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