build: Add initial support for aarch64 build

This commit adds initial support for aarch64 build. The goal is to boot
Linux with this firmware on aarch64 Cloud Hypervisor. This commit
includes a bootstrap assembly and build configs for building a binary
that complies the Linux kernel image format [1]. It also includes some
stub code to make the aarch64 target buildable with minimal changes.
The later commits will implement the code.

[1] https://docs.kernel.org/arm64/booting.html#call-the-kernel-image

Signed-off-by: Akira Moroo <retrage01@gmail.com>

Author: retrage

aarch64-unknown-none.json

@@ -0,0 +1,20 @@
+{
+  "llvm-target": "aarch64-unknown-none",
+  "abi": "softfloat",
+  "arch": "aarch64",
+  "data-layout": "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128",
+  "disable-redzone": true,
+  "features": "+strict-align,-neon,-fp-armv8",
+  "linker": "rust-lld",
+  "linker-flavor": "ld.lld",
+  "os": "none",
+  "executables": true,
+  "max-atomic-width": 128,
+  "panic-strategy": "abort",
+  "code-model": "small",
+  "relocation-model": "pic",
+  "target-pointer-width": "64",
+  "pre-link-args": {
+    "ld.lld": ["--script=aarch64-unknown-none.ld", "--oformat=binary"]
+  }
+}

aarch64-unknown-none.ld

@@ -0,0 +1,38 @@
+ENTRY(ram64_start)
+
+/* Cloud Hypervisor Memory layout:
+    DRAM:   [0x4000_0000-0xfc00_0000]
+    FDT:    [0x4000_0000-0x401f_ffff)
+    ACPI:   [0x4020_0000-0x403f_ffff)
+    kernel: [0x4048_0000-]
+   The stack start is at the end of the DRAM region. */
+ram_min = 0x40480000;
+
+SECTIONS
+{
+  /* Mapping the program headers and note into RAM makes the file smaller. */
+  . = ram_min;
+
+  /* These sections are mapped into RAM from the file. Omitting :ram from
+     later sections avoids emitting empty sections in the final binary.       */
+  text_start = .;
+  .text.boot  : { *(.text.boot)        }
+  .text       : { *(.text .text.*)     }
+  . = ALIGN(4K);
+  text_end = .;
+  .data       : { *(.data .data.*)     }
+  .rodata     : { *(.rodata .rodata.*) }
+
+  /* The BSS section isn't mapped from file data. It is just zeroed in RAM. */
+  .bss : {
+    bss_start = .;
+    *(.bss .bss.*)
+    bss_size = . - bss_start;
+  }
+
+  /* Strip symbols from the output binary (comment out to get symbols) */
+  /DISCARD/ : {
+    *(.symtab)
+    *(.strtab)
+  }
+}

build.rs

@@ -1,4 +1,6 @@
 fn main() {
+    println!("cargo:rerun-if-changed=aarch64-unknown-none.json");
+    println!("cargo:rerun-if-changed=aarch64-unknown-none.ld");
     println!("cargo:rerun-if-changed=x86_64-unknown-none.json");
     println!("cargo:rerun-if-changed=x86_64-unknown-none.ld");
 }

rust-toolchain.toml

@@ -1,5 +1,5 @@
 [toolchain]
 channel = "nightly-2022-06-10"
 components = ["rust-src", "clippy", "rustfmt"]
-targets = ["x86_64-unknown-linux-gnu"]
+targets = ["aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu"]
 profile = "default"

src/arch/aarch64/asm.rs

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2022 Akira Moroo
+
+use core::arch::global_asm;
+
+global_asm!(include_str!("ram64.s"));

src/arch/aarch64/mod.rs

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2022 Akira Moroo
+
+#[cfg(not(test))]
+pub mod asm;

src/arch/aarch64/ram64.s

@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+/* Copyright (C) 2022 Akira Moroo */
+
+.section .text.boot, "ax"
+.global ram64_start
+
+ram64_start:
+  /* UEFI "MZ" signature magic instruction */
+  add x13, x18, #0x16   /* code0 */
+  b jump_to_rust        /* code1 */
+
+  .quad 0               /* text_offset */
+  .quad 0               /* image_size */
+  .quad 0               /* flags */
+  .quad 0               /* res2 */
+  .quad 0               /* res3 */
+  .quad 0               /* res4 */
+
+  .long 0x644d5241      /* "ARM\x64" magic number */
+  .long 0               /* res5 */
+  .align 3
+
+jump_to_rust:
+  /* x0 typically points to device tree at entry */
+  ldr x0, =0x40000000
+
+  /* setup stack */
+  ldr x30, =0xfc000000
+  mov sp, x30
+
+  /* x0: pointer to device tree */
+  b rust64_start

