Introduce unstable-errno feature (#110)

This will help with integrating the musl dynamic linker until a rust
replacement is written.

Author: bjorn3

Cargo.toml

@@ -121,6 +121,12 @@ fini-array = []
 # needed to support statically-linked PIE executables.
 experimental-relocate = ["rustix/mm", "rustix/runtime"]
 
+# Enable unstable support for storing C errno values in the TLS header. This
+# will likely be removed in the future and only exists to make it easier to
+# possibly integrate a dynamic linker written in C in the near future before
+# until a dynamic linker is written in Rust.
+unstable-errno = ["thread"]
+
 [package.metadata.docs.rs]
 features = ["origin-thread", "origin-signal", "origin-start"]
 rustdoc-args = ["--cfg", "doc_cfg"]

src/thread/libc.rs

@@ -1,7 +1,7 @@
 //! Thread startup and shutdown.
 
 use alloc::boxed::Box;
-use core::ffi::c_void;
+use core::ffi::{c_int, c_void};
 use core::mem::{size_of, transmute, zeroed};
 use core::ptr::{from_exposed_addr_mut, null_mut, without_provenance_mut, NonNull};
 use core::slice;
@@ -16,6 +16,7 @@ extern "C" {
         obj: *mut c_void,
         _dso_symbol: *mut c_void,
     ) -> libc::c_int;
+    fn __errno_location() -> *mut c_int;
     fn __tls_get_addr(p: &[usize; 2]) -> *mut c_void;
 
     static __dso_handle: *const c_void;
@@ -203,6 +204,15 @@ pub unsafe fn set_current_id_after_a_fork(tid: ThreadId) {
     let _ = tid;
 }
 
+/// Return the address of the thread-local `errno` state.
+///
+/// This is equivalent to `__errno_location()` in glibc and musl.
+#[cfg(feature = "unstable-errno")]
+#[inline]
+pub fn errno_location() -> *mut i32 {
+    unsafe { __errno_location() }
+}
+
 /// Return the TLS address for the given `offset` for the current thread.
 #[inline]
 #[must_use]

src/thread/linux_raw.rs

@@ -12,6 +12,8 @@ use crate::arch::{
 };
 #[cfg(feature = "alloc")]
 use alloc::boxed::Box;
+#[cfg(feature = "unstable-errno")]
+use core::cell::Cell;
 use core::cmp::max;
 use core::ffi::c_void;
 use core::mem::{align_of, size_of};
@@ -76,6 +78,8 @@ impl Thread {
 /// This is not `repr(C)` and not ABI-exposed.
 struct ThreadData {
     thread_id: AtomicI32,
+    #[cfg(feature = "unstable-errno")]
+    errno_val: Cell<i32>,
     detached: AtomicU8,
     stack_addr: *mut c_void,
     stack_size: usize,
@@ -104,6 +108,8 @@ impl ThreadData {
     ) -> Self {
         Self {
             thread_id: AtomicI32::new(ThreadId::as_raw(tid)),
+            #[cfg(feature = "unstable-errno")]
+            errno_val: Cell::new(0),
             detached: AtomicU8::new(INITIAL),
             stack_addr,
             stack_size,
@@ -1006,6 +1012,15 @@ pub unsafe fn set_current_id_after_a_fork(tid: ThreadId) {
         .store(tid.as_raw_nonzero().get(), SeqCst);
 }
 
+/// Return the address of the thread-local `errno` state.
+///
+/// This is equivalent to `__errno_location()` in glibc and musl.
+#[cfg(feature = "unstable-errno")]
+#[inline]
+pub fn errno_location() -> *mut i32 {
+    unsafe { core::ptr::addr_of_mut!((*current_metadata()).thread.errno_val).cast::<i32>() }
+}
+
 /// Return the TLS address for the given `offset` for the current thread.
 #[inline]
 #[must_use]