Add boards/ && clippy

os/src/boards/k210.rs

@@ -0,0 +1,23 @@
+pub const CLOCK_FREQ: usize = 403000000 / 62;
+
+pub const MMIO: &[(usize, usize)] = &[
+    // we don't need clint in S priv when running
+    // we only need claim/complete for target0 after initializing
+    (0x0C00_0000, 0x3000), /* PLIC      */
+    (0x0C20_0000, 0x1000), /* PLIC      */
+    (0x3800_0000, 0x1000), /* UARTHS    */
+    (0x3800_1000, 0x1000), /* GPIOHS    */
+    (0x5020_0000, 0x1000), /* GPIO      */
+    (0x5024_0000, 0x1000), /* SPI_SLAVE */
+    (0x502B_0000, 0x1000), /* FPIOA     */
+    (0x502D_0000, 0x1000), /* TIMER0    */
+    (0x502E_0000, 0x1000), /* TIMER1    */
+    (0x502F_0000, 0x1000), /* TIMER2    */
+    (0x5044_0000, 0x1000), /* SYSCTL    */
+    (0x5200_0000, 0x1000), /* SPI0      */
+    (0x5300_0000, 0x1000), /* SPI1      */
+    (0x5400_0000, 0x1000), /* SPI2      */
+];
+
+pub type BlockDeviceImpl = crate::drivers::block::SDCardWrapper;
+

os/src/boards/qemu.rs

@@ -0,0 +1,6 @@
+pub const CLOCK_FREQ: usize = 12500000;
+
+pub const MMIO: &[(usize, usize)] = &[(0x10001000, 0x1000)];
+
+pub type BlockDeviceImpl = crate::drivers::block::VirtIOBlock;
+

os/src/config.rs

@@ -10,31 +10,5 @@ pub const PAGE_SIZE_BITS: usize = 0xc;
 pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
 pub const TRAP_CONTEXT_BASE: usize = TRAMPOLINE - PAGE_SIZE;
 
-#[cfg(feature = "board_k210")]
+pub use crate::board::{CLOCK_FREQ, MMIO};
-pub const CLOCK_FREQ: usize = 403000000 / 62;
 
-#[cfg(feature = "board_qemu")]
-pub const CLOCK_FREQ: usize = 12500000;
-
-#[cfg(feature = "board_qemu")]
-pub const MMIO: &[(usize, usize)] = &[(0x10001000, 0x1000)];
-
-#[cfg(feature = "board_k210")]
-pub const MMIO: &[(usize, usize)] = &[
-    // we don't need clint in S priv when running
-    // we only need claim/complete for target0 after initializing
-    (0x0C00_0000, 0x3000), /* PLIC      */
-    (0x0C20_0000, 0x1000), /* PLIC      */
-    (0x3800_0000, 0x1000), /* UARTHS    */
-    (0x3800_1000, 0x1000), /* GPIOHS    */
-    (0x5020_0000, 0x1000), /* GPIO      */
-    (0x5024_0000, 0x1000), /* SPI_SLAVE */
-    (0x502B_0000, 0x1000), /* FPIOA     */
-    (0x502D_0000, 0x1000), /* TIMER0    */
-    (0x502E_0000, 0x1000), /* TIMER1    */
-    (0x502F_0000, 0x1000), /* TIMER2    */
-    (0x5044_0000, 0x1000), /* SYSCTL    */
-    (0x5200_0000, 0x1000), /* SPI0      */
-    (0x5300_0000, 0x1000), /* SPI1      */
-    (0x5400_0000, 0x1000), /* SPI2      */
-];

os/src/drivers/block/mod.rs

@@ -1,15 +1,13 @@
 mod sdcard;
 mod virtio_blk;
 
+pub use virtio_blk::VirtIOBlock;
+pub use sdcard::SDCardWrapper;
+
 use alloc::sync::Arc;
 use easy_fs::BlockDevice;
 use lazy_static::*;
-
+use crate::board::BlockDeviceImpl;
-#[cfg(feature = "board_qemu")]
-type BlockDeviceImpl = virtio_blk::VirtIOBlock;
-
-#[cfg(feature = "board_k210")]
-type BlockDeviceImpl = sdcard::SDCardWrapper;
 
 lazy_static! {
     pub static ref BLOCK_DEVICE: Arc<dyn BlockDevice> = Arc::new(BlockDeviceImpl::new());

os/src/drivers/block/sdcard.rs

@@ -314,7 +314,7 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
             timeout -= 1;
         }
         /* After time out */
