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

 #include <assert.h>
 #include <futex.h>
 #include <sys/mman.h>
 #include <align.h>
+#define FAT_NODE(node)  ((node) ? (fat_node_t *) (node)->data : NULL)
+#define FS_NODE(node)   ((node) ? (node)->bp : NULL)
 /** 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);
 static void fat_node_initialize(fat_node_t *node)
+{
     futex_initialize(&node->lock, 1);
+    node->bp = NULL;
     node->idx = NULL;
     node->type = 0;
     link_initialize(&node->ffn_link);
     node->size = 0;
     node->lnkcnt = 0;
     block_put(b);
+}
 static fat_node_t *fat_node_get_new(void)
+{
+    fs_node_t *fn;
     fat_node_t *nodep;
     futex_down(&ffn_futex);
     if (!list_empty(&ffn_head)) {
         /* Try to use a cached free node structure. */
         if (nodep->dirty)
             fat_node_sync(nodep);
         idxp_tmp->nodep = NULL;
         futex_up(&nodep->lock);
         futex_up(&idxp_tmp->lock);
+        fn = FS_NODE(nodep);
     } else {
 skip_cache:
         /* Try to allocate a new node structure. */
         futex_up(&ffn_futex);
+        fn = (fs_node_t *)malloc(sizeof(fs_node_t));
+        if (!fn)
+            return NULL;
         nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
-        if (!nodep)
+        if (!nodep) {
+            free(fn);
             return NULL;
+        }
+    }
     fat_node_initialize(nodep);
+    fn->data = nodep;
+    nodep->bp = fn;
     return nodep;
+}
 /** Internal version of fat_node_get().
+ *
  * @param idxp      Locked index structure.
  */
-static void *fat_node_get_core(fat_idx_t *idxp)
+static fat_node_t *fat_node_get_core(fat_idx_t *idxp)
+{
     block_t *b;
     fat_bs_t *bs;
     fat_dentry_t *d;
     fat_node_t *nodep = NULL;
+}
 /*
  * Forward declarations of FAT libfs operations.
  */
-static void *fat_node_get(dev_handle_t, fs_index_t);
+static fs_node_t *fat_node_get(dev_handle_t, fs_index_t);
-static void fat_node_put(void *);
+static void fat_node_put(fs_node_t *);
-static void *fat_create_node(dev_handle_t, int);
+static fs_node_t *fat_create_node(dev_handle_t, int);
-static int fat_destroy_node(void *);
+static int fat_destroy_node(fs_node_t *);
-static int fat_link(void *, void *, const char *);
+static int fat_link(fs_node_t *, fs_node_t *, const char *);
-static int fat_unlink(void *, void *);
+static int fat_unlink(fs_node_t *, fs_node_t *, const char *);
-static void *fat_match(void *, const char *);
+static fs_node_t *fat_match(fs_node_t *, const char *);
-static fs_index_t fat_index_get(void *);
+static fs_index_t fat_index_get(fs_node_t *);
-static size_t fat_size_get(void *);
+static size_t fat_size_get(fs_node_t *);
-static unsigned fat_lnkcnt_get(void *);
+static unsigned fat_lnkcnt_get(fs_node_t *);
-static bool fat_has_children(void *);
+static bool fat_has_children(fs_node_t *);
-static void *fat_root_get(dev_handle_t);
+static fs_node_t *fat_root_get(dev_handle_t);
 static char fat_plb_get_char(unsigned);
-static bool fat_is_directory(void *);
+static bool fat_is_directory(fs_node_t *);
-static bool fat_is_file(void *node);
+static bool fat_is_file(fs_node_t *node);
 /*
  * FAT libfs operations.
  */
 /** Instantiate a FAT in-core node. */
-void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+fs_node_t *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+{
-    void *node;
+    fat_node_t *nodep;
     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);
+    nodep = fat_node_get_core(idxp);
     futex_up(&idxp->lock);
