On Sat, 13 Jun 2026 09:40:06 +0300 Onur Özkan <[email protected]> wrote:
> The immediate motivation is the Tyr reset infrastructure [1] which needs > to serialize reset sensitive hardware access against reset and teardown > paths. That reset series started to require many independent dependencies > so this SRCU support is split out as a standalone Rust API to keep the > reset series focused on the reset logic and easier to review, rebase and > land. > > > Changes since v9: > > - SRCU initialization restructuring is now a separate patch (the first > one in this series). > - Comment fix on C initialization functions. > > > Changes since v8: > > - Refactor srcu init handling to provide better init API (motivated by > the "mutex.h" initializers. > - Use warn_on! instead of pr_warn! on leaked guard detection. > > > Changes since v7: > > - Moved synchronize_srcu() call inside "if srcu_readers_active()" > condition in "impl PinnedDrop for Srcu". > - Improved comments on the synchronize_srcu() call in > "impl PinnedDrop for Srcu". > > > Changes since v6: > > - Removed "CONFIG_DEBUG_LOCK_ALLOC" condition from "rust/helpers/srcu.c" > and created a simple wrapper inside "include/linux/srcu.h" for it. > > > Changes since v5: > > - Created separate srcu_readers_active() variants for "srcutiny.h" and > "srcutree.h". > > > Changes since v4: > > - Exposed srcu_readers_active from C side and wired it to the Rust > helpers. > - Used srcu_readers_active() in SRCU drop and logged with pr_warn if > there are leaked guards during the drop. > > > Changes since v3 (which are for Sashiko notes [2]): > > - Added rust helpers for srcu_barrier() and synchronize_srcu_expedited() > so the abstraction builds with CONFIG_TINY_SRCU, where these are > static inline functions. > - Added missing INVARIANT comment in Srcu::new() about why the type > invariants hold after successful initialization. > > > Changes since v2: > > - Removed closure-based API. > - Added #[doc(hidden)] on new_srcu macro. > - Added #[must_use..] on srcu::Guard. > - Improved the clean-up path (PinnedDrop implementation) which > eventually made read_lock safe with leaked guards. > > > Changes since v1: > > - Made the owned SRCU read-side guard API unsafe and added a safe closure > based helper for callers that do not need to keep the guard. This is to > avoid UB on the C side cleanup_srcu_struct where the SRCU struct is freed > while there are still active guards, which can happen if the caller leaks > the guard e.g., with mem::forget(). > - Improved doc comments. > > > v1: https://lore.kernel.org/all/[email protected] > v2: https://lore.kernel.org/all/[email protected] > v3: https://lore.kernel.org/all/[email protected] > v4: https://lore.kernel.org/all/[email protected] > v5: https://lore.kernel.org/all/[email protected] > v6: https://lore.kernel.org/all/[email protected] > v7: https://lore.kernel.org/all/[email protected] > v8: https://lore.kernel.org/all/[email protected] > v9: https://lore.kernel.org/all/[email protected] > > [1]: https://lore.kernel.org/all/[email protected] > [2]: > https://sashiko.dev/#/patchset/[email protected]?part=2 > > Onur Özkan (5): > srcu: make init_srcu_struct() consistently wrap __init_srcu_struct() > rust: helpers: add SRCU helpers > srcu: expose srcu_readers_active() > rust: sync: add SRCU abstraction > MAINTAINERS: add Rust SRCU files to SRCU entry > > MAINTAINERS | 3 + > include/linux/srcu.h | 29 ++++--- > include/linux/srcutiny.h | 13 +++ > include/linux/srcutree.h | 24 ++++++ > kernel/rcu/srcutiny.c | 14 ++-- > kernel/rcu/srcutree.c | 36 ++------- > rust/helpers/helpers.c | 1 + > rust/helpers/srcu.c | 35 ++++++++ > rust/kernel/sync.rs | 2 + > rust/kernel/sync/srcu.rs | 171 +++++++++++++++++++++++++++++++++++++++ > 10 files changed, 282 insertions(+), 46 deletions(-) > create mode 100644 rust/helpers/srcu.c > create mode 100644 rust/kernel/sync/srcu.rs > > -- > 2.51.2 > A gentle ping on this series. Are there any remaining concerns with v10? Regards, Onur
