vmm: Introduce RISC-V 64-bit architecture support

Integrate KvmAia, FDT and etc. into vmm to support vmm module to work on
RISC-V 64-bit platforms.

Signed-off-by: Bingxin Li <[email protected]>

Author: alicedreamed

src/vmm/src/builder.rs

@@ -27,6 +27,8 @@ use crate::resources::VmResources;
 use crate::vmm_config::external_kernel::{ExternalKernel, KernelFormat};
 #[cfg(feature = "net")]
 use crate::vmm_config::net::NetBuilder;
+#[cfg(all(target_os = "linux", target_arch = "riscv64"))]
+use devices::legacy::KvmAia;
 #[cfg(all(target_os = "linux", target_arch = "aarch64"))]
 use devices::legacy::KvmGicV3;
 #[cfg(target_arch = "x86_64")]
@@ -466,7 +468,7 @@ impl Display for StartMicrovmError {
 enum Payload {
     #[cfg(all(target_arch = "x86_64", not(feature = "tee")))]
     KernelMmap,
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     KernelCopy,
     ExternalKernel(ExternalKernel),
     #[cfg(test)]
@@ -489,7 +491,7 @@ fn choose_payload(vm_resources: &VmResources) -> Result<Payload, StartMicrovmErr
         #[cfg(all(target_os = "linux", target_arch = "x86_64", not(feature = "tee")))]
         return Ok(Payload::KernelMmap);
 
-        #[cfg(target_arch = "aarch64")]
+        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
         return Ok(Payload::KernelCopy);
     } else if let Some(external_kernel) = vm_resources.external_kernel() {
         Ok(Payload::ExternalKernel(external_kernel.clone()))
@@ -758,6 +760,29 @@ pub fn build_microvm(
         )?;
     }
 
+    #[cfg(all(target_arch = "riscv64", target_os = "linux"))]
+    {
+        vcpus = create_vcpus_riscv64(
+            &vm,
+            &vcpu_config,
+            &guest_memory,
+            payload_config.entry_addr,
+            &exit_evt,
+        )
+        .map_err(StartMicrovmError::Internal)?;
+
+        intc = Arc::new(Mutex::new(IrqChipDevice::new(Box::new(
+            KvmAia::new(vm.fd(), vm_resources.vm_config().vcpu_count.unwrap() as u32).unwrap(),
+        ))));
+
+        attach_legacy_devices(
+            &vm,
+            &mut mmio_device_manager,
+            &mut kernel_cmdline,
+            serial_device,
+        )?;
+    }
+
     // We use this atomic to record the exit code set by init/init.c in the VM.
     let exit_code = Arc::new(AtomicI32::new(i32::MAX));
 
@@ -902,7 +927,7 @@ fn load_external_kernel(
         // Raw images are treated as bundled kernels on x86_64
         #[cfg(target_arch = "x86_64")]
         KernelFormat::Raw => unreachable!(),
-        #[cfg(target_arch = "aarch64")]
+        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
         KernelFormat::Raw => {
             let data: Vec<u8> = std::fs::read(external_kernel.path.clone())
                 .map_err(StartMicrovmError::RawOpenKernel)?;
@@ -920,7 +945,7 @@ fn load_external_kernel(
                 .map_err(StartMicrovmError::ElfLoadKernel)?;
             load_result.kernel_load
         }
-        #[cfg(target_arch = "aarch64")]
+        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
         KernelFormat::PeGz => {
             let data: Vec<u8> = std::fs::read(external_kernel.path.clone())
                 .map_err(StartMicrovmError::PeGzOpenKernel)?;
@@ -1054,7 +1079,7 @@ fn load_payload(
     StartMicrovmError,
 > {
     match payload {
-        #[cfg(target_arch = "aarch64")]
+        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
         Payload::KernelCopy => {
             let (kernel_entry_addr, kernel_host_addr, kernel_guest_addr, kernel_size) =
                 if let Some(kernel_bundle) = &_vm_resources.kernel_bundle {
@@ -1224,7 +1249,7 @@ fn create_guest_memory(
         Payload::Empty => arch::arch_memory_regions(mem_size, None, 0, 0),
         Payload::Efi => unreachable!(),
     };
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     let (arch_mem_info, mut arch_mem_regions) = match payload {
         Payload::ExternalKernel(external_kernel) => {
             arch::arch_memory_regions(mem_size, external_kernel.initramfs_size)
@@ -1385,7 +1410,10 @@ fn attach_legacy_devices(
     Ok(())
 }
 
-#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
+#[cfg(all(
+    any(target_arch = "aarch64", target_arch = "riscv64"),
+    target_os = "linux"
+))]
 fn attach_legacy_devices(
     vm: &Vm,
     mmio_device_manager: &mut MMIODeviceManager,
@@ -1399,6 +1427,7 @@ fn attach_legacy_devices(
             .map_err(StartMicrovmError::Internal)?;
     }
 
+    #[cfg(all(target_arch = "aarch64", target_os = "linux"))]
     mmio_device_manager
         .register_mmio_rtc(vm.fd())
         .map_err(Error::RegisterMMIODevice)
@@ -1546,6 +1575,31 @@ fn create_vcpus_aarch64(
     Ok(vcpus)
 }
 
+#[cfg(all(target_arch = "riscv64", target_os = "linux"))]
+fn create_vcpus_riscv64(
+    vm: &Vm,
+    vcpu_config: &VcpuConfig,
+    guest_mem: &GuestMemoryMmap,
+    entry_addr: GuestAddress,
+    exit_evt: &EventFd,
+) -> super::Result<Vec<Vcpu>> {
+    let mut vcpus = Vec::with_capacity(vcpu_config.vcpu_count as usize);
+    for cpu_index in 0..vcpu_config.vcpu_count {
+        let mut vcpu = Vcpu::new_riscv64(
+            cpu_index,
+            vm.fd(),
+            exit_evt.try_clone().map_err(Error::EventFd)?,
+        )
+        .map_err(Error::Vcpu)?;
+
+        vcpu.configure_riscv64(vm.fd(), guest_mem, entry_addr)
+            .map_err(Error::Vcpu)?;
+
+        vcpus.push(vcpu);
+    }
+    Ok(vcpus)
+}
+
 /// Attaches an MmioTransport device to the device manager.
 fn attach_mmio_device(
     vmm: &mut Vmm,

src/vmm/src/device_manager/kvm/mmio.rs

@@ -9,7 +9,7 @@ use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use std::{fmt, io};
 
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 use devices::fdt::DeviceInfoForFDT;
 use devices::{BusDevice, DeviceType};
 use kernel::cmdline as kernel_cmdline;
@@ -76,7 +76,7 @@ pub struct MMIODeviceManager {
 impl MMIODeviceManager {
     /// Create a new DeviceManager handling mmio devices (virtio net, block).
     pub fn new(mmio_base: &mut u64, irq_interval: (u32, u32)) -> MMIODeviceManager {
-        if cfg!(target_arch = "aarch64") {
+        if cfg!(any(target_arch = "aarch64", target_arch = "riscv64")) {
             *mmio_base += MMIO_LEN;
         }
         MMIODeviceManager {
@@ -175,7 +175,7 @@ impl MMIODeviceManager {
             .map_err(Error::Cmdline)
     }
 
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     /// Register an early console at some MMIO address.
     pub fn register_mmio_serial(
         &mut self,
@@ -197,7 +197,10 @@ impl MMIODeviceManager {
         cmdline
             .insert(
                 "earlycon",
+                #[cfg(target_arch = "aarch64")]
                 &format!("pl011,mmio32,0x{:08x}", self.mmio_base),
+                #[cfg(target_arch = "riscv64")]
+                &format!("uart,mmio,0x{:08x}", self.mmio_base),
             )
             .map_err(Error::Cmdline)?;
 
@@ -250,7 +253,7 @@ impl MMIODeviceManager {
         Ok(())
     }
 
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     /// Gets the information of the devices registered up to some point in time.
     pub fn get_device_info(&self) -> &HashMap<(DeviceType, String), MMIODeviceInfo> {
         &self.id_to_dev_info
@@ -282,7 +285,7 @@ pub struct MMIODeviceInfo {
     _len: u64,
 }
 
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 impl DeviceInfoForFDT for MMIODeviceInfo {
     fn addr(&self) -> u64 {
         self.addr

src/vmm/src/lib.rs

@@ -55,7 +55,7 @@ use crate::vstate::{Vcpu, VcpuHandle, VcpuResponse, Vm};
 use arch::{ArchMemoryInfo, InitrdConfig};
 #[cfg(target_os = "macos")]
 use crossbeam_channel::Sender;
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 use devices::fdt;
 use devices::legacy::IrqChip;
 use devices::virtio::VmmExitObserver;
@@ -114,7 +114,7 @@ pub enum Error {
     RegisterMMIODevice(device_manager::mmio::Error),
     /// Write to the serial console failed.
     Serial(io::Error),
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     /// Cannot generate or write FDT
     SetupFDT(devices::fdt::Error),
     /// Cannot create Timer file descriptor.
@@ -155,7 +155,7 @@ impl Display for Error {
             LoadCommandline(e) => write!(f, "Cannot load command line: {e}"),
             RegisterMMIODevice(e) => write!(f, "Cannot add a device to the MMIO Bus. {e}"),
             Serial(e) => write!(f, "Error writing to the serial console: {e:?}"),
-            #[cfg(target_arch = "aarch64")]
+            #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
             SetupFDT(e) => write!(f, "Error generating or writing FDT: {e:?}"),
             TimerFd(e) => write!(f, "Error creating timer fd: {e}"),
             Vcpu(e) => write!(f, "Vcpu error: {e}"),
@@ -319,6 +319,24 @@ impl Vmm {
             arch::aarch64::configure_system(&self.guest_memory, _smbios_oem_strings)
                 .map_err(Error::ConfigureSystem)?;
         }
+
+        #[cfg(target_arch = "riscv64")]
+        {
+            fdt::create_fdt(
+                &self.guest_memory,
+                &self.arch_memory_info,
+                vcpus.len() as u32,
+                self.kernel_cmdline.as_str(),
+                self.mmio_device_manager.get_device_info(),
+                _intc,
+                initrd,
+            )
+            .map_err(Error::SetupFDT)?;
+
+            arch::riscv64::configure_system(&self.guest_memory, _smbios_oem_strings)
+                .map_err(Error::ConfigureSystem)?;
+        }
+
         Ok(())
     }
 

src/vmm/src/linux/vstate.rs

@@ -41,12 +41,13 @@ use kvm_bindings::{
     KVM_MAX_CPUID_ENTRIES,
 };
 use kvm_bindings::{
-    kvm_create_guest_memfd, kvm_memory_attributes, kvm_userspace_memory_region,
-    kvm_userspace_memory_region2, KVM_API_VERSION, KVM_MEMORY_ATTRIBUTE_PRIVATE,
-    KVM_MEM_GUEST_MEMFD, KVM_SYSTEM_EVENT_RESET, KVM_SYSTEM_EVENT_SHUTDOWN,
+    kvm_create_guest_memfd, kvm_userspace_memory_region, kvm_userspace_memory_region2,
+    KVM_API_VERSION, KVM_MEM_GUEST_MEMFD, KVM_SYSTEM_EVENT_RESET, KVM_SYSTEM_EVENT_SHUTDOWN,
 };
 #[cfg(feature = "tee")]
 use kvm_bindings::{kvm_enable_cap, KVM_CAP_EXIT_HYPERCALL, KVM_MEMORY_EXIT_FLAG_PRIVATE};
+#[cfg(not(target_arch = "riscv64"))]
+use kvm_bindings::{kvm_memory_attributes, KVM_MEMORY_ATTRIBUTE_PRIVATE};
 use kvm_ioctls::{Cap::*, *};
 use utils::eventfd::EventFd;
 use utils::signal::{register_signal_handler, sigrtmin, Killable};
@@ -108,6 +109,9 @@ pub enum Error {
     #[cfg(target_arch = "aarch64")]
     /// Error configuring the general purpose aarch64 registers.
     REGSConfiguration(arch::aarch64::regs::Error),
+    #[cfg(target_arch = "riscv64")]
+    /// Error configuring the general purpose riscv64 registers.
+    REGSConfiguration(arch::riscv64::regs::Error),
     #[cfg(target_arch = "x86_64")]
     /// Error configuring the general purpose registers
     REGSConfiguration(arch::x86_64::regs::Error),
@@ -300,6 +304,11 @@ impl Display for Error {
                 f,
                 "Error configuring the general purpose aarch64 registers: {e:?}"
             ),
+            #[cfg(target_arch = "riscv64")]
+            REGSConfiguration(e) => write!(
+                f,
+                "Error configuring the general purpose riscv64 registers: {e:?}"
+            ),
             #[cfg(target_arch = "x86_64")]
             REGSConfiguration(e) => {
                 write!(f, "Error configuring the general purpose registers: {e:?}")
@@ -415,6 +424,9 @@ impl KvmContext {
         #[cfg(target_arch = "aarch64")]
         let capabilities = [Irqchip, Ioeventfd, Irqfd, UserMemory, ArmPsci02];
 
+        #[cfg(target_arch = "riscv64")]
+        let capabilities = [Irqchip, Ioeventfd, Irqfd, UserMemory];
+
         // Check that all desired capabilities are supported.
         match capabilities
             .iter()
@@ -624,13 +636,15 @@ impl Vm {
                     .map_err(Error::SetUserMemoryRegion)?;
             };
 
+            #[cfg(not(target_arch = "riscv64"))]
             let attr = kvm_memory_attributes {
                 address: start,
                 size: region.len(),
                 attributes: KVM_MEMORY_ATTRIBUTE_PRIVATE as u64,
                 flags: 0,
             };
 
+            #[cfg(not(target_arch = "riscv64"))]
             self.fd
                 .set_memory_attributes(attr)
                 .map_err(Error::SetMemoryAttributes)?;
@@ -950,6 +964,32 @@ impl Vcpu {
         })
     }
 
+    /// Constructs a new VCPU for `vm`.
+    ///
+    /// # Arguments
+    ///
+    /// * `id` - Represents the CPU number between [0, max vcpus).
+    /// * `vm_fd` - The kvm `VmFd` for the virtual machine this vcpu will get attached to.
+    /// * `exit_evt` - An `EventFd` that will be written into when this vcpu exits.
+    /// * `create_ts` - A timestamp used by the vcpu to calculate its lifetime.
+    #[cfg(target_arch = "riscv64")]
+    pub fn new_riscv64(id: u8, vm_fd: &VmFd, exit_evt: EventFd) -> Result<Self> {
+        let kvm_vcpu = vm_fd.create_vcpu(id as u64).map_err(Error::VcpuFd)?;
+        let (event_sender, event_receiver) = unbounded();
+        let (response_sender, response_receiver) = unbounded();
+
+        Ok(Vcpu {
+            fd: kvm_vcpu,
+            id,
+            mmio_bus: None,
+            exit_evt,
+            event_receiver,
+            event_sender: Some(event_sender),
+            response_receiver: Some(response_receiver),
+            response_sender,
+        })
+    }
+
     /// Returns the cpu index as seen by the guest OS.
     pub fn cpu_index(&self) -> u8 {
         self.id
@@ -1050,6 +1090,25 @@ impl Vcpu {
         Ok(())
     }
 
+    #[cfg(target_arch = "riscv64")]
+    /// Configures an riscv64 specific vcpu.
+    ///
+    /// # Arguments
+    ///
+    /// * `vm_fd` - The kvm `VmFd` for this microvm.
+    /// * `guest_mem` - The guest memory used by this microvm.
+    /// * `kernel_load_addr` - Offset from `guest_mem` at which the kernel is loaded.
+    pub fn configure_riscv64(
+        &mut self,
+        _vm_fd: &VmFd,
+        guest_mem: &GuestMemoryMmap,
+        kernel_load_addr: GuestAddress,
+    ) -> Result<()> {
+        arch::riscv64::regs::setup_regs(&self.fd, self.id, kernel_load_addr.raw_value(), guest_mem)
+            .map_err(Error::REGSConfiguration)?;
+        Ok(())
+    }
+
     /// Moves the vcpu to its own thread and constructs a VcpuHandle.
     /// The handle can be used to control the remote vcpu.
     pub fn start_threaded(mut self) -> Result<VcpuHandle> {