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/dma/Cargo.toml

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

crates/dma/src/lib.rs

@@ -0,0 +1,80 @@
+#![feature(question_mark)]
+
+extern crate syscall;
+
+use std::{mem, ptr};
+use std::ops::{Deref, DerefMut};
+
+use syscall::Result;
+
+struct PhysBox {
+    address: usize,
+    size: usize
+}
+
+impl PhysBox {
+    fn new(size: usize) -> Result<PhysBox> {
+        let address = unsafe { syscall::physalloc(size)? };
+        Ok(PhysBox {
+            address: address,
+            size: size
+        })
+    }
+}
+
+impl Drop for PhysBox {
+    fn drop(&mut self) {
+        let _ = unsafe { syscall::physfree(self.address, self.size) };
+    }
+}
+
+pub struct Dma<T> {
+    phys: PhysBox,
+    virt: *mut T
+}
+
+impl<T> Dma<T> {
+    pub fn new(value: T) -> Result<Dma<T>> {
+        let phys = PhysBox::new(mem::size_of::<T>())?;
+        let virt = unsafe { syscall::physmap(phys.address, phys.size, syscall::MAP_WRITE)? } as *mut T;
+        unsafe { ptr::write(virt, value); }
+        Ok(Dma {
+            phys: phys,
+            virt: virt
+        })
+    }
+
+    pub fn zeroed() -> Result<Dma<T>> {
+        let phys = PhysBox::new(mem::size_of::<T>())?;
+        let virt = unsafe { syscall::physmap(phys.address, phys.size, syscall::MAP_WRITE)? } as *mut T;
+        unsafe { ptr::write_bytes(virt as *mut u8, 0, phys.size); }
+        Ok(Dma {
+            phys: phys,
+            virt: virt
+        })
+    }
+
+    pub fn physical(&self) -> usize {
+        self.phys.address
+    }
+}
+
+impl<T> Deref for Dma<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        unsafe { &*self.virt }
+    }
+}
+
+impl<T> DerefMut for Dma<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.virt }
+    }
+}
+
+impl<T> Drop for Dma<T> {
+    fn drop(&mut self) {
+        unsafe { drop(ptr::read(self.virt)); }
+        let _ = unsafe { syscall::physunmap(self.virt as usize) };
+    }
+}

crates/event/Cargo.toml

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

crates/event/src/lib.rs

@@ -0,0 +1,55 @@
+#![feature(question_mark)]
+
+extern crate syscall;
+
+use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::{Read, Error, Result};
+use std::os::unix::io::RawFd;
+
+pub struct EventQueue<R> {
+    /// The file to read events from
+    file: File,
+    /// A map of registered file descriptors to their handler callbacks
+    callbacks: BTreeMap<RawFd, Box<FnMut(usize) -> Result<Option<R>>>>
+}
+
+impl<R> EventQueue<R> {
+    /// Create a new event queue
+    pub fn new() -> Result<EventQueue<R>> {
+        Ok(EventQueue {
+            file: File::open("event:")?,
+            callbacks: BTreeMap::new()
+        })
+    }
+
+    /// Add a file to the event queue, calling a callback when an event occurs
+    ///
+    /// The callback is given a mutable reference to the file and the event data
+    /// (typically the length of data available for read)
+    ///
+    /// The callback returns Ok(None) if it wishes to continue the event loop,
+    /// or Ok(Some(R)) to break the event loop and return the value.
+    /// Err can be used to allow the callback to return an I/O error, and break the
+    /// event loop
+    pub fn add<F: FnMut(usize) -> Result<Option<R>> + 'static>(&mut self, fd: RawFd, callback: F) -> Result<()> {
+        syscall::fevent(fd, syscall::EVENT_READ).map_err(|x| Error::from_sys(x))?;
+
+        self.callbacks.insert(fd, Box::new(callback));
+
+        Ok(())
+    }
+
+    /// Process the event queue until a callback returns Some(R)
+    pub fn run(&mut self) -> Result<R> {
+        loop {
+            let mut event = syscall::Event::default();
+            self.file.read(&mut event)?;
+            if let Some(callback) = self.callbacks.get_mut(&event.id) {
+                if let Some(ret) = callback(event.data)? {
+                    return Ok(ret);
+                }
+            }
+        }
+    }
+}

