source: trunk/src/kmk/job.c@ 175

Last change on this file since 175 was 51, checked in by bird, 23 years ago

kMk and porting to kLib.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 116.9 KB
Line 
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, 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. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the University of
21 * California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 */
38
39#ifndef lint
40#if 0
41static char sccsid[] = "@(#)job.c 8.2 (Berkeley) 3/19/94";
42#else
43static const char rcsid[] =
44 "$FreeBSD: src/usr.bin/make/job.c,v 1.17.2.2 2001/02/13 03:13:57 will Exp $";
45#endif
46#define KLIBFILEDEF rcsid
47#endif /* not lint */
48
49#if defined(NMAKE) || defined(KMK)
50#define OLD_JOKE 1
51#endif
52
53#ifndef OLD_JOKE
54#define OLD_JOKE 0
55#endif /* OLD_JOKE */
56
57/*-
58 * job.c --
59 * handle the creation etc. of our child processes.
60 *
61 * Interface:
62 * Job_Make Start the creation of the given target.
63 *
64 * Job_CatchChildren Check for and handle the termination of any
65 * children. This must be called reasonably
66 * frequently to keep the whole make going at
67 * a decent clip, since job table entries aren't
68 * removed until their process is caught this way.
69 * Its single argument is TRUE if the function
70 * should block waiting for a child to terminate.
71 *
72 * Job_CatchOutput Print any output our children have produced.
73 * Should also be called fairly frequently to
74 * keep the user informed of what's going on.
75 * If no output is waiting, it will block for
76 * a time given by the SEL_* constants, below,
77 * or until output is ready.
78 *
79 * Job_Init Called to intialize this module. in addition,
80 * any commands attached to the .BEGIN target
81 * are executed before this function returns.
82 * Hence, the makefile must have been parsed
83 * before this function is called.
84 *
85 * Job_Full Return TRUE if the job table is filled.
86 *
87 * Job_Empty Return TRUE if the job table is completely
88 * empty.
89 *
90 * Job_ParseShell Given the line following a .SHELL target, parse
91 * the line as a shell specification. Returns
92 * FAILURE if the spec was incorrect.
93 *
94 * Job_End Perform any final processing which needs doing.
95 * This includes the execution of any commands
96 * which have been/were attached to the .END
97 * target. It should only be called when the
98 * job table is empty.
99 *
100 * Job_AbortAll Abort all currently running jobs. It doesn't
101 * handle output or do anything for the jobs,
102 * just kills them. It should only be called in
103 * an emergency, as it were.
104 *
105 * Job_CheckCommands Verify that the commands for a target are
106 * ok. Provide them if necessary and possible.
107 *
108 * Job_Touch Update a target without really updating it.
109 *
110 * Job_Wait Wait for all currently-running jobs to finish.
111 */
112
113#include <sys/types.h>
114#include <sys/stat.h>
115#if defined(__IBMC__)
116# include <io.h>
117# include <process.h>
118# include <sys/utime.h>
119#else
120# include <sys/file.h>
121#endif
122# include <sys/time.h>
123#if !defined(__IBMC__)
124# include <sys/wait.h>
125#endif
126#include <fcntl.h>
127#include <errno.h>
128#if !defined(__IBMC__)
129# include <utime.h>
130#endif
131#include <stdio.h>
132#include <string.h>
133#include <signal.h>
134#include "make.h"
135#include "hash.h"
136#include "dir.h"
137#include "job.h"
138#include "pathnames.h"
139#ifdef REMOTE
140#include "rmt.h"
141# define STATIC
142#else
143# if defined(__IBMC__)
144# define STATIC
145# else
146# define STATIC static
147# endif
148#endif
149#if defined(__EMX__) && !defined(SIGCONT)
150#define SIGCONT SIGALRM /* just trying... */
151#endif
152
153/*
154 * error handling variables
155 */
156static int errors = 0; /* number of errors reported */
157static int aborting = 0; /* why is the make aborting? */
158#define ABORT_ERROR 1 /* Because of an error */
159#define ABORT_INTERRUPT 2 /* Because it was interrupted */
160#define ABORT_WAIT 3 /* Waiting for jobs to finish */
161
162/*
163 * XXX: Avoid SunOS bug... FILENO() is fp->_file, and file
164 * is a char! So when we go above 127 we turn negative!
165 */
166#define FILENO(a) ((unsigned) fileno(a))
167
168/*
169 * post-make command processing. The node postCommands is really just the
170 * .END target but we keep it around to avoid having to search for it
171 * all the time.
172 */
173static GNode *postCommands; /* node containing commands to execute when
174 * everything else is done */
175static int numCommands; /* The number of commands actually printed
176 * for a target. Should this number be
177 * 0, no shell will be executed. */
178
179/*
180 * Return values from JobStart.
181 */
182#define JOB_RUNNING 0 /* Job is running */
183#define JOB_ERROR 1 /* Error in starting the job */
184#define JOB_FINISHED 2 /* The job is already finished */
185#define JOB_STOPPED 3 /* The job is stopped */
186
187/*
188 * tfile is used to build temp file names to store shell commands to
189 * execute.
190 */
191static char tfile[sizeof(TMPPAT)];
192
193#ifndef KMK
194/*
195 * Descriptions for various shells.
196 */
197static Shell shells[] = {
198 /*
199 * CSH description. The csh can do echo control by playing
200 * with the setting of the 'echo' shell variable. Sadly,
201 * however, it is unable to do error control nicely.
202 */
203{
204 "csh",
205 TRUE, "unset verbose", "set verbose", "unset verbose", 10,
206 FALSE, "echo \"%s\"\n", "csh -c \"%s || exit 0\"",
207 "v", "e",
208},
209 /*
210 * SH description. Echo control is also possible and, under
211 * sun UNIX anyway, one can even control error checking.
212 */
213{
214 "sh",
215 TRUE, "set -", "set -v", "set -", 5,
216 TRUE, "set -e", "set +e",
217#ifdef OLDBOURNESHELL
218 FALSE, "echo \"%s\"\n", "sh -c '%s || exit 0'\n",
219#endif
220 "v", "e",
221},
222 /*
223 * UNKNOWN.
224 */
225{
226 (char *) 0,
227 FALSE, (char *) 0, (char *) 0, (char *) 0, 0,
228 FALSE, (char *) 0, (char *) 0,
229 (char *) 0, (char *) 0,
230}
231};
232static Shell *commandShell = &shells[DEFSHELL];/* this is the shell to
233 * which we pass all
234 * commands in the Makefile.
235 * It is set by the
236 * Job_ParseShell function */
237static char *shellPath = NULL, /* full pathname of
238 * executable image */
239 *shellName; /* last component of shell */
240#endif /*!KMK*/
241
242
243static int maxJobs; /* The most children we can run at once */
244static int maxLocal; /* The most local ones we can have */
245STATIC int nJobs; /* The number of children currently running */
246STATIC int nLocal; /* The number of local children */
247STATIC Lst jobs; /* The structures that describe them */
248STATIC Boolean jobFull; /* Flag to tell when the job table is full. It
249 * is set TRUE when (1) the total number of
250 * running jobs equals the maximum allowed or
251 * (2) a job can only be run locally, but
252 * nLocal equals maxLocal */
253#ifndef RMT_WILL_WATCH
254static fd_set outputs; /* Set of descriptors of pipes connected to
255 * the output channels of children */
256#endif
257
258STATIC GNode *lastNode; /* The node for which output was most recently
259 * produced. */
260STATIC char *targFmt; /* Format string to use to head output from a
261 * job when it's not the most-recent job heard
262 * from */
263
264#ifdef REMOTE
265# define TARG_FMT "--- %s at %s ---\n" /* Default format */
266# define MESSAGE(fp, gn) \
267 (void) fprintf(fp, targFmt, gn->name, gn->rem.hname);
268#else
269# define TARG_FMT "--- %s ---\n" /* Default format */
270# define MESSAGE(fp, gn) \
271 (void) fprintf(fp, targFmt, gn->name);
272#endif
273
274#ifdef SIGCONT
275/*
276 * When JobStart attempts to run a job remotely but can't, and isn't allowed
277 * to run the job locally, or when Job_CatchChildren detects a job that has
278 * been migrated home, the job is placed on the stoppedJobs queue to be run
279 * when the next job finishes.
280 */
281STATIC Lst stoppedJobs; /* Lst of Job structures describing
282 * jobs that were stopped due to concurrency
283 * limits or migration home */
284#endif /*SIGCONT*/
285
286#if defined(USE_PGRP) && defined(SYSV)
287# define KILL(pid, sig) killpg(-(pid), (sig))
288#else
289# if defined(USE_PGRP)
290# define KILL(pid, sig) killpg((pid), (sig))
291# else
292# define KILL(pid, sig) kill((pid), (sig))
293# endif
294#endif
295
296/*
297 * Grmpf... There is no way to set bits of the wait structure
298 * anymore with the stupid W*() macros. I liked the union wait
299 * stuff much more. So, we devise our own macros... This is
300 * really ugly, use dramamine sparingly. You have been warned.
301 */
302#define W_SETMASKED(st, val, fun) \
303 { \
304 int sh = (int) ~0; \
305 int mask = fun(sh); \
306 \
307 for (sh = 0; ((mask >> sh) & 1) == 0; sh++) \
308 continue; \
309 *(st) = (*(st) & ~mask) | ((val) << sh); \
310 }
311
312#define W_SETTERMSIG(st, val) W_SETMASKED(st, val, WTERMSIG)
313#define W_SETEXITSTATUS(st, val) W_SETMASKED(st, val, WEXITSTATUS)
314
315
316static int JobCondPassSig __P((ClientData, ClientData));
317static void JobPassSig __P((int));
318static int JobCmpPid __P((ClientData, ClientData));
319static int JobPrintCommand __P((ClientData, ClientData));
320static int JobSaveCommand __P((ClientData, ClientData));
321static void JobClose __P((Job *));
322#ifdef REMOTE
323static int JobCmpRmtID __P((Job *, int));
324# ifdef RMT_WILL_WATCH
325static void JobLocalInput __P((int, Job *));
326# endif
327#else
328#ifdef USE_KLIB
329static void JobFinish __P((Job *, KPROCRES *));
330#else
331static void JobFinish __P((Job *, int *));
332#endif
333static void JobExec __P((Job *, char **));
334#endif
335static void JobMakeArgv __P((Job *, char **));
336#ifdef SIGCONT
337static void JobRestart __P((Job *));
338#endif
339static int JobStart __P((GNode *, int, Job *));
340static char *JobOutput __P((Job *, char *, char *, int));
341static void JobDoOutput __P((Job *, Boolean));
342static Shell *JobMatchShell __P((char *));
343static void JobInterrupt __P((int, int));
344#ifdef SIGCONT
345static void JobRestartJobs __P((void));
346#endif
347
348/*-
349 *-----------------------------------------------------------------------
350 * JobCondPassSig --
351 * Pass a signal to a job if the job is remote or if USE_PGRP
352 * is defined.
353 *
354 * Results:
355 * === 0
356 *
357 * Side Effects:
358 * None, except the job may bite it.
359 *
360 *-----------------------------------------------------------------------
361 */
362static int
363JobCondPassSig(jobp, signop)
364 ClientData jobp; /* Job to biff */
365 ClientData signop; /* Signal to send it */
366{
367 Job *job = (Job *) jobp;
368 int signo = *(int *) signop;
369#ifdef RMT_WANTS_SIGNALS
370 if (job->flags & JOB_REMOTE) {
371 (void) Rmt_Signal(job, signo);
372 } else {
373 KILL(job->pid, signo);
374 }
375#else
376 /*
377 * Assume that sending the signal to job->pid will signal any remote
378 * job as well.
379 */
380 if (DEBUG(JOB)) {
381 (void) fprintf(stdout,
382 "JobCondPassSig passing signal %d to child %d.\n",
383 signo, job->pid);
384 (void) fflush(stdout);
385 }
386#if defined(USE_KLIB) && (defined(OS2) || defined(WIN32))
387 switch (signo)
388 {
389 case SIGINT:
390 kProcKill(job->pid, KPROCKILL_FLAGS_TREE | KPROCKILL_FLAGS_TYPE_INT);
391 break;
392 #ifdef SIGKILL
393 case SIGKILL:
394 #endif
395 case SIGTERM:
396 kProcKill(job->pid, KPROCKILL_FLAGS_TREE | KPROCKILL_FLAGS_TYPE_KILL);
397 break;
398 /* default: ignore signal as we don't really support it */
399 }
400#else
401 KILL(job->pid, signo);
402#endif
403#endif
404 return 0;
405}
406
407/*-
408 *-----------------------------------------------------------------------
409 * JobPassSig --
410 * Pass a signal on to all remote jobs and to all local jobs if
411 * USE_PGRP is defined, then die ourselves.
412 *
413 * Results:
414 * None.
415 *
416 * Side Effects:
417 * We die by the same signal.
418 *
419 *-----------------------------------------------------------------------
420 */
421static void
422JobPassSig(signo)
423 int signo; /* The signal number we've received */
424{
425#if defined(USE_KLIB) && (defined(OS2) || defined(WIN32))
426
427 if (DEBUG(JOB)) {
428 fprintf(stdout, "JobPassSig(%d) called.\n", signo);
429 fflush(stdout);
430 }
431 Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
432
433 /*
434 * Deal with proper cleanup based on the signal received. We only run
435 * the .INTERRUPT target if the signal was in fact an interrupt. The other
436 * three termination signals are more of a "get out *now*" command.
437 */
438 if (signo == SIGINT) {
439 JobInterrupt(TRUE, signo);
440 } else if (signo == SIGTERM) {
441 JobInterrupt(FALSE, signo);
442 }
443
444
445 if (DEBUG(JOB)) {
446 fprintf(stdout,
447 "JobPassSig passing signal to self, mask = %x.\n",
448 ~0 & ~(1 << (signo-1)));
449 fflush(stdout);
450 }
451 signal(signo, SIG_DFL);
452 raise(signo);
453
454#ifdef SIGCONT
455 signo = SIGCONT;
456 Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
457#endif
458
459
460#else /* Not KLIB + OS2/Win32 */
461 sigset_t nmask, omask;
462 struct sigaction act;
463
464
465 if (DEBUG(JOB)) {
466 (void) fprintf(stdout, "JobPassSig(%d) called.\n", signo);
467 (void) fflush(stdout);
468 }
469 Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
470
471 /*
472 * Deal with proper cleanup based on the signal received. We only run
473 * the .INTERRUPT target if the signal was in fact an interrupt. The other
474 * three termination signals are more of a "get out *now*" command.
475 */
476 if (signo == SIGINT) {
477 JobInterrupt(TRUE, signo);
478 } else if ( 0
479#ifdef SIGHUP /* not all systems supports this signal */
480 || (signo == SIGHUP)
481#endif
482 || (signo == SIGTERM)
483#ifdef SIGQUIT /* not all systems supports this signal */
484 || (signo == SIGQUIT)
485#endif
486 ) {
487 JobInterrupt(FALSE, signo);
488 }
489
490#ifdef SIGQUIT /* not all systems supports this signal */
491 /*
492 * Leave gracefully if SIGQUIT, rather than core dumping.
493 */
494 if (signo == SIGQUIT) {
495 signo = SIGINT;
496 }
497#endif
498
499#if !defined(USE_KLIB) || !(defined(OS2) || defined(WIN32))
500 /*
501 * Send ourselves the signal now we've given the message to everyone else.
502 * Note we block everything else possible while we're getting the signal.
503 * This ensures that all our jobs get continued when we wake up before
504 * we take any other signal.
505 */
506 sigemptyset(&nmask);
507 sigaddset(&nmask, signo);
508 sigprocmask(SIG_SETMASK, &nmask, &omask);
509 act.sa_handler = SIG_DFL;
510 sigemptyset(&act.sa_mask);
511 act.sa_flags = 0;
512 sigaction(signo, &act, NULL);
513#endif
514
515 if (DEBUG(JOB)) {
516 (void) fprintf(stdout,
517 "JobPassSig passing signal to self, mask = %x.\n",
518 ~0 & ~(1 << (signo-1)));
519 (void) fflush(stdout);
520 }
521 (void) signal(signo, SIG_DFL);
522
523 (void) KILL(getpid(), signo);
524
525 signo = SIGCONT;
526 Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
527
528#if !defined(USE_KLIB) || !(defined(OS2) || defined(WIN32))
529 (void) sigprocmask(SIG_SETMASK, &omask, NULL);
530 sigprocmask(SIG_SETMASK, &omask, NULL);
531 act.sa_handler = JobPassSig;
532 sigaction(signo, &act, NULL);
533#endif
534#endif /* KLIB + OS2/Win32 */
535}
536
537/*-
538 *-----------------------------------------------------------------------
539 * JobCmpPid --
540 * Compare the pid of the job with the given pid and return 0 if they
541 * are equal. This function is called from Job_CatchChildren via
542 * Lst_Find to find the job descriptor of the finished job.
543 *
544 * Results:
545 * 0 if the pid's match
546 *
547 * Side Effects:
548 * None
549 *-----------------------------------------------------------------------
550 */
551static int
552JobCmpPid(job, pid)
553 ClientData job; /* job to examine */
554 ClientData pid; /* process id desired */
555{
556 return *(int *) pid - ((Job *) job)->pid;
557}
558
559#ifdef REMOTE
560/*-
561 *-----------------------------------------------------------------------
562 * JobCmpRmtID --
563 * Compare the rmtID of the job with the given rmtID and return 0 if they
564 * are equal.
565 *
566 * Results:
567 * 0 if the rmtID's match
568 *
569 * Side Effects:
570 * None.
571 *-----------------------------------------------------------------------
572 */
573static int
574JobCmpRmtID(job, rmtID)
575 ClientData job; /* job to examine */
576 ClientData rmtID; /* remote id desired */
577{
578 return(*(int *) rmtID - *(int *) job->rmtID);
579}
580#endif
581
582/*-
583 *-----------------------------------------------------------------------
584 * JobPrintCommand --
585 * Put out another command for the given job. If the command starts
586 * with an @ or a - we process it specially. In the former case,
587 * so long as the -s and -n flags weren't given to make, we stick
588 * a shell-specific echoOff command in the script. In the latter,
589 * we ignore errors for the entire job, unless the shell has error
590 * control.
591 * If the command is just "..." we take all future commands for this
592 * job to be commands to be executed once the entire graph has been
593 * made and return non-zero to signal that the end of the commands
594 * was reached. These commands are later attached to the postCommands
595 * node and executed by Job_End when all things are done.
596 * This function is called from JobStart via Lst_ForEach.
597 *
598 * Results:
599 * Always 0, unless the command was "..."
600 *
601 * Side Effects:
602 * If the command begins with a '-' and the shell has no error control,
603 * the JOB_IGNERR flag is set in the job descriptor.
604 * If the command is "..." and we're not ignoring such things,
605 * tailCmds is set to the successor node of the cmd.
606 * numCommands is incremented if the command is actually printed.
607 *-----------------------------------------------------------------------
608 */
609static int
610JobPrintCommand(cmdp, jobp)
611 ClientData cmdp; /* command string to print */
612 ClientData jobp; /* job for which to print it */
613{
614 Boolean noSpecials; /* true if we shouldn't worry about
615 * inserting special commands into
616 * the input stream. */
617 Boolean shutUp = FALSE; /* true if we put a no echo command
618 * into the command file */
619 Boolean errOff = FALSE; /* true if we turned error checking
620 * off before printing the command
621 * and need to turn it back on */
622 char *cmdTemplate; /* Template to use when printing the
623 * command */
624 char *cmdStart; /* Start of expanded command */
625 LstNode cmdNode; /* Node for replacing the command */
626 char *cmd = (char *) cmdp;
627 Job *job = (Job *) jobp;
628
629 noSpecials = (noExecute && !(job->node->type & OP_MAKE));
630
631 if (strcmp(cmd, "...") == 0) {
632 job->node->type |= OP_SAVE_CMDS;
633 if ((job->flags & JOB_IGNDOTS) == 0) {
634 job->tailCmds = Lst_Succ(Lst_Member(job->node->commands,
635 (ClientData)cmd));
636 return 1;
637 }
638 return 0;
639 }
640
641#define DBPRINTF(fmt, arg) if (DEBUG(JOB)) { \
642 (void) fprintf(stdout, fmt, arg); \
643 (void) fflush(stdout); \
644 } \
645 (void) fprintf(job->cmdFILE, fmt, arg); \
646 (void) fflush(job->cmdFILE);
647
648 numCommands += 1;
649
650 /*
651 * For debugging, we replace each command with the result of expanding
652 * the variables in the command.
653 */
654 cmdNode = Lst_Member(job->node->commands, (ClientData)cmd);
655 cmdStart = cmd = Var_Subst(NULL, cmd, job->node, FALSE);
656 Lst_Replace(cmdNode, (ClientData)cmdStart);
657
658 cmdTemplate = "%s\n";
659
660 /*
661 * Check for leading @' and -'s to control echoing and error checking.
662 */
663 while (*cmd == '@' || *cmd == '-') {
664 if (*cmd == '@') {
665 shutUp = DEBUG(LOUD) ? FALSE : TRUE;
666 } else {
667 errOff = TRUE;
668 }
669 cmd++;
670 }
671
672 while (isspace((unsigned char) *cmd))
673 cmd++;
674
675 #ifndef KMK
676 if (shutUp) {
677 if (!(job->flags & JOB_SILENT) && !noSpecials &&
678 commandShell->hasEchoCtl) {
679 DBPRINTF("%s\n", commandShell->echoOff);
680 } else {
681 shutUp = FALSE;
682 }
683 }
684 #endif
685
686 if (errOff) {
687 if ( !(job->flags & JOB_IGNERR) && !noSpecials) {
688 #ifdef KMK
689 errOff = FALSE;
690 #else
691 if (commandShell->hasErrCtl) {
692 /*
693 * we don't want the error-control commands showing
694 * up either, so we turn off echoing while executing
695 * them. We could put another field in the shell
696 * structure to tell JobDoOutput to look for this
697 * string too, but why make it any more complex than
698 * it already is?
699 */
700 if (!(job->flags & JOB_SILENT) && !shutUp &&
701 commandShell->hasEchoCtl) {
702 DBPRINTF("%s\n", commandShell->echoOff);
703 DBPRINTF("%s\n", commandShell->ignErr);
704 DBPRINTF("%s\n", commandShell->echoOn);
705 } else {
706 DBPRINTF("%s\n", commandShell->ignErr);
707 }
708 } else if (commandShell->ignErr &&
709 (*commandShell->ignErr != '\0'))
710 {
711 /*
712 * The shell has no error control, so we need to be
713 * weird to get it to ignore any errors from the command.
714 * If echoing is turned on, we turn it off and use the
715 * errCheck template to echo the command. Leave echoing
716 * off so the user doesn't see the weirdness we go through
717 * to ignore errors. Set cmdTemplate to use the weirdness
718 * instead of the simple "%s\n" template.
719 */
720 if (!(job->flags & JOB_SILENT) && !shutUp &&
721 commandShell->hasEchoCtl) {
722 DBPRINTF("%s\n", commandShell->echoOff);
723 DBPRINTF(commandShell->errCheck, cmd);
724 shutUp = TRUE;
725 }
726 cmdTemplate = commandShell->ignErr;
727 /*
728 * The error ignoration (hee hee) is already taken care
729 * of by the ignErr template, so pretend error checking
730 * is still on.
731 */
732 errOff = FALSE;
733 } else {
734 errOff = FALSE;
735 }
736 #endif
737 } else {
738 errOff = FALSE;
739 }
740 }
741
742 DBPRINTF(cmdTemplate, cmd);
743
744 #ifndef KMK /*todo*/
745 if (errOff) {
746 /*
747 * If echoing is already off, there's no point in issuing the
748 * echoOff command. Otherwise we issue it and pretend it was on
749 * for the whole command...
750 */
751 if (!shutUp && !(job->flags & JOB_SILENT) && commandShell->hasEchoCtl){
752 DBPRINTF("%s\n", commandShell->echoOff);
753 shutUp = TRUE;
754 }
755 DBPRINTF("%s\n", commandShell->errCheck);
756 }
757 if (shutUp) {
758 DBPRINTF("%s\n", commandShell->echoOn);
759 }
760 #endif
761 return 0;
762}
763
764/*-
765 *-----------------------------------------------------------------------
766 * JobSaveCommand --
767 * Save a command to be executed when everything else is done.
768 * Callback function for JobFinish...
769 *
770 * Results:
771 * Always returns 0
772 *
773 * Side Effects:
774 * The command is tacked onto the end of postCommands's commands list.
775 *
776 *-----------------------------------------------------------------------
777 */
778static int
779JobSaveCommand(cmd, gn)
780 ClientData cmd;
781 ClientData gn;
782{
783 cmd = (ClientData) Var_Subst(NULL, (char *) cmd, (GNode *) gn, FALSE);
784 (void) Lst_AtEnd(postCommands->commands, cmd);
785 return(0);
786}
787
788
789/*-
790 *-----------------------------------------------------------------------
791 * JobClose --
792 * Called to close both input and output pipes when a job is finished.
793 *
794 * Results:
795 * Nada
796 *
797 * Side Effects:
798 * The file descriptors associated with the job are closed.
799 *
800 *-----------------------------------------------------------------------
801 */
802static void
803JobClose(job)
804 Job *job;
805{
806#ifdef USE_PIPES
807 if (usePipes) {
808#ifdef RMT_WILL_WATCH
809 Rmt_Ignore(job->inPipe);
810#else
811 FD_CLR(job->inPipe, &outputs);
812#endif
813 if (job->outPipe != job->inPipe) {
814 (void) close(job->outPipe);
815 }
816 JobDoOutput(job, TRUE);
817 (void) close(job->inPipe);
818 } else {
819 (void) close(job->outFd);
820 JobDoOutput(job, TRUE);
821 }
822
823#else /* Don't use Pipes */
824 close(job->outFd);
825 JobDoOutput(job, TRUE);
826#endif /* USE_PIPES */
827}
828
829/*-
830 *-----------------------------------------------------------------------
831 * JobFinish --
832 * Do final processing for the given job including updating
833 * parents and starting new jobs as available/necessary. Note
834 * that we pay no attention to the JOB_IGNERR flag here.
835 * This is because when we're called because of a noexecute flag
836 * or something, jstat.w_status is 0 and when called from
837 * Job_CatchChildren, the status is zeroed if it s/b ignored.
838 *
839 * Results:
840 * None
841 *
842 * Side Effects:
843 * Some nodes may be put on the toBeMade queue.
844 * Final commands for the job are placed on postCommands.
845 *
846 * If we got an error and are aborting (aborting == ABORT_ERROR) and
847 * the job list is now empty, we are done for the day.
848 * If we recognized an error (errors !=0), we set the aborting flag
849 * to ABORT_ERROR so no more jobs will be started.
850 *-----------------------------------------------------------------------
851 */
852/*ARGSUSED*/
853static void
854JobFinish(job, status)
855 Job *job; /* job to finish */
856#ifdef USE_KLIB
857 KPROCRES *status; /* sub-why job went away */
858#else
859 int *status; /* sub-why job went away */
860#endif
861{
862#ifdef USE_KLIB
863 Boolean done;
864
865 if ( ( (status->fFlags & KPROCRES_FLAGS_NORMAL) && status->uExitCode != 0 && !(job->flags & JOB_IGNERR) )
866 || !(status->fFlags & KPROCRES_FLAGS_NORMAL)
867 )
868 {
869 /*
870 * If it exited non-zero and either we're doing things our
871 * way or we're not ignoring errors, the job is finished.
872 * Similarly, if the shell died because of a signal
873 * the job is also finished. In these
874 * cases, finish out the job's output before printing the exit
875 * status...
876 */
877 JobClose(job);
878 if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
879 (void) fclose(job->cmdFILE);
880 job->cmdFILE = NULL;
881 }
882 done = TRUE;
883 } else if (status->fFlags & KPROCRES_FLAGS_NORMAL) {
884 /*
885 * Deal with ignored errors in -B mode. We need to print a message
886 * telling of the ignored error as well as setting status.w_status
887 * to 0 so the next command gets run. To do this, we set done to be
888 * TRUE if in -B mode and the job exited non-zero.
889 */
890 done = status->uExitCode != 0;
891 /*
892 * Old comment said: "Note we don't
893 * want to close down any of the streams until we know we're at the
894 * end."
895 * But we do. Otherwise when are we going to print the rest of the
896 * stuff?
897 */
898 JobClose(job);
899 } else {
900 /*
901 * No need to close things down or anything.
902 */
903 done = FALSE;
904 }
905
906 if ( done
907 || DEBUG(JOB))
908 {
909 FILE *out = stdout;
910 if (compatMake && !usePipes && (job->flags & JOB_IGNERR))
911 {
912 /*
913 * If output is going to a file and this job is ignoring
914 * errors, arrange to have the exit status sent to the
915 * output file as well.
916 */
917 out = fdopen(job->outFd, "w");
918 }
919
920 if (status->fFlags & KPROCRES_FLAGS_NORMAL)
921 {
922 if (DEBUG(JOB))
923 {
924 fprintf(stdout, "Process %d exited.\n", job->pid);
925 fflush(stdout);
926 }
927 if (status->uExitCode != 0)
928 {
929#ifdef USE_PIPES
930 if (usePipes && job->node != lastNode)
931 {
932 MESSAGE(out, job->node);
933 lastNode = job->node;
934 }
935#endif
936 fprintf(out, "*** Error code %d%s\n",
937 status->uExitCode,
938 (job->flags & JOB_IGNERR) ? "(ignored)" : "");
939
940 if (job->flags & JOB_IGNERR)
941 status->uExitCode = 0;
942 }
943 else if (DEBUG(JOB))
944 {
945#ifdef USE_PIPES
946 if (usePipes && job->node != lastNode)
947 {
948 MESSAGE(out, job->node);
949 lastNode = job->node;
950 }
951#endif
952 fprintf(out, "*** Completed successfully\n");
953 }
954 }
955 else
956 {
957#ifdef USE_PIPES
958 if (usePipes && job->node != lastNode)
959 {
960 MESSAGE(out, job->node);
961 lastNode = job->node;
962 }
963#endif
964 fprintf(out, "*** Abnormal End\n");
965 }
966
967 fflush(out);
968 }
969
970 /*
971 * Now handle the -B-mode stuff. If the beast still isn't finished,
972 * try and restart the job on the next command. If JobStart says it's
973 * ok, it's ok. If there's an error, this puppy is done.
974 */
975 if ( compatMake
976 && (status->fFlags & KPROCRES_FLAGS_NORMAL)
977 && !Lst_IsAtEnd(job->node->commands)
978 )
979 {
980 switch (JobStart(job->node, job->flags & JOB_IGNDOTS, job))
981 {
982 case JOB_RUNNING:
983 done = FALSE;
984 break;
985 case JOB_ERROR:
986 done = TRUE;
987 status->uExitCode = EXIT_FAILURE;
988 break;
989 case JOB_FINISHED:
990 /*
991 * If we got back a JOB_FINISHED code, JobStart has already
992 * called Make_Update and freed the job descriptor. We set
993 * done to false here to avoid fake cycles and double frees.
994 * JobStart needs to do the update so we can proceed up the
995 * graph when given the -n flag..
996 */
997 done = FALSE;
998 break;
999 }
1000 } else {
1001 done = TRUE;
1002 }
1003
1004
1005 if ( done
1006 && aborting != ABORT_ERROR
1007 && aborting != ABORT_INTERRUPT
1008 && (status->fFlags & KPROCRES_FLAGS_NORMAL)
1009 && status->uExitCode == 0
1010 )
1011 {
1012 /*
1013 * As long as we aren't aborting and the job didn't return a non-zero
1014 * status that we shouldn't ignore, we call Make_Update to update
1015 * the parents. In addition, any saved commands for the node are placed
1016 * on the .END target.
1017 */
1018 if (job->tailCmds != NILLNODE) {
1019 Lst_ForEachFrom(job->node->commands, job->tailCmds,
1020 JobSaveCommand,
1021 (ClientData)job->node);
1022 }
1023 job->node->made = MADE;
1024 Make_Update(job->node);
1025 efree((Address)job);
1026 }
1027 else if (!(status->fFlags & KPROCRES_FLAGS_NORMAL) || status->uExitCode != 0)
1028 {
1029 errors += 1;
1030 efree((Address)job);
1031 }
1032
1033 /*
1034 * Set aborting if any error.
1035 */
1036 if (errors && !keepgoing && (aborting != ABORT_INTERRUPT))
1037 {
1038 /*
1039 * If we found any errors in this batch of children and the -k flag
1040 * wasn't given, we set the aborting flag so no more jobs get
1041 * started.
1042 */
1043 aborting = ABORT_ERROR;
1044 }
1045
1046 if ((aborting == ABORT_ERROR) && Job_Empty())
1047 {
1048 /*
1049 * If we are aborting and the job table is now empty, we finish.
1050 */
1051 Finish(errors);
1052 }
1053
1054
1055#else /* Don't use kLib */
1056 Boolean done;
1057
1058 if ((WIFEXITED(*status) &&
1059 (((WEXITSTATUS(*status) != 0) && !(job->flags & JOB_IGNERR)))) ||
1060 (WIFSIGNALED(*status) && (WTERMSIG(*status) != SIGCONT)))
1061 {
1062 /*
1063 * If it exited non-zero and either we're doing things our
1064 * way or we're not ignoring errors, the job is finished.
1065 * Similarly, if the shell died because of a signal
1066 * the job is also finished. In these
1067 * cases, finish out the job's output before printing the exit
1068 * status...
1069 */
1070#ifdef REMOTE
1071 KILL(job->pid, SIGCONT);
1072#endif
1073 JobClose(job);
1074 if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
1075 (void) fclose(job->cmdFILE);
1076 }
1077 done = TRUE;
1078#ifdef REMOTE
1079 if (job->flags & JOB_REMOTE)
1080 Rmt_Done(job->rmtID, job->node);
1081#endif
1082 } else if (WIFEXITED(*status)) {
1083 /*
1084 * Deal with ignored errors in -B mode. We need to print a message
1085 * telling of the ignored error as well as setting status.w_status
1086 * to 0 so the next command gets run. To do this, we set done to be
1087 * TRUE if in -B mode and the job exited non-zero.
1088 */
1089 done = WEXITSTATUS(*status) != 0;
1090 /*
1091 * Old comment said: "Note we don't
1092 * want to close down any of the streams until we know we're at the
1093 * end."
1094 * But we do. Otherwise when are we going to print the rest of the
1095 * stuff?
1096 */
1097 JobClose(job);
1098#ifdef REMOTE
1099 if (job->flags & JOB_REMOTE)
1100 Rmt_Done(job->rmtID, job->node);
1101#endif /* REMOTE */
1102 } else {
1103 /*
1104 * No need to close things down or anything.
1105 */
1106 done = FALSE;
1107 }
1108
1109 if (done ||
1110 WIFSTOPPED(*status) ||
1111 (WIFSIGNALED(*status) && (WTERMSIG(*status) == SIGCONT)) ||
1112 DEBUG(JOB))
1113 {
1114 FILE *out;
1115
1116 if (compatMake && !usePipes && (job->flags & JOB_IGNERR)) {
1117 /*
1118 * If output is going to a file and this job is ignoring
1119 * errors, arrange to have the exit status sent to the
1120 * output file as well.
1121 */
1122 out = fdopen(job->outFd, "w");
1123 } else {
1124 out = stdout;
1125 }
1126
1127 if (WIFEXITED(*status)) {
1128 if (DEBUG(JOB)) {
1129 (void) fprintf(stdout, "Process %d exited.\n", job->pid);
1130 (void) fflush(stdout);
1131 }
1132 if (WEXITSTATUS(*status) != 0) {
1133#ifdef USE_PIPES
1134 if (usePipes && job->node != lastNode) {
1135 MESSAGE(out, job->node);
1136 lastNode = job->node;
1137 }
1138#endif
1139 (void) fprintf(out, "*** Error code %d%s\n",
1140 WEXITSTATUS(*status),
1141 (job->flags & JOB_IGNERR) ? "(ignored)" : "");
1142
1143 if (job->flags & JOB_IGNERR) {
1144 *status = 0;
1145 }
1146 } else if (DEBUG(JOB)) {
1147#ifdef USE_PIPES
1148 if (usePipes && job->node != lastNode) {
1149 MESSAGE(out, job->node);
1150 lastNode = job->node;
1151 }
1152#endif
1153 (void) fprintf(out, "*** Completed successfully\n");
1154 }
1155 } else if (WIFSTOPPED(*status)) {
1156 if (DEBUG(JOB)) {
1157 (void) fprintf(stdout, "Process %d stopped.\n", job->pid);
1158 (void) fflush(stdout);
1159 }
1160#ifdef USE_PIPES
1161 if (usePipes && job->node != lastNode) {
1162 MESSAGE(out, job->node);
1163 lastNode = job->node;
1164 }
1165#endif
1166 if (!(job->flags & JOB_REMIGRATE)) {
1167 (void) fprintf(out, "*** Stopped -- signal %d\n",
1168 WSTOPSIG(*status));
1169 }
1170 job->flags |= JOB_RESUME;
1171 (void)Lst_AtEnd(stoppedJobs, (ClientData)job);
1172#if defined(REMOTE) && defined(SIGCONT)
1173 if (job->flags & JOB_REMIGRATE)
1174 JobRestart(job);
1175#endif
1176 (void) fflush(out);
1177 return;
1178 } else if (WTERMSIG(*status) == SIGCONT) {
1179 /*
1180 * If the beastie has continued, shift the Job from the stopped
1181 * list to the running one (or re-stop it if concurrency is
1182 * exceeded) and go and get another child.
1183 */
1184 if (job->flags & (JOB_RESUME|JOB_REMIGRATE|JOB_RESTART)) {
1185#ifdef USE_PIPES
1186 if (usePipes && job->node != lastNode) {
1187 MESSAGE(out, job->node);
1188 lastNode = job->node;
1189 }
1190#endif
1191 (void) fprintf(out, "*** Continued\n");
1192 }
1193 if (!(job->flags & JOB_CONTINUING)) {
1194 if (DEBUG(JOB)) {
1195 (void) fprintf(stdout,
1196 "Warning: process %d was not continuing.\n",
1197 job->pid);
1198 (void) fflush(stdout);
1199 }
1200#ifdef SIGCONT
1201#ifdef notdef
1202 /*
1203 * We don't really want to restart a job from scratch just
1204 * because it continued, especially not without killing the
1205 * continuing process! That's why this is ifdef'ed out.
1206 * FD - 9/17/90
1207 */
1208 JobRestart(job);
1209#endif
1210#endif
1211 }
1212 job->flags &= ~JOB_CONTINUING;
1213 Lst_AtEnd(jobs, (ClientData)job);
1214 nJobs += 1;
1215 if (!(job->flags & JOB_REMOTE)) {
1216 if (DEBUG(JOB)) {
1217 (void) fprintf(stdout,
1218 "Process %d is continuing locally.\n",
1219 job->pid);
1220 (void) fflush(stdout);
1221 }
1222 nLocal += 1;
1223 }
1224 if (nJobs == maxJobs) {
1225 jobFull = TRUE;
1226 if (DEBUG(JOB)) {
1227 (void) fprintf(stdout, "Job queue is full.\n");
1228 (void) fflush(stdout);
1229 }
1230 }
1231 (void) fflush(out);
1232 return;
1233 } else {
1234#ifdef USE_PIPES
1235 if (usePipes && job->node != lastNode) {
1236 MESSAGE(out, job->node);
1237 lastNode = job->node;
1238 }
1239#endif
1240 (void) fprintf(out, "*** Signal %d\n", WTERMSIG(*status));
1241 }
1242
1243 (void) fflush(out);
1244 }
1245
1246 /*
1247 * Now handle the -B-mode stuff. If the beast still isn't finished,
1248 * try and restart the job on the next command. If JobStart says it's
1249 * ok, it's ok. If there's an error, this puppy is done.
1250 */
1251 if (compatMake && (WIFEXITED(*status) &&
1252 !Lst_IsAtEnd(job->node->commands))) {
1253 switch (JobStart(job->node, job->flags & JOB_IGNDOTS, job)) {
1254 case JOB_RUNNING:
1255 done = FALSE;
1256 break;
1257 case JOB_ERROR:
1258 done = TRUE;
1259 W_SETEXITSTATUS(status, 1);
1260 break;
1261 case JOB_FINISHED:
1262 /*
1263 * If we got back a JOB_FINISHED code, JobStart has already
1264 * called Make_Update and freed the job descriptor. We set
1265 * done to false here to avoid fake cycles and double frees.
1266 * JobStart needs to do the update so we can proceed up the
1267 * graph when given the -n flag..
1268 */
1269 done = FALSE;
1270 break;
1271 }
1272 } else {
1273 done = TRUE;
1274 }
1275
1276
1277 if (done &&
1278 (aborting != ABORT_ERROR) &&
1279 (aborting != ABORT_INTERRUPT) &&
1280 (*status == 0))
1281 {
1282 /*
1283 * As long as we aren't aborting and the job didn't return a non-zero
1284 * status that we shouldn't ignore, we call Make_Update to update
1285 * the parents. In addition, any saved commands for the node are placed
1286 * on the .END target.
1287 */
1288 if (job->tailCmds != NILLNODE) {
1289 Lst_ForEachFrom(job->node->commands, job->tailCmds,
1290 JobSaveCommand,
1291 (ClientData)job->node);
1292 }
1293 job->node->made = MADE;
1294 Make_Update(job->node);
1295 efree((Address)job);
1296 } else if (*status != 0) {
1297 errors += 1;
1298 efree((Address)job);
1299 }
1300
1301#ifdef SIGCONT
1302 JobRestartJobs();
1303#endif
1304
1305 /*
1306 * Set aborting if any error.
1307 */
1308 if (errors && !keepgoing && (aborting != ABORT_INTERRUPT)) {
1309 /*
1310 * If we found any errors in this batch of children and the -k flag
1311 * wasn't given, we set the aborting flag so no more jobs get
1312 * started.
1313 */
1314 aborting = ABORT_ERROR;
1315 }
1316
1317 if ((aborting == ABORT_ERROR) && Job_Empty())
1318 /*
1319 * If we are aborting and the job table is now empty, we finish.
1320 */
1321 Finish(errors);
1322#endif /* USE_KLIB */
1323}
1324
1325/*-
1326 *-----------------------------------------------------------------------
1327 * Job_Touch --
1328 * Touch the given target. Called by JobStart when the -t flag was
1329 * given
1330 *
1331 * Results:
1332 * None
1333 *
1334 * Side Effects:
1335 * The data modification of the file is changed. In addition, if the
1336 * file did not exist, it is created.
1337 *-----------------------------------------------------------------------
1338 */
1339void
1340Job_Touch(gn, silent)
1341 GNode *gn; /* the node of the file to touch */
1342 Boolean silent; /* TRUE if should not print messages */
1343{
1344 int streamID; /* ID of stream opened to do the touch */
1345 struct utimbuf times; /* Times for utime() call */
1346
1347 if (gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_OPTIONAL)) {
1348 /*
1349 * .JOIN, .USE, .ZEROTIME and .OPTIONAL targets are "virtual" targets
1350 * and, as such, shouldn't really be created.
1351 */
1352 return;
1353 }
1354
1355 if (!silent) {
1356 (void) fprintf(stdout, "touch %s\n", gn->name);
1357 (void) fflush(stdout);
1358 }
1359
1360 if (noExecute) {
1361 return;
1362 }
1363
1364#ifdef USE_ARCHIVES
1365 if (gn->type & OP_ARCHV) {
1366 Arch_Touch(gn);
1367 } else if (gn->type & OP_LIB) {
1368 Arch_TouchLib(gn);
1369 } else {
1370#else
1371 {
1372#endif
1373
1374 char *file = gn->path ? gn->path : gn->name;
1375
1376 times.actime = times.modtime = now;
1377 if (utime(file, &times) < 0){
1378 streamID = open(file, O_RDWR | O_CREAT, 0666);
1379
1380 if (streamID >= 0) {
1381 char c;
1382
1383 /*
1384 * Read and write a byte to the file to change the
1385 * modification time, then close the file.
1386 */
1387 if (read(streamID, &c, 1) == 1) {
1388 (void) lseek(streamID, 0L, SEEK_SET);
1389 (void) write(streamID, &c, 1);
1390 }
1391
1392 (void) close(streamID);
1393 } else {
1394 (void) fprintf(stdout, "*** couldn't touch %s: %s",
1395 file, strerror(errno));
1396 (void) fflush(stdout);
1397 }
1398 }
1399 }
1400}
1401
1402/*-
1403 *-----------------------------------------------------------------------
1404 * Job_CheckCommands --
1405 * Make sure the given node has all the commands it needs.
1406 *
1407 * Results:
1408 * TRUE if the commands list is/was ok.
1409 *
1410 * Side Effects:
1411 * The node will have commands from the .DEFAULT rule added to it
1412 * if it needs them.
1413 *-----------------------------------------------------------------------
1414 */
1415Boolean
1416Job_CheckCommands(gn, abortProc)
1417 GNode *gn; /* The target whose commands need
1418 * verifying */
1419 void (*abortProc) __P((char *, ...));
1420 /* Function to abort with message */
1421{
1422 if (OP_NOP(gn->type) && Lst_IsEmpty(gn->commands)
1423#ifdef USE_ARCHIVES
1424 && (gn->type & OP_LIB) == 0
1425#endif
1426 )
1427 {
1428 /*
1429 * No commands. Look for .DEFAULT rule from which we might infer
1430 * commands
1431 */
1432 if ((DEFAULT != NILGNODE) && !Lst_IsEmpty(DEFAULT->commands)) {
1433 char *p1;
1434 /*
1435 * Make only looks for a .DEFAULT if the node was never the
1436 * target of an operator, so that's what we do too. If
1437 * a .DEFAULT was given, we substitute its commands for gn's
1438 * commands and set the IMPSRC variable to be the target's name
1439 * The DEFAULT node acts like a transformation rule, in that
1440 * gn also inherits any attributes or sources attached to
1441 * .DEFAULT itself.
1442 */
1443 Make_HandleUse(DEFAULT, gn);
1444 Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), gn);
1445 efree(p1);
1446 } else if (Dir_MTime(gn) == 0) {
1447 /*
1448 * The node wasn't the target of an operator we have no .DEFAULT
1449 * rule to go on and the target doesn't already exist. There's
1450 * nothing more we can do for this branch. If the -k flag wasn't
1451 * given, we stop in our tracks, otherwise we just don't update
1452 * this node's parents so they never get examined.
1453 */
1454 static const char msg[] = MAKE_NAME ": don't know how to make";
1455
1456 if (gn->type & OP_OPTIONAL) {
1457 (void) fprintf(stdout, "%s %s(ignored)\n", msg, gn->name);
1458 (void) fflush(stdout);
1459 } else if (keepgoing) {
1460 (void) fprintf(stdout, "%s %s(continuing)\n", msg, gn->name);
1461 (void) fflush(stdout);
1462 return FALSE;
1463 } else {
1464#if OLD_JOKE
1465 if (strcmp(gn->name,"love") == 0)
1466 (*abortProc)("Not war.");
1467#if defined(NMAKE) || defined(KMK)
1468 else if (strcmp(gn->name,"fire") == 0)
1469 (*abortProc)("No match.");
1470#endif
1471 else
1472#endif
1473 (*abortProc)("%s %s. Stop", msg, gn->name);
1474 return FALSE;
1475 }
1476 }
1477 }
1478 return TRUE;
1479}
1480#ifdef RMT_WILL_WATCH
1481/*-
1482 *-----------------------------------------------------------------------
1483 * JobLocalInput --
1484 * Handle a pipe becoming readable. Callback function for Rmt_Watch
1485 *
1486 * Results:
1487 * None
1488 *
1489 * Side Effects:
1490 * JobDoOutput is called.
1491 *
1492 *-----------------------------------------------------------------------
1493 */
1494/*ARGSUSED*/
1495static void
1496JobLocalInput(stream, job)
1497 int stream; /* Stream that's ready (ignored) */
1498 Job *job; /* Job to which the stream belongs */
1499{
1500 JobDoOutput(job, FALSE);
1501}
1502#endif /* RMT_WILL_WATCH */
1503
1504/*-
1505 *-----------------------------------------------------------------------
1506 * JobExec --
1507 * Execute the shell for the given job. Called from JobStart and
1508 * JobRestart.
1509 *
1510 * Results:
1511 * None.
1512 *
1513 * Side Effects:
1514 * A shell is executed, outputs is altered and the Job structure added
1515 * to the job table.
1516 *
1517 *-----------------------------------------------------------------------
1518 */
1519static void
1520JobExec(job, argv)
1521 Job *job; /* Job to execute */
1522 char **argv;
1523{
1524#ifdef USE_KLIB
1525 int cpid; /* ID of new child */
1526 int rc;
1527
1528 if (DEBUG(JOB))
1529 {
1530 int i;
1531 fprintf(stdout, "Running %s %sly\n", job->node->name,
1532 job->flags&JOB_REMOTE?"remote":"local");
1533 fprintf(stdout, "\tCommand: ");
1534 for (i = 0; argv[i] != NULL; i++)
1535 fprintf(stdout, "%s ", argv[i]);
1536 fprintf(stdout, "\n");
1537 fflush(stdout);
1538 }
1539
1540 /*
1541 * Some jobs produce no output and it's disconcerting to have
1542 * no feedback of their running (since they produce no output, the
1543 * banner with their name in it never appears). This is an attempt to
1544 * provide that feedback, even if nothing follows it.
1545 */
1546 if ( lastNode != job->node
1547 && (job->flags & JOB_FIRST)
1548 && !(job->flags & JOB_SILENT)
1549 )
1550 {
1551 MESSAGE(stdout, job->node);
1552 lastNode = job->node;
1553 }
1554
1555 /*
1556 * Create process with assigned output+stderr pipe.
1557 */
1558 if (job->cmdFILE)
1559 fseek(job->cmdFILE, 0, SEEK_SET);
1560 rc = kProcCreate(argv,
1561 NULL,
1562 NULL,
1563 NULL,
1564 KPROCCREATE_FLAGS_SPAWN,
1565 job->cmdFILE ? FILENO(job->cmdFILE) : KFILE_NULL,
1566 usePipes ? job->outPipe : job->outFd, /* stdout */
1567 usePipes ? job->outPipe : job->outFd, /* stderr */
1568 &cpid,
1569 NULL);
1570 if (!rc)
1571 {
1572 job->pid = cpid;
1573
1574#ifdef USE_PIPES
1575 if (usePipes && (job->flags & JOB_FIRST) )
1576 {
1577 /*
1578 * The first time a job is run for a node, we set the current
1579 * position in the buffer to the beginning and mark another
1580 * stream to watch in the outputs mask
1581 */
1582 job->curPos = 0;
1583 FD_SET(job->inPipe, &outputs);
1584 }
1585#endif /* USE_PIPES */
1586
1587 if (job->flags & JOB_REMOTE) {
1588 job->rmtID = 0;
1589 } else {
1590 nLocal += 1;
1591 /*
1592 * XXX: Used to not happen if REMOTE. Why?
1593 */
1594 if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
1595 fclose(job->cmdFILE);
1596 job->cmdFILE = NULL;
1597 }
1598 }
1599
1600 /*
1601 * Now the job is actually running, add it to the table.
1602 */
1603 nJobs += 1;
1604 (void) Lst_AtEnd(jobs, (ClientData)job);
1605 if (nJobs == maxJobs)
1606 {
1607 jobFull = TRUE;
1608 }
1609 }
1610 else
1611 Punt("Cannot start child (%d)", rc);
1612
1613
1614
1615#else /* Don't use kLib */
1616 int cpid; /* ID of new child */
1617
1618 if (DEBUG(JOB)) {
1619 int i;
1620
1621 (void) fprintf(stdout, "Running %s %sly\n", job->node->name,
1622 job->flags&JOB_REMOTE?"remote":"local");
1623 (void) fprintf(stdout, "\tCommand: ");
1624 for (i = 0; argv[i] != NULL; i++) {
1625 (void) fprintf(stdout, "%s ", argv[i]);
1626 }
1627 (void) fprintf(stdout, "\n");
1628 (void) fflush(stdout);
1629 }
1630
1631 /*
1632 * Some jobs produce no output and it's disconcerting to have
1633 * no feedback of their running (since they produce no output, the
1634 * banner with their name in it never appears). This is an attempt to
1635 * provide that feedback, even if nothing follows it.
1636 */
1637 if ((lastNode != job->node) && (job->flags & JOB_FIRST) &&
1638 !(job->flags & JOB_SILENT)) {
1639 MESSAGE(stdout, job->node);
1640 lastNode = job->node;
1641 }
1642
1643#ifdef RMT_NO_EXEC
1644 if (job->flags & JOB_REMOTE) {
1645 goto jobExecFinish;
1646 }
1647#endif /* RMT_NO_EXEC */
1648
1649#ifdef __EMX__
1650 if ((cpid = fork()) == -1) {
1651#else
1652 if ((cpid = vfork()) == -1) {
1653#endif
1654 Punt("Cannot fork");
1655 } else if (cpid == 0) {
1656
1657 /*
1658 * Must duplicate the input stream down to the child's input and
1659 * reset it to the beginning (again). Since the stream was marked
1660 * close-on-exec, we must clear that bit in the new input.
1661 */
1662 if (dup2(FILENO(job->cmdFILE), 0) == -1)
1663 Punt("Cannot dup2: %s", strerror(errno));
1664 (void) fcntl(0, F_SETFD, 0);
1665 (void) lseek(0, 0, SEEK_SET);
1666
1667 if (usePipes) {
1668 /*
1669 * Set up the child's output to be routed through the pipe
1670 * we've created for it.
1671 */
1672 if (dup2(job->outPipe, STDOUT_FILENO) == -1)
1673 Punt("Cannot dup2: %s", strerror(errno));
1674 } else {
1675 /*
1676 * We're capturing output in a file, so we duplicate the
1677 * descriptor to the temporary file into the standard
1678 * output.
1679 */
1680 if (dup2(job->outFd, STDOUT_FILENO) == -1)
1681 Punt("Cannot dup2: %s", strerror(errno));
1682 }
1683 /*
1684 * The output channels are marked close on exec. This bit was
1685 * duplicated by the dup2 (on some systems), so we have to clear
1686 * it before routing the shell's error output to the same place as
1687 * its standard output.
1688 */
1689 (void) fcntl(1, F_SETFD, 0);
1690 if (dup2(STDOUT_FILENO, STDERR_FILENO) == -1)
1691 Punt("Cannot dup2: %s", strerror(errno));
1692
1693#ifdef USE_PGRP
1694 /*
1695 * We want to switch the child into a different process family so
1696 * we can kill it and all its descendants in one fell swoop,
1697 * by killing its process family, but not commit suicide.
1698 */
1699# if defined(SYSV)
1700 (void) setsid();
1701# else
1702 (void) setpgid(0, getpid());
1703# endif
1704#endif /* USE_PGRP */
1705
1706#ifdef REMOTE
1707 if (job->flags & JOB_REMOTE) {
1708 Rmt_Exec(shellPath, argv, FALSE);
1709 } else
1710#endif /* REMOTE */
1711#ifdef KMK
1712 (void) execv(argv[0], argv);
1713#else
1714 (void) execv(shellPath, argv);
1715#endif
1716
1717 (void) write(2, "Could not execute shell\n",
1718 sizeof("Could not execute shell"));
1719 _exit(1);
1720 } else {
1721#ifdef REMOTE
1722 long omask = sigblock(sigmask(SIGCHLD));
1723#endif
1724 job->pid = cpid;
1725
1726#ifdef USE_PIPES
1727 if (usePipes && (job->flags & JOB_FIRST) ) {
1728 /*
1729 * The first time a job is run for a node, we set the current
1730 * position in the buffer to the beginning and mark another
1731 * stream to watch in the outputs mask
1732 */
1733 job->curPos = 0;
1734
1735#ifdef RMT_WILL_WATCH
1736 Rmt_Watch(job->inPipe, JobLocalInput, job);
1737#else
1738 FD_SET(job->inPipe, &outputs);
1739#endif /* RMT_WILL_WATCH */
1740 }
1741#endif /* USE_PIPES */
1742
1743 if (job->flags & JOB_REMOTE) {
1744#ifndef REMOTE
1745 job->rmtID = 0;
1746#else
1747 job->rmtID = Rmt_LastID(job->pid);
1748#endif /* REMOTE */
1749 } else {
1750 nLocal += 1;
1751 /*
1752 * XXX: Used to not happen if REMOTE. Why?
1753 */
1754 if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
1755 (void) fclose(job->cmdFILE);
1756 job->cmdFILE = NULL;
1757 }
1758 }
1759#ifdef REMOTE
1760 (void) sigsetmask(omask);
1761#endif
1762 }
1763
1764#ifdef RMT_NO_EXEC
1765jobExecFinish:
1766#endif
1767 /*
1768 * Now the job is actually running, add it to the table.
1769 */
1770 nJobs += 1;
1771 (void) Lst_AtEnd(jobs, (ClientData)job);
1772 if (nJobs == maxJobs) {
1773 jobFull = TRUE;
1774 }
1775#endif /* USE_KLIB */
1776}
1777
1778
1779/*-
1780 *-----------------------------------------------------------------------
1781 * JobMakeArgv --
1782 * Create the argv needed to execute the shell for a given job.
1783 *
1784 *
1785 * Results:
1786 *
1787 * Side Effects:
1788 *
1789 *-----------------------------------------------------------------------
1790 */
1791static void
1792JobMakeArgv(job, argv)
1793 Job *job;
1794 char **argv;
1795{
1796#ifdef KMK
1797 int argc;
1798
1799 argv[0] = argv0;
1800 argv[1] = "--kShell";
1801 argc = 2;
1802 if (!(job->flags & JOB_IGNERR))
1803 argv[argc++] = "-e";
1804 if (!(job->flags & JOB_SILENT))
1805 argv[argc++] = "-v";
1806 argv[argc] = NULL;
1807
1808#else /* not kMk */
1809 int argc;
1810 static char args[10]; /* For merged arguments */
1811
1812 argv[0] = shellName;
1813 argc = 1;
1814
1815 if ((commandShell->exit && (*commandShell->exit != '-')) ||
1816 (commandShell->echo && (*commandShell->echo != '-')))
1817 {
1818 /*
1819 * At least one of the flags doesn't have a minus before it, so
1820 * merge them together. Have to do this because the *(&(@*#*&#$#
1821 * Bourne shell thinks its second argument is a file to source.
1822 * Grrrr. Note the ten-character limitation on the combined arguments.
1823 */
1824 (void)sprintf(args, "-%s%s",
1825 ((job->flags & JOB_IGNERR) ? "" :
1826 (commandShell->exit ? commandShell->exit : "")),
1827 ((job->flags & JOB_SILENT) ? "" :
1828 (commandShell->echo ? commandShell->echo : "")));
1829
1830 if (args[1]) {
1831 argv[argc] = args;
1832 argc++;
1833 }
1834 } else {
1835 if (!(job->flags & JOB_IGNERR) && commandShell->exit) {
1836 argv[argc] = commandShell->exit;
1837 argc++;
1838 }
1839 if (!(job->flags & JOB_SILENT) && commandShell->echo) {
1840 argv[argc] = commandShell->echo;
1841 argc++;
1842 }
1843 }
1844 argv[argc] = NULL;
1845#endif /* KMK */
1846}
1847
1848
1849#ifdef SIGCONT
1850/*-
1851 *-----------------------------------------------------------------------
1852 * JobRestart --
1853 * Restart a job that stopped for some reason.
1854 *
1855 * Results:
1856 * None.
1857 *
1858 * Side Effects:
1859 * jobFull will be set if the job couldn't be run.
1860 *
1861 *-----------------------------------------------------------------------
1862 */
1863static void
1864JobRestart(job)
1865 Job *job; /* Job to restart */
1866{
1867#ifdef REMOTE
1868 int host;
1869#endif
1870
1871 if (job->flags & JOB_REMIGRATE) {
1872 if (
1873#ifdef REMOTE
1874 verboseRemigrates ||
1875#endif
1876 DEBUG(JOB)) {
1877 (void) fprintf(stdout, "*** remigrating %x(%s)\n",
1878 job->pid, job->node->name);
1879 (void) fflush(stdout);
1880 }
1881
1882#ifdef REMOTE
1883 if (!Rmt_ReExport(job->pid, job->node, &host)) {
1884 if (verboseRemigrates || DEBUG(JOB)) {
1885 (void) fprintf(stdout, "*** couldn't migrate...\n");
1886 (void) fflush(stdout);
1887 }
1888#endif
1889 if (nLocal != maxLocal) {
1890 /*
1891 * Job cannot be remigrated, but there's room on the local
1892 * machine, so resume the job and note that another
1893 * local job has started.
1894 */
1895 if (
1896#ifdef REMOTE
1897 verboseRemigrates ||
1898#endif
1899 DEBUG(JOB)) {
1900 (void) fprintf(stdout, "*** resuming on local machine\n");
1901 (void) fflush(stdout);
1902 }
1903 KILL(job->pid, SIGCONT);
1904 nLocal +=1;
1905#ifdef REMOTE
1906 job->flags &= ~(JOB_REMIGRATE|JOB_RESUME|JOB_REMOTE);
1907 job->flags |= JOB_CONTINUING;
1908#else
1909 job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
1910#endif
1911 } else {
1912 /*
1913 * Job cannot be restarted. Mark the table as full and
1914 * place the job back on the list of stopped jobs.
1915 */
1916 if (
1917#ifdef REMOTE
1918 verboseRemigrates ||
1919#endif
1920 DEBUG(JOB)) {
1921 (void) fprintf(stdout, "*** holding\n");
1922 (void) fflush(stdout);
1923 }
1924 (void)Lst_AtFront(stoppedJobs, (ClientData)job);
1925 jobFull = TRUE;
1926 if (DEBUG(JOB)) {
1927 (void) fprintf(stdout, "Job queue is full.\n");
1928 (void) fflush(stdout);
1929 }
1930 return;
1931 }
1932#ifdef REMOTE
1933 } else {
1934 /*
1935 * Clear out the remigrate and resume flags. Set the continuing
1936 * flag so we know later on that the process isn't exiting just
1937 * because of a signal.
1938 */
1939 job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
1940 job->flags |= JOB_CONTINUING;
1941 job->rmtID = host;
1942 }
1943#endif
1944
1945 (void)Lst_AtEnd(jobs, (ClientData)job);
1946 nJobs += 1;
1947 if (nJobs == maxJobs) {
1948 jobFull = TRUE;
1949 if (DEBUG(JOB)) {
1950 (void) fprintf(stdout, "Job queue is full.\n");
1951 (void) fflush(stdout);
1952 }
1953 }
1954 } else if (job->flags & JOB_RESTART) {
1955 /*
1956 * Set up the control arguments to the shell. This is based on the
1957 * flags set earlier for this job. If the JOB_IGNERR flag is clear,
1958 * the 'exit' flag of the commandShell is used to cause it to exit
1959 * upon receiving an error. If the JOB_SILENT flag is clear, the
1960 * 'echo' flag of the commandShell is used to get it to start echoing
1961 * as soon as it starts processing commands.
1962 */
1963 char *argv[4];
1964
1965 JobMakeArgv(job, argv);
1966
1967 if (DEBUG(JOB)) {
1968 (void) fprintf(stdout, "Restarting %s...", job->node->name);
1969 (void) fflush(stdout);
1970 }
1971#ifdef REMOTE
1972 if ((job->node->type&OP_NOEXPORT) ||
1973 (nLocal < maxLocal && runLocalFirst)
1974# ifdef RMT_NO_EXEC
1975 || !Rmt_Export(shellPath, argv, job)
1976# else
1977 || !Rmt_Begin(shellPath, argv, job->node)
1978# endif
1979#endif
1980 {
1981 if (((nLocal >= maxLocal) && !(job->flags & JOB_SPECIAL))) {
1982 /*
1983 * Can't be exported and not allowed to run locally -- put it
1984 * back on the hold queue and mark the table full
1985 */
1986 if (DEBUG(JOB)) {
1987 (void) fprintf(stdout, "holding\n");
1988 (void) fflush(stdout);
1989 }
1990 (void)Lst_AtFront(stoppedJobs, (ClientData)job);
1991 jobFull = TRUE;
1992 if (DEBUG(JOB)) {
1993 (void) fprintf(stdout, "Job queue is full.\n");
1994 (void) fflush(stdout);
1995 }
1996 return;
1997 } else {
1998 /*
1999 * Job may be run locally.
2000 */
2001 if (DEBUG(JOB)) {
2002 (void) fprintf(stdout, "running locally\n");
2003 (void) fflush(stdout);
2004 }
2005 job->flags &= ~JOB_REMOTE;
2006 }
2007 }
2008#ifdef REMOTE
2009 else {
2010 /*
2011 * Can be exported. Hooray!
2012 */
2013 if (DEBUG(JOB)) {
2014 (void) fprintf(stdout, "exporting\n");
2015 (void) fflush(stdout);
2016 }
2017 job->flags |= JOB_REMOTE;
2018 }
2019#endif
2020 JobExec(job, argv);
2021 } else {
2022 /*
2023 * The job has stopped and needs to be restarted. Why it stopped,
2024 * we don't know...
2025 */
2026 if (DEBUG(JOB)) {
2027 (void) fprintf(stdout, "Resuming %s...", job->node->name);
2028 (void) fflush(stdout);
2029 }
2030 if (((job->flags & JOB_REMOTE) ||
2031 (nLocal < maxLocal) ||
2032#ifdef REMOTE
2033 (((job->flags & JOB_SPECIAL) &&
2034 (job->node->type & OP_NOEXPORT)) &&
2035 (maxLocal == 0))) &&
2036#else
2037 ((job->flags & JOB_SPECIAL) &&
2038 (maxLocal == 0))) &&
2039#endif
2040 (nJobs != maxJobs))
2041 {
2042 /*
2043 * If the job is remote, it's ok to resume it as long as the
2044 * maximum concurrency won't be exceeded. If it's local and
2045 * we haven't reached the local concurrency limit already (or the
2046 * job must be run locally and maxLocal is 0), it's also ok to
2047 * resume it.
2048 */
2049 Boolean error;
2050 int status;
2051
2052#ifdef RMT_WANTS_SIGNALS
2053 if (job->flags & JOB_REMOTE) {
2054 error = !Rmt_Signal(job, SIGCONT);
2055 } else
2056#endif /* RMT_WANTS_SIGNALS */
2057 error = (KILL(job->pid, SIGCONT) != 0);
2058
2059 if (!error) {
2060 /*
2061 * Make sure the user knows we've continued the beast and
2062 * actually put the thing in the job table.
2063 */
2064 job->flags |= JOB_CONTINUING;
2065 W_SETTERMSIG(&status, SIGCONT);
2066 JobFinish(job, &status);
2067
2068 job->flags &= ~(JOB_RESUME|JOB_CONTINUING);
2069 if (DEBUG(JOB)) {
2070 (void) fprintf(stdout, "done\n");
2071 (void) fflush(stdout);
2072 }
2073 } else {
2074 Error("couldn't resume %s: %s",
2075 job->node->name, strerror(errno));
2076 status = 0;
2077 W_SETEXITSTATUS(&status, 1);
2078 JobFinish(job, &status);
2079 }
2080 } else {
2081 /*
2082 * Job cannot be restarted. Mark the table as full and
2083 * place the job back on the list of stopped jobs.
2084 */
2085 if (DEBUG(JOB)) {
2086 (void) fprintf(stdout, "table full\n");
2087 (void) fflush(stdout);
2088 }
2089 (void) Lst_AtFront(stoppedJobs, (ClientData)job);
2090 jobFull = TRUE;
2091 if (DEBUG(JOB)) {
2092 (void) fprintf(stdout, "Job queue is full.\n");
2093 (void) fflush(stdout);
2094 }
2095 }
2096 }
2097}
2098#endif
2099
2100/*-
2101 *-----------------------------------------------------------------------
2102 * JobStart --
2103 * Start a target-creation process going for the target described
2104 * by the graph node gn.
2105 *
2106 * Results:
2107 * JOB_ERROR if there was an error in the commands, JOB_FINISHED
2108 * if there isn't actually anything left to do for the job and
2109 * JOB_RUNNING if the job has been started.
2110 *
2111 * Side Effects:
2112 * A new Job node is created and added to the list of running
2113 * jobs. PMake is forked and a child shell created.
2114 *-----------------------------------------------------------------------
2115 */
2116static int
2117JobStart(gn, flags, previous)
2118 GNode *gn; /* target to create */
2119 int flags; /* flags for the job to override normal ones.
2120 * e.g. JOB_SPECIAL or JOB_IGNDOTS */
2121 Job *previous; /* The previous Job structure for this node,
2122 * if any. */
2123{
2124 register Job *job; /* new job descriptor */
2125 char *argv[4]; /* Argument vector to shell */
2126 Boolean cmdsOK; /* true if the nodes commands were all right */
2127 Boolean local; /* Set true if the job was run locally */
2128 Boolean noExec; /* Set true if we decide not to run the job */
2129 int tfd; /* File descriptor for temp file */
2130
2131 if (previous != NULL) {
2132 previous->flags &= ~(JOB_FIRST|JOB_IGNERR|JOB_SILENT|JOB_REMOTE);
2133 job = previous;
2134 } else {
2135 job = (Job *) emalloc(sizeof(Job));
2136 if (job == NULL) {
2137 Punt("JobStart out of memory");
2138 }
2139 flags |= JOB_FIRST;
2140 }
2141
2142 job->node = gn;
2143 job->tailCmds = NILLNODE;
2144
2145 /*
2146 * Set the initial value of the flags for this job based on the global
2147 * ones and the node's attributes... Any flags supplied by the caller
2148 * are also added to the field.
2149 */
2150 job->flags = 0;
2151 if (Targ_Ignore(gn)) {
2152 job->flags |= JOB_IGNERR;
2153 }
2154 if (Targ_Silent(gn)) {
2155 job->flags |= JOB_SILENT;
2156 }
2157 job->flags |= flags;
2158
2159 /*
2160 * Check the commands now so any attributes from .DEFAULT have a chance
2161 * to migrate to the node
2162 */
2163 if (!compatMake && job->flags & JOB_FIRST) {
2164 cmdsOK = Job_CheckCommands(gn, Error);
2165 } else {
2166 cmdsOK = TRUE;
2167 }
2168
2169 /*
2170 * If the -n flag wasn't given, we open up OUR (not the child's)
2171 * temporary file to stuff commands in it. The thing is rd/wr so we don't
2172 * need to reopen it to feed it to the shell. If the -n flag *was* given,
2173 * we just set the file to be stdout. Cute, huh?
2174 */
2175 if ((gn->type & OP_MAKE) || (!noExecute && !touchFlag)) {
2176 /*
2177 * We're serious here, but if the commands were bogus, we're
2178 * also dead...
2179 */
2180 if (!cmdsOK) {
2181 DieHorribly();
2182 }
2183
2184 (void) strcpy(tfile, TMPPAT);
2185 if ((tfd = mkstemp(tfile)) == -1)
2186 Punt("Cannot create temp file: %s", strerror(errno));
2187 job->cmdFILE = fdopen(tfd, "w+");
2188 eunlink(tfile);
2189 if (job->cmdFILE == NULL) {
2190 close(tfd);
2191 Punt("Could not open %s", tfile);
2192 }
2193 (void) fcntl(FILENO(job->cmdFILE), F_SETFD, 1);
2194 /*
2195 * Send the commands to the command file, flush all its buffers then
2196 * rewind and remove the thing.
2197 */
2198 noExec = FALSE;
2199
2200 /*
2201 * used to be backwards; replace when start doing multiple commands
2202 * per shell.
2203 */
2204 if (compatMake) {
2205 /*
2206 * Be compatible: If this is the first time for this node,
2207 * verify its commands are ok and open the commands list for
2208 * sequential access by later invocations of JobStart.
2209 * Once that is done, we take the next command off the list
2210 * and print it to the command file. If the command was an
2211 * ellipsis, note that there's nothing more to execute.
2212 */
2213 if ((job->flags&JOB_FIRST) && (Lst_Open(gn->commands) != SUCCESS)){
2214 cmdsOK = FALSE;
2215 } else {
2216 LstNode ln = Lst_Next(gn->commands);
2217
2218 if ((ln == NILLNODE) ||
2219 JobPrintCommand((ClientData) Lst_Datum(ln),
2220 (ClientData) job))
2221 {
2222 noExec = TRUE;
2223 Lst_Close(gn->commands);
2224 }
2225 if (noExec && !(job->flags & JOB_FIRST)) {
2226 /*
2227 * If we're not going to execute anything, the job
2228 * is done and we need to close down the various
2229 * file descriptors we've opened for output, then
2230 * call JobDoOutput to catch the final characters or
2231 * send the file to the screen... Note that the i/o streams
2232 * are only open if this isn't the first job.
2233 * Note also that this could not be done in
2234 * Job_CatchChildren b/c it wasn't clear if there were
2235 * more commands to execute or not...
2236 */
2237 JobClose(job);
2238 }
2239 }
2240 } else {
2241 /*
2242 * We can do all the commands at once. hooray for sanity
2243 */
2244 numCommands = 0;
2245 Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
2246
2247 /*
2248 * If we didn't print out any commands to the shell script,
2249 * there's not much point in executing the shell, is there?
2250 */
2251 if (numCommands == 0) {
2252 noExec = TRUE;
2253 }
2254 }
2255 } else if (noExecute) {
2256 /*
2257 * Not executing anything -- just print all the commands to stdout
2258 * in one fell swoop. This will still set up job->tailCmds correctly.
2259 */
2260 if (lastNode != gn) {
2261 MESSAGE(stdout, gn);
2262 lastNode = gn;
2263 }
2264 job->cmdFILE = stdout;
2265 /*
2266 * Only print the commands if they're ok, but don't die if they're
2267 * not -- just let the user know they're bad and keep going. It
2268 * doesn't do any harm in this case and may do some good.
2269 */
2270 if (cmdsOK) {
2271 Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
2272 }
2273 /*
2274 * Don't execute the shell, thank you.
2275 */
2276 noExec = TRUE;
2277 } else {
2278 /*
2279 * Just touch the target and note that no shell should be executed.
2280 * Set cmdFILE to stdout to make life easier. Check the commands, too,
2281 * but don't die if they're no good -- it does no harm to keep working
2282 * up the graph.
2283 */
2284 job->cmdFILE = stdout;
2285 Job_Touch(gn, job->flags&JOB_SILENT);
2286 noExec = TRUE;
2287 }
2288
2289 /*
2290 * If we're not supposed to execute a shell, don't.
2291 */
2292 if (noExec) {
2293 /*
2294 * Unlink and close the command file if we opened one
2295 */
2296 if (job->cmdFILE != stdout) {
2297 if (job->cmdFILE != NULL)
2298 (void) fclose(job->cmdFILE);
2299 } else {
2300 (void) fflush(stdout);
2301 }
2302
2303 /*
2304 * We only want to work our way up the graph if we aren't here because
2305 * the commands for the job were no good.
2306 */
2307 if (cmdsOK) {
2308 if (aborting == 0) {
2309 if (job->tailCmds != NILLNODE) {
2310 Lst_ForEachFrom(job->node->commands, job->tailCmds,
2311 JobSaveCommand,
2312 (ClientData)job->node);
2313 }
2314 job->node->made = MADE;
2315 Make_Update(job->node);
2316 }
2317 efree((Address)job);
2318 return(JOB_FINISHED);
2319 } else {
2320 efree((Address)job);
2321 return(JOB_ERROR);
2322 }
2323 } else {
2324 (void) fflush(job->cmdFILE);
2325 }
2326
2327 /*
2328 * Set up the control arguments to the shell. This is based on the flags
2329 * set earlier for this job.
2330 */
2331 JobMakeArgv(job, argv);
2332
2333 /*
2334 * If we're using pipes to catch output, create the pipe by which we'll
2335 * get the shell's output. If we're using files, print out that we're
2336 * starting a job and then set up its temporary-file name.
2337 */
2338 if (!compatMake || (job->flags & JOB_FIRST)) {
2339#ifdef USE_PIPES
2340 if (usePipes) {
2341 int fd[2];
2342 if (pipe(fd) == -1)
2343 Punt("Cannot create pipe: %s", strerror(errno));
2344 job->inPipe = fd[0];
2345 job->outPipe = fd[1];
2346 (void) fcntl(job->inPipe, F_SETFD, 1);
2347 (void) fcntl(job->outPipe, F_SETFD, 1);
2348 }
2349 else
2350#endif /* USE_PIPES */
2351 {
2352 (void) fprintf(stdout, "Remaking `%s'\n", gn->name);
2353 (void) fflush(stdout);
2354 (void) strcpy(job->outFile, TMPPAT);
2355 if ((job->outFd = mkstemp(job->outFile)) == -1)
2356 Punt("cannot create temp file: %s", strerror(errno));
2357 (void) fcntl(job->outFd, F_SETFD, 1);
2358 }
2359 }
2360
2361#ifdef REMOTE
2362 if (!(gn->type & OP_NOEXPORT) && !(runLocalFirst && nLocal < maxLocal)) {
2363#ifdef RMT_NO_EXEC
2364 local = !Rmt_Export(shellPath, argv, job);
2365#else
2366 local = !Rmt_Begin(shellPath, argv, job->node);
2367#endif /* RMT_NO_EXEC */
2368 if (!local) {
2369 job->flags |= JOB_REMOTE;
2370 }
2371 } else
2372#endif
2373 local = TRUE;
2374
2375 if (local && (((nLocal >= maxLocal) &&
2376 !(job->flags & JOB_SPECIAL) &&
2377#ifdef REMOTE
2378 (!(gn->type & OP_NOEXPORT) || (maxLocal != 0))
2379#else
2380 (maxLocal != 0)
2381#endif
2382 )))
2383 {
2384 /*
2385 * The job can only be run locally, but we've hit the limit of
2386 * local concurrency, so put the job on hold until some other job
2387 * finishes. Note that the special jobs (.BEGIN, .INTERRUPT and .END)
2388 * may be run locally even when the local limit has been reached
2389 * (e.g. when maxLocal == 0), though they will be exported if at
2390 * all possible. In addition, any target marked with .NOEXPORT will
2391 * be run locally if maxLocal is 0.
2392 */
2393 jobFull = TRUE;
2394
2395 if (DEBUG(JOB)) {
2396 (void) fprintf(stdout, "Can only run job locally.\n");
2397 (void) fflush(stdout);
2398 }
2399 job->flags |= JOB_RESTART;
2400 (void) Lst_AtEnd(stoppedJobs, (ClientData)job);
2401 } else {
2402 if ((nLocal >= maxLocal) && local) {
2403 /*
2404 * If we're running this job locally as a special case (see above),
2405 * at least say the table is full.
2406 */
2407 jobFull = TRUE;
2408 if (DEBUG(JOB)) {
2409 (void) fprintf(stdout, "Local job queue is full.\n");
2410 (void) fflush(stdout);
2411 }
2412 }
2413 JobExec(job, argv);
2414 }
2415 return(JOB_RUNNING);
2416}
2417
2418static char *
2419JobOutput(job, cp, endp, msg)
2420 register Job *job;
2421 register char *cp, *endp;
2422 int msg;
2423{
2424 register char *ecp;
2425
2426 #ifndef KMK /* @Todo */
2427 if (commandShell->noPrint) {
2428 ecp = Str_FindSubstring(cp, commandShell->noPrint);
2429 while (ecp != NULL) {
2430 if (cp != ecp) {
2431 *ecp = '\0';
2432 if (msg && job->node != lastNode) {
2433 MESSAGE(stdout, job->node);
2434 lastNode = job->node;
2435 }
2436 /*
2437 * The only way there wouldn't be a newline after
2438 * this line is if it were the last in the buffer.
2439 * however, since the non-printable comes after it,
2440 * there must be a newline, so we don't print one.
2441 */
2442 (void) fprintf(stdout, "%s", cp);
2443 (void) fflush(stdout);
2444 }
2445 cp = ecp + commandShell->noPLen;
2446 if (cp != endp) {
2447 /*
2448 * Still more to print, look again after skipping
2449 * the whitespace following the non-printable
2450 * command....
2451 */
2452 cp++;
2453 while (*cp == ' ' || *cp == '\t' || *cp == '\n') {
2454 cp++;
2455 }
2456 ecp = Str_FindSubstring(cp, commandShell->noPrint);
2457 } else {
2458 return cp;
2459 }
2460 }
2461 }
2462 #endif /*!KMK*/
2463 return cp;
2464}
2465
2466/*-
2467 *-----------------------------------------------------------------------
2468 * JobDoOutput --
2469 * This function is called at different times depending on
2470 * whether the user has specified that output is to be collected
2471 * via pipes or temporary files. In the former case, we are called
2472 * whenever there is something to read on the pipe. We collect more
2473 * output from the given job and store it in the job's outBuf. If
2474 * this makes up a line, we print it tagged by the job's identifier,
2475 * as necessary.
2476 * If output has been collected in a temporary file, we open the
2477 * file and read it line by line, transfering it to our own
2478 * output channel until the file is empty. At which point we
2479 * remove the temporary file.
2480 * In both cases, however, we keep our figurative eye out for the
2481 * 'noPrint' line for the shell from which the output came. If
2482 * we recognize a line, we don't print it. If the command is not
2483 * alone on the line (the character after it is not \0 or \n), we
2484 * do print whatever follows it.
2485 *
2486 * Results:
2487 * None
2488 *
2489 * Side Effects:
2490 * curPos may be shifted as may the contents of outBuf.
2491 *-----------------------------------------------------------------------
2492 */
2493STATIC void
2494JobDoOutput(job, finish)
2495 register Job *job; /* the job whose output needs printing */
2496 Boolean finish; /* TRUE if this is the last time we'll be
2497 * called for this job */
2498{
2499 Boolean gotNL = FALSE; /* true if got a newline */
2500 Boolean fbuf; /* true if our buffer filled up */
2501 register int nr; /* number of bytes read */
2502 register int i; /* auxiliary index into outBuf */
2503 register int max; /* limit for i (end of current data) */
2504 int nRead; /* (Temporary) number of bytes read */
2505
2506 FILE *oFILE; /* Stream pointer to shell's output file */
2507 char inLine[132];
2508
2509
2510#ifdef USE_PIPES
2511 if (usePipes) {
2512 /*
2513 * Read as many bytes as will fit in the buffer.
2514 */
2515end_loop:
2516 gotNL = FALSE;
2517 fbuf = FALSE;
2518
2519 nRead = read(job->inPipe, &job->outBuf[job->curPos],
2520 JOB_BUFSIZE - job->curPos);
2521 if (nRead < 0) {
2522 if (DEBUG(JOB)) {
2523 perror("JobDoOutput(piperead)");
2524 }
2525 nr = 0;
2526 } else {
2527 nr = nRead;
2528 }
2529
2530 /*
2531 * If we hit the end-of-file (the job is dead), we must flush its
2532 * remaining output, so pretend we read a newline if there's any
2533 * output remaining in the buffer.
2534 * Also clear the 'finish' flag so we stop looping.
2535 */
2536 if ((nr == 0) && (job->curPos != 0)) {
2537 job->outBuf[job->curPos] = '\n';
2538 nr = 1;
2539 finish = FALSE;
2540 } else if (nr == 0) {
2541 finish = FALSE;
2542 }
2543
2544 /*
2545 * Look for the last newline in the bytes we just got. If there is
2546 * one, break out of the loop with 'i' as its index and gotNL set
2547 * TRUE.
2548 */
2549 max = job->curPos + nr;
2550 for (i = job->curPos + nr - 1; i >= job->curPos; i--) {
2551 if (job->outBuf[i] == '\n') {
2552 gotNL = TRUE;
2553 break;
2554 } else if (job->outBuf[i] == '\0') {
2555 /*
2556 * Why?
2557 */
2558 job->outBuf[i] = ' ';
2559 }
2560 }
2561
2562 if (!gotNL) {
2563 job->curPos += nr;
2564 if (job->curPos == JOB_BUFSIZE) {
2565 /*
2566 * If we've run out of buffer space, we have no choice
2567 * but to print the stuff. sigh.
2568 */
2569 fbuf = TRUE;
2570 i = job->curPos;
2571 }
2572 }
2573 if (gotNL || fbuf) {
2574 /*
2575 * Need to send the output to the screen. Null terminate it
2576 * first, overwriting the newline character if there was one.
2577 * So long as the line isn't one we should filter (according
2578 * to the shell description), we print the line, preceeded
2579 * by a target banner if this target isn't the same as the
2580 * one for which we last printed something.
2581 * The rest of the data in the buffer are then shifted down
2582 * to the start of the buffer and curPos is set accordingly.
2583 */
2584 job->outBuf[i] = '\0';
2585 if (i >= job->curPos) {
2586 char *cp;
2587
2588 cp = JobOutput(job, job->outBuf, &job->outBuf[i], FALSE);
2589
2590 /*
2591 * There's still more in that thar buffer. This time, though,
2592 * we know there's no newline at the end, so we add one of
2593 * our own efree will.
2594 */
2595 if (*cp != '\0') {
2596 if (job->node != lastNode) {
2597 MESSAGE(stdout, job->node);
2598 lastNode = job->node;
2599 }
2600 (void) fprintf(stdout, "%s%s", cp, gotNL ? "\n" : "");
2601 (void) fflush(stdout);
2602 }
2603 }
2604 if (i < max - 1) {
2605 /* shift the remaining characters down */
2606 (void) memcpy(job->outBuf, &job->outBuf[i + 1], max - (i + 1));
2607 job->curPos = max - (i + 1);
2608
2609 } else {
2610 /*
2611 * We have written everything out, so we just start over
2612 * from the start of the buffer. No copying. No nothing.
2613 */
2614 job->curPos = 0;
2615 }
2616 }
2617 if (finish) {
2618 /*
2619 * If the finish flag is true, we must loop until we hit
2620 * end-of-file on the pipe. This is guaranteed to happen
2621 * eventually since the other end of the pipe is now closed
2622 * (we closed it explicitly and the child has exited). When
2623 * we do get an EOF, finish will be set FALSE and we'll fall
2624 * through and out.
2625 */
2626 goto end_loop;
2627 }
2628 }
2629 else
2630#endif /* USE_PIPES */
2631 {
2632 /*
2633 * We've been called to retrieve the output of the job from the
2634 * temporary file where it's been squirreled away. This consists of
2635 * opening the file, reading the output line by line, being sure not
2636 * to print the noPrint line for the shell we used, then close and
2637 * remove the temporary file. Very simple.
2638 *
2639 * Change to read in blocks and do FindSubString type things as for
2640 * pipes? That would allow for "@echo -n..."
2641 */
2642 oFILE = fopen(job->outFile, "r");
2643 if (oFILE != NULL) {
2644 (void) fprintf(stdout, "Results of making %s:\n", job->node->name);
2645 (void) fflush(stdout);
2646 while (fgets(inLine, sizeof(inLine), oFILE) != NULL) {
2647 register char *cp, *endp, *oendp;
2648
2649 cp = inLine;
2650 oendp = endp = inLine + strlen(inLine);
2651 if (endp[-1] == '\n') {
2652 *--endp = '\0';
2653 }
2654 cp = JobOutput(job, inLine, endp, FALSE);
2655
2656 /*
2657 * There's still more in that thar buffer. This time, though,
2658 * we know there's no newline at the end, so we add one of
2659 * our own efree will.
2660 */
2661 (void) fprintf(stdout, "%s", cp);
2662 (void) fflush(stdout);
2663 if (endp != oendp) {
2664 (void) fprintf(stdout, "\n");
2665 (void) fflush(stdout);
2666 }
2667 }
2668 (void) fclose(oFILE);
2669 (void) eunlink(job->outFile);
2670 }
2671 }
2672}
2673
2674/*-
2675 *-----------------------------------------------------------------------
2676 * Job_CatchChildren --
2677 * Handle the exit of a child. Called from Make_Make.
2678 *
2679 * Results:
2680 * none.
2681 *
2682 * Side Effects:
2683 * The job descriptor is removed from the list of children.
2684 *
2685 * Notes:
2686 * We do waits, blocking or not, according to the wisdom of our
2687 * caller, until there are no more children to report. For each
2688 * job, call JobFinish to finish things off. This will take care of
2689 * putting jobs on the stoppedJobs queue.
2690 *
2691 *-----------------------------------------------------------------------
2692 */
2693void
2694Job_CatchChildren(block)
2695 Boolean block; /* TRUE if should block on the wait. */
2696{
2697#ifdef USE_KLIB
2698 int pid; /* pid of dead child */
2699 register Job *job; /* job descriptor for dead child */
2700 LstNode jnode; /* list element for finding job */
2701 KPROCRES status; /* Exit/termination status */
2702
2703 /*
2704 * Don't even bother if we know there's no one around.
2705 */
2706 if (nLocal == 0) {
2707 return;
2708 }
2709
2710 while (!kProcWait(KPID_NULL, KPROCWAIT_FLAGS_NOWAIT, &status, &pid))
2711 {
2712 if (DEBUG(JOB)) {
2713 (void) fprintf(stdout, "Process %d exited or stopped.\n", pid);
2714 (void) fflush(stdout);
2715 }
2716
2717 jnode = Lst_Find(jobs, (ClientData)&pid, JobCmpPid);
2718 if (jnode == NILLNODE) {
2719 Error("Child (%d) not in table?", pid);
2720 continue;
2721 } else {
2722 job = (Job *) Lst_Datum(jnode);
2723 (void) Lst_Remove(jobs, jnode);
2724 nJobs -= 1;
2725 if (jobFull && DEBUG(JOB)) {
2726 (void) fprintf(stdout, "Job queue is no longer full.\n");
2727 (void) fflush(stdout);
2728 }
2729 jobFull = FALSE;
2730 nLocal -= 1;
2731 }
2732 JobFinish(job, &status);
2733 }
2734
2735#else /* Don't Use kLib */
2736 int pid; /* pid of dead child */
2737 register Job *job; /* job descriptor for dead child */
2738 LstNode jnode; /* list element for finding job */
2739 int status; /* Exit/termination status */
2740
2741 /*
2742 * Don't even bother if we know there's no one around.
2743 */
2744 if (nLocal == 0) {
2745 return;
2746 }
2747
2748 while ((pid = waitpid((pid_t) -1, &status,
2749 (block?0:WNOHANG)|WUNTRACED)) > 0)
2750 {
2751 if (DEBUG(JOB)) {
2752 (void) fprintf(stdout, "Process %d exited or stopped.\n", pid);
2753 (void) fflush(stdout);
2754 }
2755
2756
2757 jnode = Lst_Find(jobs, (ClientData)&pid, JobCmpPid);
2758
2759 if (jnode == NILLNODE) {
2760 if (WIFSIGNALED(status) && (WTERMSIG(status) == SIGCONT)) {
2761 jnode = Lst_Find(stoppedJobs, (ClientData) &pid, JobCmpPid);
2762 if (jnode == NILLNODE) {
2763 Error("Resumed child (%d) not in table", pid);
2764 continue;
2765 }
2766 job = (Job *)Lst_Datum(jnode);
2767 (void) Lst_Remove(stoppedJobs, jnode);
2768 } else {
2769 Error("Child (%d) not in table?", pid);
2770 continue;
2771 }
2772 } else {
2773 job = (Job *) Lst_Datum(jnode);
2774 (void) Lst_Remove(jobs, jnode);
2775 nJobs -= 1;
2776 if (jobFull && DEBUG(JOB)) {
2777 (void) fprintf(stdout, "Job queue is no longer full.\n");
2778 (void) fflush(stdout);
2779 }
2780 jobFull = FALSE;
2781#ifdef REMOTE
2782 if (!(job->flags & JOB_REMOTE)) {
2783 if (DEBUG(JOB)) {
2784 (void) fprintf(stdout,
2785 "Job queue has one fewer local process.\n");
2786 (void) fflush(stdout);
2787 }
2788 nLocal -= 1;
2789 }
2790#else
2791 nLocal -= 1;
2792#endif
2793 }
2794
2795 JobFinish(job, &status);
2796 }
2797#endif /* USE_KLIB */
2798}
2799
2800/*-
2801 *-----------------------------------------------------------------------
2802 * Job_CatchOutput --
2803 * Catch the output from our children, if we're using
2804 * pipes do so. Otherwise just block time until we get a
2805 * signal (most likely a SIGCHLD) since there's no point in
2806 * just spinning when there's nothing to do and the reaping
2807 * of a child can wait for a while.
2808 *
2809 * Results:
2810 * None
2811 *
2812 * Side Effects:
2813 * Output is read from pipes if we're piping.
2814 * -----------------------------------------------------------------------
2815 */
2816void
2817Job_CatchOutput()
2818{
2819 int nfds;
2820 struct timeval timeout;
2821 fd_set readfds;
2822 register LstNode ln;
2823 register Job *job;
2824#ifdef RMT_WILL_WATCH
2825 int pnJobs; /* Previous nJobs */
2826#endif
2827
2828 (void) fflush(stdout);
2829#ifdef RMT_WILL_WATCH
2830 pnJobs = nJobs;
2831
2832 /*
2833 * It is possible for us to be called with nJobs equal to 0. This happens
2834 * if all the jobs finish and a job that is stopped cannot be run
2835 * locally (eg if maxLocal is 0) and cannot be exported. The job will
2836 * be placed back on the stoppedJobs queue, Job_Empty() will return false,
2837 * Make_Run will call us again when there's nothing for which to wait.
2838 * nJobs never changes, so we loop forever. Hence the check. It could
2839 * be argued that we should sleep for a bit so as not to swamp the
2840 * exportation system with requests. Perhaps we should.
2841 *
2842 * NOTE: IT IS THE RESPONSIBILITY OF Rmt_Wait TO CALL Job_CatchChildren
2843 * IN A TIMELY FASHION TO CATCH ANY LOCALLY RUNNING JOBS THAT EXIT.
2844 * It may use the variable nLocal to determine if it needs to call
2845 * Job_CatchChildren (if nLocal is 0, there's nothing for which to
2846 * wait...)
2847 */
2848 while (nJobs != 0 && pnJobs == nJobs) {
2849 Rmt_Wait();
2850 }
2851#else
2852#ifdef USE_PIPES
2853 if (usePipes) {
2854 readfds = outputs;
2855 timeout.tv_sec = SEL_SEC;
2856 timeout.tv_usec = SEL_USEC;
2857
2858 if ((nfds = select(FD_SETSIZE, &readfds, (fd_set *) 0,
2859 (fd_set *) 0, &timeout)) <= 0)
2860 return;
2861 else {
2862 if (Lst_Open(jobs) == FAILURE) {
2863 Punt("Cannot open job table");
2864 }
2865 while (nfds && (ln = Lst_Next(jobs)) != NILLNODE) {
2866 job = (Job *) Lst_Datum(ln);
2867 if (FD_ISSET(job->inPipe, &readfds)) {
2868 JobDoOutput(job, FALSE);
2869 nfds -= 1;
2870 }
2871 }
2872 Lst_Close(jobs);
2873 }
2874 }
2875#endif /* USE_PIPES */
2876#endif /* RMT_WILL_WATCH */
2877}
2878
2879/*-
2880 *-----------------------------------------------------------------------
2881 * Job_Make --
2882 * Start the creation of a target. Basically a front-end for
2883 * JobStart used by the Make module.
2884 *
2885 * Results:
2886 * None.
2887 *
2888 * Side Effects:
2889 * Another job is started.
2890 *
2891 *-----------------------------------------------------------------------
2892 */
2893void
2894Job_Make(gn)
2895 GNode *gn;
2896{
2897 (void) JobStart(gn, 0, NULL);
2898}
2899
2900/*-
2901 *-----------------------------------------------------------------------
2902 * Job_Init --
2903 * Initialize the process module
2904 *
2905 * Results:
2906 * none
2907 *
2908 * Side Effects:
2909 * lists and counters are initialized
2910 *-----------------------------------------------------------------------
2911 */
2912void
2913Job_Init(maxproc, maxlocal)
2914 int maxproc; /* the greatest number of jobs which may be
2915 * running at one time */
2916 int maxlocal; /* the greatest number of local jobs which may
2917 * be running at once. */
2918{
2919 GNode *begin; /* node for commands to do at the very start */
2920
2921 jobs = Lst_Init(FALSE);
2922#ifdef SIGCONT
2923 stoppedJobs = Lst_Init(FALSE);
2924#endif
2925 maxJobs = maxproc;
2926 maxLocal = maxlocal;
2927 nJobs = 0;
2928 nLocal = 0;
2929 jobFull = FALSE;
2930
2931 aborting = 0;
2932 errors = 0;
2933
2934 lastNode = NILGNODE;
2935
2936 if (maxJobs == 1 || beVerbose == 0
2937#ifdef REMOTE
2938 || noMessages
2939#endif
2940 ) {
2941 /*
2942 * If only one job can run at a time, there's no need for a banner,
2943 * no is there?
2944 */
2945 targFmt = "";
2946 } else {
2947 targFmt = TARG_FMT;
2948 }
2949
2950#ifndef KMK
2951 if (shellPath == NULL) {
2952 /*
2953 * The user didn't specify a shell to use, so we are using the
2954 * default one... Both the absolute path and the last component
2955 * must be set. The last component is taken from the 'name' field
2956 * of the default shell description pointed-to by commandShell.
2957 * All default shells are located in _PATH_DEFSHELLDIR.
2958 */
2959 shellName = commandShell->name;
2960 shellPath = str_concat(_PATH_DEFSHELLDIR, shellName, STR_ADDSLASH);
2961 }
2962
2963 if (commandShell->exit == NULL) {
2964 commandShell->exit = "";
2965 }
2966 if (commandShell->echo == NULL) {
2967 commandShell->echo = "";
2968 }
2969#endif
2970
2971 /*
2972 * Catch the four signals that POSIX specifies if they aren't ignored.
2973 * JobPassSig will take care of calling JobInterrupt if appropriate.
2974 */
2975 if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
2976 (void) signal(SIGINT, JobPassSig);
2977 }
2978#ifdef SIGHUP /* not all systems supports this signal */
2979 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
2980 (void) signal(SIGHUP, JobPassSig);
2981 }
2982#endif
2983#ifdef SIGQUIT /* not all systems supports this signal */
2984 if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
2985 (void) signal(SIGQUIT, JobPassSig);
2986 }
2987#endif
2988 if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
2989 (void) signal(SIGTERM, JobPassSig);
2990 }
2991 /*
2992 * There are additional signals that need to be caught and passed if
2993 * either the export system wants to be told directly of signals or if
2994 * we're giving each job its own process group (since then it won't get
2995 * signals from the terminal driver as we own the terminal)
2996 */
2997#if defined(RMT_WANTS_SIGNALS) || defined(USE_PGRP)
2998 if (signal(SIGTSTP, SIG_IGN) != SIG_IGN) {
2999 (void) signal(SIGTSTP, JobPassSig);
3000 }
3001 if (signal(SIGTTOU, SIG_IGN) != SIG_IGN) {
3002 (void) signal(SIGTTOU, JobPassSig);
3003 }
3004 if (signal(SIGTTIN, SIG_IGN) != SIG_IGN) {
3005 (void) signal(SIGTTIN, JobPassSig);
3006 }
3007 if (signal(SIGWINCH, SIG_IGN) != SIG_IGN) {
3008 (void) signal(SIGWINCH, JobPassSig);
3009 }
3010#endif
3011
3012 begin = Targ_FindNode(".BEGIN", TARG_NOCREATE);
3013
3014 if (begin != NILGNODE) {
3015 JobStart(begin, JOB_SPECIAL, (Job *)0);
3016 while (nJobs) {
3017 Job_CatchOutput();
3018#ifndef RMT_WILL_WATCH
3019 Job_CatchChildren(!usePipes);
3020#endif /* RMT_WILL_WATCH */
3021 }
3022 }
3023 postCommands = Targ_FindNode(".END", TARG_CREATE);
3024}
3025
3026/*-
3027 *-----------------------------------------------------------------------
3028 * Job_Full --
3029 * See if the job table is full. It is considered full if it is OR
3030 * if we are in the process of aborting OR if we have
3031 * reached/exceeded our local quota. This prevents any more jobs
3032 * from starting up.
3033 *
3034 * Results:
3035 * TRUE if the job table is full, FALSE otherwise
3036 * Side Effects:
3037 * None.
3038 *-----------------------------------------------------------------------
3039 */
3040Boolean
3041Job_Full()
3042{
3043 return(aborting || jobFull);
3044}
3045
3046/*-
3047 *-----------------------------------------------------------------------
3048 * Job_Empty --
3049 * See if the job table is empty. Because the local concurrency may
3050 * be set to 0, it is possible for the job table to become empty,
3051 * while the list of stoppedJobs remains non-empty. In such a case,
3052 * we want to restart as many jobs as we can.
3053 *
3054 * Results:
3055 * TRUE if it is. FALSE if it ain't.
3056 *
3057 * Side Effects:
3058 * None.
3059 *
3060 * -----------------------------------------------------------------------
3061 */
3062Boolean
3063Job_Empty()
3064{
3065 if (nJobs == 0) {
3066#ifdef SIGCONT
3067 if (!Lst_IsEmpty(stoppedJobs) && !aborting) {
3068 /*
3069 * The job table is obviously not full if it has no jobs in
3070 * it...Try and restart the stopped jobs.
3071 */
3072 jobFull = FALSE;
3073 JobRestartJobs();
3074 return(FALSE);
3075 }
3076#else
3077 return(TRUE);
3078#endif
3079 } else {
3080 return(FALSE);
3081 }
3082}
3083
3084#ifndef KMK
3085/*-
3086 *-----------------------------------------------------------------------
3087 * JobMatchShell --
3088 * Find a matching shell in 'shells' given its final component.
3089 *
3090 * Results:
3091 * A pointer to the Shell structure.
3092 *
3093 * Side Effects:
3094 * None.
3095 *
3096 *-----------------------------------------------------------------------
3097 */
3098static Shell *
3099JobMatchShell(name)
3100 char *name; /* Final component of shell path */
3101{
3102 register Shell *sh; /* Pointer into shells table */
3103 Shell *match; /* Longest-matching shell */
3104 register char *cp1,
3105 *cp2;
3106 char *eoname;
3107
3108 eoname = name + strlen(name);
3109
3110 match = NULL;
3111
3112 for (sh = shells; sh->name != NULL; sh++) {
3113 for (cp1 = eoname - strlen(sh->name), cp2 = sh->name;
3114 *cp1 != '\0' && *cp1 == *cp2;
3115 cp1++, cp2++) {
3116 continue;
3117 }
3118 if (*cp1 != *cp2) {
3119 continue;
3120 } else if (match == NULL || strlen(match->name) < strlen(sh->name)) {
3121 match = sh;
3122 }
3123 }
3124 return(match == NULL ? sh : match);
3125}
3126#endif /*!KMK*/
3127
3128#ifndef KMK
3129/*-
3130 *-----------------------------------------------------------------------
3131 * Job_ParseShell --
3132 * Parse a shell specification and set up commandShell, shellPath
3133 * and shellName appropriately.
3134 *
3135 * Results:
3136 * FAILURE if the specification was incorrect.
3137 *
3138 * Side Effects:
3139 * commandShell points to a Shell structure (either predefined or
3140 * created from the shell spec), shellPath is the full path of the
3141 * shell described by commandShell, while shellName is just the
3142 * final component of shellPath.
3143 *
3144 * Notes:
3145 * A shell specification consists of a .SHELL target, with dependency
3146 * operator, followed by a series of blank-separated words. Double
3147 * quotes can be used to use blanks in words. A backslash escapes
3148 * anything (most notably a double-quote and a space) and
3149 * provides the functionality it does in C. Each word consists of
3150 * keyword and value separated by an equal sign. There should be no
3151 * unnecessary spaces in the word. The keywords are as follows:
3152 * name Name of shell.
3153 * path Location of shell. Overrides "name" if given
3154 * quiet Command to turn off echoing.
3155 * echo Command to turn echoing on
3156 * filter Result of turning off echoing that shouldn't be
3157 * printed.
3158 * echoFlag Flag to turn echoing on at the start
3159 * errFlag Flag to turn error checking on at the start
3160 * hasErrCtl True if shell has error checking control
3161 * check Command to turn on error checking if hasErrCtl
3162 * is TRUE or template of command to echo a command
3163 * for which error checking is off if hasErrCtl is
3164 * FALSE.
3165 * ignore Command to turn off error checking if hasErrCtl
3166 * is TRUE or template of command to execute a
3167 * command so as to ignore any errors it returns if
3168 * hasErrCtl is FALSE.
3169 *
3170 *-----------------------------------------------------------------------
3171 */
3172ReturnStatus
3173Job_ParseShell(line)
3174 char *line; /* The shell spec */
3175{
3176 char **words;
3177 int wordCount;
3178 register char **argv;
3179 register int argc;
3180 char *path;
3181 Shell newShell;
3182 Boolean fullSpec = FALSE;
3183
3184 while (isspace(*line)) {
3185 line++;
3186 }
3187 words = brk_string(line, &wordCount, TRUE);
3188
3189 memset((Address)&newShell, 0, sizeof(newShell));
3190
3191 /*
3192 * Parse the specification by keyword
3193 */
3194 for (path = NULL, argc = wordCount - 1, argv = words + 1;
3195 argc != 0;
3196 argc--, argv++) {
3197 if (strncmp(*argv, "path=", 5) == 0) {
3198 path = &argv[0][5];
3199 } else if (strncmp(*argv, "name=", 5) == 0) {
3200 newShell.name = &argv[0][5];
3201 } else {
3202 if (strncmp(*argv, "quiet=", 6) == 0) {
3203 newShell.echoOff = &argv[0][6];
3204 } else if (strncmp(*argv, "echo=", 5) == 0) {
3205 newShell.echoOn = &argv[0][5];
3206 } else if (strncmp(*argv, "filter=", 7) == 0) {
3207 newShell.noPrint = &argv[0][7];
3208 newShell.noPLen = strlen(newShell.noPrint);
3209 } else if (strncmp(*argv, "echoFlag=", 9) == 0) {
3210 newShell.echo = &argv[0][9];
3211 } else if (strncmp(*argv, "errFlag=", 8) == 0) {
3212 newShell.exit = &argv[0][8];
3213 } else if (strncmp(*argv, "hasErrCtl=", 10) == 0) {
3214 char c = argv[0][10];
3215 newShell.hasErrCtl = !((c != 'Y') && (c != 'y') &&
3216 (c != 'T') && (c != 't'));
3217 } else if (strncmp(*argv, "check=", 6) == 0) {
3218 newShell.errCheck = &argv[0][6];
3219 } else if (strncmp(*argv, "ignore=", 7) == 0) {
3220 newShell.ignErr = &argv[0][7];
3221 } else {
3222 Parse_Error(PARSE_FATAL, "Unknown keyword \"%s\"",
3223 *argv);
3224 return(FAILURE);
3225 }
3226 fullSpec = TRUE;
3227 }
3228 }
3229
3230 if (path == NULL) {
3231 /*
3232 * If no path was given, the user wants one of the pre-defined shells,
3233 * yes? So we find the one s/he wants with the help of JobMatchShell
3234 * and set things up the right way. shellPath will be set up by
3235 * Job_Init.
3236 */
3237 if (newShell.name == NULL) {
3238 Parse_Error(PARSE_FATAL, "Neither path nor name specified");
3239 return(FAILURE);
3240 } else {
3241 commandShell = JobMatchShell(newShell.name);
3242 shellName = newShell.name;
3243 }
3244 } else {
3245 /*
3246 * The user provided a path. If s/he gave nothing else (fullSpec is
3247 * FALSE), try and find a matching shell in the ones we know of.
3248 * Else we just take the specification at its word and copy it
3249 * to a new location. In either case, we need to record the
3250 * path the user gave for the shell.
3251 */
3252 shellPath = path;
3253 path = strrchr(path, '/');
3254 if (path == NULL) {
3255 path = shellPath;
3256 } else {
3257 path += 1;
3258 }
3259 if (newShell.name != NULL) {
3260 shellName = newShell.name;
3261 } else {
3262 shellName = path;
3263 }
3264 if (!fullSpec) {
3265 commandShell = JobMatchShell(shellName);
3266 } else {
3267 commandShell = (Shell *) emalloc(sizeof(Shell));
3268 *commandShell = newShell;
3269 }
3270 }
3271
3272 if (commandShell->echoOn && commandShell->echoOff) {
3273 commandShell->hasEchoCtl = TRUE;
3274 }
3275
3276 if (!commandShell->hasErrCtl) {
3277 if (commandShell->errCheck == NULL) {
3278 commandShell->errCheck = "";
3279 }
3280 if (commandShell->ignErr == NULL) {
3281 commandShell->ignErr = "%s\n";
3282 }
3283 }
3284
3285 /*
3286 * Do not efree up the words themselves, since they might be in use by the
3287 * shell specification...
3288 */
3289 efree(words);
3290 return SUCCESS;
3291}
3292#endif /*!KMK*/
3293
3294/*-
3295 *-----------------------------------------------------------------------
3296 * JobInterrupt --
3297 * Handle the receipt of an interrupt.
3298 *
3299 * Results:
3300 * None
3301 *
3302 * Side Effects:
3303 * All children are killed. Another job will be started if the
3304 * .INTERRUPT target was given.
3305 *-----------------------------------------------------------------------
3306 */
3307static void
3308JobInterrupt(runINTERRUPT, signo)
3309 int runINTERRUPT; /* Non-zero if commands for the .INTERRUPT
3310 * target should be executed */
3311 int signo; /* signal received */
3312{
3313 LstNode ln; /* element in job table */
3314 Job *job = NULL; /* job descriptor in that element */
3315 GNode *interrupt; /* the node describing the .INTERRUPT target */
3316
3317 aborting = ABORT_INTERRUPT;
3318
3319 (void) Lst_Open(jobs);
3320 while ((ln = Lst_Next(jobs)) != NILLNODE) {
3321 job = (Job *) Lst_Datum(ln);
3322
3323 if (!Targ_Precious(job->node)) {
3324 char *file = (job->node->path == NULL ?
3325 job->node->name :
3326 job->node->path);
3327 if (!noExecute && eunlink(file) != -1) {
3328 Error("*** %s removed", file);
3329 }
3330 }
3331#ifdef RMT_WANTS_SIGNALS
3332 if (job->flags & JOB_REMOTE) {
3333 /*
3334 * If job is remote, let the Rmt module do the killing.
3335 */
3336 if (!Rmt_Signal(job, signo)) {
3337 /*
3338 * If couldn't kill the thing, finish it out now with an
3339 * error code, since no exit report will come in likely.
3340 */
3341 int status;
3342
3343 status.w_status = 0;
3344 status.w_retcode = 1;
3345 JobFinish(job, &status);
3346 }
3347 } else if (job->pid) {
3348 KILL(job->pid, signo);
3349 }
3350#else
3351 if (job->pid) {
3352 if (DEBUG(JOB)) {
3353 (void) fprintf(stdout,
3354 "JobInterrupt passing signal to child %d.\n",
3355 job->pid);
3356 (void) fflush(stdout);
3357 }
3358 KILL(job->pid, signo);
3359 }
3360#endif /* RMT_WANTS_SIGNALS */
3361 }
3362
3363#ifdef REMOTE
3364 (void)Lst_Open(stoppedJobs);
3365 while ((ln = Lst_Next(stoppedJobs)) != NILLNODE) {
3366 job = (Job *) Lst_Datum(ln);
3367
3368 if (job->flags & JOB_RESTART) {
3369 if (DEBUG(JOB)) {
3370 (void) fprintf(stdout, "%s%s",
3371 "JobInterrupt skipping job on stopped queue",
3372 "-- it was waiting to be restarted.\n");
3373 (void) fflush(stdout);
3374 }
3375 continue;
3376 }
3377 if (!Targ_Precious(job->node)) {
3378 char *file = (job->node->path == NULL ?
3379 job->node->name :
3380 job->node->path);
3381 if (eunlink(file) == 0) {
3382 Error("*** %s removed", file);
3383 }
3384 }
3385 /*
3386 * Resume the thing so it will take the signal.
3387 */
3388 if (DEBUG(JOB)) {
3389 (void) fprintf(stdout,
3390 "JobInterrupt passing CONT to stopped child %d.\n",
3391 job->pid);
3392 (void) fflush(stdout);
3393 }
3394 KILL(job->pid, SIGCONT);
3395#ifdef RMT_WANTS_SIGNALS
3396 if (job->flags & JOB_REMOTE) {
3397 /*
3398 * If job is remote, let the Rmt module do the killing.
3399 */
3400 if (!Rmt_Signal(job, SIGINT)) {
3401 /*
3402 * If couldn't kill the thing, finish it out now with an
3403 * error code, since no exit report will come in likely.
3404 */
3405 int status;
3406 status.w_status = 0;
3407 status.w_retcode = 1;
3408 JobFinish(job, &status);
3409 }
3410 } else if (job->pid) {
3411 if (DEBUG(JOB)) {
3412 (void) fprintf(stdout,
3413 "JobInterrupt passing interrupt to stopped child %d.\n",
3414 job->pid);
3415 (void) fflush(stdout);
3416 }
3417 KILL(job->pid, SIGINT);
3418 }
3419#endif /* RMT_WANTS_SIGNALS */
3420 }
3421 Lst_Close(stoppedJobs);
3422#endif
3423
3424 if (runINTERRUPT && !touchFlag) {
3425 interrupt = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
3426 if (interrupt != NILGNODE) {
3427 ignoreErrors = FALSE;
3428
3429 JobStart(interrupt, JOB_IGNDOTS, (Job *)0);
3430 while (nJobs) {
3431 Job_CatchOutput();
3432#ifndef RMT_WILL_WATCH
3433 Job_CatchChildren(!usePipes);
3434#endif /* RMT_WILL_WATCH */
3435 }
3436 }
3437 }
3438}
3439
3440/*
3441 *-----------------------------------------------------------------------
3442 * Job_End --
3443 * Do final processing such as the running of the commands
3444 * attached to the .END target.
3445 *
3446 * Results:
3447 * Number of errors reported.
3448 *-----------------------------------------------------------------------
3449 */
3450int
3451Job_End()
3452{
3453 if (postCommands != NILGNODE && !Lst_IsEmpty(postCommands->commands)) {
3454 if (errors) {
3455 Error("Errors reported so .END ignored");
3456 } else {
3457 JobStart(postCommands, JOB_SPECIAL | JOB_IGNDOTS, NULL);
3458
3459 while (nJobs) {
3460 Job_CatchOutput();
3461#ifndef RMT_WILL_WATCH
3462 Job_CatchChildren(!usePipes);
3463#endif /* RMT_WILL_WATCH */
3464 }
3465 }
3466 }
3467 return(errors);
3468}
3469
3470/*-
3471 *-----------------------------------------------------------------------
3472 * Job_Wait --
3473 * Waits for all running jobs to finish and returns. Sets 'aborting'
3474 * to ABORT_WAIT to prevent other jobs from starting.
3475 *
3476 * Results:
3477 * None.
3478 *
3479 * Side Effects:
3480 * Currently running jobs finish.
3481 *
3482 *-----------------------------------------------------------------------
3483 */
3484void
3485Job_Wait()
3486{
3487 aborting = ABORT_WAIT;
3488 while (nJobs != 0) {
3489 Job_CatchOutput();
3490#ifndef RMT_WILL_WATCH
3491 Job_CatchChildren(!usePipes);
3492#endif /* RMT_WILL_WATCH */
3493 }
3494 aborting = 0;
3495}
3496
3497/*-
3498 *-----------------------------------------------------------------------
3499 * Job_AbortAll --
3500 * Abort all currently running jobs without handling output or anything.
3501 * This function is to be called only in the event of a major
3502 * error. Most definitely NOT to be called from JobInterrupt.
3503 *
3504 * Results:
3505 * None
3506 *
3507 * Side Effects:
3508 * All children are killed, not just the firstborn
3509 *-----------------------------------------------------------------------
3510 */
3511void
3512Job_AbortAll()
3513{
3514#ifdef USE_KLIB
3515 LstNode ln; /* element in job table */
3516 Job *job; /* the job descriptor in that element */
3517 KPROCRES res;
3518
3519 aborting = ABORT_ERROR;
3520
3521 if (nJobs)
3522 {
3523 Lst_Open(jobs);
3524 while ((ln = Lst_Next(jobs)) != NILLNODE)
3525 {
3526 job = (Job *) Lst_Datum(ln);
3527
3528 /*
3529 * kill the child process with increasingly drastic signals to make
3530 * darn sure it's dead.
3531 */
3532 kProcKill(job->pid, KPROCKILL_FLAGS_TREE | KPROCKILL_FLAGS_TYPE_INT);
3533 kProcKill(job->pid, KPROCKILL_FLAGS_TREE | KPROCKILL_FLAGS_TYPE_KILL);
3534 }
3535 }
3536
3537 /*
3538 * Catch as many children as want to report in at first, then give up
3539 */
3540 do
3541 {
3542 kThrdYield();
3543 } while (!kProcWait(KPID_NULL, KPROCWAIT_FLAGS_NOWAIT, &res, NULL)); /** @todo checkout this call */
3544
3545#else /* Don't use kLib */
3546 LstNode ln; /* element in job table */
3547 Job *job; /* the job descriptor in that element */
3548 int foo;
3549
3550 aborting = ABORT_ERROR;
3551
3552 if (nJobs) {
3553
3554 (void) Lst_Open(jobs);
3555 while ((ln = Lst_Next(jobs)) != NILLNODE) {
3556 job = (Job *) Lst_Datum(ln);
3557
3558 /*
3559 * kill the child process with increasingly drastic signals to make
3560 * darn sure it's dead.
3561 */
3562#ifdef RMT_WANTS_SIGNALS
3563 if (job->flags & JOB_REMOTE) {
3564 Rmt_Signal(job, SIGINT);
3565 Rmt_Signal(job, SIGKILL);
3566 } else {
3567 KILL(job->pid, SIGINT);
3568 KILL(job->pid, SIGKILL);
3569 }
3570#else
3571 KILL(job->pid, SIGINT);
3572 KILL(job->pid, SIGKILL);
3573#endif /* RMT_WANTS_SIGNALS */
3574 }
3575 }
3576
3577 /*
3578 * Catch as many children as want to report in at first, then give up
3579 */
3580 while (waitpid((pid_t) -1, &foo, WNOHANG) > 0)
3581 continue;
3582#endif /* USE_KLIB */
3583}
3584
3585#ifdef REMOTE
3586/*-
3587 *-----------------------------------------------------------------------
3588 * JobFlagForMigration --
3589 * Handle the eviction of a child. Called from RmtStatusChange.
3590 * Flags the child as remigratable and then suspends it.
3591 *
3592 * Results:
3593 * none.
3594 *
3595 * Side Effects:
3596 * The job descriptor is flagged for remigration.
3597 *
3598 *-----------------------------------------------------------------------
3599 */
3600void
3601JobFlagForMigration(hostID)
3602 int hostID; /* ID of host we used, for matching children. */
3603{
3604 register Job *job; /* job descriptor for dead child */
3605 LstNode jnode; /* list element for finding job */
3606
3607 if (DEBUG(JOB)) {
3608 (void) fprintf(stdout, "JobFlagForMigration(%d) called.\n", hostID);
3609 (void) fflush(stdout);
3610 }
3611 jnode = Lst_Find(jobs, (ClientData)hostID, JobCmpRmtID);
3612
3613 if (jnode == NILLNODE) {
3614 jnode = Lst_Find(stoppedJobs, (ClientData)hostID, JobCmpRmtID);
3615 if (jnode == NILLNODE) {
3616 if (DEBUG(JOB)) {
3617 Error("Evicting host(%d) not in table", hostID);
3618 }
3619 return;
3620 }
3621 }
3622 job = (Job *) Lst_Datum(jnode);
3623
3624 if (DEBUG(JOB)) {
3625 (void) fprintf(stdout,
3626 "JobFlagForMigration(%d) found job '%s'.\n", hostID,
3627 job->node->name);
3628 (void) fflush(stdout);
3629 }
3630
3631 KILL(job->pid, SIGSTOP);
3632
3633 job->flags |= JOB_REMIGRATE;
3634}
3635
3636#endif
3637
3638
3639#ifdef SIGCONT
3640/*-
3641 *-----------------------------------------------------------------------
3642 * JobRestartJobs --
3643 * Tries to restart stopped jobs if there are slots available.
3644 * Note that this tries to restart them regardless of pending errors.
3645 * It's not good to leave stopped jobs lying around!
3646 *
3647 * Results:
3648 * None.
3649 *
3650 * Side Effects:
3651 * Resumes(and possibly migrates) jobs.
3652 *
3653 *-----------------------------------------------------------------------
3654 */
3655static void
3656JobRestartJobs()
3657{
3658 while (!jobFull && !Lst_IsEmpty(stoppedJobs)) {
3659 if (DEBUG(JOB)) {
3660 (void) fprintf(stdout,
3661 "Job queue is not full. Restarting a stopped job.\n");
3662 (void) fflush(stdout);
3663 }
3664 JobRestart((Job *)Lst_DeQueue(stoppedJobs));
3665 }
3666}
3667#endif
Note: See TracBrowser for help on using the repository browser.