[RFC PATCH v5 07/25] mount: Support MOVE_MOUNT_CLONE with MOVE_MOUNT_T_MNTNS
From: Jarkko Sakkinen
Date: Fri Nov 20 2026 - 19:09:46 EST
Unprivileged container managers cannot use open_tree(OPEN_TREE_CLONE) in
the host mount namespace because it requires may_mount() against the
caller's current mount namespace rather than the destination namespace.
Add MOVE_MOUNT_CLONE for use with MOVE_MOUNT_T_MNTNS so move_mount() can
recursively loopback-clone a path from the caller's mount namespace
directly into the target mount namespace file descriptor. Authorize the
operation against CAP_SYS_ADMIN in target_mnt_ns->user_ns, apply
CL_SLAVE | CL_COPY_UNBINDABLE when crossing user namespace boundaries,
and lock cross-user-namespace cloned subtrees with MNT_LOCKED inside
attach_recursive_mnt().
Signed-off-by: Jarkko Sakkinen <jarkko@xxxxxxxxxx>
---
fs/namespace.c | 106 +++++++++++++++++++++++++++----------
include/uapi/linux/mount.h | 3 +-
2 files changed, 80 insertions(+), 29 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index b65f1fdd9281..1e7d776c0966 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2573,13 +2573,15 @@ enum mnt_tree_flags_t {
MNT_TREE_PROPAGATION = BIT(1),
MNT_TREE_MNTNS = BIT(2),
MNT_TREE_MNTNS_INIT = BIT(3),
+ MNT_TREE_CLONE = BIT(4),
};
/**
* attach_recursive_mnt - attach a source mount tree
* @source_mnt: mount tree to be attached
* @dest: the context for mounting at the place where the tree should go
- * @move_mntns: whether @source_mnt is attached via MOVE_MOUNT_T_MNTNS
+ * @src_user_ns: owning user namespace of @source_mnt for MOVE_MOUNT_T_MNTNS,
+ * or NULL
*
* NOTE: in the table below explains the semantics when a source mount
* of a given type is attached to a destination mount of a given type.
@@ -2643,7 +2645,7 @@ enum mnt_tree_flags_t {
*/
static int attach_recursive_mnt(struct mount *source_mnt,
const struct pinned_mountpoint *dest,
- bool move_mntns)
+ struct user_namespace *src_user_ns)
{
struct mount *dest_mnt = dest->parent;
struct mountpoint *dest_mp = dest->mp;
@@ -2652,7 +2654,6 @@ static int attach_recursive_mnt(struct mount *source_mnt,
struct user_namespace *user_ns = ns->user_ns;
struct pinned_mountpoint root = {};
struct mountpoint *shorter = NULL;
- struct mnt_namespace *src_ns;
struct mount *child, *p;
struct mount *top;
struct hlist_node *n;
@@ -2670,13 +2671,12 @@ static int attach_recursive_mnt(struct mount *source_mnt,
* the attaching task's mount namespace is authoritative, not
* the creator of the detached tree.
*/
- if (is_anon_ns(ns))
+ if (src_user_ns)
+ user_ns = src_user_ns;
+ else if (is_anon_ns(ns))
user_ns = current->nsproxy->mnt_ns->user_ns;
else
user_ns = ns->user_ns;
- src_ns = moving ? NULL : source_mnt->mnt_ns;
- if (move_mntns && src_ns)
- user_ns = src_ns->user_ns;
/*
* Preallocate a mountpoint in case the new mounts need to be
@@ -2745,7 +2745,7 @@ static int attach_recursive_mnt(struct mount *source_mnt,
/* Notice when we are propagating across user namespaces */
if (child->mnt_parent->mnt_ns->user_ns != user_ns) {
lock_mnt_tree(child);
- if ((move_mntns || is_anon_ns(ns)) &&
+ if ((src_user_ns || is_anon_ns(ns)) &&
list_empty(&child->mnt_expire))
child->mnt.mnt_flags |= MNT_LOCKED;
}
@@ -2956,7 +2956,7 @@ static int graft_tree(struct mount *mnt, const struct pinned_mountpoint *mp)
d_is_dir(mnt->mnt.mnt_root))
return -ENOTDIR;
- return attach_recursive_mnt(mnt, mp, false);
+ return attach_recursive_mnt(mnt, mp, NULL);
}
static int may_change_propagation(const struct mount *m)
@@ -3799,29 +3799,27 @@ static int do_move_mount(const struct path *old_path,
struct mnt_namespace *target_mnt_ns)
{
struct mount *old = real_mount(old_path->mnt);
+ struct user_namespace *src_user_ns = NULL;
+ struct mount *cloned = NULL;
struct mnt_namespace *dest_mnt_ns;
int err;
bool beneath = flags & MNT_TREE_BENEATH;
- if (!path_mounted(old_path))
+ if (!(flags & MNT_TREE_CLONE) && !path_mounted(old_path))
return -EINVAL;
if (d_is_dir(new_path->dentry) != d_is_dir(old_path->dentry))
return -EINVAL;
+ if ((flags & MNT_TREE_CLONE) && mnt_ns_loop(old_path->dentry))
+ return -EINVAL;
+
LOCK_MOUNT_MAYBE_BENEATH(mp, new_path, beneath);
if (IS_ERR(mp.parent))
return PTR_ERR(mp.parent);
if (flags & MNT_TREE_MNTNS) {
- u64 seq;
-
- if (!anon_ns_root(old) || old->mnt_ns == mp.parent->mnt_ns ||
- mp.parent->mnt_ns != target_mnt_ns)
- return -EINVAL;
- seq = old->mnt_ns->seq_origin;
- if (seq && seq != target_mnt_ns->ns.ns_id &&
- seq != current->nsproxy->mnt_ns->ns.ns_id)
+ if (mp.parent->mnt_ns != target_mnt_ns)
return -EINVAL;
if (flags & MNT_TREE_MNTNS_INIT) {
if (mp.parent != target_mnt_ns->root)
@@ -3835,6 +3833,35 @@ static int do_move_mount(const struct path *old_path,
if (m == target_mnt_ns->root)
return beneath ? -EINVAL : -EBUSY;
}
+ if (flags & MNT_TREE_CLONE) {
+ unsigned int copy_flags;
+
+ if (!check_mnt(old) || old->mnt_ns == target_mnt_ns)
+ return -EINVAL;
+ src_user_ns = old->mnt_ns->user_ns;
+ copy_flags = (target_mnt_ns->user_ns != src_user_ns) ?
+ (CL_SLAVE | CL_COPY_UNBINDABLE) :
+ CL_COPY_MNT_NS_FILE;
+ cloned = __do_loopback(old_path, true, copy_flags);
+ if (IS_ERR(cloned))
+ return PTR_ERR(cloned);
+ old = cloned;
+ if (d_is_symlink(old->mnt.mnt_root)) {
+ err = -EINVAL;
+ goto out_cloned;
+ }
+ } else {
+ u64 seq;
+
+ if (!anon_ns_root(old) ||
+ old->mnt_ns == mp.parent->mnt_ns)
+ return -EINVAL;
+ seq = old->mnt_ns->seq_origin;
+ if (seq && seq != target_mnt_ns->ns.ns_id &&
+ seq != current->nsproxy->mnt_ns->ns.ns_id)
+ return -EINVAL;
+ src_user_ns = old->mnt_ns->user_ns;
+ }
} else if (check_mnt(old)) {
/* if the source is in our namespace... */
/* ... it should be detachable from parent */
@@ -3874,23 +3901,36 @@ static int do_move_mount(const struct path *old_path,
over = mp.parent->overmount;
err = can_move_mount_beneath(old, over, &mp);
if (err)
- return err;
+ goto out_cloned;
}
/*
* Don't move a mount tree containing unbindable mounts to a destination
* mount which is shared.
*/
- if (IS_MNT_SHARED(mp.parent) && tree_contains_unbindable(old))
- return -EINVAL;
+ if (IS_MNT_SHARED(mp.parent) && tree_contains_unbindable(old)) {
+ err = -EINVAL;
+ goto out_cloned;
+ }
dest_mnt_ns = is_anon_ns(mp.parent->mnt_ns) ?
current->nsproxy->mnt_ns : mp.parent->mnt_ns;
- if (!check_for_nsfs_mounts(old, dest_mnt_ns))
- return -ELOOP;
- if (mount_is_ancestor(old, mp.parent))
- return -ELOOP;
+ if (!check_for_nsfs_mounts(old, dest_mnt_ns)) {
+ err = -ELOOP;
+ goto out_cloned;
+ }
+ if (mount_is_ancestor(old, mp.parent)) {
+ err = -ELOOP;
+ goto out_cloned;
+ }
- return attach_recursive_mnt(old, &mp, flags & MNT_TREE_MNTNS);
+ err = attach_recursive_mnt(old, &mp, src_user_ns);
+out_cloned:
+ if (err && cloned) {
+ lock_mount_hash();
+ umount_tree(cloned, UMOUNT_SYNC);
+ unlock_mount_hash();
+ }
+ return err;
}
static int do_move_mount_old(const struct path *path, const char *old_name)
@@ -4816,8 +4856,8 @@ static int lookup_move_mount_from(int from_dfd,
/**
* DOC: MOVE_MOUNT_T_MNTNS
*
- * ``MOVE_MOUNT_T_MNTNS`` installs detached anonymous mount trees into a target
- * mount namespace ``nsfs`` file descriptor supplied as ``to_dfd``:
+ * ``MOVE_MOUNT_T_MNTNS`` installs mount trees into a target mount namespace
+ * ``nsfs`` file descriptor supplied as ``to_dfd``:
*
* 1. ``to_pathname`` of ``"/"`` attaches the initial root mount onto the
* ``nullfs`` root of an empty mount namespace at most once.
@@ -4825,6 +4865,11 @@ static int lookup_move_mount_from(int from_dfd,
* 2. Relative ``to_pathname`` values resolve beneath the live root of the
* target mount namespace.
*
+ * 3. Combining ``MOVE_MOUNT_CLONE`` with ``MOVE_MOUNT_T_MNTNS`` recursively
+ * loopback-clones ``from_pathname`` from the caller's mount namespace into
+ * ``to_dfd`` without requiring ``OPEN_TREE_CLONE`` or ``may_mount()`` in
+ * the caller's own mount namespace.
+ *
* Capability is checked against ``CAP_SYS_ADMIN`` in the target mount
* namespace's owning user namespace, and source trees crossing user namespace
* boundaries are locked with ``MNT_LOCKED`` and locked mount flags.
@@ -4926,12 +4971,17 @@ SYSCALL_DEFINE5(move_mount,
if (flags & ~MOVE_MOUNT__MASK)
return -EINVAL;
+ if ((flags & MOVE_MOUNT_CLONE) && !(flags & MOVE_MOUNT_T_MNTNS))
+ return -EINVAL;
+
if ((flags & (MOVE_MOUNT_BENEATH | MOVE_MOUNT_SET_GROUP)) ==
(MOVE_MOUNT_BENEATH | MOVE_MOUNT_SET_GROUP))
return -EINVAL;
if (flags & MOVE_MOUNT_SET_GROUP) mflags |= MNT_TREE_PROPAGATION;
if (flags & MOVE_MOUNT_BENEATH) mflags |= MNT_TREE_BENEATH;
+ if (flags & MOVE_MOUNT_CLONE)
+ mflags |= MNT_TREE_CLONE;
if (unlikely(flags & MOVE_MOUNT_T_MNTNS)) {
if (flags & (MOVE_MOUNT_T_EMPTY_PATH | MOVE_MOUNT_SET_GROUP))
diff --git a/include/uapi/linux/mount.h b/include/uapi/linux/mount.h
index 7d413418426a..cb4f7175db02 100644
--- a/include/uapi/linux/mount.h
+++ b/include/uapi/linux/mount.h
@@ -78,7 +78,8 @@
#define MOVE_MOUNT_T_MNTNS 0x00000080 /* Resolve to_dfd as mntns fd */
#define MOVE_MOUNT_SET_GROUP 0x00000100 /* Set sharing group instead */
#define MOVE_MOUNT_BENEATH 0x00000200 /* Mount beneath top mount */
-#define MOVE_MOUNT__MASK 0x000003f7
+#define MOVE_MOUNT_CLONE 0x00000400 /* Recursively clone from path */
+#define MOVE_MOUNT__MASK 0x000007f7
/*
* fsopen() flags.
--
2.47.3