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 <[email protected]>
---
 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
[email protected]
https://lists.openvz.org/mailman/listinfo/devel

Reply via email to