Changes in uspace/srv/fs/fat/fat_idx.c [ca093b3:991f645] in mainline

File:

• uspace/srv/fs/fat/fat_idx.c (modified) (27 diffs)

uspace/srv/fs/fat/fat_idx.c

@@ -39 +39 @@
 #include "../../vfs/vfs.h"
 #include <errno.h>
-#include <string.h>
+#include <str.h>
 #include <adt/hash_table.h>
 #include <adt/list.h>
 #include <assert.h>
-#include <fibril_sync.h>
+#include <fibril_synch.h>
 
 /** Each instance of this type describes one interval of freed VFS indices. */
@@ -58 +58 @@
 typedef struct {
         link_t          link;
-        dev_handle_t    dev_handle;
+        devmap_handle_t devmap_handle;
 
         /** Next unassigned index. */
@@ -75 +75 @@
 static LIST_INITIALIZE(unused_head);
 
-static void unused_initialize(unused_t *u, dev_handle_t dev_handle)
+static void unused_initialize(unused_t *u, devmap_handle_t devmap_handle)
 {
         link_initialize(&u->link);
-        u->dev_handle = dev_handle;
+        u->devmap_handle = devmap_handle;
         u->next = 0;
         u->remaining = ((uint64_t)((fs_index_t)-1)) + 1;
@@ -84 +84 @@
 }
 
-static unused_t *unused_find(dev_handle_t dev_handle, bool lock)
+static unused_t *unused_find(devmap_handle_t devmap_handle, bool lock)
 {
         unused_t *u;
@@ -93 +93 @@
         for (l = unused_head.next; l != &unused_head; l = l->next) {
                 u = list_get_instance(l, unused_t, link);
-                if (u->dev_handle == dev_handle) 
+                if (u->devmap_handle == devmap_handle) 
                         return u;
         }
@@ -106 +106 @@
 /**
  * Global hash table of all used fat_idx_t structures.
- * The index structures are hashed by the dev_handle, parent node's first
+ * The index structures are hashed by the devmap_handle, parent node's first
  * cluster and index within the parent directory.
  */ 
@@ -120 +120 @@
 static hash_index_t pos_hash(unsigned long key[])
 {
-        dev_handle_t dev_handle = (dev_handle_t)key[UPH_DH_KEY];
+        devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY];
         fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY];
         unsigned pdi = (unsigned)key[UPH_PDI_KEY];
@@ -140 +140 @@
         h |= (pdi & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
             (UPH_BUCKETS_LOG / 2); 
-        h |= (dev_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
+        h |= (devmap_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) <<
             (3 * (UPH_BUCKETS_LOG / 4));
 
@@ -148 +148 @@
 static int pos_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-        dev_handle_t dev_handle = (dev_handle_t)key[UPH_DH_KEY];
-        fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY];
-        unsigned pdi = (unsigned)key[UPH_PDI_KEY];
+        devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY];
+        fat_cluster_t pfc;
+        unsigned pdi;
         fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uph_link);
 
-        return (dev_handle == fidx->dev_handle) && (pfc == fidx->pfc) &&
-            (pdi == fidx->pdi);
+        switch (keys) {
+        case 1:
+                return (devmap_handle == fidx->devmap_handle);
+        case 3:
+                pfc = (fat_cluster_t) key[UPH_PFC_KEY];
+                pdi = (unsigned) key[UPH_PDI_KEY];
+                return (devmap_handle == fidx->devmap_handle) && (pfc == fidx->pfc) &&
+                    (pdi == fidx->pdi);
+        default:
+                assert((keys == 1) || (keys == 3));
+        }
+
+        return 0;
 }
 
@@ -170 +181 @@
 /**
  * Global hash table of all used fat_idx_t structures.
- * The index structures are hashed by the dev_handle and index.
+ * The index structures are hashed by the devmap_handle and index.
  */
 static hash_table_t ui_hash;
@@ -182 +193 @@
 static hash_index_t idx_hash(unsigned long key[])
 {
-        dev_handle_t dev_handle = (dev_handle_t)key[UIH_DH_KEY];
+        devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY];
         fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY];
 
         hash_index_t h;
 
-        h = dev_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1);
+        h = devmap_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1);
         h |= (index & ((1 << (UIH_BUCKETS_LOG / 2)) - 1)) <<
             (UIH_BUCKETS_LOG / 2);
