Fixes #177 -- let the kernel build process drive cargo

Author: alex

.travis.yml

@@ -17,7 +17,7 @@ install:
     - rustup component add rust-src rustfmt clippy
 
 script:
-    - ./tests/run_tests.py
+    - CC=clang ./tests/run_tests.py
     - |
       for p in . hello-world tests/*; do
         if [ -d "$p" ]; then

README.md

@@ -20,9 +20,8 @@ various other examples in the tests/ directory.
 We run [bindgen](https://github.com/rust-lang/rust-bindgen) on the
 kernel headers to generate automatic Rust FFI bindings. bindgen is
 powered by [Clang](https://clang.llvm.org), so we use use the kernel's
-own build system to determine the appropriate CFLAGS (see
-`kernel-cflags-finder`) and pass them to bindgen (see `build.rs`). Then we
-write safe bindings to these types (see the various files inside `src/`).
+own build system to determine the appropriate CFLAGS. Then we write safe
+bindings to these types (see the various files inside `src/`).
 
 Each kernel module in Rust lives in a `staticlib` crate, which generates
 a `.a` file. We pass this object to the Linux kernel's own module build
@@ -52,12 +51,13 @@ or higher [to bind constants
 properly](https://github.com/rust-lang/rust-bindgen/issues/1316). If
 you're running kernel 5.0 or newer, [you'll need Clang
 9](https://github.com/fishinabarrel/linux-kernel-module-rust/issues/123)
-(currently the development release).  You may need to set the `CLANG`
-environment variable appropriately, e.g., `CLANG=clang-9`.
+(currently the development release).  You may need to set the `CC`
+environment variable appropriately, e.g., `CC=clang-9`.
 
 ## Building hello-world
 
-1. Install clang, kernel headers, and the `rust-src` and `rustfmt` components from `rustup`:
+1. Install clang, kernel headers, and the `rust-src` and `rustfmt` components
+from `rustup`:
 
 ```
 apt-get install llvm clang linux-headers-"$(uname -r)" # or the equivalent for your OS
@@ -70,19 +70,14 @@ rustup component add --toolchain=nightly rust-src rustfmt
 cd hello-world
 ```
 
-3. Build the static object with cargo build, pointing it at our custom target
-
-```
-cargo build -Z build-std=core,alloc --target x86_64-linux-kernel
-```
-
-4. Build the kernel module using the Linux kernel build system (kbuild)
+3. Build the kernel module using the Linux kernel build system (kbuild), this
+will invoke `cargo` to build the Rust code
 
 ```
 make
 ```
 
-5. Load and unload the module!
+4. Load and unload the module!
 
 ```
 sudo insmod helloworld.ko

build.rs

@@ -85,32 +85,56 @@ fn handle_kernel_version_cfg(bindings_path: &PathBuf) {
     }
 }
 
+// Takes the CFLAGS from the kernel Makefile and changes all the include paths to be absolute
+// instead of relative.
+fn prepare_cflags(cflags: &str, kernel_dir: &str) -> Vec<String> {
+    let cflag_parts = shlex::split(&cflags).unwrap();
+    let mut cflag_iter = cflag_parts.iter();
+    let mut kernel_args = vec![];
+    while let Some(arg) = cflag_iter.next() {
+        if arg.starts_with("-I") && !arg.starts_with("-I/") {
+            kernel_args.push(format!("-I{}/{}", kernel_dir, &arg[2..]));
+        } else if arg == "-include" {
+            kernel_args.push(arg.to_string());
+            let include_path = cflag_iter.next().unwrap();
+            if include_path.starts_with("/") {
+                kernel_args.push(include_path.to_string());
+            } else {
+                kernel_args.push(format!("{}/{}", kernel_dir, include_path));
+            }
+        } else {
+            kernel_args.push(arg.to_string());
+        }
+    }
+    return kernel_args;
+}
+
 fn main() {
     println!("cargo:rerun-if-env-changed=KDIR");
-    println!("cargo:rerun-if-env-changed=CLANG");
-    println!("cargo:rerun-if-changed=kernel-cflags-finder/Makefile");
-    let output = Command::new("make")
-        .arg("-C")
-        .arg("kernel-cflags-finder")
-        .arg("-s")
-        .output()
-        .unwrap();
-    if !output.status.success() {
-        eprintln!("kernel-cflags-finder did not succeed");
-        eprintln!("stdout: {}", std::str::from_utf8(&output.stdout).unwrap());
-        eprintln!("stderr: {}", std::str::from_utf8(&output.stderr).unwrap());
-        std::process::exit(1);
-    }
+    println!("cargo:rerun-if-env-changed=CC");
+    println!("cargo:rerun-if-env-changed=KERNEL_CLFAGS");
+
+    let kernel_cflags = env::var("KERNEL_CLFAGS").expect("Must be invoked from kernel makefile");
+    let kernel_dir = env::var("KDIR").unwrap_or_else(|_| {
+        format!(
+            "/lib/modules/{}/build",
+            std::str::from_utf8(&(Command::new("uname").arg("-r").output().unwrap().stdout))
+                .unwrap()
+                .trim()
+        )
+    });
+    let kernel_args = prepare_cflags(&kernel_cflags, &kernel_dir);
 
     let mut builder = bindgen::Builder::default()
         .use_core()
         .ctypes_prefix("c_types")
         .derive_default(true)
         .rustfmt_bindings(true);
 
+    // TODO: Support building for other kernel targets!
     builder = builder.clang_arg("--target=x86_64-linux-kernel");
-    for arg in shlex::split(std::str::from_utf8(&output.stdout).unwrap()).unwrap() {
-        builder = builder.clang_arg(arg.to_string());
+    for arg in kernel_args.iter() {
+        builder = builder.clang_arg(arg.clone());
     }
 
     println!("cargo:rerun-if-changed=src/bindings_helper.h");
@@ -138,12 +162,11 @@ fn main() {
     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()));
+    builder.compiler(env::var("CC").unwrap_or("clang".to_string()));
     builder.target("x86_64-linux-kernel");
     builder.warnings(false);
     builder.file("src/helpers.c");
-    for arg in shlex::split(std::str::from_utf8(&output.stdout).unwrap()).unwrap() {
+    for arg in kernel_args.iter() {
         builder.flag(&arg);
     }
     builder.compile("helpers");

hello-world/Makefile

@@ -1,12 +1,20 @@
+ifneq ($(KERNELRELEASE),)
 obj-m := helloworld.o
 helloworld-objs := hello_world.rust.o
-KDIR ?= /lib/modules/$(shell uname -r)/build
+
+$(src)/target/x86_64-linux-kernel/debug/libhello_world.a: $(src)/Cargo.toml $(wildcard $(src)/src/*.c)
+	cd $(src); env -u MAKE -u MAKEFLAGS KERNEL_CLFAGS="$(c_flags)" cargo build -Z build-std=core,alloc --target=x86_64-linux-kernel
 
 %.rust.o: target/x86_64-linux-kernel/debug/lib%.a
 	$(LD) -r -o $@ --whole-archive $<
 
+else
+KDIR ?= /lib/modules/$(shell uname -r)/build
+CC ?= clang
+
 all:
-	$(MAKE) -C $(KDIR) M=$(CURDIR)
+	$(MAKE) -C $(KDIR) M=$(CURDIR) CC=$(CC)
 
 clean:
-	$(MAKE) -C $(KDIR) M=$(CURDIR) clean
+	$(MAKE) -C $(KDIR) M=$(CURDIR) CC=$(CC) clean
+endif

kernel-cflags-finder/.gitignore

@@ -1,12 +1,20 @@
+ifneq ($(KERNELRELEASE),)
 obj-m := testmodule.o
 testmodule-objs := $(TEST_NAME).rust.o
-KDIR ?= /lib/modules/$(shell uname -r)/build
+
+$(src)/target/x86_64-linux-kernel/debug/lib%.a: $(src)/$(TEST_PATH)/Cargo.toml $(wildcard $(src)/$(TEST_PATH)/src/*.rs)
+	cd $(src)/$(TEST_PATH); env -u MAKE -u MAKEFLAGS KERNEL_CLFAGS="$(c_flags)" RUSTFLAGS="-Dwarnings" CARGO_TARGET_DIR=../target cargo build -Z build-std=core,alloc --target=x86_64-linux-kernel
 
 %.rust.o: target/x86_64-linux-kernel/debug/lib%.a
 	$(LD) -r -o $@ --whole-archive $<
 
+else
+KDIR ?= /lib/modules/$(shell uname -r)/build
+CC ?= clang
+
 all:
-	$(MAKE) -C $(KDIR) M=$(CURDIR)
+	$(MAKE) -C $(KDIR) M=$(CURDIR) CC=$(CC)
 
 clean:
-	$(MAKE) -C $(KDIR) M=$(CURDIR) clean
+	$(MAKE) -C $(KDIR) M=$(CURDIR) CC=$(CC) clean
+endif

kernel-cflags-finder/Makefile

@@ -25,24 +25,11 @@ def main():
             continue
 
         print("+ [{}]".format(path))
-        run(
-            "cargo", "build", "-Zbuild-std=core,alloc",
-            "--target", "x86_64-linux-kernel",
-            cwd=os.path.join(BASE_DIR, path),
-            environ=dict(
-                os.environ,
-                RUSTFLAGS="-Dwarnings",
-                CARGO_TARGET_DIR=os.path.relpath(
-                    os.path.join(BASE_DIR, "target"),
-                    os.path.join(BASE_DIR, path)
-                ),
-                XBUILD_SYSROOT_PATH=os.path.join(BASE_DIR, "target-sysroot"),
-            )
-        )
 
         run(
             "make", "-C", BASE_DIR,
             "TEST_NAME={}_tests".format(path.replace("-", "_")),
+            "TEST_PATH={}".format(path),
         )
         # TODO: qemu
         run(