Step 3: run a simple guest

Author: equation314

hypervisor/Cargo.lock

@@ -1,5 +1,6 @@
-use rvm::{HostPhysAddr, HostVirtAddr, RvmHal};
+use rvm::{HostPhysAddr, HostVirtAddr, RvmHal, RvmVcpu};
 
+use super::vmexit;
 use crate::mm::{address, frame};
 
 pub struct RvmHalImpl;
@@ -20,4 +21,8 @@ impl RvmHal for RvmHalImpl {
     fn virt_to_phys(vaddr: HostVirtAddr) -> HostPhysAddr {
         address::virt_to_phys(vaddr)
     }
+
+    fn vmexit_handler(vcpu: &mut RvmVcpu<Self>) {
+        vmexit::vmexit_handler(vcpu).unwrap()
+    }
 }

hypervisor/src/hv/hal.rs

@@ -1,17 +1,36 @@
 mod hal;
+mod vmexit;
 
 use rvm::RvmPerCpu;
 
 use self::hal::RvmHalImpl;
 
-pub fn run() {
+pub fn run() -> ! {
     println!("Starting virtualization...");
     println!("Hardware support: {:?}", rvm::has_hardware_support());
 
     let mut percpu = RvmPerCpu::<RvmHalImpl>::new(0);
     percpu.hardware_enable().unwrap();
 
-    let mut vcpu = percpu.create_vcpu().unwrap();
+    let mut vcpu = percpu.create_vcpu(test_guest as usize).unwrap();
     info!("{:#x?}", vcpu);
+    println!("Running guest...");
     vcpu.run();
 }
+
+#[naked]
+unsafe extern "C" fn test_guest() -> ! {
+    core::arch::asm!(
+        "
+        mov     rax, 0
+        mov     rdi, 2
+        mov     rsi, 3
+        mov     rdx, 3
+        mov     rcx, 3
+    2:
+        vmcall
+        add     rax, 1
+        jmp     2b",
+        options(noreturn),
+    );
+}

hypervisor/src/hv/mod.rs

@@ -0,0 +1,44 @@
+use super::hal::RvmHalImpl;
+use rvm::arch::VmxExitReason;
+use rvm::{RvmResult, RvmVcpu};
+
+type Vcpu = RvmVcpu<RvmHalImpl>;
+
+const VM_EXIT_INSTR_LEN_VMCALL: u8 = 3;
+
+fn handle_hypercall(vcpu: &mut Vcpu) -> RvmResult {
+    let regs = vcpu.regs();
+    info!(
+        "VM exit: VMCALL({:#x}): {:?}",
+        regs.rax,
+        [regs.rdi, regs.rsi, regs.rdx, regs.rcx]
+    );
+    vcpu.advance_rip(VM_EXIT_INSTR_LEN_VMCALL)?;
+    Ok(())
+}
+
+pub fn vmexit_handler(vcpu: &mut Vcpu) -> RvmResult {
+    let exit_info = vcpu.exit_info()?;
+    debug!("VM exit: {:#x?}", exit_info);
+
+    if exit_info.entry_failure {
+        panic!("VM entry failed: {:#x?}", exit_info);
+    }
+
+    let res = match exit_info.exit_reason {
+        VmxExitReason::VMCALL => handle_hypercall(vcpu),
+        _ => panic!(
+            "Unhandled VM-Exit reason {:?}:\n{:#x?}",
+            exit_info.exit_reason, vcpu
+        ),
+    };
+
+    if res.is_err() {
+        panic!(
+            "Failed to handle VM-exit {:?}:\n{:#x?}",
+            exit_info.exit_reason, vcpu
+        );
+    }
+
+    Ok(())
+}

hypervisor/src/hv/vmexit.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 #![feature(asm_const)]
+#![feature(naked_functions)]
 #![feature(panic_info_message, alloc_error_handler)]
 
 #[macro_use]
@@ -76,10 +77,4 @@ fn main() -> ! {
     println!("Initialization completed.\n");
 
     hv::run();
-    println!("Run OK!");
-
-    arch::instructions::enable_irqs();
-    loop {
-        arch::instructions::wait_for_ints();
-    }
 }

hypervisor/src/main.rs

@@ -15,6 +15,7 @@ log = "0.4"
 cfg-if = "1.0"
 bitflags = "1.3"
 bit_field = "0.10"
+numeric-enum-macro = "0.2"
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 x86 = "0.52"

rvm/Cargo.toml

@@ -1,11 +1,17 @@
 pub(crate) mod msr;
+
+#[macro_use]
 pub(crate) mod regs;
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "vmx")] {
         mod vmx;
         use vmx as vender;
+        pub use vmx::{VmxExitInfo, VmxExitReason};
     }
 }
 
