Changes in uspace/lib/c/generic/async.c [649f087:36e2b55] in mainline

File:

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

uspace/lib/c/generic/async.c

@@ -98 +98 @@
 #include <ipc/ipc.h>
 #include <async.h>
+#include "private/async.h"
 #undef LIBC_ASYNC_C_
 
@@ -113 +114 @@
 #include <stdlib.h>
 #include <macros.h>
-#include "private/async.h"
 
 #define CLIENT_HASH_TABLE_BUCKETS  32
@@ -996 +996 @@
         session_ns->arg3 = 0;
         
+        fibril_mutex_initialize(&session_ns->remote_state_mtx);
+        session_ns->remote_state_data = NULL;
+        
         list_initialize(&session_ns->exch_list);
         fibril_mutex_initialize(&session_ns->mutex);
@@ -1472 +1475 @@
                 return ENOENT;
         
-        task_id_t task_id;
-        sysarg_t task_id_lo;
-        sysarg_t task_id_hi;
         sysarg_t phone_hash;
-        int rc = async_req_3_5(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
-            NULL, NULL, &task_id_lo, &task_id_hi, &phone_hash);
+        sysarg_t rc;
+
+        aid_t req;
+        ipc_call_t answer;
+        req = async_send_3(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
+            &answer);
+        async_wait_for(req, &rc);
         if (rc != EOK)
-                return rc;
-
-        task_id = (task_id_t) MERGE_LOUP32(task_id_lo, task_id_hi);
-        
+                return (int) rc;
+
+        phone_hash = IPC_GET_ARG5(answer);
+
         if (client_receiver != NULL)
-                async_new_connection(task_id, phone_hash, 0, NULL,
+                async_new_connection(answer.in_task_id, phone_hash, 0, NULL,
                     client_receiver, carg);
         
@@ -1559 +1564 @@
         sess->arg3 = 0;
         
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        
         list_initialize(&sess->exch_list);
         fibril_mutex_initialize(&sess->mutex);
@@ -1640 +1648 @@
         sess->arg3 = arg3;
         
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        
         list_initialize(&sess->exch_list);
         fibril_mutex_initialize(&sess->mutex);
@@ -1645 +1656 @@
         
         return sess;
+}
+
+/** Set arguments for new connections.
+ *
+ * FIXME This is an ugly hack to work around the problem that parallel
+ * exchanges are implemented using parallel connections. When we create
+ * a callback session, the framework does not know arguments for the new
+ * connections.
+ *
+ * The proper solution seems to be to implement parallel exchanges using
+ * tagging.
+ */
+void async_sess_args_set(async_sess_t *sess, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3)
+{
+        sess->arg1 = arg1;
+        sess->arg2 = arg2;
+        sess->arg3 = arg3;
 }
 
@@ -1690 +1719 @@
         sess->arg3 = arg3;
         
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        
         list_initialize(&sess->exch_list);
         fibril_mutex_initialize(&sess->mutex);
@@ -1721 +1753 @@
         sess->arg3 = 0;
         
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        
         list_initialize(&sess->exch_list);
         fibril_mutex_initialize(&sess->mutex);
@@ -1742 +1777 @@
 int async_hangup(async_sess_t *sess)
 {
+        async_exch_t *exch;
+        
         assert(sess);
         
         if (atomic_get(&sess->refcnt) > 0)
                 return EBUSY;
+        
+        fibril_mutex_lock(&async_sess_mutex);
         
         int rc = async_hangup_internal(sess->phone);
         if (rc == EOK)
                 free(sess);
+        
+        while (!list_empty(&sess->exch_list)) {
+                exch = (async_exch_t *)
+                    list_get_instance(list_first(&sess->exch_list),
+                    async_exch_t, sess_link);
+                
+                list_remove(&exch->sess_link);
+                list_remove(&exch->global_link);
+                async_hangup_internal(exch->phone);
+                free(exch);
+        }
+        
+        fibril_mutex_unlock(&async_sess_mutex);
         
         return rc;
@@ -2384 +2436 @@
         sess->arg3 = 0;
         
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        
         list_initialize(&sess->exch_list);
         fibril_mutex_initialize(&sess->mutex);
@@ -2430 +2485 @@
         sess->arg3 = 0;
         
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        
         list_initialize(&sess->exch_list);
         fibril_mutex_initialize(&sess->mutex);
@@ -2471 +2529 @@
         sess->arg2 = 0;
         sess->arg3 = 0;
+        
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
         
         list_initialize(&sess->exch_list);
@@ -2512 +2573 @@
 }
 
+/** Lock and get session remote state
+ *
+ * Lock and get the local replica of the remote state
+ * in stateful sessions. The call should be paired
+ * with async_remote_state_release*().
+ *
+ * @param[in] sess Stateful session.
+ *
+ * @return Local replica of the remote state.
+ *
+ */
+void *async_remote_state_acquire(async_sess_t *sess)
+{
+        fibril_mutex_lock(&sess->remote_state_mtx);
+        return sess->remote_state_data;
+}
+
+/** Update the session remote state
+ *
+ * Update the local replica of the remote state
+ * in stateful sessions. The remote state must
+ * be already locked.
+ *
+ * @param[in] sess  Stateful session.
+ * @param[in] state New local replica of the remote state.
+ *
+ */
+void async_remote_state_update(async_sess_t *sess, void *state)
+{
+        assert(fibril_mutex_is_locked(&sess->remote_state_mtx));
+        sess->remote_state_data = state;
+}
+
+/** Release the session remote state
+ *
+ * Unlock the local replica of the remote state
+ * in stateful sessions.
+ *
+ * @param[in] sess Stateful session.
+ *
+ */
+void async_remote_state_release(async_sess_t *sess)
+{
+        assert(fibril_mutex_is_locked(&sess->remote_state_mtx));
+        
+        fibril_mutex_unlock(&sess->remote_state_mtx);
+}
+
+/** Release the session remote state and end an exchange
+ *
+ * Unlock the local replica of the remote state
+ * in stateful sessions. This is convenience function
+ * which gets the session pointer from the exchange
+ * and also ends the exchange.
+ *
+ * @param[in] exch Stateful session's exchange.
+ *
+ */
+void async_remote_state_release_exchange(async_exch_t *exch)
+{
+        if (exch == NULL)
+                return;
+        
+        async_sess_t *sess = exch->sess;
+        assert(fibril_mutex_is_locked(&sess->remote_state_mtx));
+        
+        async_exchange_end(exch);
+        fibril_mutex_unlock(&sess->remote_state_mtx);
+}
+
 /** @}
  */