timerfd: support CLOCK_BOOTTIME clock
[linux-3.10.git] / fs / pnode.c
index da42ee6..9af0df1 100644 (file)
@@ -6,46 +6,89 @@
  *     Author : Ram Pai (linuxram@us.ibm.com)
  *
  */
-#include <linux/namespace.h>
+#include <linux/mnt_namespace.h>
 #include <linux/mount.h>
 #include <linux/fs.h>
+#include <linux/nsproxy.h>
+#include "internal.h"
 #include "pnode.h"
 
 /* return the next shared peer mount of @p */
-static inline struct vfsmount *next_peer(struct vfsmount *p)
+static inline struct mount *next_peer(struct mount *p)
 {
-       return list_entry(p->mnt_share.next, struct vfsmount, mnt_share);
+       return list_entry(p->mnt_share.next, struct mount, mnt_share);
 }
 
-static inline struct vfsmount *first_slave(struct vfsmount *p)
+static inline struct mount *first_slave(struct mount *p)
 {
-       return list_entry(p->mnt_slave_list.next, struct vfsmount, mnt_slave);
+       return list_entry(p->mnt_slave_list.next, struct mount, mnt_slave);
 }
 
-static inline struct vfsmount *next_slave(struct vfsmount *p)
+static inline struct mount *next_slave(struct mount *p)
 {
-       return list_entry(p->mnt_slave.next, struct vfsmount, mnt_slave);
+       return list_entry(p->mnt_slave.next, struct mount, mnt_slave);
 }
 
-static int do_make_slave(struct vfsmount *mnt)
+static struct mount *get_peer_under_root(struct mount *mnt,
+                                        struct mnt_namespace *ns,
+                                        const struct path *root)
 {
-       struct vfsmount *peer_mnt = mnt, *master = mnt->mnt_master;
-       struct vfsmount *slave_mnt;
+       struct mount *m = mnt;
+
+       do {
+               /* Check the namespace first for optimization */
+               if (m->mnt_ns == ns && is_path_reachable(m, m->mnt.mnt_root, root))
+                       return m;
+
+               m = next_peer(m);
+       } while (m != mnt);
+
+       return NULL;
+}
+
+/*
+ * Get ID of closest dominating peer group having a representative
+ * under the given root.
+ *
+ * Caller must hold namespace_sem
+ */
+int get_dominating_id(struct mount *mnt, const struct path *root)
+{
+       struct mount *m;
+
+       for (m = mnt->mnt_master; m != NULL; m = m->mnt_master) {
+               struct mount *d = get_peer_under_root(m, mnt->mnt_ns, root);
+               if (d)
+                       return d->mnt_group_id;
+       }
+
+       return 0;
+}
+
+static int do_make_slave(struct mount *mnt)
+{
+       struct mount *peer_mnt = mnt, *master = mnt->mnt_master;
+       struct mount *slave_mnt;
 
        /*
         * slave 'mnt' to a peer mount that has the
-        * same root dentry. If none is available than
+        * same root dentry. If none is available then
         * slave it to anything that is available.
         */
        while ((peer_mnt = next_peer(peer_mnt)) != mnt &&
-              peer_mnt->mnt_root != mnt->mnt_root) ;
+              peer_mnt->mnt.mnt_root != mnt->mnt.mnt_root) ;
 
        if (peer_mnt == mnt) {
                peer_mnt = next_peer(mnt);
                if (peer_mnt == mnt)
                        peer_mnt = NULL;
        }
+       if (mnt->mnt_group_id && IS_MNT_SHARED(mnt) &&
+           list_empty(&mnt->mnt_share))
+               mnt_release_group_id(mnt);
+
        list_del_init(&mnt->mnt_share);
+       mnt->mnt_group_id = 0;
 
        if (peer_mnt)
                master = peer_mnt;
@@ -59,19 +102,21 @@ static int do_make_slave(struct vfsmount *mnt)
        } else {
                struct list_head *p = &mnt->mnt_slave_list;
                while (!list_empty(p)) {
-                        slave_mnt = list_entry(p->next,
-                                       struct vfsmount, mnt_slave);
+                        slave_mnt = list_first_entry(p,
+                                       struct mount, mnt_slave);
                        list_del_init(&slave_mnt->mnt_slave);
                        slave_mnt->mnt_master = NULL;
                }
        }
        mnt->mnt_master = master;
        CLEAR_MNT_SHARED(mnt);
-       INIT_LIST_HEAD(&mnt->mnt_slave_list);
        return 0;
 }
 
