Re: [PATCH] rust: rename `kernel::c_str!` to `str_to_cstr!`

["Gary Guo" <gary@garyguo.net>]

On Mon Mar 2, 2026 at 5:20 PM GMT, Tamir Duberstein wrote:
> Now that all literals are C-Strings, rename and update the documentation
> of this macro to clarify its intended purpose.
>
> Link: https://github.com/Rust-for-Linux/linux/issues/1075
> Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
> Reviewed-by: Alice Ryhl <aliceryhl@google.com>
> Signed-off-by: Tamir Duberstein <tamird@kernel.org>

Do we really need to perform the rename? I think updating the documentation
should be good enough?

If the only concern is misuse of the macro then perhaps I can just add a
lint for this in klint.

> ---
> This patch completes the work of replacing our custom `CStr` with
> upstream's.
> ---
>  rust/kernel/bug.rs              |  2 +-
>  rust/kernel/configfs.rs         |  2 +-
>  rust/kernel/drm/ioctl.rs        |  2 +-
>  rust/kernel/kunit.rs            |  3 ++-
>  rust/kernel/str.rs              | 19 ++++++++++++++-----
>  rust/kernel/sync.rs             |  4 ++--
>  rust/kernel/sync/lock/global.rs |  3 ++-
>  rust/kernel/workqueue.rs        |  6 +++---
>  8 files changed, 26 insertions(+), 15 deletions(-)
>
> diff --git a/rust/kernel/bug.rs b/rust/kernel/bug.rs
> index ed943960f851..f7cb673b1766 100644
> --- a/rust/kernel/bug.rs
> +++ b/rust/kernel/bug.rs
> @@ -80,7 +80,7 @@ macro_rules! warn_flags {
>          // with a valid null-terminated string.
>          unsafe {
>              $crate::bindings::warn_slowpath_fmt(
> -                $crate::c_str!(::core::file!()).as_char_ptr(),
> +                $crate::str_to_cstr!(::core::file!()).as_char_ptr(),
>                  line!() as $crate::ffi::c_int,
>                  $flags as $crate::ffi::c_uint,
>                  ::core::ptr::null(),
> diff --git a/rust/kernel/configfs.rs b/rust/kernel/configfs.rs
> index 2339c6467325..930f17bb2041 100644
> --- a/rust/kernel/configfs.rs
> +++ b/rust/kernel/configfs.rs
> @@ -1000,7 +1000,7 @@ macro_rules! configfs_attrs {
>                          $crate::configfs::Attribute<$attr, $data, $data> =
>                              unsafe {
>                                  $crate::configfs::Attribute::new(
> -                                    $crate::c_str!(::core::stringify!($name)),
> +                                    $crate::str_to_cstr!(::core::stringify!($name)),
>                                  )
>                              };
>                  )*
> diff --git a/rust/kernel/drm/ioctl.rs b/rust/kernel/drm/ioctl.rs
> index cf328101dde4..6a87f489dc88 100644
> --- a/rust/kernel/drm/ioctl.rs
> +++ b/rust/kernel/drm/ioctl.rs
> @@ -157,7 +157,7 @@ macro_rules! declare_drm_ioctls {
>                      },
>                      flags: $flags,
>                      name: $crate::str::as_char_ptr_in_const_context(
> -                        $crate::c_str!(::core::stringify!($cmd)),
> +                        $crate::str_to_cstr!(::core::stringify!($cmd)),
>                      ),
>                  }
>              ),*];
> diff --git a/rust/kernel/kunit.rs b/rust/kernel/kunit.rs
> index f93f24a60bdd..5802a3507ecc 100644
> --- a/rust/kernel/kunit.rs
> +++ b/rust/kernel/kunit.rs
> @@ -59,7 +59,8 @@ macro_rules! kunit_assert {
>  
>              static FILE: &'static $crate::str::CStr = $file;
>              static LINE: i32 = ::core::line!() as i32 - $diff;
> -            static CONDITION: &'static $crate::str::CStr = $crate::c_str!(stringify!($condition));
> +            static CONDITION: &'static $crate::str::CStr =
> +                $crate::str_to_cstr!(stringify!($condition));
>  
>              // SAFETY: FFI call without safety requirements.
>              let kunit_test = unsafe { $crate::bindings::kunit_get_current_test() };
> diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs
> index fa87779d2253..8bb40de007d4 100644
> --- a/rust/kernel/str.rs
> +++ b/rust/kernel/str.rs
> @@ -376,19 +376,28 @@ fn as_ref(&self) -> &BStr {
>      }
>  }
>  
> -/// Creates a new [`CStr`] from a string literal.
> +/// Creates a new [`CStr`] at compile time.
>  ///
> -/// The string literal should not contain any `NUL` bytes.
> +/// Rust supports C string literals since Rust 1.77, and they should be used instead of this macro
> +/// where possible. This macro exists to allow static *non-literal* C strings to be created at
> +/// compile time. This is most often used in other macros.
> +///
> +/// # Panics
> +///
> +/// This macro panics if the operand contains an interior `NUL` byte.
>  ///
>  /// # Examples
>  ///
>  /// ```
> -/// # use kernel::c_str;
> +/// # use kernel::str_to_cstr;
>  /// # use kernel::str::CStr;
> -/// const MY_CSTR: &CStr = c_str!("My awesome CStr!");
> +/// const MY_CSTR: &CStr = str_to_cstr!(concat!(file!(), ":", line!(), ": My CStr!"));

