OpenVZ / Virtuozzo kernel development (devel@openvz.org)
 help / color / mirror / Atom feed
From: Mirian Shilakadze <mirian.shilakadze@virtuozzo.com>
To: khorenko@virtuozzo.com, ptikhomirov@virtuozzo.com
Cc: devel@openvz.org
Subject: [Devel] [PATCH vz10 v2 3/3] selftests/ve: test locking a mount from the host
Date: Mon, 16 Nov 2026 10:12:54 +0400	[thread overview]
Message-ID: <20261116061256.54472-4-mirian.shilakadze@virtuozzo.com> (raw)
In-Reply-To: <20261116061256.54472-1-mirian.shilakadze@virtuozzo.com>

Cover the MOUNT_ATTR_VE_LOCK_* protection locks. A forked task that owns
its user and mount namespace moves in a clone the host locked, the way
vzctl hands a container its bind mounts, and must not be able to clear
a locked protection or its lock, or lock a mount of its own. A bind it
makes keeps the locks. On the host, check that each lock bit locks its
own protection and no other, that a lock stands only where its
protection is set, that a protection lock cannot be dropped, that locks
are refused with AT_RECURSIVE, and that statmount() reports the locks.

Feature: ve: ve generic structures
https://virtuozzo.atlassian.net/browse/VSTOR-155305
Signed-off-by: Mirian Shilakadze <mirian.shilakadze@virtuozzo.com>
---
 tools/testing/selftests/ve/.gitignore         |   1 +
 tools/testing/selftests/ve/Makefile           |   1 +
 .../testing/selftests/ve/ve_mount_lock_test.c | 274 ++++++++++++++++++
 3 files changed, 276 insertions(+)
 create mode 100644 tools/testing/selftests/ve/ve_mount_lock_test.c

diff --git a/tools/testing/selftests/ve/.gitignore b/tools/testing/selftests/ve/.gitignore
index 3d1179bd2c5f..9b26fb05e342 100644
--- a/tools/testing/selftests/ve/.gitignore
+++ b/tools/testing/selftests/ve/.gitignore
@@ -4,3 +4,4 @@ ve_mount_accounting_test
 ve_cpuid_override_test
 ve_vtty_stress
 ve_numa_migrate_test
+ve_mount_lock_test
diff --git a/tools/testing/selftests/ve/Makefile b/tools/testing/selftests/ve/Makefile
index e96320a18384..57d688381f93 100644
--- a/tools/testing/selftests/ve/Makefile
+++ b/tools/testing/selftests/ve/Makefile
@@ -7,6 +7,7 @@ TEST_GEN_PROGS += ve_perms_test
 TEST_GEN_PROGS += ve_mount_accounting_test
 TEST_GEN_PROGS += ve_vtty_stress
 TEST_GEN_PROGS += ve_numa_migrate_test
+TEST_GEN_PROGS += ve_mount_lock_test
 
 # CPUID faulting is x86-64 only. ARCH says "x86" for 32-bit too and lib.mk
 # picks the clang target by its emptiness, so decide by the compiler.