-    return node;
+    return FS_NODE(nodep);
+}
-void fat_node_put(void *node)
+void fat_node_put(fs_node_t *fn)
+{
-    fat_node_t *nodep = (fat_node_t *)node;
+    fat_node_t *nodep = FAT_NODE(fn);
     bool destroy = false;
     futex_down(&nodep->lock);
     if (!--nodep->refcnt) {
         if (nodep->idx) {
              */
             destroy = true;
+        }
+    }
     futex_up(&nodep->lock);
-    if (destroy)
+    if (destroy) {
+        free(nodep->bp);
-        free(node);
+        free(nodep);
+    }
+}
-void *fat_create_node(dev_handle_t dev_handle, int flags)
+fs_node_t *fat_create_node(dev_handle_t dev_handle, int flags)
+{
     fat_idx_t *idxp;
     fat_node_t *nodep;
     fat_bs_t *bs;
     fat_cluster_t mcl, lcl;
         return NULL;
+    }
     idxp = fat_idx_get_new(dev_handle);
     if (!idxp) {
         fat_free_clusters(bs, dev_handle, mcl);
-        fat_node_put(nodep);
+        fat_node_put(FS_NODE(nodep));
         return NULL;
+    }
     /* idxp->lock held */
     if (flags & L_DIRECTORY) {
         int i;
     nodep->idx = idxp;
     idxp->nodep = nodep;
     futex_up(&idxp->lock);
-    return nodep;
+    return FS_NODE(nodep);
+}
-int fat_destroy_node(void *node)
+int fat_destroy_node(fs_node_t *fn)
+{
-    fat_node_t *nodep = (fat_node_t *)node;
+    fat_node_t *nodep = FAT_NODE(fn);
     fat_bs_t *bs;
     /*
      * The node is not reachable from the file system. This means that the
      * link count should be zero and that the index structure cannot be
     assert(nodep->lnkcnt == 0);
     /*
      * The node may not have any children.
      */
-    assert(fat_has_children(node) == false);
+    assert(fat_has_children(fn) == false);
     bs = block_bb_get(nodep->idx->dev_handle);
     if (nodep->firstc != FAT_CLST_RES0) {
         assert(nodep->size);
         /* Free all clusters allocated to the node. */
         fat_free_clusters(bs, nodep->idx->dev_handle, nodep->firstc);
+    }
     fat_idx_destroy(nodep->idx);
+    free(nodep->bp);
     free(nodep);
     return EOK;
+}
-int fat_link(void *prnt, void *chld, const char *name)
+int fat_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+{
-    fat_node_t *parentp = (fat_node_t *)prnt;
+    fat_node_t *parentp = FAT_NODE(pfn);
-    fat_node_t *childp = (fat_node_t *)chld;
+    fat_node_t *childp = FAT_NODE(cfn);
     fat_dentry_t *d;
     fat_bs_t *bs;
     block_t *b;
     int i, j;
     uint16_t bps;
     unsigned dps;
     unsigned blocks;
+    fat_cluster_t mcl, lcl;
+    int rc;
     futex_down(&childp->lock);
     if (childp->lnkcnt == 1) {
         /*
          * On FAT, we don't support multiple hard links.
                 goto hit;
+            }
+        }
         block_put(b);
+    }
+    j = 0;
     /*
      * We need to grow the parent in order to create a new unused dentry.
      */
+    if (parentp->idx->pfc == FAT_CLST_ROOT) {
+        /* Can't grow the root directory. */
-    futex_up(&parentp->idx->lock);
+        futex_up(&parentp->idx->lock);
-    return ENOTSUP; /* XXX */
+        return ENOSPC;
+    }
+    rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
+    if (rc != EOK) {
+        futex_up(&parentp->idx->lock);
+        return rc;
+    }
+    fat_append_clusters(bs, parentp, mcl);
+    b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NOREAD);
+    d = (fat_dentry_t *)b->data;
+    /*
+     * Clear all dentries in the block except for the first one (the first
+     * dentry will be cleared in the next step).
+     */
+    memset(d + 1, 0, bps - sizeof(fat_dentry_t));
 hit:
     /*
      * At this point we only establish the link between the parent and the
      * child.  The dentry, except of the name and the extension, will remain
-     * uninitialized until the the corresponding node is synced. Thus the
+     * uninitialized until the corresponding node is synced. Thus the valid
-     * valid dentry data is kept in the child node structure.
+     * dentry data is kept in the child node structure.
      */
     memset(d, 0, sizeof(fat_dentry_t));
     fat_dentry_name_set(d, name);
     b->dirty = true;        /* need to sync block */
     block_put(b);
      * not use them anyway, so this is rather a sign of our good will.
      */
     b = fat_block_get(bs, childp, 0, BLOCK_FLAGS_NONE);
     d = (fat_dentry_t *)b->data;
     if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
-        strcmp(d->name, FAT_NAME_DOT) == 0) {
+        str_cmp(d->name, FAT_NAME_DOT) == 0) {
         memset(d, 0, sizeof(fat_dentry_t));
-        strcpy(d->name, FAT_NAME_DOT);
+        str_cpy(d->name, 8, FAT_NAME_DOT);
-        strcpy(d->ext, FAT_EXT_PAD);
+        str_cpy(d->ext, 3, FAT_EXT_PAD);
         d->attr = FAT_ATTR_SUBDIR;
         d->firstc = host2uint16_t_le(childp->firstc);
         /* TODO: initialize also the date/time members. */
+    }
     d++;
     if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
