WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/fs/tmpfs/tmpfs_ops.c

 #include <libfs.h>
 #define min(a, b)       ((a) < (b) ? (a) : (b))
 #define max(a, b)       ((a) > (b) ? (a) : (b))
-#define DENTRIES_BUCKETS    256
+#define NODES_BUCKETS   256
-#define NAMES_BUCKETS       4
 /** 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;
 /*
  * Implementation of the libfs interface.
  */
 /* Forward declarations of static functions. */
-static void *tmpfs_match(void *, const char *);
+static fs_node_t *tmpfs_match(fs_node_t *, const char *);
-static void *tmpfs_node_get(dev_handle_t, fs_index_t);
+static fs_node_t *tmpfs_node_get(dev_handle_t, fs_index_t);
-static void tmpfs_node_put(void *);
+static void tmpfs_node_put(fs_node_t *);
-static void *tmpfs_create_node(dev_handle_t, int);
+static fs_node_t *tmpfs_create_node(dev_handle_t, int);
-static int tmpfs_link_node(void *, void *, const char *);
+static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
-static int tmpfs_unlink_node(void *, void *);
+static int tmpfs_unlink_node(fs_node_t *, fs_node_t *, const char *);
-static int tmpfs_destroy_node(void *);
+static int tmpfs_destroy_node(fs_node_t *);
 /* Implementation of helper functions. */
-static fs_index_t tmpfs_index_get(void *nodep)
+static fs_index_t tmpfs_index_get(fs_node_t *fn)
+{
-    return ((tmpfs_dentry_t *) nodep)->index;
+    return TMPFS_NODE(fn)->index;
+}
-static size_t tmpfs_size_get(void *nodep)
+static size_t tmpfs_size_get(fs_node_t *fn)
+{
-    return ((tmpfs_dentry_t *) nodep)->size;
+    return TMPFS_NODE(fn)->size;
+}
-static unsigned tmpfs_lnkcnt_get(void *nodep)
+static unsigned tmpfs_lnkcnt_get(fs_node_t *fn)
+{
-    return ((tmpfs_dentry_t *) nodep)->lnkcnt;
+    return TMPFS_NODE(fn)->lnkcnt;
+}
-static bool tmpfs_has_children(void *nodep)
+static bool tmpfs_has_children(fs_node_t *fn)
+{
-    return ((tmpfs_dentry_t *) nodep)->child != NULL;
+    return !list_empty(&TMPFS_NODE(fn)->cs_head);
+}
-static void *tmpfs_root_get(dev_handle_t dev_handle)
+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(void *nodep)
+static bool tmpfs_is_directory(fs_node_t *fn)
+{
-    return ((tmpfs_dentry_t *) nodep)->type == TMPFS_DIRECTORY;
+    return TMPFS_NODE(fn)->type == TMPFS_DIRECTORY;
+}
-static bool tmpfs_is_file(void *nodep)
+static bool tmpfs_is_file(fs_node_t *fn)
+{
-    return ((tmpfs_dentry_t *) nodep)->type == TMPFS_FILE;
+    return TMPFS_NODE(fn)->type == TMPFS_FILE;
+}
 /** libfs operations */
 libfs_ops_t tmpfs_libfs_ops = {
     .match = tmpfs_match,
     .plb_get_char = tmpfs_plb_get_char,
     .is_directory = tmpfs_is_directory,
     .is_file = tmpfs_is_file
 };
