![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to job.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / make|
Return to job.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / make |
1.1 root 1: /*
2: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
3: * Copyright (c) 1988, 1989 by Adam de Boor
4: * Copyright (c) 1989 by Berkeley Softworks
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 are permitted
11: * provided that: (1) source distributions retain this entire copyright
12: * notice and comment, and (2) distributions including binaries display
13: * the following acknowledgement: ``This product includes software
14: * developed by the University of California, Berkeley and its contributors''
15: * in the documentation or other materials provided with the distribution
16: * and in all advertising materials mentioning features or use of this
17: * software. Neither the name of the University nor the names of its
18: * contributors may be used to endorse or promote products derived
19: * from this software without specific prior written permission.
20: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
21: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
22: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
23: */
24:
25: #ifndef lint
26: static char sccsid[] = "@(#)job.c 5.13 (Berkeley) 6/1/90";
27: #endif /* not lint */
28:
29: /*-
30: * job.c --
31: * handle the creation etc. of our child processes.
32: *
33: * Interface:
34: * Job_Make Start the creation of the given target.
35: *
36: * Job_CatchChildren Check for and handle the termination of any
37: * children. This must be called reasonably
38: * frequently to keep the whole make going at
39: * a decent clip, since job table entries aren't
40: * removed until their process is caught this way.
41: * Its single argument is TRUE if the function
42: * should block waiting for a child to terminate.
43: *
44: * Job_CatchOutput Print any output our children have produced.
45: * Should also be called fairly frequently to
46: * keep the user informed of what's going on.
47: * If no output is waiting, it will block for
48: * a time given by the SEL_* constants, below,
49: * or until output is ready.
50: *
51: * Job_Init Called to intialize this module. in addition,
52: * any commands attached to the .BEGIN target
53: * are executed before this function returns.
54: * Hence, the makefile must have been parsed
55: * before this function is called.
56: *
57: * Job_Full Return TRUE if the job table is filled.
58: *
59: * Job_Empty Return TRUE if the job table is completely
60: * empty.
61: *
62: * Job_ParseShell Given the line following a .SHELL target, parse
63: * the line as a shell specification. Returns
64: * FAILURE if the spec was incorrect.
65: *
66: * Job_End Perform any final processing which needs doing.
67: * This includes the execution of any commands
68: * which have been/were attached to the .END
69: * target. It should only be called when the
70: * job table is empty.
71: *
72: * Job_AbortAll Abort all currently running jobs. It doesn't
73: * handle output or do anything for the jobs,
74: * just kills them. It should only be called in
75: * an emergency, as it were.
76: *
77: * Job_CheckCommands Verify that the commands for a target are
78: * ok. Provide them if necessary and possible.
79: *
80: * Job_Touch Update a target without really updating it.
81: *
82: * Job_Wait Wait for all currently-running jobs to finish.
83: */
84:
85: #include "make.h"
86: #include <sys/signal.h>
87: #include <sys/stat.h>
88: #include <sys/file.h>
89: #include <sys/time.h>
90: #include <sys/wait.h>
91: #include <fcntl.h>
92: #include <errno.h>
93: #include <stdio.h>
94: #include <string.h>
95: #include "job.h"
96: #include "pathnames.h"
97:
98: extern int errno;
99:
100: /*
101: * error handling variables
102: */
103: int errors = 0; /* number of errors reported */
104: int aborting = 0; /* why is the make aborting? */
105: #define ABORT_ERROR 1 /* Because of an error */
106: #define ABORT_INTERRUPT 2 /* Because it was interrupted */
107: #define ABORT_WAIT 3 /* Waiting for jobs to finish */
108:
109:
110: /*
111: * post-make command processing. The node postCommands is really just the
112: * .END target but we keep it around to avoid having to search for it
113: * all the time.
114: */
115: static GNode *postCommands; /* node containing commands to execute when
116: * everything else is done */
117: static int numCommands; /* The number of commands actually printed
118: * for a target. Should this number be
119: * 0, no shell will be executed. */
120:
121:
122: /*
123: * Return values from JobStart.
124: */
125: #define JOB_RUNNING 0 /* Job is running */
126: #define JOB_ERROR 1 /* Error in starting the job */
127: #define JOB_FINISHED 2 /* The job is already finished */
128: #define JOB_STOPPED 3 /* The job is stopped */
129:
130: /*
131: * tfile is the name of a file into which all shell commands are put. It is
132: * used over by removing it before the child shell is executed. The XXXXX in
133: * the string are replaced by the pid of the make process in a 5-character
134: * field with leading zeroes.
135: */
136: static char tfile[] = TMPPAT;
137:
138:
139: /*
140: * Descriptions for various shells.
141: */
142: static Shell shells[] = {
143: /*
144: * CSH description. The csh can do echo control by playing
145: * with the setting of the 'echo' shell variable. Sadly,
146: * however, it is unable to do error control nicely.
147: */
148: {
149: "csh",
150: TRUE, "unset verbose", "set verbose", "unset verbose", 10,
151: FALSE, "echo \"%s\"\n", "csh -c \"%s || exit 0\"",
152: "v", "e",
153: },
154: /*
155: * SH description. Echo control is also possible and, under
156: * sun UNIX anyway, one can even control error checking.
157: */
158: {
159: "sh",
160: TRUE, "set -", "set -v", "set -", 5,
161: FALSE, "echo \"%s\"\n", "sh -c '%s || exit 0'\n",
162: "v", "e",
163: },
164: /*
165: * UNKNOWN.
166: */
167: {
168: (char *)0,
169: FALSE, (char *)0, (char *)0, (char *)0, 0,
170: FALSE, (char *)0, (char *)0,
171: (char *)0, (char *)0,
172: }
173: };
174: Shell *commandShell = &shells[DEFSHELL]; /* this is the shell to
175: * which we pass all
176: * commands in the Makefile.
177: * It is set by the
178: * Job_ParseShell function */
179: char *shellPath = (char *) NULL, /* full pathname of
180: * executable image */
181: *shellName; /* last component of shell */
182:
183:
184: static int maxJobs; /* The most children we can run at once */
185: static int maxLocal; /* The most local ones we can have */
186: int nJobs; /* The number of children currently running */
187: int nLocal; /* The number of local children */
188: Lst jobs; /* The structures that describe them */
189: Boolean jobFull; /* Flag to tell when the job table is full. It
190: * is set TRUE when (1) the total number of
191: * running jobs equals the maximum allowed or
192: * (2) a job can only be run locally, but
193: * nLocal equals maxLocal */
194: #ifndef RMT_WILL_WATCH
195: static fd_set outputs; /* Set of descriptors of pipes connected to
196: * the output channels of children */
197: #endif
198:
199: GNode *lastNode; /* The node for which output was most recently
200: * produced. */
201: char *targFmt; /* Format string to use to head output from a
202: * job when it's not the most-recent job heard
203: * from */
204: #define TARG_FMT "--- %s ---\n" /* Default format */
205:
206: /*
207: * When JobStart attempts to run a job remotely but can't, and isn't allowed
208: * to run the job locally, or when Job_CatchChildren detects a job that has
209: * been migrated home, the job is placed on the stoppedJobs queue to be run
210: * when the next job finishes.
211: */
212: Lst stoppedJobs; /* Lst of Job structures describing
213: * jobs that were stopped due to concurrency
214: * limits or migration home */
215:
216:
217: # if defined(USE_PGRP)
218: #define KILL(pid,sig) killpg((pid),(sig))
219: # else
220: #define KILL(pid,sig) kill((pid),(sig))
221: # endif
222:
223: static void JobRestart();
224: static int JobStart();
225: static void JobInterrupt();
226:
227: /*-
228: *-----------------------------------------------------------------------
229: * JobCondPassSig --
230: * Pass a signal to a job if the job is remote or if USE_PGRP
231: * is defined.
232: *
233: * Results:
234: * === 0
235: *
236: * Side Effects:
237: * None, except the job may bite it.
238: *
239: *-----------------------------------------------------------------------
240: */
241: static int
242: JobCondPassSig(job, signo)
243: Job *job; /* Job to biff */
244: int signo; /* Signal to send it */
245: {
246: #ifdef RMT_WANTS_SIGNALS
247: if (job->flags & JOB_REMOTE) {
248: (void)Rmt_Signal(job, signo);
249: } else {
250: KILL(job->pid, signo);
251: }
252: #else
253: /*
254: * Assume that sending the signal to job->pid will signal any remote
255: * job as well.
256: */
257: KILL(job->pid, signo);
258: #endif
259: return(0);
260: }
261:
262: /*-
263: *-----------------------------------------------------------------------
264: * JobPassSig --
265: * Pass a signal on to all remote jobs and to all local jobs if
266: * USE_PGRP is defined, then die ourselves.
267: *
268: * Results:
269: * None.
270: *
271: * Side Effects:
272: * We die by the same signal.
273: *
274: *-----------------------------------------------------------------------
275: */
276: static void
277: JobPassSig(signo)
278: int signo; /* The signal number we've received */
279: {
280: int mask;
281:
282: Lst_ForEach(jobs, JobCondPassSig, (ClientData)signo);
283:
284: /*
285: * Deal with proper cleanup based on the signal received. We only run
286: * the .INTERRUPT target if the signal was in fact an interrupt. The other
287: * three termination signals are more of a "get out *now*" command.
288: */
289: if (signo == SIGINT) {
290: JobInterrupt(TRUE);
291: } else if ((signo == SIGHUP) || (signo == SIGTERM) || (signo == SIGQUIT)) {
292: JobInterrupt(FALSE);
293: }
294:
295: /*
296: * Leave gracefully if SIGQUIT, rather than core dumping.
297: */
298: if (signo == SIGQUIT) {
299: Finish();
300: }
301:
302: /*
303: * Send ourselves the signal now we've given the message to everyone else.
304: * Note we block everything else possible while we're getting the signal.
305: * This ensures that all our jobs get continued when we wake up before
306: * we take any other signal.
307: */
308: mask = sigblock(0);
309: (void) sigsetmask(~0 & ~(1 << (signo-1)));
310: signal(signo, SIG_DFL);
311:
312: kill(getpid(), signo);
313:
314: Lst_ForEach(jobs, JobCondPassSig, (ClientData)SIGCONT);
315:
316: sigsetmask(mask);
317: signal(signo, JobPassSig);
318:
319: }
320:
321: /*-
322: *-----------------------------------------------------------------------
323: * JobCmpPid --
324: * Compare the pid of the job with the given pid and return 0 if they
325: * are equal. This function is called from Job_CatchChildren via
326: * Lst_Find to find the job descriptor of the finished job.
327: *
328: * Results:
329: * 0 if the pid's match
330: *
331: * Side Effects:
332: * None
333: *-----------------------------------------------------------------------
334: */
335: static int
336: JobCmpPid (job, pid)
337: int pid; /* process id desired */
338: Job *job; /* job to examine */
339: {
340: return (pid - job->pid);
341: }
342:
343: /*-
344: *-----------------------------------------------------------------------
345: * JobPrintCommand --
346: * Put out another command for the given job. If the command starts
347: * with an @ or a - we process it specially. In the former case,
348: * so long as the -s and -n flags weren't given to make, we stick
349: * a shell-specific echoOff command in the script. In the latter,
350: * we ignore errors for the entire job, unless the shell has error
351: * control.
352: * If the command is just "..." we take all future commands for this
353: * job to be commands to be executed once the entire graph has been
354: * made and return non-zero to signal that the end of the commands
355: * was reached. These commands are later attached to the postCommands
356: * node and executed by Job_End when all things are done.
357: * This function is called from JobStart via Lst_ForEach.
358: *
359: * Results:
360: * Always 0, unless the command was "..."
361: *
362: * Side Effects:
363: * If the command begins with a '-' and the shell has no error control,
364: * the JOB_IGNERR flag is set in the job descriptor.
365: * If the command is "..." and we're not ignoring such things,
366: * tailCmds is set to the successor node of the cmd.
367: * numCommands is incremented if the command is actually printed.
368: *-----------------------------------------------------------------------
369: */
370: static int
371: JobPrintCommand (cmd, job)
372: char *cmd; /* command string to print */
373: Job *job; /* job for which to print it */
374: {
375: Boolean noSpecials; /* true if we shouldn't worry about
376: * inserting special commands into
377: * the input stream. */
378: Boolean shutUp = FALSE; /* true if we put a no echo command
379: * into the command file */
380: Boolean errOff = FALSE; /* true if we turned error checking
381: * off before printing the command
382: * and need to turn it back on */
383: char *cmdTemplate; /* Template to use when printing the
384: * command */
385: char *cmdStart; /* Start of expanded command */
386: LstNode cmdNode; /* Node for replacing the command */
387:
388: noSpecials = (noExecute && ! (job->node->type & OP_MAKE));
389:
390: if (strcmp (cmd, "...") == 0) {
391: if ((job->flags & JOB_IGNDOTS) == 0) {
392: job->tailCmds = Lst_Succ (Lst_Member (job->node->commands,
393: (ClientData)cmd));
394: return (1);
395: }
396: return (0);
397: }
398:
399: #define DBPRINTF(fmt, arg) if (DEBUG(JOB)) printf (fmt, arg); fprintf (job->cmdFILE, fmt, arg)
400:
401: numCommands += 1;
402:
403: /*
404: * For debugging, we replace each command with the result of expanding
405: * the variables in the command.
406: */
407: cmdNode = Lst_Member (job->node->commands, (ClientData)cmd);
408: cmdStart = cmd = Var_Subst (cmd, job->node, FALSE);
409: Lst_Replace (cmdNode, (ClientData)cmdStart);
410:
411: cmdTemplate = "%s\n";
412:
413: /*
414: * Check for leading @' and -'s to control echoing and error checking.
415: */
416: while (*cmd == '@' || *cmd == '-') {
417: if (*cmd == '@') {
418: shutUp = TRUE;
419: } else {
420: errOff = TRUE;
421: }
422: cmd++;
423: }
424:
425: if (shutUp) {
426: if (! (job->flags & JOB_SILENT) && !noSpecials &&
427: commandShell->hasEchoCtl) {
428: DBPRINTF ("%s\n", commandShell->echoOff);
429: } else {
430: shutUp = FALSE;
431: }
432: }
433:
434: if (errOff) {
435: if ( ! (job->flags & JOB_IGNERR) && !noSpecials) {
436: if (commandShell->hasErrCtl) {
437: /*
438: * we don't want the error-control commands showing
439: * up either, so we turn off echoing while executing
440: * them. We could put another field in the shell
441: * structure to tell JobDoOutput to look for this
442: * string too, but why make it any more complex than
443: * it already is?
444: */
445: if (! (job->flags & JOB_SILENT) && !shutUp &&
446: commandShell->hasEchoCtl) {
447: DBPRINTF ("%s\n", commandShell->echoOff);
448: DBPRINTF ("%s\n", commandShell->ignErr);
449: DBPRINTF ("%s\n", commandShell->echoOn);
450: } else {
451: DBPRINTF ("%s\n", commandShell->ignErr);
452: }
453: } else if (commandShell->ignErr &&
454: (*commandShell->ignErr != '\0'))
455: {
456: /*
457: * The shell has no error control, so we need to be
458: * weird to get it to ignore any errors from the command.
459: * If echoing is turned on, we turn it off and use the
460: * errCheck template to echo the command. Leave echoing
461: * off so the user doesn't see the weirdness we go through
462: * to ignore errors. Set cmdTemplate to use the weirdness
463: * instead of the simple "%s\n" template.
464: */
465: if (! (job->flags & JOB_SILENT) && !shutUp &&
466: commandShell->hasEchoCtl) {
467: DBPRINTF ("%s\n", commandShell->echoOff);
468: DBPRINTF (commandShell->errCheck, cmd);
469: shutUp = TRUE;
470: }
471: cmdTemplate = commandShell->ignErr;
472: /*
473: * The error ignoration (hee hee) is already taken care
474: * of by the ignErr template, so pretend error checking
475: * is still on.
476: */
477: errOff = FALSE;
478: } else {
479: errOff = FALSE;
480: }
481: } else {
482: errOff = FALSE;
483: }
484: }
485:
486: DBPRINTF (cmdTemplate, cmd);
487:
488: if (errOff) {
489: /*
490: * If echoing is already off, there's no point in issuing the
491: * echoOff command. Otherwise we issue it and pretend it was on
492: * for the whole command...
493: */
494: if (!shutUp && !(job->flags & JOB_SILENT) && commandShell->hasEchoCtl){
495: DBPRINTF ("%s\n", commandShell->echoOff);
496: shutUp = TRUE;
497: }
498: DBPRINTF ("%s\n", commandShell->errCheck);
499: }
500: if (shutUp) {
501: DBPRINTF ("%s\n", commandShell->echoOn);
502: }
503: return (0);
504: }
505:
506: /*-
507: *-----------------------------------------------------------------------
508: * JobSaveCommand --
509: * Save a command to be executed when everything else is done.
510: * Callback function for JobFinish...
511: *
512: * Results:
513: * Always returns 0
514: *
515: * Side Effects:
516: * The command is tacked onto the end of postCommands's commands list.
517: *
518: *-----------------------------------------------------------------------
519: */
520: static int
521: JobSaveCommand (cmd, gn)
522: char *cmd;
523: GNode *gn;
524: {
525: cmd = Var_Subst (cmd, gn, FALSE);
526: (void)Lst_AtEnd (postCommands->commands, (ClientData)cmd);
527: return (0);
528: }
529:
530: /*-
531: *-----------------------------------------------------------------------
532: * JobFinish --
533: * Do final processing for the given job including updating
534: * parents and starting new jobs as available/necessary. Note
535: * that we pay no attention to the JOB_IGNERR flag here.
536: * This is because when we're called because of a noexecute flag
537: * or something, jstat.w_status is 0 and when called from
538: * Job_CatchChildren, the status is zeroed if it s/b ignored.
539: *
540: * Results:
541: * None
542: *
543: * Side Effects:
544: * Some nodes may be put on the toBeMade queue.
545: * Final commands for the job are placed on postCommands.
546: *
547: * If we got an error and are aborting (aborting == ABORT_ERROR) and
548: * the job list is now empty, we are done for the day.
549: * If we recognized an error (errors !=0), we set the aborting flag
550: * to ABORT_ERROR so no more jobs will be started.
551: *-----------------------------------------------------------------------
552: */
553: /*ARGSUSED*/
554: void
555: JobFinish (job, status)
556: Job *job; /* job to finish */
557: union wait status; /* sub-why job went away */
558: {
559: Boolean done;
560:
561: if ((WIFEXITED(status) &&
562: (((status.w_retcode != 0) && !(job->flags & JOB_IGNERR)))) ||
563: (WIFSIGNALED(status) && (status.w_termsig != SIGCONT)))
564: {
565: /*
566: * If it exited non-zero and either we're doing things our
567: * way or we're not ignoring errors, the job is finished.
568: * Similarly, if the shell died because of a signal
569: * the job is also finished. In these
570: * cases, finish out the job's output before printing the exit
571: * status...
572: */
573: if (usePipes) {
574: #ifdef RMT_WILL_WATCH
575: Rmt_Ignore(job->inPipe);
576: #else
577: FD_CLR(job->inPipe, &outputs);
578: #endif /* RMT_WILL_WATCH */
579: if (job->outPipe != job->inPipe) {
580: (void)close (job->outPipe);
581: }
582: JobDoOutput (job, TRUE);
583: (void)close (job->inPipe);
584: } else {
585: (void)close (job->outFd);
586: JobDoOutput (job, TRUE);
587: }
588:
589: if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
590: fclose(job->cmdFILE);
591: }
592: done = TRUE;
593: } else if (WIFEXITED(status) && status.w_retcode != 0) {
594: /*
595: * Deal with ignored errors in -B mode. We need to print a message
596: * telling of the ignored error as well as setting status.w_status
597: * to 0 so the next command gets run. To do this, we set done to be
598: * TRUE if in -B mode and the job exited non-zero. Note we don't
599: * want to close down any of the streams until we know we're at the
600: * end.
601: */
602: done = TRUE;
603: } else {
604: /*
605: * No need to close things down or anything.
606: */
607: done = FALSE;
608: }
609:
610: if (done ||
611: WIFSTOPPED(status) ||
612: (WIFSIGNALED(status) && (status.w_termsig == SIGCONT)) ||
613: DEBUG(JOB))
614: {
615: FILE *out;
616:
617: if (!usePipes && (job->flags & JOB_IGNERR)) {
618: /*
619: * If output is going to a file and this job is ignoring
620: * errors, arrange to have the exit status sent to the
621: * output file as well.
622: */
623: out = fdopen (job->outFd, "w");
624: } else {
625: out = stdout;
626: }
627:
628: if (WIFEXITED(status)) {
629: if (status.w_retcode != 0) {
630: if (usePipes && job->node != lastNode) {
631: fprintf (out, targFmt, job->node->name);
632: lastNode = job->node;
633: }
634: fprintf (out, "*** Error code %d%s\n", status.w_retcode,
635: (job->flags & JOB_IGNERR) ? " (ignored)" : "");
636:
637: if (job->flags & JOB_IGNERR) {
638: status.w_status = 0;
639: }
640: } else if (DEBUG(JOB)) {
641: if (usePipes && job->node != lastNode) {
642: fprintf (out, targFmt, job->node->name);
643: lastNode = job->node;
644: }
645: fprintf (out, "*** Completed successfully\n");
646: }
647: } else if (WIFSTOPPED(status)) {
648: if (usePipes && job->node != lastNode) {
649: fprintf (out, targFmt, job->node->name);
650: lastNode = job->node;
651: }
652: if (! (job->flags & JOB_REMIGRATE)) {
653: fprintf (out, "*** Stopped -- signal %d\n", status.w_stopsig);
654: }
655: job->flags |= JOB_RESUME;
656: (void)Lst_AtEnd(stoppedJobs, (ClientData)job);
657: fflush(out);
658: return;
659: } else if (status.w_termsig == SIGCONT) {
660: /*
661: * If the beastie has continued, shift the Job from the stopped
662: * list to the running one (or re-stop it if concurrency is
663: * exceeded) and go and get another child.
664: */
665: if (job->flags & (JOB_RESUME|JOB_REMIGRATE|JOB_RESTART)) {
666: if (usePipes && job->node != lastNode) {
667: fprintf (out, targFmt, job->node->name);
668: lastNode = job->node;
669: }
670: fprintf (out, "*** Continued\n");
671: }
672: if (! (job->flags & JOB_CONTINUING)) {
673: JobRestart(job);
674: } else {
675: Lst_AtEnd(jobs, (ClientData)job);
676: nJobs += 1;
677: if (! (job->flags & JOB_REMOTE)) {
678: nLocal += 1;
679: }
680: if (nJobs == maxJobs) {
681: jobFull = TRUE;
682: if (DEBUG(JOB)) {
683: printf("Job queue is full.\n");
684: }
685: }
686: }
687: fflush(out);
688: return;
689: } else {
690: if (usePipes && job->node != lastNode) {
691: fprintf (out, targFmt, job->node->name);
692: lastNode = job->node;
693: }
694: fprintf (out, "*** Signal %d\n", status.w_termsig);
695: }
696:
697: fflush (out);
698: }
699:
700: /*
701: * Now handle the -B-mode stuff. If the beast still isn't finished,
702: * try and restart the job on the next command. If JobStart says it's
703: * ok, it's ok. If there's an error, this puppy is done.
704: */
705: if ((status.w_status == 0) &&
706: !Lst_IsAtEnd (job->node->commands))
707: {
708: switch (JobStart (job->node,
709: job->flags & JOB_IGNDOTS,
710: job))
711: {
712: case JOB_RUNNING:
713: done = FALSE;
714: break;
715: case JOB_ERROR:
716: done = TRUE;
717: status.w_retcode = 1;
718: break;
719: case JOB_FINISHED:
720: /*
721: * If we got back a JOB_FINISHED code, JobStart has already
722: * called Make_Update and freed the job descriptor. We set
723: * done to false here to avoid fake cycles and double frees.
724: * JobStart needs to do the update so we can proceed up the
725: * graph when given the -n flag..
726: */
727: done = FALSE;
728: break;
729: }
730: } else {
731: done = TRUE;
732: }
733:
734:
735: if (done &&
736: (aborting != ABORT_ERROR) &&
737: (aborting != ABORT_INTERRUPT) &&
738: (status.w_status == 0))
739: {
740: /*
741: * As long as we aren't aborting and the job didn't return a non-zero
742: * status that we shouldn't ignore, we call Make_Update to update
743: * the parents. In addition, any saved commands for the node are placed
744: * on the .END target.
745: */
746: if (job->tailCmds != NILLNODE) {
747: Lst_ForEachFrom (job->node->commands, job->tailCmds,
748: JobSaveCommand,
749: (ClientData)job->node);
750: }
751: job->node->made = MADE;
752: Make_Update (job->node);
753: free((Address)job);
754: } else if (status.w_status) {
755: errors += 1;
756: free((Address)job);
757: }
758:
759: while (!errors && !jobFull && !Lst_IsEmpty(stoppedJobs)) {
760: JobRestart((Job *)Lst_DeQueue(stoppedJobs));
761: }
762:
763: /*
764: * Set aborting if any error.
765: */
766: if (errors && !keepgoing && (aborting != ABORT_INTERRUPT)) {
767: /*
768: * If we found any errors in this batch of children and the -k flag
769: * wasn't given, we set the aborting flag so no more jobs get
770: * started.
771: */
772: aborting = ABORT_ERROR;
773: }
774:
775: if ((aborting == ABORT_ERROR) && Job_Empty()) {
776: /*
777: * If we are aborting and the job table is now empty, we finish.
778: */
779: (void) unlink (tfile);
780: Finish (errors);
781: }
782: }
783:
784: /*-
785: *-----------------------------------------------------------------------
786: * Job_Touch --
787: * Touch the given target. Called by JobStart when the -t flag was
788: * given
789: *
790: * Results:
791: * None
792: *
793: * Side Effects:
794: * The data modification of the file is changed. In addition, if the
795: * file did not exist, it is created.
796: *-----------------------------------------------------------------------
797: */
798: void
799: Job_Touch (gn, silent)
800: GNode *gn; /* the node of the file to touch */
801: Boolean silent; /* TRUE if should not print messages */
802: {
803: int streamID; /* ID of stream opened to do the touch */
804: struct timeval times[2]; /* Times for utimes() call */
805: struct stat attr; /* Attributes of the file */
806:
807: if (gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_OPTIONAL)) {
808: /*
809: * .JOIN, .USE, .ZEROTIME and .OPTIONAL targets are "virtual" targets
810: * and, as such, shouldn't really be created.
811: */
812: return;
813: }
814:
815: if (!silent) {
816: printf ("touch %s\n", gn->name);
817: }
818:
819: if (noExecute) {
820: return;
821: }
822:
823: if (gn->type & OP_ARCHV) {
824: Arch_Touch (gn);
825: } else if (gn->type & OP_LIB) {
826: Arch_TouchLib (gn);
827: } else {
828: char *file = gn->path ? gn->path : gn->name;
829:
830: times[0].tv_sec = times[1].tv_sec = now;
831: times[0].tv_usec = times[1].tv_usec = 0;
832: if (utimes(file, times) < 0){
833: streamID = open (file, O_RDWR | O_CREAT, 0666);
834:
835: if (streamID >= 0) {
836: char c;
837:
838: /*
839: * Read and write a byte to the file to change the
840: * modification time, then close the file.
841: */
842: if (read(streamID, &c, 1) == 1) {
843: lseek(streamID, 0L, L_SET);
844: write(streamID, &c, 1);
845: }
846:
847: (void)close (streamID);
848: } else
849: printf("*** couldn't touch %s: %s", file, strerror(errno));
850: }
851: }
852: }
853:
854: /*-
855: *-----------------------------------------------------------------------
856: * Job_CheckCommands --
857: * Make sure the given node has all the commands it needs.
858: *
859: * Results:
860: * TRUE if the commands list is/was ok.
861: *
862: * Side Effects:
863: * The node will have commands from the .DEFAULT rule added to it
864: * if it needs them.
865: *-----------------------------------------------------------------------
866: */
867: Boolean
868: Job_CheckCommands (gn, abortProc)
869: GNode *gn; /* The target whose commands need
870: * verifying */
871: void (*abortProc)(); /* Function to abort with message */
872: {
873: if (OP_NOP(gn->type) && Lst_IsEmpty (gn->commands) &&
874: (gn->type & OP_LIB) == 0) {
875: /*
876: * No commands. Look for .DEFAULT rule from which we might infer
877: * commands
878: */
879: if ((DEFAULT != NILGNODE) && !Lst_IsEmpty(DEFAULT->commands)) {
880: /*
881: * Make only looks for a .DEFAULT if the node was never the
882: * target of an operator, so that's what we do too. If
883: * a .DEFAULT was given, we substitute its commands for gn's
884: * commands and set the IMPSRC variable to be the target's name
885: * The DEFAULT node acts like a transformation rule, in that
886: * gn also inherits any attributes or sources attached to
887: * .DEFAULT itself.
888: */
889: Make_HandleUse(DEFAULT, gn);
890: Var_Set (IMPSRC, Var_Value (TARGET, gn), gn);
891: } else if (Dir_MTime (gn) == 0) {
892: /*
893: * The node wasn't the target of an operator we have no .DEFAULT
894: * rule to go on and the target doesn't already exist. There's
895: * nothing more we can do for this branch. If the -k flag wasn't
896: * given, we stop in our tracks, otherwise we just don't update
897: * this node's parents so they never get examined.
898: */
899: if (gn->type & OP_OPTIONAL) {
900: printf ("Can't figure out how to make %s (ignored)\n",
901: gn->name);
902: } else if (keepgoing) {
903: printf ("Can't figure out how to make %s (continuing)\n",
904: gn->name);
905: return (FALSE);
906: } else {
907: (*abortProc) ("Can't figure out how to make %s. Stop",
908: gn->name);
909: return(FALSE);
910: }
911: }
912: }
913: return (TRUE);
914: }
915: #ifdef RMT_WILL_WATCH
916: /*-
917: *-----------------------------------------------------------------------
918: * JobLocalInput --
919: * Handle a pipe becoming readable. Callback function for Rmt_Watch
920: *
921: * Results:
922: * None
923: *
924: * Side Effects:
925: * JobDoOutput is called.
926: *
927: *-----------------------------------------------------------------------
928: */
929: /*ARGSUSED*/
930: static void
931: JobLocalInput(stream, job)
932: int stream; /* Stream that's ready (ignored) */
933: Job *job; /* Job to which the stream belongs */
934: {
935: JobDoOutput(job, FALSE);
936: }
937: #endif /* RMT_WILL_WATCH */
938:
939: /*-
940: *-----------------------------------------------------------------------
941: * JobExec --
942: * Execute the shell for the given job. Called from JobStart and
943: * JobRestart.
944: *
945: * Results:
946: * None.
947: *
948: * Side Effects:
949: * A shell is executed, outputs is altered and the Job structure added
950: * to the job table.
951: *
952: *-----------------------------------------------------------------------
953: */
954: static void
955: JobExec(job, argv)
956: Job *job; /* Job to execute */
957: char **argv;
958: {
959: int cpid; /* ID of new child */
960:
961: if (DEBUG(JOB)) {
962: int i;
963:
964: printf("Running %s %sly\n", job->node->name,
965: job->flags&JOB_REMOTE?"remote":"local");
966: printf("\tCommand: ");
967: for (i = 0; argv[i] != (char *)NULL; i++) {
968: printf("%s ", argv[i]);
969: }
970: printf("\n");
971: }
972:
973: /*
974: * Some jobs produce no output and it's disconcerting to have
975: * no feedback of their running (since they produce no output, the
976: * banner with their name in it never appears). This is an attempt to
977: * provide that feedback, even if nothing follows it.
978: */
979: if ((lastNode != job->node) && (job->flags & JOB_FIRST) &&
980: !(job->flags & JOB_SILENT))
981: {
982: printf(targFmt, job->node->name);
983: lastNode = job->node;
984: }
985:
986: #ifdef RMT_NO_EXEC
987: if (job->flags & JOB_REMOTE) {
988: goto jobExecFinish;
989: }
990: #endif /* RMT_NO_EXEC */
991:
992: if ((cpid = vfork()) == -1) {
993: Punt ("Cannot fork");
994: } else if (cpid == 0) {
995:
996: /*
997: * Must duplicate the input stream down to the child's input and
998: * reset it to the beginning (again). Since the stream was marked
999: * close-on-exec, we must clear that bit in the new input.
1000: */
1001: (void) dup2(fileno(job->cmdFILE), 0);
1002: fcntl(0, F_SETFD, 0);
1003: lseek(0, 0, L_SET);
1004:
1005: if (usePipes) {
1006: /*
1007: * Set up the child's output to be routed through the pipe
1008: * we've created for it.
1009: */
1010: (void) dup2 (job->outPipe, 1);
1011: } else {
1012: /*
1013: * We're capturing output in a file, so we duplicate the
1014: * descriptor to the temporary file into the standard
1015: * output.
1016: */
1017: (void) dup2 (job->outFd, 1);
1018: }
1019: /*
1020: * The output channels are marked close on exec. This bit was
1021: * duplicated by the dup2 (on some systems), so we have to clear
1022: * it before routing the shell's error output to the same place as
1023: * its standard output.
1024: */
1025: fcntl(1, F_SETFD, 0);
1026: (void) dup2 (1, 2);
1027:
1028: #ifdef USE_PGRP
1029: /*
1030: * We want to switch the child into a different process family so
1031: * we can kill it and all its descendants in one fell swoop,
1032: * by killing its process family, but not commit suicide.
1033: */
1034:
1035: (void) setpgrp(0, getpid());
1036: #endif USE_PGRP
1037:
1038: (void) execv (shellPath, argv);
1039: (void) write (2, "Could not execute shell\n",
1040: sizeof ("Could not execute shell"));
1041: _exit (1);
1042: } else {
1043: job->pid = cpid;
1044:
1045: if (usePipes && (job->flags & JOB_FIRST) ) {
1046: /*
1047: * The first time a job is run for a node, we set the current
1048: * position in the buffer to the beginning and mark another
1049: * stream to watch in the outputs mask
1050: */
1051: job->curPos = 0;
1052:
1053: #ifdef RMT_WILL_WATCH
1054: Rmt_Watch(job->inPipe, JobLocalInput, job);
1055: #else
1056: FD_SET(job->inPipe, &outputs);
1057: #endif /* RMT_WILL_WATCH */
1058: }
1059:
1060: if (job->flags & JOB_REMOTE) {
1061: job->rmtID = (char *)0;
1062: } else {
1063: nLocal += 1;
1064: /*
1065: * XXX: Used to not happen if CUSTOMS. Why?
1066: */
1067: if (job->cmdFILE != stdout) {
1068: fclose(job->cmdFILE);
1069: job->cmdFILE = NULL;
1070: }
1071: }
1072: }
1073:
1074: jobExecFinish:
1075: /*
1076: * Now the job is actually running, add it to the table.
1077: */
1078: nJobs += 1;
1079: (void)Lst_AtEnd (jobs, (ClientData)job);
1080: if (nJobs == maxJobs) {
1081: jobFull = TRUE;
1082: }
1083: }
1084:
1085: /*-
1086: *-----------------------------------------------------------------------
1087: * JobMakeArgv --
1088: * Create the argv needed to execute the shell for a given job.
1089: *
1090: *
1091: * Results:
1092: *
1093: * Side Effects:
1094: *
1095: *-----------------------------------------------------------------------
1096: */
1097: static void
1098: JobMakeArgv(job, argv)
1099: Job *job;
1100: char **argv;
1101: {
1102: int argc;
1103: static char args[10]; /* For merged arguments */
1104:
1105: argv[0] = shellName;
1106: argc = 1;
1107:
1108: if ((commandShell->exit && (*commandShell->exit != '-')) ||
1109: (commandShell->echo && (*commandShell->echo != '-')))
1110: {
1111: /*
1112: * At least one of the flags doesn't have a minus before it, so
1113: * merge them together. Have to do this because the *(&(@*#*&#$#
1114: * Bourne shell thinks its second argument is a file to source.
1115: * Grrrr. Note the ten-character limitation on the combined arguments.
1116: */
1117: (void)sprintf(args, "-%s%s",
1118: ((job->flags & JOB_IGNERR) ? "" :
1119: (commandShell->exit ? commandShell->exit : "")),
1120: ((job->flags & JOB_SILENT) ? "" :
1121: (commandShell->echo ? commandShell->echo : "")));
1122:
1123: if (args[1]) {
1124: argv[argc] = args;
1125: argc++;
1126: }
1127: } else {
1128: if (!(job->flags & JOB_IGNERR) && commandShell->exit) {
1129: argv[argc] = commandShell->exit;
1130: argc++;
1131: }
1132: if (!(job->flags & JOB_SILENT) && commandShell->echo) {
1133: argv[argc] = commandShell->echo;
1134: argc++;
1135: }
1136: }
1137: argv[argc] = (char *)NULL;
1138: }
1139:
1140: /*-
1141: *-----------------------------------------------------------------------
1142: * JobRestart --
1143: * Restart a job that stopped for some reason.
1144: *
1145: * Results:
1146: * None.
1147: *
1148: * Side Effects:
1149: * jobFull will be set if the job couldn't be run.
1150: *
1151: *-----------------------------------------------------------------------
1152: */
1153: static void
1154: JobRestart(job)
1155: Job *job; /* Job to restart */
1156: {
1157: if (job->flags & JOB_REMIGRATE) {
1158: if (DEBUG(JOB)) {
1159: printf("Remigrating %x\n", job->pid);
1160: }
1161: if (nLocal != maxLocal) {
1162: /*
1163: * Job cannot be remigrated, but there's room on the local
1164: * machine, so resume the job and note that another
1165: * local job has started.
1166: */
1167: if (DEBUG(JOB)) {
1168: printf("resuming on local machine\n");
1169: }
1170: KILL(job->pid, SIGCONT);
1171: nLocal +=1;
1172: job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
1173: } else {
1174: /*
1175: * Job cannot be restarted. Mark the table as full and
1176: * place the job back on the list of stopped jobs.
1177: */
1178: if (DEBUG(JOB)) {
1179: printf("holding\n");
1180: }
1181: (void)Lst_AtFront(stoppedJobs, (ClientData)job);
1182: jobFull = TRUE;
1183: if (DEBUG(JOB)) {
1184: printf("Job queue is full.\n");
1185: }
1186: return;
1187: }
1188:
1189: (void)Lst_AtEnd(jobs, (ClientData)job);
1190: nJobs += 1;
1191: if (nJobs == maxJobs) {
1192: jobFull = TRUE;
1193: if (DEBUG(JOB)) {
1194: printf("Job queue is full.\n");
1195: }
1196: }
1197: } else if (job->flags & JOB_RESTART) {
1198: /*
1199: * Set up the control arguments to the shell. This is based on the
1200: * flags set earlier for this job. If the JOB_IGNERR flag is clear,
1201: * the 'exit' flag of the commandShell is used to cause it to exit
1202: * upon receiving an error. If the JOB_SILENT flag is clear, the
1203: * 'echo' flag of the commandShell is used to get it to start echoing
1204: * as soon as it starts processing commands.
1205: */
1206: char *argv[4];
1207:
1208: JobMakeArgv(job, argv);
1209:
1210: if (DEBUG(JOB)) {
1211: printf("Restarting %s...", job->node->name);
1212: }
1213: if (((nLocal >= maxLocal) && ! (job->flags & JOB_SPECIAL))) {
1214: /*
1215: * Can't be exported and not allowed to run locally -- put it
1216: * back on the hold queue and mark the table full
1217: */
1218: if (DEBUG(JOB)) {
1219: printf("holding\n");
1220: }
1221: (void)Lst_AtFront(stoppedJobs, (ClientData)job);
1222: jobFull = TRUE;
1223: if (DEBUG(JOB)) {
1224: printf("Job queue is full.\n");
1225: }
1226: return;
1227: } else {
1228: /*
1229: * Job may be run locally.
1230: */
1231: if (DEBUG(JOB)) {
1232: printf("running locally\n");
1233: }
1234: job->flags &= ~JOB_REMOTE;
1235: }
1236: JobExec(job, argv);
1237: } else {
1238: /*
1239: * The job has stopped and needs to be restarted. Why it stopped,
1240: * we don't know...
1241: */
1242: if (DEBUG(JOB)) {
1243: printf("Resuming %s...", job->node->name);
1244: }
1245: if (((job->flags & JOB_REMOTE) ||
1246: (nLocal < maxLocal) ||
1247: (((job->flags & JOB_SPECIAL)) &&
1248: (maxLocal == 0))) &&
1249: (nJobs != maxJobs))
1250: {
1251: /*
1252: * If the job is remote, it's ok to resume it as long as the
1253: * maximum concurrency won't be exceeded. If it's local and
1254: * we haven't reached the local concurrency limit already (or the
1255: * job must be run locally and maxLocal is 0), it's also ok to
1256: * resume it.
1257: */
1258: Boolean error;
1259: extern int errno;
1260: union wait status;
1261:
1262: #ifdef RMT_WANTS_SIGNALS
1263: if (job->flags & JOB_REMOTE) {
1264: error = !Rmt_Signal(job, SIGCONT);
1265: } else
1266: #endif /* RMT_WANTS_SIGNALS */
1267: error = (KILL(job->pid, SIGCONT) != 0);
1268:
1269: if (!error) {
1270: /*
1271: * Make sure the user knows we've continued the beast and
1272: * actually put the thing in the job table.
1273: */
1274: job->flags |= JOB_CONTINUING;
1275: status.w_termsig = SIGCONT;
1276: JobFinish(job, status);
1277:
1278: job->flags &= ~(JOB_RESUME|JOB_CONTINUING);
1279: if (DEBUG(JOB)) {
1280: printf("done\n");
1281: }
1282: } else {
1283: Error("couldn't resume %s: %s",
1284: job->node->name, strerror(errno));
1285: status.w_status = 0;
1286: status.w_retcode = 1;
1287: JobFinish(job, status);
1288: }
1289: } else {
1290: /*
1291: * Job cannot be restarted. Mark the table as full and
1292: * place the job back on the list of stopped jobs.
1293: */
1294: if (DEBUG(JOB)) {
1295: printf("table full\n");
1296: }
1297: (void)Lst_AtFront(stoppedJobs, (ClientData)job);
1298: jobFull = TRUE;
1299: if (DEBUG(JOB)) {
1300: printf("Job queue is full.\n");
1301: }
1302: }
1303: }
1304: }
1305:
1306: /*-
1307: *-----------------------------------------------------------------------
1308: * JobStart --
1309: * Start a target-creation process going for the target described
1310: * by the graph node gn.
1311: *
1312: * Results:
1313: * JOB_ERROR if there was an error in the commands, JOB_FINISHED
1314: * if there isn't actually anything left to do for the job and
1315: * JOB_RUNNING if the job has been started.
1316: *
1317: * Side Effects:
1318: * A new Job node is created and added to the list of running
1319: * jobs. PMake is forked and a child shell created.
1320: *-----------------------------------------------------------------------
1321: */
1322: static int
1323: JobStart (gn, flags, previous)
1324: GNode *gn; /* target to create */
1325: short flags; /* flags for the job to override normal ones.
1326: * e.g. JOB_SPECIAL or JOB_IGNDOTS */
1327: Job *previous; /* The previous Job structure for this node,
1328: * if any. */
1329: {
1330: register Job *job; /* new job descriptor */
1331: char *argv[4]; /* Argument vector to shell */
1332: char args[5]; /* arguments to shell */
1333: static int jobno = 0; /* job number of catching output in a file */
1334: Boolean cmdsOK; /* true if the nodes commands were all right */
1335: Boolean local; /* Set true if the job was run locally */
1336: Boolean noExec; /* Set true if we decide not to run the job */
1337:
1338: if (previous != (Job *)NULL) {
1339: previous->flags &= ~ (JOB_FIRST|JOB_IGNERR|JOB_SILENT|JOB_REMOTE);
1340: job = previous;
1341: } else {
1342: job = (Job *) emalloc (sizeof (Job));
1343: if (job == (Job *)NULL) {
1344: Punt("JobStart out of memory");
1345: }
1346: flags |= JOB_FIRST;
1347: }
1348:
1349: job->node = gn;
1350: job->tailCmds = NILLNODE;
1351:
1352: /*
1353: * Set the initial value of the flags for this job based on the global
1354: * ones and the node's attributes... Any flags supplied by the caller
1355: * are also added to the field.
1356: */
1357: job->flags = 0;
1358: if (Targ_Ignore (gn)) {
1359: job->flags |= JOB_IGNERR;
1360: }
1361: if (Targ_Silent (gn)) {
1362: job->flags |= JOB_SILENT;
1363: }
1364: job->flags |= flags;
1365:
1366: /*
1367: * Check the commands now so any attributes from .DEFAULT have a chance
1368: * to migrate to the node
1369: */
1370: if (job->flags & JOB_FIRST) {
1371: cmdsOK = Job_CheckCommands(gn, Error);
1372: } else {
1373: cmdsOK = TRUE;
1374: }
1375:
1376: /*
1377: * If the -n flag wasn't given, we open up OUR (not the child's)
1378: * temporary file to stuff commands in it. The thing is rd/wr so we don't
1379: * need to reopen it to feed it to the shell. If the -n flag *was* given,
1380: * we just set the file to be stdout. Cute, huh?
1381: */
1382: if ((gn->type & OP_MAKE) || (!noExecute && !touchFlag)) {
1383: /*
1384: * We're serious here, but if the commands were bogus, we're
1385: * also dead...
1386: */
1387: if (!cmdsOK) {
1388: DieHorribly();
1389: }
1390:
1391: job->cmdFILE = fopen (tfile, "w+");
1392: if (job->cmdFILE == (FILE *) NULL) {
1393: Punt ("Could not open %s", tfile);
1394: }
1395: fcntl(fileno(job->cmdFILE), F_SETFD, 1);
1396: /*
1397: * Send the commands to the command file, flush all its buffers then
1398: * rewind and remove the thing.
1399: */
1400: noExec = FALSE;
1401:
1402: /*
1403: * used to be backwards; replace when start doing multiple commands
1404: * per shell.
1405: */
1406: if (1) {
1407: /*
1408: * Be compatible: If this is the first time for this node,
1409: * verify its commands are ok and open the commands list for
1410: * sequential access by later invocations of JobStart.
1411: * Once that is done, we take the next command off the list
1412: * and print it to the command file. If the command was an
1413: * ellipsis, note that there's nothing more to execute.
1414: */
1415: if ((job->flags&JOB_FIRST) && (Lst_Open(gn->commands) != SUCCESS)){
1416: cmdsOK = FALSE;
1417: } else {
1418: LstNode ln = Lst_Next (gn->commands);
1419:
1420: if ((ln == NILLNODE) ||
1421: JobPrintCommand ((char *)Lst_Datum (ln), job))
1422: {
1423: noExec = TRUE;
1424: Lst_Close (gn->commands);
1425: }
1426: if (noExec && !(job->flags & JOB_FIRST)) {
1427: /*
1428: * If we're not going to execute anything, the job
1429: * is done and we need to close down the various
1430: * file descriptors we've opened for output, then
1431: * call JobDoOutput to catch the final characters or
1432: * send the file to the screen... Note that the i/o streams
1433: * are only open if this isn't the first job.
1434: * Note also that this could not be done in
1435: * Job_CatchChildren b/c it wasn't clear if there were
1436: * more commands to execute or not...
1437: */
1438: if (usePipes) {
1439: #ifdef RMT_WILL_WATCH
1440: Rmt_Ignore(job->inPipe);
1441: #else
1442: FD_CLR(job->inPipe, &outputs);
1443: #endif
1444: if (job->outPipe != job->inPipe) {
1445: (void)close (job->outPipe);
1446: }
1447: JobDoOutput (job, TRUE);
1448: (void)close (job->inPipe);
1449: } else {
1450: (void)close (job->outFd);
1451: JobDoOutput (job, TRUE);
1452: }
1453: }
1454: }
1455: } else {
1456: /*
1457: * We can do all the commands at once. hooray for sanity
1458: */
1459: numCommands = 0;
1460: Lst_ForEach (gn->commands, JobPrintCommand, (ClientData)job);
1461:
1462: /*
1463: * If we didn't print out any commands to the shell script,
1464: * there's not much point in executing the shell, is there?
1465: */
1466: if (numCommands == 0) {
1467: noExec = TRUE;
1468: }
1469: }
1470: } else if (noExecute) {
1471: /*
1472: * Not executing anything -- just print all the commands to stdout
1473: * in one fell swoop. This will still set up job->tailCmds correctly.
1474: */
1475: if (lastNode != gn) {
1476: printf (targFmt, gn->name);
1477: lastNode = gn;
1478: }
1479: job->cmdFILE = stdout;
1480: /*
1481: * Only print the commands if they're ok, but don't die if they're
1482: * not -- just let the user know they're bad and keep going. It
1483: * doesn't do any harm in this case and may do some good.
1484: */
1485: if (cmdsOK) {
1486: Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
1487: }
1488: /*
1489: * Don't execute the shell, thank you.
1490: */
1491: noExec = TRUE;
1492: } else {
1493: /*
1494: * Just touch the target and note that no shell should be executed.
1495: * Set cmdFILE to stdout to make life easier. Check the commands, too,
1496: * but don't die if they're no good -- it does no harm to keep working
1497: * up the graph.
1498: */
1499: job->cmdFILE = stdout;
1500: Job_Touch (gn, job->flags&JOB_SILENT);
1501: noExec = TRUE;
1502: }
1503:
1504: /*
1505: * If we're not supposed to execute a shell, don't.
1506: */
1507: if (noExec) {
1508: /*
1509: * Unlink and close the command file if we opened one
1510: */
1511: if (job->cmdFILE != stdout) {
1512: (void) unlink (tfile);
1513: fclose(job->cmdFILE);
1514: } else {
1515: fflush (stdout);
1516: }
1517:
1518: /*
1519: * We only want to work our way up the graph if we aren't here because
1520: * the commands for the job were no good.
1521: */
1522: if (cmdsOK) {
1523: if (aborting == 0) {
1524: if (job->tailCmds != NILLNODE) {
1525: Lst_ForEachFrom(job->node->commands, job->tailCmds,
1526: JobSaveCommand,
1527: (ClientData)job->node);
1528: }
1529: Make_Update(job->node);
1530: }
1531: free((Address)job);
1532: return(JOB_FINISHED);
1533: } else {
1534: free((Address)job);
1535: return(JOB_ERROR);
1536: }
1537: } else {
1538: fflush (job->cmdFILE);
1539: (void) unlink (tfile);
1540: }
1541:
1542: /*
1543: * Set up the control arguments to the shell. This is based on the flags
1544: * set earlier for this job.
1545: */
1546: JobMakeArgv(job, argv);
1547:
1548: /*
1549: * If we're using pipes to catch output, create the pipe by which we'll
1550: * get the shell's output. If we're using files, print out that we're
1551: * starting a job and then set up its temporary-file name. This is just
1552: * tfile with two extra digits tacked on -- jobno.
1553: */
1554: if (job->flags & JOB_FIRST) {
1555: if (usePipes) {
1556: int fd[2];
1557: (void) pipe(fd);
1558: job->inPipe = fd[0];
1559: job->outPipe = fd[1];
1560: (void)fcntl (job->inPipe, F_SETFD, 1);
1561: (void)fcntl (job->outPipe, F_SETFD, 1);
1562: } else {
1563: printf ("Remaking `%s'\n", gn->name);
1564: fflush (stdout);
1565: sprintf (job->outFile, "%s%02d", tfile, jobno);
1566: jobno = (jobno + 1) % 100;
1567: job->outFd = open(job->outFile,O_WRONLY|O_CREAT|O_APPEND,0600);
1568: (void)fcntl (job->outFd, F_SETFD, 1);
1569: }
1570: }
1571:
1572: local = TRUE;
1573:
1574: if (local && (((nLocal >= maxLocal) &&
1575: !(job->flags & JOB_SPECIAL) &&
1576: (maxLocal != 0))))
1577: {
1578: /*
1579: * The job can only be run locally, but we've hit the limit of
1580: * local concurrency, so put the job on hold until some other job
1581: * finishes. Note that the special jobs (.BEGIN, .INTERRUPT and .END)
1582: * may be run locally even when the local limit has been reached
1583: * (e.g. when maxLocal == 0), though they will be exported if at
1584: * all possible.
1585: */
1586: jobFull = TRUE;
1587:
1588: if (DEBUG(JOB)) {
1589: printf("Can only run job locally.\n");
1590: }
1591: job->flags |= JOB_RESTART;
1592: (void)Lst_AtEnd(stoppedJobs, (ClientData)job);
1593: } else {
1594: if ((nLocal >= maxLocal) && local) {
1595: /*
1596: * If we're running this job locally as a special case (see above),
1597: * at least say the table is full.
1598: */
1599: jobFull = TRUE;
1600: if (DEBUG(JOB)) {
1601: printf("Local job queue is full.\n");
1602: }
1603: }
1604: JobExec(job, argv);
1605: }
1606: return(JOB_RUNNING);
1607: }
1608:
1609: /*-
1610: *-----------------------------------------------------------------------
1611: * JobDoOutput --
1612: * This function is called at different times depending on
1613: * whether the user has specified that output is to be collected
1614: * via pipes or temporary files. In the former case, we are called
1615: * whenever there is something to read on the pipe. We collect more
1616: * output from the given job and store it in the job's outBuf. If
1617: * this makes up a line, we print it tagged by the job's identifier,
1618: * as necessary.
1619: * If output has been collected in a temporary file, we open the
1620: * file and read it line by line, transfering it to our own
1621: * output channel until the file is empty. At which point we
1622: * remove the temporary file.
1623: * In both cases, however, we keep our figurative eye out for the
1624: * 'noPrint' line for the shell from which the output came. If
1625: * we recognize a line, we don't print it. If the command is not
1626: * alone on the line (the character after it is not \0 or \n), we
1627: * do print whatever follows it.
1628: *
1629: * Results:
1630: * None
1631: *
1632: * Side Effects:
1633: * curPos may be shifted as may the contents of outBuf.
1634: *-----------------------------------------------------------------------
1635: */
1636: void
1637: JobDoOutput (job, finish)
1638: register Job *job; /* the job whose output needs printing */
1639: Boolean finish; /* TRUE if this is the last time we'll be
1640: * called for this job */
1641: {
1642: Boolean gotNL = FALSE; /* true if got a newline */
1643: register int nr; /* number of bytes read */
1644: register int i; /* auxiliary index into outBuf */
1645: register int max; /* limit for i (end of current data) */
1646: int nRead; /* (Temporary) number of bytes read */
1647:
1648: char c; /* character after noPrint string */
1649: FILE *oFILE; /* Stream pointer to shell's output file */
1650: char inLine[132];
1651:
1652:
1653: if (usePipes) {
1654: /*
1655: * Read as many bytes as will fit in the buffer.
1656: */
1657: end_loop:
1658:
1659: nRead = read (job->inPipe, &job->outBuf[job->curPos],
1660: JOB_BUFSIZE - job->curPos);
1661: if (nRead < 0) {
1662: if (DEBUG(JOB)) {
1663: perror("JobDoOutput(piperead)");
1664: }
1665: nr = 0;
1666: } else {
1667: nr = nRead;
1668: }
1669:
1670: /*
1671: * If we hit the end-of-file (the job is dead), we must flush its
1672: * remaining output, so pretend we read a newline if there's any
1673: * output remaining in the buffer.
1674: * Also clear the 'finish' flag so we stop looping.
1675: */
1676: if ((nr == 0) && (job->curPos != 0)) {
1677: job->outBuf[job->curPos] = '\n';
1678: nr = 1;
1679: finish = FALSE;
1680: } else if (nr == 0) {
1681: finish = FALSE;
1682: }
1683:
1684: /*
1685: * Look for the last newline in the bytes we just got. If there is
1686: * one, break out of the loop with 'i' as its index and gotNL set
1687: * TRUE.
1688: */
1689: max = job->curPos + nr;
1690: for (i = job->curPos + nr - 1; i >= job->curPos; i--) {
1691: if (job->outBuf[i] == '\n') {
1692: gotNL = TRUE;
1693: break;
1694: } else if (job->outBuf[i] == '\0') {
1695: /*
1696: * Why?
1697: */
1698: job->outBuf[i] = ' ';
1699: }
1700: }
1701:
1702: if (!gotNL) {
1703: job->curPos += nr;
1704: if (job->curPos == JOB_BUFSIZE) {
1705: /*
1706: * If we've run out of buffer space, we have no choice
1707: * but to print the stuff. sigh.
1708: */
1709: gotNL = TRUE;
1710: i = job->curPos;
1711: }
1712: }
1713: if (gotNL) {
1714: /*
1715: * Need to send the output to the screen. Null terminate it
1716: * first, overwriting the newline character if there was one.
1717: * So long as the line isn't one we should filter (according
1718: * to the shell description), we print the line, preceeded
1719: * by a target banner if this target isn't the same as the
1720: * one for which we last printed something.
1721: * The rest of the data in the buffer are then shifted down
1722: * to the start of the buffer and curPos is set accordingly.
1723: */
1724: job->outBuf[i] = '\0';
1725: if (i >= job->curPos) {
1726: register char *cp, *ecp;
1727:
1728: cp = job->outBuf;
1729: if (commandShell->noPrint) {
1730: ecp = Str_FindSubstring(job->outBuf,
1731: commandShell->noPrint);
1732: while (ecp != (char *)NULL) {
1733: if (cp != ecp) {
1734: *ecp = '\0';
1735: if (job->node != lastNode) {
1736: printf (targFmt, job->node->name);
1737: lastNode = job->node;
1738: }
1739: /*
1740: * The only way there wouldn't be a newline after
1741: * this line is if it were the last in the buffer.
1742: * however, since the non-printable comes after it,
1743: * there must be a newline, so we don't print one.
1744: */
1745: printf ("%s", cp);
1746: }
1747: cp = ecp + commandShell->noPLen;
1748: if (cp != &job->outBuf[i]) {
1749: /*
1750: * Still more to print, look again after skipping
1751: * the whitespace following the non-printable
1752: * command....
1753: */
1754: cp++;
1755: while (*cp == ' ' || *cp == '\t' || *cp == '\n') {
1756: cp++;
1757: }
1758: ecp = Str_FindSubstring (cp,
1759: commandShell->noPrint);
1760: } else {
1761: break;
1762: }
1763: }
1764: }
1765:
1766: /*
1767: * There's still more in that thar buffer. This time, though,
1768: * we know there's no newline at the end, so we add one of
1769: * our own free will.
1770: */
1771: if (*cp != '\0') {
1772: if (job->node != lastNode) {
1773: printf (targFmt, job->node->name);
1774: lastNode = job->node;
1775: }
1776: printf ("%s\n", cp);
1777: }
1778:
1779: fflush (stdout);
1780: }
1781: if (i < max - 1) {
1782: bcopy (&job->outBuf[i + 1], /* shift the remaining */
1783: job->outBuf, /* characters down */
1784: max - (i + 1));
1785: job->curPos = max - (i + 1);
1786:
1787: } else {
1788: /*
1789: * We have written everything out, so we just start over
1790: * from the start of the buffer. No copying. No nothing.
1791: */
1792: job->curPos = 0;
1793: }
1794: }
1795: if (finish) {
1796: /*
1797: * If the finish flag is true, we must loop until we hit
1798: * end-of-file on the pipe. This is guaranteed to happen eventually
1799: * since the other end of the pipe is now closed (we closed it
1800: * explicitly and the child has exited). When we do get an EOF,
1801: * finish will be set FALSE and we'll fall through and out.
1802: */
1803: goto end_loop;
1804: }
1805: } else {
1806: /*
1807: * We've been called to retrieve the output of the job from the
1808: * temporary file where it's been squirreled away. This consists of
1809: * opening the file, reading the output line by line, being sure not
1810: * to print the noPrint line for the shell we used, then close and
1811: * remove the temporary file. Very simple.
1812: *
1813: * Change to read in blocks and do FindSubString type things as for
1814: * pipes? That would allow for "@echo -n..."
1815: */
1816: oFILE = fopen (job->outFile, "r");
1817: if (oFILE != (FILE *) NULL) {
1818: printf ("Results of making %s:\n", job->node->name);
1819: while (fgets (inLine, sizeof(inLine), oFILE) != NULL) {
1820: register char *cp, *ecp, *endp;
1821:
1822: cp = inLine;
1823: endp = inLine + strlen(inLine);
1824: if (endp[-1] == '\n') {
1825: *--endp = '\0';
1826: }
1827: if (commandShell->noPrint) {
1828: ecp = Str_FindSubstring(cp, commandShell->noPrint);
1829: while (ecp != (char *)NULL) {
1830: if (cp != ecp) {
1831: *ecp = '\0';
1832: /*
1833: * The only way there wouldn't be a newline after
1834: * this line is if it were the last in the buffer.
1835: * however, since the non-printable comes after it,
1836: * there must be a newline, so we don't print one.
1837: */
1838: printf ("%s", cp);
1839: }
1840: cp = ecp + commandShell->noPLen;
1841: if (cp != endp) {
1842: /*
1843: * Still more to print, look again after skipping
1844: * the whitespace following the non-printable
1845: * command....
1846: */
1847: cp++;
1848: while (*cp == ' ' || *cp == '\t' || *cp == '\n') {
1849: cp++;
1850: }
1851: ecp = Str_FindSubstring(cp, commandShell->noPrint);
1852: } else {
1853: break;
1854: }
1855: }
1856: }
1857:
1858: /*
1859: * There's still more in that thar buffer. This time, though,
1860: * we know there's no newline at the end, so we add one of
1861: * our own free will.
1862: */
1863: if (*cp != '\0') {
1864: printf ("%s\n", cp);
1865: }
1866: }
1867: fclose (oFILE);
1868: (void) unlink (job->outFile);
1869: }
1870: }
1871: fflush(stdout);
1872: }
1873:
1874: /*-
1875: *-----------------------------------------------------------------------
1876: * Job_CatchChildren --
1877: * Handle the exit of a child. Called from Make_Make.
1878: *
1879: * Results:
1880: * none.
1881: *
1882: * Side Effects:
1883: * The job descriptor is removed from the list of children.
1884: *
1885: * Notes:
1886: * We do waits, blocking or not, according to the wisdom of our
1887: * caller, until there are no more children to report. For each
1888: * job, call JobFinish to finish things off. This will take care of
1889: * putting jobs on the stoppedJobs queue.
1890: *
1891: *-----------------------------------------------------------------------
1892: */
1893: void
1894: Job_CatchChildren (block)
1895: Boolean block; /* TRUE if should block on the wait. */
1896: {
1897: int pid; /* pid of dead child */
1898: register Job *job; /* job descriptor for dead child */
1899: LstNode jnode; /* list element for finding job */
1900: union wait status; /* Exit/termination status */
1901:
1902: /*
1903: * Don't even bother if we know there's no one around.
1904: */
1905: if (nLocal == 0) {
1906: return;
1907: }
1908:
1909: while ((pid = wait3(&status, (block?0:WNOHANG)|WUNTRACED,
1910: (struct rusage *)0)) > 0)
1911: {
1912: if (DEBUG(JOB))
1913: printf("Process %d exited or stopped.\n", pid);
1914:
1915:
1916: jnode = Lst_Find (jobs, (ClientData)pid, JobCmpPid);
1917:
1918: if (jnode == NILLNODE) {
1919: if (WIFSIGNALED(status) && (status.w_termsig == SIGCONT)) {
1920: jnode = Lst_Find(stoppedJobs, (ClientData)pid, JobCmpPid);
1921: if (jnode == NILLNODE) {
1922: Error("Resumed child (%d) not in table", pid);
1923: continue;
1924: }
1925: job = (Job *)Lst_Datum(jnode);
1926: (void)Lst_Remove(stoppedJobs, jnode);
1927: } else {
1928: Error ("Child (%d) not in table?", pid);
1929: continue;
1930: }
1931: } else {
1932: job = (Job *) Lst_Datum (jnode);
1933: (void)Lst_Remove (jobs, jnode);
1934: nJobs -= 1;
1935: if (jobFull && DEBUG(JOB)) {
1936: printf("Job queue is no longer full.\n");
1937: }
1938: jobFull = FALSE;
1939: nLocal -= 1;
1940: }
1941:
1942: JobFinish (job, status);
1943: }
1944: }
1945:
1946: /*-
1947: *-----------------------------------------------------------------------
1948: * Job_CatchOutput --
1949: * Catch the output from our children, if we're using
1950: * pipes do so. Otherwise just block time until we get a
1951: * signal (most likely a SIGCHLD) since there's no point in
1952: * just spinning when there's nothing to do and the reaping
1953: * of a child can wait for a while.
1954: *
1955: * Results:
1956: * None
1957: *
1958: * Side Effects:
1959: * Output is read from pipes if we're piping.
1960: * -----------------------------------------------------------------------
1961: */
1962: void
1963: Job_CatchOutput ()
1964: {
1965: int nfds;
1966: struct timeval timeout;
1967: fd_set readfds;
1968: register LstNode ln;
1969: register Job *job;
1970: int pnJobs; /* Previous nJobs */
1971:
1972: fflush(stdout);
1973: #ifdef RMT_WILL_WATCH
1974: pnJobs = nJobs;
1975:
1976: /*
1977: * It is possible for us to be called with nJobs equal to 0. This happens
1978: * if all the jobs finish and a job that is stopped cannot be run
1979: * locally (eg if maxLocal is 0) and cannot be exported. The job will
1980: * be placed back on the stoppedJobs queue, Job_Empty() will return false,
1981: * Make_Run will call us again when there's nothing for which to wait.
1982: * nJobs never changes, so we loop forever. Hence the check. It could
1983: * be argued that we should sleep for a bit so as not to swamp the
1984: * exportation system with requests. Perhaps we should.
1985: *
1986: * NOTE: IT IS THE RESPONSIBILITY OF Rmt_Wait TO CALL Job_CatchChildren
1987: * IN A TIMELY FASHION TO CATCH ANY LOCALLY RUNNING JOBS THAT EXIT.
1988: * It may use the variable nLocal to determine if it needs to call
1989: * Job_CatchChildren (if nLocal is 0, there's nothing for which to
1990: * wait...)
1991: */
1992: while (nJobs != 0 && pnJobs == nJobs) {
1993: Rmt_Wait();
1994: }
1995: #else
1996: if (usePipes) {
1997: readfds = outputs;
1998: timeout.tv_sec = SEL_SEC;
1999: timeout.tv_usec = SEL_USEC;
2000:
2001: if ((nfds = select (FD_SETSIZE, &readfds, (int *) 0, (int *) 0, &timeout)) < 0)
2002: {
2003: return;
2004: } else {
2005: if (Lst_Open (jobs) == FAILURE) {
2006: Punt ("Cannot open job table");
2007: }
2008: while (nfds && (ln = Lst_Next (jobs)) != NILLNODE) {
2009: job = (Job *) Lst_Datum (ln);
2010: if (FD_ISSET(job->inPipe, &readfds)) {
2011: JobDoOutput (job, FALSE);
2012: nfds -= 1;
2013: }
2014: }
2015: Lst_Close (jobs);
2016: }
2017: }
2018: #endif /* RMT_WILL_WATCH */
2019: }
2020:
2021: /*-
2022: *-----------------------------------------------------------------------
2023: * Job_Make --
2024: * Start the creation of a target. Basically a front-end for
2025: * JobStart used by the Make module.
2026: *
2027: * Results:
2028: * None.
2029: *
2030: * Side Effects:
2031: * Another job is started.
2032: *
2033: *-----------------------------------------------------------------------
2034: */
2035: void
2036: Job_Make (gn)
2037: GNode *gn;
2038: {
2039: (void)JobStart (gn, 0, (Job *)NULL);
2040: }
2041:
2042: /*-
2043: *-----------------------------------------------------------------------
2044: * Job_Init --
2045: * Initialize the process module
2046: *
2047: * Results:
2048: * none
2049: *
2050: * Side Effects:
2051: * lists and counters are initialized
2052: *-----------------------------------------------------------------------
2053: */
2054: void
2055: Job_Init (maxproc, maxlocal)
2056: int maxproc; /* the greatest number of jobs which may be
2057: * running at one time */
2058: int maxlocal; /* the greatest number of local jobs which may
2059: * be running at once. */
2060: {
2061: GNode *begin; /* node for commands to do at the very start */
2062:
2063: sprintf (tfile, "/tmp/make%05d", getpid());
2064:
2065: jobs = Lst_Init (FALSE);
2066: stoppedJobs = Lst_Init(FALSE);
2067: maxJobs = maxproc;
2068: maxLocal = maxlocal;
2069: nJobs = 0;
2070: nLocal = 0;
2071: jobFull = FALSE;
2072:
2073: aborting = 0;
2074: errors = 0;
2075:
2076: lastNode = NILGNODE;
2077:
2078: if (maxJobs == 1) {
2079: /*
2080: * If only one job can run at a time, there's no need for a banner,
2081: * no is there?
2082: */
2083: targFmt = "";
2084: } else {
2085: targFmt = TARG_FMT;
2086: }
2087:
2088: if (shellPath == (char *) NULL) {
2089: /*
2090: * The user didn't specify a shell to use, so we are using the
2091: * default one... Both the absolute path and the last component
2092: * must be set. The last component is taken from the 'name' field
2093: * of the default shell description pointed-to by commandShell.
2094: * All default shells are located in _PATH_DEFSHELLDIR.
2095: */
2096: shellName = commandShell->name;
2097: shellPath = str_concat (_PATH_DEFSHELLDIR, shellName, STR_ADDSLASH);
2098: }
2099:
2100: if (commandShell->exit == (char *)NULL) {
2101: commandShell->exit = "";
2102: }
2103: if (commandShell->echo == (char *)NULL) {
2104: commandShell->echo = "";
2105: }
2106:
2107: /*
2108: * Catch the four signals that POSIX specifies if they aren't ignored.
2109: * JobPassSig will take care of calling JobInterrupt if appropriate.
2110: */
2111: if (signal (SIGINT, SIG_IGN) != SIG_IGN) {
2112: signal (SIGINT, JobPassSig);
2113: }
2114: if (signal (SIGHUP, SIG_IGN) != SIG_IGN) {
2115: signal (SIGHUP, JobPassSig);
2116: }
2117: if (signal (SIGQUIT, SIG_IGN) != SIG_IGN) {
2118: signal (SIGQUIT, JobPassSig);
2119: }
2120: if (signal (SIGTERM, SIG_IGN) != SIG_IGN) {
2121: signal (SIGTERM, JobPassSig);
2122: }
2123: /*
2124: * There are additional signals that need to be caught and passed if
2125: * either the export system wants to be told directly of signals or if
2126: * we're giving each job its own process group (since then it won't get
2127: * signals from the terminal driver as we own the terminal)
2128: */
2129: #if defined(RMT_WANTS_SIGNALS) || defined(USE_PGRP)
2130: if (signal (SIGTSTP, SIG_IGN) != SIG_IGN) {
2131: signal (SIGTSTP, JobPassSig);
2132: }
2133: if (signal (SIGTTOU, SIG_IGN) != SIG_IGN) {
2134: signal (SIGTTOU, JobPassSig);
2135: }
2136: if (signal (SIGTTIN, SIG_IGN) != SIG_IGN) {
2137: signal (SIGTTIN, JobPassSig);
2138: }
2139: if (signal (SIGWINCH, SIG_IGN) != SIG_IGN) {
2140: signal (SIGWINCH, JobPassSig);
2141: }
2142: #endif
2143:
2144: begin = Targ_FindNode (".BEGIN", TARG_NOCREATE);
2145:
2146: if (begin != NILGNODE) {
2147: JobStart (begin, JOB_SPECIAL, (Job *)0);
2148: while (nJobs) {
2149: Job_CatchOutput();
2150: #ifndef RMT_WILL_WATCH
2151: Job_CatchChildren (!usePipes);
2152: #endif /* RMT_WILL_WATCH */
2153: }
2154: }
2155: postCommands = Targ_FindNode (".END", TARG_CREATE);
2156: }
2157:
2158: /*-
2159: *-----------------------------------------------------------------------
2160: * Job_Full --
2161: * See if the job table is full. It is considered full if it is OR
2162: * if we are in the process of aborting OR if we have
2163: * reached/exceeded our local quota. This prevents any more jobs
2164: * from starting up.
2165: *
2166: * Results:
2167: * TRUE if the job table is full, FALSE otherwise
2168: * Side Effects:
2169: * None.
2170: *-----------------------------------------------------------------------
2171: */
2172: Boolean
2173: Job_Full ()
2174: {
2175: return (aborting || jobFull);
2176: }
2177:
2178: /*-
2179: *-----------------------------------------------------------------------
2180: * Job_Empty --
2181: * See if the job table is empty. Because the local concurrency may
2182: * be set to 0, it is possible for the job table to become empty,
2183: * while the list of stoppedJobs remains non-empty. In such a case,
2184: * we want to restart as many jobs as we can.
2185: *
2186: * Results:
2187: * TRUE if it is. FALSE if it ain't.
2188: *
2189: * Side Effects:
2190: * None.
2191: *
2192: * -----------------------------------------------------------------------
2193: */
2194: Boolean
2195: Job_Empty ()
2196: {
2197: if (nJobs == 0) {
2198: if (!Lst_IsEmpty(stoppedJobs) && !aborting) {
2199: /*
2200: * The job table is obviously not full if it has no jobs in
2201: * it...Try and restart the stopped jobs.
2202: */
2203: jobFull = FALSE;
2204: while (!jobFull && !Lst_IsEmpty(stoppedJobs)) {
2205: JobRestart((Job *)Lst_DeQueue(stoppedJobs));
2206: }
2207: return(FALSE);
2208: } else {
2209: return(TRUE);
2210: }
2211: } else {
2212: return(FALSE);
2213: }
2214: }
2215:
2216: /*-
2217: *-----------------------------------------------------------------------
2218: * JobMatchShell --
2219: * Find a matching shell in 'shells' given its final component.
2220: *
2221: * Results:
2222: * A pointer to the Shell structure.
2223: *
2224: * Side Effects:
2225: * None.
2226: *
2227: *-----------------------------------------------------------------------
2228: */
2229: static Shell *
2230: JobMatchShell (name)
2231: char *name; /* Final component of shell path */
2232: {
2233: register Shell *sh; /* Pointer into shells table */
2234: Shell *match; /* Longest-matching shell */
2235: register char *cp1,
2236: *cp2;
2237: char *eoname;
2238:
2239: eoname = name + strlen (name);
2240:
2241: match = (Shell *) NULL;
2242:
2243: for (sh = shells; sh->name != NULL; sh++) {
2244: for (cp1 = eoname - strlen (sh->name), cp2 = sh->name;
2245: *cp1 != '\0' && *cp1 == *cp2;
2246: cp1++, cp2++) {
2247: continue;
2248: }
2249: if (*cp1 != *cp2) {
2250: continue;
2251: } else if (match == (Shell *) NULL ||
2252: strlen (match->name) < strlen (sh->name)) {
2253: match = sh;
2254: }
2255: }
2256: return (match == (Shell *) NULL ? sh : match);
2257: }
2258:
2259: /*-
2260: *-----------------------------------------------------------------------
2261: * Job_ParseShell --
2262: * Parse a shell specification and set up commandShell, shellPath
2263: * and shellName appropriately.
2264: *
2265: * Results:
2266: * FAILURE if the specification was incorrect.
2267: *
2268: * Side Effects:
2269: * commandShell points to a Shell structure (either predefined or
2270: * created from the shell spec), shellPath is the full path of the
2271: * shell described by commandShell, while shellName is just the
2272: * final component of shellPath.
2273: *
2274: * Notes:
2275: * A shell specification consists of a .SHELL target, with dependency
2276: * operator, followed by a series of blank-separated words. Double
2277: * quotes can be used to use blanks in words. A backslash escapes
2278: * anything (most notably a double-quote and a space) and
2279: * provides the functionality it does in C. Each word consists of
2280: * keyword and value separated by an equal sign. There should be no
2281: * unnecessary spaces in the word. The keywords are as follows:
2282: * name Name of shell.
2283: * path Location of shell. Overrides "name" if given
2284: * quiet Command to turn off echoing.
2285: * echo Command to turn echoing on
2286: * filter Result of turning off echoing that shouldn't be
2287: * printed.
2288: * echoFlag Flag to turn echoing on at the start
2289: * errFlag Flag to turn error checking on at the start
2290: * hasErrCtl True if shell has error checking control
2291: * check Command to turn on error checking if hasErrCtl
2292: * is TRUE or template of command to echo a command
2293: * for which error checking is off if hasErrCtl is
2294: * FALSE.
2295: * ignore Command to turn off error checking if hasErrCtl
2296: * is TRUE or template of command to execute a
2297: * command so as to ignore any errors it returns if
2298: * hasErrCtl is FALSE.
2299: *
2300: *-----------------------------------------------------------------------
2301: */
2302: ReturnStatus
2303: Job_ParseShell (line)
2304: char *line; /* The shell spec */
2305: {
2306: char **words;
2307: int wordCount;
2308: register char **argv;
2309: register int argc;
2310: char *path;
2311: Shell newShell;
2312: Boolean fullSpec = FALSE;
2313:
2314: while (isspace (*line)) {
2315: line++;
2316: }
2317: words = brk_string (line, &wordCount);
2318:
2319: bzero ((Address)&newShell, sizeof(newShell));
2320:
2321: /*
2322: * Parse the specification by keyword
2323: */
2324: for (path = (char *)NULL, argc = wordCount - 1, argv = words + 1;
2325: argc != 0;
2326: argc--, argv++) {
2327: if (strncmp (*argv, "path=", 5) == 0) {
2328: path = &argv[0][5];
2329: } else if (strncmp (*argv, "name=", 5) == 0) {
2330: newShell.name = &argv[0][5];
2331: } else {
2332: if (strncmp (*argv, "quiet=", 6) == 0) {
2333: newShell.echoOff = &argv[0][6];
2334: } else if (strncmp (*argv, "echo=", 5) == 0) {
2335: newShell.echoOn = &argv[0][5];
2336: } else if (strncmp (*argv, "filter=", 7) == 0) {
2337: newShell.noPrint = &argv[0][7];
2338: newShell.noPLen = strlen(newShell.noPrint);
2339: } else if (strncmp (*argv, "echoFlag=", 9) == 0) {
2340: newShell.echo = &argv[0][9];
2341: } else if (strncmp (*argv, "errFlag=", 8) == 0) {
2342: newShell.exit = &argv[0][8];
2343: } else if (strncmp (*argv, "hasErrCtl=", 10) == 0) {
2344: char c = argv[0][10];
2345: newShell.hasErrCtl = !((c != 'Y') && (c != 'y') &&
2346: (c != 'T') && (c != 't'));
2347: } else if (strncmp (*argv, "check=", 6) == 0) {
2348: newShell.errCheck = &argv[0][6];
2349: } else if (strncmp (*argv, "ignore=", 7) == 0) {
2350: newShell.ignErr = &argv[0][7];
2351: } else {
2352: Parse_Error (PARSE_FATAL, "Unknown keyword \"%s\"",
2353: *argv);
2354: return (FAILURE);
2355: }
2356: fullSpec = TRUE;
2357: }
2358: }
2359:
2360: if (path == (char *)NULL) {
2361: /*
2362: * If no path was given, the user wants one of the pre-defined shells,
2363: * yes? So we find the one s/he wants with the help of JobMatchShell
2364: * and set things up the right way. shellPath will be set up by
2365: * Job_Init.
2366: */
2367: if (newShell.name == (char *)NULL) {
2368: Parse_Error (PARSE_FATAL, "Neither path nor name specified");
2369: return (FAILURE);
2370: } else {
2371: commandShell = JobMatchShell (newShell.name);
2372: shellName = newShell.name;
2373: }
2374: } else {
2375: /*
2376: * The user provided a path. If s/he gave nothing else (fullSpec is
2377: * FALSE), try and find a matching shell in the ones we know of.
2378: * Else we just take the specification at its word and copy it
2379: * to a new location. In either case, we need to record the
2380: * path the user gave for the shell.
2381: */
2382: shellPath = path;
2383: path = rindex (path, '/');
2384: if (path == (char *)NULL) {
2385: path = shellPath;
2386: } else {
2387: path += 1;
2388: }
2389: if (newShell.name != (char *)NULL) {
2390: shellName = newShell.name;
2391: } else {
2392: shellName = path;
2393: }
2394: if (!fullSpec) {
2395: commandShell = JobMatchShell (shellName);
2396: } else {
2397: commandShell = (Shell *) emalloc(sizeof(Shell));
2398: *commandShell = newShell;
2399: }
2400: }
2401:
2402: if (commandShell->echoOn && commandShell->echoOff) {
2403: commandShell->hasEchoCtl = TRUE;
2404: }
2405:
2406: if (!commandShell->hasErrCtl) {
2407: if (commandShell->errCheck == (char *)NULL) {
2408: commandShell->errCheck = "";
2409: }
2410: if (commandShell->ignErr == (char *)NULL) {
2411: commandShell->ignErr = "%s\n";
2412: }
2413: }
2414:
2415: /*
2416: * Do not free up the words themselves, since they might be in use by the
2417: * shell specification...
2418: */
2419: free (words);
2420: return SUCCESS;
2421: }
2422:
2423: /*-
2424: *-----------------------------------------------------------------------
2425: * JobInterrupt --
2426: * Handle the receipt of an interrupt.
2427: *
2428: * Results:
2429: * None
2430: *
2431: * Side Effects:
2432: * All children are killed. Another job will be started if the
2433: * .INTERRUPT target was given.
2434: *-----------------------------------------------------------------------
2435: */
2436: static void
2437: JobInterrupt (runINTERRUPT)
2438: int runINTERRUPT; /* Non-zero if commands for the .INTERRUPT
2439: * target should be executed */
2440: {
2441: LstNode ln; /* element in job table */
2442: Job *job; /* job descriptor in that element */
2443: GNode *interrupt; /* the node describing the .INTERRUPT target */
2444:
2445: aborting = ABORT_INTERRUPT;
2446:
2447: (void)Lst_Open (jobs);
2448: while ((ln = Lst_Next (jobs)) != NILLNODE) {
2449: job = (Job *) Lst_Datum (ln);
2450:
2451: if (!Targ_Precious (job->node)) {
2452: char *file = (job->node->path == (char *)NULL ?
2453: job->node->name :
2454: job->node->path);
2455: if (unlink (file) == 0) {
2456: Error ("*** %s removed", file);
2457: }
2458: }
2459: #ifdef RMT_WANTS_SIGNALS
2460: if (job->flags & JOB_REMOTE) {
2461: /*
2462: * If job is remote, let the Rmt module do the killing.
2463: */
2464: if (!Rmt_Signal(job, SIGINT)) {
2465: /*
2466: * If couldn't kill the thing, finish it out now with an
2467: * error code, since no exit report will come in likely.
2468: */
2469: union wait status;
2470:
2471: status.w_status = 0;
2472: status.w_retcode = 1;
2473: JobFinish(job, status);
2474: }
2475: } else if (job->pid) {
2476: KILL(job->pid, SIGINT);
2477: }
2478: #else
2479: if (job->pid) {
2480: KILL(job->pid, SIGINT);
2481: }
2482: #endif /* RMT_WANTS_SIGNALS */
2483: }
2484: Lst_Close (jobs);
2485:
2486: if (runINTERRUPT && !touchFlag) {
2487: interrupt = Targ_FindNode (".INTERRUPT", TARG_NOCREATE);
2488: if (interrupt != NILGNODE) {
2489: ignoreErrors = FALSE;
2490:
2491: JobStart (interrupt, JOB_IGNDOTS, (Job *)0);
2492: while (nJobs) {
2493: Job_CatchOutput();
2494: #ifndef RMT_WILL_WATCH
2495: Job_CatchChildren (!usePipes);
2496: #endif /* RMT_WILL_WATCH */
2497: }
2498: }
2499: }
2500: (void) unlink (tfile);
2501: exit (0);
2502: }
2503:
2504: /*
2505: *-----------------------------------------------------------------------
2506: * Job_End --
2507: * Do final processing such as the running of the commands
2508: * attached to the .END target.
2509: *
2510: * Results:
2511: * Number of errors reported.
2512: *
2513: * Side Effects:
2514: * The process' temporary file (tfile) is removed if it still
2515: * existed.
2516: *-----------------------------------------------------------------------
2517: */
2518: int
2519: Job_End ()
2520: {
2521: if (postCommands != NILGNODE && !Lst_IsEmpty (postCommands->commands)) {
2522: if (errors) {
2523: Error ("Errors reported so .END ignored");
2524: } else {
2525: JobStart (postCommands, JOB_SPECIAL | JOB_IGNDOTS,
2526: (Job *)0);
2527:
2528: while (nJobs) {
2529: Job_CatchOutput();
2530: #ifndef RMT_WILL_WATCH
2531: Job_CatchChildren (!usePipes);
2532: #endif /* RMT_WILL_WATCH */
2533: }
2534: }
2535: }
2536: (void) unlink (tfile);
2537: return(errors);
2538: }
2539:
2540: /*-
2541: *-----------------------------------------------------------------------
2542: * Job_Wait --
2543: * Waits for all running jobs to finish and returns. Sets 'aborting'
2544: * to ABORT_WAIT to prevent other jobs from starting.
2545: *
2546: * Results:
2547: * None.
2548: *
2549: * Side Effects:
2550: * Currently running jobs finish.
2551: *
2552: *-----------------------------------------------------------------------
2553: */
2554: void
2555: Job_Wait()
2556: {
2557: aborting = ABORT_WAIT;
2558: while (nJobs != 0) {
2559: Job_CatchOutput();
2560: #ifndef RMT_WILL_WATCH
2561: Job_CatchChildren(!usePipes);
2562: #endif /* RMT_WILL_WATCH */
2563: }
2564: aborting = 0;
2565: }
2566:
2567: /*-
2568: *-----------------------------------------------------------------------
2569: * Job_AbortAll --
2570: * Abort all currently running jobs without handling output or anything.
2571: * This function is to be called only in the event of a major
2572: * error. Most definitely NOT to be called from JobInterrupt.
2573: *
2574: * Results:
2575: * None
2576: *
2577: * Side Effects:
2578: * All children are killed, not just the firstborn
2579: *-----------------------------------------------------------------------
2580: */
2581: void
2582: Job_AbortAll ()
2583: {
2584: LstNode ln; /* element in job table */
2585: Job *job; /* the job descriptor in that element */
2586: int foo;
2587:
2588: aborting = ABORT_ERROR;
2589:
2590: if (nJobs) {
2591:
2592: (void)Lst_Open (jobs);
2593: while ((ln = Lst_Next (jobs)) != NILLNODE) {
2594: job = (Job *) Lst_Datum (ln);
2595:
2596: /*
2597: * kill the child process with increasingly drastic signals to make
2598: * darn sure it's dead.
2599: */
2600: #ifdef RMT_WANTS_SIGNALS
2601: if (job->flags & JOB_REMOTE) {
2602: Rmt_Signal(job, SIGINT);
2603: Rmt_Signal(job, SIGKILL);
2604: } else {
2605: KILL(job->pid, SIGINT);
2606: KILL(job->pid, SIGKILL);
2607: }
2608: #else
2609: KILL(job->pid, SIGINT);
2610: KILL(job->pid, SIGKILL);
2611: #endif /* RMT_WANTS_SIGNALS */
2612: }
2613: }
2614:
2615: /*
2616: * Catch as many children as want to report in at first, then give up
2617: */
2618: while (wait3(&foo, WNOHANG, (struct rusage *)0) > 0) {
2619: ;
2620: }
2621: (void) unlink (tfile);
2622: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.