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

kernel/syscall/futex.rs

@@ -0,0 +1,110 @@
+use alloc::arc::Arc;
+use collections::VecDeque;
+use core::intrinsics;
+use spin::{Once, RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+use context::{self, Context};
+use syscall::error::{Error, Result, ESRCH, EAGAIN, EINVAL};
+use syscall::flag::{FUTEX_WAIT, FUTEX_WAKE, FUTEX_REQUEUE};
+use syscall::validate::validate_slice_mut;
+
+type FutexList = VecDeque<(usize, Arc<RwLock<Context>>)>;
+
+/// Fast userspace mutex list
+static FUTEXES: Once<RwLock<FutexList>> = Once::new();
+
+/// Initialize futexes, called if needed
+fn init_futexes() -> RwLock<FutexList> {
+    RwLock::new(VecDeque::new())
+}
+
+/// Get the global futexes list, const
+pub fn futexes() -> RwLockReadGuard<'static, FutexList> {
+    FUTEXES.call_once(init_futexes).read()
+}
+
+/// Get the global futexes list, mutable
+pub fn futexes_mut() -> RwLockWriteGuard<'static, FutexList> {
+    FUTEXES.call_once(init_futexes).write()
+}
+
+pub fn futex(addr: &mut i32, op: usize, val: i32, val2: usize, addr2: *mut i32) -> Result<usize> {
+    match op {
+        FUTEX_WAIT => {
+            {
+                let mut futexes = futexes_mut();
+
+                let context_lock = {
+                    let contexts = context::contexts();
+                    let context_lock = contexts.current().ok_or(Error::new(ESRCH))?;
+                    context_lock.clone()
+                };
+
+                if unsafe { intrinsics::atomic_load(addr) != val } {
+                    return Err(Error::new(EAGAIN));
+                }
+
+                context_lock.write().block();
+
+                futexes.push_back((addr as *mut i32 as usize, context_lock));
+            }
+
+            unsafe { context::switch(); }
+
+            Ok(0)
+        },
+        FUTEX_WAKE => {
+            let mut woken = 0;
+
+            {
+                let mut futexes = futexes_mut();
+
+                let mut i = 0;
+                while i < futexes.len() && (woken as i32) < val {
+                    if futexes[i].0 == addr as *mut i32 as usize {
+                        if let Some(futex) = futexes.swap_remove_back(i) {
+                            futex.1.write().unblock();
+                            woken += 1;
+                        }
+                    } else {
+                        i += 1;
+                    }
+                }
+            }
+
+            Ok(woken)
+        },
+        FUTEX_REQUEUE => {
+            let addr2_safe = validate_slice_mut(addr2, 1).map(|addr2_safe| &mut addr2_safe[0])?;
+
+            let mut woken = 0;
+            let mut requeued = 0;
+
+            {
+                let mut futexes = futexes_mut();
+
+                let mut i = 0;
+                while i < futexes.len() && (woken as i32) < val {
+                    if futexes[i].0 == addr as *mut i32 as usize {
+                        if let Some(futex) = futexes.swap_remove_back(i) {
+                            futex.1.write().unblock();
+                            woken += 1;
+                        }
+                    } else {
+                        i += 1;
+                    }
+                }
+                while i < futexes.len() && requeued < val2 {
+                    if futexes[i].0 == addr as *mut i32 as usize {
+                        futexes[i].0 = addr2_safe as *mut i32 as usize;
+                        requeued += 1;
+                    }
+                    i += 1;
+                }
+            }
+
+            Ok(woken)
+        },
+        _ => Err(Error::new(EINVAL))
+    }
+}