Annotation of src/usr.bin/make/job.c, Revision 1.158
1.158 ! christos 1: /* $NetBSD: job.c,v 1.157 2011/08/01 02:13:21 christos Exp $ */
1.10 christos 2:
1.1 cgd 3: /*
4: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
1.82 agc 5: * All rights reserved.
6: *
7: * This code is derived from software contributed to Berkeley by
8: * Adam de Boor.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. Neither the name of the University nor the names of its contributors
19: * may be used to endorse or promote products derived from this software
20: * without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32: * SUCH DAMAGE.
33: */
34:
35: /*
1.1 cgd 36: * Copyright (c) 1988, 1989 by Adam de Boor
37: * Copyright (c) 1989 by Berkeley Softworks
38: * All rights reserved.
39: *
40: * This code is derived from software contributed to Berkeley by
41: * Adam de Boor.
42: *
43: * Redistribution and use in source and binary forms, with or without
44: * modification, are permitted provided that the following conditions
45: * are met:
46: * 1. Redistributions of source code must retain the above copyright
47: * notice, this list of conditions and the following disclaimer.
48: * 2. Redistributions in binary form must reproduce the above copyright
49: * notice, this list of conditions and the following disclaimer in the
50: * documentation and/or other materials provided with the distribution.
51: * 3. All advertising materials mentioning features or use of this software
52: * must display the following acknowledgement:
53: * This product includes software developed by the University of
54: * California, Berkeley and its contributors.
55: * 4. Neither the name of the University nor the names of its contributors
56: * may be used to endorse or promote products derived from this software
57: * without specific prior written permission.
58: *
59: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69: * SUCH DAMAGE.
70: */
71:
1.84 ross 72: #ifndef MAKE_NATIVE
1.158 ! christos 73: static char rcsid[] = "$NetBSD: job.c,v 1.157 2011/08/01 02:13:21 christos Exp $";
1.21 lukem 74: #else
1.19 christos 75: #include <sys/cdefs.h>
1.1 cgd 76: #ifndef lint
1.10 christos 77: #if 0
1.16 christos 78: static char sccsid[] = "@(#)job.c 8.2 (Berkeley) 3/19/94";
1.10 christos 79: #else
1.158 ! christos 80: __RCSID("$NetBSD: job.c,v 1.157 2011/08/01 02:13:21 christos Exp $");
1.10 christos 81: #endif
1.1 cgd 82: #endif /* not lint */
1.21 lukem 83: #endif
1.1 cgd 84:
85: /*-
86: * job.c --
87: * handle the creation etc. of our child processes.
88: *
89: * Interface:
90: * Job_Make Start the creation of the given target.
91: *
92: * Job_CatchChildren Check for and handle the termination of any
93: * children. This must be called reasonably
94: * frequently to keep the whole make going at
95: * a decent clip, since job table entries aren't
96: * removed until their process is caught this way.
97: *
98: * Job_CatchOutput Print any output our children have produced.
99: * Should also be called fairly frequently to
100: * keep the user informed of what's going on.
101: * If no output is waiting, it will block for
102: * a time given by the SEL_* constants, below,
103: * or until output is ready.
104: *
105: * Job_Init Called to intialize this module. in addition,
106: * any commands attached to the .BEGIN target
107: * are executed before this function returns.
108: * Hence, the makefile must have been parsed
109: * before this function is called.
110: *
1.22 christos 111: * Job_End Cleanup any memory used.
112: *
1.1 cgd 113: * Job_ParseShell Given the line following a .SHELL target, parse
114: * the line as a shell specification. Returns
115: * FAILURE if the spec was incorrect.
116: *
1.22 christos 117: * Job_Finish Perform any final processing which needs doing.
1.1 cgd 118: * This includes the execution of any commands
119: * which have been/were attached to the .END
120: * target. It should only be called when the
121: * job table is empty.
122: *
123: * Job_AbortAll Abort all currently running jobs. It doesn't
124: * handle output or do anything for the jobs,
125: * just kills them. It should only be called in
126: * an emergency, as it were.
127: *
128: * Job_CheckCommands Verify that the commands for a target are
129: * ok. Provide them if necessary and possible.
130: *
131: * Job_Touch Update a target without really updating it.
132: *
133: * Job_Wait Wait for all currently-running jobs to finish.
134: */
135:
1.5 cgd 136: #include <sys/types.h>
1.1 cgd 137: #include <sys/stat.h>
138: #include <sys/file.h>
139: #include <sys/time.h>
140: #include <sys/wait.h>
1.72 wiz 141:
142: #include <errno.h>
1.1 cgd 143: #include <fcntl.h>
1.35 christos 144: #ifndef USE_SELECT
145: #include <poll.h>
146: #endif
1.72 wiz 147: #include <signal.h>
148: #include <stdio.h>
149: #include <string.h>
150: #include <utime.h>
151:
1.5 cgd 152: #include "make.h"
153: #include "hash.h"
154: #include "dir.h"
1.1 cgd 155: #include "job.h"
156: #include "pathnames.h"
1.40 sommerfe 157: #include "trace.h"
1.12 christos 158: # define STATIC static
1.1 cgd 159:
160: /*
1.16 christos 161: * error handling variables
1.1 cgd 162: */
1.5 cgd 163: static int errors = 0; /* number of errors reported */
164: static int aborting = 0; /* why is the make aborting? */
1.1 cgd 165: #define ABORT_ERROR 1 /* Because of an error */
166: #define ABORT_INTERRUPT 2 /* Because it was interrupted */
167: #define ABORT_WAIT 3 /* Waiting for jobs to finish */
1.101 dsl 168: #define JOB_TOKENS "+EI+" /* Token to requeue for each abort state */
1.1 cgd 169:
1.16 christos 170: /*
1.103 dsl 171: * this tracks the number of tokens currently "out" to build jobs.
172: */
173: int jobTokensRunning = 0;
1.139 christos 174: int not_parallel = 0; /* set if .NOT_PARALLEL */
1.103 dsl 175:
176: /*
1.12 christos 177: * XXX: Avoid SunOS bug... FILENO() is fp->_file, and file
178: * is a char! So when we go above 127 we turn negative!
179: */
1.139 christos 180: #define FILENO(a) ((unsigned) fileno(a))
1.1 cgd 181:
182: /*
183: * post-make command processing. The node postCommands is really just the
184: * .END target but we keep it around to avoid having to search for it
185: * all the time.
186: */
1.142 dsl 187: static GNode *postCommands = NULL;
1.71 christos 188: /* node containing commands to execute when
1.1 cgd 189: * everything else is done */
190: static int numCommands; /* The number of commands actually printed
191: * for a target. Should this number be
192: * 0, no shell will be executed. */
193:
194: /*
195: * Return values from JobStart.
196: */
197: #define JOB_RUNNING 0 /* Job is running */
198: #define JOB_ERROR 1 /* Error in starting the job */
199: #define JOB_FINISHED 2 /* The job is already finished */
200:
201: /*
202: * Descriptions for various shells.
1.121 apb 203: *
1.133 apb 204: * The build environment may set DEFSHELL_INDEX to one of
205: * DEFSHELL_INDEX_SH, DEFSHELL_INDEX_KSH, or DEFSHELL_INDEX_CSH, to
206: * select one of the prefedined shells as the default shell.
207: *
208: * Alternatively, the build environment may set DEFSHELL_CUSTOM to the
209: * name or the full path of a sh-compatible shell, which will be used as
210: * the default shell.
211: *
212: * ".SHELL" lines in Makefiles can choose the default shell from the
213: # set defined here, or add additional shells.
214: */
215:
216: #ifdef DEFSHELL_CUSTOM
217: #define DEFSHELL_INDEX_CUSTOM 0
218: #define DEFSHELL_INDEX_SH 1
219: #define DEFSHELL_INDEX_KSH 2
220: #define DEFSHELL_INDEX_CSH 3
221: #else /* !DEFSHELL_CUSTOM */
222: #define DEFSHELL_INDEX_SH 0
223: #define DEFSHELL_INDEX_KSH 1
224: #define DEFSHELL_INDEX_CSH 2
225: #endif /* !DEFSHELL_CUSTOM */
226:
227: #ifndef DEFSHELL_INDEX
228: #define DEFSHELL_INDEX 0 /* DEFSHELL_INDEX_CUSTOM or DEFSHELL_INDEX_SH */
229: #endif /* !DEFSHELL_INDEX */
230:
1.1 cgd 231: static Shell shells[] = {
1.133 apb 232: #ifdef DEFSHELL_CUSTOM
1.1 cgd 233: /*
1.121 apb 234: * An sh-compatible shell with a non-standard name.
235: *
236: * Keep this in sync with the "sh" description below, but avoid
237: * non-portable features that might not be supplied by all
238: * sh-compatible shells.
1.1 cgd 239: */
240: {
1.133 apb 241: DEFSHELL_CUSTOM,
1.121 apb 242: FALSE, "", "", "", 0,
243: FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',
244: "",
245: "",
1.1 cgd 246: },
1.133 apb 247: #endif /* DEFSHELL_CUSTOM */
1.1 cgd 248: /*
249: * SH description. Echo control is also possible and, under
250: * sun UNIX anyway, one can even control error checking.
251: */
252: {
253: "sh",
1.83 jmc 254: FALSE, "", "", "", 0,
1.112 rillig 255: FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',
1.121 apb 256: #if defined(MAKE_NATIVE) && defined(__NetBSD__)
1.83 jmc 257: "q",
1.27 christos 258: #else
1.83 jmc 259: "",
1.27 christos 260: #endif
1.83 jmc 261: "",
1.1 cgd 262: },
263: /*
1.81 sjg 264: * KSH description.
265: */
266: {
267: "ksh",
268: TRUE, "set +v", "set -v", "set +v", 6,
1.112 rillig 269: FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',
1.81 sjg 270: "v",
1.83 jmc 271: "",
1.81 sjg 272: },
273: /*
1.121 apb 274: * CSH description. The csh can do echo control by playing
275: * with the setting of the 'echo' shell variable. Sadly,
276: * however, it is unable to do error control nicely.
277: */
278: {
279: "csh",
280: TRUE, "unset verbose", "set verbose", "unset verbose", 10,
281: FALSE, "echo \"%s\"\n", "csh -c \"%s || exit 0\"\n", "", "'\\\n'", '#',
282: "v", "e",
283: },
284: /*
1.1 cgd 285: * UNKNOWN.
286: */
287: {
1.98 christos 288: NULL,
289: FALSE, NULL, NULL, NULL, 0,
1.112 rillig 290: FALSE, NULL, NULL, NULL, NULL, 0,
1.98 christos 291: NULL, NULL,
1.1 cgd 292: }
293: };
1.133 apb 294: static Shell *commandShell = &shells[DEFSHELL_INDEX]; /* this is the shell to
1.1 cgd 295: * which we pass all
296: * commands in the Makefile.
297: * It is set by the
298: * Job_ParseShell function */
1.81 sjg 299: const char *shellPath = NULL, /* full pathname of
1.1 cgd 300: * executable image */
1.81 sjg 301: *shellName = NULL; /* last component of shell */
302: static const char *shellArgv = NULL; /* Custom shell args */
1.1 cgd 303:
304:
1.114 dsl 305: STATIC Job *job_table; /* The structures that describe them */
306: STATIC Job *job_table_end; /* job_table + maxJobs */
1.120 dsl 307: static int wantToken; /* we want a token */
1.117 dsl 308: static int lurking_children = 0;
1.118 dsl 309: static int make_suspended = 0; /* non-zero if we've seen a SIGTSTP (etc) */
1.40 sommerfe 310:
1.35 christos 311: /*
312: * Set of descriptors of pipes connected to
313: * the output channels of children
314: */
315: static struct pollfd *fds = NULL;
1.36 christos 316: static Job **jobfds = NULL;
1.139 christos 317: static int nfds = 0;
1.72 wiz 318: static void watchfd(Job *);
319: static void clearfd(Job *);
320: static int readyfd(Job *);
1.1 cgd 321:
1.12 christos 322: STATIC GNode *lastNode; /* The node for which output was most recently
1.1 cgd 323: * produced. */
1.158 ! christos 324: static char *targPrefix = NULL; /* What we print at the start of TARG_FMT */
1.40 sommerfe 325: static Job tokenWaitJob; /* token wait pseudo-job */
1.12 christos 326:
1.73 gson 327: static Job childExitJob; /* child exit pseudo-job */
1.105 dsl 328: #define CHILD_EXIT "."
1.106 dsl 329: #define DO_JOB_RESUME "R"
1.73 gson 330:
1.125 sjg 331: #define TARG_FMT "%s %s ---\n" /* Default format */
1.106 dsl 332: #define MESSAGE(fp, gn) \
1.158 ! christos 333: if (maxJobs != 1) \
! 334: (void)fprintf(fp, TARG_FMT, targPrefix, gn->name)
1.1 cgd 335:
1.104 dsl 336: static sigset_t caught_signals; /* Set of signals we handle */
1.119 dsl 337: #if defined(SYSV)
338: #define KILLPG(pid, sig) kill(-(pid), (sig))
1.5 cgd 339: #else
1.119 dsl 340: #define KILLPG(pid, sig) killpg((pid), (sig))
1.5 cgd 341: #endif
1.1 cgd 342:
1.73 gson 343: static void JobChildSig(int);
1.72 wiz 344: static void JobContinueSig(int);
1.153 sjg 345: static Job *JobFindPid(int, int, Boolean);
1.144 dsl 346: static int JobPrintCommand(void *, void *);
347: static int JobSaveCommand(void *, void *);
1.72 wiz 348: static void JobClose(Job *);
349: static void JobExec(Job *, char **);
350: static void JobMakeArgv(Job *, char **);
1.108 dsl 351: static int JobStart(GNode *, int);
1.72 wiz 352: static char *JobOutput(Job *, char *, char *, int);
353: static void JobDoOutput(Job *, Boolean);
1.77 christos 354: static Shell *JobMatchShell(const char *);
1.72 wiz 355: static void JobInterrupt(int, int);
356: static void JobRestartJobs(void);
357: static void JobTokenAdd(void);
1.69 pk 358: static void JobSigLock(sigset_t *);
359: static void JobSigUnlock(sigset_t *);
360: static void JobSigReset(void);
361:
1.139 christos 362: const char *malloc_options="A";
1.69 pk 363:
1.114 dsl 364: static void
365: job_table_dump(const char *where)
366: {
367: Job *job;
368:
1.139 christos 369: fprintf(debug_file, "job table @ %s\n", where);
1.114 dsl 370: for (job = job_table; job < job_table_end; job++) {
1.139 christos 371: fprintf(debug_file, "job %d, status %d, flags %d, pid %d\n",
372: (int)(job - job_table), job->job_state, job->flags, job->pid);
1.114 dsl 373: }
374: }
1.69 pk 375:
376: /*
377: * JobSigLock/JobSigUnlock
378: *
379: * Signal lock routines to get exclusive access. Currently used to
380: * protect `jobs' and `stoppedJobs' list manipulations.
381: */
1.72 wiz 382: static void JobSigLock(sigset_t *omaskp)
1.69 pk 383: {
384: if (sigprocmask(SIG_BLOCK, &caught_signals, omaskp) != 0) {
385: Punt("JobSigLock: sigprocmask: %s", strerror(errno));
1.104 dsl 386: sigemptyset(omaskp);
1.69 pk 387: }
388: }
389:
1.72 wiz 390: static void JobSigUnlock(sigset_t *omaskp)
1.69 pk 391: {
1.96 christos 392: (void)sigprocmask(SIG_SETMASK, omaskp, NULL);
1.69 pk 393: }
1.1 cgd 394:
1.122 dsl 395: static void
396: JobCreatePipe(Job *job, int minfd)
397: {
398: int i, fd;
399:
400: if (pipe(job->jobPipe) == -1)
401: Punt("Cannot create pipe: %s", strerror(errno));
402:
403: /* Set close-on-exec flag for both */
404: (void)fcntl(job->jobPipe[0], F_SETFD, 1);
405: (void)fcntl(job->jobPipe[1], F_SETFD, 1);
406:
407: /*
408: * We mark the input side of the pipe non-blocking; we poll(2) the
409: * pipe when we're waiting for a job token, but we might lose the
410: * race for the token when a new one becomes available, so the read
411: * from the pipe should not block.
412: */
413: fcntl(job->jobPipe[0], F_SETFL,
414: fcntl(job->jobPipe[0], F_GETFL, 0) | O_NONBLOCK);
415:
416: for (i = 0; i < 2; i++) {
417: /* Avoid using low numbered fds */
418: fd = fcntl(job->jobPipe[i], F_DUPFD, minfd);
419: if (fd != -1) {
420: close(job->jobPipe[i]);
421: job->jobPipe[i] = fd;
422: }
423: }
424: }
425:
1.1 cgd 426: /*-
427: *-----------------------------------------------------------------------
428: * JobCondPassSig --
1.119 dsl 429: * Pass a signal to a job
1.1 cgd 430: *
1.72 wiz 431: * Input:
432: * signop Signal to send it
433: *
1.1 cgd 434: * Side Effects:
435: * None, except the job may bite it.
436: *
437: *-----------------------------------------------------------------------
438: */
1.114 dsl 439: static void
440: JobCondPassSig(int signo)
1.1 cgd 441: {
1.114 dsl 442: Job *job;
1.106 dsl 443:
1.116 dsl 444: if (DEBUG(JOB)) {
1.123 dsl 445: (void)fprintf(debug_file, "JobCondPassSig(%d) called.\n", signo);
1.116 dsl 446: }
447:
1.114 dsl 448: for (job = job_table; job < job_table_end; job++) {
1.116 dsl 449: if (job->job_state != JOB_ST_RUNNING)
1.114 dsl 450: continue;
451: if (DEBUG(JOB)) {
1.123 dsl 452: (void)fprintf(debug_file,
1.139 christos 453: "JobCondPassSig passing signal %d to child %d.\n",
454: signo, job->pid);
1.114 dsl 455: }
1.116 dsl 456: KILLPG(job->pid, signo);
1.12 christos 457: }
1.1 cgd 458: }
459:
460: /*-
461: *-----------------------------------------------------------------------
1.73 gson 462: * JobChldSig --
463: * SIGCHLD handler.
1.37 sommerfe 464: *
1.72 wiz 465: * Input:
466: * signo The signal number we've received
467: *
1.37 sommerfe 468: * Results:
469: * None.
470: *
471: * Side Effects:
1.73 gson 472: * Sends a token on the child exit pipe to wake us up from
473: * select()/poll().
1.37 sommerfe 474: *
475: *-----------------------------------------------------------------------
476: */
477: static void
1.87 jmc 478: JobChildSig(int signo __unused)
1.37 sommerfe 479: {
1.122 dsl 480: write(childExitJob.outPipe, CHILD_EXIT, 1);
1.37 sommerfe 481: }
482:
483:
1.47 sommerfe 484: /*-
485: *-----------------------------------------------------------------------
486: * JobContinueSig --
487: * Resume all stopped jobs.
488: *
1.72 wiz 489: * Input:
490: * signo The signal number we've received
491: *
1.47 sommerfe 492: * Results:
493: * None.
494: *
495: * Side Effects:
496: * Jobs start running again.
497: *
498: *-----------------------------------------------------------------------
499: */
500: static void
1.87 jmc 501: JobContinueSig(int signo __unused)
1.47 sommerfe 502: {
1.116 dsl 503: /*
1.118 dsl 504: * Defer sending to SIGCONT to our stopped children until we return
1.116 dsl 505: * from the signal handler.
506: */
1.122 dsl 507: write(childExitJob.outPipe, DO_JOB_RESUME, 1);
1.47 sommerfe 508: }
1.37 sommerfe 509:
510: /*-
511: *-----------------------------------------------------------------------
1.1 cgd 512: * JobPassSig --
1.119 dsl 513: * Pass a signal on to all jobs, then resend to ourselves.
1.1 cgd 514: *
1.72 wiz 515: * Input:
516: * signo The signal number we've received
517: *
1.1 cgd 518: * Results:
519: * None.
520: *
521: * Side Effects:
522: * We die by the same signal.
1.16 christos 523: *
1.1 cgd 524: *-----------------------------------------------------------------------
525: */
526: static void
1.116 dsl 527: JobPassSig_int(int signo)
528: {
529: /* Run .INTERRUPT target then exit */
530: JobInterrupt(TRUE, signo);
531: }
532:
533: static void
534: JobPassSig_term(int signo)
535: {
536: /* Dont run .INTERRUPT target then exit */
537: JobInterrupt(FALSE, signo);
538: }
539:
540: static void
541: JobPassSig_suspend(int signo)
1.1 cgd 542: {
1.13 christos 543: sigset_t nmask, omask;
1.14 christos 544: struct sigaction act;
1.118 dsl 545:
546: /* Suppress job started/continued messages */
547: make_suspended = 1;
1.16 christos 548:
1.116 dsl 549: /* Pass the signal onto every job */
1.114 dsl 550: JobCondPassSig(signo);
1.1 cgd 551:
552: /*
553: * Send ourselves the signal now we've given the message to everyone else.
554: * Note we block everything else possible while we're getting the signal.
555: * This ensures that all our jobs get continued when we wake up before
556: * we take any other signal.
557: */
1.28 christos 558: sigfillset(&nmask);
1.68 pk 559: sigdelset(&nmask, signo);
1.96 christos 560: (void)sigprocmask(SIG_SETMASK, &nmask, &omask);
1.68 pk 561:
1.14 christos 562: act.sa_handler = SIG_DFL;
563: sigemptyset(&act.sa_mask);
564: act.sa_flags = 0;
1.96 christos 565: (void)sigaction(signo, &act, NULL);
1.13 christos 566:
1.12 christos 567: if (DEBUG(JOB)) {
1.123 dsl 568: (void)fprintf(debug_file,
1.47 sommerfe 569: "JobPassSig passing signal %d to self.\n", signo);
1.12 christos 570: }
1.1 cgd 571:
1.96 christos 572: (void)kill(getpid(), signo);
1.115 dsl 573:
574: /*
1.116 dsl 575: * We've been continued.
576: *
577: * A whole host of signals continue to happen!
1.118 dsl 578: * SIGCHLD for any processes that actually suspended themselves.
1.116 dsl 579: * SIGCHLD for any processes that exited while we were alseep.
580: * The SIGCONT that actually caused us to wakeup.
581: *
582: * Since we defer passing the SIGCONT on to our children until
583: * the main processing loop, we can be sure that all the SIGCHLD
584: * events will have happened by then - and that the waitpid() will
585: * collect the child 'suspended' events.
586: * For correct sequencing we just need to ensure we process the
587: * waitpid() before passign on the SIGCONT.
588: *
589: * In any case nothing else is needed here.
1.115 dsl 590: */
1.1 cgd 591:
1.68 pk 592: /* Restore handler and signal mask */
1.116 dsl 593: act.sa_handler = JobPassSig_suspend;
1.96 christos 594: (void)sigaction(signo, &act, NULL);
595: (void)sigprocmask(SIG_SETMASK, &omask, NULL);
1.1 cgd 596: }
597:
598: /*-
599: *-----------------------------------------------------------------------
1.116 dsl 600: * JobFindPid --
1.1 cgd 601: * Compare the pid of the job with the given pid and return 0 if they
1.120 dsl 602: * are equal. This function is called from Job_CatchChildren
603: * to find the job descriptor of the finished job.
1.1 cgd 604: *
1.72 wiz 605: * Input:
606: * job job to examine
607: * pid process id desired
608: *
1.1 cgd 609: * Results:
1.114 dsl 610: * Job with matching pid
1.1 cgd 611: *
612: * Side Effects:
613: * None
614: *-----------------------------------------------------------------------
615: */
1.114 dsl 616: static Job *
1.153 sjg 617: JobFindPid(int pid, int status, Boolean isJobs)
1.1 cgd 618: {
1.114 dsl 619: Job *job;
620:
621: for (job = job_table; job < job_table_end; job++) {
1.116 dsl 622: if ((job->job_state == status) && job->pid == pid)
1.114 dsl 623: return job;
624: }
1.153 sjg 625: if (DEBUG(JOB) && isJobs)
1.114 dsl 626: job_table_dump("no pid");
627: return NULL;
1.12 christos 628: }
629:
1.1 cgd 630: /*-
631: *-----------------------------------------------------------------------
632: * JobPrintCommand --
633: * Put out another command for the given job. If the command starts
634: * with an @ or a - we process it specially. In the former case,
635: * so long as the -s and -n flags weren't given to make, we stick
636: * a shell-specific echoOff command in the script. In the latter,
637: * we ignore errors for the entire job, unless the shell has error
638: * control.
639: * If the command is just "..." we take all future commands for this
640: * job to be commands to be executed once the entire graph has been
641: * made and return non-zero to signal that the end of the commands
642: * was reached. These commands are later attached to the postCommands
643: * node and executed by Job_End when all things are done.
644: * This function is called from JobStart via Lst_ForEach.
645: *
1.72 wiz 646: * Input:
647: * cmdp command string to print
648: * jobp job for which to print it
649: *
1.1 cgd 650: * Results:
651: * Always 0, unless the command was "..."
652: *
653: * Side Effects:
654: * If the command begins with a '-' and the shell has no error control,
655: * the JOB_IGNERR flag is set in the job descriptor.
656: * If the command is "..." and we're not ignoring such things,
657: * tailCmds is set to the successor node of the cmd.
658: * numCommands is incremented if the command is actually printed.
659: *-----------------------------------------------------------------------
660: */
661: static int
1.144 dsl 662: JobPrintCommand(void *cmdp, void *jobp)
1.1 cgd 663: {
664: Boolean noSpecials; /* true if we shouldn't worry about
665: * inserting special commands into
666: * the input stream. */
667: Boolean shutUp = FALSE; /* true if we put a no echo command
668: * into the command file */
669: Boolean errOff = FALSE; /* true if we turned error checking
670: * off before printing the command
671: * and need to turn it back on */
1.77 christos 672: const char *cmdTemplate; /* Template to use when printing the
1.1 cgd 673: * command */
674: char *cmdStart; /* Start of expanded command */
1.83 jmc 675: char *escCmd = NULL; /* Command with quotes/backticks escaped */
1.98 christos 676: char *cmd = (char *)cmdp;
677: Job *job = (Job *)jobp;
1.88 christos 678: char *cp, *tmp;
1.83 jmc 679: int i, j;
680:
1.45 sommerfe 681: noSpecials = NoExecute(job->node);
1.1 cgd 682:
1.12 christos 683: if (strcmp(cmd, "...") == 0) {
1.16 christos 684: job->node->type |= OP_SAVE_CMDS;
1.1 cgd 685: if ((job->flags & JOB_IGNDOTS) == 0) {
1.12 christos 686: job->tailCmds = Lst_Succ(Lst_Member(job->node->commands,
1.124 dsl 687: cmd));
1.16 christos 688: return 1;
1.12 christos 689: }
1.16 christos 690: return 0;
1.1 cgd 691: }
692:
1.12 christos 693: #define DBPRINTF(fmt, arg) if (DEBUG(JOB)) { \
1.123 dsl 694: (void)fprintf(debug_file, fmt, arg); \
1.12 christos 695: } \
1.96 christos 696: (void)fprintf(job->cmdFILE, fmt, arg); \
697: (void)fflush(job->cmdFILE);
1.1 cgd 698:
699: numCommands += 1;
700:
1.12 christos 701: cmdStart = cmd = Var_Subst(NULL, cmd, job->node, FALSE);
1.1 cgd 702:
703: cmdTemplate = "%s\n";
704:
705: /*
706: * Check for leading @' and -'s to control echoing and error checking.
707: */
1.85 sjg 708: while (*cmd == '@' || *cmd == '-' || (*cmd == '+')) {
709: switch (*cmd) {
710: case '@':
1.135 sjg 711: shutUp = DEBUG(LOUD) ? FALSE : TRUE;
1.85 sjg 712: break;
713: case '-':
1.152 christos 714: job->flags |= JOB_IGNERR;
1.1 cgd 715: errOff = TRUE;
1.85 sjg 716: break;
717: case '+':
718: if (noSpecials) {
719: /*
720: * We're not actually executing anything...
721: * but this one needs to be - use compat mode just for it.
722: */
1.124 dsl 723: CompatRunCommand(cmdp, job->node);
1.85 sjg 724: return 0;
725: }
726: break;
1.1 cgd 727: }
728: cmd++;
729: }
730:
1.5 cgd 731: while (isspace((unsigned char) *cmd))
732: cmd++;
1.1 cgd 733:
1.83 jmc 734: /*
735: * If the shell doesn't have error control the alternate echo'ing will
736: * be done (to avoid showing additional error checking code)
737: * and this will need the characters '$ ` \ "' escaped
738: */
739:
740: if (!commandShell->hasErrCtl) {
741: /* Worst that could happen is every char needs escaping. */
1.140 joerg 742: escCmd = bmake_malloc((strlen(cmd) * 2) + 1);
1.83 jmc 743: for (i = 0, j= 0; cmd[i] != '\0'; i++, j++) {
744: if (cmd[i] == '$' || cmd[i] == '`' || cmd[i] == '\\' ||
745: cmd[i] == '"')
746: escCmd[j++] = '\\';
747: escCmd[j] = cmd[i];
748: }
749: escCmd[j] = 0;
750: }
751:
1.1 cgd 752: if (shutUp) {
1.12 christos 753: if (!(job->flags & JOB_SILENT) && !noSpecials &&
1.1 cgd 754: commandShell->hasEchoCtl) {
1.12 christos 755: DBPRINTF("%s\n", commandShell->echoOff);
1.1 cgd 756: } else {
1.83 jmc 757: if (commandShell->hasErrCtl)
758: shutUp = FALSE;
1.1 cgd 759: }
760: }
761:
762: if (errOff) {
1.152 christos 763: if (!noSpecials) {
1.1 cgd 764: if (commandShell->hasErrCtl) {
765: /*
766: * we don't want the error-control commands showing
767: * up either, so we turn off echoing while executing
768: * them. We could put another field in the shell
769: * structure to tell JobDoOutput to look for this
770: * string too, but why make it any more complex than
771: * it already is?
772: */
1.12 christos 773: if (!(job->flags & JOB_SILENT) && !shutUp &&
1.1 cgd 774: commandShell->hasEchoCtl) {
1.12 christos 775: DBPRINTF("%s\n", commandShell->echoOff);
776: DBPRINTF("%s\n", commandShell->ignErr);
777: DBPRINTF("%s\n", commandShell->echoOn);
1.1 cgd 778: } else {
1.83 jmc 779: DBPRINTF("%s\n", commandShell->ignErr);
1.1 cgd 780: }
781: } else if (commandShell->ignErr &&
1.12 christos 782: (*commandShell->ignErr != '\0'))
1.1 cgd 783: {
784: /*
785: * The shell has no error control, so we need to be
786: * weird to get it to ignore any errors from the command.
787: * If echoing is turned on, we turn it off and use the
788: * errCheck template to echo the command. Leave echoing
789: * off so the user doesn't see the weirdness we go through
790: * to ignore errors. Set cmdTemplate to use the weirdness
791: * instead of the simple "%s\n" template.
792: */
1.83 jmc 793: if (!(job->flags & JOB_SILENT) && !shutUp) {
794: if (commandShell->hasEchoCtl) {
795: DBPRINTF("%s\n", commandShell->echoOff);
796: }
797: DBPRINTF(commandShell->errCheck, escCmd);
1.1 cgd 798: shutUp = TRUE;
1.83 jmc 799: } else {
800: if (!shutUp) {
801: DBPRINTF(commandShell->errCheck, escCmd);
802: }
1.1 cgd 803: }
804: cmdTemplate = commandShell->ignErr;
805: /*
1.16 christos 806: * The error ignoration (hee hee) is already taken care
1.1 cgd 807: * of by the ignErr template, so pretend error checking
808: * is still on.
809: */
810: errOff = FALSE;
811: } else {
812: errOff = FALSE;
813: }
814: } else {
815: errOff = FALSE;
816: }
1.83 jmc 817: } else {
818:
819: /*
820: * If errors are being checked and the shell doesn't have error control
821: * but does supply an errOut template, then setup commands to run
822: * through it.
823: */
824:
825: if (!commandShell->hasErrCtl && commandShell->errOut &&
826: (*commandShell->errOut != '\0')) {
827: if (!(job->flags & JOB_SILENT) && !shutUp) {
828: if (commandShell->hasEchoCtl) {
829: DBPRINTF("%s\n", commandShell->echoOff);
830: }
831: DBPRINTF(commandShell->errCheck, escCmd);
832: shutUp = TRUE;
833: }
1.93 jmc 834: /* If it's a comment line or blank, treat as an ignored error */
835: if ((escCmd[0] == commandShell->commentChar) ||
836: (escCmd[0] == 0))
1.83 jmc 837: cmdTemplate = commandShell->ignErr;
838: else
839: cmdTemplate = commandShell->errOut;
840: errOff = FALSE;
841: }
1.1 cgd 842: }
1.16 christos 843:
1.49 sjg 844: if (DEBUG(SHELL) && strcmp(shellName, "sh") == 0 &&
845: (job->flags & JOB_TRACED) == 0) {
846: DBPRINTF("set -%s\n", "x");
847: job->flags |= JOB_TRACED;
848: }
849:
1.33 sjg 850: if ((cp = Check_Cwd_Cmd(cmd)) != NULL) {
1.55 sjg 851: DBPRINTF("test -d %s && ", cp);
1.88 christos 852: DBPRINTF("cd %s\n", cp);
853: }
854:
1.12 christos 855: DBPRINTF(cmdTemplate, cmd);
1.23 itohy 856: free(cmdStart);
1.83 jmc 857: if (escCmd)
858: free(escCmd);
1.1 cgd 859: if (errOff) {
860: /*
861: * If echoing is already off, there's no point in issuing the
862: * echoOff command. Otherwise we issue it and pretend it was on
863: * for the whole command...
864: */
865: if (!shutUp && !(job->flags & JOB_SILENT) && commandShell->hasEchoCtl){
1.12 christos 866: DBPRINTF("%s\n", commandShell->echoOff);
1.1 cgd 867: shutUp = TRUE;
868: }
1.12 christos 869: DBPRINTF("%s\n", commandShell->errCheck);
1.1 cgd 870: }
1.83 jmc 871: if (shutUp && commandShell->hasEchoCtl) {
1.12 christos 872: DBPRINTF("%s\n", commandShell->echoOn);
1.1 cgd 873: }
1.88 christos 874: if (cp != NULL) {
875: DBPRINTF("test -d %s && ", cp);
876: DBPRINTF("cd %s\n", Var_Value(".OBJDIR", VAR_GLOBAL, &tmp));
877: }
1.12 christos 878: return 0;
1.1 cgd 879: }
880:
881: /*-
882: *-----------------------------------------------------------------------
883: * JobSaveCommand --
884: * Save a command to be executed when everything else is done.
885: * Callback function for JobFinish...
886: *
887: * Results:
888: * Always returns 0
889: *
890: * Side Effects:
891: * The command is tacked onto the end of postCommands's commands list.
892: *
893: *-----------------------------------------------------------------------
894: */
895: static int
1.144 dsl 896: JobSaveCommand(void *cmd, void *gn)
1.1 cgd 897: {
1.124 dsl 898: cmd = Var_Subst(NULL, (char *)cmd, (GNode *)gn, FALSE);
1.96 christos 899: (void)Lst_AtEnd(postCommands->commands, cmd);
1.12 christos 900: return(0);
901: }
902:
903:
904: /*-
905: *-----------------------------------------------------------------------
906: * JobClose --
907: * Called to close both input and output pipes when a job is finished.
908: *
909: * Results:
910: * Nada
911: *
912: * Side Effects:
913: * The file descriptors associated with the job are closed.
914: *
915: *-----------------------------------------------------------------------
916: */
917: static void
1.72 wiz 918: JobClose(Job *job)
1.12 christos 919: {
1.120 dsl 920: clearfd(job);
1.122 dsl 921: (void)close(job->outPipe);
922: job->outPipe = -1;
923:
1.120 dsl 924: JobDoOutput(job, TRUE);
925: (void)close(job->inPipe);
926: job->inPipe = -1;
1.1 cgd 927: }
928:
929: /*-
930: *-----------------------------------------------------------------------
931: * JobFinish --
932: * Do final processing for the given job including updating
933: * parents and starting new jobs as available/necessary. Note
934: * that we pay no attention to the JOB_IGNERR flag here.
935: * This is because when we're called because of a noexecute flag
936: * or something, jstat.w_status is 0 and when called from
937: * Job_CatchChildren, the status is zeroed if it s/b ignored.
938: *
1.72 wiz 939: * Input:
940: * job job to finish
941: * status sub-why job went away
942: *
1.1 cgd 943: * Results:
944: * None
945: *
946: * Side Effects:
947: * Final commands for the job are placed on postCommands.
948: *
1.16 christos 949: * If we got an error and are aborting (aborting == ABORT_ERROR) and
1.1 cgd 950: * the job list is now empty, we are done for the day.
1.16 christos 951: * If we recognized an error (errors !=0), we set the aborting flag
1.1 cgd 952: * to ABORT_ERROR so no more jobs will be started.
953: *-----------------------------------------------------------------------
954: */
955: /*ARGSUSED*/
1.5 cgd 956: static void
1.116 dsl 957: JobFinish(Job *job, int status)
1.1 cgd 958: {
1.102 dsl 959: Boolean done, return_job_token;
1.1 cgd 960:
1.116 dsl 961: if (DEBUG(JOB)) {
1.139 christos 962: fprintf(debug_file, "Jobfinish: %d [%s], status %d\n",
963: job->pid, job->node->name, status);
1.116 dsl 964: }
965:
966: if ((WIFEXITED(status) &&
967: (((WEXITSTATUS(status) != 0) && !(job->flags & JOB_IGNERR)))) ||
968: WIFSIGNALED(status))
1.1 cgd 969: {
970: /*
971: * If it exited non-zero and either we're doing things our
972: * way or we're not ignoring errors, the job is finished.
973: * Similarly, if the shell died because of a signal
974: * the job is also finished. In these
975: * cases, finish out the job's output before printing the exit
976: * status...
977: */
1.12 christos 978: JobClose(job);
1.1 cgd 979: if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
1.96 christos 980: (void)fclose(job->cmdFILE);
1.34 christos 981: job->cmdFILE = NULL;
1.1 cgd 982: }
983: done = TRUE;
1.116 dsl 984: } else if (WIFEXITED(status)) {
1.1 cgd 985: /*
986: * Deal with ignored errors in -B mode. We need to print a message
987: * telling of the ignored error as well as setting status.w_status
988: * to 0 so the next command gets run. To do this, we set done to be
1.12 christos 989: * TRUE if in -B mode and the job exited non-zero.
990: */
1.116 dsl 991: done = WEXITSTATUS(status) != 0;
1.16 christos 992: /*
1.12 christos 993: * Old comment said: "Note we don't
1.1 cgd 994: * want to close down any of the streams until we know we're at the
1.12 christos 995: * end."
996: * But we do. Otherwise when are we going to print the rest of the
997: * stuff?
998: */
999: JobClose(job);
1.1 cgd 1000: } else {
1001: /*
1002: * No need to close things down or anything.
1003: */
1004: done = FALSE;
1005: }
1.16 christos 1006:
1.116 dsl 1007: if (done) {
1008: if (WIFEXITED(status)) {
1.12 christos 1009: if (DEBUG(JOB)) {
1.139 christos 1010: (void)fprintf(debug_file, "Process %d [%s] exited.\n",
1011: job->pid, job->node->name);
1.12 christos 1012: }
1.116 dsl 1013: if (WEXITSTATUS(status) != 0) {
1.120 dsl 1014: if (job->node != lastNode) {
1.107 dsl 1015: MESSAGE(stdout, job->node);
1.1 cgd 1016: lastNode = job->node;
1017: }
1.155 sjg 1018: #ifdef USE_META
1019: if (useMeta) {
1020: meta_job_error(job, job->node, job->flags, WEXITSTATUS(status));
1021: }
1022: #endif
1.107 dsl 1023: (void)printf("*** [%s] Error code %d%s\n",
1.61 pk 1024: job->node->name,
1.116 dsl 1025: WEXITSTATUS(status),
1.152 christos 1026: (job->flags & JOB_IGNERR) ? " (ignored)" : "");
1.151 sjg 1027: if (job->flags & JOB_IGNERR) {
1.116 dsl 1028: status = 0;
1.151 sjg 1029: } else {
1030: PrintOnError(job->node, NULL);
1031: }
1.1 cgd 1032: } else if (DEBUG(JOB)) {
1.120 dsl 1033: if (job->node != lastNode) {
1.107 dsl 1034: MESSAGE(stdout, job->node);
1.1 cgd 1035: lastNode = job->node;
1036: }
1.107 dsl 1037: (void)printf("*** [%s] Completed successfully\n",
1.61 pk 1038: job->node->name);
1.12 christos 1039: }
1.1 cgd 1040: } else {
1.120 dsl 1041: if (job->node != lastNode) {
1.107 dsl 1042: MESSAGE(stdout, job->node);
1.1 cgd 1043: lastNode = job->node;
1044: }
1.107 dsl 1045: (void)printf("*** [%s] Signal %d\n",
1.116 dsl 1046: job->node->name, WTERMSIG(status));
1.1 cgd 1047: }
1.107 dsl 1048: (void)fflush(stdout);
1.1 cgd 1049: }
1.16 christos 1050:
1.156 sjg 1051: #ifdef USE_META
1052: if (useMeta) {
1053: meta_job_finish(job);
1054: }
1055: #endif
1056:
1.102 dsl 1057: return_job_token = FALSE;
1058:
1.107 dsl 1059: Trace_Log(JOBEND, job);
1060: if (!(job->flags & JOB_SPECIAL)) {
1.116 dsl 1061: if ((status != 0) ||
1.107 dsl 1062: (aborting == ABORT_ERROR) ||
1063: (aborting == ABORT_INTERRUPT))
1064: return_job_token = TRUE;
1.42 sommerfe 1065: }
1.1 cgd 1066:
1.116 dsl 1067: if ((aborting != ABORT_ERROR) && (aborting != ABORT_INTERRUPT) && (status == 0)) {
1.1 cgd 1068: /*
1069: * As long as we aren't aborting and the job didn't return a non-zero
1070: * status that we shouldn't ignore, we call Make_Update to update
1071: * the parents. In addition, any saved commands for the node are placed
1072: * on the .END target.
1073: */
1.142 dsl 1074: if (job->tailCmds != NULL) {
1.12 christos 1075: Lst_ForEachFrom(job->node->commands, job->tailCmds,
1.1 cgd 1076: JobSaveCommand,
1.124 dsl 1077: job->node);
1.1 cgd 1078: }
1079: job->node->made = MADE;
1.43 sommerfe 1080: if (!(job->flags & JOB_SPECIAL))
1.102 dsl 1081: return_job_token = TRUE;
1.12 christos 1082: Make_Update(job->node);
1.116 dsl 1083: job->job_state = JOB_ST_FREE;
1084: } else if (status != 0) {
1.1 cgd 1085: errors += 1;
1.116 dsl 1086: job->job_state = JOB_ST_FREE;
1.1 cgd 1087: }
1088:
1089: /*
1090: * Set aborting if any error.
1091: */
1092: if (errors && !keepgoing && (aborting != ABORT_INTERRUPT)) {
1093: /*
1094: * If we found any errors in this batch of children and the -k flag
1095: * wasn't given, we set the aborting flag so no more jobs get
1096: * started.
1097: */
1098: aborting = ABORT_ERROR;
1099: }
1.16 christos 1100:
1.102 dsl 1101: if (return_job_token)
1102: Job_TokenReturn();
1103:
1.111 dsl 1104: if (aborting == ABORT_ERROR && jobTokensRunning == 0) {
1.1 cgd 1105: /*
1106: * If we are aborting and the job table is now empty, we finish.
1107: */
1.12 christos 1108: Finish(errors);
1.1 cgd 1109: }
1110: }
1111:
1112: /*-
1113: *-----------------------------------------------------------------------
1114: * Job_Touch --
1115: * Touch the given target. Called by JobStart when the -t flag was
1116: * given
1117: *
1.72 wiz 1118: * Input:
1119: * gn the node of the file to touch
1120: * silent TRUE if should not print message
1121: *
1.1 cgd 1122: * Results:
1123: * None
1124: *
1125: * Side Effects:
1126: * The data modification of the file is changed. In addition, if the
1127: * file did not exist, it is created.
1128: *-----------------------------------------------------------------------
1129: */
1130: void
1.72 wiz 1131: Job_Touch(GNode *gn, Boolean silent)
1.1 cgd 1132: {
1133: int streamID; /* ID of stream opened to do the touch */
1.14 christos 1134: struct utimbuf times; /* Times for utime() call */
1.1 cgd 1135:
1.157 christos 1136: if (gn->type & (OP_JOIN|OP_USE|OP_USEBEFORE|OP_EXEC|OP_OPTIONAL|
1137: OP_SPECIAL|OP_PHONY)) {
1.1 cgd 1138: /*
1139: * .JOIN, .USE, .ZEROTIME and .OPTIONAL targets are "virtual" targets
1140: * and, as such, shouldn't really be created.
1141: */
1142: return;
1143: }
1.16 christos 1144:
1.45 sommerfe 1145: if (!silent || NoExecute(gn)) {
1.96 christos 1146: (void)fprintf(stdout, "touch %s\n", gn->name);
1147: (void)fflush(stdout);
1.1 cgd 1148: }
1149:
1.45 sommerfe 1150: if (NoExecute(gn)) {
1.1 cgd 1151: return;
1152: }
1153:
1154: if (gn->type & OP_ARCHV) {
1.12 christos 1155: Arch_Touch(gn);
1.1 cgd 1156: } else if (gn->type & OP_LIB) {
1.12 christos 1157: Arch_TouchLib(gn);
1.1 cgd 1158: } else {
1159: char *file = gn->path ? gn->path : gn->name;
1160:
1.14 christos 1161: times.actime = times.modtime = now;
1162: if (utime(file, ×) < 0){
1.12 christos 1163: streamID = open(file, O_RDWR | O_CREAT, 0666);
1.1 cgd 1164:
1165: if (streamID >= 0) {
1166: char c;
1167:
1168: /*
1169: * Read and write a byte to the file to change the
1170: * modification time, then close the file.
1171: */
1172: if (read(streamID, &c, 1) == 1) {
1.96 christos 1173: (void)lseek(streamID, (off_t)0, SEEK_SET);
1174: (void)write(streamID, &c, 1);
1.1 cgd 1175: }
1.16 christos 1176:
1.96 christos 1177: (void)close(streamID);
1.12 christos 1178: } else {
1.96 christos 1179: (void)fprintf(stdout, "*** couldn't touch %s: %s",
1.12 christos 1180: file, strerror(errno));
1.96 christos 1181: (void)fflush(stdout);
1.12 christos 1182: }
1.1 cgd 1183: }
1184: }
1185: }
1186:
1187: /*-
1188: *-----------------------------------------------------------------------
1189: * Job_CheckCommands --
1.16 christos 1190: * Make sure the given node has all the commands it needs.
1.1 cgd 1191: *
1.72 wiz 1192: * Input:
1193: * gn The target whose commands need verifying
1194: * abortProc Function to abort with message
1195: *
1.1 cgd 1196: * Results:
1197: * TRUE if the commands list is/was ok.
1198: *
1199: * Side Effects:
1200: * The node will have commands from the .DEFAULT rule added to it
1201: * if it needs them.
1202: *-----------------------------------------------------------------------
1203: */
1204: Boolean
1.77 christos 1205: Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...))
1.1 cgd 1206: {
1.12 christos 1207: if (OP_NOP(gn->type) && Lst_IsEmpty(gn->commands) &&
1.76 christos 1208: ((gn->type & OP_LIB) == 0 || Lst_IsEmpty(gn->children))) {
1.1 cgd 1209: /*
1210: * No commands. Look for .DEFAULT rule from which we might infer
1.16 christos 1211: * commands
1.1 cgd 1212: */
1.142 dsl 1213: if ((DEFAULT != NULL) && !Lst_IsEmpty(DEFAULT->commands) &&
1.110 dsl 1214: (gn->type & OP_SPECIAL) == 0) {
1.6 jtc 1215: char *p1;
1.1 cgd 1216: /*
1217: * Make only looks for a .DEFAULT if the node was never the
1218: * target of an operator, so that's what we do too. If
1219: * a .DEFAULT was given, we substitute its commands for gn's
1220: * commands and set the IMPSRC variable to be the target's name
1221: * The DEFAULT node acts like a transformation rule, in that
1222: * gn also inherits any attributes or sources attached to
1223: * .DEFAULT itself.
1224: */
1225: Make_HandleUse(DEFAULT, gn);
1.51 sjg 1226: Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), gn, 0);
1.6 jtc 1227: if (p1)
1228: free(p1);
1.92 christos 1229: } else if (Dir_MTime(gn) == 0 && (gn->type & OP_SPECIAL) == 0) {
1.1 cgd 1230: /*
1231: * The node wasn't the target of an operator we have no .DEFAULT
1232: * rule to go on and the target doesn't already exist. There's
1233: * nothing more we can do for this branch. If the -k flag wasn't
1234: * given, we stop in our tracks, otherwise we just don't update
1.16 christos 1235: * this node's parents so they never get examined.
1.1 cgd 1236: */
1.46 christos 1237: static const char msg[] = ": don't know how to make";
1.12 christos 1238:
1.134 dsl 1239: if (gn->flags & FROM_DEPEND) {
1.147 sjg 1240: fprintf(stdout, "%s: ignoring stale %s for %s\n",
1241: progname, makeDependfile, gn->name);
1.134 dsl 1242: return TRUE;
1243: }
1244:
1.1 cgd 1245: if (gn->type & OP_OPTIONAL) {
1.152 christos 1246: (void)fprintf(stdout, "%s%s %s (ignored)\n", progname,
1.46 christos 1247: msg, gn->name);
1.96 christos 1248: (void)fflush(stdout);
1.1 cgd 1249: } else if (keepgoing) {
1.152 christos 1250: (void)fprintf(stdout, "%s%s %s (continuing)\n", progname,
1.46 christos 1251: msg, gn->name);
1.96 christos 1252: (void)fflush(stdout);
1.12 christos 1253: return FALSE;
1.1 cgd 1254: } else {
1.46 christos 1255: (*abortProc)("%s%s %s. Stop", progname, msg, gn->name);
1.12 christos 1256: return FALSE;
1.1 cgd 1257: }
1258: }
1259: }
1.12 christos 1260: return TRUE;
1.1 cgd 1261: }
1262:
1263: /*-
1264: *-----------------------------------------------------------------------
1265: * JobExec --
1.116 dsl 1266: * Execute the shell for the given job. Called from JobStart
1.1 cgd 1267: *
1.72 wiz 1268: * Input:
1269: * job Job to execute
1270: *
1.1 cgd 1271: * Results:
1272: * None.
1273: *
1274: * Side Effects:
1275: * A shell is executed, outputs is altered and the Job structure added
1276: * to the job table.
1277: *
1278: *-----------------------------------------------------------------------
1279: */
1280: static void
1.72 wiz 1281: JobExec(Job *job, char **argv)
1.1 cgd 1282: {
1.139 christos 1283: int cpid; /* ID of new child */
1.69 pk 1284: sigset_t mask;
1.16 christos 1285:
1.49 sjg 1286: job->flags &= ~JOB_TRACED;
1287:
1.1 cgd 1288: if (DEBUG(JOB)) {
1289: int i;
1.16 christos 1290:
1.123 dsl 1291: (void)fprintf(debug_file, "Running %s %sly\n", job->node->name, "local");
1292: (void)fprintf(debug_file, "\tCommand: ");
1.12 christos 1293: for (i = 0; argv[i] != NULL; i++) {
1.123 dsl 1294: (void)fprintf(debug_file, "%s ", argv[i]);
1.1 cgd 1295: }
1.123 dsl 1296: (void)fprintf(debug_file, "\n");
1.1 cgd 1297: }
1.16 christos 1298:
1.1 cgd 1299: /*
1300: * Some jobs produce no output and it's disconcerting to have
1.16 christos 1301: * no feedback of their running (since they produce no output, the
1.1 cgd 1302: * banner with their name in it never appears). This is an attempt to
1303: * provide that feedback, even if nothing follows it.
1304: */
1.109 dsl 1305: if ((lastNode != job->node) && !(job->flags & JOB_SILENT)) {
1.12 christos 1306: MESSAGE(stdout, job->node);
1.1 cgd 1307: lastNode = job->node;
1308: }
1.16 christos 1309:
1.69 pk 1310: /* No interruptions until this job is on the `jobs' list */
1311: JobSigLock(&mask);
1312:
1.116 dsl 1313: /* Pre-emptively mark job running, pid still zero though */
1314: job->job_state = JOB_ST_RUNNING;
1315:
1.149 sjg 1316: cpid = vFork();
1.116 dsl 1317: if (cpid == -1)
1.53 matt 1318: Punt("Cannot vfork: %s", strerror(errno));
1.116 dsl 1319:
1320: if (cpid == 0) {
1321: /* Child */
1.146 sjg 1322: sigset_t tmask;
1.1 cgd 1323:
1.155 sjg 1324: #ifdef USE_META
1325: if (useMeta) {
1326: meta_job_child(job);
1327: }
1328: #endif
1.1 cgd 1329: /*
1.69 pk 1330: * Reset all signal handlers; this is necessary because we also
1331: * need to unblock signals before we exec(2).
1332: */
1333: JobSigReset();
1334:
1335: /* Now unblock signals */
1.146 sjg 1336: sigemptyset(&tmask);
1337: JobSigUnlock(&tmask);
1.69 pk 1338:
1339: /*
1.1 cgd 1340: * Must duplicate the input stream down to the child's input and
1.16 christos 1341: * reset it to the beginning (again). Since the stream was marked
1.1 cgd 1342: * close-on-exec, we must clear that bit in the new input.
1343: */
1.64 pk 1344: if (dup2(FILENO(job->cmdFILE), 0) == -1) {
1345: execError("dup2", "job->cmdFILE");
1346: _exit(1);
1347: }
1.96 christos 1348: (void)fcntl(0, F_SETFD, 0);
1349: (void)lseek(0, (off_t)0, SEEK_SET);
1.16 christos 1350:
1.40 sommerfe 1351: if (job->node->type & OP_MAKE) {
1352: /*
1353: * Pass job token pipe to submakes.
1354: */
1.122 dsl 1355: fcntl(tokenWaitJob.inPipe, F_SETFD, 0);
1356: fcntl(tokenWaitJob.outPipe, F_SETFD, 0);
1.40 sommerfe 1357: }
1358:
1.120 dsl 1359: /*
1360: * Set up the child's output to be routed through the pipe
1361: * we've created for it.
1362: */
1363: if (dup2(job->outPipe, 1) == -1) {
1364: execError("dup2", "job->outPipe");
1365: _exit(1);
1.1 cgd 1366: }
1367: /*
1368: * The output channels are marked close on exec. This bit was
1.96 christos 1369: * duplicated by the dup2(on some systems), so we have to clear
1.1 cgd 1370: * it before routing the shell's error output to the same place as
1371: * its standard output.
1372: */
1.96 christos 1373: (void)fcntl(1, F_SETFD, 0);
1.64 pk 1374: if (dup2(1, 2) == -1) {
1375: execError("dup2", "1, 2");
1376: _exit(1);
1377: }
1.1 cgd 1378:
1379: /*
1380: * We want to switch the child into a different process family so
1381: * we can kill it and all its descendants in one fell swoop,
1382: * by killing its process family, but not commit suicide.
1383: */
1.119 dsl 1384: #if defined(SYSV)
1385: /* XXX: dsl - I'm sure this should be setpgrp()... */
1.97 christos 1386: (void)setsid();
1.119 dsl 1387: #else
1.96 christos 1388: (void)setpgid(0, getpid());
1.119 dsl 1389: #endif
1.1 cgd 1390:
1.126 sjg 1391: Var_ExportVars();
1392:
1.106 dsl 1393: (void)execv(shellPath, argv);
1394: execError("exec", shellPath);
1.12 christos 1395: _exit(1);
1.116 dsl 1396: }
1397:
1398: /* Parent, continuing after the child exec */
1399: job->pid = cpid;
1.1 cgd 1400:
1.116 dsl 1401: Trace_Log(JOBSTART, job);
1.40 sommerfe 1402:
1.120 dsl 1403: /*
1404: * Set the current position in the buffer to the beginning
1405: * and mark another stream to watch in the outputs mask
1406: */
1407: job->curPos = 0;
1.16 christos 1408:
1.120 dsl 1409: watchfd(job);
1.1 cgd 1410:
1.116 dsl 1411: if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
1412: (void)fclose(job->cmdFILE);
1413: job->cmdFILE = NULL;
1.1 cgd 1414: }
1415:
1416: /*
1417: * Now the job is actually running, add it to the table.
1418: */
1.69 pk 1419: if (DEBUG(JOB)) {
1.139 christos 1420: fprintf(debug_file, "JobExec(%s): pid %d added to jobs table\n",
1421: job->node->name, job->pid);
1.114 dsl 1422: job_table_dump("job started");
1.69 pk 1423: }
1424: JobSigUnlock(&mask);
1.1 cgd 1425: }
1426:
1427: /*-
1428: *-----------------------------------------------------------------------
1429: * JobMakeArgv --
1430: * Create the argv needed to execute the shell for a given job.
1.16 christos 1431: *
1.1 cgd 1432: *
1433: * Results:
1434: *
1435: * Side Effects:
1436: *
1437: *-----------------------------------------------------------------------
1438: */
1439: static void
1.72 wiz 1440: JobMakeArgv(Job *job, char **argv)
1.1 cgd 1441: {
1442: int argc;
1.77 christos 1443: static char args[10]; /* For merged arguments */
1.16 christos 1444:
1.77 christos 1445: argv[0] = UNCONST(shellName);
1.1 cgd 1446: argc = 1;
1447:
1448: if ((commandShell->exit && (*commandShell->exit != '-')) ||
1449: (commandShell->echo && (*commandShell->echo != '-')))
1450: {
1451: /*
1452: * At least one of the flags doesn't have a minus before it, so
1453: * merge them together. Have to do this because the *(&(@*#*&#$#
1454: * Bourne shell thinks its second argument is a file to source.
1455: * Grrrr. Note the ten-character limitation on the combined arguments.
1456: */
1.29 christos 1457: (void)snprintf(args, sizeof(args), "-%s%s",
1.1 cgd 1458: ((job->flags & JOB_IGNERR) ? "" :
1459: (commandShell->exit ? commandShell->exit : "")),
1460: ((job->flags & JOB_SILENT) ? "" :
1461: (commandShell->echo ? commandShell->echo : "")));
1462:
1463: if (args[1]) {
1464: argv[argc] = args;
1465: argc++;
1466: }
1467: } else {
1468: if (!(job->flags & JOB_IGNERR) && commandShell->exit) {
1.77 christos 1469: argv[argc] = UNCONST(commandShell->exit);
1.1 cgd 1470: argc++;
1471: }
1472: if (!(job->flags & JOB_SILENT) && commandShell->echo) {
1.77 christos 1473: argv[argc] = UNCONST(commandShell->echo);
1.1 cgd 1474: argc++;
1475: }
1476: }
1.12 christos 1477: argv[argc] = NULL;
1.1 cgd 1478: }
1479:
1480: /*-
1481: *-----------------------------------------------------------------------
1482: * JobStart --
1483: * Start a target-creation process going for the target described
1.16 christos 1484: * by the graph node gn.
1.1 cgd 1485: *
1.72 wiz 1486: * Input:
1487: * gn target to create
1488: * flags flags for the job to override normal ones.
1489: * e.g. JOB_SPECIAL or JOB_IGNDOTS
1490: * previous The previous Job structure for this node, if any.
1491: *
1.1 cgd 1492: * Results:
1493: * JOB_ERROR if there was an error in the commands, JOB_FINISHED
1494: * if there isn't actually anything left to do for the job and
1495: * JOB_RUNNING if the job has been started.
1496: *
1497: * Side Effects:
1498: * A new Job node is created and added to the list of running
1499: * jobs. PMake is forked and a child shell created.
1.110 dsl 1500: *
1501: * NB: I'm fairly sure that this code is never called with JOB_SPECIAL set
1502: * JOB_IGNDOTS is never set (dsl)
1.122 dsl 1503: * Also the return value is ignored by everyone.
1.1 cgd 1504: *-----------------------------------------------------------------------
1505: */
1506: static int
1.108 dsl 1507: JobStart(GNode *gn, int flags)
1.1 cgd 1508: {
1.72 wiz 1509: Job *job; /* new job descriptor */
1.29 christos 1510: char *argv[10]; /* Argument vector to shell */
1.1 cgd 1511: Boolean cmdsOK; /* true if the nodes commands were all right */
1512: Boolean noExec; /* Set true if we decide not to run the job */
1.31 christos 1513: int tfd; /* File descriptor to the temp file */
1.1 cgd 1514:
1.114 dsl 1515: for (job = job_table; job < job_table_end; job++) {
1.116 dsl 1516: if (job->job_state == JOB_ST_FREE)
1.114 dsl 1517: break;
1518: }
1519: if (job >= job_table_end)
1.122 dsl 1520: Punt("JobStart no job slots vacant");
1521:
1.114 dsl 1522: memset(job, 0, sizeof *job);
1.116 dsl 1523: job->job_state = JOB_ST_SETUP;
1.91 christos 1524: if (gn->type & OP_SPECIAL)
1525: flags |= JOB_SPECIAL;
1.1 cgd 1526:
1527: job->node = gn;
1.142 dsl 1528: job->tailCmds = NULL;
1.1 cgd 1529:
1530: /*
1531: * Set the initial value of the flags for this job based on the global
1532: * ones and the node's attributes... Any flags supplied by the caller
1533: * are also added to the field.
1534: */
1535: job->flags = 0;
1.12 christos 1536: if (Targ_Ignore(gn)) {
1.1 cgd 1537: job->flags |= JOB_IGNERR;
1538: }
1.12 christos 1539: if (Targ_Silent(gn)) {
1.1 cgd 1540: job->flags |= JOB_SILENT;
1541: }
1542: job->flags |= flags;
1543:
1544: /*
1545: * Check the commands now so any attributes from .DEFAULT have a chance
1546: * to migrate to the node
1547: */
1.109 dsl 1548: cmdsOK = Job_CheckCommands(gn, Error);
1.16 christos 1549:
1.36 christos 1550: job->inPollfd = NULL;
1.1 cgd 1551: /*
1.16 christos 1552: * If the -n flag wasn't given, we open up OUR (not the child's)
1.1 cgd 1553: * temporary file to stuff commands in it. The thing is rd/wr so we don't
1554: * need to reopen it to feed it to the shell. If the -n flag *was* given,
1555: * we just set the file to be stdout. Cute, huh?
1556: */
1.45 sommerfe 1557: if (((gn->type & OP_MAKE) && !(noRecursiveExecute)) ||
1.122 dsl 1558: (!noExecute && !touchFlag)) {
1.1 cgd 1559: /*
1.34 christos 1560: * tfile is the name of a file into which all shell commands are
1.145 apb 1561: * put. It is removed before the child shell is executed, unless
1562: * DEBUG(SCRIPT) is set.
1.34 christos 1563: */
1.145 apb 1564: char *tfile;
1.69 pk 1565: sigset_t mask;
1.34 christos 1566: /*
1.1 cgd 1567: * We're serious here, but if the commands were bogus, we're
1568: * also dead...
1569: */
1570: if (!cmdsOK) {
1.154 sjg 1571: PrintOnError(gn, NULL); /* provide some clue */
1.1 cgd 1572: DieHorribly();
1573: }
1.16 christos 1574:
1.69 pk 1575: JobSigLock(&mask);
1.148 sjg 1576: tfd = mkTempFile(TMPPAT, &tfile);
1.94 jmc 1577: if (!DEBUG(SCRIPT))
1.96 christos 1578: (void)eunlink(tfile);
1.69 pk 1579: JobSigUnlock(&mask);
1.31 christos 1580:
1581: job->cmdFILE = fdopen(tfd, "w+");
1.12 christos 1582: if (job->cmdFILE == NULL) {
1.31 christos 1583: Punt("Could not fdopen %s", tfile);
1.1 cgd 1584: }
1.96 christos 1585: (void)fcntl(FILENO(job->cmdFILE), F_SETFD, 1);
1.1 cgd 1586: /*
1587: * Send the commands to the command file, flush all its buffers then
1588: * rewind and remove the thing.
1589: */
1590: noExec = FALSE;
1591:
1.155 sjg 1592: #ifdef USE_META
1593: if (useMeta) {
1594: meta_job_start(job, gn);
1595: }
1596: #endif
1.1 cgd 1597: /*
1.107 dsl 1598: * We can do all the commands at once. hooray for sanity
1.1 cgd 1599: */
1.107 dsl 1600: numCommands = 0;
1.124 dsl 1601: Lst_ForEach(gn->commands, JobPrintCommand, job);
1.16 christos 1602:
1.107 dsl 1603: /*
1604: * If we didn't print out any commands to the shell script,
1605: * there's not much point in executing the shell, is there?
1606: */
1607: if (numCommands == 0) {
1608: noExec = TRUE;
1.1 cgd 1609: }
1.145 apb 1610:
1611: free(tfile);
1.45 sommerfe 1612: } else if (NoExecute(gn)) {
1.1 cgd 1613: /*
1614: * Not executing anything -- just print all the commands to stdout
1615: * in one fell swoop. This will still set up job->tailCmds correctly.
1616: */
1617: if (lastNode != gn) {
1.12 christos 1618: MESSAGE(stdout, gn);
1.1 cgd 1619: lastNode = gn;
1620: }
1621: job->cmdFILE = stdout;
1622: /*
1623: * Only print the commands if they're ok, but don't die if they're
1624: * not -- just let the user know they're bad and keep going. It
1625: * doesn't do any harm in this case and may do some good.
1626: */
1627: if (cmdsOK) {
1.124 dsl 1628: Lst_ForEach(gn->commands, JobPrintCommand, job);
1.1 cgd 1629: }
1630: /*
1631: * Don't execute the shell, thank you.
1632: */
1633: noExec = TRUE;
1634: } else {
1635: /*
1636: * Just touch the target and note that no shell should be executed.
1637: * Set cmdFILE to stdout to make life easier. Check the commands, too,
1638: * but don't die if they're no good -- it does no harm to keep working
1639: * up the graph.
1640: */
1641: job->cmdFILE = stdout;
1.12 christos 1642: Job_Touch(gn, job->flags&JOB_SILENT);
1.1 cgd 1643: noExec = TRUE;
1644: }
1.118 dsl 1645: /* Just in case it isn't already... */
1646: (void)fflush(job->cmdFILE);
1.1 cgd 1647:
1648: /*
1.16 christos 1649: * If we're not supposed to execute a shell, don't.
1.1 cgd 1650: */
1651: if (noExec) {
1.110 dsl 1652: if (!(job->flags & JOB_SPECIAL))
1653: Job_TokenReturn();
1.1 cgd 1654: /*
1655: * Unlink and close the command file if we opened one
1656: */
1657: if (job->cmdFILE != stdout) {
1.34 christos 1658: if (job->cmdFILE != NULL) {
1.96 christos 1659: (void)fclose(job->cmdFILE);
1.34 christos 1660: job->cmdFILE = NULL;
1661: }
1.1 cgd 1662: }
1663:
1664: /*
1665: * We only want to work our way up the graph if we aren't here because
1666: * the commands for the job were no good.
1667: */
1.118 dsl 1668: if (cmdsOK && aborting == 0) {
1.142 dsl 1669: if (job->tailCmds != NULL) {
1.118 dsl 1670: Lst_ForEachFrom(job->node->commands, job->tailCmds,
1671: JobSaveCommand,
1.124 dsl 1672: job->node);
1.1 cgd 1673: }
1.118 dsl 1674: job->node->made = MADE;
1675: Make_Update(job->node);
1.1 cgd 1676: }
1.118 dsl 1677: job->job_state = JOB_ST_FREE;
1678: return cmdsOK ? JOB_FINISHED : JOB_ERROR;
1.1 cgd 1679: }
1680:
1681: /*
1682: * Set up the control arguments to the shell. This is based on the flags
1683: * set earlier for this job.
1684: */
1685: JobMakeArgv(job, argv);
1686:
1.122 dsl 1687: /* Create the pipe by which we'll get the shell's output. */
1688: JobCreatePipe(job, 3);
1.1 cgd 1689:
1.106 dsl 1690: JobExec(job, argv);
1.1 cgd 1691: return(JOB_RUNNING);
1692: }
1693:
1.16 christos 1694: static char *
1.72 wiz 1695: JobOutput(Job *job, char *cp, char *endp, int msg)
1.12 christos 1696: {
1.72 wiz 1697: char *ecp;
1.12 christos 1698:
1699: if (commandShell->noPrint) {
1700: ecp = Str_FindSubstring(cp, commandShell->noPrint);
1701: while (ecp != NULL) {
1702: if (cp != ecp) {
1703: *ecp = '\0';
1.99 dsl 1704: if (!beSilent && msg && job->node != lastNode) {
1.12 christos 1705: MESSAGE(stdout, job->node);
1706: lastNode = job->node;
1707: }
1708: /*
1709: * The only way there wouldn't be a newline after
1710: * this line is if it were the last in the buffer.
1711: * however, since the non-printable comes after it,
1712: * there must be a newline, so we don't print one.
1713: */
1.96 christos 1714: (void)fprintf(stdout, "%s", cp);
1715: (void)fflush(stdout);
1.12 christos 1716: }
1717: cp = ecp + commandShell->noPLen;
1718: if (cp != endp) {
1719: /*
1720: * Still more to print, look again after skipping
1721: * the whitespace following the non-printable
1722: * command....
1723: */
1724: cp++;
1725: while (*cp == ' ' || *cp == '\t' || *cp == '\n') {
1726: cp++;
1727: }
1728: ecp = Str_FindSubstring(cp, commandShell->noPrint);
1729: } else {
1730: return cp;
1731: }
1732: }
1733: }
1734: return cp;
1735: }
1736:
1.1 cgd 1737: /*-
1738: *-----------------------------------------------------------------------
1739: * JobDoOutput --
1740: * This function is called at different times depending on
1741: * whether the user has specified that output is to be collected
1742: * via pipes or temporary files. In the former case, we are called
1743: * whenever there is something to read on the pipe. We collect more
1744: * output from the given job and store it in the job's outBuf. If
1745: * this makes up a line, we print it tagged by the job's identifier,
1746: * as necessary.
1747: * If output has been collected in a temporary file, we open the
1748: * file and read it line by line, transfering it to our own
1749: * output channel until the file is empty. At which point we
1750: * remove the temporary file.
1751: * In both cases, however, we keep our figurative eye out for the
1752: * 'noPrint' line for the shell from which the output came. If
1753: * we recognize a line, we don't print it. If the command is not
1.16 christos 1754: * alone on the line (the character after it is not \0 or \n), we
1.1 cgd 1755: * do print whatever follows it.
1756: *
1.72 wiz 1757: * Input:
1758: * job the job whose output needs printing
1759: * finish TRUE if this is the last time we'll be called
1760: * for this job
1761: *
1.1 cgd 1762: * Results:
1763: * None
1764: *
1765: * Side Effects:
1766: * curPos may be shifted as may the contents of outBuf.
1767: *-----------------------------------------------------------------------
1768: */
1.12 christos 1769: STATIC void
1.72 wiz 1770: JobDoOutput(Job *job, Boolean finish)
1.1 cgd 1771: {
1772: Boolean gotNL = FALSE; /* true if got a newline */
1.12 christos 1773: Boolean fbuf; /* true if our buffer filled up */
1.139 christos 1774: int nr; /* number of bytes read */
1775: int i; /* auxiliary index into outBuf */
1776: int max; /* limit for i (end of current data) */
1777: int nRead; /* (Temporary) number of bytes read */
1.1 cgd 1778:
1.120 dsl 1779: /*
1780: * Read as many bytes as will fit in the buffer.
1781: */
1.1 cgd 1782: end_loop:
1.120 dsl 1783: gotNL = FALSE;
1784: fbuf = FALSE;
1.16 christos 1785:
1.120 dsl 1786: nRead = read(job->inPipe, &job->outBuf[job->curPos],
1.139 christos 1787: JOB_BUFSIZE - job->curPos);
1.120 dsl 1788: if (nRead < 0) {
1.122 dsl 1789: if (errno == EAGAIN)
1790: return;
1.120 dsl 1791: if (DEBUG(JOB)) {
1792: perror("JobDoOutput(piperead)");
1.1 cgd 1793: }
1.120 dsl 1794: nr = 0;
1795: } else {
1796: nr = nRead;
1797: }
1.1 cgd 1798:
1.120 dsl 1799: /*
1800: * If we hit the end-of-file (the job is dead), we must flush its
1801: * remaining output, so pretend we read a newline if there's any
1802: * output remaining in the buffer.
1803: * Also clear the 'finish' flag so we stop looping.
1804: */
1805: if ((nr == 0) && (job->curPos != 0)) {
1806: job->outBuf[job->curPos] = '\n';
1807: nr = 1;
1808: finish = FALSE;
1809: } else if (nr == 0) {
1810: finish = FALSE;
1811: }
1.16 christos 1812:
1.120 dsl 1813: /*
1814: * Look for the last newline in the bytes we just got. If there is
1815: * one, break out of the loop with 'i' as its index and gotNL set
1816: * TRUE.
1817: */
1818: max = job->curPos + nr;
1.139 christos 1819: for (i = job->curPos + nr - 1; i >= job->curPos; i--) {
1820: if (job->outBuf[i] == '\n') {
1821: gotNL = TRUE;
1822: break;
1823: } else if (job->outBuf[i] == '\0') {
1824: /*
1825: * Why?
1826: */
1827: job->outBuf[i] = ' ';
1.1 cgd 1828: }
1.139 christos 1829: }
1.16 christos 1830:
1.120 dsl 1831: if (!gotNL) {
1832: job->curPos += nr;
1833: if (job->curPos == JOB_BUFSIZE) {
1.1 cgd 1834: /*
1.120 dsl 1835: * If we've run out of buffer space, we have no choice
1836: * but to print the stuff. sigh.
1.1 cgd 1837: */
1.120 dsl 1838: fbuf = TRUE;
1839: i = job->curPos;
1840: }
1841: }
1842: if (gotNL || fbuf) {
1843: /*
1844: * Need to send the output to the screen. Null terminate it
1845: * first, overwriting the newline character if there was one.
1846: * So long as the line isn't one we should filter (according
1847: * to the shell description), we print the line, preceded
1848: * by a target banner if this target isn't the same as the
1849: * one for which we last printed something.
1850: * The rest of the data in the buffer are then shifted down
1851: * to the start of the buffer and curPos is set accordingly.
1852: */
1853: job->outBuf[i] = '\0';
1854: if (i >= job->curPos) {
1855: char *cp;
1.16 christos 1856:
1.120 dsl 1857: cp = JobOutput(job, job->outBuf, &job->outBuf[i], FALSE);
1.1 cgd 1858:
1.120 dsl 1859: /*
1860: * There's still more in that thar buffer. This time, though,
1861: * we know there's no newline at the end, so we add one of
1862: * our own free will.
1863: */
1864: if (*cp != '\0') {
1865: if (!beSilent && job->node != lastNode) {
1866: MESSAGE(stdout, job->node);
1867: lastNode = job->node;
1.1 cgd 1868: }
1.155 sjg 1869: #ifdef USE_META
1870: if (useMeta) {
1871: meta_job_output(job, cp, gotNL ? "\n" : "");
1872: }
1873: #endif
1.120 dsl 1874: (void)fprintf(stdout, "%s%s", cp, gotNL ? "\n" : "");
1875: (void)fflush(stdout);
1.1 cgd 1876: }
1.120 dsl 1877: }
1.139 christos 1878: if (i < max - 1) {
1.120 dsl 1879: /* shift the remaining characters down */
1880: (void)memcpy(job->outBuf, &job->outBuf[i + 1], max - (i + 1));
1881: job->curPos = max - (i + 1);
1.16 christos 1882:
1.120 dsl 1883: } else {
1.1 cgd 1884: /*
1.120 dsl 1885: * We have written everything out, so we just start over
1886: * from the start of the buffer. No copying. No nothing.
1.1 cgd 1887: */
1.120 dsl 1888: job->curPos = 0;
1.1 cgd 1889: }
1.120 dsl 1890: }
1891: if (finish) {
1.1 cgd 1892: /*
1.120 dsl 1893: * If the finish flag is true, we must loop until we hit
1894: * end-of-file on the pipe. This is guaranteed to happen
1895: * eventually since the other end of the pipe is now closed
1896: * (we closed it explicitly and the child has exited). When
1897: * we do get an EOF, finish will be set FALSE and we'll fall
1898: * through and out.
1899: */
1900: goto end_loop;
1.1 cgd 1901: }
1902: }
1903:
1.91 christos 1904: static void
1905: JobRun(GNode *targ)
1906: {
1907: #ifdef notyet
1908: /*
1909: * Unfortunately it is too complicated to run .BEGIN, .END,
1910: * and .INTERRUPT job in the parallel job module. This has
1911: * the nice side effect that it avoids a lot of other problems.
1912: */
1913: Lst lst = Lst_Init(FALSE);
1914: Lst_AtEnd(lst, targ);
1915: (void)Make_Run(lst);
1.142 dsl 1916: Lst_Destroy(lst, NULL);
1.108 dsl 1917: JobStart(targ, JOB_SPECIAL);
1.110 dsl 1918: while (jobTokensRunning) {
1.91 christos 1919: Job_CatchOutput();
1920: }
1921: #else
1922: Compat_Make(targ, targ);
1923: if (targ->made == ERROR) {
1.147 sjg 1924: PrintOnError(targ, "\n\nStop.");
1.91 christos 1925: exit(1);
1926: }
1927: #endif
1928: }
1929:
1.1 cgd 1930: /*-
1931: *-----------------------------------------------------------------------
1932: * Job_CatchChildren --
1933: * Handle the exit of a child. Called from Make_Make.
1934: *
1.72 wiz 1935: * Input:
1936: * block TRUE if should block on the wait
1937: *
1.1 cgd 1938: * Results:
1939: * none.
1940: *
1941: * Side Effects:
1942: * The job descriptor is removed from the list of children.
1943: *
1944: * Notes:
1945: * We do waits, blocking or not, according to the wisdom of our
1946: * caller, until there are no more children to report. For each
1.118 dsl 1947: * job, call JobFinish to finish things off.
1.1 cgd 1948: *
1949: *-----------------------------------------------------------------------
1950: */
1.116 dsl 1951:
1.1 cgd 1952: void
1.120 dsl 1953: Job_CatchChildren(void)
1.1 cgd 1954: {
1.139 christos 1955: int pid; /* pid of dead child */
1956: int status; /* Exit/termination status */
1.1 cgd 1957:
1958: /*
1959: * Don't even bother if we know there's no one around.
1960: */
1.116 dsl 1961: if (jobTokensRunning == 0)
1.1 cgd 1962: return;
1.16 christos 1963:
1.120 dsl 1964: while ((pid = waitpid((pid_t) -1, &status, WNOHANG | WUNTRACED)) > 0) {
1.12 christos 1965: if (DEBUG(JOB)) {
1.139 christos 1966: (void)fprintf(debug_file, "Process %d exited/stopped status %x.\n", pid,
1967: status);
1.12 christos 1968: }
1.153 sjg 1969: JobReapChild(pid, status, TRUE);
1970: }
1971: }
1972:
1973: /*
1974: * It is possible that wait[pid]() was called from elsewhere,
1975: * this lets us reap jobs regardless.
1976: */
1977: void
1978: JobReapChild(pid_t pid, int status, Boolean isJobs)
1979: {
1980: Job *job; /* job descriptor for dead child */
1981:
1982: /*
1983: * Don't even bother if we know there's no one around.
1984: */
1985: if (jobTokensRunning == 0)
1986: return;
1.16 christos 1987:
1.153 sjg 1988: job = JobFindPid(pid, JOB_ST_RUNNING, isJobs);
1989: if (job == NULL) {
1990: if (isJobs) {
1.117 dsl 1991: if (!lurking_children)
1.139 christos 1992: Error("Child (%d) status %x not in table?", pid, status);
1.116 dsl 1993: }
1.153 sjg 1994: return; /* not ours */
1995: }
1996: if (WIFSTOPPED(status)) {
1997: if (DEBUG(JOB)) {
1998: (void)fprintf(debug_file, "Process %d (%s) stopped.\n",
1999: job->pid, job->node->name);
2000: }
2001: if (!make_suspended) {
2002: switch (WSTOPSIG(status)) {
2003: case SIGTSTP:
2004: (void)printf("*** [%s] Suspended\n", job->node->name);
2005: break;
2006: case SIGSTOP:
2007: (void)printf("*** [%s] Stopped\n", job->node->name);
2008: break;
2009: default:
2010: (void)printf("*** [%s] Stopped -- signal %d\n",
2011: job->node->name, WSTOPSIG(status));
1.1 cgd 2012: }
1.153 sjg 2013: job->job_suspended = 1;
1.1 cgd 2014: }
1.153 sjg 2015: (void)fflush(stdout);
2016: return;
2017: }
1.1 cgd 2018:
1.153 sjg 2019: job->job_state = JOB_ST_FINISHED;
2020: job->exit_status = status;
1.116 dsl 2021:
1.153 sjg 2022: JobFinish(job, status);
1.1 cgd 2023: }
2024:
2025: /*-
2026: *-----------------------------------------------------------------------
2027: * Job_CatchOutput --
2028: * Catch the output from our children, if we're using
2029: * pipes do so. Otherwise just block time until we get a
1.96 christos 2030: * signal(most likely a SIGCHLD) since there's no point in
1.1 cgd 2031: * just spinning when there's nothing to do and the reaping
1.16 christos 2032: * of a child can wait for a while.
1.1 cgd 2033: *
2034: * Results:
1.16 christos 2035: * None
1.1 cgd 2036: *
2037: * Side Effects:
2038: * Output is read from pipes if we're piping.
2039: * -----------------------------------------------------------------------
2040: */
2041: void
1.72 wiz 2042: Job_CatchOutput(void)
1.1 cgd 2043: {
1.122 dsl 2044: int nready;
2045: Job *job;
2046: int i;
1.1 cgd 2047:
1.96 christos 2048: (void)fflush(stdout);
1.105 dsl 2049:
1.120 dsl 2050: /* The first fd in the list is the job token pipe */
1.122 dsl 2051: nready = poll(fds + 1 - wantToken, nfds - 1 + wantToken, POLL_MSEC);
1.120 dsl 2052:
1.122 dsl 2053: if (nready < 0 || readyfd(&childExitJob)) {
1.120 dsl 2054: char token = 0;
2055: nready -= 1;
2056: (void)read(childExitJob.inPipe, &token, 1);
2057: if (token == DO_JOB_RESUME[0])
2058: /* Complete relay requested from our SIGCONT handler */
2059: JobRestartJobs();
1.122 dsl 2060: Job_CatchChildren();
1.120 dsl 2061: }
2062:
1.122 dsl 2063: if (nready <= 0)
2064: return;
2065:
2066: if (wantToken && readyfd(&tokenWaitJob))
2067: nready--;
2068:
2069: for (i = 2; i < nfds; i++) {
2070: if (!fds[i].revents)
2071: continue;
2072: job = jobfds[i];
1.120 dsl 2073: if (job->job_state != JOB_ST_RUNNING)
2074: continue;
1.122 dsl 2075: JobDoOutput(job, FALSE);
1.1 cgd 2076: }
2077: }
2078:
2079: /*-
2080: *-----------------------------------------------------------------------
2081: * Job_Make --
2082: * Start the creation of a target. Basically a front-end for
2083: * JobStart used by the Make module.
2084: *
2085: * Results:
2086: * None.
2087: *
2088: * Side Effects:
2089: * Another job is started.
2090: *
2091: *-----------------------------------------------------------------------
2092: */
2093: void
1.72 wiz 2094: Job_Make(GNode *gn)
1.1 cgd 2095: {
1.108 dsl 2096: (void)JobStart(gn, 0);
1.1 cgd 2097: }
2098:
1.81 sjg 2099: void
1.120 dsl 2100: Shell_Init(void)
1.81 sjg 2101: {
2102: if (shellPath == NULL) {
2103: /*
1.127 sjg 2104: * We are using the default shell, which may be an absolute
1.133 apb 2105: * path if DEFSHELL_CUSTOM is defined.
1.81 sjg 2106: */
2107: shellName = commandShell->name;
1.133 apb 2108: #ifdef DEFSHELL_CUSTOM
1.127 sjg 2109: if (*shellName == '/') {
2110: shellPath = shellName;
2111: shellName = strrchr(shellPath, '/');
2112: shellName++;
2113: } else
2114: #endif
1.81 sjg 2115: shellPath = str_concat(_PATH_DEFSHELLDIR, shellName, STR_ADDSLASH);
2116: }
2117: if (commandShell->exit == NULL) {
2118: commandShell->exit = "";
2119: }
2120: if (commandShell->echo == NULL) {
2121: commandShell->echo = "";
2122: }
2123: }
2124:
1.1 cgd 2125: /*-
1.112 rillig 2126: * Returns the string literal that is used in the current command shell
2127: * to produce a newline character.
2128: */
2129: const char *
2130: Shell_GetNewline(void)
2131: {
2132:
2133: return commandShell->newline;
2134: }
2135:
1.125 sjg 2136: void
2137: Job_SetPrefix(void)
2138: {
2139:
2140: if (targPrefix) {
2141: free(targPrefix);
1.126 sjg 2142: } else if (!Var_Exists(MAKE_JOB_PREFIX, VAR_GLOBAL)) {
2143: Var_Set(MAKE_JOB_PREFIX, "---", VAR_GLOBAL, 0);
1.125 sjg 2144: }
1.128 dsl 2145:
1.132 apb 2146: targPrefix = Var_Subst(NULL, "${" MAKE_JOB_PREFIX "}", VAR_GLOBAL, 0);
1.125 sjg 2147: }
2148:
1.112 rillig 2149: /*-
1.1 cgd 2150: *-----------------------------------------------------------------------
2151: * Job_Init --
2152: * Initialize the process module
2153: *
1.72 wiz 2154: * Input:
2155: *
1.1 cgd 2156: * Results:
2157: * none
2158: *
2159: * Side Effects:
2160: * lists and counters are initialized
2161: *-----------------------------------------------------------------------
2162: */
2163: void
1.111 dsl 2164: Job_Init(void)
1.1 cgd 2165: {
2166: GNode *begin; /* node for commands to do at the very start */
2167:
1.114 dsl 2168: /* Allocate space for all the job info */
1.140 joerg 2169: job_table = bmake_malloc(maxJobs * sizeof *job_table);
1.114 dsl 2170: memset(job_table, 0, maxJobs * sizeof *job_table);
2171: job_table_end = job_table + maxJobs;
1.120 dsl 2172: wantToken = 0;
1.1 cgd 2173:
2174: aborting = 0;
2175: errors = 0;
2176:
1.142 dsl 2177: lastNode = NULL;
1.1 cgd 2178:
1.117 dsl 2179: /*
2180: * There is a non-zero chance that we already have children.
2181: * eg after 'make -f- <<EOF'
2182: * Since their termination causes a 'Child (pid) not in table' message,
2183: * Collect the status of any that are already dead, and suppress the
2184: * error message if there are any undead ones.
2185: */
2186: for (;;) {
2187: int rval, status;
2188: rval = waitpid((pid_t) -1, &status, WNOHANG);
2189: if (rval > 0)
2190: continue;
2191: if (rval == 0)
2192: lurking_children = 1;
2193: break;
2194: }
2195:
1.81 sjg 2196: Shell_Init();
1.1 cgd 2197:
1.122 dsl 2198: JobCreatePipe(&childExitJob, 3);
1.73 gson 2199:
1.122 dsl 2200: /* We can only need to wait for tokens, children and output from each job */
1.140 joerg 2201: fds = bmake_malloc(sizeof (*fds) * (2 + maxJobs));
2202: jobfds = bmake_malloc(sizeof (*jobfds) * (2 + maxJobs));
1.122 dsl 2203:
2204: /* These are permanent entries and take slots 0 and 1 */
2205: watchfd(&tokenWaitJob);
2206: watchfd(&childExitJob);
1.73 gson 2207:
1.69 pk 2208: sigemptyset(&caught_signals);
1.1 cgd 2209: /*
1.73 gson 2210: * Install a SIGCHLD handler.
1.1 cgd 2211: */
1.150 sjg 2212: (void)bmake_signal(SIGCHLD, JobChildSig);
1.69 pk 2213: sigaddset(&caught_signals, SIGCHLD);
2214:
2215: #define ADDSIG(s,h) \
1.150 sjg 2216: if (bmake_signal(s, SIG_IGN) != SIG_IGN) { \
1.69 pk 2217: sigaddset(&caught_signals, s); \
1.150 sjg 2218: (void)bmake_signal(s, h); \
1.1 cgd 2219: }
1.69 pk 2220:
1.37 sommerfe 2221: /*
1.69 pk 2222: * Catch the four signals that POSIX specifies if they aren't ignored.
2223: * JobPassSig will take care of calling JobInterrupt if appropriate.
1.37 sommerfe 2224: */
1.116 dsl 2225: ADDSIG(SIGINT, JobPassSig_int)
2226: ADDSIG(SIGHUP, JobPassSig_term)
2227: ADDSIG(SIGTERM, JobPassSig_term)
2228: ADDSIG(SIGQUIT, JobPassSig_term)
1.69 pk 2229:
1.1 cgd 2230: /*
2231: * There are additional signals that need to be caught and passed if
2232: * either the export system wants to be told directly of signals or if
1.16 christos 2233: * we're giving each job its own process group (since then it won't get
1.1 cgd 2234: * signals from the terminal driver as we own the terminal)
2235: */
1.116 dsl 2236: ADDSIG(SIGTSTP, JobPassSig_suspend)
2237: ADDSIG(SIGTTOU, JobPassSig_suspend)
2238: ADDSIG(SIGTTIN, JobPassSig_suspend)
2239: ADDSIG(SIGWINCH, JobCondPassSig)
1.69 pk 2240: ADDSIG(SIGCONT, JobContinueSig)
2241: #undef ADDSIG
1.16 christos 2242:
1.12 christos 2243: begin = Targ_FindNode(".BEGIN", TARG_NOCREATE);
1.1 cgd 2244:
1.142 dsl 2245: if (begin != NULL) {
1.91 christos 2246: JobRun(begin);
2247: if (begin->made == ERROR) {
1.147 sjg 2248: PrintOnError(begin, "\n\nStop.");
1.91 christos 2249: exit(1);
1.1 cgd 2250: }
2251: }
1.12 christos 2252: postCommands = Targ_FindNode(".END", TARG_CREATE);
1.1 cgd 2253: }
2254:
1.72 wiz 2255: static void JobSigReset(void)
1.69 pk 2256: {
2257: #define DELSIG(s) \
2258: if (sigismember(&caught_signals, s)) { \
1.150 sjg 2259: (void)bmake_signal(s, SIG_DFL); \
1.69 pk 2260: }
2261:
2262: DELSIG(SIGINT)
2263: DELSIG(SIGHUP)
2264: DELSIG(SIGQUIT)
2265: DELSIG(SIGTERM)
2266: DELSIG(SIGTSTP)
2267: DELSIG(SIGTTOU)
2268: DELSIG(SIGTTIN)
2269: DELSIG(SIGWINCH)
2270: DELSIG(SIGCONT)
2271: #undef DELSIG
1.150 sjg 2272: (void)bmake_signal(SIGCHLD, SIG_DFL);
1.69 pk 2273: }
2274:
1.1 cgd 2275: /*-
2276: *-----------------------------------------------------------------------
2277: * JobMatchShell --
1.66 pk 2278: * Find a shell in 'shells' given its name.
1.1 cgd 2279: *
2280: * Results:
2281: * A pointer to the Shell structure.
2282: *
2283: * Side Effects:
2284: * None.
2285: *
2286: *-----------------------------------------------------------------------
2287: */
2288: static Shell *
1.77 christos 2289: JobMatchShell(const char *name)
1.1 cgd 2290: {
1.66 pk 2291: Shell *sh;
1.1 cgd 2292:
2293: for (sh = shells; sh->name != NULL; sh++) {
1.66 pk 2294: if (strcmp(name, sh->name) == 0)
2295: return (sh);
1.1 cgd 2296: }
1.142 dsl 2297: return NULL;
1.1 cgd 2298: }
2299:
2300: /*-
2301: *-----------------------------------------------------------------------
2302: * Job_ParseShell --
2303: * Parse a shell specification and set up commandShell, shellPath
2304: * and shellName appropriately.
2305: *
1.72 wiz 2306: * Input:
2307: * line The shell spec
2308: *
1.1 cgd 2309: * Results:
2310: * FAILURE if the specification was incorrect.
2311: *
2312: * Side Effects:
2313: * commandShell points to a Shell structure (either predefined or
2314: * created from the shell spec), shellPath is the full path of the
2315: * shell described by commandShell, while shellName is just the
2316: * final component of shellPath.
2317: *
2318: * Notes:
2319: * A shell specification consists of a .SHELL target, with dependency
2320: * operator, followed by a series of blank-separated words. Double
2321: * quotes can be used to use blanks in words. A backslash escapes
2322: * anything (most notably a double-quote and a space) and
2323: * provides the functionality it does in C. Each word consists of
2324: * keyword and value separated by an equal sign. There should be no
2325: * unnecessary spaces in the word. The keywords are as follows:
2326: * name Name of shell.
1.66 pk 2327: * path Location of shell.
1.1 cgd 2328: * quiet Command to turn off echoing.
2329: * echo Command to turn echoing on
2330: * filter Result of turning off echoing that shouldn't be
2331: * printed.
2332: * echoFlag Flag to turn echoing on at the start
2333: * errFlag Flag to turn error checking on at the start
2334: * hasErrCtl True if shell has error checking control
1.112 rillig 2335: * newline String literal to represent a newline char
1.1 cgd 2336: * check Command to turn on error checking if hasErrCtl
2337: * is TRUE or template of command to echo a command
2338: * for which error checking is off if hasErrCtl is
2339: * FALSE.
2340: * ignore Command to turn off error checking if hasErrCtl
2341: * is TRUE or template of command to execute a
2342: * command so as to ignore any errors it returns if
2343: * hasErrCtl is FALSE.
2344: *
2345: *-----------------------------------------------------------------------
2346: */
2347: ReturnStatus
1.72 wiz 2348: Job_ParseShell(char *line)
1.1 cgd 2349: {
1.65 pk 2350: char **words;
2351: char **argv;
1.139 christos 2352: int argc;
1.65 pk 2353: char *path;
2354: Shell newShell;
2355: Boolean fullSpec = FALSE;
1.66 pk 2356: Shell *sh;
1.1 cgd 2357:
1.24 christos 2358: while (isspace((unsigned char)*line)) {
1.1 cgd 2359: line++;
2360: }
1.22 christos 2361:
2362: if (shellArgv)
1.77 christos 2363: free(UNCONST(shellArgv));
1.22 christos 2364:
1.97 christos 2365: memset(&newShell, 0, sizeof(newShell));
1.16 christos 2366:
1.1 cgd 2367: /*
2368: * Parse the specification by keyword
2369: */
1.77 christos 2370: words = brk_string(line, &argc, TRUE, &path);
1.143 christos 2371: if (words == NULL) {
2372: Error("Unterminated quoted string [%s]", line);
2373: return FAILURE;
2374: }
1.77 christos 2375: shellArgv = path;
1.65 pk 2376:
2377: for (path = NULL, argv = words; argc != 0; argc--, argv++) {
1.22 christos 2378: if (strncmp(*argv, "path=", 5) == 0) {
2379: path = &argv[0][5];
2380: } else if (strncmp(*argv, "name=", 5) == 0) {
2381: newShell.name = &argv[0][5];
2382: } else {
2383: if (strncmp(*argv, "quiet=", 6) == 0) {
2384: newShell.echoOff = &argv[0][6];
2385: } else if (strncmp(*argv, "echo=", 5) == 0) {
2386: newShell.echoOn = &argv[0][5];
2387: } else if (strncmp(*argv, "filter=", 7) == 0) {
2388: newShell.noPrint = &argv[0][7];
2389: newShell.noPLen = strlen(newShell.noPrint);
2390: } else if (strncmp(*argv, "echoFlag=", 9) == 0) {
2391: newShell.echo = &argv[0][9];
2392: } else if (strncmp(*argv, "errFlag=", 8) == 0) {
2393: newShell.exit = &argv[0][8];
2394: } else if (strncmp(*argv, "hasErrCtl=", 10) == 0) {
2395: char c = argv[0][10];
2396: newShell.hasErrCtl = !((c != 'Y') && (c != 'y') &&
1.12 christos 2397: (c != 'T') && (c != 't'));
1.112 rillig 2398: } else if (strncmp(*argv, "newline=", 8) == 0) {
2399: newShell.newline = &argv[0][8];
1.22 christos 2400: } else if (strncmp(*argv, "check=", 6) == 0) {
2401: newShell.errCheck = &argv[0][6];
2402: } else if (strncmp(*argv, "ignore=", 7) == 0) {
2403: newShell.ignErr = &argv[0][7];
1.83 jmc 2404: } else if (strncmp(*argv, "errout=", 7) == 0) {
2405: newShell.errOut = &argv[0][7];
2406: } else if (strncmp(*argv, "comment=", 8) == 0) {
2407: newShell.commentChar = argv[0][8];
1.22 christos 2408: } else {
2409: Parse_Error(PARSE_FATAL, "Unknown keyword \"%s\"",
2410: *argv);
2411: free(words);
2412: return(FAILURE);
2413: }
2414: fullSpec = TRUE;
2415: }
1.1 cgd 2416: }
2417:
1.12 christos 2418: if (path == NULL) {
1.1 cgd 2419: /*
2420: * If no path was given, the user wants one of the pre-defined shells,
2421: * yes? So we find the one s/he wants with the help of JobMatchShell
2422: * and set things up the right way. shellPath will be set up by
2423: * Job_Init.
2424: */
1.12 christos 2425: if (newShell.name == NULL) {
2426: Parse_Error(PARSE_FATAL, "Neither path nor name specified");
1.66 pk 2427: free(words);
1.12 christos 2428: return(FAILURE);
1.1 cgd 2429: } else {
1.66 pk 2430: if ((sh = JobMatchShell(newShell.name)) == NULL) {
2431: Parse_Error(PARSE_WARNING, "%s: No matching shell",
2432: newShell.name);
2433: free(words);
2434: return(FAILURE);
2435: }
2436: commandShell = sh;
1.1 cgd 2437: shellName = newShell.name;
2438: }
2439: } else {
2440: /*
1.16 christos 2441: * The user provided a path. If s/he gave nothing else (fullSpec is
1.1 cgd 2442: * FALSE), try and find a matching shell in the ones we know of.
2443: * Else we just take the specification at its word and copy it
2444: * to a new location. In either case, we need to record the
2445: * path the user gave for the shell.
2446: */
2447: shellPath = path;
1.12 christos 2448: path = strrchr(path, '/');
2449: if (path == NULL) {
1.77 christos 2450: path = UNCONST(shellPath);
1.1 cgd 2451: } else {
2452: path += 1;
2453: }
1.12 christos 2454: if (newShell.name != NULL) {
1.1 cgd 2455: shellName = newShell.name;
2456: } else {
2457: shellName = path;
2458: }
2459: if (!fullSpec) {
1.66 pk 2460: if ((sh = JobMatchShell(shellName)) == NULL) {
2461: Parse_Error(PARSE_WARNING, "%s: No matching shell",
2462: shellName);
2463: free(words);
2464: return(FAILURE);
2465: }
2466: commandShell = sh;
1.1 cgd 2467: } else {
1.140 joerg 2468: commandShell = bmake_malloc(sizeof(Shell));
1.1 cgd 2469: *commandShell = newShell;
2470: }
2471: }
2472:
2473: if (commandShell->echoOn && commandShell->echoOff) {
2474: commandShell->hasEchoCtl = TRUE;
2475: }
1.16 christos 2476:
1.1 cgd 2477: if (!commandShell->hasErrCtl) {
1.12 christos 2478: if (commandShell->errCheck == NULL) {
1.1 cgd 2479: commandShell->errCheck = "";
2480: }
1.12 christos 2481: if (commandShell->ignErr == NULL) {
1.1 cgd 2482: commandShell->ignErr = "%s\n";
2483: }
2484: }
1.16 christos 2485:
1.1 cgd 2486: /*
2487: * Do not free up the words themselves, since they might be in use by the
1.22 christos 2488: * shell specification.
1.1 cgd 2489: */
1.12 christos 2490: free(words);
1.1 cgd 2491: return SUCCESS;
2492: }
2493:
2494: /*-
2495: *-----------------------------------------------------------------------
2496: * JobInterrupt --
2497: * Handle the receipt of an interrupt.
2498: *
1.72 wiz 2499: * Input:
2500: * runINTERRUPT Non-zero if commands for the .INTERRUPT target
2501: * should be executed
2502: * signo signal received
2503: *
1.1 cgd 2504: * Results:
2505: * None
2506: *
2507: * Side Effects:
2508: * All children are killed. Another job will be started if the
2509: * .INTERRUPT target was given.
2510: *-----------------------------------------------------------------------
2511: */
2512: static void
1.72 wiz 2513: JobInterrupt(int runINTERRUPT, int signo)
1.69 pk 2514: {
2515: Job *job; /* job descriptor in that element */
2516: GNode *interrupt; /* the node describing the .INTERRUPT target */
2517: sigset_t mask;
1.114 dsl 2518: GNode *gn;
1.16 christos 2519:
1.1 cgd 2520: aborting = ABORT_INTERRUPT;
2521:
1.69 pk 2522: JobSigLock(&mask);
2523:
1.114 dsl 2524: for (job = job_table; job < job_table_end; job++) {
1.116 dsl 2525: if (job->job_state != JOB_ST_RUNNING)
1.114 dsl 2526: continue;
1.67 pk 2527:
2528: gn = job->node;
1.1 cgd 2529:
1.67 pk 2530: if ((gn->type & (OP_JOIN|OP_PHONY)) == 0 && !Targ_Precious(gn)) {
2531: char *file = (gn->path == NULL ? gn->name : gn->path);
1.12 christos 2532: if (!noExecute && eunlink(file) != -1) {
2533: Error("*** %s removed", file);
1.1 cgd 2534: }
2535: }
2536: if (job->pid) {
1.12 christos 2537: if (DEBUG(JOB)) {
1.123 dsl 2538: (void)fprintf(debug_file,
1.139 christos 2539: "JobInterrupt passing signal %d to child %d.\n",
2540: signo, job->pid);
1.12 christos 2541: }
1.116 dsl 2542: KILLPG(job->pid, signo);
1.12 christos 2543: }
2544: }
2545:
1.69 pk 2546: JobSigUnlock(&mask);
2547:
1.1 cgd 2548: if (runINTERRUPT && !touchFlag) {
1.12 christos 2549: interrupt = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
1.142 dsl 2550: if (interrupt != NULL) {
1.1 cgd 2551: ignoreErrors = FALSE;
1.91 christos 2552: JobRun(interrupt);
1.1 cgd 2553: }
2554: }
1.40 sommerfe 2555: Trace_Log(MAKEINTR, 0);
1.12 christos 2556: exit(signo);
1.1 cgd 2557: }
2558:
2559: /*
2560: *-----------------------------------------------------------------------
1.22 christos 2561: * Job_Finish --
1.1 cgd 2562: * Do final processing such as the running of the commands
1.16 christos 2563: * attached to the .END target.
1.1 cgd 2564: *
2565: * Results:
2566: * Number of errors reported.
2567: *
2568: * Side Effects:
1.34 christos 2569: * None.
1.1 cgd 2570: *-----------------------------------------------------------------------
2571: */
2572: int
1.72 wiz 2573: Job_Finish(void)
1.1 cgd 2574: {
1.142 dsl 2575: if (postCommands != NULL &&
1.141 sjg 2576: (!Lst_IsEmpty(postCommands->commands) ||
2577: !Lst_IsEmpty(postCommands->children))) {
1.1 cgd 2578: if (errors) {
1.12 christos 2579: Error("Errors reported so .END ignored");
1.1 cgd 2580: } else {
1.91 christos 2581: JobRun(postCommands);
1.1 cgd 2582: }
2583: }
2584: return(errors);
1.22 christos 2585: }
2586:
2587: /*-
2588: *-----------------------------------------------------------------------
2589: * Job_End --
2590: * Cleanup any memory used by the jobs module
2591: *
2592: * Results:
2593: * None.
2594: *
2595: * Side Effects:
2596: * Memory is freed
2597: *-----------------------------------------------------------------------
2598: */
2599: void
1.72 wiz 2600: Job_End(void)
1.22 christos 2601: {
1.30 mycroft 2602: #ifdef CLEANUP
1.22 christos 2603: if (shellArgv)
2604: free(shellArgv);
1.30 mycroft 2605: #endif
1.1 cgd 2606: }
2607:
2608: /*-
2609: *-----------------------------------------------------------------------
2610: * Job_Wait --
2611: * Waits for all running jobs to finish and returns. Sets 'aborting'
2612: * to ABORT_WAIT to prevent other jobs from starting.
2613: *
2614: * Results:
2615: * None.
2616: *
2617: * Side Effects:
2618: * Currently running jobs finish.
2619: *
2620: *-----------------------------------------------------------------------
2621: */
2622: void
1.72 wiz 2623: Job_Wait(void)
1.1 cgd 2624: {
2625: aborting = ABORT_WAIT;
1.110 dsl 2626: while (jobTokensRunning != 0) {
1.1 cgd 2627: Job_CatchOutput();
2628: }
2629: aborting = 0;
2630: }
2631:
2632: /*-
2633: *-----------------------------------------------------------------------
2634: * Job_AbortAll --
2635: * Abort all currently running jobs without handling output or anything.
2636: * This function is to be called only in the event of a major
2637: * error. Most definitely NOT to be called from JobInterrupt.
2638: *
2639: * Results:
2640: * None
2641: *
2642: * Side Effects:
2643: * All children are killed, not just the firstborn
2644: *-----------------------------------------------------------------------
2645: */
2646: void
1.72 wiz 2647: Job_AbortAll(void)
1.1 cgd 2648: {
1.63 pk 2649: Job *job; /* the job descriptor in that element */
2650: int foo;
1.16 christos 2651:
1.1 cgd 2652: aborting = ABORT_ERROR;
1.16 christos 2653:
1.110 dsl 2654: if (jobTokensRunning) {
1.114 dsl 2655: for (job = job_table; job < job_table_end; job++) {
1.116 dsl 2656: if (job->job_state != JOB_ST_RUNNING)
1.114 dsl 2657: continue;
1.1 cgd 2658: /*
2659: * kill the child process with increasingly drastic signals to make
1.16 christos 2660: * darn sure it's dead.
1.1 cgd 2661: */
1.116 dsl 2662: KILLPG(job->pid, SIGINT);
2663: KILLPG(job->pid, SIGKILL);
1.1 cgd 2664: }
2665: }
1.16 christos 2666:
1.1 cgd 2667: /*
2668: * Catch as many children as want to report in at first, then give up
2669: */
1.13 christos 2670: while (waitpid((pid_t) -1, &foo, WNOHANG) > 0)
1.5 cgd 2671: continue;
1.12 christos 2672: }
2673:
2674:
2675: /*-
2676: *-----------------------------------------------------------------------
2677: * JobRestartJobs --
2678: * Tries to restart stopped jobs if there are slots available.
1.118 dsl 2679: * Called in process context in response to a SIGCONT.
1.12 christos 2680: *
2681: * Results:
2682: * None.
2683: *
2684: * Side Effects:
1.116 dsl 2685: * Resumes jobs.
1.12 christos 2686: *
2687: *-----------------------------------------------------------------------
2688: */
2689: static void
1.72 wiz 2690: JobRestartJobs(void)
1.12 christos 2691: {
1.114 dsl 2692: Job *job;
1.69 pk 2693:
1.114 dsl 2694: for (job = job_table; job < job_table_end; job++) {
1.118 dsl 2695: if (job->job_state == JOB_ST_RUNNING &&
2696: (make_suspended || job->job_suspended)) {
1.116 dsl 2697: if (DEBUG(JOB)) {
1.139 christos 2698: (void)fprintf(debug_file, "Restarting stopped job pid %d.\n",
2699: job->pid);
1.116 dsl 2700: }
1.118 dsl 2701: if (job->job_suspended) {
2702: (void)printf("*** [%s] Continued\n", job->node->name);
2703: (void)fflush(stdout);
2704: }
2705: job->job_suspended = 0;
1.116 dsl 2706: if (KILLPG(job->pid, SIGCONT) != 0 && DEBUG(JOB)) {
1.139 christos 2707: fprintf(debug_file, "Failed to send SIGCONT to %d\n", job->pid);
1.116 dsl 2708: }
1.12 christos 2709: }
1.116 dsl 2710: if (job->job_state == JOB_ST_FINISHED)
2711: /* Job exit deferred after calling waitpid() in a signal handler */
2712: JobFinish(job, job->exit_status);
1.12 christos 2713: }
1.118 dsl 2714: make_suspended = 0;
1.1 cgd 2715: }
1.35 christos 2716:
2717: static void
1.72 wiz 2718: watchfd(Job *job)
1.35 christos 2719: {
1.36 christos 2720: if (job->inPollfd != NULL)
2721: Punt("Watching watched job");
1.35 christos 2722:
1.36 christos 2723: fds[nfds].fd = job->inPipe;
1.39 mycroft 2724: fds[nfds].events = POLLIN;
2725: jobfds[nfds] = job;
1.36 christos 2726: job->inPollfd = &fds[nfds];
1.39 mycroft 2727: nfds++;
1.35 christos 2728: }
2729:
2730: static void
1.72 wiz 2731: clearfd(Job *job)
1.35 christos 2732: {
2733: int i;
1.36 christos 2734: if (job->inPollfd == NULL)
2735: Punt("Unwatching unwatched job");
2736: i = job->inPollfd - fds;
2737: nfds--;
1.38 sommerfe 2738: /*
2739: * Move last job in table into hole made by dead job.
2740: */
1.36 christos 2741: if (nfds != i) {
1.38 sommerfe 2742: fds[i] = fds[nfds];
2743: jobfds[i] = jobfds[nfds];
2744: jobfds[i]->inPollfd = &fds[i];
1.36 christos 2745: }
2746: job->inPollfd = NULL;
1.35 christos 2747: }
2748:
2749: static int
1.72 wiz 2750: readyfd(Job *job)
1.35 christos 2751: {
1.36 christos 2752: if (job->inPollfd == NULL)
2753: Punt("Polling unwatched job");
2754: return (job->inPollfd->revents & POLLIN) != 0;
1.35 christos 2755: }
1.40 sommerfe 2756:
2757: /*-
2758: *-----------------------------------------------------------------------
2759: * JobTokenAdd --
2760: * Put a token into the job pipe so that some make process can start
2761: * another job.
2762: *
2763: * Side Effects:
2764: * Allows more build jobs to be spawned somewhere.
2765: *
2766: *-----------------------------------------------------------------------
2767: */
2768:
2769: static void
1.72 wiz 2770: JobTokenAdd(void)
1.40 sommerfe 2771: {
1.101 dsl 2772: char tok = JOB_TOKENS[aborting], tok1;
2773:
2774: /* If we are depositing an error token flush everything else */
1.122 dsl 2775: while (tok != '+' && read(tokenWaitJob.inPipe, &tok1, 1) == 1)
1.101 dsl 2776: continue;
1.40 sommerfe 2777:
2778: if (DEBUG(JOB))
1.139 christos 2779: fprintf(debug_file, "(%d) aborting %d, deposit token %c\n",
2780: getpid(), aborting, JOB_TOKENS[aborting]);
1.122 dsl 2781: write(tokenWaitJob.outPipe, &tok, 1);
1.40 sommerfe 2782: }
2783:
2784: /*-
2785: *-----------------------------------------------------------------------
2786: * Job_ServerStartTokenAdd --
2787: * Prep the job token pipe in the root make process.
2788: *
2789: *-----------------------------------------------------------------------
2790: */
2791:
1.72 wiz 2792: void
1.122 dsl 2793: Job_ServerStart(int max_tokens, int jp_0, int jp_1)
1.40 sommerfe 2794: {
1.122 dsl 2795: int i;
1.40 sommerfe 2796: char jobarg[64];
2797:
1.122 dsl 2798: if (jp_0 >= 0 && jp_1 >= 0) {
2799: /* Pipe passed in from parent */
2800: tokenWaitJob.inPipe = jp_0;
2801: tokenWaitJob.outPipe = jp_1;
2802: return;
1.100 dsl 2803: }
2804:
1.122 dsl 2805: JobCreatePipe(&tokenWaitJob, 15);
1.40 sommerfe 2806:
1.122 dsl 2807: snprintf(jobarg, sizeof(jobarg), "%d,%d",
2808: tokenWaitJob.inPipe, tokenWaitJob.outPipe);
1.40 sommerfe 2809:
2810: Var_Append(MAKEFLAGS, "-J", VAR_GLOBAL);
2811: Var_Append(MAKEFLAGS, jobarg, VAR_GLOBAL);
1.101 dsl 2812:
1.40 sommerfe 2813: /*
1.122 dsl 2814: * Preload the job pipe with one token per job, save the one
1.40 sommerfe 2815: * "extra" token for the primary job.
2816: *
1.122 dsl 2817: * XXX should clip maxJobs against PIPE_BUF -- if max_tokens is
1.40 sommerfe 2818: * larger than the write buffer size of the pipe, we will
2819: * deadlock here.
2820: */
1.122 dsl 2821: for (i = 1; i < max_tokens; i++)
1.40 sommerfe 2822: JobTokenAdd();
2823: }
2824:
2825: /*-
2826: *-----------------------------------------------------------------------
2827: * Job_TokenReturn --
2828: * Return a withdrawn token to the pool.
2829: *
2830: *-----------------------------------------------------------------------
2831: */
2832:
2833: void
1.72 wiz 2834: Job_TokenReturn(void)
1.40 sommerfe 2835: {
1.44 sommerfe 2836: jobTokensRunning--;
2837: if (jobTokensRunning < 0)
1.40 sommerfe 2838: Punt("token botch");
1.102 dsl 2839: if (jobTokensRunning || JOB_TOKENS[aborting] != '+')
1.101 dsl 2840: JobTokenAdd();
1.40 sommerfe 2841: }
2842:
2843: /*-
2844: *-----------------------------------------------------------------------
2845: * Job_TokenWithdraw --
2846: * Attempt to withdraw a token from the pool.
2847: *
2848: * Results:
2849: * Returns TRUE if a token was withdrawn, and FALSE if the pool
2850: * is currently empty.
2851: *
2852: * Side Effects:
2853: * If pool is empty, set wantToken so that we wake up
2854: * when a token is released.
2855: *
2856: *-----------------------------------------------------------------------
2857: */
2858:
2859:
2860: Boolean
1.72 wiz 2861: Job_TokenWithdraw(void)
1.40 sommerfe 2862: {
1.101 dsl 2863: char tok, tok1;
1.40 sommerfe 2864: int count;
2865:
1.120 dsl 2866: wantToken = 0;
1.101 dsl 2867: if (DEBUG(JOB))
1.139 christos 2868: fprintf(debug_file, "Job_TokenWithdraw(%d): aborting %d, running %d\n",
2869: getpid(), aborting, jobTokensRunning);
1.60 enami 2870:
1.111 dsl 2871: if (aborting || (jobTokensRunning >= maxJobs))
1.102 dsl 2872: return FALSE;
1.40 sommerfe 2873:
1.122 dsl 2874: count = read(tokenWaitJob.inPipe, &tok, 1);
1.40 sommerfe 2875: if (count == 0)
2876: Fatal("eof on job pipe!");
1.102 dsl 2877: if (count < 0 && jobTokensRunning != 0) {
1.40 sommerfe 2878: if (errno != EAGAIN) {
2879: Fatal("job pipe read: %s", strerror(errno));
2880: }
2881: if (DEBUG(JOB))
1.139 christos 2882: fprintf(debug_file, "(%d) blocked for token\n", getpid());
1.120 dsl 2883: wantToken = 1;
1.40 sommerfe 2884: return FALSE;
2885: }
1.102 dsl 2886:
2887: if (count == 1 && tok != '+') {
1.120 dsl 2888: /* make being abvorted - remove any other job tokens */
1.101 dsl 2889: if (DEBUG(JOB))
1.139 christos 2890: fprintf(debug_file, "(%d) aborted by token %c\n", getpid(), tok);
1.122 dsl 2891: while (read(tokenWaitJob.inPipe, &tok1, 1) == 1)
1.101 dsl 2892: continue;
2893: /* And put the stopper back */
1.122 dsl 2894: write(tokenWaitJob.outPipe, &tok, 1);
1.102 dsl 2895: Fatal("A failure has been detected in another branch of the parallel make");
1.101 dsl 2896: }
1.102 dsl 2897:
2898: if (count == 1 && jobTokensRunning == 0)
2899: /* We didn't want the token really */
1.122 dsl 2900: write(tokenWaitJob.outPipe, &tok, 1);
1.102 dsl 2901:
1.44 sommerfe 2902: jobTokensRunning++;
1.40 sommerfe 2903: if (DEBUG(JOB))
1.139 christos 2904: fprintf(debug_file, "(%d) withdrew token\n", getpid());
1.40 sommerfe 2905: return TRUE;
1.41 sommerfe 2906: }
2907:
1.73 gson 2908: #ifdef USE_SELECT
2909: int
2910: emul_poll(struct pollfd *fd, int nfd, int timeout)
2911: {
2912: fd_set rfds, wfds;
2913: int i, maxfd, nselect, npoll;
2914: struct timeval tv, *tvp;
2915: long usecs;
2916:
2917: FD_ZERO(&rfds);
2918: FD_ZERO(&wfds);
2919:
2920: maxfd = -1;
2921: for (i = 0; i < nfd; i++) {
2922: fd[i].revents = 0;
2923:
2924: if (fd[i].events & POLLIN)
2925: FD_SET(fd[i].fd, &rfds);
2926:
2927: if (fd[i].events & POLLOUT)
2928: FD_SET(fd[i].fd, &wfds);
2929:
2930: if (fd[i].fd > maxfd)
2931: maxfd = fd[i].fd;
2932: }
2933:
2934: if (maxfd >= FD_SETSIZE) {
2935: Punt("Ran out of fd_set slots; "
2936: "recompile with a larger FD_SETSIZE.");
2937: }
2938:
2939: if (timeout < 0) {
2940: tvp = NULL;
2941: } else {
2942: usecs = timeout * 1000;
2943: tv.tv_sec = usecs / 1000000;
2944: tv.tv_usec = usecs % 1000000;
2945: tvp = &tv;
2946: }
2947:
2948: nselect = select(maxfd + 1, &rfds, &wfds, 0, tvp);
2949:
2950: if (nselect <= 0)
2951: return nselect;
2952:
2953: npoll = 0;
2954: for (i = 0; i < nfd; i++) {
2955: if (FD_ISSET(fd[i].fd, &rfds))
2956: fd[i].revents |= POLLIN;
2957:
2958: if (FD_ISSET(fd[i].fd, &wfds))
2959: fd[i].revents |= POLLOUT;
2960:
2961: if (fd[i].revents)
2962: npoll++;
2963: }
2964:
2965: return npoll;
2966: }
2967: #endif /* USE_SELECT */
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to job.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / usr.bin / make