@@ -196 +207 @@
 static int idx_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-        dev_handle_t dev_handle = (dev_handle_t)key[UIH_DH_KEY];
-        fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY];
+        devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY];
+        fs_index_t index;
         fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link);
 
-        return (dev_handle == fidx->dev_handle) && (index == fidx->index);
+        switch (keys) {
+        case 1:
+                return (devmap_handle == fidx->devmap_handle);
+        case 2:
+                index = (fs_index_t) key[UIH_INDEX_KEY];
+                return (devmap_handle == fidx->devmap_handle) &&
+                    (index == fidx->index);
+        default:
+                assert((keys == 1) || (keys == 2));
+        }
+
+        return 0;
 }
 
 static void idx_remove_callback(link_t *item)
 {
-        /* nothing to do */
+        fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link);
+
+        free(fidx);
 }
 
@@ -215 +239 @@
 
 /** Allocate a VFS index which is not currently in use. */
-static bool fat_index_alloc(dev_handle_t dev_handle, fs_index_t *index)
+static bool fat_index_alloc(devmap_handle_t devmap_handle, fs_index_t *index)
 {
         unused_t *u;
         
         assert(index);
-        u = unused_find(dev_handle, true);
+        u = unused_find(devmap_handle, true);
         if (!u)
                 return false;   
@@ -277 +301 @@
 
 /** Free a VFS index, which is no longer in use. */
-static void fat_index_free(dev_handle_t dev_handle, fs_index_t index)
+static void fat_index_free(devmap_handle_t devmap_handle, fs_index_t index)
 {
         unused_t *u;
 
-        u = unused_find(dev_handle, true);
+        u = unused_find(devmap_handle, true);
         assert(u);
 
@@ -339 +363 @@
 }
 
-static fat_idx_t *fat_idx_create(dev_handle_t dev_handle)
+static int fat_idx_create(fat_idx_t **fidxp, devmap_handle_t devmap_handle)
 {
         fat_idx_t *fidx;
@@ -345 +369 @@
         fidx = (fat_idx_t *) malloc(sizeof(fat_idx_t));
         if (!fidx) 
-                return NULL;
-        if (!fat_index_alloc(dev_handle, &fidx->index)) {
+                return ENOMEM;
+        if (!fat_index_alloc(devmap_handle, &fidx->index)) {
                 free(fidx);
-                return NULL;
+                return ENOSPC;
         }
                 
@@ -354 +378 @@
         link_initialize(&fidx->uih_link);
         fibril_mutex_initialize(&fidx->lock);
-        fidx->dev_handle = dev_handle;
+        fidx->devmap_handle = devmap_handle;
         fidx->pfc = FAT_CLST_RES0;      /* no parent yet */
         fidx->pdi = 0;
         fidx->nodep = NULL;
 
-        return fidx;
-}
-
-fat_idx_t *fat_idx_get_new(dev_handle_t dev_handle)
+        *fidxp = fidx;
+        return EOK;
+}
+
+int fat_idx_get_new(fat_idx_t **fidxp, devmap_handle_t devmap_handle)
 {
         fat_idx_t *fidx;
+        int rc;
 
         fibril_mutex_lock(&used_lock);
-        fidx = fat_idx_create(dev_handle);
-        if (!fidx) {
+        rc = fat_idx_create(&fidx, devmap_handle);
+        if (rc != EOK) {
                 fibril_mutex_unlock(&used_lock);
-                return NULL;
+                return rc;
         }
                 
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = dev_handle,
+                [UIH_DH_KEY] = devmap_handle,
                 [UIH_INDEX_KEY] = fidx->index,
         };
@@ -382 +408 @@
         fibril_mutex_unlock(&used_lock);
 
-        return fidx;
+        *fidxp = fidx;
+        return EOK;
 }
 
 fat_idx_t *
-fat_idx_get_by_pos(dev_handle_t dev_handle, fat_cluster_t pfc, unsigned pdi)
+fat_idx_get_by_pos(devmap_handle_t devmap_handle, fat_cluster_t pfc, unsigned pdi)
 {
         fat_idx_t *fidx;
         link_t *l;
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = dev_handle,
+                [UPH_DH_KEY] = devmap_handle,
                 [UPH_PFC_KEY] = pfc,
                 [UPH_PDI_KEY] = pdi,
@@ -401 +428 @@
                 fidx = hash_table_get_instance(l, fat_idx_t, uph_link);
         } else {
-                fidx = fat_idx_create(dev_handle);
-                if (!fidx) {
+                int rc;
+
+                rc = fat_idx_create(&fidx, devmap_handle);
+                if (rc != EOK) {
                         fibril_mutex_unlock(&used_lock);
                         return NULL;
@@ -408 +437 @@
                 
                 unsigned long ikey[] = {
-                        [UIH_DH_KEY] = dev_handle,
+                        [UIH_DH_KEY] = devmap_handle,
                         [UIH_INDEX_KEY] = fidx->index,
                 };
@@ -427 +456 @@
 {
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = idx->dev_handle,
+                [UPH_DH_KEY] = idx->devmap_handle,
                 [UPH_PFC_KEY] = idx->pfc,
                 [UPH_PDI_KEY] = idx->pdi,
@@ -440 +469 @@
 {
         unsigned long pkey[] = {
-                [UPH_DH_KEY] = idx->dev_handle,
+                [UPH_DH_KEY] = idx->devmap_handle,
                 [UPH_PFC_KEY] = idx->pfc,
                 [UPH_PDI_KEY] = idx->pdi,
@@ -451 +480 @@
 
 fat_idx_t *
-fat_idx_get_by_index(dev_handle_t dev_handle, fs_index_t index)
+fat_idx_get_by_index(devmap_handle_t devmap_handle, fs_index_t index)
 {
         fat_idx_t *fidx = NULL;
         link_t *l;
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = dev_handle,
+                [UIH_DH_KEY] = devmap_handle,
                 [UIH_INDEX_KEY] = index,
         };
@@ -478 +507 @@
 {
         unsigned long ikey[] = {
-                [UIH_DH_KEY] = idx->dev_handle,
+                [UIH_DH_KEY] = idx->devmap_handle,
                 [UIH_INDEX_KEY] = idx->index,
         };
+        devmap_handle_t devmap_handle = idx->devmap_handle;
+        fs_index_t index = idx->index;
 
         assert(idx->pfc == FAT_CLST_RES0);
@@ -493 +524 @@
         fibril_mutex_unlock(&used_lock);
         /* Release the VFS index. */
-        fat_index_free(idx->dev_handle, idx->index);
-        /* Deallocate the structure. */
-        free(idx);
+        fat_index_free(devmap_handle, index);
+        /* The index structure itself is freed in idx_remove_callback(). */
 }
 
@@ -516 +546 @@
 }
 
-int fat_idx_init_by_dev_handle(dev_handle_t dev_handle)
+int fat_idx_init_by_devmap_handle(devmap_handle_t devmap_handle)
 {
         unused_t *u;
@@ -524 +554 @@
         if (!u)
                 return ENOMEM;
-        unused_initialize(u, dev_handle);
+        unused_initialize(u, devmap_handle);
         fibril_mutex_lock(&unused_lock);
-        if (!unused_find(dev_handle, false))
+        if (!unused_find(devmap_handle, false)) {
                 list_append(&u->link, &unused_head);
-        else
+        } else {
+                free(u);
                 rc = EEXIST;
+        }
         fibril_mutex_unlock(&unused_lock);
         return rc;
 }
 
-void fat_idx_fini_by_dev_handle(dev_handle_t dev_handle)
-{
-        unused_t *u;
-
-        u = unused_find(dev_handle, true);
+void fat_idx_fini_by_devmap_handle(devmap_handle_t devmap_handle)
+{
+        unsigned long ikey[] = {
+                [UIH_DH_KEY] = devmap_handle
+        };
+        unsigned long pkey[] = {
+                [UPH_DH_KEY] = devmap_handle
+        };
+
+        /*
+         * Remove this instance's index structure from up_hash and ui_hash.
+         * Process up_hash first and ui_hash second because the index structure
+         * is actually removed in idx_remove_callback(). 
+         */
+        fibril_mutex_lock(&used_lock);
+        hash_table_remove(&up_hash, pkey, 1);
+        hash_table_remove(&ui_hash, ikey, 1);
+        fibril_mutex_unlock(&used_lock);
+
+        /*
+         * Free the unused and freed structures for this instance.
+         */
+        unused_t *u = unused_find(devmap_handle, true);
         assert(u);
         list_remove(&u->link);