Start hacking towards a test case

Author: alex

build.rs

@@ -8,6 +8,9 @@ use std::process::Command;
 
 const INCLUDED_TYPES: &[&str] = &["file_system_type", "mode_t", "umode_t", "ctl_table"];
 const INCLUDED_FUNCTIONS: &[&str] = &[
+    "cdev_add",
+    "cdev_alloc",
+    "cdev_del",
     "register_filesystem",
     "unregister_filesystem",
     "krealloc",

src/bindings_helper.h

@@ -1,3 +1,4 @@
+#include <linux/cdev.h>
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/slab.h>

src/c_types.rs

@@ -11,6 +11,9 @@ pub type c_ulong = u64;
 pub type c_ulonglong = u64;
 pub type c_ushort = u16;
 pub type c_schar = i8;
+pub type c_size_t = usize;
+pub type c_ssize_t = isize;
+
 // See explanation in rust/src/libstd/os/raw.rs
 #[repr(u8)]
 pub enum c_void {

src/chrdev.rs

@@ -1,21 +1,22 @@
+use core::default::Default;
 use core::ops::Range;
 
+use alloc::boxed::Box;
+
 use crate::bindings;
 use crate::c_types;
-use crate::error;
+use crate::error::{Error, KernelResult};
+use crate::user_ptr::{UserSlicePtr, UserSlicePtrWriter};
 
 pub struct DeviceNumberRegion {
     dev: bindings::dev_t,
     count: usize,
 }
 
 impl DeviceNumberRegion {
-    pub fn allocate(
-        minors: Range<usize>,
-        name: &'static str,
-    ) -> error::KernelResult<DeviceNumberRegion> {
+    pub fn allocate(minors: Range<usize>, name: &'static str) -> KernelResult<DeviceNumberRegion> {
         if !name.ends_with('\x00') {
-            return Err(error::Error::EINVAL);
+            return Err(Error::EINVAL);
         }
 
         let count = minors.end - minors.start;
@@ -29,10 +30,32 @@ impl DeviceNumberRegion {
             )
         };
         if res != 0 {
-            return Err(error::Error::from_kernel_errno(res));
+            return Err(Error::from_kernel_errno(res));
         }
         return Ok(DeviceNumberRegion { dev, count });
     }
+
+    pub fn register_device<T: FileOperations>(&mut self) -> KernelResult<DeviceRegistration> {
+        let cdev = unsafe { bindings::cdev_alloc() };
+        if cdev.is_null() {
+            return Err(Error::ENOMEM);
+        }
+        unsafe {
+            (*cdev).owner = &mut bindings::__this_module;
+            (*cdev).ops = &T::VTABLE.0 as *const bindings::file_operations;
+        }
+        let cdev = DeviceRegistration {
+            cdev,
+            _registration: self,
+        };
+        // TODO: Need to handle multiple register_device calls by going through the devs and
+        // erroring if we run out.
+        let rc = unsafe { bindings::cdev_add(cdev.cdev, self.dev, 1) };
+        if rc != 0 {
+            return Err(Error::from_kernel_errno(rc));
+        }
+        return Ok(cdev);
+    }
 }
 
 impl Drop for DeviceNumberRegion {
@@ -42,3 +65,70 @@ impl Drop for DeviceNumberRegion {
         }
     }
 }
+
+pub struct DeviceRegistration<'a> {
+    _registration: &'a DeviceNumberRegion,
+    cdev: *mut bindings::cdev,
+}
+
+impl Drop for DeviceRegistration<'_> {
+    fn drop(&mut self) {
+        unsafe {
+            bindings::cdev_del(self.cdev);
+        }
+    }
+}
+
+pub struct FileOperationsVtable(bindings::file_operations);
+
+unsafe extern "C" fn open_callback<T: FileOperations>(
+    _inode: *mut bindings::inode,
+    file: *mut bindings::file,
+) -> c_types::c_int {
+    let f = match T::open() {
+        Ok(f) => Box::new(f),
+        Err(e) => return e.to_kernel_errno(),
+    };
+    (*file).private_data = Box::into_raw(f) as *mut c_types::c_void;
+    return 0;
+}
+
+unsafe extern "C" fn read_callback<T: FileOperations>(
+    file: *mut bindings::file,
+    buf: *mut c_types::c_char,
+    len: c_types::c_size_t,
+    offset: *mut bindings::loff_t,
+) -> c_types::c_ssize_t {
+    let mut data = match UserSlicePtr::new(buf as *mut c_types::c_void, len) {
+        Ok(ptr) => ptr.writer(),
+        Err(e) => return e.to_kernel_errno() as c_types::c_ssize_t,
+    };
+    let f = &*((*file).private_data as *const T);
+    // TODO: Pass offset to read()?
+    match f.read(&mut data) {
+        Ok(()) => {
+            let written = len - data.len();
+            (*offset) += written as i64;
+            return written as c_types::c_ssize_t;
+        }
+        Err(e) => return e.to_kernel_errno() as c_types::c_ssize_t,
+    };
+}
+
+impl FileOperationsVtable {
+    pub fn new<T: FileOperations>() -> FileOperationsVtable {
+        return FileOperationsVtable(bindings::file_operations {
+            open: Some(open_callback::<T>),
+            read: Some(read_callback::<T>),
+
+            ..Default::default()
+        });
+    }
+}
+
+pub trait FileOperations: Sync + Sized {
+    const VTABLE: FileOperationsVtable;
+
+    fn open() -> KernelResult<Self>;
+    fn read(&self, buf: &mut UserSlicePtrWriter) -> KernelResult<()>;
+}

