GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: usr.bin/make/engine.c Lines: 214 342 62.6 %
Date: 2017-11-13 Branches: 161 299 53.8 %

Line Branch Exec Source
1
/*	$OpenBSD: engine.c,v 1.54 2017/07/24 12:08:15 espie Exp $ */
2
/*
3
 * Copyright (c) 2012 Marc Espie.
4
 *
5
 * Extensive code modifications for the OpenBSD project.
6
 *
7
 * Redistribution and use in source and binary forms, with or without
8
 * modification, are permitted provided that the following conditions
9
 * are met:
10
 * 1. Redistributions of source code must retain the above copyright
11
 *    notice, this list of conditions and the following disclaimer.
12
 * 2. Redistributions in binary form must reproduce the above copyright
13
 *    notice, this list of conditions and the following disclaimer in the
14
 *    documentation and/or other materials provided with the distribution.
15
 *
16
 * THIS SOFTWARE IS PROVIDED BY THE OPENBSD PROJECT AND CONTRIBUTORS
17
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OPENBSD
20
 * PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
/*
29
 * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
30
 * Copyright (c) 1988, 1989 by Adam de Boor
31
 * Copyright (c) 1989 by Berkeley Softworks
32
 * All rights reserved.
33
 *
34
 * This code is derived from software contributed to Berkeley by
35
 * Adam de Boor.
36
 *
37
 * Redistribution and use in source and binary forms, with or without
38
 * modification, are permitted provided that the following conditions
39
 * are met:
40
 * 1. Redistributions of source code must retain the above copyright
41
 *    notice, this list of conditions and the following disclaimer.
42
 * 2. Redistributions in binary form must reproduce the above copyright
43
 *    notice, this list of conditions and the following disclaimer in the
44
 *    documentation and/or other materials provided with the distribution.
45
 * 3. Neither the name of the University nor the names of its contributors
46
 *    may be used to endorse or promote products derived from this software
47
 *    without specific prior written permission.
48
 *
49
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59
 * SUCH DAMAGE.
60
 */
61
62
#include <sys/types.h>
63
#include <sys/time.h>
64
#include <sys/wait.h>
65
#include <assert.h>
66
#include <ctype.h>
67
#include <errno.h>
68
#include <fcntl.h>
69
#include <limits.h>
70
#include <signal.h>
71
#include <stdint.h>
72
#include <stdio.h>
73
#include <stdlib.h>
74
#include <string.h>
75
#include <unistd.h>
76
#include "config.h"
77
#include "defines.h"
78
#include "dir.h"
79
#include "engine.h"
80
#include "arch.h"
81
#include "gnode.h"
82
#include "targ.h"
83
#include "var.h"
84
#include "extern.h"
85
#include "lst.h"
86
#include "timestamp.h"
87
#include "make.h"
88
#include "pathnames.h"
89
#include "error.h"
90
#include "str.h"
91
#include "memory.h"
92
#include "buf.h"
93
#include "job.h"
94
#include "lowparse.h"
95
96
static void MakeTimeStamp(void *, void *);
97
static int rewrite_time(const char *);
98
static void setup_meta(void);
99
static void setup_engine(void);
100
static char **recheck_command_for_shell(char **);
101
static void list_parents(GNode *, FILE *);
102
103
/* XXX due to a bug in make's logic, targets looking like *.a or -l*
104
 * have been silently dropped when make couldn't figure them out.
105
 * Now, we warn about them until all Makefile bugs have been fixed.
106
 */