-        return 0xFF;
+        0xFF
     }
 
     /*
@@ -341,7 +341,7 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
             self.read_data(response);
         }
         /* Return response */
-        return 0;
+        0
     }
 
     /*
@@ -371,7 +371,7 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
         self.read_data(&mut csd_tab);
         self.end_cmd();
         /* see also: https://cdn-shop.adafruit.com/datasheets/TS16GUSDHC6.pdf */
-        return Ok(SDCardCSD {
+        Ok(SDCardCSD {
             /* Byte 0 */
             CSDStruct: (csd_tab[0] & 0xC0) >> 6,
             SysSpecVersion: (csd_tab[0] & 0x3C) >> 2,
@@ -424,7 +424,7 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
             CSD_CRC: (csd_tab[15] & 0xFE) >> 1,
             Reserved4: 1,
             /* Return the reponse */
-        });
+        })
     }
 
     /*
@@ -453,7 +453,7 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
         /* Get CRC bytes (not really needed by us, but required by SD) */
         self.read_data(&mut cid_tab);
         self.end_cmd();
-        return Ok(SDCardCID {
+        Ok(SDCardCID {
             /* Byte 0 */
             ManufacturerID: cid_tab[0],
             /* Byte 1, 2 */
@@ -478,7 +478,7 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
             /* Byte 15 */
             CID_CRC: (cid_tab[15] & 0xFE) >> 1,
             Reserved2: 1,
-        });
+        })
     }
 
     /*
@@ -684,7 +684,7 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
                 *a = b;
             }
             //self.write_data_dma(&mut dma_chunk);
-            self.write_data(&mut tmp_chunk);
+            self.write_data(&tmp_chunk);
             /* Put dummy CRC bytes */
             self.write_data(&[0xff, 0xff]);
             /* Read data response */

os/src/drivers/mod.rs

@@ -1,3 +1,3 @@
-mod block;
+pub mod block;
 
 pub use block::BLOCK_DEVICE;

os/src/fs/pipe.rs

@@ -32,9 +32,9 @@ const RING_BUFFER_SIZE: usize = 32;
 
 #[derive(Copy, Clone, PartialEq)]
 enum RingBufferStatus {
-    FULL,
+    Full,
-    EMPTY,
+    Empty,
-    NORMAL,
+    Normal,
 }
 
 pub struct PipeRingBuffer {
@@ -51,7 +51,7 @@ impl PipeRingBuffer {
             arr: [0; RING_BUFFER_SIZE],
             head: 0,
             tail: 0,
-            status: RingBufferStatus::EMPTY,
+            status: RingBufferStatus::Empty,
             write_end: None,
         }
     }
