Changeset 16d748ee in mainline for uspace/srv/taskman/main.c

Timestamp:

2020-01-05T03:04:38Z (13 months ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

66b1075

Parents:

2f04bdd

git-author:

Matthieu Riolo <matthieu.riolo@…> (2019-11-30 20:47:26)

git-committer:

Matthieu Riolo <matthieu.riolo@…> (2020-01-05 03:04:38)

Message:

Removing implicit handler from async/server and taskman.
Correcting taskman methods and it's fallback handler
Simplifying connecting to taskman

File:

• uspace/srv/taskman/main.c (modified) (6 diffs)

uspace/srv/taskman/main.c

@@ -36 +36 @@
  * @{
  */
-
+#include <abi/ipc/methods.h>
 #include <adt/prodcons.h>
 #include <assert.h>
@@ -124 +124 @@
         async_exchange_end(exch);
 
-        if (rc != EOK) {
-                async_answer_0(icall, rc);
-                return;
-        }
+        if (rc != EOK)
+                async_answer_0(icall, rc);
 }
 
@@ -133 +131 @@
 {
         errno_t rc = task_intro(icall->task_id);
-        async_answer_0(icall, rc);
+        if (rc == EOK) {
+                async_accept_0(icall);
+        } else {
+                async_answer_0(icall, rc);
+        }
 }
 
@@ -158 +160 @@
 finish:
         fibril_mutex_unlock(&session_ns_mtx);
-        async_answer_0(icall, rc);
+
+        if (rc == EOK) {
+                async_accept_0(icall);
+        } else {
+                async_answer_0(icall, rc);
+        }
 }
 
@@ -240 +247 @@
 }
 
-static bool handle_call(ipc_call_t *icall)
-{
-        switch (ipc_get_imethod(icall)) {
-        case TASKMAN_NEW_TASK:
-                taskman_new_task(icall);
-                break;
-        case TASKMAN_I_AM_NS:
-                taskman_i_am_ns(icall);
-                break;
-        case TASKMAN_WAIT:
-                taskman_ctl_wait(icall);
-                break;
-        case TASKMAN_RETVAL:
-                taskman_ctl_retval(icall);
-                break;
-        case TASKMAN_EVENT_CALLBACK:
-                taskman_ctl_ev_callback(icall);
-                break;
-        default:
-                return false;
-        }
-        return true;
-}
-
-static bool handle_implicit_call(ipc_call_t *icall)
-{
-        if (ipc_get_imethod(icall) < IPC_FIRST_USER_METHOD) {
-                switch (ipc_get_arg1(icall)) {
+static void taskman_connection(ipc_call_t *icall, void *arg)
+{
+        /* handle new incoming calls */
+        if (ipc_get_imethod(icall) == IPC_M_CONNECT_ME_TO) {
+                switch (ipc_get_arg2(icall)) {
+                case TASKMAN_NEW_TASK:
+                        taskman_new_task(icall);
+                        break;
                 case TASKMAN_CONNECT_TO_NS:
                         connect_to_ns(icall);
-                        break;
+                        return;
                 case TASKMAN_CONNECT_TO_LOADER:
                         connect_to_loader(icall);
-                        break;
+                        return;
+                default:
+                        async_answer_0(icall, ENOTSUP);
+                        return;
+                }
+        } else if (ipc_get_imethod(icall) == IPC_M_CONNECT_TO_ME) {
+                switch (ipc_get_arg2(icall)) {
                 case TASKMAN_LOADER_CALLBACK:
                         loader_callback(icall);
-                        break;
+                        return;
                 default:
-                        return false;
-
+                        async_answer_0(icall, ENOTSUP);
+                        return;
                 }
-        } else {
-                return handle_call(icall);
-        }
-
-        return true;
-}
-
-static void implicit_connection(ipc_call_t *icall, void *arg)
-{
-        if (!handle_implicit_call(icall)) {
-                async_answer_0(icall, ENOTSUP);
-                return;
-        }
-
+        }
+
+        /* handle accepted calls */
         while (true) {
                 ipc_call_t call;
 
-                if (!async_get_call(&call) || !ipc_get_imethod(&call)) {
+                if (!async_get_call(&call)) {
                         /* Client disconnected */
-                        break;
+                        return;
                 }
 
-                if (!handle_implicit_call(&call)) {
-                        async_answer_0(icall, ENOTSUP);
-                        break;
+                switch (ipc_get_imethod(&call)) {
+                case TASKMAN_I_AM_NS:
+                        taskman_i_am_ns(&call);
+                        break;
+                case TASKMAN_WAIT:
+                        taskman_ctl_wait(&call);
+                        break;
+                case TASKMAN_RETVAL:
+                        taskman_ctl_retval(&call);
+                        break;
+                case TASKMAN_EVENT_CALLBACK:
+                        taskman_ctl_ev_callback(&call);
+                        break;
+                default:
+                        async_answer_0(&call, ENOTSUP);
                 }
-        }
-}
-
-static void taskman_connection(ipc_call_t *icall, void *arg)
-{
-        /*
-         * We don't expect (yet) clients to connect, having this function is
-         * just to adapt to async framework that creates new connection for
-         * each IPC_M_CONNECT_ME_TO.
-         * In this case those are to be forwarded, so don't continue
-         * "listening" on such connections.
-         */
-        if (!handle_implicit_call(icall)) {
-                /* If cannot handle connection request, give up trying */
-                async_answer_0(icall, EHANGUP);
-                return;
         }
 }
@@ -360 +338 @@
 
         /* Start sysman server */
-        async_set_implicit_connection(implicit_connection);
         async_set_fallback_port_handler(taskman_connection, NULL);