kern_subr.c revision 1.30
1 /* $NetBSD: kern_subr.c,v 1.30 1997/09/13 07:38:25 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1997 Jason R. Thorpe. All rights reserved. 5 * Copyright (c) 1982, 1986, 1991, 1993 6 * The Regents of the University of California. All rights reserved. 7 * (c) UNIX System Laboratories, Inc. 8 * All or some portions of this file are derived from material licensed 9 * to the University of California by American Telephone and Telegraph 10 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 11 * the permission of UNIX System Laboratories, Inc. 12 * 13 * Copyright (c) 1992, 1993 14 * The Regents of the University of California. All rights reserved. 15 * 16 * This software was developed by the Computer Systems Engineering group 17 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and 18 * contributed to Berkeley. 19 * 20 * All advertising materials mentioning features or use of this software 21 * must display the following acknowledgement: 22 * This product includes software developed by the University of 23 * California, Lawrence Berkeley Laboratory. 24 * 25 * Redistribution and use in source and binary forms, with or without 26 * modification, are permitted provided that the following conditions 27 * are met: 28 * 1. Redistributions of source code must retain the above copyright 29 * notice, this list of conditions and the following disclaimer. 30 * 2. Redistributions in binary form must reproduce the above copyright 31 * notice, this list of conditions and the following disclaimer in the 32 * documentation and/or other materials provided with the distribution. 33 * 3. All advertising materials mentioning features or use of this software 34 * must display the following acknowledgement: 35 * This product includes software developed by the University of 36 * California, Berkeley and its contributors. 37 * 4. Neither the name of the University nor the names of its contributors 38 * may be used to endorse or promote products derived from this software 39 * without specific prior written permission. 40 * 41 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 * 53 * @(#)kern_subr.c 8.3 (Berkeley) 1/21/94 54 */ 55 56 #include <sys/param.h> 57 #include <sys/systm.h> 58 #include <sys/proc.h> 59 #include <sys/malloc.h> 60 #include <sys/mount.h> 61 #include <sys/device.h> 62 #include <sys/reboot.h> 63 #include <sys/conf.h> 64 #include <sys/disklabel.h> 65 #include <sys/queue.h> 66 67 #include <dev/cons.h> 68 69 #include <net/if.h> 70 71 /* XXX these should eventually move to subr_autoconf.c */ 72 static int findblkmajor __P((const char *, struct devnametobdevmaj *)); 73 static const char *findblkname __P((int, struct devnametobdevmaj *)); 74 static struct device *getdisk __P((char *, int, int, 75 struct devnametobdevmaj *, dev_t *, int)); 76 static struct device *parsedisk __P((char *, int, int, 77 struct devnametobdevmaj *, dev_t *)); 78 static int getstr __P((char *, int)); 79 80 int 81 uiomove(buf, n, uio) 82 register void *buf; 83 register int n; 84 register struct uio *uio; 85 { 86 register struct iovec *iov; 87 u_int cnt; 88 int error = 0; 89 char *cp = buf; 90 91 #ifdef DIAGNOSTIC 92 if (uio->uio_rw != UIO_READ && uio->uio_rw != UIO_WRITE) 93 panic("uiomove: mode"); 94 if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) 95 panic("uiomove proc"); 96 #endif 97 while (n > 0 && uio->uio_resid) { 98 iov = uio->uio_iov; 99 cnt = iov->iov_len; 100 if (cnt == 0) { 101 uio->uio_iov++; 102 uio->uio_iovcnt--; 103 continue; 104 } 105 if (cnt > n) 106 cnt = n; 107 switch (uio->uio_segflg) { 108 109 case UIO_USERSPACE: 110 if (uio->uio_rw == UIO_READ) 111 error = copyout(cp, iov->iov_base, cnt); 112 else 113 error = copyin(iov->iov_base, cp, cnt); 114 if (error) 115 return (error); 116 break; 117 118 case UIO_SYSSPACE: 119 if (uio->uio_rw == UIO_READ) 120 bcopy(cp, iov->iov_base, cnt); 121 else 122 bcopy(iov->iov_base, cp, cnt); 123 break; 124 } 125 iov->iov_base += cnt; 126 iov->iov_len -= cnt; 127 uio->uio_resid -= cnt; 128 uio->uio_offset += cnt; 129 cp += cnt; 130 n -= cnt; 131 } 132 return (error); 133 } 134 135 /* 136 * Give next character to user as result of read. 137 */ 138 int 139 ureadc(c, uio) 140 register int c; 141 register struct uio *uio; 142 { 143 register struct iovec *iov; 144 145 if (uio->uio_resid <= 0) 146 panic("ureadc: non-positive resid"); 147 again: 148 if (uio->uio_iovcnt <= 0) 149 panic("ureadc: non-positive iovcnt"); 150 iov = uio->uio_iov; 151 if (iov->iov_len <= 0) { 152 uio->uio_iovcnt--; 153 uio->uio_iov++; 154 goto again; 155 } 156 switch (uio->uio_segflg) { 157 158 case UIO_USERSPACE: 159 if (subyte(iov->iov_base, c) < 0) 160 return (EFAULT); 161 break; 162 163 case UIO_SYSSPACE: 164 *iov->iov_base = c; 165 break; 166 } 167 iov->iov_base++; 168 iov->iov_len--; 169 uio->uio_resid--; 170 uio->uio_offset++; 171 return (0); 172 } 173 174 /* 175 * General routine to allocate a hash table. 176 */ 177 void * 178 hashinit(elements, type, hashmask) 179 int elements, type; 180 u_long *hashmask; 181 { 182 long hashsize; 183 LIST_HEAD(generic, generic) *hashtbl; 184 int i; 185 186 if (elements <= 0) 187 panic("hashinit: bad cnt"); 188 for (hashsize = 1; hashsize <= elements; hashsize <<= 1) 189 continue; 190 hashsize >>= 1; 191 hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK); 192 for (i = 0; i < hashsize; i++) 193 LIST_INIT(&hashtbl[i]); 194 *hashmask = hashsize - 1; 195 return (hashtbl); 196 } 197 198 /* 199 * "Shutdown hook" types, functions, and variables. 200 */ 201 202 struct shutdownhook_desc { 203 LIST_ENTRY(shutdownhook_desc) sfd_list; 204 void (*sfd_fn) __P((void *)); 205 void *sfd_arg; 206 }; 207 208 LIST_HEAD(, shutdownhook_desc) shutdownhook_list; 209 210 void * 211 shutdownhook_establish(fn, arg) 212 void (*fn) __P((void *)); 213 void *arg; 214 { 215 struct shutdownhook_desc *ndp; 216 217 ndp = (struct shutdownhook_desc *) 218 malloc(sizeof (*ndp), M_DEVBUF, M_NOWAIT); 219 if (ndp == NULL) 220 return NULL; 221 222 ndp->sfd_fn = fn; 223 ndp->sfd_arg = arg; 224 LIST_INSERT_HEAD(&shutdownhook_list, ndp, sfd_list); 225 226 return (ndp); 227 } 228 229 void 230 shutdownhook_disestablish(vhook) 231 void *vhook; 232 { 233 #ifdef DIAGNOSTIC 234 struct shutdownhook_desc *dp; 235 236 for (dp = shutdownhook_list.lh_first; dp != NULL; 237 dp = dp->sfd_list.le_next) 238 if (dp == vhook) 239 break; 240 if (dp == NULL) 241 panic("shutdownhook_disestablish: hook not established"); 242 #endif 243 244 LIST_REMOVE((struct shutdownhook_desc *)vhook, sfd_list); 245 free(vhook, M_DEVBUF); 246 } 247 248 /* 249 * Run shutdown hooks. Should be invoked immediately before the 250 * system is halted or rebooted, i.e. after file systems unmounted, 251 * after crash dump done, etc. 252 * 253 * Each shutdown hook is removed from the list before it's run, so that 254 * it won't be run again. 255 */ 256 void 257 doshutdownhooks() 258 { 259 struct shutdownhook_desc *dp; 260 261 while ((dp = shutdownhook_list.lh_first) != NULL) { 262 LIST_REMOVE(dp, sfd_list); 263 (*dp->sfd_fn)(dp->sfd_arg); 264 #if 0 265 /* 266 * Don't bother freeing the hook structure,, since we may 267 * be rebooting because of a memory corruption problem, 268 * and this might only make things worse. It doesn't 269 * matter, anyway, since the system is just about to 270 * reboot. 271 */ 272 free(dp, M_DEVBUF); 273 #endif 274 } 275 } 276 277 /* 278 * "Mountroot hook" types, functions, and variables. 279 */ 280 281 struct mountroothook_desc { 282 LIST_ENTRY(mountroothook_desc) mrd_list; 283 struct device *mrd_device; 284 void (*mrd_func) __P((struct device *)); 285 }; 286 287 LIST_HEAD(, mountroothook_desc) mountroothook_list; 288 289 void * 290 mountroothook_establish(func, dev) 291 void (*func) __P((struct device *)); 292 struct device *dev; 293 { 294 struct mountroothook_desc *mrd; 295 296 mrd = (struct mountroothook_desc *) 297 malloc(sizeof(*mrd), M_DEVBUF, M_NOWAIT); 298 if (mrd == NULL) 299 return (NULL); 300 301 mrd->mrd_device = dev; 302 mrd->mrd_func = func; 303 LIST_INSERT_HEAD(&mountroothook_list, mrd, mrd_list); 304 305 return (mrd); 306 } 307 308 void 309 mountroothook_disestablish(vhook) 310 void *vhook; 311 { 312 #ifdef DIAGNOSTIC 313 struct mountroothook_desc *mrd; 314 315 for (mrd = mountroothook_list.lh_first; mrd != NULL; 316 mrd = mrd->mrd_list.le_next) 317 if (mrd == vhook) 318 break; 319 if (mrd == NULL) 320 panic("mountroothook_disestablish: hook not established"); 321 #endif 322 323 LIST_REMOVE((struct mountroothook_desc *)vhook, mrd_list); 324 free(vhook, M_DEVBUF); 325 } 326 327 void 328 mountroothook_destroy() 329 { 330 struct mountroothook_desc *mrd; 331 332 while ((mrd = mountroothook_list.lh_first) != NULL) { 333 LIST_REMOVE(mrd, mrd_list); 334 free(mrd, M_DEVBUF); 335 } 336 } 337 338 void 339 domountroothook() 340 { 341 struct mountroothook_desc *mrd; 342 343 for (mrd = mountroothook_list.lh_first; mrd != NULL; 344 mrd = mrd->mrd_list.le_next) { 345 if (mrd->mrd_device == root_device) { 346 (*mrd->mrd_func)(root_device); 347 return; 348 } 349 } 350 } 351 352 /* 353 * Determine the root device and, if instructed to, the root file system. 354 */ 355 356 #include "md.h" 357 #if NMD == 0 358 #undef MEMORY_DISK_HOOKS 359 #endif 360 361 #ifdef MEMORY_DISK_HOOKS 362 static struct device fakemdrootdev[NMD]; 363 #endif 364 365 void 366 setroot(bootdv, bootpartition, nam2blk) 367 struct device *bootdv; 368 int bootpartition; 369 struct devnametobdevmaj *nam2blk; 370 { 371 struct device *dv; 372 int len, i, print_newline = 0; 373 dev_t nrootdev; 374 dev_t ndumpdev = NODEV; 375 char buf[128]; 376 const char *rootdevname; 377 const char *dumpdevname; 378 struct device *rootdv = NULL; /* XXX gcc -Wuninitialized */ 379 struct device *dumpdv = NULL; 380 struct ifnet *ifp; 381 const char *deffsname; 382 struct vfsops *vops; 383 extern int (*mountroot) __P((void)); 384 static struct devnametobdevmaj *last_nam2blk; 385 386 if (nam2blk == NULL) { 387 if (last_nam2blk == NULL) 388 panic("setroot: no name to bdev major map"); 389 nam2blk = last_nam2blk; 390 } 391 last_nam2blk = nam2blk; 392 393 #ifdef MEMORY_DISK_HOOKS 394 for (i = 0; i < NMD; i++) { 395 fakemdrootdev[i].dv_class = DV_DISK; 396 fakemdrootdev[i].dv_cfdata = NULL; 397 fakemdrootdev[i].dv_unit = i; 398 fakemdrootdev[i].dv_parent = NULL; 399 sprintf(fakemdrootdev[i].dv_xname, "md%d", i); 400 } 401 #endif /* MEMORY_DISK_HOOKS */ 402 403 #ifdef MEMORY_DISK_IS_ROOT 404 bootdv = &fakemdrootdev[0]; 405 bootpartition = 0; 406 #endif 407 408 /* 409 * If NFS is specified as the file system, and we found 410 * a DV_DISK boot device (or no boot device at all), then 411 * find a reasonable network interface for "rootspec". 412 */ 413 vops = vfs_getopsbyname("nfs"); 414 if (vops != NULL && vops->vfs_mountroot == mountroot && 415 rootspec == NULL && 416 (bootdv == NULL || bootdv->dv_class != DV_IFNET)) { 417 for (ifp = ifnet.tqh_first; ifp != NULL; 418 ifp = ifp->if_list.tqe_next) 419 if ((ifp->if_flags & 420 (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0) 421 break; 422 if (ifp == NULL) { 423 /* 424 * Can't find a suitable interface; ask the 425 * user. 426 */ 427 boothowto |= RB_ASKNAME; 428 } else { 429 /* 430 * Have a suitable interface; behave as if 431 * the user specified this interface. 432 */ 433 rootspec = (const char *)ifp->if_xname; 434 } 435 } 436 437 /* 438 * If wildcarded root and we the boot device wasn't determined, 439 * ask the user. 440 */ 441 if (rootspec == NULL && bootdv == NULL) 442 boothowto |= RB_ASKNAME; 443 444 top: 445 if (boothowto & RB_ASKNAME) { 446 struct device *defdumpdv; 447 448 for (;;) { 449 printf("root device"); 450 if (bootdv != NULL) { 451 printf(" (default %s", bootdv->dv_xname); 452 if (bootdv->dv_class == DV_DISK) 453 printf("%c", bootpartition + 'a'); 454 printf(")"); 455 } 456 printf(": "); 457 len = getstr(buf, sizeof(buf)); 458 if (len == 0 && bootdv != NULL) { 459 strcpy(buf, bootdv->dv_xname); 460 len = strlen(buf); 461 } 462 if (len > 0 && buf[len - 1] == '*') { 463 buf[--len] = '\0'; 464 dv = getdisk(buf, len, 1, nam2blk, 465 &nrootdev, 0); 466 if (dv != NULL) { 467 rootdv = dv; 468 break; 469 } 470 } 471 dv = getdisk(buf, len, bootpartition, nam2blk, 472 &nrootdev, 0); 473 if (dv != NULL) { 474 rootdv = dv; 475 break; 476 } 477 } 478 479 /* 480 * Set up the default dump device. If root is on 481 * a network device, there is no default dump 482 * device, since we don't support dumps to the 483 * network. 484 */ 485 if (rootdv->dv_class == DV_IFNET) 486 defdumpdv = NULL; 487 else 488 defdumpdv = rootdv; 489 490 for (;;) { 491 printf("dump device"); 492 if (defdumpdv != NULL) { 493 /* 494 * Note, we know it's a disk if we get here. 495 */ 496 printf(" (default %sb)", defdumpdv->dv_xname); 497 } 498 printf(": "); 499 len = getstr(buf, sizeof(buf)); 500 if (len == 0) { 501 if (defdumpdv != NULL) { 502 ndumpdev = MAKEDISKDEV(major(nrootdev), 503 DISKUNIT(nrootdev), 1); 504 } 505 if (rootdv->dv_class == DV_IFNET) 506 dumpdv = NULL; 507 else 508 dumpdv = rootdv; 509 break; 510 } 511 if (len == 4 && strcmp(buf, "none") == 0) { 512 dumpspec = "none"; 513 goto havedump; 514 } 515 dv = getdisk(buf, len, 1, nam2blk, &ndumpdev, 1); 516 if (dv) { 517 dumpdv = dv; 518 break; 519 } 520 } 521 522 havedump: 523 rootdev = nrootdev; 524 dumpdev = ndumpdev; 525 526 for (i = 0; i < nvfssw; i++) { 527 if (vfssw[i] != NULL && 528 vfssw[i]->vfs_mountroot != NULL && 529 vfssw[i]->vfs_mountroot == mountroot) 530 break; 531 } 532 if (i >= nvfssw) { 533 mountroot = NULL; 534 deffsname = "generic"; 535 } else 536 deffsname = vfssw[i]->vfs_name; 537 for (;;) { 538 printf("file system (default %s): ", deffsname); 539 len = getstr(buf, sizeof(buf)); 540 if (len == 0) 541 break; 542 if (len == 4 && strcmp(buf, "halt") == 0) 543 cpu_reboot(RB_HALT, NULL); 544 else if (len == 7 && strcmp(buf, "generic") == 0) { 545 mountroot = NULL; 546 break; 547 } 548 vops = vfs_getopsbyname(buf); 549 if (vops == NULL || vops->vfs_mountroot == NULL) { 550 printf("use one of: generic"); 551 for (i = 0; i < nvfssw; i++) 552 if (vfssw[i] != NULL && 553 vfssw[i]->vfs_mountroot != NULL) 554 printf(" %s", 555 vfssw[i]->vfs_name); 556 printf(" halt\n"); 557 } else { 558 mountroot = vops->vfs_mountroot; 559 break; 560 } 561 } 562 563 } else if (rootspec == NULL) { 564 int majdev; 565 566 /* 567 * Wildcarded root; use the boot device. 568 */ 569 rootdv = bootdv; 570 571 majdev = findblkmajor(bootdv->dv_xname, nam2blk); 572 if (majdev >= 0) { 573 /* 574 * Root is on a disk. `bootpartition' is root. 575 */ 576 rootdev = MAKEDISKDEV(majdev, bootdv->dv_unit, 577 bootpartition); 578 } 579 } else { 580 581 /* 582 * `root on <dev> ...' 583 */ 584 585 /* 586 * If it's a network interface, we can bail out 587 * early. 588 */ 589 for (dv = alldevs.tqh_first; dv != NULL; 590 dv = dv->dv_list.tqe_next) 591 if (strcmp(dv->dv_xname, rootspec) == 0) 592 break; 593 if (dv != NULL && dv->dv_class == DV_IFNET) { 594 rootdv = dv; 595 goto haveroot; 596 } 597 598 rootdevname = findblkname(major(rootdev), nam2blk); 599 if (rootdevname == NULL) { 600 printf("unknown device major 0x%x\n", rootdev); 601 boothowto |= RB_ASKNAME; 602 goto top; 603 } 604 bzero(buf, sizeof(buf)); 605 sprintf(buf, "%s%d", rootdevname, DISKUNIT(rootdev)); 606 607 for (dv = alldevs.tqh_first; dv != NULL; 608 dv = dv->dv_list.tqe_next) { 609 if (strcmp(buf, dv->dv_xname) == 0) { 610 rootdv = dv; 611 break; 612 } 613 } 614 if (rootdv == NULL) { 615 printf("device %s (0x%x) not configured\n", 616 buf, rootdev); 617 boothowto |= RB_ASKNAME; 618 goto top; 619 } 620 } 621 622 haveroot: 623 624 root_device = rootdv; 625 626 switch (rootdv->dv_class) { 627 case DV_IFNET: 628 /* Nothing. */ 629 break; 630 631 case DV_DISK: 632 printf("root on %s%c", rootdv->dv_xname, 633 DISKPART(rootdev) + 'a'); 634 print_newline = 1; 635 break; 636 637 default: 638 printf("can't determine root device\n"); 639 boothowto |= RB_ASKNAME; 640 goto top; 641 } 642 643 /* 644 * Now configure the dump device. 645 */ 646 647 if (dumpspec != NULL && strcmp(dumpspec, "none") == 0) { 648 /* 649 * Operator doesn't want a dump device. 650 */ 651 goto nodumpdev; 652 } 653 654 /* 655 * If we haven't figured out the dump device, do so, with 656 * the following rules: 657 * 658 * (a) We already know dumpdv in the RB_ASKNAME case. 659 * 660 * (b) If dumpspec is set, try to use it. If the device 661 * is not available, punt. 662 * 663 * (c) If dumpspec is not set, the dump device is 664 * wildcarded or unspecified. If the root device 665 * is DV_IFNET, punt. Otherwise, use partition b 666 * of the root device. 667 */ 668 669 if (boothowto & RB_ASKNAME) { 670 if (dumpdv == NULL) { 671 /* 672 * Just return; dumpdev is already set to NODEV 673 * and we don't want to print a newline in this 674 * case. 675 */ 676 return; 677 } 678 goto out; 679 } 680 681 if (dumpspec != NULL) { 682 if (dumpdev == NODEV) { 683 /* 684 * Looks like they tried to pick a network 685 * device. Oops. 686 */ 687 goto nodumpdev; 688 } 689 690 dumpdevname = findblkname(major(dumpdev), nam2blk); 691 if (dumpdevname == NULL) 692 goto nodumpdev; 693 bzero(buf, sizeof(buf)); 694 sprintf(buf, "%s%d", dumpdevname, DISKUNIT(dumpdev)); 695 696 for (dv = alldevs.tqh_first; dv != NULL; 697 dv = dv->dv_list.tqe_next) { 698 if (strcmp(buf, dv->dv_xname) == 0) { 699 dumpdv = dv; 700 break; 701 } 702 } 703 if (dv == NULL) { 704 /* 705 * Device not configured. 706 */ 707 goto nodumpdev; 708 } 709 } else if (rootdv->dv_class == DV_IFNET) 710 goto nodumpdev; 711 else { 712 dumpdv = rootdv; 713 dumpdev = MAKEDISKDEV(major(rootdev), dumpdv->dv_unit, 1); 714 } 715 716 out: 717 printf(" dumps on %s%c\n", dumpdv->dv_xname, DISKPART(dumpdev) + 'a'); 718 return; 719 720 nodumpdev: 721 dumpdev = NODEV; 722 if (print_newline) 723 printf("\n"); 724 } 725 726 static int 727 findblkmajor(name, nam2blk) 728 const char *name; 729 struct devnametobdevmaj *nam2blk; 730 { 731 int i; 732 733 if (nam2blk == NULL) 734 return (-1); 735 736 for (i = 0; nam2blk[i].d_name != NULL; i++) 737 if (strncmp(name, nam2blk[i].d_name, 738 strlen(nam2blk[i].d_name)) == 0) 739 return (nam2blk[i].d_maj); 740 return (-1); 741 } 742 743 const char * 744 findblkname(maj, nam2blk) 745 int maj; 746 struct devnametobdevmaj *nam2blk; 747 { 748 int i; 749 750 if (nam2blk == NULL) 751 return (NULL); 752 753 for (i = 0; nam2blk[i].d_name != NULL; i++) 754 if (nam2blk[i].d_maj == maj) 755 return (nam2blk[i].d_name); 756 return (NULL); 757 } 758 759 static struct device * 760 getdisk(str, len, defpart, nam2blk, devp, isdump) 761 char *str; 762 int len, defpart; 763 struct devnametobdevmaj *nam2blk; 764 dev_t *devp; 765 int isdump; 766 { 767 struct device *dv; 768 #ifdef MEMORY_DISK_HOOKS 769 int i; 770 #endif 771 772 if ((dv = parsedisk(str, len, defpart, nam2blk, devp)) == NULL) { 773 printf("use one of:"); 774 #ifdef MEMORY_DISK_HOOKS 775 if (isdump == 0) 776 for (i = 0; i < NMD; i++) 777 printf(" %s[a-%c]", fakemdrootdev[i].dv_xname, 778 'a' + MAXPARTITIONS - 1); 779 #endif 780 for (dv = alldevs.tqh_first; dv != NULL; 781 dv = dv->dv_list.tqe_next) { 782 if (dv->dv_class == DV_DISK) 783 printf(" %s[a-%c]", dv->dv_xname, 784 'a' + MAXPARTITIONS - 1); 785 if (isdump == 0 && dv->dv_class == DV_IFNET) 786 printf(" %s", dv->dv_xname); 787 } 788 if (isdump) 789 printf(" none"); 790 printf(" halt\n"); 791 } 792 return (dv); 793 } 794 795 static struct device * 796 parsedisk(str, len, defpart, nam2blk, devp) 797 char *str; 798 int len, defpart; 799 struct devnametobdevmaj *nam2blk; 800 dev_t *devp; 801 { 802 struct device *dv; 803 char *cp, c; 804 int majdev, part; 805 #ifdef MEMORY_DISK_HOOKS 806 int i; 807 #endif 808 809 if (len == 0) 810 return (NULL); 811 812 if (len == 4 && strcmp(str, "halt") == 0) 813 cpu_reboot(RB_HALT, NULL); 814 815 cp = str + len - 1; 816 c = *cp; 817 if (c >= 'a' && c <= ('a' + MAXPARTITIONS - 1)) { 818 part = c - 'a'; 819 *cp = '\0'; 820 } else 821 part = defpart; 822 823 #ifdef MEMORY_DISK_HOOKS 824 for (i = 0; i < NMD; i++) 825 if (strcmp(str, fakemdrootdev[i].dv_xname) == 0) { 826 dv = &fakemdrootdev[i]; 827 goto gotdisk; 828 } 829 #endif 830 831 for (dv = alldevs.tqh_first; dv != NULL; dv = dv->dv_list.tqe_next) { 832 if (dv->dv_class == DV_DISK && 833 strcmp(str, dv->dv_xname) == 0) { 834 #ifdef MEMORY_DISK_HOOKS 835 gotdisk: 836 #endif 837 majdev = findblkmajor(dv->dv_xname, nam2blk); 838 if (majdev < 0) 839 panic("parsedisk"); 840 *devp = MAKEDISKDEV(majdev, dv->dv_unit, part); 841 break; 842 } 843 844 if (dv->dv_class == DV_IFNET && 845 strcmp(str, dv->dv_xname) == 0) { 846 *devp = NODEV; 847 break; 848 } 849 } 850 851 *cp = c; 852 return (dv); 853 } 854 855 /* 856 * XXX shouldn't this be a common function? 857 */ 858 static int 859 getstr(cp, size) 860 char *cp; 861 int size; 862 { 863 char *lp; 864 int c, len; 865 866 cnpollc(1); 867 868 lp = cp; 869 len = 0; 870 for (;;) { 871 c = cngetc(); 872 switch (c) { 873 case '\n': 874 case '\r': 875 printf("\n"); 876 *lp++ = '\0'; 877 cnpollc(0); 878 return (len); 879 case '\b': 880 case '\177': 881 case '#': 882 if (len) { 883 --len; 884 --lp; 885 printf("\b \b"); 886 } 887 continue; 888 case '@': 889 case 'u'&037: 890 len = 0; 891 lp = cp; 892 printf("\n"); 893 continue; 894 default: 895 if (len + 1 >= size || c < ' ') { 896 printf("\007"); 897 continue; 898 } 899 printf("%c", c); 900 ++len; 901 *lp++ = c; 902 } 903 } 904 } 905
Indexes created Thu Sep 25 08:09:54 GMT 2025