Read and cache required ELF info at the start

Author: phil-opp

Cargo.toml

@@ -7,11 +7,12 @@ description = "An experimental pure-Rust x86 bootloader."
 
 [dependencies]
 rlibc = "1"
-xmas-elf = "0.6.0"
+xmas-elf = { git = "https://github.com/phil-opp/xmas-elf.git" }
 x86_64 = "0.2.0-alpha-001"
 usize_conversions = "0.2.0"
 os_bootinfo = "0.2.0-alpha"
 spin = "0.4.6"
+fixedvec = "0.2.3"
 
 [profile.dev]
 panic = "abort"

src/main.rs

@@ -17,6 +17,8 @@ extern crate x86_64;
 extern crate usize_conversions;
 extern crate os_bootinfo;
 extern crate spin;
+#[macro_use]
+extern crate fixedvec;
 
 pub use x86_64::PhysAddr;
 use x86_64::VirtAddr;
@@ -44,10 +46,32 @@ mod printer;
 pub extern "C" fn load_elf(kernel_start: PhysAddr, kernel_size: u64,
     memory_map_addr: VirtAddr, memory_map_entry_count: u64) -> !
 {
-    let kernel_start_ptr = usize_from(kernel_start.as_u64()) as *const u8;
-    let kernel = unsafe { slice::from_raw_parts(kernel_start_ptr, usize_from(kernel_size)) };
-    let elf_file = xmas_elf::ElfFile::new(kernel).unwrap();
-    xmas_elf::header::sanity_check(&elf_file).unwrap();
+    use fixedvec::FixedVec;
+    use xmas_elf::program::{ProgramHeader, ProgramHeader64};
+
+    let mut preallocated_space = alloc_stack!([ProgramHeader64; 32]);
+    let mut segments = FixedVec::new(&mut preallocated_space);
+    let entry_point;
+
+    {
+        let kernel_start_ptr = usize_from(kernel_start.as_u64()) as *const u8;
+        let kernel = unsafe { slice::from_raw_parts(kernel_start_ptr, usize_from(kernel_size)) };
+        let elf_file = xmas_elf::ElfFile::new(kernel).unwrap();
+        xmas_elf::header::sanity_check(&elf_file).unwrap();
+
+        entry_point = elf_file.header.pt2.entry_point();
+
+        for program_header in elf_file.program_iter() {
+            match program_header {
+                ProgramHeader::Ph64(header) => {
+                    segments.push(*header).expect("does not support more than 32 program segments")
+                },
+                ProgramHeader::Ph32(_) => panic!("does not support 32 bit elf files"),
+            }
+        }
+    }
+
+
 
     // idea: embed memory map in frame allocator and mark allocated frames as used
     let mut memory_map = boot_info::create_from(memory_map_addr, memory_map_entry_count);
@@ -61,7 +85,7 @@ pub extern "C" fn load_elf(kernel_start: PhysAddr, kernel_size: u64,
     let p4 = unsafe { &mut *(usize_from(p4_addr.as_u64()) as *const PageTable as *mut PageTable) };
     p4.zero();
 
-    let stack_end = page_table::map_kernel(kernel_start, &elf_file, p4, &mut frame_allocator);
+    let stack_end = page_table::map_kernel(kernel_start, &segments, p4, &mut frame_allocator);
 
     let boot_info_page = Page::containing_address(VirtAddr::new(0x1000));
     let boot_info_frame = frame_allocator.allocate_frame();
@@ -96,7 +120,7 @@ pub extern "C" fn load_elf(kernel_start: PhysAddr, kernel_size: u64,
     enable_nxe_bit();
     enable_write_protect_bit();
 
-    let entry_point = VirtAddr::new(elf_file.header.pt2.entry_point());
+    let entry_point = VirtAddr::new(entry_point);
     printer::PRINTER.lock().clear_screen();
     unsafe { context_switch(p4_addr, entry_point, stack_end, boot_info_addr) };
 }

src/page_table.rs

@@ -2,14 +2,14 @@ use frame_allocator::FrameAllocator;
 use x86_64::{PhysAddr, VirtAddr, align_up};
 use x86_64::structures::paging::{PAGE_SIZE, PageTable, PageTableFlags, PageTableEntry, Page, PhysFrame};
 use usize_conversions::usize_from;
-use xmas_elf;
-use xmas_elf::program::{self, ProgramHeader};
+use xmas_elf::program::{self, ProgramHeader64};
+use fixedvec::FixedVec;
 
-pub(crate) fn map_kernel(kernel_start: PhysAddr, elf_file: &xmas_elf::ElfFile, p4: &mut PageTable,
-    frame_allocator: &mut FrameAllocator) -> VirtAddr
+pub(crate) fn map_kernel(kernel_start: PhysAddr, segments: &FixedVec<ProgramHeader64>,
+    p4: &mut PageTable, frame_allocator: &mut FrameAllocator) -> VirtAddr
 {
-    for program_header in elf_file.program_iter() {
-        map_segment(kernel_start, program_header, p4, frame_allocator);
+    for segment in segments {
+        map_segment(segment, kernel_start, p4, frame_allocator);
     }
 
     // create a stack
@@ -35,24 +35,24 @@ pub(crate) fn identity_map(frame: PhysFrame, flags: PageTableFlags, p4: &mut Pag
     map_page(page, frame, flags, p4, frame_allocator);
 }
 
-pub(crate) fn map_segment(kernel_start: PhysAddr, program_header: ProgramHeader, p4: &mut PageTable,
+pub(crate) fn map_segment(segment: &ProgramHeader64, kernel_start: PhysAddr, p4: &mut PageTable,
     frame_allocator: &mut FrameAllocator)
 {
     unsafe fn zero_frame(frame: &PhysFrame) {
         let frame_ptr = frame.start_address().as_u64() as *mut [u8; PAGE_SIZE as usize];
         *frame_ptr = [0; PAGE_SIZE as usize];
     }
 
-    let typ = program_header.get_type().unwrap();
+    let typ = segment.get_type().unwrap();
     match typ {
         program::Type::Load => {
-            let mem_size = program_header.mem_size();
-            let file_size = program_header.file_size();
-            let file_offset = program_header.offset();
+            let mem_size = segment.mem_size();
+            let file_size = segment.file_size();
+            let file_offset = segment.offset();
             let phys_start_addr = kernel_start + file_offset;
-            let virt_start_addr = VirtAddr::new(program_header.virtual_addr());
+            let virt_start_addr = VirtAddr::new(segment.virtual_addr());
 
-            let flags = program_header.flags();
+            let flags = segment.flags();
             let mut page_table_flags = PageTableFlags::PRESENT;
             if !flags.is_execute() { page_table_flags |= PageTableFlags::NO_EXECUTE };
             if flags.is_write() { page_table_flags |= PageTableFlags::WRITABLE };