std.process.Child: use clone() instead of fork()

lib/std/os/linux.zig

@@ -87,6 +87,40 @@ pub fn clone(
     ) callconv(.c) usize, @ptrCast(&syscall_bits.clone))(func, stack, flags, arg, ptid, tp, ctid);
 }
 
+pub const clone_args = extern struct {
+    flags: u64,
+    pidfd: u64,
+    child_tid: u64,
+    parent_tid: u64,
+    exit_signal: u64,
+    stack: u64,
+    stack_size: u64,
+    tls: u64,
+    set_tid: u64,
+    set_tid_size: u64,
+    cgroup: u64,
+};
+
+pub fn clone3(
+    cl_args: *const clone_args,
+    size: usize,
+    func: *const fn (arg: usize) callconv(.C) u8,
+    arg: usize,
+) usize {
+    // TODO: write asm for other arch.
+    if (@hasDecl(syscall_bits, "clone3")) {
+        // Can't directly call a naked function; cast to C calling convention first.
+        return @as(*const fn (
+            cl_args: *const clone_args,
+            size: usize,
+            func: *const fn (arg: usize) callconv(.C) u8,
+            arg: usize,
+        ) callconv(.C) usize, @ptrCast(&syscall_bits.clone3))(cl_args, size, func, arg);
+    } else {
+        @compileError("clone3() implementation has not been written for this target");
+    }
+}
+
 pub const ARCH = arch_bits.ARCH;
 pub const Elf_Symndx = arch_bits.Elf_Symndx;
 pub const F = arch_bits.F;
@@ -1724,24 +1758,21 @@ pub fn sigprocmask(flags: u32, noalias set: ?*const sigset_t, noalias oldset: ?*
     return syscall4(.rt_sigprocmask, flags, @intFromPtr(set), @intFromPtr(oldset), NSIG / 8);
 }
 