-/** Hash table of all directory entries. */
+/** Hash table of all TMPFS nodes. */
-hash_table_t dentries;
+hash_table_t nodes;
-#define DENTRIES_KEY_INDEX  0
+#define NODES_KEY_INDEX 0
-#define DENTRIES_KEY_DEV    1
+#define NODES_KEY_DEV   1
-/* Implementation of hash table interface for the dentries hash table. */
+/* Implementation of hash table interface for the nodes hash table. */
-static hash_index_t dentries_hash(unsigned long key[])
+static hash_index_t nodes_hash(unsigned long key[])
+{
-    return key[DENTRIES_KEY_INDEX] % DENTRIES_BUCKETS;
+    return key[NODES_KEY_INDEX] % NODES_BUCKETS;
+}
-static int dentries_compare(unsigned long key[], hash_count_t keys,
+static int nodes_compare(unsigned long key[], hash_count_t keys, link_t *item)
-    link_t *item)
+{
-    tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
+    tmpfs_node_t *nodep = hash_table_get_instance(item, tmpfs_node_t,
-        dh_link);
+        nh_link);
-    return (dentry->index == key[DENTRIES_KEY_INDEX] &&
+    return (nodep->index == key[NODES_KEY_INDEX] &&
-        dentry->dev_handle == key[DENTRIES_KEY_DEV]);
+        nodep->dev_handle == key[NODES_KEY_DEV]);
+}
-static void dentries_remove_callback(link_t *item)
+static void nodes_remove_callback(link_t *item)
+{
+}
-/** TMPFS dentries hash table operations. */
+/** TMPFS nodes hash table operations. */
-hash_table_operations_t dentries_ops = {
+hash_table_operations_t nodes_ops = {
-    .hash = dentries_hash,
+    .hash = nodes_hash,
-    .compare = dentries_compare,
+    .compare = nodes_compare,
-    .remove_callback = dentries_remove_callback
+    .remove_callback = nodes_remove_callback
 };
-typedef struct {
-    char *name;
-    tmpfs_dentry_t *parent;
-    link_t link;
-} tmpfs_name_t;
-/* Implementation of hash table interface for the names hash table. */
-static hash_index_t names_hash(unsigned long *key)
-{
-    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) *key;
+static void tmpfs_node_initialize(tmpfs_node_t *nodep)
-    return dentry->index % NAMES_BUCKETS;
-}
-static int names_compare(unsigned long *key, hash_count_t keys, link_t *item)
+{
-    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) *key;
-    tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
-        link);
-    return dentry == namep->parent;
-}
-static void names_remove_callback(link_t *item)
-{
-    tmpfs_name_t *namep = hash_table_get_instance(item, tmpfs_name_t,
-        link);
-    free(namep->name);
+    nodep->bp = NULL;
-    free(namep);
+    nodep->index = 0;
-}
-/** TMPFS node names hash table operations. */
+    nodep->dev_handle = 0;
-static hash_table_operations_t names_ops = {
-    .hash = names_hash,
+    nodep->type = TMPFS_NONE;
-    .compare = names_compare,
+    nodep->lnkcnt = 0;
-    .remove_callback = names_remove_callback
-};
-static void tmpfs_name_initialize(tmpfs_name_t *namep)
-{
-    namep->name = NULL;
+    nodep->size = 0;
-    namep->parent = NULL;
+    nodep->data = NULL;
-    link_initialize(&namep->link);
+    link_initialize(&nodep->nh_link);
+    list_initialize(&nodep->cs_head);
 }
-static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
+static void tmpfs_dentry_initialize(tmpfs_dentry_t *dentryp)
 {
-    dentry->index = 0;
-    dentry->dev_handle = 0;
-    dentry->sibling = NULL;
+    link_initialize(&dentryp->link);
-    dentry->child = NULL;
+    dentryp->name = NULL;
-    dentry->type = TMPFS_NONE;
-    dentry->lnkcnt = 0;
-    dentry->size = 0;
-    dentry->data = NULL;
+    dentryp->node = NULL;
-    link_initialize(&dentry->dh_link);
-    return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,
-        &names_ops);
+}
 bool tmpfs_init(void)
+{
-    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 2, &dentries_ops))
+    if (!hash_table_create(&nodes, NODES_BUCKETS, 2, &nodes_ops))
         return false;
     return true;
+}
 static bool tmpfs_instance_init(dev_handle_t dev_handle)
