From b472737771ef7b3e979fc9ce4c3b4cd30cb6e400 Mon Sep 17 00:00:00 2001
From: Ruihan Li <lrh2000@pku.edu.cn>
Date: Sun, 19 Jan 2025 08:47:53 +0900
Subject: [PATCH] Resolve FIXME in pipe tests

---
 kernel/src/fs/pipe.rs | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/kernel/src/fs/pipe.rs b/kernel/src/fs/pipe.rs
index 635e6b2a..2205288b 100644
--- a/kernel/src/fs/pipe.rs
+++ b/kernel/src/fs/pipe.rs
@@ -211,8 +211,8 @@ mod test {
 
     fn test_blocking<W, R>(write: W, read: R, ordering: Ordering)
     where
-        W: Fn(Arc<PipeWriter>) + Sync + Send + 'static,
-        R: Fn(Arc<PipeReader>) + Sync + Send + 'static,
+        W: FnOnce(Arc<PipeWriter>) + Send + 'static,
+        R: FnOnce(Arc<PipeReader>) + Send + 'static,
     {
         let channel = Channel::with_capacity(2);
         let (writer, readr) = channel.split();
@@ -220,18 +220,10 @@ mod test {
         let writer = PipeWriter::new(writer, StatusFlags::empty()).unwrap();
         let reader = PipeReader::new(readr, StatusFlags::empty()).unwrap();
 
-        // FIXME: `ThreadOptions::new` currently accepts `Fn`, forcing us to use `SpinLock` to gain
-        // internal mutability. We should avoid this `SpinLock` by making `ThreadOptions::new`
-        // accept `FnOnce`.
-        let writer_with_lock: SpinLock<_> = SpinLock::new(Some(writer));
-        let reader_with_lock: SpinLock<_> = SpinLock::new(Some(reader));
-
         let signal_writer = Arc::new(AtomicBool::new(false));
         let signal_reader = signal_writer.clone();
 
         let writer = ThreadOptions::new(move || {
-            let writer = writer_with_lock.lock().take().unwrap();
-
             if ordering == Ordering::ReadThenWrite {
                 while !signal_writer.load(atomic::Ordering::Relaxed) {
                     Thread::yield_now();
@@ -245,8 +237,6 @@ mod test {
         .spawn();
 
         let reader = ThreadOptions::new(move || {
-            let reader = reader_with_lock.lock().take().unwrap();
-
             if ordering == Ordering::WriteThenRead {
                 while !signal_reader.load(atomic::Ordering::Relaxed) {
                     Thread::yield_now();