2 #include "run-command.h"
5 #include "argv-array.h"
6 #include "thread-utils.h"
8 #include "string-list.h"
11 void child_process_init(struct child_process
*child
)
13 memset(child
, 0, sizeof(*child
));
14 argv_array_init(&child
->args
);
15 argv_array_init(&child
->env_array
);
18 void child_process_clear(struct child_process
*child
)
20 argv_array_clear(&child
->args
);
21 argv_array_clear(&child
->env_array
);
24 struct child_to_clean
{
26 struct child_process
*process
;
27 struct child_to_clean
*next
;
29 static struct child_to_clean
*children_to_clean
;
30 static int installed_child_cleanup_handler
;
32 static void cleanup_children(int sig
, int in_signal
)
34 struct child_to_clean
*children_to_wait_for
= NULL
;
36 while (children_to_clean
) {
37 struct child_to_clean
*p
= children_to_clean
;
38 children_to_clean
= p
->next
;
40 if (p
->process
&& !in_signal
) {
41 struct child_process
*process
= p
->process
;
42 if (process
->clean_on_exit_handler
) {
44 "trace: run_command: running exit handler for pid %"
45 PRIuMAX
, (uintmax_t)p
->pid
47 process
->clean_on_exit_handler(process
);
53 if (p
->process
&& p
->process
->wait_after_clean
) {
54 p
->next
= children_to_wait_for
;
55 children_to_wait_for
= p
;
62 while (children_to_wait_for
) {
63 struct child_to_clean
*p
= children_to_wait_for
;
64 children_to_wait_for
= p
->next
;
66 while (waitpid(p
->pid
, NULL
, 0) < 0 && errno
== EINTR
)
67 ; /* spin waiting for process exit or error */
74 static void cleanup_children_on_signal(int sig
)
76 cleanup_children(sig
, 1);
81 static void cleanup_children_on_exit(void)
83 cleanup_children(SIGTERM
, 0);
86 static void mark_child_for_cleanup(pid_t pid
, struct child_process
*process
)
88 struct child_to_clean
*p
= xmalloc(sizeof(*p
));
91 p
->next
= children_to_clean
;
92 children_to_clean
= p
;
94 if (!installed_child_cleanup_handler
) {
95 atexit(cleanup_children_on_exit
);
96 sigchain_push_common(cleanup_children_on_signal
);
97 installed_child_cleanup_handler
= 1;
101 static void clear_child_for_cleanup(pid_t pid
)
103 struct child_to_clean
**pp
;
105 for (pp
= &children_to_clean
; *pp
; pp
= &(*pp
)->next
) {
106 struct child_to_clean
*clean_me
= *pp
;
108 if (clean_me
->pid
== pid
) {
109 *pp
= clean_me
->next
;
116 static inline void close_pair(int fd
[2])
122 int is_executable(const char *name
)
126 if (stat(name
, &st
) || /* stat, not lstat */
127 !S_ISREG(st
.st_mode
))
130 #if defined(GIT_WINDOWS_NATIVE)
132 * On Windows there is no executable bit. The file extension
133 * indicates whether it can be run as an executable, and Git
134 * has special-handling to detect scripts and launch them
135 * through the indicated script interpreter. We test for the
136 * file extension first because virus scanners may make
137 * it quite expensive to open many files.
139 if (ends_with(name
, ".exe"))
144 * Now that we know it does not have an executable extension,
145 * peek into the file instead.
149 int fd
= open(name
, O_RDONLY
);
150 st
.st_mode
&= ~S_IXUSR
;
152 n
= read(fd
, buf
, 2);
154 /* look for a she-bang */
155 if (!strcmp(buf
, "#!"))
156 st
.st_mode
|= S_IXUSR
;
161 return st
.st_mode
& S_IXUSR
;
165 * Search $PATH for a command. This emulates the path search that
166 * execvp would perform, without actually executing the command so it
167 * can be used before fork() to prepare to run a command using
168 * execve() or after execvp() to diagnose why it failed.
170 * The caller should ensure that file contains no directory
173 * Returns the path to the command, as found in $PATH or NULL if the
174 * command could not be found. The caller inherits ownership of the memory
175 * used to store the resultant path.
177 * This should not be used on Windows, where the $PATH search rules
178 * are more complicated (e.g., a search for "foo" should find
181 static char *locate_in_PATH(const char *file
)
183 const char *p
= getenv("PATH");
184 struct strbuf buf
= STRBUF_INIT
;
190 const char *end
= strchrnul(p
, ':');
194 /* POSIX specifies an empty entry as the current directory. */
196 strbuf_add(&buf
, p
, end
- p
);
197 strbuf_addch(&buf
, '/');
199 strbuf_addstr(&buf
, file
);
201 if (is_executable(buf
.buf
))
202 return strbuf_detach(&buf
, NULL
);
209 strbuf_release(&buf
);
213 static int exists_in_PATH(const char *file
)
215 char *r
= locate_in_PATH(file
);
216 int found
= r
!= NULL
;
221 int sane_execvp(const char *file
, char * const argv
[])
223 #ifndef GIT_WINDOWS_NATIVE
225 * execvp() doesn't return, so we all we can do is tell trace2
226 * what we are about to do and let it leave a hint in the log
227 * (unless of course the execvp() fails).
229 * we skip this for Windows because the compat layer already
230 * has to emulate the execvp() call anyway.
232 int exec_id
= trace2_exec(file
, (const char **)argv
);
235 if (!execvp(file
, argv
))
236 return 0; /* cannot happen ;-) */
238 #ifndef GIT_WINDOWS_NATIVE
241 trace2_exec_result(exec_id
, ec
);
247 * When a command can't be found because one of the directories
248 * listed in $PATH is unsearchable, execvp reports EACCES, but
249 * careful usability testing (read: analysis of occasional bug
250 * reports) reveals that "No such file or directory" is more
253 * We avoid commands with "/", because execvp will not do $PATH
254 * lookups in that case.
256 * The reassignment of EACCES to errno looks like a no-op below,
257 * but we need to protect against exists_in_PATH overwriting errno.
259 if (errno
== EACCES
&& !strchr(file
, '/'))
260 errno
= exists_in_PATH(file
) ? EACCES
: ENOENT
;
261 else if (errno
== ENOTDIR
&& !strchr(file
, '/'))
266 static const char **prepare_shell_cmd(struct argv_array
*out
, const char **argv
)
269 BUG("shell command is empty");
271 if (strcspn(argv
[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv
[0])) {
272 #ifndef GIT_WINDOWS_NATIVE
273 argv_array_push(out
, SHELL_PATH
);
275 argv_array_push(out
, "sh");
277 argv_array_push(out
, "-c");
280 * If we have no extra arguments, we do not even need to
281 * bother with the "$@" magic.
284 argv_array_push(out
, argv
[0]);
286 argv_array_pushf(out
, "%s \"$@\"", argv
[0]);
289 argv_array_pushv(out
, argv
);
293 #ifndef GIT_WINDOWS_NATIVE
294 static int child_notifier
= -1;
300 CHILD_ERR_SIGPROCMASK
,
307 enum child_errcode err
;
308 int syserr
; /* errno */
311 static void child_die(enum child_errcode err
)
313 struct child_err buf
;
318 /* write(2) on buf smaller than PIPE_BUF (min 512) is atomic: */
319 xwrite(child_notifier
, &buf
, sizeof(buf
));
323 static void child_dup2(int fd
, int to
)
325 if (dup2(fd
, to
) < 0)
326 child_die(CHILD_ERR_DUP2
);
329 static void child_close(int fd
)
332 child_die(CHILD_ERR_CLOSE
);
335 static void child_close_pair(int fd
[2])
342 * parent will make it look like the child spewed a fatal error and died
343 * this is needed to prevent changes to t0061.
345 static void fake_fatal(const char *err
, va_list params
)
347 vreportf("fatal: ", err
, params
);
350 static void child_error_fn(const char *err
, va_list params
)
352 const char msg
[] = "error() should not be called in child\n";
353 xwrite(2, msg
, sizeof(msg
) - 1);
356 static void child_warn_fn(const char *err
, va_list params
)
358 const char msg
[] = "warn() should not be called in child\n";
359 xwrite(2, msg
, sizeof(msg
) - 1);
362 static void NORETURN
child_die_fn(const char *err
, va_list params
)
364 const char msg
[] = "die() should not be called in child\n";
365 xwrite(2, msg
, sizeof(msg
) - 1);
369 /* this runs in the parent process */
370 static void child_err_spew(struct child_process
*cmd
, struct child_err
*cerr
)
372 static void (*old_errfn
)(const char *err
, va_list params
);
374 old_errfn
= get_error_routine();
375 set_error_routine(fake_fatal
);
376 errno
= cerr
->syserr
;
379 case CHILD_ERR_CHDIR
:
380 error_errno("exec '%s': cd to '%s' failed",
381 cmd
->argv
[0], cmd
->dir
);
384 error_errno("dup2() in child failed");
386 case CHILD_ERR_CLOSE
:
387 error_errno("close() in child failed");
389 case CHILD_ERR_SIGPROCMASK
:
390 error_errno("sigprocmask failed restoring signals");
392 case CHILD_ERR_ENOENT
:
393 error_errno("cannot run %s", cmd
->argv
[0]);
395 case CHILD_ERR_SILENT
:
397 case CHILD_ERR_ERRNO
:
398 error_errno("cannot exec '%s'", cmd
->argv
[0]);
401 set_error_routine(old_errfn
);
404 static int prepare_cmd(struct argv_array
*out
, const struct child_process
*cmd
)
407 BUG("command is empty");
410 * Add SHELL_PATH so in the event exec fails with ENOEXEC we can
411 * attempt to interpret the command with 'sh'.
413 argv_array_push(out
, SHELL_PATH
);
416 argv_array_push(out
, "git");
417 argv_array_pushv(out
, cmd
->argv
);
418 } else if (cmd
->use_shell
) {
419 prepare_shell_cmd(out
, cmd
->argv
);
421 argv_array_pushv(out
, cmd
->argv
);
425 * If there are no '/' characters in the command then perform a path
426 * lookup and use the resolved path as the command to exec. If there
427 * are '/' characters, we have exec attempt to invoke the command
430 if (!strchr(out
->argv
[1], '/')) {
431 char *program
= locate_in_PATH(out
->argv
[1]);
433 free((char *)out
->argv
[1]);
434 out
->argv
[1] = program
;
436 argv_array_clear(out
);
445 static char **prep_childenv(const char *const *deltaenv
)
447 extern char **environ
;
449 struct string_list env
= STRING_LIST_INIT_DUP
;
450 struct strbuf key
= STRBUF_INIT
;
451 const char *const *p
;
454 /* Construct a sorted string list consisting of the current environ */
455 for (p
= (const char *const *) environ
; p
&& *p
; p
++) {
456 const char *equals
= strchr(*p
, '=');
460 strbuf_add(&key
, *p
, equals
- *p
);
461 string_list_append(&env
, key
.buf
)->util
= (void *) *p
;
463 string_list_append(&env
, *p
)->util
= (void *) *p
;
466 string_list_sort(&env
);
468 /* Merge in 'deltaenv' with the current environ */
469 for (p
= deltaenv
; p
&& *p
; p
++) {
470 const char *equals
= strchr(*p
, '=');
473 /* ('key=value'), insert or replace entry */
475 strbuf_add(&key
, *p
, equals
- *p
);
476 string_list_insert(&env
, key
.buf
)->util
= (void *) *p
;
478 /* otherwise ('key') remove existing entry */
479 string_list_remove(&env
, *p
, 0);
483 /* Create an array of 'char *' to be used as the childenv */
484 ALLOC_ARRAY(childenv
, env
.nr
+ 1);
485 for (i
= 0; i
< env
.nr
; i
++)
486 childenv
[i
] = env
.items
[i
].util
;
487 childenv
[env
.nr
] = NULL
;
489 string_list_clear(&env
, 0);
490 strbuf_release(&key
);
494 struct atfork_state
{
501 #define CHECK_BUG(err, msg) \
505 BUG("%s: %s", msg, strerror(e)); \
508 static void atfork_prepare(struct atfork_state
*as
)
512 if (sigfillset(&all
))
513 die_errno("sigfillset");
515 if (sigprocmask(SIG_SETMASK
, &all
, &as
->old
))
516 die_errno("sigprocmask");
518 CHECK_BUG(pthread_sigmask(SIG_SETMASK
, &all
, &as
->old
),
519 "blocking all signals");
520 CHECK_BUG(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
, &as
->cs
),
521 "disabling cancellation");
525 static void atfork_parent(struct atfork_state
*as
)
528 if (sigprocmask(SIG_SETMASK
, &as
->old
, NULL
))
529 die_errno("sigprocmask");
531 CHECK_BUG(pthread_setcancelstate(as
->cs
, NULL
),
532 "re-enabling cancellation");
533 CHECK_BUG(pthread_sigmask(SIG_SETMASK
, &as
->old
, NULL
),
534 "restoring signal mask");
537 #endif /* GIT_WINDOWS_NATIVE */
539 static inline void set_cloexec(int fd
)
541 int flags
= fcntl(fd
, F_GETFD
);
543 fcntl(fd
, F_SETFD
, flags
| FD_CLOEXEC
);
546 static int wait_or_whine(pid_t pid
, const char *argv0
, int in_signal
)
548 int status
, code
= -1;
550 int failed_errno
= 0;
552 while ((waiting
= waitpid(pid
, &status
, 0)) < 0 && errno
== EINTR
)
558 failed_errno
= errno
;
559 error_errno("waitpid for %s failed", argv0
);
560 } else if (waiting
!= pid
) {
561 error("waitpid is confused (%s)", argv0
);
562 } else if (WIFSIGNALED(status
)) {
563 code
= WTERMSIG(status
);
564 if (code
!= SIGINT
&& code
!= SIGQUIT
&& code
!= SIGPIPE
)
565 error("%s died of signal %d", argv0
, code
);
567 * This return value is chosen so that code & 0xff
568 * mimics the exit code that a POSIX shell would report for
569 * a program that died from this signal.
572 } else if (WIFEXITED(status
)) {
573 code
= WEXITSTATUS(status
);
575 error("waitpid is confused (%s)", argv0
);
578 clear_child_for_cleanup(pid
);
580 errno
= failed_errno
;
584 static void trace_add_env(struct strbuf
*dst
, const char *const *deltaenv
)
586 struct string_list envs
= STRING_LIST_INIT_DUP
;
587 const char *const *e
;
589 int printed_unset
= 0;
591 /* Last one wins, see run-command.c:prep_childenv() for context */
592 for (e
= deltaenv
; e
&& *e
; e
++) {
593 struct strbuf key
= STRBUF_INIT
;
594 char *equals
= strchr(*e
, '=');
597 strbuf_add(&key
, *e
, equals
- *e
);
598 string_list_insert(&envs
, key
.buf
)->util
= equals
+ 1;
600 string_list_insert(&envs
, *e
)->util
= NULL
;
602 strbuf_release(&key
);
605 /* "unset X Y...;" */
606 for (i
= 0; i
< envs
.nr
; i
++) {
607 const char *var
= envs
.items
[i
].string
;
608 const char *val
= envs
.items
[i
].util
;
610 if (val
|| !getenv(var
))
613 if (!printed_unset
) {
614 strbuf_addstr(dst
, " unset");
617 strbuf_addf(dst
, " %s", var
);
620 strbuf_addch(dst
, ';');
622 /* ... followed by "A=B C=D ..." */
623 for (i
= 0; i
< envs
.nr
; i
++) {
624 const char *var
= envs
.items
[i
].string
;
625 const char *val
= envs
.items
[i
].util
;
631 oldval
= getenv(var
);
632 if (oldval
&& !strcmp(val
, oldval
))
635 strbuf_addf(dst
, " %s=", var
);
636 sq_quote_buf_pretty(dst
, val
);
638 string_list_clear(&envs
, 0);
641 static void trace_run_command(const struct child_process
*cp
)
643 struct strbuf buf
= STRBUF_INIT
;
645 if (!trace_want(&trace_default_key
))
648 strbuf_addstr(&buf
, "trace: run_command:");
650 strbuf_addstr(&buf
, " cd ");
651 sq_quote_buf_pretty(&buf
, cp
->dir
);
652 strbuf_addch(&buf
, ';');
655 * The caller is responsible for initializing cp->env from
656 * cp->env_array if needed. We only check one place.
659 trace_add_env(&buf
, cp
->env
);
661 strbuf_addstr(&buf
, " git");
662 sq_quote_argv_pretty(&buf
, cp
->argv
);
664 trace_printf("%s", buf
.buf
);
665 strbuf_release(&buf
);
668 int start_command(struct child_process
*cmd
)
670 int need_in
, need_out
, need_err
;
671 int fdin
[2], fdout
[2], fderr
[2];
676 cmd
->argv
= cmd
->args
.argv
;
678 cmd
->env
= cmd
->env_array
.argv
;
681 * In case of errors we must keep the promise to close FDs
682 * that have been passed in via ->in and ->out.
685 need_in
= !cmd
->no_stdin
&& cmd
->in
< 0;
687 if (pipe(fdin
) < 0) {
688 failed_errno
= errno
;
691 str
= "standard input";
697 need_out
= !cmd
->no_stdout
698 && !cmd
->stdout_to_stderr
701 if (pipe(fdout
) < 0) {
702 failed_errno
= errno
;
707 str
= "standard output";
713 need_err
= !cmd
->no_stderr
&& cmd
->err
< 0;
715 if (pipe(fderr
) < 0) {
716 failed_errno
= errno
;
725 str
= "standard error";
727 error("cannot create %s pipe for %s: %s",
728 str
, cmd
->argv
[0], strerror(failed_errno
));
729 child_process_clear(cmd
);
730 errno
= failed_errno
;
736 trace2_child_start(cmd
);
737 trace_run_command(cmd
);
741 #ifndef GIT_WINDOWS_NATIVE
746 struct argv_array argv
= ARGV_ARRAY_INIT
;
747 struct child_err cerr
;
748 struct atfork_state as
;
750 if (prepare_cmd(&argv
, cmd
) < 0) {
751 failed_errno
= errno
;
753 if (!cmd
->silent_exec_failure
)
754 error_errno("cannot run %s", cmd
->argv
[0]);
758 if (pipe(notify_pipe
))
759 notify_pipe
[0] = notify_pipe
[1] = -1;
761 if (cmd
->no_stdin
|| cmd
->no_stdout
|| cmd
->no_stderr
) {
762 null_fd
= open("/dev/null", O_RDWR
| O_CLOEXEC
);
764 die_errno(_("open /dev/null failed"));
765 set_cloexec(null_fd
);
768 childenv
= prep_childenv(cmd
->env
);
772 * NOTE: In order to prevent deadlocking when using threads special
773 * care should be taken with the function calls made in between the
774 * fork() and exec() calls. No calls should be made to functions which
775 * require acquiring a lock (e.g. malloc) as the lock could have been
776 * held by another thread at the time of forking, causing the lock to
777 * never be released in the child process. This means only
778 * Async-Signal-Safe functions are permitted in the child.
781 failed_errno
= errno
;
785 * Ensure the default die/error/warn routines do not get
786 * called, they can take stdio locks and malloc.
788 set_die_routine(child_die_fn
);
789 set_error_routine(child_error_fn
);
790 set_warn_routine(child_warn_fn
);
792 close(notify_pipe
[0]);
793 set_cloexec(notify_pipe
[1]);
794 child_notifier
= notify_pipe
[1];
797 child_dup2(null_fd
, 0);
799 child_dup2(fdin
[0], 0);
800 child_close_pair(fdin
);
801 } else if (cmd
->in
) {
802 child_dup2(cmd
->in
, 0);
803 child_close(cmd
->in
);
807 child_dup2(null_fd
, 2);
809 child_dup2(fderr
[1], 2);
810 child_close_pair(fderr
);
811 } else if (cmd
->err
> 1) {
812 child_dup2(cmd
->err
, 2);
813 child_close(cmd
->err
);
817 child_dup2(null_fd
, 1);
818 else if (cmd
->stdout_to_stderr
)
821 child_dup2(fdout
[1], 1);
822 child_close_pair(fdout
);
823 } else if (cmd
->out
> 1) {
824 child_dup2(cmd
->out
, 1);
825 child_close(cmd
->out
);
828 if (cmd
->dir
&& chdir(cmd
->dir
))
829 child_die(CHILD_ERR_CHDIR
);
832 * restore default signal handlers here, in case
833 * we catch a signal right before execve below
835 for (sig
= 1; sig
< NSIG
; sig
++) {
836 /* ignored signals get reset to SIG_DFL on execve */
837 if (signal(sig
, SIG_DFL
) == SIG_IGN
)
838 signal(sig
, SIG_IGN
);
841 if (sigprocmask(SIG_SETMASK
, &as
.old
, NULL
) != 0)
842 child_die(CHILD_ERR_SIGPROCMASK
);
845 * Attempt to exec using the command and arguments starting at
846 * argv.argv[1]. argv.argv[0] contains SHELL_PATH which will
847 * be used in the event exec failed with ENOEXEC at which point
848 * we will try to interpret the command using 'sh'.
850 execve(argv
.argv
[1], (char *const *) argv
.argv
+ 1,
851 (char *const *) childenv
);
852 if (errno
== ENOEXEC
)
853 execve(argv
.argv
[0], (char *const *) argv
.argv
,
854 (char *const *) childenv
);
856 if (errno
== ENOENT
) {
857 if (cmd
->silent_exec_failure
)
858 child_die(CHILD_ERR_SILENT
);
859 child_die(CHILD_ERR_ENOENT
);
861 child_die(CHILD_ERR_ERRNO
);
866 error_errno("cannot fork() for %s", cmd
->argv
[0]);
867 else if (cmd
->clean_on_exit
)
868 mark_child_for_cleanup(cmd
->pid
, cmd
);
871 * Wait for child's exec. If the exec succeeds (or if fork()
872 * failed), EOF is seen immediately by the parent. Otherwise, the
873 * child process sends a child_err struct.
874 * Note that use of this infrastructure is completely advisory,
875 * therefore, we keep error checks minimal.
877 close(notify_pipe
[1]);
878 if (xread(notify_pipe
[0], &cerr
, sizeof(cerr
)) == sizeof(cerr
)) {
880 * At this point we know that fork() succeeded, but exec()
881 * failed. Errors have been reported to our stderr.
883 wait_or_whine(cmd
->pid
, cmd
->argv
[0], 0);
884 child_err_spew(cmd
, &cerr
);
885 failed_errno
= errno
;
888 close(notify_pipe
[0]);
892 argv_array_clear(&argv
);
899 int fhin
= 0, fhout
= 1, fherr
= 2;
900 const char **sargv
= cmd
->argv
;
901 struct argv_array nargv
= ARGV_ARRAY_INIT
;
904 fhin
= open("/dev/null", O_RDWR
);
911 fherr
= open("/dev/null", O_RDWR
);
913 fherr
= dup(fderr
[1]);
914 else if (cmd
->err
> 2)
915 fherr
= dup(cmd
->err
);
918 fhout
= open("/dev/null", O_RDWR
);
919 else if (cmd
->stdout_to_stderr
)
922 fhout
= dup(fdout
[1]);
923 else if (cmd
->out
> 1)
924 fhout
= dup(cmd
->out
);
927 cmd
->argv
= prepare_git_cmd(&nargv
, cmd
->argv
);
928 else if (cmd
->use_shell
)
929 cmd
->argv
= prepare_shell_cmd(&nargv
, cmd
->argv
);
931 cmd
->pid
= mingw_spawnvpe(cmd
->argv
[0], cmd
->argv
, (char**) cmd
->env
,
932 cmd
->dir
, fhin
, fhout
, fherr
);
933 failed_errno
= errno
;
934 if (cmd
->pid
< 0 && (!cmd
->silent_exec_failure
|| errno
!= ENOENT
))
935 error_errno("cannot spawn %s", cmd
->argv
[0]);
936 if (cmd
->clean_on_exit
&& cmd
->pid
>= 0)
937 mark_child_for_cleanup(cmd
->pid
, cmd
);
939 argv_array_clear(&nargv
);
951 trace2_child_exit(cmd
, -1);
965 child_process_clear(cmd
);
966 errno
= failed_errno
;
988 int finish_command(struct child_process
*cmd
)
990 int ret
= wait_or_whine(cmd
->pid
, cmd
->argv
[0], 0);
991 trace2_child_exit(cmd
, ret
);
992 child_process_clear(cmd
);
996 int finish_command_in_signal(struct child_process
*cmd
)
998 int ret
= wait_or_whine(cmd
->pid
, cmd
->argv
[0], 1);
999 trace2_child_exit(cmd
, ret
);
1004 int run_command(struct child_process
*cmd
)
1008 if (cmd
->out
< 0 || cmd
->err
< 0)
1009 BUG("run_command with a pipe can cause deadlock");
1011 code
= start_command(cmd
);
1014 return finish_command(cmd
);
1017 int run_command_v_opt(const char **argv
, int opt
)
1019 return run_command_v_opt_cd_env(argv
, opt
, NULL
, NULL
);
1022 int run_command_v_opt_tr2(const char **argv
, int opt
, const char *tr2_class
)
1024 return run_command_v_opt_cd_env_tr2(argv
, opt
, NULL
, NULL
, tr2_class
);
1027 int run_command_v_opt_cd_env(const char **argv
, int opt
, const char *dir
, const char *const *env
)
1029 return run_command_v_opt_cd_env_tr2(argv
, opt
, dir
, env
, NULL
);
1032 int run_command_v_opt_cd_env_tr2(const char **argv
, int opt
, const char *dir
,
1033 const char *const *env
, const char *tr2_class
)
1035 struct child_process cmd
= CHILD_PROCESS_INIT
;
1037 cmd
.no_stdin
= opt
& RUN_COMMAND_NO_STDIN
? 1 : 0;
1038 cmd
.git_cmd
= opt
& RUN_GIT_CMD
? 1 : 0;
1039 cmd
.stdout_to_stderr
= opt
& RUN_COMMAND_STDOUT_TO_STDERR
? 1 : 0;
1040 cmd
.silent_exec_failure
= opt
& RUN_SILENT_EXEC_FAILURE
? 1 : 0;
1041 cmd
.use_shell
= opt
& RUN_USING_SHELL
? 1 : 0;
1042 cmd
.clean_on_exit
= opt
& RUN_CLEAN_ON_EXIT
? 1 : 0;
1045 cmd
.trace2_child_class
= tr2_class
;
1046 return run_command(&cmd
);
1050 static pthread_t main_thread
;
1051 static int main_thread_set
;
1052 static pthread_key_t async_key
;
1053 static pthread_key_t async_die_counter
;
1055 static void *run_thread(void *data
)
1057 struct async
*async
= data
;
1060 if (async
->isolate_sigpipe
) {
1063 sigaddset(&mask
, SIGPIPE
);
1064 if (pthread_sigmask(SIG_BLOCK
, &mask
, NULL
) < 0) {
1065 ret
= error("unable to block SIGPIPE in async thread");
1070 pthread_setspecific(async_key
, async
);
1071 ret
= async
->proc(async
->proc_in
, async
->proc_out
, async
->data
);
1075 static NORETURN
void die_async(const char *err
, va_list params
)
1077 vreportf("fatal: ", err
, params
);
1080 struct async
*async
= pthread_getspecific(async_key
);
1081 if (async
->proc_in
>= 0)
1082 close(async
->proc_in
);
1083 if (async
->proc_out
>= 0)
1084 close(async
->proc_out
);
1085 pthread_exit((void *)128);
1091 static int async_die_is_recursing(void)
1093 void *ret
= pthread_getspecific(async_die_counter
);
1094 pthread_setspecific(async_die_counter
, (void *)1);
1100 if (!main_thread_set
)
1101 return 0; /* no asyncs started yet */
1102 return !pthread_equal(main_thread
, pthread_self());
1105 static void NORETURN
async_exit(int code
)
1107 pthread_exit((void *)(intptr_t)code
);
1113 void (**handlers
)(void);
1118 static int git_atexit_installed
;
1120 static void git_atexit_dispatch(void)
1124 for (i
=git_atexit_hdlrs
.nr
; i
; i
--)
1125 git_atexit_hdlrs
.handlers
[i
-1]();
1128 static void git_atexit_clear(void)
1130 free(git_atexit_hdlrs
.handlers
);
1131 memset(&git_atexit_hdlrs
, 0, sizeof(git_atexit_hdlrs
));
1132 git_atexit_installed
= 0;
1136 int git_atexit(void (*handler
)(void))
1138 ALLOC_GROW(git_atexit_hdlrs
.handlers
, git_atexit_hdlrs
.nr
+ 1, git_atexit_hdlrs
.alloc
);
1139 git_atexit_hdlrs
.handlers
[git_atexit_hdlrs
.nr
++] = handler
;
1140 if (!git_atexit_installed
) {
1141 if (atexit(&git_atexit_dispatch
))
1143 git_atexit_installed
= 1;
1147 #define atexit git_atexit
1149 static int process_is_async
;
1152 return process_is_async
;
1155 static void NORETURN
async_exit(int code
)
1162 void check_pipe(int err
)
1168 signal(SIGPIPE
, SIG_DFL
);
1170 /* Should never happen, but just in case... */
1175 int start_async(struct async
*async
)
1177 int need_in
, need_out
;
1178 int fdin
[2], fdout
[2];
1179 int proc_in
, proc_out
;
1181 need_in
= async
->in
< 0;
1183 if (pipe(fdin
) < 0) {
1186 return error_errno("cannot create pipe");
1188 async
->in
= fdin
[1];
1191 need_out
= async
->out
< 0;
1193 if (pipe(fdout
) < 0) {
1198 return error_errno("cannot create pipe");
1200 async
->out
= fdout
[0];
1206 proc_in
= async
->in
;
1211 proc_out
= fdout
[1];
1212 else if (async
->out
)
1213 proc_out
= async
->out
;
1218 /* Flush stdio before fork() to avoid cloning buffers */
1221 async
->pid
= fork();
1222 if (async
->pid
< 0) {
1223 error_errno("fork (async) failed");
1232 process_is_async
= 1;
1233 exit(!!async
->proc(proc_in
, proc_out
, async
->data
));
1236 mark_child_for_cleanup(async
->pid
, NULL
);
1245 else if (async
->out
)
1248 if (!main_thread_set
) {
1250 * We assume that the first time that start_async is called
1251 * it is from the main thread.
1253 main_thread_set
= 1;
1254 main_thread
= pthread_self();
1255 pthread_key_create(&async_key
, NULL
);
1256 pthread_key_create(&async_die_counter
, NULL
);
1257 set_die_routine(die_async
);
1258 set_die_is_recursing_routine(async_die_is_recursing
);
1262 set_cloexec(proc_in
);
1264 set_cloexec(proc_out
);
1265 async
->proc_in
= proc_in
;
1266 async
->proc_out
= proc_out
;
1268 int err
= pthread_create(&async
->tid
, NULL
, run_thread
, async
);
1270 error(_("cannot create async thread: %s"), strerror(err
));
1285 else if (async
->out
)
1290 int finish_async(struct async
*async
)
1293 return wait_or_whine(async
->pid
, "child process", 0);
1295 void *ret
= (void *)(intptr_t)(-1);
1297 if (pthread_join(async
->tid
, &ret
))
1298 error("pthread_join failed");
1299 return (int)(intptr_t)ret
;
1303 int async_with_fork(void)
1312 const char *find_hook(const char *name
)
1314 static struct strbuf path
= STRBUF_INIT
;
1316 strbuf_reset(&path
);
1317 strbuf_git_path(&path
, "hooks/%s", name
);
1318 if (access(path
.buf
, X_OK
) < 0) {
1321 #ifdef STRIP_EXTENSION
1322 strbuf_addstr(&path
, STRIP_EXTENSION
);
1323 if (access(path
.buf
, X_OK
) >= 0)
1325 if (errno
== EACCES
)
1329 if (err
== EACCES
&& advice_ignored_hook
) {
1330 static struct string_list advise_given
= STRING_LIST_INIT_DUP
;
1332 if (!string_list_lookup(&advise_given
, name
)) {
1333 string_list_insert(&advise_given
, name
);
1334 advise(_("The '%s' hook was ignored because "
1335 "it's not set as executable.\n"
1336 "You can disable this warning with "
1337 "`git config advice.ignoredHook false`."),
1346 int run_hook_ve(const char *const *env
, const char *name
, va_list args
)
1348 struct child_process hook
= CHILD_PROCESS_INIT
;
1351 p
= find_hook(name
);
1355 argv_array_push(&hook
.args
, p
);
1356 while ((p
= va_arg(args
, const char *)))
1357 argv_array_push(&hook
.args
, p
);
1360 hook
.stdout_to_stderr
= 1;
1361 hook
.trace2_hook_name
= name
;
1363 return run_command(&hook
);
1366 int run_hook_le(const char *const *env
, const char *name
, ...)
1371 va_start(args
, name
);
1372 ret
= run_hook_ve(env
, name
, args
);
1379 /* initialized by caller */
1381 int type
; /* POLLOUT or POLLIN */
1393 /* returned by pump_io */
1394 int error
; /* 0 for success, otherwise errno */
1400 static int pump_io_round(struct io_pump
*slots
, int nr
, struct pollfd
*pfd
)
1405 for (i
= 0; i
< nr
; i
++) {
1406 struct io_pump
*io
= &slots
[i
];
1409 pfd
[pollsize
].fd
= io
->fd
;
1410 pfd
[pollsize
].events
= io
->type
;
1411 io
->pfd
= &pfd
[pollsize
++];
1417 if (poll(pfd
, pollsize
, -1) < 0) {
1420 die_errno("poll failed");
1423 for (i
= 0; i
< nr
; i
++) {
1424 struct io_pump
*io
= &slots
[i
];
1429 if (!(io
->pfd
->revents
& (POLLOUT
|POLLIN
|POLLHUP
|POLLERR
|POLLNVAL
)))
1432 if (io
->type
== POLLOUT
) {
1433 ssize_t len
= xwrite(io
->fd
,
1434 io
->u
.out
.buf
, io
->u
.out
.len
);
1440 io
->u
.out
.buf
+= len
;
1441 io
->u
.out
.len
-= len
;
1442 if (!io
->u
.out
.len
) {
1449 if (io
->type
== POLLIN
) {
1450 ssize_t len
= strbuf_read_once(io
->u
.in
.buf
,
1451 io
->fd
, io
->u
.in
.hint
);
1464 static int pump_io(struct io_pump
*slots
, int nr
)
1469 for (i
= 0; i
< nr
; i
++)
1472 ALLOC_ARRAY(pfd
, nr
);
1473 while (pump_io_round(slots
, nr
, pfd
))
1477 /* There may be multiple errno values, so just pick the first. */
1478 for (i
= 0; i
< nr
; i
++) {
1479 if (slots
[i
].error
) {
1480 errno
= slots
[i
].error
;
1488 int pipe_command(struct child_process
*cmd
,
1489 const char *in
, size_t in_len
,
1490 struct strbuf
*out
, size_t out_hint
,
1491 struct strbuf
*err
, size_t err_hint
)
1493 struct io_pump io
[3];
1503 if (start_command(cmd
) < 0)
1507 io
[nr
].fd
= cmd
->in
;
1508 io
[nr
].type
= POLLOUT
;
1509 io
[nr
].u
.out
.buf
= in
;
1510 io
[nr
].u
.out
.len
= in_len
;
1514 io
[nr
].fd
= cmd
->out
;
1515 io
[nr
].type
= POLLIN
;
1516 io
[nr
].u
.in
.buf
= out
;
1517 io
[nr
].u
.in
.hint
= out_hint
;
1521 io
[nr
].fd
= cmd
->err
;
1522 io
[nr
].type
= POLLIN
;
1523 io
[nr
].u
.in
.buf
= err
;
1524 io
[nr
].u
.in
.hint
= err_hint
;
1528 if (pump_io(io
, nr
) < 0) {
1529 finish_command(cmd
); /* throw away exit code */
1533 return finish_command(cmd
);
1539 GIT_CP_WAIT_CLEANUP
,
1542 struct parallel_processes
{
1548 get_next_task_fn get_next_task
;
1549 start_failure_fn start_failure
;
1550 task_finished_fn task_finished
;
1553 enum child_state state
;
1554 struct child_process process
;
1559 * The struct pollfd is logically part of *children,
1560 * but the system call expects it as its own array.
1564 unsigned shutdown
: 1;
1567 struct strbuf buffered_output
; /* of finished children */
1570 static int default_start_failure(struct strbuf
*out
,
1577 static int default_task_finished(int result
,
1585 static void kill_children(struct parallel_processes
*pp
, int signo
)
1587 int i
, n
= pp
->max_processes
;
1589 for (i
= 0; i
< n
; i
++)
1590 if (pp
->children
[i
].state
== GIT_CP_WORKING
)
1591 kill(pp
->children
[i
].process
.pid
, signo
);
1594 static struct parallel_processes
*pp_for_signal
;
1596 static void handle_children_on_signal(int signo
)
1598 kill_children(pp_for_signal
, signo
);
1599 sigchain_pop(signo
);
1603 static void pp_init(struct parallel_processes
*pp
,
1605 get_next_task_fn get_next_task
,
1606 start_failure_fn start_failure
,
1607 task_finished_fn task_finished
,
1615 pp
->max_processes
= n
;
1617 trace_printf("run_processes_parallel: preparing to run up to %d tasks", n
);
1621 BUG("you need to specify a get_next_task function");
1622 pp
->get_next_task
= get_next_task
;
1624 pp
->start_failure
= start_failure
? start_failure
: default_start_failure
;
1625 pp
->task_finished
= task_finished
? task_finished
: default_task_finished
;
1627 pp
->nr_processes
= 0;
1628 pp
->output_owner
= 0;
1630 pp
->children
= xcalloc(n
, sizeof(*pp
->children
));
1631 pp
->pfd
= xcalloc(n
, sizeof(*pp
->pfd
));
1632 strbuf_init(&pp
->buffered_output
, 0);
1634 for (i
= 0; i
< n
; i
++) {
1635 strbuf_init(&pp
->children
[i
].err
, 0);
1636 child_process_init(&pp
->children
[i
].process
);
1637 pp
->pfd
[i
].events
= POLLIN
| POLLHUP
;
1642 sigchain_push_common(handle_children_on_signal
);
1645 static void pp_cleanup(struct parallel_processes
*pp
)
1649 trace_printf("run_processes_parallel: done");
1650 for (i
= 0; i
< pp
->max_processes
; i
++) {
1651 strbuf_release(&pp
->children
[i
].err
);
1652 child_process_clear(&pp
->children
[i
].process
);
1659 * When get_next_task added messages to the buffer in its last
1660 * iteration, the buffered output is non empty.
1662 strbuf_write(&pp
->buffered_output
, stderr
);
1663 strbuf_release(&pp
->buffered_output
);
1665 sigchain_pop_common();
1669 * 0 if a new task was started.
1670 * 1 if no new jobs was started (get_next_task ran out of work, non critical
1671 * problem with starting a new command)
1672 * <0 no new job was started, user wishes to shutdown early. Use negative code
1673 * to signal the children.
1675 static int pp_start_one(struct parallel_processes
*pp
)
1679 for (i
= 0; i
< pp
->max_processes
; i
++)
1680 if (pp
->children
[i
].state
== GIT_CP_FREE
)
1682 if (i
== pp
->max_processes
)
1683 BUG("bookkeeping is hard");
1685 code
= pp
->get_next_task(&pp
->children
[i
].process
,
1686 &pp
->children
[i
].err
,
1688 &pp
->children
[i
].data
);
1690 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1691 strbuf_reset(&pp
->children
[i
].err
);
1694 pp
->children
[i
].process
.err
= -1;
1695 pp
->children
[i
].process
.stdout_to_stderr
= 1;
1696 pp
->children
[i
].process
.no_stdin
= 1;
1698 if (start_command(&pp
->children
[i
].process
)) {
1699 code
= pp
->start_failure(&pp
->children
[i
].err
,
1701 pp
->children
[i
].data
);
1702 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1703 strbuf_reset(&pp
->children
[i
].err
);
1710 pp
->children
[i
].state
= GIT_CP_WORKING
;
1711 pp
->pfd
[i
].fd
= pp
->children
[i
].process
.err
;
1715 static void pp_buffer_stderr(struct parallel_processes
*pp
, int output_timeout
)
1719 while ((i
= poll(pp
->pfd
, pp
->max_processes
, output_timeout
)) < 0) {
1726 /* Buffer output from all pipes. */
1727 for (i
= 0; i
< pp
->max_processes
; i
++) {
1728 if (pp
->children
[i
].state
== GIT_CP_WORKING
&&
1729 pp
->pfd
[i
].revents
& (POLLIN
| POLLHUP
)) {
1730 int n
= strbuf_read_once(&pp
->children
[i
].err
,
1731 pp
->children
[i
].process
.err
, 0);
1733 close(pp
->children
[i
].process
.err
);
1734 pp
->children
[i
].state
= GIT_CP_WAIT_CLEANUP
;
1736 if (errno
!= EAGAIN
)
1742 static void pp_output(struct parallel_processes
*pp
)
1744 int i
= pp
->output_owner
;
1745 if (pp
->children
[i
].state
== GIT_CP_WORKING
&&
1746 pp
->children
[i
].err
.len
) {
1747 strbuf_write(&pp
->children
[i
].err
, stderr
);
1748 strbuf_reset(&pp
->children
[i
].err
);
1752 static int pp_collect_finished(struct parallel_processes
*pp
)
1755 int n
= pp
->max_processes
;
1758 while (pp
->nr_processes
> 0) {
1759 for (i
= 0; i
< pp
->max_processes
; i
++)
1760 if (pp
->children
[i
].state
== GIT_CP_WAIT_CLEANUP
)
1762 if (i
== pp
->max_processes
)
1765 code
= finish_command(&pp
->children
[i
].process
);
1767 code
= pp
->task_finished(code
,
1768 &pp
->children
[i
].err
, pp
->data
,
1769 pp
->children
[i
].data
);
1777 pp
->children
[i
].state
= GIT_CP_FREE
;
1779 child_process_init(&pp
->children
[i
].process
);
1781 if (i
!= pp
->output_owner
) {
1782 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1783 strbuf_reset(&pp
->children
[i
].err
);
1785 strbuf_write(&pp
->children
[i
].err
, stderr
);
1786 strbuf_reset(&pp
->children
[i
].err
);
1788 /* Output all other finished child processes */
1789 strbuf_write(&pp
->buffered_output
, stderr
);
1790 strbuf_reset(&pp
->buffered_output
);
1793 * Pick next process to output live.
1795 * For now we pick it randomly by doing a round
1796 * robin. Later we may want to pick the one with
1797 * the most output or the longest or shortest
1798 * running process time.
1800 for (i
= 0; i
< n
; i
++)
1801 if (pp
->children
[(pp
->output_owner
+ i
) % n
].state
== GIT_CP_WORKING
)
1803 pp
->output_owner
= (pp
->output_owner
+ i
) % n
;
1809 int run_processes_parallel(int n
,
1810 get_next_task_fn get_next_task
,
1811 start_failure_fn start_failure
,
1812 task_finished_fn task_finished
,
1816 int output_timeout
= 100;
1818 struct parallel_processes pp
;
1820 pp_init(&pp
, n
, get_next_task
, start_failure
, task_finished
, pp_cb
);
1823 i
< spawn_cap
&& !pp
.shutdown
&&
1824 pp
.nr_processes
< pp
.max_processes
;
1826 code
= pp_start_one(&pp
);
1831 kill_children(&pp
, -code
);
1835 if (!pp
.nr_processes
)
1837 pp_buffer_stderr(&pp
, output_timeout
);
1839 code
= pp_collect_finished(&pp
);
1843 kill_children(&pp
, -code
);
1851 int run_processes_parallel_tr2(int n
, get_next_task_fn get_next_task
,
1852 start_failure_fn start_failure
,
1853 task_finished_fn task_finished
, void *pp_cb
,
1854 const char *tr2_category
, const char *tr2_label
)
1858 trace2_region_enter_printf(tr2_category
, tr2_label
, NULL
, "max:%d",
1859 ((n
< 1) ? online_cpus() : n
));
1861 result
= run_processes_parallel(n
, get_next_task
, start_failure
,
1862 task_finished
, pp_cb
);
1864 trace2_region_leave(tr2_category
, tr2_label
, NULL
);