WebSVN – HelenOS-historic – Diff – //uspace/trunk/libc/generic/async.c

     ipc_callid_t callid;
     ipc_call_t call;
     void (*cthread)(ipc_callid_t,ipc_call_t *);
 } connection_t;
+/** Identifier of incoming connection handled by current thread */
 __thread connection_t *PS_connection;
+/** If true, it is forbidden to use async_req functions and
+ *  all preemption is disabled */
+__thread int in_interrupt_handler;
 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call);
 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call);
 static async_client_conn_t client_connection = default_client_connection;
 static async_client_conn_t interrupt_received = default_interrupt_received;
+{
     link_t *tmp;
     awaiter_t *cur;
     wd->timedout = 0;
+    wd->inlist = 1;
     tmp = timeout_list.next;
     while (tmp != &timeout_list) {
         cur = list_get_instance(tmp, awaiter_t, link);
         if (tv_gteq(&cur->expires, &wd->expires))
      *           I would never expect to find so many errors in
      *           compiler *($&$(*&$
      */
     conn = PS_connection;
-    if (usecs < 0) /* TODO: let it get through the ipc_call once */
-        return 0;
     futex_down(&async_futex);
     if (usecs) {
         gettimeofday(&conn->wdata.expires, NULL);
         tv_add(&conn->wdata.expires, usecs);
     } else {
         conn->wdata.inlist = 0;
+    }
     /* If nothing in queue, wait until something appears */
     while (list_empty(&conn->msg_queue)) {
-        if (usecs) {
+        if (usecs)
-            conn->wdata.inlist = 1;
             insert_timeout(&conn->wdata);
-        }
         conn->wdata.active = 0;
         psthread_schedule_next_adv(PS_TO_MANAGER);
         /* Futex is up after getting back from async_manager
          * get it again */
         futex_down(&async_futex);
     msg_t *msg;
     /* Setup thread local connection pointer */
     PS_connection = (connection_t *)arg;
     PS_connection->cthread(PS_connection->callid, &PS_connection->call);
     /* Remove myself from connection hash table */
     futex_down(&async_futex);
     key = PS_connection->in_phone_hash;
     hash_table_remove(&conn_hash_table, &key, 1);
     futex_up(&async_futex);
 static void handle_call(ipc_callid_t callid, ipc_call_t *call)
+{
     /* Unrouted call - do some default behaviour */
     switch (IPC_GET_METHOD(*call)) {
     case IPC_M_INTERRUPT:
+        in_interrupt_handler = 1;
         (*interrupt_received)(callid,call);
+        in_interrupt_handler = 0;
         return;
     case IPC_M_CONNECT_ME_TO:
         /* Open new connection with thread etc. */
         async_new_connection(IPC_GET_ARG3(*call), callid, call, client_connection);
         return;
     futex_up(&async_futex);
+}
 /** Endless loop dispatching incoming calls and answers */
-int async_manager(void)
+static int async_manager_worker(void)
+{
     ipc_call_t call;
     ipc_callid_t callid;
     int timeout;
     awaiter_t *waiter;
         if (!callid) {
             handle_expired_timeouts();
             continue;
+        }
-        if (callid & IPC_CALLID_ANSWERED)
+        if (callid & IPC_CALLID_ANSWERED) {
             continue;
+        }
         handle_call(callid, &call);
+    }
+}
  * currently one async_manager is started automatically per kernel
  * thread except main thread.
  */
 static int async_manager_thread(void *arg)
+{
+    in_interrupt_handler = 0; // TODO: Handle TLS better
     futex_up(&async_futex); /* async_futex is always locked when entering
                 * manager */
-    async_manager();
+    async_manager_worker();
+}
 /** Add one manager to manager list */
 void async_create_manager(void)
+{
 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 asynchronou 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
 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 asynchronou 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
     gettimeofday(&msg->wdata.expires, NULL);
     tv_add(&msg->wdata.expires, timeout);
     msg->wdata.ptid = psthread_get_id();
     msg->wdata.active = 0;
-    msg->wdata.inlist = 1;
     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...*/
  */
 void async_usleep(suseconds_t timeout)
+{
     amsg_t *msg;
+    if (in_interrupt_handler) {
+        printf("Cannot call async_usleep in interrupt handler.\n");
+        _exit(1);
+    }
     msg = malloc(sizeof(*msg));
     if (!msg)
         return;
     msg->wdata.ptid = psthread_get_id();
-    msg->wdata.inlist = 1;
     msg->wdata.active = 0;
     gettimeofday(&msg->wdata.expires, NULL);
     tv_add(&msg->wdata.expires, timeout);
+}
 void async_set_interrupt_received(async_client_conn_t conn)
+{
     interrupt_received = conn;
+}
+/* Primitive functions for simple communication */
+void async_msg_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
+         ipcarg_t arg2, ipcarg_t arg3)
+{
+    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);
+}

Subversion Repositories HelenOS-historic

(root)//uspace/trunk/libc/generic/async.c – Rev 1596 → 1610