redox-rt/src/lib.rs

+#![no_std]
+#![feature(
+    asm_const,
+    array_chunks,
+    int_roundings,
+    let_chains,
+    slice_ptr_get,
+    sync_unsafe_cell
+)]
+#![forbid(unreachable_patterns)]
+
+use core::cell::{SyncUnsafeCell, UnsafeCell};
+
+use generic_rt::{ExpectTlsFree, GenericTcb};
+use syscall::{Sigcontrol, O_CLOEXEC};
+
+use self::proc::FdGuard;
+
+extern crate alloc;
+
+#[macro_export]
+macro_rules! asmfunction(
+    ($name:ident $(-> $ret:ty)? : [$($asmstmt:expr),*$(,)?] <= [$($decl:ident = $(sym $symname:ident)?$(const $constval:expr)?),*$(,)?]$(,)? ) => {
+        ::core::arch::global_asm!(concat!("
+            .p2align 4
+            .section .text.", stringify!($name), ", \"ax\", @progbits
+            .globl ", stringify!($name), "
+            .type ", stringify!($name), ", @function
+        ", stringify!($name), ":
+        ", $($asmstmt, "\n",)* "
+            .size ", stringify!($name), ", . - ", stringify!($name), "
+        "), $($decl = $(sym $symname)?$(const $constval)?),*);
+
+        extern "C" {
+            pub fn $name() $(-> $ret)?;
+        }
+    }
+);
+
+pub mod arch;
+pub mod proc;
+
+// TODO: Replace auxvs with a non-stack-based interface, but keep getauxval for compatibility
+#[path = "../../src/platform/auxv_defs.rs"]
+pub mod auxv_defs;
+
+pub mod signal;
+pub mod sync;
+pub mod sys;
+pub mod thread;
+
+#[derive(Debug, Default)]
+pub struct RtTcb {
+    pub control: Sigcontrol,
+    pub arch: UnsafeCell<crate::arch::SigArea>,
+    pub thr_fd: UnsafeCell<Option<FdGuard>>,
+}
+impl RtTcb {
+    pub fn current() -> &'static Self {
+        unsafe { &Tcb::current().unwrap().os_specific }
+    }
+    pub fn thread_fd(&self) -> &FdGuard {
+        unsafe {
+            if (&*self.thr_fd.get()).is_none() {
+                self.thr_fd.get().write(Some(FdGuard::new(
+                    syscall::open("/scheme/thisproc/current/open_via_dup", O_CLOEXEC).unwrap(),
+                )));
+            }
+            (&*self.thr_fd.get()).as_ref().unwrap()
+        }
+    }
+}
+
+pub type Tcb = GenericTcb<RtTcb>;
+
+/// OS and architecture specific code to activate TLS - Redox aarch64
+#[cfg(target_arch = "aarch64")]
+pub unsafe fn tcb_activate(_tcb: &RtTcb, tls_end: usize, tls_len: usize) {
+    // Uses ABI page
+    let abi_ptr = tls_end - tls_len - 16;
+    core::ptr::write(abi_ptr as *mut usize, tls_end);
+    core::arch::asm!(
+        "msr tpidr_el0, {}",
+        in(reg) abi_ptr,
+    );
+}
+
+/// OS and architecture specific code to activate TLS - Redox x86
+#[cfg(target_arch = "x86")]
+pub unsafe fn tcb_activate(tcb: &RtTcb, tls_end: usize, _tls_len: usize) {
+    let mut env = syscall::EnvRegisters::default();
+
+    let file = FdGuard::new(
+        syscall::dup(**tcb.thread_fd(), b"regs/env")
+            .expect_notls("failed to open handle for process registers"),
+    );
+
+    let _ = syscall::read(*file, &mut env).expect_notls("failed to read gsbase");
+
+    env.gsbase = tls_end as u32;
+
+    let _ = syscall::write(*file, &env).expect_notls("failed to write gsbase");
+}
+
+/// OS and architecture specific code to activate TLS - Redox x86_64
+#[cfg(target_arch = "x86_64")]
+pub unsafe fn tcb_activate(tcb: &RtTcb, tls_end_and_tcb_start: usize, _tls_len: usize) {
+    let mut env = syscall::EnvRegisters::default();
+
+    let file = FdGuard::new(
+        syscall::dup(**tcb.thread_fd(), b"regs/env")
+            .expect_notls("failed to open handle for process registers"),
+    );
+
+    let _ = syscall::read(*file, &mut env).expect_notls("failed to read fsbase");
+
+    env.fsbase = tls_end_and_tcb_start as u64;
+
+    let _ = syscall::write(*file, &env).expect_notls("failed to write fsbase");
+}
+
+/// OS and architecture specific code to activate TLS - Redox riscv64
+#[cfg(target_arch = "riscv64")]
+pub unsafe fn tcb_activate(_tcb: &RtTcb, tls_end: usize, tls_len: usize) {
+    // tp points to static tls block
+    // FIXME limited to a single initial master
+    let tls_start = tls_end - tls_len;
+    let abi_ptr = tls_start - 8;
+    core::ptr::write(abi_ptr as *mut usize, tls_end);
+    core::arch::asm!(
+        "mv tp, {}",
+        in(reg) tls_start
+    );
+}
+
+/// Initialize redox-rt in situations where relibc is not used
+pub unsafe fn initialize_freestanding() {
+    // TODO: This code is a hack! Integrate the ld_so TCB code into generic-rt, and then use that
+    // (this function will need pointers to the ELF structs normally passed in auxvs), so the TCB
+    // is initialized properly.
+
+    // TODO: TLS
+    let page = {
+        &mut *(syscall::fmap(
+            !0,
+            &syscall::Map {
+                offset: 0,
+                size: syscall::PAGE_SIZE,
+                flags: syscall::MapFlags::PROT_READ
+                    | syscall::MapFlags::PROT_WRITE
+                    | syscall::MapFlags::MAP_PRIVATE,
+                address: 0,
+            },
+        )
+        .unwrap() as *mut Tcb)
+    };
+    page.tcb_ptr = page;
+    page.tcb_len = syscall::PAGE_SIZE;
+    page.tls_end = (page as *mut Tcb).cast();
+    *page.os_specific.thr_fd.get_mut() = None;
+
+    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
+    unsafe {
+        let tcb_addr = page as *mut Tcb as usize;
+        tcb_activate(&page.os_specific, tcb_addr, 0)
+    }
+    #[cfg(target_arch = "aarch64")]
+    unsafe {
+        let abi_ptr = core::ptr::addr_of_mut!(page.tcb_ptr);
+        core::arch::asm!("msr tpidr_el0, {}", in(reg) abi_ptr);
+    }
+    #[cfg(target_arch = "riscv64")]
+    unsafe {
+        let abi_ptr = core::ptr::addr_of_mut!(page.tcb_ptr) as usize;
+        core::arch::asm!("mv tp, {}", in(reg) (abi_ptr + 8));
+    }
+    initialize();
+}
+pub unsafe fn initialize() {
+    THIS_PID
+        .get()
+        .write(Some(syscall::getpid().unwrap().try_into().unwrap()).unwrap());
+}
+
+static THIS_PID: SyncUnsafeCell<u32> = SyncUnsafeCell::new(0);
+
+unsafe fn child_hook_common(new_pid_fd: FdGuard) {
+    // TODO: Currently pidfd == threadfd, but this will not be the case later.
+    RtTcb::current().thr_fd.get().write(Some(new_pid_fd));
+    THIS_PID
+        .get()
+        .write(Some(syscall::getpid().unwrap().try_into().unwrap()).unwrap());
+}

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

rust-toolchain

-nightly-2019-11-25

rust-toolchain.toml

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