lkml.org 
[lkml]   [2023]   [Jun]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    SubjectRe: [PATCH v2 4/8] rust: workqueue: define built-in queues
    On Thu,  1 Jun 2023 13:49:42 +0000
    Alice Ryhl <aliceryhl@google.com> wrote:

    > From: Wedson Almeida Filho <walmeida@microsoft.com>
    >
    > We provide these methods because it lets us access these queues from
    > Rust without using unsafe code.
    >
    > These methods return `&'static Queue`. References annotated with the
    > 'static lifetime are used when the referent will stay alive forever.
    > That is ok for these queues because they are global variables and cannot
    > be destroyed.
    >
    > Signed-off-by: Wedson Almeida Filho <walmeida@microsoft.com>
    > Co-developed-by: Alice Ryhl <aliceryhl@google.com>
    > Signed-off-by: Alice Ryhl <aliceryhl@google.com>
    > Reviewed-by: Martin Rodriguez Reboredo <yakoyoku@gmail.com>

    This looks fine to me, so:

    Reviewed-by: Gary Guo <gary@garyguo.net>

    Just one question about style: would people prefer:

    kernel::workqueue::system().enqueue(...)

    or

    use kernel::workqueue::Queue;
    Queue::system().enqueue(...)

    ?

    > ---
    > rust/kernel/workqueue.rs | 65 ++++++++++++++++++++++++++++++++++++++++
    > 1 file changed, 65 insertions(+)
    >
    > diff --git a/rust/kernel/workqueue.rs b/rust/kernel/workqueue.rs
    > index 9c630840039b..e37820f253f6 100644
    > --- a/rust/kernel/workqueue.rs
    > +++ b/rust/kernel/workqueue.rs
    > @@ -105,3 +105,68 @@ unsafe fn __enqueue<F>(self, queue_work_on: F) -> Self::EnqueueOutput
    > where
    > F: FnOnce(*mut bindings::work_struct) -> bool;
    > }
    > +
    > +/// 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.
    > +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.
    > +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) }
    > +}

    \
     
     \ /
      Last update: 2023-06-01 19:31    [W:2.683 / U:0.000 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site