WebSVN – HelenOS – Diff – /branches/dd/uspace/lib/libc/generic/async.c

 #include <futex.h>
 #include <async.h>
 #include <fibril.h>
 #include <stdio.h>
-#include <libadt/hash_table.h>
+#include <adt/hash_table.h>
-#include <libadt/list.h>
+#include <adt/list.h>
 #include <ipc/ipc.h>
 #include <assert.h>
 #include <errno.h>
 #include <sys/time.h>
 #include <arch/barrier.h>
     /** Fibril function that will be used to handle the connection. */
     void (*cfibril)(ipc_callid_t, ipc_call_t *);
 } connection_t;
 /** Identifier of the incoming connection handled by the current fibril. */
-__thread connection_t *FIBRIL_connection;
+fibril_local connection_t *FIBRIL_connection;
 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 void default_pending(void);
 /**
  * Pointer to a fibril function that will be used to handle connections.
  */
 static async_client_conn_t client_connection = default_client_connection;
  * Pointer to a fibril function that will be used to handle interrupt
  * notifications.
  */
 static async_client_conn_t interrupt_received = default_interrupt_received;
+/**
+ * Pointer to a fibril function that will be used to handle pending
+ * operations.
+ */
+static async_pending_t pending = default_pending;
 static hash_table_t conn_hash_table;
 static LIST_INITIALIZE(timeout_list);
 #define CONN_HASH_TABLE_CHAINS  32
 /** Compute hash into the connection hash table based on the source phone hash.
+ *
  * @param key Pointer to source phone hash.
     futex_up(&async_futex);
     return true;
+}
+/** Pending fibril.
+ *
+ * After each call the pending operations are executed in a separate
+ * fibril. The function pending() is c.
+ *
+ * @param arg Unused.
+ *
+ * @return Always zero.
+ *
+ */
+static int pending_fibril(void *arg)
+{
+    pending();
+    return 0;
+}
+/** Process pending actions.
+ *
+ * A new fibril is created which would process the pending operations.
+ *
+ * @return False if an error occured.
+ *         True if the execution was passed to the pending fibril.
+ *
+ */
+static bool process_pending(void)
+{
+    futex_down(&async_futex);
+    fid_t fid = fibril_create(pending_fibril, NULL);
+    fibril_add_ready(fid);
+    futex_up(&async_futex);
+    return true;
+}
 /** Return new incoming message for the current (fibril-local) connection.
+ *
  * @param call  Storage where the incoming call data will be stored.
  * @param usecs Timeout in microseconds. Zero denotes no timeout.
+ *
  */
 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)
+{
+}
+/** Default fibril function that gets called to handle pending operations.
+ *
+ * This function is defined as a weak symbol - to be redefined in user code.
+ *
+ */
+static void default_pending(void)
+{
+}
 /** Wrapper for client connection fibril.
+ *
  * When a new connection arrives, a fibril with this implementing function is
  * created. It calls client_connection() and does the final cleanup.
+ *
     hash_table_remove(&conn_hash_table, &key, 1);
     futex_up(&async_futex);
     /* Answer all remaining messages with EHANGUP */
     while (!list_empty(&FIBRIL_connection->msg_queue)) {
-        msg_t *msg
+        msg_t *msg;
-            = list_get_instance(FIBRIL_connection->msg_queue.next, msg_t, link);
+        msg = list_get_instance(FIBRIL_connection->msg_queue.next,
+            msg_t, link);
         list_remove(&msg->link);
         ipc_answer_0(msg->callid, EHANGUP);
         free(msg);
+    }
             ipc_answer_0(callid, ENOMEM);
         return NULL;
+    }
     /* Add connection to the connection hash table */
-    ipcarg_t key = conn->in_phone_hash;
+    unsigned long key = conn->in_phone_hash;
     futex_down(&async_futex);
     hash_table_insert(&conn_hash_table, &key, &conn->link);
     futex_up(&async_futex);
 static void handle_call(ipc_callid_t callid, ipc_call_t *call)
+{
     /* Unrouted call - do some default behaviour */
     if ((callid & IPC_CALLID_NOTIFICATION)) {
         process_notification(callid, call);
-        return;
+        goto out;
+    }
     switch (IPC_GET_METHOD(*call)) {
     case IPC_M_CONNECT_ME:
     case IPC_M_CONNECT_ME_TO:
         /* Open new connection with fibril etc. */
         async_new_connection(IPC_GET_ARG5(*call), callid, call,
             client_connection);
-        return;
+        goto out;
+    }
     /* Try to route the call through the connection hash table */
     if (route_call(callid, call))
-        return;
+        goto out;
     /* Unknown call from unknown phone - hang it up */
     ipc_answer_0(callid, EHANGUP);
+    return;
+out:
+    process_pending();
+}
 /** Fire all timeouts that expired. */
 static void handle_expired_timeouts(void)
+{
         futex_down(&async_futex);
         suseconds_t timeout;
         if (!list_empty(&timeout_list)) {
-            awaiter_t *waiter
+            awaiter_t *waiter = list_get_instance(timeout_list.next,
-                = list_get_instance(timeout_list.next, awaiter_t, link);
+                awaiter_t, link);
             struct timeval tv;
             gettimeofday(&tv, NULL);
             if (tv_gteq(&tv, &waiter->expires)) {
             timeout = SYNCH_NO_TIMEOUT;
         futex_up(&async_futex);
         ipc_call_t call;
-        ipc_callid_t callid
+        ipc_callid_t callid = ipc_wait_cycle(&call, timeout,
-            = ipc_wait_cycle(&call, timeout, SYNCH_FLAGS_NONE);
+            SYNCH_FLAGS_NONE);
         if (!callid) {
             handle_expired_timeouts();
             continue;
+        }
  * @param retval Value returned in the answer.
  * @param data   Call data of the answer.
  */
 static void reply_received(void *arg, int retval, ipc_call_t *data)
+{
+    futex_down(&async_futex);
     amsg_t *msg = (amsg_t *) arg;
     msg->retval = retval;
-    futex_down(&async_futex);
     /* Copy data after futex_down, just in case the call was detached */
-    if (msg->dataptr)
+    if ((msg->dataptr) && (data))
         *msg->dataptr = *data;
     write_barrier();
     /* Remove message from timeout list */
 void async_set_interrupt_received(async_client_conn_t intr)
+{
     interrupt_received = intr;
+}
+/** Setter for pending function pointer.
+ *
+ * @param pend Function that will implement a new pending
+ *             operations fibril.
+ */
+void async_set_pending(async_pending_t pend)
+{
+    pending = pend;
+}
 /** Pseudo-synchronous message sending - fast version.
+ *
  * Send message asynchronously and return only after the reply arrives.
+ *
  * This function can only transfer 4 register payload arguments. For

Subversion Repositories HelenOS

(root)/branches/dd/uspace/lib/libc/generic/async.c – Rev 4420 → 4537