Xen singlestep support

Cargo.toml

@@ -28,7 +28,7 @@ hyper-v = ["winapi", "widestring", "ntapi", "vid-sys"]
 log = "0.4.8"
 env_logger = "0.7.1"
 libc = { version = "0.2.58", optional = true }
-xenctrl = { version = "0.4.2", optional = true }
+xenctrl = { version = "0.4.4", optional = true }
 xenstore-rs = { version = "0.3.0", optional = true }
 xenforeignmemory = { version = "0.1.0", optional = true }
 xenevtchn = { version = "0.1.2", optional = true }

examples/singlestep-events.rs

@@ -0,0 +1,101 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Instant;
+
+use clap::{App, Arg, ArgMatches};
+use colored::*;
+use env_logger;
+
+use microvmi::api::*;
+
+fn parse_args() -> ArgMatches<'static> {
+    App::new(file!())
+        .version("0.1")
+        .about("Watches singlestep VMI events")
+        .arg(Arg::with_name("vm_name").index(1).required(true))
+        .get_matches()
+}
+
+fn toggle_singlestep_interception(drv: &mut Box<dyn Introspectable>, enabled: bool) {
+    drv.pause().expect("Failed to pause VM");
+
+    let intercept = InterceptType::Singlestep;
+    let status_str = if enabled { "Enabling" } else { "Disabling" };
+    println!("{} singlestep events", status_str);
+    for vcpu in 0..drv.get_vcpu_count().expect("Failed to get VCPU count") {
+        drv.toggle_intercept(vcpu, intercept, enabled)
+            .expect(&format!("Failed to enable singlestep"));
+    }
+
+    drv.resume().expect("Failed to resume VM");
+}
+
+fn main() {
+    env_logger::init();
+
+    let matches = parse_args();
+
+    let domain_name = matches.value_of("vm_name").unwrap();
+
+    let init_option = matches
+        .value_of("kvmi_socket")
+        .map(|socket| DriverInitParam::KVMiSocket(socket.into()));
+    // set CTRL-C handler
+    let running = Arc::new(AtomicBool::new(true));
+    let r = running.clone();
+    ctrlc::set_handler(move || {
+        r.store(false, Ordering::SeqCst);
+    })
+    .expect("Error setting Ctrl-C handler");
+
+    println!("Initialize Libmicrovmi");
+    let mut drv: Box<dyn Introspectable> = microvmi::init(domain_name, None, init_option);
+
+    //Enable singlestep interception
+    toggle_singlestep_interception(&mut drv, true);
+
+    println!("Listen for singlestep events...");
+    // record elapsed time
+    let start = Instant::now();
+    // listen
+    let mut i: u64 = 0;
+    while running.load(Ordering::SeqCst) {
+        match drv.listen(1000) {
+            Err(error) => {
+                println!("Error while listening for events: {}. Exiting.", error);
+                break;
+            }
+            Ok(event) => match event {
+                Some(ev) => {
+                    match ev.kind {
+                        EventType::Singlestep {} => (),
+                        _ => panic!("Not singlestep event"),
+                    };
+                    let ev_nb_output = format!("{}", i).cyan();
+                    let vcpu_output = format!("VCPU {}", ev.vcpu).yellow();
+                    let singlestep_output = format!("singlestep occurred!").color("blue");
+                    println!(
+                        "[{}] {} - {}: ",
+                        ev_nb_output, vcpu_output, singlestep_output
+                    );
+                    drv.reply_event(ev, EventReplyType::Continue)
+                        .expect("Failed to send event reply");
+                    i = i + 1;
+                }
+                None => println!("No events yet..."),
+            },
+        }
+    }
+    let duration = start.elapsed();
+
+    //disable singlestep interception
+    toggle_singlestep_interception(&mut drv, false);
+
+    let ev_per_sec = i as f64 / duration.as_secs_f64();
+    println!(
+        "Caught {} events in {:.2} seconds ({:.2} events/sec)",
+        i,
+        duration.as_secs_f64(),
+        ev_per_sec
+    );
+}

src/api.rs

@@ -314,6 +314,7 @@ pub enum InterceptType {
     /// Intercept when guest requests an access to a page for which the requested type of access is not granted. For example , guest tries to write on a read only page.
     Breakpoint,
     Pagefault,
+    Singlestep,
 }
 
 /// Various types of events along with their relevant attributes being handled by this driver
@@ -351,6 +352,7 @@ pub enum EventType {
         /// Acsess responsible for thr pagefault
         access: Access,
     },
+    Singlestep,
 }
 
 ///Types of x86 control registers are listed here
@@ -367,6 +369,7 @@ pub enum CrType {
 
 ///This provides an abstraction of event which the hypervisor reports and using which we introspect the guest
 #[repr(C)]
+#[derive(Debug)]
 pub struct Event {
     ///vcpu on which the event is detected
     pub vcpu: u16,

src/driver/kvm.rs

@@ -289,6 +289,9 @@ impl<T: KVMIntrospectable> Introspectable for Kvm<T> {
                     .kvmi
                     .control_events(vcpu, KVMiInterceptType::Pagefault, enabled)?)
             }
+            _ => {
+                unimplemented!()
+            }
         }
     }