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