ch8

Author: lythesia

easy-fs-fuse/src/main.rs

@@ -73,6 +73,7 @@ fn easy_fs_pack() -> std::io::Result<()> {
         })
         .collect::<std::io::Result<Vec<_>>>()?;
     println!("easy-fs-use >>>>");
+    let mut size_total = 0;
     for app in apps {
         // load built app only from host file system
         let path = opt.target.join(&app);
@@ -88,12 +89,13 @@ fn easy_fs_pack() -> std::io::Result<()> {
             all_data.len(),
             all_data.len() / 1024
         );
+        size_total += all_data.len();
         // create a file in easy-fs
         let inode = root_inode.create(&app).unwrap();
         // write data to easy-fs
         inode.write_at(0, &all_data);
     }
-    println!("easy-fs-use <<<<");
+    println!("easy-fs-use (total: {}KB) <<<<", size_total / 1024);
     Ok(())
 }
 

os/src/fs/inode.rs

@@ -29,16 +29,11 @@ impl OSInode {
 
     pub fn read_all(&self) -> Vec<u8> {
         let mut inner = self.inner.exclusive_access();
-        let mut buffer = [0u8; 512];
-        let mut v = Vec::new();
-        loop {
-            let len = inner.inode.read_at(inner.offset, &mut buffer);
-            if len == 0 {
-                break;
-            }
-            inner.offset += len;
-            v.extend_from_slice(&buffer[..len]);
-        }
+        let size = inner.inode.get_size();
+        let mut v = alloc::vec![0u8; size];
+        let len = inner.inode.read_at(inner.offset, v.as_mut_slice());
+        assert_eq!(size, len);
+        inner.offset += len;
         v
     }
 
@@ -76,15 +71,6 @@ lazy_static! {
     };
 }
 
