Changes in uspace/srv/vfs/vfs_node.c [4e00f87:44451ee] 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>
@@ -59 +58 @@
 #define KEY_INDEX       2
 
-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);
+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 *);
 
 /** VFS node hash table operations. */
-hash_table_ops_t nodes_ops = {
+hash_table_operations_t nodes_ops = {
         .hash = nodes_hash,
-        .key_hash = nodes_key_hash,
-        .key_equal = nodes_key_equal,
-        .equal = NULL,
-        .remove_callback = NULL,
+        .compare = nodes_compare,
+        .remove_callback = nodes_remove_callback
 };
 
@@ -79 +75 @@
 bool vfs_nodes_init(void)
 {
-        return hash_table_create(&nodes, 0, 0, &nodes_ops);
+        return hash_table_create(&nodes, NODES_BUCKETS, 3, &nodes_ops);
 }
 
@@ -118 +114 @@
                  */
                 
-                hash_table_remove_item(&nodes, &node->nh_link);
+                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);
                 free_vfs_node = true;
                 
@@ -136 +138 @@
                 async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
                 sysarg_t rc = async_req_2_0(exch, VFS_OUT_DESTROY,
-                    (sysarg_t) node->service_id, (sysarg_t)node->index);
+                    (sysarg_t) node->devmap_handle, (sysarg_t)node->index);
                 
                 assert(rc == EOK);
@@ -156 +158 @@
 {
         fibril_mutex_lock(&nodes_mutex);
-        hash_table_remove_item(&nodes, &node->nh_link);
+        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);
         fibril_mutex_unlock(&nodes_mutex);
         free(node);
@@ -175 +182 @@
 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);
-        ht_link_t *tmp = hash_table_find(&nodes, &result->triplet);
+        tmp = hash_table_find(&nodes, key);
         if (!tmp) {
                 node = (vfs_node_t *) malloc(sizeof(vfs_node_t));
@@ -187 +200 @@
                 memset(node, 0, sizeof(vfs_node_t));
                 node->fs_handle = result->triplet.fs_handle;
-                node->service_id = result->triplet.service_id;
+                node->devmap_handle = result->triplet.devmap_handle;
                 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, &node->nh_link);
+                hash_table_insert(&nodes, key, &node->nh_link);
         } else {
-                node = hash_table_get_inst(tmp, vfs_node_t, nh_link);
+                node = hash_table_get_instance(tmp, vfs_node_t, nh_link);
                 if (node->type == VFS_NODE_UNKNOWN &&
                     result->type != VFS_NODE_UNKNOWN) {
@@ -226 +240 @@
 }
 
+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;
-        service_id_t service_id;
+        devmap_handle_t devmap_handle;
 };
 
-static bool refcnt_visitor(ht_link_t *item, void *arg)
-{
-        vfs_node_t *node = hash_table_get_inst(item, vfs_node_t, nh_link);
+static void refcnt_visitor(link_t *item, void *arg)
+{
+        vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link);
         struct refcnt_data *rd = (void *) arg;
 
         if ((node->fs_handle == rd->fs_handle) &&
-            (node->service_id == rd->service_id))
+            (node->devmap_handle == rd->devmap_handle))
                 rd->refcnt += node->refcnt;
-        
-        return true;
 }
 
 unsigned
-vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, service_id_t service_id)
+vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, devmap_handle_t devmap_handle)
 {
         struct refcnt_data rd = {
                 .refcnt = 0,
                 .fs_handle = fs_handle,
-                .service_id = service_id
+                .devmap_handle = devmap_handle
         };
 
@@ -273 +305 @@
         ipc_call_t answer;
         aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE,
-            (sysarg_t) node->service_id, (sysarg_t) node->index, &answer);
+            (sysarg_t) node->devmap_handle, (sysarg_t) node->index, &answer);
         
         vfs_exchange_release(exch);
@@ -283 +315 @@
 }
 
-
-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;
-}
-
 /**
  * @}