Generate an additional meta-data struct for every test.

Signed-off-by: Gerd Zellweger <[email protected]>

Author: gz

test_harness/src/lib.rs

@@ -1,5 +1,11 @@
 #![feature(used, lang_items)]
 
+#[derive(Debug)]
+pub struct KvmTestMetaData {
+    pub mbz: u64,
+    pub meta: &'static str,
+}
+
 pub fn test_start(ntests: usize) {
     println!("KVM testing: running {} tests", ntests)
 }

test_macros/Cargo.toml

@@ -5,10 +5,11 @@ authors = ["Gerd Zellweger <[email protected]>"]
 
 [dependencies]
 quote = "0.3.*"
+test = { path = "../test_harness" }
 
 [dependencies.syn]
-version = "0.11.*"
-features = ["full"]
+version = "0.*"
+features = ["full", "fold"]
 
 [lib]
 proc-macro = true

test_macros/src/lib.rs

@@ -1,72 +1,99 @@
-#![feature(rustc_private)]
-#![feature(proc_macro)]
+///! This implements the kvmargs macro to customize the execution of KVM based tests.
+///!
+///! One problem we have to solve here is that we need to store additional data
+///! to customize the setup of the virtual CPU in the host, whereas the TokenStream
+///! of our macro only allows us to modify the test function itself that already runs inside
+///! the virtual machine (see also `test_harness/src/lib.rs`).
+///!
+///! Using procedural macros, we do the following:
+///!   (a) Generate a struct to store additional meta-data for a test
+///!   (b) Initialize that struct with values from kvmargs attributes
+///!   (b) Store the meta-data in a special ELF section (.kvm) so we can find it later
+///!   (c) Make sure the linker won't throw away the meta-data struct by inserting a dummy reference
+///!       to it in the test function itself.
+///!
+///! Obviously, this is a bit of a mess right now, my hope is that such things become
+///! easier with better custom test harness support.
+///!
+#![feature(rustc_private, proc_macro)]
 
 extern crate proc_macro;
 extern crate syn;
 #[macro_use]
 extern crate quote;
 extern crate syntax;
 
-use proc_macro::TokenStream;
-
-#[proc_macro_attribute]
-pub fn panics_note(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = args.to_string();
-    let mut input = input.to_string();
-
-    assert!(args.starts_with("= \""),
-            "`#[panics_note]` requires an argument of the form `#[panics_note = \"panic note \
-             here\"]`");
+extern crate test;
+use test::KvmTestMetaData;
 
-    // Get just the bare note string
-    let panics_note = args.trim_matches(&['=', ' ', '"'][..]);
-
-    // The input will include all docstrings regardless of where the attribute is placed,
-    // so we need to find the last index before the start of the item
-    let insert_idx = idx_after_last_docstring(&input);
-
-    // And insert our `### Panics` note there so it always appears at the end of an item's docs
-    input.insert_str(insert_idx, &format!("/// # Panics \n/// {}\n", panics_note));
-
-    input.parse().unwrap()
-}
-
-// `proc-macro` crates can contain any kind of private item still
-fn idx_after_last_docstring(input: &str) -> usize {
-    // Skip docstring lines to find the start of the item proper
-    input.lines().skip_while(|line| line.trim_left().starts_with("///")).next()
-        // Find the index of the first non-docstring line in the input
-        // Note: assumes this exact line is unique in the input
-        .and_then(|line_after| input.find(line_after))
-        // No docstrings in the input
-        .unwrap_or(0)
-}
-
-
-fn generate_kvm_setup(ident: syn::Ident) -> quote::Tokens {
-    quote! {
-        // The generated impl
-        fn #ident() {
+use syn::fold;
+use syn::parse::IResult;
+use std::string;
+use proc_macro::TokenStream;
+use quote::ToTokens;
+
+/// Add a additional meta-data and setup functions for a KVM based test.
+fn generate_kvmtest_meta_data(test_ident: &syn::Ident) -> (syn::Ident, quote::Tokens) {
+    // Create some test meta-data
+    let test_name = test_ident.as_ref();
+    let setup_fn_ident = syn::Ident::new(String::from(test_name) + "_setup");
+    let struct_ident = syn::Ident::new(String::from(test_name) + "_kvm_meta_data");
+
+    (struct_ident.clone(),
+     quote! {
+        extern crate test;
+        use self::test::KvmTestMetaData;
+        #[link_section = ".kvm"]
+        #[used]
+        static #struct_ident: KvmTestMetaData = KvmTestMetaData { mbz: 0, meta: "test"  };
+
+        /// The generated impl
+        fn #setup_fn_ident() {
             log!("blabla");
         }
-    }
+    })
+}
+
+/// Inserts a reference to the corresponding KvmTestData struct of a test function
+/// i.e., the test function fn test { foo(); } is changed to
+/// fn test() { assert!(foo_kvm_meta_data.mbz == 0); foo(); }
+///
+/// This makes sure that the linker won't throw away the symbol to the meta data struct.
+/// An alternative would be to make sure test code is linked with --whole-archive,
+/// but I'm not sure how to do that in rust...
+fn insert_meta_data_reference(struct_ident: &syn::Ident, test_block: &mut syn::Block) {
+    let stmt_string = format!("assert!({}.mbz == 0);", struct_ident);
+
+    let stmt = match syn::parse::stmt(stmt_string.as_str()) {
+        IResult::Done(stmt_str, stmt) => stmt,
+        IResult::Error => panic!("Unable to generate reference to meta data"),
+    };
+
+    test_block.stmts.insert(0, stmt);
 }
 
