Implement mpsc using semaphores.

os/src/sync/mod.rs

@@ -1,5 +1,7 @@
 mod up;
 mod mutex;
+mod semaphore;
 
 pub use up::UPSafeCell;
 pub use mutex::{Mutex, MutexSpin, MutexBlocking};
+pub use semaphore::Semaphore;

os/src/sync/semaphore.rs

@@ -0,0 +1,45 @@
+use alloc::{sync::Arc, collections::VecDeque};
+use crate::task::{add_task, TaskControlBlock, current_task, block_current_and_run_next};
+use crate::sync::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 inner.count <= 0 {
+            if let Some(task) = inner.wait_queue.pop_front() {
+                add_task(task);
+            }
+        }
+    }
+
+    pub fn down(&self) {
+        let mut inner = self.inner.exclusive_access();
+        inner.count -= 1;
+        if inner.count < 0 {
+            inner.wait_queue.push_back(current_task().unwrap());
+            drop(inner);
+            block_current_and_run_next();
+        }
+    }
+}