Changes in uspace/lib/c/generic/async.c [df956b9b:1db6dfd] in mainline

File:

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

uspace/lib/c/generic/async.c

@@ -109 +109 @@
 #include <sys/time.h>
 #include <libarch/barrier.h>
-#include <stdbool.h>
+#include <bool.h>
 #include <malloc.h>
 #include <mem.h>
 #include <stdlib.h>
 #include <macros.h>
-#include "private/libc.h"
-
+
+#define CLIENT_HASH_TABLE_BUCKETS  32
+#define CONN_HASH_TABLE_BUCKETS    32
 
 /** Session data */
@@ -203 +204 @@
 /* Client connection data */
 typedef struct {
-        ht_link_t link;
+        link_t link;
         
         task_id_t in_task_id;
@@ -215 +216 @@
         
         /** Hash table link. */
-        ht_link_t link;
+        link_t link;
         
         /** Incoming client task ID. */
@@ -350 +351 @@
 static async_client_conn_t client_connection = default_client_connection;
 static async_interrupt_handler_t interrupt_received = default_interrupt_received;
-static size_t interrupt_handler_stksz = FIBRIL_DFLT_STK_SIZE;
 
 /** Setter for client_connection function pointer.
@@ -371 +371 @@
 {
         interrupt_received = intr;
-}
-
-/** Set the stack size for the interrupt handler notification fibrils.
- *
- * @param size Stack size in bytes.
- */
-void async_set_interrupt_handler_stack_size(size_t size)
-{
-        interrupt_handler_stksz = size;
 }
 
@@ -401 +392 @@
 static LIST_INITIALIZE(timeout_list);
 
-static size_t client_key_hash(void *k)
-{
-        task_id_t key = *(task_id_t*)k;
-        return key;
-}
-
-static size_t client_hash(const ht_link_t *item)
-{
-        client_t *client = hash_table_get_inst(item, client_t, link);
-        return client_key_hash(&client->in_task_id);
-}
-
-static bool client_key_equal(void *k, const ht_link_t *item)
-{
-        task_id_t key = *(task_id_t*)k;
-        client_t *client = hash_table_get_inst(item, client_t, link);
-        return key == client->in_task_id;
-}
-
+static hash_index_t client_hash(unsigned long key[])
+{
+        assert(key);
+        
+        return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS);
+}
+
+static int client_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+        assert(key);
+        assert(keys == 2);
+        assert(item);
+        
+        client_t *client = hash_table_get_instance(item, client_t, link);
+        return (key[0] == LOWER32(client->in_task_id) &&
+            (key[1] == UPPER32(client->in_task_id)));
+}
+
+static void client_remove(link_t *item)
+{
+}
 
 /** Operations for the client hash table. */
-static hash_table_ops_t client_hash_table_ops = {
+static hash_table_operations_t client_hash_table_ops = {
         .hash = client_hash,
-        .key_hash = client_key_hash,
-        .key_equal = client_key_equal,
-        .equal = NULL,
-        .remove_callback = NULL
+        .compare = client_compare,
+        .remove_callback = client_remove
 };
 
@@ -437 +428 @@
  *
  */
-static size_t conn_key_hash(void *key)
-{
-        sysarg_t in_phone_hash  = *(sysarg_t*)key;
-        return in_phone_hash ;
-}
-
-static size_t conn_hash(const ht_link_t *item)
-{
-        connection_t *conn = hash_table_get_inst(item, connection_t, link);
-        return conn_key_hash(&conn->in_phone_hash);
-}
-
-static bool conn_key_equal(void *key, const ht_link_t *item)
-{
-        sysarg_t in_phone_hash = *(sysarg_t*)key;
-        connection_t *conn = hash_table_get_inst(item, connection_t, link);
-        return (in_phone_hash == conn->in_phone_hash);
-}
-
+static hash_index_t conn_hash(unsigned long key[])
+{
+        assert(key);
+        
+        return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS);
+}
+
+/** Compare hash table item with a key.
+ *
+ * @param key  Array containing the source phone hash as the only item.
+ * @param keys Expected 1 but ignored.
+ * @param item Connection hash table item.
+ *
+ * @return True on match, false otherwise.
+ *
+ */
+static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+        assert(key);
+        assert(item);
+        
+        connection_t *conn = hash_table_get_instance(item, connection_t, link);
+        return (key[0] == conn->in_phone_hash);
+}
+
+static void conn_remove(link_t *item)
+{
+}
 
 /** Operations for the connection hash table. */
