loader: Introduce riscv64 architecture support

RISC-V uses the same image format ARM64 did, reuse the PE image loader
and add support for loading a `riscv64` PE image.

Signed-off-by: Ruoqing He <heruoqing@iscas.ac.cn>

Author: RuoqingHe

src/lib.rs

@@ -22,6 +22,7 @@
 //!
 //! - `x86_64`
 //! - `ARM64`
+//! - `RISC-V64`
 //!
 //! # Example - load an ELF kernel and configure boot params with the PVH protocol
 //!
@@ -91,7 +92,7 @@
 //!     PvhBootConfigurator::write_bootparams::<GuestMemoryMmap>(&boot_params, &guest_mem).unwrap();
 //! }
 //!
-//! # #[cfg(target_arch = "aarch64")]
+//! # #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 //! # fn main() {}
 //! ```
 //!

src/loader/mod.rs

@@ -31,9 +31,9 @@ pub use crate::loader_gen::bootparam;
 
 pub use crate::cmdline::Cmdline;
 
-#[cfg(all(target_arch = "aarch64", feature = "pe"))]
+#[cfg(all(any(target_arch = "aarch64", target_arch = "riscv64"), feature = "pe"))]
 pub mod pe;
-#[cfg(all(target_arch = "aarch64", feature = "pe"))]
+#[cfg(all(any(target_arch = "aarch64", target_arch = "riscv64"), feature = "pe"))]
 pub use pe::*;
 
 #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "elf"))]
