Backport CStr improvement to remove need for a nightly feature

rust/kernel/src/chrdev.rs

@@ -14,7 +14,7 @@ use crate::error::{Error, KernelResult};
 use crate::file_operations;
 use crate::types::CStr;
 
-pub fn builder(name: &'static CStr, minors: Range<u16>) -> KernelResult<Builder> {
+pub fn builder(name: CStr<'static>, minors: Range<u16>) -> KernelResult<Builder> {
     Ok(Builder {
         name,
         minors,
@@ -23,7 +23,7 @@ pub fn builder(name: &'static CStr, minors: Range<u16>) -> KernelResult<Builder>
 }
 
 pub struct Builder {
-    name: &'static CStr,
+    name: CStr<'static>,
     minors: Range<u16>,
     file_ops: Vec<&'static bindings::file_operations>,
 }

rust/kernel/src/lib.rs

@@ -3,7 +3,7 @@
 //! The `kernel` crate
 
 #![no_std]
-#![feature(allocator_api, alloc_error_handler, const_raw_ptr_deref)]
+#![feature(allocator_api, alloc_error_handler)]
 
 extern crate alloc;
 

rust/kernel/src/sysctl.rs

@@ -120,8 +120,8 @@ unsafe extern "C" fn proc_handler<T: SysctlStorage>(
 
 impl<T: SysctlStorage> Sysctl<T> {
     pub fn register(
-        path: &'static types::CStr,
-        name: &'static types::CStr,
+        path: types::CStr<'static>,
+        name: types::CStr<'static>,
         storage: T,
         mode: types::Mode,
     ) -> error::KernelResult<Sysctl<T>> {

rust/kernel/src/types.rs

@@ -19,31 +19,31 @@ impl Mode {
 /// A string that is guaranteed to have exactly one NUL byte, which is at the
 /// end. Used for interoperability with kernel APIs that take C strings.
 #[repr(transparent)]
-pub struct CStr(str);
+pub struct CStr<'a>(&'a str);
 
-impl CStr {
+impl CStr<'_> {
     /// Creates a new CStr from a str without performing any additional checks.
     /// # Safety
     ///
     /// `data` _must_ end with a NUL byte, and should only have only a single
     /// NUL byte, or the string will be truncated.
-    pub const unsafe fn new_unchecked(data: &str) -> &CStr {
-        &*(data as *const str as *const CStr)
+    pub const unsafe fn new_unchecked(data: &str) -> CStr {
+        CStr(data)
     }
 }
 
-impl Deref for CStr {
+impl Deref for CStr<'_> {
     type Target = str;
 
     fn deref(&self) -> &str {
-        &self.0
+        self.0
     }
 }
 
 /// Creates a new `CStr` from a string literal. The string literal should not contain any NUL
 /// bytes. Example usage:
 /// ```
-/// const MY_CSTR: &CStr = cstr!("My awesome CStr!");
+/// const MY_CSTR: CStr<'static> = cstr!("My awesome CStr!");
 /// ```
 #[macro_export]
 macro_rules! cstr {