Changeset 54e4479 in mainline for uspace/srv/fs/tmpfs/tmpfs_ops.c

Timestamp:

2009-09-24T16:49:02Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

073f550

Parents:

0daba21

Message:

Update tmpfs implementation of libfs operations wrt. the preceding API change.

File:

• uspace/srv/fs/tmpfs/tmpfs_ops.c (modified) (11 diffs)

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -67 +67 @@
 
 /* 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_match(fs_node_t **, fs_node_t *, const char *);
+static int tmpfs_node_get(fs_node_t **, dev_handle_t, fs_index_t);
+static int tmpfs_node_put(fs_node_t *);
+static int tmpfs_create_node(fs_node_t **, dev_handle_t, int);
+static int tmpfs_destroy_node(fs_node_t *);
 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 int tmpfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
+{
+        return tmpfs_node_get(rfn, dev_handle, TMPFS_SOME_ROOT); 
+}
+
+static int tmpfs_has_children(bool *has_children, fs_node_t *fn)
+{
+        *has_children = !list_empty(&TMPFS_NODE(fn)->cs_head);
+        return EOK;
+}
+
 static fs_index_t tmpfs_index_get(fs_node_t *fn)
 {
@@ -89 +100 @@
 {
         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); 
 }
 
@@ -118 +119 @@
 /** libfs operations */
 libfs_ops_t tmpfs_libfs_ops = {
+        .root_get = tmpfs_root_get,
         .match = tmpfs_match,
         .node_get = tmpfs_node_get,
@@ -125 +127 @@
         .link = tmpfs_link_node,
         .unlink = tmpfs_unlink_node,
+        .has_children = tmpfs_has_children,
         .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,
@@ -197 +198 @@
 {
         fs_node_t *rfn;
+        int rc;
         
-        rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
-        if (!rfn) 
+        rc = tmpfs_create_node(&rfn, dev_handle, L_DIRECTORY);
+        if (rc != EOK || !rfn)
                 return false;
         TMPFS_NODE(rfn)->lnkcnt = 0;    /* FS root is not linked */
@@ -205 +207 @@
 }
 
-fs_node_t *tmpfs_match(fs_node_t *pfn, const char *component)
+int tmpfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
 {
         tmpfs_node_t *parentp = TMPFS_NODE(pfn);
@@ -212 +214 @@
         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);
-        }
-
-        return NULL;
-}
-
-fs_node_t *tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
+                tmpfs_dentry_t *dentryp;
+                dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
+                if (!str_cmp(dentryp->name, component)) {
+                        *rfn = FS_NODE(dentryp->node);
+                        return EOK;
+                }
+        }
+
+        *rfn = NULL;
+        return EOK;
+}
+
+int tmpfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
 {
         unsigned long key[] = {
@@ -228 +233 @@
         };
         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));
-}
-
-void tmpfs_node_put(fs_node_t *fn)
+        if (lnk) {
+                tmpfs_node_t *nodep;
+                nodep = hash_table_get_instance(lnk, tmpfs_node_t, nh_link);
+                *rfn = FS_NODE(nodep);
+        } else {
+                *rfn = NULL;
+        }
+        return EOK;     
+}
+
+int tmpfs_node_put(fs_node_t *fn)
 {
         /* nothing to do */
-}
-
-fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
-{
+        return EOK;
+}
+
+int tmpfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
+{
+        fs_node_t *rootfn;
+        int rc;
+
         assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
 
         tmpfs_node_t *nodep = malloc(sizeof(tmpfs_node_t));
         if (!nodep)
-                return NULL;
+                return ENOMEM;
         tmpfs_node_initialize(nodep);
         nodep->bp = malloc(sizeof(fs_node_t));
         if (!nodep->bp) {
                 free(nodep);
-                return NULL;
+                return ENOMEM;
         }
         fs_node_initialize(nodep->bp);
         nodep->bp->data = nodep;        /* link the FS and TMPFS nodes */
-        if (!tmpfs_root_get(dev_handle))
+
+        rc = tmpfs_root_get(&rootfn, dev_handle);
+        assert(rc == EOK);
+        if (!rootfn)
                 nodep->index = TMPFS_SOME_ROOT;
         else
@@ -269 +286 @@
         };
         hash_table_insert(&nodes, key, &nodep->nh_link);
-        return FS_NODE(nodep);
+        *rfn = FS_NODE(nodep);
+        return EOK;
+}
+
+int tmpfs_destroy_node(fs_node_t *fn)
+{
+        tmpfs_node_t *nodep = TMPFS_NODE(fn);
+        
+        assert(!nodep->lnkcnt);
+        assert(list_empty(&nodep->cs_head));
+
+        unsigned long key[] = {
+                [NODES_KEY_INDEX] = nodep->index,
+                [NODES_KEY_DEV] = nodep->dev_handle
+        };
+        hash_table_remove(&nodes, key, 2);
+
+        if (nodep->type == TMPFS_FILE)
+                free(nodep->data);
+        free(nodep->bp);
+        free(nodep);
+        return EOK;
 }
 
@@ -343 +381 @@
 }
 
-int tmpfs_destroy_node(fs_node_t *fn)
-{
-        tmpfs_node_t *nodep = TMPFS_NODE(fn);
-        
-        assert(!nodep->lnkcnt);
-        assert(list_empty(&nodep->cs_head));
-
-        unsigned long key[] = {
-                [NODES_KEY_INDEX] = nodep->index,
-                [NODES_KEY_DEV] = nodep->dev_handle
-        };
-        hash_table_remove(&nodes, key, 2);
-
-        if (nodep->type == TMPFS_FILE)
-                free(nodep->data);
-        free(nodep->bp);
-        free(nodep);
-        return EOK;
-}
-
 void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
 {
         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        int rc;
 
         /* accept the mount options */
@@ -395 +414 @@
         }
 
-        tmpfs_node_t *rootp = TMPFS_NODE(tmpfs_root_get(dev_handle));
+        fs_node_t *rootfn;
+        rc = tmpfs_root_get(&rootfn, dev_handle);
+        assert(rc == EOK);
+        tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
         if (str_cmp(opts, "restore") == 0) {
                 if (tmpfs_restore(dev_handle))