Method init_sev_snp

vmm/src/vm.rs:996–1066

(
        vm: &Arc<dyn hypervisor::Vm>,
        memory_manager: &Arc<Mutex<MemoryManager>>,
        cpu_manager: &Arc<Mutex<cpu::CpuManager>>,
        device_manager: &Arc<Mutex<DeviceManager>>,
     

    #[cfg(feature = "sev_snp")]
    #[allow(clippy::too_many_arguments)]
    fn init_sev_snp(
        vm: &Arc<dyn hypervisor::Vm>,
        memory_manager: &Arc<Mutex<MemoryManager>>,
        cpu_manager: &Arc<Mutex<cpu::CpuManager>>,
        device_manager: &Arc<Mutex<DeviceManager>>,
        config: &Arc<Mutex<VmConfig>>,
        console_info: Option<&ConsoleInfo>,
        console_resize_pipe: Option<&Arc<File>>,
        original_termios: &Arc<Mutex<Option<termios>>>,
        snapshot: Option<&Snapshot>,
        #[cfg(feature = "igvm")] igvm_file: Option<IgvmFile>,
    ) -> Result<Option<thread::JoinHandle<Result<EntryPoint>>>> {
        // Create boot vCPUs before SEV-SNP initialization
        cpu_manager
            .lock()
            .unwrap()
            .create_boot_vcpus(snapshot_from_id(snapshot, CPU_MANAGER_SNAPSHOT_ID))
            .map_err(Error::CpuManager)?;

        // Extract guest policy from IGVM if available, otherwise use default.
        #[cfg(feature = "igvm")]
        let guest_policy = igvm_file
            .as_ref()
            .and_then(igvm_loader::extract_guest_policy)
            .unwrap_or_else(Self::get_default_sev_snp_guest_policy);
        #[cfg(not(feature = "igvm"))]
        let guest_policy = Self::get_default_sev_snp_guest_policy();

        vm.sev_snp_init(guest_policy)
            .map_err(Error::InitializeSevSnpVm)?;

        // Load payload for SEV-SNP (IGVM parser needs cpu_manager for cpuid)
        let load_payload_handle = if snapshot.is_none() {
            Self::load_payload_async(
                memory_manager,
                config,
                #[cfg(feature = "igvm")]
                cpu_manager,
                #[cfg(feature = "igvm")]
                igvm_file,
            )?
        } else {
            None
        };

        // Create interrupt controller and devices for MSHV
        let ic = device_manager
            .lock()
            .unwrap()
            .create_interrupt_controller()
            .map_err(Error::DeviceManager)?;

        #[cfg(target_arch = "aarch64")]
        vm.init().map_err(Error::InitializeVm)?;

        device_manager
            .lock()
            .unwrap()