Create example userspace scheme. Remove kernel duplication of syscalls, use syscall crate instead

kernel/syscall/mod.rs

@@ -1,60 +1,51 @@
 ///! Syscall handlers
 
-pub use self::call::*;
-pub use self::error::*;
+extern crate syscall;
+
+pub use self::syscall::{error, number, scheme};
+
+use self::error::{Error, Result, ENOSYS};
+use self::number::*;
 pub use self::fs::*;
 pub use self::process::*;
 pub use self::validate::*;
 
-/// System call numbers
-mod call;
-
-/// System error codes
-mod error;
-
 /// Filesystem syscalls
-mod fs;
+pub mod fs;
 
 /// Process syscalls
-mod process;
+pub mod process;
 
 /// Validate input
-mod validate;
+pub mod validate;
 
 #[no_mangle]
 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),
-                Call::Read => read(b, validate_slice_mut(c as *mut u8, d)?),
-                Call::Write => write(b, validate_slice(c as *const u8, d)?),
-                Call::Open => open(validate_slice(b as *const u8, c)?, d),
-                Call::Close => close(b),
-                Call::WaitPid => waitpid(b, c, d),
-                Call::Exec => exec(validate_slice(b as *const u8, c)?, validate_slice(d as *const [usize; 2], e)?),
-                Call::ChDir => chdir(validate_slice(b as *const u8, c)?),
-                Call::GetPid => getpid(),
-                Call::Dup => dup(b),
-                Call::Brk => brk(b),
-                Call::Iopl => iopl(b),
-                Call::FSync => fsync(b),
-                Call::Clone => clone(b, stack),
-                Call::SchedYield => sched_yield(),
-                Call::GetCwd => getcwd(validate_slice_mut(b as *mut u8, c)?)
-            },
-            None => {
+        match a {
+            SYS_EXIT => exit(b),
+            SYS_READ => read(b, validate_slice_mut(c as *mut u8, d)?),
+            SYS_WRITE => write(b, validate_slice(c as *const u8, d)?),
+            SYS_OPEN => open(validate_slice(b as *const u8, c)?, d),
+            SYS_CLOSE => close(b),
+            SYS_WAITPID => waitpid(b, c, d),
+            SYS_EXECVE => exec(validate_slice(b as *const u8, c)?, validate_slice(d as *const [usize; 2], e)?),
+            SYS_CHDIR => chdir(validate_slice(b as *const u8, c)?),
+            SYS_GETPID => getpid(),
+            SYS_DUP => dup(b),
+            SYS_BRK => brk(b),
+            SYS_IOPL => iopl(b),
+            SYS_FSYNC => fsync(b),
+            SYS_CLONE => clone(b, stack),
+            SYS_YIELD => sched_yield(),
+            SYS_GETCWD => getcwd(validate_slice_mut(b as *mut u8, c)?),
+            _ => {
                 println!("Unknown syscall {}", a);
-                Err(Error::NoCall)
+                Err(Error::new(ENOSYS))
             }
         }
     }
 
-    match inner(a, b, c, d, e, f, stack) {
-        Ok(value) => value,
-        Err(value) => (-(value as isize)) as usize
-    }
+    Error::mux(inner(a, b, c, d, e, f, stack))
 }