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