From nobody Wed Apr 1 09:44:31 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 01A8E426684 for ; Tue, 31 Mar 2026 15:34:53 +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=1774971297; cv=none; b=h7LlgOdrVeyvuW+O7+FGNEEJ3JGb5bIPjBOrFoR5pbp4v9XdDVvyKG8u1pyQfNvK3R7TGxEsmCBUyJBwIRU5IJ7T+zycq67QWj9U24qpN+/muYpNPATBVYSOpkpwHkqjlqo2eKbs/15kd6WTagnFl/jug1ocAKH9yGFnYbKQzdM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774971297; c=relaxed/simple; bh=QKH00JljZrlMfVod10pqmeNjUeUmhefNzONLwQdWIy4=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=DR7KNgu0PzfgkAnq1viIN38V7HOo3LNCChpR0eNosbGk38I41Rt92DzAV1y4lb6OuNtFExakCljYwzOn7MDAdTkfM+vNuigmfECL0aQKXZ9UTvict/cBCeg5nqA0EoRGwNSp9lj3coQ/WvFopW0e6eRvpK5Cdqm+Ky2IolGV+9Y= 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=aZiqyRw6; 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="aZiqyRw6" Received: by mail-dy1-f201.google.com with SMTP id 5a478bee46e88-2bdf75bc88fso4877566eec.0 for ; Tue, 31 Mar 2026 08:34:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1774971293; x=1775576093; 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=EQA/UKYBuXcCvugMU5yRxI2SsSzVyoeHKW9NqHrZ5UA=; b=aZiqyRw694GKSHlKvQISz4LUFSWoy2YiR8D9kfutO79W9rFfui+PfshZKv+ADZ9pNV B7I5sHTP2uLb00d1Mvgt9d3JZpAsNGRWmyKwZ1lv9Ukl/eIrKor70PvOXSXIb6KbSKYd 6HjXjY6dmoA9dtu9YxlgVPKpYi0ajC9Xn6+ACI8Vi7IWKROHr0xuWmt5CaQEQeXU/BG6 lqJZgdk7L+qNe9IpyuGLWSJQDWKrUi0rJdLN7cf+n9VzoditU1FRN40cqkE/pRkkvxJY W10s+yhE3bUdqwX8A2w56of9gWdITdeecirF98YjT7nN76VcGCniS+0Kf+1ZgHkKTnDE QS4Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1774971293; x=1775576093; 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=EQA/UKYBuXcCvugMU5yRxI2SsSzVyoeHKW9NqHrZ5UA=; b=WFVb4RBdiOvBD4tbmLCG2xxJWeDBqtM8pecdA6YxtI4nWgMdTgveVllKC77cfJddh2 VeHLx4V/gP+YPlmeAVX61Rg8+kJHcmpvx2CQLHWoM64KIIfeK2Tl9tmhbPtuRyKFukrY X+IP2jewbukyU62rNhTzwcVuVnbGUazUMKM0zbWcilbXtRkANOmjrKeu8XiZw1bUnvbf h3f2/snuhfGNM+nzox3AbeJMvP6pEFoNOBp3eroHmlSBHIFZR4OdSH1pBlgDsw4zaW0h QtkPiGRbrOCsABLXi7b+oQymihbYvCvC4W73a6ahnz11JvWVxxMrTJaIjxh4fqtQf7xg fPOg== X-Forwarded-Encrypted: i=1; AJvYcCVka1mGDNherh8QDUeVcq2fwArs8Upf6I/gpy2kddGm0p22FGNt6xRabS5Jp/HuOfppcuPtv3/kcGazdvA=@vger.kernel.org X-Gm-Message-State: AOJu0YwMJPCyCsfTXcUXcOo6rVRJX14VRRMCaietmIpfpl3o2PlkqHyI kQmCEgFfV+yh8Y5kz46GzbcSIMBjNsZj99jVxMVO4JQJfXG/W23m1+qGwxh2gsyKPP2LhV5g6fD tJnCWj+YWpzMdig== X-Received: from dyr23.prod.google.com ([2002:a05:693c:4017:b0:2be:6911:c4f2]) (user=wusamuel job=prod-delivery.src-stubby-dispatcher) by 2002:a05:7301:da0b:b0:2c3:b172:83c2 with SMTP id 5a478bee46e88-2c3b1728c62mr5463093eec.20.1774971292418; Tue, 31 Mar 2026 08:34:52 -0700 (PDT) Date: Tue, 31 Mar 2026 08:34:10 -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-2-wusamuel@google.com> Subject: [PATCH v3 1/2] PM: wakeup: Add kfuncs to traverse over wakeup_sources From: Samuel Wu To: "Rafael J. Wysocki" , Len Brown , Pavel Machek , Greg Kroah-Hartman , Danilo Krummrich , Andrii Nakryiko , Eduard Zingerman , Alexei Starovoitov , Daniel Borkmann , Martin KaFai Lau , 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" Iterating through wakeup sources via sysfs or debugfs can be inefficient or restricted. Introduce BPF kfuncs to allow high-performance and safe in-kernel traversal of the wakeup_sources list. The new kfuncs include: - bpf_wakeup_sources_get_head() to obtain the list head. - bpf_wakeup_sources_read_lock/unlock() to manage the SRCU lock. For verifier safety, the underlying SRCU index is wrapped in an opaque 'struct bpf_ws_lock' pointer. This enables the use of KF_ACQUIRE and KF_RELEASE flags, allowing the BPF verifier to strictly enforce paired lock/unlock cycles and prevent resource leaks. Signed-off-by: Samuel Wu --- drivers/base/power/power.h | 7 ++++ drivers/base/power/wakeup.c | 72 +++++++++++++++++++++++++++++++++++-- 2 files changed, 77 insertions(+), 2 deletions(-) diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h index 922ed457db19..8823aceeac8b 100644 --- a/drivers/base/power/power.h +++ b/drivers/base/power/power.h @@ -168,3 +168,10 @@ static inline void device_pm_init(struct device *dev) device_pm_sleep_init(dev); pm_runtime_init(dev); } + +#ifdef CONFIG_BPF_SYSCALL +struct bpf_ws_lock { }; +struct bpf_ws_lock *bpf_wakeup_sources_read_lock(void); +void bpf_wakeup_sources_read_unlock(struct bpf_ws_lock *lock); +void *bpf_wakeup_sources_get_head(void); +#endif diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c index b8e48a023bf0..8eda7d35d9cc 100644 --- a/drivers/base/power/wakeup.c +++ b/drivers/base/power/wakeup.c @@ -1168,11 +1168,79 @@ static const struct file_operations wakeup_sources_= stats_fops =3D { .release =3D seq_release_private, }; =20 -static int __init wakeup_sources_debugfs_init(void) +#ifdef CONFIG_BPF_SYSCALL +#include + +__bpf_kfunc_start_defs(); + +/** + * bpf_wakeup_sources_read_lock - Acquire the SRCU lock for wakeup sources + * + * The underlying SRCU lock returns an integer index. However, the BPF ver= ifier + * requires a pointer (PTR_TO_BTF_ID) to strictly track the state of acqui= red + * resources using KF_ACQUIRE and KF_RELEASE semantics. We use an opaque + * structure pointer (struct bpf_ws_lock *) to satisfy the verifier while + * safely encoding the integer index within the pointer address itself. + * + * Return: An opaque pointer encoding the SRCU lock index + 1 (to avoid NU= LL). + */ +__bpf_kfunc struct bpf_ws_lock *bpf_wakeup_sources_read_lock(void) +{ + return (struct bpf_ws_lock *)(long)(wakeup_sources_read_lock() + 1); +} + +/** + * bpf_wakeup_sources_read_unlock - Release the SRCU lock for wakeup sourc= es + * @lock: The opaque pointer returned by bpf_wakeup_sources_read_lock() + * + * The BPF verifier guarantees that @lock is a valid, unreleased pointer f= rom + * the acquire function. We decode the pointer back into the integer SRCU = index + * by subtracting 1 and release the lock. + */ +__bpf_kfunc void bpf_wakeup_sources_read_unlock(struct bpf_ws_lock *lock) +{ + wakeup_sources_read_unlock((int)(long)lock - 1); +} + +/** + * bpf_wakeup_sources_get_head - Get the head of the wakeup sources list + * + * Return: The head of the wakeup sources list. + */ +__bpf_kfunc void *bpf_wakeup_sources_get_head(void) +{ + return &wakeup_sources; +} + +__bpf_kfunc_end_defs(); + +BTF_KFUNCS_START(wakeup_source_kfunc_ids) +BTF_ID_FLAGS(func, bpf_wakeup_sources_read_lock, KF_ACQUIRE) +BTF_ID_FLAGS(func, bpf_wakeup_sources_read_unlock, KF_RELEASE) +BTF_ID_FLAGS(func, bpf_wakeup_sources_get_head) +BTF_KFUNCS_END(wakeup_source_kfunc_ids) + +static const struct btf_kfunc_id_set wakeup_source_kfunc_set =3D { + .owner =3D THIS_MODULE, + .set =3D &wakeup_source_kfunc_ids, +}; + +static void __init wakeup_sources_bpf_init(void) +{ + if (register_btf_kfunc_id_set(BPF_PROG_TYPE_SYSCALL, &wakeup_source_kfunc= _set)) + pm_pr_dbg("Wakeup: failed to register BTF kfuncs\n"); +} +#else +static inline void wakeup_sources_bpf_init(void) {} +#endif /* CONFIG_BPF_SYSCALL */ + +static int __init wakeup_sources_init(void) { debugfs_create_file("wakeup_sources", 0444, NULL, NULL, &wakeup_sources_stats_fops); + wakeup_sources_bpf_init(); + return 0; } =20 -postcore_initcall(wakeup_sources_debugfs_init); +postcore_initcall(wakeup_sources_init); --=20 2.53.0.1018.g2bb0e51243-goog From nobody Wed Apr 1 09:44:31 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