Skip to contentSkip to conversation

Fix missing fops.owner in Rust DRM/misc abstractions

PATCH Superseded Alvin Sun 3 participants 16 messages May 21 – Jun 22

Subsystems (13)

v2 of 10 Superseded Latest is v10 →

lore
Share & tools
lore

Alvin Sun

author
#0 lore raw

v2 cover Fix missing fops.owner in Rust DRM/misc abstractions

During tyr debugfs development, a kernel NULL pointer dereference was encountered after rmmod tyr while gnome-shell still held /dev/card1 open:

```
  [158827.868132] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000000
  [158827.868918] Mem abort info:
  [158827.869177]   ESR = 0x0000000086000004
  [158827.869519]   EC = 0x21: IABT (current EL), IL = 32 bits
  [158827.870000]   SET = 0, FnV = 0
  [158827.870281]   EA = 0, S1PTW = 0
  [158827.870571]   FSC = 0x04: level 0 translation fault
  [158827.871043] user pgtable: 4k pages, 48-bit VAs, pgdp=0000000108dec000
  [158827.871623] [0000000000000000] pgd=0000000000000000, p4d=0000000000000000
  [158827.872242] Internal error: Oops: 0000000086000004 [#1]  SMP
  [158827.872246] Modules linked in: tyr sunrpc snd_soc_simple_card rk805_pwrkey snd_soc_simple_card_utils rtw88_8822bu display_connector rtw88_usb rtw88_8822b snd_soc_rockchip_i2s_tdm snd_soc_hdmi_codec
  rtw88_core]
  [158827.872337] CPU: 4 UID: 1000 PID: 11276 Comm: gnome-s:disk$0 Tainted: G                 N  7.1.0-rc1+ #331 PREEMPT
  [158827.880534] Tainted: [N]=TEST
  [158827.880535] Hardware name: FriendlyElec NanoPi R6C/NanoPi R6C, BIOS v1.1 04/09/2025
  [158827.880538] pstate: 60400009 (nZCv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--)
  [158827.880542] pc : 0x0
  [158827.880547] lr : _RNvNtCs257m05FHVbX_3tyr2vm8pt_unmap+0x8c/0x12c [tyr]
  [158827.880578] sp : ffff800083c236b0
  [158827.880579] x29: ffff800083c236d0 x28: ffff00013f8a0000 x27: 0000000000000000
  [158827.880585] x26: 000000000000007c x25: ffff000108e6ed80 x24: 0000000000401000
  [158827.880590] x23: 0000000000000000 x22: 0000000040000000 x21: 0000000000001000
  [158827.880595] x20: ffff00010f778138 x19: 0000000000400000 x18: 00000000ffffffff
  [158827.880600] x17: 000000040044ffff x16: 045000f2b5503510 x15: 0720072007200720
  [158827.880606] x14: 0720072007200720 x13: 0000000000401000 x12: 0000000000400000
  [158827.880611] x11: ffff800083c239d0 x10: ffff000141e4fd88 x9 : 0000000000000000
  [158827.880615] x8 : 0000000000000000 x7 : 0000000000000000 x6 : 0000000000400000
  [158827.880620] x5 : ffff00013f8a0000 x4 : 0000000000000000 x3 : 0000000000000001
  [158827.880625] x2 : 0000000000001000 x1 : 0000000000400000 x0 : ffff00010f778138
  [158827.880630] Call trace:
  [158827.880632]  0x0 (P)
  [158827.880635]  _RNvXs6_NtCs257m05FHVbX_3tyr2vmNtB5_9GpuVmDataNtNtNtCsgmSOfgXi5CZ_6kernel3drm5gpuvm11DriverGpuVm13sm_step_unmap+0x3c/0x120 [tyr]
  [158827.891166]  _RNvMs4_NtNtNtCsgmSOfgXi5CZ_6kernel3drm5gpuvm6sm_opsINtB7_5GpuVmNtNtCs257m05FHVbX_3tyr2vm9GpuVmDataE13sm_step_unmapB13_+0x18/0x34 [tyr]
  [158827.891187]  op_unmap_cb+0x78/0xb0
  [158827.891196]  __drm_gpuvm_sm_unmap+0x18c/0x1b4
  [158827.891204]  drm_gpuvm_sm_unmap+0x38/0x4c
  [158827.891209]  _RNvMs5_NtCs257m05FHVbX_3tyr2vmNtB5_2Vm7exec_op+0x1cc/0x254 [tyr]
  [158827.894085]  _RNvMs5_NtCs257m05FHVbX_3tyr2vmNtB5_2Vm11unmap_range+0x124/0x188 [tyr]
  [158827.894105]  _RINvNtCs5hGKnPbRUFW_4core3ptr13drop_in_placeNtNtCs257m05FHVbX_3tyr3gem8KernelBoEBK_+0x44/0xd8 [tyr]
  [158827.894125]  _RINvNtCs5hGKnPbRUFW_4core3ptr13drop_in_placeINtNtNtCsgmSOfgXi5CZ_6kernel5alloc4kvec3VecNtNtCs257m05FHVbX_3tyr2fw7SectionNtNtBL_9allocator7KmallocEEB1r_+0x3c/0x100 [tyr]
  [158827.894147]  _RINvNtCs5hGKnPbRUFW_4core3ptr13drop_in_placeINtNtNtCsgmSOfgXi5CZ_6kernel4sync3arc3ArcNtNtCs257m05FHVbX_3tyr2fw8FirmwareEEB1p_+0x94/0x190 [tyr]
  [158827.894167]  _RNvMs4_NtNtCsgmSOfgXi5CZ_6kernel3drm6deviceINtB5_6DeviceNtNtCs257m05FHVbX_3tyr6driver12TyrDrmDriverE7releaseBW_+0x30/0x98 [tyr]
  [158827.899550]  drm_dev_put.part.0+0x88/0xc0
  [158827.899557]  drm_minor_release+0x18/0x28
  [158827.899562]  drm_release+0x144/0x170
  [158827.899567]  __fput+0xe4/0x30c
  [158827.899573]  ____fput+0x14/0x20
  [158827.899579]  task_work_run+0x7c/0xe8
  [158827.899586]  do_exit+0x2a8/0xac4
  [158827.899590]  do_group_exit+0x34/0x90
  [158827.899594]  get_signal+0xaac/0xabc
  [158827.899599]  arch_do_signal_or_restart+0x90/0x3e8
  [158827.899606]  exit_to_user_mode_loop+0x140/0x1d0
  [158827.899613]  el0_svc+0x2f4/0x2f8
  [158827.899620]  el0t_64_sync_handler+0xa0/0xe4
  [158827.899627]  el0t_64_sync+0x198/0x19c
  [158827.899632] ---[ end trace 0000000000000000 ]---
```

