Changes in / [e095644:fea0ce6] 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 (deleted)
• app/bdsh/cmds/modules/unmount/unmount.c (deleted)
• app/bdsh/cmds/modules/unmount/unmount.h (deleted)
• app/bdsh/cmds/modules/unmount/unmount_def.h (deleted)
• 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"
 
@@ -52 +51 @@
 #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,
@@ -141 +140 @@
 
 /**
- * L_OPEN is used to indicate that the lookup operation is a part of VFS_IN_OPEN
+ * L_OPEN is used to indicate that the lookup operation is a part of VFS_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
@@ -148 +147 @@
 #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 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 ((tmp) && (tmp->mp_data.mp_active)) {
                         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
@@ -201 +198 @@
 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);
 }
 
@@ -251 +231 @@
 }
 
-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)
 {
@@ -595 +454 @@
         /*
          * 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 or
-         * L_NOCROSS_LAST_MP.
+         * L_DIRECTORY. Make sure that the user does not pass L_OPEN.
          */
         if (((lflag & (L_FILE | L_DIRECTORY)) == 0) ||
             ((lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) ||
-            (lflag & L_OPEN) || (lflag & L_NOCROSS_LAST_MP)) {
+            ((lflag & L_OPEN) != 0)) {
                 ipc_answer_0(rid, EINVAL);
                 return;