diff --git a/tools/testing/selftests/ve/ve_mount_lock_test.c b/tools/testing/selftests/ve/ve_mount_lock_test.c
new file mode 100644
index 000000000000..b113aebe617d
--- /dev/null
+++ b/tools/testing/selftests/ve/ve_mount_lock_test.c
@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * ve_mount_lock selftests
+ *
+ * The host locks a mount with the MOUNT_ATTR_VE_LOCK_* attributes before it
+ * hands the mount over. A task that owns its user and mount namespace, as a
+ * container does, moves the mount in and must not be able to undo the locks.
+ */
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <sched.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/mount.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/wait.h>
+#include <linux/mount.h>
+
+#include "../kselftest_harness.h"
+#include "ve_selftest.h"
+
+#ifndef MOUNT_ATTR_VE_LOCK_RDONLY
+#define MOUNT_ATTR_VE_LOCK_RDONLY	0x8000000000000000ULL
+#define MOUNT_ATTR_VE_LOCK_NOSUID	0x4000000000000000ULL
+#define MOUNT_ATTR_VE_LOCK_NODEV	0x2000000000000000ULL
+#define MOUNT_ATTR_VE_LOCK_NOEXEC	0x1000000000000000ULL
+#define MOUNT_ATTR_VE_LOCK \
+	(MOUNT_ATTR_VE_LOCK_RDONLY | MOUNT_ATTR_VE_LOCK_NOSUID | \
+	 MOUNT_ATTR_VE_LOCK_NODEV | MOUNT_ATTR_VE_LOCK_NOEXEC)
+#endif
+
+#define SRC	"/tmp/src"
+#define DST	"/tmp/dst"
+#define DST2	"/tmp/dst2"
+
+#define PROTECTIONS (MOUNT_ATTR_RDONLY | MOUNT_ATTR_NOSUID | \
+		     MOUNT_ATTR_NODEV | MOUNT_ATTR_NOEXEC)
+
+static int setattr(int dfd, const char *path, unsigned int flags,
+		   __u64 set, __u64 clr)
+{
+	struct mount_attr attr = { .attr_set = set, .attr_clr = clr };
+
+	return syscall(__NR_mount_setattr, dfd, path, flags, &attr,
+		       sizeof(attr));
+}
+
+static int setattr_path(const char *path, __u64 set, __u64 clr)
+{
+	return setattr(AT_FDCWD, path, 0, set, clr);
+}
+
+static int move(int fd, const char *dst)
+{
+	return syscall(__NR_move_mount, fd, "", AT_FDCWD, dst,
+		       MOVE_MOUNT_F_EMPTY_PATH);
+}
+
+/* A detached clone of @path carrying @set, as the host hands a mount over. */
+static int handover(const char *path, __u64 set)
+{
+	int fd = syscall(__NR_open_tree, AT_FDCWD, path, OPEN_TREE_CLONE);
+
+	if (fd >= 0 && setattr(fd, "", AT_EMPTY_PATH, set, 0)) {
+		close(fd);
+		return -1;
+	}
+	return fd;
+}
+
+static int mnt_attr(const char *path, __u64 *attr)
+{
+	struct mnt_id_req req = {
+		.size = MNT_ID_REQ_SIZE_VER0,
+		.param = STATMOUNT_MNT_BASIC,
+	};
+	struct statmount sm;
+	struct statx sx;
+
+	if (statx(AT_FDCWD, path, 0, STATX_MNT_ID_UNIQUE, &sx))
+		return -1;
+	req.mnt_id = sx.stx_mnt_id;
+	if (syscall(__NR_statmount, &req, &sm, sizeof(sm), 0))
+		return -1;
+	*attr = sm.mnt_attr;
+	return 0;
+}
+
+/* Run @fn as container root once handover(SRC, @set) is moved onto DST. */
+static void in_ct(struct __test_metadata *_metadata,
+		  void (*fn)(struct __test_metadata *), __u64 set)
+{
+	int status;
+	pid_t pid;
+
+	pid = fork();
+	ASSERT_LE(0, pid);
+	if (pid == 0) {
+		int fd = handover(SRC, set);
+
+		if (fd < 0 || unshare(CLONE_NEWUSER | CLONE_NEWNS) ||
+		    write_file_at(AT_FDCWD, "/proc/self/setgroups", "deny") ||
+		    write_file_at(AT_FDCWD, "/proc/self/uid_map", "0 0 1") ||
+		    write_file_at(AT_FDCWD, "/proc/self/gid_map", "0 0 1") ||
+		    move(fd, DST)) {
+			perror("container setup");
+			_exit(1);
+		}
+		fn(_metadata);
+		_exit(_metadata->exit_code);
+	}
+	ASSERT_EQ(pid, waitpid(pid, &status, 0));
+	ASSERT_EQ(0, status);
+}
+
+FIXTURE(lock) {};
+
+FIXTURE_SETUP(lock)
+{
+	ASSERT_EQ(0, unshare(CLONE_NEWNS));
+	ASSERT_EQ(0, mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL));
+	ASSERT_EQ(0, mount("tmpfs", "/tmp", "tmpfs", 0, NULL));
+	ASSERT_EQ(0, mkdir(SRC, 0755));
+	ASSERT_EQ(0, mkdir(DST, 0755));
+	ASSERT_EQ(0, mkdir(DST2, 0755));
+}
+
+FIXTURE_TEARDOWN(lock)
+{
+}
+
+static void relax_unlocked(struct __test_metadata *_metadata)
+{
+	__u64 attr;
+
+	ASSERT_EQ(0, mount(NULL, DST, NULL, MS_REMOUNT | MS_BIND, NULL));
+	ASSERT_EQ(0, mnt_attr(DST, &attr));
+	EXPECT_EQ(0ULL, attr & MOUNT_ATTR_RDONLY);
+}
+
+/* Without a lock the container takes a read-only mount writable. */
+TEST_F(lock, unlocked_mount_is_relaxed)
+{
+	in_ct(_metadata, relax_unlocked, MOUNT_ATTR_RDONLY);
+}
+
+static void relax_locked(struct __test_metadata *_metadata)
+{
+	static const struct { unsigned long ms; __u64 attr; } prot[] = {
+		{ MS_RDONLY, MOUNT_ATTR_RDONLY },
+		{ MS_NOSUID, MOUNT_ATTR_NOSUID },
+		{ MS_NODEV, MOUNT_ATTR_NODEV },
+		{ MS_NOEXEC, MOUNT_ATTR_NOEXEC },
+	};
+	unsigned long all = MS_RDONLY | MS_NOSUID | MS_NODEV | MS_NOEXEC;
+	unsigned int i;
+	__u64 attr;
+
+	for (i = 0; i < ARRAY_SIZE(prot); i++) {
+		ASSERT_EQ(-1, mount(NULL, DST, NULL, MS_REMOUNT | MS_BIND |
+				    (all & ~prot[i].ms), NULL));
+		ASSERT_EQ(EPERM, errno);
+		ASSERT_EQ(-1, setattr_path(DST, 0, prot[i].attr));
+		ASSERT_EQ(EPERM, errno);
+	}
+	ASSERT_EQ(-1, setattr_path(DST, 0, MOUNT_ATTR_VE_LOCK_RDONLY));
+	ASSERT_EQ(EPERM, errno);
+	ASSERT_EQ(0, mnt_attr(DST, &attr));
+	EXPECT_EQ(PROTECTIONS, attr & PROTECTIONS);
+	EXPECT_EQ(MOUNT_ATTR_VE_LOCK, attr & MOUNT_ATTR_VE_LOCK);
+	EXPECT_EQ(0, setattr_path(DST, MOUNT_ATTR_NOSYMFOLLOW, 0));
+}
+
+/* No locked protection or lock can be cleared, other attributes can be set. */
+TEST_F(lock, locked_protections_hold)
+{
+	in_ct(_metadata, relax_locked, PROTECTIONS | MOUNT_ATTR_VE_LOCK);
+}
+
+static void lock_own(struct __test_metadata *_metadata)
+{
+	ASSERT_EQ(0, mount("tmpfs", DST2, "tmpfs", MS_RDONLY, NULL));
+	ASSERT_EQ(-1, setattr_path(DST2, MOUNT_ATTR_VE_LOCK, 0));
+	ASSERT_EQ(EPERM, errno);
+}
+
+/* The container cannot lock its own mounts. */
+TEST_F(lock, container_cannot_lock)
+{
+	in_ct(_metadata, lock_own, MOUNT_ATTR_RDONLY | MOUNT_ATTR_VE_LOCK);
+}
+
+static void bind_locked(struct __test_metadata *_metadata)
+{
+	ASSERT_EQ(0, mount(DST, DST2, NULL, MS_BIND, NULL));
+	ASSERT_EQ(-1, mount(NULL, DST2, NULL, MS_REMOUNT | MS_BIND, NULL));
+	ASSERT_EQ(EPERM, errno);
+}
+
+/* A bind keeps the protection locks. */
+TEST_F(lock, bind_keeps_protection_locks)
+{
+	in_ct(_metadata, bind_locked, MOUNT_ATTR_RDONLY | MOUNT_ATTR_VE_LOCK);
+}
+
+/* A protection lock stands only where its protection is set. */
+TEST_F(lock, lock_follows_protection)
+{
+	int fd = handover(SRC, MOUNT_ATTR_RDONLY);
+	__u64 attr;
+
+	ASSERT_GE(fd, 0);
+	ASSERT_EQ(0, move(fd, DST));
+	ASSERT_EQ(0, setattr_path(DST, MOUNT_ATTR_VE_LOCK, 0));
+	ASSERT_EQ(0, mnt_attr(DST, &attr));
+	EXPECT_EQ(MOUNT_ATTR_VE_LOCK_RDONLY, attr & MOUNT_ATTR_VE_LOCK);
+
+	ASSERT_EQ(0, setattr_path(DST, MOUNT_ATTR_NOSUID, 0));
+	EXPECT_EQ(0, setattr_path(DST, 0, MOUNT_ATTR_NOSUID));
+}
+
+/* Each lock bit locks its own protection and no other. */
+TEST_F(lock, one_lock_per_protection)
+{
+	static const struct { __u64 prot; __u64 lock; } pair[] = {
+		{ MOUNT_ATTR_RDONLY, MOUNT_ATTR_VE_LOCK_RDONLY },
+		{ MOUNT_ATTR_NOSUID, MOUNT_ATTR_VE_LOCK_NOSUID },
+		{ MOUNT_ATTR_NODEV, MOUNT_ATTR_VE_LOCK_NODEV },
+		{ MOUNT_ATTR_NOEXEC, MOUNT_ATTR_VE_LOCK_NOEXEC },
+	};
+	unsigned int i;
+	__u64 attr;
+
+	for (i = 0; i < ARRAY_SIZE(pair); i++) {
+		__u64 other = pair[(i + 1) % ARRAY_SIZE(pair)].prot;
+		int fd = handover(SRC, PROTECTIONS | pair[i].lock);
+
+		ASSERT_GE(fd, 0);
+		ASSERT_EQ(0, move(fd, DST));
+		close(fd);
+		ASSERT_EQ(0, mnt_attr(DST, &attr));
+		EXPECT_EQ(pair[i].lock, attr & MOUNT_ATTR_VE_LOCK);
+		ASSERT_EQ(-1, setattr_path(DST, 0, pair[i].prot));
+		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(0, setattr_path(DST, 0, other));
+		ASSERT_EQ(0, umount2(DST, 0));
+	}
+}
+
+/* Not even the host drops a protection lock or clears what it protects. */
+TEST_F(lock, host_cannot_unlock_protection)
+{
+	int fd = handover(SRC, MOUNT_ATTR_RDONLY | MOUNT_ATTR_VE_LOCK);
+
+	ASSERT_GE(fd, 0);
+	ASSERT_EQ(0, move(fd, DST));
+	ASSERT_EQ(-1, setattr_path(DST, 0, MOUNT_ATTR_VE_LOCK_RDONLY));
+	ASSERT_EQ(EINVAL, errno);
+	ASSERT_EQ(-1, setattr_path(DST, 0, MOUNT_ATTR_RDONLY));
+	ASSERT_EQ(EPERM, errno);
+}
+
+/* Locks change on the one mount named, never recursively. */
+TEST_F(lock, not_recursive)
+{
+	ASSERT_EQ(0, mount(SRC, DST, NULL, MS_BIND, NULL));
+	ASSERT_EQ(-1, setattr(AT_FDCWD, DST, AT_RECURSIVE,
+			      MOUNT_ATTR_VE_LOCK, 0));
+	EXPECT_EQ(EINVAL, errno);
+}
+
+TEST_HARNESS_MAIN
-- 
2.43.0

