From: Jarkko Sakkinen <jarkko@kernel.org>
To: linux-fsdevel@vger.kernel.org
Cc: Jarkko Sakkinen <jarkko@kernel.org>,
linux-api@vger.kernel.org, linux-arch@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,
Albert Ou <aou@eecs.berkeley.edu>,
Alexander Gordeev <agordeev@linux.ibm.com>,
Alexander Viro <viro@zeniv.linux.org.uk>,
Alexandre Ghiti <alex@ghiti.fr>,
Andreas Larsson <andreas@gaisler.com>,
Andrew Morton <akpm@linux-foundation.org>,
Andy Lutomirski <luto@amacapital.net>,
Andy Lutomirski <luto@kernel.org>,
Anna-Maria Behnsen <anna-maria@linutronix.de>,
Arnd Bergmann <arnd@arndb.de>, Ben Segall <bsegall@google.com>,
Borislav Petkov <bp@alien8.de>,
Casey Schaufler <casey@schaufler-ca.com>,
Catalin Marinas <catalin.marinas@arm.com>,
Christian Borntraeger <borntraeger@linux.ibm.com>,
Christian Brauner <brauner@kernel.org>,
"Christophe Leroy (CS GROUP)" <chleroy@kernel.org>,
Chris Zankel <chris@zankel.net>,
Dave Hansen <dave.hansen@linux.intel.com>,
David Hildenbrand <david@kernel.org>,
David Howells <dhowells@redhat.com>,
Davidlohr Bueso <dave@stgolabs.net>,
"David S. Miller" <davem@davemloft.net>,
Dietmar Eggemann <dietmar.eggemann@arm.com>,
Frederic Weisbecker <frederic@kernel.org>,
Geert Uytterhoeven <geert@linux-m68k.org>,
"Hallgrimur H. Gunnarsson" <halg@google.com>,
Heiko Carstens <hca@linux.ibm.com>, Helge Deller <deller@gmx.de>,
"H. Peter Anvin" <hpa@zytor.com>, Ingo Molnar <mingo@redhat.com>,
"James E.J. Bottomley" <James.Bottomley@HansenPartnership.com>,
Jan Kara <jack@suse.cz>,
John Johansen <john.johansen@canonical.com>,
John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>,
Jonathan Corbet <corbet@lwn.net>,
Josef Bacik <josef@toxicpanda.com>,
Juri Lelli <juri.lelli@redhat.com>, Kees Cook <kees@kernel.org>,
K Prateek Nayak <kprateek.nayak@amd.com>,
"Liam R. Howlett" <liam@infradead.org>,
Lorenzo Stoakes <ljs@kernel.org>,
Madhavan Srinivasan <maddy@linux.ibm.com>,
Magnus Lindholm <linmag7@gmail.com>,
Manfred Spraul <manfred@colorfullife.com>,
Mark Rutland <mark.rutland@arm.com>,
Matt Turner <mattst88@gmail.com>,
Max Filippov <jcmvbkbc@gmail.com>, Mel Gorman <mgorman@suse.de>,
Michael Ellerman <mpe@ellerman.id.au>,
Michal Hocko <mhocko@suse.com>, Michal Simek <monstr@monstr.eu>,
Mike Rapoport <rppt@kernel.org>, Neal Gompa <neal@gompa.dev>,
Nicholas Piggin <npiggin@gmail.com>,
Palmer Dabbelt <palmer@dabbelt.com>,
Paul Moore <paul@paul-moore.com>, Paul Walmsley <pjw@kernel.org>,
Pavel Tikhomirov <ptikhomirov@virtuozzo.com>,
Peter Zijlstra <peterz@infradead.org>,
Randy Dunlap <rdunlap@infradead.org>,
Richard Henderson <richard.henderson@linaro.org>,
Rich Felker <dalias@libc.org>,
"Ritesh Harjani (IBM)" <ritesh.list@gmail.com>,
Russell King <linux@armlinux.org.uk>,
Serge Hallyn <sergeh@kernel.org>,
Shrikanth Hegde <sshegde@linux.ibm.com>,
Shuah Khan <skhan@linuxfoundation.org>,
Steven Rostedt <rostedt@goodmis.org>,
Suren Baghdasaryan <surenb@google.com>,
Sven Schnelle <svens@linux.ibm.com>,
Thomas Bogendoerfer <tsbogend@alpha.franken.de>,
Thomas Gleixner <tglx@kernel.org>,
Valentin Schneider <vschneid@redhat.com>,
Vasily Gorbik <gor@linux.ibm.com>,
Vincent Guittot <vincent.guittot@linaro.org>,
Vincenzo Frascino <vincenzo.frascino@arm.com>,
Vlastimil Babka <vbabka@kernel.org>,
Will Deacon <will@kernel.org>,
Yoshinori Sato <ysato@users.sourceforge.jp>,
Zygmunt Krynicki <zygmunt.krynicki@canonical.com>
Subject: [RFC PATCH v4 13/14] selftests/rootns: Add root namespace test suite
Date: Fri, 20 Nov 2026 00:43:11 +0200 [thread overview]
Message-ID: <20261119224312.1037966-14-jarkko@kernel.org> (raw)
In-Reply-To: <20261119224312.1037966-1-jarkko@kernel.org>
Verify the root namespace and mount-namespace configuration uAPI and
security invariants across privileged, unprivileged, 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 | 1076 +++++++++++++++
tools/testing/selftests/rootns/rootns_test.py | 1161 +++++++++++++++++
tools/testing/selftests/rootns/test_smoke.sh | 11 +
6 files changed, 2264 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..b690ed71a521
--- /dev/null
+++ b/tools/testing/selftests/rootns/rootns_cells.py
@@ -0,0 +1,1076 @@
+#!/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
+import ctypes
+from dataclasses import asdict, dataclass, field
+import errno
+import json
+import os
+import platform
+import selectors
+import signal
+import socket
+import sys
+from types import TracebackType
+from typing import Any, Final, NoReturn
+
+ROOTNS_KILL_ON_CLOSE: Final[int] = 0x00000001
+ROOTNS_CLOSE_ON_EXEC: Final[int] = 0x00000002
+ROOTNS_ALL_FLAGS: Final[int] = 0x00000003
+ROOTNS_IOCTL_MAGIC: Final[int] = 0xB9
+
+CLONE_NEWTIME: Final[int] = 0x00000080
+CLONE_VM: Final[int] = 0x00000100
+CLONE_FS: Final[int] = 0x00000200
+CLONE_FILES: Final[int] = 0x00000400
+CLONE_SIGHAND: Final[int] = 0x00000800
+CLONE_PIDFD: Final[int] = 0x00001000
+CLONE_VFORK: Final[int] = 0x00004000
+CLONE_PARENT: Final[int] = 0x00008000
+CLONE_THREAD: Final[int] = 0x00010000
+CLONE_NEWNS: Final[int] = 0x00020000
+CLONE_SYSVSEM: Final[int] = 0x00040000
+CLONE_NEWCGROUP: Final[int] = 0x02000000
+CLONE_NEWUTS: Final[int] = 0x04000000
+CLONE_NEWIPC: Final[int] = 0x08000000
+CLONE_NEWUSER: Final[int] = 0x10000000
+CLONE_NEWPID: Final[int] = 0x20000000
+CLONE_NEWNET: Final[int] = 0x40000000
+
+CLONE_CLEAR_SIGHAND: Final[int] = 1 << 32
+CLONE_INTO_CGROUP: Final[int] = 1 << 33
+CLONE_AUTOREAP: Final[int] = 1 << 34
+CLONE_NNP: Final[int] = 1 << 35
+CLONE_PIDFD_AUTOKILL: Final[int] = 1 << 36
+CLONE_EMPTY_MNTNS: Final[int] = 1 << 37
+CLONE_INTO_ROOTNS: Final[int] = 1 << 38
+
+CLONE_ARGS_SIZE_VER2: Final[int] = 88
+CLONE_ARGS_SIZE_VER3: Final[int] = 96
+
+AT_FDCWD: Final[int] = -100
+AT_EMPTY_PATH: Final[int] = 0x1000
+AT_RECURSIVE: Final[int] = 0x8000
+MNT_DETACH: Final[int] = 2
+MS_REC: Final[int] = 0x4000
+MS_PRIVATE: Final[int] = 1 << 18
+
+OPEN_TREE_CLONE: Final[int] = 1 << 0
+OPEN_TREE_CLOEXEC: Final[int] = os.O_CLOEXEC
+
+MOVE_MOUNT_F_EMPTY_PATH: Final[int] = 0x00000004
+MOVE_MOUNT_T_EMPTY_PATH: Final[int] = 0x00000040
+MOVE_MOUNT_T_MNTNS: Final[int] = 0x00000080
+MOVE_MOUNT_SET_GROUP: Final[int] = 0x00000100
+MOVE_MOUNT_BENEATH: Final[int] = 0x00000200
+
+FSOPEN_CLOEXEC: Final[int] = 0x00000001
+FSMOUNT_CLOEXEC: Final[int] = 0x00000001
+
+FSCONFIG_SET_FLAG: Final[int] = 0
+FSCONFIG_SET_STRING: Final[int] = 1
+FSCONFIG_CMD_CREATE: Final[int] = 6
+FSCONFIG_SET_ROOTNS: Final[int] = 9
+
+MOUNT_ATTR_RDONLY: Final[int] = 0x00000001
+MOUNT_ATTR_NOSUID: Final[int] = 0x00000002
+MOUNT_ATTR_NODEV: Final[int] = 0x00000004
+
+RESOLVE_IN_ROOT: Final[int] = 0x10
+
+PR_GET_DUMPABLE: Final[int] = 3
+PR_SET_DUMPABLE: Final[int] = 4
+PR_GET_NO_NEW_PRIVS: Final[int] = 39
+
+NSIO: Final[int] = 0xB7
+
+HOST_RUNTIME_ENTRIES: Final[tuple[str, ...]] = (
+ "usr",
+ "bin",
+ "sbin",
+ "lib",
+ "lib32",
+ "lib64",
+ "libx32",
+ "etc",
+ "opt",
+ "nix",
+)
+
+_WIDE_IOC_ARCHS: Final[tuple[str, ...]] = (
+ "ppc",
+ "ppc64",
+ "ppc64le",
+ "powerpc",
+ "sparc",
+ "sparc64",
+ "alpha",
+)
+
+
+def _is_wide_ioc_arch() -> bool:
+ mach = platform.machine().lower()
+ return mach in _WIDE_IOC_ARCHS or mach.startswith("mips")
+
+
+def _ioc(direction: int, magic: int, nr: int, size: int) -> int:
+ sizebits = 13 if _is_wide_ioc_arch() else 14
+ typeshift = 8
+ sizeshift = 16
+ dirshift = sizeshift + sizebits
+ return (
+ (direction << dirshift)
+ | (magic << typeshift)
+ | nr
+ | (size << sizeshift)
+ )
+
+
+def _io(magic: int, nr: int) -> int:
+ return _ioc(0, magic, nr, 0)
+
+
+def _iowr(magic: int, nr: int, size: int) -> int:
+ rw = 6 if _is_wide_ioc_arch() else 3
+ return _ioc(rw, magic, nr, size)
+
+
+class RootnsWaitArgs(ctypes.Structure):
+ flags: int
+ status: int
+ _fields_ = [
+ ("flags", ctypes.c_uint32),
+ ("status", ctypes.c_int32),
+ ]
+
+
+class CloneArgs(ctypes.Structure):
+ 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),
+ ]
+
+
+ROOTNS_GET_NSFD: Final[int] = _io(ROOTNS_IOCTL_MAGIC, 0x01)
+ROOTNS_WAIT: Final[int] = _iowr(
+ ROOTNS_IOCTL_MAGIC, 0x02, ctypes.sizeof(RootnsWaitArgs)
+)
+ROOTNS_KILL: Final[int] = _io(ROOTNS_IOCTL_MAGIC, 0x03)
+
+NS_GET_USERNS: Final[int] = _io(NSIO, 0x01)
+NS_GET_PARENT: Final[int] = _io(NSIO, 0x02)
+NS_GET_NSTYPE: Final[int] = _io(NSIO, 0x03)
+
+
+def _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,
+ "pidfd_open": base + 434,
+ "clone3": base + 435,
+ "openat2": base + 437,
+ "rootns": base + 473,
+ }
+ 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: Final[dict[str, int]] = _syscall_numbers()
+LIBC: Final[ctypes.CDLL] = ctypes.CDLL(None, use_errno=True)
+LIBC.syscall.restype = ctypes.c_long
+
+
+@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: str
+ init_pid: int | None = None
+ exit_code: int | None = None
+
+
+@dataclass(frozen=True)
+class SpawnInfo:
+ pid: int
+ state: str
+
+
+def _os_err() -> NoReturn:
+ err = ctypes.get_errno()
+ raise OSError(err, os.strerror(err))
+
+
+def _cstr(val: str | bytes) -> bytes:
+ if isinstance(val, bytes):
+ return val
+ return os.fsencode(val)
+
+
+def syscall(nr: int, *args: Any) -> int:
+ ret: int = LIBC.syscall(ctypes.c_long(nr), *args)
+ if ret < 0:
+ _os_err()
+ return int(ret)
+
+
+def raw_ioctl(fd: int, cmd: int, arg: int = 0) -> int:
+ ret: int = LIBC.ioctl(
+ ctypes.c_int(fd), ctypes.c_ulong(cmd), ctypes.c_ulong(arg)
+ )
+ if ret < 0:
+ _os_err()
+ return int(ret)
+
+
+def rootns(
+ flags: int = ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC,
+) -> int:
+ return syscall(NR["rootns"], ctypes.c_uint(flags))
+
+
+def rootns_get_nsfd(cfd: int, nstype: int) -> int:
+ return raw_ioctl(cfd, ROOTNS_GET_NSFD, nstype)
+
+
+def rootns_wait(cfd: int, flags: int = 0) -> WaitResult:
+ args = RootnsWaitArgs(flags=flags, status=0)
+ pid = raw_ioctl(cfd, ROOTNS_WAIT, ctypes.addressof(args))
+ return WaitResult(pid=pid, status=int(args.status))
+
+
+def rootns_kill(cfd: int, sig: int) -> None:
+ mask = (1 << (ctypes.sizeof(ctypes.c_ulong) * 8)) - 1
+ raw_ioctl(cfd, ROOTNS_KILL, sig & mask)
+
+
+def fsopen(fsname: str | bytes, flags: int = FSOPEN_CLOEXEC) -> int:
+ return syscall(
+ NR["fsopen"], ctypes.c_char_p(_cstr(fsname)), ctypes.c_uint(flags)
+ )
+
+
+def fsconfig(
+ fsfd: int,
+ cmd: int,
+ key: str | bytes | None = None,
+ value: str | bytes | None = None,
+ aux: int = 0,
+) -> None:
+ k_ptr = (
+ ctypes.c_char_p(_cstr(key)) if key is not None else ctypes.c_void_p(0)
+ )
+ v_ptr = (
+ ctypes.c_char_p(_cstr(value))
+ if value is not None
+ else ctypes.c_void_p(0)
+ )
+ syscall(
+ NR["fsconfig"],
+ ctypes.c_int(fsfd),
+ ctypes.c_uint(cmd),
+ k_ptr,
+ v_ptr,
+ ctypes.c_int(aux),
+ )
+
+
+def fsmount(
+ fsfd: int, flags: int = FSMOUNT_CLOEXEC, attr_flags: int = 0
+) -> int:
+ return syscall(
+ NR["fsmount"],
+ ctypes.c_int(fsfd),
+ ctypes.c_uint(flags),
+ ctypes.c_uint(attr_flags),
+ )
+
+
+def open_tree(dfd: int, path: str | bytes, flags: int) -> int:
+ return syscall(
+ NR["open_tree"],
+ ctypes.c_int(dfd),
+ ctypes.c_char_p(_cstr(path)),
+ ctypes.c_uint(flags),
+ )
+
+
+def move_mount(
+ from_dfd: int,
+ from_path: str | bytes,
+ to_dfd: int,
+ to_path: str | bytes,
+ flags: int,
+) -> None:
+ syscall(
+ NR["move_mount"],
+ ctypes.c_int(from_dfd),
+ ctypes.c_char_p(_cstr(from_path)),
+ ctypes.c_int(to_dfd),
+ ctypes.c_char_p(_cstr(to_path)),
+ ctypes.c_uint(flags),
+ )
+
+
+def openat2(
+ dfd: int,
+ path: str | bytes,
+ flags: int,
+ mode: int = 0,
+ resolve: int = 0,
+) -> int:
+ how = OpenHow(flags=flags, mode=mode, resolve=resolve)
+ return syscall(
+ NR["openat2"],
+ ctypes.c_int(dfd),
+ ctypes.c_char_p(_cstr(path)),
+ ctypes.byref(how),
+ ctypes.c_size_t(ctypes.sizeof(how)),
+ )
+
+
+def execveat(
+ dfd: int,
+ path: str | bytes,
+ argv: Sequence[str],
+ envp: Mapping[str, str] | Sequence[str] | None = None,
+ flags: int = 0,
+) -> NoReturn:
+ c_argv = (ctypes.c_char_p * (len(argv) + 1))(
+ *[_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))(
+ *[_cstr(e) for e in env_items], None
+ )
+ syscall(
+ NR["execveat"],
+ ctypes.c_int(dfd),
+ ctypes.c_char_p(_cstr(path)),
+ c_argv,
+ c_envp,
+ ctypes.c_int(flags),
+ )
+ _os_err()
+
+
+def pidfd_open(pid: int, flags: int = 0) -> int:
+ return syscall(NR["pidfd_open"], ctypes.c_int(pid), ctypes.c_uint(flags))
+
+
+def pivot_root(new_root: str | bytes, put_old: str | bytes) -> None:
+ syscall(
+ NR["pivot_root"],
+ ctypes.c_char_p(_cstr(new_root)),
+ ctypes.c_char_p(_cstr(put_old)),
+ )
+
+
+def umount2(target: str | bytes, flags: int = 0) -> None:
+ syscall(NR["umount2"], ctypes.c_char_p(_cstr(target)), ctypes.c_int(flags))
+
+
+def make_mount_private(target: str | bytes = "/") -> None:
+ ret: int = LIBC.mount(
+ ctypes.c_char_p(b"none"),
+ ctypes.c_char_p(_cstr(target)),
+ ctypes.c_void_p(0),
+ ctypes.c_ulong(MS_REC | MS_PRIVATE),
+ ctypes.c_void_p(0),
+ )
+ if ret < 0:
+ _os_err()
+
+
+def setns(fd: int, nstype: int = 0) -> None:
+ ret: int = LIBC.setns(ctypes.c_int(fd), ctypes.c_int(nstype))
+ if ret < 0:
+ _os_err()
+
+
+def unshare(flags: int) -> None:
+ ret: int = LIBC.unshare(ctypes.c_int(flags))
+ if ret < 0:
+ _os_err()
+
+
+def setgroups_empty() -> None:
+ ret: int = LIBC.setgroups(ctypes.c_size_t(0), ctypes.c_void_p(0))
+ if ret < 0:
+ _os_err()
+
+
+def prctl(
+ option: int,
+ arg2: int = 0,
+ arg3: int = 0,
+ arg4: int = 0,
+ arg5: int = 0,
+) -> int:
+ ret: int = LIBC.prctl(
+ ctypes.c_int(option),
+ ctypes.c_ulong(arg2),
+ ctypes.c_ulong(arg3),
+ ctypes.c_ulong(arg4),
+ ctypes.c_ulong(arg5),
+ )
+ if ret < 0:
+ _os_err()
+ return int(ret)
+
+
+def clone3_raw(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 syscall(
+ NR["clone3"], ctypes.byref(args), ctypes.c_size_t(actual_size)
+ )
+
+
+def clone_into_rootns(
+ cfd: int,
+ extra_flags: int = 0,
+ exit_signal: int = int(signal.SIGCHLD),
+) -> tuple[int, int]:
+ pidfd_cell = ctypes.c_int(-1)
+ args = CloneArgs()
+ args.flags = CLONE_INTO_ROOTNS | extra_flags
+ args.exit_signal = exit_signal
+ args.rootns = cfd & 0xFFFFFFFFFFFFFFFF
+ if extra_flags & CLONE_PIDFD:
+ args.pidfd = ctypes.addressof(pidfd_cell)
+ pid = clone3_raw(args)
+ return pid, int(pidfd_cell.value)
+
+
+def run_in_rootns(
+ cfd: int,
+ fn: Callable[[], int | None],
+ extra_flags: int = 0,
+) -> int:
+ pid, _ = clone_into_rootns(cfd, extra_flags=extra_flags)
+ if pid == 0:
+ try:
+ os.close(cfd)
+ rc = fn()
+ os._exit(0 if rc is None else int(rc))
+ except BaseException:
+ os._exit(126)
+ return pid
+
+
+def make_rootns_mount(
+ cfd: int,
+ fstype: str,
+ attr_flags: int = 0,
+ options: Mapping[str, str | None] | None = None,
+) -> int:
+ fsfd = fsopen(fstype, FSOPEN_CLOEXEC)
+ try:
+ fsconfig(fsfd, FSCONFIG_SET_ROOTNS, aux=cfd)
+ if options:
+ for k, v in options.items():
+ if v is None:
+ fsconfig(fsfd, FSCONFIG_SET_FLAG, key=k)
+ else:
+ fsconfig(fsfd, FSCONFIG_SET_STRING, key=k, value=str(v))
+ fsconfig(fsfd, FSCONFIG_CMD_CREATE)
+ return fsmount(fsfd, FSMOUNT_CLOEXEC, attr_flags)
+ finally:
+ os.close(fsfd)
+
+
+@dataclass
+class Cell:
+ name: str
+ flags: int = ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC
+ cfd: int = field(init=False, default=-1)
+ 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.cfd = rootns(self.flags)
+ self.mntns_fd = rootns_get_nsfd(self.cfd, CLONE_NEWNS)
+
+ def __enter__(self) -> Cell:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: TracebackType | None,
+ ) -> None:
+ self.close()
+
+ def setup_rootfs(
+ self,
+ dirs: Sequence[str] = ("proc", "tmp", "mnt"),
+ mount_procfs: bool = True,
+ host_runtime: bool = False,
+ ) -> None:
+ rootfd = make_rootns_mount(self.cfd, "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)
+ move_mount(
+ rootfd,
+ "",
+ self.mntns_fd,
+ "/",
+ MOVE_MOUNT_F_EMPTY_PATH | MOVE_MOUNT_T_MNTNS,
+ )
+ self.root_dfd = rootfd
+ rootfd = -1
+ finally:
+ if rootfd >= 0:
+ os.close(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: int = 0,
+ options: Mapping[str, str | None] | None = None,
+ ) -> None:
+ mfd = make_rootns_mount(
+ self.cfd, fstype, attr_flags=attr_flags, options=options
+ )
+ try:
+ move_mount(
+ mfd,
+ "",
+ self.mntns_fd,
+ target.lstrip("/"),
+ MOVE_MOUNT_F_EMPTY_PATH | MOVE_MOUNT_T_MNTNS,
+ )
+ finally:
+ os.close(mfd)
+
+ def bind_mount(self, host_src: str, target: str) -> None:
+ mfd = open_tree(
+ AT_FDCWD,
+ host_src,
+ OPEN_TREE_CLONE | AT_RECURSIVE | OPEN_TREE_CLOEXEC,
+ )
+ try:
+ move_mount(
+ mfd,
+ "",
+ self.mntns_fd,
+ target.lstrip("/"),
+ MOVE_MOUNT_F_EMPTY_PATH | MOVE_MOUNT_T_MNTNS,
+ )
+ finally:
+ os.close(mfd)
+
+ 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 = openat2(
+ self.root_dfd,
+ argv[0],
+ os.O_RDONLY | os.O_CLOEXEC,
+ resolve=RESOLVE_IN_ROOT,
+ )
+ try:
+ pid, _ = clone_into_rootns(
+ self.cfd, extra_flags=CLONE_AUTOREAP, exit_signal=0
+ )
+ if pid == 0:
+ try:
+ os.close(self.cfd)
+ os.close(self.mntns_fd)
+ if self.root_dfd >= 0:
+ os.close(self.root_dfd)
+ if bin_fd >= 0:
+ execveat(bin_fd, "", argv, env, AT_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:
+ if bin_fd >= 0:
+ os.close(bin_fd)
+
+ def kill(self, sig: int = int(signal.SIGTERM)) -> None:
+ rootns_kill(self.cfd, sig)
+
+ def wait(self, nohang: bool = False) -> WaitResult:
+ res = rootns_wait(self.cfd, os.WNOHANG if nohang else 0)
+ if res.pid > 0:
+ self.exit_status = res.status
+ return res
+
+ @property
+ def status_str(self) -> str:
+ if self.init_pid is None:
+ return "created"
+ if self.exit_status is None:
+ return "running"
+ return "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.status_str,
+ init_pid=self.init_pid,
+ exit_code=code,
+ )
+
+ def close(self) -> None:
+ for attr in ("root_dfd", "mntns_fd", "cfd"):
+ fd: int = getattr(self, attr, -1)
+ if fd >= 0:
+ try:
+ os.close(fd)
+ except OSError:
+ pass
+ setattr(self, attr, -1)
+
+
+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
+ if os.path.exists(sock_path):
+ 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 _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:
+ try:
+ res = cell.wait(nohang=True)
+ if res.pid > 0:
+ try:
+ self.sel.unregister(cell.cfd)
+ except KeyError:
+ pass
+ except OSError:
+ pass
+ self._reap_children()
+
+ def _on_accept(self) -> None:
+ conn, _ = self.srv.accept()
+ with conn:
+ data = b""
+ while not data.endswith(b"\n"):
+ chunk = conn.recv(4096)
+ if not chunk:
+ break
+ data += chunk
+ if not data:
+ return
+ try:
+ req: dict[str, Any] = json.loads(data.decode("utf-8"))
+ 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),
+ }
+ conn.sendall((json.dumps(resp) + "\n").encode("utf-8"))
+
+ def _dispatch(self, req: Mapping[str, Any]) -> Any:
+ op = str(req["op"])
+ if op == "ping":
+ return "pong"
+ if op == "shutdown":
+ self.running = False
+ return "bye"
+ if op == "list":
+ self._reap_children()
+ return [asdict(c.info()) for c in self.cells.values()]
+
+ name = str(req["name"])
+ if op == "create":
+ if name in self.cells:
+ raise OSError(errno.EEXIST, f"cell {name} already exists")
+ cell = Cell(name)
+ try:
+ host_runtime = req.get("mode", "host") == "host"
+ cell.setup_rootfs(
+ mount_procfs=bool(req.get("proc", True)),
+ host_runtime=host_runtime,
+ )
+ except Exception:
+ cell.close()
+ raise
+ self.cells[name] = cell
+ self.sel.register(
+ cell.cfd,
+ selectors.EVENT_READ,
+ lambda c=cell: self._on_cell_event(c),
+ )
+ return asdict(cell.info())
+
+ cell_opt = self.cells.get(name)
+ if cell_opt is None:
+ raise OSError(errno.ENOENT, f"unknown cell {name}")
+ cell = cell_opt
+
+ if op in ("start", "exec"):
+ pid = cell.spawn(
+ list(req["argv"]),
+ resolve_in_root=bool(req.get("resolve_in_root", True)),
+ )
+ return asdict(SpawnInfo(pid=pid, state=cell.status_str))
+ if op == "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 == "kill":
+ cell.kill(int(req.get("sig", int(signal.SIGTERM))))
+ return name
+ if op == "wait":
+ res = cell.wait(nohang=bool(req.get("nohang", False)))
+ self._reap_children()
+ return asdict(res)
+ if op == "destroy":
+ try:
+ self.sel.unregister(cell.cfd)
+ except KeyError:
+ pass
+ 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()):
+ try:
+ self.sel.unregister(cell.cfd)
+ except KeyError:
+ pass
+ cell.close()
+ self.cells.clear()
+ try:
+ self.sel.unregister(self.srv)
+ except KeyError:
+ pass
+ self.srv.close()
+ self.sel.close()
+ if os.path.exists(self.sock_path):
+ os.unlink(self.sock_path)
+ self._reap_children()
+
+
+@dataclass(frozen=True)
+class CellClient:
+ sock_path: str
+
+ def call(self, **req: Any) -> Any:
+ with socket.socket(
+ socket.AF_UNIX, socket.SOCK_STREAM | socket.SOCK_CLOEXEC
+ ) as s:
+ s.connect(self.sock_path)
+ s.sendall((json.dumps(req) + "\n").encode("utf-8"))
+ data = b""
+ while not data.endswith(b"\n"):
+ chunk = s.recv(4096)
+ if not chunk:
+ break
+ data += chunk
+ resp: dict[str, Any] = json.loads(data.decode("utf-8"))
+ 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"]
+
+ def ping(self) -> str:
+ return str(self.call(op="ping"))
+
+ def shutdown(self) -> str:
+ return str(self.call(op="shutdown"))
+
+ def list_cells(self) -> list[CellInfo]:
+ items: list[dict[str, Any]] = self.call(op="list")
+ return [CellInfo(**item) for item in items]
+
+ def create(
+ self, name: str, mode: str = "host", proc: bool = True
+ ) -> CellInfo:
+ data: dict[str, Any] = self.call(
+ op="create", name=name, mode=mode, proc=proc
+ )
+ return CellInfo(**data)
+
+ def start(
+ self,
+ name: str,
+ argv: Sequence[str],
+ resolve_in_root: bool = True,
+ ) -> SpawnInfo:
+ data: dict[str, Any] = self.call(
+ op="start",
+ name=name,
+ argv=list(argv),
+ resolve_in_root=resolve_in_root,
+ )
+ return SpawnInfo(**data)
+
+ def exec_cmd(
+ self,
+ name: str,
+ argv: Sequence[str],
+ resolve_in_root: bool = True,
+ ) -> SpawnInfo:
+ data: dict[str, Any] = self.call(
+ op="exec",
+ name=name,
+ argv=list(argv),
+ resolve_in_root=resolve_in_root,
+ )
+ return SpawnInfo(**data)
+
+ def mount(
+ self,
+ name: str,
+ source: str,
+ target: str,
+ bind: bool = False,
+ options: Mapping[str, str | None] | None = None,
+ ) -> str:
+ return str(
+ self.call(
+ op="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: int = int(signal.SIGTERM)) -> str:
+ return str(self.call(op="kill", name=name, sig=sig))
+
+ def wait(self, name: str, nohang: bool = False) -> WaitResult:
+ data: dict[str, Any] = self.call(op="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(op="destroy", name=name))
+
+
+def _cli() -> None:
+ 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", choices=("host", "tmpfs"), default="host")
+
+ for cname in ("start", "exec"):
+ 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")
+
+ args = parser.parse_args()
+ if args.cmd == "daemon":
+ CellService(args.sock).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":
+ print(json.dumps(asdict(client.create(args.name, mode=args.mode))))
+ elif args.cmd in ("start", "exec"):
+ argv = (
+ args.argv[1:]
+ if args.argv and args.argv[0] == "--"
+ else list(args.argv)
+ )
+ fn = client.start if args.cmd == "start" else client.exec_cmd
+ print(json.dumps(asdict(fn(args.name, 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__":
+ _cli()
diff --git a/tools/testing/selftests/rootns/rootns_test.py b/tools/testing/selftests/rootns/rootns_test.py
new file mode 100755
index 000000000000..7594b7a40c0c
--- /dev/null
+++ b/tools/testing/selftests/rootns/rootns_test.py
@@ -0,0 +1,1161 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-2.0
+#
+# Copyright (C) 2026 Opinsys Oy
+
+from __future__ import annotations
+
+import ctypes
+from dataclasses import dataclass
+import errno
+import os
+import select
+import shutil
+import signal
+import socket
+import sys
+import tempfile
+import time
+from typing import Final
+import unittest
+
+import rootns_cells as rc
+
+PYTHON_BIN: Final[str] = os.path.realpath(sys.executable)
+SKIP_EXIT: Final[int] = 77
+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 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 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: int
+
+
+@dataclass(frozen=True)
+class BadCloneCase:
+ name: str
+ flags: int
+ 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", rc.CLONE_NEWNS),
+ NsTypeCase("cgroup", rc.CLONE_NEWCGROUP),
+ NsTypeCase("uts", rc.CLONE_NEWUTS),
+ NsTypeCase("ipc", rc.CLONE_NEWIPC),
+ NsTypeCase("user", rc.CLONE_NEWUSER),
+ NsTypeCase("net", rc.CLONE_NEWNET),
+ NsTypeCase("time", rc.CLONE_NEWTIME),
+)
+
+BAD_CLONE_CASES: Final[tuple[BadCloneCase, ...]] = (
+ BadCloneCase("newns", rc.CLONE_NEWNS),
+ BadCloneCase("newpid", rc.CLONE_NEWPID),
+ BadCloneCase("newuser", rc.CLONE_NEWUSER),
+ BadCloneCase("empty_mntns", rc.CLONE_EMPTY_MNTNS),
+ BadCloneCase("fs", rc.CLONE_FS),
+ BadCloneCase(
+ "thread",
+ rc.CLONE_THREAD | rc.CLONE_SIGHAND | rc.CLONE_VM,
+ exit_signal=0,
+ ),
+ BadCloneCase("parent", rc.CLONE_PARENT, exit_signal=0),
+ BadCloneCase("sysvsem", rc.CLONE_SYSVSEM),
+ BadCloneCase("vm", rc.CLONE_VM),
+ BadCloneCase("vm_vfork", rc.CLONE_VM | rc.CLONE_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),
+)
+
+
+def _pause_forever() -> int:
+ signal.pause()
+ return 0
+
+
+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
+
+
+def _drop_to_uid(uid: int) -> None:
+ try:
+ rc.setgroups_empty()
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ raise
+ os.setresgid(uid, uid, uid)
+ os.setresuid(uid, uid, uid)
+ rc.prctl(rc.PR_SET_DUMPABLE, 1)
+
+
+def _write_ugid_map(pid: int, host_uid: int, host_gid: int) -> None:
+ try:
+ with open(f"/proc/{pid}/setgroups", "wb") as f:
+ f.write(b"deny\n")
+ except OSError:
+ pass
+ with open(f"/proc/{pid}/uid_map", "wb") as f:
+ f.write(f"0 {host_uid} 1\n".encode())
+ with open(f"/proc/{pid}/gid_map", "wb") as f:
+ f.write(f"0 {host_gid} 1\n".encode())
+
+
+def _probe_pre_idmap_mkdir() -> ProbeResult:
+ try:
+ cfd = rc.rootns()
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ return ProbeResult(False, f"rootns() unavailable: {exc}")
+ raise
+ try:
+ try:
+ mfd = rc.make_rootns_mount(cfd, "tmpfs")
+ except OSError as exc:
+ return ProbeResult(False, f"tmpfs mount unavailable: {exc}")
+ try:
+ os.mkdir("probe", 0o755, dir_fd=mfd)
+ return ProbeResult(True)
+ except OSError as exc:
+ if exc.errno == errno.EOVERFLOW:
+ return ProbeResult(
+ False, "pre-idmap submount setup requires mapped userns"
+ )
+ raise
+ finally:
+ os.close(mfd)
+ finally:
+ os.close(cfd)
+
+
+def _send_fd(sock: socket.socket, fd: int) -> None:
+ sock.sendmsg(
+ [b"F"], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, ctypes.c_int(fd))]
+ )
+
+
+def _recv_fd(sock: socket.socket) -> int:
+ _, ancdata, _, _ = sock.recvmsg(
+ 1, socket.CMSG_SPACE(ctypes.sizeof(ctypes.c_int))
+ )
+ for cmsg_lvl, cmsg_type, cmsg_data in ancdata:
+ if cmsg_lvl == socket.SOL_SOCKET and cmsg_type == socket.SCM_RIGHTS:
+ buf = cmsg_data[: ctypes.sizeof(ctypes.c_int)]
+ return int(ctypes.c_int.from_buffer_copy(buf).value)
+ raise RuntimeError("missing SCM_RIGHTS fd")
+
+
+def _create_rootns_as_uid(uid: int) -> tuple[int, int]:
+ s_parent, s_child = socket.socketpair(socket.AF_UNIX, socket.SOCK_DGRAM)
+ pid = os.fork()
+ if pid == 0:
+ s_parent.close()
+ try:
+ _drop_to_uid(uid)
+ cfd = rc.rootns()
+ _send_fd(s_child, cfd)
+ os.close(cfd)
+ os._exit(0)
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ os._exit(SKIP_EXIT)
+ os._exit(1)
+ finally:
+ s_child.close()
+ s_child.close()
+ try:
+ rlist, _, _ = select.select([s_parent], [], [], 5.0)
+ cfd = _recv_fd(s_parent) if rlist else -1
+ finally:
+ s_parent.close()
+ code = _reap_exit_code(pid)
+ return code, cfd
+
+
+class CellServiceTest(unittest.TestCase):
+ tmpdir: str
+ sock_path: str
+ daemon_pid: int
+ client: rc.CellClient
+
+ def setUp(self) -> None:
+ probe = _probe_pre_idmap_mkdir()
+ if not probe.supported:
+ self.skipTest(probe.reason)
+ self.tmpdir = tempfile.mkdtemp(prefix="rootns-cells-")
+ self.sock_path = os.path.join(self.tmpdir, "cells.sock")
+ self.daemon_pid = os.fork()
+ if self.daemon_pid == 0:
+ try:
+ rc.CellService(self.sock_path).serve_forever()
+ os._exit(0)
+ except BaseException:
+ os._exit(1)
+ self.client = rc.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")
+
+ 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)
+ _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="host")
+ self.assertEqual(info.state, "created")
+ self.assertEqual(
+ self.client.list_cells(),
+ [rc.CellInfo(name="alpha", state="created")],
+ )
+
+ started = self.client.start("alpha", WAIT_MOUNT_PAYLOAD.argv())
+ self.assertEqual(started.state, "running")
+
+ self.client.mount("alpha", "tmpfs", "/mnt")
+ self.client.exec_cmd("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="host")
+ self.client.start("killme", PAUSE_PAYLOAD.argv())
+ self.client.exec_cmd("killme", PAUSE_PAYLOAD.argv())
+
+ self.client.kill("killme", int(signal.SIGKILL))
+ res = self.client.wait("killme")
+ self.assertEqual(res.exit_code, -int(signal.SIGKILL))
+ self.client.destroy("killme")
+
+
+class RootnsUapiTest(unittest.TestCase):
+ probe: ProbeResult
+ cell: rc.Cell | None
+
+ def setUp(self) -> None:
+ self.probe = _probe_pre_idmap_mkdir()
+ self.cell = None
+ if self.probe.supported:
+ self.cell = rc.Cell("test")
+ self.cell.setup_rootfs(
+ dirs=("proc", "tmp", "mnt"), mount_procfs=True
+ )
+
+ def tearDown(self) -> None:
+ if self.cell is not None:
+ self.cell.close()
+
+ def _require_cell(self) -> rc.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 self.assertRaises(OSError) as cm:
+ rc.rootns((~rc.ROOTNS_ALL_FLAGS) & 0xFFFFFFFF)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ def test_get_nsfd(self) -> None:
+ try:
+ cfd = rc.rootns()
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ self.skipTest(f"rootns() unavailable: {exc}")
+ raise
+ try:
+ for case in NS_TYPE_CASES:
+ with self.subTest(ns=case.name):
+ nsfd = rc.rootns_get_nsfd(cfd, case.nstype)
+ try:
+ self.assertEqual(
+ rc.raw_ioctl(nsfd, rc.NS_GET_NSTYPE), case.nstype
+ )
+ finally:
+ os.close(nsfd)
+
+ with self.assertRaises(OSError) as cm:
+ rc.rootns_get_nsfd(cfd, rc.CLONE_NEWPID)
+ self.assertEqual(cm.exception.errno, errno.ESRCH)
+
+ with self.assertRaises(OSError) as cm:
+ rc.rootns_get_nsfd(cfd, 0)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ mntns_fd = rc.rootns_get_nsfd(cfd, rc.CLONE_NEWNS)
+ rootfd = rc.make_rootns_mount(cfd, "tmpfs")
+ rc.move_mount(
+ rootfd,
+ "",
+ mntns_fd,
+ "/",
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ os.close(rootfd)
+ os.close(mntns_fd)
+
+ hold = SyncPipe.create()
+ pid = rc.run_in_rootns(cfd, hold.wait_in_child)
+ hold.close_read()
+ try:
+ nsfd = rc.rootns_get_nsfd(cfd, rc.CLONE_NEWPID)
+ try:
+ self.assertEqual(
+ rc.raw_ioctl(nsfd, rc.NS_GET_NSTYPE), rc.CLONE_NEWPID
+ )
+ finally:
+ os.close(nsfd)
+ finally:
+ hold.close_write()
+ self.assertEqual(_reap_exit_code(pid), 0)
+ finally:
+ os.close(cfd)
+
+ def test_wait_poll_and_clone_dead(self) -> None:
+ cell = self._require_cell()
+ cfd = cell.cfd
+
+ with self.assertRaises(OSError) as cm:
+ rc.raw_ioctl(cfd, rc.ROOTNS_WAIT, 0)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ rc.rootns_wait(cfd, (~os.WNOHANG) & 0xFFFFFFFF)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ for wait_flags in (0, os.WNOHANG):
+ with self.assertRaises(OSError) as cm:
+ rc.rootns_wait(cfd, wait_flags)
+ self.assertEqual(cm.exception.errno, errno.ECHILD)
+
+ hold = SyncPipe.create()
+ pid = rc.run_in_rootns(cfd, lambda: hold.wait_in_child(42))
+ hold.close_read()
+
+ self.assertEqual(
+ rc.rootns_wait(cfd, os.WNOHANG), rc.WaitResult(0, 0)
+ )
+ poller = select.poll()
+ poller.register(cfd, select.POLLIN)
+ self.assertEqual(poller.poll(0), [])
+
+ hold.close_write()
+ events = poller.poll(5000)
+ self.assertTrue(any(ev & select.POLLHUP for _, ev in events))
+
+ res = rc.rootns_wait(cfd, os.WNOHANG)
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.exit_code, 42)
+ self.assertEqual(_reap_exit_code(pid), 42)
+
+ with self.assertRaises(OSError) as cm:
+ rc.clone_into_rootns(cfd)
+ self.assertEqual(cm.exception.errno, errno.ESRCH)
+
+ def test_kill_ioctl_and_kill_on_close(self) -> None:
+ cell = self._require_cell()
+ cfd = cell.cfd
+
+ for case in BAD_SIGNAL_CASES:
+ with self.subTest(sig=case.name):
+ with self.assertRaises(OSError) as cm:
+ rc.rootns_kill(cfd, case.sig)
+ self.assertEqual(cm.exception.errno, case.expected_errno)
+
+ ready = SyncPipe.create()
+ hold = SyncPipe.create()
+
+ 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 = rc.run_in_rootns(cfd, init_proc)
+ pid2 = rc.run_in_rootns(cfd, member_proc)
+ ready.close_write()
+ hold.close_write()
+
+ self.assertEqual(ready.read_bytes(), b"r")
+ ready.close_read()
+
+ rc.rootns_kill(cfd, 0)
+ rc.rootns_kill(cfd, int(signal.SIGKILL))
+ self.assertEqual(hold.read_bytes(), b"")
+ hold.close_read()
+
+ self.assertEqual(_reap_exit_code(pid2), 128 + int(signal.SIGKILL))
+ self.assertEqual(_reap_exit_code(pid1), 128 + int(signal.SIGKILL))
+
+ with rc.Cell(
+ "koc", flags=rc.ROOTNS_KILL_ON_CLOSE | rc.ROOTNS_CLOSE_ON_EXEC
+ ) as cell2:
+ cell2.setup_rootfs(mount_procfs=False)
+ pid_koc = rc.run_in_rootns(cell2.cfd, _pause_forever)
+ self.assertEqual(_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")
+ rc.unshare(rc.CLONE_NEWUTS | rc.CLONE_NEWIPC | rc.CLONE_NEWNET)
+ return 0
+
+ pid = rc.run_in_rootns(cell.cfd, inside)
+ res = cell.wait()
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.exit_code, 0)
+ self.assertEqual(_reap_exit_code(pid), 0)
+
+ def test_setns_owner_vs_foreign(self) -> None:
+ cell = self._require_cell()
+ hold = SyncPipe.create()
+ pid = rc.run_in_rootns(cell.cfd, hold.wait_in_child)
+ hold.close_read()
+ try:
+ uts_fd = os.open(
+ f"/proc/{pid}/ns/uts", os.O_RDONLY | os.O_CLOEXEC
+ )
+ try:
+ w1 = os.fork()
+ if w1 == 0:
+ try:
+ rc.setns(uts_fd, rc.CLONE_NEWUTS)
+ os._exit(0)
+ except BaseException:
+ os._exit(1)
+ self.assertEqual(_reap_exit_code(w1), 0)
+
+ if os.geteuid() == 0:
+ w2 = os.fork()
+ if w2 == 0:
+ try:
+ _drop_to_uid(1000)
+ except OSError:
+ os._exit(0)
+ try:
+ rc.setns(uts_fd, rc.CLONE_NEWUTS)
+ os._exit(2)
+ except OSError as exc:
+ os._exit(0 if exc.errno == errno.EPERM else 3)
+ self.assertEqual(_reap_exit_code(w2), 0)
+ finally:
+ os.close(uts_fd)
+ finally:
+ hold.close_write()
+ _reap_exit_code(pid)
+
+ def test_mount_and_fsconfig_validation(self) -> None:
+ self._require_cell()
+ cfd = rc.rootns()
+ mntns_fd = rc.rootns_get_nsfd(cfd, rc.CLONE_NEWNS)
+ try:
+ with self.assertRaises(OSError) as cm:
+ rc.move_mount(
+ rc.AT_FDCWD, "/", mntns_fd, "/", rc.MOVE_MOUNT_T_MNTNS
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ m1 = rc.make_rootns_mount(cfd, "tmpfs")
+ try:
+ rc.move_mount(
+ m1,
+ "",
+ mntns_fd,
+ "/",
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ finally:
+ os.close(m1)
+
+ m2 = rc.make_rootns_mount(cfd, "tmpfs")
+ try:
+ for alias in ("/", "."):
+ with self.assertRaises(OSError) as cm:
+ rc.move_mount(
+ m2,
+ "",
+ mntns_fd,
+ alias,
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+ with self.assertRaises(OSError) as cm:
+ rc.move_mount(
+ m2,
+ "",
+ mntns_fd,
+ ".",
+ rc.MOVE_MOUNT_F_EMPTY_PATH
+ | rc.MOVE_MOUNT_T_MNTNS
+ | rc.MOVE_MOUNT_BENEATH,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+ finally:
+ os.close(m2)
+
+ fsfd = rc.fsopen("tmpfs")
+ try:
+ rc.fsconfig(fsfd, rc.FSCONFIG_SET_ROOTNS, aux=cfd)
+ with self.assertRaises(OSError) as cm:
+ rc.fsconfig(fsfd, rc.FSCONFIG_SET_ROOTNS, aux=cfd)
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+ finally:
+ os.close(fsfd)
+
+ bad_proc = rc.fsopen("proc")
+ try:
+ w_nonanc = os.fork()
+ if w_nonanc == 0:
+ try:
+ rc.unshare(rc.CLONE_NEWPID)
+ inner = os.fork()
+ if inner == 0:
+ try:
+ rc.fsconfig(
+ bad_proc, rc.FSCONFIG_SET_ROOTNS, aux=cfd
+ )
+ os._exit(1)
+ except OSError as exc:
+ if exc.errno != errno.EINVAL:
+ os._exit(2)
+ try:
+ rc.fsconfig(bad_proc, rc.FSCONFIG_CMD_CREATE)
+ os._exit(3)
+ except OSError as exc:
+ os._exit(0 if exc.errno == errno.EBUSY else 4)
+ os._exit(_reap_exit_code(inner))
+ except BaseException:
+ os._exit(5)
+ self.assertEqual(_reap_exit_code(w_nonanc), 0)
+ finally:
+ os.close(bad_proc)
+
+ cfd_lock = rc.rootns()
+ lock_mntns = rc.rootns_get_nsfd(cfd_lock, rc.CLONE_NEWNS)
+ try:
+ rfd = rc.make_rootns_mount(cfd_lock, "tmpfs")
+ os.mkdir("host_sub", 0o755, dir_fd=rfd)
+ sfd = rc.open_tree(
+ rc.AT_FDCWD,
+ "/tmp",
+ rc.OPEN_TREE_CLONE
+ | rc.AT_RECURSIVE
+ | rc.OPEN_TREE_CLOEXEC,
+ )
+ rc.move_mount(
+ sfd, "", rfd, "host_sub", rc.MOVE_MOUNT_F_EMPTY_PATH
+ )
+ os.close(sfd)
+ rc.move_mount(
+ rfd,
+ "",
+ lock_mntns,
+ "/",
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ os.close(rfd)
+
+ def try_umount_locked() -> int:
+ try:
+ rc.umount2("/host_sub", rc.MNT_DETACH)
+ return 1
+ except OSError as exc:
+ return 0 if exc.errno == errno.EINVAL else 2
+
+ p_lock = rc.run_in_rootns(cfd_lock, try_umount_locked)
+ self.assertEqual(_reap_exit_code(p_lock), 0)
+ finally:
+ os.close(lock_mntns)
+ os.close(cfd_lock)
+
+ if os.geteuid() == 0:
+ code, u_cfd = _create_rootns_as_uid(1000)
+ if code == 0 and u_cfd >= 0:
+ try:
+ u_mntns = rc.rootns_get_nsfd(u_cfd, rc.CLONE_NEWNS)
+ m_root = rc.make_rootns_mount(u_cfd, "tmpfs")
+ rc.move_mount(
+ m_root,
+ "",
+ u_mntns,
+ "/",
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ os.close(m_root)
+
+ attacker = os.fork()
+ if attacker == 0:
+ try:
+ _drop_to_uid(2000)
+ except OSError:
+ os._exit(0)
+ fsfd2 = rc.fsopen("tmpfs")
+ try:
+ rc.fsconfig(
+ fsfd2, rc.FSCONFIG_SET_ROOTNS, aux=u_cfd
+ )
+ os._exit(1)
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ os._exit(2)
+ finally:
+ os.close(fsfd2)
+ try:
+ rc.clone_into_rootns(u_cfd)
+ os._exit(3)
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ os._exit(4)
+ os._exit(0)
+ self.assertEqual(_reap_exit_code(attacker), 0)
+ os.close(u_mntns)
+ finally:
+ os.close(u_cfd)
+ finally:
+ os.close(mntns_fd)
+ os.close(cfd)
+
+ def test_clone_flags_and_pidns_ancestry(self) -> None:
+ cell = self._require_cell()
+ cfd = cell.cfd
+
+ empty_cfd = rc.rootns()
+ try:
+ with self.assertRaises(OSError) as cm:
+ rc.clone_into_rootns(empty_cfd, rc.CLONE_VFORK)
+ self.assertEqual(cm.exception.errno, errno.ENOENT)
+ finally:
+ os.close(empty_cfd)
+
+ args = rc.CloneArgs(
+ flags=rc.CLONE_INTO_ROOTNS,
+ exit_signal=int(signal.SIGCHLD),
+ rootns=cfd,
+ )
+ with self.assertRaises(OSError) as cm:
+ rc.clone3_raw(args, size=rc.CLONE_ARGS_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:
+ rc.clone_into_rootns(
+ cfd,
+ extra_flags=case.flags,
+ exit_signal=case.exit_signal,
+ )
+ self.assertEqual(cm.exception.errno, case.expected_errno)
+
+ allowed = (
+ rc.CLONE_VFORK
+ | rc.CLONE_PIDFD
+ | rc.CLONE_CLEAR_SIGHAND
+ | rc.CLONE_NNP
+ )
+ old_umask = os.umask(0o077)
+ try:
+ rc.prctl(rc.PR_SET_DUMPABLE, 1)
+ pid, pidfd = rc.clone_into_rootns(cfd, extra_flags=allowed)
+ if pid == 0:
+ cur_umask = os.umask(0o022)
+ dumpable = rc.prctl(rc.PR_GET_DUMPABLE)
+ ok = (
+ os.getpid() == 1
+ and rc.prctl(rc.PR_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(_reap_exit_code(pid), 0)
+
+ with rc.Cell("exdev") as cell2:
+ cell2.setup_rootfs(mount_procfs=False)
+ w = os.fork()
+ if w == 0:
+ try:
+ rc.unshare(rc.CLONE_NEWPID)
+ inner = os.fork()
+ if inner == 0:
+ try:
+ rc.clone_into_rootns(cell2.cfd)
+ os._exit(1)
+ except OSError as exc:
+ os._exit(0 if exc.errno == errno.EXDEV else 2)
+ os._exit(_reap_exit_code(inner))
+ except BaseException:
+ os._exit(3)
+ self.assertEqual(_reap_exit_code(w), 0)
+
+ def test_concurrent_bootstrap(self) -> None:
+ cell = self._require_cell()
+ cfd = cell.cfd
+ start = SyncPipe.create()
+ ready = SyncPipe.create()
+ init_gate = SyncPipe.create()
+ peer_gate = SyncPipe.create()
+
+ 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 = rc.run_in_rootns(cfd, entrant)
+ ready.close_write()
+ init_gate.close_read()
+ peer_gate.close_read()
+ os._exit(0 if _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(_reap_exit_code(wpid), 0)
+ init_gate.close_write()
+ self.assertEqual(_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()
+ go = SyncPipe.create()
+ ready = SyncPipe.create()
+ hold = SyncPipe.create()
+
+ def init_pivot() -> int:
+ go.close_write()
+ ready.close_read()
+ hold.close_write()
+ if go.read_bytes() != b"g":
+ return 1
+ go.close_read()
+ tfd = rc.fsopen("tmpfs")
+ rc.fsconfig(tfd, rc.FSCONFIG_CMD_CREATE)
+ mfd = rc.fsmount(tfd)
+ os.close(tfd)
+ os.mkdir("old_root", 0o755, dir_fd=mfd)
+ os.mkdir("sub", 0o755, dir_fd=mfd)
+ pfd = os.open(
+ "pivoted",
+ os.O_CREAT | os.O_WRONLY | os.O_CLOEXEC,
+ 0o644,
+ dir_fd=mfd,
+ )
+ os.close(pfd)
+ rc.move_mount(
+ mfd, "", rc.AT_FDCWD, "/mnt", rc.MOVE_MOUNT_F_EMPTY_PATH
+ )
+ os.close(mfd)
+ os.chdir("/mnt")
+ rc.pivot_root(".", "old_root")
+ os.chdir("/")
+ rc.umount2("/old_root", rc.MNT_DETACH)
+ ready.write_bytes(b"p")
+ ready.close_write()
+ hold.read_bytes()
+ hold.close_read()
+ return 0
+
+ pid1 = rc.run_in_rootns(cell.cfd, init_pivot)
+ go.close_read()
+ ready.close_write()
+ hold.close_read()
+ try:
+ _write_ugid_map(pid1, os.geteuid(), os.getegid())
+ go.write_bytes(b"g")
+ go.close_write()
+
+ self.assertEqual(ready.read_bytes(), b"p")
+ ready.close_read()
+
+ cell.mount_fs("tmpfs", "sub")
+
+ pid2 = rc.run_in_rootns(
+ cell.cfd,
+ lambda: (
+ 0
+ if os.path.exists("/pivoted") and os.path.ismount("/sub")
+ else 1
+ ),
+ )
+ self.assertEqual(_reap_exit_code(pid2), 0)
+ finally:
+ hold.close_write()
+ self.assertEqual(_reap_exit_code(pid1), 0)
+
+ ext_ready = SyncPipe.create()
+ ext_hold = SyncPipe.create()
+ plain_pid = os.fork()
+ if plain_pid == 0:
+ ext_ready.close_read()
+ ext_hold.close_write()
+ try:
+ rc.unshare(rc.CLONE_NEWNS)
+ rc.make_mount_private("/")
+ tfd = rc.fsopen("tmpfs")
+ rc.fsconfig(tfd, rc.FSCONFIG_CMD_CREATE)
+ mfd = rc.fsmount(tfd)
+ os.close(tfd)
+ rc.move_mount(
+ mfd, "", rc.AT_FDCWD, "/tmp", rc.MOVE_MOUNT_F_EMPTY_PATH
+ )
+ os.close(mfd)
+ 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()
+ ext_mntns = os.open(
+ f"/proc/{plain_pid}/ns/mnt", os.O_RDONLY | os.O_CLOEXEC
+ )
+ try:
+ tfd = rc.fsopen("tmpfs")
+ rc.fsconfig(tfd, rc.FSCONFIG_CMD_CREATE)
+ mfd = rc.fsmount(tfd)
+ os.close(tfd)
+ with self.assertRaises(OSError) as cm:
+ rc.move_mount(
+ mfd,
+ "",
+ ext_mntns,
+ "tmp/..",
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+ with self.assertRaises(OSError) as cm:
+ rc.move_mount(
+ mfd,
+ "",
+ ext_mntns,
+ "tmp/..",
+ rc.MOVE_MOUNT_F_EMPTY_PATH
+ | rc.MOVE_MOUNT_T_MNTNS
+ | rc.MOVE_MOUNT_BENEATH,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+ rc.move_mount(
+ mfd,
+ "",
+ ext_mntns,
+ "tmp/target",
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ os.close(mfd)
+ finally:
+ os.close(ext_mntns)
+ finally:
+ ext_hold.close_write()
+ self.assertEqual(_reap_exit_code(plain_pid), 0)
+
+ def test_unprivileged_without_entering_userns(self) -> None:
+ worker = os.fork()
+ if worker == 0:
+ try:
+ if os.geteuid() == 0:
+ try:
+ _drop_to_uid(1000)
+ except OSError as exc:
+ if exc.errno == errno.EINVAL:
+ os._exit(SKIP_EXIT)
+ os._exit(1)
+
+ try:
+ tfd = rc.fsopen("tmpfs")
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ os._exit(2)
+ else:
+ try:
+ rc.fsconfig(tfd, rc.FSCONFIG_CMD_CREATE)
+ os._exit(3)
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ os._exit(4)
+ finally:
+ os.close(tfd)
+
+ try:
+ cfd = rc.rootns()
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ os._exit(SKIP_EXIT)
+ os._exit(5)
+
+ mntns_fd = rc.rootns_get_nsfd(cfd, rc.CLONE_NEWNS)
+ rootfd = rc.make_rootns_mount(cfd, "tmpfs")
+ rc.move_mount(
+ rootfd,
+ "",
+ mntns_fd,
+ "/",
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ os.close(rootfd)
+
+ go = SyncPipe.create()
+ ack = SyncPipe.create()
+
+ def unpriv_init() -> int:
+ go.close_write()
+ ack.close_read()
+ rc.prctl(rc.PR_SET_DUMPABLE, 1)
+ ack.write_bytes(b"d")
+ if go.read_bytes() != b"1":
+ return 1
+ os.mkdir("/proc", 0o755)
+ ack.write_bytes(b"m")
+ ack.close_write()
+ if go.read_bytes() != b"2":
+ return 2
+ go.close_read()
+ pids = [e for e in os.listdir("/proc") if e.isdigit()]
+ return 0 if pids == ["1"] else 3
+
+ pid = rc.run_in_rootns(cfd, unpriv_init)
+ go.close_read()
+ ack.close_write()
+
+ if ack.read_bytes() != b"d":
+ os._exit(6)
+ _write_ugid_map(pid, os.geteuid(), os.getegid())
+ go.write_bytes(b"1")
+ if ack.read_bytes() != b"m":
+ os._exit(6)
+ ack.close_read()
+
+ pfd = rc.make_rootns_mount(cfd, "proc")
+ rc.move_mount(
+ pfd,
+ "",
+ mntns_fd,
+ "proc",
+ rc.MOVE_MOUNT_F_EMPTY_PATH | rc.MOVE_MOUNT_T_MNTNS,
+ )
+ os.close(pfd)
+ os.close(mntns_fd)
+
+ go.write_bytes(b"2")
+ go.close_write()
+
+ res = rc.rootns_wait(cfd)
+ os.close(cfd)
+ if res.pid != pid or res.exit_code != 0:
+ os._exit(7)
+ if _reap_exit_code(pid) != 0:
+ os._exit(8)
+ os._exit(0)
+ except BaseException:
+ os._exit(9)
+
+ code = _reap_exit_code(worker)
+ if code == SKIP_EXIT:
+ self.skipTest("unprivileged rootns unavailable")
+ self.assertEqual(code, 0)
+
+
+if __name__ == "__main__":
+ unittest.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..2cb23ca2ad29
--- /dev/null
+++ b/tools/testing/selftests/rootns/test_smoke.sh
@@ -0,0 +1,11 @@
+#!/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")")"
+PYTHONPATH="$DIR${PYTHONPATH:+:$PYTHONPATH}" \
+ python3 -m unittest -v rootns_test 2>&1
--
2.47.3
next prev parent reply other threads:[~2026-11-19 22:44 UTC|newest]
Thread overview: 15+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-19 22:42 [RFC PATCH v4 00/14] Namespace for namespace roots Jarkko Sakkinen
2026-11-19 22:42 ` [RFC PATCH v4 01/14] nsproxy: Pass nsproxy to create_new_namespaces() Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 02/14] rootns: Add core infrastructure for root namespaces Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 03/14] rootns: Track init lifecycle via copy_process() and pid_namespace Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 04/14] rootns: Add rootns() system call Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 05/14] rootns: Add ROOTNS_WAIT ioctl Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 06/14] rootns: Add ROOTNS_KILL ioctl Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 07/14] fork: Support CLONE_INTO_ROOTNS in clone3() Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 08/14] fs: Support FSCONFIG_SET_ROOTNS in fsconfig() Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 09/14] fs: Support MOVE_MOUNT_T_MNTNS in move_mount() Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 10/14] security: Add rootns LSM hooks Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 11/14] arch: Wire up rootns() system call Jarkko Sakkinen
2026-11-19 22:43 ` [RFC PATCH v4 12/14] docs: Document root namespace uAPI Jarkko Sakkinen
2026-11-19 22:43 ` Jarkko Sakkinen [this message]
2026-11-19 22:43 ` [RFC PATCH v4 14/14] 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=20261119224312.1037966-14-jarkko@kernel.org \
--to=jarkko@kernel.org \
--cc=James.Bottomley@HansenPartnership.com \
--cc=agordeev@linux.ibm.com \
--cc=akpm@linux-foundation.org \
--cc=alex@ghiti.fr \
--cc=andreas@gaisler.com \
--cc=anna-maria@linutronix.de \
--cc=aou@eecs.berkeley.edu \
--cc=arnd@arndb.de \
--cc=borntraeger@linux.ibm.com \
--cc=bp@alien8.de \
--cc=brauner@kernel.org \
--cc=bsegall@google.com \
--cc=casey@schaufler-ca.com \
--cc=catalin.marinas@arm.com \
--cc=chleroy@kernel.org \
--cc=chris@zankel.net \
--cc=corbet@lwn.net \
--cc=dalias@libc.org \
--cc=dave.hansen@linux.intel.com \
--cc=dave@stgolabs.net \
--cc=davem@davemloft.net \
--cc=david@kernel.org \
--cc=deller@gmx.de \
--cc=dhowells@redhat.com \
--cc=dietmar.eggemann@arm.com \
--cc=frederic@kernel.org \
--cc=geert@linux-m68k.org \
--cc=glaubitz@physik.fu-berlin.de \
--cc=gor@linux.ibm.com \
--cc=halg@google.com \
--cc=hca@linux.ibm.com \
--cc=hpa@zytor.com \
--cc=jack@suse.cz \
--cc=jcmvbkbc@gmail.com \
--cc=john.johansen@canonical.com \
--cc=josef@toxicpanda.com \
--cc=juri.lelli@redhat.com \
--cc=kees@kernel.org \
--cc=kprateek.nayak@amd.com \
--cc=liam@infradead.org \
--cc=linmag7@gmail.com \
--cc=linux-api@vger.kernel.org \
--cc=linux-arch@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=linux@armlinux.org.uk \
--cc=ljs@kernel.org \
--cc=luto@amacapital.net \
--cc=luto@kernel.org \
--cc=maddy@linux.ibm.com \
--cc=manfred@colorfullife.com \
--cc=mark.rutland@arm.com \
--cc=mattst88@gmail.com \
--cc=mgorman@suse.de \
--cc=mhocko@suse.com \
--cc=mingo@redhat.com \
--cc=monstr@monstr.eu \
--cc=mpe@ellerman.id.au \
--cc=neal@gompa.dev \
--cc=npiggin@gmail.com \
--cc=palmer@dabbelt.com \
--cc=paul@paul-moore.com \
--cc=peterz@infradead.org \
--cc=pjw@kernel.org \
--cc=ptikhomirov@virtuozzo.com \
--cc=rdunlap@infradead.org \
--cc=richard.henderson@linaro.org \
--cc=ritesh.list@gmail.com \
--cc=rostedt@goodmis.org \
--cc=rppt@kernel.org \
--cc=sergeh@kernel.org \
--cc=skhan@linuxfoundation.org \
--cc=sshegde@linux.ibm.com \
--cc=surenb@google.com \
--cc=svens@linux.ibm.com \
--cc=tglx@kernel.org \
--cc=tsbogend@alpha.franken.de \
--cc=vbabka@kernel.org \
--cc=vincent.guittot@linaro.org \
--cc=vincenzo.frascino@arm.com \
--cc=viro@zeniv.linux.org.uk \
--cc=vschneid@redhat.com \
--cc=will@kernel.org \
--cc=ysato@users.sourceforge.jp \
--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