src/user_ptr.rs

@@ -125,6 +125,10 @@ impl UserSlicePtrReader {
 pub struct UserSlicePtrWriter(*mut c_types::c_void, usize);
 
 impl UserSlicePtrWriter {
+    pub fn len(&self) -> usize {
+        return self.1;
+    }
+
     pub fn write(&mut self, data: &[u8]) -> error::KernelResult<()> {
         if data.len() > self.1 || data.len() > u32::MAX as usize {
             return Err(error::Error::EFAULT);

tests/chrdev/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "chrdev-tests"
+version = "0.1.0"
+authors = ["Alex Gaynor <[email protected]>", "Geoffrey Thomas <[email protected]>"]
+edition = "2018"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+linux-kernel-module = { path = "../.." }

tests/chrdev/src/lib.rs

@@ -0,0 +1,49 @@
+#![no_std]
+#![feature(const_str_as_bytes)]
+
+use linux_kernel_module;
+
+struct CycleFile;
+
+impl linux_kernel_module::chrdev::FileOperations for CycleFile {
+    const VTABLE: linux_kernel_module::chrdev::FileOperationsVtable =
+        linux_kernel_module::chrdev::FileOperationsVtable::new::<Self>();
+
+    fn open() -> Self {
+        return CycleFile;
+    }
+
+    fn read(
+        &self,
+        buf: &linux_kernel_module::user_ptr::UserSlicePtrWriter,
+    ) -> linux_kernel_module::KernelResult<()> {
+        for c in b"123456789".iter().cycle().take(buf.len()) {
+            buf.write(c)?;
+        }
+        return Ok(());
+    }
+}
+
+struct ChrdevTestModule {
+    _dev_region: linux_kernel_module::chrdev::DeviceNumberRegion,
+    _chrdev_registration: linux_kernel_module::chrdev::DeviceRegistration,
+}
+
+impl linux_kernel_module::KernelModule for ChrdevTestModule {
+    fn init() -> linux_kernel_module::KernelResult<Self> {
+        let dev_region =
+            linux_kernel_module::chrdev::DeviceNumberRegion::allocate(0..1, "chrdev-tests\x00")?;
+        let chrdev_registration = dev_region.register_device::<CycleFile>()?;
+        Ok(ChrdevTestModule {
+            _dev_region: dev_region,
+            _chrdev_registration: chrdev_registration,
+        })
+    }
+}
+
+linux_kernel_module::kernel_module!(
+    ChrdevTestModule,
+    author: "Alex Gaynor and Geoffrey Thomas",
+    description: "A module for testing character devices",
+    license: "GPL"
+);

tests/chrdev/tests.rs

@@ -0,0 +1,59 @@
+use kernel_module_tests::with_kernel_module;
+use std::fs;
+
+fn get_device_number() -> u32 {
+    let devices = fs::read_to_string("/proc/devices").unwrap();
+    let dev_no_line = devices
+        .lines()
+        .find(|l| l.ends_with("chrdev-tests"))
+        .unwrap();
+    let elements = dev_no_line.rsplitn(2, " ").collect::<Vec<_>>();
+    assert_eq!(elements.len(), 2);
+    assert_eq!(elements[0], "chrdev-tests");
+    return elements[1].trim().parse().unwrap();
+}
+
+fn temporary_file_path() -> PathBuf {
+    let p = env::temp_dir();
+    p.push("chrdev-test-device");
+    return p
+}
+
+struct<'a> UnlinkOnDelete<'a> {
+    path: &'a Path,
+}
+
+impl Drop for UnlinkOnDrop {
+    fn drop(&mut self) {
+        fs::remove_file(self.path);
+    }
+}
+
+fn mknod(path: &Path, mode: u32, device_number: u32) -> UnlinkOnDrop {
+    let result = libc::mknod(CString::new(p).unwrap(), mode, device_number);
+    assert_eq(result, 0);
+    return UnlinkOnDrop{path};
+}
+
+#[test]
+fn test_mknod() {
+    with_kernel_module(|| {
+        let device_number = get_device_number();
+        let _u = mknod(temporary_file_path(), 0o600, device_number);
+    });
+}
+
+#[test]
+fn test_read() {
+    with_kernel_module(|| {
+        let device_number = get_device_number();
+        let p = temporary_file_path()
+        let _u = mknod(temporary_file_path(), 0o600, device_number);
+
+        let f = fs::File::open(p);
+        let data = vec![0; 12];
+        f.read_exact(&mut data).unwrap();
+        assert_eq(data, "123456789123")
+    });
+
+}