Support raw image (vmlinux) loading for Aarch64.

Change-Id: I12b8f50de9013e126980056444ca241fdfe7a0ee
Signed-off-by: Michael Zhao <michael.zhao@arm.com>

Author: michael2012z

Cargo.toml

@@ -9,6 +9,7 @@ license = "Apache-2.0 AND BSD-3-Clause"
 default = ["elf"]
 elf = []
 bzimage = []
+arm64_pe = []
 
 [dependencies.vm-memory]
 git = "https://github.com/rust-vmm/vm-memory"

src/lib.rs

@@ -11,20 +11,22 @@
 
 //! A Linux kernel image loading crate.
 //!
-//! This crate offers support for loading raw ELF (vmlinux) and compressed
+//! This crate offers support for loading raw ELF/PE (vmlinux) and compressed
 //! big zImage (bzImage) kernel images.
 //! Support for any other kernel image format can be added by implementing
 //! the KernelLoader.
 //!
 //! # Platform support
 //!
 //! - x86_64
+//! - aarch64
 //!
-//! This crates only supports x86_64 platforms because it implements support
-//! for kernel image formats (vmlinux and bzImage) that are x86 specific.
+//! This crates supports kernel image in format:
+//! - vmlinux and bzImage on x86_64 platform.
+//! - PE on aarch64 platform.
 //!
-//! Extending it to support other kernel image formats (e.g. ARM's Image)
-//! will make it consumable by other platforms.
+//! Extending it to support other kernel image formats will make it consumable
+//! by other platforms.
 
 pub mod cmdline;
 pub mod loader;

src/loader/mod.rs

@@ -12,19 +12,20 @@
 //! - [KernelLoaderResult](struct.KernelLoaderResult.html): the structure which loader
 //! returns to VMM to assist zero page construction and boot environment setup
 //! - [Elf](struct.Elf.html): elf image loader
+//! - [Arm64Pe](struct.Arm64Pe.html): arm64_pe image loader
 //! - [BzImage](struct.BzImage.html): bzImage loader
 
 extern crate vm_memory;
 
 use std::error::{self, Error as KernelLoaderError};
 use std::ffi::CStr;
 use std::fmt::{self, Display};
-#[cfg(any(feature = "elf", feature = "bzimage"))]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+#[cfg(any(feature = "elf", feature = "bzimage", feature = "arm64_pe"))]
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
 use std::io::SeekFrom;
 use std::io::{Read, Seek};
-#[cfg(feature = "elf")]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+#[cfg(any(feature = "elf", feature = "bzimage", feature = "arm64_pe"))]
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
 use std::mem;
 
 use vm_memory::{Address, Bytes, GuestAddress, GuestMemory, GuestUsize};
@@ -42,8 +43,6 @@ pub mod bootparam;
 #[allow(non_upper_case_globals)]
 #[cfg_attr(feature = "cargo-clippy", allow(clippy::all))]
 mod elf;
-#[cfg(any(feature = "elf", feature = "bzimage"))]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 mod struct_util;
 
 #[derive(Debug, PartialEq)]
@@ -81,6 +80,10 @@ pub enum Error {
     ReadBzImageHeader,
     /// Unable to read bzImage compressed image.
     ReadBzImageCompressedKernel,
+    /// Unable to read image magic number.
+    ReadImageMagicNumber,
+    /// Unable to read entry address.
+    ReadEntryAddress,
     /// Unable to seek to kernel start.
     SeekKernelStart,
     /// Unable to seek to ELF start.
@@ -93,6 +96,14 @@ pub enum Error {
     SeekBzImageHeader,
     /// Unable to seek to bzImage compressed kernel.
     SeekBzImageCompressedKernel,
+    /// Unable to seek to image start.
+    SeekImageStart,
+    /// Unable to seek to image end.
+    SeekImageEnd,
+    /// Unable to seek to magic image number.
+    SeekImageMagicNumber,
+    /// Unable to seek to entry address.
+    SeekEntryAddress,
 }
 
 /// A specialized `Result` type for the kernel loader.
@@ -119,12 +130,18 @@ impl error::Error for Error {
             Error::ReadProgramHeader => "Unable to read program header",
             Error::ReadBzImageHeader => "Unable to read bzImage header",
             Error::ReadBzImageCompressedKernel => "Unable to read bzImage compressed kernel",
+            Error::ReadImageMagicNumber => "Unable to read image magic number",
+            Error::ReadEntryAddress => "Unable to read entry address",
             Error::SeekKernelStart => "Unable to seek to kernel start",
             Error::SeekElfStart => "Unable to seek to elf start",
             Error::SeekProgramHeader => "Unable to seek to program header",
             Error::SeekBzImageEnd => "Unable to seek bzImage end",
             Error::SeekBzImageHeader => "Unable to seek bzImage header",
             Error::SeekBzImageCompressedKernel => "Unable to seek bzImage compressed kernel",
+            Error::SeekImageStart => "Unable to seek to image start",
+            Error::SeekImageEnd => "Unable to seek to image end",
+            Error::SeekImageMagicNumber => "Unable to seek to magic image number",
+            Error::SeekEntryAddress => "Unable to seek to entry address",
         }
     }
 }
