|
|
@@ -0,0 +1,889 @@
|
|
|
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
|
|
+From: Jameson Nash <[email protected]>
|
|
|
+Date: Wed, 2 Mar 2022 15:15:39 -0500
|
|
|
+Subject: Reland "macos: use posix_spawn instead of fork" (#3257)
|
|
|
+
|
|
|
+Fixes: https://github.com/libuv/libuv/issues/3050
|
|
|
+Refs: https://github.com/libuv/libuv/issues/3086
|
|
|
+Refs: https://github.com/libuv/libuv/pull/3064
|
|
|
+Refs: https://github.com/libuv/libuv/pull/3107
|
|
|
+Refs: https://github.com/libuv/libuv/pull/3064
|
|
|
+
|
|
|
+This reverts commit 217fdf4265589889d00c7c0622fde2710971a020, then fixes
|
|
|
+several issues with it:
|
|
|
+
|
|
|
+* remove error fast-cleanup code that triggers a nodejs bug
|
|
|
+
|
|
|
+Refs: https://github.com/libuv/libuv/pull/3107#issuecomment-782482608
|
|
|
+
|
|
|
+* protect posix_spawn from EINTR
|
|
|
+
|
|
|
+This is not a documented valid error, but seems to have been observed.
|
|
|
+
|
|
|
+* ignore setuid/setgid syscall
|
|
|
+
|
|
|
+This kernel function is not permitted unless the process is setuid root,
|
|
|
+so disable this syscall. Falling back to fork/exec should be okay for
|
|
|
+the rare cases that the user decides they need to do setuid(getuid()) or
|
|
|
+setuid(geteuid()) for the child.
|
|
|
+
|
|
|
+Refs: https://github.com/libuv/libuv/pull/3107#issuecomment-782482608
|
|
|
+
|
|
|
+* improve posix_spawn path search
|
|
|
+
|
|
|
+Ports the improvements in musl back to this function
|
|
|
+
|
|
|
+* fix some additional problems and formatting issues
|
|
|
+
|
|
|
+We previously might fail to start a watcher, in rare failure cases,
|
|
|
+resulting in a zombie that we would fail to kill. Also avoid creating
|
|
|
+the signal-pipe unless required (addresses a review comment from Apple)
|
|
|
+
|
|
|
+* fix fd->fd mapping reuse
|
|
|
+
|
|
|
+There was a chance that when duplicating the fd's into stdio_count+fd we
|
|
|
+might be closing a currently opened fd with that value.
|
|
|
+
|
|
|
+diff --git a/deps/uv/src/unix/process.c b/deps/uv/src/unix/process.c
|
|
|
+index 2920b942962357827bae9bcad23af8333e8b007f..b85aa3b94edd040952e0d350a47a38d9ba8a67d3 100644
|
|
|
+--- a/deps/uv/src/unix/process.c
|
|
|
++++ b/deps/uv/src/unix/process.c
|
|
|
+@@ -27,6 +27,7 @@
|
|
|
+ #include <assert.h>
|
|
|
+ #include <errno.h>
|
|
|
+ #include <signal.h>
|
|
|
++#include <string.h>
|
|
|
+
|
|
|
+ #include <sys/types.h>
|
|
|
+ #include <sys/wait.h>
|
|
|
+@@ -35,8 +36,21 @@
|
|
|
+ #include <poll.h>
|
|
|
+
|
|
|
+ #if defined(__APPLE__) && !TARGET_OS_IPHONE
|
|
|
++# include <spawn.h>
|
|
|
++# include <paths.h>
|
|
|
++# include <sys/kauth.h>
|
|
|
++# include <sys/types.h>
|
|
|
++# include <sys/sysctl.h>
|
|
|
++# include <dlfcn.h>
|
|
|
+ # include <crt_externs.h>
|
|
|
++# include <xlocale.h>
|
|
|
+ # define environ (*_NSGetEnviron())
|
|
|
++
|
|
|
++/* macOS 10.14 back does not define this constant */
|
|
|
++# ifndef POSIX_SPAWN_SETSID
|
|
|
++# define POSIX_SPAWN_SETSID 1024
|
|
|
++# endif
|
|
|
++
|
|
|
+ #else
|
|
|
+ extern char **environ;
|
|
|
+ #endif
|
|
|
+@@ -261,22 +275,22 @@ static void uv__process_child_init(const uv_process_options_t* options,
|
|
|
+ use_fd = pipes[fd][1];
|
|
|
+ if (use_fd < 0 || use_fd >= fd)
|
|
|
+ continue;
|
|
|
+- pipes[fd][1] = fcntl(use_fd, F_DUPFD, stdio_count);
|
|
|
++ pipes[fd][1] = fcntl(use_fd, F_DUPFD_CLOEXEC, stdio_count);
|
|
|
+ if (pipes[fd][1] == -1)
|
|
|
+ uv__write_errno(error_fd);
|
|
|
+ }
|
|
|
+
|
|
|
+ for (fd = 0; fd < stdio_count; fd++) {
|
|
|
+- close_fd = pipes[fd][0];
|
|
|
++ close_fd = -1;
|
|
|
+ use_fd = pipes[fd][1];
|
|
|
+
|
|
|
+ if (use_fd < 0) {
|
|
|
+ if (fd >= 3)
|
|
|
+ continue;
|
|
|
+ else {
|
|
|
+- /* redirect stdin, stdout and stderr to /dev/null even if UV_IGNORE is
|
|
|
+- * set
|
|
|
+- */
|
|
|
++ /* Redirect stdin, stdout and stderr to /dev/null even if UV_IGNORE is
|
|
|
++ * set. */
|
|
|
++ uv__close_nocheckstdio(fd); /* Free up fd, if it happens to be open. */
|
|
|
+ use_fd = open("/dev/null", fd == 0 ? O_RDONLY : O_RDWR);
|
|
|
+ close_fd = use_fd;
|
|
|
+
|
|
|
+@@ -285,28 +299,24 @@ static void uv__process_child_init(const uv_process_options_t* options,
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+- if (fd == use_fd)
|
|
|
+- uv__cloexec_fcntl(use_fd, 0);
|
|
|
+- else
|
|
|
++ if (fd == use_fd) {
|
|
|
++ if (close_fd == -1)
|
|
|
++ uv__cloexec_fcntl(use_fd, 0);
|
|
|
++ }
|
|
|
++ else {
|
|
|
+ fd = dup2(use_fd, fd);
|
|
|
++ }
|
|
|
+
|
|
|
+ if (fd == -1)
|
|
|
+ uv__write_errno(error_fd);
|
|
|
+
|
|
|
+- if (fd <= 2)
|
|
|
++ if (fd <= 2 && close_fd == -1)
|
|
|
+ uv__nonblock_fcntl(fd, 0);
|
|
|
+
|
|
|
+ if (close_fd >= stdio_count)
|
|
|
+ uv__close(close_fd);
|
|
|
+ }
|
|
|
+
|
|
|
+- for (fd = 0; fd < stdio_count; fd++) {
|
|
|
+- use_fd = pipes[fd][1];
|
|
|
+-
|
|
|
+- if (use_fd >= stdio_count)
|
|
|
+- uv__close(use_fd);
|
|
|
+- }
|
|
|
+-
|
|
|
+ if (options->cwd != NULL && chdir(options->cwd))
|
|
|
+ uv__write_errno(error_fd);
|
|
|
+
|
|
|
+@@ -327,9 +337,8 @@ static void uv__process_child_init(const uv_process_options_t* options,
|
|
|
+ if ((options->flags & UV_PROCESS_SETUID) && setuid(options->uid))
|
|
|
+ uv__write_errno(error_fd);
|
|
|
+
|
|
|
+- if (options->env != NULL) {
|
|
|
++ if (options->env != NULL)
|
|
|
+ environ = options->env;
|
|
|
+- }
|
|
|
+
|
|
|
+ /* Reset signal mask just before exec. */
|
|
|
+ sigemptyset(&signewset);
|
|
|
+@@ -348,6 +357,562 @@ static void uv__process_child_init(const uv_process_options_t* options,
|
|
|
+ #endif
|
|
|
+
|
|
|
+
|
|
|
++#if defined(__APPLE__)
|
|
|
++typedef struct uv__posix_spawn_fncs_tag {
|
|
|
++ struct {
|
|
|
++ int (*addchdir_np)(const posix_spawn_file_actions_t *, const char *);
|
|
|
++ } file_actions;
|
|
|
++} uv__posix_spawn_fncs_t;
|
|
|
++
|
|
|
++
|
|
|
++static uv_once_t posix_spawn_init_once = UV_ONCE_INIT;
|
|
|
++static uv__posix_spawn_fncs_t posix_spawn_fncs;
|
|
|
++static int posix_spawn_can_use_setsid;
|
|
|
++
|
|
|
++
|
|
|
++static void uv__spawn_init_posix_spawn_fncs(void) {
|
|
|
++ /* Try to locate all non-portable functions at runtime */
|
|
|
++ posix_spawn_fncs.file_actions.addchdir_np =
|
|
|
++ dlsym(RTLD_DEFAULT, "posix_spawn_file_actions_addchdir_np");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void uv__spawn_init_can_use_setsid(void) {
|
|
|
++ static const int MACOS_CATALINA_VERSION_MAJOR = 19;
|
|
|
++ char version_str[256];
|
|
|
++ char* version_major_str;
|
|
|
++ size_t version_str_size = 256;
|
|
|
++ int r;
|
|
|
++ int version_major;
|
|
|
++
|
|
|
++ /* Get a version string */
|
|
|
++ r = sysctlbyname("kern.osrelease", version_str, &version_str_size, NULL, 0);
|
|
|
++ if (r != 0)
|
|
|
++ return;
|
|
|
++
|
|
|
++ /* Try to get the major version number. If not found
|
|
|
++ * fall back to the fork/exec flow */
|
|
|
++ version_major_str = strtok(version_str, ".");
|
|
|
++ if (version_major_str == NULL)
|
|
|
++ return;
|
|
|
++
|
|
|
++ /* Parse the version major as a number. If it is greater than
|
|
|
++ * the major version for macOS Catalina (aka macOS 10.15), then
|
|
|
++ * the POSIX_SPAWN_SETSID flag is available */
|
|
|
++ version_major = atoi_l(version_major_str, NULL); /* Use LC_C_LOCALE */
|
|
|
++ if (version_major >= MACOS_CATALINA_VERSION_MAJOR)
|
|
|
++ posix_spawn_can_use_setsid = 1;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void uv__spawn_init_posix_spawn(void) {
|
|
|
++ /* Init handles to all potentially non-defined functions */
|
|
|
++ uv__spawn_init_posix_spawn_fncs();
|
|
|
++
|
|
|
++ /* Init feature detection for POSIX_SPAWN_SETSID flag */
|
|
|
++ uv__spawn_init_can_use_setsid();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static int uv__spawn_set_posix_spawn_attrs(
|
|
|
++ posix_spawnattr_t* attrs,
|
|
|
++ const uv__posix_spawn_fncs_t* posix_spawn_fncs,
|
|
|
++ const uv_process_options_t* options) {
|
|
|
++ int err;
|
|
|
++ unsigned int flags;
|
|
|
++ sigset_t signal_set;
|
|
|
++
|
|
|
++ err = posix_spawnattr_init(attrs);
|
|
|
++ if (err != 0) {
|
|
|
++ /* If initialization fails, no need to de-init, just return */
|
|
|
++ return err;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (options->flags & (UV_PROCESS_SETUID | UV_PROCESS_SETGID)) {
|
|
|
++ /* kauth_cred_issuser currently requires exactly uid == 0 for these
|
|
|
++ * posixspawn_attrs (set_groups_np, setuid_np, setgid_np), which deviates
|
|
|
++ * from the normal specification of setuid (which also uses euid), and they
|
|
|
++ * are also undocumented syscalls, so we do not use them. */
|
|
|
++ err = ENOSYS;
|
|
|
++ goto error;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Set flags for spawn behavior
|
|
|
++ * 1) POSIX_SPAWN_CLOEXEC_DEFAULT: (Apple Extension) All descriptors in the
|
|
|
++ * parent will be treated as if they had been created with O_CLOEXEC. The
|
|
|
++ * only fds that will be passed on to the child are those manipulated by
|
|
|
++ * the file actions
|
|
|
++ * 2) POSIX_SPAWN_SETSIGDEF: Signals mentioned in spawn-sigdefault in the
|
|
|
++ * spawn attributes will be reset to behave as their default
|
|
|
++ * 3) POSIX_SPAWN_SETSIGMASK: Signal mask will be set to the value of
|
|
|
++ * spawn-sigmask in attributes
|
|
|
++ * 4) POSIX_SPAWN_SETSID: Make the process a new session leader if a detached
|
|
|
++ * session was requested. */
|
|
|
++ flags = POSIX_SPAWN_CLOEXEC_DEFAULT |
|
|
|
++ POSIX_SPAWN_SETSIGDEF |
|
|
|
++ POSIX_SPAWN_SETSIGMASK;
|
|
|
++ if (options->flags & UV_PROCESS_DETACHED) {
|
|
|
++ /* If running on a version of macOS where this flag is not supported,
|
|
|
++ * revert back to the fork/exec flow. Otherwise posix_spawn will
|
|
|
++ * silently ignore the flag. */
|
|
|
++ if (!posix_spawn_can_use_setsid) {
|
|
|
++ err = ENOSYS;
|
|
|
++ goto error;
|
|
|
++ }
|
|
|
++
|
|
|
++ flags |= POSIX_SPAWN_SETSID;
|
|
|
++ }
|
|
|
++ err = posix_spawnattr_setflags(attrs, flags);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++
|
|
|
++ /* Reset all signal the child to their default behavior */
|
|
|
++ sigfillset(&signal_set);
|
|
|
++ err = posix_spawnattr_setsigdefault(attrs, &signal_set);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++
|
|
|
++ /* Reset the signal mask for all signals */
|
|
|
++ sigemptyset(&signal_set);
|
|
|
++ err = posix_spawnattr_setsigmask(attrs, &signal_set);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++
|
|
|
++ return err;
|
|
|
++
|
|
|
++error:
|
|
|
++ (void) posix_spawnattr_destroy(attrs);
|
|
|
++ return err;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static int uv__spawn_set_posix_spawn_file_actions(
|
|
|
++ posix_spawn_file_actions_t* actions,
|
|
|
++ const uv__posix_spawn_fncs_t* posix_spawn_fncs,
|
|
|
++ const uv_process_options_t* options,
|
|
|
++ int stdio_count,
|
|
|
++ int (*pipes)[2]) {
|
|
|
++ int fd;
|
|
|
++ int fd2;
|
|
|
++ int use_fd;
|
|
|
++ int err;
|
|
|
++
|
|
|
++ err = posix_spawn_file_actions_init(actions);
|
|
|
++ if (err != 0) {
|
|
|
++ /* If initialization fails, no need to de-init, just return */
|
|
|
++ return err;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Set the current working directory if requested */
|
|
|
++ if (options->cwd != NULL) {
|
|
|
++ if (posix_spawn_fncs->file_actions.addchdir_np == NULL) {
|
|
|
++ err = ENOSYS;
|
|
|
++ goto error;
|
|
|
++ }
|
|
|
++
|
|
|
++ err = posix_spawn_fncs->file_actions.addchdir_np(actions, options->cwd);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Do not return ENOSYS after this point, as we may mutate pipes. */
|
|
|
++
|
|
|
++ /* First duplicate low numbered fds, since it's not safe to duplicate them,
|
|
|
++ * they could get replaced. Example: swapping stdout and stderr; without
|
|
|
++ * this fd 2 (stderr) would be duplicated into fd 1, thus making both
|
|
|
++ * stdout and stderr go to the same fd, which was not the intention. */
|
|
|
++ for (fd = 0; fd < stdio_count; fd++) {
|
|
|
++ use_fd = pipes[fd][1];
|
|
|
++ if (use_fd < 0 || use_fd >= fd)
|
|
|
++ continue;
|
|
|
++ use_fd = stdio_count;
|
|
|
++ for (fd2 = 0; fd2 < stdio_count; fd2++) {
|
|
|
++ /* If we were not setting POSIX_SPAWN_CLOEXEC_DEFAULT, we would need to
|
|
|
++ * also consider whether fcntl(fd, F_GETFD) returned without the
|
|
|
++ * FD_CLOEXEC flag set. */
|
|
|
++ if (pipes[fd2][1] == use_fd) {
|
|
|
++ use_fd++;
|
|
|
++ fd2 = 0;
|
|
|
++ }
|
|
|
++ }
|
|
|
++ err = posix_spawn_file_actions_adddup2(
|
|
|
++ actions,
|
|
|
++ pipes[fd][1],
|
|
|
++ use_fd);
|
|
|
++ assert(err != ENOSYS);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++ pipes[fd][1] = use_fd;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Second, move the descriptors into their respective places */
|
|
|
++ for (fd = 0; fd < stdio_count; fd++) {
|
|
|
++ use_fd = pipes[fd][1];
|
|
|
++ if (use_fd < 0) {
|
|
|
++ if (fd >= 3)
|
|
|
++ continue;
|
|
|
++ else {
|
|
|
++ /* If ignored, redirect to (or from) /dev/null, */
|
|
|
++ err = posix_spawn_file_actions_addopen(
|
|
|
++ actions,
|
|
|
++ fd,
|
|
|
++ "/dev/null",
|
|
|
++ fd == 0 ? O_RDONLY : O_RDWR,
|
|
|
++ 0);
|
|
|
++ assert(err != ENOSYS);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++ continue;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ if (fd == use_fd)
|
|
|
++ err = posix_spawn_file_actions_addinherit_np(actions, fd);
|
|
|
++ else
|
|
|
++ err = posix_spawn_file_actions_adddup2(actions, use_fd, fd);
|
|
|
++ assert(err != ENOSYS);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++
|
|
|
++ /* Make sure the fd is marked as non-blocking (state shared between child
|
|
|
++ * and parent). */
|
|
|
++ uv__nonblock_fcntl(use_fd, 0);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Finally, close all the superfluous descriptors */
|
|
|
++ for (fd = 0; fd < stdio_count; fd++) {
|
|
|
++ use_fd = pipes[fd][1];
|
|
|
++ if (use_fd < stdio_count)
|
|
|
++ continue;
|
|
|
++
|
|
|
++ /* Check if we already closed this. */
|
|
|
++ for (fd2 = 0; fd2 < fd; fd2++) {
|
|
|
++ if (pipes[fd2][1] == use_fd)
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ if (fd2 < fd)
|
|
|
++ continue;
|
|
|
++
|
|
|
++ err = posix_spawn_file_actions_addclose(actions, use_fd);
|
|
|
++ assert(err != ENOSYS);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++ }
|
|
|
++
|
|
|
++ return 0;
|
|
|
++
|
|
|
++error:
|
|
|
++ (void) posix_spawn_file_actions_destroy(actions);
|
|
|
++ return err;
|
|
|
++}
|
|
|
++
|
|
|
++char* uv__spawn_find_path_in_env(char** env) {
|
|
|
++ char** env_iterator;
|
|
|
++ const char path_var[] = "PATH=";
|
|
|
++
|
|
|
++ /* Look for an environment variable called PATH in the
|
|
|
++ * provided env array, and return its value if found */
|
|
|
++ for (env_iterator = env; *env_iterator != NULL; env_iterator++) {
|
|
|
++ if (strncmp(*env_iterator, path_var, sizeof(path_var) - 1) == 0) {
|
|
|
++ /* Found "PATH=" at the beginning of the string */
|
|
|
++ return *env_iterator + sizeof(path_var) - 1;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ return NULL;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static int uv__spawn_resolve_and_spawn(const uv_process_options_t* options,
|
|
|
++ posix_spawnattr_t* attrs,
|
|
|
++ posix_spawn_file_actions_t* actions,
|
|
|
++ pid_t* pid) {
|
|
|
++ const char *p;
|
|
|
++ const char *z;
|
|
|
++ const char *path;
|
|
|
++ size_t l;
|
|
|
++ size_t k;
|
|
|
++ int err;
|
|
|
++ int seen_eacces;
|
|
|
++
|
|
|
++ path = NULL;
|
|
|
++ err = -1;
|
|
|
++ seen_eacces = 0;
|
|
|
++
|
|
|
++ /* Short circuit for erroneous case */
|
|
|
++ if (options->file == NULL)
|
|
|
++ return ENOENT;
|
|
|
++
|
|
|
++ /* The environment for the child process is that of the parent unless overriden
|
|
|
++ * by options->env */
|
|
|
++ char** env = environ;
|
|
|
++ if (options->env != NULL)
|
|
|
++ env = options->env;
|
|
|
++
|
|
|
++ /* If options->file contains a slash, posix_spawn/posix_spawnp behave
|
|
|
++ * the same, and don't involve PATH resolution at all. Otherwise, if
|
|
|
++ * options->file does not include a slash, but no custom environment is
|
|
|
++ * to be used, the environment used for path resolution as well for the
|
|
|
++ * child process is that of the parent process, so posix_spawnp is the
|
|
|
++ * way to go. */
|
|
|
++ if (strchr(options->file, '/') != NULL || options->env == NULL) {
|
|
|
++ do
|
|
|
++ err = posix_spawnp(pid, options->file, actions, attrs, options->args, env);
|
|
|
++ while (err == EINTR);
|
|
|
++ return err;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Look for the definition of PATH in the provided env */
|
|
|
++ path = uv__spawn_find_path_in_env(options->env);
|
|
|
++
|
|
|
++ /* The following resolution logic (execvpe emulation) is copied from
|
|
|
++ * https://git.musl-libc.org/cgit/musl/tree/src/process/execvp.c
|
|
|
++ * and adapted to work for our specific usage */
|
|
|
++
|
|
|
++ /* If no path was provided in options->env, use the default value
|
|
|
++ * to look for the executable */
|
|
|
++ if (path == NULL)
|
|
|
++ path = _PATH_DEFPATH;
|
|
|
++
|
|
|
++ k = strnlen(options->file, NAME_MAX + 1);
|
|
|
++ if (k > NAME_MAX)
|
|
|
++ return ENAMETOOLONG;
|
|
|
++
|
|
|
++ l = strnlen(path, PATH_MAX - 1) + 1;
|
|
|
++
|
|
|
++ for (p = path;; p = z) {
|
|
|
++ /* Compose the new process file from the entry in the PATH
|
|
|
++ * environment variable and the actual file name */
|
|
|
++ char b[PATH_MAX + NAME_MAX];
|
|
|
++ z = strchr(p, ':');
|
|
|
++ if (!z)
|
|
|
++ z = p + strlen(p);
|
|
|
++ if ((size_t)(z - p) >= l) {
|
|
|
++ if (!*z++)
|
|
|
++ break;
|
|
|
++
|
|
|
++ continue;
|
|
|
++ }
|
|
|
++ memcpy(b, p, z - p);
|
|
|
++ b[z - p] = '/';
|
|
|
++ memcpy(b + (z - p) + (z > p), options->file, k + 1);
|
|
|
++
|
|
|
++ /* Try to spawn the new process file. If it fails with ENOENT, the
|
|
|
++ * new process file is not in this PATH entry, continue with the next
|
|
|
++ * PATH entry. */
|
|
|
++ do
|
|
|
++ err = posix_spawn(pid, b, actions, attrs, options->args, env);
|
|
|
++ while (err == EINTR);
|
|
|
++
|
|
|
++ switch (err) {
|
|
|
++ case EACCES:
|
|
|
++ seen_eacces = 1;
|
|
|
++ break; /* continue search */
|
|
|
++ case ENOENT:
|
|
|
++ case ENOTDIR:
|
|
|
++ break; /* continue search */
|
|
|
++ default:
|
|
|
++ return err;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (!*z++)
|
|
|
++ break;
|
|
|
++ }
|
|
|
++
|
|
|
++ if (seen_eacces)
|
|
|
++ return EACCES;
|
|
|
++ return err;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static int uv__spawn_and_init_child_posix_spawn(
|
|
|
++ const uv_process_options_t* options,
|
|
|
++ int stdio_count,
|
|
|
++ int (*pipes)[2],
|
|
|
++ pid_t* pid,
|
|
|
++ const uv__posix_spawn_fncs_t* posix_spawn_fncs) {
|
|
|
++ int err;
|
|
|
++ posix_spawnattr_t attrs;
|
|
|
++ posix_spawn_file_actions_t actions;
|
|
|
++
|
|
|
++ err = uv__spawn_set_posix_spawn_attrs(&attrs, posix_spawn_fncs, options);
|
|
|
++ if (err != 0)
|
|
|
++ goto error;
|
|
|
++
|
|
|
++ /* This may mutate pipes. */
|
|
|
++ err = uv__spawn_set_posix_spawn_file_actions(&actions,
|
|
|
++ posix_spawn_fncs,
|
|
|
++ options,
|
|
|
++ stdio_count,
|
|
|
++ pipes);
|
|
|
++ if (err != 0) {
|
|
|
++ (void) posix_spawnattr_destroy(&attrs);
|
|
|
++ goto error;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Try to spawn options->file resolving in the provided environment
|
|
|
++ * if any */
|
|
|
++ err = uv__spawn_resolve_and_spawn(options, &attrs, &actions, pid);
|
|
|
++ assert(err != ENOSYS);
|
|
|
++
|
|
|
++ /* Destroy the actions/attributes */
|
|
|
++ (void) posix_spawn_file_actions_destroy(&actions);
|
|
|
++ (void) posix_spawnattr_destroy(&attrs);
|
|
|
++
|
|
|
++error:
|
|
|
++ /* In an error situation, the attributes and file actions are
|
|
|
++ * already destroyed, only the happy path requires cleanup */
|
|
|
++ return UV__ERR(err);
|
|
|
++}
|
|
|
++#endif
|
|
|
++
|
|
|
++static int uv__spawn_and_init_child_fork(const uv_process_options_t* options,
|
|
|
++ int stdio_count,
|
|
|
++ int (*pipes)[2],
|
|
|
++ int error_fd,
|
|
|
++ pid_t* pid) {
|
|
|
++ sigset_t signewset;
|
|
|
++ sigset_t sigoldset;
|
|
|
++
|
|
|
++ /* Start the child with most signals blocked, to avoid any issues before we
|
|
|
++ * can reset them, but allow program failures to exit (and not hang). */
|
|
|
++ sigfillset(&signewset);
|
|
|
++ sigdelset(&signewset, SIGKILL);
|
|
|
++ sigdelset(&signewset, SIGSTOP);
|
|
|
++ sigdelset(&signewset, SIGTRAP);
|
|
|
++ sigdelset(&signewset, SIGSEGV);
|
|
|
++ sigdelset(&signewset, SIGBUS);
|
|
|
++ sigdelset(&signewset, SIGILL);
|
|
|
++ sigdelset(&signewset, SIGSYS);
|
|
|
++ sigdelset(&signewset, SIGABRT);
|
|
|
++ if (pthread_sigmask(SIG_BLOCK, &signewset, &sigoldset) != 0)
|
|
|
++ abort();
|
|
|
++
|
|
|
++ *pid = fork();
|
|
|
++
|
|
|
++ if (*pid == -1) {
|
|
|
++ /* Failed to fork */
|
|
|
++ return UV__ERR(errno);
|
|
|
++ }
|
|
|
++
|
|
|
++ if (*pid == 0) {
|
|
|
++ /* Fork succeeded, in the child process */
|
|
|
++ uv__process_child_init(options, stdio_count, pipes, error_fd);
|
|
|
++ abort();
|
|
|
++ }
|
|
|
++
|
|
|
++ if (pthread_sigmask(SIG_SETMASK, &sigoldset, NULL) != 0)
|
|
|
++ abort();
|
|
|
++
|
|
|
++ /* Fork succeeded, in the parent process */
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++static int uv__spawn_and_init_child(
|
|
|
++ uv_loop_t* loop,
|
|
|
++ const uv_process_options_t* options,
|
|
|
++ int stdio_count,
|
|
|
++ int (*pipes)[2],
|
|
|
++ pid_t* pid) {
|
|
|
++ int signal_pipe[2] = { -1, -1 };
|
|
|
++ int status;
|
|
|
++ int err;
|
|
|
++ int exec_errorno;
|
|
|
++ ssize_t r;
|
|
|
++
|
|
|
++#if defined(__APPLE__)
|
|
|
++ uv_once(&posix_spawn_init_once, uv__spawn_init_posix_spawn);
|
|
|
++
|
|
|
++ /* Special child process spawn case for macOS Big Sur (11.0) onwards
|
|
|
++ *
|
|
|
++ * Big Sur introduced a significant performance degradation on a call to
|
|
|
++ * fork/exec when the process has many pages mmaped in with MAP_JIT, like, say
|
|
|
++ * a javascript interpreter. Electron-based applications, for example,
|
|
|
++ * are impacted; though the magnitude of the impact depends on how much the
|
|
|
++ * app relies on subprocesses.
|
|
|
++ *
|
|
|
++ * On macOS, though, posix_spawn is implemented in a way that does not
|
|
|
++ * exhibit the problem. This block implements the forking and preparation
|
|
|
++ * logic with posix_spawn and its related primitives. It also takes advantage of
|
|
|
++ * the macOS extension POSIX_SPAWN_CLOEXEC_DEFAULT that makes impossible to
|
|
|
++ * leak descriptors to the child process. */
|
|
|
++ err = uv__spawn_and_init_child_posix_spawn(options,
|
|
|
++ stdio_count,
|
|
|
++ pipes,
|
|
|
++ pid,
|
|
|
++ &posix_spawn_fncs);
|
|
|
++
|
|
|
++ /* The posix_spawn flow will return UV_ENOSYS if any of the posix_spawn_x_np
|
|
|
++ * non-standard functions is both _needed_ and _undefined_. In those cases,
|
|
|
++ * default back to the fork/execve strategy. For all other errors, just fail. */
|
|
|
++ if (err != UV_ENOSYS)
|
|
|
++ return err;
|
|
|
++
|
|
|
++#endif
|
|
|
++
|
|
|
++ /* This pipe is used by the parent to wait until
|
|
|
++ * the child has called `execve()`. We need this
|
|
|
++ * to avoid the following race condition:
|
|
|
++ *
|
|
|
++ * if ((pid = fork()) > 0) {
|
|
|
++ * kill(pid, SIGTERM);
|
|
|
++ * }
|
|
|
++ * else if (pid == 0) {
|
|
|
++ * execve("/bin/cat", argp, envp);
|
|
|
++ * }
|
|
|
++ *
|
|
|
++ * The parent sends a signal immediately after forking.
|
|
|
++ * Since the child may not have called `execve()` yet,
|
|
|
++ * there is no telling what process receives the signal,
|
|
|
++ * our fork or /bin/cat.
|
|
|
++ *
|
|
|
++ * To avoid ambiguity, we create a pipe with both ends
|
|
|
++ * marked close-on-exec. Then, after the call to `fork()`,
|
|
|
++ * the parent polls the read end until it EOFs or errors with EPIPE.
|
|
|
++ */
|
|
|
++ err = uv__make_pipe(signal_pipe, 0);
|
|
|
++ if (err)
|
|
|
++ return err;
|
|
|
++
|
|
|
++ /* Acquire write lock to prevent opening new fds in worker threads */
|
|
|
++ uv_rwlock_wrlock(&loop->cloexec_lock);
|
|
|
++
|
|
|
++ err = uv__spawn_and_init_child_fork(options, stdio_count, pipes, signal_pipe[1], pid);
|
|
|
++
|
|
|
++ /* Release lock in parent process */
|
|
|
++ uv_rwlock_wrunlock(&loop->cloexec_lock);
|
|
|
++
|
|
|
++ uv__close(signal_pipe[1]);
|
|
|
++
|
|
|
++ if (err == 0) {
|
|
|
++ do
|
|
|
++ r = read(signal_pipe[0], &exec_errorno, sizeof(exec_errorno));
|
|
|
++ while (r == -1 && errno == EINTR);
|
|
|
++
|
|
|
++ if (r == 0)
|
|
|
++ ; /* okay, EOF */
|
|
|
++ else if (r == sizeof(exec_errorno)) {
|
|
|
++ do
|
|
|
++ err = waitpid(*pid, &status, 0); /* okay, read errorno */
|
|
|
++ while (err == -1 && errno == EINTR);
|
|
|
++ assert(err == *pid);
|
|
|
++ err = exec_errorno;
|
|
|
++ } else if (r == -1 && errno == EPIPE) {
|
|
|
++ /* Something unknown happened to our child before spawn */
|
|
|
++ do
|
|
|
++ err = waitpid(*pid, &status, 0); /* okay, got EPIPE */
|
|
|
++ while (err == -1 && errno == EINTR);
|
|
|
++ assert(err == *pid);
|
|
|
++ err = UV_EPIPE;
|
|
|
++ } else
|
|
|
++ abort();
|
|
|
++ }
|
|
|
++
|
|
|
++ uv__close_nocheckstdio(signal_pipe[0]);
|
|
|
++
|
|
|
++ return err;
|
|
|
++}
|
|
|
++
|
|
|
+ int uv_spawn(uv_loop_t* loop,
|
|
|
+ uv_process_t* process,
|
|
|
+ const uv_process_options_t* options) {
|
|
|
+@@ -355,18 +920,13 @@ int uv_spawn(uv_loop_t* loop,
|
|
|
+ /* fork is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED. */
|
|
|
+ return UV_ENOSYS;
|
|
|
+ #else
|
|
|
+- sigset_t signewset;
|
|
|
+- sigset_t sigoldset;
|
|
|
+- int signal_pipe[2] = { -1, -1 };
|
|
|
+ int pipes_storage[8][2];
|
|
|
+ int (*pipes)[2];
|
|
|
+ int stdio_count;
|
|
|
+- ssize_t r;
|
|
|
+ pid_t pid;
|
|
|
+ int err;
|
|
|
+ int exec_errorno;
|
|
|
+ int i;
|
|
|
+- int status;
|
|
|
+
|
|
|
+ assert(options->file != NULL);
|
|
|
+ assert(!(options->flags & ~(UV_PROCESS_DETACHED |
|
|
|
+@@ -379,6 +939,7 @@ int uv_spawn(uv_loop_t* loop,
|
|
|
+
|
|
|
+ uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
|
|
|
+ QUEUE_INIT(&process->queue);
|
|
|
++ process->status = 0;
|
|
|
+
|
|
|
+ stdio_count = options->stdio_count;
|
|
|
+ if (stdio_count < 3)
|
|
|
+@@ -403,106 +964,24 @@ int uv_spawn(uv_loop_t* loop,
|
|
|
+ goto error;
|
|
|
+ }
|
|
|
+
|
|
|
+- /* This pipe is used by the parent to wait until
|
|
|
+- * the child has called `execve()`. We need this
|
|
|
+- * to avoid the following race condition:
|
|
|
+- *
|
|
|
+- * if ((pid = fork()) > 0) {
|
|
|
+- * kill(pid, SIGTERM);
|
|
|
+- * }
|
|
|
+- * else if (pid == 0) {
|
|
|
+- * execve("/bin/cat", argp, envp);
|
|
|
+- * }
|
|
|
+- *
|
|
|
+- * The parent sends a signal immediately after forking.
|
|
|
+- * Since the child may not have called `execve()` yet,
|
|
|
+- * there is no telling what process receives the signal,
|
|
|
+- * our fork or /bin/cat.
|
|
|
+- *
|
|
|
+- * To avoid ambiguity, we create a pipe with both ends
|
|
|
+- * marked close-on-exec. Then, after the call to `fork()`,
|
|
|
+- * the parent polls the read end until it EOFs or errors with EPIPE.
|
|
|
+- */
|
|
|
+- err = uv__make_pipe(signal_pipe, 0);
|
|
|
+- if (err)
|
|
|
+- goto error;
|
|
|
+-
|
|
|
+ #if !(defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__))
|
|
|
+ uv_signal_start(&loop->child_watcher, uv__chld, SIGCHLD);
|
|
|
+ #endif
|
|
|
+
|
|
|
+- /* Acquire write lock to prevent opening new fds in worker threads */
|
|
|
+- uv_rwlock_wrlock(&loop->cloexec_lock);
|
|
|
+-
|
|
|
+- /* Start the child with most signals blocked, to avoid any issues before we
|
|
|
+- * can reset them, but allow program failures to exit (and not hang). */
|
|
|
+- sigfillset(&signewset);
|
|
|
+- sigdelset(&signewset, SIGKILL);
|
|
|
+- sigdelset(&signewset, SIGSTOP);
|
|
|
+- sigdelset(&signewset, SIGTRAP);
|
|
|
+- sigdelset(&signewset, SIGSEGV);
|
|
|
+- sigdelset(&signewset, SIGBUS);
|
|
|
+- sigdelset(&signewset, SIGILL);
|
|
|
+- sigdelset(&signewset, SIGSYS);
|
|
|
+- sigdelset(&signewset, SIGABRT);
|
|
|
+- if (pthread_sigmask(SIG_BLOCK, &signewset, &sigoldset) != 0)
|
|
|
+- abort();
|
|
|
+-
|
|
|
+- pid = fork();
|
|
|
+- if (pid == -1)
|
|
|
+- err = UV__ERR(errno);
|
|
|
+-
|
|
|
+- if (pid == 0)
|
|
|
+- uv__process_child_init(options, stdio_count, pipes, signal_pipe[1]);
|
|
|
++ /* Spawn the child */
|
|
|
++ exec_errorno = uv__spawn_and_init_child(loop, options, stdio_count, pipes, &pid);
|
|
|
+
|
|
|
+- if (pthread_sigmask(SIG_SETMASK, &sigoldset, NULL) != 0)
|
|
|
+- abort();
|
|
|
+-
|
|
|
+- /* Release lock in parent process */
|
|
|
+- uv_rwlock_wrunlock(&loop->cloexec_lock);
|
|
|
+-
|
|
|
+- uv__close(signal_pipe[1]);
|
|
|
+-
|
|
|
+- if (pid == -1) {
|
|
|
+- uv__close(signal_pipe[0]);
|
|
|
+- goto error;
|
|
|
+- }
|
|
|
+-
|
|
|
+- process->status = 0;
|
|
|
+- exec_errorno = 0;
|
|
|
+- do
|
|
|
+- r = read(signal_pipe[0], &exec_errorno, sizeof(exec_errorno));
|
|
|
+- while (r == -1 && errno == EINTR);
|
|
|
+-
|
|
|
+- if (r == 0)
|
|
|
+- ; /* okay, EOF */
|
|
|
+- else if (r == sizeof(exec_errorno)) {
|
|
|
+- do
|
|
|
+- err = waitpid(pid, &status, 0); /* okay, read errorno */
|
|
|
+- while (err == -1 && errno == EINTR);
|
|
|
+- assert(err == pid);
|
|
|
+- } else if (r == -1 && errno == EPIPE) {
|
|
|
+- do
|
|
|
+- err = waitpid(pid, &status, 0); /* okay, got EPIPE */
|
|
|
+- while (err == -1 && errno == EINTR);
|
|
|
+- assert(err == pid);
|
|
|
+- } else
|
|
|
+- abort();
|
|
|
+-
|
|
|
+- uv__close_nocheckstdio(signal_pipe[0]);
|
|
|
+-
|
|
|
+- for (i = 0; i < options->stdio_count; i++) {
|
|
|
+- err = uv__process_open_stream(options->stdio + i, pipes[i]);
|
|
|
+- if (err == 0)
|
|
|
+- continue;
|
|
|
+-
|
|
|
+- while (i--)
|
|
|
+- uv__process_close_stream(options->stdio + i);
|
|
|
+-
|
|
|
+- goto error;
|
|
|
+- }
|
|
|
++#if 0
|
|
|
++ /* This runs into a nodejs issue (it expects initialized streams, even if the
|
|
|
++ * exec failed).
|
|
|
++ * See https://github.com/libuv/libuv/pull/3107#issuecomment-782482608 */
|
|
|
++ if (exec_errorno != 0)
|
|
|
++ goto error;
|
|
|
++#endif
|
|
|
+
|
|
|
+- /* Only activate this handle if exec() happened successfully */
|
|
|
++ /* Activate this handle if exec() happened successfully, even if we later
|
|
|
++ * fail to open a stdio handle. This ensures we can eventually reap the child
|
|
|
++ * with waitpid. */
|
|
|
+ if (exec_errorno == 0) {
|
|
|
+ #if defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
|
|
+ struct kevent event;
|
|
|
+@@ -515,12 +994,22 @@ int uv_spawn(uv_loop_t* loop,
|
|
|
+ }
|
|
|
+ #endif
|
|
|
+
|
|
|
++ process->pid = pid;
|
|
|
++ process->exit_cb = options->exit_cb;
|
|
|
+ QUEUE_INSERT_TAIL(&loop->process_handles, &process->queue);
|
|
|
+ uv__handle_start(process);
|
|
|
+ }
|
|
|
+
|
|
|
+- process->pid = pid;
|
|
|
+- process->exit_cb = options->exit_cb;
|
|
|
++ for (i = 0; i < options->stdio_count; i++) {
|
|
|
++ err = uv__process_open_stream(options->stdio + i, pipes[i]);
|
|
|
++ if (err == 0)
|
|
|
++ continue;
|
|
|
++
|
|
|
++ while (i--)
|
|
|
++ uv__process_close_stream(options->stdio + i);
|
|
|
++
|
|
|
++ goto error;
|
|
|
++ }
|
|
|
+
|
|
|
+ if (pipes != pipes_storage)
|
|
|
+ uv__free(pipes);
|
trop[bot]