Changeset bc1f1c2 in mainline for uspace/lib/libc/generic/async.c

Timestamp:

2007-06-28T00:54:12Z (17 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

12f91130

Parents:

b9641ee

Message:

Goodbye pseudo threads, welcome fibrils.
The renaming might still be incomplete.

File:

• uspace/lib/libc/generic/async.c (modified) (29 diffs)

uspace/lib/libc/generic/async.c

@@ -86 +86 @@
  * }
  *
- * TODO: Detaching/joining dead psthreads?
  */
 #include <futex.h>
 #include <async.h>
-#include <psthread.h>
+#include <fibril.h>
 #include <stdio.h>
 #include <libadt/hash_table.h>
@@ -105 +104 @@
 
 typedef struct {
-        struct timeval expires;         /**< Expiration time for waiting thread */
-        int inlist;                     /**< If true, this struct is in timeout list */
+        /** Expiration time for waiting fibril. */
+        struct timeval expires;         
+        /** If true, this struct is in the timeout list. */
+        int inlist;
         link_t link;
 
-        pstid_t ptid;                   /**< Thread waiting for this message */
-        int active;                     /**< If this thread is currently active */
-        int timedout;                   /**< If true, we timed out */
+        /** Fibril waiting for this message. */
+        fid_t fid;
+        /** If this fibril is currently active. */
+        int active;
+        /** If true, we timed out. */
+        int timedout;
 } awaiter_t;
 
@@ -119 +123 @@
         int done;                       /**< If reply was received */
         ipc_call_t *dataptr;            /**< Pointer where the answer data
-                                          *   is stored */
+                                         *   is stored */
         ipcarg_t retval;
 } amsg_t;
@@ -132 +136 @@
         awaiter_t wdata;
 
-        link_t link;                    /**< Hash table link */
+        link_t link;                    /**< Hash table link. */
         ipcarg_t in_phone_hash;         /**< Incoming phone hash. */
-        link_t msg_queue;               /**< Messages that should be delivered to this thread */
+        link_t msg_queue;               /**< Messages that should be delivered
+                                         *   to this fibril. */
         /* Structures for connection opening packet */
         ipc_callid_t callid;
         ipc_call_t call;
-        ipc_callid_t close_callid;      /* Identification of closing packet */
-        void (*cthread)(ipc_callid_t,ipc_call_t *);
+        ipc_callid_t close_callid;      /* Identification of closing packet. */
+        void (*cfibril)(ipc_callid_t, ipc_call_t *);
 } connection_t;
 
-/** Identifier of incoming connection handled by current thread */
-__thread connection_t *PS_connection;
+/** Identifier of the incoming connection handled by the current fibril. */
+__thread connection_t *FIBRIL_connection;
 /** If true, it is forbidden to use async_req functions and
  *  all preemption is disabled */
@@ -286 +291 @@
                 }
                 conn->wdata.active = 1;
-                psthread_add_ready(conn->wdata.ptid);
+                fibril_add_ready(conn->wdata.fid);
         }
 
@@ -301 +306 @@
         connection_t *conn;
         
-        assert(PS_connection);
-        /* GCC 4.1.0 coughs on PS_connection-> dereference,
+        assert(FIBRIL_connection);
+        /* GCC 4.1.0 coughs on FIBRIL_connection-> dereference,
          * GCC 4.1.1 happilly puts the rdhwr instruction in delay slot.
          *           I would never expect to find so many errors in 
          *           compiler *($&$(*&$
          */
-        conn = PS_connection; 
+        conn = FIBRIL_connection; 
 
         futex_down(&async_futex);
@@ -323 +328 @@
 
                 conn->wdata.active = 0;
-                psthread_schedule_next_adv(PS_TO_MANAGER);
+                fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
                 /* Futex is up after getting back from async_manager 
                  * get it again */
                 futex_down(&async_futex);
