Changes in uspace/srv/fs/mfs/mfs_ops.c [44ecf89:7769ec9] in mainline

File:

• uspace/srv/fs/mfs/mfs_ops.c (modified) (13 diffs)

uspace/srv/fs/mfs/mfs_ops.c

@@ -35 +35 @@
 #include <align.h>
 #include <adt/hash_table.h>
-#include <adt/hash.h>
 #include "mfs.h"
 
+#define OPEN_NODES_KEYS 2
+#define OPEN_NODES_SERVICE_KEY 0
+#define OPEN_NODES_INODE_KEY 1
+#define OPEN_NODES_BUCKETS 256
 
 static bool check_magic_number(uint16_t magic, bool *native,
@@ -58 +61 @@
 static int mfs_unlink(fs_node_t *, fs_node_t *, const char *name);
 static int mfs_destroy_node(fs_node_t *fn);
+static hash_index_t open_nodes_hash(unsigned long key[]);
+static int open_nodes_compare(unsigned long key[], hash_count_t keys,
+    link_t *item);
+static void open_nodes_remove_cb(link_t *link);
 static int mfs_node_get(fs_node_t **rfn, service_id_t service_id,
     fs_index_t index);
@@ -88 +95 @@
 
 /* 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)
-{
-        struct mfs_node *m = hash_table_get_inst(item, struct mfs_node, link);
-        return hash_combine(m->instance->service_id, m->ino_i->index);
-}
-
-static bool
-open_nodes_key_equal(void *key, const ht_link_t *item)
-{
-        node_key_t *node_key = (node_key_t*)key;
-        struct mfs_node *mnode = hash_table_get_inst(item, struct mfs_node, link);
-
-        return node_key->service_id == mnode->instance->service_id
-                && node_key->index == mnode->ino_i->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;
+}
+
+static int
+open_nodes_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
+{
+        struct mfs_node *mnode = hash_table_get_instance(item,
+            struct mfs_node, link);
+        assert(keys > 0);
+        if (mnode->instance->service_id !=
+            ((service_id_t) key[OPEN_NODES_SERVICE_KEY])) {
+                return false;
+        }
+        if (keys == 1) {
+                return true;
+        }
+        assert(keys == 2);
+        return (mnode->ino_i->index == key[OPEN_NODES_INODE_KEY]);
+}
+
+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,
 };
 
@@ -129 +135 @@
 mfs_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;
         }
@@ -190 +197 @@
                 /* This is a V1 or V2 Minix filesystem */
                 magic = sb->s_magic;
-        } else if (check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
+        } else if (check_magic_number(sb3->s_magic, &native,
+            &version, &longnames)) {
                 /* This is a V3 Minix filesystem */
                 magic = sb3->s_magic;
@@ -400 +408 @@
         mnode->refcnt = 1;
 
+        link_initialize(&mnode->link);
+
+        unsigned long key[] = {
+                [OPEN_NODES_SERVICE_KEY] = inst->service_id,
+                [OPEN_NODES_INODE_KEY] = inum,
+        };
+
         fibril_mutex_lock(&open_nodes_lock);
-        hash_table_insert(&open_nodes, &mnode->link);
+        hash_table_insert(&open_nodes, key, &mnode->link);
         fibril_mutex_unlock(&open_nodes_lock);
         inst->open_nodes_cnt++;
@@ -452 +467 @@
 
                 if (comp_size == dentry_name_size &&
-                    memcmp(component, d_info.d_name, dentry_name_size) == 0) {
+                    !bcmp(component, d_info.d_name, dentry_name_size)) {
                         /* Hit! */
                         mfs_node_core_get(rfn, mnode->instance,
@@ -500 +515 @@
         mnode->refcnt--;
         if (mnode->refcnt == 0) {
-                hash_table_remove_item(&open_nodes, &mnode->link);
+                unsigned long key[] = {
+                        [OPEN_NODES_SERVICE_KEY] = mnode->instance->service_id,
+                        [OPEN_NODES_INODE_KEY] = mnode->ino_i->index
+                };
+                hash_table_remove(&open_nodes, key, OPEN_NODES_KEYS);
                 assert(mnode->instance->open_nodes_cnt > 0);
                 mnode->instance->open_nodes_cnt--;
@@ -559 +578 @@
 
         /* Check if the node is not already open */
-        node_key_t key = {
-                .service_id = inst->service_id,
-                .index = index
+        unsigned long key[] = {
+                [OPEN_NODES_SERVICE_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);
 
         if (already_open) {
-                mnode = hash_table_get_inst(already_open, struct mfs_node, link);
+                mnode = hash_table_get_instance(already_open,
+                    struct mfs_node, link);
                 *rfn = mnode->fsnode;
                 mnode->refcnt++;
@@ -598 +617 @@
         mnode->ino_i = ino_i;
         mnode->refcnt = 1;
+        link_initialize(&mnode->link);
 
         mnode->instance = inst;
@@ -604 +624 @@
         *rfn = node;
 
-        hash_table_insert(&open_nodes, &mnode->link);
+        hash_table_insert(&open_nodes, key, &mnode->link);
         inst->open_nodes_cnt++;
 
@@ -773 +793 @@
 {
         int rc;
-        fs_node_t *fn = NULL;
+        fs_node_t *fn;
 
         rc = mfs_node_get(&fn, service_id, index);
@@ -1108 +1128 @@
 mfs_sync(service_id_t service_id, fs_index_t index)
 {
-        fs_node_t *fn = NULL;
+        fs_node_t *fn;
         int rc = mfs_node_get(&fn, service_id, index);
         if (rc != EOK)