redox-rt/src/arch/mod.rs

+#[cfg(target_arch = "aarch64")]
+pub use self::aarch64::*;
+#[cfg(target_arch = "aarch64")]
+pub mod aarch64;
+
+#[cfg(target_arch = "x86")]
+pub use self::i686::*;
+#[cfg(target_arch = "x86")]
+pub mod i686;
+
+#[cfg(target_arch = "x86_64")]
+pub use self::x86_64::*;
+#[cfg(target_arch = "x86_64")]
+pub mod x86_64;
+
+#[cfg(target_arch = "riscv64")]
+pub use self::riscv64::*;
+#[cfg(target_arch = "riscv64")]
+pub mod riscv64;

redox-rt/src/sync.rs

+// TODO: Share code for simple futex-based mutex between relibc's Mutex<()> and this.
+
+use core::{
+    cell::UnsafeCell,
+    ops::{Deref, DerefMut},
+    sync::atomic::{AtomicU32, Ordering},
+};
+
+pub struct Mutex<T> {
+    pub lockword: AtomicU32,
+    pub inner: UnsafeCell<T>,
+}
+
+const UNLOCKED: u32 = 0;
+const LOCKED: u32 = 1;
+const WAITING: u32 = 2;
+
+unsafe impl<T: Send> Send for Mutex<T> {}
+unsafe impl<T: Send> Sync for Mutex<T> {}
+
+impl<T> Mutex<T> {
+    pub const fn new(t: T) -> Self {
+        Self {
+            lockword: AtomicU32::new(0),
+            inner: UnsafeCell::new(t),
+        }
+    }
+    pub fn lock(&self) -> MutexGuard<'_, T> {
+        while self
+            .lockword
+            .compare_exchange(UNLOCKED, LOCKED, Ordering::Acquire, Ordering::Relaxed)
+            .is_err()
+        {
+            core::hint::spin_loop();
+        }
+        MutexGuard { lock: self }
+    }
+}
+pub struct MutexGuard<'l, T> {
+    lock: &'l Mutex<T>,
+}
+impl<T> Deref for MutexGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.lock.inner.get() }
+    }
+}
+impl<T> DerefMut for MutexGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.lock.inner.get() }
+    }
+}
+impl<T> Drop for MutexGuard<'_, T> {
+    fn drop(&mut self) {
+        self.lock.lockword.store(UNLOCKED, Ordering::Release);
+    }
+}

redox-rt/src/thread.rs

+use core::mem::size_of;
+
+use syscall::{Result, O_CLOEXEC};
+
+use crate::{arch::*, proc::*, signal::tmp_disable_signals, RtTcb};
+
+/// Spawns a new context sharing the same address space as the current one (i.e. a new thread).
+pub unsafe fn rlct_clone_impl(stack: *mut usize) -> Result<FdGuard> {
+    let cur_thr_fd = RtTcb::current().thread_fd();
+    let new_thr_fd = FdGuard::new(syscall::open(
+        "/scheme/thisproc/new-thread/open_via_dup",
+        O_CLOEXEC,
+    )?);
+
+    copy_str(**cur_thr_fd, *new_thr_fd, "name")?;
+
+    // Inherit existing address space
+    {
+        let cur_addr_space_fd = FdGuard::new(syscall::dup(**cur_thr_fd, b"addrspace")?);
+        let new_addr_space_sel_fd = FdGuard::new(syscall::dup(*new_thr_fd, b"current-addrspace")?);
+
+        let buf = create_set_addr_space_buf(
+            *cur_addr_space_fd,
+            __relibc_internal_rlct_clone_ret as usize,
+            stack as usize,
+        );
+        let _ = syscall::write(*new_addr_space_sel_fd, &buf)?;
+    }
+
+    // Inherit reference to file table
+    {
+        let cur_filetable_fd = FdGuard::new(syscall::dup(**cur_thr_fd, b"filetable")?);
+        let new_filetable_sel_fd = FdGuard::new(syscall::dup(*new_thr_fd, b"current-filetable")?);
+
+        let _ = syscall::write(
+            *new_filetable_sel_fd,
+            &usize::to_ne_bytes(*cur_filetable_fd),
+        )?;
+    }
+
+    // Since the signal handler is not yet initialized, signals specifically targeting the thread
+    // (relibc is only required to implement thread-specific signals that already originate from
+    // the same process) will be discarded. Process-specific signals will ignore this new thread,
+    // until it has initialized its own signal handler.
+
+    // Unblock context.
+    let start_fd = FdGuard::new(syscall::dup(*new_thr_fd, b"start")?);
+    let _ = syscall::write(*start_fd, &[0])?;
+
+    Ok(new_thr_fd)
+}
+
+pub unsafe fn exit_this_thread(stack_base: *mut (), stack_size: usize) -> ! {
+    let _guard = tmp_disable_signals();
+
+    let tcb = RtTcb::current();
+    let thread_fd = tcb.thread_fd();
+
+    let _ = syscall::funmap(tcb as *const RtTcb as usize, syscall::PAGE_SIZE);
+
+    // TODO: modify interface so it writes directly to the thread fd?
+    let status_fd = syscall::dup(**thread_fd, b"status").unwrap();
+    let mut buf = [0; size_of::<usize>() * 3];
+    plain::slice_from_mut_bytes(&mut buf)
+        .unwrap()
+        .copy_from_slice(&[usize::MAX, stack_base as usize, stack_size]);
+    syscall::write(status_fd, &buf).unwrap();
+    unreachable!()
+}

redoxer.sh

+#!/usr/bin/env bash
+
+set -e
+
+if ! which redoxer
+then
+    cargo install redoxer
+fi
+
+if [ ! -d "$HOME/.redoxer/toolchain" ]
+then
+    redoxer toolchain
+fi
+
+export CARGOFLAGS=""
+export CARGO_TEST="redoxer"
+export TEST_RUNNER="redoxer exec --folder . --"
+redoxer env make "$@"

rust-toolchain

-nightly-2019-08-08

rust-toolchain.toml

+[toolchain]
+channel = "nightly-2025-01-12"
+components = ["rust-src"]

src/c/fcntl.c

-#include <stdarg.h>
-#include <sys/types.h>
-
-// TODO: Can be implemented in rust when cbindgen supports "..." syntax
-
-int sys_open(const char* filename, int flags, mode_t mode);
-
-int open(const char* filename, int flags, ...) {
-    mode_t mode = 0;
-    va_list ap;
-    va_start(ap, flags);
-    mode = va_arg(ap, mode_t);
-    va_end(ap);
-    return sys_open(filename, flags, mode);
-}
-
-int sys_fcntl(int fildes, int cmd, int args);
-
-int fcntl(int fildes, int cmd, ...) {
-    int args = 0;
-    va_list ap;
-    va_start(ap, cmd);
-    args = va_arg(ap, int);
-    va_end(ap);
-    return sys_fcntl(fildes, cmd, args);
-}