The root cause: fops.owner was NULL in Rust DRM drivers, so the kernel never blocked module unloading while file descriptors were open. This leads to use-after-free when drm_release (or other fops) is called on freed module code.

The series moves THIS_MODULE into the ModuleMetadata as a const, threads it through #[vtable] to set fops.owner in DRM/miscdevice, and updates configfs and rnull to use LocalModule::THIS_MODULE.

---
Changes in v2:
- Merged old static THIS_MODULE and v1's MODULE_PTR into a single ModuleMetadata::THIS_MODULE const
- #[vtable] macro now auto-inserts type ThisModule, removing all per-driver manual patches from v1
- Added configfs & rnull usage site updates and doctest LocalModule fallback
- Link to v1: https://lore.kernel.org/r/[email protected]

---
Alvin Sun (7):
rust: module: add THIS_MODULE const to ModuleMetadata trait
rust: macros: auto-insert ThisModule in #[vtable]
rust: doctest: add LocalModule fallback for #[vtable] ThisModule
rust: drm: set fops.owner from driver module pointer
rust: miscdevice: set fops.owner from driver module pointer
rust: configfs: use LocalModule for THIS_MODULE
block: rnull: use LocalModule for THIS_MODULE

 drivers/block/rnull/configfs.rs |  6 ++----
 rust/kernel/configfs.rs         |  8 +++++---
 rust/kernel/drm/device.rs       |  3 ++-
 rust/kernel/drm/gem/mod.rs      |  4 ++--
 rust/kernel/lib.rs              |  3 +++
 rust/kernel/miscdevice.rs       |  2 ++
 rust/macros/lib.rs              |  6 ++++++
 rust/macros/module.rs           | 34 +++++++++++++++++-----------------
 rust/macros/vtable.rs           | 38 +++++++++++++++++++++++++++++++++++++-
 scripts/rustdoc_test_gen.rs     | 16 ++++++++++++++++
 10 files changed, 92 insertions(+), 28 deletions(-)

---
base-commit: aa61612ab641d7d62b0b6889f2c7c9251489f6e3
change-id: 20260519-fix-fops-owner-e3a77bb27c6c
prerequisite-change-id: 20260519-miscdev-use-format-9ab7e83b1c11:v3
prerequisite-patch-id: 405b334ff0d48ad350014f05a2321bdbaa025400
prerequisite-patch-id: 604b631c81d5423f4ebb2e12ba2d22e9ce371bfc
prerequisite-patch-id: cb550d94cefe01920e0d3ced2b2bcbecd76f3907
prerequisite-patch-id: 3bc830839742591460cb86d9472c04f4686dc600
prerequisite-patch-id: 571058244bc8c7088638d2e3225713011246c7e9
prerequisite-patch-id: 347c5a3c6dbef9832bfce8419fc23e6e08ba477f
prerequisite-patch-id: 3e202d988b56b88446f7535e90d3f00cf5f15701

Best regards,

Signature · 1 line
Alvin Sun <[email protected]>
author
#1 lore raw

PATCH v2 1/7 rust: module: add `THIS_MODULE` const to `ModuleMetadata` trait

Add a THIS_MODULE const to the ModuleMetadata trait so that modules can provide their ThisModule pointer usable in const contexts such as static file_operations.

Move the THIS_MODULE static from the module! macro into the ModuleMetadata impl, and update __init to use LocalModule::THIS_MODULE instead.

---
 rust/kernel/lib.rs    |  3 +++
 rust/macros/module.rs | 34 +++++++++++++++++-----------------
 2 files changed, 20 insertions(+), 17 deletions(-)