+{
-    tmpfs_dentry_t *root;
+    fs_node_t *rfn;
-    root = (tmpfs_dentry_t *) tmpfs_create_node(dev_handle, L_DIRECTORY);
+    rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
-    if (!root)
+    if (!rfn)
         return false;
-    root->lnkcnt = 0;   /* FS root is not linked */
+    TMPFS_NODE(rfn)->lnkcnt = 0;    /* FS root is not linked */
     return true;
+}
-/** Compare one component of path to a directory entry.
- *
- * @param parentp   Pointer to node from which we descended.
- * @param childp    Pointer to node to compare the path component with.
+fs_node_t *tmpfs_match(fs_node_t *pfn, const char *component)
- * @param component Array of characters holding component name.
- *
- * @return      True on match, false otherwise.
- */
-static bool
-tmpfs_match_one(tmpfs_dentry_t *parentp, tmpfs_dentry_t *childp,
-    const char *component)
+{
-    unsigned long key = (unsigned long) parentp;
+    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
-    link_t *hlp = hash_table_find(&childp->names, &key);
-    assert(hlp);
+    link_t *lnk;
-    tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);
-    return !str_cmp(namep->name, component);
-}
-void *tmpfs_match(void *prnt, const char *component)
+    for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
-{
-    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
+        lnk = lnk->next) {
-    tmpfs_dentry_t *childp = parentp->child;
+        tmpfs_dentry_t *dentryp = list_get_instance(lnk, tmpfs_dentry_t,
+            link);
-    while (childp && !tmpfs_match_one(parentp, childp, component))
+        if (!str_cmp(dentryp->name, component))
-        childp = childp->sibling;
+            return FS_NODE(dentryp->node);
+    }
-    return (void *) childp;
+    return NULL;
+}
-void *
-tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
+fs_node_t *tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
+{
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
+        [NODES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle
+        [NODES_KEY_DEV] = dev_handle
     };
-    link_t *lnk = hash_table_find(&dentries, key);
+    link_t *lnk = hash_table_find(&nodes, key);
     if (!lnk)
         return NULL;
-    return hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link);
+    return FS_NODE(hash_table_get_instance(lnk, tmpfs_node_t, nh_link));
+}
-void tmpfs_node_put(void *node)
+void tmpfs_node_put(fs_node_t *fn)
+{
     /* nothing to do */
+}
-void *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
+fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
+{
     assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
-    tmpfs_dentry_t *node = malloc(sizeof(tmpfs_dentry_t));
+    tmpfs_node_t *nodep = malloc(sizeof(tmpfs_node_t));
-    if (!node)
+    if (!nodep)
         return NULL;
-    if (!tmpfs_dentry_initialize(node)) {
+    tmpfs_node_initialize(nodep);
+    nodep->bp = malloc(sizeof(fs_node_t));
+    if (!nodep->bp) {
-        free(node);
+        free(nodep);
         return NULL;
+    }
+    nodep->bp->data = nodep;    /* link the FS and TMPFS nodes */
     if (!tmpfs_root_get(dev_handle))
-        node->index = TMPFS_SOME_ROOT;
+        nodep->index = TMPFS_SOME_ROOT;
     else
-        node->index = tmpfs_next_index++;
+        nodep->index = tmpfs_next_index++;
-    node->dev_handle = dev_handle;
+    nodep->dev_handle = dev_handle;
     if (lflag & L_DIRECTORY)
-        node->type = TMPFS_DIRECTORY;
+        nodep->type = TMPFS_DIRECTORY;
     else
-        node->type = TMPFS_FILE;
+        nodep->type = TMPFS_FILE;
-    /* Insert the new node into the dentry hash table. */
+    /* Insert the new node into the nodes hash table. */
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = node->index,
+        [NODES_KEY_INDEX] = nodep->index,
-        [DENTRIES_KEY_DEV] = node->dev_handle
+        [NODES_KEY_DEV] = nodep->dev_handle
     };
-    hash_table_insert(&dentries, key, &node->dh_link);
+    hash_table_insert(&nodes, key, &nodep->nh_link);
-    return (void *) node;
+    return FS_NODE(nodep);
+}
-int tmpfs_link_node(void *prnt, void *chld, const char *nm)
+int tmpfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
+{
-    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
+    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
-    tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld;
+    tmpfs_node_t *childp = TMPFS_NODE(cfn);
+    tmpfs_dentry_t *dentryp;
+    link_t *lnk;
     assert(parentp->type == TMPFS_DIRECTORY);
+    /* 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;
+    }
+    /* Allocate and initialize the dentry. */
-    tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
+    dentryp = malloc(sizeof(tmpfs_dentry_t));
-    if (!namep)
+    if (!dentryp)
         return ENOMEM;
-    tmpfs_name_initialize(namep);
+    tmpfs_dentry_initialize(dentryp);
+    /* Populate and link the new dentry. */
     size_t size = str_size(nm);
-    namep->name = malloc(size + 1);
+    dentryp->name = malloc(size + 1);
-    if (!namep->name) {
+    if (!dentryp->name) {
-        free(namep);
+        free(dentryp);
         return ENOMEM;
+    }
-    str_cpy(namep->name, size + 1, nm);
+    str_cpy(dentryp->name, size + 1, nm);
-    namep->parent = parentp;
+    dentryp->node = childp;
     childp->lnkcnt++;
-    unsigned long key = (unsigned long) parentp;
-    hash_table_insert(&childp->names, &key, &namep->link);
-    /* Insert the new node into the namespace. */
-    if (parentp->child) {
-        tmpfs_dentry_t *tmp = parentp->child;
+    list_append(&dentryp->link, &parentp->cs_head);
-        while (tmp->sibling)
-            tmp = tmp->sibling;
-        tmp->sibling = childp;
-    } else {
-        parentp->child = childp;
-    }
     return EOK;
+}
-int tmpfs_unlink_node(void *prnt, void *chld)
+int tmpfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
+{
-    tmpfs_dentry_t *parentp = (tmpfs_dentry_t *)prnt;
+    tmpfs_node_t *parentp = TMPFS_NODE(pfn);
+    tmpfs_node_t *childp = NULL;
-    tmpfs_dentry_t *childp = (tmpfs_dentry_t *)chld;
+    tmpfs_dentry_t *dentryp;
+    link_t *lnk;
     if (!parentp)
         return EBUSY;
-    if (childp->child)
-        return ENOTEMPTY;
-    if (parentp->child == childp) {
+    for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
-        parentp->child = childp->sibling;
+        lnk = lnk->next) {
-    } else {
-        /* TODO: consider doubly linked list for organizing siblings. */
-        tmpfs_dentry_t *tmp = parentp->child;
+        dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
-        while (tmp->sibling != childp)
+        if (!str_cmp(dentryp->name, nm)) {
-            tmp = tmp->sibling;
+            childp = dentryp->node;
-        tmp->sibling = childp->sibling;
+            assert(FS_NODE(childp) == cfn);
+            break;
+        }
+    }
-    childp->sibling = NULL;
+    if (!childp)
+        return ENOENT;
-    unsigned long key = (unsigned long) parentp;
+    if ((childp->lnkcnt == 1) && !list_empty(&childp->cs_head))
-    hash_table_remove(&childp->names, &key, 1);
+        return ENOTEMPTY;
+    list_remove(&dentryp->link);
+    free(dentryp);
     childp->lnkcnt--;
     return EOK;
+}
-int tmpfs_destroy_node(void *nodep)
+int tmpfs_destroy_node(fs_node_t *fn)
+{
-    tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep;
+    tmpfs_node_t *nodep = TMPFS_NODE(fn);
-    assert(!dentry->lnkcnt);
+    assert(!nodep->lnkcnt);
-    assert(!dentry->child);
+    assert(list_empty(&nodep->cs_head));
-    assert(!dentry->sibling);
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = dentry->index,
+        [NODES_KEY_INDEX] = nodep->index,
-        [DENTRIES_KEY_DEV] = dentry->dev_handle
+        [NODES_KEY_DEV] = nodep->dev_handle
     };
-    hash_table_remove(&dentries, key, 2);
+    hash_table_remove(&nodes, key, 2);
-    hash_table_destroy(&dentry->names);
-    if (dentry->type == TMPFS_FILE)
+    if (nodep->type == TMPFS_FILE)
-        free(dentry->data);
+        free(nodep->data);
+    free(nodep->bp);
-    free(dentry);
+    free(nodep);
     return EOK;
+}
 void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
