futex: initial implementation

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From 7483398f8048d7b25eae2015a6d67fc1feb061e6 Mon Sep 17 00:00:00 2001
+From 60f70d42c981a6c2645201d2d0997d48f91c53a0 Mon Sep 17 00:00:00 2001
 From: Andy-Python-Programmer <[email protected]>
 Date: Thu, 10 Feb 2022 19:12:25 +1100
 Subject: [PATCH] yes
@@ -7,12 +7,12 @@ Signed-off-by: Andy-Python-Programmer <[email protected]>
 ---
  .gitignore                          |  3 +
  options/rtdl/generic/linker.cpp     |  2 +-
- sysdeps/aero/generic/aero.cpp       | 26 ++++++--
+ sysdeps/aero/generic/aero.cpp       | 40 +++++++++---
  sysdeps/aero/generic/filesystem.cpp | 97 ++++++++++++++++++++++++++---
  sysdeps/aero/generic/signals.cpp    |  8 ++-
  sysdeps/aero/generic/sockets.cpp    | 59 ++++++++++++++++++
- sysdeps/aero/include/aero/syscall.h | 12 ++++
- 7 files changed, 191 insertions(+), 16 deletions(-)
+ sysdeps/aero/include/aero/syscall.h | 14 +++++
+ 7 files changed, 205 insertions(+), 18 deletions(-)
 
 diff --git a/.gitignore b/.gitignore
 index dbb35e8b..20c8d4c3 100644
@@ -39,10 +39,35 @@ index 53264175..38ba8c9f 100644
 
  #if defined(__x86_64__)
 diff --git a/sysdeps/aero/generic/aero.cpp b/sysdeps/aero/generic/aero.cpp
-index 7de909f5..c8d076a5 100644
+index 7de909f5..8605e426 100644
 --- a/sysdeps/aero/generic/aero.cpp
 +++ b/sysdeps/aero/generic/aero.cpp
