]> git.ipfire.org Git - thirdparty/git.git/blame - run-command.c
test-ref-store: tweaks to for-each-reflog-ent format
[thirdparty/git.git] / run-command.c
CommitLineData
b1bf95bb
JW
1#include "cache.h"
2#include "run-command.h"
d807c4a0 3#include "exec-cmd.h"
afe19ff7 4#include "sigchain.h"
dbbcd44f 5#include "strvec.h"
c553c72e
SB
6#include "thread-utils.h"
7#include "strbuf.h"
f805a00a 8#include "string-list.h"
e73dd786 9#include "quote.h"
1942d483 10#include "config.h"
28d04e1e 11#include "packfile.h"
5e3aba33 12#include "hook.h"
b1bf95bb 13
483bbd4e
RS
14void child_process_init(struct child_process *child)
15{
5726a6b4
ÆAB
16 struct child_process blank = CHILD_PROCESS_INIT;
17 memcpy(child, &blank, sizeof(*child));
483bbd4e
RS
18}
19
2d71608e
RS
20void child_process_clear(struct child_process *child)
21{
c972bf4c
JK
22 strvec_clear(&child->args);
23 strvec_clear(&child->env_array);
2d71608e
RS
24}
25
afe19ff7
JK
26struct child_to_clean {
27 pid_t pid;
ac2fbaa6 28 struct child_process *process;
afe19ff7
JK
29 struct child_to_clean *next;
30};
31static struct child_to_clean *children_to_clean;
32static int installed_child_cleanup_handler;
33
507d7804 34static void cleanup_children(int sig, int in_signal)
afe19ff7 35{
46df6906
JK
36 struct child_to_clean *children_to_wait_for = NULL;
37
afe19ff7
JK
38 while (children_to_clean) {
39 struct child_to_clean *p = children_to_clean;
40 children_to_clean = p->next;
ac2fbaa6
LS
41
42 if (p->process && !in_signal) {
43 struct child_process *process = p->process;
44 if (process->clean_on_exit_handler) {
45 trace_printf(
46 "trace: run_command: running exit handler for pid %"
47 PRIuMAX, (uintmax_t)p->pid
48 );
49 process->clean_on_exit_handler(process);
50 }
51 }
52
afe19ff7 53 kill(p->pid, sig);
46df6906 54
7b91929b 55 if (p->process && p->process->wait_after_clean) {
46df6906
JK
56 p->next = children_to_wait_for;
57 children_to_wait_for = p;
58 } else {
59 if (!in_signal)
60 free(p);
61 }
62 }
63
64 while (children_to_wait_for) {
65 struct child_to_clean *p = children_to_wait_for;
66 children_to_wait_for = p->next;
67
68 while (waitpid(p->pid, NULL, 0) < 0 && errno == EINTR)
69 ; /* spin waiting for process exit or error */
70
507d7804
TI
71 if (!in_signal)
72 free(p);
afe19ff7
JK
73 }
74}
75
76static void cleanup_children_on_signal(int sig)
77{
507d7804 78 cleanup_children(sig, 1);
afe19ff7
JK
79 sigchain_pop(sig);
80 raise(sig);
81}
82
83static void cleanup_children_on_exit(void)
84{
507d7804 85 cleanup_children(SIGTERM, 0);
afe19ff7
JK
86}
87
ac2fbaa6 88static void mark_child_for_cleanup(pid_t pid, struct child_process *process)
afe19ff7
JK
89{
90 struct child_to_clean *p = xmalloc(sizeof(*p));
91 p->pid = pid;
ac2fbaa6 92 p->process = process;
afe19ff7
JK
93 p->next = children_to_clean;
94 children_to_clean = p;
95
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;
100 }
101}
102
103static void clear_child_for_cleanup(pid_t pid)
104{
bdee397d 105 struct child_to_clean **pp;
afe19ff7 106
bdee397d
DG
107 for (pp = &children_to_clean; *pp; pp = &(*pp)->next) {
108 struct child_to_clean *clean_me = *pp;
109
110 if (clean_me->pid == pid) {
111 *pp = clean_me->next;
112 free(clean_me);
afe19ff7
JK
113 return;
114 }
115 }
116}
117
9dc09c76
SP
118static inline void close_pair(int fd[2])
119{
120 close(fd[0]);
121 close(fd[1]);
122}
123
38124a40
BW
124int is_executable(const char *name)
125{
126 struct stat st;
127
128 if (stat(name, &st) || /* stat, not lstat */
129 !S_ISREG(st.st_mode))
130 return 0;
131
132#if defined(GIT_WINDOWS_NATIVE)
133 /*
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.
140 */
141 if (ends_with(name, ".exe"))
142 return S_IXUSR;
143
144{
145 /*
146 * Now that we know it does not have an executable extension,
147 * peek into the file instead.
148 */
149 char buf[3] = { 0 };
150 int n;
151 int fd = open(name, O_RDONLY);
152 st.st_mode &= ~S_IXUSR;
153 if (fd >= 0) {
154 n = read(fd, buf, 2);
155 if (n == 2)
156 /* look for a she-bang */
157 if (!strcmp(buf, "#!"))
158 st.st_mode |= S_IXUSR;
159 close(fd);
160 }
161}
162#endif
163 return st.st_mode & S_IXUSR;
164}
165
94028310
BW
166/*
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.
171 *
172 * The caller should ensure that file contains no directory
173 * separators.
174 *
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.
178 *
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
181 * "foo.exe").
182 */
38f865c2
JK
183static char *locate_in_PATH(const char *file)
184{
185 const char *p = getenv("PATH");
186 struct strbuf buf = STRBUF_INIT;
187
188 if (!p || !*p)
189 return NULL;
190
191 while (1) {
192 const char *end = strchrnul(p, ':');
193
194 strbuf_reset(&buf);
195
196 /* POSIX specifies an empty entry as the current directory. */
197 if (end != p) {
198 strbuf_add(&buf, p, end - p);
199 strbuf_addch(&buf, '/');
200 }
201 strbuf_addstr(&buf, file);
202
94028310 203 if (is_executable(buf.buf))
38f865c2
JK
204 return strbuf_detach(&buf, NULL);
205
206 if (!*end)
207 break;
208 p = end + 1;
209 }
210
211 strbuf_release(&buf);
212 return NULL;
213}
214
3f36e6f3 215int exists_in_PATH(const char *command)
38f865c2 216{
3f36e6f3 217 char *r = locate_in_PATH(command);
63ab08fb 218 int found = r != NULL;
38f865c2 219 free(r);
63ab08fb 220 return found;
38f865c2
JK
221}
222
223int sane_execvp(const char *file, char * const argv[])
224{
ee4512ed
JH
225#ifndef GIT_WINDOWS_NATIVE
226 /*
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).
230 *
231 * we skip this for Windows because the compat layer already
232 * has to emulate the execvp() call anyway.
233 */
234 int exec_id = trace2_exec(file, (const char **)argv);
235#endif
236
38f865c2
JK
237 if (!execvp(file, argv))
238 return 0; /* cannot happen ;-) */
239
ee4512ed
JH
240#ifndef GIT_WINDOWS_NATIVE
241 {
242 int ec = errno;
243 trace2_exec_result(exec_id, ec);
244 errno = ec;
245 }
246#endif
247
38f865c2
JK
248 /*
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
253 * intuitive.
254 *
255 * We avoid commands with "/", because execvp will not do $PATH
256 * lookups in that case.
257 *
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.
260 */
261 if (errno == EACCES && !strchr(file, '/'))
262 errno = exists_in_PATH(file) ? EACCES : ENOENT;
a7855083
JH
263 else if (errno == ENOTDIR && !strchr(file, '/'))
264 errno = ENOENT;
38f865c2
JK
265 return -1;
266}
267
c972bf4c 268static const char **prepare_shell_cmd(struct strvec *out, const char **argv)
8dba1e63 269{
20574f55 270 if (!argv[0])
033abf97 271 BUG("shell command is empty");
8dba1e63 272
f445644f 273 if (strcspn(argv[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
380395d0 274#ifndef GIT_WINDOWS_NATIVE
c972bf4c 275 strvec_push(out, SHELL_PATH);
77629754 276#else
c972bf4c 277 strvec_push(out, "sh");
77629754 278#endif
c972bf4c 279 strvec_push(out, "-c");
8dba1e63 280
20574f55
JK
281 /*
282 * If we have no extra arguments, we do not even need to
283 * bother with the "$@" magic.
284 */
285 if (!argv[1])
c972bf4c 286 strvec_push(out, argv[0]);
20574f55 287 else
c972bf4c 288 strvec_pushf(out, "%s \"$@\"", argv[0]);
20574f55 289 }
8dba1e63 290
c972bf4c 291 strvec_pushv(out, argv);
d70a9eb6 292 return out->v;
8dba1e63
JK
293}
294
380395d0 295#ifndef GIT_WINDOWS_NATIVE
2b541bf8
JS
296static int child_notifier = -1;
297
79319b19
BW
298enum child_errcode {
299 CHILD_ERR_CHDIR,
53fa6753
BW
300 CHILD_ERR_DUP2,
301 CHILD_ERR_CLOSE,
45afb1ca 302 CHILD_ERR_SIGPROCMASK,
79319b19
BW
303 CHILD_ERR_ENOENT,
304 CHILD_ERR_SILENT,
305 CHILD_ERR_ERRNO
306};
307
308struct child_err {
309 enum child_errcode err;
310 int syserr; /* errno */
311};
312
313static void child_die(enum child_errcode err)
2b541bf8 314{
79319b19
BW
315 struct child_err buf;
316
317 buf.err = err;
318 buf.syserr = errno;
319
320 /* write(2) on buf smaller than PIPE_BUF (min 512) is atomic: */
321 xwrite(child_notifier, &buf, sizeof(buf));
322 _exit(1);
323}
324
53fa6753
BW
325static void child_dup2(int fd, int to)
326{
327 if (dup2(fd, to) < 0)
328 child_die(CHILD_ERR_DUP2);
329}
330
331static void child_close(int fd)
332{
333 if (close(fd))
334 child_die(CHILD_ERR_CLOSE);
335}
336
337static void child_close_pair(int fd[2])
338{
339 child_close(fd[0]);
340 child_close(fd[1]);
341}
342
79319b19
BW
343/*
344 * parent will make it look like the child spewed a fatal error and died
345 * this is needed to prevent changes to t0061.
346 */
347static void fake_fatal(const char *err, va_list params)
348{
349 vreportf("fatal: ", err, params);
350}
351
352static void child_error_fn(const char *err, va_list params)
353{
354 const char msg[] = "error() should not be called in child\n";
355 xwrite(2, msg, sizeof(msg) - 1);
356}
357
358static void child_warn_fn(const char *err, va_list params)
359{
360 const char msg[] = "warn() should not be called in child\n";
361 xwrite(2, msg, sizeof(msg) - 1);
362}
363
364static void NORETURN child_die_fn(const char *err, va_list params)
365{
366 const char msg[] = "die() should not be called in child\n";
367 xwrite(2, msg, sizeof(msg) - 1);
368 _exit(2);
369}
370
371/* this runs in the parent process */
372static void child_err_spew(struct child_process *cmd, struct child_err *cerr)
373{
374 static void (*old_errfn)(const char *err, va_list params);
375
376 old_errfn = get_error_routine();
377 set_error_routine(fake_fatal);
378 errno = cerr->syserr;
379
380 switch (cerr->err) {
381 case CHILD_ERR_CHDIR:
382 error_errno("exec '%s': cd to '%s' failed",
383 cmd->argv[0], cmd->dir);
384 break;
53fa6753
BW
385 case CHILD_ERR_DUP2:
386 error_errno("dup2() in child failed");
387 break;
388 case CHILD_ERR_CLOSE:
389 error_errno("close() in child failed");
390 break;
45afb1ca
EW
391 case CHILD_ERR_SIGPROCMASK:
392 error_errno("sigprocmask failed restoring signals");
393 break;
79319b19
BW
394 case CHILD_ERR_ENOENT:
395 error_errno("cannot run %s", cmd->argv[0]);
396 break;
397 case CHILD_ERR_SILENT:
398 break;
399 case CHILD_ERR_ERRNO:
400 error_errno("cannot exec '%s'", cmd->argv[0]);
401 break;
402 }
403 set_error_routine(old_errfn);
2b541bf8 404}
3967e25b 405
c972bf4c 406static int prepare_cmd(struct strvec *out, const struct child_process *cmd)
3967e25b
BW
407{
408 if (!cmd->argv[0])
033abf97 409 BUG("command is empty");
3967e25b 410
e3a43446
BW
411 /*
412 * Add SHELL_PATH so in the event exec fails with ENOEXEC we can
413 * attempt to interpret the command with 'sh'.
414 */
c972bf4c 415 strvec_push(out, SHELL_PATH);
e3a43446 416
3967e25b 417 if (cmd->git_cmd) {
54a7a646 418 prepare_git_cmd(out, cmd->argv);
3967e25b
BW
419 } else if (cmd->use_shell) {
420 prepare_shell_cmd(out, cmd->argv);
421 } else {
c972bf4c 422 strvec_pushv(out, cmd->argv);
3967e25b 423 }
e3a43446
BW
424
425 /*
05ac8582
AK
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.
e3a43446 430 */
d70a9eb6
JK
431 if (!has_dir_sep(out->v[1])) {
432 char *program = locate_in_PATH(out->v[1]);
e3a43446 433 if (program) {
d70a9eb6
JK
434 free((char *)out->v[1]);
435 out->v[1] = program;
321fd823 436 } else {
c972bf4c 437 strvec_clear(out);
321fd823
JK
438 errno = ENOENT;
439 return -1;
e3a43446
BW
440 }
441 }
321fd823
JK
442
443 return 0;
3967e25b 444}
ae25394b
BW
445
446static char **prep_childenv(const char *const *deltaenv)
447{
448 extern char **environ;
449 char **childenv;
450 struct string_list env = STRING_LIST_INIT_DUP;
451 struct strbuf key = STRBUF_INIT;
452 const char *const *p;
453 int i;
454
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, '=');
458
459 if (equals) {
460 strbuf_reset(&key);
461 strbuf_add(&key, *p, equals - *p);
462 string_list_append(&env, key.buf)->util = (void *) *p;
463 } else {
464 string_list_append(&env, *p)->util = (void *) *p;
465 }
466 }
467 string_list_sort(&env);
468
469 /* Merge in 'deltaenv' with the current environ */
470 for (p = deltaenv; p && *p; p++) {
471 const char *equals = strchr(*p, '=');
472
473 if (equals) {
474 /* ('key=value'), insert or replace entry */
475 strbuf_reset(&key);
476 strbuf_add(&key, *p, equals - *p);
477 string_list_insert(&env, key.buf)->util = (void *) *p;
478 } else {
479 /* otherwise ('key') remove existing entry */
480 string_list_remove(&env, *p, 0);
481 }
482 }
483
484 /* Create an array of 'char *' to be used as the childenv */
0e187d75 485 ALLOC_ARRAY(childenv, env.nr + 1);
ae25394b
BW
486 for (i = 0; i < env.nr; i++)
487 childenv[i] = env.items[i].util;
488 childenv[env.nr] = NULL;
489
490 string_list_clear(&env, 0);
491 strbuf_release(&key);
492 return childenv;
493}
45afb1ca
EW
494
495struct atfork_state {
496#ifndef NO_PTHREADS
497 int cs;
498#endif
499 sigset_t old;
500};
501
dde74d73
JS
502#define CHECK_BUG(err, msg) \
503 do { \
504 int e = (err); \
505 if (e) \
506 BUG("%s: %s", msg, strerror(e)); \
507 } while(0)
45afb1ca
EW
508
509static void atfork_prepare(struct atfork_state *as)
510{
511 sigset_t all;
512
513 if (sigfillset(&all))
514 die_errno("sigfillset");
515#ifdef NO_PTHREADS
516 if (sigprocmask(SIG_SETMASK, &all, &as->old))
517 die_errno("sigprocmask");
518#else
dde74d73 519 CHECK_BUG(pthread_sigmask(SIG_SETMASK, &all, &as->old),
45afb1ca 520 "blocking all signals");
dde74d73 521 CHECK_BUG(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &as->cs),
45afb1ca
EW
522 "disabling cancellation");
523#endif
524}
525
526static void atfork_parent(struct atfork_state *as)
527{
528#ifdef NO_PTHREADS
529 if (sigprocmask(SIG_SETMASK, &as->old, NULL))
530 die_errno("sigprocmask");
531#else
dde74d73 532 CHECK_BUG(pthread_setcancelstate(as->cs, NULL),
45afb1ca 533 "re-enabling cancellation");
dde74d73 534 CHECK_BUG(pthread_sigmask(SIG_SETMASK, &as->old, NULL),
45afb1ca 535 "restoring signal mask");
200a76b7 536#endif
45afb1ca
EW
537}
538#endif /* GIT_WINDOWS_NATIVE */
a5487ddf
JS
539
540static inline void set_cloexec(int fd)
541{
542 int flags = fcntl(fd, F_GETFD);
543 if (flags >= 0)
544 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
545}
a5487ddf 546
507d7804 547static int wait_or_whine(pid_t pid, const char *argv0, int in_signal)
ab0b41da
JS
548{
549 int status, code = -1;
550 pid_t waiting;
551 int failed_errno = 0;
552
553 while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
554 ; /* nothing */
85db79a9 555 if (in_signal) {
be8fc53e
ÆAB
556 if (WIFEXITED(status))
557 code = WEXITSTATUS(status);
558 return code;
85db79a9 559 }
ab0b41da
JS
560
561 if (waiting < 0) {
562 failed_errno = errno;
fbcb0e06 563 error_errno("waitpid for %s failed", argv0);
ab0b41da
JS
564 } else if (waiting != pid) {
565 error("waitpid is confused (%s)", argv0);
566 } else if (WIFSIGNALED(status)) {
567 code = WTERMSIG(status);
ac78663b 568 if (code != SIGINT && code != SIGQUIT && code != SIGPIPE)
a2767c5c 569 error("%s died of signal %d", argv0, code);
ab0b41da
JS
570 /*
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.
574 */
709ca730 575 code += 128;
ab0b41da
JS
576 } else if (WIFEXITED(status)) {
577 code = WEXITSTATUS(status);
ab0b41da
JS
578 } else {
579 error("waitpid is confused (%s)", argv0);
580 }
afe19ff7
JK
581
582 clear_child_for_cleanup(pid);
583
ab0b41da
JS
584 errno = failed_errno;
585 return code;
586}
587
c61a975d
NTND
588static void trace_add_env(struct strbuf *dst, const char *const *deltaenv)
589{
590 struct string_list envs = STRING_LIST_INIT_DUP;
591 const char *const *e;
592 int i;
593 int printed_unset = 0;
594
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, '=');
599
600 if (equals) {
601 strbuf_add(&key, *e, equals - *e);
602 string_list_insert(&envs, key.buf)->util = equals + 1;
603 } else {
604 string_list_insert(&envs, *e)->util = NULL;
605 }
606 strbuf_release(&key);
607 }
608
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;
613
614 if (val || !getenv(var))
615 continue;
616
617 if (!printed_unset) {
618 strbuf_addstr(dst, " unset");
619 printed_unset = 1;
620 }
621 strbuf_addf(dst, " %s", var);
622 }
623 if (printed_unset)
624 strbuf_addch(dst, ';');
625
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;
630 const char *oldval;
631
632 if (!val)
633 continue;
634
635 oldval = getenv(var);
636 if (oldval && !strcmp(val, oldval))
637 continue;
638
639 strbuf_addf(dst, " %s=", var);
640 sq_quote_buf_pretty(dst, val);
641 }
642 string_list_clear(&envs, 0);
643}
644
e73dd786
NTND
645static void trace_run_command(const struct child_process *cp)
646{
647 struct strbuf buf = STRBUF_INIT;
648
649 if (!trace_want(&trace_default_key))
650 return;
651
248f66ed 652 strbuf_addstr(&buf, "trace: run_command:");
090a0927
NTND
653 if (cp->dir) {
654 strbuf_addstr(&buf, " cd ");
655 sq_quote_buf_pretty(&buf, cp->dir);
656 strbuf_addch(&buf, ';');
657 }
c61a975d
NTND
658 /*
659 * The caller is responsible for initializing cp->env from
660 * cp->env_array if needed. We only check one place.
661 */
662 if (cp->env)
663 trace_add_env(&buf, cp->env);
21dfc5e0
NTND
664 if (cp->git_cmd)
665 strbuf_addstr(&buf, " git");
e73dd786
NTND
666 sq_quote_argv_pretty(&buf, cp->argv);
667
668 trace_printf("%s", buf.buf);
669 strbuf_release(&buf);
670}
671
ebcb5d16 672int start_command(struct child_process *cmd)
b1bf95bb 673{
f3b33f1d
JS
674 int need_in, need_out, need_err;
675 int fdin[2], fdout[2], fderr[2];
25043d8a 676 int failed_errno;
939296c4 677 char *str;
4919bf03 678
c460c0ec 679 if (!cmd->argv)
d70a9eb6 680 cmd->argv = cmd->args.v;
19a583dc 681 if (!cmd->env)
d70a9eb6 682 cmd->env = cmd->env_array.v;
c460c0ec 683
c20181e3
JS
684 /*
685 * In case of errors we must keep the promise to close FDs
686 * that have been passed in via ->in and ->out.
687 */
688
e4507ae8 689 need_in = !cmd->no_stdin && cmd->in < 0;
4919bf03 690 if (need_in) {
c20181e3 691 if (pipe(fdin) < 0) {
0ac77ec3 692 failed_errno = errno;
c20181e3
JS
693 if (cmd->out > 0)
694 close(cmd->out);
939296c4 695 str = "standard input";
0ac77ec3 696 goto fail_pipe;
c20181e3 697 }
4919bf03 698 cmd->in = fdin[1];
4919bf03
SP
699 }
700
e4507ae8
SP
701 need_out = !cmd->no_stdout
702 && !cmd->stdout_to_stderr
703 && cmd->out < 0;
f4bba25b
SP
704 if (need_out) {
705 if (pipe(fdout) < 0) {
0ac77ec3 706 failed_errno = errno;
f4bba25b
SP
707 if (need_in)
708 close_pair(fdin);
c20181e3
JS
709 else if (cmd->in)
710 close(cmd->in);
939296c4 711 str = "standard output";
0ac77ec3 712 goto fail_pipe;
f4bba25b
SP
713 }
714 cmd->out = fdout[0];
f4bba25b
SP
715 }
716
b73a4397 717 need_err = !cmd->no_stderr && cmd->err < 0;
f3b33f1d
JS
718 if (need_err) {
719 if (pipe(fderr) < 0) {
0ac77ec3 720 failed_errno = errno;
f3b33f1d
JS
721 if (need_in)
722 close_pair(fdin);
c20181e3
JS
723 else if (cmd->in)
724 close(cmd->in);
f3b33f1d
JS
725 if (need_out)
726 close_pair(fdout);
c20181e3
JS
727 else if (cmd->out)
728 close(cmd->out);
939296c4 729 str = "standard error";
0ac77ec3 730fail_pipe:
939296c4
SB
731 error("cannot create %s pipe for %s: %s",
732 str, cmd->argv[0], strerror(failed_errno));
2d71608e 733 child_process_clear(cmd);
0ac77ec3
JS
734 errno = failed_errno;
735 return -1;
f3b33f1d
JS
736 }
737 cmd->err = fderr[0];
738 }
739
ee4512ed 740 trace2_child_start(cmd);
e73dd786
NTND
741 trace_run_command(cmd);
742
13af8cbd 743 fflush(NULL);
8852f5d7 744
28d04e1e
JS
745 if (cmd->close_object_store)
746 close_object_store(the_repository->objects);
747
380395d0 748#ifndef GIT_WINDOWS_NATIVE
2b541bf8
JS
749{
750 int notify_pipe[2];
db015a28 751 int null_fd = -1;
ae25394b 752 char **childenv;
c972bf4c 753 struct strvec argv = STRVEC_INIT;
79319b19 754 struct child_err cerr;
45afb1ca 755 struct atfork_state as;
3967e25b 756
321fd823
JK
757 if (prepare_cmd(&argv, cmd) < 0) {
758 failed_errno = errno;
759 cmd->pid = -1;
e5a329a2
JH
760 if (!cmd->silent_exec_failure)
761 error_errno("cannot run %s", cmd->argv[0]);
321fd823
JK
762 goto end_of_spawn;
763 }
764
2b541bf8
JS
765 if (pipe(notify_pipe))
766 notify_pipe[0] = notify_pipe[1] = -1;
767
db015a28 768 if (cmd->no_stdin || cmd->no_stdout || cmd->no_stderr) {
66e905b7 769 null_fd = xopen("/dev/null", O_RDWR | O_CLOEXEC);
db015a28
BW
770 set_cloexec(null_fd);
771 }
772
ae25394b 773 childenv = prep_childenv(cmd->env);
45afb1ca 774 atfork_prepare(&as);
3967e25b 775
e503cd6e
BW
776 /*
777 * NOTE: In order to prevent deadlocking when using threads special
778 * care should be taken with the function calls made in between the
779 * fork() and exec() calls. No calls should be made to functions which
780 * require acquiring a lock (e.g. malloc) as the lock could have been
781 * held by another thread at the time of forking, causing the lock to
782 * never be released in the child process. This means only
783 * Async-Signal-Safe functions are permitted in the child.
784 */
ebcb5d16 785 cmd->pid = fork();
25043d8a 786 failed_errno = errno;
ebcb5d16 787 if (!cmd->pid) {
45afb1ca 788 int sig;
a5487ddf 789 /*
79319b19
BW
790 * Ensure the default die/error/warn routines do not get
791 * called, they can take stdio locks and malloc.
a5487ddf 792 */
79319b19
BW
793 set_die_routine(child_die_fn);
794 set_error_routine(child_error_fn);
795 set_warn_routine(child_warn_fn);
a5487ddf 796
2b541bf8
JS
797 close(notify_pipe[0]);
798 set_cloexec(notify_pipe[1]);
799 child_notifier = notify_pipe[1];
2b541bf8 800
e4507ae8 801 if (cmd->no_stdin)
53fa6753 802 child_dup2(null_fd, 0);
e4507ae8 803 else if (need_in) {
53fa6753
BW
804 child_dup2(fdin[0], 0);
805 child_close_pair(fdin);
4919bf03 806 } else if (cmd->in) {
53fa6753
BW
807 child_dup2(cmd->in, 0);
808 child_close(cmd->in);
95d3c4f5 809 }
4919bf03 810
ce2cf27a 811 if (cmd->no_stderr)
53fa6753 812 child_dup2(null_fd, 2);
ce2cf27a 813 else if (need_err) {
53fa6753
BW
814 child_dup2(fderr[1], 2);
815 child_close_pair(fderr);
4f41b611 816 } else if (cmd->err > 1) {
53fa6753
BW
817 child_dup2(cmd->err, 2);
818 child_close(cmd->err);
ce2cf27a
CC
819 }
820
e4507ae8 821 if (cmd->no_stdout)
53fa6753 822 child_dup2(null_fd, 1);
e4507ae8 823 else if (cmd->stdout_to_stderr)
53fa6753 824 child_dup2(2, 1);
f4bba25b 825 else if (need_out) {
53fa6753
BW
826 child_dup2(fdout[1], 1);
827 child_close_pair(fdout);
f4bba25b 828 } else if (cmd->out > 1) {
53fa6753
BW
829 child_dup2(cmd->out, 1);
830 child_close(cmd->out);
f4bba25b
SP
831 }
832
1568fea0 833 if (cmd->dir && chdir(cmd->dir))
79319b19 834 child_die(CHILD_ERR_CHDIR);
3967e25b 835
45afb1ca
EW
836 /*
837 * restore default signal handlers here, in case
838 * we catch a signal right before execve below
839 */
840 for (sig = 1; sig < NSIG; sig++) {
841 /* ignored signals get reset to SIG_DFL on execve */
842 if (signal(sig, SIG_DFL) == SIG_IGN)
843 signal(sig, SIG_IGN);
844 }
845
846 if (sigprocmask(SIG_SETMASK, &as.old, NULL) != 0)
847 child_die(CHILD_ERR_SIGPROCMASK);
848
e3a43446
BW
849 /*
850 * Attempt to exec using the command and arguments starting at
851 * argv.argv[1]. argv.argv[0] contains SHELL_PATH which will
852 * be used in the event exec failed with ENOEXEC at which point
853 * we will try to interpret the command using 'sh'.
854 */
d70a9eb6 855 execve(argv.v[1], (char *const *) argv.v + 1,
ae25394b 856 (char *const *) childenv);
e3a43446 857 if (errno == ENOEXEC)
d70a9eb6 858 execve(argv.v[0], (char *const *) argv.v,
ae25394b 859 (char *const *) childenv);
3967e25b 860
fc1b56f0 861 if (errno == ENOENT) {
79319b19
BW
862 if (cmd->silent_exec_failure)
863 child_die(CHILD_ERR_SILENT);
864 child_die(CHILD_ERR_ENOENT);
fc1b56f0 865 } else {
79319b19 866 child_die(CHILD_ERR_ERRNO);
fc1b56f0 867 }
b1bf95bb 868 }
45afb1ca 869 atfork_parent(&as);
0ac77ec3 870 if (cmd->pid < 0)
fbcb0e06 871 error_errno("cannot fork() for %s", cmd->argv[0]);
afe19ff7 872 else if (cmd->clean_on_exit)
ac2fbaa6 873 mark_child_for_cleanup(cmd->pid, cmd);
2b541bf8
JS
874
875 /*
3967e25b 876 * Wait for child's exec. If the exec succeeds (or if fork()
2b541bf8 877 * failed), EOF is seen immediately by the parent. Otherwise, the
79319b19 878 * child process sends a child_err struct.
2b541bf8
JS
879 * Note that use of this infrastructure is completely advisory,
880 * therefore, we keep error checks minimal.
881 */
882 close(notify_pipe[1]);
79319b19 883 if (xread(notify_pipe[0], &cerr, sizeof(cerr)) == sizeof(cerr)) {
2b541bf8 884 /*
3967e25b 885 * At this point we know that fork() succeeded, but exec()
2b541bf8
JS
886 * failed. Errors have been reported to our stderr.
887 */
507d7804 888 wait_or_whine(cmd->pid, cmd->argv[0], 0);
79319b19 889 child_err_spew(cmd, &cerr);
2b541bf8
JS
890 failed_errno = errno;
891 cmd->pid = -1;
892 }
893 close(notify_pipe[0]);
3967e25b 894
db015a28
BW
895 if (null_fd >= 0)
896 close(null_fd);
c972bf4c 897 strvec_clear(&argv);
ae25394b 898 free(childenv);
2b541bf8 899}
321fd823
JK
900end_of_spawn:
901
ba26f296 902#else
0d30ad71 903{
75301f90 904 int fhin = 0, fhout = 1, fherr = 2;
108ac313 905 const char **sargv = cmd->argv;
c972bf4c 906 struct strvec nargv = STRVEC_INIT;
ba26f296 907
75301f90
JS
908 if (cmd->no_stdin)
909 fhin = open("/dev/null", O_RDWR);
910 else if (need_in)
911 fhin = dup(fdin[0]);
912 else if (cmd->in)
913 fhin = dup(cmd->in);
914
915 if (cmd->no_stderr)
916 fherr = open("/dev/null", O_RDWR);
917 else if (need_err)
918 fherr = dup(fderr[1]);
76d44c8c
JH
919 else if (cmd->err > 2)
920 fherr = dup(cmd->err);
75301f90
JS
921
922 if (cmd->no_stdout)
923 fhout = open("/dev/null", O_RDWR);
924 else if (cmd->stdout_to_stderr)
925 fhout = dup(fherr);
926 else if (need_out)
927 fhout = dup(fdout[1]);
928 else if (cmd->out > 1)
929 fhout = dup(cmd->out);
ba26f296 930
5a50085c 931 if (cmd->git_cmd)
20574f55 932 cmd->argv = prepare_git_cmd(&nargv, cmd->argv);
5a50085c 933 else if (cmd->use_shell)
20574f55 934 cmd->argv = prepare_shell_cmd(&nargv, cmd->argv);
ba26f296 935
77734da2
KB
936 cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, (char**) cmd->env,
937 cmd->dir, fhin, fhout, fherr);
0ac77ec3 938 failed_errno = errno;
c024beb5 939 if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
fbcb0e06 940 error_errno("cannot spawn %s", cmd->argv[0]);
afe19ff7 941 if (cmd->clean_on_exit && cmd->pid >= 0)
ac2fbaa6 942 mark_child_for_cleanup(cmd->pid, cmd);
ba26f296 943
c972bf4c 944 strvec_clear(&nargv);
108ac313 945 cmd->argv = sargv;
75301f90
JS
946 if (fhin != 0)
947 close(fhin);
948 if (fhout != 1)
949 close(fhout);
950 if (fherr != 2)
951 close(fherr);
0d30ad71 952}
ba26f296
JS
953#endif
954
955 if (cmd->pid < 0) {
ee4512ed
JH
956 trace2_child_exit(cmd, -1);
957
ba26f296
JS
958 if (need_in)
959 close_pair(fdin);
960 else if (cmd->in)
961 close(cmd->in);
962 if (need_out)
963 close_pair(fdout);
964 else if (cmd->out)
965 close(cmd->out);
966 if (need_err)
967 close_pair(fderr);
fc012c28
D
968 else if (cmd->err)
969 close(cmd->err);
2d71608e 970 child_process_clear(cmd);
0ac77ec3
JS
971 errno = failed_errno;
972 return -1;
ba26f296 973 }
4919bf03
SP
974
975 if (need_in)
976 close(fdin[0]);
977 else if (cmd->in)
978 close(cmd->in);
979
f4bba25b
SP
980 if (need_out)
981 close(fdout[1]);
c20181e3 982 else if (cmd->out)
f4bba25b
SP
983 close(cmd->out);
984
f3b33f1d
JS
985 if (need_err)
986 close(fderr[1]);
4f41b611
SP
987 else if (cmd->err)
988 close(cmd->err);
f3b33f1d 989
ebcb5d16
SP
990 return 0;
991}
992
2d22c208
JS
993int finish_command(struct child_process *cmd)
994{
507d7804 995 int ret = wait_or_whine(cmd->pid, cmd->argv[0], 0);
ee4512ed 996 trace2_child_exit(cmd, ret);
2d71608e 997 child_process_clear(cmd);
0d58fef5 998 invalidate_lstat_cache();
c460c0ec 999 return ret;
2d22c208
JS
1000}
1001
507d7804
TI
1002int finish_command_in_signal(struct child_process *cmd)
1003{
ee4512ed
JH
1004 int ret = wait_or_whine(cmd->pid, cmd->argv[0], 1);
1005 trace2_child_exit(cmd, ret);
1006 return ret;
507d7804
TI
1007}
1008
1009
ebcb5d16
SP
1010int run_command(struct child_process *cmd)
1011{
c29b3962
JK
1012 int code;
1013
1014 if (cmd->out < 0 || cmd->err < 0)
033abf97 1015 BUG("run_command with a pipe can cause deadlock");
c29b3962
JK
1016
1017 code = start_command(cmd);
ebcb5d16
SP
1018 if (code)
1019 return code;
1020 return finish_command(cmd);
1021}
1022
f1000898
SP
1023int run_command_v_opt(const char **argv, int opt)
1024{
41e9bad7 1025 return run_command_v_opt_cd_env(argv, opt, NULL, NULL);
1568fea0
AR
1026}
1027
ee4512ed
JH
1028int run_command_v_opt_tr2(const char **argv, int opt, const char *tr2_class)
1029{
1030 return run_command_v_opt_cd_env_tr2(argv, opt, NULL, NULL, tr2_class);
1031}
1032
ee493148 1033int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
ee4512ed
JH
1034{
1035 return run_command_v_opt_cd_env_tr2(argv, opt, dir, env, NULL);
1036}
1037
1038int run_command_v_opt_cd_env_tr2(const char **argv, int opt, const char *dir,
1039 const char *const *env, const char *tr2_class)
ee493148 1040{
1f87293d
RS
1041 struct child_process cmd = CHILD_PROCESS_INIT;
1042 cmd.argv = argv;
1043 cmd.no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
1044 cmd.git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
1045 cmd.stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
1046 cmd.silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
1047 cmd.use_shell = opt & RUN_USING_SHELL ? 1 : 0;
1048 cmd.clean_on_exit = opt & RUN_CLEAN_ON_EXIT ? 1 : 0;
e662df7e 1049 cmd.wait_after_clean = opt & RUN_WAIT_AFTER_CLEAN ? 1 : 0;
28d04e1e 1050 cmd.close_object_store = opt & RUN_CLOSE_OBJECT_STORE ? 1 : 0;
ee493148
AR
1051 cmd.dir = dir;
1052 cmd.env = env;
ee4512ed 1053 cmd.trace2_child_class = tr2_class;
ee493148
AR
1054 return run_command(&cmd);
1055}
2d22c208 1056
f6b60983 1057#ifndef NO_PTHREADS
0ea1c89b
JS
1058static pthread_t main_thread;
1059static int main_thread_set;
1060static pthread_key_t async_key;
1ece66bc 1061static pthread_key_t async_die_counter;
0ea1c89b 1062
200a76b7 1063static void *run_thread(void *data)
618ebe9f
JS
1064{
1065 struct async *async = data;
f6b60983 1066 intptr_t ret;
0ea1c89b 1067
c792d7b6
JK
1068 if (async->isolate_sigpipe) {
1069 sigset_t mask;
1070 sigemptyset(&mask);
1071 sigaddset(&mask, SIGPIPE);
1072 if (pthread_sigmask(SIG_BLOCK, &mask, NULL) < 0) {
1073 ret = error("unable to block SIGPIPE in async thread");
1074 return (void *)ret;
1075 }
1076 }
1077
0ea1c89b 1078 pthread_setspecific(async_key, async);
f6b60983 1079 ret = async->proc(async->proc_in, async->proc_out, async->data);
200a76b7 1080 return (void *)ret;
618ebe9f 1081}
0ea1c89b
JS
1082
1083static NORETURN void die_async(const char *err, va_list params)
1084{
1085 vreportf("fatal: ", err, params);
1086
661a8cf4 1087 if (in_async()) {
0ea1c89b
JS
1088 struct async *async = pthread_getspecific(async_key);
1089 if (async->proc_in >= 0)
1090 close(async->proc_in);
1091 if (async->proc_out >= 0)
1092 close(async->proc_out);
1093 pthread_exit((void *)128);
1094 }
1095
1096 exit(128);
618ebe9f 1097}
1ece66bc
JK
1098
1099static int async_die_is_recursing(void)
1100{
1101 void *ret = pthread_getspecific(async_die_counter);
4b540cf9 1102 pthread_setspecific(async_die_counter, &async_die_counter); /* set to any non-NULL valid pointer */
1ece66bc
JK
1103 return ret != NULL;
1104}
1105
661a8cf4
JK
1106int in_async(void)
1107{
1108 if (!main_thread_set)
1109 return 0; /* no asyncs started yet */
1110 return !pthread_equal(main_thread, pthread_self());
1111}
1112
b992fe10 1113static void NORETURN async_exit(int code)
9658846c
JK
1114{
1115 pthread_exit((void *)(intptr_t)code);
1116}
1117
0f4b6db3
EB
1118#else
1119
1120static struct {
1121 void (**handlers)(void);
1122 size_t nr;
1123 size_t alloc;
1124} git_atexit_hdlrs;
1125
1126static int git_atexit_installed;
1127
6066a7ea 1128static void git_atexit_dispatch(void)
0f4b6db3
EB
1129{
1130 size_t i;
1131
1132 for (i=git_atexit_hdlrs.nr ; i ; i--)
1133 git_atexit_hdlrs.handlers[i-1]();
1134}
1135
6066a7ea 1136static void git_atexit_clear(void)
0f4b6db3
EB
1137{
1138 free(git_atexit_hdlrs.handlers);
1139 memset(&git_atexit_hdlrs, 0, sizeof(git_atexit_hdlrs));
1140 git_atexit_installed = 0;
1141}
1142
1143#undef atexit
1144int git_atexit(void (*handler)(void))
1145{
1146 ALLOC_GROW(git_atexit_hdlrs.handlers, git_atexit_hdlrs.nr + 1, git_atexit_hdlrs.alloc);
1147 git_atexit_hdlrs.handlers[git_atexit_hdlrs.nr++] = handler;
1148 if (!git_atexit_installed) {
1149 if (atexit(&git_atexit_dispatch))
1150 return -1;
1151 git_atexit_installed = 1;
1152 }
1153 return 0;
1154}
1155#define atexit git_atexit
1156
661a8cf4
JK
1157static int process_is_async;
1158int in_async(void)
1159{
1160 return process_is_async;
1161}
1162
b992fe10 1163static void NORETURN async_exit(int code)
9658846c
JK
1164{
1165 exit(code);
1166}
1167
618ebe9f
JS
1168#endif
1169
b992fe10
LS
1170void check_pipe(int err)
1171{
1172 if (err == EPIPE) {
1173 if (in_async())
1174 async_exit(141);
1175
1176 signal(SIGPIPE, SIG_DFL);
1177 raise(SIGPIPE);
1178 /* Should never happen, but just in case... */
1179 exit(141);
1180 }
1181}
1182
2d22c208
JS
1183int start_async(struct async *async)
1184{
ae6a5609
EFL
1185 int need_in, need_out;
1186 int fdin[2], fdout[2];
1187 int proc_in, proc_out;
2d22c208 1188
ae6a5609
EFL
1189 need_in = async->in < 0;
1190 if (need_in) {
1191 if (pipe(fdin) < 0) {
1192 if (async->out > 0)
1193 close(async->out);
fbcb0e06 1194 return error_errno("cannot create pipe");
ae6a5609
EFL
1195 }
1196 async->in = fdin[1];
1197 }
1198
1199 need_out = async->out < 0;
1200 if (need_out) {
1201 if (pipe(fdout) < 0) {
1202 if (need_in)
1203 close_pair(fdin);
1204 else if (async->in)
1205 close(async->in);
fbcb0e06 1206 return error_errno("cannot create pipe");
ae6a5609
EFL
1207 }
1208 async->out = fdout[0];
1209 }
1210
1211 if (need_in)
1212 proc_in = fdin[0];
1213 else if (async->in)
1214 proc_in = async->in;
1215 else
1216 proc_in = -1;
1217
1218 if (need_out)
1219 proc_out = fdout[1];
1220 else if (async->out)
1221 proc_out = async->out;
1222 else
1223 proc_out = -1;
2d22c208 1224
f6b60983 1225#ifdef NO_PTHREADS
2c3766f0
AM
1226 /* Flush stdio before fork() to avoid cloning buffers */
1227 fflush(NULL);
1228
2d22c208
JS
1229 async->pid = fork();
1230 if (async->pid < 0) {
fbcb0e06 1231 error_errno("fork (async) failed");
ae6a5609 1232 goto error;
2d22c208
JS
1233 }
1234 if (!async->pid) {
ae6a5609
EFL
1235 if (need_in)
1236 close(fdin[1]);
1237 if (need_out)
1238 close(fdout[0]);
0f4b6db3 1239 git_atexit_clear();
661a8cf4 1240 process_is_async = 1;
ae6a5609 1241 exit(!!async->proc(proc_in, proc_out, async->data));
2d22c208 1242 }
ae6a5609 1243
ac2fbaa6 1244 mark_child_for_cleanup(async->pid, NULL);
afe19ff7 1245
ae6a5609
EFL
1246 if (need_in)
1247 close(fdin[0]);
1248 else if (async->in)
1249 close(async->in);
1250
1251 if (need_out)
1252 close(fdout[1]);
1253 else if (async->out)
1254 close(async->out);
618ebe9f 1255#else
0ea1c89b
JS
1256 if (!main_thread_set) {
1257 /*
1258 * We assume that the first time that start_async is called
1259 * it is from the main thread.
1260 */
1261 main_thread_set = 1;
1262 main_thread = pthread_self();
1263 pthread_key_create(&async_key, NULL);
1ece66bc 1264 pthread_key_create(&async_die_counter, NULL);
0ea1c89b 1265 set_die_routine(die_async);
1ece66bc 1266 set_die_is_recursing_routine(async_die_is_recursing);
0ea1c89b
JS
1267 }
1268
200a76b7
JS
1269 if (proc_in >= 0)
1270 set_cloexec(proc_in);
1271 if (proc_out >= 0)
1272 set_cloexec(proc_out);
ae6a5609
EFL
1273 async->proc_in = proc_in;
1274 async->proc_out = proc_out;
200a76b7
JS
1275 {
1276 int err = pthread_create(&async->tid, NULL, run_thread, async);
1277 if (err) {
2179045f 1278 error(_("cannot create async thread: %s"), strerror(err));
200a76b7
JS
1279 goto error;
1280 }
618ebe9f
JS
1281 }
1282#endif
2d22c208 1283 return 0;
ae6a5609
EFL
1284
1285error:
1286 if (need_in)
1287 close_pair(fdin);
1288 else if (async->in)
1289 close(async->in);
1290
1291 if (need_out)
1292 close_pair(fdout);
1293 else if (async->out)
1294 close(async->out);
1295 return -1;
2d22c208
JS
1296}
1297
1298int finish_async(struct async *async)
1299{
f6b60983 1300#ifdef NO_PTHREADS
0d58fef5
JS
1301 int ret = wait_or_whine(async->pid, "child process", 0);
1302
1303 invalidate_lstat_cache();
1304
1305 return ret;
618ebe9f 1306#else
200a76b7
JS
1307 void *ret = (void *)(intptr_t)(-1);
1308
1309 if (pthread_join(async->tid, &ret))
1310 error("pthread_join failed");
0d58fef5 1311 invalidate_lstat_cache();
200a76b7 1312 return (int)(intptr_t)ret;
0d58fef5 1313
618ebe9f 1314#endif
2d22c208 1315}
ae98a008 1316
c0e40a2d
NTND
1317int async_with_fork(void)
1318{
1319#ifdef NO_PTHREADS
1320 return 1;
1321#else
1322 return 0;
1323#endif
1324}
1325
15048f8a 1326int run_hook_ve(const char *const *env, const char *name, va_list args)
ae98a008 1327{
d3180279 1328 struct child_process hook = CHILD_PROCESS_INIT;
15048f8a 1329 const char *p;
ae98a008 1330
5a7da2dc
AS
1331 p = find_hook(name);
1332 if (!p)
cf94ca8e
SB
1333 return 0;
1334
c972bf4c 1335 strvec_push(&hook.args, p);
d1d09456 1336 while ((p = va_arg(args, const char *)))
c972bf4c 1337 strvec_push(&hook.args, p);
15048f8a 1338 hook.env = env;
ae98a008
SB
1339 hook.no_stdin = 1;
1340 hook.stdout_to_stderr = 1;
ee4512ed 1341 hook.trace2_hook_name = name;
ae98a008 1342
d1d09456 1343 return run_command(&hook);
ae98a008 1344}
15048f8a
BP
1345
1346int run_hook_le(const char *const *env, const char *name, ...)
1347{
1348 va_list args;
1349 int ret;
1350
1351 va_start(args, name);
1352 ret = run_hook_ve(env, name, args);
1353 va_end(args);
1354
1355 return ret;
1356}
911ec99b 1357
96335bcf
JK
1358struct io_pump {
1359 /* initialized by caller */
1360 int fd;
1361 int type; /* POLLOUT or POLLIN */
1362 union {
1363 struct {
1364 const char *buf;
1365 size_t len;
1366 } out;
1367 struct {
1368 struct strbuf *buf;
1369 size_t hint;
1370 } in;
1371 } u;
1372
1373 /* returned by pump_io */
1374 int error; /* 0 for success, otherwise errno */
1375
1376 /* internal use */
1377 struct pollfd *pfd;
1378};
1379
1380static int pump_io_round(struct io_pump *slots, int nr, struct pollfd *pfd)
1381{
1382 int pollsize = 0;
1383 int i;
1384
1385 for (i = 0; i < nr; i++) {
1386 struct io_pump *io = &slots[i];
1387 if (io->fd < 0)
1388 continue;
1389 pfd[pollsize].fd = io->fd;
1390 pfd[pollsize].events = io->type;
1391 io->pfd = &pfd[pollsize++];
1392 }
1393
1394 if (!pollsize)
1395 return 0;
1396
1397 if (poll(pfd, pollsize, -1) < 0) {
1398 if (errno == EINTR)
1399 return 1;
1400 die_errno("poll failed");
1401 }
1402
1403 for (i = 0; i < nr; i++) {
1404 struct io_pump *io = &slots[i];
1405
1406 if (io->fd < 0)
1407 continue;
1408
1409 if (!(io->pfd->revents & (POLLOUT|POLLIN|POLLHUP|POLLERR|POLLNVAL)))
1410 continue;
1411
1412 if (io->type == POLLOUT) {
1413 ssize_t len = xwrite(io->fd,
1414 io->u.out.buf, io->u.out.len);
1415 if (len < 0) {
1416 io->error = errno;
1417 close(io->fd);
1418 io->fd = -1;
1419 } else {
1420 io->u.out.buf += len;
1421 io->u.out.len -= len;
1422 if (!io->u.out.len) {
1423 close(io->fd);
1424 io->fd = -1;
1425 }
1426 }
1427 }
1428
1429 if (io->type == POLLIN) {
1430 ssize_t len = strbuf_read_once(io->u.in.buf,
1431 io->fd, io->u.in.hint);
1432 if (len < 0)
1433 io->error = errno;
1434 if (len <= 0) {
1435 close(io->fd);
1436 io->fd = -1;
1437 }
1438 }
1439 }
1440
1441 return 1;
1442}
1443
1444static int pump_io(struct io_pump *slots, int nr)
911ec99b 1445{
96335bcf
JK
1446 struct pollfd *pfd;
1447 int i;
1448
1449 for (i = 0; i < nr; i++)
1450 slots[i].error = 0;
1451
1452 ALLOC_ARRAY(pfd, nr);
1453 while (pump_io_round(slots, nr, pfd))
1454 ; /* nothing */
1455 free(pfd);
1456
1457 /* There may be multiple errno values, so just pick the first. */
1458 for (i = 0; i < nr; i++) {
1459 if (slots[i].error) {
1460 errno = slots[i].error;
1461 return -1;
1462 }
1463 }
1464 return 0;
1465}
1466
1467
1468int pipe_command(struct child_process *cmd,
1469 const char *in, size_t in_len,
1470 struct strbuf *out, size_t out_hint,
1471 struct strbuf *err, size_t err_hint)
1472{
1473 struct io_pump io[3];
1474 int nr = 0;
1475
1476 if (in)
1477 cmd->in = -1;
1478 if (out)
1479 cmd->out = -1;
1480 if (err)
1481 cmd->err = -1;
1482
911ec99b
JK
1483 if (start_command(cmd) < 0)
1484 return -1;
1485
96335bcf
JK
1486 if (in) {
1487 io[nr].fd = cmd->in;
1488 io[nr].type = POLLOUT;
1489 io[nr].u.out.buf = in;
1490 io[nr].u.out.len = in_len;
1491 nr++;
1492 }
1493 if (out) {
1494 io[nr].fd = cmd->out;
1495 io[nr].type = POLLIN;
1496 io[nr].u.in.buf = out;
1497 io[nr].u.in.hint = out_hint;
1498 nr++;
1499 }
1500 if (err) {
1501 io[nr].fd = cmd->err;
1502 io[nr].type = POLLIN;
1503 io[nr].u.in.buf = err;
1504 io[nr].u.in.hint = err_hint;
1505 nr++;
1506 }
1507
1508 if (pump_io(io, nr) < 0) {
911ec99b
JK
1509 finish_command(cmd); /* throw away exit code */
1510 return -1;
1511 }
1512
911ec99b
JK
1513 return finish_command(cmd);
1514}
c553c72e
SB
1515
1516enum child_state {
1517 GIT_CP_FREE,
1518 GIT_CP_WORKING,
1519 GIT_CP_WAIT_CLEANUP,
1520};
1521
1522struct parallel_processes {
1523 void *data;
1524
1525 int max_processes;
1526 int nr_processes;
1527
1528 get_next_task_fn get_next_task;
1529 start_failure_fn start_failure;
1530 task_finished_fn task_finished;
1531
1532 struct {
1533 enum child_state state;
1534 struct child_process process;
1535 struct strbuf err;
1536 void *data;
1537 } *children;
1538 /*
1539 * The struct pollfd is logically part of *children,
1540 * but the system call expects it as its own array.
1541 */
1542 struct pollfd *pfd;
1543
1544 unsigned shutdown : 1;
1545
1546 int output_owner;
1547 struct strbuf buffered_output; /* of finished children */
1548};
1549
aa710494 1550static int default_start_failure(struct strbuf *out,
c553c72e
SB
1551 void *pp_cb,
1552 void *pp_task_cb)
1553{
c553c72e
SB
1554 return 0;
1555}
1556
1557static int default_task_finished(int result,
aa710494 1558 struct strbuf *out,
c553c72e
SB
1559 void *pp_cb,
1560 void *pp_task_cb)
1561{
c553c72e
SB
1562 return 0;
1563}
1564
1565static void kill_children(struct parallel_processes *pp, int signo)
1566{
1567 int i, n = pp->max_processes;
1568
1569 for (i = 0; i < n; i++)
1570 if (pp->children[i].state == GIT_CP_WORKING)
1571 kill(pp->children[i].process.pid, signo);
1572}
1573
1574static struct parallel_processes *pp_for_signal;
1575
1576static void handle_children_on_signal(int signo)
1577{
1578 kill_children(pp_for_signal, signo);
1579 sigchain_pop(signo);
1580 raise(signo);
1581}
1582
1583static void pp_init(struct parallel_processes *pp,
1584 int n,
1585 get_next_task_fn get_next_task,
1586 start_failure_fn start_failure,
1587 task_finished_fn task_finished,
1588 void *data)
1589{
1590 int i;
1591
1592 if (n < 1)
1593 n = online_cpus();
1594
1595 pp->max_processes = n;
1596
1597 trace_printf("run_processes_parallel: preparing to run up to %d tasks", n);
1598
1599 pp->data = data;
1600 if (!get_next_task)
033abf97 1601 BUG("you need to specify a get_next_task function");
c553c72e
SB
1602 pp->get_next_task = get_next_task;
1603
1604 pp->start_failure = start_failure ? start_failure : default_start_failure;
1605 pp->task_finished = task_finished ? task_finished : default_task_finished;
1606
1607 pp->nr_processes = 0;
1608 pp->output_owner = 0;
1609 pp->shutdown = 0;
ca56dadb
RS
1610 CALLOC_ARRAY(pp->children, n);
1611 CALLOC_ARRAY(pp->pfd, n);
c553c72e
SB
1612 strbuf_init(&pp->buffered_output, 0);
1613
1614 for (i = 0; i < n; i++) {
1615 strbuf_init(&pp->children[i].err, 0);
1616 child_process_init(&pp->children[i].process);
1617 pp->pfd[i].events = POLLIN | POLLHUP;
1618 pp->pfd[i].fd = -1;
1619 }
1620
1621 pp_for_signal = pp;
1622 sigchain_push_common(handle_children_on_signal);
1623}
1624
1625static void pp_cleanup(struct parallel_processes *pp)
1626{
1627 int i;
1628
1629 trace_printf("run_processes_parallel: done");
1630 for (i = 0; i < pp->max_processes; i++) {
1631 strbuf_release(&pp->children[i].err);
1632 child_process_clear(&pp->children[i].process);
1633 }
1634
1635 free(pp->children);
1636 free(pp->pfd);
1637
1638 /*
1639 * When get_next_task added messages to the buffer in its last
1640 * iteration, the buffered output is non empty.
1641 */
2dac9b56 1642 strbuf_write(&pp->buffered_output, stderr);
c553c72e
SB
1643 strbuf_release(&pp->buffered_output);
1644
1645 sigchain_pop_common();
1646}
1647
1648/* returns
1649 * 0 if a new task was started.
1650 * 1 if no new jobs was started (get_next_task ran out of work, non critical
1651 * problem with starting a new command)
1652 * <0 no new job was started, user wishes to shutdown early. Use negative code
1653 * to signal the children.
1654 */
1655static int pp_start_one(struct parallel_processes *pp)
1656{
1657 int i, code;
1658
1659 for (i = 0; i < pp->max_processes; i++)
1660 if (pp->children[i].state == GIT_CP_FREE)
1661 break;
1662 if (i == pp->max_processes)
033abf97 1663 BUG("bookkeeping is hard");
c553c72e
SB
1664
1665 code = pp->get_next_task(&pp->children[i].process,
1666 &pp->children[i].err,
1667 pp->data,
1668 &pp->children[i].data);
1669 if (!code) {
1670 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1671 strbuf_reset(&pp->children[i].err);
1672 return 1;
1673 }
1674 pp->children[i].process.err = -1;
1675 pp->children[i].process.stdout_to_stderr = 1;
1676 pp->children[i].process.no_stdin = 1;
1677
1678 if (start_command(&pp->children[i].process)) {
2a73b3da 1679 code = pp->start_failure(&pp->children[i].err,
c553c72e 1680 pp->data,
c1e860f1 1681 pp->children[i].data);
c553c72e
SB
1682 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1683 strbuf_reset(&pp->children[i].err);
1684 if (code)
1685 pp->shutdown = 1;
1686 return code;
1687 }
1688
1689 pp->nr_processes++;
1690 pp->children[i].state = GIT_CP_WORKING;
1691 pp->pfd[i].fd = pp->children[i].process.err;
1692 return 0;
1693}
1694
1695static void pp_buffer_stderr(struct parallel_processes *pp, int output_timeout)
1696{
1697 int i;
1698
1699 while ((i = poll(pp->pfd, pp->max_processes, output_timeout)) < 0) {
1700 if (errno == EINTR)
1701 continue;
1702 pp_cleanup(pp);
1703 die_errno("poll");
1704 }
1705
1706 /* Buffer output from all pipes. */
1707 for (i = 0; i < pp->max_processes; i++) {
1708 if (pp->children[i].state == GIT_CP_WORKING &&
1709 pp->pfd[i].revents & (POLLIN | POLLHUP)) {
1710 int n = strbuf_read_once(&pp->children[i].err,
1711 pp->children[i].process.err, 0);
1712 if (n == 0) {
1713 close(pp->children[i].process.err);
1714 pp->children[i].state = GIT_CP_WAIT_CLEANUP;
1715 } else if (n < 0)
1716 if (errno != EAGAIN)
1717 die_errno("read");
1718 }
1719 }
1720}
1721
1722static void pp_output(struct parallel_processes *pp)
1723{
1724 int i = pp->output_owner;
1725 if (pp->children[i].state == GIT_CP_WORKING &&
1726 pp->children[i].err.len) {
2dac9b56 1727 strbuf_write(&pp->children[i].err, stderr);
c553c72e
SB
1728 strbuf_reset(&pp->children[i].err);
1729 }
1730}
1731
1732static int pp_collect_finished(struct parallel_processes *pp)
1733{
1734 int i, code;
1735 int n = pp->max_processes;
1736 int result = 0;
1737
1738 while (pp->nr_processes > 0) {
1739 for (i = 0; i < pp->max_processes; i++)
1740 if (pp->children[i].state == GIT_CP_WAIT_CLEANUP)
1741 break;
1742 if (i == pp->max_processes)
1743 break;
1744
1745 code = finish_command(&pp->children[i].process);
1746
2a73b3da 1747 code = pp->task_finished(code,
c553c72e 1748 &pp->children[i].err, pp->data,
c1e860f1 1749 pp->children[i].data);
c553c72e
SB
1750
1751 if (code)
1752 result = code;
1753 if (code < 0)
1754 break;
1755
1756 pp->nr_processes--;
1757 pp->children[i].state = GIT_CP_FREE;
1758 pp->pfd[i].fd = -1;
1759 child_process_init(&pp->children[i].process);
1760
1761 if (i != pp->output_owner) {
1762 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1763 strbuf_reset(&pp->children[i].err);
1764 } else {
2dac9b56 1765 strbuf_write(&pp->children[i].err, stderr);
c553c72e
SB
1766 strbuf_reset(&pp->children[i].err);
1767
1768 /* Output all other finished child processes */
2dac9b56 1769 strbuf_write(&pp->buffered_output, stderr);
c553c72e
SB
1770 strbuf_reset(&pp->buffered_output);
1771
1772 /*
1773 * Pick next process to output live.
1774 * NEEDSWORK:
1775 * For now we pick it randomly by doing a round
1776 * robin. Later we may want to pick the one with
1777 * the most output or the longest or shortest
1778 * running process time.
1779 */
1780 for (i = 0; i < n; i++)
1781 if (pp->children[(pp->output_owner + i) % n].state == GIT_CP_WORKING)
1782 break;
1783 pp->output_owner = (pp->output_owner + i) % n;
1784 }
1785 }
1786 return result;
1787}
1788
1789int run_processes_parallel(int n,
1790 get_next_task_fn get_next_task,
1791 start_failure_fn start_failure,
1792 task_finished_fn task_finished,
1793 void *pp_cb)
1794{
1795 int i, code;
1796 int output_timeout = 100;
1797 int spawn_cap = 4;
1798 struct parallel_processes pp;
1799
1800 pp_init(&pp, n, get_next_task, start_failure, task_finished, pp_cb);
1801 while (1) {
1802 for (i = 0;
1803 i < spawn_cap && !pp.shutdown &&
1804 pp.nr_processes < pp.max_processes;
1805 i++) {
1806 code = pp_start_one(&pp);
1807 if (!code)
1808 continue;
1809 if (code < 0) {
1810 pp.shutdown = 1;
1811 kill_children(&pp, -code);
1812 }
1813 break;
1814 }
1815 if (!pp.nr_processes)
1816 break;
1817 pp_buffer_stderr(&pp, output_timeout);
1818 pp_output(&pp);
1819 code = pp_collect_finished(&pp);
1820 if (code) {
1821 pp.shutdown = 1;
1822 if (code < 0)
1823 kill_children(&pp, -code);
1824 }
1825 }
1826
1827 pp_cleanup(&pp);
1828 return 0;
1829}
ee4512ed
JH
1830
1831int run_processes_parallel_tr2(int n, get_next_task_fn get_next_task,
1832 start_failure_fn start_failure,
1833 task_finished_fn task_finished, void *pp_cb,
1834 const char *tr2_category, const char *tr2_label)
1835{
1836 int result;
1837
1838 trace2_region_enter_printf(tr2_category, tr2_label, NULL, "max:%d",
1839 ((n < 1) ? online_cpus() : n));
1840
1841 result = run_processes_parallel(n, get_next_task, start_failure,
1842 task_finished, pp_cb);
1843
1844 trace2_region_leave(tr2_category, tr2_label, NULL);
1845
1846 return result;
1847}
850b6ede 1848
a95ce124 1849int run_auto_maintenance(int quiet)
850b6ede 1850{
1942d483 1851 int enabled;
a95ce124 1852 struct child_process maint = CHILD_PROCESS_INIT;
850b6ede 1853
1942d483
DS
1854 if (!git_config_get_bool("maintenance.auto", &enabled) &&
1855 !enabled)
1856 return 0;
1857
a95ce124 1858 maint.git_cmd = 1;
5a22a334 1859 maint.close_object_store = 1;
a95ce124
DS
1860 strvec_pushl(&maint.args, "maintenance", "run", "--auto", NULL);
1861 strvec_push(&maint.args, quiet ? "--quiet" : "--no-quiet");
1862
1863 return run_command(&maint);
850b6ede 1864}
d1fa9435
JT
1865
1866void prepare_other_repo_env(struct strvec *env_array, const char *new_git_dir)
1867{
1868 const char * const *var;
1869
1870 for (var = local_repo_env; *var; var++) {
1871 if (strcmp(*var, CONFIG_DATA_ENVIRONMENT) &&
1872 strcmp(*var, CONFIG_COUNT_ENVIRONMENT))
1873 strvec_push(env_array, *var);
1874 }
1875 strvec_pushf(env_array, "%s=%s", GIT_DIR_ENVIRONMENT, new_git_dir);
1876}
fdb13226
JH
1877
1878enum start_bg_result start_bg_command(struct child_process *cmd,
1879 start_bg_wait_cb *wait_cb,
1880 void *cb_data,
1881 unsigned int timeout_sec)
1882{
1883 enum start_bg_result sbgr = SBGR_ERROR;
1884 int ret;
1885 int wait_status;
1886 pid_t pid_seen;
1887 time_t time_limit;
1888
1889 /*
1890 * We do not allow clean-on-exit because the child process
1891 * should persist in the background and possibly/probably
1892 * after this process exits. So we don't want to kill the
1893 * child during our atexit routine.
1894 */
1895 if (cmd->clean_on_exit)
1896 BUG("start_bg_command() does not allow non-zero clean_on_exit");
1897
1898 if (!cmd->trace2_child_class)
1899 cmd->trace2_child_class = "background";
1900
1901 ret = start_command(cmd);
1902 if (ret) {
1903 /*
1904 * We assume that if `start_command()` fails, we
1905 * either get a complete `trace2_child_start() /
1906 * trace2_child_exit()` pair or it fails before the
1907 * `trace2_child_start()` is emitted, so we do not
1908 * need to worry about it here.
1909 *
1910 * We also assume that `start_command()` does not add
1911 * us to the cleanup list. And that it calls
1912 * calls `child_process_clear()`.
1913 */
1914 sbgr = SBGR_ERROR;
1915 goto done;
1916 }
1917
1918 time(&time_limit);
1919 time_limit += timeout_sec;
1920
1921wait:
1922 pid_seen = waitpid(cmd->pid, &wait_status, WNOHANG);
1923
1924 if (!pid_seen) {
1925 /*
1926 * The child is currently running. Ask the callback
1927 * if the child is ready to do work or whether we
1928 * should keep waiting for it to boot up.
1929 */
1930 ret = (*wait_cb)(cmd, cb_data);
1931 if (!ret) {
1932 /*
1933 * The child is running and "ready".
1934 */
1935 trace2_child_ready(cmd, "ready");
1936 sbgr = SBGR_READY;
1937 goto done;
1938 } else if (ret > 0) {
1939 /*
1940 * The callback said to give it more time to boot up
1941 * (subject to our timeout limit).
1942 */
1943 time_t now;
1944
1945 time(&now);
1946 if (now < time_limit)
1947 goto wait;
1948
1949 /*
1950 * Our timeout has expired. We don't try to
1951 * kill the child, but rather let it continue
1952 * (hopefully) trying to startup.
1953 */
1954 trace2_child_ready(cmd, "timeout");
1955 sbgr = SBGR_TIMEOUT;
1956 goto done;
1957 } else {
1958 /*
1959 * The cb gave up on this child. It is still running,
1960 * but our cb got an error trying to probe it.
1961 */
1962 trace2_child_ready(cmd, "error");
1963 sbgr = SBGR_CB_ERROR;
1964 goto done;
1965 }
1966 }
1967
1968 else if (pid_seen == cmd->pid) {
1969 int child_code = -1;
1970
1971 /*
1972 * The child started, but exited or was terminated
1973 * before becoming "ready".
1974 *
1975 * We try to match the behavior of `wait_or_whine()`
1976 * WRT the handling of WIFSIGNALED() and WIFEXITED()
1977 * and convert the child's status to a return code for
1978 * tracing purposes and emit the `trace2_child_exit()`
1979 * event.
1980 *
1981 * We do not want the wait_or_whine() error message
1982 * because we will be called by client-side library
1983 * routines.
1984 */
1985 if (WIFEXITED(wait_status))
1986 child_code = WEXITSTATUS(wait_status);
1987 else if (WIFSIGNALED(wait_status))
1988 child_code = WTERMSIG(wait_status) + 128;
1989 trace2_child_exit(cmd, child_code);
1990
1991 sbgr = SBGR_DIED;
1992 goto done;
1993 }
1994
1995 else if (pid_seen < 0 && errno == EINTR)
1996 goto wait;
1997
1998 trace2_child_exit(cmd, -1);
1999 sbgr = SBGR_ERROR;
2000
2001done:
2002 child_process_clear(cmd);
2003 invalidate_lstat_cache();
2004 return sbgr;
2005}