AArch64: try boot from kernel before bootloader

Add kernel image loader and try to find kernel image info in FDT, if
there is one, load and start kernel directly.

Signed-off-by: Jianyong Wu <[email protected]>

Author: jongwu

src/efi/mod.rs

@@ -10,6 +10,7 @@ use core::{
     ptr::null_mut,
 };
 
+use crate::efi::file::FileSystemWrapper;
 use atomic_refcell::AtomicRefCell;
 use linked_list_allocator::LockedHeap;
 use r_efi::{
@@ -1107,8 +1108,8 @@ pub fn efi_exec(
     loaded_address: u64,
     loaded_size: u64,
     info: &dyn bootinfo::Info,
-    fs: &crate::fat::Filesystem,
-    block: *const crate::block::VirtioBlockDevice,
+    fs: Option<&crate::fat::Filesystem>,
+    block: Option<*const crate::block::VirtioBlockDevice>,
 ) {
     let vendor_data = 0u32;
 
@@ -1178,14 +1179,23 @@ pub fn efi_exec(
 
     populate_allocator(info, loaded_address, loaded_size);
 
-    let efi_part_id = unsafe { block::populate_block_wrappers(&mut BLOCK_WRAPPERS, block) };
+    let efi_part_id = if let Some(b) = block {
+        unsafe { block::populate_block_wrappers(&mut BLOCK_WRAPPERS, b) }
+    } else {
+        None
+    };
 
-    let wrapped_fs = file::FileSystemWrapper::new(fs, efi_part_id);
+    let wrapfs: FileSystemWrapper;
+    let mut wrapped_fs = core::ptr::null::<u8>() as Handle;
+    if let Some(f) = fs {
+        wrapfs = file::FileSystemWrapper::new(f, efi_part_id);
+        wrapped_fs = &wrapfs as *const _ as Handle;
+    };
 
     let image = new_image_handle(
         crate::efi::EFI_BOOT_PATH,
         0 as Handle,
-        &wrapped_fs as *const _ as Handle,
+        wrapped_fs,
         loaded_address,
         loaded_size,
         address,

src/main.rs

@@ -28,6 +28,8 @@ use x86_64::instructions::hlt;
 
 #[cfg(target_arch = "aarch64")]
 use crate::arch::aarch64::layout::code_range;
+#[cfg(target_arch = "aarch64")]
+use crate::fdt::KernelInfo;
 
 #[macro_use]
 mod serial;
@@ -156,10 +158,42 @@ fn boot_from_device(device: &mut block::VirtioBlockDevice, info: &dyn bootinfo::
     }
 
     log!("Executable loaded");
-    efi::efi_exec(entry_addr, load_addr, size, info, &f, device);
+    efi::efi_exec(entry_addr, load_addr, size, info, Some(&f), Some(device));
     true
 }
 
+#[cfg(target_arch = "aarch64")]
+fn boot_from_kernel(k: KernelInfo, info: &dyn bootinfo::Info) {
+    let load_addr = info.kernel_load_addr();
+    let dsc = load_addr as *mut u8;
+    let src = k.address as *const u8;
+    unsafe {
+        core::ptr::copy(src, dsc, k.size as usize);
+    }
+    // Get pe_header_offset
+    let pe_header_offset = unsafe {
+        let addr = (dsc.wrapping_add(60_usize)) as *const u32;
+        *addr
+    };
+    let entry_addr = unsafe {
+        let addr = (dsc.wrapping_add((pe_header_offset + 40).try_into().unwrap())) as *const u32;
+        *addr
+    };
+    let image_size = unsafe {
+        let addr = (dsc.wrapping_add((pe_header_offset + 80).try_into().unwrap())) as *const u32;
+        *addr
+    };
+
+    efi::efi_exec(
+        load_addr + entry_addr as u64,
+        load_addr,
+        image_size.into(),
+        info,
+        None,
+        None,
+    );
+}
+
 #[cfg(target_arch = "x86_64")]
 #[no_mangle]
 pub extern "C" fn rust64_start(#[cfg(not(feature = "coreboot"))] pvh_info: &pvh::StartInfo) -> ! {
@@ -194,6 +228,11 @@ pub extern "C" fn rust64_start(x0: *const u8) -> ! {
         None,
     );
 
+    if let Some(kernel_info) = info.find_kernel_info() {
+        log!("Boot with direct kernel");
+        boot_from_kernel(kernel_info, &info);
+    }
+
     if let Some((base, length)) = info.find_compatible_region(&["pci-host-ecam-generic"]) {
         pci::init(base as u64, length as u64);
     }