@@ -59,24 +59,24 @@ impl PipeRingBuffer {
         self.write_end = Some(Arc::downgrade(write_end));
     }
     pub fn write_byte(&mut self, byte: u8) {
-        self.status = RingBufferStatus::NORMAL;
+        self.status = RingBufferStatus::Normal;
         self.arr[self.tail] = byte;
         self.tail = (self.tail + 1) % RING_BUFFER_SIZE;
         if self.tail == self.head {
-            self.status = RingBufferStatus::FULL;
+            self.status = RingBufferStatus::Full;
         }
     }
     pub fn read_byte(&mut self) -> u8 {
-        self.status = RingBufferStatus::NORMAL;
+        self.status = RingBufferStatus::Normal;
         let c = self.arr[self.head];
         self.head = (self.head + 1) % RING_BUFFER_SIZE;
         if self.head == self.tail {
-            self.status = RingBufferStatus::EMPTY;
+            self.status = RingBufferStatus::Empty;
         }
         c
     }
     pub fn available_read(&self) -> usize {
-        if self.status == RingBufferStatus::EMPTY {
+        if self.status == RingBufferStatus::Empty {
             0
         } else if self.tail > self.head {
             self.tail - self.head
@@ -85,7 +85,7 @@ impl PipeRingBuffer {
         }
     }
     pub fn available_write(&self) -> usize {
-        if self.status == RingBufferStatus::FULL {
+        if self.status == RingBufferStatus::Full {
             0
         } else {
             RING_BUFFER_SIZE - self.available_read()
@@ -113,7 +113,7 @@ impl File for Pipe {
         self.writable
     }
     fn read(&self, buf: UserBuffer) -> usize {
-        assert_eq!(self.readable(), true);
+        assert!(self.readable());
         let mut buf_iter = buf.into_iter();
         let mut read_size = 0usize;
         loop {
@@ -141,7 +141,7 @@ impl File for Pipe {
         }
     }
     fn write(&self, buf: UserBuffer) -> usize {
-        assert_eq!(self.writable(), true);
+        assert!(self.writable());
         let mut buf_iter = buf.into_iter();
         let mut write_size = 0usize;
         loop {

os/src/main.rs

@@ -8,6 +8,13 @@ extern crate alloc;
 #[macro_use]
 extern crate bitflags;
 
+#[cfg(feature = "board_k210")]
+#[path = "boards/k210.rs"]
+mod board;
+#[cfg(not(any(feature = "board_k210")))]
+#[path = "boards/qemu.rs"]
+mod board;
+
 #[macro_use]
 mod console;
 mod config;

os/src/mm/address.rs

@@ -165,15 +165,15 @@ impl PhysAddr {
 }
 impl PhysPageNum {
     pub fn get_pte_array(&self) -> &'static mut [PageTableEntry] {
-        let pa: PhysAddr = self.clone().into();
+        let pa: PhysAddr = (*self).into();
         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();
+        let pa: PhysAddr = (*self).into();
         unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut u8, 4096) }
     }
     pub fn get_mut<T>(&self) -> &'static mut T {
-        let pa: PhysAddr = self.clone().into();
+        let pa: PhysAddr = (*self).into();
         pa.get_mut()
     }
 }

os/src/mm/frame_allocator.rs

@@ -72,7 +72,7 @@ impl FrameAllocator for StackFrameAllocator {
     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().any(|&v| v == ppn) {
             panic!("Frame ppn={:#x} has not been allocated!", ppn);
         }
         // recycle
@@ -101,7 +101,7 @@ pub fn frame_alloc() -> Option<FrameTracker> {
     FRAME_ALLOCATOR
         .exclusive_access()
         .alloc()
-        .map(|ppn| FrameTracker::new(ppn))
+        .map(FrameTracker::new)
 }
 
 pub fn frame_dealloc(ppn: PhysPageNum) {

os/src/mm/heap_allocator.rs

@@ -36,8 +36,8 @@ pub fn heap_test() {
     for i in 0..500 {
         v.push(i);
     }
-    for i in 0..500 {
+    for (i, val) in v.iter().take(500).enumerate() {
-        assert_eq!(v[i], i);
+        assert_eq!(*val, i);
     }
     assert!(bss_range.contains(&(v.as_ptr() as usize)));
     drop(v);

os/src/mm/memory_set.rs

@@ -291,11 +291,8 @@ impl MapArea {
         page_table.map(vpn, ppn, pte_flags);
     }
     pub fn unmap_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
-        match self.map_type {
+        if self.map_type == MapType::Framed {
-            MapType::Framed => {
+            self.data_frames.remove(&vpn);
-                self.data_frames.remove(&vpn);
-            }
-            _ => {}
         }
         page_table.unmap(vpn);
     }
@@ -354,29 +351,26 @@ pub fn remap_test() {
     let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
     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!(
+    assert!(
-        kernel_space
+        !kernel_space
             .page_table
             .translate(mid_text.floor())
             .unwrap()
             .writable(),
-        false
     );
-    assert_eq!(
+    assert!(
-        kernel_space
+        !kernel_space
             .page_table
             .translate(mid_rodata.floor())
             .unwrap()
             .writable(),
-        false,
     );
-    assert_eq!(
+    assert!(
-        kernel_space
+        !kernel_space
             .page_table
             .translate(mid_data.floor())
             .unwrap()
             .executable(),
-        false,
     );
     println!("remap_test passed!");
 }

os/src/mm/page_table.rs

@@ -77,8 +77,8 @@ impl PageTable {
         let idxs = vpn.indexes();
         let mut ppn = self.root_ppn;
         let mut result: Option<&mut PageTableEntry> = None;
-        for i in 0..3 {
+        for (i, idx) in idxs.iter().enumerate() {
-            let pte = &mut ppn.get_pte_array()[idxs[i]];
+            let pte = &mut ppn.get_pte_array()[*idx];
             if i == 2 {
                 result = Some(pte);
                 break;
@@ -96,8 +96,8 @@ impl PageTable {
         let idxs = vpn.indexes();
         let mut ppn = self.root_ppn;
         let mut result: Option<&mut PageTableEntry> = None;
-        for i in 0..3 {
+        for (i, idx) in idxs.iter().enumerate() {
-            let pte = &mut ppn.get_pte_array()[idxs[i]];
+            let pte = &mut ppn.get_pte_array()[*idx];
             if i == 2 {
                 result = Some(pte);
                 break;
@@ -122,7 +122,7 @@ impl PageTable {
         *pte = PageTableEntry::empty();
     }
     pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
-        self.find_pte(vpn).map(|pte| pte.clone())
+        self.find_pte(vpn).map(|pte| *pte)
     }
     pub fn translate_va(&self, va: VirtAddr) -> Option<PhysAddr> {
         self.find_pte(va.clone().floor()).map(|pte| {

os/src/sync/mutex.rs

@@ -78,7 +78,7 @@ impl Mutex for MutexBlocking {
 
     fn unlock(&self) {
         let mut mutex_inner = self.inner.exclusive_access();
-        assert_eq!(mutex_inner.locked, true);
+        assert!(mutex_inner.locked);
         if let Some(waking_task) = mutex_inner.wait_queue.pop_front() {
             add_task(waking_task);
         } else {

os/src/syscall/process.rs

@@ -74,11 +74,10 @@ pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
     // find a child process
 
     let mut inner = process.inner_exclusive_access();
-    if inner
+    if !inner
         .children
         .iter()
-        .find(|p| pid == -1 || pid as usize == p.getpid())
+        .any(|p| pid == -1 || pid as usize == p.getpid())
-        .is_none()
     {
         return -1;
         // ---- release current PCB

os/src/task/id.rs

@@ -31,7 +31,7 @@ impl RecycleAllocator {
     pub fn dealloc(&mut self, id: usize) {
         assert!(id < self.current);
         assert!(
-            self.recycled.iter().find(|i| **i == id).is_none(),
+            !self.recycled.iter().any(|i| *i == id),
             "id {} has been deallocated!",
             id
         );

os/src/task/manager.rs

@@ -40,7 +40,7 @@ pub fn fetch_task() -> Option<Arc<TaskControlBlock>> {
 
 pub fn pid2process(pid: usize) -> Option<Arc<ProcessControlBlock>> {
     let map = PID2PCB.exclusive_access();
-    map.get(&pid).map(|task| Arc::clone(task))
+    map.get(&pid).map(Arc::clone)
 }
 
 pub fn insert_into_pid2process(pid: usize, process: Arc<ProcessControlBlock>) {

os/src/task/mod.rs

@@ -5,6 +5,7 @@ mod process;
 mod processor;
 mod signal;
 mod switch;
+#[allow(clippy::module_inception)]
 mod task;
 
 use crate::fs::{open_file, OpenFlags};

os/src/task/processor.rs

@@ -25,7 +25,7 @@ impl Processor {
         self.current.take()
     }
     pub fn current(&self) -> Option<Arc<TaskControlBlock>> {
-        self.current.as_ref().map(|task| Arc::clone(task))
+        self.current.as_ref().map(Arc::clone)
     }
 }
 
@@ -70,8 +70,7 @@ pub fn current_process() -> Arc<ProcessControlBlock> {
 
 pub fn current_user_token() -> usize {
     let task = current_task().unwrap();
-    let token = task.get_user_token();
+    task.get_user_token()
-    token
 }
 
 pub fn current_trap_cx() -> &'static mut TrapContext {

os/src/timer.rs

@@ -65,7 +65,6 @@ pub fn check_timer() {
     while let Some(timer) = timers.peek() {
         if timer.expire_ms <= current_ms {
             add_task(Arc::clone(&timer.task));
-            drop(timer);
             timers.pop();
         } else {
             break;