1 /* $NetBSD: main.c,v 1.102 2025/01/07 14:21:11 joe Exp $ */
2
3 /*
4 * Copyright (c) 1992, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This software was developed by the Computer Systems Engineering group
8 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
9 * contributed to Berkeley.
10 *
11 * All advertising materials mentioning features or use of this software
12 * must display the following acknowledgement:
13 * This product includes software developed by the University of
14 * California, Lawrence Berkeley Laboratories.
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 * 3. Neither the name of the University nor the names of its contributors
25 * may be used to endorse or promote products derived from this software
26 * without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * SUCH DAMAGE.
39 *
40 * from: @(#)main.c 8.1 (Berkeley) 6/6/93
41 */
42
43 #if HAVE_NBTOOL_CONFIG_H
44 #include "nbtool_config.h"
45 #endif
46
47 #include <sys/cdefs.h>
48 __RCSID("$NetBSD: main.c,v 1.102 2025/01/07 14:21:11 joe Exp $");
49
50 #ifndef MAKE_BOOTSTRAP
51 #include <sys/cdefs.h>
52 #define COPYRIGHT(x) __COPYRIGHT(x)
53 #else
54 #define COPYRIGHT(x) static const char copyright[] = x
55 #endif
56
57 #ifndef lint
58 COPYRIGHT("@(#) Copyright (c) 1992, 1993\
59 The Regents of the University of California. All rights reserved.");
60 #endif /* not lint */
61
62 #include <sys/types.h>
63 #include <sys/stat.h>
64 #include <sys/param.h>
65 #include <sys/mman.h>
66 #if !HAVE_NBTOOL_CONFIG_H
67 #include <sys/sysctl.h>
68 #endif
69 #include <paths.h>
70 #include <ctype.h>
71 #include <err.h>
72 #include <errno.h>
73 #include <fcntl.h>
74 #include <limits.h>
75 #include <stdio.h>
76 #include <stdlib.h>
77 #include <string.h>
78 #include <unistd.h>
79 #include <vis.h>
80 #include <util.h>
81
82 #include "defs.h"
83 #include "sem.h"
84
85 #ifndef LINE_MAX
86 #define LINE_MAX 1024
87 #endif
88
89 struct devbasetq allbases;
90 struct devatq alldevas;
91 struct conftq allcf;
92 struct devitq alldevi, allpseudo;
93 struct devmtq alldevms;
94 struct pspectq allpspecs;
95
96 struct devi **packed;
97 size_t npacked;
98
99 struct locators locators;
100
101 int lkmmode;
102 const char *conffile; /* source file, e.g., "GENERIC.sparc" */
103 const char *machine; /* machine type, e.g., "sparc" or "sun3" */
104 const char *machinearch; /* machine arch, e.g., "sparc" or "m68k" */
105 struct nvlist *machinesubarches;
106 /* machine subarches, e.g., "sun68k" or "hpc" */
107 const char *ioconfname; /* ioconf name, mutually exclusive to machine */
108 const char *srcdir; /* path to source directory (rel. to build) */
109 const char *builddir; /* path to build directory */
110 const char *defbuilddir; /* default build directory */
111 const char *ident; /* kernel "ident"ification string */
112 int errors; /* counts calls to error() */
113 int minmaxusers; /* minimum "maxusers" parameter */
114 int defmaxusers; /* default "maxusers" parameter */
115 int maxmaxusers; /* default "maxusers" parameter */
116 int maxusers; /* configuration's "maxusers" parameter */
117 int maxpartitions; /* configuration's "maxpartitions" parameter */
118 int version; /* version of the configuration file */
119 struct nvlist *options; /* options */
120 struct nvlist *fsoptions; /* filesystems */
121 struct nvlist *mkoptions; /* makeoptions */
122 struct nvlist *appmkoptions; /* appending mkoptions */
123 struct nvlist *condmkoptions; /* conditional makeoption table */
124 struct hashtab *devbasetab; /* devbase lookup */
125 struct hashtab *devroottab; /* attach at root lookup */
126 struct hashtab *devatab; /* devbase attachment lookup */
127 struct hashtab *deaddevitab; /* removed instances lookup */
128 struct hashtab *selecttab; /* selects things that are "optional foo" */
129 struct hashtab *needcnttab; /* retains names marked "needs-count" */
130 struct hashtab *opttab; /* table of configured options */
131 struct hashtab *fsopttab; /* table of configured file systems */
132 struct dlhash *defopttab; /* options that have been "defopt"'d */
133 struct dlhash *defflagtab; /* options that have been "defflag"'d */
134 struct dlhash *defparamtab; /* options that have been "defparam"'d */
135 struct dlhash *defoptlint; /* lint values for options */
136 struct nvhash *deffstab; /* defined file systems */
137 struct dlhash *optfiletab; /* "defopt"'d option .h files */
138 struct hashtab *attrtab; /* attributes (locators, etc.) */
139 struct hashtab *attrdeptab; /* attribute dependencies */
140 struct hashtab *bdevmtab; /* block devm lookup */
141 struct hashtab *cdevmtab; /* character devm lookup */
142
143 int ndevi; /* number of devi's (before packing) */
144 int npspecs; /* number of parent specs */
145 devmajor_t maxbdevm; /* max number of block major */
146 devmajor_t maxcdevm; /* max number of character major */
147 int do_devsw; /* 0 if pre-devsw config */
148 int oktopackage; /* 0 before setmachine() */
149 int devilevel; /* used for devi->i_level */
150
151 struct filelist allfiles; /* list of all kernel source files */
152 struct filelist allcfiles; /* list of all .c files */
153 struct filelist allsfiles; /* list of all .S files */
154 struct filelist allofiles; /* list of all .o files */
155
156 struct prefixlist prefixes, /* prefix stack */
157 allprefixes; /* all prefixes used (after popped) */
158 struct prefixlist buildprefixes, /* build prefix stack */
159 allbuildprefixes;/* all build prefixes used (after popped) */
160
161 int vflag; /* verbose output */
162 int Pflag; /* pack locators */
163 int Lflag; /* lint config generation */
164 int Mflag; /* modular build */
165 int Sflag; /* suffix rules & subdirectory */
166 int handling_cmdlineopts; /* currently processing -D/-U options */
167
168 int yyparse(void);
169
170 #if !defined(MAKE_BOOTSTRAP) && defined(YYDEBUG)
171 extern int yydebug;
172 #endif
173 int dflag;
174
175 static struct dlhash *obsopttab;
176 static struct hashtab *mkopttab;
177 static struct nvlist **nextopt;
178 static struct nvlist **nextmkopt;
179 static struct nvlist **nextappmkopt;
180 static struct nvlist **nextcndmkopt;
181 static struct nvlist **nextfsopt;
182 static struct nvlist *cmdlinedefs, *cmdlineundefs;
183
184 static void usage(void) __dead;
185 static void dependopts(void);
186 static void dependopts_one(const char *);
187 static void do_depends(struct nvlist *);
188 static void do_depend(struct nvlist *);
189 static void stop(void);
190 static int do_option(struct hashtab *, struct nvlist **,
191 struct nvlist ***, const char *, const char *,
192 const char *, struct hashtab *);
193 static int undo_option(struct hashtab *, struct nvlist **,
194 struct nvlist ***, const char *, const char *, int);
195 static int crosscheck(void);
196 static int badstar(void);
197 static int mkallsubdirs(void);
198 static int mksymlinks(void);
199 static int mkident(void);
200 static int devbase_has_dead_instances(const char *, void *, void *);
201 static int devbase_has_any_instance(struct devbase *, int, int, int);
202 static int check_dead_devi(const char *, void *, void *);
203 static void add_makeopt(const char *);
204 static void remove_makeopt(const char *);
205 static void handle_cmdline_makeoptions(void);
206 static void kill_orphans(void);
207 static void do_kill_orphans(struct devbase *, struct attr *,
208 struct devbase *, int);
209 static int kill_orphans_cb(const char *, void *, void *);
210 static int cfcrosscheck(struct config *, const char *, struct nvlist *);
211 static void defopt(struct dlhash *ht, const char *fname,
212 struct defoptlist *opts, struct nvlist *deps, int obs);
213 static struct nvlist *find_declared_fs_option(const char *name);
214
215 #define LOGCONFIG_LARGE "INCLUDE_CONFIG_FILE"
216 #define LOGCONFIG_SMALL "INCLUDE_JUST_CONFIG"
217
218 static void logconfig_start(void);
219 static void logconfig_end(void);
220 static FILE *cfg;
221 static time_t cfgtime;
222
223 static int is_elf(const char *);
224 static int extract_config(const char *, const char *, int);
225
226 int badfilename(const char *fname);
227
228 const char *progname;
229 extern const char *yyfile;
230
231 int
main(int argc,char ** argv)232 main(int argc, char **argv)
233 {
234 char *p, cname[PATH_MAX];
235 const char *last_component;
236 int pflag, xflag, ch, removeit;
237
238 setprogname(argv[0]);
239
240 pflag = 0;
241 xflag = 0;
242 while ((ch = getopt(argc, argv, "D:LMPSU:dgpvb:s:x")) != -1) {
243 switch (ch) {
244
245 case 'd':
246 #if !defined(MAKE_BOOTSTRAP) && defined(YYDEBUG)
247 yydebug = 1;
248 #endif
249 dflag++;
250 break;
251
252 case 'M':
253 Mflag = 1;
254 break;
255
256 case 'L':
257 Lflag = 1;
258 break;
259
260 case 'P':
261 Pflag = 1;
262 break;
263
264 case 'g':
265 /*
266 * In addition to DEBUG, you probably wanted to
267 * set "options KGDB" and maybe others. We could
268 * do that for you, but you really should just
269 * put them in the config file.
270 */
271 warnx("-g is obsolete (use -D DEBUG=\"-g\")");
272 usage();
273 /*NOTREACHED*/
274
275 case 'p':
276 /*
277 * Essentially the same as makeoptions PROF="-pg",
278 * but also changes the path from ../../compile/FOO
279 * to ../../compile/FOO.PROF; i.e., compile a
280 * profiling kernel based on a typical "regular"
281 * kernel.
282 *
283 * Note that if you always want profiling, you
284 * can (and should) use a "makeoptions" line.
285 */
286 pflag = 1;
287 break;
288
289 case 'v':
290 vflag = 1;
291 break;
292
293 case 'b':
294 builddir = optarg;
295 break;
296
297 case 's':
298 srcdir = optarg;
299 break;
300
301 case 'S':
302 Sflag = 1;
303 break;
304
305 case 'x':
306 xflag = 1;
307 break;
308
309 case 'D':
310 add_makeopt(optarg);
311 break;
312
313 case 'U':
314 remove_makeopt(optarg);
315 break;
316
317 case '?':
318 default:
319 usage();
320 }
321 }
322
323 if (xflag && optind != 2) {
324 errx(EXIT_FAILURE, "-x must be used alone");
325 }
326
327 argc -= optind;
328 argv += optind;
329 if (argc > 1) {
330 usage();
331 }
332
333 if (Lflag && (builddir != NULL || Pflag || pflag))
334 errx(EXIT_FAILURE, "-L can only be used with -s and -v");
335
336 if (xflag) {
337 if (argc == 0) {
338 #if !HAVE_NBTOOL_CONFIG_H
339 char path_unix[MAXPATHLEN];
340 size_t len = sizeof(path_unix) - 1;
341 path_unix[0] = '/';
342
343 conffile = sysctlbyname("machdep.booted_kernel",
344 &path_unix[1], &len, NULL, 0) == -1 ? _PATH_UNIX :
345 path_unix;
346 #else
347 errx(EXIT_FAILURE, "no kernel supplied");
348 #endif
349 } else
350 conffile = argv[0];
351 if (!is_elf(conffile))
352 errx(EXIT_FAILURE, "%s: not a binary kernel",
353 conffile);
354 if (!extract_config(conffile, "stdout", STDOUT_FILENO))
355 errx(EXIT_FAILURE, "%s does not contain embedded "
356 "configuration data", conffile);
357 exit(0);
358 }
359
360 conffile = (argc == 1) ? argv[0] : "CONFIG";
361 if (firstfile(conffile)) {
362 err(EXIT_FAILURE, "Cannot read `%s'", conffile);
363 exit(2);
364 }
365
366 /*
367 * Init variables.
368 */
369 minmaxusers = 1;
370 maxmaxusers = 10000;
371 initintern();
372 ident = NULL;
373 devbasetab = ht_new();
374 devroottab = ht_new();
375 devatab = ht_new();
376 devitab = ht_new();
377 deaddevitab = ht_new();
378 selecttab = ht_new();
379 needcnttab = ht_new();
380 opttab = ht_new();
381 mkopttab = ht_new();
382 fsopttab = ht_new();
383 deffstab = nvhash_create();
384 defopttab = dlhash_create();
385 defparamtab = dlhash_create();
386 defoptlint = dlhash_create();
387 defflagtab = dlhash_create();
388 optfiletab = dlhash_create();
389 obsopttab = dlhash_create();
390 bdevmtab = ht_new();
391 maxbdevm = 0;
392 cdevmtab = ht_new();
393 maxcdevm = 0;
394 nextopt = &options;
395 nextmkopt = &mkoptions;
396 nextappmkopt = &appmkoptions;
397 nextcndmkopt = &condmkoptions;
398 nextfsopt = &fsoptions;
399 initfiles();
400 initsem();
401
402 /*
403 * Handle profiling (must do this before we try to create any
404 * files).
405 */
406 last_component = strrchr(conffile, '/');
407 last_component = (last_component) ? last_component + 1 : conffile;
408 if (pflag) {
409 p = emalloc(strlen(last_component) + 17);
410 (void)sprintf(p, "../compile/%s.PROF", last_component);
411 (void)addmkoption(intern("PROF"), "-pg");
412 (void)addoption(intern("GPROF"), NULL);
413 } else {
414 p = emalloc(strlen(last_component) + 13);
415 (void)sprintf(p, "../compile/%s", last_component);
416 }
417 defbuilddir = (argc == 0) ? "." : p;
418
419 if (Lflag) {
420 char resolvedname[MAXPATHLEN];
421
422 if (realpath(conffile, resolvedname) == NULL)
423 err(EXIT_FAILURE, "realpath(%s)", conffile);
424
425 if (yyparse())
426 stop();
427
428 printf("include \"%s\"\n", resolvedname);
429
430 emit_params();
431 emit_options();
432 emit_instances();
433
434 exit(EXIT_SUCCESS);
435 }
436
437 removeit = 0;
438 if (is_elf(conffile)) {
439 const char *tmpdir;
440 int cfd;
441
442 if (builddir == NULL)
443 errx(EXIT_FAILURE, "Build directory must be specified "
444 "with binary kernels");
445
446 /* Open temporary configuration file */
447 tmpdir = getenv("TMPDIR");
448 if (tmpdir == NULL)
449 tmpdir = _PATH_TMP;
450 snprintf(cname, sizeof(cname), "%s/config.tmp.XXXXXX", tmpdir);
451 cfd = mkstemp(cname);
452 if (cfd == -1)
453 err(EXIT_FAILURE, "Cannot create `%s'", cname);
454
455 printf("Using configuration data embedded in kernel...\n");
456 if (!extract_config(conffile, cname, cfd)) {
457 unlink(cname);
458 errx(EXIT_FAILURE, "%s does not contain embedded "
459 "configuration data", conffile);
460 }
461
462 removeit = 1;
463 close(cfd);
464 firstfile(cname);
465 }
466
467 /*
468 * Log config file. We don't know until yyparse() if we're
469 * going to need config_file.h (i.e. if we're doing ioconf-only
470 * or not). Just start creating the file, and when we know
471 * later, we'll just keep or discard our work here.
472 */
473 logconfig_start();
474
475 /*
476 * Parse config file (including machine definitions).
477 */
478 if (yyparse())
479 stop();
480
481 if (ioconfname && cfg)
482 fclose(cfg);
483 else
484 logconfig_end();
485
486 if (removeit)
487 unlink(cname);
488
489 /*
490 * Handle command line overrides
491 */
492 yyfile = "handle_cmdline_makeoptions";
493 handle_cmdline_makeoptions();
494
495 /*
496 * Detect and properly ignore orphaned devices
497 */
498 yyfile = "kill_orphans";
499 kill_orphans();
500
501 /*
502 * Select devices and pseudo devices and their attributes
503 */
504 yyfile = "fixdevis";
505 if (fixdevis())
506 stop();
507
508 /*
509 * Copy maxusers to param.
510 */
511 yyfile = "fixmaxusers";
512 fixmaxusers();
513
514 /*
515 * Copy makeoptions to params
516 */
517 yyfile = "fixmkoption";
518 fixmkoption();
519
520 /*
521 * If working on an ioconf-only config, process here and exit
522 */
523 if (ioconfname) {
524 yyfile = "pack";
525 pack();
526 yyfile = "mkioconf";
527 mkioconf();
528 yyfile = "emitlocs";
529 emitlocs();
530 yyfile = "emitioconfh";
531 emitioconfh();
532 return 0;
533 }
534
535 yyfile = "dependattrs";
536 dependattrs();
537
538 /*
539 * Deal with option dependencies.
540 */
541 yyfile = "dependopts";
542 dependopts();
543
544 /*
545 * Fix (as in `set firmly in place') files.
546 */
547 yyfile = "fixfiles";
548 if (fixfiles())
549 stop();
550
551 /*
552 * Fix device-majors.
553 */
554 yyfile = "fixdevsw";
555 if (fixdevsw())
556 stop();
557
558 /*
559 * Perform cross-checking.
560 */
561 if (maxusers == 0) {
562 if (defmaxusers) {
563 (void)printf("maxusers not specified; %d assumed\n",
564 defmaxusers);
565 maxusers = defmaxusers;
566 } else {
567 warnx("need \"maxusers\" line");
568 errors++;
569 }
570 }
571 if (crosscheck() || errors)
572 stop();
573
574 /*
575 * Squeeze things down and finish cross-checks (STAR checks must
576 * run after packing).
577 */
578 yyfile = "pack";
579 pack();
580 yyfile = "badstar";
581 if (badstar())
582 stop();
583
584 yyfile = NULL;
585 /*
586 * Ready to go. Build all the various files.
587 */
588 if ((Sflag && mkallsubdirs()) || mksymlinks() || mkmakefile() || mkheaders() || mkswap() ||
589 mkioconf() || (do_devsw ? mkdevsw() : 0) || mkident() || errors)
590 stop();
591 (void)printf("Build directory is %s\n", builddir);
592 (void)printf("Don't forget to run \"make depend\"\n");
593
594 return 0;
595 }
596
597 static void
usage(void)598 usage(void)
599 {
600 (void)fprintf(stderr, "Usage: %s [-Ppv] [-b builddir] [-D var=value] "
601 "[-s srcdir] [-U var] "
602 "[config-file]\n\t%s -x [kernel-file]\n"
603 "\t%s -L [-v] [-s srcdir] [config-file]\n",
604 getprogname(), getprogname(), getprogname());
605 exit(1);
606 }
607
608 /*
609 * Set any options that are implied by other options.
610 */
611 static void
dependopts(void)612 dependopts(void)
613 {
614 struct nvlist *nv;
615
616 for (nv = options; nv != NULL; nv = nv->nv_next) {
617 dependopts_one(nv->nv_name);
618 }
619
620 for (nv = fsoptions; nv != NULL; nv = nv->nv_next) {
621 dependopts_one(nv->nv_name);
622 }
623 }
624
625 static void
dependopts_one(const char * name)626 dependopts_one(const char *name)
627 {
628 struct defoptlist *dl;
629 struct nvlist *fs;
630
631 dl = find_declared_option_option(name);
632 if (dl != NULL) {
633 do_depends(dl->dl_depends);
634 }
635 fs = find_declared_fs_option(name);
636 if (fs != NULL) {
637 do_depends(fs->nv_ptr);
638 }
639
640 CFGDBG(3, "depend `%s' searched", name);
641 }
642
643 static void
do_depends(struct nvlist * nv)644 do_depends(struct nvlist *nv)
645 {
646 struct nvlist *opt;
647
648 for (opt = nv; opt != NULL; opt = opt->nv_next) {
649 do_depend(opt);
650 }
651 }
652
653 static void
do_depend(struct nvlist * nv)654 do_depend(struct nvlist *nv)
655 {
656 struct attr *a;
657
658 if (nv != NULL && (nv->nv_flags & NV_DEPENDED) == 0) {
659 nv->nv_flags |= NV_DEPENDED;
660 /*
661 * If the dependency is an attribute, then just add
662 * it to the selecttab.
663 */
664 CFGDBG(3, "depend attr `%s'", nv->nv_name);
665 if ((a = ht_lookup(attrtab, nv->nv_name)) != NULL) {
666 if (a->a_iattr)
667 panic("do_depend(%s): dep `%s' is an iattr",
668 nv->nv_name, a->a_name);
669 expandattr(a, selectattr);
670 } else {
671 if (ht_lookup(opttab, nv->nv_name) == NULL)
672 addoption(nv->nv_name, NULL);
673 dependopts_one(nv->nv_name);
674 }
675 }
676 }
677
678 static int
recreate(const char * p,const char * q)679 recreate(const char *p, const char *q)
680 {
681 int ret;
682
683 if ((ret = unlink(q)) == -1 && errno != ENOENT)
684 warn("unlink(%s)", q);
685 if ((ret = symlink(p, q)) == -1)
686 warn("symlink(%s -> %s)", q, p);
687 return ret;
688 }
689
690 static void
mksubdir(char * buf)691 mksubdir(char *buf)
692 {
693 char *p;
694 struct stat st;
695
696 p = strrchr(buf, '/');
697 if (p != NULL && *p == '/') {
698 *p = '\0';
699 mksubdir(buf);
700 *p = '/';
701 }
702 if (stat(buf, &st) == 0) {
703 if (!S_ISDIR(st.st_mode))
704 errx(EXIT_FAILURE, "not directory %s", buf);
705 } else
706 if (mkdir(buf, 0777) == -1)
707 errx(EXIT_FAILURE, "cannot create %s", buf);
708 }
709
710 static int
mksubdirs(struct filelist * fl)711 mksubdirs(struct filelist *fl)
712 {
713 struct files *fi;
714 const char *prologue, *prefix, *sep;
715 char buf[MAXPATHLEN];
716
717 TAILQ_FOREACH(fi, fl, fi_next) {
718 if ((fi->fi_flags & FI_SEL) == 0)
719 continue;
720 prefix = sep = "";
721 if (fi->fi_buildprefix != NULL) {
722 prefix = fi->fi_buildprefix;
723 sep = "/";
724 } else {
725 if (fi->fi_prefix != NULL) {
726 prefix = fi->fi_prefix;
727 sep = "/";
728 }
729 }
730 snprintf(buf, sizeof(buf), "%s%s%s", prefix, sep, fi->fi_dir);
731 if (buf[0] == '\0')
732 continue;
733 mksubdir(buf);
734 if (fi->fi_prefix != NULL && fi->fi_buildprefix != NULL) {
735 char org[MAXPATHLEN];
736
737 if (fi->fi_prefix[0] == '/') {
738 prologue = "";
739 sep = "";
740 } else {
741 prologue = srcdir;
742 sep = "/";
743 }
744 snprintf(buf, sizeof(buf), "%s%s%s",
745 fi->fi_buildprefix, "/", fi->fi_path);
746 snprintf(org, sizeof(org), "%s%s%s%s%s",
747 prologue, sep, fi->fi_prefix, "/", fi->fi_path);
748 recreate(org, buf);
749 fi->fi_prefix = fi->fi_buildprefix;
750 fi->fi_buildprefix = NULL;
751 }
752 }
753
754 return 0;
755 }
756
757 static int
mkallsubdirs(void)758 mkallsubdirs(void)
759 {
760
761 mksubdirs(&allfiles);
762 mksubdirs(&allofiles);
763 return 0;
764 }
765
766 /*
767 * Make a symlink for "machine" so that "#include <machine/foo.h>" works,
768 * and for the machine's CPU architecture, so that works as well.
769 */
770 static int
mksymlinks(void)771 mksymlinks(void)
772 {
773 int ret;
774 char *p, buf[MAXPATHLEN];
775 const char *q;
776 struct nvlist *nv;
777
778 p = buf;
779
780 snprintf(buf, sizeof(buf), "%s/arch/%s/include", srcdir, machine);
781 ret = recreate(p, "machine");
782 ret = recreate(p, machine);
783
784 if (machinearch != NULL) {
785 snprintf(buf, sizeof(buf), "%s/arch/%s/include", srcdir, machinearch);
786 q = machinearch;
787 } else {
788 snprintf(buf, sizeof(buf), "machine");
789 q = machine;
790 }
791
792 ret = recreate(p, q);
793
794 for (nv = machinesubarches; nv != NULL; nv = nv->nv_next) {
795 q = nv->nv_name;
796 snprintf(buf, sizeof(buf), "%s/arch/%s/include", srcdir, q);
797 ret = recreate(p, q);
798 }
799
800 return (ret);
801 }
802
803 static __dead void
stop(void)804 stop(void)
805 {
806 (void)fprintf(stderr, "*** Stop.\n");
807 exit(1);
808 }
809
810 static void
check_dependencies(const char * thing,struct nvlist * deps)811 check_dependencies(const char *thing, struct nvlist *deps)
812 {
813 struct nvlist *dep;
814 struct attr *a;
815
816 for (dep = deps; dep != NULL; dep = dep->nv_next) {
817 /*
818 * If the dependency is an attribute, it must not
819 * be an interface attribute. Otherwise, it must
820 * be a previously declared option.
821 */
822 if ((a = ht_lookup(attrtab, dep->nv_name)) != NULL) {
823 if (a->a_iattr)
824 cfgerror("option `%s' dependency `%s' "
825 "is an interface attribute",
826 thing, a->a_name);
827 } else if (OPT_OBSOLETE(dep->nv_name)) {
828 cfgerror("option `%s' dependency `%s' "
829 "is obsolete", thing, dep->nv_name);
830 } else if (!find_declared_option(dep->nv_name)) {
831 cfgerror("option `%s' dependency `%s' "
832 "is an unknown option",
833 thing, dep->nv_name);
834 }
835 }
836 }
837
838 static void
add_fs_dependencies(struct nvlist * nv,struct nvlist * deps)839 add_fs_dependencies(struct nvlist *nv, struct nvlist *deps)
840 {
841 /* Use nv_ptr to link any other options that are implied. */
842 nv->nv_ptr = deps;
843 check_dependencies(nv->nv_name, deps);
844 }
845
846 static void
add_opt_dependencies(struct defoptlist * dl,struct nvlist * deps)847 add_opt_dependencies(struct defoptlist *dl, struct nvlist *deps)
848 {
849 dl->dl_depends = deps;
850 check_dependencies(dl->dl_name, deps);
851 }
852
853 /*
854 * Define one or more file systems.
855 */
856 void
deffilesystem(struct nvlist * fses,struct nvlist * deps)857 deffilesystem(struct nvlist *fses, struct nvlist *deps)
858 {
859 struct nvlist *nv;
860 struct where *w;
861
862 /*
863 * Mark these options as ones to skip when creating the Makefile.
864 */
865 for (nv = fses; nv != NULL; nv = nv->nv_next) {
866 if ((w = DEFINED_OPTION(nv->nv_name)) != NULL) {
867 cfgerror("file system or option `%s' already defined"
868 " at %s:%hu", nv->nv_name, w->w_srcfile,
869 w->w_srcline);
870 return;
871 }
872
873 /*
874 * Also mark it as a valid file system, which may be
875 * used in "file-system" directives in the config
876 * file.
877 */
878 if (nvhash_insert(deffstab, nv->nv_name, nv))
879 panic("file system `%s' already in table?!",
880 nv->nv_name);
881
882 add_fs_dependencies(nv, deps);
883
884 /*
885 * Implicit attribute definition for filesystem.
886 */
887 const char *n;
888 n = strtolower(nv->nv_name);
889 refattr(n);
890 }
891 }
892
893 /*
894 * Sanity check a file name.
895 */
896 int
badfilename(const char * fname)897 badfilename(const char *fname)
898 {
899 const char *n;
900
901 /*
902 * We're putting multiple options into one file. Sanity
903 * check the file name.
904 */
905 if (strchr(fname, '/') != NULL) {
906 cfgerror("option file name contains a `/'");
907 return 1;
908 }
909 if ((n = strrchr(fname, '.')) == NULL || strcmp(n, ".h") != 0) {
910 cfgerror("option file name does not end in `.h'");
911 return 1;
912 }
913 return 0;
914 }
915
916
917 /*
918 * Search for a defined option (defopt, filesystem, etc), and if found,
919 * return the option's struct nvlist.
920 *
921 * This used to be one function (find_declared_option) before options
922 * and filesystems became different types.
923 */
924 struct defoptlist *
find_declared_option_option(const char * name)925 find_declared_option_option(const char *name)
926 {
927 struct defoptlist *option;
928
929 if ((option = dlhash_lookup(defopttab, name)) != NULL ||
930 (option = dlhash_lookup(defparamtab, name)) != NULL ||
931 (option = dlhash_lookup(defflagtab, name)) != NULL) {
932 return (option);
933 }
934
935 return (NULL);
936 }
937
938 static struct nvlist *
find_declared_fs_option(const char * name)939 find_declared_fs_option(const char *name)
940 {
941 struct nvlist *fs;
942
943 if ((fs = nvhash_lookup(deffstab, name)) != NULL) {
944 return fs;
945 }
946
947 return (NULL);
948 }
949
950 /*
951 * Like find_declared_option but doesn't return what it finds, so it
952 * can search both the various kinds of options and also filesystems.
953 */
954 struct where *
find_declared_option(const char * name)955 find_declared_option(const char *name)
956 {
957 struct defoptlist *option = NULL;
958 struct nvlist *fs;
959
960 if ((option = dlhash_lookup(defopttab, name)) != NULL ||
961 (option = dlhash_lookup(defparamtab, name)) != NULL ||
962 (option = dlhash_lookup(defflagtab, name)) != NULL) {
963 return &option->dl_where;
964 }
965 if ((fs = nvhash_lookup(deffstab, name)) != NULL) {
966 return &fs->nv_where;
967 }
968
969 return NULL;
970 }
971
972 /*
973 * Define one or more standard options. If an option file name is specified,
974 * place all options in one file with the specified name. Otherwise, create
975 * an option file for each option.
976 * record the option information in the specified table.
977 */
978 void
defopt(struct dlhash * ht,const char * fname,struct defoptlist * opts,struct nvlist * deps,int obs)979 defopt(struct dlhash *ht, const char *fname, struct defoptlist *opts,
980 struct nvlist *deps, int obs)
981 {
982 struct defoptlist *dl, *nextdl, *olddl;
983 const char *name;
984 struct where *w;
985 char buf[500];
986
987 if (fname != NULL && badfilename(fname)) {
988 return;
989 }
990
991 /*
992 * Mark these options as ones to skip when creating the Makefile.
993 */
994 for (dl = opts; dl != NULL; dl = nextdl) {
995 nextdl = dl->dl_next;
996
997 if (dl->dl_lintvalue != NULL) {
998 /*
999 * If an entry already exists, then we are about to
1000 * complain, so no worry.
1001 */
1002 (void) dlhash_insert(defoptlint, dl->dl_name,
1003 dl);
1004 }
1005
1006 /* An option name can be declared at most once. */
1007 if ((w = DEFINED_OPTION(dl->dl_name)) != NULL) {
1008 cfgerror("file system or option `%s' already defined"
1009 " at %s:%hu", dl->dl_name, w->w_srcfile,
1010 w->w_srcline);
1011 return;
1012 }
1013
1014 if (dlhash_insert(ht, dl->dl_name, dl)) {
1015 cfgerror("file system or option `%s' already defined"
1016 " at %s:%hu", dl->dl_name, dl->dl_where.w_srcfile,
1017 dl->dl_where.w_srcline);
1018 return;
1019 }
1020
1021 if (fname == NULL) {
1022 /*
1023 * Each option will be going into its own file.
1024 * Convert the option name to lower case. This
1025 * lower case name will be used as the option
1026 * file name.
1027 */
1028 (void) snprintf(buf, sizeof(buf), "opt_%s.h",
1029 strtolower(dl->dl_name));
1030 name = intern(buf);
1031 } else {
1032 name = fname;
1033 }
1034
1035 add_opt_dependencies(dl, deps);
1036
1037 /*
1038 * Remove this option from the parameter list before adding
1039 * it to the list associated with this option file.
1040 */
1041 dl->dl_next = NULL;
1042
1043 /*
1044 * Flag as obsolete, if requested.
1045 */
1046 if (obs) {
1047 dl->dl_obsolete = 1;
1048 (void)dlhash_insert(obsopttab, dl->dl_name, dl);
1049 }
1050
1051 /*
1052 * Add this option file if we haven't seen it yet.
1053 * Otherwise, append to the list of options already
1054 * associated with this file.
1055 */
1056 if ((olddl = dlhash_lookup(optfiletab, name)) == NULL) {
1057 (void)dlhash_insert(optfiletab, name, dl);
1058 } else {
1059 while (olddl->dl_next != NULL)
1060 olddl = olddl->dl_next;
1061 olddl->dl_next = dl;
1062 }
1063 }
1064 }
1065
1066 /*
1067 * Specify that a defined option should have a Makefile variable created.
1068 */
1069 static void
mkoptvar(struct dlhash * ht,struct defoptlist * opts)1070 mkoptvar(struct dlhash *ht, struct defoptlist *opts)
1071 {
1072 struct defoptlist *dl, *defined_dl;
1073
1074 for (dl = opts; dl != NULL; dl = dl->dl_next) {
1075 defined_dl = dlhash_lookup(ht, dl->dl_name);
1076 if (defined_dl == NULL) {
1077 cfgerror("option `%s' not defined"
1078 " at %s:%hu", dl->dl_name, dl->dl_where.w_srcfile,
1079 dl->dl_where.w_srcline);
1080 continue;
1081 }
1082 defined_dl->dl_mkvar = 1;
1083 }
1084 defoptlist_destroy(dl);
1085 }
1086
1087 /*
1088 * Define one or more standard options. If an option file name is specified,
1089 * place all options in one file with the specified name. Otherwise, create
1090 * an option file for each option.
1091 */
1092 void
defoption(const char * fname,struct defoptlist * opts,struct nvlist * deps)1093 defoption(const char *fname, struct defoptlist *opts, struct nvlist *deps)
1094 {
1095
1096 cfgwarn("The use of `defopt' is deprecated");
1097 defopt(defopttab, fname, opts, deps, 0);
1098 }
1099
1100
1101 /*
1102 * Define an option for which a value is required.
1103 */
1104 void
defparam(const char * fname,struct defoptlist * opts,struct nvlist * deps,int obs)1105 defparam(const char *fname, struct defoptlist *opts, struct nvlist *deps, int obs)
1106 {
1107
1108 defopt(defparamtab, fname, opts, deps, obs);
1109 }
1110
1111 /*
1112 * Define an option which must not have a value, and which
1113 * emits a "needs-flag" style output.
1114 */
1115 void
defflag(const char * fname,struct defoptlist * opts,struct nvlist * deps,int obs)1116 defflag(const char *fname, struct defoptlist *opts, struct nvlist *deps, int obs)
1117 {
1118
1119 defopt(defflagtab, fname, opts, deps, obs);
1120 }
1121
1122 /*
1123 * Specify that a defined flag option should have a Makefile variable
1124 * created.
1125 */
1126 void
mkflagvar(struct defoptlist * opts)1127 mkflagvar(struct defoptlist *opts)
1128 {
1129
1130 mkoptvar(defflagtab, opts);
1131 }
1132
1133 /*
1134 * Add an option from "options FOO". Note that this selects things that
1135 * are "optional foo".
1136 */
1137 void
addoption(const char * name,const char * value)1138 addoption(const char *name, const char *value)
1139 {
1140 const char *n;
1141 int is_fs, is_param, is_flag, is_undecl, is_obs;
1142
1143 /*
1144 * Figure out how this option was declared (if at all.)
1145 * XXX should use "params" and "flags" in config.
1146 * XXX crying out for a type field in a unified hashtab.
1147 */
1148 is_fs = OPT_FSOPT(name);
1149 is_param = OPT_DEFPARAM(name);
1150 is_flag = OPT_DEFFLAG(name);
1151 is_obs = OPT_OBSOLETE(name);
1152 is_undecl = !DEFINED_OPTION(name);
1153
1154 /* Warn and pretend the user had not selected the option */
1155 if (is_obs) {
1156 cfgwarn("obsolete option `%s' will be ignored", name);
1157 return;
1158 }
1159
1160 /* Make sure this is not a defined file system. */
1161 if (is_fs) {
1162 cfgerror("`%s' is a defined file system", name);
1163 return;
1164 }
1165 /* A defparam must have a value */
1166 if (is_param && value == NULL) {
1167 cfgerror("option `%s' must have a value", name);
1168 return;
1169 }
1170 /* A defflag must not have a value */
1171 if (is_flag && value != NULL) {
1172 cfgerror("option `%s' must not have a value", name);
1173 return;
1174 }
1175
1176 if (is_undecl && vflag) {
1177 cfgwarn("undeclared option `%s' added to IDENT", name);
1178 }
1179
1180 if (do_option(opttab, &options, &nextopt, name, value, "options",
1181 selecttab))
1182 return;
1183
1184 /* make lowercase, then add to select table */
1185 n = strtolower(name);
1186 (void)ht_insert(selecttab, n, (void *)__UNCONST(n));
1187 CFGDBG(3, "option selected `%s'", n);
1188 }
1189
1190 void
deloption(const char * name,int nowarn)1191 deloption(const char *name, int nowarn)
1192 {
1193
1194 CFGDBG(4, "deselecting opt `%s'", name);
1195 if (undo_option(opttab, &options, &nextopt, name, "options", nowarn))
1196 return;
1197 if (undo_option(selecttab, NULL, NULL, strtolower(name), "options", nowarn))
1198 return;
1199 }
1200
1201 /*
1202 * Add a file system option. This routine simply inserts the name into
1203 * a list of valid file systems, which is used to validate the root
1204 * file system type. The name is then treated like a standard option.
1205 */
1206 void
addfsoption(const char * name)1207 addfsoption(const char *name)
1208 {
1209 const char *n;
1210
1211 /* Make sure this is a defined file system. */
1212 if (!OPT_FSOPT(name)) {
1213 cfgerror("`%s' is not a defined file system", name);
1214 return;
1215 }
1216
1217 /*
1218 * Convert to lower case. This will be used in the select
1219 * table, to verify root file systems.
1220 */
1221 n = strtolower(name);
1222
1223 if (do_option(fsopttab, &fsoptions, &nextfsopt, name, n, "file-system",
1224 selecttab))
1225 return;
1226
1227 /* Add to select table. */
1228 (void)ht_insert(selecttab, n, __UNCONST(n));
1229 CFGDBG(3, "fs selected `%s'", name);
1230
1231 /*
1232 * Select attribute if one exists.
1233 */
1234 struct attr *a;
1235 if ((a = ht_lookup(attrtab, n)) != NULL)
1236 selectattr(a);
1237 }
1238
1239 void
delfsoption(const char * name,int nowarn)1240 delfsoption(const char *name, int nowarn)
1241 {
1242 const char *n;
1243
1244 CFGDBG(4, "deselecting fs `%s'", name);
1245 n = strtolower(name);
1246 if (undo_option(fsopttab, &fsoptions, &nextfsopt, name, "file-system", nowarn))
1247 return;
1248 if (undo_option(selecttab, NULL, NULL, n, "file-system", nowarn))
1249 return;
1250 }
1251
1252 /*
1253 * Add a "make" option.
1254 */
1255 void
addmkoption(const char * name,const char * value)1256 addmkoption(const char *name, const char *value)
1257 {
1258
1259 (void)do_option(mkopttab, &mkoptions, &nextmkopt, name, value,
1260 "makeoptions", NULL);
1261 }
1262
1263 void
delmkoption(const char * name,int nowarn)1264 delmkoption(const char *name, int nowarn)
1265 {
1266
1267 CFGDBG(4, "deselecting mkopt `%s'", name);
1268 (void)undo_option(mkopttab, &mkoptions, &nextmkopt, name,
1269 "makeoptions", nowarn);
1270 }
1271
1272 /*
1273 * Add an appending "make" option.
1274 */
1275 void
appendmkoption(const char * name,const char * value)1276 appendmkoption(const char *name, const char *value)
1277 {
1278 struct nvlist *nv;
1279
1280 nv = newnv(name, value, NULL, 0, NULL);
1281 *nextappmkopt = nv;
1282 nextappmkopt = &nv->nv_next;
1283 }
1284
1285 /*
1286 * Add a conditional appending "make" option.
1287 */
1288 void
appendcondmkoption(struct condexpr * cond,const char * name,const char * value)1289 appendcondmkoption(struct condexpr *cond, const char *name, const char *value)
1290 {
1291 struct nvlist *nv;
1292
1293 nv = newnv(name, value, cond, 0, NULL);
1294 *nextcndmkopt = nv;
1295 nextcndmkopt = &nv->nv_next;
1296 }
1297
1298 /*
1299 * Copy maxusers to param "MAXUSERS".
1300 */
1301 void
fixmaxusers(void)1302 fixmaxusers(void)
1303 {
1304 char str[32];
1305
1306 snprintf(str, sizeof(str), "%d", maxusers);
1307 addoption(intern("MAXUSERS"), intern(str));
1308 }
1309
1310 /*
1311 * Copy makeoptions to params with "makeoptions_" prefix.
1312 */
1313 void
fixmkoption(void)1314 fixmkoption(void)
1315 {
1316 struct nvlist *nv;
1317 char buf[100];
1318 const char *name;
1319
1320 for (nv = mkoptions; nv != NULL; nv = nv->nv_next) {
1321 snprintf(buf, sizeof(buf), "makeoptions_%s", nv->nv_name);
1322 name = intern(buf);
1323 if (!DEFINED_OPTION(name) || !OPT_DEFPARAM(name))
1324 continue;
1325 addoption(name, intern(nv->nv_str));
1326 }
1327 }
1328
1329 /*
1330 * Add a name=value pair to an option list. The value may be NULL.
1331 */
1332 static int
do_option(struct hashtab * ht,struct nvlist ** npp,struct nvlist *** next,const char * name,const char * value,const char * type,struct hashtab * stab)1333 do_option(struct hashtab *ht, struct nvlist **npp, struct nvlist ***next,
1334 const char *name, const char *value, const char *type,
1335 struct hashtab *stab)
1336 {
1337 struct nvlist *nv, *onv;
1338
1339 /* assume it will work */
1340 nv = newnv(name, value, NULL, 0, NULL);
1341 if (ht_insert(ht, name, nv) != 0) {
1342
1343 /* oops, already got that option - remove it first */
1344 if ((onv = ht_lookup(ht, name)) == NULL)
1345 panic("do_option 1");
1346 if (onv->nv_str != NULL && !OPT_FSOPT(name))
1347 cfgwarn("already have %s `%s=%s'", type, name,
1348 onv->nv_str);
1349 else
1350 cfgwarn("already have %s `%s'", type, name);
1351
1352 if (undo_option(ht, npp, next, name, type, 0))
1353 panic("do_option 2");
1354 if (stab != NULL &&
1355 undo_option(stab, NULL, NULL, strtolower(name), type, 0))
1356 panic("do_option 3");
1357
1358 /* now try adding it again */
1359 if (ht_insert(ht, name, nv) != 0)
1360 panic("do_option 4");
1361
1362 CFGDBG(2, "opt `%s' replaced", name);
1363 }
1364 **next = nv;
1365 *next = &nv->nv_next;
1366
1367 return (0);
1368 }
1369
1370 /*
1371 * Remove a name from a hash table,
1372 * and optionally, a name=value pair from an option list.
1373 */
1374 static int
undo_option(struct hashtab * ht,struct nvlist ** npp,struct nvlist *** next,const char * name,const char * type,int nowarn)1375 undo_option(struct hashtab *ht, struct nvlist **npp,
1376 struct nvlist ***next, const char *name, const char *type, int nowarn)
1377 {
1378 struct nvlist *nv;
1379
1380 if (ht_remove(ht, name)) {
1381 /*
1382 * -U command line option removals are always silent
1383 */
1384 if (!handling_cmdlineopts && !nowarn)
1385 cfgwarn("%s `%s' is not defined", type, name);
1386 return (1);
1387 }
1388 if (npp == NULL) {
1389 CFGDBG(2, "opt `%s' deselected", name);
1390 return (0);
1391 }
1392
1393 for ( ; *npp != NULL; npp = &(*npp)->nv_next) {
1394 if ((*npp)->nv_name != name)
1395 continue;
1396 if (next != NULL && *next == &(*npp)->nv_next)
1397 *next = npp;
1398 nv = (*npp)->nv_next;
1399 CFGDBG(2, "opt `%s' deselected", (*npp)->nv_name);
1400 nvfree(*npp);
1401 *npp = nv;
1402 return (0);
1403 }
1404 panic("%s `%s' is not defined in nvlist", type, name);
1405 return (1);
1406 }
1407
1408 /*
1409 * Return true if there is at least one instance of the given unit
1410 * on the given device attachment (or any units, if unit == WILD).
1411 */
1412 int
deva_has_instances(struct deva * deva,int unit)1413 deva_has_instances(struct deva *deva, int unit)
1414 {
1415 struct devi *i;
1416
1417 /*
1418 * EHAMMERTOOBIG: we shouldn't check i_pseudoroot here.
1419 * What we want by this check is them to appear non-present
1420 * except for purposes of other devices being able to attach
1421 * to them.
1422 */
1423 for (i = deva->d_ihead; i != NULL; i = i->i_asame)
1424 if (i->i_active == DEVI_ACTIVE && i->i_pseudoroot == 0 &&
1425 (unit == WILD || unit == i->i_unit || i->i_unit == STAR))
1426 return (1);
1427 return (0);
1428 }
1429
1430 /*
1431 * Return true if there is at least one instance of the given unit
1432 * on the given base (or any units, if unit == WILD).
1433 */
1434 int
devbase_has_instances(struct devbase * dev,int unit)1435 devbase_has_instances(struct devbase *dev, int unit)
1436 {
1437 struct deva *da;
1438
1439 /*
1440 * Pseudo-devices are a little special. We consider them
1441 * to have instances only if they are both:
1442 *
1443 * 1. Included in this kernel configuration.
1444 *
1445 * 2. Be declared "defpseudodev".
1446 */
1447 if (dev->d_ispseudo) {
1448 return ((ht_lookup(devitab, dev->d_name) != NULL)
1449 && (dev->d_ispseudo > 1));
1450 }
1451
1452 for (da = dev->d_ahead; da != NULL; da = da->d_bsame)
1453 if (deva_has_instances(da, unit))
1454 return (1);
1455 return (0);
1456 }
1457
1458 static int
cfcrosscheck(struct config * cf,const char * what,struct nvlist * nv)1459 cfcrosscheck(struct config *cf, const char *what, struct nvlist *nv)
1460 {
1461 struct devbase *dev;
1462 struct devi *pd;
1463 int errs, devunit;
1464
1465 if (maxpartitions <= 0)
1466 panic("cfcrosscheck");
1467
1468 for (errs = 0; nv != NULL; nv = nv->nv_next) {
1469 if (nv->nv_name == NULL)
1470 continue;
1471 dev = ht_lookup(devbasetab, nv->nv_name);
1472 if (dev == NULL)
1473 panic("cfcrosscheck(%s)", nv->nv_name);
1474 if (has_attr(dev->d_attrs, s_ifnet))
1475 devunit = nv->nv_ifunit; /* XXX XXX XXX */
1476 else
1477 devunit = (int)(minor(nv->nv_num) / maxpartitions);
1478 if (devbase_has_instances(dev, devunit))
1479 continue;
1480 if (devbase_has_instances(dev, STAR) &&
1481 devunit >= dev->d_umax)
1482 continue;
1483 TAILQ_FOREACH(pd, &allpseudo, i_next) {
1484 if (pd->i_base == dev && devunit < dev->d_umax &&
1485 devunit >= 0)
1486 goto loop;
1487 }
1488 (void)fprintf(stderr,
1489 "%s:%hu: %s says %s on %s, but there's no %s\n",
1490 conffile, cf->cf_where.w_srcline,
1491 cf->cf_name, what, nv->nv_str, nv->nv_str);
1492 errs++;
1493 loop:
1494 ;
1495 }
1496 return (errs);
1497 }
1498
1499 /*
1500 * Cross-check the configuration: make sure that each target device
1501 * or attribute (`at foo[0*?]') names at least one real device. Also
1502 * see that the root and dump devices for all configurations are there.
1503 */
1504 int
crosscheck(void)1505 crosscheck(void)
1506 {
1507 struct config *cf;
1508 int errs;
1509
1510 errs = 0;
1511 if (TAILQ_EMPTY(&allcf)) {
1512 warnx("%s has no configurations!", conffile);
1513 errs++;
1514 }
1515 TAILQ_FOREACH(cf, &allcf, cf_next) {
1516 if (cf->cf_root != NULL) { /* i.e., not root on ? */
1517 errs += cfcrosscheck(cf, "root", cf->cf_root);
1518 errs += cfcrosscheck(cf, "dumps", cf->cf_dump);
1519 }
1520 }
1521 return (errs);
1522 }
1523
1524 /*
1525 * Check to see if there is a *'d unit with a needs-count file.
1526 */
1527 int
badstar(void)1528 badstar(void)
1529 {
1530 struct devbase *d;
1531 struct deva *da;
1532 struct devi *i;
1533 int errs, n;
1534
1535 errs = 0;
1536 TAILQ_FOREACH(d, &allbases, d_next) {
1537 for (da = d->d_ahead; da != NULL; da = da->d_bsame)
1538 for (i = da->d_ihead; i != NULL; i = i->i_asame) {
1539 if (i->i_unit == STAR)
1540 goto aybabtu;
1541 }
1542 continue;
1543 aybabtu:
1544 if (ht_lookup(needcnttab, d->d_name)) {
1545 warnx("%s's cannot be *'d until its driver is fixed",
1546 d->d_name);
1547 errs++;
1548 continue;
1549 }
1550 for (n = 0; i != NULL; i = i->i_alias)
1551 if (!i->i_collapsed)
1552 n++;
1553 if (n < 1)
1554 panic("badstar() n<1");
1555 }
1556 return (errs);
1557 }
1558
1559 /*
1560 * Verify/create builddir if necessary, change to it, and verify srcdir.
1561 * This will be called when we see the first include.
1562 */
1563 void
setupdirs(void)1564 setupdirs(void)
1565 {
1566 struct stat st;
1567
1568 /* srcdir must be specified if builddir is not specified or if
1569 * no configuration filename was specified. */
1570 if ((builddir || strcmp(defbuilddir, ".") == 0) && !srcdir) {
1571 cfgerror("source directory must be specified");
1572 exit(1);
1573 }
1574
1575 if (Lflag) {
1576 if (srcdir == NULL)
1577 srcdir = "../../..";
1578 return;
1579 }
1580
1581 if (srcdir == NULL)
1582 srcdir = "../../../..";
1583 if (builddir == NULL)
1584 builddir = defbuilddir;
1585
1586 if (stat(builddir, &st) == -1) {
1587 if (mkdir(builddir, 0777) == -1)
1588 errx(EXIT_FAILURE, "cannot create %s", builddir);
1589 } else if (!S_ISDIR(st.st_mode))
1590 errx(EXIT_FAILURE, "%s is not a directory", builddir);
1591 if (chdir(builddir) == -1)
1592 err(EXIT_FAILURE, "cannot change to %s", builddir);
1593 if (stat(srcdir, &st) == -1)
1594 err(EXIT_FAILURE, "cannot stat %s", srcdir);
1595 if (!S_ISDIR(st.st_mode))
1596 errx(EXIT_FAILURE, "%s is not a directory", srcdir);
1597 }
1598
1599 /*
1600 * Write identifier from "ident" directive into file, for
1601 * newvers.sh to pick it up.
1602 */
1603 int
mkident(void)1604 mkident(void)
1605 {
1606 FILE *fp;
1607 int error = 0;
1608
1609 (void)unlink("ident");
1610
1611 if (ident == NULL)
1612 return (0);
1613
1614 if ((fp = fopen("ident", "w")) == NULL) {
1615 warn("cannot write ident");
1616 return (1);
1617 }
1618 if (vflag)
1619 (void)printf("using ident '%s'\n", ident);
1620 fprintf(fp, "%s\n", ident);
1621 fflush(fp);
1622 if (ferror(fp))
1623 error = 1;
1624 (void)fclose(fp);
1625
1626 return error;
1627 }
1628
1629 void
logconfig_start(void)1630 logconfig_start(void)
1631 {
1632 extern FILE *yyin;
1633 char line[1024];
1634 const char *tmpdir;
1635 struct stat st;
1636 int fd;
1637
1638 if (yyin == NULL || fstat(fileno(yyin), &st) == -1)
1639 return;
1640 cfgtime = st.st_mtime;
1641
1642 tmpdir = getenv("TMPDIR");
1643 if (tmpdir == NULL)
1644 tmpdir = _PATH_TMP;
1645 (void)snprintf(line, sizeof(line), "%s/config.tmp.XXXXXX", tmpdir);
1646 if ((fd = mkstemp(line)) == -1 ||
1647 (cfg = fdopen(fd, "r+")) == NULL) {
1648 if (fd != -1) {
1649 (void)unlink(line);
1650 (void)close(fd);
1651 }
1652 cfg = NULL;
1653 return;
1654 }
1655 (void)unlink(line);
1656
1657 (void)fprintf(cfg, "#include <sys/cdefs.h>\n\n");
1658 (void)fprintf(cfg, "#include \"opt_config.h\"\n");
1659 (void)fprintf(cfg, "\n");
1660 (void)fprintf(cfg, "/*\n");
1661 (void)fprintf(cfg, " * Add either (or both) of\n");
1662 (void)fprintf(cfg, " *\n");
1663 (void)fprintf(cfg, " *\toptions %s\n", LOGCONFIG_LARGE);
1664 (void)fprintf(cfg, " *\toptions %s\n", LOGCONFIG_SMALL);
1665 (void)fprintf(cfg, " *\n");
1666 (void)fprintf(cfg,
1667 " * to your kernel config file to embed it in the resulting\n");
1668 (void)fprintf(cfg,
1669 " * kernel. The latter option does not include files that are\n");
1670 (void)fprintf(cfg,
1671 " * included (recursively) by your config file. The embedded\n");
1672 (void)fprintf(cfg,
1673 " * data be extracted by using the command:\n");
1674 (void)fprintf(cfg, " *\n");
1675 (void)fprintf(cfg,
1676 " *\tstrings netbsd | sed -n 's/^_CFG_//p' | unvis\n");
1677 (void)fprintf(cfg, " */\n");
1678 (void)fprintf(cfg, "\n");
1679 (void)fprintf(cfg, "#ifdef CONFIG_FILE\n");
1680 (void)fprintf(cfg, "#if defined(%s) || defined(%s)\n\n",
1681 LOGCONFIG_LARGE, LOGCONFIG_SMALL);
1682 (void)fprintf(cfg, "static const char config[] __used =\n\n");
1683
1684 (void)fprintf(cfg, "#ifdef %s\n\n", LOGCONFIG_LARGE);
1685 (void)fprintf(cfg, "\"_CFG_### START CONFIG FILE \\\"%s\\\"\\n\"\n\n",
1686 conffile);
1687 (void)fprintf(cfg, "#endif /* %s */\n\n", LOGCONFIG_LARGE);
1688
1689 logconfig_include(yyin, NULL);
1690
1691 (void)fprintf(cfg, "#ifdef %s\n\n", LOGCONFIG_LARGE);
1692 (void)fprintf(cfg, "\"_CFG_### END CONFIG FILE \\\"%s\\\"\\n\"\n",
1693 conffile);
1694
1695 rewind(yyin);
1696 }
1697
1698 void
logconfig_include(FILE * cf,const char * filename)1699 logconfig_include(FILE *cf, const char *filename)
1700 {
1701 char line[1024], in[2048], *out;
1702 struct stat st;
1703 int missingeol;
1704
1705 if (!cfg)
1706 return;
1707
1708 missingeol = 0;
1709 if (fstat(fileno(cf), &st) == -1)
1710 return;
1711 if (cfgtime < st.st_mtime)
1712 cfgtime = st.st_mtime;
1713
1714 if (filename)
1715 (void)fprintf(cfg,
1716 "\"_CFG_### (included from \\\"%s\\\")\\n\"\n",
1717 filename);
1718 while (fgets(line, sizeof(line), cf) != NULL) {
1719 missingeol = 1;
1720 (void)fprintf(cfg, "\"_CFG_");
1721 if (filename)
1722 (void)fprintf(cfg, "###> ");
1723 strvis(in, line, VIS_TAB);
1724 for (out = in; *out; out++)
1725 switch (*out) {
1726 case '\n':
1727 (void)fprintf(cfg, "\\n\"\n");
1728 missingeol = 0;
1729 break;
1730 case '"': case '\\':
1731 (void)fputc('\\', cfg);
1732 /* FALLTHROUGH */
1733 default:
1734 (void)fputc(*out, cfg);
1735 break;
1736 }
1737 }
1738 if (missingeol) {
1739 (void)fprintf(cfg, "\\n\"\n");
1740 warnx("%s: newline missing at EOF",
1741 filename != NULL ? filename : conffile);
1742 }
1743 if (filename)
1744 (void)fprintf(cfg, "\"_CFG_### (end include \\\"%s\\\")\\n\"\n",
1745 filename);
1746
1747 rewind(cf);
1748 }
1749
1750 void
logconfig_end(void)1751 logconfig_end(void)
1752 {
1753 char line[1024];
1754 FILE *fp;
1755 struct stat st;
1756
1757 if (!cfg)
1758 return;
1759
1760 (void)fprintf(cfg, "#endif /* %s */\n", LOGCONFIG_LARGE);
1761 (void)fprintf(cfg, ";\n");
1762 (void)fprintf(cfg, "#endif /* %s || %s */\n",
1763 LOGCONFIG_LARGE, LOGCONFIG_SMALL);
1764 (void)fprintf(cfg, "#endif /* CONFIG_FILE */\n");
1765 fflush(cfg);
1766 if (ferror(cfg))
1767 err(EXIT_FAILURE, "write to temporary file for config.h failed");
1768 rewind(cfg);
1769
1770 if (stat("config_file.h", &st) != -1) {
1771 if (cfgtime < st.st_mtime) {
1772 fclose(cfg);
1773 return;
1774 }
1775 }
1776
1777 fp = fopen("config_file.h", "w");
1778 if (!fp)
1779 err(EXIT_FAILURE, "cannot open \"config.h\"");
1780
1781 while (fgets(line, sizeof(line), cfg) != NULL)
1782 fputs(line, fp);
1783 fflush(fp);
1784 if (ferror(fp))
1785 err(EXIT_FAILURE, "write to \"config.h\" failed");
1786 fclose(fp);
1787 fclose(cfg);
1788 }
1789
1790 const char *
strtolower(const char * name)1791 strtolower(const char *name)
1792 {
1793 const char *n;
1794 char *p, low[500];
1795 char c;
1796
1797 for (n = name, p = low; (c = *n) != '\0'; n++)
1798 *p++ = (char)(isupper((u_char)c) ? tolower((u_char)c) : c);
1799 *p = '\0';
1800 return (intern(low));
1801 }
1802
1803 static int
is_elf(const char * file)1804 is_elf(const char *file)
1805 {
1806 int kernel;
1807 char hdr[4];
1808
1809 kernel = open(file, O_RDONLY);
1810 if (kernel == -1)
1811 err(EXIT_FAILURE, "cannot open %s", file);
1812 if (read(kernel, hdr, 4) != 4)
1813 err(EXIT_FAILURE, "Cannot read from %s", file);
1814 (void)close(kernel);
1815
1816 return memcmp("\177ELF", hdr, 4) == 0 ? 1 : 0;
1817 }
1818
1819 static int
extract_config(const char * kname,const char * cname,int cfd)1820 extract_config(const char *kname, const char *cname, int cfd)
1821 {
1822 char *ptr;
1823 void *base;
1824 int found, kfd;
1825 struct stat st;
1826 off_t i;
1827
1828 found = 0;
1829
1830 /* mmap(2) binary kernel */
1831 kfd = open(conffile, O_RDONLY);
1832 if (kfd == -1)
1833 err(EXIT_FAILURE, "cannot open %s", kname);
1834 if (fstat(kfd, &st) == -1)
1835 err(EXIT_FAILURE, "cannot stat %s", kname);
1836 base = mmap(0, (size_t)st.st_size, PROT_READ, MAP_FILE | MAP_SHARED,
1837 kfd, 0);
1838 if (base == MAP_FAILED)
1839 err(EXIT_FAILURE, "cannot mmap %s", kname);
1840 ptr = base;
1841
1842 /* Scan mmap(2)'ed region, extracting kernel configuration */
1843 for (i = 0; i < st.st_size; i++) {
1844 if ((*ptr == '_') && (st.st_size - i > 5) && memcmp(ptr,
1845 "_CFG_", 5) == 0) {
1846 /* Line found */
1847 char *oldptr, line[LINE_MAX + 1], uline[LINE_MAX + 1];
1848 int j;
1849
1850 found = 1;
1851
1852 oldptr = (ptr += 5);
1853 while (*ptr != '\n' && *ptr != '\0')
1854 ptr++;
1855 if (ptr - oldptr > LINE_MAX)
1856 errx(EXIT_FAILURE, "line too long");
1857 i += ptr - oldptr + 5;
1858 (void)memcpy(line, oldptr, (size_t)(ptr - oldptr));
1859 line[ptr - oldptr] = '\0';
1860 j = strunvis(uline, line);
1861 if (j == -1)
1862 errx(EXIT_FAILURE, "unvis: invalid "
1863 "encoded sequence");
1864 uline[j] = '\n';
1865 if (write(cfd, uline, (size_t)j + 1) == -1)
1866 err(EXIT_FAILURE, "cannot write to %s", cname);
1867 } else
1868 ptr++;
1869 }
1870
1871 (void)close(kfd);
1872 (void)munmap(base, (size_t)st.st_size);
1873
1874 return found;
1875 }
1876
1877 struct dhdi_params {
1878 struct devbase *d;
1879 int unit;
1880 int level;
1881 };
1882
1883 static int
devbase_has_dead_instances(const char * key,void * value,void * aux)1884 devbase_has_dead_instances(const char *key, void *value, void *aux)
1885 {
1886 struct devi *i;
1887 struct dhdi_params *dhdi = aux;
1888
1889 for (i = value; i != NULL; i = i->i_alias)
1890 if (i->i_base == dhdi->d &&
1891 (dhdi->unit == WILD || dhdi->unit == i->i_unit ||
1892 i->i_unit == STAR) &&
1893 i->i_level >= dhdi->level)
1894 return 1;
1895 return 0;
1896 }
1897
1898 /*
1899 * This is almost the same as devbase_has_instances, except it
1900 * may have special considerations regarding ignored instances.
1901 */
1902
1903 static int
devbase_has_any_instance(struct devbase * dev,int unit,int state,int level)1904 devbase_has_any_instance(struct devbase *dev, int unit, int state, int level)
1905 {
1906 struct deva *da;
1907 struct devi *i;
1908
1909 if (dev->d_ispseudo) {
1910 if (dev->d_ihead != NULL)
1911 return 1;
1912 else if (state != DEVI_IGNORED)
1913 return 0;
1914 if ((i = ht_lookup(deaddevitab, dev->d_name)) == NULL)
1915 return 0;
1916 return (i->i_level >= level);
1917 }
1918
1919 for (da = dev->d_ahead; da != NULL; da = da->d_bsame)
1920 for (i = da->d_ihead; i != NULL; i = i->i_asame)
1921 if ((i->i_active == DEVI_ACTIVE ||
1922 i->i_active == state) &&
1923 (unit == WILD || unit == i->i_unit ||
1924 i->i_unit == STAR))
1925 return 1;
1926
1927 if (state == DEVI_IGNORED) {
1928 struct dhdi_params dhdi = { dev, unit, level };
1929 /* also check dead devices */
1930 return ht_enumerate(deaddevitab, devbase_has_dead_instances,
1931 &dhdi);
1932 }
1933
1934 return 0;
1935 }
1936
1937 /*
1938 * check_dead_devi(), used with ht_enumerate, checks if any of the removed
1939 * device instances would have been a valid instance considering the devbase,
1940 * the parent device and the interface attribute.
1941 *
1942 * In other words, for a non-active device, it checks if children would be
1943 * actual orphans or the result of a negative statement in the config file.
1944 */
1945
1946 struct cdd_params {
1947 struct devbase *d;
1948 struct attr *at;
1949 struct devbase *parent;
1950 };
1951
1952 static int
check_dead_devi(const char * key,void * value,void * aux)1953 check_dead_devi(const char *key, void *value, void *aux)
1954 {
1955 struct cdd_params *cdd = aux;
1956 struct devi *i = value;
1957 struct pspec *p;
1958
1959 if (i->i_base != cdd->d)
1960 return 0;
1961
1962 for (; i != NULL; i = i->i_alias) {
1963 p = i->i_pspec;
1964 if ((p == NULL && cdd->at == NULL) ||
1965 (p != NULL && p->p_iattr == cdd->at &&
1966 (p->p_atdev == NULL || p->p_atdev == cdd->parent))) {
1967 if (p != NULL &&
1968 !devbase_has_any_instance(cdd->parent, p->p_atunit,
1969 DEVI_IGNORED, i->i_level))
1970 return 0;
1971 else
1972 return 1;
1973 }
1974 }
1975 return 0;
1976 }
1977
1978 static struct devbase root;
1979
1980 static int
addlevelparent(struct devbase * d,struct devbase * parent)1981 addlevelparent(struct devbase *d, struct devbase *parent)
1982 {
1983 struct devbase *p;
1984
1985 if (d == parent) {
1986 if (d->d_level > 1)
1987 return 0;
1988 return 1;
1989 }
1990
1991 if (d->d_levelparent) {
1992 if (d->d_level > 1)
1993 return 0;
1994 return 1;
1995 }
1996
1997 for (p = parent; p != NULL; p = p->d_levelparent)
1998 if (d == p && d->d_level > 1)
1999 return 0;
2000 d->d_levelparent = p ? p : &root;
2001 d->d_level++;
2002 return 1;
2003 }
2004
2005 static void
do_kill_orphans(struct devbase * d,struct attr * at,struct devbase * parent,int state)2006 do_kill_orphans(struct devbase *d, struct attr *at, struct devbase *parent,
2007 int state)
2008 {
2009 struct nvlist *nv1;
2010 struct attrlist *al;
2011 struct attr *a;
2012 struct devi *i, *j = NULL;
2013 struct pspec *p;
2014 int active = 0;
2015
2016 if (!addlevelparent(d, parent))
2017 return;
2018
2019 /*
2020 * A pseudo-device will always attach at root, and if it has an
2021 * instance (it cannot have more than one), it is enough to consider
2022 * it active, as there is no real attachment.
2023 *
2024 * A pseudo device can never be marked DEVI_IGNORED.
2025 */
2026 if (d->d_ispseudo) {
2027 if (d->d_ihead != NULL)
2028 d->d_ihead->i_active = active = DEVI_ACTIVE;
2029 else {
2030 if (ht_lookup(deaddevitab, d->d_name) != NULL)
2031 active = DEVI_IGNORED;
2032 else
2033 return;
2034 }
2035 } else {
2036 int seen = 0;
2037 int changed = 0;
2038
2039 for (i = d->d_ihead; i != NULL; i = i->i_bsame) {
2040 for (j = i; j != NULL; j = j->i_alias) {
2041 p = j->i_pspec;
2042 if ((p == NULL && at == NULL) ||
2043 (p != NULL && p->p_iattr == at &&
2044 (p->p_atdev == NULL ||
2045 p->p_atdev == parent))) {
2046 if (p != NULL &&
2047 !devbase_has_any_instance(parent,
2048 p->p_atunit, state, j->i_level))
2049 continue;
2050 /*
2051 * There are Fry-like devices which can
2052 * be their own grand-parent (or even
2053 * parent, like uhub). We don't want
2054 * to loop, so if we've already reached
2055 * an instance for one reason or
2056 * another, stop there.
2057 */
2058 if (j->i_active == DEVI_ACTIVE ||
2059 j->i_active == state) {
2060 /*
2061 * Device has already been
2062 * seen. However it might
2063 * have siblings who still
2064 * have to be activated or
2065 * orphaned.
2066 */
2067 seen = 1;
2068 continue;
2069 }
2070 changed |= j->i_active != state;
2071 j->i_active = active = state;
2072 if (p != NULL) {
2073 if (state == DEVI_ACTIVE ||
2074 --p->p_ref == 0)
2075 p->p_active = state;
2076 }
2077 if (state == DEVI_IGNORED) {
2078 CFGDBG(5,
2079 "`%s' at '%s' ignored",
2080 d->d_name, parent ?
2081 parent->d_name : "(root)");
2082 }
2083 }
2084 }
2085 }
2086 /*
2087 * If we've been there but have made no change, stop.
2088 */
2089 if (seen && active != DEVI_ACTIVE)
2090 goto out;
2091 if (active != DEVI_ACTIVE) {
2092 struct cdd_params cdd = { d, at, parent };
2093 /* Look for a matching dead devi */
2094 if (ht_enumerate(deaddevitab, check_dead_devi, &cdd) &&
2095 d != parent) {
2096 /*
2097 * That device had its instances removed.
2098 * Continue the loop marking descendants
2099 * with DEVI_IGNORED instead of DEVI_ACTIVE.
2100 *
2101 * There is one special case for devices that
2102 * are their own parent: if that instance is
2103 * removed (e.g., no uhub* at uhub?), we don't
2104 * have to continue looping.
2105 */
2106 active = DEVI_IGNORED;
2107 CFGDBG(5, "`%s' at '%s' ignored", d->d_name,
2108 parent ? parent->d_name : "(root)");
2109
2110 } else if (!changed)
2111 goto out;
2112 }
2113 }
2114
2115 for (al = d->d_attrs; al != NULL; al = al->al_next) {
2116 a = al->al_this;
2117 for (nv1 = a->a_devs; nv1 != NULL; nv1 = nv1->nv_next) {
2118 do_kill_orphans(nv1->nv_ptr, a, d, active);
2119 }
2120 }
2121 out:
2122 d->d_levelparent = NULL;
2123 d->d_level--;
2124 }
2125
2126 static int
2127 /*ARGSUSED*/
kill_orphans_cb(const char * key,void * value,void * aux)2128 kill_orphans_cb(const char *key, void *value, void *aux)
2129 {
2130 do_kill_orphans((struct devbase *)value, NULL, NULL, DEVI_ACTIVE);
2131 return 0;
2132 }
2133
2134 static void
kill_orphans(void)2135 kill_orphans(void)
2136 {
2137 ht_enumerate(devroottab, kill_orphans_cb, NULL);
2138 }
2139
2140 static void
add_makeopt(const char * opt)2141 add_makeopt(const char *opt)
2142 {
2143 struct nvlist *p;
2144 char *buf = estrdup(opt);
2145 char *eq = strchr(buf, '=');
2146
2147 if (!eq)
2148 errx(EXIT_FAILURE, "-D %s is not in var=value format", opt);
2149
2150 *eq = 0;
2151 p = newnv(estrdup(buf), estrdup(eq+1), NULL, 0, NULL);
2152 free(buf);
2153 p->nv_next = cmdlinedefs;
2154 cmdlinedefs = p;
2155 }
2156
2157 static void
remove_makeopt(const char * opt)2158 remove_makeopt(const char *opt)
2159 {
2160 struct nvlist *p;
2161
2162 p = newnv(estrdup(opt), NULL, NULL, 0, NULL);
2163 p->nv_next = cmdlineundefs;
2164 cmdlineundefs = p;
2165 }
2166
2167 static void
handle_cmdline_makeoptions(void)2168 handle_cmdline_makeoptions(void)
2169 {
2170 struct nvlist *p, *n;
2171
2172 handling_cmdlineopts = 1;
2173 for (p = cmdlineundefs; p; p = n) {
2174 n = p->nv_next;
2175 delmkoption(intern(p->nv_name), 0);
2176 free(__UNCONST(p->nv_name));
2177 nvfree(p);
2178 }
2179 for (p = cmdlinedefs; p; p = n) {
2180 const char *name = intern(p->nv_name);
2181
2182 n = p->nv_next;
2183 delmkoption(name, 0);
2184 addmkoption(name, intern(p->nv_str));
2185 free(__UNCONST(p->nv_name));
2186 free(__UNCONST(p->nv_str));
2187
2188 nvfree(p);
2189 }
2190 handling_cmdlineopts = 0;
2191 }
2192