Redesign create_thread to avoid dynamic allocation. (#94)

Change `create_thread` from taking a boxed closure to taking a function
pointer, as well as an array of pointers to be copied into the new thread
to pass to the function. This avoids the need to dynamically allocate for
a `Box`, and in particular it allows c-ward's `pthread_create` to be used
from within `malloc` implementations.

And, implement thread return values, which is simpler with the removal of
`Option<Box<dyn Any>>`.

These changes do create more work for users of the API, however it also
gives them more control.

Fixes #85.

Author: sunfishcode

example-crates/basic/src/main.rs

@@ -9,18 +9,21 @@ fn main() {
         eprintln!("Hello from a main-thread at_thread_exit handler")
     }));
 
-    let thread = create_thread(
-        Box::new(|| {
-            eprintln!("Hello from child thread");
-            at_thread_exit(Box::new(|| {
-                eprintln!("Hello from child thread's at_thread_exit handler")
-            }));
-            None
-        }),
-        default_stack_size(),
-        default_guard_size(),
-    )
-    .unwrap();
+    let thread = unsafe {
+        create_thread(
+            |_args| {
+                eprintln!("Hello from child thread");
+                at_thread_exit(Box::new(|| {
+                    eprintln!("Hello from child thread's at_thread_exit handler")
+                }));
+                None
+            },
+            &[],
+            default_stack_size(),
+            default_guard_size(),
+        )
+        .unwrap()
+    };
 
     unsafe {
         join_thread(thread);

example-crates/external-start/src/main.rs

@@ -65,13 +65,14 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
     }));
 
     let thread = create_thread(
-        Box::new(|| {
+        |_args| {
             eprintln!("Hello from child thread");
             at_thread_exit(Box::new(|| {
                 eprintln!("Hello from child thread's at_thread_exit handler")
             }));
             None
-        }),
+        },
+        &[],
         default_stack_size(),
         default_guard_size(),
     )

example-crates/no-std/src/main.rs

@@ -34,18 +34,21 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
         eprintln!("Hello from a main-thread at_thread_exit handler")
     }));
 
-    let thread = create_thread(
-        Box::new(|| {
-            eprintln!("Hello from child thread");
-            at_thread_exit(Box::new(|| {
-                eprintln!("Hello from child thread's at_thread_exit handler")
-            }));
-            None
-        }),
-        default_stack_size(),
-        default_guard_size(),
-    )
-    .unwrap();
+    let thread = unsafe {
+        create_thread(
+            |_args| {
+                eprintln!("Hello from child thread");
+                at_thread_exit(Box::new(|| {
+                    eprintln!("Hello from child thread's at_thread_exit handler")
+                }));
+                None
+            },
+            &[],
+            default_stack_size(),
+            default_guard_size(),
+        )
+        .unwrap()
+    };
 
     unsafe {
         join_thread(thread);

example-crates/origin-start-lto/src/main.rs

@@ -36,13 +36,14 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
     }));
 
     let thread = create_thread(
-        Box::new(|| {
+        |_args| {
             eprintln!("Hello from child thread");
             at_thread_exit(Box::new(|| {
                 eprintln!("Hello from child thread's at_thread_exit handler")
             }));
             None
-        }),
+        },
+        &[],
         default_stack_size(),
         default_guard_size(),
     )

example-crates/origin-start/src/main.rs

@@ -36,13 +36,14 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
     }));
 
     let thread = create_thread(
-        Box::new(|| {
+        |_args| {
             eprintln!("Hello from child thread");
             at_thread_exit(Box::new(|| {
                 eprintln!("Hello from child thread's at_thread_exit handler")
             }));
             None
-        }),
+        },
+        &[],
         default_stack_size(),
         default_guard_size(),
     )

src/arch/aarch64.rs