+{
     if (!tmpfs_instance_init(dev_handle)) {
         ipc_answer_0(rid, ENOMEM);
         return;
+    }
-    tmpfs_dentry_t *root = tmpfs_root_get(dev_handle);
+    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, root->index, root->size,
+            ipc_answer_3(rid, EOK, rootp->index, rootp->size,
-                root->lnkcnt);
+                rootp->lnkcnt);
         else
             ipc_answer_0(rid, ELIMIT);
     } else {
-        ipc_answer_3(rid, EOK, root->index, root->size, root->lnkcnt);
+        ipc_answer_3(rid, EOK, rootp->index, rootp->size,
+            rootp->lnkcnt);
+    }
+}
 void tmpfs_mount(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);
     /*
-     * Lookup the respective dentry.
+     * Lookup the respective TMPFS node.
      */
     link_t *hlp;
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
+        [NODES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle,
+        [NODES_KEY_DEV] = dev_handle,
     };
-    hlp = hash_table_find(&dentries, key);
+    hlp = hash_table_find(&nodes, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
-    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
+    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
-        dh_link);
+        nh_link);
     /*
      * Receive the read request.
      */
     ipc_callid_t callid;
         ipc_answer_0(rid, EINVAL);
         return;
+    }
     size_t bytes;
-    if (dentry->type == TMPFS_FILE) {
+    if (nodep->type == TMPFS_FILE) {
-        bytes = max(0, min(dentry->size - pos, size));
+        bytes = max(0, min(nodep->size - pos, size));
-        (void) ipc_data_read_finalize(callid, dentry->data + pos,
+        (void) ipc_data_read_finalize(callid, nodep->data + pos,
             bytes);
     } else {
+        tmpfs_dentry_t *dentryp;
+        link_t *lnk;
         int i;
-        tmpfs_dentry_t *cur;
-        assert(dentry->type == TMPFS_DIRECTORY);
+        assert(nodep->type == TMPFS_DIRECTORY);
         /*
          * Yes, we really use O(n) algorithm here.
          * If it bothers someone, it could be fixed by introducing a
          * hash table.
          */
-        for (i = 0, cur = dentry->child; i < pos && cur; i++,
+        for (i = 0, lnk = nodep->cs_head.next;
+            i < pos && lnk != &nodep->cs_head;
-            cur = cur->sibling)
+            i++, lnk = lnk->next)
+            ;
-        if (!cur) {
+        if (lnk == &nodep->cs_head) {
             ipc_answer_0(callid, ENOENT);
             ipc_answer_1(rid, ENOENT, 0);
             return;
+        }
-        unsigned long key = (unsigned long) dentry;
-        link_t *hlp = hash_table_find(&cur->names, &key);
-        assert(hlp);
-        tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t,
+        dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
-            link);
-        (void) ipc_data_read_finalize(callid, namep->name,
+        (void) ipc_data_read_finalize(callid, dentryp->name,
-            str_size(namep->name) + 1);
+            str_size(dentryp->name) + 1);
         bytes = 1;
+    }
     /*
      * Answer the VFS_READ call.
     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);
     /*
-     * Lookup the respective dentry.
+     * Lookup the respective TMPFS node.
      */
     link_t *hlp;
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
+        [NODES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle
+        [NODES_KEY_DEV] = dev_handle
     };
-    hlp = hash_table_find(&dentries, key);
+    hlp = hash_table_find(&nodes, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
-    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
+    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
-        dh_link);
+        nh_link);
     /*
      * Receive the write request.
      */
     ipc_callid_t callid;
+    }
     /*
      * Check whether the file needs to grow.
      */