-use std::string;
 
 #[proc_macro_attribute]
 pub fn kvmattrs(args: TokenStream, input: TokenStream) -> TokenStream {
     let args = args.to_string();
     let mut input = input.to_string();
+    let mut ast = syn::parse_item(&input).unwrap();
+    let ident = ast.ident.clone();
+    let (meta_data_ident, new_code) = generate_kvmtest_meta_data(&ident);
+
+    {
+        match &mut ast.node {
+            &mut syn::ItemKind::Fn(_, _, _, _, _, ref mut block) => {
+                let mod_test_code = insert_meta_data_reference(&meta_data_ident, block);
+                println!("{:#?}", block);
+            }
+            _ => panic!("Not a function!"),
+        };
+    }
+    let mut token = quote::Tokens::new();
+    ast.to_tokens(&mut token);
+    token.append(new_code);
 
-    let ast = syn::parse_item(&input).unwrap();
-    let new_fn_ident = syn::Ident::new(String::from(ast.ident.as_ref()) + "_setup");
-    println!("{:?}", new_fn_ident);
-
-    // Get just the bare note string
-    let panics_note = args.trim_matches(&['=', ' ', '"'][..]);
-    let new_code: TokenStream = generate_kvm_setup(new_fn_ident).parse().unwrap();
-
-    input += new_code.to_string().as_str();
-    input.parse().unwrap()
+    //input += new_code.to_string().as_str();
+    token.to_string().parse().unwrap()
 }

tests/kvm/bin.rs

@@ -1,4 +1,4 @@
-#![feature(linkage, naked_functions, asm, const_fn, test, proc_macro)]
+#![feature(linkage, naked_functions, asm, const_fn, proc_macro, used)]
 // Execute using: RUSTFLAGS="-C relocation-model=dynamic-no-pic -C code-model=kernel" RUST_BACKTRACE=1 cargo test --verbose --test kvm -- --nocapture
 
 extern crate kvm;
@@ -10,7 +10,6 @@ extern crate core;
 extern crate klogger;
 
 extern crate test_macros;
-use test_macros::panics_note;
 use test_macros::kvmattrs;
 
 use kvm::{Capability, Exit, IoDirection, Segment, System, Vcpu, VirtualMachine};
@@ -24,7 +23,6 @@ use x86::bits64::paging::*;
 
 #[kvmattrs(identity_map)]
 fn use_the_port() {
-    use_the_port_setup();
     log!("1");
     unsafe {
         asm!("inb $0, %al" :: "i"(0x01) :: "volatile");