Commit 1ce98bb2 authored by Tamir Duberstein's avatar Tamir Duberstein Committed by Miguel Ojeda
Browse files

rust: workqueue: remove HasWork::OFFSET 

Implement `HasWork::work_container_of` in `impl_has_work!`, narrowing
the interface of `HasWork` and replacing pointer arithmetic with
`container_of!`. Remove the provided implementation of
`HasWork::get_work_offset` without replacement; an implementation is
already generated in `impl_has_work!`. Remove the `Self: Sized` bound on
`HasWork::work_container_of` which was apparently necessary to access
`OFFSET` as `OFFSET` no longer exists.

A similar API change was discussed on the hrtimer series[1].

Link: https://lore.kernel.org/all/20250224-hrtimer-v3-v6-12-rc2-v9-1-5bd3bf0ce6cc@kernel.org/

 [1]
Reviewed-by: default avatarBenno Lossin <benno.lossin@proton.me>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Tested-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarAndreas Hindborg <a.hindborg@kernel.org>
Signed-off-by: default avatarTamir Duberstein <tamird@gmail.com>
Acked-by: default avatarTejun Heo <tj@kernel.org>
Link: https://lore.kernel.org/r/20250411-no-offset-v3-1-c0b174640ec3@gmail.com


Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent 74d6a606

rust/kernel/workqueue.rs

+17 −33
Original line number Diff line number Diff line
@@ -429,51 +429,28 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { 
///

/// # Safety

///

/// The [`OFFSET`] constant must be the offset of a field in `Self` of type [`Work<T, ID>`]. The

/// methods on this trait must have exactly the behavior that the definitions given below have.

/// The methods [`raw_get_work`] and [`work_container_of`] must return valid pointers and must be

/// true inverses of each other; that is, they must satisfy the following invariants:

/// - `work_container_of(raw_get_work(ptr)) == ptr` for any `ptr: *mut Self`.

/// - `raw_get_work(work_container_of(ptr)) == ptr` for any `ptr: *mut Work<T, ID>`.

///

/// [`impl_has_work!`]: crate::impl_has_work

/// [`OFFSET`]: HasWork::OFFSET

/// [`raw_get_work`]: HasWork::raw_get_work

/// [`work_container_of`]: HasWork::work_container_of

pub unsafe trait HasWork<T, const ID: u64 = 0> {

    /// The offset of the [`Work<T, ID>`] field.

    const OFFSET: usize;



    /// Returns the offset of the [`Work<T, ID>`] field.

    ///

    /// This method exists because the [`OFFSET`] constant cannot be accessed if the type is not

    /// [`Sized`].

    ///

    /// [`OFFSET`]: HasWork::OFFSET

    #[inline]

    fn get_work_offset(&self) -> usize {

        Self::OFFSET

    }



    /// Returns a pointer to the [`Work<T, ID>`] field.

    ///

    /// # Safety

    ///

    /// The provided pointer must point at a valid struct of type `Self`.

    #[inline]

    unsafe fn raw_get_work(ptr: *mut Self) -> *mut Work<T, ID> {

        // SAFETY: The caller promises that the pointer is valid.

        unsafe { (ptr as *mut u8).add(Self::OFFSET) as *mut Work<T, ID> }

    }

    unsafe fn raw_get_work(ptr: *mut Self) -> *mut Work<T, ID>;



    /// Returns a pointer to the struct containing the [`Work<T, ID>`] field.

    ///

    /// # Safety

    ///

    /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`.

    #[inline]

    unsafe fn work_container_of(ptr: *mut Work<T, ID>) -> *mut Self

    where

        Self: Sized,

    {

        // SAFETY: The caller promises that the pointer points at a field of the right type in the

        // right kind of struct.

        unsafe { (ptr as *mut u8).sub(Self::OFFSET) as *mut Self }

    }

    unsafe fn work_container_of(ptr: *mut Work<T, ID>) -> *mut Self;

}



/// Used to safely implement the [`HasWork<T, ID>`] trait.
@@ -504,8 +481,6 @@ macro_rules! impl_has_work { 
        // SAFETY: The implementation of `raw_get_work` only compiles if the field has the right

        // type.

        unsafe impl$(<$($generics)+>)? $crate::workqueue::HasWork<$work_type $(, $id)?> for $self {

            const OFFSET: usize = ::core::mem::offset_of!(Self, $field) as usize;



            #[inline]

            unsafe fn raw_get_work(ptr: *mut Self) -> *mut $crate::workqueue::Work<$work_type $(, $id)?> {

                // SAFETY: The caller promises that the pointer is not dangling.
@@ -513,6 +488,15 @@ unsafe fn raw_get_work(ptr: *mut Self) -> *mut $crate::workqueue::Work<$work_typ 
                    ::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) }

            }

        }

    )*};

}