@@ -378,6 +395,117 @@ impl KernelLoader for BzImage {
     }
 }
 
+#[cfg(feature = "arm64_pe")]
+#[cfg(target_arch = "aarch64")]
+/// Aarch64 kernel image support.
+pub struct Arm64Pe;
+
+#[cfg(feature = "arm64_pe")]
+#[cfg(target_arch = "aarch64")]
+impl KernelLoader for Arm64Pe {
+    /// Loads a Aarch64 kernel image
+    ///
+    /// Aarch64 kernel boot protocol is specified in the kernel docs
+    /// Documentation/arm/Booting and Documentation/arm64/booting.txt.
+    ///
+    /// ======aarch64 kernel header========
+    /// u32 code0;                /* Executable code */
+    /// u32 code1;                /* Executable code */
+    /// u64 text_offset;          /* Image load offset, little endian */
+    /// u64 image_size;           /* Effective Image size, little endian */
+    /// u64 flags;                /* kernel flags, little endian */
+    /// u64 res2  = 0;            /* reserved */
+    /// u64 res3  = 0;            /* reserved */
+    /// u64 res4  = 0;            /* reserved */
+    /// u32 magic = 0x644d5241;   /* Magic number, little endian, "ARM\x64" */
+    /// u32 res5;                 /* reserved (used for PE COFF offset) */
+    /// ====================================
+    ///
+    /// # Arguments
+    ///
+    /// * `guest_mem` - The guest memory region the kernel is written to.
+    /// * `kernel_start` - The offset into 'guest_mem' at which to load the kernel.
+    /// * `kernel_image` - Input vmlinux image.
+    /// * `highmem_start_address` - This is the start of the high memory, kernel should above it.
+    ///
+    /// # Returns
+    /// * KernelLoaderResult
+    fn load<F, M: GuestMemory>(
+        guest_mem: &M,
+        kernel_start: Option<GuestAddress>,
+        kernel_image: &mut F,
+        _highmem_start_address: Option<GuestAddress>,
+    ) -> Result<KernelLoaderResult>
+    where
+        F: Read + Seek,
+    {
+        const AARCH64_KERNEL_LOAD_ADDR: usize = 0x80000;
+        const AARCH64_MAGIC_NUMBER: u32 = 0x644d_5241;
+        const AARCH64_MAGIC_OFFSET: u64 =
+            2 * mem::size_of::<u32>() as u64 + 6 * mem::size_of::<u64>() as u64; // This should total 56.
+        const AARCH64_TEXT_OFFSET: u64 = 2 * mem::size_of::<u32>() as u64;
+        let mut kernel_load_offset = AARCH64_KERNEL_LOAD_ADDR;
+
+        /* Look for the magic number inside the elf header. */
+        kernel_image
+            .seek(SeekFrom::Start(AARCH64_MAGIC_OFFSET))
+            .map_err(|_| Error::SeekImageMagicNumber)?;
+        let mut magic_number: u32 = 0;
+        unsafe {
+            struct_util::read_struct(kernel_image, &mut magic_number)
+                .map_err(|_| Error::ReadImageMagicNumber)?
+        }
+        if u32::from_le(magic_number) != AARCH64_MAGIC_NUMBER {
+            return Err(Error::InvalidElfMagicNumber);
+        }
+
+        /* Look for the `text_offset` from the elf header. */
+        kernel_image
+            .seek(SeekFrom::Start(AARCH64_TEXT_OFFSET)) // This should total 8.
+            .map_err(|_| Error::SeekEntryAddress)?;
+        let mut hdrvals: [u64; 2] = [0; 2];
+        unsafe {
+            struct_util::read_struct(kernel_image, &mut hdrvals)
+                .map_err(|_| Error::ReadEntryAddress)?;
+        }
+        /* Following the boot protocol mentioned above. */
+        if u64::from_le(hdrvals[1]) != 0 {
+            kernel_load_offset = u64::from_le(hdrvals[0]) as usize;
+        }
+        /* Get the total size of kernel image. */
+        let kernel_size = kernel_image
+            .seek(SeekFrom::End(0))
+            .map_err(|_| Error::SeekImageEnd)?;
+
+        /* Last `seek` will leave the image with the cursor at its end, rewind it to start. */
+        kernel_image
+            .seek(SeekFrom::Start(0))
+            .map_err(|_| Error::SeekImageStart)?;
+
+        let mut loader_result: KernelLoaderResult = Default::default();
+        // where the kernel will be start loaded.
+        let mem_offset = match kernel_start {
+            Some(start) => GuestAddress(start.raw_value() + (kernel_load_offset as u64)),
+            None => GuestAddress(kernel_load_offset as u64),
+        };
+
+        loader_result.kernel_load = mem_offset;
+
+        guest_mem
+            .read_exact_from(mem_offset, kernel_image, kernel_size as usize)
+            .map_err(|_| Error::ReadKernelImage)?;
+
+        loader_result.kernel_end = mem_offset
+            .raw_value()
+            .checked_add(kernel_size as GuestUsize)
+            .ok_or(Error::MemoryOverflow)?;
+
+        loader_result.setup_header = None;
+
+        Ok(loader_result)
+    }
+}
+
 /// Writes the command line string to the given memory slice.
 ///
 /// # Arguments
