timerfd: support CLOCK_BOOTTIME clock
[linux-3.10.git] / fs / pnode.c
index 3105cca..9af0df1 100644 (file)
@@ -9,34 +9,35 @@
 #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 struct vfsmount *get_peer_under_root(struct vfsmount *mnt,
-                                           struct mnt_namespace *ns,
-                                           const struct path *root)
+static struct mount *get_peer_under_root(struct mount *mnt,
+                                        struct mnt_namespace *ns,
+                                        const struct path *root)
 {
-       struct vfsmount *m = mnt;
+       struct mount *m = mnt;
 
        do {
                /* Check the namespace first for optimization */
-               if (m->mnt_ns == ns && is_path_reachable(m, m->mnt_root, root))
+               if (m->mnt_ns == ns && is_path_reachable(m, m->mnt.mnt_root, root))
                        return m;
 
                m = next_peer(m);
@@ -51,12 +52,12 @@ static struct vfsmount *get_peer_under_root(struct vfsmount *mnt,
  *
  * Caller must hold namespace_sem
  */
-int get_dominating_id(struct vfsmount *mnt, const struct path *root)
+int get_dominating_id(struct mount *mnt, const struct path *root)
 {
-       struct vfsmount *m;
+       struct mount *m;
 
        for (m = mnt->mnt_master; m != NULL; m = m->mnt_master) {
-               struct vfsmount *d = get_peer_under_root(m, mnt->mnt_ns, root);
+               struct mount *d = get_peer_under_root(m, mnt->mnt_ns, root);
                if (d)
                        return d->mnt_group_id;
        }
@@ -64,10 +65,10 @@ int get_dominating_id(struct vfsmount *mnt, const struct path *root)
        return 0;
 }
 
-static int do_make_slave(struct vfsmount *mnt)
+static int do_make_slave(struct mount *mnt)
 {
-       struct vfsmount *peer_mnt = mnt, *master = mnt->mnt_master;
-       struct vfsmount *slave_mnt;
+       struct mount *peer_mnt = mnt, *master = mnt->mnt_master;
+       struct mount *slave_mnt;
 
        /*
         * slave 'mnt' to a peer mount that has the
@@ -75,15 +76,16 @@ static int do_make_slave(struct vfsmount *mnt)
         * 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 (IS_MNT_SHARED(mnt) && list_empty(&mnt->mnt_share))
-               mnt_release_group_id(real_mount(mnt));
+       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;
@@ -101,7 +103,7 @@ static int do_make_slave(struct vfsmount *mnt)
                struct list_head *p = &mnt->mnt_slave_list;
                while (!list_empty(p)) {
                         slave_mnt = list_first_entry(p,
-                                       struct vfsmount, mnt_slave);
+                                       struct mount, mnt_slave);
                        list_del_init(&slave_mnt->mnt_slave);
                        slave_mnt->mnt_master = NULL;
                }
@@ -120,10 +122,10 @@ void change_mnt_propagation(struct mount *mnt, int type)
                set_mnt_shared(mnt);
                return;
        }
-       do_make_slave(&mnt->mnt);
+       do_make_slave(mnt);
        if (type != MS_SLAVE) {
-               list_del_init(&mnt->mnt.mnt_slave);
-               mnt->mnt.mnt_master = NULL;
+               list_del_init(&mnt->mnt_slave);
+               mnt->mnt_master = NULL;
                if (type == MS_UNBINDABLE)
                        mnt->mnt.mnt_flags |= MNT_UNBINDABLE;
                else
@@ -141,20 +143,19 @@ void change_mnt_propagation(struct mount *mnt, int type)
  * 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);
 
@@ -172,13 +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;
+       struct mount *p_last_src = NULL;
+       struct mount *p_last_dest = NULL;
 
        while (last_dest != dest->mnt_master) {
                p_last_dest = last_dest;
@@ -218,35 +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;
-       struct mount *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(real_mount(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 {
                        /*
@@ -256,16 +261,15 @@ int propagate_mnt(struct vfsmount *dest_mnt, struct dentry *dest_dentry,
                        list_add_tail(&child->mnt_hash, &tmp_list);
                }
                prev_dest_mnt = m;
-               prev_src_mnt  = &child->mnt;
+               prev_src_mnt  = child;
        }
 out:
-       br_write_lock(vfsmount_lock);
+       br_write_lock(&vfsmount_lock);
        while (!list_empty(&tmp_list)) {
                child = list_first_entry(&tmp_list, struct mount, mnt_hash);
-               umount_tree(child, 0, &umount_list);
+               umount_tree(child, 0);
        }
-       br_write_unlock(vfsmount_lock);
-       release_mounts(&umount_list);
+       br_write_unlock(&vfsmount_lock);
        return ret;
 }
 
@@ -274,7 +278,7 @@ out:
  */
 static inline int do_refcount_check(struct mount *mnt, int count)
 {
-       int mycount = mnt_get_count(&mnt->mnt) - mnt->mnt.mnt_ghosts;
+       int mycount = mnt_get_count(mnt) - mnt->mnt_ghosts;
        return (mycount > count);
 }
 
@@ -290,12 +294,11 @@ static inline int do_refcount_check(struct mount *mnt, int count)
  */
 int propagate_mount_busy(struct mount *mnt, int refcnt)
 {
-       struct vfsmount *m;
-       struct mount *child;
-       struct vfsmount *parent = mnt->mnt.mnt_parent;
+       struct mount *m, *child;
+       struct mount *parent = mnt->mnt_parent;
        int ret = 0;
 
-       if (&mnt->mnt == parent)
+       if (mnt == parent)
                return do_refcount_check(mnt, refcnt);
 
        /*
@@ -303,13 +306,13 @@ int propagate_mount_busy(struct mount *mnt, int refcnt)
         * If not, we don't have to go checking for all other
         * mounts
         */
-       if (!list_empty(&mnt->mnt.mnt_mounts) || do_refcount_check(mnt, refcnt))
+       if (!list_empty(&mnt->mnt_mounts) || do_refcount_check(mnt, refcnt))
                return 1;
 
        for (m = propagation_next(parent, parent); m;
                        m = propagation_next(m, parent)) {
-               child = __lookup_mnt(m, mnt->mnt.mnt_mountpoint, 0);
-               if (child && list_empty(&child->mnt.mnt_mounts) &&
+               child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint, 0);
+               if (child && list_empty(&child->mnt_mounts) &&
                    (ret = do_refcount_check(child, 1)))
                        break;
        }
@@ -322,21 +325,21 @@ int propagate_mount_busy(struct mount *mnt, int refcnt)
  */
 static void __propagate_umount(struct mount *mnt)
 {
-       struct vfsmount *parent = mnt->mnt.mnt_parent;
-       struct vfsmount *m;
+       struct mount *parent = mnt->mnt_parent;
+       struct mount *m;
 
-       BUG_ON(parent == &mnt->mnt);
+       BUG_ON(parent == mnt);
 
        for (m = propagation_next(parent, parent); m;
                        m = propagation_next(m, parent)) {
 
-               struct mount *child = __lookup_mnt(m,
-                                       mnt->mnt.mnt_mountpoint, 0);
+               struct mount *child = __lookup_mnt(&m->mnt,
+                                       mnt->mnt_mountpoint, 0);
                /*
                 * umount the child only if the child has no
                 * other children
                 */
-               if (child && list_empty(&child->mnt.mnt_mounts))
+               if (child && list_empty(&child->mnt_mounts))
                        list_move_tail(&child->mnt_hash, &mnt->mnt_hash);
        }
 }