Add charp and some primitive param types.

adamrk · adamrk · commit 3adc0d5b1f90 · 2021-01-23T01:54:11.000+01:00
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -156,18 +156,26 @@ jobs:
       # Run
       - run: ${{ env.BUILD_DIR }}usr/gen_init_cpio .github/workflows/qemu-initramfs.desc > qemu-initramfs.img
 
-      - run: qemu-system-${{ env.QEMU_ARCH }} -kernel ${{ env.BUILD_DIR }}${{ env.IMAGE_PATH }} -initrd qemu-initramfs.img -M ${{ env.QEMU_MACHINE }} -cpu ${{ env.QEMU_CPU }} -smp 2 -nographic -no-reboot -append '${{ env.QEMU_APPEND }} rust_example.my_i32=123321 rust_example_2.my_i32=234432' | tee qemu-stdout.log
+      - run: qemu-system-${{ env.QEMU_ARCH }} -kernel ${{ env.BUILD_DIR }}${{ env.IMAGE_PATH }} -initrd qemu-initramfs.img -M ${{ env.QEMU_MACHINE }} -cpu ${{ env.QEMU_CPU }} -smp 2 -nographic -no-reboot -append '${{ env.QEMU_APPEND }} rust_example.my_i32=123321 rust_example.my_str=🦀mod rust_example.my_invbool=y rust_example_2.my_i32=234432' | tee qemu-stdout.log
 
       # Check
       - run: grep -F     '] Rust Example (init)' qemu-stdout.log
       - run: grep -F '] [2] Rust Example (init)' qemu-stdout.log
       - run: grep -F '] [3] Rust Example (init)' qemu-stdout.log
       - run: grep -F '] [4] Rust Example (init)' qemu-stdout.log
 
-      - run: "grep -F     ']   my_i32:   123321' qemu-stdout.log"
-      - run: "grep -F '] [2]   my_i32:   234432' qemu-stdout.log"
-      - run: "grep -F '] [3]   my_i32:   345543' qemu-stdout.log"
-      - run: "grep -F '] [4]   my_i32:   456654' qemu-stdout.log"
+      - run: "grep -F     ']   my_i32:     123321' qemu-stdout.log"
+      - run: "grep -F '] [2]   my_i32:     234432' qemu-stdout.log"
+      - run: "grep -F '] [3]   my_i32:     345543' qemu-stdout.log"
+      - run: "grep -F '] [4]   my_i32:     456654' qemu-stdout.log"
+
+      - run: "grep -F     ']   my_invbool: false'  qemu-stdout.log"
+      - run: "grep -F '] [2]   my_invbool: true'   qemu-stdout.log"
+
+      - run: "grep            '\\]   my_str:     🦀mod\\s*$'           qemu-stdout.log"
+      - run: "grep    '\\] \\[2\\]   my_str:     default str val\\s*$' qemu-stdout.log"
+      - run: "grep    '\\] \\[3\\]   my_str:     🦀mod\\s*$'           qemu-stdout.log"
+      - run: "grep    '\\] \\[4\\]   my_str:     default str val\\s*$' qemu-stdout.log"
 
       - run: grep -F '] [3] Rust Example (exit)' qemu-stdout.log
       - run: grep -F '] [4] Rust Example (exit)' qemu-stdout.log
diff --git a/.github/workflows/qemu-init.sh b/.github/workflows/qemu-init.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 
-busybox insmod rust_example_3.ko my_i32=345543
+busybox insmod rust_example_3.ko my_i32=345543 my_str=🦀mod
 busybox insmod rust_example_4.ko my_i32=456654
 busybox  rmmod rust_example_3.ko
 busybox  rmmod rust_example_4.ko
diff --git a/drivers/char/rust_example.rs b/drivers/char/rust_example.rs
@@ -25,6 +25,16 @@ module! {
             permissions: 0o644,
             description: b"Example of i32",
         },
+        my_str: str {
+            default: b"default str val",
+            permissions: 0o644,
+            description: b"Example of a string param",
+        },
+        my_invbool: invbool {
+            default: true,
+            permissions: 0o644,
+            description: b"Example of an inverted bool",
+        },
     },
 }
 