107
static bool
108
drop_silently(const char *s)
109
{
110
	size_t len;
111
112

4
	if (s[0] == '-' && s[1] == 'l')
113
		return true;
114
115
2
	len = strlen(s);
116

4
	if (len >=2 && s[len-2] == '.' && s[len-1] == 'a')
117
		return true;
118
2
	return false;
119
2
}
120
121
bool
122
node_find_valid_commands(GNode *gn)
123
{
124
	/* Alter our type to tell if errors should be ignored or things
125
	 * should not be printed so setup_and_run_command knows what to do.
126
	 */
127
112374
	if (Targ_Ignore(gn))
128
		gn->type |= OP_IGNORE;
129
56187
	if (Targ_Silent(gn))
130
1944
		gn->type |= OP_SILENT;
131
132

56187
	if (DEBUG(DOUBLE) && (gn->type & OP_DOUBLE))
133
		fprintf(stderr, "Warning: target %s had >1 lists of "
134
		    "shell commands (ignoring later ones)\n", gn->name);
135

65802
	if (OP_NOP(gn->type) && Lst_IsEmpty(&gn->commands)) {
136
2
		if (drop_silently(gn->name)) {
137
			printf("Warning: target %s", gn->name);
138
			list_parents(gn, stdout);
139
			printf(" does not have any command (BUG)\n");
140
			return true;
141
		}
142
		/*
143
		 * No commands. Look for .DEFAULT rule from which we might infer
144
		 * commands
145
		 */
146

2
		if ((gn->type & OP_NODEFAULT) == 0 &&
147
2
		    (DEFAULT->type & OP_DUMMY) == 0 &&
148
		    !Lst_IsEmpty(&DEFAULT->commands)) {
149
			/*
150
			 * Make only looks for a .DEFAULT if the node was never
151
			 * the target of an operator, so that's what we do too.
152
			 * If a .DEFAULT was given, we substitute its commands
153
			 * for gn's commands and set the IMPSRC variable to be
154
			 * the target's name The DEFAULT node acts like a
155
			 * transformation rule, in that gn also inherits any
156
			 * attributes or sources attached to .DEFAULT itself.
157
			 */
158
			Make_HandleUse(DEFAULT, gn);
159
			Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn);
160

4
		} else if (is_out_of_date(Dir_MTime(gn))) {
161
			/*
162
			 * The node wasn't the target of an operator we have no
163
			 * .DEFAULT rule to go on and the target doesn't
164
			 * already exist. There's nothing more we can do for
165
			 * this branch.
166
			 */
167
2
			 return false;
168
	    	}
169
	}
170
56185
	return true;
171
56187
}
172
173
static void
174
list_parents(GNode *gn, FILE *out)
175
{
176
	LstNode ln;
177
	bool first = true;
178
179
6
	for (ln = Lst_First(&gn->parents); ln != NULL; ln = Lst_Adv(ln)) {
180
		GNode *p = Lst_Datum(ln);
181
		if (!p->must_make)
182
			continue;
183
		if (first) {
184
			fprintf(out, " (prerequisite of:");
185
			first = false;
186
		}
187
		fprintf(out, " %s", p->name);
188
	}
189
2
	if (!first)
190
		fprintf(out, ")");
191
2
}
192
193
void
194
node_failure(GNode *gn)
195
{
196
	/*
197
	 If the -k flag wasn't given, we stop in
198
	 * our tracks, otherwise we just don't update this
199
	 * node's parents so they never get examined.
200
	 */
201
	const char *diag;
202
	FILE *out;
203
204
4
	if (gn->type & OP_OPTIONAL) {
205
		out = stdout;
206
		diag = "(ignored)";
207
2
	} else if (keepgoing) {
208
		out = stdout;
209
		diag = "(continuing)";
210
	} else {
211
		out = stderr;
212
		diag = "";
213
	}
214
2
	fprintf(out, "make: don't know how to make %s", gn->name);
215
2
	list_parents(gn, out);
216
2
	fprintf(out, "%s\n", diag);
217
2
	if (out == stdout)
218
		fflush(stdout);
219
	else {
220
2
		print_errors();
221
2
		Punt(NULL);
222
	}
223
}
224
225
/* touch files the hard way, by writing stuff to them */
226
static int
227
rewrite_time(const char *name)
228
{
229
	int fd;
230
	char c;
231
232
	fd = open(name, O_RDWR | O_CREAT, 0666);
233
	if (fd < 0)
234
		return -1;
235
	/*
236
	 * Read and write a byte to the file to change
237
	 * the modification time.
238
	 */
239
	if (read(fd, &c, 1) == 1) {
240
		(void)lseek(fd, 0, SEEK_SET);
241
		(void)write(fd, &c, 1);
242
	}
243
244
	(void)close(fd);
245
	return 0;
246
}
247
248
void
249
Job_Touch(GNode *gn)
250
{
251
	handle_all_signals();
252
	if (gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_OPTIONAL|OP_PHONY)) {
253
		/*
254
		 * .JOIN, .USE, and .OPTIONAL targets are "virtual" targets
255
		 * and, as such, shouldn't really be created.
256
		 * Likewise, .PHONY targets are not really files
257
		 */
258
		return;
259
	}
