WebSVN – HelenOS – Path Comparison – / – /branches/network/uspace/srv/fs/ Rev HEAD and /trunk/uspace/srv/fs Rev 2728

Ignore whitespace Rev HEAD → Rev 2728

/trunk/uspace/srv/fs/devfs/devfs.h
File deleted

/trunk/uspace/srv/fs/devfs/Makefile
File deleted

/trunk/uspace/srv/fs/devfs/devfs_ops.h
File deleted

/trunk/uspace/srv/fs/devfs/devfs.c
File deleted

/trunk/uspace/srv/fs/devfs/devfs_ops.c
File deleted

/trunk/uspace/srv/fs/tmpfs/tmpfs_dump.c
File deleted

 /trunk/uspace/srv/fs/tmpfs/tmpfs_ops.c
 ,406 → 45,310
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <dirent.h>
 #include <assert.h>
 #include <sys/types.h>
-#include <adt/hash_table.h>
+#include <libadt/hash_table.h>
 #include <as.h>
-#include <libfs.h>
 #define min(a, b)       ((a) < (b) ? (a) : (b))
 #define max(a, b)       ((a) > (b) ? (a) : (b))
-#define NODES_BUCKETS   256
+#define PLB_GET_CHAR(i)     (tmpfs_reg.plb_ro[(i) % PLB_SIZE])
-/** All root nodes have index 0. */
-#define TMPFS_SOME_ROOT     0
-/** Global counter for assigning node indices. Shared by all instances. */
-fs_index_t tmpfs_next_index = 1;
+#define DENTRIES_BUCKETS    256
 /*
- * Implementation of the libfs interface.
+ * Hash table of all directory entries.
  */
+hash_table_t dentries;
-/* Forward declarations of static functions. */
-static fs_node_t *tmpfs_match(fs_node_t *, const char *);
-static fs_node_t *tmpfs_node_get(dev_handle_t, fs_index_t);
-static void tmpfs_node_put(fs_node_t *);
-static fs_node_t *tmpfs_create_node(dev_handle_t, int);
-static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
-static int tmpfs_unlink_node(fs_node_t *, fs_node_t *, const char *);
-static int tmpfs_destroy_node(fs_node_t *);
-/* Implementation of helper functions. */
-static fs_index_t tmpfs_index_get(fs_node_t *fn)
+static hash_index_t dentries_hash(unsigned long *key)
 {
-    return TMPFS_NODE(fn)->index;
+    return *key % DENTRIES_BUCKETS;
 }
-static size_t tmpfs_size_get(fs_node_t *fn)
+static int dentries_compare(unsigned long *key, hash_count_t keys,
+    link_t *item)
 {
-    return TMPFS_NODE(fn)->size;
+    tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
+        dh_link);
+    return dentry->index == *key;
 }
-static unsigned tmpfs_lnkcnt_get(fs_node_t *fn)
+static void dentries_remove_callback(link_t *item)
 {
-    return TMPFS_NODE(fn)->lnkcnt;
 }
-static bool tmpfs_has_children(fs_node_t *fn)
-{
-    return !list_empty(&TMPFS_NODE(fn)->cs_head);
-}
-static fs_node_t *tmpfs_root_get(dev_handle_t dev_handle)
-{
-    return tmpfs_node_get(dev_handle, TMPFS_SOME_ROOT);
-}
-static char tmpfs_plb_get_char(unsigned pos)
-{
-    return tmpfs_reg.plb_ro[pos % PLB_SIZE];
-}
-static bool tmpfs_is_directory(fs_node_t *fn)
-{
-    return TMPFS_NODE(fn)->type == TMPFS_DIRECTORY;
-}
-static bool tmpfs_is_file(fs_node_t *fn)
-{
-    return TMPFS_NODE(fn)->type == TMPFS_FILE;
-}
-/** libfs operations */
-libfs_ops_t tmpfs_libfs_ops = {
-    .match = tmpfs_match,
-    .node_get = tmpfs_node_get,
-    .node_put = tmpfs_node_put,
-    .create = tmpfs_create_node,
-    .destroy = tmpfs_destroy_node,
-    .link = tmpfs_link_node,
-    .unlink = tmpfs_unlink_node,
-    .index_get = tmpfs_index_get,
-    .size_get = tmpfs_size_get,
-    .lnkcnt_get = tmpfs_lnkcnt_get,
-    .has_children = tmpfs_has_children,
-    .root_get = tmpfs_root_get,
-    .plb_get_char = tmpfs_plb_get_char,
-    .is_directory = tmpfs_is_directory,
-    .is_file = tmpfs_is_file
+/** TMPFS dentries hash table operations. */
+hash_table_operations_t dentries_ops = {
+    .hash = dentries_hash,
+    .compare = dentries_compare,
+    .remove_callback = dentries_remove_callback
 };
-/** Hash table of all TMPFS nodes. */
-hash_table_t nodes;
+unsigned tmpfs_next_index = 1;
-#define NODES_KEY_INDEX 0
-#define NODES_KEY_DEV   1
-/* Implementation of hash table interface for the nodes hash table. */
-static hash_index_t nodes_hash(unsigned long key[])
+static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
 {
-    return key[NODES_KEY_INDEX] % NODES_BUCKETS;
+    dentry->index = 0;
+    dentry->parent = NULL;
+    dentry->sibling = NULL;
+    dentry->child = NULL;
+    dentry->name = NULL;
+    dentry->type = TMPFS_NONE;
+    dentry->size = 0;
+    dentry->data = NULL;
+    link_initialize(&dentry->dh_link);
 }
-static int nodes_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-    tmpfs_node_t *nodep = hash_table_get_instance(item, tmpfs_node_t,
-        nh_link);
-    return (nodep->index == key[NODES_KEY_INDEX] &&
-        nodep->dev_handle == key[NODES_KEY_DEV]);
-}
+/*
+ * For now, we don't distinguish between different dev_handles/instances. All
+ * requests resolve to the only instance, rooted in the following variable.
+ */
+static tmpfs_dentry_t *root;
-static void nodes_remove_callback(link_t *item)
+static bool tmpfs_init(void)
 {
-}
+    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
+        return false;
-/** TMPFS nodes hash table operations. */
-hash_table_operations_t nodes_ops = {
-    .hash = nodes_hash,
-    .compare = nodes_compare,
-    .remove_callback = nodes_remove_callback
-};
+    root = (tmpfs_dentry_t *) malloc(sizeof(tmpfs_dentry_t));
+    if (!root)
+        return false;
+    tmpfs_dentry_initialize(root);
+    root->index = tmpfs_next_index++;
+    root->name = "";
+    root->type = TMPFS_DIRECTORY;
+    hash_table_insert(&dentries, &root->index, &root->dh_link);
-static void tmpfs_node_initialize(tmpfs_node_t *nodep)
-{
-    nodep->bp = NULL;
-    nodep->index = 0;
-    nodep->dev_handle = 0;
-    nodep->type = TMPFS_NONE;
-    nodep->lnkcnt = 0;
-    nodep->size = 0;
-    nodep->data = NULL;
-    link_initialize(&nodep->nh_link);
-    list_initialize(&nodep->cs_head);
-}
-static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentryp)
-{
-    link_initialize(&dentryp->link);
-    dentryp->name = NULL;
-    dentryp->node = NULL;
-}
-bool tmpfs_init(void)
-{
-    if (!hash_table_create(&nodes, NODES_BUCKETS, 2, &nodes_ops))
-        return false;
     return true;
 }
-static bool tmpfs_instance_init(dev_handle_t dev_handle)
+/** Compare one component of path to a directory entry.
+ *
+ * @param dentry    Directory entry to compare the path component with.
+ * @param component Array of characters holding component name.
+ *
+ * @return      True on match, false otherwise.
+ */
+static bool match_component(tmpfs_dentry_t *dentry, const char *component)
 {
-    fs_node_t *rfn;
-    rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
-    if (!rfn)
-        return false;
-    TMPFS_NODE(rfn)->lnkcnt = 0;    /* FS root is not linked */
-    return true;
+    return !strcmp(dentry->name, component);
 }
-fs_node_t *tmpfs_match(fs_node_t *pfn, const char *component)
+static unsigned long create_node(tmpfs_dentry_t *dentry,
+    const char *component, int lflag)
 {
-    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
-    link_t *lnk;
+    assert(dentry->type == TMPFS_DIRECTORY);
+    assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
-    for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
-        lnk = lnk->next) {
-        tmpfs_dentry_t *dentryp = list_get_instance(lnk, tmpfs_dentry_t,
-            link);
-        if (!str_cmp(dentryp->name, component))
-            return FS_NODE(dentryp->node);
+    tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
+    if (!node)
+        return 0;
+    size_t len = strlen(component);
+    char *name = malloc(len + 1);
+    if (!name) {
+        free(node);
+        return 0;
     }
+    strcpy(name, component);
-    return NULL;
-}
+    tmpfs_dentry_initialize(node);
+    node->index = tmpfs_next_index++;
+    node->name = name;
+    node->parent = dentry;
+    if (lflag & L_DIRECTORY)
+        node->type = TMPFS_DIRECTORY;
+    else
+        node->type = TMPFS_FILE;
-fs_node_t *tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
-{
-    unsigned long key[] = {
-        [NODES_KEY_INDEX] = index,
-        [NODES_KEY_DEV] = dev_handle
-    };
-    link_t *lnk = hash_table_find(&nodes, key);
-    if (!lnk)
-        return NULL;
-    return FS_NODE(hash_table_get_instance(lnk, tmpfs_node_t, nh_link));
-}
+    /* Insert the new node into the namespace. */
+    if (dentry->child) {
+        tmpfs_dentry_t *tmp = dentry->child;
+        while (tmp->sibling)
+            tmp = tmp->sibling;
+        tmp->sibling = node;
+    } else {
+        dentry->child = node;
+    }
-void tmpfs_node_put(fs_node_t *fn)
-{
-    /* nothing to do */
+    /* Insert the new node into the dentry hash table. */
+    hash_table_insert(&dentries, &node->index, &node->dh_link);
+    return node->index;
 }
-fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
+static int destroy_component(tmpfs_dentry_t *dentry)
 {
-    assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
-    tmpfs_node_t *nodep = malloc(sizeof(tmpfs_node_t));
-    if (!nodep)
-        return NULL;
-    tmpfs_node_initialize(nodep);
-    nodep->bp = malloc(sizeof(fs_node_t));
-    if (!nodep->bp) {
-        free(nodep);
-        return NULL;
-    }
-    fs_node_initialize(nodep->bp);
-    nodep->bp->data = nodep;    /* link the FS and TMPFS nodes */
-    if (!tmpfs_root_get(dev_handle))
-        nodep->index = TMPFS_SOME_ROOT;
-    else
-        nodep->index = tmpfs_next_index++;
-    nodep->dev_handle = dev_handle;
-    if (lflag & L_DIRECTORY)
-        nodep->type = TMPFS_DIRECTORY;
-    else
-        nodep->type = TMPFS_FILE;
-    /* Insert the new node into the nodes hash table. */
-    unsigned long key[] = {
-        [NODES_KEY_INDEX] = nodep->index,
-        [NODES_KEY_DEV] = nodep->dev_handle
-    };
-    hash_table_insert(&nodes, key, &nodep->nh_link);
-    return FS_NODE(nodep);
+    return EPERM;
 }