-void change_mnt_propagation(struct vfsmount *mnt, int type)
+/*
+ * vfsmount lock must be held for write
+ */
+void change_mnt_propagation(struct mount *mnt, int type)
 {
        if (type == MS_SHARED) {
                set_mnt_shared(mnt);
@@ -82,7 +127,9 @@ void change_mnt_propagation(struct vfsmount *mnt, int type)
                list_del_init(&mnt->mnt_slave);
                mnt->mnt_master = NULL;
                if (type == MS_UNBINDABLE)
-                       mnt->mnt_flags |= MNT_UNBINDABLE;
+                       mnt->mnt.mnt_flags |= MNT_UNBINDABLE;
+               else
+                       mnt->mnt.mnt_flags &= ~MNT_UNBINDABLE;
        }
 }
 
@@ -90,21 +137,25 @@ void change_mnt_propagation(struct vfsmount *mnt, int type)
  * get the next mount in the propagation tree.
  * @m: the mount seen last
  * @origin: the original mount from where the tree walk initiated
+ *
+ * Note that peer groups form contiguous segments of slave lists.
+ * We rely on that in get_source() to be able to find out if
+ * vfsmount found while iterating with propagation_next() is
+ * a peer of one we'd found earlier.
  */
-static struct vfsmount *propagation_next(struct vfsmount *m,
-                                        struct vfsmount *origin)
+static struct mount *propagation_next(struct mount *m,
+                                        struct mount *origin)
 {
        /* are there any slaves of this mount? */
        if (!IS_MNT_NEW(m) && !list_empty(&m->mnt_slave_list))
                return first_slave(m);
 
        while (1) {
-               struct vfsmount *next;
-               struct vfsmount *master = m->mnt_master;
+               struct mount *master = m->mnt_master;
 
                if (master == origin->mnt_master) {
-                       next = next_peer(m);
-                       return ((next == origin) ? NULL : next);
+                       struct mount *next = next_peer(m);
+                       return (next == origin) ? NULL : next;
                } else if (m->mnt_slave.next != &master->mnt_slave_list)
                        return next_slave(m);
 
@@ -122,17 +173,13 @@ static struct vfsmount *propagation_next(struct vfsmount *m,
  * @type       return CL_SLAVE if the new mount has to be
  *             cloned as a slave.
  */
-static struct vfsmount *get_source(struct vfsmount *dest,
-                                       struct vfsmount *last_dest,
-                                       struct vfsmount *last_src,
-                                       int *type)
+static struct mount *get_source(struct mount *dest,
+                               struct mount *last_dest,
+                               struct mount *last_src,
+                               int *type)
 {
-       struct vfsmount *p_last_src = NULL;
-       struct vfsmount *p_last_dest = NULL;
-       *type = CL_PROPAGATION;
-
-       if (IS_MNT_SHARED(dest))
-               *type |= CL_MAKE_SHARED;
+       struct mount *p_last_src = NULL;
+       struct mount *p_last_dest = NULL;
 
        while (last_dest != dest->mnt_master) {
                p_last_dest = last_dest;
@@ -145,13 +192,18 @@ static struct vfsmount *get_source(struct vfsmount *dest,
                do {
                        p_last_dest = next_peer(p_last_dest);
                } while (IS_MNT_NEW(p_last_dest));
+               /* is that a peer of the earlier? */
+               if (dest == p_last_dest) {
+                       *type = CL_MAKE_SHARED;
+                       return p_last_src;
+               }
        }
-
-       if (dest != p_last_dest) {
-               *type |= CL_SLAVE;
-               return last_src;
-       } else
-               return p_last_src;
+       /* slave of the earlier, then */
+       *type = CL_SLAVE;
+       /* beginning of peer group among the slaves? */
+       if (IS_MNT_SHARED(dest))
+               *type |= CL_MAKE_SHARED;
+       return last_src;
 }
 
 /*
@@ -167,34 +219,39 @@ static struct vfsmount *get_source(struct vfsmount *dest,
  * @source_mnt: source mount.
  * @tree_list : list of heads of trees to be attached.
  */
-int propagate_mnt(struct vfsmount *dest_mnt, struct dentry *dest_dentry,
-                   struct vfsmount *source_mnt, struct list_head *tree_list)
+int propagate_mnt(struct mount *dest_mnt, struct mountpoint *dest_mp,
+                   struct mount *source_mnt, struct list_head *tree_list)
 {
-       struct vfsmount *m, *child;
+       struct user_namespace *user_ns = current->nsproxy->mnt_ns->user_ns;
+       struct mount *m, *child;
        int ret = 0;
-       struct vfsmount *prev_dest_mnt = dest_mnt;
-       struct vfsmount *prev_src_mnt  = source_mnt;
+       struct mount *prev_dest_mnt = dest_mnt;
+       struct mount *prev_src_mnt  = source_mnt;
        LIST_HEAD(tmp_list);
-       LIST_HEAD(umount_list);
 
        for (m = propagation_next(dest_mnt, dest_mnt); m;
                        m = propagation_next(m, dest_mnt)) {
                int type;
-               struct vfsmount *source;
+               struct mount *source;
 
                if (IS_MNT_NEW(m))
                        continue;
 
                source =  get_source(m, prev_dest_mnt, prev_src_mnt, &type);
 
-               if (!(child = copy_tree(source, source->mnt_root, type))) {
-                       ret = -ENOMEM;
+               /* Notice when we are propagating across user namespaces */
+               if (m->mnt_ns->user_ns != user_ns)
+                       type |= CL_UNPRIVILEGED;
+
+               child = copy_tree(source, source->mnt.mnt_root, type);
+               if (IS_ERR(child)) {
+                       ret = PTR_ERR(child);
                        list_splice(tree_list, tmp_list.prev);
                        goto out;
                }
 
-               if (is_subdir(dest_dentry, m->mnt_root)) {
-                       mnt_set_mountpoint(m, dest_dentry, child);
+               if (is_subdir(dest_mp->m_dentry, m->mnt.mnt_root)) {
+                       mnt_set_mountpoint(m, dest_mp, child);
                        list_add_tail(&child->mnt_hash, tree_list);
                } else {
                        /*
@@ -207,23 +264,21 @@ int propagate_mnt(struct vfsmount *dest_mnt, struct dentry *dest_dentry,
                prev_src_mnt  = child;
        }
 out:
-       spin_lock(&vfsmount_lock);
+       br_write_lock(&vfsmount_lock);
        while (!list_empty(&tmp_list)) {
-               child = list_entry(tmp_list.next, struct vfsmount, mnt_hash);
-               list_del_init(&child->mnt_hash);
-               umount_tree(child, 0, &umount_list);
+               child = list_first_entry(&tmp_list, struct mount, mnt_hash);
+               umount_tree(child, 0);
        }
-       spin_unlock(&vfsmount_lock);
-       release_mounts(&umount_list);
+       br_write_unlock(&vfsmount_lock);
        return ret;
 }
 
 /*
  * return true if the refcount is greater than count
  */
-static inline int do_refcount_check(struct vfsmount *mnt, int count)
+static inline int do_refcount_check(struct mount *mnt, int count)
 {
-       int mycount = atomic_read(&mnt->mnt_count);
+       int mycount = mnt_get_count(mnt) - mnt->mnt_ghosts;
        return (mycount > count);
 }
 
@@ -234,11 +289,13 @@ static inline int do_refcount_check(struct vfsmount *mnt, int count)
  * other mounts its parent propagates to.
  * Check if any of these mounts that **do not have submounts**
  * have more references than 'refcnt'. If so return busy.
+ *
+ * vfsmount lock must be held for write
  */
-int propagate_mount_busy(struct vfsmount *mnt, int refcnt)
+int propagate_mount_busy(struct mount *mnt, int refcnt)
 {
-       struct vfsmount *m, *child;
-       struct vfsmount *parent = mnt->mnt_parent;
+       struct mount *m, *child;
+       struct mount *parent = mnt->mnt_parent;
        int ret = 0;
 
        if (mnt == parent)
@@ -254,7 +311,7 @@ int propagate_mount_busy(struct vfsmount *mnt, int refcnt)
 
        for (m = propagation_next(parent, parent); m;
                        m = propagation_next(m, parent)) {
-               child = __lookup_mnt(m, mnt->mnt_mountpoint, 0);
+               child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint, 0);
                if (child && list_empty(&child->mnt_mounts) &&
                    (ret = do_refcount_check(child, 1)))
                        break;
@@ -266,17 +323,17 @@ int propagate_mount_busy(struct vfsmount *mnt, int refcnt)
  * NOTE: unmounting 'mnt' naturally propagates to all other mounts its
  * parent propagates to.
  */
-static void __propagate_umount(struct vfsmount *mnt)
+static void __propagate_umount(struct mount *mnt)
 {
-       struct vfsmount *parent = mnt->mnt_parent;
-       struct vfsmount *m;
+       struct mount *parent = mnt->mnt_parent;
+       struct mount *m;
 
        BUG_ON(parent == mnt);
 
        for (m = propagation_next(parent, parent); m;
                        m = propagation_next(m, parent)) {
 
-               struct vfsmount *child = __lookup_mnt(m,
+               struct mount *child = __lookup_mnt(&m->mnt,
                                        mnt->mnt_mountpoint, 0);
                /*
                 * umount the child only if the child has no
@@ -291,10 +348,12 @@ static void __propagate_umount(struct vfsmount *mnt)
  * collect all mounts that receive propagation from the mount in @list,
  * and return these additional mounts in the same list.
  * @list: the list of mounts to be unmounted.
+ *
+ * vfsmount lock must be held for write
  */
 int propagate_umount(struct list_head *list)
 {
-       struct vfsmount *mnt;
+       struct mount *mnt;
 
        list_for_each_entry(mnt, list, mnt_hash)
                __propagate_umount(mnt);