Single Processor Works with new Serial Logger

Author: memN0ps

driver/src/main.rs

@@ -5,12 +5,16 @@
 
 extern crate alloc;
 
+use core::ffi::c_void;
 use {
-    crate::{processor::MpManager, virtualize::virtualize_system},
+    crate::{
+        processor::MpManager,
+        virtualize::{switch_stack_and_virtualize_core, zap_relocations},
+    },
     hypervisor::{
         global::GlobalState,
         intel::capture::{capture_registers, GuestRegisters},
-        logger::init_uart_logger,
+        logger,
     },
     log::*,
     uefi::prelude::*,
@@ -41,12 +45,9 @@ fn panic_handler(info: &core::panic::PanicInfo) -> ! {
 #[entry]
 fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
     // Initialize the COM2 port logger with level filter set to Info.
-    // init_uart_logger();
+    logger::init(LevelFilter::Trace);
 
-    com_logger::builder()
-        .base(0x2f8)
-        .filter(LevelFilter::Trace)
-        .setup();
+    //com_logger::builder().base(0x2f8).filter(LevelFilter::Trace).setup();
 
     uefi_services::init(&mut system_table).unwrap();
 
@@ -67,6 +68,8 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
     info!("Total processors: {}", processor_count.total);
     info!("Enabled processors: {}", processor_count.enabled);
 
+    zap_relocations(&system_table);
+
     // 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) }
@@ -81,20 +84,17 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
 
         if processor_count.enabled == 1 {
             info!("Found only one processor, virtualizing it");
-            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),
-                }
+            switch_stack_and_virtualize_core(&mut global_state 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 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!");

driver/src/virtualize.rs

@@ -1,3 +1,4 @@
+use core::ffi::c_void;
 use {
     alloc::alloc::{alloc_zeroed, handle_alloc_error},
     core::{alloc::Layout, arch::global_asm},
@@ -9,7 +10,7 @@ use {
     },
 };
 
-pub fn virtualize_system(global_state: &mut GlobalState, system_table: &SystemTable<Boot>) -> ! {
+pub fn zap_relocations(system_table: &SystemTable<Boot>) {
     let boot_service = system_table.boot_services();
 
     // Open the loaded image protocol to get the current image base and image size.
@@ -37,7 +38,9 @@ pub fn virtualize_system(global_state: &mut GlobalState, system_table: &SystemTa
         *((image_base + 0x128) as *mut u32) = 0;
         *((image_base + 0x12c) as *mut u32) = 0;
     }
+}
 
+pub fn allocate_stack() -> u64 {
     // Allocate separate stack space. This is never freed.
     let layout = Layout::array::<Page>(0x10).unwrap();
 
@@ -50,6 +53,13 @@ pub fn virtualize_system(global_state: &mut GlobalState, system_table: &SystemTa
     let stack_base = stack as u64 + layout.size() as u64 - 0x10;
     debug!("Stack range: {:#x?}", stack_base..stack as u64);
 
+    stack_base
+}
+
+pub extern "efiapi" fn switch_stack_and_virtualize_core(procedure_argument: *mut c_void) {
+    let global_state = unsafe { &mut *(procedure_argument as *mut GlobalState) };
+    let stack_base = allocate_stack();
+
     unsafe { switch_stack(global_state, start_hypervisor as usize, stack_base) };
 }
 

hypervisor/src/logger.rs

@@ -1,7 +1,4 @@
-//! The module containing the UART (serial port) logger implementation.
-// Inspired by:
-// https://github.com/iankronquist/rustyvisor/blob/83b53ac104d85073858ba83326a28a6e08d1af12/pcuart/src/lib.rs
-// Credits: https://github.com/tandasat/Hello-VT-rp/blob/main/hypervisor/src/logger.rs
+//! The module containing the serial port logger implementation.
 
 use {
     crate::intel::support::{inb, outb},
@@ -10,25 +7,27 @@ use {
 };
 
 /// Initializes the logger instance.
-pub fn init_uart_logger(level: log::LevelFilter) -> Result<(), log::SetLoggerError> {
-    log::set_logger(&UART_LOGGER).map(|()| log::set_max_level(level))
+pub fn init(level: log::LevelFilter) {
+    log::set_logger(&SERIAL_LOGGER)
+        .map(|()| log::set_max_level(level))
+        .unwrap();
 }
 
-struct UartLogger {
-    port: Mutex<Uart>,
+struct SerialLogger {
+    port: Mutex<Serial>,
 }
-impl UartLogger {
-    const fn new(port: UartComPort) -> Self {
+impl SerialLogger {
+    const fn new() -> Self {
         Self {
-            port: Mutex::new(Uart::new(port)),
+            port: Mutex::new(Serial {}),
         }
     }
 
-    fn lock(&self) -> spin::MutexGuard<'_, Uart> {
+    fn lock(&self) -> spin::MutexGuard<'_, Serial> {
         self.port.lock()
     }
 }
-impl log::Log for UartLogger {
+impl log::Log for SerialLogger {
     fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
         metadata.level() <= log::Level::Trace
     }
@@ -42,38 +41,22 @@ impl log::Log for UartLogger {
     fn flush(&self) {}
 }
 
-#[derive(Default)]
-struct Uart {
-    io_port_base: u16,
-}
-impl Uart {
-    const fn new(port: UartComPort) -> Self {
-        Self {
-            io_port_base: port as u16,
-        }
-    }
-}
-impl Write for Uart {
+struct Serial;
+
+impl Write for Serial {
     // Writes bytes `string` to the serial port.
     fn write_str(&mut self, string: &str) -> Result<(), fmt::Error> {
+        //const UART_COM1: u16 = 0x3f8;
+        const UART_COM2: u16 = 0x2f8;
         const UART_OFFSET_TRANSMITTER_HOLDING_BUFFER: u16 = 0;
         const UART_OFFSET_LINE_STATUS: u16 = 5;
 
         for byte in string.bytes() {
-            while (inb(self.io_port_base + UART_OFFSET_LINE_STATUS) & 0x20) == 0 {}
-            outb(
-                self.io_port_base + UART_OFFSET_TRANSMITTER_HOLDING_BUFFER,
-                byte,
-            );
+            while (inb(UART_COM2 + UART_OFFSET_LINE_STATUS) & 0x20) == 0 {}
+            outb(UART_COM2 + UART_OFFSET_TRANSMITTER_HOLDING_BUFFER, byte);
         }
         Ok(())
     }
 }
 
-#[derive(Clone, Copy)]
-#[repr(u16)]
-enum UartComPort {
-    Com1 = 0x3f8,
-}
-
-static UART_LOGGER: UartLogger = UartLogger::new(UartComPort::Com1);
+static SERIAL_LOGGER: SerialLogger = SerialLogger::new();