config.y revision 8480
1%union { 2 char *str; 3 int val; 4 struct file_list *file; 5 struct idlst *lst; 6} 7 8%token AND 9%token ANY 10%token ARGS 11%token AT 12%token BIO 13%token COMMA 14%token CONFIG 15%token CONFLICTS 16%token CONTROLLER 17%token CPU 18%token CSR 19%token DEVICE 20%token DISK 21%token DRIVE 22%token DRQ 23%token DST 24%token DUMPS 25%token EQUALS 26%token FLAGS 27%token HZ 28%token IDENT 29%token INTERLEAVE 30%token IOMEM 31%token IOSIZ 32%token IRQ 33%token MACHINE 34%token MAJOR 35%token MASTER 36%token MAXUSERS 37%token MINOR 38%token MINUS 39%token NET 40%token NEXUS 41%token ON 42%token OPTIONS 43%token MAKEOPTIONS 44%token PORT 45%token PRIORITY 46%token PSEUDO_DEVICE 47%token ROOT 48%token SEMICOLON 49%token SEQUENTIAL 50%token SIZE 51%token SLAVE 52%token SWAP 53%token TARGET 54%token TIMEZONE 55%token TTY 56%token TRACE 57%token UNIT 58%token VECTOR 59 60%token <str> ID 61%token <val> NUMBER 62%token <val> FPNUMBER 63 64%type <str> Save_id 65%type <str> Opt_value 66%type <str> Dev 67%type <lst> Id_list 68%type <val> optional_size 69%type <val> optional_sflag 70%type <str> device_name 71%type <val> major_minor 72%type <val> arg_device_spec 73%type <val> root_device_spec root_device_specs 74%type <val> dump_device_spec 75%type <file> swap_device_spec 76%type <file> comp_device_spec 77 78%{ 79 80/* 81 * Copyright (c) 1988, 1993 82 * The Regents of the University of California. All rights reserved. 83 * 84 * Redistribution and use in source and binary forms, with or without 85 * modification, are permitted provided that the following conditions 86 * are met: 87 * 1. Redistributions of source code must retain the above copyright 88 * notice, this list of conditions and the following disclaimer. 89 * 2. Redistributions in binary form must reproduce the above copyright 90 * notice, this list of conditions and the following disclaimer in the 91 * documentation and/or other materials provided with the distribution. 92 * 3. All advertising materials mentioning features or use of this software 93 * must display the following acknowledgement: 94 * This product includes software developed by the University of 95 * California, Berkeley and its contributors. 96 * 4. Neither the name of the University nor the names of its contributors 97 * may be used to endorse or promote products derived from this software 98 * without specific prior written permission. 99 * 100 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 101 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 102 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 103 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 104 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 105 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 106 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 107 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 108 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 109 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 110 * SUCH DAMAGE. 111 * 112 * @(#)config.y 8.1 (Berkeley) 6/6/93 113 */ 114 115#include "config.h" 116 117#include <sys/disklabel.h> 118#include <sys/diskslice.h> 119 120#include <ctype.h> 121#include <stdio.h> 122#include <err.h> 123 124struct device cur; 125struct device *curp = 0; 126char *temp_id; 127char *val_id; 128 129%} 130%% 131Configuration: 132 Many_specs 133 = { verifysystemspecs(); } 134 ; 135 136Many_specs: 137 Many_specs Spec 138 | 139 /* lambda */ 140 ; 141 142Spec: 143 Device_spec SEMICOLON 144 = { newdev(&cur); } | 145 Config_spec SEMICOLON 146 | 147 TRACE SEMICOLON 148 = { do_trace = !do_trace; } | 149 SEMICOLON 150 | 151 error SEMICOLON 152 ; 153 154Config_spec: 155 MACHINE Save_id 156 = { 157 if (!strcmp($2, "vax")) { 158 machine = MACHINE_VAX; 159 machinename = "vax"; 160 } else if (!strcmp($2, "tahoe")) { 161 machine = MACHINE_TAHOE; 162 machinename = "tahoe"; 163 } else if (!strcmp($2, "hp300")) { 164 machine = MACHINE_HP300; 165 machinename = "hp300"; 166 } else if (!strcmp($2, "i386")) { 167 machine = MACHINE_I386; 168 machinename = "i386"; 169 } else if (!strcmp($2, "mips")) { 170 machine = MACHINE_MIPS; 171 machinename = "mips"; 172 } else if (!strcmp($2, "pmax")) { 173 machine = MACHINE_PMAX; 174 machinename = "pmax"; 175 } else if (!strcmp($2, "luna68k")) { 176 machine = MACHINE_LUNA68K; 177 machinename = "luna68k"; 178 } else if (!strcmp($2, "news3400")) { 179 machine = MACHINE_NEWS3400; 180 machinename = "news3400"; 181 } else 182 yyerror("Unknown machine type"); 183 } | 184 CPU Save_id 185 = { 186 struct cputype *cp = 187 (struct cputype *)malloc(sizeof (struct cputype)); 188 cp->cpu_name = ns($2); 189 cp->cpu_next = cputype; 190 cputype = cp; 191 free(temp_id); 192 } | 193 OPTIONS Opt_list 194 | 195 MAKEOPTIONS Mkopt_list 196 | 197 IDENT ID 198 = { ident = ns($2); } | 199 System_spec 200 | 201 HZ NUMBER 202 = { yyerror("HZ specification obsolete; delete"); } | 203 TIMEZONE NUMBER 204 = { zone = 60 * $2; check_tz(); } | 205 TIMEZONE NUMBER DST NUMBER 206 = { zone = 60 * $2; dst = $4; check_tz(); } | 207 TIMEZONE NUMBER DST 208 = { zone = 60 * $2; dst = 1; check_tz(); } | 209 TIMEZONE FPNUMBER 210 = { zone = $2; check_tz(); } | 211 TIMEZONE FPNUMBER DST NUMBER 212 = { zone = $2; dst = $4; check_tz(); } | 213 TIMEZONE FPNUMBER DST 214 = { zone = $2; dst = 1; check_tz(); } | 215 TIMEZONE MINUS NUMBER 216 = { zone = -60 * $3; check_tz(); } | 217 TIMEZONE MINUS NUMBER DST NUMBER 218 = { zone = -60 * $3; dst = $5; check_tz(); } | 219 TIMEZONE MINUS NUMBER DST 220 = { zone = -60 * $3; dst = 1; check_tz(); } | 221 TIMEZONE MINUS FPNUMBER 222 = { zone = -$3; check_tz(); } | 223 TIMEZONE MINUS FPNUMBER DST NUMBER 224 = { zone = -$3; dst = $5; check_tz(); } | 225 TIMEZONE MINUS FPNUMBER DST 226 = { zone = -$3; dst = 1; check_tz(); } | 227 MAXUSERS NUMBER 228 = { maxusers = $2; }; 229 230System_spec: 231 System_id System_parameter_list 232 = { checksystemspec(*confp); } 233 ; 234 235System_id: 236 CONFIG Save_id 237 = { mkconf($2); } 238 ; 239 240System_parameter_list: 241 System_parameter_list System_parameter 242 | System_parameter 243 ; 244 245System_parameter: 246 addr_spec 247 | swap_spec 248 | root_spec 249 | dump_spec 250 | arg_spec 251 ; 252 253addr_spec: 254 AT NUMBER 255 = { loadaddress = $2; } 256 ; 257 258swap_spec: 259 SWAP optional_on swap_device_list 260 ; 261 262swap_device_list: 263 swap_device_list AND swap_device 264 | swap_device 265 ; 266 267swap_device: 268 swap_device_spec optional_size optional_sflag 269 = { mkswap(*confp, $1, $2, $3); } 270 ; 271 272swap_device_spec: 273 device_name 274 = { 275 struct file_list *fl = newflist(SWAPSPEC); 276 277 if (eq($1, "generic")) 278 fl->f_fn = $1; 279 else { 280 fl->f_swapdev = nametodev($1, 0, 281 COMPATIBILITY_SLICE, 'b'); 282 fl->f_fn = devtoname(fl->f_swapdev); 283 } 284 $$ = fl; 285 } 286 | major_minor 287 = { 288 struct file_list *fl = newflist(SWAPSPEC); 289 290 fl->f_swapdev = $1; 291 fl->f_fn = devtoname($1); 292 $$ = fl; 293 } 294 ; 295 296root_spec: 297 ROOT optional_on root_device_specs 298 = { 299 struct file_list *fl = *confp; 300 301 if (fl && fl->f_rootdev != NODEV) 302 yyerror("extraneous root device specification"); 303 else 304 fl->f_rootdev = $3; 305 } 306 ; 307 308root_device_specs: 309 root_device_spec AND root_device_specs 310 = { 311 warnx("extraneous root devices ignored"); 312 $$ = $1; 313 } 314 | root_device_spec 315 ; 316 317root_device_spec: 318 device_name 319 = { $$ = nametodev($1, 0, COMPATIBILITY_SLICE, 'a'); } 320 | major_minor 321 ; 322 323dump_spec: 324 DUMPS optional_on dump_device_spec 325 = { 326 struct file_list *fl = *confp; 327 328 if (fl && fl->f_dumpdev != NODEV) 329 yyerror("extraneous dump device specification"); 330 else 331 fl->f_dumpdev = $3; 332 } 333 334 ; 335 336dump_device_spec: 337 device_name 338 = { $$ = nametodev($1, 0, COMPATIBILITY_SLICE, 'b'); } 339 | major_minor 340 ; 341 342arg_spec: 343 ARGS optional_on arg_device_spec 344 = { yyerror("arg device specification obsolete, ignored"); } 345 ; 346 347arg_device_spec: 348 device_name 349 = { $$ = nametodev($1, 0, COMPATIBILITY_SLICE, 'b'); } 350 | major_minor 351 ; 352 353major_minor: 354 MAJOR NUMBER MINOR NUMBER 355 = { $$ = makedev($2, $4); } 356 ; 357 358optional_on: 359 ON 360 | /* empty */ 361 ; 362 363optional_size: 364 SIZE NUMBER 365 = { $$ = $2; } 366 | /* empty */ 367 = { $$ = 0; } 368 ; 369 370optional_sflag: 371 SEQUENTIAL 372 = { $$ = 2; } 373 | /* empty */ 374 = { $$ = 0; } 375 ; 376 377device_name: 378 Save_id 379 = { $$ = $1; } 380 | Save_id NUMBER 381 = { 382 char buf[80]; 383 384 (void) sprintf(buf, "%s%d", $1, $2); 385 $$ = ns(buf); free($1); 386 } 387 | Save_id NUMBER ID 388 = { 389 char buf[80]; 390 391 (void) sprintf(buf, "%s%d%s", $1, $2, $3); 392 $$ = ns(buf); free($1); 393 } 394 | Save_id NUMBER ID NUMBER 395 = { 396 char buf[80]; 397 398 (void) sprintf(buf, "%s%d%s%d", $1, $2, $3, $4); 399 $$ = ns(buf); free($1); 400 } 401 | Save_id NUMBER ID NUMBER ID 402 = { 403 char buf[80]; 404 405 (void) sprintf(buf, "%s%d%s%d%s", $1, $2, $3, $4, $5); 406 $$ = ns(buf); free($1); 407 } 408 ; 409 410Opt_list: 411 Opt_list COMMA Option 412 | 413 Option 414 ; 415 416Option: 417 Save_id 418 = { 419 struct opt *op = (struct opt *)malloc(sizeof (struct opt)); 420 op->op_name = ns($1); 421 op->op_next = opt; 422 op->op_value = 0; 423 opt = op; 424 free(temp_id); 425 } | 426 Save_id EQUALS Opt_value 427 = { 428 struct opt *op = (struct opt *)malloc(sizeof (struct opt)); 429 op->op_name = ns($1); 430 op->op_next = opt; 431 op->op_value = ns($3); 432 opt = op; 433 free(temp_id); 434 free(val_id); 435 } ; 436 437Opt_value: 438 ID 439 = { $$ = val_id = ns($1); } | 440 NUMBER 441 = { 442 char nb[16]; 443 (void) sprintf(nb, "%d", $1); 444 $$ = val_id = ns(nb); 445 } ; 446 447 448Save_id: 449 ID 450 = { $$ = temp_id = ns($1); } 451 ; 452 453Mkopt_list: 454 Mkopt_list COMMA Mkoption 455 | 456 Mkoption 457 ; 458 459Mkoption: 460 Save_id EQUALS Opt_value 461 = { 462 struct opt *op = (struct opt *)malloc(sizeof (struct opt)); 463 op->op_name = ns($1); 464 op->op_next = mkopt; 465 op->op_value = ns($3); 466 mkopt = op; 467 free(temp_id); 468 free(val_id); 469 } ; 470 471Dev: 472 ID 473 = { $$ = ns($1); } 474 ; 475 476Device_spec: 477 DEVICE Dev_name Dev_info Int_spec 478 = { cur.d_type = DEVICE; } | 479 MASTER Dev_name Dev_info Int_spec 480 = { cur.d_type = MASTER; } | 481 DISK Dev_name Dev_info Int_spec 482 = { cur.d_dk = 1; cur.d_type = DEVICE; } | 483 CONTROLLER Dev_name Dev_info Int_spec 484 = { cur.d_type = CONTROLLER; } | 485 PSEUDO_DEVICE Init_dev Dev 486 = { 487 cur.d_name = $3; 488 cur.d_type = PSEUDO_DEVICE; 489 } | 490 PSEUDO_DEVICE Init_dev Dev NUMBER 491 = { 492 cur.d_name = $3; 493 cur.d_type = PSEUDO_DEVICE; 494 cur.d_slave = $4; 495 } | 496 PSEUDO_DEVICE Dev_name Cdev_init Cdev_info 497 = { 498 if (!eq(cur.d_name, "cd")) 499 yyerror("improper spec for pseudo-device"); 500 seen_cd = 1; 501 cur.d_type = DEVICE; 502 verifycomp(*compp); 503 }; 504 505Cdev_init: 506 /* lambda */ 507 = { mkcomp(&cur); }; 508 509Cdev_info: 510 optional_on comp_device_list comp_option_list 511 ; 512 513comp_device_list: 514 comp_device_list AND comp_device 515 | comp_device 516 ; 517 518comp_device: 519 comp_device_spec 520 = { addcomp(*compp, $1); } 521 ; 522 523comp_device_spec: 524 device_name 525 = { 526 struct file_list *fl = newflist(COMPSPEC); 527 528 fl->f_compdev = nametodev($1, 0, COMPATIBILITY_SLICE, 529 'c'); 530 fl->f_fn = devtoname(fl->f_compdev); 531 $$ = fl; 532 } 533 | major_minor 534 = { 535 struct file_list *fl = newflist(COMPSPEC); 536 537 fl->f_compdev = $1; 538 fl->f_fn = devtoname($1); 539 $$ = fl; 540 } 541 ; 542 543comp_option_list: 544 comp_option_list comp_option 545 | 546 /* lambda */ 547 ; 548 549comp_option: 550 INTERLEAVE NUMBER 551 = { cur.d_pri = $2; } | 552 FLAGS NUMBER 553 = { cur.d_flags = $2; }; 554 555Dev_name: 556 Init_dev Dev NUMBER 557 = { 558 cur.d_name = $2; 559 if (eq($2, "mba")) 560 seen_mba = 1; 561 else if (eq($2, "uba")) 562 seen_uba = 1; 563 else if (eq($2, "vba")) 564 seen_vba = 1; 565 else if (eq($2, "isa")) 566 seen_isa = 1; 567 else if (eq($2, "scbus")) 568 seen_scbus = 1; 569 cur.d_unit = $3; 570 }; 571 572Init_dev: 573 /* lambda */ 574 = { init_dev(&cur); }; 575 576Dev_info: 577 Con_info Info_list 578 | 579 /* lambda */ 580 ; 581 582Con_info: 583 AT Dev NUMBER 584 = { 585 if (eq(cur.d_name, "mba") || eq(cur.d_name, "uba")) { 586 (void) sprintf(errbuf, 587 "%s must be connected to a nexus", cur.d_name); 588 yyerror(errbuf); 589 } 590 cur.d_conn = connect($2, $3); 591 } | 592 AT NEXUS NUMBER 593 = { check_nexus(&cur, $3); cur.d_conn = TO_NEXUS; }; 594 595Info_list: 596 Info_list Info 597 | 598 /* lambda */ 599 ; 600 601Info: 602 CSR NUMBER 603 = { cur.d_addr = $2; } | 604 TARGET NUMBER 605 = { cur.d_target = $2; } | 606 UNIT NUMBER 607 = { cur.d_lun = $2; } | 608 DRIVE NUMBER 609 = { cur.d_drive = $2; } | 610 SLAVE NUMBER 611 = { 612 if (cur.d_conn != 0 && cur.d_conn != TO_NEXUS && 613 cur.d_conn->d_type == MASTER) 614 cur.d_slave = $2; 615 else 616 yyerror("can't specify slave--not to master"); 617 } | 618 IRQ NUMBER 619 = { cur.d_irq = $2; } | 620 DRQ NUMBER 621 = { cur.d_drq = $2; } | 622 IOMEM NUMBER 623 = { cur.d_maddr = $2; } | 624 IOSIZ NUMBER 625 = { cur.d_msize = $2; } | 626 PORT device_name 627 = { cur.d_port = ns($2); } | 628 PORT NUMBER 629 = { cur.d_portn = $2; } | 630 TTY 631 = { cur.d_mask = "tty"; } | 632 BIO 633 = { cur.d_mask = "bio"; } | 634 NET 635 = { cur.d_mask = "net"; } | 636 FLAGS NUMBER 637 = { cur.d_flags = $2; } | 638 CONFLICTS 639 = { cur.d_conflicts = 1; }; 640 641Int_spec: 642 VECTOR Id_list 643 = { cur.d_vec = $2; } | 644 PRIORITY NUMBER 645 = { cur.d_pri = $2; } | 646 /* lambda */ 647 ; 648 649Id_list: 650 Save_id 651 = { 652 struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst)); 653 a->id = $1; a->id_next = 0; $$ = a; 654 } | 655 Save_id Id_list = 656 { 657 struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst)); 658 a->id = $1; a->id_next = $2; $$ = a; 659 }; 660 661%% 662 663yyerror(s) 664 char *s; 665{ 666 667 fprintf(stderr, "config: line %d: %s\n", yyline + 1, s); 668} 669 670/* 671 * return the passed string in a new space 672 */ 673char * 674ns(str) 675 register char *str; 676{ 677 register char *cp; 678 679 cp = malloc((unsigned)(strlen(str)+1)); 680 (void) strcpy(cp, str); 681 return (cp); 682} 683 684/* 685 * add a device to the list of devices 686 */ 687newdev(dp) 688 register struct device *dp; 689{ 690 register struct device *np; 691 692 np = (struct device *) malloc(sizeof *np); 693 *np = *dp; 694 np->d_next = 0; 695 if (curp == 0) 696 dtab = np; 697 else 698 curp->d_next = np; 699 curp = np; 700} 701 702/* 703 * note that a configuration should be made 704 */ 705mkconf(sysname) 706 char *sysname; 707{ 708 register struct file_list *fl, **flp; 709 710 fl = (struct file_list *) malloc(sizeof *fl); 711 fl->f_type = SYSTEMSPEC; 712 fl->f_needs = sysname; 713 fl->f_rootdev = NODEV; 714 fl->f_dumpdev = NODEV; 715 fl->f_fn = 0; 716 fl->f_next = 0; 717 for (flp = confp; *flp; flp = &(*flp)->f_next) 718 ; 719 *flp = fl; 720 confp = flp; 721} 722 723struct file_list * 724newflist(ftype) 725 u_char ftype; 726{ 727 struct file_list *fl = (struct file_list *)malloc(sizeof (*fl)); 728 729 fl->f_type = ftype; 730 fl->f_next = 0; 731 fl->f_swapdev = NODEV; 732 fl->f_swapsize = 0; 733 fl->f_needs = 0; 734 fl->f_fn = 0; 735 return (fl); 736} 737 738/* 739 * Add a swap device to the system's configuration 740 */ 741mkswap(system, fl, size, flag) 742 struct file_list *system, *fl; 743 int size, flag; 744{ 745 register struct file_list **flp; 746 char name[80]; 747 748 if (system == 0 || system->f_type != SYSTEMSPEC) { 749 yyerror("\"swap\" spec precedes \"config\" specification"); 750 return; 751 } 752 if (size < 0) { 753 yyerror("illegal swap partition size"); 754 return; 755 } 756 /* 757 * Append swap description to the end of the list. 758 */ 759 flp = &system->f_next; 760 for (; *flp && (*flp)->f_type == SWAPSPEC; flp = &(*flp)->f_next) 761 ; 762 fl->f_next = *flp; 763 *flp = fl; 764 fl->f_swapsize = size; 765 fl->f_swapflag = flag; 766 /* 767 * If first swap device for this system, 768 * set up f_fn field to insure swap 769 * files are created with unique names. 770 */ 771 if (system->f_fn) 772 return; 773 if (eq(fl->f_fn, "generic")) 774 system->f_fn = ns(fl->f_fn); 775 else 776 system->f_fn = ns(system->f_needs); 777} 778 779mkcomp(dp) 780 register struct device *dp; 781{ 782 register struct file_list *fl, **flp; 783 char buf[80]; 784 785 fl = (struct file_list *) malloc(sizeof *fl); 786 fl->f_type = COMPDEVICE; 787 fl->f_compinfo = dp->d_unit; 788 fl->f_fn = ns(dp->d_name); 789 (void) sprintf(buf, "%s%d", dp->d_name, dp->d_unit); 790 fl->f_needs = ns(buf); 791 fl->f_next = 0; 792 for (flp = compp; *flp; flp = &(*flp)->f_next) 793 ; 794 *flp = fl; 795 compp = flp; 796} 797 798addcomp(compdev, fl) 799 struct file_list *compdev, *fl; 800{ 801 register struct file_list **flp; 802 char name[80]; 803 804 if (compdev == 0 || compdev->f_type != COMPDEVICE) { 805 yyerror("component spec precedes device specification"); 806 return; 807 } 808 /* 809 * Append description to the end of the list. 810 */ 811 flp = &compdev->f_next; 812 for (; *flp && (*flp)->f_type == COMPSPEC; flp = &(*flp)->f_next) 813 ; 814 fl->f_next = *flp; 815 *flp = fl; 816} 817 818/* 819 * find the pointer to connect to the given device and number. 820 * returns 0 if no such device and prints an error message 821 */ 822struct device * 823connect(dev, num) 824 register char *dev; 825 register int num; 826{ 827 register struct device *dp; 828 struct device *huhcon(); 829 830 if (num == QUES) 831 return (huhcon(dev)); 832 for (dp = dtab; dp != 0; dp = dp->d_next) { 833 if ((num != dp->d_unit) || !eq(dev, dp->d_name)) 834 continue; 835 if (dp->d_type != CONTROLLER && dp->d_type != MASTER) { 836 (void) sprintf(errbuf, 837 "%s connected to non-controller", dev); 838 yyerror(errbuf); 839 return (0); 840 } 841 return (dp); 842 } 843 (void) sprintf(errbuf, "%s %d not defined", dev, num); 844 yyerror(errbuf); 845 return (0); 846} 847 848/* 849 * connect to an unspecific thing 850 */ 851struct device * 852huhcon(dev) 853 register char *dev; 854{ 855 register struct device *dp, *dcp; 856 struct device rdev; 857 int oldtype; 858 859 /* 860 * First make certain that there are some of these to wildcard on 861 */ 862 for (dp = dtab; dp != 0; dp = dp->d_next) 863 if (eq(dp->d_name, dev)) 864 break; 865 if (dp == 0) { 866 (void) sprintf(errbuf, "no %s's to wildcard", dev); 867 yyerror(errbuf); 868 return (0); 869 } 870 oldtype = dp->d_type; 871 dcp = dp->d_conn; 872 /* 873 * Now see if there is already a wildcard entry for this device 874 * (e.g. Search for a "uba ?") 875 */ 876 for (; dp != 0; dp = dp->d_next) 877 if (eq(dev, dp->d_name) && dp->d_unit == -1) 878 break; 879 /* 880 * If there isn't, make one because everything needs to be connected 881 * to something. 882 */ 883 if (dp == 0) { 884 dp = &rdev; 885 init_dev(dp); 886 dp->d_unit = QUES; 887 dp->d_name = ns(dev); 888 dp->d_type = oldtype; 889 newdev(dp); 890 dp = curp; 891 /* 892 * Connect it to the same thing that other similar things are 893 * connected to, but make sure it is a wildcard unit 894 * (e.g. up connected to sc ?, here we make connect sc? to a 895 * uba?). If other things like this are on the NEXUS or 896 * if they aren't connected to anything, then make the same 897 * connection, else call ourself to connect to another 898 * unspecific device. 899 */ 900 if (dcp == TO_NEXUS || dcp == 0) 901 dp->d_conn = dcp; 902 else 903 dp->d_conn = connect(dcp->d_name, QUES); 904 } 905 return (dp); 906} 907 908init_dev(dp) 909 register struct device *dp; 910{ 911 912 dp->d_name = "OHNO!!!"; 913 dp->d_type = DEVICE; 914 dp->d_conn = 0; 915 dp->d_conflicts = 0; 916 dp->d_vec = 0; 917 dp->d_addr = dp->d_flags = dp->d_dk = 0; 918 dp->d_pri = -1; 919 dp->d_slave = dp->d_lun = dp->d_target = dp->d_drive = dp->d_unit = UNKNOWN; 920 dp->d_port = (char *)0; 921 dp->d_portn = 0; 922 dp->d_irq = -1; 923 dp->d_drq = -1; 924 dp->d_maddr = 0; 925 dp->d_msize = 0; 926 dp->d_mask = "null"; 927} 928 929/* 930 * make certain that this is a reasonable type of thing to connect to a nexus 931 */ 932check_nexus(dev, num) 933 register struct device *dev; 934 int num; 935{ 936 937 switch (machine) { 938 939 case MACHINE_VAX: 940 if (!eq(dev->d_name, "uba") && !eq(dev->d_name, "mba") && 941 !eq(dev->d_name, "bi")) 942 yyerror("only uba's, mba's, and bi's should be connected to the nexus"); 943 if (num != QUES) 944 yyerror("can't give specific nexus numbers"); 945 break; 946 947 case MACHINE_TAHOE: 948 if (!eq(dev->d_name, "vba")) 949 yyerror("only vba's should be connected to the nexus"); 950 break; 951 952 case MACHINE_HP300: 953 case MACHINE_LUNA68K: 954 if (num != QUES) 955 dev->d_addr = num; 956 break; 957 958 case MACHINE_I386: 959 if (!eq(dev->d_name, "isa")) 960 yyerror("only isa's should be connected to the nexus"); 961 break; 962 963 case MACHINE_NEWS3400: 964 if (!eq(dev->d_name, "iop") && !eq(dev->d_name, "hb") && 965 !eq(dev->d_name, "vme")) 966 yyerror("only iop's, hb's and vme's should be connected to the nexus"); 967 break; 968 } 969} 970 971/* 972 * Check the timezone to make certain it is sensible 973 */ 974 975check_tz() 976{ 977 if (zone != 0 || dst != 0) 978 yyerror("timezone specification is no longer permitted"); 979 else 980 hadtz = 1; 981} 982 983/* 984 * Check system specification and apply defaulting 985 * rules on root, argument, dump, and swap devices. 986 */ 987checksystemspec(fl) 988 register struct file_list *fl; 989{ 990 char buf[BUFSIZ]; 991 register struct file_list *swap; 992 int generic; 993 994 if (fl == 0 || fl->f_type != SYSTEMSPEC) { 995 yyerror("internal error, bad system specification"); 996 exit(1); 997 } 998 swap = fl->f_next; 999 generic = swap && swap->f_type == SWAPSPEC && eq(swap->f_fn, "generic"); 1000 if (fl->f_rootdev == NODEV && !generic) { 1001 yyerror("no root device specified"); 1002 exit(1); 1003 } 1004 /* 1005 * Default swap area to be in 'b' partition of root's 1006 * device. If root specified to be other than on 'a' 1007 * partition, give warning, something probably amiss. 1008 */ 1009 if (swap == 0 || swap->f_type != SWAPSPEC) { 1010 dev_t dev; 1011 1012 swap = newflist(SWAPSPEC); 1013 dev = fl->f_rootdev; 1014 if (dkpart(dev) != 0) { 1015 (void) sprintf(buf, 1016"Warning, swap defaulted to 'b' partition with root on '%c' partition", 1017 dkpart(dev) + 'a'); 1018 yyerror(buf); 1019 } 1020 swap->f_swapdev = dkmodpart(dev, SWAP_PART); 1021 swap->f_fn = devtoname(swap->f_swapdev); 1022 mkswap(fl, swap, 0); 1023 } 1024 /* 1025 * Make sure a generic swap isn't specified, along with 1026 * other stuff (user must really be confused). 1027 */ 1028 if (generic) { 1029 if (fl->f_rootdev != NODEV) 1030 yyerror("root device specified with generic swap"); 1031 if (fl->f_dumpdev != NODEV) 1032 yyerror("dump device specified with generic swap"); 1033 return; 1034 } 1035 /* 1036 * Warn if dump device is not a swap area. 1037 */ 1038 if (fl->f_dumpdev != NODEV && fl->f_dumpdev != swap->f_swapdev) { 1039 struct file_list *p = swap->f_next; 1040 1041 for (; p && p->f_type == SWAPSPEC; p = p->f_next) 1042 if (fl->f_dumpdev == p->f_swapdev) 1043 return; 1044 (void) sprintf(buf, 1045 "Warning: dump device is not a swap partition"); 1046 yyerror(buf); 1047 } 1048} 1049 1050/* 1051 * Verify all devices specified in the system specification 1052 * are present in the device specifications. 1053 */ 1054verifysystemspecs() 1055{ 1056 register struct file_list *fl; 1057 dev_t checked[50], *verifyswap(); 1058 register dev_t *pchecked = checked; 1059 1060 for (fl = conf_list; fl; fl = fl->f_next) { 1061 if (fl->f_type != SYSTEMSPEC) 1062 continue; 1063 if (!finddev(fl->f_rootdev)) 1064 deverror(fl->f_needs, "root"); 1065 *pchecked++ = fl->f_rootdev; 1066 pchecked = verifyswap(fl->f_next, checked, pchecked); 1067 if (!alreadychecked(fl->f_dumpdev, checked, pchecked)) { 1068 if (!finddev(fl->f_dumpdev)) 1069 deverror(fl->f_needs, "dump"); 1070 *pchecked++ = fl->f_dumpdev; 1071 } 1072 } 1073} 1074 1075/* 1076 * Do as above, but for swap devices. 1077 */ 1078dev_t * 1079verifyswap(fl, checked, pchecked) 1080 register struct file_list *fl; 1081 dev_t checked[]; 1082 register dev_t *pchecked; 1083{ 1084 1085 for (;fl && fl->f_type == SWAPSPEC; fl = fl->f_next) { 1086 if (eq(fl->f_fn, "generic")) 1087 continue; 1088 if (alreadychecked(fl->f_swapdev, checked, pchecked)) 1089 continue; 1090 if (!finddev(fl->f_swapdev)) 1091 fprintf(stderr, 1092 "config: swap device %s not configured", fl->f_fn); 1093 *pchecked++ = fl->f_swapdev; 1094 } 1095 return (pchecked); 1096} 1097 1098/* 1099 * Verify that components of a compound device have themselves been config'ed 1100 */ 1101verifycomp(fl) 1102 register struct file_list *fl; 1103{ 1104 char *dname = fl->f_needs; 1105 1106 for (fl = fl->f_next; fl; fl = fl->f_next) { 1107 if (fl->f_type != COMPSPEC || finddev(fl->f_compdev)) 1108 continue; 1109 fprintf(stderr, 1110 "config: %s: component device %s not configured\n", 1111 dname, fl->f_needs); 1112 } 1113} 1114 1115/* 1116 * Has a device already been checked 1117 * for its existence in the configuration? 1118 */ 1119alreadychecked(dev, list, last) 1120 dev_t dev, list[]; 1121 register dev_t *last; 1122{ 1123 register dev_t *p; 1124 1125 for (p = list; p < last; p++) 1126 if (dkmodpart(*p, 0) != dkmodpart(dev, 0)) 1127 return (1); 1128 return (0); 1129} 1130 1131deverror(systemname, devtype) 1132 char *systemname, *devtype; 1133{ 1134 1135 fprintf(stderr, "config: %s: %s device not configured\n", 1136 systemname, devtype); 1137} 1138 1139/* 1140 * Look for the device in the list of 1141 * configured hardware devices. Must 1142 * take into account stuff wildcarded. 1143 */ 1144/*ARGSUSED*/ 1145finddev(dev) 1146 dev_t dev; 1147{ 1148 1149 /* punt on this right now */ 1150 return (1); 1151} 1152