feat: 添加 MMIO 读写处理逻辑，优化 VDeviceList 设备管理

Author: ZR233

src/arch/aarch64/cpu.rs

@@ -168,15 +168,22 @@ impl VCpuOp for CPUState {
 
                         self.vcpu.set_gpr(reg, val);
                     } else {
-                        return Err(RunError::ExitWithError(anyhow!(
-                            "MMIO read @{addr:#x} no device"
-                        )));
+                        // TODO handle MMIO read failure
+                        warn!(
+                            "vCPU {:#x} MMIO read failed at addr {:#x}",
+                            self.mpidr_el1, addr
+                        );
                     }
-
-                    todo!()
                 }
                 arm_vcpu::AxVCpuExitReason::MmioWrite { addr, width, data } => {
                     debug!("vCPU {:#x} MMIO write at addr {:#x}", self.mpidr_el1, addr);
+                    let res = vm.handle_mmio_write(addr, width, data as _);
+                    if res.is_none() {
+                        warn!(
+                            "vCPU {:#x} MMIO write failed at addr {:#x}",
+                            self.mpidr_el1, addr
+                        );
+                    }
                 }
                 arm_vcpu::AxVCpuExitReason::SysRegRead { addr, reg } => {
                     todo!()

src/arch/aarch64/plat.rs

@@ -34,15 +34,21 @@ impl PlatData {
         let gicd = regs.get(0).ok_or(anyhow!("No GICD reg"))?;
         let gicr = regs.get(1).ok_or(anyhow!("No GICR reg"))?;
         let plat = self.vdev.new_plat();
+        let mut gic = v3::VGic::new();
+
+        // self.vdev.add_device(|plat| {
+        //     let gic = v3::VGic::new(
+        //         (gicd.address as usize).into(),
+        //         (gicr.address as usize).into(),
+        //         plat.clone(),
+        //     );
+        //     Ok(gic)
+        // });
 
         self.vdev.add_device(|plat| {
-            let gic = v3::VGic::new(
-                (gicd.address as usize).into(),
-                (gicr.address as usize).into(),
-                plat.clone(),
-            );
-            Ok(gic)
-        });
+            let gicd = gic.new_gicd(plat.clone(), (gicd.address as usize).into());
+            Ok(gicd)
+        })?;
 
         Ok(())
     }

src/vm/machine/mod.rs

@@ -45,4 +45,16 @@ impl<H: HalOp> Machine<H> {
         };
         running.vdevs.handle_mmio_read(addr, width)
     }
+
+    pub fn handle_mmio_write(
+        &self,
+        addr: GuestPhysAddr,
+        width: AccessWidth,
+        data: usize,
+    ) -> Option<()> {
+        let Machine::Running(running) = self else {
+            panic!("VM is not in running state");
+        };
+        running.vdevs.handle_mmio_write(addr, width, data)
+    }
 }

src/vm/mod.rs

@@ -171,6 +171,16 @@ impl Vm {
         let machine = self.machine.read();
         machine.handle_mmio_read(addr, width)
     }
+
+    pub(crate) fn handle_mmio_write(
+        &self,
+        addr: GuestPhysAddr,
+        width: AccessWidth,
+        data: usize,
+    ) -> Option<()> {
+        let machine = self.machine.read();
+        machine.handle_mmio_write(addr, width, data)
+    }
 }
 
 #[derive(Clone)]

src/vm/vdev.rs

@@ -24,9 +24,10 @@ impl VDevice {
         self.id
     }
 
-    pub fn run(&self) {
-        let mut dev = self.raw.lock();
-        dev.run();
+    pub fn try_invoke(&self) {
+        if let Some(mut dev) = self.raw.try_lock() {
+            dev.invoke();
+        }
     }
 }
 
@@ -84,7 +85,7 @@ impl VDeviceList {
 
     pub fn handle_mmio_read(&self, addr: GuestPhysAddr, width: AccessWidth) -> Option<usize> {
         let mmio = &self.mmio;
-        for (id, region) in unsafe { &(*mmio.inner.get()).regions } {
+        for (&id, region) in unsafe { &(*mmio.inner.get()).regions } {
             if addr >= region.gpa()
                 && addr.as_usize() + width.size() <= region.gpa().as_usize() + region.size()
             {
@@ -94,7 +95,7 @@ impl VDeviceList {
                     width,
                     id
                 );
-                self.get_device(*id).unwrap().run();
+                self.device_try_invoke(id);
 
                 let offset = addr.as_usize() - region.gpa().as_usize();
                 let access_ptr = unsafe { region.hva().as_ptr().add(offset) };
@@ -109,6 +110,45 @@ impl VDeviceList {
         }
         None
     }
+
+    pub fn handle_mmio_write(
+        &self,
+        addr: GuestPhysAddr,
+        width: AccessWidth,
+        data: usize,
+    ) -> Option<()> {
+        let mmio = &self.mmio;
+        for (&id, region) in unsafe { &(*mmio.inner.get()).regions } {
+            if addr >= region.gpa()
+                && addr.as_usize() + width.size() <= region.gpa().as_usize() + region.size()
+            {
+                debug!(
+                    "VDev MMIO write addr={:#x} width={:?} data={:#x} dev_id={}",
+                    addr.as_usize(),
+                    width,
+                    data,
+                    id
+                );
+
+                let offset = addr.as_usize() - region.gpa().as_usize();
+                let access_ptr = unsafe { region.hva().as_ptr().add(offset) };
+                match width {
+                    AccessWidth::Byte => unsafe { *(access_ptr as *mut u8) = data as u8 },
+                    AccessWidth::Word => unsafe { *(access_ptr as *mut u16) = data as u16 },
+                    AccessWidth::Dword => unsafe { *(access_ptr as *mut u32) = data as u32 },
+                    AccessWidth::Qword => unsafe { *(access_ptr as *mut u64) = data as u64 },
+                };
+
+                self.device_try_invoke(id);
+                return Some(());
+            }
+        }
+        None
+    }
+
+    fn device_try_invoke(&self, id: u32) {
+        self.get_device(*id).unwrap().try_invoke();
+    }
 }
 
 #[derive(Clone)]
@@ -140,7 +180,7 @@ impl VirtPlatformOp for VDevPlat {
         todo!()
     }
 
-    fn invoke_irq(&self, irq: IrqNum) {
+    fn send_irq(&self, irq: IrqNum) {
         todo!()
     }
 }