From nobody Sat Jun 13 00:35:33 2026 Received: from mail-dy1-f202.google.com (mail-dy1-f202.google.com [74.125.82.202]) (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 69650472784 for ; Mon, 11 May 2026 17:50:11 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1778521812; cv=none; b=qAV5h+5kZf3WU29URkzAddUnAxNKBv+Bdbuq0neNPeHdaABwi/68qxbf0P+Mba+fj2SXsbsMTWgtr2s7VbJn5u4hz4OcEnRHOe0WoW6mUyewdihgLA2lNhhRyoGAduw31kCLMkf010sXQYbp0iPpk9PT3BmSSdnCOaUBuJ1P0D0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1778521812; c=relaxed/simple; bh=Oq67dXaTV+BHjGRbysYou0ulHtDM/4BziolaYr9VX4g=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=OGOnA2fc3QL67J3b9wrRBhju7+0ZAF6w3Y+czbeWa6vjzDhTr4YjQeOoksfpcM8EPWh979HGroQHqn0hpVhuxfDdz8CzqGjw7AaZ7iXjB7gpuEuZbAT/tu7Ex983TT+8RMW0TXGNIrereiC54+pz1WGDlieD5+QfZHtjPWMmCeA= 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=FgiouSv6; arc=none smtp.client-ip=74.125.82.202 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="FgiouSv6" Received: by mail-dy1-f202.google.com with SMTP id 5a478bee46e88-2f5943ca81aso4307995eec.0 for ; Mon, 11 May 2026 10:50:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1778521810; x=1779126610; 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=/Hxl2WZ9OZBQQeGr1zOYQYix9RVHeZZ/4ou1EYE8Zvc=; b=FgiouSv6VjkmVA3VSULStTRpIh/teWFFANtwx6w7HQRmL3GX0faS0yimcSvqmKuG9G EmrmPvTADnb1xcfTxXbnzpvFKW/s+WYx5RAQthf2QhZUnug26v3SoiGrIu1f4ef5+6zM FNkkcMzZYxzR09xPgtsIyiNYs07m4zeWxL77Ufy9tos2C3rCpHUkbDYNQSbvZzFcfTYh DyFvPALODrO35FbuleQRsy2GzovV+SjDQQNXRKWyKZv/+K/KaIgvnmHJ2bg0HQFyD9c0 1mXzCWaSwE16WoG3X9IoMxKS3nlyg+G5YNU9I6gF7qOw1Emn/QxK6KOQorOV+sFjrqoX c7AQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1778521810; x=1779126610; 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=/Hxl2WZ9OZBQQeGr1zOYQYix9RVHeZZ/4ou1EYE8Zvc=; b=oOD6pl2jx1MhISylUxFfifsnO0SU9oUup+oY+u2153/9cn2Aqv0jrBkhacbtt1LLdB ZA0OgeVRHQP8w+8ZeFpLPcrQXQP7GFjqnbZPtRHDkO/PRf3axPnZpOZxSPotzW3Fxc3A 5ZNjnPFrHqSUpLmMb8rwb/5RpF9HPUe6L0K1Oaqyy5nawqpEYmQYfGIhCY6MafdhTIHT TLRou/2bZPYtbLGT0j9EOo20bfMvXp4bWiQQzXIbUPO+EPHOQY7fcIy0cpJCJRFfPc6K 029Tss7e/G83Fgta7tTG5IOMI7gGujQe1ElaZ1bpMQvBqsDSkL8+opCNfBI6+VPsqj5i gmNg== X-Forwarded-Encrypted: i=1; AFNElJ9W2L4r4d7FGdcP3R9pQmizhcUXz9AJsai5pWNcWuLILITYZA6hSUpbJ9olWjccckljTO+e90QHKqFdNSI=@vger.kernel.org X-Gm-Message-State: AOJu0YzrS82of42S2ry1PRDunVx55+CkXmtIGx/78erES6pgGw96q+hm 7wP0tG4vgEZvTURcle7ZhPMfZ1D2PAbCt8NwhAD9zusCT0o63FXff6joZNb+huMJbtzPgkSiGX3 nnyK+mRY6YVU0jw== X-Received: from dybkf34.prod.google.com ([2002:a05:7301:3aa2:b0:2f7:1410:b095]) (user=wusamuel job=prod-delivery.src-stubby-dispatcher) by 2002:a05:7301:19a5:b0:2dd:6937:79b8 with SMTP id 5a478bee46e88-2fb3dbf98bamr5182384eec.5.1778521810205; Mon, 11 May 2026 10:50:10 -0700 (PDT) Date: Mon, 11 May 2026 10:45:56 -0700 In-Reply-To: <20260511174559.659782-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: <20260511174559.659782-1-wusamuel@google.com> X-Mailer: git-send-email 2.54.0.563.g4f69b47b94-goog Message-ID: <20260511174559.659782-2-wusamuel@google.com> Subject: [PATCH v4 1/2] PM: wakeup: Add kfuncs to traverse over wakeup_sources 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" 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. There is at least a 30x speedup for walking 150 wakeup sources and all their attributes. 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 Acked-by: Greg Kroah-Hartman Acked-by: Kumar Kartikeya Dwivedi Acked-by: Rafael J. Wysocki (Intel) --- drivers/base/power/power.h | 7 ++++ drivers/base/power/wakeup.c | 71 +++++++++++++++++++++++++++++++++++-- 2 files changed, 76 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..80b497de2deb 100644 --- a/drivers/base/power/wakeup.c +++ b/drivers/base/power/wakeup.c @@ -1168,11 +1168,78 @@ 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 { + .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.54.0.563.g4f69b47b94-goog From nobody Sat Jun 13 00:35:33 2026 Received: from mail-dy1-f202.google.com (mail-dy1-f202.google.com [74.125.82.202]) (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 A6D79477990 for ; Mon, 11 May 2026 17:50:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1778521817; cv=none; b=USekonVQk+0+3E760cULuJCQ/6TBWQC3s9Uo8qgu/JZkPst91gJYfJ3l0Lb98mxameinOik2u1Vy//EGQSA42Jj1WwY4H7gw+egPxmNpvX47GXwdiRvAHdL2S1bwPGI/atmP0TcJi38D+2XvdiKfcNOCH6egGRODONpex277pgA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1778521817; c=relaxed/simple; bh=5t+rgRmwNKOTGxjA3TnMftuOAxoMHi99654/aoqt7DU=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=OHNuB/SkzojM/O0+TZZKRl8SgVt1uvGC4BCYlJ7qjb1v9a2Emryv0oMbaswreZvJEhmclHgeRxIrF8GukIrmxMdIsDIxl/zuWCxJqt37m3PYDSvlKJD4ufST9LE6XDY4xPS2IVmfRpgCUA5dva25kEWON2aHqWv7jRcmZTyFxTw= 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=QAXob9KW; arc=none smtp.client-ip=74.125.82.202 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="QAXob9KW" Received: by mail-dy1-f202.google.com with SMTP id 5a478bee46e88-2ee34588671so6667085eec.0 for ; Mon, 11 May 2026 10:50:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1778521815; x=1779126615; 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=Ea7DK+L4Wu/KHKm8qiylB6j3XaGbVSoqEomBPOOxkq4=; b=QAXob9KWWQdcv5/eRgGkAojwr+Mgay/ugcvHiRhciTrk8l5YoQN+JK7BPxQFTqLmRB oULrpwm+u5Mt/oVjUYRtfozog+9UJ0620SKJOM29WlPj0xmfJyZj0vuGYLowUVPHmgvf JutUdrPB1RvdVJKwh4kh4ynxiXDmhhL7LxU8Ay27ioHg3kfjGay71NodDgqj8G0kuI5D rWBrRdDz/S8dVFNO1POBOreiGoeR3nDZvnJYiMRmflXHzQKQQU21ad1zU57Df2W/xr89 zgjJwqeN9Z7s83/R4UWKsukGUxgw/wcjeVa7x2HzMXSzZlhw8d6BT/OLtA3vECxn6NyR P8sQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1778521815; x=1779126615; 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=Ea7DK+L4Wu/KHKm8qiylB6j3XaGbVSoqEomBPOOxkq4=; b=l7djPntIKwh46atYMOHyTEhxpCCsGSos4C70fse5YVC+GgHh3x8Wl0LA16v6xWrZ7z S9PtsQfYJs4M4kgLkBvy1PrqYoKH/X7emfPLraQoxhYWJnayWXQ1DIvzB1UxoEvp8lh1 d1vHE6Jv6byd9/oRtfzPySq1ID1lK16+fQRiXJS39FHHl1O5TTEqRuBfIGOinXJqwQDL HMpo12SsjrB6DUKh/otxDILbE3O4bw0fCr4WiB5OMxesMBE+4yUuT9JqXBQlU3XBpRzZ G9d0Srdxclesro+WP7+TLAu1llM28UMA6PZWR918zJQfezQpIeuozFaVV1xuiq4YXARN e4aw== X-Forwarded-Encrypted: i=1; AFNElJ+JU2LUojs8OaU2AEi6K1C58TXf/YBa6dc6Qbjyjs04ofpII7ctmfG55hVJTVAQixYJX+WXc8QJVI6DCqs=@vger.kernel.org X-Gm-Message-State: AOJu0Yw5pnisODVxG+AsBiWpeiwZ005gbSz4LyBTM4e+ukVn6mi+AyR9 zRM8rQE+9zkBk3VqG3n5Y1ico5pCvEZOFKGX5WsoXzeujz+fvU0NKpD9DtMzOpUJ62uiQ6Ar9IG qCUfru/00i62PpA== X-Received: from dycnn11.prod.google.com ([2002:a05:7301:140b:b0:2d8:e3a6:d707]) (user=wusamuel job=prod-delivery.src-stubby-dispatcher) by 2002:a05:7300:6424:b0:2da:a813:a60c with SMTP id 5a478bee46e88-2f549f8389bmr13536600eec.20.1778521814470; Mon, 11 May 2026 10:50:14 -0700 (PDT) Date: Mon, 11 May 2026 10:45:57 -0700 In-Reply-To: <20260511174559.659782-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: <20260511174559.659782-1-wusamuel@google.com> X-Mailer: git-send-email 2.54.0.563.g4f69b47b94-goog Message-ID: <20260511174559.659782-3-wusamuel@google.com> Subject: [PATCH v4 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 , 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" 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 Acked-by: Greg Kroah-Hartman Acked-by: Kumar Kartikeya Dwivedi Acked-by: Rafael J. Wysocki (Intel) --- tools/testing/selftests/bpf/config | 3 +- .../selftests/bpf/prog_tests/wakeup_source.c | 118 ++++++++++++++++++ .../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, 310 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..ebfdc03271b9 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/wakeup_source.c @@ -0,0 +1,118 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright 2026 Google LLC */ + +#include +#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) +{ + struct btf *btf; + int id; + + btf =3D btf__load_vmlinux_btf(); + if (!ASSERT_OK_PTR(btf, "btf_vmlinux")) + return; + + id =3D btf__find_by_name_kind(btf, "bpf_wakeup_sources_get_head", BTF_KIN= D_FUNC); + btf__free(btf); + + if (id < 0) { + printf("%s:SKIP:bpf_wakeup_sources_get_head kfunc not found in BTF\n", _= _func__); + test__skip(); + return; + } + + 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..b8bbb61d4d4e --- /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") +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.54.0.563.g4f69b47b94-goog