Couple of refactorings to make adding dynamic linker support easier (#111)

* Move the relocate call from init_runtime to entry

Self-relocation is not actually initializing runtime state, but making
it possible to safely run any code at all. When using a dynamic linker
the dynamic linker needs to be relocated before it can do dynamic
linking, but some of the runtime intialization needs to happen after
dynamic linking when all static DSO's that use thread local storage are
known.

* Always write thread_id field after initializing thread metadata

Also move writing __stack_chk_guard earlier. This makes future
refactorings easier.

Author: bjorn3

src/program.rs

@@ -90,6 +90,13 @@ pub(super) unsafe extern "C" fn entry(mem: *mut usize) -> ! {
     // Compute `argc`, `argv`, and `envp`.
     let (argc, argv, envp) = compute_args(mem);
 
+    // Before doing anything else, perform dynamic relocations.
+    #[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
+    #[cfg(relocation_model = "pic")]
+    {
+        crate::relocate::relocate(envp);
+    }
+
     // Initialize program state before running any user code.
     init_runtime(mem, envp);
 
@@ -187,8 +194,7 @@ unsafe fn compute_args(mem: *mut usize) -> (i32, *mut *mut u8, *mut *mut u8) {
     (argc, argv, envp)
 }
 
-/// Perform dynamic relocation (if enabled), and initialize `origin` and
-/// `rustix` runtime state.
+/// Initialize `origin` and `rustix` runtime state.
 ///
 /// # Safety
 ///
@@ -197,11 +203,6 @@ unsafe fn compute_args(mem: *mut usize) -> (i32, *mut *mut u8, *mut *mut u8) {
 #[cfg(feature = "origin-program")]
 #[allow(unused_variables)]
 unsafe fn init_runtime(mem: *mut usize, envp: *mut *mut u8) {
-    // Before doing anything else, perform dynamic relocations.
-    #[cfg(all(feature = "experimental-relocate", feature = "origin-start"))]
-    #[cfg(relocation_model = "pic")]
-    crate::relocate::relocate(envp);
-
     // Explicitly initialize `rustix`. This is needed for things like
     // `page_size()` to work.
     #[cfg(feature = "param")]

src/thread/linux_raw.rs

@@ -99,15 +99,9 @@ const ABANDONED: u8 = 2;
 
 impl ThreadData {
     #[inline]
-    fn new(
-        tid: Option<ThreadId>,
-        stack_addr: *mut c_void,
-        stack_size: usize,
-        guard_size: usize,
-        map_size: usize,
-    ) -> Self {
+    fn new(stack_addr: *mut c_void, stack_size: usize, guard_size: usize, map_size: usize) -> Self {
         Self {
-            thread_id: AtomicI32::new(ThreadId::as_raw(tid)),
+            thread_id: AtomicI32::new(0),
             #[cfg(feature = "unstable-errno")]
             errno_val: Cell::new(0),
             detached: AtomicU8::new(INITIAL),
@@ -336,6 +330,12 @@ pub(super) unsafe fn initialize_main(mem: *mut c_void) {
     let stack_least = stack_base.cast::<u8>().sub(stack_map_size);
     let stack_size = stack_least.offset_from(mem.cast::<u8>()) as usize;
     let guard_size = page_size();
+
+    // Initialize the canary value from the OS-provided random bytes.
+    let random_ptr = rustix::runtime::random().cast::<usize>();
+    let canary = random_ptr.read_unaligned();
+    __stack_chk_guard = canary;
+
     let map_size = 0;
 
     // Compute relevant alignments.
@@ -390,14 +390,6 @@ pub(super) unsafe fn initialize_main(mem: *mut c_void) {
     let metadata: *mut Metadata = new.add(header).cast();
     let newtls: *mut c_void = (*metadata).abi.thread_pointee.as_mut_ptr().cast();
 
-    let thread_id_ptr = (*metadata).thread.thread_id.as_ptr();
-    let tid = rustix::runtime::set_tid_address(thread_id_ptr.cast());
-
-    // Initialize the canary value from the OS-provided random bytes.
-    let random_ptr = rustix::runtime::random().cast::<usize>();
-    let canary = random_ptr.read_unaligned();
-    __stack_chk_guard = canary;
-
     // Initialize the thread metadata.
     metadata.write(Metadata {
         abi: Abi {
@@ -408,13 +400,7 @@ pub(super) unsafe fn initialize_main(mem: *mut c_void) {
             _pad: Default::default(),
             thread_pointee: [],
         },
-        thread: ThreadData::new(
-            Some(tid),
-            stack_least.cast(),
-            stack_size,
-            guard_size,
-            map_size,
-        ),
+        thread: ThreadData::new(stack_least.cast(), stack_size, guard_size, map_size),
     });
 
     // Initialize the TLS data with explicit initializer data.
@@ -432,6 +418,10 @@ pub(super) unsafe fn initialize_main(mem: *mut c_void) {
     )
     .fill(0);
 
+    let thread_id_ptr = (*metadata).thread.thread_id.as_ptr();
+    let tid = rustix::runtime::set_tid_address(thread_id_ptr.cast());
+    *thread_id_ptr = tid.as_raw_nonzero().get();
+
     // Point the platform thread-pointer register at the new thread metadata.
     set_thread_pointer(newtls);
 }
@@ -544,13 +534,7 @@ pub unsafe fn create(
                 _pad: Default::default(),
                 thread_pointee: [],
             },
-            thread: ThreadData::new(
-                None, // the real tid will be written by `clone`.
-                stack_least.cast(),
-                stack_size,
-                guard_size,
-                map_size,
-            ),
+            thread: ThreadData::new(stack_least.cast(), stack_size, guard_size, map_size),
         });
 
         // Initialize the TLS data with explicit initializer data.