[PATCH v2] rust: update `kernel::c_str!` documentation

[PATCH v2] rust: update `kernel::c_str!` documentation

[Tamir Duberstein]

Now that all literals are C-Strings, update the documentation to explain
that use of this macro should be limited to non-literal strings.

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.
---
Changes in v2:
- Drop rename, keep only documentation update. (Gary Guo)
- Add example of misuse to documentation. (Gary Guo)
- Link to v1: https://patch.msgid.link/20260302-cstr-rename-macro-v1-1-a269fe4dc3f0@kernel.org
---
 rust/kernel/str.rs | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs
index fa87779d2253..6dae82e7d875 100644
--- a/rust/kernel/str.rs
+++ b/rust/kernel/str.rs
@@ -376,19 +376,32 @@ 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::CStr;
-/// const MY_CSTR: &CStr = c_str!("My awesome CStr!");
+/// // This is allowed, but `c"literal"` should be preferred for literals.
+/// const BAD: &CStr = c_str!("literal");
+///
+/// // `c_str!` is still needed for static non-literal C strings.
+/// const GOOD: &CStr = c_str!(concat!(file!(), ":", line!(), ": My CStr!"));
 /// ```
 #[macro_export]
 macro_rules! c_str {
+    // 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.
     ($str:expr) => {{
         const S: &str = concat!($str, "\0");
         const C: &$crate::str::CStr = match $crate::str::CStr::from_bytes_with_nul(S.as_bytes()) {

---
base-commit: 11439c4635edd669ae435eec308f4ab8a0804808
change-id: 20260302-cstr-rename-macro-64201be6c969

Best regards,
--  
Tamir Duberstein <tamird@kernel.org>

Claude review: rust: update `kernel::c_str!` documentation

[Claude Code Review Bot]

Overall Series Review

Subject: rust: update `kernel::c_str!` documentation
Author: Tamir Duberstein <tamird@kernel.org>
Patches: 1
Reviewed: 2026-03-10T12:05:04.277925

---

This is a single, straightforward documentation-only patch. It updates the `kernel::c_str!` macro documentation to reflect that Rust now has native C string literals (`c"..."` since Rust 1.77), and that the macro's primary remaining use case is for non-literal compile-time C strings (e.g., inside other macros using `concat!`). The patch is well-motivated, clearly written, and already carries reviews from Alice Ryhl and an ack from Greg KH.

No functional code changes are made. The patch looks correct and ready to merge.

---
Generated by Claude Code Patch Reviewer

Claude review: rust: update `kernel::c_str!` documentation

[Claude Code Review Bot]

Patch Review

**Summary:** Updates the doc comment on `c_str!` to explain that `c"literal"` syntax should be preferred for string literals, and that `c_str!` remains useful for non-literal compile-time strings (e.g. `concat!(file!(), ...)`). Also adds a comment explaining why a `compile_error!` arm for literal arguments was intentionally omitted.

**Positive observations:**

1. The updated doc comment at line 379-383 is clear and well-written, correctly explaining the relationship between `c"..."` literals and the macro.

2. The new "Panics" section (lines 385-387) documenting the interior NUL panic behavior is a good addition — the old documentation only said "should not contain any `NUL` bytes" without specifying what happens.

3. The example is well-chosen:
   ```rust
   // This is allowed, but `c"literal"` should be preferred for literals.
   const BAD: &CStr = c_str!("literal");
   
   // `c_str!` is still needed for static non-literal C strings.
   const GOOD: &CStr = c_str!(concat!(file!(), ":", line!(), ": My CStr!"));
   ```
   Naming the first example `BAD` and the second `GOOD` makes the intent immediately obvious.

4. The NB comment at lines 402-404 explaining the design decision not to add a `compile_error!` arm for `$str:lit` is valuable — it preempts the natural follow-up question of "why not just reject literals?" and explains that it would break macro authors who happen to have a literal at the top of expansions.

**Minor observations:**

- The "Panics" section says the macro "panics" — technically it's a compile-time `panic!` (since it's used in a `const` context), which is a compilation error, not a runtime panic. This is arguably a pedantic distinction and the current wording matches Rust documentation conventions, so it's fine as-is.

**Verdict:** Looks good. No issues found.

---
Generated by Claude Code Patch Reviewer