Add ModuleParam trait and new int params

Author: adamrk

rust/Makefile

@@ -46,7 +46,7 @@ $(objtree)/rust/bindings_generated.rs: $(srctree)/rust/kernel/bindings_helper.h
 quiet_cmd_exports = EXPORTS $@
       cmd_exports = \
 	$(NM) -p --defined-only $< \
-		| grep -F ' T ' | cut -d ' ' -f 3 | grep -E '^(__rust_|_R)' \
+		| grep -E '( T | R )' | cut -d ' ' -f 3 | grep -E '^(__rust_|_R)' \
 		| xargs -n1 -Isymbol \
 		echo 'EXPORT_SYMBOL$(exports_target_type)(symbol);' > $@
 

rust/kernel/buffer.rs

@@ -0,0 +1,31 @@
+use core::fmt;
+
+pub struct Buffer<'a> {
+    slice: &'a mut [u8],
+    pos: usize,
+}
+
+impl<'a> Buffer<'a> {
+    pub fn new(slice: &'a mut [u8]) -> Self {
+        Buffer {
+            slice,
+            pos: 0,
+        }
+    }
+
+    pub fn bytes_written(&self) -> usize {
+        self.pos
+    }
+}
+
+impl<'a> fmt::Write for Buffer<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        if s.len() > self.slice.len() - self.pos {
+            Err(fmt::Error)
+        } else {
+            self.slice[self.pos..self.pos + s.len()].copy_from_slice(s.as_bytes());
+            self.pos += s.len();
+            Ok(())
+        }
+    }
+}

rust/kernel/lib.rs

@@ -14,11 +14,13 @@ use core::panic::PanicInfo;
 
 mod allocator;
 pub mod bindings;
+mod buffer;
 pub mod c_types;
 pub mod chrdev;
 mod error;
 pub mod file_operations;
 pub mod miscdev;
+pub mod module_param;
 pub mod prelude;
 pub mod printk;
 pub mod random;
@@ -32,6 +34,8 @@ pub mod user_ptr;
 pub use crate::error::{Error, KernelResult};
 pub use crate::types::{CStr, Mode};
 
+pub const PAGE_SIZE: usize = 1 << bindings::PAGE_SHIFT;
+
 /// KernelModule is the top level entrypoint to implementing a kernel module. Your kernel module
 /// should implement the `init` method on it, which maps to the `module_init` macro in Linux C API.
 /// You can use this method to do whatever setup or registration your module should do. For any

rust/kernel/module_param.rs

@@ -0,0 +1,67 @@
+use core::fmt::Write;
+
+/// Types that can be used for module parameters.
+/// Note that displaying the type in `sysfs` will fail if `to_string` returns
+/// more than 4K bytes (including an additional null terminator).
+pub trait ModuleParam : core::fmt::Display + core::marker::Sized {
+    fn try_from_param_arg(arg: &[u8]) -> Option<Self>;
+
+    /// # Safety
+    ///
+    /// `val` must point to a valid null-terminated string. The `arg` field of
+    /// `param` must be an instance of `Self`.
+    unsafe extern "C" fn set_param(val: *const crate::c_types::c_char, param: *const crate::bindings::kernel_param) -> crate::c_types::c_int {
+        let arg = crate::c_types::c_string_bytes(val);
+        match Self::try_from_param_arg(arg) {
+            Some(new_value) => {
+                let old_value = (*param).__bindgen_anon_1.arg as *mut Self;
+                let _ = core::ptr::replace(old_value, new_value);
+                0
+            }
+            None => crate::error::Error::EINVAL.to_kernel_errno()
+        }
+    }
+
+    /// # Safety
+    ///
+    /// `buf` must be a buffer of length at least `kernel::PAGE_SIZE` that is
+    /// writeable. The `arg` field of `param` must be an instance of `Self`.
+    unsafe extern "C" fn get_param(buf: *mut crate::c_types::c_char, param: *const crate::bindings::kernel_param) -> crate::c_types::c_int {
+        let slice = core::slice::from_raw_parts_mut(buf as *mut u8, crate::PAGE_SIZE);
+        let mut buf = crate::buffer::Buffer::new(slice);
+        match write!(buf, "{}\0", *((*param).__bindgen_anon_1.arg as *mut Self)) {
+            Err(_) => crate::error::Error::EINVAL.to_kernel_errno(),
+            Ok(()) => buf.bytes_written() as crate::c_types::c_int,
+        }
+    }
+
+    /// # Safety
+    ///
+    /// The `arg` field of `param` must be an instance of `Self`.
+    unsafe extern "C" fn free(arg: *mut crate::c_types::c_void) {
+        core::ptr::drop_in_place(arg as *mut Self);
+    }
+}
+
+macro_rules! make_param_ops {
+    ($ops:ident, $ty:ident) => {
+        impl ModuleParam for $ty {
+            fn try_from_param_arg(arg: &[u8]) -> Option<Self> {
+                let utf8 = core::str::from_utf8(arg).ok()?;
+                utf8.parse::<$ty>().ok()
+            }
+        }
+
+        pub static $ops: crate::bindings::kernel_param_ops = crate::bindings::kernel_param_ops {
+            flags: 0,
+            set: Some(<$ty as crate::module_param::ModuleParam>::set_param),    
+            get: Some(<$ty as crate::module_param::ModuleParam>::get_param),
+            free: Some(<$ty as crate::module_param::ModuleParam>::free),
+        };
+    }
+}
+
+make_param_ops!(PARAM_OPS_I8, i8);
+make_param_ops!(PARAM_OPS_I64, i64);
+make_param_ops!(PARAM_OPS_USIZE, usize);
+make_param_ops!(PARAM_OPS_ISIZE, isize);

