[PATCH v5 01/16] rust: pass module name to `Module::init`

Danilo Krummrich
2024-12-10T22:50:05Z

In a subsequent patch we introduce the `Registration` abstraction used
to register driver structures. Some subsystems require the module name on
driver registration (e.g. PCI in __pci_register_driver()), hence pass
the module name to `Module::init`.

Signed-off-by: Danilo Krummrich <dakr@kernel.org>
---
drivers/block/rnull.rs | 2 +-
rust/kernel/lib.rs | 14 ++++++++++----
rust/kernel/net/phy.rs | 2 +-
rust/kernel/sync/lock/global.rs | 6 ++++--
rust/macros/lib.rs | 6 ++++--
rust/macros/module.rs | 7 +++++--
samples/rust/rust_minimal.rs | 2 +-
samples/rust/rust_print_main.rs | 2 +-
8 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/drivers/block/rnull.rs b/drivers/block/rnull.rs
index 9cca05dcf772..8e859dda70c3 100644
--- a/drivers/block/rnull.rs
+++ b/drivers/block/rnull.rs
@@ -37,7 +37,7 @@ struct NullBlkModule {
}

impl kernel::Module for NullBlkModule {
- fn init(_module: &'static ThisModule) -> Result<Self> {
+ fn init(_name: &'static CStr, _module: &'static ThisModule) -> Result<Self> {
pr_info!("Rust null_blk loaded\n");
let tagset = Arc::pin_init(TagSet::new(1, 256, 1), flags::GFP_KERNEL)?;

diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index e1065a7551a3..686db6aa3323 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -90,7 +90,7 @@ pub trait Module: Sized + Sync + Send {
/// should do.
///
/// Equivalent to the `module_init` macro in the C API.
- fn init(module: &'static ThisModule) -> error::Result<Self>;
+ fn init(name: &'static str::CStr, module: &'static ThisModule) -> error::Result<Self>;
}

/// A module that is pinned and initialised in-place.
@@ -98,13 +98,19 @@ pub trait InPlaceModule: Sync + Send {
/// Creates an initialiser for the module.
///
/// It is called when the module is loaded.
- fn init(module: &'static ThisModule) -> impl init::PinInit<Self, error::Error>;
+ fn init(
+ name: &'static str::CStr,
+ module: &'static ThisModule,
+ ) -> impl init::PinInit<Self, error::Error>;
}

impl<T: Module> InPlaceModule for T {
- fn init(module: &'static ThisModule) -> impl init::PinInit<Self, error::Error> {
+ fn init(
+ name: &'static str::CStr,
+ module: &'static ThisModule,
+ ) -> impl init::PinInit<Self, error::Error> {
let initer = move |slot: *mut Self| {
- let m = <Self as Module>::init(module)?;
+ let m = <Self as Module>::init(name, module)?;

// SAFETY: `slot` is valid for write per the contract with `pin_init_from_closure`.
unsafe { slot.write(m) };
diff --git a/rust/kernel/net/phy.rs b/rust/kernel/net/phy.rs
index b89c681d97c0..0f41df2e6b96 100644
--- a/rust/kernel/net/phy.rs
+++ b/rust/kernel/net/phy.rs
@@ -903,7 +903,7 @@ struct Module {
[$($crate::net::phy::create_phy_driver::<$driver>()),+];

impl $crate::Module for Module {
- fn init(module: &'static ThisModule) -> Result<Self> {
+ fn init(_name: &'static CStr, module: &'static ThisModule) -> Result<Self> {
// SAFETY: The anonymous constant guarantees that nobody else can access
// the `DRIVERS` static. The array is used only in the C side.
let drivers = unsafe { &mut DRIVERS };
diff --git a/rust/kernel/sync/lock/global.rs b/rust/kernel/sync/lock/global.rs
index 480ee724e3cc..feff4638e20b 100644
--- a/rust/kernel/sync/lock/global.rs
+++ b/rust/kernel/sync/lock/global.rs
@@ -187,6 +187,7 @@ pub fn get_mut(&mut self) -> &mut T {
/// ```
/// # mod ex {
/// # use kernel::prelude::*;
+/// # use kernel::str;
/// kernel::sync::global_lock! {
/// // SAFETY: Initialized in module initializer before first use.
/// unsafe(uninit) static MY_COUNTER: Mutex<u32> = 0;
@@ -199,7 +200,7 @@ pub fn get_mut(&mut self) -> &mut T {
/// }
///
/// impl kernel::Module for MyModule {
-/// fn init(_module: &'static ThisModule) -> Result<Self> {
+/// fn init(_name: &'static str::CStr, _module: &'static ThisModule) -> Result<Self> {
/// // SAFETY: Called exactly once.
/// unsafe { MY_COUNTER.init() };
///
@@ -216,6 +217,7 @@ pub fn get_mut(&mut self) -> &mut T {
/// # mod ex {
/// # use kernel::prelude::*;
/// use kernel::sync::{GlobalGuard, GlobalLockedBy};
+/// # use kernel::str;
///
/// kernel::sync::global_lock! {
/// // SAFETY: Initialized in module initializer before first use.
@@ -239,7 +241,7 @@ pub fn get_mut(&mut self) -> &mut T {
/// }
///
/// impl kernel::Module for MyModule {
-/// fn init(_module: &'static ThisModule) -> Result<Self> {
+/// fn init(_name: &'static str::CStr, _module: &'static ThisModule) -> Result<Self> {
/// // SAFETY: Called exactly once.
/// unsafe { MY_MUTEX.init() };
///
diff --git a/rust/macros/lib.rs b/rust/macros/lib.rs
index 4ab94e44adfe..d669f9cd1726 100644
--- a/rust/macros/lib.rs
+++ b/rust/macros/lib.rs
@@ -32,6 +32,7 @@
///
/// ```
/// use kernel::prelude::*;
+/// use kernel::str;
///
/// module!{
/// type: MyModule,
@@ -45,7 +46,7 @@
/// struct MyModule(i32);
///
/// impl kernel::Module for MyModule {
-/// fn init(_module: &'static ThisModule) -> Result<Self> {
+/// fn init(_name: &'static str::CStr, _module: &'static ThisModule) -> Result<Self> {
/// let foo: i32 = 42;
/// pr_info!("I contain: {}\n", foo);
/// Ok(Self(foo))
@@ -65,6 +66,7 @@
///
/// ```
/// use kernel::prelude::*;
+/// use kernel::str;
///
/// module!{
/// type: MyDeviceDriverModule,
@@ -78,7 +80,7 @@
/// struct MyDeviceDriverModule;
///
/// impl kernel::Module for MyDeviceDriverModule {
-/// fn init(_module: &'static ThisModule) -> Result<Self> {
+/// fn init(_name: &'static str::CStr, _module: &'static ThisModule) -> Result<Self> {
/// Ok(Self)
/// }
/// }
diff --git a/rust/macros/module.rs b/rust/macros/module.rs
index 2587f41b0d39..1f14ef55341a 100644
--- a/rust/macros/module.rs
+++ b/rust/macros/module.rs
@@ -333,8 +333,11 @@ mod __module_init {{
///
/// This function must only be called once.
unsafe fn __init() -> kernel::ffi::c_int {{
- let initer =
- <{type_} as kernel::InPlaceModule>::init(&super::super::THIS_MODULE);
+ let initer = <{type_} as kernel::InPlaceModule>::init(
+ kernel::c_str!(\"{name}\"),
+ &super::super::THIS_MODULE
+ );
+
// SAFETY: No data race, since `__MOD` can only be accessed by this module
// and there only `__init` and `__exit` access it. These functions are only
// called once and `__exit` cannot be called before or during `__init`.
diff --git a/samples/rust/rust_minimal.rs b/samples/rust/rust_minimal.rs
index 4aaf117bf8e3..1577dc34e563 100644
--- a/samples/rust/rust_minimal.rs
+++ b/samples/rust/rust_minimal.rs
@@ -17,7 +17,7 @@ struct RustMinimal {
}

impl kernel::Module for RustMinimal {
- fn init(_module: &'static ThisModule) -> Result<Self> {
+ fn init(_name: &'static CStr, _module: &'static ThisModule) -> Result<Self> {
pr_info!("Rust minimal sample (init)\n");
pr_info!("Am I built-in? {}\n", !cfg!(MODULE));

diff --git a/samples/rust/rust_print_main.rs b/samples/rust/rust_print_main.rs
index aed90a6feecf..0853d767439b 100644
--- a/samples/rust/rust_print_main.rs
+++ b/samples/rust/rust_print_main.rs
@@ -41,7 +41,7 @@ fn arc_print() -> Result {
}

impl kernel::Module for RustPrint {
- fn init(_module: &'static ThisModule) -> Result<Self> {
+ fn init(_name: &'static CStr, _module: &'static ThisModule) -> Result<Self> {
pr_info!("Rust printing macros sample (init)\n");

pr_emerg!("Emergency message (level 0) without args\n");
--
2.47.0