From: Jarkko Sakkinen <jarkko@kernel.org>
To: linux-fsdevel@vger.kernel.org
Cc: Jarkko Sakkinen <jarkko@kernel.org>,
bpf@vger.kernel.org, containers@lists.linux.dev,
linux-api@vger.kernel.org, linux-arch@vger.kernel.org,
linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org,
linux-kselftest@vger.kernel.org, linux-mm@kvack.org,
linux-security-module@vger.kernel.org,
Aleksa Sarai <aleksa@amutable.com>,
Alexander Mikhalitsyn <alex@amutable.com>,
Alexander Viro <viro@zeniv.linux.org.uk>,
Andy Lutomirski <luto@amacapital.net>,
Arnd Bergmann <arnd@arndb.de>,
Christian Brauner <brauner@kernel.org>,
David Howells <dhowells@redhat.com>,
Eric Biggers <ebiggers@kernel.org>,
Giuseppe Scrivano <giuseppe@scrivano.org>,
Hugh Dickins <hughd@google.com>, Jan Kara <jack@suse.cz>,
Jeff Layton <jlayton@kernel.org>,
Jonathan Corbet <corbet@lwn.net>,
Josef Bacik <josef@toxicpanda.com>, Kees Cook <kees@kernel.org>,
KP Singh <kpsingh@kernel.org>,
Lennart Poettering <lennart@poettering.net>,
Neal Gompa <neal@gompa.dev>, Oleg Nesterov <oleg@redhat.com>,
Paul Moore <paul@paul-moore.com>,
Pavel Tikhomirov <ptikhomirov@virtuozzo.com>,
Serge Hallyn <sergeh@kernel.org>,
Shuah Khan <skhan@linuxfoundation.org>,
Zygmunt Krynicki <zygmunt.krynicki@canonical.com>
Subject: [RFC PATCH v7 25/26] selftests/userland: Add userland test suite
Date: Sun, 22 Nov 2026 21:35:38 +0200 [thread overview]
Message-ID: <20261122193539.3334213-26-jarkko@kernel.org> (raw)
In-Reply-To: <20261122193539.3334213-1-jarkko@kernel.org>
Verify the userland_open() control object, namespace sharing,
mount-namespace configuration, waitid(P_USERLAND), pidfd_send_signal(),
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/userland/Makefile | 6 +
tools/testing/selftests/userland/config | 10 +
.../testing/selftests/userland/test_smoke.sh | 10 +
.../selftests/userland/userland_cells.py | 1088 ++++++++
.../selftests/userland/userland_test.py | 2330 +++++++++++++++++
6 files changed, 3445 insertions(+)
create mode 100644 tools/testing/selftests/userland/Makefile
create mode 100644 tools/testing/selftests/userland/config
create mode 100755 tools/testing/selftests/userland/test_smoke.sh
create mode 100644 tools/testing/selftests/userland/userland_cells.py
create mode 100755 tools/testing/selftests/userland/userland_test.py
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 07c3719f8b04..4bf12d0cfd1e 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -145,6 +145,7 @@ TARGETS += tty
TARGETS += ublk
TARGETS += uevent
TARGETS += user_events
+TARGETS += userland
TARGETS += vDSO
TARGETS += mm
TARGETS += vfio
diff --git a/tools/testing/selftests/userland/Makefile b/tools/testing/selftests/userland/Makefile
new file mode 100644
index 000000000000..566ecb6f7f19
--- /dev/null
+++ b/tools/testing/selftests/userland/Makefile
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: GPL-2.0
+include ../lib.mk
+
+TEST_PROGS := test_smoke.sh
+TEST_FILES := userland_cells.py userland_test.py
+TEST_INCLUDES := ../kselftest/ksft.py
diff --git a/tools/testing/selftests/userland/config b/tools/testing/selftests/userland/config
new file mode 100644
index 000000000000..c144ef706856
--- /dev/null
+++ b/tools/testing/selftests/userland/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_TIME_NS=y
+CONFIG_TMPFS=y
+CONFIG_USER_NS=y
+CONFIG_UTS_NS=y
+CONFIG_USERLAND=y
diff --git a/tools/testing/selftests/userland/test_smoke.sh b/tools/testing/selftests/userland/test_smoke.sh
new file mode 100755
index 000000000000..fdd4aaa01804
--- /dev/null
+++ b/tools/testing/selftests/userland/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/userland_test.py" "$@"
diff --git a/tools/testing/selftests/userland/userland_cells.py b/tools/testing/selftests/userland/userland_cells.py
new file mode 100644
index 000000000000..586cb5f09ddf
--- /dev/null
+++ b/tools/testing/selftests/userland/userland_cells.py
@@ -0,0 +1,1088 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Copyright (C) 2026 Opinsys Oy
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import suppress
+import ctypes
+from dataclasses import dataclass, field
+from enum import IntEnum, IntFlag
+import errno
+import os
+import platform
+import signal
+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 UserlandFlag(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_USERLAND = 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 UsernsFlag(IntFlag):
+ NONE = 0
+ SETGROUPS_ALLOWED = 1 << 0
+
+
+class MountAttrFlag(IntFlag):
+ NONE = 0
+ RDONLY = 0x00000001
+ NOSUID = 0x00000002
+ NODEV = 0x00000004
+
+
+class MountFlag(IntFlag):
+ REC = 0x4000
+ PRIVATE = 1 << 18
+ SLAVE = 1 << 19
+ 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_USERLAND = 9
+
+
+class PrctlOp(IntEnum):
+ GET_DUMPABLE = 3
+ SET_DUMPABLE = 4
+ SET_KEEPCAPS = 8
+ GET_NO_NEW_PRIVS = 39
+
+
+class WaitIdType(IntEnum):
+ ALL = 0
+ PID = 1
+ PGID = 2
+ PIDFD = 3
+ USERLAND = 4
+
+
+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
+ userland: 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),
+ ("userland", 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
+
+ nr_uid_extents: int
+ nr_gid_extents: int
+ nr_projid_extents: int
+ reserved: int
+ uid_extents: int
+ gid_extents: int
+ projid_extents: int
+ _fields_ = [
+ ("nr_uid_extents", ctypes.c_uint32),
+ ("nr_gid_extents", ctypes.c_uint32),
+ ("nr_projid_extents", ctypes.c_uint32),
+ ("reserved", ctypes.c_uint32),
+ ("uid_extents", ctypes.c_uint64),
+ ("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_PREFIXES: Final[tuple[str, ...]] = (
+ "alpha",
+ "mips",
+ "powerpc",
+ "ppc",
+ "sparc",
+ )
+
+ @classmethod
+ def _is_wide_ioc_arch(cls) -> bool:
+ return platform.machine().lower().startswith(cls._WIDE_IOC_PREFIXES)
+
+ @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)
+
+ @staticmethod
+ def _build_syscall_numbers() -> dict[str, int]:
+ mach = platform.machine().lower()
+ ptr_size = ctypes.sizeof(ctypes.c_void_p)
+ multiarch = getattr(sys.implementation, "_multiarch", "")
+ arch_legacy: dict[str, int]
+
+ if mach.startswith("alpha"):
+ base = 110
+ arch_legacy = {
+ "pivot_root": 374,
+ "umount2": 22,
+ "waitid": 438,
+ "execveat": 513,
+ }
+ elif mach.startswith("mips"):
+ if ptr_size == 8:
+ base = 5000
+ arch_legacy = {
+ "pivot_root": 5151,
+ "umount2": 5161,
+ "waitid": 5237,
+ "execveat": 5316,
+ }
+ elif "abin32" in multiarch:
+ base = 6000
+ arch_legacy = {
+ "pivot_root": 6151,
+ "umount2": 6161,
+ "waitid": 6241,
+ "execveat": 6320,
+ }
+ else:
+ base = 4000
+ arch_legacy = {
+ "pivot_root": 4216,
+ "umount2": 4052,
+ "waitid": 4278,
+ "execveat": 4356,
+ }
+ elif mach == "x86_64" and ptr_size == 4 and "x32" in multiarch:
+ base = 0x40000000
+ arch_legacy = {
+ "pivot_root": base + 155,
+ "umount2": base + 166,
+ "waitid": base + 529,
+ "execveat": base + 545,
+ }
+ else:
+ base = 0
+ asm_generic = {
+ "pivot_root": 41,
+ "umount2": 39,
+ "waitid": 95,
+ "execveat": 281,
+ }
+ if mach == "x86_64" and ptr_size == 8:
+ arch_legacy = {
+ "pivot_root": 155,
+ "umount2": 166,
+ "waitid": 247,
+ "execveat": 322,
+ }
+ elif mach in ("i386", "i486", "i586", "i686", "x86_64"):
+ arch_legacy = {
+ "pivot_root": 217,
+ "umount2": 52,
+ "waitid": 284,
+ "execveat": 358,
+ }
+ elif mach in ("aarch64", "arm64") and ptr_size == 8:
+ arch_legacy = asm_generic
+ elif mach.startswith(("arm", "aarch64")):
+ arch_legacy = {
+ "pivot_root": 218,
+ "umount2": 52,
+ "waitid": 280,
+ "execveat": 387,
+ }
+ elif mach.startswith(("ppc", "powerpc")):
+ arch_legacy = {
+ "pivot_root": 203,
+ "umount2": 52,
+ "waitid": 272,
+ "execveat": 362,
+ }
+ elif mach.startswith("s390"):
+ arch_legacy = {
+ "pivot_root": 217,
+ "umount2": 52,
+ "waitid": 281,
+ "execveat": 354,
+ }
+ elif mach.startswith("sparc"):
+ arch_legacy = {
+ "pivot_root": 146,
+ "umount2": 45,
+ "waitid": 279,
+ "execveat": 350,
+ }
+ elif mach.startswith(("parisc", "hppa")):
+ arch_legacy = {
+ "pivot_root": 67,
+ "umount2": 52,
+ "waitid": 235,
+ "execveat": 342,
+ }
+ elif mach == "m68k":
+ arch_legacy = {
+ "pivot_root": 217,
+ "umount2": 52,
+ "waitid": 277,
+ "execveat": 355,
+ }
+ elif mach.startswith("microblaze"):
+ arch_legacy = {
+ "pivot_root": 217,
+ "umount2": 52,
+ "waitid": 284,
+ "execveat": 388,
+ }
+ elif mach.startswith("sh"):
+ arch_legacy = {
+ "pivot_root": 217,
+ "umount2": 52,
+ "waitid": 284,
+ "execveat": 376,
+ }
+ elif mach == "xtensa":
+ arch_legacy = {
+ "pivot_root": 175,
+ "umount2": 171,
+ "waitid": 122,
+ "execveat": 341,
+ }
+ else:
+ arch_legacy = asm_generic
+
+ nums: dict[str, int] = {
+ "pidfd_send_signal": base + 424,
+ "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,
+ "userland_open": base + 474,
+ }
+ nums.update(arch_legacy)
+ 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 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 pidfd_send_signal(
+ cls,
+ pidfd: int,
+ sig: int,
+ info_addr: int = 0,
+ flags: int = 0,
+ ) -> None:
+ cls.syscall(
+ "pidfd_send_signal",
+ ctypes.c_int(pidfd),
+ ctypes.c_int(sig),
+ ctypes.c_void_p(info_addr),
+ ctypes.c_uint(flags),
+ )
+
+ @classmethod
+ def waitid_raw(
+ cls,
+ which: int,
+ upid: int,
+ infop_addr: int,
+ options: int,
+ ru_addr: int = 0,
+ ) -> None:
+ cls.syscall(
+ "waitid",
+ ctypes.c_int(which),
+ ctypes.c_int(upid),
+ ctypes.c_void_p(infop_addr),
+ ctypes.c_int(options),
+ ctypes.c_void_p(ru_addr),
+ )
+
+ @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]] = (),
+ *,
+ reserved: int = 0,
+ size: int | None = None,
+ flags: UsernsFlag | int = UsernsFlag.NONE,
+ ) -> None:
+ u_arr = cls._extent_array(uid_extents)
+ g_arr = cls._extent_array(gid_extents)
+ p_arr = cls._extent_array(projid_extents)
+ req = UsernsIdmap(
+ nr_uid_extents=len(uid_extents),
+ nr_gid_extents=len(gid_extents),
+ nr_projid_extents=len(projid_extents),
+ reserved=reserved,
+ uid_extents=ctypes.addressof(u_arr) if u_arr is not None else 0,
+ 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,
+ int(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):
+ USERLAND_GET_NSFD = Sys.io(0xB9, 0x01)
+ USERLAND_SHARE_NSFD = Sys.io(0xB9, 0x02)
+ NS_GET_USERNS = Sys.io(0xB7, 0x01)
+ NS_GET_PARENT = Sys.io(0xB7, 0x02)
+ NS_GET_NSTYPE = Sys.io(0xB7, 0x03)
+
+
+@dataclass(frozen=True)
+class WaitResult:
+ pid: int
+ status: int = 0
+ code: int = 0
+ uid: int = 0
+
+ @property
+ def exit_code(self) -> int | None:
+ if self.pid <= 0:
+ return None
+ if self.code == os.CLD_EXITED:
+ return self.status
+ if self.code in (os.CLD_KILLED, os.CLD_DUMPED):
+ return -self.status
+ return os.waitstatus_to_exitcode(self.status)
+
+
+class Userland:
+ fd: int
+
+ def __init__(
+ self,
+ flags: UserlandFlag | int = UserlandFlag.DEFAULT,
+ *,
+ fd: int | None = None,
+ ) -> None:
+ if fd is not None:
+ self.fd = fd
+ else:
+ self.fd = Sys.syscall("userland_open", ctypes.c_uint(int(flags)))
+
+ @classmethod
+ def from_fd(cls, fd: int) -> Userland:
+ return cls(fd=fd)
+
+ def fileno(self) -> int:
+ return self.fd
+
+ def __enter__(self) -> Userland:
+ 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.USERLAND_GET_NSFD, int(nstype))
+
+ def share_nsfd(self, nsfd: int) -> None:
+ Sys.ioctl(self.fd, Ioctl.USERLAND_SHARE_NSFD, nsfd)
+
+ 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]] = (),
+ *,
+ flags: UsernsFlag | int = UsernsFlag.NONE,
+ ) -> 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,
+ flags=flags,
+ )
+ 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),),
+ )
+
+ def wait(self, flags: int = 0) -> WaitResult:
+ res = os.waitid(int(WaitIdType.USERLAND), self.fd, os.WEXITED | flags)
+ if res is None:
+ return WaitResult(pid=0)
+ return WaitResult(
+ pid=int(res.si_pid),
+ status=int(res.si_status),
+ code=int(res.si_code),
+ uid=int(res.si_uid),
+ )
+
+ def kill(self, sig: signal.Signals | int) -> None:
+ Sys.pidfd_send_signal(self.fd, int(sig))
+
+ 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_USERLAND | extra_flags)
+ args.exit_signal = exit_signal
+ args.userland = 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_USERLAND, 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: UserlandFlag = UserlandFlag.DEFAULT
+ rns: Userland = field(init=False)
+ mntns_fd: int = field(init=False, default=-1)
+ root_dfd: int = field(init=False, default=-1)
+
+ def __post_init__(self) -> None:
+ self.rns = Userland(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)
+ 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:
+ return self.rns.wait(os.WNOHANG if nohang else 0)
+
+ 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()
diff --git a/tools/testing/selftests/userland/userland_test.py b/tools/testing/selftests/userland/userland_test.py
new file mode 100755
index 000000000000..2b43adbbb429
--- /dev/null
+++ b/tools/testing/selftests/userland/userland_test.py
@@ -0,0 +1,2330 @@
+#!/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
+import ctypes
+from dataclasses import dataclass
+import errno
+import importlib
+import json
+import os
+from pathlib import Path
+import select
+import signal
+import socket
+import sys
+import tempfile
+import threading
+import traceback
+from types import TracebackType
+from typing import Any, Final, NoReturn
+import unittest
+
+from userland_cells import (
+ AtFlag,
+ Cell,
+ CloneArgs,
+ CloneFlag,
+ FsconfigCmd,
+ Ioctl,
+ MountFlag,
+ MoveMountFlag,
+ OpenTreeFlag,
+ PrctlOp,
+ Sys,
+ UmountFlag,
+ Userland,
+ UserlandFlag,
+ UsernsFlag,
+ UsernsIdmap,
+ WaitIdType,
+ 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_userland", 0, errno.ESRCH),
+)
+
+
+class UserlandTestBase(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 enter_userns_if_unpriv(cls) -> None:
+ if os.geteuid() == 0:
+ return
+ uid = os.geteuid()
+ gid = os.getegid()
+ os.unshare(CloneFlag.NEWUSER | CloneFlag.NEWNS)
+ Path("/proc/self/setgroups").write_bytes(b"deny\n")
+ Path("/proc/self/uid_map").write_bytes(f"0 {uid} 1\n".encode())
+ Path("/proc/self/gid_map").write_bytes(f"0 {gid} 1\n".encode())
+
+ @classmethod
+ def enter_foreign_pidns(cls, rns: Userland) -> None:
+ with cls.closing_fd(rns.get_nsfd(CloneFlag.NEWUSER)) as ufd:
+ os.setns(ufd, CloneFlag.NEWUSER)
+ os.unshare(CloneFlag.NEWPID)
+
+ @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 = Userland()
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ return ProbeResult(
+ False, f"userland_open() unavailable: {exc}"
+ )
+ raise
+ with rns:
+ try:
+ rns.map_self_ugid()
+ mfd = rns.make_mount("tmpfs")
+ except OSError as exc:
+ return ProbeResult(False, f"userland 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_userland_as_uid(self, uid: int) -> Userland | None:
+ s_parent, s_child = socket.socketpair(
+ socket.AF_UNIX, socket.SOCK_SEQPACKET
+ )
+ sys.stdout.flush()
+ sys.stderr.flush()
+ pid = os.fork()
+ if pid == 0:
+ s_parent.close()
+ try:
+ self.drop_to_uid(uid)
+ with Userland() 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_userland_as_uid({uid}) failed with status {code}"
+ )
+ return Userland.from_fd(fds[0]) if fds else None
+
+
+class UserlandUapiTest(UserlandTestBase):
+ 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_cell_lifecycle_exec_and_hot_mount(self) -> None:
+ self._require_cell()
+ with Cell("alpha") as cell:
+ cell.setup_rootfs(mount_procfs=True, host_runtime=True)
+ pid = cell.spawn(WAIT_MOUNT_PAYLOAD.argv())
+ self.assertGreater(pid, 0)
+ cell.mount_fs("tmpfs", "/mnt")
+ cell.spawn(WRITE_MOUNT_PAYLOAD.argv())
+ res = cell.wait()
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.exit_code, 0)
+
+ def test_cell_broadcast_kill(self) -> None:
+ self._require_cell()
+ with Cell("killme") as cell:
+ cell.setup_rootfs(mount_procfs=True, host_runtime=True)
+ cell.spawn(PAUSE_PAYLOAD.argv())
+ cell.spawn(PAUSE_PAYLOAD.argv())
+ cell.kill(signal.SIGKILL)
+ res = cell.wait()
+ self.assertEqual(res.exit_code, -int(signal.SIGKILL))
+
+ def test_create_flags(self) -> None:
+ self._require_cell()
+ with Userland(UserlandFlag.NONE):
+ pass
+ with Userland(UserlandFlag.DEFAULT):
+ pass
+ with self.assertRaises(OSError) as cm:
+ Userland((~int(UserlandFlag.ALL)) & 0xFFFFFFFF)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ def test_get_nsfd(self) -> None:
+ try:
+ rns = Userland()
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ self.skipTest(f"userland_open() unavailable: {exc}")
+ raise
+ with rns:
+ for case in NS_TYPE_CASES:
+ with self.subTest(ns=case.name):
+ try:
+ nsfd = rns.get_nsfd(case.nstype)
+ except OSError as exc:
+ if (
+ case.nstype == CloneFlag.NEWTIME
+ and exc.errno == errno.EOPNOTSUPP
+ and not os.path.exists("/proc/self/ns/time")
+ ):
+ continue
+ raise
+ with self.closing_fd(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_share_nsfd(self) -> None:
+ self._require_cell()
+ with Userland() as rns:
+ with self.assertRaises(OSError) as cm:
+ Sys.ioctl(rns.fd, Ioctl.USERLAND_SHARE_NSFD, 99999)
+ self.assertEqual(cm.exception.errno, errno.EBADF)
+
+ with self.assertRaises(OSError) as cm:
+ rns.share_nsfd(rns.fd)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ for bad_type in (CloneFlag.NEWUSER, CloneFlag.NEWNS):
+ with self.closing_fd(rns.get_nsfd(bad_type)) as bad_fd:
+ with self.assertRaises(OSError) as cm:
+ rns.share_nsfd(bad_fd)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.closing_fd(
+ os.open("/proc/self/ns/pid", os.O_RDONLY | os.O_CLOEXEC)
+ ) as pid_fd:
+ with self.assertRaises(OSError) as cm:
+ rns.share_nsfd(pid_fd)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ shareable = (
+ NsTypeCase("cgroup", CloneFlag.NEWCGROUP),
+ NsTypeCase("uts", CloneFlag.NEWUTS),
+ NsTypeCase("ipc", CloneFlag.NEWIPC),
+ NsTypeCase("net", CloneFlag.NEWNET),
+ NsTypeCase("time", CloneFlag.NEWTIME),
+ )
+ for case in shareable:
+ ns_path = f"/proc/self/ns/{case.name}"
+ if not os.path.exists(ns_path):
+ continue
+ with self.subTest(ns=case.name):
+ with (
+ self.closing_fd(
+ os.open(ns_path, os.O_RDONLY | os.O_CLOEXEC)
+ ) as host_fd,
+ self.closing_fd(
+ rns.get_nsfd(case.nstype)
+ ) as orig_fd,
+ ):
+ host_st = os.fstat(host_fd)
+ orig_st = os.fstat(orig_fd)
+ self.assertNotEqual(
+ (orig_st.st_dev, orig_st.st_ino),
+ (host_st.st_dev, host_st.st_ino),
+ )
+ rns.share_nsfd(host_fd)
+ with self.closing_fd(
+ rns.get_nsfd(case.nstype)
+ ) as new_fd:
+ new_st = os.fstat(new_fd)
+ self.assertEqual(
+ (new_st.st_dev, new_st.st_ino),
+ (host_st.st_dev, host_st.st_ino),
+ )
+
+ rns.map_self_ugid()
+ with (
+ self.closing_fd(rns.get_nsfd(CloneFlag.NEWNS)) as mntns_fd,
+ 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,
+ )
+
+ host_net_st = os.stat("/proc/self/ns/net")
+ with (
+ SyncPipe.create() as hold,
+ self.closing_fd(
+ os.open("/proc/self/ns/net", os.O_RDONLY | os.O_CLOEXEC)
+ ) as host_net_fd,
+ ):
+
+ def check_inside_shared() -> int:
+ hold.close_write()
+ st = os.stat("/proc/self/ns/net")
+ ok = (st.st_dev, st.st_ino) == (
+ host_net_st.st_dev,
+ host_net_st.st_ino,
+ )
+ hold.read_bytes()
+ hold.close_read()
+ return 0 if ok else 1
+
+ pid = rns.run(check_inside_shared)
+ hold.close_read()
+ try:
+ with self.assertRaises(OSError) as cm:
+ rns.share_nsfd(host_net_fd)
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+ finally:
+ hold.close_write()
+ self.assertEqual(rns.wait().exit_code, 0)
+ self.assertEqual(self.reap_exit_code(pid), 0)
+
+ with self.assertRaises(OSError) as cm:
+ rns.share_nsfd(host_net_fd)
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+
+ with (
+ Userland() as race_rns,
+ self.closing_fd(race_rns.get_nsfd(CloneFlag.NEWNET)) as v_net,
+ self.closing_fd(
+ os.open("/proc/self/ns/net", os.O_RDONLY | os.O_CLOEXEC)
+ ) as h_net,
+ ):
+ errs: list[BaseException] = []
+
+ def share_worker() -> None:
+ try:
+ for _ in range(100):
+ race_rns.share_nsfd(h_net)
+ race_rns.share_nsfd(v_net)
+ except BaseException as exc:
+ errs.append(exc)
+
+ def reader_worker() -> None:
+ try:
+ for _ in range(100):
+ with self.closing_fd(Sys.fsopen("proc")) as fsfd:
+ Sys.fsconfig(
+ fsfd, FsconfigCmd.SET_USERLAND, aux=race_rns.fd
+ )
+ with self.closing_fd(
+ race_rns.get_nsfd(CloneFlag.NEWNET)
+ ):
+ pass
+ try:
+ race_rns.wait(os.WNOHANG)
+ except OSError as exc:
+ if exc.errno != errno.ECHILD:
+ raise
+ try:
+ race_rns.kill(0)
+ except OSError as exc:
+ if exc.errno != errno.ESRCH:
+ raise
+ except BaseException as exc:
+ errs.append(exc)
+
+ t1 = threading.Thread(target=share_worker)
+ t2 = threading.Thread(target=reader_worker)
+ t1.start()
+ t2.start()
+ t1.join()
+ t2.join()
+ self.assertEqual(errs, [])
+
+ if os.geteuid() == 0:
+ with (
+ Userland() as foreign_rns,
+ self.closing_fd(
+ foreign_rns.get_nsfd(CloneFlag.NEWNET)
+ ) as foreign_net,
+ ):
+
+ def check_foreign_share() -> None:
+ try:
+ self.drop_to_uid(1000)
+ except OSError:
+ return
+ try:
+ alice_rns = Userland()
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ return
+ raise
+ with alice_rns:
+ with self.assertRaises(OSError) as cm_f:
+ alice_rns.share_nsfd(foreign_net)
+ self.assertEqual(cm_f.exception.errno, errno.EPERM)
+ with self.closing_fd(
+ os.open(
+ "/proc/self/ns/net",
+ os.O_RDONLY | os.O_CLOEXEC,
+ )
+ ) as own_net:
+ alice_rns.share_nsfd(own_net)
+
+ self.run_forked(check_foreign_share)
+
+ def test_wait_poll_and_clone_dead(self) -> None:
+ cell = self._require_cell()
+ rns = cell.rns
+
+ with self.assertRaises(OSError) as cm:
+ os.waitid(int(WaitIdType.USERLAND), -1, os.WEXITED)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ os.waitid(int(WaitIdType.USERLAND), 99999, os.WEXITED)
+ self.assertEqual(cm.exception.errno, errno.EBADF)
+
+ with self.assertRaises(OSError) as cm:
+ os.waitid(int(WaitIdType.USERLAND), cell.mntns_fd, os.WEXITED)
+ self.assertEqual(cm.exception.errno, errno.EBADF)
+
+ with self.assertRaises(OSError) as cm:
+ os.waitid(int(WaitIdType.USERLAND), rns.fd, os.WNOHANG)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ rns.wait(os.WSTOPPED)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ ru_buf = ctypes.create_string_buffer(256)
+ with self.assertRaises(OSError) as cm:
+ Sys.waitid_raw(
+ int(WaitIdType.USERLAND),
+ rns.fd,
+ 0,
+ os.WEXITED | os.WNOHANG,
+ ctypes.addressof(ru_buf),
+ )
+ 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))
+
+ os.set_blocking(rns.fd, False)
+ try:
+ with self.assertRaises(OSError) as cm:
+ rns.wait(0)
+ self.assertEqual(cm.exception.errno, errno.EAGAIN)
+ finally:
+ os.set_blocking(rns.fd, True)
+
+ def check_foreign_pidns_wait() -> None:
+ self.enter_foreign_pidns(rns)
+
+ 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 | os.WNOWAIT)
+ self.assertEqual(res.pid, pid)
+ self.assertEqual(res.code, os.CLD_EXITED)
+ self.assertEqual(res.status, 42)
+ self.assertEqual(res.exit_code, 42)
+ self.assertEqual(res.uid, os.geteuid())
+ Sys.waitid_raw(int(WaitIdType.USERLAND), rns.fd, 0, os.WEXITED, 0)
+ self.assertEqual(rns.wait(), res)
+ 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_send_signal_and_kill_on_close(self) -> None:
+ cell = self._require_cell()
+ rns = cell.rns
+
+ with self.assertRaises(OSError) as cm:
+ Sys.pidfd_send_signal(99999, 0)
+ self.assertEqual(cm.exception.errno, errno.EBADF)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.pidfd_send_signal(cell.mntns_fd, 0)
+ self.assertEqual(cm.exception.errno, errno.EBADF)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.pidfd_send_signal(rns.fd, 0, flags=1)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ siginfo_buf = ctypes.create_string_buffer(128)
+ with self.assertRaises(OSError) as cm:
+ Sys.pidfd_send_signal(
+ rns.fd, int(signal.SIGKILL), ctypes.addressof(siginfo_buf)
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ 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()
+
+ def check_foreign_pidns_kill() -> None:
+ self.enter_foreign_pidns(rns)
+
+ def check_inner_kill() -> None:
+ with self.assertRaises(OSError) as cm_k:
+ rns.kill(0)
+ self.assertEqual(cm_k.exception.errno, errno.EXDEV)
+
+ self.run_forked(check_inner_kill)
+
+ self.run_forked(check_foreign_pidns_kill)
+
+ 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=UserlandFlag.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")
+ os.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 ready, SyncPipe.create() as hold:
+
+ def dumpable_child() -> int:
+ ready.close_read()
+ Sys.prctl(PrctlOp.SET_DUMPABLE, 1)
+ ready.write_bytes(b"r")
+ ready.close_write()
+ return hold.wait_in_child()
+
+ pid = cell.rns.run(dumpable_child)
+ ready.close_write()
+ hold.close_read()
+ try:
+ self.assertEqual(ready.read_bytes(), b"r")
+ ready.close_read()
+ with (
+ self.closing_fd(
+ os.open(
+ f"/proc/{pid}/ns/uts", os.O_RDONLY | os.O_CLOEXEC
+ )
+ ) as uts_fd,
+ self.closing_fd(
+ cell.rns.get_nsfd(CloneFlag.NEWUSER)
+ ) as ufd,
+ ):
+
+ def check_owner() -> None:
+ os.setns(ufd, CloneFlag.NEWUSER)
+ os.setns(uts_fd, CloneFlag.NEWUTS)
+
+ self.run_forked(check_owner)
+
+ if os.geteuid() == 0:
+
+ def check_foreign() -> None:
+ try:
+ self.drop_to_uid(1000)
+ except OSError:
+ return
+ self.enter_userns_if_unpriv()
+ with self.assertRaises(OSError) as cm_perm:
+ os.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 (
+ Userland() 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)
+
+ def check_clone_without_mntns() -> None:
+ self.enter_userns_if_unpriv()
+ with self.assertRaises(OSError) as cm_c:
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ "/tmp",
+ Sys.AT_FDCWD,
+ "/tmp",
+ MoveMountFlag.CLONE,
+ )
+ self.assertEqual(cm_c.exception.errno, errno.EINVAL)
+
+ self.run_forked(check_clone_without_mntns)
+
+ 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_USERLAND, aux=rns.fd)
+ with self.assertRaises(OSError) as cm:
+ Sys.fsconfig(fsfd, FsconfigCmd.SET_USERLAND, aux=rns.fd)
+ self.assertEqual(cm.exception.errno, errno.EBUSY)
+
+ if os.geteuid() == 0:
+ with self.closing_fd(Sys.fsopen("cgroup2")) as cg_fsfd:
+ with self.assertRaises(OSError) as cm:
+ Sys.fsconfig(
+ cg_fsfd, FsconfigCmd.SET_USERLAND, aux=rns.fd
+ )
+ self.assertEqual(cm.exception.errno, errno.EOPNOTSUPP)
+
+ def check_sb_nouser_clone() -> None:
+ self.enter_userns_if_unpriv()
+ with (
+ Userland() as empty_u,
+ self.closing_fd(
+ empty_u.get_nsfd(CloneFlag.NEWUSER)
+ ) as e_ufd,
+ self.closing_fd(
+ empty_u.get_nsfd(CloneFlag.NEWNS)
+ ) as e_mfd,
+ ):
+ empty_u.map_self_ugid()
+ os.setns(e_ufd, int(CloneFlag.NEWUSER))
+ os.setns(e_mfd, int(CloneFlag.NEWNS))
+ with (
+ Userland() as dest_u,
+ self.closing_fd(
+ dest_u.get_nsfd(CloneFlag.NEWNS)
+ ) as d_mfd,
+ ):
+ with self.assertRaises(OSError) as cm_nu:
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ "/",
+ d_mfd,
+ "/",
+ MoveMountFlag.T_MNTNS | MoveMountFlag.CLONE,
+ )
+ self.assertEqual(cm_nu.exception.errno, errno.EINVAL)
+
+ self.run_forked(check_sb_nouser_clone)
+
+ def check_child_src_slave_locking() -> None:
+ self.enter_userns_if_unpriv()
+ os.unshare(CloneFlag.NEWNS)
+ with self.closing_fd(self.make_plain_mount("tmpfs")) as tfd:
+ os.mkdir("sub", 0o755, dir_fd=tfd)
+ Sys.move_mount(
+ tfd,
+ "",
+ Sys.AT_FDCWD,
+ "/tmp",
+ MoveMountFlag.F_EMPTY_PATH,
+ )
+ Sys.set_mount_propagation(
+ "/tmp", MountFlag.REC | MountFlag.SHARED
+ )
+ s_p, s_c = socket.socketpair(
+ socket.AF_UNIX, socket.SOCK_SEQPACKET
+ )
+ with (
+ Userland() as u2,
+ self.closing_fd(u2.get_nsfd(CloneFlag.NEWUSER)) as u2_ufd,
+ self.closing_fd(
+ os.open(
+ "/proc/self/ns/mnt", os.O_RDONLY | os.O_CLOEXEC
+ )
+ ) as u1_mfd,
+ SyncPipe.create() as s_go,
+ ):
+ u2.map_self_ugid()
+ spid = os.fork()
+ if spid == 0:
+ s_p.close()
+ s_go.close_write()
+ try:
+ os.setns(u2_ufd, int(CloneFlag.NEWUSER))
+ os.unshare(CloneFlag.NEWNS)
+ Sys.set_mount_propagation(
+ "/tmp", MountFlag.REC | MountFlag.SLAVE
+ )
+ with (
+ self.closing_fd(
+ self.make_plain_mount("tmpfs")
+ ) as m_top,
+ self.closing_fd(
+ self.make_plain_mount("tmpfs")
+ ) as m_inner,
+ ):
+ os.mkdir("inner", 0o755, dir_fd=m_top)
+ Sys.move_mount(
+ m_inner,
+ "",
+ m_top,
+ "inner",
+ MoveMountFlag.F_EMPTY_PATH,
+ )
+ socket.send_fds(s_c, [b"M"], [m_top])
+ if s_go.read_bytes() != b"g":
+ os._exit(1)
+ s_go.close_read()
+ if not os.path.ismount("/tmp/sub/inner"):
+ os._exit(2)
+ try:
+ Sys.umount2(
+ "/tmp/sub/inner", UmountFlag.DETACH
+ )
+ os._exit(3)
+ except OSError as exc:
+ if exc.errno != errno.EINVAL:
+ os._exit(4)
+ Sys.umount2("/tmp/sub", UmountFlag.DETACH)
+ os._exit(0)
+ finally:
+ s_c.close()
+ s_c.close()
+ s_go.close_read()
+ try:
+ _, m_fds, _, _ = socket.recv_fds(s_p, 1, 1)
+ finally:
+ s_p.close()
+ if not m_fds:
+ s_go.close_write()
+ self.assertEqual(self.reap_exit_code(spid), 0)
+ self.fail("did not receive mount fd")
+ with self.closing_fd(m_fds[0]) as m_top:
+ Sys.move_mount(
+ m_top,
+ "",
+ u1_mfd,
+ "tmp/sub",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ s_go.write_bytes(b"g")
+ s_go.close_write()
+ self.assertEqual(self.reap_exit_code(spid), 0)
+ Sys.umount2("/tmp/sub", UmountFlag.DETACH)
+
+ self.run_forked(check_child_src_slave_locking)
+
+ with (
+ Userland() 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_USERLAND, 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)
+
+ rns.map_self_ugid()
+ with self.closing_fd(Sys.fsopen("proc")) as bad_proc:
+
+ def check_nonancestor_proc() -> None:
+ self.enter_foreign_pidns(rns)
+
+ def check_inner() -> None:
+ with self.assertRaises(OSError) as cm_set:
+ Sys.fsconfig(
+ bad_proc, FsconfigCmd.SET_USERLAND, 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 (
+ Userland() 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:
+ os.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)
+
+ def check_clone_mntns_loop() -> None:
+ with (
+ Userland() as host_v,
+ SyncPipe.create() as ready,
+ SyncPipe.create() as hold,
+ ):
+ host_v.map_self_ugid()
+ with self.closing_fd(
+ host_v.get_nsfd(CloneFlag.NEWUSER)
+ ) as ufd:
+ os.setns(ufd, int(CloneFlag.NEWUSER))
+ os.unshare(CloneFlag.NEWNS)
+ Sys.prctl(PrctlOp.SET_DUMPABLE, 1)
+ with self.closing_fd(
+ self.make_plain_mount("tmpfs")
+ ) as tfd:
+ for fname in ("src_m1", "src_m2", "loop_ns", "ok_ns"):
+ os.close(
+ os.open(
+ fname,
+ os.O_CREAT | os.O_WRONLY | os.O_CLOEXEC,
+ 0o600,
+ dir_fd=tfd,
+ )
+ )
+ Sys.move_mount(
+ tfd,
+ "",
+ Sys.AT_FDCWD,
+ "/tmp",
+ MoveMountFlag.F_EMPTY_PATH,
+ )
+ cpid = os.fork()
+ if cpid == 0:
+ ready.close_read()
+ hold.close_write()
+ os.unshare(CloneFlag.NEWNS)
+ ready.write_bytes(b"1")
+ ready.close_write()
+ hold.read_bytes()
+ hold.close_read()
+ os._exit(0)
+ ready.close_write()
+ hold.close_read()
+ self.assertEqual(ready.read_bytes(), b"1")
+ try:
+ with (
+ Userland() as v2,
+ self.closing_fd(
+ os.open(
+ f"/proc/{cpid}/ns/mnt",
+ os.O_RDONLY | os.O_CLOEXEC,
+ )
+ ) as m1_fd,
+ self.closing_fd(
+ v2.get_nsfd(CloneFlag.NEWNS)
+ ) as m2_fd,
+ ):
+ ot_flags = OpenTreeFlag(
+ int(OpenTreeFlag.CLONE)
+ | int(OpenTreeFlag.CLOEXEC)
+ | int(AtFlag.EMPTY_PATH)
+ )
+ with self.closing_fd(
+ Sys.open_tree(m1_fd, "", ot_flags)
+ ) as c1:
+ Sys.move_mount(
+ c1,
+ "",
+ Sys.AT_FDCWD,
+ "/tmp/src_m1",
+ MoveMountFlag.F_EMPTY_PATH,
+ )
+ with self.closing_fd(
+ Sys.open_tree(m2_fd, "", ot_flags)
+ ) as c2:
+ Sys.move_mount(
+ c2,
+ "",
+ Sys.AT_FDCWD,
+ "/tmp/src_m2",
+ MoveMountFlag.F_EMPTY_PATH,
+ )
+ with self.assertRaises(OSError) as cm_loop:
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ "/tmp/src_m1",
+ m1_fd,
+ "tmp/loop_ns",
+ MoveMountFlag.T_MNTNS
+ | MoveMountFlag.CLONE,
+ )
+ self.assertEqual(
+ cm_loop.exception.errno, errno.EINVAL
+ )
+ Sys.move_mount(
+ Sys.AT_FDCWD,
+ "/tmp/src_m2",
+ m1_fd,
+ "tmp/ok_ns",
+ MoveMountFlag.T_MNTNS | MoveMountFlag.CLONE,
+ )
+ finally:
+ hold.close_write()
+ self.assertEqual(self.reap_exit_code(cpid), 0)
+
+ self.run_forked(check_clone_mntns_loop)
+
+ if os.geteuid() == 0:
+ u_rns = self.create_userland_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_USERLAND,
+ 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 Userland() 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_USERLAND),
+ exit_signal=int(signal.SIGCHLD),
+ userland=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:
+ self.enter_foreign_pidns(cell2.rns)
+
+ 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 check_dead_ancestor_pidns() -> None:
+ self.enter_userns_if_unpriv()
+ s_p, s_c = socket.socketpair(
+ socket.AF_UNIX, socket.SOCK_SEQPACKET
+ )
+ p1 = os.fork()
+ if p1 == 0:
+ s_p.close()
+ try:
+ os.unshare(CloneFlag.NEWPID)
+ p2 = os.fork()
+ if p2 == 0:
+ with Userland() as nested_u:
+ socket.send_fds(s_c, [b"U"], [nested_u.fd])
+ os._exit(0)
+ os._exit(self.reap_exit_code(p2))
+ finally:
+ s_c.close()
+ s_c.close()
+ try:
+ _, recv_u, _, _ = socket.recv_fds(s_p, 1, 1)
+ finally:
+ s_p.close()
+ self.assertEqual(self.reap_exit_code(p1), 0)
+ self.assertEqual(len(recv_u), 1)
+ with Userland.from_fd(recv_u[0]) as dead_u:
+ with (
+ self.closing_fd(dead_u.get_nsfd(CloneFlag.NEWNS)) as mfd,
+ self.closing_fd(dead_u.make_mount("tmpfs")) as rfd,
+ ):
+ Sys.move_mount(
+ rfd,
+ "",
+ mfd,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ with self.assertRaises(OSError) as cm_dead:
+ dead_u.clone_into()
+ self.assertEqual(cm_dead.exception.errno, errno.ESRCH)
+
+ self.run_forked(check_dead_ancestor_pidns)
+
+ 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)
+
+ def check_standalone_mntns() -> None:
+ self.enter_userns_if_unpriv()
+ 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:
+ os.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)
+
+ self.run_forked(check_standalone_mntns)
+
+ def test_userns_set_idmap(self) -> None:
+ self._require_cell()
+ with (
+ Userland() 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, size=0, flags=0)
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.userns_set_idmap_raw(
+ userns_fd, 0, size=UsernsIdmap.SIZE_VER0, flags=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)
+
+ big_buf = ctypes.create_string_buffer(65536)
+ with self.assertRaises(OSError) as cm:
+ Sys.userns_set_idmap_raw(
+ userns_fd, ctypes.addressof(big_buf), size=65536
+ )
+ self.assertEqual(cm.exception.errno, errno.E2BIG)
+
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(
+ userns_fd,
+ uid_extents=((0, os.geteuid(), 1),),
+ flags=(~int(UsernsFlag.SETGROUPS_ALLOWED)) & 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(), 1),),
+ flags=UsernsFlag.SETGROUPS_ALLOWED,
+ )
+ 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),),
+ reserved=1,
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ bad_req = UsernsIdmap(nr_uid_extents=1, uid_extents=0)
+ with self.assertRaises(OSError) as cm:
+ Sys.userns_set_idmap_raw(
+ userns_fd, ctypes.addressof(bad_req)
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ bad_req2 = UsernsIdmap(nr_uid_extents=0, uid_extents=1)
+ with self.assertRaises(OSError) as cm:
+ Sys.userns_set_idmap_raw(
+ userns_fd, ctypes.addressof(bad_req2)
+ )
+ 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),),
+ )
+ 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),),
+ )
+ 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,
+ uid_extents=((0, os.geteuid(), 0),),
+ )
+ self.assertEqual(cm.exception.errno, errno.EINVAL)
+
+ can_allow_setgroups = (
+ os.geteuid() == 0
+ and Path("/proc/self/setgroups").read_bytes() == b"allow\n"
+ )
+ if can_allow_setgroups:
+ with (
+ Userland() as rns_sg,
+ self.closing_fd(
+ rns_sg.get_nsfd(CloneFlag.NEWNS)
+ ) as sg_mntns,
+ ):
+ rns_sg.set_idmap(
+ uid_extents=((0, 0, 1),),
+ gid_extents=((0, 0, 1),),
+ flags=UsernsFlag.SETGROUPS_ALLOWED,
+ )
+ with self.closing_fd(rns_sg.make_mount("tmpfs")) as sgr:
+ os.mkdir("proc", 0o755, dir_fd=sgr)
+ Sys.move_mount(
+ sgr,
+ "",
+ sg_mntns,
+ "/",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+ with self.closing_fd(rns_sg.make_mount("proc")) as sgp:
+ Sys.move_mount(
+ sgp,
+ "",
+ sg_mntns,
+ "proc",
+ MoveMountFlag.F_EMPTY_PATH | MoveMountFlag.T_MNTNS,
+ )
+
+ def verify_allow() -> int:
+ with open("/proc/self/setgroups", "rb") as f:
+ return 0 if f.read() == b"allow\n" else 1
+
+ sg_pid = rns_sg.run(verify_allow)
+ self.assertEqual(rns_sg.wait().exit_code, 0)
+ self.assertEqual(self.reap_exit_code(sg_pid), 0)
+ else:
+ with self.assertRaises(OSError) as cm:
+ Sys.set_userns_idmap(
+ userns_fd,
+ gid_extents=((0, os.getegid(), 1),),
+ flags=UsernsFlag.SETGROUPS_ALLOWED,
+ )
+ self.assertEqual(cm.exception.errno, errno.EPERM)
+
+ rns.map_self_ugid()
+ if Path("/proc/self/projid_map").read_bytes():
+ rns.set_idmap(projid_extents=((0, 0, 1),))
+ with self.assertRaises(OSError) as cm:
+ rns.set_idmap(projid_extents=((0, 0, 1),))
+ self.assertEqual(cm.exception.errno, errno.EPERM)
+ else:
+ with self.assertRaises(OSError) as cm:
+ rns.set_idmap(projid_extents=((0, 0, 1),))
+ self.assertEqual(cm.exception.errno, errno.EPERM)
+ 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_userland_as_uid(1000)
+ rns2 = self.create_userland_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 userland creation unavailable")
+
+ with rns1, rns2:
+ s_main, s_alice = socket.socketpair(
+ socket.AF_UNIX, socket.SOCK_SEQPACKET
+ )
+ 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()
+ try:
+ _, alice_fds, _, _ = socket.recv_fds(s_main, 1, 1)
+ finally:
+ s_main.close()
+ self.assertEqual(self.reap_exit_code(alice_pid), 0)
+ self.assertEqual(len(alice_fds), 1)
+
+ 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_SEQPACKET
+ )
+ mal_pid = os.fork()
+ if mal_pid == 0:
+ s_m1.close()
+ try:
+ self.drop_to_uid(2000)
+ try:
+ Sys.set_userns_idmap(
+ alice_ufd, projid_extents=((0, 2000, 1),)
+ )
+ os._exit(2)
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ os._exit(3)
+ with self.closing_fd(
+ Sys.ioctl(uts2_fd, Ioctl.NS_GET_USERNS)
+ ) as bad_ufd:
+ try:
+ Sys.set_userns_idmap(
+ bad_ufd, projid_extents=((0, 2000, 1),)
+ )
+ os._exit(4)
+ except OSError as exc:
+ if exc.errno != errno.EPERM:
+ os._exit(5)
+ socket.send_fds(s_m2, [b"M"], [bad_ufd])
+ os._exit(0)
+ except BaseException:
+ os._exit(1)
+ finally:
+ s_m2.close()
+ s_m2.close()
+ try:
+ _, mal_fds, _, _ = socket.recv_fds(s_m1, 1, 1)
+ finally:
+ s_m1.close()
+ self.assertEqual(self.reap_exit_code(mal_pid), 0)
+ self.assertEqual(len(mal_fds), 1)
+
+ 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),),
+ )
+ 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),),
+ )
+ self.assertEqual(cm_root.exception.errno, errno.EPERM)
+
+ with self.assertRaises(OSError) as cm_mal_p:
+ Sys.set_userns_idmap(
+ mallory_ufd, projid_extents=((0, 1000, 1),)
+ )
+ self.assertEqual(cm_mal_p.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)),
+ projid_extents=((0, 1000, 1),),
+ flags=UsernsFlag.SETGROUPS_ALLOWED,
+ )
+
+ 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:
+ Sys.setgroups_empty()
+ 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
+
+ with self.assertRaises(OSError) as cm_sys:
+ Sys.fsopen("sysfs")
+ self.assertEqual(cm_sys.exception.errno, errno.EPERM)
+
+ 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=UserlandFlag.DEFAULT)
+ except OSError as exc:
+ if exc.errno in SKIP_ERRNOS:
+ self.skipTest("unprivileged userland unavailable")
+ raise
+
+ with (
+ tempfile.TemporaryDirectory(prefix="userland-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()
--
2.47.3
next prev parent reply other threads:[~2026-11-22 19:37 UTC|newest]
Thread overview: 34+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-22 19:35 [RFC PATCH v7 00/26] userland: Userland containers Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 01/26] userns: Factor out idmap validation and commit helpers Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 02/26] userns: Add userns_set_idmap() system call Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 03/26] arch: Wire up " Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 04/26] mount: Add mnt_ns_get_root() Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 05/26] mount: Enforce mount_too_revealing() for foreign mntns Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 06/26] mount: Support MOVE_MOUNT_T_MNTNS in move_mount() Jarkko Sakkinen
2026-11-22 20:02 ` sashiko-bot
2026-11-22 19:35 ` [RFC PATCH v7 07/26] mount: Support MOVE_MOUNT_CLONE with MOVE_MOUNT_T_MNTNS Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 08/26] userns: Factor out install_user_ns_cred() Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 09/26] nsproxy: Expose create_new_namespaces() Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 10/26] userland: Add core infrastructure Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 11/26] userland: Track init lifecycle via copy_process() and pid_namespace Jarkko Sakkinen
2026-11-22 20:09 ` bot+bpf-ci
2026-11-22 19:35 ` [RFC PATCH v7 12/26] userland: Add userland_open() system call Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 13/26] userland: Add USERLAND_GET_NSFD ioctl Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 14/26] userland: Add USERLAND_SHARE_NSFD ioctl Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 15/26] exit: Support P_USERLAND in waitid() Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 16/26] signal: Support userland fds in pidfd_send_signal() Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 17/26] fork: Support CLONE_INTO_USERLAND in clone3() Jarkko Sakkinen
2026-11-22 20:01 ` sashiko-bot
2026-11-22 19:35 ` [RFC PATCH v7 18/26] fs: Support FSCONFIG_SET_USERLAND in fsconfig() Jarkko Sakkinen
2026-11-22 19:58 ` sashiko-bot
2026-11-22 19:35 ` [RFC PATCH v7 19/26] proc: Implement ->set_userland() fs_context operation Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 20/26] ipc/mqueue: " Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 21/26] security: Add userland LSM hooks Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 22/26] bpf: Register " Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 23/26] arch: Wire up userland_open() system call Jarkko Sakkinen
2026-11-22 19:35 ` [RFC PATCH v7 24/26] docs: Document userland uAPI Jarkko Sakkinen
2026-11-22 20:09 ` bot+bpf-ci
2026-11-22 19:35 ` Jarkko Sakkinen [this message]
2026-11-22 19:52 ` [RFC PATCH v7 25/26] selftests/userland: Add userland test suite sashiko-bot
2026-11-22 19:35 ` [RFC PATCH v7 26/26] MAINTAINERS: Add entry for USERLAND Jarkko Sakkinen
2026-11-22 20:02 ` [RFC PATCH v7 00/26] userland: Userland containers sashiko-bot
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=20261122193539.3334213-26-jarkko@kernel.org \
--to=jarkko@kernel.org \
--cc=aleksa@amutable.com \
--cc=alex@amutable.com \
--cc=arnd@arndb.de \
--cc=bpf@vger.kernel.org \
--cc=brauner@kernel.org \
--cc=containers@lists.linux.dev \
--cc=corbet@lwn.net \
--cc=dhowells@redhat.com \
--cc=ebiggers@kernel.org \
--cc=giuseppe@scrivano.org \
--cc=hughd@google.com \
--cc=jack@suse.cz \
--cc=jlayton@kernel.org \
--cc=josef@toxicpanda.com \
--cc=kees@kernel.org \
--cc=kpsingh@kernel.org \
--cc=lennart@poettering.net \
--cc=linux-api@vger.kernel.org \
--cc=linux-arch@vger.kernel.org \
--cc=linux-doc@vger.kernel.org \
--cc=linux-fsdevel@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-kselftest@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=linux-security-module@vger.kernel.org \
--cc=luto@amacapital.net \
--cc=neal@gompa.dev \
--cc=oleg@redhat.com \
--cc=paul@paul-moore.com \
--cc=ptikhomirov@virtuozzo.com \
--cc=sergeh@kernel.org \
--cc=skhan@linuxfoundation.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