rust: add Work::disable_sync
Onur Özkan
reviewercover rust: add Work::disable_sync
The immediate motivation is the Tyr reset infrastructure [1] which needs to stop queued or running reset work during teardown before dropping the resources used by that work. The reset series started to require too many independent dependencies, so this is split out as a standalone change to keep the reset series focused on the reset logic and easier to review, rebase and land.
[1]: https://lore.kernel.org/all/[email protected]/
Onur Özkan (1):
rust: add Work::disable_sync
rust/kernel/workqueue.rs | 102 +++++++++++++++++++++++++++++---------- 1 file changed, 76 insertions(+), 26 deletions(-)
Signature · 1 line
2.51.2
Onur Özkan
reviewerPATCH 1/1 rust: add Work::disable_sync
Adds Work::disable_sync() as a safe wrapper for disable_work_sync().
Drivers can use this during teardown to stop new queueing and wait for queued or running work to finish before dropping related resources.
--- rust/kernel/workqueue.rs | 102 +++++++++++++++++++++++++++++---------- 1 file changed, 76 insertions(+), 26 deletions(-)
rust/kernel/workqueue.rs +76 -26
@@ -442,21 +442,48 @@ pub unsafe trait RawDelayedWorkItem<const ID: u64>: RawWorkItem<ID> {}/// /// # Safety /// -/// Implementers must ensure that [`__enqueue`] uses a `work_struct` initialized with the [`run`] -/// method of this trait as the function pointer. -/// -/// [`__enqueue`]: RawWorkItem::__enqueue -/// [`run`]: WorkItemPointer::run -pub unsafe trait WorkItemPointer <const ID :u64 >:RawWorkItem <ID > { +/// Implementers must ensure that [`WorkItemPointer::from_raw_work`] rebuilds the exact ownership +/// transferred by a successful [`RawWorkItem::__enqueue`] call. +pub unsafe trait WorkItemPointer <const ID :u64 >:RawWorkItem <ID > +Sized { +/// The work item type containing the embedded `work_struct`. +type Item :WorkItem <ID ,Pointer =Self > + ?Sized ; + +/// Rebuild this work item's pointer from its embedded `work_struct`. +/// +/// # Safety +/// +/// The provided `work_struct` pointer must originate from a previous call to +/// [`RawWorkItem::__enqueue`] where the `queue_work_on` closure returned true +/// and the pointer must still be valid. +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self ; +/// Run this work item. /// /// # Safety /// -/// The provided `work_struct` pointer must originate from a previous call to [`__enqueue`] -/// where the `queue_work_on` closure returned true, and the pointer must still be valid. +/// The provided `work_struct` pointer must satisfy the same requirements as +/// [`WorkItemPointer::from_raw_work`]. +#[inline] +unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { + <Self ::Item as WorkItem <ID >>::run ( +// SAFETY: The requirements for `run` are exactly those of `from_raw_work`. +unsafe {Self ::from_raw_work (ptr) }, + ); + } + +/// Reclaim a previously enqueued work item that will no longer run. +/// +/// # Safety /// -/// [`__enqueue`]: RawWorkItem::__enqueue -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ); +/// The provided `work_struct` pointer must satisfy the same requirements as +/// [`WorkItemPointer::from_raw_work`]. +#[inline] +unsafe fn cancel (ptr: *mut bindings::work_struct ) { +drop ( +// SAFETY: The requirements for `cancel` are exactly those of `from_raw_work`. +unsafe {Self ::from_raw_work (ptr) }, + ); + } }/// Defines the method that should be called when this work item is executed.
@@ -537,6 +564,29 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct {// the compiler does not complain that the `work` field is unused. unsafe {Opaque ::cast_into (core::ptr::addr_of!((*ptr).work)) } } + +/// Disables this work item and waits for queued/running executions to finish. +/// +/// # Note +/// +/// Should be called from a sleepable context if the work was last queued on a non-BH +/// workqueue. +#[inline] +pub fn disable_sync (&self) +where +T :WorkItem <ID >, + { +let ptr: *const Self = self; +// SAFETY: `self` points to a valid initialized work. +let raw_work =unsafe {Self ::raw_get (ptr) }; +// SAFETY: `raw_work` is a valid embedded `work_struct`. +if unsafe { bindings::disable_work_sync (raw_work) } { +// SAFETY: A `true` return means the work was pending and got canceled, so the queued +// ownership transfer performed by `__enqueue` must be reclaimed here and the work +// item will not subsequently run. +unsafe {T ::Pointer ::cancel (raw_work) }; + } + } }/// Declares that a type contains a [`Work<T, ID>`].
@@ -817,22 +867,22 @@ unsafe fn work_container_of(// - `Work::new` makes sure that `T::Pointer::run` is passed to `init_work_with_key`. // - Finally `Work` and `RawWorkItem` guarantee that the correct `Work` field // will be used because of the ID const generic bound. This makes sure that `T::raw_get_work` -// uses the correct offset for the `Work` field, and `Work::new` picks the correct -// implementation of `WorkItemPointer` for `Arc<T>`. +// uses the correct offset for the `Work` field, and `T::Pointer::from_raw_work` rebuilds the +// correct pointer type for `Arc<T>`. unsafe impl <T ,const ID :u64 >WorkItemPointer <ID >for Arc <T >where T :WorkItem <ID ,Pointer =Self >,T :HasWork <T ,ID >, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();// SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`. let ptr =unsafe {T ::work_container_of (ptr) };// SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership. -let arc =unsafe {Arc ::from_raw (ptr) }; - -T ::run (arc) +unsafe {Arc ::from_raw (ptr) } } }
@@ -887,7 +937,9 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for Pin<KBox<T>> T: WorkItem<ID, Pointer = Self>, T: HasWork<T, ID>, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();// SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`.
@@ -895,9 +947,7 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for Pin<KBox<T>>// SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership. let boxed =unsafe {KBox ::from_raw (ptr) };// SAFETY: The box was already pinned when it was enqueued. -let pinned =unsafe {Pin ::new_unchecked (boxed) }; - -T ::run (pinned) +unsafe {Pin ::new_unchecked (boxed) } } }
@@ -950,15 +1000,17 @@ unsafe impl<T, const ID: u64> RawDelayedWorkItem<ID> for Pin<KBox<T>>// - `Work::new` makes sure that `T::Pointer::run` is passed to `init_work_with_key`. // - Finally `Work` and `RawWorkItem` guarantee that the correct `Work` field // will be used because of the ID const generic bound. This makes sure that `T::raw_get_work` -// uses the correct offset for the `Work` field, and `Work::new` picks the correct -// implementation of `WorkItemPointer` for `ARef<T>`. +// uses the correct offset for the `Work` field, and `T::Pointer::from_raw_work` rebuilds the +// correct pointer type for `ARef<T>`. unsafe impl <T ,const ID :u64 >WorkItemPointer <ID >for ARef <T >where T :AlwaysRefCounted ,T :WorkItem <ID ,Pointer =Self >,T :HasWork <T ,ID >, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();
@@ -972,9 +1024,7 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for ARef<T>// SAFETY: This pointer comes from `ARef::into_raw` and we've been given // back ownership. -let aref =unsafe {ARef ::from_raw (ptr) }; - -T ::run (aref) +unsafe {ARef ::from_raw (ptr) } } }
Signature · 1 line
2.51.2
Gary Guo
reviewerQuoted 88 lines · Onur Özkan
Adds
Work::disable_sync()as a safe wrapper fordisable_work_sync().Drivers can use this during teardown to stop new queueing and wait for queued or running work to finish before dropping related resources.
Signed-off-by Onur Özkan <[email protected]>--- rust/kernel/workqueue.rs | 102 +++++++++++++++++++++++++++++---------- 1 file changed, 76 insertions(+), 26 deletions(-)rust/kernel/workqueue.rs +48
-10@@ -442,21 +442,48 @@ pub unsafe trait RawDelayedWorkItem<const ID: u64>: RawWorkItem<ID> {}/// /// # Safety /// -/// Implementers must ensure that [`__enqueue`] uses a `work_struct` initialized with the [`run`] -/// method of this trait as the function pointer. -/// -/// [`__enqueue`]: RawWorkItem::__enqueue -/// [`run`]: WorkItemPointer::run -pub unsafe trait WorkItemPointer <const ID :u64 >:RawWorkItem <ID > { +/// Implementers must ensure that [`WorkItemPointer::from_raw_work`] rebuilds the exact ownership +/// transferred by a successful [`RawWorkItem::__enqueue`] call. +pub unsafe trait WorkItemPointer <const ID :u64 >:RawWorkItem <ID > +Sized { +/// The work item type containing the embedded `work_struct`. +type Item :WorkItem <ID ,Pointer =Self > + ?Sized ; + +/// Rebuild this work item's pointer from its embedded `work_struct`. +/// +/// # Safety +/// +/// The provided `work_struct` pointer must originate from a previous call to +/// [`RawWorkItem::__enqueue`] where the `queue_work_on` closure returned true +/// and the pointer must still be valid. +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self ; +/// Run this work item. /// /// # Safety /// -/// The provided `work_struct` pointer must originate from a previous call to [`__enqueue`] -/// where the `queue_work_on` closure returned true, and the pointer must still be valid. +/// The provided `work_struct` pointer must satisfy the same requirements as +/// [`WorkItemPointer::from_raw_work`]. +#[inline] +unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { + <Self ::Item as WorkItem <ID >>::run ( +// SAFETY: The requirements for `run` are exactly those of `from_raw_work`. +unsafe {Self ::from_raw_work (ptr) }, + ); + } + +/// Reclaim a previously enqueued work item that will no longer run. +/// +/// # Safety /// -/// [`__enqueue`]: RawWorkItem::__enqueue -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ); +/// The provided `work_struct` pointer must satisfy the same requirements as +/// [`WorkItemPointer::from_raw_work`]. +#[inline] +unsafe fn cancel (ptr: *mut bindings::work_struct ) { +drop ( +// SAFETY: The requirements for `cancel` are exactly those of `from_raw_work`. +unsafe {Self ::from_raw_work (ptr) }, + ); + } }/// Defines the method that should be called when this work item is executed. @@ -537,6 +564,29 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct {// the compiler does not complain that the `work` field is unused. unsafe {Opaque ::cast_into (core::ptr::addr_of!((*ptr).work)) } } + +/// Disables this work item and waits for queued/running executions to finish. +/// +/// # Note +/// +/// Should be called from a sleepable context if the work was last queued on a non-BH +/// workqueue. +#[inline] +pub fn disable_sync (&self) +where +T :WorkItem <ID >,
rust/kernel/workqueue.rs pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { · line 587
Quoted 10 lines
rust/kernel/workqueue.rs +10
-0+ { +let ptr: *const Self = self; +// SAFETY: `self` points to a valid initialized work. +let raw_work =unsafe {Self ::raw_get (ptr) }; +// SAFETY: `raw_work` is a valid embedded `work_struct`. +if unsafe { bindings::disable_work_sync (raw_work) } { +// SAFETY: A `true` return means the work was pending and got canceled, so the queued +// ownership transfer performed by `__enqueue` must be reclaimed here and the work +// item will not subsequently run. +unsafe {T ::Pointer ::cancel (raw_work) };
I think have an explicit drop is clearer and remove the need of additional function in the trait.
// SAFETY: A `true` return means the work was pending and got canceled, so the queued
// ownership transfer performed by `__enqueue` is reclaimed here.
drop(unsafe { T::Pointer::from_raw_work(ptr) })The cancel name is confusing because this is called *after* the work has already been cancelled.
Best,
Gary
Quoted 88 lines
rust/kernel/workqueue.rs +18
-16+ } + } }/// Declares that a type contains a [`Work<T, ID>`]. @@ -817,22 +867,22 @@ unsafe fn work_container_of(// - `Work::new` makes sure that `T::Pointer::run` is passed to `init_work_with_key`. // - Finally `Work` and `RawWorkItem` guarantee that the correct `Work` field // will be used because of the ID const generic bound. This makes sure that `T::raw_get_work` -// uses the correct offset for the `Work` field, and `Work::new` picks the correct -// implementation of `WorkItemPointer` for `Arc<T>`. +// uses the correct offset for the `Work` field, and `T::Pointer::from_raw_work` rebuilds the +// correct pointer type for `Arc<T>`. unsafe impl <T ,const ID :u64 >WorkItemPointer <ID >for Arc <T >where T :WorkItem <ID ,Pointer =Self >,T :HasWork <T ,ID >, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();// SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`. let ptr =unsafe {T ::work_container_of (ptr) };// SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership. -let arc =unsafe {Arc ::from_raw (ptr) }; - -T ::run (arc) +unsafe {Arc ::from_raw (ptr) } } }@@ -887,7 +937,9 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for Pin<KBox<T>> T: WorkItem<ID, Pointer = Self>, T: HasWork<T, ID>, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();// SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`. @@ -895,9 +947,7 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for Pin<KBox<T>>// SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership. let boxed =unsafe {KBox ::from_raw (ptr) };// SAFETY: The box was already pinned when it was enqueued. -let pinned =unsafe {Pin ::new_unchecked (boxed) }; - -T ::run (pinned) +unsafe {Pin ::new_unchecked (boxed) } } }@@ -950,15 +1000,17 @@ unsafe impl<T, const ID: u64> RawDelayedWorkItem<ID> for Pin<KBox<T>>// - `Work::new` makes sure that `T::Pointer::run` is passed to `init_work_with_key`. // - Finally `Work` and `RawWorkItem` guarantee that the correct `Work` field // will be used because of the ID const generic bound. This makes sure that `T::raw_get_work` -// uses the correct offset for the `Work` field, and `Work::new` picks the correct -// implementation of `WorkItemPointer` for `ARef<T>`. +// uses the correct offset for the `Work` field, and `T::Pointer::from_raw_work` rebuilds the +// correct pointer type for `ARef<T>`. unsafe impl <T ,const ID :u64 >WorkItemPointer <ID >for ARef <T >where T :AlwaysRefCounted ,T :WorkItem <ID ,Pointer =Self >,T :HasWork <T ,ID >, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();@@ -972,9 +1024,7 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for ARef<T>// SAFETY: This pointer comes from `ARef::into_raw` and we've been given // back ownership. -let aref =unsafe {ARef ::from_raw (ptr) }; - -T ::run (aref) +unsafe {ARef ::from_raw (ptr) } } }
Onur Özkan
reviewerQuoted 103 lines · On Tue, 28 Apr 2026 12:42:59 +0100 Gary Guo <[email protected]> wrote:
Quoted 88 lines · Onur Özkan
Adds
Work::disable_sync()as a safe wrapper fordisable_work_sync().Drivers can use this during teardown to stop new queueing and wait for queued or running work to finish before dropping related resources.
Signed-off-by Onur Özkan <[email protected]>--- rust/kernel/workqueue.rs | 102 +++++++++++++++++++++++++++++---------- 1 file changed, 76 insertions(+), 26 deletions(-)rust/kernel/workqueue.rs +48
-10@@ -442,21 +442,48 @@ pub unsafe trait RawDelayedWorkItem<const ID: u64>: RawWorkItem<ID> {}/// /// # Safety /// -/// Implementers must ensure that [`__enqueue`] uses a `work_struct` initialized with the [`run`] -/// method of this trait as the function pointer. -/// -/// [`__enqueue`]: RawWorkItem::__enqueue -/// [`run`]: WorkItemPointer::run -pub unsafe trait WorkItemPointer <const ID :u64 >:RawWorkItem <ID > { +/// Implementers must ensure that [`WorkItemPointer::from_raw_work`] rebuilds the exact ownership +/// transferred by a successful [`RawWorkItem::__enqueue`] call. +pub unsafe trait WorkItemPointer <const ID :u64 >:RawWorkItem <ID > +Sized { +/// The work item type containing the embedded `work_struct`. +type Item :WorkItem <ID ,Pointer =Self > + ?Sized ; + +/// Rebuild this work item's pointer from its embedded `work_struct`. +/// +/// # Safety +/// +/// The provided `work_struct` pointer must originate from a previous call to +/// [`RawWorkItem::__enqueue`] where the `queue_work_on` closure returned true +/// and the pointer must still be valid. +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self ; +/// Run this work item. /// /// # Safety /// -/// The provided `work_struct` pointer must originate from a previous call to [`__enqueue`] -/// where the `queue_work_on` closure returned true, and the pointer must still be valid. +/// The provided `work_struct` pointer must satisfy the same requirements as +/// [`WorkItemPointer::from_raw_work`]. +#[inline] +unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { + <Self ::Item as WorkItem <ID >>::run ( +// SAFETY: The requirements for `run` are exactly those of `from_raw_work`. +unsafe {Self ::from_raw_work (ptr) }, + ); + } + +/// Reclaim a previously enqueued work item that will no longer run. +/// +/// # Safety /// -/// [`__enqueue`]: RawWorkItem::__enqueue -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ); +/// The provided `work_struct` pointer must satisfy the same requirements as +/// [`WorkItemPointer::from_raw_work`]. +#[inline] +unsafe fn cancel (ptr: *mut bindings::work_struct ) { +drop ( +// SAFETY: The requirements for `cancel` are exactly those of `from_raw_work`. +unsafe {Self ::from_raw_work (ptr) }, + ); + } }/// Defines the method that should be called when this work item is executed. @@ -537,6 +564,29 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct {// the compiler does not complain that the `work` field is unused. unsafe {Opaque ::cast_into (core::ptr::addr_of!((*ptr).work)) } } + +/// Disables this work item and waits for queued/running executions to finish. +/// +/// # Note +/// +/// Should be called from a sleepable context if the work was last queued on a non-BH +/// workqueue. +#[inline] +pub fn disable_sync (&self) +where +T :WorkItem <ID >,rust/kernel/workqueue.rs pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { · line 587
Quoted 10 lines
rust/kernel/workqueue.rs +10
-0+ { +let ptr: *const Self = self; +// SAFETY: `self` points to a valid initialized work. +let raw_work =unsafe {Self ::raw_get (ptr) }; +// SAFETY: `raw_work` is a valid embedded `work_struct`. +if unsafe { bindings::disable_work_sync (raw_work) } { +// SAFETY: A `true` return means the work was pending and got canceled, so the queued +// ownership transfer performed by `__enqueue` must be reclaimed here and the work +// item will not subsequently run. +unsafe {T ::Pointer ::cancel (raw_work) };I think have an explicit drop is clearer and remove the need of additional function in the trait.
Quoted 6 lines
// SAFETY: A `true` return means the work was pending and got canceled, so the queued // ownership transfer performed by `__enqueue` is reclaimed here. drop(unsafe { T::Pointer::from_raw_work(ptr) })The
cancelname is confusing because this is called *after* the work has already been cancelled.
Makes sense.
Thanks,
Onur
Quoted 93 lines
Best,
GaryQuoted 88 lines
rust/kernel/workqueue.rs +18
-16+ } + } }/// Declares that a type contains a [`Work<T, ID>`]. @@ -817,22 +867,22 @@ unsafe fn work_container_of(// - `Work::new` makes sure that `T::Pointer::run` is passed to `init_work_with_key`. // - Finally `Work` and `RawWorkItem` guarantee that the correct `Work` field // will be used because of the ID const generic bound. This makes sure that `T::raw_get_work` -// uses the correct offset for the `Work` field, and `Work::new` picks the correct -// implementation of `WorkItemPointer` for `Arc<T>`. +// uses the correct offset for the `Work` field, and `T::Pointer::from_raw_work` rebuilds the +// correct pointer type for `Arc<T>`. unsafe impl <T ,const ID :u64 >WorkItemPointer <ID >for Arc <T >where T :WorkItem <ID ,Pointer =Self >,T :HasWork <T ,ID >, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();// SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`. let ptr =unsafe {T ::work_container_of (ptr) };// SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership. -let arc =unsafe {Arc ::from_raw (ptr) }; - -T ::run (arc) +unsafe {Arc ::from_raw (ptr) } } }@@ -887,7 +937,9 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for Pin<KBox<T>> T: WorkItem<ID, Pointer = Self>, T: HasWork<T, ID>, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();// SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`. @@ -895,9 +947,7 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for Pin<KBox<T>>// SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership. let boxed =unsafe {KBox ::from_raw (ptr) };// SAFETY: The box was already pinned when it was enqueued. -let pinned =unsafe {Pin ::new_unchecked (boxed) }; - -T ::run (pinned) +unsafe {Pin ::new_unchecked (boxed) } } }@@ -950,15 +1000,17 @@ unsafe impl<T, const ID: u64> RawDelayedWorkItem<ID> for Pin<KBox<T>>// - `Work::new` makes sure that `T::Pointer::run` is passed to `init_work_with_key`. // - Finally `Work` and `RawWorkItem` guarantee that the correct `Work` field // will be used because of the ID const generic bound. This makes sure that `T::raw_get_work` -// uses the correct offset for the `Work` field, and `Work::new` picks the correct -// implementation of `WorkItemPointer` for `ARef<T>`. +// uses the correct offset for the `Work` field, and `T::Pointer::from_raw_work` rebuilds the +// correct pointer type for `ARef<T>`. unsafe impl <T ,const ID :u64 >WorkItemPointer <ID >for ARef <T >where T :AlwaysRefCounted ,T :WorkItem <ID ,Pointer =Self >,T :HasWork <T ,ID >, { -unsafe extern "C" fn run (ptr: *mut bindings::work_struct ) { +type Item =T ; + +unsafe fn from_raw_work (ptr: *mut bindings::work_struct ) ->Self {// The `__enqueue` method always uses a `work_struct` stored in a `Work<T, ID>`. let ptr = ptr.cast ::<Work <T ,ID >>();@@ -972,9 +1024,7 @@ unsafe impl<T, const ID: u64> WorkItemPointer<ID> for ARef<T>// SAFETY: This pointer comes from `ARef::into_raw` and we've been given // back ownership. -let aref =unsafe {ARef ::from_raw (ptr) }; - -T ::run (aref) +unsafe {ARef ::from_raw (ptr) } } }
kernel test robot
build botkernel test robot noticed the following build warnings:
Hi Onur,
kernel test robot noticed the following build warnings:
[auto build test WARNING on rust/rust-next]
[also build test WARNING on linus/master v7.1-rc1 next-20260430] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Onur-zkan/rust-add-Work-disable_sync/20260502-140019 base: https://github.com/Rust-for-Linux/linux rust-next patch link: https://lore.kernel.org/r/20260428104459.174602-2-work%40onurozkan.dev patch subject: [PATCH v1 1/1] rust: add Work::disable_sync config: x86_64-rhel-9.4-rust (https://download.01.org/0day-ci/archive/20260502/[email protected]/config) compiler: clang version 20.1.8 (https://github.com/llvm/llvm-project 87f0227cb60147a26a1eeb4fb06e3b505e9c7261) rustc: rustc 1.88.0 (6b00bc388 2025-06-23) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260502/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
>> warning: unresolved link to `run`
--> rust/kernel/workqueue.rs:436:62
|
436 | /// structs, you would implement [WorkItem] instead. The [run] method on
| ^^^ no item named run in scope
|
= help: to escape [ and ] characters, add '\' before them like \[ or \] = note: #[warn(rustdoc::broken_intra_doc_links)] on by default
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki