Changeset fdb7795 in mainline

Timestamp:

2008-02-25T22:22:57Z (17 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

6c441cf8

Parents:

07e01e6

Message:

Separate creation of a TMPFS node and its linking in the file system name space.
Rename VFS_FREE to VFS_DESTROY and destroy_node() to unlink_node().

Location:

uspace/srv

Files:

• fs/tmpfs/tmpfs.c (modified) (2 diffs)
• fs/tmpfs/tmpfs.h (modified) (1 diff)
• fs/tmpfs/tmpfs_ops.c (modified) (12 diffs)
• vfs/vfs.h (modified) (1 diff)
• vfs/vfs_node.c (modified) (1 diff)
• vfs/vfs_ops.c (modified) (1 diff)

uspace/srv/fs/tmpfs/tmpfs.c

@@ -61 +61 @@
                 [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_NULL,
                 [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
-                [IPC_METHOD_TO_VFS_OP(VFS_FREE)] = VFS_OP_DEFINED,
+                [IPC_METHOD_TO_VFS_OP(VFS_DESTROY)] = VFS_OP_DEFINED,
         }
 };
@@ -116 +116 @@
                         tmpfs_truncate(callid, &call);
                         break;
-                case VFS_FREE:
-                        tmpfs_free(callid, &call);
+                case VFS_DESTROY:
+                        tmpfs_destroy(callid, &call);
                         break;
                 default:

uspace/srv/fs/tmpfs/tmpfs.h

@@ -65 +65 @@
 extern void tmpfs_write(ipc_callid_t, ipc_call_t *);
 extern void tmpfs_truncate(ipc_callid_t, ipc_call_t *);
-extern void tmpfs_free(ipc_callid_t, ipc_call_t *);
+extern void tmpfs_destroy(ipc_callid_t, ipc_call_t *);
 
 #endif

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -62 +62 @@
 #define TMPFS_GET_LNKCNT(x)     1
 
-/*
- * Hash table of all directory entries.
- */
+/* Forward declarations of static functions. */
+static void *create_node(int);
+static bool link_node(void *, void *, const char *);
+static int unlink_node(void *);
+static void destroy_node(void *);
+
+/** Hash table of all directory entries. */
 hash_table_t dentries;
 
@@ -116 +120 @@
         if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
                 return false;
-
-        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);
-
-        return true;
+        root = (tmpfs_dentry_t *) create_node(L_DIRECTORY);
+        return root != NULL;
 }
 
@@ -143 +138 @@
 }
 
-static void *create_node(void *nodep,
-    const char *component, int lflag)
-{
-        tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep;
-
-        assert(dentry->type == TMPFS_DIRECTORY);
+void *create_node(int lflag)
+{
         assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
 
@@ -154 +145 @@
         if (!node)
                 return NULL;
-        size_t len = strlen(component);
-        char *name = malloc(len + 1);
-        if (!name) {
-                free(node);
-                return NULL;
-        }
-        strcpy(name, component);
 
         tmpfs_dentry_initialize(node);
         node->index = tmpfs_next_index++;
-        node->name = name;
-        node->parent = dentry;
         if (lflag & L_DIRECTORY) 
                 node->type = TMPFS_DIRECTORY;
@@ -171 +153 @@
                 node->type = TMPFS_FILE;
 
-        /* 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;
-        }
-
         /* Insert the new node into the dentry hash table. */
         hash_table_insert(&dentries, &node->index, &node->dh_link);
@@ -186 +158 @@
 }
 
-static int destroy_component(void *nodeptr)
+bool link_node(void *prnt, void *chld, const char *nm)
+{
+        tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
+        tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld;
+
+        assert(parentp->type == TMPFS_DIRECTORY);
+
+        size_t len = strlen(nm);
+        char *name = malloc(len + 1);
+        if (!name)
+                return false;
+        strcpy(name, nm);
+        childp->name = name;
+
+        /* Insert the new node into the namespace. */
+        if (parentp->child) {
+                tmpfs_dentry_t *tmp = parentp->child;
+                while (tmp->sibling)
+                        tmp = tmp->sibling;
+                tmp->sibling = childp;
+        } else {
+                parentp->child = childp;
+        }
+        childp->parent = parentp;
+
+        return true;
+}
+
+int unlink_node(void *nodeptr)
 {
         tmpfs_dentry_t *dentry = (tmpfs_dentry_t *)nodeptr;
@@ -208 +208 @@
         dentry->parent = NULL;
 
+        free(dentry->name);
+        dentry->name = NULL;
+
         return EOK;
+}
+
+void destroy_node(void *nodep)
+{
+        tmpfs_dentry_t *dentry = (tmpfs_dentry_t *) nodep;
+        
+        assert(!dentry->child);
+        assert(!dentry->sibling);
+
+        unsigned long index = dentry->index;
+        hash_table_remove(&dentries, &index, 1);
+
+        if (dentry->type == TMPFS_FILE)
+                free(dentry->data);
+        free(dentry);
 }
 
@@ -269 +287 @@
                                         return;
                                 } 
