Add fsync. Add env scheme, currently hardcoded to get ion to launch. Make serial IRQ send data to debug scheme

kernel/syscall/call.rs

@@ -29,6 +29,8 @@ pub enum Call {
     Brk = 45,
     /// Set process I/O privilege level
     Iopl = 110,
+    /// Sync file descriptor
+    FSync = 118,
     /// Clone process
     Clone = 120,
     /// Yield to scheduler
@@ -55,6 +57,7 @@ impl Call {
             41 => Ok(Call::Dup),
             45 => Ok(Call::Brk),
             110 => Ok(Call::Iopl),
+            118 => Ok(Call::FSync),
             120 => Ok(Call::Clone),
             158 => Ok(Call::SchedYield),
             183 => Ok(Call::GetCwd),

kernel/syscall/fs.rs

@@ -120,3 +120,18 @@ pub fn dup(fd: usize) -> Result<usize> {
     let result = scheme_mutex.lock().dup(file.number);
     result
 }
+
+pub fn fsync(fd: usize) -> Result<usize> {
+    let file = {
+        let contexts = context::contexts();
+        let context_lock = contexts.current().ok_or(Error::NoProcess)?;
+        let context = context_lock.read();
+        let file = context.get_file(fd).ok_or(Error::BadFile)?;
+        file
+    };
+
+    let schemes = scheme::schemes();
+    let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
+    let result = scheme_mutex.lock().fsync(file.number).and(Ok(0));
+    result
+}

kernel/syscall/mod.rs

@@ -39,6 +39,7 @@ pub extern fn syscall(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize
                 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)?)