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