Cube Sandbox

简体中文

English

简体中文

English

Appearance

VMM 核心：vm.rs 深度解析 ​

概述 ​

vm.rs 是 Cube Hypervisor 最核心的文件，实现了虚拟机的完整生命周期管理。本文深入分析其设计和实现。

核心结构 ​

Vm 结构体 ​

rust
// vmm/src/vm.rs (3467 行)
pub struct Vm {
    // 配置
    vm_config: VmConfig,
    
    // 管理器
    cpu_manager: CpuManager,
    memory_manager: MemoryManager,
    device_manager: DeviceManager,
    
    // 状态
    state: VmState,
    
    // 内核
    kernel: Option<File>,
    initramfs: Option<File>,
    cmdline: Cmdline,
    
    // 设备树
    device_tree: DeviceTree,
    
    // 信号
    signals: Signals,
    
    // 事件
    api_evt: EventFd,
}

VmState 枚举 ​

rust
// vmm/src/vm.rs
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
pub enum VmState {
    Created,
    Running,
    Shutdown,
    Paused,
    Snapshot,
}

生命周期管理 ​

创建 VM ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn new(
        vm_config: VmConfig,
        exit_evt: EventFd,
        reset_evt: EventFd,
    ) -> Result<Self> {
        // 1. 创建内存管理器
        let memory_manager = MemoryManager::new(
            &vm_config.memory,
            vm_config.platform.clone(),
        )?;
        
        // 2. 创建 CPU 管理器
        let cpu_manager = CpuManager::new(
            &vm_config.cpus,
            &memory_manager,
        )?;
        
        // 3. 创建设备管理器
        let device_manager = DeviceManager::new(
            &vm_config,
            &memory_manager,
            &cpu_manager,
        )?;
        
        // 4. 加载内核
        let kernel = vm_config.kernel.as_ref()
            .map(|k| File::open(&k.path))
            .transpose()?;
        
        // 5. 构建命令行
        let cmdline = Cmdline::new(
            vm_config.cmdline.clone().unwrap_or_default(),
        );
        
        Ok(Self {
            vm_config,
            cpu_manager,
            memory_manager,
            device_manager,
            state: VmState::Created,
            kernel,
            initramfs: None,
            cmdline,
            // ...
        })
    }
}

启动 VM ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn boot(&mut self) -> Result<()> {
        // 1. 配置内存布局
        self.memory_manager.setup_memory_layout()?;
        
        // 2. 加载内核到内存
        self.load_kernel()?;
        
        // 3. 加载 initramfs
        if let Some(initramfs) = &self.initramfs {
            self.load_initramfs(initramfs)?;
        }
        
        // 4. 配置命令行
        self.configure_cmdline()?;
        
        // 5. 创建中断控制器
        self.device_manager.create_interrupt_controllers()?;
        
        // 6. 创建设备
        self.device_manager.create_devices()?;
        
        // 7. 配置 ACPI 表
        self.configure_acpi_tables()?;
        
        // 8. 启动 vCPU
        self.cpu_manager.start_vcpus()?;
        
        // 9. 更新状态
        self.state = VmState::Running;
        
        Ok(())
    }
}

暂停 VM ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn pause(&mut self) -> Result<()> {
        // 1. 暂停所有 vCPU
        self.cpu_manager.pause_vcpus()?;
        
        // 2. 暂停所有设备
        self.device_manager.pause_devices()?;
        
        // 3. 更新状态
        self.state = VmState::Paused;
        
        Ok(())
    }
}

恢复 VM ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn resume(&mut self) -> Result<()> {
        // 1. 恢复所有设备
        self.device_manager.resume_devices()?;
        
        // 2. 恢复所有 vCPU
        self.cpu_manager.resume_vcpus()?;
        
        // 3. 更新状态
        self.state = VmState::Running;
        
        Ok(())
    }
}

关机 VM ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn shutdown(&mut self) -> Result<()> {
        // 1. 暂停所有 vCPU
        self.cpu_manager.pause_vcpus()?;
        
        // 2. 停止所有设备
        self.device_manager.stop_devices()?;
        
        // 3. 清理资源
        self.cleanup()?;
        
        // 4. 更新状态
        self.state = VmState::Shutdown;
        
        Ok(())
    }
}

内核加载 ​

x86_64 内核加载 ​

