Fixes #34 -- add a test framework (#45)

And some initial tests for printk

Author: alex

.travis.yml

@@ -5,24 +5,15 @@ rust:
     - nightly
 cache:
     - cargo: true
-    # TODO: dedup this with the MODULE_DIR in env
     - directories:
-        - static-filesystem/target/
-        - hello-world/target/
-        - example-sysctl/target/
+        - tests/target/
 
 branches:
     only:
         - master
 
-matrix:
-    include:
-        - env: MODULE_DIR=hello-world MODULE=helloworld
-        - env: MODULE_DIR=static-filesystem MODULE=staticfilesystem
-        - env: MODULE_DIR=example-sysctl MODULE=examplesysctl
-
 install:
-    - sudo apt-get install -y "linux-headers-$(uname -r)"
+    - sudo apt-get install -y "linux-headers-$(uname -r)" realpath
     - type -p cargo-install-update || cargo install --force cargo-update
     - |
       if type -p cargo-xbuild; then
@@ -33,12 +24,7 @@ install:
     - rustup component add rust-src
 
 script:
-    - cd $MODULE_DIR
-    - RUST_TARGET_PATH="$(pwd)/.." cargo xbuild --target x86_64-linux-kernel-module
-    - make
-    - sudo dmesg -C
-    - sudo insmod "${MODULE}.ko"
-    - sudo rmmod "$MODULE"
+    - ./tests/run_tests.py
 
 after_failure:
     - dmesg

tests/Makefile

@@ -0,0 +1,9 @@
+obj-m := testmodule.o
+testmodule-objs := $(TEST_LIBRARY)
+EXTRA_LDFLAGS += --entry=init_module
+
+all:
+	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(CURDIR)
+
+clean:
+	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(CURDIR) clean

tests/printk/Cargo.toml

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

tests/printk/src/lib.rs

@@ -0,0 +1,23 @@
+#![no_std]
+
+#[macro_use]
+extern crate linux_kernel_module;
+
+struct PrintkTestModule;
+
+impl linux_kernel_module::KernelModule for PrintkTestModule {
+    fn init() -> linux_kernel_module::KernelResult<Self> {
+        println!("Single element printk");
+        println!();
+        println!("printk with {} parameters{}", 2, "!");
+
+        Ok(PrintkTestModule)
+    }
+}
+
+kernel_module!(
+    PrintkTestModule,
+    author: "Alex Gaynor and Geoffrey Thomas",
+    description: "A module for testing println!()",
+    license: "GPL"
+);

tests/printk/tests.rs

@@ -0,0 +1,55 @@
+use std::env;
+use std::process::Command;
+
+struct LoadedModule {
+    name: String,
+}
+
+impl LoadedModule {
+    fn load(name: String) -> LoadedModule {
+        Command::new("sudo")
+            .arg("insmod")
+            .arg(&name)
+            .status()
+            .unwrap();
+        return LoadedModule { name };
+    }
+}
+
+impl Drop for LoadedModule {
+    fn drop(&mut self) {
+        Command::new("sudo")
+            .arg("rmmod")
+            .arg(&self.name)
+            .status()
+            .unwrap();
+    }
+}
+
+fn with_kernel_module<F: Fn()>(f: F) {
+    Command::new("sudo")
+        .arg("dmesg")
+        .arg("-C")
+        .status()
+        .unwrap();
+    let _m = LoadedModule::load(env::var("KERNEL_MODULE").unwrap());
+    f();
+}
+
+fn assert_dmesg_contains(msgs: &[&[u8]]) {
+    let output = Command::new("dmesg").output().unwrap();
+    let lines = output.stdout.split(|x| *x == b'\n').collect::<Vec<_>>();
+    let mut lines: &[&[u8]] = &lines;
+    for msg in msgs {
+        let pos = lines.iter().position(|l| l.ends_with(msg));
+        assert!(pos.is_some());
+        lines = &lines[pos.unwrap()..];
+    }
+}
+
+#[test]
+fn test_printk() {
+    with_kernel_module(|| {
+        assert_dmesg_contains(&[b"Single element printk", b"", b"printk with 2 parameters!"]);
+    });
+}

tests/run_tests.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+
+import os
+import subprocess
+
+
+BASE_DIR = os.path.realpath(os.path.dirname(__file__))
+
+
+def run(*args, **kwargs):
+    cwd = kwargs.pop("cwd", None)
+    environ = kwargs.pop("environ", os.environ)
+    assert not kwargs
+
+    print("+ [running] {}".format(list(args)))
+    subprocess.check_call(list(args), cwd=cwd, env=environ)
+
+
+def main():
+    for path in os.listdir(BASE_DIR):
+        if (
+            not os.path.isdir(os.path.join(BASE_DIR, path)) or
+            not os.path.exists(os.path.join(BASE_DIR, path, "tests.rs"))
+        ):
+            continue
+
+        run(
+            "cargo", "xbuild", "--target", "x86_64-linux-kernel-module",
+            cwd=os.path.join(BASE_DIR, path),
+            environ=dict(
+                os.environ,
+                RUST_TARGET_PATH=os.path.join(BASE_DIR, os.path.pardir),
+                CARGO_TARGET_DIR=os.path.relpath(
+                    os.path.join(BASE_DIR, "target"),
+                    os.path.join(BASE_DIR, path)
+                ),
+            )
+        )
+
+        module = os.path.join(
+            BASE_DIR,
+            "target/x86_64-linux-kernel-module/debug/lib{}_tests.a".format(
+                path
+            )
+        )
+        run(
+            "make", "-C", BASE_DIR,
+            "TEST_LIBRARY={}".format(
+                os.path.join(
+                    "target/x86_64-linux-kernel-module/debug/",
+                    os.path.basename(module)
+                )
+            ),
+        )
+        run(
+            "rustc",
+            "--test",
+            "--out-dir", os.path.join(BASE_DIR, path),
+            os.path.join(BASE_DIR, path, "tests.rs"),
+        )
+        # TODO: qemu
+        run(
+            os.path.join(BASE_DIR, path, "tests"),
+            environ=dict(
+                os.environ,
+                KERNEL_MODULE=os.path.join(BASE_DIR, "testmodule.ko")
+            )
+        )
+
+
+
+if __name__ == "__main__":
+    main()
+