Changeset bc216a0 in mainline for uspace/srv/fs/ext2fs/ext2fs_ops.c

Timestamp:

2012-08-07T22:13:44Z (12 years ago)

Author:

Adam Hraska <adam.hraska+hos@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

da68871a

Parents:

b17518e

Message:

Refactored any users of hash_table to use opaque void* keys instead of the cumbersome unsigned long[] keys. Switched from the ad hoc computations of hashes of multiple values to hash_combine().

File:

• uspace/srv/fs/ext2fs/ext2fs_ops.c (modified) (9 diffs)

uspace/srv/fs/ext2fs/ext2fs_ops.c

@@ -49 +49 @@
 #include <byteorder.h>
 #include <adt/hash_table.h>
+#include <adt/hash.h>
 #include <adt/list.h>
 #include <assert.h>
@@ -62 +63 @@
 #define EXT2FS_NODE(node)       ((node) ? (ext2fs_node_t *) (node)->data : NULL)
 #define EXT2FS_DBG(format, ...) {if (false) printf("ext2fs: %s: " format "\n", __FUNCTION__, ##__VA_ARGS__);}
-#define OPEN_NODES_KEYS 2
-#define OPEN_NODES_DEV_HANDLE_KEY 0
-#define OPEN_NODES_INODE_KEY 1
 
 typedef struct ext2fs_instance {
@@ -77 +75 @@
         ext2_inode_ref_t *inode_ref;
         fs_node_t *fs_node;
-        link_t link;
+        ht_link_t link;
         unsigned int references;
 } ext2fs_node_t;
@@ -121 +119 @@
 static FIBRIL_MUTEX_INITIALIZE(open_nodes_lock);
 
-/* Hash table interface for open nodes hash table */
-static size_t open_nodes_key_hash(unsigned long key[])
-{
-        /* Hash construction recommended in Effective Java, 2nd Edition. */
-        size_t hash = 17;
-        hash = 31 * hash + key[OPEN_NODES_DEV_HANDLE_KEY];
-        hash = 31 * hash + key[OPEN_NODES_INODE_KEY];
-        return hash;
-}
-
-static size_t open_nodes_hash(const link_t *item)
-{
-        ext2fs_node_t *enode = hash_table_get_instance(item, ext2fs_node_t, link);
+/* 
+ * 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)
+{
+        node_key_t *node_key = (node_key_t*)key;
+        return hash_combine(node_key->service_id, node_key->index);
+}
+
+static size_t open_nodes_hash(const ht_link_t *item)
+{
+        ext2fs_node_t *enode = hash_table_get_inst(item, ext2fs_node_t, link);
 
         assert(enode->instance);
         assert(enode->inode_ref);
         
-        unsigned long key[] = {
-                [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id,
-                [OPEN_NODES_INODE_KEY] = enode->inode_ref->index,
-        };
-        
-        return open_nodes_key_hash(key);
-}
-
-static bool open_nodes_match(unsigned long key[], size_t keys, 
-    const link_t *item)
-{
-        ext2fs_node_t *enode = hash_table_get_instance(item, ext2fs_node_t, link);
-        assert(keys > 0);
-        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]);
+        return hash_combine(enode->instance->service_id, enode->inode_ref->index);
+}
+
+static bool open_nodes_key_equal(void *key, const ht_link_t *item)
+{
+        node_key_t *node_key = (node_key_t*)key;
+        ext2fs_node_t *enode = hash_table_get_inst(item, ext2fs_node_t, link);
+        
+        return node_key->service_id == enode->instance->service_id
+                && node_key->index == enode->inode_ref->index;
 }
 
@@ -165 +156 @@
         .hash = open_nodes_hash,
         .key_hash = open_nodes_key_hash,
-        .match = open_nodes_match,
+        .key_equal = open_nodes_key_equal,
         .equal = 0,
         .remove_callback = 0,
@@ -175 +166 @@
 int ext2fs_global_init(void)
 {
-        if (!hash_table_create(&open_nodes, 0, OPEN_NODES_KEYS, &open_nodes_ops)) {
+        if (!hash_table_create(&open_nodes, 0, 0, &open_nodes_ops)) {
                 return ENOMEM;
         }
@@ -329 +320 @@
         
         /* Check if the node is not already open */
-        unsigned long key[] = {
-                [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
-                [OPEN_NODES_INODE_KEY] = index,
+        node_key_t key = {
+                .service_id = inst->service_id,
+                .index = index
         };
-        link_t *already_open = hash_table_find(&open_nodes, key);
+        ht_link_t *already_open = hash_table_find(&open_nodes, &key);
 
         if (already_open) {
-                enode = hash_table_get_instance(already_open, ext2fs_node_t, link);
+                enode = hash_table_get_inst(already_open, ext2fs_node_t, link);
                 *rfn = enode->fs_node;
                 enode->references++;
@@ -370 +361 @@
         enode->references = 1;
         enode->fs_node = node;
-        link_initialize(&enode->link);
         
         node->data = enode;
@@ -421 +411 @@
 int ext2fs_node_put_core(ext2fs_node_t *enode)
 {
-        int rc;
-
-        unsigned long key[] = {
-                [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id,
-                [OPEN_NODES_INODE_KEY] = enode->inode_ref->index,
+        node_key_t key = {
+                .service_id = enode->instance->service_id,
+                .index = enode->inode_ref->index
         };
-        hash_table_remove(&open_nodes, key, OPEN_NODES_KEYS);
+
+        hash_table_remove(&open_nodes, &key);
+        
         assert(enode->instance->open_nodes_count > 0);
         enode->instance->open_nodes_count--;
 
-        rc = ext2_filesystem_put_inode_ref(enode->inode_ref);
+        int rc = ext2_filesystem_put_inode_ref(enode->inode_ref);
         if (rc != EOK) {
                 EXT2FS_DBG("ext2_filesystem_put_inode_ref failed");