rust
// vmm/src/vm.rs
impl Vm {
    fn load_kernel(&mut self) -> Result<()> {
        let kernel_file = self.kernel.as_ref().ok_or(Error::NoKernel)?;
        
        // 检测内核格式
        let entry_point = match self.detect_kernel_format(kernel_file)? {
            KernelFormat::Elf => {
                // ELF 格式加载
                linux_loader::loader::elf::Elf::load(
                    &self.memory_manager.guest_memory(),
                    None,
                    kernel_file,
                    Some(arch::x86_64::layout::KERNEL_START),
                )?
            }
            KernelFormat::BzImage => {
                // BzImage 格式加载
                linux_loader::loader::bzimage::BzImage::load(
                    &self.memory_manager.guest_memory(),
                    None,
                    kernel_file,
                    Some(arch::x86_64::layout::KERNEL_START),
                )?
            }
            KernelFormat::Pvh => {
                // PVH 格式加载
                linux_loader::loader::elf::Elf::load(
                    &self.memory_manager.guest_memory(),
                    None,
                    kernel_file,
                    Some(arch::x86_64::layout::KERNEL_START),
                )?
            }
        };
        
        // 设置入口点
        self.entry_point = Some(entry_point);
        
        Ok(())
    }
}

aarch64 内核加载 ​

rust
// vmm/src/vm.rs
impl Vm {
    fn load_kernel_aarch64(&mut self) -> Result<()> {
        let kernel_file = self.kernel.as_ref().ok_or(Error::NoKernel)?;
        
        // PE 格式加载
        let entry_point = linux_loader::loader::pe::Pe::load(
            &self.memory_manager.guest_memory(),
            None,
            kernel_file,
            Some(arch::aarch64::layout::KERNEL_START),
        )?;
        
        self.entry_point = Some(entry_point);
        
        Ok(())
    }
}

设备配置 ​

ACPI 表配置 ​

rust
// vmm/src/vm.rs
impl Vm {
    fn configure_acpi_tables(&mut self) -> Result<()> {
        // 创建 ACPI 表
        let mut acpi_tables = AcpiTables::new();
        
        // 添加 RSDP
        acpi_tables.add_rsdp(Rsdp::new(*b"CUBE  "));
        
        // 添加 RSDT/XSDT
        acpi_tables.add_rsdt(self.create_rsdt()?);
        
        // 添加 MADT
        acpi_tables.add_madt(self.create_madt()?);
        
        // 添加 FADT
        acpi_tables.add_fadt(self.create_fadt()?);
        
        // 添加 MCFG
        acpi_tables.add_mcfg(self.create_mcfg()?);
        
        // 添加 SRAT
        if self.vm_config.platform.num_pci_segments > 1 {
            acpi_tables.add_srat(self.create_srat()?);
        }
        
        // 添加 SLIT
        if self.vm_config.platform.num_pci_segments > 1 {
            acpi_tables.add_slit(self.create_slit()?);
        }
        
        // 写入内存
        self.write_acpi_tables(acpi_tables)?;
        
        Ok(())
    }
}

FDT 配置 (aarch64) ​

rust
// vmm/src/vm.rs
impl Vm {
    fn configure_fdt(&mut self) -> Result<()> {
        let mut fdt = Fdt::new();
        
        // 添加 CPU 节点
        fdt.add_cpu_nodes(&self.cpu_manager)?;
        
        // 添加内存节点
        fdt.add_memory_nodes(&self.memory_manager)?;
        
        // 添加设备节点
        fdt.add_device_nodes(&self.device_manager)?;
        
        // 添加中断控制器节点
        fdt.add_interrupt_controller_nodes()?;
        
        // 写入内存
        self.write_fdt(fdt)?;
        
        Ok(())
    }
}

快照与恢复 ​

快照创建 ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn snapshot(&mut self) -> Result<VmSnapshot> {
        // 1. 暂停 VM
        self.pause()?;
        
        // 2. 创建快照
        let mut snapshot = VmSnapshot {
            config: self.vm_config.clone(),
            state: self.state.clone(),
            device_states: HashMap::new(),
            memory_snapshot: self.memory_manager.snapshot()?,
        };
        
        // 3. 保存设备状态
        snapshot.device_states = self.device_manager.snapshot()?;
        
        Ok(snapshot)
    }
}

