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: 23+ 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-20 13:18 ` Alexander Mikhalitsyn
2026-11-20 13:30 ` Jarkko Sakkinen
2026-11-20 15:24 ` 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-20 10:33 ` Jarkko Sakkinen
2026-11-20 12:47 ` 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
2026-11-20 5:58 ` [RFC PATCH v4 00/14] Namespace for namespace roots Jarkko Sakkinen
2026-11-20 10:10 ` Jarkko Sakkinen
2026-11-20 10:24 ` 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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.