Do com/debug output through DeviceEventResponse

Author: ALSchwalm

mythril/src/kmain.rs

@@ -56,10 +56,10 @@ fn default_vm(
         .register_device(virtdev::acpi::AcpiRuntime::new(0xb000).unwrap())
         .unwrap();
     device_map
-        .register_device(virtdev::debug::DebugPort::new(core as u64, 0x402))
+        .register_device(virtdev::debug::DebugPort::new(0x402))
         .unwrap();
     device_map
-        .register_device(virtdev::com::Uart8250::new(core as u64, 0x3F8))
+        .register_device(virtdev::com::Uart8250::new(0x3F8))
         .unwrap();
     device_map
         .register_device(virtdev::vga::VgaController::new())

mythril/src/vcpu.rs

@@ -540,7 +540,15 @@ impl VCpu {
                 virtdev::DeviceEventResponse::Interrupt((vector, kind)) => {
                     self.inject_interrupt(vector, kind);
                 }
-                _ => (),
+                virtdev::DeviceEventResponse::GuestUartTransmitted(val) => {
+                    let vm = self.vm.read();
+                    if vm.config.physical_devices().serial.is_some() {
+                        //TODO: This should be a write to the physical serial device
+                        let buff = &[val];
+                        let s = alloc::string::String::from_utf8_lossy(buff);
+                        crate::logger::write_console(&s);
+                    }
+                }
             }
         }
 

mythril/src/virtdev/com.rs

@@ -1,20 +1,16 @@
 use crate::error::Result;
-use crate::logger;
 use crate::physdev::com::*;
 use crate::vcpu;
 use crate::virtdev::{
     DeviceEvent, DeviceEventResponse, DeviceRegion, EmulatedDevice, Event, Port,
 };
-use alloc::string::String;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::convert::TryInto;
 use spin::RwLock;
 
 pub struct Uart8250 {
-    id: u64,
     base_port: Port,
-    is_newline: bool,
     divisor: u16,
     receive_buffer: Option<u8>,
     interrupt_enable_register: IerFlags,
@@ -27,12 +23,10 @@ pub struct Uart8250 {
 }
 
 impl Uart8250 {
-    pub fn new(vmid: u64, base_port: Port) -> Arc<RwLock<Self>> {
+    pub fn new(base_port: Port) -> Arc<RwLock<Self>> {
         Arc::new(RwLock::new(Self {
-            id: vmid,
             base_port: base_port,
             divisor: 0,
-            is_newline: true,
             receive_buffer: None,
             interrupt_identification_register: 0x01,
             interrupt_enable_register: IerFlags::empty(),
@@ -123,19 +117,9 @@ impl EmulatedDevice for Uart8250 {
                     if self.divisor_latch_bit_set() {
                         self.divisor &= 0xff00 | val as u16;
                     } else {
-                        if self.is_newline {
-                            logger::write_console(&format!(
-                                "GUEST{}: ",
-                                self.id
-                            ));
-                        }
-
-                        let buff = &[val];
-                        let s = String::from_utf8_lossy(buff);
-                        logger::write_console(&s);
-
-                        self.is_newline = val == 10;
-
+                        event.responses.push(
+                            DeviceEventResponse::GuestUartTransmitted(val),
+                        );
                         if self
                             .interrupt_enable_register
                             .contains(IerFlags::THR_EMPTY_INTERRUPT)

mythril/src/virtdev/debug.rs

@@ -1,24 +1,19 @@
 use crate::error::Result;
-use crate::logger;
-use crate::virtdev::{DeviceEvent, DeviceRegion, EmulatedDevice, Event, Port};
-use alloc::string::String;
+use crate::virtdev::{
+    DeviceEvent, DeviceEventResponse, DeviceRegion, EmulatedDevice, Event, Port,
+};
 use alloc::sync::Arc;
 use alloc::vec::Vec;
+use core::convert::TryInto;
 use spin::RwLock;
 
 pub struct DebugPort {
-    id: u64,
     port: Port,
-    buff: Vec<u8>,
 }
 
 impl DebugPort {
-    pub fn new(vmid: u64, port: Port) -> Arc<RwLock<Self>> {
-        Arc::new(RwLock::new(Self {
-            port,
-            buff: vec![],
-            id: vmid,
-        }))
+    pub fn new(port: Port) -> Arc<RwLock<Self>> {
+        Arc::new(RwLock::new(Self { port }))
     }
 }
 
@@ -29,20 +24,13 @@ impl EmulatedDevice for DebugPort {
 
     fn on_event(&mut self, event: Event) -> Result<()> {
         match event.kind {
-            DeviceEvent::PortRead((port, mut val)) => {
+            DeviceEvent::PortRead((_port, mut val)) => {
                 val.copy_from_u32(0xe9);
             }
-            DeviceEvent::PortWrite((port, val)) => {
-                self.buff.extend_from_slice(val.as_slice());
-
-                // Flush on newlines
-                if val.as_slice().iter().filter(|b| **b == 10).next().is_some()
-                {
-                    let s = String::from_utf8_lossy(&self.buff);
-
-                    logger::write_console(&format!("GUEST{}: {}", self.id, s));
-                    self.buff.clear();
-                }
+            DeviceEvent::PortWrite((_port, val)) => {
+                event.responses.push(
+                    DeviceEventResponse::GuestUartTransmitted(val.try_into()?),
+                );
             }
             _ => (),
         }