Changes in uspace/srv/fs/cdfs/cdfs_ops.c [b33870b:44ecf89] in mainline

File:

• uspace/srv/fs/cdfs/cdfs_ops.c (modified) (16 diffs)

uspace/srv/fs/cdfs/cdfs_ops.c

@@ -37 +37 @@
  */
 
-#include <bool.h>
+#include "cdfs_ops.h"
+#include <stdbool.h>
 #include <adt/hash_table.h>
+#include <adt/hash.h>
 #include <malloc.h>
 #include <mem.h>
@@ -44 +46 @@
 #include <libfs.h>
 #include <errno.h>
-#include <libblock.h>
+#include <block.h>
 #include <str.h>
 #include <byteorder.h>
@@ -50 +52 @@
 #include "cdfs.h"
 #include "cdfs_endian.h"
-#include "cdfs_ops.h"
 
 /** Standard CD-ROM block size */
 #define BLOCK_SIZE  2048
 
-/** Implicit node cache size
- *
- * More nodes can be actually cached if the files remain
- * opended.
- *
- */
-#define NODE_CACHE_SIZE  200
-
-#define NODES_BUCKETS  256
-
-#define NODES_KEY_SRVC   0
-#define NODES_KEY_INDEX  1
+#define NODE_CACHE_SIZE 200
 
 /** All root nodes have index 0 */
@@ -205 +195 @@
         service_id_t service_id;  /**< Service ID of block device */
         
-        link_t nh_link;           /**< Nodes hash table link */
+        ht_link_t nh_link;        /**< Nodes hash table link */
         cdfs_dentry_type_t type;  /**< Dentry type */
         
@@ -226 +216 @@
 static hash_table_t nodes;
 
