arch: prepare crate for non-x86_64 code

- Refactored crate to support addition of non-x86_64 architectures
- Labeled code accordingly
- 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

@@ -14,23 +14,24 @@ use std::result;
 
 #[derive(Debug, PartialEq)]
 pub enum Error {
+    #[cfg(target_arch = "x86_64")]
+    /// X86_64 specific error triggered during system configuration.
+    X86_64Setup(x86_64::Error),
     /// The zero page extends past the end of guest_mem.
     ZeroPagePastRamEnd,
     /// Error writing the zero page of guest memory.
     ZeroPageSetup,
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    /// X86_64 specific error triggered during system configuration.
-    X86_64Setup(x86_64::Error),
 }
 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(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,
+};

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

@@ -61,7 +61,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;
@@ -814,7 +813,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(())
@@ -834,11 +833,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)?;
@@ -1093,7 +1092,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,
@@ -1384,7 +1383,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(|_| {
@@ -1397,7 +1396,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);
 
@@ -1856,12 +1855,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);
         }
@@ -2423,7 +2422,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"));
 
@@ -2447,7 +2446,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()
@@ -2475,7 +2474,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="));
@@ -2509,7 +2508,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 {
@@ -2551,7 +2550,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());
@@ -2605,14 +2604,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

@@ -13,17 +13,18 @@ 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 logger::{LogOption, LOGGER};
 use logger::{Metric, METRICS};
 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;
 const KVM_MEM_LOG_DIRTY_PAGES: u32 = 0x1;
 
 /// Errors associated with the wrappers over KVM ioctls.
@@ -48,17 +49,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),
 }
@@ -173,7 +178,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
     ///
@@ -217,21 +223,21 @@ 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(())
     }