Small Fix && cargo fmt

os/src/fs/inode.rs

@@ -1,15 +1,12 @@
-use easy_fs::{
-    EasyFileSystem,
-    Inode,
-};
+use super::File;
 use crate::drivers::BLOCK_DEVICE;
+use crate::mm::UserBuffer;
 use crate::sync::UPSafeCell;
 use alloc::sync::Arc;
-use lazy_static::*;
-use bitflags::*;
 use alloc::vec::Vec;
-use super::File;
-use crate::mm::UserBuffer;
+use bitflags::*;
+use easy_fs::{EasyFileSystem, Inode};
+use lazy_static::*;
 
 pub struct OSInode {
     readable: bool,
@@ -23,18 +20,11 @@ pub struct OSInodeInner {
 }
 
 impl OSInode {
-    pub fn new(
-        readable: bool,
-        writable: bool,
-        inode: Arc<Inode>,
-    ) -> Self {
+    pub fn new(readable: bool, writable: bool, inode: Arc<Inode>) -> Self {
         Self {
             readable,
             writable,
-            inner: unsafe { UPSafeCell::new(OSInodeInner {
-                offset: 0,
-                inode,
-            })},
+            inner: unsafe { UPSafeCell::new(OSInodeInner { offset: 0, inode }) },
         }
     }
     pub fn read_all(&self) -> Vec<u8> {
@@ -98,40 +88,30 @@ pub fn open_file(name: &str, flags: OpenFlags) -> Option<Arc<OSInode>> {
         if let Some(inode) = ROOT_INODE.find(name) {
             // clear size
             inode.clear();
-            Some(Arc::new(OSInode::new(
-                readable,
-                writable,
-                inode,
-            )))
+            Some(Arc::new(OSInode::new(readable, writable, inode)))
         } else {
             // create file
-            ROOT_INODE.create(name)
-                .map(|inode| {
-                    Arc::new(OSInode::new(
-                        readable,
-                        writable,
-                        inode,
-                    ))
-                })
+            ROOT_INODE
+                .create(name)
+                .map(|inode| Arc::new(OSInode::new(readable, writable, inode)))
         }
     } else {
-        ROOT_INODE.find(name)
-            .map(|inode| {
-                if flags.contains(OpenFlags::TRUNC) {
-                    inode.clear();
-                }
-                Arc::new(OSInode::new(
-                    readable,
-                    writable,
-                    inode
-                ))
-            })
+        ROOT_INODE.find(name).map(|inode| {
+            if flags.contains(OpenFlags::TRUNC) {
+                inode.clear();
+            }
+            Arc::new(OSInode::new(readable, writable, inode))
+        })
     }
 }
 
 impl File for OSInode {
-    fn readable(&self) -> bool { self.readable }
-    fn writable(&self) -> bool { self.writable }
+    fn readable(&self) -> bool {
+        self.readable
+    }
+    fn writable(&self) -> bool {
+        self.writable
+    }
     fn read(&self, mut buf: UserBuffer) -> usize {
         let mut inner = self.inner.exclusive_access();
         let mut total_read_size = 0usize;
@@ -156,4 +136,4 @@ impl File for OSInode {
         }
         total_write_size
     }
-}
+}

os/src/fs/mod.rs

@@ -1,16 +1,16 @@
+mod inode;
 mod pipe;
 mod stdio;
-mod inode;
 
 use crate::mm::UserBuffer;
 
-pub trait File : Send + Sync {
+pub trait File: Send + Sync {
     fn readable(&self) -> bool;
     fn writable(&self) -> bool;
     fn read(&self, buf: UserBuffer) -> usize;
     fn write(&self, buf: UserBuffer) -> usize;
 }
 
-pub use pipe::{Pipe, make_pipe};
+pub use inode::{list_apps, open_file, OSInode, OpenFlags};
+pub use pipe::{make_pipe, Pipe};
 pub use stdio::{Stdin, Stdout};
-pub use inode::{OSInode, open_file, OpenFlags, list_apps};

os/src/fs/pipe.rs

@@ -1,7 +1,7 @@
 use super::File;
-use alloc::sync::{Arc, Weak};
-use crate::sync::UPSafeCell;
 use crate::mm::UserBuffer;
+use crate::sync::UPSafeCell;
+use alloc::sync::{Arc, Weak};
 
 use crate::task::suspend_current_and_run_next;
 
@@ -98,22 +98,20 @@ impl PipeRingBuffer {
 
 /// Return (read_end, write_end)
 pub fn make_pipe() -> (Arc<Pipe>, Arc<Pipe>) {
-    let buffer = Arc::new(unsafe {
-        UPSafeCell::new(PipeRingBuffer::new())
-    });
-    let read_end = Arc::new(
-        Pipe::read_end_with_buffer(buffer.clone())
-    );
-    let write_end = Arc::new(
-        Pipe::write_end_with_buffer(buffer.clone())
-    );
+    let buffer = Arc::new(unsafe { UPSafeCell::new(PipeRingBuffer::new()) });
+    let read_end = Arc::new(Pipe::read_end_with_buffer(buffer.clone()));
+    let write_end = Arc::new(Pipe::write_end_with_buffer(buffer.clone()));
     buffer.exclusive_access().set_write_end(&write_end);
     (read_end, write_end)
 }
 
 impl File for Pipe {
-    fn readable(&self) -> bool { self.readable }
-    fn writable(&self) -> bool { self.writable }
+    fn readable(&self) -> bool {
+        self.readable
+    }
+    fn writable(&self) -> bool {
+        self.writable
+    }
     fn read(&self, buf: UserBuffer) -> usize {
         assert_eq!(self.readable(), true);
         let mut buf_iter = buf.into_iter();
@@ -132,7 +130,9 @@ impl File for Pipe {
             // read at most loop_read bytes
             for _ in 0..loop_read {
                 if let Some(byte_ref) = buf_iter.next() {
-                    unsafe { *byte_ref = ring_buffer.read_byte(); }
+                    unsafe {
+                        *byte_ref = ring_buffer.read_byte();
+                    }
                     read_size += 1;
                 } else {
                     return read_size;

os/src/fs/stdio.rs

@@ -1,5 +1,5 @@
 use super::File;
-use crate::mm::{UserBuffer};
+use crate::mm::UserBuffer;
 use crate::sbi::console_getchar;
 use crate::task::suspend_current_and_run_next;
 
@@ -8,8 +8,12 @@ pub struct Stdin;
 pub struct Stdout;
 
 impl File for Stdin {
-    fn readable(&self) -> bool { true }
-    fn writable(&self) -> bool { false }
+    fn readable(&self) -> bool {
+        true
+    }
+    fn writable(&self) -> bool {
+        false
+    }
     fn read(&self, mut user_buf: UserBuffer) -> usize {
         assert_eq!(user_buf.len(), 1);
         // busy loop
@@ -24,7 +28,9 @@ impl File for Stdin {
             }
         }
         let ch = c as u8;
-        unsafe { user_buf.buffers[0].as_mut_ptr().write_volatile(ch); }
+        unsafe {
+            user_buf.buffers[0].as_mut_ptr().write_volatile(ch);
+        }
         1
     }
     fn write(&self, _user_buf: UserBuffer) -> usize {
@@ -33,9 +39,13 @@ impl File for Stdin {
 }
 
 impl File for Stdout {
-    fn readable(&self) -> bool { false }
-    fn writable(&self) -> bool { true }
-    fn read(&self, _user_buf: UserBuffer) -> usize{
+    fn readable(&self) -> bool {
+        false
+    }
+    fn writable(&self) -> bool {
+        true
+    }
+    fn read(&self, _user_buf: UserBuffer) -> usize {
         panic!("Cannot read from stdout!");
     }
     fn write(&self, user_buf: UserBuffer) -> usize {
@@ -44,4 +54,4 @@ impl File for Stdout {
         }
         user_buf.len()
     }
-}
+}