1 /* $OpenBSD: engine.c,v 1.47 2013/11/22 15:47:35 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 if (s[0] == '-' && s[1] == 'l') 113 return true; 114 115 len = strlen(s); 116 if (len >=2 && s[len-2] == '.' && s[len-1] == 'a') 117 return true; 118 return false; 119 } 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 if (Targ_Ignore(gn)) 128 gn->type |= OP_IGNORE; 129 if (Targ_Silent(gn)) 130 gn->type |= OP_SILENT; 131 132 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 if (OP_NOP(gn->type) && Lst_IsEmpty(&gn->commands)) { 136 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 if ((gn->type & OP_NODEFAULT) == 0 && 147 (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 } 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 return false; 168 } 169 } 170 return true; 171 } 172 173 static void 174 list_parents(GNode *gn, FILE *out) 175 { 176 LstNode ln; 177 bool first = true; 178 179 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 if (!first) 190 fprintf(out, ")"); 191 } 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 if (gn->type & OP_OPTIONAL) { 205 out = stdout; 206 diag = "(ignored)"; 207 } else if (keepgoing) { 208 out = stdout; 209 diag = "(continuing)"; 210 } else { 211 out = stderr; 212 diag = ""; 213 } 214 fprintf(out, "make: don't know how to make %s", gn->name); 215 list_parents(gn, out); 216 fprintf(out, "%s\n", diag); 217 if (out == stdout) 218 fflush(stdout); 219 else { 220 print_errors(); 221 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(stdout, 278 "*** couldn't touch %s: %s", file, 279 strerror(errno)); 280 (void)fflush(stdout); 281 } 282 } 283 } 284 } 285 286 void 287 Make_TimeStamp(GNode *parent, GNode *child) 288 { 289 if (is_strictly_before(parent->youngest->mtime, child->mtime)) { 290 parent->youngest = child; 291 } 292 } 293 294 void 295 Make_HandleUse(GNode *cgn, /* The .USE node */ 296 GNode *pgn) /* The target of the .USE node */ 297 { 298 GNode *gn; /* A child of the .USE node */ 299 LstNode ln; /* An element in the children list */ 300 301 302 assert(cgn->type & (OP_USE|OP_TRANSFORM)); 303 304 if ((cgn->type & OP_USE) || Lst_IsEmpty(&pgn->commands)) { 305 /* .USE or transformation and target has no commands 306 * -- append the child's commands to the parent. */ 307 Lst_Concat(&pgn->commands, &cgn->commands); 308 } 309 310 for (ln = Lst_First(&cgn->children); ln != NULL; 311 ln = Lst_Adv(ln)) { 312 gn = (GNode *)Lst_Datum(ln); 313 314 if (Lst_AddNew(&pgn->children, gn)) { 315 Lst_AtEnd(&gn->parents, pgn); 316 pgn->unmade++; 317 } 318 } 319 320 if (DEBUG(DOUBLE) && (cgn->type & OP_DOUBLE)) 321 fprintf(stderr, 322 "Warning: .USE %s expanded in %s had >1 lists of " 323 "shell commands (ignoring later ones)\n", 324 cgn->name, pgn->name); 325 pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM|OP_DOUBLE); 326 327 /* 328 * This child node is now "made", so we decrement the count of 329 * unmade children in the parent... We also remove the child 330 * from the parent's list to accurately reflect the number of 331 * decent children the parent has. This is used by Make_Run to 332 * decide whether to queue the parent or examine its children... 333 */ 334 if (cgn->type & OP_USE) 335 pgn->unmade--; 336 } 337 338 void 339 Make_DoAllVar(GNode *gn) 340 { 341 GNode *child; 342 LstNode ln; 343 BUFFER allsrc, oodate; 344 char *target; 345 bool do_oodate; 346 int oodate_count, allsrc_count = 0; 347 348 oodate_count = 0; 349 allsrc_count = 0; 350 351 Var(OODATE_INDEX, gn) = ""; 352 Var(ALLSRC_INDEX, gn) = ""; 353 354 for (ln = Lst_First(&gn->children); ln != NULL; ln = Lst_Adv(ln)) { 355 child = (GNode *)Lst_Datum(ln); 356 if ((child->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) != 0) 357 continue; 358 if (OP_NOP(child->type) || 359 (target = Var(TARGET_INDEX, child)) == NULL) { 360 /* 361 * this node is only source; use the specific pathname 362 * for it 363 */ 364 target = child->path != NULL ? child->path : 365 child->name; 366 } 367 368 /* 369 * It goes in the OODATE variable if the parent is younger than 370 * the child or if the child has been modified more recently 371 * than the start of the make. This is to keep make from 372 * getting confused if something else updates the parent after 373 * the make starts (shouldn't happen, I know, but sometimes it 374 * does). In such a case, if we've updated the kid, the parent 375 * is likely to have a modification time later than that of the 376 * kid and anything that relies on the OODATE variable will be 377 * hosed. 378 */ 379 do_oodate = false; 380 if (gn->type & OP_JOIN) { 381 if (child->built_status == MADE) 382 do_oodate = true; 383 } else if (is_strictly_before(gn->mtime, child->mtime) || 384 (!is_strictly_before(child->mtime, starttime) && 385 child->built_status == MADE)) 386 do_oodate = true; 387 if (do_oodate) { 388 oodate_count++; 389 if (oodate_count == 1) 390 Var(OODATE_INDEX, gn) = target; 391 else { 392 if (oodate_count == 2) { 393 Buf_Init(&oodate, 0); 394 Buf_AddString(&oodate, 395 Var(OODATE_INDEX, gn)); 396 } 397 Buf_AddSpace(&oodate); 398 Buf_AddString(&oodate, target); 399 } 400 } 401 allsrc_count++; 402 if (allsrc_count == 1) 403 Var(ALLSRC_INDEX, gn) = target; 404 else { 405 if (allsrc_count == 2) { 406 Buf_Init(&allsrc, 0); 407 Buf_AddString(&allsrc, 408 Var(ALLSRC_INDEX, gn)); 409 } 410 Buf_AddSpace(&allsrc); 411 Buf_AddString(&allsrc, target); 412 } 413 } 414 415 if (allsrc_count > 1) 416 Var(ALLSRC_INDEX, gn) = Buf_Retrieve(&allsrc); 417 if (oodate_count > 1) 418 Var(OODATE_INDEX, gn) = Buf_Retrieve(&oodate); 419 420 if (gn->impliedsrc) 421 Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn->impliedsrc); 422 423 if (gn->type & OP_JOIN) 424 Var(TARGET_INDEX, gn) = Var(ALLSRC_INDEX, gn); 425 } 426 427 /* Wrapper to call Make_TimeStamp from a forEach loop. */ 428 static void 429 MakeTimeStamp(void *parent, void *child) 430 { 431 Make_TimeStamp((GNode *)parent, (GNode *)child); 432 } 433 434 bool 435 Make_OODate(GNode *gn) 436 { 437 bool oodate; 438 439 /* 440 * Certain types of targets needn't even be sought as their datedness 441 * doesn't depend on their modification time... 442 */ 443 if ((gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_PHONY)) == 0) { 444 (void)Dir_MTime(gn); 445 if (DEBUG(MAKE)) { 446 if (!is_out_of_date(gn->mtime)) 447 printf("modified %s...", 448 time_to_string(&gn->mtime)); 449 else 450 printf("non-existent..."); 451 } 452 } 453 454 /* 455 * A target is remade in one of the following circumstances: 456 * - its modification time is smaller than that of its youngest child 457 * and it would actually be run (has commands or type OP_NOP) 458 * - it's the object of a force operator 459 * - it has no children, was on the lhs of an operator and doesn't 460 * exist already. 461 * 462 */ 463 if (gn->type & OP_USE) { 464 /* 465 * If the node is a USE node it is *never* out of date 466 * no matter *what*. 467 */ 468 if (DEBUG(MAKE)) 469 printf(".USE node..."); 470 oodate = false; 471 } else if (gn->type & OP_JOIN) { 472 /* 473 * A target with the .JOIN attribute is only considered 474 * out-of-date if any of its children was out-of-date. 475 */ 476 if (DEBUG(MAKE)) 477 printf(".JOIN node..."); 478 oodate = gn->childMade; 479 } else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) { 480 /* 481 * A node which is the object of the force (!) operator or which 482 * has the .EXEC attribute is always considered out-of-date. 483 */ 484 if (DEBUG(MAKE)) { 485 if (gn->type & OP_FORCE) 486 printf("! operator..."); 487 else if (gn->type & OP_PHONY) 488 printf(".PHONY node..."); 489 else 490 printf(".EXEC node..."); 491 } 492 oodate = true; 493 } else if (is_strictly_before(gn->mtime, gn->youngest->mtime) || 494 (gn == gn->youngest && 495 (is_out_of_date(gn->mtime) || (gn->type & OP_DOUBLEDEP)))) { 496 /* 497 * A node whose modification time is less than that of its 498 * youngest child or that has no children (gn->youngest == gn) 499 * and either doesn't exist (mtime == OUT_OF_DATE) 500 * or was the object of a :: operator is out-of-date. 501 */ 502 if (DEBUG(MAKE)) { 503 if (is_strictly_before(gn->mtime, gn->youngest->mtime)) 504 printf("modified before source(%s)...", 505 gn->youngest->name); 506 else if (is_out_of_date(gn->mtime)) 507 printf("non-existent and no sources..."); 508 else 509 printf(":: operator and no sources..."); 510 } 511 oodate = true; 512 } else { 513 oodate = false; 514 } 515 516 /* 517 * If the target isn't out-of-date, the parents need to know its 518 * modification time. Note that targets that appear to be out-of-date 519 * but aren't, because they have no commands and aren't of type OP_NOP, 520 * have their mtime stay below their children's mtime to keep parents 521 * from thinking they're out-of-date. 522 */ 523 if (!oodate) 524 Lst_ForEach(&gn->parents, MakeTimeStamp, gn); 525 526 return oodate; 527 } 528 529 /* The following array is used to make a fast determination of which 530 * characters are interpreted specially by the shell. If a command 531 * contains any of these characters, it is executed by the shell, not 532 * directly by us. */ 533 static char meta[256]; 534 535 void 536 setup_meta(void) 537 { 538 char *p; 539 540 for (p = "#=|^(){};&<>*?[]:$`\\\n"; *p != '\0'; p++) 541 meta[(unsigned char) *p] = 1; 542 /* The null character serves as a sentinel in the string. */ 543 meta[0] = 1; 544 } 545 546 static char ** 547 recheck_command_for_shell(char **av) 548 { 549 char *runsh[] = { 550 "!", "alias", "cd", "eval", "exit", "read", "set", "ulimit", 551 "unalias", "unset", "wait", "umask", NULL 552 }; 553 554 char **p; 555 556 /* optimization: if exec cmd, we avoid the intermediate shell */ 557 if (strcmp(av[0], "exec") == 0) 558 av++; 559 560 for (p = runsh; *p; p++) 561 if (strcmp(av[0], *p) == 0) 562 return NULL; 563 564 return av; 565 } 566 567 static void 568 run_command(const char *cmd, bool errCheck) 569 { 570 const char *p; 571 char *shargv[4]; 572 char **todo; 573 574 shargv[0] = _PATH_BSHELL; 575 576 shargv[1] = errCheck ? "-ec" : "-c"; 577 shargv[2] = (char *)cmd; 578 shargv[3] = NULL; 579 580 todo = shargv; 581 582 583 /* Search for meta characters in the command. If there are no meta 584 * characters, there's no need to execute a shell to execute the 585 * command. */ 586 for (p = cmd; !meta[(unsigned char)*p]; p++) 587 continue; 588 if (*p == '\0') { 589 char *bp; 590 char **av; 591 int argc; 592 /* No meta-characters, so probably no need to exec a shell. 593 * Break the command into words to form an argument vector 594 * we can execute. */ 595 av = brk_string(cmd, &argc, &bp); 596 av = recheck_command_for_shell(av); 597 if (av != NULL) 598 todo = av; 599 } 600 execvp(todo[0], todo); 601 602 if (errno == ENOENT) 603 fprintf(stderr, "%s: not found\n", todo[0]); 604 else 605 perror(todo[0]); 606 _exit(1); 607 } 608 609 static Job myjob; 610 611 void 612 job_attach_node(Job *job, GNode *node) 613 { 614 job->node = node; 615 job->node->built_status = BUILDING; 616 job->next_cmd = Lst_First(&node->commands); 617 job->exit_type = JOB_EXIT_OKAY; 618 job->location = NULL; 619 job->flags = 0; 620 } 621 622 void 623 job_handle_status(Job *job, int status) 624 { 625 bool silent; 626 int dying; 627 628 /* if there's one job running and we don't keep going, no need 629 * to report right now. 630 */ 631 if ((job->flags & JOB_ERRCHECK) && !keepgoing && runningJobs == NULL) 632 silent = !DEBUG(JOB); 633 else 634 silent = false; 635 636 debug_job_printf("Process %ld (%s) exited with status %d.\n", 637 (long)job->pid, job->node->name, status); 638 639 /* classify status */ 640 if (WIFEXITED(status)) { 641 job->code = WEXITSTATUS(status);/* exited */ 642 if (job->code != 0) { 643 /* if we're already dying from that signal, be silent */ 644 if (!silent && job->code > 128 645 && job->code <= 128 + _NSIG) { 646 dying = check_dying_signal(); 647 silent = dying && job->code == dying + 128; 648 } 649 if (!silent) 650 printf("*** Error %d", job->code); 651 job->exit_type = JOB_EXIT_BAD; 652 } else 653 job->exit_type = JOB_EXIT_OKAY; 654 } else { 655 job->exit_type = JOB_SIGNALED; 656 job->code = WTERMSIG(status); /* signaled */ 657 /* if we're already dying from that signal, be silent */ 658 if (!silent) { 659 dying = check_dying_signal(); 660 silent = dying && job->code == dying; 661 } 662 if (!silent) 663 printf("*** Signal %d", job->code); 664 } 665 666 /* if there is a problem, what's going on ? */ 667 if (job->exit_type != JOB_EXIT_OKAY) { 668 if (!silent) 669 printf(" in target '%s'", job->node->name); 670 if (job->flags & JOB_ERRCHECK) { 671 job->node->built_status = ERROR; 672 /* compute expensive status if we really want it */ 673 if ((job->flags & JOB_SILENT) && job == &myjob) 674 determine_expensive_job(job); 675 if (!keepgoing) { 676 if (!silent) 677 printf("\n"); 678 job->next = errorJobs; 679 errorJobs = job; 680 /* XXX don't free the command */ 681 return; 682 } 683 printf(", line %lu of %s", job->location->lineno, 684 job->location->fname); 685 if ((job->flags & (JOB_SILENT | JOB_IS_EXPENSIVE)) 686 == JOB_SILENT) 687 printf(": %s", job->cmd); 688 /* Abort the current target, 689 * but let others continue. */ 690 printf(" (continuing)\n"); 691 } else { 692 /* Continue executing commands for 693 * this target. If we return 0, 694 * this will happen... */ 695 printf(" (ignored)\n"); 696 job->exit_type = JOB_EXIT_OKAY; 697 } 698 } 699 free(job->cmd); 700 } 701 702 int 703 run_gnode(GNode *gn) 704 { 705 if (!gn || (gn->type & OP_DUMMY)) 706 return NOSUCHNODE; 707 708 gn->built_status = MADE; 709 710 job_attach_node(&myjob, gn); 711 while (myjob.exit_type == JOB_EXIT_OKAY) { 712 bool finished = job_run_next(&myjob); 713 if (finished) 714 break; 715 handle_one_job(&myjob); 716 } 717 718 return gn->built_status; 719 } 720 721 722 static void 723 setup_engine(void) 724 { 725 static int already_setup = 0; 726 727 if (!already_setup) { 728 setup_meta(); 729 already_setup = 1; 730 } 731 } 732 733 static bool 734 do_run_command(Job *job) 735 { 736 bool silent; /* Don't print command */ 737 bool doExecute; /* Execute the command */ 738 bool errCheck; /* Check errors */ 739 pid_t cpid; /* Child pid */ 740 741 const char *cmd = job->cmd; 742 silent = job->node->type & OP_SILENT; 743 errCheck = !(job->node->type & OP_IGNORE); 744 if (job->node->type & OP_MAKE) 745 doExecute = true; 746 else 747 doExecute = !noExecute; 748 749 /* How can we execute a null command ? we warn the user that the 750 * command expanded to nothing (is this the right thing to do?). */ 751 if (*cmd == '\0') { 752 Error("%s expands to empty string", cmd); 753 return false; 754 } 755 756 for (;; cmd++) { 757 if (*cmd == '@') 758 silent = DEBUG(LOUD) ? false : true; 759 else if (*cmd == '-') 760 errCheck = false; 761 else if (*cmd == '+') 762 doExecute = true; 763 else 764 break; 765 } 766 while (ISSPACE(*cmd)) 767 cmd++; 768 /* Print the command before fork if make -n or !silent*/ 769 if ( noExecute || !silent) 770 printf("%s\n", cmd); 771 772 if (silent) 773 job->flags |= JOB_SILENT; 774 else 775 job->flags &= ~JOB_SILENT; 776 777 /* If we're not supposed to execute any commands, this is as far as 778 * we go... */ 779 if (!doExecute) 780 return false; 781 /* always flush for other stuff */ 782 fflush(stdout); 783 784 /* Fork and execute the single command. If the fork fails, we abort. */ 785 switch (cpid = fork()) { 786 case -1: 787 Punt("Could not fork"); 788 /*NOTREACHED*/ 789 case 0: 790 /* put a random delay unless we're the only job running 791 * and there's nothing left to do. 792 */ 793 if (random_delay) 794 if (!(runningJobs == NULL && no_jobs_left())) 795 usleep(arc4random_uniform(random_delay)); 796 run_command(cmd, errCheck); 797 /*NOTREACHED*/ 798 default: 799 job->pid = cpid; 800 job->next = runningJobs; 801 runningJobs = job; 802 if (errCheck) 803 job->flags |= JOB_ERRCHECK; 804 else 805 job->flags &= ~JOB_ERRCHECK; 806 debug_job_printf("Running %ld (%s) %s\n", (long)job->pid, 807 job->node->name, (noExecute || !silent) ? "" : cmd); 808 return true; 809 } 810 } 811 812 bool 813 job_run_next(Job *job) 814 { 815 bool started; 816 GNode *gn = job->node; 817 818 setup_engine(); 819 while (job->next_cmd != NULL) { 820 struct command *command = Lst_Datum(job->next_cmd); 821 822 handle_all_signals(); 823 job->location = &command->location; 824 Parse_SetLocation(job->location); 825 job->cmd = Var_Subst(command->string, &gn->context, false); 826 job->next_cmd = Lst_Adv(job->next_cmd); 827 if (fatal_errors) 828 Punt(NULL); 829 started = do_run_command(job); 830 if (started) 831 return false; 832 else 833 free(job->cmd); 834 } 835 job->exit_type = JOB_EXIT_OKAY; 836 return true; 837 } 838 839