WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/fs/fat/fat_ops.c

 #include <assert.h>
 #include <futex.h>
 #define BS_BLOCK        0
-/** List of free FAT nodes that still contain valid data. */
+/** Futex protecting the list of cached free FAT nodes. */
+static futex_t ffn_futex = FUTEX_INITIALIZER;
+/** List of cached free FAT nodes. */
-LIST_INITIALIZE(ffn_head);
+static LIST_INITIALIZE(ffn_head);
 #define FAT_NAME_LEN        8
 #define FAT_EXT_LEN     3
 #define FAT_PAD         ' '
     return b;
+}
 static void fat_node_initialize(fat_node_t *node)
+{
+    futex_initialize(&node->lock, 1);
     node->idx = NULL;
     node->type = 0;
     link_initialize(&node->ffn_link);
     node->size = 0;
     node->lnkcnt = 0;
 static void fat_node_sync(fat_node_t *node)
+{
     /* TODO */
+}
-/** Instantiate a FAT in-core node. */
+/** Internal version of fat_node_get().
+ *
+ * @param idxp      Locked index structure.
+ */
-static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+static void *fat_node_get_core(fat_idx_t *idxp)
+{
-    fat_idx_t *idx;
     block_t *b;
     fat_dentry_t *d;
     fat_node_t *nodep;
     unsigned bps;
     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.
          */
+        futex_down(&idxp->nodep->lock);
-        if (!idx->nodep->refcnt++)
+        if (!idxp->nodep->refcnt++)
             list_remove(&nodep->ffn_link);
+        futex_up(&idxp->nodep->lock);
-        return idx->nodep;
+        return idxp->nodep;
+    }
     /*
      * We must instantiate the node from the file system.
      */
-    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);
+        idxp_tmp->nodep = NULL;
-        list_remove(&nodep->ffn_link);
+        futex_up(&nodep->lock);
-        nodep->idx->nodep = NULL;
+        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)
             return NULL;
+    }
     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,
+    b = _fat_block_get(idxp->dev_handle, idxp->pfc,
-        (idx->pdi * sizeof(fat_dentry_t)) / bps);
+        (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) {
         /*
          * The only directory which does not have this bit set is the
          * root directory itself. The root directory node is handled
          * and initialized elsewhere.
     nodep->refcnt = 1;
     block_put(b);
     /* Link the idx structure with the node structure. */
-    nodep->idx = idx;
+    nodep->idx = idxp;
-    idx->nodep = nodep;
+    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);
+}
 static void *fat_create(int flags)
+{
     return NULL;    /* not supported at the moment */
     unsigned dps;       /* dentries per sector */
     unsigned blocks;
     fat_dentry_t *d;
     block_t *b;
+    futex_down(&parentp->idx->lock);
     bps = fat_bps_get(parentp->idx->dev_handle);
     dps = bps / sizeof(fat_dentry_t);
     blocks = parentp->size / bps + (parentp->size % bps != 0);
     for (i = 0; i < blocks; i++) {
         unsigned dentries;
             switch (fat_classify_dentry(d)) {
             case FAT_DENTRY_SKIP:
                 continue;
             case FAT_DENTRY_LAST:
                 block_put(b);
+                futex_up(&parentp->idx->lock);
                 return NULL;
             default:
             case FAT_DENTRY_VALID:
                 dentry_name_canonify(d, name);
                 break;
+            }
             if (strcmp(name, component) == 0) {
                 /* hit */
+                void *node;
+                /*
+                 * Assume tree hierarchy for locking.  We
+                 * already have the parent and now we are going
+                 * to lock the child.  Never lock in the oposite
+                 * order.
+                 */
                 fat_idx_t *idx = fat_idx_get_by_pos(
                     parentp->idx->dev_handle, parentp->firstc,
                     i * dps + j);
+                futex_up(&parentp->idx->lock);
                 if (!idx) {
                     /*
                      * Can happen if memory is low or if we
                      * run out of 32-bit indices.
                      */
                     block_put(b);
                     return NULL;
+                }
-                void *node = fat_node_get(idx->dev_handle,
+                node = fat_node_get_core(idx);
-                    idx->index);
+                futex_up(&idx->lock);
                 block_put(b);
                 return node;
+            }
+        }
         block_put(b);
+    }
+    futex_up(&parentp->idx->lock);
     return NULL;
+}
 static fs_index_t fat_index_get(void *node)
+{
     unsigned i, j;
     if (nodep->type != FAT_DIRECTORY)
         return false;
+    futex_down(&nodep->idx->lock);
     bps = fat_bps_get(nodep->idx->dev_handle);
     dps = bps / sizeof(fat_dentry_t);
     blocks = nodep->size / bps + (nodep->size % bps != 0);
             switch (fat_classify_dentry(d)) {
             case FAT_DENTRY_SKIP:
                 continue;
             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;
+        }
         block_put(b);
+    }
+    futex_up(&nodep->idx->lock);
     return false;
+}
 static void *fat_root_get(dev_handle_t dev_handle)
+{

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/fs/fat/fat_ops.c – Rev 2927 → 3009