From: "Hallgrimur H. Gunnarsson" <halg@google.com>
To: Christian Brauner <brauner@kernel.org>,
Serge Hallyn <sergeh@kernel.org>,
Andy Lutomirski <luto@kernel.org>
Cc: "Paul Moore" <paul@paul-moore.com>,
"James Morris" <jmorris@namei.org>,
"David Howells" <dhowells@redhat.com>,
"Jarkko Sakkinen" <jarkko@kernel.org>,
"Kees Cook" <kees@kernel.org>, "Jonathan Corbet" <corbet@lwn.net>,
"Shuah Khan" <skhan@linuxfoundation.org>,
"Randy Dunlap" <rdunlap@infradead.org>,
"Mickaël Salaün" <mic@digikod.net>,
"Jonathan Calmels" <jcalmels@3xx0.net>,
"Jann Horn" <jannh@google.com>,
"Günther Noack" <gnoack@google.com>,
"KP Singh" <kpsingh@kernel.org>,
"Casey Schaufler" <casey@schaufler-ca.com>,
linux-fsdevel@vger.kernel.org,
linux-security-module@vger.kernel.org, linux-api@vger.kernel.org,
containers@lists.linux.dev, keyrings@vger.kernel.org,
linux-doc@vger.kernel.org, linux-kselftest@vger.kernel.org,
linux-kernel@vger.kernel.org,
"Hallgrimur H. Gunnarsson" <halg@google.com>
Subject: [PATCH v2 4/4] selftests/capabilities: add userns capability bounding set tests
Date: Thu, 19 Nov 2026 10:42:08 +0000 [thread overview]
Message-ID: <20261119104208.782900-5-halg@google.com> (raw)
In-Reply-To: <20261119104208.782900-1-halg@google.com>
Add selftests in tools/testing/selftests/capabilities covering:
- prctl(PR_CAP_USERNS) argument validation and authorization rules for
lowering, clearing, and raising capabilities.
- Default full capability grants, cap_userns restrictions (including
clearing all capabilities), and monotonic inheritance across nested
user namespaces.
- Default retention of capabilities in cap_permitted, and strict
enforcement and persistence of SECBIT_CAP_USERNS_STRICT and its lock
across user namespace transitions.
- Credential and cap_userns clamping upon entering a user namespace via
setns().
- Implicit parent-owner capability bounding by the owned namespace's
cap_bset (including over descendants) and the caller's userns
ceiling, while preserving explicit ancestor capabilities.
- Ptrace restrictions across PTRACE_ATTACH, PTRACE_TRACEME, and
PTRACE_MODE_READ for same-userns peers and owned descendant
namespaces, while preserving explicit CAP_SYS_PTRACE.
- Preservation of dumpable and pdeath_signal when narrowing the userns
ceiling and resets when widening it.
- CapUns reporting in /proc/self/status.
Signed-off-by: Hallgrimur H. Gunnarsson <halg@google.com>
---
.../testing/selftests/capabilities/.gitignore | 1 +
tools/testing/selftests/capabilities/Makefile | 2 +-
.../capabilities/userns_bounding_set_test.c | 1064 +++++++++++++++++
3 files changed, 1066 insertions(+), 1 deletion(-)
create mode 100644 tools/testing/selftests/capabilities/userns_bounding_set_test.c
diff --git a/tools/testing/selftests/capabilities/.gitignore b/tools/testing/selftests/capabilities/.gitignore
index 426d9adca67c..28767c08dea8 100644
--- a/tools/testing/selftests/capabilities/.gitignore
+++ b/tools/testing/selftests/capabilities/.gitignore
@@ -1,3 +1,4 @@
# SPDX-License-Identifier: GPL-2.0-only
test_execve
+userns_bounding_set_test
validate_cap
diff --git a/tools/testing/selftests/capabilities/Makefile b/tools/testing/selftests/capabilities/Makefile
index 411ac098308f..b29f7b117c11 100644
--- a/tools/testing/selftests/capabilities/Makefile
+++ b/tools/testing/selftests/capabilities/Makefile
@@ -1,6 +1,6 @@
# SPDX-License-Identifier: GPL-2.0
TEST_GEN_FILES := validate_cap
-TEST_GEN_PROGS := test_execve
+TEST_GEN_PROGS := test_execve userns_bounding_set_test
CFLAGS += -O2 -g -std=gnu99 -Wall $(KHDR_INCLUDES)
LDLIBS += -lcap-ng -lrt -ldl
diff --git a/tools/testing/selftests/capabilities/userns_bounding_set_test.c b/tools/testing/selftests/capabilities/userns_bounding_set_test.c
new file mode 100644
index 000000000000..9aa9e5b31130
--- /dev/null
+++ b/tools/testing/selftests/capabilities/userns_bounding_set_test.c
@@ -0,0 +1,1064 @@
+// SPDX-License-Identifier: GPL-2.0
+#define _GNU_SOURCE
+
+#include <errno.h>
+#include <fcntl.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/prctl.h>
+#include <sys/ptrace.h>
+#include <sys/socket.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <linux/capability.h>
+#include <linux/prctl.h>
+#include <linux/sched.h>
+#include <linux/securebits.h>
+
+#include "../clone3/clone3_selftests.h"
+#include "../kselftest_harness.h"
+
+#define MAX_TRACEES 2
+
+struct cap_state {
+ bool bset;
+ bool permitted;
+ bool effective;
+};
+
+static int get_cap_state(int cap, struct cap_state *state)
+{
+ struct __user_cap_header_struct hdr = {
+ .version = _LINUX_CAPABILITY_VERSION_3,
+ .pid = 0,
+ };
+ struct __user_cap_data_struct data[2];
+ uint32_t mask;
+ int idx;
+
+ if (cap < 0 || cap > CAP_LAST_CAP)
+ return -EINVAL;
+
+ if (syscall(SYS_capget, &hdr, data) != 0)
+ return -errno;
+
+ idx = CAP_TO_INDEX(cap);
+ mask = CAP_TO_MASK(cap);
+
+ state->bset = (prctl(PR_CAPBSET_READ, cap, 0, 0, 0) == 1);
+ state->permitted = (data[idx].permitted & mask) != 0;
+ state->effective = (data[idx].effective & mask) != 0;
+
+ return 0;
+}
+
+static bool cap_raised(int cap)
+{
+ struct cap_state t;
+
+ if (get_cap_state(cap, &t) != 0)
+ return false;
+
+ return t.bset && t.permitted && t.effective;
+}
+
+static bool cap_dropped(int cap)
+{
+ struct cap_state t;
+
+ if (get_cap_state(cap, &t) != 0)
+ return false;
+
+ return !t.bset && !t.permitted && !t.effective;
+}
+
+static int set_caps(uint64_t permitted, uint64_t effective)
+{
+ struct __user_cap_header_struct hdr = {
+ .version = _LINUX_CAPABILITY_VERSION_3,
+ };
+ struct __user_cap_data_struct data[2] = {
+ {
+ .permitted = (uint32_t)permitted,
+ .effective = (uint32_t)effective,
+ },
+ {
+ .permitted = (uint32_t)(permitted >> 32),
+ .effective = (uint32_t)(effective >> 32),
+ },
+ };
+
+ return syscall(SYS_capset, &hdr, data);
+}
+
+static int drop_all_caps(void)
+{
+ return set_caps(0, 0);
+}
+
+static int drop_caps_except(int cap)
+{
+ uint64_t cap_mask = 1ULL << cap;
+
+ return set_caps(cap_mask, cap_mask);
+}
+
+static int write_file(const char *path, const char *str)
+{
+ ssize_t len = strlen(str);
+ ssize_t ret;
+ int fd, err;
+
+ fd = open(path, O_WRONLY | O_CLOEXEC);
+ if (fd < 0)
+ return -errno;
+ ret = write(fd, str, len);
+ err = errno;
+ close(fd);
+
+ if (ret < 0)
+ return -err;
+ return (ret == len) ? 0 : -EIO;
+}
+
+static int map_current_ugid(uid_t uid, gid_t gid)
+{
+ char map_buf[64];
+ int ret;
+
+ /*
+ * May return -EPERM in nested user namespaces when an ancestor
+ * namespace already set setgroups to "deny".
+ */
+ ret = write_file("/proc/self/setgroups", "deny\n");
+ if (ret != 0 && ret != -EPERM)
+ return ret;
+
+ snprintf(map_buf, sizeof(map_buf), "0 %u 1\n", uid);
+ ret = write_file("/proc/self/uid_map", map_buf);
+ if (ret != 0)
+ return ret;
+
+ snprintf(map_buf, sizeof(map_buf), "0 %u 1\n", gid);
+ return write_file("/proc/self/gid_map", map_buf);
+}
+
+static int read_proc_userns(uint64_t *val)
+{
+ static const char prefix[] = "CapUns:\t";
+ FILE *f = fopen("/proc/self/status", "r");
+ char line[256];
+ int ret = -1;
+
+ if (!f)
+ return -1;
+
+ while (fgets(line, sizeof(line), f)) {
+ if (strncmp(line, prefix, strlen(prefix)) == 0) {
+ *val = strtoull(line + strlen(prefix), NULL, 16);
+ ret = 0;
+ break;
+ }
+ }
+
+ fclose(f);
+ return ret;
+}
+
+/*
+ * Spawns a child userns owned by the caller's euid without mutating the
+ * caller's credentials. Uses CLONE_FILES so the child can open its own
+ * /proc/self/ns/user directly into the parent's fd table and exit cleanly.
+ */
+static int open_child_userns_without(int lower_cap)
+{
+ struct __clone_args args = {
+ .flags = CLONE_FILES,
+ .exit_signal = SIGCHLD,
+ };
+ int ns_fd, status;
+ pid_t child;
+
+ ns_fd = open("/dev/null", O_RDONLY | O_CLOEXEC);
+ if (ns_fd < 0)
+ return -1;
+
+ child = sys_clone3(&args, sizeof(args));
+ if (child < 0) {
+ close(ns_fd);
+ return -1;
+ }
+
+ if (child == 0) {
+ int fd;
+
+ if (lower_cap >= 0) {
+ if (prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ lower_cap, 0, 0) != 0)
+ _exit(1);
+ if (prctl(PR_SET_SECUREBITS, SECBIT_CAP_USERNS_STRICT,
+ 0, 0, 0) != 0)
+ _exit(1);
+ }
+ if (unshare(CLONE_NEWUSER) != 0)
+ _exit(1);
+
+ fd = open("/proc/self/ns/user", O_RDONLY | O_CLOEXEC);
+ if (fd < 0)
+ _exit(1);
+ if (dup3(fd, ns_fd, O_CLOEXEC) < 0)
+ _exit(1);
+ close(fd);
+ _exit(0);
+ }
+
+ if (waitpid(child, &status, 0) != child ||
+ !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+ close(ns_fd);
+ return -1;
+ }
+
+ return ns_fd;
+}
+
+static int open_child_userns(void)
+{
+ return open_child_userns_without(-1);
+}
+
+FIXTURE(userns_bset) {
+};
+
+FIXTURE_SETUP(userns_bset)
+{
+ uid_t uid = geteuid();
+ gid_t gid = getegid();
+
+ if (prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET, 0, 0, 0) < 0 &&
+ errno == EINVAL)
+ SKIP(return, "PR_CAP_USERNS not supported");
+
+ if (unshare(CLONE_NEWUSER) != 0)
+ SKIP(return, "unshare(CLONE_NEWUSER) failed");
+
+ ASSERT_EQ(0, map_current_ugid(uid, gid));
+}
+
+FIXTURE_TEARDOWN(userns_bset)
+{
+}
+
+/*
+ * An unprivileged userns creator with the default full cap_userns mask
+ * receives all capabilities (0..CAP_LAST_CAP) in a new user namespace.
+ */
+TEST_F(userns_bset, default_full_capabilities)
+{
+ int cap;
+
+ for (cap = 0; cap <= CAP_LAST_CAP; cap++)
+ EXPECT_EQ(1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ cap, 0, 0));
+
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, unshare(CLONE_NEWUSER));
+
+ for (cap = 0; cap <= CAP_LAST_CAP; cap++)
+ EXPECT_TRUE(cap_raised(cap));
+}
+
+/*
+ * Verify prctl(PR_CAP_USERNS) rejects unknown sub-options, out-of-range
+ * capabilities, and non-zero reserved arguments.
+ */
+TEST_F(userns_bset, prctl_invalid_args)
+{
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, 999, 0, 0, 0));
+ EXPECT_EQ(EINVAL, errno);
+
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_LAST_CAP + 1, 0, 0));
+ EXPECT_EQ(EINVAL, errno);
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_RAISE,
+ CAP_LAST_CAP + 1, 0, 0));
+ EXPECT_EQ(EINVAL, errno);
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_LAST_CAP + 1, 0, 0));
+ EXPECT_EQ(EINVAL, errno);
+
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_ADMIN, 1, 0));
+ EXPECT_EQ(EINVAL, errno);
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_ADMIN, 0, 1));
+ EXPECT_EQ(EINVAL, errno);
+
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_CLEAR_ALL, 1, 0, 0));
+ EXPECT_EQ(EINVAL, errno);
+}
+
+/*
+ * Verify PR_CAP_USERNS_LOWER and PR_CAP_USERNS_CLEAR_ALL require either
+ * CAP_SETPCAP or no_new_privs.
+ */
+TEST_F(userns_bset, prctl_lower_authorization)
+{
+ /* CAP_SETPCAP alone (without no_new_privs) authorizes LOWER */
+ ASSERT_EQ(0, drop_caps_except(CAP_SETPCAP));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_RAW, 0, 0));
+ EXPECT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_RAW, 0, 0));
+
+ /* Without CAP_SETPCAP or no_new_privs, LOWER and CLEAR_ALL must fail */
+ ASSERT_EQ(0, drop_all_caps());
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ EXPECT_EQ(EPERM, errno);
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_CLEAR_ALL, 0, 0, 0));
+ EXPECT_EQ(EPERM, errno);
+
+ /* Setting no_new_privs unlocks LOWER and CLEAR_ALL */
+ ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ EXPECT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_ADMIN, 0, 0));
+
+ EXPECT_EQ(1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_SYS_ADMIN, 0, 0));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_CLEAR_ALL, 0, 0, 0));
+ EXPECT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_SYS_ADMIN, 0, 0));
+}
+
+/*
+ * Verify PR_CAP_USERNS_RAISE requires the capability in cap_permitted.
+ */
+TEST_F(userns_bset, prctl_raise_requires_permitted)
+{
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ EXPECT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_ADMIN, 0, 0));
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_RAISE,
+ CAP_NET_ADMIN, 0, 0));
+ EXPECT_EQ(1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_ADMIN, 0, 0));
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, drop_caps_except(CAP_SETPCAP));
+
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_RAISE,
+ CAP_NET_ADMIN, 0, 0));
+ EXPECT_EQ(EPERM, errno);
+}
+
+/*
+ * Verify /proc/self/status CapUns reflects PR_CAP_USERNS mutations.
+ */
+TEST_F(userns_bset, proc_status_cap_uns)
+{
+ uint64_t cap_uns = 0;
+
+ ASSERT_EQ(0, read_proc_userns(&cap_uns));
+ EXPECT_NE(0ULL, cap_uns & (1ULL << CAP_NET_ADMIN));
+ EXPECT_NE(0ULL, cap_uns & (1ULL << CAP_SYS_ADMIN));
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, read_proc_userns(&cap_uns));
+ EXPECT_EQ(0ULL, cap_uns & (1ULL << CAP_NET_ADMIN));
+ EXPECT_NE(0ULL, cap_uns & (1ULL << CAP_SYS_ADMIN));
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_RAISE,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, read_proc_userns(&cap_uns));
+ EXPECT_NE(0ULL, cap_uns & (1ULL << CAP_NET_ADMIN));
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_CLEAR_ALL, 0, 0, 0));
+ ASSERT_EQ(0, read_proc_userns(&cap_uns));
+ EXPECT_EQ(0ULL, cap_uns);
+}
+
+/*
+ * Lowering CAP_NET_ADMIN in cap_userns prevents an unprivileged creator from
+ * acquiring it in a child userns while keeping other capabilities intact.
+ */
+TEST_F(userns_bset, unprivileged_restriction)
+{
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, unshare(CLONE_NEWUSER));
+
+ EXPECT_TRUE(cap_raised(CAP_SYS_ADMIN));
+ EXPECT_TRUE(cap_dropped(CAP_NET_ADMIN));
+}
+
+/*
+ * Clearing all capabilities in cap_userns produces a userns with an empty
+ * bounding, permitted, and effective set for an unprivileged creator.
+ */
+TEST_F(userns_bset, clear_all_caps)
+{
+ int cap;
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_CLEAR_ALL, 0, 0, 0));
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, unshare(CLONE_NEWUSER));
+
+ for (cap = 0; cap <= CAP_LAST_CAP; cap++)
+ EXPECT_TRUE(cap_dropped(cap));
+}
+
+/*
+ * A userns creator retains capabilities held in cred->cap_permitted even when
+ * lowered in cred->cap_userns.
+ */
+TEST_F(userns_bset, creator_retains_permitted_caps)
+{
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_RAW, 0, 0));
+ ASSERT_EQ(0, drop_caps_except(CAP_NET_ADMIN));
+
+ ASSERT_EQ(0, unshare(CLONE_NEWUSER));
+
+ EXPECT_TRUE(cap_raised(CAP_NET_ADMIN));
+ EXPECT_TRUE(cap_dropped(CAP_NET_RAW));
+ EXPECT_TRUE(cap_raised(CAP_SYS_ADMIN));
+
+ EXPECT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_ADMIN, 0, 0));
+ EXPECT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_RAW, 0, 0));
+}
+
+/*
+ * Verify SECURE_CAP_USERNS_STRICT:
+ * - Prevents PR_CAP_USERNS_RAISE even when cap is in cap_permitted.
+ * - Prevents retaining lowered caps via cap_permitted on userns creation.
+ * - Persists (with its lock bit) across userns transition.
+ */
+TEST_F(userns_bset, securebit_cap_userns_strict)
+{
+ int secbits;
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, prctl(PR_SET_SECUREBITS,
+ SECBIT_CAP_USERNS_STRICT |
+ SECBIT_CAP_USERNS_STRICT_LOCKED, 0, 0, 0));
+
+ /* Lock prevents clearing */
+ EXPECT_EQ(-1, prctl(PR_SET_SECUREBITS, 0, 0, 0, 0));
+ EXPECT_EQ(EPERM, errno);
+
+ /* Cannot raise even though CAP_NET_ADMIN is in cap_permitted */
+ EXPECT_EQ(-1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_RAISE,
+ CAP_NET_ADMIN, 0, 0));
+ EXPECT_EQ(EPERM, errno);
+
+ /* Child userns does not inherit CAP_NET_ADMIN from cap_permitted */
+ ASSERT_EQ(0, unshare(CLONE_NEWUSER));
+ EXPECT_TRUE(cap_dropped(CAP_NET_ADMIN));
+ EXPECT_TRUE(cap_raised(CAP_SYS_ADMIN));
+
+ /* Securebit and lock persist across userns transition */
+ secbits = prctl(PR_GET_SECUREBITS, 0, 0, 0, 0);
+ ASSERT_GE(secbits, 0);
+ EXPECT_NE(0, secbits & SECBIT_CAP_USERNS_STRICT);
+ EXPECT_NE(0, secbits & SECBIT_CAP_USERNS_STRICT_LOCKED);
+}
+
+/*
+ * Verify ns->cap_bset decreases monotonically across nested user namespaces.
+ */
+TEST_F(userns_bset, nested_monotonic_restriction)
+{
+ /* Child userns lacks CAP_NET_ADMIN (keep CAP_SETFCAP to map uid 0) */
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, drop_caps_except(CAP_SETFCAP));
+ ASSERT_EQ(0, unshare(CLONE_NEWUSER));
+ ASSERT_EQ(0, map_current_ugid(0, 0));
+
+ EXPECT_TRUE(cap_dropped(CAP_NET_ADMIN));
+ EXPECT_TRUE(cap_raised(CAP_NET_RAW));
+
+ /* Lower a second cap and unshare a grandchild userns */
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_RAW, 0, 0));
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, unshare(CLONE_NEWUSER));
+
+ /* Grandchild lacks both parent's dropped cap and newly lowered cap */
+ EXPECT_TRUE(cap_dropped(CAP_NET_ADMIN));
+ EXPECT_TRUE(cap_dropped(CAP_NET_RAW));
+ EXPECT_TRUE(cap_raised(CAP_SYS_ADMIN));
+}
+
+/*
+ * Verify setns() clamps both active capabilities and cap_userns to the target
+ * namespace's cap_bset, even when held in cap_permitted and cap_userns.
+ */
+TEST_F(userns_bset, setns_clamps_to_userns_bset)
+{
+ int trimmed_ns_fd;
+
+ trimmed_ns_fd = open_child_userns_without(CAP_NET_ADMIN);
+ ASSERT_GE(trimmed_ns_fd, 0);
+
+ ASSERT_EQ(0, drop_caps_except(CAP_NET_ADMIN));
+ ASSERT_EQ(1, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, setns(trimmed_ns_fd, CLONE_NEWUSER));
+ close(trimmed_ns_fd);
+
+ EXPECT_TRUE(cap_dropped(CAP_NET_ADMIN));
+ EXPECT_TRUE(cap_raised(CAP_SYS_ADMIN));
+ EXPECT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET,
+ CAP_NET_ADMIN, 0, 0));
+}
+
+/*
+ * Verify setns() clamps capabilities to the caller's userns capability ceiling
+ * when entering a less-restricted child userns.
+ */
+TEST_F(userns_bset, setns_clamps_to_task_cap_userns)
+{
+ int full_ns_fd;
+
+ full_ns_fd = open_child_userns();
+ ASSERT_GE(full_ns_fd, 0);
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, prctl(PR_SET_SECUREBITS, SECBIT_CAP_USERNS_STRICT,
+ 0, 0, 0));
+ ASSERT_TRUE(cap_raised(CAP_NET_ADMIN));
+
+ ASSERT_EQ(0, setns(full_ns_fd, CLONE_NEWUSER));
+ close(full_ns_fd);
+
+ EXPECT_TRUE(cap_dropped(CAP_NET_ADMIN));
+ EXPECT_TRUE(cap_raised(CAP_SYS_ADMIN));
+}
+
+/*
+ * Verify a child's ns->cap_bset does not restrict an ancestor holding the
+ * capability from acting on the child userns, while still clamping credentials
+ * upon entry.
+ */
+TEST_F(userns_bset, ancestor_capable_over_trimmed_child)
+{
+ int no_sys_admin_ns_fd;
+
+ no_sys_admin_ns_fd = open_child_userns_without(CAP_SYS_ADMIN);
+ ASSERT_GE(no_sys_admin_ns_fd, 0);
+
+ ASSERT_EQ(0, setns(no_sys_admin_ns_fd, CLONE_NEWUSER));
+ close(no_sys_admin_ns_fd);
+
+ EXPECT_TRUE(cap_dropped(CAP_SYS_ADMIN));
+ EXPECT_TRUE(cap_raised(CAP_NET_ADMIN));
+}
+
+/*
+ * Verify an unprivileged parent owner only holds implicit capabilities that
+ * are present in the owned namespace's cap_bset, even when the caller's own
+ * cap_userns is unrestricted.
+ */
+TEST_F(userns_bset, parent_owner_bounded_by_owned_bset)
+{
+ int full_ns_fd, no_sys_admin_ns_fd;
+
+ full_ns_fd = open_child_userns();
+ ASSERT_GE(full_ns_fd, 0);
+ no_sys_admin_ns_fd = open_child_userns_without(CAP_SYS_ADMIN);
+ ASSERT_GE(no_sys_admin_ns_fd, 0);
+
+ ASSERT_EQ(0, drop_all_caps());
+
+ /* Denied when the owned namespace's cap_bset lacks CAP_SYS_ADMIN */
+ EXPECT_EQ(-1, setns(no_sys_admin_ns_fd, CLONE_NEWUSER));
+ EXPECT_EQ(EPERM, errno);
+
+ /* Allowed when the owned namespace's cap_bset contains CAP_SYS_ADMIN */
+ EXPECT_EQ(0, setns(full_ns_fd, CLONE_NEWUSER));
+
+ close(no_sys_admin_ns_fd);
+ close(full_ns_fd);
+}
+
+/*
+ * Verify an unprivileged parent owner only holds implicit capabilities over a
+ * child userns when the child's cap_bset is a subset of the caller's userns
+ * capability ceiling.
+ */
+TEST_F(userns_bset, parent_owner_requires_bset_subset)
+{
+ int full_ns_fd, trimmed_ns_fd;
+
+ full_ns_fd = open_child_userns();
+ ASSERT_GE(full_ns_fd, 0);
+ trimmed_ns_fd = open_child_userns_without(CAP_NET_ADMIN);
+ ASSERT_GE(trimmed_ns_fd, 0);
+
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+
+ /* Denied: full_ns has CAP_NET_ADMIN outside caller's ceiling */
+ EXPECT_EQ(-1, setns(full_ns_fd, CLONE_NEWUSER));
+ EXPECT_EQ(EPERM, errno);
+
+ /* Allowed: trimmed_ns->cap_bset is a subset of caller's ceiling */
+ EXPECT_EQ(0, setns(trimmed_ns_fd, CLONE_NEWUSER));
+
+ close(trimmed_ns_fd);
+ close(full_ns_fd);
+}
+
+struct tracee {
+ pid_t pid;
+ int fd;
+};
+
+FIXTURE(userns_ptrace) {
+ struct tracee tracees[MAX_TRACEES];
+};
+
+FIXTURE_SETUP(userns_ptrace)
+{
+ uid_t uid = geteuid();
+ gid_t gid = getegid();
+ int i;
+
+ for (i = 0; i < MAX_TRACEES; i++) {
+ self->tracees[i].pid = -1;
+ self->tracees[i].fd = -1;
+ }
+
+ if (prctl(PR_CAP_USERNS, PR_CAP_USERNS_IS_SET, 0, 0, 0) < 0 &&
+ errno == EINVAL)
+ SKIP(return, "PR_CAP_USERNS not supported");
+
+ if (unshare(CLONE_NEWUSER) != 0)
+ SKIP(return, "unshare(CLONE_NEWUSER) failed");
+
+ ASSERT_EQ(0, map_current_ugid(uid, gid));
+}
+
+FIXTURE_TEARDOWN(userns_ptrace)
+{
+ int i;
+
+ for (i = 0; i < MAX_TRACEES; i++) {
+ if (self->tracees[i].fd >= 0)
+ close(self->tracees[i].fd);
+ if (self->tracees[i].pid > 0) {
+ kill(self->tracees[i].pid, SIGKILL);
+ waitpid(self->tracees[i].pid, NULL, 0);
+ }
+ }
+}
+
+/*
+ * Spawn a child initialized with @setup() that blocks until FIXTURE_TEARDOWN.
+ */
+static pid_t start_tracee(struct tracee *tracees, int (*setup)(void))
+{
+ int slot = -1, sv[2];
+ char ch = 0;
+ pid_t pid;
+ int i;
+
+ for (i = 0; i < MAX_TRACEES; i++) {
+ if (tracees[i].pid < 0) {
+ slot = i;
+ break;
+ }
+ }
+ if (slot < 0)
+ return -1;
+
+ if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) != 0)
+ return -1;
+
+ pid = fork();
+ if (pid < 0) {
+ close(sv[0]);
+ close(sv[1]);
+ return -1;
+ }
+
+ if (pid == 0) {
+ close(sv[0]);
+ if (setup && setup() != 0)
+ _exit(1);
+ if (write(sv[1], &ch, 1) != 1)
+ _exit(1);
+ while (read(sv[1], &ch, 1) < 0 && errno == EINTR)
+ ;
+ close(sv[1]);
+ _exit(0);
+ }
+
+ close(sv[1]);
+ if (read(sv[0], &ch, 1) != 1) {
+ close(sv[0]);
+ kill(pid, SIGKILL);
+ waitpid(pid, NULL, 0);
+ return -1;
+ }
+
+ tracees[slot].pid = pid;
+ tracees[slot].fd = sv[0];
+ return pid;
+}
+
+static int try_ptrace_attach(pid_t pid)
+{
+ int err, status;
+ pid_t ret;
+
+ if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) != 0)
+ return -errno;
+ do {
+ ret = waitpid(pid, &status, 0);
+ } while (ret < 0 && errno == EINTR);
+ if (ret != pid) {
+ err = -errno;
+ ptrace(PTRACE_DETACH, pid, NULL, NULL);
+ return err;
+ }
+ if (ptrace(PTRACE_DETACH, pid, NULL, NULL) != 0)
+ return -errno;
+ return 0;
+}
+
+/* Unprivileged task in caller's userns with a full userns ceiling. */
+static int tracee_same_ns_full(void)
+{
+ return drop_all_caps();
+}
+
+/* Unprivileged task in caller's userns with CAP_NET_ADMIN lowered. */
+static int tracee_same_ns_no_net_admin(void)
+{
+ if (prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER, CAP_NET_ADMIN, 0, 0) != 0)
+ return -1;
+ return drop_all_caps();
+}
+
+/* Task with full capabilities inside an untrimmed child userns. */
+static int tracee_child_ns_full(void)
+{
+ return unshare(CLONE_NEWUSER);
+}
+
+/* Task inside a trimmed child userns lacking CAP_NET_ADMIN. */
+static int tracee_child_ns_no_net_admin(void)
+{
+ if (prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER, CAP_NET_ADMIN, 0, 0) != 0)
+ return -1;
+ if (drop_all_caps() != 0)
+ return -1;
+ return unshare(CLONE_NEWUSER);
+}
+
+/*
+ * Unprivileged task in an untrimmed child userns with CAP_NET_ADMIN dropped
+ * from task caps.
+ */
+static int tracee_child_ns_dropped_caps(void)
+{
+ if (unshare(CLONE_NEWUSER) != 0)
+ return -1;
+ if (prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER, CAP_NET_ADMIN, 0, 0) != 0)
+ return -1;
+ if (prctl(PR_CAPBSET_DROP, CAP_NET_ADMIN, 0, 0, 0) != 0)
+ return -1;
+ return drop_all_caps();
+}
+
+/*
+ * Unprivileged task in an empty grandchild userns under an untrimmed child
+ * userns.
+ */
+static int tracee_grandchild_ns_empty(void)
+{
+ if (unshare(CLONE_NEWUSER) != 0)
+ return -1;
+ if (map_current_ugid(0, 0) != 0)
+ return -1;
+ if (prctl(PR_CAP_USERNS, PR_CAP_USERNS_CLEAR_ALL, 0, 0, 0) != 0)
+ return -1;
+ if (drop_all_caps() != 0)
+ return -1;
+ return unshare(CLONE_NEWUSER);
+}
+
+/*
+ * Unprivileged tracer in the same userns cannot PTRACE_ATTACH a peer with a
+ * wider userns capability ceiling, while attaching to an equally restricted
+ * peer succeeds.
+ */
+TEST_F(userns_ptrace, same_ns_ceiling)
+{
+ pid_t full, trimmed;
+
+ full = start_tracee(self->tracees, tracee_same_ns_full);
+ ASSERT_GT(full, 0);
+ trimmed = start_tracee(self->tracees, tracee_same_ns_no_net_admin);
+ ASSERT_GT(trimmed, 0);
+
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+
+ EXPECT_EQ(-EPERM, try_ptrace_attach(full));
+ EXPECT_EQ(0, try_ptrace_attach(trimmed));
+}
+
+/*
+ * Implicit CAP_SYS_PTRACE from owning a child userns does not allow a
+ * restricted parent task to attach to a less restricted child userns.
+ */
+TEST_F(userns_ptrace, owned_child_ns_ceiling)
+{
+ pid_t full, trimmed;
+
+ full = start_tracee(self->tracees, tracee_child_ns_full);
+ ASSERT_GT(full, 0);
+ trimmed = start_tracee(self->tracees, tracee_child_ns_no_net_admin);
+ ASSERT_GT(trimmed, 0);
+
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+
+ EXPECT_EQ(-EPERM, try_ptrace_attach(full));
+ EXPECT_EQ(0, try_ptrace_attach(trimmed));
+}
+
+/*
+ * A tracer holding CAP_SYS_PTRACE in its own credentials can still attach to
+ * less restricted tasks in both its own userns and descendant user namespaces.
+ */
+TEST_F(userns_ptrace, explicit_cap_sys_ptrace)
+{
+ pid_t same, child;
+
+ same = start_tracee(self->tracees, tracee_same_ns_full);
+ ASSERT_GT(same, 0);
+ child = start_tracee(self->tracees, tracee_child_ns_full);
+ ASSERT_GT(child, 0);
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, prctl(PR_SET_SECUREBITS, SECBIT_CAP_USERNS_STRICT,
+ 0, 0, 0));
+ ASSERT_EQ(0, drop_caps_except(CAP_SYS_PTRACE));
+
+ EXPECT_EQ(0, try_ptrace_attach(same));
+ EXPECT_EQ(0, try_ptrace_attach(child));
+}
+
+/*
+ * PTRACE_MODE_READ_FSCREDS (gating /proc/<pid>/ns/user and /proc/<pid>/fd/)
+ * is likewise bounded by the caller's userns capability ceiling, preventing
+ * a restricted task from stealing open fds or setns()-joining a populated
+ * untrimmed child userns to gain intra-namespace CAP_SYS_PTRACE over tasks
+ * inside it.
+ */
+TEST_F(userns_ptrace, read_mode_ceiling)
+{
+ pid_t full, trimmed;
+ char path[64];
+ int fd;
+
+ full = start_tracee(self->tracees, tracee_child_ns_full);
+ ASSERT_GT(full, 0);
+ trimmed = start_tracee(self->tracees, tracee_child_ns_no_net_admin);
+ ASSERT_GT(trimmed, 0);
+
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+
+ snprintf(path, sizeof(path), "/proc/%d/ns/user", full);
+ EXPECT_EQ(-1, open(path, O_RDONLY | O_CLOEXEC));
+ EXPECT_EQ(EACCES, errno);
+
+ snprintf(path, sizeof(path), "/proc/%d/ns/user", trimmed);
+ fd = open(path, O_RDONLY | O_CLOEXEC);
+ EXPECT_GE(fd, 0);
+ if (fd >= 0)
+ close(fd);
+}
+
+/*
+ * Verify PTRACE_TRACEME fails when the parent tracer has a narrower userns
+ * capability ceiling than the child, and succeeds once the child matches it.
+ */
+TEST_F(userns_ptrace, traceme_ceiling)
+{
+ int sync_pipe[2];
+ int status;
+ char ch = 0;
+ pid_t child;
+
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, pipe(sync_pipe));
+
+ child = fork();
+ ASSERT_GE(child, 0);
+
+ if (child == 0) {
+ close(sync_pipe[1]);
+ if (read(sync_pipe[0], &ch, 1) != 1)
+ _exit(1);
+ close(sync_pipe[0]);
+
+ /* Parent lowered CAP_NET_ADMIN; child still has full mask */
+ if (ptrace(PTRACE_TRACEME, 0, NULL, NULL) != -1 ||
+ errno != EPERM)
+ _exit(2);
+
+ /* Matching parent's ceiling allows PTRACE_TRACEME */
+ if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0)
+ _exit(3);
+ if (prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0) != 0)
+ _exit(4);
+
+ if (ptrace(PTRACE_TRACEME, 0, NULL, NULL) != 0)
+ _exit(5);
+
+ _exit(0);
+ }
+
+ close(sync_pipe[0]);
+ ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+
+ ASSERT_EQ(1, write(sync_pipe[1], &ch, 1));
+ close(sync_pipe[1]);
+
+ ASSERT_EQ(child, waitpid(child, &status, 0));
+ ASSERT_TRUE(WIFEXITED(status));
+ EXPECT_EQ(0, WEXITSTATUS(status));
+}
+
+/*
+ * Verify a restricted parent owner cannot attach to a task in an untrimmed
+ * child userns even after that task drops the restricted capability from all
+ * of its own capability sets, since the child namespace itself remains less
+ * restricted than the tracer.
+ */
+TEST_F(userns_ptrace, owned_child_ns_dropped_task_caps)
+{
+ pid_t child;
+
+ child = start_tracee(self->tracees, tracee_child_ns_dropped_caps);
+ ASSERT_GT(child, 0);
+
+ ASSERT_EQ(0, drop_all_caps());
+ ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+
+ EXPECT_EQ(-EPERM, try_ptrace_attach(child));
+}
+
+/*
+ * Verify narrowing the userns capability ceiling preserves dumpability and the
+ * parent-death signal, while widening it resets both.
+ */
+TEST_F(userns_ptrace, ceiling_widening_resets_dumpable)
+{
+ int suid_dumpable = 0;
+ int pdeath_sig = 0;
+ FILE *f;
+
+ f = fopen("/proc/sys/fs/suid_dumpable", "r");
+ if (f) {
+ if (fscanf(f, "%d", &suid_dumpable) != 1)
+ suid_dumpable = 0;
+ fclose(f);
+ }
+
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_ADMIN, 0, 0));
+ ASSERT_EQ(0, prctl(PR_SET_SECUREBITS, SECBIT_CAP_USERNS_STRICT,
+ 0, 0, 0));
+
+ ASSERT_EQ(0, prctl(PR_SET_DUMPABLE, 1, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_SET_PDEATHSIG, SIGUSR1, 0, 0, 0));
+
+ /* Narrowing the ceiling preserves dumpable and parent-death signal */
+ ASSERT_EQ(0, prctl(PR_CAP_USERNS, PR_CAP_USERNS_LOWER,
+ CAP_NET_RAW, 0, 0));
+ EXPECT_EQ(1, prctl(PR_GET_DUMPABLE, 0, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_GET_PDEATHSIG, &pdeath_sig, 0, 0, 0));
+ EXPECT_EQ(SIGUSR1, pdeath_sig);
+
+ /*
+ * Clearing SECBIT_CAP_USERNS_STRICT widens the effective ceiling via
+ * cap_permitted, resetting both.
+ */
+ ASSERT_EQ(0, prctl(PR_SET_SECUREBITS, 0, 0, 0, 0));
+ EXPECT_EQ(suid_dumpable, prctl(PR_GET_DUMPABLE, 0, 0, 0, 0));
+ ASSERT_EQ(0, prctl(PR_GET_PDEATHSIG, &pdeath_sig, 0, 0, 0));
+ EXPECT_EQ(0, pdeath_sig);
+}
+
+/*
+ * Verify an unprivileged owner of an untrimmed child userns retains implicit
+ * capabilities (ptrace and setns) over a grandchild userns with an empty
+ * cap_bset, while setns() still clamps capabilities to the grandchild's
+ * cap_bset upon entry.
+ */
+TEST_F(userns_ptrace, owned_child_ns_trimmed_grandchild)
+{
+ char path[64];
+ pid_t child;
+ int ns_fd;
+
+ child = start_tracee(self->tracees, tracee_grandchild_ns_empty);
+ ASSERT_GT(child, 0);
+
+ ASSERT_EQ(0, drop_all_caps());
+ EXPECT_EQ(0, try_ptrace_attach(child));
+
+ snprintf(path, sizeof(path), "/proc/%d/ns/user", child);
+ ns_fd = open(path, O_RDONLY | O_CLOEXEC);
+ ASSERT_GE(ns_fd, 0);
+
+ ASSERT_EQ(0, setns(ns_fd, CLONE_NEWUSER));
+ close(ns_fd);
+
+ EXPECT_TRUE(cap_dropped(CAP_SYS_ADMIN));
+ EXPECT_TRUE(cap_dropped(CAP_NET_ADMIN));
+}
+
+TEST_HARNESS_MAIN
--
2.56.1.708.g77570a6a1d-goog
prev parent reply other threads:[~2026-11-19 10:42 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-19 10:42 [PATCH v2 0/4] userns: per-namespace capability bounding set Hallgrimur H. Gunnarsson
2026-11-19 10:42 ` [PATCH v2 1/4] userns: introduce capability bounding set for user namespaces Hallgrimur H. Gunnarsson
2026-11-19 10:42 ` [PATCH v2 2/4] capability: bound ptrace and cred subset checks by userns ceilings Hallgrimur H. Gunnarsson
2026-11-19 10:42 ` [PATCH v2 3/4] proc: expose userns capability mask as CapUns in /proc/<pid>/status Hallgrimur H. Gunnarsson
2026-11-19 10:42 ` Hallgrimur H. Gunnarsson [this message]
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=20261119104208.782900-5-halg@google.com \
--to=halg@google.com \
--cc=brauner@kernel.org \
--cc=casey@schaufler-ca.com \
--cc=containers@lists.linux.dev \
--cc=corbet@lwn.net \
--cc=dhowells@redhat.com \
--cc=gnoack@google.com \
--cc=jannh@google.com \
--cc=jarkko@kernel.org \
--cc=jcalmels@3xx0.net \
--cc=jmorris@namei.org \
--cc=kees@kernel.org \
--cc=keyrings@vger.kernel.org \
--cc=kpsingh@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-security-module@vger.kernel.org \
--cc=luto@kernel.org \
--cc=mic@digikod.net \
--cc=paul@paul-moore.com \
--cc=rdunlap@infradead.org \
--cc=sergeh@kernel.org \
--cc=skhan@linuxfoundation.org \
/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
all inboxes | Powered by JetHome®