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/sys.rs

+use core::{
+    ptr::addr_of,
+    sync::atomic::{AtomicU32, Ordering},
+};
+
+use syscall::{
+    error::{Error, Result, EINTR},
+    RtSigInfo, TimeSpec,
+};
+
+use crate::{arch::manually_enter_trampoline, proc::FdGuard, signal::tmp_disable_signals, Tcb};
+
+#[inline]
+fn wrapper<T>(restart: bool, mut f: impl FnMut() -> Result<T>) -> Result<T> {
+    loop {
+        let _guard = tmp_disable_signals();
+        let rt_sigarea = unsafe { &Tcb::current().unwrap().os_specific };
+        let res = f();
+
+        if let Err(err) = res
+            && err == Error::new(EINTR)
+        {
+            unsafe {
+                manually_enter_trampoline();
+            }
+            if restart && unsafe { (*rt_sigarea.arch.get()).last_sig_was_restart } {
+                continue;
+            }
+        }
+
+        return res;
+    }
+}
+
+// TODO: uninitialized memory?
+#[inline]
+pub fn posix_read(fd: usize, buf: &mut [u8]) -> Result<usize> {
+    wrapper(true, || syscall::read(fd, buf))
+}
+#[inline]
+pub fn posix_write(fd: usize, buf: &[u8]) -> Result<usize> {
+    wrapper(true, || syscall::write(fd, buf))
+}
+#[inline]
+pub fn posix_kill(pid: usize, sig: usize) -> Result<()> {
+    match wrapper(false, || syscall::kill(pid, sig)) {
+        Ok(_) | Err(Error { errno: EINTR }) => Ok(()),
+        Err(error) => Err(error),
+    }
+}
+#[inline]
+pub fn posix_sigqueue(pid: usize, sig: usize, arg: usize) -> Result<()> {
+    let siginf = RtSigInfo {
+        arg,
+        code: -1, // TODO: SI_QUEUE constant
+        uid: 0,   // TODO
+        pid: posix_getpid(),
+    };
+    match wrapper(false, || unsafe {
+        syscall::syscall3(syscall::SYS_SIGENQUEUE, pid, sig, addr_of!(siginf) as usize)
+    }) {
+        Ok(_) | Err(Error { errno: EINTR }) => Ok(()),
+        Err(error) => Err(error),
+    }
+}
+#[inline]
+pub fn posix_getpid() -> u32 {
+    // SAFETY: read-only except during program/fork child initialization
+    unsafe { crate::THIS_PID.get().read() }
+}
+#[inline]
+pub fn posix_killpg(pgrp: usize, sig: usize) -> Result<()> {
+    match wrapper(false, || syscall::kill(usize::wrapping_neg(pgrp), sig)) {
+        Ok(_) | Err(Error { errno: EINTR }) => Ok(()),
+        Err(error) => Err(error),
+    }
+}
+#[inline]
+pub unsafe fn sys_futex_wait(addr: *mut u32, val: u32, deadline: Option<&TimeSpec>) -> Result<()> {
+    wrapper(true, || {
+        syscall::syscall5(
+            syscall::SYS_FUTEX,
+            addr as usize,
+            syscall::FUTEX_WAIT,
+            val as usize,
+            deadline.map_or(0, |d| d as *const _ as usize),
+            0,
+        )
+        .map(|_| ())
+    })
+}
+#[inline]
+pub unsafe fn sys_futex_wake(addr: *mut u32, num: u32) -> Result<u32> {
+    syscall::syscall5(
+        syscall::SYS_FUTEX,
+        addr as usize,
+        syscall::FUTEX_WAKE,
+        num as usize,
+        0,
+        0,
+    )
+    .map(|awoken| awoken as u32)
+}
+pub fn sys_waitpid(pid: usize, status: &mut usize, flags: usize) -> Result<usize> {
+    wrapper(true, || {
+        syscall::waitpid(
+            pid,
+            status,
+            syscall::WaitFlags::from_bits(flags).expect("waitpid: invalid bit pattern"),
+        )
+    })
+}
+pub fn posix_kill_thread(thread_fd: usize, signal: u32) -> Result<()> {
+    let killfd = FdGuard::new(syscall::dup(thread_fd, b"signal")?);
+    match wrapper(false, || syscall::write(*killfd, &signal.to_ne_bytes())) {
+        Ok(_) | Err(Error { errno: EINTR }) => Ok(()),
+        Err(error) => Err(error),
+    }
+}
+
+static UMASK: AtomicU32 = AtomicU32::new(0o022);
+
+/// Controls the set of bits removed from the `mode` mask when new file descriptors are created.
+///
+/// Must be validated by the caller
+//
+// TODO: validate here?
+#[inline]
+pub fn swap_umask(mask: u32) -> u32 {
+    UMASK.swap(mask, Ordering::AcqRel)
+}
+
+#[inline]
+pub fn get_umask() -> u32 {
+    UMASK.load(Ordering::Acquire)
+}

