Merge pull request #15 from lemolatoon/impl-gui-layers

Impl gui layers

.vscode/settings.json

@@ -7,4 +7,5 @@
         "./kernel-lib/Cargo.toml",
         "./common/Cargo.toml",
     ],
+    "editor.formatOnSave": true,
 }

Makefile

@@ -45,7 +45,7 @@ disk.img: bootloader/target/x86_64-unknown-uefi/$(PROFILE)/bootloader.efi kernel
 
 install: bootloader/target/x86_64-unknown-uefi/$(PROFILE)/bootloader.efi kernel/target/x86_64-lemolaos-eabi/$(PROFILE)/kernel.elf
 	mkdir -p mnt && \
-	sudo mount -t drvfs e: mnt && \
+	sudo mount -t drvfs d: mnt && \
 	sudo mkdir -p mnt/EFI/BOOT && \
 	sudo cp bootloader/target/x86_64-unknown-uefi/$(PROFILE)/bootloader.efi mnt/EFI/BOOT/BOOTX64.EFI && \
 	sudo cp kernel/target/x86_64-lemolaos-eabi/$(PROFILE)/kernel.elf mnt/kernel.elf && \

bootloader/src/main.rs

@@ -5,7 +5,7 @@ extern crate alloc;
 
 use alloc::vec::Vec;
 use alloc::{string::String, vec};
-use common::types::{GraphicsInfo, KernelMain, KernelMainArg, PixcelFormat};
+use common::types::{GraphicsInfo, KernelMain, KernelMainArg, MemMapEntry, PixcelFormat};
 use core::arch::asm;
 use core::panic;
 use elf::{endian::AnyEndian, ElfBytes};
@@ -200,15 +200,28 @@ fn main(image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
     unsafe {
         dont_use_this_uninit_buf.set_len(buf_size)
     };
-    let (_system_table, _memory_map) =
+    let mut mem_map_buf = Vec::<u8>::with_capacity(buf_size);
+    let (_system_table, memory_map) =
         match system_table.exit_boot_services(image_handle, &mut dont_use_this_uninit_buf) {
             Ok(ret) => ret,
             Err(err) => {
                 panic!("Failed to exit_boot_services, {:?}", err);
             }
         };
+    let size = memory_map.len();
+    {
+        let header = mem_map_buf.as_mut_ptr() as *mut MemMapEntry;
+        unsafe { (*header).size = size as u64 };
+        let desc_head = unsafe { (header).add(1) } as *mut MemoryDescriptor;
+        for (i, desc) in memory_map.enumerate() {
+            unsafe { *desc_head.add(i) = *desc };
+        }
+    }
 
-    let kernel_main_arg = KernelMainArg { graphics_info };
+    let kernel_main_arg = KernelMainArg {
+        graphics_info,
+        memory_map_entry: mem_map_buf.as_ptr() as *const _,
+    };
 
     let kernel_main: KernelMain = unsafe { core::mem::transmute(entry_point as usize) };
 

common/Cargo.toml

@@ -6,3 +6,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+uefi-raw = "0.5.0"

common/src/types.rs

@@ -1,7 +1,75 @@
+pub use uefi_raw::table::boot::MemoryDescriptor;
+pub use uefi_raw::table::boot::MemoryType;
+
 #[repr(C)]
 #[derive(Debug, Clone)]
 pub struct KernelMainArg {
     pub graphics_info: GraphicsInfo,
+    pub memory_map_entry: *const MemMapEntry,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct MemMapEntry {
+    pub size: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct MemMapIter<'a> {
+    index: usize,
+    size: usize,
+    current: *const MemoryDescriptor,
+    _lifetime: core::marker::PhantomData<&'a MemoryDescriptor>,
+}
+
+impl MemMapEntry {
+    /// # Safety
+    /// The caller must ensure that entry has enough size to store the given iterator.
+    /// And header(=MemMapEntry) can be placed at the beginning of the entry.
+    pub unsafe fn new_inplace<'a, 'b>(
+        entry: &'a mut [u8],
+        size: u64,
+        iter: impl ExactSizeIterator<Item = &'b MemoryDescriptor> + Clone,
+    ) {
+        let header = entry.as_mut_ptr() as *mut MemMapEntry;
+        (*header).size = size;
+        let desc_head = unsafe { (header).add(1) } as *mut MemoryDescriptor;
+        for (i, desc) in iter.enumerate() {
+            unsafe { *desc_head.add(i) = *desc };
+        }
+    }
+
+    /// # Safety
+    /// The caller must ensure that an array(len = self.size) of MemoryDescriptor are
+    /// placed after this struct.
+    pub unsafe fn into_iter(&self) -> MemMapIter<'_> {
+        let current = unsafe { (self as *const MemMapEntry).add(1) } as *const MemoryDescriptor;
+        MemMapIter {
+            index: 0,
+            current,
+            size: self.size as usize,
+            _lifetime: core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a> Iterator for MemMapIter<'a> {
+    type Item = MemoryDescriptor;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index >= self.size {
+            return None;
+        }
+        let current = unsafe { self.current.add(self.index) };
+        self.index += 1;
+        Some(unsafe { *current })
+    }
+}
+
+impl<'a> ExactSizeIterator for MemMapIter<'a> {
+    fn len(&self) -> usize {
+        self.size
+    }
 }
 
 pub type KernelMain = extern "C" fn(arg: *const KernelMainArg) -> !;
@@ -24,6 +92,16 @@ pub struct GraphicsInfo {
 }
 
 impl GraphicsInfo {
+    pub const fn uninitialized() -> Self {
+        Self {
+            horizontal_resolution: 0,
+            vertical_resolution: 0,
+            pixels_per_scan_line: 0,
+            frame_buffer_base: core::ptr::null_mut(),
+            pixcel_format: PixcelFormat::Rgb,
+        }
+    }
+
     pub fn new(
         horizontal_resolution: usize,
         vertical_resolution: usize,