Changeset add5835 in mainline for uspace/srv/fs/fat/fat_ops.c

Timestamp:

2008-05-17T20:10:54Z (17 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

e811bde

Parents:

78a1b7b

Message:

Add locks to FAT index structures, FAT in-core node structures. Add futex to
protect the list of free cached FAT in-core nodes. Make fat_node_get() and
fat_node_put() and some other functions aware of these new locks.

File:

• uspace/srv/fs/fat/fat_ops.c (modified) (12 diffs)

uspace/srv/fs/fat/fat_ops.c

@@ -51 +51 @@
 #define BS_BLOCK                0
 
-/** List of free FAT nodes that still contain valid data. */
-LIST_INITIALIZE(ffn_head);
+/** Futex protecting the list of cached free FAT nodes. */
+static futex_t ffn_futex = FUTEX_INITIALIZER;
+
+/** List of cached free FAT nodes. */
+static LIST_INITIALIZE(ffn_head);
 
 #define FAT_NAME_LEN            8
@@ -180 +183 @@
 static void fat_node_initialize(fat_node_t *node)
 {
+        futex_initialize(&node->lock, 1);
         node->idx = NULL;
         node->type = 0;
@@ -237 +241 @@
 }
 
-/** Instantiate a FAT in-core node. */
-static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
-{
-        fat_idx_t *idx;
+/** Internal version of fat_node_get().
+ *
+ * @param idxp          Locked index structure.
+ */
+static void *fat_node_get_core(fat_idx_t *idxp)
+{
         block_t *b;
         fat_dentry_t *d;
@@ -247 +253 @@
         unsigned dps;
 
-        idx = fat_idx_get_by_index(dev_handle, index);
-        if (!idx)
-                return NULL;
-
-        if (idx->nodep) {
+        if (idxp->nodep) {
                 /*
                  * We are lucky.
                  * The node is already instantiated in memory.
                  */
-                if (!idx->nodep->refcnt++)
+                futex_down(&idxp->nodep->lock);
+                if (!idxp->nodep->refcnt++)
                         list_remove(&nodep->ffn_link);
-                return idx->nodep;
+                futex_up(&idxp->nodep->lock);
+                return idxp->nodep;
         }
 
@@ -265 +269 @@
          */
         
-        assert(idx->pfc);
-
+        assert(idxp->pfc);
+
+        futex_down(&ffn_futex);
         if (!list_empty(&ffn_head)) {
-                /* Try to use a cached unused node structure. */
+                /* Try to use a cached free node structure. */
+                fat_idx_t *idxp_tmp;
                 nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
+                if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
+                        goto skip_cache;
+                idxp_tmp = nodep->idx;
+                if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
+                        futex_up(&nodep->lock);
+                        goto skip_cache;
+                }
+                list_remove(&nodep->ffn_link);
+                futex_up(&ffn_futex);
                 if (nodep->dirty)
                         fat_node_sync(nodep);
-                list_remove(&nodep->ffn_link);
-                nodep->idx->nodep = NULL;
+                idxp_tmp->nodep = NULL;
+                futex_up(&nodep->lock);
+                futex_up(&idxp_tmp->lock);
         } else {
+skip_cache:
                 /* Try to allocate a new node structure. */
+                futex_up(&ffn_futex);
                 nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
                 if (!nodep)
@@ -282 +300 @@
         fat_node_initialize(nodep);
 
-        bps = fat_bps_get(dev_handle);
+        bps = fat_bps_get(idxp->dev_handle);
         dps = bps / sizeof(fat_dentry_t);
 
         /* Read the block that contains the dentry of interest. */
-        b = _fat_block_get(dev_handle, idx->pfc,
-            (idx->pdi * sizeof(fat_dentry_t)) / bps);
+        b = _fat_block_get(idxp->dev_handle, idxp->pfc,
+            (idxp->pdi * sizeof(fat_dentry_t)) / bps);
         assert(b);
 
-        d = ((fat_dentry_t *)b->data) + (idx->pdi % dps);
+        d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
         if (d->attr & FAT_ATTR_SUBDIR) {
                 /* 
@@ -309 +327 @@
 
         /* Link the idx structure with the node structure. */
-        nodep->idx = idx;
-        idx->nodep = nodep;
+        nodep->idx = idxp;
+        idxp->nodep = nodep;
 
         return nodep;
 }
 
+/** Instantiate a FAT in-core node. */
+static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+{
+        void *node;
+        fat_idx_t *idxp;
+
+        idxp = fat_idx_get_by_index(dev_handle, index);
+        if (!idxp)
+                return NULL;
+        /* idxp->lock held */
+        node = fat_node_get_core(idxp);
+        futex_up(&idxp->lock);
+        return node;
+}
+
 static void fat_node_put(void *node)
 {
         fat_node_t *nodep = (fat_node_t *)node;
 
+        futex_down(&nodep->lock);
         if (!--nodep->refcnt) {
+                futex_down(&ffn_futex);
                 list_append(&nodep->ffn_link, &ffn_head);
-        }
+                futex_up(&ffn_futex);
+        }
+        futex_up(&nodep->lock);
 }
 
@@ -380 +417 @@
                         if (strcmp(name, component) == 0) {
                                 /* hit */
+                                void *node;
                                 fat_idx_t *idx = fat_idx_get_by_pos(
                                     parentp->idx->dev_handle, parentp->firstc,
@@ -391 +429 @@
                                         return NULL;
                                 }
-                                void *node = fat_node_get(idx->dev_handle,
-                                    idx->index);
+                                node = fat_node_get_core(idx);
+                                futex_up(&idx->lock);
                                 block_put(b);
                                 return node;
@@ -433 +471 @@
                 return false;
 
+        futex_down(&nodep->idx->lock);
         bps = fat_bps_get(nodep->idx->dev_handle);
         dps = bps / sizeof(fat_dentry_t);
@@ -453 +492 @@
                         case FAT_DENTRY_LAST:
                                 block_put(b);
+                                futex_up(&nodep->idx->lock);
                                 return false;
                         default:
                         case FAT_DENTRY_VALID:
                                 block_put(b);
+                                futex_up(&nodep->idx->lock);
                                 return true;
                         }
                         block_put(b);
+                        futex_up(&nodep->idx->lock);
                         return true;
                 }
@@ -465 +507 @@
         }
 
+        futex_up(&nodep->idx->lock);
         return false;
 }