Rm spin::Mutex except for easy-fs & add new test huge_write & flush cache to disk after a write transaction

os/src/fs/inode.rs

@@ -3,18 +3,18 @@ use easy_fs::{
     Inode,
 };
 use crate::drivers::BLOCK_DEVICE;
+use crate::sync::UPSafeCell;
 use alloc::sync::Arc;
 use lazy_static::*;
 use bitflags::*;
 use alloc::vec::Vec;
-use spin::Mutex;
 use super::File;
 use crate::mm::UserBuffer;
 
 pub struct OSInode {
     readable: bool,
     writable: bool,
-    inner: Mutex<OSInodeInner>,
+    inner: UPSafeCell<OSInodeInner>,
 }
 
 pub struct OSInodeInner {
@@ -31,14 +31,14 @@ impl OSInode {
         Self {
             readable,
             writable,
-            inner: Mutex::new(OSInodeInner {
+            inner: unsafe { UPSafeCell::new(OSInodeInner {
                 offset: 0,
                 inode,
-            }),
+            })},
         }
     }
     pub fn read_all(&self) -> Vec<u8> {
-        let mut inner = self.inner.lock();
+        let mut inner = self.inner.exclusive_access();
         let mut buffer = [0u8; 512];
         let mut v: Vec<u8> = Vec::new();
         loop {
@@ -133,7 +133,7 @@ impl File for OSInode {
     fn readable(&self) -> bool { self.readable }
     fn writable(&self) -> bool { self.writable }
     fn read(&self, mut buf: UserBuffer) -> usize {
-        let mut inner = self.inner.lock();
+        let mut inner = self.inner.exclusive_access();
         let mut total_read_size = 0usize;
         for slice in buf.buffers.iter_mut() {
             let read_size = inner.inode.read_at(inner.offset, *slice);
@@ -146,7 +146,7 @@ impl File for OSInode {
         total_read_size
     }
     fn write(&self, buf: UserBuffer) -> usize {
-        let mut inner = self.inner.lock();
+        let mut inner = self.inner.exclusive_access();
         let mut total_write_size = 0usize;
         for slice in buf.buffers.iter() {
             let write_size = inner.inode.write_at(inner.offset, *slice);

os/src/fs/pipe.rs

@@ -1,26 +1,25 @@
 use super::File;
 use alloc::sync::{Arc, Weak};
-use spin::Mutex;
-use crate::mm::{
-    UserBuffer,
-};
+use crate::sync::UPSafeCell;
+use crate::mm::UserBuffer;
+
 use crate::task::suspend_current_and_run_next;
 
 pub struct Pipe {
     readable: bool,
     writable: bool,
-    buffer: Arc<Mutex<PipeRingBuffer>>,
+    buffer: Arc<UPSafeCell<PipeRingBuffer>>,
 }
 
 impl Pipe {
-    pub fn read_end_with_buffer(buffer: Arc<Mutex<PipeRingBuffer>>) -> Self {
+    pub fn read_end_with_buffer(buffer: Arc<UPSafeCell<PipeRingBuffer>>) -> Self {
         Self {
             readable: true,
             writable: false,
             buffer,
         }
     }
-    pub fn write_end_with_buffer(buffer: Arc<Mutex<PipeRingBuffer>>) -> Self {
+    pub fn write_end_with_buffer(buffer: Arc<UPSafeCell<PipeRingBuffer>>) -> Self {
         Self {
             readable: false,
             writable: true,
@@ -101,14 +100,16 @@ impl PipeRingBuffer {
 
 /// Return (read_end, write_end)
 pub fn make_pipe() -> (Arc<Pipe>, Arc<Pipe>) {
-    let buffer = Arc::new(Mutex::new(PipeRingBuffer::new()));
+    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.lock().set_write_end(&write_end);
+    buffer.exclusive_access().set_write_end(&write_end);
     (read_end, write_end)
 }
 
@@ -120,7 +121,7 @@ impl File for Pipe {
         let mut buf_iter = buf.into_iter();
         let mut read_size = 0usize;
         loop {
-            let mut ring_buffer = self.buffer.lock();
+            let mut ring_buffer = self.buffer.exclusive_access();
             let loop_read = ring_buffer.available_read();
             if loop_read == 0 {
                 if ring_buffer.all_write_ends_closed() {
@@ -146,7 +147,7 @@ impl File for Pipe {
         let mut buf_iter = buf.into_iter();
         let mut write_size = 0usize;
         loop {
-            let mut ring_buffer = self.buffer.lock();
+            let mut ring_buffer = self.buffer.exclusive_access();
             let loop_write = ring_buffer.available_write();
             if loop_write == 0 {
                 drop(ring_buffer);