@@ -8,8 +8,6 @@ use linux_raw_sys::general::__NR_rt_sigreturn;
 use linux_raw_sys::general::{__NR_mprotect, PROT_READ};
 #[cfg(feature = "origin-thread")]
 use {
-    alloc::boxed::Box,
-    core::any::Any,
     core::ffi::c_void,
     linux_raw_sys::general::{__NR_clone, __NR_exit, __NR_munmap},
     rustix::thread::RawPid,
@@ -131,6 +129,10 @@ pub(super) unsafe fn relocation_mprotect_readonly(ptr: usize, len: usize) {
     assert_eq!(r0, 0);
 }
 
+/// The required alignment for the stack pointer.
+#[cfg(feature = "origin-thread")]
+pub(super) const STACK_ALIGNMENT: usize = 16;
+
 /// A wrapper around the Linux `clone` system call.
 ///
 /// This can't be implemented in `rustix` because the child starts executing at
@@ -144,7 +146,8 @@ pub(super) unsafe fn clone(
     parent_tid: *mut RawPid,
     child_tid: *mut RawPid,
     newtls: *mut c_void,
-    fn_: *mut Box<dyn FnOnce() -> Option<Box<dyn Any>> + Send>,
+    fn_: extern "C" fn(),
+    num_args: usize,
 ) -> isize {
     let r0;
     asm!(
@@ -153,6 +156,8 @@ pub(super) unsafe fn clone(
 
         // Child thread.
         "mov x0, {fn_}",      // Pass `fn_` as the first argument.
+        "mov x1, sp",         // Pass the args pointer as the second argument.
+        "mov x2, {num_args}", // Pass `num_args` as the third argument.
         "mov x29, xzr",       // Zero the frame address.
         "mov x30, xzr",       // Zero the return address.
         "b {entry}",          // Call `entry`.
@@ -162,6 +167,7 @@ pub(super) unsafe fn clone(
 
         entry = sym super::thread::entry,
         fn_ = in(reg) fn_,
+        num_args = in(reg) num_args,
         in("x8") __NR_clone,
         inlateout("x0") flags as usize => r0,
         in("x1") child_stack,

src/arch/arm.rs

@@ -8,8 +8,6 @@ use linux_raw_sys::general::{__NR_mprotect, PROT_READ};
 use linux_raw_sys::general::{__NR_rt_sigreturn, __NR_sigreturn};
 #[cfg(feature = "origin-thread")]
 use {
-    alloc::boxed::Box,
-    core::any::Any,
     core::ffi::c_void,
     linux_raw_sys::general::{__NR_clone, __NR_exit, __NR_munmap},
     rustix::thread::RawPid,
@@ -131,6 +129,10 @@ pub(super) unsafe fn relocation_mprotect_readonly(ptr: usize, len: usize) {
     assert_eq!(r0, 0);
 }
 
+/// The required alignment for the stack pointer.
+#[cfg(feature = "origin-thread")]
+pub(super) const STACK_ALIGNMENT: usize = 4;
+
 /// A wrapper around the Linux `clone` system call.
 ///
 /// This can't be implemented in `rustix` because the child starts executing at
@@ -144,7 +146,8 @@ pub(super) unsafe fn clone(
     parent_tid: *mut RawPid,
     child_tid: *mut RawPid,
     newtls: *mut c_void,
-    fn_: *mut Box<dyn FnOnce() -> Option<Box<dyn Any>> + Send>,
+    fn_: extern "C" fn(),
+    num_args: usize,
 ) -> isize {
     let r0;
     asm!(
@@ -154,6 +157,8 @@ pub(super) unsafe fn clone(
 
         // Child thread.
         "mov r0, {fn_}",      // Pass `fn_` as the first argument.
+        "mov r1, sp",         // Pass the args pointer as the second argument.
+        "mov r2, {num_args}", // Pass `num_args` as the third argument.
         "mov fp, #0",         // Zero the frame address.
         "mov lr, #0",         // Zero the return address.
         "b {entry}",          // Call `entry`.
@@ -163,6 +168,7 @@ pub(super) unsafe fn clone(
 
         entry = sym super::thread::entry,
         fn_ = in(reg) fn_,
+        num_args = in(reg) num_args,
         in("r7") __NR_clone,
         inlateout("r0") flags as usize => r0,
         in("r1") child_stack,

src/arch/riscv64.rs

@@ -7,8 +7,6 @@ use core::arch::asm;
 use linux_raw_sys::general::{__NR_mprotect, PROT_READ};
 #[cfg(feature = "origin-thread")]
 use {
-    alloc::boxed::Box,
-    core::any::Any,
     core::ffi::c_void,
     linux_raw_sys::general::{__NR_clone, __NR_exit, __NR_munmap},
     rustix::thread::RawPid,
@@ -131,6 +129,10 @@ pub(super) unsafe fn relocation_mprotect_readonly(ptr: usize, len: usize) {
     assert_eq!(r0, 0);
 }
 
+/// The required alignment for the stack pointer.
+#[cfg(feature = "origin-thread")]
+pub(super) const STACK_ALIGNMENT: usize = 16;
+
 /// A wrapper around the Linux `clone` system call.
 ///
 /// This can't be implemented in `rustix` because the child starts executing at
@@ -144,7 +146,8 @@ pub(super) unsafe fn clone(
     parent_tid: *mut RawPid,
     child_tid: *mut RawPid,
     newtls: *mut c_void,
-    fn_: *mut Box<dyn FnOnce() -> Option<Box<dyn Any>> + Send>,
+    fn_: extern "C" fn(),
+    num_args: usize,
 ) -> isize {
     let r0;
     asm!(
@@ -153,6 +156,8 @@ pub(super) unsafe fn clone(
 
         // Child thread.
         "mv a0, {fn_}",       // Pass `fn_` as the first argument.
+        "mv a1, sp",          // Pass the args pointer as the second argument.
+        "mv a2, {num_args}",  // Pass `num_args` as the third argument.
         "mv fp, zero",        // Zero the frame address.
         "mv ra, zero",        // Zero the return address.
         "tail {entry}",       // Call `entry`.
@@ -162,6 +167,7 @@ pub(super) unsafe fn clone(
 
         entry = sym super::thread::entry,
         fn_ = in(reg) fn_,
+        num_args = in(reg) num_args,
         in("a7") __NR_clone,
         inlateout("a0") flags as usize => r0,
         in("a1") child_stack,

src/arch/x86.rs

@@ -8,8 +8,6 @@ use linux_raw_sys::general::{__NR_mprotect, PROT_READ};
 use linux_raw_sys::general::{__NR_rt_sigreturn, __NR_sigreturn};
 #[cfg(feature = "origin-thread")]
 use {
-    alloc::boxed::Box,
-    core::any::Any,
     core::ffi::c_void,
     core::ptr::invalid_mut,
     linux_raw_sys::general::{__NR_clone, __NR_exit, __NR_munmap},
@@ -136,6 +134,10 @@ pub(super) unsafe fn relocation_mprotect_readonly(ptr: usize, len: usize) {
     assert_eq!(r0, 0);
 }
 
+/// The required alignment for the stack pointer.
+#[cfg(feature = "origin-thread")]
+pub(super) const STACK_ALIGNMENT: usize = 16;
+
 /// A wrapper around the Linux `clone` system call.
 ///
 /// This can't be implemented in `rustix` because the child starts executing at
@@ -149,7 +151,8 @@ pub(super) unsafe fn clone(
     parent_tid: *mut RawPid,
     child_tid: *mut RawPid,
     newtls: *mut c_void,
-    fn_: *mut Box<dyn FnOnce() -> Option<Box<dyn Any>> + Send>,
+    fn_: extern "C" fn(),
+    num_args: usize,
 ) -> isize {
     let mut gs: u32 = 0;
     asm!("mov {0:x}, gs", inout(reg) gs);
@@ -171,6 +174,11 @@ pub(super) unsafe fn clone(
     user_desc.set_useable(1);
     let newtls: *const _ = &user_desc;
 
+    // Push `fn_` to the child stack, since after all the `clone` args, and
+    // `num_args` in `ebp`, there are no more free registers.
+    let child_stack = child_stack.cast::<*mut c_void>().sub(1);
+    child_stack.write(fn_ as _);
+
     // See the comments for x86's `syscall6` in `rustix`. Inline asm isn't
     // allowed to name ebp or esi as operands, so we have to jump through
     // extra hoops here.
@@ -179,7 +187,7 @@ pub(super) unsafe fn clone(
         "push esi",           // Save incoming register value.
         "push ebp",           // Save incoming register value.
 
-        // Pass `fn_` to the child in ebp.
+        // Pass `num_args` to the child in `ebp`.
         "mov ebp, [eax+8]",
 
         "mov esi, [eax+0]",   // Pass `newtls` to the `int 0x80`.
@@ -193,10 +201,12 @@ pub(super) unsafe fn clone(
         "jnz 0f",
 
         // Child thread.
-        "push eax",           // Pad for alignment.
-        "push eax",           // Pad for alignment.
-        "push eax",           // Pad for alignment.
-        "push ebp",           // Pass `fn` as the first argument.
+        "pop edi",            // Load `fn_` from the child stack.
+        "mov esi, esp",       // Snapshot the args pointer.
+        "push eax",           // Pad for stack pointer alignment.
+        "push ebp",           // Pass `num_args` as the third argument.
+        "push esi",           // Pass the args pointer as the second argument.
+        "push edi",           // Pass `fn_` as the first argument.
         "xor ebp, ebp",       // Zero the frame address.
         "push eax",           // Zero the return address.
         "jmp {entry}",        // Call `entry`.
@@ -210,7 +220,7 @@ pub(super) unsafe fn clone(
         inout("eax") &[
             newtls.cast::<c_void>().cast_mut(),
             invalid_mut(__NR_clone as usize),
-            fn_.cast::<c_void>()
+            invalid_mut(num_args)
         ] => r0,
         in("ebx") flags,
         in("ecx") child_stack,

src/arch/x86_64.rs

@@ -10,8 +10,6 @@ use linux_raw_sys::general::__NR_rt_sigreturn;
 use linux_raw_sys::general::{__NR_mprotect, PROT_READ};
 #[cfg(feature = "origin-thread")]
 use {
-    alloc::boxed::Box,
-    core::any::Any,
     linux_raw_sys::general::{__NR_clone, __NR_exit, __NR_munmap},
     rustix::thread::RawPid,
 };
@@ -134,6 +132,10 @@ pub(super) unsafe fn relocation_mprotect_readonly(ptr: usize, len: usize) {
     assert_eq!(r0, 0);
 }
 
+/// The required alignment for the stack pointer.
+#[cfg(feature = "origin-thread")]
+pub(super) const STACK_ALIGNMENT: usize = 16;
+
 /// A wrapper around the Linux `clone` system call.
 ///
 /// This can't be implemented in `rustix` because the child starts executing at
@@ -147,7 +149,8 @@ pub(super) unsafe fn clone(
     parent_tid: *mut RawPid,
     child_tid: *mut RawPid,
     newtls: *mut c_void,
-    fn_: *mut Box<dyn FnOnce() -> Option<Box<dyn Any>> + Send>,
+    fn_: extern "C" fn(),
+    num_args: usize,
 ) -> isize {
     let r0;
     asm!(
@@ -156,8 +159,10 @@ pub(super) unsafe fn clone(
         "jnz 0f",
 
         // Child thread.
-        "xor ebp, ebp",       // Zero the frame address.
         "mov rdi, r9",        // Pass `fn_` as the first argument.
+        "mov rsi, rsp",       // Pass the args pointer as the second argument.
+        "mov rdx, r12",       // Pass `num_args` as the third argument.
+        "xor ebp, ebp",       // Zero the frame address.
         "push rax",           // Zero the return address.
         "jmp {entry}",        // Call `entry`.
 
@@ -172,6 +177,7 @@ pub(super) unsafe fn clone(
         in("r10") child_tid,
         in("r8") newtls,
         in("r9") fn_,
+        in("r12") num_args,
         lateout("rcx") _,
         lateout("r11") _,
         options(nostack)