[RFC PATCH 7/7] rust: sync: rcu: Introduce RcuHead

[Boqun Feng <boqun.feng@gmail.com>]

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<T>` in it, e.g.

    #[derive(HasField)]
    struct Foo {
        a: i32,
	b: i32,
	#[field]
        rcu_head: RcuHead,
    }

A wrapper `WithRcuHead<T>` is also provided for users that want to
specify a generic `T` with a rcu_head.

Signed-off-by: Boqun Feng <boqun.feng@gmail.com>
---
 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)
 
-use crate::{bindings, types::NotThreadSafe};
+use crate::{
+    bindings,
+    field::{Field, HasField},
+    macros::HasField,
+    types::{NotThreadSafe, Opaque},
+};
+
+use core::ops::Deref;
 
 /// 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 _: () = {
+///     const fn assert_has_field<T: HasField<T, RcuHead>>() { }
+///     assert_has_field::<Foo>();
+/// };
+/// ```
+#[repr(transparent)]
+pub struct RcuHead(Opaque<bindings::callback_head>);
+
+impl<T> Field<T> for RcuHead {}
+
+// SAFETY: `callback_head` doesn't hold anything local to the current execution 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<T> {
+    #[field]
+    head: RcuHead,
+    data: T,
+}
+
+impl<T> WithRcuHead<T> {
+    /// Creates a new wrapper on `T` with `RcuHead`.
+    pub fn new(data: T) -> Self {
+        Self {
+            head: RcuHead(Opaque::zeroed()),
+            data,
+        }
+    }
+}
+
+impl<T> Deref for WithRcuHead<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
-- 
2.50.1 (Apple Git-155)