-                                void *nodep = create_node(dcur,
-                                    component, lflag);
+                                void *nodep = create_node(lflag);
                                 if (nodep) {
-                                        ipc_answer_5(rid, EOK,
-                                            tmpfs_reg.fs_handle, dev_handle,
-                                            TMPFS_GET_INDEX(nodep), 0,
-                                            TMPFS_GET_LNKCNT(nodep));
+                                        if (!link_node(dcur, nodep,
+                                            component)) {
+                                                destroy_node(nodep);
+                                                ipc_answer_0(rid, ENOSPC);
+                                        } else {
+                                                ipc_answer_5(rid, EOK,
+                                                    tmpfs_reg.fs_handle,
+                                                    dev_handle,
+                                                    TMPFS_GET_INDEX(nodep), 0,
+                                                    TMPFS_GET_LNKCNT(nodep));
+                                        }
                                 } else {
                                         ipc_answer_0(rid, ENOSPC);
@@ -317 +341 @@
                         len = 0;
                                 
-                        void *nodep = create_node(dcur, component, lflag);
+                        void *nodep = create_node(lflag);
                         if (nodep) {
-                                ipc_answer_5(rid, EOK, tmpfs_reg.fs_handle,
-                                    dev_handle, TMPFS_GET_INDEX(nodep), 0,
-                                    TMPFS_GET_LNKCNT(nodep));
+                                if (!link_node(dcur, nodep, component)) {
+                                        destroy_node(nodep);
+                                        ipc_answer_0(rid, ENOSPC);
+                                } else {
+                                        ipc_answer_5(rid, EOK,
+                                            tmpfs_reg.fs_handle,
+                                            dev_handle, TMPFS_GET_INDEX(nodep),
+                                            0, TMPFS_GET_LNKCNT(nodep));
+                                }
                         } else {
                                 ipc_answer_0(rid, ENOSPC);
@@ -334 +364 @@
         if (lflag & L_DESTROY) {
                 unsigned old_lnkcnt = TMPFS_GET_LNKCNT(dcur);
-                int res = destroy_component(dcur);
+                int res = unlink_node(dcur);
                 ipc_answer_5(rid, (ipcarg_t)res, tmpfs_reg.fs_handle,
                     dev_handle, dcur->index, dcur->size, old_lnkcnt);
@@ -519 +549 @@
 }
 
-void tmpfs_free(ipc_callid_t rid, ipc_call_t *request)
+void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
 {
         int dev_handle = IPC_GET_ARG1(*request);
@@ -532 +562 @@
         tmpfs_dentry_t *dentry = hash_table_get_instance(hlp, tmpfs_dentry_t,
             dh_link);
-        
-        assert(!dentry->parent);
-        assert(!dentry->child);
-        assert(!dentry->sibling);
-
-        hash_table_remove(&dentries, &index, 1);
-
-        if (dentry->type == TMPFS_FILE)
-                free(dentry->data);
-        free(dentry->name);
-        free(dentry);
-
+        destroy_node(dentry);
         ipc_answer_0(rid, EOK);
 }

uspace/srv/vfs/vfs.h

@@ -58 +58 @@
 typedef enum {
         VFS_LOOKUP = VFS_LAST_CMN,
-        VFS_FREE,
+        VFS_DESTROY,
         VFS_LAST_CLNT,  /* keep this the last member of this enum */
 } vfs_request_clnt_t;

uspace/srv/vfs/vfs_node.c

@@ -132 +132 @@
                 int phone = vfs_grab_phone(node->fs_handle);
                 ipcarg_t rc;
-                rc = async_req_2_0(phone, VFS_FREE, (ipcarg_t)node->dev_handle,
-                    (ipcarg_t)node->index);
+                rc = async_req_2_0(phone, VFS_DESTROY,
+                    (ipcarg_t)node->dev_handle, (ipcarg_t)node->index);
                 assert(rc == EOK);
                 vfs_release_phone(phone);

uspace/srv/vfs/vfs_ops.c

@@ -678 +678 @@
          * The name has already been unlinked by vfs_lookup_internal().
          * We have to get and put the VFS node to ensure that it is
-         * VFS_FREE'd after the last reference to it is dropped.
+         * VFS_DESTROY'ed after the last reference to it is dropped.
          */
         vfs_node_t *node = vfs_node_get(&lr);