-/// List all files in the filesystems
-pub fn ls_root() {
-    println!("/**** ls / ****");
-    for app in ROOT_INODE.ls() {
-        println!("{}", app);
-    }
-    println!("**************/");
-}
-
 bitflags! {
     pub struct OpenFlags: u32 {
         const RDONLY = 0;

os/src/main.rs

@@ -99,7 +99,6 @@ pub fn rust_main() -> ! {
     trap::enable_timer_interrupt();
     timer::set_next_trigger();
 
-    fs::ls_root();
     task::run_tasks();
     panic!("Unreachable in rust_main!");
 }

os/src/mm/memory_set.rs

@@ -6,7 +6,7 @@ use lazy_static::lazy_static;
 use riscv::register::satp;
 
 use crate::{
-    config::{MEMORY_END, MMIO, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT, USER_STACK_SIZE},
+    config::{MEMORY_END, MMIO, PAGE_SIZE, TRAMPOLINE},
     mm::address::StepByOne,
     sync::UPSafeCell,
 };
@@ -176,14 +176,6 @@ impl MemorySet {
         memory_set.map_trampoline();
 
         // map kernel sections
-        // 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!("mapping kernel .text section");
         memory_set.push(
             MapArea::new(
@@ -310,30 +302,10 @@ impl MemorySet {
         let mut user_stack_bottom: usize = max_end_va.into();
         // 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,
-        );
-        // map TrapContext
-        memory_set.push(
-            MapArea::new(
-                TRAP_CONTEXT.into(),
-                TRAMPOLINE.into(),
-                MapType::Framed,
-                MapPermission::R | MapPermission::W,
-            ),
-            None,
-        );
 
         (
             memory_set,
-            user_stack_top,
+            user_stack_bottom,
             elf.header.pt2.entry_point() as usize,
         )
     }
@@ -474,5 +446,4 @@ pub fn remap_test() {
             .executable(),
         false
     );
-    println!("remap_test passed!");
 }

os/src/sync/condvar.rs

@@ -0,0 +1,42 @@
+use alloc::{collections::vec_deque::VecDeque, sync::Arc};
+
+use crate::task::{block_current_and_run_next, current_task, wakeup_task, TaskControlBlock};
+
+use super::{Mutex, UPSafeCell};
+
+pub struct CondVar {
+    pub inner: UPSafeCell<CondVarInner>,
+}
+
+pub struct CondVarInner {
+    pub wait_queue: VecDeque<Arc<TaskControlBlock>>,
+}
+
+impl CondVar {
+    pub fn new() -> Self {
+        Self {
+            inner: unsafe {
+                UPSafeCell::new(CondVarInner {
+                    wait_queue: VecDeque::new(),
+                })
+            },
+        }
+    }
+
+    pub fn signal(&self) {
+        let mut inner = self.inner.exclusive_access();
+        if let Some(task) = inner.wait_queue.pop_front() {
+            wakeup_task(task);
+        }
+    }
+
+    pub fn wait(&self, mutex: Arc<dyn Mutex>) {
+        mutex.unlock();
+        let mut inner = self.inner.exclusive_access();
+        let task = current_task().unwrap();
+        inner.wait_queue.push_back(task);
+        drop(inner);
+        block_current_and_run_next();
+        mutex.lock();
+    }
+}

os/src/sync/mod.rs

@@ -1,2 +1,11 @@
 mod up;
 pub use up::UPSafeCell;
+
+mod mutex;
+pub use mutex::{Mutex, MutexBlocking, MutexSpin};
+
+mod semaphore;
+pub use semaphore::Semaphore;
+
+mod condvar;
+pub use condvar::CondVar;

os/src/sync/mutex.rs

@@ -0,0 +1,93 @@
+use alloc::{collections::vec_deque::VecDeque, sync::Arc};
+
+use crate::task::{
+    block_current_and_run_next, current_task, suspend_current_and_run_next, wakeup_task,
+    TaskControlBlock,
+};
+
+use super::UPSafeCell;
+
+pub trait Mutex: Sync + Send {
+    fn lock(&self);
+    fn unlock(&self);
+}
+
+/// based on yield
+pub struct MutexSpin {
+    locked: UPSafeCell<bool>,
+}
+
+impl MutexSpin {
+    pub fn new() -> Self {
+        Self {
+            locked: unsafe { UPSafeCell::new(false) },
+        }
+    }
+}
+
+impl Mutex for MutexSpin {
+    fn lock(&self) {
+        loop {
+            let mut locked = self.locked.exclusive_access();
+            if *locked {
+                drop(locked);
+                suspend_current_and_run_next();
+                continue;
+            } else {
+                *locked = true;
+                return;
+            }
+        }
+    }
+
+    fn unlock(&self) {
+        let mut locked = self.locked.exclusive_access();
+        *locked = false;
+    }
+}
+
+/// based on thread blocking
+pub struct MutexBlocking {
+    inner: UPSafeCell<MutexBlockingInner>,
+}
+
+impl MutexBlocking {
+    pub fn new() -> Self {
+        Self {
+            inner: unsafe {
+                UPSafeCell::new(MutexBlockingInner {
+                    locked: false,
+                    wait_queue: VecDeque::new(),
+                })
+            },
+        }
+    }
+}
+
+struct MutexBlockingInner {
+    locked: bool,
+    wait_queue: VecDeque<Arc<TaskControlBlock>>,
+}
+
+impl Mutex for MutexBlocking {
+    fn lock(&self) {
+        let mut inner = self.inner.exclusive_access();
+        if inner.locked {
+            inner.wait_queue.push_back(current_task().unwrap());
+            drop(inner);
+            block_current_and_run_next();
+        } else {
+            inner.locked = true;
+        }
+    }
+
+    fn unlock(&self) {
+        let mut inner = self.inner.exclusive_access();
+        assert!(inner.locked);
+        if let Some(task) = inner.wait_queue.pop_front() {
+            wakeup_task(task);
+        } else {
+            inner.locked = false;
+        }
+    }
+}

os/src/sync/semaphore.rs

@@ -0,0 +1,46 @@
+use alloc::{collections::vec_deque::VecDeque, sync::Arc};
+
+use crate::task::{block_current_and_run_next, current_task, wakeup_task, TaskControlBlock};
+
+use super::UPSafeCell;
+
+pub struct Semaphore {
+    pub inner: UPSafeCell<SemaphoreInner>,
+}
+
+pub struct SemaphoreInner {
+    pub count: isize,
+    pub wait_queue: VecDeque<Arc<TaskControlBlock>>,
+}
+
+impl Semaphore {
+    pub fn new(res_count: usize) -> Self {
+        Self {
+            inner: unsafe {
+                UPSafeCell::new(SemaphoreInner {
+                    count: res_count as isize,
+                    wait_queue: VecDeque::new(),
+                })
+            },
+        }
+    }
+
+    pub fn up(&self) {
+        let mut inner = self.inner.exclusive_access();
+        inner.count += 1;
+        if let Some(task) = inner.wait_queue.pop_front() {
+            wakeup_task(task);
+        }
+    }
+
+    pub fn down(&self) {
+        let mut inner = self.inner.exclusive_access();
+        inner.count -= 1;
+        if inner.count < 0 {
+            let task = current_task().unwrap();
+            inner.wait_queue.push_back(task);
+            drop(inner);
+            block_current_and_run_next();
+        }
+    }
+}