rust: miscdev: support names created at runtime

drivers/android/rust_binder.rs

@@ -105,7 +105,7 @@ struct BinderModule {
 impl KernelModule for BinderModule {
     fn init(name: &'static CStr, _module: &'static kernel::ThisModule) -> Result<Self> {
         let ctx = Context::new()?;
-        let reg = Registration::new_pinned(name, ctx)?;
+        let reg = Registration::new_pinned(fmt!("{name}"), ctx)?;
         Ok(Self { _reg: reg })
     }
 }

drivers/char/hw_random/bcm2835_rng_rust.rs

@@ -3,7 +3,7 @@
 //! Broadcom BCM2835 Random Number Generator support.
 
 use kernel::{
-    c_str, device, file::File, file_operations::FileOperations, io_buffer::IoBufferWriter, miscdev,
+    device, file::File, file_operations::FileOperations, io_buffer::IoBufferWriter, miscdev,
     module_platform_driver, of, platform, prelude::*, sync::Ref,
 };
 
@@ -57,7 +57,7 @@ impl platform::Driver for RngDriver {
         data.registrations()
             .ok_or(Error::ENXIO)?
             .as_pinned_mut()
-            .register(c_str!("rust_hwrng"), ())?;
+            .register(fmt!("rust_hwrng"), ())?;
         Ok(data.into())
     }
 }

rust/kernel/miscdev.rs

@@ -9,10 +9,10 @@
 use crate::bindings;
 use crate::error::{Error, Result};
 use crate::file_operations::{FileOpenAdapter, FileOperations, FileOperationsVtable};
-use crate::{device, str::CStr, KernelModule, ThisModule};
+use crate::{device, str::CStr, str::CString, KernelModule, ThisModule};
 use alloc::boxed::Box;
 use core::marker::PhantomPinned;
-use core::{mem::MaybeUninit, pin::Pin};
+use core::{fmt, mem::MaybeUninit, pin::Pin};
 
 /// Options which can be used to configure how a misc device is registered.
 ///
@@ -28,7 +28,7 @@ use core::{mem::MaybeUninit, pin::Pin};
 ///         .mode(0o600)
 ///         .minor(10)
 ///         .parent(parent)
-///         .register(reg, c_str!("sample"), ())
+///         .register(reg, fmt!("sample"), ())
 /// }
 /// ```
 #[derive(Default)]
@@ -73,7 +73,7 @@ impl<'a> Options<'a> {
     pub fn register<T: FileOperations>(
         &self,
         reg: Pin<&mut Registration<T>>,
-        name: &'static CStr,
+        name: fmt::Arguments<'_>,
         open_data: T::OpenData,
     ) -> Result {
         reg.register_with_options(name, open_data, self)
@@ -83,7 +83,7 @@ impl<'a> Options<'a> {
     /// configured options.
     pub fn register_new<T: FileOperations>(
         &self,
-        name: &'static CStr,
+        name: fmt::Arguments<'_>,
         open_data: T::OpenData,
     ) -> Result<Pin<Box<Registration<T>>>> {
         let mut r = Pin::from(Box::try_new(Registration::new())?);
@@ -100,6 +100,7 @@ impl<'a> Options<'a> {
 pub struct Registration<T: FileOperations> {
     registered: bool,
     mdev: bindings::miscdevice,
+    name: Option<CString>,
     _pin: PhantomPinned,
 
     /// Context initialised on construction and made available to all file instances on
@@ -116,6 +117,7 @@ impl<T: FileOperations> Registration<T> {
         Self {
             registered: false,
             mdev: bindings::miscdevice::default(),
+            name: None,
             _pin: PhantomPinned,
             open_data: MaybeUninit::uninit(),
         }
@@ -124,15 +126,19 @@ impl<T: FileOperations> Registration<T> {
     /// Registers a miscellaneous device.
     ///
     /// Returns a pinned heap-allocated representation of the registration.
-    pub fn new_pinned(name: &'static CStr, open_data: T::OpenData) -> Result<Pin<Box<Self>>> {
+    pub fn new_pinned(name: fmt::Arguments<'_>, open_data: T::OpenData) -> Result<Pin<Box<Self>>> {
         Options::new().register_new(name, open_data)
     }
 
     /// Registers a miscellaneous device with the rest of the kernel.
     ///
     /// It must be pinned because the memory block that represents the registration is
     /// self-referential.
-    pub fn register(self: Pin<&mut Self>, name: &'static CStr, open_data: T::OpenData) -> Result {
+    pub fn register(
+        self: Pin<&mut Self>,
+        name: fmt::Arguments<'_>,
+        open_data: T::OpenData,
+    ) -> Result {
         Options::new().register(self, name, open_data)
     }
 
@@ -143,7 +149,7 @@ impl<T: FileOperations> Registration<T> {
     /// self-referential.
     pub fn register_with_options(
         self: Pin<&mut Self>,
-        name: &'static CStr,
+        name: fmt::Arguments<'_>,
         open_data: T::OpenData,
         opts: &Options<'_>,
     ) -> Result {
@@ -154,6 +160,8 @@ impl<T: FileOperations> Registration<T> {
             return Err(Error::EINVAL);
         }
 
+        let name = CString::try_from_fmt(name)?;
+
         // SAFETY: The adapter is compatible with `misc_register`.
         this.mdev.fops = unsafe { FileOperationsVtable::<Self, T>::build() };
         this.mdev.name = name.as_char_ptr();
@@ -179,6 +187,8 @@ impl<T: FileOperations> Registration<T> {
             return Err(Error::from_kernel_errno(ret));
         }
 
+        this.name = Some(name);
+
         Ok(())
     }
 }
@@ -235,7 +245,7 @@ pub struct Module<T: FileOperations<OpenData = ()>> {
 impl<T: FileOperations<OpenData = ()>> KernelModule for Module<T> {
     fn init(name: &'static CStr, _module: &'static ThisModule) -> Result<Self> {
         Ok(Self {
-            _dev: Registration::new_pinned(name, ())?,
+            _dev: Registration::new_pinned(crate::fmt!("{name}"), ())?,
         })
     }
 }

samples/rust/rust_miscdev.rs

@@ -132,7 +132,7 @@ impl KernelModule for RustMiscdev {
         let state = SharedState::try_new()?;
 
         Ok(RustMiscdev {
-            _dev: miscdev::Registration::new_pinned(name, state)?,
+            _dev: miscdev::Registration::new_pinned(fmt!("{name}"), state)?,
         })
     }
 }

samples/rust/rust_semaphore.rs

@@ -133,7 +133,7 @@ impl KernelModule for RustSemaphore {
         mutex_init!(pinned, "Semaphore::inner");
 
         Ok(Self {
-            _dev: Registration::new_pinned(name, sema.into())?,
+            _dev: Registration::new_pinned(fmt!("{name}"), sema.into())?,
         })
     }
 }