blob: a558042c876ad2baefcfcc111163bab9691f7f1c [file] [log] [blame]
Elijah Newren64c85592023-05-16 06:33:49 +00001#include "git-compat-util.h"
Josef Weidendorferb1bf95b2005-07-31 21:17:43 +02002#include "run-command.h"
Elijah Newren32a8f512023-03-21 06:26:03 +00003#include "environment.h"
Stefan Bellerd807c4a2018-04-10 14:26:18 -07004#include "exec-cmd.h"
Elijah Newrenf394e092023-03-21 06:25:54 +00005#include "gettext.h"
Jeff Kingafe19ff2012-01-07 12:42:43 +01006#include "sigchain.h"
Jeff Kingdbbcd442020-07-28 16:23:39 -04007#include "strvec.h"
Elijah Newrencb2a5132023-04-22 20:17:09 +00008#include "symlinks.h"
Stefan Bellerc553c722015-12-15 16:04:10 -08009#include "thread-utils.h"
10#include "strbuf.h"
Damien Mariéf805a002017-10-06 08:07:55 +000011#include "string-list.h"
Elijah Newren74ea5c92023-04-11 03:00:38 +000012#include "trace.h"
13#include "trace2.h"
Nguyễn Thái Ngọc Duye73dd782018-01-18 16:45:09 +070014#include "quote.h"
Derrick Stolee1942d482020-08-28 15:45:12 +000015#include "config.h"
Johannes Schindelin28d04e12021-09-09 09:47:06 +000016#include "packfile.h"
Ævar Arnfjörð Bjarmason5e3aba32021-09-26 21:03:26 +020017#include "hook.h"
Jeff King716c1f62022-08-17 02:10:22 -040018#include "compat/nonblock.h"
Taylor Blau52c0f332023-05-16 17:33:43 -040019#include "alloc.h"
Josef Weidendorferb1bf95b2005-07-31 21:17:43 +020020
René Scharfe483bbd42014-08-19 21:10:48 +020021void child_process_init(struct child_process *child)
22{
Ævar Arnfjörð Bjarmason5726a6b2021-07-01 12:51:26 +020023 struct child_process blank = CHILD_PROCESS_INIT;
24 memcpy(child, &blank, sizeof(*child));
René Scharfe483bbd42014-08-19 21:10:48 +020025}
26
René Scharfe2d716082015-10-24 14:11:27 +020027void child_process_clear(struct child_process *child)
28{
Jeff Kingc972bf42020-07-28 16:25:12 -040029 strvec_clear(&child->args);
Ævar Arnfjörð Bjarmason29fda242022-06-02 11:09:50 +020030 strvec_clear(&child->env);
René Scharfe2d716082015-10-24 14:11:27 +020031}
32
Jeff Kingafe19ff2012-01-07 12:42:43 +010033struct child_to_clean {
34 pid_t pid;
Lars Schneiderac2fbaa2016-10-16 16:20:28 -070035 struct child_process *process;
Jeff Kingafe19ff2012-01-07 12:42:43 +010036 struct child_to_clean *next;
37};
38static struct child_to_clean *children_to_clean;
39static int installed_child_cleanup_handler;
40
Takashi Iwai507d7802015-09-04 11:35:57 +020041static void cleanup_children(int sig, int in_signal)
Jeff Kingafe19ff2012-01-07 12:42:43 +010042{
Jeff King46df6902017-01-06 20:22:23 -050043 struct child_to_clean *children_to_wait_for = NULL;
44
Jeff Kingafe19ff2012-01-07 12:42:43 +010045 while (children_to_clean) {
46 struct child_to_clean *p = children_to_clean;
47 children_to_clean = p->next;
Lars Schneiderac2fbaa2016-10-16 16:20:28 -070048
49 if (p->process && !in_signal) {
50 struct child_process *process = p->process;
51 if (process->clean_on_exit_handler) {
52 trace_printf(
53 "trace: run_command: running exit handler for pid %"
54 PRIuMAX, (uintmax_t)p->pid
55 );
56 process->clean_on_exit_handler(process);
57 }
58 }
59
Jeff Kingafe19ff2012-01-07 12:42:43 +010060 kill(p->pid, sig);
Jeff King46df6902017-01-06 20:22:23 -050061
Jeff King7b919292017-03-17 19:20:04 -040062 if (p->process && p->process->wait_after_clean) {
Jeff King46df6902017-01-06 20:22:23 -050063 p->next = children_to_wait_for;
64 children_to_wait_for = p;
65 } else {
66 if (!in_signal)
67 free(p);
68 }
69 }
70
71 while (children_to_wait_for) {
72 struct child_to_clean *p = children_to_wait_for;
73 children_to_wait_for = p->next;
74
75 while (waitpid(p->pid, NULL, 0) < 0 && errno == EINTR)
76 ; /* spin waiting for process exit or error */
77
Takashi Iwai507d7802015-09-04 11:35:57 +020078 if (!in_signal)
79 free(p);
Jeff Kingafe19ff2012-01-07 12:42:43 +010080 }
81}
82
83static void cleanup_children_on_signal(int sig)
84{
Takashi Iwai507d7802015-09-04 11:35:57 +020085 cleanup_children(sig, 1);
Jeff Kingafe19ff2012-01-07 12:42:43 +010086 sigchain_pop(sig);
87 raise(sig);
88}
89
90static void cleanup_children_on_exit(void)
91{
Takashi Iwai507d7802015-09-04 11:35:57 +020092 cleanup_children(SIGTERM, 0);
Jeff Kingafe19ff2012-01-07 12:42:43 +010093}
94
Lars Schneiderac2fbaa2016-10-16 16:20:28 -070095static void mark_child_for_cleanup(pid_t pid, struct child_process *process)
Jeff Kingafe19ff2012-01-07 12:42:43 +010096{
97 struct child_to_clean *p = xmalloc(sizeof(*p));
98 p->pid = pid;
Lars Schneiderac2fbaa2016-10-16 16:20:28 -070099 p->process = process;
Jeff Kingafe19ff2012-01-07 12:42:43 +0100100 p->next = children_to_clean;
101 children_to_clean = p;
102
103 if (!installed_child_cleanup_handler) {
104 atexit(cleanup_children_on_exit);
105 sigchain_push_common(cleanup_children_on_signal);
106 installed_child_cleanup_handler = 1;
107 }
108}
109
110static void clear_child_for_cleanup(pid_t pid)
111{
David Gouldbdee3972012-09-11 15:32:47 +0100112 struct child_to_clean **pp;
Jeff Kingafe19ff2012-01-07 12:42:43 +0100113
David Gouldbdee3972012-09-11 15:32:47 +0100114 for (pp = &children_to_clean; *pp; pp = &(*pp)->next) {
115 struct child_to_clean *clean_me = *pp;
116
117 if (clean_me->pid == pid) {
118 *pp = clean_me->next;
119 free(clean_me);
Jeff Kingafe19ff2012-01-07 12:42:43 +0100120 return;
121 }
122 }
123}
124
Shawn O. Pearce9dc09c72007-03-12 14:37:28 -0400125static inline void close_pair(int fd[2])
126{
127 close(fd[0]);
128 close(fd[1]);
129}
130
Brandon Williams38124a42017-04-25 16:46:59 -0700131int is_executable(const char *name)
132{
133 struct stat st;
134
135 if (stat(name, &st) || /* stat, not lstat */
136 !S_ISREG(st.st_mode))
137 return 0;
138
139#if defined(GIT_WINDOWS_NATIVE)
140 /*
141 * On Windows there is no executable bit. The file extension
142 * indicates whether it can be run as an executable, and Git
143 * has special-handling to detect scripts and launch them
144 * through the indicated script interpreter. We test for the
145 * file extension first because virus scanners may make
146 * it quite expensive to open many files.
147 */
148 if (ends_with(name, ".exe"))
149 return S_IXUSR;
150
151{
152 /*
153 * Now that we know it does not have an executable extension,
154 * peek into the file instead.
155 */
156 char buf[3] = { 0 };
157 int n;
158 int fd = open(name, O_RDONLY);
159 st.st_mode &= ~S_IXUSR;
160 if (fd >= 0) {
161 n = read(fd, buf, 2);
162 if (n == 2)
163 /* look for a she-bang */
164 if (!strcmp(buf, "#!"))
165 st.st_mode |= S_IXUSR;
166 close(fd);
167 }
168}
169#endif
170 return st.st_mode & S_IXUSR;
171}
172
Matthias Aßhauerbb532b52023-08-04 04:08:42 +0000173#ifndef locate_in_PATH
Brandon Williams94028312017-04-25 16:47:00 -0700174/*
175 * Search $PATH for a command. This emulates the path search that
176 * execvp would perform, without actually executing the command so it
177 * can be used before fork() to prepare to run a command using
178 * execve() or after execvp() to diagnose why it failed.
179 *
180 * The caller should ensure that file contains no directory
181 * separators.
182 *
183 * Returns the path to the command, as found in $PATH or NULL if the
184 * command could not be found. The caller inherits ownership of the memory
185 * used to store the resultant path.
186 *
187 * This should not be used on Windows, where the $PATH search rules
188 * are more complicated (e.g., a search for "foo" should find
189 * "foo.exe").
190 */
Jeff King38f865c2012-03-30 03:52:18 -0400191static char *locate_in_PATH(const char *file)
192{
193 const char *p = getenv("PATH");
194 struct strbuf buf = STRBUF_INIT;
195
196 if (!p || !*p)
197 return NULL;
198
199 while (1) {
200 const char *end = strchrnul(p, ':');
201
202 strbuf_reset(&buf);
203
204 /* POSIX specifies an empty entry as the current directory. */
205 if (end != p) {
206 strbuf_add(&buf, p, end - p);
207 strbuf_addch(&buf, '/');
208 }
209 strbuf_addstr(&buf, file);
210
Brandon Williams94028312017-04-25 16:47:00 -0700211 if (is_executable(buf.buf))
Jeff King38f865c2012-03-30 03:52:18 -0400212 return strbuf_detach(&buf, NULL);
213
214 if (!*end)
215 break;
216 p = end + 1;
217 }
218
219 strbuf_release(&buf);
220 return NULL;
221}
Matthias Aßhauerbb532b52023-08-04 04:08:42 +0000222#endif
Jeff King38f865c2012-03-30 03:52:18 -0400223
Pranit Bauva3f36e6f2021-09-13 19:39:01 +0200224int exists_in_PATH(const char *command)
Jeff King38f865c2012-03-30 03:52:18 -0400225{
Pranit Bauva3f36e6f2021-09-13 19:39:01 +0200226 char *r = locate_in_PATH(command);
brian m. carlson63ab08f2020-01-07 01:36:40 +0000227 int found = r != NULL;
Jeff King38f865c2012-03-30 03:52:18 -0400228 free(r);
brian m. carlson63ab08f2020-01-07 01:36:40 +0000229 return found;
Jeff King38f865c2012-03-30 03:52:18 -0400230}
231
232int sane_execvp(const char *file, char * const argv[])
233{
Jeff Hostetleree4512e2019-02-22 14:25:01 -0800234#ifndef GIT_WINDOWS_NATIVE
235 /*
236 * execvp() doesn't return, so we all we can do is tell trace2
237 * what we are about to do and let it leave a hint in the log
238 * (unless of course the execvp() fails).
239 *
240 * we skip this for Windows because the compat layer already
241 * has to emulate the execvp() call anyway.
242 */
243 int exec_id = trace2_exec(file, (const char **)argv);
244#endif
245
Jeff King38f865c2012-03-30 03:52:18 -0400246 if (!execvp(file, argv))
247 return 0; /* cannot happen ;-) */
248
Jeff Hostetleree4512e2019-02-22 14:25:01 -0800249#ifndef GIT_WINDOWS_NATIVE
250 {
251 int ec = errno;
252 trace2_exec_result(exec_id, ec);
253 errno = ec;
254 }
255#endif
256
Jeff King38f865c2012-03-30 03:52:18 -0400257 /*
258 * When a command can't be found because one of the directories
259 * listed in $PATH is unsearchable, execvp reports EACCES, but
260 * careful usability testing (read: analysis of occasional bug
261 * reports) reveals that "No such file or directory" is more
262 * intuitive.
263 *
264 * We avoid commands with "/", because execvp will not do $PATH
265 * lookups in that case.
266 *
267 * The reassignment of EACCES to errno looks like a no-op below,
268 * but we need to protect against exists_in_PATH overwriting errno.
269 */
270 if (errno == EACCES && !strchr(file, '/'))
271 errno = exists_in_PATH(file) ? EACCES : ENOENT;
Junio C Hamanoa7855082012-07-31 12:51:30 -0700272 else if (errno == ENOTDIR && !strchr(file, '/'))
273 errno = ENOENT;
Jeff King38f865c2012-03-30 03:52:18 -0400274 return -1;
275}
276
Jeff Kingc972bf42020-07-28 16:25:12 -0400277static const char **prepare_shell_cmd(struct strvec *out, const char **argv)
Jeff King8dba1e62009-12-30 05:53:16 -0500278{
Jeff King20574f52016-02-22 17:44:39 -0500279 if (!argv[0])
Johannes Schindelin033abf92018-05-02 11:38:39 +0200280 BUG("shell command is empty");
Jeff King8dba1e62009-12-30 05:53:16 -0500281
Jeff Kingf4456442009-12-30 05:55:36 -0500282 if (strcspn(argv[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
Jonathan Nieder380395d2013-05-02 20:26:08 +0100283#ifndef GIT_WINDOWS_NATIVE
Jeff Kingc972bf42020-07-28 16:25:12 -0400284 strvec_push(out, SHELL_PATH);
Johannes Sixt77629752012-04-17 09:03:21 +0200285#else
Jeff Kingc972bf42020-07-28 16:25:12 -0400286 strvec_push(out, "sh");
Johannes Sixt77629752012-04-17 09:03:21 +0200287#endif
Jeff Kingc972bf42020-07-28 16:25:12 -0400288 strvec_push(out, "-c");
Jeff King8dba1e62009-12-30 05:53:16 -0500289
Jeff King20574f52016-02-22 17:44:39 -0500290 /*
291 * If we have no extra arguments, we do not even need to
292 * bother with the "$@" magic.
293 */
294 if (!argv[1])
Jeff Kingc972bf42020-07-28 16:25:12 -0400295 strvec_push(out, argv[0]);
Jeff King20574f52016-02-22 17:44:39 -0500296 else
Jeff Kingc972bf42020-07-28 16:25:12 -0400297 strvec_pushf(out, "%s \"$@\"", argv[0]);
Jeff King8dba1e62009-12-30 05:53:16 -0500298 }
299
Jeff Kingc972bf42020-07-28 16:25:12 -0400300 strvec_pushv(out, argv);
Jeff Kingd70a9eb2020-07-28 20:37:20 -0400301 return out->v;
Jeff King8dba1e62009-12-30 05:53:16 -0500302}
303
Jonathan Nieder380395d2013-05-02 20:26:08 +0100304#ifndef GIT_WINDOWS_NATIVE
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100305static int child_notifier = -1;
306
Brandon Williams79319b12017-04-19 16:13:24 -0700307enum child_errcode {
308 CHILD_ERR_CHDIR,
Brandon Williams53fa6752017-04-19 16:13:25 -0700309 CHILD_ERR_DUP2,
310 CHILD_ERR_CLOSE,
Eric Wong45afb1c2017-04-19 16:13:27 -0700311 CHILD_ERR_SIGPROCMASK,
Brandon Williams79319b12017-04-19 16:13:24 -0700312 CHILD_ERR_SILENT,
313 CHILD_ERR_ERRNO
314};
315
316struct child_err {
317 enum child_errcode err;
318 int syserr; /* errno */
319};
320
321static void child_die(enum child_errcode err)
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100322{
Brandon Williams79319b12017-04-19 16:13:24 -0700323 struct child_err buf;
324
325 buf.err = err;
326 buf.syserr = errno;
327
328 /* write(2) on buf smaller than PIPE_BUF (min 512) is atomic: */
329 xwrite(child_notifier, &buf, sizeof(buf));
330 _exit(1);
331}
332
Brandon Williams53fa6752017-04-19 16:13:25 -0700333static void child_dup2(int fd, int to)
334{
335 if (dup2(fd, to) < 0)
336 child_die(CHILD_ERR_DUP2);
337}
338
339static void child_close(int fd)
340{
341 if (close(fd))
342 child_die(CHILD_ERR_CLOSE);
343}
344
345static void child_close_pair(int fd[2])
346{
347 child_close(fd[0]);
348 child_close(fd[1]);
349}
350
Jeff Kingce417592023-02-24 01:39:18 -0500351static void child_error_fn(const char *err UNUSED, va_list params UNUSED)
Brandon Williams79319b12017-04-19 16:13:24 -0700352{
353 const char msg[] = "error() should not be called in child\n";
354 xwrite(2, msg, sizeof(msg) - 1);
355}
356
Jeff Kingce417592023-02-24 01:39:18 -0500357static void child_warn_fn(const char *err UNUSED, va_list params UNUSED)
Brandon Williams79319b12017-04-19 16:13:24 -0700358{
359 const char msg[] = "warn() should not be called in child\n";
360 xwrite(2, msg, sizeof(msg) - 1);
361}
362
Jeff Kingce417592023-02-24 01:39:18 -0500363static void NORETURN child_die_fn(const char *err UNUSED, va_list params UNUSED)
Brandon Williams79319b12017-04-19 16:13:24 -0700364{
365 const char msg[] = "die() should not be called in child\n";
366 xwrite(2, msg, sizeof(msg) - 1);
367 _exit(2);
368}
369
370/* this runs in the parent process */
371static void child_err_spew(struct child_process *cmd, struct child_err *cerr)
372{
373 static void (*old_errfn)(const char *err, va_list params);
Ævar Arnfjörð Bjarmasone081a7c2021-12-07 19:26:30 +0100374 report_fn die_message_routine = get_die_message_routine();
Brandon Williams79319b12017-04-19 16:13:24 -0700375
376 old_errfn = get_error_routine();
Ævar Arnfjörð Bjarmasone081a7c2021-12-07 19:26:30 +0100377 set_error_routine(die_message_routine);
Brandon Williams79319b12017-04-19 16:13:24 -0700378 errno = cerr->syserr;
379
380 switch (cerr->err) {
381 case CHILD_ERR_CHDIR:
382 error_errno("exec '%s': cd to '%s' failed",
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100383 cmd->args.v[0], cmd->dir);
Brandon Williams79319b12017-04-19 16:13:24 -0700384 break;
Brandon Williams53fa6752017-04-19 16:13:25 -0700385 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;
Eric Wong45afb1c2017-04-19 16:13:27 -0700391 case CHILD_ERR_SIGPROCMASK:
392 error_errno("sigprocmask failed restoring signals");
393 break;
Brandon Williams79319b12017-04-19 16:13:24 -0700394 case CHILD_ERR_SILENT:
395 break;
396 case CHILD_ERR_ERRNO:
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100397 error_errno("cannot exec '%s'", cmd->args.v[0]);
Brandon Williams79319b12017-04-19 16:13:24 -0700398 break;
399 }
400 set_error_routine(old_errfn);
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100401}
Brandon Williams3967e252017-04-19 16:13:19 -0700402
Jeff Kingc972bf42020-07-28 16:25:12 -0400403static int prepare_cmd(struct strvec *out, const struct child_process *cmd)
Brandon Williams3967e252017-04-19 16:13:19 -0700404{
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100405 if (!cmd->args.v[0])
Johannes Schindelin033abf92018-05-02 11:38:39 +0200406 BUG("command is empty");
Brandon Williams3967e252017-04-19 16:13:19 -0700407
Brandon Williamse3a43442017-04-19 16:13:20 -0700408 /*
409 * Add SHELL_PATH so in the event exec fails with ENOEXEC we can
410 * attempt to interpret the command with 'sh'.
411 */
Jeff Kingc972bf42020-07-28 16:25:12 -0400412 strvec_push(out, SHELL_PATH);
Brandon Williamse3a43442017-04-19 16:13:20 -0700413
Brandon Williams3967e252017-04-19 16:13:19 -0700414 if (cmd->git_cmd) {
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100415 prepare_git_cmd(out, cmd->args.v);
Brandon Williams3967e252017-04-19 16:13:19 -0700416 } else if (cmd->use_shell) {
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100417 prepare_shell_cmd(out, cmd->args.v);
Brandon Williams3967e252017-04-19 16:13:19 -0700418 } else {
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100419 strvec_pushv(out, cmd->args.v);
Brandon Williams3967e252017-04-19 16:13:19 -0700420 }
Brandon Williamse3a43442017-04-19 16:13:20 -0700421
422 /*
Andras Kucsma05ac8582020-03-27 00:36:43 +0000423 * If there are no dir separator characters in the command then perform
424 * a path lookup and use the resolved path as the command to exec. If
425 * there are dir separator characters, we have exec attempt to invoke
426 * the command directly.
Brandon Williamse3a43442017-04-19 16:13:20 -0700427 */
Jeff Kingd70a9eb2020-07-28 20:37:20 -0400428 if (!has_dir_sep(out->v[1])) {
429 char *program = locate_in_PATH(out->v[1]);
Brandon Williamse3a43442017-04-19 16:13:20 -0700430 if (program) {
Jeff Kingd70a9eb2020-07-28 20:37:20 -0400431 free((char *)out->v[1]);
432 out->v[1] = program;
Jeff King321fd822018-10-24 03:38:00 -0400433 } else {
Jeff Kingc972bf42020-07-28 16:25:12 -0400434 strvec_clear(out);
Jeff King321fd822018-10-24 03:38:00 -0400435 errno = ENOENT;
436 return -1;
Brandon Williamse3a43442017-04-19 16:13:20 -0700437 }
438 }
Jeff King321fd822018-10-24 03:38:00 -0400439
440 return 0;
Brandon Williams3967e252017-04-19 16:13:19 -0700441}
Brandon Williamsae253942017-04-19 16:13:22 -0700442
443static char **prep_childenv(const char *const *deltaenv)
444{
445 extern char **environ;
446 char **childenv;
447 struct string_list env = STRING_LIST_INIT_DUP;
448 struct strbuf key = STRBUF_INIT;
449 const char *const *p;
450 int i;
451
452 /* Construct a sorted string list consisting of the current environ */
453 for (p = (const char *const *) environ; p && *p; p++) {
454 const char *equals = strchr(*p, '=');
455
456 if (equals) {
457 strbuf_reset(&key);
458 strbuf_add(&key, *p, equals - *p);
459 string_list_append(&env, key.buf)->util = (void *) *p;
460 } else {
461 string_list_append(&env, *p)->util = (void *) *p;
462 }
463 }
464 string_list_sort(&env);
465
466 /* Merge in 'deltaenv' with the current environ */
467 for (p = deltaenv; p && *p; p++) {
468 const char *equals = strchr(*p, '=');
469
470 if (equals) {
471 /* ('key=value'), insert or replace entry */
472 strbuf_reset(&key);
473 strbuf_add(&key, *p, equals - *p);
474 string_list_insert(&env, key.buf)->util = (void *) *p;
475 } else {
476 /* otherwise ('key') remove existing entry */
477 string_list_remove(&env, *p, 0);
478 }
479 }
480
481 /* Create an array of 'char *' to be used as the childenv */
René Scharfe0e187d72017-10-01 17:14:31 +0200482 ALLOC_ARRAY(childenv, env.nr + 1);
Brandon Williamsae253942017-04-19 16:13:22 -0700483 for (i = 0; i < env.nr; i++)
484 childenv[i] = env.items[i].util;
485 childenv[env.nr] = NULL;
486
487 string_list_clear(&env, 0);
488 strbuf_release(&key);
489 return childenv;
490}
Eric Wong45afb1c2017-04-19 16:13:27 -0700491
492struct atfork_state {
493#ifndef NO_PTHREADS
494 int cs;
Johannes Sixt200a76b2010-03-06 16:40:42 +0100495#endif
Eric Wong45afb1c2017-04-19 16:13:27 -0700496 sigset_t old;
497};
498
Johannes Schindelindde74d72018-05-02 11:38:31 +0200499#define CHECK_BUG(err, msg) \
500 do { \
501 int e = (err); \
502 if (e) \
503 BUG("%s: %s", msg, strerror(e)); \
504 } while(0)
Eric Wong45afb1c2017-04-19 16:13:27 -0700505
506static void atfork_prepare(struct atfork_state *as)
507{
508 sigset_t all;
509
510 if (sigfillset(&all))
511 die_errno("sigfillset");
512#ifdef NO_PTHREADS
513 if (sigprocmask(SIG_SETMASK, &all, &as->old))
514 die_errno("sigprocmask");
515#else
Johannes Schindelindde74d72018-05-02 11:38:31 +0200516 CHECK_BUG(pthread_sigmask(SIG_SETMASK, &all, &as->old),
Eric Wong45afb1c2017-04-19 16:13:27 -0700517 "blocking all signals");
Johannes Schindelindde74d72018-05-02 11:38:31 +0200518 CHECK_BUG(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &as->cs),
Eric Wong45afb1c2017-04-19 16:13:27 -0700519 "disabling cancellation");
520#endif
521}
522
523static void atfork_parent(struct atfork_state *as)
524{
525#ifdef NO_PTHREADS
526 if (sigprocmask(SIG_SETMASK, &as->old, NULL))
527 die_errno("sigprocmask");
528#else
Johannes Schindelindde74d72018-05-02 11:38:31 +0200529 CHECK_BUG(pthread_setcancelstate(as->cs, NULL),
Eric Wong45afb1c2017-04-19 16:13:27 -0700530 "re-enabling cancellation");
Johannes Schindelindde74d72018-05-02 11:38:31 +0200531 CHECK_BUG(pthread_sigmask(SIG_SETMASK, &as->old, NULL),
Eric Wong45afb1c2017-04-19 16:13:27 -0700532 "restoring signal mask");
533#endif
534}
535#endif /* GIT_WINDOWS_NATIVE */
Johannes Sixta5487dd2010-01-10 14:07:52 +0100536
537static inline void set_cloexec(int fd)
538{
539 int flags = fcntl(fd, F_GETFD);
540 if (flags >= 0)
541 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
542}
Johannes Sixta5487dd2010-01-10 14:07:52 +0100543
Takashi Iwai507d7802015-09-04 11:35:57 +0200544static int wait_or_whine(pid_t pid, const char *argv0, int in_signal)
Johannes Sixtab0b41d2010-01-10 14:08:45 +0100545{
546 int status, code = -1;
547 pid_t waiting;
548 int failed_errno = 0;
549
550 while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
551 ; /* nothing */
552
553 if (waiting < 0) {
554 failed_errno = errno;
Jeff King96bfb2d2021-11-22 16:28:13 -0500555 if (!in_signal)
556 error_errno("waitpid for %s failed", argv0);
Johannes Sixtab0b41d2010-01-10 14:08:45 +0100557 } else if (waiting != pid) {
Jeff King96bfb2d2021-11-22 16:28:13 -0500558 if (!in_signal)
559 error("waitpid is confused (%s)", argv0);
Johannes Sixtab0b41d2010-01-10 14:08:45 +0100560 } else if (WIFSIGNALED(status)) {
561 code = WTERMSIG(status);
Jeff King96bfb2d2021-11-22 16:28:13 -0500562 if (!in_signal && code != SIGINT && code != SIGQUIT && code != SIGPIPE)
Jeff Kinga2767c52012-11-30 17:41:38 -0500563 error("%s died of signal %d", argv0, code);
Johannes Sixtab0b41d2010-01-10 14:08:45 +0100564 /*
565 * This return value is chosen so that code & 0xff
566 * mimics the exit code that a POSIX shell would report for
567 * a program that died from this signal.
568 */
Jeff King709ca732013-01-05 09:49:49 -0500569 code += 128;
Johannes Sixtab0b41d2010-01-10 14:08:45 +0100570 } else if (WIFEXITED(status)) {
571 code = WEXITSTATUS(status);
Johannes Sixtab0b41d2010-01-10 14:08:45 +0100572 } else {
Jeff King96bfb2d2021-11-22 16:28:13 -0500573 if (!in_signal)
574 error("waitpid is confused (%s)", argv0);
Johannes Sixtab0b41d2010-01-10 14:08:45 +0100575 }
Jeff Kingafe19ff2012-01-07 12:42:43 +0100576
Jeff King96bfb2d2021-11-22 16:28:13 -0500577 if (!in_signal)
578 clear_child_for_cleanup(pid);
Jeff Kingafe19ff2012-01-07 12:42:43 +0100579
Johannes Sixtab0b41d2010-01-10 14:08:45 +0100580 errno = failed_errno;
581 return code;
582}
583
Nguyễn Thái Ngọc Duyc61a9752018-01-18 16:45:11 +0700584static void trace_add_env(struct strbuf *dst, const char *const *deltaenv)
585{
586 struct string_list envs = STRING_LIST_INIT_DUP;
587 const char *const *e;
588 int i;
589 int printed_unset = 0;
590
591 /* Last one wins, see run-command.c:prep_childenv() for context */
592 for (e = deltaenv; e && *e; e++) {
593 struct strbuf key = STRBUF_INIT;
594 char *equals = strchr(*e, '=');
595
596 if (equals) {
597 strbuf_add(&key, *e, equals - *e);
598 string_list_insert(&envs, key.buf)->util = equals + 1;
599 } else {
600 string_list_insert(&envs, *e)->util = NULL;
601 }
602 strbuf_release(&key);
603 }
604
605 /* "unset X Y...;" */
606 for (i = 0; i < envs.nr; i++) {
607 const char *var = envs.items[i].string;
608 const char *val = envs.items[i].util;
609
610 if (val || !getenv(var))
611 continue;
612
613 if (!printed_unset) {
614 strbuf_addstr(dst, " unset");
615 printed_unset = 1;
616 }
617 strbuf_addf(dst, " %s", var);
618 }
619 if (printed_unset)
620 strbuf_addch(dst, ';');
621
622 /* ... followed by "A=B C=D ..." */
623 for (i = 0; i < envs.nr; i++) {
624 const char *var = envs.items[i].string;
625 const char *val = envs.items[i].util;
626 const char *oldval;
627
628 if (!val)
629 continue;
630
631 oldval = getenv(var);
632 if (oldval && !strcmp(val, oldval))
633 continue;
634
635 strbuf_addf(dst, " %s=", var);
636 sq_quote_buf_pretty(dst, val);
637 }
638 string_list_clear(&envs, 0);
639}
640
Nguyễn Thái Ngọc Duye73dd782018-01-18 16:45:09 +0700641static void trace_run_command(const struct child_process *cp)
642{
643 struct strbuf buf = STRBUF_INIT;
644
645 if (!trace_want(&trace_default_key))
646 return;
647
René Scharfe248f66e2018-03-25 12:57:50 +0200648 strbuf_addstr(&buf, "trace: run_command:");
Nguyễn Thái Ngọc Duy090a0922018-01-18 16:45:12 +0700649 if (cp->dir) {
650 strbuf_addstr(&buf, " cd ");
651 sq_quote_buf_pretty(&buf, cp->dir);
652 strbuf_addch(&buf, ';');
653 }
Ævar Arnfjörð Bjarmason29fda242022-06-02 11:09:50 +0200654 trace_add_env(&buf, cp->env.v);
Nguyễn Thái Ngọc Duy21dfc5e2018-01-18 16:45:10 +0700655 if (cp->git_cmd)
656 strbuf_addstr(&buf, " git");
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100657 sq_quote_argv_pretty(&buf, cp->args.v);
Nguyễn Thái Ngọc Duye73dd782018-01-18 16:45:09 +0700658
659 trace_printf("%s", buf.buf);
660 strbuf_release(&buf);
661}
662
Shawn O. Pearceebcb5d12007-03-10 03:28:05 -0500663int start_command(struct child_process *cmd)
Josef Weidendorferb1bf95b2005-07-31 21:17:43 +0200664{
Johannes Sixtf3b33f12007-10-19 21:47:58 +0200665 int need_in, need_out, need_err;
666 int fdin[2], fdout[2], fderr[2];
Jeff King25043d82013-03-21 11:45:00 -0400667 int failed_errno;
Stephen Boyd939296c2013-01-30 18:01:05 -0800668 char *str;
Shawn O. Pearce4919bf02007-03-10 03:28:08 -0500669
Johannes Sixtc20181e2008-02-21 23:42:56 +0100670 /*
671 * In case of errors we must keep the promise to close FDs
672 * that have been passed in via ->in and ->out.
673 */
674
Shawn O. Pearcee4507ae2007-03-12 14:37:55 -0400675 need_in = !cmd->no_stdin && cmd->in < 0;
Shawn O. Pearce4919bf02007-03-10 03:28:08 -0500676 if (need_in) {
Johannes Sixtc20181e2008-02-21 23:42:56 +0100677 if (pipe(fdin) < 0) {
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200678 failed_errno = errno;
Johannes Sixtc20181e2008-02-21 23:42:56 +0100679 if (cmd->out > 0)
680 close(cmd->out);
Stephen Boyd939296c2013-01-30 18:01:05 -0800681 str = "standard input";
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200682 goto fail_pipe;
Johannes Sixtc20181e2008-02-21 23:42:56 +0100683 }
Shawn O. Pearce4919bf02007-03-10 03:28:08 -0500684 cmd->in = fdin[1];
Shawn O. Pearce4919bf02007-03-10 03:28:08 -0500685 }
686
Shawn O. Pearcee4507ae2007-03-12 14:37:55 -0400687 need_out = !cmd->no_stdout
688 && !cmd->stdout_to_stderr
689 && cmd->out < 0;
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400690 if (need_out) {
691 if (pipe(fdout) < 0) {
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200692 failed_errno = errno;
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400693 if (need_in)
694 close_pair(fdin);
Johannes Sixtc20181e2008-02-21 23:42:56 +0100695 else if (cmd->in)
696 close(cmd->in);
Stephen Boyd939296c2013-01-30 18:01:05 -0800697 str = "standard output";
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200698 goto fail_pipe;
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400699 }
700 cmd->out = fdout[0];
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400701 }
702
Shawn O. Pearceb73a4392007-11-11 02:29:37 -0500703 need_err = !cmd->no_stderr && cmd->err < 0;
Johannes Sixtf3b33f12007-10-19 21:47:58 +0200704 if (need_err) {
705 if (pipe(fderr) < 0) {
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200706 failed_errno = errno;
Johannes Sixtf3b33f12007-10-19 21:47:58 +0200707 if (need_in)
708 close_pair(fdin);
Johannes Sixtc20181e2008-02-21 23:42:56 +0100709 else if (cmd->in)
710 close(cmd->in);
Johannes Sixtf3b33f12007-10-19 21:47:58 +0200711 if (need_out)
712 close_pair(fdout);
Johannes Sixtc20181e2008-02-21 23:42:56 +0100713 else if (cmd->out)
714 close(cmd->out);
Stephen Boyd939296c2013-01-30 18:01:05 -0800715 str = "standard error";
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200716fail_pipe:
Stephen Boyd939296c2013-01-30 18:01:05 -0800717 error("cannot create %s pipe for %s: %s",
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100718 str, cmd->args.v[0], strerror(failed_errno));
René Scharfe2d716082015-10-24 14:11:27 +0200719 child_process_clear(cmd);
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200720 errno = failed_errno;
721 return -1;
Johannes Sixtf3b33f12007-10-19 21:47:58 +0200722 }
723 cmd->err = fderr[0];
724 }
725
Jeff Hostetleree4512e2019-02-22 14:25:01 -0800726 trace2_child_start(cmd);
Nguyễn Thái Ngọc Duye73dd782018-01-18 16:45:09 +0700727 trace_run_command(cmd);
728
Johannes Sixt13af8cb2011-02-04 09:41:58 +0100729 fflush(NULL);
Johannes Schindelin8852f5d2008-07-07 14:41:34 +0100730
Johannes Schindelin28d04e12021-09-09 09:47:06 +0000731 if (cmd->close_object_store)
732 close_object_store(the_repository->objects);
733
Jonathan Nieder380395d2013-05-02 20:26:08 +0100734#ifndef GIT_WINDOWS_NATIVE
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100735{
736 int notify_pipe[2];
Brandon Williamsdb015a22017-04-19 16:13:23 -0700737 int null_fd = -1;
Brandon Williamsae253942017-04-19 16:13:22 -0700738 char **childenv;
Jeff Kingc972bf42020-07-28 16:25:12 -0400739 struct strvec argv = STRVEC_INIT;
Brandon Williams79319b12017-04-19 16:13:24 -0700740 struct child_err cerr;
Eric Wong45afb1c2017-04-19 16:13:27 -0700741 struct atfork_state as;
Brandon Williams3967e252017-04-19 16:13:19 -0700742
Jeff King321fd822018-10-24 03:38:00 -0400743 if (prepare_cmd(&argv, cmd) < 0) {
744 failed_errno = errno;
745 cmd->pid = -1;
Junio C Hamanoe5a329a2018-12-11 14:46:07 +0900746 if (!cmd->silent_exec_failure)
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100747 error_errno("cannot run %s", cmd->args.v[0]);
Jeff King321fd822018-10-24 03:38:00 -0400748 goto end_of_spawn;
749 }
750
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100751 if (pipe(notify_pipe))
752 notify_pipe[0] = notify_pipe[1] = -1;
753
Brandon Williamsdb015a22017-04-19 16:13:23 -0700754 if (cmd->no_stdin || cmd->no_stdout || cmd->no_stderr) {
René Scharfe66e905b2021-08-25 22:16:46 +0200755 null_fd = xopen("/dev/null", O_RDWR | O_CLOEXEC);
Brandon Williamsdb015a22017-04-19 16:13:23 -0700756 set_cloexec(null_fd);
757 }
758
Ævar Arnfjörð Bjarmason29fda242022-06-02 11:09:50 +0200759 childenv = prep_childenv(cmd->env.v);
Eric Wong45afb1c2017-04-19 16:13:27 -0700760 atfork_prepare(&as);
Brandon Williams3967e252017-04-19 16:13:19 -0700761
Brandon Williamse503cd62017-04-19 16:13:26 -0700762 /*
763 * NOTE: In order to prevent deadlocking when using threads special
764 * care should be taken with the function calls made in between the
765 * fork() and exec() calls. No calls should be made to functions which
766 * require acquiring a lock (e.g. malloc) as the lock could have been
767 * held by another thread at the time of forking, causing the lock to
768 * never be released in the child process. This means only
769 * Async-Signal-Safe functions are permitted in the child.
770 */
Shawn O. Pearceebcb5d12007-03-10 03:28:05 -0500771 cmd->pid = fork();
Jeff King25043d82013-03-21 11:45:00 -0400772 failed_errno = errno;
Shawn O. Pearceebcb5d12007-03-10 03:28:05 -0500773 if (!cmd->pid) {
Eric Wong45afb1c2017-04-19 16:13:27 -0700774 int sig;
Johannes Sixta5487dd2010-01-10 14:07:52 +0100775 /*
Brandon Williams79319b12017-04-19 16:13:24 -0700776 * Ensure the default die/error/warn routines do not get
777 * called, they can take stdio locks and malloc.
Johannes Sixta5487dd2010-01-10 14:07:52 +0100778 */
Brandon Williams79319b12017-04-19 16:13:24 -0700779 set_die_routine(child_die_fn);
780 set_error_routine(child_error_fn);
781 set_warn_routine(child_warn_fn);
Johannes Sixta5487dd2010-01-10 14:07:52 +0100782
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100783 close(notify_pipe[0]);
784 set_cloexec(notify_pipe[1]);
785 child_notifier = notify_pipe[1];
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100786
Shawn O. Pearcee4507ae2007-03-12 14:37:55 -0400787 if (cmd->no_stdin)
Brandon Williams53fa6752017-04-19 16:13:25 -0700788 child_dup2(null_fd, 0);
Shawn O. Pearcee4507ae2007-03-12 14:37:55 -0400789 else if (need_in) {
Brandon Williams53fa6752017-04-19 16:13:25 -0700790 child_dup2(fdin[0], 0);
791 child_close_pair(fdin);
Shawn O. Pearce4919bf02007-03-10 03:28:08 -0500792 } else if (cmd->in) {
Brandon Williams53fa6752017-04-19 16:13:25 -0700793 child_dup2(cmd->in, 0);
794 child_close(cmd->in);
Shawn O. Pearce95d3c4f2006-12-30 21:55:22 -0500795 }
Shawn O. Pearce4919bf02007-03-10 03:28:08 -0500796
Christian Couderce2cf272008-03-05 08:35:16 +0100797 if (cmd->no_stderr)
Brandon Williams53fa6752017-04-19 16:13:25 -0700798 child_dup2(null_fd, 2);
Christian Couderce2cf272008-03-05 08:35:16 +0100799 else if (need_err) {
Brandon Williams53fa6752017-04-19 16:13:25 -0700800 child_dup2(fderr[1], 2);
801 child_close_pair(fderr);
Shawn O. Pearce4f41b612010-02-05 12:57:37 -0800802 } else if (cmd->err > 1) {
Brandon Williams53fa6752017-04-19 16:13:25 -0700803 child_dup2(cmd->err, 2);
804 child_close(cmd->err);
Christian Couderce2cf272008-03-05 08:35:16 +0100805 }
806
Shawn O. Pearcee4507ae2007-03-12 14:37:55 -0400807 if (cmd->no_stdout)
Brandon Williams53fa6752017-04-19 16:13:25 -0700808 child_dup2(null_fd, 1);
Shawn O. Pearcee4507ae2007-03-12 14:37:55 -0400809 else if (cmd->stdout_to_stderr)
Brandon Williams53fa6752017-04-19 16:13:25 -0700810 child_dup2(2, 1);
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400811 else if (need_out) {
Brandon Williams53fa6752017-04-19 16:13:25 -0700812 child_dup2(fdout[1], 1);
813 child_close_pair(fdout);
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400814 } else if (cmd->out > 1) {
Brandon Williams53fa6752017-04-19 16:13:25 -0700815 child_dup2(cmd->out, 1);
816 child_close(cmd->out);
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400817 }
818
Alex Riesen1568fea2007-05-22 23:48:23 +0200819 if (cmd->dir && chdir(cmd->dir))
Brandon Williams79319b12017-04-19 16:13:24 -0700820 child_die(CHILD_ERR_CHDIR);
Brandon Williams3967e252017-04-19 16:13:19 -0700821
Brandon Williamse3a43442017-04-19 16:13:20 -0700822 /*
Eric Wong45afb1c2017-04-19 16:13:27 -0700823 * restore default signal handlers here, in case
824 * we catch a signal right before execve below
825 */
826 for (sig = 1; sig < NSIG; sig++) {
827 /* ignored signals get reset to SIG_DFL on execve */
828 if (signal(sig, SIG_DFL) == SIG_IGN)
829 signal(sig, SIG_IGN);
830 }
831
832 if (sigprocmask(SIG_SETMASK, &as.old, NULL) != 0)
833 child_die(CHILD_ERR_SIGPROCMASK);
834
835 /*
Brandon Williamse3a43442017-04-19 16:13:20 -0700836 * Attempt to exec using the command and arguments starting at
837 * argv.argv[1]. argv.argv[0] contains SHELL_PATH which will
838 * be used in the event exec failed with ENOEXEC at which point
839 * we will try to interpret the command using 'sh'.
840 */
Jeff Kingd70a9eb2020-07-28 20:37:20 -0400841 execve(argv.v[1], (char *const *) argv.v + 1,
Brandon Williamsae253942017-04-19 16:13:22 -0700842 (char *const *) childenv);
Brandon Williamse3a43442017-04-19 16:13:20 -0700843 if (errno == ENOEXEC)
Jeff Kingd70a9eb2020-07-28 20:37:20 -0400844 execve(argv.v[0], (char *const *) argv.v,
Brandon Williamsae253942017-04-19 16:13:22 -0700845 (char *const *) childenv);
Brandon Williams3967e252017-04-19 16:13:19 -0700846
René Scharfe6d224ac2023-06-10 16:51:21 +0200847 if (cmd->silent_exec_failure && errno == ENOENT)
848 child_die(CHILD_ERR_SILENT);
849 child_die(CHILD_ERR_ERRNO);
Josef Weidendorferb1bf95b2005-07-31 21:17:43 +0200850 }
Eric Wong45afb1c2017-04-19 16:13:27 -0700851 atfork_parent(&as);
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200852 if (cmd->pid < 0)
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100853 error_errno("cannot fork() for %s", cmd->args.v[0]);
Jeff Kingafe19ff2012-01-07 12:42:43 +0100854 else if (cmd->clean_on_exit)
Lars Schneiderac2fbaa2016-10-16 16:20:28 -0700855 mark_child_for_cleanup(cmd->pid, cmd);
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100856
857 /*
Brandon Williams3967e252017-04-19 16:13:19 -0700858 * Wait for child's exec. If the exec succeeds (or if fork()
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100859 * failed), EOF is seen immediately by the parent. Otherwise, the
Brandon Williams79319b12017-04-19 16:13:24 -0700860 * child process sends a child_err struct.
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100861 * Note that use of this infrastructure is completely advisory,
862 * therefore, we keep error checks minimal.
863 */
864 close(notify_pipe[1]);
Brandon Williams79319b12017-04-19 16:13:24 -0700865 if (xread(notify_pipe[0], &cerr, sizeof(cerr)) == sizeof(cerr)) {
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100866 /*
Brandon Williams3967e252017-04-19 16:13:19 -0700867 * At this point we know that fork() succeeded, but exec()
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100868 * failed. Errors have been reported to our stderr.
869 */
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100870 wait_or_whine(cmd->pid, cmd->args.v[0], 0);
Brandon Williams79319b12017-04-19 16:13:24 -0700871 child_err_spew(cmd, &cerr);
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100872 failed_errno = errno;
873 cmd->pid = -1;
874 }
875 close(notify_pipe[0]);
Brandon Williams3967e252017-04-19 16:13:19 -0700876
Brandon Williamsdb015a22017-04-19 16:13:23 -0700877 if (null_fd >= 0)
878 close(null_fd);
Jeff Kingc972bf42020-07-28 16:25:12 -0400879 strvec_clear(&argv);
Brandon Williamsae253942017-04-19 16:13:22 -0700880 free(childenv);
Johannes Sixt2b541bf2010-01-10 14:11:22 +0100881}
Jeff King321fd822018-10-24 03:38:00 -0400882end_of_spawn:
883
Johannes Sixtba26f292007-12-07 22:08:59 +0100884#else
Frank Li0d30ad72009-09-16 10:20:17 +0200885{
Johannes Sixt75301f92010-01-15 21:12:18 +0100886 int fhin = 0, fhout = 1, fherr = 2;
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100887 const char **sargv = cmd->args.v;
Jeff Kingc972bf42020-07-28 16:25:12 -0400888 struct strvec nargv = STRVEC_INIT;
Johannes Sixtba26f292007-12-07 22:08:59 +0100889
Johannes Sixt75301f92010-01-15 21:12:18 +0100890 if (cmd->no_stdin)
891 fhin = open("/dev/null", O_RDWR);
892 else if (need_in)
893 fhin = dup(fdin[0]);
894 else if (cmd->in)
895 fhin = dup(cmd->in);
Johannes Sixtba26f292007-12-07 22:08:59 +0100896
Johannes Sixt75301f92010-01-15 21:12:18 +0100897 if (cmd->no_stderr)
898 fherr = open("/dev/null", O_RDWR);
899 else if (need_err)
900 fherr = dup(fderr[1]);
Junio C Hamano76d44c82010-02-05 21:08:53 -0800901 else if (cmd->err > 2)
902 fherr = dup(cmd->err);
Johannes Sixtba26f292007-12-07 22:08:59 +0100903
Johannes Sixt75301f92010-01-15 21:12:18 +0100904 if (cmd->no_stdout)
905 fhout = open("/dev/null", O_RDWR);
906 else if (cmd->stdout_to_stderr)
907 fhout = dup(fherr);
908 else if (need_out)
909 fhout = dup(fdout[1]);
910 else if (cmd->out > 1)
911 fhout = dup(cmd->out);
Johannes Sixtba26f292007-12-07 22:08:59 +0100912
Felipe Contreras5a500852013-10-31 03:25:45 -0600913 if (cmd->git_cmd)
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100914 cmd->args.v = prepare_git_cmd(&nargv, sargv);
Felipe Contreras5a500852013-10-31 03:25:45 -0600915 else if (cmd->use_shell)
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100916 cmd->args.v = prepare_shell_cmd(&nargv, sargv);
Johannes Sixtba26f292007-12-07 22:08:59 +0100917
Ævar Arnfjörð Bjarmason29fda242022-06-02 11:09:50 +0200918 cmd->pid = mingw_spawnvpe(cmd->args.v[0], cmd->args.v,
919 (char**) cmd->env.v,
920 cmd->dir, fhin, fhout, fherr);
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200921 failed_errno = errno;
Johannes Sixtc024beb2009-07-04 21:26:42 +0200922 if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100923 error_errno("cannot spawn %s", cmd->args.v[0]);
Jeff Kingafe19ff2012-01-07 12:42:43 +0100924 if (cmd->clean_on_exit && cmd->pid >= 0)
Lars Schneiderac2fbaa2016-10-16 16:20:28 -0700925 mark_child_for_cleanup(cmd->pid, cmd);
Johannes Sixtba26f292007-12-07 22:08:59 +0100926
Jeff Kingc972bf42020-07-28 16:25:12 -0400927 strvec_clear(&nargv);
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100928 cmd->args.v = sargv;
Johannes Sixt75301f92010-01-15 21:12:18 +0100929 if (fhin != 0)
930 close(fhin);
931 if (fhout != 1)
932 close(fhout);
933 if (fherr != 2)
934 close(fherr);
Frank Li0d30ad72009-09-16 10:20:17 +0200935}
Johannes Sixtba26f292007-12-07 22:08:59 +0100936#endif
937
938 if (cmd->pid < 0) {
Jeff Hostetleree4512e2019-02-22 14:25:01 -0800939 trace2_child_exit(cmd, -1);
940
Johannes Sixtba26f292007-12-07 22:08:59 +0100941 if (need_in)
942 close_pair(fdin);
943 else if (cmd->in)
944 close(cmd->in);
945 if (need_out)
946 close_pair(fdout);
947 else if (cmd->out)
948 close(cmd->out);
949 if (need_err)
950 close_pair(fderr);
bert Dvornikfc012c22010-05-20 20:57:52 +0200951 else if (cmd->err)
952 close(cmd->err);
René Scharfe2d716082015-10-24 14:11:27 +0200953 child_process_clear(cmd);
Johannes Sixt0ac77ec2009-07-04 21:26:40 +0200954 errno = failed_errno;
955 return -1;
Johannes Sixtba26f292007-12-07 22:08:59 +0100956 }
Shawn O. Pearce4919bf02007-03-10 03:28:08 -0500957
958 if (need_in)
959 close(fdin[0]);
960 else if (cmd->in)
961 close(cmd->in);
962
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400963 if (need_out)
964 close(fdout[1]);
Johannes Sixtc20181e2008-02-21 23:42:56 +0100965 else if (cmd->out)
Shawn O. Pearcef4bba252007-03-12 14:37:45 -0400966 close(cmd->out);
967
Johannes Sixtf3b33f12007-10-19 21:47:58 +0200968 if (need_err)
969 close(fderr[1]);
Shawn O. Pearce4f41b612010-02-05 12:57:37 -0800970 else if (cmd->err)
971 close(cmd->err);
Johannes Sixtf3b33f12007-10-19 21:47:58 +0200972
Shawn O. Pearceebcb5d12007-03-10 03:28:05 -0500973 return 0;
974}
975
Johannes Sixt2d22c202007-10-19 21:48:00 +0200976int finish_command(struct child_process *cmd)
977{
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100978 int ret = wait_or_whine(cmd->pid, cmd->args.v[0], 0);
Jeff Hostetleree4512e2019-02-22 14:25:01 -0800979 trace2_child_exit(cmd, ret);
René Scharfe2d716082015-10-24 14:11:27 +0200980 child_process_clear(cmd);
Johannes Schindelin0d58fef2021-02-02 22:09:52 +0100981 invalidate_lstat_cache();
Jeff Kingc460c0e2014-05-15 04:33:26 -0400982 return ret;
Johannes Sixt2d22c202007-10-19 21:48:00 +0200983}
984
Takashi Iwai507d7802015-09-04 11:35:57 +0200985int finish_command_in_signal(struct child_process *cmd)
986{
Ævar Arnfjörð Bjarmasond3b21592021-11-25 23:52:22 +0100987 int ret = wait_or_whine(cmd->pid, cmd->args.v[0], 1);
Josh Steadmonce3986b2022-06-07 11:21:57 -0700988 if (ret != -1)
989 trace2_child_exit(cmd, ret);
Jeff Hostetleree4512e2019-02-22 14:25:01 -0800990 return ret;
Takashi Iwai507d7802015-09-04 11:35:57 +0200991}
992
993
Shawn O. Pearceebcb5d12007-03-10 03:28:05 -0500994int run_command(struct child_process *cmd)
995{
Jeff Kingc29b3962015-03-22 23:54:05 -0400996 int code;
997
998 if (cmd->out < 0 || cmd->err < 0)
Johannes Schindelin033abf92018-05-02 11:38:39 +0200999 BUG("run_command with a pipe can cause deadlock");
Jeff Kingc29b3962015-03-22 23:54:05 -04001000
1001 code = start_command(cmd);
Shawn O. Pearceebcb5d12007-03-10 03:28:05 -05001002 if (code)
1003 return code;
1004 return finish_command(cmd);
1005}
1006
Johannes Sixtf6b60982010-03-09 21:00:36 +01001007#ifndef NO_PTHREADS
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001008static pthread_t main_thread;
1009static int main_thread_set;
1010static pthread_key_t async_key;
Jeff King1ece66b2013-04-16 15:50:07 -04001011static pthread_key_t async_die_counter;
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001012
Johannes Sixt200a76b2010-03-06 16:40:42 +01001013static void *run_thread(void *data)
Johannes Sixt618ebe92007-12-08 22:19:14 +01001014{
1015 struct async *async = data;
Johannes Sixtf6b60982010-03-09 21:00:36 +01001016 intptr_t ret;
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001017
Jeff Kingc792d7b2016-04-19 18:49:41 -04001018 if (async->isolate_sigpipe) {
1019 sigset_t mask;
1020 sigemptyset(&mask);
1021 sigaddset(&mask, SIGPIPE);
Seija786e6762022-12-02 17:02:58 +00001022 if (pthread_sigmask(SIG_BLOCK, &mask, NULL)) {
Jeff Kingc792d7b2016-04-19 18:49:41 -04001023 ret = error("unable to block SIGPIPE in async thread");
1024 return (void *)ret;
1025 }
1026 }
1027
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001028 pthread_setspecific(async_key, async);
Johannes Sixtf6b60982010-03-09 21:00:36 +01001029 ret = async->proc(async->proc_in, async->proc_out, async->data);
Johannes Sixt200a76b2010-03-06 16:40:42 +01001030 return (void *)ret;
Johannes Sixt618ebe92007-12-08 22:19:14 +01001031}
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001032
1033static NORETURN void die_async(const char *err, va_list params)
1034{
Ævar Arnfjörð Bjarmasone081a7c2021-12-07 19:26:30 +01001035 report_fn die_message_fn = get_die_message_routine();
1036
1037 die_message_fn(err, params);
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001038
Jeff King661a8cf2015-09-01 16:22:43 -04001039 if (in_async()) {
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001040 struct async *async = pthread_getspecific(async_key);
1041 if (async->proc_in >= 0)
1042 close(async->proc_in);
1043 if (async->proc_out >= 0)
1044 close(async->proc_out);
1045 pthread_exit((void *)128);
1046 }
1047
1048 exit(128);
Johannes Sixt618ebe92007-12-08 22:19:14 +01001049}
Jeff King1ece66b2013-04-16 15:50:07 -04001050
1051static int async_die_is_recursing(void)
1052{
1053 void *ret = pthread_getspecific(async_die_counter);
Victoria Dye4b540cf2021-11-04 04:01:03 +00001054 pthread_setspecific(async_die_counter, &async_die_counter); /* set to any non-NULL valid pointer */
Jeff King1ece66b2013-04-16 15:50:07 -04001055 return ret != NULL;
1056}
1057
Jeff King661a8cf2015-09-01 16:22:43 -04001058int in_async(void)
1059{
1060 if (!main_thread_set)
1061 return 0; /* no asyncs started yet */
1062 return !pthread_equal(main_thread, pthread_self());
1063}
1064
Lars Schneiderb992fe12016-10-16 16:20:27 -07001065static void NORETURN async_exit(int code)
Jeff King96588462016-02-24 02:40:16 -05001066{
1067 pthread_exit((void *)(intptr_t)code);
1068}
1069
Etienne Buira0f4b6db2014-10-18 14:31:15 +02001070#else
1071
1072static struct {
1073 void (**handlers)(void);
1074 size_t nr;
1075 size_t alloc;
1076} git_atexit_hdlrs;
1077
1078static int git_atexit_installed;
1079
René Scharfe6066a7e2014-11-10 22:17:00 +01001080static void git_atexit_dispatch(void)
Etienne Buira0f4b6db2014-10-18 14:31:15 +02001081{
1082 size_t i;
1083
1084 for (i=git_atexit_hdlrs.nr ; i ; i--)
1085 git_atexit_hdlrs.handlers[i-1]();
1086}
1087
René Scharfe6066a7e2014-11-10 22:17:00 +01001088static void git_atexit_clear(void)
Etienne Buira0f4b6db2014-10-18 14:31:15 +02001089{
1090 free(git_atexit_hdlrs.handlers);
1091 memset(&git_atexit_hdlrs, 0, sizeof(git_atexit_hdlrs));
1092 git_atexit_installed = 0;
1093}
1094
1095#undef atexit
1096int git_atexit(void (*handler)(void))
1097{
1098 ALLOC_GROW(git_atexit_hdlrs.handlers, git_atexit_hdlrs.nr + 1, git_atexit_hdlrs.alloc);
1099 git_atexit_hdlrs.handlers[git_atexit_hdlrs.nr++] = handler;
1100 if (!git_atexit_installed) {
1101 if (atexit(&git_atexit_dispatch))
1102 return -1;
1103 git_atexit_installed = 1;
1104 }
1105 return 0;
1106}
1107#define atexit git_atexit
1108
Jeff King661a8cf2015-09-01 16:22:43 -04001109static int process_is_async;
1110int in_async(void)
1111{
1112 return process_is_async;
1113}
1114
Lars Schneiderb992fe12016-10-16 16:20:27 -07001115static void NORETURN async_exit(int code)
Jeff King96588462016-02-24 02:40:16 -05001116{
1117 exit(code);
1118}
1119
Johannes Sixt618ebe92007-12-08 22:19:14 +01001120#endif
1121
Lars Schneiderb992fe12016-10-16 16:20:27 -07001122void check_pipe(int err)
1123{
1124 if (err == EPIPE) {
1125 if (in_async())
1126 async_exit(141);
1127
1128 signal(SIGPIPE, SIG_DFL);
1129 raise(SIGPIPE);
1130 /* Should never happen, but just in case... */
1131 exit(141);
1132 }
1133}
1134
Johannes Sixt2d22c202007-10-19 21:48:00 +02001135int start_async(struct async *async)
1136{
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001137 int need_in, need_out;
1138 int fdin[2], fdout[2];
1139 int proc_in, proc_out;
Johannes Sixt2d22c202007-10-19 21:48:00 +02001140
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001141 need_in = async->in < 0;
1142 if (need_in) {
1143 if (pipe(fdin) < 0) {
1144 if (async->out > 0)
1145 close(async->out);
Nguyễn Thái Ngọc Duyfbcb0e02016-05-08 16:47:53 +07001146 return error_errno("cannot create pipe");
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001147 }
1148 async->in = fdin[1];
1149 }
1150
1151 need_out = async->out < 0;
1152 if (need_out) {
1153 if (pipe(fdout) < 0) {
1154 if (need_in)
1155 close_pair(fdin);
1156 else if (async->in)
1157 close(async->in);
Nguyễn Thái Ngọc Duyfbcb0e02016-05-08 16:47:53 +07001158 return error_errno("cannot create pipe");
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001159 }
1160 async->out = fdout[0];
1161 }
1162
1163 if (need_in)
1164 proc_in = fdin[0];
1165 else if (async->in)
1166 proc_in = async->in;
1167 else
1168 proc_in = -1;
1169
1170 if (need_out)
1171 proc_out = fdout[1];
1172 else if (async->out)
1173 proc_out = async->out;
1174 else
1175 proc_out = -1;
Johannes Sixt2d22c202007-10-19 21:48:00 +02001176
Johannes Sixtf6b60982010-03-09 21:00:36 +01001177#ifdef NO_PTHREADS
Anders Melchiorsen2c3766f2008-08-04 02:30:03 +02001178 /* Flush stdio before fork() to avoid cloning buffers */
1179 fflush(NULL);
1180
Johannes Sixt2d22c202007-10-19 21:48:00 +02001181 async->pid = fork();
1182 if (async->pid < 0) {
Nguyễn Thái Ngọc Duyfbcb0e02016-05-08 16:47:53 +07001183 error_errno("fork (async) failed");
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001184 goto error;
Johannes Sixt2d22c202007-10-19 21:48:00 +02001185 }
1186 if (!async->pid) {
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001187 if (need_in)
1188 close(fdin[1]);
1189 if (need_out)
1190 close(fdout[0]);
Etienne Buira0f4b6db2014-10-18 14:31:15 +02001191 git_atexit_clear();
Jeff King661a8cf2015-09-01 16:22:43 -04001192 process_is_async = 1;
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001193 exit(!!async->proc(proc_in, proc_out, async->data));
Johannes Sixt2d22c202007-10-19 21:48:00 +02001194 }
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001195
Lars Schneiderac2fbaa2016-10-16 16:20:28 -07001196 mark_child_for_cleanup(async->pid, NULL);
Jeff Kingafe19ff2012-01-07 12:42:43 +01001197
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001198 if (need_in)
1199 close(fdin[0]);
1200 else if (async->in)
1201 close(async->in);
1202
1203 if (need_out)
1204 close(fdout[1]);
1205 else if (async->out)
1206 close(async->out);
Johannes Sixt618ebe92007-12-08 22:19:14 +01001207#else
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001208 if (!main_thread_set) {
1209 /*
1210 * We assume that the first time that start_async is called
1211 * it is from the main thread.
1212 */
1213 main_thread_set = 1;
1214 main_thread = pthread_self();
1215 pthread_key_create(&async_key, NULL);
Jeff King1ece66b2013-04-16 15:50:07 -04001216 pthread_key_create(&async_die_counter, NULL);
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001217 set_die_routine(die_async);
Jeff King1ece66b2013-04-16 15:50:07 -04001218 set_die_is_recursing_routine(async_die_is_recursing);
Johannes Sixt0ea1c892010-03-06 16:40:43 +01001219 }
1220
Johannes Sixt200a76b2010-03-06 16:40:42 +01001221 if (proc_in >= 0)
1222 set_cloexec(proc_in);
1223 if (proc_out >= 0)
1224 set_cloexec(proc_out);
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001225 async->proc_in = proc_in;
1226 async->proc_out = proc_out;
Johannes Sixt200a76b2010-03-06 16:40:42 +01001227 {
1228 int err = pthread_create(&async->tid, NULL, run_thread, async);
1229 if (err) {
Nguyễn Thái Ngọc Duy21790452018-11-03 09:48:50 +01001230 error(_("cannot create async thread: %s"), strerror(err));
Johannes Sixt200a76b2010-03-06 16:40:42 +01001231 goto error;
1232 }
Johannes Sixt618ebe92007-12-08 22:19:14 +01001233 }
1234#endif
Johannes Sixt2d22c202007-10-19 21:48:00 +02001235 return 0;
Erik Faye-Lundae6a5602010-02-05 12:57:38 -08001236
1237error:
1238 if (need_in)
1239 close_pair(fdin);
1240 else if (async->in)
1241 close(async->in);
1242
1243 if (need_out)
1244 close_pair(fdout);
1245 else if (async->out)
1246 close(async->out);
1247 return -1;
Johannes Sixt2d22c202007-10-19 21:48:00 +02001248}
1249
1250int finish_async(struct async *async)
1251{
Johannes Sixtf6b60982010-03-09 21:00:36 +01001252#ifdef NO_PTHREADS
Johannes Schindelin0d58fef2021-02-02 22:09:52 +01001253 int ret = wait_or_whine(async->pid, "child process", 0);
1254
1255 invalidate_lstat_cache();
1256
1257 return ret;
Johannes Sixt618ebe92007-12-08 22:19:14 +01001258#else
Johannes Sixt200a76b2010-03-06 16:40:42 +01001259 void *ret = (void *)(intptr_t)(-1);
1260
1261 if (pthread_join(async->tid, &ret))
1262 error("pthread_join failed");
Johannes Schindelin0d58fef2021-02-02 22:09:52 +01001263 invalidate_lstat_cache();
Johannes Sixt200a76b2010-03-06 16:40:42 +01001264 return (int)(intptr_t)ret;
Johannes Schindelin0d58fef2021-02-02 22:09:52 +01001265
Johannes Sixt618ebe92007-12-08 22:19:14 +01001266#endif
Johannes Sixt2d22c202007-10-19 21:48:00 +02001267}
Stephan Beyerae98a002009-01-16 20:09:59 +01001268
Nguyễn Thái Ngọc Duyc0e40a22018-11-03 09:48:39 +01001269int async_with_fork(void)
1270{
1271#ifdef NO_PTHREADS
1272 return 1;
1273#else
1274 return 0;
1275#endif
1276}
1277
Jeff King96335bc2016-06-17 19:38:47 -04001278struct io_pump {
1279 /* initialized by caller */
1280 int fd;
1281 int type; /* POLLOUT or POLLIN */
1282 union {
1283 struct {
1284 const char *buf;
1285 size_t len;
1286 } out;
1287 struct {
1288 struct strbuf *buf;
1289 size_t hint;
1290 } in;
1291 } u;
1292
1293 /* returned by pump_io */
1294 int error; /* 0 for success, otherwise errno */
1295
1296 /* internal use */
1297 struct pollfd *pfd;
1298};
1299
1300static int pump_io_round(struct io_pump *slots, int nr, struct pollfd *pfd)
Jeff King911ec992015-03-22 23:53:43 -04001301{
Jeff King96335bc2016-06-17 19:38:47 -04001302 int pollsize = 0;
1303 int i;
1304
1305 for (i = 0; i < nr; i++) {
1306 struct io_pump *io = &slots[i];
1307 if (io->fd < 0)
1308 continue;
1309 pfd[pollsize].fd = io->fd;
1310 pfd[pollsize].events = io->type;
1311 io->pfd = &pfd[pollsize++];
1312 }
1313
1314 if (!pollsize)
1315 return 0;
1316
1317 if (poll(pfd, pollsize, -1) < 0) {
1318 if (errno == EINTR)
1319 return 1;
1320 die_errno("poll failed");
1321 }
1322
1323 for (i = 0; i < nr; i++) {
1324 struct io_pump *io = &slots[i];
1325
1326 if (io->fd < 0)
1327 continue;
1328
1329 if (!(io->pfd->revents & (POLLOUT|POLLIN|POLLHUP|POLLERR|POLLNVAL)))
1330 continue;
1331
1332 if (io->type == POLLOUT) {
Jeff King14eab812022-08-17 02:08:06 -04001333 ssize_t len;
1334
1335 /*
1336 * Don't use xwrite() here. It loops forever on EAGAIN,
1337 * and we're in our own poll() loop here.
1338 *
1339 * Note that we lose xwrite()'s handling of MAX_IO_SIZE
1340 * and EINTR, so we have to implement those ourselves.
1341 */
1342 len = write(io->fd, io->u.out.buf,
1343 io->u.out.len <= MAX_IO_SIZE ?
1344 io->u.out.len : MAX_IO_SIZE);
Jeff King96335bc2016-06-17 19:38:47 -04001345 if (len < 0) {
Jeff Kingc6d3cce2022-08-17 02:09:42 -04001346 if (errno != EINTR && errno != EAGAIN &&
1347 errno != ENOSPC) {
Jeff King14eab812022-08-17 02:08:06 -04001348 io->error = errno;
1349 close(io->fd);
1350 io->fd = -1;
1351 }
Jeff King96335bc2016-06-17 19:38:47 -04001352 } else {
1353 io->u.out.buf += len;
1354 io->u.out.len -= len;
1355 if (!io->u.out.len) {
1356 close(io->fd);
1357 io->fd = -1;
1358 }
1359 }
1360 }
1361
1362 if (io->type == POLLIN) {
1363 ssize_t len = strbuf_read_once(io->u.in.buf,
1364 io->fd, io->u.in.hint);
1365 if (len < 0)
1366 io->error = errno;
1367 if (len <= 0) {
1368 close(io->fd);
1369 io->fd = -1;
1370 }
1371 }
1372 }
1373
1374 return 1;
1375}
1376
1377static int pump_io(struct io_pump *slots, int nr)
1378{
1379 struct pollfd *pfd;
1380 int i;
1381
1382 for (i = 0; i < nr; i++)
1383 slots[i].error = 0;
1384
1385 ALLOC_ARRAY(pfd, nr);
1386 while (pump_io_round(slots, nr, pfd))
1387 ; /* nothing */
1388 free(pfd);
1389
1390 /* There may be multiple errno values, so just pick the first. */
1391 for (i = 0; i < nr; i++) {
1392 if (slots[i].error) {
1393 errno = slots[i].error;
1394 return -1;
1395 }
1396 }
1397 return 0;
1398}
1399
1400
1401int pipe_command(struct child_process *cmd,
1402 const char *in, size_t in_len,
1403 struct strbuf *out, size_t out_hint,
1404 struct strbuf *err, size_t err_hint)
1405{
1406 struct io_pump io[3];
1407 int nr = 0;
1408
1409 if (in)
1410 cmd->in = -1;
1411 if (out)
1412 cmd->out = -1;
1413 if (err)
1414 cmd->err = -1;
1415
Jeff King911ec992015-03-22 23:53:43 -04001416 if (start_command(cmd) < 0)
1417 return -1;
1418
Jeff King96335bc2016-06-17 19:38:47 -04001419 if (in) {
Jeff King716c1f62022-08-17 02:10:22 -04001420 if (enable_pipe_nonblock(cmd->in) < 0) {
1421 error_errno("unable to make pipe non-blocking");
1422 close(cmd->in);
1423 if (out)
1424 close(cmd->out);
1425 if (err)
1426 close(cmd->err);
1427 return -1;
1428 }
Jeff King96335bc2016-06-17 19:38:47 -04001429 io[nr].fd = cmd->in;
1430 io[nr].type = POLLOUT;
1431 io[nr].u.out.buf = in;
1432 io[nr].u.out.len = in_len;
1433 nr++;
1434 }
1435 if (out) {
1436 io[nr].fd = cmd->out;
1437 io[nr].type = POLLIN;
1438 io[nr].u.in.buf = out;
1439 io[nr].u.in.hint = out_hint;
1440 nr++;
1441 }
1442 if (err) {
1443 io[nr].fd = cmd->err;
1444 io[nr].type = POLLIN;
1445 io[nr].u.in.buf = err;
1446 io[nr].u.in.hint = err_hint;
1447 nr++;
1448 }
1449
1450 if (pump_io(io, nr) < 0) {
Jeff King911ec992015-03-22 23:53:43 -04001451 finish_command(cmd); /* throw away exit code */
1452 return -1;
1453 }
1454
Jeff King911ec992015-03-22 23:53:43 -04001455 return finish_command(cmd);
1456}
Stefan Bellerc553c722015-12-15 16:04:10 -08001457
1458enum child_state {
1459 GIT_CP_FREE,
1460 GIT_CP_WORKING,
1461 GIT_CP_WAIT_CLEANUP,
1462};
1463
1464struct parallel_processes {
Ævar Arnfjörð Bjarmason6a48b422022-10-12 23:02:23 +02001465 size_t nr_processes;
Stefan Bellerc553c722015-12-15 16:04:10 -08001466
Stefan Bellerc553c722015-12-15 16:04:10 -08001467 struct {
1468 enum child_state state;
1469 struct child_process process;
1470 struct strbuf err;
1471 void *data;
1472 } *children;
1473 /*
1474 * The struct pollfd is logically part of *children,
1475 * but the system call expects it as its own array.
1476 */
1477 struct pollfd *pfd;
1478
1479 unsigned shutdown : 1;
1480
Ævar Arnfjörð Bjarmason6a48b422022-10-12 23:02:23 +02001481 size_t output_owner;
Stefan Bellerc553c722015-12-15 16:04:10 -08001482 struct strbuf buffered_output; /* of finished children */
1483};
1484
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001485struct parallel_processes_for_signal {
1486 const struct run_process_parallel_opts *opts;
1487 const struct parallel_processes *pp;
1488};
1489
1490static void kill_children(const struct parallel_processes *pp,
1491 const struct run_process_parallel_opts *opts,
1492 int signo)
Stefan Bellerc553c722015-12-15 16:04:10 -08001493{
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001494 for (size_t i = 0; i < opts->processes; i++)
Stefan Bellerc553c722015-12-15 16:04:10 -08001495 if (pp->children[i].state == GIT_CP_WORKING)
1496 kill(pp->children[i].process.pid, signo);
1497}
1498
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001499static void kill_children_signal(const struct parallel_processes_for_signal *pp_sig,
1500 int signo)
1501{
1502 kill_children(pp_sig->pp, pp_sig->opts, signo);
1503}
1504
1505static struct parallel_processes_for_signal *pp_for_signal;
Stefan Bellerc553c722015-12-15 16:04:10 -08001506
1507static void handle_children_on_signal(int signo)
1508{
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001509 kill_children_signal(pp_for_signal, signo);
Stefan Bellerc553c722015-12-15 16:04:10 -08001510 sigchain_pop(signo);
1511 raise(signo);
1512}
1513
1514static void pp_init(struct parallel_processes *pp,
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001515 const struct run_process_parallel_opts *opts,
1516 struct parallel_processes_for_signal *pp_sig)
Stefan Bellerc553c722015-12-15 16:04:10 -08001517{
Ævar Arnfjörð Bjarmason6e5ba0b2022-10-12 23:02:26 +02001518 const size_t n = opts->processes;
Ævar Arnfjörð Bjarmasonc333e6f2022-10-12 23:02:25 +02001519
Ævar Arnfjörð Bjarmason51243f92022-10-12 23:02:24 +02001520 if (!n)
1521 BUG("you must provide a non-zero number of processes!");
Stefan Bellerc553c722015-12-15 16:04:10 -08001522
Ævar Arnfjörð Bjarmason6a48b422022-10-12 23:02:23 +02001523 trace_printf("run_processes_parallel: preparing to run up to %"PRIuMAX" tasks",
1524 (uintmax_t)n);
Stefan Bellerc553c722015-12-15 16:04:10 -08001525
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001526 if (!opts->get_next_task)
Johannes Schindelin033abf92018-05-02 11:38:39 +02001527 BUG("you need to specify a get_next_task function");
Stefan Bellerc553c722015-12-15 16:04:10 -08001528
René Scharfeca56dad2021-03-13 17:17:22 +01001529 CALLOC_ARRAY(pp->children, n);
Ævar Arnfjörð Bjarmason357f8e62022-10-12 23:02:30 +02001530 if (!opts->ungroup)
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001531 CALLOC_ARRAY(pp->pfd, n);
Stefan Bellerc553c722015-12-15 16:04:10 -08001532
Ævar Arnfjörð Bjarmason6a48b422022-10-12 23:02:23 +02001533 for (size_t i = 0; i < n; i++) {
Stefan Bellerc553c722015-12-15 16:04:10 -08001534 strbuf_init(&pp->children[i].err, 0);
1535 child_process_init(&pp->children[i].process);
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001536 if (pp->pfd) {
1537 pp->pfd[i].events = POLLIN | POLLHUP;
1538 pp->pfd[i].fd = -1;
1539 }
Stefan Bellerc553c722015-12-15 16:04:10 -08001540 }
1541
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001542 pp_sig->pp = pp;
1543 pp_sig->opts = opts;
1544 pp_for_signal = pp_sig;
Stefan Bellerc553c722015-12-15 16:04:10 -08001545 sigchain_push_common(handle_children_on_signal);
1546}
1547
Ævar Arnfjörð Bjarmasond1610ee2022-10-12 23:02:33 +02001548static void pp_cleanup(struct parallel_processes *pp,
1549 const struct run_process_parallel_opts *opts)
Stefan Bellerc553c722015-12-15 16:04:10 -08001550{
Stefan Bellerc553c722015-12-15 16:04:10 -08001551 trace_printf("run_processes_parallel: done");
Ævar Arnfjörð Bjarmasond1610ee2022-10-12 23:02:33 +02001552 for (size_t i = 0; i < opts->processes; i++) {
Stefan Bellerc553c722015-12-15 16:04:10 -08001553 strbuf_release(&pp->children[i].err);
1554 child_process_clear(&pp->children[i].process);
1555 }
1556
1557 free(pp->children);
1558 free(pp->pfd);
1559
1560 /*
1561 * When get_next_task added messages to the buffer in its last
1562 * iteration, the buffered output is non empty.
1563 */
Stefan Beller2dac9b52016-02-29 18:07:15 -08001564 strbuf_write(&pp->buffered_output, stderr);
Stefan Bellerc553c722015-12-15 16:04:10 -08001565 strbuf_release(&pp->buffered_output);
1566
1567 sigchain_pop_common();
1568}
1569
1570/* returns
1571 * 0 if a new task was started.
1572 * 1 if no new jobs was started (get_next_task ran out of work, non critical
1573 * problem with starting a new command)
1574 * <0 no new job was started, user wishes to shutdown early. Use negative code
1575 * to signal the children.
1576 */
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001577static int pp_start_one(struct parallel_processes *pp,
1578 const struct run_process_parallel_opts *opts)
Stefan Bellerc553c722015-12-15 16:04:10 -08001579{
Ævar Arnfjörð Bjarmason6a48b422022-10-12 23:02:23 +02001580 size_t i;
1581 int code;
Stefan Bellerc553c722015-12-15 16:04:10 -08001582
Ævar Arnfjörð Bjarmason9f3df6c2022-10-12 23:02:32 +02001583 for (i = 0; i < opts->processes; i++)
Stefan Bellerc553c722015-12-15 16:04:10 -08001584 if (pp->children[i].state == GIT_CP_FREE)
1585 break;
Ævar Arnfjörð Bjarmason9f3df6c2022-10-12 23:02:32 +02001586 if (i == opts->processes)
Johannes Schindelin033abf92018-05-02 11:38:39 +02001587 BUG("bookkeeping is hard");
Stefan Bellerc553c722015-12-15 16:04:10 -08001588
Emily Shaffer54026732023-02-08 20:21:12 +01001589 /*
1590 * By default, do not inherit stdin from the parent process - otherwise,
1591 * all children would share stdin! Users may overwrite this to provide
1592 * something to the child's stdin by having their 'get_next_task'
1593 * callback assign 0 to .no_stdin and an appropriate integer to .in.
1594 */
1595 pp->children[i].process.no_stdin = 1;
1596
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001597 code = opts->get_next_task(&pp->children[i].process,
Ævar Arnfjörð Bjarmason357f8e62022-10-12 23:02:30 +02001598 opts->ungroup ? NULL : &pp->children[i].err,
Ævar Arnfjörð Bjarmason2aa8d222022-10-12 23:02:31 +02001599 opts->data,
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001600 &pp->children[i].data);
Stefan Bellerc553c722015-12-15 16:04:10 -08001601 if (!code) {
Ævar Arnfjörð Bjarmason357f8e62022-10-12 23:02:30 +02001602 if (!opts->ungroup) {
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001603 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1604 strbuf_reset(&pp->children[i].err);
1605 }
Stefan Bellerc553c722015-12-15 16:04:10 -08001606 return 1;
1607 }
Ævar Arnfjörð Bjarmason357f8e62022-10-12 23:02:30 +02001608 if (!opts->ungroup) {
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001609 pp->children[i].process.err = -1;
1610 pp->children[i].process.stdout_to_stderr = 1;
1611 }
Stefan Bellerc553c722015-12-15 16:04:10 -08001612
1613 if (start_command(&pp->children[i].process)) {
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001614 if (opts->start_failure)
Ævar Arnfjörð Bjarmason357f8e62022-10-12 23:02:30 +02001615 code = opts->start_failure(opts->ungroup ? NULL :
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001616 &pp->children[i].err,
Ævar Arnfjörð Bjarmason2aa8d222022-10-12 23:02:31 +02001617 opts->data,
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001618 pp->children[i].data);
1619 else
1620 code = 0;
1621
Ævar Arnfjörð Bjarmason357f8e62022-10-12 23:02:30 +02001622 if (!opts->ungroup) {
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001623 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1624 strbuf_reset(&pp->children[i].err);
1625 }
Stefan Bellerc553c722015-12-15 16:04:10 -08001626 if (code)
1627 pp->shutdown = 1;
1628 return code;
1629 }
1630
1631 pp->nr_processes++;
1632 pp->children[i].state = GIT_CP_WORKING;
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001633 if (pp->pfd)
1634 pp->pfd[i].fd = pp->children[i].process.err;
Stefan Bellerc553c722015-12-15 16:04:10 -08001635 return 0;
1636}
1637
Ævar Arnfjörð Bjarmasond1610ee2022-10-12 23:02:33 +02001638static void pp_buffer_stderr(struct parallel_processes *pp,
1639 const struct run_process_parallel_opts *opts,
1640 int output_timeout)
Stefan Bellerc553c722015-12-15 16:04:10 -08001641{
Ævar Arnfjörð Bjarmason5123e6e2023-02-08 20:21:11 +01001642 while (poll(pp->pfd, opts->processes, output_timeout) < 0) {
Stefan Bellerc553c722015-12-15 16:04:10 -08001643 if (errno == EINTR)
1644 continue;
Ævar Arnfjörð Bjarmasond1610ee2022-10-12 23:02:33 +02001645 pp_cleanup(pp, opts);
Stefan Bellerc553c722015-12-15 16:04:10 -08001646 die_errno("poll");
1647 }
1648
1649 /* Buffer output from all pipes. */
Ævar Arnfjörð Bjarmasond1610ee2022-10-12 23:02:33 +02001650 for (size_t i = 0; i < opts->processes; i++) {
Stefan Bellerc553c722015-12-15 16:04:10 -08001651 if (pp->children[i].state == GIT_CP_WORKING &&
1652 pp->pfd[i].revents & (POLLIN | POLLHUP)) {
1653 int n = strbuf_read_once(&pp->children[i].err,
1654 pp->children[i].process.err, 0);
1655 if (n == 0) {
1656 close(pp->children[i].process.err);
1657 pp->children[i].state = GIT_CP_WAIT_CLEANUP;
1658 } else if (n < 0)
1659 if (errno != EAGAIN)
1660 die_errno("read");
1661 }
1662 }
1663}
1664
Ævar Arnfjörð Bjarmasone39c9de2022-10-12 23:02:28 +02001665static void pp_output(const struct parallel_processes *pp)
Stefan Bellerc553c722015-12-15 16:04:10 -08001666{
Ævar Arnfjörð Bjarmason6a48b422022-10-12 23:02:23 +02001667 size_t i = pp->output_owner;
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001668
Stefan Bellerc553c722015-12-15 16:04:10 -08001669 if (pp->children[i].state == GIT_CP_WORKING &&
1670 pp->children[i].err.len) {
Stefan Beller2dac9b52016-02-29 18:07:15 -08001671 strbuf_write(&pp->children[i].err, stderr);
Stefan Bellerc553c722015-12-15 16:04:10 -08001672 strbuf_reset(&pp->children[i].err);
1673 }
1674}
1675
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001676static int pp_collect_finished(struct parallel_processes *pp,
1677 const struct run_process_parallel_opts *opts)
Stefan Bellerc553c722015-12-15 16:04:10 -08001678{
Ævar Arnfjörð Bjarmason6a48b422022-10-12 23:02:23 +02001679 int code;
Ævar Arnfjörð Bjarmason9f3df6c2022-10-12 23:02:32 +02001680 size_t i;
Stefan Bellerc553c722015-12-15 16:04:10 -08001681 int result = 0;
1682
1683 while (pp->nr_processes > 0) {
Ævar Arnfjörð Bjarmason9f3df6c2022-10-12 23:02:32 +02001684 for (i = 0; i < opts->processes; i++)
Stefan Bellerc553c722015-12-15 16:04:10 -08001685 if (pp->children[i].state == GIT_CP_WAIT_CLEANUP)
1686 break;
Ævar Arnfjörð Bjarmason9f3df6c2022-10-12 23:02:32 +02001687 if (i == opts->processes)
Stefan Bellerc553c722015-12-15 16:04:10 -08001688 break;
1689
1690 code = finish_command(&pp->children[i].process);
1691
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001692 if (opts->task_finished)
Ævar Arnfjörð Bjarmason357f8e62022-10-12 23:02:30 +02001693 code = opts->task_finished(code, opts->ungroup ? NULL :
Ævar Arnfjörð Bjarmason2aa8d222022-10-12 23:02:31 +02001694 &pp->children[i].err, opts->data,
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001695 pp->children[i].data);
1696 else
1697 code = 0;
Stefan Bellerc553c722015-12-15 16:04:10 -08001698
1699 if (code)
1700 result = code;
1701 if (code < 0)
1702 break;
1703
1704 pp->nr_processes--;
1705 pp->children[i].state = GIT_CP_FREE;
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001706 if (pp->pfd)
1707 pp->pfd[i].fd = -1;
Stefan Bellerc553c722015-12-15 16:04:10 -08001708 child_process_init(&pp->children[i].process);
1709
Ævar Arnfjörð Bjarmason357f8e62022-10-12 23:02:30 +02001710 if (opts->ungroup) {
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001711 ; /* no strbuf_*() work to do here */
1712 } else if (i != pp->output_owner) {
Stefan Bellerc553c722015-12-15 16:04:10 -08001713 strbuf_addbuf(&pp->buffered_output, &pp->children[i].err);
1714 strbuf_reset(&pp->children[i].err);
1715 } else {
Ævar Arnfjörð Bjarmason9f3df6c2022-10-12 23:02:32 +02001716 const size_t n = opts->processes;
1717
Stefan Beller2dac9b52016-02-29 18:07:15 -08001718 strbuf_write(&pp->children[i].err, stderr);
Stefan Bellerc553c722015-12-15 16:04:10 -08001719 strbuf_reset(&pp->children[i].err);
1720
1721 /* Output all other finished child processes */
Stefan Beller2dac9b52016-02-29 18:07:15 -08001722 strbuf_write(&pp->buffered_output, stderr);
Stefan Bellerc553c722015-12-15 16:04:10 -08001723 strbuf_reset(&pp->buffered_output);
1724
1725 /*
1726 * Pick next process to output live.
1727 * NEEDSWORK:
1728 * For now we pick it randomly by doing a round
1729 * robin. Later we may want to pick the one with
1730 * the most output or the longest or shortest
1731 * running process time.
1732 */
1733 for (i = 0; i < n; i++)
1734 if (pp->children[(pp->output_owner + i) % n].state == GIT_CP_WORKING)
1735 break;
1736 pp->output_owner = (pp->output_owner + i) % n;
1737 }
1738 }
1739 return result;
1740}
1741
Ævar Arnfjörð Bjarmason6e5ba0b2022-10-12 23:02:26 +02001742void run_processes_parallel(const struct run_process_parallel_opts *opts)
Stefan Bellerc553c722015-12-15 16:04:10 -08001743{
1744 int i, code;
1745 int output_timeout = 100;
1746 int spawn_cap = 4;
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001747 struct parallel_processes_for_signal pp_sig;
Ævar Arnfjörð Bjarmasonc333e6f2022-10-12 23:02:25 +02001748 struct parallel_processes pp = {
Ævar Arnfjörð Bjarmasonc333e6f2022-10-12 23:02:25 +02001749 .buffered_output = STRBUF_INIT,
Ævar Arnfjörð Bjarmasonc333e6f2022-10-12 23:02:25 +02001750 };
Ævar Arnfjörð Bjarmason6e5ba0b2022-10-12 23:02:26 +02001751 /* options */
1752 const char *tr2_category = opts->tr2_category;
1753 const char *tr2_label = opts->tr2_label;
1754 const int do_trace2 = tr2_category && tr2_label;
Stefan Bellerc553c722015-12-15 16:04:10 -08001755
Ævar Arnfjörð Bjarmason6e5ba0b2022-10-12 23:02:26 +02001756 if (do_trace2)
1757 trace2_region_enter_printf(tr2_category, tr2_label, NULL,
1758 "max:%d", opts->processes);
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001759
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001760 pp_init(&pp, opts, &pp_sig);
Stefan Bellerc553c722015-12-15 16:04:10 -08001761 while (1) {
1762 for (i = 0;
1763 i < spawn_cap && !pp.shutdown &&
Ævar Arnfjörð Bjarmason9f3df6c2022-10-12 23:02:32 +02001764 pp.nr_processes < opts->processes;
Stefan Bellerc553c722015-12-15 16:04:10 -08001765 i++) {
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001766 code = pp_start_one(&pp, opts);
Stefan Bellerc553c722015-12-15 16:04:10 -08001767 if (!code)
1768 continue;
1769 if (code < 0) {
1770 pp.shutdown = 1;
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001771 kill_children(&pp, opts, -code);
Stefan Bellerc553c722015-12-15 16:04:10 -08001772 }
1773 break;
1774 }
1775 if (!pp.nr_processes)
1776 break;
Ævar Arnfjörð Bjarmason6e5ba0b2022-10-12 23:02:26 +02001777 if (opts->ungroup) {
Ævar Arnfjörð Bjarmason9f3df6c2022-10-12 23:02:32 +02001778 for (size_t i = 0; i < opts->processes; i++)
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001779 pp.children[i].state = GIT_CP_WAIT_CLEANUP;
1780 } else {
Ævar Arnfjörð Bjarmasond1610ee2022-10-12 23:02:33 +02001781 pp_buffer_stderr(&pp, opts, output_timeout);
Ævar Arnfjörð Bjarmasonfd3aaf52022-06-07 10:48:19 +02001782 pp_output(&pp);
1783 }
Ævar Arnfjörð Bjarmasonfa939512022-10-12 23:02:29 +02001784 code = pp_collect_finished(&pp, opts);
Stefan Bellerc553c722015-12-15 16:04:10 -08001785 if (code) {
1786 pp.shutdown = 1;
1787 if (code < 0)
Ævar Arnfjörð Bjarmason0b0ab952022-10-12 23:02:34 +02001788 kill_children(&pp, opts,-code);
Stefan Bellerc553c722015-12-15 16:04:10 -08001789 }
1790 }
1791
Ævar Arnfjörð Bjarmasond1610ee2022-10-12 23:02:33 +02001792 pp_cleanup(&pp, opts);
Ævar Arnfjörð Bjarmason6e5ba0b2022-10-12 23:02:26 +02001793
1794 if (do_trace2)
1795 trace2_region_leave(tr2_category, tr2_label, NULL);
Stefan Bellerc553c722015-12-15 16:04:10 -08001796}
Jeff Hostetleree4512e2019-02-22 14:25:01 -08001797
Derrick Stoleea95ce122020-09-17 18:11:44 +00001798int run_auto_maintenance(int quiet)
Junio C Hamano850b6ed2020-05-06 13:18:29 -07001799{
Derrick Stolee1942d482020-08-28 15:45:12 +00001800 int enabled;
Derrick Stoleea95ce122020-09-17 18:11:44 +00001801 struct child_process maint = CHILD_PROCESS_INIT;
Junio C Hamano850b6ed2020-05-06 13:18:29 -07001802
Derrick Stolee1942d482020-08-28 15:45:12 +00001803 if (!git_config_get_bool("maintenance.auto", &enabled) &&
1804 !enabled)
1805 return 0;
1806
Derrick Stoleea95ce122020-09-17 18:11:44 +00001807 maint.git_cmd = 1;
Johannes Schindelin5a22a332021-09-09 09:47:07 +00001808 maint.close_object_store = 1;
Derrick Stoleea95ce122020-09-17 18:11:44 +00001809 strvec_pushl(&maint.args, "maintenance", "run", "--auto", NULL);
1810 strvec_push(&maint.args, quiet ? "--quiet" : "--no-quiet");
1811
1812 return run_command(&maint);
Junio C Hamano850b6ed2020-05-06 13:18:29 -07001813}
Jonathan Tand1fa9432021-06-17 10:13:25 -07001814
Ævar Arnfjörð Bjarmasonb3193252022-06-02 11:09:51 +02001815void prepare_other_repo_env(struct strvec *env, const char *new_git_dir)
Jonathan Tand1fa9432021-06-17 10:13:25 -07001816{
1817 const char * const *var;
1818
1819 for (var = local_repo_env; *var; var++) {
1820 if (strcmp(*var, CONFIG_DATA_ENVIRONMENT) &&
1821 strcmp(*var, CONFIG_COUNT_ENVIRONMENT))
Ævar Arnfjörð Bjarmasonb3193252022-06-02 11:09:51 +02001822 strvec_push(env, *var);
Jonathan Tand1fa9432021-06-17 10:13:25 -07001823 }
Ævar Arnfjörð Bjarmasonb3193252022-06-02 11:09:51 +02001824 strvec_pushf(env, "%s=%s", GIT_DIR_ENVIRONMENT, new_git_dir);
Jonathan Tand1fa9432021-06-17 10:13:25 -07001825}
Jeff Hostetlerfdb13222021-09-20 15:36:17 +00001826
1827enum start_bg_result start_bg_command(struct child_process *cmd,
1828 start_bg_wait_cb *wait_cb,
1829 void *cb_data,
1830 unsigned int timeout_sec)
1831{
1832 enum start_bg_result sbgr = SBGR_ERROR;
1833 int ret;
1834 int wait_status;
1835 pid_t pid_seen;
1836 time_t time_limit;
1837
1838 /*
1839 * We do not allow clean-on-exit because the child process
1840 * should persist in the background and possibly/probably
1841 * after this process exits. So we don't want to kill the
1842 * child during our atexit routine.
1843 */
1844 if (cmd->clean_on_exit)
1845 BUG("start_bg_command() does not allow non-zero clean_on_exit");
1846
1847 if (!cmd->trace2_child_class)
1848 cmd->trace2_child_class = "background";
1849
1850 ret = start_command(cmd);
1851 if (ret) {
1852 /*
1853 * We assume that if `start_command()` fails, we
1854 * either get a complete `trace2_child_start() /
1855 * trace2_child_exit()` pair or it fails before the
1856 * `trace2_child_start()` is emitted, so we do not
1857 * need to worry about it here.
1858 *
1859 * We also assume that `start_command()` does not add
1860 * us to the cleanup list. And that it calls
Andrei Rybakb39a8412023-01-07 14:56:55 +01001861 * `child_process_clear()`.
Jeff Hostetlerfdb13222021-09-20 15:36:17 +00001862 */
1863 sbgr = SBGR_ERROR;
1864 goto done;
1865 }
1866
1867 time(&time_limit);
1868 time_limit += timeout_sec;
1869
1870wait:
1871 pid_seen = waitpid(cmd->pid, &wait_status, WNOHANG);
1872
1873 if (!pid_seen) {
1874 /*
1875 * The child is currently running. Ask the callback
1876 * if the child is ready to do work or whether we
1877 * should keep waiting for it to boot up.
1878 */
1879 ret = (*wait_cb)(cmd, cb_data);
1880 if (!ret) {
1881 /*
1882 * The child is running and "ready".
1883 */
1884 trace2_child_ready(cmd, "ready");
1885 sbgr = SBGR_READY;
1886 goto done;
1887 } else if (ret > 0) {
1888 /*
1889 * The callback said to give it more time to boot up
1890 * (subject to our timeout limit).
1891 */
1892 time_t now;
1893
1894 time(&now);
1895 if (now < time_limit)
1896 goto wait;
1897
1898 /*
1899 * Our timeout has expired. We don't try to
1900 * kill the child, but rather let it continue
1901 * (hopefully) trying to startup.
1902 */
1903 trace2_child_ready(cmd, "timeout");
1904 sbgr = SBGR_TIMEOUT;
1905 goto done;
1906 } else {
1907 /*
1908 * The cb gave up on this child. It is still running,
1909 * but our cb got an error trying to probe it.
1910 */
1911 trace2_child_ready(cmd, "error");
1912 sbgr = SBGR_CB_ERROR;
1913 goto done;
1914 }
1915 }
1916
1917 else if (pid_seen == cmd->pid) {
1918 int child_code = -1;
1919
1920 /*
1921 * The child started, but exited or was terminated
1922 * before becoming "ready".
1923 *
1924 * We try to match the behavior of `wait_or_whine()`
1925 * WRT the handling of WIFSIGNALED() and WIFEXITED()
1926 * and convert the child's status to a return code for
1927 * tracing purposes and emit the `trace2_child_exit()`
1928 * event.
1929 *
1930 * We do not want the wait_or_whine() error message
1931 * because we will be called by client-side library
1932 * routines.
1933 */
1934 if (WIFEXITED(wait_status))
1935 child_code = WEXITSTATUS(wait_status);
1936 else if (WIFSIGNALED(wait_status))
1937 child_code = WTERMSIG(wait_status) + 128;
1938 trace2_child_exit(cmd, child_code);
1939
1940 sbgr = SBGR_DIED;
1941 goto done;
1942 }
1943
1944 else if (pid_seen < 0 && errno == EINTR)
1945 goto wait;
1946
1947 trace2_child_exit(cmd, -1);
1948 sbgr = SBGR_ERROR;
1949
1950done:
1951 child_process_clear(cmd);
1952 invalidate_lstat_cache();
1953 return sbgr;
1954}