Revises CPU exit event

gui/src/hv/mod.rs

@@ -40,7 +40,7 @@ pub trait Hypervisor: Send + Sync + 'static {
     fn create_cpu(&self, id: usize) -> Result<Self::Cpu<'_>, Self::CpuErr>;
 }
 
-/// Represents a core of the PS4 CPU.
+/// Represents a core of the CPU.
 ///
 /// On AArch64 this represent one Processing Element (PE).
 pub trait Cpu {
@@ -54,9 +54,7 @@ pub trait Cpu {
     type TranslateErr: Error + Send + Sync + 'static;
 
     fn id(&self) -> usize;
-
     fn states(&mut self) -> Result<Self::States<'_>, Self::GetStatesErr>;
-
     fn translate(&self, vaddr: usize) -> Result<usize, Self::TranslateErr>;
 }
 

gui/src/main.rs

@@ -8,7 +8,7 @@ use self::ui::{
     MainWindow, PlatformExt, ProfileModel, ResolutionModel, RuntimeExt, SlintBackend,
     WaitForDebugger,
 };
-use self::vmm::{Vmm, VmmError};
+use self::vmm::{Vmm, VmmError, VmmEvent};
 use async_net::{TcpListener, TcpStream};
 use clap::{Parser, ValueEnum};
 use erdp::ErrorDisplay;
@@ -275,12 +275,11 @@ async fn run(args: ProgramArgs, exe: PathBuf) -> Result<(), ProgramError> {
 
         // Process VMM event.
         if let Some(vmm) = vmm {
-            let vmm = match vmm {
-                Some(v) => v,
-                None => break,
-            };
-
-            todo!()
+            match vmm {
+                VmmEvent::Exit(_, _) => todo!(),
+                VmmEvent::Log(console_type, _) => todo!(),
+                VmmEvent::Breakpoint(base_stop_reason) => todo!(),
+            }
         }
 
         // Process debugger requests.

gui/src/vmm/channel/main.rs

@@ -1,6 +1,5 @@
 use gdbstub::stub::MultiThreadStopReason;
 use obconf::ConsoleType;
-use std::error::Error;
 
 /// Provides method to send and receive events from the main thread.
 pub struct MainStream {}
@@ -10,21 +9,13 @@ impl MainStream {
         Self {}
     }
 
-    pub fn error(&self, reason: impl Error + Send + Sync + 'static) {
-        todo!()
-    }
-
     pub fn log(&self, ty: ConsoleType, msg: impl Into<String>) {
         todo!()
     }
 
     pub fn breakpoint(&self, stop: Option<MultiThreadStopReason<u64>>) -> BreakpointLock {
         todo!()
     }
-
-    pub fn exit(&self, success: bool) {
-        todo!()
-    }
 }
 
 /// This struct will prevent the other CPU from entering a debugger dispatch loop.

gui/src/vmm/cpu/mod.rs

@@ -1,28 +1,12 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
-pub use self::controller::*;
-
-use super::channel::MainStream;
-use super::hw::{DeviceContext, DeviceTree};
+use super::hw::DeviceContext;
 use crate::hv::Cpu;
 use std::collections::BTreeMap;
-use std::error::Error;
 use std::num::NonZero;
-use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, Mutex};
 use thiserror::Error;
 
-mod controller;
 pub mod debug;
 
-/// Encapsulates arguments for a function to run a CPU.
-pub struct Args<H> {
-    pub hv: Arc<H>,
-    pub main: Arc<MainStream>,
-    pub devices: Arc<DeviceTree>,
-    pub breakpoint: Arc<Mutex<()>>,
-    pub shutdown: Arc<AtomicBool>,
-}
-
 /// Contains instantiated device context for a CPU.
 pub struct Device<'a, C: Cpu> {
     pub context: Box<dyn DeviceContext<C> + 'a>,
@@ -47,40 +31,6 @@ impl<'a, C: Cpu> Device<'a, C> {
     }
 }
 
