Support registering a FileOperations for a chrdev

Author: alex

build.rs

@@ -2,12 +2,16 @@ use bindgen;
 use cc;
 use shlex;
 
-use std::env;
+use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 use std::process::Command;
+use std::{env, fs};
 
 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",
@@ -35,6 +39,7 @@ const INCLUDED_VARS: &[&str] = &[
     "BINDINGS_GFP_KERNEL",
     "KERN_INFO",
     "VERIFY_WRITE",
+    "LINUX_VERSION_CODE",
 ];
 const OPAQUE_TYPES: &[&str] = &[
     // These need to be opaque because they're both packed and aligned, which rustc
@@ -44,6 +49,30 @@ const OPAQUE_TYPES: &[&str] = &[
     "xregs_state",
 ];
 
+fn kernel_version_code(major: u8, minor: u8, patch: u8) -> u64 {
+    ((major as u64) << 16) | ((minor as u64) << 8) | (patch as u64)
+}
+
+fn handle_kernel_version_cfg(bindings_path: &PathBuf) {
+    let f = BufReader::new(fs::File::open(bindings_path).unwrap());
+    let mut version = None;
+    for line in f.lines() {
+        let line = line.unwrap();
+        if line.starts_with("pub const LINUX_VERSION_CODE") {
+            let mut parts = line.split(" = ");
+            parts.next();
+            let raw_version = parts.next().unwrap();
+            // Remove the trailing semi-colon
+            version = Some(raw_version[..raw_version.len() - 1].parse::<u64>().unwrap());
+            break;
+        }
+    }
+    let version = version.expect("Couldn't find kernel version");
+    if version >= kernel_version_code(4, 15, 0) {
+        println!("cargo:rustc-cfg=kernel_4_15_0_or_greataer")
+    }
+}
+
 fn main() {
     println!("rerun-if-env-changed=KDIR");
     let output = String::from_utf8(
@@ -90,6 +119,8 @@ fn main() {
         .write_to_file(out_path.join("bindings.rs"))
         .expect("Couldn't write bindings!");
 
+    handle_kernel_version_cfg(&out_path.join("bindings.rs"));
+
     let mut builder = cc::Build::new();
     println!("cargo:rerun-if-env-changed=CLANG");
     builder.compiler(env::var("CLANG").unwrap_or("clang".to_string()));

src/bindings_helper.h

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

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,8 +1,13 @@
 use core::ops::Range;
+use core::ptr;
+
+use alloc::boxed::Box;
+use alloc::sync::Arc;
 
 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,
@@ -13,9 +18,9 @@ impl DeviceNumberRegion {
     pub fn allocate(
         minors: Range<usize>,
         name: &'static str,
-    ) -> error::KernelResult<DeviceNumberRegion> {
+    ) -> KernelResult<Arc<DeviceNumberRegion>> {
         if !name.ends_with('\x00') {
-            return Err(error::Error::EINVAL);
+            return Err(Error::EINVAL);
         }
 
         let count = minors.end - minors.start;
@@ -29,9 +34,33 @@ impl DeviceNumberRegion {
             )
         };
         if res != 0 {
-            return Err(error::Error::from_kernel_errno(res));
+            return Err(Error::from_kernel_errno(res));
+        }
+        return Ok(Arc::new(DeviceNumberRegion { dev, count }));
+    }
+
+    pub fn register_device<T: FileOperations>(
+        self: &Arc<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,
+            _region: Arc::clone(&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(DeviceNumberRegion { dev, count });
+        return Ok(cdev);
     }
 }
 
@@ -42,3 +71,112 @@ impl Drop for DeviceNumberRegion {
         }
     }
 }
+
+pub struct DeviceRegistration {
+    _region: Arc<DeviceNumberRegion>,
+    cdev: *mut bindings::cdev,
+}
+
+unsafe impl Sync for DeviceRegistration {}
+
+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 bindings::loff_t;
+            return written as c_types::c_ssize_t;
+        }
+        Err(e) => return e.to_kernel_errno() as c_types::c_ssize_t,
+    };
+}
+
+unsafe extern "C" fn release_callback<T: FileOperations>(
+    _inode: *mut bindings::inode,
+    file: *mut bindings::file,
+) -> c_types::c_int {
+    let ptr = (*file).private_data as *mut T;
+    (*file).private_data = ptr::null_mut();
+    Box::from_raw(ptr);
+    return 0;
+}
+
+impl FileOperationsVtable {
+    pub const fn new<T: FileOperations>() -> FileOperationsVtable {
+        return FileOperationsVtable(bindings::file_operations {
+            open: Some(open_callback::<T>),
+            read: Some(read_callback::<T>),
+            release: Some(release_callback::<T>),
+
+            check_flags: None,
+            clone_file_range: None,
+            compat_ioctl: None,
+            copy_file_range: None,
+            dedupe_file_range: None,
+            fallocate: None,
+            fasync: None,
+            flock: None,
+            flush: None,
+            fsync: None,
+            get_unmapped_area: None,
+            iterate: None,
+            iterate_shared: None,
+            llseek: None,
+            lock: None,
+            mmap: None,
+            #[cfg(kernel_4_15_0_or_greataer)]
+            mmap_supported_flags: 0,
+            owner: ptr::null_mut(),
+            poll: None,
+            read_iter: None,
+            sendpage: None,
+            setfl: None,
+            setlease: None,
+            show_fdinfo: None,
+            splice_read: None,
+            splice_write: None,
+            unlocked_ioctl: None,
+            write: None,
+            write_iter: None,
+        });
+    }
+}
+
+pub trait FileOperations: Sync + Sized {
+    const VTABLE: FileOperationsVtable;
+
+    fn open() -> KernelResult<Self>;
+    fn read(&self, buf: &mut UserSlicePtrWriter) -> KernelResult<()>;
+}

src/lib.rs

@@ -1,5 +1,5 @@
 #![no_std]
-#![feature(allocator_api, alloc_error_handler)]
+#![feature(allocator_api, alloc_error_handler, arbitrary_self_types, const_fn)]
 
 extern crate alloc;
 

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-region-allocation/src/lib.rs

@@ -1,10 +1,14 @@
 #![no_std]
 #![feature(const_str_as_bytes)]
 
+extern crate alloc;
+
+use alloc::sync::Arc;
+
 use linux_kernel_module;
 
 struct ChrdevRegionAllocationTestModule {
-    _dev: linux_kernel_module::chrdev::DeviceNumberRegion,
+    _dev: Arc<linux_kernel_module::chrdev::DeviceNumberRegion>,
 }
 
 impl linux_kernel_module::KernelModule for ChrdevRegionAllocationTestModule {

tests/chrdev/Cargo.toml

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

tests/chrdev/src/lib.rs

@@ -0,0 +1,53 @@
+#![no_std]
+#![feature(const_str_as_bytes)]
+
+extern crate alloc;
+
+use alloc::sync::Arc;
+
+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() -> linux_kernel_module::KernelResult<Self> {
+        return Ok(CycleFile);
+    }
+
+    fn read(
+        &self,
+        buf: &mut 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: Arc<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"
+);