-pub fn sigaction(sig: u6, noalias act: ?*const Sigaction, noalias oact: ?*Sigaction) usize {
-    assert(sig >= 1);
-    assert(sig != SIG.KILL);
-    assert(sig != SIG.STOP);
-
+pub fn sigaction(sig: u8, noalias act: ?*const Sigaction, noalias oact: ?*Sigaction) usize {
     var ksa: k_sigaction = undefined;
     var oldksa: k_sigaction = undefined;
     const mask_size = @sizeOf(@TypeOf(ksa.mask));
 
     if (act) |new| {
-        const restorer_fn = if ((new.flags & SA.SIGINFO) != 0) &restore_rt else &restore;
-        ksa = k_sigaction{
-            .handler = new.handler.handler,
-            .flags = new.flags | SA.RESTORER,
-            .mask = undefined,
-            .restorer = @ptrCast(restorer_fn),
-        };
-        @memcpy(@as([*]u8, @ptrCast(&ksa.mask))[0..mask_size], @as([*]const u8, @ptrCast(&new.mask)));
+        ksa.handler = new.handler.handler;
+        if (ksa.handler == SIG.DFL or ksa.handler == SIG.IGN) {
+            ksa.flags = new.flags;
+        } else {
+            const restorer_fn = if ((new.flags & SA.SIGINFO) != 0) &restore_rt else &restore;
+            ksa.flags = new.flags | SA.RESTORER;
+            ksa.restorer = @ptrCast(restorer_fn);
+            @memcpy(@as([*]u8, @ptrCast(&ksa.mask))[0..mask_size], @as([*]const u8, @ptrCast(&new.mask)));
+        }
     }
 
     const ksa_arg = if (act != null) @intFromPtr(&ksa) else 0;

lib/std/os/linux/aarch64.zig

@@ -115,7 +115,7 @@ pub fn clone() callconv(.naked) usize {
         \\      mov x2,x4
         \\      mov x3,x5
         \\      mov x4,x6
-        \\      mov x8,#220 // SYS_clone
+        \\      mov x8,#220
         \\      svc #0
         \\
         \\      cbz x0,1f
@@ -134,7 +134,26 @@ pub fn clone() callconv(.naked) usize {
         \\
         \\      ldp x1,x0,[sp],#16
         \\      blr x1
-        \\      mov x8,#93 // SYS_exit
+        \\      mov x8,#93
+        \\      svc #0
+    );
+}
+
+pub fn clone3() callconv(.Naked) usize {
+    asm volatile (
+        \\      mov x8,#435
+        \\      svc #0
+        \\
+        \\      cbz x0,1f
+        \\      ret
+        \\
+        \\1:    .cfi_undefined lr
+        \\      mov fp, 0
+        \\      mov lr, 0
+        \\
+        \\      mov x0,x3
+        \\      blr x2
+        \\      mov x8,#93
         \\      svc #0
     );
 }

lib/std/os/linux/arm.zig

@@ -106,7 +106,7 @@ pub fn clone() callconv(.naked) usize {
     //         r7         r0,    r1,    r2,   r3,  r4
     asm volatile (
         \\    stmfd sp!,{r4,r5,r6,r7}
-        \\    mov r7,#120 // SYS_clone
+        \\    mov r7,#120
         \\    mov r6,r3
         \\    mov r5,r0
         \\    mov r0,r2
@@ -127,14 +127,34 @@ pub fn clone() callconv(.naked) usize {
         \\
         \\    mov r0,r6
         \\    bl 3f
-        \\    mov r7,#1 // SYS_exit
+        \\    mov r7,#1
         \\    svc 0
         \\
         \\3:  bx r5
     );
 }
 
-pub fn restore() callconv(.naked) noreturn {
+pub fn clone3() callconv(.Naked) usize {
+    asm volatile (
+        \\    stmfd sp!,{r7}
+        \\    mov r7,#435
+        \\    svc 0
+        \\    tst r0,r0
+        \\    beq 1f
+        \\    ldmfd sp!,{r7}
+        \\    bx lr
+        \\
+        \\    // https://github.com/llvm/llvm-project/issues/115891
+        \\1:  mov r11, #0
+        \\    mov lr, #0
+        \\    mov r0,r3
+        \\    bx r2
+        \\    mov r7,#1
+        \\    svc 0
+    );
+}
+
+pub fn restore() callconv(.Naked) noreturn {
     switch (@import("builtin").zig_backend) {
         .stage2_c => asm volatile (
             \\ mov r7, %[number]

lib/std/os/linux/thumb.zig

@@ -142,6 +142,7 @@ pub fn syscall6(
 }
 
 pub const clone = @import("arm.zig").clone;
+pub const clone3 = @import("arm.zig").clone3;
 
 pub fn restore() callconv(.naked) noreturn {
     asm volatile (

lib/std/os/linux/x86.zig

@@ -146,7 +146,7 @@ pub fn clone() callconv(.naked) usize {
         \\  movl 24(%%ebp),%%edx
         \\  movl 28(%%ebp),%%esi
         \\  movl 32(%%ebp),%%edi
-        \\  movl $120,%%eax // SYS_clone
+        \\  movl $120,%%eax
         \\  int $128
         \\  testl %%eax,%%eax
         \\  jz 1f
@@ -167,12 +167,42 @@ pub fn clone() callconv(.naked) usize {
         \\  popl %%eax
         \\  calll *%%eax
         \\  movl %%eax,%%ebx
-        \\  movl $1,%%eax // SYS_exit
+        \\  movl $1,%%eax
         \\  int $128
     );
 }
 
-pub fn restore() callconv(.naked) noreturn {
+pub fn clone3() callconv(.Naked) usize {
+    asm volatile (
+        \\  pushl %%ebx
+        \\  pushl %%esi
+        \\  movl 12(%%esp),%%ebx
+        \\  movl 16(%%esp),%%ecx
+        \\  movl 20(%%esp),%%edx
+        \\  movl 24(%%esp),%%esi
+        \\  movl $435,%%eax
+        \\  int $128
+        \\  testl %%eax,%%eax
+        \\  jz 1f
+        \\  popl %%esi
+        \\  popl %%ebx
+        \\  retl
+        \\
+        \\1:
+        \\  .cfi_undefined %%eip
+        \\  xorl %%ebp,%%ebp
+        \\
+        \\  andl $-16,%%esp
+        \\  subl $12,%%esp
+        \\  pushl %%esi
+        \\  calll *%%edx
+        \\  movl %%eax,%%ebx
+        \\  movl $1,%%eax
+        \\  int $128
+    );
+}
+
+pub fn restore() callconv(.Naked) noreturn {
     switch (@import("builtin").zig_backend) {
         .stage2_c => asm volatile (
             \\ movl %[number], %%eax

lib/std/os/linux/x86_64.zig

@@ -103,7 +103,7 @@ pub fn syscall6(
 
 pub fn clone() callconv(.naked) usize {
     asm volatile (
-        \\      movl $56,%%eax // SYS_clone
+        \\      movl $56,%%eax
         \\      movq %%rdi,%%r11
         \\      movq %%rdx,%%rdi
         \\      movq %%r8,%%rdx
@@ -129,7 +129,28 @@ pub fn clone() callconv(.naked) usize {
         \\      popq %%rdi
         \\      callq *%%r9
         \\      movl %%eax,%%edi
-        \\      movl $60,%%eax // SYS_exit
+        \\      movl $60,%%eax
+        \\      syscall
+        \\
+    );
+}
+
+pub fn clone3() callconv(.Naked) usize {
+    asm volatile (
+        \\      movl $435,%%eax
+        \\      movq %%rcx,%%r8
+        \\      syscall
+        \\      testq %%rax,%%rax
+        \\      jz 1f
+        \\      retq
+        \\
+        \\1:    .cfi_undefined %%rip
+        \\      xorl %%ebp,%%ebp
+        \\
+        \\      movq %%r8,%%rdi
+        \\      callq *%%rdx
+        \\      movl %%eax,%%edi
+        \\      movl $60,%%eax
         \\      syscall
         \\
     );