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