-        strcmp(d->name, FAT_NAME_DOT_DOT) == 0) {
+        str_cmp(d->name, FAT_NAME_DOT_DOT) == 0) {
         memset(d, 0, sizeof(fat_dentry_t));
-        strcpy(d->name, FAT_NAME_DOT_DOT);
+        str_cpy(d->name, 8, FAT_NAME_DOT_DOT);
-        strcpy(d->ext, FAT_EXT_PAD);
+        str_cpy(d->ext, 3, FAT_EXT_PAD);
         d->attr = FAT_ATTR_SUBDIR;
         d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
             host2uint16_t_le(FAT_CLST_RES0) :
             host2uint16_t_le(parentp->firstc);
         /* TODO: initialize also the date/time members. */
     fat_idx_hashin(childp->idx);
     return EOK;
+}
-int fat_unlink(void *prnt, void *chld)
+int fat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
+{
-    fat_node_t *parentp = (fat_node_t *)prnt;
+    fat_node_t *parentp = FAT_NODE(pfn);
-    fat_node_t *childp = (fat_node_t *)chld;
+    fat_node_t *childp = FAT_NODE(cfn);
     fat_bs_t *bs;
     fat_dentry_t *d;
     uint16_t bps;
     block_t *b;
+    if (!parentp)
+        return EBUSY;
+    if (fat_has_children(cfn))
+        return ENOTEMPTY;
     futex_down(&parentp->lock);
     futex_down(&childp->lock);
     assert(childp->lnkcnt == 1);
     futex_down(&childp->idx->lock);
     bs = block_bb_get(childp->idx->dev_handle);
     futex_up(&parentp->lock);
     return EOK;
+}
-void *fat_match(void *prnt, const char *component)
+fs_node_t *fat_match(fs_node_t *pfn, const char *component)
+{
     fat_bs_t *bs;
-    fat_node_t *parentp = (fat_node_t *)prnt;
+    fat_node_t *parentp = FAT_NODE(pfn);
     char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
     unsigned i, j;
     unsigned bps;       /* bytes per sector */
     unsigned dps;       /* dentries per sector */
     unsigned blocks;
                 fat_dentry_name_get(d, name);
                 break;
+            }
             if (fat_dentry_namecmp(name, component) == 0) {
                 /* hit */
-                void *node;
+                fat_node_t *nodep;
                 /*
                  * 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.
                      * run out of 32-bit indices.
                      */
                     block_put(b);
                     return NULL;
+                }
-                node = fat_node_get_core(idx);
+                nodep = fat_node_get_core(idx);
                 futex_up(&idx->lock);
                 block_put(b);
-                return node;
+                return FS_NODE(nodep);
+            }
+        }
         block_put(b);
+    }
     futex_up(&parentp->idx->lock);
     return NULL;
