From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.openvz.org (mail.openvz.org [69.168.225.77]) by lore.virtuozzo.com (Postfix) with ESMTPS id 9C2EC817C6 for ; Mon, 16 Nov 2026 06:14:33 +0000 (UTC) Received: from mail.openvz.org (localhost [127.0.0.1]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6AG6DJq1020492; Mon, 16 Nov 2026 09:13:20 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6AG6DJq1020492 Authentication-Results: mail.openvz.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=virtuozzo.com header.i=@virtuozzo.com header.b="fWCPjKmm" Received: from mail-wr1-f69.google.com (mail-wr1-f69.google.com [209.85.221.69]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6AG6D9Iv020470 (version=TLSv1/SSLv3 cipher=AES128-GCM-SHA256 bits=128 verify=FAIL) for ; Mon, 16 Nov 2026 09:13:09 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6AG6D9Iv020470 Received: by mail-wr1-f69.google.com with SMTP id ffacd0b85a97d-492e3189fc9so1940693f8f.1 for ; Sun, 15 Nov 2026 22:13:09 -0800 (PST) X-Gm-Message-State: APuU4Z9dccL01t7bCSV8pqrQ4CNnGVnKVl2g34z30nxrebpQ8Z6/kkUZ Ar2O7te1HOPwiSvLmaL8q3nA9K5/Zkv0WeFYWSPo7AW6z8lPnqIv14por/6lpZoGmZ91VVflH7O 7TpKgdAuryarJ/DPt6OcBQsVMIaSxgWf3MP576kl67A21Hs7fkLGA5Q== X-Gm-Gg: AYBFou1Y1ZrE/xqHnlGft/3JDLZ7ycTvZW+OR29U0u9lYbwi3VK0PrDpdeex+pspp4+ gTs2J4QSV5A8coUyWUa+mOnb027S1doITxgZ5OdhN8+OIAOqkRaMaY1JCctJqwCnDc0fZg8QepZ uQZzzXDUUshADqUVZHquEzmSBYyp8zZqzRMnVgOC9/cw60EngEj0VXGOY3EKQQwCkG/7fDR+Qvi edYw5O3Ee2EKi2zD2qEQO/rJU/VCjVFisrx6y4/cv9WLMBuum5q0pTlHfcWZG1zSJKHejN+O27u f/k2Sft5E6aUNbiKf2eKzT6ECZey7lk0M2REWItKaP/aN/+Hw+skZidi4N2Kg4A1GdrPlCbwh4C a5wc2uhoj5V8BQ5EKVEB2+0eBC6Ka X-Received: by 2002:a05:600c:8518:b0:4bb:5de1:e90f with SMTP id 5b1f17b1804b1-4bb5de1f1fdmr173868545e9.31.1794809589364; Sun, 15 Nov 2026 22:13:09 -0800 (PST) X-Received: by 2002:a05:600c:8518:b0:4bb:5de1:e90f with SMTP id 5b1f17b1804b1-4bb5de1f1fdmr173868045e9.31.1794809588762; Sun, 15 Nov 2026 22:13:08 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1794809588; cv=none; d=google.com; s=arc-20260327; b=KR1uJRZGSLm96mh85VHlf8muDOOHw/YqemOluePB858HFKosGoLlQ5CHyhxly36pXw iTRPsnU4dqoxhSHVlPbPqlZyQ3NCXgPA0sEO3gpC1x+28W4JMyRZS+j7KPLyrm+wpwxK cJ4GX1pXxUJoVywiU9ric0aONh4xtLJ6qYWsnDPG7dpuOR5KkRPE3TtNB+dmXDjCQBsG SGz083K7ahYX35UcISVMxsHSyap1B6npZ7swWO4P6trhAtyw/iv+CM47UcaG37XJhJhU xnGzFAQPLEPijPJ+l27996eNLerkeq1sDQxWinIUSNxIgdTcE0wNBqcFUYjqd50Dq953 /t5g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20260327; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=GR1d1GhHTs5S8/mASWdx47CM6NLX6ljXyAwdo2uGCLo=; fh=wpoNUURlquLpJK/14Kny0oMIYkY7mYwjJ/Ils9UT2kk=; b=ZRPulg/lVDDwepqR9NpJhZkR9rbP3TnMfgHuFc+SrQvcZIfAz3lA5li+YdOSH1p7re sJUDGnZytZyCRQjHDUuSyZrE8mikODWvmaw5wBzzQ+rtxt4zcx022su0KGvvCVZYiTvF Ld2w0RcNGa7UgJ1b/zy51q6KE10JnF6hyUQB+3U1cShU5ljz//C92zObTLfSlyP7dKEh qzh7X1M606bJWhVRx3aNm+F9aWsEKxw57aibZi8VFqz1Qi6MLnCxrhAFZ3xI4IfQs1xM 0drrTrTICHhC2RBcXoQz+RwcJZB+cM5TwIGWNmQenYmvdBSqjzvNQEcGV3NU/+V/+l0q +hhw==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=relay header.b=fWCPjKmm; spf=pass (google.com: domain of mirian.shilakadze@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=mirian.shilakadze@virtuozzo.com; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=virtuozzo.com Received: from relay.virtuozzo.com (relay.virtuozzo.com. [130.117.225.111]) by mx.google.com with ESMTPS id ffacd0b85a97d-49c650cbfd6si19835458f8f.486.2026.11.15.22.13.08 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 15 Nov 2026 22:13:08 -0800 (PST) Received-SPF: pass (google.com: domain of mirian.shilakadze@virtuozzo.com designates 130.117.225.111 as permitted sender) client-ip=130.117.225.111; Authentication-Results: mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=relay header.b=fWCPjKmm; spf=pass (google.com: domain of mirian.shilakadze@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=mirian.shilakadze@virtuozzo.com; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=virtuozzo.com DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=virtuozzo.com; s=relay; h=MIME-Version:Message-ID:Date:Subject:From: Content-Type; bh=GR1d1GhHTs5S8/mASWdx47CM6NLX6ljXyAwdo2uGCLo=; b=fWCPjKmmUmTt 1rSLObsuar3cm/OcXTJEEaP9Q3+1fJVSy/RIUTUCP7A32ClQ4wPEDr92FCkc517+qIu49wWrGbki2 DShJmsn3sExqjgiQDdjLIxvKnMnz08kc+r0ImHCk+fIg/eE+357LyzijSxaRzB+u6a1pgx7mwn7kQ TPypXhYJBlafAFQypRld2Q0lvTwmCkskAaM/R47cJoTjSIWSk1ttXwwsAMDnjUovjMexEV1MRyHwS CGCWKh4igTsyGwQNvRjs3UUeshOL1XMB8lhaB3JZN6lYqCjsdtFgJ1sVmJ4n2NsUhP0NzIS6/ioOz iuK97Sh0CRS7LrzH5CG7nw==; Received: from ch-demo-asa.virtuozzo.com ([130.117.225.8] helo=localhost.localdomain) by relay.virtuozzo.com with esmtp (Exim 4.96) (envelope-from ) id 1xSptV-00Cj8x-2Z; Mon, 16 Nov 2026 07:13:00 +0100 From: Mirian Shilakadze To: khorenko@virtuozzo.com, ptikhomirov@virtuozzo.com Date: Mon, 16 Nov 2026 10:12:54 +0400 Message-ID: <20261116061256.54472-4-mirian.shilakadze@virtuozzo.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20261116061256.54472-1-mirian.shilakadze@virtuozzo.com> References: <20261116061256.54472-1-mirian.shilakadze@virtuozzo.com> MIME-Version: 1.0 X-OZ-Fwd: true Cc: devel@openvz.org Subject: [Devel] [PATCH vz10 v2 3/3] selftests/ve: test locking a mount from the host X-BeenThere: devel@openvz.org X-Mailman-Version: 2.1.12 Precedence: list List-Id: OpenVZ development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: devel-bounces@openvz.org Errors-To: devel-bounces@openvz.org 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 --- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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