2 #include "run-command.h"
6 #include "thread-utils.h"
8 #include "string-list.h"
14 void child_process_init(struct child_process
*child
)
16 struct child_process blank
= CHILD_PROCESS_INIT
;
17 memcpy(child
, &blank
, sizeof(*child
));
20 void child_process_clear(struct child_process
*child
)
22 strvec_clear(&child
->args
);
23 strvec_clear(&child
->env_array
);
26 struct child_to_clean
{
28 struct child_process
*process
;
29 struct child_to_clean
*next
;
31 static struct child_to_clean
*children_to_clean
;
32 static int installed_child_cleanup_handler
;
34 static void cleanup_children(int sig
, int in_signal
)
36 struct child_to_clean
*children_to_wait_for
= NULL
;
38 while (children_to_clean
) {
39 struct child_to_clean
*p
= children_to_clean
;
40 children_to_clean
= p
->next
;
42 if (p
->process
&& !in_signal
) {
43 struct child_process
*process
= p
->process
;
44 if (process
->clean_on_exit_handler
) {
46 "trace: run_command: running exit handler for pid %"
47 PRIuMAX
, (uintmax_t)p
->pid
49 process
->clean_on_exit_handler(process
);
55 if (p
->process
&& p
->process
->wait_after_clean
) {
56 p
->next
= children_to_wait_for
;
57 children_to_wait_for
= p
;
64 while (children_to_wait_for
) {
65 struct child_to_clean
*p
= children_to_wait_for
;
66 children_to_wait_for
= p
->next
;
68 while (waitpid(p
->pid
, NULL
, 0) < 0 && errno
== EINTR
)
69 ; /* spin waiting for process exit or error */
76 static void cleanup_children_on_signal(int sig
)
78 cleanup_children(sig
, 1);
83 static void cleanup_children_on_exit(void)
85 cleanup_children(SIGTERM
, 0);
88 static void mark_child_for_cleanup(pid_t pid
, struct child_process
*process
)
90 struct child_to_clean
*p
= xmalloc(sizeof(*p
));
93 p
->next
= children_to_clean
;
94 children_to_clean
= p
;
96 if (!installed_child_cleanup_handler
) {
97 atexit(cleanup_children_on_exit
);
98 sigchain_push_common(cleanup_children_on_signal
);
99 installed_child_cleanup_handler
= 1;
103 static void clear_child_for_cleanup(pid_t pid
)
105 struct child_to_clean
**pp
;
107 for (pp
= &children_to_clean
; *pp
; pp
= &(*pp
)->next
) {
108 struct child_to_clean
*clean_me
= *pp
;
110 if (clean_me
->pid
== pid
) {
111 *pp
= clean_me
->next
;
118 static inline void close_pair(int fd
[2])
124 int is_executable(const char *name
)
128 if (stat(name
, &st
) || /* stat, not lstat */
129 !S_ISREG(st
.st_mode
))
132 #if defined(GIT_WINDOWS_NATIVE)
134 * On Windows there is no executable bit. The file extension
135 * indicates whether it can be run as an executable, and Git
136 * has special-handling to detect scripts and launch them
137 * through the indicated script interpreter. We test for the
138 * file extension first because virus scanners may make
139 * it quite expensive to open many files.
141 if (ends_with(name
, ".exe"))
146 * Now that we know it does not have an executable extension,
147 * peek into the file instead.
151 int fd
= open(name
, O_RDONLY
);
152 st
.st_mode
&= ~S_IXUSR
;
154 n
= read(fd
, buf
, 2);
156 /* look for a she-bang */
157 if (!strcmp(buf
, "#!"))
158 st
.st_mode
|= S_IXUSR
;
163 return st
.st_mode
& S_IXUSR
;
167 * Search $PATH for a command. This emulates the path search that
168 * execvp would perform, without actually executing the command so it
169 * can be used before fork() to prepare to run a command using
170 * execve() or after execvp() to diagnose why it failed.
172 * The caller should ensure that file contains no directory
175 * Returns the path to the command, as found in $PATH or NULL if the
176 * command could not be found. The caller inherits ownership of the memory
177 * used to store the resultant path.
179 * This should not be used on Windows, where the $PATH search rules
180 * are more complicated (e.g., a search for "foo" should find
183 static char *locate_in_PATH(const char *file
)
185 const char *p
= getenv("PATH");
186 struct strbuf buf
= STRBUF_INIT
;
192 const char *end
= strchrnul(p
, ':');
196 /* POSIX specifies an empty entry as the current directory. */
198 strbuf_add(&buf
, p
, end
- p
);
199 strbuf_addch(&buf
, '/');
201 strbuf_addstr(&buf
, file
);
203 if (is_executable(buf
.buf
))
204 return strbuf_detach(&buf
, NULL
);
211 strbuf_release(&buf
);
215 int exists_in_PATH(const char *command
)
217 char *r
= locate_in_PATH(command
);
218 int found
= r
!= NULL
;
223 int sane_execvp(const char *file
, char * const argv
[])
225 #ifndef GIT_WINDOWS_NATIVE
227 * execvp() doesn't return, so we all we can do is tell trace2
228 * what we are about to do and let it leave a hint in the log
229 * (unless of course the execvp() fails).
231 * we skip this for Windows because the compat layer already
232 * has to emulate the execvp() call anyway.
234 int exec_id
= trace2_exec(file
, (const char **)argv
);
237 if (!execvp(file
, argv
))
238 return 0; /* cannot happen ;-) */
240 #ifndef GIT_WINDOWS_NATIVE
243 trace2_exec_result(exec_id
, ec
);
249 * When a command can't be found because one of the directories
250 * listed in $PATH is unsearchable, execvp reports EACCES, but
251 * careful usability testing (read: analysis of occasional bug
252 * reports) reveals that "No such file or directory" is more
255 * We avoid commands with "/", because execvp will not do $PATH
256 * lookups in that case.
258 * The reassignment of EACCES to errno looks like a no-op below,
259 * but we need to protect against exists_in_PATH overwriting errno.
261 if (errno
== EACCES
&& !strchr(file
, '/'))
262 errno
= exists_in_PATH(file
) ? EACCES
: ENOENT
;
263 else if (errno
== ENOTDIR
&& !strchr(file
, '/'))
268 static const char **prepare_shell_cmd(struct strvec
*out
, const char **argv
)
271 BUG("shell command is empty");
273 if (strcspn(argv
[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv
[0])) {
274 #ifndef GIT_WINDOWS_NATIVE
275 strvec_push(out
, SHELL_PATH
);
277 strvec_push(out
, "sh");
279 strvec_push(out
, "-c");
282 * If we have no extra arguments, we do not even need to
283 * bother with the "$@" magic.
286 strvec_push(out
, argv
[0]);
288 strvec_pushf(out
, "%s \"$@\"", argv
[0]);
291 strvec_pushv(out
, argv
);
295 #ifndef GIT_WINDOWS_NATIVE
296 static int child_notifier
= -1;
302 CHILD_ERR_SIGPROCMASK
,
309 enum child_errcode err
;
310 int syserr
; /* errno */
313 static void child_die(enum child_errcode err
)
315 struct child_err buf
;
320 /* write(2) on buf smaller than PIPE_BUF (min 512) is atomic: */
321 xwrite(child_notifier
, &buf
, sizeof(buf
));
325 static void child_dup2(int fd
, int to
)
327 if (dup2(fd
, to
) < 0)
328 child_die(CHILD_ERR_DUP2
);
331 static void child_close(int fd
)
334 child_die(CHILD_ERR_CLOSE
);
337 static void child_close_pair(int fd
[2])
344 * parent will make it look like the child spewed a fatal error and died
345 * this is needed to prevent changes to t0061.
347 static void fake_fatal(const char *err
, va_list params
)
349 vreportf("fatal: ", err
, params
);
352 static void child_error_fn(const char *err
, va_list params
)
354 const char msg
[] = "error() should not be called in child\n";
355 xwrite(2, msg
, sizeof(msg
) - 1);
358 static void child_warn_fn(const char *err
, va_list params
)
360 const char msg
[] = "warn() should not be called in child\n";
361 xwrite(2, msg
, sizeof(msg
) - 1);
364 static void NORETURN
child_die_fn(const char *err
, va_list params
)
366 const char msg
[] = "die() should not be called in child\n";
367 xwrite(2, msg
, sizeof(msg
) - 1);
371 /* this runs in the parent process */
372 static void child_err_spew(struct child_process
*cmd
, struct child_err
*cerr
)
374 static void (*old_errfn
)(const char *err
, va_list params
);
376 old_errfn
= get_error_routine();
377 set_error_routine(fake_fatal
);
378 errno
= cerr
->syserr
;
381 case CHILD_ERR_CHDIR
:
382 error_errno("exec '%s': cd to '%s' failed",
383 cmd
->args
.v
[0], cmd
->dir
);
386 error_errno("dup2() in child failed");
388 case CHILD_ERR_CLOSE
:
389 error_errno("close() in child failed");
391 case CHILD_ERR_SIGPROCMASK
:
392 error_errno("sigprocmask failed restoring signals");
394 case CHILD_ERR_ENOENT
:
395 error_errno("cannot run %s", cmd
->args
.v
[0]);
397 case CHILD_ERR_SILENT
:
399 case CHILD_ERR_ERRNO
:
400 error_errno("cannot exec '%s'", cmd
->args
.v
[0]);
403 set_error_routine(old_errfn
);
406 static int prepare_cmd(struct strvec
*out
, const struct child_process
*cmd
)
409 BUG("command is empty");
412 * Add SHELL_PATH so in the event exec fails with ENOEXEC we can
413 * attempt to interpret the command with 'sh'.
415 strvec_push(out
, SHELL_PATH
);
418 prepare_git_cmd(out
, cmd
->args
.v
);
419 } else if (cmd
->use_shell
) {
420 prepare_shell_cmd(out
, cmd
->args
.v
);
422 strvec_pushv(out
, cmd
->args
.v
);
426 * If there are no dir separator characters in the command then perform
427 * a path lookup and use the resolved path as the command to exec. If
428 * there are dir separator characters, we have exec attempt to invoke
429 * the command directly.
431 if (!has_dir_sep(out
->v
[1])) {
432 char *program
= locate_in_PATH(out
->v
[1]);
434 free((char *)out
->v
[1]);
446 static char **prep_childenv(const char *const *deltaenv
)
448 extern char **environ
;
450 struct string_list env
= STRING_LIST_INIT_DUP
;
451 struct strbuf key
= STRBUF_INIT
;
452 const char *const *p
;
455 /* Construct a sorted string list consisting of the current environ */
456 for (p
= (const char *const *) environ
; p
&& *p
; p
++) {
457 const char *equals
= strchr(*p
, '=');
461 strbuf_add(&key
, *p
, equals
- *p
);
462 string_list_append(&env
, key
.buf
)->util
= (void *) *p
;
464 string_list_append(&env
, *p
)->util
= (void *) *p
;
467 string_list_sort(&env
);
469 /* Merge in 'deltaenv' with the current environ */
470 for (p
= deltaenv
; p
&& *p
; p
++) {
471 const char *equals
= strchr(*p
, '=');
474 /* ('key=value'), insert or replace entry */
476 strbuf_add(&key
, *p
, equals
- *p
);
477 string_list_insert(&env
, key
.buf
)->util
= (void *) *p
;
479 /* otherwise ('key') remove existing entry */
480 string_list_remove(&env
, *p
, 0);
484 /* Create an array of 'char *' to be used as the childenv */
485 ALLOC_ARRAY(childenv
, env
.nr
+ 1);
486 for (i
= 0; i
< env
.nr
; i
++)
487 childenv
[i
] = env
.items
[i
].util
;
488 childenv
[env
.nr
] = NULL
;
490 string_list_clear(&env
, 0);
491 strbuf_release(&key
);
495 struct atfork_state
{
502 #define CHECK_BUG(err, msg) \
506 BUG("%s: %s", msg, strerror(e)); \
509 static void atfork_prepare(struct atfork_state
*as
)
513 if (sigfillset(&all
))
514 die_errno("sigfillset");
516 if (sigprocmask(SIG_SETMASK
, &all
, &as
->old
))
517 die_errno("sigprocmask");
519 CHECK_BUG(pthread_sigmask(SIG_SETMASK
, &all
, &as
->old
),
520 "blocking all signals");
521 CHECK_BUG(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
, &as
->cs
),
522 "disabling cancellation");
526 static void atfork_parent(struct atfork_state
*as
)
529 if (sigprocmask(SIG_SETMASK
, &as
->old
, NULL
))
530 die_errno("sigprocmask");
532 CHECK_BUG(pthread_setcancelstate(as
->cs
, NULL
),
533 "re-enabling cancellation");
534 CHECK_BUG(pthread_sigmask(SIG_SETMASK
, &as
->old
, NULL
),
535 "restoring signal mask");
538 #endif /* GIT_WINDOWS_NATIVE */
540 static inline void set_cloexec(int fd
)
542 int flags
= fcntl(fd
, F_GETFD
);
544 fcntl(fd
, F_SETFD
, flags
| FD_CLOEXEC
);
547 static int wait_or_whine(pid_t pid
, const char *argv0
, int in_signal
)
549 int status
, code
= -1;
551 int failed_errno
= 0;
553 while ((waiting
= waitpid(pid
, &status
, 0)) < 0 && errno
== EINTR
)
556 if (WIFEXITED(status
))
557 code
= WEXITSTATUS(status
);
562 failed_errno
= errno
;
563 error_errno("waitpid for %s failed", argv0
);
564 } else if (waiting
!= pid
) {
565 error("waitpid is confused (%s)", argv0
);
566 } else if (WIFSIGNALED(status
)) {
567 code
= WTERMSIG(status
);
568 if (code
!= SIGINT
&& code
!= SIGQUIT
&& code
!= SIGPIPE
)
569 error("%s died of signal %d", argv0
, code
);
571 * This return value is chosen so that code & 0xff
572 * mimics the exit code that a POSIX shell would report for
573 * a program that died from this signal.
576 } else if (WIFEXITED(status
)) {
577 code
= WEXITSTATUS(status
);
579 error("waitpid is confused (%s)", argv0
);
582 clear_child_for_cleanup(pid
);
584 errno
= failed_errno
;
588 static void trace_add_env(struct strbuf
*dst
, const char *const *deltaenv
)
590 struct string_list envs
= STRING_LIST_INIT_DUP
;
591 const char *const *e
;
593 int printed_unset
= 0;
595 /* Last one wins, see run-command.c:prep_childenv() for context */
596 for (e
= deltaenv
; e
&& *e
; e
++) {
597 struct strbuf key
= STRBUF_INIT
;
598 char *equals
= strchr(*e
, '=');
601 strbuf_add(&key
, *e
, equals
- *e
);
602 string_list_insert(&envs
, key
.buf
)->util
= equals
+ 1;
604 string_list_insert(&envs
, *e
)->util
= NULL
;
606 strbuf_release(&key
);
609 /* "unset X Y...;" */
610 for (i
= 0; i
< envs
.nr
; i
++) {
611 const char *var
= envs
.items
[i
].string
;
612 const char *val
= envs
.items
[i
].util
;
614 if (val
|| !getenv(var
))
617 if (!printed_unset
) {
618 strbuf_addstr(dst
, " unset");
621 strbuf_addf(dst
, " %s", var
);
624 strbuf_addch(dst
, ';');
626 /* ... followed by "A=B C=D ..." */
627 for (i
= 0; i
< envs
.nr
; i
++) {
628 const char *var
= envs
.items
[i
].string
;
629 const char *val
= envs
.items
[i
].util
;
635 oldval
= getenv(var
);
636 if (oldval
&& !strcmp(val
, oldval
))
639 strbuf_addf(dst
, " %s=", var
);
640 sq_quote_buf_pretty(dst
, val
);
642 string_list_clear(&envs
, 0);
645 static void trace_run_command(const struct child_process
*cp
)
647 struct strbuf buf
= STRBUF_INIT
;
649 if (!trace_want(&trace_default_key
))
652 strbuf_addstr(&buf
, "trace: run_command:");
654 strbuf_addstr(&buf
, " cd ");
655 sq_quote_buf_pretty(&buf
, cp
->dir
);
656 strbuf_addch(&buf
, ';');
658 trace_add_env(&buf
, cp
->env_array
.v
);
660 strbuf_addstr(&buf
, " git");
661 sq_quote_argv_pretty(&buf
, cp
->args
.v
);
663 trace_printf("%s", buf
.buf
);
664 strbuf_release(&buf
);
667 int start_command(struct child_process
*cmd
)
669 int need_in
, need_out
, need_err
;
670 int fdin
[2], fdout
[2], fderr
[2];
675 * In case of errors we must keep the promise to close FDs
676 * that have been passed in via ->in and ->out.
679 need_in
= !cmd
->no_stdin
&& cmd
->in
< 0;
681 if (pipe(fdin
) < 0) {
682 failed_errno
= errno
;
685 str
= "standard input";
691 need_out
= !cmd
->no_stdout
692 && !cmd
->stdout_to_stderr
695 if (pipe(fdout
) < 0) {
696 failed_errno
= errno
;
701 str
= "standard output";
707 need_err
= !cmd
->no_stderr
&& cmd
->err
< 0;
709 if (pipe(fderr
) < 0) {
710 failed_errno
= errno
;
719 str
= "standard error";
721 error("cannot create %s pipe for %s: %s",
722 str
, cmd
->args
.v
[0], strerror(failed_errno
));
723 child_process_clear(cmd
);
724 errno
= failed_errno
;
730 trace2_child_start(cmd
);
731 trace_run_command(cmd
);
735 if (cmd
->close_object_store
)
736 close_object_store(the_repository
->objects
);
738 #ifndef GIT_WINDOWS_NATIVE
743 struct strvec argv
= STRVEC_INIT
;
744 struct child_err cerr
;
745 struct atfork_state as
;
747 if (prepare_cmd(&argv
, cmd
) < 0) {
748 failed_errno
= errno
;
750 if (!cmd
->silent_exec_failure
)
751 error_errno("cannot run %s", cmd
->args
.v
[0]);
755 if (pipe(notify_pipe
))
756 notify_pipe
[0] = notify_pipe
[1] = -1;
758 if (cmd
->no_stdin
|| cmd
->no_stdout
|| cmd
->no_stderr
) {
759 null_fd
= xopen("/dev/null", O_RDWR
| O_CLOEXEC
);
760 set_cloexec(null_fd
);
763 childenv
= prep_childenv(cmd
->env_array
.v
);
767 * NOTE: In order to prevent deadlocking when using threads special
768 * care should be taken with the function calls made in between the
769 * fork() and exec() calls. No calls should be made to functions which
770 * require acquiring a lock (e.g. malloc) as the lock could have been
771 * held by another thread at the time of forking, causing the lock to
772 * never be released in the child process. This means only
773 * Async-Signal-Safe functions are permitted in the child.
776 failed_errno
= errno
;
780 * Ensure the default die/error/warn routines do not get
781 * called, they can take stdio locks and malloc.
783 set_die_routine(child_die_fn
);
784 set_error_routine(child_error_fn
);
785 set_warn_routine(child_warn_fn
);
787 close(notify_pipe
[0]);
788 set_cloexec(notify_pipe
[1]);
789 child_notifier
= notify_pipe
[1];
792 child_dup2(null_fd
, 0);
794 child_dup2(fdin
[0], 0);
795 child_close_pair(fdin
);
796 } else if (cmd
->in
) {
797 child_dup2(cmd
->in
, 0);
798 child_close(cmd
->in
);
802 child_dup2(null_fd
, 2);
804 child_dup2(fderr
[1], 2);
805 child_close_pair(fderr
);
806 } else if (cmd
->err
> 1) {
807 child_dup2(cmd
->err
, 2);
808 child_close(cmd
->err
);
812 child_dup2(null_fd
, 1);
813 else if (cmd
->stdout_to_stderr
)
816 child_dup2(fdout
[1], 1);
817 child_close_pair(fdout
);
818 } else if (cmd
->out
> 1) {
819 child_dup2(cmd
->out
, 1);
820 child_close(cmd
->out
);
823 if (cmd
->dir
&& chdir(cmd
->dir
))
824 child_die(CHILD_ERR_CHDIR
);
827 * restore default signal handlers here, in case
828 * we catch a signal right before execve below
830 for (sig
= 1; sig
< NSIG
; sig
++) {
831 /* ignored signals get reset to SIG_DFL on execve */
832 if (signal(sig
, SIG_DFL
) == SIG_IGN
)
833 signal(sig
, SIG_IGN
);
836 if (sigprocmask(SIG_SETMASK
, &as
.old
, NULL
) != 0)
837 child_die(CHILD_ERR_SIGPROCMASK
);
840 * Attempt to exec using the command and arguments starting at
841 * argv.argv[1]. argv.argv[0] contains SHELL_PATH which will
842 * be used in the event exec failed with ENOEXEC at which point
843 * we will try to interpret the command using 'sh'.
845 execve(argv
.v
[1], (char *const *) argv
.v
+ 1,
846 (char *const *) childenv
);
847 if (errno
== ENOEXEC
)
848 execve(argv
.v
[0], (char *const *) argv
.v
,
849 (char *const *) childenv
);
851 if (errno
== ENOENT
) {
852 if (cmd
->silent_exec_failure
)
853 child_die(CHILD_ERR_SILENT
);
854 child_die(CHILD_ERR_ENOENT
);
856 child_die(CHILD_ERR_ERRNO
);
861 error_errno("cannot fork() for %s", cmd
->args
.v
[0]);
862 else if (cmd
->clean_on_exit
)
863 mark_child_for_cleanup(cmd
->pid
, cmd
);
866 * Wait for child's exec. If the exec succeeds (or if fork()
867 * failed), EOF is seen immediately by the parent. Otherwise, the
868 * child process sends a child_err struct.
869 * Note that use of this infrastructure is completely advisory,
870 * therefore, we keep error checks minimal.
872 close(notify_pipe
[1]);
873 if (xread(notify_pipe
[0], &cerr
, sizeof(cerr
)) == sizeof(cerr
)) {
875 * At this point we know that fork() succeeded, but exec()
876 * failed. Errors have been reported to our stderr.
878 wait_or_whine(cmd
->pid
, cmd
->args
.v
[0], 0);
879 child_err_spew(cmd
, &cerr
);
880 failed_errno
= errno
;
883 close(notify_pipe
[0]);
894 int fhin
= 0, fhout
= 1, fherr
= 2;
895 const char **sargv
= cmd
->args
.v
;
896 struct strvec nargv
= STRVEC_INIT
;
899 fhin
= open("/dev/null", O_RDWR
);
906 fherr
= open("/dev/null", O_RDWR
);
908 fherr
= dup(fderr
[1]);
909 else if (cmd
->err
> 2)
910 fherr
= dup(cmd
->err
);
913 fhout
= open("/dev/null", O_RDWR
);
914 else if (cmd
->stdout_to_stderr
)
917 fhout
= dup(fdout
[1]);
918 else if (cmd
->out
> 1)
919 fhout
= dup(cmd
->out
);
922 cmd
->args
.v
= prepare_git_cmd(&nargv
, sargv
);
923 else if (cmd
->use_shell
)
924 cmd
->args
.v
= prepare_shell_cmd(&nargv
, sargv
);
926 cmd
->pid
= mingw_spawnvpe(cmd
->args
.v
[0], cmd
->args
.v
, (char**) cmd
->env_array
.v
,
927 cmd
->dir
, fhin
, fhout
, fherr
);
928 failed_errno
= errno
;
929 if (cmd
->pid
< 0 && (!cmd
->silent_exec_failure
|| errno
!= ENOENT
))
930 error_errno("cannot spawn %s", cmd
->args
.v
[0]);
931 if (cmd
->clean_on_exit
&& cmd
->pid
>= 0)
932 mark_child_for_cleanup(cmd
->pid
, cmd
);
934 strvec_clear(&nargv
);
946 trace2_child_exit(cmd
, -1);
960 child_process_clear(cmd
);
961 errno
= failed_errno
;
983 int finish_command(struct child_process
*cmd
)
985 int ret
= wait_or_whine(cmd
->pid
, cmd
->args
.v
[0], 0);
986 trace2_child_exit(cmd
, ret
);
987 child_process_clear(cmd
);
988 invalidate_lstat_cache();
992 int finish_command_in_signal(struct child_process
*cmd
)
994 int ret
= wait_or_whine(cmd
->pid
, cmd
->args
.v
[0], 1);
995 trace2_child_exit(cmd
, ret
);
1000 int run_command(struct child_process
*cmd
)
1004 if (cmd
->out
< 0 || cmd
->err
< 0)
1005 BUG("run_command with a pipe can cause deadlock");
1007 code
= start_command(cmd
);
1010 return finish_command(cmd
);
1013 int run_command_v_opt(const char **argv
, int opt
)
1015 return run_command_v_opt_cd_env(argv
, opt
, NULL
, NULL
);
1018 int run_command_v_opt_tr2(const char **argv
, int opt
, const char *tr2_class
)
1020 return run_command_v_opt_cd_env_tr2(argv
, opt
, NULL
, NULL
, tr2_class
);
1023 int run_command_v_opt_cd_env(const char **argv
, int opt
, const char *dir
, const char *const *env
)
1025 return run_command_v_opt_cd_env_tr2(argv
, opt
, dir
, env
, NULL
);
1028 int run_command_v_opt_cd_env_tr2(const char **argv
, int opt
, const char *dir
,
1029 const char *const *env
, const char *tr2_class
)
1031 struct child_process cmd
= CHILD_PROCESS_INIT
;
1032 strvec_pushv(&cmd
.args
, argv
);
1033 cmd
.no_stdin
= opt
& RUN_COMMAND_NO_STDIN
? 1 : 0;
1034 cmd
.git_cmd
= opt
& RUN_GIT_CMD
? 1 : 0;
1035 cmd
.stdout_to_stderr
= opt
& RUN_COMMAND_STDOUT_TO_STDERR
? 1 : 0;
1036 cmd
.silent_exec_failure
= opt
& RUN_SILENT_EXEC_FAILURE
? 1 : 0;
1037 cmd
.use_shell
= opt
& RUN_USING_SHELL
? 1 : 0;
1038 cmd
.clean_on_exit
= opt
& RUN_CLEAN_ON_EXIT
? 1 : 0;
1039 cmd
.wait_after_clean
= opt
& RUN_WAIT_AFTER_CLEAN
? 1 : 0;
1040 cmd
.close_object_store
= opt
& RUN_CLOSE_OBJECT_STORE
? 1 : 0;
1043 strvec_pushv(&cmd
.env_array
, (const char **)env
);
1044 cmd
.trace2_child_class
= tr2_class
;
1045 return run_command(&cmd
);
1049 static pthread_t main_thread
;
1050 static int main_thread_set
;
1051 static pthread_key_t async_key
;
1052 static pthread_key_t async_die_counter
;
1054 static void *run_thread(void *data
)
1056 struct async
*async
= data
;
1059 if (async
->isolate_sigpipe
) {
1062 sigaddset(&mask
, SIGPIPE
);
1063 if (pthread_sigmask(SIG_BLOCK
, &mask
, NULL
) < 0) {
1064 ret
= error("unable to block SIGPIPE in async thread");
1069 pthread_setspecific(async_key
, async
);
1070 ret
= async
->proc(async
->proc_in
, async
->proc_out
, async
->data
);
1074 static NORETURN
void die_async(const char *err
, va_list params
)
1076 vreportf("fatal: ", err
, params
);
1079 struct async
*async
= pthread_getspecific(async_key
);
1080 if (async
->proc_in
>= 0)
1081 close(async
->proc_in
);
1082 if (async
->proc_out
>= 0)
1083 close(async
->proc_out
);
1084 pthread_exit((void *)128);
1090 static int async_die_is_recursing(void)
1092 void *ret
= pthread_getspecific(async_die_counter
);
1093 pthread_setspecific(async_die_counter
, &async_die_counter
); /* set to any non-NULL valid pointer */
1099 if (!main_thread_set
)
1100 return 0; /* no asyncs started yet */
1101 return !pthread_equal(main_thread
, pthread_self());
1104 static void NORETURN
async_exit(int code
)
1106 pthread_exit((void *)(intptr_t)code
);
1112 void (**handlers
)(void);
1117 static int git_atexit_installed
;
1119 static void git_atexit_dispatch(void)
1123 for (i
=git_atexit_hdlrs
.nr
; i
; i
--)
1124 git_atexit_hdlrs
.handlers
[i
-1]();
1127 static void git_atexit_clear(void)
1129 free(git_atexit_hdlrs
.handlers
);
1130 memset(&git_atexit_hdlrs
, 0, sizeof(git_atexit_hdlrs
));
1131 git_atexit_installed
= 0;
1135 int git_atexit(void (*handler
)(void))
1137 ALLOC_GROW(git_atexit_hdlrs
.handlers
, git_atexit_hdlrs
.nr
+ 1, git_atexit_hdlrs
.alloc
);
1138 git_atexit_hdlrs
.handlers
[git_atexit_hdlrs
.nr
++] = handler
;
1139 if (!git_atexit_installed
) {
1140 if (atexit(&git_atexit_dispatch
))
1142 git_atexit_installed
= 1;
1146 #define atexit git_atexit
1148 static int process_is_async
;
1151 return process_is_async
;
1154 static void NORETURN
async_exit(int code
)
1161 void check_pipe(int err
)
1167 signal(SIGPIPE
, SIG_DFL
);
1169 /* Should never happen, but just in case... */
1174 int start_async(struct async
*async
)
1176 int need_in
, need_out
;
1177 int fdin
[2], fdout
[2];
1178 int proc_in
, proc_out
;
1180 need_in
= async
->in
< 0;
1182 if (pipe(fdin
) < 0) {
1185 return error_errno("cannot create pipe");
1187 async
->in
= fdin
[1];
1190 need_out
= async
->out
< 0;
1192 if (pipe(fdout
) < 0) {
1197 return error_errno("cannot create pipe");
1199 async
->out
= fdout
[0];
1205 proc_in
= async
->in
;
1210 proc_out
= fdout
[1];
1211 else if (async
->out
)
1212 proc_out
= async
->out
;
1217 /* Flush stdio before fork() to avoid cloning buffers */
1220 async
->pid
= fork();
1221 if (async
->pid
< 0) {
1222 error_errno("fork (async) failed");
1231 process_is_async
= 1;
1232 exit(!!async
->proc(proc_in
, proc_out
, async
->data
));
1235 mark_child_for_cleanup(async
->pid
, NULL
);
1244 else if (async
->out
)
1247 if (!main_thread_set
) {
1249 * We assume that the first time that start_async is called
1250 * it is from the main thread.
1252 main_thread_set
= 1;
1253 main_thread
= pthread_self();
1254 pthread_key_create(&async_key
, NULL
);
1255 pthread_key_create(&async_die_counter
, NULL
);
1256 set_die_routine(die_async
);
1257 set_die_is_recursing_routine(async_die_is_recursing
);
1261 set_cloexec(proc_in
);
1263 set_cloexec(proc_out
);
1264 async
->proc_in
= proc_in
;
1265 async
->proc_out
= proc_out
;
1267 int err
= pthread_create(&async
->tid
, NULL
, run_thread
, async
);
1269 error(_("cannot create async thread: %s"), strerror(err
));
1284 else if (async
->out
)
1289 int finish_async(struct async
*async
)
1292 int ret
= wait_or_whine(async
->pid
, "child process", 0);
1294 invalidate_lstat_cache();
1298 void *ret
= (void *)(intptr_t)(-1);
1300 if (pthread_join(async
->tid
, &ret
))
1301 error("pthread_join failed");
1302 invalidate_lstat_cache();
1303 return (int)(intptr_t)ret
;
1308 int async_with_fork(void)
1317 int run_hook_ve(const char *const *env
, const char *name
, va_list args
)
1319 struct child_process hook
= CHILD_PROCESS_INIT
;
1322 p
= find_hook(name
);
1326 strvec_push(&hook
.args
, p
);
1327 while ((p
= va_arg(args
, const char *)))
1328 strvec_push(&hook
.args
, p
);
1330 strvec_pushv(&hook
.env_array
, (const char **)env
);
1332 hook
.stdout_to_stderr
= 1;
1333 hook
.trace2_hook_name
= name
;
1335 return run_command(&hook
);
1338 int run_hook_le(const char *const *env
, const char *name
, ...)
1343 va_start(args
, name
);
1344 ret
= run_hook_ve(env
, name
, args
);
1351 /* initialized by caller */
1353 int type
; /* POLLOUT or POLLIN */
1365 /* returned by pump_io */
1366 int error
; /* 0 for success, otherwise errno */
1372 static int pump_io_round(struct io_pump
*slots
, int nr
, struct pollfd
*pfd
)
1377 for (i
= 0; i
< nr
; i
++) {
1378 struct io_pump
*io
= &slots
[i
];
1381 pfd
[pollsize
].fd
= io
->fd
;
1382 pfd
[pollsize
].events
= io
->type
;
1383 io
->pfd
= &pfd
[pollsize
++];
1389 if (poll(pfd
, pollsize
, -1) < 0) {
1392 die_errno("poll failed");
1395 for (i
= 0; i
< nr
; i
++) {
1396 struct io_pump
*io
= &slots
[i
];
1401 if (!(io
->pfd
->revents
& (POLLOUT
|POLLIN
|POLLHUP
|POLLERR
|POLLNVAL
)))
1404 if (io
->type
== POLLOUT
) {
1405 ssize_t len
= xwrite(io
->fd
,
1406 io
->u
.out
.buf
, io
->u
.out
.len
);
1412 io
->u
.out
.buf
+= len
;
1413 io
->u
.out
.len
-= len
;
1414 if (!io
->u
.out
.len
) {
1421 if (io
->type
== POLLIN
) {
1422 ssize_t len
= strbuf_read_once(io
->u
.in
.buf
,
1423 io
->fd
, io
->u
.in
.hint
);
1436 static int pump_io(struct io_pump
*slots
, int nr
)
1441 for (i
= 0; i
< nr
; i
++)
1444 ALLOC_ARRAY(pfd
, nr
);
1445 while (pump_io_round(slots
, nr
, pfd
))
1449 /* There may be multiple errno values, so just pick the first. */
1450 for (i
= 0; i
< nr
; i
++) {
1451 if (slots
[i
].error
) {
1452 errno
= slots
[i
].error
;
1460 int pipe_command(struct child_process
*cmd
,
1461 const char *in
, size_t in_len
,
1462 struct strbuf
*out
, size_t out_hint
,
1463 struct strbuf
*err
, size_t err_hint
)
1465 struct io_pump io
[3];
1475 if (start_command(cmd
) < 0)
1479 io
[nr
].fd
= cmd
->in
;
1480 io
[nr
].type
= POLLOUT
;
1481 io
[nr
].u
.out
.buf
= in
;
1482 io
[nr
].u
.out
.len
= in_len
;
1486 io
[nr
].fd
= cmd
->out
;
1487 io
[nr
].type
= POLLIN
;
1488 io
[nr
].u
.in
.buf
= out
;
1489 io
[nr
].u
.in
.hint
= out_hint
;
1493 io
[nr
].fd
= cmd
->err
;
1494 io
[nr
].type
= POLLIN
;
1495 io
[nr
].u
.in
.buf
= err
;
1496 io
[nr
].u
.in
.hint
= err_hint
;
1500 if (pump_io(io
, nr
) < 0) {
1501 finish_command(cmd
); /* throw away exit code */
1505 return finish_command(cmd
);
1511 GIT_CP_WAIT_CLEANUP
,
1514 struct parallel_processes
{
1520 get_next_task_fn get_next_task
;
1521 start_failure_fn start_failure
;
1522 task_finished_fn task_finished
;
1525 enum child_state state
;
1526 struct child_process process
;
1531 * The struct pollfd is logically part of *children,
1532 * but the system call expects it as its own array.
1536 unsigned shutdown
: 1;
1539 struct strbuf buffered_output
; /* of finished children */
1542 static int default_start_failure(struct strbuf
*out
,
1549 static int default_task_finished(int result
,
1557 static void kill_children(struct parallel_processes
*pp
, int signo
)
1559 int i
, n
= pp
->max_processes
;
1561 for (i
= 0; i
< n
; i
++)
1562 if (pp
->children
[i
].state
== GIT_CP_WORKING
)
1563 kill(pp
->children
[i
].process
.pid
, signo
);
1566 static struct parallel_processes
*pp_for_signal
;
1568 static void handle_children_on_signal(int signo
)
1570 kill_children(pp_for_signal
, signo
);
1571 sigchain_pop(signo
);
1575 static void pp_init(struct parallel_processes
*pp
,
1577 get_next_task_fn get_next_task
,
1578 start_failure_fn start_failure
,
1579 task_finished_fn task_finished
,
1587 pp
->max_processes
= n
;
1589 trace_printf("run_processes_parallel: preparing to run up to %d tasks", n
);
1593 BUG("you need to specify a get_next_task function");
1594 pp
->get_next_task
= get_next_task
;
1596 pp
->start_failure
= start_failure
? start_failure
: default_start_failure
;
1597 pp
->task_finished
= task_finished
? task_finished
: default_task_finished
;
1599 pp
->nr_processes
= 0;
1600 pp
->output_owner
= 0;
1602 CALLOC_ARRAY(pp
->children
, n
);
1603 CALLOC_ARRAY(pp
->pfd
, n
);
1604 strbuf_init(&pp
->buffered_output
, 0);
1606 for (i
= 0; i
< n
; i
++) {
1607 strbuf_init(&pp
->children
[i
].err
, 0);
1608 child_process_init(&pp
->children
[i
].process
);
1609 pp
->pfd
[i
].events
= POLLIN
| POLLHUP
;
1614 sigchain_push_common(handle_children_on_signal
);
1617 static void pp_cleanup(struct parallel_processes
*pp
)
1621 trace_printf("run_processes_parallel: done");
1622 for (i
= 0; i
< pp
->max_processes
; i
++) {
1623 strbuf_release(&pp
->children
[i
].err
);
1624 child_process_clear(&pp
->children
[i
].process
);
1631 * When get_next_task added messages to the buffer in its last
1632 * iteration, the buffered output is non empty.
1634 strbuf_write(&pp
->buffered_output
, stderr
);
1635 strbuf_release(&pp
->buffered_output
);
1637 sigchain_pop_common();
1641 * 0 if a new task was started.
1642 * 1 if no new jobs was started (get_next_task ran out of work, non critical
1643 * problem with starting a new command)
1644 * <0 no new job was started, user wishes to shutdown early. Use negative code
1645 * to signal the children.
1647 static int pp_start_one(struct parallel_processes
*pp
)
1651 for (i
= 0; i
< pp
->max_processes
; i
++)
1652 if (pp
->children
[i
].state
== GIT_CP_FREE
)
1654 if (i
== pp
->max_processes
)
1655 BUG("bookkeeping is hard");
1657 code
= pp
->get_next_task(&pp
->children
[i
].process
,
1658 &pp
->children
[i
].err
,
1660 &pp
->children
[i
].data
);
1662 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1663 strbuf_reset(&pp
->children
[i
].err
);
1666 pp
->children
[i
].process
.err
= -1;
1667 pp
->children
[i
].process
.stdout_to_stderr
= 1;
1668 pp
->children
[i
].process
.no_stdin
= 1;
1670 if (start_command(&pp
->children
[i
].process
)) {
1671 code
= pp
->start_failure(&pp
->children
[i
].err
,
1673 pp
->children
[i
].data
);
1674 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1675 strbuf_reset(&pp
->children
[i
].err
);
1682 pp
->children
[i
].state
= GIT_CP_WORKING
;
1683 pp
->pfd
[i
].fd
= pp
->children
[i
].process
.err
;
1687 static void pp_buffer_stderr(struct parallel_processes
*pp
, int output_timeout
)
1691 while ((i
= poll(pp
->pfd
, pp
->max_processes
, output_timeout
)) < 0) {
1698 /* Buffer output from all pipes. */
1699 for (i
= 0; i
< pp
->max_processes
; i
++) {
1700 if (pp
->children
[i
].state
== GIT_CP_WORKING
&&
1701 pp
->pfd
[i
].revents
& (POLLIN
| POLLHUP
)) {
1702 int n
= strbuf_read_once(&pp
->children
[i
].err
,
1703 pp
->children
[i
].process
.err
, 0);
1705 close(pp
->children
[i
].process
.err
);
1706 pp
->children
[i
].state
= GIT_CP_WAIT_CLEANUP
;
1708 if (errno
!= EAGAIN
)
1714 static void pp_output(struct parallel_processes
*pp
)
1716 int i
= pp
->output_owner
;
1717 if (pp
->children
[i
].state
== GIT_CP_WORKING
&&
1718 pp
->children
[i
].err
.len
) {
1719 strbuf_write(&pp
->children
[i
].err
, stderr
);
1720 strbuf_reset(&pp
->children
[i
].err
);
1724 static int pp_collect_finished(struct parallel_processes
*pp
)
1727 int n
= pp
->max_processes
;
1730 while (pp
->nr_processes
> 0) {
1731 for (i
= 0; i
< pp
->max_processes
; i
++)
1732 if (pp
->children
[i
].state
== GIT_CP_WAIT_CLEANUP
)
1734 if (i
== pp
->max_processes
)
1737 code
= finish_command(&pp
->children
[i
].process
);
1739 code
= pp
->task_finished(code
,
1740 &pp
->children
[i
].err
, pp
->data
,
1741 pp
->children
[i
].data
);
1749 pp
->children
[i
].state
= GIT_CP_FREE
;
1751 child_process_init(&pp
->children
[i
].process
);
1753 if (i
!= pp
->output_owner
) {
1754 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1755 strbuf_reset(&pp
->children
[i
].err
);
1757 strbuf_write(&pp
->children
[i
].err
, stderr
);
1758 strbuf_reset(&pp
->children
[i
].err
);
1760 /* Output all other finished child processes */
1761 strbuf_write(&pp
->buffered_output
, stderr
);
1762 strbuf_reset(&pp
->buffered_output
);
1765 * Pick next process to output live.
1767 * For now we pick it randomly by doing a round
1768 * robin. Later we may want to pick the one with
1769 * the most output or the longest or shortest
1770 * running process time.
1772 for (i
= 0; i
< n
; i
++)
1773 if (pp
->children
[(pp
->output_owner
+ i
) % n
].state
== GIT_CP_WORKING
)
1775 pp
->output_owner
= (pp
->output_owner
+ i
) % n
;
1781 int run_processes_parallel(int n
,
1782 get_next_task_fn get_next_task
,
1783 start_failure_fn start_failure
,
1784 task_finished_fn task_finished
,
1788 int output_timeout
= 100;
1790 struct parallel_processes pp
;
1792 pp_init(&pp
, n
, get_next_task
, start_failure
, task_finished
, pp_cb
);
1795 i
< spawn_cap
&& !pp
.shutdown
&&
1796 pp
.nr_processes
< pp
.max_processes
;
1798 code
= pp_start_one(&pp
);
1803 kill_children(&pp
, -code
);
1807 if (!pp
.nr_processes
)
1809 pp_buffer_stderr(&pp
, output_timeout
);
1811 code
= pp_collect_finished(&pp
);
1815 kill_children(&pp
, -code
);
1823 int run_processes_parallel_tr2(int n
, get_next_task_fn get_next_task
,
1824 start_failure_fn start_failure
,
1825 task_finished_fn task_finished
, void *pp_cb
,
1826 const char *tr2_category
, const char *tr2_label
)
1830 trace2_region_enter_printf(tr2_category
, tr2_label
, NULL
, "max:%d",
1831 ((n
< 1) ? online_cpus() : n
));
1833 result
= run_processes_parallel(n
, get_next_task
, start_failure
,
1834 task_finished
, pp_cb
);
1836 trace2_region_leave(tr2_category
, tr2_label
, NULL
);
1841 int run_auto_maintenance(int quiet
)
1844 struct child_process maint
= CHILD_PROCESS_INIT
;
1846 if (!git_config_get_bool("maintenance.auto", &enabled
) &&
1851 maint
.close_object_store
= 1;
1852 strvec_pushl(&maint
.args
, "maintenance", "run", "--auto", NULL
);
1853 strvec_push(&maint
.args
, quiet
? "--quiet" : "--no-quiet");
1855 return run_command(&maint
);
1858 void prepare_other_repo_env(struct strvec
*env_array
, const char *new_git_dir
)
1860 const char * const *var
;
1862 for (var
= local_repo_env
; *var
; var
++) {
1863 if (strcmp(*var
, CONFIG_DATA_ENVIRONMENT
) &&
1864 strcmp(*var
, CONFIG_COUNT_ENVIRONMENT
))
1865 strvec_push(env_array
, *var
);
1867 strvec_pushf(env_array
, "%s=%s", GIT_DIR_ENVIRONMENT
, new_git_dir
);
1870 enum start_bg_result
start_bg_command(struct child_process
*cmd
,
1871 start_bg_wait_cb
*wait_cb
,
1873 unsigned int timeout_sec
)
1875 enum start_bg_result sbgr
= SBGR_ERROR
;
1882 * We do not allow clean-on-exit because the child process
1883 * should persist in the background and possibly/probably
1884 * after this process exits. So we don't want to kill the
1885 * child during our atexit routine.
1887 if (cmd
->clean_on_exit
)
1888 BUG("start_bg_command() does not allow non-zero clean_on_exit");
1890 if (!cmd
->trace2_child_class
)
1891 cmd
->trace2_child_class
= "background";
1893 ret
= start_command(cmd
);
1896 * We assume that if `start_command()` fails, we
1897 * either get a complete `trace2_child_start() /
1898 * trace2_child_exit()` pair or it fails before the
1899 * `trace2_child_start()` is emitted, so we do not
1900 * need to worry about it here.
1902 * We also assume that `start_command()` does not add
1903 * us to the cleanup list. And that it calls
1904 * calls `child_process_clear()`.
1911 time_limit
+= timeout_sec
;
1914 pid_seen
= waitpid(cmd
->pid
, &wait_status
, WNOHANG
);
1918 * The child is currently running. Ask the callback
1919 * if the child is ready to do work or whether we
1920 * should keep waiting for it to boot up.
1922 ret
= (*wait_cb
)(cmd
, cb_data
);
1925 * The child is running and "ready".
1927 trace2_child_ready(cmd
, "ready");
1930 } else if (ret
> 0) {
1932 * The callback said to give it more time to boot up
1933 * (subject to our timeout limit).
1938 if (now
< time_limit
)
1942 * Our timeout has expired. We don't try to
1943 * kill the child, but rather let it continue
1944 * (hopefully) trying to startup.
1946 trace2_child_ready(cmd
, "timeout");
1947 sbgr
= SBGR_TIMEOUT
;
1951 * The cb gave up on this child. It is still running,
1952 * but our cb got an error trying to probe it.
1954 trace2_child_ready(cmd
, "error");
1955 sbgr
= SBGR_CB_ERROR
;
1960 else if (pid_seen
== cmd
->pid
) {
1961 int child_code
= -1;
1964 * The child started, but exited or was terminated
1965 * before becoming "ready".
1967 * We try to match the behavior of `wait_or_whine()`
1968 * WRT the handling of WIFSIGNALED() and WIFEXITED()
1969 * and convert the child's status to a return code for
1970 * tracing purposes and emit the `trace2_child_exit()`
1973 * We do not want the wait_or_whine() error message
1974 * because we will be called by client-side library
1977 if (WIFEXITED(wait_status
))
1978 child_code
= WEXITSTATUS(wait_status
);
1979 else if (WIFSIGNALED(wait_status
))
1980 child_code
= WTERMSIG(wait_status
) + 128;
1981 trace2_child_exit(cmd
, child_code
);
1987 else if (pid_seen
< 0 && errno
== EINTR
)
1990 trace2_child_exit(cmd
, -1);
1994 child_process_clear(cmd
);
1995 invalidate_lstat_cache();