From nobody Thu Dec 18 05:02:03 2025 Received: from mail-vk1-f201.google.com (mail-vk1-f201.google.com [209.85.221.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B307A277008 for ; Thu, 8 May 2025 18:46:52 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730014; cv=none; b=nSZufVPKoFzM7/4E1MpYiOJ5if4OFREgA+e9yWJgUvig3Gxb9N3iaXdtkXUN5nX1Fi2hULBpc5iTm23Gs1cgShlpytdTZfBpt0qWZM8Mp/w/KT+A9atdC+iysK77AHrW633lG+yKG/dfTYswKPHZCvzLC9EeSC6HyIXjGVPpJKs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730014; c=relaxed/simple; bh=ID+kESnpGV9XC5UpFrnA1MTFIrRsvE/G+IFXut8ZjKI=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=EwGv50HEYAlg16+gP0vAA54yYhrIMGiXTcAbGybxFUDDpdalzQAD41FuTA4v9f+QsQjyJWVAl4G2XHRpwo80FlCoIFlYxXBLKG8IZCYAuKGnhl5BCX7Z6YVBc6J8HDg0z7ENksAdw7hBTGxPe42ZsSR9Po3zbrjBbCpGlw57e70= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=XTuHkBIT; arc=none smtp.client-ip=209.85.221.201 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="XTuHkBIT" Received: by mail-vk1-f201.google.com with SMTP id 71dfb90a1353d-52af857ae54so347294e0c.3 for ; Thu, 08 May 2025 11:46:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746730011; x=1747334811; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=Hxkkjg5u6Lgu9hSFXDjlO0GOLkT7I31/k4lHPDm8iZ0=; b=XTuHkBITXygWOn5VP/fp4Okh4nE4Sv44/bX80NCtPdgud8x0s5pL4JYqaFdsQv+Y6H fWhbKZNfVQ9JCJZJEOj6iXINjIKVjHK3qq2oKLbCw2S9ilJO56buiPXigUX0xGOPtmV2 Vrom+O3Pj8fi3P2cwpEez69ix06p1NQHyUgRhuNJ5bHRucvFPwq9Ffe0oHvoNdnI20wW SLaS9fBxAJVuGS/EwLwJU1nQKn0IdLx/3uJPP1ud8hxCynxEWAngRdr4GgllV+aEiVEX fzSYuU1z61cDWrg8h1AYaZchdtIG4fEHO728bX3U59MJfIemiHLOiDkLs8P8wZ/XNoep FicA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746730011; x=1747334811; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=Hxkkjg5u6Lgu9hSFXDjlO0GOLkT7I31/k4lHPDm8iZ0=; b=NitW70/PQQh/fiHPDBFKLOzXGHsva85XQnDloAsLoV9Yf1wrgrqbU1ulRY382LNRQh UuZ4ohzazJl4wC3wnYbZpvYzH/gu9M21qSip+C/60anzixerwx800GMDcE9zcpMnetf1 L6EGY4dADQUDJiWbINexboUXJ80dZCmP4r0ZYMUv5TD7nbbhgM5+Jn/jPQZVI11Od4kG /dAbnZUYArTFJdADBnAMH1b2iCW/drfyGvXc305PWgZh4qLQOoJl0sDwkyyoc6dZr8BI qoDRP+J9ECSWTJAJboe1JUfk2Dsag7Evc8y22aMjxOULKQHkjHjiAP8CpUikvdhstrLz 7vng== X-Forwarded-Encrypted: i=1; AJvYcCVSEjeL4/cbetcvfm+kkvBbBB6KB6KN/Bc1RyqZSDAA3VvDZof5ocqa1SD61BLDuPADLmigDn1QaEW9yUE=@vger.kernel.org X-Gm-Message-State: AOJu0YwWp0VxAvShv5GF2YxaRhUJNbBrYLDOWIdMtM/pehtzqHMydSu5 7iRzDE8y3KR3XffAegmObZ65qM1AtmqrmjZ+XWq8HMUvS/G8PE4tG8NKgsI32ugdoWL9k6vQ9KN rxO74yCxEi7NLhuV0KQ== X-Google-Smtp-Source: AGHT+IHvbfgIWOhtssbanXIq57gUuQkyH7+nzkAOyeL8z91e6IyZf0dy8+Xf3YfxbrenPkYR/Im4OMTBcB25PxoE X-Received: from vsbhy11.prod.google.com ([2002:a67:e7cb:0:b0:4be:5ff1:69d6]) (user=jthoughton job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6102:15a0:b0:4dd:b9bc:df71 with SMTP id ada2fe7eead31-4deed3552b0mr662515137.10.1746730011602; Thu, 08 May 2025 11:46:51 -0700 (PDT) Date: Thu, 8 May 2025 18:46:42 +0000 In-Reply-To: <20250508184649.2576210-1-jthoughton@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250508184649.2576210-1-jthoughton@google.com> X-Mailer: git-send-email 2.49.0.1015.ga840276032-goog Message-ID: <20250508184649.2576210-2-jthoughton@google.com> Subject: [PATCH v4 1/7] KVM: selftests: Extract guts of THP accessor to standalone sysfs helpers From: James Houghton To: Sean Christopherson , kvm@vger.kernel.org Cc: Maxim Levitsky , Axel Rasmussen , Tejun Heo , Johannes Weiner , mkoutny@suse.com, Yosry Ahmed , Yu Zhao , David Matlack , James Houghton , cgroups@vger.kernel.org, linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Sean Christopherson Extract the guts of thp_configured() and get_trans_hugepagesz() to standalone helpers so that the core logic can be reused for other sysfs files, e.g. to query numa_balancing. Opportunistically assert that the initial fscanf() read at least one byte, and add a comment explaining the second call to fscanf(). Signed-off-by: Sean Christopherson Signed-off-by: Maxim Levitsky Signed-off-by: James Houghton --- tools/testing/selftests/kvm/lib/test_util.c | 35 ++++++++++++++------- 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/tools/testing/selftests/kvm/lib/test_util.c b/tools/testing/se= lftests/kvm/lib/test_util.c index 8ed0b74ae8373..3dc8538f5d696 100644 --- a/tools/testing/selftests/kvm/lib/test_util.c +++ b/tools/testing/selftests/kvm/lib/test_util.c @@ -132,37 +132,50 @@ void print_skip(const char *fmt, ...) puts(", skipping test"); } =20 -bool thp_configured(void) +static bool test_sysfs_path(const char *path) { - int ret; struct stat statbuf; + int ret; =20 - ret =3D stat("/sys/kernel/mm/transparent_hugepage", &statbuf); + ret =3D stat(path, &statbuf); TEST_ASSERT(ret =3D=3D 0 || (ret =3D=3D -1 && errno =3D=3D ENOENT), - "Error in stating /sys/kernel/mm/transparent_hugepage"); + "Error in stat()ing '%s'", path); =20 return ret =3D=3D 0; } =20 -size_t get_trans_hugepagesz(void) +bool thp_configured(void) +{ + return test_sysfs_path("/sys/kernel/mm/transparent_hugepage"); +} + +static size_t get_sysfs_val(const char *path) { size_t size; FILE *f; int ret; =20 - TEST_ASSERT(thp_configured(), "THP is not configured in host kernel"); - - f =3D fopen("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size", "r"); - TEST_ASSERT(f !=3D NULL, "Error in opening transparent_hugepage/hpage_pmd= _size"); + f =3D fopen(path, "r"); + TEST_ASSERT(f, "Error opening '%s'", path); =20 ret =3D fscanf(f, "%ld", &size); + TEST_ASSERT(ret > 0, "Error reading '%s'", path); + + /* Re-scan the input stream to verify the entire file was read. */ ret =3D fscanf(f, "%ld", &size); - TEST_ASSERT(ret < 1, "Error reading transparent_hugepage/hpage_pmd_size"); - fclose(f); + TEST_ASSERT(ret < 1, "Error reading '%s'", path); =20 + fclose(f); return size; } =20 +size_t get_trans_hugepagesz(void) +{ + TEST_ASSERT(thp_configured(), "THP is not configured in host kernel"); + + return get_sysfs_val("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size"= ); +} + size_t get_def_hugetlb_pagesz(void) { char buf[64]; --=20 2.49.0.1015.ga840276032-goog From nobody Thu Dec 18 05:02:03 2025 Received: from mail-vs1-f74.google.com (mail-vs1-f74.google.com [209.85.217.74]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6BB212857C6 for ; Thu, 8 May 2025 18:46:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.217.74 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730016; cv=none; b=X3X9kPcKgJce2V8GEmtrjPvC9i+5oFprZkMpUnCbM4WiI9gQIjgzAhFU0r4gI/016R1ydMrObWwvtEW171CsxxfPp6tIhY6q7Q853WM0+X1fWnSjLrAYCfO7o2sDbC8ixKUUZnsYo3eQTTNyYoYfaqpyngP8OWBZqce28M6P1Bc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730016; c=relaxed/simple; bh=ZcVsgXQwg2/GyQr/vof0NC0TWU9+fC8WarKxZppgA0g=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=SRAbbl/h12Ho9Pj0KkLcZ9mMRX5afxYbmpbhdH+zat30hM/M/5QujGwOWarROiiKJSLHnH5ddGnZ5iXmizi2XOUCmFjTbVgGUV+Ch9Vb+RoGcACsvfpgweSs3R0nYp9SMsNklJaObgqpaKmAZesciEcavhBIGd3S3F+zrASKPbo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=jQLY8BDU; arc=none smtp.client-ip=209.85.217.74 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="jQLY8BDU" Received: by mail-vs1-f74.google.com with SMTP id ada2fe7eead31-4deed7cfb95so11760137.1 for ; Thu, 08 May 2025 11:46:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746730012; x=1747334812; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=qj43d6+YzTB6RT1En1eLIwlHOTDu4X6j9DjphPgdOm8=; b=jQLY8BDUgIdDMmC41cTGDETLKQLEb6y+JMMM3Ym0d+cBz2Pheo/fGgWvzGARk+XfCt msNpHLd1J47KWbcFNrYKPAaMUxci81m7cFdvnL88z+UM6mt051ekXKI/v8yWQ8UaPYDt LyucROCoHy3a92O6cf0ESGkYNol7hkWlIKYBA0RSHtb5SAZ0bLpsVxewvP+KJ/3RY4cj 9Q3FVqRNsugNfk7Wa4KIWlfAZLniRKw8VSoKpUEDk6c71P5JerYN1tKuRAQMrciv5+9r 0+xnY7niqoh+t5O/XvGXeWvd1BXDz57RSjvwymenA5fpQmp1eiiE+i9ETTbi90sggjsM ABoA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746730012; x=1747334812; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=qj43d6+YzTB6RT1En1eLIwlHOTDu4X6j9DjphPgdOm8=; b=Q6BW5wXvefndpx3ejdaFY2b6TUAzp0ydrtludZX06cIFeTMI3CntdRQdEgmgJSg35E DiRNmPAIQdgcerc9Zmyfo3LvBUIKmn0fzEdAnufNvrJ7KYhT7Kn0iOQh3jbTKLZTRIol EdB9rajRfB7paHSuy7e6nk3SAXF3fRMb7jKAIiHBbfmAtgPAL5cpG0ZkRMCIfoIAw9b3 QTRjsSThmC2CbTCyB0qGTR64uuggBy/4W8lh9L0o5gJLMhEEN8VypnJjqJYxblmOP6r+ RrnNEAhuEcdjcbjF3WYxO6ZJZfLtFhegL3/I5Nu9vRMBwLfW+X62qAWYUEThL4uR8xiV GHVA== X-Forwarded-Encrypted: i=1; AJvYcCXMEKmD6JZ3R6DCWd/FN4IZ1ndnmGL9VDcmPd9rmevr8Gb9xtLm1VWYG0q8sfP6K0p+byWatwUsEMZ3eWU=@vger.kernel.org X-Gm-Message-State: AOJu0Yx86/toUFDqhcQCPD3+VSpNZH++hdDX5wr0yiWRKK3hohFEMn6N Nu8v7MWGlY78fqrpgV0oSQsDKGQSFUaQXb/pKenzzuVJYsZVaPHFn9gTMrBGO2/HdwHM0lRCVyn GhQ39icMiuRcZIs7yXw== X-Google-Smtp-Source: AGHT+IGiJCw0IZYg4Spkkv5MvH3n/nmBvrY1UsIkawmfL66rCGdSh6drerePqQFfzIMxCsgsCNqImNaJ+BexciQP X-Received: from uabfe4.prod.google.com ([2002:a05:6130:1884:b0:877:a5a1:6bc6]) (user=jthoughton job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6102:2c19:b0:4c2:f972:b699 with SMTP id ada2fe7eead31-4deed3053e4mr494779137.5.1746730012318; Thu, 08 May 2025 11:46:52 -0700 (PDT) Date: Thu, 8 May 2025 18:46:43 +0000 In-Reply-To: <20250508184649.2576210-1-jthoughton@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250508184649.2576210-1-jthoughton@google.com> X-Mailer: git-send-email 2.49.0.1015.ga840276032-goog Message-ID: <20250508184649.2576210-3-jthoughton@google.com> Subject: [PATCH v4 2/7] KVM: selftests: access_tracking_perf_test: Add option to skip the sanity check From: James Houghton To: Sean Christopherson , kvm@vger.kernel.org Cc: Maxim Levitsky , Axel Rasmussen , Tejun Heo , Johannes Weiner , mkoutny@suse.com, Yosry Ahmed , Yu Zhao , David Matlack , James Houghton , cgroups@vger.kernel.org, linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Maxim Levitsky Add an option to skip sanity check of number of still idle pages, and set it by default to skip, in case hypervisor or NUMA balancing is detected. Signed-off-by: Maxim Levitsky Co-developed-by: James Houghton Signed-off-by: James Houghton Reviewed-by: Maxim Levitsky --- .../selftests/kvm/access_tracking_perf_test.c | 62 ++++++++++++++++--- .../testing/selftests/kvm/include/test_util.h | 1 + tools/testing/selftests/kvm/lib/test_util.c | 7 +++ 3 files changed, 61 insertions(+), 9 deletions(-) diff --git a/tools/testing/selftests/kvm/access_tracking_perf_test.c b/tool= s/testing/selftests/kvm/access_tracking_perf_test.c index 447e619cf856e..a2ac6fa2ba141 100644 --- a/tools/testing/selftests/kvm/access_tracking_perf_test.c +++ b/tools/testing/selftests/kvm/access_tracking_perf_test.c @@ -65,6 +65,16 @@ static int vcpu_last_completed_iteration[KVM_MAX_VCPUS]; /* Whether to overlap the regions of memory vCPUs access. */ static bool overlap_memory_access; =20 +/* + * If the test should only warn if there are too many idle pages (i.e., it= is + * expected). + * -1: Not yet set. + * 0: We do not expect too many idle pages, so FAIL if too many idle page= s. + * 1: Having too many idle pages is expected, so merely print a warning if + * too many idle pages are found. + */ +static int idle_pages_warn_only =3D -1; + struct test_params { /* The backing source for the region of memory. */ enum vm_mem_backing_src_type backing_src; @@ -177,18 +187,12 @@ static void mark_vcpu_memory_idle(struct kvm_vm *vm, * arbitrary; high enough that we ensure most memory access went through * access tracking but low enough as to not make the test too brittle * over time and across architectures. - * - * When running the guest as a nested VM, "warn" instead of asserting - * as the TLB size is effectively unlimited and the KVM doesn't - * explicitly flush the TLB when aging SPTEs. As a result, more pages - * are cached and the guest won't see the "idle" bit cleared. */ if (still_idle >=3D pages / 10) { -#ifdef __x86_64__ - TEST_ASSERT(this_cpu_has(X86_FEATURE_HYPERVISOR), + TEST_ASSERT(idle_pages_warn_only, "vCPU%d: Too many pages still idle (%lu out of %lu)", vcpu_idx, still_idle, pages); -#endif + printf("WARNING: vCPU%d: Too many pages still idle (%lu out of %lu), " "this will affect performance results.\n", vcpu_idx, still_idle, pages); @@ -328,6 +332,32 @@ static void run_test(enum vm_guest_mode mode, void *ar= g) memstress_destroy_vm(vm); } =20 +static int access_tracking_unreliable(void) +{ +#ifdef __x86_64__ + /* + * When running nested, the TLB size may be effectively unlimited (for + * example, this is the case when running on KVM L0), and KVM doesn't + * explicitly flush the TLB when aging SPTEs. As a result, more pages + * are cached and the guest won't see the "idle" bit cleared. + */ + if (this_cpu_has(X86_FEATURE_HYPERVISOR)) { + puts("Skipping idle page count sanity check, because the test is run nes= ted"); + return 1; + } +#endif + /* + * When NUMA balancing is enabled, guest memory will be unmapped to get + * NUMA faults, dropping the Accessed bits. + */ + if (is_numa_balancing_enabled()) { + puts("Skipping idle page count sanity check, because NUMA balancing is e= nabled"); + return 1; + } + + return 0; +} + static void help(char *name) { puts(""); @@ -342,6 +372,12 @@ 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" + " of pages are still seen as idle/old after accessing guest\n" + " memory. >0 =3D=3D warn only, 0 =3D=3D fail, <0 =3D=3D auto.= For auto\n" + " mode, the test fails by default, but switches to warn only\n" + " if NUMA balancing is enabled or the test detects it's runnin= g\n" + " in a VM.\n"); backing_src_help("-s"); puts(""); exit(0); @@ -359,7 +395,7 @@ int main(int argc, char *argv[]) =20 guest_modes_append_default(); =20 - while ((opt =3D getopt(argc, argv, "hm:b:v:os:")) !=3D -1) { + while ((opt =3D getopt(argc, argv, "hm:b:v:os:w:")) !=3D -1) { switch (opt) { case 'm': guest_modes_cmdline(optarg); @@ -376,6 +412,11 @@ int main(int argc, char *argv[]) case 's': params.backing_src =3D parse_backing_src_type(optarg); break; + case 'w': + idle_pages_warn_only =3D + atoi_non_negative("Idle pages warning", + optarg); + break; case 'h': default: help(argv[0]); @@ -388,6 +429,9 @@ int main(int argc, char *argv[]) "CONFIG_IDLE_PAGE_TRACKING is not enabled"); close(page_idle_fd); =20 + if (idle_pages_warn_only =3D=3D -1) + idle_pages_warn_only =3D access_tracking_unreliable(); + for_each_guest_mode(run_test, ¶ms); =20 return 0; diff --git a/tools/testing/selftests/kvm/include/test_util.h b/tools/testin= g/selftests/kvm/include/test_util.h index 77d13d7920cb8..c6ef895fbd9ab 100644 --- a/tools/testing/selftests/kvm/include/test_util.h +++ b/tools/testing/selftests/kvm/include/test_util.h @@ -153,6 +153,7 @@ bool is_backing_src_hugetlb(uint32_t i); void backing_src_help(const char *flag); enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name); long get_run_delay(void); +bool is_numa_balancing_enabled(void); =20 /* * Whether or not the given source type is shared memory (as opposed to diff --git a/tools/testing/selftests/kvm/lib/test_util.c b/tools/testing/se= lftests/kvm/lib/test_util.c index 3dc8538f5d696..03eb99af9b8de 100644 --- a/tools/testing/selftests/kvm/lib/test_util.c +++ b/tools/testing/selftests/kvm/lib/test_util.c @@ -176,6 +176,13 @@ size_t get_trans_hugepagesz(void) return get_sysfs_val("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size"= ); } =20 +bool is_numa_balancing_enabled(void) +{ + if (!test_sysfs_path("/proc/sys/kernel/numa_balancing")) + return false; + return get_sysfs_val("/proc/sys/kernel/numa_balancing") =3D=3D 1; +} + size_t get_def_hugetlb_pagesz(void) { char buf[64]; --=20 2.49.0.1015.ga840276032-goog From nobody Thu Dec 18 05:02:03 2025 Received: from mail-vs1-f73.google.com (mail-vs1-f73.google.com [209.85.217.73]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6B9CA28750B for ; Thu, 8 May 2025 18:46:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.217.73 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730017; cv=none; b=VXaCd+EiyGixweAkY1ev3EnV8vvuwmZLEalkLDtRofoa8+gKRWtdr06c1KgdsOJdwrjfN9XaTJVFH/BGgHZ08dEdwlGSyxgJfFQuabgd8BlPSuTWUJaZmu1Zzji6vzpIJ/SMesUkJgJxKUGOhimQQIvOUBZLEH8ZtDXJwJ2uUFo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730017; c=relaxed/simple; bh=2zlOsbrXOKvpKxOQtyINONcY1OAOsAyDfaqD4GbpVTc=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=c+E/fiZBJoFRZ7mnuj2d2dkQDfKm9jjUmsvO8nLYUWufnyqAjvr2B2kA6oaIrU82gjY3LxIl/uxUaTgXWDTILrWVae3bKz+HHZOsSmrRWNPkq3j+yBYCz3gZhHItWDdfvXnTtjx29NCDuZCSqbnhRNkIpVP9pMi6x4Gl9XzDNxc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=dab/8Qes; arc=none smtp.client-ip=209.85.217.73 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="dab/8Qes" Received: by mail-vs1-f73.google.com with SMTP id ada2fe7eead31-4ddb36b85e8so212772137.0 for ; Thu, 08 May 2025 11:46:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746730013; x=1747334813; darn=vger.kernel.org; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:from:to:cc:subject:date:message-id :reply-to; bh=ho5EBVy1X8wD8IAytwlI/FNNysTpSwOecb1lJqJ7yC0=; b=dab/8QesuUddepHr57OdcWA2CcKbptQBNoTfSAZ9uSap1K9cXeVb4vCKEcSzsUzu2S fC4QvYmdTF/wyGEA3Nm8xTtUy5DbOhqpVvT0WM4Obx4E1bDVJm815WMRIsQaOZtgDnes lYqRvd75HgzpE26XJqWCVV+ISI3xgPpWqN/KxWvP/1Z0Z0VMfin35OOj5ayngT9ISmup smkC3DjMYMoHyL/R9vFqNCueEEM1xORwd8eNI54tKFyd+Bk+PO8k+3CegP9grusKtcAn PDs5niUsjsfnS6dqS1RTF1VVN/QjbN8twvwmhkpWKyTst4CF1ALMy3uzt1BHVuWVuPNi W2IA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746730013; x=1747334813; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=ho5EBVy1X8wD8IAytwlI/FNNysTpSwOecb1lJqJ7yC0=; b=GqbEFM/Lh+9ANj7PVzZURL6gjDNDlnPj8uxLSdtWGdv+SKGDz9BMte0abWCinZoXmj B2etpmOL2hby62Yiq5wJ3rNVYhW1LCeIXkia6DSkLq1AjoUpjkca5wOiZjnjIR3loZhl x8BCAg+JVoD666c7Z4PKNbZVTfYj1suTH2p0DpUSj6oV3sQF+T4fYnbGbuI6s8XO+zq/ 3t82H5k/ry/D9QiOJTOD27xHLhUKFlnPVmNphqqmsyg4GMV72gzqsnpaLvEVxryitm7Y FPjcX15z2edHLKsLxkTS9n+vunbVzfEmK2nvk7+S8Jnr2DmxHnDAVUSlVSjNp7/zFPI5 objQ== X-Forwarded-Encrypted: i=1; AJvYcCWEB7gO0xD0eyZ7aXWa6S1PdSs5xRx+uEfEZ89FZa60aqWUpDsONKGx/lj4XLsteJ15co/I9aI2RHTWNqM=@vger.kernel.org X-Gm-Message-State: AOJu0YyVJDDR5a44slCIK9uPSYbBClIsbBoYjwMd+1iV8mJgV1NMWk/g DZfe8eOcyc3dHGTOamKeyNndOQXN3r9ACfoSYTNLHpkpxO9oSpon6gZQSfRhBdBVy1r/i+hI25T kNvGMar6+Z6SR3KWqyw== X-Google-Smtp-Source: AGHT+IG+Ktw2TRWaNA2c/slycRN+I23OsKqIBnhedgC898fwZF1LQsk23WFexmZdOVeoiRImDSIoMtqhLLazt25f X-Received: from vsvj5.prod.google.com ([2002:a05:6102:3e05:b0:4dd:b44f:e267]) (user=jthoughton job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6102:3e18:b0:4de:81a:7d3e with SMTP id ada2fe7eead31-4deed32b1fcmr767025137.2.1746730013348; Thu, 08 May 2025 11:46:53 -0700 (PDT) Date: Thu, 8 May 2025 18:46:44 +0000 In-Reply-To: <20250508184649.2576210-1-jthoughton@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250508184649.2576210-1-jthoughton@google.com> X-Mailer: git-send-email 2.49.0.1015.ga840276032-goog Message-ID: <20250508184649.2576210-4-jthoughton@google.com> Subject: [PATCH v4 3/7] cgroup: selftests: Move memcontrol specific helpers out of common cgroup_util.c From: James Houghton To: Sean Christopherson , kvm@vger.kernel.org Cc: Maxim Levitsky , Axel Rasmussen , Tejun Heo , Johannes Weiner , mkoutny@suse.com, Yosry Ahmed , Yu Zhao , David Matlack , James Houghton , cgroups@vger.kernel.org, linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Sean Christopherson Move a handful of helpers out of cgroup_util.c and into test_memcontrol.c that have nothing to with cgroups in general, in anticipation of making cgroup_util.c a generic library that can be used by other selftests. Make read_text() and write_text() non-static so test_memcontrol.c can use them. Signed-off-by: Sean Christopherson Signed-off-by: James Houghton Acked-by: Michal Koutn=C3=BD --- Sean's original patch[1] didn't build for me, hence the read_text() and write_text() change. [1]: https://lore.kernel.org/kvm/aBAlcrTtBDeQCL0X@google.com/ --- tools/testing/selftests/cgroup/cgroup_util.c | 82 +------------------ tools/testing/selftests/cgroup/cgroup_util.h | 8 +- .../selftests/cgroup/test_memcontrol.c | 78 ++++++++++++++++++ 3 files changed, 83 insertions(+), 85 deletions(-) diff --git a/tools/testing/selftests/cgroup/cgroup_util.c b/tools/testing/s= elftests/cgroup/cgroup_util.c index 1e2d46636a0ca..0ef3b8b8d7f74 100644 --- a/tools/testing/selftests/cgroup/cgroup_util.c +++ b/tools/testing/selftests/cgroup/cgroup_util.c @@ -20,7 +20,7 @@ #include "../clone3/clone3_selftests.h" =20 /* Returns read len on success, or -errno on failure. */ -static ssize_t read_text(const char *path, char *buf, size_t max_len) +ssize_t read_text(const char *path, char *buf, size_t max_len) { ssize_t len; int fd; @@ -39,7 +39,7 @@ static ssize_t read_text(const char *path, char *buf, siz= e_t max_len) } =20 /* Returns written len on success, or -errno on failure. */ -static ssize_t write_text(const char *path, char *buf, ssize_t len) +ssize_t write_text(const char *path, char *buf, ssize_t len) { int fd; =20 @@ -488,84 +488,6 @@ int cg_run_nowait(const char *cgroup, return pid; } =20 -int get_temp_fd(void) -{ - return open(".", O_TMPFILE | O_RDWR | O_EXCL); -} - -int alloc_pagecache(int fd, size_t size) -{ - char buf[PAGE_SIZE]; - struct stat st; - int i; - - if (fstat(fd, &st)) - goto cleanup; - - size +=3D st.st_size; - - if (ftruncate(fd, size)) - goto cleanup; - - for (i =3D 0; i < size; i +=3D sizeof(buf)) - read(fd, buf, sizeof(buf)); - - return 0; - -cleanup: - return -1; -} - -int alloc_anon(const char *cgroup, void *arg) -{ - size_t size =3D (unsigned long)arg; - char *buf, *ptr; - - buf =3D malloc(size); - for (ptr =3D buf; ptr < buf + size; ptr +=3D PAGE_SIZE) - *ptr =3D 0; - - free(buf); - return 0; -} - -int is_swap_enabled(void) -{ - char buf[PAGE_SIZE]; - const char delim[] =3D "\n"; - int cnt =3D 0; - char *line; - - if (read_text("/proc/swaps", buf, sizeof(buf)) <=3D 0) - return -1; - - for (line =3D strtok(buf, delim); line; line =3D strtok(NULL, delim)) - cnt++; - - return cnt > 1; -} - -int set_oom_adj_score(int pid, int score) -{ - char path[PATH_MAX]; - int fd, len; - - sprintf(path, "/proc/%d/oom_score_adj", pid); - - fd =3D open(path, O_WRONLY | O_APPEND); - if (fd < 0) - return fd; - - len =3D dprintf(fd, "%d", score); - if (len < 0) { - close(fd); - return len; - } - - close(fd); - return 0; -} - int proc_mount_contains(const char *option) { char buf[4 * PAGE_SIZE]; diff --git a/tools/testing/selftests/cgroup/cgroup_util.h b/tools/testing/s= elftests/cgroup/cgroup_util.h index 19b131ee77072..139c870ecc285 100644 --- a/tools/testing/selftests/cgroup/cgroup_util.h +++ b/tools/testing/selftests/cgroup/cgroup_util.h @@ -21,6 +21,9 @@ static inline int values_close(long a, long b, int err) return labs(a - b) <=3D (a + b) / 100 * err; } =20 +extern ssize_t read_text(const char *path, char *buf, size_t max_len); +extern ssize_t write_text(const char *path, char *buf, ssize_t len); + 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= ); @@ -49,11 +52,6 @@ extern int cg_enter_current_thread(const char *cgroup); extern int cg_run_nowait(const char *cgroup, int (*fn)(const char *cgroup, void *arg), void *arg); -extern int get_temp_fd(void); -extern int alloc_pagecache(int fd, size_t size); -extern int alloc_anon(const char *cgroup, void *arg); -extern int is_swap_enabled(void); -extern int set_oom_adj_score(int pid, int score); extern int cg_wait_for_proc_count(const char *cgroup, int count); extern int cg_killall(const char *cgroup); int proc_mount_contains(const char *option); diff --git a/tools/testing/selftests/cgroup/test_memcontrol.c b/tools/testi= ng/selftests/cgroup/test_memcontrol.c index 16f5d74ae762e..2908f4e0629db 100644 --- a/tools/testing/selftests/cgroup/test_memcontrol.c +++ b/tools/testing/selftests/cgroup/test_memcontrol.c @@ -24,6 +24,84 @@ static bool has_localevents; static bool has_recursiveprot; =20 +int get_temp_fd(void) +{ + return open(".", O_TMPFILE | O_RDWR | O_EXCL); +} + +int alloc_pagecache(int fd, size_t size) +{ + char buf[PAGE_SIZE]; + struct stat st; + int i; + + if (fstat(fd, &st)) + goto cleanup; + + size +=3D st.st_size; + + if (ftruncate(fd, size)) + goto cleanup; + + for (i =3D 0; i < size; i +=3D sizeof(buf)) + read(fd, buf, sizeof(buf)); + + return 0; + +cleanup: + return -1; +} + +int alloc_anon(const char *cgroup, void *arg) +{ + size_t size =3D (unsigned long)arg; + char *buf, *ptr; + + buf =3D malloc(size); + for (ptr =3D buf; ptr < buf + size; ptr +=3D PAGE_SIZE) + *ptr =3D 0; + + free(buf); + return 0; +} + +int is_swap_enabled(void) +{ + char buf[PAGE_SIZE]; + const char delim[] =3D "\n"; + int cnt =3D 0; + char *line; + + if (read_text("/proc/swaps", buf, sizeof(buf)) <=3D 0) + return -1; + + for (line =3D strtok(buf, delim); line; line =3D strtok(NULL, delim)) + cnt++; + + return cnt > 1; +} + +int set_oom_adj_score(int pid, int score) +{ + char path[PATH_MAX]; + int fd, len; + + sprintf(path, "/proc/%d/oom_score_adj", pid); + + fd =3D open(path, O_WRONLY | O_APPEND); + if (fd < 0) + return fd; + + len =3D dprintf(fd, "%d", score); + if (len < 0) { + close(fd); + return len; + } + + close(fd); + return 0; +} + /* * This test creates two nested cgroups with and without enabling * the memory controller. --=20 2.49.0.1015.ga840276032-goog From nobody Thu Dec 18 05:02:03 2025 Received: from mail-vk1-f201.google.com (mail-vk1-f201.google.com [209.85.221.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 31D492882B0 for ; Thu, 8 May 2025 18:46:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730017; cv=none; b=SokzMl18RdQ+S76o/c9yIyMCRX/KNGuXmkHgDm1+RGpBLa+1b6hXcZuK5IcsGgOR2MLiKWAC3wLk7fjfnvbnXka8P/tyVO8Bc3RxVBzW44EKq//pi97LQ4CIb0ORnpdvHQfPEXhYExueqcfkK/9yA8mDr7pgaHwzoy9GZ9WqcA8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730017; c=relaxed/simple; bh=JDJtvsLd6pAgSjFemxlKNebzWLSR94Q0gKRIgC16z9A=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=Lj9NI1i1mUHwgcVQEvu1v38Lw4rLDCfIj4vHj+Vos56aw2j6YStKnJ4l4bN0NH68qhjZxrlvohF7v+HSeVpYyDB35MCW7vLIDQFNYmh9O4MGpBLwk7KMP6UHKKafw9w3yPvFaxmuhLTLHOJDVDoosV8Qjwvv+qG1HCbvLNOEQkA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=lFIGs2Z5; arc=none smtp.client-ip=209.85.221.201 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="lFIGs2Z5" Received: by mail-vk1-f201.google.com with SMTP id 71dfb90a1353d-52c51af3807so121825e0c.2 for ; Thu, 08 May 2025 11:46:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746730014; x=1747334814; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=IBAW9WzDfaO30Qr6hkH4oUfrnATBljwiWcxlfgotkDs=; b=lFIGs2Z5QzRvguz3IfUza/Kw3VtQNtDPusHvDoNATVT72J0jN3U/HcOBuLPQvyHqyv bDn6CBreNF1eil+AXAJjV93u0SrlhvfbCs2n6iswogMQ/DZoZSHi0qVF0e6c/XY8mNDM 26BM7OdC7ZpUZLlwXLL579+N/0DWLlNsPFIyqOFzmD9wpwu6T4AZAN2fq1vAdE6l10Qz CY75UG7hOdOWjmgbAm0uD9WoWkiUaOFmEyNqzmAAyMPHhV8G80oxhASaHHGaS/ykMMeV WShRCvHEIO0vaxQ2SO+gPebQchBXQTlH/O4J9N/wnO+6bRPhl/X+RpeWf8hjybs6CoJ7 RAMQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746730014; x=1747334814; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=IBAW9WzDfaO30Qr6hkH4oUfrnATBljwiWcxlfgotkDs=; b=ht90Y4gxbG332zBRQ7RmNHunKcxsZ95S92QZo9feUq/8yBLwtm5YpLhAJFTDkmy8u3 F6m+TZ0gYrJ6BtqGN7jBQgrFxFw7RXaT+heGhXrvrgRvXrqYrbB9IekWJYiA9b8cKo1+ eC1AeCj7kAQ9xakEl06xYSYxhjVxwRLlSd1M9tMqwQWTo74jFSYh3IfMSOmMIWczcDfw DCKLFIA/GBxGKNhCd1SwKnklTpbVjnlyP+ARuigiGTZlAHQxHR2/4LfjiGrbU3O06doA VJHPhe1A/dlABltvYlRNijq8MD30QswKABm4z1Ikh1AKzeaKTCFFsvHaPB6rvoJCBTX9 USUg== X-Forwarded-Encrypted: i=1; AJvYcCWlb0g1oOabroPHiJsX29ZhfEFh0f9L7suY9fvk88JGzzn+RCgMx3zOE21Wz6TYBBqKmzqnbu38CoK1NjY=@vger.kernel.org X-Gm-Message-State: AOJu0Yx3IvOmRTgVbJ9G5Ip+FyA3rUzILSR/tl/0tp79vmYwV3TSKpG4 spoCpk8te+Sc8RmpCyand0drP7lrs1DfhZoxhAXfy+1iBUIudiu+OGtNain6yPHCm2QgwdP+l0V WeGVESZPFeZsCBua7Cg== X-Google-Smtp-Source: AGHT+IFvlfYZC2prDcJoUl/Lv0MPGRDwzVSm29UhzJxGswg/cvFXev8EsLu92bMLUeQ0toOW4Nlb9mHr6Zg+i/u5 X-Received: from vkben11.prod.google.com ([2002:a05:6122:280b:b0:529:1066:edac]) (user=jthoughton job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6122:2a09:b0:526:1ddd:7603 with SMTP id 71dfb90a1353d-52c538183a0mr902501e0c.0.1746730014050; Thu, 08 May 2025 11:46:54 -0700 (PDT) Date: Thu, 8 May 2025 18:46:45 +0000 In-Reply-To: <20250508184649.2576210-1-jthoughton@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250508184649.2576210-1-jthoughton@google.com> X-Mailer: git-send-email 2.49.0.1015.ga840276032-goog Message-ID: <20250508184649.2576210-5-jthoughton@google.com> Subject: [PATCH v4 4/7] cgroup: selftests: Move cgroup_util into its own library From: James Houghton To: Sean Christopherson , kvm@vger.kernel.org Cc: Maxim Levitsky , Axel Rasmussen , Tejun Heo , Johannes Weiner , mkoutny@suse.com, Yosry Ahmed , Yu Zhao , David Matlack , James Houghton , cgroups@vger.kernel.org, linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" KVM selftests will soon need to use some of the cgroup creation and deletion functionality from cgroup_util. Suggested-by: David Matlack Signed-off-by: James Houghton Acked-by: Tejun Heo --- tools/testing/selftests/cgroup/Makefile | 21 ++++++++++--------- .../selftests/cgroup/{ =3D> lib}/cgroup_util.c | 2 +- .../cgroup/{ =3D> lib/include}/cgroup_util.h | 4 ++-- .../testing/selftests/cgroup/lib/libcgroup.mk | 19 +++++++++++++++++ 4 files changed, 33 insertions(+), 13 deletions(-) rename tools/testing/selftests/cgroup/{ =3D> lib}/cgroup_util.c (99%) rename tools/testing/selftests/cgroup/{ =3D> lib/include}/cgroup_util.h (9= 9%) create mode 100644 tools/testing/selftests/cgroup/lib/libcgroup.mk diff --git a/tools/testing/selftests/cgroup/Makefile b/tools/testing/selfte= sts/cgroup/Makefile index 1b897152bab6e..e01584c2189ac 100644 --- a/tools/testing/selftests/cgroup/Makefile +++ b/tools/testing/selftests/cgroup/Makefile @@ -21,14 +21,15 @@ TEST_GEN_PROGS +=3D test_zswap LOCAL_HDRS +=3D $(selfdir)/clone3/clone3_selftests.h $(selfdir)/pidfd/pidf= d.h =20 include ../lib.mk +include lib/libcgroup.mk =20 -$(OUTPUT)/test_core: cgroup_util.c -$(OUTPUT)/test_cpu: cgroup_util.c -$(OUTPUT)/test_cpuset: cgroup_util.c -$(OUTPUT)/test_freezer: cgroup_util.c -$(OUTPUT)/test_hugetlb_memcg: cgroup_util.c -$(OUTPUT)/test_kill: cgroup_util.c -$(OUTPUT)/test_kmem: cgroup_util.c -$(OUTPUT)/test_memcontrol: cgroup_util.c -$(OUTPUT)/test_pids: cgroup_util.c -$(OUTPUT)/test_zswap: cgroup_util.c +$(OUTPUT)/test_core: $(LIBCGROUP_O) +$(OUTPUT)/test_cpu: $(LIBCGROUP_O) +$(OUTPUT)/test_cpuset: $(LIBCGROUP_O) +$(OUTPUT)/test_freezer: $(LIBCGROUP_O) +$(OUTPUT)/test_hugetlb_memcg: $(LIBCGROUP_O) +$(OUTPUT)/test_kill: $(LIBCGROUP_O) +$(OUTPUT)/test_kmem: $(LIBCGROUP_O) +$(OUTPUT)/test_memcontrol: $(LIBCGROUP_O) +$(OUTPUT)/test_pids: $(LIBCGROUP_O) +$(OUTPUT)/test_zswap: $(LIBCGROUP_O) diff --git a/tools/testing/selftests/cgroup/cgroup_util.c b/tools/testing/s= elftests/cgroup/lib/cgroup_util.c similarity index 99% rename from tools/testing/selftests/cgroup/cgroup_util.c rename to tools/testing/selftests/cgroup/lib/cgroup_util.c index 0ef3b8b8d7f74..4b975637351b2 100644 --- a/tools/testing/selftests/cgroup/cgroup_util.c +++ b/tools/testing/selftests/cgroup/lib/cgroup_util.c @@ -17,7 +17,7 @@ #include =20 #include "cgroup_util.h" -#include "../clone3/clone3_selftests.h" +#include "../../clone3/clone3_selftests.h" =20 /* Returns read len on success, or -errno on failure. */ ssize_t read_text(const char *path, char *buf, size_t max_len) diff --git a/tools/testing/selftests/cgroup/cgroup_util.h b/tools/testing/s= elftests/cgroup/lib/include/cgroup_util.h similarity index 99% rename from tools/testing/selftests/cgroup/cgroup_util.h rename to tools/testing/selftests/cgroup/lib/include/cgroup_util.h index 139c870ecc285..b7006dc761aba 100644 --- a/tools/testing/selftests/cgroup/cgroup_util.h +++ b/tools/testing/selftests/cgroup/lib/include/cgroup_util.h @@ -2,9 +2,9 @@ #include #include =20 -#include "../kselftest.h" - +#ifndef PAGE_SIZE #define PAGE_SIZE 4096 +#endif =20 #define MB(x) (x << 20) =20 diff --git a/tools/testing/selftests/cgroup/lib/libcgroup.mk b/tools/testin= g/selftests/cgroup/lib/libcgroup.mk new file mode 100644 index 0000000000000..7a73007204c39 --- /dev/null +++ b/tools/testing/selftests/cgroup/lib/libcgroup.mk @@ -0,0 +1,19 @@ +CGROUP_DIR :=3D $(selfdir)/cgroup + +LIBCGROUP_C :=3D lib/cgroup_util.c + +LIBCGROUP_O :=3D $(patsubst %.c, $(OUTPUT)/%.o, $(LIBCGROUP_C)) + +LIBCGROUP_O_DIRS :=3D $(shell dirname $(LIBCGROUP_O) | uniq) + +CFLAGS +=3D -I$(CGROUP_DIR)/lib/include + +EXTRA_HDRS :=3D $(selfdir)/clone3/clone3_selftests.h + +$(LIBCGROUP_O_DIRS): + mkdir -p $@ + +$(LIBCGROUP_O): $(OUTPUT)/%.o : $(CGROUP_DIR)/%.c $(EXTRA_HDRS) $(LIBCGROU= P_O_DIRS) + $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c $< -o $@ + +EXTRA_CLEAN +=3D $(LIBCGROUP_O) --=20 2.49.0.1015.ga840276032-goog From nobody Thu Dec 18 05:02:03 2025 Received: from mail-ua1-f74.google.com (mail-ua1-f74.google.com [209.85.222.74]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BF8B92882D0 for ; Thu, 8 May 2025 18:46:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.74 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730017; cv=none; b=FqDcq+x4X5qLUKEG8qtB+McP/IMSwUtid0MDebBFmsEbnKrJvCzwGyWxUZEb7S99jLCwxzOpZzXMfe1uPQdDE/n5xYVlDRxarth8YdWKj6uDuY6VHZR95JD0PqwDYp4332uwojAgcXrodSnVrhqx6T8RBW85Lr5k1Ch2ynrkYkg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730017; c=relaxed/simple; bh=pIVHOeltDOBLl2WJPbpjxuiQl2m85diWEjVbTSjOxCQ=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=Rcc/yCahJ44BLAcN41DuwWl7fHC/K+xlEOIRG5yfGoCsPvFT0PSp0bXDuCgS4JZY2e8aXCcilIZ8bsEOuluGh/1YYPQnxDJkXaHadKc4c2o/1KVq8Wa00XHCoIFQ7HRgEpvRj5ExEHRU9yUVoVH9lseMuV0773IyhhDp4J/l6Zs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=3pTU088t; arc=none smtp.client-ip=209.85.222.74 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="3pTU088t" Received: by mail-ua1-f74.google.com with SMTP id a1e0cc1a2514c-87835ba6838so1007962241.3 for ; Thu, 08 May 2025 11:46:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746730015; x=1747334815; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=TPkcI+kCU+4Iqs2BRj8Yz0fZ6778cjSBpMNFBoleiKE=; b=3pTU088tAziygbxrMHYuIgXUZprP/Q7Daxa+iY7gvgGNOS/NrgseZenM5Amh8fnJ1B i2iAS8SEPPmsIla04NcJJpgfuZBXWCIZsfWeeUyLoYYDlnFQmZTnFZNHf7IvqR1ZYh3C OoahSV1u836SxaURLwLdx0qbXtJ6TrK1iyhLkthz0r0GY/h3JvM09AmnasHNF9BEWVAM 2cy4WedBb/5E6Nnzl7k1VNGNx+DLFettrvNyhspHj/A47WQp0OXteGxss5sKGUUbIqmJ macBXW7stBn/3G7NOoTp1x7hNxePpyrqRFLBTHTxsmt2tSKLj/c9RwDgK6TlMdKeOWos vPXQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746730015; x=1747334815; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=TPkcI+kCU+4Iqs2BRj8Yz0fZ6778cjSBpMNFBoleiKE=; b=CRNrId0ABf/+xfoVG2TJhFTJLllumWz/8ph3NiKTrsIWOEkRSE65h3JqDyZkDD4zby f+RNTIZr0eFfRjLVTITa0shcc/Kh1NYl9gs33hkwiFKKVf+e5KLK0vPOvghbWImBAhZ6 nPZRSYffEGf5DlAZjxTULQgOl5RNlwunkHROE+cc8b3hzMJtluleAo3ioghEbsA+LobG U4M7ei8FAfu2/5B1vJ2cjYCU7RmNe2PlyIBPPhaiuChD4aeaOOyKHcePYeAyhTKMbOSA XEG8y197L49InnaVlmH7NEchA/uIQ6eLmRVawbyZJuKfsVdC1HtF8jlm1KDcvgpWDRFt O6Xg== X-Forwarded-Encrypted: i=1; AJvYcCV01ox/Q8nDsvlr4hp+bq5BUb4ttzcV6VP8zpIy6NnewubPdhwBRpy7GlVA11z68N8kYafwYg14THk9v3g=@vger.kernel.org X-Gm-Message-State: AOJu0YwW9pA2fJZMkbfzDGwLv63bwEFQ/abRiUOSqzngde7/onLW79cz Rg6A2EiXucJCG8L7/5jBE0sUiXvypPenay5e1ThXGaIpw1r7Ve3jH6sqIEcSqgcAPNX1uQ8N4Wi G9tNxbyGC1OLBYuHTAw== X-Google-Smtp-Source: AGHT+IH4jloYyqMQYt/c6wOYxAFh3MZtC8q8yjTVGigRDrHGekdZZHmBnb8TqkSl8QUx+cSBb+kiytSFdKZf7Wwu X-Received: from uabht8.prod.google.com ([2002:a05:6130:4f88:b0:877:add4:6ac3]) (user=jthoughton job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6102:15a0:b0:4c3:6979:2ef with SMTP id ada2fe7eead31-4deed3e7b59mr624443137.21.1746730014791; Thu, 08 May 2025 11:46:54 -0700 (PDT) Date: Thu, 8 May 2025 18:46:46 +0000 In-Reply-To: <20250508184649.2576210-1-jthoughton@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250508184649.2576210-1-jthoughton@google.com> X-Mailer: git-send-email 2.49.0.1015.ga840276032-goog Message-ID: <20250508184649.2576210-6-jthoughton@google.com> Subject: [PATCH v4 5/7] cgroup: selftests: Add API to find root of specific controller From: James Houghton To: Sean Christopherson , kvm@vger.kernel.org Cc: Maxim Levitsky , Axel Rasmussen , Tejun Heo , Johannes Weiner , mkoutny@suse.com, Yosry Ahmed , Yu Zhao , David Matlack , James Houghton , cgroups@vger.kernel.org, linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Sean Christopherson 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 Signed-off-by: James Houghton --- .../selftests/cgroup/lib/cgroup_util.c | 34 +++++++++++++++---- .../cgroup/lib/include/cgroup_util.h | 1 + 2 files changed, 28 insertions(+), 7 deletions(-) diff --git a/tools/testing/selftests/cgroup/lib/cgroup_util.c b/tools/testi= ng/selftests/cgroup/lib/cgroup_util.c index 4b975637351b2..8832f3d1cb614 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 *co= ntrol, long value) return cg_write(cgroup, control, buf); } =20 -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; @@ -236,18 +237,37 @@ int cg_find_unified_root(char *root, size_t len, bool= *nsdelegate) options =3D strtok(NULL, delim); strtok(NULL, delim); strtok(NULL, delim); - - if (strcmp(type, "cgroup2") =3D=3D 0) { - strncpy(root, mount, len); - if (nsdelegate) - *nsdelegate =3D !!strstr(options, "nsdelegate"); - return 0; + if (strcmp(type, "cgroup") =3D=3D 0) { + if (!controller || !strstr(options, controller)) + continue; + } else if (strcmp(type, "cgroup2") =3D=3D 0) { + if (controller && + cg_read_strstr(mount, "cgroup.controllers", controller)) + continue; + } else { + continue; } + strncpy(root, mount, len); + + if (nsdelegate) + *nsdelegate =3D !!strstr(options, "nsdelegate"); + return 0; + } =20 return -1; } =20 +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/too= ls/testing/selftests/cgroup/lib/include/cgroup_util.h index b7006dc761aba..adb2bc1931839 100644 --- a/tools/testing/selftests/cgroup/lib/include/cgroup_util.h +++ b/tools/testing/selftests/cgroup/lib/include/cgroup_util.h @@ -24,6 +24,7 @@ static inline int values_close(long a, long b, int err) extern ssize_t read_text(const char *path, char *buf, size_t max_len); extern ssize_t write_text(const char *path, char *buf, ssize_t len); =20 +extern int cg_find_controller_root(char *root, size_t len, const char *con= troller); 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= ); --=20 2.49.0.1015.ga840276032-goog From nobody Thu Dec 18 05:02:03 2025 Received: from mail-qv1-f74.google.com (mail-qv1-f74.google.com [209.85.219.74]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BA64628851B for ; Thu, 8 May 2025 18:46:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.219.74 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730018; cv=none; b=NXEJjoPkhnbP6+CX/bUK4Wdv+8yObowauOjsa7t75oGQkTetRej2/0rfx3dLaltRaRIBB45ksOdWmSjYBkcGoBe3xjYPln5ub/Ae7XQxVZM3iRw9av4pzwsnfTl00xnXKSO3pM6pnK3aS3gdjRU1stlsdmnEezNo0FtsQ2PoLMU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730018; c=relaxed/simple; bh=XxmjuqNyUSH40nAiJniXWQhl/jBhBznduv5cxq5yeKs=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=jZGG9+Dy1tqIWHeff44e7GK3j6BYXrNAFypRpj5nsbTdexb2S89PZVUuMnLerk5ajJl68uj67u9jGu5sALq5M2kRGt/xtYfNPNPZCWKWBZefro47lMksjq4hN/Ls4sJNDFx0lbEMM1T5TQ6JVXLIh8NZwF/phABnonR3/ujXjuU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=axpBAd6j; arc=none smtp.client-ip=209.85.219.74 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="axpBAd6j" Received: by mail-qv1-f74.google.com with SMTP id 6a1803df08f44-6f2b4ab462cso14514816d6.3 for ; Thu, 08 May 2025 11:46:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746730015; x=1747334815; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=uONc7WAgpVw3vuoHf0vvNHDupNr/S8j5Mtg90jyXV1Y=; b=axpBAd6jCM2ZSzMe6E2Ygn7EDSYK+zQ6TViyr7A9GuxcWttA5hYoXeDMh4ZfFx+phV v0hOUiEmDDtILH8HOViCQenUO60EoNY8PQRwZRviAyhEZIl7uMnlR8bTL/SAPgxXc5LG B6zCQNHIlFvmivpeP/Ikr2UeRfamCLqdc+WRPREI0rBHDIkYmzNSNyLe4oEYcfMzdPe0 2r/smUugwpIJRnqokef15gGKBqHSjYh3vbO2nTsdkpdqguXH006kyNRmQkhtZCMFfV5G bNQkB0wSZgUUB+h+LQdNlzTXAMJ0/hSZr+ji2Eyp4EnrQzrb7HtMEga1HOh0KQqLVBYf iamg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746730015; x=1747334815; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=uONc7WAgpVw3vuoHf0vvNHDupNr/S8j5Mtg90jyXV1Y=; b=jOnmQBU8MaFAPkT4wx4By/HfZ9NmIwLE2YAHxAdjbv2EaIBDcINZsL3Od7JUhovCts NTgsBcofZMTSCa9e9P6nKAzu4w0LLDFViseuBKHl9nNn0T/ansn4PFA7y0OF89QjfLdn k8mWyV3jjfzsQx4l0c74oDiTyCLA6wReX2U+rbS54RydizSw23Gu0DP7z+zVbPVs8H8r cE7/2JUzVpIHyDDz4RoCng+/LgF3lYztFWsYoZMq/kQjypNWmZ7pqCtpgfr5BSTt5jgP 2MsAYf8lCfjQ1A4AxqzF9mkN7CjjS/Cx9XDCw9D2YaT6UsqyLzc11ptjONSzmZ3tKRzw MMUQ== X-Forwarded-Encrypted: i=1; AJvYcCUvRbNz4/0zGwU7N/x6EnVBXvankS7Ryi82ZVBaxFqa5oMqgR9i1sl/DK4jOPSZsdFF78YTumaKlOCwRQU=@vger.kernel.org X-Gm-Message-State: AOJu0YxxV8QLYXZ+yVL4F2BkgLvCLe9i9csLm16uyPFHiY0Qsi4gC1GK hvAQ0zwr/QDp9XJvb0gl3jolIhOeWlWuD4WN8X2qTIwsTDg2J15l7nZVM/PAclnG7CgMfckP5xC z1pY2x0XpAu7XrXt32A== X-Google-Smtp-Source: AGHT+IHCSF3WPWtWHvI8KIBlSC7FdHqt0IH8/ghvMwVjrKFTrdvoF62AI1U/UII2RXUtP23ELsj30SazWDnfhkbF X-Received: from qvblr6.prod.google.com ([2002:a05:6214:5bc6:b0:6f2:b7f7:aeaf]) (user=jthoughton job=prod-delivery.src-stubby-dispatcher) by 2002:ad4:45ac:0:b0:6f5:3f55:343c with SMTP id 6a1803df08f44-6f6e480e25bmr4365056d6.32.1746730015502; Thu, 08 May 2025 11:46:55 -0700 (PDT) Date: Thu, 8 May 2025 18:46:47 +0000 In-Reply-To: <20250508184649.2576210-1-jthoughton@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250508184649.2576210-1-jthoughton@google.com> X-Mailer: git-send-email 2.49.0.1015.ga840276032-goog Message-ID: <20250508184649.2576210-7-jthoughton@google.com> Subject: [PATCH v4 6/7] KVM: selftests: Build and link selftests/cgroup/lib into KVM selftests From: James Houghton To: Sean Christopherson , kvm@vger.kernel.org Cc: Maxim Levitsky , Axel Rasmussen , Tejun Heo , Johannes Weiner , mkoutny@suse.com, Yosry Ahmed , Yu Zhao , David Matlack , James Houghton , cgroups@vger.kernel.org, linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" libcgroup.o is built separately from KVM selftests and cgroup selftests, so different compiler flags used by the different selftests will not conflict with each other. Signed-off-by: James Houghton --- tools/testing/selftests/kvm/Makefile.kvm | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/kvm/Makefile.kvm b/tools/testing/selft= ests/kvm/Makefile.kvm index f62b0a5aba35a..bea746878bcaa 100644 --- a/tools/testing/selftests/kvm/Makefile.kvm +++ b/tools/testing/selftests/kvm/Makefile.kvm @@ -204,6 +204,7 @@ OVERRIDE_TARGETS =3D 1 # importantly defines, i.e. overwrites, $(CC) (unless `make -e` or `make C= C=3D`, # which causes the environment variable to override the makefile). include ../lib.mk +include ../cgroup/lib/libcgroup.mk =20 INSTALL_HDR_PATH =3D $(top_srcdir)/usr LINUX_HDR_PATH =3D $(INSTALL_HDR_PATH)/include/ @@ -257,7 +258,7 @@ LIBKVM_S :=3D $(filter %.S,$(LIBKVM)) LIBKVM_C_OBJ :=3D $(patsubst %.c, $(OUTPUT)/%.o, $(LIBKVM_C)) LIBKVM_S_OBJ :=3D $(patsubst %.S, $(OUTPUT)/%.o, $(LIBKVM_S)) LIBKVM_STRING_OBJ :=3D $(patsubst %.c, $(OUTPUT)/%.o, $(LIBKVM_STRING)) -LIBKVM_OBJS =3D $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ) $(LIBKVM_STRING_OBJ) +LIBKVM_OBJS =3D $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ) $(LIBKVM_STRING_OBJ) $(LIB= CGROUP_O) SPLIT_TEST_GEN_PROGS :=3D $(patsubst %, $(OUTPUT)/%, $(SPLIT_TESTS)) SPLIT_TEST_GEN_OBJ :=3D $(patsubst %, $(OUTPUT)/$(ARCH)/%.o, $(SPLIT_TESTS= )) =20 --=20 2.49.0.1015.ga840276032-goog From nobody Thu Dec 18 05:02:03 2025 Received: from mail-vs1-f74.google.com (mail-vs1-f74.google.com [209.85.217.74]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 578D6288538 for ; Thu, 8 May 2025 18:46:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.217.74 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730021; cv=none; b=sCpZi8GNu7/NFRNuEkkB3Xs+n9fve0Oa5wNHT3ezqo9gPTeeh6S8FBUZm+kFPA/1itdiKg6h9VqUsqdI2TrMgSdB3EEM4z1ZDUmhZFT2OC46IFNJQ6/oSzIZUyRMS8jTSKn4f0YgGF7zGLDMui9ke9+br04Va0HslVFXPl2Wypc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746730021; c=relaxed/simple; bh=uGzoZiAyC7XeHc9C6MAXsup18eUjrbN0PWQ5mpOWyLY=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=oqidYptcsSt2M3fDY6DfhaVbLx4Cy0C2Wq63bLmPrToMPiPf6U4D6eIDtS7vWRvTdSZwKfwXILgZkVjO1a5rhGBdbpN1+z7xWof1WyoMxUGEVGdy/sV/qzyZoTAugIp+//6i4xSYuZzeFnc1uo9w6MZ6yOlmmkb/Gy2Eqi1Vu9s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=dfgyAqoO; arc=none smtp.client-ip=209.85.217.74 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--jthoughton.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="dfgyAqoO" Received: by mail-vs1-f74.google.com with SMTP id ada2fe7eead31-4c4e1ee505bso214044137.3 for ; Thu, 08 May 2025 11:46:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1746730016; x=1747334816; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=g7MOPr6aEyCJBKCYTTWJ1BhSZeOvZNL8U24hH1aKYh4=; b=dfgyAqoOdwdxKo1hl3sBEi394wqfvCVmQJ7PPbdwZDnuV8TU9Z9qPIjRCo73hNO6HX XKAoGjApjMuAaHV3OxUxv1VyzHsIvCtH8tQj6vLTwNmYE8OJSvJH1waSMUv7FkPxr2eW qHpi9qRSrClD1utA9xEyLDL00sbme22wo/E9DQOMleOy7P72KBmAhmX/vjMgrdQps+ZT V5erPppPJxpG7uQwcF6YOCBLNXdh9oLzQmY9OJcueQz3EJZPhvjIJ/Hqk1n0BEVPzgKd E5aRzpCjaL8Q/8VxqsszT9lsKWjpZsOA+Zb7Vz8AUCBknMTf+ONpEPB16BzuWCg5K2w5 uHdg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746730016; x=1747334816; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=g7MOPr6aEyCJBKCYTTWJ1BhSZeOvZNL8U24hH1aKYh4=; b=iBEoh2+RrQQx+gKD1zku6QCyP6kppjRfAST3zaQHw9wVtu+x24CNu6wZ2XoyPI3yLW qiwk1dgmXyuf2q38rF/5KboL+8tLz/vJtXvEkasdlc0uxKVg3tfEho698W6WeEe510iZ x36lJoKuY1WWEMX1f79d99twtNLY9/3Zba1YTTf6/TOCWucgnsf5E9Dk3yKWhc5gYjno DJ3buPOhW6PJ6W0qGhBq0Mht1mVYQFMUS3elVIMEOwdXHawbaePXhNEx0Ujsga5us8i/ 9AYvTJtEeGRm8MCdq5T6VWrfR3ior9PjhfTb26yueFeRAJMMMa+wLn4/pK+9oCumnepB Cmsw== X-Forwarded-Encrypted: i=1; AJvYcCXkWS2hXJrLyKtV/NW0/H5UVfuOj7CHIRNb+E7d3F7qidtGEiMRNwQq+De2UX+d0HGkdEllCp61nHVjnXA=@vger.kernel.org X-Gm-Message-State: AOJu0YzGA6/YQQCIqfrQv9AgamwxTQSsAVGuNqbeJRfxCPHWN3GpekIg kohGTzLgkRik+xqy23KEPlH90sgTiblQHAG/fdvutJSsArOx0o8903uuHobEhsvpabWFZGfSH8n 9q/tshsrL3d60t15jNw== X-Google-Smtp-Source: AGHT+IGf6TRPd0VvytlRNzzFCvUuIvZQ2B6eYivTZIQK94OkxaMDDnPLjXseEjTKt4R30HtA36ZwF3H1RdlMbOxE X-Received: from vsbbu12.prod.google.com ([2002:a05:6102:524c:b0:4c2:f06a:6e57]) (user=jthoughton job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6102:151c:b0:4db:154e:69a7 with SMTP id ada2fe7eead31-4deed32b9c1mr742288137.2.1746730016307; Thu, 08 May 2025 11:46:56 -0700 (PDT) Date: Thu, 8 May 2025 18:46:48 +0000 In-Reply-To: <20250508184649.2576210-1-jthoughton@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250508184649.2576210-1-jthoughton@google.com> X-Mailer: git-send-email 2.49.0.1015.ga840276032-goog Message-ID: <20250508184649.2576210-8-jthoughton@google.com> Subject: [PATCH v4 7/7] KVM: selftests: access_tracking_perf_test: Use MGLRU for access tracking From: James Houghton To: Sean Christopherson , kvm@vger.kernel.org Cc: Maxim Levitsky , Axel Rasmussen , Tejun Heo , Johannes Weiner , mkoutny@suse.com, Yosry Ahmed , Yu Zhao , David Matlack , James Houghton , cgroups@vger.kernel.org, linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use MGLRU's debugfs interface to do access tracking instead of page_idle. The logic to use the page_idle bitmap is left in, as it is useful for kernels that do not have MGLRU built in. When MGLRU is enabled, page_idle will report pages as still idle even after being accessed, as MGLRU doesn't necessarily clear the Idle folio flag when accessing an idle page, so the test will not attempt to use page_idle if MGLRU is enabled but otherwise not usable. Aging pages with MGLRU is much faster than marking pages as idle with page_idle. Co-developed-by: Axel Rasmussen Signed-off-by: Axel Rasmussen Signed-off-by: James Houghton --- tools/testing/selftests/kvm/Makefile.kvm | 1 + .../selftests/kvm/access_tracking_perf_test.c | 227 ++++++++-- .../selftests/kvm/include/lru_gen_util.h | 51 +++ .../testing/selftests/kvm/lib/lru_gen_util.c | 386 ++++++++++++++++++ 4 files changed, 638 insertions(+), 27 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/selft= ests/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 +=3D lib/elf.c LIBKVM +=3D lib/guest_modes.c LIBKVM +=3D lib/io.c LIBKVM +=3D lib/kvm_util.c +LIBKVM +=3D lib/lru_gen_util.c LIBKVM +=3D lib/memstress.c LIBKVM +=3D lib/guest_sprintf.c LIBKVM +=3D lib/rbtree.c diff --git a/tools/testing/selftests/kvm/access_tracking_perf_test.c b/tool= s/testing/selftests/kvm/access_tracking_perf_test.c index a2ac6fa2ba141..da7196fd1b230 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. Perform= ance @@ -17,10 +19,11 @@ * predefined region. * * Note that a deterministic correctness test of access tracking is not po= ssible - * 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 T= LB 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" =20 +#include "cgroup_util.h" +#include "lru_gen_util.h" + +static const char *TEST_MEMCG_NAME =3D "access_tracking_perf_test"; + /* Global variable used to synchronize all of the vCPU threads. */ static int iteration; =20 +/* The cgroup memory controller 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,15 @@ static bool overlap_memory_access; */ static int idle_pages_warn_only =3D -1; =20 +/* 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 test_pages; + +/* Last generation we found the pages in */ +static int lru_gen_last_gen =3D -1; + struct test_params { /* The backing source for the region of memory. */ enum vm_mem_backing_src_type backing_src; @@ -133,8 +153,24 @@ static void mark_page_idle(int page_idle_fd, uint64_t = pfn) "Set page_idle bits for PFN 0x%" PRIx64, pfn); } =20 -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 vcp= u_idx) +{ + char prefix[18] =3D {}; + + if (vcpu_idx >=3D 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 =3D vcpu_args->vcpu_idx; uint64_t base_gva =3D vcpu_args->gva; @@ -188,20 +224,78 @@ 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 >=3D 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 >=3D pages / 10) + too_many_idle_pages(still_idle, pages, + overlap_memory_access ? -1 : vcpu_idx); =20 close(page_idle_fd); close(pagemap_fd); } =20 +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 =3D lru_gen_find_generation(stats, total_pages * 9 / 10); + + if (gen >=3D 0) + return gen; + + if (!idle_pages_warn_only) { + TEST_FAIL("Could not find a generation with 90%% of guest memory (%ld pa= ges).", + 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 =3D lru_gen_find_generation(stats, total_pages / 2); + TEST_ASSERT(gen >=3D 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 new_gen; + + /* Make a new generation */ + clock_gettime(CLOCK_MONOTONIC, &ts_start); + lru_gen_do_aging(&stats, TEST_MEMCG_NAME); + ts_elapsed =3D timespec_elapsed(ts_start); + + /* Check the generation again */ + new_gen =3D 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 (new_gen <=3D lru_gen_last_gen) { + /* We did not move to a newer generation. */ + long idle_pages =3D lru_gen_sum_memcg_stats_for_gen(lru_gen_last_gen, + &stats); + + 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 =3D new_gen; +} + 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; } =20 @@ -293,15 +387,18 @@ static void access_memory(struct kvm_vm *vm, int nr_v= cpus, =20 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 =3D ITERATION_MARK_IDLE; - run_iteration(vm, nr_vcpus, "Mark memory idle"); + run_iteration(vm, nr_vcpus, "Mark memory idle (page_idle)"); } =20 static void run_test(enum vm_guest_mode mode, void *arg) @@ -313,11 +410,38 @@ static void run_test(enum vm_guest_mode mode, void *a= rg) vm =3D memstress_create_vm(mode, nr_vcpus, params->vcpu_memory_bytes, 1, params->backing_src, !overlap_memory_access); =20 + /* + * 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 =3D 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); =20 pr_info("\n"); access_memory(vm, nr_vcpus, ACCESS_WRITE, "Populating memory"); =20 + if (use_lru_gen) { + struct memcg_stats stats; + + /* + * Do a page table scan now. Following 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) >=3D 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"); + lru_gen_read_memcg_stats(&stats, TEST_MEMCG_NAME); + lru_gen_last_gen =3D find_generation(&stats, test_pages); + } + /* 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 +478,12 @@ static int access_tracking_unreliable(void) puts("Skipping idle page count sanity check, because NUMA balancing is e= nabled"); return 1; } + return 0; +} =20 +static int run_test_for_each_guest_mode(const char *cgroup, void *arg) +{ + for_each_guest_mode(run_test, arg); return 0; } =20 @@ -372,7 +501,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 =3D=3D warn only, 0 =3D=3D fail, <0 =3D=3D auto.= For auto\n" " mode, the test fails by default, but switches to warn only\n" @@ -383,6 +512,11 @@ static void help(char *name) exit(0); } =20 +void destroy_cgroup(char *cg) +{ + printf("Destroying cgroup: %s\n", cg); +} + int main(int argc, char *argv[]) { struct test_params params =3D { @@ -390,6 +524,7 @@ int main(int argc, char *argv[]) .vcpu_memory_bytes =3D DEFAULT_PER_VCPU_MEM_SIZE, .nr_vcpus =3D 1, }; + char *new_cg =3D NULL; int page_idle_fd; int opt; =20 @@ -424,15 +559,53 @@ int main(int argc, char *argv[]) } } =20 - page_idle_fd =3D open("/sys/kernel/mm/page_idle/bitmap", O_RDWR); - __TEST_REQUIRE(page_idle_fd >=3D 0, - "CONFIG_IDLE_PAGE_TRACKING is not enabled"); - close(page_idle_fd); - if (idle_pages_warn_only =3D=3D -1) idle_pages_warn_only =3D access_tracking_unreliable(); =20 - for_each_guest_mode(run_test, ¶ms); + if (lru_gen_usable()) { + bool cg_created =3D true; + int ret; + + puts("Using lru_gen for aging"); + use_lru_gen =3D true; + + if (cg_find_controller_root(cgroup_root, sizeof(cgroup_root), "memory")) + ksft_exit_skip("Cannot find memory cgroup controller\n"); + + new_cg =3D cg_name(cgroup_root, TEST_MEMCG_NAME); + printf("Creating cgroup: %s\n", new_cg); + if (cg_create(new_cg)) { + if (errno =3D=3D EEXIST) { + printf("Found existing cgroup"); + cg_created =3D 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 =3D cg_run(new_cg, &run_test_for_each_guest_mode, ¶ms); + if (cg_created) + cg_destroy(new_cg); + if (ret < 0) + TEST_FAIL("child did not spawn or was abnormally killed"); + if (ret) + return ret; + } else { + page_idle_fd =3D open("/sys/kernel/mm/page_idle/bitmap", O_RDWR); + __TEST_REQUIRE(page_idle_fd >=3D 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"); + run_test_for_each_guest_mode(NULL, ¶ms); + } =20 return 0; } diff --git a/tools/testing/selftests/kvm/include/lru_gen_util.h b/tools/tes= ting/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 ou= tput. + * + * Copyright (C) 2025, Google LLC. + */ +#ifndef SELFTEST_KVM_LRU_GEN_UTIL_H +#define SELFTEST_KVM_LRU_GEN_UTIL_H + +#include +#include +#include + +#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 *st= ats); +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..8d55029ee9ba0 --- /dev/null +++ b/tools/testing/selftests/kvm/lib/lru_gen_util.c @@ -0,0 +1,386 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2025, Google LLC. + */ + +#include + +#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 =3D strtok_r(it->str, " \t\n\r", &it->save); + + it->str =3D 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 =3D { .str =3D line }; + char *prefix =3D split_next(&it); + char *memcg_id =3D split_next(&it); + char *memcg_name =3D split_next(&it); + char *end; + + ctx->consumed =3D 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 =3D strtoul(memcg_id, &end, 10); + TEST_ASSERT(*end =3D=3D '\0', "malformed memcg id '%s'", memcg_id); + if (!stats->memcg_id) + return; /* Removed memcg? */ + + ctx->next_handler =3D 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 =3D { .str =3D line }; + char *prefix =3D split_next(&it); + char *id =3D split_next(&it); + long found_node_id; + char *end; + + ctx->consumed =3D true; + ctx->current_node_idx =3D -1; + + if (!prefix) + return; /* Skip empty lines */ + + if (!strcmp("memcg", prefix)) { + /* Memcg done, found next one; stop. */ + ctx->next_handler =3D 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 =3D strtol(id, &end, 10); + TEST_ASSERT(*end =3D=3D '\0', "malformed node id '%s'", id); + + ctx->current_node_idx =3D 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 =3D found_node_id; + + ctx->next_handler =3D 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 =3D strdup(line); + struct split_iterator it =3D { .str =3D 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 =3D 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 =3D memcg_stats_handle_in_memcg; + goto out; + } + + node_stats =3D &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 =3D &node_stats->gens[node_stats->nr_gens++]; + + age =3D split_next(&it); + nr_anon =3D split_next(&it); + nr_file =3D split_next(&it); + + TEST_ASSERT(age && nr_anon && nr_file, + "malformed generation line; not enough tokens"); + + gen_stats->gen =3D (int)strtol(gen, &end, 10); + TEST_ASSERT(*end =3D=3D '\0', "malformed generation number '%s'", gen); + + gen_stats->age_ms =3D strtol(age, &end, 10); + TEST_ASSERT(*end =3D=3D '\0', "malformed generation age '%s'", age); + + gen_stats->nr_anon =3D strtol(nr_anon, &end, 10); + TEST_ASSERT(*end =3D=3D '\0', "malformed anonymous page count '%s'", + nr_anon); + + gen_stats->nr_file =3D strtol(nr_file, &end, 10); + TEST_ASSERT(*end =3D=3D '\0', "malformed file page count '%s'", nr_file); + +out_consume: + ctx->consumed =3D 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 =3D 0; node < stats->nr_nodes; ++node) { + pr_debug("\tnode %d\n", stats->nodes[node].node); + for (gen =3D 0; gen < stats->nodes[node].nr_gens; ++gen) { + const struct generation_stats *gstats =3D + &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 =3D 0; + char *line =3D NULL; + size_t bufsz; + struct memcg_stats_parse_context ctx =3D { + .next_handler =3D memcg_stats_handle_searching, + .name =3D memcg, + }; + + memset(stats, 0, sizeof(struct memcg_stats)); + + f =3D fopen(LRU_GEN_DEBUGFS, "r"); + TEST_ASSERT(f, "fopen(%s) failed", LRU_GEN_DEBUGFS); + + while (ctx.next_handler && (read =3D getline(&line, &bufsz, f)) > 0) { + ctx.consumed =3D 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 =3D 0; + + for (node =3D 0; node < stats->nr_nodes; ++node) { + const struct node_stats *node_stats =3D &stats->nodes[node]; + + for (gen =3D 0; gen < node_stats->nr_gens; ++gen) { + const struct generation_stats *gen_stats =3D + &node_stats->gens[gen]; + + if (target_gen >=3D 0 && gen_stats->gen !=3D target_gen) + continue; + + total_nr +=3D 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 =3D true; + +static void run_aging_impl(unsigned long memcg_id, int node_id, int max_ge= n) +{ + FILE *f =3D fopen(LRU_GEN_DEBUGFS, "w"); + char *command; + size_t sz; + + TEST_ASSERT(f, "fopen(%s) failed", LRU_GEN_DEBUGFS); + sz =3D 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 =3D 0; node < stats->nr_nodes; ++node) { + int max_gen =3D 0; + + for (gen =3D 0; gen < stats->nodes[node].nr_gens; ++gen) { + int this_gen =3D stats->nodes[node].gens[gen].gen; + + max_gen =3D 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 =3D INT_MAX, max_gen =3D -1; + + for (node =3D 0; node < stats->nr_nodes; ++node) + for (gen_idx =3D 0; gen_idx < stats->nodes[node].nr_gens; + ++gen_idx) { + gen =3D stats->nodes[node].gens[gen_idx].gen; + max_gen =3D gen > max_gen ? gen : max_gen; + min_gen =3D gen < min_gen ? gen : min_gen; + } + + for (gen =3D min_gen; gen <=3D 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 =3D LRU_GEN_ENABLED | LRU_GEN_MM_WALK; + int lru_gen_fd, lru_gen_debug_fd; + char mglru_feature_str[8] =3D {}; + long mglru_features; + + lru_gen_fd =3D 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 =3D strtol(mglru_feature_str, NULL, 16); + if ((mglru_features & required_features) !=3D required_features) { + printf("lru_gen: missing features, got: %s, expected: 0x%lx\n", + mglru_feature_str, required_features); + printf("lru_gen: Try 'echo 0x%lx > /sys/kernel/mm/lru_gen/enabled'\n", + required_features); + return false; + } + + lru_gen_debug_fd =3D open(LRU_GEN_DEBUGFS, O_RDWR); + __TEST_REQUIRE(lru_gen_debug_fd >=3D 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; +} --=20 2.49.0.1015.ga840276032-goog