Changes in uspace/lib/c/generic/async.c [45cbcaf4:4e00f87] in mainline

File:

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

uspace/lib/c/generic/async.c

@@ -114 +114 @@
 #include <stdlib.h>
 #include <macros.h>
-
-#define CLIENT_HASH_TABLE_BUCKETS  32
-#define CONN_HASH_TABLE_BUCKETS    32
+#include "private/libc.h"
+
 
 /** Session data */
@@ -204 +203 @@
 /* Client connection data */
 typedef struct {
-        link_t link;
+        ht_link_t link;
         
         task_id_t in_task_id;
@@ -216 +215 @@
         
         /** Hash table link. */
-        link_t link;
+        ht_link_t link;
         
         /** Incoming client task ID. */
@@ -392 +391 @@
 static LIST_INITIALIZE(timeout_list);
 
-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)
-{
-}
+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;
+}
+
 
 /** Operations for the client hash table. */
-static hash_table_operations_t client_hash_table_ops = {
+static hash_table_ops_t client_hash_table_ops = {
         .hash = client_hash,
-        .compare = client_compare,
-        .remove_callback = client_remove
+        .key_hash = client_key_hash,
+        .key_equal = client_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL
 };
 
@@ -428 +427 @@
  *
  */
-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)
-{
-}
+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);
+}
+
 
 /** Operations for the connection hash table. */
-static hash_table_operations_t conn_hash_table_ops = {
+static hash_table_ops_t conn_hash_table_ops = {
         .hash = conn_hash,
-        .compare = conn_compare,
-        .remove_callback = conn_remove
+        .key_hash = conn_key_hash,
+        .key_equal = conn_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL
 };
 
@@ -509 +501 @@
         futex_down(&async_futex);
         
-        unsigned long key = call->in_phone_hash;
-        link_t *hlp = hash_table_find(&conn_hash_table, &key);
+        ht_link_t *hlp = hash_table_find(&conn_hash_table, &call->in_phone_hash);
         
         if (!hlp) {
@@ -517 +508 @@
         }
         
-        connection_t *conn = hash_table_get_instance(hlp, connection_t, link);
+        connection_t *conn = hash_table_get_inst(hlp, connection_t, link);
         
         msg_t *msg = malloc(sizeof(*msg));
@@ -697 +688 @@
 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);
-        link_t *lnk = hash_table_find(&client_hash_table, key);
+        ht_link_t *lnk = hash_table_find(&client_hash_table, &client_id);
         if (lnk) {
-                client = hash_table_get_instance(lnk, client_t, link);
+                client = hash_table_get_inst(lnk, client_t, link);
                 atomic_inc(&client->refcnt);
         } else if (create) {
@@ -715 +702 @@
                 
                         atomic_set(&client->refcnt, 1);
-                        hash_table_insert(&client_hash_table, key, &client->link);
+                        hash_table_insert(&client_hash_table, &client->link);
                 }
         }
@@ -726 +713 @@
 {
         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, key, 2);
+                hash_table_remove(&client_hash_table, &client->in_task_id);
                 destroy = true;
         } else
@@ -830 +813 @@
          */
         futex_down(&async_futex);
-        unsigned long key = fibril_connection->in_phone_hash;
-        hash_table_remove(&conn_hash_table, &key, 1);
+        hash_table_remove(&conn_hash_table, &fibril_connection->in_phone_hash);
         futex_up(&async_futex);
         
@@ -915 +897 @@
         
         /* Add connection to the connection hash table */
-        unsigned long key = conn->in_phone_hash;
         
         futex_down(&async_futex);
-        hash_table_insert(&conn_hash_table, &key, &conn->link);
+        hash_table_insert(&conn_hash_table, &conn->link);
         futex_up(&async_futex);
         
@@ -1110 +1091 @@
 void __async_init(void)
 {
-        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS,
-            2, &client_hash_table_ops))
+        if (!hash_table_create(&client_hash_table, 0, 0, &client_hash_table_ops))
                 abort();
         
-        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS,
-            1, &conn_hash_table_ops))
+        if (!hash_table_create(&conn_hash_table, 0, 0, &conn_hash_table_ops))
                 abort();
         
@@ -2166 +2145 @@
 int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
 {
-        return ipc_share_in_finalize(callid, src, flags);
+        return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
+            (sysarg_t) __entry);
 }
 
@@ -2233 +2213 @@
 int async_share_out_finalize(ipc_callid_t callid, void **dst)
 {
-        return ipc_share_out_finalize(callid, dst);
+        return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
 }
 
@@ -2317 +2297 @@
 int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
 {
-        return ipc_data_read_finalize(callid, src, size);
+        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
 }
 
@@ -2420 +2400 @@
 int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
 {
-        return ipc_data_write_finalize(callid, dst, size);
+        return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
 }