Switch to on_event system for EmulatedDevice

Author: ALSchwalm

mythril/src/emulate/memio.rs

@@ -1,6 +1,8 @@
 use crate::error::Result;
 use crate::memory;
-use crate::virtdev::{InterruptArray, Port, PortReadRequest, PortWriteRequest};
+use crate::virtdev::{
+    DeviceEvent, Port, PortReadRequest, PortWriteRequest, ResponseEventArray,
+};
 use crate::{vcpu, vmcs, vmexit};
 use core::convert::TryFrom;
 
@@ -9,7 +11,7 @@ fn emulate_outs(
     port: Port,
     guest_cpu: &mut vmexit::GuestCpuState,
     exit: vmexit::IoInstructionInformation,
-    interrupts: &mut InterruptArray,
+    responses: &mut ResponseEventArray,
 ) -> Result<()> {
     let mut vm = vcpu.vm.write();
 
@@ -37,7 +39,12 @@ fn emulate_outs(
     // FIXME: Actually test for REP
     for chunk in bytes.chunks_exact(exit.size as usize) {
         let request = PortWriteRequest::try_from(chunk)?;
-        vm.on_port_write(vcpu, port, request, interrupts)?;
+        vm.dispatch_event(
+            port,
+            DeviceEvent::PortWrite((port, request)),
+            vcpu,
+            responses,
+        )?;
     }
 
     guest_cpu.rsi += bytes.len() as u64;
@@ -50,7 +57,7 @@ fn emulate_ins(
     port: Port,
     guest_cpu: &mut vmexit::GuestCpuState,
     exit: vmexit::IoInstructionInformation,
-    interrupts: &mut InterruptArray,
+    responses: &mut ResponseEventArray,
 ) -> Result<()> {
     let mut vm = vcpu.vm.write();
 
@@ -62,7 +69,12 @@ fn emulate_ins(
     let mut bytes = vec![0u8; guest_cpu.rcx as usize];
     for chunk in bytes.chunks_exact_mut(exit.size as usize) {
         let request = PortReadRequest::try_from(chunk)?;
-        vm.on_port_read(vcpu, port, request, interrupts)?;
+        vm.dispatch_event(
+            port,
+            DeviceEvent::PortRead((port, request)),
+            vcpu,
+            responses,
+        )?;
     }
 
     let mut view = memory::GuestAddressSpaceViewMut::from_vmcs(
@@ -80,7 +92,7 @@ pub fn emulate_portio(
     vcpu: &mut vcpu::VCpu,
     guest_cpu: &mut vmexit::GuestCpuState,
     exit: vmexit::IoInstructionInformation,
-    interrupts: &mut InterruptArray,
+    responses: &mut ResponseEventArray,
 ) -> Result<()> {
     let (port, input, size, string) =
         (exit.port, exit.input, exit.size, exit.string);
@@ -89,25 +101,32 @@ pub fn emulate_portio(
         let mut vm = vcpu.vm.write();
         if !input {
             let arr = (guest_cpu.rax as u32).to_be_bytes();
-            vm.on_port_write(
-                vcpu,
+            let request =
+                PortWriteRequest::try_from(&arr[4 - size as usize..])?;
+            vm.dispatch_event(
                 port,
-                PortWriteRequest::try_from(&arr[4 - size as usize..])?,
-                interrupts,
+                DeviceEvent::PortWrite((port, request)),
+                vcpu,
+                responses,
             )?;
         } else {
             let mut arr = [0u8; 4];
             let request =
                 PortReadRequest::try_from(&mut arr[4 - size as usize..])?;
-            vm.on_port_read(vcpu, port, request, interrupts)?;
+            vm.dispatch_event(
+                port,
+                DeviceEvent::PortRead((port, request)),
+                vcpu,
+                responses,
+            )?;
             guest_cpu.rax &= (!guest_cpu.rax) << (size * 8);
             guest_cpu.rax |= u32::from_be_bytes(arr) as u64;
         };
     } else {
         if !input {
-            emulate_outs(vcpu, port, guest_cpu, exit, interrupts)?;
+            emulate_outs(vcpu, port, guest_cpu, exit, responses)?;
         } else {
-            emulate_ins(vcpu, port, guest_cpu, exit, interrupts)?;
+            emulate_ins(vcpu, port, guest_cpu, exit, responses)?;
         }
     }
 

mythril/src/emulate/portio.rs

@@ -446,7 +446,7 @@ impl VCpu {
 
     fn handle_uart_keypress(
         &mut self,
-        interrupts: &mut virtdev::InterruptArray,
+        responses: &mut virtdev::ResponseEventArray,
     ) -> Result<()> {
         let vm = self.vm.read();
 
@@ -460,11 +460,11 @@ impl VCpu {
 
         let mut vm = self.vm.write();
         if let Some((key, port)) = serial_info {
-            vm.on_event(
-                self,
-                &virtdev::DeviceMessage::UartKeyPressed(key),
+            vm.dispatch_event(
                 port,
-                interrupts,
+                virtdev::DeviceEvent::HostUartReceived(key),
+                self,
+                responses,
             )
         } else {
             Ok(())
@@ -476,9 +476,7 @@ impl VCpu {
         guest_cpu: &mut vmexit::GuestCpuState,
         exit: vmexit::ExitReason,
     ) -> Result<()> {
-        // An array of outstanding interrupts/exceptions that should be injected
-        // into the guest as a result of this vmexit
-        let mut interrupts = virtdev::InterruptArray::default();
+        let mut responses = virtdev::ResponseEventArray::default();
 
         match exit.info {
             vmexit::ExitInformation::CrAccess(info) => {
@@ -542,7 +540,7 @@ impl VCpu {
                     self,
                     guest_cpu,
                     info,
-                    &mut interrupts,
+                    &mut responses,
                 )?;
                 self.skip_emulated_instruction()?;
             }
@@ -551,7 +549,7 @@ impl VCpu {
                     self,
                     guest_cpu,
                     info,
-                    &mut interrupts,
+                    &mut responses,
                 )?;
                 self.skip_emulated_instruction()?;
             }
@@ -566,7 +564,7 @@ impl VCpu {
             vmexit::ExitInformation::InterruptWindow => {}
             vmexit::ExitInformation::ExternalInterrupt(info) => unsafe {
                 match info.vector {
-                    0x24 => self.handle_uart_keypress(&mut interrupts)?,
+                    0x24 => self.handle_uart_keypress(&mut responses)?,
                     _ => (),
                 }
 
@@ -584,11 +582,13 @@ impl VCpu {
             }
         }
 
-        for interrupt in interrupts {
-            self.inject_interrupt(
-                interrupt,
-                InjectedInterruptType::ExternalInterrupt,
-            );
+        for response in responses {
+            match response {
+                virtdev::DeviceEventResponse::Interrupt((vector, kind)) => {
+                    self.inject_interrupt(vector, kind);
+                }
+                _ => (),
+            }
         }
 
         Ok(())

mythril/src/vcpu.rs

@@ -1,10 +1,6 @@
 use crate::error::Result;
-use crate::memory::GuestAddressSpaceViewMut;
 use crate::time;
-use crate::virtdev::{
-    DeviceRegion, EmulatedDevice, InterruptArray, Port, PortReadRequest,
-    PortWriteRequest,
-};
+use crate::virtdev::{DeviceEvent, DeviceRegion, EmulatedDevice, Event, Port};
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use spin::RwLock;
@@ -71,33 +67,25 @@ impl EmulatedDevice for AcpiRuntime {
         ]
     }
 
-    fn on_port_read(
-        &mut self,
-        port: Port,
-        mut val: PortReadRequest,
-        _space: GuestAddressSpaceViewMut,
-        _interrupts: &mut InterruptArray,
-    ) -> Result<()> {
-        if port == self.pmtimer() {
-            let on_duration = time::now() - time::system_start_time();
-            let pm_time =
-                (on_duration.as_nanos() * PMTIMER_HZ as u128) / 1_000_000_000;
-            val.copy_from_u32(pm_time as u32);
+    fn on_event(&mut self, event: Event) -> Result<()> {
+        match event.kind {
+            DeviceEvent::PortRead((port, mut val)) => {
+                if port == self.pmtimer() {
+                    let on_duration = time::now() - time::system_start_time();
+                    let pm_time = (on_duration.as_nanos() * PMTIMER_HZ as u128)
+                        / 1_000_000_000;
+                    val.copy_from_u32(pm_time as u32);
+                }
+            }
+            DeviceEvent::PortWrite((port, val)) => {
+                info!(
+                    "Attempt to write to AcpiRuntime port=0x{:x}, val={}. Ignoring",
+                    port, val
+                );
+            }
+            _ => (),
         }
-        Ok(())
-    }
 
-    fn on_port_write(
-        &mut self,
-        port: Port,
-        val: PortWriteRequest,
-        _space: GuestAddressSpaceViewMut,
-        _interrupts: &mut InterruptArray,
-    ) -> Result<()> {
-        info!(
-            "Attempt to write to AcpiRuntime port=0x{:x}, val={}. Ignoring",
-            port, val
-        );
         Ok(())
     }
 }