From fadc203e4adf86b80b669c4cb65f52aaf15a2662 Mon Sep 17 00:00:00 2001 From: Yifan Wu Date: Fri, 21 Jan 2022 14:23:53 -0800 Subject: [PATCH] cargo clippy & fmt --- os/build.rs | 20 ++-- os/src/console.rs | 4 +- os/src/lang_items.rs | 9 +- os/src/loader.rs | 14 +-- os/src/main.rs | 16 ++- os/src/mm/address.rs | 132 +++++++++++++++-------- os/src/mm/frame_allocator.rs | 39 +++---- os/src/mm/heap_allocator.rs | 2 +- os/src/mm/memory_set.rs | 203 +++++++++++++++++++++-------------- os/src/mm/mod.rs | 16 +-- os/src/mm/page_table.rs | 16 +-- os/src/sbi.rs | 1 - os/src/sync/mod.rs | 2 +- os/src/sync/up.rs | 6 +- os/src/syscall/fs.rs | 4 +- os/src/syscall/mod.rs | 1 - os/src/syscall/process.rs | 7 +- os/src/task/context.rs | 1 - os/src/task/mod.rs | 37 +++---- os/src/task/switch.rs | 5 +- os/src/task/task.rs | 20 ++-- os/src/timer.rs | 6 +- os/src/trap/context.rs | 6 +- os/src/trap/mod.rs | 41 ++++--- user/src/bin/00power_3.rs | 2 +- user/src/bin/03sleep.rs | 2 +- user/src/console.rs | 4 +- user/src/lang_items.rs | 9 +- user/src/lib.rs | 19 ++-- 29 files changed, 358 insertions(+), 286 deletions(-) diff --git a/os/build.rs b/os/build.rs index 07a25c99..905e21e3 100644 --- a/os/build.rs +++ b/os/build.rs @@ -1,5 +1,5 @@ +use std::fs::{read_dir, File}; use std::io::{Result, Write}; -use std::fs::{File, read_dir}; fn main() { println!("cargo:rerun-if-changed=../user/src/"); @@ -22,12 +22,16 @@ fn insert_app_data() -> Result<()> { .collect(); apps.sort(); - writeln!(f, r#" + writeln!( + f, + r#" .align 3 .section .data .global _num_app _num_app: - .quad {}"#, apps.len())?; + .quad {}"#, + apps.len() + )?; for i in 0..apps.len() { writeln!(f, r#" .quad app_{}_start"#, i)?; @@ -36,14 +40,18 @@ _num_app: for (idx, app) in apps.iter().enumerate() { println!("app_{}: {}", idx, app); - writeln!(f, r#" + writeln!( + f, + r#" .section .data .global app_{0}_start .global app_{0}_end .align 3 app_{0}_start: .incbin "{2}{1}" -app_{0}_end:"#, idx, app, TARGET_PATH)?; +app_{0}_end:"#, + idx, app, TARGET_PATH + )?; } Ok(()) -} \ No newline at end of file +} diff --git a/os/src/console.rs b/os/src/console.rs index 2bd55930..dda4911a 100644 --- a/os/src/console.rs +++ b/os/src/console.rs @@ -1,5 +1,5 @@ -use core::fmt::{self, Write}; use crate::sbi::console_putchar; +use core::fmt::{self, Write}; struct Stdout; @@ -29,5 +29,3 @@ macro_rules! println { $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?)); } } - - diff --git a/os/src/lang_items.rs b/os/src/lang_items.rs index 3f5462ab..af3e5152 100644 --- a/os/src/lang_items.rs +++ b/os/src/lang_items.rs @@ -1,10 +1,15 @@ -use core::panic::PanicInfo; use crate::sbi::shutdown; +use core::panic::PanicInfo; #[panic_handler] fn panic(info: &PanicInfo) -> ! { if let Some(location) = info.location() { - println!("[kernel] Panicked at {}:{} {}", location.file(), location.line(), info.message().unwrap()); + println!( + "[kernel] Panicked at {}:{} {}", + location.file(), + location.line(), + info.message().unwrap() + ); } else { println!("[kernel] Panicked: {}", info.message().unwrap()); } diff --git a/os/src/loader.rs b/os/src/loader.rs index 6d284743..1358c464 100644 --- a/os/src/loader.rs +++ b/os/src/loader.rs @@ -1,20 +1,22 @@ pub fn get_num_app() -> usize { - extern "C" { fn _num_app(); } + extern "C" { + fn _num_app(); + } unsafe { (_num_app as usize as *const usize).read_volatile() } } pub fn get_app_data(app_id: usize) -> &'static [u8] { - extern "C" { fn _num_app(); } + extern "C" { + fn _num_app(); + } let num_app_ptr = _num_app as usize as *const usize; let num_app = get_num_app(); - let app_start = unsafe { - core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1) - }; + let app_start = unsafe { core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1) }; assert!(app_id < num_app); unsafe { core::slice::from_raw_parts( app_start[app_id] as *const u8, - app_start[app_id + 1] - app_start[app_id] + app_start[app_id + 1] - app_start[app_id], ) } } diff --git a/os/src/main.rs b/os/src/main.rs index 3d06bb1b..259a52ae 100644 --- a/os/src/main.rs +++ b/os/src/main.rs @@ -10,16 +10,16 @@ extern crate bitflags; #[macro_use] mod console; +mod config; mod lang_items; +mod loader; +mod mm; mod sbi; +mod sync; mod syscall; -mod trap; -mod loader; -mod config; mod task; mod timer; -mod sync; -mod mm; +mod trap; use core::arch::global_asm; @@ -32,10 +32,8 @@ fn clear_bss() { fn ebss(); } unsafe { - core::slice::from_raw_parts_mut( - sbss as usize as *mut u8, - ebss as usize - sbss as usize, - ).fill(0); + core::slice::from_raw_parts_mut(sbss as usize as *mut u8, ebss as usize - sbss as usize) + .fill(0); } } diff --git a/os/src/mm/address.rs b/os/src/mm/address.rs index e6fc10f7..ef940b7a 100644 --- a/os/src/mm/address.rs +++ b/os/src/mm/address.rs @@ -1,5 +1,5 @@ -use crate::config::{PAGE_SIZE, PAGE_SIZE_BITS}; use super::PageTableEntry; +use crate::config::{PAGE_SIZE, PAGE_SIZE_BITS}; use core::fmt::{self, Debug, Formatter}; const PA_WIDTH_SV39: usize = 56; @@ -48,35 +48,59 @@ impl Debug for PhysPageNum { /// usize -> T: usize.into() impl From for PhysAddr { - fn from(v: usize) -> Self { Self(v & ( (1 << PA_WIDTH_SV39) - 1 )) } + fn from(v: usize) -> Self { + Self(v & ((1 << PA_WIDTH_SV39) - 1)) + } } impl From for PhysPageNum { - fn from(v: usize) -> Self { Self(v & ( (1 << PPN_WIDTH_SV39) - 1 )) } + fn from(v: usize) -> Self { + Self(v & ((1 << PPN_WIDTH_SV39) - 1)) + } } impl From for VirtAddr { - fn from(v: usize) -> Self { Self(v & ( (1 << VA_WIDTH_SV39) - 1 )) } + fn from(v: usize) -> Self { + Self(v & ((1 << VA_WIDTH_SV39) - 1)) + } } impl From for VirtPageNum { - fn from(v: usize) -> Self { Self(v & ( (1 << VPN_WIDTH_SV39) - 1 )) } + fn from(v: usize) -> Self { + Self(v & ((1 << VPN_WIDTH_SV39) - 1)) + } } impl From for usize { - fn from(v: PhysAddr) -> Self { v.0 } + fn from(v: PhysAddr) -> Self { + v.0 + } } impl From for usize { - fn from(v: PhysPageNum) -> Self { v.0 } + fn from(v: PhysPageNum) -> Self { + v.0 + } } impl From for usize { - fn from(v: VirtAddr) -> Self { v.0 } + fn from(v: VirtAddr) -> Self { + v.0 + } } impl From for usize { - fn from(v: VirtPageNum) -> Self { v.0 } + fn from(v: VirtPageNum) -> Self { + v.0 + } } impl VirtAddr { - pub fn floor(&self) -> VirtPageNum { VirtPageNum(self.0 / PAGE_SIZE) } - pub fn ceil(&self) -> VirtPageNum { VirtPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE) } - pub fn page_offset(&self) -> usize { self.0 & (PAGE_SIZE - 1) } - pub fn aligned(&self) -> bool { self.page_offset() == 0 } + pub fn floor(&self) -> VirtPageNum { + VirtPageNum(self.0 / PAGE_SIZE) + } + pub fn ceil(&self) -> VirtPageNum { + VirtPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE) + } + pub fn page_offset(&self) -> usize { + self.0 & (PAGE_SIZE - 1) + } + pub fn aligned(&self) -> bool { + self.page_offset() == 0 + } } impl From for VirtPageNum { fn from(v: VirtAddr) -> Self { @@ -85,13 +109,23 @@ impl From for VirtPageNum { } } impl From for VirtAddr { - fn from(v: VirtPageNum) -> Self { Self(v.0 << PAGE_SIZE_BITS) } + fn from(v: VirtPageNum) -> Self { + Self(v.0 << PAGE_SIZE_BITS) + } } impl PhysAddr { - pub fn floor(&self) -> PhysPageNum { PhysPageNum(self.0 / PAGE_SIZE) } - pub fn ceil(&self) -> PhysPageNum { PhysPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE) } - pub fn page_offset(&self) -> usize { self.0 & (PAGE_SIZE - 1) } - pub fn aligned(&self) -> bool { self.page_offset() == 0 } + pub fn floor(&self) -> PhysPageNum { + PhysPageNum(self.0 / PAGE_SIZE) + } + pub fn ceil(&self) -> PhysPageNum { + PhysPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE) + } + pub fn page_offset(&self) -> usize { + self.0 & (PAGE_SIZE - 1) + } + pub fn aligned(&self) -> bool { + self.page_offset() == 0 + } } impl From for PhysPageNum { fn from(v: PhysAddr) -> Self { @@ -100,7 +134,9 @@ impl From for PhysPageNum { } } impl From for PhysAddr { - fn from(v: PhysPageNum) -> Self { Self(v.0 << PAGE_SIZE_BITS) } + fn from(v: PhysPageNum) -> Self { + Self(v.0 << PAGE_SIZE_BITS) + } } impl VirtPageNum { @@ -118,21 +154,15 @@ impl VirtPageNum { impl PhysPageNum { pub fn get_pte_array(&self) -> &'static mut [PageTableEntry] { let pa: PhysAddr = self.clone().into(); - unsafe { - core::slice::from_raw_parts_mut(pa.0 as *mut PageTableEntry, 512) - } + unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut PageTableEntry, 512) } } pub fn get_bytes_array(&self) -> &'static mut [u8] { let pa: PhysAddr = self.clone().into(); - unsafe { - core::slice::from_raw_parts_mut(pa.0 as *mut u8, 4096) - } + unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut u8, 4096) } } pub fn get_mut(&self) -> &'static mut T { let pa: PhysAddr = self.clone().into(); - unsafe { - (pa.0 as *mut T).as_mut().unwrap() - } + unsafe { (pa.0 as *mut T).as_mut().unwrap() } } } @@ -146,41 +176,57 @@ impl StepByOne for VirtPageNum { } #[derive(Copy, Clone)] -pub struct SimpleRange where - T: StepByOne + Copy + PartialEq + PartialOrd + Debug, { +pub struct SimpleRange +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ l: T, r: T, } -impl SimpleRange where - T: StepByOne + Copy + PartialEq + PartialOrd + Debug, { +impl SimpleRange +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ pub fn new(start: T, end: T) -> Self { assert!(start <= end, "start {:?} > end {:?}!", start, end); Self { l: start, r: end } } - pub fn get_start(&self) -> T { self.l } - pub fn get_end(&self) -> T { self.r } + pub fn get_start(&self) -> T { + self.l + } + pub fn get_end(&self) -> T { + self.r + } } -impl IntoIterator for SimpleRange where - T: StepByOne + Copy + PartialEq + PartialOrd + Debug, { +impl IntoIterator for SimpleRange +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ type Item = T; type IntoIter = SimpleRangeIterator; fn into_iter(self) -> Self::IntoIter { SimpleRangeIterator::new(self.l, self.r) } } -pub struct SimpleRangeIterator where - T: StepByOne + Copy + PartialEq + PartialOrd + Debug, { +pub struct SimpleRangeIterator +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ current: T, end: T, } -impl SimpleRangeIterator where - T: StepByOne + Copy + PartialEq + PartialOrd + Debug, { +impl SimpleRangeIterator +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ pub fn new(l: T, r: T) -> Self { - Self { current: l, end: r, } + Self { current: l, end: r } } } -impl Iterator for SimpleRangeIterator where - T: StepByOne + Copy + PartialEq + PartialOrd + Debug, { +impl Iterator for SimpleRangeIterator +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ type Item = T; fn next(&mut self) -> Option { if self.current == self.end { diff --git a/os/src/mm/frame_allocator.rs b/os/src/mm/frame_allocator.rs index 34152355..37c04098 100644 --- a/os/src/mm/frame_allocator.rs +++ b/os/src/mm/frame_allocator.rs @@ -1,9 +1,9 @@ use super::{PhysAddr, PhysPageNum}; -use alloc::vec::Vec; -use crate::sync::UPSafeCell; use crate::config::MEMORY_END; -use lazy_static::*; +use crate::sync::UPSafeCell; +use alloc::vec::Vec; use core::fmt::{self, Debug, Formatter}; +use lazy_static::*; pub struct FrameTracker { pub ppn: PhysPageNum, @@ -61,22 +61,17 @@ impl FrameAllocator for StackFrameAllocator { fn alloc(&mut self) -> Option { if let Some(ppn) = self.recycled.pop() { Some(ppn.into()) + } else if self.current == self.end { + None } else { - if self.current == self.end { - None - } else { - self.current += 1; - Some((self.current - 1).into()) - } + self.current += 1; + Some((self.current - 1).into()) } } fn dealloc(&mut self, ppn: PhysPageNum) { let ppn = ppn.0; // validity check - if ppn >= self.current || self.recycled - .iter() - .find(|&v| {*v == ppn}) - .is_some() { + if ppn >= self.current || self.recycled.iter().find(|&v| *v == ppn).is_some() { panic!("Frame ppn={:#x} has not been allocated!", ppn); } // recycle @@ -87,18 +82,18 @@ impl FrameAllocator for StackFrameAllocator { type FrameAllocatorImpl = StackFrameAllocator; lazy_static! { - pub static ref FRAME_ALLOCATOR: UPSafeCell = unsafe { - UPSafeCell::new(FrameAllocatorImpl::new()) - }; + pub static ref FRAME_ALLOCATOR: UPSafeCell = + unsafe { UPSafeCell::new(FrameAllocatorImpl::new()) }; } pub fn init_frame_allocator() { extern "C" { fn ekernel(); } - FRAME_ALLOCATOR - .exclusive_access() - .init(PhysAddr::from(ekernel as usize).ceil(), PhysAddr::from(MEMORY_END).floor()); + FRAME_ALLOCATOR.exclusive_access().init( + PhysAddr::from(ekernel as usize).ceil(), + PhysAddr::from(MEMORY_END).floor(), + ); } pub fn frame_alloc() -> Option { @@ -109,9 +104,7 @@ pub fn frame_alloc() -> Option { } fn frame_dealloc(ppn: PhysPageNum) { - FRAME_ALLOCATOR - .exclusive_access() - .dealloc(ppn); + FRAME_ALLOCATOR.exclusive_access().dealloc(ppn); } #[allow(unused)] @@ -130,4 +123,4 @@ pub fn frame_allocator_test() { } drop(v); println!("frame_allocator_test passed!"); -} \ No newline at end of file +} diff --git a/os/src/mm/heap_allocator.rs b/os/src/mm/heap_allocator.rs index 2c7468f2..b802bbd3 100644 --- a/os/src/mm/heap_allocator.rs +++ b/os/src/mm/heap_allocator.rs @@ -1,5 +1,5 @@ -use buddy_system_allocator::LockedHeap; use crate::config::KERNEL_HEAP_SIZE; +use buddy_system_allocator::LockedHeap; #[global_allocator] static HEAP_ALLOCATOR: LockedHeap = LockedHeap::empty(); diff --git a/os/src/mm/memory_set.rs b/os/src/mm/memory_set.rs index 68d4221a..35392e87 100644 --- a/os/src/mm/memory_set.rs +++ b/os/src/mm/memory_set.rs @@ -1,21 +1,15 @@ -use super::{PageTable, PageTableEntry, PTEFlags}; -use super::{VirtPageNum, VirtAddr, PhysPageNum, PhysAddr}; -use super::{FrameTracker, frame_alloc}; -use super::{VPNRange, StepByOne}; +use super::{frame_alloc, FrameTracker}; +use super::{PTEFlags, PageTable, PageTableEntry}; +use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum}; +use super::{StepByOne, VPNRange}; +use crate::config::{MEMORY_END, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT, USER_STACK_SIZE}; +use crate::sync::UPSafeCell; use alloc::collections::BTreeMap; -use alloc::vec::Vec; -use riscv::register::satp; use alloc::sync::Arc; -use lazy_static::*; -use crate::sync::UPSafeCell; -use crate::config::{ - MEMORY_END, - PAGE_SIZE, - TRAMPOLINE, - TRAP_CONTEXT, - USER_STACK_SIZE -}; +use alloc::vec::Vec; use core::arch::asm; +use lazy_static::*; +use riscv::register::satp; extern "C" { fn stext(); @@ -31,9 +25,8 @@ extern "C" { } lazy_static! { - pub static ref KERNEL_SPACE: Arc> = Arc::new(unsafe { - UPSafeCell::new(MemorySet::new_kernel() - )}); + pub static ref KERNEL_SPACE: Arc> = + Arc::new(unsafe { UPSafeCell::new(MemorySet::new_kernel()) }); } pub struct MemorySet { @@ -52,13 +45,16 @@ impl MemorySet { self.page_table.token() } /// Assume that no conflicts. - pub fn insert_framed_area(&mut self, start_va: VirtAddr, end_va: VirtAddr, permission: MapPermission) { - self.push(MapArea::new( - start_va, - end_va, - MapType::Framed, - permission, - ), None); + pub fn insert_framed_area( + &mut self, + start_va: VirtAddr, + end_va: VirtAddr, + permission: MapPermission, + ) { + self.push( + MapArea::new(start_va, end_va, MapType::Framed, permission), + None, + ); } fn push(&mut self, mut map_area: MapArea, data: Option<&[u8]>) { map_area.map(&mut self.page_table); @@ -84,42 +80,60 @@ impl MemorySet { println!(".text [{:#x}, {:#x})", stext as usize, etext as usize); println!(".rodata [{:#x}, {:#x})", srodata as usize, erodata as usize); println!(".data [{:#x}, {:#x})", sdata as usize, edata as usize); - println!(".bss [{:#x}, {:#x})", sbss_with_stack as usize, ebss as usize); + println!( + ".bss [{:#x}, {:#x})", + sbss_with_stack as usize, ebss as usize + ); println!("mapping .text section"); - memory_set.push(MapArea::new( - (stext as usize).into(), - (etext as usize).into(), - MapType::Identical, - MapPermission::R | MapPermission::X, - ), None); + memory_set.push( + MapArea::new( + (stext as usize).into(), + (etext as usize).into(), + MapType::Identical, + MapPermission::R | MapPermission::X, + ), + None, + ); println!("mapping .rodata section"); - memory_set.push(MapArea::new( - (srodata as usize).into(), - (erodata as usize).into(), - MapType::Identical, - MapPermission::R, - ), None); + memory_set.push( + MapArea::new( + (srodata as usize).into(), + (erodata as usize).into(), + MapType::Identical, + MapPermission::R, + ), + None, + ); println!("mapping .data section"); - memory_set.push(MapArea::new( - (sdata as usize).into(), - (edata as usize).into(), - MapType::Identical, - MapPermission::R | MapPermission::W, - ), None); + memory_set.push( + MapArea::new( + (sdata as usize).into(), + (edata as usize).into(), + MapType::Identical, + MapPermission::R | MapPermission::W, + ), + None, + ); println!("mapping .bss section"); - memory_set.push(MapArea::new( - (sbss_with_stack as usize).into(), - (ebss as usize).into(), - MapType::Identical, - MapPermission::R | MapPermission::W, - ), None); + memory_set.push( + MapArea::new( + (sbss_with_stack as usize).into(), + (ebss as usize).into(), + MapType::Identical, + MapPermission::R | MapPermission::W, + ), + None, + ); println!("mapping physical memory"); - memory_set.push(MapArea::new( - (ekernel as usize).into(), - MEMORY_END.into(), - MapType::Identical, - MapPermission::R | MapPermission::W, - ), None); + memory_set.push( + MapArea::new( + (ekernel as usize).into(), + MEMORY_END.into(), + MapType::Identical, + MapPermission::R | MapPermission::W, + ), + None, + ); memory_set } /// Include sections in elf and trampoline and TrapContext and user stack, @@ -142,19 +156,20 @@ impl MemorySet { let end_va: VirtAddr = ((ph.virtual_addr() + ph.mem_size()) as usize).into(); let mut map_perm = MapPermission::U; let ph_flags = ph.flags(); - if ph_flags.is_read() { map_perm |= MapPermission::R; } - if ph_flags.is_write() { map_perm |= MapPermission::W; } - if ph_flags.is_execute() { map_perm |= MapPermission::X; } - let map_area = MapArea::new( - start_va, - end_va, - MapType::Framed, - map_perm, - ); + if ph_flags.is_read() { + map_perm |= MapPermission::R; + } + if ph_flags.is_write() { + map_perm |= MapPermission::W; + } + if ph_flags.is_execute() { + map_perm |= MapPermission::X; + } + let map_area = MapArea::new(start_va, end_va, MapType::Framed, map_perm); max_end_vpn = map_area.vpn_range.get_end(); memory_set.push( map_area, - Some(&elf.input[ph.offset() as usize..(ph.offset() + ph.file_size()) as usize]) + Some(&elf.input[ph.offset() as usize..(ph.offset() + ph.file_size()) as usize]), ); } } @@ -164,20 +179,30 @@ impl MemorySet { // guard page user_stack_bottom += PAGE_SIZE; let user_stack_top = user_stack_bottom + USER_STACK_SIZE; - memory_set.push(MapArea::new( - user_stack_bottom.into(), - user_stack_top.into(), - MapType::Framed, - MapPermission::R | MapPermission::W | MapPermission::U, - ), None); + memory_set.push( + MapArea::new( + user_stack_bottom.into(), + user_stack_top.into(), + MapType::Framed, + MapPermission::R | MapPermission::W | MapPermission::U, + ), + None, + ); // map TrapContext - memory_set.push(MapArea::new( - TRAP_CONTEXT.into(), - TRAMPOLINE.into(), - MapType::Framed, - MapPermission::R | MapPermission::W, - ), None); - (memory_set, user_stack_top, elf.header.pt2.entry_point() as usize) + memory_set.push( + MapArea::new( + TRAP_CONTEXT.into(), + TRAMPOLINE.into(), + MapType::Framed, + MapPermission::R | MapPermission::W, + ), + None, + ); + ( + memory_set, + user_stack_top, + elf.header.pt2.entry_point() as usize, + ) } pub fn activate(&self) { let satp = self.page_table.token(); @@ -203,7 +228,7 @@ impl MapArea { start_va: VirtAddr, end_va: VirtAddr, map_type: MapType, - map_perm: MapPermission + map_perm: MapPermission, ) -> Self { let start_vpn: VirtPageNum = start_va.floor(); let end_vpn: VirtPageNum = end_va.ceil(); @@ -296,15 +321,27 @@ pub fn remap_test() { let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into(); let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into(); assert_eq!( - kernel_space.page_table.translate(mid_text.floor()).unwrap().writable(), + kernel_space + .page_table + .translate(mid_text.floor()) + .unwrap() + .writable(), false ); assert_eq!( - kernel_space.page_table.translate(mid_rodata.floor()).unwrap().writable(), + kernel_space + .page_table + .translate(mid_rodata.floor()) + .unwrap() + .writable(), false, ); assert_eq!( - kernel_space.page_table.translate(mid_data.floor()).unwrap().executable(), + kernel_space + .page_table + .translate(mid_data.floor()) + .unwrap() + .executable(), false, ); println!("remap_test passed!"); diff --git a/os/src/mm/mod.rs b/os/src/mm/mod.rs index bb04aea9..bbf8bef4 100644 --- a/os/src/mm/mod.rs +++ b/os/src/mm/mod.rs @@ -1,16 +1,16 @@ -mod heap_allocator; mod address; mod frame_allocator; -mod page_table; +mod heap_allocator; mod memory_set; +mod page_table; -use page_table::{PageTable, PTEFlags}; -use address::{VPNRange, StepByOne}; -pub use address::{PhysAddr, VirtAddr, PhysPageNum, VirtPageNum}; -pub use frame_allocator::{FrameTracker, frame_alloc}; -pub use page_table::{PageTableEntry, translated_byte_buffer}; -pub use memory_set::{MemorySet, KERNEL_SPACE, MapPermission}; +pub use address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum}; +use address::{StepByOne, VPNRange}; +pub use frame_allocator::{frame_alloc, FrameTracker}; pub use memory_set::remap_test; +pub use memory_set::{MapPermission, MemorySet, KERNEL_SPACE}; +pub use page_table::{translated_byte_buffer, PageTableEntry}; +use page_table::{PTEFlags, PageTable}; pub fn init() { heap_allocator::init_heap(); diff --git a/os/src/mm/page_table.rs b/os/src/mm/page_table.rs index 0315ff91..191e1a04 100644 --- a/os/src/mm/page_table.rs +++ b/os/src/mm/page_table.rs @@ -1,6 +1,6 @@ -use super::{frame_alloc, PhysPageNum, FrameTracker, VirtPageNum, VirtAddr, StepByOne}; -use alloc::vec::Vec; +use super::{frame_alloc, FrameTracker, PhysPageNum, StepByOne, VirtAddr, VirtPageNum}; use alloc::vec; +use alloc::vec::Vec; use bitflags::*; bitflags! { @@ -29,9 +29,7 @@ impl PageTableEntry { } } pub fn empty() -> Self { - PageTableEntry { - bits: 0, - } + PageTableEntry { bits: 0 } } pub fn ppn(&self) -> PhysPageNum { (self.bits >> 10 & ((1usize << 44) - 1)).into() @@ -123,8 +121,7 @@ impl PageTable { *pte = PageTableEntry::empty(); } pub fn translate(&self, vpn: VirtPageNum) -> Option { - self.find_pte(vpn) - .map(|pte| {pte.clone()}) + self.find_pte(vpn).map(|pte| pte.clone()) } pub fn token(&self) -> usize { 8usize << 60 | self.root_ppn.0 @@ -139,10 +136,7 @@ pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<& while start < end { let start_va = VirtAddr::from(start); let mut vpn = start_va.floor(); - let ppn = page_table - .translate(vpn) - .unwrap() - .ppn(); + let ppn = page_table.translate(vpn).unwrap().ppn(); vpn.step(); let mut end_va: VirtAddr = vpn.into(); end_va = end_va.min(VirtAddr::from(end)); diff --git a/os/src/sbi.rs b/os/src/sbi.rs index c8ecbf1d..2e2804b2 100644 --- a/os/src/sbi.rs +++ b/os/src/sbi.rs @@ -43,4 +43,3 @@ pub fn shutdown() -> ! { sbi_call(SBI_SHUTDOWN, 0, 0, 0); panic!("It should shutdown!"); } - diff --git a/os/src/sync/mod.rs b/os/src/sync/mod.rs index 77295248..d1ce5bcf 100644 --- a/os/src/sync/mod.rs +++ b/os/src/sync/mod.rs @@ -1,3 +1,3 @@ mod up; -pub use up::UPSafeCell; \ No newline at end of file +pub use up::UPSafeCell; diff --git a/os/src/sync/up.rs b/os/src/sync/up.rs index 642668c1..c7b2c9ee 100644 --- a/os/src/sync/up.rs +++ b/os/src/sync/up.rs @@ -18,10 +18,12 @@ impl UPSafeCell { /// User is responsible to guarantee that inner struct is only used in /// uniprocessor. pub unsafe fn new(value: T) -> Self { - Self { inner: RefCell::new(value) } + Self { + inner: RefCell::new(value), + } } /// Panic if the data has been borrowed. pub fn exclusive_access(&self) -> RefMut<'_, T> { self.inner.borrow_mut() } -} \ No newline at end of file +} diff --git a/os/src/syscall/fs.rs b/os/src/syscall/fs.rs index b02e0871..5dfff5e3 100644 --- a/os/src/syscall/fs.rs +++ b/os/src/syscall/fs.rs @@ -11,9 +11,9 @@ pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize { print!("{}", core::str::from_utf8(buffer).unwrap()); } len as isize - }, + } _ => { panic!("Unsupported fd in sys_write!"); } } -} \ No newline at end of file +} diff --git a/os/src/syscall/mod.rs b/os/src/syscall/mod.rs index da411680..572b081a 100644 --- a/os/src/syscall/mod.rs +++ b/os/src/syscall/mod.rs @@ -18,4 +18,3 @@ pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize { _ => panic!("Unsupported syscall_id: {}", syscall_id), } } - diff --git a/os/src/syscall/process.rs b/os/src/syscall/process.rs index 23eab1ff..55856e70 100644 --- a/os/src/syscall/process.rs +++ b/os/src/syscall/process.rs @@ -1,7 +1,4 @@ -use crate::task::{ - suspend_current_and_run_next, - exit_current_and_run_next, -}; +use crate::task::{exit_current_and_run_next, suspend_current_and_run_next}; use crate::timer::get_time_ms; pub fn sys_exit(exit_code: i32) -> ! { @@ -17,4 +14,4 @@ pub fn sys_yield() -> isize { pub fn sys_get_time() -> isize { get_time_ms() as isize -} \ No newline at end of file +} diff --git a/os/src/task/context.rs b/os/src/task/context.rs index d25cc2c8..e4f59d8a 100644 --- a/os/src/task/context.rs +++ b/os/src/task/context.rs @@ -23,4 +23,3 @@ impl TaskContext { } } } - diff --git a/os/src/task/mod.rs b/os/src/task/mod.rs index 5a85eebd..d3d9cf9c 100644 --- a/os/src/task/mod.rs +++ b/os/src/task/mod.rs @@ -2,13 +2,13 @@ mod context; mod switch; mod task; -use crate::loader::{get_num_app, get_app_data}; -use crate::trap::TrapContext; +use crate::loader::{get_app_data, get_num_app}; use crate::sync::UPSafeCell; +use crate::trap::TrapContext; +use alloc::vec::Vec; use lazy_static::*; use switch::__switch; use task::{TaskControlBlock, TaskStatus}; -use alloc::vec::Vec; pub use context::TaskContext; @@ -29,17 +29,16 @@ lazy_static! { println!("num_app = {}", num_app); let mut tasks: Vec = Vec::new(); for i in 0..num_app { - tasks.push(TaskControlBlock::new( - get_app_data(i), - i, - )); + tasks.push(TaskControlBlock::new(get_app_data(i), i)); } TaskManager { num_app, - inner: unsafe { UPSafeCell::new(TaskManagerInner { - tasks, - current_task: 0, - })}, + inner: unsafe { + UPSafeCell::new(TaskManagerInner { + tasks, + current_task: 0, + }) + }, } }; } @@ -54,10 +53,7 @@ impl TaskManager { let mut _unused = TaskContext::zero_init(); // before this, we should drop local variables that must be dropped manually unsafe { - __switch( - &mut _unused as *mut _, - next_task_cx_ptr, - ); + __switch(&mut _unused as *mut _, next_task_cx_ptr); } panic!("unreachable in run_first_task!"); } @@ -79,9 +75,7 @@ impl TaskManager { let current = inner.current_task; (current + 1..current + self.num_app + 1) .map(|id| id % self.num_app) - .find(|id| { - inner.tasks[*id].task_status == TaskStatus::Ready - }) + .find(|id| inner.tasks[*id].task_status == TaskStatus::Ready) } fn get_current_token(&self) -> usize { @@ -105,10 +99,7 @@ impl TaskManager { drop(inner); // before this, we should drop local variables that must be dropped manually unsafe { - __switch( - current_task_cx_ptr, - next_task_cx_ptr, - ); + __switch(current_task_cx_ptr, next_task_cx_ptr); } // go back to user mode } else { @@ -149,4 +140,4 @@ pub fn current_user_token() -> usize { pub fn current_trap_cx() -> &'static mut TrapContext { TASK_MANAGER.get_current_trap_cx() -} \ No newline at end of file +} diff --git a/os/src/task/switch.rs b/os/src/task/switch.rs index dd3a2d3e..59f8b1a0 100644 --- a/os/src/task/switch.rs +++ b/os/src/task/switch.rs @@ -4,8 +4,5 @@ use core::arch::global_asm; global_asm!(include_str!("switch.S")); extern "C" { - pub fn __switch( - current_task_cx_ptr: *mut TaskContext, - next_task_cx_ptr: *const TaskContext - ); + pub fn __switch(current_task_cx_ptr: *mut TaskContext, next_task_cx_ptr: *const TaskContext); } diff --git a/os/src/task/task.rs b/os/src/task/task.rs index 47368db6..036018bc 100644 --- a/os/src/task/task.rs +++ b/os/src/task/task.rs @@ -1,7 +1,7 @@ -use crate::mm::{MemorySet, MapPermission, PhysPageNum, KERNEL_SPACE, VirtAddr}; -use crate::trap::{TrapContext, trap_handler}; -use crate::config::{TRAP_CONTEXT, kernel_stack_position}; use super::TaskContext; +use crate::config::{kernel_stack_position, TRAP_CONTEXT}; +use crate::mm::{MapPermission, MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE}; +use crate::trap::{trap_handler, TrapContext}; pub struct TaskControlBlock { pub task_status: TaskStatus, @@ -28,13 +28,11 @@ impl TaskControlBlock { let task_status = TaskStatus::Ready; // map a kernel-stack in kernel space let (kernel_stack_bottom, kernel_stack_top) = kernel_stack_position(app_id); - KERNEL_SPACE - .exclusive_access() - .insert_framed_area( - kernel_stack_bottom.into(), - kernel_stack_top.into(), - MapPermission::R | MapPermission::W, - ); + KERNEL_SPACE.exclusive_access().insert_framed_area( + kernel_stack_bottom.into(), + kernel_stack_top.into(), + MapPermission::R | MapPermission::W, + ); let task_control_block = Self { task_status, task_cx: TaskContext::goto_trap_return(kernel_stack_top), @@ -60,4 +58,4 @@ pub enum TaskStatus { Ready, Running, Exited, -} \ No newline at end of file +} diff --git a/os/src/timer.rs b/os/src/timer.rs index 92d50e3a..048aa3b7 100644 --- a/os/src/timer.rs +++ b/os/src/timer.rs @@ -1,6 +1,6 @@ -use riscv::register::time; -use crate::sbi::set_timer; use crate::config::CLOCK_FREQ; +use crate::sbi::set_timer; +use riscv::register::time; const TICKS_PER_SEC: usize = 100; const MSEC_PER_SEC: usize = 1000; @@ -15,4 +15,4 @@ pub fn get_time_ms() -> usize { pub fn set_next_trigger() { set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC); -} \ No newline at end of file +} diff --git a/os/src/trap/context.rs b/os/src/trap/context.rs index d910d4e6..d0734515 100644 --- a/os/src/trap/context.rs +++ b/os/src/trap/context.rs @@ -1,4 +1,4 @@ -use riscv::register::sstatus::{Sstatus, self, SPP}; +use riscv::register::sstatus::{self, Sstatus, SPP}; #[repr(C)] pub struct TrapContext { @@ -11,7 +11,9 @@ pub struct TrapContext { } impl TrapContext { - pub fn set_sp(&mut self, sp: usize) { self.x[2] = sp; } + pub fn set_sp(&mut self, sp: usize) { + self.x[2] = sp; + } pub fn app_init_context( entry: usize, sp: usize, diff --git a/os/src/trap/mod.rs b/os/src/trap/mod.rs index 9eb0d792..67577210 100644 --- a/os/src/trap/mod.rs +++ b/os/src/trap/mod.rs @@ -1,27 +1,17 @@ mod context; -use riscv::register::{ - mtvec::TrapMode, - stvec, - scause::{ - self, - Trap, - Exception, - Interrupt, - }, - stval, - sie, -}; +use crate::config::{TRAMPOLINE, TRAP_CONTEXT}; use crate::syscall::syscall; use crate::task::{ - exit_current_and_run_next, - suspend_current_and_run_next, - current_user_token, - current_trap_cx, + current_trap_cx, current_user_token, exit_current_and_run_next, suspend_current_and_run_next, }; use crate::timer::set_next_trigger; -use crate::config::{TRAP_CONTEXT, TRAMPOLINE}; -use core::arch::{global_asm, asm}; +use core::arch::{asm, global_asm}; +use riscv::register::{ + mtvec::TrapMode, + scause::{self, Exception, Interrupt, Trap}, + sie, stval, stvec, +}; global_asm!(include_str!("trap.S")); @@ -42,7 +32,9 @@ fn set_user_trap_entry() { } pub fn enable_timer_interrupt() { - unsafe { sie::set_stimer(); } + unsafe { + sie::set_stimer(); + } } #[no_mangle] @@ -56,8 +48,7 @@ pub fn trap_handler() -> ! { cx.sepc += 4; cx.x[10] = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]) as usize; } - Trap::Exception(Exception::StoreFault) | - Trap::Exception(Exception::StorePageFault) => { + Trap::Exception(Exception::StoreFault) | Trap::Exception(Exception::StorePageFault) => { println!("[kernel] PageFault in application, bad addr = {:#x}, bad instruction = {:#x}, kernel killed it.", stval, cx.sepc); exit_current_and_run_next(); } @@ -70,7 +61,11 @@ pub fn trap_handler() -> ! { suspend_current_and_run_next(); } _ => { - panic!("Unsupported trap {:?}, stval = {:#x}!", scause.cause(), stval); + panic!( + "Unsupported trap {:?}, stval = {:#x}!", + scause.cause(), + stval + ); } } trap_return(); @@ -103,4 +98,4 @@ pub fn trap_from_kernel() -> ! { panic!("a trap from kernel!"); } -pub use context::{TrapContext}; +pub use context::TrapContext; diff --git a/user/src/bin/00power_3.rs b/user/src/bin/00power_3.rs index e14f1e2b..125e6701 100644 --- a/user/src/bin/00power_3.rs +++ b/user/src/bin/00power_3.rs @@ -26,4 +26,4 @@ unsafe fn main() -> i32 { println!("{}^{} = {}(MOD {})", p, iter, S[cur], m); println!("Test power_3 OK!"); 0 -} \ No newline at end of file +} diff --git a/user/src/bin/03sleep.rs b/user/src/bin/03sleep.rs index 83411233..7e43d9c2 100644 --- a/user/src/bin/03sleep.rs +++ b/user/src/bin/03sleep.rs @@ -15,4 +15,4 @@ fn main() -> i32 { } println!("Test sleep OK!"); 0 -} \ No newline at end of file +} diff --git a/user/src/console.rs b/user/src/console.rs index ac801174..d37e867c 100644 --- a/user/src/console.rs +++ b/user/src/console.rs @@ -1,5 +1,5 @@ -use core::fmt::{self, Write}; use super::write; +use core::fmt::{self, Write}; struct Stdout; @@ -28,4 +28,4 @@ macro_rules! println { ($fmt: literal $(, $($arg: tt)+)?) => { $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?)); } -} \ No newline at end of file +} diff --git a/user/src/lang_items.rs b/user/src/lang_items.rs index c90d297f..3aee17ba 100644 --- a/user/src/lang_items.rs +++ b/user/src/lang_items.rs @@ -2,9 +2,14 @@ fn panic_handler(panic_info: &core::panic::PanicInfo) -> ! { let err = panic_info.message().unwrap(); if let Some(location) = panic_info.location() { - println!("Panicked at {}:{}, {}", location.file(), location.line(), err); + println!( + "Panicked at {}:{}, {}", + location.file(), + location.line(), + err + ); } else { println!("Panicked: {}", err); } loop {} -} \ No newline at end of file +} diff --git a/user/src/lib.rs b/user/src/lib.rs index 5da90d74..2e99ba4e 100644 --- a/user/src/lib.rs +++ b/user/src/lib.rs @@ -4,8 +4,8 @@ #[macro_use] pub mod console; -mod syscall; mod lang_items; +mod syscall; #[no_mangle] #[link_section = ".text.entry"] @@ -20,10 +20,17 @@ fn main() -> i32 { panic!("Cannot find main!"); } - use syscall::*; -pub fn write(fd: usize, buf: &[u8]) -> isize { sys_write(fd, buf) } -pub fn exit(exit_code: i32) -> isize { sys_exit(exit_code) } -pub fn yield_() -> isize { sys_yield() } -pub fn get_time() -> isize { sys_get_time() } \ No newline at end of file +pub fn write(fd: usize, buf: &[u8]) -> isize { + sys_write(fd, buf) +} +pub fn exit(exit_code: i32) -> isize { + sys_exit(exit_code) +} +pub fn yield_() -> isize { + sys_yield() +} +pub fn get_time() -> isize { + sys_get_time() +}