-/// Represents an error when a vCPU fails.
-#[derive(Debug, Error)]
-pub enum CpuError {
-    #[error("couldn't create vCPU")]
-    Create(#[source] Box<dyn Error + Send + Sync>),
-
-    #[error("couldn't setup vCPU")]
-    Setup(#[source] Box<dyn Error + Send + Sync>),
-
-    #[error("couldn't run vCPU")]
-    Run(#[source] Box<dyn Error + Send + Sync>),
-
-    #[error("couldn't execute a VM exited event on a {0}")]
-    DeviceExitHandler(String, #[source] Box<dyn Error + Send + Sync>),
-
-    #[error("the vCPU attempt to execute a memory-mapped I/O on a non-mapped address {0:#x}")]
-    MmioAddr(usize),
-
-    #[error("couldn't execute a memory-mapped I/O on a {0}")]
-    Mmio(String, #[source] Box<dyn Error + Send + Sync>),
-
-    #[error("couldn't get vCPU states")]
-    GetStates(#[source] Box<dyn Error + Send + Sync>),
-
-    #[error("couldn't read {0} register")]
-    ReadReg(&'static str, #[source] Box<dyn Error + Send + Sync>),
-
-    #[error("couldn't translate address {0:#x}")]
-    TranslateAddr(usize, #[source] Box<dyn Error + Send + Sync>),
-
-    #[error("couldn't execute a post VM exit on a {0}")]
-    DevicePostExitHandler(String, #[source] Box<dyn Error + Send + Sync>),
-}
-
 /// Implementation of [`gdbstub::target::Target::Error`].
 #[derive(Debug, Error)]
 pub enum GdbError {

gui/src/vmm/hw/console/context.rs

@@ -34,7 +34,7 @@ impl<H: Hypervisor, C: Cpu> DeviceContext<C> for Context<'_, H> {
     fn mmio(
         &mut self,
         exit: &mut <C::Exit<'_> as CpuExit>::Io,
-    ) -> Result<bool, Box<dyn Error + Send + Sync>> {
+    ) -> Result<Option<bool>, Box<dyn Error + Send + Sync>> {
         // Check field.
         let off = exit.addr() - self.dev.addr;
 
@@ -76,7 +76,7 @@ impl<H: Hypervisor, C: Cpu> DeviceContext<C> for Context<'_, H> {
             return Err(Box::new(ExecError::UnknownField(off)));
         }
 
-        Ok(true)
+        Ok(None)
     }
 }
 

gui/src/vmm/hw/mod.rs

@@ -114,21 +114,21 @@ pub trait Device: Send + Sync {
 /// Context for a CPU to execute operations on a virtual device.
 pub trait DeviceContext<C: Cpu> {
     /// Execute immeditately after the VM exited.
-    fn exited(&mut self, cpu: &mut C) -> Result<bool, Box<dyn Error + Send + Sync>> {
+    fn exited(&mut self, cpu: &mut C) -> Result<Option<bool>, Box<dyn Error + Send + Sync>> {
         let _ = cpu;
-        Ok(true)
+        Ok(None)
     }
 
     /// Execute only if the CPU read or write into this device address.
     fn mmio(
         &mut self,
         exit: &mut <C::Exit<'_> as CpuExit>::Io,
-    ) -> Result<bool, Box<dyn Error + Send + Sync>>;
+    ) -> Result<Option<bool>, Box<dyn Error + Send + Sync>>;
 
     /// Always execute after the exited event has been handled (before enter the VM again).
-    fn post(&mut self, cpu: &mut C) -> Result<bool, Box<dyn Error + Send + Sync>> {
+    fn post(&mut self, cpu: &mut C) -> Result<Option<bool>, Box<dyn Error + Send + Sync>> {
         let _ = cpu;
-        Ok(true)
+        Ok(None)
     }
 }
 

gui/src/vmm/hw/vmm/context.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 use super::Vmm;
 use crate::hv::{Cpu, CpuExit, CpuIo};
-use crate::vmm::channel::MainStream;
 use crate::vmm::hw::{read_u8, DeviceContext, MmioError};
 use obconf::{KernelExit, VmmMemory};
 use std::error::Error;
@@ -11,20 +10,19 @@ use thiserror::Error;
 /// Implementation of [`DeviceContext`].
 pub struct Context<'a> {
     dev: &'a Vmm,
-    main: &'a MainStream,
 }
 
 impl<'a> Context<'a> {
-    pub fn new(dev: &'a Vmm, main: &'a MainStream) -> Self {
-        Self { dev, main }
+    pub fn new(dev: &'a Vmm) -> Self {
+        Self { dev }
     }
 }
 
 impl<C: Cpu> DeviceContext<C> for Context<'_> {
     fn mmio(
         &mut self,
         exit: &mut <C::Exit<'_> as CpuExit>::Io,
-    ) -> Result<bool, Box<dyn Error + Send + Sync>> {
+    ) -> Result<Option<bool>, Box<dyn Error + Send + Sync>> {
         // Check field.
         let off = exit.addr() - self.dev.addr;
 
@@ -34,9 +32,7 @@ impl<C: Cpu> DeviceContext<C> for Context<'_> {
                 .try_into()
                 .map_err(|_| Box::new(ExecError::InvalidExit(exit)))?;
 
-            self.main.exit(exit == KernelExit::Success);
-
-            Ok(false)
+            Ok(Some(exit == KernelExit::Success))
         } else {
             Err(Box::new(ExecError::UnknownField(off)))
         }

gui/src/vmm/hw/vmm/mod.rs

@@ -2,7 +2,6 @@
 use self::context::Context;
 use super::{Device, DeviceContext};
 use crate::hv::Cpu;
-use crate::vmm::channel::MainStream;
 use obconf::VmmMemory;
 use std::num::NonZero;
 
@@ -24,11 +23,8 @@ impl Vmm {
         Self { addr, len }
     }
 
-    pub fn create_context<'a, C: Cpu>(
-        &'a self,
-        main: &'a MainStream,
-    ) -> Box<dyn DeviceContext<C> + 'a> {
-        Box::new(Context::new(self, main))
+    pub fn create_context<'a, C: Cpu>(&'a self) -> Box<dyn DeviceContext<C> + 'a> {
+        Box::new(Context::new(self))
     }
 }