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
