From nobody Wed Apr 1 11:17:53 2026 Received: from mail-dy1-f201.google.com (mail-dy1-f201.google.com [74.125.82.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 ADA57426691 for ; Tue, 31 Mar 2026 15:34:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774971302; cv=none; b=S+ZNTqtqiwejMrPyQRpzLVFy23rgCFGZgc7oL3/SNgvAQktUMzkBDjS/lkW4JLt3ABOM1YacPp7ClXQ4QAbb9EZEDuArPASlQkEY+XA/CoY3/L1WZLu01kAgJ9Wo8ZvcNt7Tjorroliif1Y94PGC/CCjK3+PviONVx5S0JHXjgA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774971302; c=relaxed/simple; bh=hqnvAUyRD//uDsghjeO9XTcRE/oWX3SD/127id8yotY=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=mPUp5u9/lF48uVRHc8++s6Z2MoDuQzI1WJ3ot6k6avUetFeqG/+DelapxuC/KemvKnJ0atkMaS9lm/DqIqZeolst4FPr4lXY3k1nFf0weYUUH1nps08McRy2kGoAjOQsafjFPhe8Oq2JcQ44DM1hRk6jbl90S5QGmpQ7F2bvZNk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--wusamuel.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=uf+Q21rv; arc=none smtp.client-ip=74.125.82.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--wusamuel.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="uf+Q21rv" Received: by mail-dy1-f201.google.com with SMTP id 5a478bee46e88-2bdf6fe90a9so5391553eec.1 for ; Tue, 31 Mar 2026 08:34:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1774971298; x=1775576098; 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=oKdyQZxERM7zX00CvQx5rmQ/yM+uYmSc+NIq9/dspVA=; b=uf+Q21rvAXqnL1spCKc1aC7Jk5QtpsQVXMAPbL8omoJbYpVJH44IgdOYUr9TcR+wzv rFsNXmPSrkdu+96sMSV5+OFVhcCkMdpohQ9LCsr2oyouV+AkvLZsr0RkKNxb6GgCQGat SPXOZqq6gnkRUWwtSIvA3nsFTIvyEbejprmZPQ8koRlcAEa7+WmTovkOaNDSxP5d4+kC mcvM4xvNS9BvMZZ/GMH2ksqywD9n7HBpUUrWdsXyZLQSh1OWjqsKj8l62TjwqmJ+n8hB LZjOrGnwJvArW7koRSr2O3zSwBSBymj7E/x/jN+CRtd4N5N5dwxHtxPZOXOeWGs7iAKt 15ww== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1774971298; x=1775576098; 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=oKdyQZxERM7zX00CvQx5rmQ/yM+uYmSc+NIq9/dspVA=; b=J2YkfqfjBxDpWCdHxF9CqNtkf/wKF7E3M7wq0nN77zAAu6kZpIRMatA6N00F88ZEdc WaObMuAXUUOWwVERuN4MzVU0yrTWMXCcbV5FUB9pCdBZkGdSn9y+eR/NrpF83J/T8olZ EozLarMwjEbt3bBgsNoGdj1q687uZV2Sv4DML2XuU5Hf3ibA8f1LSMn2/VPLVmK3K/iA LaytgJuyVpBGoaBHQFCssXKirW0+Pj3hsaioPxfgeKnTFzgdzIN32IX8WakXmogIcRE7 JyxhPURtN7ygzWuQDRbj5NgiXaHvHHG4MLg0Q9TqELqjqdQVlducDjQ1jEvaygnpUUmA jB9A== X-Forwarded-Encrypted: i=1; AJvYcCVKiaa5GS4KGhheQwAUF1DKJMBO/25d4bDLz+BNKJuuil6VyOut7Ws0N1EHudjM6rqcowN6txzgzOAheZs=@vger.kernel.org X-Gm-Message-State: AOJu0YzEoqC//lIU7+FGf5T3XuSedvkppIbCgU7kyStr6mjMo3SMTrm6 +9mSMubj8h9okc2PNrTFDvUmF8rocaQIJBzX4fe+5twhYOFfSLETeLi4KPa5I1U4JKiHHAqsDOs xOd51C2r/2MOxtA== X-Received: from dycmo5.prod.google.com ([2002:a05:693c:26c5:b0:2c6:af43:29fd]) (user=wusamuel job=prod-delivery.src-stubby-dispatcher) by 2002:a05:7301:4909:b0:2c3:f58a:77c5 with SMTP id 5a478bee46e88-2c3f58a877emr3793737eec.30.1774971297340; Tue, 31 Mar 2026 08:34:57 -0700 (PDT) Date: Tue, 31 Mar 2026 08:34:11 -0700 In-Reply-To: <20260331153413.2469218-1-wusamuel@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260331153413.2469218-1-wusamuel@google.com> X-Mailer: git-send-email 2.53.0.1018.g2bb0e51243-goog Message-ID: <20260331153413.2469218-3-wusamuel@google.com> Subject: [PATCH v3 2/2] selftests/bpf: Add tests for wakeup_sources kfuncs From: Samuel Wu To: "Rafael J. Wysocki" , Pavel Machek , Len Brown , Greg Kroah-Hartman , Danilo Krummrich , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Eduard Zingerman , Kumar Kartikeya Dwivedi , Song Liu , Yonghong Song , Jiri Olsa , Shuah Khan Cc: Samuel Wu , kernel-team@android.com, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, driver-core@lists.linux.dev, bpf@vger.kernel.org, linux-kselftest@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Introduce a set of BPF selftests to verify the safety and functionality of wakeup_source kfuncs. The suite includes: 1. A functional test (test_wakeup_source.c) that iterates over the global wakeup_sources list. It uses CO-RE to read timing statistics and validates them in user-space via the BPF ring buffer. 2. A negative test suite (wakeup_source_fail.c) ensuring the BPF verifier correctly enforces reference tracking and type safety. 3. Enable CONFIG_PM_WAKELOCKS in the test config, allowing creation of wakeup sources via /sys/power/wake_lock. A shared header (wakeup_source.h) is introduced to ensure consistent memory layout for the Ring Buffer data between BPF and user-space. Signed-off-by: Samuel Wu --- tools/testing/selftests/bpf/config | 3 +- .../selftests/bpf/prog_tests/wakeup_source.c | 101 ++++++++++++++++++ .../selftests/bpf/progs/test_wakeup_source.c | 92 ++++++++++++++++ .../selftests/bpf/progs/wakeup_source.h | 22 ++++ .../selftests/bpf/progs/wakeup_source_fail.c | 76 +++++++++++++ 5 files changed, 293 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/wakeup_source.c create mode 100644 tools/testing/selftests/bpf/progs/test_wakeup_source.c create mode 100644 tools/testing/selftests/bpf/progs/wakeup_source.h create mode 100644 tools/testing/selftests/bpf/progs/wakeup_source_fail.c diff --git a/tools/testing/selftests/bpf/config b/tools/testing/selftests/b= pf/config index 24855381290d..bac60b444551 100644 --- a/tools/testing/selftests/bpf/config +++ b/tools/testing/selftests/bpf/config @@ -130,4 +130,5 @@ CONFIG_INFINIBAND=3Dy CONFIG_SMC=3Dy CONFIG_SMC_HS_CTRL_BPF=3Dy CONFIG_DIBS=3Dy -CONFIG_DIBS_LO=3Dy \ No newline at end of file +CONFIG_DIBS_LO=3Dy +CONFIG_PM_WAKELOCKS=3Dy diff --git a/tools/testing/selftests/bpf/prog_tests/wakeup_source.c b/tools= /testing/selftests/bpf/prog_tests/wakeup_source.c new file mode 100644 index 000000000000..ff2899cbf3a8 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/wakeup_source.c @@ -0,0 +1,101 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright 2026 Google LLC */ + +#include +#include +#include "test_wakeup_source.skel.h" +#include "wakeup_source_fail.skel.h" +#include "progs/wakeup_source.h" + +static int lock_ws(const char *name) +{ + int fd; + ssize_t bytes; + + fd =3D open("/sys/power/wake_lock", O_WRONLY); + if (!ASSERT_OK_FD(fd, "open /sys/power/wake_lock")) + return -1; + + bytes =3D write(fd, name, strlen(name)); + close(fd); + if (!ASSERT_EQ(bytes, strlen(name), "write to wake_lock")) + return -1; + + return 0; +} + +static void unlock_ws(const char *name) +{ + int fd; + + fd =3D open("/sys/power/wake_unlock", O_WRONLY); + if (fd < 0) + return; + + write(fd, name, strlen(name)); + close(fd); +} + +struct rb_ctx { + const char *name; + bool found; + long long active_time_ns; + long long total_time_ns; +}; + +static int process_sample(void *ctx, void *data, size_t len) +{ + struct rb_ctx *rb_ctx =3D ctx; + struct wakeup_event_t *e =3D data; + + if (strcmp(e->name, rb_ctx->name) =3D=3D 0) { + rb_ctx->found =3D true; + rb_ctx->active_time_ns =3D e->active_time_ns; + rb_ctx->total_time_ns =3D e->total_time_ns; + } + return 0; +} + +void test_wakeup_source(void) +{ + if (test__start_subtest("iterate_and_verify_times")) { + struct test_wakeup_source *skel; + struct ring_buffer *rb =3D NULL; + struct rb_ctx rb_ctx =3D { + .name =3D "bpf_selftest_ws_times", + .found =3D false, + }; + int err; + + skel =3D test_wakeup_source__open_and_load(); + if (!ASSERT_OK_PTR(skel, "skel_open_and_load")) + return; + + rb =3D ring_buffer__new(bpf_map__fd(skel->maps.rb), process_sample, &rb_= ctx, NULL); + if (!ASSERT_OK_PTR(rb, "ring_buffer__new")) + goto destroy; + + /* Create a temporary wakeup source */ + if (!ASSERT_OK(lock_ws(rb_ctx.name), "lock_ws")) + goto unlock; + + err =3D bpf_prog_test_run_opts(bpf_program__fd( + skel->progs.iterate_wakeupsources), NULL); + ASSERT_OK(err, "bpf_prog_test_run"); + + ring_buffer__consume(rb); + + ASSERT_TRUE(rb_ctx.found, "found_test_ws_in_rb"); + ASSERT_GT(rb_ctx.active_time_ns, 0, "active_time_gt_0"); + ASSERT_GT(rb_ctx.total_time_ns, 0, "total_time_gt_0"); + +unlock: + unlock_ws(rb_ctx.name); +destroy: + if (rb) + ring_buffer__free(rb); + test_wakeup_source__destroy(skel); + } + + RUN_TESTS(wakeup_source_fail); +} diff --git a/tools/testing/selftests/bpf/progs/test_wakeup_source.c b/tools= /testing/selftests/bpf/progs/test_wakeup_source.c new file mode 100644 index 000000000000..fd2fb6aebd82 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_wakeup_source.c @@ -0,0 +1,92 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright 2026 Google LLC */ + +#include "vmlinux.h" +#include +#include +#include "bpf_experimental.h" +#include "bpf_misc.h" +#include "wakeup_source.h" + +#define MAX_LOOP_ITER 1000 +#define RB_SIZE (16384 * 4) + +struct { + __uint(type, BPF_MAP_TYPE_RINGBUF); + __uint(max_entries, RB_SIZE); +} rb SEC(".maps"); + +struct bpf_ws_lock; +struct bpf_ws_lock *bpf_wakeup_sources_read_lock(void) __ksym; +void bpf_wakeup_sources_read_unlock(struct bpf_ws_lock *lock) __ksym; +void *bpf_wakeup_sources_get_head(void) __ksym; + +SEC("syscall") +__success __retval(0) +int iterate_wakeupsources(void *ctx) +{ + struct list_head *head =3D bpf_wakeup_sources_get_head(); + struct list_head *pos =3D head; + struct bpf_ws_lock *lock; + int i; + + lock =3D bpf_wakeup_sources_read_lock(); + if (!lock) + return 0; + + bpf_for(i, 0, MAX_LOOP_ITER) { + if (bpf_core_read(&pos, sizeof(pos), &pos->next) || !pos || pos =3D=3D h= ead) + break; + + struct wakeup_event_t *e =3D bpf_ringbuf_reserve(&rb, sizeof(*e), 0); + + if (!e) + break; + + struct wakeup_source *ws =3D bpf_core_cast( + (void *)pos - bpf_core_field_offset(struct wakeup_source, entry), + struct wakeup_source); + s64 active_time =3D 0; + bool active =3D BPF_CORE_READ_BITFIELD(ws, active); + bool autosleep_enable =3D BPF_CORE_READ_BITFIELD(ws, autosleep_enabled); + s64 last_time =3D ws->last_time; + s64 max_time =3D ws->max_time; + s64 prevent_sleep_time =3D ws->prevent_sleep_time; + s64 total_time =3D ws->total_time; + + if (active) { + s64 curr_time =3D bpf_ktime_get_ns(); + s64 prevent_time =3D ws->start_prevent_time; + + if (curr_time > last_time) + active_time =3D curr_time - last_time; + + total_time +=3D active_time; + if (active_time > max_time) + max_time =3D active_time; + if (autosleep_enable && curr_time > prevent_time) + prevent_sleep_time +=3D curr_time - prevent_time; + } + + e->active_count =3D ws->active_count; + e->active_time_ns =3D active_time; + e->event_count =3D ws->event_count; + e->expire_count =3D ws->expire_count; + e->last_time_ns =3D last_time; + e->max_time_ns =3D max_time; + e->prevent_sleep_time_ns =3D prevent_sleep_time; + e->total_time_ns =3D total_time; + e->wakeup_count =3D ws->wakeup_count; + + if (bpf_probe_read_kernel_str( + e->name, WAKEUP_NAME_LEN, ws->name) < 0) + e->name[0] =3D '\0'; + + bpf_ringbuf_submit(e, 0); + } + + bpf_wakeup_sources_read_unlock(lock); + return 0; +} + +char _license[] SEC("license") =3D "GPL"; diff --git a/tools/testing/selftests/bpf/progs/wakeup_source.h b/tools/test= ing/selftests/bpf/progs/wakeup_source.h new file mode 100644 index 000000000000..cd74de92c82f --- /dev/null +++ b/tools/testing/selftests/bpf/progs/wakeup_source.h @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright 2026 Google LLC */ + +#ifndef __WAKEUP_SOURCE_H__ +#define __WAKEUP_SOURCE_H__ + +#define WAKEUP_NAME_LEN 128 + +struct wakeup_event_t { + unsigned long active_count; + long long active_time_ns; + unsigned long event_count; + unsigned long expire_count; + long long last_time_ns; + long long max_time_ns; + long long prevent_sleep_time_ns; + long long total_time_ns; + unsigned long wakeup_count; + char name[WAKEUP_NAME_LEN]; +}; + +#endif /* __WAKEUP_SOURCE_H__ */ diff --git a/tools/testing/selftests/bpf/progs/wakeup_source_fail.c b/tools= /testing/selftests/bpf/progs/wakeup_source_fail.c new file mode 100644 index 000000000000..0f8d29865a01 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/wakeup_source_fail.c @@ -0,0 +1,76 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright 2026 Google LLC */ + +#include +#include +#include "bpf_misc.h" + +struct bpf_ws_lock; + +struct bpf_ws_lock *bpf_wakeup_sources_read_lock(void) __ksym; +void bpf_wakeup_sources_read_unlock(struct bpf_ws_lock *lock) __ksym; +void *bpf_wakeup_sources_get_head(void) __ksym; + +SEC("syscall") +__failure __msg("BPF_EXIT instruction in main prog would lead to reference= leak") +int wakeup_source_lock_no_unlock(void *ctx) +{ + struct bpf_ws_lock *lock; + + lock =3D bpf_wakeup_sources_read_lock(); + if (!lock) + return 0; + + return 0; +} + +SEC("syscall") +__failure __msg("access beyond struct") +int wakeup_source_access_lock_fields(void *ctx) +{ + struct bpf_ws_lock *lock; + int val; + + lock =3D bpf_wakeup_sources_read_lock(); + if (!lock) + return 0; + + val =3D *(int *)lock; + + bpf_wakeup_sources_read_unlock(lock); + return val; +} + +SEC("syscall") +__failure __msg("type=3Dscalar expected=3Dfp") +int wakeup_source_unlock_no_lock(void *ctx) +{ + struct bpf_ws_lock *lock =3D (void *)0x1; + + bpf_wakeup_sources_read_unlock(lock); + + return 0; +} + +SEC("syscall") +__failure __msg("Possibly NULL pointer passed to trusted arg0") +int wakeup_source_unlock_null(void *ctx) +{ + bpf_wakeup_sources_read_unlock(NULL); + + return 0; +} + +SEC("syscall") +__failure __msg("R0 invalid mem access 'scalar'") +int wakeup_source_unsafe_dereference(void *ctx) +{ + struct list_head *head =3D bpf_wakeup_sources_get_head(); + + if (head->next) + return 1; + + return 0; +} + +char _license[] SEC("license") =3D "GPL"; --=20 2.53.0.1018.g2bb0e51243-goog