From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 521CFC369D8 for ; Mon, 28 Apr 2025 03:37:14 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id A93296B002E; Sun, 27 Apr 2025 23:37:12 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id A45726B0030; Sun, 27 Apr 2025 23:37:12 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 8729B6B0031; Sun, 27 Apr 2025 23:37:12 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 5CDE06B002E for ; Sun, 27 Apr 2025 23:37:12 -0400 (EDT) Received: from smtpin16.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay06.hostedemail.com (Postfix) with ESMTP id 5D14CC8AD0 for ; Mon, 28 Apr 2025 03:37:12 +0000 (UTC) X-FDA: 83382041904.16.9563C54 Received: from out-181.mta1.migadu.com (out-181.mta1.migadu.com [95.215.58.181]) by imf26.hostedemail.com (Postfix) with ESMTP id 9B61914000D for ; Mon, 28 Apr 2025 03:37:10 +0000 (UTC) Authentication-Results: imf26.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=WoHk90vS; spf=pass (imf26.hostedemail.com: domain of roman.gushchin@linux.dev designates 95.215.58.181 as permitted sender) smtp.mailfrom=roman.gushchin@linux.dev; dmarc=pass (policy=none) header.from=linux.dev ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1745811430; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=PMD4alSuF/CQrdJat1BcZoxvyxgjdLtWthYldLJYf1E=; b=ZWhu1MaZAP2lAlUBKoBOqbjFvYC42eLTO4e1ahGoHsrKfgbGJMvm4Wa7ZIetT65qairgLC m2RumbpixLRBNMlY4bP9vOl9giNgv5hm1rkuyvPEgJgZYz8mKcqcBacfIpP6ClEUh4EzTR /AaGnTUqieAldxNKgYNYOAyqPz+eh9U= ARC-Authentication-Results: i=1; imf26.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=WoHk90vS; spf=pass (imf26.hostedemail.com: domain of roman.gushchin@linux.dev designates 95.215.58.181 as permitted sender) smtp.mailfrom=roman.gushchin@linux.dev; dmarc=pass (policy=none) header.from=linux.dev ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1745811430; a=rsa-sha256; cv=none; b=MGF93PUw/SMirZFqnFZGiJ/oN5faRLLvBF+eZEndIEXrp1My8vHhDvJVzNHE6cHjwthUlp O9t1uzz+QDJRYiVr96XaOd5rFGbAh/GgQSjRzNm1iOQKe/EsROyso9M6QQZ35S5uVEvXER uitePIOKaGBp5/vTinaUIlGQwjgiC+E= X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1745811429; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=PMD4alSuF/CQrdJat1BcZoxvyxgjdLtWthYldLJYf1E=; b=WoHk90vSsCT6HqUIwr7zPvav48u2HbF9Fj+LO5seyFrEcCAO/yMDiQn7IpkGImXxA5Cx3W jN5br5GN6WKkrp+RIO/MIO4P0oJHADYQOhd7umOi69q0P/NDHaILQKKI3xxLRvkpkvHRIX Rab1/AQR2q1H72iYJeg+PrWNcLnEGGE= From: Roman Gushchin To: linux-kernel@vger.kernel.org Cc: Andrew Morton , Alexei Starovoitov , Johannes Weiner , Michal Hocko , Shakeel Butt , Suren Baghdasaryan , David Rientjes , Josh Don , Chuyi Zhou , cgroups@vger.kernel.org, linux-mm@kvack.org, bpf@vger.kernel.org, Roman Gushchin Subject: [PATCH rfc 12/12] bpf: selftests: psi handler test Date: Mon, 28 Apr 2025 03:36:17 +0000 Message-ID: <20250428033617.3797686-13-roman.gushchin@linux.dev> In-Reply-To: <20250428033617.3797686-1-roman.gushchin@linux.dev> References: <20250428033617.3797686-1-roman.gushchin@linux.dev> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Migadu-Flow: FLOW_OUT X-Stat-Signature: mzr1wbcm7kgh3ejnfy35r6gniebz9n4z X-Rspamd-Server: rspam01 X-Rspamd-Queue-Id: 9B61914000D X-Rspam-User: X-HE-Tag: 1745811430-118173 X-HE-Meta: U2FsdGVkX18WeyOSQiYnU4HAFtv6EeRl9lgqeVkgr7JQlyeTxaQQ9FQw9eXLEKdo+P2iFWSalUD/L9hrdGzqQrr3re0Ni5XZfXE09z5t6P8125vOaxT0OVHjkI75rynCofdCuJu2n7JC9T0kOOyBuYh0Nymcoy5r1drHTD6g9aXplSvF9o1bTfYqvgDQePY4TKXB1HRC/nUhp3/QVyy7X8ql/1hu0BufxcpJQ5DkgCZV+YGvcuZVidUVrnUlPfh5Phk90Bz18kKPttNa4zawOOqrPv6LvXbkpGJp6DHZlANmMBP/LQl68QIIQ8q/a6wpUZD6v+aW2rghUQiaJoeLJa1gk3VIqX/x3RbsRbJf4g619ZNtVJxQ7QL2SVzAcXpHFTsjGFBFKh2cacanOv3WtZaZgVDwX6OUozBR/NfxJb8pqig0c9wcfHhYeFCHwbNCdslDIXqfM3lJ84MrXd9/mXV56rqStYfYAGBdkE/PwL4EzHHjreuodVQbqfmbgQPQ5RFsGoJuqLpUl69IRuYAF9vOHYJphU7yG7kmsqpuhZ7WTawwEfDjjwVBHEH9nqO0MmWy/AZbWUsKGjRd+jB1LcoS0FFk8EqFXilbyEYy5S0gZ015/5s+9LK6ogfHBOe59Ma+7zBQkmUfEvc1F41eoio2J0yymKhsMG6jPVRm47/B+xdGZdFufhIZoXUmf5CHRdNEe5ye2ZhBgbTKpuci1UUwk5gkfnn89h0xRLZcLAOJBYsX/G4rIPGOb2bKbTDBKe78b7P2S9YDkyHAr8O1M6JrC2MtjlQ8Di1AUDQIWD0pMFbUHQQ8kL8yY2n7X6h6y54evfII1y0SYNcEx6ireMW6hgx6V4B1dDjMeqQ2nE1Px098DxIUL21JmIcn1rjqXDnWSLF3jq0t/9yfoaovOtx29CyaHi5KkJ68gWPz2g3a2AI7Rkbx8P/FwbGNAJjzp+kahB2lQdHZxVX5GSP 6yRm/0rj 5PVUv6xX1Uiwy/nKx5jVQ8hqlfPCy4xLaXX1YQw05nuY+3Wxh9dFQLb8Ec5PxHJGEeDehcpcuh7fKPi0/qiIWd+CAtB7DEdOL/+DJrclK3ksMyiMVywjAlmCtH1sMRWJogPE4VYrJcB1PZBbC7KBg/jp6cbhssqQ1tQY/NDBH1+cDDD0= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Add a psi handler test. The test creates a cgroup with two child sub-cgroups, sets up memory.high for one of those and puts memory hungry processes in each of them. Then it sets up a psi trigger for one of cgroups and waits till the process in this cgroup will be killed by the OOM killer. To make sure there was indeed an OOM event, it checks the corresponding memcg statistics. Signed-off-by: Roman Gushchin --- tools/testing/selftests/bpf/prog_tests/psi.c | 234 +++++++++++++++++++ tools/testing/selftests/bpf/progs/test_psi.c | 43 ++++ 2 files changed, 277 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/psi.c create mode 100644 tools/testing/selftests/bpf/progs/test_psi.c diff --git a/tools/testing/selftests/bpf/prog_tests/psi.c b/tools/testing/selftests/bpf/prog_tests/psi.c new file mode 100644 index 000000000000..99d68bc20eee --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/psi.c @@ -0,0 +1,234 @@ +// SPDX-License-Identifier: GPL-2.0-only +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cgroup_helpers.h" +#include "test_psi.skel.h" + +struct cgroup_desc { + const char *path; + int fd; + unsigned long long id; + int pid; + size_t target; + size_t high; + bool victim; + bool psi; +}; + +#define MB (1024 * 1024) + +static struct cgroup_desc cgroups[] = { + { .path = "/oom_test" }, + { .path = "/oom_test/cg1", .target = 100 * MB }, + { .path = "/oom_test/cg2", .target = 500 * MB, + .high = 40 * MB, .psi = true, .victim = true }, +}; + +static int spawn_task(struct cgroup_desc *desc) +{ + char *ptr; + int pid; + + pid = fork(); + if (pid < 0) + return pid; + + if (pid > 0) { + /* parent */ + desc->pid = pid; + return 0; + } + + /* child */ + ptr = (char *)malloc(desc->target); + if (!ptr) + return -ENOMEM; + + memset(ptr, 'a', desc->target); + + while (1) + sleep(1000); + + return 0; +} + +static int setup_psi_alert(struct cgroup_desc *desc) +{ + const char *trig = "some 100000 1000000"; + int fd; + + fd = open_cgroup_file(desc->path, "memory.pressure", O_RDWR); + if (fd < 0) { + printf("memory.pressure open error: %s\n", strerror(errno)); + return 1; + } + + if (write(fd, trig, strlen(trig) + 1) < 0) { + printf("memory.pressure write error: %s\n", strerror(errno)); + return 1; + } + + /* keep fd open, otherwise the psi trigger will be deleted */ + return 0; +} + +static void setup_environment(void) +{ + int i, err; + + err = setup_cgroup_environment(); + if (!ASSERT_OK(err, "setup_cgroup_environment")) + goto cleanup; + + for (i = 0; i < ARRAY_SIZE(cgroups); i++) { + cgroups[i].fd = create_and_get_cgroup(cgroups[i].path); + if (!ASSERT_GE(cgroups[i].fd, 0, "create_and_get_cgroup")) + goto cleanup; + + cgroups[i].id = get_cgroup_id(cgroups[i].path); + if (!ASSERT_GT(cgroups[i].id, 0, "get_cgroup_id")) + goto cleanup; + + if (i == 0) { + /* Freeze the top-level cgroup */ + err = write_cgroup_file(cgroups[i].path, "cgroup.freeze", "1"); + if (!ASSERT_OK(err, "freeze cgroup")) + goto cleanup; + } + + if (!cgroups[i].target) { + /* Recursively enable the memory controller */ + err = write_cgroup_file(cgroups[i].path, "cgroup.subtree_control", + "+memory"); + if (!ASSERT_OK(err, "enable memory controller")) + goto cleanup; + } + + if (cgroups[i].high) { + char buf[256]; + + snprintf(buf, sizeof(buf), "%lu", cgroups[i].high); + err = write_cgroup_file(cgroups[i].path, "memory.high", buf); + if (!ASSERT_OK(err, "set memory.high")) + goto cleanup; + + snprintf(buf, sizeof(buf), "0"); + write_cgroup_file(cgroups[i].path, "memory.swap.max", buf); + } + + if (cgroups[i].target) { + char buf[256]; + + err = spawn_task(&cgroups[i]); + if (!ASSERT_OK(err, "spawn task")) + goto cleanup; + + snprintf(buf, sizeof(buf), "%d", cgroups[i].pid); + err = write_cgroup_file(cgroups[i].path, "cgroup.procs", buf); + if (!ASSERT_OK(err, "put child into a cgroup")) + goto cleanup; + } + + if (cgroups[i].psi) { + err = setup_psi_alert(&cgroups[i]); + if (!ASSERT_OK(err, "create psi trigger")) + goto cleanup; + } + } + + return; + +cleanup: + cleanup_cgroup_environment(); +} + +static int run_and_wait_for_oom(void) +{ + int ret = -1; + bool first = true; + char buf[4096] = {}; + size_t size; + + ret = write_cgroup_file(cgroups[0].path, "cgroup.freeze", "0"); + if (!ASSERT_OK(ret, "freeze cgroup")) + return -1; + + for (;;) { + int i, status; + pid_t pid = wait(&status); + + if (pid == -1) { + if (errno == EINTR) + continue; + /* ECHILD */ + break; + } + + if (!first) + continue; + + first = false; + + for (i = 0; i < ARRAY_SIZE(cgroups); i++) { + if (!ASSERT_OK(cgroups[i].victim != + (pid == cgroups[i].pid), + "correct process was killed")) { + ret = -1; + break; + } + + if (!cgroups[i].victim) + continue; + + size = read_cgroup_file(cgroups[i].path, "memory.events", + buf, sizeof(buf)); + if (!ASSERT_OK(size <= 0, "read memory.events")) { + ret = -1; + break; + } + + if (!ASSERT_OK(strstr(buf, "oom_kill 1") == NULL, + "oom_kill count check")) { + ret = -1; + break; + } + } + + for (i = 0; i < ARRAY_SIZE(cgroups); i++) + if (cgroups[i].pid && cgroups[i].pid != pid) + kill(cgroups[i].pid, SIGKILL); + } + + return ret; +} + +void test_psi(void) +{ + struct test_psi *skel; + int err; + + skel = test_psi__open_and_load(); + err = test_psi__attach(skel); + if (!ASSERT_OK(err, "test_psi__attach")) + goto cleanup; + + setup_environment(); + + run_and_wait_for_oom(); + + cleanup_cgroup_environment(); +cleanup: + test_psi__destroy(skel); +} diff --git a/tools/testing/selftests/bpf/progs/test_psi.c b/tools/testing/selftests/bpf/progs/test_psi.c new file mode 100644 index 000000000000..8cbc1e0a5b24 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_psi.c @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include "vmlinux.h" +#include +#include +#include "bpf_misc.h" +#include "bpf_experimental.h" + +char _license[] SEC("license") = "GPL"; + +struct mem_cgroup *bpf_get_mem_cgroup(struct cgroup_subsys_state *css) __ksym; +void bpf_put_mem_cgroup(struct mem_cgroup *memcg) __ksym; +int bpf_out_of_memory(struct mem_cgroup *memcg, int order) __ksym; + +SEC("fmod_ret.s/bpf_handle_psi_event") +int BPF_PROG(test_psi_event, struct psi_trigger *t) +{ + struct cgroup *cgroup = NULL; + struct mem_cgroup *memcg; + u64 cgroup_id; + + if (!t->of || !t->of->kn) { + bpf_out_of_memory(NULL, 0); + return 1; + } + + cgroup_id = t->of->kn->__parent->id; + cgroup = bpf_cgroup_from_id(cgroup_id); + if (!cgroup) + return 0; + + memcg = bpf_get_mem_cgroup(&cgroup->self); + if (!memcg) { + bpf_cgroup_release(cgroup); + return 0; + } + + bpf_out_of_memory(memcg, 0); + + bpf_put_mem_cgroup(memcg); + bpf_cgroup_release(cgroup); + + return 1; +} -- 2.49.0.901.g37484f566f-goog