@@ -58,7 +58,7 @@ pub enum Error {
     Elf(elf::Error),
 
     /// Failed to load PE image.
-    #[cfg(all(feature = "pe", target_arch = "aarch64"))]
+    #[cfg(all(feature = "pe", any(target_arch = "aarch64", target_arch = "riscv64")))]
     Pe(pe::Error),
 
     /// Invalid command line.
@@ -86,7 +86,7 @@ impl fmt::Display for Error {
             Error::Bzimage(ref e) => write!(f, "failed to load bzImage kernel image: {e}"),
             #[cfg(all(feature = "elf", any(target_arch = "x86", target_arch = "x86_64")))]
             Error::Elf(ref e) => write!(f, "failed to load ELF kernel image: {e}"),
-            #[cfg(all(feature = "pe", target_arch = "aarch64"))]
+            #[cfg(all(feature = "pe", any(target_arch = "aarch64", target_arch = "riscv64")))]
             Error::Pe(ref e) => write!(f, "failed to load PE kernel image: {e}"),
 
             Error::InvalidCommandLine => write!(f, "invalid command line provided"),
@@ -105,7 +105,7 @@ impl std::error::Error for Error {
             Error::Bzimage(ref e) => Some(e),
             #[cfg(all(feature = "elf", any(target_arch = "x86", target_arch = "x86_64")))]
             Error::Elf(ref e) => Some(e),
-            #[cfg(all(feature = "pe", target_arch = "aarch64"))]
+            #[cfg(all(feature = "pe", any(target_arch = "aarch64", target_arch = "riscv64")))]
             Error::Pe(ref e) => Some(e),
 
             Error::InvalidCommandLine => None,
@@ -131,7 +131,7 @@ impl From<bzimage::Error> for Error {
     }
 }
 
-#[cfg(all(feature = "pe", target_arch = "aarch64"))]
+#[cfg(all(feature = "pe", any(target_arch = "aarch64", target_arch = "riscv64")))]
 impl From<pe::Error> for Error {
     fn from(err: pe::Error) -> Self {
         Error::Pe(err)

src/loader/pe/mod.rs

@@ -1,3 +1,4 @@
+// Copyright 2024 © Institute of Software, CAS. All rights reserved.
 // Copyright © 2020, Oracle and/or its affiliates.
 // Copyright (c) 2019 Intel Corporation. All rights reserved.
 // Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
@@ -17,13 +18,9 @@ use vm_memory::{Address, ByteValued, GuestAddress, GuestMemory, GuestUsize, Read
 
 use crate::loader::{Error as KernelLoaderError, KernelLoader, KernelLoaderResult, Result};
 
-/// ARM64 Image (PE) format support
+/// ARM64 and RISC-V64 Image (PE) format support
 pub struct PE;
 
-// SAFETY: The layout of the structure is fixed and can be initialized by
-// reading its content from byte array.
-unsafe impl ByteValued for arm64_image_header {}
-
 #[derive(Debug, PartialEq, Eq)]
 /// PE kernel loader errors.
 pub enum Error {
@@ -73,6 +70,7 @@ impl fmt::Display for Error {
 
 impl std::error::Error for Error {}
 
+#[cfg(target_arch = "aarch64")]
 #[repr(C)]
 #[derive(Debug, Copy, Clone, Default)]
 // See kernel doc Documentation/arm64/booting.txt for more information.
@@ -90,6 +88,35 @@ struct arm64_image_header {
     res5: u32,
 }
 
+#[cfg(target_arch = "aarch64")]
+// SAFETY: The layout of the structure is fixed and can be initialized by
+// reading its content from byte array.
+unsafe impl ByteValued for arm64_image_header {}
+
+#[cfg(target_arch = "riscv64")]
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Default)]
+// See kernel doc Documentation/arch/riscv/boot-image-header.rst
+// All these fields should be little endian.
+struct riscv64_image_header {
+    code0: u32,
+    code1: u32,
+    text_offset: u64,
+    image_size: u64,
+    flags: u64,
+    version: u32,
+    res1: u32,
+    res2: u64,
+    magic: u64,
+    magic2: u32,
+    res3: u32,
+}
+
+#[cfg(target_arch = "riscv64")]
+// SAFETY: The layout of the structure is fixed and can be initialized by
+// reading its content from byte array.
+unsafe impl ByteValued for riscv64_image_header {}
+
 impl KernelLoader for PE {
     /// Loads a PE Image into guest memory.
     ///
@@ -98,7 +125,7 @@ impl KernelLoader for PE {
     /// * `guest_mem` - The guest memory where the kernel image is loaded.
     /// * `kernel_offset` - 2MB-aligned base addres in guest memory at which to load the kernel.
     /// * `kernel_image` - Input Image format kernel image.
-    /// * `highmem_start_address` - ignored on ARM64.
+    /// * `highmem_start_address` - ignored on ARM64 and RISC-V64.
     ///
     /// # Returns
     /// * KernelLoaderResult
@@ -114,26 +141,38 @@ impl KernelLoader for PE {
         let kernel_size = kernel_image
             .seek(SeekFrom::End(0))
             .map_err(|_| Error::SeekImageEnd)? as usize;
-        let mut arm64_header: arm64_image_header = Default::default();
+
+        #[cfg(target_arch = "aarch64")]
+        let mut image_header: arm64_image_header = Default::default();
+        #[cfg(target_arch = "riscv64")]
+        let mut image_header: riscv64_image_header = Default::default();
+
         kernel_image.rewind().map_err(|_| Error::SeekImageHeader)?;
 
         kernel_image
-            .read_exact(arm64_header.as_mut_slice())
+            .read_exact(image_header.as_mut_slice())
             .map_err(|_| Error::ReadImageHeader)?;
 
-        if u32::from_le(arm64_header.magic) != 0x644d_5241 {
+        #[cfg(target_arch = "aarch64")]
+        if u32::from_le(image_header.magic) != 0x644d_5241 {
             return Err(Error::InvalidImageMagicNumber.into());
         }
-
-        let image_size = u64::from_le(arm64_header.image_size);
-        let mut text_offset = u64::from_le(arm64_header.text_offset);
-
-        if image_size == 0 {
-            text_offset = 0x80000;
+        #[cfg(target_arch = "riscv64")]
+        if u32::from_le(image_header.magic2) != 0x0543_5352 {
+            return Err(Error::InvalidImageMagicNumber.into());
         }
 
+        #[cfg(target_arch = "aarch64")]
+        let text_offset = if u64::from_le(image_header.image_size) == 0 {
+            0x80000
+        } else {
+            u64::from_le(image_header.text_offset)
+        };
+        #[cfg(target_arch = "riscv64")]
+        let text_offset = u64::from_le(image_header.text_offset);
+
         // Validate that kernel_offset is 2 MB aligned, as required by the
-        // arm64 boot protocol
+        // arm64 and riscv64 boot protocol
         if let Some(kernel_offset) = kernel_offset {
             if kernel_offset.raw_value() % 0x0020_0000 != 0 {
                 return Err(Error::InvalidBaseAddrAlignment.into());
@@ -171,7 +210,7 @@ impl KernelLoader for PE {
 /// * `guest_mem` - A u8 slice that will be partially overwritten by the device tree blob.
 /// * `guest_addr` - The address in `guest_mem` at which to load the device tree blob.
 /// * `dtb_image` - The device tree blob.
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 pub fn load_dtb<F, M: GuestMemory>(
     guest_mem: &M,
     guest_addr: GuestAddress,
@@ -207,12 +246,16 @@ mod tests {
 
     fn make_image_bin() -> Vec<u8> {
         let mut v = Vec::new();
-        v.extend_from_slice(include_bytes!("test_image.bin"));
+        #[cfg(target_arch = "aarch64")]
+        v.extend_from_slice(include_bytes!("test_arm64_image.bin"));
+        #[cfg(target_arch = "riscv64")]
+        v.extend_from_slice(include_bytes!("test_riscv64_image.bin"));
         v
     }
 
+    #[cfg(target_arch = "aarch64")]
     #[test]
-    fn load_image() {
+    fn load_arm64_image() {
         let gm = create_guest_mem();
         let mut image = make_image_bin();
         let kernel_addr = GuestAddress(0x200000);
@@ -237,4 +280,32 @@ mod tests {
             Err(KernelLoaderError::Pe(Error::InvalidImageMagicNumber))
         );
     }
+
+    #[cfg(target_arch = "riscv64")]
+    #[test]
+    fn load_riscv64_image() {
+        let gm = create_guest_mem();
+        let mut image = make_image_bin();
+        let kernel_addr = GuestAddress(0x400000);
+
+        let loader_result =
+            PE::load(&gm, Some(kernel_addr), &mut Cursor::new(&image), None).unwrap();
+        assert_eq!(loader_result.kernel_load.raw_value(), 0x600000);
+        assert_eq!(loader_result.kernel_end, 0x601000);
+
+        // Attempt to load the kernel at an address that is not aligned to 2MB boundary
+        let kernel_offset = GuestAddress(0x0030_0000);
+        let loader_result = PE::load(&gm, Some(kernel_offset), &mut Cursor::new(&image), None);
+        assert_eq!(
+            loader_result,
+            Err(KernelLoaderError::Pe(Error::InvalidBaseAddrAlignment))
+        );
+
+        image[0x38] = 0x0;
+        let loader_result = PE::load(&gm, Some(kernel_addr), &mut Cursor::new(&image), None);
+        assert_eq!(
+            loader_result,
+            Err(KernelLoaderError::Pe(Error::InvalidImageMagicNumber))
+        );
+    }
 }