260
261
	if (!(gn->type & OP_SILENT)) {
262
		(void)fprintf(stdout, "touch %s\n", gn->name);
263
		(void)fflush(stdout);
264
	}
265
266
	if (noExecute) {
267
		return;
268
	}
269
270
	if (gn->type & OP_ARCHV) {
271
		Arch_Touch(gn);
272
	} else {
273
		const char *file = gn->path != NULL ? gn->path : gn->name;
274
275
		if (set_times(file) == -1){
276
			if (rewrite_time(file) == -1) {
277
				(void)fprintf(stderr,
278
				    "*** couldn't touch %s: %s", file,
279
				    strerror(errno));
280
		    	}
281
		}
282
	}
283
}
284
285
void
286
Make_TimeStamp(GNode *parent, GNode *child)
287
{
288

3151788
	if (is_strictly_before(parent->youngest->mtime, child->mtime)) {
289
505653
 		parent->youngest = child;
290
505653
	}
291
1050596
}
292
293
void
294
Make_HandleUse(GNode	*cgn,	/* The .USE node */
295
    GNode	*pgn)	/* The target of the .USE node */
296
{
297
	GNode	*gn;	/* A child of the .USE node */
298
	LstNode	ln;	/* An element in the children list */
299
300
301
82342
	assert(cgn->type & (OP_USE|OP_TRANSFORM));
302
303
41171
	if (pgn == NULL)
304
		Fatal("Trying to apply .USE to '%s' without a parent",
305
		    cgn->name);
306
307

75420
	if ((cgn->type & OP_USE) || Lst_IsEmpty(&pgn->commands)) {
308
		/* .USE or transformation and target has no commands
309
		 * -- append the child's commands to the parent.  */
310
41111
		Lst_Concat(&pgn->commands, &cgn->commands);
311
41111
	}
312
313
82342
	for (ln = Lst_First(&cgn->children); ln != NULL;
314
	    ln = Lst_Adv(ln)) {
315
		gn = Lst_Datum(ln);
316
317
		if (Lst_AddNew(&pgn->children, gn)) {
318
			Lst_AtEnd(&gn->parents, pgn);
319
			pgn->unmade++;
320
		}
321
	}
322
323

41171
	if (DEBUG(DOUBLE) && (cgn->type & OP_DOUBLE))
324
		fprintf(stderr,
325
		    "Warning: .USE %s expanded in %s had >1 lists of "
326
		    "shell commands (ignoring later ones)\n",
327
		    cgn->name, pgn->name);
328
41171
	pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM|OP_DOUBLE);
329
330
	/*
331
	 * This child node is now "made", so we decrement the count of
332
	 * unmade children in the parent... We also remove the child
333
	 * from the parent's list to accurately reflect the number of
334
	 * decent children the parent has. This is used by Make_Run to
335
	 * decide whether to queue the parent or examine its children...
336
	 */
337
41171
	if (cgn->type & OP_USE)
338
6922
		pgn->unmade--;