redox-rt/src/thread.rs

-use syscall::SetSighandlerData;
+use core::mem::size_of;
+
 use syscall::{Result, O_CLOEXEC};
 
-use crate::arch::*;
-use crate::proc::*;
-use crate::signal::sighandler_function;
+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<usize> {
-    let cur_pid_fd = FdGuard::new(syscall::open("thisproc:current/open_via_dup", O_CLOEXEC)?);
-    let (new_pid_fd, new_pid) = new_context()?;
+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_pid_fd, *new_pid_fd, "name")?;
+    copy_str(**cur_thr_fd, *new_thr_fd, "name")?;
 
     // Inherit existing address space
     {
-        let cur_addr_space_fd = FdGuard::new(syscall::dup(*cur_pid_fd, b"addrspace")?);
-        let new_addr_space_sel_fd = FdGuard::new(syscall::dup(*new_pid_fd, b"current-addrspace")?);
+        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,
+            __relibc_internal_rlct_clone_ret as usize,
             stack as usize,
         );
         let _ = syscall::write(*new_addr_space_sel_fd, &buf)?;
     }
 
-    // Inherit file table
+    // Inherit reference to file table
     {
-        let cur_filetable_fd = FdGuard::new(syscall::dup(*cur_pid_fd, b"filetable")?);
-        let new_filetable_sel_fd = FdGuard::new(syscall::dup(*new_pid_fd, b"current-filetable")?);
+        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,
@@ -36,37 +38,32 @@ pub unsafe fn rlct_clone_impl(stack: *mut usize) -> Result<usize> {
         )?;
     }
 
-    // Inherit sigactions (on Linux, CLONE_THREAD requires CLONE_SIGHAND which implies the sigactions
-    // table is reused).
-    {
-        let cur_sigaction_fd = FdGuard::new(syscall::dup(*cur_pid_fd, b"sigactions")?);
-        let new_sigaction_sel_fd = FdGuard::new(syscall::dup(*new_pid_fd, b"current-sigactions")?);
+    // 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.
 
-        let _ = syscall::write(
-            *new_sigaction_sel_fd,
-            &usize::to_ne_bytes(*cur_sigaction_fd),
-        )?;
-    }
-    // Inherit sighandler, but not the sigaltstack.
-    {
-        let new_sighandler_fd = FdGuard::new(syscall::dup(*new_pid_fd, b"sighandler")?);
-        let data = SetSighandlerData {
-            user_handler: sighandler_function(),
-            excp_handler: 0,
-            word_addr: 0, // TODO
-        };
-        let _ = syscall::write(*new_sighandler_fd, &data)?;
-    }
+    // Unblock context.
+    let start_fd = FdGuard::new(syscall::dup(*new_thr_fd, b"start")?);
+    let _ = syscall::write(*start_fd, &[0])?;
+
+    Ok(new_thr_fd)
+}
 
-    // Sigprocmask starts as "block all", and is initialized when the thread has actually returned
-    // from clone_ret.
+pub unsafe fn exit_this_thread(stack_base: *mut (), stack_size: usize) -> ! {
+    let _guard = tmp_disable_signals();
 
-    // TODO: Should some of these registers be inherited?
-    //copy_env_regs(*cur_pid_fd, *new_pid_fd)?;
+    let tcb = RtTcb::current();
+    let thread_fd = tcb.thread_fd();
 
-    // Unblock context.
-    let start_fd = FdGuard::new(syscall::dup(*new_pid_fd, b"start")?);
-    let _ = syscall::write(*start_fd, &[0])?;
+    let _ = syscall::funmap(tcb as *const RtTcb as usize, syscall::PAGE_SIZE);
 
-    Ok(new_pid)
+    // 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!()
 }

