Commit e283ee23 authored by Alice Ryhl's avatar Alice Ryhl Committed by Miguel Ojeda
Browse files

rust: kernel: add reexports for macros 



Currently, all macros are reexported with #[macro_export] only, which
means that to access `new_work!` from the workqueue, you need to import
it from the path `kernel::new_work` instead of importing it from the
workqueue module like all other items in the workqueue. By adding
reexports of the macros, it becomes possible to import the macros from
the correct modules.

It's still possible to import the macros from the root, but I don't
think we can do anything about that.

There is no functional change. This is merely a code cleanliness
improvement.

Signed-off-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarTrevor Gross <tmgross@umich.edu>
Reviewed-by: default avatarMartin Rodriguez Reboredo <yakoyoku@gmail.com>
Tested-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Link: https://lore.kernel.org/r/20240129145837.1419880-1-aliceryhl@google.com


[ Removed new `use kernel::prelude::*`s, reworded title. ]
Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent ed6d0bed

rust/kernel/init.rs

+3 −3
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ 
//!

//! ```rust

//! # #![allow(clippy::disallowed_names)]

//! use kernel::{prelude::*, sync::Mutex, new_mutex};

//! use kernel::sync::{new_mutex, Mutex};

//! # use core::pin::Pin;

//! #[pin_data]

//! struct Foo {
@@ -56,7 +56,7 @@ 
//!

//! ```rust

//! # #![allow(clippy::disallowed_names)]

//! # use kernel::{prelude::*, sync::Mutex, new_mutex};

//! # use kernel::sync::{new_mutex, Mutex};

//! # use core::pin::Pin;

//! # #[pin_data]

//! # struct Foo {
@@ -79,7 +79,7 @@ 
//! above method only works for types where you can access the fields.

//!

//! ```rust

//! # use kernel::{new_mutex, sync::{Arc, Mutex}};

//! # use kernel::sync::{new_mutex, Arc, Mutex};

//! let mtx: Result<Arc<Mutex<usize>>> = Arc::pin_init(new_mutex!(42, "example::mtx"));

//! ```

//!

rust/kernel/sync.rs

+3 −2
Original line number Diff line number Diff line
@@ -13,8 +13,9 @@ 
mod locked_by;



pub use arc::{Arc, ArcBorrow, UniqueArc};

pub use condvar::{CondVar, CondVarTimeoutResult};

pub use lock::{mutex::Mutex, spinlock::SpinLock};

pub use condvar::{new_condvar, CondVar, CondVarTimeoutResult};

pub use lock::mutex::{new_mutex, Mutex};

pub use lock::spinlock::{new_spinlock, SpinLock};

pub use locked_by::LockedBy;



/// Represents a lockdep class. It's a wrapper around C's `lock_class_key`.

rust/kernel/sync/condvar.rs

+2 −2
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ macro_rules! new_condvar { 
        $crate::sync::CondVar::new($crate::optional_name!($($name)?), $crate::static_lock_class!())

    };

}

pub use new_condvar;



/// A conditional variable.

///
@@ -44,8 +45,7 @@ macro_rules! new_condvar { 
/// The following is an example of using a condvar with a mutex:

///

/// ```

/// use kernel::sync::{CondVar, Mutex};

/// use kernel::{new_condvar, new_mutex};

/// use kernel::sync::{new_condvar, new_mutex, CondVar, Mutex};

///

/// #[pin_data]

/// pub struct Example {

rust/kernel/sync/lock/mutex.rs

+2 −1
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ macro_rules! new_mutex { 
            $inner, $crate::optional_name!($($name)?), $crate::static_lock_class!())

    };

}

pub use new_mutex;



/// A mutual exclusion primitive.

///
@@ -35,7 +36,7 @@ macro_rules! new_mutex { 
/// contains an inner struct (`Inner`) that is protected by a mutex.

///

/// ```

/// use kernel::{init::InPlaceInit, init::PinInit, new_mutex, pin_init, sync::Mutex};

/// use kernel::sync::{new_mutex, Mutex};

///

/// struct Inner {

///     a: u32,

rust/kernel/sync/lock/spinlock.rs

+2 −1
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ macro_rules! new_spinlock { 
            $inner, $crate::optional_name!($($name)?), $crate::static_lock_class!())

    };

}

pub use new_spinlock;



/// A spinlock.

///
@@ -33,7 +34,7 @@ macro_rules! new_spinlock { 
/// contains an inner struct (`Inner`) that is protected by a spinlock.

///

/// ```

/// use kernel::{init::InPlaceInit, init::PinInit, new_spinlock, pin_init, sync::SpinLock};

/// use kernel::sync::{new_spinlock, SpinLock};

///

/// struct Inner {

///     a: u32,