arch: add template support for non-x86_64 code

- Refactored crate to support addition of non-x86_64 architectures
- Labeled code accordingly
- Created a template for adding non-x86_64 code
- non-x86_64 code was moved outside x86_64 folder
- Adjusted vmm related code

Signed-off-by: Diana Popa <[email protected]>

Author: dianpopa

arch/src/lib.rs

@@ -18,7 +18,7 @@ pub enum Error {
     ZeroPagePastRamEnd,
     /// Error writing the zero page of guest memory.
     ZeroPageSetup,
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    #[cfg(target_arch = "x86_64")]
     /// X86_64 specific error triggered during system configuration.
     X86_64Setup(x86_64::Error),
 }
@@ -27,10 +27,20 @@ pub type Result<T> = result::Result<T, Error>;
 // 1MB.  We don't put anything above here except the kernel itself.
 pub const HIMEM_START: usize = 0x100000;
 
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub mod x86_64;
-impl From<x86_64::Error> for Error {
-    fn from(e: x86_64::Error) -> Error {
-        Error::X86_64Setup(e)
-    }
-}
+#[cfg(target_arch = "x86_64")]
+mod x86_64;
+
+#[cfg(not(target_arch = "x86_64"))]
+mod template;
+
+#[cfg(target_arch = "x86_64")]
+pub use x86_64::{
+    arch_memory_regions, configure_system, get_32bit_gap_start as get_reserved_mem_addr,
+    interrupts, regs, CMDLINE_START, COMMAND_LINE_SIZE, ZERO_PAGE_START,
+};
+
+#[cfg(not(target_arch = "x86_64"))]
+pub use template::{
+    arch_memory_regions, configure_system, get_reserved_mem_addr, CMDLINE_START, COMMAND_LINE_SIZE,
+    ZERO_PAGE_START,
+};

arch/src/template/mod.rs

@@ -0,0 +1,30 @@
+use memory_model::{GuestAddress, GuestMemory};
+
+/// Stub function that needs to be implemented every time new architecture support is added.
+pub fn arch_memory_regions(size: usize) -> Vec<(GuestAddress, usize)> {
+    Vec::with_capacity(size)
+}
+
+/// Stub function that needs to be implemented every time new architecture support is added.
+pub fn configure_system(
+    _guest_mem: &GuestMemory,
+    _cmdline_addr: GuestAddress,
+    _cmdline_size: usize,
+    _num_cpus: u8,
+) -> super::Result<()> {
+    Ok(())
+}
+
+/// Stub function that needs to be implemented every time new architecture support is added.
+pub fn get_reserved_mem_addr() -> usize {
+    0
+}
+
+/// Stub variable, should be defined every time new architecture support is added.
+pub const CMDLINE_START: usize = 0x0;
+
+/// Stub variable, should be defined every time new architecture support is added.
+pub const COMMAND_LINE_SIZE: usize = 0;
+
+/// Stub variable, should be defined every time new architecture support is added.
+pub const ZERO_PAGE_START: usize = 0;

arch/src/x86_64/mod.rs

@@ -23,14 +23,18 @@ pub enum Error {
     MpTableSetup(mptable::Error),
 }
 
-// Magic addresses used to lay out x86_64 VMs.
+impl From<Error> for super::Error {
+    fn from(e: Error) -> super::Error {
+        super::Error::X86_64Setup(e)
+    }
+}
 
-// Initial stack for the boot CPU.
-pub const BOOT_STACK_POINTER: usize = 0x8ff0;
+// Magic addresses used to lay out x86_64 VMs.
 
 // Kernel command line.
 pub const CMDLINE_START: usize = 0x20000;
-pub const CMDLINE_MAX_SIZE: usize = 0x10000;
+// As per arch/x86/include/asm/setup.h.
+pub const COMMAND_LINE_SIZE: usize = 2048;
 
 // The 'zero page', a.k.a linux kernel bootparams.
 pub const ZERO_PAGE_START: usize = 0x7000;

vmm/src/lib.rs

@@ -59,7 +59,6 @@ use std::time::Duration;
 use libc::{c_void, siginfo_t};
 use timerfd::{ClockId, SetTimeFlags, TimerFd, TimerState};
 
