main: Rewrite boot_from_device

We now pass the boot::Info to `loader::load_default_entry` and
`efi::efi_exec`. We also reorganize the code in this function to:
  - Avoid unnecessary nesting
  - log errors when they occur

The code is now much more readable

Signed-off-by: Joe Richey <joerichey@google.com>

Author: josephlr

src/main.rs

@@ -76,81 +76,66 @@ fn enable_sse() {
 const VIRTIO_PCI_VENDOR_ID: u16 = 0x1af4;
 const VIRTIO_PCI_BLOCK_DEVICE_ID: u16 = 0x1042;
 
-fn boot_from_device(device: &mut block::VirtioBlockDevice) -> bool {
-    match device.init() {
-        Err(_) => {
-            log!("Error configuring block device");
-            return false;
-        }
-        Ok(_) => log!(
-            "Virtio block device configured. Capacity: {} sectors",
-            device.get_capacity()
-        ),
+fn boot_from_device(device: &mut block::VirtioBlockDevice, info: &dyn boot::Info) -> bool {
+    if let Err(err) = device.init() {
+        log!("Error configuring block device: {:?}", err);
+        return false;
     }
+    log!(
+        "Virtio block device configured. Capacity: {} sectors",
+        device.get_capacity()
+    );
 
-    let mut f;
-
-    match part::find_efi_partition(device) {
-        Ok((start, end)) => {
-            log!("Found EFI partition");
-            f = fat::Filesystem::new(device, start, end);
-            if f.init().is_err() {
-                log!("Failed to create filesystem");
-                return false;
-            }
-        }
-        Err(_) => {
-            log!("Failed to find EFI partition");
+    let (start, end) = match part::find_efi_partition(device) {
+        Ok(p) => p,
+        Err(err) => {
+            log!("Failed to find EFI partition: {:?}", err);
             return false;
         }
-    }
+    };
+    log!("Found EFI partition");
 
+    let mut f = fat::Filesystem::new(device, start, end);
+    if let Err(err) = f.init() {
+        log!("Failed to create filesystem: {:?}", err);
+        return false;
+    }
     log!("Filesystem ready");
 
-    let jump_address;
+    match loader::load_default_entry(&f, info) {
+        Ok(mut kernel) => {
+            device.reset();
+            log!("Jumping to kernel");
+            kernel.boot();
+            return true;
+        }
+        Err(err) => log!("Error loading default entry: {:?}", err),
+    }
 
-    match loader::load_default_entry(&f) {
-        Ok(addr) => {
-            jump_address = addr;
+    log!("Using EFI boot.");
+    let mut file = match f.open("/EFI/BOOT/BOOTX64 EFI") {
+        Ok(file) => file,
+        Err(err) => {
+            log!("Failed to load default EFI binary: {:?}", err);
+            return false;
         }
-        Err(_) => {
-            log!("Error loading default entry. Using EFI boot.");
-            match f.open("/EFI/BOOT/BOOTX64 EFI") {
-                Ok(mut file) => {
-                    log!("Found bootloader (BOOTX64.EFI)");
-                    let mut l = pe::Loader::new(&mut file);
-                    match l.load(0x20_0000) {
-                        Ok((a, size)) => {
-                            log!("Executable loaded");
-                            efi::efi_exec(a, 0x20_0000, size, &f, device);
-                            return true;
-                        }
-                        Err(e) => {
-                            match e {
-                                pe::Error::FileError => log!("File error"),
-                                pe::Error::InvalidExecutable => log!("Invalid executable"),
-                            }
-                            return false;
-                        }
-                    }
-                }
-                Err(_) => {
-                    log!("Failed to find bootloader");
-                    return false;
-                }
-            }
+    };
+    log!("Found bootloader (BOOTX64.EFI)");
+
+    let mut l = pe::Loader::new(&mut file);
+    let load_addr = 0x20_0000;
+    let (entry_addr, size) = match l.load(load_addr) {
+        Ok(load_info) => load_info,
+        Err(err) => {
+            log!("Error loading executable: {:?}", err);
+            return false;
         }
-    }
+    };
 
     device.reset();
-
-    log!("Jumping to kernel");
-
-    // Rely on x86 C calling convention where second argument is put into %rsi register
-    let ptr = jump_address as *const ();
-    let code: extern "C" fn(u64, u64) = unsafe { core::mem::transmute(ptr) };
-    (code)(0 /* dummy value */, bzimage::ZERO_PAGE_START as u64);
-    true
+    log!("Executable loaded");
+    efi::efi_exec(entry_addr, 0x20_0000, size, info, &f, device);
+    return true;
 }
 
 #[no_mangle]
@@ -175,7 +160,7 @@ fn run(info: &dyn boot::Info) -> ! {
             let mut pci_transport = pci::VirtioPciTransport::new(pci_device);
             block::VirtioBlockDevice::new(&mut pci_transport);
             let mut device = block::VirtioBlockDevice::new(&mut pci_transport);
-            boot_from_device(&mut device)
+            boot_from_device(&mut device, info)
         },
     );