From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.openvz.org (unknown [69.168.225.77]) by lore.virtuozzo.com (Postfix) with ESMTPS id DDBAD8015C for ; Tue, 15 Sep 2026 17:24:57 +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 68FHNcsh006512; Tue, 15 Sep 2026 20:23:39 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 68FHNcsh006512 Authentication-Results: mail.openvz.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=virtuozzo.com header.i=@virtuozzo.com header.b="aYjzHfA9" 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 68FHN48U006431 (version=TLSv1/SSLv3 cipher=AES128-GCM-SHA256 bits=128 verify=FAIL) for ; Tue, 15 Sep 2026 20:23:05 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 68FHN48U006431 Received: by mail-wr1-f69.google.com with SMTP id ffacd0b85a97d-4870af30a85so232672f8f.1 for ; Tue, 15 Sep 2026 10:23:04 -0700 (PDT) X-Gm-Message-State: AFuF++kWqYot9M0l6OuW5AYZzTe5iVG3oEgbLNRHWMJccM2PXqT3b5Y/ VdSeSlFKZwU+xVeYsiIqY94URSM4JkIQChxuXsRQKiWLaEpPWqr3J37a4MhI7s5k2FChtDrZ7At yODFjVyrLozxftUmncQjvqK8PsC0BxgzqmqxX1XU7Fh3brjGzIiA/8A== X-Gm-Gg: AYBFou2kfzsAqTMS1uCCa09KghRtRRCJQEcdarwbLsum0VY4aSZcaIYNPSjzjU3YdXO 3qYKbaNLNrZK6sIQ6dHnP6h9+baA5v2xY44polhAdPxGOpv+ByhQnBk8t6VRmKqrn9amXoiBv3y uxm+SCd5YQ8iZqr9YWkjARTdyWpW4nW0nSyKv+S8ssQibLOClyM0a4w7Z0H9hnXQ9jDgoRPsDxE MJX1vGF8idU+zxUoDP/UFDGp4pBZv6V8pkC9kp1LStjrMTMP734WL/yOaYiUF/xHcp+Rc+9O+AC yZgIXhXHXTu9DTBfWn/rf8j71/MASv13Y+YGOonmHAMKn9NjxtwUEvPuSQhkavVDzf4tp2SFfen b06sUp6/UnfK1P9dwircrvL6n7JEj8Q== X-Received: by 2002:a5d:6d2e:0:b0:486:fdd9:a0d9 with SMTP id ffacd0b85a97d-48705b9b96emr6035193f8f.20.1789492984554; Tue, 15 Sep 2026 10:23:04 -0700 (PDT) X-Received: by 2002:a5d:6d2e:0:b0:486:fdd9:a0d9 with SMTP id ffacd0b85a97d-48705b9b96emr6035145f8f.20.1789492983976; Tue, 15 Sep 2026 10:23:03 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1789492983; cv=none; d=google.com; s=arc-20260327; b=ZEY2lFZ7e/Fg2K5ZkhBw8m8LwJ9lBApDG2BS2Pyk5AqJC9tPW9lljDYRwvewQ2sPWM mG6Y/+brdM4PDjoLKPxrk4YwIaJqC2aWMjrZ19pzn6rG1t91iSsOXPbgsiXQPy8wUatG 99PJhyvfotVtUWV3N3ShU+9I7i0/N0+JaGRMJuD9js3eCbAm8/B+pb3h8gePop8oOqXl 1nb39jzVZzoKsdk8oYifEN+txcxpckcwdARjcOXWViDtP1KFqIKH2GsopIZLknpPDmKz zdcLcK9AXgw6jtbmSvbB3PreNzvJwhRkCex5ZKIZ5pPNDOrt0HMcM9VeEmjcK/oQRP9N KDjQ== 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=xcXqeKoH+ye2G62FtDzVUXLD387fHRm2WrXiWFNrnrg=; fh=QQvtjDaAlLft5IR2jnjma4lVp8TaaKU12WD0fWdFifQ=; b=k7VDOg2NUYeAraOxLd19W2k0YjCmjB+EB2HYPwlq5XJ7UdB/kBUby8xx043D/RbYKg 7uoj5pB0yi7C79gQgf5zyYcJjEz/5Z22MsfjdYqjRRlLIi6bqaXAct5HcsRAmPneZ2Z2 DPtvO8ycBtkDS/1q92YICx9PdjjLJDnDGZC3+JQqUJDvybSofKGwSoCiE+bwZM/4gO0X 3uiok8E79HXZ7y4Iq9HnERmqruRa60ec1vguDF9iLs7N1C/U9H/R+8y2EtITFnUaKcl0 5OKDAI7SFrq6Vau/CKvhlnxZ3lpLywlTPPQC3Y6wNGdQ9vZuIToZywhPGxngJGi0t1ic gUWg==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=relay header.b=aYjzHfA9; spf=pass (google.com: domain of vladimir.riabchun@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=vladimir.riabchun@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-4870beefee5si492915f8f.34.2026.09.15.10.23.03 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 15 Sep 2026 10:23:03 -0700 (PDT) Received-SPF: pass (google.com: domain of vladimir.riabchun@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=aYjzHfA9; spf=pass (google.com: domain of vladimir.riabchun@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=vladimir.riabchun@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=xcXqeKoH+ye2G62FtDzVUXLD387fHRm2WrXiWFNrnrg=; b=aYjzHfA9A7UJ JNjChYgybuOJ07GmIl7BXnqCDjtJOh8vJgfhf5vUTsNAhgIIvoyrjMMRJTTmW1jtpzCfaGxDix/up yjLTie/9G2QhHbZRoihMY0MeMWd4UneIszFmpaYfkUwCI1wFjNYWkVIQHeheq4K8k0+2bjD6b6+KY VR1P/WEQTsVXigRyi7/Xnj4PJK4oiKdK28WQ6u+qACyZuLm64QAfi9eV66/M2pj8vJop0jyo0Zfkd 69zdGMQeLkJfF6UYrMJ9h15lEYmh50l8lI29u3v38vqVYnBcmCW/KSW3c2uASQMeq0BepCMsPA5RD 7Lwxl42AP6uKLdTExrV+iQ==; Received: from [130.117.225.5] (helo=dev012.aci.vzint.dev) by relay.virtuozzo.com with esmtps (TLS1.3) tls TLS_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1x6WpK-00GSrt-1p; Tue, 15 Sep 2026 19:22:53 +0200 From: Vladimir Riabchun To: devel@openvz.org Date: Tue, 15 Sep 2026 17:22:36 +0000 Message-ID: <3d74194715f906abca9da70b881731a51025081e.1789491990.git.vladimir.riabchun@virtuozzo.com> X-Mailer: git-send-email 2.47.1 In-Reply-To: References: MIME-Version: 1.0 X-OZ-Fwd: true Subject: [Devel] [PATCH VZ10 v9 8/8] selftests/ve: Add mount accounting selftest 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 There are 6 test cases, covered in the new test: 1. Simple mount accouting correctness, just mount/umount. 2. Verification of correct limit hits and changes, including negative values. 3. Partial mounts test, when mount limit is hit in the middle of creation. 4. Test that enabled pseudosuper allows overuse. 5. Test that pseudosuper doesn't affect mount accounting. 6. Failcount feature verification. https://virtuozzo.atlassian.net/browse/VSTOR-135520 Feature: per-ve failcounters Signed-off-by: Vladimir Riabchun --- tools/testing/selftests/ve/.gitignore | 1 + tools/testing/selftests/ve/Makefile | 1 + .../selftests/ve/ve_mount_accounting_test.c | 550 ++++++++++++++++++ tools/testing/selftests/ve/ve_selftest.h | 21 + 4 files changed, 573 insertions(+) create mode 100644 tools/testing/selftests/ve/ve_mount_accounting_test.c diff --git a/tools/testing/selftests/ve/.gitignore b/tools/testing/selftests/ve/.gitignore index afa4c568c2c9..3df4d05888dc 100644 --- a/tools/testing/selftests/ve/.gitignore +++ b/tools/testing/selftests/ve/.gitignore @@ -1,2 +1,3 @@ ve_ns_owner_test ve_perms_test +ve_mount_accounting_test diff --git a/tools/testing/selftests/ve/Makefile b/tools/testing/selftests/ve/Makefile index ec40cbc7b3a1..c6efe7c4b4fb 100644 --- a/tools/testing/selftests/ve/Makefile +++ b/tools/testing/selftests/ve/Makefile @@ -4,5 +4,6 @@ CFLAGS += -g -Wall -O2 TEST_GEN_PROGS += ve_ns_owner_test TEST_GEN_PROGS += ve_perms_test +TEST_GEN_PROGS += ve_mount_accounting_test include ../lib.mk diff --git a/tools/testing/selftests/ve/ve_mount_accounting_test.c b/tools/testing/selftests/ve/ve_mount_accounting_test.c new file mode 100644 index 000000000000..6ba13dcdcc87 --- /dev/null +++ b/tools/testing/selftests/ve/ve_mount_accounting_test.c @@ -0,0 +1,550 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * ve_mount_accounting selftests + * + * Tests to check the correctness of mount accounting. + */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../kselftest_harness.h" +#include "ve_selftest.h" + +#define TMP_DIR "/ve-mnt-tmp/" +#define VE_MOUNTS_MAX 128 + +/* + * These values take a while to calculate, the first test will + * do this and store the values for those who come after. + */ +int *need_avail; + +FIXTURE(ve_mnt_acc) +{ + int cgv2_fd; + int ctid; + struct namespace_ctx ns_ctx; + int orig_have_mnt; +}; + +/* + * free_vfsmnt is called via call_rcu, so we need to ensure + * that all pending call_rcu tasks are finished. + * However, one barrier is not enough: + * mntput_no_expire + * init_task_work(&mnt->mnt_rcu, __cleanup_mnt); + * task_work_add(task, &mnt->mnt_rcu, TWA_RESUME) + * OR + * schedule_delayed_work(&delayed_mntput_work, 1) + * # Both later call cleanup_mnt + * cleanup_mnt + * call_rcu(&mnt->mnt_rcu, delayed_free_vfsmnt); + * + * We can't enforce workqueue flush from userspace, so instead + * read several times until the value is the one we expect. + */ +static int wait_on_mnt_avail(FIXTURE_DATA(ve_mnt_acc) * self, int expected) +{ +#define WAIT_TIMEOUT_NS (4096UL * 1000 * 1000) + char path_avail[64]; + int mnt_avail_nr = 0; + struct timespec delay = { .tv_nsec = 1000000 }; + + snprintf(path_avail, sizeof(path_avail), "%d/ve.mnt_avail_nr", self->ctid); + + while (delay.tv_nsec <= WAIT_TIMEOUT_NS) { + if (read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr)) { + fprintf(stderr, "Failed to read from %s\n", path_avail); + return 1; + } + if (mnt_avail_nr == expected) + return 0; + + do_rcu_barrier(); + if (nanosleep(&delay, NULL)) { + fprintf(stderr, "nanosleep failed: %s\n", strerror(errno)); + return 1; + } + delay.tv_nsec *= 2; + } + fprintf(stderr, "Didn't get expected value at %s\n", path_avail); + fprintf(stderr, "Expected %d, last read %d\n", expected, mnt_avail_nr); + return -1; +} + +static int set_pseudosuper(FIXTURE_DATA(ve_mnt_acc) * self, int value) +{ + char path[64]; + + snprintf(path, sizeof(path), "%d/ve.pseudosuper", self->ctid); + return write_u64_at(self->cgv2_fd, path, value); +} + +static int _create_mount(void *id_ptr) +{ + char path[PATH_MAX]; + int id = *(int *)id_ptr, ret; + + snprintf(path, sizeof(path), TMP_DIR "%d", id); + + if (mkdir(path, 0755) < 0) { + fprintf(stderr, "Failed to create directory %s: %s\n", path, strerror(errno)); + return -1; + } + ret = mount("tmpfs", path, "tmpfs", 0, "size=1M"); + if (!ret) + return 0; + fprintf(stderr, "Failed to mount tmpfs to %s: %s\n", path, strerror(errno)); + + rmdir(path); + return -1; +} + +/* Create a mount and wait until mount counter is valid */ +static int create_mount(FIXTURE_DATA(ve_mnt_acc) * self, int id) +{ + int ret, avail_before; + char path[64]; + + snprintf(path, sizeof(path), "%d/ve.mnt_avail_nr", self->ctid); + + if (read_s32_at(self->cgv2_fd, path, &avail_before)) { + fprintf(stderr, "Failed to read mnt_avail_nr in create_mount\n"); + return 1; + } + + ret = run_in_ve(self->cgv2_fd, self->ctid, &self->ns_ctx, + CLONE_NEWVE | CLONE_NEWNS, _create_mount, &id); + + if (ret) + wait_on_mnt_avail(self, avail_before); + else + ret = wait_on_mnt_avail(self, avail_before - 1); + return ret; +} + +static int _destroy_mount(void *id_ptr) +{ + char path[PATH_MAX]; + struct stat st; + int id = *(int *)id_ptr; + + snprintf(path, sizeof(path), TMP_DIR "%d", id); + + if (stat(path, &st)) + return 1; + if (umount(path)) { + fprintf(stderr, "failed to umount directory %s: %s\n", path, strerror(errno)); + return -1; + } + if (rmdir(path)) { + fprintf(stderr, "failed to remove directory %s: %s\n", path, strerror(errno)); + return -1; + } + return 0; +} + +/* Do umount and ensure that mnt_avail_nr is valid on exit(+1) */ +static int destroy_mount(FIXTURE_DATA(ve_mnt_acc) * self, int id) +{ + int ret, avail_before; + char path[64]; + + snprintf(path, sizeof(path), "%d/ve.mnt_avail_nr", self->ctid); + + if (read_s32_at(self->cgv2_fd, path, &avail_before)) { + fprintf(stderr, "Failed to read mnt_avail_nr in create_mount\n"); + return 1; + } + + ret = run_in_ve(self->cgv2_fd, self->ctid, &self->ns_ctx, + CLONE_NEWVE | CLONE_NEWNS, _destroy_mount, &id); + + /* Cost must be exactly 1 */ + if (!ret) + ret = wait_on_mnt_avail(self, avail_before + 1); + + return ret; +} + +#define MAX_MNT_ID 32 + +static int get_free_mnt_id(void) +{ + int i; + struct stat st; + char path[PATH_MAX]; + + for (i = 0; i < MAX_MNT_ID; i++) { + snprintf(path, sizeof(path), TMP_DIR "%d", i); + if (stat(path, &st)) + return i; + } + return -1; +} + +/* Returns 0 if mount failed OR mount cost is not 1 */ +static int try_mount(FIXTURE_DATA(ve_mnt_acc) * self) +{ + int mnt_id = get_free_mnt_id(); + + if (mnt_id < 0 || create_mount(self, mnt_id)) + return 0; + + return destroy_mount(self, mnt_id) == 0; +} + +/* + * Current kernel code first creates many mounts with ve_owner != ve0, + * so this VE needs more mounts than would be really consumed after commit_tree. + */ +static int get_required_avail_mnts(FIXTURE_DATA(ve_mnt_acc) * self) +{ + int l = 0, r = VE_MOUNTS_MAX + 1, mid; + char path_max_nr[64]; + + snprintf(path_max_nr, sizeof(path_max_nr), "%d/ve.mnt_max_nr", self->ctid); + + while (r - l > 1) { + mid = (l + r) / 2; + if (write_u64_at(self->cgv2_fd, path_max_nr, mid + self->orig_have_mnt)) + return -1; + + if (try_mount(self)) + r = mid; + else + l = mid; + } + if (r == VE_MOUNTS_MAX + 1) { + fprintf(stderr, "%s: %d avail mounts is not enough\n", __func__, r); + return -1; + } + if (write_u64_at(self->cgv2_fd, path_max_nr, VE_MOUNTS_MAX)) + return -1; + return r; +} + +/* Expect mount success and return new avail value */ +static int mount_and_get_avail(struct __test_metadata *_metadata, + FIXTURE_DATA(ve_mnt_acc) * self, int mnt_id) +{ + char path_avail[64]; + int mnt_avail_nr; + + snprintf(path_avail, sizeof(path_avail), "%d/ve.mnt_avail_nr", self->ctid); + + ASSERT_EQ(create_mount(self, mnt_id), 0); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr), 0); + return mnt_avail_nr; +} + +/* Expect mount failure and ensure intact avail number */ +static int check_mount_fails(struct __test_metadata *_metadata, + FIXTURE_DATA(ve_mnt_acc) * self, + int mnt_id, int avail_count) +{ + char path_avail[64]; + int mnt_avail_nr; + + snprintf(path_avail, sizeof(path_avail), "%d/ve.mnt_avail_nr", self->ctid); + + if (read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr)) + return 1; + if (mnt_avail_nr != avail_count) { + fprintf(stderr, "%s: mnt_avail(%d) != avail_count(%d) before mount\n", + __func__, mnt_avail_nr, avail_count); + return -1; + } + + if (create_mount(self, mnt_id) == 0) { + fprintf(stderr, "%s: successful mount\n", __func__); + return -1; + } + + if (read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr)) + return 1; + if (mnt_avail_nr != avail_count) { + fprintf(stderr, "%s: mnt_avail(%d) != avail_count(%d) after mount\n", + __func__, mnt_avail_nr, avail_count); + return -1; + } + return 0; +} + +FIXTURE_SETUP(ve_mnt_acc) +{ + int initial_mnt_avail_nr; + char path[64]; + + self->cgv2_fd = mount_cg2_fd(); + ASSERT_GE(self->cgv2_fd, 0); + mkdir(TMP_DIR, 0755); + + ASSERT_EQ(write_file_at(self->cgv2_fd, "cgroup.subtree_control", + VE_CONTROLLERS), 0); + + self->ctid = make_ve(self->cgv2_fd, CTID_MIN); + ASSERT_GE(self->ctid, 0); + + snprintf(path, sizeof(path), "%d/ve.mnt_max_nr", self->ctid); + ASSERT_EQ(write_u64_at(self->cgv2_fd, path, VE_MOUNTS_MAX), 0); + + /* + * The new ve cgroup has not been entered by anything yet, so its + * mnt_avail_nr counter should be VE_MOUNTS_MAX. + */ + snprintf(path, sizeof(path), "%d/ve.mnt_avail_nr", self->ctid); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path, &initial_mnt_avail_nr), 0); + ASSERT_EQ(initial_mnt_avail_nr, VE_MOUNTS_MAX); + + ASSERT_EQ(prepare_namespaces(&self->ns_ctx, CLONE_NEWNS | CLONE_NEWVE, + self->cgv2_fd, self->ctid), 0); + + ASSERT_EQ(read_s32_at(self->cgv2_fd, path, &initial_mnt_avail_nr), 0); + self->orig_have_mnt = VE_MOUNTS_MAX - initial_mnt_avail_nr; + + /* Calculate once - it is time-consuming */ + if (*need_avail == -1) + *need_avail = get_required_avail_mnts(self); + + ASSERT_GE(*need_avail, 1); + /* try_mount ensures cost is 1 */ + ASSERT_EQ(try_mount(self), 1); +}; + +FIXTURE_TEARDOWN(ve_mnt_acc) +{ + for (int i = 0; i < MAX_MNT_ID; i++) + _destroy_mount((void *)&i); + + close_namespace_fds(&self->ns_ctx); + destroy_ve(self->cgv2_fd, self->ctid); + close(self->cgv2_fd); + rmdir(TMP_DIR); +} + +/* Simple test to check mount/umount accounting correctness */ +TEST_F(ve_mnt_acc, mount_umount) +{ + int original_mnt_avail, mnt_avail_nr; + char path[64]; + + snprintf(path, sizeof(path), "%d/ve.mnt_avail_nr", self->ctid); + + ASSERT_EQ(read_s32_at(self->cgv2_fd, path, &original_mnt_avail), 0); + + ASSERT_LT(mount_and_get_avail(_metadata, self, 0), + original_mnt_avail); + + ASSERT_EQ(destroy_mount(self, 0), 0); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path, &mnt_avail_nr), 0); + ASSERT_EQ(mnt_avail_nr, original_mnt_avail); +} + +/* Test mount limit hits */ +TEST_F(ve_mnt_acc, hit_limits) +{ + int mnt_avail_nr; + char path_avail[64], path_max_nr[64]; + + snprintf(path_avail, sizeof(path_avail), "%d/ve.mnt_avail_nr", self->ctid); + snprintf(path_max_nr, sizeof(path_max_nr), "%d/ve.mnt_max_nr", self->ctid); + + /* Step 1: reduce number of available mounts to *need_avail */ + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, + self->orig_have_mnt + 1 * (*need_avail)), 0); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr), 0); + ASSERT_EQ(mnt_avail_nr, 1 * *need_avail); + + /* Step 2: do one mount, no mounts should be available */ + ASSERT_EQ(mount_and_get_avail(_metadata, self, 0), *need_avail - 1); + + /* Step 3: check that one more mount fails */ + ASSERT_EQ(check_mount_fails(_metadata, self, 1, (*need_avail) - 1), 0); + + /* Step 4: increase by 1 and win now */ + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, + self->orig_have_mnt + 1 + *need_avail), 0); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr), 0); + ASSERT_EQ(mnt_avail_nr, *need_avail); + + ASSERT_EQ(mount_and_get_avail(_metadata, self, 1), *need_avail - 1); + + /* Step 5: reduce mnt_max_nr so we have more mounts than allowed */ + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, + self->orig_have_mnt + 1), 0); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr), 0); + ASSERT_EQ(mnt_avail_nr, -1); + + /* Step 6: try to do mount when avail < 0, ensure number is intact */ + ASSERT_EQ(check_mount_fails(_metadata, self, 2, -1), 0); + + /* Step 7: remove one mount, check avail value update, mount should fail */ + ASSERT_EQ(destroy_mount(self, 0), 0); + ASSERT_EQ(check_mount_fails(_metadata, self, 2, 0), 0); + + /* Step 8: remove one more mount and check that new mount succeeds */ + ASSERT_EQ(destroy_mount(self, 1), 0); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr), 0); + ASSERT_EQ(mnt_avail_nr, 1); + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, self->orig_have_mnt + *need_avail), 0); + ASSERT_EQ(mount_and_get_avail(_metadata, self, 2), *need_avail - 1); + + ASSERT_EQ(destroy_mount(self, 2), 0); +} + +/* + * Mount propagation makes one mount cost more. + * This test checks that if we run out of mounts in the middle of creating + * a new one, everything is restored smoothly and nothing leaks. + */ +TEST_F(ve_mnt_acc, partial_mounts) +{ + char path_avail[64], path_max_nr[64]; + int i; + + snprintf(path_max_nr, sizeof(path_max_nr), "%d/ve.mnt_max_nr", self->ctid); + snprintf(path_avail, sizeof(path_avail), "%d/ve.mnt_avail_nr", self->ctid); + + if (*need_avail == 1) + SKIP(return, "mount cost is 1, no partial mounts possible"); + + for (i = 0; i < *need_avail; i++) { + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, self->orig_have_mnt + i), 0); + ASSERT_EQ(check_mount_fails(_metadata, self, 0, i), 0); + } +} + +/* Test that pseudosuper allows negative avail with correct accounting. */ +TEST_F(ve_mnt_acc, pseudosuper_allows_overuse) +{ + char path_max_nr[64]; + + snprintf(path_max_nr, sizeof(path_max_nr), "%d/ve.mnt_max_nr", self->ctid); + + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, self->orig_have_mnt + *need_avail), 0); + ASSERT_EQ(set_pseudosuper(self, 1), 0); + + ASSERT_EQ(mount_and_get_avail(_metadata, self, 0), *need_avail - 1); + ASSERT_EQ(mount_and_get_avail(_metadata, self, 1), *need_avail - 2); + + /* Go below zero */ + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, self->orig_have_mnt), 0); + ASSERT_EQ(mount_and_get_avail(_metadata, self, 2), -3); + + ASSERT_EQ(set_pseudosuper(self, 0), 0); + + /* Below zero should fail */ + ASSERT_EQ(check_mount_fails(_metadata, self, 3, -3), 0); + /* Now need 2 more to add a new mount */ + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, + self->orig_have_mnt + 3 + *need_avail - 2), 0); + ASSERT_EQ(check_mount_fails(_metadata, self, 3, *need_avail - 2), 0); + + ASSERT_EQ(destroy_mount(self, 0), 0); + ASSERT_EQ(check_mount_fails(_metadata, self, 3, *need_avail - 1), 0); + ASSERT_EQ(destroy_mount(self, 2), 0); + + ASSERT_EQ(try_mount(self), 1); +} + +/* Test that pseudosuper doesn't disable accounting. */ +TEST_F(ve_mnt_acc, pseudosuper_continues_accounting) +{ + int orig_mnt_avail, mnt_avail_nr; + char path_avail[64]; + + snprintf(path_avail, sizeof(path_avail), "%d/ve.mnt_avail_nr", self->ctid); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path_avail, &orig_mnt_avail), 0); + + ASSERT_EQ(set_pseudosuper(self, 0), 0); + + /* mnt 0 - mounted without pseudosuper, umounted with it. */ + ASSERT_EQ(mount_and_get_avail(_metadata, self, 0), orig_mnt_avail - 1); + ASSERT_EQ(set_pseudosuper(self, 1), 0); + + /* Cost is the same when mount/umount happen under pseudosuper. */ + ASSERT_EQ(try_mount(self), 1); + + /* mnt 1 - mounted with pseudosuper, umounted without it. */ + ASSERT_EQ(mount_and_get_avail(_metadata, self, 1), + orig_mnt_avail - 2); + + ASSERT_EQ(destroy_mount(self, 0), 0); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr), 0); + ASSERT_EQ(mnt_avail_nr, orig_mnt_avail - 1); + + ASSERT_EQ(set_pseudosuper(self, 0), 0); + + ASSERT_EQ(destroy_mount(self, 1), 0); + ASSERT_EQ(read_s32_at(self->cgv2_fd, path_avail, &mnt_avail_nr), 0); + ASSERT_EQ(mnt_avail_nr, orig_mnt_avail); +} + +/* Test failcount feature */ +TEST_F(ve_mnt_acc, failcount) +{ + char path_fc[64], failcount_str[512], path_max_nr[64]; + + snprintf(path_fc, sizeof(path_fc), "%d/ve.failcount", self->ctid); + snprintf(path_max_nr, sizeof(path_max_nr), "%d/ve.mnt_max_nr", self->ctid); + + ASSERT_GE(read_file_at(self->cgv2_fd, path_fc, + failcount_str, sizeof(failcount_str)), 0); + ASSERT_TRUE(strstr(failcount_str, "mnt: 0\n") != NULL); + + /* Check successful mount doesn't affect failcount */ + mount_and_get_avail(_metadata, self, 0); + ASSERT_GE(read_file_at(self->cgv2_fd, path_fc, + failcount_str, sizeof(failcount_str)), 0); + ASSERT_TRUE(strstr(failcount_str, "mnt: 0\n") != NULL); + ASSERT_EQ(destroy_mount(self, 0), 0); + + /* Check failcount update when mount fails */ + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, 0), 0); + ASSERT_LT(create_mount(self, 1), 0); + ASSERT_GE(read_file_at(self->cgv2_fd, path_fc, + failcount_str, sizeof(failcount_str)), 0); + ASSERT_TRUE(strstr(failcount_str, "mnt: 1\n") != NULL); + + /* Check failcount flush */ + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_fc, 0), 0); + ASSERT_GE(read_file_at(self->cgv2_fd, path_fc, + failcount_str, sizeof(failcount_str)), 0); + ASSERT_TRUE(strstr(failcount_str, "mnt: 0\n") != NULL); + + /* Check failcount update when mount fails again */ + ASSERT_EQ(write_u64_at(self->cgv2_fd, path_max_nr, 0), 0); + ASSERT_LT(create_mount(self, 1), 0); + ASSERT_GE(read_file_at(self->cgv2_fd, path_fc, + failcount_str, sizeof(failcount_str)), 0); + ASSERT_TRUE(strstr(failcount_str, "mnt: 1\n") != NULL); +} + +int main(int argc, char **argv) +{ + need_avail = mmap(NULL, sizeof(int), + PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); + + if (need_avail == MAP_FAILED) { + fprintf(stderr, "Failed to mmap shared region: %s\n", strerror(errno)); + return 1; + } + *need_avail = -1; + + return test_harness_run(argc, argv); +} diff --git a/tools/testing/selftests/ve/ve_selftest.h b/tools/testing/selftests/ve/ve_selftest.h index bf9b89b59a6c..8cc9b3238aaf 100644 --- a/tools/testing/selftests/ve/ve_selftest.h +++ b/tools/testing/selftests/ve/ve_selftest.h @@ -413,4 +413,25 @@ static inline int is_mounted(const char *path) return errno == EXDEV ? 1 : -1; } +static inline int do_rcu_barrier(void) +{ + int fd; + + errno = 0; + fd = open("/sys/module/rcutree/parameters/do_rcu_barrier", O_WRONLY); + + if (fd < 0) { + fprintf(stderr, "Failed to open do_rcu_barrier: %s\n", strerror(errno)); + return -1; + } + errno = 0; + if (write(fd, "1", 2) != 2) { + fprintf(stderr, "Failed to issue rcu_barrier: %s\n", strerror(errno)); + close(fd); + return -1; + } + close(fd); + return 0; +} + #endif /* __SELFTESTS_VE_VE_SELFTEST_H */ -- 2.47.1 _______________________________________________ Devel mailing list Devel@openvz.org https://lists.openvz.org/mailman/listinfo/devel