Orbital (#16)

* Port previous ethernet scheme

* Add ipd

* Fix initfs rebuilds, use QEMU user networking addresses in ipd

* Add tcp/udp, netutils, dns, and network config

* Add fsync to network driver

* Add dns, router, subnet by default

* Fix e1000 driver. Make ethernet and IP non-blocking to avoid deadlocks

* Add orbital server, WIP

* Add futex

* Add orbutils and orbital

* Update libstd, orbutils, and orbital
Move ANSI key encoding to vesad

* Add orbital assets

* Update orbital

* Update to add login manager

* Add blocking primitives, block for most things except waitpid, update orbital

* Wait in waitpid and IRQ, improvements for other waits

* Fevent in root scheme

* WIP: Switch to using fevent

* Reorganize

* Event based e1000d driver

* Superuser-only access to some network schemes, display, and disk

* Superuser root and irq schemes

* Fix orbital

crates/resource_scheme/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "resource_scheme"
+version = "0.1.0"
+
+[dependencies.syscall]
+path = "../../syscall/"

crates/resource_scheme/src/lib.rs

@@ -0,0 +1,9 @@
+#![feature(question_mark)]
+
+extern crate syscall;
+
+pub use resource::Resource;
+pub use scheme::ResourceScheme;
+
+mod resource;
+mod scheme;

crates/resource_scheme/src/resource.rs

@@ -0,0 +1,52 @@
+use syscall::data::Stat;
+use syscall::error::*;
+
+pub trait Resource {
+    /// Duplicate the resource
+    /// Returns `EPERM` if the operation is not supported.
+    fn dup(&self) -> Result<Box<Self>> {
+        Err(Error::new(EPERM))
+    }
+
+    /// Return the path of this resource
+    /// Returns `EPERM` if the operation is not supported.
+    fn path(&self, _buf: &mut [u8]) -> Result<usize> {
+        Err(Error::new(EPERM))
+    }
+
+    /// Read data to buffer
+    /// Returns `EPERM` if the operation is not supported.
+    fn read(&mut self, _buf: &mut [u8]) -> Result<usize> {
+        Err(Error::new(EPERM))
+    }
+
+    /// Write to resource
+    /// Returns `EPERM` if the operation is not supported.
+    fn write(&mut self, _buf: &[u8]) -> Result<usize> {
+        Err(Error::new(EPERM))
+    }
+
+    /// Seek to the given offset
+    /// Returns `ESPIPE` if the operation is not supported.
+    fn seek(&mut self, _pos: usize, _whence: usize) -> Result<usize> {
+        Err(Error::new(ESPIPE))
+    }
+
+    /// Get informations about the resource, such as mode and size
+    /// Returns `EPERM` if the operation is not supported.
+    fn stat(&self, _stat: &mut Stat) -> Result<usize> {
+        Err(Error::new(EPERM))
+    }
+
+    /// Sync all buffers
+    /// Returns `EPERM` if the operation is not supported.
+    fn sync(&mut self) -> Result<usize> {
+        Err(Error::new(EPERM))
+    }
+
+    /// Truncate to the given length
+    /// Returns `EPERM` if the operation is not supported.
+    fn truncate(&mut self, _len: usize) -> Result<usize> {
+        Err(Error::new(EPERM))
+    }
+}

crates/resource_scheme/src/scheme.rs

@@ -0,0 +1,109 @@
+use std::slice;
+
+use syscall::data::{Packet, Stat};
+use syscall::error::*;
+use syscall::number::*;
+
+use super::Resource;
+
+pub trait ResourceScheme<T: Resource> {
+    fn open_resource(&self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result<Box<T>>;
+
+    fn handle(&self, packet: &mut Packet) {
+        packet.a = Error::mux(match packet.a {
+            SYS_OPEN => self.open(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d, packet.uid, packet.gid),
+            SYS_MKDIR => self.mkdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.d as u16, packet.uid, packet.gid),
+            SYS_RMDIR => self.rmdir(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid),
+            SYS_UNLINK => self.unlink(unsafe { slice::from_raw_parts(packet.b as *const u8, packet.c) }, packet.uid, packet.gid),
+
+            SYS_DUP => self.dup(packet.b),
+            SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
+            SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }),
+            SYS_LSEEK => self.seek(packet.b, packet.c, packet.d),
+            SYS_FEVENT => self.fevent(packet.b, packet.c),
+            SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
+            SYS_FSTAT => self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) }),
+            SYS_FSYNC => self.fsync(packet.b),
+            SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c),
+            SYS_CLOSE => self.close(packet.b),
+
+            _ => Err(Error::new(ENOSYS))
+        });
+    }
+
+    /* Scheme operations */
+    fn open(&self, path: &[u8], flags: usize, uid: u32, gid: u32) -> Result<usize> {
+        let resource = self.open_resource(path, flags, uid, gid)?;
+        let resource_ptr = Box::into_raw(resource);
+        Ok(resource_ptr as usize)
+    }
+
+    #[allow(unused_variables)]
+    fn mkdir(&self, path: &[u8], mode: u16, uid: u32, gid: u32) -> Result<usize> {
+        Err(Error::new(ENOENT))
+    }
+
+    #[allow(unused_variables)]
+    fn rmdir(&self, path: &[u8], uid: u32, gid: u32) -> Result<usize> {
+        Err(Error::new(ENOENT))
+    }
+
+    #[allow(unused_variables)]
+    fn unlink(&self, path: &[u8], uid: u32, gid: u32) -> Result<usize> {
+        Err(Error::new(ENOENT))
+    }
+
+    /* Resource operations */
+    fn dup(&self, old_id: usize) -> Result<usize> {
+        let old = unsafe { &*(old_id as *const T) };
+        let resource = old.dup()?;
+        let resource_ptr = Box::into_raw(resource);
+        Ok(resource_ptr as usize)
+    }
+
+    fn read(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let mut resource = unsafe { &mut *(id as *mut T) };
+        resource.read(buf)
+    }
+
+    fn write(&self, id: usize, buf: &[u8]) -> Result<usize> {
+        let mut resource = unsafe { &mut *(id as *mut T) };
+        resource.write(buf)
+    }
+
+    fn seek(&self, id: usize, pos: usize, whence: usize) -> Result<usize> {
+        let mut resource = unsafe { &mut *(id as *mut T) };
+        resource.seek(pos, whence)
+    }
+
+    #[allow(unused_variables)]
+    fn fevent(&self, id: usize, flags: usize) -> Result<usize> {
+        Err(Error::new(EBADF))
+    }
+
+    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let resource = unsafe { &*(id as *const T) };
+        resource.path(buf)
+    }
+
+    fn fstat(&self, id: usize, stat: &mut Stat) -> Result<usize> {
+        let resource = unsafe { &*(id as *const T) };
+        resource.stat(stat)
+    }
+
+    fn fsync(&self, id: usize) -> Result<usize> {
+        let mut resource = unsafe { &mut *(id as *mut T) };
+        resource.sync()
+    }
+
+    fn ftruncate(&self, id: usize, len: usize) -> Result<usize> {
+        let mut resource = unsafe { &mut *(id as *mut T) };
+        resource.truncate(len)
+    }
+
+    fn close(&self, id: usize) -> Result<usize> {
+        let resource = unsafe { Box::from_raw(id as *mut T) };
+        drop(resource);
+        Ok(0)
+    }
+}