1*f079f926Schristos /* $NetBSD: sem.c,v 1.84 2020/03/07 19:26:13 christos Exp $ */ 25ecc953bSthorpej 35ecc953bSthorpej /* 45ecc953bSthorpej * Copyright (c) 1992, 1993 55ecc953bSthorpej * The Regents of the University of California. All rights reserved. 65ecc953bSthorpej * 75ecc953bSthorpej * This software was developed by the Computer Systems Engineering group 85ecc953bSthorpej * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and 95ecc953bSthorpej * contributed to Berkeley. 105ecc953bSthorpej * 115ecc953bSthorpej * All advertising materials mentioning features or use of this software 125ecc953bSthorpej * must display the following acknowledgement: 135ecc953bSthorpej * This product includes software developed by the University of 145ecc953bSthorpej * California, Lawrence Berkeley Laboratories. 155ecc953bSthorpej * 165ecc953bSthorpej * Redistribution and use in source and binary forms, with or without 175ecc953bSthorpej * modification, are permitted provided that the following conditions 185ecc953bSthorpej * are met: 195ecc953bSthorpej * 1. Redistributions of source code must retain the above copyright 205ecc953bSthorpej * notice, this list of conditions and the following disclaimer. 215ecc953bSthorpej * 2. Redistributions in binary form must reproduce the above copyright 225ecc953bSthorpej * notice, this list of conditions and the following disclaimer in the 235ecc953bSthorpej * documentation and/or other materials provided with the distribution. 245ecc953bSthorpej * 3. Neither the name of the University nor the names of its contributors 255ecc953bSthorpej * may be used to endorse or promote products derived from this software 265ecc953bSthorpej * without specific prior written permission. 275ecc953bSthorpej * 285ecc953bSthorpej * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 295ecc953bSthorpej * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 305ecc953bSthorpej * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 315ecc953bSthorpej * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 325ecc953bSthorpej * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 335ecc953bSthorpej * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 345ecc953bSthorpej * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 355ecc953bSthorpej * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 365ecc953bSthorpej * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 375ecc953bSthorpej * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 385ecc953bSthorpej * SUCH DAMAGE. 395ecc953bSthorpej * 405ecc953bSthorpej * from: @(#)sem.c 8.1 (Berkeley) 6/6/93 415ecc953bSthorpej */ 425ecc953bSthorpej 435ecc953bSthorpej #if HAVE_NBTOOL_CONFIG_H 445ecc953bSthorpej #include "nbtool_config.h" 455ecc953bSthorpej #endif 465ecc953bSthorpej 479a7f4bbaSchristos #include <sys/cdefs.h> 48*f079f926Schristos __RCSID("$NetBSD: sem.c,v 1.84 2020/03/07 19:26:13 christos Exp $"); 499a7f4bbaSchristos 505ecc953bSthorpej #include <sys/param.h> 515ecc953bSthorpej #include <ctype.h> 525ecc953bSthorpej #include <stdio.h> 535ecc953bSthorpej #include <stdlib.h> 545ecc953bSthorpej #include <string.h> 55d0fb8901Schristos #include <util.h> 565ecc953bSthorpej #include "defs.h" 575ecc953bSthorpej #include "sem.h" 585ecc953bSthorpej 595ecc953bSthorpej /* 605ecc953bSthorpej * config semantics. 615ecc953bSthorpej */ 625ecc953bSthorpej 635ecc953bSthorpej #define NAMESIZE 100 /* local name buffers */ 645ecc953bSthorpej 655ecc953bSthorpej const char *s_ifnet; /* magic attribute */ 665ecc953bSthorpej const char *s_qmark; 675ecc953bSthorpej const char *s_none; 685ecc953bSthorpej 695ecc953bSthorpej static struct hashtab *cfhashtab; /* for config lookup */ 705ecc953bSthorpej struct hashtab *devitab; /* etc */ 717c7d91e6Suebayasi struct attr allattr; 72374a3e4fSchristos size_t nattrs; 735ecc953bSthorpej 745ecc953bSthorpej static struct attr errattr; 755ecc953bSthorpej static struct devbase errdev; 765ecc953bSthorpej static struct deva errdeva; 775ecc953bSthorpej 784caf067bSdholland static int has_errobj(struct attrlist *, struct attr *); 795ecc953bSthorpej static struct nvlist *addtoattr(struct nvlist *, struct devbase *); 805ecc953bSthorpej static int resolve(struct nvlist **, const char *, const char *, 815ecc953bSthorpej struct nvlist *, int); 824b9e5cb1Schristos static struct pspec *getpspec(struct attr *, struct devbase *, int, int); 835ecc953bSthorpej static struct devi *newdevi(const char *, int, struct devbase *d); 845ecc953bSthorpej static struct devi *getdevi(const char *); 85c130d400Scube static void remove_devi(struct devi *); 865ecc953bSthorpej static const char *concat(const char *, int); 875ecc953bSthorpej static char *extend(char *, const char *); 885ecc953bSthorpej static int split(const char *, size_t, char *, size_t, int *); 895ecc953bSthorpej static void selectbase(struct devbase *, struct deva *); 9016a8771bSdholland static const char **fixloc(const char *, struct attr *, struct loclist *); 91d767912bSdrochner static const char *makedevstr(devmajor_t, devminor_t); 92d767912bSdrochner static const char *major2name(devmajor_t); 93d767912bSdrochner static devmajor_t dev2major(struct devbase *); 945ecc953bSthorpej 955ecc953bSthorpej extern const char *yyfile; 967aa6070dScube extern int vflag; 975ecc953bSthorpej 9811a68adeSchristos #define V_ATTRIBUTE 0 9911a68adeSchristos #define V_DEVICE 1 10011a68adeSchristos struct vtype { 10111a68adeSchristos int type; 10211a68adeSchristos struct attr *attr; 10311a68adeSchristos void *value; 10411a68adeSchristos }; 10511a68adeSchristos 10611a68adeSchristos static struct nvlist * 10711a68adeSchristos makedevstack(struct devbase *d) 10811a68adeSchristos { 10911a68adeSchristos struct devi *firsti, *i; 11011a68adeSchristos struct nvlist *stack = NULL; 11111a68adeSchristos 11211a68adeSchristos for (firsti = d->d_ihead; firsti != NULL; firsti = firsti->i_bsame) 11311a68adeSchristos for (i = firsti; i != NULL; i = i->i_alias) 11411a68adeSchristos stack = newnv(NULL, NULL, i, 0, stack); 11511a68adeSchristos return stack; 11611a68adeSchristos } 11711a68adeSchristos 11811a68adeSchristos static void 11911a68adeSchristos devcleanup(struct nvlist *stack) 12011a68adeSchristos { 12111a68adeSchristos struct nvlist *nv; 12211a68adeSchristos for (nv = stack; nv != NULL; nv = nv->nv_next) 12311a68adeSchristos remove_devi(nv->nv_ptr); 12411a68adeSchristos nvfreel(stack); 12511a68adeSchristos } 12611a68adeSchristos 12711a68adeSchristos static void * 12811a68adeSchristos addvalue(int type, struct attr *a, void *value) 12911a68adeSchristos { 13011a68adeSchristos struct vtype *vt = emalloc(sizeof(*vt)); 13111a68adeSchristos vt->type = type; 13211a68adeSchristos vt->attr = a; 13311a68adeSchristos vt->value = value; 13411a68adeSchristos return vt; 13511a68adeSchristos } 13611a68adeSchristos 1375ecc953bSthorpej void 1385ecc953bSthorpej initsem(void) 1395ecc953bSthorpej { 1405ecc953bSthorpej 1415ecc953bSthorpej attrtab = ht_new(); 1426d1bba4aSuebayasi attrdeptab = ht_new(); 1437c7d91e6Suebayasi 1447c7d91e6Suebayasi allattr.a_name = "netbsd"; 1457c7d91e6Suebayasi TAILQ_INIT(&allattr.a_files); 1467c7d91e6Suebayasi (void)ht_insert(attrtab, allattr.a_name, &allattr); 147cd06fea3Suebayasi selectattr(&allattr); 1487c7d91e6Suebayasi 1495ecc953bSthorpej errattr.a_name = "<internal>"; 1505ecc953bSthorpej 1515ecc953bSthorpej TAILQ_INIT(&allbases); 1525ecc953bSthorpej 1535ecc953bSthorpej TAILQ_INIT(&alldevas); 1545ecc953bSthorpej 1555ecc953bSthorpej TAILQ_INIT(&allpspecs); 1565ecc953bSthorpej 1575ecc953bSthorpej cfhashtab = ht_new(); 1585ecc953bSthorpej TAILQ_INIT(&allcf); 1595ecc953bSthorpej 1605ecc953bSthorpej TAILQ_INIT(&alldevi); 1615ecc953bSthorpej errdev.d_name = "<internal>"; 1625ecc953bSthorpej 1635ecc953bSthorpej TAILQ_INIT(&allpseudo); 1645ecc953bSthorpej 1655ecc953bSthorpej TAILQ_INIT(&alldevms); 1665ecc953bSthorpej 1675ecc953bSthorpej s_ifnet = intern("ifnet"); 1685ecc953bSthorpej s_qmark = intern("?"); 1695ecc953bSthorpej s_none = intern("none"); 1705ecc953bSthorpej } 1715ecc953bSthorpej 1725ecc953bSthorpej /* Name of include file just ended (set in scan.l) */ 1735ecc953bSthorpej extern const char *lastfile; 1745ecc953bSthorpej 175a87832feSuebayasi static struct attr * 176da706167Suebayasi finddep(struct attr *a, const char *name) 177da706167Suebayasi { 178da706167Suebayasi struct attrlist *al; 179da706167Suebayasi 180da706167Suebayasi for (al = a->a_deps; al != NULL; al = al->al_next) { 181da706167Suebayasi struct attr *this = al->al_this; 182da706167Suebayasi if (strcmp(this->a_name, name) == 0) 183da706167Suebayasi return this; 184da706167Suebayasi } 185da706167Suebayasi return NULL; 186da706167Suebayasi } 187da706167Suebayasi 188da706167Suebayasi static void 189c80681c9Suebayasi mergedeps(const char *dname, const char *name) 190da706167Suebayasi { 191da706167Suebayasi struct attr *a, *newa; 192da706167Suebayasi 193c80681c9Suebayasi CFGDBG(4, "merging attr `%s' to devbase `%s'", name, dname); 194c80681c9Suebayasi a = refattr(dname); 195da706167Suebayasi if (finddep(a, name) == NULL) { 196da706167Suebayasi newa = refattr(name); 197da706167Suebayasi a->a_deps = attrlist_cons(a->a_deps, newa); 198da706167Suebayasi CFGDBG(3, "attr `%s' merged to attr `%s'", newa->a_name, 199da706167Suebayasi a->a_name); 200da706167Suebayasi } 201da706167Suebayasi } 202da706167Suebayasi 203da706167Suebayasi static void 204da706167Suebayasi fixdev(struct devbase *dev) 205da706167Suebayasi { 206da706167Suebayasi struct attrlist *al; 207da706167Suebayasi struct attr *devattr, *a; 208da706167Suebayasi 209da706167Suebayasi devattr = refattr(dev->d_name); 210da706167Suebayasi if (devattr->a_devclass) 211a87832feSuebayasi panic("%s: dev %s is devclass!", __func__, devattr->a_name); 212da706167Suebayasi 213c4bac1d0Suebayasi CFGDBG(4, "fixing devbase `%s'", dev->d_name); 214da706167Suebayasi for (al = dev->d_attrs; al != NULL; al = al->al_next) { 215da706167Suebayasi a = al->al_this; 216d25ad65eSchristos CFGDBG(4, "fixing devbase `%s' attr `%s'", dev->d_name, 217d25ad65eSchristos a->a_name); 218da706167Suebayasi if (a->a_iattr) { 219da706167Suebayasi a->a_refs = addtoattr(a->a_refs, dev); 220c4bac1d0Suebayasi CFGDBG(3, "device `%s' has iattr `%s'", dev->d_name, 221c4bac1d0Suebayasi a->a_name); 222da706167Suebayasi } else if (a->a_devclass != NULL) { 223c5a6c986Suebayasi if (dev->d_classattr != NULL && dev->d_classattr != a) { 224da706167Suebayasi cfgwarn("device `%s' has multiple classes " 225da706167Suebayasi "(`%s' and `%s')", 226da706167Suebayasi dev->d_name, dev->d_classattr->a_name, 227da706167Suebayasi a->a_name); 228da706167Suebayasi } 229c5a6c986Suebayasi if (dev->d_classattr == NULL) { 230da706167Suebayasi dev->d_classattr = a; 231d25ad65eSchristos CFGDBG(3, "device `%s' is devclass `%s'", 232d25ad65eSchristos dev->d_name, a->a_name); 233c5a6c986Suebayasi } 234da706167Suebayasi } else { 235da706167Suebayasi if (strcmp(dev->d_name, a->a_name) != 0) { 236bc707469Suebayasi mergedeps(dev->d_name, a->a_name); 237da706167Suebayasi } 238da706167Suebayasi } 239da706167Suebayasi } 240da706167Suebayasi } 241da706167Suebayasi 2425ecc953bSthorpej void 2435ecc953bSthorpej enddefs(void) 2445ecc953bSthorpej { 2455ecc953bSthorpej struct devbase *dev; 2465ecc953bSthorpej 247c4bac1d0Suebayasi yyfile = "enddefs"; 248c4bac1d0Suebayasi 2495ecc953bSthorpej TAILQ_FOREACH(dev, &allbases, d_next) { 2505ecc953bSthorpej if (!dev->d_isdef) { 2515ecc953bSthorpej (void)fprintf(stderr, 2525ecc953bSthorpej "%s: device `%s' used but not defined\n", 2535ecc953bSthorpej lastfile, dev->d_name); 2545ecc953bSthorpej errors++; 2555ecc953bSthorpej continue; 2565ecc953bSthorpej } 257bc707469Suebayasi fixdev(dev); 2585ecc953bSthorpej } 2595ecc953bSthorpej if (errors) { 2605ecc953bSthorpej (void)fprintf(stderr, "*** Stop.\n"); 2615ecc953bSthorpej exit(1); 2625ecc953bSthorpej } 2635ecc953bSthorpej } 2645ecc953bSthorpej 2655ecc953bSthorpej void 2665ecc953bSthorpej setdefmaxusers(int min, int def, int max) 2675ecc953bSthorpej { 2685ecc953bSthorpej 2695ecc953bSthorpej if (min < 1 || min > def || def > max) 270c7295a4cSchristos cfgerror("maxusers must have 1 <= min (%d) <= default (%d) " 271c7295a4cSchristos "<= max (%d)", min, def, max); 2725ecc953bSthorpej else { 2735ecc953bSthorpej minmaxusers = min; 2745ecc953bSthorpej defmaxusers = def; 2755ecc953bSthorpej maxmaxusers = max; 2765ecc953bSthorpej } 2775ecc953bSthorpej } 2785ecc953bSthorpej 279*f079f926Schristos static const char *maxusers_srcfile; 280*f079f926Schristos static u_short maxusers_srcline; 281*f079f926Schristos 2825ecc953bSthorpej void 2835ecc953bSthorpej setmaxusers(int n) 2845ecc953bSthorpej { 2855ecc953bSthorpej 286895e5687Scube if (maxusers == n) { 287*f079f926Schristos cfgerror("duplicate maxusers parameter at %s:%hu", 288*f079f926Schristos maxusers_srcfile, maxusers_srcline); 2895ecc953bSthorpej return; 2905ecc953bSthorpej } 291895e5687Scube if (vflag && maxusers != 0) 292*f079f926Schristos cfgwarn("warning: maxusers already defined at %s:%hu", 293*f079f926Schristos maxusers_srcfile, maxusers_srcline); 2945ecc953bSthorpej maxusers = n; 295*f079f926Schristos maxusers_srcfile = yyfile; 296*f079f926Schristos maxusers_srcline = currentline(); 2975ecc953bSthorpej if (n < minmaxusers) { 298c7295a4cSchristos cfgerror("warning: minimum of %d maxusers assumed", 299c7295a4cSchristos minmaxusers); 3005ecc953bSthorpej errors--; /* take it away */ 3015ecc953bSthorpej maxusers = minmaxusers; 3025ecc953bSthorpej } else if (n > maxmaxusers) { 303c7295a4cSchristos cfgerror("warning: maxusers (%d) > %d", n, maxmaxusers); 3045ecc953bSthorpej errors--; 3055ecc953bSthorpej } 3065ecc953bSthorpej } 3075ecc953bSthorpej 3085ecc953bSthorpej void 3095ecc953bSthorpej setident(const char *i) 3105ecc953bSthorpej { 3115ecc953bSthorpej 3124a7be1f9Smrg if (i) 3135ecc953bSthorpej ident = intern(i); 3144a7be1f9Smrg else 3154a7be1f9Smrg ident = NULL; 3165ecc953bSthorpej } 3175ecc953bSthorpej 3185ecc953bSthorpej /* 3195ecc953bSthorpej * Define an attribute, optionally with an interface (a locator list) 3205ecc953bSthorpej * and a set of attribute-dependencies. 3215ecc953bSthorpej * 3225ecc953bSthorpej * Attribute dependencies MAY NOT be interface attributes. 3235ecc953bSthorpej * 3245ecc953bSthorpej * Since an empty locator list is logically different from "no interface", 3255ecc953bSthorpej * all locator lists include a dummy head node, which we discard here. 3265ecc953bSthorpej */ 3275ecc953bSthorpej int 328bb4307a6Suebayasi defattr0(const char *name, struct loclist *locs, struct attrlist *deps, 329bb4307a6Suebayasi int devclass) 330bb4307a6Suebayasi { 331bb4307a6Suebayasi 332bb4307a6Suebayasi if (locs != NULL) 333bb4307a6Suebayasi return defiattr(name, locs, deps, devclass); 334bb4307a6Suebayasi else if (devclass) 335bb4307a6Suebayasi return defdevclass(name, locs, deps, devclass); 336bb4307a6Suebayasi else 337bb4307a6Suebayasi return defattr(name, locs, deps, devclass); 338bb4307a6Suebayasi } 339bb4307a6Suebayasi 340bb4307a6Suebayasi int 34116a8771bSdholland defattr(const char *name, struct loclist *locs, struct attrlist *deps, 3425ecc953bSthorpej int devclass) 3435ecc953bSthorpej { 3445ecc953bSthorpej struct attr *a, *dep; 3454caf067bSdholland struct attrlist *al; 3465ecc953bSthorpej 3478955e3e2Schristos if (getrefattr(name, &a)) { 348*f079f926Schristos cfgerror("attribute `%s' already defined at %s:%hu", name, 349*f079f926Schristos a->a_where.w_srcfile, a->a_where.w_srcline); 3508955e3e2Schristos loclist_destroy(locs); 3518955e3e2Schristos return (1); 3528955e3e2Schristos } 3538955e3e2Schristos if (a == NULL) 3548955e3e2Schristos a = mkattr(name); 3558955e3e2Schristos 3565ecc953bSthorpej /* 3575ecc953bSthorpej * If this attribute depends on any others, make sure none of 3585ecc953bSthorpej * the dependencies are interface attributes. 3595ecc953bSthorpej */ 3604caf067bSdholland for (al = deps; al != NULL; al = al->al_next) { 3614caf067bSdholland dep = al->al_this; 3625ecc953bSthorpej if (dep->a_iattr) { 363c7295a4cSchristos cfgerror("`%s' dependency `%s' is an interface " 364c7295a4cSchristos "attribute", name, dep->a_name); 3655ecc953bSthorpej return (1); 3665ecc953bSthorpej } 36711a68adeSchristos (void)ht_insert2(attrdeptab, name, dep->a_name, 36811a68adeSchristos addvalue(V_ATTRIBUTE, a, dep)); 369bc707469Suebayasi CFGDBG(2, "attr `%s' depends on attr `%s'", name, dep->a_name); 3705ecc953bSthorpej } 3715ecc953bSthorpej 3725ecc953bSthorpej 373a949e288Suebayasi a->a_deps = deps; 374bb4307a6Suebayasi expandattr(a, NULL); 3752f2f3382Suebayasi CFGDBG(3, "attr `%s' defined", a->a_name); 376bb4307a6Suebayasi 377bb4307a6Suebayasi return (0); 378bb4307a6Suebayasi } 379a949e288Suebayasi 3802f2f3382Suebayasi struct attr * 3812f2f3382Suebayasi mkattr(const char *name) 3822f2f3382Suebayasi { 3832f2f3382Suebayasi struct attr *a; 3842f2f3382Suebayasi 3852f2f3382Suebayasi a = ecalloc(1, sizeof *a); 3862f2f3382Suebayasi if (ht_insert(attrtab, name, a)) { 3872f2f3382Suebayasi free(a); 3882f2f3382Suebayasi return NULL; 3892f2f3382Suebayasi } 3902f2f3382Suebayasi a->a_name = name; 391*f079f926Schristos a->a_where.w_srcfile = yyfile; 392*f079f926Schristos a->a_where.w_srcline = currentline(); 3932f2f3382Suebayasi TAILQ_INIT(&a->a_files); 3942f2f3382Suebayasi CFGDBG(3, "attr `%s' allocated", name); 3952f2f3382Suebayasi 3962f2f3382Suebayasi return a; 3972f2f3382Suebayasi } 3982f2f3382Suebayasi 399a949e288Suebayasi /* "interface attribute" initialization */ 400bb4307a6Suebayasi int 401bb4307a6Suebayasi defiattr(const char *name, struct loclist *locs, struct attrlist *deps, 402bb4307a6Suebayasi int devclass) 403bb4307a6Suebayasi { 404bb4307a6Suebayasi struct attr *a; 405bb4307a6Suebayasi int len; 406bb4307a6Suebayasi struct loclist *ll; 407bb4307a6Suebayasi 408bb4307a6Suebayasi if (devclass) 409d25ad65eSchristos panic("%s: %s has both locators and devclass", __func__, name); 410bb4307a6Suebayasi 411bb4307a6Suebayasi if (defattr(name, locs, deps, devclass) != 0) 412bb4307a6Suebayasi return (1); 413bb4307a6Suebayasi 414bb4307a6Suebayasi a = getattr(name); 4155ecc953bSthorpej a->a_iattr = 1; 41616a8771bSdholland /* unwrap */ 41716a8771bSdholland a->a_locs = locs->ll_next; 41816a8771bSdholland locs->ll_next = NULL; 41916a8771bSdholland loclist_destroy(locs); 420a949e288Suebayasi len = 0; 421a949e288Suebayasi for (ll = a->a_locs; ll != NULL; ll = ll->ll_next) 422a949e288Suebayasi len++; 423a949e288Suebayasi a->a_loclen = len; 424bb4307a6Suebayasi if (deps) 425bb4307a6Suebayasi CFGDBG(2, "attr `%s' iface with deps", a->a_name); 426bb4307a6Suebayasi return (0); 4275ecc953bSthorpej } 428a949e288Suebayasi 429a949e288Suebayasi /* "device class" initialization */ 430bb4307a6Suebayasi int 431bb4307a6Suebayasi defdevclass(const char *name, struct loclist *locs, struct attrlist *deps, 432bb4307a6Suebayasi int devclass) 433bb4307a6Suebayasi { 434bb4307a6Suebayasi struct attr *a; 435bbfbbde1Schristos char classenum[256], *cp; 4365ecc953bSthorpej int errored = 0; 4375ecc953bSthorpej 438bb4307a6Suebayasi if (deps) 439d25ad65eSchristos panic("%s: %s has both dependencies and devclass", __func__, 440d25ad65eSchristos name); 441bb4307a6Suebayasi 442bb4307a6Suebayasi if (defattr(name, locs, deps, devclass) != 0) 443bb4307a6Suebayasi return (1); 444bb4307a6Suebayasi 445bb4307a6Suebayasi a = getattr(name); 446bbfbbde1Schristos (void)snprintf(classenum, sizeof(classenum), "DV_%s", name); 4475ecc953bSthorpej for (cp = classenum + 3; *cp; cp++) { 448d25ad65eSchristos if (!errored && (!isalnum((unsigned char)*cp) || 449d25ad65eSchristos (isalpha((unsigned char)*cp) 450d25ad65eSchristos && !islower((unsigned char)*cp)))) { 451c7295a4cSchristos cfgerror("device class names must be " 452c7295a4cSchristos "lower-case alphanumeric characters"); 4535ecc953bSthorpej errored = 1; 4545ecc953bSthorpej } 45564a07b54Sjoerg *cp = (char)toupper((unsigned char)*cp); 4565ecc953bSthorpej } 4575ecc953bSthorpej a->a_devclass = intern(classenum); 4585ecc953bSthorpej 4595ecc953bSthorpej return (0); 4605ecc953bSthorpej } 4615ecc953bSthorpej 4625ecc953bSthorpej /* 4635ecc953bSthorpej * Return true if the given `error object' is embedded in the given 4645ecc953bSthorpej * pointer list. 4655ecc953bSthorpej */ 4665ecc953bSthorpej static int 4674caf067bSdholland has_errobj(struct attrlist *al, struct attr *obj) 4685ecc953bSthorpej { 4695ecc953bSthorpej 4704caf067bSdholland for (; al != NULL; al = al->al_next) 4714caf067bSdholland if (al->al_this == obj) 4725ecc953bSthorpej return (1); 4735ecc953bSthorpej return (0); 4745ecc953bSthorpej } 4755ecc953bSthorpej 4765ecc953bSthorpej /* 4775ecc953bSthorpej * Return true if the given attribute is embedded in the given 4785ecc953bSthorpej * pointer list. 4795ecc953bSthorpej */ 4805ecc953bSthorpej int 4814caf067bSdholland has_attr(struct attrlist *al, const char *attr) 4825ecc953bSthorpej { 4835ecc953bSthorpej struct attr *a; 4845ecc953bSthorpej 4855ecc953bSthorpej if ((a = getattr(attr)) == NULL) 4865ecc953bSthorpej return (0); 4875ecc953bSthorpej 4884caf067bSdholland for (; al != NULL; al = al->al_next) 4894caf067bSdholland if (al->al_this == a) 4905ecc953bSthorpej return (1); 4915ecc953bSthorpej return (0); 4925ecc953bSthorpej } 4935ecc953bSthorpej 4945ecc953bSthorpej /* 4955ecc953bSthorpej * Add a device base to a list in an attribute (actually, to any list). 4965ecc953bSthorpej * Note that this does not check for duplicates, and does reverse the 4975ecc953bSthorpej * list order, but no one cares anyway. 4985ecc953bSthorpej */ 4995ecc953bSthorpej static struct nvlist * 5005ecc953bSthorpej addtoattr(struct nvlist *l, struct devbase *dev) 5015ecc953bSthorpej { 5025ecc953bSthorpej struct nvlist *n; 5035ecc953bSthorpej 5045ecc953bSthorpej n = newnv(NULL, NULL, dev, 0, l); 5055ecc953bSthorpej return (n); 5065ecc953bSthorpej } 5075ecc953bSthorpej 5085ecc953bSthorpej /* 5095ecc953bSthorpej * Define a device. This may (or may not) also define an interface 5105ecc953bSthorpej * attribute and/or refer to existing attributes. 5115ecc953bSthorpej */ 5125ecc953bSthorpej void 51316a8771bSdholland defdev(struct devbase *dev, struct loclist *loclist, struct attrlist *attrs, 5145ecc953bSthorpej int ispseudo) 5155ecc953bSthorpej { 51616a8771bSdholland struct loclist *ll; 5174caf067bSdholland struct attrlist *al; 5185ecc953bSthorpej 5195ecc953bSthorpej if (dev == &errdev) 5205ecc953bSthorpej goto bad; 5215ecc953bSthorpej if (dev->d_isdef) { 52209274d9eSchristos cfgerror("redefinition of `%s' (previously defined at %s:%d)", 523*f079f926Schristos dev->d_name, dev->d_where.w_srcfile, dev->d_where.w_srcline); 5245ecc953bSthorpej goto bad; 5255ecc953bSthorpej } 5265ecc953bSthorpej 5275ecc953bSthorpej dev->d_isdef = 1; 5285ecc953bSthorpej if (has_errobj(attrs, &errattr)) 5295ecc953bSthorpej goto bad; 5305ecc953bSthorpej 5315ecc953bSthorpej /* 5325ecc953bSthorpej * Handle implicit attribute definition from locator list. Do 5335ecc953bSthorpej * this before scanning the `at' list so that we can have, e.g.: 5345ecc953bSthorpej * device foo at other, foo { slot = -1 } 5355ecc953bSthorpej * (where you can plug in a foo-bus extender to a foo-bus). 5365ecc953bSthorpej */ 5375ecc953bSthorpej if (loclist != NULL) { 53816a8771bSdholland ll = loclist; 5395ecc953bSthorpej loclist = NULL; /* defattr disposes of them for us */ 540bb4307a6Suebayasi if (defiattr(dev->d_name, ll, NULL, 0)) 5415ecc953bSthorpej goto bad; 5424caf067bSdholland attrs = attrlist_cons(attrs, getattr(dev->d_name)); 5434caf067bSdholland /* This used to be stored but was never used */ 5444caf067bSdholland /* attrs->al_name = dev->d_name; */ 545c454f920Scube } 546c454f920Scube 547c130d400Scube /* 548c130d400Scube * Pseudo-devices can have children. Consider them as 549c130d400Scube * attaching at root. 550c130d400Scube */ 551c454f920Scube if (ispseudo) { 5524caf067bSdholland for (al = attrs; al != NULL; al = al->al_next) 5534caf067bSdholland if (al->al_this->a_iattr) 554c454f920Scube break; 5554caf067bSdholland if (al != NULL) { 556b66156c7Sdrochner if (ispseudo < 2) { 557b66156c7Sdrochner if (version >= 20080610) 558b66156c7Sdrochner cfgerror("interface attribute on " 559b66156c7Sdrochner "non-device pseudo `%s'", dev->d_name); 560b66156c7Sdrochner else { 561b66156c7Sdrochner ispseudo = 2; 562b66156c7Sdrochner } 563b66156c7Sdrochner } 564c130d400Scube ht_insert(devroottab, dev->d_name, dev); 5655ecc953bSthorpej } 566b66156c7Sdrochner } 5675ecc953bSthorpej 5685ecc953bSthorpej /* Committed! Set up fields. */ 5695ecc953bSthorpej dev->d_ispseudo = ispseudo; 5705ecc953bSthorpej dev->d_attrs = attrs; 5715ecc953bSthorpej dev->d_classattr = NULL; /* for now */ 572da706167Suebayasi CFGDBG(3, "dev `%s' defined", dev->d_name); 5735ecc953bSthorpej 5745ecc953bSthorpej /* 575a2dd9676Suebayasi * Implicit attribute definition for device. 576a2dd9676Suebayasi */ 57701b2a130Smartin refattr(dev->d_name); 578a2dd9676Suebayasi 579a2dd9676Suebayasi /* 5805ecc953bSthorpej * For each interface attribute this device refers to, add this 5815ecc953bSthorpej * device to its reference list. This makes, e.g., finding all 5825ecc953bSthorpej * "scsi"s easier. 5835ecc953bSthorpej * 5845ecc953bSthorpej * While looking through the attributes, set up the device 5855ecc953bSthorpej * class if any are devclass attributes (and error out if the 5865ecc953bSthorpej * device has two classes). 5875ecc953bSthorpej */ 5884caf067bSdholland for (al = attrs; al != NULL; al = al->al_next) { 589da706167Suebayasi /* 590da706167Suebayasi * Implicit attribute definition for device dependencies. 591da706167Suebayasi */ 592bc707469Suebayasi refattr(al->al_this->a_name); 59311a68adeSchristos (void)ht_insert2(attrdeptab, dev->d_name, al->al_this->a_name, 59411a68adeSchristos addvalue(V_DEVICE, al->al_this, dev)); 595bc707469Suebayasi CFGDBG(2, "device `%s' depends on attr `%s'", dev->d_name, 596bc707469Suebayasi al->al_this->a_name); 5975ecc953bSthorpej } 5985ecc953bSthorpej return; 5995ecc953bSthorpej bad: 60016a8771bSdholland loclist_destroy(loclist); 6014caf067bSdholland attrlist_destroyall(attrs); 6025ecc953bSthorpej } 6035ecc953bSthorpej 6045ecc953bSthorpej /* 6055ecc953bSthorpej * Look up a devbase. Also makes sure it is a reasonable name, 6065ecc953bSthorpej * i.e., does not end in a digit or contain special characters. 6075ecc953bSthorpej */ 6085ecc953bSthorpej struct devbase * 6095ecc953bSthorpej getdevbase(const char *name) 6105ecc953bSthorpej { 611c7295a4cSchristos const u_char *p; 6125ecc953bSthorpej struct devbase *dev; 6135ecc953bSthorpej 614c7295a4cSchristos p = (const u_char *)name; 6155ecc953bSthorpej if (!isalpha(*p)) 6165ecc953bSthorpej goto badname; 6175ecc953bSthorpej while (*++p) { 6185ecc953bSthorpej if (!isalnum(*p) && *p != '_') 6195ecc953bSthorpej goto badname; 6205ecc953bSthorpej } 6215ecc953bSthorpej if (isdigit(*--p)) { 6225ecc953bSthorpej badname: 623c7295a4cSchristos cfgerror("bad device base name `%s'", name); 6245ecc953bSthorpej return (&errdev); 6255ecc953bSthorpej } 6265ecc953bSthorpej dev = ht_lookup(devbasetab, name); 6275ecc953bSthorpej if (dev == NULL) { 6285ecc953bSthorpej dev = ecalloc(1, sizeof *dev); 6295ecc953bSthorpej dev->d_name = name; 6305ecc953bSthorpej dev->d_isdef = 0; 631d767912bSdrochner dev->d_major = NODEVMAJOR; 6325ecc953bSthorpej dev->d_attrs = NULL; 6335ecc953bSthorpej dev->d_ihead = NULL; 6345ecc953bSthorpej dev->d_ipp = &dev->d_ihead; 6355ecc953bSthorpej dev->d_ahead = NULL; 6365ecc953bSthorpej dev->d_app = &dev->d_ahead; 6375ecc953bSthorpej dev->d_umax = 0; 638*f079f926Schristos dev->d_where.w_srcfile = yyfile; 639*f079f926Schristos dev->d_where.w_srcline = currentline(); 6405ecc953bSthorpej TAILQ_INSERT_TAIL(&allbases, dev, d_next); 6415ecc953bSthorpej if (ht_insert(devbasetab, name, dev)) 642d25ad65eSchristos panic("%s: Can't insert %s", __func__, name); 643da706167Suebayasi CFGDBG(3, "devbase defined `%s'", dev->d_name); 6445ecc953bSthorpej } 6455ecc953bSthorpej return (dev); 6465ecc953bSthorpej } 6475ecc953bSthorpej 6485ecc953bSthorpej /* 6495ecc953bSthorpej * Define some of a device's allowable parent attachments. 6505ecc953bSthorpej * There may be a list of (plain) attributes. 6515ecc953bSthorpej */ 6525ecc953bSthorpej void 6535ecc953bSthorpej defdevattach(struct deva *deva, struct devbase *dev, struct nvlist *atlist, 6544caf067bSdholland struct attrlist *attrs) 6555ecc953bSthorpej { 6565ecc953bSthorpej struct nvlist *nv; 6574caf067bSdholland struct attrlist *al; 6585ecc953bSthorpej struct attr *a; 6595ecc953bSthorpej 6605ecc953bSthorpej if (dev == &errdev) 6615ecc953bSthorpej goto bad; 6625ecc953bSthorpej if (deva == NULL) 6635ecc953bSthorpej deva = getdevattach(dev->d_name); 6645ecc953bSthorpej if (deva == &errdeva) 6655ecc953bSthorpej goto bad; 6665ecc953bSthorpej if (!dev->d_isdef) { 667c7295a4cSchristos cfgerror("attaching undefined device `%s'", dev->d_name); 6685ecc953bSthorpej goto bad; 6695ecc953bSthorpej } 6705ecc953bSthorpej if (deva->d_isdef) { 67109274d9eSchristos cfgerror("redefinition of `%s' (previously defined at %s:%d)", 672*f079f926Schristos deva->d_name, deva->d_where.w_srcfile, deva->d_where.w_srcline); 6735ecc953bSthorpej goto bad; 6745ecc953bSthorpej } 6755ecc953bSthorpej if (dev->d_ispseudo) { 676c7295a4cSchristos cfgerror("pseudo-devices can't attach"); 6775ecc953bSthorpej goto bad; 6785ecc953bSthorpej } 6795ecc953bSthorpej 6805ecc953bSthorpej deva->d_isdef = 1; 6815ecc953bSthorpej if (has_errobj(attrs, &errattr)) 6825ecc953bSthorpej goto bad; 6834caf067bSdholland for (al = attrs; al != NULL; al = al->al_next) { 6844caf067bSdholland a = al->al_this; 6855ecc953bSthorpej if (a == &errattr) 6865ecc953bSthorpej continue; /* already complained */ 6875ecc953bSthorpej if (a->a_iattr || a->a_devclass != NULL) 688c7295a4cSchristos cfgerror("`%s' is not a plain attribute", a->a_name); 6895ecc953bSthorpej } 6905ecc953bSthorpej 6915ecc953bSthorpej /* Committed! Set up fields. */ 6925ecc953bSthorpej deva->d_attrs = attrs; 6935ecc953bSthorpej deva->d_atlist = atlist; 6945ecc953bSthorpej deva->d_devbase = dev; 6952f2f3382Suebayasi CFGDBG(3, "deva `%s' defined", deva->d_name); 6962f2f3382Suebayasi 6972f2f3382Suebayasi /* 698a5a68b71Suebayasi * Implicit attribute definition for device attachment. 6992f2f3382Suebayasi */ 7002f2f3382Suebayasi refattr(deva->d_name); 7015ecc953bSthorpej 7025ecc953bSthorpej /* 7035ecc953bSthorpej * Turn the `at' list into interface attributes (map each 7045ecc953bSthorpej * nv_name to an attribute, or to NULL for root), and add 7055ecc953bSthorpej * this device to those attributes, so that children can 7065ecc953bSthorpej * be listed at this particular device if they are supported 7075ecc953bSthorpej * by that attribute. 7085ecc953bSthorpej */ 7095ecc953bSthorpej for (nv = atlist; nv != NULL; nv = nv->nv_next) { 7105ecc953bSthorpej if (nv->nv_name == NULL) 7115ecc953bSthorpej nv->nv_ptr = a = NULL; /* at root */ 7125ecc953bSthorpej else 7135ecc953bSthorpej nv->nv_ptr = a = getattr(nv->nv_name); 7145ecc953bSthorpej if (a == &errattr) 7155ecc953bSthorpej continue; /* already complained */ 7165ecc953bSthorpej 71753be83e0Schristos #if 0 7185ecc953bSthorpej /* 7195ecc953bSthorpej * Make sure that an attachment spec doesn't 7205ecc953bSthorpej * already say how to attach to this attribute. 7215ecc953bSthorpej */ 72253be83e0Schristos for (struct deva *da = dev->d_ahead; da; da = da->d_bsame) 7235ecc953bSthorpej if (onlist(da->d_atlist, a)) 724c7295a4cSchristos cfgerror("attach at `%s' already done by `%s'", 7255ecc953bSthorpej a ? a->a_name : "root", da->d_name); 72653be83e0Schristos #endif 7275ecc953bSthorpej 728c130d400Scube if (a == NULL) { 729c130d400Scube ht_insert(devroottab, dev->d_name, dev); 7305ecc953bSthorpej continue; /* at root; don't add */ 731c130d400Scube } 7325ecc953bSthorpej if (!a->a_iattr) 733c7295a4cSchristos cfgerror("%s cannot be at plain attribute `%s'", 7345ecc953bSthorpej dev->d_name, a->a_name); 7355ecc953bSthorpej else 7365ecc953bSthorpej a->a_devs = addtoattr(a->a_devs, dev); 7375ecc953bSthorpej } 7385ecc953bSthorpej 7395ecc953bSthorpej /* attach to parent */ 7405ecc953bSthorpej *dev->d_app = deva; 7415ecc953bSthorpej dev->d_app = &deva->d_bsame; 7425ecc953bSthorpej return; 7435ecc953bSthorpej bad: 7445ecc953bSthorpej nvfreel(atlist); 7454caf067bSdholland attrlist_destroyall(attrs); 7465ecc953bSthorpej } 7475ecc953bSthorpej 7485ecc953bSthorpej /* 7495ecc953bSthorpej * Look up a device attachment. Also makes sure it is a reasonable 7505ecc953bSthorpej * name, i.e., does not contain digits or special characters. 7515ecc953bSthorpej */ 7525ecc953bSthorpej struct deva * 7535ecc953bSthorpej getdevattach(const char *name) 7545ecc953bSthorpej { 755c7295a4cSchristos const u_char *p; 7565ecc953bSthorpej struct deva *deva; 7575ecc953bSthorpej 758c7295a4cSchristos p = (const u_char *)name; 7595ecc953bSthorpej if (!isalpha(*p)) 7605ecc953bSthorpej goto badname; 7615ecc953bSthorpej while (*++p) { 7625ecc953bSthorpej if (!isalnum(*p) && *p != '_') 7635ecc953bSthorpej goto badname; 7645ecc953bSthorpej } 7655ecc953bSthorpej if (isdigit(*--p)) { 7665ecc953bSthorpej badname: 767c7295a4cSchristos cfgerror("bad device attachment name `%s'", name); 7685ecc953bSthorpej return (&errdeva); 7695ecc953bSthorpej } 7705ecc953bSthorpej deva = ht_lookup(devatab, name); 7715ecc953bSthorpej if (deva == NULL) { 7725ecc953bSthorpej deva = ecalloc(1, sizeof *deva); 7735ecc953bSthorpej deva->d_name = name; 7745ecc953bSthorpej deva->d_bsame = NULL; 7755ecc953bSthorpej deva->d_isdef = 0; 7765ecc953bSthorpej deva->d_devbase = NULL; 7775ecc953bSthorpej deva->d_atlist = NULL; 7785ecc953bSthorpej deva->d_attrs = NULL; 7795ecc953bSthorpej deva->d_ihead = NULL; 7805ecc953bSthorpej deva->d_ipp = &deva->d_ihead; 781*f079f926Schristos deva->d_where.w_srcfile = yyfile; 782*f079f926Schristos deva->d_where.w_srcline = currentline(); 7835ecc953bSthorpej TAILQ_INSERT_TAIL(&alldevas, deva, d_next); 7845ecc953bSthorpej if (ht_insert(devatab, name, deva)) 785d25ad65eSchristos panic("%s: Can't insert %s", __func__, name); 7865ecc953bSthorpej } 7875ecc953bSthorpej return (deva); 7885ecc953bSthorpej } 7895ecc953bSthorpej 7905ecc953bSthorpej /* 7915ecc953bSthorpej * Look up an attribute. 7925ecc953bSthorpej */ 7935ecc953bSthorpej struct attr * 7945ecc953bSthorpej getattr(const char *name) 7955ecc953bSthorpej { 7965ecc953bSthorpej struct attr *a; 7975ecc953bSthorpej 7985ecc953bSthorpej if ((a = ht_lookup(attrtab, name)) == NULL) { 799c7295a4cSchristos cfgerror("undefined attribute `%s'", name); 8005ecc953bSthorpej a = &errattr; 8015ecc953bSthorpej } 8025ecc953bSthorpej return (a); 8035ecc953bSthorpej } 8045ecc953bSthorpej 8055ecc953bSthorpej /* 8062f2f3382Suebayasi * Implicit attribute definition. 8072f2f3382Suebayasi */ 80851deed3eSuebayasi struct attr * 8092f2f3382Suebayasi refattr(const char *name) 8102f2f3382Suebayasi { 81151deed3eSuebayasi struct attr *a; 8122f2f3382Suebayasi 81351deed3eSuebayasi if ((a = ht_lookup(attrtab, name)) == NULL) 81451deed3eSuebayasi a = mkattr(name); 81551deed3eSuebayasi return a; 8162f2f3382Suebayasi } 8172f2f3382Suebayasi 818bb52c144Suebayasi int 819bb52c144Suebayasi getrefattr(const char *name, struct attr **ra) 820bb52c144Suebayasi { 821bb52c144Suebayasi struct attr *a; 822bb52c144Suebayasi 823bb52c144Suebayasi a = ht_lookup(attrtab, name); 824bb52c144Suebayasi if (a == NULL) { 825bb52c144Suebayasi *ra = NULL; 826bb52c144Suebayasi return (0); 827bb52c144Suebayasi } 828bb52c144Suebayasi /* 829bb52c144Suebayasi * Check if the existing attr is only referenced, not really defined. 830bb52c144Suebayasi */ 831bb52c144Suebayasi if (a->a_deps == NULL && 832bb52c144Suebayasi a->a_iattr == 0 && 833bb52c144Suebayasi a->a_devclass == 0) { 834bb52c144Suebayasi *ra = a; 835bb52c144Suebayasi return (0); 836bb52c144Suebayasi } 837bb52c144Suebayasi return (1); 838bb52c144Suebayasi } 839bb52c144Suebayasi 8402f2f3382Suebayasi /* 8415ecc953bSthorpej * Recursively expand an attribute and its dependencies, checking for 8425ecc953bSthorpej * cycles, and invoking a callback for each attribute found. 8435ecc953bSthorpej */ 8445ecc953bSthorpej void 8455ecc953bSthorpej expandattr(struct attr *a, void (*callback)(struct attr *)) 8465ecc953bSthorpej { 8474caf067bSdholland struct attrlist *al; 8485ecc953bSthorpej struct attr *dep; 8495ecc953bSthorpej 8505ecc953bSthorpej if (a->a_expanding) { 851c7295a4cSchristos cfgerror("circular dependency on attribute `%s'", a->a_name); 8525ecc953bSthorpej return; 8535ecc953bSthorpej } 8545ecc953bSthorpej 8555ecc953bSthorpej a->a_expanding = 1; 8565ecc953bSthorpej 8575ecc953bSthorpej /* First expand all of this attribute's dependencies. */ 8584caf067bSdholland for (al = a->a_deps; al != NULL; al = al->al_next) { 8594caf067bSdholland dep = al->al_this; 8605ecc953bSthorpej expandattr(dep, callback); 8615ecc953bSthorpej } 8625ecc953bSthorpej 8635ecc953bSthorpej /* ...and now invoke the callback for ourself. */ 8645ecc953bSthorpej if (callback != NULL) 8655ecc953bSthorpej (*callback)(a); 8665ecc953bSthorpej 8675ecc953bSthorpej a->a_expanding = 0; 8685ecc953bSthorpej } 8695ecc953bSthorpej 8705ecc953bSthorpej /* 8715ecc953bSthorpej * Set the major device number for a device, so that it can be used 8725ecc953bSthorpej * as a root/dumps "on" device in a configuration. 8735ecc953bSthorpej */ 8745ecc953bSthorpej void 875d767912bSdrochner setmajor(struct devbase *d, devmajor_t n) 8765ecc953bSthorpej { 8775ecc953bSthorpej 878d767912bSdrochner if (d != &errdev && d->d_major != NODEVMAJOR) 879d767912bSdrochner cfgerror("device `%s' is already major %d", 880d767912bSdrochner d->d_name, d->d_major); 8815ecc953bSthorpej else 8825ecc953bSthorpej d->d_major = n; 8835ecc953bSthorpej } 8845ecc953bSthorpej 8855ecc953bSthorpej const char * 886d767912bSdrochner major2name(devmajor_t maj) 8875ecc953bSthorpej { 8885ecc953bSthorpej struct devbase *dev; 8895ecc953bSthorpej struct devm *dm; 8905ecc953bSthorpej 8915ecc953bSthorpej if (!do_devsw) { 8925ecc953bSthorpej TAILQ_FOREACH(dev, &allbases, d_next) { 8935ecc953bSthorpej if (dev->d_major == maj) 8945ecc953bSthorpej return (dev->d_name); 8955ecc953bSthorpej } 8965ecc953bSthorpej } else { 8975ecc953bSthorpej TAILQ_FOREACH(dm, &alldevms, dm_next) { 8985ecc953bSthorpej if (dm->dm_bmajor == maj) 8995ecc953bSthorpej return (dm->dm_name); 9005ecc953bSthorpej } 9015ecc953bSthorpej } 9025ecc953bSthorpej return (NULL); 9035ecc953bSthorpej } 9045ecc953bSthorpej 905d767912bSdrochner devmajor_t 9065ecc953bSthorpej dev2major(struct devbase *dev) 9075ecc953bSthorpej { 9085ecc953bSthorpej struct devm *dm; 9095ecc953bSthorpej 9105ecc953bSthorpej if (!do_devsw) 9115ecc953bSthorpej return (dev->d_major); 9125ecc953bSthorpej 9135ecc953bSthorpej TAILQ_FOREACH(dm, &alldevms, dm_next) { 9145ecc953bSthorpej if (strcmp(dm->dm_name, dev->d_name) == 0) 9155ecc953bSthorpej return (dm->dm_bmajor); 9165ecc953bSthorpej } 917d767912bSdrochner return (NODEVMAJOR); 9185ecc953bSthorpej } 9195ecc953bSthorpej 9205ecc953bSthorpej /* 9215ecc953bSthorpej * Make a string description of the device at maj/min. 9225ecc953bSthorpej */ 9235ecc953bSthorpej static const char * 924d767912bSdrochner makedevstr(devmajor_t maj, devminor_t min) 9255ecc953bSthorpej { 926c7295a4cSchristos const char *devicename; 9275ecc953bSthorpej char buf[32]; 9285ecc953bSthorpej 929c7295a4cSchristos devicename = major2name(maj); 930c7295a4cSchristos if (devicename == NULL) 931d767912bSdrochner (void)snprintf(buf, sizeof(buf), "<%d/%d>", maj, min); 9325ecc953bSthorpej else 933d767912bSdrochner (void)snprintf(buf, sizeof(buf), "%s%d%c", devicename, 934d767912bSdrochner min / maxpartitions, (min % maxpartitions) + 'a'); 9355ecc953bSthorpej 9365ecc953bSthorpej return (intern(buf)); 9375ecc953bSthorpej } 9385ecc953bSthorpej 9395ecc953bSthorpej /* 9405ecc953bSthorpej * Map things like "ra0b" => makedev(major("ra"), 0*maxpartitions + 'b'-'a'). 9415ecc953bSthorpej * Handle the case where the device number is given but there is no 9425ecc953bSthorpej * corresponding name, and map NULL to the default. 9435ecc953bSthorpej */ 9445ecc953bSthorpej static int 9455ecc953bSthorpej resolve(struct nvlist **nvp, const char *name, const char *what, 9465ecc953bSthorpej struct nvlist *dflt, int part) 9475ecc953bSthorpej { 9485ecc953bSthorpej struct nvlist *nv; 9495ecc953bSthorpej struct devbase *dev; 9505ecc953bSthorpej const char *cp; 951d767912bSdrochner devmajor_t maj; 952d767912bSdrochner devminor_t min; 9539a7f4bbaSchristos size_t i, l; 9545ecc953bSthorpej int unit; 9555ecc953bSthorpej char buf[NAMESIZE]; 9565ecc953bSthorpej 9575cc303e1Slukem if ((part -= 'a') >= maxpartitions || part < 0) 958d25ad65eSchristos panic("%s: Bad partition %c", __func__, part); 9595ecc953bSthorpej if ((nv = *nvp) == NULL) { 9605ecc953bSthorpej dev_t d = NODEV; 9615ecc953bSthorpej /* 9625ecc953bSthorpej * Apply default. Easiest to do this by number. 9635ecc953bSthorpej * Make sure to retain NODEVness, if this is dflt's disposition. 9645ecc953bSthorpej */ 9655cc303e1Slukem if ((dev_t)dflt->nv_num != NODEV) { 9660001b928Schristos maj = major(dflt->nv_num); 9670001b928Schristos min = ((minor(dflt->nv_num) / maxpartitions) * 9685ecc953bSthorpej maxpartitions) + part; 9695ecc953bSthorpej d = makedev(maj, min); 9705ecc953bSthorpej cp = makedevstr(maj, min); 9715ecc953bSthorpej } else 9725ecc953bSthorpej cp = NULL; 9739a7f4bbaSchristos *nvp = nv = newnv(NULL, cp, NULL, (long long)d, NULL); 9745ecc953bSthorpej } 9755cc303e1Slukem if ((dev_t)nv->nv_num != NODEV) { 9765ecc953bSthorpej /* 9775ecc953bSthorpej * By the numbers. Find the appropriate major number 9785ecc953bSthorpej * to make a name. 9795ecc953bSthorpej */ 9800001b928Schristos maj = major(nv->nv_num); 9810001b928Schristos min = minor(nv->nv_num); 9825ecc953bSthorpej nv->nv_str = makedevstr(maj, min); 9835ecc953bSthorpej return (0); 9845ecc953bSthorpej } 9855ecc953bSthorpej 9865ecc953bSthorpej if (nv->nv_str == NULL || nv->nv_str == s_qmark) 9875ecc953bSthorpej /* 9885ecc953bSthorpej * Wildcarded or unspecified; leave it as NODEV. 9895ecc953bSthorpej */ 9905ecc953bSthorpej return (0); 9915ecc953bSthorpej 99279cd2972Smlelstv if (nv->nv_ptr != NULL && strcmp(nv->nv_ptr, "spec") == 0) 99379cd2972Smlelstv /* 99479cd2972Smlelstv * spec string, interpreted by kernel 99579cd2972Smlelstv */ 99679cd2972Smlelstv return (0); 99779cd2972Smlelstv 9985ecc953bSthorpej /* 9995ecc953bSthorpej * The normal case: things like "ra2b". Check for partition 10005ecc953bSthorpej * suffix, remove it if there, and split into name ("ra") and 10015ecc953bSthorpej * unit (2). 10025ecc953bSthorpej */ 10035ecc953bSthorpej l = i = strlen(nv->nv_str); 10045ecc953bSthorpej cp = &nv->nv_str[l]; 10055ecc953bSthorpej if (l > 1 && *--cp >= 'a' && *cp < 'a' + maxpartitions && 10065ecc953bSthorpej isdigit((unsigned char)cp[-1])) { 10075ecc953bSthorpej l--; 10085ecc953bSthorpej part = *cp - 'a'; 10095ecc953bSthorpej } 10105ecc953bSthorpej cp = nv->nv_str; 10115ecc953bSthorpej if (split(cp, l, buf, sizeof buf, &unit)) { 1012c7295a4cSchristos cfgerror("%s: invalid %s device name `%s'", name, what, cp); 10135ecc953bSthorpej return (1); 10145ecc953bSthorpej } 10155ecc953bSthorpej dev = ht_lookup(devbasetab, intern(buf)); 10165ecc953bSthorpej if (dev == NULL) { 1017c7295a4cSchristos cfgerror("%s: device `%s' does not exist", name, buf); 10185ecc953bSthorpej return (1); 10195ecc953bSthorpej } 10205ecc953bSthorpej 10215ecc953bSthorpej /* 10225ecc953bSthorpej * Check for the magic network interface attribute, and 10235ecc953bSthorpej * don't bother making a device number. 10245ecc953bSthorpej */ 10255ecc953bSthorpej if (has_attr(dev->d_attrs, s_ifnet)) { 10269a7f4bbaSchristos nv->nv_num = (long long)NODEV; 10275ecc953bSthorpej nv->nv_ifunit = unit; /* XXX XXX XXX */ 10285ecc953bSthorpej } else { 10295ecc953bSthorpej maj = dev2major(dev); 10305cc303e1Slukem if (maj == NODEVMAJOR) { 1031c7295a4cSchristos cfgerror("%s: can't make %s device from `%s'", 10325ecc953bSthorpej name, what, nv->nv_str); 10335ecc953bSthorpej return (1); 10345ecc953bSthorpej } 10355beb9d5aSjoerg nv->nv_num = (long long)makedev(maj, unit * maxpartitions + part); 10365ecc953bSthorpej } 10375ecc953bSthorpej 10385ecc953bSthorpej nv->nv_name = dev->d_name; 10395ecc953bSthorpej return (0); 10405ecc953bSthorpej } 10415ecc953bSthorpej 10425ecc953bSthorpej /* 10435ecc953bSthorpej * Add a completed configuration to the list. 10445ecc953bSthorpej */ 10455ecc953bSthorpej void 10465ecc953bSthorpej addconf(struct config *cf0) 10475ecc953bSthorpej { 10485ecc953bSthorpej struct config *cf; 10495ecc953bSthorpej const char *name; 10505ecc953bSthorpej 10515ecc953bSthorpej name = cf0->cf_name; 1052*f079f926Schristos if ((cf = ht_lookup(cfhashtab, name)) != NULL) { 1053*f079f926Schristos cfgerror("configuration `%s' already defined %s:%hu", name, 1054*f079f926Schristos cf->cf_where.w_srcfile, cf->cf_where.w_srcline); 10555ecc953bSthorpej goto bad; 10565ecc953bSthorpej } 1057*f079f926Schristos cf = ecalloc(1, sizeof *cf); 1058*f079f926Schristos if (ht_insert(cfhashtab, name, cf)) { 1059*f079f926Schristos free(cf); 1060*f079f926Schristos } 10615ecc953bSthorpej *cf = *cf0; 1062*f079f926Schristos cf->cf_where.w_srcfile = yyfile; 1063*f079f926Schristos cf->cf_where.w_srcline = currentline(); 10645ecc953bSthorpej 10655ecc953bSthorpej /* 10665ecc953bSthorpej * Resolve the root device. 10675ecc953bSthorpej */ 1068cd429362Serh if (cf->cf_root == NULL) { 1069c7295a4cSchristos cfgerror("%s: no root device specified", name); 10705ecc953bSthorpej goto bad; 10715ecc953bSthorpej } 1072cd429362Serh if (cf->cf_root && cf->cf_root->nv_str != s_qmark) { 1073cd429362Serh struct nvlist *nv; 1074cd429362Serh nv = cf->cf_root; 10755ecc953bSthorpej if (resolve(&cf->cf_root, name, "root", nv, 'a')) 10765ecc953bSthorpej goto bad; 10775ecc953bSthorpej } 10785ecc953bSthorpej 10795ecc953bSthorpej /* 10805ecc953bSthorpej * Resolve the dump device. 10815ecc953bSthorpej */ 10825ecc953bSthorpej if (cf->cf_dump == NULL || cf->cf_dump->nv_str == s_qmark) { 10835ecc953bSthorpej /* 10845ecc953bSthorpej * Wildcarded dump device is equivalent to unspecified. 10855ecc953bSthorpej */ 10865ecc953bSthorpej cf->cf_dump = NULL; 10875ecc953bSthorpej } else if (cf->cf_dump->nv_str == s_none) { 10885ecc953bSthorpej /* 10895ecc953bSthorpej * Operator has requested that no dump device should be 10905ecc953bSthorpej * configured; do nothing. 10915ecc953bSthorpej */ 10925ecc953bSthorpej } else { 10935ecc953bSthorpej if (resolve(&cf->cf_dump, name, "dumps", cf->cf_dump, 'b')) 10945ecc953bSthorpej goto bad; 10955ecc953bSthorpej } 10965ecc953bSthorpej 10975ecc953bSthorpej /* Wildcarded fstype is `unspecified'. */ 10985ecc953bSthorpej if (cf->cf_fstype == s_qmark) 10995ecc953bSthorpej cf->cf_fstype = NULL; 11005ecc953bSthorpej 11015ecc953bSthorpej TAILQ_INSERT_TAIL(&allcf, cf, cf_next); 11025ecc953bSthorpej return; 11035ecc953bSthorpej bad: 11045ecc953bSthorpej nvfreel(cf0->cf_root); 11055ecc953bSthorpej nvfreel(cf0->cf_dump); 11065ecc953bSthorpej } 11075ecc953bSthorpej 11085ecc953bSthorpej void 11095ecc953bSthorpej setconf(struct nvlist **npp, const char *what, struct nvlist *v) 11105ecc953bSthorpej { 11115ecc953bSthorpej 11125ecc953bSthorpej if (*npp != NULL) { 1113c7295a4cSchristos cfgerror("duplicate %s specification", what); 11145ecc953bSthorpej nvfreel(v); 11155ecc953bSthorpej } else 11165ecc953bSthorpej *npp = v; 11175ecc953bSthorpej } 11185ecc953bSthorpej 11195ecc953bSthorpej void 11203dbd1573Schristos delconf(const char *name, int nowarn) 112142b52b8aScube { 112242b52b8aScube struct config *cf; 112342b52b8aScube 112475eb07f2Suebayasi CFGDBG(5, "deselecting config `%s'", name); 112542b52b8aScube if (ht_lookup(cfhashtab, name) == NULL) { 11263dbd1573Schristos if (!nowarn) 1127c7295a4cSchristos cfgerror("configuration `%s' undefined", name); 112842b52b8aScube return; 112942b52b8aScube } 113042b52b8aScube (void)ht_remove(cfhashtab, name); 113142b52b8aScube 113242b52b8aScube TAILQ_FOREACH(cf, &allcf, cf_next) 113342b52b8aScube if (!strcmp(cf->cf_name, name)) 113442b52b8aScube break; 113542b52b8aScube if (cf == NULL) 1136d25ad65eSchristos panic("%s: lost configuration for %s", __func__, name); 113742b52b8aScube 113842b52b8aScube TAILQ_REMOVE(&allcf, cf, cf_next); 113942b52b8aScube } 114042b52b8aScube 114142b52b8aScube void 11425ecc953bSthorpej setfstype(const char **fstp, const char *v) 11435ecc953bSthorpej { 11445ecc953bSthorpej 11455ecc953bSthorpej if (*fstp != NULL) { 1146c7295a4cSchristos cfgerror("multiple fstype specifications"); 11475ecc953bSthorpej return; 11485ecc953bSthorpej } 11495ecc953bSthorpej 11505ecc953bSthorpej if (v != s_qmark && OPT_FSOPT(v)) { 1151c7295a4cSchristos cfgerror("\"%s\" is not a configured file system", v); 11525ecc953bSthorpej return; 11535ecc953bSthorpej } 11545ecc953bSthorpej 11555ecc953bSthorpej *fstp = v; 11565ecc953bSthorpej } 11575ecc953bSthorpej 11585ecc953bSthorpej static struct devi * 11595ecc953bSthorpej newdevi(const char *name, int unit, struct devbase *d) 11605ecc953bSthorpej { 11615ecc953bSthorpej struct devi *i; 11625ecc953bSthorpej 11635ecc953bSthorpej i = ecalloc(1, sizeof *i); 11645ecc953bSthorpej i->i_name = name; 11655ecc953bSthorpej i->i_unit = unit; 11665ecc953bSthorpej i->i_base = d; 11675ecc953bSthorpej i->i_bsame = NULL; 11685ecc953bSthorpej i->i_asame = NULL; 11695ecc953bSthorpej i->i_alias = NULL; 11705ecc953bSthorpej i->i_at = NULL; 11715ecc953bSthorpej i->i_pspec = NULL; 11725ecc953bSthorpej i->i_atdeva = NULL; 11735ecc953bSthorpej i->i_locs = NULL; 11745ecc953bSthorpej i->i_cfflags = 0; 1175*f079f926Schristos i->i_where.w_srcline = currentline(); 1176*f079f926Schristos i->i_where.w_srcfile = yyfile; 11777aa6070dScube i->i_active = DEVI_ORPHAN; /* Proper analysis comes later */ 1178a31ff6b4Scube i->i_level = devilevel; 117990ac64deSpooka i->i_pseudoroot = 0; 1180*f079f926Schristos i->i_where.w_srcfile = yyfile; 1181*f079f926Schristos i->i_where.w_srcline = currentline(); 11825ecc953bSthorpej if (unit >= d->d_umax) 11835ecc953bSthorpej d->d_umax = unit + 1; 11845ecc953bSthorpej return (i); 11855ecc953bSthorpej } 11865ecc953bSthorpej 118753be83e0Schristos static struct attr * 118853be83e0Schristos finddevattr(const char *name, const char *at, struct devbase *ib, 118953be83e0Schristos struct devbase **ab, int *atunit) 11905ecc953bSthorpej { 11915ecc953bSthorpej const char *cp; 11925ecc953bSthorpej char atbuf[NAMESIZE]; 119353be83e0Schristos struct attrlist *al; 119453be83e0Schristos struct attr *attr; 11955ecc953bSthorpej 11965ecc953bSthorpej if (at == NULL) { 119753be83e0Schristos *ab = NULL; 119853be83e0Schristos *atunit = -1; 119953be83e0Schristos return &errattr; /* a convenient "empty" attr */ 12005ecc953bSthorpej } 120153be83e0Schristos if (split(at, strlen(at), atbuf, sizeof atbuf, atunit)) { 1202c7295a4cSchristos cfgerror("invalid attachment name `%s'", at); 12035ecc953bSthorpej /* (void)getdevi(name); -- ??? */ 120453be83e0Schristos return NULL; 12055ecc953bSthorpej } 12065ecc953bSthorpej 12075ecc953bSthorpej /* 12085ecc953bSthorpej * Devices can attach to two types of things: Attributes, 12095ecc953bSthorpej * and other devices (which have the appropriate attributes 12105ecc953bSthorpej * to allow attachment). 12115ecc953bSthorpej * 12125ecc953bSthorpej * (1) If we're attached to an attribute, then we don't need 12135ecc953bSthorpej * look at the parent base device to see what attributes 12145ecc953bSthorpej * it has, and make sure that we can attach to them. 12155ecc953bSthorpej * 12165ecc953bSthorpej * (2) If we're attached to a real device (i.e. named in 12175ecc953bSthorpej * the config file), we want to remember that so that 12185ecc953bSthorpej * at cross-check time, if the device we're attached to 12195ecc953bSthorpej * is missing but other devices which also provide the 12205ecc953bSthorpej * attribute are present, we don't get a false "OK." 12215ecc953bSthorpej * 12225ecc953bSthorpej * (3) If the thing we're attached to is an attribute 12235ecc953bSthorpej * but is actually named in the config file, we still 12245ecc953bSthorpej * have to remember its devbase. 12255ecc953bSthorpej */ 12265ecc953bSthorpej cp = intern(atbuf); 12275ecc953bSthorpej 12285ecc953bSthorpej /* Figure out parent's devbase, to satisfy case (3). */ 122953be83e0Schristos *ab = ht_lookup(devbasetab, cp); 12305ecc953bSthorpej 12315ecc953bSthorpej /* Find out if it's an attribute. */ 12325ecc953bSthorpej attr = ht_lookup(attrtab, cp); 12335ecc953bSthorpej 12345ecc953bSthorpej /* Make sure we're _really_ attached to the attr. Case (1). */ 12355ecc953bSthorpej if (attr != NULL && onlist(attr->a_devs, ib)) 123653be83e0Schristos return attr; 12375ecc953bSthorpej 12385ecc953bSthorpej /* 12395ecc953bSthorpej * Else a real device, and not just an attribute. Case (2). 12405ecc953bSthorpej * 12415ecc953bSthorpej * Have to work a bit harder to see whether we have 12425ecc953bSthorpej * something like "tg0 at esp0" (where esp is merely 12435ecc953bSthorpej * not an attribute) or "tg0 at nonesuch0" (where 12445ecc953bSthorpej * nonesuch is not even a device). 12455ecc953bSthorpej */ 124653be83e0Schristos if (*ab == NULL) { 124753be83e0Schristos cfgerror("%s at %s: `%s' unknown", name, at, atbuf); 124853be83e0Schristos return NULL; 12495ecc953bSthorpej } 12505ecc953bSthorpej 12515ecc953bSthorpej /* 12525ecc953bSthorpej * See if the named parent carries an attribute 12535ecc953bSthorpej * that allows it to supervise device ib. 12545ecc953bSthorpej */ 125553be83e0Schristos for (al = (*ab)->d_attrs; al != NULL; al = al->al_next) { 12564caf067bSdholland attr = al->al_this; 12575ecc953bSthorpej if (onlist(attr->a_devs, ib)) 125853be83e0Schristos return attr; 12595ecc953bSthorpej } 1260c7295a4cSchristos cfgerror("`%s' cannot attach to `%s'", ib->d_name, atbuf); 126153be83e0Schristos return NULL; 126253be83e0Schristos } 126353be83e0Schristos 126453be83e0Schristos /* 126553be83e0Schristos * Add the named device as attaching to the named attribute (or perhaps 126653be83e0Schristos * another device instead) plus unit number. 126753be83e0Schristos */ 126853be83e0Schristos void 126953be83e0Schristos adddev(const char *name, const char *at, struct loclist *loclist, int flags) 127053be83e0Schristos { 127153be83e0Schristos struct devi *i; /* the new instance */ 127253be83e0Schristos struct pspec *p; /* and its pspec */ 127353be83e0Schristos struct attr *attr; /* attribute that allows attach */ 127453be83e0Schristos struct devbase *ib; /* i->i_base */ 127553be83e0Schristos struct devbase *ab; /* not NULL => at another dev */ 127653be83e0Schristos struct deva *iba; /* devbase attachment used */ 127753be83e0Schristos struct deva *lastiba; 1278d25ad65eSchristos int atunit, first; 127953be83e0Schristos 128053be83e0Schristos lastiba = NULL; 128153be83e0Schristos if ((i = getdevi(name)) == NULL) 128253be83e0Schristos goto bad; 128353be83e0Schristos ib = i->i_base; 128453be83e0Schristos attr = finddevattr(name, at, ib, &ab, &atunit); 128553be83e0Schristos if (attr == NULL) { 12865ec393e9Scube i->i_active = DEVI_BROKEN; 12875ecc953bSthorpej goto bad; 128853be83e0Schristos } 12895ecc953bSthorpej 129053be83e0Schristos for (lastiba = ib->d_ahead; lastiba; lastiba = iba->d_bsame) { 129153be83e0Schristos for (iba = lastiba; iba != NULL; iba = iba->d_bsame) 129253be83e0Schristos if (onlist(iba->d_atlist, 129353be83e0Schristos attr == &errattr ? NULL : attr)) 12945ecc953bSthorpej break; 129553be83e0Schristos 1296d25ad65eSchristos first = lastiba == ib->d_ahead; 129753be83e0Schristos if (iba == NULL) { 1298d25ad65eSchristos if (!first) 129953be83e0Schristos goto bad; 130053be83e0Schristos if (attr != &errattr) { 1301d25ad65eSchristos panic("%s: can't figure out attachment", 1302d25ad65eSchristos __func__); 130353be83e0Schristos } else { 130453be83e0Schristos cfgerror("`%s' cannot attach to the root", 130553be83e0Schristos ib->d_name); 130653be83e0Schristos i->i_active = DEVI_BROKEN; 13075ecc953bSthorpej } 130853be83e0Schristos } 130953be83e0Schristos // get a new one if it is not the first time 1310d25ad65eSchristos if (!first && (i = getdevi(name)) == NULL) 131153be83e0Schristos goto bad; 131253be83e0Schristos 131353be83e0Schristos if (attr != &errattr) { 131453be83e0Schristos /* 131553be83e0Schristos * Find the parent spec. If a matching one has not 131653be83e0Schristos * yet been created, create one. 131753be83e0Schristos * 131853be83e0Schristos * XXX: This creates multiple pspecs that look the 131953be83e0Schristos * same in the config file and could be merged. 132053be83e0Schristos */ 13214b9e5cb1Schristos p = getpspec(attr, ab, atunit, first); 132253be83e0Schristos p->p_devs = newnv(NULL, NULL, i, 0, p->p_devs); 1323d25ad65eSchristos } else 1324d25ad65eSchristos p = NULL; 132553be83e0Schristos 13265ec393e9Scube if ((i->i_locs = fixloc(name, attr, loclist)) == NULL) { 13275ec393e9Scube i->i_active = DEVI_BROKEN; 13285ecc953bSthorpej goto bad; 13295ec393e9Scube } 13305ecc953bSthorpej i->i_at = at; 13315ecc953bSthorpej i->i_pspec = p; 13325ecc953bSthorpej i->i_atdeva = iba; 13335ecc953bSthorpej i->i_cfflags = flags; 133453be83e0Schristos CFGDBG(3, "devi `%s' at '%s' added", i->i_name, iba->d_name); 13355ecc953bSthorpej 13365ecc953bSthorpej *iba->d_ipp = i; 13375ecc953bSthorpej iba->d_ipp = &i->i_asame; 133853be83e0Schristos } 13395ecc953bSthorpej 13405ecc953bSthorpej /* all done, fall into ... */ 13415ecc953bSthorpej bad: 134216a8771bSdholland loclist_destroy(loclist); 13435ecc953bSthorpej return; 13445ecc953bSthorpej } 13455ecc953bSthorpej 13465ecc953bSthorpej void 13473dbd1573Schristos deldevi(const char *name, const char *at, int nowarn) 13485ecc953bSthorpej { 13497b7c582aScube struct devi *firsti, *i; 13505ecc953bSthorpej struct devbase *d; 13515ecc953bSthorpej int unit; 13525ecc953bSthorpej char base[NAMESIZE]; 13535ecc953bSthorpej 135475eb07f2Suebayasi CFGDBG(5, "deselecting devi `%s'", name); 13555ecc953bSthorpej if (split(name, strlen(name), base, sizeof base, &unit)) { 13563dbd1573Schristos if (!nowarn) { 1357c7295a4cSchristos cfgerror("invalid device name `%s'", name); 13585ecc953bSthorpej return; 13595ecc953bSthorpej } 13603dbd1573Schristos } 13615ecc953bSthorpej d = ht_lookup(devbasetab, intern(base)); 13625ecc953bSthorpej if (d == NULL) { 13633dbd1573Schristos if (!nowarn) 1364c7295a4cSchristos cfgerror("%s: unknown device `%s'", name, base); 13655ecc953bSthorpej return; 13665ecc953bSthorpej } 13675ecc953bSthorpej if (d->d_ispseudo) { 1368c7295a4cSchristos cfgerror("%s: %s is a pseudo-device", name, base); 13695ecc953bSthorpej return; 13705ecc953bSthorpej } 13715ecc953bSthorpej if ((firsti = ht_lookup(devitab, name)) == NULL) { 1372c7295a4cSchristos cfgerror("`%s' not defined", name); 13735ecc953bSthorpej return; 13745ecc953bSthorpej } 13757b7c582aScube if (at == NULL && firsti->i_at == NULL) { 1376e499d8b5Scube /* 'at root' */ 13777b7c582aScube remove_devi(firsti); 13787b7c582aScube return; 13797b7c582aScube } else if (at != NULL) 13807b7c582aScube for (i = firsti; i != NULL; i = i->i_alias) 1381bfc250f2Scube if (i->i_active != DEVI_BROKEN && 1382bfc250f2Scube strcmp(at, i->i_at) == 0) { 13837b7c582aScube remove_devi(i); 13845ecc953bSthorpej return; 13855ecc953bSthorpej } 1386c7295a4cSchristos cfgerror("`%s' at `%s' not found", name, at ? at : "root"); 1387e499d8b5Scube } 13885ecc953bSthorpej 13897b7c582aScube static void 1390511fbc70Schristos remove_pspec(struct devi *i) 1391511fbc70Schristos { 1392511fbc70Schristos struct pspec *p = i->i_pspec; 1393511fbc70Schristos struct nvlist *nv, *onv; 1394511fbc70Schristos 1395511fbc70Schristos if (p == NULL) 1396511fbc70Schristos return; 1397511fbc70Schristos 1398511fbc70Schristos /* Double-linked nvlist anyone? */ 1399511fbc70Schristos for (nv = p->p_devs; nv->nv_next != NULL; nv = nv->nv_next) { 1400511fbc70Schristos if (nv->nv_next && nv->nv_next->nv_ptr == i) { 1401511fbc70Schristos onv = nv->nv_next; 1402511fbc70Schristos nv->nv_next = onv->nv_next; 1403511fbc70Schristos nvfree(onv); 1404511fbc70Schristos break; 1405511fbc70Schristos } 1406511fbc70Schristos if (nv->nv_ptr == i) { 1407511fbc70Schristos /* nv is p->p_devs in that case */ 1408511fbc70Schristos p->p_devs = nv->nv_next; 1409511fbc70Schristos nvfree(nv); 1410511fbc70Schristos break; 1411511fbc70Schristos } 1412511fbc70Schristos } 1413511fbc70Schristos if (p->p_devs == NULL) 1414511fbc70Schristos TAILQ_REMOVE(&allpspecs, p, p_list); 1415511fbc70Schristos } 1416511fbc70Schristos 1417511fbc70Schristos static void 14187b7c582aScube remove_devi(struct devi *i) 14197b7c582aScube { 14207b7c582aScube struct devbase *d = i->i_base; 14217b7c582aScube struct devi *f, *j, **ppi; 14227b7c582aScube struct deva *iba; 14237b7c582aScube 14248d928a75Suebayasi CFGDBG(5, "removing devi `%s'", i->i_name); 14257b7c582aScube f = ht_lookup(devitab, i->i_name); 14266a6299ebScube if (f == NULL) 1427d25ad65eSchristos panic("%s: instance %s disappeared from devitab", __func__, 14286a6299ebScube i->i_name); 14297b7c582aScube 1430bfc250f2Scube if (i->i_active == DEVI_BROKEN) { 1431bfc250f2Scube cfgerror("not removing broken instance `%s'", i->i_name); 1432bfc250f2Scube return; 1433bfc250f2Scube } 1434bfc250f2Scube 1435e499d8b5Scube /* 1436e499d8b5Scube * We have the device instance, i. 1437e499d8b5Scube * We have to: 1438e499d8b5Scube * - delete the alias 1439e499d8b5Scube * 1440e499d8b5Scube * If the devi was an alias of an already listed devi, all is 1441e499d8b5Scube * good we don't have to do more. 1442e499d8b5Scube * If it was the first alias, we have to replace i's entry in 1443e499d8b5Scube * d's list by its first alias. 1444e499d8b5Scube * If it was the only entry, we must remove i's entry from d's 1445e499d8b5Scube * list. 1446e499d8b5Scube */ 14477b7c582aScube if (i != f) { 1448db7dbdacSuebayasi for (j = f; j->i_alias != i; j = j->i_alias) 1449db7dbdacSuebayasi continue; 14507b7c582aScube j->i_alias = i->i_alias; 14513b405775Scube } else { 14523b405775Scube if (i->i_alias == NULL) { 1453e499d8b5Scube /* No alias, must unlink the entry from devitab */ 14547b7c582aScube ht_remove(devitab, i->i_name); 14557b7c582aScube j = i->i_bsame; 14563b405775Scube } else { 1457e499d8b5Scube /* Or have the first alias replace i in d's list */ 1458e499d8b5Scube i->i_alias->i_bsame = i->i_bsame; 14597b7c582aScube j = i->i_alias; 14607b7c582aScube if (i == f) 14617b7c582aScube ht_replace(devitab, i->i_name, i->i_alias); 14623b405775Scube } 14633b405775Scube 1464e499d8b5Scube /* 1465e499d8b5Scube * - remove/replace the instance from the devbase's list 1466e499d8b5Scube * 1467e499d8b5Scube * A double-linked list would make this much easier. Oh, well, 1468e499d8b5Scube * what is done is done. 1469e499d8b5Scube */ 1470e499d8b5Scube for (ppi = &d->d_ihead; 1471e499d8b5Scube *ppi != NULL && *ppi != i && (*ppi)->i_bsame != i; 1472db7dbdacSuebayasi ppi = &(*ppi)->i_bsame) 1473db7dbdacSuebayasi continue; 1474e499d8b5Scube if (*ppi == NULL) 1475d25ad65eSchristos panic("%s: dev (%s) doesn't list the devi (%s at %s)", 1476d25ad65eSchristos __func__, d->d_name, i->i_name, i->i_at); 14777b7c582aScube f = *ppi; 14787b7c582aScube if (f == i) 1479c3414672Scube /* That implies d->d_ihead == i */ 14807b7c582aScube *ppi = j; 1481e499d8b5Scube else 14827b7c582aScube (*ppi)->i_bsame = j; 1483e499d8b5Scube if (d->d_ipp == &i->i_bsame) { 14843b405775Scube if (i->i_alias == NULL) { 14857b7c582aScube if (f == i) 1486e499d8b5Scube d->d_ipp = &d->d_ihead; 1487e499d8b5Scube else 14887b7c582aScube d->d_ipp = &f->i_bsame; 14893b405775Scube } else 14903b405775Scube d->d_ipp = &i->i_alias->i_bsame; 1491e499d8b5Scube } 1492e499d8b5Scube } 1493e499d8b5Scube /* 1494e499d8b5Scube * - delete the attachment instance 1495e499d8b5Scube */ 1496e499d8b5Scube iba = i->i_atdeva; 1497e499d8b5Scube for (ppi = &iba->d_ihead; 1498e499d8b5Scube *ppi != NULL && *ppi != i && (*ppi)->i_asame != i; 1499db7dbdacSuebayasi ppi = &(*ppi)->i_asame) 1500db7dbdacSuebayasi continue; 1501e499d8b5Scube if (*ppi == NULL) 1502d25ad65eSchristos panic("%s: deva (%s) doesn't list the devi (%s)", __func__, 1503e499d8b5Scube iba->d_name, i->i_name); 15047b7c582aScube f = *ppi; 15057b7c582aScube if (f == i) 1506c3414672Scube /* That implies iba->d_ihead == i */ 1507e499d8b5Scube *ppi = i->i_asame; 1508e499d8b5Scube else 1509e499d8b5Scube (*ppi)->i_asame = i->i_asame; 1510e499d8b5Scube if (iba->d_ipp == &i->i_asame) { 15117b7c582aScube if (f == i) 1512e499d8b5Scube iba->d_ipp = &iba->d_ihead; 1513e499d8b5Scube else 15147b7c582aScube iba->d_ipp = &f->i_asame; 1515e499d8b5Scube } 1516e499d8b5Scube /* 1517e499d8b5Scube * - delete the pspec 1518e499d8b5Scube */ 1519511fbc70Schristos remove_pspec(i); 1520e499d8b5Scube 1521e499d8b5Scube /* 1522e499d8b5Scube * - delete the alldevi entry 1523e499d8b5Scube */ 1524e499d8b5Scube TAILQ_REMOVE(&alldevi, i, i_next); 1525e499d8b5Scube ndevi--; 15267aa6070dScube /* 15277aa6070dScube * Put it in deaddevitab 1528a31ff6b4Scube * 1529a31ff6b4Scube * Each time a devi is removed, devilevel is increased so that later on 1530a31ff6b4Scube * it is possible to tell if an instance was added before or after the 1531a31ff6b4Scube * removal of its parent. 1532a31ff6b4Scube * 1533a31ff6b4Scube * For active instances, i_level contains the number of devi removed so 1534a31ff6b4Scube * far, and for dead devis, it contains its index. 15357aa6070dScube */ 1536a31ff6b4Scube i->i_level = devilevel++; 15377aa6070dScube i->i_alias = NULL; 15387aa6070dScube f = ht_lookup(deaddevitab, i->i_name); 15397aa6070dScube if (f == NULL) { 15407aa6070dScube if (ht_insert(deaddevitab, i->i_name, i)) 1541d25ad65eSchristos panic("%s: can't add %s to deaddevitab", __func__, 15427aa6070dScube i->i_name); 15437aa6070dScube } else { 1544db7dbdacSuebayasi for (j = f; j->i_alias != NULL; j = j->i_alias) 1545db7dbdacSuebayasi continue; 15467aa6070dScube j->i_alias = i; 15477aa6070dScube } 1548e499d8b5Scube /* 15495d1e8b27Swiz * - reconstruct d->d_umax 1550e499d8b5Scube */ 1551e499d8b5Scube d->d_umax = 0; 1552e499d8b5Scube for (i = d->d_ihead; i != NULL; i = i->i_bsame) 1553e499d8b5Scube if (i->i_unit >= d->d_umax) 1554e499d8b5Scube d->d_umax = i->i_unit + 1; 15555ecc953bSthorpej } 15565ecc953bSthorpej 15575ecc953bSthorpej void 15583dbd1573Schristos deldeva(const char *at, int nowarn) 15597b7c582aScube { 15607b7c582aScube int unit; 15617b7c582aScube const char *cp; 15627b7c582aScube struct devbase *d, *ad; 15637b7c582aScube struct devi *i, *j; 15647b7c582aScube struct attr *a; 15657b7c582aScube struct pspec *p; 15667b7c582aScube struct nvlist *nv, *stack = NULL; 15677b7c582aScube 15687b7c582aScube if (at == NULL) { 15697b7c582aScube TAILQ_FOREACH(i, &alldevi, i_next) 15707b7c582aScube if (i->i_at == NULL) 15717b7c582aScube stack = newnv(NULL, NULL, i, 0, stack); 15727b7c582aScube } else { 15739a7f4bbaSchristos size_t l; 15747b7c582aScube 157575eb07f2Suebayasi CFGDBG(5, "deselecting deva `%s'", at); 15769a7f4bbaSchristos if (at[0] == '\0') 15779a7f4bbaSchristos goto out; 15789a7f4bbaSchristos 15797b7c582aScube l = strlen(at) - 1; 15807b7c582aScube if (at[l] == '?' || isdigit((unsigned char)at[l])) { 15817b7c582aScube char base[NAMESIZE]; 15827b7c582aScube 15837b7c582aScube if (split(at, l+1, base, sizeof base, &unit)) { 15849a7f4bbaSchristos out: 1585c7295a4cSchristos cfgerror("invalid attachment name `%s'", at); 15867b7c582aScube return; 15877b7c582aScube } 15887b7c582aScube cp = intern(base); 15897b7c582aScube } else { 15907b7c582aScube cp = intern(at); 15917b7c582aScube unit = STAR; 15927b7c582aScube } 15937b7c582aScube 15947b7c582aScube ad = ht_lookup(devbasetab, cp); 15957b7c582aScube a = ht_lookup(attrtab, cp); 15967b7c582aScube if (a == NULL) { 1597c7295a4cSchristos cfgerror("unknown attachment attribute or device `%s'", 15987b7c582aScube cp); 15997b7c582aScube return; 16007b7c582aScube } 16017b7c582aScube if (!a->a_iattr) { 1602c7295a4cSchristos cfgerror("plain attribute `%s' cannot have children", 16037b7c582aScube a->a_name); 16047b7c582aScube return; 16057b7c582aScube } 16067b7c582aScube 16077b7c582aScube /* 16087b7c582aScube * remove_devi() makes changes to the devbase's list and the 16097b7c582aScube * alias list, * so the actual deletion of the instances must 16107b7c582aScube * be delayed. 16117b7c582aScube */ 16127b7c582aScube for (nv = a->a_devs; nv != NULL; nv = nv->nv_next) { 16137b7c582aScube d = nv->nv_ptr; 16147b7c582aScube for (i = d->d_ihead; i != NULL; i = i->i_bsame) 16157b7c582aScube for (j = i; j != NULL; j = j->i_alias) { 16167b7c582aScube /* Ignore devices at root */ 16177b7c582aScube if (j->i_at == NULL) 16187b7c582aScube continue; 16197b7c582aScube p = j->i_pspec; 16207b7c582aScube /* 16217b7c582aScube * There are three cases: 16227b7c582aScube * 16237b7c582aScube * 1. unit is not STAR. Consider 'at' 16247b7c582aScube * to be explicit, even if it 16257b7c582aScube * references an interface 16267b7c582aScube * attribute. 16277b7c582aScube * 16287b7c582aScube * 2. unit is STAR and 'at' references 16297b7c582aScube * a real device. Look for pspec 16307b7c582aScube * that have a matching p_atdev 16317b7c582aScube * field. 16327b7c582aScube * 16337b7c582aScube * 3. unit is STAR and 'at' references 16347b7c582aScube * an interface attribute. Look 16357b7c582aScube * for pspec that have a matching 16367b7c582aScube * p_iattr field. 16377b7c582aScube */ 16387b7c582aScube if ((unit != STAR && /* Case */ 16397b7c582aScube !strcmp(j->i_at, at)) || /* 1 */ 16407b7c582aScube (unit == STAR && 16417b7c582aScube ((ad != NULL && /* Case */ 16427b7c582aScube p->p_atdev == ad) || /* 2 */ 16437b7c582aScube (ad == NULL && /* Case */ 16447b7c582aScube p->p_iattr == a)))) /* 3 */ 16457b7c582aScube stack = newnv(NULL, NULL, j, 0, 16467b7c582aScube stack); 16477b7c582aScube } 16487b7c582aScube } 16497b7c582aScube } 16507b7c582aScube 165111a68adeSchristos devcleanup(stack); 16527b7c582aScube } 16537b7c582aScube 16547b7c582aScube void 16553dbd1573Schristos deldev(const char *name, int nowarn) 16567b7c582aScube { 16579a7f4bbaSchristos size_t l; 16587b7c582aScube struct devi *firsti, *i; 165911a68adeSchristos struct nvlist *stack = NULL; 16607b7c582aScube 166175eb07f2Suebayasi CFGDBG(5, "deselecting dev `%s'", name); 16629a7f4bbaSchristos if (name[0] == '\0') 16639a7f4bbaSchristos goto out; 16649a7f4bbaSchristos 16657b7c582aScube l = strlen(name) - 1; 16667b7c582aScube if (name[l] == '*' || isdigit((unsigned char)name[l])) { 16677b7c582aScube /* `no mydev0' or `no mydev*' */ 16687b7c582aScube firsti = ht_lookup(devitab, name); 16697b7c582aScube if (firsti == NULL) { 16709a7f4bbaSchristos out: 16713dbd1573Schristos if (!nowarn) 1672c7295a4cSchristos cfgerror("unknown instance %s", name); 16737b7c582aScube return; 16747b7c582aScube } 16757b7c582aScube for (i = firsti; i != NULL; i = i->i_alias) 16767b7c582aScube stack = newnv(NULL, NULL, i, 0, stack); 16777b7c582aScube } else { 16787b7c582aScube struct devbase *d = ht_lookup(devbasetab, name); 16797b7c582aScube 16807b7c582aScube if (d == NULL) { 1681c7295a4cSchristos cfgerror("unknown device %s", name); 16827b7c582aScube return; 16837b7c582aScube } 168471af9028Scube if (d->d_ispseudo) { 1685c7295a4cSchristos cfgerror("%s is a pseudo-device; " 168671af9028Scube "use \"no pseudo-device %s\" instead", name, 168771af9028Scube name); 168871af9028Scube return; 168971af9028Scube } 169011a68adeSchristos stack = makedevstack(d); 16917b7c582aScube } 16927b7c582aScube 169311a68adeSchristos devcleanup(stack); 16947b7c582aScube } 16957b7c582aScube 169600ed8a38Spooka /* 169700ed8a38Spooka * Insert given device "name" into devroottab. In case "name" 169800ed8a38Spooka * designates a pure interface attribute, create a fake device 169900ed8a38Spooka * instance for the attribute and insert that into the roottab 170000ed8a38Spooka * (this scheme avoids mucking around with the orphanage analysis). 170100ed8a38Spooka */ 17027b7c582aScube void 170390ac64deSpooka addpseudoroot(const char *name) 170490ac64deSpooka { 1705194e1c80Spooka char buf[NAMESIZE]; 1706194e1c80Spooka int unit; 1707194e1c80Spooka struct attr *attr; 170890ac64deSpooka struct devi *i; 170990ac64deSpooka struct deva *iba; 171090ac64deSpooka struct devbase *ib; 171190ac64deSpooka 1712194e1c80Spooka if (split(name, strlen(name), buf, sizeof(buf), &unit)) { 1713194e1c80Spooka cfgerror("invalid pseudo-root name `%s'", name); 1714194e1c80Spooka return; 1715194e1c80Spooka } 1716194e1c80Spooka 1717194e1c80Spooka /* 171800ed8a38Spooka * Prefer device because devices with locators define an 171900ed8a38Spooka * implicit interface attribute. However, if a device is 172000ed8a38Spooka * not available, try to attach to the interface attribute. 172100ed8a38Spooka * This makes sure adddev() doesn't get confused when we 172200ed8a38Spooka * are really attaching to a device (alternatively we maybe 172300ed8a38Spooka * could specify a non-NULL atlist to defdevattach() below). 1724194e1c80Spooka */ 172500ed8a38Spooka ib = ht_lookup(devbasetab, intern(buf)); 172600ed8a38Spooka if (ib == NULL) { 1727194e1c80Spooka struct devbase *fakedev; 1728194e1c80Spooka char fakename[NAMESIZE]; 1729194e1c80Spooka 173000ed8a38Spooka attr = ht_lookup(attrtab, intern(buf)); 173100ed8a38Spooka if (!(attr && attr->a_iattr)) { 173200ed8a38Spooka cfgerror("pseudo-root `%s' not available", name); 173300ed8a38Spooka return; 173400ed8a38Spooka } 173500ed8a38Spooka 1736194e1c80Spooka /* 1737194e1c80Spooka * here we cheat a bit: create a fake devbase with the 1738194e1c80Spooka * interface attribute and instantiate it. quick, cheap, 1739194e1c80Spooka * dirty & bad for you, much like the stuff in the fridge. 1740194e1c80Spooka * and, it works, since the pseudoroot device is not included 1741194e1c80Spooka * in ioconf, just used by config to make sure we start from 1742194e1c80Spooka * the right place. 1743194e1c80Spooka */ 174400ed8a38Spooka snprintf(fakename, sizeof(fakename), "%s_devattrs", buf); 1745194e1c80Spooka fakedev = getdevbase(intern(fakename)); 1746194e1c80Spooka fakedev->d_isdef = 1; 1747194e1c80Spooka fakedev->d_ispseudo = 0; 17484caf067bSdholland fakedev->d_attrs = attrlist_cons(NULL, attr); 1749194e1c80Spooka defdevattach(NULL, fakedev, NULL, NULL); 1750194e1c80Spooka 1751194e1c80Spooka if (unit == STAR) 1752194e1c80Spooka snprintf(buf, sizeof(buf), "%s*", fakename); 1753194e1c80Spooka else 1754194e1c80Spooka snprintf(buf, sizeof(buf), "%s%d", fakename, unit); 1755194e1c80Spooka name = buf; 1756194e1c80Spooka } 1757194e1c80Spooka 1758194e1c80Spooka /* ok, everything should be set up, so instantiate a fake device */ 175990ac64deSpooka i = getdevi(name); 176090ac64deSpooka if (i == NULL) 1761d25ad65eSchristos panic("%s: device `%s' expected to be present", __func__, 1762d25ad65eSchristos name); 176390ac64deSpooka ib = i->i_base; 1764194e1c80Spooka iba = ib->d_ahead; 176590ac64deSpooka 176690ac64deSpooka i->i_atdeva = iba; 176790ac64deSpooka i->i_cfflags = 0; 176890ac64deSpooka i->i_locs = fixloc(name, &errattr, NULL); 176990ac64deSpooka i->i_pseudoroot = 1; 177090ac64deSpooka i->i_active = DEVI_ORPHAN; /* set active by kill_orphans() */ 177190ac64deSpooka 177290ac64deSpooka *iba->d_ipp = i; 177390ac64deSpooka iba->d_ipp = &i->i_asame; 177490ac64deSpooka 177590ac64deSpooka ht_insert(devroottab, ib->d_name, ib); 177690ac64deSpooka } 177790ac64deSpooka 177811a68adeSchristos static void 177911a68adeSchristos deldevbase(struct devbase *d) 178011a68adeSchristos { 178111a68adeSchristos struct devi *i; 178211a68adeSchristos const char *name = d->d_name; 178311a68adeSchristos 178411a68adeSchristos if (!d->d_ispseudo) { 178511a68adeSchristos devcleanup(makedevstack(d)); 178611a68adeSchristos return; 178711a68adeSchristos } 178811a68adeSchristos 178911a68adeSchristos if ((i = ht_lookup(devitab, name)) == NULL) 179011a68adeSchristos return; 179111a68adeSchristos 179211a68adeSchristos d->d_umax = 0; /* clear neads-count entries */ 179311a68adeSchristos d->d_ihead = NULL; /* make sure it won't be considered active */ 179411a68adeSchristos TAILQ_REMOVE(&allpseudo, i, i_next); 179511a68adeSchristos if (ht_remove(devitab, name)) 1796d25ad65eSchristos panic("%s: Can't remove %s from devitab", __func__, name); 179711a68adeSchristos if (ht_insert(deaddevitab, name, i)) 1798d25ad65eSchristos panic("%s: Can't add %s to deaddevitab", __func__, name); 179911a68adeSchristos } 180011a68adeSchristos 180190ac64deSpooka void 18025ecc953bSthorpej addpseudo(const char *name, int number) 18035ecc953bSthorpej { 18045ecc953bSthorpej struct devbase *d; 18055ecc953bSthorpej struct devi *i; 18065ecc953bSthorpej 18075ecc953bSthorpej d = ht_lookup(devbasetab, name); 18085ecc953bSthorpej if (d == NULL) { 1809c7295a4cSchristos cfgerror("undefined pseudo-device %s", name); 18105ecc953bSthorpej return; 18115ecc953bSthorpej } 18125ecc953bSthorpej if (!d->d_ispseudo) { 1813c7295a4cSchristos cfgerror("%s is a real device, not a pseudo-device", name); 18145ecc953bSthorpej return; 18155ecc953bSthorpej } 1816*f079f926Schristos if ((i = ht_lookup(devitab, name)) != NULL) { 1817*f079f926Schristos cfgerror("`%s' already defined at %s:%hu", name, 1818*f079f926Schristos i->i_where.w_srcfile, i->i_where.w_srcline); 18195ecc953bSthorpej return; 18205ecc953bSthorpej } 18215ecc953bSthorpej i = newdevi(name, number - 1, d); /* foo 16 => "foo0..foo15" */ 18225ecc953bSthorpej if (ht_insert(devitab, name, i)) 1823d25ad65eSchristos panic("%s: %s", __func__, name); 18247b7c582aScube /* Useful to retrieve the instance from the devbase */ 18257b7c582aScube d->d_ihead = i; 18267aa6070dScube i->i_active = DEVI_ACTIVE; 18275ecc953bSthorpej TAILQ_INSERT_TAIL(&allpseudo, i, i_next); 18285ecc953bSthorpej } 18295ecc953bSthorpej 18305ecc953bSthorpej void 18313dbd1573Schristos delpseudo(const char *name, int nowarn) 18325ecc953bSthorpej { 18335ecc953bSthorpej struct devbase *d; 18345ecc953bSthorpej 183575eb07f2Suebayasi CFGDBG(5, "deselecting pseudo `%s'", name); 18365ecc953bSthorpej d = ht_lookup(devbasetab, name); 18375ecc953bSthorpej if (d == NULL) { 18383dbd1573Schristos if (!nowarn) 1839c7295a4cSchristos cfgerror("undefined pseudo-device %s", name); 18405ecc953bSthorpej return; 18415ecc953bSthorpej } 18425ecc953bSthorpej if (!d->d_ispseudo) { 1843c7295a4cSchristos cfgerror("%s is a real device, not a pseudo-device", name); 18445ecc953bSthorpej return; 18455ecc953bSthorpej } 184611a68adeSchristos deldevbase(d); 18475ecc953bSthorpej } 18485ecc953bSthorpej 18495ecc953bSthorpej void 1850d767912bSdrochner adddevm(const char *name, devmajor_t cmajor, devmajor_t bmajor, 18519483bda7Sdholland struct condexpr *cond, struct nvlist *nv_nodes) 18525ecc953bSthorpej { 18535ecc953bSthorpej struct devm *dm; 18545ecc953bSthorpej 1855d767912bSdrochner if (cmajor != NODEVMAJOR && (cmajor < 0 || cmajor >= 4096)) { 1856c7295a4cSchristos cfgerror("character major %d is invalid", cmajor); 18579483bda7Sdholland condexpr_destroy(cond); 18583da3ab25Spooka nvfreel(nv_nodes); 18595ecc953bSthorpej return; 18605ecc953bSthorpej } 18615ecc953bSthorpej 1862d767912bSdrochner if (bmajor != NODEVMAJOR && (bmajor < 0 || bmajor >= 4096)) { 1863c7295a4cSchristos cfgerror("block major %d is invalid", bmajor); 18649483bda7Sdholland condexpr_destroy(cond); 18653da3ab25Spooka nvfreel(nv_nodes); 18665ecc953bSthorpej return; 18675ecc953bSthorpej } 1868d767912bSdrochner if (cmajor == NODEVMAJOR && bmajor == NODEVMAJOR) { 1869c7295a4cSchristos cfgerror("both character/block majors are not specified"); 18709483bda7Sdholland condexpr_destroy(cond); 18713da3ab25Spooka nvfreel(nv_nodes); 18725ecc953bSthorpej return; 18735ecc953bSthorpej } 18745ecc953bSthorpej 18755ecc953bSthorpej dm = ecalloc(1, sizeof(*dm)); 1876*f079f926Schristos dm->dm_where.w_srcfile = yyfile; 1877*f079f926Schristos dm->dm_where.w_srcline = currentline(); 18785ecc953bSthorpej dm->dm_name = name; 18795ecc953bSthorpej dm->dm_cmajor = cmajor; 18805ecc953bSthorpej dm->dm_bmajor = bmajor; 18819483bda7Sdholland dm->dm_opts = cond; 18823da3ab25Spooka dm->dm_devnodes = nv_nodes; 18835ecc953bSthorpej 18845ecc953bSthorpej TAILQ_INSERT_TAIL(&alldevms, dm, dm_next); 18855ecc953bSthorpej 18865ecc953bSthorpej maxcdevm = MAX(maxcdevm, dm->dm_cmajor); 18875ecc953bSthorpej maxbdevm = MAX(maxbdevm, dm->dm_bmajor); 18885ecc953bSthorpej } 18895ecc953bSthorpej 18907aa6070dScube int 18915ecc953bSthorpej fixdevis(void) 18925ecc953bSthorpej { 1893d25ad65eSchristos const char *msg; 18945ecc953bSthorpej struct devi *i; 1895511fbc70Schristos struct pspec *p; 18967aa6070dScube int error = 0; 18975ecc953bSthorpej 1898bc707469Suebayasi TAILQ_FOREACH(i, &alldevi, i_next) { 1899bc707469Suebayasi CFGDBG(3, "fixing devis `%s'", i->i_name); 19007aa6070dScube if (i->i_active == DEVI_ACTIVE) 19015ecc953bSthorpej selectbase(i->i_base, i->i_atdeva); 19027aa6070dScube else if (i->i_active == DEVI_ORPHAN) { 1903c130d400Scube /* 1904c130d400Scube * At this point, we can't have instances for which 1905c130d400Scube * i_at or i_pspec are NULL. 1906c130d400Scube */ 19077aa6070dScube ++error; 1908511fbc70Schristos p = i->i_pspec; 1909d25ad65eSchristos msg = p == NULL ? "no parent" : 1910d25ad65eSchristos (p->p_atunit == WILD ? "nothing matching" : "no"); 1911*f079f926Schristos cfgxerror(i->i_where.w_srcfile, i->i_where.w_srcline, 19120dbd1c0eScube "`%s at %s' is orphaned (%s `%s' found)", 1913d25ad65eSchristos i->i_name, i->i_at, msg, i->i_at); 19147aa6070dScube } else if (vflag && i->i_active == DEVI_IGNORED) 1915*f079f926Schristos cfgxwarn(i->i_where.w_srcfile, i->i_where.w_srcline, "ignoring " 1916c7295a4cSchristos "explicitly orphaned instance `%s at %s'", 1917c7295a4cSchristos i->i_name, i->i_at); 1918bc707469Suebayasi } 19197aa6070dScube 19207aa6070dScube if (error) 19217aa6070dScube return error; 19225ecc953bSthorpej 19235ecc953bSthorpej TAILQ_FOREACH(i, &allpseudo, i_next) 19247aa6070dScube if (i->i_active == DEVI_ACTIVE) 19255ecc953bSthorpej selectbase(i->i_base, NULL); 19267aa6070dScube return 0; 19275ecc953bSthorpej } 19285ecc953bSthorpej 19295ecc953bSthorpej /* 19305ecc953bSthorpej * Look up a parent spec, creating a new one if it does not exist. 19315ecc953bSthorpej */ 19325ecc953bSthorpej static struct pspec * 19334b9e5cb1Schristos getpspec(struct attr *attr, struct devbase *ab, int atunit, int first) 19345ecc953bSthorpej { 19355ecc953bSthorpej struct pspec *p; 193653be83e0Schristos int inst = npspecs; 19374b9e5cb1Schristos int ref = 1; 19385ecc953bSthorpej 19395ecc953bSthorpej TAILQ_FOREACH(p, &allpspecs, p_list) { 194053be83e0Schristos if (p->p_iattr == attr && p->p_atdev == ab && 194153be83e0Schristos p->p_atunit == atunit) { 19424b9e5cb1Schristos p->p_ref++; 19434b9e5cb1Schristos if (first) 19444b9e5cb1Schristos return p; 19454b9e5cb1Schristos else { 194653be83e0Schristos inst = p->p_inst; 19474b9e5cb1Schristos ref = p->p_ref; 19484b9e5cb1Schristos } 19494b9e5cb1Schristos 19505ecc953bSthorpej } 195153be83e0Schristos } 19525ecc953bSthorpej 19535ecc953bSthorpej p = ecalloc(1, sizeof(*p)); 19545ecc953bSthorpej 19555ecc953bSthorpej p->p_iattr = attr; 19565ecc953bSthorpej p->p_atdev = ab; 19575ecc953bSthorpej p->p_atunit = atunit; 195853be83e0Schristos p->p_inst = inst; 195953be83e0Schristos if (inst == npspecs) 196053be83e0Schristos npspecs++; 1961c130d400Scube p->p_active = 0; 19624b9e5cb1Schristos p->p_ref = ref; 19635ecc953bSthorpej 19645ecc953bSthorpej TAILQ_INSERT_TAIL(&allpspecs, p, p_list); 19655ecc953bSthorpej 19665ecc953bSthorpej return (p); 19675ecc953bSthorpej } 19685ecc953bSthorpej 19695ecc953bSthorpej /* 19705ecc953bSthorpej * Define a new instance of a specific device. 19715ecc953bSthorpej */ 19725ecc953bSthorpej static struct devi * 19735ecc953bSthorpej getdevi(const char *name) 19745ecc953bSthorpej { 19755ecc953bSthorpej struct devi *i, *firsti; 19765ecc953bSthorpej struct devbase *d; 19775ecc953bSthorpej int unit; 19785ecc953bSthorpej char base[NAMESIZE]; 19795ecc953bSthorpej 19805ecc953bSthorpej if (split(name, strlen(name), base, sizeof base, &unit)) { 1981c7295a4cSchristos cfgerror("invalid device name `%s'", name); 19825ecc953bSthorpej return (NULL); 19835ecc953bSthorpej } 19845ecc953bSthorpej d = ht_lookup(devbasetab, intern(base)); 19855ecc953bSthorpej if (d == NULL) { 1986c7295a4cSchristos cfgerror("%s: unknown device `%s'", name, base); 19875ecc953bSthorpej return (NULL); 19885ecc953bSthorpej } 19895ecc953bSthorpej if (d->d_ispseudo) { 1990c7295a4cSchristos cfgerror("%s: %s is a pseudo-device", name, base); 19915ecc953bSthorpej return (NULL); 19925ecc953bSthorpej } 19935ecc953bSthorpej firsti = ht_lookup(devitab, name); 19945ecc953bSthorpej i = newdevi(name, unit, d); 19955ecc953bSthorpej if (firsti == NULL) { 19965ecc953bSthorpej if (ht_insert(devitab, name, i)) 1997d25ad65eSchristos panic("%s: %s", __func__, name); 19985ecc953bSthorpej *d->d_ipp = i; 19995ecc953bSthorpej d->d_ipp = &i->i_bsame; 20005ecc953bSthorpej } else { 20015ecc953bSthorpej while (firsti->i_alias) 20025ecc953bSthorpej firsti = firsti->i_alias; 20035ecc953bSthorpej firsti->i_alias = i; 20045ecc953bSthorpej } 20055ecc953bSthorpej TAILQ_INSERT_TAIL(&alldevi, i, i_next); 20065ecc953bSthorpej ndevi++; 20075ecc953bSthorpej return (i); 20085ecc953bSthorpej } 20095ecc953bSthorpej 20105ecc953bSthorpej static const char * 20115ecc953bSthorpej concat(const char *name, int c) 20125ecc953bSthorpej { 2013c7295a4cSchristos size_t len; 20145ecc953bSthorpej char buf[NAMESIZE]; 20155ecc953bSthorpej 20165ecc953bSthorpej len = strlen(name); 20175ecc953bSthorpej if (len + 2 > sizeof(buf)) { 2018c7295a4cSchristos cfgerror("device name `%s%c' too long", name, c); 20195ecc953bSthorpej len = sizeof(buf) - 2; 20205ecc953bSthorpej } 20215ecc953bSthorpej memmove(buf, name, len); 20229a7f4bbaSchristos buf[len] = (char)c; 20239a7f4bbaSchristos buf[len + 1] = '\0'; 20245ecc953bSthorpej return (intern(buf)); 20255ecc953bSthorpej } 20265ecc953bSthorpej 20275ecc953bSthorpej const char * 20285ecc953bSthorpej starref(const char *name) 20295ecc953bSthorpej { 20305ecc953bSthorpej 20315ecc953bSthorpej return (concat(name, '*')); 20325ecc953bSthorpej } 20335ecc953bSthorpej 20345ecc953bSthorpej const char * 20355ecc953bSthorpej wildref(const char *name) 20365ecc953bSthorpej { 20375ecc953bSthorpej 20385ecc953bSthorpej return (concat(name, '?')); 20395ecc953bSthorpej } 20405ecc953bSthorpej 20415ecc953bSthorpej /* 20425ecc953bSthorpej * Split a name like "foo0" into base name (foo) and unit number (0). 20435ecc953bSthorpej * Return 0 on success. To make this useful for names like "foo0a", 20445ecc953bSthorpej * the length of the "foo0" part is one of the arguments. 20455ecc953bSthorpej */ 20465ecc953bSthorpej static int 20475ecc953bSthorpej split(const char *name, size_t nlen, char *base, size_t bsize, int *aunit) 20485ecc953bSthorpej { 20495ecc953bSthorpej const char *cp; 2050c7295a4cSchristos int c; 2051c7295a4cSchristos size_t l; 20525ecc953bSthorpej 20535ecc953bSthorpej l = nlen; 20545ecc953bSthorpej if (l < 2 || l >= bsize || isdigit((unsigned char)*name)) 20555ecc953bSthorpej return (1); 20565ecc953bSthorpej c = (u_char)name[--l]; 20575ecc953bSthorpej if (!isdigit(c)) { 20585ecc953bSthorpej if (c == '*') 20595ecc953bSthorpej *aunit = STAR; 20605ecc953bSthorpej else if (c == '?') 20615ecc953bSthorpej *aunit = WILD; 20625ecc953bSthorpej else 20635ecc953bSthorpej return (1); 20645ecc953bSthorpej } else { 20655ecc953bSthorpej cp = &name[l]; 20665ecc953bSthorpej while (isdigit((unsigned char)cp[-1])) 20675ecc953bSthorpej l--, cp--; 20685ecc953bSthorpej *aunit = atoi(cp); 20695ecc953bSthorpej } 20705ecc953bSthorpej memmove(base, name, l); 20715ecc953bSthorpej base[l] = 0; 20725ecc953bSthorpej return (0); 20735ecc953bSthorpej } 20745ecc953bSthorpej 20755ecc953bSthorpej void 20768d928a75Suebayasi addattr(const char *name) 20778d928a75Suebayasi { 20788d928a75Suebayasi struct attr *a; 20798d928a75Suebayasi 20808d928a75Suebayasi a = refattr(name); 20818d928a75Suebayasi selectattr(a); 20828d928a75Suebayasi } 20838d928a75Suebayasi 20848d928a75Suebayasi void 20853dbd1573Schristos delattr(const char *name, int nowarn) 20868d928a75Suebayasi { 20878d928a75Suebayasi struct attr *a; 20888d928a75Suebayasi 20898d928a75Suebayasi a = refattr(name); 20908d928a75Suebayasi deselectattr(a); 20918d928a75Suebayasi } 20928d928a75Suebayasi 20938d928a75Suebayasi void 20945ecc953bSthorpej selectattr(struct attr *a) 20955ecc953bSthorpej { 20963a03bee6Suebayasi struct attrlist *al; 20973a03bee6Suebayasi struct attr *dep; 20985ecc953bSthorpej 20998d928a75Suebayasi CFGDBG(5, "selecting attr `%s'", a->a_name); 21003a03bee6Suebayasi for (al = a->a_deps; al != NULL; al = al->al_next) { 21013a03bee6Suebayasi dep = al->al_this; 21023a03bee6Suebayasi selectattr(dep); 21033a03bee6Suebayasi } 2104d6687201Suebayasi if (ht_insert(selecttab, a->a_name, __UNCONST(a->a_name)) == 0) 2105d6687201Suebayasi nattrs++; 2106b599bf99Suebayasi CFGDBG(3, "attr selected `%s'", a->a_name); 21075ecc953bSthorpej } 21085ecc953bSthorpej 21096d1bba4aSuebayasi static int 21108d928a75Suebayasi deselectattrcb2(const char *name1, const char *name2, void *v, void *arg) 21118d928a75Suebayasi { 211211a68adeSchristos struct attr *a = arg; 211311a68adeSchristos const char *name = a->a_name; 211411a68adeSchristos struct vtype *vt = v; 21158d928a75Suebayasi 211611a68adeSchristos if (strcmp(name, name2) == 0) { 21173dbd1573Schristos delattr(name1, 0); 21188d928a75Suebayasi return 0; 21198d928a75Suebayasi } 21208d928a75Suebayasi 212111a68adeSchristos if (!vt->attr->a_deselected) 212211a68adeSchristos return 0; 212311a68adeSchristos 212411a68adeSchristos switch (vt->type) { 212511a68adeSchristos case V_ATTRIBUTE: 212611a68adeSchristos #ifdef notyet 212711a68adeSchristos // XXX: Loops 212811a68adeSchristos deselectattr(vt->value); 212911a68adeSchristos #endif 213011a68adeSchristos break; 213111a68adeSchristos case V_DEVICE: 213211a68adeSchristos CFGDBG(5, "removing device `%s' with attr `%s' because attr `%s'" 213311a68adeSchristos " is deselected", name1, name2, name); 213411a68adeSchristos deldevbase(vt->value); 213511a68adeSchristos break; 213611a68adeSchristos default: 213711a68adeSchristos abort(); 213811a68adeSchristos } 213911a68adeSchristos return 0; 214011a68adeSchristos } 214111a68adeSchristos 21428d928a75Suebayasi void 21438d928a75Suebayasi deselectattr(struct attr *a) 21448d928a75Suebayasi { 21458d928a75Suebayasi CFGDBG(5, "deselecting attr `%s'", a->a_name); 214611a68adeSchristos a->a_deselected = 1; 214711a68adeSchristos ht_enumerate2(attrdeptab, deselectattrcb2, a); 2148d6687201Suebayasi if (ht_remove(selecttab, a->a_name) == 0) 2149d6687201Suebayasi nattrs--; 21508d928a75Suebayasi CFGDBG(3, "attr deselected `%s'", a->a_name); 21518d928a75Suebayasi } 21528d928a75Suebayasi 21538d928a75Suebayasi static int 21546d1bba4aSuebayasi dumpattrdepcb2(const char *name1, const char *name2, void *v, void *arg) 21556d1bba4aSuebayasi { 21566d1bba4aSuebayasi 21576d1bba4aSuebayasi CFGDBG(3, "attr `%s' depends on attr `%s'", name1, name2); 21586d1bba4aSuebayasi return 0; 21596d1bba4aSuebayasi } 21606d1bba4aSuebayasi 21616d1bba4aSuebayasi void 21626d1bba4aSuebayasi dependattrs(void) 21636d1bba4aSuebayasi { 21646d1bba4aSuebayasi 21656d1bba4aSuebayasi ht_enumerate2(attrdeptab, dumpattrdepcb2, NULL); 21666d1bba4aSuebayasi } 21676d1bba4aSuebayasi 21685ecc953bSthorpej /* 21695ecc953bSthorpej * We have an instance of the base foo, so select it and all its 21705ecc953bSthorpej * attributes for "optional foo". 21715ecc953bSthorpej */ 21725ecc953bSthorpej static void 21735ecc953bSthorpej selectbase(struct devbase *d, struct deva *da) 21745ecc953bSthorpej { 21755ecc953bSthorpej struct attr *a; 21764caf067bSdholland struct attrlist *al; 21775ecc953bSthorpej 2178c7295a4cSchristos (void)ht_insert(selecttab, d->d_name, __UNCONST(d->d_name)); 2179b599bf99Suebayasi CFGDBG(3, "devbase selected `%s'", d->d_name); 21806d1bba4aSuebayasi CFGDBG(5, "selecting dependencies of devbase `%s'", d->d_name); 21814caf067bSdholland for (al = d->d_attrs; al != NULL; al = al->al_next) { 21824caf067bSdholland a = al->al_this; 21835ecc953bSthorpej expandattr(a, selectattr); 21845ecc953bSthorpej } 2185da706167Suebayasi 2186da706167Suebayasi struct attr *devattr; 2187da706167Suebayasi devattr = refattr(d->d_name); 2188da706167Suebayasi expandattr(devattr, selectattr); 2189da706167Suebayasi 21905ecc953bSthorpej if (da != NULL) { 2191c7295a4cSchristos (void)ht_insert(selecttab, da->d_name, __UNCONST(da->d_name)); 2192b599bf99Suebayasi CFGDBG(3, "devattr selected `%s'", da->d_name); 21934caf067bSdholland for (al = da->d_attrs; al != NULL; al = al->al_next) { 21944caf067bSdholland a = al->al_this; 21955ecc953bSthorpej expandattr(a, selectattr); 21965ecc953bSthorpej } 21975ecc953bSthorpej } 2198c4bac1d0Suebayasi 2199c4bac1d0Suebayasi fixdev(d); 22005ecc953bSthorpej } 22015ecc953bSthorpej 22025ecc953bSthorpej /* 22035ecc953bSthorpej * Is the given pointer on the given list of pointers? 22045ecc953bSthorpej */ 220559c94545Scube int 22065ecc953bSthorpej onlist(struct nvlist *nv, void *ptr) 22075ecc953bSthorpej { 22085ecc953bSthorpej for (; nv != NULL; nv = nv->nv_next) 22095ecc953bSthorpej if (nv->nv_ptr == ptr) 22105ecc953bSthorpej return (1); 22115ecc953bSthorpej return (0); 22125ecc953bSthorpej } 22135ecc953bSthorpej 22145ecc953bSthorpej static char * 22155ecc953bSthorpej extend(char *p, const char *name) 22165ecc953bSthorpej { 2217c7295a4cSchristos size_t l; 22185ecc953bSthorpej 22195ecc953bSthorpej l = strlen(name); 22205ecc953bSthorpej memmove(p, name, l); 22215ecc953bSthorpej p += l; 22225ecc953bSthorpej *p++ = ','; 22235ecc953bSthorpej *p++ = ' '; 22245ecc953bSthorpej return (p); 22255ecc953bSthorpej } 22265ecc953bSthorpej 22275ecc953bSthorpej /* 22285ecc953bSthorpej * Check that we got all required locators, and default any that are 22295ecc953bSthorpej * given as "?" and have defaults. Return 0 on success. 22305ecc953bSthorpej */ 22315ecc953bSthorpej static const char ** 223216a8771bSdholland fixloc(const char *name, struct attr *attr, struct loclist *got) 22335ecc953bSthorpej { 223416a8771bSdholland struct loclist *m, *n; 22355ecc953bSthorpej int ord; 22365ecc953bSthorpej const char **lp; 22375ecc953bSthorpej int nmissing, nextra, nnodefault; 22385ecc953bSthorpej char *mp, *ep, *ndp; 22395ecc953bSthorpej char missing[1000], extra[1000], nodefault[1000]; 22405ecc953bSthorpej static const char *nullvec[1]; 22415ecc953bSthorpej 22425ecc953bSthorpej /* 22435ecc953bSthorpej * Look for all required locators, and number the given ones 22445ecc953bSthorpej * according to the required order. While we are numbering, 22455ecc953bSthorpej * set default values for defaulted locators. 22465ecc953bSthorpej */ 22475ecc953bSthorpej if (attr->a_loclen == 0) /* e.g., "at root" */ 22485ecc953bSthorpej lp = nullvec; 22495ecc953bSthorpej else 22509a7f4bbaSchristos lp = emalloc((size_t)(attr->a_loclen + 1) * sizeof(const char *)); 225116a8771bSdholland for (n = got; n != NULL; n = n->ll_next) 225216a8771bSdholland n->ll_num = -1; 22535ecc953bSthorpej nmissing = 0; 22545ecc953bSthorpej mp = missing; 22555ecc953bSthorpej /* yes, this is O(mn), but m and n should be small */ 225616a8771bSdholland for (ord = 0, m = attr->a_locs; m != NULL; m = m->ll_next, ord++) { 225716a8771bSdholland for (n = got; n != NULL; n = n->ll_next) { 225816a8771bSdholland if (n->ll_name == m->ll_name) { 225916a8771bSdholland n->ll_num = ord; 22605ecc953bSthorpej break; 22615ecc953bSthorpej } 22625ecc953bSthorpej } 226316a8771bSdholland if (n == NULL && m->ll_num == 0) { 22645ecc953bSthorpej nmissing++; 226516a8771bSdholland mp = extend(mp, m->ll_name); 22665ecc953bSthorpej } 226716a8771bSdholland lp[ord] = m->ll_string; 22685ecc953bSthorpej } 22695ecc953bSthorpej if (ord != attr->a_loclen) 2270d25ad65eSchristos panic("%s: bad length", __func__); 22715ecc953bSthorpej lp[ord] = NULL; 22725ecc953bSthorpej nextra = 0; 22735ecc953bSthorpej ep = extra; 22745ecc953bSthorpej nnodefault = 0; 22755ecc953bSthorpej ndp = nodefault; 227616a8771bSdholland for (n = got; n != NULL; n = n->ll_next) { 227716a8771bSdholland if (n->ll_num >= 0) { 227816a8771bSdholland if (n->ll_string != NULL) 227916a8771bSdholland lp[n->ll_num] = n->ll_string; 228016a8771bSdholland else if (lp[n->ll_num] == NULL) { 22815ecc953bSthorpej nnodefault++; 228216a8771bSdholland ndp = extend(ndp, n->ll_name); 22835ecc953bSthorpej } 22845ecc953bSthorpej } else { 22855ecc953bSthorpej nextra++; 228616a8771bSdholland ep = extend(ep, n->ll_name); 22875ecc953bSthorpej } 22885ecc953bSthorpej } 22895ecc953bSthorpej if (nextra) { 22905ecc953bSthorpej ep[-2] = 0; /* kill ", " */ 2291c7295a4cSchristos cfgerror("%s: extraneous locator%s: %s", 22925ecc953bSthorpej name, nextra > 1 ? "s" : "", extra); 22935ecc953bSthorpej } 22945ecc953bSthorpej if (nmissing) { 22955ecc953bSthorpej mp[-2] = 0; 2296c7295a4cSchristos cfgerror("%s: must specify %s", name, missing); 22975ecc953bSthorpej } 22985ecc953bSthorpej if (nnodefault) { 22995ecc953bSthorpej ndp[-2] = 0; 2300c7295a4cSchristos cfgerror("%s: cannot wildcard %s", name, nodefault); 23015ecc953bSthorpej } 23025ecc953bSthorpej if (nmissing || nnodefault) { 23035ecc953bSthorpej free(lp); 23045ecc953bSthorpej lp = NULL; 23055ecc953bSthorpej } 23065ecc953bSthorpej return (lp); 23075ecc953bSthorpej } 2308437f8925Scube 2309437f8925Scube void 2310437f8925Scube setversion(int newver) 2311437f8925Scube { 2312437f8925Scube if (newver > CONFIG_VERSION) 2313c7295a4cSchristos cfgerror("your sources require a newer version of config(1) " 2314437f8925Scube "-- please rebuild it."); 2315437f8925Scube else if (newver < CONFIG_MINVERSION) 2316c7295a4cSchristos cfgerror("your sources are out of date -- please update."); 2317437f8925Scube else 2318437f8925Scube version = newver; 2319437f8925Scube } 2320