Context Navigation

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

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: