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

 #define DENTRIES_BUCKETS    256
 #define NAMES_BUCKETS       4
-/*
- * For now, we don't distinguish between different dev_handles/instances. All
+/** All root nodes have index 0. */
+#define TMPFS_SOME_ROOT     0
- * requests resolve to the only instance, rooted in the following variable.
+/** Global counter for assigning node indices. Shared by all instances. */
- */
-static tmpfs_dentry_t *root;
+fs_index_t tmpfs_next_index = 1;
-#define TMPFS_DEV       0   /**< Dummy device handle for TMPFS */
 /*
  * Implementation of the libfs interface.
  */
     return ((tmpfs_dentry_t *) nodep)->child != NULL;
+}
 static void *tmpfs_root_get(dev_handle_t dev_handle)
+{
-    return root;
+    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];
 };
 /** Hash table of all directory entries. */
 hash_table_t dentries;
+#define DENTRIES_KEY_INDEX  0
+#define DENTRIES_KEY_DEV    1
 /* Implementation of hash table interface for the dentries hash table. */
-static hash_index_t dentries_hash(unsigned long *key)
+static hash_index_t dentries_hash(unsigned long key[])
+{
-    return *key % DENTRIES_BUCKETS;
+    return key[DENTRIES_KEY_INDEX] % DENTRIES_BUCKETS;
+}
-static int dentries_compare(unsigned long *key, hash_count_t keys,
+static int dentries_compare(unsigned long key[], hash_count_t keys,
     link_t *item)
+{
     tmpfs_dentry_t *dentry = hash_table_get_instance(item, tmpfs_dentry_t,
         dh_link);
-    return dentry->index == *key;
+    return (dentry->index == key[DENTRIES_KEY_INDEX] &&
+        dentry->dev_handle == key[DENTRIES_KEY_DEV]);
+}
 static void dentries_remove_callback(link_t *item)
+{
+}
     .hash = dentries_hash,
     .compare = dentries_compare,
     .remove_callback = dentries_remove_callback
 };
-fs_index_t tmpfs_next_index = 1;
 typedef struct {
     char *name;
     tmpfs_dentry_t *parent;
     link_t link;
 } tmpfs_name_t;
+}
 static bool tmpfs_dentry_initialize(tmpfs_dentry_t *dentry)
+{
     dentry->index = 0;
+    dentry->dev_handle = 0;
     dentry->sibling = NULL;
     dentry->child = NULL;
     dentry->type = TMPFS_NONE;
     dentry->lnkcnt = 0;
     dentry->size = 0;
     link_initialize(&dentry->dh_link);
     return (bool)hash_table_create(&dentry->names, NAMES_BUCKETS, 1,
         &names_ops);
+}
-static bool tmpfs_init(void)
+bool tmpfs_init(void)
+{
-    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
+    if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 2, &dentries_ops))
         return false;
+    return true;
+}
+static bool tmpfs_instance_init(dev_handle_t dev_handle)
+{
+    tmpfs_dentry_t *root;
-    root = (tmpfs_dentry_t *) tmpfs_create_node(TMPFS_DEV, L_DIRECTORY);
+    root = (tmpfs_dentry_t *) tmpfs_create_node(dev_handle, L_DIRECTORY);
-    if (!root) {
+    if (!root)
-        hash_table_destroy(&dentries);
         return false;
-    }
     root->lnkcnt = 0;   /* FS root is not linked */
     return true;
+}
 /** Compare one component of path to a directory entry.
+{
     unsigned long key = (unsigned long) parentp;
     link_t *hlp = hash_table_find(&childp->names, &key);
     assert(hlp);
     tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t, link);
-    return !strcmp(namep->name, component);
+    return !str_cmp(namep->name, component);
+}
 void *tmpfs_match(void *prnt, const char *component)
+{
     tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
+}
 void *
 tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
+{
-    unsigned long key = index;
+    unsigned long key[] = {
+        [DENTRIES_KEY_INDEX] = index,
+        [DENTRIES_KEY_DEV] = dev_handle
+    };
-    link_t *lnk = hash_table_find(&dentries, &key);
+    link_t *lnk = hash_table_find(&dentries, key);
     if (!lnk)
         return NULL;
     return hash_table_get_instance(lnk, tmpfs_dentry_t, dh_link);
+}
     if (!tmpfs_dentry_initialize(node)) {
         free(node);
         return NULL;
+    }
+    if (!tmpfs_root_get(dev_handle))
+        node->index = TMPFS_SOME_ROOT;
+    else
-    node->index = tmpfs_next_index++;
+        node->index = tmpfs_next_index++;
+    node->dev_handle = dev_handle;
     if (lflag & L_DIRECTORY)
         node->type = TMPFS_DIRECTORY;
     else
         node->type = TMPFS_FILE;
     /* Insert the new node into the dentry hash table. */
-    unsigned long key = node->index;
+    unsigned long key[] = {
+        [DENTRIES_KEY_INDEX] = node->index,
+        [DENTRIES_KEY_DEV] = node->dev_handle
+    };
-    hash_table_insert(&dentries, &key, &node->dh_link);
+    hash_table_insert(&dentries, key, &node->dh_link);
     return (void *) node;
+}
 int tmpfs_link_node(void *prnt, void *chld, const char *nm)