快照恢复 ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn restore(
        vm_config: VmConfig,
        snapshot: VmSnapshot,
        exit_evt: EventFd,
        reset_evt: EventFd,
    ) -> Result<Self> {
        // 1. 创建 VM
        let mut vm = Self::new(vm_config, exit_evt, reset_evt)?;
        
        // 2. 恢复内存
        vm.memory_manager.restore(snapshot.memory_snapshot)?;
        
        // 3. 恢复设备
        vm.device_manager.restore(snapshot.device_states)?;
        
        // 4. 恢复状态
        vm.state = snapshot.state;
        
        Ok(vm)
    }
}

设备管理 ​

设备添加 ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn add_device(&mut self, device_cfg: DeviceConfig) -> Result<()> {
        // 1. 创建设备
        let device = self.device_manager.create_device(&device_cfg)?;
        
        // 2. 注册到总线
        self.device_manager.register_device(device)?;
        
        // 3. 更新设备树
        self.device_tree.add_device(&device_cfg);
        
        Ok(())
    }
    
    pub fn add_disk(&mut self, disk_cfg: DiskConfig) -> Result<()> {
        // 1. 创建块设备
        let disk = self.device_manager.create_disk(&disk_cfg)?;
        
        // 2. 注册到总线
        self.device_manager.register_device(disk)?;
        
        // 3. 更新设备树
        self.device_tree.add_disk(&disk_cfg);
        
        Ok(())
    }
    
    pub fn add_net(&mut self, net_cfg: NetConfig) -> Result<()> {
        // 1. 创建网络设备
        let net = self.device_manager.create_net(&net_cfg)?;
        
        // 2. 注册到总线
        self.device_manager.register_device(net)?;
        
        // 3. 更新设备树
        self.device_tree.add_net(&net_cfg);
        
        Ok(())
    }
}

事件处理 ​

事件监听 ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn handle_events(&mut self) -> Result<()> {
        // 1. 监听信号
        for signal in self.signals.pending() {
            match signal {
                SIGWINCH => {
                    // 处理终端大小变化
                    self.handle_sigwinch()?;
                }
                _ => {}
            }
        }
        
        // 2. 监听 API 事件
        if self.api_evt.read().is_ok() {
            self.handle_api_request()?;
        }
        
        // 3. 监听设备事件
        self.device_manager.handle_events()?;
        
        Ok(())
    }
}

错误处理 ​

错误类型 ​

rust
// vmm/src/vm.rs
#[derive(Debug, Error)]
pub enum Error {
    #[error("Cannot open kernel file: {0}")]
    KernelFile(#[source] io::Error),
    
    #[error("Cannot open initramfs file: {0}")]
    InitramfsFile(#[source] io::Error),
    
    #[error("Cannot load the kernel into memory: {0}")]
    KernelLoad(#[source] linux_loader::loader::Error),
    
    #[error("Cannot load the initramfs into memory: {0}")]
    InitramfsLoad(#[source] linux_loader::loader::Error),
    
    #[error("Cannot configure the cmdline: {0}")]
    Cmdline(#[source] linux_loader::cmdline::Error),
    
    #[error("Cannot create the device manager: {0}")]
    DeviceManager(#[source] DeviceManagerError),
    
    #[error("Cannot create the memory manager: {0}")]
    MemoryManager(#[source] MemoryManagerError),
    
    #[error("Cannot create the CPU manager: {0}")]
    CpuManager(#[source] cpu::Error),
    
    // ...
}

性能优化 ​

1. 延迟初始化 ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn new_lazy(vm_config: VmConfig) -> Result<Self> {
        // 只创建最小配置
        // 设备和 vCPU 在第一次启动时创建
        Ok(Self {
            vm_config,
            cpu_manager: None,
            memory_manager: None,
            device_manager: None,
            state: VmState::Created,
            // ...
        })
    }
}

2. 并行初始化 ​

rust
// vmm/src/vm.rs
impl Vm {
    pub fn boot_parallel(&mut self) -> Result<()> {
        // 并行初始化内存和设备
        let (memory_result, device_result) = rayon::join(
            || self.memory_manager.setup_memory_layout(),
            || self.device_manager.create_devices(),
        );
        
        memory_result?;
        device_result?;
        
        // 启动 vCPU
        self.cpu_manager.start_vcpus()?;
        
        Ok(())
    }
}

下一步 ​