contrib/bmake/meta.c

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