From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-pl1-f172.google.com (mail-pl1-f172.google.com [209.85.214.172]) (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 020B13921E0 for ; Fri, 6 Mar 2026 12:49:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.172 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772801360; cv=none; b=rdqmquPm1NfjTnvFPmDl67LccOlpQN+yeHrDnlK/Rw+Fp6v6cngohmsIXkKCx2AfeIG9dSF6JEgMq7uGSzGASOwCCPJISnwvJrKbmoZOv61B/HBCP8KZZT4bvAvy4IO1DvXF4tCztdrYgT25vEca6CKhmME5WbDMfROcw321q+s= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772801360; c=relaxed/simple; bh=BZeeJ1JML7xaZoBvWAKlQYnkV7F90b7mZuzv0ATZ6Jw=; h=From:To:Cc:Subject:Date:Message-ID:MIME-Version; b=d3IBW7fNlW/NB5lKCOYESYCVNc5APmQ2NiNSwzSnFK5r42IVuoIvgXYrvU/RMRy0pt0iE/fKYM41e3Si3zt3VP/t0/P87VipC+MYBIEfeGYVwOInY+Vb6Hjgqaq7r6pdqLvGvRfIP+zIKd7FmcreECpjfIg2z+s+DJa+HbF4aFo= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Ruv+3MI9; arc=none smtp.client-ip=209.85.214.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Ruv+3MI9" Received: by mail-pl1-f172.google.com with SMTP id d9443c01a7336-2a9296b3926so68026365ad.1 for ; Fri, 06 Mar 2026 04:49:17 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1772801357; x=1773406157; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=6TnQKdPGtTuRU+46cutq94eviTJ71u1qZiPiKlbjQJQ=; b=Ruv+3MI9uh9UmKCqZJuzUEQDiMDwyf2WsPQ/dzzFIMEcQ1Fsa1Vq7jjPAj/wv5Ku8y NF64Hprvi3encEih0iGaugA792BkY4TOeBUKAlOgtDgrPfA1x+7Yhj0P89BJC7uFGhw+ 9x/z9DhdZivVjl7mF5KCJ+/iZIioXlNRQ27LfAi+VqPGbTV8vCIpYoRf88dgj1GRQAl3 y/N8KObAFi4WxHq6rJPmNgRC08QspaCkz7P0NrclnxKvBSASQA9uF4Pk5oZk8TCkg8L9 qBCdp/vu2z+1gtxSfa6RiY3zrKCmBXpshRa3DMmj2oK0KKkDLtthE8ixzp//JlWAq6ih 5ymw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1772801357; x=1773406157; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=6TnQKdPGtTuRU+46cutq94eviTJ71u1qZiPiKlbjQJQ=; b=o96JkKXQIpR6rZ9s8+X6j89RnlN4FL9IONoxzLd/e6w0kZ9cax7BNLUfvgKu9VdDGW HhvjzbFbxB5XKWO6cl3RzsxxxTFwlgwcdGJa45PtaDsvjwmOu70QDhkEoFBEeeKA3NG6 jXeMnjDw0K/ZylgXsKYHeRKTLpC44UFVnFtHGQ2aMcURMtSV9Xk64FybV/rmJpe/DngP woCuDvhBZq7fGxPcPYz+G6YUfGcTNSMweyNivP+OY5fZ5gse8Gg+/RLKI5XqsOl5vBso ZzYxEqZQyljg7Xf24t436aPGrNcPcXFeqFcThLiusXYXXPB/u+6C/Q+jZZeM4W+R9NtK b/ig== X-Forwarded-Encrypted: i=1; AJvYcCUVYCzDzUdA4r3/QVE4X+R2pVIk52ZjHc4XmuhZYxMsce5sGPgsIe3mLM2xBIoJpLKE9lN7BU2ucGTTCVY=@vger.kernel.org X-Gm-Message-State: AOJu0YzQYLCKSyF5pVL0zqV6mt2aZEpIGkZZIHSpStxuXpO5QR1pbpbU QIS+vo8XgVfgBwRegVf2IHKcGXgEFFf3ZRwhBwVm1V7Amut3t9qn5ckO X-Gm-Gg: ATEYQzyqMvEG/YxcfUR8PXCOhqBS02SL1oumil05bVFoCwx3hkErzVQT9D7BjX7R7J1 ZwfzZN6bgyL5pH9l0PYTIb+dKP5lEq5Y3Uy+oZb3z19C75G9qnPazQ0jI1IupcLvF9NzAKFc0sm SJAsFFAwIsmJ4epw/4Y7QkT1lavpB/Ycc5IjwUyclB9gsAp6GNJ5Jp+3UxR67fpTrWVaXAz3e5o zgYZ+oM0FZu8p+jm8zZlZhMDXNLenLkuX3tVXYGXNScAqYAX9WCeZPUhJ74CoqpKH/5s064gG6Z 5KOPP6YOZYCuGIHClle42BhGStSSilKvsGz/ogFza/RPYHHzf6HAkxiq4I8BR45rILI5xah+IBI gZZDuCdsCbIS+1Hf1Ej7Sg9bdWUd5v3gZcw5kUycTwjji1EWytg4qkFLmR/TlV32oJ/7PuBhJ0j EHXKHAD2rxv6ui81ZqNdrJq0OUQUwKLl0ITumQqH8utW7vIZBwATFxqpEyxQwP0vjwMwvCWv3OF zRd0WSE92ictQ== X-Received: by 2002:a17:902:d544:b0:2ae:7f3a:b213 with SMTP id d9443c01a7336-2ae8252fb45mr22420835ad.47.1772801357343; Fri, 06 Mar 2026 04:49:17 -0800 (PST) Received: from mi-HP-ProDesk-680-G6-PCI-Microtower-PC.mioffice.cn ([43.224.245.226]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2ae83e78f77sm27712845ad.21.2026.03.06.04.49.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Mar 2026 04:49:17 -0800 (PST) From: zhidao su X-Google-Original-From: zhidao su To: tj@kernel.org, sched-ext@lists.linux.dev, linux-kernel@vger.kernel.org Cc: void@manifault.com, arighi@nvidia.com, changwoo@igalia.com, linux-kselftest@vger.kernel.org, Su Zhidao Subject: [PATCH 4/5] sched_ext/selftests: Add bypass mode operational test Date: Fri, 6 Mar 2026 20:49:00 +0800 Message-ID: <20260306124901.2653465-4-suzhidao@xiaomi.com> X-Mailer: git-send-email 2.43.0 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit From: Su Zhidao Add a test that verifies the sched_ext bypass mechanism does not prevent tasks from running to completion. The test attaches a minimal global FIFO scheduler, spawns worker processes that complete a fixed computation, detaches the scheduler (which triggers bypass mode while workers are still active), and verifies all workers complete successfully under bypass mode. This exercises the scheduler attach/detach lifecycle and verifies that bypass mode (activated during unregistration to guarantee forward progress) does not stall running tasks. Signed-off-by: Su Zhidao --- tools/testing/selftests/sched_ext/Makefile | 1 + .../testing/selftests/sched_ext/bypass.bpf.c | 32 ++++++ tools/testing/selftests/sched_ext/bypass.c | 105 ++++++++++++++++++ 3 files changed, 138 insertions(+) create mode 100644 tools/testing/selftests/sched_ext/bypass.bpf.c create mode 100644 tools/testing/selftests/sched_ext/bypass.c diff --git a/tools/testing/selftests/sched_ext/Makefile b/tools/testing/selftests/sched_ext/Makefile index a3bbe2c7911b..5fb6278d3f97 100644 --- a/tools/testing/selftests/sched_ext/Makefile +++ b/tools/testing/selftests/sched_ext/Makefile @@ -162,6 +162,7 @@ endef all_test_bpfprogs := $(foreach prog,$(wildcard *.bpf.c),$(INCLUDE_DIR)/$(patsubst %.c,%.skel.h,$(prog))) auto-test-targets := \ + bypass \ create_dsq \ dequeue \ enq_last_no_enq_fails \ diff --git a/tools/testing/selftests/sched_ext/bypass.bpf.c b/tools/testing/selftests/sched_ext/bypass.bpf.c new file mode 100644 index 000000000000..cb37c8df6834 --- /dev/null +++ b/tools/testing/selftests/sched_ext/bypass.bpf.c @@ -0,0 +1,32 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * BPF scheduler for bypass mode operational test. + * + * Implements a minimal global FIFO scheduler. The userspace side + * attaches this scheduler, runs worker tasks to completion, and + * verifies that tasks complete successfully. + * + * Copyright (c) 2026 Xiaomi Corporation. + */ +#include + +char _license[] SEC("license") = "GPL"; + +UEI_DEFINE(uei); + +void BPF_STRUCT_OPS(bypass_enqueue, struct task_struct *p, u64 enq_flags) +{ + scx_bpf_dsq_insert(p, SCX_DSQ_GLOBAL, SCX_SLICE_DFL, enq_flags); +} + +void BPF_STRUCT_OPS(bypass_exit, struct scx_exit_info *ei) +{ + UEI_RECORD(uei, ei); +} + +SEC(".struct_ops.link") +struct sched_ext_ops bypass_ops = { + .enqueue = (void *)bypass_enqueue, + .exit = (void *)bypass_exit, + .name = "bypass_test", +}; diff --git a/tools/testing/selftests/sched_ext/bypass.c b/tools/testing/selftests/sched_ext/bypass.c new file mode 100644 index 000000000000..952f09d76bdb --- /dev/null +++ b/tools/testing/selftests/sched_ext/bypass.c @@ -0,0 +1,105 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Verify the sched_ext bypass mechanism: spawn worker tasks and ensure + * they run to completion while a BPF scheduler is active. + * + * The bypass mechanism (activated on scheduler unregistration) must + * guarantee forward progress. This test verifies that worker tasks + * complete successfully when the scheduler is detached. + * + * Copyright (c) 2026 Xiaomi Corporation. + */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include "scx_test.h" +#include "bypass.bpf.skel.h" + +#define NUM_BYPASS_WORKERS 4 + +static void worker_fn(void) +{ + volatile int sum = 0; + int i; + + /* + * Do enough work to still be running when bpf_link__destroy() + * is called, ensuring tasks are active during bypass mode. + */ + for (i = 0; i < 10000000; i++) + sum += i; +} + +static enum scx_test_status setup(void **ctx) +{ + struct bypass *skel; + + skel = bypass__open(); + SCX_FAIL_IF(!skel, "Failed to open bypass skel"); + SCX_ENUM_INIT(skel); + SCX_FAIL_IF(bypass__load(skel), "Failed to load bypass skel"); + + *ctx = skel; + return SCX_TEST_PASS; +} + +static enum scx_test_status run(void *ctx) +{ + struct bypass *skel = ctx; + struct bpf_link *link; + pid_t pids[NUM_BYPASS_WORKERS]; + int i, status; + + link = bpf_map__attach_struct_ops(skel->maps.bypass_ops); + SCX_FAIL_IF(!link, "Failed to attach bypass scheduler"); + + /* + * Spawn worker processes. These must complete successfully + * even as the scheduler is active and then detached (which + * triggers bypass mode). + */ + for (i = 0; i < NUM_BYPASS_WORKERS; i++) { + pids[i] = fork(); + SCX_FAIL_IF(pids[i] < 0, "fork() failed for worker %d", i); + + if (pids[i] == 0) { + worker_fn(); + _exit(0); + } + } + + /* + * Detach the scheduler while workers are still running. This + * triggers bypass mode, which must guarantee forward progress + * for all active tasks. + */ + bpf_link__destroy(link); + + /* Workers must complete successfully under bypass mode */ + for (i = 0; i < NUM_BYPASS_WORKERS; i++) { + SCX_FAIL_IF(waitpid(pids[i], &status, 0) != pids[i], + "waitpid failed for worker %d", i); + SCX_FAIL_IF(!WIFEXITED(status) || WEXITSTATUS(status) != 0, + "Worker %d did not exit cleanly", i); + } + + SCX_EQ(skel->data->uei.kind, EXIT_KIND(SCX_EXIT_UNREG)); + + return SCX_TEST_PASS; +} + +static void cleanup(void *ctx) +{ + bypass__destroy(ctx); +} + +struct scx_test bypass_test = { + .name = "bypass", + .description = "Verify tasks complete during bypass mode", + .setup = setup, + .run = run, + .cleanup = cleanup, +}; +REGISTER_SCX_TEST(&bypass_test) -- 2.43.0