Changes in uspace/srv/fs/ext4fs/ext4fs_ops.c [062d900:38542dc] in mainline

File:

• uspace/srv/fs/ext4fs/ext4fs_ops.c (modified) (9 diffs)

uspace/srv/fs/ext4fs/ext4fs_ops.c

@@ -42 +42 @@
 #include <malloc.h>
 #include <adt/hash_table.h>
-#include <adt/hash.h>
 #include <ipc/loc.h>
 #include "ext4fs.h"
@@ -49 +48 @@
 #define EXT4FS_NODE(node) \
         ((node) ? (ext4fs_node_t *) (node)->data : NULL)
+
+#define OPEN_NODES_KEYS  2
+
+#define OPEN_NODES_DEV_HANDLE_KEY  0
+#define OPEN_NODES_INODE_KEY       1
+
+#define OPEN_NODES_BUCKETS  256
 
 /**
@@ -67 +73 @@
         ext4_inode_ref_t *inode_ref;
         fs_node_t *fs_node;
-        ht_link_t link;
+        link_t link;
         unsigned int references;
 } ext4fs_node_t;
@@ -109 +115 @@
 
 /* Hash table interface for open nodes hash table */
-
-typedef struct {
-        service_id_t service_id;
-        fs_index_t index;
-} node_key_t;
-
-static size_t open_nodes_key_hash(void *key_arg)
-{
-        node_key_t *key = (node_key_t *)key_arg;
-        return hash_combine(key->service_id, key->index);
-}
-
-static size_t open_nodes_hash(const ht_link_t *item)
-{
-        ext4fs_node_t *enode = hash_table_get_inst(item, ext4fs_node_t, link);
-        return hash_combine(enode->instance->service_id, enode->inode_ref->index);      
-}
-
-static bool open_nodes_key_equal(void *key_arg, const ht_link_t *item)
-{
-        node_key_t *key = (node_key_t *)key_arg;
-        ext4fs_node_t *enode = hash_table_get_inst(item, ext4fs_node_t, link);
-        
-        return key->service_id == enode->instance->service_id
-                && key->index == enode->inode_ref->index;
-}
-
-static hash_table_ops_t open_nodes_ops = {
+static hash_index_t open_nodes_hash(unsigned long key[])
+{
+        /* TODO: This is very simple and probably can be improved */
+        return key[OPEN_NODES_INODE_KEY] % OPEN_NODES_BUCKETS;
+}
+
+/** Compare given item with values in hash table.
+ *
+ */
+static int open_nodes_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
+{
+        assert(keys > 0);
+        
+        ext4fs_node_t *enode =
+            hash_table_get_instance(item, ext4fs_node_t, link);
+        
+        if (enode->instance->service_id !=
+            ((service_id_t) key[OPEN_NODES_DEV_HANDLE_KEY]))
+                return false;
+        
+        if (keys == 1)
+                return true;
+        
+        assert(keys == 2);
+        
+        return (enode->inode_ref->index == key[OPEN_NODES_INODE_KEY]);
+}
+
+/** Empty callback to correct hash table initialization.
+ *
+ */
+static void open_nodes_remove_cb(link_t *link)
+{
+        /* We don't use remove callback for this hash table */
+}
+
+static hash_table_operations_t open_nodes_ops = {
         .hash = open_nodes_hash,
-        .key_hash = open_nodes_key_hash,
-        .key_equal = open_nodes_key_equal,
-        .equal = NULL,
-        .remove_callback = NULL,
+        .compare = open_nodes_compare,
+        .remove_callback = open_nodes_remove_cb,
 };
 
@@ -154 +168 @@
 int ext4fs_global_init(void)
 {
-        if (!hash_table_create(&open_nodes, 0, 0, &open_nodes_ops))
+        if (!hash_table_create(&open_nodes, OPEN_NODES_BUCKETS,
+            OPEN_NODES_KEYS, &open_nodes_ops))
                 return ENOMEM;
         
@@ -300 +315 @@
         
         /* Check if the node is not already open */
-        node_key_t key = {
-                .service_id = inst->service_id,
-                .index = index
+        unsigned long key[] = {
+                [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
+                [OPEN_NODES_INODE_KEY] = index
         };
         
-        ht_link_t *already_open = hash_table_find(&open_nodes, &key);
+        link_t *already_open = hash_table_find(&open_nodes, key);
         ext4fs_node_t *enode = NULL;
         if (already_open) {
-                enode = hash_table_get_inst(already_open, ext4fs_node_t, link);
+                enode = hash_table_get_instance(already_open, ext4fs_node_t, link);
                 *rfn = enode->fs_node;
                 enode->references++;
@@ -349 +364 @@
         enode->references = 1;
         enode->fs_node = fs_node;
+        link_initialize(&enode->link);
         
         fs_node->data = enode;
         *rfn = fs_node;
         
-        hash_table_insert(&open_nodes, &enode->link);
+        hash_table_insert(&open_nodes, key, &enode->link);
         inst->open_nodes_count++;
         
@@ -370 +386 @@
 int ext4fs_node_put_core(ext4fs_node_t *enode)
 {
-        hash_table_remove_item(&open_nodes, &enode->link);
+        unsigned long key[] = {
+                [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id,
+                [OPEN_NODES_INODE_KEY] = enode->inode_ref->index
+        };
+        
+        hash_table_remove(&open_nodes, key, OPEN_NODES_KEYS);
         assert(enode->instance->open_nodes_count > 0);
         enode->instance->open_nodes_count--;
@@ -477 +498 @@
         enode->references = 1;
         
+        link_initialize(&enode->link);
+        
+        unsigned long key[] = {
+                [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
+                [OPEN_NODES_INODE_KEY] = inode_ref->index
+        };
+        
         fibril_mutex_lock(&open_nodes_lock);
-        hash_table_insert(&open_nodes, &enode->link);
+        hash_table_insert(&open_nodes, key, &enode->link);
         fibril_mutex_unlock(&open_nodes_lock);
         inst->open_nodes_count++;