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 CONTROLLER 16 %token CPU 17 %token CSR 18 %token DEVICE 19 %token DISK 20 %token DRIVE 21 %token DRQ 22 %token DST 23 %token DUMPS 24 %token EQUALS 25 %token FLAGS 26 %token HZ 27 %token IDENT 28 %token IOMEM 29 %token IOSIZ 30 %token IRQ 31 %token MACHINE 32 %token MAJOR 33 %token MASTER 34 %token MAXUSERS 35 %token MINOR 36 %token MINUS 37 %token NET 38 %token NEXUS 39 %token ON 40 %token OPTIONS 41 %token MAKEOPTIONS 42 %token PORT 43 %token PRIORITY 44 %token PSEUDO_DEVICE 45 %token ROOT 46 %token SEMICOLON 47 %token SIZE 48 %token SLAVE 49 %token SWAP 50 %token TIMEZONE 51 %token TTY 52 %token TRACE 53 %token VECTOR 54 55 %token <str> ID 56 %token <val> NUMBER 57 %token <val> FPNUMBER 58 59 %type <str> Save_id 60 %type <str> Opt_value 61 %type <str> Dev 62 %type <lst> Id_list 63 %type <val> optional_size 64 %type <str> device_name 65 %type <val> major_minor 66 %type <val> arg_device_spec 67 %type <val> root_device_spec 68 %type <val> dump_device_spec 69 %type <file> swap_device_spec 70 71 %{ 72 73 /* 74 * Copyright (c) 1988 Regents of the University of California. 75 * All rights reserved. 76 * 77 * %sccs.include.redist.c% 78 * 79 * @(#)config.y 5.16 (Berkeley) 06/19/92 80 */ 81 82 #include "config.h" 83 #include <ctype.h> 84 #include <stdio.h> 85 86 struct device cur; 87 struct device *curp = 0; 88 char *temp_id; 89 char *val_id; 90 91 %} 92 %% 93 Configuration: 94 Many_specs 95 = { verifysystemspecs(); } 96 ; 97 98 Many_specs: 99 Many_specs Spec 100 | 101 /* lambda */ 102 ; 103 104 Spec: 105 Device_spec SEMICOLON 106 = { newdev(&cur); } | 107 Config_spec SEMICOLON 108 | 109 TRACE SEMICOLON 110 = { do_trace = !do_trace; } | 111 SEMICOLON 112 | 113 error SEMICOLON 114 ; 115 116 Config_spec: 117 MACHINE Save_id 118 = { 119 if (!strcmp($2, "vax")) { 120 machine = MACHINE_VAX; 121 machinename = "vax"; 122 } else if (!strcmp($2, "tahoe")) { 123 machine = MACHINE_TAHOE; 124 machinename = "tahoe"; 125 } else if (!strcmp($2, "hp300")) { 126 machine = MACHINE_HP300; 127 machinename = "hp300"; 128 } else if (!strcmp($2, "i386")) { 129 machine = MACHINE_I386; 130 machinename = "i386"; 131 } else if (!strcmp($2, "mips")) { 132 machine = MACHINE_MIPS; 133 machinename = "mips"; 134 } else if (!strcmp($2, "pmax")) { 135 machine = MACHINE_PMAX; 136 machinename = "pmax"; 137 } else if (!strcmp($2, "luna68k")) { 138 machine = MACHINE_LUNA68K; 139 machinename = "luna68k"; 140 } else 141 yyerror("Unknown machine type"); 142 } | 143 CPU Save_id 144 = { 145 struct cputype *cp = 146 (struct cputype *)malloc(sizeof (struct cputype)); 147 cp->cpu_name = ns($2); 148 cp->cpu_next = cputype; 149 cputype = cp; 150 free(temp_id); 151 } | 152 OPTIONS Opt_list 153 | 154 MAKEOPTIONS Mkopt_list 155 | 156 IDENT ID 157 = { ident = ns($2); } | 158 System_spec 159 | 160 HZ NUMBER 161 = { hz = $2; }| 162 TIMEZONE NUMBER 163 = { zone = 60 * $2; check_tz(); } | 164 TIMEZONE NUMBER DST NUMBER 165 = { zone = 60 * $2; dst = $4; check_tz(); } | 166 TIMEZONE NUMBER DST 167 = { zone = 60 * $2; dst = 1; check_tz(); } | 168 TIMEZONE FPNUMBER 169 = { zone = $2; check_tz(); } | 170 TIMEZONE FPNUMBER DST NUMBER 171 = { zone = $2; dst = $4; check_tz(); } | 172 TIMEZONE FPNUMBER DST 173 = { zone = $2; dst = 1; check_tz(); } | 174 TIMEZONE MINUS NUMBER 175 = { zone = -60 * $3; check_tz(); } | 176 TIMEZONE MINUS NUMBER DST NUMBER 177 = { zone = -60 * $3; dst = $5; check_tz(); } | 178 TIMEZONE MINUS NUMBER DST 179 = { zone = -60 * $3; dst = 1; check_tz(); } | 180 TIMEZONE MINUS FPNUMBER 181 = { zone = -$3; check_tz(); } | 182 TIMEZONE MINUS FPNUMBER DST NUMBER 183 = { zone = -$3; dst = $5; check_tz(); } | 184 TIMEZONE MINUS FPNUMBER DST 185 = { zone = -$3; dst = 1; check_tz(); } | 186 MAXUSERS NUMBER 187 = { maxusers = $2; }; 188 189 System_spec: 190 System_id System_parameter_list 191 = { checksystemspec(*confp); } 192 ; 193 194 System_id: 195 CONFIG Save_id 196 = { mkconf($2); } 197 ; 198 199 System_parameter_list: 200 System_parameter_list System_parameter 201 | System_parameter 202 ; 203 204 System_parameter: 205 swap_spec 206 | root_spec 207 | dump_spec 208 | arg_spec 209 ; 210 211 swap_spec: 212 SWAP optional_on swap_device_list 213 ; 214 215 swap_device_list: 216 swap_device_list AND swap_device 217 | swap_device 218 ; 219 220 swap_device: 221 swap_device_spec optional_size 222 = { mkswap(*confp, $1, $2); } 223 ; 224 225 swap_device_spec: 226 device_name 227 = { 228 struct file_list *fl = newswap(); 229 230 if (eq($1, "generic")) 231 fl->f_fn = $1; 232 else { 233 fl->f_swapdev = nametodev($1, 0, 'b'); 234 fl->f_fn = devtoname(fl->f_swapdev); 235 } 236 $$ = fl; 237 } 238 | major_minor 239 = { 240 struct file_list *fl = newswap(); 241 242 fl->f_swapdev = $1; 243 fl->f_fn = devtoname($1); 244 $$ = fl; 245 } 246 ; 247 248 root_spec: 249 ROOT optional_on root_device_spec 250 = { 251 struct file_list *fl = *confp; 252 253 if (fl && fl->f_rootdev != NODEV) 254 yyerror("extraneous root device specification"); 255 else 256 fl->f_rootdev = $3; 257 } 258 ; 259 260 root_device_spec: 261 device_name 262 = { $$ = nametodev($1, 0, 'a'); } 263 | major_minor 264 ; 265 266 dump_spec: 267 DUMPS optional_on dump_device_spec 268 = { 269 struct file_list *fl = *confp; 270 271 if (fl && fl->f_dumpdev != NODEV) 272 yyerror("extraneous dump device specification"); 273 else 274 fl->f_dumpdev = $3; 275 } 276 277 ; 278 279 dump_device_spec: 280 device_name 281 = { $$ = nametodev($1, 0, 'b'); } 282 | major_minor 283 ; 284 285 arg_spec: 286 ARGS optional_on arg_device_spec 287 = { yyerror("arg device specification obsolete, ignored"); } 288 ; 289 290 arg_device_spec: 291 device_name 292 = { $$ = nametodev($1, 0, 'b'); } 293 | major_minor 294 ; 295 296 major_minor: 297 MAJOR NUMBER MINOR NUMBER 298 = { $$ = makedev($2, $4); } 299 ; 300 301 optional_on: 302 ON 303 | /* empty */ 304 ; 305 306 optional_size: 307 SIZE NUMBER 308 = { $$ = $2; } 309 | /* empty */ 310 = { $$ = 0; } 311 ; 312 313 device_name: 314 Save_id 315 = { $$ = $1; } 316 | Save_id NUMBER 317 = { 318 char buf[80]; 319 320 (void) sprintf(buf, "%s%d", $1, $2); 321 $$ = ns(buf); free($1); 322 } 323 | Save_id NUMBER ID 324 = { 325 char buf[80]; 326 327 (void) sprintf(buf, "%s%d%s", $1, $2, $3); 328 $$ = ns(buf); free($1); 329 } 330 ; 331 332 Opt_list: 333 Opt_list COMMA Option 334 | 335 Option 336 ; 337 338 Option: 339 Save_id 340 = { 341 struct opt *op = (struct opt *)malloc(sizeof (struct opt)); 342 op->op_name = ns($1); 343 op->op_next = opt; 344 op->op_value = 0; 345 opt = op; 346 free(temp_id); 347 } | 348 Save_id EQUALS Opt_value 349 = { 350 struct opt *op = (struct opt *)malloc(sizeof (struct opt)); 351 op->op_name = ns($1); 352 op->op_next = opt; 353 op->op_value = ns($3); 354 opt = op; 355 free(temp_id); 356 free(val_id); 357 } ; 358 359 Opt_value: 360 ID 361 = { $$ = val_id = ns($1); } | 362 NUMBER 363 = { 364 char nb[16]; 365 (void) sprintf(nb, "%d", $1); 366 $$ = val_id = ns(nb); 367 } ; 368 369 370 Save_id: 371 ID 372 = { $$ = temp_id = ns($1); } 373 ; 374 375 Mkopt_list: 376 Mkopt_list COMMA Mkoption 377 | 378 Mkoption 379 ; 380 381 Mkoption: 382 Save_id EQUALS Opt_value 383 = { 384 struct opt *op = (struct opt *)malloc(sizeof (struct opt)); 385 op->op_name = ns($1); 386 op->op_next = mkopt; 387 op->op_value = ns($3); 388 mkopt = op; 389 free(temp_id); 390 free(val_id); 391 } ; 392 393 Dev: 394 ID 395 = { $$ = ns($1); } 396 ; 397 398 Device_spec: 399 DEVICE Dev_name Dev_info Int_spec 400 = { cur.d_type = DEVICE; } | 401 MASTER Dev_name Dev_info Int_spec 402 = { cur.d_type = MASTER; } | 403 DISK Dev_name Dev_info Int_spec 404 = { cur.d_dk = 1; cur.d_type = DEVICE; } | 405 CONTROLLER Dev_name Dev_info Int_spec 406 = { cur.d_type = CONTROLLER; } | 407 PSEUDO_DEVICE Init_dev Dev 408 = { 409 cur.d_name = $3; 410 cur.d_type = PSEUDO_DEVICE; 411 } | 412 PSEUDO_DEVICE Init_dev Dev NUMBER 413 = { 414 cur.d_name = $3; 415 cur.d_type = PSEUDO_DEVICE; 416 cur.d_slave = $4; 417 }; 418 419 Dev_name: 420 Init_dev Dev NUMBER 421 = { 422 cur.d_name = $2; 423 if (eq($2, "mba")) 424 seen_mba = 1; 425 else if (eq($2, "uba")) 426 seen_uba = 1; 427 else if (eq($2, "vba")) 428 seen_vba = 1; 429 else if (eq($2, "isa")) 430 seen_isa = 1; 431 cur.d_unit = $3; 432 }; 433 434 Init_dev: 435 /* lambda */ 436 = { init_dev(&cur); }; 437 438 Dev_info: 439 Con_info Info_list 440 | 441 /* lambda */ 442 ; 443 444 Con_info: 445 AT Dev NUMBER 446 = { 447 if (eq(cur.d_name, "mba") || eq(cur.d_name, "uba")) { 448 (void) sprintf(errbuf, 449 "%s must be connected to a nexus", cur.d_name); 450 yyerror(errbuf); 451 } 452 cur.d_conn = connect($2, $3); 453 } | 454 AT NEXUS NUMBER 455 = { check_nexus(&cur, $3); cur.d_conn = TO_NEXUS; }; 456 457 Info_list: 458 Info_list Info 459 | 460 /* lambda */ 461 ; 462 463 Info: 464 CSR NUMBER 465 = { cur.d_addr = $2; } | 466 DRIVE NUMBER 467 = { cur.d_drive = $2; } | 468 SLAVE NUMBER 469 = { 470 if (cur.d_conn != 0 && cur.d_conn != TO_NEXUS && 471 cur.d_conn->d_type == MASTER) 472 cur.d_slave = $2; 473 else 474 yyerror("can't specify slave--not to master"); 475 } | 476 IRQ NUMBER 477 = { cur.d_irq = $2; } | 478 DRQ NUMBER 479 = { cur.d_drq = $2; } | 480 IOMEM NUMBER 481 = { cur.d_maddr = $2; } | 482 IOSIZ NUMBER 483 = { cur.d_msize = $2; } | 484 PORT device_name 485 = { cur.d_port = ns($2); } | 486 PORT NUMBER 487 = { cur.d_portn = $2; } | 488 TTY 489 = { cur.d_mask = "tty"; } | 490 BIO 491 = { cur.d_mask = "bio"; } | 492 NET 493 = { cur.d_mask = "net"; } | 494 FLAGS NUMBER 495 = { cur.d_flags = $2; }; 496 497 Int_spec: 498 VECTOR Id_list 499 = { cur.d_vec = $2; } | 500 PRIORITY NUMBER 501 = { cur.d_pri = $2; } | 502 /* lambda */ 503 ; 504 505 Id_list: 506 Save_id 507 = { 508 struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst)); 509 a->id = $1; a->id_next = 0; $$ = a; 510 } | 511 Save_id Id_list = 512 { 513 struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst)); 514 a->id = $1; a->id_next = $2; $$ = a; 515 }; 516 517 %% 518 519 yyerror(s) 520 char *s; 521 { 522 523 fprintf(stderr, "config: line %d: %s\n", yyline + 1, s); 524 } 525 526 /* 527 * return the passed string in a new space 528 */ 529 char * 530 ns(str) 531 register char *str; 532 { 533 register char *cp; 534 535 cp = malloc((unsigned)(strlen(str)+1)); 536 (void) strcpy(cp, str); 537 return (cp); 538 } 539 540 /* 541 * add a device to the list of devices 542 */ 543 newdev(dp) 544 register struct device *dp; 545 { 546 register struct device *np; 547 548 np = (struct device *) malloc(sizeof *np); 549 *np = *dp; 550 np->d_next = 0; 551 if (curp == 0) 552 dtab = np; 553 else 554 curp->d_next = np; 555 curp = np; 556 } 557 558 /* 559 * note that a configuration should be made 560 */ 561 mkconf(sysname) 562 char *sysname; 563 { 564 register struct file_list *fl, **flp; 565 566 fl = (struct file_list *) malloc(sizeof *fl); 567 fl->f_type = SYSTEMSPEC; 568 fl->f_needs = sysname; 569 fl->f_rootdev = NODEV; 570 fl->f_dumpdev = NODEV; 571 fl->f_fn = 0; 572 fl->f_next = 0; 573 for (flp = confp; *flp; flp = &(*flp)->f_next) 574 ; 575 *flp = fl; 576 confp = flp; 577 } 578 579 struct file_list * 580 newswap() 581 { 582 struct file_list *fl = (struct file_list *)malloc(sizeof (*fl)); 583 584 fl->f_type = SWAPSPEC; 585 fl->f_next = 0; 586 fl->f_swapdev = NODEV; 587 fl->f_swapsize = 0; 588 fl->f_needs = 0; 589 fl->f_fn = 0; 590 return (fl); 591 } 592 593 /* 594 * Add a swap device to the system's configuration 595 */ 596 mkswap(system, fl, size) 597 struct file_list *system, *fl; 598 int size; 599 { 600 register struct file_list **flp; 601 char name[80]; 602 603 if (system == 0 || system->f_type != SYSTEMSPEC) { 604 yyerror("\"swap\" spec precedes \"config\" specification"); 605 return; 606 } 607 if (size < 0) { 608 yyerror("illegal swap partition size"); 609 return; 610 } 611 /* 612 * Append swap description to the end of the list. 613 */ 614 flp = &system->f_next; 615 for (; *flp && (*flp)->f_type == SWAPSPEC; flp = &(*flp)->f_next) 616 ; 617 fl->f_next = *flp; 618 *flp = fl; 619 fl->f_swapsize = size; 620 /* 621 * If first swap device for this system, 622 * set up f_fn field to insure swap 623 * files are created with unique names. 624 */ 625 if (system->f_fn) 626 return; 627 if (eq(fl->f_fn, "generic")) 628 system->f_fn = ns(fl->f_fn); 629 else 630 system->f_fn = ns(system->f_needs); 631 } 632 633 /* 634 * find the pointer to connect to the given device and number. 635 * returns 0 if no such device and prints an error message 636 */ 637 struct device * 638 connect(dev, num) 639 register char *dev; 640 register int num; 641 { 642 register struct device *dp; 643 struct device *huhcon(); 644 645 if (num == QUES) 646 return (huhcon(dev)); 647 for (dp = dtab; dp != 0; dp = dp->d_next) { 648 if ((num != dp->d_unit) || !eq(dev, dp->d_name)) 649 continue; 650 if (dp->d_type != CONTROLLER && dp->d_type != MASTER) { 651 (void) sprintf(errbuf, 652 "%s connected to non-controller", dev); 653 yyerror(errbuf); 654 return (0); 655 } 656 return (dp); 657 } 658 (void) sprintf(errbuf, "%s %d not defined", dev, num); 659 yyerror(errbuf); 660 return (0); 661 } 662 663 /* 664 * connect to an unspecific thing 665 */ 666 struct device * 667 huhcon(dev) 668 register char *dev; 669 { 670 register struct device *dp, *dcp; 671 struct device rdev; 672 int oldtype; 673 674 /* 675 * First make certain that there are some of these to wildcard on 676 */ 677 for (dp = dtab; dp != 0; dp = dp->d_next) 678 if (eq(dp->d_name, dev)) 679 break; 680 if (dp == 0) { 681 (void) sprintf(errbuf, "no %s's to wildcard", dev); 682 yyerror(errbuf); 683 return (0); 684 } 685 oldtype = dp->d_type; 686 dcp = dp->d_conn; 687 /* 688 * Now see if there is already a wildcard entry for this device 689 * (e.g. Search for a "uba ?") 690 */ 691 for (; dp != 0; dp = dp->d_next) 692 if (eq(dev, dp->d_name) && dp->d_unit == -1) 693 break; 694 /* 695 * If there isn't, make one because everything needs to be connected 696 * to something. 697 */ 698 if (dp == 0) { 699 dp = &rdev; 700 init_dev(dp); 701 dp->d_unit = QUES; 702 dp->d_name = ns(dev); 703 dp->d_type = oldtype; 704 newdev(dp); 705 dp = curp; 706 /* 707 * Connect it to the same thing that other similar things are 708 * connected to, but make sure it is a wildcard unit 709 * (e.g. up connected to sc ?, here we make connect sc? to a 710 * uba?). If other things like this are on the NEXUS or 711 * if they aren't connected to anything, then make the same 712 * connection, else call ourself to connect to another 713 * unspecific device. 714 */ 715 if (dcp == TO_NEXUS || dcp == 0) 716 dp->d_conn = dcp; 717 else 718 dp->d_conn = connect(dcp->d_name, QUES); 719 } 720 return (dp); 721 } 722 723 init_dev(dp) 724 register struct device *dp; 725 { 726 727 dp->d_name = "OHNO!!!"; 728 dp->d_type = DEVICE; 729 dp->d_conn = 0; 730 dp->d_vec = 0; 731 dp->d_addr = dp->d_pri = dp->d_flags = dp->d_dk = 0; 732 dp->d_slave = dp->d_drive = dp->d_unit = UNKNOWN; 733 dp->d_port = (char *)0; 734 dp->d_portn = 0; 735 dp->d_irq = -1; 736 dp->d_drq = -1; 737 dp->d_maddr = 0; 738 dp->d_msize = 0; 739 dp->d_mask = "null"; 740 } 741 742 /* 743 * make certain that this is a reasonable type of thing to connect to a nexus 744 */ 745 check_nexus(dev, num) 746 register struct device *dev; 747 int num; 748 { 749 750 switch (machine) { 751 752 case MACHINE_VAX: 753 if (!eq(dev->d_name, "uba") && !eq(dev->d_name, "mba") && 754 !eq(dev->d_name, "bi")) 755 yyerror("only uba's, mba's, and bi's should be connected to the nexus"); 756 if (num != QUES) 757 yyerror("can't give specific nexus numbers"); 758 break; 759 760 case MACHINE_TAHOE: 761 if (!eq(dev->d_name, "vba")) 762 yyerror("only vba's should be connected to the nexus"); 763 break; 764 765 case MACHINE_HP300: 766 case MACHINE_LUNA68K: 767 if (num != QUES) 768 dev->d_addr = num; 769 break; 770 771 case MACHINE_I386: 772 if (!eq(dev->d_name, "isa")) 773 yyerror("only isa's should be connected to the nexus"); 774 break; 775 } 776 } 777 778 /* 779 * Check the timezone to make certain it is sensible 780 */ 781 782 check_tz() 783 { 784 if (abs(zone) > 12 * 60) 785 yyerror("timezone is unreasonable"); 786 else 787 hadtz = 1; 788 } 789 790 /* 791 * Check system specification and apply defaulting 792 * rules on root, argument, dump, and swap devices. 793 */ 794 checksystemspec(fl) 795 register struct file_list *fl; 796 { 797 char buf[BUFSIZ]; 798 register struct file_list *swap; 799 int generic; 800 801 if (fl == 0 || fl->f_type != SYSTEMSPEC) { 802 yyerror("internal error, bad system specification"); 803 exit(1); 804 } 805 swap = fl->f_next; 806 generic = swap && swap->f_type == SWAPSPEC && eq(swap->f_fn, "generic"); 807 if (fl->f_rootdev == NODEV && !generic) { 808 yyerror("no root device specified"); 809 exit(1); 810 } 811 /* 812 * Default swap area to be in 'b' partition of root's 813 * device. If root specified to be other than on 'a' 814 * partition, give warning, something probably amiss. 815 */ 816 if (swap == 0 || swap->f_type != SWAPSPEC) { 817 dev_t dev; 818 819 swap = newswap(); 820 dev = fl->f_rootdev; 821 if (minor(dev) & 07) { 822 (void) sprintf(buf, 823 "Warning, swap defaulted to 'b' partition with root on '%c' partition", 824 (minor(dev) & 07) + 'a'); 825 yyerror(buf); 826 } 827 swap->f_swapdev = 828 makedev(major(dev), (minor(dev) &~ 07) | ('b' - 'a')); 829 swap->f_fn = devtoname(swap->f_swapdev); 830 mkswap(fl, swap, 0); 831 } 832 /* 833 * Make sure a generic swap isn't specified, along with 834 * other stuff (user must really be confused). 835 */ 836 if (generic) { 837 if (fl->f_rootdev != NODEV) 838 yyerror("root device specified with generic swap"); 839 if (fl->f_dumpdev != NODEV) 840 yyerror("dump device specified with generic swap"); 841 return; 842 } 843 /* 844 * Default dump device and warn if place is not a 845 * swap area. 846 */ 847 if (fl->f_dumpdev == NODEV) 848 fl->f_dumpdev = swap->f_swapdev; 849 if (fl->f_dumpdev != swap->f_swapdev) { 850 struct file_list *p = swap->f_next; 851 852 for (; p && p->f_type == SWAPSPEC; p = p->f_next) 853 if (fl->f_dumpdev == p->f_swapdev) 854 return; 855 (void) sprintf(buf, 856 "Warning: dump device is not a swap partition"); 857 yyerror(buf); 858 } 859 } 860 861 /* 862 * Verify all devices specified in the system specification 863 * are present in the device specifications. 864 */ 865 verifysystemspecs() 866 { 867 register struct file_list *fl; 868 dev_t checked[50], *verifyswap(); 869 register dev_t *pchecked = checked; 870 871 for (fl = conf_list; fl; fl = fl->f_next) { 872 if (fl->f_type != SYSTEMSPEC) 873 continue; 874 if (!finddev(fl->f_rootdev)) 875 deverror(fl->f_needs, "root"); 876 *pchecked++ = fl->f_rootdev; 877 pchecked = verifyswap(fl->f_next, checked, pchecked); 878 #define samedev(dev1, dev2) \ 879 ((minor(dev1) &~ 07) != (minor(dev2) &~ 07)) 880 if (!alreadychecked(fl->f_dumpdev, checked, pchecked)) { 881 if (!finddev(fl->f_dumpdev)) 882 deverror(fl->f_needs, "dump"); 883 *pchecked++ = fl->f_dumpdev; 884 } 885 } 886 } 887 888 /* 889 * Do as above, but for swap devices. 890 */ 891 dev_t * 892 verifyswap(fl, checked, pchecked) 893 register struct file_list *fl; 894 dev_t checked[]; 895 register dev_t *pchecked; 896 { 897 898 for (;fl && fl->f_type == SWAPSPEC; fl = fl->f_next) { 899 if (eq(fl->f_fn, "generic")) 900 continue; 901 if (alreadychecked(fl->f_swapdev, checked, pchecked)) 902 continue; 903 if (!finddev(fl->f_swapdev)) 904 fprintf(stderr, 905 "config: swap device %s not configured", fl->f_fn); 906 *pchecked++ = fl->f_swapdev; 907 } 908 return (pchecked); 909 } 910 911 /* 912 * Has a device already been checked 913 * for it's existence in the configuration? 914 */ 915 alreadychecked(dev, list, last) 916 dev_t dev, list[]; 917 register dev_t *last; 918 { 919 register dev_t *p; 920 921 for (p = list; p < last; p++) 922 if (samedev(*p, dev)) 923 return (1); 924 return (0); 925 } 926 927 deverror(systemname, devtype) 928 char *systemname, *devtype; 929 { 930 931 fprintf(stderr, "config: %s: %s device not configured\n", 932 systemname, devtype); 933 } 934 935 /* 936 * Look for the device in the list of 937 * configured hardware devices. Must 938 * take into account stuff wildcarded. 939 */ 940 /*ARGSUSED*/ 941 finddev(dev) 942 dev_t dev; 943 { 944 945 /* punt on this right now */ 946 return (1); 947 } 948