_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel

  parent reply	other threads:[~2026-11-16  6:14 UTC|newest]

Thread overview: 11+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-16  6:12 [Devel] [PATCH vz10 v2 0/3] fs: let the host lock the protection flags of a mount Mirian Shilakadze
2026-11-16  6:12 ` [Devel] [PATCH vz10 v2 1/3] fs: let the protection flags of a mount be locked from userspace Mirian Shilakadze
2026-11-16  6:24   ` no-reply
2026-11-16 17:13   ` Konstantin Khorenko
2026-11-16  6:12 ` [Devel] [PATCH vz10 v2 2/3] fs: report the locks of a mount in statmount() Mirian Shilakadze
2026-11-16  6:17   ` no-reply
2026-11-16 17:13   ` Konstantin Khorenko
2026-11-16  6:12 ` Mirian Shilakadze [this message]
2026-11-16  6:38   ` [Devel] [PATCH vz10 v2 3/3] selftests/ve: test locking a mount from the host no-reply
2026-11-16 17:13   ` Konstantin Khorenko
2026-11-16 17:13 ` [Devel] [PATCH vz10 v2 0/3] fs: let the host lock the protection flags of a mount Konstantin Khorenko

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=20261116061256.54472-4-mirian.shilakadze@virtuozzo.com \
    --to=mirian.shilakadze@virtuozzo.com \
    --cc=devel@openvz.org \
    --cc=khorenko@virtuozzo.com \
    --cc=ptikhomirov@virtuozzo.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