-static hash_table_ops_t conn_hash_table_ops = {
+static hash_table_operations_t conn_hash_table_ops = {
         .hash = conn_hash,
-        .key_hash = conn_key_hash,
-        .key_equal = conn_key_equal,
-        .equal = NULL,
-        .remove_callback = NULL
+        .compare = conn_compare,
+        .remove_callback = conn_remove
 };
 
@@ -511 +509 @@
         futex_down(&async_futex);
         
-        ht_link_t *hlp = hash_table_find(&conn_hash_table, &call->in_phone_hash);
+        unsigned long key = call->in_phone_hash;
+        link_t *hlp = hash_table_find(&conn_hash_table, &key);
         
         if (!hlp) {
@@ -518 +517 @@
         }
         
-        connection_t *conn = hash_table_get_inst(hlp, connection_t, link);
+        connection_t *conn = hash_table_get_instance(hlp, connection_t, link);
         
         msg_t *msg = malloc(sizeof(*msg));
@@ -597 +596 @@
         msg->call = *call;
         
-        fid_t fid = fibril_create_generic(notification_fibril, msg,
-            interrupt_handler_stksz);
+        fid_t fid = fibril_create(notification_fibril, msg);
         if (fid == 0) {
                 free(msg);
@@ -639 +637 @@
         
         if (usecs) {
-                getuptime(&conn->wdata.to_event.expires);
+                gettimeofday(&conn->wdata.to_event.expires, NULL);
                 tv_add(&conn->wdata.to_event.expires, usecs);
         } else
@@ -699 +697 @@
 static client_t *async_client_get(task_id_t client_id, bool create)
 {
+        unsigned long key[2] = {
+                LOWER32(client_id),
+                UPPER32(client_id),
+        };
         client_t *client = NULL;
 
         futex_down(&async_futex);
-        ht_link_t *lnk = hash_table_find(&client_hash_table, &client_id);
+        link_t *lnk = hash_table_find(&client_hash_table, key);
         if (lnk) {
-                client = hash_table_get_inst(lnk, client_t, link);
+                client = hash_table_get_instance(lnk, client_t, link);
                 atomic_inc(&client->refcnt);
         } else if (create) {
@@ -713 +715 @@
                 
                         atomic_set(&client->refcnt, 1);
-                        hash_table_insert(&client_hash_table, &client->link);
+                        hash_table_insert(&client_hash_table, key, &client->link);
                 }
         }
@@ -724 +726 @@
 {
         bool destroy;
-
+        unsigned long key[2] = {
+                LOWER32(client->in_task_id),
+                UPPER32(client->in_task_id)
+        };
+        
         futex_down(&async_futex);
         
         if (atomic_predec(&client->refcnt) == 0) {
-                hash_table_remove(&client_hash_table, &client->in_task_id);
+                hash_table_remove(&client_hash_table, key, 2);
                 destroy = true;
         } else
@@ -824 +830 @@
          */
         futex_down(&async_futex);
-        hash_table_remove(&conn_hash_table, &fibril_connection->in_phone_hash);
+        unsigned long key = fibril_connection->in_phone_hash;
+        hash_table_remove(&conn_hash_table, &key, 1);
         futex_up(&async_futex);
         
@@ -908 +915 @@
         
         /* Add connection to the connection hash table */
+        unsigned long key = conn->in_phone_hash;
         
         futex_down(&async_futex);
-        hash_table_insert(&conn_hash_table, &conn->link);
+        hash_table_insert(&conn_hash_table, &key, &conn->link);
         futex_up(&async_futex);
         
@@ -938 +946 @@
         
         switch (IPC_GET_IMETHOD(*call)) {
-        case IPC_M_CLONE_ESTABLISH:
+        case IPC_M_CONNECT_ME:
         case IPC_M_CONNECT_ME_TO:
                 /* Open new connection with fibril, etc. */
@@ -958 +966 @@
 {
         struct timeval tv;
-        getuptime(&tv);
+        gettimeofday(&tv, NULL);
         
         futex_down(&async_futex);
@@ -1015 +1023 @@
                         
                         struct timeval tv;
-                        getuptime(&tv);
+                        gettimeofday(&tv, NULL);
                         
                         if (tv_gteq(&tv, &waiter->to_event.expires)) {
@@ -1102 +1110 @@
 void __async_init(void)
 {
-        if (!hash_table_create(&client_hash_table, 0, 0, &client_hash_table_ops))
+        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS,
+            2, &client_hash_table_ops))
                 abort();
         
-        if (!hash_table_create(&conn_hash_table, 0, 0, &conn_hash_table_ops))
+        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS,
+            1, &conn_hash_table_ops))
                 abort();
         
@@ -1320 +1330 @@
                 timeout = 0;
 
-        getuptime(&msg->wdata.to_event.expires);
+        gettimeofday(&msg->wdata.to_event.expires, NULL);
         tv_add(&msg->wdata.to_event.expires, timeout);
         
@@ -1378 +1388 @@
 
         futex_down(&async_futex);
-        if (msg->done) {
+        if (msg->done)
                 amsg_destroy(msg);
-        } else {
-                msg->dataptr = NULL;
+        else 
                 msg->forget = true;
-        }
         futex_up(&async_futex);
 }
@@ -1402 +1410 @@
         msg->wdata.fid = fibril_get_id();
         
-        getuptime(&msg->wdata.to_event.expires);
+        gettimeofday(&msg->wdata.to_event.expires, NULL);
         tv_add(&msg->wdata.to_event.expires, timeout);
         
@@ -1660 +1668 @@
 }
 
-/** Wrapper for making IPC_M_CLONE_ESTABLISH calls using the async framework.
- *
- * Ask for a cloned connection to some service.
+/** Wrapper for making IPC_M_CONNECT_ME calls using the async framework.
+ *
+ * Ask through for a cloned connection to some service.
  *
  * @param mgmt Exchange management style.
@@ -1670 +1678 @@
  *
  */
-async_sess_t *async_clone_establish(exch_mgmt_t mgmt, async_exch_t *exch)
+async_sess_t *async_connect_me(exch_mgmt_t mgmt, async_exch_t *exch)
 {
         if (exch == NULL) {
@@ -1695 +1703 @@
         msg->wdata.active = true;
         
-        ipc_call_async_0(exch->phone, IPC_M_CLONE_ESTABLISH, msg,
+        ipc_call_async_0(exch->phone, IPC_M_CONNECT_ME, msg,
             reply_received, true);
         
@@ -2068 +2076 @@
         
         async_sess_t *sess = exch->sess;
-        assert(sess != NULL);
         
         atomic_dec(&sess->refcnt);
@@ -2090 +2097 @@
  * @param arg   User defined argument.
  * @param flags Storage for the received flags. Can be NULL.
- * @param dst   Address of the storage for the destination address space area
- *              base address. Cannot be NULL.
+ * @param dst   Destination address space area base. Cannot be NULL.
  *
  * @return Zero on success or a negative error code from errno.h.
@@ -2158 +2164 @@
 int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
 {
-        return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
-            (sysarg_t) __entry);
+        return ipc_share_in_finalize(callid, src, flags);
 }
 
@@ -2219 +2224 @@
  *
  * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
- * @param dst    Address of the storage for the destination address space area
- *               base address.
+ * @param dst    Destination address space area base address.
  *
  * @return Zero on success or a value from @ref errno.h on failure.
@@ -2227 +2231 @@
 int async_share_out_finalize(ipc_callid_t callid, void **dst)
 {
-        return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
+        return ipc_share_out_finalize(callid, dst);
 }
 
@@ -2311 +2315 @@
 int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
 {
-        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
+        return ipc_data_read_finalize(callid, src, size);
 }
 
@@ -2414 +2418 @@
 int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
 {
-        return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
+        return ipc_data_write_finalize(callid, dst, size);
 }