From: Pavel Tikhomirov <ptikhomirov@virtuozzo.com>
To: Konstantin Khorenko <khorenko@virtuozzo.com>
Cc: devel@openvz.org
Subject: [Devel] [PATCH hci-8.1 2/2] selftests/ve: check the AIO ring size in a pseudosuper VE
Date: Fri, 13 Nov 2026 16:08:45 +0100 [thread overview]
Message-ID: <20261113-pr-ptikhomirov-vstor-154129-aio-pseudosuper-ring-v1-2-7d35d143fdc3@virtuozzo.com> (raw)
In-Reply-To: <20261113-pr-ptikhomirov-vstor-154129-aio-pseudosuper-ring-v1-0-7d35d143fdc3@virtuozzo.com>
Check that the host and a VE keep the CPU heuristic of the io_setup()
ring and a pseudosuper VE skips it, and that io_setup((nr - 2) / 2)
there gives back a ring of nr events for rings of 1 to 4 pages.
The rings differ only when the CPU heuristic makes a one-page ring
bigger, e.g. with 16 possible CPUs and 4K pages, else the test is
skipped. Before the fix the pseudosuper tests fail on 16 CPUs with a
ring of 255 events instead of 127.
https://virtuozzo.atlassian.net/browse/VSTOR-154129
Feature: ve: CRIU support
Signed-off-by: Pavel Tikhomirov <ptikhomirov@virtuozzo.com>
---
tools/testing/selftests/ve/.gitignore | 1 +
tools/testing/selftests/ve/Makefile | 1 +
tools/testing/selftests/ve/ve_aio_ring_test.c | 214 ++++++++++++++++++++++++++
3 files changed, 216 insertions(+)
diff --git a/tools/testing/selftests/ve/.gitignore b/tools/testing/selftests/ve/.gitignore
index 3d1179bd2c5f4..2ff027048a6ae 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_aio_ring_test
diff --git a/tools/testing/selftests/ve/Makefile b/tools/testing/selftests/ve/Makefile
index e96320a183844..124b4a918016c 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_aio_ring_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_aio_ring_test.c b/tools/testing/selftests/ve/ve_aio_ring_test.c
new file mode 100644
index 0000000000000..c370941574224
--- /dev/null
+++ b/tools/testing/selftests/ve/ve_aio_ring_test.c
@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * ve_aio_ring selftest
+ *
+ * io_setup() makes the ring at least 4 events per possible CPU. CRIU
+ * restores a ring with io_setup() and needs the size it had on dump, so
+ * a VE in pseudosuper mode (restore) gets the ring of exactly the size
+ * asked for. The tests check that:
+ *
+ * - the host keeps the CPU heuristic
+ * - a VE keeps the CPU heuristic
+ * - a VE in pseudosuper mode skips the CPU heuristic
+ * - a VE in pseudosuper mode gets a ring of nr events from
+ * io_setup((nr - 2) / 2), for rings of 1 to 4 pages
+ *
+ * The rings differ only when the CPU heuristic makes a small ring bigger,
+ * e.g. with 16 possible CPUs and 4K pages, else the test is skipped.
+ */
+#define _GNU_SOURCE
+#include <sched.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <linux/aio_abi.h>
+
+#include "../kselftest_harness.h"
+#include "ve_selftest.h"
+
+/* The ring header mapped by io_setup(), a copy of the one in fs/aio.c. */
+struct aio_ring {
+ unsigned int id;
+ unsigned int nr; /* ring capacity in io_events */
+ unsigned int head;
+ unsigned int tail;
+ unsigned int magic;
+ unsigned int compat_features;
+ unsigned int incompat_features;
+ unsigned int header_length;
+ struct io_event io_events[];
+};
+
+#define PAGE_ALIGN(size, ps) (((size) + ((ps) - 1)) & ~((ps) - 1))
+
+/* The biggest ring, in pages, the pseudosuper restore test covers. */
+#define RING_PAGES_MAX 4
+
+struct aio_ring_arg {
+ unsigned int nr_events; /* in: io_setup() nr_events */
+ unsigned int ring_nr; /* out: ring capacity, struct aio_ring::nr */
+};
+
+FIXTURE(ve_aio_ring)
+{
+ int cgv2_fd;
+ int ctid;
+ struct namespace_ctx ns_ctx;
+ unsigned int cpus;
+ unsigned long page_size;
+ struct aio_ring_arg *arg; /* shared with the child in the VE */
+};
+
+/* The ring capacity aio_setup_ring() makes for @nr_events. */
+static unsigned int calculate_ring_nr(FIXTURE_DATA(ve_aio_ring) * self,
+ unsigned int nr_events)
+{
+ unsigned long size;
+
+ size = sizeof(struct aio_ring) + (nr_events + 2) * sizeof(struct io_event);
+ size = PAGE_ALIGN(size, self->page_size);
+ return (size - sizeof(struct aio_ring)) / sizeof(struct io_event);
+}
+
+/* The ring capacity io_setup(@nr_events) makes. */
+static unsigned int ring_nr(FIXTURE_DATA(ve_aio_ring) * self,
+ unsigned int nr_events)
+{
+ unsigned int cpu_events = self->cpus * 4;
+
+ if (nr_events < cpu_events)
+ nr_events = cpu_events;
+ return calculate_ring_nr(self, 2 * nr_events);
+}
+
+/* The ring capacity io_setup(@nr_events) makes without the CPU heuristic. */
+static unsigned int ring_nr_pseudosuper(FIXTURE_DATA(ve_aio_ring) * self,
+ unsigned int nr_events)
+{
+ return calculate_ring_nr(self, 2 * nr_events);
+}
+
+/* Create an AIO context of arg->nr_events, store its ring capacity. */
+static int aio_ring_nr(void *data)
+{
+ struct aio_ring_arg *arg = data;
+ aio_context_t ctx = 0;
+
+ if (syscall(__NR_io_setup, arg->nr_events, &ctx)) {
+ fprintf(stderr, "%s: io_setup(%u): %s\n", __func__,
+ arg->nr_events, strerror(errno));
+ return -1;
+ }
+ arg->ring_nr = ((struct aio_ring *)ctx)->nr;
+
+ if (syscall(__NR_io_destroy, ctx)) {
+ fprintf(stderr, "%s: io_destroy: %s\n", __func__,
+ strerror(errno));
+ return -1;
+ }
+ return 0;
+}
+
+/* The ring capacity io_setup(@nr_events) makes in the VE, or 0. */
+static unsigned int ve_ring_nr(FIXTURE_DATA(ve_aio_ring) * self,
+ unsigned int nr_events)
+{
+ self->arg->nr_events = nr_events;
+ self->arg->ring_nr = 0;
+ if (run_in_ve(self->cgv2_fd, self->ctid, &self->ns_ctx, CLONE_NEWVE,
+ aio_ring_nr, self->arg))
+ return 0;
+ return self->arg->ring_nr;
+}
+
+static int set_pseudosuper(FIXTURE_DATA(ve_aio_ring) * self, int value)
+{
+ char path[64];
+
+ snprintf(path, sizeof(path), "%d/ve.pseudosuper", self->ctid);
+ return write_u64_at(self->cgv2_fd, path, value);
+}
+
+FIXTURE_SETUP(ve_aio_ring)
+{
+ long cpus;
+
+ self->ctid = -1;
+ self->arg = MAP_FAILED;
+
+ self->page_size = sysconf(_SC_PAGESIZE);
+ cpus = sysconf(_SC_NPROCESSORS_CONF);
+ ASSERT_GT(cpus, 0);
+ self->cpus = cpus;
+ if (ring_nr(self, 1) == ring_nr_pseudosuper(self, 1))
+ SKIP(return, "%u possible CPUs are too few for the CPU heuristic to matter",
+ self->cpus);
+
+ self->arg = mmap(NULL, sizeof(*self->arg), PROT_READ | PROT_WRITE,
+ MAP_SHARED | MAP_ANONYMOUS, -1, 0);
+ ASSERT_NE(self->arg, MAP_FAILED);
+
+ self->cgv2_fd = mount_cg2_fd();
+ ASSERT_GE(self->cgv2_fd, 0);
+
+ 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);
+
+ ASSERT_EQ(prepare_namespaces(&self->ns_ctx, CLONE_NEWVE,
+ self->cgv2_fd, self->ctid), 0);
+}
+
+FIXTURE_TEARDOWN(ve_aio_ring)
+{
+ if (self->ctid >= 0) {
+ set_pseudosuper(self, 0);
+ close_namespace_fds(&self->ns_ctx);
+ destroy_ve(self->cgv2_fd, self->ctid);
+ close(self->cgv2_fd);
+ }
+ if (self->arg != MAP_FAILED)
+ munmap(self->arg, sizeof(*self->arg));
+}
+
+TEST_F(ve_aio_ring, host_keeps_cpu_heuristic)
+{
+ self->arg->nr_events = 1;
+ EXPECT_EQ(aio_ring_nr(self->arg), 0);
+ EXPECT_EQ(self->arg->ring_nr, ring_nr(self, 1));
+}
+
+TEST_F(ve_aio_ring, ve_keeps_cpu_heuristic)
+{
+ EXPECT_EQ(ve_ring_nr(self, 1), ring_nr(self, 1));
+}
+
+TEST_F(ve_aio_ring, pseudosuper_ve_skips_cpu_heuristic)
+{
+ EXPECT_EQ(set_pseudosuper(self, 1), 0);
+ EXPECT_EQ(ve_ring_nr(self, 1), ring_nr_pseudosuper(self, 1));
+}
+
+/*
+ * A ring of nr events is restored with io_setup((nr - 2) / 2), check
+ * it gives back a ring of nr events.
+ */
+TEST_F(ve_aio_ring, pseudosuper_ve_restores_ring_size)
+{
+ unsigned int pages, nr;
+
+ EXPECT_EQ(set_pseudosuper(self, 1), 0);
+ for (pages = 1; pages <= RING_PAGES_MAX; pages++) {
+ nr = (pages * self->page_size - sizeof(struct aio_ring)) /
+ sizeof(struct io_event);
+ EXPECT_EQ(ve_ring_nr(self, (nr - 2) / 2), nr)
+ TH_LOG("ring of %u pages", pages);
+ }
+}
+
+TEST_HARNESS_MAIN
--
2.56.0
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
next prev parent reply other threads:[~2026-11-13 15:11 UTC|newest]
Thread overview: 11+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-13 15:08 [Devel] [PATCH hci-8.1 0/2] fs/aio: fix CT migration with AIO to a node with more CPUs Pavel Tikhomirov
2026-11-13 15:08 ` [Devel] [PATCH hci-8.1 1/2] fs/aio: restore the AIO ring of the dumped size in a pseudosuper VE Pavel Tikhomirov
2026-11-13 15:14 ` no-reply
2026-11-13 19:41 ` Konstantin Khorenko
2026-11-13 15:08 ` Pavel Tikhomirov [this message]
2026-11-13 15:15 ` [Devel] [PATCH hci-8.1 2/2] selftests/ve: check the AIO ring " no-reply
2026-11-13 19:41 ` Konstantin Khorenko
2026-11-13 19:41 ` [Devel] [PATCH hci-8.1 0/2] fs/aio: fix CT migration with AIO to a node with more CPUs Konstantin Khorenko
2026-11-16 10:33 ` Pavel Tikhomirov
2026-11-16 10:35 ` Pavel Tikhomirov
2026-11-16 10:35 ` Pavel Tikhomirov
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261113-pr-ptikhomirov-vstor-154129-aio-pseudosuper-ring-v1-2-7d35d143fdc3@virtuozzo.com \
--to=ptikhomirov@virtuozzo.com \
--cc=devel@openvz.org \
--cc=khorenko@virtuozzo.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox