WIP: json-sysctl: add a chrdev

Depends on some changes to core that we should land with a bit more consideration

Author: geofft

src/chrdev.rs

@@ -125,7 +125,7 @@ unsafe extern "C" fn read_callback<T: FileOperations>(
     };
     let f = &*((*file).private_data as *const T);
     // TODO: Pass offset to read()?
-    match f.read(&mut data) {
+    match f.read(&mut data, *offset) {
         Ok(()) => {
             let written = len - data.len();
             (*offset) += written as bindings::loff_t;
@@ -191,5 +191,5 @@ pub trait FileOperations: Sync + Sized {
     const VTABLE: FileOperationsVtable;
 
     fn open() -> KernelResult<Self>;
-    fn read(&self, buf: &mut UserSlicePtrWriter) -> KernelResult<()>;
+    fn read(&self, buf: &mut UserSlicePtrWriter, offset: i64) -> KernelResult<()>;
 }

src/lib.rs

@@ -9,7 +9,7 @@ mod allocator;
 pub mod bindings;
 mod c_types;
 pub mod chrdev;
-mod error;
+pub mod error;
 pub mod filesystem;
 pub mod printk;
 pub mod sysctl;

tests/json-sysctl/src/lib.rs

@@ -2,18 +2,64 @@
 #![feature(const_str_as_bytes)]
 
 use core::sync::atomic::{AtomicBool, Ordering};
+use core::convert::TryInto;
 
 use serde::Serialize;
 use serde_json_core;
 
-use linux_kernel_module::sysctl::Sysctl;
+use linux_kernel_module::sysctl::{Sysctl, SysctlStorage};
 use linux_kernel_module::Mode;
+use linux_kernel_module::error;
 use linux_kernel_module::println;
+use linux_kernel_module::user_ptr::UserSlicePtrWriter;
+
+struct Reference(&'static AtomicBool);
+
+impl SysctlStorage for Reference {
+    fn store_value(&self, data: &[u8]) -> (usize, error::KernelResult<()>) {
+        self.0.store_value(&*data)
+    }
+    fn read_value(&self, data: &mut UserSlicePtrWriter) -> (usize, error::KernelResult<()>) {
+        self.0.read_value(&mut *data)
+    }
+}
+
+static A: AtomicBool = AtomicBool::new(false);
+static B: AtomicBool = AtomicBool::new(false);
+static C: AtomicBool = AtomicBool::new(false);
+
+struct JsonChrdev;
+
+impl linux_kernel_module::chrdev::FileOperations for JsonChrdev {
+    const VTABLE: linux_kernel_module::chrdev::FileOperationsVtable =
+        linux_kernel_module::chrdev::FileOperationsVtable::new::<Self>();
+
+    fn open() -> linux_kernel_module::KernelResult<Self> {
+        Ok(JsonChrdev)
+    }
+
+    fn read(
+        &self,
+        buf: &mut linux_kernel_module::user_ptr::UserSlicePtrWriter,
+        offset: i64,
+    ) -> linux_kernel_module::KernelResult<()> {
+        let o = Output {
+            a: A.load(Ordering::Relaxed),
+            b: B.load(Ordering::Relaxed),
+            c: C.load(Ordering::Relaxed),
+        };
+        let mut s = serde_json_core::to_string::<typenum::U32, _>(&o).map_err(|_| error::Error::ENOMEM)?;
+        s.push_str("\n").map_err(|_| error::Error::ENOMEM)?;
+        buf.write(&s.into_bytes()[offset.try_into()?..])?;
+        Ok(())
+    }
+}
 
 struct JsonSysctlModule {
-    a: Sysctl<AtomicBool>,
-    b: Sysctl<AtomicBool>,
-    c: Sysctl<AtomicBool>,
+    _a: Sysctl<Reference>,
+    _b: Sysctl<Reference>,
+    _c: Sysctl<Reference>,
+    _chrdev_registration: linux_kernel_module::chrdev::Registration,
 }
 
 #[derive(Serialize)]
@@ -25,40 +71,33 @@ struct Output {
 
 impl linux_kernel_module::KernelModule for JsonSysctlModule {
     fn init() -> linux_kernel_module::KernelResult<Self> {
+        let chrdev_registration = linux_kernel_module::chrdev::builder("json\x00", 0..1)?
+            .register_device::<JsonChrdev>()
+            .build()?;
         Ok(JsonSysctlModule {
-            a: Sysctl::register(
+            _a: Sysctl::register(
                 "json-sysctl\x00",
                 "a\x00",
-                AtomicBool::new(false),
+                Reference(&A),
                 Mode::from_int(0o666),
             )?,
-            b: Sysctl::register(
+            _b: Sysctl::register(
                 "json-sysctl\x00",
                 "b\x00",
-                AtomicBool::new(false),
+                Reference(&B),
                 Mode::from_int(0o666),
             )?,
-            c: Sysctl::register(
+            _c: Sysctl::register(
                 "json-sysctl\x00",
                 "c\x00",
-                AtomicBool::new(false),
+                Reference(&C),
                 Mode::from_int(0o666),
             )?,
+            _chrdev_registration: chrdev_registration,
         })
     }
 }
 
-impl Drop for JsonSysctlModule {
-    fn drop(&mut self) {
-        let o = Output {
-            a: self.a.get().load(Ordering::Relaxed),
-            b: self.b.get().load(Ordering::Relaxed),
-            c: self.c.get().load(Ordering::Relaxed),
-        };
-        println!("{}", serde_json_core::to_string::<typenum::U32, _>(&o).unwrap());
-    }
-}
-
 linux_kernel_module::kernel_module!(
     JsonSysctlModule,
     author: "Alex Gaynor and Geoffrey Thomas",