rust/module.rs

@@ -221,12 +221,16 @@ fn permissions_are_readonly(perms: &str) -> bool {
 /// # Supported Parameter Types
 ///
 /// - `bool`    - Corresponds to C `bool` param type.
+/// - `i8`      - No equivalent C 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.
+/// - `i64`     - No equivalent C param type.
 /// - `u64`     - Corresponds to C `ullong` param type.
+/// - `isize`   - No equivalent C param type.
+/// - `usize`   - No equivalent C param type.
 /// - `str`     - Corresponds to C `charp` param type.
 ///               Reading the param returns a `&[u8]`.
 ///
@@ -277,15 +281,19 @@ pub fn module(ts: TokenStream) -> TokenStream {
 
         // TODO: more primitive types
         // 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",
-            "str" => "charp",
+        let (param_kernel_type, ops) = match param_type.as_ref() {
+            "bool" => ("bool", "kernel::bindings::param_ops_bool"),
+            "i8" => ("i8", "kernel::module_param::PARAM_OPS_I8"),
+            "u8" => ("u8", "kernel::bindings::param_ops_char"),
+            "i16" => ("i16", "kernel::bindings::param_ops_short"),
+            "u16" => ("u16", "kernel::bindings::param_ops_ushort"),
+            "i32" => ("i32", "kernel::bindings::param_ops_int"),
+            "u32" => ("u32", "kernel::bindings::param_ops_uint"),
+            "i64" => ("i64", "kernel::module_param::PARAM_OPS_I64"),
+            "u64" => ("u64", "kernel::bindings::param_ops_ullong"),
+            "isize" => ("isize", "kernel::module_param::PARAM_OPS_ISIZE"),
+            "usize" => ("usize", "kernel::module_param::PARAM_OPS_USIZE"),
+            "str" => ("charp", "kernel::bindings::param_ops_charp"),
             t => panic!("Unrecognized type {}", t),
         };
 
@@ -409,7 +417,7 @@ pub fn module(ts: TokenStream) -> TokenStream {
                     mod_: unsafe {{ &kernel::bindings::__this_module as *const _ as *mut _ }},
                     #[cfg(not(MODULE))]
                     mod_: core::ptr::null_mut(),
-                    ops: unsafe {{ &kernel::bindings::param_ops_{param_kernel_type} }} as *const kernel::bindings::kernel_param_ops,
+                    ops: unsafe {{ &{ops} }} as *const kernel::bindings::kernel_param_ops,
                     perm: {permissions},
                     level: -1,
                     flags: 0,
@@ -419,9 +427,9 @@ pub fn module(ts: TokenStream) -> TokenStream {
                 name = name,
                 param_type_internal = param_type_internal,
                 read_func = read_func,
-                param_kernel_type = param_kernel_type,
                 param_default = param_default,
                 param_name = param_name,
+                ops = ops,
                 permissions = param_permissions,
                 kparam = kparam,
             )