1*c3414672Scube /* $NetBSD: sem.c,v 1.4 2005/07/25 22:31:07 cube 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 475ecc953bSthorpej #include <sys/param.h> 485ecc953bSthorpej #include <ctype.h> 495ecc953bSthorpej #include <stdio.h> 505ecc953bSthorpej #include <stdlib.h> 515ecc953bSthorpej #include <string.h> 525ecc953bSthorpej #include "defs.h" 535ecc953bSthorpej #include "sem.h" 545ecc953bSthorpej 555ecc953bSthorpej /* 565ecc953bSthorpej * config semantics. 575ecc953bSthorpej */ 585ecc953bSthorpej 595ecc953bSthorpej #define NAMESIZE 100 /* local name buffers */ 605ecc953bSthorpej 615ecc953bSthorpej const char *s_ifnet; /* magic attribute */ 625ecc953bSthorpej const char *s_qmark; 635ecc953bSthorpej const char *s_none; 645ecc953bSthorpej 655ecc953bSthorpej static struct hashtab *cfhashtab; /* for config lookup */ 665ecc953bSthorpej struct hashtab *devitab; /* etc */ 675ecc953bSthorpej 685ecc953bSthorpej static struct attr errattr; 695ecc953bSthorpej static struct devbase errdev; 705ecc953bSthorpej static struct deva errdeva; 715ecc953bSthorpej 725ecc953bSthorpej static int has_errobj(struct nvlist *, void *); 735ecc953bSthorpej static struct nvlist *addtoattr(struct nvlist *, struct devbase *); 745ecc953bSthorpej static int resolve(struct nvlist **, const char *, const char *, 755ecc953bSthorpej struct nvlist *, int); 765ecc953bSthorpej static struct pspec *getpspec(struct attr *, struct devbase *, int); 775ecc953bSthorpej static struct devi *newdevi(const char *, int, struct devbase *d); 785ecc953bSthorpej static struct devi *getdevi(const char *); 795ecc953bSthorpej static const char *concat(const char *, int); 805ecc953bSthorpej static char *extend(char *, const char *); 815ecc953bSthorpej static int split(const char *, size_t, char *, size_t, int *); 825ecc953bSthorpej static void selectbase(struct devbase *, struct deva *); 835ecc953bSthorpej static int onlist(struct nvlist *, void *); 845ecc953bSthorpej static const char **fixloc(const char *, struct attr *, struct nvlist *); 855ecc953bSthorpej static const char *makedevstr(int, int); 865ecc953bSthorpej static const char *major2name(int); 875ecc953bSthorpej static int dev2major(struct devbase *); 885ecc953bSthorpej 895ecc953bSthorpej extern const char *yyfile; 905ecc953bSthorpej 915ecc953bSthorpej void 925ecc953bSthorpej initsem(void) 935ecc953bSthorpej { 945ecc953bSthorpej 955ecc953bSthorpej attrtab = ht_new(); 965ecc953bSthorpej errattr.a_name = "<internal>"; 975ecc953bSthorpej 985ecc953bSthorpej TAILQ_INIT(&allbases); 995ecc953bSthorpej 1005ecc953bSthorpej TAILQ_INIT(&alldevas); 1015ecc953bSthorpej 1025ecc953bSthorpej TAILQ_INIT(&allpspecs); 1035ecc953bSthorpej 1045ecc953bSthorpej cfhashtab = ht_new(); 1055ecc953bSthorpej TAILQ_INIT(&allcf); 1065ecc953bSthorpej 1075ecc953bSthorpej TAILQ_INIT(&alldevi); 1085ecc953bSthorpej errdev.d_name = "<internal>"; 1095ecc953bSthorpej 1105ecc953bSthorpej TAILQ_INIT(&allpseudo); 1115ecc953bSthorpej 1125ecc953bSthorpej TAILQ_INIT(&alldevms); 1135ecc953bSthorpej 1145ecc953bSthorpej s_ifnet = intern("ifnet"); 1155ecc953bSthorpej s_qmark = intern("?"); 1165ecc953bSthorpej s_none = intern("none"); 1175ecc953bSthorpej } 1185ecc953bSthorpej 1195ecc953bSthorpej /* Name of include file just ended (set in scan.l) */ 1205ecc953bSthorpej extern const char *lastfile; 1215ecc953bSthorpej 1225ecc953bSthorpej void 1235ecc953bSthorpej enddefs(void) 1245ecc953bSthorpej { 1255ecc953bSthorpej struct devbase *dev; 1265ecc953bSthorpej 1275ecc953bSthorpej TAILQ_FOREACH(dev, &allbases, d_next) { 1285ecc953bSthorpej if (!dev->d_isdef) { 1295ecc953bSthorpej (void)fprintf(stderr, 1305ecc953bSthorpej "%s: device `%s' used but not defined\n", 1315ecc953bSthorpej lastfile, dev->d_name); 1325ecc953bSthorpej errors++; 1335ecc953bSthorpej continue; 1345ecc953bSthorpej } 1355ecc953bSthorpej } 1365ecc953bSthorpej if (errors) { 1375ecc953bSthorpej (void)fprintf(stderr, "*** Stop.\n"); 1385ecc953bSthorpej exit(1); 1395ecc953bSthorpej } 1405ecc953bSthorpej } 1415ecc953bSthorpej 1425ecc953bSthorpej void 1435ecc953bSthorpej setdefmaxusers(int min, int def, int max) 1445ecc953bSthorpej { 1455ecc953bSthorpej 1465ecc953bSthorpej if (min < 1 || min > def || def > max) 1475ecc953bSthorpej error("maxusers must have 1 <= min (%d) <= default (%d) <= max (%d)", min, def, max); 1485ecc953bSthorpej else { 1495ecc953bSthorpej minmaxusers = min; 1505ecc953bSthorpej defmaxusers = def; 1515ecc953bSthorpej maxmaxusers = max; 1525ecc953bSthorpej } 1535ecc953bSthorpej } 1545ecc953bSthorpej 1555ecc953bSthorpej void 1565ecc953bSthorpej setmaxusers(int n) 1575ecc953bSthorpej { 1585ecc953bSthorpej 1595ecc953bSthorpej if (maxusers != 0) { 1605ecc953bSthorpej error("duplicate maxusers parameter"); 1615ecc953bSthorpej return; 1625ecc953bSthorpej } 1635ecc953bSthorpej maxusers = n; 1645ecc953bSthorpej if (n < minmaxusers) { 1655ecc953bSthorpej error("warning: minimum of %d maxusers assumed", minmaxusers); 1665ecc953bSthorpej errors--; /* take it away */ 1675ecc953bSthorpej maxusers = minmaxusers; 1685ecc953bSthorpej } else if (n > maxmaxusers) { 1695ecc953bSthorpej error("warning: maxusers (%d) > %d", n, maxmaxusers); 1705ecc953bSthorpej errors--; 1715ecc953bSthorpej } 1725ecc953bSthorpej } 1735ecc953bSthorpej 1745ecc953bSthorpej void 1755ecc953bSthorpej setident(const char *i) 1765ecc953bSthorpej { 1775ecc953bSthorpej 1785ecc953bSthorpej ident = intern(i); 1795ecc953bSthorpej } 1805ecc953bSthorpej 1815ecc953bSthorpej /* 1825ecc953bSthorpej * Define an attribute, optionally with an interface (a locator list) 1835ecc953bSthorpej * and a set of attribute-dependencies. 1845ecc953bSthorpej * 1855ecc953bSthorpej * Attribute dependencies MAY NOT be interface attributes. 1865ecc953bSthorpej * 1875ecc953bSthorpej * Since an empty locator list is logically different from "no interface", 1885ecc953bSthorpej * all locator lists include a dummy head node, which we discard here. 1895ecc953bSthorpej */ 1905ecc953bSthorpej int 1915ecc953bSthorpej defattr(const char *name, struct nvlist *locs, struct nvlist *deps, 1925ecc953bSthorpej int devclass) 1935ecc953bSthorpej { 1945ecc953bSthorpej struct attr *a, *dep; 1955ecc953bSthorpej struct nvlist *nv; 1965ecc953bSthorpej int len; 1975ecc953bSthorpej 1985ecc953bSthorpej if (locs != NULL && devclass) 1995ecc953bSthorpej panic("defattr(%s): locators and devclass", name); 2005ecc953bSthorpej 2015ecc953bSthorpej if (deps != NULL && devclass) 2025ecc953bSthorpej panic("defattr(%s): dependencies and devclass", name); 2035ecc953bSthorpej 2045ecc953bSthorpej /* 2055ecc953bSthorpej * If this attribute depends on any others, make sure none of 2065ecc953bSthorpej * the dependencies are interface attributes. 2075ecc953bSthorpej */ 2085ecc953bSthorpej for (nv = deps; nv != NULL; nv = nv->nv_next) { 2095ecc953bSthorpej dep = nv->nv_ptr; 2105ecc953bSthorpej if (dep->a_iattr) { 2115ecc953bSthorpej error("`%s' dependency `%s' is an interface attribute", 2125ecc953bSthorpej name, dep->a_name); 2135ecc953bSthorpej return (1); 2145ecc953bSthorpej } 2155ecc953bSthorpej } 2165ecc953bSthorpej 2175ecc953bSthorpej a = ecalloc(1, sizeof *a); 2185ecc953bSthorpej if (ht_insert(attrtab, name, a)) { 2195ecc953bSthorpej free(a); 2205ecc953bSthorpej error("attribute `%s' already defined", name); 2215ecc953bSthorpej nvfreel(locs); 2225ecc953bSthorpej return (1); 2235ecc953bSthorpej } 2245ecc953bSthorpej 2255ecc953bSthorpej a->a_name = name; 2265ecc953bSthorpej if (locs != NULL) { 2275ecc953bSthorpej a->a_iattr = 1; 2285ecc953bSthorpej a->a_locs = locs->nv_next; 2295ecc953bSthorpej nvfree(locs); 2305ecc953bSthorpej } else { 2315ecc953bSthorpej a->a_iattr = 0; 2325ecc953bSthorpej a->a_locs = NULL; 2335ecc953bSthorpej } 2345ecc953bSthorpej if (devclass) { 2355ecc953bSthorpej size_t l = strlen(name) + 4; 2365ecc953bSthorpej char *classenum = alloca(l), *cp; 2375ecc953bSthorpej int errored = 0; 2385ecc953bSthorpej 2395ecc953bSthorpej strlcpy(classenum, "DV_", l); 2405ecc953bSthorpej strlcat(classenum, name, l); 2415ecc953bSthorpej for (cp = classenum + 3; *cp; cp++) { 2425ecc953bSthorpej if (!errored && 2435ecc953bSthorpej (!isalnum((unsigned char)*cp) || 2445ecc953bSthorpej (isalpha((unsigned char)*cp) && !islower((unsigned char)*cp)))) { 2455ecc953bSthorpej error("device class names must be lower-case alphanumeric characters"); 2465ecc953bSthorpej errored = 1; 2475ecc953bSthorpej } 2485ecc953bSthorpej *cp = toupper((unsigned char)*cp); 2495ecc953bSthorpej } 2505ecc953bSthorpej a->a_devclass = intern(classenum); 2515ecc953bSthorpej } else 2525ecc953bSthorpej a->a_devclass = NULL; 2535ecc953bSthorpej len = 0; 2545ecc953bSthorpej for (nv = a->a_locs; nv != NULL; nv = nv->nv_next) 2555ecc953bSthorpej len++; 2565ecc953bSthorpej a->a_loclen = len; 2575ecc953bSthorpej a->a_devs = NULL; 2585ecc953bSthorpej a->a_refs = NULL; 2595ecc953bSthorpej a->a_deps = deps; 2605ecc953bSthorpej a->a_expanding = 0; 2615ecc953bSthorpej 2625ecc953bSthorpej /* Expand the attribute to check for cycles in the graph. */ 2635ecc953bSthorpej expandattr(a, NULL); 2645ecc953bSthorpej 2655ecc953bSthorpej return (0); 2665ecc953bSthorpej } 2675ecc953bSthorpej 2685ecc953bSthorpej /* 2695ecc953bSthorpej * Return true if the given `error object' is embedded in the given 2705ecc953bSthorpej * pointer list. 2715ecc953bSthorpej */ 2725ecc953bSthorpej static int 2735ecc953bSthorpej has_errobj(struct nvlist *nv, void *obj) 2745ecc953bSthorpej { 2755ecc953bSthorpej 2765ecc953bSthorpej for (; nv != NULL; nv = nv->nv_next) 2775ecc953bSthorpej if (nv->nv_ptr == obj) 2785ecc953bSthorpej return (1); 2795ecc953bSthorpej return (0); 2805ecc953bSthorpej } 2815ecc953bSthorpej 2825ecc953bSthorpej /* 2835ecc953bSthorpej * Return true if the given attribute is embedded in the given 2845ecc953bSthorpej * pointer list. 2855ecc953bSthorpej */ 2865ecc953bSthorpej int 2875ecc953bSthorpej has_attr(struct nvlist *nv, const char *attr) 2885ecc953bSthorpej { 2895ecc953bSthorpej struct attr *a; 2905ecc953bSthorpej 2915ecc953bSthorpej if ((a = getattr(attr)) == NULL) 2925ecc953bSthorpej return (0); 2935ecc953bSthorpej 2945ecc953bSthorpej for (; nv != NULL; nv = nv->nv_next) 2955ecc953bSthorpej if (nv->nv_ptr == a) 2965ecc953bSthorpej return (1); 2975ecc953bSthorpej return (0); 2985ecc953bSthorpej } 2995ecc953bSthorpej 3005ecc953bSthorpej /* 3015ecc953bSthorpej * Add a device base to a list in an attribute (actually, to any list). 3025ecc953bSthorpej * Note that this does not check for duplicates, and does reverse the 3035ecc953bSthorpej * list order, but no one cares anyway. 3045ecc953bSthorpej */ 3055ecc953bSthorpej static struct nvlist * 3065ecc953bSthorpej addtoattr(struct nvlist *l, struct devbase *dev) 3075ecc953bSthorpej { 3085ecc953bSthorpej struct nvlist *n; 3095ecc953bSthorpej 3105ecc953bSthorpej n = newnv(NULL, NULL, dev, 0, l); 3115ecc953bSthorpej return (n); 3125ecc953bSthorpej } 3135ecc953bSthorpej 3145ecc953bSthorpej /* 3155ecc953bSthorpej * Define a device. This may (or may not) also define an interface 3165ecc953bSthorpej * attribute and/or refer to existing attributes. 3175ecc953bSthorpej */ 3185ecc953bSthorpej void 3195ecc953bSthorpej defdev(struct devbase *dev, struct nvlist *loclist, struct nvlist *attrs, 3205ecc953bSthorpej int ispseudo) 3215ecc953bSthorpej { 3225ecc953bSthorpej struct nvlist *nv; 3235ecc953bSthorpej struct attr *a; 3245ecc953bSthorpej 3255ecc953bSthorpej if (dev == &errdev) 3265ecc953bSthorpej goto bad; 3275ecc953bSthorpej if (dev->d_isdef) { 3285ecc953bSthorpej error("redefinition of `%s'", dev->d_name); 3295ecc953bSthorpej goto bad; 3305ecc953bSthorpej } 3315ecc953bSthorpej 3325ecc953bSthorpej dev->d_isdef = 1; 3335ecc953bSthorpej if (has_errobj(attrs, &errattr)) 3345ecc953bSthorpej goto bad; 3355ecc953bSthorpej 3365ecc953bSthorpej /* 3375ecc953bSthorpej * Handle implicit attribute definition from locator list. Do 3385ecc953bSthorpej * this before scanning the `at' list so that we can have, e.g.: 3395ecc953bSthorpej * device foo at other, foo { slot = -1 } 3405ecc953bSthorpej * (where you can plug in a foo-bus extender to a foo-bus). 3415ecc953bSthorpej */ 3425ecc953bSthorpej if (loclist != NULL) { 3435ecc953bSthorpej nv = loclist; 3445ecc953bSthorpej loclist = NULL; /* defattr disposes of them for us */ 3455ecc953bSthorpej if (defattr(dev->d_name, nv, NULL, 0)) 3465ecc953bSthorpej goto bad; 3475ecc953bSthorpej attrs = newnv(dev->d_name, NULL, getattr(dev->d_name), 0, 3485ecc953bSthorpej attrs); 3495ecc953bSthorpej } 3505ecc953bSthorpej 3515ecc953bSthorpej /* Committed! Set up fields. */ 3525ecc953bSthorpej dev->d_ispseudo = ispseudo; 3535ecc953bSthorpej dev->d_attrs = attrs; 3545ecc953bSthorpej dev->d_classattr = NULL; /* for now */ 3555ecc953bSthorpej 3565ecc953bSthorpej /* 3575ecc953bSthorpej * For each interface attribute this device refers to, add this 3585ecc953bSthorpej * device to its reference list. This makes, e.g., finding all 3595ecc953bSthorpej * "scsi"s easier. 3605ecc953bSthorpej * 3615ecc953bSthorpej * While looking through the attributes, set up the device 3625ecc953bSthorpej * class if any are devclass attributes (and error out if the 3635ecc953bSthorpej * device has two classes). 3645ecc953bSthorpej */ 3655ecc953bSthorpej for (nv = attrs; nv != NULL; nv = nv->nv_next) { 3665ecc953bSthorpej a = nv->nv_ptr; 3675ecc953bSthorpej if (a->a_iattr) 3685ecc953bSthorpej a->a_refs = addtoattr(a->a_refs, dev); 3695ecc953bSthorpej if (a->a_devclass != NULL) { 3705ecc953bSthorpej if (dev->d_classattr != NULL) { 3715ecc953bSthorpej error("device `%s' has multiple classes (`%s' and `%s')", 3725ecc953bSthorpej dev->d_name, dev->d_classattr->a_name, 3735ecc953bSthorpej a->a_name); 3745ecc953bSthorpej } 3755ecc953bSthorpej dev->d_classattr = a; 3765ecc953bSthorpej } 3775ecc953bSthorpej } 3785ecc953bSthorpej return; 3795ecc953bSthorpej bad: 3805ecc953bSthorpej nvfreel(loclist); 3815ecc953bSthorpej nvfreel(attrs); 3825ecc953bSthorpej } 3835ecc953bSthorpej 3845ecc953bSthorpej /* 3855ecc953bSthorpej * Look up a devbase. Also makes sure it is a reasonable name, 3865ecc953bSthorpej * i.e., does not end in a digit or contain special characters. 3875ecc953bSthorpej */ 3885ecc953bSthorpej struct devbase * 3895ecc953bSthorpej getdevbase(const char *name) 3905ecc953bSthorpej { 3915ecc953bSthorpej u_char *p; 3925ecc953bSthorpej struct devbase *dev; 3935ecc953bSthorpej 3945ecc953bSthorpej p = (u_char *)name; 3955ecc953bSthorpej if (!isalpha(*p)) 3965ecc953bSthorpej goto badname; 3975ecc953bSthorpej while (*++p) { 3985ecc953bSthorpej if (!isalnum(*p) && *p != '_') 3995ecc953bSthorpej goto badname; 4005ecc953bSthorpej } 4015ecc953bSthorpej if (isdigit(*--p)) { 4025ecc953bSthorpej badname: 4035ecc953bSthorpej error("bad device base name `%s'", name); 4045ecc953bSthorpej return (&errdev); 4055ecc953bSthorpej } 4065ecc953bSthorpej dev = ht_lookup(devbasetab, name); 4075ecc953bSthorpej if (dev == NULL) { 4085ecc953bSthorpej dev = ecalloc(1, sizeof *dev); 4095ecc953bSthorpej dev->d_name = name; 4105ecc953bSthorpej dev->d_isdef = 0; 4115ecc953bSthorpej dev->d_major = NODEV; 4125ecc953bSthorpej dev->d_attrs = NULL; 4135ecc953bSthorpej dev->d_ihead = NULL; 4145ecc953bSthorpej dev->d_ipp = &dev->d_ihead; 4155ecc953bSthorpej dev->d_ahead = NULL; 4165ecc953bSthorpej dev->d_app = &dev->d_ahead; 4175ecc953bSthorpej dev->d_umax = 0; 4185ecc953bSthorpej TAILQ_INSERT_TAIL(&allbases, dev, d_next); 4195ecc953bSthorpej if (ht_insert(devbasetab, name, dev)) 4205ecc953bSthorpej panic("getdevbase(%s)", name); 4215ecc953bSthorpej } 4225ecc953bSthorpej return (dev); 4235ecc953bSthorpej } 4245ecc953bSthorpej 4255ecc953bSthorpej /* 4265ecc953bSthorpej * Define some of a device's allowable parent attachments. 4275ecc953bSthorpej * There may be a list of (plain) attributes. 4285ecc953bSthorpej */ 4295ecc953bSthorpej void 4305ecc953bSthorpej defdevattach(struct deva *deva, struct devbase *dev, struct nvlist *atlist, 4315ecc953bSthorpej struct nvlist *attrs) 4325ecc953bSthorpej { 4335ecc953bSthorpej struct nvlist *nv; 4345ecc953bSthorpej struct attr *a; 4355ecc953bSthorpej struct deva *da; 4365ecc953bSthorpej 4375ecc953bSthorpej if (dev == &errdev) 4385ecc953bSthorpej goto bad; 4395ecc953bSthorpej if (deva == NULL) 4405ecc953bSthorpej deva = getdevattach(dev->d_name); 4415ecc953bSthorpej if (deva == &errdeva) 4425ecc953bSthorpej goto bad; 4435ecc953bSthorpej if (!dev->d_isdef) { 4445ecc953bSthorpej error("attaching undefined device `%s'", dev->d_name); 4455ecc953bSthorpej goto bad; 4465ecc953bSthorpej } 4475ecc953bSthorpej if (deva->d_isdef) { 4485ecc953bSthorpej error("redefinition of `%s'", deva->d_name); 4495ecc953bSthorpej goto bad; 4505ecc953bSthorpej } 4515ecc953bSthorpej if (dev->d_ispseudo) { 4525ecc953bSthorpej error("pseudo-devices can't attach"); 4535ecc953bSthorpej goto bad; 4545ecc953bSthorpej } 4555ecc953bSthorpej 4565ecc953bSthorpej deva->d_isdef = 1; 4575ecc953bSthorpej if (has_errobj(attrs, &errattr)) 4585ecc953bSthorpej goto bad; 4595ecc953bSthorpej for (nv = attrs; nv != NULL; nv = nv->nv_next) { 4605ecc953bSthorpej a = nv->nv_ptr; 4615ecc953bSthorpej if (a == &errattr) 4625ecc953bSthorpej continue; /* already complained */ 4635ecc953bSthorpej if (a->a_iattr || a->a_devclass != NULL) 4645ecc953bSthorpej error("`%s' is not a plain attribute", a->a_name); 4655ecc953bSthorpej } 4665ecc953bSthorpej 4675ecc953bSthorpej /* Committed! Set up fields. */ 4685ecc953bSthorpej deva->d_attrs = attrs; 4695ecc953bSthorpej deva->d_atlist = atlist; 4705ecc953bSthorpej deva->d_devbase = dev; 4715ecc953bSthorpej 4725ecc953bSthorpej /* 4735ecc953bSthorpej * Turn the `at' list into interface attributes (map each 4745ecc953bSthorpej * nv_name to an attribute, or to NULL for root), and add 4755ecc953bSthorpej * this device to those attributes, so that children can 4765ecc953bSthorpej * be listed at this particular device if they are supported 4775ecc953bSthorpej * by that attribute. 4785ecc953bSthorpej */ 4795ecc953bSthorpej for (nv = atlist; nv != NULL; nv = nv->nv_next) { 4805ecc953bSthorpej if (nv->nv_name == NULL) 4815ecc953bSthorpej nv->nv_ptr = a = NULL; /* at root */ 4825ecc953bSthorpej else 4835ecc953bSthorpej nv->nv_ptr = a = getattr(nv->nv_name); 4845ecc953bSthorpej if (a == &errattr) 4855ecc953bSthorpej continue; /* already complained */ 4865ecc953bSthorpej 4875ecc953bSthorpej /* 4885ecc953bSthorpej * Make sure that an attachment spec doesn't 4895ecc953bSthorpej * already say how to attach to this attribute. 4905ecc953bSthorpej */ 4915ecc953bSthorpej for (da = dev->d_ahead; da != NULL; da = da->d_bsame) 4925ecc953bSthorpej if (onlist(da->d_atlist, a)) 4935ecc953bSthorpej error("attach at `%s' already done by `%s'", 4945ecc953bSthorpej a ? a->a_name : "root", da->d_name); 4955ecc953bSthorpej 4965ecc953bSthorpej if (a == NULL) 4975ecc953bSthorpej continue; /* at root; don't add */ 4985ecc953bSthorpej if (!a->a_iattr) 4995ecc953bSthorpej error("%s cannot be at plain attribute `%s'", 5005ecc953bSthorpej dev->d_name, a->a_name); 5015ecc953bSthorpej else 5025ecc953bSthorpej a->a_devs = addtoattr(a->a_devs, dev); 5035ecc953bSthorpej } 5045ecc953bSthorpej 5055ecc953bSthorpej /* attach to parent */ 5065ecc953bSthorpej *dev->d_app = deva; 5075ecc953bSthorpej dev->d_app = &deva->d_bsame; 5085ecc953bSthorpej return; 5095ecc953bSthorpej bad: 5105ecc953bSthorpej nvfreel(atlist); 5115ecc953bSthorpej nvfreel(attrs); 5125ecc953bSthorpej } 5135ecc953bSthorpej 5145ecc953bSthorpej /* 5155ecc953bSthorpej * Look up a device attachment. Also makes sure it is a reasonable 5165ecc953bSthorpej * name, i.e., does not contain digits or special characters. 5175ecc953bSthorpej */ 5185ecc953bSthorpej struct deva * 5195ecc953bSthorpej getdevattach(const char *name) 5205ecc953bSthorpej { 5215ecc953bSthorpej u_char *p; 5225ecc953bSthorpej struct deva *deva; 5235ecc953bSthorpej 5245ecc953bSthorpej p = (u_char *)name; 5255ecc953bSthorpej if (!isalpha(*p)) 5265ecc953bSthorpej goto badname; 5275ecc953bSthorpej while (*++p) { 5285ecc953bSthorpej if (!isalnum(*p) && *p != '_') 5295ecc953bSthorpej goto badname; 5305ecc953bSthorpej } 5315ecc953bSthorpej if (isdigit(*--p)) { 5325ecc953bSthorpej badname: 5335ecc953bSthorpej error("bad device attachment name `%s'", name); 5345ecc953bSthorpej return (&errdeva); 5355ecc953bSthorpej } 5365ecc953bSthorpej deva = ht_lookup(devatab, name); 5375ecc953bSthorpej if (deva == NULL) { 5385ecc953bSthorpej deva = ecalloc(1, sizeof *deva); 5395ecc953bSthorpej deva->d_name = name; 5405ecc953bSthorpej deva->d_bsame = NULL; 5415ecc953bSthorpej deva->d_isdef = 0; 5425ecc953bSthorpej deva->d_devbase = NULL; 5435ecc953bSthorpej deva->d_atlist = NULL; 5445ecc953bSthorpej deva->d_attrs = NULL; 5455ecc953bSthorpej deva->d_ihead = NULL; 5465ecc953bSthorpej deva->d_ipp = &deva->d_ihead; 5475ecc953bSthorpej TAILQ_INSERT_TAIL(&alldevas, deva, d_next); 5485ecc953bSthorpej if (ht_insert(devatab, name, deva)) 5495ecc953bSthorpej panic("getdeva(%s)", name); 5505ecc953bSthorpej } 5515ecc953bSthorpej return (deva); 5525ecc953bSthorpej } 5535ecc953bSthorpej 5545ecc953bSthorpej /* 5555ecc953bSthorpej * Look up an attribute. 5565ecc953bSthorpej */ 5575ecc953bSthorpej struct attr * 5585ecc953bSthorpej getattr(const char *name) 5595ecc953bSthorpej { 5605ecc953bSthorpej struct attr *a; 5615ecc953bSthorpej 5625ecc953bSthorpej if ((a = ht_lookup(attrtab, name)) == NULL) { 5635ecc953bSthorpej error("undefined attribute `%s'", name); 5645ecc953bSthorpej a = &errattr; 5655ecc953bSthorpej } 5665ecc953bSthorpej return (a); 5675ecc953bSthorpej } 5685ecc953bSthorpej 5695ecc953bSthorpej /* 5705ecc953bSthorpej * Recursively expand an attribute and its dependencies, checking for 5715ecc953bSthorpej * cycles, and invoking a callback for each attribute found. 5725ecc953bSthorpej */ 5735ecc953bSthorpej void 5745ecc953bSthorpej expandattr(struct attr *a, void (*callback)(struct attr *)) 5755ecc953bSthorpej { 5765ecc953bSthorpej struct nvlist *nv; 5775ecc953bSthorpej struct attr *dep; 5785ecc953bSthorpej 5795ecc953bSthorpej if (a->a_expanding) { 5805ecc953bSthorpej error("circular dependency on attribute `%s'", a->a_name); 5815ecc953bSthorpej return; 5825ecc953bSthorpej } 5835ecc953bSthorpej 5845ecc953bSthorpej a->a_expanding = 1; 5855ecc953bSthorpej 5865ecc953bSthorpej /* First expand all of this attribute's dependencies. */ 5875ecc953bSthorpej for (nv = a->a_deps; nv != NULL; nv = nv->nv_next) { 5885ecc953bSthorpej dep = nv->nv_ptr; 5895ecc953bSthorpej expandattr(dep, callback); 5905ecc953bSthorpej } 5915ecc953bSthorpej 5925ecc953bSthorpej /* ...and now invoke the callback for ourself. */ 5935ecc953bSthorpej if (callback != NULL) 5945ecc953bSthorpej (*callback)(a); 5955ecc953bSthorpej 5965ecc953bSthorpej a->a_expanding = 0; 5975ecc953bSthorpej } 5985ecc953bSthorpej 5995ecc953bSthorpej /* 6005ecc953bSthorpej * Set the major device number for a device, so that it can be used 6015ecc953bSthorpej * as a root/dumps "on" device in a configuration. 6025ecc953bSthorpej */ 6035ecc953bSthorpej void 6045ecc953bSthorpej setmajor(struct devbase *d, int n) 6055ecc953bSthorpej { 6065ecc953bSthorpej 6075ecc953bSthorpej if (d != &errdev && d->d_major != NODEV) 6085ecc953bSthorpej error("device `%s' is already major %d", 6095ecc953bSthorpej d->d_name, d->d_major); 6105ecc953bSthorpej else 6115ecc953bSthorpej d->d_major = n; 6125ecc953bSthorpej } 6135ecc953bSthorpej 6145ecc953bSthorpej const char * 6155ecc953bSthorpej major2name(int maj) 6165ecc953bSthorpej { 6175ecc953bSthorpej struct devbase *dev; 6185ecc953bSthorpej struct devm *dm; 6195ecc953bSthorpej 6205ecc953bSthorpej if (!do_devsw) { 6215ecc953bSthorpej TAILQ_FOREACH(dev, &allbases, d_next) { 6225ecc953bSthorpej if (dev->d_major == maj) 6235ecc953bSthorpej return (dev->d_name); 6245ecc953bSthorpej } 6255ecc953bSthorpej } else { 6265ecc953bSthorpej TAILQ_FOREACH(dm, &alldevms, dm_next) { 6275ecc953bSthorpej if (dm->dm_bmajor == maj) 6285ecc953bSthorpej return (dm->dm_name); 6295ecc953bSthorpej } 6305ecc953bSthorpej } 6315ecc953bSthorpej return (NULL); 6325ecc953bSthorpej } 6335ecc953bSthorpej 6345ecc953bSthorpej int 6355ecc953bSthorpej dev2major(struct devbase *dev) 6365ecc953bSthorpej { 6375ecc953bSthorpej struct devm *dm; 6385ecc953bSthorpej 6395ecc953bSthorpej if (!do_devsw) 6405ecc953bSthorpej return (dev->d_major); 6415ecc953bSthorpej 6425ecc953bSthorpej TAILQ_FOREACH(dm, &alldevms, dm_next) { 6435ecc953bSthorpej if (strcmp(dm->dm_name, dev->d_name) == 0) 6445ecc953bSthorpej return (dm->dm_bmajor); 6455ecc953bSthorpej } 6465ecc953bSthorpej return (NODEV); 6475ecc953bSthorpej } 6485ecc953bSthorpej 6495ecc953bSthorpej /* 6505ecc953bSthorpej * Make a string description of the device at maj/min. 6515ecc953bSthorpej */ 6525ecc953bSthorpej static const char * 6535ecc953bSthorpej makedevstr(int maj, int min) 6545ecc953bSthorpej { 6555ecc953bSthorpej const char *devname; 6565ecc953bSthorpej char buf[32]; 6575ecc953bSthorpej 6585ecc953bSthorpej devname = major2name(maj); 6595ecc953bSthorpej if (devname == NULL) 6605ecc953bSthorpej (void)snprintf(buf, sizeof(buf), "<%d/%d>", maj, min); 6615ecc953bSthorpej else 6625ecc953bSthorpej (void)snprintf(buf, sizeof(buf), "%s%d%c", devname, 6635ecc953bSthorpej min / maxpartitions, (min % maxpartitions) + 'a'); 6645ecc953bSthorpej 6655ecc953bSthorpej return (intern(buf)); 6665ecc953bSthorpej } 6675ecc953bSthorpej 6685ecc953bSthorpej /* 6695ecc953bSthorpej * Map things like "ra0b" => makedev(major("ra"), 0*maxpartitions + 'b'-'a'). 6705ecc953bSthorpej * Handle the case where the device number is given but there is no 6715ecc953bSthorpej * corresponding name, and map NULL to the default. 6725ecc953bSthorpej */ 6735ecc953bSthorpej static int 6745ecc953bSthorpej resolve(struct nvlist **nvp, const char *name, const char *what, 6755ecc953bSthorpej struct nvlist *dflt, int part) 6765ecc953bSthorpej { 6775ecc953bSthorpej struct nvlist *nv; 6785ecc953bSthorpej struct devbase *dev; 6795ecc953bSthorpej const char *cp; 6805ecc953bSthorpej int maj, min, i, l; 6815ecc953bSthorpej int unit; 6825ecc953bSthorpej char buf[NAMESIZE]; 6835ecc953bSthorpej 6845ecc953bSthorpej if ((u_int)(part -= 'a') >= maxpartitions) 6855ecc953bSthorpej panic("resolve"); 6865ecc953bSthorpej if ((nv = *nvp) == NULL) { 6875ecc953bSthorpej dev_t d = NODEV; 6885ecc953bSthorpej /* 6895ecc953bSthorpej * Apply default. Easiest to do this by number. 6905ecc953bSthorpej * Make sure to retain NODEVness, if this is dflt's disposition. 6915ecc953bSthorpej */ 6925ecc953bSthorpej if (dflt->nv_int != NODEV) { 6935ecc953bSthorpej maj = major(dflt->nv_int); 6945ecc953bSthorpej min = ((minor(dflt->nv_int) / maxpartitions) * 6955ecc953bSthorpej maxpartitions) + part; 6965ecc953bSthorpej d = makedev(maj, min); 6975ecc953bSthorpej cp = makedevstr(maj, min); 6985ecc953bSthorpej } else 6995ecc953bSthorpej cp = NULL; 7005ecc953bSthorpej *nvp = nv = newnv(NULL, cp, NULL, d, NULL); 7015ecc953bSthorpej } 7025ecc953bSthorpej if (nv->nv_int != NODEV) { 7035ecc953bSthorpej /* 7045ecc953bSthorpej * By the numbers. Find the appropriate major number 7055ecc953bSthorpej * to make a name. 7065ecc953bSthorpej */ 7075ecc953bSthorpej maj = major(nv->nv_int); 7085ecc953bSthorpej min = minor(nv->nv_int); 7095ecc953bSthorpej nv->nv_str = makedevstr(maj, min); 7105ecc953bSthorpej return (0); 7115ecc953bSthorpej } 7125ecc953bSthorpej 7135ecc953bSthorpej if (nv->nv_str == NULL || nv->nv_str == s_qmark) 7145ecc953bSthorpej /* 7155ecc953bSthorpej * Wildcarded or unspecified; leave it as NODEV. 7165ecc953bSthorpej */ 7175ecc953bSthorpej return (0); 7185ecc953bSthorpej 7195ecc953bSthorpej /* 7205ecc953bSthorpej * The normal case: things like "ra2b". Check for partition 7215ecc953bSthorpej * suffix, remove it if there, and split into name ("ra") and 7225ecc953bSthorpej * unit (2). 7235ecc953bSthorpej */ 7245ecc953bSthorpej l = i = strlen(nv->nv_str); 7255ecc953bSthorpej cp = &nv->nv_str[l]; 7265ecc953bSthorpej if (l > 1 && *--cp >= 'a' && *cp < 'a' + maxpartitions && 7275ecc953bSthorpej isdigit((unsigned char)cp[-1])) { 7285ecc953bSthorpej l--; 7295ecc953bSthorpej part = *cp - 'a'; 7305ecc953bSthorpej } 7315ecc953bSthorpej cp = nv->nv_str; 7325ecc953bSthorpej if (split(cp, l, buf, sizeof buf, &unit)) { 7335ecc953bSthorpej error("%s: invalid %s device name `%s'", name, what, cp); 7345ecc953bSthorpej return (1); 7355ecc953bSthorpej } 7365ecc953bSthorpej dev = ht_lookup(devbasetab, intern(buf)); 7375ecc953bSthorpej if (dev == NULL) { 7385ecc953bSthorpej error("%s: device `%s' does not exist", name, buf); 7395ecc953bSthorpej return (1); 7405ecc953bSthorpej } 7415ecc953bSthorpej 7425ecc953bSthorpej /* 7435ecc953bSthorpej * Check for the magic network interface attribute, and 7445ecc953bSthorpej * don't bother making a device number. 7455ecc953bSthorpej */ 7465ecc953bSthorpej if (has_attr(dev->d_attrs, s_ifnet)) { 7475ecc953bSthorpej nv->nv_int = NODEV; 7485ecc953bSthorpej nv->nv_ifunit = unit; /* XXX XXX XXX */ 7495ecc953bSthorpej } else { 7505ecc953bSthorpej maj = dev2major(dev); 7515ecc953bSthorpej if (maj == NODEV) { 7525ecc953bSthorpej error("%s: can't make %s device from `%s'", 7535ecc953bSthorpej name, what, nv->nv_str); 7545ecc953bSthorpej return (1); 7555ecc953bSthorpej } 7565ecc953bSthorpej nv->nv_int = makedev(maj, unit * maxpartitions + part); 7575ecc953bSthorpej } 7585ecc953bSthorpej 7595ecc953bSthorpej nv->nv_name = dev->d_name; 7605ecc953bSthorpej return (0); 7615ecc953bSthorpej } 7625ecc953bSthorpej 7635ecc953bSthorpej /* 7645ecc953bSthorpej * Add a completed configuration to the list. 7655ecc953bSthorpej */ 7665ecc953bSthorpej void 7675ecc953bSthorpej addconf(struct config *cf0) 7685ecc953bSthorpej { 7695ecc953bSthorpej struct config *cf; 7705ecc953bSthorpej struct nvlist *nv; 7715ecc953bSthorpej const char *name; 7725ecc953bSthorpej 7735ecc953bSthorpej name = cf0->cf_name; 7745ecc953bSthorpej cf = ecalloc(1, sizeof *cf); 7755ecc953bSthorpej if (ht_insert(cfhashtab, name, cf)) { 7765ecc953bSthorpej error("configuration `%s' already defined", name); 7775ecc953bSthorpej free(cf); 7785ecc953bSthorpej goto bad; 7795ecc953bSthorpej } 7805ecc953bSthorpej *cf = *cf0; 7815ecc953bSthorpej 7825ecc953bSthorpej /* 7835ecc953bSthorpej * Resolve the root device. 7845ecc953bSthorpej */ 7855ecc953bSthorpej if (cf->cf_root->nv_str != s_qmark) { 7865ecc953bSthorpej nv = cf->cf_root; 7875ecc953bSthorpej if (nv == NULL) { 7885ecc953bSthorpej error("%s: no root device specified", name); 7895ecc953bSthorpej goto bad; 7905ecc953bSthorpej } 7915ecc953bSthorpej if (resolve(&cf->cf_root, name, "root", nv, 'a')) 7925ecc953bSthorpej goto bad; 7935ecc953bSthorpej } 7945ecc953bSthorpej 7955ecc953bSthorpej /* 7965ecc953bSthorpej * Resolve the dump device. 7975ecc953bSthorpej */ 7985ecc953bSthorpej if (cf->cf_dump == NULL || cf->cf_dump->nv_str == s_qmark) { 7995ecc953bSthorpej /* 8005ecc953bSthorpej * Wildcarded dump device is equivalent to unspecified. 8015ecc953bSthorpej */ 8025ecc953bSthorpej cf->cf_dump = NULL; 8035ecc953bSthorpej } else if (cf->cf_dump->nv_str == s_none) { 8045ecc953bSthorpej /* 8055ecc953bSthorpej * Operator has requested that no dump device should be 8065ecc953bSthorpej * configured; do nothing. 8075ecc953bSthorpej */ 8085ecc953bSthorpej } else { 8095ecc953bSthorpej if (resolve(&cf->cf_dump, name, "dumps", cf->cf_dump, 'b')) 8105ecc953bSthorpej goto bad; 8115ecc953bSthorpej } 8125ecc953bSthorpej 8135ecc953bSthorpej /* Wildcarded fstype is `unspecified'. */ 8145ecc953bSthorpej if (cf->cf_fstype == s_qmark) 8155ecc953bSthorpej cf->cf_fstype = NULL; 8165ecc953bSthorpej 8175ecc953bSthorpej TAILQ_INSERT_TAIL(&allcf, cf, cf_next); 8185ecc953bSthorpej return; 8195ecc953bSthorpej bad: 8205ecc953bSthorpej nvfreel(cf0->cf_root); 8215ecc953bSthorpej nvfreel(cf0->cf_dump); 8225ecc953bSthorpej } 8235ecc953bSthorpej 8245ecc953bSthorpej void 8255ecc953bSthorpej setconf(struct nvlist **npp, const char *what, struct nvlist *v) 8265ecc953bSthorpej { 8275ecc953bSthorpej 8285ecc953bSthorpej if (*npp != NULL) { 8295ecc953bSthorpej error("duplicate %s specification", what); 8305ecc953bSthorpej nvfreel(v); 8315ecc953bSthorpej } else 8325ecc953bSthorpej *npp = v; 8335ecc953bSthorpej } 8345ecc953bSthorpej 8355ecc953bSthorpej void 8365ecc953bSthorpej setfstype(const char **fstp, const char *v) 8375ecc953bSthorpej { 8385ecc953bSthorpej 8395ecc953bSthorpej if (*fstp != NULL) { 8405ecc953bSthorpej error("multiple fstype specifications"); 8415ecc953bSthorpej return; 8425ecc953bSthorpej } 8435ecc953bSthorpej 8445ecc953bSthorpej if (v != s_qmark && OPT_FSOPT(v)) { 8455ecc953bSthorpej error("\"%s\" is not a configured file system", v); 8465ecc953bSthorpej return; 8475ecc953bSthorpej } 8485ecc953bSthorpej 8495ecc953bSthorpej *fstp = v; 8505ecc953bSthorpej } 8515ecc953bSthorpej 8525ecc953bSthorpej static struct devi * 8535ecc953bSthorpej newdevi(const char *name, int unit, struct devbase *d) 8545ecc953bSthorpej { 8555ecc953bSthorpej struct devi *i; 8565ecc953bSthorpej 8575ecc953bSthorpej i = ecalloc(1, sizeof *i); 8585ecc953bSthorpej i->i_name = name; 8595ecc953bSthorpej i->i_unit = unit; 8605ecc953bSthorpej i->i_base = d; 8615ecc953bSthorpej i->i_bsame = NULL; 8625ecc953bSthorpej i->i_asame = NULL; 8635ecc953bSthorpej i->i_alias = NULL; 8645ecc953bSthorpej i->i_at = NULL; 8655ecc953bSthorpej i->i_pspec = NULL; 8665ecc953bSthorpej i->i_atdeva = NULL; 8675ecc953bSthorpej i->i_locs = NULL; 8685ecc953bSthorpej i->i_cfflags = 0; 8695ecc953bSthorpej i->i_lineno = currentline(); 8705ecc953bSthorpej if (unit >= d->d_umax) 8715ecc953bSthorpej d->d_umax = unit + 1; 8725ecc953bSthorpej return (i); 8735ecc953bSthorpej } 8745ecc953bSthorpej 8755ecc953bSthorpej /* 8765ecc953bSthorpej * Add the named device as attaching to the named attribute (or perhaps 8775ecc953bSthorpej * another device instead) plus unit number. 8785ecc953bSthorpej */ 8795ecc953bSthorpej void 8805ecc953bSthorpej adddev(const char *name, const char *at, struct nvlist *loclist, int flags) 8815ecc953bSthorpej { 8825ecc953bSthorpej struct devi *i; /* the new instance */ 8835ecc953bSthorpej struct pspec *p; /* and its pspec */ 8845ecc953bSthorpej struct attr *attr; /* attribute that allows attach */ 8855ecc953bSthorpej struct devbase *ib; /* i->i_base */ 8865ecc953bSthorpej struct devbase *ab; /* not NULL => at another dev */ 8875ecc953bSthorpej struct nvlist *nv; 8885ecc953bSthorpej struct deva *iba; /* devbase attachment used */ 8895ecc953bSthorpej const char *cp; 8905ecc953bSthorpej int atunit; 8915ecc953bSthorpej char atbuf[NAMESIZE]; 8925ecc953bSthorpej int hit; 8935ecc953bSthorpej 8945ecc953bSthorpej ab = NULL; 8955ecc953bSthorpej iba = NULL; 8965ecc953bSthorpej if (at == NULL) { 8975ecc953bSthorpej /* "at root" */ 8985ecc953bSthorpej p = NULL; 8995ecc953bSthorpej if ((i = getdevi(name)) == NULL) 9005ecc953bSthorpej goto bad; 9015ecc953bSthorpej /* 9025ecc953bSthorpej * Must warn about i_unit > 0 later, after taking care of 9035ecc953bSthorpej * the STAR cases (we could do non-star's here but why 9045ecc953bSthorpej * bother?). Make sure this device can be at root. 9055ecc953bSthorpej */ 9065ecc953bSthorpej ib = i->i_base; 9075ecc953bSthorpej hit = 0; 9085ecc953bSthorpej for (iba = ib->d_ahead; iba != NULL; iba = iba->d_bsame) 9095ecc953bSthorpej if (onlist(iba->d_atlist, NULL)) { 9105ecc953bSthorpej hit = 1; 9115ecc953bSthorpej break; 9125ecc953bSthorpej } 9135ecc953bSthorpej if (!hit) { 9145ecc953bSthorpej error("`%s' cannot attach to the root", ib->d_name); 9155ecc953bSthorpej goto bad; 9165ecc953bSthorpej } 9175ecc953bSthorpej attr = &errattr; /* a convenient "empty" attr */ 9185ecc953bSthorpej } else { 9195ecc953bSthorpej if (split(at, strlen(at), atbuf, sizeof atbuf, &atunit)) { 9205ecc953bSthorpej error("invalid attachment name `%s'", at); 9215ecc953bSthorpej /* (void)getdevi(name); -- ??? */ 9225ecc953bSthorpej goto bad; 9235ecc953bSthorpej } 9245ecc953bSthorpej if ((i = getdevi(name)) == NULL) 9255ecc953bSthorpej goto bad; 9265ecc953bSthorpej ib = i->i_base; 9275ecc953bSthorpej 9285ecc953bSthorpej /* 9295ecc953bSthorpej * Devices can attach to two types of things: Attributes, 9305ecc953bSthorpej * and other devices (which have the appropriate attributes 9315ecc953bSthorpej * to allow attachment). 9325ecc953bSthorpej * 9335ecc953bSthorpej * (1) If we're attached to an attribute, then we don't need 9345ecc953bSthorpej * look at the parent base device to see what attributes 9355ecc953bSthorpej * it has, and make sure that we can attach to them. 9365ecc953bSthorpej * 9375ecc953bSthorpej * (2) If we're attached to a real device (i.e. named in 9385ecc953bSthorpej * the config file), we want to remember that so that 9395ecc953bSthorpej * at cross-check time, if the device we're attached to 9405ecc953bSthorpej * is missing but other devices which also provide the 9415ecc953bSthorpej * attribute are present, we don't get a false "OK." 9425ecc953bSthorpej * 9435ecc953bSthorpej * (3) If the thing we're attached to is an attribute 9445ecc953bSthorpej * but is actually named in the config file, we still 9455ecc953bSthorpej * have to remember its devbase. 9465ecc953bSthorpej */ 9475ecc953bSthorpej cp = intern(atbuf); 9485ecc953bSthorpej 9495ecc953bSthorpej /* Figure out parent's devbase, to satisfy case (3). */ 9505ecc953bSthorpej ab = ht_lookup(devbasetab, cp); 9515ecc953bSthorpej 9525ecc953bSthorpej /* Find out if it's an attribute. */ 9535ecc953bSthorpej attr = ht_lookup(attrtab, cp); 9545ecc953bSthorpej 9555ecc953bSthorpej /* Make sure we're _really_ attached to the attr. Case (1). */ 9565ecc953bSthorpej if (attr != NULL && onlist(attr->a_devs, ib)) 9575ecc953bSthorpej goto findattachment; 9585ecc953bSthorpej 9595ecc953bSthorpej /* 9605ecc953bSthorpej * Else a real device, and not just an attribute. Case (2). 9615ecc953bSthorpej * 9625ecc953bSthorpej * Have to work a bit harder to see whether we have 9635ecc953bSthorpej * something like "tg0 at esp0" (where esp is merely 9645ecc953bSthorpej * not an attribute) or "tg0 at nonesuch0" (where 9655ecc953bSthorpej * nonesuch is not even a device). 9665ecc953bSthorpej */ 9675ecc953bSthorpej if (ab == NULL) { 9685ecc953bSthorpej error("%s at %s: `%s' unknown", 9695ecc953bSthorpej name, at, atbuf); 9705ecc953bSthorpej goto bad; 9715ecc953bSthorpej } 9725ecc953bSthorpej 9735ecc953bSthorpej /* 9745ecc953bSthorpej * See if the named parent carries an attribute 9755ecc953bSthorpej * that allows it to supervise device ib. 9765ecc953bSthorpej */ 9775ecc953bSthorpej for (nv = ab->d_attrs; nv != NULL; nv = nv->nv_next) { 9785ecc953bSthorpej attr = nv->nv_ptr; 9795ecc953bSthorpej if (onlist(attr->a_devs, ib)) 9805ecc953bSthorpej goto findattachment; 9815ecc953bSthorpej } 9825ecc953bSthorpej error("`%s' cannot attach to `%s'", ib->d_name, atbuf); 9835ecc953bSthorpej goto bad; 9845ecc953bSthorpej 9855ecc953bSthorpej findattachment: 9865ecc953bSthorpej /* 9875ecc953bSthorpej * Find the parent spec. If a matching one has not yet been 9885ecc953bSthorpej * created, create one. 9895ecc953bSthorpej */ 9905ecc953bSthorpej p = getpspec(attr, ab, atunit); 9915ecc953bSthorpej p->p_devs = newnv(NULL, NULL, i, 0, p->p_devs); 9925ecc953bSthorpej 9935ecc953bSthorpej /* find out which attachment it uses */ 9945ecc953bSthorpej hit = 0; 9955ecc953bSthorpej for (iba = ib->d_ahead; iba != NULL; iba = iba->d_bsame) 9965ecc953bSthorpej if (onlist(iba->d_atlist, attr)) { 9975ecc953bSthorpej hit = 1; 9985ecc953bSthorpej break; 9995ecc953bSthorpej } 10005ecc953bSthorpej if (!hit) 10015ecc953bSthorpej panic("adddev: can't figure out attachment"); 10025ecc953bSthorpej } 10035ecc953bSthorpej if ((i->i_locs = fixloc(name, attr, loclist)) == NULL) 10045ecc953bSthorpej goto bad; 10055ecc953bSthorpej i->i_at = at; 10065ecc953bSthorpej i->i_pspec = p; 10075ecc953bSthorpej i->i_atdeva = iba; 10085ecc953bSthorpej i->i_cfflags = flags; 10095ecc953bSthorpej 10105ecc953bSthorpej *iba->d_ipp = i; 10115ecc953bSthorpej iba->d_ipp = &i->i_asame; 10125ecc953bSthorpej 10135ecc953bSthorpej /* all done, fall into ... */ 10145ecc953bSthorpej bad: 10155ecc953bSthorpej nvfreel(loclist); 10165ecc953bSthorpej return; 10175ecc953bSthorpej } 10185ecc953bSthorpej 10195ecc953bSthorpej void 10205ecc953bSthorpej deldev(const char *name, const char *at) 10215ecc953bSthorpej { 1022e499d8b5Scube struct devi *firsti, *i, *match, *previ, **ppi; 1023e499d8b5Scube struct deva *iba; 10245ecc953bSthorpej struct devbase *d; 10255ecc953bSthorpej int unit; 10265ecc953bSthorpej char base[NAMESIZE]; 10275ecc953bSthorpej 10285ecc953bSthorpej if (split(name, strlen(name), base, sizeof base, &unit)) { 10295ecc953bSthorpej error("invalid device name `%s'", name); 10305ecc953bSthorpej return; 10315ecc953bSthorpej } 10325ecc953bSthorpej d = ht_lookup(devbasetab, intern(base)); 10335ecc953bSthorpej if (d == NULL) { 10345ecc953bSthorpej error("%s: unknown device `%s'", name, base); 10355ecc953bSthorpej return; 10365ecc953bSthorpej } 10375ecc953bSthorpej if (d->d_ispseudo) { 10385ecc953bSthorpej error("%s: %s is a pseudo-device", name, base); 10395ecc953bSthorpej return; 10405ecc953bSthorpej } 10415ecc953bSthorpej if ((firsti = ht_lookup(devitab, name)) == NULL) { 10425ecc953bSthorpej error("`%s' not defined", name); 10435ecc953bSthorpej return; 10445ecc953bSthorpej } 10455ecc953bSthorpej match = NULL; 1046e499d8b5Scube previ = NULL; 1047e499d8b5Scube if (at == NULL) 1048e499d8b5Scube /* 'at root' */ 1049e499d8b5Scube match = firsti; 1050e499d8b5Scube else { 10515ecc953bSthorpej if (strcmp(at, firsti->i_at) == 0) { 10525ecc953bSthorpej match = firsti; 10535ecc953bSthorpej } else { 1054e499d8b5Scube for (i = firsti; i != NULL; i = i->i_alias) { 10555ecc953bSthorpej if (strcmp(at, i->i_at) == 0) { 10565ecc953bSthorpej match = i; 10575ecc953bSthorpej break; 10585ecc953bSthorpej } 1059e499d8b5Scube previ = i; 10605ecc953bSthorpej } 10615ecc953bSthorpej } 10625ecc953bSthorpej if (match == NULL) { 10635ecc953bSthorpej error("`%s' at `%s' not found", name, at); 10645ecc953bSthorpej return; 10655ecc953bSthorpej } 1066e499d8b5Scube } 10675ecc953bSthorpej 1068e499d8b5Scube i = match; 1069e499d8b5Scube /* 1070e499d8b5Scube * We have the device instance, i. 1071e499d8b5Scube * We have to: 1072e499d8b5Scube * - delete the alias 1073e499d8b5Scube * 1074e499d8b5Scube * If the devi was an alias of an already listed devi, all is 1075e499d8b5Scube * good we don't have to do more. 1076e499d8b5Scube * If it was the first alias, we have to replace i's entry in 1077e499d8b5Scube * d's list by its first alias. 1078e499d8b5Scube * If it was the only entry, we must remove i's entry from d's 1079e499d8b5Scube * list. 1080e499d8b5Scube */ 1081e499d8b5Scube if (previ != NULL) 1082e499d8b5Scube previ->i_alias = i->i_alias; 1083e499d8b5Scube else { 1084e499d8b5Scube if (i->i_alias == NULL) 1085e499d8b5Scube /* No alias, must unlink the entry from devitab */ 1086e499d8b5Scube ht_remove(devitab, i->i_name); 1087e499d8b5Scube else 1088e499d8b5Scube /* Or have the first alias replace i in d's list */ 1089e499d8b5Scube i->i_alias->i_bsame = i->i_bsame; 1090e499d8b5Scube /* 1091e499d8b5Scube * - remove/replace the instance from the devbase's list 1092e499d8b5Scube * 1093e499d8b5Scube * A double-linked list would make this much easier. Oh, well, 1094e499d8b5Scube * what is done is done. 1095e499d8b5Scube */ 1096e499d8b5Scube for (ppi = &d->d_ihead; 1097e499d8b5Scube *ppi != NULL && *ppi != i && (*ppi)->i_bsame != i; 1098e499d8b5Scube ppi = &(*ppi)->i_bsame); 1099e499d8b5Scube if (*ppi == NULL) 1100*c3414672Scube panic("deldev: dev (%s) doesn't list the devi" 1101*c3414672Scube " (%s at %s)", d->d_name, i->i_name, i->i_at); 1102*c3414672Scube previ = *ppi; 1103*c3414672Scube if (previ == i) 1104*c3414672Scube /* That implies d->d_ihead == i */ 1105e499d8b5Scube *ppi = i->i_bsame; 1106e499d8b5Scube else 1107e499d8b5Scube (*ppi)->i_bsame = i->i_bsame; 1108e499d8b5Scube if (d->d_ipp == &i->i_bsame) { 1109*c3414672Scube if (previ == i) 1110e499d8b5Scube d->d_ipp = &d->d_ihead; 1111e499d8b5Scube else 1112*c3414672Scube d->d_ipp = &previ->i_bsame; 1113e499d8b5Scube } 1114e499d8b5Scube } 1115e499d8b5Scube /* 1116e499d8b5Scube * - delete the attachment instance 1117e499d8b5Scube */ 1118e499d8b5Scube iba = i->i_atdeva; 1119e499d8b5Scube for (ppi = &iba->d_ihead; 1120e499d8b5Scube *ppi != NULL && *ppi != i && (*ppi)->i_asame != i; 1121e499d8b5Scube ppi = &(*ppi)->i_asame); 1122e499d8b5Scube if (*ppi == NULL) 1123e499d8b5Scube panic("deldev: deva (%s) doesn't list the devi (%s)", 1124e499d8b5Scube iba->d_name, i->i_name); 1125*c3414672Scube previ = *ppi; 1126*c3414672Scube if (previ == i) 1127*c3414672Scube /* That implies iba->d_ihead == i */ 1128e499d8b5Scube *ppi = i->i_asame; 1129e499d8b5Scube else 1130e499d8b5Scube (*ppi)->i_asame = i->i_asame; 1131e499d8b5Scube if (iba->d_ipp == &i->i_asame) { 1132*c3414672Scube if (previ == i) 1133e499d8b5Scube iba->d_ipp = &iba->d_ihead; 1134e499d8b5Scube else 1135*c3414672Scube iba->d_ipp = &previ->i_asame; 1136e499d8b5Scube } 1137e499d8b5Scube /* 1138e499d8b5Scube * - delete the pspec 1139e499d8b5Scube */ 1140e499d8b5Scube if (i->i_pspec) { 1141e499d8b5Scube struct pspec *p = i->i_pspec; 1142e499d8b5Scube struct nvlist *nv, *onv; 1143e499d8b5Scube 1144e499d8b5Scube /* Double-linked nvlist anyone? */ 1145e499d8b5Scube for (nv = p->p_devs; nv->nv_ptr != NULL; nv = nv->nv_next) { 1146e499d8b5Scube if (nv->nv_next && nv->nv_next->nv_ptr == i) { 1147e499d8b5Scube onv = nv->nv_next; 1148e499d8b5Scube nv->nv_next = onv->nv_next; 1149e499d8b5Scube nvfree(onv); 1150e499d8b5Scube break; 1151878c29f5Scube } if (nv->nv_ptr == i) { 1152e499d8b5Scube /* nv is p->p_devs in that case */ 1153e499d8b5Scube p->p_devs = nv->nv_next; 1154e499d8b5Scube nvfree(nv); 1155e499d8b5Scube break; 1156e499d8b5Scube } 1157e499d8b5Scube } 1158e499d8b5Scube if (p->p_devs == NULL) 1159e499d8b5Scube TAILQ_REMOVE(&allpspecs, p, p_list); 1160e499d8b5Scube } 1161e499d8b5Scube /* 1162e499d8b5Scube * - delete the alldevi entry 1163e499d8b5Scube */ 1164e499d8b5Scube TAILQ_REMOVE(&alldevi, i, i_next); 1165e499d8b5Scube ndevi--; 1166e499d8b5Scube /* 1167e499d8b5Scube * - reconstuct d->d_umax 1168e499d8b5Scube */ 1169e499d8b5Scube d->d_umax = 0; 1170e499d8b5Scube for (i = d->d_ihead; i != NULL; i = i->i_bsame) 1171e499d8b5Scube if (i->i_unit >= d->d_umax) 1172e499d8b5Scube d->d_umax = i->i_unit + 1; 11735ecc953bSthorpej } 11745ecc953bSthorpej 11755ecc953bSthorpej void 11765ecc953bSthorpej addpseudo(const char *name, int number) 11775ecc953bSthorpej { 11785ecc953bSthorpej struct devbase *d; 11795ecc953bSthorpej struct devi *i; 11805ecc953bSthorpej 11815ecc953bSthorpej d = ht_lookup(devbasetab, name); 11825ecc953bSthorpej if (d == NULL) { 11835ecc953bSthorpej error("undefined pseudo-device %s", name); 11845ecc953bSthorpej return; 11855ecc953bSthorpej } 11865ecc953bSthorpej if (!d->d_ispseudo) { 11875ecc953bSthorpej error("%s is a real device, not a pseudo-device", name); 11885ecc953bSthorpej return; 11895ecc953bSthorpej } 11905ecc953bSthorpej if (ht_lookup(devitab, name) != NULL) { 11915ecc953bSthorpej error("`%s' already defined", name); 11925ecc953bSthorpej return; 11935ecc953bSthorpej } 11945ecc953bSthorpej i = newdevi(name, number - 1, d); /* foo 16 => "foo0..foo15" */ 11955ecc953bSthorpej if (ht_insert(devitab, name, i)) 11965ecc953bSthorpej panic("addpseudo(%s)", name); 11975ecc953bSthorpej TAILQ_INSERT_TAIL(&allpseudo, i, i_next); 11985ecc953bSthorpej } 11995ecc953bSthorpej 12005ecc953bSthorpej void 12015ecc953bSthorpej delpseudo(const char *name) 12025ecc953bSthorpej { 12035ecc953bSthorpej struct devbase *d; 12045ecc953bSthorpej struct devi *i; 12055ecc953bSthorpej 12065ecc953bSthorpej d = ht_lookup(devbasetab, name); 12075ecc953bSthorpej if (d == NULL) { 12085ecc953bSthorpej error("undefined pseudo-device %s", name); 12095ecc953bSthorpej return; 12105ecc953bSthorpej } 12115ecc953bSthorpej if (!d->d_ispseudo) { 12125ecc953bSthorpej error("%s is a real device, not a pseudo-device", name); 12135ecc953bSthorpej return; 12145ecc953bSthorpej } 12155ecc953bSthorpej if ((i = ht_lookup(devitab, name)) == NULL) { 12165ecc953bSthorpej error("`%s' not defined", name); 12175ecc953bSthorpej return; 12185ecc953bSthorpej } 12195ecc953bSthorpej d->d_umax = 0; /* clear neads-count entries */ 12205ecc953bSthorpej TAILQ_REMOVE(&allpseudo, i, i_next); 12215ecc953bSthorpej if (ht_remove(devitab, name)) 12225ecc953bSthorpej panic("delpseudo(%s) - can't remove from devitab", name); 12235ecc953bSthorpej } 12245ecc953bSthorpej 12255ecc953bSthorpej void 12265ecc953bSthorpej adddevm(const char *name, int cmajor, int bmajor, struct nvlist *options) 12275ecc953bSthorpej { 12285ecc953bSthorpej struct devm *dm; 12295ecc953bSthorpej 12305ecc953bSthorpej if (cmajor < -1 || cmajor >= 4096) { 12315ecc953bSthorpej error("character major %d is invalid", cmajor); 12325ecc953bSthorpej nvfreel(options); 12335ecc953bSthorpej return; 12345ecc953bSthorpej } 12355ecc953bSthorpej 12365ecc953bSthorpej if (bmajor < -1 || bmajor >= 4096) { 12375ecc953bSthorpej error("block major %d is invalid", bmajor); 12385ecc953bSthorpej nvfreel(options); 12395ecc953bSthorpej return; 12405ecc953bSthorpej } 12415ecc953bSthorpej if (cmajor == -1 && bmajor == -1) { 12425ecc953bSthorpej error("both character/block majors are not specified"); 12435ecc953bSthorpej nvfreel(options); 12445ecc953bSthorpej return; 12455ecc953bSthorpej } 12465ecc953bSthorpej 12475ecc953bSthorpej dm = ecalloc(1, sizeof(*dm)); 12485ecc953bSthorpej dm->dm_srcfile = yyfile; 12495ecc953bSthorpej dm->dm_srcline = currentline(); 12505ecc953bSthorpej dm->dm_name = name; 12515ecc953bSthorpej dm->dm_cmajor = cmajor; 12525ecc953bSthorpej dm->dm_bmajor = bmajor; 12535ecc953bSthorpej dm->dm_opts = options; 12545ecc953bSthorpej 12555ecc953bSthorpej TAILQ_INSERT_TAIL(&alldevms, dm, dm_next); 12565ecc953bSthorpej 12575ecc953bSthorpej maxcdevm = MAX(maxcdevm, dm->dm_cmajor); 12585ecc953bSthorpej maxbdevm = MAX(maxbdevm, dm->dm_bmajor); 12595ecc953bSthorpej } 12605ecc953bSthorpej 12615ecc953bSthorpej void 12625ecc953bSthorpej fixdevis(void) 12635ecc953bSthorpej { 12645ecc953bSthorpej struct devi *i; 12655ecc953bSthorpej 12665ecc953bSthorpej TAILQ_FOREACH(i, &alldevi, i_next) 12675ecc953bSthorpej selectbase(i->i_base, i->i_atdeva); 12685ecc953bSthorpej 12695ecc953bSthorpej TAILQ_FOREACH(i, &allpseudo, i_next) 12705ecc953bSthorpej selectbase(i->i_base, NULL); 12715ecc953bSthorpej } 12725ecc953bSthorpej 12735ecc953bSthorpej /* 12745ecc953bSthorpej * Look up a parent spec, creating a new one if it does not exist. 12755ecc953bSthorpej */ 12765ecc953bSthorpej static struct pspec * 12775ecc953bSthorpej getpspec(struct attr *attr, struct devbase *ab, int atunit) 12785ecc953bSthorpej { 12795ecc953bSthorpej struct pspec *p; 12805ecc953bSthorpej 12815ecc953bSthorpej TAILQ_FOREACH(p, &allpspecs, p_list) { 12825ecc953bSthorpej if (p->p_iattr == attr && 12835ecc953bSthorpej p->p_atdev == ab && 12845ecc953bSthorpej p->p_atunit == atunit) 12855ecc953bSthorpej return (p); 12865ecc953bSthorpej } 12875ecc953bSthorpej 12885ecc953bSthorpej p = ecalloc(1, sizeof(*p)); 12895ecc953bSthorpej 12905ecc953bSthorpej p->p_iattr = attr; 12915ecc953bSthorpej p->p_atdev = ab; 12925ecc953bSthorpej p->p_atunit = atunit; 12935ecc953bSthorpej p->p_inst = npspecs++; 12945ecc953bSthorpej 12955ecc953bSthorpej TAILQ_INSERT_TAIL(&allpspecs, p, p_list); 12965ecc953bSthorpej 12975ecc953bSthorpej return (p); 12985ecc953bSthorpej } 12995ecc953bSthorpej 13005ecc953bSthorpej /* 13015ecc953bSthorpej * Define a new instance of a specific device. 13025ecc953bSthorpej */ 13035ecc953bSthorpej static struct devi * 13045ecc953bSthorpej getdevi(const char *name) 13055ecc953bSthorpej { 13065ecc953bSthorpej struct devi *i, *firsti; 13075ecc953bSthorpej struct devbase *d; 13085ecc953bSthorpej int unit; 13095ecc953bSthorpej char base[NAMESIZE]; 13105ecc953bSthorpej 13115ecc953bSthorpej if (split(name, strlen(name), base, sizeof base, &unit)) { 13125ecc953bSthorpej error("invalid device name `%s'", name); 13135ecc953bSthorpej return (NULL); 13145ecc953bSthorpej } 13155ecc953bSthorpej d = ht_lookup(devbasetab, intern(base)); 13165ecc953bSthorpej if (d == NULL) { 13175ecc953bSthorpej error("%s: unknown device `%s'", name, base); 13185ecc953bSthorpej return (NULL); 13195ecc953bSthorpej } 13205ecc953bSthorpej if (d->d_ispseudo) { 13215ecc953bSthorpej error("%s: %s is a pseudo-device", name, base); 13225ecc953bSthorpej return (NULL); 13235ecc953bSthorpej } 13245ecc953bSthorpej firsti = ht_lookup(devitab, name); 13255ecc953bSthorpej i = newdevi(name, unit, d); 13265ecc953bSthorpej if (firsti == NULL) { 13275ecc953bSthorpej if (ht_insert(devitab, name, i)) 13285ecc953bSthorpej panic("getdevi(%s)", name); 13295ecc953bSthorpej *d->d_ipp = i; 13305ecc953bSthorpej d->d_ipp = &i->i_bsame; 13315ecc953bSthorpej } else { 13325ecc953bSthorpej while (firsti->i_alias) 13335ecc953bSthorpej firsti = firsti->i_alias; 13345ecc953bSthorpej firsti->i_alias = i; 13355ecc953bSthorpej } 13365ecc953bSthorpej TAILQ_INSERT_TAIL(&alldevi, i, i_next); 13375ecc953bSthorpej ndevi++; 13385ecc953bSthorpej return (i); 13395ecc953bSthorpej } 13405ecc953bSthorpej 13415ecc953bSthorpej static const char * 13425ecc953bSthorpej concat(const char *name, int c) 13435ecc953bSthorpej { 13445ecc953bSthorpej int len; 13455ecc953bSthorpej char buf[NAMESIZE]; 13465ecc953bSthorpej 13475ecc953bSthorpej len = strlen(name); 13485ecc953bSthorpej if (len + 2 > sizeof(buf)) { 13495ecc953bSthorpej error("device name `%s%c' too long", name, c); 13505ecc953bSthorpej len = sizeof(buf) - 2; 13515ecc953bSthorpej } 13525ecc953bSthorpej memmove(buf, name, len); 13535ecc953bSthorpej buf[len] = c; 13545ecc953bSthorpej buf[len + 1] = 0; 13555ecc953bSthorpej return (intern(buf)); 13565ecc953bSthorpej } 13575ecc953bSthorpej 13585ecc953bSthorpej const char * 13595ecc953bSthorpej starref(const char *name) 13605ecc953bSthorpej { 13615ecc953bSthorpej 13625ecc953bSthorpej return (concat(name, '*')); 13635ecc953bSthorpej } 13645ecc953bSthorpej 13655ecc953bSthorpej const char * 13665ecc953bSthorpej wildref(const char *name) 13675ecc953bSthorpej { 13685ecc953bSthorpej 13695ecc953bSthorpej return (concat(name, '?')); 13705ecc953bSthorpej } 13715ecc953bSthorpej 13725ecc953bSthorpej /* 13735ecc953bSthorpej * Split a name like "foo0" into base name (foo) and unit number (0). 13745ecc953bSthorpej * Return 0 on success. To make this useful for names like "foo0a", 13755ecc953bSthorpej * the length of the "foo0" part is one of the arguments. 13765ecc953bSthorpej */ 13775ecc953bSthorpej static int 13785ecc953bSthorpej split(const char *name, size_t nlen, char *base, size_t bsize, int *aunit) 13795ecc953bSthorpej { 13805ecc953bSthorpej const char *cp; 13815ecc953bSthorpej int c, l; 13825ecc953bSthorpej 13835ecc953bSthorpej l = nlen; 13845ecc953bSthorpej if (l < 2 || l >= bsize || isdigit((unsigned char)*name)) 13855ecc953bSthorpej return (1); 13865ecc953bSthorpej c = (u_char)name[--l]; 13875ecc953bSthorpej if (!isdigit(c)) { 13885ecc953bSthorpej if (c == '*') 13895ecc953bSthorpej *aunit = STAR; 13905ecc953bSthorpej else if (c == '?') 13915ecc953bSthorpej *aunit = WILD; 13925ecc953bSthorpej else 13935ecc953bSthorpej return (1); 13945ecc953bSthorpej } else { 13955ecc953bSthorpej cp = &name[l]; 13965ecc953bSthorpej while (isdigit((unsigned char)cp[-1])) 13975ecc953bSthorpej l--, cp--; 13985ecc953bSthorpej *aunit = atoi(cp); 13995ecc953bSthorpej } 14005ecc953bSthorpej memmove(base, name, l); 14015ecc953bSthorpej base[l] = 0; 14025ecc953bSthorpej return (0); 14035ecc953bSthorpej } 14045ecc953bSthorpej 14055ecc953bSthorpej void 14065ecc953bSthorpej selectattr(struct attr *a) 14075ecc953bSthorpej { 14085ecc953bSthorpej 14095ecc953bSthorpej (void)ht_insert(selecttab, a->a_name, (char *)a->a_name); 14105ecc953bSthorpej } 14115ecc953bSthorpej 14125ecc953bSthorpej /* 14135ecc953bSthorpej * We have an instance of the base foo, so select it and all its 14145ecc953bSthorpej * attributes for "optional foo". 14155ecc953bSthorpej */ 14165ecc953bSthorpej static void 14175ecc953bSthorpej selectbase(struct devbase *d, struct deva *da) 14185ecc953bSthorpej { 14195ecc953bSthorpej struct attr *a; 14205ecc953bSthorpej struct nvlist *nv; 14215ecc953bSthorpej 14225ecc953bSthorpej (void)ht_insert(selecttab, d->d_name, (char *)d->d_name); 14235ecc953bSthorpej for (nv = d->d_attrs; nv != NULL; nv = nv->nv_next) { 14245ecc953bSthorpej a = nv->nv_ptr; 14255ecc953bSthorpej expandattr(a, selectattr); 14265ecc953bSthorpej } 14275ecc953bSthorpej if (da != NULL) { 14285ecc953bSthorpej (void)ht_insert(selecttab, da->d_name, (char *)da->d_name); 14295ecc953bSthorpej for (nv = da->d_attrs; nv != NULL; nv = nv->nv_next) { 14305ecc953bSthorpej a = nv->nv_ptr; 14315ecc953bSthorpej expandattr(a, selectattr); 14325ecc953bSthorpej } 14335ecc953bSthorpej } 14345ecc953bSthorpej } 14355ecc953bSthorpej 14365ecc953bSthorpej /* 14375ecc953bSthorpej * Is the given pointer on the given list of pointers? 14385ecc953bSthorpej */ 14395ecc953bSthorpej static int 14405ecc953bSthorpej onlist(struct nvlist *nv, void *ptr) 14415ecc953bSthorpej { 14425ecc953bSthorpej for (; nv != NULL; nv = nv->nv_next) 14435ecc953bSthorpej if (nv->nv_ptr == ptr) 14445ecc953bSthorpej return (1); 14455ecc953bSthorpej return (0); 14465ecc953bSthorpej } 14475ecc953bSthorpej 14485ecc953bSthorpej static char * 14495ecc953bSthorpej extend(char *p, const char *name) 14505ecc953bSthorpej { 14515ecc953bSthorpej int l; 14525ecc953bSthorpej 14535ecc953bSthorpej l = strlen(name); 14545ecc953bSthorpej memmove(p, name, l); 14555ecc953bSthorpej p += l; 14565ecc953bSthorpej *p++ = ','; 14575ecc953bSthorpej *p++ = ' '; 14585ecc953bSthorpej return (p); 14595ecc953bSthorpej } 14605ecc953bSthorpej 14615ecc953bSthorpej /* 14625ecc953bSthorpej * Check that we got all required locators, and default any that are 14635ecc953bSthorpej * given as "?" and have defaults. Return 0 on success. 14645ecc953bSthorpej */ 14655ecc953bSthorpej static const char ** 14665ecc953bSthorpej fixloc(const char *name, struct attr *attr, struct nvlist *got) 14675ecc953bSthorpej { 14685ecc953bSthorpej struct nvlist *m, *n; 14695ecc953bSthorpej int ord; 14705ecc953bSthorpej const char **lp; 14715ecc953bSthorpej int nmissing, nextra, nnodefault; 14725ecc953bSthorpej char *mp, *ep, *ndp; 14735ecc953bSthorpej char missing[1000], extra[1000], nodefault[1000]; 14745ecc953bSthorpej static const char *nullvec[1]; 14755ecc953bSthorpej 14765ecc953bSthorpej /* 14775ecc953bSthorpej * Look for all required locators, and number the given ones 14785ecc953bSthorpej * according to the required order. While we are numbering, 14795ecc953bSthorpej * set default values for defaulted locators. 14805ecc953bSthorpej */ 14815ecc953bSthorpej if (attr->a_loclen == 0) /* e.g., "at root" */ 14825ecc953bSthorpej lp = nullvec; 14835ecc953bSthorpej else 14845ecc953bSthorpej lp = emalloc((attr->a_loclen + 1) * sizeof(const char *)); 14855ecc953bSthorpej for (n = got; n != NULL; n = n->nv_next) 14865ecc953bSthorpej n->nv_int = -1; 14875ecc953bSthorpej nmissing = 0; 14885ecc953bSthorpej mp = missing; 14895ecc953bSthorpej /* yes, this is O(mn), but m and n should be small */ 14905ecc953bSthorpej for (ord = 0, m = attr->a_locs; m != NULL; m = m->nv_next, ord++) { 14915ecc953bSthorpej for (n = got; n != NULL; n = n->nv_next) { 14925ecc953bSthorpej if (n->nv_name == m->nv_name) { 14935ecc953bSthorpej n->nv_int = ord; 14945ecc953bSthorpej break; 14955ecc953bSthorpej } 14965ecc953bSthorpej } 14975ecc953bSthorpej if (n == NULL && m->nv_int == 0) { 14985ecc953bSthorpej nmissing++; 14995ecc953bSthorpej mp = extend(mp, m->nv_name); 15005ecc953bSthorpej } 15015ecc953bSthorpej lp[ord] = m->nv_str; 15025ecc953bSthorpej } 15035ecc953bSthorpej if (ord != attr->a_loclen) 15045ecc953bSthorpej panic("fixloc"); 15055ecc953bSthorpej lp[ord] = NULL; 15065ecc953bSthorpej nextra = 0; 15075ecc953bSthorpej ep = extra; 15085ecc953bSthorpej nnodefault = 0; 15095ecc953bSthorpej ndp = nodefault; 15105ecc953bSthorpej for (n = got; n != NULL; n = n->nv_next) { 15115ecc953bSthorpej if (n->nv_int >= 0) { 15125ecc953bSthorpej if (n->nv_str != NULL) 15135ecc953bSthorpej lp[n->nv_int] = n->nv_str; 15145ecc953bSthorpej else if (lp[n->nv_int] == NULL) { 15155ecc953bSthorpej nnodefault++; 15165ecc953bSthorpej ndp = extend(ndp, n->nv_name); 15175ecc953bSthorpej } 15185ecc953bSthorpej } else { 15195ecc953bSthorpej nextra++; 15205ecc953bSthorpej ep = extend(ep, n->nv_name); 15215ecc953bSthorpej } 15225ecc953bSthorpej } 15235ecc953bSthorpej if (nextra) { 15245ecc953bSthorpej ep[-2] = 0; /* kill ", " */ 15255ecc953bSthorpej error("%s: extraneous locator%s: %s", 15265ecc953bSthorpej name, nextra > 1 ? "s" : "", extra); 15275ecc953bSthorpej } 15285ecc953bSthorpej if (nmissing) { 15295ecc953bSthorpej mp[-2] = 0; 15305ecc953bSthorpej error("%s: must specify %s", name, missing); 15315ecc953bSthorpej } 15325ecc953bSthorpej if (nnodefault) { 15335ecc953bSthorpej ndp[-2] = 0; 15345ecc953bSthorpej error("%s: cannot wildcard %s", name, nodefault); 15355ecc953bSthorpej } 15365ecc953bSthorpej if (nmissing || nnodefault) { 15375ecc953bSthorpej free(lp); 15385ecc953bSthorpej lp = NULL; 15395ecc953bSthorpej } 15405ecc953bSthorpej return (lp); 15415ecc953bSthorpej } 1542