1 /* $NetBSD: meta.c,v 1.70 2018/02/13 19:37:30 sjg Exp $ */ 2 3 /* 4 * Implement 'meta' mode. 5 * Adapted from John Birrell's patches to FreeBSD make. 6 * --sjg 7 */ 8 /* 9 * Copyright (c) 2009-2016, Juniper Networks, Inc. 10 * Portions Copyright (c) 2009, John Birrell. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 #if defined(USE_META) 34 35 #ifdef HAVE_CONFIG_H 36 # include "config.h" 37 #endif 38 #include <sys/stat.h> 39 #include <sys/ioctl.h> 40 #ifdef HAVE_LIBGEN_H 41 #include <libgen.h> 42 #elif !defined(HAVE_DIRNAME) 43 char * dirname(char *); 44 #endif 45 #include <errno.h> 46 #if !defined(HAVE_CONFIG_H) || defined(HAVE_ERR_H) 47 #include <err.h> 48 #endif 49 50 #include "make.h" 51 #include "job.h" 52 53 #ifdef HAVE_FILEMON_H 54 # include <filemon.h> 55 #endif 56 #if !defined(USE_FILEMON) && defined(FILEMON_SET_FD) 57 # define USE_FILEMON 58 #endif 59 60 static BuildMon Mybm; /* for compat */ 61 static Lst metaBailiwick; /* our scope of control */ 62 static char *metaBailiwickStr; /* string storage for the list */ 63 static Lst metaIgnorePaths; /* paths we deliberately ignore */ 64 static char *metaIgnorePathsStr; /* string storage for the list */ 65 66 #ifndef MAKE_META_IGNORE_PATHS 67 #define MAKE_META_IGNORE_PATHS ".MAKE.META.IGNORE_PATHS" 68 #endif 69 #ifndef MAKE_META_IGNORE_PATTERNS 70 #define MAKE_META_IGNORE_PATTERNS ".MAKE.META.IGNORE_PATTERNS" 71 #endif 72 #ifndef MAKE_META_IGNORE_FILTER 73 #define MAKE_META_IGNORE_FILTER ".MAKE.META.IGNORE_FILTER" 74 #endif 75 76 Boolean useMeta = FALSE; 77 static Boolean useFilemon = FALSE; 78 static Boolean writeMeta = FALSE; 79 static Boolean metaMissing = FALSE; /* oodate if missing */ 80 static Boolean filemonMissing = FALSE; /* oodate if missing */ 81 static Boolean metaEnv = FALSE; /* don't save env unless asked */ 82 static Boolean metaVerbose = FALSE; 83 static Boolean metaIgnoreCMDs = FALSE; /* ignore CMDs in .meta files */ 84 static Boolean metaIgnorePatterns = FALSE; /* do we need to do pattern matches */ 85 static Boolean metaIgnoreFilter = FALSE; /* do we have more complex filtering? */ 86 static Boolean metaCurdirOk = FALSE; /* write .meta in .CURDIR Ok? */ 87 static Boolean metaSilent = FALSE; /* if we have a .meta be SILENT */ 88 89 extern Boolean forceJobs; 90 extern Boolean comatMake; 91 extern char **environ; 92 93 #define MAKE_META_PREFIX ".MAKE.META.PREFIX" 94 95 #ifndef N2U 96 # define N2U(n, u) (((n) + ((u) - 1)) / (u)) 97 #endif 98 #ifndef ROUNDUP 99 # define ROUNDUP(n, u) (N2U((n), (u)) * (u)) 100 #endif 101 102 #if !defined(HAVE_STRSEP) 103 # define strsep(s, d) stresep((s), (d), 0) 104 #endif 105 106 /* 107 * Filemon is a kernel module which snoops certain syscalls. 108 * 109 * C chdir 110 * E exec 111 * F [v]fork 112 * L [sym]link 113 * M rename 114 * R read 115 * W write 116 * S stat 117 * 118 * See meta_oodate below - we mainly care about 'E' and 'R'. 119 * 120 * We can still use meta mode without filemon, but 121 * the benefits are more limited. 122 */ 123 #ifdef USE_FILEMON 124 # ifndef _PATH_FILEMON 125 # define _PATH_FILEMON "/dev/filemon" 126 # endif 127 128 /* 129 * Open the filemon device. 130 */ 131 static void 132 filemon_open(BuildMon *pbm) 133 { 134 int retry; 135 136 pbm->mon_fd = pbm->filemon_fd = -1; 137 if (!useFilemon) 138 return; 139 140 for (retry = 5; retry >= 0; retry--) { 141 if ((pbm->filemon_fd = open(_PATH_FILEMON, O_RDWR)) >= 0) 142 break; 143 } 144 145 if (pbm->filemon_fd < 0) { 146 useFilemon = FALSE; 147 warn("Could not open %s", _PATH_FILEMON); 148 return; 149 } 150 151 /* 152 * We use a file outside of '.' 153 * to avoid a FreeBSD kernel bug where unlink invalidates 154 * cwd causing getcwd to do a lot more work. 155 * We only care about the descriptor. 156 */ 157 pbm->mon_fd = mkTempFile("filemon.XXXXXX", NULL); 158 if (ioctl(pbm->filemon_fd, FILEMON_SET_FD, &pbm->mon_fd) < 0) { 159 err(1, "Could not set filemon file descriptor!"); 160 } 161 /* we don't need these once we exec */ 162 (void)fcntl(pbm->mon_fd, F_SETFD, FD_CLOEXEC); 163 (void)fcntl(pbm->filemon_fd, F_SETFD, FD_CLOEXEC); 164 } 165 166 /* 167 * Read the build monitor output file and write records to the target's 168 * metadata file. 169 */ 170 static int 171 filemon_read(FILE *mfp, int fd) 172 { 173 char buf[BUFSIZ]; 174 int n; 175 int error; 176 177 /* Check if we're not writing to a meta data file.*/ 178 if (mfp == NULL) { 179 if (fd >= 0) 180 close(fd); /* not interested */ 181 return 0; 182 } 183 /* rewind */ 184 (void)lseek(fd, (off_t)0, SEEK_SET); 185 186 error = 0; 187 fprintf(mfp, "\n-- filemon acquired metadata --\n"); 188 189 while ((n = read(fd, buf, sizeof(buf))) > 0) { 190 if ((int)fwrite(buf, 1, n, mfp) < n) 191 error = EIO; 192 } 193 fflush(mfp); 194 if (close(fd) < 0) 195 error = errno; 196 return error; 197 } 198 #endif 199 200 /* 201 * when realpath() fails, 202 * we use this, to clean up ./ and ../ 203 */ 204 static void 205 eat_dots(char *buf, size_t bufsz, int dots) 206 { 207 char *cp; 208 char *cp2; 209 const char *eat; 210 size_t eatlen; 211 212 switch (dots) { 213 case 1: 214 eat = "/./"; 215 eatlen = 2; 216 break; 217 case 2: 218 eat = "/../"; 219 eatlen = 3; 220 break; 221 default: 222 return; 223 } 224 225 do { 226 cp = strstr(buf, eat); 227 if (cp) { 228 cp2 = cp + eatlen; 229 if (dots == 2 && cp > buf) { 230 do { 231 cp--; 232 } while (cp > buf && *cp != '/'); 233 } 234 if (*cp == '/') { 235 strlcpy(cp, cp2, bufsz - (cp - buf)); 236 } else { 237 return; /* can't happen? */ 238 } 239 } 240 } while (cp); 241 } 242 243 static char * 244 meta_name(char *mname, size_t mnamelen, 245 const char *dname, 246 const char *tname, 247 const char *cwd) 248 { 249 char buf[MAXPATHLEN]; 250 char *rp; 251 char *cp; 252 char *tp; 253 char *dtp; 254 size_t ldname; 255 256 /* 257 * Weed out relative paths from the target file name. 258 * We have to be careful though since if target is a 259 * symlink, the result will be unstable. 260 * So we use realpath() just to get the dirname, and leave the 261 * basename as given to us. 262 */ 263 if ((cp = strrchr(tname, '/'))) { 264 if (cached_realpath(tname, buf)) { 265 if ((rp = strrchr(buf, '/'))) { 266 rp++; 267 cp++; 268 if (strcmp(cp, rp) != 0) 269 strlcpy(rp, cp, sizeof(buf) - (rp - buf)); 270 } 271 tname = buf; 272 } else { 273 /* 274 * We likely have a directory which is about to be made. 275 * We pretend realpath() succeeded, to have a chance 276 * of generating the same meta file name that we will 277 * next time through. 278 */ 279 if (tname[0] == '/') { 280 strlcpy(buf, tname, sizeof(buf)); 281 } else { 282 snprintf(buf, sizeof(buf), "%s/%s", cwd, tname); 283 } 284 eat_dots(buf, sizeof(buf), 1); /* ./ */ 285 eat_dots(buf, sizeof(buf), 2); /* ../ */ 286 tname = buf; 287 } 288 } 289 /* on some systems dirname may modify its arg */ 290 tp = bmake_strdup(tname); 291 dtp = dirname(tp); 292 if (strcmp(dname, dtp) == 0) 293 snprintf(mname, mnamelen, "%s.meta", tname); 294 else { 295 ldname = strlen(dname); 296 if (strncmp(dname, dtp, ldname) == 0 && dtp[ldname] == '/') 297 snprintf(mname, mnamelen, "%s/%s.meta", dname, &tname[ldname+1]); 298 else 299 snprintf(mname, mnamelen, "%s/%s.meta", dname, tname); 300 301 /* 302 * Replace path separators in the file name after the 303 * current object directory path. 304 */ 305 cp = mname + strlen(dname) + 1; 306 307 while (*cp != '\0') { 308 if (*cp == '/') 309 *cp = '_'; 310 cp++; 311 } 312 } 313 free(tp); 314 return (mname); 315 } 316 317 /* 318 * Return true if running ${.MAKE} 319 * Bypassed if target is flagged .MAKE 320 */ 321 static int 322 is_submake(void *cmdp, void *gnp) 323 { 324 static char *p_make = NULL; 325 static int p_len; 326 char *cmd = cmdp; 327 GNode *gn = gnp; 328 char *mp = NULL; 329 char *cp; 330 char *cp2; 331 int rc = 0; /* keep looking */ 332 333 if (!p_make) { 334 p_make = Var_Value(".MAKE", gn, &cp); 335 p_len = strlen(p_make); 336 } 337 cp = strchr(cmd, '$'); 338 if ((cp)) { 339 mp = Var_Subst(NULL, cmd, gn, VARF_WANTRES); 340 cmd = mp; 341 } 342 cp2 = strstr(cmd, p_make); 343 if ((cp2)) { 344 switch (cp2[p_len]) { 345 case '\0': 346 case ' ': 347 case '\t': 348 case '\n': 349 rc = 1; 350 break; 351 } 352 if (cp2 > cmd && rc > 0) { 353 switch (cp2[-1]) { 354 case ' ': 355 case '\t': 356 case '\n': 357 break; 358 default: 359 rc = 0; /* no match */ 360 break; 361 } 362 } 363 } 364 free(mp); 365 return (rc); 366 } 367 368 typedef struct meta_file_s { 369 FILE *fp; 370 GNode *gn; 371 } meta_file_t; 372 373 static int 374 printCMD(void *cmdp, void *mfpp) 375 { 376 meta_file_t *mfp = mfpp; 377 char *cmd = cmdp; 378 char *cp = NULL; 379 380 if (strchr(cmd, '$')) { 381 cmd = cp = Var_Subst(NULL, cmd, mfp->gn, VARF_WANTRES); 382 } 383 fprintf(mfp->fp, "CMD %s\n", cmd); 384 free(cp); 385 return 0; 386 } 387 388 /* 389 * Certain node types never get a .meta file 390 */ 391 #define SKIP_META_TYPE(_type) do { \ 392 if ((gn->type & __CONCAT(OP_, _type))) { \ 393 if (verbose) { \ 394 fprintf(debug_file, "Skipping meta for %s: .%s\n", \ 395 gn->name, __STRING(_type)); \ 396 } \ 397 return FALSE; \ 398 } \ 399 } while (0) 400 401 402 /* 403 * Do we need/want a .meta file ? 404 */ 405 static Boolean 406 meta_needed(GNode *gn, const char *dname, 407 char *objdir, int verbose) 408 { 409 struct stat fs; 410 411 if (verbose) 412 verbose = DEBUG(META); 413 414 /* This may be a phony node which we don't want meta data for... */ 415 /* Skip .meta for .BEGIN, .END, .ERROR etc as well. */ 416 /* Or it may be explicitly flagged as .NOMETA */ 417 SKIP_META_TYPE(NOMETA); 418 /* Unless it is explicitly flagged as .META */ 419 if (!(gn->type & OP_META)) { 420 SKIP_META_TYPE(PHONY); 421 SKIP_META_TYPE(SPECIAL); 422 SKIP_META_TYPE(MAKE); 423 } 424 425 /* Check if there are no commands to execute. */ 426 if (Lst_IsEmpty(gn->commands)) { 427 if (verbose) 428 fprintf(debug_file, "Skipping meta for %s: no commands\n", 429 gn->name); 430 return FALSE; 431 } 432 if ((gn->type & (OP_META|OP_SUBMAKE)) == OP_SUBMAKE) { 433 /* OP_SUBMAKE is a bit too aggressive */ 434 if (Lst_ForEach(gn->commands, is_submake, gn)) { 435 if (DEBUG(META)) 436 fprintf(debug_file, "Skipping meta for %s: .SUBMAKE\n", 437 gn->name); 438 return FALSE; 439 } 440 } 441 442 /* The object directory may not exist. Check it.. */ 443 if (cached_stat(dname, &fs) != 0) { 444 if (verbose) 445 fprintf(debug_file, "Skipping meta for %s: no .OBJDIR\n", 446 gn->name); 447 return FALSE; 448 } 449 450 /* make sure these are canonical */ 451 if (cached_realpath(dname, objdir)) 452 dname = objdir; 453 454 /* If we aren't in the object directory, don't create a meta file. */ 455 if (!metaCurdirOk && strcmp(curdir, dname) == 0) { 456 if (verbose) 457 fprintf(debug_file, "Skipping meta for %s: .OBJDIR == .CURDIR\n", 458 gn->name); 459 return FALSE; 460 } 461 return TRUE; 462 } 463 464 465 static FILE * 466 meta_create(BuildMon *pbm, GNode *gn) 467 { 468 meta_file_t mf; 469 char buf[MAXPATHLEN]; 470 char objdir[MAXPATHLEN]; 471 char **ptr; 472 const char *dname; 473 const char *tname; 474 char *fname; 475 const char *cp; 476 char *p[4]; /* >= possible uses */ 477 int i; 478 479 mf.fp = NULL; 480 i = 0; 481 482 dname = Var_Value(".OBJDIR", gn, &p[i++]); 483 tname = Var_Value(TARGET, gn, &p[i++]); 484 485 /* if this succeeds objdir is realpath of dname */ 486 if (!meta_needed(gn, dname, objdir, TRUE)) 487 goto out; 488 dname = objdir; 489 490 if (metaVerbose) { 491 char *mp; 492 493 /* Describe the target we are building */ 494 mp = Var_Subst(NULL, "${" MAKE_META_PREFIX "}", gn, VARF_WANTRES); 495 if (*mp) 496 fprintf(stdout, "%s\n", mp); 497 free(mp); 498 } 499 /* Get the basename of the target */ 500 if ((cp = strrchr(tname, '/')) == NULL) { 501 cp = tname; 502 } else { 503 cp++; 504 } 505 506 fflush(stdout); 507 508 if (!writeMeta) 509 /* Don't create meta data. */ 510 goto out; 511 512 fname = meta_name(pbm->meta_fname, sizeof(pbm->meta_fname), 513 dname, tname, objdir); 514 515 #ifdef DEBUG_META_MODE 516 if (DEBUG(META)) 517 fprintf(debug_file, "meta_create: %s\n", fname); 518 #endif 519 520 if ((mf.fp = fopen(fname, "w")) == NULL) 521 err(1, "Could not open meta file '%s'", fname); 522 523 fprintf(mf.fp, "# Meta data file %s\n", fname); 524 525 mf.gn = gn; 526 527 Lst_ForEach(gn->commands, printCMD, &mf); 528 529 fprintf(mf.fp, "CWD %s\n", getcwd(buf, sizeof(buf))); 530 fprintf(mf.fp, "TARGET %s\n", tname); 531 532 if (metaEnv) { 533 for (ptr = environ; *ptr != NULL; ptr++) 534 fprintf(mf.fp, "ENV %s\n", *ptr); 535 } 536 537 fprintf(mf.fp, "-- command output --\n"); 538 fflush(mf.fp); 539 540 Var_Append(".MAKE.META.FILES", fname, VAR_GLOBAL); 541 Var_Append(".MAKE.META.CREATED", fname, VAR_GLOBAL); 542 543 gn->type |= OP_META; /* in case anyone wants to know */ 544 if (metaSilent) { 545 gn->type |= OP_SILENT; 546 } 547 out: 548 for (i--; i >= 0; i--) { 549 free(p[i]); 550 } 551 552 return (mf.fp); 553 } 554 555 static Boolean 556 boolValue(char *s) 557 { 558 switch(*s) { 559 case '0': 560 case 'N': 561 case 'n': 562 case 'F': 563 case 'f': 564 return FALSE; 565 } 566 return TRUE; 567 } 568 569 /* 570 * Initialization we need before reading makefiles. 571 */ 572 void 573 meta_init(void) 574 { 575 #ifdef USE_FILEMON 576 /* this allows makefiles to test if we have filemon support */ 577 Var_Set(".MAKE.PATH_FILEMON", _PATH_FILEMON, VAR_GLOBAL, 0); 578 #endif 579 } 580 581 582 #define get_mode_bf(bf, token) \ 583 if ((cp = strstr(make_mode, token))) \ 584 bf = boolValue(&cp[sizeof(token) - 1]) 585 586 /* 587 * Initialization we need after reading makefiles. 588 */ 589 void 590 meta_mode_init(const char *make_mode) 591 { 592 static int once = 0; 593 char *cp; 594 595 useMeta = TRUE; 596 useFilemon = TRUE; 597 writeMeta = TRUE; 598 599 if (make_mode) { 600 if (strstr(make_mode, "env")) 601 metaEnv = TRUE; 602 if (strstr(make_mode, "verb")) 603 metaVerbose = TRUE; 604 if (strstr(make_mode, "read")) 605 writeMeta = FALSE; 606 if (strstr(make_mode, "nofilemon")) 607 useFilemon = FALSE; 608 if (strstr(make_mode, "ignore-cmd")) 609 metaIgnoreCMDs = TRUE; 610 if (useFilemon) 611 get_mode_bf(filemonMissing, "missing-filemon="); 612 get_mode_bf(metaCurdirOk, "curdirok="); 613 get_mode_bf(metaMissing, "missing-meta="); 614 get_mode_bf(metaSilent, "silent="); 615 } 616 if (metaVerbose && !Var_Exists(MAKE_META_PREFIX, VAR_GLOBAL)) { 617 /* 618 * The default value for MAKE_META_PREFIX 619 * prints the absolute path of the target. 620 * This works be cause :H will generate '.' if there is no / 621 * and :tA will resolve that to cwd. 622 */ 623 Var_Set(MAKE_META_PREFIX, "Building ${.TARGET:H:tA}/${.TARGET:T}", VAR_GLOBAL, 0); 624 } 625 if (once) 626 return; 627 once = 1; 628 memset(&Mybm, 0, sizeof(Mybm)); 629 /* 630 * We consider ourselves master of all within ${.MAKE.META.BAILIWICK} 631 */ 632 metaBailiwick = Lst_Init(FALSE); 633 metaBailiwickStr = Var_Subst(NULL, "${.MAKE.META.BAILIWICK:O:u:tA}", 634 VAR_GLOBAL, VARF_WANTRES); 635 if (metaBailiwickStr) { 636 str2Lst_Append(metaBailiwick, metaBailiwickStr, NULL); 637 } 638 /* 639 * We ignore any paths that start with ${.MAKE.META.IGNORE_PATHS} 640 */ 641 metaIgnorePaths = Lst_Init(FALSE); 642 Var_Append(MAKE_META_IGNORE_PATHS, 643 "/dev /etc /proc /tmp /var/run /var/tmp ${TMPDIR}", VAR_GLOBAL); 644 metaIgnorePathsStr = Var_Subst(NULL, 645 "${" MAKE_META_IGNORE_PATHS ":O:u:tA}", VAR_GLOBAL, 646 VARF_WANTRES); 647 if (metaIgnorePathsStr) { 648 str2Lst_Append(metaIgnorePaths, metaIgnorePathsStr, NULL); 649 } 650 651 /* 652 * We ignore any paths that match ${.MAKE.META.IGNORE_PATTERNS} 653 */ 654 cp = NULL; 655 if (Var_Value(MAKE_META_IGNORE_PATTERNS, VAR_GLOBAL, &cp)) { 656 metaIgnorePatterns = TRUE; 657 free(cp); 658 } 659 cp = NULL; 660 if (Var_Value(MAKE_META_IGNORE_FILTER, VAR_GLOBAL, &cp)) { 661 metaIgnoreFilter = TRUE; 662 free(cp); 663 } 664 } 665 666 /* 667 * In each case below we allow for job==NULL 668 */ 669 void 670 meta_job_start(Job *job, GNode *gn) 671 { 672 BuildMon *pbm; 673 674 if (job != NULL) { 675 pbm = &job->bm; 676 } else { 677 pbm = &Mybm; 678 } 679 pbm->mfp = meta_create(pbm, gn); 680 #ifdef USE_FILEMON_ONCE 681 /* compat mode we open the filemon dev once per command */ 682 if (job == NULL) 683 return; 684 #endif 685 #ifdef USE_FILEMON 686 if (pbm->mfp != NULL && useFilemon) { 687 filemon_open(pbm); 688 } else { 689 pbm->mon_fd = pbm->filemon_fd = -1; 690 } 691 #endif 692 } 693 694 /* 695 * The child calls this before doing anything. 696 * It does not disturb our state. 697 */ 698 void 699 meta_job_child(Job *job) 700 { 701 #ifdef USE_FILEMON 702 BuildMon *pbm; 703 704 if (job != NULL) { 705 pbm = &job->bm; 706 } else { 707 pbm = &Mybm; 708 } 709 if (pbm->mfp != NULL) { 710 close(fileno(pbm->mfp)); 711 if (useFilemon) { 712 pid_t pid; 713 714 pid = getpid(); 715 if (ioctl(pbm->filemon_fd, FILEMON_SET_PID, &pid) < 0) { 716 err(1, "Could not set filemon pid!"); 717 } 718 } 719 } 720 #endif 721 } 722 723 void 724 meta_job_error(Job *job, GNode *gn, int flags, int status) 725 { 726 char cwd[MAXPATHLEN]; 727 BuildMon *pbm; 728 729 if (job != NULL) { 730 pbm = &job->bm; 731 if (!gn) 732 gn = job->node; 733 } else { 734 pbm = &Mybm; 735 } 736 if (pbm->mfp != NULL) { 737 fprintf(pbm->mfp, "\n*** Error code %d%s\n", 738 status, 739 (flags & JOB_IGNERR) ? 740 "(ignored)" : ""); 741 } 742 if (gn) { 743 Var_Set(".ERROR_TARGET", gn->path ? gn->path : gn->name, VAR_GLOBAL, 0); 744 } 745 getcwd(cwd, sizeof(cwd)); 746 Var_Set(".ERROR_CWD", cwd, VAR_GLOBAL, 0); 747 if (pbm->meta_fname[0]) { 748 Var_Set(".ERROR_META_FILE", pbm->meta_fname, VAR_GLOBAL, 0); 749 } 750 meta_job_finish(job); 751 } 752 753 void 754 meta_job_output(Job *job, char *cp, const char *nl) 755 { 756 BuildMon *pbm; 757 758 if (job != NULL) { 759 pbm = &job->bm; 760 } else { 761 pbm = &Mybm; 762 } 763 if (pbm->mfp != NULL) { 764 if (metaVerbose) { 765 static char *meta_prefix = NULL; 766 static int meta_prefix_len; 767 768 if (!meta_prefix) { 769 char *cp2; 770 771 meta_prefix = Var_Subst(NULL, "${" MAKE_META_PREFIX "}", 772 VAR_GLOBAL, VARF_WANTRES); 773 if ((cp2 = strchr(meta_prefix, '$'))) 774 meta_prefix_len = cp2 - meta_prefix; 775 else 776 meta_prefix_len = strlen(meta_prefix); 777 } 778 if (strncmp(cp, meta_prefix, meta_prefix_len) == 0) { 779 cp = strchr(cp+1, '\n'); 780 if (!cp++) 781 return; 782 } 783 } 784 fprintf(pbm->mfp, "%s%s", cp, nl); 785 } 786 } 787 788 int 789 meta_cmd_finish(void *pbmp) 790 { 791 int error = 0; 792 BuildMon *pbm = pbmp; 793 #ifdef USE_FILEMON 794 int x; 795 #endif 796 797 if (!pbm) 798 pbm = &Mybm; 799 800 #ifdef USE_FILEMON 801 if (pbm->filemon_fd >= 0) { 802 if (close(pbm->filemon_fd) < 0) 803 error = errno; 804 x = filemon_read(pbm->mfp, pbm->mon_fd); 805 if (error == 0 && x != 0) 806 error = x; 807 pbm->filemon_fd = pbm->mon_fd = -1; 808 } else 809 #endif 810 fprintf(pbm->mfp, "\n"); /* ensure end with newline */ 811 return error; 812 } 813 814 int 815 meta_job_finish(Job *job) 816 { 817 BuildMon *pbm; 818 int error = 0; 819 int x; 820 821 if (job != NULL) { 822 pbm = &job->bm; 823 } else { 824 pbm = &Mybm; 825 } 826 if (pbm->mfp != NULL) { 827 error = meta_cmd_finish(pbm); 828 x = fclose(pbm->mfp); 829 if (error == 0 && x != 0) 830 error = errno; 831 pbm->mfp = NULL; 832 pbm->meta_fname[0] = '\0'; 833 } 834 return error; 835 } 836 837 void 838 meta_finish(void) 839 { 840 Lst_Destroy(metaBailiwick, NULL); 841 free(metaBailiwickStr); 842 Lst_Destroy(metaIgnorePaths, NULL); 843 free(metaIgnorePathsStr); 844 } 845 846 /* 847 * Fetch a full line from fp - growing bufp if needed 848 * Return length in bufp. 849 */ 850 static int 851 fgetLine(char **bufp, size_t *szp, int o, FILE *fp) 852 { 853 char *buf = *bufp; 854 size_t bufsz = *szp; 855 struct stat fs; 856 int x; 857 858 if (fgets(&buf[o], bufsz - o, fp) != NULL) { 859 check_newline: 860 x = o + strlen(&buf[o]); 861 if (buf[x - 1] == '\n') 862 return x; 863 /* 864 * We need to grow the buffer. 865 * The meta file can give us a clue. 866 */ 867 if (fstat(fileno(fp), &fs) == 0) { 868 size_t newsz; 869 char *p; 870 871 newsz = ROUNDUP((fs.st_size / 2), BUFSIZ); 872 if (newsz <= bufsz) 873 newsz = ROUNDUP(fs.st_size, BUFSIZ); 874 if (newsz <= bufsz) 875 return x; /* truncated */ 876 if (DEBUG(META)) 877 fprintf(debug_file, "growing buffer %u -> %u\n", 878 (unsigned)bufsz, (unsigned)newsz); 879 p = bmake_realloc(buf, newsz); 880 if (p) { 881 *bufp = buf = p; 882 *szp = bufsz = newsz; 883 /* fetch the rest */ 884 if (!fgets(&buf[x], bufsz - x, fp)) 885 return x; /* truncated! */ 886 goto check_newline; 887 } 888 } 889 } 890 return 0; 891 } 892 893 /* Lst_ForEach wants 1 to stop search */ 894 static int 895 prefix_match(void *p, void *q) 896 { 897 const char *prefix = p; 898 const char *path = q; 899 size_t n = strlen(prefix); 900 901 return (0 == strncmp(path, prefix, n)); 902 } 903 904 /* 905 * looking for exact or prefix/ match to 906 * Lst_Find wants 0 to stop search 907 */ 908 static int 909 path_match(const void *p, const void *q) 910 { 911 const char *prefix = q; 912 const char *path = p; 913 size_t n = strlen(prefix); 914 int rc; 915 916 if ((rc = strncmp(path, prefix, n)) == 0) { 917 switch (path[n]) { 918 case '\0': 919 case '/': 920 break; 921 default: 922 rc = 1; 923 break; 924 } 925 } 926 return rc; 927 } 928 929 /* Lst_Find wants 0 to stop search */ 930 static int 931 string_match(const void *p, const void *q) 932 { 933 const char *p1 = p; 934 const char *p2 = q; 935 936 return strcmp(p1, p2); 937 } 938 939 940 static int 941 meta_ignore(GNode *gn, const char *p) 942 { 943 char fname[MAXPATHLEN]; 944 945 if (p == NULL) 946 return TRUE; 947 948 if (*p == '/') { 949 cached_realpath(p, fname); /* clean it up */ 950 if (Lst_ForEach(metaIgnorePaths, prefix_match, fname)) { 951 #ifdef DEBUG_META_MODE 952 if (DEBUG(META)) 953 fprintf(debug_file, "meta_oodate: ignoring path: %s\n", 954 p); 955 #endif 956 return TRUE; 957 } 958 } 959 960 if (metaIgnorePatterns) { 961 char *pm; 962 963 Var_Set(".p.", p, gn, 0); 964 pm = Var_Subst(NULL, 965 "${" MAKE_META_IGNORE_PATTERNS ":@m@${.p.:M$m}@}", 966 gn, VARF_WANTRES); 967 if (*pm) { 968 #ifdef DEBUG_META_MODE 969 if (DEBUG(META)) 970 fprintf(debug_file, "meta_oodate: ignoring pattern: %s\n", 971 p); 972 #endif 973 free(pm); 974 return TRUE; 975 } 976 free(pm); 977 } 978 979 if (metaIgnoreFilter) { 980 char *fm; 981 982 /* skip if filter result is empty */ 983 snprintf(fname, sizeof(fname), 984 "${%s:L:${%s:ts:}}", 985 p, MAKE_META_IGNORE_FILTER); 986 fm = Var_Subst(NULL, fname, gn, VARF_WANTRES); 987 if (*fm == '\0') { 988 #ifdef DEBUG_META_MODE 989 if (DEBUG(META)) 990 fprintf(debug_file, "meta_oodate: ignoring filtered: %s\n", 991 p); 992 #endif 993 free(fm); 994 return TRUE; 995 } 996 free(fm); 997 } 998 return FALSE; 999 } 1000 1001 /* 1002 * When running with 'meta' functionality, a target can be out-of-date 1003 * if any of the references in its meta data file is more recent. 1004 * We have to track the latestdir on a per-process basis. 1005 */ 1006 #define LCWD_VNAME_FMT ".meta.%d.lcwd" 1007 #define LDIR_VNAME_FMT ".meta.%d.ldir" 1008 1009 /* 1010 * It is possible that a .meta file is corrupted, 1011 * if we detect this we want to reproduce it. 1012 * Setting oodate TRUE will have that effect. 1013 */ 1014 #define CHECK_VALID_META(p) if (!(p && *p)) { \ 1015 warnx("%s: %d: malformed", fname, lineno); \ 1016 oodate = TRUE; \ 1017 continue; \ 1018 } 1019 1020 #define DEQUOTE(p) if (*p == '\'') { \ 1021 char *ep; \ 1022 p++; \ 1023 if ((ep = strchr(p, '\''))) \ 1024 *ep = '\0'; \ 1025 } 1026 1027 Boolean 1028 meta_oodate(GNode *gn, Boolean oodate) 1029 { 1030 static char *tmpdir = NULL; 1031 static char cwd[MAXPATHLEN]; 1032 char lcwd_vname[64]; 1033 char ldir_vname[64]; 1034 char lcwd[MAXPATHLEN]; 1035 char latestdir[MAXPATHLEN]; 1036 char fname[MAXPATHLEN]; 1037 char fname1[MAXPATHLEN]; 1038 char fname2[MAXPATHLEN]; 1039 char fname3[MAXPATHLEN]; 1040 const char *dname; 1041 const char *tname; 1042 char *p; 1043 char *cp; 1044 char *link_src; 1045 char *move_target; 1046 static size_t cwdlen = 0; 1047 static size_t tmplen = 0; 1048 FILE *fp; 1049 Boolean needOODATE = FALSE; 1050 Lst missingFiles; 1051 char *pa[4]; /* >= possible uses */ 1052 int i; 1053 int have_filemon = FALSE; 1054 1055 if (oodate) 1056 return oodate; /* we're done */ 1057 1058 i = 0; 1059 1060 dname = Var_Value(".OBJDIR", gn, &pa[i++]); 1061 tname = Var_Value(TARGET, gn, &pa[i++]); 1062 1063 /* if this succeeds fname3 is realpath of dname */ 1064 if (!meta_needed(gn, dname, fname3, FALSE)) 1065 goto oodate_out; 1066 dname = fname3; 1067 1068 missingFiles = Lst_Init(FALSE); 1069 1070 /* 1071 * We need to check if the target is out-of-date. This includes 1072 * checking if the expanded command has changed. This in turn 1073 * requires that all variables are set in the same way that they 1074 * would be if the target needs to be re-built. 1075 */ 1076 Make_DoAllVar(gn); 1077 1078 meta_name(fname, sizeof(fname), dname, tname, dname); 1079 1080 #ifdef DEBUG_META_MODE 1081 if (DEBUG(META)) 1082 fprintf(debug_file, "meta_oodate: %s\n", fname); 1083 #endif 1084 1085 if ((fp = fopen(fname, "r")) != NULL) { 1086 static char *buf = NULL; 1087 static size_t bufsz; 1088 int lineno = 0; 1089 int lastpid = 0; 1090 int pid; 1091 int x; 1092 LstNode ln; 1093 struct stat fs; 1094 1095 if (!buf) { 1096 bufsz = 8 * BUFSIZ; 1097 buf = bmake_malloc(bufsz); 1098 } 1099 1100 if (!cwdlen) { 1101 if (getcwd(cwd, sizeof(cwd)) == NULL) 1102 err(1, "Could not get current working directory"); 1103 cwdlen = strlen(cwd); 1104 } 1105 strlcpy(lcwd, cwd, sizeof(lcwd)); 1106 strlcpy(latestdir, cwd, sizeof(latestdir)); 1107 1108 if (!tmpdir) { 1109 tmpdir = getTmpdir(); 1110 tmplen = strlen(tmpdir); 1111 } 1112 1113 /* we want to track all the .meta we read */ 1114 Var_Append(".MAKE.META.FILES", fname, VAR_GLOBAL); 1115 1116 ln = Lst_First(gn->commands); 1117 while (!oodate && (x = fgetLine(&buf, &bufsz, 0, fp)) > 0) { 1118 lineno++; 1119 if (buf[x - 1] == '\n') 1120 buf[x - 1] = '\0'; 1121 else { 1122 warnx("%s: %d: line truncated at %u", fname, lineno, x); 1123 oodate = TRUE; 1124 break; 1125 } 1126 link_src = NULL; 1127 move_target = NULL; 1128 /* Find the start of the build monitor section. */ 1129 if (!have_filemon) { 1130 if (strncmp(buf, "-- filemon", 10) == 0) { 1131 have_filemon = TRUE; 1132 continue; 1133 } 1134 if (strncmp(buf, "# buildmon", 10) == 0) { 1135 have_filemon = TRUE; 1136 continue; 1137 } 1138 } 1139 1140 /* Delimit the record type. */ 1141 p = buf; 1142 #ifdef DEBUG_META_MODE 1143 if (DEBUG(META)) 1144 fprintf(debug_file, "%s: %d: %s\n", fname, lineno, buf); 1145 #endif 1146 strsep(&p, " "); 1147 if (have_filemon) { 1148 /* 1149 * We are in the 'filemon' output section. 1150 * Each record from filemon follows the general form: 1151 * 1152 * <key> <pid> <data> 1153 * 1154 * Where: 1155 * <key> is a single letter, denoting the syscall. 1156 * <pid> is the process that made the syscall. 1157 * <data> is the arguments (of interest). 1158 */ 1159 switch(buf[0]) { 1160 case '#': /* comment */ 1161 case 'V': /* version */ 1162 break; 1163 default: 1164 /* 1165 * We need to track pathnames per-process. 1166 * 1167 * Each process run by make, starts off in the 'CWD' 1168 * recorded in the .meta file, if it chdirs ('C') 1169 * elsewhere we need to track that - but only for 1170 * that process. If it forks ('F'), we initialize 1171 * the child to have the same cwd as its parent. 1172 * 1173 * We also need to track the 'latestdir' of 1174 * interest. This is usually the same as cwd, but 1175 * not if a process is reading directories. 1176 * 1177 * Each time we spot a different process ('pid') 1178 * we save the current value of 'latestdir' in a 1179 * variable qualified by 'lastpid', and 1180 * re-initialize 'latestdir' to any pre-saved 1181 * value for the current 'pid' and 'CWD' if none. 1182 */ 1183 CHECK_VALID_META(p); 1184 pid = atoi(p); 1185 if (pid > 0 && pid != lastpid) { 1186 char *ldir; 1187 char *tp; 1188 1189 if (lastpid > 0) { 1190 /* We need to remember these. */ 1191 Var_Set(lcwd_vname, lcwd, VAR_GLOBAL, 0); 1192 Var_Set(ldir_vname, latestdir, VAR_GLOBAL, 0); 1193 } 1194 snprintf(lcwd_vname, sizeof(lcwd_vname), LCWD_VNAME_FMT, pid); 1195 snprintf(ldir_vname, sizeof(ldir_vname), LDIR_VNAME_FMT, pid); 1196 lastpid = pid; 1197 ldir = Var_Value(ldir_vname, VAR_GLOBAL, &tp); 1198 if (ldir) { 1199 strlcpy(latestdir, ldir, sizeof(latestdir)); 1200 free(tp); 1201 } 1202 ldir = Var_Value(lcwd_vname, VAR_GLOBAL, &tp); 1203 if (ldir) { 1204 strlcpy(lcwd, ldir, sizeof(lcwd)); 1205 free(tp); 1206 } 1207 } 1208 /* Skip past the pid. */ 1209 if (strsep(&p, " ") == NULL) 1210 continue; 1211 #ifdef DEBUG_META_MODE 1212 if (DEBUG(META)) 1213 fprintf(debug_file, "%s: %d: %d: %c: cwd=%s lcwd=%s ldir=%s\n", 1214 fname, lineno, 1215 pid, buf[0], cwd, lcwd, latestdir); 1216 #endif 1217 break; 1218 } 1219 1220 CHECK_VALID_META(p); 1221 1222 /* Process according to record type. */ 1223 switch (buf[0]) { 1224 case 'X': /* eXit */ 1225 Var_Delete(lcwd_vname, VAR_GLOBAL); 1226 Var_Delete(ldir_vname, VAR_GLOBAL); 1227 lastpid = 0; /* no need to save ldir_vname */ 1228 break; 1229 1230 case 'F': /* [v]Fork */ 1231 { 1232 char cldir[64]; 1233 int child; 1234 1235 child = atoi(p); 1236 if (child > 0) { 1237 snprintf(cldir, sizeof(cldir), LCWD_VNAME_FMT, child); 1238 Var_Set(cldir, lcwd, VAR_GLOBAL, 0); 1239 snprintf(cldir, sizeof(cldir), LDIR_VNAME_FMT, child); 1240 Var_Set(cldir, latestdir, VAR_GLOBAL, 0); 1241 #ifdef DEBUG_META_MODE 1242 if (DEBUG(META)) 1243 fprintf(debug_file, "%s: %d: %d: cwd=%s lcwd=%s ldir=%s\n", 1244 fname, lineno, 1245 child, cwd, lcwd, latestdir); 1246 #endif 1247 } 1248 } 1249 break; 1250 1251 case 'C': /* Chdir */ 1252 /* Update lcwd and latest directory. */ 1253 strlcpy(latestdir, p, sizeof(latestdir)); 1254 strlcpy(lcwd, p, sizeof(lcwd)); 1255 Var_Set(lcwd_vname, lcwd, VAR_GLOBAL, 0); 1256 Var_Set(ldir_vname, lcwd, VAR_GLOBAL, 0); 1257 #ifdef DEBUG_META_MODE 1258 if (DEBUG(META)) 1259 fprintf(debug_file, "%s: %d: cwd=%s ldir=%s\n", fname, lineno, cwd, lcwd); 1260 #endif 1261 break; 1262 1263 case 'M': /* renaMe */ 1264 /* 1265 * For 'M'oves we want to check 1266 * the src as for 'R'ead 1267 * and the target as for 'W'rite. 1268 */ 1269 cp = p; /* save this for a second */ 1270 /* now get target */ 1271 if (strsep(&p, " ") == NULL) 1272 continue; 1273 CHECK_VALID_META(p); 1274 move_target = p; 1275 p = cp; 1276 /* 'L' and 'M' put single quotes around the args */ 1277 DEQUOTE(p); 1278 DEQUOTE(move_target); 1279 /* FALLTHROUGH */ 1280 case 'D': /* unlink */ 1281 if (*p == '/' && !Lst_IsEmpty(missingFiles)) { 1282 /* remove any missingFiles entries that match p */ 1283 if ((ln = Lst_Find(missingFiles, p, 1284 path_match)) != NULL) { 1285 LstNode nln; 1286 char *tp; 1287 1288 do { 1289 nln = Lst_FindFrom(missingFiles, Lst_Succ(ln), 1290 p, path_match); 1291 tp = Lst_Datum(ln); 1292 Lst_Remove(missingFiles, ln); 1293 free(tp); 1294 } while ((ln = nln) != NULL); 1295 } 1296 } 1297 if (buf[0] == 'M') { 1298 /* the target of the mv is a file 'W'ritten */ 1299 #ifdef DEBUG_META_MODE 1300 if (DEBUG(META)) 1301 fprintf(debug_file, "meta_oodate: M %s -> %s\n", 1302 p, move_target); 1303 #endif 1304 p = move_target; 1305 goto check_write; 1306 } 1307 break; 1308 case 'L': /* Link */ 1309 /* 1310 * For 'L'inks check 1311 * the src as for 'R'ead 1312 * and the target as for 'W'rite. 1313 */ 1314 link_src = p; 1315 /* now get target */ 1316 if (strsep(&p, " ") == NULL) 1317 continue; 1318 CHECK_VALID_META(p); 1319 /* 'L' and 'M' put single quotes around the args */ 1320 DEQUOTE(p); 1321 DEQUOTE(link_src); 1322 #ifdef DEBUG_META_MODE 1323 if (DEBUG(META)) 1324 fprintf(debug_file, "meta_oodate: L %s -> %s\n", 1325 link_src, p); 1326 #endif 1327 /* FALLTHROUGH */ 1328 case 'W': /* Write */ 1329 check_write: 1330 /* 1331 * If a file we generated within our bailiwick 1332 * but outside of .OBJDIR is missing, 1333 * we need to do it again. 1334 */ 1335 /* ignore non-absolute paths */ 1336 if (*p != '/') 1337 break; 1338 1339 if (Lst_IsEmpty(metaBailiwick)) 1340 break; 1341 1342 /* ignore cwd - normal dependencies handle those */ 1343 if (strncmp(p, cwd, cwdlen) == 0) 1344 break; 1345 1346 if (!Lst_ForEach(metaBailiwick, prefix_match, p)) 1347 break; 1348 1349 /* tmpdir might be within */ 1350 if (tmplen > 0 && strncmp(p, tmpdir, tmplen) == 0) 1351 break; 1352 1353 /* ignore anything containing the string "tmp" */ 1354 if ((strstr("tmp", p))) 1355 break; 1356 1357 if ((link_src != NULL && cached_lstat(p, &fs) < 0) || 1358 (link_src == NULL && cached_stat(p, &fs) < 0)) { 1359 if (!meta_ignore(gn, p)) { 1360 if (Lst_Find(missingFiles, p, string_match) == NULL) 1361 Lst_AtEnd(missingFiles, bmake_strdup(p)); 1362 } 1363 } 1364 break; 1365 check_link_src: 1366 p = link_src; 1367 link_src = NULL; 1368 #ifdef DEBUG_META_MODE 1369 if (DEBUG(META)) 1370 fprintf(debug_file, "meta_oodate: L src %s\n", p); 1371 #endif 1372 /* FALLTHROUGH */ 1373 case 'R': /* Read */ 1374 case 'E': /* Exec */ 1375 /* 1376 * Check for runtime files that can't 1377 * be part of the dependencies because 1378 * they are _expected_ to change. 1379 */ 1380 if (meta_ignore(gn, p)) 1381 break; 1382 1383 /* 1384 * The rest of the record is the file name. 1385 * Check if it's not an absolute path. 1386 */ 1387 { 1388 char *sdirs[4]; 1389 char **sdp; 1390 int sdx = 0; 1391 int found = 0; 1392 1393 if (*p == '/') { 1394 sdirs[sdx++] = p; /* done */ 1395 } else { 1396 if (strcmp(".", p) == 0) 1397 continue; /* no point */ 1398 1399 /* Check vs latestdir */ 1400 snprintf(fname1, sizeof(fname1), "%s/%s", latestdir, p); 1401 sdirs[sdx++] = fname1; 1402 1403 if (strcmp(latestdir, lcwd) != 0) { 1404 /* Check vs lcwd */ 1405 snprintf(fname2, sizeof(fname2), "%s/%s", lcwd, p); 1406 sdirs[sdx++] = fname2; 1407 } 1408 if (strcmp(lcwd, cwd) != 0) { 1409 /* Check vs cwd */ 1410 snprintf(fname3, sizeof(fname3), "%s/%s", cwd, p); 1411 sdirs[sdx++] = fname3; 1412 } 1413 } 1414 sdirs[sdx++] = NULL; 1415 1416 for (sdp = sdirs; *sdp && !found; sdp++) { 1417 #ifdef DEBUG_META_MODE 1418 if (DEBUG(META)) 1419 fprintf(debug_file, "%s: %d: looking for: %s\n", fname, lineno, *sdp); 1420 #endif 1421 if (cached_stat(*sdp, &fs) == 0) { 1422 found = 1; 1423 p = *sdp; 1424 } 1425 } 1426 if (found) { 1427 #ifdef DEBUG_META_MODE 1428 if (DEBUG(META)) 1429 fprintf(debug_file, "%s: %d: found: %s\n", fname, lineno, p); 1430 #endif 1431 if (!S_ISDIR(fs.st_mode) && 1432 fs.st_mtime > gn->mtime) { 1433 if (DEBUG(META)) 1434 fprintf(debug_file, "%s: %d: file '%s' is newer than the target...\n", fname, lineno, p); 1435 oodate = TRUE; 1436 } else if (S_ISDIR(fs.st_mode)) { 1437 /* Update the latest directory. */ 1438 cached_realpath(p, latestdir); 1439 } 1440 } else if (errno == ENOENT && *p == '/' && 1441 strncmp(p, cwd, cwdlen) != 0) { 1442 /* 1443 * A referenced file outside of CWD is missing. 1444 * We cannot catch every eventuality here... 1445 */ 1446 if (Lst_Find(missingFiles, p, string_match) == NULL) 1447 Lst_AtEnd(missingFiles, bmake_strdup(p)); 1448 } 1449 } 1450 if (buf[0] == 'E') { 1451 /* previous latestdir is no longer relevant */ 1452 strlcpy(latestdir, lcwd, sizeof(latestdir)); 1453 } 1454 break; 1455 default: 1456 break; 1457 } 1458 if (!oodate && buf[0] == 'L' && link_src != NULL) 1459 goto check_link_src; 1460 } else if (strcmp(buf, "CMD") == 0) { 1461 /* 1462 * Compare the current command with the one in the 1463 * meta data file. 1464 */ 1465 if (ln == NULL) { 1466 if (DEBUG(META)) 1467 fprintf(debug_file, "%s: %d: there were more build commands in the meta data file than there are now...\n", fname, lineno); 1468 oodate = TRUE; 1469 } else { 1470 char *cmd = (char *)Lst_Datum(ln); 1471 Boolean hasOODATE = FALSE; 1472 1473 if (strstr(cmd, "$?")) 1474 hasOODATE = TRUE; 1475 else if ((cp = strstr(cmd, ".OODATE"))) { 1476 /* check for $[{(].OODATE[:)}] */ 1477 if (cp > cmd + 2 && cp[-2] == '$') 1478 hasOODATE = TRUE; 1479 } 1480 if (hasOODATE) { 1481 needOODATE = TRUE; 1482 if (DEBUG(META)) 1483 fprintf(debug_file, "%s: %d: cannot compare command using .OODATE\n", fname, lineno); 1484 } 1485 cmd = Var_Subst(NULL, cmd, gn, VARF_WANTRES|VARF_UNDEFERR); 1486 1487 if ((cp = strchr(cmd, '\n'))) { 1488 int n; 1489 1490 /* 1491 * This command contains newlines, we need to 1492 * fetch more from the .meta file before we 1493 * attempt a comparison. 1494 */ 1495 /* first put the newline back at buf[x - 1] */ 1496 buf[x - 1] = '\n'; 1497 do { 1498 /* now fetch the next line */ 1499 if ((n = fgetLine(&buf, &bufsz, x, fp)) <= 0) 1500 break; 1501 x = n; 1502 lineno++; 1503 if (buf[x - 1] != '\n') { 1504 warnx("%s: %d: line truncated at %u", fname, lineno, x); 1505 break; 1506 } 1507 cp = strchr(++cp, '\n'); 1508 } while (cp); 1509 if (buf[x - 1] == '\n') 1510 buf[x - 1] = '\0'; 1511 } 1512 if (!hasOODATE && 1513 !(gn->type & OP_NOMETA_CMP) && 1514 strcmp(p, cmd) != 0) { 1515 if (DEBUG(META)) 1516 fprintf(debug_file, "%s: %d: a build command has changed\n%s\nvs\n%s\n", fname, lineno, p, cmd); 1517 if (!metaIgnoreCMDs) 1518 oodate = TRUE; 1519 } 1520 free(cmd); 1521 ln = Lst_Succ(ln); 1522 } 1523 } else if (strcmp(buf, "CWD") == 0) { 1524 /* 1525 * Check if there are extra commands now 1526 * that weren't in the meta data file. 1527 */ 1528 if (!oodate && ln != NULL) { 1529 if (DEBUG(META)) 1530 fprintf(debug_file, "%s: %d: there are extra build commands now that weren't in the meta data file\n", fname, lineno); 1531 oodate = TRUE; 1532 } 1533 if (strcmp(p, cwd) != 0) { 1534 if (DEBUG(META)) 1535 fprintf(debug_file, "%s: %d: the current working directory has changed from '%s' to '%s'\n", fname, lineno, p, curdir); 1536 oodate = TRUE; 1537 } 1538 } 1539 } 1540 1541 fclose(fp); 1542 if (!Lst_IsEmpty(missingFiles)) { 1543 if (DEBUG(META)) 1544 fprintf(debug_file, "%s: missing files: %s...\n", 1545 fname, (char *)Lst_Datum(Lst_First(missingFiles))); 1546 oodate = TRUE; 1547 } 1548 if (!oodate && !have_filemon && filemonMissing) { 1549 if (DEBUG(META)) 1550 fprintf(debug_file, "%s: missing filemon data\n", fname); 1551 oodate = TRUE; 1552 } 1553 } else { 1554 if (writeMeta && metaMissing) { 1555 cp = NULL; 1556 1557 /* if target is in .CURDIR we do not need a meta file */ 1558 if (gn->path && (cp = strrchr(gn->path, '/')) && cp > gn->path) { 1559 if (strncmp(curdir, gn->path, (cp - gn->path)) != 0) { 1560 cp = NULL; /* not in .CURDIR */ 1561 } 1562 } 1563 if (!cp) { 1564 if (DEBUG(META)) 1565 fprintf(debug_file, "%s: required but missing\n", fname); 1566 oodate = TRUE; 1567 needOODATE = TRUE; /* assume the worst */ 1568 } 1569 } 1570 } 1571 1572 Lst_Destroy(missingFiles, (FreeProc *)free); 1573 1574 if (oodate && needOODATE) { 1575 /* 1576 * Target uses .OODATE which is empty; or we wouldn't be here. 1577 * We have decided it is oodate, so .OODATE needs to be set. 1578 * All we can sanely do is set it to .ALLSRC. 1579 */ 1580 Var_Delete(OODATE, gn); 1581 Var_Set(OODATE, Var_Value(ALLSRC, gn, &cp), gn, 0); 1582 free(cp); 1583 } 1584 1585 oodate_out: 1586 for (i--; i >= 0; i--) { 1587 free(pa[i]); 1588 } 1589 return oodate; 1590 } 1591 1592 /* support for compat mode */ 1593 1594 static int childPipe[2]; 1595 1596 void 1597 meta_compat_start(void) 1598 { 1599 #ifdef USE_FILEMON_ONCE 1600 /* 1601 * We need to re-open filemon for each cmd. 1602 */ 1603 BuildMon *pbm = &Mybm; 1604 1605 if (pbm->mfp != NULL && useFilemon) { 1606 filemon_open(pbm); 1607 } else { 1608 pbm->mon_fd = pbm->filemon_fd = -1; 1609 } 1610 #endif 1611 if (pipe(childPipe) < 0) 1612 Punt("Cannot create pipe: %s", strerror(errno)); 1613 /* Set close-on-exec flag for both */ 1614 (void)fcntl(childPipe[0], F_SETFD, FD_CLOEXEC); 1615 (void)fcntl(childPipe[1], F_SETFD, FD_CLOEXEC); 1616 } 1617 1618 void 1619 meta_compat_child(void) 1620 { 1621 meta_job_child(NULL); 1622 if (dup2(childPipe[1], 1) < 0 || 1623 dup2(1, 2) < 0) { 1624 execError("dup2", "pipe"); 1625 _exit(1); 1626 } 1627 } 1628 1629 void 1630 meta_compat_parent(void) 1631 { 1632 FILE *fp; 1633 char buf[BUFSIZ]; 1634 1635 close(childPipe[1]); /* child side */ 1636 fp = fdopen(childPipe[0], "r"); 1637 while (fgets(buf, sizeof(buf), fp)) { 1638 meta_job_output(NULL, buf, ""); 1639 printf("%s", buf); 1640 fflush(stdout); 1641 } 1642 fclose(fp); 1643 } 1644 1645 #endif /* USE_META */ 1646