crates/hole_list_allocator/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+authors = ["Philipp Oppermann <dev@phil-opp.com>"]
+name = "hole_list_allocator"
+version = "0.1.0"
+
+[dependencies]
+linked_list_allocator = { git = "https://github.com/phil-opp/linked-list-allocator.git" }
+spin = "*"

crates/hole_list_allocator/src/lib.rs

@@ -0,0 +1,62 @@
+#![feature(allocator)]
+#![feature(const_fn)]
+
+#![allocator]
+#![no_std]
+
+use spin::Mutex;
+use linked_list_allocator::Heap;
+
+extern crate spin;
+extern crate linked_list_allocator;
+
+static HEAP: Mutex<Option<Heap>> = Mutex::new(None);
+
+pub unsafe fn init(offset: usize, size: usize) {
+    *HEAP.lock() = Some(Heap::new(offset, size));
+}
+
+#[no_mangle]
+pub extern fn __rust_allocate(size: usize, align: usize) -> *mut u8 {
+    if let Some(ref mut heap) = *HEAP.lock() {
+        heap.allocate_first_fit(size, align).expect("out of memory")
+    } else {
+        panic!("__rust_allocate: heap not initialized");
+    }
+}
+
+#[no_mangle]
+pub extern fn __rust_deallocate(ptr: *mut u8, size: usize, align: usize) {
+    if let Some(ref mut heap) = *HEAP.lock() {
+        unsafe { heap.deallocate(ptr, size, align) };
+    } else {
+        panic!("__rust_deallocate: heap not initialized");
+    }
+}
+
+#[no_mangle]
+pub extern fn __rust_usable_size(size: usize, _align: usize) -> usize {
+    size
+}
+
+#[no_mangle]
+pub extern fn __rust_reallocate_inplace(_ptr: *mut u8, size: usize,
+    _new_size: usize, _align: usize) -> usize
+{
+    size
+}
+
+#[no_mangle]
+pub extern fn __rust_reallocate(ptr: *mut u8, size: usize, new_size: usize,
+                                align: usize) -> *mut u8 {
+    use core::{ptr, cmp};
+
+    // from: https://github.com/rust-lang/rust/blob/
+    //     c66d2380a810c9a2b3dbb4f93a830b101ee49cc2/
+    //     src/liballoc_system/lib.rs#L98-L101
+
+    let new_ptr = __rust_allocate(new_size, align);
+    unsafe { ptr::copy(ptr, new_ptr, cmp::min(size, new_size)) };
+    __rust_deallocate(ptr, size, align);
+    new_ptr
+}

crates/io/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "io"
+version = "0.1.0"

crates/io/src/io.rs

@@ -0,0 +1,67 @@
+use core::cmp::PartialEq;
+use core::ops::{BitAnd, BitOr, Not};
+
+pub trait Io {
+    type Value: Copy + PartialEq + BitAnd<Output = Self::Value> + BitOr<Output = Self::Value> + Not<Output = Self::Value>;
+
+    fn read(&self) -> Self::Value;
+    fn write(&mut self, value: Self::Value);
+
+    #[inline(always)]
+    fn readf(&self, flags: Self::Value) -> bool  {
+        (self.read() & flags) as Self::Value == flags
+    }
+
+    #[inline(always)]
+    fn writef(&mut self, flags: Self::Value, value: bool) {
+        let tmp: Self::Value = match value {
+            true => self.read() | flags,
+            false => self.read() & !flags,
+        };
+        self.write(tmp);
+    }
+}
+
+pub struct ReadOnly<I: Io> {
+    inner: I
+}
+
+impl<I: Io> ReadOnly<I> {
+    pub const fn new(inner: I) -> ReadOnly<I> {
+        ReadOnly {
+            inner: inner
+        }
+    }
+
+    #[inline(always)]
+    pub fn read(&self) -> I::Value {
+        self.inner.read()
+    }
+
+    #[inline(always)]
+    pub fn readf(&self, flags: I::Value) -> bool {
+        self.inner.readf(flags)
+    }
+}
+
+pub struct WriteOnly<I: Io> {
+    inner: I
+}
+
+impl<I: Io> WriteOnly<I> {
+    pub const fn new(inner: I) -> WriteOnly<I> {
+        WriteOnly {
+            inner: inner
+        }
+    }
+
+    #[inline(always)]
+    pub fn write(&mut self, value: I::Value) {
+        self.inner.write(value)
+    }
+
+    #[inline(always)]
+    pub fn writef(&mut self, flags: I::Value, value: bool) {
+        self.inner.writef(flags, value)
+    }
+}

