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

[Tamir Duberstein <tamird@kernel.org>]

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>
---
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!"));
 /// ```
 #[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>