Bug was the new logger. (EPT is now per logical processor) TODO MULTI

Author: memN0ps

driver/Cargo.toml

@@ -11,5 +11,7 @@ uefi-services = { version = "0.23.0", default-features = false } # https://crate
 log = { version = "0.4.20", default-features = false } # https://crates.io/crates/log
 once_cell = "1.19.0" # https://crates.io/crates/once_cell
 spin = "0.9" # https://crates.io/crates/spin
+com_logger = "0.1.1" # https://crates.io/crates/com_logger
+
 
 hypervisor = { path = "../hypervisor" }

driver/src/main.rs

@@ -6,19 +6,10 @@
 extern crate alloc;
 
 use {
-    crate::{
-        processor::MpManager,
-        virtualize::{switch_stack_and_virtualize_core, Virtualize},
-    },
-    alloc::boxed::Box,
-    core::ffi::c_void,
+    crate::{processor::MpManager, virtualize::virtualize_system},
     hypervisor::{
-        error::HypervisorError,
-        intel::{
-            capture::{capture_registers, GuestRegisters},
-            ept::paging::{AccessType, Ept},
-            shared_data::SharedData,
-        },
+        global::GlobalState,
+        intel::capture::{capture_registers, GuestRegisters},
         logger::init_uart_logger,
     },
     log::*,
@@ -49,13 +40,23 @@ fn panic_handler(info: &core::panic::PanicInfo) -> ! {
 
 #[entry]
 fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
-    init_uart_logger();
+    // Initialize the COM2 port logger with level filter set to Info.
+    // init_uart_logger();
+
+    com_logger::builder()
+        .base(0x2f8)
+        .filter(LevelFilter::Trace)
+        .setup();
+
     uefi_services::init(&mut system_table).unwrap();
 
     info!("The Matrix is an illusion");
 
-    let mp_manager =
-        MpManager::new(system_table.boot_services()).expect("Failed to create MpManager");
+    // Get the MP Services (MultiProcessor Services) Protocol
+    let mp_manager = match MpManager::new(system_table.boot_services()) {
+        Ok(mp_manager) => mp_manager,
+        Err(e) => panic!("Failed to get MP Services: {:?}", e),
+    };
 
     // Get the processor count
     let processor_count = match mp_manager.processor_count() {
@@ -66,40 +67,34 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
     info!("Total processors: {}", processor_count.total);
     info!("Enabled processors: {}", processor_count.enabled);
 
-    // Setup EPT
-    let shared_data = match setup_ept() {
-        Ok(shared_data) => shared_data,
-        Err(e) => panic!("Failed to setup EPT: {:?}", e),
-    };
-
     // Capture the register values to be used as an initial state of the VM.
     let mut guest_registers = GuestRegisters::default();
     unsafe { capture_registers(&mut guest_registers) }
 
     // Since we captured RIP just above, the VM will start running from here.
-    // Check if our hypervisor is already loaded. If so, done, otherwise, continue
-    // installing the hypervisor.
+    // Check if our hypervisor is already loaded. If so, done, otherwise, continue installing the hypervisor.
     if !mp_manager.is_virtualized() {
         debug!("Virtualizing the system");
-
-        let mut virtualize = Virtualize::new(guest_registers, shared_data, &system_table);
-
-        debug!("Virtualizing each core");
         mp_manager.set_virtualized();
 
+        let mut global_state = GlobalState::new(guest_registers);
+
         if processor_count.enabled == 1 {
             info!("Found only one processor, virtualizing it");
-            switch_stack_and_virtualize_core(&mut virtualize as *mut _ as *mut c_void);
-        } else {
-            info!("Found multiple processors, virtualizing all of them");
-            match mp_manager.start_virtualization_on_all_processors(
-                switch_stack_and_virtualize_core,
-                &mut virtualize as *mut _ as *mut c_void,
-            ) {
-                Ok(_) => debug!("Virtualization started on all processors"),
-                Err(e) => panic!("Failed to start virtualization on all processors: {:?}", e),
-            }
+            virtualize_system(&mut global_state, &system_table);
         }
+        /*
+            else {
+                info!("Found multiple processors, virtualizing all of them");
+                match mp_manager.start_virtualization_on_all_processors(
+                    switch_stack_and_virtualize_core,
+                    &mut global_state as *mut _ as *mut c_void,
+                ) {
+                    Ok(_) => debug!("Virtualization started on all processors"),
+                    Err(e) => panic!("Failed to start virtualization on all processors: {:?}", e),
+                }
+            }
+        */
     }
 
     info!("The hypervisor has been installed successfully!");
@@ -108,18 +103,3 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
 
     Status::SUCCESS
 }
-
-pub fn setup_ept() -> Result<Box<SharedData>, HypervisorError> {
-    let mut primary_ept: Box<Ept> = unsafe { Box::new_zeroed().assume_init() };
-    let mut secondary_ept: Box<Ept> = unsafe { Box::new_zeroed().assume_init() };
-
-    debug!("Creating Primary EPT");
-    primary_ept.identity_2mb(AccessType::READ_WRITE_EXECUTE)?;
-
-    debug!("Creating Secondary EPT");
-    secondary_ept.identity_2mb(AccessType::READ_WRITE_EXECUTE)?;
-
-    let shared_data = SharedData::new(primary_ept, secondary_ept);
-
-    shared_data
-}

driver/src/virtualize.rs

@@ -1,123 +1,73 @@
 use {
     alloc::alloc::{alloc_zeroed, handle_alloc_error},
-    alloc::boxed::Box,
-    core::ffi::c_void,
     core::{alloc::Layout, arch::global_asm},
-    hypervisor::{
-        intel::{capture::GuestRegisters, page::Page, shared_data::SharedData},
-        vmm::start_hypervisor,
-    },
+    hypervisor::{global::GlobalState, intel::page::Page, vmm::start_hypervisor},
     log::debug,
     uefi::{
         proto::loaded_image::LoadedImage,
         table::{Boot, SystemTable},
     },
 };
 
-pub struct Virtualize {
-    guest_registers: GuestRegisters,
-    shared_data: Box<SharedData>,
-    landing_code: usize,
-    stack_base: u64,
-}
-
-impl Virtualize {
-    pub fn new(
-        guest_registers: GuestRegisters,
-        shared_data: Box<SharedData>,
-        system_table: &SystemTable<Boot>,
-    ) -> Self {
-        debug!("Zapping the Relocation Table and allocating separate stack space");
-
-        let boot_service = system_table.boot_services();
-
-        // Open the loaded image protocol to get the current image base and image size.
-        let loaded_image = boot_service
-            .open_protocol_exclusive::<LoadedImage>(boot_service.image_handle())
-            .unwrap();
-
-        // Get the current image base and image size.
-        let (image_base, image_size) = loaded_image.info();
-
-        let image_base = image_base as usize;
+pub fn virtualize_system(global_state: &mut GlobalState, system_table: &SystemTable<Boot>) -> ! {
+    let boot_service = system_table.boot_services();
 
-        let image_range = image_base..image_base + image_size as usize;
-        debug!("Image base: {:#x?}", image_range);
+    // Open the loaded image protocol to get the current image base and image size.
+    let loaded_image = boot_service
+        .open_protocol_exclusive::<LoadedImage>(boot_service.image_handle())
+        .unwrap();
 
-        // Prevent relocation by zapping the Relocation Table in the PE header. UEFI
-        // keeps the list of runtime drivers and applies patches into their code and
-        // data according to relocation information, as address translation switches
-        // from physical-mode to virtual-mode when the OS starts. This causes a problem
-        // with us because the host part keeps running under physical-mode, as the
-        // host has its own page tables. Relocation ends up breaking the host code.
-        // The easiest way is prevented this from happening is to nullify the relocation
-        // table.
-        unsafe {
-            *((image_base + 0x128) as *mut u32) = 0;
-            *((image_base + 0x12c) as *mut u32) = 0;
-        }
+    // Get the current image base and image size.
+    let (image_base, image_size) = loaded_image.info();
 
-        // Allocate separate stack space. This is never freed.
-        let layout = Layout::array::<Page>(0x10).unwrap();
+    let image_base = image_base as usize;
 
-        let stack = unsafe { alloc_zeroed(layout) };
+    let image_range = image_base..image_base + image_size as usize;
+    debug!("Image base: {:#x?}", image_range);
 
-        if stack.is_null() {
-            handle_alloc_error(layout);
-        }
+    // Prevent relocation by zapping the Relocation Table in the PE header. UEFI
+    // keeps the list of runtime drivers and applies patches into their code and
+    // data according to relocation information, as address translation switches
+    // from physical-mode to virtual-mode when the OS starts. This causes a problem
+    // with us because the host part keeps running under physical-mode, as the
+    // host has its own page tables. Relocation ends up breaking the host code.
+    // The easiest way is prevented this from happening is to nullify the relocation
+    // table.
+    unsafe {
+        *((image_base + 0x128) as *mut u32) = 0;
+        *((image_base + 0x12c) as *mut u32) = 0;
+    }
 
-        let stack_base = stack as u64 + layout.size() as u64 - 0x10;
-        debug!("Stack range: {:#x?}", stack_base..stack as u64);
+    // Allocate separate stack space. This is never freed.
+    let layout = Layout::array::<Page>(0x10).unwrap();
 
-        debug!("Relocation Table zapped and separate stack space allocated successfully!");
+    let stack = unsafe { alloc_zeroed(layout) };
 
-        Self {
-            guest_registers,
-            shared_data,
-            landing_code: start_hypervisor as usize,
-            stack_base,
-        }
+    if stack.is_null() {
+        handle_alloc_error(layout);
     }
-}
-
-pub extern "efiapi" fn switch_stack_and_virtualize_core(procedure_argument: *mut c_void) {
-    let virtualize: &mut Virtualize = unsafe { &mut *(procedure_argument as *mut Virtualize) };
 
-    debug!("Switching stack and virtualizing core");
+    let stack_base = stack as u64 + layout.size() as u64 - 0x10;
+    debug!("Stack range: {:#x?}", stack_base..stack as u64);
 
-    // Call `switch_stack` with the context data.
-    // Assuming `switch_stack` never returns, similar to the original `virtualize_system` behavior.
-    unsafe {
-        switch_stack(
-            &virtualize.guest_registers,
-            &mut virtualize.shared_data,
-            virtualize.landing_code,
-            virtualize.stack_base,
-        );
-    }
+    unsafe { switch_stack(global_state, start_hypervisor as usize, stack_base) };
 }
 
 extern "efiapi" {
     /// Jumps to the landing code with the new stack pointer.
-    fn switch_stack(
-        guest_registers: &GuestRegisters,
-        shared_data: &mut SharedData,
-        landing_code: usize,
-        stack_base: u64,
-    ) -> !;
+    fn switch_stack(global_state: &mut GlobalState, landing_code: usize, stack_base: u64) -> !;
 }
 
 global_asm!(
     r#"
 // The module containing the `switch_stack` function.
-
 // Jumps to the landing code with the new stack pointer.
 //
-// fn switch_stack(guest_registers: &GuestRegisters, shared_data: &mut SharedData, landing_code: usize, stack_base: u64) -> !
+// fn switch_stack(global_state: &mut GlobalState, landing_code: usize, stack_base: u64) -> !
 .global switch_stack
 switch_stack:
     xchg    bx, bx
-    mov     rsp, r9
-    jmp     r8
+    mov     rsp, r8
+    jmp     rdx
 "#
 );

hypervisor/src/config.rs

@@ -0,0 +1,11 @@
+use crate::intel::capture::GuestRegisters;
+
+pub struct GlobalState {
+    pub guest_registers: GuestRegisters,
+}
+
+impl GlobalState {
+    pub fn new(guest_registers: GuestRegisters) -> Self {
+        Self { guest_registers }
+    }
+}

hypervisor/src/global.rs

@@ -9,7 +9,6 @@ pub mod invvpid;
 pub mod page;
 pub mod paging;
 pub mod segmentation;
-pub mod shared_data;
 pub mod support;
 pub mod vm;
 pub mod vmcs;