Changes in uspace/srv/fs/locfs/locfs_ops.c [3e6a98c5:086290d] in mainline

File:

• uspace/srv/fs/locfs/locfs_ops.c (modified) (17 diffs)

uspace/srv/fs/locfs/locfs_ops.c

@@ -37 +37 @@
 
 #include <macros.h>
-#include <stdbool.h>
+#include <bool.h>
 #include <errno.h>
 #include <malloc.h>
@@ -61 +61 @@
         async_sess_t *sess;       /**< If NULL, the structure is incomplete. */
         size_t refcount;
-        ht_link_t link;
+        link_t link;
         fibril_condvar_t cv;      /**< Broadcast when completed. */
 } service_t;
@@ -71 +71 @@
 static FIBRIL_MUTEX_INITIALIZE(services_mutex);
 
+#define SERVICES_KEYS        1
+#define SERVICES_KEY_HANDLE  0
+#define SERVICES_BUCKETS     256
+
 /* Implementation of hash table interface for the nodes hash table. */
-
-static size_t services_key_hash(void *key)
-{
-        return *(service_id_t*)key;
-}
-
-static size_t services_hash(const ht_link_t *item)
-{
-        service_t *dev = hash_table_get_inst(item, service_t, link);
-        return dev->service_id;
-}
-
-static bool services_key_equal(void *key, const ht_link_t *item)
-{
-        service_t *dev = hash_table_get_inst(item, service_t, link);
-        return (dev->service_id == *(service_id_t*)key);
-}
-
-static void services_remove_callback(ht_link_t *item)
-{
-        free(hash_table_get_inst(item, service_t, link));
-}
-
-static hash_table_ops_t services_ops = {
+static hash_index_t services_hash(unsigned long key[])
+{
+        return key[SERVICES_KEY_HANDLE] % SERVICES_BUCKETS;
+}
+
+static int services_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+        service_t *dev = hash_table_get_instance(item, service_t, link);
+        return (dev->service_id == (service_id_t) key[SERVICES_KEY_HANDLE]);
+}
+
+static void services_remove_callback(link_t *item)
+{
+        free(hash_table_get_instance(item, service_t, link));
+}
+
+static hash_table_operations_t services_ops = {
         .hash = services_hash,
-        .key_hash = services_key_hash,
-        .key_equal = services_key_equal,
-        .equal = NULL, 
+        .compare = services_compare,
         .remove_callback = services_remove_callback
 };
@@ -234 +229 @@
                 /* Device node */
                 
+                unsigned long key[] = {
+                        [SERVICES_KEY_HANDLE] = (unsigned long) node->service_id
+                };
+                link_t *lnk;
+                
                 fibril_mutex_lock(&services_mutex);
-                ht_link_t *lnk;
 restart:
-                lnk = hash_table_find(&services, &node->service_id);
+                lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
                         service_t *dev = (service_t *) malloc(sizeof(service_t));
@@ -257 +256 @@
                          * below.
                          */
-                        hash_table_insert(&services, &dev->link);
+                        hash_table_insert(&services, key, &dev->link);
                         
                         /*
@@ -280 +279 @@
                                  * entry and free the device structure.
                                  */
-                                hash_table_remove(&services, &node->service_id);
+                                hash_table_remove(&services, key, SERVICES_KEYS);
                                 fibril_mutex_unlock(&services_mutex);
                                 
@@ -289 +288 @@
                         dev->sess = sess;
                 } else {
-                        service_t *dev = hash_table_get_inst(lnk, service_t, link);
+                        service_t *dev = hash_table_get_instance(lnk, service_t, link);
                         
                         if (!dev->sess) {
@@ -451 +450 @@
 bool locfs_init(void)
 {
-        if (!hash_table_create(&services, 0,  0, &services_ops))
+        if (!hash_table_create(&services, SERVICES_BUCKETS,
+            SERVICES_KEYS, &services_ops))
                 return false;
         
@@ -555 +555 @@
                 /* Device node */
                 
+                unsigned long key[] = {
+                        [SERVICES_KEY_HANDLE] = (unsigned long) index
+                };
+                
                 fibril_mutex_lock(&services_mutex);
-                service_id_t service_index = index;
-                ht_link_t *lnk = hash_table_find(&services, &service_index);
+                link_t *lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
                         fibril_mutex_unlock(&services_mutex);
@@ -563 +566 @@
                 }
                 
-                service_t *dev = hash_table_get_inst(lnk, service_t, link);
+                service_t *dev = hash_table_get_instance(lnk, service_t, link);
                 assert(dev->sess);
                 
@@ -618 +621 @@
         if (type == LOC_OBJECT_SERVICE) {
                 /* Device node */
+                unsigned long key[] = {
+                        [SERVICES_KEY_HANDLE] = (unsigned long) index
+                };
                 
                 fibril_mutex_lock(&services_mutex);
-                service_id_t service_index = index;
-                ht_link_t *lnk = hash_table_find(&services, &service_index);
+                link_t *lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
                         fibril_mutex_unlock(&services_mutex);
@@ -627 +632 @@
                 }
                 
-                service_t *dev = hash_table_get_inst(lnk, service_t, link);
+                service_t *dev = hash_table_get_instance(lnk, service_t, link);
                 assert(dev->sess);
                 
@@ -686 +691 @@
         
         if (type == LOC_OBJECT_SERVICE) {
+                unsigned long key[] = {
+                        [SERVICES_KEY_HANDLE] = (unsigned long) index
+                };
                 
                 fibril_mutex_lock(&services_mutex);
-                service_id_t service_index = index;
-                ht_link_t *lnk = hash_table_find(&services, &service_index);
+                link_t *lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
                         fibril_mutex_unlock(&services_mutex);
@@ -695 +702 @@
                 }
                 
-                service_t *dev = hash_table_get_inst(lnk, service_t, link);
+                service_t *dev = hash_table_get_instance(lnk, service_t, link);
                 assert(dev->sess);
                 dev->refcount--;
@@ -701 +708 @@
                 if (dev->refcount == 0) {
                         async_hangup(dev->sess);
-                        service_id_t service_index = index;
-                        hash_table_remove(&services, &service_index);
+                        hash_table_remove(&services, key, SERVICES_KEYS);
                 }
                 
@@ -726 +732 @@
         
         if (type == LOC_OBJECT_SERVICE) {
-
+                unsigned long key[] = {
+                        [SERVICES_KEY_HANDLE] = (unsigned long) index
+                };
+                
                 fibril_mutex_lock(&services_mutex);
-                service_id_t service_index = index;
-                ht_link_t *lnk = hash_table_find(&services, &service_index);
+                link_t *lnk = hash_table_find(&services, key);
                 if (lnk == NULL) {
                         fibril_mutex_unlock(&services_mutex);
@@ -735 +743 @@
                 }
                 
-                service_t *dev = hash_table_get_inst(lnk, service_t, link);
+                service_t *dev = hash_table_get_instance(lnk, service_t, link);
                 assert(dev->sess);