339
41171
}
340
341
void
342
Make_DoAllVar(GNode *gn)
343
{
344
	GNode *child;
345
	LstNode ln;
346
111872
	BUFFER allsrc, oodate;
347
	char *target;
348
	bool do_oodate;
349
	int oodate_count, allsrc_count = 0;
350
351
	oodate_count = 0;
352
	allsrc_count = 0;
353
354
55936
	Var(OODATE_INDEX, gn) = "";
355
55936
	Var(ALLSRC_INDEX, gn) = "";
356
357
464830
	for (ln = Lst_First(&gn->children); ln != NULL; ln = Lst_Adv(ln)) {
358
176479
		child = Lst_Datum(ln);
359
176479
		if ((child->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) != 0)
360
			continue;
361

293230
		if (OP_NOP(child->type) ||
362
123673
		    (target = Var(TARGET_INDEX, child)) == NULL) {
363
			/*
364
			 * this node is only source; use the specific pathname
365
			 * for it
366
			 */
367
137652
			target = child->path != NULL ? child->path :
368
			    child->name;
369
45884
		}
370
371
		/*
372
		 * It goes in the OODATE variable if the parent is younger than
373
		 * the child or if the child has been modified more recently
374
		 * than the start of the make.  This is to keep make from
375
		 * getting confused if something else updates the parent after
376
		 * the make starts (shouldn't happen, I know, but sometimes it
377
		 * does). In such a case, if we've updated the kid, the parent
378
		 * is likely to have a modification time later than that of the
379
		 * kid and anything that relies on the OODATE variable will be
380
		 * hosed.
381
		 */
382
		do_oodate = false;
383
169557
		if (gn->type & OP_JOIN) {
384
			if (child->built_status == MADE)
385
				do_oodate = true;
386


339114
		} else if (is_strictly_before(gn->mtime, child->mtime) ||
387

250
		   (!is_strictly_before(child->mtime, starttime) &&
388
		   child->built_status == MADE))
389
169432
		   	do_oodate = true;
390
169557
		if (do_oodate) {
391
169432
			oodate_count++;
392
169432
			if (oodate_count == 1)
393
41417
				Var(OODATE_INDEX, gn) = target;
394
			else {
395
128015
				if (oodate_count == 2) {
396
13880
					Buf_Init(&oodate, 0);
397
13880
					Buf_AddString(&oodate,
398
					    Var(OODATE_INDEX, gn));
399
13880
				}
400
256395
				Buf_AddSpace(&oodate);
401
128015
				Buf_AddString(&oodate, target);
402
			}
403
		}
404
169557
		allsrc_count++;
405
169557
		if (allsrc_count == 1)
406
41417
			Var(ALLSRC_INDEX, gn) = target;
407
		else {
408
128140
			if (allsrc_count == 2) {
409
13891
				Buf_Init(&allsrc, 0);
410
13891
				Buf_AddString(&allsrc,
411
				    Var(ALLSRC_INDEX, gn));
412
13891
			}
413
256645
			Buf_AddSpace(&allsrc);
414
128140
			Buf_AddString(&allsrc, target);
415
		}
416
	}
417
418
55936
	if (allsrc_count > 1)
419
13891
		Var(ALLSRC_INDEX, gn) = Buf_Retrieve(&allsrc);
420
55936
	if (oodate_count > 1)
421
13880
		Var(OODATE_INDEX, gn) = Buf_Retrieve(&oodate);
422
423
55936
	if (gn->impliedsrc)
424
23311
		Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn->impliedsrc);
425
426
55936
	if (gn->type & OP_JOIN)
427
		Var(TARGET_INDEX, gn) = Var(ALLSRC_INDEX, gn);
428
55936
}
429
430
/* Wrapper to call Make_TimeStamp from a forEach loop.	*/
431
static void
432
MakeTimeStamp(void *parent, void *child)
433
{
434
1427574
    Make_TimeStamp(parent, child);
435
713787
}
436
437
bool
438
Make_OODate(GNode *gn)
439
{
440
	bool	    oodate;
441
442
	/*
443
	 * Certain types of targets needn't even be sought as their datedness
444
	 * doesn't depend on their modification time...
445
	 */
446
435328
	if ((gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_PHONY)) == 0) {
447
190869
		(void)Dir_MTime(gn);
448
190869
		if (DEBUG(MAKE)) {
449
			if (!is_out_of_date(gn->mtime))
450
				printf("modified %s...",
451
				    time_to_string(&gn->mtime));
452
			else
453
				printf("non-existent...");
454
		}
455
	}
456
457
	/*
458
	 * A target is remade in one of the following circumstances:
459
	 * - its modification time is smaller than that of its youngest child
460
	 *   and it would actually be run (has commands or type OP_NOP)
461
	 * - it's the object of a force operator
462
	 * - it has no children, was on the lhs of an operator and doesn't
463
	 *   exist already.
464
	 *
465
	 */