+{
     tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
     if (!namep)
         return ENOMEM;
     tmpfs_name_initialize(namep);
-    size_t len = strlen(nm);
+    size_t size = str_size(nm);
-    namep->name = malloc(len + 1);
+    namep->name = malloc(size + 1);
     if (!namep->name) {
         free(namep);
         return ENOMEM;
+    }
-    strcpy(namep->name, nm);
+    str_cpy(namep->name, size + 1, nm);
     namep->parent = parentp;
     childp->lnkcnt++;
     unsigned long key = (unsigned long) parentp;
     assert(!dentry->lnkcnt);
     assert(!dentry->child);
     assert(!dentry->sibling);
-    unsigned long key = dentry->index;
+    unsigned long key[] = {
+        [DENTRIES_KEY_INDEX] = dentry->index,
+        [DENTRIES_KEY_DEV] = dentry->dev_handle
+    };
-    hash_table_remove(&dentries, &key, 1);
+    hash_table_remove(&dentries, key, 2);
     hash_table_destroy(&dentry->names);
     if (dentry->type == TMPFS_FILE)
         free(dentry->data);
 void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
+{
     dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+    /* accept the mount options */
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_write_receive(&callid, &size)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    char *opts = malloc(size + 1);
+    if (!opts) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
+    if (retval != EOK) {
+        ipc_answer_0(rid, retval);
+        free(opts);
+        return;
+    }
+    opts[size] = '\0';
-    /* Initialize TMPFS. */
+    /* Initialize TMPFS instance. */
-    if (!root && !tmpfs_init()) {
+    if (!tmpfs_instance_init(dev_handle)) {
         ipc_answer_0(rid, ENOMEM);
         return;
+    }
+    tmpfs_dentry_t *root = tmpfs_root_get(dev_handle);
-    if (dev_handle >= 0) {
+    if (str_cmp(opts, "restore") == 0) {
         if (tmpfs_restore(dev_handle))
             ipc_answer_3(rid, EOK, root->index, root->size,
                 root->lnkcnt);
         else
             ipc_answer_0(rid, ELIMIT);
     /*
      * Lookup the respective dentry.
      */
     link_t *hlp;
-    unsigned long key = index;
+    unsigned long key[] = {
+        [DENTRIES_KEY_INDEX] = index,
+        [DENTRIES_KEY_DEV] = dev_handle,
+    };
-    hlp = hash_table_find(&dentries, &key);
+    hlp = hash_table_find(&dentries, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
     tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
     /*
      * Receive the read request.
      */
     ipc_callid_t callid;
-    size_t len;
+    size_t size;
-    if (!ipc_data_read_receive(&callid, &len)) {
+    if (!ipc_data_read_receive(&callid, &size)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
+    }
     size_t bytes;
     if (dentry->type == TMPFS_FILE) {
-        bytes = max(0, min(dentry->size - pos, len));
+        bytes = max(0, min(dentry->size - pos, size));
         (void) ipc_data_read_finalize(callid, dentry->data + pos,
             bytes);
     } else {
         int i;
         tmpfs_dentry_t *cur;
         assert(hlp);
         tmpfs_name_t *namep = hash_table_get_instance(hlp, tmpfs_name_t,
             link);
         (void) ipc_data_read_finalize(callid, namep->name,
-            strlen(namep->name) + 1);
+            str_size(namep->name) + 1);
         bytes = 1;
+    }
     /*
      * Answer the VFS_READ call.
     /*
      * Lookup the respective dentry.
      */
     link_t *hlp;
-    unsigned long key = index;
+    unsigned long key[] = {
+        [DENTRIES_KEY_INDEX] = index,
+        [DENTRIES_KEY_DEV] = dev_handle
+    };
-    hlp = hash_table_find(&dentries, &key);
+    hlp = hash_table_find(&dentries, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
     tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
     /*
      * Receive the write request.
      */
     ipc_callid_t callid;
-    size_t len;
+    size_t size;
-    if (!ipc_data_write_receive(&callid, &len)) {
+    if (!ipc_data_write_receive(&callid, &size)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
+    }
     /*
      * Check whether the file needs to grow.
      */
-    if (pos + len <= dentry->size) {
+    if (pos + size <= dentry->size) {
         /* The file size is not changing. */
-        (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
+        (void) ipc_data_write_finalize(callid, dentry->data + pos, size);
-        ipc_answer_2(rid, EOK, len, dentry->size);
+        ipc_answer_2(rid, EOK, size, dentry->size);
         return;
+    }
-    size_t delta = (pos + len) - dentry->size;
+    size_t delta = (pos + size) - dentry->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
+    }
     /* Clear any newly allocated memory in order to emulate gaps. */
     memset(newdata + dentry->size, 0, delta);
     dentry->size += delta;
     dentry->data = newdata;
-    (void) ipc_data_write_finalize(callid, dentry->data + pos, len);
+    (void) ipc_data_write_finalize(callid, dentry->data + pos, size);
-    ipc_answer_2(rid, EOK, len, dentry->size);
+    ipc_answer_2(rid, EOK, size, 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);
     /*
      * Lookup the respective dentry.
      */
     link_t *hlp;
-    unsigned long key = index;
+    unsigned long key[] = {
+        [DENTRIES_KEY_INDEX] = index,
+        [DENTRIES_KEY_DEV] = dev_handle
+    };
-    hlp = hash_table_find(&dentries, &key);
+    hlp = hash_table_find(&dentries, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
     tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
     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 = index;
+    unsigned long key[] = {
+        [DENTRIES_KEY_INDEX] = index,
+        [DENTRIES_KEY_DEV] = dev_handle
+    };
-    hlp = hash_table_find(&dentries, &key);
+    hlp = hash_table_find(&dentries, key);
     if (!hlp) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
     tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,

Subversion Repositories HelenOS

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