Refactor the CStr API to reduce the need for nightly features

src/chrdev.rs

@@ -12,7 +12,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,
@@ -21,7 +21,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>,
 }

src/filesystem.rs

@@ -22,7 +22,7 @@ impl<T: FileSystem> Drop for Registration<T> {
 }
 
 pub trait FileSystem: Sync {
-    const NAME: &'static CStr;
+    const NAME: CStr<'static>;
     const FLAGS: FileSystemFlags;
 }
 

src/lib.rs

@@ -1,5 +1,5 @@
 #![no_std]
-#![feature(allocator_api, alloc_error_handler, const_raw_ptr_deref)]
+#![feature(allocator_api, alloc_error_handler)]
 
 extern crate alloc;
 

src/sysctl.rs

@@ -118,8 +118,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>> {

src/types.rs

@@ -17,31 +17,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 {

tests/filesystem/src/lib.rs

@@ -12,7 +12,7 @@ struct TestFSModule {
 struct TestFS {}
 
 impl FileSystem for TestFS {
-    const NAME: &'static CStr = cstr!("testfs");
+    const NAME: CStr<'static> = cstr!("testfs");
     const FLAGS: FileSystemFlags = FileSystemFlags::empty();
 }
 

tests/utils/src/lib.rs

@@ -3,7 +3,7 @@
 struct UtilsTestModule;
 
 #[allow(dead_code)]
-const TEST_CSTR: &linux_kernel_module::CStr = linux_kernel_module::cstr!("abc");
+const TEST_CSTR: linux_kernel_module::CStr<'static> = linux_kernel_module::cstr!("abc");
 
 impl linux_kernel_module::KernelModule for UtilsTestModule {
     fn init() -> linux_kernel_module::KernelResult<Self> {