[Devel] [PATCH VZ10 v9 8/8] selftests/ve: Add mount accounting selftest

[Vladimir Riabchun <vladimir.riabchun@virtuozzo.com>]

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 <vladimir.riabchun@virtuozzo.com>
---
 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 <asm/unistd.h>
+#include <linux/sched.h>
+#include <linux/limits.h>
+#include <sys/wait.h>
+#include <sys/syscall.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+
+#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