[PATCH v2] rust: workqueue: replace deprecated system_wq with system_{percpu,dfl}_wq

Patch content 6 changed files

From: Danilo Krummrich <dakr@kernel.org> system_wq is deprecated and triggers a runtime warning: 	[    0.857414] workqueue: work func ...WorkItemPointerKy0_E3runB7_ enqueued on deprecated workqueue. Use system_{percpu|dfl}_wq instead. Replace system() with system_percpu() and system_dfl(), to match theprevious behavior of the deprecated system() and convert doc examplesand tests to system_dfl(). system_unbound_wq is deprecated in the same way, in favor ofsystem_dfl_wq. Since system_unbound() has no users, just remove it aswell. Fixes: 64d8eae3f895 ("workqueue: Add warnings and fallback if system_{unbound}_wq is used")Signed-off-by: Danilo Krummrich <dakr@kernel.org>Reviewed-by: Daniel Almeida <daniel.almeida@collabora.com>Reviewed-by: Boqun Feng <boqun@kernel.org>Reviewed-by: Dongliang Mu <dzm91@hust.edu.cn>Signed-off-by: Alice Ryhl <aliceryhl@google.com>---This patch was previously sent as part of other workqueue series [1][2].However it's a fix that is independent of those series, so it's sent onits own here. [1] https://lore.kernel.org/all/20260726223613.1242940-3-dakr@kernel.org[2] https://lore.kernel.org/all/20260807165252.3849875-2-dakr@kernel.org---Changes in v2:- Also remove system_unbound(), which is deprecated in the same way  and has no users. (Gary)- Collect Reviewed-by from Boqun and Dongliang.- Link to v1: https://lore.kernel.org/r/20261013-rust-workqueue-system-fix-v1-1-e9ec616e402b@google.com Changes since [2]:- Rebase on v7.3-rc7 and also convert the new SpinLockIrq KUnit test,  which calls workqueue::system() and otherwise fails to build.- Add Fixes: tag for the commit that made system_wq warn.- Collect Reviewed-by from Daniel.--- Documentation/rust/testing.rst                    |  2 +- Documentation/translations/zh_CN/rust/testing.rst |  2 +- drivers/android/binder/process.rs                 |  4 +- rust/kernel/sync/completion.rs                    |  2 +- rust/kernel/sync/lock/spinlock.rs                 |  2 +- rust/kernel/workqueue.rs                          | 52 ++++++++++++----------- 6 files changed, 33 insertions(+), 31 deletions(-) diff --git a/Documentation/rust/testing.rst b/Documentation/rust/testing.rstindex e3943aceceb9..73046523a9a2 100644--- a/Documentation/rust/testing.rst+++ b/Documentation/rust/testing.rst@@ -97,7 +97,7 @@ operator are also supported as usual, e.g.:  	/// ``` 	/// # use kernel::{spawn_work_item, workqueue};-	/// spawn_work_item!(workqueue::system(), || pr_info!("x\n"))?;+	/// spawn_work_item!(workqueue::system_dfl(), || pr_info!("x\n"))?; 	/// # Ok::<(), Error>(()) 	/// ``` diff --git a/Documentation/translations/zh_CN/rust/testing.rst b/Documentation/translations/zh_CN/rust/testing.rstindex 6747d0012991..fdd88fa2fe40 100644--- a/Documentation/translations/zh_CN/rust/testing.rst+++ b/Documentation/translations/zh_CN/rust/testing.rst@@ -93,7 +93,7 @@ KUnit 测试即文档测试  	/// ``` 	/// # use kernel::{spawn_work_item, workqueue};-	/// spawn_work_item!(workqueue::system(), || pr_info!("x\n"))?;+	/// spawn_work_item!(workqueue::system_dfl(), || pr_info!("x\n"))?; 	/// # Ok::<(), Error>(()) 	/// ``` diff --git a/drivers/android/binder/process.rs b/drivers/android/binder/process.rsindex 5372bfbd93b3..de5bca7f9fc7 100644--- a/drivers/android/binder/process.rs+++ b/drivers/android/binder/process.rs@@ -1728,7 +1728,7 @@ pub(crate) fn release(this: Arc<Process>, _file: &File) {         if should_schedule {             // Ignore failures to schedule to the workqueue. Those just mean that we're already             // scheduled for execution.-            let _ = workqueue::system().enqueue(this);+            let _ = workqueue::system_percpu().enqueue(this);         }          drop(binderfs_file);@@ -1745,7 +1745,7 @@ pub(crate) fn flush(this: ArcBorrow<'_, Process>) -> Result {         if should_schedule {             // Ignore failures to schedule to the workqueue. Those just mean that we're already             // scheduled for execution.-            let _ = workqueue::system().enqueue(Arc::from(this));+            let _ = workqueue::system_percpu().enqueue(Arc::from(this));         }         Ok(())     }diff --git a/rust/kernel/sync/completion.rs b/rust/kernel/sync/completion.rsindex 35ff049ff078..1771bfc0ade2 100644--- a/rust/kernel/sync/completion.rs+++ b/rust/kernel/sync/completion.rs@@ -38,7 +38,7 @@ ///             done <- Completion::new(), ///         }), GFP_KERNEL)?; ///-///         let _ = workqueue::system().enqueue(this.clone());+///         let _ = workqueue::system_dfl().enqueue(this.clone()); /// ///         Ok(this) ///     }diff --git a/rust/kernel/sync/lock/spinlock.rs b/rust/kernel/sync/lock/spinlock.rsindex aafc80125f59..92ad133262b6 100644--- a/rust/kernel/sync/lock/spinlock.rs+++ b/rust/kernel/sync/lock/spinlock.rs@@ -450,7 +450,7 @@ fn run(this: Arc<Self>) {     fn spinlock_irq_condvar() -> Result {         let testdata = Test::new()?; -        let _ = workqueue::system().enqueue(testdata.clone());+        let _ = workqueue::system_dfl().enqueue(testdata.clone());          // Let the updater know when we're ready to wait         let mut state = testdata.state.lock();diff --git a/rust/kernel/workqueue.rs b/rust/kernel/workqueue.rsindex 7e253b6f299c..a872f9fffb90 100644--- a/rust/kernel/workqueue.rs+++ b/rust/kernel/workqueue.rs@@ -67,7 +67,7 @@ //! /// This method will enqueue the struct for execution on the system workqueue, where its value //! /// will be printed. //! fn print_later(val: Arc<MyStruct>) {-//!     let _ = workqueue::system().enqueue(val);+//!     let _ = workqueue::system_dfl().enqueue(val); //! } //! # print_later(MyStruct::new(42).unwrap()); //! ```@@ -121,11 +121,11 @@ //! } //! //! fn print_1_later(val: Arc<MyStruct>) {-//!     let _ = workqueue::system().enqueue::<Arc<MyStruct>, 1>(val);+//!     let _ = workqueue::system_dfl().enqueue::<Arc<MyStruct>, 1>(val); //! } //! //! fn print_2_later(val: Arc<MyStruct>) {-//!     let _ = workqueue::system().enqueue::<Arc<MyStruct>, 2>(val);+//!     let _ = workqueue::system_dfl().enqueue::<Arc<MyStruct>, 2>(val); //! } //! # print_1_later(MyStruct::new(24, 25).unwrap()); //! # print_2_later(MyStruct::new(41, 42).unwrap());@@ -171,13 +171,13 @@ //! /// This method will enqueue the struct for execution on the system workqueue, where its value //! /// will be printed 12 jiffies later. //! fn print_later(val: Arc<MyStruct>) {-//!     let _ = workqueue::system().enqueue_delayed(val, 12);+//!     let _ = workqueue::system_dfl().enqueue_delayed(val, 12); //! } //! //! /// It is also possible to use the ordinary `enqueue` method together with `DelayedWork`. This //! /// is equivalent to calling `enqueue_delayed` with a delay of zero. //! fn print_now(val: Arc<MyStruct>) {-//!     let _ = workqueue::system().enqueue(val);+//!     let _ = workqueue::system_dfl().enqueue(val); //! } //! # print_later(MyStruct::new(42).unwrap()); //! # print_now(MyStruct::new(42).unwrap());@@ -1024,20 +1024,32 @@ unsafe impl<T, const ID: u64> RawDelayedWorkItem<ID> for ARef<T> { } -/// Returns the system work queue (`system_wq`).+/// Returns the system per-cpu work queue (`system_percpu_wq`). /// /// It is the one used by `schedule[_delayed]_work[_on]()`. Multi-CPU multi-threaded. There are /// users which expect relatively short queue flush time. /// /// Callers shouldn't queue work items which can run for too long.-pub fn system() -> &'static Queue {-    // SAFETY: `system_wq` is a C global, always available.-    unsafe { Queue::from_raw(bindings::system_wq) }+#[inline]+pub fn system_percpu() -> &'static Queue {+    // SAFETY: `system_percpu_wq` is a C global, always available.+    unsafe { Queue::from_raw(bindings::system_percpu_wq) }+}++/// Returns the system default (unbound) work queue (`system_dfl_wq`).+///+/// Workers are not bound to any specific CPU, not concurrency managed, and all queued work items+/// are executed immediately as long as `max_active` limit is not reached and resources are+/// available.+#[inline]+pub fn system_dfl() -> &'static Queue {+    // SAFETY: `system_dfl_wq` is a C global, always available.+    unsafe { Queue::from_raw(bindings::system_dfl_wq) } }  /// Returns the system high-priority work queue (`system_highpri_wq`). ///-/// It is similar to the one returned by [`system`] but for work items which require higher+/// It is similar to the one returned by [`system_percpu`] but for work items which require higher /// scheduling priority. pub fn system_highpri() -> &'static Queue {     // SAFETY: `system_highpri_wq` is a C global, always available.@@ -1046,26 +1058,16 @@ pub fn system_highpri() -> &'static Queue {  /// Returns the system work queue for potentially long-running work items (`system_long_wq`). ///-/// It is similar to the one returned by [`system`] but may host long running work items. Queue-/// flushing might take relatively long.+/// It is similar to the one returned by [`system_percpu`] but may host long running work items.+/// Queue flushing might take relatively long. pub fn system_long() -> &'static Queue {     // SAFETY: `system_long_wq` is a C global, always available.     unsafe { Queue::from_raw(bindings::system_long_wq) } } -/// Returns the system unbound work queue (`system_unbound_wq`).-///-/// Workers are not bound to any specific CPU, not concurrency managed, and all queued work items-/// are executed immediately as long as `max_active` limit is not reached and resources are-/// available.-pub fn system_unbound() -> &'static Queue {-    // SAFETY: `system_unbound_wq` is a C global, always available.-    unsafe { Queue::from_raw(bindings::system_unbound_wq) }-}- /// Returns the system freezable work queue (`system_freezable_wq`). ///-/// It is equivalent to the one returned by [`system`] except that it's freezable.+/// It is equivalent to the one returned by [`system_percpu`] except that it's freezable. /// /// A freezable workqueue participates in the freeze phase of the system suspend operations. Work /// items on the workqueue are drained and no new work item starts execution until thawed.@@ -1078,7 +1080,7 @@ pub fn system_freezable() -> &'static Queue { /// /// It is inclined towards saving power and is converted to "unbound" variants if the /// `workqueue.power_efficient` kernel parameter is specified; otherwise, it is similar to the one-/// returned by [`system`].+/// returned by [`system_percpu`]. pub fn system_power_efficient() -> &'static Queue {     // SAFETY: `system_power_efficient_wq` is a C global, always available.     unsafe { Queue::from_raw(bindings::system_power_efficient_wq) }@@ -1097,7 +1099,7 @@ pub fn system_freezable_power_efficient() -> &'static Queue {  /// Returns the system bottom halves work queue (`system_bh_wq`). ///-/// It is similar to the one returned by [`system`] but for work items which+/// It is similar to the one returned by [`system_percpu`] but for work items which /// need to run from a softirq context. pub fn system_bh() -> &'static Queue {     // SAFETY: `system_bh_wq` is a C global, always available. ---base-commit: 24a19b953e2a3d0ea5a8c4951a0ab8f32720c907change-id: 20261013-rust-workqueue-system-fix-5f9020c90f27 Best regards,-- Alice Ryhl <aliceryhl@google.com>