1 files changed, 114 insertions, 43 deletions

diff --git a/fs/namespace.c b/fs/namespace.c
index c13072a5f1ee..6ede3a539ed8 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -8,16 +8,17 @@
  * Heavily rewritten.
  */
 
-#include <linux/config.h>
 #include <linux/syscalls.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/smp_lock.h>
 #include <linux/init.h>
+#include <linux/kernel.h>
 #include <linux/quotaops.h>
 #include <linux/acct.h>
 #include <linux/capability.h>
 #include <linux/module.h>
+#include <linux/sysfs.h>
 #include <linux/seq_file.h>
 #include <linux/namespace.h>
 #include <linux/namei.h>
@@ -29,15 +30,6 @@
 
 extern int __init init_rootfs(void);
 
-#ifdef CONFIG_SYSFS
-extern int __init sysfs_init(void);
-#else
-static inline int sysfs_init(void)
-{
-        return 0;
-}
-#endif
-
 /* spinlock for vfsmount related operations, inplace of dcache_lock */
 __cacheline_aligned_in_smp DEFINE_SPINLOCK(vfsmount_lock);
 
@@ -526,10 +518,8 @@ void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill)
 {
         struct vfsmount *p;
 
-        for (p = mnt; p; p = next_mnt(p, mnt)) {
-                list_del(&p->mnt_hash);
-                list_add(&p->mnt_hash, kill);
-        }
+        for (p = mnt; p; p = next_mnt(p, mnt))
+                list_move(&p->mnt_hash, kill);
 
         if (propagate)
                 propagate_umount(kill);
@@ -585,8 +575,8 @@ static int do_umount(struct vfsmount *mnt, int flags)
          */
 
         lock_kernel();
-        if ((flags & MNT_FORCE) && sb->s_op->umount_begin)
-                sb->s_op->umount_begin(sb);
+        if (sb->s_op->umount_begin)
+                sb->s_op->umount_begin(mnt, flags);
         unlock_kernel();
 
         /*
@@ -1172,13 +1162,46 @@ static void expire_mount(struct vfsmount *mnt, struct list_head *mounts,
 }
 
 /*
+ * go through the vfsmounts we've just consigned to the graveyard to
+ * - check that they're still dead
+ * - delete the vfsmount from the appropriate namespace under lock
+ * - dispose of the corpse
+ */
+static void expire_mount_list(struct list_head *graveyard, struct list_head *mounts)
+{
+        struct namespace *namespace;
+        struct vfsmount *mnt;
+
+        while (!list_empty(graveyard)) {
+                LIST_HEAD(umounts);
+                mnt = list_entry(graveyard->next, struct vfsmount, mnt_expire);
+                list_del_init(&mnt->mnt_expire);
+
+                /* don't do anything if the namespace is dead - all the
+                 * vfsmounts from it are going away anyway */
+                namespace = mnt->mnt_namespace;
+                if (!namespace || !namespace->root)
+                        continue;
+                get_namespace(namespace);
+
+                spin_unlock(&vfsmount_lock);
+                down_write(&namespace_sem);
+                expire_mount(mnt, mounts, &umounts);
+                up_write(&namespace_sem);
+                release_mounts(&umounts);
+                mntput(mnt);
+                put_namespace(namespace);
+                spin_lock(&vfsmount_lock);
+        }
+}
+
+/*
  * process a list of expirable mountpoints with the intent of discarding any
  * mountpoints that aren't in use and haven't been touched since last we came
  * here
  */
 void mark_mounts_for_expiry(struct list_head *mounts)
 {
-        struct namespace *namespace;
         struct vfsmount *mnt, *next;
         LIST_HEAD(graveyard);
 
@@ -1202,38 +1225,79 @@ void mark_mounts_for_expiry(struct list_head *mounts)
                 list_move(&mnt->mnt_expire, &graveyard);
         }
 
-        /*
-         * go through the vfsmounts we've just consigned to the graveyard to
-         * - check that they're still dead
-         * - delete the vfsmount from the appropriate namespace under lock
-         * - dispose of the corpse
-         */
-        while (!list_empty(&graveyard)) {
-                LIST_HEAD(umounts);
-                mnt = list_entry(graveyard.next, struct vfsmount, mnt_expire);
-                list_del_init(&mnt->mnt_expire);
+        expire_mount_list(&graveyard, mounts);
 
-                /* don't do anything if the namespace is dead - all the
-                 * vfsmounts from it are going away anyway */
-                namespace = mnt->mnt_namespace;
-                if (!namespace || !namespace->root)
+        spin_unlock(&vfsmount_lock);
+}
+
+EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
+
+/*
+ * Ripoff of 'select_parent()'
+ *
+ * search the list of submounts for a given mountpoint, and move any
+ * shrinkable submounts to the 'graveyard' list.
+ */
+static int select_submounts(struct vfsmount *parent, struct list_head *graveyard)
+{
+        struct vfsmount *this_parent = parent;
+        struct list_head *next;
+        int found = 0;
+
+repeat:
+        next = this_parent->mnt_mounts.next;
+resume:
+        while (next != &this_parent->mnt_mounts) {
+                struct list_head *tmp = next;
+                struct vfsmount *mnt = list_entry(tmp, struct vfsmount, mnt_child);
+
+                next = tmp->next;
+                if (!(mnt->mnt_flags & MNT_SHRINKABLE))
                         continue;
-                get_namespace(namespace);
+                /*
+                 * Descend a level if the d_mounts list is non-empty.
+                 */
+                if (!list_empty(&mnt->mnt_mounts)) {
+                        this_parent = mnt;
+                        goto repeat;
+                }
 
-                spin_unlock(&vfsmount_lock);
-                down_write(&namespace_sem);
-                expire_mount(mnt, mounts, &umounts);
-                up_write(&namespace_sem);
-                release_mounts(&umounts);
-                mntput(mnt);
-                put_namespace(namespace);
-                spin_lock(&vfsmount_lock);
+                if (!propagate_mount_busy(mnt, 1)) {
+                        mntget(mnt);
+                        list_move_tail(&mnt->mnt_expire, graveyard);
+                        found++;
+                }
+        }
+        /*
+         * All done at this level ... ascend and resume the search
+         */
+        if (this_parent != parent) {
+                next = this_parent->mnt_child.next;
+                this_parent = this_parent->mnt_parent;
+                goto resume;
         }
+        return found;
+}
+
+/*
+ * process a list of expirable mountpoints with the intent of discarding any
+ * submounts of a specific parent mountpoint
+ */
+void shrink_submounts(struct vfsmount *mountpoint, struct list_head *mounts)
+{
+        LIST_HEAD(graveyard);
+        int found;
+
+        spin_lock(&vfsmount_lock);
+
+        /* extract submounts of 'mountpoint' from the expiration list */
+        while ((found = select_submounts(mountpoint, &graveyard)) != 0)
+                expire_mount_list(&graveyard, mounts);
 
         spin_unlock(&vfsmount_lock);
 }
 
-EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
+EXPORT_SYMBOL_GPL(shrink_submounts);
 
 /*
  * Some copy_from_user() implementations do not return the exact number of
@@ -1750,6 +1814,7 @@ void __init mnt_init(unsigned long mempages)
         struct list_head *d;
         unsigned int nr_hash;
         int i;
+        int err;
 
         init_rwsem(&namespace_sem);
 
@@ -1790,8 +1855,14 @@ void __init mnt_init(unsigned long mempages)
                 d++;
                 i--;
         } while (i);
-        sysfs_init();
-        subsystem_register(&fs_subsys);
+        err = sysfs_init();
+        if (err)
+                printk(KERN_WARNING "%s: sysfs_init error: %d\n",
+                        __FUNCTION__, err);
+        err = subsystem_register(&fs_subsys);
+        if (err)
+                printk(KERN_WARNING "%s: subsystem_register error: %d\n",
+                        __FUNCTION__, err);
         init_rootfs();
         init_mount_tree();
 }