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