src/arch/mod.rs

@@ -1,5 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (C) 2022 Akira Moroo
 
+#[cfg(target_arch = "aarch64")]
+pub mod aarch64;
+
 #[cfg(target_arch = "x86_64")]
 pub mod x86_64;

src/delay.rs

@@ -10,12 +10,24 @@ const NSECS_PER_SEC: u64 = 1000000000;
 const CPU_KHZ_DEFAULT: u64 = 200;
 const PAUSE_THRESHOLD_TICKS: u64 = 150;
 
+#[cfg(target_arch = "aarch64")]
+#[inline]
+unsafe fn rdtsc() -> u64 {
+    todo!();
+}
+
 #[cfg(target_arch = "x86_64")]
 #[inline]
 unsafe fn rdtsc() -> u64 {
     _rdtsc()
 }
 
+#[cfg(target_arch = "aarch64")]
+#[inline]
+unsafe fn pause() {
+    todo!();
+}
+
 #[cfg(target_arch = "x86_64")]
 #[inline]
 unsafe fn pause() {

src/efi/mod.rs

@@ -1255,6 +1255,9 @@ pub fn efi_exec(
     let wrapped_fs = file::FileSystemWrapper::new(fs, efi_part_id);
 
     let image = new_image_handle(
+        #[cfg(target_arch = "aarch64")]
+        "\\EFI\\BOOT\\BOOTAA64.EFI",
+        #[cfg(target_arch = "x86_64")]
         "\\EFI\\BOOT\\BOOTX64.EFI",
         0 as Handle,
         &wrapped_fs as *const _ as Handle,

src/main.rs

@@ -109,16 +109,23 @@ fn boot_from_device(device: &mut block::VirtioBlockDevice, info: &dyn boot::Info
     }
 
     log!("Using EFI boot.");
-    let mut file = match f.open("/EFI/BOOT/BOOTX64 EFI") {
+    #[cfg(target_arch = "aarch64")]
+    let efi_boot_path = "/EFI/BOOT/BOOTAA64.EFI";
+    #[cfg(target_arch = "x86_64")]
+    let efi_boot_path = "/EFI/BOOT/BOOTX64 EFI";
+    let mut file = match f.open(efi_boot_path) {
         Ok(file) => file,
         Err(err) => {
             log!("Failed to load default EFI binary: {:?}", err);
             return false;
         }
     };
-    log!("Found bootloader (BOOTX64.EFI)");
+    log!("Found bootloader: {}", efi_boot_path);
 
     let mut l = pe::Loader::new(&mut file);
+    #[cfg(target_arch = "aarch64")]
+    let load_addr = 0x4040_0000;
+    #[cfg(target_arch = "x86_64")]
     let load_addr = 0x20_0000;
     let (entry_addr, load_addr, size) = match l.load(load_addr) {
         Ok(load_info) => load_info,
@@ -152,6 +159,12 @@ pub extern "C" fn rust64_start(#[cfg(not(feature = "coreboot"))] pvh_info: &pvh:
     main(info)
 }
 
+#[cfg(target_arch = "aarch64")]
+#[no_mangle]
+pub extern "C" fn rust64_start(_x0: *const u8) -> ! {
+    todo!();
+}
+
 #[cfg(target_arch = "x86_64")]
 fn main(info: &dyn boot::Info) -> ! {
     log!("\nBooting with {}", info.name());

src/pe.rs

@@ -38,10 +38,12 @@ struct Section {
 }
 
 impl<'a> Loader<'a> {
+    #[cfg(target_arch = "aarch64")]
+    const MACHINE_TYPE: u16 = 0xaa64;
     #[cfg(target_arch = "x86_64")]
     const MACHINE_TYPE: u16 = 0x8664;
 
-    #[cfg(target_arch = "x86_64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
     const OPTIONAL_HEADER_MAGIC: u16 = 0x20b; // PE32+
 
     pub fn new(file: &'a mut dyn crate::fat::Read) -> Loader {

src/rtc.rs

@@ -3,3 +3,13 @@
 
 #[cfg(target_arch = "x86_64")]
 pub use crate::cmos::{read_date, read_time};
+
+#[cfg(target_arch = "aarch64")]
+pub fn read_date() -> Result<(u8, u8, u8), ()> {
+    todo!();
+}
+
+#[cfg(target_arch = "aarch64")]
+pub fn read_time() -> Result<(u8, u8, u8), ()> {
+    todo!();
+}

src/serial.rs

@@ -32,6 +32,11 @@ impl fmt::Write for Serial {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         PORT.borrow_mut().write_str(s)
     }
+
+    #[cfg(target_arch = "aarch64")]
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        todo!();
+    }
 }
 
 #[macro_export]