Changes in / [fea0ce6:e095644] in mainline

Location:

uspace

Files:

• app/bdsh/Makefile (modified) (1 diff)
• app/bdsh/cmds/modules/module_aliases.h (modified) (1 diff)
• app/bdsh/cmds/modules/modules.h (modified) (2 diffs)
• app/bdsh/cmds/modules/unmount/entry.h (added)
• app/bdsh/cmds/modules/unmount/unmount.c (added)
• app/bdsh/cmds/modules/unmount/unmount.h (added)
• app/bdsh/cmds/modules/unmount/unmount_def.h (added)
• lib/libc/generic/adt/hash_table.c (modified) (1 diff)
• lib/libc/generic/vfs/vfs.c (modified) (1 diff)
• lib/libc/include/adt/hash_table.h (modified) (1 diff)
• lib/libc/include/ipc/vfs.h (modified) (3 diffs)
• lib/libc/include/vfs/vfs.h (modified) (1 diff)
• lib/libfs/libfs.c (modified) (1 diff)
• srv/vfs/vfs.c (modified) (1 diff)
• srv/vfs/vfs.h (modified) (2 diffs)
• srv/vfs/vfs_node.c (modified) (2 diffs)
• srv/vfs/vfs_ops.c (modified) (2 diffs)

uspace/app/bdsh/Makefile

@@ -48 +48 @@
         cmds/modules/mv/mv.c \
         cmds/modules/mount/mount.c \
+        cmds/modules/unmount/unmount.c \
         cmds/modules/kcon/kcon.c \
         cmds/builtins/exit/exit.c \

uspace/app/bdsh/cmds/modules/module_aliases.h

@@ -14 +14 @@
 char *mod_aliases[] = {
         "ren", "mv",
+        "umount", "unmount",
         NULL, NULL
 };

uspace/app/bdsh/cmds/modules/modules.h

@@ -31 +31 @@
 #include "mv/entry.h"
 #include "mount/entry.h"
+#include "unmount/entry.h"
 #include "kcon/entry.h"
 
@@ -51 +52 @@
 #include "mv/mv_def.h"
 #include "mount/mount_def.h"
+#include "unmount/unmount_def.h"
 #include "kcon/kcon_def.h"
 

uspace/lib/libc/generic/adt/hash_table.c

@@ -193 +193 @@
 }
 
+/** Apply fucntion to all items in hash table.
+ *
+ * @param h             Hash table.
+ * @param f             Function to be applied.
+ * @param arg           Argument to be passed to the function.
+ */
+void
+hash_table_apply(hash_table_t *h, void (*f)(link_t *, void *), void *arg)
+{
+        hash_index_t bucket;
+        link_t *cur;
+
+        for (bucket = 0; bucket < h->entries; bucket++) {
+                for (cur = h->entry[bucket].next; cur != &h->entry[bucket];
+                    cur = cur->next) {
+                        f(cur, arg);
+                }
+        }
+}
+
 /** @}
  */

uspace/lib/libc/generic/vfs/vfs.c

@@ -197 +197 @@
 }
 