Perhaps keep a copy of the old example and add a comment saying this is allowed
but c"literal" should be preferred.

Best,
Gary

>  /// ```
>  #[macro_export]
> -macro_rules! c_str {
> +macro_rules! str_to_cstr {
> +    // NB: we could write `($str:lit) => compile_error!("use a C string literal instead");` here but
> +    // that would trigger when the literal is at the top of several macro expansions. That would be
> +    // too limiting to macro authors, so we rely on the name as a hint instead.
>      ($str:expr) => {{
>          const S: &str = concat!($str, "\0");
>          const C: &$crate::str::CStr = match $crate::str::CStr::from_bytes_with_nul(S.as_bytes()) {
> diff --git a/rust/kernel/sync.rs b/rust/kernel/sync.rs
> index 993dbf2caa0e..ecf02a67ec35 100644
> --- a/rust/kernel/sync.rs
> +++ b/rust/kernel/sync.rs
> @@ -154,9 +154,9 @@ macro_rules! static_lock_class {
>  #[macro_export]
>  macro_rules! optional_name {
>      () => {
> -        $crate::c_str!(::core::concat!(::core::file!(), ":", ::core::line!()))
> +        $crate::str_to_cstr!(::core::concat!(::core::file!(), ":", ::core::line!()))
>      };
>      ($name:literal) => {
> -        $crate::c_str!($name)
> +        $crate::str_to_cstr!($name)
>      };
>  }
> diff --git a/rust/kernel/sync/lock/global.rs b/rust/kernel/sync/lock/global.rs
> index aecbdc34738f..81f46229be7d 100644
> --- a/rust/kernel/sync/lock/global.rs
> +++ b/rust/kernel/sync/lock/global.rs
> @@ -272,7 +272,8 @@ macro_rules! global_lock {
>          $pub enum $name {}
>  
>          impl $crate::sync::lock::GlobalLockBackend for $name {
> -            const NAME: &'static $crate::str::CStr = $crate::c_str!(::core::stringify!($name));
> +            const NAME: &'static $crate::str::CStr =
> +                $crate::str_to_cstr!(::core::stringify!($name));
>              type Item = $valuety;
>              type Backend = $crate::global_lock_inner!(backend $kind);
>  
> diff --git a/rust/kernel/workqueue.rs b/rust/kernel/workqueue.rs
> index 706e833e9702..7616d71df68e 100644
> --- a/rust/kernel/workqueue.rs
> +++ b/rust/kernel/workqueue.rs
> @@ -212,7 +212,7 @@ macro_rules! new_delayed_work {
>          $crate::workqueue::DelayedWork::new(
>              $crate::optional_name!(),
>              $crate::static_lock_class!(),
> -            $crate::c_str!(::core::concat!(
> +            $crate::str_to_cstr!(::core::concat!(
>                  ::core::file!(),
>                  ":",
>                  ::core::line!(),
> @@ -223,9 +223,9 @@ macro_rules! new_delayed_work {
>      };
>      ($name:literal) => {
>          $crate::workqueue::DelayedWork::new(
> -            $crate::c_str!($name),
> +            $crate::str_to_cstr!($name),
>              $crate::static_lock_class!(),
> -            $crate::c_str!(::core::concat!($name, "_timer")),
> +            $crate::str_to_cstr!(::core::concat!($name, "_timer")),
>              $crate::static_lock_class!(),
>          )
>      };
>
> ---
> base-commit: 11439c4635edd669ae435eec308f4ab8a0804808
> change-id: 20260302-cstr-rename-macro-64201be6c969
>
> Best regards,
> --  
> Tamir Duberstein <tamird@kernel.org>