Add support for charp and some primitive parameter types

Author: adamrk

rust/kernel/c_types.rs

@@ -51,3 +51,9 @@ mod c {
 }
 
 pub use c::*;
+
+/// Reads string until null byte is reached and returns slice excluding the terminating null.
+pub unsafe fn c_string_bytes(ptr: *const crate::c_types::c_char) -> &'static [u8] {
+    let length = crate::bindings::strlen(ptr) as usize;
+    &core::slice::from_raw_parts(ptr as *const u8, length)
+}

rust/module.rs

@@ -160,7 +160,7 @@ fn build_modinfo_string_param(module: &str, field: &str, param: &str, content: &
 /// The `type` argument should be a type which implements the [`KernelModule`] trait.
 /// Also accepts various forms of kernel metadata.
 ///
-/// Example:
+/// ## Example
 /// ```rust,no_run
 /// use kernel::prelude::*;
 ///
@@ -170,17 +170,38 @@ fn build_modinfo_string_param(module: &str, field: &str, param: &str, content: &
 ///     author: b"Rust for Linux Contributors",
 ///     description: b"My very own kernel module!",
 ///     license: b"GPL v2",
-///     params: {},
+///     params: {
+///        my_i32: i32 {
+///            default: 42,
+///            permissions: 0o644,
+///            description: b"Example of i32",
+///        },
+///    },
 /// }
 ///
 /// struct MyKernelModule;
 ///
 /// impl KernelModule for MyKernelModule {
 ///     fn init() -> KernelResult<Self> {
+///         println!("i32 param is:  {}", my_i32.read());
 ///         Ok(MyKernelModule)
 ///     }
 /// }
 /// ```
+/// 
+/// ## Suported Parameter Types
+///
+/// - `bool`    - Corresponds to C `bool` param type.
+/// - `u8`      - Corresponds to C `char` param type.
+/// - `i16`     - Corresponds to C `short` param type.
+/// - `u16`     - Corresponds to C `ushort` param type.
+/// - `i32`     - Corresponds to C `int` param type.
+/// - `u32`     - Corresponds to C `uint` param type.
+/// - `u64`     - Corresponds to C `ullong` param type.
+/// - `invbool` - Corresponds to C `invbool` param type
+///               Value is inverse of user input.
+/// - `str`     - Corresponds to C `charp` param type.
+///               `read` returns a &[u8].
 #[proc_macro]
 pub fn module(ts: TokenStream) -> TokenStream {
     let mut it = ts.into_iter();
@@ -215,10 +236,10 @@ pub fn module(ts: TokenStream) -> TokenStream {
         assert_eq!(group.delimiter(), Delimiter::Brace);
 
         let mut param_it = group.stream().into_iter();
-        let param_default = if param_type == "bool" {
-            get_ident(&mut param_it, "default")
-        } else {
-            get_literal(&mut param_it, "default")
+        let param_default = match param_type.as_ref() {
+            "bool" | "invbool" => get_ident(&mut param_it, "default"),
+            "str" => get_byte_string(&mut param_it, "default"),
+            _ => get_literal(&mut param_it, "default"),
         };
         let param_permissions = get_literal(&mut param_it, "permissions");
         let param_description = get_byte_string(&mut param_it, "description");
@@ -228,7 +249,14 @@ pub fn module(ts: TokenStream) -> TokenStream {
         // TODO: other kinds: arrays, unsafes, etc.
         let param_kernel_type = match param_type.as_ref() {
             "bool" => "bool",
+            "u8" => "char",
+            "i16" => "short",
+            "u16" => "ushort",
             "i32" => "int",
+            "u32" => "uint",
+            "u64" => "ullong",
+            "invbool" => "invbool",
+            "str" => "charp",
             t => panic!("Unrecognized type {}", t),
         };
 
@@ -244,18 +272,57 @@ pub fn module(ts: TokenStream) -> TokenStream {
             &param_name,
             &param_description,
         ));
+        let param_type_internal = match param_type.as_ref() {
+            "str" => "*mut kernel::c_types::c_char",
+            "invbool" => "bool",
+            _ => &param_type,
+        };
+        let param_default = match param_type.as_ref() {
+            "str" => format!("b\"{}\0\" as *const _ as *mut kernel::c_types::c_char", param_default),
+            _ => param_default,
+        };
+        let read_func = match param_type.as_ref() {
+            "str" => format!(
+                "
+                    fn read(&self) -> &[u8] {{
+                        // SAFETY: The pointer is provided either in `param_default` when building the module,
+                        //        or by the kernel through `set_param_charp`. Both will be valid C strings.
+                        unsafe {{
+                            kernel::c_types::c_string_bytes(__{name}_{param_name}_value)
+                        }}
+                    }}
+                ",
+                name = name,
+                param_name = param_name,
+            ),
+            _ => format!(
+                "
+                    fn read(&self) -> {param_type_internal} {{
+                        unsafe {{ __{name}_{param_name}_value }}
+                    }}
+                ",
+                name = name,
+                param_name = param_name,
+                param_type_internal = param_type_internal,
+            ),
+        };
+        let kparam = format!(
+            "
+                kernel::bindings::kernel_param__bindgen_ty_1 {{
+                    arg: unsafe {{ &__{name}_{param_name}_value }} as *const _ as *mut kernel::c_types::c_void,
+                }},
+            ",
+            name = name,
+            param_name = param_name,
+        );
         params_modinfo.push_str(
             &format!(
                 "
-                static mut __{name}_{param_name}_value: {param_type} = {param_default};
+                static mut __{name}_{param_name}_value: {param_type_internal} = {param_default};
 
                 struct __{name}_{param_name};
 
-                impl __{name}_{param_name} {{
-                    fn read(&self) -> {param_type} {{
-                        unsafe {{ __{name}_{param_name}_value }}
-                    }}
-                }}
+                impl __{name}_{param_name} {{ {read_func} }}
 
                 const {param_name}: __{name}_{param_name} = __{name}_{param_name};
 
@@ -288,17 +355,17 @@ pub fn module(ts: TokenStream) -> TokenStream {
                     perm: {permissions},
                     level: -1,
                     flags: 0,
-                    __bindgen_anon_1: kernel::bindings::kernel_param__bindgen_ty_1 {{
-                        arg: unsafe {{ &__{name}_{param_name}_value }} as *const _ as *mut kernel::c_types::c_void,
-                    }},
+                    __bindgen_anon_1: {kparam}
                 }});
                 ",
                 name = name,
-                param_type = param_type,
+                param_type_internal = param_type_internal,
+                read_func = read_func,
                 param_kernel_type = param_kernel_type,
                 param_default = param_default,
                 param_name = param_name,
                 permissions = param_permissions,
+                kparam = kparam,
             )
         );
     }