466
217664
	if (gn->type & OP_USE) {
467
		/*
468
		 * If the node is a USE node it is *never* out of date
469
		 * no matter *what*.
470
		 */
471
		if (DEBUG(MAKE))
472
			printf(".USE node...");
473
		oodate = false;
474
217664
	} else if (gn->type & OP_JOIN) {
475
		/*
476
		 * A target with the .JOIN attribute is only considered
477
		 * out-of-date if any of its children was out-of-date.
478
		 */
479
		if (DEBUG(MAKE))
480
			printf(".JOIN node...");
481
		oodate = gn->childMade;
482
217664
	} else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) {
483
		/*
484
		 * A node which is the object of the force (!) operator or which
485
		 * has the .EXEC attribute is always considered out-of-date.
486
		 */
487
26795
		if (DEBUG(MAKE)) {
488
			if (gn->type & OP_FORCE)
489
				printf("! operator...");
490
			else if (gn->type & OP_PHONY)
491
				printf(".PHONY node...");
492
			else
493
				printf(".EXEC node...");
494
		}
495
		oodate = true;
496


554165
	} else if (is_strictly_before(gn->mtime, gn->youngest->mtime) ||
497
164819
	   (gn == gn->youngest &&
498

297446
	    (is_out_of_date(gn->mtime) || (gn->type & OP_DOUBLEDEP)))) {
499
		/*
500
		 * A node whose modification time is less than that of its
501
		 * youngest child or that has no children (gn->youngest == gn)
502
		 * and either doesn't exist (mtime == OUT_OF_DATE)
503
		 * or was the object of a :: operator is out-of-date.
504
		 */
505
29141
		if (DEBUG(MAKE)) {
506
			if (is_strictly_before(gn->mtime, gn->youngest->mtime))
507
				printf("modified before source(%s)...",
508
				    gn->youngest->name);
509
			else if (is_out_of_date(gn->mtime))
510
				printf("non-existent and no sources...");
511
			else
512
				printf(":: operator and no sources...");
513
		}
514
		oodate = true;
515
29141
	} else {
516
		oodate = false;
517
	}
518
519
	/*
520
	 * If the target isn't out-of-date, the parents need to know its
521
	 * modification time. Note that targets that appear to be out-of-date
522
	 * but aren't, because they have no commands and aren't of type OP_NOP,
523
	 * have their mtime stay below their children's mtime to keep parents
524
	 * from thinking they're out-of-date.
525
	 */
526
217664
	if (!oodate)
527
161728
		Lst_ForEach(&gn->parents, MakeTimeStamp, gn);
528
529
217664
	return oodate;
530
}
531
532
/* The following array is used to make a fast determination of which
533
 * characters are interpreted specially by the shell.  If a command
534
 * contains any of these characters, it is executed by the shell, not
535
 * directly by us.  */