renamesyms.sh

 #!/bin/bash
+
+set -e
+
 target=$1
 deps_dir=$2
 
@@ -7,8 +10,18 @@ if [ -z "$target" ] || [ -z "$deps_dir" ]; then
     exit 1
 fi
 
+if [ ! -f "$target" ]; then
+    echo "Target file '$target' does not exist"
+    exit 1
+fi
+if [ ! -d "$deps_dir" ] ; then
+    echo "Deps dir '$deps_dir' does not exist or not a directory"
+    exit 1
+fi
+
 symbols_file=`mktemp`
 special_syms=(
+    __rdl_oom
     __rg_alloc
     __rg_alloc_zeroed
     __rg_dealloc
@@ -24,7 +37,7 @@ special_syms=(
 )
 
 for dep in `find $deps_dir -type f -name "*.rlib"`; do
-    "${TARGET}-nm" --format=posix -g "$dep" 2>/dev/null | sed 's/.*:.*//g' | awk '{if ($2 == "T") print $1}' | sed 's/^\(.*\)$/\1 __relibc_\1/g' >> $symbols_file
+    "${NM}" --format=posix -g "$dep" 2>/dev/null | sed 's/.*:.*//g' | awk '{if ($2 == "T") print $1}' | sed 's/^\(.*\)$/\1 __relibc_\1/g' >> $symbols_file
 done
 
 for special_sym in "${special_syms[@]}"; do
@@ -35,6 +48,6 @@ sorted_file=`mktemp`
 sort -u "$symbols_file" > "$sorted_file"
 rm -f "$symbols_file"
 
-"${TARGET}-objcopy" --redefine-syms="$sorted_file" "$target"
+"${OBJCOPY}" --redefine-syms="$sorted_file" "$target"
 
 rm -f "$sorted_file"

rust-toolchain.toml

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

src/c_str.rs

+//! Nul-terminated byte strings.
+
 use core::{marker::PhantomData, ptr::NonNull, str::Utf8Error};
 
 use alloc::{
@@ -49,7 +51,7 @@ impl<'a> CStr<'a> {
     pub fn to_string_lossy(self) -> Cow<'a, str> {
         String::from_utf8_lossy(self.to_bytes())
     }
-    pub fn as_ptr(self) -> *const c_char {
+    pub const fn as_ptr(self) -> *const c_char {
         self.ptr.as_ptr()
     }
     pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &'a [u8]) -> Self {
@@ -80,6 +82,15 @@ impl<'a> CStr<'a> {
 unsafe impl Send for CStr<'_> {}
 unsafe impl Sync for CStr<'_> {}
 
+impl From<&core::ffi::CStr> for CStr<'_> {
+    fn from(s: &core::ffi::CStr) -> Self {
+        // SAFETY:
+        // * We can assume that `s` is valid because the caller should have upheld its
+        // safety concerns when constructing it.
+        unsafe { Self::from_ptr(s.as_ptr()) }
+    }
+}
+
 #[derive(Debug)]
 pub struct FromBytesWithNulError;
 

src/c_vec.rs

+//! Equivalent of Rust's `Vec<T>`, but using relibc's own allocator.
+
 use crate::{
     io::{self, Write},
     platform::{self, types::*, WriteByte},

src/crt0/src/lib.rs

@@ -60,9 +60,20 @@ _start:
 "
 );
 
+#[cfg(target_arch = "riscv64")]
+global_asm!(
+    "
+    .globl _start
+_start:
+    mv a0, sp
+    la t0, relibc_start
+    jalr ra, t0
+"
+);
+
 #[linkage = "weak"]
 #[no_mangle]
-extern "C" fn relibc_panic(pi: &::core::panic::PanicInfo) -> ! {
+extern "C" fn relibc_panic(_pi: &::core::panic::PanicInfo) -> ! {
     loop {}
 }
 

src/crti/src/lib.rs

@@ -72,9 +72,11 @@ global_asm!(
 "#
 );
 
+// risc-v has no _init / _fini functions; it exclusively uses init/fini arrays
+
 #[linkage = "weak"]
 #[no_mangle]
-extern "C" fn relibc_panic(pi: &::core::panic::PanicInfo) -> ! {
+extern "C" fn relibc_panic(_pi: &::core::panic::PanicInfo) -> ! {
     loop {}
 }
 

src/crtn/src/lib.rs

@@ -58,9 +58,11 @@ global_asm!(
 "#
 );
 
+// risc-v has no _init / _fini functions; it exclusively uses init/fini arrays
+
 #[linkage = "weak"]
 #[no_mangle]
-extern "C" fn relibc_panic(pi: &::core::panic::PanicInfo) -> ! {
+extern "C" fn relibc_panic(_pi: &::core::panic::PanicInfo) -> ! {
     loop {}
 }
 

src/error.rs

+use alloc::boxed::Box;
+
+use crate::{header::errno::STR_ERROR, platform::types::c_int};
+
+/// Positive error codes (EINVAL, not -EINVAL).
+#[derive(Debug, Eq, PartialEq)]
+// TODO: Move to a more generic place.
+pub struct Errno(pub c_int);
+
+impl Errno {
+    pub fn sync(self) -> Self {
+        crate::platform::ERRNO.set(self.0);
+        self
+    }
+}
+
+pub type Result<T, E = Errno> = core::result::Result<T, E>;
+
+#[cfg(target_os = "redox")]
+impl From<syscall::Error> for Errno {
+    #[inline]
+    fn from(value: syscall::Error) -> Self {
+        Errno(value.errno)
+    }
+}
+#[cfg(target_os = "redox")]
+impl From<Errno> for syscall::Error {
+    #[inline]
+    fn from(value: Errno) -> Self {
+        syscall::Error::new(value.0)
+    }
+}
+
+impl From<Errno> for crate::io::Error {
+    #[inline]
+    fn from(Errno(errno): Errno) -> Self {
+        Self::from_raw_os_error(errno)
+    }
+}
+
+// TODO: core::error::Error
+
+impl core::fmt::Display for Errno {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match usize::try_from(self.0).ok().and_then(|i| STR_ERROR.get(i)) {
+            Some(desc) => write!(f, "{desc}"),
+            None => write!(f, "unknown error ({})", self.0),
+        }
+    }
+}
+
+pub trait ResultExt<T> {
+    fn or_minus_one_errno(self) -> T;
+}
+impl<T: From<i8>> ResultExt<T> for Result<T, Errno> {
+    fn or_minus_one_errno(self) -> T {
+        match self {
+            Self::Ok(v) => v,
+            Self::Err(Errno(errno)) => {
+                crate::platform::ERRNO.set(errno);
+                T::from(-1)
+            }
+        }
+    }
+}
+pub trait ResultExtPtrMut<T> {
+    fn or_errno_null_mut(self) -> *mut T;
+}
+impl<T> ResultExtPtrMut<T> for Result<*mut T, Errno> {
+    fn or_errno_null_mut(self) -> *mut T {
+        match self {
+            Self::Ok(ptr) => ptr,
+            Self::Err(Errno(errno)) => {
+                crate::platform::ERRNO.set(errno);
+                core::ptr::null_mut()
+            }
+        }
+    }
+}
+impl<T> ResultExtPtrMut<T> for Result<Box<T>, Errno> {
+    fn or_errno_null_mut(self) -> *mut T {
+        match self {
+            Self::Ok(ptr) => Box::into_raw(ptr),
+            Self::Err(Errno(errno)) => {
+                crate::platform::ERRNO.set(errno);
+                core::ptr::null_mut()
+            }
+        }
+    }
+}

src/fs.rs

 use crate::{
     c_str::CStr,
+    error::{Errno, ResultExt},
     header::{
         fcntl::O_CREAT,
         unistd::{SEEK_CUR, SEEK_END, SEEK_SET},
     },
     io,
     platform::{types::*, Pal, Sys},
-    pthread::ResultExt,
 };
 use core::ops::Deref;
 
@@ -25,39 +25,28 @@ impl File {
         }
     }
 
-    pub fn open(path: CStr, oflag: c_int) -> io::Result<Self> {
-        match Sys::open(path, oflag, 0) {
-            -1 => Err(io::last_os_error()),
-            ok => Ok(Self::new(ok)),
-        }
+    pub fn open(path: CStr, oflag: c_int) -> Result<Self, Errno> {
+        Sys::open(path, oflag, 0)
+            .map(Self::new)
+            .map_err(Errno::sync)
     }
 
-    pub fn create(path: CStr, oflag: c_int, mode: mode_t) -> io::Result<Self> {
-        match Sys::open(path, oflag | O_CREAT, mode) {
-            -1 => Err(io::last_os_error()),
-            ok => Ok(Self::new(ok)),
-        }
+    pub fn create(path: CStr, oflag: c_int, mode: mode_t) -> Result<Self, Errno> {
+        Sys::open(path, oflag | O_CREAT, mode)
+            .map(Self::new)
+            .map_err(Errno::sync)
     }
 
-    pub fn sync_all(&self) -> io::Result<()> {
-        match Sys::fsync(self.fd) {
-            -1 => Err(io::last_os_error()),
-            _ok => Ok(()),
-        }
+    pub fn sync_all(&self) -> Result<(), Errno> {
+        Sys::fsync(self.fd).map_err(Errno::sync)
     }
 
-    pub fn set_len(&self, size: u64) -> io::Result<()> {
-        match Sys::ftruncate(self.fd, size as off_t) {
-            -1 => Err(io::last_os_error()),
-            _ok => Ok(()),
-        }
+    pub fn set_len(&self, size: u64) -> Result<(), Errno> {
+        Sys::ftruncate(self.fd, size as off_t).map_err(Errno::sync)
     }
 
     pub fn try_clone(&self) -> io::Result<Self> {
-        match Sys::dup(self.fd) {
-            -1 => Err(io::last_os_error()),
-            ok => Ok(Self::new(ok)),
-        }
+        Ok(Self::new(Sys::dup(self.fd)?))
     }
 
     /// Create a new file pointing to the same underlying descriptor. This file
@@ -73,7 +62,7 @@ impl File {
 
 impl io::Read for &File {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        match Sys::read(self.fd, buf).or_minus_one_errno() /* TODO */ {
+        match Sys::read(self.fd, buf).map(|read| read as ssize_t).or_minus_one_errno() /* TODO */ {
             -1 => Err(io::last_os_error()),
             ok => Ok(ok as usize),
         }
@@ -82,7 +71,10 @@ impl io::Read for &File {
 
 impl io::Write for &File {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match Sys::write(self.fd, buf).or_minus_one_errno() {
+        match Sys::write(self.fd, buf)
+            .map(|read| read as ssize_t)
+            .or_minus_one_errno()
+        {
             -1 => Err(io::last_os_error()),
             ok => Ok(ok as usize),
         }
@@ -101,10 +93,7 @@ impl io::Seek for &File {
             io::SeekFrom::End(end) => (end as off_t, SEEK_END),
         };
 
-        match Sys::lseek(self.fd, offset, whence) {
-            -1 => Err(io::last_os_error()),
-            ok => Ok(ok as u64),
-        }
+        Ok(Sys::lseek(self.fd, offset, whence)? as u64)
     }
 }
 

src/header/arch_aarch64_user/mod.rs

@@ -20,7 +20,7 @@ pub type elf_gregset_t = [c_ulong; 34];
 pub type elf_fpregset_t = user_fpsimd_struct;
 
 #[no_mangle]
-pub extern "C" fn _cbindgen_only_generates_structs_if_they_are_mentioned_which_is_dumb_aarch64_user(
+pub extern "C" fn _cbindgen_export_aarch64_user(
     a: user_regs_struct,
     b: user_fpsimd_struct,
     c: elf_gregset_t,

src/header/arch_riscv64_user/cbindgen.toml

+sys_includes = []
+include_guard = "_RISCV64_USER_H"
+language = "C"
+style = "Tag"
+
+[enum]
+prefix_with_name = true

src/header/arch_x64_user/mod.rs

@@ -72,7 +72,7 @@ pub struct user {
 }
 
 #[no_mangle]
-pub extern "C" fn _cbindgen_only_generates_structs_if_they_are_mentioned_which_is_dumb_x86_user(
+pub extern "C" fn _cbindgen_export_x86_user(
     a: user_fpregs_struct,
     b: user_regs_struct,
     c: user,