-    if (pos + size <= dentry->size) {
+    if (pos + size <= nodep->size) {
         /* The file size is not changing. */
-        (void) ipc_data_write_finalize(callid, dentry->data + pos, size);
+        (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
-        ipc_answer_2(rid, EOK, size, dentry->size);
+        ipc_answer_2(rid, EOK, size, nodep->size);
         return;
+    }
-    size_t delta = (pos + size) - dentry->size;
+    size_t delta = (pos + size) - nodep->size;
     /*
      * At this point, we are deliberately extremely straightforward and
      * simply realloc the contents of the file on every write that grows the
      * file. In the end, the situation might not be as bad as it may look:
      * our heap allocator can save us and just grow the block whenever
      * possible.
      */
-    void *newdata = realloc(dentry->data, dentry->size + delta);
+    void *newdata = realloc(nodep->data, nodep->size + delta);
     if (!newdata) {
         ipc_answer_0(callid, ENOMEM);
-        ipc_answer_2(rid, EOK, 0, dentry->size);
+        ipc_answer_2(rid, EOK, 0, nodep->size);
         return;
+    }
     /* Clear any newly allocated memory in order to emulate gaps. */
-    memset(newdata + dentry->size, 0, delta);
+    memset(newdata + nodep->size, 0, delta);
-    dentry->size += delta;
+    nodep->size += delta;
-    dentry->data = newdata;
+    nodep->data = newdata;
-    (void) ipc_data_write_finalize(callid, dentry->data + pos, size);
+    (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
-    ipc_answer_2(rid, EOK, size, dentry->size);
+    ipc_answer_2(rid, EOK, size, nodep->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);
     /*
-     * Lookup the respective dentry.
+     * Lookup the respective TMPFS node.
      */
     link_t *hlp;
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
+        [NODES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle
+        [NODES_KEY_DEV] = dev_handle
     };
-    hlp = hash_table_find(&dentries, key);
+    hlp = hash_table_find(&nodes, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
-    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
+    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
-        dh_link);
+        nh_link);
-    if (size == dentry->size) {
+    if (size == nodep->size) {
         ipc_answer_0(rid, EOK);
         return;
+    }
-    void *newdata = realloc(dentry->data, size);
+    void *newdata = realloc(nodep->data, size);
     if (!newdata) {
         ipc_answer_0(rid, ENOMEM);
         return;
+    }
-    if (size > dentry->size) {
+    if (size > nodep->size) {
-        size_t delta = size - dentry->size;
+        size_t delta = size - nodep->size;
-        memset(newdata + dentry->size, 0, delta);
+        memset(newdata + nodep->size, 0, delta);
+    }
-    dentry->size = size;
+    nodep->size = size;
-    dentry->data = newdata;
+    nodep->data = newdata;
     ipc_answer_0(rid, EOK);
+}
 void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
+{
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     int rc;
     link_t *hlp;
     unsigned long key[] = {
-        [DENTRIES_KEY_INDEX] = index,
+        [NODES_KEY_INDEX] = index,
-        [DENTRIES_KEY_DEV] = dev_handle
+        [NODES_KEY_DEV] = dev_handle
     };
-    hlp = hash_table_find(&dentries, key);
+    hlp = hash_table_find(&nodes, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
-    tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
+    tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
-        dh_link);
+        nh_link);
-    rc = tmpfs_destroy_node(dentry);
+    rc = tmpfs_destroy_node(FS_NODE(nodep));
     ipc_answer_0(rid, rc);
+}
 /**
  * @}

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/fs/tmpfs/tmpfs_ops.c – Rev 4348 → 4389