From: Jarkko Sakkinen <jarkko@kernel.org>
To: linux-fsdevel@vger.kernel.org
Cc: Jarkko Sakkinen <jarkko@kernel.org>,
linux-api@vger.kernel.org, linux-doc@vger.kernel.org,
linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org,
linux-mm@kvack.org, linux-security-module@vger.kernel.org,
Alexander Mikhalitsyn <alex@amutable.com>,
Alexander Viro <viro@zeniv.linux.org.uk>,
Andy Lutomirski <luto@amacapital.net>,
Christian Brauner <brauner@kernel.org>,
David Howells <dhowells@redhat.com>, Jan Kara <jack@suse.cz>,
Jonathan Corbet <corbet@lwn.net>,
Josef Bacik <josef@toxicpanda.com>, Kees Cook <kees@kernel.org>,
Neal Gompa <neal@gompa.dev>, Paul Moore <paul@paul-moore.com>,
Serge Hallyn <sergeh@kernel.org>,
Zygmunt Krynicki <zygmunt.krynicki@canonical.com>
Subject: [RFC PATCH v5 24/25] selftests/rootns: Add root namespace test suite
Date: Sat, 21 Nov 2026 02:08:43 +0200 [thread overview]
Message-ID: <20261121000844.1863324-25-jarkko@kernel.org> (raw)
In-Reply-To: <20261121000844.1863324-1-jarkko@kernel.org>
Verify the root namespace, mount-namespace configuration, and
userns_set_idmap() uAPI and security invariants across privileged,
unprivileged, SCM_RIGHTS delegation, and edge-case scenarios.
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
tools/testing/selftests/Makefile | 1 +
tools/testing/selftests/rootns/Makefile | 5 +
tools/testing/selftests/rootns/config | 10 +
.../testing/selftests/rootns/rootns_cells.py | 1400 ++++++++++++++
tools/testing/selftests/rootns/rootns_test.py | 1645 +++++++++++++++++
tools/testing/selftests/rootns/test_smoke.sh | 10 +
6 files changed, 3071 insertions(+)
create mode 100644 tools/testing/selftests/rootns/Makefile
create mode 100644 tools/testing/selftests/rootns/config
create mode 100755 tools/testing/selftests/rootns/rootns_cells.py
create mode 100755 tools/testing/selftests/rootns/rootns_test.py
create mode 100755 tools/testing/selftests/rootns/test_smoke.sh
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 07c3719f8b04..7c44f93e57a4 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -117,6 +117,7 @@ TARGETS += rdma
TARGETS += resctrl
TARGETS += riscv
TARGETS += rlimits
+TARGETS += rootns
TARGETS += rseq
TARGETS += rtc
TARGETS += rust
diff --git a/tools/testing/selftests/rootns/Makefile b/tools/testing/selftests/rootns/Makefile
new file mode 100644
index 000000000000..62629d112e12
--- /dev/null
+++ b/tools/testing/selftests/rootns/Makefile
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0
+include ../lib.mk
+
+TEST_PROGS := test_smoke.sh
+TEST_PROGS_EXTENDED := rootns_cells.py rootns_test.py
diff --git a/tools/testing/selftests/rootns/config b/tools/testing/selftests/rootns/config
new file mode 100644
index 000000000000..21b1aecc003b
--- /dev/null
+++ b/tools/testing/selftests/rootns/config
@@ -0,0 +1,10 @@
+CONFIG_CGROUPS=y
+CONFIG_IPC_NS=y
+CONFIG_NET_NS=y
+CONFIG_PID_NS=y
+CONFIG_PROC_FS=y
+CONFIG_ROOTNS=y
+CONFIG_TIME_NS=y
+CONFIG_TMPFS=y
+CONFIG_USER_NS=y
+CONFIG_UTS_NS=y
diff --git a/tools/testing/selftests/rootns/rootns_cells.py b/tools/testing/selftests/rootns/rootns_cells.py
new file mode 100755
index 000000000000..733e45b39a8a
--- /dev/null
+++ b/tools/testing/selftests/rootns/rootns_cells.py
@@ -0,0 +1,1400 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-2.0
+#
+# Copyright (C) 2026 Opinsys Oy
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import suppress
+import ctypes
+from dataclasses import asdict, dataclass, field
+from enum import Enum, IntEnum, IntFlag
+import errno
+import json
+import os
+import platform
+import selectors
+import signal
+import socket
+import sys
+from types import TracebackType
+from typing import Any, ClassVar, Final, NoReturn
+
+HOST_RUNTIME_ENTRIES: Final[tuple[str, ...]] = (
+ "usr",
+ "bin",
+ "sbin",
+ "lib",
+ "lib32",
+ "lib64",
+ "libx32",
+ "etc",
+ "opt",
+ "nix",
+)
+
+
+class RootnsFlag(IntFlag):
+ NONE = 0
+ KILL_ON_CLOSE = 0x00000001
+ CLOSE_ON_EXEC = 0x00000002
+ DEFAULT = KILL_ON_CLOSE | CLOSE_ON_EXEC
+ ALL = KILL_ON_CLOSE | CLOSE_ON_EXEC
+
+
+class CloneFlag(IntFlag):
+ NONE = 0
+ NEWTIME = 0x00000080
+ VM = 0x00000100
+ FS = 0x00000200
+ FILES = 0x00000400
+ SIGHAND = 0x00000800
+ PIDFD = 0x00001000
+ VFORK = 0x00004000
+ PARENT = 0x00008000
+ THREAD = 0x00010000
+ NEWNS = 0x00020000
+ SYSVSEM = 0x00040000
+ NEWCGROUP = 0x02000000
+ NEWUTS = 0x04000000
+ NEWIPC = 0x08000000
+ NEWUSER = 0x10000000
+ NEWPID = 0x20000000
+ NEWNET = 0x40000000
+ CLEAR_SIGHAND = 1 << 32
+ INTO_CGROUP = 1 << 33
+ AUTOREAP = 1 << 34
+ NNP = 1 << 35
+ PIDFD_AUTOKILL = 1 << 36
+ EMPTY_MNTNS = 1 << 37
+ INTO_ROOTNS = 1 << 38
+
+
+class AtFlag(IntFlag):
+ NONE = 0
+ EMPTY_PATH = 0x1000
+ RECURSIVE = 0x8000
+
+
+class OpenTreeFlag(IntFlag):
+ CLONE = 1 << 0
+ CLOEXEC = os.O_CLOEXEC
+ RECURSIVE = 0x8000
+
+
+class MoveMountFlag(IntFlag):
+ F_EMPTY_PATH = 0x00000004
+ T_EMPTY_PATH = 0x00000040
+ T_MNTNS = 0x00000080
+ SET_GROUP = 0x00000100
+ BENEATH = 0x00000200
+ CLONE = 0x00000400
+
+
+class UsernsIdmapFlag(IntFlag):
+ NONE = 0
+ UID = 1 << 0
+ GID = 1 << 1
+ PROJID = 1 << 2
+ SETGROUPS_DENY = 1 << 3
+ ALL = 0x0F
+
+
+class MountAttrFlag(IntFlag):
+ NONE = 0
+ RDONLY = 0x00000001
+ NOSUID = 0x00000002
+ NODEV = 0x00000004
+
+
+class MountFlag(IntFlag):
+ REC = 0x4000
+ PRIVATE = 1 << 18
+ SHARED = 1 << 20
+
+
+class UmountFlag(IntFlag):
+ NONE = 0
+ DETACH = 2
+
+
+class ResolveFlag(IntFlag):
+ NONE = 0
+ IN_ROOT = 0x10
+
+
+class FsconfigCmd(IntEnum):
+ SET_FLAG = 0
+ SET_STRING = 1
+ CMD_CREATE = 6
+ SET_ROOTNS = 9
+
+
+class PrctlOp(IntEnum):
+ GET_DUMPABLE = 3
+ SET_DUMPABLE = 4
+ SET_KEEPCAPS = 8
+ GET_NO_NEW_PRIVS = 39
+
+
+class RootnsWaitArgs(ctypes.Structure):
+ flags: int
+ status: int
+ _fields_ = [
+ ("flags", ctypes.c_uint32),
+ ("status", ctypes.c_int32),
+ ]
+
+
+class CloneArgs(ctypes.Structure):
+ SIZE_VER2: ClassVar[int] = 88
+ SIZE_VER3: ClassVar[int] = 96
+
+ flags: int
+ pidfd: int
+ child_tid: int
+ parent_tid: int
+ exit_signal: int
+ stack: int
+ stack_size: int
+ tls: int
+ set_tid: int
+ set_tid_size: int
+ cgroup: int
+ rootns: int
+ _fields_ = [
+ ("flags", ctypes.c_uint64),
+ ("pidfd", ctypes.c_uint64),
+ ("child_tid", ctypes.c_uint64),
+ ("parent_tid", ctypes.c_uint64),
+ ("exit_signal", ctypes.c_uint64),
+ ("stack", ctypes.c_uint64),
+ ("stack_size", ctypes.c_uint64),
+ ("tls", ctypes.c_uint64),
+ ("set_tid", ctypes.c_uint64),
+ ("set_tid_size", ctypes.c_uint64),
+ ("cgroup", ctypes.c_uint64),
+ ("rootns", ctypes.c_uint64),
+ ]
+
+
+class OpenHow(ctypes.Structure):
+ flags: int
+ mode: int
+ resolve: int
+ _fields_ = [
+ ("flags", ctypes.c_uint64),
+ ("mode", ctypes.c_uint64),
+ ("resolve", ctypes.c_uint64),
+ ]
+
+
+class UsernsIdmapExtent(ctypes.Structure):
+ first: int
+ lower_first: int
+ count: int
+ reserved: int
+ _fields_ = [
+ ("first", ctypes.c_uint32),
+ ("lower_first", ctypes.c_uint32),
+ ("count", ctypes.c_uint32),
+ ("reserved", ctypes.c_uint32),
+ ]
+
+
+class CapHeader(ctypes.Structure):
+ VERSION_3: ClassVar[int] = 0x20080522
+
+ version: int
+ pid: int
+ _fields_ = [
+ ("version", ctypes.c_uint32),
+ ("pid", ctypes.c_int32),
+ ]
+
+
+class CapData(ctypes.Structure):
+ effective: int
+ permitted: int
+ inheritable: int
+ _fields_ = [
+ ("effective", ctypes.c_uint32),
+ ("permitted", ctypes.c_uint32),
+ ("inheritable", ctypes.c_uint32),
+ ]
+
+
+class UsernsIdmap(ctypes.Structure):
+ SIZE_VER0: ClassVar[int] = 40
+
+ flags: int
+ nr_uid_extents: int
+ uid_extents: int
+ nr_gid_extents: int
+ nr_projid_extents: int
+ gid_extents: int
+ projid_extents: int
+ _fields_ = [
+ ("flags", ctypes.c_uint32),
+ ("nr_uid_extents", ctypes.c_uint32),
+ ("uid_extents", ctypes.c_uint64),
+ ("nr_gid_extents", ctypes.c_uint32),
+ ("nr_projid_extents", ctypes.c_uint32),
+ ("gid_extents", ctypes.c_uint64),
+ ("projid_extents", ctypes.c_uint64),
+ ]
+
+
+class Sys:
+ AT_FDCWD: Final[int] = -100
+ FSOPEN_CLOEXEC: Final[int] = 0x00000001
+ FSMOUNT_CLOEXEC: Final[int] = 0x00000001
+ CAP_SETGID: Final[int] = 6
+ CAP_SETUID: Final[int] = 7
+ _WIDE_IOC_ARCHS: Final[tuple[str, ...]] = (
+ "ppc",
+ "ppc64",
+ "ppc64le",
+ "powerpc",
+ "sparc",
+ "sparc64",
+ "alpha",
+ )
+
+ @classmethod
+ def _is_wide_ioc_arch(cls) -> bool:
+ mach = platform.machine().lower()
+ return mach in cls._WIDE_IOC_ARCHS or mach.startswith("mips")
+
+ @classmethod
+ def ioc(cls, direction: int, magic: int, nr: int, size: int) -> int:
+ sizebits = 13 if cls._is_wide_ioc_arch() else 14
+ typeshift = 8
+ sizeshift = 16
+ dirshift = sizeshift + sizebits
+ return (
+ (direction << dirshift)
+ | (magic << typeshift)
+ | nr
+ | (size << sizeshift)
+ )
+
+ @classmethod
+ def io(cls, magic: int, nr: int) -> int:
+ none_dir = 1 if cls._is_wide_ioc_arch() else 0
+ return cls.ioc(none_dir, magic, nr, 0)
+
+ @classmethod
+ def iowr(cls, magic: int, nr: int, size: int) -> int:
+ rw = 6 if cls._is_wide_ioc_arch() else 3
+ return cls.ioc(rw, magic, nr, size)
+
+ @staticmethod
+ def _build_syscall_numbers() -> dict[str, int]:
+ mach = platform.machine().lower()
+ if mach == "alpha":
+ base = 110
+ elif mach.startswith("mips"):
+ base = 5000 if ctypes.sizeof(ctypes.c_void_p) == 8 else 4000
+ else:
+ base = 0
+
+ nums: dict[str, int] = {
+ "open_tree": base + 428,
+ "move_mount": base + 429,
+ "fsopen": base + 430,
+ "fsconfig": base + 431,
+ "fsmount": base + 432,
+ "clone3": base + 435,
+ "openat2": base + 437,
+ "userns_set_idmap": base + 473,
+ "rootns": base + 474,
+ }
+ legacy: dict[str, dict[str, int]] = {
+ "x86_64": {"pivot_root": 155, "umount2": 166, "execveat": 322},
+ "i386": {"pivot_root": 217, "umount2": 52, "execveat": 358},
+ "i686": {"pivot_root": 217, "umount2": 52, "execveat": 358},
+ "aarch64": {"pivot_root": 41, "umount2": 39, "execveat": 281},
+ "riscv64": {"pivot_root": 41, "umount2": 39, "execveat": 281},
+ "loongarch64": {
+ "pivot_root": 41,
+ "umount2": 39,
+ "execveat": 281,
+ },
+ "s390x": {"pivot_root": 217, "umount2": 52, "execveat": 354},
+ "ppc64le": {"pivot_root": 203, "umount2": 52, "execveat": 362},
+ "ppc64": {"pivot_root": 203, "umount2": 52, "execveat": 362},
+ "armv7l": {"pivot_root": 218, "umount2": 52, "execveat": 387},
+ }
+ nums.update(legacy.get(mach, legacy["x86_64"]))
+ return nums
+
+ _NR: ClassVar[dict[str, int]]
+ _LIBC: ClassVar[ctypes.CDLL]
+
+ @staticmethod
+ def _os_err() -> NoReturn:
+ err = ctypes.get_errno()
+ raise OSError(err, os.strerror(err))
+
+ @staticmethod
+ def _cstr(val: str | bytes) -> bytes:
+ return val if isinstance(val, bytes) else os.fsencode(val)
+
+ @classmethod
+ def syscall(cls, name: str, *args: Any) -> int:
+ ret: int = cls._LIBC.syscall(ctypes.c_long(cls._NR[name]), *args)
+ if ret < 0:
+ cls._os_err()
+ return int(ret)
+
+ @classmethod
+ def ioctl(cls, fd: int, cmd: int, arg: int = 0) -> int:
+ ret: int = cls._LIBC.ioctl(
+ ctypes.c_int(fd), ctypes.c_ulong(int(cmd)), ctypes.c_ulong(arg)
+ )
+ if ret < 0:
+ cls._os_err()
+ return int(ret)
+
+ @classmethod
+ def fsopen(cls, fsname: str | bytes, flags: int = FSOPEN_CLOEXEC) -> int:
+ return cls.syscall(
+ "fsopen", ctypes.c_char_p(cls._cstr(fsname)), ctypes.c_uint(flags)
+ )
+
+ @classmethod
+ def fsconfig(
+ cls,
+ fsfd: int,
+ cmd: FsconfigCmd,
+ key: str | bytes | None = None,
+ value: str | bytes | None = None,
+ aux: int = 0,
+ ) -> None:
+ k_ptr = (
+ ctypes.c_char_p(cls._cstr(key))
+ if key is not None
+ else ctypes.c_void_p(0)
+ )
+ v_ptr = (
+ ctypes.c_char_p(cls._cstr(value))
+ if value is not None
+ else ctypes.c_void_p(0)
+ )
+ cls.syscall(
+ "fsconfig",
+ ctypes.c_int(fsfd),
+ ctypes.c_uint(int(cmd)),
+ k_ptr,
+ v_ptr,
+ ctypes.c_int(aux),
+ )
+
+ @classmethod
+ def fsmount(
+ cls,
+ fsfd: int,
+ flags: int = FSMOUNT_CLOEXEC,
+ attr_flags: MountAttrFlag = MountAttrFlag.NONE,
+ ) -> int:
+ return cls.syscall(
+ "fsmount",
+ ctypes.c_int(fsfd),
+ ctypes.c_uint(flags),
+ ctypes.c_uint(int(attr_flags)),
+ )
+
+ @classmethod
+ def open_tree(
+ cls, dfd: int, path: str | bytes, flags: OpenTreeFlag
+ ) -> int:
+ return cls.syscall(
+ "open_tree",
+ ctypes.c_int(dfd),
+ ctypes.c_char_p(cls._cstr(path)),
+ ctypes.c_uint(int(flags)),
+ )
+
+ @classmethod
+ def move_mount(
+ cls,
+ from_dfd: int,
+ from_path: str | bytes,
+ to_dfd: int,
+ to_path: str | bytes,
+ flags: MoveMountFlag,
+ ) -> None:
+ cls.syscall(
+ "move_mount",
+ ctypes.c_int(from_dfd),
+ ctypes.c_char_p(cls._cstr(from_path)),
+ ctypes.c_int(to_dfd),
+ ctypes.c_char_p(cls._cstr(to_path)),
+ ctypes.c_uint(int(flags)),
+ )
+
+ @classmethod
+ def openat2(
+ cls,
+ dfd: int,
+ path: str | bytes,
+ flags: int,
+ mode: int = 0,
+ resolve: ResolveFlag = ResolveFlag.NONE,
+ ) -> int:
+ how = OpenHow(flags=flags, mode=mode, resolve=int(resolve))
+ return cls.syscall(
+ "openat2",
+ ctypes.c_int(dfd),
+ ctypes.c_char_p(cls._cstr(path)),
+ ctypes.byref(how),
+ ctypes.c_size_t(ctypes.sizeof(how)),
+ )
+
+ @classmethod
+ def execveat(
+ cls,
+ dfd: int,
+ path: str | bytes,
+ argv: Sequence[str],
+ envp: Mapping[str, str] | Sequence[str] | None = None,
+ flags: AtFlag = AtFlag.NONE,
+ ) -> NoReturn:
+ c_argv = (ctypes.c_char_p * (len(argv) + 1))(
+ *[cls._cstr(a) for a in argv], None
+ )
+ if envp is None:
+ env_items = [f"{k}={v}" for k, v in os.environ.items()]
+ elif isinstance(envp, Mapping):
+ env_items = [f"{k}={v}" for k, v in envp.items()]
+ else:
+ env_items = list(envp)
+ c_envp = (ctypes.c_char_p * (len(env_items) + 1))(
+ *[cls._cstr(e) for e in env_items], None
+ )
+ cls.syscall(
+ "execveat",
+ ctypes.c_int(dfd),
+ ctypes.c_char_p(cls._cstr(path)),
+ c_argv,
+ c_envp,
+ ctypes.c_int(int(flags)),
+ )
+ cls._os_err()
+
+ @classmethod
+ def pivot_root(cls, new_root: str | bytes, put_old: str | bytes) -> None:
+ cls.syscall(
+ "pivot_root",
+ ctypes.c_char_p(cls._cstr(new_root)),
+ ctypes.c_char_p(cls._cstr(put_old)),
+ )
+
+ @classmethod
+ def umount2(
+ cls, target: str | bytes, flags: UmountFlag = UmountFlag.NONE
+ ) -> None:
+ cls.syscall(
+ "umount2",
+ ctypes.c_char_p(cls._cstr(target)),
+ ctypes.c_int(int(flags)),
+ )
+
+ @classmethod
+ def set_mount_propagation(
+ cls,
+ target: str | bytes = "/",
+ flags: MountFlag = MountFlag.REC | MountFlag.PRIVATE,
+ ) -> None:
+ ret: int = cls._LIBC.mount(
+ ctypes.c_char_p(b"none"),
+ ctypes.c_char_p(cls._cstr(target)),
+ ctypes.c_void_p(0),
+ ctypes.c_ulong(int(flags)),
+ ctypes.c_void_p(0),
+ )
+ if ret < 0:
+ cls._os_err()
+
+ @classmethod
+ def setns(cls, fd: int, nstype: CloneFlag | int = 0) -> None:
+ if hasattr(os, "setns"):
+ os.setns(fd, int(nstype))
+ return
+ ret: int = cls._LIBC.setns(ctypes.c_int(fd), ctypes.c_int(int(nstype)))
+ if ret < 0:
+ cls._os_err()
+
+ @classmethod
+ def unshare(cls, flags: CloneFlag | int) -> None:
+ if hasattr(os, "unshare"):
+ os.unshare(int(flags))
+ return
+ ret: int = cls._LIBC.unshare(ctypes.c_int(int(flags)))
+ if ret < 0:
+ cls._os_err()
+
+ @classmethod
+ def setgroups_empty(cls) -> None:
+ ret: int = cls._LIBC.setgroups(ctypes.c_size_t(0), ctypes.c_void_p(0))
+ if ret < 0:
+ cls._os_err()
+
+ @classmethod
+ def drop_to_setid_helper(cls, uid: int) -> None:
+ cls.prctl(PrctlOp.SET_KEEPCAPS, 1)
+ try:
+ cls.setgroups_empty()
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ raise
+ os.setresgid(uid, uid, uid)
+ os.setresuid(uid, uid, uid)
+ hdr = CapHeader(version=CapHeader.VERSION_3, pid=0)
+ mask = (1 << cls.CAP_SETGID) | (1 << cls.CAP_SETUID)
+ data = (CapData * 2)(
+ CapData(effective=mask, permitted=mask, inheritable=0),
+ CapData(effective=0, permitted=0, inheritable=0),
+ )
+ ret: int = cls._LIBC.capset(ctypes.byref(hdr), ctypes.byref(data))
+ if ret < 0:
+ cls._os_err()
+ cls.prctl(PrctlOp.SET_DUMPABLE, 1)
+
+ @classmethod
+ def prctl(
+ cls,
+ option: PrctlOp,
+ arg2: int = 0,
+ arg3: int = 0,
+ arg4: int = 0,
+ arg5: int = 0,
+ ) -> int:
+ ret: int = cls._LIBC.prctl(
+ ctypes.c_int(int(option)),
+ ctypes.c_ulong(arg2),
+ ctypes.c_ulong(arg3),
+ ctypes.c_ulong(arg4),
+ ctypes.c_ulong(arg5),
+ )
+ if ret < 0:
+ cls._os_err()
+ return int(ret)
+
+ @classmethod
+ def clone3(cls, args: CloneArgs, size: int | None = None) -> int:
+ actual_size = ctypes.sizeof(args) if size is None else size
+ sys.stdout.flush()
+ sys.stderr.flush()
+ return cls.syscall(
+ "clone3", ctypes.byref(args), ctypes.c_size_t(actual_size)
+ )
+
+ @staticmethod
+ def _extent_array(
+ extents: Sequence[tuple[int, int, int]],
+ ) -> ctypes.Array[UsernsIdmapExtent] | None:
+ if not extents:
+ return None
+ arr_t = UsernsIdmapExtent * len(extents)
+ return arr_t(
+ *[
+ UsernsIdmapExtent(
+ first=first, lower_first=lower, count=count, reserved=0
+ )
+ for first, lower, count in extents
+ ]
+ )
+
+ @classmethod
+ def userns_set_idmap_raw(
+ cls,
+ userns_fd: int,
+ map_addr: int,
+ size: int = UsernsIdmap.SIZE_VER0,
+ flags: int = 0,
+ ) -> None:
+ cls.syscall(
+ "userns_set_idmap",
+ ctypes.c_int(userns_fd),
+ ctypes.c_void_p(map_addr),
+ ctypes.c_size_t(size),
+ ctypes.c_uint(flags),
+ )
+
+ @classmethod
+ def set_userns_idmap(
+ cls,
+ userns_fd: int,
+ uid_extents: Sequence[tuple[int, int, int]] = (),
+ gid_extents: Sequence[tuple[int, int, int]] = (),
+ projid_extents: Sequence[tuple[int, int, int]] = (),
+ *,
+ deny_setgroups: bool = False,
+ extra_flags: UsernsIdmapFlag | int = UsernsIdmapFlag.NONE,
+ size: int | None = None,
+ sys_flags: int = 0,
+ ) -> None:
+ flags = int(extra_flags)
+ u_arr = cls._extent_array(uid_extents)
+ g_arr = cls._extent_array(gid_extents)
+ p_arr = cls._extent_array(projid_extents)
+ if u_arr is not None:
+ flags |= int(UsernsIdmapFlag.UID)
+ if g_arr is not None:
+ flags |= int(UsernsIdmapFlag.GID)
+ if p_arr is not None:
+ flags |= int(UsernsIdmapFlag.PROJID)
+ if deny_setgroups:
+ flags |= int(UsernsIdmapFlag.SETGROUPS_DENY)
+ req = UsernsIdmap(
+ flags=flags,
+ nr_uid_extents=len(uid_extents),
+ uid_extents=ctypes.addressof(u_arr) if u_arr is not None else 0,
+ nr_gid_extents=len(gid_extents),
+ nr_projid_extents=len(projid_extents),
+ gid_extents=ctypes.addressof(g_arr) if g_arr is not None else 0,
+ projid_extents=ctypes.addressof(p_arr) if p_arr is not None else 0,
+ )
+ cls.userns_set_idmap_raw(
+ userns_fd,
+ ctypes.addressof(req),
+ ctypes.sizeof(req) if size is None else size,
+ sys_flags,
+ )
+
+
+Sys._NR = Sys._build_syscall_numbers()
+Sys._LIBC = ctypes.CDLL(None, use_errno=True)
+Sys._LIBC.syscall.restype = ctypes.c_long
+
+
+class Ioctl(IntEnum):
+ ROOTNS_GET_NSFD = Sys.io(0xB9, 0x01)
+ ROOTNS_WAIT = Sys.iowr(0xB9, 0x02, ctypes.sizeof(RootnsWaitArgs))
+ ROOTNS_KILL = Sys.io(0xB9, 0x03)
+ NS_GET_USERNS = Sys.io(0xB7, 0x01)
+ NS_GET_PARENT = Sys.io(0xB7, 0x02)
+ NS_GET_NSTYPE = Sys.io(0xB7, 0x03)
+
+
+class CellState(str, Enum):
+ CREATED = "created"
+ RUNNING = "running"
+ EXITED = "exited"
+
+
+class CellMode(str, Enum):
+ HOST = "host"
+ TMPFS = "tmpfs"
+
+
+class RpcOp(str, Enum):
+ PING = "ping"
+ SHUTDOWN = "shutdown"
+ LIST = "list"
+ CREATE = "create"
+ SPAWN = "spawn"
+ MOUNT = "mount"
+ KILL = "kill"
+ WAIT = "wait"
+ DESTROY = "destroy"
+
+
+@dataclass(frozen=True)
+class WaitResult:
+ pid: int
+ status: int = 0
+
+ @property
+ def exit_code(self) -> int | None:
+ if self.pid <= 0:
+ return None
+ return os.waitstatus_to_exitcode(self.status)
+
+
+@dataclass(frozen=True)
+class CellInfo:
+ name: str
+ state: CellState
+ init_pid: int | None = None
+ exit_code: int | None = None
+
+
+@dataclass(frozen=True)
+class SpawnInfo:
+ pid: int
+ state: CellState
+
+
+class Rootns:
+ fd: int
+
+ def __init__(
+ self,
+ flags: RootnsFlag | int = RootnsFlag.DEFAULT,
+ *,
+ fd: int | None = None,
+ ) -> None:
+ if fd is not None:
+ self.fd = fd
+ else:
+ self.fd = Sys.syscall("rootns", ctypes.c_uint(int(flags)))
+
+ @classmethod
+ def from_fd(cls, fd: int) -> Rootns:
+ return cls(fd=fd)
+
+ def fileno(self) -> int:
+ return self.fd
+
+ def __enter__(self) -> Rootns:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: TracebackType | None,
+ ) -> None:
+ self.close()
+
+ def close(self) -> None:
+ if self.fd >= 0:
+ try:
+ os.close(self.fd)
+ except OSError:
+ pass
+ self.fd = -1
+
+ def get_nsfd(self, nstype: CloneFlag | int) -> int:
+ return Sys.ioctl(self.fd, Ioctl.ROOTNS_GET_NSFD, int(nstype))
+
+ def set_idmap(
+ self,
+ uid_extents: Sequence[tuple[int, int, int]] = (),
+ gid_extents: Sequence[tuple[int, int, int]] = (),
+ projid_extents: Sequence[tuple[int, int, int]] = (),
+ *,
+ deny_setgroups: bool = False,
+ ) -> None:
+ userns_fd = self.get_nsfd(CloneFlag.NEWUSER)
+ try:
+ Sys.set_userns_idmap(
+ userns_fd,
+ uid_extents=uid_extents,
+ gid_extents=gid_extents,
+ projid_extents=projid_extents,
+ deny_setgroups=deny_setgroups,
+ )
+ finally:
+ os.close(userns_fd)
+
+ def map_self_ugid(self) -> None:
+ self.set_idmap(
+ uid_extents=((0, os.geteuid(), 1),),
+ gid_extents=((0, os.getegid(), 1),),
+ deny_setgroups=True,
+ )
+
+ def wait(self, flags: int = 0) -> WaitResult:
+ args = RootnsWaitArgs(flags=flags, status=0)
+ pid = Sys.ioctl(self.fd, Ioctl.ROOTNS_WAIT, ctypes.addressof(args))
+ return WaitResult(pid=pid, status=int(args.status))
+
+ def kill(self, sig: signal.Signals | int) -> None:
+ mask = (1 << (ctypes.sizeof(ctypes.c_ulong) * 8)) - 1
+ Sys.ioctl(self.fd, Ioctl.ROOTNS_KILL, int(sig) & mask)
+
+ def clone_into(
+ self,
+ extra_flags: CloneFlag = CloneFlag.NONE,
+ exit_signal: int = int(signal.SIGCHLD),
+ ) -> tuple[int, int]:
+ pidfd_cell = ctypes.c_int(-1)
+ args = CloneArgs()
+ args.flags = int(CloneFlag.INTO_ROOTNS | extra_flags)
+ args.exit_signal = exit_signal
+ args.rootns = self.fd & 0xFFFFFFFFFFFFFFFF
+ if extra_flags & CloneFlag.PIDFD:
+ args.pidfd = ctypes.addressof(pidfd_cell)
+ pid = Sys.clone3(args)
+ return pid, int(pidfd_cell.value)
+
+ def run(
+ self,
+ fn: Callable[[], int | None],
+ extra_flags: CloneFlag = CloneFlag.NONE,
+ ) -> int:
+ pid, _ = self.clone_into(extra_flags=extra_flags)
+ if pid == 0:
+ try:
+ self.close()
+ rc = fn()
+ os._exit(0 if rc is None else int(rc))
+ except BaseException:
+ os._exit(126)
+ return pid
+
+ def make_mount(
+ self,
+ fstype: str,
+ attr_flags: MountAttrFlag = MountAttrFlag.NONE,
+ options: Mapping[str, str | None] | None = None,
+ ) -> int:
+ fsfd = Sys.fsopen(fstype)
+ try:
+ Sys.fsconfig(fsfd, FsconfigCmd.SET_ROOTNS, aux=self.fd)
+ if options:
+ for k, v in options.items():
+ if v is None:
+ Sys.fsconfig(fsfd, FsconfigCmd.SET_FLAG, key=k)
+ else:
+ Sys.fsconfig(
+ fsfd, FsconfigCmd.SET_STRING, key=k, value=str(v)
+ )
+ Sys.fsconfig(fsfd, FsconfigCmd.CMD_CREATE)
+ return Sys.fsmount(fsfd, attr_flags=attr_flags)
+ finally:
+ os.close(fsfd)
+
+
+@dataclass
+class Cell:
+ name: str
+ flags: RootnsFlag = RootnsFlag.DEFAULT
+ rns: Rootns = field(init=False)
+ mntns_fd: int = field(init=False, default=-1)
+ root_dfd: int = field(init=False, default=-1)
+ init_pid: int | None = field(init=False, default=None)
+ exit_status: int | None = field(init=False, default=None)
+
+ def __post_init__(self) -> None:
+ self.rns = Rootns(self.flags)
+ try:
+ self.mntns_fd = self.rns.get_nsfd(CloneFlag.NEWNS)
+ except Exception:
+ self.rns.close()
+ raise
+
+ def __enter__(self) -> Cell:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: TracebackType | None,
+ ) -> None:
+ self.close()
+
+ @staticmethod
+ def _close_fd(fd: int) -> int:
+ if fd >= 0:
+ with suppress(OSError):
+ os.close(fd)
+ return -1
+
+ def _move_to_mntns(self, mfd: int, target: str) -> None:
+ Sys.move_mount(
+ mfd,
+ "",
+ self.mntns_fd,
+ target,
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+
+ def _consume_mount(self, mfd: int, target: str) -> None:
+ try:
+ self._move_to_mntns(mfd, target.lstrip("/"))
+ finally:
+ os.close(mfd)
+
+ def setup_rootfs(
+ self,
+ dirs: Sequence[str] = ("proc", "tmp", "mnt"),
+ mount_procfs: bool = True,
+ host_runtime: bool = False,
+ map_ugid: bool = True,
+ ) -> None:
+ if map_ugid:
+ self.rns.map_self_ugid()
+ rootfd = self.rns.make_mount("tmpfs")
+ bind_dirs: list[str] = []
+ try:
+ for d in dirs:
+ os.mkdir(d, 0o755, dir_fd=rootfd)
+ if host_runtime:
+ for entry in HOST_RUNTIME_ENTRIES:
+ host_path = f"/{entry}"
+ if os.path.islink(host_path):
+ os.symlink(
+ os.readlink(host_path), entry, dir_fd=rootfd
+ )
+ elif os.path.isdir(host_path):
+ os.mkdir(entry, 0o755, dir_fd=rootfd)
+ bind_dirs.append(entry)
+ self._move_to_mntns(rootfd, "/")
+ except Exception:
+ os.close(rootfd)
+ raise
+ self.root_dfd = rootfd
+ for entry in bind_dirs:
+ self.bind_mount(f"/{entry}", entry)
+ if mount_procfs and "proc" in dirs:
+ self.mount_fs("proc", "proc")
+
+ def mount_fs(
+ self,
+ fstype: str,
+ target: str,
+ attr_flags: MountAttrFlag = MountAttrFlag.NONE,
+ options: Mapping[str, str | None] | None = None,
+ ) -> None:
+ mfd = self.rns.make_mount(
+ fstype, attr_flags=attr_flags, options=options
+ )
+ self._consume_mount(mfd, target)
+
+ def bind_mount(self, host_src: str, target: str) -> None:
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ host_src,
+ self.mntns_fd,
+ target.lstrip("/"),
+ MoveMountFlag.T_MNTNS | MoveMountFlag.CLONE,
+ )
+
+ def spawn(
+ self,
+ argv: Sequence[str],
+ env: Mapping[str, str] | None = None,
+ resolve_in_root: bool = True,
+ ) -> int:
+ bin_fd = -1
+ if resolve_in_root and self.root_dfd >= 0:
+ bin_fd = Sys.openat2(
+ self.root_dfd,
+ argv[0],
+ os.O_RDONLY | os.O_CLOEXEC,
+ resolve=ResolveFlag.IN_ROOT,
+ )
+ try:
+ pid, _ = self.rns.clone_into(
+ extra_flags=CloneFlag.AUTOREAP, exit_signal=0
+ )
+ if pid == 0:
+ try:
+ self.close()
+ if bin_fd >= 0:
+ Sys.execveat(bin_fd, "", argv, env, AtFlag.EMPTY_PATH)
+ if env is None:
+ os.execv(argv[0], list(argv))
+ else:
+ os.execve(argv[0], list(argv), dict(env))
+ except BaseException:
+ os._exit(127)
+ if self.init_pid is None:
+ self.init_pid = pid
+ return pid
+ finally:
+ self._close_fd(bin_fd)
+
+ def kill(self, sig: signal.Signals | int = signal.SIGTERM) -> None:
+ self.rns.kill(sig)
+
+ def wait(self, nohang: bool = False) -> WaitResult:
+ res = self.rns.wait(os.WNOHANG if nohang else 0)
+ if res.pid > 0:
+ self.exit_status = res.status
+ return res
+
+ @property
+ def state(self) -> CellState:
+ if self.init_pid is None:
+ return CellState.CREATED
+ if self.exit_status is None:
+ return CellState.RUNNING
+ return CellState.EXITED
+
+ def info(self) -> CellInfo:
+ code = (
+ os.waitstatus_to_exitcode(self.exit_status)
+ if self.exit_status is not None
+ else None
+ )
+ return CellInfo(
+ name=self.name,
+ state=self.state,
+ init_pid=self.init_pid,
+ exit_code=code,
+ )
+
+ def close(self) -> None:
+ self.root_dfd = self._close_fd(self.root_dfd)
+ self.mntns_fd = self._close_fd(self.mntns_fd)
+ self.rns.close()
+
+
+class JsonLine:
+ @staticmethod
+ def send(sock: socket.socket, payload: Mapping[str, Any]) -> None:
+ sock.sendall((json.dumps(payload) + "\n").encode("utf-8"))
+
+ @staticmethod
+ def recv(sock: socket.socket) -> dict[str, Any] | None:
+ with sock.makefile("r", encoding="utf-8") as reader:
+ line = reader.readline()
+ if not line:
+ return None
+ data: dict[str, Any] = json.loads(line)
+ return data
+
+
+class CellService:
+ def __init__(self, sock_path: str) -> None:
+ self.sock_path = sock_path
+ self.sel = selectors.DefaultSelector()
+ self.cells: dict[str, Cell] = {}
+ self.running = True
+ with suppress(FileNotFoundError):
+ os.unlink(sock_path)
+ self.srv = socket.socket(
+ socket.AF_UNIX, socket.SOCK_STREAM | socket.SOCK_CLOEXEC
+ )
+ self.srv.bind(sock_path)
+ self.srv.listen(16)
+ self.srv.setblocking(False)
+ self.sel.register(self.srv, selectors.EVENT_READ, self._on_accept)
+
+ def __enter__(self) -> CellService:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: TracebackType | None,
+ ) -> None:
+ self.close()
+
+ def _safe_unregister(self, fileobj: Any) -> None:
+ with suppress(KeyError, ValueError):
+ self.sel.unregister(fileobj)
+
+ def _reap_children(self) -> None:
+ while True:
+ try:
+ pid, _ = os.waitpid(-1, os.WNOHANG)
+ if pid == 0:
+ break
+ except ChildProcessError:
+ break
+
+ def _on_cell_event(self, cell: Cell) -> None:
+ with suppress(OSError):
+ res = cell.wait(nohang=True)
+ if res.pid > 0:
+ self._safe_unregister(cell.rns)
+ self._reap_children()
+
+ def _on_accept(self) -> None:
+ conn, _ = self.srv.accept()
+ with conn:
+ conn.setblocking(True)
+ try:
+ req = JsonLine.recv(conn)
+ if req is None:
+ return
+ resp: dict[str, Any] = {
+ "ok": True,
+ "result": self._dispatch(req),
+ }
+ except Exception as exc:
+ resp = {
+ "ok": False,
+ "error": str(exc),
+ "errno": getattr(exc, "errno", None),
+ }
+ JsonLine.send(conn, resp)
+
+ def _dispatch(self, req: Mapping[str, Any]) -> Any:
+ op = RpcOp(req["op"])
+ if op is RpcOp.PING:
+ return "pong"
+ if op is RpcOp.SHUTDOWN:
+ self.running = False
+ return "bye"
+ if op is RpcOp.LIST:
+ self._reap_children()
+ return [asdict(c.info()) for c in self.cells.values()]
+
+ name = str(req["name"])
+ if op is RpcOp.CREATE:
+ if name in self.cells:
+ raise OSError(errno.EEXIST, f"cell {name} already exists")
+ mode = CellMode(req.get("mode", CellMode.HOST))
+ cell = Cell(name, flags=RootnsFlag.DEFAULT)
+ try:
+ cell.setup_rootfs(
+ mount_procfs=bool(req.get("proc", True)),
+ host_runtime=mode is CellMode.HOST,
+ )
+ except Exception:
+ cell.close()
+ raise
+ self.cells[name] = cell
+ self.sel.register(
+ cell.rns,
+ selectors.EVENT_READ,
+ lambda c=cell: self._on_cell_event(c),
+ )
+ return asdict(cell.info())
+
+ if name not in self.cells:
+ raise OSError(errno.ENOENT, f"unknown cell {name}")
+ cell = self.cells[name]
+
+ if op is RpcOp.SPAWN:
+ pid = cell.spawn(
+ list(req["argv"]),
+ resolve_in_root=bool(req.get("resolve_in_root", True)),
+ )
+ return asdict(SpawnInfo(pid=pid, state=cell.state))
+ if op is RpcOp.MOUNT:
+ if req.get("bind"):
+ cell.bind_mount(str(req["source"]), str(req["target"]))
+ else:
+ cell.mount_fs(
+ str(req["source"]),
+ str(req["target"]),
+ options=req.get("options"),
+ )
+ return str(req["target"])
+ if op is RpcOp.KILL:
+ cell.kill(int(req.get("sig", int(signal.SIGTERM))))
+ return name
+ if op is RpcOp.WAIT:
+ res = cell.wait(nohang=bool(req.get("nohang", False)))
+ self._reap_children()
+ return asdict(res)
+ if op is RpcOp.DESTROY:
+ self._safe_unregister(cell.rns)
+ cell.close()
+ del self.cells[name]
+ self._reap_children()
+ return name
+ raise ValueError(f"unsupported op {op}")
+
+ def serve_forever(self) -> None:
+ try:
+ while self.running:
+ for key, _ in self.sel.select(timeout=0.2):
+ cb: Callable[[], None] = key.data
+ cb()
+ self._reap_children()
+ finally:
+ self.close()
+
+ def close(self) -> None:
+ for cell in list(self.cells.values()):
+ self._safe_unregister(cell.rns)
+ cell.close()
+ self.cells.clear()
+ self._safe_unregister(self.srv)
+ self.srv.close()
+ self.sel.close()
+ with suppress(FileNotFoundError):
+ os.unlink(self.sock_path)
+ self._reap_children()
+
+
+@dataclass(frozen=True)
+class CellClient:
+ sock_path: str
+
+ def call(self, op: RpcOp, **params: Any) -> Any:
+ with socket.socket(
+ socket.AF_UNIX, socket.SOCK_STREAM | socket.SOCK_CLOEXEC
+ ) as sock:
+ sock.connect(self.sock_path)
+ JsonLine.send(sock, {"op": op.value, **params})
+ resp = JsonLine.recv(sock)
+ if resp is None:
+ raise RuntimeError("empty RPC response")
+ if not resp["ok"]:
+ err = resp.get("errno")
+ if err is not None:
+ raise OSError(int(err), str(resp["error"]))
+ raise RuntimeError(str(resp["error"]))
+ return resp["result"]
+
+ @staticmethod
+ def _parse_cell_info(data: Mapping[str, Any]) -> CellInfo:
+ return CellInfo(
+ name=str(data["name"]),
+ state=CellState(data["state"]),
+ init_pid=data.get("init_pid"),
+ exit_code=data.get("exit_code"),
+ )
+
+ def ping(self) -> str:
+ return str(self.call(RpcOp.PING))
+
+ def shutdown(self) -> str:
+ return str(self.call(RpcOp.SHUTDOWN))
+
+ def list_cells(self) -> list[CellInfo]:
+ items: list[dict[str, Any]] = self.call(RpcOp.LIST)
+ return [self._parse_cell_info(item) for item in items]
+
+ def create(
+ self,
+ name: str,
+ mode: CellMode = CellMode.HOST,
+ proc: bool = True,
+ ) -> CellInfo:
+ data: dict[str, Any] = self.call(
+ RpcOp.CREATE,
+ name=name,
+ mode=mode.value,
+ proc=proc,
+ )
+ return self._parse_cell_info(data)
+
+ def spawn(
+ self,
+ name: str,
+ argv: Sequence[str],
+ resolve_in_root: bool = True,
+ ) -> SpawnInfo:
+ data: dict[str, Any] = self.call(
+ RpcOp.SPAWN,
+ name=name,
+ argv=list(argv),
+ resolve_in_root=resolve_in_root,
+ )
+ return SpawnInfo(pid=int(data["pid"]), state=CellState(data["state"]))
+
+ def mount(
+ self,
+ name: str,
+ source: str,
+ target: str,
+ bind: bool = False,
+ options: Mapping[str, str | None] | None = None,
+ ) -> str:
+ return str(
+ self.call(
+ RpcOp.MOUNT,
+ name=name,
+ source=source,
+ target=target,
+ bind=bind,
+ options=dict(options) if options is not None else None,
+ )
+ )
+
+ def kill(
+ self, name: str, sig: signal.Signals | int = signal.SIGTERM
+ ) -> str:
+ return str(self.call(RpcOp.KILL, name=name, sig=int(sig)))
+
+ def wait(self, name: str, nohang: bool = False) -> WaitResult:
+ data: dict[str, Any] = self.call(RpcOp.WAIT, name=name, nohang=nohang)
+ return WaitResult(pid=int(data["pid"]), status=int(data["status"]))
+
+ def destroy(self, name: str) -> str:
+ return str(self.call(RpcOp.DESTROY, name=name))
+
+
+class CellCli:
+ @staticmethod
+ def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--sock", default="/tmp/rootns-cells.sock")
+ sub = parser.add_subparsers(dest="cmd", required=True)
+ sub.add_parser("daemon")
+ sub.add_parser("ps")
+ sub.add_parser("shutdown")
+
+ p_create = sub.add_parser("create")
+ p_create.add_argument("name")
+ p_create.add_argument(
+ "--mode",
+ type=CellMode,
+ choices=tuple(CellMode),
+ default=CellMode.HOST,
+ )
+
+ for cname in ("start", "exec", "spawn"):
+ p_run = sub.add_parser(cname)
+ p_run.add_argument("name")
+ p_run.add_argument("argv", nargs=argparse.REMAINDER)
+
+ p_mnt = sub.add_parser("mount")
+ p_mnt.add_argument("name")
+ p_mnt.add_argument("source")
+ p_mnt.add_argument("target")
+ p_mnt.add_argument("--bind", action="store_true")
+
+ p_kill = sub.add_parser("kill")
+ p_kill.add_argument("name")
+ p_kill.add_argument(
+ "-s", "--sig", type=int, default=int(signal.SIGTERM)
+ )
+
+ p_wait = sub.add_parser("wait")
+ p_wait.add_argument("name")
+
+ p_rm = sub.add_parser("destroy")
+ p_rm.add_argument("name")
+ return parser
+
+ @classmethod
+ def main(cls, argv: Sequence[str] | None = None) -> None:
+ args = cls.build_parser().parse_args(argv)
+ if args.cmd == "daemon":
+ with CellService(args.sock) as srv:
+ srv.serve_forever()
+ return
+
+ client = CellClient(args.sock)
+ if args.cmd == "ps":
+ print(
+ json.dumps([asdict(c) for c in client.list_cells()], indent=2)
+ )
+ elif args.cmd == "shutdown":
+ print(json.dumps(client.shutdown()))
+ elif args.cmd == "create":
+ info = client.create(args.name, mode=args.mode)
+ print(json.dumps(asdict(info)))
+ elif args.cmd in ("start", "exec", "spawn"):
+ cmd_argv = (
+ args.argv[1:]
+ if args.argv and args.argv[0] == "--"
+ else list(args.argv)
+ )
+ print(json.dumps(asdict(client.spawn(args.name, cmd_argv))))
+ elif args.cmd == "mount":
+ print(
+ json.dumps(
+ client.mount(
+ args.name, args.source, args.target, bind=args.bind
+ )
+ )
+ )
+ elif args.cmd == "kill":
+ print(json.dumps(client.kill(args.name, args.sig)))
+ elif args.cmd == "wait":
+ res = client.wait(args.name)
+ print(json.dumps({"pid": res.pid, "exit_code": res.exit_code}))
+ elif args.cmd == "destroy":
+ print(json.dumps(client.destroy(args.name)))
+
+
+if __name__ == "__main__":
+ CellCli.main()
diff --git a/tools/testing/selftests/rootns/rootns_test.py b/tools/testing/selftests/rootns/rootns_test.py
new file mode 100755
index 000000000000..756bfe605f8e
--- /dev/null
+++ b/tools/testing/selftests/rootns/rootns_test.py
@@ -0,0 +1,1645 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-2.0
+#
+# Copyright (C) 2026 Opinsys Oy
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator, Sequence
+from contextlib import contextmanager, suppress
+from dataclasses import dataclass
+import errno
+import importlib
+import json
+import os
+from pathlib import Path
+import select
+import shutil
+import signal
+import socket
+import sys
+import tempfile
+import time
+import traceback
+from types import TracebackType
+from typing import Any, Final, NoReturn
+import unittest
+
+from rootns_cells import (
+ Cell,
+ CellClient,
+ CellInfo,
+ CellMode,
+ CellService,
+ CellState,
+ CloneArgs,
+ CloneFlag,
+ FsconfigCmd,
+ Ioctl,
+ MountFlag,
+ MoveMountFlag,
+ OpenTreeFlag,
+ PrctlOp,
+ Rootns,
+ RootnsFlag,
+ Sys,
+ UmountFlag,
+ UsernsIdmap,
+ UsernsIdmapFlag,
+ WaitResult,
+)
+
+PYTHON_BIN: Final[str] = os.path.realpath(sys.executable)
+SKIP_ERRNOS: Final[tuple[int, ...]] = (
+ errno.ENOSYS,
+ errno.EPERM,
+ errno.EACCES,
+ errno.EINVAL,
+ errno.ENOSPC,
+)
+
+
+@dataclass(frozen=True)
+class Payload:
+ code: str
+
+ def argv(self) -> list[str]:
+ return [PYTHON_BIN, "-S", "-c", self.code]
+
+
+WAIT_MOUNT_PAYLOAD: Final[Payload] = Payload(
+ """\
+import os
+import sys
+import time
+
+if os.getpid() != 1:
+ sys.exit(1)
+deadline = time.monotonic() + 5.0
+while time.monotonic() < deadline:
+ if os.path.ismount("/mnt") and os.path.exists("/mnt/done"):
+ with open("/mnt/done", "rb") as f:
+ sys.exit(0 if f.read() == b"ok\\n" else 2)
+ time.sleep(0.02)
+sys.exit(3)
+"""
+)
+
+WRITE_MOUNT_PAYLOAD: Final[Payload] = Payload(
+ """\
+import os
+import sys
+
+if not os.path.ismount("/mnt"):
+ sys.exit(1)
+with open("/mnt/done.tmp", "wb") as f:
+ f.write(b"ok\\n")
+os.replace("/mnt/done.tmp", "/mnt/done")
+"""
+)
+
+PAUSE_PAYLOAD: Final[Payload] = Payload(
+ """\
+import signal
+
+signal.pause()
+"""
+)
+
+
+@dataclass(frozen=True)
+class ProbeResult:
+ supported: bool
+ reason: str = ""
+
+
+@dataclass
+class SyncPipe:
+ r_fd: int
+ w_fd: int
+
+ @classmethod
+ def create(cls) -> SyncPipe:
+ r_fd, w_fd = os.pipe2(os.O_CLOEXEC)
+ return cls(r_fd=r_fd, w_fd=w_fd)
+
+ def __enter__(self) -> SyncPipe:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: TracebackType | None,
+ ) -> None:
+ self.close()
+
+ def close_read(self) -> None:
+ if self.r_fd >= 0:
+ os.close(self.r_fd)
+ self.r_fd = -1
+
+ def close_write(self) -> None:
+ if self.w_fd >= 0:
+ os.close(self.w_fd)
+ self.w_fd = -1
+
+ def close(self) -> None:
+ self.close_read()
+ self.close_write()
+
+ def read_bytes(self, n: int = 1) -> bytes:
+ return os.read(self.r_fd, n)
+
+ def read_all(self) -> bytes:
+ chunks: list[bytes] = []
+ while True:
+ chunk = os.read(self.r_fd, 4096)
+ if not chunk:
+ break
+ chunks.append(chunk)
+ return b"".join(chunks)
+
+ def write_bytes(self, data: bytes = b"1") -> None:
+ os.write(self.w_fd, data)
+
+ def wait_in_child(self, exit_code: int = 0) -> int:
+ self.close_write()
+ self.read_bytes()
+ self.close_read()
+ return exit_code
+
+
+@dataclass(frozen=True)
+class NsTypeCase:
+ name: str
+ nstype: CloneFlag
+
+
+@dataclass(frozen=True)
+class BadCloneCase:
+ name: str
+ flags: CloneFlag
+ exit_signal: int = int(signal.SIGCHLD)
+ expected_errno: int = errno.EINVAL
+
+
+@dataclass(frozen=True)
+class SignalCase:
+ name: str
+ sig: int
+ expected_errno: int
+
+
+NS_TYPE_CASES: Final[tuple[NsTypeCase, ...]] = (
+ NsTypeCase("mnt", CloneFlag.NEWNS),
+ NsTypeCase("cgroup", CloneFlag.NEWCGROUP),
+ NsTypeCase("uts", CloneFlag.NEWUTS),
+ NsTypeCase("ipc", CloneFlag.NEWIPC),
+ NsTypeCase("user", CloneFlag.NEWUSER),
+ NsTypeCase("net", CloneFlag.NEWNET),
+ NsTypeCase("time", CloneFlag.NEWTIME),
+)
+
+BAD_CLONE_CASES: Final[tuple[BadCloneCase, ...]] = (
+ BadCloneCase("newns", CloneFlag.NEWNS),
+ BadCloneCase("newpid", CloneFlag.NEWPID),
+ BadCloneCase("newuser", CloneFlag.NEWUSER),
+ BadCloneCase("empty_mntns", CloneFlag.EMPTY_MNTNS),
+ BadCloneCase("fs", CloneFlag.FS),
+ BadCloneCase(
+ "thread",
+ CloneFlag.THREAD | CloneFlag.SIGHAND | CloneFlag.VM,
+ exit_signal=0,
+ ),
+ BadCloneCase("parent", CloneFlag.PARENT, exit_signal=0),
+ BadCloneCase("sysvsem", CloneFlag.SYSVSEM),
+ BadCloneCase("vm", CloneFlag.VM),
+ BadCloneCase("vm_vfork", CloneFlag.VM | CloneFlag.VFORK),
+)
+
+BAD_SIGNAL_CASES: Final[tuple[SignalCase, ...]] = (
+ SignalCase("negative", -1, errno.EINVAL),
+ SignalCase("out_of_range", 9999, errno.EINVAL),
+ SignalCase("empty_rootns", 0, errno.ESRCH),
+)
+
+
+class RootnsTestBase(unittest.TestCase):
+ @staticmethod
+ @contextmanager
+ def closing_fd(fd: int) -> Iterator[int]:
+ try:
+ yield fd
+ finally:
+ os.close(fd)
+
+ @staticmethod
+ def pause_forever() -> int:
+ signal.pause()
+ return 0
+
+ @staticmethod
+ def reap_exit_code(pid: int) -> int:
+ _, status = os.waitpid(pid, 0)
+ if os.WIFEXITED(status):
+ return os.WEXITSTATUS(status)
+ if os.WIFSIGNALED(status):
+ return 128 + os.WTERMSIG(status)
+ return 255
+
+ @staticmethod
+ def drop_to_uid(uid: int) -> None:
+ try:
+ Sys.setgroups_empty()
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ raise
+ os.setresgid(uid, uid, uid)
+ os.setresuid(uid, uid, uid)
+ Sys.prctl(PrctlOp.SET_DUMPABLE, 1)
+
+ @classmethod
+ def make_plain_mount(cls, fstype: str) -> int:
+ with cls.closing_fd(Sys.fsopen(fstype)) as fsfd:
+ Sys.fsconfig(fsfd, FsconfigCmd.CMD_CREATE)
+ return Sys.fsmount(fsfd)
+
+ @classmethod
+ def probe_pre_idmap_mkdir(cls) -> ProbeResult:
+ try:
+ rns = Rootns()
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ return ProbeResult(False, f"rootns() unavailable: {exc}")
+ raise
+ with rns:
+ try:
+ rns.map_self_ugid()
+ mfd = rns.make_mount("tmpfs")
+ except OSError as exc:
+ return ProbeResult(False, f"rootns setup unavailable: {exc}")
+ with cls.closing_fd(mfd):
+ os.mkdir("probe", 0o755, dir_fd=mfd)
+ return ProbeResult(True)
+
+ def run_forked(self, fn: Callable[[], None]) -> None:
+ with SyncPipe.create() as pipe:
+ sys.stdout.flush()
+ sys.stderr.flush()
+ pid = os.fork()
+ if pid == 0:
+ pipe.close_read()
+ try:
+ fn()
+ except unittest.SkipTest as exc:
+ payload = json.dumps({"kind": "skip", "msg": str(exc)})
+ pipe.write_bytes(payload.encode("utf-8"))
+ pipe.close_write()
+ os._exit(0)
+ except BaseException:
+ payload = json.dumps(
+ {"kind": "fail", "msg": traceback.format_exc()}
+ )
+ pipe.write_bytes(payload.encode("utf-8"))
+ pipe.close_write()
+ os._exit(1)
+ pipe.close_write()
+ os._exit(0)
+ pipe.close_write()
+ raw = pipe.read_all()
+ code = self.reap_exit_code(pid)
+ if raw:
+ info = json.loads(raw.decode("utf-8"))
+ if info["kind"] == "skip":
+ self.skipTest(str(info["msg"]))
+ self.fail(str(info["msg"]))
+ self.assertEqual(code, 0)
+
+ def create_rootns_as_uid(self, uid: int) -> Rootns | None:
+ s_parent, s_child = socket.socketpair(
+ socket.AF_UNIX, socket.SOCK_DGRAM
+ )
+ sys.stdout.flush()
+ sys.stderr.flush()
+ pid = os.fork()
+ if pid == 0:
+ s_parent.close()
+ try:
+ self.drop_to_uid(uid)
+ with Rootns() as rns:
+ socket.send_fds(s_child, [b"F"], [rns.fd])
+ os._exit(0)
+ except OSError as exc:
+ os._exit(0 if exc.errno in SKIP_ERRNOS else 1)
+ finally:
+ s_child.close()
+ s_child.close()
+ fds: list[int] = []
+ try:
+ rlist, _, _ = select.select([s_parent], [], [], 5.0)
+ if rlist:
+ _, fds, _, _ = socket.recv_fds(s_parent, 1, 1)
+ finally:
+ s_parent.close()
+ code = self.reap_exit_code(pid)
+ if code != 0:
+ for fd in fds:
+ os.close(fd)
+ self.fail(f"create_rootns_as_uid({uid}) failed with status {code}")
+ return Rootns.from_fd(fds[0]) if fds else None
+
+
+class CellServiceTest(RootnsTestBase):
+ tmpdir: str
+ sock_path: str
+ daemon_pid: int
+ client: CellClient
+
+ def setUp(self) -> None:
+ probe = self.probe_pre_idmap_mkdir()
+ if not probe.supported:
+ self.skipTest(probe.reason)
+ self.daemon_pid = 0
+ self.tmpdir = tempfile.mkdtemp(prefix="rootns-cells-")
+ try:
+ self.sock_path = os.path.join(self.tmpdir, "cells.sock")
+ self.daemon_pid = os.fork()
+ if self.daemon_pid == 0:
+ try:
+ with CellService(self.sock_path) as srv:
+ srv.serve_forever()
+ os._exit(0)
+ except BaseException:
+ os._exit(1)
+ self.client = CellClient(self.sock_path)
+ for _ in range(50):
+ if os.path.exists(self.sock_path):
+ try:
+ if self.client.ping() == "pong":
+ break
+ except OSError:
+ pass
+ time.sleep(0.05)
+ else:
+ self.fail("CellService daemon failed to start")
+ except BaseException:
+ self.tearDown()
+ raise
+
+ def tearDown(self) -> None:
+ daemon_pid = getattr(self, "daemon_pid", 0)
+ if daemon_pid > 0:
+ try:
+ self.client.shutdown()
+ except Exception:
+ os.kill(daemon_pid, signal.SIGKILL)
+ self.reap_exit_code(daemon_pid)
+ tmpdir = getattr(self, "tmpdir", "")
+ if tmpdir:
+ shutil.rmtree(tmpdir, ignore_errors=True)
+
+ def test_cell_lifecycle_exec_and_hot_mount(self) -> None:
+ info = self.client.create("alpha", mode=CellMode.HOST)
+ self.assertEqual(info.state, CellState.CREATED)
+ self.assertEqual(
+ self.client.list_cells(),
+ [CellInfo(name="alpha", state=CellState.CREATED)],
+ )
+
+ started = self.client.spawn("alpha", WAIT_MOUNT_PAYLOAD.argv())
+ self.assertEqual(started.state, CellState.RUNNING)
+
+ self.client.mount("alpha", "tmpfs", "/mnt")
+ self.client.spawn("alpha", WRITE_MOUNT_PAYLOAD.argv())
+
+ res = self.client.wait("alpha")
+ self.assertGreater(res.pid, 0)
+ self.assertEqual(res.exit_code, 0)
+
+ self.client.destroy("alpha")
+ self.assertEqual(self.client.list_cells(), [])
+
+ def test_cell_broadcast_kill(self) -> None:
+ self.client.create("killme", mode=CellMode.HOST)
+ self.client.spawn("killme", PAUSE_PAYLOAD.argv())
+ self.client.spawn("killme", PAUSE_PAYLOAD.argv())
+
+ self.client.kill("killme", signal.SIGKILL)
+ res = self.client.wait("killme")
+ self.assertEqual(res.exit_code, -int(signal.SIGKILL))
+ self.client.destroy("killme")
+
+
+class RootnsUapiTest(RootnsTestBase):
+ probe: ProbeResult
+ cell: Cell | None
+
+ def setUp(self) -> None:
+ self.probe = self.probe_pre_idmap_mkdir()
+ self.cell = None
+ if self.probe.supported:
+ cell = Cell("test")
+ try:
+ cell.setup_rootfs(
+ dirs=("proc", "tmp", "mnt"), mount_procfs=True
+ )
+ except BaseException:
+ cell.close()
+ raise
+ self.cell = cell
+
+ def tearDown(self) -> None:
+ if self.cell is not None:
+ self.cell.close()
+
+ def _require_cell(self) -> Cell:
+ if not self.probe.supported or self.cell is None:
+ self.skipTest(self.probe.reason)
+ return self.cell
+
+ def test_create_flags(self) -> None:
+ self._require_cell()
+ with Rootns(RootnsFlag.NONE):
+ pass
+ with Rootns(RootnsFlag.DEFAULT):
+ pass
+ with self.assertRaises(OSError) as cm:
+ Rootns((~int(RootnsFlag.ALL)) & 0xFFFFFFFF)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ def test_get_nsfd(self) -> None:
+ try:
+ rns = Rootns()
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ self.skipTest(f"rootns() unavailable: {exc}")
+ raise
+ with rns:
+ for case in NS_TYPE_CASES:
+ with self.subTest(ns=case.name):
+ with self.closing_fd(rns.get_nsfd(case.nstype)) as nsfd:
+ self.assertEqual(
+ Sys.ioctl(nsfd, Ioctl.NS_GET_NSTYPE),
+ int(case.nstype),
+ )
+
+ with self.assertRaises(OSError) as cm:
+ rns.get_nsfd(CloneFlag.NEWPID)
+ self.assertEqual(cm.exception.errno, errno.ESRCH)
+
+ with self.assertRaises(OSError) as cm:
+ rns.get_nsfd(0)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with (
+ self.closing_fd(rns.get_nsfd(CloneFlag.NEWNS)) as mntns_fd,
+ self.closing_fd(rns.make_mount("tmpfs")) as rootfd,
+ ):
+ Sys.move_mount(
+ rootfd,
+ "",
+ mntns_fd,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+
+ with SyncPipe.create() as hold:
+ pid = rns.run(hold.wait_in_child)
+ hold.close_read()
+ try:
+ with self.closing_fd(
+ rns.get_nsfd(CloneFlag.NEWPID)
+ ) as nsfd:
+ self.assertEqual(
+ Sys.ioctl(nsfd, Ioctl.NS_GET_NSTYPE),
+ int(CloneFlag.NEWPID),
+ )
+ finally:
+ hold.close_write()
+ self.assertEqual(self.reap_exit_code(pid), 0)
+
+ def test_wait_poll_and_clone_dead(self) -> None:
+ cell = self._require_cell()
+ rns = cell.rns
+
+ with self.assertRaises(OSError) as cm:
+ Sys.ioctl(rns.fd, Ioctl.ROOTNS_WAIT, 0)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ rns.wait((~os.WNOHANG) & 0xFFFFFFFF)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ for wait_flags in (0, os.WNOHANG):
+ with self.assertRaises(OSError) as cm:
+ rns.wait(wait_flags)
+ self.assertEqual(cm.exception.errno, errno.ECHILD)
+
+ with SyncPipe.create() as hold:
+ pid = rns.run(lambda: hold.wait_in_child(42))
+ hold.close_read()
+
+ self.assertEqual(rns.wait(os.WNOHANG), WaitResult(0, 0))
+
+ def check_foreign_pidns_wait() -> None:
+ Sys.unshare(CloneFlag.NEWPID)
+
+ def check_inner_wait() -> None:
+ with self.assertRaises(OSError) as cm_w:
+ rns.wait(os.WNOHANG)
+ self.assertEqual(cm_w.exception.errno, errno.ECHILD)
+
+ self.run_forked(check_inner_wait)
+
+ self.run_forked(check_foreign_pidns_wait)
+ poller = select.poll()
+ poller.register(rns, select.POLLIN)
+ self.assertEqual(poller.poll(0), [])
+ with select.epoll() as ep1, select.epoll() as ep2:
+ ep1.register(rns, select.EPOLLIN | select.EPOLLEXCLUSIVE)
+ ep2.register(rns, select.EPOLLIN | select.EPOLLEXCLUSIVE)
+ self.assertEqual(ep1.poll(0), [])
+ self.assertEqual(ep2.poll(0), [])
+
+ hold.close_write()
+ events = poller.poll(5000)
+ self.assertTrue(any(ev & select.POLLHUP for _, ev in events))
+ ep1_ev = ep1.poll(5.0)
+ ep2_ev = ep2.poll(5.0)
+ self.assertTrue(any(ev & select.EPOLLHUP for _, ev in ep1_ev))
+ self.assertTrue(any(ev & select.EPOLLHUP for _, ev in ep2_ev))
+
+ res = rns.wait(os.WNOHANG)
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.exit_code, 42)
+ self.assertEqual(self.reap_exit_code(pid), 42)
+
+ with self.assertRaises(OSError) as cm:
+ rns.clone_into()
+ self.assertEqual(cm.exception.errno, errno.ESRCH)
+
+ def test_kill_ioctl_and_kill_on_close(self) -> None:
+ cell = self._require_cell()
+ rns = cell.rns
+
+ for case in BAD_SIGNAL_CASES:
+ with self.subTest(sig=case.name):
+ with self.assertRaises(OSError) as cm:
+ rns.kill(case.sig)
+ self.assertEqual(cm.exception.errno, case.expected_errno)
+
+ with SyncPipe.create() as ready, SyncPipe.create() as hold:
+
+ def init_proc() -> int:
+ ready.close()
+ hold.close()
+ signal.pause()
+ return 0
+
+ def member_proc() -> int:
+ ready.close_read()
+ hold.close_read()
+ os.setsid()
+ gc = os.fork()
+ if gc == 0:
+ ready.write_bytes(b"r")
+ ready.close_write()
+ signal.pause()
+ os._exit(0)
+ ready.close_write()
+ signal.pause()
+ return 0
+
+ pid1 = rns.run(init_proc)
+ pid2 = rns.run(member_proc)
+ ready.close_write()
+ hold.close_write()
+
+ self.assertEqual(ready.read_bytes(), b"r")
+ ready.close_read()
+
+ rns.kill(0)
+ rns.kill(signal.SIGKILL)
+ self.assertEqual(hold.read_bytes(), b"")
+ hold.close_read()
+
+ self.assertEqual(
+ self.reap_exit_code(pid2), 128 + int(signal.SIGKILL)
+ )
+ self.assertEqual(
+ self.reap_exit_code(pid1), 128 + int(signal.SIGKILL)
+ )
+
+ with Cell("koc", flags=RootnsFlag.DEFAULT) as cell2:
+ cell2.setup_rootfs(mount_procfs=False)
+ pid_koc = cell2.rns.run(self.pause_forever)
+ self.assertEqual(
+ self.reap_exit_code(pid_koc), 128 + int(signal.SIGKILL)
+ )
+
+ def test_proc_submount_and_nested_namespaces(self) -> None:
+ cell = self._require_cell()
+ cell.mount_fs("tmpfs", "mnt")
+
+ def inside() -> int:
+ if os.getpid() != 1:
+ return 1
+ pids = [e for e in os.listdir("/proc") if e.isdigit()]
+ if pids != ["1"]:
+ return 2
+ with open("/mnt/hello", "wb") as f:
+ f.write(b"ok")
+ Sys.unshare(
+ CloneFlag.NEWUTS | CloneFlag.NEWIPC | CloneFlag.NEWNET
+ )
+ return 0
+
+ pid = cell.rns.run(inside)
+ res = cell.wait()
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.exit_code, 0)
+ self.assertEqual(self.reap_exit_code(pid), 0)
+
+ def test_setns_owner_vs_foreign(self) -> None:
+ cell = self._require_cell()
+ with SyncPipe.create() as hold:
+ pid = cell.rns.run(hold.wait_in_child)
+ hold.close_read()
+ try:
+ with self.closing_fd(
+ os.open(f"/proc/{pid}/ns/uts", os.O_RDONLY | os.O_CLOEXEC)
+ ) as uts_fd:
+ self.run_forked(
+ lambda: Sys.setns(uts_fd, CloneFlag.NEWUTS)
+ )
+
+ if os.geteuid() == 0:
+
+ def check_foreign() -> None:
+ try:
+ self.drop_to_uid(1000)
+ except OSError:
+ return
+ with self.assertRaises(OSError) as cm_perm:
+ Sys.setns(uts_fd, CloneFlag.NEWUTS)
+ self.assertEqual(
+ cm_perm.exception.errno, errno.EPERM
+ )
+
+ self.run_forked(check_foreign)
+ finally:
+ hold.close_write()
+ self.reap_exit_code(pid)
+
+ def test_mount_and_fsconfig_validation(self) -> None:
+ self._require_cell()
+ with (
+ Rootns() as rns,
+ self.closing_fd(rns.get_nsfd(CloneFlag.NEWNS)) as mntns_fd,
+ ):
+ with self.assertRaises(OSError) as cm:
+ Sys.move_mount(
+ Sys.AT_FDCWD, "/", mntns_fd, "/", MoveMountFlag.T_MNTNS
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ "/tmp",
+ Sys.AT_FDCWD,
+ "/tmp",
+ MoveMountFlag.CLONE,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ "/tmp",
+ mntns_fd,
+ "/",
+ MoveMountFlag.T_MNTNS
+ | MoveMountFlag.CLONE
+ | MoveMountFlag.SET_GROUP,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.closing_fd(rns.make_mount("tmpfs")) as m1:
+ Sys.move_mount(
+ m1,
+ "",
+ mntns_fd,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+
+ with self.closing_fd(rns.make_mount("tmpfs")) as m2:
+ for alias in ("/", "."):
+ with self.assertRaises(OSError) as cm:
+ Sys.move_mount(
+ m2,
+ "",
+ mntns_fd,
+ alias,
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+ with self.assertRaises(OSError) as cm:
+ Sys.move_mount(
+ m2,
+ "",
+ mntns_fd,
+ ".",
+ MoveMountFlag.F_EMPTY_PATH
+ | MoveMountFlag.T_MNTNS
+ | MoveMountFlag.BENEATH,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.closing_fd(Sys.fsopen("tmpfs")) as fsfd:
+ Sys.fsconfig(fsfd, FsconfigCmd.SET_ROOTNS, aux=rns.fd)
+ with self.assertRaises(OSError) as cm:
+ Sys.fsconfig(fsfd, FsconfigCmd.SET_ROOTNS, aux=rns.fd)
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+
+ with (
+ Rootns() as other_rns,
+ self.closing_fd(
+ other_rns.get_nsfd(CloneFlag.NEWNS)
+ ) as other_mntns,
+ self.closing_fd(rns.make_mount("tmpfs")) as bound_mfd,
+ ):
+ with self.assertRaises(OSError) as cm:
+ Sys.move_mount(
+ bound_mfd,
+ "",
+ other_mntns,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.closing_fd(Sys.fsopen("proc")) as p_fsfd:
+ Sys.fsconfig(p_fsfd, FsconfigCmd.SET_ROOTNS, aux=rns.fd)
+ with self.assertRaises(OSError) as cm:
+ Sys.fsconfig(
+ p_fsfd,
+ FsconfigCmd.SET_STRING,
+ key="pidns",
+ value="/proc/self/ns/pid",
+ )
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+
+ with self.closing_fd(Sys.fsopen("proc")) as bad_proc:
+
+ def check_nonancestor_proc() -> None:
+ Sys.unshare(CloneFlag.NEWPID)
+
+ def check_inner() -> None:
+ with self.assertRaises(OSError) as cm_set:
+ Sys.fsconfig(
+ bad_proc, FsconfigCmd.SET_ROOTNS, aux=rns.fd
+ )
+ self.assertEqual(cm_set.exception.errno, errno.EINVAL)
+ with self.assertRaises(OSError) as cm_create:
+ Sys.fsconfig(bad_proc, FsconfigCmd.CMD_CREATE)
+ self.assertEqual(
+ cm_create.exception.errno, errno.EBUSY
+ )
+
+ self.run_forked(check_inner)
+
+ self.run_forked(check_nonancestor_proc)
+
+ with (
+ Rootns() as rns_lock,
+ self.closing_fd(
+ rns_lock.get_nsfd(CloneFlag.NEWNS)
+ ) as lock_mntns,
+ SyncPipe.create() as prop_ready,
+ SyncPipe.create() as prop_go,
+ ):
+ rns_lock.map_self_ugid()
+ with self.closing_fd(rns_lock.make_mount("tmpfs")) as rfd:
+ os.mkdir("host_sub", 0o755, dir_fd=rfd)
+ os.mkdir("prop_mnt", 0o755, dir_fd=rfd)
+ Sys.move_mount(
+ rfd,
+ "",
+ lock_mntns,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ "/tmp",
+ lock_mntns,
+ "host_sub",
+ MoveMountFlag.T_MNTNS | MoveMountFlag.CLONE,
+ )
+
+ def try_umount_locked() -> int:
+ prop_ready.close_read()
+ prop_go.close_write()
+ try:
+ Sys.umount2("/host_sub", UmountFlag.DETACH)
+ return 1
+ except OSError as exc:
+ if exc.errno != errno.EINVAL:
+ return 2
+ Sys.set_mount_propagation(
+ "/", MountFlag.REC | MountFlag.SHARED
+ )
+ peer = os.fork()
+ if peer == 0:
+ Sys.unshare(CloneFlag.NEWNS)
+ prop_ready.write_bytes(b"p")
+ prop_ready.close_write()
+ if prop_go.read_bytes() != b"g":
+ os._exit(3)
+ prop_go.close_read()
+ if not os.path.ismount("/prop_mnt"):
+ os._exit(4)
+ try:
+ Sys.umount2("/prop_mnt", UmountFlag.DETACH)
+ os._exit(5)
+ except OSError as exc:
+ os._exit(0 if exc.errno == errno.EINVAL else 6)
+ prop_ready.close_write()
+ prop_go.close_read()
+ return self.reap_exit_code(peer)
+
+ p_lock = rns_lock.run(try_umount_locked)
+ prop_ready.close_write()
+ prop_go.close_read()
+ self.assertEqual(prop_ready.read_bytes(), b"p")
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ "/tmp",
+ lock_mntns,
+ "prop_mnt",
+ MoveMountFlag.T_MNTNS | MoveMountFlag.CLONE,
+ )
+ prop_go.write_bytes(b"g")
+ prop_go.close_write()
+ self.assertEqual(self.reap_exit_code(p_lock), 0)
+
+ if os.geteuid() == 0:
+ u_rns = self.create_rootns_as_uid(1000)
+ if u_rns is not None:
+ with (
+ u_rns,
+ self.closing_fd(
+ u_rns.get_nsfd(CloneFlag.NEWNS)
+ ) as u_mntns,
+ ):
+ with self.closing_fd(
+ u_rns.make_mount("tmpfs")
+ ) as m_root:
+ Sys.move_mount(
+ m_root,
+ "",
+ u_mntns,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH
+ | MoveMountFlag.T_MNTNS,
+ )
+
+ def check_attacker() -> None:
+ try:
+ self.drop_to_uid(2000)
+ except OSError:
+ return
+ with self.closing_fd(Sys.fsopen("tmpfs")) as fsfd2:
+ with self.assertRaises(OSError) as cm_fs:
+ Sys.fsconfig(
+ fsfd2,
+ FsconfigCmd.SET_ROOTNS,
+ aux=u_rns.fd,
+ )
+ self.assertEqual(
+ cm_fs.exception.errno, errno.EPERM
+ )
+ with self.assertRaises(OSError) as cm_clone:
+ u_rns.clone_into()
+ self.assertEqual(
+ cm_clone.exception.errno, errno.EPERM
+ )
+
+ self.run_forked(check_attacker)
+
+ def test_clone_flags_and_pidns_ancestry(self) -> None:
+ cell = self._require_cell()
+ rns = cell.rns
+
+ with Rootns() as empty_rns:
+ with self.assertRaises(OSError) as cm:
+ empty_rns.clone_into(CloneFlag.VFORK)
+ self.assertEqual(cm.exception.errno, errno.ENOENT)
+
+ with (
+ self.closing_fd(
+ empty_rns.get_nsfd(CloneFlag.NEWNS)
+ ) as e_mntns,
+ self.closing_fd(empty_rns.make_mount("tmpfs")) as e_root,
+ ):
+ Sys.move_mount(
+ e_root,
+ "",
+ e_mntns,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ with self.assertRaises(OSError) as cm:
+ empty_rns.clone_into(
+ CloneFlag.AUTOREAP, exit_signal=int(signal.SIGCHLD)
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ args = CloneArgs(
+ flags=int(CloneFlag.INTO_ROOTNS),
+ exit_signal=int(signal.SIGCHLD),
+ rootns=rns.fd,
+ )
+ with self.assertRaises(OSError) as cm:
+ Sys.clone3(args, size=CloneArgs.SIZE_VER2)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ for case in BAD_CLONE_CASES:
+ with self.subTest(flag=case.name):
+ with self.assertRaises(OSError) as cm:
+ rns.clone_into(
+ extra_flags=case.flags,
+ exit_signal=case.exit_signal,
+ )
+ self.assertEqual(cm.exception.errno, case.expected_errno)
+
+ allowed = (
+ CloneFlag.VFORK
+ | CloneFlag.PIDFD
+ | CloneFlag.CLEAR_SIGHAND
+ | CloneFlag.NNP
+ )
+ old_umask = os.umask(0o077)
+ try:
+ Sys.prctl(PrctlOp.SET_DUMPABLE, 1)
+ pid, pidfd = rns.clone_into(extra_flags=allowed)
+ if pid == 0:
+ cur_umask = os.umask(0o022)
+ dumpable = Sys.prctl(PrctlOp.GET_DUMPABLE)
+ ok = (
+ os.getpid() == 1
+ and Sys.prctl(PrctlOp.GET_NO_NEW_PRIVS) == 1
+ and cur_umask == 0o077
+ and dumpable != 1
+ )
+ os._exit(0 if ok else 1)
+ finally:
+ os.umask(old_umask)
+ self.assertGreaterEqual(pidfd, 0)
+ os.close(pidfd)
+ self.assertEqual(self.reap_exit_code(pid), 0)
+
+ with Cell("exdev") as cell2:
+ cell2.setup_rootfs(mount_procfs=False)
+
+ def check_exdev() -> None:
+ Sys.unshare(CloneFlag.NEWPID)
+
+ def check_inner() -> None:
+ with self.assertRaises(OSError) as cm_exdev:
+ cell2.rns.clone_into()
+ self.assertEqual(cm_exdev.exception.errno, errno.EXDEV)
+
+ self.run_forked(check_inner)
+
+ self.run_forked(check_exdev)
+
+ def test_concurrent_bootstrap(self) -> None:
+ cell = self._require_cell()
+ rns = cell.rns
+ with (
+ SyncPipe.create() as start,
+ SyncPipe.create() as ready,
+ SyncPipe.create() as init_gate,
+ SyncPipe.create() as peer_gate,
+ ):
+ workers: list[int] = []
+ for idx in range(4):
+ wpid = os.fork()
+ if wpid == 0:
+ start.close_write()
+ ready.close_read()
+ init_gate.close_write()
+ peer_gate.close_write()
+ start.read_bytes()
+ start.close_read()
+
+ def entrant(worker_idx: int = idx) -> int:
+ my_pid = os.getpid()
+ ready.write_bytes(bytes([worker_idx, my_pid]))
+ ready.close_write()
+ gate = init_gate if my_pid == 1 else peer_gate
+ gate.read_bytes()
+ init_gate.close_read()
+ peer_gate.close_read()
+ return 0
+
+ cpid = rns.run(entrant)
+ ready.close_write()
+ init_gate.close_read()
+ peer_gate.close_read()
+ os._exit(0 if self.reap_exit_code(cpid) == 0 else 1)
+ workers.append(wpid)
+
+ start.close_read()
+ ready.close_write()
+ init_gate.close_read()
+ peer_gate.close_read()
+ start.close_write()
+
+ seen_pids: set[int] = set()
+ init_idx = -1
+ for _ in range(4):
+ msg = ready.read_bytes(2)
+ self.assertEqual(len(msg), 2)
+ if msg[1] == 1:
+ init_idx = msg[0]
+ seen_pids.add(msg[1])
+ ready.close_read()
+
+ self.assertEqual(seen_pids, {1, 2, 3, 4})
+ self.assertGreaterEqual(init_idx, 0)
+
+ peer_gate.close_write()
+ for i, wpid in enumerate(workers):
+ if i != init_idx:
+ self.assertEqual(self.reap_exit_code(wpid), 0)
+ init_gate.close_write()
+ self.assertEqual(self.reap_exit_code(workers[init_idx]), 0)
+
+ res = cell.wait()
+ self.assertGreater(res.pid, 0)
+ self.assertEqual(res.exit_code, 0)
+
+ def test_pivot_root_and_standalone_mntns_hot_mount(self) -> None:
+ cell = self._require_cell()
+ with (
+ SyncPipe.create() as ready,
+ SyncPipe.create() as hold,
+ ):
+
+ def init_pivot() -> int:
+ ready.close_read()
+ hold.close_write()
+ with self.closing_fd(self.make_plain_mount("tmpfs")) as mfd:
+ os.mkdir("old_root", 0o755, dir_fd=mfd)
+ os.mkdir("sub", 0o755, dir_fd=mfd)
+ with self.closing_fd(
+ os.open(
+ "pivoted",
+ os.O_CREAT | os.O_WRONLY | os.O_CLOEXEC,
+ 0o644,
+ dir_fd=mfd,
+ )
+ ):
+ pass
+ Sys.move_mount(
+ mfd,
+ "",
+ Sys.AT_FDCWD,
+ "/mnt",
+ MoveMountFlag.F_EMPTY_PATH,
+ )
+ os.chdir("/mnt")
+ Sys.pivot_root(".", "old_root")
+ os.chdir("/")
+ Sys.umount2("/old_root", UmountFlag.DETACH)
+ ready.write_bytes(b"p")
+ ready.close_write()
+ hold.read_bytes()
+ hold.close_read()
+ return 0
+
+ pid1 = cell.rns.run(init_pivot)
+ ready.close_write()
+ hold.close_read()
+ try:
+ self.assertEqual(ready.read_bytes(), b"p")
+ ready.close_read()
+
+ cell.mount_fs("tmpfs", "sub")
+
+ pid2 = cell.rns.run(
+ lambda: (
+ 0
+ if os.path.exists("/pivoted")
+ and os.path.ismount("/sub")
+ else 1
+ ),
+ )
+ self.assertEqual(self.reap_exit_code(pid2), 0)
+ finally:
+ hold.close_write()
+ self.assertEqual(self.reap_exit_code(pid1), 0)
+
+ with SyncPipe.create() as ext_ready, SyncPipe.create() as ext_hold:
+ plain_pid = os.fork()
+ if plain_pid == 0:
+ ext_ready.close_read()
+ ext_hold.close_write()
+ try:
+ Sys.unshare(CloneFlag.NEWNS)
+ Sys.set_mount_propagation("/")
+ with self.closing_fd(
+ self.make_plain_mount("tmpfs")
+ ) as mfd:
+ Sys.move_mount(
+ mfd,
+ "",
+ Sys.AT_FDCWD,
+ "/tmp",
+ MoveMountFlag.F_EMPTY_PATH,
+ )
+ os.mkdir("/tmp/target", 0o755)
+ ext_ready.write_bytes(b"r")
+ ext_ready.close_write()
+ ext_hold.read_bytes()
+ ext_hold.close_read()
+ os._exit(0 if os.path.ismount("/tmp/target") else 2)
+ except BaseException:
+ os._exit(1)
+ ext_ready.close_write()
+ ext_hold.close_read()
+ try:
+ self.assertEqual(ext_ready.read_bytes(), b"r")
+ ext_ready.close_read()
+ with (
+ self.closing_fd(
+ os.open(
+ f"/proc/{plain_pid}/ns/mnt",
+ os.O_RDONLY | os.O_CLOEXEC,
+ )
+ ) as ext_mntns,
+ self.closing_fd(self.make_plain_mount("tmpfs")) as mfd,
+ ):
+ with self.assertRaises(OSError) as cm:
+ Sys.move_mount(
+ mfd,
+ "",
+ ext_mntns,
+ "tmp/..",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+ with self.assertRaises(OSError) as cm:
+ Sys.move_mount(
+ mfd,
+ "",
+ ext_mntns,
+ "tmp/..",
+ MoveMountFlag.F_EMPTY_PATH
+ | MoveMountFlag.T_MNTNS
+ | MoveMountFlag.BENEATH,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+ Sys.move_mount(
+ mfd,
+ "",
+ ext_mntns,
+ "tmp/target",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ finally:
+ ext_hold.close_write()
+ self.assertEqual(self.reap_exit_code(plain_pid), 0)
+
+ def test_userns_set_idmap(self) -> None:
+ self._require_cell()
+ with (
+ Rootns() as rns,
+ self.closing_fd(rns.get_nsfd(CloneFlag.NEWUSER)) as userns_fd,
+ self.closing_fd(rns.get_nsfd(CloneFlag.NEWNS)) as mntns_fd,
+ ):
+ with self.assertRaises(OSError) as cm:
+ Sys.userns_set_idmap_raw(-1, 0)
+ self.assertEqual(cm.exception.errno, errno.EBADF)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.userns_set_idmap_raw(userns_fd, 0)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(
+ userns_fd,
+ uid_extents=((0, os.geteuid(), 1),),
+ size=UsernsIdmap.SIZE_VER0 - 1,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(
+ userns_fd,
+ uid_extents=((0, os.geteuid(), 1),),
+ sys_flags=1,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(
+ rns.fd,
+ uid_extents=((0, os.geteuid(), 1),),
+ deny_setgroups=True,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(
+ mntns_fd,
+ uid_extents=((0, os.geteuid(), 1),),
+ deny_setgroups=True,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(userns_fd)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(
+ userns_fd,
+ extra_flags=(~int(UsernsIdmapFlag.ALL)) & 0xFFFFFFFF,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(
+ userns_fd,
+ uid_extents=((0, os.geteuid(), 0),),
+ deny_setgroups=True,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ rns.map_self_ugid()
+ with self.assertRaises(OSError) as cm:
+ rns.map_self_ugid()
+ self.assertEqual(cm.exception.errno, errno.EPERM)
+
+ with self.closing_fd(rns.make_mount("tmpfs")) as rootfd:
+ os.mkdir("proc", 0o755, dir_fd=rootfd)
+ Sys.move_mount(
+ rootfd,
+ "",
+ mntns_fd,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ with self.closing_fd(rns.make_mount("proc")) as pfd:
+ Sys.move_mount(
+ pfd,
+ "",
+ mntns_fd,
+ "proc",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+
+ def verify_idmap() -> int:
+ if os.geteuid() != 0 or os.getegid() != 0:
+ return 1
+ with open("/proc/self/setgroups", "rb") as f:
+ if f.read() != b"deny\n":
+ return 2
+ return 0
+
+ pid = rns.run(verify_idmap)
+ res = rns.wait()
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.exit_code, 0)
+ self.assertEqual(self.reap_exit_code(pid), 0)
+
+ def test_userns_set_idmap_delegation(self) -> None:
+ self._require_cell()
+ if os.geteuid() != 0:
+ self.skipTest("uidmapd delegation test requires root")
+
+ rns1 = self.create_rootns_as_uid(1000)
+ rns2 = self.create_rootns_as_uid(1000)
+ if rns1 is None or rns2 is None:
+ if rns1 is not None:
+ rns1.close()
+ if rns2 is not None:
+ rns2.close()
+ self.skipTest("unprivileged rootns creation unavailable")
+
+ with rns1, rns2:
+ s_main, s_alice = socket.socketpair(
+ socket.AF_UNIX, socket.SOCK_DGRAM
+ )
+ alice_pid = os.fork()
+ if alice_pid == 0:
+ s_main.close()
+ try:
+ self.drop_to_uid(1000)
+ with self.closing_fd(
+ rns1.get_nsfd(CloneFlag.NEWUSER)
+ ) as ufd1:
+ socket.send_fds(s_alice, [b"A"], [ufd1])
+ os._exit(0)
+ except BaseException:
+ os._exit(1)
+ finally:
+ s_alice.close()
+ s_alice.close()
+ _, alice_fds, _, _ = socket.recv_fds(s_main, 1, 1)
+ s_main.close()
+ self.assertEqual(self.reap_exit_code(alice_pid), 0)
+
+ with (
+ self.closing_fd(alice_fds[0]) as alice_ufd,
+ self.closing_fd(rns2.get_nsfd(CloneFlag.NEWUTS)) as uts2_fd,
+ ):
+ s_m1, s_m2 = socket.socketpair(
+ socket.AF_UNIX, socket.SOCK_DGRAM
+ )
+ mal_pid = os.fork()
+ if mal_pid == 0:
+ s_m1.close()
+ try:
+ self.drop_to_uid(2000)
+ with self.closing_fd(
+ Sys.ioctl(uts2_fd, Ioctl.NS_GET_USERNS)
+ ) as bad_ufd:
+ socket.send_fds(s_m2, [b"M"], [bad_ufd])
+ os._exit(0)
+ except BaseException:
+ os._exit(1)
+ finally:
+ s_m2.close()
+ s_m2.close()
+ _, mal_fds, _, _ = socket.recv_fds(s_m1, 1, 1)
+ s_m1.close()
+ self.assertEqual(self.reap_exit_code(mal_pid), 0)
+
+ with self.closing_fd(mal_fds[0]) as mallory_ufd:
+
+ def run_uidmapd() -> None:
+ try:
+ Sys.drop_to_setid_helper(990)
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ self.skipTest(f"setid helper setup: {exc}")
+ raise
+
+ with self.assertRaises(OSError) as cm_bad:
+ Sys.set_userns_idmap(
+ mallory_ufd,
+ uid_extents=((0, 1000, 1),),
+ deny_setgroups=True,
+ )
+ self.assertEqual(cm_bad.exception.errno, errno.EPERM)
+
+ with self.assertRaises(OSError) as cm_root:
+ Sys.set_userns_idmap(
+ alice_ufd,
+ uid_extents=((0, 0, 1),),
+ deny_setgroups=True,
+ )
+ self.assertEqual(cm_root.exception.errno, errno.EPERM)
+
+ Sys.set_userns_idmap(
+ alice_ufd,
+ uid_extents=((0, 1000, 1), (1, 2000, 1)),
+ gid_extents=((0, 1000, 1), (1, 2000, 1)),
+ deny_setgroups=True,
+ )
+
+ self.run_forked(run_uidmapd)
+
+ def verify_as_alice() -> None:
+ self.drop_to_uid(1000)
+ with (
+ self.closing_fd(
+ rns1.get_nsfd(CloneFlag.NEWNS)
+ ) as mntns_fd,
+ self.closing_fd(rns1.make_mount("tmpfs")) as rootfd,
+ ):
+ Sys.move_mount(
+ rootfd,
+ "",
+ mntns_fd,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+
+ def switch_subuid() -> int:
+ os.setresgid(1, 1, 1)
+ os.setresuid(1, 1, 1)
+ return 0 if os.geteuid() == 1 and os.getegid() == 1 else 1
+
+ pid = rns1.run(switch_subuid)
+ res = rns1.wait()
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.exit_code, 0)
+ self.assertEqual(self.reap_exit_code(pid), 0)
+
+ self.run_forked(verify_as_alice)
+
+ def test_unprivileged_without_entering_userns(self) -> None:
+ def worker() -> None:
+ if os.geteuid() == 0:
+ try:
+ self.drop_to_uid(1000)
+ except OSError as exc:
+ if exc.errno == errno.EINVAL:
+ self.skipTest("uid 1000 unmapped in current userns")
+ raise
+
+ try:
+ tfd = Sys.fsopen("tmpfs")
+ except OSError as exc:
+ self.assertEqual(exc.errno, errno.EPERM)
+ else:
+ with self.closing_fd(tfd):
+ with self.assertRaises(OSError) as cm_create:
+ Sys.fsconfig(tfd, FsconfigCmd.CMD_CREATE)
+ self.assertEqual(cm_create.exception.errno, errno.EPERM)
+
+ with self.assertRaises(OSError) as cm_ot:
+ Sys.open_tree(
+ Sys.AT_FDCWD,
+ "/tmp",
+ OpenTreeFlag.CLONE | OpenTreeFlag.CLOEXEC,
+ )
+ self.assertEqual(cm_ot.exception.errno, errno.EPERM)
+
+ try:
+ cell = Cell("unpriv", flags=RootnsFlag.DEFAULT)
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ self.skipTest("unprivileged rootns unavailable")
+ raise
+
+ with (
+ tempfile.TemporaryDirectory(prefix="rootns-unpriv-") as hdir,
+ cell,
+ ):
+ os.chmod(hdir, 0o755)
+ with open(os.path.join(hdir, "hello"), "wb") as f:
+ f.write(b"unpriv-ok\n")
+ cell.setup_rootfs(
+ dirs=("proc", "tmp", "mnt"), mount_procfs=True
+ )
+ cell.bind_mount(hdir, "mnt")
+
+ def unpriv_init() -> int:
+ if (
+ os.getpid() != 1
+ or os.geteuid() != 0
+ or os.getegid() != 0
+ ):
+ return 1
+ pids = [e for e in os.listdir("/proc") if e.isdigit()]
+ if pids != ["1"]:
+ return 2
+ with open("/mnt/hello", "rb") as hf:
+ if hf.read() != b"unpriv-ok\n":
+ return 3
+ try:
+ Sys.umount2("/mnt", UmountFlag.DETACH)
+ return 4
+ except OSError as exc:
+ return 0 if exc.errno == errno.EINVAL else 5
+
+ pid = cell.rns.run(unpriv_init)
+ res = cell.wait()
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.exit_code, 0)
+ self.assertEqual(self.reap_exit_code(pid), 0)
+
+ self.run_forked(worker)
+
+class KtapTestResult(unittest.TestResult):
+ def __init__(self, ksft_mod: Any) -> None:
+ super().__init__()
+ self._ksft = ksft_mod
+ self._failed = False
+
+ @staticmethod
+ def _test_name(test: unittest.TestCase) -> str:
+ return f"{type(test).__name__}.{test._testMethodName}"
+
+ def _print_diag(self, text: str) -> None:
+ for line in text.rstrip().splitlines():
+ self._ksft.print_msg(line)
+
+ def _print_err(
+ self,
+ test: unittest.TestCase,
+ err: (
+ tuple[type[BaseException], BaseException, TracebackType]
+ | tuple[None, None, None]
+ ),
+ ) -> None:
+ formatted = "".join(traceback.format_exception(*err))
+ self._print_diag(f"{test.id()}:\n{formatted}")
+
+ def startTest(self, test: unittest.TestCase) -> None:
+ super().startTest(test)
+ self._failed = False
+
+ def stopTest(self, test: unittest.TestCase) -> None:
+ if self._failed:
+ self._ksft.test_result_fail(self._test_name(test))
+ super().stopTest(test)
+
+ def addSuccess(self, test: unittest.TestCase) -> None:
+ super().addSuccess(test)
+ self._ksft.test_result_pass(self._test_name(test))
+
+ def addSkip(self, test: unittest.TestCase, reason: str) -> None:
+ super().addSkip(test, reason)
+ name = self._test_name(test)
+ if reason:
+ self._print_diag(f"{name}: {reason}")
+ self._ksft.test_result_skip(name)
+
+ def addFailure(
+ self,
+ test: unittest.TestCase,
+ err: (
+ tuple[type[BaseException], BaseException, TracebackType]
+ | tuple[None, None, None]
+ ),
+ ) -> None:
+ super().addFailure(test, err)
+ self._print_err(test, err)
+ self._failed = True
+
+ def addError(
+ self,
+ test: unittest.TestCase,
+ err: (
+ tuple[type[BaseException], BaseException, TracebackType]
+ | tuple[None, None, None]
+ ),
+ ) -> None:
+ super().addError(test, err)
+ self._print_err(test, err)
+ self._failed = True
+
+ def addSubTest(
+ self,
+ test: unittest.TestCase,
+ subtest: unittest.TestCase,
+ err: (
+ tuple[type[BaseException], BaseException, TracebackType]
+ | tuple[None, None, None]
+ | None
+ ),
+ ) -> None:
+ super().addSubTest(test, subtest, err)
+ if err is not None:
+ self._print_err(subtest, err)
+ self._failed = True
+
+
+class KtapRunner:
+ @staticmethod
+ def _load_ksft() -> Any:
+ ksft_dir = str(Path(__file__).resolve().parents[1] / "kselftest")
+ if ksft_dir not in sys.path:
+ sys.path.insert(0, ksft_dir)
+ return importlib.import_module("ksft")
+
+ @classmethod
+ def main(cls, argv: Sequence[str] | None = None) -> NoReturn:
+ args = list(sys.argv[1:] if argv is None else argv)
+ loader = unittest.TestLoader()
+ module = sys.modules[__name__]
+ suite = (
+ loader.loadTestsFromNames(args, module)
+ if args
+ else loader.loadTestsFromModule(module)
+ )
+ ksft = cls._load_ksft()
+ total = suite.countTestCases()
+ ksft.print_header()
+ ksft.set_plan(total)
+ result = KtapTestResult(ksft)
+ suite.run(result)
+ ksft.print_cnts()
+ sys.stdout.flush()
+ counts: dict[str, int] = ksft.ksft_cnt
+ if counts["fail"] > 0:
+ code = int(ksft.KSFT_FAIL)
+ elif total == 0 or (counts["pass"] == 0 and counts["skip"] > 0):
+ code = int(ksft.KSFT_SKIP)
+ else:
+ code = int(ksft.KSFT_PASS)
+ sys.exit(code)
+
+
+if __name__ == "__main__":
+ KtapRunner.main()
diff --git a/tools/testing/selftests/rootns/test_smoke.sh b/tools/testing/selftests/rootns/test_smoke.sh
new file mode 100755
index 000000000000..729e0c275602
--- /dev/null
+++ b/tools/testing/selftests/rootns/test_smoke.sh
@@ -0,0 +1,10 @@
+#!/bin/sh
+# SPDX-License-Identifier: GPL-2.0
+
+# Kselftest framework requirement - SKIP code is 4.
+ksft_skip=4
+
+command -v python3 >/dev/null 2>&1 || exit $ksft_skip
+
+DIR="$(dirname "$(readlink -f "$0")")"
+exec python3 "$DIR/rootns_test.py" "$@"
--
2.47.3
next prev parent reply other threads:[~2026-11-21 0:10 UTC|newest]
Thread overview: 28+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-21 0:08 [RFC PATCH v5 00/25] rootns: fd-bound process closures Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 01/25] userns: Factor out idmap validation and commit helpers Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 02/25] userns: Add userns_set_idmap() system call Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 03/25] arch: Wire up " Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 04/25] mount: Add mnt_ns_get_root() Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 05/25] mount: Enforce mount_too_revealing() for foreign mntns Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 06/25] mount: Support MOVE_MOUNT_T_MNTNS in move_mount() Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 07/25] mount: Support MOVE_MOUNT_CLONE with MOVE_MOUNT_T_MNTNS Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 08/25] userns: Factor out install_user_ns_cred() Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 09/25] nsfs: Add nsproxy_open_namespace() Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 10/25] nsproxy: Pass nsproxy to create_new_namespaces() Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 11/25] rootns: Add core infrastructure for root namespaces Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 12/25] rootns: Track init lifecycle via copy_process() and pid_namespace Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 13/25] rootns: Add rootns() system call Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 14/25] rootns: Add ROOTNS_WAIT ioctl Jarkko Sakkinen
2026-11-21 0:17 ` Jarkko Sakkinen
2026-11-21 0:18 ` Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 15/25] rootns: Add ROOTNS_KILL ioctl Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 16/25] fork: Support CLONE_INTO_ROOTNS in clone3() Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 17/25] fs: Support FSCONFIG_SET_ROOTNS in fsconfig() Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 18/25] proc: Implement ->set_rootns() fs_context operation Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 19/25] ipc/mqueue: " Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 20/25] security: Add rootns LSM hooks Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 21/25] bpf: Register " Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 22/25] arch: Wire up rootns() system call Jarkko Sakkinen
2026-11-21 0:08 ` [RFC PATCH v5 23/25] docs: Document root namespace uAPI Jarkko Sakkinen
2026-11-21 0:08 ` Jarkko Sakkinen [this message]
2026-11-21 0:08 ` [RFC PATCH v5 25/25] MAINTAINERS: Add entry for ROOT NAMESPACE Jarkko Sakkinen
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261121000844.1863324-25-jarkko@kernel.org \
--to=jarkko@kernel.org \
--cc=alex@amutable.com \
--cc=brauner@kernel.org \
--cc=corbet@lwn.net \
--cc=dhowells@redhat.com \
--cc=jack@suse.cz \
--cc=josef@toxicpanda.com \
--cc=kees@kernel.org \
--cc=linux-api@vger.kernel.org \
--cc=linux-doc@vger.kernel.org \
--cc=linux-fsdevel@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-kselftest@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=linux-security-module@vger.kernel.org \
--cc=luto@amacapital.net \
--cc=neal@gompa.dev \
--cc=paul@paul-moore.com \
--cc=sergeh@kernel.org \
--cc=viro@zeniv.linux.org.uk \
--cc=zygmunt.krynicki@canonical.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).