refactor: move load_kernel into arch module

Move `load_kernel` arch specific functions into arch module per
architecture. Make the function to accept the kernel `File`
instead of the `BootConfig`.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

src/vmm/src/arch/aarch64/mod.rs

@@ -20,11 +20,14 @@ use std::cmp::min;
 use std::collections::HashMap;
 use std::ffi::CString;
 use std::fmt::Debug;
+use std::fs::File;
 
+use linux_loader::loader::KernelLoader;
+use linux_loader::loader::pe::PE as Loader;
 use vm_memory::GuestMemoryError;
 
 use self::gic::GICDevice;
-use crate::arch::DeviceType;
+use crate::arch::{BootProtocol, DeviceType, EntryPoint};
 use crate::device_manager::mmio::MMIODeviceInfo;
 use crate::devices::acpi::vmgenid::VmGenId;
 use crate::initrd::InitrdConfig;
@@ -37,6 +40,10 @@ pub enum ConfigurationError {
     SetupFDT(#[from] fdt::FdtError),
     /// Failed to write to guest memory.
     MemoryError(GuestMemoryError),
+    /// Cannot copy kernel file fd
+    KernelFile,
+    /// Cannot load kernel due to invalid memory configuration or invalid kernel image: {0}
+    KernelLoader(#[from] linux_loader::loader::Error),
 }
 
 /// The start of the memory area reserved for MMIO devices.
@@ -123,6 +130,30 @@ fn get_fdt_addr(mem: &GuestMemoryMmap) -> u64 {
     layout::DRAM_MEM_START
 }
 
+/// Load linux kernel into guest memory.
+pub fn load_kernel(
+    kernel: &File,
+    guest_memory: &GuestMemoryMmap,
+) -> Result<EntryPoint, ConfigurationError> {
+    // Need to clone the File because reading from it
+    // mutates it.
+    let mut kernel_file = kernel
+        .try_clone()
+        .map_err(|_| ConfigurationError::KernelFile)?;
+
+    let entry_addr = Loader::load(
+        guest_memory,
+        Some(GuestAddress(get_kernel_start())),
+        &mut kernel_file,
+        None,
+    )?;
+
+    Ok(EntryPoint {
+        entry_addr: entry_addr.kernel_load,
+        protocol: BootProtocol::LinuxBoot,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/vmm/src/arch/mod.rs

@@ -22,7 +22,7 @@ pub use aarch64::vm::{ArchVm, ArchVmError, VmState};
 pub use aarch64::{
     ConfigurationError, MMIO_MEM_SIZE, MMIO_MEM_START, arch_memory_regions, configure_system,
     get_kernel_start, initrd_load_addr, layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE,
-    layout::IRQ_MAX, layout::SYSTEM_MEM_SIZE, layout::SYSTEM_MEM_START,
+    layout::IRQ_MAX, layout::SYSTEM_MEM_SIZE, layout::SYSTEM_MEM_START, load_kernel,
 };
 
 /// Module for x86_64 related functionality.
@@ -40,7 +40,7 @@ pub use x86_64::{
     ConfigurationError, MMIO_MEM_SIZE, MMIO_MEM_START, arch_memory_regions, configure_system,
     get_kernel_start, initrd_load_addr, layout::APIC_ADDR, layout::CMDLINE_MAX_SIZE,
     layout::IOAPIC_ADDR, layout::IRQ_BASE, layout::IRQ_MAX, layout::SYSTEM_MEM_SIZE,
-    layout::SYSTEM_MEM_START,
+    layout::SYSTEM_MEM_START, load_kernel,
 };
 
 /// Types of devices that can get attached to this platform.

src/vmm/src/arch/x86_64/mod.rs

@@ -31,14 +31,20 @@ pub mod xstate;
 #[allow(missing_docs)]
 pub mod generated;
 
+use std::fs::File;
+
 use linux_loader::configurator::linux::LinuxBootConfigurator;
 use linux_loader::configurator::pvh::PvhBootConfigurator;
 use linux_loader::configurator::{BootConfigurator, BootParams};
 use linux_loader::loader::bootparam::boot_params;
+use linux_loader::loader::elf::Elf as Loader;
 use linux_loader::loader::elf::start_info::{
     hvm_memmap_table_entry, hvm_modlist_entry, hvm_start_info,
 };
+use linux_loader::loader::{KernelLoader, PvhBootCapability};
+use log::debug;
 
+use super::EntryPoint;
 use crate::arch::{BootProtocol, SYSTEM_MEM_SIZE, SYSTEM_MEM_START};
 use crate::device_manager::resources::ResourceAllocator;
 use crate::initrd::InitrdConfig;
@@ -70,6 +76,10 @@ pub enum ConfigurationError {
     MemmapTableSetup,
     /// Error writing hvm_start_info to guest memory.
     StartInfoSetup,
+    /// Cannot copy kernel file fd
+    KernelFile,
+    /// Cannot load kernel due to invalid memory configuration or invalid kernel image: {0}
+    KernelLoader(#[from] linux_loader::loader::Error),
 }
 
 /// First address that cannot be addressed using 32 bit anymore.
@@ -354,6 +364,40 @@ fn add_e820_entry(
     Ok(())
 }
 
+/// Load linux kernel into guest memory.
+pub fn load_kernel(
+    kernel: &File,
+    guest_memory: &GuestMemoryMmap,
+) -> Result<EntryPoint, ConfigurationError> {
+    // Need to clone the File because reading from it
+    // mutates it.
+    let mut kernel_file = kernel
+        .try_clone()
+        .map_err(|_| ConfigurationError::KernelFile)?;
+
+    let entry_addr = Loader::load(
+        guest_memory,
+        None,
+        &mut kernel_file,
+        Some(GuestAddress(get_kernel_start())),
+    )?;
+
+    let mut entry_point_addr: GuestAddress = entry_addr.kernel_load;
+    let mut boot_prot: BootProtocol = BootProtocol::LinuxBoot;
+    if let PvhBootCapability::PvhEntryPresent(pvh_entry_addr) = entry_addr.pvh_boot_cap {
+        // Use the PVH kernel entry point to boot the guest
+        entry_point_addr = pvh_entry_addr;
+        boot_prot = BootProtocol::PvhBoot;
+    }
+
+    debug!("Kernel loaded using {boot_prot}");
+
+    Ok(EntryPoint {
+        entry_addr: entry_point_addr,
+        protocol: boot_prot,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use linux_loader::loader::bootparam::boot_e820_entry;

src/vmm/src/builder.rs

@@ -14,13 +14,6 @@ use std::sync::{Arc, Mutex};
 use event_manager::{MutEventSubscriber, SubscriberOps};
 use libc::EFD_NONBLOCK;
 use linux_loader::cmdline::Cmdline as LoaderKernelCmdline;
-use linux_loader::loader::KernelLoader;
-#[cfg(target_arch = "x86_64")]
-use linux_loader::loader::elf::Elf as Loader;
-#[cfg(target_arch = "x86_64")]
-use linux_loader::loader::elf::PvhBootCapability;
-#[cfg(target_arch = "aarch64")]
-use linux_loader::loader::pe::PE as Loader;
 use userfaultfd::Uffd;
 use utils::time::TimestampUs;
 #[cfg(target_arch = "aarch64")]
@@ -30,7 +23,7 @@ use vmm_sys_util::eventfd::EventFd;
 
 #[cfg(target_arch = "x86_64")]
 use crate::acpi;
-use crate::arch::{BootProtocol, EntryPoint};
+use crate::arch::{ConfigurationError, EntryPoint, load_kernel};
 #[cfg(target_arch = "aarch64")]
 use crate::construct_kvm_mpidrs;
 use crate::cpu_config::templates::{
@@ -66,11 +59,10 @@ use crate::persist::{MicrovmState, MicrovmStateError};
 use crate::resources::VmResources;
 use crate::seccomp::BpfThreadMap;
 use crate::snapshot::Persist;
-use crate::vmm_config::boot_source::BootConfig;
 use crate::vmm_config::instance_info::InstanceInfo;
 use crate::vmm_config::machine_config::{MachineConfig, MachineConfigError};
 use crate::vstate::kvm::Kvm;
-use crate::vstate::memory::{GuestAddress, GuestMemoryMmap};
+use crate::vstate::memory::GuestMemoryMmap;
 use crate::vstate::vcpu::{Vcpu, VcpuConfig, VcpuError};
 use crate::vstate::vm::Vm;
 use crate::{EventManager, Vmm, VmmError, device_manager};
@@ -83,7 +75,7 @@ pub enum StartMicrovmError {
     /// Unable to attach the VMGenID device: {0}
     AttachVmgenidDevice(kvm_ioctls::Error),
     /// System configuration error: {0}
-    ConfigureSystem(crate::arch::ConfigurationError),
+    ConfigureSystem(#[from] ConfigurationError),
     /// Failed to create guest config: {0}
     CreateGuestConfig(#[from] GuestConfigError),
     /// Cannot create network device: {0}
@@ -105,8 +97,6 @@ pub enum StartMicrovmError {
     GetCpuTemplate(#[from] GetCpuTemplateError),
     /// Invalid kernel command line: {0}
     KernelCmdline(String),
-    /// Cannot load kernel due to invalid memory configuration or invalid kernel image: {0}
-    KernelLoader(linux_loader::loader::Error),
     /// Cannot load command line string: {0}
     LoadCommandline(linux_loader::loader::Error),
     /// Cannot start microvm without kernel configuration.
@@ -236,7 +226,7 @@ pub fn build_microvm_for_boot(
         .allocate_guest_memory()
         .map_err(StartMicrovmError::GuestMemory)?;
 
-    let entry_point = load_kernel(boot_config, &guest_memory)?;
+    let entry_point = load_kernel(&boot_config.kernel_file, &guest_memory)?;
     let initrd = InitrdConfig::from_config(boot_config, &guest_memory)?;
     // Clone the command-line so that a failed boot doesn't pollute the original.
     #[allow(unused_mut)]
@@ -541,64 +531,6 @@ pub fn build_microvm_from_snapshot(
     Ok(vmm)
 }
 
-#[cfg(target_arch = "x86_64")]
-fn load_kernel(
-    boot_config: &BootConfig,
-    guest_memory: &GuestMemoryMmap,
-) -> Result<EntryPoint, StartMicrovmError> {
-    let mut kernel_file = boot_config
-        .kernel_file
-        .try_clone()
-        .map_err(VmmError::KernelFile)?;
-
-    let entry_addr = Loader::load::<std::fs::File, GuestMemoryMmap>(
-        guest_memory,
-        None,
-        &mut kernel_file,
-        Some(GuestAddress(crate::arch::get_kernel_start())),
-    )
-    .map_err(StartMicrovmError::KernelLoader)?;
-
-    let mut entry_point_addr: GuestAddress = entry_addr.kernel_load;
-    let mut boot_prot: BootProtocol = BootProtocol::LinuxBoot;
-    if let PvhBootCapability::PvhEntryPresent(pvh_entry_addr) = entry_addr.pvh_boot_cap {
-        // Use the PVH kernel entry point to boot the guest
-        entry_point_addr = pvh_entry_addr;
-        boot_prot = BootProtocol::PvhBoot;
-    }
-
-    debug!("Kernel loaded using {boot_prot}");
-
-    Ok(EntryPoint {
-        entry_addr: entry_point_addr,
-        protocol: boot_prot,
-    })
-}
-
-#[cfg(target_arch = "aarch64")]
-fn load_kernel(
-    boot_config: &BootConfig,
-    guest_memory: &GuestMemoryMmap,
-) -> Result<EntryPoint, StartMicrovmError> {
-    let mut kernel_file = boot_config
-        .kernel_file
-        .try_clone()
-        .map_err(VmmError::KernelFile)?;
-
-    let entry_addr = Loader::load::<std::fs::File, GuestMemoryMmap>(
-        guest_memory,
-        Some(GuestAddress(crate::arch::get_kernel_start())),
-        &mut kernel_file,
-        None,
-    )
-    .map_err(StartMicrovmError::KernelLoader)?;
-
-    Ok(EntryPoint {
-        entry_addr: entry_addr.kernel_load,
-        protocol: BootProtocol::LinuxBoot,
-    })
-}
-
 /// Sets up the serial device.
 pub fn setup_serial_device(
     event_manager: &mut EventManager,
@@ -725,7 +657,7 @@ pub fn configure_system_for_boot(
 
         linux_loader::loader::load_cmdline::<crate::vstate::memory::GuestMemoryMmap>(
             vmm.guest_memory(),
-            GuestAddress(crate::arch::x86_64::layout::CMDLINE_START),
+            crate::vstate::memory::GuestAddress(crate::arch::x86_64::layout::CMDLINE_START),
             &boot_cmdline,
         )
         .map_err(LoadCommandline)?;
@@ -737,8 +669,7 @@ pub fn configure_system_for_boot(
             initrd,
             vcpu_config.vcpu_count,
             entry_point.protocol,
-        )
-        .map_err(ConfigureSystem)?;
+        )?;
 
         // Create ACPI tables and write them in guest memory
         // For the time being we only support ACPI in x86_64
@@ -777,8 +708,7 @@ pub fn configure_system_for_boot(
             vmm.vm.get_irqchip(),
             &vmm.acpi_device_manager.vmgenid,
             initrd,
-        )
-        .map_err(ConfigureSystem)?;
+        )?;
     }
     Ok(())
 }

src/vmm/src/lib.rs

@@ -221,8 +221,6 @@ pub enum VmmError {
     EventFd(io::Error),
     /// I8042 error: {0}
     I8042Error(devices::legacy::I8042DeviceError),
-    /// Cannot access kernel file: {0}
-    KernelFile(io::Error),
     #[cfg(target_arch = "x86_64")]
     /// Cannot add devices to the legacy I/O Bus. {0}
     LegacyIOBus(device_manager::legacy::LegacyDeviceError),

src/vmm/src/vstate/vcpu.rs

@@ -771,7 +771,6 @@ pub(crate) mod tests {
     use super::*;
     use crate::RECV_TIMEOUT_SEC;
     use crate::arch::{BootProtocol, EntryPoint};
-    use crate::builder::StartMicrovmError;
     use crate::devices::BusDevice;
     use crate::devices::bus::DummyDevice;
     use crate::seccomp::get_empty_filters;
@@ -952,12 +951,11 @@ pub(crate) mod tests {
             &mut kernel_file,
             Some(GuestAddress(crate::arch::get_kernel_start())),
         )
-        .map_err(StartMicrovmError::KernelLoader);
+        .unwrap();
         #[cfg(target_arch = "aarch64")]
         let entry_addr =
-            linux_loader::loader::pe::PE::load(vm_memory, None, &mut kernel_file, None)
-                .map_err(StartMicrovmError::KernelLoader);
-        entry_addr.unwrap().kernel_load
+            linux_loader::loader::pe::PE::load(vm_memory, None, &mut kernel_file, None).unwrap();
+        entry_addr.kernel_load
     }
 
     fn vcpu_configured_for_boot() -> (VcpuHandle, EventFd, GuestMemoryMmap) {