-pub use vender::{has_hardware_support, ArchPerCpuState, RvmVcpu};
+pub(crate) use vender::{has_hardware_support, ArchPerCpuState};
+
+pub use regs::GeneralRegisters;
+pub use vender::RvmVcpu;

rvm/src/arch/x86_64/mod.rs

@@ -19,3 +19,47 @@ pub struct GeneralRegisters {
     pub r14: u64,
     pub r15: u64,
 }
+
+macro_rules! save_regs_to_stack {
+    () => {
+        "
+        push r15
+        push r14
+        push r13
+        push r12
+        push r11
+        push r10
+        push r9
+        push r8
+        push rdi
+        push rsi
+        push rbp
+        sub rsp, 8
+        push rbx
+        push rdx
+        push rcx
+        push rax"
+    };
+}
+
+macro_rules! restore_regs_from_stack {
+    () => {
+        "
+        pop rax
+        pop rcx
+        pop rdx
+        pop rbx
+        add rsp, 8
+        pop rbp
+        pop rsi
+        pop rdi
+        pop r8
+        pop r9
+        pop r10
+        pop r11
+        pop r12
+        pop r13
+        pop r14
+        pop r15"
+    };
+}

rvm/src/arch/x86_64/regs.rs

@@ -0,0 +1,126 @@
+use core::fmt::{Debug, Formatter, Result};
+
+/// VM instruction error numbers. (SDM Vol. 3C, Section 30.4)
+pub struct VmxInstructionError(u32);
+
+impl VmxInstructionError {
+    pub fn as_str(&self) -> &str {
+        match self.0 {
+            0 => "OK",
+            1 => "VMCALL executed in VMX root operation",
+            2 => "VMCLEAR with invalid physical address",
+            3 => "VMCLEAR with VMXON pointer",
+            4 => "VMLAUNCH with non-clear VMCS",
+            5 => "VMRESUME with non-launched VMCS",
+            6 => "VMRESUME after VMXOFF (VMXOFF and VMXON between VMLAUNCH and VMRESUME)",
+            7 => "VM entry with invalid control field(s)",
+            8 => "VM entry with invalid host-state field(s)",
+            9 => "VMPTRLD with invalid physical address",
+            10 => "VMPTRLD with VMXON pointer",
+            11 => "VMPTRLD with incorrect VMCS revision identifier",
+            12 => "VMREAD/VMWRITE from/to unsupported VMCS component",
+            13 => "VMWRITE to read-only VMCS component",
+            15 => "VMXON executed in VMX root operation",
+            16 => "VM entry with invalid executive-VMCS pointer",
+            17 => "VM entry with non-launched executive VMCS",
+            18 => "VM entry with executive-VMCS pointer not VMXON pointer (when attempting to deactivate the dual-monitor treatment of SMIs and SMM)",
+            19 => "VMCALL with non-clear VMCS (when attempting to activate the dual-monitor treatment of SMIs and SMM)",
+            20 => "VMCALL with invalid VM-exit control fields",
+            22 => "VMCALL with incorrect MSEG revision identifier (when attempting to activate the dual-monitor treatment of SMIs and SMM)",
+            23 => "VMXOFF under dual-monitor treatment of SMIs and SMM",
+            24 => "VMCALL with invalid SMM-monitor features (when attempting to activate the dual-monitor treatment of SMIs and SMM)",
+            25 => "VM entry with invalid VM-execution control fields in executive VMCS (when attempting to return from SMM)",
+            26 => "VM entry with events blocked by MOV SS",
+            28 => "Invalid operand to INVEPT/INVVPID",
+            _ => "[INVALID]",
+        }
+    }
+}
+
+impl From<u32> for VmxInstructionError {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl Debug for VmxInstructionError {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        write!(f, "VmxInstructionError({}, {:?})", self.0, self.as_str())
+    }
+}
+
+numeric_enum_macro::numeric_enum! {
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[allow(non_camel_case_types)]
+/// VMX basic exit reasons. (SDM Vol. 3D, Appendix C)
+pub enum VmxExitReason {
+    EXCEPTION_NMI = 0,
+    EXTERNAL_INTERRUPT = 1,
+    TRIPLE_FAULT = 2,
+    INIT = 3,
+    SIPI = 4,
+    SMI = 5,
+    OTHER_SMI = 6,
+    INTERRUPT_WINDOW = 7,
+    NMI_WINDOW = 8,
+    TASK_SWITCH = 9,
+    CPUID = 10,
+    GETSEC = 11,
+    HLT = 12,
+    INVD = 13,
+    INVLPG = 14,
+    RDPMC = 15,
+    RDTSC = 16,
+    RSM = 17,
+    VMCALL = 18,
+    VMCLEAR = 19,
+    VMLAUNCH = 20,
+    VMPTRLD = 21,
+    VMPTRST = 22,
+    VMREAD = 23,
+    VMRESUME = 24,
+    VMWRITE = 25,
+    VMOFF = 26,
+    VMON = 27,
+    CR_ACCESS = 28,
+    DR_ACCESS = 29,
+    IO_INSTRUCTION = 30,
+    MSR_READ = 31,
+    MSR_WRITE = 32,
+    INVALID_GUEST_STATE = 33,
+    MSR_LOAD_FAIL = 34,
+    MWAIT_INSTRUCTION = 36,
+    MONITOR_TRAP_FLAG = 37,
+    MONITOR_INSTRUCTION = 39,
+    PAUSE_INSTRUCTION = 40,
+    MCE_DURING_VMENTRY = 41,
+    TPR_BELOW_THRESHOLD = 43,
+    APIC_ACCESS = 44,
+    VIRTUALIZED_EOI = 45,
+    GDTR_IDTR = 46,
+    LDTR_TR = 47,
+    EPT_VIOLATION = 48,
+    EPT_MISCONFIG = 49,
+    INVEPT = 50,
+    RDTSCP = 51,
+    PREEMPTION_TIMER = 52,
+    INVVPID = 53,
+    WBINVD = 54,
+    XSETBV = 55,
+    APIC_WRITE = 56,
+    RDRAND = 57,
+    INVPCID = 58,
+    VMFUNC = 59,
+    ENCLS = 60,
+    RDSEED = 61,
+    PML_FULL = 62,
+    XSAVES = 63,
+    XRSTORS = 64,
+    PCONFIG = 65,
+    SPP_EVENT = 66,
+    UMWAIT = 67,
+    TPAUSE = 68,
+    LOADIWKEY = 69,
+}
+}

rvm/src/arch/x86_64/vmx/definitions.rs

@@ -1,3 +1,4 @@
+mod definitions;
 mod structs;
 mod vcpu;
 mod vmcs;
@@ -11,7 +12,9 @@ use crate::arch::msr::Msr;
 use crate::error::{RvmError, RvmResult};
 use crate::hal::RvmHal;
 
+pub use self::definitions::VmxExitReason;
 pub use self::vcpu::VmxVcpu as RvmVcpu;
+pub use self::vmcs::VmxExitInfo;
 pub use self::VmxPerCpuState as ArchPerCpuState;
 
 pub fn has_hardware_support() -> bool {
@@ -127,6 +130,9 @@ impl<H: RvmHal> VmxPerCpuState<H> {
 
 impl From<VmFail> for RvmError {
     fn from(err: VmFail) -> Self {
-        rvm_err_type!(BadState, format_args!("VMX instruction failed: {:?}", err))
+        match err {
+            VmFail::VmFailValid => rvm_err_type!(BadState, vmcs::instruction_error().as_str()),
+            _ => rvm_err_type!(BadState, format_args!("VMX instruction failed: {:?}", err)),
+        }
     }
 }