Changeset 50e5b25 in mainline

Timestamp:

2008-11-23T11:00:08Z (16 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

f714576

Parents:

31696b4f

Message:

Add implementation of fat_destroy_node() and fat_destroy().

Location:

uspace/srv/fs/fat

Files:

• fat.h (modified) (1 diff)
• fat_ops.c (modified) (8 diffs)

uspace/srv/fs/fat/fat.h

@@ -204 +204 @@
 extern void fat_write(ipc_callid_t, ipc_call_t *);
 extern void fat_truncate(ipc_callid_t, ipc_call_t *);
+extern void fat_destroy(ipc_callid_t, ipc_call_t *);
 
 extern fat_idx_t *fat_idx_get_new(dev_handle_t);

uspace/srv/fs/fat/fat_ops.c

@@ -217 +217 @@
 }
 
+/*
+ * Forward declarations of FAT libfs operations.
+ */
+static void *fat_node_get(dev_handle_t, fs_index_t);
+static void fat_node_put(void *);
+static void *fat_create_node(dev_handle_t, int);
+static int fat_destroy_node(void *);
+static bool fat_link(void *, void *, const char *);
+static int fat_unlink(void *, void *);
+static void *fat_match(void *, const char *);
+static fs_index_t fat_index_get(void *);
+static size_t fat_size_get(void *);
+static unsigned fat_lnkcnt_get(void *);
+static bool fat_has_children(void *);
+static void *fat_root_get(dev_handle_t);
+static char fat_plb_get_char(unsigned);
+static bool fat_is_directory(void *);
+static bool fat_is_file(void *node);
+
+/*
+ * FAT libfs operations.
+ */
+
 /** Instantiate a FAT in-core node. */
-static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
 {
         void *node;
@@ -232 +255 @@
 }
 
-static void fat_node_put(void *node)
+void fat_node_put(void *node)
 {
         fat_node_t *nodep = (fat_node_t *)node;
@@ -258 +281 @@
 }
 
-static void *fat_create_node(dev_handle_t dev_handle, int flags)
+void *fat_create_node(dev_handle_t dev_handle, int flags)
 {
         fat_idx_t *idxp;
@@ -289 +312 @@
 }
 
-static int fat_destroy_node(void *node)
+int fat_destroy_node(void *node)
+{
+        fat_node_t *nodep = (fat_node_t *)node;
+        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(node) == 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);
+        return EOK;
+}
+
+bool fat_link(void *prnt, void *chld, const char *name)
+{
+        return false;   /* not supported at the moment */
+}
+
+int fat_unlink(void *prnt, void *chld)
 {
         return ENOTSUP; /* not supported at the moment */
 }
 
-static bool fat_link(void *prnt, void *chld, const char *name)
-{
-        return false;   /* not supported at the moment */
-}
-
-static int fat_unlink(void *prnt, void *chld)
-{
-        return ENOTSUP; /* not supported at the moment */
-}
-
-static void *fat_match(void *prnt, const char *component)
+void *fat_match(void *prnt, const char *component)
 {
         fat_bs_t *bs;
@@ -371 +419 @@
 }
 
-static fs_index_t fat_index_get(void *node)
+fs_index_t fat_index_get(void *node)
 {
         fat_node_t *fnodep = (fat_node_t *)node;
@@ -379 +427 @@
 }
 
-static size_t fat_size_get(void *node)
+size_t fat_size_get(void *node)
 {
         return ((fat_node_t *)node)->size;
 }
 
-static unsigned fat_lnkcnt_get(void *node)
+unsigned fat_lnkcnt_get(void *node)
 {
         return ((fat_node_t *)node)->lnkcnt;
 }
 
-static bool fat_has_children(void *node)
+bool fat_has_children(void *node)
 {
         fat_bs_t *bs;
@@ -439 +487 @@
 }
 
-static void *fat_root_get(dev_handle_t dev_handle)
+void *fat_root_get(dev_handle_t dev_handle)
 {
         return fat_node_get(dev_handle, 0);
 }
 
-static char fat_plb_get_char(unsigned pos)
+char fat_plb_get_char(unsigned pos)
 {
         return fat_reg.plb_ro[pos % PLB_SIZE];
 }
 
-static bool fat_is_directory(void *node)
+bool fat_is_directory(void *node)
 {
         return ((fat_node_t *)node)->type == FAT_DIRECTORY;
 }
 
-static bool fat_is_file(void *node)
+bool fat_is_file(void *node)
 {
         return ((fat_node_t *)node)->type == FAT_FILE;
@@ -839 +887 @@
 }
 
+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;
+
+        fat_node_t *nodep = fat_node_get(dev_handle, index);
+        if (!nodep) {
+                ipc_answer_0(rid, ENOENT);
+                return;
+        }
+
+        rc = fat_destroy_node(nodep);
+        ipc_answer_0(rid, rc);
+}
+
 /**
  * @}