Changeset 16d748ee in mainline

Timestamp:

2020-01-05T03:04:38Z (5 years 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

Location:

uspace

Files:

• lib/c/generic/async/client.c (modified) (2 diffs)
• lib/c/generic/async/server.c (modified) (3 diffs)
• lib/c/generic/taskman.c (modified) (2 diffs)
• lib/c/include/ipc/taskman.h (modified) (2 diffs)
• srv/taskman/main.c (modified) (6 diffs)

uspace/lib/c/generic/async/client.c

@@ -857 +857 @@
         if (sess == NULL) {
                 ipc_hangup(phone);
-        }else {
+        } else {
                 sess->iface = iface;
         }
@@ -915 +915 @@
         if (sess == NULL) {
                 ipc_hangup(phone);
-        }else {
+        } else {
                 sess->iface = iface;
         }

uspace/lib/c/generic/async/server.c

@@ -216 +216 @@
 }
 
-static async_port_handler_t implicit_connection = NULL;
-
-/** Setter for implicit_connection function pointer.
- *
- * @param conn Function that will implement a new connection fibril for
- *             unrouted calls.
- *
- */
-void async_set_implicit_connection(async_port_handler_t conn)
-{
-        assert(implicit_connection == NULL);
-        implicit_connection = conn;
-}
-
 static fibril_rmutex_t client_mutex;
 static hash_table_t client_hash_table;
@@ -407 +393 @@
  *                    either a callback connection that was opened by
  *                    accepting the IPC_M_CONNECT_TO_ME call.
- *                    Alternatively, it is zero when we are opening
- *                    implicit connection.
  * @param handler     Connection handler.
  * @param data        Client argument to pass to the connection handler.
@@ -979 +963 @@
         /* Route the call according to its request label */
         errno_t rc = route_call(call);
-        if (rc == EOK) {
+        if (rc == EOK)
                 return;
-        } else if (implicit_connection != NULL) {
-                connection_t *conn = calloc(1, sizeof(connection_t));
-                if (!conn) {
-                        ipc_answer_0(call->cap_handle, ENOMEM);
-                        return;
-                }
-
-                async_new_connection(conn, call->task_id, call, implicit_connection, NULL);
-                return;
-        }
 
         // TODO: Log the error.
-
         if (call->cap_handle != CAP_NIL)
                 /* Unknown call from unknown phone - hang it up */

uspace/lib/c/generic/taskman.c

@@ -69 +69 @@
         async_exchange_end(exch);
 }
-#include <stdio.h>
+
 /** Wrap PHONE_INITIAL with session and introduce to taskman
  */
@@ -85 +85 @@
                 /* Introduce ourselves and ignore answer */
                 async_exch_t *exch = async_exchange_begin(sess);
-                aid_t req = async_send_0(exch, TASKMAN_NEW_TASK, NULL);
+                sess = async_connect_me_to(exch, INTERFACE_ANY,
+                    TASKMAN_NEW_TASK, 0);
                 async_exchange_end(exch);
-
-                if (req) {
-                        async_forget(req);
-                }
         }
 

uspace/lib/c/include/ipc/taskman.h

@@ -43 +43 @@
         TASKMAN_EVENT_CALLBACK,
         TASKMAN_NEW_TASK,
-        TASKMAN_I_AM_NS
+        TASKMAN_I_AM_NS,
+
+        TASKMAN_CONNECT_TO_NS,
+        TASKMAN_CONNECT_TO_LOADER,
+        TASKMAN_LOADER_CALLBACK
 } taskman_request_t;
 
@@ -50 +54 @@
 } taskman_event_t;
 
-typedef enum {
-        TASKMAN_CONNECT_TO_NS = 0,
-        TASKMAN_CONNECT_TO_LOADER,
-        TASKMAN_LOADER_CALLBACK
-} taskman_connect_t;
-
 #endif
 

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);