Linux filesystem development
 help / color / mirror / Atom feed
From: Jarkko Sakkinen <jarkko@kernel.org>
To: linux-fsdevel@vger.kernel.org
Cc: Jarkko Sakkinen <jarkko@kernel.org>,
	linux-api@vger.kernel.org, linux-doc@vger.kernel.org,
	linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org,
	linux-mm@kvack.org, linux-security-module@vger.kernel.org,
	Alexander Mikhalitsyn <alex@amutable.com>,
	Alexander Viro <viro@zeniv.linux.org.uk>,
	Andy Lutomirski <luto@amacapital.net>,
	Christian Brauner <brauner@kernel.org>,
	David Howells <dhowells@redhat.com>, Jan Kara <jack@suse.cz>,
	Jonathan Corbet <corbet@lwn.net>,
	Josef Bacik <josef@toxicpanda.com>, Kees Cook <kees@kernel.org>,
	Neal Gompa <neal@gompa.dev>, Paul Moore <paul@paul-moore.com>,
	Serge Hallyn <sergeh@kernel.org>,
	Zygmunt Krynicki <zygmunt.krynicki@canonical.com>
Subject: [RFC PATCH v5 24/25] selftests/rootns: Add root namespace test suite
Date: Sat, 21 Nov 2026 02:08:43 +0200	[thread overview]
Message-ID: <20261121000844.1863324-25-jarkko@kernel.org> (raw)
In-Reply-To: <20261121000844.1863324-1-jarkko@kernel.org>

Verify the root namespace, mount-namespace configuration, and
userns_set_idmap() uAPI and security invariants across privileged,
unprivileged, SCM_RIGHTS delegation, and edge-case scenarios.

Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 tools/testing/selftests/Makefile              |    1 +
 tools/testing/selftests/rootns/Makefile       |    5 +
 tools/testing/selftests/rootns/config         |   10 +
 .../testing/selftests/rootns/rootns_cells.py  | 1400 ++++++++++++++
 tools/testing/selftests/rootns/rootns_test.py | 1645 +++++++++++++++++
 tools/testing/selftests/rootns/test_smoke.sh  |   10 +
 6 files changed, 3071 insertions(+)
 create mode 100644 tools/testing/selftests/rootns/Makefile
 create mode 100644 tools/testing/selftests/rootns/config
 create mode 100755 tools/testing/selftests/rootns/rootns_cells.py
 create mode 100755 tools/testing/selftests/rootns/rootns_test.py
 create mode 100755 tools/testing/selftests/rootns/test_smoke.sh

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


  parent reply	other threads:[~2026-11-21  0:10 UTC|newest]

Thread overview: 28+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-21  0:08 [RFC PATCH v5 00/25] rootns: fd-bound process closures Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 01/25] userns: Factor out idmap validation and commit helpers Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 02/25] userns: Add userns_set_idmap() system call Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 03/25] arch: Wire up " Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 04/25] mount: Add mnt_ns_get_root() Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 05/25] mount: Enforce mount_too_revealing() for foreign mntns Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 06/25] mount: Support MOVE_MOUNT_T_MNTNS in move_mount() Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 07/25] mount: Support MOVE_MOUNT_CLONE with MOVE_MOUNT_T_MNTNS Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 08/25] userns: Factor out install_user_ns_cred() Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 09/25] nsfs: Add nsproxy_open_namespace() Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 10/25] nsproxy: Pass nsproxy to create_new_namespaces() Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 11/25] rootns: Add core infrastructure for root namespaces Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 12/25] rootns: Track init lifecycle via copy_process() and pid_namespace Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 13/25] rootns: Add rootns() system call Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 14/25] rootns: Add ROOTNS_WAIT ioctl Jarkko Sakkinen
2026-11-21  0:17   ` Jarkko Sakkinen
2026-11-21  0:18     ` Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 15/25] rootns: Add ROOTNS_KILL ioctl Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 16/25] fork: Support CLONE_INTO_ROOTNS in clone3() Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 17/25] fs: Support FSCONFIG_SET_ROOTNS in fsconfig() Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 18/25] proc: Implement ->set_rootns() fs_context operation Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 19/25] ipc/mqueue: " Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 20/25] security: Add rootns LSM hooks Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 21/25] bpf: Register " Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 22/25] arch: Wire up rootns() system call Jarkko Sakkinen
2026-11-21  0:08 ` [RFC PATCH v5 23/25] docs: Document root namespace uAPI Jarkko Sakkinen
2026-11-21  0:08 ` Jarkko Sakkinen [this message]
2026-11-21  0:08 ` [RFC PATCH v5 25/25] MAINTAINERS: Add entry for ROOT NAMESPACE Jarkko Sakkinen

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261121000844.1863324-25-jarkko@kernel.org \
    --to=jarkko@kernel.org \
    --cc=alex@amutable.com \
    --cc=brauner@kernel.org \
    --cc=corbet@lwn.net \
    --cc=dhowells@redhat.com \
    --cc=jack@suse.cz \
    --cc=josef@toxicpanda.com \
    --cc=kees@kernel.org \
    --cc=linux-api@vger.kernel.org \
    --cc=linux-doc@vger.kernel.org \
    --cc=linux-fsdevel@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-kselftest@vger.kernel.org \
    --cc=linux-mm@kvack.org \
    --cc=linux-security-module@vger.kernel.org \
    --cc=luto@amacapital.net \
    --cc=neal@gompa.dev \
    --cc=paul@paul-moore.com \
    --cc=sergeh@kernel.org \
    --cc=viro@zeniv.linux.org.uk \
    --cc=zygmunt.krynicki@canonical.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox