1 /* $NetBSD: sem.c,v 1.74 2016/04/29 18:18:22 mlelstv Exp $ */ 2 3 /* 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This software was developed by the Computer Systems Engineering group 8 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and 9 * contributed to Berkeley. 10 * 11 * All advertising materials mentioning features or use of this software 12 * must display the following acknowledgement: 13 * This product includes software developed by the University of 14 * California, Lawrence Berkeley Laboratories. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 1. Redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer. 21 * 2. Redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution. 24 * 3. Neither the name of the University nor the names of its contributors 25 * may be used to endorse or promote products derived from this software 26 * without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 * 40 * from: @(#)sem.c 8.1 (Berkeley) 6/6/93 41 */ 42 43 #if HAVE_NBTOOL_CONFIG_H 44 #include "nbtool_config.h" 45 #endif 46 47 #include <sys/cdefs.h> 48 __RCSID("$NetBSD: sem.c,v 1.74 2016/04/29 18:18:22 mlelstv Exp $"); 49 50 #include <sys/param.h> 51 #include <ctype.h> 52 #include <stdio.h> 53 #include <stdlib.h> 54 #include <string.h> 55 #include <util.h> 56 #include "defs.h" 57 #include "sem.h" 58 59 /* 60 * config semantics. 61 */ 62 63 #define NAMESIZE 100 /* local name buffers */ 64 65 const char *s_ifnet; /* magic attribute */ 66 const char *s_qmark; 67 const char *s_none; 68 69 static struct hashtab *cfhashtab; /* for config lookup */ 70 struct hashtab *devitab; /* etc */ 71 struct attr allattr; 72 size_t nattrs; 73 74 static struct attr errattr; 75 static struct devbase errdev; 76 static struct deva errdeva; 77 78 static int has_errobj(struct attrlist *, struct attr *); 79 static struct nvlist *addtoattr(struct nvlist *, struct devbase *); 80 static int resolve(struct nvlist **, const char *, const char *, 81 struct nvlist *, int); 82 static struct pspec *getpspec(struct attr *, struct devbase *, int); 83 static struct devi *newdevi(const char *, int, struct devbase *d); 84 static struct devi *getdevi(const char *); 85 static void remove_devi(struct devi *); 86 static const char *concat(const char *, int); 87 static char *extend(char *, const char *); 88 static int split(const char *, size_t, char *, size_t, int *); 89 static void selectbase(struct devbase *, struct deva *); 90 static const char **fixloc(const char *, struct attr *, struct loclist *); 91 static const char *makedevstr(devmajor_t, devminor_t); 92 static const char *major2name(devmajor_t); 93 static devmajor_t dev2major(struct devbase *); 94 95 extern const char *yyfile; 96 extern int vflag; 97 98 void 99 initsem(void) 100 { 101 102 attrtab = ht_new(); 103 attrdeptab = ht_new(); 104 105 allattr.a_name = "netbsd"; 106 TAILQ_INIT(&allattr.a_files); 107 (void)ht_insert(attrtab, allattr.a_name, &allattr); 108 selectattr(&allattr); 109 110 errattr.a_name = "<internal>"; 111 112 TAILQ_INIT(&allbases); 113 114 TAILQ_INIT(&alldevas); 115 116 TAILQ_INIT(&allpspecs); 117 118 cfhashtab = ht_new(); 119 TAILQ_INIT(&allcf); 120 121 TAILQ_INIT(&alldevi); 122 errdev.d_name = "<internal>"; 123 124 TAILQ_INIT(&allpseudo); 125 126 TAILQ_INIT(&alldevms); 127 128 s_ifnet = intern("ifnet"); 129 s_qmark = intern("?"); 130 s_none = intern("none"); 131 } 132 133 /* Name of include file just ended (set in scan.l) */ 134 extern const char *lastfile; 135 136 static struct attr * 137 finddep(struct attr *a, const char *name) 138 { 139 struct attrlist *al; 140 141 for (al = a->a_deps; al != NULL; al = al->al_next) { 142 struct attr *this = al->al_this; 143 if (strcmp(this->a_name, name) == 0) 144 return this; 145 } 146 return NULL; 147 } 148 149 static void 150 mergedeps(const char *dname, const char *name) 151 { 152 struct attr *a, *newa; 153 154 CFGDBG(4, "merging attr `%s' to devbase `%s'", name, dname); 155 a = refattr(dname); 156 if (finddep(a, name) == NULL) { 157 newa = refattr(name); 158 a->a_deps = attrlist_cons(a->a_deps, newa); 159 CFGDBG(3, "attr `%s' merged to attr `%s'", newa->a_name, 160 a->a_name); 161 } 162 } 163 164 static void 165 fixdev(struct devbase *dev) 166 { 167 struct attrlist *al; 168 struct attr *devattr, *a; 169 170 devattr = refattr(dev->d_name); 171 if (devattr->a_devclass) 172 panic("%s: dev %s is devclass!", __func__, devattr->a_name); 173 174 CFGDBG(4, "fixing devbase `%s'", dev->d_name); 175 for (al = dev->d_attrs; al != NULL; al = al->al_next) { 176 a = al->al_this; 177 CFGDBG(4, "fixing devbase `%s' attr `%s'", dev->d_name, a->a_name); 178 if (a->a_iattr) { 179 a->a_refs = addtoattr(a->a_refs, dev); 180 CFGDBG(3, "device `%s' has iattr `%s'", dev->d_name, 181 a->a_name); 182 } else if (a->a_devclass != NULL) { 183 if (dev->d_classattr != NULL && dev->d_classattr != a) { 184 cfgwarn("device `%s' has multiple classes " 185 "(`%s' and `%s')", 186 dev->d_name, dev->d_classattr->a_name, 187 a->a_name); 188 } 189 if (dev->d_classattr == NULL) { 190 dev->d_classattr = a; 191 CFGDBG(3, "device `%s' is devclass `%s'", dev->d_name, 192 a->a_name); 193 } 194 } else { 195 if (strcmp(dev->d_name, a->a_name) != 0) { 196 mergedeps(dev->d_name, a->a_name); 197 } 198 } 199 } 200 } 201 202 void 203 enddefs(void) 204 { 205 struct devbase *dev; 206 207 yyfile = "enddefs"; 208 209 TAILQ_FOREACH(dev, &allbases, d_next) { 210 if (!dev->d_isdef) { 211 (void)fprintf(stderr, 212 "%s: device `%s' used but not defined\n", 213 lastfile, dev->d_name); 214 errors++; 215 continue; 216 } 217 fixdev(dev); 218 } 219 if (errors) { 220 (void)fprintf(stderr, "*** Stop.\n"); 221 exit(1); 222 } 223 } 224 225 void 226 setdefmaxusers(int min, int def, int max) 227 { 228 229 if (min < 1 || min > def || def > max) 230 cfgerror("maxusers must have 1 <= min (%d) <= default (%d) " 231 "<= max (%d)", min, def, max); 232 else { 233 minmaxusers = min; 234 defmaxusers = def; 235 maxmaxusers = max; 236 } 237 } 238 239 void 240 setmaxusers(int n) 241 { 242 243 if (maxusers == n) { 244 cfgerror("duplicate maxusers parameter"); 245 return; 246 } 247 if (vflag && maxusers != 0) 248 cfgwarn("warning: maxusers already defined"); 249 maxusers = n; 250 if (n < minmaxusers) { 251 cfgerror("warning: minimum of %d maxusers assumed", 252 minmaxusers); 253 errors--; /* take it away */ 254 maxusers = minmaxusers; 255 } else if (n > maxmaxusers) { 256 cfgerror("warning: maxusers (%d) > %d", n, maxmaxusers); 257 errors--; 258 } 259 } 260 261 void 262 setident(const char *i) 263 { 264 265 if (i) 266 ident = intern(i); 267 else 268 ident = NULL; 269 } 270 271 /* 272 * Define an attribute, optionally with an interface (a locator list) 273 * and a set of attribute-dependencies. 274 * 275 * Attribute dependencies MAY NOT be interface attributes. 276 * 277 * Since an empty locator list is logically different from "no interface", 278 * all locator lists include a dummy head node, which we discard here. 279 */ 280 int 281 defattr0(const char *name, struct loclist *locs, struct attrlist *deps, 282 int devclass) 283 { 284 285 if (locs != NULL) 286 return defiattr(name, locs, deps, devclass); 287 else if (devclass) 288 return defdevclass(name, locs, deps, devclass); 289 else 290 return defattr(name, locs, deps, devclass); 291 } 292 293 int 294 defattr(const char *name, struct loclist *locs, struct attrlist *deps, 295 int devclass) 296 { 297 struct attr *a, *dep; 298 struct attrlist *al; 299 300 /* 301 * If this attribute depends on any others, make sure none of 302 * the dependencies are interface attributes. 303 */ 304 for (al = deps; al != NULL; al = al->al_next) { 305 dep = al->al_this; 306 if (dep->a_iattr) { 307 cfgerror("`%s' dependency `%s' is an interface " 308 "attribute", name, dep->a_name); 309 return (1); 310 } 311 (void)ht_insert2(attrdeptab, name, dep->a_name, NULL); 312 CFGDBG(2, "attr `%s' depends on attr `%s'", name, dep->a_name); 313 } 314 315 if (getrefattr(name, &a)) { 316 cfgerror("attribute `%s' already defined", name); 317 loclist_destroy(locs); 318 return (1); 319 } 320 if (a == NULL) 321 a = mkattr(name); 322 323 a->a_deps = deps; 324 expandattr(a, NULL); 325 CFGDBG(3, "attr `%s' defined", a->a_name); 326 327 return (0); 328 } 329 330 struct attr * 331 mkattr(const char *name) 332 { 333 struct attr *a; 334 335 a = ecalloc(1, sizeof *a); 336 if (ht_insert(attrtab, name, a)) { 337 free(a); 338 return NULL; 339 } 340 a->a_name = name; 341 TAILQ_INIT(&a->a_files); 342 CFGDBG(3, "attr `%s' allocated", name); 343 344 return a; 345 } 346 347 /* "interface attribute" initialization */ 348 int 349 defiattr(const char *name, struct loclist *locs, struct attrlist *deps, 350 int devclass) 351 { 352 struct attr *a; 353 int len; 354 struct loclist *ll; 355 356 if (devclass) 357 panic("defattr(%s): locators and devclass", name); 358 359 if (defattr(name, locs, deps, devclass) != 0) 360 return (1); 361 362 a = getattr(name); 363 a->a_iattr = 1; 364 /* unwrap */ 365 a->a_locs = locs->ll_next; 366 locs->ll_next = NULL; 367 loclist_destroy(locs); 368 len = 0; 369 for (ll = a->a_locs; ll != NULL; ll = ll->ll_next) 370 len++; 371 a->a_loclen = len; 372 if (deps) 373 CFGDBG(2, "attr `%s' iface with deps", a->a_name); 374 return (0); 375 } 376 377 /* "device class" initialization */ 378 int 379 defdevclass(const char *name, struct loclist *locs, struct attrlist *deps, 380 int devclass) 381 { 382 struct attr *a; 383 char classenum[256], *cp; 384 int errored = 0; 385 386 if (deps) 387 panic("defattr(%s): dependencies and devclass", name); 388 389 if (defattr(name, locs, deps, devclass) != 0) 390 return (1); 391 392 a = getattr(name); 393 (void)snprintf(classenum, sizeof(classenum), "DV_%s", name); 394 for (cp = classenum + 3; *cp; cp++) { 395 if (!errored && 396 (!isalnum((unsigned char)*cp) || 397 (isalpha((unsigned char)*cp) && !islower((unsigned char)*cp)))) { 398 cfgerror("device class names must be " 399 "lower-case alphanumeric characters"); 400 errored = 1; 401 } 402 *cp = (char)toupper((unsigned char)*cp); 403 } 404 a->a_devclass = intern(classenum); 405 406 return (0); 407 } 408 409 /* 410 * Return true if the given `error object' is embedded in the given 411 * pointer list. 412 */ 413 static int 414 has_errobj(struct attrlist *al, struct attr *obj) 415 { 416 417 for (; al != NULL; al = al->al_next) 418 if (al->al_this == obj) 419 return (1); 420 return (0); 421 } 422 423 /* 424 * Return true if the given attribute is embedded in the given 425 * pointer list. 426 */ 427 int 428 has_attr(struct attrlist *al, const char *attr) 429 { 430 struct attr *a; 431 432 if ((a = getattr(attr)) == NULL) 433 return (0); 434 435 for (; al != NULL; al = al->al_next) 436 if (al->al_this == a) 437 return (1); 438 return (0); 439 } 440 441 /* 442 * Add a device base to a list in an attribute (actually, to any list). 443 * Note that this does not check for duplicates, and does reverse the 444 * list order, but no one cares anyway. 445 */ 446 static struct nvlist * 447 addtoattr(struct nvlist *l, struct devbase *dev) 448 { 449 struct nvlist *n; 450 451 n = newnv(NULL, NULL, dev, 0, l); 452 return (n); 453 } 454 455 /* 456 * Define a device. This may (or may not) also define an interface 457 * attribute and/or refer to existing attributes. 458 */ 459 void 460 defdev(struct devbase *dev, struct loclist *loclist, struct attrlist *attrs, 461 int ispseudo) 462 { 463 struct loclist *ll; 464 struct attrlist *al; 465 466 if (dev == &errdev) 467 goto bad; 468 if (dev->d_isdef) { 469 cfgerror("redefinition of `%s'", dev->d_name); 470 goto bad; 471 } 472 473 dev->d_isdef = 1; 474 if (has_errobj(attrs, &errattr)) 475 goto bad; 476 477 /* 478 * Handle implicit attribute definition from locator list. Do 479 * this before scanning the `at' list so that we can have, e.g.: 480 * device foo at other, foo { slot = -1 } 481 * (where you can plug in a foo-bus extender to a foo-bus). 482 */ 483 if (loclist != NULL) { 484 ll = loclist; 485 loclist = NULL; /* defattr disposes of them for us */ 486 if (defiattr(dev->d_name, ll, NULL, 0)) 487 goto bad; 488 attrs = attrlist_cons(attrs, getattr(dev->d_name)); 489 /* This used to be stored but was never used */ 490 /* attrs->al_name = dev->d_name; */ 491 } 492 493 /* 494 * Pseudo-devices can have children. Consider them as 495 * attaching at root. 496 */ 497 if (ispseudo) { 498 for (al = attrs; al != NULL; al = al->al_next) 499 if (al->al_this->a_iattr) 500 break; 501 if (al != NULL) { 502 if (ispseudo < 2) { 503 if (version >= 20080610) 504 cfgerror("interface attribute on " 505 "non-device pseudo `%s'", dev->d_name); 506 else { 507 ispseudo = 2; 508 } 509 } 510 ht_insert(devroottab, dev->d_name, dev); 511 } 512 } 513 514 /* Committed! Set up fields. */ 515 dev->d_ispseudo = ispseudo; 516 dev->d_attrs = attrs; 517 dev->d_classattr = NULL; /* for now */ 518 CFGDBG(3, "dev `%s' defined", dev->d_name); 519 520 /* 521 * Implicit attribute definition for device. 522 */ 523 refattr(dev->d_name); 524 525 /* 526 * For each interface attribute this device refers to, add this 527 * device to its reference list. This makes, e.g., finding all 528 * "scsi"s easier. 529 * 530 * While looking through the attributes, set up the device 531 * class if any are devclass attributes (and error out if the 532 * device has two classes). 533 */ 534 for (al = attrs; al != NULL; al = al->al_next) { 535 /* 536 * Implicit attribute definition for device dependencies. 537 */ 538 refattr(al->al_this->a_name); 539 (void)ht_insert2(attrdeptab, dev->d_name, al->al_this->a_name, NULL); 540 CFGDBG(2, "device `%s' depends on attr `%s'", dev->d_name, 541 al->al_this->a_name); 542 } 543 return; 544 bad: 545 loclist_destroy(loclist); 546 attrlist_destroyall(attrs); 547 } 548 549 /* 550 * Look up a devbase. Also makes sure it is a reasonable name, 551 * i.e., does not end in a digit or contain special characters. 552 */ 553 struct devbase * 554 getdevbase(const char *name) 555 { 556 const u_char *p; 557 struct devbase *dev; 558 559 p = (const u_char *)name; 560 if (!isalpha(*p)) 561 goto badname; 562 while (*++p) { 563 if (!isalnum(*p) && *p != '_') 564 goto badname; 565 } 566 if (isdigit(*--p)) { 567 badname: 568 cfgerror("bad device base name `%s'", name); 569 return (&errdev); 570 } 571 dev = ht_lookup(devbasetab, name); 572 if (dev == NULL) { 573 dev = ecalloc(1, sizeof *dev); 574 dev->d_name = name; 575 dev->d_isdef = 0; 576 dev->d_major = NODEVMAJOR; 577 dev->d_attrs = NULL; 578 dev->d_ihead = NULL; 579 dev->d_ipp = &dev->d_ihead; 580 dev->d_ahead = NULL; 581 dev->d_app = &dev->d_ahead; 582 dev->d_umax = 0; 583 TAILQ_INSERT_TAIL(&allbases, dev, d_next); 584 if (ht_insert(devbasetab, name, dev)) 585 panic("getdevbase(%s)", name); 586 CFGDBG(3, "devbase defined `%s'", dev->d_name); 587 } 588 return (dev); 589 } 590 591 /* 592 * Define some of a device's allowable parent attachments. 593 * There may be a list of (plain) attributes. 594 */ 595 void 596 defdevattach(struct deva *deva, struct devbase *dev, struct nvlist *atlist, 597 struct attrlist *attrs) 598 { 599 struct nvlist *nv; 600 struct attrlist *al; 601 struct attr *a; 602 struct deva *da; 603 604 if (dev == &errdev) 605 goto bad; 606 if (deva == NULL) 607 deva = getdevattach(dev->d_name); 608 if (deva == &errdeva) 609 goto bad; 610 if (!dev->d_isdef) { 611 cfgerror("attaching undefined device `%s'", dev->d_name); 612 goto bad; 613 } 614 if (deva->d_isdef) { 615 cfgerror("redefinition of `%s'", deva->d_name); 616 goto bad; 617 } 618 if (dev->d_ispseudo) { 619 cfgerror("pseudo-devices can't attach"); 620 goto bad; 621 } 622 623 deva->d_isdef = 1; 624 if (has_errobj(attrs, &errattr)) 625 goto bad; 626 for (al = attrs; al != NULL; al = al->al_next) { 627 a = al->al_this; 628 if (a == &errattr) 629 continue; /* already complained */ 630 if (a->a_iattr || a->a_devclass != NULL) 631 cfgerror("`%s' is not a plain attribute", a->a_name); 632 } 633 634 /* Committed! Set up fields. */ 635 deva->d_attrs = attrs; 636 deva->d_atlist = atlist; 637 deva->d_devbase = dev; 638 CFGDBG(3, "deva `%s' defined", deva->d_name); 639 640 /* 641 * Implicit attribute definition for device attachment. 642 */ 643 refattr(deva->d_name); 644 645 /* 646 * Turn the `at' list into interface attributes (map each 647 * nv_name to an attribute, or to NULL for root), and add 648 * this device to those attributes, so that children can 649 * be listed at this particular device if they are supported 650 * by that attribute. 651 */ 652 for (nv = atlist; nv != NULL; nv = nv->nv_next) { 653 if (nv->nv_name == NULL) 654 nv->nv_ptr = a = NULL; /* at root */ 655 else 656 nv->nv_ptr = a = getattr(nv->nv_name); 657 if (a == &errattr) 658 continue; /* already complained */ 659 660 /* 661 * Make sure that an attachment spec doesn't 662 * already say how to attach to this attribute. 663 */ 664 for (da = dev->d_ahead; da != NULL; da = da->d_bsame) 665 if (onlist(da->d_atlist, a)) 666 cfgerror("attach at `%s' already done by `%s'", 667 a ? a->a_name : "root", da->d_name); 668 669 if (a == NULL) { 670 ht_insert(devroottab, dev->d_name, dev); 671 continue; /* at root; don't add */ 672 } 673 if (!a->a_iattr) 674 cfgerror("%s cannot be at plain attribute `%s'", 675 dev->d_name, a->a_name); 676 else 677 a->a_devs = addtoattr(a->a_devs, dev); 678 } 679 680 /* attach to parent */ 681 *dev->d_app = deva; 682 dev->d_app = &deva->d_bsame; 683 return; 684 bad: 685 nvfreel(atlist); 686 attrlist_destroyall(attrs); 687 } 688 689 /* 690 * Look up a device attachment. Also makes sure it is a reasonable 691 * name, i.e., does not contain digits or special characters. 692 */ 693 struct deva * 694 getdevattach(const char *name) 695 { 696 const u_char *p; 697 struct deva *deva; 698 699 p = (const u_char *)name; 700 if (!isalpha(*p)) 701 goto badname; 702 while (*++p) { 703 if (!isalnum(*p) && *p != '_') 704 goto badname; 705 } 706 if (isdigit(*--p)) { 707 badname: 708 cfgerror("bad device attachment name `%s'", name); 709 return (&errdeva); 710 } 711 deva = ht_lookup(devatab, name); 712 if (deva == NULL) { 713 deva = ecalloc(1, sizeof *deva); 714 deva->d_name = name; 715 deva->d_bsame = NULL; 716 deva->d_isdef = 0; 717 deva->d_devbase = NULL; 718 deva->d_atlist = NULL; 719 deva->d_attrs = NULL; 720 deva->d_ihead = NULL; 721 deva->d_ipp = &deva->d_ihead; 722 TAILQ_INSERT_TAIL(&alldevas, deva, d_next); 723 if (ht_insert(devatab, name, deva)) 724 panic("getdeva(%s)", name); 725 } 726 return (deva); 727 } 728 729 /* 730 * Look up an attribute. 731 */ 732 struct attr * 733 getattr(const char *name) 734 { 735 struct attr *a; 736 737 if ((a = ht_lookup(attrtab, name)) == NULL) { 738 cfgerror("undefined attribute `%s'", name); 739 a = &errattr; 740 } 741 return (a); 742 } 743 744 /* 745 * Implicit attribute definition. 746 */ 747 struct attr * 748 refattr(const char *name) 749 { 750 struct attr *a; 751 752 if ((a = ht_lookup(attrtab, name)) == NULL) 753 a = mkattr(name); 754 return a; 755 } 756 757 int 758 getrefattr(const char *name, struct attr **ra) 759 { 760 struct attr *a; 761 762 a = ht_lookup(attrtab, name); 763 if (a == NULL) { 764 *ra = NULL; 765 return (0); 766 } 767 /* 768 * Check if the existing attr is only referenced, not really defined. 769 */ 770 if (a->a_deps == NULL && 771 a->a_iattr == 0 && 772 a->a_devclass == 0) { 773 *ra = a; 774 return (0); 775 } 776 return (1); 777 } 778 779 /* 780 * Recursively expand an attribute and its dependencies, checking for 781 * cycles, and invoking a callback for each attribute found. 782 */ 783 void 784 expandattr(struct attr *a, void (*callback)(struct attr *)) 785 { 786 struct attrlist *al; 787 struct attr *dep; 788 789 if (a->a_expanding) { 790 cfgerror("circular dependency on attribute `%s'", a->a_name); 791 return; 792 } 793 794 a->a_expanding = 1; 795 796 /* First expand all of this attribute's dependencies. */ 797 for (al = a->a_deps; al != NULL; al = al->al_next) { 798 dep = al->al_this; 799 expandattr(dep, callback); 800 } 801 802 /* ...and now invoke the callback for ourself. */ 803 if (callback != NULL) 804 (*callback)(a); 805 806 a->a_expanding = 0; 807 } 808 809 /* 810 * Set the major device number for a device, so that it can be used 811 * as a root/dumps "on" device in a configuration. 812 */ 813 void 814 setmajor(struct devbase *d, devmajor_t n) 815 { 816 817 if (d != &errdev && d->d_major != NODEVMAJOR) 818 cfgerror("device `%s' is already major %d", 819 d->d_name, d->d_major); 820 else 821 d->d_major = n; 822 } 823 824 const char * 825 major2name(devmajor_t maj) 826 { 827 struct devbase *dev; 828 struct devm *dm; 829 830 if (!do_devsw) { 831 TAILQ_FOREACH(dev, &allbases, d_next) { 832 if (dev->d_major == maj) 833 return (dev->d_name); 834 } 835 } else { 836 TAILQ_FOREACH(dm, &alldevms, dm_next) { 837 if (dm->dm_bmajor == maj) 838 return (dm->dm_name); 839 } 840 } 841 return (NULL); 842 } 843 844 devmajor_t 845 dev2major(struct devbase *dev) 846 { 847 struct devm *dm; 848 849 if (!do_devsw) 850 return (dev->d_major); 851 852 TAILQ_FOREACH(dm, &alldevms, dm_next) { 853 if (strcmp(dm->dm_name, dev->d_name) == 0) 854 return (dm->dm_bmajor); 855 } 856 return (NODEVMAJOR); 857 } 858 859 /* 860 * Make a string description of the device at maj/min. 861 */ 862 static const char * 863 makedevstr(devmajor_t maj, devminor_t min) 864 { 865 const char *devicename; 866 char buf[32]; 867 868 devicename = major2name(maj); 869 if (devicename == NULL) 870 (void)snprintf(buf, sizeof(buf), "<%d/%d>", maj, min); 871 else 872 (void)snprintf(buf, sizeof(buf), "%s%d%c", devicename, 873 min / maxpartitions, (min % maxpartitions) + 'a'); 874 875 return (intern(buf)); 876 } 877 878 /* 879 * Map things like "ra0b" => makedev(major("ra"), 0*maxpartitions + 'b'-'a'). 880 * Handle the case where the device number is given but there is no 881 * corresponding name, and map NULL to the default. 882 */ 883 static int 884 resolve(struct nvlist **nvp, const char *name, const char *what, 885 struct nvlist *dflt, int part) 886 { 887 struct nvlist *nv; 888 struct devbase *dev; 889 const char *cp; 890 devmajor_t maj; 891 devminor_t min; 892 size_t i, l; 893 int unit; 894 char buf[NAMESIZE]; 895 896 if ((part -= 'a') >= maxpartitions || part < 0) 897 panic("resolve"); 898 if ((nv = *nvp) == NULL) { 899 dev_t d = NODEV; 900 /* 901 * Apply default. Easiest to do this by number. 902 * Make sure to retain NODEVness, if this is dflt's disposition. 903 */ 904 if ((dev_t)dflt->nv_num != NODEV) { 905 maj = major(dflt->nv_num); 906 min = ((minor(dflt->nv_num) / maxpartitions) * 907 maxpartitions) + part; 908 d = makedev(maj, min); 909 cp = makedevstr(maj, min); 910 } else 911 cp = NULL; 912 *nvp = nv = newnv(NULL, cp, NULL, (long long)d, NULL); 913 } 914 if ((dev_t)nv->nv_num != NODEV) { 915 /* 916 * By the numbers. Find the appropriate major number 917 * to make a name. 918 */ 919 maj = major(nv->nv_num); 920 min = minor(nv->nv_num); 921 nv->nv_str = makedevstr(maj, min); 922 return (0); 923 } 924 925 if (nv->nv_str == NULL || nv->nv_str == s_qmark) 926 /* 927 * Wildcarded or unspecified; leave it as NODEV. 928 */ 929 return (0); 930 931 if (nv->nv_ptr != NULL && strcmp(nv->nv_ptr, "spec") == 0) 932 /* 933 * spec string, interpreted by kernel 934 */ 935 return (0); 936 937 /* 938 * The normal case: things like "ra2b". Check for partition 939 * suffix, remove it if there, and split into name ("ra") and 940 * unit (2). 941 */ 942 l = i = strlen(nv->nv_str); 943 cp = &nv->nv_str[l]; 944 if (l > 1 && *--cp >= 'a' && *cp < 'a' + maxpartitions && 945 isdigit((unsigned char)cp[-1])) { 946 l--; 947 part = *cp - 'a'; 948 } 949 cp = nv->nv_str; 950 if (split(cp, l, buf, sizeof buf, &unit)) { 951 cfgerror("%s: invalid %s device name `%s'", name, what, cp); 952 return (1); 953 } 954 dev = ht_lookup(devbasetab, intern(buf)); 955 if (dev == NULL) { 956 cfgerror("%s: device `%s' does not exist", name, buf); 957 return (1); 958 } 959 960 /* 961 * Check for the magic network interface attribute, and 962 * don't bother making a device number. 963 */ 964 if (has_attr(dev->d_attrs, s_ifnet)) { 965 nv->nv_num = (long long)NODEV; 966 nv->nv_ifunit = unit; /* XXX XXX XXX */ 967 } else { 968 maj = dev2major(dev); 969 if (maj == NODEVMAJOR) { 970 cfgerror("%s: can't make %s device from `%s'", 971 name, what, nv->nv_str); 972 return (1); 973 } 974 nv->nv_num = (long long)makedev(maj, unit * maxpartitions + part); 975 } 976 977 nv->nv_name = dev->d_name; 978 return (0); 979 } 980 981 /* 982 * Add a completed configuration to the list. 983 */ 984 void 985 addconf(struct config *cf0) 986 { 987 struct config *cf; 988 const char *name; 989 990 name = cf0->cf_name; 991 cf = ecalloc(1, sizeof *cf); 992 if (ht_insert(cfhashtab, name, cf)) { 993 cfgerror("configuration `%s' already defined", name); 994 free(cf); 995 goto bad; 996 } 997 *cf = *cf0; 998 999 /* 1000 * Resolve the root device. 1001 */ 1002 if (cf->cf_root == NULL) { 1003 cfgerror("%s: no root device specified", name); 1004 goto bad; 1005 } 1006 if (cf->cf_root && cf->cf_root->nv_str != s_qmark) { 1007 struct nvlist *nv; 1008 nv = cf->cf_root; 1009 if (resolve(&cf->cf_root, name, "root", nv, 'a')) 1010 goto bad; 1011 } 1012 1013 /* 1014 * Resolve the dump device. 1015 */ 1016 if (cf->cf_dump == NULL || cf->cf_dump->nv_str == s_qmark) { 1017 /* 1018 * Wildcarded dump device is equivalent to unspecified. 1019 */ 1020 cf->cf_dump = NULL; 1021 } else if (cf->cf_dump->nv_str == s_none) { 1022 /* 1023 * Operator has requested that no dump device should be 1024 * configured; do nothing. 1025 */ 1026 } else { 1027 if (resolve(&cf->cf_dump, name, "dumps", cf->cf_dump, 'b')) 1028 goto bad; 1029 } 1030 1031 /* Wildcarded fstype is `unspecified'. */ 1032 if (cf->cf_fstype == s_qmark) 1033 cf->cf_fstype = NULL; 1034 1035 TAILQ_INSERT_TAIL(&allcf, cf, cf_next); 1036 return; 1037 bad: 1038 nvfreel(cf0->cf_root); 1039 nvfreel(cf0->cf_dump); 1040 } 1041 1042 void 1043 setconf(struct nvlist **npp, const char *what, struct nvlist *v) 1044 { 1045 1046 if (*npp != NULL) { 1047 cfgerror("duplicate %s specification", what); 1048 nvfreel(v); 1049 } else 1050 *npp = v; 1051 } 1052 1053 void 1054 delconf(const char *name) 1055 { 1056 struct config *cf; 1057 1058 CFGDBG(5, "deselecting config `%s'", name); 1059 if (ht_lookup(cfhashtab, name) == NULL) { 1060 cfgerror("configuration `%s' undefined", name); 1061 return; 1062 } 1063 (void)ht_remove(cfhashtab, name); 1064 1065 TAILQ_FOREACH(cf, &allcf, cf_next) 1066 if (!strcmp(cf->cf_name, name)) 1067 break; 1068 if (cf == NULL) 1069 panic("lost configuration `%s'", name); 1070 1071 TAILQ_REMOVE(&allcf, cf, cf_next); 1072 } 1073 1074 void 1075 setfstype(const char **fstp, const char *v) 1076 { 1077 1078 if (*fstp != NULL) { 1079 cfgerror("multiple fstype specifications"); 1080 return; 1081 } 1082 1083 if (v != s_qmark && OPT_FSOPT(v)) { 1084 cfgerror("\"%s\" is not a configured file system", v); 1085 return; 1086 } 1087 1088 *fstp = v; 1089 } 1090 1091 static struct devi * 1092 newdevi(const char *name, int unit, struct devbase *d) 1093 { 1094 struct devi *i; 1095 1096 i = ecalloc(1, sizeof *i); 1097 i->i_name = name; 1098 i->i_unit = unit; 1099 i->i_base = d; 1100 i->i_bsame = NULL; 1101 i->i_asame = NULL; 1102 i->i_alias = NULL; 1103 i->i_at = NULL; 1104 i->i_pspec = NULL; 1105 i->i_atdeva = NULL; 1106 i->i_locs = NULL; 1107 i->i_cfflags = 0; 1108 i->i_lineno = currentline(); 1109 i->i_srcfile = yyfile; 1110 i->i_active = DEVI_ORPHAN; /* Proper analysis comes later */ 1111 i->i_level = devilevel; 1112 i->i_pseudoroot = 0; 1113 if (unit >= d->d_umax) 1114 d->d_umax = unit + 1; 1115 return (i); 1116 } 1117 1118 /* 1119 * Add the named device as attaching to the named attribute (or perhaps 1120 * another device instead) plus unit number. 1121 */ 1122 void 1123 adddev(const char *name, const char *at, struct loclist *loclist, int flags) 1124 { 1125 struct devi *i; /* the new instance */ 1126 struct pspec *p; /* and its pspec */ 1127 struct attr *attr; /* attribute that allows attach */ 1128 struct devbase *ib; /* i->i_base */ 1129 struct devbase *ab; /* not NULL => at another dev */ 1130 struct attrlist *al; 1131 struct deva *iba; /* devbase attachment used */ 1132 const char *cp; 1133 int atunit; 1134 char atbuf[NAMESIZE]; 1135 int hit; 1136 1137 ab = NULL; 1138 iba = NULL; 1139 if (at == NULL) { 1140 /* "at root" */ 1141 p = NULL; 1142 if ((i = getdevi(name)) == NULL) 1143 goto bad; 1144 /* 1145 * Must warn about i_unit > 0 later, after taking care of 1146 * the STAR cases (we could do non-star's here but why 1147 * bother?). Make sure this device can be at root. 1148 */ 1149 ib = i->i_base; 1150 hit = 0; 1151 for (iba = ib->d_ahead; iba != NULL; iba = iba->d_bsame) 1152 if (onlist(iba->d_atlist, NULL)) { 1153 hit = 1; 1154 break; 1155 } 1156 if (!hit) { 1157 cfgerror("`%s' cannot attach to the root", ib->d_name); 1158 i->i_active = DEVI_BROKEN; 1159 goto bad; 1160 } 1161 attr = &errattr; /* a convenient "empty" attr */ 1162 } else { 1163 if (split(at, strlen(at), atbuf, sizeof atbuf, &atunit)) { 1164 cfgerror("invalid attachment name `%s'", at); 1165 /* (void)getdevi(name); -- ??? */ 1166 goto bad; 1167 } 1168 if ((i = getdevi(name)) == NULL) 1169 goto bad; 1170 ib = i->i_base; 1171 1172 /* 1173 * Devices can attach to two types of things: Attributes, 1174 * and other devices (which have the appropriate attributes 1175 * to allow attachment). 1176 * 1177 * (1) If we're attached to an attribute, then we don't need 1178 * look at the parent base device to see what attributes 1179 * it has, and make sure that we can attach to them. 1180 * 1181 * (2) If we're attached to a real device (i.e. named in 1182 * the config file), we want to remember that so that 1183 * at cross-check time, if the device we're attached to 1184 * is missing but other devices which also provide the 1185 * attribute are present, we don't get a false "OK." 1186 * 1187 * (3) If the thing we're attached to is an attribute 1188 * but is actually named in the config file, we still 1189 * have to remember its devbase. 1190 */ 1191 cp = intern(atbuf); 1192 1193 /* Figure out parent's devbase, to satisfy case (3). */ 1194 ab = ht_lookup(devbasetab, cp); 1195 1196 /* Find out if it's an attribute. */ 1197 attr = ht_lookup(attrtab, cp); 1198 1199 /* Make sure we're _really_ attached to the attr. Case (1). */ 1200 if (attr != NULL && onlist(attr->a_devs, ib)) 1201 goto findattachment; 1202 1203 /* 1204 * Else a real device, and not just an attribute. Case (2). 1205 * 1206 * Have to work a bit harder to see whether we have 1207 * something like "tg0 at esp0" (where esp is merely 1208 * not an attribute) or "tg0 at nonesuch0" (where 1209 * nonesuch is not even a device). 1210 */ 1211 if (ab == NULL) { 1212 cfgerror("%s at %s: `%s' unknown", 1213 name, at, atbuf); 1214 i->i_active = DEVI_BROKEN; 1215 goto bad; 1216 } 1217 1218 /* 1219 * See if the named parent carries an attribute 1220 * that allows it to supervise device ib. 1221 */ 1222 for (al = ab->d_attrs; al != NULL; al = al->al_next) { 1223 attr = al->al_this; 1224 if (onlist(attr->a_devs, ib)) 1225 goto findattachment; 1226 } 1227 cfgerror("`%s' cannot attach to `%s'", ib->d_name, atbuf); 1228 i->i_active = DEVI_BROKEN; 1229 goto bad; 1230 1231 findattachment: 1232 /* 1233 * Find the parent spec. If a matching one has not yet been 1234 * created, create one. 1235 */ 1236 p = getpspec(attr, ab, atunit); 1237 p->p_devs = newnv(NULL, NULL, i, 0, p->p_devs); 1238 1239 /* find out which attachment it uses */ 1240 hit = 0; 1241 for (iba = ib->d_ahead; iba != NULL; iba = iba->d_bsame) 1242 if (onlist(iba->d_atlist, attr)) { 1243 hit = 1; 1244 break; 1245 } 1246 if (!hit) 1247 panic("adddev: can't figure out attachment"); 1248 } 1249 if ((i->i_locs = fixloc(name, attr, loclist)) == NULL) { 1250 i->i_active = DEVI_BROKEN; 1251 goto bad; 1252 } 1253 i->i_at = at; 1254 i->i_pspec = p; 1255 i->i_atdeva = iba; 1256 i->i_cfflags = flags; 1257 CFGDBG(3, "devi `%s' added", i->i_name); 1258 1259 *iba->d_ipp = i; 1260 iba->d_ipp = &i->i_asame; 1261 1262 /* all done, fall into ... */ 1263 bad: 1264 loclist_destroy(loclist); 1265 return; 1266 } 1267 1268 void 1269 deldevi(const char *name, const char *at) 1270 { 1271 struct devi *firsti, *i; 1272 struct devbase *d; 1273 int unit; 1274 char base[NAMESIZE]; 1275 1276 CFGDBG(5, "deselecting devi `%s'", name); 1277 if (split(name, strlen(name), base, sizeof base, &unit)) { 1278 cfgerror("invalid device name `%s'", name); 1279 return; 1280 } 1281 d = ht_lookup(devbasetab, intern(base)); 1282 if (d == NULL) { 1283 cfgerror("%s: unknown device `%s'", name, base); 1284 return; 1285 } 1286 if (d->d_ispseudo) { 1287 cfgerror("%s: %s is a pseudo-device", name, base); 1288 return; 1289 } 1290 if ((firsti = ht_lookup(devitab, name)) == NULL) { 1291 cfgerror("`%s' not defined", name); 1292 return; 1293 } 1294 if (at == NULL && firsti->i_at == NULL) { 1295 /* 'at root' */ 1296 remove_devi(firsti); 1297 return; 1298 } else if (at != NULL) 1299 for (i = firsti; i != NULL; i = i->i_alias) 1300 if (i->i_active != DEVI_BROKEN && 1301 strcmp(at, i->i_at) == 0) { 1302 remove_devi(i); 1303 return; 1304 } 1305 cfgerror("`%s' at `%s' not found", name, at ? at : "root"); 1306 } 1307 1308 static void 1309 remove_devi(struct devi *i) 1310 { 1311 struct devbase *d = i->i_base; 1312 struct devi *f, *j, **ppi; 1313 struct deva *iba; 1314 1315 CFGDBG(5, "removing devi `%s'", i->i_name); 1316 f = ht_lookup(devitab, i->i_name); 1317 if (f == NULL) 1318 panic("remove_devi(): instance %s disappeared from devitab", 1319 i->i_name); 1320 1321 if (i->i_active == DEVI_BROKEN) { 1322 cfgerror("not removing broken instance `%s'", i->i_name); 1323 return; 1324 } 1325 1326 /* 1327 * We have the device instance, i. 1328 * We have to: 1329 * - delete the alias 1330 * 1331 * If the devi was an alias of an already listed devi, all is 1332 * good we don't have to do more. 1333 * If it was the first alias, we have to replace i's entry in 1334 * d's list by its first alias. 1335 * If it was the only entry, we must remove i's entry from d's 1336 * list. 1337 */ 1338 if (i != f) { 1339 for (j = f; j->i_alias != i; j = j->i_alias) 1340 continue; 1341 j->i_alias = i->i_alias; 1342 } else { 1343 if (i->i_alias == NULL) { 1344 /* No alias, must unlink the entry from devitab */ 1345 ht_remove(devitab, i->i_name); 1346 j = i->i_bsame; 1347 } else { 1348 /* Or have the first alias replace i in d's list */ 1349 i->i_alias->i_bsame = i->i_bsame; 1350 j = i->i_alias; 1351 if (i == f) 1352 ht_replace(devitab, i->i_name, i->i_alias); 1353 } 1354 1355 /* 1356 * - remove/replace the instance from the devbase's list 1357 * 1358 * A double-linked list would make this much easier. Oh, well, 1359 * what is done is done. 1360 */ 1361 for (ppi = &d->d_ihead; 1362 *ppi != NULL && *ppi != i && (*ppi)->i_bsame != i; 1363 ppi = &(*ppi)->i_bsame) 1364 continue; 1365 if (*ppi == NULL) 1366 panic("deldev: dev (%s) doesn't list the devi" 1367 " (%s at %s)", d->d_name, i->i_name, i->i_at); 1368 f = *ppi; 1369 if (f == i) 1370 /* That implies d->d_ihead == i */ 1371 *ppi = j; 1372 else 1373 (*ppi)->i_bsame = j; 1374 if (d->d_ipp == &i->i_bsame) { 1375 if (i->i_alias == NULL) { 1376 if (f == i) 1377 d->d_ipp = &d->d_ihead; 1378 else 1379 d->d_ipp = &f->i_bsame; 1380 } else 1381 d->d_ipp = &i->i_alias->i_bsame; 1382 } 1383 } 1384 /* 1385 * - delete the attachment instance 1386 */ 1387 iba = i->i_atdeva; 1388 for (ppi = &iba->d_ihead; 1389 *ppi != NULL && *ppi != i && (*ppi)->i_asame != i; 1390 ppi = &(*ppi)->i_asame) 1391 continue; 1392 if (*ppi == NULL) 1393 panic("deldev: deva (%s) doesn't list the devi (%s)", 1394 iba->d_name, i->i_name); 1395 f = *ppi; 1396 if (f == i) 1397 /* That implies iba->d_ihead == i */ 1398 *ppi = i->i_asame; 1399 else 1400 (*ppi)->i_asame = i->i_asame; 1401 if (iba->d_ipp == &i->i_asame) { 1402 if (f == i) 1403 iba->d_ipp = &iba->d_ihead; 1404 else 1405 iba->d_ipp = &f->i_asame; 1406 } 1407 /* 1408 * - delete the pspec 1409 */ 1410 if (i->i_pspec) { 1411 struct pspec *p = i->i_pspec; 1412 struct nvlist *nv, *onv; 1413 1414 /* Double-linked nvlist anyone? */ 1415 for (nv = p->p_devs; nv->nv_next != NULL; nv = nv->nv_next) { 1416 if (nv->nv_next && nv->nv_next->nv_ptr == i) { 1417 onv = nv->nv_next; 1418 nv->nv_next = onv->nv_next; 1419 nvfree(onv); 1420 break; 1421 } 1422 if (nv->nv_ptr == i) { 1423 /* nv is p->p_devs in that case */ 1424 p->p_devs = nv->nv_next; 1425 nvfree(nv); 1426 break; 1427 } 1428 } 1429 if (p->p_devs == NULL) 1430 TAILQ_REMOVE(&allpspecs, p, p_list); 1431 } 1432 /* 1433 * - delete the alldevi entry 1434 */ 1435 TAILQ_REMOVE(&alldevi, i, i_next); 1436 ndevi--; 1437 /* 1438 * Put it in deaddevitab 1439 * 1440 * Each time a devi is removed, devilevel is increased so that later on 1441 * it is possible to tell if an instance was added before or after the 1442 * removal of its parent. 1443 * 1444 * For active instances, i_level contains the number of devi removed so 1445 * far, and for dead devis, it contains its index. 1446 */ 1447 i->i_level = devilevel++; 1448 i->i_alias = NULL; 1449 f = ht_lookup(deaddevitab, i->i_name); 1450 if (f == NULL) { 1451 if (ht_insert(deaddevitab, i->i_name, i)) 1452 panic("remove_devi(%s) - can't add to deaddevitab", 1453 i->i_name); 1454 } else { 1455 for (j = f; j->i_alias != NULL; j = j->i_alias) 1456 continue; 1457 j->i_alias = i; 1458 } 1459 /* 1460 * - reconstruct d->d_umax 1461 */ 1462 d->d_umax = 0; 1463 for (i = d->d_ihead; i != NULL; i = i->i_bsame) 1464 if (i->i_unit >= d->d_umax) 1465 d->d_umax = i->i_unit + 1; 1466 } 1467 1468 void 1469 deldeva(const char *at) 1470 { 1471 int unit; 1472 const char *cp; 1473 struct devbase *d, *ad; 1474 struct devi *i, *j; 1475 struct attr *a; 1476 struct pspec *p; 1477 struct nvlist *nv, *stack = NULL; 1478 1479 if (at == NULL) { 1480 TAILQ_FOREACH(i, &alldevi, i_next) 1481 if (i->i_at == NULL) 1482 stack = newnv(NULL, NULL, i, 0, stack); 1483 } else { 1484 size_t l; 1485 1486 CFGDBG(5, "deselecting deva `%s'", at); 1487 if (at[0] == '\0') 1488 goto out; 1489 1490 l = strlen(at) - 1; 1491 if (at[l] == '?' || isdigit((unsigned char)at[l])) { 1492 char base[NAMESIZE]; 1493 1494 if (split(at, l+1, base, sizeof base, &unit)) { 1495 out: 1496 cfgerror("invalid attachment name `%s'", at); 1497 return; 1498 } 1499 cp = intern(base); 1500 } else { 1501 cp = intern(at); 1502 unit = STAR; 1503 } 1504 1505 ad = ht_lookup(devbasetab, cp); 1506 a = ht_lookup(attrtab, cp); 1507 if (a == NULL) { 1508 cfgerror("unknown attachment attribute or device `%s'", 1509 cp); 1510 return; 1511 } 1512 if (!a->a_iattr) { 1513 cfgerror("plain attribute `%s' cannot have children", 1514 a->a_name); 1515 return; 1516 } 1517 1518 /* 1519 * remove_devi() makes changes to the devbase's list and the 1520 * alias list, * so the actual deletion of the instances must 1521 * be delayed. 1522 */ 1523 for (nv = a->a_devs; nv != NULL; nv = nv->nv_next) { 1524 d = nv->nv_ptr; 1525 for (i = d->d_ihead; i != NULL; i = i->i_bsame) 1526 for (j = i; j != NULL; j = j->i_alias) { 1527 /* Ignore devices at root */ 1528 if (j->i_at == NULL) 1529 continue; 1530 p = j->i_pspec; 1531 /* 1532 * There are three cases: 1533 * 1534 * 1. unit is not STAR. Consider 'at' 1535 * to be explicit, even if it 1536 * references an interface 1537 * attribute. 1538 * 1539 * 2. unit is STAR and 'at' references 1540 * a real device. Look for pspec 1541 * that have a matching p_atdev 1542 * field. 1543 * 1544 * 3. unit is STAR and 'at' references 1545 * an interface attribute. Look 1546 * for pspec that have a matching 1547 * p_iattr field. 1548 */ 1549 if ((unit != STAR && /* Case */ 1550 !strcmp(j->i_at, at)) || /* 1 */ 1551 (unit == STAR && 1552 ((ad != NULL && /* Case */ 1553 p->p_atdev == ad) || /* 2 */ 1554 (ad == NULL && /* Case */ 1555 p->p_iattr == a)))) /* 3 */ 1556 stack = newnv(NULL, NULL, j, 0, 1557 stack); 1558 } 1559 } 1560 } 1561 1562 for (nv = stack; nv != NULL; nv = nv->nv_next) 1563 remove_devi(nv->nv_ptr); 1564 nvfreel(stack); 1565 } 1566 1567 void 1568 deldev(const char *name) 1569 { 1570 size_t l; 1571 struct devi *firsti, *i; 1572 struct nvlist *nv, *stack = NULL; 1573 1574 CFGDBG(5, "deselecting dev `%s'", name); 1575 if (name[0] == '\0') 1576 goto out; 1577 1578 l = strlen(name) - 1; 1579 if (name[l] == '*' || isdigit((unsigned char)name[l])) { 1580 /* `no mydev0' or `no mydev*' */ 1581 firsti = ht_lookup(devitab, name); 1582 if (firsti == NULL) { 1583 out: 1584 cfgerror("unknown instance %s", name); 1585 return; 1586 } 1587 for (i = firsti; i != NULL; i = i->i_alias) 1588 stack = newnv(NULL, NULL, i, 0, stack); 1589 } else { 1590 struct devbase *d = ht_lookup(devbasetab, name); 1591 1592 if (d == NULL) { 1593 cfgerror("unknown device %s", name); 1594 return; 1595 } 1596 if (d->d_ispseudo) { 1597 cfgerror("%s is a pseudo-device; " 1598 "use \"no pseudo-device %s\" instead", name, 1599 name); 1600 return; 1601 } 1602 1603 for (firsti = d->d_ihead; firsti != NULL; 1604 firsti = firsti->i_bsame) 1605 for (i = firsti; i != NULL; i = i->i_alias) 1606 stack = newnv(NULL, NULL, i, 0, stack); 1607 } 1608 1609 for (nv = stack; nv != NULL; nv = nv->nv_next) 1610 remove_devi(nv->nv_ptr); 1611 nvfreel(stack); 1612 } 1613 1614 /* 1615 * Insert given device "name" into devroottab. In case "name" 1616 * designates a pure interface attribute, create a fake device 1617 * instance for the attribute and insert that into the roottab 1618 * (this scheme avoids mucking around with the orphanage analysis). 1619 */ 1620 void 1621 addpseudoroot(const char *name) 1622 { 1623 char buf[NAMESIZE]; 1624 int unit; 1625 struct attr *attr; 1626 struct devi *i; 1627 struct deva *iba; 1628 struct devbase *ib; 1629 1630 if (split(name, strlen(name), buf, sizeof(buf), &unit)) { 1631 cfgerror("invalid pseudo-root name `%s'", name); 1632 return; 1633 } 1634 1635 /* 1636 * Prefer device because devices with locators define an 1637 * implicit interface attribute. However, if a device is 1638 * not available, try to attach to the interface attribute. 1639 * This makes sure adddev() doesn't get confused when we 1640 * are really attaching to a device (alternatively we maybe 1641 * could specify a non-NULL atlist to defdevattach() below). 1642 */ 1643 ib = ht_lookup(devbasetab, intern(buf)); 1644 if (ib == NULL) { 1645 struct devbase *fakedev; 1646 char fakename[NAMESIZE]; 1647 1648 attr = ht_lookup(attrtab, intern(buf)); 1649 if (!(attr && attr->a_iattr)) { 1650 cfgerror("pseudo-root `%s' not available", name); 1651 return; 1652 } 1653 1654 /* 1655 * here we cheat a bit: create a fake devbase with the 1656 * interface attribute and instantiate it. quick, cheap, 1657 * dirty & bad for you, much like the stuff in the fridge. 1658 * and, it works, since the pseudoroot device is not included 1659 * in ioconf, just used by config to make sure we start from 1660 * the right place. 1661 */ 1662 snprintf(fakename, sizeof(fakename), "%s_devattrs", buf); 1663 fakedev = getdevbase(intern(fakename)); 1664 fakedev->d_isdef = 1; 1665 fakedev->d_ispseudo = 0; 1666 fakedev->d_attrs = attrlist_cons(NULL, attr); 1667 defdevattach(NULL, fakedev, NULL, NULL); 1668 1669 if (unit == STAR) 1670 snprintf(buf, sizeof(buf), "%s*", fakename); 1671 else 1672 snprintf(buf, sizeof(buf), "%s%d", fakename, unit); 1673 name = buf; 1674 } 1675 1676 /* ok, everything should be set up, so instantiate a fake device */ 1677 i = getdevi(name); 1678 if (i == NULL) 1679 panic("device `%s' expected to be present", name); 1680 ib = i->i_base; 1681 iba = ib->d_ahead; 1682 1683 i->i_atdeva = iba; 1684 i->i_cfflags = 0; 1685 i->i_locs = fixloc(name, &errattr, NULL); 1686 i->i_pseudoroot = 1; 1687 i->i_active = DEVI_ORPHAN; /* set active by kill_orphans() */ 1688 1689 *iba->d_ipp = i; 1690 iba->d_ipp = &i->i_asame; 1691 1692 ht_insert(devroottab, ib->d_name, ib); 1693 } 1694 1695 void 1696 addpseudo(const char *name, int number) 1697 { 1698 struct devbase *d; 1699 struct devi *i; 1700 1701 d = ht_lookup(devbasetab, name); 1702 if (d == NULL) { 1703 cfgerror("undefined pseudo-device %s", name); 1704 return; 1705 } 1706 if (!d->d_ispseudo) { 1707 cfgerror("%s is a real device, not a pseudo-device", name); 1708 return; 1709 } 1710 if (ht_lookup(devitab, name) != NULL) { 1711 cfgerror("`%s' already defined", name); 1712 return; 1713 } 1714 i = newdevi(name, number - 1, d); /* foo 16 => "foo0..foo15" */ 1715 if (ht_insert(devitab, name, i)) 1716 panic("addpseudo(%s)", name); 1717 /* Useful to retrieve the instance from the devbase */ 1718 d->d_ihead = i; 1719 i->i_active = DEVI_ACTIVE; 1720 TAILQ_INSERT_TAIL(&allpseudo, i, i_next); 1721 } 1722 1723 void 1724 delpseudo(const char *name) 1725 { 1726 struct devbase *d; 1727 struct devi *i; 1728 1729 CFGDBG(5, "deselecting pseudo `%s'", name); 1730 d = ht_lookup(devbasetab, name); 1731 if (d == NULL) { 1732 cfgerror("undefined pseudo-device %s", name); 1733 return; 1734 } 1735 if (!d->d_ispseudo) { 1736 cfgerror("%s is a real device, not a pseudo-device", name); 1737 return; 1738 } 1739 if ((i = ht_lookup(devitab, name)) == NULL) { 1740 cfgerror("`%s' not defined", name); 1741 return; 1742 } 1743 d->d_umax = 0; /* clear neads-count entries */ 1744 d->d_ihead = NULL; /* make sure it won't be considered active */ 1745 TAILQ_REMOVE(&allpseudo, i, i_next); 1746 if (ht_remove(devitab, name)) 1747 panic("delpseudo(%s) - can't remove from devitab", name); 1748 if (ht_insert(deaddevitab, name, i)) 1749 panic("delpseudo(%s) - can't add to deaddevitab", name); 1750 } 1751 1752 void 1753 adddevm(const char *name, devmajor_t cmajor, devmajor_t bmajor, 1754 struct condexpr *cond, struct nvlist *nv_nodes) 1755 { 1756 struct devm *dm; 1757 1758 if (cmajor != NODEVMAJOR && (cmajor < 0 || cmajor >= 4096)) { 1759 cfgerror("character major %d is invalid", cmajor); 1760 condexpr_destroy(cond); 1761 nvfreel(nv_nodes); 1762 return; 1763 } 1764 1765 if (bmajor != NODEVMAJOR && (bmajor < 0 || bmajor >= 4096)) { 1766 cfgerror("block major %d is invalid", bmajor); 1767 condexpr_destroy(cond); 1768 nvfreel(nv_nodes); 1769 return; 1770 } 1771 if (cmajor == NODEVMAJOR && bmajor == NODEVMAJOR) { 1772 cfgerror("both character/block majors are not specified"); 1773 condexpr_destroy(cond); 1774 nvfreel(nv_nodes); 1775 return; 1776 } 1777 1778 dm = ecalloc(1, sizeof(*dm)); 1779 dm->dm_srcfile = yyfile; 1780 dm->dm_srcline = currentline(); 1781 dm->dm_name = name; 1782 dm->dm_cmajor = cmajor; 1783 dm->dm_bmajor = bmajor; 1784 dm->dm_opts = cond; 1785 dm->dm_devnodes = nv_nodes; 1786 1787 TAILQ_INSERT_TAIL(&alldevms, dm, dm_next); 1788 1789 maxcdevm = MAX(maxcdevm, dm->dm_cmajor); 1790 maxbdevm = MAX(maxbdevm, dm->dm_bmajor); 1791 } 1792 1793 int 1794 fixdevis(void) 1795 { 1796 struct devi *i; 1797 int error = 0; 1798 1799 TAILQ_FOREACH(i, &alldevi, i_next) { 1800 CFGDBG(3, "fixing devis `%s'", i->i_name); 1801 if (i->i_active == DEVI_ACTIVE) 1802 selectbase(i->i_base, i->i_atdeva); 1803 else if (i->i_active == DEVI_ORPHAN) { 1804 /* 1805 * At this point, we can't have instances for which 1806 * i_at or i_pspec are NULL. 1807 */ 1808 ++error; 1809 cfgxerror(i->i_srcfile, i->i_lineno, 1810 "`%s at %s' is orphaned (%s `%s' found)", 1811 i->i_name, i->i_at, i->i_pspec->p_atunit == WILD ? 1812 "nothing matching" : "no", i->i_at); 1813 } else if (vflag && i->i_active == DEVI_IGNORED) 1814 cfgxwarn(i->i_srcfile, i->i_lineno, "ignoring " 1815 "explicitly orphaned instance `%s at %s'", 1816 i->i_name, i->i_at); 1817 } 1818 1819 if (error) 1820 return error; 1821 1822 TAILQ_FOREACH(i, &allpseudo, i_next) 1823 if (i->i_active == DEVI_ACTIVE) 1824 selectbase(i->i_base, NULL); 1825 return 0; 1826 } 1827 1828 /* 1829 * Look up a parent spec, creating a new one if it does not exist. 1830 */ 1831 static struct pspec * 1832 getpspec(struct attr *attr, struct devbase *ab, int atunit) 1833 { 1834 struct pspec *p; 1835 1836 TAILQ_FOREACH(p, &allpspecs, p_list) { 1837 if (p->p_iattr == attr && 1838 p->p_atdev == ab && 1839 p->p_atunit == atunit) 1840 return (p); 1841 } 1842 1843 p = ecalloc(1, sizeof(*p)); 1844 1845 p->p_iattr = attr; 1846 p->p_atdev = ab; 1847 p->p_atunit = atunit; 1848 p->p_inst = npspecs++; 1849 p->p_active = 0; 1850 1851 TAILQ_INSERT_TAIL(&allpspecs, p, p_list); 1852 1853 return (p); 1854 } 1855 1856 /* 1857 * Define a new instance of a specific device. 1858 */ 1859 static struct devi * 1860 getdevi(const char *name) 1861 { 1862 struct devi *i, *firsti; 1863 struct devbase *d; 1864 int unit; 1865 char base[NAMESIZE]; 1866 1867 if (split(name, strlen(name), base, sizeof base, &unit)) { 1868 cfgerror("invalid device name `%s'", name); 1869 return (NULL); 1870 } 1871 d = ht_lookup(devbasetab, intern(base)); 1872 if (d == NULL) { 1873 cfgerror("%s: unknown device `%s'", name, base); 1874 return (NULL); 1875 } 1876 if (d->d_ispseudo) { 1877 cfgerror("%s: %s is a pseudo-device", name, base); 1878 return (NULL); 1879 } 1880 firsti = ht_lookup(devitab, name); 1881 i = newdevi(name, unit, d); 1882 if (firsti == NULL) { 1883 if (ht_insert(devitab, name, i)) 1884 panic("getdevi(%s)", name); 1885 *d->d_ipp = i; 1886 d->d_ipp = &i->i_bsame; 1887 } else { 1888 while (firsti->i_alias) 1889 firsti = firsti->i_alias; 1890 firsti->i_alias = i; 1891 } 1892 TAILQ_INSERT_TAIL(&alldevi, i, i_next); 1893 ndevi++; 1894 return (i); 1895 } 1896 1897 static const char * 1898 concat(const char *name, int c) 1899 { 1900 size_t len; 1901 char buf[NAMESIZE]; 1902 1903 len = strlen(name); 1904 if (len + 2 > sizeof(buf)) { 1905 cfgerror("device name `%s%c' too long", name, c); 1906 len = sizeof(buf) - 2; 1907 } 1908 memmove(buf, name, len); 1909 buf[len] = (char)c; 1910 buf[len + 1] = '\0'; 1911 return (intern(buf)); 1912 } 1913 1914 const char * 1915 starref(const char *name) 1916 { 1917 1918 return (concat(name, '*')); 1919 } 1920 1921 const char * 1922 wildref(const char *name) 1923 { 1924 1925 return (concat(name, '?')); 1926 } 1927 1928 /* 1929 * Split a name like "foo0" into base name (foo) and unit number (0). 1930 * Return 0 on success. To make this useful for names like "foo0a", 1931 * the length of the "foo0" part is one of the arguments. 1932 */ 1933 static int 1934 split(const char *name, size_t nlen, char *base, size_t bsize, int *aunit) 1935 { 1936 const char *cp; 1937 int c; 1938 size_t l; 1939 1940 l = nlen; 1941 if (l < 2 || l >= bsize || isdigit((unsigned char)*name)) 1942 return (1); 1943 c = (u_char)name[--l]; 1944 if (!isdigit(c)) { 1945 if (c == '*') 1946 *aunit = STAR; 1947 else if (c == '?') 1948 *aunit = WILD; 1949 else 1950 return (1); 1951 } else { 1952 cp = &name[l]; 1953 while (isdigit((unsigned char)cp[-1])) 1954 l--, cp--; 1955 *aunit = atoi(cp); 1956 } 1957 memmove(base, name, l); 1958 base[l] = 0; 1959 return (0); 1960 } 1961 1962 void 1963 addattr(const char *name) 1964 { 1965 struct attr *a; 1966 1967 a = refattr(name); 1968 selectattr(a); 1969 } 1970 1971 void 1972 delattr(const char *name) 1973 { 1974 struct attr *a; 1975 1976 a = refattr(name); 1977 deselectattr(a); 1978 } 1979 1980 void 1981 selectattr(struct attr *a) 1982 { 1983 struct attrlist *al; 1984 struct attr *dep; 1985 1986 CFGDBG(5, "selecting attr `%s'", a->a_name); 1987 for (al = a->a_deps; al != NULL; al = al->al_next) { 1988 dep = al->al_this; 1989 selectattr(dep); 1990 } 1991 if (ht_insert(selecttab, a->a_name, __UNCONST(a->a_name)) == 0) 1992 nattrs++; 1993 CFGDBG(3, "attr selected `%s'", a->a_name); 1994 } 1995 1996 static int 1997 deselectattrcb2(const char *name1, const char *name2, void *v, void *arg) 1998 { 1999 const char *name = arg; 2000 2001 if (strcmp(name, name2) == 0) 2002 delattr(name1); 2003 return 0; 2004 } 2005 2006 void 2007 deselectattr(struct attr *a) 2008 { 2009 2010 CFGDBG(5, "deselecting attr `%s'", a->a_name); 2011 ht_enumerate2(attrdeptab, deselectattrcb2, __UNCONST(a->a_name)); 2012 if (ht_remove(selecttab, a->a_name) == 0) 2013 nattrs--; 2014 CFGDBG(3, "attr deselected `%s'", a->a_name); 2015 } 2016 2017 static int 2018 dumpattrdepcb2(const char *name1, const char *name2, void *v, void *arg) 2019 { 2020 2021 CFGDBG(3, "attr `%s' depends on attr `%s'", name1, name2); 2022 return 0; 2023 } 2024 2025 void 2026 dependattrs(void) 2027 { 2028 2029 ht_enumerate2(attrdeptab, dumpattrdepcb2, NULL); 2030 } 2031 2032 /* 2033 * We have an instance of the base foo, so select it and all its 2034 * attributes for "optional foo". 2035 */ 2036 static void 2037 selectbase(struct devbase *d, struct deva *da) 2038 { 2039 struct attr *a; 2040 struct attrlist *al; 2041 2042 (void)ht_insert(selecttab, d->d_name, __UNCONST(d->d_name)); 2043 CFGDBG(3, "devbase selected `%s'", d->d_name); 2044 CFGDBG(5, "selecting dependencies of devbase `%s'", d->d_name); 2045 for (al = d->d_attrs; al != NULL; al = al->al_next) { 2046 a = al->al_this; 2047 expandattr(a, selectattr); 2048 } 2049 2050 struct attr *devattr; 2051 devattr = refattr(d->d_name); 2052 expandattr(devattr, selectattr); 2053 2054 if (da != NULL) { 2055 (void)ht_insert(selecttab, da->d_name, __UNCONST(da->d_name)); 2056 CFGDBG(3, "devattr selected `%s'", da->d_name); 2057 for (al = da->d_attrs; al != NULL; al = al->al_next) { 2058 a = al->al_this; 2059 expandattr(a, selectattr); 2060 } 2061 } 2062 2063 fixdev(d); 2064 } 2065 2066 /* 2067 * Is the given pointer on the given list of pointers? 2068 */ 2069 int 2070 onlist(struct nvlist *nv, void *ptr) 2071 { 2072 for (; nv != NULL; nv = nv->nv_next) 2073 if (nv->nv_ptr == ptr) 2074 return (1); 2075 return (0); 2076 } 2077 2078 static char * 2079 extend(char *p, const char *name) 2080 { 2081 size_t l; 2082 2083 l = strlen(name); 2084 memmove(p, name, l); 2085 p += l; 2086 *p++ = ','; 2087 *p++ = ' '; 2088 return (p); 2089 } 2090 2091 /* 2092 * Check that we got all required locators, and default any that are 2093 * given as "?" and have defaults. Return 0 on success. 2094 */ 2095 static const char ** 2096 fixloc(const char *name, struct attr *attr, struct loclist *got) 2097 { 2098 struct loclist *m, *n; 2099 int ord; 2100 const char **lp; 2101 int nmissing, nextra, nnodefault; 2102 char *mp, *ep, *ndp; 2103 char missing[1000], extra[1000], nodefault[1000]; 2104 static const char *nullvec[1]; 2105 2106 /* 2107 * Look for all required locators, and number the given ones 2108 * according to the required order. While we are numbering, 2109 * set default values for defaulted locators. 2110 */ 2111 if (attr->a_loclen == 0) /* e.g., "at root" */ 2112 lp = nullvec; 2113 else 2114 lp = emalloc((size_t)(attr->a_loclen + 1) * sizeof(const char *)); 2115 for (n = got; n != NULL; n = n->ll_next) 2116 n->ll_num = -1; 2117 nmissing = 0; 2118 mp = missing; 2119 /* yes, this is O(mn), but m and n should be small */ 2120 for (ord = 0, m = attr->a_locs; m != NULL; m = m->ll_next, ord++) { 2121 for (n = got; n != NULL; n = n->ll_next) { 2122 if (n->ll_name == m->ll_name) { 2123 n->ll_num = ord; 2124 break; 2125 } 2126 } 2127 if (n == NULL && m->ll_num == 0) { 2128 nmissing++; 2129 mp = extend(mp, m->ll_name); 2130 } 2131 lp[ord] = m->ll_string; 2132 } 2133 if (ord != attr->a_loclen) 2134 panic("fixloc"); 2135 lp[ord] = NULL; 2136 nextra = 0; 2137 ep = extra; 2138 nnodefault = 0; 2139 ndp = nodefault; 2140 for (n = got; n != NULL; n = n->ll_next) { 2141 if (n->ll_num >= 0) { 2142 if (n->ll_string != NULL) 2143 lp[n->ll_num] = n->ll_string; 2144 else if (lp[n->ll_num] == NULL) { 2145 nnodefault++; 2146 ndp = extend(ndp, n->ll_name); 2147 } 2148 } else { 2149 nextra++; 2150 ep = extend(ep, n->ll_name); 2151 } 2152 } 2153 if (nextra) { 2154 ep[-2] = 0; /* kill ", " */ 2155 cfgerror("%s: extraneous locator%s: %s", 2156 name, nextra > 1 ? "s" : "", extra); 2157 } 2158 if (nmissing) { 2159 mp[-2] = 0; 2160 cfgerror("%s: must specify %s", name, missing); 2161 } 2162 if (nnodefault) { 2163 ndp[-2] = 0; 2164 cfgerror("%s: cannot wildcard %s", name, nodefault); 2165 } 2166 if (nmissing || nnodefault) { 2167 free(lp); 2168 lp = NULL; 2169 } 2170 return (lp); 2171 } 2172 2173 void 2174 setversion(int newver) 2175 { 2176 if (newver > CONFIG_VERSION) 2177 cfgerror("your sources require a newer version of config(1) " 2178 "-- please rebuild it."); 2179 else if (newver < CONFIG_MINVERSION) 2180 cfgerror("your sources are out of date -- please update."); 2181 else 2182 version = newver; 2183 } 2184