Changes in uspace/srv/vfs/vfs_node.c [44451ee:4e00f87] in mainline

File:

• uspace/srv/vfs/vfs_node.c (modified) (11 diffs)

uspace/srv/vfs/vfs_node.c

@@ -41 +41 @@
 #include <fibril_synch.h>
 #include <adt/hash_table.h>
+#include <adt/hash.h>
 #include <assert.h>
 #include <async.h>
@@ -58 +59 @@
 #define KEY_INDEX       2
 
-static hash_index_t nodes_hash(unsigned long []);
-static int nodes_compare(unsigned long [], hash_count_t, link_t *);
-static void nodes_remove_callback(link_t *);
+static size_t nodes_key_hash(void *);
+static size_t nodes_hash(const ht_link_t *);
+static bool nodes_key_equal(void *, const ht_link_t *);
+static vfs_triplet_t node_triplet(vfs_node_t *node);
 
 /** VFS node hash table operations. */
-hash_table_operations_t nodes_ops = {
+hash_table_ops_t nodes_ops = {
         .hash = nodes_hash,
-        .compare = nodes_compare,
-        .remove_callback = nodes_remove_callback
+        .key_hash = nodes_key_hash,
+        .key_equal = nodes_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL,
 };
 
@@ -75 +79 @@
 bool vfs_nodes_init(void)
 {
-        return hash_table_create(&nodes, NODES_BUCKETS, 3, &nodes_ops);
+        return hash_table_create(&nodes, 0, 0, &nodes_ops);
 }
 
@@ -114 +118 @@
                  */
                 
-                unsigned long key[] = {
-                        [KEY_FS_HANDLE] = node->fs_handle,
-                        [KEY_DEV_HANDLE] = node->devmap_handle,
-                        [KEY_INDEX] = node->index
-                };
-                
-                hash_table_remove(&nodes, key, 3);
+                hash_table_remove_item(&nodes, &node->nh_link);
                 free_vfs_node = true;
                 
@@ -138 +136 @@
                 async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
                 sysarg_t rc = async_req_2_0(exch, VFS_OUT_DESTROY,
-                    (sysarg_t) node->devmap_handle, (sysarg_t)node->index);
+                    (sysarg_t) node->service_id, (sysarg_t)node->index);
                 
                 assert(rc == EOK);
