From 165e6ebff8640b89a4600bb4bf7994a34e6af11c Mon Sep 17 00:00:00 2001 From: Philipp Oppermann Date: Sun, 20 Dec 2015 15:05:08 +0100 Subject: [PATCH] Run rustfmt --- src/lib.rs | 33 ++++++++++++++++-------- src/memory/area_frame_allocator.rs | 31 +++++++++++++++-------- src/memory/paging/mod.rs | 9 +++---- src/vga_buffer.rs | 40 +++++++++++++++--------------- 4 files changed, 66 insertions(+), 47 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 2ffc7daa..9d63c01c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -28,24 +28,28 @@ mod vga_buffer; mod memory; #[no_mangle] -pub extern fn rust_main(multiboot_information_address: usize) { +pub extern "C" fn rust_main(multiboot_information_address: usize) { // ATTENTION: we have a very small stack and no guard page vga_buffer::clear_screen(); println!("Hello World{}", "!"); - let boot_info = unsafe{ multiboot2::load(multiboot_information_address) }; + let boot_info = unsafe { multiboot2::load(multiboot_information_address) }; let memory_map_tag = boot_info.memory_map_tag().expect("Memory map tag required"); let elf_sections_tag = boot_info.elf_sections_tag().expect("Memory map 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); + println!(" start: 0x{:x}, length: 0x{:x}", + area.base_addr, + area.length); } println!("kernel sections:"); for section in elf_sections_tag.sections() { println!(" addr: 0x{:x}, size: 0x{:x}, flags: 0x{:x}", - section.addr, section.size, section.flags); + section.addr, + section.size, + section.flags); } let kernel_start = elf_sections_tag.sections().map(|s| s.addr).min().unwrap(); @@ -54,25 +58,32 @@ pub extern fn rust_main(multiboot_information_address: usize) { let multiboot_start = multiboot_information_address; let multiboot_end = multiboot_start + (boot_info.total_size as usize); - println!("kernel start: 0x{:x}, kernel end: 0x{:x}", kernel_start, kernel_end); - println!("multiboot start: 0x{:x}, multiboot end: 0x{:x}", multiboot_start, multiboot_end); + println!("kernel start: 0x{:x}, kernel end: 0x{:x}", + kernel_start, + kernel_end); + println!("multiboot start: 0x{:x}, multiboot end: 0x{:x}", + multiboot_start, + multiboot_end); let mut frame_allocator = memory::AreaFrameAllocator::new(kernel_start as usize, - kernel_end as usize, multiboot_start, multiboot_end, memory_map_tag.memory_areas()); + kernel_end as usize, + multiboot_start, + multiboot_end, + memory_map_tag.memory_areas()); memory::test_paging(&mut frame_allocator); - loop{} + loop {} } #[cfg(not(test))] #[lang = "eh_personality"] -extern fn eh_personality() {} +extern "C" fn eh_personality() {} #[cfg(not(test))] #[lang = "panic_fmt"] -extern fn panic_fmt(fmt: core::fmt::Arguments, file: &str, line: u32) -> ! { +extern "C" fn panic_fmt(fmt: core::fmt::Arguments, file: &str, line: u32) -> ! { println!("\n\nPANIC in {} at line {}:", file, line); println!(" {}", fmt); - loop{} + loop {} } diff --git a/src/memory/area_frame_allocator.rs b/src/memory/area_frame_allocator.rs index 99dbadc7..709a8892 100644 --- a/src/memory/area_frame_allocator.rs +++ b/src/memory/area_frame_allocator.rs @@ -17,9 +17,12 @@ pub struct AreaFrameAllocator { } impl AreaFrameAllocator { - pub fn new(kernel_start: usize, kernel_end: usize, multiboot_start: usize, multiboot_end: usize, - memory_areas: MemoryAreaIter) -> AreaFrameAllocator - { + pub fn new(kernel_start: usize, + kernel_end: usize, + multiboot_start: usize, + multiboot_end: usize, + memory_areas: MemoryAreaIter) + -> AreaFrameAllocator { let mut allocator = AreaFrameAllocator { next_free_frame: Frame::containing_address(0), current_area: None, @@ -34,10 +37,14 @@ impl AreaFrameAllocator { } fn choose_next_area(&mut self) { - self.current_area = self.areas.clone().filter(|area| { - let address = area.base_addr + area.length - 1; - Frame::containing_address(address as usize) >= self.next_free_frame - }).min_by_key(|area| area.base_addr); + self.current_area = self.areas + .clone() + .filter(|area| { + let address = area.base_addr + area.length - 1; + Frame::containing_address(address as usize) >= + self.next_free_frame + }) + .min_by_key(|area| area.base_addr); if let Some(area) = self.current_area { let start_frame = Frame::containing_address(area.base_addr as usize); @@ -53,7 +60,7 @@ impl FrameAllocator for AreaFrameAllocator { if let Some(area) = self.current_area { // "clone" the frame to return it if it's free. Frame doesn't // implement Clone, but we can construct an identical frame. - let frame = Frame{ number: self.next_free_frame.number }; + let frame = Frame { number: self.next_free_frame.number }; // the last frame of the current area let current_area_last_frame = { @@ -66,10 +73,10 @@ impl FrameAllocator for AreaFrameAllocator { self.choose_next_area(); } else if frame >= self.kernel_start && frame <= self.kernel_end { // `frame` is used by the kernel - self.next_free_frame = Frame{ number: self.kernel_end.number + 1 }; + self.next_free_frame = Frame { number: self.kernel_end.number + 1 }; } else if frame >= self.multiboot_start && frame <= self.multiboot_end { // `frame` is used by the multiboot information structure - self.next_free_frame = Frame{ number: self.multiboot_end.number + 1 }; + self.next_free_frame = Frame { number: self.multiboot_end.number + 1 }; } else { // frame is unused, increment `next_free_frame` and return it self.next_free_frame.number += 1; @@ -82,5 +89,7 @@ impl FrameAllocator for AreaFrameAllocator { } } - fn deallocate_frame(&mut self, _frame: Frame) {unimplemented!()} + fn deallocate_frame(&mut self, _frame: Frame) { + unimplemented!() + } } diff --git a/src/memory/paging/mod.rs b/src/memory/paging/mod.rs index 3477ad88..2263a530 100644 --- a/src/memory/paging/mod.rs +++ b/src/memory/paging/mod.rs @@ -139,9 +139,9 @@ impl RecursivePageTable { .expect("mapping code does not support huge pages"); let frame = p1[page.p1_index()].pointed_frame().unwrap(); p1[page.p1_index()].set_unused(); - unsafe { ::x86::tlb::flush(page.start_address() )}; + unsafe { ::x86::tlb::flush(page.start_address()) }; // TODO free p(1,2,3) table if empty - //allocator.deallocate_frame(frame); + // allocator.deallocate_frame(frame); } } @@ -170,9 +170,8 @@ pub fn test_paging(allocator: &mut A) println!("next free frame: {:?}", allocator.allocate_frame()); // test unmap - println!("{:#x}", unsafe { - *(Page::containing_address(addr).start_address() as *const u64) - }); + println!("{:#x}", + unsafe { *(Page::containing_address(addr).start_address() as *const u64) }); page_table.unmap(Page::containing_address(addr), allocator); println!("None = {:?}", page_table.translate(addr)); } diff --git a/src/vga_buffer.rs b/src/vga_buffer.rs index af5fa8cf..65e5352a 100644 --- a/src/vga_buffer.rs +++ b/src/vga_buffer.rs @@ -22,7 +22,7 @@ const BUFFER_WIDTH: usize = 80; pub static WRITER: Mutex = Mutex::new(Writer { column_position: 0, color_code: ColorCode::new(Color::LightGreen, Color::Black), - buffer: unsafe{Unique::new(0xb8000 as *mut _)}, + buffer: unsafe { Unique::new(0xb8000 as *mut _) }, }); macro_rules! println { @@ -46,22 +46,22 @@ pub fn clear_screen() { #[allow(dead_code)] #[repr(u8)] pub enum Color { - Black = 0, - Blue = 1, - Green = 2, - Cyan = 3, - Red = 4, - Magenta = 5, - Brown = 6, - LightGray = 7, - DarkGray = 8, - LightBlue = 9, + Black = 0, + Blue = 1, + Green = 2, + Cyan = 3, + Red = 4, + Magenta = 5, + Brown = 6, + LightGray = 7, + DarkGray = 8, + LightBlue = 9, LightGreen = 10, - LightCyan = 11, - LightRed = 12, - Pink = 13, - Yellow = 14, - White = 15, + LightCyan = 11, + LightRed = 12, + Pink = 13, + Yellow = 14, + White = 15, } pub struct Writer { @@ -91,15 +91,15 @@ impl Writer { } fn buffer(&mut self) -> &mut Buffer { - unsafe{self.buffer.get_mut()} + unsafe { self.buffer.get_mut() } } fn new_line(&mut self) { - for row in 0..(BUFFER_HEIGHT-1) { + for row in 0..(BUFFER_HEIGHT - 1) { let buffer = self.buffer(); buffer.chars[row] = buffer.chars[row + 1] } - self.clear_row(BUFFER_HEIGHT-1); + self.clear_row(BUFFER_HEIGHT - 1); self.column_position = 0; } @@ -115,7 +115,7 @@ impl Writer { impl fmt::Write for Writer { fn write_str(&mut self, s: &str) -> ::core::fmt::Result { for byte in s.bytes() { - self.write_byte(byte) + self.write_byte(byte) } Ok(()) }