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

 /*
- * Copyright (c) 2007 Jakub Jermar
+ * Copyright (c) 2008 Jakub Jermar
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * @brief   Implementation of VFS operations for the FAT file system server.
  */
 #include "fat.h"
 #include "../../vfs/vfs.h"
+#include <libfs.h>
 #include <ipc/ipc.h>
 #include <async.h>
 #include <errno.h>
+#include <string.h>
+#include <byteorder.h>
+#include <libadt/hash_table.h>
+#include <libadt/list.h>
+#include <assert.h>
+#include <futex.h>
+#define BS_BLOCK        0
-#define PLB_GET_CHAR(i)     (fat_reg.plb_ro[(i) % PLB_SIZE])
+/** List of free FAT nodes that still contain valid data. */
+LIST_INITIALIZE(ffn_head);
 #define FAT_NAME_LEN        8
 #define FAT_EXT_LEN     3
 #define FAT_PAD         ' '
 #define FAT_DENTRY_UNUSED   0x00
 #define FAT_DENTRY_E5_ESC   0x05
 #define FAT_DENTRY_DOT      0x2e
 #define FAT_DENTRY_ERASED   0xe5
-/** Compare one component of path to a directory entry.
- *
- * @param dentry    Directory entry to compare the path component with.
- * @param start     Index into PLB where the path component starts.
- * @param last      Index of the last character of the path in PLB.
- *
- * @return      Zero on failure or delta such that (index + delta) %
- *          PLB_SIZE points to a new path component in PLB.
- */
-static unsigned match_path_component(fat_dentry_t *dentry, unsigned start,
+static void dentry_name_canonify(fat_dentry_t *d, char *buf)
-    unsigned last)
+{
-    unsigned cur;   /* current position in PLB */
-    int pos;    /* current position in dentry->name or dentry->ext */
-    bool name_processed = false;
-    bool dot_processed = false;
-    bool ext_processed = false;
+    int i;
-    if (last < start)
-        last += PLB_SIZE;
-    for (pos = 0, cur = start; (cur <= last) && (PLB_GET_CHAR(cur) != '/');
-        pos++, cur++) {
-        if (!name_processed) {
-            if ((pos == FAT_NAME_LEN - 1) ||
+    for (i = 0; i < FAT_NAME_LEN; i++) {
-                (dentry->name[pos + 1] == FAT_PAD)) {
-                    /* this is the last character in name */
-                name_processed = true;
-            }
-            if (dentry->name[0] == FAT_PAD) {
+        if (d->name[i] == FAT_PAD) {
-                /* name is empty */
-                name_processed = true;
-            } else if ((pos == 0) && (dentry->name[pos] ==
-                FAT_DENTRY_E5_ESC)) {
-                if (PLB_GET_CHAR(cur) == 0xe5)
-                    continue;
-                else
+            buf++;
-                    return 0;   /* character mismatch */
-            } else {
-                if (PLB_GET_CHAR(cur) == dentry->name[pos])
-                    continue;
-                else
+            break;
-                    return 0;   /* character mismatch */
-            }
+        }
+        if (d->name[i] == FAT_DENTRY_E5_ESC)
+            *buf++ = 0xe5;
+        else
-        if (!dot_processed) {
+            *buf++ = d->name[i];
+    }
-            dot_processed = true;
+    if (d->ext[0] != FAT_PAD)
-            pos = -1;
+        *buf++ = '.';
+    for (i = 0; i < FAT_EXT_LEN; i++) {
-            if (PLB_GET_CHAR(cur) != '.')
+        if (d->ext[i] == FAT_PAD) {
-                return 0;
+            *buf = '\0';
-            continue;
+            return;
+        }
+        if (d->ext[i] == FAT_DENTRY_E5_ESC)
+            *buf++ = 0xe5;
+        else
+            *buf++ = d->ext[i];
+    }
+}
+/* TODO move somewhere else */
+typedef struct {
+    void *data;
+} block_t;
+static block_t *block_get(dev_handle_t dev_handle, off_t offset)
+{
+    return NULL;    /* TODO */
+}
+static void block_put(block_t *block)
+{
+    /* TODO */
+}
+#define FAT_BS(b)       ((fat_bs_t *)((b)->data))
+#define FAT_CLST_RES0   0x0000
+#define FAT_CLST_RES1   0x0001  /* internally used to mark root directory */
+#define FAT_CLST_FIRST  0x0002
+#define FAT_CLST_BAD    0xfff7
+#define FAT_CLST_LAST1  0xfff8
+#define FAT_CLST_LAST8  0xffff
+#define fat_block_get(np, off) \
+    _fat_block_get((np)->idx->dev_handle, (np)->firstc, (off))
+static block_t *
+_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
+{
+    block_t *bb;
+    block_t *b;
+    unsigned bps;
+    unsigned spc;
+    unsigned rscnt;     /* block address of the first FAT */
+    unsigned fatcnt;
+    unsigned rde;
+    unsigned rds;       /* root directory size */
+    unsigned sf;
+    unsigned ssa;       /* size of the system area */
+    unsigned clusters;
+    fat_cluster_t clst = firstc;
+    unsigned i;
+    bb = block_get(dev_handle, BS_BLOCK);
+    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-        if (!ext_processed) {
+    spc = FAT_BS(bb)->spc;
+    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
+    fatcnt = FAT_BS(bb)->fatcnt;
+    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
+    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
+    block_put(bb);
+    rds = (sizeof(fat_dentry_t) * rde) / bps;
+    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
+    ssa = rscnt + fatcnt * sf + rds;
-            if ((pos == FAT_EXT_LEN - 1) ||
+    if (firstc == FAT_CLST_RES1) {
+        /* root directory special case */
+        assert(offset < rds);
+        b = block_get(dev_handle, rscnt + fatcnt * sf + offset);
+        return b;
+    }
+    clusters = offset / spc;
+    for (i = 0; i < clusters; i++) {
+        unsigned fsec;  /* sector offset relative to FAT1 */
+        unsigned fidx;  /* FAT1 entry index */
+        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
+        fsec = (clst * sizeof(fat_cluster_t)) / bps;
+        fidx = clst % (bps / sizeof(fat_cluster_t));
+        /* read FAT1 */
+        b = block_get(dev_handle, rscnt + fsec);
+        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
+        assert(clst != FAT_CLST_BAD);
+        assert(clst < FAT_CLST_LAST1);
+        block_put(b);
+    }
+    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
+        offset % spc);
+    return b;
+}
+static void fat_node_initialize(fat_node_t *node)
+{
+    node->idx = NULL;
+    node->type = 0;
+    link_initialize(&node->ffn_link);
+    node->size = 0;
+    node->lnkcnt = 0;
+    node->refcnt = 0;
+    node->dirty = false;
+}
+static uint16_t fat_bps_get(dev_handle_t dev_handle)
+{
+    block_t *bb;
+    uint16_t bps;
+    bb = block_get(dev_handle, BS_BLOCK);
+    assert(bb != NULL);
+    bps = uint16_t_le2host(FAT_BS(bb)->bps);
+    block_put(bb);
+    return bps;
+}
+typedef enum {
+    FAT_DENTRY_SKIP,
+    FAT_DENTRY_LAST,
+    FAT_DENTRY_VALID
+} fat_dentry_clsf_t;
+static fat_dentry_clsf_t fat_classify_dentry(fat_dentry_t *d)
+{
+    if (d->attr & FAT_ATTR_VOLLABEL) {
+        /* volume label entry */
+        return FAT_DENTRY_SKIP;
+    }
-                (dentry->ext[pos + 1] == FAT_PAD)) {
+    if (d->name[0] == FAT_DENTRY_ERASED) {
-                /* this is the last character in ext */
+        /* not-currently-used entry */
+        return FAT_DENTRY_SKIP;
+    }
+    if (d->name[0] == FAT_DENTRY_UNUSED) {
-                ext_processed = true;
+        /* never used entry */
+        return FAT_DENTRY_LAST;
-            }
+    }
-            if (dentry->ext[0] == FAT_PAD) {
+    if (d->name[0] == FAT_DENTRY_DOT) {
+        /*
+         * Most likely '.' or '..'.
+         * It cannot occur in a regular file name.
+         */
+        return FAT_DENTRY_SKIP;
+    }
+    return FAT_DENTRY_VALID;
+}
+static void fat_node_sync(fat_node_t *node)
+{
+    /* TODO */
+}
+/** Instantiate a FAT in-core node. */
+static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+{
+    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) {
+        /*
+         * We are lucky.
+         * The node is already instantiated in memory.
+         */
+        if (!idx->nodep->refcnt++)
+            list_remove(&nodep->ffn_link);
+        return idx->nodep;
+    }
+    /*
-                /* ext is empty; the match will fail */
+     * We must instantiate the node from the file system.
+     */
+    assert(idx->pfc);
+    if (!list_empty(&ffn_head)) {
+        /* Try to use a cached unused node structure. */
+        nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
+        if (nodep->dirty)
-                ext_processed = true;
+            fat_node_sync(nodep);
+        list_remove(&nodep->ffn_link);
+        nodep->idx->nodep = NULL;
+    } else {
+        /* Try to allocate a new node structure. */
+        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
+        if (!nodep)
+            return NULL;
+    }
+    fat_node_initialize(nodep);
+    bps = fat_bps_get(dev_handle);
+    dps = bps / sizeof(fat_dentry_t);
-            } else if (PLB_GET_CHAR(cur) == dentry->ext[pos]) {
+    /* Read the block that contains the dentry of interest. */
+    b = _fat_block_get(dev_handle, idx->pfc,
+        (idx->pdi * sizeof(fat_dentry_t)) / bps);
+    assert(b);
+    d = ((fat_dentry_t *)b->data) + (idx->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->type = FAT_DIRECTORY;
+    } else {
+        nodep->type = FAT_FILE;
+    }
+    nodep->firstc = uint16_t_le2host(d->firstc);
+    nodep->size = uint32_t_le2host(d->size);
+    nodep->lnkcnt = 1;
+    nodep->refcnt = 1;
+    block_put(b);
+    /* Link the idx structure with the node structure. */
+    nodep->idx = idx;
+    idx->nodep = nodep;
+    return nodep;
+}
+static void fat_node_put(void *node)
+{
+    fat_node_t *nodep = (fat_node_t *)node;
+    if (!--nodep->refcnt) {
+        list_append(&nodep->ffn_link, &ffn_head);
+    }
+}
+static void *fat_create(int flags)
+{
+    return NULL;    /* not supported at the moment */
+}
+static int fat_destroy(void *node)
+{
+    return ENOTSUP; /* not supported at the moment */
+}
+static bool fat_link(void *prnt, void *chld, const char *name)
+{
+    return false;   /* not supported at the moment */
+}
+static int fat_unlink(void *prnt, void *chld)
+{
+    return ENOTSUP; /* not supported at the moment */
+}
+static void *fat_match(void *prnt, const char *component)
+{
+    fat_node_t *parentp = (fat_node_t *)prnt;
+    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_t *d;
+    block_t *b;
+    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;
+        b = fat_block_get(parentp, i);
+        dentries = (i == blocks - 1) ?
+            parentp->size % sizeof(fat_dentry_t) :
+            dps;
+        for (j = 0; j < dentries; j++) {
+            d = ((fat_dentry_t *)b->data) + j;
+            switch (fat_classify_dentry(d)) {
+            case FAT_DENTRY_SKIP:
                 continue;
+            case FAT_DENTRY_LAST:
+                block_put(b);
+                return NULL;
-            } else {
+            default:
+            case FAT_DENTRY_VALID:
+                dentry_name_canonify(d, name);
+                break;
+            }
+            if (strcmp(name, component) == 0) {
-                /* character mismatch */
+                /* hit */
+                fat_idx_t *idx = fat_idx_get_by_pos(
+                    parentp->idx->dev_handle, parentp->firstc,
+                    i * dps + j);
+                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,
+                    idx->index);
+                block_put(b);
-                return 0;
+                return node;
+            }
+        }
-        return 0;   /* extra characters in the component */
+        block_put(b);
+    }
+    return NULL;
+}
-    if (ext_processed || (name_processed && dentry->ext[0] == FAT_PAD))
+static fs_index_t fat_index_get(void *node)
+{
-        return cur - start;
+    fat_node_t *fnodep = (fat_node_t *)node;
-    else
+    if (!fnodep)
         return 0;
+    return fnodep->idx->index;
+}
-void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
+static size_t fat_size_get(void *node)
+{
-    int first = IPC_GET_ARG1(*request);
+    return ((fat_node_t *)node)->size;
-    int second = IPC_GET_ARG2(*request);
-    int dev_handle = IPC_GET_ARG3(*request);
+}
+static unsigned fat_lnkcnt_get(void *node)
+{
+    return ((fat_node_t *)node)->lnkcnt;
+}
+static bool fat_has_children(void *node)
+{
+    fat_node_t *nodep = (fat_node_t *)node;
+    unsigned bps;
+    unsigned dps;
+    unsigned blocks;
+    block_t *b;
+    unsigned i, j;
+    if (nodep->type != FAT_DIRECTORY)
+        return false;
+    bps = fat_bps_get(nodep->idx->dev_handle);
+    dps = bps / sizeof(fat_dentry_t);
+    blocks = nodep->size / bps + (nodep->size % bps != 0);
+    for (i = 0; i < blocks; i++) {
+        unsigned dentries;
+        fat_dentry_t *d;
+        b = fat_block_get(nodep, i);
+        dentries = (i == blocks - 1) ?
+            nodep->size % sizeof(fat_dentry_t) :
+            dps;
+        for (j = 0; j < dentries; j++) {
+            d = ((fat_dentry_t *)b->data) + j;
+            switch (fat_classify_dentry(d)) {
+            case FAT_DENTRY_SKIP:
+                continue;
+            case FAT_DENTRY_LAST:
+                block_put(b);
+                return false;
+            default:
+            case FAT_DENTRY_VALID:
+                block_put(b);
+                return true;
+            }
+            block_put(b);
+            return true;
+        }
+        block_put(b);
+    }
+    return false;
+}
+static void *fat_root_get(dev_handle_t dev_handle)
+{
+    return NULL;    /* TODO */
+}
+static char fat_plb_get_char(unsigned pos)
+{
+    return fat_reg.plb_ro[pos % PLB_SIZE];
+}
+static bool fat_is_directory(void *node)
+{
+    return ((fat_node_t *)node)->type == FAT_DIRECTORY;
+}
+static bool fat_is_file(void *node)
+{
+    return ((fat_node_t *)node)->type == FAT_FILE;
+}
+/** libfs operations */
+libfs_ops_t fat_libfs_ops = {
+    .match = fat_match,
+    .node_get = fat_node_get,
+    .node_put = fat_node_put,
+    .create = fat_create,
+    .destroy = fat_destroy,
+    .link = fat_link,
+    .unlink = fat_unlink,
+    .index_get = fat_index_get,
+    .size_get = fat_size_get,
+    .lnkcnt_get = fat_lnkcnt_get,
+    .has_children = fat_has_children,
+    .root_get = fat_root_get,
+    .plb_get_char = fat_plb_get_char,
+    .is_directory = fat_is_directory,
+    .is_file = fat_is_file
+};
+void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
+{
+    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
+}
 /**
  * @}
  */

Subversion Repositories HelenOS

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