536
static char	    meta[256];
537
538
void
539
setup_meta(void)
540
{
541
	char *p;
542
543
790258
	for (p = "#=|^(){};&<>*?[]:$`\\\n~"; *p != '\0'; p++)
544
369908
		meta[(unsigned char) *p] = 1;
545
	/* The null character serves as a sentinel in the string.  */
546
16814
	meta[0] = 1;
547
16814
}
548
549
static char **
550
recheck_command_for_shell(char **av)
551
{
552
	char *runsh[] = {
553
		"!", "alias", "cd", "eval", "exit", "read", "set", "ulimit",
554
		"unalias", "unset", "wait", "umask", NULL
555
	};
556
557
	char **p;
558
559
	/* optimization: if exec cmd, we avoid the intermediate shell */
560
	if (strcmp(av[0], "exec") == 0)
561
		av++;
562
563
	for (p = runsh; *p; p++)
564
		if (strcmp(av[0], *p) == 0)
565
			return NULL;
566
567
	return av;
568
}
569
570
static void
571
run_command(const char *cmd, bool errCheck)
572
{
573
	const char *p;
574
	char *shargv[4];
575
	char **todo;
576
577
	shargv[0] = _PATH_BSHELL;
578
579
	shargv[1] = errCheck ? "-ec" : "-c";
580
	shargv[2] = (char *)cmd;
581
	shargv[3] = NULL;
582
583
	todo = shargv;
584
585
586
	/* Search for meta characters in the command. If there are no meta
587
	 * characters, there's no need to execute a shell to execute the
588
	 * command.  */
589
	for (p = cmd; !meta[(unsigned char)*p]; p++)
590
		continue;
591
	if (*p == '\0') {
592
		char *bp;
593
		char **av;
594
		int argc;
595
		/* No meta-characters, so probably no need to exec a shell.
596
		 * Break the command into words to form an argument vector
597
		 * we can execute.  */
598
		av = brk_string(cmd, &argc, &bp);
599
		av = recheck_command_for_shell(av);
600
		if (av != NULL)
601
			todo = av;
602
	}
603
	execvp(todo[0], todo);
604
605
	if (errno == ENOENT)
606
		fprintf(stderr, "%s: not found\n", todo[0]);
607
	else
608
		perror(todo[0]);
609
	_exit(1);
610
}
611
612
static Job myjob;
613
614
void
615
job_attach_node(Job *job, GNode *node)
616
{
617
112908
	job->node = node;
618
56454
	job->node->built_status = BUILDING;
619
56454
	job->next_cmd = Lst_First(&node->commands);
620
56454
	job->exit_type = JOB_EXIT_OKAY;
621
56454
	job->location = NULL;
622
56454
	job->flags = 0;
623
56454
}
624
625
void
626
job_handle_status(Job *job, int status)
627
{
628
	bool silent;
629
	int dying;
630
631
	/* if there's one job running and we don't keep going, no need
632
	 * to report right now.
633
	 */
634

387175
	if ((job->flags & JOB_ERRCHECK) && !keepgoing && runningJobs == NULL)
635
111619
		silent = !DEBUG(JOB);
636
	else
637
		silent = false;
638
639
137778
	debug_job_printf("Process %ld (%s) exited with status %d.\n",
640
137778
	    (long)job->pid, job->node->name, status);
641
642
	/* classify status */
643
137778
	if (WIFEXITED(status)) {
644
137772
		job->code = WEXITSTATUS(status);/* exited */
645
137772
		if (job->code != 0) {
646
			/* if we're already dying from that signal, be silent */
647

361
			if (!silent && job->code > 128
648
111
			    && job->code <= 128 + _NSIG) {
649
				dying = check_dying_signal();
650
				silent = dying && job->code == dying + 128;
651
			}
652
250
			if (!silent)
653
111
				printf("*** Error %d", job->code);
654
			job->exit_type = JOB_EXIT_BAD;
655
250
		} else
656
			job->exit_type = JOB_EXIT_OKAY;
657
137772
	} else {
658
6
		job->exit_type = JOB_SIGNALED;
659
6
		job->code = WTERMSIG(status);	/* signaled */
660
		/* if we're already dying from that signal, be silent */
661
6
		if (!silent) {
662
			dying = check_dying_signal();
663
			silent = dying && job->code == dying;
664
		}
665
6
		if (!silent)
666
			printf("*** Signal %d", job->code);
667
	}
668
669
	/* if there is a problem, what's going on ? */
670
137778
	if (job->exit_type != JOB_EXIT_OKAY) {
671
256
		if (!silent)
672
111
			printf(" in target '%s'", job->node->name);
673
256
		if (job->flags & JOB_ERRCHECK) {
674
145
			job->node->built_status = ERROR;
675
			/* compute expensive status if we really want it */
676
145
			if ((job->flags & JOB_SILENT) && job == &myjob)
677
37
				determine_expensive_job(job);
678
145
			if (!keepgoing) {
679
145
				if (!silent)
680
					printf("\n");
681
145
				job->next = errorJobs;
682
145
				errorJobs = job;
683
				/* XXX don't free the command */
684
145
				return;
685
			}
686
			printf(", line %lu of %s", job->location->lineno,
687
			    job->location->fname);
688
			if ((job->flags & (JOB_SILENT | JOB_IS_EXPENSIVE))
689
			    == JOB_SILENT)
690
				printf(": %s", job->cmd);
691
			/* Abort the current target,
692
			 * but let others continue.  */
693
			printf(" (continuing)\n");
694
		} else {
695
			/* Continue executing commands for
696
			 * this target.  If we return 0,
697
			 * this will happen...  */
698
111
			printf(" (ignored)\n");
699
111
			job->exit_type = JOB_EXIT_OKAY;
700
		}
701
	}
702
137633
	free(job->cmd);
703
275411
}
704
705
int
706
run_gnode(GNode *gn)
707
{
708

217896
	if (!gn || (gn->type & OP_DUMMY))
709
16429
		return NOSUCHNODE;
710
711
56203
	gn->built_status = MADE;
712
713
56203
	job_attach_node(&myjob, gn);
714
386190
	while (myjob.exit_type == JOB_EXIT_OKAY) {
715
192950
		bool finished = job_run_next(&myjob);
716
192950
		if (finished)
717
56058
			break;
718
136892
		handle_one_job(&myjob);
719
136892
	}
720
721
56203
	return gn->built_status;
722
72632
}
723
724
725
static void
726
setup_engine(void)
727
{
728
	static int already_setup = 0;
729
730
387672
	if (!already_setup) {
731
16814
		setup_meta();
732
16814
		already_setup = 1;
733
16814
	}
734
193836
}
735
736
static bool
737
do_run_command(Job *job, const char *pre)
738
{
739
	bool silent;	/* Don't print command */
740
	bool doExecute;	/* Execute the command */
741
	bool errCheck;	/* Check errors */
742
	pid_t cpid; 	/* Child pid */
743
744
275850
	const char *cmd = job->cmd;
745
137925
	silent = job->node->type & OP_SILENT;
746
137925
	errCheck = !(job->node->type & OP_IGNORE);
747
137925
	if (job->node->type & OP_MAKE)
748
		doExecute = true;
749
	else
750
137925
		doExecute = !noExecute;
751
752
	/* How can we execute a null command ? we warn the user that the
753
	 * command expanded to nothing (is this the right thing to do?).  */
754
137925
	if (*cmd == '\0') {
755
		Parse_Error(PARSE_WARNING,
756
		    "'%s' expands to '' while building %s",
757
		    pre, job->node->name);
758
		return false;
759
	}
760
761
273128
	for (;; cmd++) {
762
273128
		if (*cmd == '@')
763
109044
			silent = DEBUG(LOUD) ? false : true;
764
164084
		else if (*cmd == '-')
765
26159
			errCheck = false;
766
137925
		else if (*cmd == '+')
767
			doExecute = true;
768
		else
769
			break;
770
	}
771
281930
	while (ISSPACE(*cmd))
772
3040
		cmd++;
773
	/* Print the command before fork if make -n or !silent*/
774

275850
	if ( noExecute || !silent)
775
16467
		printf("%s\n", cmd);
776
777
275850
	if (silent)
778
137925
		job->flags |= JOB_SILENT;
779
	else
780
137925
		job->flags &= ~JOB_SILENT;
781
782
	/* If we're not supposed to execute any commands, this is as far as
783
	 * we go...  */
784
137925
	if (!doExecute)
785
		return false;
786
	/* always flush for other stuff */
787
137925
	fflush(stdout);
788
789
	/* Optimization: bypass comments entirely */
790
137925
	if (*cmd == '#')
791
147
		return false;
792
793
	/* Fork and execute the single command. If the fork fails, we abort.  */
794
137778
	switch (cpid = fork()) {
795
	case -1:
796
		Punt("Could not fork");
797
		/*NOTREACHED*/
798
	case 0:
799
		/* put a random delay unless we're the only job running
800
		 * and there's nothing left to do.
801
		 */
802
		if (random_delay)
803
			if (!(runningJobs == NULL && no_jobs_left()))
804
				usleep(arc4random_uniform(random_delay));
805
		run_command(cmd, errCheck);
806
		/*NOTREACHED*/
807
	default:
808
137778
		job->pid = cpid;
809
137778
		job->next = runningJobs;
810
137778
		runningJobs = job;
811
275556
		if (errCheck)
812
137778
			job->flags |= JOB_ERRCHECK;
813
		else
814
137778
			job->flags &= ~JOB_ERRCHECK;
815
275556
		debug_job_printf("Running %ld (%s) %s\n", (long)job->pid,
816

534792
		    job->node->name, (noExecute || !silent) ? "" : cmd);
817
137778
		return true;
818
	}
819
137925
}
820
821
bool
822
job_run_next(Job *job)
823
{
824
	bool started;
825
387672
	GNode *gn = job->node;
826
827
193836
	setup_engine();
828
387966
	while (job->next_cmd != NULL) {
829
137925
		struct command *command = Lst_Datum(job->next_cmd);
830
831
137925
		handle_all_signals();
832
137925
		job->location = &command->location;
833
137925
		Parse_SetLocation(job->location);
834
137925
		job->cmd = Var_Subst(command->string, &gn->context, false);
835
137925
		job->next_cmd = Lst_Adv(job->next_cmd);
836
137925
		if (fatal_errors)
837
			Punt(NULL);
838
137925
		started = do_run_command(job, command->string);
839
137925
		if (started)
840
137778
			return false;
841
		else
842
147
			free(job->cmd);
843
147
	}
844
56058
	job->exit_type = JOB_EXIT_OKAY;
845
56058
	return true;
846
193836
}
847