Run rustfmt

Author: phil-opp

src/boot_info.rs

@@ -1,14 +1,13 @@
 use core::slice;
 
-use x86_64::VirtAddr;
+use os_bootinfo::{E820MemoryRegion, MemoryMap, MemoryRegion};
 use usize_conversions::usize_from;
-use os_bootinfo::{MemoryMap, MemoryRegion, E820MemoryRegion};
+use x86_64::VirtAddr;
 
 pub(crate) fn create_from(memory_map_addr: VirtAddr, entry_count: u64) -> MemoryMap {
     let memory_map_start_ptr = usize_from(memory_map_addr.as_u64()) as *const E820MemoryRegion;
-    let e820_memory_map = unsafe {
-        slice::from_raw_parts(memory_map_start_ptr, usize_from(entry_count))
-    };
+    let e820_memory_map =
+        unsafe { slice::from_raw_parts(memory_map_start_ptr, usize_from(entry_count)) };
 
     let mut memory_map = MemoryMap::new();
     for region in e820_memory_map {

src/frame_allocator.rs

@@ -1,5 +1,5 @@
-use x86_64::structures::paging::{PAGE_SIZE, PhysFrame};
 use os_bootinfo::{MemoryMap, MemoryRegion, MemoryRegionType};
+use x86_64::structures::paging::{PhysFrame, PAGE_SIZE};
 
 pub(crate) struct FrameAllocator<'a> {
     pub memory_map: &'a mut MemoryMap,
@@ -16,8 +16,12 @@ impl<'a> FrameAllocator<'a> {
             if region.len < page_size {
                 continue;
             }
-            assert_eq!(0, region.start_addr.as_u64() & 0xfff,
-                "Region start address is not page aligned: {:?}", region);
+            assert_eq!(
+                0,
+                region.start_addr.as_u64() & 0xfff,
+                "Region start address is not page aligned: {:?}",
+                region
+            );
 
             frame = Some(PhysFrame::containing_address(region.start_addr));
             region.start_addr += page_size;
@@ -28,7 +32,7 @@ impl<'a> FrameAllocator<'a> {
             self.add_region(MemoryRegion {
                 start_addr: frame.start_address(),
                 len: page_size,
-                region_type
+                region_type,
             });
             Some(frame)
         } else {
@@ -38,26 +42,32 @@ impl<'a> FrameAllocator<'a> {
 
     pub(crate) fn deallocate_frame(&mut self, frame: PhysFrame) {
         let page_size = u64::from(PAGE_SIZE);
-        self.add_region_overwrite(MemoryRegion {
-            start_addr: frame.start_address(),
-            len: page_size,
-            region_type: MemoryRegionType::Usable,
-        }, true);
+        self.add_region_overwrite(
+            MemoryRegion {
+                start_addr: frame.start_address(),
+                len: page_size,
+                region_type: MemoryRegionType::Usable,
+            },
+            true,
+        );
     }
 
     /// Adds the passed region to the memory map.
     ///
     /// This function automatically adjusts the existing regions so that no overlap occurs.
     ///
     /// Panics if a non-usable region (e.g. a reserved region) overlaps with the passed region.
-    pub(crate) fn add_region(&mut self, region: MemoryRegion)
-    {
+    pub(crate) fn add_region(&mut self, region: MemoryRegion) {
         self.add_region_overwrite(region, false);
     }
 
     fn add_region_overwrite(&mut self, region: MemoryRegion, overwrite: bool) {
-        assert_eq!(0, region.start_addr.as_u64() & 0xfff,
-            "Region start address is not page aligned: {:?}", region);
+        assert_eq!(
+            0,
+            region.start_addr.as_u64() & 0xfff,
+            "Region start address is not page aligned: {:?}",
+            region
+        );
 
         let mut region_already_inserted = false;
         let mut split_region = None;
@@ -69,12 +79,16 @@ impl<'a> FrameAllocator<'a> {
                 match r.region_type {
                     MemoryRegionType::Usable => {
                         if region.region_type == MemoryRegionType::Usable {
-                            panic!("region {:?} overlaps with other usable region {:?}", region, r)
+                            panic!(
+                                "region {:?} overlaps with other usable region {:?}",
+                                region, r
+                            )
                         }
                     }
-                    MemoryRegionType::InUse => {},
-                    MemoryRegionType::Bootloader | MemoryRegionType::Kernel
-                        | MemoryRegionType::PageTable if overwrite => {}
+                    MemoryRegionType::InUse => {}
+                    MemoryRegionType::Bootloader
+                    | MemoryRegionType::Kernel
+                    | MemoryRegionType::PageTable if overwrite => {}
                     _ => {
                         panic!("can't override region {:?} with {:?}", r, region);
                     }
@@ -84,7 +98,10 @@ impl<'a> FrameAllocator<'a> {
                     // ----rrrrrrrrrrr----
                     // ------RRRR---------
                     r.len = region.start_addr() - r.start_addr();
-                    assert!(split_region.is_none(), "area overlaps with multiple regions");
+                    assert!(
+                        split_region.is_none(),
+                        "area overlaps with multiple regions"
+                    );
                     split_region = Some(MemoryRegion {
                         start_addr: region.end_addr(),
                         len: r.end_addr() - region.end_addr(),
@@ -94,8 +111,8 @@ impl<'a> FrameAllocator<'a> {
                     // Case: (r = `r`, R = `region`)
                     // ----rrrrrrrrrrr----
                     // --RRRR-------------
-                        r.len -= region.end_addr() - r.start_addr();
-                        r.start_addr = region.end_addr();
+                    r.len -= region.end_addr() - r.start_addr();
+                    r.start_addr = region.end_addr();
                 } else if region.end_addr() >= r.end_addr() {
                     // Case: (r = `r`, R = `region`)
                     // ----rrrrrrrrrrr----

src/main.rs

@@ -8,27 +8,26 @@
 #![feature(pointer_methods)]
 #![feature(const_fn)]
 #![feature(nll)]
-
 #![no_std]
 #![no_main]
 
-extern crate xmas_elf;
-extern crate x86_64;
-extern crate usize_conversions;
 extern crate os_bootinfo;
 extern crate spin;
+extern crate usize_conversions;
+extern crate x86_64;
+extern crate xmas_elf;
 #[macro_use]
 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::ux::u9;
-use x86_64::structures::paging::{PAGE_SIZE, PageTableFlags, Page};
-use x86_64::structures::paging::RecursivePageTable;
 use x86_64::instructions::tlb;
-use core::slice;
-use usize_conversions::usize_from;
-use os_bootinfo::BootInfo;
+use x86_64::structures::paging::RecursivePageTable;
+use x86_64::structures::paging::{Page, PageTableFlags, PAGE_SIZE};
+use x86_64::ux::u9;
 
 global_asm!(include_str!("boot.s"));
 global_asm!(include_str!("second_stage.s"));
@@ -40,8 +39,8 @@ extern "C" {
 }
 
 mod boot_info;
-mod page_table;
 mod frame_allocator;
+mod page_table;
 mod printer;
 
 pub struct IdentityMappedAddr(PhysAddr);
@@ -61,15 +60,19 @@ impl IdentityMappedAddr {
 }
 
 #[no_mangle]
-pub extern "C" fn load_elf(kernel_start: IdentityMappedAddr, kernel_size: u64,
-        memory_map_addr: VirtAddr, memory_map_entry_count: u64,
-        page_table_start: PhysAddr, page_table_end: PhysAddr,
-        bootloader_start: PhysAddr, bootloader_end: PhysAddr,
-    ) -> !
-{
+pub extern "C" fn load_elf(
+    kernel_start: IdentityMappedAddr,
+    kernel_size: u64,
+    memory_map_addr: VirtAddr,
+    memory_map_entry_count: u64,
+    page_table_start: PhysAddr,
+    page_table_end: PhysAddr,
+    bootloader_start: PhysAddr,
+    bootloader_end: PhysAddr,
+) -> ! {
     use fixedvec::FixedVec;
-    use xmas_elf::program::{ProgramHeader, ProgramHeader64};
     use os_bootinfo::{MemoryRegion, MemoryRegionType};
+    use xmas_elf::program::{ProgramHeader, ProgramHeader64};
 
     let mut memory_map = boot_info::create_from(memory_map_addr, memory_map_entry_count);
 
@@ -87,9 +90,9 @@ pub extern "C" fn load_elf(kernel_start: IdentityMappedAddr, kernel_size: u64,
 
         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::Ph64(header) => segments
+                    .push(*header)
+                    .expect("does not support more than 32 program segments"),
                 ProgramHeader::Ph32(_) => panic!("does not support 32 bit elf files"),
             }
         }
@@ -100,14 +103,20 @@ pub extern "C" fn load_elf(kernel_start: IdentityMappedAddr, kernel_size: u64,
 
     // Create a RecursivePageTable
     let recursive_index = u9::new(511);
-    let recursive_page_table_addr = Page::from_page_table_indices(recursive_index,
-        recursive_index, recursive_index, recursive_index);
+    let recursive_page_table_addr = Page::from_page_table_indices(
+        recursive_index,
+        recursive_index,
+        recursive_index,
+        recursive_index,
+    );
     let page_table = unsafe { &mut *(recursive_page_table_addr.start_address().as_mut_ptr()) };
-    let mut rec_page_table = RecursivePageTable::new(page_table)
-        .expect("recursive page table creation failed");
+    let mut rec_page_table =
+        RecursivePageTable::new(page_table).expect("recursive page table creation failed");
 
     // Create a frame allocator, which marks allocated frames as used in the memory map.
-    let mut frame_allocator = frame_allocator::FrameAllocator{ memory_map:&mut memory_map };
+    let mut frame_allocator = frame_allocator::FrameAllocator {
+        memory_map: &mut memory_map,
+    };
 
     // Mark already used memory areas in frame allocator.
     {
@@ -117,15 +126,18 @@ pub extern "C" fn load_elf(kernel_start: IdentityMappedAddr, kernel_size: u64,
             region_type: MemoryRegionType::Kernel,
         });
         frame_allocator.add_region(MemoryRegion {
-            start_addr: page_table_start, len: page_table_end - page_table_start,
+            start_addr: page_table_start,
+            len: page_table_end - page_table_start,
             region_type: MemoryRegionType::PageTable,
         });
         frame_allocator.add_region(MemoryRegion {
-            start_addr: bootloader_start, len: bootloader_end - bootloader_start,
+            start_addr: bootloader_start,
+            len: bootloader_end - bootloader_start,
             region_type: MemoryRegionType::Bootloader,
         });
         frame_allocator.add_region(MemoryRegion {
-            start_addr: PhysAddr::new(0), len: u64::from(PAGE_SIZE),
+            start_addr: PhysAddr::new(0),
+            len: u64::from(PAGE_SIZE),
             region_type: MemoryRegionType::FrameZero,
         });
     }
@@ -134,25 +146,37 @@ pub extern "C" fn load_elf(kernel_start: IdentityMappedAddr, kernel_size: u64,
     let kernel_start_page = Page::containing_address(kernel_start.virt());
     let kernel_end_page = Page::containing_address(kernel_start.virt() + kernel_size - 1u64);
     for page in Page::range_inclusive(kernel_start_page, kernel_end_page).step_by(512) {
-        rec_page_table.unmap(page, &mut |frame| {
-            frame_allocator.deallocate_frame(frame);
-        }).expect("dealloc error");
+        rec_page_table
+            .unmap(page, &mut |frame| {
+                frame_allocator.deallocate_frame(frame);
+            })
+            .expect("dealloc error");
     }
     // Flush the translation lookaside buffer since we changed the active mapping.
     tlb::flush_all();
 
     // Map kernel segments.
-    let stack_end = page_table::map_kernel(kernel_start.phys(), &segments, &mut rec_page_table,
-        &mut frame_allocator).expect("kernel mapping failed");
+    let stack_end = page_table::map_kernel(
+        kernel_start.phys(),
+        &segments,
+        &mut rec_page_table,
+        &mut frame_allocator,
+    ).expect("kernel mapping failed");
 
     // Map a page for the boot info structure
     let boot_info_page = {
         let page = Page::containing_address(VirtAddr::new(0xb0071f0000));
-        let frame = frame_allocator.allocate_frame(MemoryRegionType::Bootloader)
+        let frame = frame_allocator
+            .allocate_frame(MemoryRegionType::Bootloader)
             .expect("frame allocation failed");
         let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-        page_table::map_page(page, frame, flags,
-            &mut rec_page_table, &mut frame_allocator).expect("Mapping of bootinfo page failed");
+        page_table::map_page(
+            page,
+            frame,
+            flags,
+            &mut rec_page_table,
+            &mut frame_allocator,
+        ).expect("Mapping of bootinfo page failed");
         page
     };
 
@@ -162,7 +186,7 @@ pub extern "C" fn load_elf(kernel_start: IdentityMappedAddr, kernel_size: u64,
 
     // Write boot info to boot info page.
     let boot_info_addr = boot_info_page.start_address();
-    unsafe {boot_info_addr.as_mut_ptr::<BootInfo>().write(boot_info)};
+    unsafe { boot_info_addr.as_mut_ptr::<BootInfo>().write(boot_info) };
 
     // Make sure that the kernel respects the write-protection bits, even when in ring 0.
     enable_write_protect_bit();
@@ -175,7 +199,7 @@ pub extern "C" fn load_elf(kernel_start: IdentityMappedAddr, kernel_size: u64,
 
 fn enable_nxe_bit() {
     use x86_64::registers::control::{Efer, EferFlags};
-    unsafe { Efer::update(|efer| *efer |= EferFlags::NO_EXECUTE_ENABLE)}
+    unsafe { Efer::update(|efer| *efer |= EferFlags::NO_EXECUTE_ENABLE) }
 }
 
 fn enable_write_protect_bit() {
@@ -185,10 +209,12 @@ fn enable_write_protect_bit() {
 
 #[lang = "panic_fmt"]
 #[no_mangle]
-pub extern fn rust_begin_panic(msg: core::fmt::Arguments,
-                               _file: &'static str,
-                               _line: u32,
-                               _column: u32) -> ! {
+pub extern "C" fn rust_begin_panic(
+    msg: core::fmt::Arguments,
+    _file: &'static str,
+    _line: u32,
+    _column: u32,
+) -> ! {
     use core::fmt::Write;
     write!(printer::PRINTER.lock(), "PANIC: {}", msg).unwrap();
 
@@ -197,7 +223,11 @@ pub extern fn rust_begin_panic(msg: core::fmt::Arguments,
 
 #[lang = "eh_personality"]
 #[no_mangle]
-pub extern fn eh_personality() { loop {} }
+pub extern "C" fn eh_personality() {
+    loop {}
+}
 
 #[no_mangle]
-pub extern fn _Unwind_Resume() { loop {} }
+pub extern "C" fn _Unwind_Resume() {
+    loop {}
+}