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