Merge branch 'master' into no-more-rust-target-path

Author: alex

.travis.yml

@@ -1,12 +1,12 @@
-sudo: required
+matrix:
+    include:
+        - dist: xenial
 
 language: rust
 rust:
     - nightly
 cache:
     - cargo: true
-    - directories:
-        - tests/target/
 
 branches:
     only:
@@ -21,10 +21,16 @@ install:
       else
           cargo install --force cargo-xbuild
       fi
-    - rustup component add rust-src
+    - rustup component add rust-src rustfmt
 
 script:
-    - RUST_BACKTRACE=1 ./tests/run_tests.py
+    - ./tests/run_tests.py
+    - |
+      for p in . hello-world tests/*; do
+        if [ -d "$p" ]; then
+          (cd "$p" && cargo fmt --all -- --check) || exit 1
+        fi
+      done
 
 after_failure:
     - dmesg

Cargo.toml

@@ -2,6 +2,7 @@
 name = "linux-kernel-module"
 version = "0.1.0"
 authors = ["Alex Gaynor <[email protected]>"]
+edition = "2018"
 
 [dependencies]
 bitflags = "1"

build.rs

@@ -1,6 +1,6 @@
-extern crate bindgen;
-extern crate cc;
-extern crate shlex;
+use bindgen;
+use cc;
+use shlex;
 
 use std::env;
 use std::path::PathBuf;
@@ -19,6 +19,8 @@ const INCLUDED_FUNCTIONS: &[&str] = &[
     "access_ok",
     "_copy_to_user",
     "_copy_from_user",
+    "alloc_chrdev_region",
+    "unregister_chrdev_region",
 ];
 const INCLUDED_VARS: &[&str] = &[
     "EINVAL",
@@ -34,15 +36,16 @@ const INCLUDED_VARS: &[&str] = &[
     "KERN_INFO",
     "VERIFY_WRITE",
 ];
+const OPAQUE_TYPES: &[&str] = &[
+    // These need to be opaque because they're both packed and aligned, which rustc
+    // doesn't support yet. See https://github.com/rust-lang/rust/issues/59154
+    // and https://github.com/rust-lang/rust-bindgen/issues/1538
+    "desc_struct",
+    "xregs_state",
+];
 
 fn main() {
-    let mut builder = bindgen::Builder::default()
-        .use_core()
-        .ctypes_prefix("c_types")
-        .no_copy(".*")
-        .derive_default(true)
-        .rustfmt_bindings(true);
-
+    println!("rerun-if-env-changed=KDIR");
     let output = String::from_utf8(
         Command::new("make")
             .arg("-C")
@@ -51,8 +54,16 @@ fn main() {
             .output()
             .unwrap()
             .stdout,
-    ).unwrap();
+    )
+    .unwrap();
 
+    let mut builder = bindgen::Builder::default()
+        .use_core()
+        .ctypes_prefix("c_types")
+        .derive_default(true)
+        .rustfmt_bindings(true);
+
+    builder = builder.clang_arg("--target=x86_64-linux-kernel-module");
     for arg in shlex::split(&output).unwrap() {
         builder = builder.clang_arg(arg.to_string());
     }
@@ -69,6 +80,9 @@ fn main() {
     for v in INCLUDED_VARS {
         builder = builder.whitelist_var(v);
     }
+    for t in OPAQUE_TYPES {
+        builder = builder.opaque_type(t);
+    }
     let bindings = builder.generate().expect("Unable to generate bindings");
 
     let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
@@ -79,6 +93,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.target("x86_64-linux-kernel-module");
     builder.warnings(false);
     builder.file("src/helpers.c");
     for arg in shlex::split(&output).unwrap() {

example-sysctl/Cargo.toml

@@ -2,6 +2,7 @@
 name = "hello-world"
 version = "0.1.0"
 authors = ["Geoffrey Thomas <[email protected]>"]
+edition = "2018"
 
 [lib]
 crate-type = ["staticlib"]

example-sysctl/Makefile

@@ -1,9 +1,10 @@
 obj-m := helloworld.o
 helloworld-objs := target/x86_64-linux-kernel-module/debug/libhello_world.a
 EXTRA_LDFLAGS += --entry=init_module
+KDIR ?= /lib/modules/$(shell uname -r)/build
 
 all:
-	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(CURDIR)
+	$(MAKE) -C $(KDIR) M=$(CURDIR)
 
 clean:
-	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(CURDIR) clean
+	$(MAKE) -C $(KDIR) M=$(CURDIR) clean

example-sysctl/src/lib.rs

@@ -1,12 +1,13 @@
 #![no_std]
-#![feature(alloc)]
+#![feature(const_str_as_bytes)]
 
 extern crate alloc;
+
 use alloc::borrow::ToOwned;
-use alloc::String;
+use alloc::string::String;
 
-#[macro_use]
-extern crate linux_kernel_module;
+use linux_kernel_module;
+use linux_kernel_module::println;
 
 struct HelloWorldModule {
     message: String,
@@ -27,7 +28,8 @@ impl Drop for HelloWorldModule {
         println!("Goodbye kernel module!");
     }
 }
-kernel_module!(
+
+linux_kernel_module::kernel_module!(
     HelloWorldModule,
     author: "Alex Gaynor and Geoffrey Thomas",
     description: "An extremely simple kernel module",

hello-world/Cargo.toml

@@ -1,27 +1,24 @@
-use core::alloc::{AllocErr, GlobalAlloc, Layout};
+use core::alloc::{GlobalAlloc, Layout};
+use core::ptr;
 
-use bindings;
-use c_types;
+use crate::bindings;
+use crate::c_types;
 
 pub struct KernelAllocator;
 
 unsafe impl GlobalAlloc for KernelAllocator {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         // krealloc is used instead of kmalloc because kmalloc is an inline function and can't be
         // bound to as a result
-        return bindings::krealloc(
-            0 as *const c_types::c_void,
-            layout.size(),
-            bindings::GFP_KERNEL,
-        ) as *mut u8;
+        return bindings::krealloc(ptr::null(), layout.size(), bindings::GFP_KERNEL) as *mut u8;
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
         bindings::kfree(ptr as *const c_types::c_void);
     }
 }
 
-#[lang = "oom"]
-extern "C" fn oom(_err: AllocErr) -> ! {
+#[alloc_error_handler]
+fn oom(_layout: Layout) -> ! {
     panic!("Out of memory!");
 }

hello-world/Makefile

@@ -1,6 +1,6 @@
 #![allow(non_camel_case_types, non_upper_case_globals, non_snake_case, improper_ctypes)]
 
-use c_types;
+use crate::c_types;
 
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 

hello-world/src/lib.rs

@@ -1,5 +1,5 @@
-#include <linux/module.h>
 #include <linux/fs.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 

src/allocator.rs

@@ -0,0 +1,53 @@
+use core::convert::TryInto;
+use core::ops::Range;
+
+use crate::bindings;
+use crate::c_types;
+use crate::error;
+
+pub fn builder(name: &'static str, minors: Range<u16>) -> error::KernelResult<Builder> {
+    if !name.ends_with('\x00') {
+        return Err(error::Error::EINVAL);
+    }
+
+    return Ok(Builder { name, minors });
+}
+
+pub struct Builder {
+    name: &'static str,
+    minors: Range<u16>,
+}
+
+impl Builder {
+    pub fn build(self) -> error::KernelResult<Registration> {
+        let mut dev: bindings::dev_t = 0;
+        let res = unsafe {
+            bindings::alloc_chrdev_region(
+                &mut dev,
+                self.minors.start.into(),
+                self.minors.len().try_into()?,
+                self.name.as_ptr() as *const c_types::c_char,
+            )
+        };
+        if res != 0 {
+            return Err(error::Error::from_kernel_errno(res));
+        }
+        return Ok(Registration {
+            dev,
+            count: self.minors.len(),
+        });
+    }
+}
+
+pub struct Registration {
+    dev: bindings::dev_t,
+    count: usize,
+}
+
+impl Drop for Registration {
+    fn drop(&mut self) {
+        unsafe {
+            bindings::unregister_chrdev_region(self.dev, self.count as _);
+        }
+    }
+}

src/bindings.rs

@@ -1,5 +1,7 @@
-use bindings;
-use c_types;
+use core::num::TryFromIntError;
+
+use crate::bindings;
+use crate::c_types;
 
 pub struct Error(c_types::c_int);
 
@@ -17,4 +19,10 @@ impl Error {
     }
 }
 
+impl From<TryFromIntError> for Error {
+    fn from(_: TryFromIntError) -> Error {
+        return Error::EINVAL;
+    }
+}
+
 pub type KernelResult<T> = Result<T, Error>;

src/bindings_helper.h

@@ -3,9 +3,11 @@ use core::default::Default;
 use core::marker;
 use core::mem;
 
-use bindings;
-use c_types;
-use error;
+use bitflags;
+
+use crate::bindings;
+use crate::c_types;
+use crate::error;
 
 pub struct FileSystemRegistration<T: FileSystem> {
     _phantom: marker::PhantomData<T>,
@@ -24,7 +26,7 @@ pub trait FileSystem {
     const FLAGS: FileSystemFlags;
 }
 
-bitflags! {
+bitflags::bitflags! {
     pub struct FileSystemFlags: c_types::c_int {
         const FS_REQUIRES_DEV = bindings::FS_REQUIRES_DEV as c_types::c_int;
         const FS_BINARY_MOUNTDATA = bindings::FS_BINARY_MOUNTDATA as c_types::c_int;
@@ -34,12 +36,6 @@ bitflags! {
     }
 }
 
-impl FileSystemFlags {
-    pub const fn const_empty() -> FileSystemFlags {
-        FileSystemFlags { bits: 0 }
-    }
-}
-
 extern "C" fn fill_super_callback<T: FileSystem>(
     _sb: *mut bindings::super_block,
     _data: *mut c_types::c_void,