os: start processes with posix_spawn

The process layer was a stub. StartProcess refused every ProcAttr that carried
Dir, Sys or Files, and os/exec always passes three Files, so no command could
run. Wait, Kill and Signal returned ErrNotImplemented, and ProcessState was an
empty struct whose methods all reported a failure. The code that did exist was
a fork() and an execve() with no branch on the result of the fork, so the
parent fell into the exec as well.

Use posix_spawn(3) on hosted Linux and macOS, which are the two targets where
the standard library os/exec and syscall packages compile against this
override. Those targets run the threads scheduler and collect with Boehm, so a
fork from Go gives the child one thread that holds the locks of the other
threads, malloc among them, and the stop-the-world signal of the collector can
arrive between the fork and the exec. posix_spawn does the clone and the exec
inside libc, where no Go code runs, and it reports a failed exec as its return
value, so the usual status pipe is not necessary.

The descriptors of the child come from a file-actions list. There is a dup2 for
each entry of ProcAttr.Files, a close for a missing one, and an addchdir_np for
Dir. A nil Env means the environment of the parent, as Go documents. The
attribute block installs an empty signal mask, because a blocked mask survives
an exec and the spawning thread can carry the signal of the collector blocked.

Setpgid and Pgid are honoured through posix_spawnattr_setpgroup, which is the
one SysProcAttr request that posix_spawn can express. Every other field is
refused by name, and the error unwraps to ErrNotImplementedSys.

Wait reaps with wait4 and retries on EINTR, which a thread in wait4 gets as a
matter of course, because the collector interrupts it. ProcessState now carries
the pid and the real syscall.WaitStatus, so exec.ExitError reports "exit status
N", and ExitCode, Exited, Success and Sys work. A killed child is reported as
signalled. Signal refuses a pid that Wait reaped and maps ESRCH to
ErrProcessDone, which is what exec.CommandContext expects when its context
fires as the command finishes.

macOS has no pipe2, so os.Pipe there marks both descriptors close-on-exec
afterwards, under ForkLock. Without the flag every pipe goes into every child,
and a child that holds a copy of a write end keeps that pipe from a report of
EOF. Linux asks for O_CLOEXEC in pipe2 and gets it atomically.

The minimal macOS SDK in lib/macos-minimal-sdk does not declare <spawn.h>, so
the generated libSystem stub has none of the posix_spawn symbols and a darwin
program that starts a process does not link. The builder now assembles the
missing names into a second stub object. posix_spawn_file_actions_addchdir_np
came with macOS 10.15, so a binary from this toolchain needs at least that
release.

Targets without a process model keep the previous stubs. Only the build tag on
exec_other.go changes, to let macOS through to the new implementation.

Author: yohimik

builder/darwin-libsystem.go

@@ -1,13 +1,37 @@
 package builder
 
 import (
+	"os"
 	"path/filepath"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
 )
 
+// Symbols that libSystem exports but the minimal macOS SDK in
+// lib/macos-minimal-sdk does not declare. Its generator reads a fixed list of
+// headers that does not contain <spawn.h>, so these names are absent from the
+// generated libSystem.s. The stubs below have the same form as the generated
+// ones, because the linker only needs to know that the names are in
+// libSystem.B.dylib.
+var darwinExtraLibSystemSymbols = []string{
+	// The posix_spawn family, which src/os uses to start processes.
+	// posix_spawn_file_actions_addchdir_np came with macOS 10.15, so a binary
+	// from this toolchain needs at least that release.
+	"posix_spawn",
+	"posix_spawn_file_actions_addchdir_np",
+	"posix_spawn_file_actions_addclose",
+	"posix_spawn_file_actions_adddup2",
+	"posix_spawn_file_actions_destroy",
+	"posix_spawn_file_actions_init",
+	"posix_spawnattr_destroy",
+	"posix_spawnattr_init",
+	"posix_spawnattr_setflags",
+	"posix_spawnattr_setpgroup",
+	"posix_spawnattr_setsigmask",
+}
+
 // Create a job that builds a Darwin libSystem.dylib stub library. This library
 // contains all the symbols needed so that we can link against it, but it
 // doesn't contain any real symbol implementations.
@@ -36,7 +60,34 @@ func makeDarwinLibSystemJob(config *compileopts.Config, tmpdir string) *compileJ
 				return err
 			}
 
