slight cleanup; move memory initialization to memory::init()

src/arch/x86_64/memory/mod.rs

@@ -5,9 +5,10 @@
 mod area_frame_allocator;
 mod paging;
 
-pub use self::area_frame_allocator::AreaFrameAllocator;
+use multiboot2::BootInformation;
+use arch::x86_64;
 
-pub use self::paging::remap_kernel;
+pub use self::area_frame_allocator::AreaFrameAllocator;
 
 /// The physical size of each frame.
 pub const PAGE_SIZE: usize = 4096;
@@ -75,3 +76,38 @@ pub trait FrameAllocator {
     fn alloc_frame(&mut self) -> Option<Frame>;
     fn dealloc_frame(&mut self, frame: Frame);
 }
+
+
+pub fn init(boot_info: &BootInformation) {
+    let memory_map_tag = boot_info.memory_map_tag()
+        .expect("multiboot: Memory map tag required");
+    let elf_sections_tag = boot_info.elf_sections_tag()
+        .expect("multiboot: ELF sections tag required");
+
+    info!("memory areas:");
+    for area in memory_map_tag.memory_areas() {
+        info!("  start: 0x{:x}, length: 0x{:x}",
+            area.base_addr, area.length);
+    }
+
+    let kernel_start = elf_sections_tag.sections()
+        .filter(|s| s.is_allocated()).map(|s| s.addr).min().unwrap();
+    let kernel_end = elf_sections_tag.sections()
+        .filter(|s| s.is_allocated()).map(|s| s.addr + s.size).max().unwrap();
+
+    info!("kernel start: {:#x}, kernel end: {:#x}",
+        kernel_start, kernel_end);
+    info!("multiboot start: {:#x}, multiboot end: {:#x}",
+        boot_info.start_address(), boot_info.end_address());
+
+    let mut frame_allocator = AreaFrameAllocator::new(
+        kernel_start as usize, kernel_end as usize, boot_info.start_address(),
+        boot_info.end_address(), memory_map_tag.memory_areas());
+
+    // Enable required CPU features
+    x86_64::enable_nxe_bit(); // Enable NO_EXECUTE pages
+    x86_64::enable_wrprot_bit(); // Disable writing to non-WRITABLE pages
+
+    paging::remap_kernel(&mut frame_allocator, boot_info);
+    info!("-- kernel remapped --");
+}

src/arch/x86_64/memory/paging/mod.rs

@@ -177,7 +177,7 @@ pub fn remap_kernel<A>(allocator: &mut A, boot_info: &BootInformation)
             }
 
             assert!(section.start_address() % PAGE_SIZE == 0, "ELF sections must be page-aligned!");
-            info!("Mapping section at addr: {:#x}, size: {:#x}",
+            debug!("Mapping section at addr: {:#x}, size: {:#x}",
                 section.addr, section.size);
 
             let flags = EntryFlags::from_elf_section_flags(section);
@@ -202,30 +202,5 @@ pub fn remap_kernel<A>(allocator: &mut A, boot_info: &BootInformation)
 
     let old_table = active_table.switch(new_table);
     info!("Successfully switched to new page table.");
-}
-
-/// Temporary function to test paging
-pub fn test_paging<A>(allocator: &mut A) where A: FrameAllocator {
-    let mut page_table = unsafe {ActivePageTable::new()};
-
-    // test stuff
-
-    let addr = 42 * 515 * 515 * 4096;
-    let page = Page::containing_address(addr);
-    let frame = allocator.alloc_frame().expect("no more frames");
-    println!("vaddr->phys = {:?}, map to {:?}", page_table.translate(addr), frame);
-    page_table.map_to(page, frame, EntryFlags::empty(), allocator);
-    println!("vaddr->phys = {:?} (after mapping)", page_table.translate(addr));
-    println!("next frame: {:?}", allocator.alloc_frame());
-
-    println!("{:#x}", unsafe {
-        *(Page::containing_address(addr).start_address() as *const u64)
-    });
-
-    page_table.unmap(Page::containing_address(addr), allocator);
-    println!("vaddr->phys = {:?} (should be None)", page_table.translate(addr));
 
-    // println!("{:#x}", unsafe {
-    //     *(Page::containing_address(addr).start_address() as *const u64)
-    // });
 }

src/lib.rs

@@ -33,44 +33,8 @@ pub extern fn kernel_main(multiboot_info_pointer: usize) {
     logger::init().expect("Logger failed to launch!");
 
     let boot_info = unsafe {multiboot2::load(multiboot_info_pointer)};
-    let memory_map_tag = boot_info.memory_map_tag()
-        .expect("multiboot: Memory map tag required");
-    let elf_sections_tag = boot_info.elf_sections_tag()
-        .expect("multiboot: ELF sections tag required");
 
-    println!("memory areas:");
-    for area in memory_map_tag.memory_areas() {
-        println!("  start: 0x{:x}, length: 0x{:x}",
-            area.base_addr, area.length);
-    }
-    /*debug!("kernel sections:");
-    for section in elf_sections_tag.sections() {
-        debug!("  start: 0x{:x}, size: 0x{:x}, flags: 0x{:x}",
-            section.addr, section.size, section.flags);
-    }*/
-
-    let kernel_start = elf_sections_tag.sections().map(|s| s.addr)
-        .min().unwrap();
-    let kernel_end = elf_sections_tag.sections().map(|s| s.addr + s.size)
-        .max().unwrap();
-    let multiboot_start = multiboot_info_pointer;
-    let multiboot_end = multiboot_start + (boot_info.total_size as usize);
-    let mut frame_allocator = memory::AreaFrameAllocator::new(
-        kernel_start as usize, kernel_end as usize, multiboot_start,
-        multiboot_end, memory_map_tag.memory_areas());
-
-    println!("multiboot start: {:#x}, multiboot end: {:#x}",
-        multiboot_start, multiboot_end);
-
-    // Enable required CPU features
-    x86_64::enable_nxe_bit(); // Enable NO_EXECUTE pages
-    x86_64::enable_wrprot_bit(); // Disable writing to non-WRITABLE pages
-
-    memory::remap_kernel(&mut frame_allocator, boot_info);
-
-    println!("-- remap_kernel finished! --");
-
-    info!("{:?}", frame_allocator.alloc_frame());
+    memory::init(boot_info);
 
     loop {}
 }