Update to new x86_64 and os_bootinfo versions (rust-osdev#11)

Author: phil-opp

Cargo.lock

@@ -7,9 +7,9 @@ description = "An experimental pure-Rust x86 bootloader."
 
 [dependencies]
 xmas-elf = "0.6.2"
-x86_64 = "0.2.0-alpha"
+x86_64 = { git = "https://github.com/rust-osdev/x86_64" }
 usize_conversions = "0.2.0"
-os_bootinfo = "0.2.0-alpha"
+os_bootinfo = { git = "https://github.com/rust-osdev/os_bootinfo" }
 fixedvec = "0.2.3"
 
 [profile.dev]

Cargo.toml

@@ -19,9 +19,9 @@ pub(crate) fn create_from(memory_map_addr: VirtAddr, entry_count: u64) -> Memory
     let mut iter = memory_map.iter_mut().peekable();
     while let Some(region) = iter.next() {
         if let Some(next) = iter.peek() {
-            if region.range.end > next.range.start {
+            if region.range.end_frame_number > next.range.start_frame_number {
                 if region.region_type == MemoryRegionType::Usable {
-                    region.range.end = next.range.start;
+                    region.range.end_frame_number = next.range.start_frame_number;
                 } else {
                     panic!("two non-usable regions overlap: {:?} {:?}", region, next);
                 }

src/boot_info.rs

@@ -12,13 +12,13 @@ impl<'a> FrameAllocator<'a> {
         while let Some(region) = iter.next() {
             if region.region_type == region_type {
                 if let Some(next) = iter.peek() {
-                    if next.range.start == region.range.end
+                    if next.range.start_frame_number == region.range.end_frame_number
                         && next.region_type == MemoryRegionType::Usable
                         && !next.range.is_empty()
                     {
-                        let frame = region.range.end;
-                        region.range.end += 1;
-                        iter.next().unwrap().range.start += 1;
+                        let frame = PhysFrameRange::from(region.range).end;
+                        region.range.end_frame_number += 1;
+                        iter.next().unwrap().range.start_frame_number += 1;
                         return Some(frame);
                     }
                 }
@@ -37,8 +37,8 @@ impl<'a> FrameAllocator<'a> {
                     continue;
                 }
 
-                let frame = region.range.start;
-                region.range.start += 1;
+                let frame = PhysFrameRange::from(region.range).start;
+                region.range.start_frame_number += 1;
                 return Some((frame, PhysFrame::range(frame, frame + 1)));
             }
             None
@@ -53,7 +53,7 @@ impl<'a> FrameAllocator<'a> {
 
         if let Some((frame, range)) = result {
             self.memory_map
-                .add_region(MemoryRegion { range, region_type });
+                .add_region(MemoryRegion { range: range.into(), region_type });
             Some(frame)
         } else {
             None
@@ -65,10 +65,10 @@ impl<'a> FrameAllocator<'a> {
     /// Panics if a non-usable region (e.g. a reserved region) overlaps with the passed region.
     pub(crate) fn mark_allocated_region(&mut self, region: MemoryRegion) {
         for r in self.memory_map.iter_mut() {
-            if region.range.start >= r.range.end {
+            if region.range.start_frame_number >= r.range.end_frame_number {
                 continue;
             }
-            if region.range.end <= r.range.start {
+            if region.range.end_frame_number <= r.range.start_frame_number {
                 continue;
             }
 
@@ -79,42 +79,42 @@ impl<'a> FrameAllocator<'a> {
                 );
             }
 
-            if region.range.start == r.range.start {
-                if region.range.end < r.range.end {
+            if region.range.start_frame_number == r.range.start_frame_number {
+                if region.range.end_frame_number < r.range.end_frame_number {
                     // Case: (r = `r`, R = `region`)
                     // ----rrrrrrrrrrr----
                     // ----RRRR-----------
-                    r.range.start = region.range.end;
+                    r.range.start_frame_number = region.range.end_frame_number;
                     self.memory_map.add_region(region);
                 } else {
                     // Case: (r = `r`, R = `region`)
                     // ----rrrrrrrrrrr----
                     // ----RRRRRRRRRRRRRR-
                     *r = region;
                 }
-            } else if region.range.start > r.range.start {
-                if region.range.end < r.range.end {
+            } else if region.range.start_frame_number > r.range.start_frame_number {
+                if region.range.end_frame_number < r.range.end_frame_number {
                     // Case: (r = `r`, R = `region`)
                     // ----rrrrrrrrrrr----
                     // ------RRRR---------
                     let mut behind_r = r.clone();
-                    behind_r.range.start = region.range.end;
-                    r.range.end = region.range.start;
+                    behind_r.range.start_frame_number = region.range.end_frame_number;
+                    r.range.end_frame_number = region.range.start_frame_number;
                     self.memory_map.add_region(behind_r);
                     self.memory_map.add_region(region);
                 } else {
                     // Case: (r = `r`, R = `region`)
                     // ----rrrrrrrrrrr----
                     // -----------RRRR---- or
                     // -------------RRRR--
-                    r.range.end = region.range.start;
+                    r.range.end_frame_number = region.range.start_frame_number;
                     self.memory_map.add_region(region);
                 }
             } else {
                 // Case: (r = `r`, R = `region`)
                 // ----rrrrrrrrrrr----
                 // --RRRR-------------
-                r.range.start = region.range.end;
+                r.range.start_frame_number = region.range.end_frame_number;
                 self.memory_map.add_region(region);
             }
             return;

src/frame_allocator.rs

@@ -118,39 +118,41 @@ pub extern "C" fn load_elf(
         memory_map: &mut memory_map,
     };
 
+
     // Mark already used memory areas in frame allocator.
     {
         let zero_frame: PhysFrame = PhysFrame::from_start_address(PhysAddr::new(0)).unwrap();
         frame_allocator.mark_allocated_region(MemoryRegion {
-            range: PhysFrame::range(zero_frame, zero_frame + 1),
+            range: PhysFrame::range(zero_frame, zero_frame + 1).into(),
             region_type: MemoryRegionType::FrameZero,
         });
         let bootloader_start_frame = PhysFrame::containing_address(bootloader_start);
         let bootloader_end_frame = PhysFrame::containing_address(bootloader_end - 1u64);
         let bootloader_memory_area =
             PhysFrame::range(bootloader_start_frame, bootloader_end_frame + 1);
         frame_allocator.mark_allocated_region(MemoryRegion {
-            range: bootloader_memory_area,
+            range: bootloader_memory_area.into(),
             region_type: MemoryRegionType::Bootloader,
         });
         let kernel_start_frame = PhysFrame::containing_address(kernel_start.phys());
         let kernel_end_frame =
             PhysFrame::containing_address(kernel_start.phys() + kernel_size - 1u64);
         let kernel_memory_area = PhysFrame::range(kernel_start_frame, kernel_end_frame + 1);
         frame_allocator.mark_allocated_region(MemoryRegion {
-            range: kernel_memory_area,
+            range: kernel_memory_area.into(),
             region_type: MemoryRegionType::Kernel,
         });
         let page_table_start_frame = PhysFrame::containing_address(page_table_start);
         let page_table_end_frame = PhysFrame::containing_address(page_table_end - 1u64);
         let page_table_memory_area =
             PhysFrame::range(page_table_start_frame, page_table_end_frame + 1);
         frame_allocator.mark_allocated_region(MemoryRegion {
-            range: page_table_memory_area,
+            range: page_table_memory_area.into(),
             region_type: MemoryRegionType::PageTable,
         });
     }
 
+
     // Unmap the ELF file.
     let kernel_start_page: Page<Size2MB> = Page::containing_address(kernel_start.virt());
     let kernel_end_page: Page<Size2MB> =
@@ -187,7 +189,7 @@ pub extern "C" fn load_elf(
     };
 
     // Construct boot info structure.
-    let mut boot_info = BootInfo::new(page_table, memory_map);
+    let mut boot_info = BootInfo::new(recursive_page_table_addr.start_address().as_u64(), memory_map);
     boot_info.memory_map.sort();
 
     // Write boot info to boot info page.