+int unmount(const char *mp)
+{
+        ipcarg_t rc;
+        ipcarg_t rc_orig;
+        aid_t req;
+        size_t mpa_size;
+        char *mpa;
+        
+        mpa = absolutize(mp, &mpa_size);
+        if (!mpa)
+                return ENOMEM;
+        
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        
+        req = async_send_0(vfs_phone, VFS_IN_UNMOUNT, NULL);
+        rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
+        if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                free(mpa);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        
+
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        free(mpa);
+        
+        return (int) rc;
+}
+
 static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag)
 {

uspace/lib/libc/include/adt/hash_table.h

@@ -88 +88 @@
 extern void hash_table_remove(hash_table_t *, unsigned long [], hash_count_t);
 extern void hash_table_destroy(hash_table_t *);
+extern void hash_table_apply(hash_table_t *, void (*)(link_t *, void *),
+    void *);
 
 #endif

uspace/lib/libc/include/ipc/vfs.h

@@ -86 +86 @@
         VFS_OUT_MOUNTED,
         VFS_OUT_UNMOUNT,
+        VFS_OUT_UNMOUNTED,
         VFS_OUT_SYNC,
         VFS_OUT_STAT,
@@ -140 +141 @@
 
 /**
- * L_OPEN is used to indicate that the lookup operation is a part of VFS_OPEN
+ * L_OPEN is used to indicate that the lookup operation is a part of VFS_IN_OPEN
  * call from the client. This means that the server might allocate some
  * resources for the opened file. This flag cannot be passed directly by the
@@ -147 +148 @@
 #define L_OPEN  64
 
+/**
+ * L_NOCROSS_LAST_MP is used exclusively during the VFS_IN_UNMOUNT operation. It
+ * tells the lookup routine not to cross the last mount point in the lookup
+ * path.
+ */
+#define L_NOCROSS_LAST_MP       128
+
 #endif
 

uspace/lib/libc/include/vfs/vfs.h

@@ -55 +55 @@
 extern int mount(const char *, const char *, const char *, const char *,
     unsigned int);
+extern int unmount(const char *);
 
 extern void __stdio_init(int filc, fdi_node_t *filv[]);

uspace/lib/libfs/libfs.c

@@ -304 +304 @@
                 on_error(rc, goto out_with_answer);
                 
-                if ((tmp) && (tmp->mp_data.mp_active)) {
+                /*
+                 * If the matching component is a mount point, there are two
+                 * legitimate semantics of the lookup operation. The first is
+                 * the commonly used one in which the lookup crosses each mount
+                 * point into the mounted file system. The second semantics is
+                 * used mostly during unmount() and differs from the first one
+                 * only in that the last mount point in the looked up path,
+                 * which is also its last component, is not crossed.
+                 */
+
+                if ((tmp) && (tmp->mp_data.mp_active) &&
+                    (!(lflag & L_NOCROSS_LAST_MP) || (next <= last))) {
                         if (next > last)
                                 next = last = first;

uspace/srv/vfs/vfs.c

@@ -86 +86 @@
                 case VFS_IN_MOUNT:
                         vfs_mount(callid, &call);
+                        break;
+                case VFS_IN_UNMOUNT:
+                        vfs_unmount(callid, &call);
                         break;
                 case VFS_IN_OPEN:

uspace/srv/vfs/vfs.h

@@ -181 +181 @@
 extern vfs_node_t *vfs_node_get(vfs_lookup_res_t *);
 extern void vfs_node_put(vfs_node_t *);
+extern void vfs_node_forget(vfs_node_t *);
+extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, dev_handle_t);
+
 
 #define MAX_OPEN_FILES  128
@@ -198 +201 @@
 extern void vfs_register(ipc_callid_t, ipc_call_t *);
 extern void vfs_mount(ipc_callid_t, ipc_call_t *);
+extern void vfs_unmount(ipc_callid_t, ipc_call_t *);
 extern void vfs_open(ipc_callid_t, ipc_call_t *);
 extern void vfs_open_node(ipc_callid_t, ipc_call_t *);

uspace/srv/vfs/vfs_node.c

@@ -137 +137 @@
         if (free_vfs_node)
                 free(node);
+}
+
+/** Forget node.
+ *
+ * This function will remove the node from the node hash table and deallocate
+ * its memory, regardless of the node's reference count.
+ *
+ * @param node  Node to be forgotten.
+ */
+void vfs_node_forget(vfs_node_t *node)
+{
+        fibril_mutex_lock(&nodes_mutex);
+        unsigned long key[] = {
+                [KEY_FS_HANDLE] = node->fs_handle,
+                [KEY_DEV_HANDLE] = node->dev_handle,
+                [KEY_INDEX] = node->index
+        };
+        hash_table_remove(&nodes, key, 3);
+        fibril_mutex_unlock(&nodes_mutex);
+        free(node);
 }
 
@@ -231 +251 @@
 }
 
