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