-static hash_index_t nodes_hash(unsigned long key[])
-{
-        return key[NODES_KEY_INDEX] % NODES_BUCKETS;
-}
-
-static int nodes_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-        cdfs_node_t *node =
-            hash_table_get_instance(item, cdfs_node_t, nh_link);
-        
-        switch (keys) {
-        case 1:
-                return (node->service_id == key[NODES_KEY_SRVC]);
-        case 2:
-                return ((node->service_id == key[NODES_KEY_SRVC]) &&
-                    (node->index == key[NODES_KEY_INDEX]));
-        default:
-                assert((keys == 1) || (keys == 2));
-        }
-        
-        return 0;
-}
-
-static void nodes_remove_callback(link_t *item)
-{
-        cdfs_node_t *node =
-            hash_table_get_instance(item, cdfs_node_t, nh_link);
+/* 
+ * Hash table support functions.
+ */
+
+typedef struct {
+        service_id_t service_id;
+    fs_index_t index;
+} ht_key_t;
+
+static size_t nodes_key_hash(void *k)
+{
+        ht_key_t *key = (ht_key_t*)k;
+        return hash_combine(key->service_id, key->index);
+}
+
+static size_t nodes_hash(const ht_link_t *item)
+{
+        cdfs_node_t *node = hash_table_get_inst(item, cdfs_node_t, nh_link);
+        return hash_combine(node->service_id, node->index);
+}
+
+static bool nodes_key_equal(void *k, const ht_link_t *item)
+{
+        cdfs_node_t *node = hash_table_get_inst(item, cdfs_node_t, nh_link);
+        ht_key_t *key = (ht_key_t*)k;
+        
+        return key->service_id == node->service_id && key->index == node->index;
+}
+
+static void nodes_remove_callback(ht_link_t *item)
+{
+        cdfs_node_t *node = hash_table_get_inst(item, cdfs_node_t, nh_link);
         
         assert(node->type == CDFS_DIRECTORY);
@@ -268 +263 @@
 
 /** Nodes hash table operations */
-static hash_table_operations_t nodes_ops = {
+static hash_table_ops_t nodes_ops = {
         .hash = nodes_hash,
-        .compare = nodes_compare,
+        .key_hash = nodes_key_hash,
+        .key_equal = nodes_key_equal,
+        .equal = NULL,
         .remove_callback = nodes_remove_callback
 };
@@ -277 +274 @@
     fs_index_t index)
 {
-        unsigned long key[] = {
-                [NODES_KEY_SRVC] = service_id,
-                [NODES_KEY_INDEX] = index
+        ht_key_t key = {
+                .index = index,
+                .service_id = service_id
         };
         
-        link_t *link = hash_table_find(&nodes, key);
+        ht_link_t *link = hash_table_find(&nodes, &key);
         if (link) {
                 cdfs_node_t *node =
-                    hash_table_get_instance(link, cdfs_node_t, nh_link);
+                    hash_table_get_inst(link, cdfs_node_t, nh_link);
                 
                 *rfn = FS_NODE(node);
@@ -311 +308 @@
         node->opened = 0;
         
-        link_initialize(&node->nh_link);
         list_initialize(&node->cs_list);
 }
@@ -353 +349 @@
         
         /* Insert the new node into the nodes hash table. */
-        unsigned long key[] = {
-                [NODES_KEY_SRVC] = node->service_id,
-                [NODES_KEY_INDEX] = node->index
-        };
-        
-        hash_table_insert(&nodes, key, &node->nh_link);
+        hash_table_insert(&nodes, &node->nh_link);
         
         *rfn = FS_NODE(node);
@@ -508 +499 @@
 static fs_node_t *get_cached_node(service_id_t service_id, fs_index_t index)
 {
-        unsigned long key[] = {
-                [NODES_KEY_SRVC] = service_id,
-                [NODES_KEY_INDEX] = index
+        ht_key_t key = {
+                .index = index,
+                .service_id = service_id
         };
         
-        link_t *link = hash_table_find(&nodes, key);
+        ht_link_t *link = hash_table_find(&nodes, &key);
         if (link) {
                 cdfs_node_t *node =
-                    hash_table_get_instance(link, cdfs_node_t, nh_link);
+                    hash_table_get_inst(link, cdfs_node_t, nh_link);
                 return FS_NODE(node);
         }
@@ -669 +660 @@
          */
         if ((vol_desc->type != VOL_DESC_PRIMARY) ||
-            (bcmp(vol_desc->standard_ident, CDFS_STANDARD_IDENT, 5) != 0) ||
+            (memcmp(vol_desc->standard_ident, CDFS_STANDARD_IDENT, 5) != 0) ||
             (vol_desc->version != 1)) {
                 block_put(block);
@@ -802 +793 @@
 }
 
+static bool rm_service_id_nodes(ht_link_t *item, void *arg) 
+{
+        service_id_t service_id = *(service_id_t*)arg;
+        cdfs_node_t *node = hash_table_get_inst(item, cdfs_node_t, nh_link);
+        
+        if (node->service_id == service_id) {
+                hash_table_remove_item(&nodes, &node->nh_link);
+        }
+        
+        return true;
+}
+
 static void cdfs_instance_done(service_id_t service_id)
 {
-        unsigned long key[] = {
-                [NODES_KEY_SRVC] = service_id
-        };
-        
-        hash_table_remove(&nodes, key, 1);
+        hash_table_apply(&nodes, rm_service_id_nodes, &service_id);
         block_cache_fini(service_id);
         block_fini(service_id);
@@ -822 +821 @@
     size_t *rbytes)
 {
-        unsigned long key[] = {
-                [NODES_KEY_SRVC] = service_id,
-                [NODES_KEY_INDEX] = index
+        ht_key_t key = {
+                .index = index,
+                .service_id = service_id
         };
         
-        link_t *link = hash_table_find(&nodes, key);
+        ht_link_t *link = hash_table_find(&nodes, &key);
         if (link == NULL)
                 return ENOENT;
         
         cdfs_node_t *node =
-            hash_table_get_instance(link, cdfs_node_t, nh_link);
+            hash_table_get_inst(link, cdfs_node_t, nh_link);
         
         if (!node->processed) {
@@ -912 +911 @@
 }
 
+static bool cache_remove_closed(ht_link_t *item, void *arg)
+{
+        size_t *premove_cnt = (size_t*)arg;
+        
+        /* Some nodes were requested to be removed from the cache. */
+        if (0 < *premove_cnt) {
+                cdfs_node_t *node =     hash_table_get_inst(item, cdfs_node_t, nh_link);
+
+                if (!node->opened) {
+                        hash_table_remove_item(&nodes, item);
+                        
+                        --nodes_cached;
+                        --*premove_cnt;
+                }
+        }
+        
+        /* Only continue if more nodes were requested to be removed. */
+        return 0 < *premove_cnt;
+}
+
 static void cleanup_cache(service_id_t service_id)
 {
         if (nodes_cached > NODE_CACHE_SIZE) {
-                size_t remove = nodes_cached - NODE_CACHE_SIZE;
-                
-                // FIXME: this accesses the internals of the hash table
-                //        and should be rewritten in a clean way
-                
-                for (hash_index_t chain = 0; chain < nodes.entries; chain++) {
-                        for (link_t *link = nodes.entry[chain].head.next;
-                            link != &nodes.entry[chain].head;
-                            link = link->next) {
-                                if (remove == 0)
-                                        return;
-                                
-                                cdfs_node_t *node =
-                                    hash_table_get_instance(link, cdfs_node_t, nh_link);
-                                if (node->opened == 0) {
-                                        link_t *tmp = link;
-                                        link = link->prev;
-                                        
-                                        list_remove(tmp);
-                                        nodes.op->remove_callback(tmp);
-                                        nodes_cached--;
-                                        remove--;
-                                        
-                                        continue;
-                                }
-                        }
-                }
+                size_t remove_cnt = nodes_cached - NODE_CACHE_SIZE;
+                
+                if (0 < remove_cnt)
+                        hash_table_apply(&nodes, cache_remove_closed, &remove_cnt);
         }
 }
@@ -951 +947 @@
                 return EOK;
         
-        unsigned long key[] = {
-                [NODES_KEY_SRVC] = service_id,
-                [NODES_KEY_INDEX] = index
+        ht_key_t key = {
+                .index = index,
+                .service_id = service_id
         };
         
-        link_t *link = hash_table_find(&nodes, key);
+        ht_link_t *link = hash_table_find(&nodes, &key);
         if (link == 0)
                 return ENOENT;
         
         cdfs_node_t *node =
-            hash_table_get_instance(link, cdfs_node_t, nh_link);
+            hash_table_get_inst(link, cdfs_node_t, nh_link);
         
         assert(node->opened > 0);
@@ -1007 +1003 @@
 bool cdfs_init(void)
 {
-        if (!hash_table_create(&nodes, NODES_BUCKETS, 2, &nodes_ops))
+        if (!hash_table_create(&nodes, 0, 0, &nodes_ops))
                 return false;