Mercurial

comparison third_party/libuv/src/unix/process.c @ 160:948de3f54cea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added libuv
author June Park <parkjune1995@gmail.com>
date Wed, 14 Jan 2026 19:39:52 -0800
parents
children
comparison
equal deleted inserted replaced
159:05cf9467a1c3 160:948de3f54cea
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2 *
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to
5 * deal in the Software without restriction, including without limitation the
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7 * sell copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
9 *
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19 * IN THE SOFTWARE.
20 */
21
22 #include "uv.h"
23 #include "internal.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <assert.h>
28 #include <errno.h>
29 #include <signal.h>
30 #include <string.h>
31
32 #include <sys/types.h>
33 #include <sys/wait.h>
34 #include <unistd.h>
35 #include <fcntl.h>
36 #include <poll.h>
37
38 #if defined(__APPLE__)
39 # include <spawn.h>
40 # include <paths.h>
41 # include <sys/kauth.h>
42 # include <sys/types.h>
43 # include <sys/sysctl.h>
44 # include <dlfcn.h>
45 # include <crt_externs.h>
46 # include <xlocale.h>
47 # define environ (*_NSGetEnviron())
48
49 /* macOS 10.14 back does not define this constant */
50 # ifndef POSIX_SPAWN_SETSID
51 # define POSIX_SPAWN_SETSID 1024
52 # endif
53
54 #else
55 extern char **environ;
56 #endif
57
58 #if defined(__linux__) || \
59 defined(__GNU__)
60 # include <grp.h>
61 #endif
62
63 #if defined(__MVS__)
64 # include "zos-base.h"
65 #endif
66
67 #ifdef UV_HAVE_KQUEUE
68 #include <sys/event.h>
69 #else
70 #define UV_USE_SIGCHLD
71 #endif
72
73
74 #ifdef UV_USE_SIGCHLD
75 static void uv__chld(uv_signal_t* handle, int signum) {
76 assert(signum == SIGCHLD);
77 uv__wait_children(handle->loop);
78 }
79
80
81 int uv__process_init(uv_loop_t* loop) {
82 int err;
83
84 err = uv_signal_init(loop, &loop->child_watcher);
85 if (err)
86 return err;
87 uv__handle_unref(&loop->child_watcher);
88 loop->child_watcher.flags |= UV_HANDLE_INTERNAL;
89 return 0;
90 }
91
92
93 #else
94 int uv__process_init(uv_loop_t* loop) {
95 memset(&loop->child_watcher, 0, sizeof(loop->child_watcher));
96 return 0;
97 }
98 #endif
99
100
101 void uv__wait_children(uv_loop_t* loop) {
102 uv_process_t* process;
103 int exit_status;
104 int term_signal;
105 int status;
106 int options;
107 pid_t pid;
108 struct uv__queue pending;
109 struct uv__queue* q;
110 struct uv__queue* h;
111
112 uv__queue_init(&pending);
113
114 h = &loop->process_handles;
115 q = uv__queue_head(h);
116 while (q != h) {
117 process = uv__queue_data(q, uv_process_t, queue);
118 q = uv__queue_next(q);
119
120 #ifndef UV_USE_SIGCHLD
121 if ((process->flags & UV_HANDLE_REAP) == 0)
122 continue;
123 options = 0;
124 process->flags &= ~UV_HANDLE_REAP;
125 loop->nfds--;
126 #else
127 options = WNOHANG;
128 #endif
129
130 do
131 pid = waitpid(process->pid, &status, options);
132 while (pid == -1 && errno == EINTR);
133
134 #ifdef UV_USE_SIGCHLD
135 if (pid == 0) /* Not yet exited */
136 continue;
137 #endif
138
139 if (pid == -1) {
140 if (errno != ECHILD)
141 abort();
142 /* The child died, and we missed it. This probably means someone else
143 * stole the waitpid from us. Handle this by not handling it at all. */
144 continue;
145 }
146
147 assert(pid == process->pid);
148 process->status = status;
149 uv__queue_remove(&process->queue);
150 uv__queue_insert_tail(&pending, &process->queue);
151 }
152
153 h = &pending;
154 q = uv__queue_head(h);
155 while (q != h) {
156 process = uv__queue_data(q, uv_process_t, queue);
157 q = uv__queue_next(q);
158
159 uv__queue_remove(&process->queue);
160 uv__queue_init(&process->queue);
161 uv__handle_stop(process);
162
163 if (process->exit_cb == NULL)
164 continue;
165
166 exit_status = 0;
167 if (WIFEXITED(process->status))
168 exit_status = WEXITSTATUS(process->status);
169
170 term_signal = 0;
171 if (WIFSIGNALED(process->status))
172 term_signal = WTERMSIG(process->status);
173
174 process->exit_cb(process, exit_status, term_signal);
175 }
176 assert(uv__queue_empty(&pending));
177 }
178
179 /*
180 * Used for initializing stdio streams like options.stdin_stream. Returns
181 * zero on success. See also the cleanup section in uv_spawn().
182 */
183 #if !(defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH))
184 /* execvp is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED, so must be
185 * avoided. Since this isn't called on those targets, the function
186 * doesn't even need to be defined for them.
187 */
188 static int uv__process_init_stdio(uv_stdio_container_t* container, int fds[2]) {
189 int mask;
190 int fd;
191 int ret;
192 int size;
193 int i;
194
195 mask = UV_IGNORE | UV_CREATE_PIPE | UV_INHERIT_FD | UV_INHERIT_STREAM;
196 size = 64 * 1024;
197
198 switch (container->flags & mask) {
199 case UV_IGNORE:
200 return 0;
201
202 case UV_CREATE_PIPE:
203 assert(container->data.stream != NULL);
204 if (container->data.stream->type != UV_NAMED_PIPE)
205 return UV_EINVAL;
206 else {
207 ret = uv_socketpair(SOCK_STREAM, 0, fds, 0, 0);
208
209 if (ret == 0)
210 for (i = 0; i < 2; i++) {
211 setsockopt(fds[i], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
212 setsockopt(fds[i], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
213 }
214 }
215
216 return ret;
217
218 case UV_INHERIT_FD:
219 case UV_INHERIT_STREAM:
220 if (container->flags & UV_INHERIT_FD)
221 fd = container->data.fd;
222 else
223 fd = uv__stream_fd(container->data.stream);
224
225 if (fd == -1)
226 return UV_EINVAL;
227
228 fds[1] = fd;
229 return 0;
230
231 default:
232 assert(0 && "Unexpected flags");
233 return UV_EINVAL;
234 }
235 }
236
237
238 static int uv__process_open_stream(uv_stdio_container_t* container,
239 int pipefds[2]) {
240 int flags;
241 int err;
242
243 if (!(container->flags & UV_CREATE_PIPE) || pipefds[0] < 0)
244 return 0;
245
246 err = uv__close(pipefds[1]);
247 if (err != 0)
248 abort();
249
250 pipefds[1] = -1;
251 uv__nonblock(pipefds[0], 1);
252
253 flags = 0;
254 if (container->flags & UV_WRITABLE_PIPE)
255 flags |= UV_HANDLE_READABLE;
256 if (container->flags & UV_READABLE_PIPE)
257 flags |= UV_HANDLE_WRITABLE;
258
259 return uv__stream_open(container->data.stream, pipefds[0], flags);
260 }
261
262
263 static void uv__process_close_stream(uv_stdio_container_t* container) {
264 if (!(container->flags & UV_CREATE_PIPE)) return;
265 uv__stream_close(container->data.stream);
266 }
267
268
269 static void uv__write_int(int fd, int val) {
270 ssize_t n;
271
272 do
273 n = write(fd, &val, sizeof(val));
274 while (n == -1 && errno == EINTR);
275
276 /* The write might have failed (e.g. if the parent process has died),
277 * but we have nothing left but to _exit ourself now too. */
278 _exit(127);
279 }
280
281
282 static void uv__write_errno(int error_fd) {
283 uv__write_int(error_fd, UV__ERR(errno));
284 }
285
286
287 static void uv__process_child_init(const uv_process_options_t* options,
288 int stdio_count,
289 int (*pipes)[2],
290 int error_fd) {
291 sigset_t signewset;
292 int close_fd;
293 int use_fd;
294 int fd;
295 int n;
296
297 /* Reset signal disposition first. Use a hard-coded limit because NSIG is not
298 * fixed on Linux: it's either 32, 34 or 64, depending on whether RT signals
299 * are enabled. We are not allowed to touch RT signal handlers, glibc uses
300 * them internally.
301 */
302 for (n = 1; n < 32; n += 1) {
303 if (n == SIGKILL || n == SIGSTOP)
304 continue; /* Can't be changed. */
305
306 #if defined(__HAIKU__)
307 if (n == SIGKILLTHR)
308 continue; /* Can't be changed. */
309 #endif
310
311 if (SIG_ERR != signal(n, SIG_DFL))
312 continue;
313
314 uv__write_errno(error_fd);
315 }
316
317 if (options->flags & UV_PROCESS_DETACHED)
318 setsid();
319
320 /* First duplicate low numbered fds, since it's not safe to duplicate them,
321 * they could get replaced. Example: swapping stdout and stderr; without
322 * this fd 2 (stderr) would be duplicated into fd 1, thus making both
323 * stdout and stderr go to the same fd, which was not the intention. */
324 for (fd = 0; fd < stdio_count; fd++) {
325 use_fd = pipes[fd][1];
326 if (use_fd < 0 || use_fd >= fd)
327 continue;
328 #ifdef F_DUPFD_CLOEXEC /* POSIX 2008 */
329 pipes[fd][1] = fcntl(use_fd, F_DUPFD_CLOEXEC, stdio_count);
330 #else
331 pipes[fd][1] = fcntl(use_fd, F_DUPFD, stdio_count);
332 #endif
333 if (pipes[fd][1] == -1)
334 uv__write_errno(error_fd);
335 #ifndef F_DUPFD_CLOEXEC /* POSIX 2008 */
336 n = uv__cloexec(pipes[fd][1], 1);
337 if (n)
338 uv__write_int(error_fd, n);
339 #endif
340 }
341
342 for (fd = 0; fd < stdio_count; fd++) {
343 close_fd = -1;
344 use_fd = pipes[fd][1];
345
346 if (use_fd < 0) {
347 if (fd >= 3)
348 continue;
349 else {
350 /* Redirect stdin, stdout and stderr to /dev/null even if UV_IGNORE is
351 * set. */
352 uv__close_nocheckstdio(fd); /* Free up fd, if it happens to be open. */
353 use_fd = open("/dev/null", fd == 0 ? O_RDONLY : O_RDWR);
354 close_fd = use_fd;
355
356 if (use_fd < 0)
357 uv__write_errno(error_fd);
358 }
359 }
360
361 if (fd == use_fd) {
362 if (close_fd == -1) {
363 n = uv__cloexec(use_fd, 0);
364 if (n)
365 uv__write_int(error_fd, n);
366 }
367 }
368 else {
369 fd = dup2(use_fd, fd);
370 }
371
372 if (fd == -1)
373 uv__write_errno(error_fd);
374
375 if (fd <= 2 && close_fd == -1)
376 uv__nonblock_fcntl(fd, 0);
377
378 if (close_fd >= stdio_count)
379 uv__close(close_fd);
380 }
381
382 if (options->cwd != NULL && chdir(options->cwd))
383 uv__write_errno(error_fd);
384
385 if (options->flags & (UV_PROCESS_SETUID | UV_PROCESS_SETGID)) {
386 /* When dropping privileges from root, the `setgroups` call will
387 * remove any extraneous groups. If we don't call this, then
388 * even though our uid has dropped, we may still have groups
389 * that enable us to do super-user things. This will fail if we
390 * aren't root, so don't bother checking the return value, this
391 * is just done as an optimistic privilege dropping function.
392 */
393 SAVE_ERRNO(setgroups(0, NULL));
394 }
395
396 if ((options->flags & UV_PROCESS_SETGID) && setgid(options->gid))
397 uv__write_errno(error_fd);
398
399 if ((options->flags & UV_PROCESS_SETUID) && setuid(options->uid))
400 uv__write_errno(error_fd);
401
402 if (options->env != NULL)
403 environ = options->env;
404
405 /* Reset signal mask just before exec. */
406 sigemptyset(&signewset);
407 if (sigprocmask(SIG_SETMASK, &signewset, NULL) != 0)
408 abort();
409
410 #ifdef __MVS__
411 execvpe(options->file, options->args, environ);
412 #else
413 execvp(options->file, options->args);
414 #endif
415
416 uv__write_errno(error_fd);
417 }
418
419
420 #if defined(__APPLE__)
421 typedef struct uv__posix_spawn_fncs_tag {
422 struct {
423 int (*addchdir_np)(const posix_spawn_file_actions_t *, const char *);
424 } file_actions;
425 } uv__posix_spawn_fncs_t;
426
427
428 static uv_once_t posix_spawn_init_once = UV_ONCE_INIT;
429 static uv__posix_spawn_fncs_t posix_spawn_fncs;
430 static int posix_spawn_can_use_setsid;
431
432
433 static void uv__spawn_init_posix_spawn_fncs(void) {
434 /* Try to locate all non-portable functions at runtime */
435 posix_spawn_fncs.file_actions.addchdir_np =
436 dlsym(RTLD_DEFAULT, "posix_spawn_file_actions_addchdir_np");
437 }
438
439
440 static void uv__spawn_init_can_use_setsid(void) {
441 int which[] = {CTL_KERN, KERN_OSRELEASE};
442 unsigned major;
443 unsigned minor;
444 unsigned patch;
445 char buf[256];
446 size_t len;
447
448 len = sizeof(buf);
449 if (sysctl(which, ARRAY_SIZE(which), buf, &len, NULL, 0))
450 return;
451
452 /* NULL specifies to use LC_C_LOCALE */
453 if (3 != sscanf_l(buf, NULL, "%u.%u.%u", &major, &minor, &patch))
454 return;
455
456 posix_spawn_can_use_setsid = (major >= 19); /* macOS Catalina */
457 }
458
459
460 static void uv__spawn_init_posix_spawn(void) {
461 /* Init handles to all potentially non-defined functions */
462 uv__spawn_init_posix_spawn_fncs();
463
464 /* Init feature detection for POSIX_SPAWN_SETSID flag */
465 uv__spawn_init_can_use_setsid();
466 }
467
468
469 static int uv__spawn_set_posix_spawn_attrs(
470 posix_spawnattr_t* attrs,
471 const uv__posix_spawn_fncs_t* posix_spawn_fncs,
472 const uv_process_options_t* options) {
473 int err;
474 unsigned int flags;
475 sigset_t signal_set;
476
477 err = posix_spawnattr_init(attrs);
478 if (err != 0) {
479 /* If initialization fails, no need to de-init, just return */
480 return err;
481 }
482
483 if (options->flags & (UV_PROCESS_SETUID | UV_PROCESS_SETGID)) {
484 /* kauth_cred_issuser currently requires exactly uid == 0 for these
485 * posixspawn_attrs (set_groups_np, setuid_np, setgid_np), which deviates
486 * from the normal specification of setuid (which also uses euid), and they
487 * are also undocumented syscalls, so we do not use them. */
488 err = ENOSYS;
489 goto error;
490 }
491
492 /* Set flags for spawn behavior
493 * 1) POSIX_SPAWN_CLOEXEC_DEFAULT: (Apple Extension) All descriptors in the
494 * parent will be treated as if they had been created with O_CLOEXEC. The
495 * only fds that will be passed on to the child are those manipulated by
496 * the file actions
497 * 2) POSIX_SPAWN_SETSIGDEF: Signals mentioned in spawn-sigdefault in the
498 * spawn attributes will be reset to behave as their default
499 * 3) POSIX_SPAWN_SETSIGMASK: Signal mask will be set to the value of
500 * spawn-sigmask in attributes
501 * 4) POSIX_SPAWN_SETSID: Make the process a new session leader if a detached
502 * session was requested. */
503 flags = POSIX_SPAWN_CLOEXEC_DEFAULT |
504 POSIX_SPAWN_SETSIGDEF |
505 POSIX_SPAWN_SETSIGMASK;
506 if (options->flags & UV_PROCESS_DETACHED) {
507 /* If running on a version of macOS where this flag is not supported,
508 * revert back to the fork/exec flow. Otherwise posix_spawn will
509 * silently ignore the flag. */
510 if (!posix_spawn_can_use_setsid) {
511 err = ENOSYS;
512 goto error;
513 }
514
515 flags |= POSIX_SPAWN_SETSID;
516 }
517 err = posix_spawnattr_setflags(attrs, flags);
518 if (err != 0)
519 goto error;
520
521 /* Reset all signal the child to their default behavior */
522 sigfillset(&signal_set);
523 err = posix_spawnattr_setsigdefault(attrs, &signal_set);
524 if (err != 0)
525 goto error;
526
527 /* Reset the signal mask for all signals */
528 sigemptyset(&signal_set);
529 err = posix_spawnattr_setsigmask(attrs, &signal_set);
530 if (err != 0)
531 goto error;
532
533 return err;
534
535 error:
536 (void) posix_spawnattr_destroy(attrs);
537 return err;
538 }
539
540
541 static int uv__spawn_set_posix_spawn_file_actions(
542 posix_spawn_file_actions_t* actions,
543 const uv__posix_spawn_fncs_t* posix_spawn_fncs,
544 const uv_process_options_t* options,
545 int stdio_count,
546 int (*pipes)[2]) {
547 int fd;
548 int fd2;
549 int use_fd;
550 int err;
551
552 err = posix_spawn_file_actions_init(actions);
553 if (err != 0) {
554 /* If initialization fails, no need to de-init, just return */
555 return err;
556 }
557
558 /* Set the current working directory if requested */
559 if (options->cwd != NULL) {
560 if (posix_spawn_fncs->file_actions.addchdir_np == NULL) {
561 err = ENOSYS;
562 goto error;
563 }
564
565 err = posix_spawn_fncs->file_actions.addchdir_np(actions, options->cwd);
566 if (err != 0)
567 goto error;
568 }
569
570 /* Do not return ENOSYS after this point, as we may mutate pipes. */
571
572 /* First duplicate low numbered fds, since it's not safe to duplicate them,
573 * they could get replaced. Example: swapping stdout and stderr; without
574 * this fd 2 (stderr) would be duplicated into fd 1, thus making both
575 * stdout and stderr go to the same fd, which was not the intention. */
576 for (fd = 0; fd < stdio_count; fd++) {
577 use_fd = pipes[fd][1];
578 if (use_fd < 0 || use_fd >= fd)
579 continue;
580 use_fd = stdio_count;
581 for (fd2 = 0; fd2 < stdio_count; fd2++) {
582 /* If we were not setting POSIX_SPAWN_CLOEXEC_DEFAULT, we would need to
583 * also consider whether fcntl(fd, F_GETFD) returned without the
584 * FD_CLOEXEC flag set. */
585 if (pipes[fd2][1] == use_fd) {
586 use_fd++;
587 fd2 = 0;
588 }
589 }
590 err = posix_spawn_file_actions_adddup2(
591 actions,
592 pipes[fd][1],
593 use_fd);
594 assert(err != ENOSYS);
595 if (err != 0)
596 goto error;
597 pipes[fd][1] = use_fd;
598 }
599
600 /* Second, move the descriptors into their respective places */
601 for (fd = 0; fd < stdio_count; fd++) {
602 use_fd = pipes[fd][1];
603 if (use_fd < 0) {
604 if (fd >= 3)
605 continue;
606 else {
607 /* If ignored, redirect to (or from) /dev/null, */
608 err = posix_spawn_file_actions_addopen(
609 actions,
610 fd,
611 "/dev/null",
612 fd == 0 ? O_RDONLY : O_RDWR,
613 0);
614 assert(err != ENOSYS);
615 if (err != 0)
616 goto error;
617 continue;
618 }
619 }
620
621 if (fd == use_fd)
622 err = posix_spawn_file_actions_addinherit_np(actions, fd);
623 else
624 err = posix_spawn_file_actions_adddup2(actions, use_fd, fd);
625 assert(err != ENOSYS);
626 if (err != 0)
627 goto error;
628
629 /* Make sure the fd is marked as non-blocking (state shared between child
630 * and parent). */
631 uv__nonblock_fcntl(use_fd, 0);
632 }
633
634 /* Finally, close all the superfluous descriptors */
635 for (fd = 0; fd < stdio_count; fd++) {
636 use_fd = pipes[fd][1];
637 if (use_fd < stdio_count)
638 continue;
639
640 /* Check if we already closed this. */
641 for (fd2 = 0; fd2 < fd; fd2++) {
642 if (pipes[fd2][1] == use_fd)
643 break;
644 }
645 if (fd2 < fd)
646 continue;
647
648 err = posix_spawn_file_actions_addclose(actions, use_fd);
649 assert(err != ENOSYS);
650 if (err != 0)
651 goto error;
652 }
653
654 return 0;
655
656 error:
657 (void) posix_spawn_file_actions_destroy(actions);
658 return err;
659 }
660
661 char* uv__spawn_find_path_in_env(char** env) {
662 char** env_iterator;
663 const char path_var[] = "PATH=";
664
665 /* Look for an environment variable called PATH in the
666 * provided env array, and return its value if found */
667 for (env_iterator = env; *env_iterator != NULL; env_iterator++) {
668 if (strncmp(*env_iterator, path_var, sizeof(path_var) - 1) == 0) {
669 /* Found "PATH=" at the beginning of the string */
670 return *env_iterator + sizeof(path_var) - 1;
671 }
672 }
673
674 return NULL;
675 }
676
677
678 static int uv__spawn_resolve_and_spawn(const uv_process_options_t* options,
679 posix_spawnattr_t* attrs,
680 posix_spawn_file_actions_t* actions,
681 pid_t* pid) {
682 const char *p;
683 const char *z;
684 const char *path;
685 size_t l;
686 size_t k;
687 int err;
688 int seen_eacces;
689
690 path = NULL;
691 err = -1;
692 seen_eacces = 0;
693
694 /* Short circuit for erroneous case */
695 if (options->file == NULL)
696 return ENOENT;
697
698 /* The environment for the child process is that of the parent unless overridden
699 * by options->env */
700 char** env = environ;
701 if (options->env != NULL)
702 env = options->env;
703
704 /* If options->file contains a slash, posix_spawn/posix_spawnp should behave
705 * the same, and do not involve PATH resolution at all. The libc
706 * `posix_spawnp` provided by Apple is buggy (since 10.15), so we now emulate it
707 * here, per https://github.com/libuv/libuv/pull/3583. */
708 if (strchr(options->file, '/') != NULL) {
709 do
710 err = posix_spawn(pid, options->file, actions, attrs, options->args, env);
711 while (err == EINTR);
712 return err;
713 }
714
715 /* Look for the definition of PATH in the provided env */
716 path = uv__spawn_find_path_in_env(env);
717
718 /* The following resolution logic (execvpe emulation) is copied from
719 * https://git.musl-libc.org/cgit/musl/tree/src/process/execvp.c
720 * and adapted to work for our specific usage */
721
722 /* If no path was provided in env, use the default value
723 * to look for the executable */
724 if (path == NULL)
725 path = _PATH_DEFPATH;
726
727 k = strnlen(options->file, NAME_MAX + 1);
728 if (k > NAME_MAX)
729 return ENAMETOOLONG;
730
731 l = strnlen(path, PATH_MAX - 1) + 1;
732
733 for (p = path;; p = z) {
734 /* Compose the new process file from the entry in the PATH
735 * environment variable and the actual file name */
736 char b[PATH_MAX + NAME_MAX];
737 z = strchr(p, ':');
738 if (!z)
739 z = p + strlen(p);
740 if ((size_t)(z - p) >= l) {
741 if (!*z++)
742 break;
743
744 continue;
745 }
746 memcpy(b, p, z - p);
747 b[z - p] = '/';
748 memcpy(b + (z - p) + (z > p), options->file, k + 1);
749
750 /* Try to spawn the new process file. If it fails with ENOENT, the
751 * new process file is not in this PATH entry, continue with the next
752 * PATH entry. */
753 do
754 err = posix_spawn(pid, b, actions, attrs, options->args, env);
755 while (err == EINTR);
756
757 switch (err) {
758 case EACCES:
759 seen_eacces = 1;
760 break; /* continue search */
761 case ENOENT:
762 case ENOTDIR:
763 break; /* continue search */
764 default:
765 return err;
766 }
767
768 if (!*z++)
769 break;
770 }
771
772 if (seen_eacces)
773 return EACCES;
774 return err;
775 }
776
777
778 static int uv__spawn_and_init_child_posix_spawn(
779 const uv_process_options_t* options,
780 int stdio_count,
781 int (*pipes)[2],
782 pid_t* pid,
783 const uv__posix_spawn_fncs_t* posix_spawn_fncs) {
784 int err;
785 posix_spawnattr_t attrs;
786 posix_spawn_file_actions_t actions;
787
788 err = uv__spawn_set_posix_spawn_attrs(&attrs, posix_spawn_fncs, options);
789 if (err != 0)
790 goto error;
791
792 /* This may mutate pipes. */
793 err = uv__spawn_set_posix_spawn_file_actions(&actions,
794 posix_spawn_fncs,
795 options,
796 stdio_count,
797 pipes);
798 if (err != 0) {
799 (void) posix_spawnattr_destroy(&attrs);
800 goto error;
801 }
802
803 /* Try to spawn options->file resolving in the provided environment
804 * if any */
805 err = uv__spawn_resolve_and_spawn(options, &attrs, &actions, pid);
806 assert(err != ENOSYS);
807
808 /* Destroy the actions/attributes */
809 (void) posix_spawn_file_actions_destroy(&actions);
810 (void) posix_spawnattr_destroy(&attrs);
811
812 error:
813 /* In an error situation, the attributes and file actions are
814 * already destroyed, only the happy path requires cleanup */
815 return UV__ERR(err);
816 }
817 #endif
818
819 static int uv__spawn_and_init_child_fork(const uv_process_options_t* options,
820 int stdio_count,
821 int (*pipes)[2],
822 int error_fd,
823 pid_t* pid) {
824 sigset_t signewset;
825 sigset_t sigoldset;
826
827 /* Start the child with most signals blocked, to avoid any issues before we
828 * can reset them, but allow program failures to exit (and not hang). */
829 sigfillset(&signewset);
830 sigdelset(&signewset, SIGKILL);
831 sigdelset(&signewset, SIGSTOP);
832 sigdelset(&signewset, SIGTRAP);
833 sigdelset(&signewset, SIGSEGV);
834 sigdelset(&signewset, SIGBUS);
835 sigdelset(&signewset, SIGILL);
836 sigdelset(&signewset, SIGSYS);
837 sigdelset(&signewset, SIGABRT);
838 if (pthread_sigmask(SIG_BLOCK, &signewset, &sigoldset) != 0)
839 abort();
840
841 *pid = fork();
842
843 if (*pid == 0) {
844 /* Fork succeeded, in the child process */
845 uv__process_child_init(options, stdio_count, pipes, error_fd);
846 abort();
847 }
848
849 if (pthread_sigmask(SIG_SETMASK, &sigoldset, NULL) != 0)
850 abort();
851
852 if (*pid == -1)
853 /* Failed to fork */
854 return UV__ERR(errno);
855
856 /* Fork succeeded, in the parent process */
857 return 0;
858 }
859
860 static int uv__spawn_and_init_child(
861 uv_loop_t* loop,
862 const uv_process_options_t* options,
863 int stdio_count,
864 int (*pipes)[2],
865 pid_t* pid) {
866 int signal_pipe[2] = { -1, -1 };
867 int status;
868 int err;
869 int exec_errorno;
870 ssize_t r;
871
872 #if defined(__APPLE__)
873 uv_once(&posix_spawn_init_once, uv__spawn_init_posix_spawn);
874
875 /* Special child process spawn case for macOS Big Sur (11.0) onwards
876 *
877 * Big Sur introduced a significant performance degradation on a call to
878 * fork/exec when the process has many pages mmaped in with MAP_JIT, like, say
879 * a javascript interpreter. Electron-based applications, for example,
880 * are impacted; though the magnitude of the impact depends on how much the
881 * app relies on subprocesses.
882 *
883 * On macOS, though, posix_spawn is implemented in a way that does not
884 * exhibit the problem. This block implements the forking and preparation
885 * logic with posix_spawn and its related primitives. It also takes advantage of
886 * the macOS extension POSIX_SPAWN_CLOEXEC_DEFAULT that makes impossible to
887 * leak descriptors to the child process. */
888 err = uv__spawn_and_init_child_posix_spawn(options,
889 stdio_count,
890 pipes,
891 pid,
892 &posix_spawn_fncs);
893
894 /* The posix_spawn flow will return UV_ENOSYS if any of the posix_spawn_x_np
895 * non-standard functions is both _needed_ and _undefined_. In those cases,
896 * default back to the fork/execve strategy. For all other errors, just fail. */
897 if (err != UV_ENOSYS)
898 return err;
899
900 #endif
901
902 /* This pipe is used by the parent to wait until
903 * the child has called `execve()`. We need this
904 * to avoid the following race condition:
905 *
906 * if ((pid = fork()) > 0) {
907 * kill(pid, SIGTERM);
908 * }
909 * else if (pid == 0) {
910 * execve("/bin/cat", argp, envp);
911 * }
912 *
913 * The parent sends a signal immediately after forking.
914 * Since the child may not have called `execve()` yet,
915 * there is no telling what process receives the signal,
916 * our fork or /bin/cat.
917 *
918 * To avoid ambiguity, we create a pipe with both ends
919 * marked close-on-exec. Then, after the call to `fork()`,
920 * the parent polls the read end until it EOFs or errors with EPIPE.
921 */
922 err = uv__make_pipe(signal_pipe, 0);
923 if (err)
924 return err;
925
926 /* Acquire write lock to prevent opening new fds in worker threads */
927 uv_rwlock_wrlock(&loop->cloexec_lock);
928
929 err = uv__spawn_and_init_child_fork(options, stdio_count, pipes, signal_pipe[1], pid);
930
931 /* Release lock in parent process */
932 uv_rwlock_wrunlock(&loop->cloexec_lock);
933
934 uv__close(signal_pipe[1]);
935
936 if (err == 0) {
937 do
938 r = read(signal_pipe[0], &exec_errorno, sizeof(exec_errorno));
939 while (r == -1 && errno == EINTR);
940
941 if (r == 0)
942 ; /* okay, EOF */
943 else if (r == sizeof(exec_errorno)) {
944 do
945 err = waitpid(*pid, &status, 0); /* okay, read errorno */
946 while (err == -1 && errno == EINTR);
947 assert(err == *pid);
948 err = exec_errorno;
949 } else if (r == -1 && errno == EPIPE) {
950 /* Something unknown happened to our child before spawn */
951 do
952 err = waitpid(*pid, &status, 0); /* okay, got EPIPE */
953 while (err == -1 && errno == EINTR);
954 assert(err == *pid);
955 err = UV_EPIPE;
956 } else
957 abort();
958 }
959
960 uv__close_nocheckstdio(signal_pipe[0]);
961
962 return err;
963 }
964 #endif /* ISN'T TARGET_OS_TV || TARGET_OS_WATCH */
965
966 int uv_spawn(uv_loop_t* loop,
967 uv_process_t* process,
968 const uv_process_options_t* options) {
969 #if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
970 /* fork is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED. */
971 return UV_ENOSYS;
972 #else
973 int pipes_storage[8][2];
974 int (*pipes)[2];
975 int stdio_count;
976 pid_t pid;
977 int err;
978 int exec_errorno;
979 int i;
980
981 assert(options->file != NULL);
982 assert(!(options->flags & ~(UV_PROCESS_DETACHED |
983 UV_PROCESS_SETGID |
984 UV_PROCESS_SETUID |
985 UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME |
986 UV_PROCESS_WINDOWS_HIDE |
987 UV_PROCESS_WINDOWS_HIDE_CONSOLE |
988 UV_PROCESS_WINDOWS_HIDE_GUI |
989 UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
990
991 uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
992 uv__queue_init(&process->queue);
993 process->status = 0;
994
995 stdio_count = options->stdio_count;
996 if (stdio_count < 3)
997 stdio_count = 3;
998
999 err = UV_ENOMEM;
1000 pipes = pipes_storage;
1001 if (stdio_count > (int) ARRAY_SIZE(pipes_storage))
1002 pipes = uv__malloc(stdio_count * sizeof(*pipes));
1003
1004 if (pipes == NULL)
1005 goto error;
1006
1007 for (i = 0; i < stdio_count; i++) {
1008 pipes[i][0] = -1;
1009 pipes[i][1] = -1;
1010 }
1011
1012 for (i = 0; i < options->stdio_count; i++) {
1013 err = uv__process_init_stdio(options->stdio + i, pipes[i]);
1014 if (err)
1015 goto error;
1016 }
1017
1018 #ifdef UV_USE_SIGCHLD
1019 uv_signal_start(&loop->child_watcher, uv__chld, SIGCHLD);
1020 #endif
1021
1022 /* Spawn the child */
1023 exec_errorno = uv__spawn_and_init_child(loop, options, stdio_count, pipes, &pid);
1024
1025 #if 0
1026 /* This runs into a nodejs issue (it expects initialized streams, even if the
1027 * exec failed).
1028 * See https://github.com/libuv/libuv/pull/3107#issuecomment-782482608 */
1029 if (exec_errorno != 0)
1030 goto error;
1031 #endif
1032
1033 /* Activate this handle if exec() happened successfully, even if we later
1034 * fail to open a stdio handle. This ensures we can eventually reap the child
1035 * with waitpid. */
1036 if (exec_errorno == 0) {
1037 #ifndef UV_USE_SIGCHLD
1038 struct kevent event;
1039 EV_SET(&event, pid, EVFILT_PROC, EV_ADD | EV_ONESHOT, NOTE_EXIT, 0, 0);
1040 if (kevent(loop->backend_fd, &event, 1, NULL, 0, NULL)) {
1041 if (errno != ESRCH)
1042 abort();
1043 /* Process already exited. Call waitpid on the next loop iteration. */
1044 process->flags |= UV_HANDLE_REAP;
1045 loop->flags |= UV_LOOP_REAP_CHILDREN;
1046 }
1047 /* This prevents uv__io_poll() from bailing out prematurely, being unaware
1048 * that we added an event here for it to react to. We will decrement this
1049 * again after the waitpid call succeeds. */
1050 loop->nfds++;
1051 #endif
1052
1053 process->pid = pid;
1054 process->exit_cb = options->exit_cb;
1055 uv__queue_insert_tail(&loop->process_handles, &process->queue);
1056 uv__handle_start(process);
1057 }
1058
1059 for (i = 0; i < options->stdio_count; i++) {
1060 err = uv__process_open_stream(options->stdio + i, pipes[i]);
1061 if (err == 0)
1062 continue;
1063
1064 while (i--)
1065 uv__process_close_stream(options->stdio + i);
1066
1067 goto error;
1068 }
1069
1070 if (pipes != pipes_storage)
1071 uv__free(pipes);
1072
1073 return exec_errorno;
1074
1075 error:
1076 if (pipes != NULL) {
1077 for (i = 0; i < stdio_count; i++) {
1078 if (i < options->stdio_count)
1079 if (options->stdio[i].flags & (UV_INHERIT_FD | UV_INHERIT_STREAM))
1080 continue;
1081 if (pipes[i][0] != -1)
1082 uv__close_nocheckstdio(pipes[i][0]);
1083 if (pipes[i][1] != -1)
1084 uv__close_nocheckstdio(pipes[i][1]);
1085 }
1086
1087 if (pipes != pipes_storage)
1088 uv__free(pipes);
1089 }
1090
1091 return err;
1092 #endif
1093 }
1094
1095
1096 int uv_process_kill(uv_process_t* process, int signum) {
1097 return uv_kill(process->pid, signum);
1098 }
1099
1100
1101 int uv_kill(int pid, int signum) {
1102 if (kill(pid, signum)) {
1103 #if defined(__MVS__)
1104 /* EPERM is returned if the process is a zombie. */
1105 siginfo_t infop;
1106 if (errno == EPERM &&
1107 waitid(P_PID, pid, &infop, WNOHANG | WNOWAIT | WEXITED) == 0)
1108 return 0;
1109 #endif
1110 return UV__ERR(errno);
1111 } else
1112 return 0;
1113 }
1114
1115
1116 void uv__process_close(uv_process_t* handle) {
1117 uv__queue_remove(&handle->queue);
1118 uv__handle_stop(handle);
1119 #ifdef UV_USE_SIGCHLD
1120 if (uv__queue_empty(&handle->loop->process_handles))
1121 uv_signal_stop(&handle->loop->child_watcher);
1122 #endif
1123 }