+struct refcnt_data {
+        /** Sum of all reference counts for this file system instance. */
+        unsigned refcnt;
+        fs_handle_t fs_handle;
+        dev_handle_t dev_handle;
+};
+
+static void refcnt_visitor(link_t *item, void *arg)
+{
+        vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link);
+        struct refcnt_data *rd = (void *) arg;
+
+        if ((node->fs_handle == rd->fs_handle) &&
+            (node->dev_handle == rd->dev_handle))
+                rd->refcnt += node->refcnt;
+}
+
+unsigned
+vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, dev_handle_t dev_handle)
+{
+        struct refcnt_data rd = {
+                .refcnt = 0,
+                .fs_handle = fs_handle,
+                .dev_handle = dev_handle
+        };
+
+        fibril_mutex_lock(&nodes_mutex);
+        hash_table_apply(&nodes, refcnt_visitor, &rd);
+        fibril_mutex_unlock(&nodes_mutex);
+
+        return rd.refcnt;
+}
+
 /**
  * @}

uspace/srv/vfs/vfs_ops.c

@@ -429 +429 @@
 }
 
+void vfs_unmount(ipc_callid_t rid, ipc_call_t *request)
+{
+        int rc;
+        char *mp;
+        vfs_lookup_res_t mp_res;
+        vfs_lookup_res_t mr_res;
+        vfs_node_t *mp_node;
+        vfs_node_t *mr_node;
+        int phone;
+
+        /*
+         * Receive the mount point path.
+         */
+        rc = async_data_string_receive(&mp, MAX_PATH_LEN);
+        if (rc != EOK)
+                ipc_answer_0(rid, rc);
+
+        /*
+         * Taking the namespace lock will do two things for us. First, it will
+         * prevent races with other lookup operations. Second, it will stop new
+         * references to already existing VFS nodes and creation of new VFS
+         * nodes. This is because new references are added as a result of some
+         * lookup operation or at least of some operation which is protected by
+         * the namespace lock.
+         */
+        fibril_rwlock_write_lock(&namespace_rwlock);
+        
+        /*
+         * Lookup the mounted root and instantiate it.
+         */
+        rc = vfs_lookup_internal(mp, L_NONE, &mr_res, NULL);
+        if (rc != EOK) {
+                fibril_rwlock_write_unlock(&namespace_rwlock);
+                free(mp);
+                ipc_answer_0(rid, rc);
+                return;
+        }
+        mr_node = vfs_node_get(&mr_res);
+        if (!mr_node) {
+                fibril_rwlock_write_unlock(&namespace_rwlock);
+                free(mp);
+                ipc_answer_0(rid, ENOMEM);
+                return;
+        }
+
+        /*
+         * Count the total number of references for the mounted file system. We
+         * are expecting at least two. One which we got above and one which we
+         * got when the file system was mounted. If we find more, it means that
+         * the file system cannot be gracefully unmounted at the moment because
+         * someone is working with it.
+         */
+        if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
+            mr_node->dev_handle) != 2) {
+                fibril_rwlock_write_unlock(&namespace_rwlock);
+                vfs_node_put(mr_node);
+                free(mp);
+                ipc_answer_0(rid, EBUSY);
+                return;
+        }
+
+        if (str_cmp(mp, "/") == 0) {
+
+                /*
+                 * Unmounting the root file system.
+                 *
+                 * In this case, there is no mount point node and we send
+                 * VFS_OUT_UNMOUNTED directly to the mounted file system.
+                 */
+
+                free(mp);
+                phone = vfs_grab_phone(mr_node->fs_handle);
+                rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED,
+                    mr_node->dev_handle);
+                vfs_release_phone(phone);
+                if (rc != EOK) {
+                        fibril_rwlock_write_unlock(&namespace_rwlock);
+                        vfs_node_put(mr_node);
+                        ipc_answer_0(rid, rc);
+                        return;
+                }
+                rootfs.fs_handle = 0;
+                rootfs.dev_handle = 0;
+        } else {
+
+                /*
+                 * Unmounting a non-root file system.
+                 *
+                 * We have a regular mount point node representing the parent
+                 * file system, so we delegate the operation to it.
+                 */
+
+                /*
+                 * The L_NOCROSS_LAST_MP flag is essential if we really want to
+                 * lookup the mount point and not the mounted root.
+                 */
+                rc = vfs_lookup_internal(mp, L_NOCROSS_LAST_MP, &mp_res, NULL);
+                free(mp);
+                if (rc != EOK) {
+                        fibril_rwlock_write_unlock(&namespace_rwlock);
+                        vfs_node_put(mr_node);
+                        ipc_answer_0(rid, rc);
+                        return;
+                }
+                vfs_node_t *mp_node = vfs_node_get(&mp_res);
+                if (!mp_node) {
+                        fibril_rwlock_write_unlock(&namespace_rwlock);
+                        vfs_node_put(mr_node);
+                        ipc_answer_0(rid, ENOMEM);
+                        return;
+                }
+
+                phone = vfs_grab_phone(mp_node->fs_handle);
+                rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->fs_handle,
+                    mp_node->dev_handle);
+                vfs_release_phone(phone);
+                if (rc != EOK) {
+                        fibril_rwlock_write_unlock(&namespace_rwlock);
+                        vfs_node_put(mp_node);
+                        vfs_node_put(mr_node);
+                        ipc_answer_0(rid, rc);
+                        return;
+                }
+
+                /* Drop the reference we got above. */
+                vfs_node_put(mp_node);
+                /* Drop the reference from when the file system was mounted. */
+                vfs_node_put(mp_node);
+        }
+
+
+        /*
+         * All went well, the mounted file system was successfully unmounted.
+         * The only thing left is to forget the unmounted root VFS node.
+         */
+        vfs_node_forget(mr_node);
+
+        fibril_rwlock_write_unlock(&namespace_rwlock);
+        ipc_answer_0(rid, EOK);
+}
+
 void vfs_open(ipc_callid_t rid, ipc_call_t *request)
 {
@@ -454 +595 @@
         /*
          * Make sure that we are called with exactly one of L_FILE and
-         * L_DIRECTORY. Make sure that the user does not pass L_OPEN.
+         * L_DIRECTORY. Make sure that the user does not pass L_OPEN or
+         * L_NOCROSS_LAST_MP.
          */
         if (((lflag & (L_FILE | L_DIRECTORY)) == 0) ||
             ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
-            ((lflag & L_OPEN) != 0)) {
+            (lflag & L_OPEN) || (lflag & L_NOCROSS_LAST_MP)) {
                 ipc_answer_0(rid, EINVAL);
                 return;