-                if (usecs && conn->wdata.timedout && \
+                if (usecs && conn->wdata.timedout &&
                     list_empty(&conn->msg_queue)) {
                         /* If we timed out-> exit */
@@ -365 +370 @@
  * @param arg Connection structure pointer
  */
-static int connection_thread(void  *arg)
+static int connection_fibril(void  *arg)
 {
         unsigned long key;
@@ -372 +377 @@
 
         /* Setup thread local connection pointer */
-        PS_connection = (connection_t *)arg;
-        PS_connection->cthread(PS_connection->callid, &PS_connection->call);
+        FIBRIL_connection = (connection_t *) arg;
+        FIBRIL_connection->cfibril(FIBRIL_connection->callid,
+            &FIBRIL_connection->call);
         
         /* Remove myself from connection hash table */
         futex_down(&async_futex);
-        key = PS_connection->in_phone_hash;
+        key = FIBRIL_connection->in_phone_hash;
         hash_table_remove(&conn_hash_table, &key, 1);
         futex_up(&async_futex);
         
         /* Answer all remaining messages with ehangup */
-        while (!list_empty(&PS_connection->msg_queue)) {
-                msg = list_get_instance(PS_connection->msg_queue.next, msg_t, link);
+        while (!list_empty(&FIBRIL_connection->msg_queue)) {
+                msg = list_get_instance(FIBRIL_connection->msg_queue.next,
+                    msg_t, link);
                 list_remove(&msg->link);
-                if (msg->callid == PS_connection->close_callid)
+                if (msg->callid == FIBRIL_connection->close_callid)
                         close_answered = 1;
                 ipc_answer_fast(msg->callid, EHANGUP, 0, 0);
                 free(msg);
         }
-        if (PS_connection->close_callid)
-                ipc_answer_fast(PS_connection->close_callid, 0, 0, 0);
+        if (FIBRIL_connection->close_callid)
+                ipc_answer_fast(FIBRIL_connection->close_callid, 0, 0, 0);
         
         return 0;
@@ -406 +413 @@
  * @param callid Callid of the IPC_M_CONNECT_ME_TO packet
  * @param call Call data of the opening packet
- * @param cthread Thread function that should be called upon
+ * @param cfibril Fibril function that should be called upon
  *                opening the connection
- * @return New thread id
- */
-pstid_t async_new_connection(ipcarg_t in_phone_hash,ipc_callid_t callid, ipc_call_t *call, void (*cthread)(ipc_callid_t, ipc_call_t *))
+ * @return New fibril id.
+ */
+fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
+    ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *))
 {
         connection_t *conn;
@@ -427 +435 @@
                 conn->call = *call;
         conn->wdata.active = 1; /* We will activate it asap */
-        conn->cthread = cthread;
-
-        conn->wdata.ptid = psthread_create(connection_thread, conn);
-        if (!conn->wdata.ptid) {
+        conn->cfibril = cfibril;
+
+        conn->wdata.fid = fibril_create(connection_fibril, conn);
+        if (!conn->wdata.fid) {
                 free(conn);
                 ipc_answer_fast(callid, ENOMEM, 0, 0);
@@ -441 +449 @@
         futex_up(&async_futex);
 
-        psthread_add_ready(conn->wdata.ptid);
-
-        return conn->wdata.ptid;
+        fibril_add_ready(conn->wdata.fid);
+
+        return conn->wdata.fid;
 }
 
@@ -460 +468 @@
         case IPC_M_CONNECT_ME_TO:
                 /* Open new connection with thread etc. */
-                async_new_connection(IPC_GET_ARG3(*call), callid, call, client_connection);
+                async_new_connection(IPC_GET_ARG3(*call), callid, call,
+                    client_connection);
                 return;
         }
@@ -486 +495 @@
         cur = timeout_list.next;
         while (cur != &timeout_list) {
-                waiter = list_get_instance(cur,awaiter_t,link);
+                waiter = list_get_instance(cur, awaiter_t, link);
                 if (tv_gt(&waiter->expires, &tv))
                         break;
@@ -498 +507 @@
                 if (!waiter->active) {
                         waiter->active = 1;
-                        psthread_add_ready(waiter->ptid);
+                        fibril_add_ready(waiter->fid);
                 }
         }
@@ -515 +524 @@
 
         while (1) {
-                if (psthread_schedule_next_adv(PS_FROM_MANAGER)) {
+                if (fibril_schedule_next_adv(FIBRIL_FROM_MANAGER)) {
                         futex_up(&async_futex); 
                         /* async_futex is always held
@@ -524 +533 @@
                 futex_down(&async_futex);
                 if (!list_empty(&timeout_list)) {
-                        waiter = list_get_instance(timeout_list.next,awaiter_t,link);
-                        gettimeofday(&tv,NULL);
+                        waiter = list_get_instance(timeout_list.next, awaiter_t,
+                            link);
+                        gettimeofday(&tv, NULL);
                         if (tv_gteq(&tv, &waiter->expires)) {
                                 futex_up(&async_futex);
@@ -573 +583 @@
 void async_create_manager(void)
 {
-        pstid_t ptid;
-
-        ptid = psthread_create(async_manager_thread, NULL);
-        psthread_add_manager(ptid);
+        fid_t fid;
+
+        fid = fibril_create(async_manager_thread, NULL);
+        fibril_add_manager(fid);
 }
 
@@ -582 +592 @@
 void async_destroy_manager(void)
 {
-        psthread_remove_manager();
+        fibril_remove_manager();
 }
 
@@ -588 +598 @@
 int _async_init(void)
 {
-        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1, &conn_hash_table_ops)) {
+        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1,
+            &conn_hash_table_ops)) {
                 printf("%s: cannot create hash table\n", "async");
                 return ENOMEM;
@@ -598 +609 @@
 /** IPC handler for messages in async framework
  *
- * Notify thread that is waiting for this message, that it arrived
+ * Notify the fibril which is waiting for this message, that it arrived
  */
 static void reply_received(void *private, int retval,
@@ -621 +632 @@
         if (! msg->wdata.active) {
                 msg->wdata.active = 1;
-                psthread_add_ready(msg->wdata.ptid);
+                fibril_add_ready(msg->wdata.fid);
         }
         futex_up(&async_futex);
@@ -633 +644 @@
 aid_t async_send_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
                    ipc_call_t *dataptr)
+{
+        amsg_t *msg;
+
+        if (in_interrupt_handler) {
+                printf("Cannot send asynchronous request in interrupt "
+                    "handler.\n");
+                _exit(1);
+        }
+
+        msg = malloc(sizeof(*msg));
+        msg->done = 0;
+        msg->dataptr = dataptr;
+
+        msg->wdata.active = 1; /* We may sleep in next method, but it
+                                * will use it's own mechanism */
+        ipc_call_async_2(phoneid, method, arg1, arg2, msg, reply_received, 1);
+
+        return (aid_t) msg;
+}
+
+/** Send message and return id of the sent message
+ *
+ * The return value can be used as input for async_wait() to wait
+ * for completion.
+ */
+aid_t async_send_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
+                   ipcarg_t arg3, ipc_call_t *dataptr)
 {
         amsg_t *msg;
@@ -647 +685 @@
         msg->wdata.active = 1; /* We may sleep in next method, but it
                                 * will use it's own mechanism */
-        ipc_call_async_2(phoneid,method,arg1,arg2,msg,reply_received,1);
-
-        return (aid_t) msg;
-}
-
-/** Send message and return id of the sent message
- *
- * The return value can be used as input for async_wait() to wait
- * for completion.
- */
-aid_t async_send_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
-                   ipcarg_t arg3, ipc_call_t *dataptr)
-{
-        amsg_t *msg;
-
-        if (in_interrupt_handler) {
-                printf("Cannot send asynchronous request in interrupt handler.\n");
-                _exit(1);
-        }
-
-        msg = malloc(sizeof(*msg));
-        msg->done = 0;
-        msg->dataptr = dataptr;
-
-        msg->wdata.active = 1; /* We may sleep in next method, but it
-                                * will use it's own mechanism */
-        ipc_call_async_3(phoneid,method,arg1,arg2,arg3, msg,reply_received,1);
+        ipc_call_async_3(phoneid, method, arg1, arg2, arg3, msg, reply_received,
+            1);
 
         return (aid_t) msg;
@@ -695 +708 @@
         }
 
-        msg->wdata.ptid = psthread_get_id();
+        msg->wdata.fid = fibril_get_id();
         msg->wdata.active = 0;
         msg->wdata.inlist = 0;
         /* Leave locked async_futex when entering this function */
-        psthread_schedule_next_adv(PS_TO_MANAGER);
-        /* futex is up automatically after psthread_schedule_next...*/
+        fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
+        /* futex is up automatically after fibril_schedule_next...*/
 done:
         if (retval)
@@ -733 +746 @@
         tv_add(&msg->wdata.expires, timeout);
 
-        msg->wdata.ptid = psthread_get_id();
+        msg->wdata.fid = fibril_get_id();
         msg->wdata.active = 0;
         insert_timeout(&msg->wdata);
 
         /* Leave locked async_futex when entering this function */
-        psthread_schedule_next_adv(PS_TO_MANAGER);
-        /* futex is up automatically after psthread_schedule_next...*/
+        fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
+        /* futex is up automatically after fibril_schedule_next...*/
 
         if (!msg->done)
@@ -769 +782 @@
                 return;
 
-        msg->wdata.ptid = psthread_get_id();
+        msg->wdata.fid = fibril_get_id();
         msg->wdata.active = 0;
 
@@ -778 +791 @@
         insert_timeout(&msg->wdata);
         /* Leave locked async_futex when entering this function */
-        psthread_schedule_next_adv(PS_TO_MANAGER);
-        /* futex is up automatically after psthread_schedule_next...*/
+        fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
+        /* futex is up automatically after fibril_schedule_next...*/
         free(msg);
 }
@@ -800 +813 @@
                  ipcarg_t arg2, ipcarg_t arg3)
 {
-        ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL, !in_interrupt_handler);
+        ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL,
+            !in_interrupt_handler);
 }
 
 void async_msg_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2)
 {
-        ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL, !in_interrupt_handler);
+        ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL,
+            !in_interrupt_handler);
 }