-int tmpfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
+void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
 {
-    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
-    tmpfs_node_t *childp = TMPFS_NODE(cfn);
-    tmpfs_dentry_t *dentryp;
-    link_t *lnk;
+    unsigned next = IPC_GET_ARG1(*request);
+    unsigned last = IPC_GET_ARG2(*request);
+    int dev_handle = IPC_GET_ARG3(*request);
+    int lflag = IPC_GET_ARG4(*request);
-    assert(parentp->type == TMPFS_DIRECTORY);
+    if (last < next)
+        last += PLB_SIZE;
-    /* Check for duplicit entries. */
-    for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
-        lnk = lnk->next) {
-        dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
-        if (!str_cmp(dentryp->name, nm))
-            return EEXIST;
+    /*
+     * Initialize TMPFS.
+     */
+    if (!root && !tmpfs_init()) {
+        ipc_answer_0(rid, ENOMEM);
+        return;
     }
-    /* Allocate and initialize the dentry. */
-    dentryp = malloc(sizeof(tmpfs_dentry_t));
-    if (!dentryp)
-        return ENOMEM;
-    tmpfs_dentry_initialize(dentryp);
+    tmpfs_dentry_t *dtmp = root->child;
+    tmpfs_dentry_t *dcur = root;
-    /* Populate and link the new dentry. */
-    size_t size = str_size(nm);
-    dentryp->name = malloc(size + 1);
-    if (!dentryp->name) {
-        free(dentryp);
-        return ENOMEM;
-    }
-    str_cpy(dentryp->name, size + 1, nm);
-    dentryp->node = childp;
-    childp->lnkcnt++;
-    list_append(&dentryp->link, &parentp->cs_head);
-    return EOK;
-}
-int tmpfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
-{
-    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
-    tmpfs_node_t *childp = NULL;
-    tmpfs_dentry_t *dentryp;
-    link_t *lnk;
-    if (!parentp)
-        return EBUSY;
+    if (PLB_GET_CHAR(next) == '/')
+        next++;     /* eat slash */
-    for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
-        lnk = lnk->next) {
-        dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
-        if (!str_cmp(dentryp->name, nm)) {
-            childp = dentryp->node;
-            assert(FS_NODE(childp) == cfn);
-            break;
-        }
-    }
+    char component[NAME_MAX + 1];
+    int len = 0;
+    while (dtmp && next <= last) {
-    if (!childp)
-        return ENOENT;
-    if ((childp->lnkcnt == 1) && !list_empty(&childp->cs_head))
-        return ENOTEMPTY;
+        /* collect the component */
+        if (PLB_GET_CHAR(next) != '/') {
+            if (len + 1 == NAME_MAX) {
+                /* comopnent length overflow */
+                ipc_answer_0(rid, ENAMETOOLONG);
+                return;
+            }
+            component[len++] = PLB_GET_CHAR(next);
+            next++; /* process next character */
+            if (next <= last)
+                continue;
+        }
-    list_remove(&dentryp->link);
-    free(dentryp);
-    childp->lnkcnt--;
+        assert(len);
+        component[len] = '\0';
+        next++;     /* eat slash */
+        len = 0;
-    return EOK;
-}
+        /* match the component */
+        while (dtmp && !match_component(dtmp, component))
+            dtmp = dtmp->sibling;
-int tmpfs_destroy_node(fs_node_t *fn)
-{
-    tmpfs_node_t *nodep = TMPFS_NODE(fn);
-    assert(!nodep->lnkcnt);
-    assert(list_empty(&nodep->cs_head));
+        /* handle miss: match amongst siblings */
+        if (!dtmp) {
+            if ((next > last) && (lflag & L_CREATE)) {
+                /* no components left and L_CREATE specified */
+                if (dcur->type != TMPFS_DIRECTORY) {
+                    ipc_answer_0(rid, ENOTDIR);
+                    return;
+                }
+                unsigned long index = create_node(dcur,
+                    component, lflag);
+                if (index > 0) {
+                    ipc_answer_4(rid, EOK,
+                        tmpfs_reg.fs_handle, dev_handle,
+                        index, 0);
+                } else {
+                    ipc_answer_0(rid, ENOSPC);
+                }
+                return;
+            }
+            ipc_answer_0(rid, ENOENT);
+            return;
+        }
-    unsigned long key[] = {
-        [NODES_KEY_INDEX] = nodep->index,
-        [NODES_KEY_DEV] = nodep->dev_handle
-    };
-    hash_table_remove(&nodes, key, 2);
+        /* descend one level */
+        dcur = dtmp;
+        dtmp = dtmp->child;
+    }
-    if (nodep->type == TMPFS_FILE)
-        free(nodep->data);
-    free(nodep->bp);
-    free(nodep);
-    return EOK;
-}
+    /* handle miss: excessive components */
+    if (!dtmp && next <= last) {
+        if (lflag & L_CREATE) {
+            if (dcur->type != TMPFS_DIRECTORY) {
+                ipc_answer_0(rid, ENOTDIR);
+                return;
+            }
-void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
-{
-    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+            /* collect next component */
+            while (next <= last) {
+                if (PLB_GET_CHAR(next) == '/') {
+                    /* more than one component */
+                    ipc_answer_0(rid, ENOENT);
+                    return;
+                }
+                if (len + 1 == NAME_MAX) {
+                    /* component length overflow */
+                    ipc_answer_0(rid, ENAMETOOLONG);
+                    return;
+                }
+                component[len++] = PLB_GET_CHAR(next);
+                next++; /* process next character */
+            }
+            assert(len);
+            component[len] = '\0';
+            len = 0;
+            unsigned long index;
+            index = create_node(dcur, component, lflag);
+            if (index) {
+                ipc_answer_4(rid, EOK, tmpfs_reg.fs_handle,
+                    dev_handle, index, 0);
+            } else {
+                ipc_answer_0(rid, ENOSPC);
+            }
+            return;
+        }
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
-    /* 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);
+    /* handle hit */
+    if (lflag & L_DESTROY) {
+        int res = destroy_component(dcur);
+        ipc_answer_0(rid, res);
         return;
     }
-    char *opts = malloc(size + 1);
-    if (!opts) {
-        ipc_answer_0(callid, ENOMEM);
-        ipc_answer_0(rid, ENOMEM);
+    if ((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) {
+        ipc_answer_0(rid, EEXIST);
         return;
     }
-    ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
-    if (retval != EOK) {
-        ipc_answer_0(rid, retval);
-        free(opts);
+    if ((lflag & L_FILE) && (dcur->type != TMPFS_FILE)) {
+        ipc_answer_0(rid, EISDIR);
         return;
     }
-    opts[size] = '\0';
-    /* Initialize TMPFS instance. */
-    if (!tmpfs_instance_init(dev_handle)) {
-        ipc_answer_0(rid, ENOMEM);
+    if ((lflag & L_DIRECTORY) && (dcur->type != TMPFS_DIRECTORY)) {
+        ipc_answer_0(rid, ENOTDIR);
         return;
     }
-    tmpfs_node_t *rootp = TMPFS_NODE(tmpfs_root_get(dev_handle));
-    if (str_cmp(opts, "restore") == 0) {
-        if (tmpfs_restore(dev_handle))
-            ipc_answer_3(rid, EOK, rootp->index, rootp->size,
-                rootp->lnkcnt);
-        else
-            ipc_answer_0(rid, ELIMIT);
-    } else {
-        ipc_answer_3(rid, EOK, rootp->index, rootp->size,
-            rootp->lnkcnt);
-    }
+    ipc_answer_4(rid, EOK, tmpfs_reg.fs_handle, dev_handle, dcur->index,
+        dcur->size);
 }
-void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request)
-{
-    libfs_mount(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
-}
-void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
-{
-    libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
-}
 void tmpfs_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);
+    int dev_handle = IPC_GET_ARG1(*request);
+    unsigned long index = IPC_GET_ARG2(*request);
+    off_t pos = IPC_GET_ARG3(*request);
     /*
-     * Lookup the respective TMPFS node.
+     * Lookup the respective dentry.
      */
     link_t *hlp;
-    unsigned long key[] = {
-        [NODES_KEY_INDEX] = index,
-        [NODES_KEY_DEV] = dev_handle,
-    };
-    hlp = hash_table_find(&nodes, key);
+    hlp = hash_table_find(&dentries, &index);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
-        nh_link);
+    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
+        dh_link);
     /*
      * Receive the read request.
      */
     ipc_callid_t callid;
-    size_t size;
-    if (!ipc_data_read_receive(&callid, &size)) {
+    size_t len;
+    if (!ipc_data_read_receive(&callid, &len)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
 ,16 → 355,15
     }
     size_t bytes;
-    if (nodep->type == TMPFS_FILE) {
-        bytes = max(0, min(nodep->size - pos, size));
-        (void) ipc_data_read_finalize(callid, nodep->data + pos,
+    if (dentry->type == TMPFS_FILE) {
+        bytes = max(0, min(dentry->size - pos, len));
+        (void) ipc_data_read_finalize(callid, dentry->data + pos,
             bytes);
     } else {
-        tmpfs_dentry_t *dentryp;
-        link_t *lnk;
         int i;
+        tmpfs_dentry_t *cur = dentry->child;
-        assert(nodep->type == TMPFS_DIRECTORY);
+        assert(dentry->type == TMPFS_DIRECTORY);
         /*
          * Yes, we really use O(n) algorithm here.
 ,21 → 370,18
          * If it bothers someone, it could be fixed by introducing a
          * hash table.
          */
-        for (i = 0, lnk = nodep->cs_head.next;
-            i < pos && lnk != &nodep->cs_head;
-            i++, lnk = lnk->next)
+        for (i = 0, cur = dentry->child; i < pos && cur; i++,
+            cur = cur->sibling)
             ;
-        if (lnk == &nodep->cs_head) {
+        if (!cur) {
             ipc_answer_0(callid, ENOENT);
             ipc_answer_1(rid, ENOENT, 0);
             return;
         }
-        dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
-        (void) ipc_data_read_finalize(callid, dentryp->name,
-            str_size(dentryp->name) + 1);
+        (void) ipc_data_read_finalize(callid, cur->name,
+            strlen(cur->name) + 1);
         bytes = 1;
     }
 ,32 → 393,28
 void tmpfs_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);
+    int dev_handle = IPC_GET_ARG1(*request);
+    unsigned long index = IPC_GET_ARG2(*request);
+    off_t pos = IPC_GET_ARG3(*request);
     /*
-     * Lookup the respective TMPFS node.
+     * Lookup the respective dentry.
      */
     link_t *hlp;
-    unsigned long key[] = {
-        [NODES_KEY_INDEX] = index,
-        [NODES_KEY_DEV] = dev_handle
-    };
-    hlp = hash_table_find(&nodes, key);
+    hlp = hash_table_find(&dentries, &index);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
-        nh_link);
+    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
+        dh_link);
     /*
      * Receive the write request.
      */
     ipc_callid_t callid;
-    size_t size;
-    if (!ipc_data_write_receive(&callid, &size)) {
+    size_t len;
+    if (!ipc_data_write_receive(&callid, &len)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
 ,13 → 423,13
     /*
      * Check whether the file needs to grow.
      */
-    if (pos + size <= nodep->size) {
+    if (pos + len <= dentry->size) {
         /* The file size is not changing. */
-        (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
-        ipc_answer_2(rid, EOK, size, nodep->size);
+        (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
+        ipc_answer_2(rid, EOK, len, dentry->size);
         return;
     }
-    size_t delta = (pos + size) - nodep->size;
+    size_t delta = (pos + len) - dentry->size;
     /*
      * At this point, we are deliberately extremely straightforward and
      * simply realloc the contents of the file on every write that grows the
 ,104 → 437,57
      * our heap allocator can save us and just grow the block whenever
      * possible.
      */
-    void *newdata = realloc(nodep->data, nodep->size + delta);
+    void *newdata = realloc(dentry->data, dentry->size + delta);
     if (!newdata) {
         ipc_answer_0(callid, ENOMEM);
-        ipc_answer_2(rid, EOK, 0, nodep->size);
+        ipc_answer_2(rid, EOK, 0, dentry->size);
         return;
     }
     /* Clear any newly allocated memory in order to emulate gaps. */
-    memset(newdata + nodep->size, 0, delta);
-    nodep->size += delta;
-    nodep->data = newdata;
-    (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
-    ipc_answer_2(rid, EOK, size, nodep->size);
+    memset(newdata + dentry->size, 0, delta);
+    dentry->size += delta;
+    dentry->data = newdata;
+    (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
+    ipc_answer_2(rid, EOK, len, dentry->size);
 }
 void tmpfs_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);
+    int dev_handle = IPC_GET_ARG1(*request);
+    unsigned long index = IPC_GET_ARG2(*request);
+    size_t size = IPC_GET_ARG3(*request);
     /*
-     * Lookup the respective TMPFS node.
+     * Lookup the respective dentry.
      */
     link_t *hlp;
-    unsigned long key[] = {
-        [NODES_KEY_INDEX] = index,
-        [NODES_KEY_DEV] = dev_handle
-    };
-    hlp = hash_table_find(&nodes, key);
+    hlp = hash_table_find(&dentries, &index);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
     }
-    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
-        nh_link);
+    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
+        dh_link);
-    if (size == nodep->size) {
+    if (size == dentry->size) {
         ipc_answer_0(rid, EOK);
         return;
     }
-    void *newdata = realloc(nodep->data, size);
+    void *newdata = realloc(dentry->data, size);
     if (!newdata) {
         ipc_answer_0(rid, ENOMEM);
         return;
     }
-    if (size > nodep->size) {
-        size_t delta = size - nodep->size;
-        memset(newdata + nodep->size, 0, delta);
+    if (size > dentry->size) {
+        size_t delta = size - dentry->size;
+        memset(newdata + dentry->size, 0, delta);
     }
-    nodep->size = size;
-    nodep->data = newdata;
+    dentry->size = size;
+    dentry->data = newdata;
     ipc_answer_0(rid, EOK);
 }
-void tmpfs_close(ipc_callid_t rid, ipc_call_t *request)
-{
-    ipc_answer_0(rid, EOK);
-}
-void tmpfs_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;
-    link_t *hlp;
-    unsigned long key[] = {
-        [NODES_KEY_INDEX] = index,
-        [NODES_KEY_DEV] = dev_handle
-    };
-    hlp = hash_table_find(&nodes, key);
-    if (!hlp) {
-        ipc_answer_0(rid, ENOENT);
-        return;
-    }
-    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
-        nh_link);
-    rc = tmpfs_destroy_node(FS_NODE(nodep));
-    ipc_answer_0(rid, rc);
-}
-void tmpfs_open_node(ipc_callid_t rid, ipc_call_t *request)
-{
-    libfs_open_node(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
-}
-void tmpfs_stat(ipc_callid_t rid, ipc_call_t *request)
-{
-    libfs_stat(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
-}
-void tmpfs_sync(ipc_callid_t rid, ipc_call_t *request)
-{
-    /* Dummy implementation */
-    ipc_answer_0(rid, EOK);
-}
 /**
  * @}
- */
+ */

 /trunk/uspace/srv/fs/tmpfs/tmpfs.c
 ,11 → 50,24
 #include <libfs.h>
 #include "../../vfs/vfs.h"
-#define NAME "tmpfs"
 vfs_info_t tmpfs_vfs_info = {
     .name = "tmpfs",
+    .ops = {
+        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_OPEN)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_RENAME)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_OPENDIR)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_READDIR)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_CLOSEDIR)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_UNLINK)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
+    }
 };
 fs_reg_t tmpfs_reg;
 ,41 → 109,15
         callid = async_get_call(&call);
         switch  (IPC_GET_METHOD(call)) {
-        case IPC_M_PHONE_HUNGUP:
-            return;
-        case VFS_OUT_MOUNTED:
-            tmpfs_mounted(callid, &call);
-            break;
-        case VFS_OUT_MOUNT:
-            tmpfs_mount(callid, &call);
-            break;
-        case VFS_OUT_LOOKUP:
+        case VFS_LOOKUP:
             tmpfs_lookup(callid, &call);
             break;
-        case VFS_OUT_READ:
+        case VFS_READ:
             tmpfs_read(callid, &call);
             break;
-        case VFS_OUT_WRITE:
+        case VFS_WRITE:
             tmpfs_write(callid, &call);
             break;
-        case VFS_OUT_TRUNCATE:
-            tmpfs_truncate(callid, &call);
-            break;
-        case VFS_OUT_CLOSE:
-            tmpfs_close(callid, &call);
-            break;
-        case VFS_OUT_DESTROY:
-            tmpfs_destroy(callid, &call);
-            break;
-        case VFS_OUT_OPEN_NODE:
-            tmpfs_open_node(callid, &call);
-            break;
-        case VFS_OUT_STAT:
-            tmpfs_stat(callid, &call);
-            break;
-        case VFS_OUT_SYNC:
-            tmpfs_sync(callid, &call);
-            break;
         default:
             ipc_answer_0(callid, ENOTSUP);
             break;
 ,27 → 127,27
 int main(int argc, char **argv)
 {
-    printf(NAME ": HelenOS TMPFS file system server\n");
+    int vfs_phone;
-    if (!tmpfs_init()) {
-        printf(NAME ": failed to initialize TMPFS\n");
-        return -1;
-    }
+    printf("TMPFS: HelenOS TMPFS file system server.\n");
-    int vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
-    if (vfs_phone < EOK) {
-        printf(NAME ": Unable to connect to VFS\n");
-        return -1;
+    vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
+    while (vfs_phone < EOK) {
+        usleep(10000);
+        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
     }
-    int rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info,
+    int rc;
+    rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info,
         tmpfs_connection);
     if (rc != EOK) {
-        printf(NAME ": Failed to register file system (%d)\n", rc);
+        printf("Failed to register the TMPFS file system (%d)\n", rc);
         return rc;
     }
+    dprintf("TMPFS filesystem registered, fs_handle=%d.\n",
+        tmpfs_reg.fs_handle);
-    printf(NAME ": Accepting connections\n");
     async_manager();
     /* not reached */
     return 0;

 /trunk/uspace/srv/fs/tmpfs/tmpfs.h
 ,62 → 38,33
 #include <atomic.h>
 #include <sys/types.h>
 #include <bool.h>
-#include <adt/hash_table.h>
+#include <libadt/hash_table.h>
-#ifndef dprintf
 #define dprintf(...)    printf(__VA_ARGS__)
-#endif
-#define TMPFS_NODE(node)    ((node) ? (tmpfs_node_t *)(node)->data : NULL)
-#define FS_NODE(node)       ((node) ? (node)->bp : NULL)
-typedef enum {
-    TMPFS_NONE,
-    TMPFS_FILE,
-    TMPFS_DIRECTORY
-} tmpfs_dentry_type_t;
-/* forward declaration */
-struct tmpfs_node;
 typedef struct tmpfs_dentry {
-    link_t link;        /**< Linkage for the list of siblings. */
-    struct tmpfs_node *node;/**< Back pointer to TMPFS node. */
-    char *name;     /**< Name of dentry. */
-} tmpfs_dentry_t;
-typedef struct tmpfs_node {
-    fs_node_t *bp;      /**< Back pointer to the FS node. */
-    fs_index_t index;   /**< TMPFS node index. */
-    dev_handle_t dev_handle;/**< Device handle. */
-    link_t nh_link;     /**< Nodes hash table link. */
-    tmpfs_dentry_type_t type;
-    unsigned lnkcnt;    /**< Link count. */
+    unsigned long index;    /**< TMPFS node index. */
+    link_t dh_link;     /**< Dentries hash table link. */
+    struct tmpfs_dentry *parent;
+    struct tmpfs_dentry *sibling;
+    struct tmpfs_dentry *child;
+    char *name;
+    enum {
+        TMPFS_NONE,
+        TMPFS_FILE,
+        TMPFS_DIRECTORY
+    } type;
     size_t size;        /**< File size if type is TMPFS_FILE. */
     void *data;     /**< File content's if type is TMPFS_FILE. */
-    link_t cs_head;     /**< Head of child's siblings list. */
-} tmpfs_node_t;
+} tmpfs_dentry_t;
 extern fs_reg_t tmpfs_reg;
-extern libfs_ops_t tmpfs_libfs_ops;
-extern bool tmpfs_init(void);
-extern void tmpfs_mounted(ipc_callid_t, ipc_call_t *);
-extern void tmpfs_mount(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_lookup(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_read(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_write(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_truncate(ipc_callid_t, ipc_call_t *);
-extern void tmpfs_stat(ipc_callid_t, ipc_call_t *);
-extern void tmpfs_close(ipc_callid_t, ipc_call_t *);
-extern void tmpfs_destroy(ipc_callid_t, ipc_call_t *);
-extern void tmpfs_open_node(ipc_callid_t, ipc_call_t *);
-extern void tmpfs_sync(ipc_callid_t, ipc_call_t *);
-extern bool tmpfs_restore(dev_handle_t);
 #endif
 /**

 /trunk/uspace/srv/fs/tmpfs/Makefile
 ,17 → 31,12
 LIBC_PREFIX = ../../../lib/libc
 LIBFS_PREFIX = ../../../lib/libfs
-LIBBLOCK_PREFIX = ../../../lib/libblock
 SOFTINT_PREFIX = ../../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I $(LIBFS_PREFIX) -I $(LIBBLOCK_PREFIX)
+CFLAGS += -I $(LIBFS_PREFIX)
-LIBS = \
-    $(LIBFS_PREFIX)/libfs.a \
-    $(LIBBLOCK_PREFIX)/libblock.a \
-    $(LIBC_PREFIX)/libc.a
+LIBS = $(LIBC_PREFIX)/libc.a $(LIBFS_PREFIX)/libfs.a
 ## Sources
 #
 ,31 → 44,28
 OUTPUT = tmpfs
 SOURCES = \
     tmpfs.c \
-    tmpfs_ops.c \
-    tmpfs_dump.c
+    tmpfs_ops.c
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

/trunk/uspace/srv/fs/fat/fat_fat.c
File deleted

/trunk/uspace/srv/fs/fat/fat_dentry.c
File deleted

/trunk/uspace/srv/fs/fat/fat_dentry.h
File deleted

/trunk/uspace/srv/fs/fat/fat_fat.h
File deleted

/trunk/uspace/srv/fs/fat/fat_idx.c
File deleted

 /trunk/uspace/srv/fs/fat/fat.c
 ,6 → 49,21
 vfs_info_t fat_vfs_info = {
     .name = "fat",
+    .ops = {
+        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_OPEN)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_CLOSE)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_RENAME)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_OPENDIR)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_READDIR)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_CLOSEDIR)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_UNLINK)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
+    }
 };
 fs_reg_t fat_reg;
 ,41 → 104,9
         callid = async_get_call(&call);
         switch  (IPC_GET_METHOD(call)) {
-        case IPC_M_PHONE_HUNGUP:
-            return;
-        case VFS_OUT_MOUNTED:
-            fat_mounted(callid, &call);
-            break;
-        case VFS_OUT_MOUNT:
-            fat_mount(callid, &call);
-            break;
-        case VFS_OUT_LOOKUP:
+        case VFS_LOOKUP:
             fat_lookup(callid, &call);
             break;
-        case VFS_OUT_READ:
-            fat_read(callid, &call);
-            break;
-        case VFS_OUT_WRITE:
-            fat_write(callid, &call);
-            break;
-        case VFS_OUT_TRUNCATE:
-            fat_truncate(callid, &call);
-            break;
-        case VFS_OUT_STAT:
-            fat_stat(callid, &call);
-            break;
-        case VFS_OUT_CLOSE:
-            fat_close(callid, &call);
-            break;
-        case VFS_OUT_DESTROY:
-            fat_destroy(callid, &call);
-            break;
-        case VFS_OUT_OPEN_NODE:
-            fat_open_node(callid, &call);
-            break;
-        case VFS_OUT_SYNC:
-            fat_sync(callid, &call);
-            break;
         default:
             ipc_answer_0(callid, ENOTSUP);
             break;
 ,24 → 117,20
 int main(int argc, char **argv)
 {
     int vfs_phone;
-    int rc;
-    printf("fat: HelenOS FAT file system server.\n");
+    printf("FAT: HelenOS FAT file system server.\n");
-    rc = fat_idx_init();
-    if (rc != EOK)
-        goto err;
-    vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
-    if (vfs_phone < EOK) {
-        printf("fat: failed to connect to VFS\n");
-        return -1;
+    vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
+    while (vfs_phone < EOK) {
+        usleep(10000);
+        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
     }
+    int rc;
     rc = fs_register(vfs_phone, &fat_reg, &fat_vfs_info, fat_connection);
     if (rc != EOK) {
-        fat_idx_fini();
-        goto err;
+        printf("Failed to register the FAT file system (%d)\n", rc);
+        return rc;
     }
     dprintf("FAT filesystem registered, fs_handle=%d.\n",
 ,10 → 139,6
     async_manager();
     /* not reached */
     return 0;
-err:
-    printf("Failed to register the FAT file system (%d)\n", rc);
-    return rc;
 }
 /**

 /trunk/uspace/srv/fs/fat/fat.h
 ,5 → 1,5
 /*
- * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2007 Jakub Jermar
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,41 → 33,31
 #ifndef FAT_FAT_H_
 #define FAT_FAT_H_
-#include "fat_fat.h"
 #include <ipc/ipc.h>
-#include <fibril_sync.h>
 #include <libfs.h>
 #include <atomic.h>
 #include <sys/types.h>
 #include <bool.h>
-#include "../../vfs/vfs.h"
-#ifndef dprintf
 #define dprintf(...)    printf(__VA_ARGS__)
-#endif
-#define min(a, b)       ((a) < (b) ? (a) : (b))
-#define BS_BLOCK        0
-#define BS_SIZE         512
-typedef struct fat_bs {
+typedef struct {
     uint8_t     ji[3];      /**< Jump instruction. */
     uint8_t     oem_name[8];
     /* BIOS Parameter Block */
     uint16_t    bps;        /**< Bytes per sector. */
     uint8_t     spc;        /**< Sectors per cluster. */
-    uint16_t    rscnt;      /**< Reserved sector count. */
+    uint16_t    rsc;        /**< Reserved sector count. */
     uint8_t     fatcnt;     /**< Number of FATs. */
     uint16_t    root_ent_max;   /**< Maximum number of root directory
                          entries. */
-    uint16_t    totsec16;   /**< Total sectors. 16-bit version. */
+    uint16_t    totsec;     /**< Total sectors. */
     uint8_t     mdesc;      /**< Media descriptor. */
     uint16_t    sec_per_fat;    /**< Sectors per FAT12/FAT16. */
     uint16_t    sec_per_track;  /**< Sectors per track. */
     uint16_t    headcnt;    /**< Number of heads. */
     uint32_t    hidden_sec; /**< Hidden sectors. */
-    uint32_t    totsec32;   /**< Total sectors. 32-bit version. */
+    uint32_t    total_sec;  /**< Total sectors. */
     union {
         struct {
 ,7 → 101,7
             /** Serial number. */
             uint32_t    id;
             /** Volume label. */
-            uint8_t     label[11];
+            uint8_t     label;
             /** FAT type. */
             uint8_t     type[8];
             /** Boot code. */
 ,110 → 112,32
     };
 } __attribute__ ((packed)) fat_bs_t;
-typedef enum {
-    FAT_INVALID,
-    FAT_DIRECTORY,
-    FAT_FILE
-} fat_node_type_t;
-struct fat_node;
-/** FAT index structure.
- *
- * This structure exists to help us to overcome certain limitations of the FAT
- * file system design.  The problem with FAT is that it is hard to find
- * an entity which could represent a VFS index.  There are two candidates:
- *
- * a) number of the node's first cluster
- * b) the pair of the parent directory's first cluster and the dentry index
- *    within the parent directory
- *
- * We need VFS indices to be:
- * A) unique
- * B) stable in time, at least until the next mount
- *
- * Unfortunately a) does not meet the A) criterion because zero-length files
- * will have the first cluster field cleared.  And b) does not meet the B)
- * criterion because unlink() and rename() will both free up the original
- * dentry, which contains all the essential info about the file.
- *
- * Therefore, a completely opaque indices are used and the FAT server maintains
- * a mapping between them and otherwise nice b) variant.  On rename(), the VFS
- * index stays unaltered, while the internal FAT "physical tree address"
- * changes.  The unlink case is also handled this way thanks to an in-core node
- * pointer embedded in the index structure.
- */
 typedef struct {
-    /** Used indices (position) hash table link. */
-    link_t      uph_link;
-    /** Used indices (index) hash table link. */
-    link_t      uih_link;
+    uint8_t     name[8];
+    uint8_t     ext[3];
+    uint8_t     attr;
+    uint8_t     reserved;
+    uint8_t     ctime_fine;
+    uint16_t    ctime;
+    uint16_t    cdate;
+    uint16_t    adate;
+    union {
+        uint16_t    eaidx;      /* FAT12/FAT16 */
+        uint16_t    firstc_hi;  /* FAT32 */
+    };
+    uint16_t    mtime;
+    uint16_t    mdate;
+    union {
+        uint16_t    firstc;     /* FAT12/FAT16 */
+        uint16_t    firstc_lo;  /* FAT32 */
+    };
+    uint32_t    size;
+} __attribute__ ((packed)) fat_dentry_t;
-    fibril_mutex_t  lock;
-    dev_handle_t    dev_handle;
-    fs_index_t  index;
-    /**
-     * Parent node's first cluster.
-     * Zero is used if this node is not linked, in which case nodep must
-     * contain a pointer to the in-core node structure.
-     * One is used when the parent is the root directory.
-     */
-    fat_cluster_t   pfc;
-    /** Directory entry index within the parent node. */
-    unsigned    pdi;
-    /** Pointer to in-core node instance. */
-    struct fat_node *nodep;
-} fat_idx_t;
-/** FAT in-core node. */
-typedef struct fat_node {
-    /** Back pointer to the FS node. */
-    fs_node_t       *bp;
-    fibril_mutex_t      lock;
-    fat_node_type_t     type;
-    fat_idx_t       *idx;
-    /**
-     *  Node's first cluster.
-     *  Zero is used for zero-length nodes.
-     *  One is used to mark root directory.
-     */
-    fat_cluster_t       firstc;
-    /** FAT in-core node free list link. */
-    link_t          ffn_link;
-    size_t          size;
-    unsigned        lnkcnt;
-    unsigned        refcnt;
-    bool            dirty;
-} fat_node_t;
 extern fs_reg_t fat_reg;
-extern void fat_mounted(ipc_callid_t, ipc_call_t *);
-extern void fat_mount(ipc_callid_t, ipc_call_t *);
 extern void fat_lookup(ipc_callid_t, ipc_call_t *);
-extern void fat_read(ipc_callid_t, ipc_call_t *);
-extern void fat_write(ipc_callid_t, ipc_call_t *);
-extern void fat_truncate(ipc_callid_t, ipc_call_t *);
-extern void fat_stat(ipc_callid_t, ipc_call_t *);
-extern void fat_close(ipc_callid_t, ipc_call_t *);
-extern void fat_destroy(ipc_callid_t, ipc_call_t *);
-extern void fat_open_node(ipc_callid_t, ipc_call_t *);
-extern void fat_stat(ipc_callid_t, ipc_call_t *);
-extern void fat_sync(ipc_callid_t, ipc_call_t *);
-extern fat_idx_t *fat_idx_get_new(dev_handle_t);
-extern fat_idx_t *fat_idx_get_by_pos(dev_handle_t, fat_cluster_t, unsigned);
-extern fat_idx_t *fat_idx_get_by_index(dev_handle_t, fs_index_t);
-extern void fat_idx_destroy(fat_idx_t *);
-extern void fat_idx_hashin(fat_idx_t *);
-extern void fat_idx_hashout(fat_idx_t *);
-extern int fat_idx_init(void);
-extern void fat_idx_fini(void);
-extern int fat_idx_init_by_dev_handle(dev_handle_t);
-extern void fat_idx_fini_by_dev_handle(dev_handle_t);
 #endif
 /**

 /trunk/uspace/srv/fs/fat/fat_ops.c
 ,5 → 1,5
 /*
- * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2007 Jakub Jermar
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,1183 → 36,107
  */
 #include "fat.h"
-#include "fat_dentry.h"
-#include "fat_fat.h"
 #include "../../vfs/vfs.h"
-#include <libfs.h>
-#include <libblock.h>
 #include <ipc/ipc.h>
-#include <ipc/services.h>
-#include <ipc/devmap.h>
 #include <async.h>
 #include <errno.h>
-#include <string.h>
-#include <byteorder.h>
-#include <adt/hash_table.h>
-#include <adt/list.h>
-#include <assert.h>
-#include <fibril_sync.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)
+#define PLB_GET_CHAR(i)     (fat_reg.plb_ro[(i) % PLB_SIZE])
-/** Mutex protecting the list of cached free FAT nodes. */
-static FIBRIL_MUTEX_INITIALIZE(ffn_mutex);
+#define FAT_NAME_LEN        8
+#define FAT_EXT_LEN     3
-/** List of cached free FAT nodes. */
-static LIST_INITIALIZE(ffn_head);
+#define FAT_PAD         ' '
-static void fat_node_initialize(fat_node_t *node)
-{
-    fibril_mutex_initialize(&node->lock);
-    node->bp = NULL;
-    node->idx = NULL;
-    node->type = 0;
-    link_initialize(&node->ffn_link);
-    node->size = 0;
-    node->lnkcnt = 0;
-    node->refcnt = 0;
-    node->dirty = false;
-}
+#define FAT_DENTRY_UNUSED   0x00
+#define FAT_DENTRY_E5_ESC   0x05
+#define FAT_DENTRY_DOT      0x2e
+#define FAT_DENTRY_ERASED   0xe5
-static void fat_node_sync(fat_node_t *node)
-{
-    block_t *b;
-    fat_bs_t *bs;
-    fat_dentry_t *d;
-    uint16_t bps;
-    unsigned dps;
-    assert(node->dirty);
-    bs = block_bb_get(node->idx->dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    dps = bps / sizeof(fat_dentry_t);
-    /* Read the block that contains the dentry of interest. */
-    b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
-        (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
-    d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
-    d->firstc = host2uint16_t_le(node->firstc);
-    if (node->type == FAT_FILE) {
-        d->size = host2uint32_t_le(node->size);
-    } else if (node->type == FAT_DIRECTORY) {
-        d->attr = FAT_ATTR_SUBDIR;
-    }
-    /* TODO: update other fields? (e.g time fields) */
-    b->dirty = true;        /* need to sync block */
-    block_put(b);
-}
-static fat_node_t *fat_node_get_new(void)
-{
-    fs_node_t *fn;
-    fat_node_t *nodep;
-    fibril_mutex_lock(&ffn_mutex);
-    if (!list_empty(&ffn_head)) {
-        /* 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 (!fibril_mutex_trylock(&nodep->lock))
-            goto skip_cache;
-        idxp_tmp = nodep->idx;
-        if (!fibril_mutex_trylock(&idxp_tmp->lock)) {
-            fibril_mutex_unlock(&nodep->lock);
-            goto skip_cache;
-        }
-        list_remove(&nodep->ffn_link);
-        fibril_mutex_unlock(&ffn_mutex);
-        if (nodep->dirty)
-            fat_node_sync(nodep);
-        idxp_tmp->nodep = NULL;
-        fibril_mutex_unlock(&nodep->lock);
-        fibril_mutex_unlock(&idxp_tmp->lock);
-        fn = FS_NODE(nodep);
-    } else {
-skip_cache:
-        /* Try to allocate a new node structure. */
-        fibril_mutex_unlock(&ffn_mutex);
-        fn = (fs_node_t *)malloc(sizeof(fs_node_t));
-        if (!fn)
-            return NULL;
-        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
-        if (!nodep) {
-            free(fn);
-            return NULL;
-        }
-    }
-    fat_node_initialize(nodep);
-    fs_node_initialize(fn);
-    fn->data = nodep;
-    nodep->bp = fn;
-    return nodep;
-}
-/** Internal version of fat_node_get().
+/** Compare one component of path to a directory entry.
  *
- * @param idxp      Locked index structure.
+ * @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 fat_node_t *fat_node_get_core(fat_idx_t *idxp)
+static unsigned match_path_component(fat_dentry_t *dentry, unsigned start,
+    unsigned last)
 {
-    block_t *b;
-    fat_bs_t *bs;
-    fat_dentry_t *d;
-    fat_node_t *nodep = NULL;
-    unsigned bps;
-    unsigned spc;
-    unsigned dps;
+    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;
-    if (idxp->nodep) {
-        /*
-         * We are lucky.
-         * The node is already instantiated in memory.
-         */
-        fibril_mutex_lock(&idxp->nodep->lock);
-        if (!idxp->nodep->refcnt++)
-            list_remove(&idxp->nodep->ffn_link);
-        fibril_mutex_unlock(&idxp->nodep->lock);
-        return idxp->nodep;
-    }
-    /*
-     * We must instantiate the node from the file system.
-     */
-    assert(idxp->pfc);
-    nodep = fat_node_get_new();
-    if (!nodep)
-        return NULL;
-    bs = block_bb_get(idxp->dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    spc = bs->spc;
-    dps = bps / sizeof(fat_dentry_t);
-    /* Read the block that contains the dentry of interest. */
-    b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
-        (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
-    assert(b);
-    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->type = FAT_DIRECTORY;
-        /*
-         * Unfortunately, the 'size' field of the FAT dentry is not
-         * defined for the directory entry type. We must determine the
-         * size of the directory by walking the FAT.
-         */
-        nodep->size = bps * spc * fat_clusters_get(bs, idxp->dev_handle,
-            uint16_t_le2host(d->firstc));
-    } else {
-        nodep->type = FAT_FILE;
-        nodep->size = uint32_t_le2host(d->size);
-    }
-    nodep->firstc = uint16_t_le2host(d->firstc);
-    nodep->lnkcnt = 1;
-    nodep->refcnt = 1;
-    block_put(b);
-    /* Link the idx structure with the node structure. */
-    nodep->idx = idxp;
-    idxp->nodep = nodep;
-    return nodep;
-}
-/*
- * Forward declarations of FAT libfs operations.
- */
-static fs_node_t *fat_node_get(dev_handle_t, fs_index_t);
-static void fat_node_put(fs_node_t *);
-static fs_node_t *fat_create_node(dev_handle_t, int);
-static int fat_destroy_node(fs_node_t *);
-static int fat_link(fs_node_t *, fs_node_t *, const char *);
-static int fat_unlink(fs_node_t *, fs_node_t *, const char *);
-static fs_node_t *fat_match(fs_node_t *, const char *);
-static fs_index_t fat_index_get(fs_node_t *);
-static size_t fat_size_get(fs_node_t *);
-static unsigned fat_lnkcnt_get(fs_node_t *);
-static bool fat_has_children(fs_node_t *);
-static fs_node_t *fat_root_get(dev_handle_t);
-static char fat_plb_get_char(unsigned);
-static bool fat_is_directory(fs_node_t *);
-static bool fat_is_file(fs_node_t *node);
-/*
- * FAT libfs operations.
- */
-/** Instantiate a FAT in-core node. */
-fs_node_t *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
-{
-    fat_node_t *nodep;
-    fat_idx_t *idxp;
-    idxp = fat_idx_get_by_index(dev_handle, index);
-    if (!idxp)
-        return NULL;
-    /* idxp->lock held */
-    nodep = fat_node_get_core(idxp);
-    fibril_mutex_unlock(&idxp->lock);
-    return FS_NODE(nodep);
-}
-void fat_node_put(fs_node_t *fn)
-{
-    fat_node_t *nodep = FAT_NODE(fn);
-    bool destroy = false;
-    fibril_mutex_lock(&nodep->lock);
-    if (!--nodep->refcnt) {
-        if (nodep->idx) {
-            fibril_mutex_lock(&ffn_mutex);
-            list_append(&nodep->ffn_link, &ffn_head);
-            fibril_mutex_unlock(&ffn_mutex);
-        } else {
-            /*
-             * The node does not have any index structure associated
-             * with itself. This can only mean that we are releasing
-             * the node after a failed attempt to allocate the index
-             * structure for it.
-             */
-            destroy = true;
+    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) ||
+                (dentry->name[pos + 1] == FAT_PAD)) {
+                    /* this is the last character in name */
+                name_processed = true;
+            }
+            if (dentry->name[0] == 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
+                    return 0;   /* character mismatch */
+            } else {
+                if (PLB_GET_CHAR(cur) == dentry->name[pos])
+                    continue;
+                else
+                    return 0;   /* character mismatch */
+            }
         }
-    }
-    fibril_mutex_unlock(&nodep->lock);
-    if (destroy) {
-        free(nodep->bp);
-        free(nodep);
-    }
-}
-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;
-    uint16_t bps;
-    int rc;
-    bs = block_bb_get(dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    if (flags & L_DIRECTORY) {
-        /* allocate a cluster */
-        rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
-        if (rc != EOK)
-            return NULL;
-    }
-    nodep = fat_node_get_new();
-    if (!nodep) {
-        fat_free_clusters(bs, dev_handle, mcl);
-        return NULL;
-    }
-    idxp = fat_idx_get_new(dev_handle);
-    if (!idxp) {
-        fat_free_clusters(bs, dev_handle, mcl);
-        fat_node_put(FS_NODE(nodep));
-        return NULL;
-    }
-    /* idxp->lock held */
-    if (flags & L_DIRECTORY) {
-        int i;
-        block_t *b;
-        /*
-         * Populate the new cluster with unused dentries.
-         */
-        for (i = 0; i < bs->spc; i++) {
-            b = _fat_block_get(bs, dev_handle, mcl, i,
-                BLOCK_FLAGS_NOREAD);
-            /* mark all dentries as never-used */
-            memset(b->data, 0, bps);
-            b->dirty = false;
-            block_put(b);
+        if (!dot_processed) {
+            dot_processed = true;
+            pos = -1;
+            if (PLB_GET_CHAR(cur) != '.')
+                return 0;
+            continue;
         }
-        nodep->type = FAT_DIRECTORY;
-        nodep->firstc = mcl;
-        nodep->size = bps * bs->spc;
-    } else {
-        nodep->type = FAT_FILE;
-        nodep->firstc = FAT_CLST_RES0;
-        nodep->size = 0;
-    }
-    nodep->lnkcnt = 0;  /* not linked anywhere */
-    nodep->refcnt = 1;
-    nodep->dirty = true;
-    nodep->idx = idxp;
-    idxp->nodep = nodep;
-    fibril_mutex_unlock(&idxp->lock);
-    return FS_NODE(nodep);
-}
-int fat_destroy_node(fs_node_t *fn)
-{
-    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
-     * found in the position hash. Obviously, we don't need to lock the node
-     * nor its index structure.
-     */
-    assert(nodep->lnkcnt == 0);
-    /*
-     * The node may not have any children.
-     */
-    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(fs_node_t *pfn, fs_node_t *cfn, const char *name)
-{
-    fat_node_t *parentp = FAT_NODE(pfn);
-    fat_node_t *childp = FAT_NODE(cfn);
-    fat_dentry_t *d;
-    fat_bs_t *bs;
-    block_t *b;
-    unsigned i, j;
-    uint16_t bps;
-    unsigned dps;
-    unsigned blocks;
-    fat_cluster_t mcl, lcl;
-    int rc;
-    fibril_mutex_lock(&childp->lock);
-    if (childp->lnkcnt == 1) {
-        /*
-         * On FAT, we don't support multiple hard links.
-         */
-        fibril_mutex_unlock(&childp->lock);
-        return EMLINK;
-    }
-    assert(childp->lnkcnt == 0);
-    fibril_mutex_unlock(&childp->lock);
-    if (!fat_dentry_name_verify(name)) {
-        /*
-         * Attempt to create unsupported name.
-         */
-        return ENOTSUP;
-    }
-    /*
-     * Get us an unused parent node's dentry or grow the parent and allocate
-     * a new one.
-     */
-    fibril_mutex_lock(&parentp->idx->lock);
-    bs = block_bb_get(parentp->idx->dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    dps = bps / sizeof(fat_dentry_t);
-    blocks = parentp->size / bps;
-    for (i = 0; i < blocks; i++) {
-        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
-        for (j = 0; j < dps; j++) {
-            d = ((fat_dentry_t *)b->data) + j;
-            switch (fat_classify_dentry(d)) {
-            case FAT_DENTRY_SKIP:
-            case FAT_DENTRY_VALID:
-                /* skipping used and meta entries */
-                continue;
-            case FAT_DENTRY_FREE:
-            case FAT_DENTRY_LAST:
-                /* found an empty slot */
-                goto hit;
+        if (!ext_processed) {
+            if ((pos == FAT_EXT_LEN - 1) ||
+                (dentry->ext[pos + 1] == FAT_PAD)) {
+                /* this is the last character in ext */
+                ext_processed = true;
             }
-        }
-        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. */
-        fibril_mutex_unlock(&parentp->idx->lock);
-        return ENOSPC;
-    }
-    rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
-    if (rc != EOK) {
-        fibril_mutex_unlock(&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 corresponding node is synced. Thus the valid
-     * 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);
-    fibril_mutex_unlock(&parentp->idx->lock);
-    fibril_mutex_lock(&childp->idx->lock);
-    /*
-     * If possible, create the Sub-directory Identifier Entry and the
-     * Sub-directory Parent Pointer Entry (i.e. "." and ".."). These entries
-     * are not mandatory according to Standard ECMA-107 and HelenOS VFS does
-     * 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 ||
-        str_cmp(d->name, FAT_NAME_DOT) == 0) {
-        memset(d, 0, sizeof(fat_dentry_t));
-        str_cpy(d->name, 8, FAT_NAME_DOT);
-        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 ||
-        str_cmp(d->name, FAT_NAME_DOT_DOT) == 0) {
-        memset(d, 0, sizeof(fat_dentry_t));
-        str_cpy(d->name, 8, FAT_NAME_DOT_DOT);
-        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. */
-    }
-    b->dirty = true;        /* need to sync block */
-    block_put(b);
-    childp->idx->pfc = parentp->firstc;
-    childp->idx->pdi = i * dps + j;
-    fibril_mutex_unlock(&childp->idx->lock);
-    fibril_mutex_lock(&childp->lock);
-    childp->lnkcnt = 1;
-    childp->dirty = true;       /* need to sync node */
-    fibril_mutex_unlock(&childp->lock);
-    /*
-     * Hash in the index structure into the position hash.
-     */
-    fat_idx_hashin(childp->idx);
-    return EOK;
-}
-int fat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
-{
-    fat_node_t *parentp = FAT_NODE(pfn);
-    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;
-    fibril_mutex_lock(&parentp->lock);
-    fibril_mutex_lock(&childp->lock);
-    assert(childp->lnkcnt == 1);
-    fibril_mutex_lock(&childp->idx->lock);
-    bs = block_bb_get(childp->idx->dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    b = _fat_block_get(bs, childp->idx->dev_handle, childp->idx->pfc,
-        (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
-        BLOCK_FLAGS_NONE);
-    d = (fat_dentry_t *)b->data +
-        (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
-    /* mark the dentry as not-currently-used */
-    d->name[0] = FAT_DENTRY_ERASED;
-    b->dirty = true;        /* need to sync block */
-    block_put(b);
-    /* remove the index structure from the position hash */
-    fat_idx_hashout(childp->idx);
-    /* clear position information */
-    childp->idx->pfc = FAT_CLST_RES0;
-    childp->idx->pdi = 0;
-    fibril_mutex_unlock(&childp->idx->lock);
-    childp->lnkcnt = 0;
-    childp->dirty = true;
-    fibril_mutex_unlock(&childp->lock);
-    fibril_mutex_unlock(&parentp->lock);
-    return EOK;
-}
-fs_node_t *fat_match(fs_node_t *pfn, const char *component)
-{
-    fat_bs_t *bs;
-    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_t *d;
-    block_t *b;
-    fibril_mutex_lock(&parentp->idx->lock);
-    bs = block_bb_get(parentp->idx->dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    dps = bps / sizeof(fat_dentry_t);
-    blocks = parentp->size / bps;
-    for (i = 0; i < blocks; i++) {
-        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
-        for (j = 0; j < dps; j++) {
-            d = ((fat_dentry_t *)b->data) + j;
-            switch (fat_classify_dentry(d)) {
-            case FAT_DENTRY_SKIP:
-            case FAT_DENTRY_FREE:
+            if (dentry->ext[0] == FAT_PAD) {
+                /* ext is empty; the match will fail */
+                ext_processed = true;
+            } else if (PLB_GET_CHAR(cur) == dentry->ext[pos]) {
                 continue;
-            case FAT_DENTRY_LAST:
-                block_put(b);
-                fibril_mutex_unlock(&parentp->idx->lock);
-                return NULL;
-            default:
-            case FAT_DENTRY_VALID:
-                fat_dentry_name_get(d, name);
-                break;
+            } else {
+                /* character mismatch */
+                return 0;
             }
-            if (fat_dentry_namecmp(name, component) == 0) {
-                /* hit */
-                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.
-                 */
-                fat_idx_t *idx = fat_idx_get_by_pos(
-                    parentp->idx->dev_handle, parentp->firstc,
-                    i * dps + j);
-                fibril_mutex_unlock(&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;
-                }
-                nodep = fat_node_get_core(idx);
-                fibril_mutex_unlock(&idx->lock);
-                block_put(b);
-                return FS_NODE(nodep);
-            }
         }
-        block_put(b);
+        return 0;   /* extra characters in the component */
     }
-    fibril_mutex_unlock(&parentp->idx->lock);
-    return NULL;
-}
-fs_index_t fat_index_get(fs_node_t *fn)
-{
-    return FAT_NODE(fn)->idx->index;
-}
-size_t fat_size_get(fs_node_t *fn)
-{
-    return FAT_NODE(fn)->size;
-}
-unsigned fat_lnkcnt_get(fs_node_t *fn)
-{
-    return FAT_NODE(fn)->lnkcnt;
-}
-bool fat_has_children(fs_node_t *fn)
-{
-    fat_bs_t *bs;
-    fat_node_t *nodep = FAT_NODE(fn);
-    unsigned bps;
-    unsigned dps;
-    unsigned blocks;
-    block_t *b;
-    unsigned i, j;
-    if (nodep->type != FAT_DIRECTORY)
-        return false;
-    fibril_mutex_lock(&nodep->idx->lock);
-    bs = block_bb_get(nodep->idx->dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    dps = bps / sizeof(fat_dentry_t);
-    blocks = nodep->size / bps;
-    for (i = 0; i < blocks; i++) {
-        fat_dentry_t *d;
-        b = fat_block_get(bs, nodep, i, BLOCK_FLAGS_NONE);
-        for (j = 0; j < dps; j++) {
-            d = ((fat_dentry_t *)b->data) + j;
-            switch (fat_classify_dentry(d)) {
-            case FAT_DENTRY_SKIP:
-            case FAT_DENTRY_FREE:
-                continue;
-            case FAT_DENTRY_LAST:
-                block_put(b);
-                fibril_mutex_unlock(&nodep->idx->lock);
-                return false;
-            default:
-            case FAT_DENTRY_VALID:
-                block_put(b);
-                fibril_mutex_unlock(&nodep->idx->lock);
-                return true;
-            }
-            block_put(b);
-            fibril_mutex_unlock(&nodep->idx->lock);
-            return true;
-        }
-        block_put(b);
-    }
-    fibril_mutex_unlock(&nodep->idx->lock);
-    return false;
-}
-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(fs_node_t *fn)
-{
-    return FAT_NODE(fn)->type == FAT_DIRECTORY;
-}
-bool fat_is_file(fs_node_t *fn)
-{
-    return FAT_NODE(fn)->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_node,
-    .destroy = fat_destroy_node,
-    .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
-};
-/*
- * VFS operations.
- */
-void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
-{
-    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
-    enum cache_mode cmode;
-    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';
-    /* Check for option enabling write through. */
-    if (str_cmp(opts, "wtcache") == 0)
-        cmode = CACHE_MODE_WT;
+    if (ext_processed || (name_processed && dentry->ext[0] == FAT_PAD))
+        return cur - start;
     else
-        cmode = CACHE_MODE_WB;
-    /* initialize libblock */
-    rc = block_init(dev_handle, BS_SIZE);
-    if (rc != EOK) {
-        ipc_answer_0(rid, rc);
-        return;
-    }
-    /* prepare the boot block */
-    rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE);
-    if (rc != EOK) {
-        block_fini(dev_handle);
-        ipc_answer_0(rid, rc);
-        return;
-    }
-    /* get the buffer with the boot sector */
-    bs = block_bb_get(dev_handle);
-    /* Read the number of root directory entries. */
-    bps = uint16_t_le2host(bs->bps);
-    rde = uint16_t_le2host(bs->root_ent_max);
-    if (bps != BS_SIZE) {
-        block_fini(dev_handle);
-        ipc_answer_0(rid, ENOTSUP);
-        return;
-    }
-    /* Initialize the block cache */
-    rc = block_cache_init(dev_handle, bps, 0 /* XXX */, cmode);
-    if (rc != EOK) {
-        block_fini(dev_handle);
-        ipc_answer_0(rid, rc);
-        return;
-    }
-    rc = fat_idx_init_by_dev_handle(dev_handle);
-    if (rc != EOK) {
-        block_fini(dev_handle);
-        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;
-    }
-    fs_node_initialize(rfn);
-    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) {
-        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);
-    /* ridxp->lock held */
-    rootp->type = FAT_DIRECTORY;
-    rootp->firstc = FAT_CLST_ROOT;
-    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;
-    fibril_mutex_unlock(&ridxp->lock);
-    ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
+        return 0;
 }
-void fat_mount(ipc_callid_t rid, ipc_call_t *request)
-{
-    libfs_mount(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
-}
 void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
 {
-    libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
-}
+    int first = IPC_GET_ARG1(*request);
+    int second = IPC_GET_ARG2(*request);
+    int dev_handle = IPC_GET_ARG3(*request);
-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);
-    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 (!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(fn);
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    bs = block_bb_get(dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    if (nodep->type == FAT_FILE) {
-        /*
-         * Our strategy for regular file reads is to read one block at
-         * most and make use of the possibility to return less data than
-         * requested. This keeps the code very simple.
-         */
-        if (pos >= nodep->size) {
-            /* reading beyond the EOF */
-            bytes = 0;
-            (void) ipc_data_read_finalize(callid, NULL, 0);
-        } else {
-            bytes = min(len, bps - pos % bps);
-            bytes = min(bytes, nodep->size - pos);
-            b = fat_block_get(bs, nodep, pos / bps,
-                BLOCK_FLAGS_NONE);
-            (void) ipc_data_read_finalize(callid, b->data + pos % bps,
-                bytes);
-            block_put(b);
-        }
-    } else {
-        unsigned bnum;
-        off_t spos = pos;
-        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
-        fat_dentry_t *d;
-        assert(nodep->type == FAT_DIRECTORY);
-        assert(nodep->size % bps == 0);
-        assert(bps % sizeof(fat_dentry_t) == 0);
-        /*
-         * Our strategy for readdir() is to use the position pointer as
-         * an index into the array of all dentries. On entry, it points
-         * to the first unread dentry. If we skip any dentries, we bump
-         * the position pointer accordingly.
-         */
-        bnum = (pos * sizeof(fat_dentry_t)) / bps;
-        while (bnum < nodep->size / bps) {
-            off_t o;
-            b = fat_block_get(bs, nodep, bnum, BLOCK_FLAGS_NONE);
-            for (o = pos % (bps / sizeof(fat_dentry_t));
-                o < bps / sizeof(fat_dentry_t);
-                o++, pos++) {
-                d = ((fat_dentry_t *)b->data) + o;
-                switch (fat_classify_dentry(d)) {
-                case FAT_DENTRY_SKIP:
-                case FAT_DENTRY_FREE:
-                    continue;
-                case FAT_DENTRY_LAST:
-                    block_put(b);
-                    goto miss;
-                default:
-                case FAT_DENTRY_VALID:
-                    fat_dentry_name_get(d, name);
-                    block_put(b);
-                    goto hit;
-                }
-            }
-            block_put(b);
-            bnum++;
-        }
-miss:
-        fat_node_put(fn);
-        ipc_answer_0(callid, ENOENT);
-        ipc_answer_1(rid, ENOENT, 0);
-        return;
-hit:
-        (void) ipc_data_read_finalize(callid, name, str_size(name) + 1);
-        bytes = (pos - spos) + 1;
-    }
-    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);
-    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 (!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(fn);
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    bs = block_bb_get(dev_handle);
-    bps = uint16_t_le2host(bs->bps);
-    spc = bs->spc;
-    bpc = bps * spc;
-    /*
-     * In all scenarios, we will attempt to write out only one block worth
-     * of data at maximum. There might be some more efficient approaches,
-     * but this one greatly simplifies fat_write(). Note that we can afford
-     * to do this because the client must be ready to handle the return
-     * value signalizing a smaller number of bytes written.
-     */
-    bytes = min(len, bps - pos % bps);
-    if (bytes == bps)
-        flags |= BLOCK_FLAGS_NOREAD;
-    boundary = ROUND_UP(nodep->size, bpc);
-    if (pos < boundary) {
-        /*
-         * This is the easier case - we are either overwriting already
-         * existing contents or writing behind the EOF, but still within
-         * the limits of the last cluster. The node size may grow to the
-         * next block size boundary.
-         */
-        fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
-        b = fat_block_get(bs, nodep, pos / bps, flags);
-        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
-            bytes);
-        b->dirty = true;        /* need to sync block */
-        block_put(b);
-        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(fn);
-        return;
-    } else {
-        /*
-         * This is the more difficult case. We must allocate new
-         * clusters for the node and zero them out.
-         */
-        int status;
-        unsigned nclsts;
-        fat_cluster_t mcl, lcl;
-        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(fn);
-            ipc_answer_0(callid, status);
-            ipc_answer_0(rid, status);
-            return;
-        }
-        /* zero fill any gaps */
-        fat_fill_gap(bs, nodep, mcl, pos);
-        b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc,
-            flags);
-        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
-            bytes);
-        b->dirty = true;        /* need to sync block */
-        block_put(b);
-        /*
-         * Append the cluster chain starting in mcl to the end of the
-         * node's cluster chain.
-         */
-        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(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);
-    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 (!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;
-    if (nodep->size == size) {
-        rc = EOK;
-    } else if (nodep->size < size) {
-        /*
-         * The standard says we have the freedom to grow the node.
-         * For now, we simply return an error.
-         */
-        rc = EINVAL;
-    } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
-        /*
-         * The node will be shrunk, but no clusters will be deallocated.
-         */
-        nodep->size = size;
-        nodep->dirty = true;        /* need to sync node */
-        rc = EOK;
-    } else {
-        /*
-         * The node will be shrunk, clusters will be deallocated.
-         */
-        if (size == 0) {
-            fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
-        } else {
-            fat_cluster_t lastc;
-            (void) fat_cluster_walk(bs, dev_handle, nodep->firstc,
-                &lastc, (size - 1) / bpc);
-            fat_chop_clusters(bs, nodep, lastc);
-        }
-        nodep->size = size;
-        nodep->dirty = true;        /* need to sync node */
-        rc = EOK;
-    }
-    fat_node_put(fn);
-    ipc_answer_0(rid, rc);
-    return;
-}
-void fat_close(ipc_callid_t rid, ipc_call_t *request)
-{
-    ipc_answer_0(rid, EOK);
-}
-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;
-    fs_node_t *fn = fat_node_get(dev_handle, index);
-    if (!fn) {
-        ipc_answer_0(rid, ENOENT);
-        return;
-    }
-    rc = fat_destroy_node(fn);
-    ipc_answer_0(rid, rc);
-}
-void fat_open_node(ipc_callid_t rid, ipc_call_t *request)
-{
-    libfs_open_node(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
-}
-void fat_stat(ipc_callid_t rid, ipc_call_t *request)
-{
-    libfs_stat(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
-}
-void fat_sync(ipc_callid_t rid, ipc_call_t *request)
-{
-    /* Dummy implementation */
-    ipc_answer_0(rid, EOK);
-}
 /**
  * @}
- */
+ */

 /trunk/uspace/srv/fs/fat/Makefile
 ,17 → 31,12
 LIBC_PREFIX = ../../../lib/libc
 LIBFS_PREFIX = ../../../lib/libfs
-LIBBLOCK_PREFIX = ../../../lib/libblock
 SOFTINT_PREFIX = ../../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I $(LIBFS_PREFIX) -I $(LIBBLOCK_PREFIX)
+CFLAGS += -I $(LIBFS_PREFIX)
-LIBS = \
-    $(LIBFS_PREFIX)/libfs.a \
-    $(LIBBLOCK_PREFIX)/libblock.a \
-    $(LIBC_PREFIX)/libc.a
+LIBS = $(LIBC_PREFIX)/libc.a $(LIBFS_PREFIX)/libfs.a
 ## Sources
 #
 ,33 → 44,28
 OUTPUT = fat
 SOURCES = \
     fat.c \
-    fat_ops.c \
-    fat_idx.c \
-    fat_dentry.c \
-    fat_fat.c
+    fat_ops.c
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 .PHONY: all clean depend disasm
-all: $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) disasm
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
-disasm: $(OUTPUT).disasm
+disasm:
+    $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-$(OUTPUT).disasm: $(OUTPUT)
-    $(OBJDUMP) -d $< > $@
 %.o: %.S
     $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev HEAD → Rev 2728