load linux kernel from UEFI

nel_os_bootloader/create-iso.sh

@@ -6,12 +6,14 @@ cd ../nel_os_kernel
 cargo build --release -q
 cd ../nel_os_bootloader
 
-dd if=/dev/zero of=fat.img bs=1k count=1440
-mformat -i fat.img -f 1440 ::
+dd if=/dev/zero of=fat.img bs=1k count=32768
+mformat -i fat.img -C -h 16 -t 128 -s 32 ::
 mmd -i fat.img ::/EFI
 mmd -i fat.img ::/EFI/BOOT
 mcopy -i fat.img "$EFI_BINARY" ::/EFI/BOOT/BOOTX64.EFI
 mcopy -i fat.img ../nel_os_kernel/target/x86_64-nel_os/release/nel_os_kernel.elf ::/nel_os_kernel.elf
+mcopy -i fat.img bzImage ::/bzImage
+mcopy -i fat.img rootfs-n.cpio.gz ::/rootfs-n.cpio.gz
 
 mkdir iso
 cp fat.img iso

nel_os_bootloader/src/main.rs

@@ -42,25 +42,53 @@ fn get_fs() -> Directory {
     fs.open_volume().unwrap()
 }
 
-fn read_kernel(name: &CStr16) -> Box<[u8]> {
+fn read_file(name: &CStr16) -> Box<[u8]> {
     let mut root = get_fs();
-    let kernel_file_info = root
+    let file_info = root
         .open(name, FileMode::Read, FileAttribute::empty())
         .unwrap();
-    let mut kernel_file = kernel_file_info.into_regular_file().unwrap();
+    let mut file = file_info.into_regular_file().unwrap();
 
-    let file_size = kernel_file
-        .get_boxed_info::<FileInfo>()
-        .unwrap()
-        .file_size();
+    let file_size = file.get_boxed_info::<FileInfo>().unwrap().file_size();
     let mut buf = vec![0; file_size as usize];
 
-    let read_size = kernel_file.read(&mut buf).unwrap();
-    println!("kernel size: {}", read_size);
+    let read_size = file.read(&mut buf).unwrap();
+    println!("file {} size: {}", name, read_size);
 
     buf.into_boxed_slice()
 }
 
+fn load_file_to_laoder_data(name: &CStr16) -> (u64, u64) {
+    let mut root = get_fs();
+    let file_info = root
+        .open(name, FileMode::Read, FileAttribute::empty())
+        .expect("Failed to open file");
+    let mut file = file_info
+        .into_regular_file()
+        .expect("Failed to convert to regular file");
+
+    let file_size = file
+        .get_boxed_info::<FileInfo>()
+        .expect("Failed to get file info")
+        .file_size();
+
+    let page_ptr = unsafe {
+        uefi::boot::allocate_pages(
+            AllocateType::AnyPages,
+            MemoryType::LOADER_DATA,
+            file_size.div_ceil(4096) as usize,
+        )
+        .expect("Failed to allocate pages")
+        .as_mut()
+    };
+
+    let buf = unsafe { slice::from_raw_parts_mut(page_ptr, file_size as usize) };
+    let read_size = file.read(buf).expect("Failed to read file");
+    println!("file {} size: {}", name, read_size);
+
+    (page_ptr as *mut u8 as u64, file_size)
+}
+
 fn load_elf(bin: Box<[u8]>) -> u64 {
     let elf = elf::Elf::parse(&bin).expect("Failed to parse elf");
     let mut dest_start = u64::MAX;
@@ -143,7 +171,10 @@ fn main() -> Status {
 
     println!("{} v{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
 
-    let kernel = read_kernel(cstr16!("nel_os_kernel.elf"));
+    let kernel = read_file(cstr16!("nel_os_kernel.elf"));
+
+    let (bzimage_addr, bzimage_size) = load_file_to_laoder_data(cstr16!("bzImage"));
+    let (rootfs_addr, rootfs_size) = load_file_to_laoder_data(cstr16!("rootfs-n.cpio.gz"));
 
     let entry_point = load_elf(kernel);
 
@@ -195,6 +226,10 @@ fn main() -> Status {
         usable_memory,
         frame_buffer,
         rsdp,
+        bzimage_addr,
+        bzimage_size,
+        rootfs_addr,
+        rootfs_size,
     });
 
     hlt_loop();