Run rustfmt

Author: phil-opp

src/frame_allocator.rs

@@ -12,7 +12,10 @@ 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 && next.region_type == MemoryRegionType::Usable && !next.range.is_empty() {
+                    if next.range.start == region.range.end
+                        && next.region_type == MemoryRegionType::Usable
+                        && !next.range.is_empty()
+                    {
                         let frame = region.range.end;
                         region.range.end += 1;
                         iter.next().unwrap().range.start += 1;
@@ -49,7 +52,8 @@ impl<'a> FrameAllocator<'a> {
         };
 
         if let Some((frame, range)) = result {
-            self.memory_map.add_region(MemoryRegion { range, region_type, });
+            self.memory_map
+                .add_region(MemoryRegion { range, region_type });
             Some(frame)
         } else {
             None
@@ -62,14 +66,17 @@ impl<'a> FrameAllocator<'a> {
     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 {
-                continue
+                continue;
             }
             if region.range.end <= r.range.start {
-                continue
+                continue;
             }
 
             if r.region_type != MemoryRegionType::Usable {
-                panic!("region {:x?} overlaps with non-usable region {:x?}", region, r);
+                panic!(
+                    "region {:x?} overlaps with non-usable region {:x?}",
+                    region, r
+                );
             }
 
             if region.range.start == r.range.start {

src/main.rs

@@ -21,12 +21,12 @@ extern crate fixedvec;
 use core::slice;
 use os_bootinfo::BootInfo;
 use usize_conversions::usize_from;
-pub use x86_64::PhysAddr;
-use x86_64::{VirtAddr};
 use x86_64::instructions::tlb;
-use x86_64::structures::paging::{RecursivePageTable, Mapper};
-use x86_64::structures::paging::{Page, PhysFrame, PageTableFlags, Size2MB};
+use x86_64::structures::paging::{Mapper, RecursivePageTable};
+use x86_64::structures::paging::{Page, PageTableFlags, PhysFrame, Size2MB};
 use x86_64::ux::u9;
+pub use x86_64::PhysAddr;
+use x86_64::VirtAddr;
 
 global_asm!(include_str!("boot.s"));
 global_asm!(include_str!("second_stage.s"));
@@ -119,7 +119,6 @@ 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();
@@ -129,21 +128,24 @@ pub extern "C" fn load_elf(
         });
         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);
+        let bootloader_memory_area =
+            PhysFrame::range(bootloader_start_frame, bootloader_end_frame + 1);
         frame_allocator.mark_allocated_region(MemoryRegion {
             range: bootloader_memory_area,
             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_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,
             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);
+        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,
             region_type: MemoryRegionType::PageTable,
@@ -152,9 +154,12 @@ pub extern "C" fn load_elf(
 
     // Unmap the ELF file.
     let kernel_start_page: Page<Size2MB> = Page::containing_address(kernel_start.virt());
-    let kernel_end_page: Page<Size2MB> = Page::containing_address(kernel_start.virt() + kernel_size - 1u64);
+    let kernel_end_page: Page<Size2MB> =
+        Page::containing_address(kernel_start.virt() + kernel_size - 1u64);
     for page in Page::range_inclusive(kernel_start_page, kernel_end_page) {
-        rec_page_table.unmap(page, &mut |_| {}).expect("dealloc error");
+        rec_page_table
+            .unmap(page, &mut |_| {})
+            .expect("dealloc error");
     }
     // Flush the translation lookaside buffer since we changed the active mapping.
     tlb::flush_all();

src/page_table.rs

@@ -3,7 +3,7 @@ use frame_allocator::FrameAllocator;
 use os_bootinfo::MemoryRegionType;
 use x86_64::instructions::tlb;
 use x86_64::structures::paging::{MapToError, RecursivePageTable, UnmapError};
-use x86_64::structures::paging::{Page, PageTableFlags, PhysFrame, Mapper, PageSize, Size4KB};
+use x86_64::structures::paging::{Mapper, Page, PageSize, PageTableFlags, PhysFrame, Size4KB};
 use x86_64::{align_up, PhysAddr, VirtAddr};
 use xmas_elf::program::{self, ProgramHeader64};