@@ -49,8 +59,13 @@ impl KernelModule for RustExample {
         println!("Rust Example (init)");
         println!("Am I built-in? {}", !cfg!(MODULE));
         println!("Parameters:");
-        println!("  my_bool:  {}", my_bool.read());
-        println!("  my_i32:   {}", my_i32.read());
+        println!("  my_bool:    {}", my_bool.read());
+        println!("  my_i32:     {}", my_i32.read());
+        println!(
+            "  my_str:     {}",
+            my_str.read().expect("Expected valid UTF8 parameter")
+        );
+        println!("  my_invbool: {}", my_invbool.read());
 
         Ok(RustExample {
             message: "on the heap!".to_owned(),
diff --git a/drivers/char/rust_example_2.rs b/drivers/char/rust_example_2.rs
@@ -22,6 +22,16 @@ module! {
             permissions: 0o644,
             description: b"Example of i32",
         },
+        my_str: str {
+            default: b"default str val",
+            permissions: 0o644,
+            description: b"Example of a string param",
+        },
+        my_invbool: invbool {
+            default: true,
+            permissions: 0o644,
+            description: b"Example of an inverted bool",
+        },
     },
 }
 
@@ -34,8 +44,13 @@ impl KernelModule for RustExample2 {
         println!("[2] Rust Example (init)");
         println!("[2] Am I built-in? {}", !cfg!(MODULE));
         println!("[2] Parameters:");
-        println!("[2]   my_bool:  {}", my_bool.read());
-        println!("[2]   my_i32:   {}", my_i32.read());
+        println!("[2]   my_bool:    {}", my_bool.read());
+        println!("[2]   my_i32:     {}", my_i32.read());
+        println!(
+            "[2]   my_str:     {}",
+            my_str.read().expect("Expected valid UTF8 parameter")
+        );
+        println!("[2]   my_invbool: {}", my_invbool.read());
         Ok(RustExample2 {
             message: "on the heap!".to_owned(),
         })
diff --git a/drivers/char/rust_example_3.rs b/drivers/char/rust_example_3.rs
@@ -22,6 +22,16 @@ module! {
             permissions: 0o644,
             description: b"Example of i32",
         },
+        my_str: str {
+            default: b"default str val",
+            permissions: 0o644,
+            description: b"Example of a string param",
+        },
+        my_invbool: invbool {
+            default: true,
+            permissions: 0o644,
+            description: b"Example of an inverted bool",
+        },
     },
 }
 
@@ -34,8 +44,14 @@ impl KernelModule for RustExample3 {
         println!("[3] Rust Example (init)");
         println!("[3] Am I built-in? {}", !cfg!(MODULE));
         println!("[3] Parameters:");
-        println!("[3]   my_bool:  {}", my_bool.read());
-        println!("[3]   my_i32:   {}", my_i32.read());
+        println!("[3]   my_bool:    {}", my_bool.read());
+        println!("[3]   my_i32:     {}", my_i32.read());
+        println!(
+            "[3]   my_str:     {}",
+            my_str.read().expect("Expected valid UTF8 parameter")
+        );
+        println!("[3]   my_invbool: {}", my_invbool.read());
+
         Ok(RustExample3 {
             message: "on the heap!".to_owned(),
         })
diff --git a/drivers/char/rust_example_4.rs b/drivers/char/rust_example_4.rs
@@ -22,6 +22,16 @@ module! {
             permissions: 0o644,
             description: b"Example of i32",
         },
+        my_str: str {
+            default: b"default str val",
+            permissions: 0o644,
+            description: b"Example of a string param",
+        },
+        my_invbool: invbool {
+            default: true,
+            permissions: 0o644,
+            description: b"Example of an inverted bool",
+        },
     },
 }
 
@@ -34,8 +44,13 @@ impl KernelModule for RustExample4 {
         println!("[4] Rust Example (init)");
         println!("[4] Am I built-in? {}", !cfg!(MODULE));
         println!("[4] Parameters:");
-        println!("[4]   my_bool:  {}", my_bool.read());
-        println!("[4]   my_i32:   {}", my_i32.read());
+        println!("[4]   my_bool:    {}", my_bool.read());
+        println!("[4]   my_i32:     {}", my_i32.read());
+        println!(
+            "[4]   my_str:     {}",
+            my_str.read().expect("Expected valid UTF8 parameter")
+        );
+        println!("[4]   my_invbool: {}", my_invbool.read());
         Ok(RustExample4 {
             message: "on the heap!".to_owned(),
         })
diff --git a/rust/module.rs b/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,36 @@ 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` signature is `read(&self) -> Result<&str, core::str::Utf8Error>`.
 #[proc_macro]
 pub fn module(ts: TokenStream) -> TokenStream {
     let mut it = ts.into_iter();
@@ -215,10 +234,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 +247,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 +270,59 @@ pub fn module(ts: TokenStream) -> TokenStream {
             &param_name,
             &param_description,
         ));
+        let param_type_internal = match param_type.as_ref() {
+            "str" => "*mut u8",
+            "invbool" => "bool",
+            _ => &param_type,
+        };
+        let param_default = match param_type.as_ref() {
+            "str" => format!("b\"{}\0\" as *const u8 as *mut u8", param_default),
+            _ => param_default,
+        };
+        let read_func = match param_type.as_ref() {
+            "str" => format!(
+                "
+                    fn read(&self) -> Result<&str, core::str::Utf8Error> {{
+                        unsafe {{
+                            let mut count = 0;
+                            while *__{name}_{param_name}_value.add(count) != b'\0' {{
+                                count += 1;
+                            }}
+                            core::str::from_utf8(&core::slice::from_raw_parts(__{name}_{param_name}_value, count))
+                        }}
+                    }}
+                ",
+                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,
             )
         );
     }
