// SAFETY: Pointers from ARef::into_raw are valid and non-null.        let work_ptr = unsafe { T::raw_get_work(ptr.as_ptr()) };        // SAFETY: `raw_get_work` returns a pointer to a valid value.        let work_ptr = unsafe { Work::raw_get(work_ptr) };         if queue_work_on(work_ptr) {            Ok(())        } else {            // SAFETY: The work queue has not taken ownership of the pointer.            Err(unsafe { ARef::from_raw(ptr) })        }    }} // SAFETY: By the safety requirements of `HasDelayedWork`, the `work_struct` returned by methods in// `HasWork` provides a `work_struct` that is the `work` field of a `delayed_work`, and the rest of// the `delayed_work` has the same access rules as its `work` field.unsafe impl<T, const ID: u64> RawDelayedWorkItem<ID> for ARef<T>where    T: WorkItem<ID, Pointer = Self>,    T: HasDelayedWork<T, ID>,    T: AlwaysRefCounted,{} /// Returns the system work queue (`system_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) }} /// 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/// scheduling priority.pub fn system_highpri() -> &'static Queue {    // SAFETY: `system_highpri_wq` is a C global, always available.    unsafe { Queue::from_raw(bindings::system_highpri_wq) }} /// 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.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.////// 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.pub fn system_freezable() -> &'static Queue {    // SAFETY: `system_freezable_wq` is a C global, always available.    unsafe { Queue::from_raw(bindings::system_freezable_wq) }} /// Returns the system power-efficient work queue (`system_power_efficient_wq`).////// 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`].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) }} /// Returns the system freezable power-efficient work queue (`system_freezable_power_efficient_wq`).////// It is similar to the one returned by [`system_power_efficient`] except that is 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.pub fn system_freezable_power_efficient() -> &'static Queue {    // SAFETY: `system_freezable_power_efficient_wq` is a C global, always available.    unsafe { Queue::from_raw(bindings::system_freezable_power_efficient_wq) }} /// Returns the system bottom halves work queue (`system_bh_wq`).////// It is similar to the one returned by [`system`] 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.    unsafe { Queue::from_raw(bindings::system_bh_wq) }} /// Returns the system bottom halves high-priority work queue (`system_bh_highpri_wq`).////// It is similar to the one returned by [`system_bh`] but for work items which/// require higher scheduling priority.pub fn system_bh_highpri() -> &'static Queue {    // SAFETY: `system_bh_highpri_wq` is a C global, always available.    unsafe { Queue::from_raw(bindings::system_bh_highpri_wq) }}

Lines 1001–1114 of 1114. Previous lines