contrib/bmake/meta.c

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