By using MGLRU's debugfs for invoking test_young() and clear_young(), we
avoid page_idle's incompatibility with MGLRU, and we can mark pages as
idle (clear_young()) much faster.
The ability to use page_idle is left in, as it is useful for kernels
that do not have MGLRU built in. If MGLRU is enabled but is not usable
(e.g. we can't access the debugfs mount), the test will fail, as
page_idle is not compatible with MGLRU.
cgroup utility functions have been borrowed so that, when running with
MGLRU, we can create a memcg in which to run our test.
Other MGLRU-debugfs-specific parsing code has been added to
lru_gen_util.{c,h}.
Co-developed-by: Axel Rasmussen <axelrasmussen@google.com>
Signed-off-by: Axel Rasmussen <axelrasmussen@google.com>
Signed-off-by: James Houghton <jthoughton@google.com>
---
tools/testing/selftests/kvm/Makefile.kvm | 1 +
.../selftests/kvm/access_tracking_perf_test.c | 207 ++++++++--
.../selftests/kvm/include/lru_gen_util.h | 51 +++
.../testing/selftests/kvm/lib/lru_gen_util.c | 383 ++++++++++++++++++
4 files changed, 616 insertions(+), 26 deletions(-)
create mode 100644 tools/testing/selftests/kvm/include/lru_gen_util.h
create mode 100644 tools/testing/selftests/kvm/lib/lru_gen_util.c
diff --git a/tools/testing/selftests/kvm/Makefile.kvm b/tools/testing/selftests/kvm/Makefile.kvm
index bea746878bcaa..24d2a5d387d34 100644
--- a/tools/testing/selftests/kvm/Makefile.kvm
+++ b/tools/testing/selftests/kvm/Makefile.kvm
@@ -8,6 +8,7 @@ LIBKVM += lib/elf.c
LIBKVM += lib/guest_modes.c
LIBKVM += lib/io.c
LIBKVM += lib/kvm_util.c
+LIBKVM += lib/lru_gen_util.c
LIBKVM += lib/memstress.c
LIBKVM += lib/guest_sprintf.c
LIBKVM += lib/rbtree.c
diff --git a/tools/testing/selftests/kvm/access_tracking_perf_test.c b/tools/testing/selftests/kvm/access_tracking_perf_test.c
index a2ac6fa2ba141..d4ef201b67055 100644
--- a/tools/testing/selftests/kvm/access_tracking_perf_test.c
+++ b/tools/testing/selftests/kvm/access_tracking_perf_test.c
@@ -7,9 +7,11 @@
* This test measures the performance effects of KVM's access tracking.
* Access tracking is driven by the MMU notifiers test_young, clear_young, and
* clear_flush_young. These notifiers do not have a direct userspace API,
- * however the clear_young notifier can be triggered by marking a pages as idle
- * in /sys/kernel/mm/page_idle/bitmap. This test leverages that mechanism to
- * enable access tracking on guest memory.
+ * however the clear_young notifier can be triggered either by
+ * 1. marking a pages as idle in /sys/kernel/mm/page_idle/bitmap OR
+ * 2. adding a new MGLRU generation using the lru_gen debugfs file.
+ * This test leverages page_idle to enable access tracking on guest memory
+ * unless MGLRU is enabled, in which case MGLRU is used.
*
* To measure performance this test runs a VM with a configurable number of
* vCPUs that each touch every page in disjoint regions of memory. Performance
@@ -17,10 +19,11 @@
* predefined region.
*
* Note that a deterministic correctness test of access tracking is not possible
- * by using page_idle as it exists today. This is for a few reasons:
+ * by using page_idle or MGLRU aging as it exists today. This is for a few
+ * reasons:
*
- * 1. page_idle only issues clear_young notifiers, which lack a TLB flush. This
- * means subsequent guest accesses are not guaranteed to see page table
+ * 1. page_idle and MGLRU only issue clear_young notifiers, which lack a TLB flush.
+ * This means subsequent guest accesses are not guaranteed to see page table
* updates made by KVM until some time in the future.
*
* 2. page_idle only operates on LRU pages. Newly allocated pages are not
@@ -48,9 +51,17 @@
#include "guest_modes.h"
#include "processor.h"
+#include "cgroup_util.h"
+#include "lru_gen_util.h"
+
+static const char *TEST_MEMCG_NAME = "access_tracking_perf_test";
+
/* Global variable used to synchronize all of the vCPU threads. */
static int iteration;
+/* The cgroup v2 root. Needed for lru_gen-based aging. */
+char cgroup_root[PATH_MAX];
+
/* Defines what vCPU threads should do during a given iteration. */
static enum {
/* Run the vCPU to access all its memory. */
@@ -75,6 +86,12 @@ static bool overlap_memory_access;
*/
static int idle_pages_warn_only = -1;
+/* Whether or not to use MGLRU instead of page_idle for access tracking */
+static bool use_lru_gen;
+
+/* Total number of pages to expect in the memcg after touching everything */
+static long total_pages;
+
struct test_params {
/* The backing source for the region of memory. */
enum vm_mem_backing_src_type backing_src;
@@ -133,8 +150,24 @@ static void mark_page_idle(int page_idle_fd, uint64_t pfn)
"Set page_idle bits for PFN 0x%" PRIx64, pfn);
}
-static void mark_vcpu_memory_idle(struct kvm_vm *vm,
- struct memstress_vcpu_args *vcpu_args)
+static void too_many_idle_pages(long idle_pages, long total_pages, int vcpu_idx)
+{
+ char prefix[18] = {};
+
+ if (vcpu_idx >= 0)
+ snprintf(prefix, 18, "vCPU%d: ", vcpu_idx);
+
+ TEST_ASSERT(idle_pages_warn_only,
+ "%sToo many pages still idle (%lu out of %lu)",
+ prefix, idle_pages, total_pages);
+
+ printf("WARNING: %sToo many pages still idle (%lu out of %lu), "
+ "this will affect performance results.\n",
+ prefix, idle_pages, total_pages);
+}
+
+static void pageidle_mark_vcpu_memory_idle(struct kvm_vm *vm,
+ struct memstress_vcpu_args *vcpu_args)
{
int vcpu_idx = vcpu_args->vcpu_idx;
uint64_t base_gva = vcpu_args->gva;
@@ -188,20 +221,81 @@ static void mark_vcpu_memory_idle(struct kvm_vm *vm,
* access tracking but low enough as to not make the test too brittle
* over time and across architectures.
*/
- if (still_idle >= pages / 10) {
- TEST_ASSERT(idle_pages_warn_only,
- "vCPU%d: Too many pages still idle (%lu out of %lu)",
- vcpu_idx, still_idle, pages);
-
- printf("WARNING: vCPU%d: Too many pages still idle (%lu out of %lu), "
- "this will affect performance results.\n",
- vcpu_idx, still_idle, pages);
- }
+ if (still_idle >= pages / 10)
+ too_many_idle_pages(still_idle, pages,
+ overlap_memory_access ? -1 : vcpu_idx);
close(page_idle_fd);
close(pagemap_fd);
}
+int find_generation(struct memcg_stats *stats, long total_pages)
+{
+ /*
+ * For finding the generation that contains our pages, use the same
+ * 90% threshold that page_idle uses.
+ */
+ int gen = lru_gen_find_generation(stats, total_pages * 9 / 10);
+
+ if (gen >= 0)
+ return gen;
+
+ if (!idle_pages_warn_only) {
+ TEST_FAIL("Could not find a generation with 90%% of guest memory (%ld pages).",
+ total_pages * 9 / 10);
+ return gen;
+ }
+
+ /*
+ * We couldn't find a generation with 90% of guest memory, which can
+ * happen if access tracking is unreliable. Simply look for a majority
+ * of pages.
+ */
+ puts("WARNING: Couldn't find a generation with 90% of guest memory. "
+ "Performance results may not be accurate.");
+ gen = lru_gen_find_generation(stats, total_pages / 2);
+ TEST_ASSERT(gen >= 0,
+ "Could not find a generation with 50%% of guest memory (%ld pages).",
+ total_pages / 2);
+ return gen;
+}
+
+static void lru_gen_mark_memory_idle(struct kvm_vm *vm)
+{
+ struct timespec ts_start;
+ struct timespec ts_elapsed;
+ struct memcg_stats stats;
+ int found_gens[2];
+
+ /* Find current generation the pages lie in. */
+ lru_gen_read_memcg_stats(&stats, TEST_MEMCG_NAME);
+ found_gens[0] = find_generation(&stats, total_pages);
+
+ /* Make a new generation */
+ clock_gettime(CLOCK_MONOTONIC, &ts_start);
+ lru_gen_do_aging(&stats, TEST_MEMCG_NAME);
+ ts_elapsed = timespec_elapsed(ts_start);
+
+ /* Check the generation again */
+ found_gens[1] = find_generation(&stats, total_pages);
+
+ /*
+ * This function should only be invoked with newly-accessed pages,
+ * so pages should always move to a newer generation.
+ */
+ if (found_gens[0] >= found_gens[1]) {
+ /* We did not move to a newer generation. */
+ long idle_pages = lru_gen_sum_memcg_stats_for_gen(found_gens[1],
+ &stats);
+
+ too_many_idle_pages(min_t(long, idle_pages, total_pages),
+ total_pages, -1);
+ }
+ pr_info("%-30s: %ld.%09lds\n",
+ "Mark memory idle (lru_gen)", ts_elapsed.tv_sec,
+ ts_elapsed.tv_nsec);
+}
+
static void assert_ucall(struct kvm_vcpu *vcpu, uint64_t expected_ucall)
{
struct ucall uc;
@@ -241,7 +335,7 @@ static void vcpu_thread_main(struct memstress_vcpu_args *vcpu_args)
assert_ucall(vcpu, UCALL_SYNC);
break;
case ITERATION_MARK_IDLE:
- mark_vcpu_memory_idle(vm, vcpu_args);
+ pageidle_mark_vcpu_memory_idle(vm, vcpu_args);
break;
}
@@ -293,15 +387,18 @@ static void access_memory(struct kvm_vm *vm, int nr_vcpus,
static void mark_memory_idle(struct kvm_vm *vm, int nr_vcpus)
{
+ if (use_lru_gen)
+ return lru_gen_mark_memory_idle(vm);
+
/*
* Even though this parallelizes the work across vCPUs, this is still a
* very slow operation because page_idle forces the test to mark one pfn
- * at a time and the clear_young notifier serializes on the KVM MMU
+ * at a time and the clear_young notifier may serialize on the KVM MMU
* lock.
*/
pr_debug("Marking VM memory idle (slow)...\n");
iteration_work = ITERATION_MARK_IDLE;
- run_iteration(vm, nr_vcpus, "Mark memory idle");
+ run_iteration(vm, nr_vcpus, "Mark memory idle (page_idle)");
}
static void run_test(enum vm_guest_mode mode, void *arg)
@@ -318,6 +415,14 @@ static void run_test(enum vm_guest_mode mode, void *arg)
pr_info("\n");
access_memory(vm, nr_vcpus, ACCESS_WRITE, "Populating memory");
+ if (use_lru_gen) {
+ struct memcg_stats stats;
+
+ lru_gen_read_memcg_stats(&stats, TEST_MEMCG_NAME);
+ TEST_ASSERT(lru_gen_sum_memcg_stats(&stats) >= total_pages,
+ "Not all pages accounted for. Was the memcg set up correctly?");
+ }
+
/* As a control, read and write to the populated memory first. */
access_memory(vm, nr_vcpus, ACCESS_WRITE, "Writing to populated memory");
access_memory(vm, nr_vcpus, ACCESS_READ, "Reading from populated memory");
@@ -354,7 +459,12 @@ static int access_tracking_unreliable(void)
puts("Skipping idle page count sanity check, because NUMA balancing is enabled");
return 1;
}
+ return 0;
+}
+int run_test_in_cg(const char *cgroup, void *arg)
+{
+ for_each_guest_mode(run_test, arg);
return 0;
}
@@ -372,7 +482,7 @@ static void help(char *name)
printf(" -v: specify the number of vCPUs to run.\n");
printf(" -o: Overlap guest memory accesses instead of partitioning\n"
" them into a separate region of memory for each vCPU.\n");
- printf(" -w: Control whether the test warns or fails if more than 10%\n"
+ printf(" -w: Control whether the test warns or fails if more than 10%%\n"
" of pages are still seen as idle/old after accessing guest\n"
" memory. >0 == warn only, 0 == fail, <0 == auto. For auto\n"
" mode, the test fails by default, but switches to warn only\n"
@@ -383,6 +493,12 @@ static void help(char *name)
exit(0);
}
+void destroy_cgroup(char *cg)
+{
+ printf("Destroying cgroup: %s\n", cg);
+ cg_destroy(cg);
+}
+
int main(int argc, char *argv[])
{
struct test_params params = {
@@ -390,6 +506,7 @@ int main(int argc, char *argv[])
.vcpu_memory_bytes = DEFAULT_PER_VCPU_MEM_SIZE,
.nr_vcpus = 1,
};
+ char *new_cg = NULL;
int page_idle_fd;
int opt;
@@ -424,15 +541,53 @@ int main(int argc, char *argv[])
}
}
- page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR);
- __TEST_REQUIRE(page_idle_fd >= 0,
- "CONFIG_IDLE_PAGE_TRACKING is not enabled");
- close(page_idle_fd);
+ if (lru_gen_usable()) {
+ if (cg_find_unified_root(cgroup_root, sizeof(cgroup_root), NULL))
+ ksft_exit_skip("cgroup v2 isn't mounted\n");
+
+ new_cg = cg_name(cgroup_root, TEST_MEMCG_NAME);
+ printf("Creating cgroup: %s\n", new_cg);
+ if (cg_create(new_cg) && errno != EEXIST)
+ ksft_exit_skip("could not create new cgroup: %s\n", new_cg);
+
+ use_lru_gen = true;
+ } else {
+ page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR);
+ __TEST_REQUIRE(page_idle_fd >= 0,
+ "Couldn't open /sys/kernel/mm/page_idle/bitmap. "
+ "Is CONFIG_IDLE_PAGE_TRACKING enabled?");
+
+ close(page_idle_fd);
+ }
if (idle_pages_warn_only == -1)
idle_pages_warn_only = access_tracking_unreliable();
- for_each_guest_mode(run_test, ¶ms);
+ /*
+ * If guest_page_size is larger than the host's page size, the
+ * guest (memstress) will only fault in a subset of the host's pages.
+ */
+ total_pages = params.nr_vcpus * params.vcpu_memory_bytes /
+ max(memstress_args.guest_page_size,
+ (uint64_t)getpagesize());
+
+ if (use_lru_gen) {
+ int ret;
+
+ puts("Using lru_gen for aging");
+ /*
+ * This will fork off a new process to run the test within
+ * a new memcg, so we need to properly propagate the return
+ * value up.
+ */
+ ret = cg_run(new_cg, &run_test_in_cg, ¶ms);
+ destroy_cgroup(new_cg);
+ if (ret)
+ return ret;
+ } else {
+ puts("Using page_idle for aging");
+ for_each_guest_mode(run_test, ¶ms);
+ }
return 0;
}
diff --git a/tools/testing/selftests/kvm/include/lru_gen_util.h b/tools/testing/selftests/kvm/include/lru_gen_util.h
new file mode 100644
index 0000000000000..d32ff5d8ffd05
--- /dev/null
+++ b/tools/testing/selftests/kvm/include/lru_gen_util.h
@@ -0,0 +1,51 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Tools for integrating with lru_gen, like parsing the lru_gen debugfs output.
+ *
+ * Copyright (C) 2025, Google LLC.
+ */
+#ifndef SELFTEST_KVM_LRU_GEN_UTIL_H
+#define SELFTEST_KVM_LRU_GEN_UTIL_H
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdlib.h>
+
+#include "test_util.h"
+
+#define MAX_NR_GENS 16 /* MAX_NR_GENS in include/linux/mmzone.h */
+#define MAX_NR_NODES 4 /* Maximum number of nodes supported by the test */
+
+#define LRU_GEN_DEBUGFS "/sys/kernel/debug/lru_gen"
+#define LRU_GEN_ENABLED_PATH "/sys/kernel/mm/lru_gen/enabled"
+#define LRU_GEN_ENABLED 1
+#define LRU_GEN_MM_WALK 2
+
+struct generation_stats {
+ int gen;
+ long age_ms;
+ long nr_anon;
+ long nr_file;
+};
+
+struct node_stats {
+ int node;
+ int nr_gens; /* Number of populated gens entries. */
+ struct generation_stats gens[MAX_NR_GENS];
+};
+
+struct memcg_stats {
+ unsigned long memcg_id;
+ int nr_nodes; /* Number of populated nodes entries. */
+ struct node_stats nodes[MAX_NR_NODES];
+};
+
+void lru_gen_read_memcg_stats(struct memcg_stats *stats, const char *memcg);
+long lru_gen_sum_memcg_stats(const struct memcg_stats *stats);
+long lru_gen_sum_memcg_stats_for_gen(int gen, const struct memcg_stats *stats);
+void lru_gen_do_aging(struct memcg_stats *stats, const char *memcg);
+int lru_gen_find_generation(const struct memcg_stats *stats,
+ unsigned long total_pages);
+bool lru_gen_usable(void);
+
+#endif /* SELFTEST_KVM_LRU_GEN_UTIL_H */
diff --git a/tools/testing/selftests/kvm/lib/lru_gen_util.c b/tools/testing/selftests/kvm/lib/lru_gen_util.c
new file mode 100644
index 0000000000000..783a1f1028a26
--- /dev/null
+++ b/tools/testing/selftests/kvm/lib/lru_gen_util.c
@@ -0,0 +1,383 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2025, Google LLC.
+ */
+
+#include <time.h>
+
+#include "lru_gen_util.h"
+
+/*
+ * Tracks state while we parse memcg lru_gen stats. The file we're parsing is
+ * structured like this (some extra whitespace elided):
+ *
+ * memcg (id) (path)
+ * node (id)
+ * (gen_nr) (age_in_ms) (nr_anon_pages) (nr_file_pages)
+ */
+struct memcg_stats_parse_context {
+ bool consumed; /* Whether or not this line was consumed */
+ /* Next parse handler to invoke */
+ void (*next_handler)(struct memcg_stats *,
+ struct memcg_stats_parse_context *, char *);
+ int current_node_idx; /* Current index in nodes array */
+ const char *name; /* The name of the memcg we're looking for */
+};
+
+static void memcg_stats_handle_searching(struct memcg_stats *stats,
+ struct memcg_stats_parse_context *ctx,
+ char *line);
+static void memcg_stats_handle_in_memcg(struct memcg_stats *stats,
+ struct memcg_stats_parse_context *ctx,
+ char *line);
+static void memcg_stats_handle_in_node(struct memcg_stats *stats,
+ struct memcg_stats_parse_context *ctx,
+ char *line);
+
+struct split_iterator {
+ char *str;
+ char *save;
+};
+
+static char *split_next(struct split_iterator *it)
+{
+ char *ret = strtok_r(it->str, " \t\n\r", &it->save);
+
+ it->str = NULL;
+ return ret;
+}
+
+static void memcg_stats_handle_searching(struct memcg_stats *stats,
+ struct memcg_stats_parse_context *ctx,
+ char *line)
+{
+ struct split_iterator it = { .str = line };
+ char *prefix = split_next(&it);
+ char *memcg_id = split_next(&it);
+ char *memcg_name = split_next(&it);
+ char *end;
+
+ ctx->consumed = true;
+
+ if (!prefix || strcmp("memcg", prefix))
+ return; /* Not a memcg line (maybe empty), skip */
+
+ TEST_ASSERT(memcg_id && memcg_name,
+ "malformed memcg line; no memcg id or memcg_name");
+
+ if (strcmp(memcg_name + 1, ctx->name))
+ return; /* Wrong memcg, skip */
+
+ /* Found it! */
+
+ stats->memcg_id = strtoul(memcg_id, &end, 10);
+ TEST_ASSERT(*end == '\0', "malformed memcg id '%s'", memcg_id);
+ if (!stats->memcg_id)
+ return; /* Removed memcg? */
+
+ ctx->next_handler = memcg_stats_handle_in_memcg;
+}
+
+static void memcg_stats_handle_in_memcg(struct memcg_stats *stats,
+ struct memcg_stats_parse_context *ctx,
+ char *line)
+{
+ struct split_iterator it = { .str = line };
+ char *prefix = split_next(&it);
+ char *id = split_next(&it);
+ long found_node_id;
+ char *end;
+
+ ctx->consumed = true;
+ ctx->current_node_idx = -1;
+
+ if (!prefix)
+ return; /* Skip empty lines */
+
+ if (!strcmp("memcg", prefix)) {
+ /* Memcg done, found next one; stop. */
+ ctx->next_handler = NULL;
+ return;
+ } else if (strcmp("node", prefix))
+ TEST_ASSERT(false, "found malformed line after 'memcg ...',"
+ "token: '%s'", prefix);
+
+ /* At this point we know we have a node line. Parse the ID. */
+
+ TEST_ASSERT(id, "malformed node line; no node id");
+
+ found_node_id = strtol(id, &end, 10);
+ TEST_ASSERT(*end == '\0', "malformed node id '%s'", id);
+
+ ctx->current_node_idx = stats->nr_nodes++;
+ TEST_ASSERT(ctx->current_node_idx < MAX_NR_NODES,
+ "memcg has stats for too many nodes, max is %d",
+ MAX_NR_NODES);
+ stats->nodes[ctx->current_node_idx].node = found_node_id;
+
+ ctx->next_handler = memcg_stats_handle_in_node;
+}
+
+static void memcg_stats_handle_in_node(struct memcg_stats *stats,
+ struct memcg_stats_parse_context *ctx,
+ char *line)
+{
+ char *my_line = strdup(line);
+ struct split_iterator it = { .str = my_line };
+ char *gen, *age, *nr_anon, *nr_file;
+ struct node_stats *node_stats;
+ struct generation_stats *gen_stats;
+ char *end;
+
+ TEST_ASSERT(it.str, "failed to copy input line");
+
+ gen = split_next(&it);
+
+ if (!gen)
+ goto out_consume; /* Skip empty lines */
+
+ if (!strcmp("memcg", gen) || !strcmp("node", gen)) {
+ /*
+ * Reached next memcg or node section. Don't consume, let the
+ * other handler deal with this.
+ */
+ ctx->next_handler = memcg_stats_handle_in_memcg;
+ goto out;
+ }
+
+ node_stats = &stats->nodes[ctx->current_node_idx];
+ TEST_ASSERT(node_stats->nr_gens < MAX_NR_GENS,
+ "found too many generation lines; max is %d",
+ MAX_NR_GENS);
+ gen_stats = &node_stats->gens[node_stats->nr_gens++];
+
+ age = split_next(&it);
+ nr_anon = split_next(&it);
+ nr_file = split_next(&it);
+
+ TEST_ASSERT(age && nr_anon && nr_file,
+ "malformed generation line; not enough tokens");
+
+ gen_stats->gen = (int)strtol(gen, &end, 10);
+ TEST_ASSERT(*end == '\0', "malformed generation number '%s'", gen);
+
+ gen_stats->age_ms = strtol(age, &end, 10);
+ TEST_ASSERT(*end == '\0', "malformed generation age '%s'", age);
+
+ gen_stats->nr_anon = strtol(nr_anon, &end, 10);
+ TEST_ASSERT(*end == '\0', "malformed anonymous page count '%s'",
+ nr_anon);
+
+ gen_stats->nr_file = strtol(nr_file, &end, 10);
+ TEST_ASSERT(*end == '\0', "malformed file page count '%s'", nr_file);
+
+out_consume:
+ ctx->consumed = true;
+out:
+ free(my_line);
+}
+
+static void print_memcg_stats(const struct memcg_stats *stats, const char *name)
+{
+ int node, gen;
+
+ pr_debug("stats for memcg %s (id %lu):\n", name, stats->memcg_id);
+ for (node = 0; node < stats->nr_nodes; ++node) {
+ pr_debug("\tnode %d\n", stats->nodes[node].node);
+ for (gen = 0; gen < stats->nodes[node].nr_gens; ++gen) {
+ const struct generation_stats *gstats =
+ &stats->nodes[node].gens[gen];
+
+ pr_debug("\t\tgen %d\tage_ms %ld"
+ "\tnr_anon %ld\tnr_file %ld\n",
+ gstats->gen, gstats->age_ms, gstats->nr_anon,
+ gstats->nr_file);
+ }
+ }
+}
+
+/* Re-read lru_gen debugfs information for @memcg into @stats. */
+void lru_gen_read_memcg_stats(struct memcg_stats *stats, const char *memcg)
+{
+ FILE *f;
+ ssize_t read = 0;
+ char *line = NULL;
+ size_t bufsz;
+ struct memcg_stats_parse_context ctx = {
+ .next_handler = memcg_stats_handle_searching,
+ .name = memcg,
+ };
+
+ memset(stats, 0, sizeof(struct memcg_stats));
+
+ f = fopen(LRU_GEN_DEBUGFS, "r");
+ TEST_ASSERT(f, "fopen(%s) failed", LRU_GEN_DEBUGFS);
+
+ while (ctx.next_handler && (read = getline(&line, &bufsz, f)) > 0) {
+ ctx.consumed = false;
+
+ do {
+ ctx.next_handler(stats, &ctx, line);
+ if (!ctx.next_handler)
+ break;
+ } while (!ctx.consumed);
+ }
+
+ if (read < 0 && !feof(f))
+ TEST_ASSERT(false, "getline(%s) failed", LRU_GEN_DEBUGFS);
+
+ TEST_ASSERT(stats->memcg_id > 0, "Couldn't find memcg: %s\n"
+ "Did the memcg get created in the proper mount?",
+ memcg);
+ if (line)
+ free(line);
+ TEST_ASSERT(!fclose(f), "fclose(%s) failed", LRU_GEN_DEBUGFS);
+
+ print_memcg_stats(stats, memcg);
+}
+
+/*
+ * Find all pages tracked by lru_gen for this memcg in generation @target_gen.
+ *
+ * If @target_gen is negative, look for all generations.
+ */
+long lru_gen_sum_memcg_stats_for_gen(int target_gen,
+ const struct memcg_stats *stats)
+{
+ int node, gen;
+ long total_nr = 0;
+
+ for (node = 0; node < stats->nr_nodes; ++node) {
+ const struct node_stats *node_stats = &stats->nodes[node];
+
+ for (gen = 0; gen < node_stats->nr_gens; ++gen) {
+ const struct generation_stats *gen_stats =
+ &node_stats->gens[gen];
+
+ if (target_gen >= 0 && gen_stats->gen != target_gen)
+ continue;
+
+ total_nr += gen_stats->nr_anon + gen_stats->nr_file;
+ }
+ }
+
+ return total_nr;
+}
+
+/* Find all pages tracked by lru_gen for this memcg. */
+long lru_gen_sum_memcg_stats(const struct memcg_stats *stats)
+{
+ return lru_gen_sum_memcg_stats_for_gen(-1, stats);
+}
+
+/*
+ * If lru_gen aging should force page table scanning.
+ *
+ * If you want to set this to false, you will need to do eviction
+ * before doing extra aging passes.
+ */
+static const bool force_scan = true;
+
+static void run_aging_impl(unsigned long memcg_id, int node_id, int max_gen)
+{
+ FILE *f = fopen(LRU_GEN_DEBUGFS, "w");
+ char *command;
+ size_t sz;
+
+ TEST_ASSERT(f, "fopen(%s) failed", LRU_GEN_DEBUGFS);
+ sz = asprintf(&command, "+ %lu %d %d 1 %d\n",
+ memcg_id, node_id, max_gen, force_scan);
+ TEST_ASSERT(sz > 0, "creating aging command failed");
+
+ pr_debug("Running aging command: %s", command);
+ if (fwrite(command, sizeof(char), sz, f) < sz) {
+ TEST_ASSERT(false, "writing aging command %s to %s failed",
+ command, LRU_GEN_DEBUGFS);
+ }
+
+ TEST_ASSERT(!fclose(f), "fclose(%s) failed", LRU_GEN_DEBUGFS);
+}
+
+void lru_gen_do_aging(struct memcg_stats *stats, const char *memcg)
+{
+ int node, gen;
+
+ pr_debug("lru_gen: invoking aging...\n");
+
+ /* Must read memcg stats to construct the proper aging command. */
+ lru_gen_read_memcg_stats(stats, memcg);
+
+ for (node = 0; node < stats->nr_nodes; ++node) {
+ int max_gen = 0;
+
+ for (gen = 0; gen < stats->nodes[node].nr_gens; ++gen) {
+ int this_gen = stats->nodes[node].gens[gen].gen;
+
+ max_gen = max_gen > this_gen ? max_gen : this_gen;
+ }
+
+ run_aging_impl(stats->memcg_id, stats->nodes[node].node,
+ max_gen);
+ }
+
+ /* Re-read so callers get updated information */
+ lru_gen_read_memcg_stats(stats, memcg);
+}
+
+/*
+ * Find which generation contains at least @pages pages, assuming that
+ * such a generation exists.
+ */
+int lru_gen_find_generation(const struct memcg_stats *stats,
+ unsigned long pages)
+{
+ int node, gen, gen_idx, min_gen = INT_MAX, max_gen = -1;
+
+ for (node = 0; node < stats->nr_nodes; ++node)
+ for (gen_idx = 0; gen_idx < stats->nodes[node].nr_gens;
+ ++gen_idx) {
+ gen = stats->nodes[node].gens[gen_idx].gen;
+ max_gen = gen > max_gen ? gen : max_gen;
+ min_gen = gen < min_gen ? gen : min_gen;
+ }
+
+ for (gen = min_gen; gen < max_gen; ++gen)
+ /* See if this generation has enough pages. */
+ if (lru_gen_sum_memcg_stats_for_gen(gen, stats) > pages)
+ return gen;
+
+ return -1;
+}
+
+bool lru_gen_usable(void)
+{
+ long required_features = LRU_GEN_ENABLED | LRU_GEN_MM_WALK;
+ int lru_gen_fd, lru_gen_debug_fd;
+ char mglru_feature_str[8] = {};
+ long mglru_features;
+
+ lru_gen_fd = open(LRU_GEN_ENABLED_PATH, O_RDONLY);
+ if (lru_gen_fd < 0) {
+ puts("lru_gen: Could not open " LRU_GEN_ENABLED_PATH);
+ return false;
+ }
+ if (read(lru_gen_fd, &mglru_feature_str, 7) < 7) {
+ puts("lru_gen: Could not read from " LRU_GEN_ENABLED_PATH);
+ close(lru_gen_fd);
+ return false;
+ }
+ close(lru_gen_fd);
+
+ mglru_features = strtol(mglru_feature_str, NULL, 16);
+ if ((mglru_features & required_features) != required_features) {
+ printf("lru_gen: missing features, got: %s", mglru_feature_str);
+ return false;
+ }
+
+ lru_gen_debug_fd = open(LRU_GEN_DEBUGFS, O_RDWR);
+ __TEST_REQUIRE(lru_gen_debug_fd >= 0,
+ "lru_gen: Could not open " LRU_GEN_DEBUGFS ", "
+ "but lru_gen is enabled, so cannot use page_idle.");
+ close(lru_gen_debug_fd);
+ return true;
+}
--
2.49.0.604.gff1f9ca942-googOn Mon, Apr 14, 2025, James Houghton wrote:
> By using MGLRU's debugfs for invoking test_young() and clear_young(), we
> avoid page_idle's incompatibility with MGLRU, and we can mark pages as
> idle (clear_young()) much faster.
>
> The ability to use page_idle is left in, as it is useful for kernels
> that do not have MGLRU built in. If MGLRU is enabled but is not usable
> (e.g. we can't access the debugfs mount), the test will fail, as
> page_idle is not compatible with MGLRU.
>
> cgroup utility functions have been borrowed so that, when running with
> MGLRU, we can create a memcg in which to run our test.
>
> Other MGLRU-debugfs-specific parsing code has been added to
> lru_gen_util.{c,h}.
This is not a proper changelog, at least not by upstream KVM standards. Please
rewrite it describe the changes being made, using imperative mood/tone. From
Documentation/process/maintainer-kvm-x86.rst:
Changelog
~~~~~~~~~
Most importantly, write changelogs using imperative mood and avoid pronouns.
> @@ -354,7 +459,12 @@ static int access_tracking_unreliable(void)
> puts("Skipping idle page count sanity check, because NUMA balancing is enabled");
> return 1;
> }
> + return 0;
> +}
>
> +int run_test_in_cg(const char *cgroup, void *arg)
static
> +{
> + for_each_guest_mode(run_test, arg);
Having "separate" flows for MGLRU vs. page_idle is unnecessary. Give the helper
a more common name and use it for both:
static int run_test_for_each_guest_mode(const char *cgroup, void *arg)
{
for_each_guest_mode(run_test, arg);
return 0;
}
> return 0;
> }
>
> @@ -372,7 +482,7 @@ static void help(char *name)
> printf(" -v: specify the number of vCPUs to run.\n");
> printf(" -o: Overlap guest memory accesses instead of partitioning\n"
> " them into a separate region of memory for each vCPU.\n");
> - printf(" -w: Control whether the test warns or fails if more than 10%\n"
> + printf(" -w: Control whether the test warns or fails if more than 10%%\n"
> " of pages are still seen as idle/old after accessing guest\n"
> " memory. >0 == warn only, 0 == fail, <0 == auto. For auto\n"
> " mode, the test fails by default, but switches to warn only\n"
> @@ -383,6 +493,12 @@ static void help(char *name)
> exit(0);
> }
>
> +void destroy_cgroup(char *cg)
static. But this is a pointless wrapper, just delete it.
> +{
> + printf("Destroying cgroup: %s\n", cg);
> + cg_destroy(cg);
> +}
> +
> int main(int argc, char *argv[])
> {
> struct test_params params = {
> @@ -390,6 +506,7 @@ int main(int argc, char *argv[])
> .vcpu_memory_bytes = DEFAULT_PER_VCPU_MEM_SIZE,
> .nr_vcpus = 1,
> };
> + char *new_cg = NULL;
> int page_idle_fd;
> int opt;
>
> @@ -424,15 +541,53 @@ int main(int argc, char *argv[])
> }
> }
>
> - page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR);
> - __TEST_REQUIRE(page_idle_fd >= 0,
> - "CONFIG_IDLE_PAGE_TRACKING is not enabled");
> - close(page_idle_fd);
> + if (lru_gen_usable()) {
Using MGLRU on my home box fails. It's full cgroup v2, and has both
CONFIG_IDLE_PAGE_TRACKING=y and MGLRU enabled.
==== Test Assertion Failure ====
access_tracking_perf_test.c:244: false
pid=114670 tid=114670 errno=17 - File exists
1 0x00000000004032a9: find_generation at access_tracking_perf_test.c:244
2 0x00000000004032da: lru_gen_mark_memory_idle at access_tracking_perf_test.c:272
3 0x00000000004034e4: mark_memory_idle at access_tracking_perf_test.c:391
4 (inlined by) run_test at access_tracking_perf_test.c:431
5 0x0000000000403d84: for_each_guest_mode at guest_modes.c:96
6 0x0000000000402c61: run_test_for_each_guest_mode at access_tracking_perf_test.c:492
7 0x000000000041d8e2: cg_run at cgroup_util.c:382
8 0x00000000004027fa: main at access_tracking_perf_test.c:572
9 0x00007fa1cb629d8f: ?? ??:0
10 0x00007fa1cb629e3f: ?? ??:0
11 0x00000000004029d4: _start at ??:?
Could not find a generation with 90% of guest memory (235929 pages).
Interestingly, if I force the test to use /sys/kernel/mm/page_idle/bitmap, it
passes.
Please try to reproduce the failure (assuming you haven't already tested that
exact combination of cgroups v2, MGLRU=y, and CONFIG_IDLE_PAGE_TRACKING=y). I
don't have bandwidth to dig any further at this time.
> + if (cg_find_unified_root(cgroup_root, sizeof(cgroup_root), NULL))
> + ksft_exit_skip("cgroup v2 isn't mounted\n");
> +
> + new_cg = cg_name(cgroup_root, TEST_MEMCG_NAME);
> + printf("Creating cgroup: %s\n", new_cg);
> + if (cg_create(new_cg) && errno != EEXIST)
> + ksft_exit_skip("could not create new cgroup: %s\n", new_cg);
> +
> + use_lru_gen = true;
> + } else {
> + page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR);
> + __TEST_REQUIRE(page_idle_fd >= 0,
> + "Couldn't open /sys/kernel/mm/page_idle/bitmap. "
> + "Is CONFIG_IDLE_PAGE_TRACKING enabled?");
> +
> + close(page_idle_fd);
> + }
Splitting the "check" and "execute" into separate if-else statements results in
some compilers complaining about new_cg possibly being unused. The compiler is
probably being a bit stupid, but the code is just as must to blame. There's zero
reason to split this in two, just do everything after the idle_pages_warn_only
and total_pages processing. Code at the bottom (note, you'll have to rebase on
my not-yet-posted series, or undo the use of __open_path_or_exit()).
>
> if (idle_pages_warn_only == -1)
> idle_pages_warn_only = access_tracking_unreliable();
>
> - for_each_guest_mode(run_test, ¶ms);
> + /*
> + * If guest_page_size is larger than the host's page size, the
> + * guest (memstress) will only fault in a subset of the host's pages.
> + */
> + total_pages = params.nr_vcpus * params.vcpu_memory_bytes /
> + max(memstress_args.guest_page_size,
> + (uint64_t)getpagesize());
> +
> + if (use_lru_gen) {
> + int ret;
> +
> + puts("Using lru_gen for aging");
> + /*
> + * This will fork off a new process to run the test within
> + * a new memcg, so we need to properly propagate the return
> + * value up.
> + */
> + ret = cg_run(new_cg, &run_test_in_cg, ¶ms);
> + destroy_cgroup(new_cg);
> + if (ret)
> + return ret;
> + } else {
> + puts("Using page_idle for aging");
> + for_each_guest_mode(run_test, ¶ms);
> + }
static int run_test_for_each_guest_mode(const char *cgroup, void *arg)
{
for_each_guest_mode(run_test, arg);
return 0;
}
int main(int argc, char *argv[])
{
struct test_params params = {
.backing_src = DEFAULT_VM_MEM_SRC,
.vcpu_memory_bytes = DEFAULT_PER_VCPU_MEM_SIZE,
.nr_vcpus = 1,
};
int page_idle_fd;
int opt;
guest_modes_append_default();
while ((opt = getopt(argc, argv, "hm:b:v:os:w:")) != -1) {
switch (opt) {
case 'm':
guest_modes_cmdline(optarg);
break;
case 'b':
params.vcpu_memory_bytes = parse_size(optarg);
break;
case 'v':
params.nr_vcpus = atoi_positive("Number of vCPUs", optarg);
break;
case 'o':
overlap_memory_access = true;
break;
case 's':
params.backing_src = parse_backing_src_type(optarg);
break;
case 'w':
idle_pages_warn_only =
atoi_non_negative("Idle pages warning",
optarg);
break;
case 'h':
default:
help(argv[0]);
break;
}
}
if (idle_pages_warn_only == -1)
idle_pages_warn_only = access_tracking_unreliable();
/*
* If guest_page_size is larger than the host's page size, the
* guest (memstress) will only fault in a subset of the host's pages.
*/
total_pages = params.nr_vcpus * params.vcpu_memory_bytes /
max_t(uint64_t, memstress_args.guest_page_size, getpagesize());
if (lru_gen_usable()) {
bool cg_created = true;
char *test_cg = NULL;
int ret;
puts("Using lru_gen for aging");
use_lru_gen = true;
if (cg_find_controller_root(cgroup_root, sizeof(cgroup_root), "memory"))
ksft_exit_skip("Cannot find memory group controller\n");
test_cg = cg_name(cgroup_root, TEST_MEMCG_NAME);
printf("Creating cgroup: %s\n", test_cg);
if (cg_create(test_cg)) {
if (errno == EEXIST)
cg_created = false;
else
ksft_exit_skip("could not create new cgroup: %s\n", test_cg);
}
/*
* This will fork off a new process to run the test within
* a new memcg, so we need to properly propagate the return
* value up.
*/
ret = cg_run(test_cg, &run_test_for_each_guest_mode, ¶ms);
if (cg_created)
cg_destroy(test_cg);
return ret;
}
puts("Using page_idle for aging");
page_idle_fd = __open_path_or_exit("/sys/kernel/mm/page_idle/bitmap", O_RDWR,
"Is CONFIG_IDLE_PAGE_TRACKING enabled?");
close(page_idle_fd);
run_test_for_each_guest_mode(NULL, ¶ms);
return 0;
}
On Mon, Apr 28, 2025 at 9:19 PM Sean Christopherson <seanjc@google.com> wrote:
>
> On Mon, Apr 14, 2025, James Houghton wrote:
> > By using MGLRU's debugfs for invoking test_young() and clear_young(), we
> > avoid page_idle's incompatibility with MGLRU, and we can mark pages as
> > idle (clear_young()) much faster.
> >
> > The ability to use page_idle is left in, as it is useful for kernels
> > that do not have MGLRU built in. If MGLRU is enabled but is not usable
> > (e.g. we can't access the debugfs mount), the test will fail, as
> > page_idle is not compatible with MGLRU.
> >
> > cgroup utility functions have been borrowed so that, when running with
> > MGLRU, we can create a memcg in which to run our test.
> >
> > Other MGLRU-debugfs-specific parsing code has been added to
> > lru_gen_util.{c,h}.
>
> This is not a proper changelog, at least not by upstream KVM standards. Please
> rewrite it describe the changes being made, using imperative mood/tone. From
> Documentation/process/maintainer-kvm-x86.rst:
>
> Changelog
> ~~~~~~~~~
> Most importantly, write changelogs using imperative mood and avoid pronouns.
Right. I'll rewrite the changelog properly.
>
> > @@ -354,7 +459,12 @@ static int access_tracking_unreliable(void)
> > puts("Skipping idle page count sanity check, because NUMA balancing is enabled");
> > return 1;
> > }
> > + return 0;
> > +}
> >
> > +int run_test_in_cg(const char *cgroup, void *arg)
>
> static
Will change.
>
> > +{
> > + for_each_guest_mode(run_test, arg);
>
> Having "separate" flows for MGLRU vs. page_idle is unnecessary. Give the helper
> a more common name and use it for both:
>
> static int run_test_for_each_guest_mode(const char *cgroup, void *arg)
> {
> for_each_guest_mode(run_test, arg);
> return 0;
> }
Applied for my next version, thanks.
>
> > return 0;
> > }
> >
> > @@ -372,7 +482,7 @@ static void help(char *name)
> > printf(" -v: specify the number of vCPUs to run.\n");
> > printf(" -o: Overlap guest memory accesses instead of partitioning\n"
> > " them into a separate region of memory for each vCPU.\n");
> > - printf(" -w: Control whether the test warns or fails if more than 10%\n"
> > + printf(" -w: Control whether the test warns or fails if more than 10%%\n"
> > " of pages are still seen as idle/old after accessing guest\n"
> > " memory. >0 == warn only, 0 == fail, <0 == auto. For auto\n"
> > " mode, the test fails by default, but switches to warn only\n"
> > @@ -383,6 +493,12 @@ static void help(char *name)
> > exit(0);
> > }
> >
> > +void destroy_cgroup(char *cg)
>
> static. But this is a pointless wrapper, just delete it.
Will do.
> Using MGLRU on my home box fails. It's full cgroup v2, and has both
> CONFIG_IDLE_PAGE_TRACKING=y and MGLRU enabled.
>
> ==== Test Assertion Failure ====
> access_tracking_perf_test.c:244: false
> pid=114670 tid=114670 errno=17 - File exists
> 1 0x00000000004032a9: find_generation at access_tracking_perf_test.c:244
> 2 0x00000000004032da: lru_gen_mark_memory_idle at access_tracking_perf_test.c:272
> 3 0x00000000004034e4: mark_memory_idle at access_tracking_perf_test.c:391
> 4 (inlined by) run_test at access_tracking_perf_test.c:431
> 5 0x0000000000403d84: for_each_guest_mode at guest_modes.c:96
> 6 0x0000000000402c61: run_test_for_each_guest_mode at access_tracking_perf_test.c:492
> 7 0x000000000041d8e2: cg_run at cgroup_util.c:382
> 8 0x00000000004027fa: main at access_tracking_perf_test.c:572
> 9 0x00007fa1cb629d8f: ?? ??:0
> 10 0x00007fa1cb629e3f: ?? ??:0
> 11 0x00000000004029d4: _start at ??:?
> Could not find a generation with 90% of guest memory (235929 pages).
>
> Interestingly, if I force the test to use /sys/kernel/mm/page_idle/bitmap, it
> passes.
>
> Please try to reproduce the failure (assuming you haven't already tested that
> exact combination of cgroups v2, MGLRU=y, and CONFIG_IDLE_PAGE_TRACKING=y). I
> don't have bandwidth to dig any further at this time.
Sorry... please see the bottom of this message for a diff that should fix this.
It fixes these bugs:
1. Tracking generation numbers without hardware Accessed bit management.
(This is addition of lru_gen_last_gen.)
1.5 It does an initial aging pass so that pages always move to newer
generations in (or before) the subsequent aging passes. This probably
isn't needed given the change I made for (1).
2. Fixes the expected number of pages for guest page sizes > PAGE_SIZE.
(This is the move of test_pages. test_pages has also been renamed to avoid
shadowing.)
3. Fixes an off-by-one error when looking for the generation with the most
pages. Previously it failed to check the youngest generation, which I think
is the bug you ran into. (This is the change to lru_gen_util.c.)
It might take a couple tweaks to compile in your tree. (It is just a WIP diff
from when I was applying changes from your feedback, so it contains partial
changes you asked for.
> > + if (cg_find_unified_root(cgroup_root, sizeof(cgroup_root), NULL))
> > + ksft_exit_skip("cgroup v2 isn't mounted\n");
> > +
> > + new_cg = cg_name(cgroup_root, TEST_MEMCG_NAME);
> > + printf("Creating cgroup: %s\n", new_cg);
> > + if (cg_create(new_cg) && errno != EEXIST)
> > + ksft_exit_skip("could not create new cgroup: %s\n", new_cg);
> > +
> > + use_lru_gen = true;
> > + } else {
> > + page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR);
> > + __TEST_REQUIRE(page_idle_fd >= 0,
> > + "Couldn't open /sys/kernel/mm/page_idle/bitmap. "
> > + "Is CONFIG_IDLE_PAGE_TRACKING enabled?");
> > +
> > + close(page_idle_fd);
> > + }
>
> Splitting the "check" and "execute" into separate if-else statements results in
> some compilers complaining about new_cg possibly being unused. The compiler is
> probably being a bit stupid, but the code is just as must to blame. There's zero
> reason to split this in two, just do everything after the idle_pages_warn_only
> and total_pages processing. Code at the bottom (note, you'll have to rebase on
> my not-yet-posted series, or undo the use of __open_path_or_exit()).
I have applied the below suggestion for the next version of the series. Thanks.
> static int run_test_for_each_guest_mode(const char *cgroup, void *arg)
> {
> for_each_guest_mode(run_test, arg);
> return 0;
> }
>
> int main(int argc, char *argv[])
> {
> struct test_params params = {
> .backing_src = DEFAULT_VM_MEM_SRC,
> .vcpu_memory_bytes = DEFAULT_PER_VCPU_MEM_SIZE,
> .nr_vcpus = 1,
> };
> int page_idle_fd;
> int opt;
>
> guest_modes_append_default();
>
> while ((opt = getopt(argc, argv, "hm:b:v:os:w:")) != -1) {
> switch (opt) {
> case 'm':
> guest_modes_cmdline(optarg);
> break;
> case 'b':
> params.vcpu_memory_bytes = parse_size(optarg);
> break;
> case 'v':
> params.nr_vcpus = atoi_positive("Number of vCPUs", optarg);
> break;
> case 'o':
> overlap_memory_access = true;
> break;
> case 's':
> params.backing_src = parse_backing_src_type(optarg);
> break;
> case 'w':
> idle_pages_warn_only =
> atoi_non_negative("Idle pages warning",
> optarg);
> break;
> case 'h':
> default:
> help(argv[0]);
> break;
> }
> }
>
> if (idle_pages_warn_only == -1)
> idle_pages_warn_only = access_tracking_unreliable();
>
> /*
> * If guest_page_size is larger than the host's page size, the
> * guest (memstress) will only fault in a subset of the host's pages.
> */
> total_pages = params.nr_vcpus * params.vcpu_memory_bytes /
> max_t(uint64_t, memstress_args.guest_page_size, getpagesize());
>
> if (lru_gen_usable()) {
> bool cg_created = true;
> char *test_cg = NULL;
> int ret;
>
> puts("Using lru_gen for aging");
> use_lru_gen = true;
>
> if (cg_find_controller_root(cgroup_root, sizeof(cgroup_root), "memory"))
> ksft_exit_skip("Cannot find memory group controller\n");
>
> test_cg = cg_name(cgroup_root, TEST_MEMCG_NAME);
> printf("Creating cgroup: %s\n", test_cg);
> if (cg_create(test_cg)) {
> if (errno == EEXIST)
> cg_created = false;
> else
> ksft_exit_skip("could not create new cgroup: %s\n", test_cg);
> }
>
> /*
> * This will fork off a new process to run the test within
> * a new memcg, so we need to properly propagate the return
> * value up.
> */
> ret = cg_run(test_cg, &run_test_for_each_guest_mode, ¶ms);
> if (cg_created)
> cg_destroy(test_cg);
> return ret;
> }
>
> puts("Using page_idle for aging");
> page_idle_fd = __open_path_or_exit("/sys/kernel/mm/page_idle/bitmap", O_RDWR,
> "Is CONFIG_IDLE_PAGE_TRACKING enabled?");
> close(page_idle_fd);
> run_test_for_each_guest_mode(NULL, ¶ms);
> return 0;
> }
And here is the diff that make the test start working for you:
diff --git a/tools/testing/selftests/kvm/access_tracking_perf_test.c b/tools/testing/selftests/kvm/access_tracking_perf_test.c
index d4ef201b67055..d4ae29c7dfe35 100644
--- a/tools/testing/selftests/kvm/access_tracking_perf_test.c
+++ b/tools/testing/selftests/kvm/access_tracking_perf_test.c
@@ -90,7 +90,10 @@ static int idle_pages_warn_only = -1;
static bool use_lru_gen;
/* Total number of pages to expect in the memcg after touching everything */
-static long total_pages;
+static long test_pages;
+
+/* Last generation we found the pages in */
+static int lru_gen_last_gen = -1;
struct test_params {
/* The backing source for the region of memory. */
@@ -265,11 +268,7 @@ static void lru_gen_mark_memory_idle(struct kvm_vm *vm)
struct timespec ts_start;
struct timespec ts_elapsed;
struct memcg_stats stats;
- int found_gens[2];
-
- /* Find current generation the pages lie in. */
- lru_gen_read_memcg_stats(&stats, TEST_MEMCG_NAME);
- found_gens[0] = find_generation(&stats, total_pages);
+ int new_gen;
/* Make a new generation */
clock_gettime(CLOCK_MONOTONIC, &ts_start);
@@ -277,23 +276,24 @@ static void lru_gen_mark_memory_idle(struct kvm_vm *vm)
ts_elapsed = timespec_elapsed(ts_start);
/* Check the generation again */
- found_gens[1] = find_generation(&stats, total_pages);
+ new_gen = find_generation(&stats, test_pages);
/*
* This function should only be invoked with newly-accessed pages,
* so pages should always move to a newer generation.
*/
- if (found_gens[0] >= found_gens[1]) {
+ if (new_gen <= lru_gen_last_gen) {
/* We did not move to a newer generation. */
- long idle_pages = lru_gen_sum_memcg_stats_for_gen(found_gens[1],
+ long idle_pages = lru_gen_sum_memcg_stats_for_gen(lru_gen_last_gen,
&stats);
- too_many_idle_pages(min_t(long, idle_pages, total_pages),
- total_pages, -1);
+ too_many_idle_pages(min_t(long, idle_pages, test_pages),
+ test_pages, -1);
}
pr_info("%-30s: %ld.%09lds\n",
"Mark memory idle (lru_gen)", ts_elapsed.tv_sec,
ts_elapsed.tv_nsec);
+ lru_gen_last_gen = new_gen;
}
static void assert_ucall(struct kvm_vcpu *vcpu, uint64_t expected_ucall)
@@ -410,6 +410,14 @@ static void run_test(enum vm_guest_mode mode, void *arg)
vm = memstress_create_vm(mode, nr_vcpus, params->vcpu_memory_bytes, 1,
params->backing_src, !overlap_memory_access);
+ /*
+ * If guest_page_size is larger than the host's page size, the
+ * guest (memstress) will only fault in a subset of the host's pages.
+ */
+ test_pages = params->nr_vcpus * params->vcpu_memory_bytes /
+ max(memstress_args.guest_page_size,
+ (uint64_t)getpagesize());
+
memstress_start_vcpu_threads(nr_vcpus, vcpu_thread_main);
pr_info("\n");
@@ -418,9 +426,18 @@ static void run_test(enum vm_guest_mode mode, void *arg)
if (use_lru_gen) {
struct memcg_stats stats;
- lru_gen_read_memcg_stats(&stats, TEST_MEMCG_NAME);
- TEST_ASSERT(lru_gen_sum_memcg_stats(&stats) >= total_pages,
- "Not all pages accounted for. Was the memcg set up correctly?");
+ /*
+ * Do a page table scan now. After initial population, aging
+ * may not cause the pages to move to a newer generation. Do
+ * an aging pass now so that future aging passes always move
+ * pages to a newer generation.
+ */
+ printf("Initial aging pass (lru_gen)\n");
+ lru_gen_do_aging(&stats, TEST_MEMCG_NAME);
+ TEST_ASSERT(lru_gen_sum_memcg_stats(&stats) >= test_pages,
+ "Not all pages accounted for (looking for %ld). "
+ "Was the memcg set up correctly?", test_pages);
+ access_memory(vm, nr_vcpus, ACCESS_WRITE, "Re-populating memory");
}
/* As a control, read and write to the populated memory first. */
@@ -496,7 +513,6 @@ static void help(char *name)
void destroy_cgroup(char *cg)
{
printf("Destroying cgroup: %s\n", cg);
- cg_destroy(cg);
}
int main(int argc, char *argv[])
@@ -541,50 +557,48 @@ int main(int argc, char *argv[])
}
}
- if (lru_gen_usable()) {
- if (cg_find_unified_root(cgroup_root, sizeof(cgroup_root), NULL))
- ksft_exit_skip("cgroup v2 isn't mounted\n");
-
- new_cg = cg_name(cgroup_root, TEST_MEMCG_NAME);
- printf("Creating cgroup: %s\n", new_cg);
- if (cg_create(new_cg) && errno != EEXIST)
- ksft_exit_skip("could not create new cgroup: %s\n", new_cg);
-
- use_lru_gen = true;
- } else {
- page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR);
- __TEST_REQUIRE(page_idle_fd >= 0,
- "Couldn't open /sys/kernel/mm/page_idle/bitmap. "
- "Is CONFIG_IDLE_PAGE_TRACKING enabled?");
-
- close(page_idle_fd);
- }
-
if (idle_pages_warn_only == -1)
idle_pages_warn_only = access_tracking_unreliable();
- /*
- * If guest_page_size is larger than the host's page size, the
- * guest (memstress) will only fault in a subset of the host's pages.
- */
- total_pages = params.nr_vcpus * params.vcpu_memory_bytes /
- max(memstress_args.guest_page_size,
- (uint64_t)getpagesize());
-
- if (use_lru_gen) {
+ if (lru_gen_usable()) {
+ bool cg_created = true;
int ret;
puts("Using lru_gen for aging");
+ use_lru_gen = true;
+
+ if (cg_find_controller_root(cgroup_root, sizeof(cgroup_root), "memory"))
+ ksft_exit_skip("Cannot find memory cgroup controller\n");
+
+ new_cg = cg_name(cgroup_root, TEST_MEMCG_NAME);
+ printf("Creating cgroup: %s\n", new_cg);
+ if (cg_create(new_cg)) {
+ if (errno == EEXIST) {
+ printf("Found existing cgroup");
+ cg_created = false;
+ }
+ else
+ ksft_exit_skip("could not create new cgroup: %s\n", new_cg);
+ }
+
/*
* This will fork off a new process to run the test within
* a new memcg, so we need to properly propagate the return
* value up.
*/
ret = cg_run(new_cg, &run_test_in_cg, ¶ms);
- destroy_cgroup(new_cg);
+ if (cg_created)
+ cg_destroy(new_cg);
if (ret)
return ret;
} else {
+ page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR);
+ __TEST_REQUIRE(page_idle_fd >= 0,
+ "Couldn't open /sys/kernel/mm/page_idle/bitmap. "
+ "Is CONFIG_IDLE_PAGE_TRACKING enabled?");
+
+ close(page_idle_fd);
+
puts("Using page_idle for aging");
for_each_guest_mode(run_test, ¶ms);
}
diff --git a/tools/testing/selftests/kvm/lib/lru_gen_util.c b/tools/testing/selftests/kvm/lib/lru_gen_util.c
index 783a1f1028a26..cab54935b160a 100644
--- a/tools/testing/selftests/kvm/lib/lru_gen_util.c
+++ b/tools/testing/selftests/kvm/lib/lru_gen_util.c
@@ -341,7 +341,7 @@ int lru_gen_find_generation(const struct memcg_stats *stats,
min_gen = gen < min_gen ? gen : min_gen;
}
- for (gen = min_gen; gen < max_gen; ++gen)
+ for (gen = min_gen; gen <= max_gen; ++gen)
/* See if this generation has enough pages. */
if (lru_gen_sum_memcg_stats_for_gen(gen, stats) > pages)
return gen;
On Tue, Apr 29, 2025, James Houghton wrote: > On Mon, Apr 28, 2025 at 9:19 PM Sean Christopherson <seanjc@google.com> wrote: > > Using MGLRU on my home box fails. It's full cgroup v2, and has both > > CONFIG_IDLE_PAGE_TRACKING=y and MGLRU enabled. > > > > ==== Test Assertion Failure ==== > > access_tracking_perf_test.c:244: false > > pid=114670 tid=114670 errno=17 - File exists > > 1 0x00000000004032a9: find_generation at access_tracking_perf_test.c:244 > > 2 0x00000000004032da: lru_gen_mark_memory_idle at access_tracking_perf_test.c:272 > > 3 0x00000000004034e4: mark_memory_idle at access_tracking_perf_test.c:391 > > 4 (inlined by) run_test at access_tracking_perf_test.c:431 > > 5 0x0000000000403d84: for_each_guest_mode at guest_modes.c:96 > > 6 0x0000000000402c61: run_test_for_each_guest_mode at access_tracking_perf_test.c:492 > > 7 0x000000000041d8e2: cg_run at cgroup_util.c:382 > > 8 0x00000000004027fa: main at access_tracking_perf_test.c:572 > > 9 0x00007fa1cb629d8f: ?? ??:0 > > 10 0x00007fa1cb629e3f: ?? ??:0 > > 11 0x00000000004029d4: _start at ??:? > > Could not find a generation with 90% of guest memory (235929 pages). > > > > Interestingly, if I force the test to use /sys/kernel/mm/page_idle/bitmap, it > > passes. > > > > Please try to reproduce the failure (assuming you haven't already tested that > > exact combination of cgroups v2, MGLRU=y, and CONFIG_IDLE_PAGE_TRACKING=y). I > > don't have bandwidth to dig any further at this time. > > Sorry... please see the bottom of this message for a diff that should fix this. > It fixes these bugs: > > 1. Tracking generation numbers without hardware Accessed bit management. > (This is addition of lru_gen_last_gen.) > 1.5 It does an initial aging pass so that pages always move to newer > generations in (or before) the subsequent aging passes. This probably > isn't needed given the change I made for (1). > 2. Fixes the expected number of pages for guest page sizes > PAGE_SIZE. > (This is the move of test_pages. test_pages has also been renamed to avoid > shadowing.) > 3. Fixes an off-by-one error when looking for the generation with the most > pages. Previously it failed to check the youngest generation, which I think > is the bug you ran into. (This is the change to lru_gen_util.c.) Ya, this was the bug I initially ran into, I also encountered more failues after applying just that fix. But, with the full diff applied, it's passing, so good to go for the next version from my end.
On Mon, Apr 14, 2025, James Houghton wrote:
> By using MGLRU's debugfs for invoking test_young() and clear_young(), we
> avoid page_idle's incompatibility with MGLRU, and we can mark pages as
> idle (clear_young()) much faster.
>
> The ability to use page_idle is left in, as it is useful for kernels
> that do not have MGLRU built in. If MGLRU is enabled but is not usable
> (e.g. we can't access the debugfs mount), the test will fail, as
> page_idle is not compatible with MGLRU.
>
> cgroup utility functions have been borrowed so that, when running with
> MGLRU, we can create a memcg in which to run our test.
>
> Other MGLRU-debugfs-specific parsing code has been added to
> lru_gen_util.{c,h}.
This fails on my end due to not being able to find the cgroup. I spent about 15
minutes poking at it and gave it. FWIW, this is on our devrez hosts, so it's
presumably similar hardware to what you tested on.
Even if this turns out to be PEBKAC or some CONFIG_XXX incompatibility, there
needs to be better hints provided to the user of how they can some this.
And this would be a perfect opportunity to clean up this:
__TEST_REQUIRE(page_idle_fd >= 0,
"CONFIG_IDLE_PAGE_TRACKING is not enabled");
I can't count the number of times I've forgotten to run the test with root
privileges, and wasted a bunch of time remembering it's not that the kernel
doesn't have CONFIG_IDLE_PAGE_TRACKING, but that /sys/kernel/mm/page_idle/bitmap
isn't accessible.
I mention that, because on a kernel with MGRLU available but disabled, and
CONFIG_IDLE_PAGE_TRACKING=n, the user has no idea that they _can_ run the test
without mucking with their kernel.
==== Test Assertion Failure ====
lib/lru_gen_util.c:229: stats->memcg_id > 0
pid=423298 tid=423298 errno=2 - No such file or directory
1 0x0000000000408b45: lru_gen_read_memcg_stats at lru_gen_util.c:229
2 0x0000000000402e4c: run_test at access_tracking_perf_test.c:421
3 0x0000000000403694: for_each_guest_mode at guest_modes.c:96
4 0x00000000004023dd: run_test_in_cg at access_tracking_perf_test.c:467
5 0x000000000041ba65: cg_run at cgroup_util.c:362
6 0x0000000000402042: main at access_tracking_perf_test.c:583
7 0x000000000041c753: __libc_start_call_main at libc-start.o:?
8 0x000000000041e9ac: __libc_start_main_impl at ??:?
9 0x0000000000402280: _start at ??:?
Couldn't find memcg: access_tracking_perf_test
Did the memcg get created in the proper mount?
Destroying cgroup: /sys/fs/cgroup/access_tracking_perf_test
On Fri, Apr 25, 2025 at 8:31 PM Sean Christopherson <seanjc@google.com> wrote:
>
> On Mon, Apr 14, 2025, James Houghton wrote:
> > By using MGLRU's debugfs for invoking test_young() and clear_young(), we
> > avoid page_idle's incompatibility with MGLRU, and we can mark pages as
> > idle (clear_young()) much faster.
> >
> > The ability to use page_idle is left in, as it is useful for kernels
> > that do not have MGLRU built in. If MGLRU is enabled but is not usable
> > (e.g. we can't access the debugfs mount), the test will fail, as
> > page_idle is not compatible with MGLRU.
> >
> > cgroup utility functions have been borrowed so that, when running with
> > MGLRU, we can create a memcg in which to run our test.
> >
> > Other MGLRU-debugfs-specific parsing code has been added to
> > lru_gen_util.{c,h}.
>
> This fails on my end due to not being able to find the cgroup. I spent about 15
> minutes poking at it and gave it. FWIW, this is on our devrez hosts, so it's
> presumably similar hardware to what you tested on.
Ah sorry, yes, this selftest needs to be patched when running the
devrez userspace, which uses a combination of cgroup-v1 and cgroup-v2.
Simply hard-coding the root to "/dev/cgroup/memory" (which is in fact
a cgroup-v1 mount) should be what you need if you want to give it
another go.
> Even if this turns out to be PEBKAC or some CONFIG_XXX incompatibility, there
> needs to be better hints provided to the user of how they can some this.
Yeah this can be better. I should at least check that the found
cgroup-v2 root's cgroup.controllers contains "memory". In your case,
it did not.
(cgroup.controllers is not available for cgroup-v1 -- because it
doesn't make sense -- so if I patch the selftest to check this file,
using cgroup-v1 mounts will stop working. So, again, you'd need to
patch the test to work on devrez.)
> And this would be a perfect opportunity to clean up this:
>
> __TEST_REQUIRE(page_idle_fd >= 0,
> "CONFIG_IDLE_PAGE_TRACKING is not enabled");
I think the change I've already made to this string is sufficient
(happy to change it further if you like):
> > + __TEST_REQUIRE(page_idle_fd >= 0,
> > + "Couldn't open /sys/kernel/mm/page_idle/bitmap. "
> > + "Is CONFIG_IDLE_PAGE_TRACKING enabled?");
> I can't count the number of times I've forgotten to run the test with root
> privileges, and wasted a bunch of time remembering it's not that the kernel
> doesn't have CONFIG_IDLE_PAGE_TRACKING, but that /sys/kernel/mm/page_idle/bitmap
> isn't accessible.
>
> I mention that, because on a kernel with MGRLU available but disabled, and
> CONFIG_IDLE_PAGE_TRACKING=n, the user has no idea that they _can_ run the test
> without mucking with their kernel.
Fair enough, I'll change the output from the test for that
configuration to say something like: "please either enable the missing
MGLRU features (e.g. `echo 3 > /sys/kernel/mm/lru_gen/enabled`) or
recompile your kernel with CONFIG_IDLE_PAGE_TRACKING=y."
> ==== Test Assertion Failure ====
> lib/lru_gen_util.c:229: stats->memcg_id > 0
> pid=423298 tid=423298 errno=2 - No such file or directory
> 1 0x0000000000408b45: lru_gen_read_memcg_stats at lru_gen_util.c:229
> 2 0x0000000000402e4c: run_test at access_tracking_perf_test.c:421
> 3 0x0000000000403694: for_each_guest_mode at guest_modes.c:96
> 4 0x00000000004023dd: run_test_in_cg at access_tracking_perf_test.c:467
> 5 0x000000000041ba65: cg_run at cgroup_util.c:362
> 6 0x0000000000402042: main at access_tracking_perf_test.c:583
> 7 0x000000000041c753: __libc_start_call_main at libc-start.o:?
> 8 0x000000000041e9ac: __libc_start_main_impl at ??:?
> 9 0x0000000000402280: _start at ??:?
> Couldn't find memcg: access_tracking_perf_test
> Did the memcg get created in the proper mount?
> Destroying cgroup: /sys/fs/cgroup/access_tracking_perf_test
Thanks for taking a look!
On Mon, Apr 28, 2025, James Houghton wrote:
> On Fri, Apr 25, 2025 at 8:31 PM Sean Christopherson <seanjc@google.com> wrote:
> >
> > On Mon, Apr 14, 2025, James Houghton wrote:
> > > By using MGLRU's debugfs for invoking test_young() and clear_young(), we
> > > avoid page_idle's incompatibility with MGLRU, and we can mark pages as
> > > idle (clear_young()) much faster.
> > >
> > > The ability to use page_idle is left in, as it is useful for kernels
> > > that do not have MGLRU built in. If MGLRU is enabled but is not usable
> > > (e.g. we can't access the debugfs mount), the test will fail, as
> > > page_idle is not compatible with MGLRU.
> > >
> > > cgroup utility functions have been borrowed so that, when running with
> > > MGLRU, we can create a memcg in which to run our test.
> > >
> > > Other MGLRU-debugfs-specific parsing code has been added to
> > > lru_gen_util.{c,h}.
> >
> > This fails on my end due to not being able to find the cgroup. I spent about 15
> > minutes poking at it and gave it. FWIW, this is on our devrez hosts, so it's
> > presumably similar hardware to what you tested on.
>
> Ah sorry, yes, this selftest needs to be patched when running the
> devrez userspace, which uses a combination of cgroup-v1 and cgroup-v2.
> Simply hard-coding the root to "/dev/cgroup/memory" (which is in fact
> a cgroup-v1 mount) should be what you need if you want to give it
> another go.
>
> > Even if this turns out to be PEBKAC or some CONFIG_XXX incompatibility, there
> > needs to be better hints provided to the user of how they can some this.
>
> Yeah this can be better. I should at least check that the found
> cgroup-v2 root's cgroup.controllers contains "memory". In your case,
> it did not.
>
> (cgroup.controllers is not available for cgroup-v1 -- because it
> doesn't make sense -- so if I patch the selftest to check this file,
> using cgroup-v1 mounts will stop working. So, again, you'd need to
> patch the test to work on devrez.)
Or, and I know this going to sound crazy, what if we simply make the test work
with v1 or v2? That is not hard to do, at all. Please slot the below into the
next version of the series. Feel free to modify it as needed, e.g. to address
other maintainer feedback. The only thing I care about is the selftest not failing.
> > And this would be a perfect opportunity to clean up this:
> >
> > __TEST_REQUIRE(page_idle_fd >= 0,
> > "CONFIG_IDLE_PAGE_TRACKING is not enabled");
>
> I think the change I've already made to this string is sufficient
> (happy to change it further if you like):
Doh, I missed that your patch did already improve the skip message to spit out
/sys/kernel/mm/page_idle/bitmap; that part I definitely like.
> > > + __TEST_REQUIRE(page_idle_fd >= 0,
> > > + "Couldn't open /sys/kernel/mm/page_idle/bitmap. "
> > > + "Is CONFIG_IDLE_PAGE_TRACKING enabled?");
>
> > I can't count the number of times I've forgotten to run the test with root
> > privileges, and wasted a bunch of time remembering it's not that the kernel
> > doesn't have CONFIG_IDLE_PAGE_TRACKING, but that /sys/kernel/mm/page_idle/bitmap
> > isn't accessible.
> >
> > I mention that, because on a kernel with MGRLU available but disabled, and
> > CONFIG_IDLE_PAGE_TRACKING=n, the user has no idea that they _can_ run the test
> > without mucking with their kernel.
>
> Fair enough, I'll change the output from the test for that
> configuration to say something like: "please either enable the missing
> MGLRU features (e.g. `echo 3 > /sys/kernel/mm/lru_gen/enabled`) or
> recompile your kernel with CONFIG_IDLE_PAGE_TRACKING=y."
That's still misleading. In my case, my kernels are already built with
CONFIG_IDLE_PAGE_TRACKING=y.
Looking at this again, we can do much better. For my permissions issue, open()
should fail with -EACCES, whereas the CONFIG_IDLE_PAGE_TRACKING=n case should
fail with ENOENT. And that is easy enough to handle in open_path_or_exit().
I'll send a small series to clean that up, and then will apply this series on top.
The resulting conflict will be trivial to resolve, so don't worry about rebasing
on top of my mini-series.
--
From: Sean Christopherson <seanjc@google.com>
Date: Mon, 28 Apr 2025 17:36:06 -0700
Subject: [PATCH] cgroup: selftests: Add API to find root of specific
controller
Add an API in the cgroups library to find the root of a specific
controller. KVM selftests will use the API to find the memory controller.
Search for the controller on both v1 and v2 mounts, as KVM selftests'
usage will be completely oblivious of v1 versus v2.
Signed-off-by: Sean Christopherson <seanjc@google.com>
---
.../selftests/cgroup/lib/cgroup_util.c | 32 +++++++++++++++----
.../cgroup/lib/include/cgroup_util.h | 1 +
2 files changed, 27 insertions(+), 6 deletions(-)
diff --git a/tools/testing/selftests/cgroup/lib/cgroup_util.c b/tools/testing/selftests/cgroup/lib/cgroup_util.c
index 69a68f43e3fa..4e7e7329b226 100644
--- a/tools/testing/selftests/cgroup/lib/cgroup_util.c
+++ b/tools/testing/selftests/cgroup/lib/cgroup_util.c
@@ -217,7 +217,8 @@ int cg_write_numeric(const char *cgroup, const char *control, long value)
return cg_write(cgroup, control, buf);
}
-int cg_find_unified_root(char *root, size_t len, bool *nsdelegate)
+static int cg_find_root(char *root, size_t len, const char *controller,
+ bool *nsdelegate)
{
char buf[10 * PAGE_SIZE];
char *fs, *mount, *type, *options;
@@ -237,17 +238,36 @@ int cg_find_unified_root(char *root, size_t len, bool *nsdelegate)
strtok(NULL, delim);
strtok(NULL, delim);
- if (strcmp(type, "cgroup2") == 0) {
- strncpy(root, mount, len);
- if (nsdelegate)
- *nsdelegate = !!strstr(options, "nsdelegate");
- return 0;
+ if (strcmp(type, "cgroup") == 0) {
+ if (!controller || !strstr(options, controller))
+ continue;
+ } else if (strcmp(type, "cgroup2") == 0) {
+ if (controller &&
+ cg_read_strstr(mount, "cgroup.controllers", controller))
+ continue;
+ } else {
+ continue;
}
+ strncpy(root, mount, len);
+
+ if (nsdelegate)
+ *nsdelegate = !!strstr(options, "nsdelegate");
+ return 0;
}
return -1;
}
+int cg_find_controller_root(char *root, size_t len, const char *controller)
+{
+ return cg_find_root(root, len, controller, NULL);
+}
+
+int cg_find_unified_root(char *root, size_t len, bool *nsdelegate)
+{
+ return cg_find_root(root, len, NULL, nsdelegate);
+}
+
int cg_create(const char *cgroup)
{
return mkdir(cgroup, 0755);
diff --git a/tools/testing/selftests/cgroup/lib/include/cgroup_util.h b/tools/testing/selftests/cgroup/lib/include/cgroup_util.h
index cbe6f0b4247d..d9e6e3090b3f 100644
--- a/tools/testing/selftests/cgroup/lib/include/cgroup_util.h
+++ b/tools/testing/selftests/cgroup/lib/include/cgroup_util.h
@@ -21,6 +21,7 @@ static inline int values_close(long a, long b, int err)
return labs(a - b) <= (a + b) / 100 * err;
}
+extern int cg_find_controller_root(char *root, size_t len, const char *controller);
extern int cg_find_unified_root(char *root, size_t len, bool *nsdelegate);
extern char *cg_name(const char *root, const char *name);
extern char *cg_name_indexed(const char *root, const char *name, int index);
base-commit: 65a87fcc85da28361af2a5718c109dbc2f8d54a2
--
© 2016 - 2025 Red Hat, Inc.