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