add some comments

Author: Freax13

src/lib.rs

@@ -123,6 +123,8 @@ pub fn create_bios_disk_image(
     Ok(())
 }
 
+/// Prepare a folder for use with booting over UEFI_PXE. The dhcp server should
+/// have the filename option set to `bootloader`.
 pub fn create_uefi_pxe_tftp_folder(kernel_binary: &Path, out_path: &Path) -> anyhow::Result<()> {
     let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
 

uefi/src/main.rs

@@ -26,6 +26,7 @@ use uefi::{
     CStr16, CStr8,
 };
 use x86_64::{
+    align_up,
     structures::paging::{FrameAllocator, OffsetPageTable, PageTable, PhysFrame, Size4KiB},
     PhysAddr, VirtAddr,
 };
@@ -130,6 +131,7 @@ fn load_kernel(image: Handle, st: &SystemTable<Boot>) -> Kernel<'static> {
     Kernel::parse(kernel_slice)
 }
 
+/// Try to load a kernel file from the boot device.
 fn load_kernel_file(image: Handle, st: &SystemTable<Boot>) -> Option<&'static mut [u8]> {
     load_kernel_file_from_disk(image, st)
         .or_else(|| load_kernel_file_from_tftp_boot_server(image, st))
@@ -189,59 +191,62 @@ fn load_kernel_file_from_disk(image: Handle, st: &SystemTable<Boot>) -> Option<&
     Some(kernel_slice)
 }
 
+/// Try to load a kernel from a TFTP boot server.
 fn load_kernel_file_from_tftp_boot_server(
     image: Handle,
     st: &SystemTable<Boot>,
 ) -> Option<&'static mut [u8]> {
-    let ref this = st.boot_services();
+    let this = st.boot_services();
 
-    let file_system_raw = {
-        let ref this = st.boot_services();
-        let loaded_image = this
-            .handle_protocol::<LoadedImage>(image)
-            .expect("Failed to retrieve `LoadedImage` protocol from handle");
-        let loaded_image = unsafe { &*loaded_image.get() };
+    // Try to locate a `BaseCode` protocol on the boot device.
 
-        let device_handle = loaded_image.device();
+    let loaded_image = this
+        .handle_protocol::<LoadedImage>(image)
+        .expect("Failed to retrieve `LoadedImage` protocol from handle");
+    let loaded_image = unsafe { &*loaded_image.get() };
 
-        let device_path = this
-            .handle_protocol::<DevicePath>(device_handle)
-            .expect("Failed to retrieve `DevicePath` protocol from image's device handle");
-        let mut device_path = unsafe { &*device_path.get() };
+    let device_handle = loaded_image.device();
 
-        let device_handle = this
-            .locate_device_path::<BaseCode>(&mut device_path)
-            .expect("Failed to locate `BaseCode` protocol on device path");
+    let device_path = this
+        .handle_protocol::<DevicePath>(device_handle)
+        .expect("Failed to retrieve `DevicePath` protocol from image's device handle");
+    let mut device_path = unsafe { &*device_path.get() };
 
-        this.handle_protocol::<BaseCode>(device_handle)
-    }
-    .unwrap();
-    let base_code = unsafe { &mut *file_system_raw.get() };
+    let device_handle = this.locate_device_path::<BaseCode>(&mut device_path).ok()?;
 
+    let base_code_raw = this.handle_protocol::<BaseCode>(device_handle).unwrap();
+    let base_code = unsafe { &mut *base_code_raw.get() };
+
+    // Find the TFTP boot server.
     let mode = base_code.mode();
     assert!(mode.dhcp_ack_received);
     let dhcpv4: &DhcpV4Packet = mode.dhcp_ack.as_ref();
     let server_ip = IpAddress::new_v4(dhcpv4.bootp_si_addr);
 
     let filename = CStr8::from_bytes_with_nul(b"kernel-x86_64\0").unwrap();
-    let file_size = base_code.tftp_get_file_size(&server_ip, filename).unwrap();
 
-    let kernel_size = usize::try_from(file_size).unwrap();
+    // Determine the kernel file size.
+    let file_size = base_code
+        .tftp_get_file_size(&server_ip, filename)
+        .expect("Failed to query the kernel file size");
+    let kernel_size =
+        usize::try_from(file_size).expect("The kernel file size should fit into usize");
 
+    // Allocate some memory for the kernel file.
     let kernel_ptr = st
         .boot_services()
         .allocate_pages(
             AllocateType::AnyPages,
             MemoryType::LOADER_DATA,
-            ((kernel_size - 1) / 4096) + 1,
+            align_up(kernel_size, 4096),
         )
-        .unwrap() as *mut u8;
-    unsafe { ptr::write_bytes(kernel_ptr, 0, kernel_size) };
+        .expect("Failed to allocate memory for the kernel file") as *mut u8;
     let kernel_slice = unsafe { slice::from_raw_parts_mut(kernel_ptr, kernel_size) };
 
+    // Load the kernel file.
     base_code
         .tftp_read_file(&server_ip, filename, Some(kernel_slice))
-        .unwrap();
+        .expect("Failed to read kernel file from the TFTP boot server");
 
     Some(kernel_slice)
 }