+}
-fs_index_t fat_index_get(void *node)
+fs_index_t fat_index_get(fs_node_t *fn)
+{
-    fat_node_t *fnodep = (fat_node_t *)node;
-    if (!fnodep)
-        return 0;
-    return fnodep->idx->index;
+    return FAT_NODE(fn)->idx->index;
+}
-size_t fat_size_get(void *node)
+size_t fat_size_get(fs_node_t *fn)
+{
-    return ((fat_node_t *)node)->size;
+    return FAT_NODE(fn)->size;
+}
-unsigned fat_lnkcnt_get(void *node)
+unsigned fat_lnkcnt_get(fs_node_t *fn)
+{
-    return ((fat_node_t *)node)->lnkcnt;
+    return FAT_NODE(fn)->lnkcnt;
+}
-bool fat_has_children(void *node)
+bool fat_has_children(fs_node_t *fn)
+{
     fat_bs_t *bs;
-    fat_node_t *nodep = (fat_node_t *)node;
+    fat_node_t *nodep = FAT_NODE(fn);
     unsigned bps;
     unsigned dps;
     unsigned blocks;
     block_t *b;
     unsigned i, j;
     futex_up(&nodep->idx->lock);
     return false;
+}
-void *fat_root_get(dev_handle_t dev_handle)
+fs_node_t *fat_root_get(dev_handle_t dev_handle)
+{
     return fat_node_get(dev_handle, 0);
+}
 char fat_plb_get_char(unsigned pos)
+{
     return fat_reg.plb_ro[pos % PLB_SIZE];
+}
-bool fat_is_directory(void *node)
+bool fat_is_directory(fs_node_t *fn)
+{
-    return ((fat_node_t *)node)->type == FAT_DIRECTORY;
+    return FAT_NODE(fn)->type == FAT_DIRECTORY;
+}
-bool fat_is_file(void *node)
+bool fat_is_file(fs_node_t *fn)
+{
-    return ((fat_node_t *)node)->type == FAT_FILE;
+    return FAT_NODE(fn)->type == FAT_FILE;
+}
 /** libfs operations */
 libfs_ops_t fat_libfs_ops = {
     .match = fat_match,
     fat_bs_t *bs;
     uint16_t bps;
     uint16_t rde;
     int rc;
+    /* accept the mount options */
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_write_receive(&callid, &size)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    char *opts = malloc(size + 1);
+    if (!opts) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
+    if (retval != EOK) {
+        ipc_answer_0(rid, retval);
+        free(opts);
+        return;
+    }
+    opts[size] = '\0';
     /* initialize libblock */
     rc = block_init(dev_handle, BS_SIZE);
     if (rc != EOK) {
         ipc_answer_0(rid, rc);
         return;
         ipc_answer_0(rid, rc);
         return;
+    }
     /* Initialize the root node. */
+    fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t));
+    if (!rfn) {
+        block_fini(dev_handle);
+        fat_idx_fini_by_dev_handle(dev_handle);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
     fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
     if (!rootp) {
+        free(rfn);
         block_fini(dev_handle);
         fat_idx_fini_by_dev_handle(dev_handle);
         ipc_answer_0(rid, ENOMEM);
         return;
+    }
     fat_node_initialize(rootp);
     fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
     if (!ridxp) {
-        block_fini(dev_handle);
+        free(rfn);
         free(rootp);
+        block_fini(dev_handle);
         fat_idx_fini_by_dev_handle(dev_handle);
         ipc_answer_0(rid, ENOMEM);
         return;
+    }
     assert(ridxp->index == 0);
     rootp->refcnt = 1;
     rootp->lnkcnt = 0;  /* FS root is not linked */
     rootp->size = rde * sizeof(fat_dentry_t);
     rootp->idx = ridxp;
     ridxp->nodep = rootp;
+    rootp->bp = rfn;
+    rfn->data = rootp;
     futex_up(&ridxp->lock);
     ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
+}
 void fat_read(ipc_callid_t rid, ipc_call_t *request)
+{
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     off_t pos = (off_t)IPC_GET_ARG3(*request);
-    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
+    fs_node_t *fn = fat_node_get(dev_handle, index);
+    fat_node_t *nodep;
     fat_bs_t *bs;
     uint16_t bps;
     size_t bytes;
     block_t *b;
-    if (!nodep) {
+    if (!fn) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
+    nodep = FAT_NODE(fn);
     ipc_callid_t callid;
     size_t len;
     if (!ipc_data_read_receive(&callid, &len)) {
-        fat_node_put(nodep);
+        fat_node_put(fn);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
+    }
+            }
             block_put(b);
             bnum++;
+        }
 miss:
-        fat_node_put(nodep);
+        fat_node_put(fn);
         ipc_answer_0(callid, ENOENT);
         ipc_answer_1(rid, ENOENT, 0);
         return;
 hit:
-        (void) ipc_data_read_finalize(callid, name, strlen(name) + 1);
+        (void) ipc_data_read_finalize(callid, name, str_size(name) + 1);
         bytes = (pos - spos) + 1;
+    }
-    fat_node_put(nodep);
+    fat_node_put(fn);
     ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
+}
 void fat_write(ipc_callid_t rid, ipc_call_t *request)
+{
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     off_t pos = (off_t)IPC_GET_ARG3(*request);
-    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
+    fs_node_t *fn = fat_node_get(dev_handle, index);
+    fat_node_t *nodep;
     fat_bs_t *bs;
     size_t bytes;
     block_t *b;
     uint16_t bps;
     unsigned spc;
     unsigned bpc;       /* bytes per cluster */
     off_t boundary;
     int flags = BLOCK_FLAGS_NONE;
-    if (!nodep) {
+    if (!fn) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
+    nodep = FAT_NODE(fn);
     ipc_callid_t callid;
     size_t len;
     if (!ipc_data_write_receive(&callid, &len)) {
-        fat_node_put(nodep);
+        fat_node_put(fn);
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
+    }
         if (pos + bytes > nodep->size) {
             nodep->size = pos + bytes;
             nodep->dirty = true;    /* need to sync node */
+        }
         ipc_answer_2(rid, EOK, bytes, nodep->size);
-        fat_node_put(nodep);
+        fat_node_put(fn);
         return;
     } else {
         /*
          * This is the more difficult case. We must allocate new
          * clusters for the node and zero them out.
         nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
         /* create an independent chain of nclsts clusters in all FATs */
         status = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
         if (status != EOK) {
             /* could not allocate a chain of nclsts clusters */
-            fat_node_put(nodep);
+            fat_node_put(fn);
             ipc_answer_0(callid, status);
             ipc_answer_0(rid, status);
             return;
+        }
         /* zero fill any gaps */
          */
         fat_append_clusters(bs, nodep, mcl);
         nodep->size = pos + bytes;
         nodep->dirty = true;        /* need to sync node */
         ipc_answer_2(rid, EOK, bytes, nodep->size);
-        fat_node_put(nodep);
+        fat_node_put(fn);
         return;
+    }
+}
 void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
+{
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     size_t size = (off_t)IPC_GET_ARG3(*request);
-    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
+    fs_node_t *fn = fat_node_get(dev_handle, index);
+    fat_node_t *nodep;
     fat_bs_t *bs;
     uint16_t bps;
     uint8_t spc;
     unsigned bpc;   /* bytes per cluster */
     int rc;
-    if (!nodep) {
+    if (!fn) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
+    nodep = FAT_NODE(fn);
     bs = block_bb_get(dev_handle);
     bps = uint16_t_le2host(bs->bps);
     spc = bs->spc;
     bpc = bps * spc;
+        }
         nodep->size = size;
         nodep->dirty = true;        /* need to sync node */
         rc = EOK;
+    }
-    fat_node_put(nodep);
+    fat_node_put(fn);
     ipc_answer_0(rid, rc);
     return;
+}
 void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
+{
     dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     int rc;
-    fat_node_t *nodep = fat_node_get(dev_handle, index);
+    fs_node_t *fn = fat_node_get(dev_handle, index);
-    if (!nodep) {
+    if (!fn) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
-    rc = fat_destroy_node(nodep);
+    rc = fat_destroy_node(fn);
     ipc_answer_0(rid, rc);
+}
 /**
  * @}

Subversion Repositories HelenOS

(root)//branches/tracing/uspace/srv/fs/fat/fat_ops.c – Rev 3675 → 4377