github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-29 18:51:21 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

selftests/sched_ext: Fix select_cpu_dfl link leak on early return

Browse Source 
If run() exits early via SCX_EQ/SCX_ASSERT (which calls return
directly), bpf_link__destroy() is never reached and the BPF
scheduler stays loaded. All subsequent tests then fail to attach
because SCX is not in the DISABLED state.

Move bpf_link into a context struct so cleanup() always destroys
it, regardless of how run() exits. Also skip waitpid() for children
where fork() returned -1, avoiding waitpid(-1,...) accidentally
reaping an unrelated child and triggering the early return path.

Signed-off-by: Cheng-Yang Chou <yphbchou0911@gmail.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Andrea Righi <arighi@nvidia.com>
This commit is contained in:
Cheng-Yang Chou 2026-05-08 14:55:12 +08:00 committed by Tejun Heo
parent d91b36de53
commit e18002d2c7
1 changed files with 38 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
tools/testing/selftests/sched_ext/select_cpu_dfl.c
View File

@ -6,6 +6,7 @@
*/
#include <bpf/bpf.h>
#include <scx/common.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include "select_cpu_dfl.bpf.skel.h"
@ -13,29 +14,44 @@
#define NUM_CHILDREN 1028
struct select_cpu_dfl_ctx {
struct select_cpu_dfl *skel;
struct bpf_link *link;
};
static enum scx_test_status setup(void **ctx)
{
struct select_cpu_dfl *skel;
struct select_cpu_dfl_ctx *tctx;
skel = select_cpu_dfl__open();
SCX_FAIL_IF(!skel, "Failed to open");
SCX_ENUM_INIT(skel);
SCX_FAIL_IF(select_cpu_dfl__load(skel), "Failed to load skel");
tctx = malloc(sizeof(*tctx));
SCX_FAIL_IF(!tctx, "Failed to allocate test context");
tctx->link = NULL;
*ctx = skel;
tctx->skel = select_cpu_dfl__open();
if (!tctx->skel) {
free(tctx);
SCX_FAIL("Failed to open");
}
SCX_ENUM_INIT(tctx->skel);
if (select_cpu_dfl__load(tctx->skel)) {
select_cpu_dfl__destroy(tctx->skel);
free(tctx);
SCX_FAIL("Failed to load skel");
}
*ctx = tctx;
return SCX_TEST_PASS;
}
static enum scx_test_status run(void *ctx)
{
struct select_cpu_dfl *skel = ctx;
struct bpf_link *link;
struct select_cpu_dfl_ctx *tctx = ctx;
pid_t pids[NUM_CHILDREN];
int i, status;
int i, status, nforked = 0;
link = bpf_map__attach_struct_ops(skel->maps.select_cpu_dfl_ops);
SCX_FAIL_IF(!link, "Failed to attach scheduler");
tctx->link = bpf_map__attach_struct_ops(tctx->skel->maps.select_cpu_dfl_ops);
SCX_FAIL_IF(!tctx->link, "Failed to attach scheduler");
for (i = 0; i < NUM_CHILDREN; i++) {
pids[i] = fork();
@ -43,25 +59,31 @@ static enum scx_test_status run(void *ctx)
sleep(1);
exit(0);
}
if (pids[i] > 0)
nforked++;
}
for (i = 0; i < NUM_CHILDREN; i++) {
if (pids[i] <= 0)
continue;
SCX_EQ(waitpid(pids[i], &status, 0), pids[i]);
SCX_EQ(status, 0);
}
SCX_ASSERT(!skel->bss->saw_local);
bpf_link__destroy(link);
SCX_GT(nforked, 0);
SCX_ASSERT(!tctx->skel->bss->saw_local);
return SCX_TEST_PASS;
}
static void cleanup(void *ctx)
{
struct select_cpu_dfl *skel = ctx;
struct select_cpu_dfl_ctx *tctx = ctx;
select_cpu_dfl__destroy(skel);
if (tctx->link)
bpf_link__destroy(tctx->link);
select_cpu_dfl__destroy(tctx->skel);
free(tctx);
}
struct scx_test select_cpu_dfl = {