@@ -158 +156 @@
 {
         fibril_mutex_lock(&nodes_mutex);
-        unsigned long key[] = {
-                [KEY_FS_HANDLE] = node->fs_handle,
-                [KEY_DEV_HANDLE] = node->devmap_handle,
-                [KEY_INDEX] = node->index
-        };
-        hash_table_remove(&nodes, key, 3);
+        hash_table_remove_item(&nodes, &node->nh_link);
         fibril_mutex_unlock(&nodes_mutex);
         free(node);
@@ -182 +175 @@
 vfs_node_t *vfs_node_get(vfs_lookup_res_t *result)
 {
-        unsigned long key[] = {
-                [KEY_FS_HANDLE] = result->triplet.fs_handle,
-                [KEY_DEV_HANDLE] = result->triplet.devmap_handle,
-                [KEY_INDEX] = result->triplet.index
-        };
-        link_t *tmp;
         vfs_node_t *node;
 
         fibril_mutex_lock(&nodes_mutex);
-        tmp = hash_table_find(&nodes, key);
+        ht_link_t *tmp = hash_table_find(&nodes, &result->triplet);
         if (!tmp) {
                 node = (vfs_node_t *) malloc(sizeof(vfs_node_t));
@@ -200 +187 @@
                 memset(node, 0, sizeof(vfs_node_t));
                 node->fs_handle = result->triplet.fs_handle;
-                node->devmap_handle = result->triplet.devmap_handle;
+                node->service_id = result->triplet.service_id;
                 node->index = result->triplet.index;
                 node->size = result->size;
                 node->lnkcnt = result->lnkcnt;
                 node->type = result->type;
-                link_initialize(&node->nh_link);
                 fibril_rwlock_initialize(&node->contents_rwlock);
-                hash_table_insert(&nodes, key, &node->nh_link);
+                hash_table_insert(&nodes, &node->nh_link);
         } else {
-                node = hash_table_get_instance(tmp, vfs_node_t, nh_link);
+                node = hash_table_get_inst(tmp, vfs_node_t, nh_link);
                 if (node->type == VFS_NODE_UNKNOWN &&
                     result->type != VFS_NODE_UNKNOWN) {
@@ -240 +226 @@
 }
 
-hash_index_t nodes_hash(unsigned long key[])
-{
-        hash_index_t a = key[KEY_FS_HANDLE] << (NODES_BUCKETS_LOG / 4);
-        hash_index_t b = (a | key[KEY_DEV_HANDLE]) << (NODES_BUCKETS_LOG / 2);
-        
-        return (b | key[KEY_INDEX]) & (NODES_BUCKETS - 1);
-}
-
-int nodes_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-        vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link);
-        return (node->fs_handle == (fs_handle_t) key[KEY_FS_HANDLE]) &&
-            (node->devmap_handle == key[KEY_DEV_HANDLE]) &&
-            (node->index == key[KEY_INDEX]);
-}
-
-void nodes_remove_callback(link_t *item)
-{
-}
-
 struct refcnt_data {
         /** Sum of all reference counts for this file system instance. */
         unsigned refcnt;
         fs_handle_t fs_handle;
-        devmap_handle_t devmap_handle;
+        service_id_t service_id;
 };
 
-static void refcnt_visitor(link_t *item, void *arg)
-{
-        vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link);
+static bool refcnt_visitor(ht_link_t *item, void *arg)
+{
+        vfs_node_t *node = hash_table_get_inst(item, vfs_node_t, nh_link);
         struct refcnt_data *rd = (void *) arg;
 
         if ((node->fs_handle == rd->fs_handle) &&
-            (node->devmap_handle == rd->devmap_handle))
+            (node->service_id == rd->service_id))
                 rd->refcnt += node->refcnt;
+        
+        return true;
 }
 
 unsigned
-vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, devmap_handle_t devmap_handle)
+vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, service_id_t service_id)
 {
         struct refcnt_data rd = {
                 .refcnt = 0,
                 .fs_handle = fs_handle,
-                .devmap_handle = devmap_handle
+                .service_id = service_id
         };
 
@@ -305 +273 @@
         ipc_call_t answer;
         aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE,
-            (sysarg_t) node->devmap_handle, (sysarg_t) node->index, &answer);
+            (sysarg_t) node->service_id, (sysarg_t) node->index, &answer);
         
         vfs_exchange_release(exch);
@@ -315 +283 @@
 }
 
+
+static size_t nodes_key_hash(void *key)
+{
+        vfs_triplet_t *tri = key;
+        size_t hash = hash_combine(tri->fs_handle, tri->index);
+        return hash_combine(hash, tri->service_id);
+}
+
+static size_t nodes_hash(const ht_link_t *item)
+{
+        vfs_node_t *node = hash_table_get_inst(item, vfs_node_t, nh_link);
+        vfs_triplet_t tri = node_triplet(node);
+        return nodes_key_hash(&tri);
+}
+
+static bool nodes_key_equal(void *key, const ht_link_t *item)
+{
+        vfs_triplet_t *tri = key;
+        vfs_node_t *node = hash_table_get_inst(item, vfs_node_t, nh_link);
+        return node->fs_handle == tri->fs_handle 
+                && node->service_id == tri->service_id
+                && node->index == tri->index;
+}
+
+static inline vfs_triplet_t node_triplet(vfs_node_t *node)
+{
+        vfs_triplet_t tri = {
+                .fs_handle = node->fs_handle,
+                .service_id = node->service_id,
+                .index = node->index
+        };
+        
+        return tri;
+}
+
 /**
  * @}