@@ -412,8 +540,6 @@ pub fn load_cmdline<M: GuestMemory>(
 #[cfg(test)]
 mod test {
     use super::*;
-    #[cfg(any(feature = "elf", feature = "bzimage"))]
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     use std::io::Cursor;
     use vm_memory::{Address, GuestAddress, GuestMemoryMmap};
 
@@ -440,6 +566,15 @@ mod test {
         v
     }
 
+    // Aarch64 image.
+    #[cfg(feature = "arm64_pe")]
+    #[cfg(target_arch = "aarch64")]
+    fn make_aarch64_bin() -> Vec<u8> {
+        let mut v = Vec::new();
+        v.extend_from_slice(include_bytes!("test_arm64_pe.bin"));
+        v
+    }
+
     #[allow(safe_packed_borrows)]
     #[allow(non_snake_case)]
     #[test]
@@ -562,6 +697,29 @@ mod test {
         );
     }
 
+    // Aarch64 image.
+    #[cfg(feature = "arm64_pe")]
+    #[cfg(target_arch = "aarch64")]
+    #[test]
+    fn load_aarch64() {
+        const TEST_IMAGE_KERNEL_OFFSET: u64 = 0x8_0000; // test binary specific
+        const TEST_IMAGE_KERNEL_SIZE: u64 = 0x50; // test binary specific
+        let gm = create_guest_mem();
+        let image = make_aarch64_bin();
+        let kernel_addr = GuestAddress(0x80000);
+
+        assert_eq!(
+            Ok(KernelLoaderResult {
+                kernel_load: GuestAddress(kernel_addr.raw_value() + TEST_IMAGE_KERNEL_OFFSET),
+                kernel_end: (kernel_addr.raw_value()
+                    + TEST_IMAGE_KERNEL_OFFSET
+                    + TEST_IMAGE_KERNEL_SIZE) as u64,
+                setup_header: None
+            }),
+            Arm64Pe::load(&gm, Some(kernel_addr), &mut Cursor::new(&image), None)
+        );
+    }
+
     #[test]
     fn cmdline_overflow() {
         let gm = create_guest_mem();
@@ -618,6 +776,21 @@ mod test {
         );
     }
 
+    #[cfg(feature = "arm64_pe")]
+    #[cfg(target_arch = "aarch64")]
+    #[test]
+    fn bad_magic() {
+        let gm = create_guest_mem();
+        let kernel_addr = GuestAddress(0x0);
+        let mut bad_image = make_aarch64_bin();
+        bad_image[0x38] = 0x33;
+
+        assert_eq!(
+            Err(Error::InvalidElfMagicNumber),
+            Arm64Pe::load(&gm, Some(kernel_addr), &mut Cursor::new(&bad_image), None)
+        );
+    }
+
     #[cfg(feature = "elf")]
     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     #[test]