-			// Link object file to dynamic library.
+			// Compile the extra stubs into a second object file, so that the
+			// generated one stays as it is.
+			extrapath := filepath.Join(tmpdir, "libSystem-extra.s")
+			extraobjpath := filepath.Join(tmpdir, "libSystem-extra.o")
+			var extra strings.Builder
+			extra.WriteString("// Stubs for symbols exported by libSystem but not declared in lib/macos-minimal-sdk.\n")
+			for _, symbol := range darwinExtraLibSystemSymbols {
+				extra.WriteString("\n.global _" + symbol + "\n_" + symbol + ":\n")
+			}
+			if err := os.WriteFile(extrapath, []byte(extra.String()), 0o666); err != nil {
+				return err
+			}
+			flags = []string{
+				"-nostdlib",
+				"--target=" + config.Triple(),
+				"-c",
+				"-o", extraobjpath,
+				extrapath,
+			}
+			if config.Options.PrintCommands != nil {
+				config.Options.PrintCommands("clang", flags...)
+			}
+			err = runCCompiler(flags...)
+			if err != nil {
+				return err
+			}
+
+			// Link object files to dynamic library.
 			platformVersion := strings.TrimPrefix(strings.Split(config.Triple(), "-")[2], "macosx")
 			flags = []string{
 				"-flavor", "darwin",
@@ -48,6 +99,7 @@ func makeDarwinLibSystemJob(config *compileopts.Config, tmpdir string) *compileJ
 				"-install_name", "/usr/lib/libSystem.B.dylib",
 				"-o", job.result,
 				objpath,
+				extraobjpath,
 			}
 			if config.Options.PrintCommands != nil {
 				config.Options.PrintCommands("ld.lld", flags...)

src/os/exec.go

@@ -5,6 +5,9 @@ import (
 	"syscall"
 )
 
+// Errors StartProcess returns for a ProcAttr that it cannot honour. On a
+// hosted OS only ErrNotImplementedSys is reachable. The other two stay because
+// they are part of the exported API of this package.
 var (
 	ErrNotImplementedDir   = errors.New("directory setting not implemented")
 	ErrNotImplementedSys   = errors.New("sys setting not implemented")
@@ -36,35 +39,12 @@ type ProcAttr struct {
 // ErrProcessDone indicates a Process has finished.
 var ErrProcessDone = errors.New("os: process already finished")
 
-type ProcessState struct {
-}
-
-func (p *ProcessState) String() string {
-	return "" // TODO
-}
-func (p *ProcessState) Success() bool {
-	return false // TODO
-}
-
-// Sys returns system-dependent exit information about
-// the process. Convert it to the appropriate underlying
-// type, such as syscall.WaitStatus on Unix, to access its contents.
-func (p *ProcessState) Sys() interface{} {
-	return nil // TODO
-}
-
-func (p *ProcessState) Exited() bool {
-	return false // TODO
-}
-
-// ExitCode returns the exit code of the exited process, or -1
-// if the process hasn't exited or was terminated by a signal.
-func (p *ProcessState) ExitCode() int {
-	return -1 // TODO
-}
-
 type Process struct {
 	Pid int
+
+	// done reports whether Wait reaped this process. A signal to a reaped pid
+	// is unsafe, because the number can belong to an unrelated process.
+	done int32
 }
 
 // StartProcess starts a new process with the program, arguments and attributes specified by name, argv and attr.
@@ -73,21 +53,6 @@ func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)
 	return startProcess(name, argv, attr)
 }
 
-func (p *Process) Wait() (*ProcessState, error) {
-	if p.Pid == -1 {
-		return nil, syscall.EINVAL
-	}
-	return nil, ErrNotImplemented
-}
-
-func (p *Process) Kill() error {
-	return ErrNotImplemented
-}
-
-func (p *Process) Signal(sig Signal) error {
-	return ErrNotImplemented
-}
-
 func Ignore(sig ...Signal) {
 	// leave all the signals unaltered
 	return

src/os/exec_linux.go

@@ -1,4 +1,4 @@
-//go:build (!aix && !android && !freebsd && !linux && !netbsd && !openbsd && !plan9 && !solaris) || baremetal || tinygo.wasm || nintendoswitch
+//go:build (!aix && !android && !darwin && !freebsd && !linux && !netbsd && !openbsd && !plan9 && !solaris) || baremetal || tinygo.wasm || nintendoswitch
 
 package os
 
@@ -18,6 +18,49 @@ func (p *Process) release() error {
 	return nil
 }
 
+// ProcessState is a placeholder on targets that have no process model.
+type ProcessState struct {
+}
+
+func (p *ProcessState) String() string {
+	return "" // TODO
+}
+func (p *ProcessState) Success() bool {
+	return false // TODO
+}
+
+// Sys returns system-dependent exit information about
+// the process. Convert it to the appropriate underlying
+// type, such as syscall.WaitStatus on Unix, to access its contents.
+func (p *ProcessState) Sys() interface{} {
+	return nil // TODO
+}
+
+func (p *ProcessState) Exited() bool {
+	return false // TODO
+}
+
+// ExitCode returns the exit code of the exited process, or -1
+// if the process hasn't exited or was terminated by a signal.
+func (p *ProcessState) ExitCode() int {
+	return -1 // TODO
+}
+
+func (p *Process) Wait() (*ProcessState, error) {
+	if p.Pid == -1 {
+		return nil, syscall.EINVAL
+	}
+	return nil, ErrNotImplemented
+}
+
+func (p *Process) Kill() error {
+	return ErrNotImplemented
+}
+
+func (p *Process) Signal(sig Signal) error {
+	return ErrNotImplemented
+}
+
 func forkExec(_ string, _ []string, _ *ProcAttr) (pid int, err error) {
 	return 0, ErrNotImplemented
 }