crates/io/src/lib.rs

@@ -0,0 +1,14 @@
+//! I/O functions
+
+#![feature(asm)]
+#![feature(const_fn)]
+#![feature(core_intrinsics)]
+#![no_std]
+
+pub use self::io::*;
+pub use self::mmio::*;
+pub use self::pio::*;
+
+mod io;
+mod mmio;
+mod pio;

crates/io/src/mmio.rs

@@ -0,0 +1,31 @@
+use core::intrinsics::{volatile_load, volatile_store};
+use core::mem::uninitialized;
+use core::ops::{BitAnd, BitOr, Not};
+
+use super::io::Io;
+
+#[repr(packed)]
+pub struct Mmio<T> {
+    value: T,
+}
+
+impl<T> Mmio<T> {
+    /// Create a new Mmio without initializing
+    pub fn new() -> Self {
+        Mmio {
+            value: unsafe { uninitialized() }
+        }
+    }
+}
+
+impl<T> Io for Mmio<T> where T: Copy + PartialEq + BitAnd<Output = T> + BitOr<Output = T> + Not<Output = T> {
+    type Value = T;
+
+    fn read(&self) -> T {
+        unsafe { volatile_load(&self.value) }
+    }
+
+    fn write(&mut self, value: T) {
+        unsafe { volatile_store(&mut self.value, value) };
+    }
+}

crates/io/src/pio.rs

@@ -0,0 +1,89 @@
+use core::marker::PhantomData;
+
+use super::io::Io;
+
+/// Generic PIO
+#[derive(Copy, Clone)]
+pub struct Pio<T> {
+    port: u16,
+    value: PhantomData<T>,
+}
+
+impl<T> Pio<T> {
+    /// Create a PIO from a given port
+    pub const fn new(port: u16) -> Self {
+        Pio::<T> {
+            port: port,
+            value: PhantomData,
+        }
+    }
+}
+
+/// Read/Write for byte PIO
+impl Io for Pio<u8> {
+    type Value = u8;
+
+    /// Read
+    #[inline(always)]
+    fn read(&self) -> u8 {
+        let value: u8;
+        unsafe {
+            asm!("in $0, $1" : "={al}"(value) : "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+        value
+    }
+
+    /// Write
+    #[inline(always)]
+    fn write(&mut self, value: u8) {
+        unsafe {
+            asm!("out $1, $0" : : "{al}"(value), "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+    }
+}
+
+/// Read/Write for word PIO
+impl Io for Pio<u16> {
+    type Value = u16;
+
+    /// Read
+    #[inline(always)]
+    fn read(&self) -> u16 {
+        let value: u16;
+        unsafe {
+            asm!("in $0, $1" : "={ax}"(value) : "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+        value
+    }
+
+    /// Write
+    #[inline(always)]
+    fn write(&mut self, value: u16) {
+        unsafe {
+            asm!("out $1, $0" : : "{ax}"(value), "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+    }
+}
+
+/// Read/Write for doubleword PIO
+impl Io for Pio<u32> {
+    type Value = u32;
+
+    /// Read
+    #[inline(always)]
+    fn read(&self) -> u32 {
+        let value: u32;
+        unsafe {
+            asm!("in $0, $1" : "={eax}"(value) : "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+        value
+    }
+
+    /// Write
+    #[inline(always)]
+    fn write(&mut self, value: u32) {
+        unsafe {
+            asm!("out $1, $0" : : "{eax}"(value), "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+    }
+}

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)
+    }
+}