-use arch::x86_64;
 use device_manager::legacy::LegacyDeviceManager;
 use device_manager::mmio::MMIODeviceManager;
 use devices::virtio;
@@ -776,7 +775,7 @@ impl Vmm {
                 memory_model::GuestMemoryError::MemoryNotInitialized,
             ))?
             << 20;
-        let arch_mem_regions = x86_64::arch_memory_regions(mem_size);
+        let arch_mem_regions = arch::arch_memory_regions(mem_size);
         self.guest_memory =
             Some(GuestMemory::new(&arch_mem_regions).map_err(StartMicrovmError::GuestMemory)?);
         Ok(())
@@ -796,11 +795,11 @@ impl Vmm {
             .ok_or(StartMicrovmError::GuestMemory(
                 memory_model::GuestMemoryError::MemoryNotInitialized,
             ))?;
+
         // Instantiate the MMIO device manager.
-        // 'mmio_base' address has to be an address which is protected by the kernel, in this case
-        // the start of the x86 specific gap of memory (currently hardcoded at 768MiB).
+        // 'mmio_base' address has to be an address which is protected by the kernel.
         let mut device_manager =
-            MMIODeviceManager::new(guest_mem.clone(), x86_64::get_32bit_gap_start() as u64);
+            MMIODeviceManager::new(guest_mem.clone(), arch::get_reserved_mem_addr() as u64);
 
         self.attach_block_devices(&mut device_manager)?;
         self.attach_net_devices(&mut device_manager)?;
@@ -1052,7 +1051,7 @@ impl Vmm {
             .vm_config
             .vcpu_count
             .ok_or(StartMicrovmError::VcpusNotConfigured)?;
-        x86_64::configure_system(
+        arch::configure_system(
             vm_memory,
             kernel_config.cmdline_addr,
             cmdline_cstring.to_bytes().len() + 1,
@@ -1318,7 +1317,7 @@ impl Vmm {
         let kernel_file = File::open(kernel_image_path).map_err(|_| {
             VmmActionError::BootSource(ErrorKind::User, BootSourceConfigError::InvalidKernelPath)
         })?;
-        let mut cmdline = kernel_cmdline::Cmdline::new(x86_64::CMDLINE_MAX_SIZE);
+        let mut cmdline = kernel_cmdline::Cmdline::new(arch::COMMAND_LINE_SIZE);
         cmdline
             .insert_str(kernel_cmdline.unwrap_or(String::from(DEFAULT_KERNEL_CMDLINE)))
             .map_err(|_| {
@@ -1331,7 +1330,7 @@ impl Vmm {
         let kernel_config = KernelConfig {
             kernel_file,
             cmdline,
-            cmdline_addr: GuestAddress(x86_64::CMDLINE_START),
+            cmdline_addr: GuestAddress(arch::CMDLINE_START),
         };
         self.configure_kernel(kernel_config);
 
@@ -1783,12 +1782,12 @@ mod tests {
             let kernel_path = String::from(kernel_file_temp.path().to_path_buf().to_str().unwrap());
             let kernel_file = File::open(kernel_path).unwrap();
 
-            let mut cmdline = kernel_cmdline::Cmdline::new(x86_64::CMDLINE_MAX_SIZE);
+            let mut cmdline = kernel_cmdline::Cmdline::new(arch::COMMAND_LINE_SIZE);
             assert!(cmdline.insert_str(DEFAULT_KERNEL_CMDLINE).is_ok());
             let kernel_cfg = KernelConfig {
                 cmdline,
                 kernel_file,
-                cmdline_addr: GuestAddress(x86_64::CMDLINE_START),
+                cmdline_addr: GuestAddress(arch::CMDLINE_START),
             };
             self.configure_kernel(kernel_cfg);
         }
@@ -2356,7 +2355,7 @@ mod tests {
 
         let guest_mem = vmm.guest_memory.clone().unwrap();
         let mut device_manager =
-            MMIODeviceManager::new(guest_mem.clone(), x86_64::get_32bit_gap_start() as u64);
+            MMIODeviceManager::new(guest_mem.clone(), arch::get_reserved_mem_addr() as u64);
         assert!(vmm.attach_block_devices(&mut device_manager).is_ok());
         assert!(vmm.get_kernel_cmdline_str().contains("root=/dev/vda"));
 
@@ -2380,7 +2379,7 @@ mod tests {
 
         let guest_mem = vmm.guest_memory.clone().unwrap();
         let mut device_manager =
-            MMIODeviceManager::new(guest_mem.clone(), x86_64::get_32bit_gap_start() as u64);
+            MMIODeviceManager::new(guest_mem.clone(), arch::get_reserved_mem_addr() as u64);
         assert!(vmm.attach_block_devices(&mut device_manager).is_ok());
         assert!(
             vmm.get_kernel_cmdline_str()
@@ -2410,7 +2409,7 @@ mod tests {
 
         let guest_mem = vmm.guest_memory.clone().unwrap();
         let mut device_manager =
-            MMIODeviceManager::new(guest_mem.clone(), x86_64::get_32bit_gap_start() as u64);
+            MMIODeviceManager::new(guest_mem.clone(), arch::get_reserved_mem_addr() as u64);
         assert!(vmm.attach_block_devices(&mut device_manager).is_ok());
         // Test that kernel commandline does not contain either /dev/vda or PARTUUID.
         assert!(!vmm.get_kernel_cmdline_str().contains("root=PARTUUID="));
@@ -2448,7 +2447,7 @@ mod tests {
 
         let guest_mem = vmm.guest_memory.clone().unwrap();
         let mut device_manager =
-            MMIODeviceManager::new(guest_mem.clone(), x86_64::get_32bit_gap_start() as u64);
+            MMIODeviceManager::new(guest_mem.clone(), arch::get_reserved_mem_addr() as u64);
 
         // test create network interface
         let network_interface = NetworkInterfaceConfig {
@@ -2491,7 +2490,7 @@ mod tests {
         // Test valid kernel path and invalid cmdline.
         let kernel_file = NamedTempFile::new().expect("Failed to create temporary kernel file.");
         let kernel_path = String::from(kernel_file.path().to_path_buf().to_str().unwrap());
-        let invalid_cmdline = String::from_utf8(vec![b'X'; x86_64::CMDLINE_MAX_SIZE + 1]).unwrap();
+        let invalid_cmdline = String::from_utf8(vec![b'X'; arch::COMMAND_LINE_SIZE + 1]).unwrap();
         assert!(
             vmm.configure_boot_source(kernel_path.clone(), Some(invalid_cmdline))
                 .is_err()
@@ -2549,14 +2548,14 @@ mod tests {
 
         let guest_mem = vmm.guest_memory.clone().unwrap();
         let mut device_manager =
-            MMIODeviceManager::new(guest_mem.clone(), x86_64::get_32bit_gap_start() as u64);
+            MMIODeviceManager::new(guest_mem.clone(), arch::get_reserved_mem_addr() as u64);
 
         let dummy_box = Box::new(DummyDevice { dummy: 0 });
         // Use a dummy command line as it is not used in this test.
         let _addr = device_manager
             .register_device(
                 dummy_box,
-                &mut kernel_cmdline::Cmdline::new(x86_64::CMDLINE_MAX_SIZE),
+                &mut kernel_cmdline::Cmdline::new(arch::COMMAND_LINE_SIZE),
                 Some(scratch_id.clone()),
             ).unwrap();
 

vmm/src/vstate.rs

@@ -12,15 +12,15 @@ extern crate sys_util;
 use std::result;
 
 use super::KvmContext;
-use arch::x86_64;
 use cpuid::{c3_template, filter_cpuid, t2_template};
 use kvm::*;
 use memory_model::{GuestAddress, GuestMemory, GuestMemoryError};
 use sys_util::EventFd;
 use vmm_config::machine_config::{CpuFeaturesTemplate, VmConfig};
-use x86_64::{interrupts, regs};
 
 pub const KVM_TSS_ADDRESS: usize = 0xfffbd000;
+// Initial stack for the boot CPU.
+const BOOT_STACK_POINTER: usize = 0x8ff0;
 
 /// Errors associated with the wrappers over KVM ioctls.
 #[derive(Debug)]
@@ -46,17 +46,21 @@ pub enum Error {
     /// The number of configured slots is bigger than the maximum reported by KVM.
     NotEnoughMemorySlots,
     /// Cannot set the local interruption due to bad configuration.
-    LocalIntConfiguration(interrupts::Error),
+    LocalIntConfiguration(arch::interrupts::Error),
     /// Cannot set the memory regions.
     SetUserMemoryRegion(sys_util::Error),
+    #[cfg(target_arch = "x86_64")]
     /// Error configuring the MSR registers
-    MSRSConfiguration(regs::Error),
+    MSRSConfiguration(arch::regs::Error),
+    #[cfg(target_arch = "x86_64")]
     /// Error configuring the general purpose registers
-    REGSConfiguration(regs::Error),
+    REGSConfiguration(arch::regs::Error),
+    #[cfg(target_arch = "x86_64")]
     /// Error configuring the special registers
-    SREGSConfiguration(regs::Error),
+    SREGSConfiguration(arch::regs::Error),
+    #[cfg(target_arch = "x86_64")]
     /// Error configuring the floating point related registers
-    FPUConfiguration(regs::Error),
+    FPUConfiguration(arch::regs::Error),
     /// Cannot configure the IRQ.
     Irq(sys_util::Error),
 }
@@ -165,7 +169,8 @@ impl Vcpu {
         })
     }
 
-    /// /// Configures the vcpu and should be called once per vcpu from the vcpu's thread.
+    #[cfg(target_arch = "x86_64")]
+    /// Configures the vcpu and should be called once per vcpu from the vcpu's thread.
     ///
     /// # Arguments
     ///
@@ -202,20 +207,37 @@ impl Vcpu {
             .set_cpuid2(&self.cpuid)
             .map_err(Error::SetSupportedCpusFailed)?;
 
-        x86_64::regs::setup_msrs(&self.fd).map_err(Error::MSRSConfiguration)?;
+        arch::regs::setup_msrs(&self.fd).map_err(Error::MSRSConfiguration)?;
         // Safe to unwrap because this method is called after the VM is configured
         let vm_memory = vm
             .get_memory()
             .ok_or(Error::GuestMemory(GuestMemoryError::MemoryNotInitialized))?;
-        x86_64::regs::setup_regs(
+        arch::regs::setup_regs(
             &self.fd,
             kernel_start_addr.offset() as u64,
-            x86_64::BOOT_STACK_POINTER as u64,
-            x86_64::ZERO_PAGE_START as u64,
+            BOOT_STACK_POINTER as u64,
+            arch::ZERO_PAGE_START as u64,
         ).map_err(Error::REGSConfiguration)?;
-        x86_64::regs::setup_fpu(&self.fd).map_err(Error::FPUConfiguration)?;
-        x86_64::regs::setup_sregs(vm_memory, &self.fd).map_err(Error::SREGSConfiguration)?;
-        x86_64::interrupts::set_lint(&self.fd).map_err(Error::LocalIntConfiguration)?;
+        arch::regs::setup_fpu(&self.fd).map_err(Error::FPUConfiguration)?;
+        arch::regs::setup_sregs(vm_memory, &self.fd).map_err(Error::SREGSConfiguration)?;
+        arch::interrupts::set_lint(&self.fd).map_err(Error::LocalIntConfiguration)?;
+        Ok(())
+    }
+
+    #[cfg(not(target_arch = "x86_64"))]
+    /// Stub function that should be used whenever new architecture support is added.
+    ///
+    /// # Arguments
+    ///
+    /// * `machine_config` - Specifies necessary info used for the CPUID configuration.
+    /// * `kernel_start_addr` - Offset from `guest_mem` at which the kernel starts.
+    /// * `vm` - The virtual machine this vcpu will get attached to.
+    pub fn configure(
+        &mut self,
+        _machine_config: &VmConfig,
+        _kernel_start_addr: GuestAddress,
+        _vm: &Vm,
+    ) -> Result<()> {
         Ok(())
     }