rust/kernel/lib.rs +3 -0
index b72b2fbe046d6..f0cf0705d9697 100644
@@ -184,6 +184,9 @@ fn init(module: &'static ThisModule) -> impl pin_init::PinInit<Self, error::Erro
 pub trait ModuleMetadata {
     /// The name of the module as specified in the `module!` macro.
     const NAME: &'static crate::str::CStr;
+
+    /// The module's `THIS_MODULE` pointer.
+    const THIS_MODULE: ThisModule;
 }
 
 /// Equivalent to `THIS_MODULE` in the C API.
rust/macros/module.rs +17 -17
index 06c18e2075083..b6d7b3299fbf9 100644
@@ -497,28 +497,28 @@ pub(crate) fn module(info: ModuleInfo) -> Result<TokenStream> {
         /// Used by the printing macros, e.g. [`info!`].
         const __LOG_PREFIX: &[u8] = #name_cstr.to_bytes_with_nul();
 
-        // SAFETY: `__this_module` is constructed by the kernel at load time and will not be
-        // freed until the module is unloaded.
-        #[cfg(MODULE)]
-        static THIS_MODULE: ::kernel::ThisModule = unsafe {
-            extern "C" {
-                static __this_module: ::kernel::types::Opaque<::kernel::bindings::module>;
-            };
-
-            ::kernel::ThisModule::from_ptr(__this_module.get())
-        };
-
-        #[cfg(not(MODULE))]
-        static THIS_MODULE: ::kernel::ThisModule = unsafe {
-            ::kernel::ThisModule::from_ptr(::core::ptr::null_mut())
-        };
-
         /// The `LocalModule` type is the type of the module created by `module!`,
         /// `module_pci_driver!`, `module_platform_driver!`, etc.
         type LocalModule = #type_;
 
         impl ::kernel::ModuleMetadata for #type_ {
             const NAME: &'static ::kernel::str::CStr = #name_cstr;
+
+            #[cfg(MODULE)]
+            const THIS_MODULE: ::kernel::ThisModule = {
+                extern "C" {
+                    static __this_module: ::kernel::types::Opaque<::kernel::bindings::module>;
+                }
+
+                // SAFETY: `__this_module` is constructed by the kernel at load time
+                // and lives until the module is unloaded.
+                unsafe { ::kernel::ThisModule::from_ptr(__this_module.get()) }
+            };
+
+            #[cfg(not(MODULE))]
+            const THIS_MODULE: ::kernel::ThisModule = unsafe {
+                ::kernel::ThisModule::from_ptr(::core::ptr::null_mut())
+            };
         }
 
         // Double nested modules, since then nobody can access the public items inside.
@@ -616,7 +616,7 @@ pub extern "C" fn #ident_exit() {
                 /// This function must only be called once.
                 unsafe fn __init() -> ::kernel::ffi::c_int {
                     let initer = <super::super::LocalModule as ::kernel::InPlaceModule>::init(
-                        &super::super::THIS_MODULE
+                        &<super::super::LocalModule as ::kernel::ModuleMetadata>::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
Signature · 1 line
2.43.0
maintainer
#2 lore raw

Re: [PATCH v2 1/7] rust: module: add `THIS_MODULE` const to `ModuleMetadata` trait

Quoted 78 lines · Alvin Sun

Add a THIS_MODULE const to the ModuleMetadata trait so that modules can provide their ThisModule pointer usable in const contexts such as static file_operations.

Move the THIS_MODULE static from the module! macro into the ModuleMetadata impl, and update __init to use LocalModule::THIS_MODULE instead.

---
 rust/kernel/lib.rs    |  3 +++
 rust/macros/module.rs | 34 +++++++++++++++++-----------------
 2 files changed, 20 insertions(+), 17 deletions(-)
rust/kernel/lib.rs +3 -0
index b72b2fbe046d6..f0cf0705d9697 100644
@@ -184,6 +184,9 @@ fn init(module: &'static ThisModule) -> impl pin_init::PinInit<Self, error::Erro
 pub trait ModuleMetadata {
     /// The name of the module as specified in the `module!` macro.
     const NAME: &'static crate::str::CStr;
+
+    /// The module's `THIS_MODULE` pointer.
+    const THIS_MODULE: ThisModule;
 }
 
 /// Equivalent to `THIS_MODULE` in the C API.
rust/macros/module.rs +16 -16
index 06c18e2075083..b6d7b3299fbf9 100644
@@ -497,28 +497,28 @@ pub(crate) fn module(info: ModuleInfo) -> Result<TokenStream> {
         /// Used by the printing macros, e.g. [`info!`].
         const __LOG_PREFIX: &[u8] = #name_cstr.to_bytes_with_nul();
 
-        // SAFETY: `__this_module` is constructed by the kernel at load time and will not be
-        // freed until the module is unloaded.
-        #[cfg(MODULE)]
-        static THIS_MODULE: ::kernel::ThisModule = unsafe {
-            extern "C" {
-                static __this_module: ::kernel::types::Opaque<::kernel::bindings::module>;
-            };
-
-            ::kernel::ThisModule::from_ptr(__this_module.get())
-        };
-
-        #[cfg(not(MODULE))]
-        static THIS_MODULE: ::kernel::ThisModule = unsafe {
-            ::kernel::ThisModule::from_ptr(::core::ptr::null_mut())
-        };
-
         /// The `LocalModule` type is the type of the module created by `module!`,
         /// `module_pci_driver!`, `module_platform_driver!`, etc.
         type LocalModule = #type_;
 
         impl ::kernel::ModuleMetadata for #type_ {
             const NAME: &'static ::kernel::str::CStr = #name_cstr;
+
+            #[cfg(MODULE)]
+            const THIS_MODULE: ::kernel::ThisModule = {
+                extern "C" {
+                    static __this_module: ::kernel::types::Opaque<::kernel::bindings::module>;
+                }
+
+                // SAFETY: `__this_module` is constructed by the kernel at load time
+                // and lives until the module is unloaded.
+                unsafe { ::kernel::ThisModule::from_ptr(__this_module.get()) }
+            };
+
+            #[cfg(not(MODULE))]
+            const THIS_MODULE: ::kernel::ThisModule = unsafe {
+                ::kernel::ThisModule::from_ptr(::core::ptr::null_mut())
+            };
         }
 
         // Double nested modules, since then nobody can access the public items inside.

rust/macros/module.rs pub extern "C" fn #ident_exit() { · line 619

Quoted 5 lines
rust/macros/module.rs +1 -1
@@ -616,7 +616,7 @@ pub extern "C" fn #ident_exit() {
                 /// This function must only be called once.
                 unsafe fn __init() -> ::kernel::ffi::c_int {
                     let initer = <super::super::LocalModule as ::kernel::InPlaceModule>::init(
-                        &super::super::THIS_MODULE
+                        &<super::super::LocalModule as ::kernel::ModuleMetadata>::THIS_MODULE

Is it possible we could make this more ergonomic? Perhaps by adding a helper:

  fn this_module<M: ::kernel::ModuleMetadata>() -> &'static ::kernel::ThisModule {
      &M::THIS_MODULE
  }

Then the invocation is a little better:

let initer = <super::super::LocalModule as ::kernel::InPlaceModule>::init(

      this_module::<super::super::LocalModule>()

);

Best regards,
Andreas Hindborg

reviewer
#3 lore raw

Re: [PATCH v2 1/7] rust: module: add `THIS_MODULE` const to `ModuleMetadata` trait

In reply to Alvin Sun
Quoted 7 lines · Alvin Sun

Add a THIS_MODULE const to the ModuleMetadata trait so that modules can provide their ThisModule pointer usable in const contexts such as static file_operations.

Move the THIS_MODULE static from the module! macro into the ModuleMetadata impl, and update __init to use LocalModule::THIS_MODULE instead.

Perhaps you could mention that this is made possible by const_refs_to_static which is stable since the MSRV bump.

Best,
Gary

Quoted 79 lines
---
 rust/kernel/lib.rs    |  3 +++
 rust/macros/module.rs | 34 +++++++++++++++++-----------------
 2 files changed, 20 insertions(+), 17 deletions(-)
rust/kernel/lib.rs +3 -0
index b72b2fbe046d6..f0cf0705d9697 100644
@@ -184,6 +184,9 @@ fn init(module: &'static ThisModule) -> impl pin_init::PinInit<Self, error::Erro
 pub trait ModuleMetadata {
     /// The name of the module as specified in the `module!` macro.
     const NAME: &'static crate::str::CStr;
+
+    /// The module's `THIS_MODULE` pointer.
+    const THIS_MODULE: ThisModule;
 }
 
 /// Equivalent to `THIS_MODULE` in the C API.
rust/macros/module.rs +17 -17
index 06c18e2075083..b6d7b3299fbf9 100644
@@ -497,28 +497,28 @@ pub(crate) fn module(info: ModuleInfo) -> Result<TokenStream> {
         /// Used by the printing macros, e.g. [`info!`].
         const __LOG_PREFIX: &[u8] = #name_cstr.to_bytes_with_nul();
 
-        // SAFETY: `__this_module` is constructed by the kernel at load time and will not be
-        // freed until the module is unloaded.
-        #[cfg(MODULE)]
-        static THIS_MODULE: ::kernel::ThisModule = unsafe {
-            extern "C" {
-                static __this_module: ::kernel::types::Opaque<::kernel::bindings::module>;
-            };
-
-            ::kernel::ThisModule::from_ptr(__this_module.get())
-        };
-
-        #[cfg(not(MODULE))]
-        static THIS_MODULE: ::kernel::ThisModule = unsafe {
-            ::kernel::ThisModule::from_ptr(::core::ptr::null_mut())
-        };
-
         /// The `LocalModule` type is the type of the module created by `module!`,
         /// `module_pci_driver!`, `module_platform_driver!`, etc.
         type LocalModule = #type_;
 
         impl ::kernel::ModuleMetadata for #type_ {
             const NAME: &'static ::kernel::str::CStr = #name_cstr;
+
+            #[cfg(MODULE)]
+            const THIS_MODULE: ::kernel::ThisModule = {
+                extern "C" {
+                    static __this_module: ::kernel::types::Opaque<::kernel::bindings::module>;
+                }
+
+                // SAFETY: `__this_module` is constructed by the kernel at load time
+                // and lives until the module is unloaded.
+                unsafe { ::kernel::ThisModule::from_ptr(__this_module.get()) }
+            };
+
+            #[cfg(not(MODULE))]
+            const THIS_MODULE: ::kernel::ThisModule = unsafe {
+                ::kernel::ThisModule::from_ptr(::core::ptr::null_mut())
+            };
         }
 
         // Double nested modules, since then nobody can access the public items inside.
@@ -616,7 +616,7 @@ pub extern "C" fn #ident_exit() {
                 /// This function must only be called once.
                 unsafe fn __init() -> ::kernel::ffi::c_int {
                     let initer = <super::super::LocalModule as ::kernel::InPlaceModule>::init(
-                        &super::super::THIS_MODULE
+                        &<super::super::LocalModule as ::kernel::ModuleMetadata>::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
author
#4 lore raw

PATCH v2 2/7 rust: macros: auto-insert ThisModule in #[vtable]

In reply to Alvin Sun

Auto-add type ThisModule: ::kernel::ModuleMetadata; as a required associated type on the trait side if not already defined, and auto-insert type ThisModule = crate::LocalModule; on the impl side if not explicitly provided, eliminating the need to manually declare and implement ThisModule in every vtable trait and impl.

---
 rust/macros/lib.rs    |  6 ++++++
 rust/macros/vtable.rs | 38 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 43 insertions(+), 1 deletion(-)
rust/macros/lib.rs +6 -0
index 2cfd59e0f9e7c..d35e45ea745c0 100644
@@ -176,6 +176,12 @@ pub fn module(input: TokenStream) -> TokenStream {
 ///
 /// This macro should not be used when all functions are required.
 ///
+/// Additionally, this macro automatically handles the `ThisModule`
+/// associated type: on the trait side, `type ThisModule: ModuleMetadata;`
+/// is added as a required associated type if not already defined; on the
+/// impl side, `type ThisModule = LocalModule;` is automatically inserted
+/// if not explicitly defined.
+///
 /// # Examples
 ///
 /// ```
rust/macros/vtable.rs +37 -1
index c6510b0c4ea1d..d3d0e9cbd7172 100644
@@ -23,6 +23,7 @@
 
 fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> {
     let mut gen_items = Vec::new();
+    let mut has_this_module = false;
 
     gen_items.push(parse_quote! {
          /// A marker to prevent implementors from forgetting to use [`#[vtable]`](vtable)
@@ -30,6 +31,28 @@ fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> {
          const USE_VTABLE_ATTR: ();
     });
 
+    // Detect existing type ThisModule so we don't add a duplicate.
+    for i in &item.items {
+        if let TraitItem::Type(type_item) = i {
+            if type_item.ident == "ThisModule" {
+                has_this_module = true;
+            }
+        }
+    }
+
+    // Add `type ThisModule: ModuleMetadata` as a required associated type if
+    // the trait does not already define it. No default is used because
+    // `associated_type_defaults` is unstable (issue #29661).
+    if !has_this_module {
+        gen_items.push(parse_quote! {
+            /// The module implementing this vtable trait.
+            ///
+            /// Automatically set to `crate::LocalModule` by the `#[vtable]`
+            /// impl macro.
+            type ThisModule: ::kernel::ModuleMetadata;
+        });
+    }
+
     for item in &item.items {
         if let TraitItem::Fn(fn_item) = item {
             let name = &fn_item.sig.ident;
@@ -58,18 +81,31 @@ fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> {
 fn handle_impl(mut item: ItemImpl) -> Result<ItemImpl> {
     let mut gen_items = Vec::new();
     let mut defined_consts = HashSet::new();
+    let mut defined_types = HashSet::new();
 
-    // Iterate over all user-defined constants to gather any possible explicit overrides.
+    // Iterate over all user-defined constants and types to gather any possible explicit overrides.
     for item in &item.items {
         if let ImplItem::Const(const_item) = item {
             defined_consts.insert(const_item.ident.clone());
         }
+        if let ImplItem::Type(type_item) = item {
+            defined_types.insert(type_item.ident.clone());
+        }
     }
 
     gen_items.push(parse_quote! {
         const USE_VTABLE_ATTR: () = ();
     });
 
+    // Auto-insert `type ThisModule = crate::LocalModule` if not explicitly defined.
+    // `crate::LocalModule` resolves to the real module type (via `module!`) or a
+    // dummy fallback in non-module contexts (e.g., doctests).
+    if !defined_types.contains(&parse_quote!(ThisModule)) {
+        gen_items.push(parse_quote! {
+            type ThisModule = crate::LocalModule;
+        });
+    }
+
     for item in &item.items {
         if let ImplItem::Fn(fn_item) = item {
             let name = &fn_item.sig.ident;
Signature · 1 line
2.43.0
maintainer Reviewed-by on v2 2/7
#5 lore raw

Re: [PATCH v2 2/7] rust: macros: auto-insert ThisModule in #[vtable]

Quoted 7 lines · Alvin Sun

Auto-add type ThisModule: ::kernel::ModuleMetadata; as a required associated type on the trait side if not already defined, and auto-insert type ThisModule = crate::LocalModule; on the impl side if not explicitly provided, eliminating the need to manually declare and implement ThisModule in every vtable trait and impl.

Best regards,
Andreas Hindborg

reviewer
#6 lore raw

Re: [PATCH v2 2/7] rust: macros: auto-insert ThisModule in #[vtable]

In reply to Alvin Sun
Quoted 7 lines · Alvin Sun

Auto-add type ThisModule: ::kernel::ModuleMetadata; as a required associated type on the trait side if not already defined, and auto-insert type ThisModule = crate::LocalModule; on the impl side if not explicitly provided, eliminating the need to manually declare and implement ThisModule in every vtable trait and impl.

Quoted 40 lines
---
 rust/macros/lib.rs    |  6 ++++++
 rust/macros/vtable.rs | 38 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 43 insertions(+), 1 deletion(-)
rust/macros/lib.rs +6 -0
index 2cfd59e0f9e7c..d35e45ea745c0 100644
@@ -176,6 +176,12 @@ pub fn module(input: TokenStream) -> TokenStream {
 ///
 /// This macro should not be used when all functions are required.
 ///
+/// Additionally, this macro automatically handles the `ThisModule`
+/// associated type: on the trait side, `type ThisModule: ModuleMetadata;`
+/// is added as a required associated type if not already defined; on the
+/// impl side, `type ThisModule = LocalModule;` is automatically inserted
+/// if not explicitly defined.
+///
 /// # Examples
 ///
 /// ```
rust/macros/vtable.rs +3 -0
index c6510b0c4ea1d..d3d0e9cbd7172 100644
@@ -23,6 +23,7 @@
 
 fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> {
     let mut gen_items = Vec::new();
+    let mut has_this_module = false;
 
     gen_items.push(parse_quote! {
          /// A marker to prevent implementors from forgetting to use [`#[vtable]`](vtable)
@@ -30,6 +31,28 @@ fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> {
          const USE_VTABLE_ATTR: ();
     });
 
+    // Detect existing type ThisModule so we don't add a duplicate.
+    for i in &item.items {

rust/macros/vtable.rs fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> { · line 45

Quoted 10 lines
rust/macros/vtable.rs +10 -0
+        if let TraitItem::Type(type_item) = i {
+            if type_item.ident == "ThisModule" {
+                has_this_module = true;
+            }
+        }
+    }
+
+    // Add `type ThisModule: ModuleMetadata` as a required associated type if
+    // the trait does not already define it. No default is used because
+    // `associated_type_defaults` is unstable (issue #29661).

I don't think this is relevant. What's the sensible default anyway?

rust/macros/vtable.rs fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> { · line 46

Quoted 1 line
rust/macros/vtable.rs +1 -0
+    if !has_this_module {

Perhaps just make this an one liner :

    if !item.items.iter().any(|i| matches!(item, TraitItem::Type(t) if t.ident == "ThisModule")) {
Quoted 13 lines
rust/macros/vtable.rs +9 -0
+        gen_items.push(parse_quote! {
+            /// The module implementing this vtable trait.
+            ///
+            /// Automatically set to `crate::LocalModule` by the `#[vtable]`
+            /// impl macro.
+            type ThisModule: ::kernel::ModuleMetadata;
+        });
+    }
+
     for item in &item.items {
         if let TraitItem::Fn(fn_item) = item {
             let name = &fn_item.sig.ident;

rust/macros/vtable.rs fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> { · line 84

Quoted 4 lines
rust/macros/vtable.rs +1 -0
@@ -58,18 +81,31 @@ fn handle_trait(mut item: ItemTrait) -> Result<ItemTrait> {
 fn handle_impl(mut item: ItemImpl) -> Result<ItemImpl> {
     let mut gen_items = Vec::new();
     let mut defined_consts = HashSet::new();
+    let mut defined_types = HashSet::new();

I'd just rename defined_consts to defined_items to reuse the same set as there cannot be assoc items with same name anyway.

Best,
Gary

Quoted 28 lines
rust/macros/vtable.rs +13 -1
-    // Iterate over all user-defined constants to gather any possible explicit overrides.
+    // Iterate over all user-defined constants and types to gather any possible explicit overrides.
     for item in &item.items {
         if let ImplItem::Const(const_item) = item {
             defined_consts.insert(const_item.ident.clone());
         }
+        if let ImplItem::Type(type_item) = item {
+            defined_types.insert(type_item.ident.clone());
+        }
     }
 
     gen_items.push(parse_quote! {
         const USE_VTABLE_ATTR: () = ();
     });
 
+    // Auto-insert `type ThisModule = crate::LocalModule` if not explicitly defined.
+    // `crate::LocalModule` resolves to the real module type (via `module!`) or a
+    // dummy fallback in non-module contexts (e.g., doctests).
+    if !defined_types.contains(&parse_quote!(ThisModule)) {
+        gen_items.push(parse_quote! {
+            type ThisModule = crate::LocalModule;
+        });
+    }
+
     for item in &item.items {
         if let ImplItem::Fn(fn_item) = item {
             let name = &fn_item.sig.ident;
author
#7 lore raw

PATCH v2 3/7 rust: doctest: add LocalModule fallback for #[vtable] ThisModule

In reply to Alvin Sun

Add a LocalModule struct with a null-pointer ModuleMetadata impl in the doctest harness, so that crate::LocalModule (auto-inserted by #[vtable]) resolves correctly when there is no module! macro.

---
 scripts/rustdoc_test_gen.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
scripts/rustdoc_test_gen.rs +16 -0
index ee76e96b41eea..198af4e446c8c 100644
@@ -239,6 +239,22 @@ macro_rules! assert_eq {{
 
 const __LOG_PREFIX: &[u8] = b"rust_doctests_kernel\0";
 
+/// Dummy module type for doctest context.
+struct LocalModule;
+
+use kernel::{{
+    str::CStr,
+    ModuleMetadata,
+    ThisModule, //
+}};
+use core::ptr::null_mut;
+
+impl ModuleMetadata for LocalModule {{
+    const NAME: &'static CStr = c"rust_doctests_kernel";
+    // SAFETY: `try_module_get`/`module_put` handle null module pointers gracefully.
+    const THIS_MODULE: ThisModule = unsafe {{ ThisModule::from_ptr(null_mut()) }};
+}}
+
 {rust_tests}
 "#
     )
Signature · 1 line
2.43.0
maintainer Reviewed-by on v2 3/7
#8 lore raw

Re: [PATCH v2 3/7] rust: doctest: add LocalModule fallback for #[vtable] ThisModule

Quoted 5 lines · Alvin Sun

Add a LocalModule struct with a null-pointer ModuleMetadata impl in the doctest harness, so that crate::LocalModule (auto-inserted by #[vtable]) resolves correctly when there is no module! macro.

Does this need to be ordered before the vtable auto insert in the patch series?

Best regards,
Andreas Hindborg

author
#9 lore raw

Re: [PATCH v2 3/7] rust: doctest: add LocalModule fallback for #[vtable] ThisModule

Quoted 10 lines · Andreas Hindborg
Quoted 5 lines · Alvin Sun

Add a LocalModule struct with a null-pointer ModuleMetadata impl in the doctest harness, so that crate::LocalModule (auto-inserted by #[vtable]) resolves correctly when there is no module! macro.

Does this need to be ordered before the vtable auto insert in the patch series?

Yes, you're right — this patch would be better placed before the vtable auto-insert patch to avoid a temporary state where the doctest harness doesn't provide the LocalModule fallback that #[vtable] expects.

Thanks for the suggestions from you and Gary. v3 has been sent to the list:

https://lore.kernel.org/rust-for-linux/[email protected]

Best regards,
Alvin Sun

Quoted 5 lines

Best regards,
Andreas Hindborg

author
#10 lore raw

PATCH v2 4/7 rust: drm: set fops.owner from driver module pointer

In reply to Alvin Sun

Change create_fops() to accept an owner module pointer instead of hardcoding null_mut(), ensuring the kernel correctly tracks the module owning the DRM device's file operations.

---
 rust/kernel/drm/device.rs  | 3 ++-
 rust/kernel/drm/gem/mod.rs | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)
rust/kernel/drm/device.rs +2 -1
index 403fc35353c74..53e44a780ae97 100644
@@ -111,7 +111,8 @@ impl<T: drm::Driver> Device<T> {
         fops: &Self::GEM_FOPS,
     };
 
-    const GEM_FOPS: bindings::file_operations = drm::gem::create_fops();
+    const GEM_FOPS: bindings::file_operations =
+        drm::gem::create_fops(<T::ThisModule as crate::ModuleMetadata>::THIS_MODULE.as_ptr());
 
     /// Create a new `drm::Device` for a `drm::Driver`.
     pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<ARef<Self>> {
rust/kernel/drm/gem/mod.rs +2 -2
index 01b5bd47a3332..9a203efc59116 100644
@@ -357,10 +357,10 @@ impl<T: DriverObject> AllocImpl for Object<T> {
     };
 }
 
-pub(super) const fn create_fops() -> bindings::file_operations {
+pub(super) const fn create_fops(owner: *mut bindings::module) -> bindings::file_operations {
     let mut fops: bindings::file_operations = pin_init::zeroed();
 
-    fops.owner = core::ptr::null_mut();
+    fops.owner = owner;
     fops.open = Some(bindings::drm_open);
     fops.release = Some(bindings::drm_release);
     fops.unlocked_ioctl = Some(bindings::drm_ioctl);
Signature · 1 line
2.43.0
reviewer
#11 lore raw

Re: [PATCH v2 4/7] rust: drm: set fops.owner from driver module pointer

Quoted 15 lines · Alvin Sun

Change create_fops() to accept an owner module pointer instead of hardcoding null_mut(), ensuring the kernel correctly tracks the module owning the DRM device's file operations.

---
 rust/kernel/drm/device.rs  | 3 ++-
 rust/kernel/drm/gem/mod.rs | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)
rust/kernel/drm/device.rs +0 -0
index 403fc35353c74..53e44a780ae97 100644

rust/kernel/drm/device.rs impl<T: drm::Driver> Device<T> { · line 115

Quoted 6 lines
rust/kernel/drm/device.rs +2 -1
@@ -111,7 +111,8 @@ impl<T: drm::Driver> Device<T> {
         fops: &Self::GEM_FOPS,
     };
 
-    const GEM_FOPS: bindings::file_operations = drm::gem::create_fops();
+    const GEM_FOPS: bindings::file_operations =
+        drm::gem::create_fops(<T::ThisModule as crate::ModuleMetadata>::THIS_MODULE.as_ptr());

I wonder if the assoc type should just be called Owner or OwnerModule?

Best.
Gary

Quoted 20 lines
rust/kernel/drm/device.rs +0 -0
     /// Create a new `drm::Device` for a `drm::Driver`.
     pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<ARef<Self>> {
rust/kernel/drm/gem/mod.rs +2 -2
index 01b5bd47a3332..9a203efc59116 100644
@@ -357,10 +357,10 @@ impl<T: DriverObject> AllocImpl for Object<T> {
     };
 }
 
-pub(super) const fn create_fops() -> bindings::file_operations {
+pub(super) const fn create_fops(owner: *mut bindings::module) -> bindings::file_operations {
     let mut fops: bindings::file_operations = pin_init::zeroed();
 
-    fops.owner = core::ptr::null_mut();
+    fops.owner = owner;
     fops.open = Some(bindings::drm_open);
     fops.release = Some(bindings::drm_release);
     fops.unlocked_ioctl = Some(bindings::drm_ioctl);
author
#12 lore raw

PATCH v2 5/7 rust: miscdevice: set fops.owner from driver module pointer

In reply to Alvin Sun

Set the miscdevice fops owner field from the driver module pointer via <T::ThisModule as ModuleMetadata>::THIS_MODULE, instead of defaulting to null.

---
 rust/kernel/miscdevice.rs | 2 ++
 1 file changed, 2 insertions(+)
rust/kernel/miscdevice.rs +2 -0
index 83ce50def5ac9..16837c46bca49 100644
@@ -30,6 +30,7 @@
         ForeignOwnable,
         Opaque, //
     },
+    ModuleMetadata, //
 };
 use core::marker::PhantomData;
 
@@ -430,6 +431,7 @@ impl<T: MiscDevice> MiscdeviceVTable<T> {
         } else {
             None
         },
+        owner: <T::ThisModule as ModuleMetadata>::THIS_MODULE.as_ptr(),
         ..pin_init::zeroed()
     };
 
Signature · 1 line
2.43.0
author
#13 lore raw

PATCH v2 6/7 rust: configfs: use `LocalModule` for `THIS_MODULE`

In reply to Alvin Sun

Replace the THIS_MODULE static reference in the configfs_attrs! macro with <LocalModule as ModuleMetadata>::THIS_MODULE, consistent with the move of THIS_MODULE into the ModuleMetadata trait.

---
 rust/kernel/configfs.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
rust/kernel/configfs.rs +5 -3
index 2339c6467325d..cc60297f11551 100644
@@ -875,7 +875,7 @@ fn as_ptr(&self) -> *const bindings::config_item_type {
 ///                 configfs::Subsystem<Configuration>,
 ///                 Configuration
 ///                 >::new_with_child_ctor::<N,Child>(
-///             &THIS_MODULE,
+///             &<LocalModule as ::kernel::ModuleMetadata>::THIS_MODULE,
 ///             &CONFIGURATION_ATTRS
 ///         );
 ///
@@ -1021,7 +1021,8 @@ macro_rules! configfs_attrs {
 
                     static [< $data:upper _TPE >] : $crate::configfs::ItemType<$container, $data>  =
                         $crate::configfs::ItemType::<$container, $data>::new::<N>(
-                            &THIS_MODULE, &[<$ data:upper _ATTRS >]
+                            &<LocalModule as ::kernel::ModuleMetadata>::THIS_MODULE,
+                            &[<$ data:upper _ATTRS >]
                         );
                 )?
 
@@ -1030,7 +1031,8 @@ macro_rules! configfs_attrs {
                         $crate::configfs::ItemType<$container, $data>  =
                             $crate::configfs::ItemType::<$container, $data>::
                             new_with_child_ctor::<N, $child>(
-                                &THIS_MODULE, &[<$ data:upper _ATTRS >]
+                                &<LocalModule as ::kernel::ModuleMetadata>::THIS_MODULE,
+                                &[<$ data:upper _ATTRS >]
                             );
                 )?
 
Signature · 1 line
2.43.0
author
#14 lore raw

PATCH v2 7/7 block: rnull: use `LocalModule` for `THIS_MODULE`

In reply to Alvin Sun

Replace the THIS_MODULE import with LocalModule from the crate, consistent with the move of THIS_MODULE into the ModuleMetadata trait.

---
 drivers/block/rnull/configfs.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)
drivers/block/rnull/configfs.rs +2 -4
index c10a55fc58948..b2547ad1e5ddd 100644
@@ -1,9 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0
 
-use super::{
-    NullBlkDevice,
-    THIS_MODULE, //
-};
+use super::NullBlkDevice;
+use crate::LocalModule;
 use kernel::{
     block::mq::gen_disk::{
         GenDisk,
Signature · 1 line
2.43.0
maintainer
#15 lore raw

Re: [PATCH v2 7/7] block: rnull: use `LocalModule` for `THIS_MODULE`

Quoted 5 lines · Alvin Sun

Replace the THIS_MODULE import with LocalModule from the crate, consistent with the move of THIS_MODULE into the ModuleMetadata trait.

You need to squash this with the previous patch.

Best regards,
Andreas Hindborg