-@@ -131,12 +131,20 @@ void sys_exit(int status) {
+@@ -69,12 +69,22 @@ int sys_futex_tid() {
+ }
+ 
+ int sys_futex_wait(int *pointer, int expected, const struct timespec *time) {
+-    mlibc::infoLogger() << "sys_futex_wait() is not implemented" << frg::endlog;
++    auto result = syscall(SYS_FUTEX_WAIT, pointer, expected, time);
++
++    if (result < 0) {
++        return -result;
++    }
++
+     return 0;
+ }
+ 
+ int sys_futex_wake(int *pointer) {
+-    mlibc::infoLogger() << "sys_futex_wake() is not implemented" << frg::endlog;
++    auto result = syscall(SYS_FUTEX_WAKE, pointer);
++
++    if (result < 0) {
++        return -result;
++    }
++
+     return 0;
+ }
+ 
+@@ -131,12 +141,20 @@ void sys_exit(int status) {
  pid_t sys_getpid() {
      auto result = syscall(SYS_GETPID);
 
@@ -66,7 +91,7 @@ index 7de909f5..c8d076a5 100644
  pid_t sys_getpgid(pid_t pid, pid_t *pgid) {
      mlibc::infoLogger() << "sys_getpgid() is unimplemented" << frg::endlog;
      *pgid = 0;
-@@ -173,7 +181,15 @@ int sys_getcwd(char *buffer, size_t size) {
+@@ -173,7 +191,15 @@ int sys_getcwd(char *buffer, size_t size) {
      return 0;
  }
 
@@ -83,7 +108,7 @@ index 7de909f5..c8d076a5 100644
 
  int sys_gethostname(char *buffer, size_t bufsize) {
      auto result = syscall(SYS_GETHOSTNAME, buffer, bufsize);
-@@ -286,7 +302,7 @@ int sys_execve(const char *path, char *const argv[], char *const envp[]) {
+@@ -286,7 +312,7 @@ int sys_execve(const char *path, char *const argv[], char *const envp[]) {
      __builtin_unreachable();
  }
 
@@ -316,10 +341,10 @@ index e69de29b..b6b18fe7 100644
 +}
 +} // namespace mlibc
 diff --git a/sysdeps/aero/include/aero/syscall.h b/sysdeps/aero/include/aero/syscall.h
-index 07b1b51b..b6763b63 100644
+index 07b1b51b..4576d268 100644
 --- a/sysdeps/aero/include/aero/syscall.h
 +++ b/sysdeps/aero/include/aero/syscall.h
-@@ -49,6 +49,18 @@
+@@ -49,6 +49,20 @@
  #define SYS_DUP 42
  #define SYS_FCNTL 43
  #define SYS_DUP2 44
@@ -335,6 +360,8 @@ index 07b1b51b..b6763b63 100644
 +#define SYS_EPOLL_CTL 54
 +#define SYS_EVENT_FD 55
 +#define SYS_KILL 56
++#define SYS_FUTEX_WAIT 59
++#define SYS_FUTEX_WAKE 60
 
  // Invalid syscall used to trigger a log error in the kernel (as a hint)
  // so, that we can implement the syscall in the kernel.

src/aero_kernel/src/mem/paging/addr.rs

@@ -48,7 +48,7 @@ pub struct VirtAddr(u64);
 ///
 /// On `x86_64`, only the 52 lower bits of a physical address can be used. The top 12 bits need
 /// to be zero. This type guarantees that it always represents a valid physical address.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
 pub struct PhysAddr(u64);
 

src/aero_kernel/src/syscall/futex.rs

@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2021-2022 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+use core::sync::atomic::{AtomicU32, Ordering};
+
+use aero_syscall::{AeroSyscallError, TimeSpec};
+use alloc::sync::Arc;
+use spin::Once;
+
+use crate::mem::paging::{PhysAddr, Translate, VirtAddr};
+use crate::mem::AddressSpace;
+use crate::userland::scheduler;
+use crate::utils::sync::{BlockQueue, Mutex};
+
+pub struct FutexContainer {
+    futexes: Mutex<hashbrown::HashMap<PhysAddr, Arc<BlockQueue>>>,
+}
+
+impl FutexContainer {
+    fn new() -> Self {
+        Self {
+            futexes: Mutex::new(hashbrown::HashMap::new()),
+        }
+    }
+
+    /// Ensures the user-provided futex pointer is non-null and aligned to the alignment of
+    /// a futex word (32-bits).
+    fn validate_futex_ptr(ptr: VirtAddr) -> Result<(), AeroSyscallError> {
+        let raw = ptr.as_u64() as usize;
+
+        if raw == 0 || (raw & (core::mem::size_of::<u32>() - 1)) == 0 {
+            Err(AeroSyscallError::EINVAL)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Converts the user-provided futex word pointer to a unique futex key.
+    fn addr_as_futex_key(ptr: VirtAddr) -> Option<PhysAddr> {
+        let mut address_space = AddressSpace::this();
+        let offset_table = address_space.offset_page_table();
+
+        offset_table.translate_addr(ptr)
+    }
+
+    /// Returns the futex at the given key; allocating it if it doesn't exist.
+    fn get_alloc(&self, key: PhysAddr) -> Arc<BlockQueue> {
+        let mut container = self.futexes.lock();
+
+        if let Some(futex) = container.get(&key) {
+            futex.clone()
+        } else {
+            let futex = Arc::new(BlockQueue::new());
+            container.insert(key, futex.clone());
+            futex
+        }
+    }
+
+    /// Returns the futex at the given key, or None if it doesn't exist.
+    fn get(&self, key: PhysAddr) -> Option<Arc<BlockQueue>> {
+        self.futexes.lock_irq().get(&key).map(|e| e.clone())
+    }
+
+    /// Tests the that the value at the futex word pointed to by `uaddr` still contains the
+    /// `expected` value, and if so, it sleeps waiting for a futex wake operation on the
+    /// futex word.
+    fn wait(
+        &self,
+        uaddr: VirtAddr,
+        expected: u32,
+        _timeout: &TimeSpec,
+    ) -> Result<(), AeroSyscallError> {
+        Self::validate_futex_ptr(uaddr)?;
+
+        let key = Self::addr_as_futex_key(uaddr).ok_or(AeroSyscallError::EINVAL)?;
+        let value = uaddr
+            .read_mut::<AtomicU32>()
+            .ok_or(AeroSyscallError::EINVAL)?;
+
+        if value.load(Ordering::SeqCst) == expected {
+            let futex = self.get_alloc(key);
+
+            let scheduler = scheduler::get_scheduler();
+            let current_task = scheduler.current_task();
+
+            futex.insert(current_task.clone());
+            scheduler.inner.await_io()?;
+            futex.remove(current_task);
+
+            if futex.is_empty() {
+                self.futexes.lock().remove(&key);
+            }
+
+            Ok(())
+        } else {
+            Err(AeroSyscallError::EAGAIN)
+        }
+    }
+
+    fn wake(&self, uaddr: VirtAddr) -> Result<(), AeroSyscallError> {
+        Self::validate_futex_ptr(uaddr)?;
+
+        let key = Self::addr_as_futex_key(uaddr).ok_or(AeroSyscallError::EINVAL)?;
+        let futex = self.get(key).ok_or(AeroSyscallError::EINVAL)?;
+
+        futex.notify_complete();
+
+        // todo: early reschedule if the futex is not empty.
+        Ok(())
+    }
+}
+
+static FUTEX_CONTAINER: Once<FutexContainer> = Once::new();
+
+/// Returns a reference to the futex conatiner; initializing if necessary.
+fn get_futex_conatiner() -> &'static FutexContainer {
+    FUTEX_CONTAINER.call_once(|| FutexContainer::new())
+}
+
+#[syscall]
+pub fn wait(ptr: usize, expected: usize, timeout: &TimeSpec) -> Result<usize, AeroSyscallError> {
+    let ptr = VirtAddr::new(ptr as u64);
+
+    let futex_container = get_futex_conatiner();
+    futex_container.wait(ptr, expected as u32, timeout)?;
+
+    Ok(0)
+}
+
+#[syscall]
+pub fn wake(ptr: usize) -> Result<usize, AeroSyscallError> {
+    let ptr = VirtAddr::new(ptr as u64);
+
+    let futex_container = get_futex_conatiner();
+    futex_container.wake(ptr)?;
+
+    Ok(0)
+}

src/aero_kernel/src/syscall/mod.rs

@@ -78,11 +78,12 @@ use core::mem::MaybeUninit;
 
 use aero_syscall::prelude::*;
 
-pub mod fs;
-pub mod ipc;
+mod fs;
+mod futex;
+mod ipc;
 mod net;
-pub mod process;
-pub mod time;
+mod process;
+mod time;
 
 use alloc::boxed::Box;
 use alloc::vec::Vec;
@@ -223,6 +224,9 @@ pub fn generic_do_syscall(
         SYS_IPC_DISCOVER_ROOT => ipc::discover_root(),
         SYS_IPC_BECOME_ROOT => ipc::become_root(),
 
+        SYS_FUTEX_WAIT => futex::wait(b, c, d),
+        SYS_FUTEX_WAKE => futex::wake(b),
+
         // Syscall aliases (this should be handled in aero_syscall)
         SYS_MKDIR => fs::mkdirat(aero_syscall::AT_FDCWD as _, b, c),
 

src/aero_kernel/src/utils/sync.rs

@@ -82,6 +82,10 @@ impl BlockQueue {
             scheduler.inner.wake_up(task.clone());
         }
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.queue.lock_irq().is_empty()
+    }
 }
 
 /// Helper guard structure used to lock interrupts. When dropped, interrupts

src/aero_syscall/src/consts.rs

@@ -77,6 +77,8 @@ pub const SYS_EPOLL_PWAIT: usize = 53;
 pub const SYS_EPOLL_CTL: usize = 54;
 pub const SYS_EVENT_FD: usize = 55;
 pub const SYS_KILL: usize = 56;
+pub const SYS_FUTEX_WAIT: usize = 59;
+pub const SYS_FUTEX_WAKE: usize = 60;
 
 // constants for fcntl()'s command argument:
 pub const F_DUPFD: usize = 1;

src/aero_syscall/src/lib.rs

@@ -226,6 +226,8 @@ pub fn syscall_as_str(syscall: usize) -> &'static str {
         prelude::SYS_EPOLL_CTL => "epoll_ctl",
         prelude::SYS_EVENT_FD => "event_fd",
         prelude::SYS_KILL => "kill",
+        prelude::SYS_FUTEX_WAIT => "futex_wait",
+        prelude::SYS_FUTEX_WAKE => "futex_wake",
 
         _ => unreachable!("unknown syscall {syscall}"),
     }