From nobody Sat Feb 7 17:04:36 2026 Received: from mail-ot1-f41.google.com (mail-ot1-f41.google.com [209.85.210.41]) (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 2C8D95B5AB for ; Wed, 28 Jan 2026 23:21:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769642464; cv=none; b=A3aI5DnFjYsPSlARTRub+Xp5IyKsY9SJIxoKrCxO6bLA6hYae4Rxe9Y+BdJLEm694+0l6OKBFQOPjKmNIqKwGoW2UQqDYl82BWM1aMz1FryENX0TXyeu2dBRDCmpYWKW2PxFdgtLqLZqq/sThWHSSr1S3yRya1TzjNYN/z+l06U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769642464; c=relaxed/simple; bh=/hRPwTjZmIfPfF6SXM76s/bDbQMZnDCoJvb+xB1fsC4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Kwbr6wzzRWGAEX8H7n2EthFVSEZQT/7k65CcpBfQZgkQF9QBMeJVlR3FAEc0cG6zk+nW11ezaJgvrkzXeGlMXNCFgHQtlxAdt3eF/c6sD2kpdtFLqZBTX7e3ENfjUDcoAvCcRSDnp38sXlsPBBNjBuDMb2Yionaw9Q0tALcoum0= 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=OSwMD3I+; arc=none smtp.client-ip=209.85.210.41 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="OSwMD3I+" Received: by mail-ot1-f41.google.com with SMTP id 46e09a7af769-7d195166b2cso217645a34.3 for ; Wed, 28 Jan 2026 15:21:01 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769642461; x=1770247261; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:from:to:cc:subject :date:message-id:reply-to; bh=NNS0YAOwbVOFsEM5UfR8k15PlxPXeRQf3X2TS9uzn6I=; b=OSwMD3I+4TaljjLEeOpfWhDV6TjbHWxSSXgIPpR5rAwACY9DP0rC0jklYeXw/z0Jqa 2O4C4rodt0gvSN02DORKNFYEoxITOLiddp/hpNGoLm7wrHZNGi5HE3Wk1vRZ1qn9X5PP EI61TAjj1FTyGkk5VyZdVBecNpfS4jkKn9iyyBoB+Mfp+UAQOhwFP0zmMWyWt/pXo+Og mCqod8aunjIyD8r/S0xLUVu6IFZQNLWkJq948W6MbVf/iIrKOXYqWJ6GI7JwBapf0kO6 SDY6BzypwbScTLPkb8+v/wNPIQU7gcKWgVw2GVK5smpIr228mf1pUTvX4g8D/T36Eoza Wa4Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769642461; x=1770247261; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=NNS0YAOwbVOFsEM5UfR8k15PlxPXeRQf3X2TS9uzn6I=; b=DnvZbngTFCd4pB5QPTkxv1DBjnTFEk+Jexf4oUN/1P4+ub8AFXBzdYY/PxvU9x2lrI zszdvmOXCYkNtXLhHfJ85F5/c5MkirxWPI+6pMhuUnN8O3YhpoL1TIUeWmGJR8GjJHVE U91OoaCEXhD4eB9uGZd90OAm7eXqetZWstIUp/maUKr6qVc+5vwP4JLXyCZvSFFHS0Z4 qvwIRlF6TM/Ddo9pYtU96S7K16v8bPCu6Th86PZhhRI8A4O7OMPYVqK6J+FqksLJnm+N dGE+z+k62h/gWokatE5W6lxbSnn3E43nUl/3Vo7X+kgvHVYpYHpcdvgwSygIBlOICEqv M/vQ== X-Gm-Message-State: AOJu0YxUUd9/HnzSaZISqmXuOMxO3eGmkDnUqC5tNfpuJBb9BBNX6xvz KIMR8bAXnDd1TWem2m/W4l7SKsns/OHstk6hamE5TeiStnl3+UDHTre6FCM39Q== X-Gm-Gg: AZuq6aLa5Omwxk2DZtcsSfthYdF+RbnpHsD5GXQiCbR4wbC3atLm1OFt9DlKxtWiWfo KlqGEh9ZhzkYzH0xZn5naoevbHMgFrXHPd/o4nW+2XmoU2y5o4c9Z+OZ/eWXa5I5oU1vmOFZpqH 4GA7wpvy7UA18VO6WL/PRat0D57U3V4yc6FKT4/H8+CGPbYnBD4izXQu5gkwndKyjdHWaAPCsCN 8gZK2jXWVIzC+Illm1Hs7+00fYlSxvV5r3h7WSaDdKagAKD2RJy4CGebpH9lXvowfKbGiZ3OUJs tstNN8qOHCY3FzOjo0b8rOr1n6EZ5xoqJGptP2kVMPDH1CeAAczwefJ6GutR409M1G7JoiR2by2 iQeU/iwW800j7JhR3bQ/COe2412c0nXiSW4DH/ShPHQ7OPWWz8EGl9jyL1WqAqfNASkgn8ej/J8 +kJChSuWajgpCOR63MCe5hFdBwxM2JwCcIlw4sLAa5elIrKZ1I1X456Qi/DKq0SUMYQsfDOsiGp owLQZIA1D7TpAs= X-Received: by 2002:ad4:5de1:0:b0:894:6e23:3c3f with SMTP id 6a1803df08f44-894cc81e09amr106899066d6.20.1769637215910; Wed, 28 Jan 2026 13:53:35 -0800 (PST) Received: from fauth-a1-smtp.messagingengine.com (fauth-a1-smtp.messagingengine.com. [103.168.172.200]) by smtp.gmail.com with ESMTPSA id 6a1803df08f44-894d3740f6dsm25243756d6.37.2026.01.28.13.53.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Jan 2026 13:53:35 -0800 (PST) Received: from phl-compute-07.internal (phl-compute-07.internal [10.202.2.47]) by mailfauth.phl.internal (Postfix) with ESMTP id A8058F4006D; Wed, 28 Jan 2026 16:53:34 -0500 (EST) Received: from phl-frontend-04 ([10.202.2.163]) by phl-compute-07.internal (MEProxy); Wed, 28 Jan 2026 16:53:34 -0500 X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgdduieeggeehucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmnecujf gurhephffvvefufffkofgjfhgggfestdekredtredttdenucfhrhhomhepuehoqhhunhcu hfgvnhhguceosghoqhhunhdrfhgvnhhgsehgmhgrihhlrdgtohhmqeenucggtffrrghtth gvrhhnpefhkeetffffleefffelueduhfeufedtffdvuedtkeejhfeivdelkedvffejvdeu keenucffohhmrghinhepphgrthhhrdhishenucevlhhushhtvghrufhiiigvpedtnecurf grrhgrmhepmhgrihhlfhhrohhmpegsohhquhhnodhmvghsmhhtphgruhhthhhpvghrshho nhgrlhhithihqdeiledvgeehtdeigedqudejjeekheehhedvqdgsohhquhhnrdhfvghngh eppehgmhgrihhlrdgtohhmsehfihigmhgvrdhnrghmvgdpnhgspghrtghpthhtohepgedv pdhmohguvgepshhmthhpohhuthdprhgtphhtthhopehlihhnuhigqdhkvghrnhgvlhesvh hgvghrrdhkvghrnhgvlhdrohhrghdprhgtphhtthhopehruhhsthdqfhhorhdqlhhinhhu giesvhhgvghrrdhkvghrnhgvlhdrohhrghdprhgtphhtthhopehrtghusehvghgvrhdrkh gvrhhnvghlrdhorhhgpdhrtghpthhtohepghhrvghgkhhhsehlihhnuhigfhhouhhnuggr thhiohhnrdhorhhgpdhrtghpthhtoheprghrvhgvsegrnhgurhhoihgurdgtohhmpdhrtg hpthhtohepthhkjhhoshesrghnughrohhiugdrtghomhdprhgtphhtthhopegsrhgruhhn vghrsehkvghrnhgvlhdrohhrghdprhgtphhtthhopegtmhhllhgrmhgrshesghhoohhglh gvrdgtohhmpdhrtghpthhtoheprghlihgtvghrhihhlhesghhoohhglhgvrdgtohhm X-ME-Proxy: Feedback-ID: iad51458e:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Wed, 28 Jan 2026 16:53:34 -0500 (EST) From: Boqun Feng To: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, rcu@vger.kernel.org Cc: Greg Kroah-Hartman , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Todd Kjos , Christian Brauner , Carlos Llamas , Alice Ryhl , Miguel Ojeda , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Trevor Gross , Danilo Krummrich , "Paul E. McKenney" , Frederic Weisbecker , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Uladzislau Rezki , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang , FUJITA Tomonori , Lyude Paul , Thomas Gleixner , Anna-Maria Behnsen , John Stultz , Stephen Boyd , "Yury Norov (NVIDIA)" , Vitaly Wool , Tamir Duberstein , Viresh Kumar , Daniel Almeida , Mitchell Levy , David Gow , Peter Novak , =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= Subject: [RFC PATCH 1/7] rust: types: Introduce HasField trait and derive macro Date: Wed, 28 Jan 2026 13:53:24 -0800 Message-ID: <20260128215330.58410-2-boqun.feng@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260128215330.58410-1-boqun.feng@gmail.com> References: <20260128215330.58410-1-boqun.feng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In order to unify all the `Has*` infrastrutures, a generic `HasField` trait is added along with a derive macro `#[derive(HasField)]` which allows generate implementation of `HasField` automatically, e.g. #[derive(HasField)] struct Base { a: i32; b: i32; #[field] f1: Field, #[field] f2: Field, } two implementations `impl HasField>` and `impl HasField>` will be generated with `&raw mut` and `container_of!()`. This simplifies the usage of the current `Has*` traits, namely `HasWork` and `HasHrTimer`, and eases the introduction of more `Field` type in the future. Signed-off-by: Boqun Feng --- rust/kernel/field.rs | 73 ++++++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 1 + rust/kernel/prelude.rs | 4 +- rust/macros/field.rs | 85 ++++++++++++++++++++++++++++++++++++++++++ rust/macros/lib.rs | 11 ++++++ 5 files changed, 173 insertions(+), 1 deletion(-) create mode 100644 rust/kernel/field.rs create mode 100644 rust/macros/field.rs diff --git a/rust/kernel/field.rs b/rust/kernel/field.rs new file mode 100644 index 000000000000..347387731d71 --- /dev/null +++ b/rust/kernel/field.rs @@ -0,0 +1,73 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Field types to describe a field inside a struct. + +/// A field. +/// +/// The generic type `T` is usually the type that contains the field. For = some field types, it +/// needs to be generic over the type containing it, because it needs to b= e initialized with +/// container-type-specific callbacks. For other types, simply implement [= `Field`] for all `T` +/// to indicate there is no restriction. +pub trait Field: Sized {} + +/// A struct `T` that has a field `F`. +/// +/// # Safety +/// +/// The methods [`raw_get_field()`] and [`field_container_of()`] must retu= rn valid pointers and +/// must be true inverses of each other; that is, they must satisfy the fo= llowing invariants: - +/// `field_container_of(raw_get_field(ptr)) =3D=3D ptr` for any `ptr: *mut= Self`. - +/// `raw_get_field(field_container_of(ptr)) =3D=3D ptr` for any `ptr: *mut= Field`. +/// +/// Use [`macros::HasField`] to generate the impls automatically. +/// +/// # Examples +/// +/// ``` +/// # use core::marker::PhantomData; +/// use kernel::{ +/// macros::HasField, +/// field::{ +/// Field, +/// HasField, // +/// }, // +/// }; +/// +/// struct Work { +/// _x: isize, +/// _inner: PhantomData, +/// } +/// +/// // Declare that `Work` is a `Field`. +/// impl Field for Work {} +/// +/// #[derive(HasField)] +/// struct B { +/// #[field] +/// w: Work, +/// a: i32, +/// } +/// +/// const _: () =3D { +/// const fn assert_has_field>>() { } +/// assert_has_field::(); +/// }; +/// ``` +/// +/// [`raw_get_field()`]: HasField::raw_get_field +/// [`field_container_of()`]: HasField::field_container_of +pub unsafe trait HasField> { + /// Returns a pointer to the [`Field`] field. + /// + /// # Safety + /// + /// The provided pointer must point at a valid struct of type `Self`. + unsafe fn raw_get_field(ptr: *mut Self) -> *mut F; + + /// Returns a pointer to the struct containing [`Field`] field. + /// + /// # Safety + /// + /// The pointer must point at a [`Field`] field in a struct of type= `Self`. + unsafe fn field_container_of(ptr: *mut F) -> *mut Self; +} diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index f812cf120042..36259aac1843 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -93,6 +93,7 @@ pub mod drm; pub mod error; pub mod faux; +pub mod field; #[cfg(CONFIG_RUST_FW_LOADER_ABSTRACTIONS)] pub mod firmware; pub mod fmt; diff --git a/rust/kernel/prelude.rs b/rust/kernel/prelude.rs index 2877e3f7b6d3..3668ef42046b 100644 --- a/rust/kernel/prelude.rs +++ b/rust/kernel/prelude.rs @@ -25,10 +25,12 @@ pub use crate::alloc::{flags::*, Box, KBox, KVBox, KVVec, KVec, VBox, VVec= , Vec}; =20 #[doc(no_inline)] -pub use macros::{export, fmt, kunit_tests, module, vtable}; +pub use macros::{export, fmt, kunit_tests, module, vtable, HasField}; =20 pub use pin_init::{init, pin_data, pin_init, pinned_drop, InPlaceWrite, In= it, PinInit, Zeroable}; =20 +pub use super::field::{Field, HasField}; + pub use super::{build_assert, build_error}; =20 // `super::std_vendor` is hidden, which makes the macro inline for some re= ason. diff --git a/rust/macros/field.rs b/rust/macros/field.rs new file mode 100644 index 000000000000..3d32e5089f27 --- /dev/null +++ b/rust/macros/field.rs @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: GPL-2.0 + +use proc_macro2::{Span, TokenStream}; +use quote::quote; +use syn::{ + spanned::Spanned, Data, DataStruct, DeriveInput, Error, Fields, Generi= cs, Ident, Result, Type, +}; + +fn impl_has_field(base: &Ident, field: &Ident, ty: &Type, generics: &Gener= ics) -> TokenStream { + let (impl_generics, type_generics, where_clause) =3D generics.split_fo= r_impl(); + + quote!( + // SAFETY: The implementation of `raw_get_field()` only compiles i= f the field has the + // right type. + unsafe impl #impl_generics + HasField<#base #type_generics, #ty> + for #base #type_generics + #where_clause { + #[inline(always)] + unsafe fn raw_get_field(ptr: *mut Self) -> *mut #ty { + // SAFETY: Per function safety requirement, the pointer is= valid. + unsafe { &raw mut (*ptr).#field } + } + + #[inline(always)] + unsafe fn field_container_of(ptr: *mut #ty) -> *mut Self { + // SAFETY: Per function safety requirement, the pointer is= valid, and it points + // to the right field of the struct. + unsafe { kernel::container_of!(ptr, Self, #field) } + } + } + ) +} +fn handle_struct( + ident: &Ident, + generics: &Generics, + st: &DataStruct, + span: Span, +) -> Result { + let mut impls =3D vec![]; + + if let Fields::Named(fields) =3D &st.fields { + for field in &fields.named { + let found =3D field + .attrs + .iter() + .find(|attr| attr.path().is_ident("field")); + + if found.is_some() { + if let Some(name) =3D &field.ident { + impls.push(impl_has_field(ident, name, &field.ty, gene= rics)); + } + } + } + + Ok(quote!( + #(#impls)* + )) + } else { + Err(Error::new( + span, + "`#[derive(HasField)]` only supports structs with named fields= ", + )) + } +} + +pub(crate) fn has_field(input: DeriveInput) -> Result { + let span =3D input.span(); + let data =3D &input.data; + let ident =3D &input.ident; + let generics =3D &input.generics; + + if let Data::Struct(st) =3D data { + let impls =3D handle_struct(ident, generics, st, span)?; + + Ok(quote!( + #impls + )) + } else { + Err(Error::new_spanned( + input, + "`#[derive(HasField)]` only supports structs", + )) + } +} diff --git a/rust/macros/lib.rs b/rust/macros/lib.rs index 85b7938c08e5..4fccca0e11af 100644 --- a/rust/macros/lib.rs +++ b/rust/macros/lib.rs @@ -13,6 +13,7 @@ =20 mod concat_idents; mod export; +mod field; mod fmt; mod helpers; mod kunit; @@ -486,3 +487,13 @@ pub fn kunit_tests(attr: TokenStream, input: TokenStre= am) -> TokenStream { .unwrap_or_else(|e| e.into_compile_error()) .into() } + +/// Derives the implementation for `HasField`. +/// +/// See the documentation of `HasField` for more information. +#[proc_macro_derive(HasField, attributes(field))] +pub fn has_field(input: TokenStream) -> TokenStream { + field::has_field(parse_macro_input!(input)) + .unwrap_or_else(|e| e.into_compile_error()) + .into() +} --=20 2.50.1 (Apple Git-155) From nobody Sat Feb 7 17:04:36 2026 Received: from mail-pl1-f179.google.com (mail-pl1-f179.google.com [209.85.214.179]) (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 B07281531C1 for ; Wed, 28 Jan 2026 23:42:52 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643774; cv=none; b=BZXnnRRSEE6WrqziXkfV8JaWjym1hKGnuOXPZVM2yHWtqrh0VZVf/Llp0T0w7RFhDgrvrCXB9mVKbBs9FLTOF6soT/oG+537rhiEVPHfWrKbolDbQlDJjIwwQIW+8oRwyjCGEim+X+H2V7KJxAImk33H4ZAAV08BJCPv+61fRIU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643774; c=relaxed/simple; bh=OUnhhLpw0G4jfOUrV0sIe5rYFeDBYm/rgYAQew5ALOE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rP0XqjJCWV/ipiaFmb4I8He3NoRzGku0k3wqXiz7wMErsz5En70fBI8BoEKsm9H7ij9e4eRuHjbNaPXxkLA4MnHZ9i3cwqXjf5EEnlHcxn2zwJ1Q4Qk87Fef+CwvNaANnNGV5dW4SbfiV03VH5/rje18LrNRmSmENLIctLRXAWg= 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=AbAp+qlA; arc=none smtp.client-ip=209.85.214.179 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="AbAp+qlA" Received: by mail-pl1-f179.google.com with SMTP id d9443c01a7336-2a743050256so1852175ad.3 for ; Wed, 28 Jan 2026 15:42:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769643772; x=1770248572; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:from:to:cc:subject :date:message-id:reply-to; bh=ZwleCKT0WC1y4r31KovKxSZY4leqC3/LnghDg5OFIfc=; b=AbAp+qlAItQzE/RpQxbexcqVGThucphcw8KAclwxE9mDG6nG3IWbY1suER+Lxv0L4W fnEDiDs/2Q3JfpcSc6l1xbMxQrcnFojJXoR6aVDtay95y6iPhLx4Vpc6XZZIVzOJ0BFf FqqeuInLBKv9s8Ahw5WAHTPJDkwVTROZ5vbgXtjiCxLYomHNhdi7sURodo8KmeqmAQnq z5l6Tm9mxlPTLF+xaHGd2PKcZI109K7hnRxAvYP5DwVgP4dMXGn9sNtnJUq5uCh10Al0 sc+e4gK6NOwLrp+3Znsy21lLZOZlEzcdj4NHpotbnNZv24O0WdNGngUJC6yysr9HN61h 7Gsg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769643772; x=1770248572; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=ZwleCKT0WC1y4r31KovKxSZY4leqC3/LnghDg5OFIfc=; b=Z/0UaR+OXMsB8VnhKD7FBeh3ue9lrW9Uw33NkcFuPHgG2w8fKV3IEsIiBIFW7F7F0O ZIsl8nPXnaMEWykxYAz61AsGZjT9vt4temJVJfkHtfNji6ZB5EjtMLEadHpSW6vsijqT FG8slTxfHE2tkdO3IP1KcDc5jj3sE8pJ/Q32/rEWpZgschTsV53Ah5Imfm/AvFYH1VqP hMZzhfCJPGJFPQj1dWVXFxxX9QjKHer/BM5qH7g/e1Uw8/8jzQlTHPjGPem5WPdBNwLY LAURijb2GnlwXwnXQJGXmr7xRLihfPblCvapR9EnFUAYrnpTSSC7KNXy+vcQccyivRJ/ /mBg== X-Gm-Message-State: AOJu0YwnN2sTofGzugikpMPsXDaO/wSzotvWUzeJB3nIDC0YVBPtoP2O n0SJtKkBFtqhG1oxdtya/UzkOlvVVDTbfrXvLLt+uqSS2NBn4yNhUrKII5sn4g== X-Gm-Gg: AZuq6aLpFHsuIzCZ04CcxG1PjjolGizBZXdJ7ojABDd6/5wEvNfmmO1gPVBoYdptdbA iBF4t0AiEHu1qlVYCXYHEKiLxoxBW6ofDLgwUSQDqrN7tvoZRuP1HfGbYDE25PXltAoa+dumf+o obafN96Pg6uzmLVrlc5DFCgQIlA6m9z1sAKmkraQqQvI2K+8NJ3yBcsa02p1YnUqMCM0/lrKLfI MWXpBIsg37dUzS9zZuacRwX619q4cTl5K504Z7oksNnOD933jwATPmBmvUCwrPmvhGK5qaH8Cnx hNWPo5ToDhR0E1/+YmEPguazz/95bfXUhuieqzeh2+sbgKYLS2CqSR4onsKORlFT6D5zCOC/zIj ldnAcdZGWbRf2jWLZdOWP9i7g32jFK1VnrRFXpHAfbLMIl8Umou1Ujcw+FVqP+IH5ZhyKh0l/66 cGSd2uGzQDkFn5BRR9JKypV8jt1xkeWxyhNZoIDlXSYl1/H+FfAJBkqfN+qXE+78aM9mLbfACWF dqfiXt7ou+BG1c= X-Received: by 2002:ad4:5f0f:0:b0:888:3d1e:f95 with SMTP id 6a1803df08f44-894cc8c97dbmr102202586d6.32.1769637217348; Wed, 28 Jan 2026 13:53:37 -0800 (PST) Received: from fauth-a1-smtp.messagingengine.com (fauth-a1-smtp.messagingengine.com. [103.168.172.200]) by smtp.gmail.com with ESMTPSA id 6a1803df08f44-894d373fe92sm25727956d6.32.2026.01.28.13.53.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Jan 2026 13:53:37 -0800 (PST) Received: from phl-compute-07.internal (phl-compute-07.internal [10.202.2.47]) by mailfauth.phl.internal (Postfix) with ESMTP id 28E16F4006C; Wed, 28 Jan 2026 16:53:36 -0500 (EST) Received: from phl-frontend-03 ([10.202.2.162]) by phl-compute-07.internal (MEProxy); Wed, 28 Jan 2026 16:53:36 -0500 X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgdduieeggeehucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmnecujf gurhephffvvefufffkofgjfhgggfestdekredtredttdenucfhrhhomhepuehoqhhunhcu hfgvnhhguceosghoqhhunhdrfhgvnhhgsehgmhgrihhlrdgtohhmqeenucggtffrrghtth gvrhhnpeegleejiedthedvheeggfejveefjeejkefgveffieeujefhueeigfegueehgeeg gfenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpegsoh hquhhnodhmvghsmhhtphgruhhthhhpvghrshhonhgrlhhithihqdeiledvgeehtdeigedq udejjeekheehhedvqdgsohhquhhnrdhfvghngheppehgmhgrihhlrdgtohhmsehfihigmh gvrdhnrghmvgdpnhgspghrtghpthhtohepgedvpdhmohguvgepshhmthhpohhuthdprhgt phhtthhopehlihhnuhigqdhkvghrnhgvlhesvhhgvghrrdhkvghrnhgvlhdrohhrghdprh gtphhtthhopehruhhsthdqfhhorhdqlhhinhhugiesvhhgvghrrdhkvghrnhgvlhdrohhr ghdprhgtphhtthhopehrtghusehvghgvrhdrkhgvrhhnvghlrdhorhhgpdhrtghpthhtoh epghhrvghgkhhhsehlihhnuhigfhhouhhnuggrthhiohhnrdhorhhgpdhrtghpthhtohep rghrvhgvsegrnhgurhhoihgurdgtohhmpdhrtghpthhtohepthhkjhhoshesrghnughroh hiugdrtghomhdprhgtphhtthhopegsrhgruhhnvghrsehkvghrnhgvlhdrohhrghdprhgt phhtthhopegtmhhllhgrmhgrshesghhoohhglhgvrdgtohhmpdhrtghpthhtoheprghlih gtvghrhihhlhesghhoohhglhgvrdgtohhm X-ME-Proxy: Feedback-ID: iad51458e:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Wed, 28 Jan 2026 16:53:35 -0500 (EST) From: Boqun Feng To: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, rcu@vger.kernel.org Cc: Greg Kroah-Hartman , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Todd Kjos , Christian Brauner , Carlos Llamas , Alice Ryhl , Miguel Ojeda , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Trevor Gross , Danilo Krummrich , "Paul E. McKenney" , Frederic Weisbecker , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Uladzislau Rezki , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang , FUJITA Tomonori , Lyude Paul , Thomas Gleixner , Anna-Maria Behnsen , John Stultz , Stephen Boyd , "Yury Norov (NVIDIA)" , Vitaly Wool , Tamir Duberstein , Viresh Kumar , Daniel Almeida , Mitchell Levy , David Gow , Peter Novak , =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= Subject: [RFC PATCH 2/7] rust: time: hrtimer: Make `HasField` a super-trait of `HasHrTimer` Date: Wed, 28 Jan 2026 13:53:25 -0800 Message-ID: <20260128215330.58410-3-boqun.feng@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260128215330.58410-1-boqun.feng@gmail.com> References: <20260128215330.58410-1-boqun.feng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This decouples the hrtimer mode part from the `HasField` part of a `HasHrTimer`, `impl_has_hr_timer` also gets removed, as we can do: #[has_field] #[pin] struct MyStruct { a: i32, #[field] timer: HrTimer, } impl HasHrTimer for MyStruct { type TimerMode =3D ...; } Signed-off-by: Boqun Feng --- rust/kernel/time/hrtimer.rs | 70 ++++++++----------------------------- 1 file changed, 15 insertions(+), 55 deletions(-) diff --git a/rust/kernel/time/hrtimer.rs b/rust/kernel/time/hrtimer.rs index 856d2d929a00..eef6d60f5adb 100644 --- a/rust/kernel/time/hrtimer.rs +++ b/rust/kernel/time/hrtimer.rs @@ -98,6 +98,8 @@ unsafe impl Send for HrTimer {} // on a timer from multiple threads. unsafe impl Sync for HrTimer {} =20 +impl Field for HrTimer {} + impl HrTimer { /// Return an initializer for a new timer instance. pub fn new() -> impl PinInit @@ -417,17 +419,7 @@ pub unsafe trait HrTimerHandle { } =20 /// Implemented by structs that contain timer nodes. -/// -/// Clients of the timer API would usually safely implement this trait by = using -/// the [`crate::impl_has_hr_timer`] macro. -/// -/// # Safety -/// -/// Implementers of this trait must ensure that the implementer has a -/// [`HrTimer`] field and that all trait methods are implemented according= to -/// their documentation. All the methods of this trait must operate on the= same -/// field. -pub unsafe trait HasHrTimer { +pub trait HasHrTimer: HasField> { /// The operational mode associated with this timer. /// /// This defines how the expiration value is interpreted. @@ -441,7 +433,11 @@ pub unsafe trait HasHrTimer { /// # Safety /// /// `this` must be a valid pointer. - unsafe fn raw_get_timer(this: *const Self) -> *const HrTimer; + #[inline] + unsafe fn raw_get_timer(this: *const Self) -> *const HrTimer { + // SAFETY: Per function safety requirement, `this` is a valid poin= ter. + unsafe { >::raw_get_field(this.cast_mut()) = }.cast_const() + } =20 /// Return a pointer to the struct that is containing the [`HrTimer`] = pointed /// to by `ptr`. @@ -452,9 +448,15 @@ pub unsafe trait HasHrTimer { /// # Safety /// /// `ptr` must point to a [`HrTimer`] field in a struct of type `Se= lf`. + #[inline] unsafe fn timer_container_of(ptr: *mut HrTimer) -> *mut Self where - Self: Sized; + Self: Sized, + { + // SAFETY: Per function safety requirement, `ptr` is a valid point= er and points to a + // `HrTimer` field in a struct. + unsafe { >::field_container_of(ptr) } + } =20 /// Get pointer to the contained `bindings::hrtimer` struct. /// @@ -731,48 +733,6 @@ pub fn forward_now(&mut self, duration: Delta) -> u64 { } } =20 -/// Use to implement the [`HasHrTimer`] trait. -/// -/// See [`module`] documentation for an example. -/// -/// [`module`]: crate::time::hrtimer -#[macro_export] -macro_rules! impl_has_hr_timer { - ( - impl$({$($generics:tt)*})? - HasHrTimer<$timer_type:ty> - for $self:ty - { - mode : $mode:ty, - field : self.$field:ident $(,)? - } - $($rest:tt)* - ) =3D> { - // SAFETY: This implementation of `raw_get_timer` only compiles if= the - // field has the right type. - unsafe impl$(<$($generics)*>)? $crate::time::hrtimer::HasHrTimer<$= timer_type> for $self { - type TimerMode =3D $mode; - - #[inline] - unsafe fn raw_get_timer( - this: *const Self, - ) -> *const $crate::time::hrtimer::HrTimer<$timer_type> { - // SAFETY: The caller promises that the pointer is not dan= gling. - unsafe { ::core::ptr::addr_of!((*this).$field) } - } - - #[inline] - unsafe fn timer_container_of( - ptr: *mut $crate::time::hrtimer::HrTimer<$timer_type>, - ) -> *mut Self { - // SAFETY: As per the safety requirement of this function,= `ptr` - // is pointing inside a `$timer_type`. - unsafe { ::kernel::container_of!(ptr, $timer_type, $field)= } - } - } - } -} - mod arc; pub use arc::ArcHrTimerHandle; mod pin; --=20 2.50.1 (Apple Git-155) From nobody Sat Feb 7 17:04:36 2026 Received: from mail-pf1-f177.google.com (mail-pf1-f177.google.com [209.85.210.177]) (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 D99E61531C1 for ; Wed, 28 Jan 2026 23:41:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643717; cv=none; b=hGa4aoJ99nMez8O+PjEkuSj+sbGgtGwpvJaVN/VXXGkrQcoFU9LPQBEdujndhoO+jZaNti08VNgBqkJg86apjXFYBNtX7GmrEqy36KOQBAyyLRPh2xC7J3PcORkWhcPmXKsmqemC/5o5CRIbVeSoRpGf1Ih8x7WYGl7aNDhpU9E= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643717; c=relaxed/simple; bh=x68kyFMcXCVl2ap3eh7O4CQGneM+mz/6DOkFyCpzqd0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=nNv4UgBccjv0FzWxnB4YV8dPKyaC2gC3/j6t9k4lMu3G4gWf6+uhZ70+VxElnkflgf1RsV85LcBkApo4XjMlM8AbhHRxqyjhYLdizH9Po0oAeHN2wemUo6g6FYkAkJyKiaUHJvwdDFb+dDdH3jhPYJjecWgwH4MiysTaKEn1O4k= 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=B3wDNKeI; arc=none smtp.client-ip=209.85.210.177 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="B3wDNKeI" Received: by mail-pf1-f177.google.com with SMTP id d2e1a72fcca58-81c72659e6bso335621b3a.0 for ; Wed, 28 Jan 2026 15:41:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769643715; x=1770248515; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:from:to:cc:subject :date:message-id:reply-to; bh=Kr5A9uFY8WKbxdwaztWr2I99L6qNUiDvl4AMlkp9MKU=; b=B3wDNKeIykeC7PrdyY6sJhCSu/rO/mUSL+FG/mots3HWo611aiPvX/S4aMWs1OY0EY 7Lm8ANIPdY5WP9nZo4DLLZ34c/nb16UZunobaZ5o0Qg23jusBsqIQiml2fqteYC/N/Pl ItySVLt03m0+NQqKAEj4FZbcQaTLDWoGfYO4U6ytgERkDe97bG5Q948JUGi3vu+jLN0u WZ78Tsw8KxnltiFBfCD8p2z7GIxv7f4vUSM/ssubckSFnE+iOEuTPpJTI91dBKkm8zAe lX816g4eYBRD4LyziagrZKB5IxUCxPj7qKpwVBInrfG7A0TUWnH2oIsDg9Z4vK7GzNA2 +MuA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769643715; x=1770248515; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=Kr5A9uFY8WKbxdwaztWr2I99L6qNUiDvl4AMlkp9MKU=; b=q7srYlRat9cLgPD7G1UcVtARATnGkATpbJWTSnHGI2plGhDqQzqBRafa1dEwr02GBY Oo1+22OfJ2HvBlVpcgBq9xrKslDxMSZ9O2ztgZxi7TjInHCRg4W8TV/R5pfQ4hBBVAA+ 25jZYYlYALAwbTRg3bl1hvEMpHm/7AlPwEK654oNmf0no/VRIDhRaou69TfGpuCCuI9F tCJMhCAWWUGAbvE9h5N6ZiW3nxpGu/lDMAYrN8d7HMv6C2Eqk1OpLs0bAS+s+CxyMSBG rMagzKVHgIC13tkHizRIPA9kWJr4JwHesO3O/t3h5X80sAfmvYd+7/4Ri8HikZPkfCxZ 8HhQ== X-Gm-Message-State: AOJu0Yzig6Wu8xUzH/lnBXQ88YcBepB4gMEGzLE1YsXyAOQ63kAABA0r e9G1O7FGTsZV8u8GkgSDV4sjZ38fGHz3arznajAL0Ts0KOoqT1TVpSk5cimNIw== X-Gm-Gg: AZuq6aL7MGkYSY8UYH7xHzf7c0GJxiCXeq1gczdYdFgHXlswgK6sRiRpTY9JyV+7nZm +Q67S/TIEtxadu9IX6ys8/mCqPCbbSRmZai421dtUaZA06l8DydhBiKK8+Q6JMcVhmxJsqCk/5K zHmwq1wi34DAGwo7GyQnAHHcsE3ImfOVSQEUYAyVnnhFd3dmNhsRSTj2SD9kPLpHoq59SiYK/eL KYvQVKUPCio0yuDlty4MImV13pAitPYzm6UXgzPQbp8OAaB5w/G56ZKBhNX5brN6lnkJ8MN71iL nwacXgPnGVawtPxVxXV0M2Oh0kT+XaVKE39BVe2vE9vRL4PjPr4eg2EleAV7giM0HBkYVWjxYIJ qOHz3UenePcRU+c2AhjMcx5YjGESoblHltDLahEUvPeKTSX2O0RCnFRX+so0NWpRvihuC7VHJO4 VE250N9uZdZUfV8MtpZl1mICi66+uWYqVyMjvEvPDWNYW2zaEpTsd1h71xLGr8INXrulUbqN9UF HmRbeLmW/ie5FM= X-Received: by 2002:a05:620a:d81:b0:8c5:310d:3b3a with SMTP id af79cd13be357-8c70b8f6964mr868040985a.70.1769637219381; Wed, 28 Jan 2026 13:53:39 -0800 (PST) Received: from fauth-a1-smtp.messagingengine.com (fauth-a1-smtp.messagingengine.com. [103.168.172.200]) by smtp.gmail.com with ESMTPSA id af79cd13be357-8c711d61c6fsm263878285a.47.2026.01.28.13.53.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Jan 2026 13:53:38 -0800 (PST) Received: from phl-compute-03.internal (phl-compute-03.internal [10.202.2.43]) by mailfauth.phl.internal (Postfix) with ESMTP id 09698F4006C; Wed, 28 Jan 2026 16:53:38 -0500 (EST) Received: from phl-frontend-03 ([10.202.2.162]) by phl-compute-03.internal (MEProxy); Wed, 28 Jan 2026 16:53:38 -0500 X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgdduieeggeehucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmnecujf gurhephffvvefufffkofgjfhgggfestdekredtredttdenucfhrhhomhepuehoqhhunhcu hfgvnhhguceosghoqhhunhdrfhgvnhhgsehgmhgrihhlrdgtohhmqeenucggtffrrghtth gvrhhnpeegleejiedthedvheeggfejveefjeejkefgveffieeujefhueeigfegueehgeeg gfenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpegsoh hquhhnodhmvghsmhhtphgruhhthhhpvghrshhonhgrlhhithihqdeiledvgeehtdeigedq udejjeekheehhedvqdgsohhquhhnrdhfvghngheppehgmhgrihhlrdgtohhmsehfihigmh gvrdhnrghmvgdpnhgspghrtghpthhtohepgedvpdhmohguvgepshhmthhpohhuthdprhgt phhtthhopehlihhnuhigqdhkvghrnhgvlhesvhhgvghrrdhkvghrnhgvlhdrohhrghdprh gtphhtthhopehruhhsthdqfhhorhdqlhhinhhugiesvhhgvghrrdhkvghrnhgvlhdrohhr ghdprhgtphhtthhopehrtghusehvghgvrhdrkhgvrhhnvghlrdhorhhgpdhrtghpthhtoh epghhrvghgkhhhsehlihhnuhigfhhouhhnuggrthhiohhnrdhorhhgpdhrtghpthhtohep rghrvhgvsegrnhgurhhoihgurdgtohhmpdhrtghpthhtohepthhkjhhoshesrghnughroh hiugdrtghomhdprhgtphhtthhopegsrhgruhhnvghrsehkvghrnhgvlhdrohhrghdprhgt phhtthhopegtmhhllhgrmhgrshesghhoohhglhgvrdgtohhmpdhrtghpthhtoheprghlih gtvghrhihhlhesghhoohhglhgvrdgtohhm X-ME-Proxy: Feedback-ID: iad51458e:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Wed, 28 Jan 2026 16:53:37 -0500 (EST) From: Boqun Feng To: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, rcu@vger.kernel.org Cc: Greg Kroah-Hartman , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Todd Kjos , Christian Brauner , Carlos Llamas , Alice Ryhl , Miguel Ojeda , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Trevor Gross , Danilo Krummrich , "Paul E. McKenney" , Frederic Weisbecker , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Uladzislau Rezki , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang , FUJITA Tomonori , Lyude Paul , Thomas Gleixner , Anna-Maria Behnsen , John Stultz , Stephen Boyd , "Yury Norov (NVIDIA)" , Vitaly Wool , Tamir Duberstein , Viresh Kumar , Daniel Almeida , Mitchell Levy , David Gow , Peter Novak , =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= Subject: [RFC PATCH 3/7] rust: workqueue: Add HasField support for Work Date: Wed, 28 Jan 2026 13:53:26 -0800 Message-ID: <20260128215330.58410-4-boqun.feng@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260128215330.58410-1-boqun.feng@gmail.com> References: <20260128215330.58410-1-boqun.feng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Implement `HasWork` via `HasField` so that manually impl_has_work!() is no longer needed. Signed-off-by: Boqun Feng --- rust/kernel/workqueue.rs | 60 +++++++++++++++++++++++++--------------- 1 file changed, 38 insertions(+), 22 deletions(-) diff --git a/rust/kernel/workqueue.rs b/rust/kernel/workqueue.rs index 706e833e9702..2dcfd3eace39 100644 --- a/rust/kernel/workqueue.rs +++ b/rust/kernel/workqueue.rs @@ -34,19 +34,17 @@ //! //! ``` //! use kernel::sync::Arc; -//! use kernel::workqueue::{self, impl_has_work, new_work, Work, WorkItem}; +//! use kernel::workqueue::{self, new_work, Work, WorkItem}; //! +//! #[derive(HasField)] //! #[pin_data] //! struct MyStruct { //! value: i32, //! #[pin] +//! #[field] //! work: Work, //! } //! -//! impl_has_work! { -//! impl HasWork for MyStruct { self.work } -//! } -//! //! impl MyStruct { //! fn new(value: i32) -> Result> { //! Arc::pin_init(pin_init!(MyStruct { @@ -76,23 +74,21 @@ //! //! ``` //! use kernel::sync::Arc; -//! use kernel::workqueue::{self, impl_has_work, new_work, Work, WorkItem}; +//! use kernel::workqueue::{self, new_work, Work, WorkItem}; //! +//! #[derive(HasField)] //! #[pin_data] //! struct MyStruct { //! value_1: i32, //! value_2: i32, //! #[pin] +//! #[field] //! work_1: Work, //! #[pin] +//! #[field] //! work_2: Work, //! } //! -//! impl_has_work! { -//! impl HasWork for MyStruct { self.work_1 } -//! impl HasWork for MyStruct { self.work_2 } -//! } -//! //! impl MyStruct { //! fn new(value_1: i32, value_2: i32) -> Result> { //! Arc::pin_init(pin_init!(MyStruct { @@ -188,6 +184,11 @@ use crate::{ alloc::{AllocError, Flags}, container_of, + field::{ + Field, + HasField, // + }, + macros::HasField, prelude::*, sync::Arc, sync::LockClassKey, @@ -349,9 +350,11 @@ pub fn try_spawn( /// A helper type used in [`try_spawn`]. /// /// [`try_spawn`]: Queue::try_spawn +#[derive(HasField)] #[pin_data] struct ClosureWork { #[pin] + #[field] work: Work>, func: Option, } @@ -534,19 +537,17 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindi= ngs::work_struct { =20 /// Declares that a type contains a [`Work`]. /// -/// The intended way of using this trait is via the [`impl_has_work!`] mac= ro. You can use the macro -/// like this: +/// The intended way of using this trait is via the `#[derive(HasField)]` = macro. You can use the +/// macro like this: /// -/// ```no_run -/// use kernel::workqueue::{impl_has_work, Work}; +/// ``` +/// use kernel::workqueue::Work; /// +/// #[derive(HasField)] /// struct MyWorkItem { +/// #[field] /// work_field: Work, /// } -/// -/// impl_has_work! { -/// impl HasWork for MyWorkItem { self.work_field } -/// } /// ``` /// /// Note that since the [`Work`] type is annotated with an id, you can hav= e several `work_struct` @@ -559,7 +560,6 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut binding= s::work_struct { /// - `work_container_of(raw_get_work(ptr)) =3D=3D ptr` for any `ptr: *mut= Self`. /// - `raw_get_work(work_container_of(ptr)) =3D=3D ptr` for any `ptr: *mut= Work`. /// -/// [`impl_has_work!`]: crate::impl_has_work /// [`raw_get_work`]: HasWork::raw_get_work /// [`work_container_of`]: HasWork::work_container_of pub unsafe trait HasWork { @@ -627,8 +627,24 @@ unsafe fn work_container_of( } pub use impl_has_work; =20 -impl_has_work! { - impl{T} HasWork for ClosureWork { self.work } +impl Field for Work {} + +/// SAFETY: Per the safety requirement of `HasField`, `raw_get_field()` an= d `field_container_of()` +/// return valid pointers and are true inverses of each other, hence the i= mplementation below +/// fulfills `HasWork`'s safety requirement as well. +unsafe impl>, const ID: u64> HasWork for= T { + #[inline] + unsafe fn raw_get_work(ptr: *mut Self) -> *mut Work { + // SAFETY: Per the function safety requirement, `ptr` is a valid p= ointer. + unsafe { >>::raw_get_field(ptr) } + } + + #[inline] + unsafe fn work_container_of(ptr: *mut Work) -> *mut Self { + // SAFETY: Per the function safety requirement, `ptr` is a valid p= ointer, and it points to + // a work field in struct `T`. + unsafe { >>::field_container_of(ptr) } + } } =20 /// Links for a delayed work item. --=20 2.50.1 (Apple Git-155) From nobody Sat Feb 7 17:04:36 2026 Received: from mail-ot1-f54.google.com (mail-ot1-f54.google.com [209.85.210.54]) (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 73DD42BE03D for ; Wed, 28 Jan 2026 23:40:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643645; cv=none; b=gcZT7JhzxmkM6+WVi75JKwdAAEWqpRJFbB9K/1fSpqIUDzUP9PeEIeS6iCcWsbhPioDY3HZz7x/hR3uS7i6kVrLIBu3cGhPug8fkh/BryajQ9d0sDLvWyhQ6htkHkxeaM/biUFOo1c/HO0KgqlyrH0IkL5aD9kd0W7FCzFInwJY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643645; c=relaxed/simple; bh=1d8hvFb5TqW+gQq4qtYvC+fv837UPEdBxL2Hk07VcJE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=GmgDCuxFCfACPXWdn2XtuwaDGppzTE3sTntSWkO/nBCNI59YgeoQCBqgJ+gnzsdfkH76UWjdp05fGW/26PnWf4GhzdE8nd05aJ9NneRRInZYf2OJFOObdVOm2/vbGuxqOJKpxeWUqcKenTHtc+VHRuh14adgJFNC3WehLzJq/k0= 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=i2A8yuvV; arc=none smtp.client-ip=209.85.210.54 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="i2A8yuvV" Received: by mail-ot1-f54.google.com with SMTP id 46e09a7af769-7cfcb5b1e2fso185763a34.3 for ; Wed, 28 Jan 2026 15:40:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769643642; x=1770248442; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:from:to:cc:subject :date:message-id:reply-to; bh=+paZfars3KKP1JZVhG7KRu0fZBv7UeCEE9k0P4oMOM4=; b=i2A8yuvVFwpAoh15rEMO7tWE+TPG3pmRfHxszywUInLPqvhJPZEFOq5cTLp1X8hX47 6tf8f/iXMbGrlQRT/HO6Q1n4VRa+WW2QebcBu7V4CEScXkb4M9NyndriihFWpp7FqBVb jeBzwC9AAWAMu1KtUR4Tbvixoq/XFAQnITAsVfRnm9DtDiEcXjWLFiOXwyQwxdNNlaZ7 RIgG1gM7PghnU/uCF5du7493gPxLDa16XrHGsFqUGPw+XGFEQjS11fnV38YbGpCQ6MMM z0nhnHPmaMkGbc9kNcpr3eZ2WlO8vxAE+Pk4C5HRo/lQ1nghSszCn/mhPINB5uZkcaqV pZew== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769643642; x=1770248442; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=+paZfars3KKP1JZVhG7KRu0fZBv7UeCEE9k0P4oMOM4=; b=oXkWsIOI/eR+QvWLnEckFOOOIDCN7D1hIt2uXW2JDp6OW2eviYUC0YV0ymVlhK5Pls +zDqd0FDsv/ZTuMHYdItp+lpW3ArQzSTJt11U3aY4+akZIqbhwe3EgSRVZ42TSrUAw1O 3FpHmYd4AWXX1RCJ9p8gmlXlaKobjUrORRLFouQUwHiqsv/tifiLfWL+A6A7SDg+VrLS 6wSNDSAviC4vn3K7ETt0nD8UZJNlv3u9KKMZZkkrZdLo3RkLmx601P16PHFyPMW1ZHZg QIAeQT2+2T4O95vZQK9L/WgW0xLFYfnuAmjwFtimJSMOu8LxMgwvf9Px6HxtuQ7GHLVb T7sQ== X-Gm-Message-State: AOJu0YxakE+nQSJsOVdR3jwWg8q/O4o2ItwuGt5Bj8rJcSt8d47csJww 0W2INDw1wMY1V5CnCoUnAMi50EY9jtNvgsf7UfvmOg1SuCa1dOxVVzl1Zl9pVA== X-Gm-Gg: AZuq6aKDNLexFj3pIl8VoL50Bk3zP3hPmj4TTRXcnk3CklCNhSd9kCL6my75CVNlqg1 xi8F1jtKqCGV2uoXVZodDHlpwGD9K8hsNpujcO5XvUZuiOpSAKKOQg8g5rymVW4w+4hyQnnS+VF n2/pKCvpcm2WgY1aWMr6d1xrnY21Yf4lK73tukooZMA55W5aET8YvdpVQ/rXSUz9HeJNqtlqwu8 iIyRiYtRRNHBmBlF6WaEdyVj3YJHdodsgb0uD8DdvnJBs3ARjeayixnKnt2EqJqkB0OjO0MOeXX ddGWa2wUhS97tr6sVEsQbZCK2xlyYeS3RlYcFl/kI2XW/rSCrDPzHdm9VTXCnVvRO4eLWbGFyEZ sd1vd63FCnoDmZAylHy3C4hc89ACQP9Lhw8OlSXtyUXx2+LMnjPXcS//ivmPpTNtFZBBv1CjWR4 HKlWerZAR12OJuefBWz8zrlb7flvxgQZ6WwPjxIfdkp7JXkpR7/eU3APAfLd8jPaJt8rnCVku8j nrNSsXTIBs0JU8= X-Received: by 2002:ad4:5cea:0:b0:894:7e6f:f92c with SMTP id 6a1803df08f44-894cc94b68cmr93585776d6.58.1769637220835; Wed, 28 Jan 2026 13:53:40 -0800 (PST) Received: from fauth-a1-smtp.messagingengine.com (fauth-a1-smtp.messagingengine.com. [103.168.172.200]) by smtp.gmail.com with ESMTPSA id af79cd13be357-8c711d40139sm259339985a.37.2026.01.28.13.53.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Jan 2026 13:53:40 -0800 (PST) Received: from phl-compute-04.internal (phl-compute-04.internal [10.202.2.44]) by mailfauth.phl.internal (Postfix) with ESMTP id 86AD0F4006D; Wed, 28 Jan 2026 16:53:39 -0500 (EST) Received: from phl-frontend-03 ([10.202.2.162]) by phl-compute-04.internal (MEProxy); Wed, 28 Jan 2026 16:53:39 -0500 X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgdduieeggeehucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmnecujf gurhephffvvefufffkofgjfhgggfestdekredtredttdenucfhrhhomhepuehoqhhunhcu hfgvnhhguceosghoqhhunhdrfhgvnhhgsehgmhgrihhlrdgtohhmqeenucggtffrrghtth gvrhhnpeegleejiedthedvheeggfejveefjeejkefgveffieeujefhueeigfegueehgeeg gfenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpegsoh hquhhnodhmvghsmhhtphgruhhthhhpvghrshhonhgrlhhithihqdeiledvgeehtdeigedq udejjeekheehhedvqdgsohhquhhnrdhfvghngheppehgmhgrihhlrdgtohhmsehfihigmh gvrdhnrghmvgdpnhgspghrtghpthhtohepgedvpdhmohguvgepshhmthhpohhuthdprhgt phhtthhopehlihhnuhigqdhkvghrnhgvlhesvhhgvghrrdhkvghrnhgvlhdrohhrghdprh gtphhtthhopehruhhsthdqfhhorhdqlhhinhhugiesvhhgvghrrdhkvghrnhgvlhdrohhr ghdprhgtphhtthhopehrtghusehvghgvrhdrkhgvrhhnvghlrdhorhhgpdhrtghpthhtoh epghhrvghgkhhhsehlihhnuhigfhhouhhnuggrthhiohhnrdhorhhgpdhrtghpthhtohep rghrvhgvsegrnhgurhhoihgurdgtohhmpdhrtghpthhtohepthhkjhhoshesrghnughroh hiugdrtghomhdprhgtphhtthhopegsrhgruhhnvghrsehkvghrnhgvlhdrohhrghdprhgt phhtthhopegtmhhllhgrmhgrshesghhoohhglhgvrdgtohhmpdhrtghpthhtoheprghlih gtvghrhihhlhesghhoohhglhgvrdgtohhm X-ME-Proxy: Feedback-ID: iad51458e:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Wed, 28 Jan 2026 16:53:38 -0500 (EST) From: Boqun Feng To: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, rcu@vger.kernel.org Cc: Greg Kroah-Hartman , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Todd Kjos , Christian Brauner , Carlos Llamas , Alice Ryhl , Miguel Ojeda , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Trevor Gross , Danilo Krummrich , "Paul E. McKenney" , Frederic Weisbecker , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Uladzislau Rezki , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang , FUJITA Tomonori , Lyude Paul , Thomas Gleixner , Anna-Maria Behnsen , John Stultz , Stephen Boyd , "Yury Norov (NVIDIA)" , Vitaly Wool , Tamir Duberstein , Viresh Kumar , Daniel Almeida , Mitchell Levy , David Gow , Peter Novak , =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= Subject: [RFC PATCH 4/7] drivers: android: binder: Replace `impl_has_work!` with `#[derive(HasField)]` Date: Wed, 28 Jan 2026 13:53:27 -0800 Message-ID: <20260128215330.58410-5-boqun.feng@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260128215330.58410-1-boqun.feng@gmail.com> References: <20260128215330.58410-1-boqun.feng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" `#[derive(HasField)]` offers less code and better ergonomic for defining a struct with a Work in it. Hence replace the current usage of `impl_has_work!()`. Signed-off-by: Boqun Feng --- drivers/android/binder/process.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/drivers/android/binder/process.rs b/drivers/android/binder/pro= cess.rs index 132055b4790f..2a2510e3a0cb 100644 --- a/drivers/android/binder/process.rs +++ b/drivers/android/binder/process.rs @@ -423,6 +423,7 @@ fn new() -> Self { /// Strictly speaking, there can be multiple of these per process. There i= s one for each binder fd /// that a process has opened, so processes using several binder contexts = have several `Process` /// objects. This ensures that the contexts are fully separated. +#[derive(HasField)] #[pin_data] pub(crate) struct Process { pub(crate) ctx: Arc, @@ -451,6 +452,7 @@ pub(crate) struct Process { =20 // Work node for deferred work item. #[pin] + #[field] defer_work: Work, =20 // Links for process list in Context. @@ -460,10 +462,6 @@ pub(crate) struct Process { pub(crate) stats: BinderStats, } =20 -kernel::impl_has_work! { - impl HasWork for Process { self.defer_work } -} - kernel::list::impl_list_arc_safe! { impl ListArcSafe<0> for Process { untracked; } } --=20 2.50.1 (Apple Git-155) From nobody Sat Feb 7 17:04:36 2026 Received: from mail-vs1-f53.google.com (mail-vs1-f53.google.com [209.85.217.53]) (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 EF02E1531C1 for ; Wed, 28 Jan 2026 23:33:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.217.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643228; cv=none; b=LylG0FgOqBveipzu7MD89opXE7ihfk3nEskla1W6CjWHNlYuTPB8pVXaOIwvEo2zOm/i/9pjDxiR1G1g6JTgLHWv2V+2NcX+UhmL14E3wOKOk2v1T3MXiOjdeiCHiBZbVP97G7dXS1H46ZpQvMfw6tquPep6Pq36QlG+/ZqNlXQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643228; c=relaxed/simple; bh=D8IHOpzdpv4jpNHqY+5RxyIP01Gxc9I18RznU79aOOY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=SPMDrrnVcYkXJVslhk6cUKMD/10o525Xqi6oSDr3w+V67Z2ODPmvxVOtX241rZt4DEPbjinz0GoMxalpqzwLpxG1x4mCAsfUpOFmREgGLWGOKklu9s51N+m2GsXDZR/aW1uywL3POkxpwF91hteXUXdQZ5Q0fBLwZKiga0ZAkhY= 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=ip1bJtV+; arc=none smtp.client-ip=209.85.217.53 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="ip1bJtV+" Received: by mail-vs1-f53.google.com with SMTP id ada2fe7eead31-5eeff7e8bb3so310764137.1 for ; Wed, 28 Jan 2026 15:33:46 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769643226; x=1770248026; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:from:to:cc:subject :date:message-id:reply-to; bh=5K4fiuuxH7TZZ5P2nOc2at3WjKzG7Xg5l87CzajWOME=; b=ip1bJtV+llFVgpi0DEKQa912HpttAAy1P5nrN4uzVkOzaBajOQ5L6GaOXMpJukV3Lz 7Xhdu7vOiek7A0t1IuXxFQfiiUgr5y32csU/3mvjlhmBLhZHDi5fMWDyL88F2c/rN8Cv /3a2KfkqCHKdOTJaoUxHxHG3a3YBS0aKbJtS4PES9sYUFKzOP/BvKRYMcKuvjPu7ouLU fNyDiZyJ4fS7vd0Ykm53aahnbGdrSngIjZROKBvsKLPHClp0YVeVsZiZq4zK2uJnHVRX AQSH5GDmXzhZrpDPsv0kKfDd1vusXVOXaC/qKBIN1TLo+3p9PdTXqICCHnt1Ftn1X846 20Kw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769643226; x=1770248026; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=5K4fiuuxH7TZZ5P2nOc2at3WjKzG7Xg5l87CzajWOME=; b=vGmE+246We+BptFUNv2j5w+1R75ave1KAPr3MVcZ44ZhhdoDAAnTxHCkMHqxRdvupI GAnLqjHKgQkEly36xE+BzxoWLPeqlEU5N9ta6HuQTZrfwLES56+jMTA3jL+u7nP112vh j/o+JZPGkTbvpHiyzzyB1raau5S5PmWkRroDHSrSfmLfbTWRbI//fGFwSIPCoRfbterL vi6J76bkeKcom0r+j754Bh68Ye+NVZl8cYWc0hMbo5P/m0j+Dhw4CfpdLD4Nm+9npZWy ZmlwMXnCSSV3oThAwebBoTrDYg5OP3dbrq+FJheRjpqFiEC54EfTCFJZd8QDr1G4la70 j3AA== X-Gm-Message-State: AOJu0YwEa7rFPdKGMcqntxqMA/sBIA9U8ItWcG7EPUFxPOtDr7yCosoA IQ76HBa6vQB5edLLMKr4xS4+x2Kq5Vhz8vhSoNeSU5ODueRqh0+NAmrxHArGJg== X-Gm-Gg: AZuq6aKMWYFjHPYHTEr2/oL/CvONn2Ajr/rpZsgS7SniFRoRcLXMBXc78PPyk7eqK92 8uoqq7jq1gTGlPQ6GSnEWgB7F3FaW4EpgTMzaKuW5T3DbcIR485SFxqh0pB0ADdo/JJdsDxV6oN onHo02I/0B/tR6WFOLZ3Ac1V/nCJAE6jH3zoHuWHtiSoaKac0kwBrmqXRpn6qxBtw7WWm56n+bS tdZ5qSkua1w2pD+U03CBfsorMo+GUz2ox2fi0fCx7N/peGAn/Ahnx5q9yvV5KZaSpn7rCSsXQ8M Jls9AC1DQzbYluHZRq6ua6okuNRtJjCpxghj7k3Go4nbw0cU7uDbCA+rhb/v0XGWXq4LwKKovVP pSs1kL/JrykN8A0on6f2jeuOBPiMN/3nwFILSaG7gOZdBa9zM+fmyjE1HamuUSP7M0VqTPtEFDU vOWFve+oH6egMf+CbOf1davM9WTOh5InAwdKi2zGrMokqiSsD1pjZ0tdgBz8lM1A9clPZW/V2Fw Mp5DLaZXhDFO0c= X-Received: by 2002:a05:620a:1a9d:b0:8b2:ea2b:923c with SMTP id af79cd13be357-8c70b84a575mr922371985a.14.1769637222303; Wed, 28 Jan 2026 13:53:42 -0800 (PST) Received: from fauth-a1-smtp.messagingengine.com (fauth-a1-smtp.messagingengine.com. [103.168.172.200]) by smtp.gmail.com with ESMTPSA id af79cd13be357-8c711b7ba79sm256119785a.11.2026.01.28.13.53.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Jan 2026 13:53:41 -0800 (PST) Received: from phl-compute-05.internal (phl-compute-05.internal [10.202.2.45]) by mailfauth.phl.internal (Postfix) with ESMTP id F1F6CF4006C; Wed, 28 Jan 2026 16:53:40 -0500 (EST) Received: from phl-frontend-03 ([10.202.2.162]) by phl-compute-05.internal (MEProxy); Wed, 28 Jan 2026 16:53:40 -0500 X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgdduieeggeehucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmnecujf gurhephffvvefufffkofgjfhgggfestdekredtredttdenucfhrhhomhepuehoqhhunhcu hfgvnhhguceosghoqhhunhdrfhgvnhhgsehgmhgrihhlrdgtohhmqeenucggtffrrghtth gvrhhnpeegleejiedthedvheeggfejveefjeejkefgveffieeujefhueeigfegueehgeeg gfenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpegsoh hquhhnodhmvghsmhhtphgruhhthhhpvghrshhonhgrlhhithihqdeiledvgeehtdeigedq udejjeekheehhedvqdgsohhquhhnrdhfvghngheppehgmhgrihhlrdgtohhmsehfihigmh gvrdhnrghmvgdpnhgspghrtghpthhtohepgedvpdhmohguvgepshhmthhpohhuthdprhgt phhtthhopehlihhnuhigqdhkvghrnhgvlhesvhhgvghrrdhkvghrnhgvlhdrohhrghdprh gtphhtthhopehruhhsthdqfhhorhdqlhhinhhugiesvhhgvghrrdhkvghrnhgvlhdrohhr ghdprhgtphhtthhopehrtghusehvghgvrhdrkhgvrhhnvghlrdhorhhgpdhrtghpthhtoh epghhrvghgkhhhsehlihhnuhigfhhouhhnuggrthhiohhnrdhorhhgpdhrtghpthhtohep rghrvhgvsegrnhgurhhoihgurdgtohhmpdhrtghpthhtohepthhkjhhoshesrghnughroh hiugdrtghomhdprhgtphhtthhopegsrhgruhhnvghrsehkvghrnhgvlhdrohhrghdprhgt phhtthhopegtmhhllhgrmhgrshesghhoohhglhgvrdgtohhmpdhrtghpthhtoheprghlih gtvghrhihhlhesghhoohhglhgvrdgtohhm X-ME-Proxy: Feedback-ID: iad51458e:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Wed, 28 Jan 2026 16:53:40 -0500 (EST) From: Boqun Feng To: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, rcu@vger.kernel.org Cc: Greg Kroah-Hartman , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Todd Kjos , Christian Brauner , Carlos Llamas , Alice Ryhl , Miguel Ojeda , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Trevor Gross , Danilo Krummrich , "Paul E. McKenney" , Frederic Weisbecker , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Uladzislau Rezki , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang , FUJITA Tomonori , Lyude Paul , Thomas Gleixner , Anna-Maria Behnsen , John Stultz , Stephen Boyd , "Yury Norov (NVIDIA)" , Vitaly Wool , Tamir Duberstein , Viresh Kumar , Daniel Almeida , Mitchell Levy , David Gow , Peter Novak , =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= Subject: [RFC PATCH 5/7] rust: sync: Completion: Replace `impl_has_work!` with `#[derive(HasField)]` Date: Wed, 28 Jan 2026 13:53:28 -0800 Message-ID: <20260128215330.58410-6-boqun.feng@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260128215330.58410-1-boqun.feng@gmail.com> References: <20260128215330.58410-1-boqun.feng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" `#[derive(HasField)]` offers less code and better ergnomic for defining a struct with a Work in it. Hence replace the current usage of `impl_has_work!()`. Signed-off-by: Boqun Feng --- rust/kernel/sync/completion.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/rust/kernel/sync/completion.rs b/rust/kernel/sync/completion.rs index c50012a940a3..c4af58924fe3 100644 --- a/rust/kernel/sync/completion.rs +++ b/rust/kernel/sync/completion.rs @@ -17,20 +17,18 @@ /// /// ``` /// use kernel::sync::{Arc, Completion}; -/// use kernel::workqueue::{self, impl_has_work, new_work, Work, WorkItem}; +/// use kernel::workqueue::{self, new_work, Work, WorkItem}; /// +/// #[derive(HasField)] /// #[pin_data] /// struct MyTask { /// #[pin] +/// #[field] /// work: Work, /// #[pin] /// done: Completion, /// } /// -/// impl_has_work! { -/// impl HasWork for MyTask { self.work } -/// } -/// /// impl MyTask { /// fn new() -> Result> { /// let this =3D Arc::pin_init(pin_init!(MyTask { --=20 2.50.1 (Apple Git-155) From nobody Sat Feb 7 17:04:36 2026 Received: from mail-oa1-f51.google.com (mail-oa1-f51.google.com [209.85.160.51]) (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 41BC61531C1 for ; Wed, 28 Jan 2026 23:30:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.160.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643026; cv=none; b=NithmPM1WQ8kvBq2A+xx2NRC5+8U7WIGAJT+WqrpGdwOdNNzhB0SVkEMl606+BQyJWa+pJn7amd3W6yScHAWayN75MbbKfA2FepD87++ujxfoEQaBoEKpp6qH+brD8XY+bUHUcrlZCmEFhif7/OEHwbC23jbuPq4l044PXXIOKg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769643026; c=relaxed/simple; bh=OWcfZiYWS0H6ctpWcE+xkPHvQjej9ptDYntcK8zIjcw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=HBmlPuwGNjJVPY7Jk096nnCe/QGcDcHqBRV8tO78bj1d5weUO8OhW9B5cVATn+NztZAKufB/D2f5uNQEGwweytGDIwnP4Cuk1jJ+Dfi2jT4wL7Ye9MIJ8yRMmCQHGNiqRs3E+3BxhUzpPQP/w2Htvg+WhziDrU1Gd0MLF+9KJWM= 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=gD8jlORE; arc=none smtp.client-ip=209.85.160.51 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="gD8jlORE" Received: by mail-oa1-f51.google.com with SMTP id 586e51a60fabf-40970f97638so189394fac.3 for ; Wed, 28 Jan 2026 15:30:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769643024; x=1770247824; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:from:to:cc:subject :date:message-id:reply-to; bh=HK2cJpoHs1cW08tNlDAhBYjQE8db82PEiBJhgotTdb4=; b=gD8jlOREgJOcRXyjY6LTPfLO2DPUND05ze/P9W/p8W47M6Jvpr2OEyxLEZ9Gc5QuWI tYnhRTzY1i7Y4yHU5sSFbz7Nvz2KDyCzMqjik8+2AAM1/M6XC2dd0jq882LKGhiUZ6l+ yWJa2wCIlCzmzw6L6hIx7Ztv0pSNj5JfCt+z51+iLxw+p3JWF1yHd1zf3coOnnmDaqRY DpuGJsCywo+83Zq9oDOm4LeRMarPB6RnpApg5R3pJJwaF+oWsudcNduk7LQS+kFqdpec yFchH/ZmOGS89PSp0Cj92BOzxm3k/sXBUjTOh+Z/nCfNgN9woPSzPtwLkKsrDOy2dQcY rGog== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769643024; x=1770247824; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=HK2cJpoHs1cW08tNlDAhBYjQE8db82PEiBJhgotTdb4=; b=w2BC7++vwOdmj2adN+xOkX7YjmO3GU/vqFECDnEIGbeCYQTn+TUXFKIMQqwBFzhpx1 fJI9UV2oWYhxLe6HvmOypuVZ1YY6eMWuvCeSbddKX6b+jeopddTbrF/EGjs5P3q/crXp DgRX06ALCX22/gPwQpt6vAvf94sm2gx5RNWoJBPp5ZC+sYdZ1m6wfOh+67DVVpsgYZEs TCnQSzEMm4C3amICBEXlRc8dmwcWYJE2f/Jw7JPYxc7RiPHBBEgToELjrcNhyDHOa1he 4lfmU61OvdVKa8t8GQDcSV0WZiVJkbuhb5ixMeZeeJvogwsfqGAgIpND4u8/HB5LNWVJ QcLA== X-Gm-Message-State: AOJu0Yx/aMJ1Kz33sj6XL93Cz2GH2EogCeMOcpQyBiiOVXs8dP5H+1CO sU2JzjboAx81QOPVJuGZt2JgJ6+Q1OiDOGky+1NkVmb2N2KcB6kKjxoqKxuOAA== X-Gm-Gg: AZuq6aImEG+HzBL37jgl6/ormElTUKelx/owMcXoXVSJsKDVEBiNSR2OHgacemnBI3K uIjGM5Apf41yJkqJyGGdl3mm3RQWfbj7zwcyU05Bw0ZQ3xJ/DBvGPx8hVNUJKlxjDy2SqkOOcSK AGSu6LxLYEEGP9tSkMEtCvWQ9KoHmbWmU2vZzaTd+gIltSTPEwHJeghQY3upKua/p4xjVv9bZAh YifHm/vvX5FVLT8gA84IliFMXu1LW5dfjHD+tbxA44pV88/5IF0o1eDqTr8LQsJldwvx/GfASCT Wj2q2qBP8yPLNuBFRdX73+sPmk8yLVClI6C2o9zSABqA96+8F6llMyOMhpOU6IgfdPiGV0RJwSq SNqFdxZy9yBSKM+EmkGJ5ohWvxpoAjQPHWb95m6VMOl6MNWA/HX6LZeYNRbCo+bo7lTCfqWRcVE PRjt5E5tkiMRxYkaG2+LNvja6zMVvOqFiwHOIXkOtZrOe2yu7E0iMMp8KjD25rv20EzRYoXpRHA KQIOE5FxR7e3hg= X-Received: by 2002:a05:620a:4447:b0:8c7:13b8:8b55 with SMTP id af79cd13be357-8c713b8905cmr517714785a.46.1769637223840; Wed, 28 Jan 2026 13:53:43 -0800 (PST) Received: from fauth-a1-smtp.messagingengine.com (fauth-a1-smtp.messagingengine.com. [103.168.172.200]) by smtp.gmail.com with ESMTPSA id af79cd13be357-8c713580985sm237855085a.8.2026.01.28.13.53.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Jan 2026 13:53:43 -0800 (PST) Received: from phl-compute-05.internal (phl-compute-05.internal [10.202.2.45]) by mailfauth.phl.internal (Postfix) with ESMTP id 7918BF4006C; Wed, 28 Jan 2026 16:53:42 -0500 (EST) Received: from phl-frontend-03 ([10.202.2.162]) by phl-compute-05.internal (MEProxy); Wed, 28 Jan 2026 16:53:42 -0500 X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgdduieeggeehucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmnecujf gurhephffvvefufffkofgjfhgggfestdekredtredttdenucfhrhhomhepuehoqhhunhcu hfgvnhhguceosghoqhhunhdrfhgvnhhgsehgmhgrihhlrdgtohhmqeenucggtffrrghtth gvrhhnpeegleejiedthedvheeggfejveefjeejkefgveffieeujefhueeigfegueehgeeg gfenucevlhhushhtvghrufhiiigvpedunecurfgrrhgrmhepmhgrihhlfhhrohhmpegsoh hquhhnodhmvghsmhhtphgruhhthhhpvghrshhonhgrlhhithihqdeiledvgeehtdeigedq udejjeekheehhedvqdgsohhquhhnrdhfvghngheppehgmhgrihhlrdgtohhmsehfihigmh gvrdhnrghmvgdpnhgspghrtghpthhtohepgedvpdhmohguvgepshhmthhpohhuthdprhgt phhtthhopehlihhnuhigqdhkvghrnhgvlhesvhhgvghrrdhkvghrnhgvlhdrohhrghdprh gtphhtthhopehruhhsthdqfhhorhdqlhhinhhugiesvhhgvghrrdhkvghrnhgvlhdrohhr ghdprhgtphhtthhopehrtghusehvghgvrhdrkhgvrhhnvghlrdhorhhgpdhrtghpthhtoh epghhrvghgkhhhsehlihhnuhigfhhouhhnuggrthhiohhnrdhorhhgpdhrtghpthhtohep rghrvhgvsegrnhgurhhoihgurdgtohhmpdhrtghpthhtohepthhkjhhoshesrghnughroh hiugdrtghomhdprhgtphhtthhopegsrhgruhhnvghrsehkvghrnhgvlhdrohhrghdprhgt phhtthhopegtmhhllhgrmhgrshesghhoohhglhgvrdgtohhmpdhrtghpthhtoheprghlih gtvghrhihhlhesghhoohhglhgvrdgtohhm X-ME-Proxy: Feedback-ID: iad51458e:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Wed, 28 Jan 2026 16:53:41 -0500 (EST) From: Boqun Feng To: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, rcu@vger.kernel.org Cc: Greg Kroah-Hartman , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Todd Kjos , Christian Brauner , Carlos Llamas , Alice Ryhl , Miguel Ojeda , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Trevor Gross , Danilo Krummrich , "Paul E. McKenney" , Frederic Weisbecker , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Uladzislau Rezki , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang , FUJITA Tomonori , Lyude Paul , Thomas Gleixner , Anna-Maria Behnsen , John Stultz , Stephen Boyd , "Yury Norov (NVIDIA)" , Vitaly Wool , Tamir Duberstein , Viresh Kumar , Daniel Almeida , Mitchell Levy , David Gow , Peter Novak , =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= Subject: [RFC PATCH 6/7] rust: work: Remove `impl_has_work!` Date: Wed, 28 Jan 2026 13:53:29 -0800 Message-ID: <20260128215330.58410-7-boqun.feng@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260128215330.58410-1-boqun.feng@gmail.com> References: <20260128215330.58410-1-boqun.feng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Now all in-tree users of `impl_has_work!()` are converted to use `#[derive(HasField)]`, hence remove it. Signed-off-by: Boqun Feng --- rust/kernel/workqueue.rs | 53 ++-------------------------------------- 1 file changed, 2 insertions(+), 51 deletions(-) diff --git a/rust/kernel/workqueue.rs b/rust/kernel/workqueue.rs index 2dcfd3eace39..37fbf348c760 100644 --- a/rust/kernel/workqueue.rs +++ b/rust/kernel/workqueue.rs @@ -578,55 +578,6 @@ pub unsafe trait HasWork { unsafe fn work_container_of(ptr: *mut Work) -> *mut Self; } =20 -/// Used to safely implement the [`HasWork`] trait. -/// -/// # Examples -/// -/// ``` -/// use kernel::sync::Arc; -/// use kernel::workqueue::{self, impl_has_work, Work}; -/// -/// struct MyStruct<'a, T, const N: usize> { -/// work_field: Work, 17>, -/// f: fn(&'a [T; N]), -/// } -/// -/// impl_has_work! { -/// impl{'a, T, const N: usize} HasWork, 17> -/// for MyStruct<'a, T, N> { self.work_field } -/// } -/// ``` -#[macro_export] -macro_rules! impl_has_work { - ($(impl$({$($generics:tt)*})? - HasWork<$work_type:ty $(, $id:tt)?> - for $self:ty - { self.$field:ident } - )*) =3D> {$( - // SAFETY: The implementation of `raw_get_work` only compiles if t= he field has the right - // type. - unsafe impl$(<$($generics)+>)? $crate::workqueue::HasWork<$work_ty= pe $(, $id)?> for $self { - #[inline] - unsafe fn raw_get_work(ptr: *mut Self) -> *mut $crate::workque= ue::Work<$work_type $(, $id)?> { - // SAFETY: The caller promises that the pointer is not dan= gling. - unsafe { - ::core::ptr::addr_of_mut!((*ptr).$field) - } - } - - #[inline] - unsafe fn work_container_of( - ptr: *mut $crate::workqueue::Work<$work_type $(, $id)?>, - ) -> *mut Self { - // SAFETY: The caller promises that the pointer points at = a field of the right type - // in the right kind of struct. - unsafe { $crate::container_of!(ptr, Self, $field) } - } - } - )*}; -} -pub use impl_has_work; - impl Field for Work {} =20 /// SAFETY: Per the safety requirement of `HasField`, `raw_get_field()` an= d `field_container_of()` @@ -746,8 +697,8 @@ pub unsafe trait HasDelayedWork= : HasWork {} =20 /// Used to safely implement the [`HasDelayedWork`] trait. /// -/// This macro also implements the [`HasWork`] trait, so you do not need t= o use [`impl_has_work!`] -/// when using this macro. +/// This macro also implements the [`HasWork`] trait, so you do not need t= o use `#[has_field]` when +/// using this macro. /// /// # Examples /// --=20 2.50.1 (Apple Git-155) From nobody Sat Feb 7 17:04:36 2026 Received: from mail-qk1-f181.google.com (mail-qk1-f181.google.com [209.85.222.181]) (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 8C7B733ADA5 for ; Wed, 28 Jan 2026 21:53:47 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769637230; cv=none; b=BWjKB6KOnPkRdTLYHTGyBOoQFLXeJjc7YRA7W6eFrPB0daG28j6CNcxnL0OWn1Scg4IWe96z825E3JG+LU7aS4Vv6Eg3vc33BMPnunJNnB0cz+wKfIkui4WRlj+7qXewqP6yKChyXJim4yKwYXWQT2a2vOr77SRjvVT6cniSUbc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769637230; c=relaxed/simple; bh=VS2vDVTbhryM2iG2RFEe63s3RzGceDZw2ywU6GaaAO4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=SViFpbT9ruqtkpj9Al+H4R6cNGcuY+kQEzOJD5fSzTF9scev5KGmy8HkS/DohfWV8Yw1bnt1MUB8d/9ZC87Tvdllnf7kFaiGhuoVRXSi+0D30KPZdADycIlAFlfvv1kgGUoUZrJaiwWoqMKjr9gIx2GDxn77RP5Q980MdiKZeRo= 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=UWP2xgle; arc=none smtp.client-ip=209.85.222.181 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="UWP2xgle" Received: by mail-qk1-f181.google.com with SMTP id af79cd13be357-8c6a822068eso48514585a.3 for ; Wed, 28 Jan 2026 13:53:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1769637225; x=1770242025; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:from:to:cc:subject :date:message-id:reply-to; bh=NJefVb7bf1Dw+gUw0ZVM3yqaOt6rhoTdHQFIKu4uZfc=; b=UWP2xglezd+cyTnP70i7txqJuIktFy1MIxQeWsY/RIamcg0lhDKpL462kDCtgm6234 G3KembYWEBOoCiBQ/7+NP5InQ7Wsf8BmcnA7f+Vb3Tti1TIoFUu9xBNOELTnk+o8xVI1 92d/o900HVXi6GQRz1M+UPNhov8j3rcoBJsUlV0/uvHej1JIGnSXKY0FrfcQ6ilqefsq aaKtxY5PEEtwSs/YaNuxvf48nyG7mfRLk37I5j1bfbvU1Y3kxqvPjR4gC54ryd93J9uN 6ckHCCN/gVfOYyuNpFs/P5LD09r+9j6b4CAqTVGUB7KtIBFPMT8nd1lJheeeEQs6XN+x s4nw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769637225; x=1770242025; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:feedback-id:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=NJefVb7bf1Dw+gUw0ZVM3yqaOt6rhoTdHQFIKu4uZfc=; b=RdVqNzReEQd8G3nJvdusbzJrv/Z0CGwG/QCeILExC7/v0qk6uNqm9cpoMW3+HZuVak qFXN8Jgv3ftXA6TaL9FhHPd0B9XbWmiSNixRyMfL19mYHfzkeXagmFdkLPZRBvlm1V98 5QothTGn/M0ujNMJdI26ly9qNj8l4yu7Z1VokR1bO5ZJDa2wyYTKTD82D69BOir61uaf DIvjKlCNya3hUafam66/qComIty6ShPgS0f+vfj1idh/Atm5TMPHxPBzVOTGBsmvHX5n 5/qiyI2opUEf3iKb2iNd36BDoH/cSVTjkiXDprJKOk6jzuJj9nArCpHpCMJToYe0q6TX IQbg== X-Gm-Message-State: AOJu0Yx9PaAmG7zxl385Ne/o+VT9ym7QfIBbsc3B+6AN26Gug4mgYnTr uU8EA8DV+1DvrqlV3/QR01kSsWNX1Hh4abghtYp1CtkthwQ3cPoUholB X-Gm-Gg: AZuq6aJVTApl9f1LYLsLA0xvREBRFUchZ/RBBvWmEwnFTRZM6IxUfS1Z1/cH3Y7pnil lL7Vlk5koE3Bdsl/6llFjC1ElUrDArTlmdL9ha+AtJTUzkdbLWQzkgw5JQ+3IJK9YbThbfsd+5m DKsKjAXaVg1bljx+3ZbwLv7VMqHiSB+PgT861HCSAbOskYT+VEfT3h9+d4kJNASwULn7tvJVh0h 1sO8VNOrKDDpmi5rBIw8zunyF6b7yh2XhrJwDLvEcRk3xIbHt2fjjvHZ8ekLvH4LaHEYrm5bx8m RTYnQFagSPmuDPmtoy9Y0cQuTdJs4ho5DHdGDp+n9pUQuKUOIxUsPDJR1QsMP+HV9qLy9tdlX/F +oo5Zwnwz4nLdFtjf231amYKnXhX3JxieYWShxtxEyXgXLnaywRSxL5Li6DzhKHibbMHwmw/vH0 O/x/pKzkUBPucBaRaVrOHUVuDdJsQxKE1w7oyDxDYEVV4z/fzVlSgZhI6lItyDtlWnMdqak49uq VUBWWmQfGL/DLU= X-Received: by 2002:a05:620a:1988:b0:8c1:6018:b186 with SMTP id af79cd13be357-8c70b927a0dmr857145285a.87.1769637225168; Wed, 28 Jan 2026 13:53:45 -0800 (PST) Received: from fauth-a1-smtp.messagingengine.com (fauth-a1-smtp.messagingengine.com. [103.168.172.200]) by smtp.gmail.com with ESMTPSA id af79cd13be357-8c711b96fbdsm261644985a.14.2026.01.28.13.53.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 28 Jan 2026 13:53:44 -0800 (PST) Received: from phl-compute-06.internal (phl-compute-06.internal [10.202.2.46]) by mailfauth.phl.internal (Postfix) with ESMTP id EE44BF4006D; Wed, 28 Jan 2026 16:53:43 -0500 (EST) Received: from phl-frontend-03 ([10.202.2.162]) by phl-compute-06.internal (MEProxy); Wed, 28 Jan 2026 16:53:43 -0500 X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefgedrtddtgdduieeggeehucetufdoteggodetrf dotffvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfurfetoffkrfgpnffqhgenuceu rghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmnecujf gurhephffvvefufffkofgjfhgggfestdekredtredttdenucfhrhhomhepuehoqhhunhcu hfgvnhhguceosghoqhhunhdrfhgvnhhgsehgmhgrihhlrdgtohhmqeenucggtffrrghtth gvrhhnpeegleejiedthedvheeggfejveefjeejkefgveffieeujefhueeigfegueehgeeg gfenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpegsoh hquhhnodhmvghsmhhtphgruhhthhhpvghrshhonhgrlhhithihqdeiledvgeehtdeigedq udejjeekheehhedvqdgsohhquhhnrdhfvghngheppehgmhgrihhlrdgtohhmsehfihigmh gvrdhnrghmvgdpnhgspghrtghpthhtohepgedvpdhmohguvgepshhmthhpohhuthdprhgt phhtthhopehlihhnuhigqdhkvghrnhgvlhesvhhgvghrrdhkvghrnhgvlhdrohhrghdprh gtphhtthhopehruhhsthdqfhhorhdqlhhinhhugiesvhhgvghrrdhkvghrnhgvlhdrohhr ghdprhgtphhtthhopehrtghusehvghgvrhdrkhgvrhhnvghlrdhorhhgpdhrtghpthhtoh epghhrvghgkhhhsehlihhnuhigfhhouhhnuggrthhiohhnrdhorhhgpdhrtghpthhtohep rghrvhgvsegrnhgurhhoihgurdgtohhmpdhrtghpthhtohepthhkjhhoshesrghnughroh hiugdrtghomhdprhgtphhtthhopegsrhgruhhnvghrsehkvghrnhgvlhdrohhrghdprhgt phhtthhopegtmhhllhgrmhgrshesghhoohhglhgvrdgtohhmpdhrtghpthhtoheprghlih gtvghrhihhlhesghhoohhglhgvrdgtohhm X-ME-Proxy: Feedback-ID: iad51458e:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Wed, 28 Jan 2026 16:53:43 -0500 (EST) From: Boqun Feng To: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, rcu@vger.kernel.org Cc: Greg Kroah-Hartman , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Todd Kjos , Christian Brauner , Carlos Llamas , Alice Ryhl , Miguel Ojeda , Boqun Feng , Gary Guo , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Benno Lossin , Andreas Hindborg , Trevor Gross , Danilo Krummrich , "Paul E. McKenney" , Frederic Weisbecker , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Uladzislau Rezki , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang , FUJITA Tomonori , Lyude Paul , Thomas Gleixner , Anna-Maria Behnsen , John Stultz , Stephen Boyd , "Yury Norov (NVIDIA)" , Vitaly Wool , Tamir Duberstein , Viresh Kumar , Daniel Almeida , Mitchell Levy , David Gow , Peter Novak , =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= Subject: [RFC PATCH 7/7] rust: sync: rcu: Introduce RcuHead Date: Wed, 28 Jan 2026 13:53:30 -0800 Message-ID: <20260128215330.58410-8-boqun.feng@gmail.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260128215330.58410-1-boqun.feng@gmail.com> References: <20260128215330.58410-1-boqun.feng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In order to support RCU delay free (call_rcu() and kfree_rcu()), the abstraction of the `rcu_head` is introduced. Types that want to support RCU delay free can specify a `RcuHead` in it, e.g. #[derive(HasField)] struct Foo { a: i32, b: i32, #[field] rcu_head: RcuHead, } A wrapper `WithRcuHead` is also provided for users that want to specify a generic `T` with a rcu_head. Signed-off-by: Boqun Feng --- rust/kernel/sync/rcu.rs | 69 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 68 insertions(+), 1 deletion(-) diff --git a/rust/kernel/sync/rcu.rs b/rust/kernel/sync/rcu.rs index a32bef6e490b..694ca2f54953 100644 --- a/rust/kernel/sync/rcu.rs +++ b/rust/kernel/sync/rcu.rs @@ -4,7 +4,14 @@ //! //! C header: [`include/linux/rcupdate.h`](srctree/include/linux/rcupdate.= h) =20 -use crate::{bindings, types::NotThreadSafe}; +use crate::{ + bindings, + field::{Field, HasField}, + macros::HasField, + types::{NotThreadSafe, Opaque}, +}; + +use core::ops::Deref; =20 /// Evidence that the RCU read side lock is held on the current thread/CPU. /// @@ -50,3 +57,63 @@ fn drop(&mut self) { pub fn read_lock() -> Guard { Guard::new() } + +/// RCU head for call backs. +/// +/// # Examples +/// +/// Use `#[derive(HasField)]` macro to specify a struct has a RCU head. +/// +/// ``` +/// use kernel::sync::rcu::RcuHead; +/// +/// #[derive(HasField)] +/// struct Foo { +/// a: i32, +/// #[field] +/// rcu_head: RcuHead, +/// b: i32, +/// } +/// +/// const _: () =3D { +/// const fn assert_has_field>() { } +/// assert_has_field::(); +/// }; +/// ``` +#[repr(transparent)] +pub struct RcuHead(Opaque); + +impl Field for RcuHead {} + +// SAFETY: `callback_head` doesn't hold anything local to the current exec= ution context, so it's +// safe to transfer to another execution context. +unsafe impl Send for RcuHead {} +// SAFETY: `callback_head` should only be used when it's in the destructor= , and accesses to it are +// already unsafe, hence make it `Sync`. +unsafe impl Sync for RcuHead {} + +/// A wrapper that adds an `RcuHead` on `T`. +#[derive(HasField)] +pub struct WithRcuHead { + #[field] + head: RcuHead, + data: T, +} + +impl WithRcuHead { + /// Creates a new wrapper on `T` with `RcuHead`. + pub fn new(data: T) -> Self { + Self { + head: RcuHead(Opaque::zeroed()), + data, + } + } +} + +impl Deref for WithRcuHead { + type Target =3D T; + + fn deref(&self) -> &Self::Target { + &self.data + } +} --=20 2.50.1 (Apple Git-155)