1 #include "git-compat-util.h"
2 #include "run-command.h"
3 #include "environment.h"
9 #include "thread-utils.h"
11 #include "string-list.h"
17 #include "compat/nonblock.h"
19 void child_process_init(struct child_process
*child
)
21 struct child_process blank
= CHILD_PROCESS_INIT
;
22 memcpy(child
, &blank
, sizeof(*child
));
25 void child_process_clear(struct child_process
*child
)
27 strvec_clear(&child
->args
);
28 strvec_clear(&child
->env
);
31 struct child_to_clean
{
33 struct child_process
*process
;
34 struct child_to_clean
*next
;
36 static struct child_to_clean
*children_to_clean
;
37 static int installed_child_cleanup_handler
;
39 static void cleanup_children(int sig
, int in_signal
)
41 struct child_to_clean
*children_to_wait_for
= NULL
;
43 while (children_to_clean
) {
44 struct child_to_clean
*p
= children_to_clean
;
45 children_to_clean
= p
->next
;
47 if (p
->process
&& !in_signal
) {
48 struct child_process
*process
= p
->process
;
49 if (process
->clean_on_exit_handler
) {
51 "trace: run_command: running exit handler for pid %"
52 PRIuMAX
, (uintmax_t)p
->pid
54 process
->clean_on_exit_handler(process
);
60 if (p
->process
&& p
->process
->wait_after_clean
) {
61 p
->next
= children_to_wait_for
;
62 children_to_wait_for
= p
;
69 while (children_to_wait_for
) {
70 struct child_to_clean
*p
= children_to_wait_for
;
71 children_to_wait_for
= p
->next
;
73 while (waitpid(p
->pid
, NULL
, 0) < 0 && errno
== EINTR
)
74 ; /* spin waiting for process exit or error */
81 static void cleanup_children_on_signal(int sig
)
83 cleanup_children(sig
, 1);
88 static void cleanup_children_on_exit(void)
90 cleanup_children(SIGTERM
, 0);
93 static void mark_child_for_cleanup(pid_t pid
, struct child_process
*process
)
95 struct child_to_clean
*p
= xmalloc(sizeof(*p
));
98 p
->next
= children_to_clean
;
99 children_to_clean
= p
;
101 if (!installed_child_cleanup_handler
) {
102 atexit(cleanup_children_on_exit
);
103 sigchain_push_common(cleanup_children_on_signal
);
104 installed_child_cleanup_handler
= 1;
108 static void clear_child_for_cleanup(pid_t pid
)
110 struct child_to_clean
**pp
;
112 for (pp
= &children_to_clean
; *pp
; pp
= &(*pp
)->next
) {
113 struct child_to_clean
*clean_me
= *pp
;
115 if (clean_me
->pid
== pid
) {
116 *pp
= clean_me
->next
;
123 static inline void close_pair(int fd
[2])
129 int is_executable(const char *name
)
133 if (stat(name
, &st
) || /* stat, not lstat */
134 !S_ISREG(st
.st_mode
))
137 #if defined(GIT_WINDOWS_NATIVE)
139 * On Windows there is no executable bit. The file extension
140 * indicates whether it can be run as an executable, and Git
141 * has special-handling to detect scripts and launch them
142 * through the indicated script interpreter. We test for the
143 * file extension first because virus scanners may make
144 * it quite expensive to open many files.
146 if (ends_with(name
, ".exe"))
151 * Now that we know it does not have an executable extension,
152 * peek into the file instead.
156 int fd
= open(name
, O_RDONLY
);
157 st
.st_mode
&= ~S_IXUSR
;
159 n
= read(fd
, buf
, 2);
161 /* look for a she-bang */
162 if (!strcmp(buf
, "#!"))
163 st
.st_mode
|= S_IXUSR
;
168 return st
.st_mode
& S_IXUSR
;
171 #ifndef locate_in_PATH
173 * Search $PATH for a command. This emulates the path search that
174 * execvp would perform, without actually executing the command so it
175 * can be used before fork() to prepare to run a command using
176 * execve() or after execvp() to diagnose why it failed.
178 * The caller should ensure that file contains no directory
181 * Returns the path to the command, as found in $PATH or NULL if the
182 * command could not be found. The caller inherits ownership of the memory
183 * used to store the resultant path.
185 * This should not be used on Windows, where the $PATH search rules
186 * are more complicated (e.g., a search for "foo" should find
189 static char *locate_in_PATH(const char *file
)
191 const char *p
= getenv("PATH");
192 struct strbuf buf
= STRBUF_INIT
;
198 const char *end
= strchrnul(p
, ':');
202 /* POSIX specifies an empty entry as the current directory. */
204 strbuf_add(&buf
, p
, end
- p
);
205 strbuf_addch(&buf
, '/');
207 strbuf_addstr(&buf
, file
);
209 if (is_executable(buf
.buf
))
210 return strbuf_detach(&buf
, NULL
);
217 strbuf_release(&buf
);
222 int exists_in_PATH(const char *command
)
224 char *r
= locate_in_PATH(command
);
225 int found
= r
!= NULL
;
230 int sane_execvp(const char *file
, char * const argv
[])
232 #ifndef GIT_WINDOWS_NATIVE
234 * execvp() doesn't return, so we all we can do is tell trace2
235 * what we are about to do and let it leave a hint in the log
236 * (unless of course the execvp() fails).
238 * we skip this for Windows because the compat layer already
239 * has to emulate the execvp() call anyway.
241 int exec_id
= trace2_exec(file
, (const char **)argv
);
244 if (!execvp(file
, argv
))
245 return 0; /* cannot happen ;-) */
247 #ifndef GIT_WINDOWS_NATIVE
250 trace2_exec_result(exec_id
, ec
);
256 * When a command can't be found because one of the directories
257 * listed in $PATH is unsearchable, execvp reports EACCES, but
258 * careful usability testing (read: analysis of occasional bug
259 * reports) reveals that "No such file or directory" is more
262 * We avoid commands with "/", because execvp will not do $PATH
263 * lookups in that case.
265 * The reassignment of EACCES to errno looks like a no-op below,
266 * but we need to protect against exists_in_PATH overwriting errno.
268 if (errno
== EACCES
&& !strchr(file
, '/'))
269 errno
= exists_in_PATH(file
) ? EACCES
: ENOENT
;
270 else if (errno
== ENOTDIR
&& !strchr(file
, '/'))
275 static const char **prepare_shell_cmd(struct strvec
*out
, const char **argv
)
278 BUG("shell command is empty");
280 if (strcspn(argv
[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv
[0])) {
281 #ifndef GIT_WINDOWS_NATIVE
282 strvec_push(out
, SHELL_PATH
);
284 strvec_push(out
, "sh");
286 strvec_push(out
, "-c");
289 * If we have no extra arguments, we do not even need to
290 * bother with the "$@" magic.
293 strvec_push(out
, argv
[0]);
295 strvec_pushf(out
, "%s \"$@\"", argv
[0]);
298 strvec_pushv(out
, argv
);
302 #ifndef GIT_WINDOWS_NATIVE
303 static int child_notifier
= -1;
309 CHILD_ERR_SIGPROCMASK
,
315 enum child_errcode err
;
316 int syserr
; /* errno */
319 static void child_die(enum child_errcode err
)
321 struct child_err buf
;
326 /* write(2) on buf smaller than PIPE_BUF (min 512) is atomic: */
327 xwrite(child_notifier
, &buf
, sizeof(buf
));
331 static void child_dup2(int fd
, int to
)
333 if (dup2(fd
, to
) < 0)
334 child_die(CHILD_ERR_DUP2
);
337 static void child_close(int fd
)
340 child_die(CHILD_ERR_CLOSE
);
343 static void child_close_pair(int fd
[2])
349 static void child_error_fn(const char *err UNUSED
, va_list params UNUSED
)
351 const char msg
[] = "error() should not be called in child\n";
352 xwrite(2, msg
, sizeof(msg
) - 1);
355 static void child_warn_fn(const char *err UNUSED
, va_list params UNUSED
)
357 const char msg
[] = "warn() should not be called in child\n";
358 xwrite(2, msg
, sizeof(msg
) - 1);
361 static void NORETURN
child_die_fn(const char *err UNUSED
, va_list params UNUSED
)
363 const char msg
[] = "die() should not be called in child\n";
364 xwrite(2, msg
, sizeof(msg
) - 1);
368 /* this runs in the parent process */
369 static void child_err_spew(struct child_process
*cmd
, struct child_err
*cerr
)
371 static void (*old_errfn
)(const char *err
, va_list params
);
372 report_fn die_message_routine
= get_die_message_routine();
374 old_errfn
= get_error_routine();
375 set_error_routine(die_message_routine
);
376 errno
= cerr
->syserr
;
379 case CHILD_ERR_CHDIR
:
380 error_errno("exec '%s': cd to '%s' failed",
381 cmd
->args
.v
[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_SILENT
:
394 case CHILD_ERR_ERRNO
:
395 error_errno("cannot exec '%s'", cmd
->args
.v
[0]);
398 set_error_routine(old_errfn
);
401 static int prepare_cmd(struct strvec
*out
, const struct child_process
*cmd
)
404 BUG("command is empty");
407 * Add SHELL_PATH so in the event exec fails with ENOEXEC we can
408 * attempt to interpret the command with 'sh'.
410 strvec_push(out
, SHELL_PATH
);
413 prepare_git_cmd(out
, cmd
->args
.v
);
414 } else if (cmd
->use_shell
) {
415 prepare_shell_cmd(out
, cmd
->args
.v
);
417 strvec_pushv(out
, cmd
->args
.v
);
421 * If there are no dir separator characters in the command then perform
422 * a path lookup and use the resolved path as the command to exec. If
423 * there are dir separator characters, we have exec attempt to invoke
424 * the command directly.
426 if (!has_dir_sep(out
->v
[1])) {
427 char *program
= locate_in_PATH(out
->v
[1]);
429 free((char *)out
->v
[1]);
441 static char **prep_childenv(const char *const *deltaenv
)
443 extern char **environ
;
445 struct string_list env
= STRING_LIST_INIT_DUP
;
446 struct strbuf key
= STRBUF_INIT
;
447 const char *const *p
;
450 /* Construct a sorted string list consisting of the current environ */
451 for (p
= (const char *const *) environ
; p
&& *p
; p
++) {
452 const char *equals
= strchr(*p
, '=');
456 strbuf_add(&key
, *p
, equals
- *p
);
457 string_list_append(&env
, key
.buf
)->util
= (void *) *p
;
459 string_list_append(&env
, *p
)->util
= (void *) *p
;
462 string_list_sort(&env
);
464 /* Merge in 'deltaenv' with the current environ */
465 for (p
= deltaenv
; p
&& *p
; p
++) {
466 const char *equals
= strchr(*p
, '=');
469 /* ('key=value'), insert or replace entry */
471 strbuf_add(&key
, *p
, equals
- *p
);
472 string_list_insert(&env
, key
.buf
)->util
= (void *) *p
;
474 /* otherwise ('key') remove existing entry */
475 string_list_remove(&env
, *p
, 0);
479 /* Create an array of 'char *' to be used as the childenv */
480 ALLOC_ARRAY(childenv
, env
.nr
+ 1);
481 for (i
= 0; i
< env
.nr
; i
++)
482 childenv
[i
] = env
.items
[i
].util
;
483 childenv
[env
.nr
] = NULL
;
485 string_list_clear(&env
, 0);
486 strbuf_release(&key
);
490 struct atfork_state
{
497 #define CHECK_BUG(err, msg) \
501 BUG("%s: %s", msg, strerror(e)); \
504 static void atfork_prepare(struct atfork_state
*as
)
508 if (sigfillset(&all
))
509 die_errno("sigfillset");
511 if (sigprocmask(SIG_SETMASK
, &all
, &as
->old
))
512 die_errno("sigprocmask");
514 CHECK_BUG(pthread_sigmask(SIG_SETMASK
, &all
, &as
->old
),
515 "blocking all signals");
516 CHECK_BUG(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
, &as
->cs
),
517 "disabling cancellation");
521 static void atfork_parent(struct atfork_state
*as
)
524 if (sigprocmask(SIG_SETMASK
, &as
->old
, NULL
))
525 die_errno("sigprocmask");
527 CHECK_BUG(pthread_setcancelstate(as
->cs
, NULL
),
528 "re-enabling cancellation");
529 CHECK_BUG(pthread_sigmask(SIG_SETMASK
, &as
->old
, NULL
),
530 "restoring signal mask");
533 #endif /* GIT_WINDOWS_NATIVE */
535 static inline void set_cloexec(int fd
)
537 int flags
= fcntl(fd
, F_GETFD
);
539 fcntl(fd
, F_SETFD
, flags
| FD_CLOEXEC
);
542 static int wait_or_whine(pid_t pid
, const char *argv0
, int in_signal
)
544 int status
, code
= -1;
546 int failed_errno
= 0;
548 while ((waiting
= waitpid(pid
, &status
, 0)) < 0 && errno
== EINTR
)
552 failed_errno
= errno
;
554 error_errno("waitpid for %s failed", argv0
);
555 } else if (waiting
!= pid
) {
557 error("waitpid is confused (%s)", argv0
);
558 } else if (WIFSIGNALED(status
)) {
559 code
= WTERMSIG(status
);
560 if (!in_signal
&& code
!= SIGINT
&& code
!= SIGQUIT
&& code
!= SIGPIPE
)
561 error("%s died of signal %d", argv0
, code
);
563 * This return value is chosen so that code & 0xff
564 * mimics the exit code that a POSIX shell would report for
565 * a program that died from this signal.
568 } else if (WIFEXITED(status
)) {
569 code
= WEXITSTATUS(status
);
572 error("waitpid is confused (%s)", argv0
);
576 clear_child_for_cleanup(pid
);
578 errno
= failed_errno
;
582 static void trace_add_env(struct strbuf
*dst
, const char *const *deltaenv
)
584 struct string_list envs
= STRING_LIST_INIT_DUP
;
585 const char *const *e
;
587 int printed_unset
= 0;
589 /* Last one wins, see run-command.c:prep_childenv() for context */
590 for (e
= deltaenv
; e
&& *e
; e
++) {
591 struct strbuf key
= STRBUF_INIT
;
592 char *equals
= strchr(*e
, '=');
595 strbuf_add(&key
, *e
, equals
- *e
);
596 string_list_insert(&envs
, key
.buf
)->util
= equals
+ 1;
598 string_list_insert(&envs
, *e
)->util
= NULL
;
600 strbuf_release(&key
);
603 /* "unset X Y...;" */
604 for (i
= 0; i
< envs
.nr
; i
++) {
605 const char *var
= envs
.items
[i
].string
;
606 const char *val
= envs
.items
[i
].util
;
608 if (val
|| !getenv(var
))
611 if (!printed_unset
) {
612 strbuf_addstr(dst
, " unset");
615 strbuf_addf(dst
, " %s", var
);
618 strbuf_addch(dst
, ';');
620 /* ... followed by "A=B C=D ..." */
621 for (i
= 0; i
< envs
.nr
; i
++) {
622 const char *var
= envs
.items
[i
].string
;
623 const char *val
= envs
.items
[i
].util
;
629 oldval
= getenv(var
);
630 if (oldval
&& !strcmp(val
, oldval
))
633 strbuf_addf(dst
, " %s=", var
);
634 sq_quote_buf_pretty(dst
, val
);
636 string_list_clear(&envs
, 0);
639 static void trace_run_command(const struct child_process
*cp
)
641 struct strbuf buf
= STRBUF_INIT
;
643 if (!trace_want(&trace_default_key
))
646 strbuf_addstr(&buf
, "trace: run_command:");
648 strbuf_addstr(&buf
, " cd ");
649 sq_quote_buf_pretty(&buf
, cp
->dir
);
650 strbuf_addch(&buf
, ';');
652 trace_add_env(&buf
, cp
->env
.v
);
654 strbuf_addstr(&buf
, " git");
655 sq_quote_argv_pretty(&buf
, cp
->args
.v
);
657 trace_printf("%s", buf
.buf
);
658 strbuf_release(&buf
);
661 int start_command(struct child_process
*cmd
)
663 int need_in
, need_out
, need_err
;
664 int fdin
[2], fdout
[2], fderr
[2];
669 * In case of errors we must keep the promise to close FDs
670 * that have been passed in via ->in and ->out.
673 need_in
= !cmd
->no_stdin
&& cmd
->in
< 0;
675 if (pipe(fdin
) < 0) {
676 failed_errno
= errno
;
679 str
= "standard input";
685 need_out
= !cmd
->no_stdout
686 && !cmd
->stdout_to_stderr
689 if (pipe(fdout
) < 0) {
690 failed_errno
= errno
;
695 str
= "standard output";
701 need_err
= !cmd
->no_stderr
&& cmd
->err
< 0;
703 if (pipe(fderr
) < 0) {
704 failed_errno
= errno
;
713 str
= "standard error";
715 error("cannot create %s pipe for %s: %s",
716 str
, cmd
->args
.v
[0], strerror(failed_errno
));
717 child_process_clear(cmd
);
718 errno
= failed_errno
;
724 trace2_child_start(cmd
);
725 trace_run_command(cmd
);
729 if (cmd
->close_object_store
)
730 close_object_store(the_repository
->objects
);
732 #ifndef GIT_WINDOWS_NATIVE
737 struct strvec argv
= STRVEC_INIT
;
738 struct child_err cerr
;
739 struct atfork_state as
;
741 if (prepare_cmd(&argv
, cmd
) < 0) {
742 failed_errno
= errno
;
744 if (!cmd
->silent_exec_failure
)
745 error_errno("cannot run %s", cmd
->args
.v
[0]);
749 trace_argv_printf(&argv
.v
[1], "trace: start_command:");
751 if (pipe(notify_pipe
))
752 notify_pipe
[0] = notify_pipe
[1] = -1;
754 if (cmd
->no_stdin
|| cmd
->no_stdout
|| cmd
->no_stderr
) {
755 null_fd
= xopen("/dev/null", O_RDWR
| O_CLOEXEC
);
756 set_cloexec(null_fd
);
759 childenv
= prep_childenv(cmd
->env
.v
);
763 * NOTE: In order to prevent deadlocking when using threads special
764 * care should be taken with the function calls made in between the
765 * fork() and exec() calls. No calls should be made to functions which
766 * require acquiring a lock (e.g. malloc) as the lock could have been
767 * held by another thread at the time of forking, causing the lock to
768 * never be released in the child process. This means only
769 * Async-Signal-Safe functions are permitted in the child.
772 failed_errno
= errno
;
776 * Ensure the default die/error/warn routines do not get
777 * called, they can take stdio locks and malloc.
779 set_die_routine(child_die_fn
);
780 set_error_routine(child_error_fn
);
781 set_warn_routine(child_warn_fn
);
783 close(notify_pipe
[0]);
784 set_cloexec(notify_pipe
[1]);
785 child_notifier
= notify_pipe
[1];
788 child_dup2(null_fd
, 0);
790 child_dup2(fdin
[0], 0);
791 child_close_pair(fdin
);
792 } else if (cmd
->in
) {
793 child_dup2(cmd
->in
, 0);
794 child_close(cmd
->in
);
798 child_dup2(null_fd
, 2);
800 child_dup2(fderr
[1], 2);
801 child_close_pair(fderr
);
802 } else if (cmd
->err
> 1) {
803 child_dup2(cmd
->err
, 2);
804 child_close(cmd
->err
);
808 child_dup2(null_fd
, 1);
809 else if (cmd
->stdout_to_stderr
)
812 child_dup2(fdout
[1], 1);
813 child_close_pair(fdout
);
814 } else if (cmd
->out
> 1) {
815 child_dup2(cmd
->out
, 1);
816 child_close(cmd
->out
);
819 if (cmd
->dir
&& chdir(cmd
->dir
))
820 child_die(CHILD_ERR_CHDIR
);
823 * restore default signal handlers here, in case
824 * we catch a signal right before execve below
826 for (sig
= 1; sig
< NSIG
; sig
++) {
827 /* ignored signals get reset to SIG_DFL on execve */
828 if (signal(sig
, SIG_DFL
) == SIG_IGN
)
829 signal(sig
, SIG_IGN
);
832 if (sigprocmask(SIG_SETMASK
, &as
.old
, NULL
) != 0)
833 child_die(CHILD_ERR_SIGPROCMASK
);
836 * Attempt to exec using the command and arguments starting at
837 * argv.argv[1]. argv.argv[0] contains SHELL_PATH which will
838 * be used in the event exec failed with ENOEXEC at which point
839 * we will try to interpret the command using 'sh'.
841 execve(argv
.v
[1], (char *const *) argv
.v
+ 1,
842 (char *const *) childenv
);
843 if (errno
== ENOEXEC
)
844 execve(argv
.v
[0], (char *const *) argv
.v
,
845 (char *const *) childenv
);
847 if (cmd
->silent_exec_failure
&& errno
== ENOENT
)
848 child_die(CHILD_ERR_SILENT
);
849 child_die(CHILD_ERR_ERRNO
);
853 error_errno("cannot fork() for %s", cmd
->args
.v
[0]);
854 else if (cmd
->clean_on_exit
)
855 mark_child_for_cleanup(cmd
->pid
, cmd
);
858 * Wait for child's exec. If the exec succeeds (or if fork()
859 * failed), EOF is seen immediately by the parent. Otherwise, the
860 * child process sends a child_err struct.
861 * Note that use of this infrastructure is completely advisory,
862 * therefore, we keep error checks minimal.
864 close(notify_pipe
[1]);
865 if (xread(notify_pipe
[0], &cerr
, sizeof(cerr
)) == sizeof(cerr
)) {
867 * At this point we know that fork() succeeded, but exec()
868 * failed. Errors have been reported to our stderr.
870 wait_or_whine(cmd
->pid
, cmd
->args
.v
[0], 0);
871 child_err_spew(cmd
, &cerr
);
872 failed_errno
= errno
;
875 close(notify_pipe
[0]);
886 int fhin
= 0, fhout
= 1, fherr
= 2;
887 const char **sargv
= cmd
->args
.v
;
888 struct strvec nargv
= STRVEC_INIT
;
891 fhin
= open("/dev/null", O_RDWR
);
898 fherr
= open("/dev/null", O_RDWR
);
900 fherr
= dup(fderr
[1]);
901 else if (cmd
->err
> 2)
902 fherr
= dup(cmd
->err
);
905 fhout
= open("/dev/null", O_RDWR
);
906 else if (cmd
->stdout_to_stderr
)
909 fhout
= dup(fdout
[1]);
910 else if (cmd
->out
> 1)
911 fhout
= dup(cmd
->out
);
914 cmd
->args
.v
= prepare_git_cmd(&nargv
, sargv
);
915 else if (cmd
->use_shell
)
916 cmd
->args
.v
= prepare_shell_cmd(&nargv
, sargv
);
918 trace_argv_printf(cmd
->args
.v
, "trace: start_command:");
919 cmd
->pid
= mingw_spawnvpe(cmd
->args
.v
[0], cmd
->args
.v
,
921 cmd
->dir
, fhin
, fhout
, fherr
);
922 failed_errno
= errno
;
923 if (cmd
->pid
< 0 && (!cmd
->silent_exec_failure
|| errno
!= ENOENT
))
924 error_errno("cannot spawn %s", cmd
->args
.v
[0]);
925 if (cmd
->clean_on_exit
&& cmd
->pid
>= 0)
926 mark_child_for_cleanup(cmd
->pid
, cmd
);
928 strvec_clear(&nargv
);
940 trace2_child_exit(cmd
, -1);
954 child_process_clear(cmd
);
955 errno
= failed_errno
;
977 int finish_command(struct child_process
*cmd
)
979 int ret
= wait_or_whine(cmd
->pid
, cmd
->args
.v
[0], 0);
980 trace2_child_exit(cmd
, ret
);
981 child_process_clear(cmd
);
982 invalidate_lstat_cache();
986 int finish_command_in_signal(struct child_process
*cmd
)
988 int ret
= wait_or_whine(cmd
->pid
, cmd
->args
.v
[0], 1);
990 trace2_child_exit(cmd
, ret
);
995 int run_command(struct child_process
*cmd
)
999 if (cmd
->out
< 0 || cmd
->err
< 0)
1000 BUG("run_command with a pipe can cause deadlock");
1002 code
= start_command(cmd
);
1005 return finish_command(cmd
);
1009 static pthread_t main_thread
;
1010 static int main_thread_set
;
1011 static pthread_key_t async_key
;
1012 static pthread_key_t async_die_counter
;
1014 static void *run_thread(void *data
)
1016 struct async
*async
= data
;
1019 if (async
->isolate_sigpipe
) {
1022 sigaddset(&mask
, SIGPIPE
);
1023 if (pthread_sigmask(SIG_BLOCK
, &mask
, NULL
)) {
1024 ret
= error("unable to block SIGPIPE in async thread");
1029 pthread_setspecific(async_key
, async
);
1030 ret
= async
->proc(async
->proc_in
, async
->proc_out
, async
->data
);
1034 static NORETURN
void die_async(const char *err
, va_list params
)
1036 report_fn die_message_fn
= get_die_message_routine();
1038 die_message_fn(err
, params
);
1041 struct async
*async
= pthread_getspecific(async_key
);
1042 if (async
->proc_in
>= 0)
1043 close(async
->proc_in
);
1044 if (async
->proc_out
>= 0)
1045 close(async
->proc_out
);
1046 pthread_exit((void *)128);
1052 static int async_die_is_recursing(void)
1054 void *ret
= pthread_getspecific(async_die_counter
);
1055 pthread_setspecific(async_die_counter
, &async_die_counter
); /* set to any non-NULL valid pointer */
1061 if (!main_thread_set
)
1062 return 0; /* no asyncs started yet */
1063 return !pthread_equal(main_thread
, pthread_self());
1066 static void NORETURN
async_exit(int code
)
1068 pthread_exit((void *)(intptr_t)code
);
1074 void (**handlers
)(void);
1079 static int git_atexit_installed
;
1081 static void git_atexit_dispatch(void)
1085 for (i
=git_atexit_hdlrs
.nr
; i
; i
--)
1086 git_atexit_hdlrs
.handlers
[i
-1]();
1089 static void git_atexit_clear(void)
1091 free(git_atexit_hdlrs
.handlers
);
1092 memset(&git_atexit_hdlrs
, 0, sizeof(git_atexit_hdlrs
));
1093 git_atexit_installed
= 0;
1097 int git_atexit(void (*handler
)(void))
1099 ALLOC_GROW(git_atexit_hdlrs
.handlers
, git_atexit_hdlrs
.nr
+ 1, git_atexit_hdlrs
.alloc
);
1100 git_atexit_hdlrs
.handlers
[git_atexit_hdlrs
.nr
++] = handler
;
1101 if (!git_atexit_installed
) {
1102 if (atexit(&git_atexit_dispatch
))
1104 git_atexit_installed
= 1;
1108 #define atexit git_atexit
1110 static int process_is_async
;
1113 return process_is_async
;
1116 static void NORETURN
async_exit(int code
)
1123 void check_pipe(int err
)
1129 signal(SIGPIPE
, SIG_DFL
);
1131 /* Should never happen, but just in case... */
1136 int start_async(struct async
*async
)
1138 int need_in
, need_out
;
1139 int fdin
[2], fdout
[2];
1140 int proc_in
, proc_out
;
1142 need_in
= async
->in
< 0;
1144 if (pipe(fdin
) < 0) {
1147 return error_errno("cannot create pipe");
1149 async
->in
= fdin
[1];
1152 need_out
= async
->out
< 0;
1154 if (pipe(fdout
) < 0) {
1159 return error_errno("cannot create pipe");
1161 async
->out
= fdout
[0];
1167 proc_in
= async
->in
;
1172 proc_out
= fdout
[1];
1173 else if (async
->out
)
1174 proc_out
= async
->out
;
1179 /* Flush stdio before fork() to avoid cloning buffers */
1182 async
->pid
= fork();
1183 if (async
->pid
< 0) {
1184 error_errno("fork (async) failed");
1193 process_is_async
= 1;
1194 exit(!!async
->proc(proc_in
, proc_out
, async
->data
));
1197 mark_child_for_cleanup(async
->pid
, NULL
);
1206 else if (async
->out
)
1209 if (!main_thread_set
) {
1211 * We assume that the first time that start_async is called
1212 * it is from the main thread.
1214 main_thread_set
= 1;
1215 main_thread
= pthread_self();
1216 pthread_key_create(&async_key
, NULL
);
1217 pthread_key_create(&async_die_counter
, NULL
);
1218 set_die_routine(die_async
);
1219 set_die_is_recursing_routine(async_die_is_recursing
);
1223 set_cloexec(proc_in
);
1225 set_cloexec(proc_out
);
1226 async
->proc_in
= proc_in
;
1227 async
->proc_out
= proc_out
;
1229 int err
= pthread_create(&async
->tid
, NULL
, run_thread
, async
);
1231 error(_("cannot create async thread: %s"), strerror(err
));
1246 else if (async
->out
)
1251 int finish_async(struct async
*async
)
1254 int ret
= wait_or_whine(async
->pid
, "child process", 0);
1256 invalidate_lstat_cache();
1260 void *ret
= (void *)(intptr_t)(-1);
1262 if (pthread_join(async
->tid
, &ret
))
1263 error("pthread_join failed");
1264 invalidate_lstat_cache();
1265 return (int)(intptr_t)ret
;
1270 int async_with_fork(void)
1280 /* initialized by caller */
1282 int type
; /* POLLOUT or POLLIN */
1294 /* returned by pump_io */
1295 int error
; /* 0 for success, otherwise errno */
1301 static int pump_io_round(struct io_pump
*slots
, int nr
, struct pollfd
*pfd
)
1306 for (i
= 0; i
< nr
; i
++) {
1307 struct io_pump
*io
= &slots
[i
];
1310 pfd
[pollsize
].fd
= io
->fd
;
1311 pfd
[pollsize
].events
= io
->type
;
1312 io
->pfd
= &pfd
[pollsize
++];
1318 if (poll(pfd
, pollsize
, -1) < 0) {
1321 die_errno("poll failed");
1324 for (i
= 0; i
< nr
; i
++) {
1325 struct io_pump
*io
= &slots
[i
];
1330 if (!(io
->pfd
->revents
& (POLLOUT
|POLLIN
|POLLHUP
|POLLERR
|POLLNVAL
)))
1333 if (io
->type
== POLLOUT
) {
1337 * Don't use xwrite() here. It loops forever on EAGAIN,
1338 * and we're in our own poll() loop here.
1340 * Note that we lose xwrite()'s handling of MAX_IO_SIZE
1341 * and EINTR, so we have to implement those ourselves.
1343 len
= write(io
->fd
, io
->u
.out
.buf
,
1344 io
->u
.out
.len
<= MAX_IO_SIZE
?
1345 io
->u
.out
.len
: MAX_IO_SIZE
);
1347 if (errno
!= EINTR
&& errno
!= EAGAIN
&&
1354 io
->u
.out
.buf
+= len
;
1355 io
->u
.out
.len
-= len
;
1356 if (!io
->u
.out
.len
) {
1363 if (io
->type
== POLLIN
) {
1364 ssize_t len
= strbuf_read_once(io
->u
.in
.buf
,
1365 io
->fd
, io
->u
.in
.hint
);
1378 static int pump_io(struct io_pump
*slots
, int nr
)
1383 for (i
= 0; i
< nr
; i
++)
1386 ALLOC_ARRAY(pfd
, nr
);
1387 while (pump_io_round(slots
, nr
, pfd
))
1391 /* There may be multiple errno values, so just pick the first. */
1392 for (i
= 0; i
< nr
; i
++) {
1393 if (slots
[i
].error
) {
1394 errno
= slots
[i
].error
;
1402 int pipe_command(struct child_process
*cmd
,
1403 const char *in
, size_t in_len
,
1404 struct strbuf
*out
, size_t out_hint
,
1405 struct strbuf
*err
, size_t err_hint
)
1407 struct io_pump io
[3];
1417 if (start_command(cmd
) < 0)
1421 if (enable_pipe_nonblock(cmd
->in
) < 0) {
1422 error_errno("unable to make pipe non-blocking");
1430 io
[nr
].fd
= cmd
->in
;
1431 io
[nr
].type
= POLLOUT
;
1432 io
[nr
].u
.out
.buf
= in
;
1433 io
[nr
].u
.out
.len
= in_len
;
1437 io
[nr
].fd
= cmd
->out
;
1438 io
[nr
].type
= POLLIN
;
1439 io
[nr
].u
.in
.buf
= out
;
1440 io
[nr
].u
.in
.hint
= out_hint
;
1444 io
[nr
].fd
= cmd
->err
;
1445 io
[nr
].type
= POLLIN
;
1446 io
[nr
].u
.in
.buf
= err
;
1447 io
[nr
].u
.in
.hint
= err_hint
;
1451 if (pump_io(io
, nr
) < 0) {
1452 finish_command(cmd
); /* throw away exit code */
1456 return finish_command(cmd
);
1462 GIT_CP_WAIT_CLEANUP
,
1465 struct parallel_processes
{
1466 size_t nr_processes
;
1469 enum child_state state
;
1470 struct child_process process
;
1475 * The struct pollfd is logically part of *children,
1476 * but the system call expects it as its own array.
1480 unsigned shutdown
: 1;
1482 size_t output_owner
;
1483 struct strbuf buffered_output
; /* of finished children */
1486 struct parallel_processes_for_signal
{
1487 const struct run_process_parallel_opts
*opts
;
1488 const struct parallel_processes
*pp
;
1491 static void kill_children(const struct parallel_processes
*pp
,
1492 const struct run_process_parallel_opts
*opts
,
1495 for (size_t i
= 0; i
< opts
->processes
; i
++)
1496 if (pp
->children
[i
].state
== GIT_CP_WORKING
)
1497 kill(pp
->children
[i
].process
.pid
, signo
);
1500 static void kill_children_signal(const struct parallel_processes_for_signal
*pp_sig
,
1503 kill_children(pp_sig
->pp
, pp_sig
->opts
, signo
);
1506 static struct parallel_processes_for_signal
*pp_for_signal
;
1508 static void handle_children_on_signal(int signo
)
1510 kill_children_signal(pp_for_signal
, signo
);
1511 sigchain_pop(signo
);
1515 static void pp_init(struct parallel_processes
*pp
,
1516 const struct run_process_parallel_opts
*opts
,
1517 struct parallel_processes_for_signal
*pp_sig
)
1519 const size_t n
= opts
->processes
;
1522 BUG("you must provide a non-zero number of processes!");
1524 trace_printf("run_processes_parallel: preparing to run up to %"PRIuMAX
" tasks",
1527 if (!opts
->get_next_task
)
1528 BUG("you need to specify a get_next_task function");
1530 CALLOC_ARRAY(pp
->children
, n
);
1532 CALLOC_ARRAY(pp
->pfd
, n
);
1534 for (size_t i
= 0; i
< n
; i
++) {
1535 strbuf_init(&pp
->children
[i
].err
, 0);
1536 child_process_init(&pp
->children
[i
].process
);
1538 pp
->pfd
[i
].events
= POLLIN
| POLLHUP
;
1544 pp_sig
->opts
= opts
;
1545 pp_for_signal
= pp_sig
;
1546 sigchain_push_common(handle_children_on_signal
);
1549 static void pp_cleanup(struct parallel_processes
*pp
,
1550 const struct run_process_parallel_opts
*opts
)
1552 trace_printf("run_processes_parallel: done");
1553 for (size_t i
= 0; i
< opts
->processes
; i
++) {
1554 strbuf_release(&pp
->children
[i
].err
);
1555 child_process_clear(&pp
->children
[i
].process
);
1562 * When get_next_task added messages to the buffer in its last
1563 * iteration, the buffered output is non empty.
1565 strbuf_write(&pp
->buffered_output
, stderr
);
1566 strbuf_release(&pp
->buffered_output
);
1568 sigchain_pop_common();
1572 * 0 if a new task was started.
1573 * 1 if no new jobs was started (get_next_task ran out of work, non critical
1574 * problem with starting a new command)
1575 * <0 no new job was started, user wishes to shutdown early. Use negative code
1576 * to signal the children.
1578 static int pp_start_one(struct parallel_processes
*pp
,
1579 const struct run_process_parallel_opts
*opts
)
1584 for (i
= 0; i
< opts
->processes
; i
++)
1585 if (pp
->children
[i
].state
== GIT_CP_FREE
)
1587 if (i
== opts
->processes
)
1588 BUG("bookkeeping is hard");
1591 * By default, do not inherit stdin from the parent process - otherwise,
1592 * all children would share stdin! Users may overwrite this to provide
1593 * something to the child's stdin by having their 'get_next_task'
1594 * callback assign 0 to .no_stdin and an appropriate integer to .in.
1596 pp
->children
[i
].process
.no_stdin
= 1;
1598 code
= opts
->get_next_task(&pp
->children
[i
].process
,
1599 opts
->ungroup
? NULL
: &pp
->children
[i
].err
,
1601 &pp
->children
[i
].data
);
1603 if (!opts
->ungroup
) {
1604 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1605 strbuf_reset(&pp
->children
[i
].err
);
1609 if (!opts
->ungroup
) {
1610 pp
->children
[i
].process
.err
= -1;
1611 pp
->children
[i
].process
.stdout_to_stderr
= 1;
1614 if (start_command(&pp
->children
[i
].process
)) {
1615 if (opts
->start_failure
)
1616 code
= opts
->start_failure(opts
->ungroup
? NULL
:
1617 &pp
->children
[i
].err
,
1619 pp
->children
[i
].data
);
1623 if (!opts
->ungroup
) {
1624 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1625 strbuf_reset(&pp
->children
[i
].err
);
1633 pp
->children
[i
].state
= GIT_CP_WORKING
;
1635 pp
->pfd
[i
].fd
= pp
->children
[i
].process
.err
;
1639 static void pp_buffer_stderr(struct parallel_processes
*pp
,
1640 const struct run_process_parallel_opts
*opts
,
1643 while (poll(pp
->pfd
, opts
->processes
, output_timeout
) < 0) {
1646 pp_cleanup(pp
, opts
);
1650 /* Buffer output from all pipes. */
1651 for (size_t i
= 0; i
< opts
->processes
; i
++) {
1652 if (pp
->children
[i
].state
== GIT_CP_WORKING
&&
1653 pp
->pfd
[i
].revents
& (POLLIN
| POLLHUP
)) {
1654 int n
= strbuf_read_once(&pp
->children
[i
].err
,
1655 pp
->children
[i
].process
.err
, 0);
1657 close(pp
->children
[i
].process
.err
);
1658 pp
->children
[i
].state
= GIT_CP_WAIT_CLEANUP
;
1660 if (errno
!= EAGAIN
)
1666 static void pp_output(const struct parallel_processes
*pp
)
1668 size_t i
= pp
->output_owner
;
1670 if (pp
->children
[i
].state
== GIT_CP_WORKING
&&
1671 pp
->children
[i
].err
.len
) {
1672 strbuf_write(&pp
->children
[i
].err
, stderr
);
1673 strbuf_reset(&pp
->children
[i
].err
);
1677 static int pp_collect_finished(struct parallel_processes
*pp
,
1678 const struct run_process_parallel_opts
*opts
)
1684 while (pp
->nr_processes
> 0) {
1685 for (i
= 0; i
< opts
->processes
; i
++)
1686 if (pp
->children
[i
].state
== GIT_CP_WAIT_CLEANUP
)
1688 if (i
== opts
->processes
)
1691 code
= finish_command(&pp
->children
[i
].process
);
1693 if (opts
->task_finished
)
1694 code
= opts
->task_finished(code
, opts
->ungroup
? NULL
:
1695 &pp
->children
[i
].err
, opts
->data
,
1696 pp
->children
[i
].data
);
1706 pp
->children
[i
].state
= GIT_CP_FREE
;
1709 child_process_init(&pp
->children
[i
].process
);
1711 if (opts
->ungroup
) {
1712 ; /* no strbuf_*() work to do here */
1713 } else if (i
!= pp
->output_owner
) {
1714 strbuf_addbuf(&pp
->buffered_output
, &pp
->children
[i
].err
);
1715 strbuf_reset(&pp
->children
[i
].err
);
1717 const size_t n
= opts
->processes
;
1719 strbuf_write(&pp
->children
[i
].err
, stderr
);
1720 strbuf_reset(&pp
->children
[i
].err
);
1722 /* Output all other finished child processes */
1723 strbuf_write(&pp
->buffered_output
, stderr
);
1724 strbuf_reset(&pp
->buffered_output
);
1727 * Pick next process to output live.
1729 * For now we pick it randomly by doing a round
1730 * robin. Later we may want to pick the one with
1731 * the most output or the longest or shortest
1732 * running process time.
1734 for (i
= 0; i
< n
; i
++)
1735 if (pp
->children
[(pp
->output_owner
+ i
) % n
].state
== GIT_CP_WORKING
)
1737 pp
->output_owner
= (pp
->output_owner
+ i
) % n
;
1743 void run_processes_parallel(const struct run_process_parallel_opts
*opts
)
1746 int output_timeout
= 100;
1748 struct parallel_processes_for_signal pp_sig
;
1749 struct parallel_processes pp
= {
1750 .buffered_output
= STRBUF_INIT
,
1753 const char *tr2_category
= opts
->tr2_category
;
1754 const char *tr2_label
= opts
->tr2_label
;
1755 const int do_trace2
= tr2_category
&& tr2_label
;
1758 trace2_region_enter_printf(tr2_category
, tr2_label
, NULL
,
1759 "max:%d", opts
->processes
);
1761 pp_init(&pp
, opts
, &pp_sig
);
1764 i
< spawn_cap
&& !pp
.shutdown
&&
1765 pp
.nr_processes
< opts
->processes
;
1767 code
= pp_start_one(&pp
, opts
);
1772 kill_children(&pp
, opts
, -code
);
1776 if (!pp
.nr_processes
)
1778 if (opts
->ungroup
) {
1779 for (size_t i
= 0; i
< opts
->processes
; i
++)
1780 pp
.children
[i
].state
= GIT_CP_WAIT_CLEANUP
;
1782 pp_buffer_stderr(&pp
, opts
, output_timeout
);
1785 code
= pp_collect_finished(&pp
, opts
);
1789 kill_children(&pp
, opts
,-code
);
1793 pp_cleanup(&pp
, opts
);
1796 trace2_region_leave(tr2_category
, tr2_label
, NULL
);
1799 int prepare_auto_maintenance(int quiet
, struct child_process
*maint
)
1803 if (!git_config_get_bool("maintenance.auto", &enabled
) &&
1808 maint
->close_object_store
= 1;
1809 strvec_pushl(&maint
->args
, "maintenance", "run", "--auto", NULL
);
1810 strvec_push(&maint
->args
, quiet
? "--quiet" : "--no-quiet");
1815 int run_auto_maintenance(int quiet
)
1817 struct child_process maint
= CHILD_PROCESS_INIT
;
1818 if (!prepare_auto_maintenance(quiet
, &maint
))
1820 return run_command(&maint
);
1823 void prepare_other_repo_env(struct strvec
*env
, const char *new_git_dir
)
1825 const char * const *var
;
1827 for (var
= local_repo_env
; *var
; var
++) {
1828 if (strcmp(*var
, CONFIG_DATA_ENVIRONMENT
) &&
1829 strcmp(*var
, CONFIG_COUNT_ENVIRONMENT
))
1830 strvec_push(env
, *var
);
1832 strvec_pushf(env
, "%s=%s", GIT_DIR_ENVIRONMENT
, new_git_dir
);
1835 enum start_bg_result
start_bg_command(struct child_process
*cmd
,
1836 start_bg_wait_cb
*wait_cb
,
1838 unsigned int timeout_sec
)
1840 enum start_bg_result sbgr
= SBGR_ERROR
;
1847 * We do not allow clean-on-exit because the child process
1848 * should persist in the background and possibly/probably
1849 * after this process exits. So we don't want to kill the
1850 * child during our atexit routine.
1852 if (cmd
->clean_on_exit
)
1853 BUG("start_bg_command() does not allow non-zero clean_on_exit");
1855 if (!cmd
->trace2_child_class
)
1856 cmd
->trace2_child_class
= "background";
1858 ret
= start_command(cmd
);
1861 * We assume that if `start_command()` fails, we
1862 * either get a complete `trace2_child_start() /
1863 * trace2_child_exit()` pair or it fails before the
1864 * `trace2_child_start()` is emitted, so we do not
1865 * need to worry about it here.
1867 * We also assume that `start_command()` does not add
1868 * us to the cleanup list. And that it calls
1869 * `child_process_clear()`.
1876 time_limit
+= timeout_sec
;
1879 pid_seen
= waitpid(cmd
->pid
, &wait_status
, WNOHANG
);
1883 * The child is currently running. Ask the callback
1884 * if the child is ready to do work or whether we
1885 * should keep waiting for it to boot up.
1887 ret
= (*wait_cb
)(cmd
, cb_data
);
1890 * The child is running and "ready".
1892 trace2_child_ready(cmd
, "ready");
1895 } else if (ret
> 0) {
1897 * The callback said to give it more time to boot up
1898 * (subject to our timeout limit).
1903 if (now
< time_limit
)
1907 * Our timeout has expired. We don't try to
1908 * kill the child, but rather let it continue
1909 * (hopefully) trying to startup.
1911 trace2_child_ready(cmd
, "timeout");
1912 sbgr
= SBGR_TIMEOUT
;
1916 * The cb gave up on this child. It is still running,
1917 * but our cb got an error trying to probe it.
1919 trace2_child_ready(cmd
, "error");
1920 sbgr
= SBGR_CB_ERROR
;
1925 else if (pid_seen
== cmd
->pid
) {
1926 int child_code
= -1;
1929 * The child started, but exited or was terminated
1930 * before becoming "ready".
1932 * We try to match the behavior of `wait_or_whine()`
1933 * WRT the handling of WIFSIGNALED() and WIFEXITED()
1934 * and convert the child's status to a return code for
1935 * tracing purposes and emit the `trace2_child_exit()`
1938 * We do not want the wait_or_whine() error message
1939 * because we will be called by client-side library
1942 if (WIFEXITED(wait_status
))
1943 child_code
= WEXITSTATUS(wait_status
);
1944 else if (WIFSIGNALED(wait_status
))
1945 child_code
= WTERMSIG(wait_status
) + 128;
1946 trace2_child_exit(cmd
, child_code
);
1952 else if (pid_seen
< 0 && errno
== EINTR
)
1955 trace2_child_exit(cmd
, -1);
1959 child_process_clear(cmd
);
1960 invalidate_lstat_cache();