t0061: run_command executes scripts without a #! line
[git/git.git] / run-command.c
CommitLineData
b1bf95bb
JW
1#include "cache.h"
2#include "run-command.h"
77cb17e9 3#include "exec_cmd.h"
afe19ff7 4#include "sigchain.h"
5d40a179 5#include "argv-array.h"
c553c72e
SB
6#include "thread-utils.h"
7#include "strbuf.h"
b1bf95bb 8
483bbd4e
RS
9void child_process_init(struct child_process *child)
10{
11 memset(child, 0, sizeof(*child));
12 argv_array_init(&child->args);
19a583dc 13 argv_array_init(&child->env_array);
483bbd4e
RS
14}
15
2d71608e
RS
16void child_process_clear(struct child_process *child)
17{
18 argv_array_clear(&child->args);
19 argv_array_clear(&child->env_array);
20}
21
afe19ff7
JK
22struct child_to_clean {
23 pid_t pid;
ac2fbaa6 24 struct child_process *process;
afe19ff7
JK
25 struct child_to_clean *next;
26};
27static struct child_to_clean *children_to_clean;
28static int installed_child_cleanup_handler;
29
507d7804 30static void cleanup_children(int sig, int in_signal)
afe19ff7 31{
46df6906
JK
32 struct child_to_clean *children_to_wait_for = NULL;
33
afe19ff7
JK
34 while (children_to_clean) {
35 struct child_to_clean *p = children_to_clean;
36 children_to_clean = p->next;
ac2fbaa6
LS
37
38 if (p->process && !in_signal) {
39 struct child_process *process = p->process;
40 if (process->clean_on_exit_handler) {
41 trace_printf(
42 "trace: run_command: running exit handler for pid %"
43 PRIuMAX, (uintmax_t)p->pid
44 );
45 process->clean_on_exit_handler(process);
46 }
47 }
48
afe19ff7 49 kill(p->pid, sig);
46df6906 50
7b91929b 51 if (p->process && p->process->wait_after_clean) {
46df6906
JK
52 p->next = children_to_wait_for;
53 children_to_wait_for = p;
54 } else {
55 if (!in_signal)
56 free(p);
57 }
58 }
59
60 while (children_to_wait_for) {
61 struct child_to_clean *p = children_to_wait_for;
62 children_to_wait_for = p->next;
63
64 while (waitpid(p->pid, NULL, 0) < 0 && errno == EINTR)
65 ; /* spin waiting for process exit or error */
66
507d7804
TI
67 if (!in_signal)
68 free(p);
afe19ff7
JK
69 }
70}
71
72static void cleanup_children_on_signal(int sig)
73{
507d7804 74 cleanup_children(sig, 1);
afe19ff7
JK
75 sigchain_pop(sig);
76 raise(sig);
77}
78
79static void cleanup_children_on_exit(void)
80{
507d7804 81 cleanup_children(SIGTERM, 0);
afe19ff7
JK
82}
83
ac2fbaa6 84static void mark_child_for_cleanup(pid_t pid, struct child_process *process)
afe19ff7
JK
85{
86 struct child_to_clean *p = xmalloc(sizeof(*p));
87 p->pid = pid;
ac2fbaa6 88 p->process = process;
afe19ff7
JK
89 p->next = children_to_clean;
90 children_to_clean = p;
91
92 if (!installed_child_cleanup_handler) {
93 atexit(cleanup_children_on_exit);
94 sigchain_push_common(cleanup_children_on_signal);
95 installed_child_cleanup_handler = 1;
96 }
97}
98
99static void clear_child_for_cleanup(pid_t pid)
100{
bdee397d 101 struct child_to_clean **pp;
afe19ff7 102
bdee397d
DG
103 for (pp = &children_to_clean; *pp; pp = &(*pp)->next) {
104 struct child_to_clean *clean_me = *pp;
105
106 if (clean_me->pid == pid) {
107 *pp = clean_me->next;
108 free(clean_me);
afe19ff7
JK
109 return;
110 }
111 }
112}
113
9dc09c76
SP
114static inline void close_pair(int fd[2])
115{
116 close(fd[0]);
117 close(fd[1]);
118}
119
380395d0 120#ifndef GIT_WINDOWS_NATIVE
e4507ae8
SP
121static inline void dup_devnull(int to)
122{
123 int fd = open("/dev/null", O_RDWR);
a77f106c
TR
124 if (fd < 0)
125 die_errno(_("open /dev/null failed"));
126 if (dup2(fd, to) < 0)
127 die_errno(_("dup2(%d,%d) failed"), fd, to);
e4507ae8
SP
128 close(fd);
129}
75301f90 130#endif
e4507ae8 131
38f865c2
JK
132static char *locate_in_PATH(const char *file)
133{
134 const char *p = getenv("PATH");
135 struct strbuf buf = STRBUF_INIT;
136
137 if (!p || !*p)
138 return NULL;
139
140 while (1) {
141 const char *end = strchrnul(p, ':');
142
143 strbuf_reset(&buf);
144
145 /* POSIX specifies an empty entry as the current directory. */
146 if (end != p) {
147 strbuf_add(&buf, p, end - p);
148 strbuf_addch(&buf, '/');
149 }
150 strbuf_addstr(&buf, file);
151
152 if (!access(buf.buf, F_OK))
153 return strbuf_detach(&buf, NULL);
154
155 if (!*end)
156 break;
157 p = end + 1;
158 }
159
160 strbuf_release(&buf);
161 return NULL;
162}
163
164static int exists_in_PATH(const char *file)
165{
166 char *r = locate_in_PATH(file);
167 free(r);
168 return r != NULL;
169}
170
171int sane_execvp(const char *file, char * const argv[])
172{
173 if (!execvp(file, argv))
174 return 0; /* cannot happen ;-) */
175
176 /*
177 * When a command can't be found because one of the directories
178 * listed in $PATH is unsearchable, execvp reports EACCES, but
179 * careful usability testing (read: analysis of occasional bug
180 * reports) reveals that "No such file or directory" is more
181 * intuitive.
182 *
183 * We avoid commands with "/", because execvp will not do $PATH
184 * lookups in that case.
185 *
186 * The reassignment of EACCES to errno looks like a no-op below,
187 * but we need to protect against exists_in_PATH overwriting errno.
188 */
189 if (errno == EACCES && !strchr(file, '/'))
190 errno = exists_in_PATH(file) ? EACCES : ENOENT;
a7855083
JH
191 else if (errno == ENOTDIR && !strchr(file, '/'))
192 errno = ENOENT;
38f865c2
JK
193 return -1;
194}
195
20574f55 196static const char **prepare_shell_cmd(struct argv_array *out, const char **argv)
8dba1e63 197{
20574f55 198 if (!argv[0])
8dba1e63
JK
199 die("BUG: shell command is empty");
200
f445644f 201 if (strcspn(argv[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
380395d0 202#ifndef GIT_WINDOWS_NATIVE
20574f55 203 argv_array_push(out, SHELL_PATH);
77629754 204#else
20574f55 205 argv_array_push(out, "sh");
77629754 206#endif
20574f55 207 argv_array_push(out, "-c");
8dba1e63 208
20574f55
JK
209 /*
210 * If we have no extra arguments, we do not even need to
211 * bother with the "$@" magic.
212 */
213 if (!argv[1])
214 argv_array_push(out, argv[0]);
215 else
216 argv_array_pushf(out, "%s \"$@\"", argv[0]);
217 }
8dba1e63 218
20574f55
JK
219 argv_array_pushv(out, argv);
220 return out->argv;
8dba1e63
JK
221}
222
380395d0 223#ifndef GIT_WINDOWS_NATIVE
8dba1e63
JK
224static int execv_shell_cmd(const char **argv)
225{
20574f55
JK
226 struct argv_array nargv = ARGV_ARRAY_INIT;
227 prepare_shell_cmd(&nargv, argv);
228 trace_argv_printf(nargv.argv, "trace: exec:");
229 sane_execvp(nargv.argv[0], (char **)nargv.argv);
230 argv_array_clear(&nargv);
8dba1e63
JK
231 return -1;
232}
233#endif
234
380395d0 235#ifndef GIT_WINDOWS_NATIVE
2b541bf8
JS
236static int child_notifier = -1;
237
238static void notify_parent(void)
239{
a111eb78
JN
240 /*
241 * execvp failed. If possible, we'd like to let start_command
242 * know, so failures like ENOENT can be handled right away; but
243 * otherwise, finish_command will still report the error.
244 */
245 xwrite(child_notifier, "", 1);
2b541bf8 246}
200a76b7 247#endif
a5487ddf
JS
248
249static inline void set_cloexec(int fd)
250{
251 int flags = fcntl(fd, F_GETFD);
252 if (flags >= 0)
253 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
254}
a5487ddf 255
507d7804 256static int wait_or_whine(pid_t pid, const char *argv0, int in_signal)
ab0b41da
JS
257{
258 int status, code = -1;
259 pid_t waiting;
260 int failed_errno = 0;
261
262 while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
263 ; /* nothing */
507d7804
TI
264 if (in_signal)
265 return 0;
ab0b41da
JS
266
267 if (waiting < 0) {
268 failed_errno = errno;
fbcb0e06 269 error_errno("waitpid for %s failed", argv0);
ab0b41da
JS
270 } else if (waiting != pid) {
271 error("waitpid is confused (%s)", argv0);
272 } else if (WIFSIGNALED(status)) {
273 code = WTERMSIG(status);
ac78663b 274 if (code != SIGINT && code != SIGQUIT && code != SIGPIPE)
a2767c5c 275 error("%s died of signal %d", argv0, code);
ab0b41da
JS
276 /*
277 * This return value is chosen so that code & 0xff
278 * mimics the exit code that a POSIX shell would report for
279 * a program that died from this signal.
280 */
709ca730 281 code += 128;
ab0b41da
JS
282 } else if (WIFEXITED(status)) {
283 code = WEXITSTATUS(status);
284 /*
285 * Convert special exit code when execvp failed.
286 */
287 if (code == 127) {
288 code = -1;
289 failed_errno = ENOENT;
ab0b41da
JS
290 }
291 } else {
292 error("waitpid is confused (%s)", argv0);
293 }
afe19ff7
JK
294
295 clear_child_for_cleanup(pid);
296
ab0b41da
JS
297 errno = failed_errno;
298 return code;
299}
300
ebcb5d16 301int start_command(struct child_process *cmd)
b1bf95bb 302{
f3b33f1d
JS
303 int need_in, need_out, need_err;
304 int fdin[2], fdout[2], fderr[2];
25043d8a 305 int failed_errno;
939296c4 306 char *str;
4919bf03 307
c460c0ec
JK
308 if (!cmd->argv)
309 cmd->argv = cmd->args.argv;
19a583dc
RS
310 if (!cmd->env)
311 cmd->env = cmd->env_array.argv;
c460c0ec 312
c20181e3
JS
313 /*
314 * In case of errors we must keep the promise to close FDs
315 * that have been passed in via ->in and ->out.
316 */
317
e4507ae8 318 need_in = !cmd->no_stdin && cmd->in < 0;
4919bf03 319 if (need_in) {
c20181e3 320 if (pipe(fdin) < 0) {
0ac77ec3 321 failed_errno = errno;
c20181e3
JS
322 if (cmd->out > 0)
323 close(cmd->out);
939296c4 324 str = "standard input";
0ac77ec3 325 goto fail_pipe;
c20181e3 326 }
4919bf03 327 cmd->in = fdin[1];
4919bf03
SP
328 }
329
e4507ae8
SP
330 need_out = !cmd->no_stdout
331 && !cmd->stdout_to_stderr
332 && cmd->out < 0;
f4bba25b
SP
333 if (need_out) {
334 if (pipe(fdout) < 0) {
0ac77ec3 335 failed_errno = errno;
f4bba25b
SP
336 if (need_in)
337 close_pair(fdin);
c20181e3
JS
338 else if (cmd->in)
339 close(cmd->in);
939296c4 340 str = "standard output";
0ac77ec3 341 goto fail_pipe;
f4bba25b
SP
342 }
343 cmd->out = fdout[0];
f4bba25b
SP
344 }
345
b73a4397 346 need_err = !cmd->no_stderr && cmd->err < 0;
f3b33f1d
JS
347 if (need_err) {
348 if (pipe(fderr) < 0) {
0ac77ec3 349 failed_errno = errno;
f3b33f1d
JS
350 if (need_in)
351 close_pair(fdin);
c20181e3
JS
352 else if (cmd->in)
353 close(cmd->in);
f3b33f1d
JS
354 if (need_out)
355 close_pair(fdout);
c20181e3
JS
356 else if (cmd->out)
357 close(cmd->out);
939296c4 358 str = "standard error";
0ac77ec3 359fail_pipe:
939296c4
SB
360 error("cannot create %s pipe for %s: %s",
361 str, cmd->argv[0], strerror(failed_errno));
2d71608e 362 child_process_clear(cmd);
0ac77ec3
JS
363 errno = failed_errno;
364 return -1;
f3b33f1d
JS
365 }
366 cmd->err = fderr[0];
367 }
368
8852f5d7 369 trace_argv_printf(cmd->argv, "trace: run_command:");
13af8cbd 370 fflush(NULL);
8852f5d7 371
380395d0 372#ifndef GIT_WINDOWS_NATIVE
2b541bf8
JS
373{
374 int notify_pipe[2];
375 if (pipe(notify_pipe))
376 notify_pipe[0] = notify_pipe[1] = -1;
377
ebcb5d16 378 cmd->pid = fork();
25043d8a 379 failed_errno = errno;
ebcb5d16 380 if (!cmd->pid) {
a5487ddf
JS
381 /*
382 * Redirect the channel to write syscall error messages to
383 * before redirecting the process's stderr so that all die()
384 * in subsequent call paths use the parent's stderr.
385 */
386 if (cmd->no_stderr || need_err) {
3b331e92 387 int child_err = dup(2);
a5487ddf 388 set_cloexec(child_err);
3b331e92 389 set_error_handle(fdopen(child_err, "w"));
a5487ddf 390 }
a5487ddf 391
2b541bf8
JS
392 close(notify_pipe[0]);
393 set_cloexec(notify_pipe[1]);
394 child_notifier = notify_pipe[1];
395 atexit(notify_parent);
396
e4507ae8
SP
397 if (cmd->no_stdin)
398 dup_devnull(0);
399 else if (need_in) {
4919bf03 400 dup2(fdin[0], 0);
9dc09c76 401 close_pair(fdin);
4919bf03
SP
402 } else if (cmd->in) {
403 dup2(cmd->in, 0);
404 close(cmd->in);
95d3c4f5 405 }
4919bf03 406
ce2cf27a
CC
407 if (cmd->no_stderr)
408 dup_devnull(2);
409 else if (need_err) {
410 dup2(fderr[1], 2);
411 close_pair(fderr);
4f41b611
SP
412 } else if (cmd->err > 1) {
413 dup2(cmd->err, 2);
414 close(cmd->err);
ce2cf27a
CC
415 }
416
e4507ae8
SP
417 if (cmd->no_stdout)
418 dup_devnull(1);
419 else if (cmd->stdout_to_stderr)
cd83c74c 420 dup2(2, 1);
f4bba25b
SP
421 else if (need_out) {
422 dup2(fdout[1], 1);
423 close_pair(fdout);
424 } else if (cmd->out > 1) {
425 dup2(cmd->out, 1);
426 close(cmd->out);
427 }
428
1568fea0 429 if (cmd->dir && chdir(cmd->dir))
d824cbba
TR
430 die_errno("exec '%s': cd to '%s' failed", cmd->argv[0],
431 cmd->dir);
ee493148 432 if (cmd->env) {
3427b375
AR
433 for (; *cmd->env; cmd->env++) {
434 if (strchr(*cmd->env, '='))
4b25d091 435 putenv((char *)*cmd->env);
3427b375
AR
436 else
437 unsetenv(*cmd->env);
438 }
ee493148 439 }
5a50085c 440 if (cmd->git_cmd)
f1000898 441 execv_git_cmd(cmd->argv);
5a50085c 442 else if (cmd->use_shell)
8dba1e63 443 execv_shell_cmd(cmd->argv);
5a50085c 444 else
38f865c2 445 sane_execvp(cmd->argv[0], (char *const*) cmd->argv);
fc1b56f0
CB
446 if (errno == ENOENT) {
447 if (!cmd->silent_exec_failure)
448 error("cannot run %s: %s", cmd->argv[0],
449 strerror(ENOENT));
a5487ddf 450 exit(127);
fc1b56f0 451 } else {
a5487ddf 452 die_errno("cannot exec '%s'", cmd->argv[0]);
fc1b56f0 453 }
b1bf95bb 454 }
0ac77ec3 455 if (cmd->pid < 0)
fbcb0e06 456 error_errno("cannot fork() for %s", cmd->argv[0]);
afe19ff7 457 else if (cmd->clean_on_exit)
ac2fbaa6 458 mark_child_for_cleanup(cmd->pid, cmd);
2b541bf8
JS
459
460 /*
461 * Wait for child's execvp. If the execvp succeeds (or if fork()
462 * failed), EOF is seen immediately by the parent. Otherwise, the
463 * child process sends a single byte.
464 * Note that use of this infrastructure is completely advisory,
465 * therefore, we keep error checks minimal.
466 */
467 close(notify_pipe[1]);
468 if (read(notify_pipe[0], &notify_pipe[1], 1) == 1) {
469 /*
470 * At this point we know that fork() succeeded, but execvp()
471 * failed. Errors have been reported to our stderr.
472 */
507d7804 473 wait_or_whine(cmd->pid, cmd->argv[0], 0);
2b541bf8
JS
474 failed_errno = errno;
475 cmd->pid = -1;
476 }
477 close(notify_pipe[0]);
478}
ba26f296 479#else
0d30ad71 480{
75301f90 481 int fhin = 0, fhout = 1, fherr = 2;
108ac313 482 const char **sargv = cmd->argv;
20574f55 483 struct argv_array nargv = ARGV_ARRAY_INIT;
ba26f296 484
75301f90
JS
485 if (cmd->no_stdin)
486 fhin = open("/dev/null", O_RDWR);
487 else if (need_in)
488 fhin = dup(fdin[0]);
489 else if (cmd->in)
490 fhin = dup(cmd->in);
491
492 if (cmd->no_stderr)
493 fherr = open("/dev/null", O_RDWR);
494 else if (need_err)
495 fherr = dup(fderr[1]);
76d44c8c
JH
496 else if (cmd->err > 2)
497 fherr = dup(cmd->err);
75301f90
JS
498
499 if (cmd->no_stdout)
500 fhout = open("/dev/null", O_RDWR);
501 else if (cmd->stdout_to_stderr)
502 fhout = dup(fherr);
503 else if (need_out)
504 fhout = dup(fdout[1]);
505 else if (cmd->out > 1)
506 fhout = dup(cmd->out);
ba26f296 507
5a50085c 508 if (cmd->git_cmd)
20574f55 509 cmd->argv = prepare_git_cmd(&nargv, cmd->argv);
5a50085c 510 else if (cmd->use_shell)
20574f55 511 cmd->argv = prepare_shell_cmd(&nargv, cmd->argv);
ba26f296 512
77734da2
KB
513 cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, (char**) cmd->env,
514 cmd->dir, fhin, fhout, fherr);
0ac77ec3 515 failed_errno = errno;
c024beb5 516 if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
fbcb0e06 517 error_errno("cannot spawn %s", cmd->argv[0]);
afe19ff7 518 if (cmd->clean_on_exit && cmd->pid >= 0)
ac2fbaa6 519 mark_child_for_cleanup(cmd->pid, cmd);
ba26f296 520
20574f55 521 argv_array_clear(&nargv);
108ac313 522 cmd->argv = sargv;
75301f90
JS
523 if (fhin != 0)
524 close(fhin);
525 if (fhout != 1)
526 close(fhout);
527 if (fherr != 2)
528 close(fherr);
0d30ad71 529}
ba26f296
JS
530#endif
531
532 if (cmd->pid < 0) {
533 if (need_in)
534 close_pair(fdin);
535 else if (cmd->in)
536 close(cmd->in);
537 if (need_out)
538 close_pair(fdout);
539 else if (cmd->out)
540 close(cmd->out);
541 if (need_err)
542 close_pair(fderr);
fc012c28
D
543 else if (cmd->err)
544 close(cmd->err);
2d71608e 545 child_process_clear(cmd);
0ac77ec3
JS
546 errno = failed_errno;
547 return -1;
ba26f296 548 }
4919bf03
SP
549
550 if (need_in)
551 close(fdin[0]);
552 else if (cmd->in)
553 close(cmd->in);
554
f4bba25b
SP
555 if (need_out)
556 close(fdout[1]);
c20181e3 557 else if (cmd->out)
f4bba25b
SP
558 close(cmd->out);
559
f3b33f1d
JS
560 if (need_err)
561 close(fderr[1]);
4f41b611
SP
562 else if (cmd->err)
563 close(cmd->err);
f3b33f1d 564
ebcb5d16
SP
565 return 0;
566}
567
2d22c208
JS
568int finish_command(struct child_process *cmd)
569{
507d7804 570 int ret = wait_or_whine(cmd->pid, cmd->argv[0], 0);
2d71608e 571 child_process_clear(cmd);
c460c0ec 572 return ret;
2d22c208
JS
573}
574
507d7804
TI
575int finish_command_in_signal(struct child_process *cmd)
576{
577 return wait_or_whine(cmd->pid, cmd->argv[0], 1);
578}
579
580
ebcb5d16
SP
581int run_command(struct child_process *cmd)
582{
c29b3962
JK
583 int code;
584
585 if (cmd->out < 0 || cmd->err < 0)
586 die("BUG: run_command with a pipe can cause deadlock");
587
588 code = start_command(cmd);
ebcb5d16
SP
589 if (code)
590 return code;
591 return finish_command(cmd);
592}
593
f1000898
SP
594int run_command_v_opt(const char **argv, int opt)
595{
41e9bad7 596 return run_command_v_opt_cd_env(argv, opt, NULL, NULL);
1568fea0
AR
597}
598
ee493148
AR
599int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
600{
1f87293d
RS
601 struct child_process cmd = CHILD_PROCESS_INIT;
602 cmd.argv = argv;
603 cmd.no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
604 cmd.git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
605 cmd.stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
606 cmd.silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
607 cmd.use_shell = opt & RUN_USING_SHELL ? 1 : 0;
608 cmd.clean_on_exit = opt & RUN_CLEAN_ON_EXIT ? 1 : 0;
ee493148
AR
609 cmd.dir = dir;
610 cmd.env = env;
611 return run_command(&cmd);
612}
2d22c208 613
f6b60983 614#ifndef NO_PTHREADS
0ea1c89b
JS
615static pthread_t main_thread;
616static int main_thread_set;
617static pthread_key_t async_key;
1ece66bc 618static pthread_key_t async_die_counter;
0ea1c89b 619
200a76b7 620static void *run_thread(void *data)
618ebe9f
JS
621{
622 struct async *async = data;
f6b60983 623 intptr_t ret;
0ea1c89b 624
c792d7b6
JK
625 if (async->isolate_sigpipe) {
626 sigset_t mask;
627 sigemptyset(&mask);
628 sigaddset(&mask, SIGPIPE);
629 if (pthread_sigmask(SIG_BLOCK, &mask, NULL) < 0) {
630 ret = error("unable to block SIGPIPE in async thread");
631 return (void *)ret;
632 }
633 }
634
0ea1c89b 635 pthread_setspecific(async_key, async);
f6b60983 636 ret = async->proc(async->proc_in, async->proc_out, async->data);
200a76b7 637 return (void *)ret;
618ebe9f 638}
0ea1c89b
JS
639
640static NORETURN void die_async(const char *err, va_list params)
641{
642 vreportf("fatal: ", err, params);
643
661a8cf4 644 if (in_async()) {
0ea1c89b
JS
645 struct async *async = pthread_getspecific(async_key);
646 if (async->proc_in >= 0)
647 close(async->proc_in);
648 if (async->proc_out >= 0)
649 close(async->proc_out);
650 pthread_exit((void *)128);
651 }
652
653 exit(128);
618ebe9f 654}
1ece66bc
JK
655
656static int async_die_is_recursing(void)
657{
658 void *ret = pthread_getspecific(async_die_counter);
659 pthread_setspecific(async_die_counter, (void *)1);
660 return ret != NULL;
661}
662
661a8cf4
JK
663int in_async(void)
664{
665 if (!main_thread_set)
666 return 0; /* no asyncs started yet */
667 return !pthread_equal(main_thread, pthread_self());
668}
669
b992fe10 670static void NORETURN async_exit(int code)
9658846c
JK
671{
672 pthread_exit((void *)(intptr_t)code);
673}
674
0f4b6db3
EB
675#else
676
677static struct {
678 void (**handlers)(void);
679 size_t nr;
680 size_t alloc;
681} git_atexit_hdlrs;
682
683static int git_atexit_installed;
684
6066a7ea 685static void git_atexit_dispatch(void)
0f4b6db3
EB
686{
687 size_t i;
688
689 for (i=git_atexit_hdlrs.nr ; i ; i--)
690 git_atexit_hdlrs.handlers[i-1]();
691}
692
6066a7ea 693static void git_atexit_clear(void)
0f4b6db3
EB
694{
695 free(git_atexit_hdlrs.handlers);
696 memset(&git_atexit_hdlrs, 0, sizeof(git_atexit_hdlrs));
697 git_atexit_installed = 0;
698}
699
700#undef atexit
701int git_atexit(void (*handler)(void))
702{
703 ALLOC_GROW(git_atexit_hdlrs.handlers, git_atexit_hdlrs.nr + 1, git_atexit_hdlrs.alloc);
704 git_atexit_hdlrs.handlers[git_atexit_hdlrs.nr++] = handler;
705 if (!git_atexit_installed) {
706 if (atexit(&git_atexit_dispatch))
707 return -1;
708 git_atexit_installed = 1;
709 }
710 return 0;
711}
712#define atexit git_atexit
713
661a8cf4
JK
714static int process_is_async;
715int in_async(void)
716{
717 return process_is_async;
718}
719
b992fe10 720static void NORETURN async_exit(int code)
9658846c
JK
721{
722 exit(code);
723}
724
618ebe9f
JS
725#endif
726
b992fe10
LS
727void check_pipe(int err)
728{
729 if (err == EPIPE) {
730 if (in_async())
731 async_exit(141);
732
733 signal(SIGPIPE, SIG_DFL);
734 raise(SIGPIPE);
735 /* Should never happen, but just in case... */
736 exit(141);
737 }
738}
739
2d22c208
JS
740int start_async(struct async *async)
741{
ae6a5609
EFL
742 int need_in, need_out;
743 int fdin[2], fdout[2];
744 int proc_in, proc_out;
2d22c208 745
ae6a5609
EFL
746 need_in = async->in < 0;
747 if (need_in) {
748 if (pipe(fdin) < 0) {
749 if (async->out > 0)
750 close(async->out);
fbcb0e06 751 return error_errno("cannot create pipe");
ae6a5609
EFL
752 }
753 async->in = fdin[1];
754 }
755
756 need_out = async->out < 0;
757 if (need_out) {
758 if (pipe(fdout) < 0) {
759 if (need_in)
760 close_pair(fdin);
761 else if (async->in)
762 close(async->in);
fbcb0e06 763 return error_errno("cannot create pipe");
ae6a5609
EFL
764 }
765 async->out = fdout[0];
766 }
767
768 if (need_in)
769 proc_in = fdin[0];
770 else if (async->in)
771 proc_in = async->in;
772 else
773 proc_in = -1;
774
775 if (need_out)
776 proc_out = fdout[1];
777 else if (async->out)
778 proc_out = async->out;
779 else
780 proc_out = -1;
2d22c208 781
f6b60983 782#ifdef NO_PTHREADS
2c3766f0
AM
783 /* Flush stdio before fork() to avoid cloning buffers */
784 fflush(NULL);
785
2d22c208
JS
786 async->pid = fork();
787 if (async->pid < 0) {
fbcb0e06 788 error_errno("fork (async) failed");
ae6a5609 789 goto error;
2d22c208
JS
790 }
791 if (!async->pid) {
ae6a5609
EFL
792 if (need_in)
793 close(fdin[1]);
794 if (need_out)
795 close(fdout[0]);
0f4b6db3 796 git_atexit_clear();
661a8cf4 797 process_is_async = 1;
ae6a5609 798 exit(!!async->proc(proc_in, proc_out, async->data));
2d22c208 799 }
ae6a5609 800
ac2fbaa6 801 mark_child_for_cleanup(async->pid, NULL);
afe19ff7 802
ae6a5609
EFL
803 if (need_in)
804 close(fdin[0]);
805 else if (async->in)
806 close(async->in);
807
808 if (need_out)
809 close(fdout[1]);
810 else if (async->out)
811 close(async->out);
618ebe9f 812#else
0ea1c89b
JS
813 if (!main_thread_set) {
814 /*
815 * We assume that the first time that start_async is called
816 * it is from the main thread.
817 */
818 main_thread_set = 1;
819 main_thread = pthread_self();
820 pthread_key_create(&async_key, NULL);
1ece66bc 821 pthread_key_create(&async_die_counter, NULL);
0ea1c89b 822 set_die_routine(die_async);
1ece66bc 823 set_die_is_recursing_routine(async_die_is_recursing);
0ea1c89b
JS
824 }
825
200a76b7
JS
826 if (proc_in >= 0)
827 set_cloexec(proc_in);
828 if (proc_out >= 0)
829 set_cloexec(proc_out);
ae6a5609
EFL
830 async->proc_in = proc_in;
831 async->proc_out = proc_out;
200a76b7
JS
832 {
833 int err = pthread_create(&async->tid, NULL, run_thread, async);
834 if (err) {
fbcb0e06 835 error_errno("cannot create thread");
200a76b7
JS
836 goto error;
837 }
618ebe9f
JS
838 }
839#endif
2d22c208 840 return 0;
ae6a5609
EFL
841
842error:
843 if (need_in)
844 close_pair(fdin);
845 else if (async->in)
846 close(async->in);
847
848 if (need_out)
849 close_pair(fdout);
850 else if (async->out)
851 close(async->out);
852 return -1;
2d22c208
JS
853}
854
855int finish_async(struct async *async)
856{
f6b60983 857#ifdef NO_PTHREADS
507d7804 858 return wait_or_whine(async->pid, "child process", 0);
618ebe9f 859#else
200a76b7
JS
860 void *ret = (void *)(intptr_t)(-1);
861
862 if (pthread_join(async->tid, &ret))
863 error("pthread_join failed");
864 return (int)(intptr_t)ret;
618ebe9f 865#endif
2d22c208 866}
ae98a008 867
dcf69262 868const char *find_hook(const char *name)
5a7da2dc 869{
03f2c773 870 static struct strbuf path = STRBUF_INIT;
5a7da2dc 871
03f2c773 872 strbuf_reset(&path);
9445b492 873 strbuf_git_path(&path, "hooks/%s", name);
235be51f
JS
874 if (access(path.buf, X_OK) < 0) {
875#ifdef STRIP_EXTENSION
876 strbuf_addstr(&path, STRIP_EXTENSION);
877 if (access(path.buf, X_OK) >= 0)
878 return path.buf;
879#endif
03f2c773 880 return NULL;
235be51f 881 }
03f2c773 882 return path.buf;
5a7da2dc
AS
883}
884
15048f8a 885int run_hook_ve(const char *const *env, const char *name, va_list args)
ae98a008 886{
d3180279 887 struct child_process hook = CHILD_PROCESS_INIT;
15048f8a 888 const char *p;
ae98a008 889
5a7da2dc
AS
890 p = find_hook(name);
891 if (!p)
cf94ca8e
SB
892 return 0;
893
d1d09456
RS
894 argv_array_push(&hook.args, p);
895 while ((p = va_arg(args, const char *)))
896 argv_array_push(&hook.args, p);
15048f8a 897 hook.env = env;
ae98a008
SB
898 hook.no_stdin = 1;
899 hook.stdout_to_stderr = 1;
ae98a008 900
d1d09456 901 return run_command(&hook);
ae98a008 902}
15048f8a
BP
903
904int run_hook_le(const char *const *env, const char *name, ...)
905{
906 va_list args;
907 int ret;
908
909 va_start(args, name);
910 ret = run_hook_ve(env, name, args);
911 va_end(args);
912
913 return ret;
914}
911ec99b 915
96335bcf
JK
916struct io_pump {
917 /* initialized by caller */
918 int fd;
919 int type; /* POLLOUT or POLLIN */
920 union {
921 struct {
922 const char *buf;
923 size_t len;
924 } out;
925 struct {
926 struct strbuf *buf;
927 size_t hint;
928 } in;
929 } u;
930
931 /* returned by pump_io */
932 int error; /* 0 for success, otherwise errno */
933
934 /* internal use */
935 struct pollfd *pfd;
936};
937
938static int pump_io_round(struct io_pump *slots, int nr, struct pollfd *pfd)
939{
940 int pollsize = 0;
941 int i;
942
943 for (i = 0; i < nr; i++) {
944 struct io_pump *io = &slots[i];
945 if (io->fd < 0)
946 continue;
947 pfd[pollsize].fd = io->fd;
948 pfd[pollsize].events = io->type;
949 io->pfd = &pfd[pollsize++];
950 }
951
952 if (!pollsize)
953 return 0;
954
955 if (poll(pfd, pollsize, -1) < 0) {
956 if (errno == EINTR)
957 return 1;
958 die_errno("poll failed");
959 }
960
961 for (i = 0; i < nr; i++) {
962 struct io_pump *io = &slots[i];
963
964 if (io->fd < 0)
965 continue;
966
967 if (!(io->pfd->revents & (POLLOUT|POLLIN|POLLHUP|POLLERR|POLLNVAL)))
968 continue;
969
970 if (io->type == POLLOUT) {
971 ssize_t len = xwrite(io->fd,
972 io->u.out.buf, io->u.out.len);
973 if (len < 0) {
974 io->error = errno;
975 close(io->fd);
976 io->fd = -1;
977 } else {
978 io->u.out.buf += len;
979 io->u.out.len -= len;
980 if (!io->u.out.len) {
981 close(io->fd);
982 io->fd = -1;
983 }
984 }
985 }
986
987 if (io->type == POLLIN) {
988 ssize_t len = strbuf_read_once(io->u.in.buf,
989 io->fd, io->u.in.hint);
990 if (len < 0)
991 io->error = errno;
992 if (len <= 0) {
993 close(io->fd);
994 io->fd = -1;
995 }
996 }
997 }
998
999 return 1;
1000}
1001
1002static int pump_io(struct io_pump *slots, int nr)
911ec99b 1003{
96335bcf
JK
1004 struct pollfd *pfd;
1005 int i;
1006
1007 for (i = 0; i < nr; i++)
1008 slots[i].error = 0;
1009
1010 ALLOC_ARRAY(pfd, nr);
1011 while (pump_io_round(slots, nr, pfd))
1012 ; /* nothing */
1013 free(pfd);
1014
1015 /* There may be multiple errno values, so just pick the first. */
1016 for (i = 0; i < nr; i++) {
1017 if (slots[i].error) {
1018 errno = slots[i].error;
1019 return -1;
1020 }
1021 }
1022 return 0;
1023}
1024
1025
1026int pipe_command(struct child_process *cmd,
1027 const char *in, size_t in_len,
1028 struct strbuf *out, size_t out_hint,
1029 struct strbuf *err, size_t err_hint)
1030{
1031 struct io_pump io[3];
1032 int nr = 0;
1033
1034 if (in)
1035 cmd->in = -1;
1036 if (out)
1037 cmd->out = -1;
1038 if (err)
1039 cmd->err = -1;
1040
911ec99b
JK
1041 if (start_command(cmd) < 0)
1042 return -1;
1043
96335bcf
JK
1044 if (in) {
1045 io[nr].fd = cmd->in;
1046 io[nr].type = POLLOUT;
1047 io[nr].u.out.buf = in;
1048 io[nr].u.out.len = in_len;
1049 nr++;
1050 }
1051 if (out) {
1052 io[nr].fd = cmd->out;
1053 io[nr].type = POLLIN;
1054 io[nr].u.in.buf = out;
1055 io[nr].u.in.hint = out_hint;
1056 nr++;
1057 }
1058 if (err) {
1059 io[nr].fd = cmd->err;
1060 io[nr].type = POLLIN;
1061 io[nr].u.in.buf = err;
1062 io[nr].u.in.hint = err_hint;
1063 nr++;
1064 }
1065
1066 if (pump_io(io, nr) < 0) {
911ec99b
JK
1067 finish_command(cmd); /* throw away exit code */
1068 return -1;
1069 }
1070
911ec99b
JK
1071 return finish_command(cmd);
1072}
c553c72e
SB
1073
1074enum child_state {
1075 GIT_CP_FREE,
1076 GIT_CP_WORKING,
1077 GIT_CP_WAIT_CLEANUP,
1078};
1079
1080struct parallel_processes {
1081 void *data;
1082
1083 int max_processes;
1084 int nr_processes;
1085
1086 get_next_task_fn get_next_task;
1087 start_failure_fn start_failure;
1088 task_finished_fn task_finished;
1089
1090 struct {
1091 enum child_state state;
1092 struct child_process process;
1093 struct strbuf err;
1094 void *data;
1095 } *children;
1096 /*
1097 * The struct pollfd is logically part of *children,
1098 * but the system call expects it as its own array.
1099 */
1100 struct pollfd *pfd;
1101
1102 unsigned shutdown : 1;
1103
1104 int output_owner;
1105 struct strbuf buffered_output; /* of finished children */
1106};
1107
aa710494 1108static int default_start_failure(struct strbuf *out,
c553c72e
SB
1109 void *pp_cb,
1110 void *pp_task_cb)
1111{
c553c72e
SB
1112 return 0;
1113}
1114
1115static int default_task_finished(int result,
aa710494 1116 struct strbuf *out,
c553c72e
SB
1117 void *pp_cb,
1118 void *pp_task_cb)
1119{
c553c72e
SB
1120 return 0;
1121}
1122
1123static void kill_children(struct parallel_processes *pp, int signo)
1124{
1125 int i, n = pp->max_processes;
1126
1127 for (i = 0; i < n; i++)
1128 if (pp->children[i].state == GIT_CP_WORKING)
1129 kill(pp->children[i].process.pid, signo);
1130}
1131
1132static struct parallel_processes *pp_for_signal;
1133
1134static void handle_children_on_signal(int signo)
1135{
1136 kill_children(pp_for_signal, signo);
1137 sigchain_pop(signo);
1138 raise(signo);
1139}
1140
1141static void pp_init(struct parallel_processes *pp,
1142 int n,
1143 get_next_task_fn get_next_task,
1144 start_failure_fn start_failure,
1145 task_finished_fn task_finished,
1146 void *data)
1147{
1148 int i;
1149
1150 if (n < 1)
1151 n = online_cpus();
1152
1153 pp->max_processes = n;
1154
1155 trace_printf("run_processes_parallel: preparing to run up to %d tasks", n);
1156
1157 pp->data = data;
1158 if (!get_next_task)
1159 die("BUG: you need to specify a get_next_task function");
1160 pp->get_next_task = get_next_task;
1161
1162 pp->start_failure = start_failure ? start_failure : default_start_failure;
1163 pp->task_finished = task_finished ? task_finished : default_task_finished;
1164
1165 pp->nr_processes = 0;
1166 pp->output_owner = 0;
1167 pp->shutdown = 0;
1168 pp->children = xcalloc(n, sizeof(*pp->children));
1169 pp->pfd = xcalloc(n, sizeof(*pp->pfd));
1170 strbuf_init(&pp->buffered_output, 0);
1171
1172 for (i = 0; i < n; i++) {
1173 strbuf_init(&pp->children[i].err, 0);
1174 child_process_init(&pp->children[i].process);
1175 pp->pfd[i].events = POLLIN | POLLHUP;
1176 pp->pfd[i].fd = -1;
1177 }
1178
1179 pp_for_signal = pp;
1180 sigchain_push_common(handle_children_on_signal);
1181}
1182
1183static void pp_cleanup(struct parallel_processes *pp)
1184{
1185 int i;
1186
1187 trace_printf("run_processes_parallel: done");
1188 for (i = 0; i < pp->max_processes; i++) {
1189 strbuf_release(&pp->children[i].err);
1190 child_process_clear(&pp->children[i].process);
1191 }
1192
1193 free(pp->children);
1194 free(pp->pfd);
1195
1196 /*
1197 * When get_next_task added messages to the buffer in its last
1198 * iteration, the buffered output is non empty.
1199 */
2dac9b56 1200 strbuf_write(&pp->buffered_output, stderr);
c553c72e
SB
1201 strbuf_release(&pp->buffered_output);
1202
1203 sigchain_pop_common();
1204}
1205
1206/* returns
1207 * 0 if a new task was started.
1208 * 1 if no new jobs was started (get_next_task ran out of work, non critical
1209 * problem with starting a new command)
1210 * <0 no new job was started, user wishes to shutdown early. Use negative code
1211 * to signal the children.
1212 */
1213static int pp_start_one(struct parallel_processes *pp)
1214{
1215 int i, code;
1216
1217 for (i = 0; i < pp->max_processes; i++)
1218 if (pp->children[i].state == GIT_CP_FREE)
1219 break;
1220 if (i == pp->max_processes)
1221 die("BUG: bookkeeping is hard");
1222
1223 code = pp->get_next_task(&pp->children[i].process,
1224 &pp->children[i].err,
1225 pp->data,
1226 &pp->children[i].data);
1227 if (!code) {
1228 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1229 strbuf_reset(&pp->children[i].err);
1230 return 1;
1231 }
1232 pp->children[i].process.err = -1;
1233 pp->children[i].process.stdout_to_stderr = 1;
1234 pp->children[i].process.no_stdin = 1;
1235
1236 if (start_command(&pp->children[i].process)) {
2a73b3da 1237 code = pp->start_failure(&pp->children[i].err,
c553c72e
SB
1238 pp->data,
1239 &pp->children[i].data);
1240 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1241 strbuf_reset(&pp->children[i].err);
1242 if (code)
1243 pp->shutdown = 1;
1244 return code;
1245 }
1246
1247 pp->nr_processes++;
1248 pp->children[i].state = GIT_CP_WORKING;
1249 pp->pfd[i].fd = pp->children[i].process.err;
1250 return 0;
1251}
1252
1253static void pp_buffer_stderr(struct parallel_processes *pp, int output_timeout)
1254{
1255 int i;
1256
1257 while ((i = poll(pp->pfd, pp->max_processes, output_timeout)) < 0) {
1258 if (errno == EINTR)
1259 continue;
1260 pp_cleanup(pp);
1261 die_errno("poll");
1262 }
1263
1264 /* Buffer output from all pipes. */
1265 for (i = 0; i < pp->max_processes; i++) {
1266 if (pp->children[i].state == GIT_CP_WORKING &&
1267 pp->pfd[i].revents & (POLLIN | POLLHUP)) {
1268 int n = strbuf_read_once(&pp->children[i].err,
1269 pp->children[i].process.err, 0);
1270 if (n == 0) {
1271 close(pp->children[i].process.err);
1272 pp->children[i].state = GIT_CP_WAIT_CLEANUP;
1273 } else if (n < 0)
1274 if (errno != EAGAIN)
1275 die_errno("read");
1276 }
1277 }
1278}
1279
1280static void pp_output(struct parallel_processes *pp)
1281{
1282 int i = pp->output_owner;
1283 if (pp->children[i].state == GIT_CP_WORKING &&
1284 pp->children[i].err.len) {
2dac9b56 1285 strbuf_write(&pp->children[i].err, stderr);
c553c72e
SB
1286 strbuf_reset(&pp->children[i].err);
1287 }
1288}
1289
1290static int pp_collect_finished(struct parallel_processes *pp)
1291{
1292 int i, code;
1293 int n = pp->max_processes;
1294 int result = 0;
1295
1296 while (pp->nr_processes > 0) {
1297 for (i = 0; i < pp->max_processes; i++)
1298 if (pp->children[i].state == GIT_CP_WAIT_CLEANUP)
1299 break;
1300 if (i == pp->max_processes)
1301 break;
1302
1303 code = finish_command(&pp->children[i].process);
1304
2a73b3da 1305 code = pp->task_finished(code,
c553c72e
SB
1306 &pp->children[i].err, pp->data,
1307 &pp->children[i].data);
1308
1309 if (code)
1310 result = code;
1311 if (code < 0)
1312 break;
1313
1314 pp->nr_processes--;
1315 pp->children[i].state = GIT_CP_FREE;
1316 pp->pfd[i].fd = -1;
1317 child_process_init(&pp->children[i].process);
1318
1319 if (i != pp->output_owner) {
1320 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1321 strbuf_reset(&pp->children[i].err);
1322 } else {
2dac9b56 1323 strbuf_write(&pp->children[i].err, stderr);
c553c72e
SB
1324 strbuf_reset(&pp->children[i].err);
1325
1326 /* Output all other finished child processes */
2dac9b56 1327 strbuf_write(&pp->buffered_output, stderr);
c553c72e
SB
1328 strbuf_reset(&pp->buffered_output);
1329
1330 /*
1331 * Pick next process to output live.
1332 * NEEDSWORK:
1333 * For now we pick it randomly by doing a round
1334 * robin. Later we may want to pick the one with
1335 * the most output or the longest or shortest
1336 * running process time.
1337 */
1338 for (i = 0; i < n; i++)
1339 if (pp->children[(pp->output_owner + i) % n].state == GIT_CP_WORKING)
1340 break;
1341 pp->output_owner = (pp->output_owner + i) % n;
1342 }
1343 }
1344 return result;
1345}
1346
1347int run_processes_parallel(int n,
1348 get_next_task_fn get_next_task,
1349 start_failure_fn start_failure,
1350 task_finished_fn task_finished,
1351 void *pp_cb)
1352{
1353 int i, code;
1354 int output_timeout = 100;
1355 int spawn_cap = 4;
1356 struct parallel_processes pp;
1357
1358 pp_init(&pp, n, get_next_task, start_failure, task_finished, pp_cb);
1359 while (1) {
1360 for (i = 0;
1361 i < spawn_cap && !pp.shutdown &&
1362 pp.nr_processes < pp.max_processes;
1363 i++) {
1364 code = pp_start_one(&pp);
1365 if (!code)
1366 continue;
1367 if (code < 0) {
1368 pp.shutdown = 1;
1369 kill_children(&pp, -code);
1370 }
1371 break;
1372 }
1373 if (!pp.nr_processes)
1374 break;
1375 pp_buffer_stderr(&pp, output_timeout);
1376 pp_output(&pp);
1377 code = pp_collect_finished(&pp);
1378 if (code) {
1379 pp.shutdown = 1;
1380 if (code < 0)
1381 kill_children(&pp, -code);
1382 }
1383 }
1384
1385 pp_cleanup(&pp);
1386 return 0;
1387}