Fix deadlock

kernel/scheme/root.rs

@@ -2,7 +2,6 @@ use alloc::arc::Arc;
 use alloc::boxed::Box;
 use collections::BTreeMap;
 use core::sync::atomic::{AtomicUsize, Ordering};
-use core::str;
 use spin::RwLock;
 
 use syscall::{Error, Result};
@@ -24,7 +23,7 @@ impl RootScheme {
 }
 
 impl Scheme for RootScheme {
-    fn open(&self, path: &[u8], flags: usize) -> Result<usize> {
+    fn open(&self, path: &[u8], _flags: usize) -> Result<usize> {
         let inner = {
             let mut schemes = scheme::schemes_mut();
             if schemes.get_name(path).is_some() {
@@ -42,14 +41,14 @@ impl Scheme for RootScheme {
     }
 
     fn dup(&self, file: usize) -> Result<usize> {
+        let mut handles = self.handles.write();
         let inner = {
-            let handles = self.handles.read();
             let inner = handles.get(&file).ok_or(Error::BadFile)?;
             inner.clone()
         };
 
         let id = self.next_id.fetch_add(1, Ordering::SeqCst);
-        self.handles.write().insert(id, inner);
+        handles.insert(id, inner);
 
         Ok(id)
     }

kernel/scheme/user.rs

@@ -48,9 +48,12 @@ impl UserInner {
         self.todo.lock().push_back(packet);
 
         loop {
-            if let Some(a) = self.done.lock().remove(&id) {
+            {
+                let mut done = self.done.lock();
+                if let Some(a) = done.remove(&id) {
                     return convert_to_result(a);
                 }
+            }
 
             unsafe { context::switch(); }
         }
@@ -89,7 +92,6 @@ impl UserInner {
         while i < len {
             let packet = unsafe { *(buf.as_ptr() as *const Packet).offset(i as isize) };
             self.done.lock().insert(packet.id, packet.a);
-
             i += 1;
         }
 

kernel/syscall/mod.rs

@@ -25,6 +25,8 @@ mod validate;
 pub extern fn syscall(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, stack: usize) -> usize {
     #[inline(always)]
     fn inner(a: usize, b: usize, c: usize, d: usize, e: usize, _f: usize, stack: usize) -> Result<usize> {
+        //println!("{}: {:?}: {} {} {} {}", ::context::context_id(), Call::from(a), a, b, c, d);
+
         match Call::from(a) {
             Some(call) => match call {
                 Call::Exit => exit(b),

kernel/syscall/process.rs

@@ -174,9 +174,13 @@ pub fn clone(flags: usize, stack_base: usize) -> Result<usize> {
             if flags & CLONE_FILES == CLONE_FILES {
                 files = context.files.clone();
             } else {
-                let mut files_vec = Vec::new();
+                files = Arc::new(Mutex::new(context.files.lock().clone()));
-                for (fd, file_option) in context.files.lock().iter().enumerate() {
+            }
-                    if let Some(file) = *file_option {
+        }
+
+        if flags & CLONE_FILES == 0 {
+            for (fd, mut file_option) in files.lock().iter_mut().enumerate() {
+                let new_file_option = if let Some(file) = *file_option {
                     let result = {
                         let scheme = {
                             let schemes = scheme::schemes();
@@ -188,17 +192,18 @@ pub fn clone(flags: usize, stack_base: usize) -> Result<usize> {
                     };
                     match result {
                         Ok(new_number) => {
-                                files_vec.push(Some(context::file::File { scheme: file.scheme, number: new_number }));
+                            Some(context::file::File { scheme: file.scheme, number: new_number })
                         },
                         Err(err) => {
                             println!("clone: failed to dup {}: {:?}", fd, err);
+                            None
                         }
                     }
                 } else {
-                        files_vec.push(None);
+                    None
-                    }
+                };
-                }
+
-                files = Arc::new(Mutex::new(files_vec));
+                *file_option = new_file_option;
             }
         }