Very close now

Author: alex

build.rs

@@ -16,10 +16,12 @@ const INCLUDED_FUNCTIONS: &[&str] = &[
     "kill_litter_super",
     "register_sysctl",
     "unregister_sysctl_table",
+    "access_ok",
 ];
 const INCLUDED_VARS: &[&str] = &[
     "EINVAL",
     "ENOMEM",
+    "EFAULT",
     "__this_module",
     "FS_REQUIRES_DEV",
     "FS_BINARY_MOUNTDATA",
@@ -28,6 +30,7 @@ const INCLUDED_VARS: &[&str] = &[
     "FS_RENAME_DOES_D_MOVE",
     "BINDINGS_GFP_KERNEL",
     "KERN_INFO",
+    "VERIFY_WRITE",
 ];
 
 fn main() {
@@ -74,6 +77,7 @@ fn main() {
     let mut builder = cc::Build::new();
     println!("cargo:rerun-if-env-changed=CLANG");
     builder.compiler(env::var("CLANG").unwrap_or("clang".to_string()));
+    builder.warnings(false);
     builder.file("src/helpers.c");
     for arg in shlex::split(&output).unwrap() {
         builder.flag(&arg);

src/bindings_helper.h

@@ -1,6 +1,7 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/slab.h>
+#include <linux/uaccess.h>
 
 // Bindgen gets confused at certain things
 //

src/error.rs

@@ -6,6 +6,7 @@ pub struct Error(c_types::c_int);
 impl Error {
     pub const EINVAL: Self = Error(-(bindings::EINVAL as i32));
     pub const ENOMEM: Self = Error(-(bindings::ENOMEM as i32));
+    pub const EFAULT: Self = Error(-(bindings::EFAULT as i32));
 
     pub fn from_kernel_errno(errno: c_types::c_int) -> Error {
         return Error(errno);

src/helpers.c

@@ -1,5 +1,7 @@
 #include <linux/bug.h>
 #include <linux/printk.h>
+#include <linux/uaccess.h>
+
 
 int printk_helper(const unsigned char *s, int len)
 {
@@ -10,3 +12,8 @@ void bug_helper(void)
 {
     BUG();
 }
+
+int access_ok_helper(unsigned int mode, const void __user *addr, unsigned long n)
+{
+    return access_ok(mode, addr, n);
+}

src/lib.rs

@@ -13,6 +13,7 @@ pub mod filesystem;
 pub mod printk;
 pub mod sysctl;
 mod types;
+pub mod user_ptr;
 
 pub use alloc::format;
 pub use error::{Error, KernelResult};

src/sysctl.rs

@@ -7,6 +7,7 @@ use bindings;
 use c_types;
 use error;
 use types;
+use user_ptr::UserSlicePtr;
 
 pub struct Sysctl<T: Sync> {
     inner: Box<T>,
@@ -21,7 +22,20 @@ unsafe extern "C" fn proc_handler<T>(
     len: *mut usize,
     ppos: *mut bindings::loff_t,
 ) -> c_types::c_int {
-    unimplemented!();
+    let data = match UserSlicePtr::new(buffer, *len) {
+        Ok(ptr) => ptr,
+        Err(e) => return e.to_kernel_errno(),
+    };
+    let storage = (*ctl).data as *mut T as Box<T>;
+    let (bytes_processed, result) = if write != 0 {
+        let data = data.read_all()?;
+        storage.store_value(&data)
+    } else {
+        storage.read_value(&data)
+    };
+    *len -= bytes_processed;
+    *ppos += bytes_processed;
+    return result;
 }
 
 impl<T: Sync> Sysctl<T> {

src/user_ptr.rs

@@ -0,0 +1,29 @@
+use alloc::Vec;
+
+use bindings;
+use c_types;
+use error;
+
+extern "C" {
+    fn access_ok_helper(
+        mode: c_types::c_uint,
+        addr: *const c_types::c_void,
+        len: c_types::c_ulong,
+    ) -> c_types::c_int;
+}
+
+pub struct UserSlicePtr(*mut c_types::c_void, usize);
+
+impl UserSlicePtr {
+    pub fn new(ptr: *mut c_types::c_void, length: usize) -> error::KernelResult<UserSlicePtr> {
+        if unsafe { access_ok_helper(bindings::VERIFY_WRITE, ptr, length as c_types::c_ulong) } != 0
+        {
+            return Err(error::Error::EFAULT);
+        }
+        return Ok(UserSlicePtr(ptr, length));
+    }
+
+    pub fn read_all(self) -> error::KernelResult<Vec<u8>> {
+        unimplemented!();
+    }
+}