Home | History | Annotate | Line # | Download | only in kern
kern_subr.c revision 1.22 
      1 /*	$NetBSD: kern_subr.c,v 1.22 1997/02/24 12:20:47 leo 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 *));
     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  * XXX Root and swap must be on the same class of device, (ie. DV_DISK
    356  * XXX or DV_IFNET) because of how (*mountroot)() is written.
    357  * XXX That should be fixed.
    358  */
    359 
    360 #include "md.h"
    361 #if NMD == 0
    362 #undef MEMORY_DISK_HOOKS
    363 #endif
    364 
    365 #ifdef MEMORY_DISK_HOOKS
    366 static struct device fakemdrootdev = { DV_DISK, {}, NULL, 0, "md0", NULL };
    367 #endif
    368 
    369 void
    370 setroot(bootdv, bootpartition, nam2blk)
    371 	struct device *bootdv;
    372 	int bootpartition;
    373 	struct devnametobdevmaj *nam2blk;
    374 {
    375 	struct swdevt *swp;
    376 	struct device *dv;
    377 	register int len, i;
    378 	dev_t nrootdev, nswapdev = NODEV;
    379 	char buf[128];
    380 	const char *rootdevname;
    381 	dev_t temp;
    382 	struct device *rootdv, *swapdv = NULL;		/* XXX gcc */
    383 	struct ifnet *ifp;
    384 	const char *deffsname;
    385 	struct vfsops *vops;
    386 	extern int (*mountroot) __P((void));
    387 	static struct devnametobdevmaj *last_nam2blk;
    388 
    389 	if (nam2blk == NULL) {
    390 		if (last_nam2blk == NULL)
    391 			panic("setroot: no name to bdev major map");
    392 		nam2blk = last_nam2blk;
    393 	}
    394 	last_nam2blk = nam2blk;
    395 
    396 #ifdef MEMORY_DISK_IS_ROOT
    397 	bootdv = &fakemdrootdev;
    398 	bootpartition = 0;
    399 #endif
    400 
    401 	/*
    402 	 * If wildcarded root and we the boot device wasn't determined,
    403 	 * ask the user.
    404 	 */
    405 	if (rootspec == NULL && bootdv == NULL)
    406 		boothowto |= RB_ASKNAME;
    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  top:
    438 	if (boothowto & RB_ASKNAME) {
    439 		for (;;) {
    440 			printf("root device");
    441 			if (bootdv != NULL) {
    442 				printf(" (default %s", bootdv->dv_xname);
    443 				if (bootdv->dv_class == DV_DISK)
    444 					printf("%c", bootpartition + 'a');
    445 				printf(")");
    446 			}
    447 			printf(": ");
    448 			len = getstr(buf, sizeof(buf));
    449 			if (len == 0 && bootdv != NULL) {
    450 				strcpy(buf, bootdv->dv_xname);
    451 				len = strlen(buf);
    452 			}
    453 			if (len > 0 && buf[len - 1] == '*') {
    454 				buf[--len] = '\0';
    455 				dv = getdisk(buf, len, 1, nam2blk, &nrootdev);
    456 				if (dv != NULL) {
    457 					rootdv = dv;
    458 					swapdv = dv;
    459 					nswapdev = nrootdev;
    460 					goto gotswap;
    461 				}
    462 			}
    463 			dv = getdisk(buf, len, bootpartition, nam2blk,
    464 			    &nrootdev);
    465 			if (dv != NULL) {
    466 				rootdv = dv;
    467 				break;
    468 			}
    469 		}
    470 
    471 		/*
    472 		 * Because swap must be on the same device as root,
    473 		 * for network devices this is easy.
    474 		 */
    475 		if (rootdv->dv_class == DV_IFNET) {
    476 			swapdv = NULL;
    477 			goto gotswap;
    478 		}
    479 
    480 		for (;;) {
    481 			printf("swap device (default %s", rootdv->dv_xname);
    482 			if (rootdv->dv_class == DV_DISK)
    483 				printf("b");
    484 			printf("): ");
    485 			len = getstr(buf, sizeof(buf));
    486 			if (len == 0) {
    487 				switch (rootdv->dv_class) {
    488 				case DV_IFNET:
    489 					nswapdev = NODEV;
    490 					break;
    491 				case DV_DISK:
    492 					nswapdev = MAKEDISKDEV(major(nrootdev),
    493 					    DISKUNIT(nrootdev), 1);
    494 					break;
    495 				default:
    496 					break;
    497 				}
    498 				swapdv = rootdv;
    499 				break;
    500 			}
    501 			dv = getdisk(buf, len, 1, nam2blk, &nswapdev);
    502 			if (dv) {
    503 				if (dv->dv_class == DV_IFNET)
    504 					nswapdev = NODEV;
    505 				swapdv = dv;
    506 				break;
    507 			}
    508 		}
    509  gotswap:
    510 
    511 #ifdef MEMORY_DISK_HOOKS
    512 		/*
    513 		 * Mustn't swap on a memory disk!
    514 		 */
    515 		if (swapdv == &fakemdrootdev) {
    516 			swapdv = NULL;
    517 			nswapdev = NODEV;
    518 		}
    519 #endif
    520 
    521 		rootdev = nrootdev;
    522 		dumpdev = nswapdev;
    523 		swdevt[0].sw_dev = nswapdev;
    524 		swdevt[1].sw_dev = NODEV;
    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 				boot(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 		majdev = findblkmajor(bootdv->dv_xname, nam2blk);
    570 		if (majdev >= 0) {
    571 			/*
    572 			 * Root and swap are on a disk.  `bootpartition'
    573 			 * is root, partition `b' is swap.
    574 			 */
    575 			rootdv = swapdv = bootdv;
    576 			rootdev = MAKEDISKDEV(majdev, bootdv->dv_unit,
    577 			    bootpartition);
    578 			nswapdev = dumpdev =
    579 			    MAKEDISKDEV(majdev, bootdv->dv_unit, 1);
    580 		} else {
    581 			/*
    582 			 * Root and swap are on a net.
    583 			 */
    584 			rootdv = swapdv = bootdv;
    585 			nswapdev = dumpdev = NODEV;
    586 		}
    587 
    588 #ifdef MEMORY_DISK_HOOKS
    589 		/*
    590 		 * Mustn't swap to a memory disk!
    591 		 */
    592 		if (swapdv == &fakemdrootdev) {
    593 			swapdv = NULL;
    594 			nswapdev = NODEV;
    595 		}
    596 #endif
    597 
    598 		swdevt[0].sw_dev = nswapdev;
    599 		swdevt[1].sw_dev = NODEV;
    600 
    601 	} else {
    602 
    603 		/*
    604 		 * `root on <dev> swap on <dev> ...'
    605 		 */
    606 
    607 		/*
    608 		 * If it's a network interface, we can bail out
    609 		 * early.
    610 		 */
    611 		for (dv = alldevs.tqh_first; dv != NULL;
    612 		    dv = dv->dv_list.tqe_next)
    613 			if (strcmp(dv->dv_xname, rootspec) == 0)
    614 				break;
    615 		if (dv != NULL && dv->dv_class == DV_IFNET) {
    616 			root_device = dv;
    617 			return;
    618 		}
    619 
    620 		rootdevname = findblkname(major(rootdev), nam2blk);
    621 		if (rootdevname == NULL) {
    622 			printf("unknown device major 0x%x\n", rootdev);
    623 			boothowto |= RB_ASKNAME;
    624 			goto top;
    625 		}
    626 		bzero(buf, sizeof(buf));
    627 		sprintf(buf, "%s%d", rootdevname, DISKUNIT(rootdev));
    628 
    629 #ifdef MEMORY_DISK_HOOKS
    630 		if (strcmp(buf, fakemdrootdev.dv_xname) == 0) {
    631 			/*
    632 			 * XXX Must make sure we don't swap
    633 			 * XXX to a memory disk!
    634 			 */
    635 			root_device = &fakemdrootdev;
    636 			return;
    637 		}
    638 #endif
    639 
    640 		for (dv = alldevs.tqh_first; dv != NULL;
    641 		    dv = dv->dv_list.tqe_next) {
    642 			if (strcmp(buf, dv->dv_xname) == 0) {
    643 				root_device = dv;
    644 				break;
    645 			}
    646 		}
    647 		if (dv == NULL) {
    648 			printf("device %s (0x%x) not configured\n",
    649 			    buf, rootdev);
    650 			boothowto |= RB_ASKNAME;
    651 			goto top;
    652 		}
    653 
    654 		return;
    655 	}
    656 
    657 	root_device = rootdv;
    658 
    659 	switch (rootdv->dv_class) {
    660 	case DV_IFNET:
    661 		return;
    662 
    663 	case DV_DISK:
    664 		printf("root on %s%c", rootdv->dv_xname,
    665 		    DISKPART(rootdev) + 'a');
    666 		if (nswapdev != NODEV)
    667 			printf(" swap on %s%c", swapdv->dv_xname,
    668 			    DISKPART(nswapdev) + 'a');
    669 		printf("\n");
    670 		break;
    671 
    672 	default:
    673 		printf("can't determine root device\n");
    674 		boothowto |= RB_ASKNAME;
    675 		goto top;
    676 	}
    677 
    678 	/*
    679 	 * Make the swap partition on the root drive the primary swap.
    680 	 */
    681 	temp = NODEV;
    682 	for (swp = swdevt; swp->sw_dev != NODEV; swp++) {
    683 		if (major(rootdev) == major(swp->sw_dev) &&
    684 		    DISKUNIT(rootdev) == DISKUNIT(swp->sw_dev)) {
    685 			temp = swdevt[0].sw_dev;
    686 			swdevt[0].sw_dev = swp->sw_dev;
    687 			swp->sw_dev = temp;
    688 			break;
    689 		}
    690 	}
    691 	if (swp->sw_dev == NODEV)
    692 		return;
    693 
    694 	/*
    695 	 * If dumpdev was the same as the old primary swap device, move
    696 	 * it to the new primary swap device.
    697 	 */
    698 	if (temp == dumpdev)
    699 		dumpdev = swdevt[0].sw_dev;
    700 }
    701 
    702 static int
    703 findblkmajor(name, nam2blk)
    704 	const char *name;
    705 	struct devnametobdevmaj *nam2blk;
    706 {
    707 	int i;
    708 
    709 	if (nam2blk == NULL)
    710 		return (-1);
    711 
    712 	for (i = 0; nam2blk[i].d_name != NULL; i++)
    713 		if (strncmp(name, nam2blk[i].d_name,
    714 		    strlen(nam2blk[i].d_name)) == 0)
    715 			return (nam2blk[i].d_maj);
    716 	return (-1);
    717 }
    718 
    719 const char *
    720 findblkname(maj, nam2blk)
    721 	int maj;
    722 	struct devnametobdevmaj *nam2blk;
    723 {
    724 	int i;
    725 
    726 	if (nam2blk == NULL)
    727 		return (NULL);
    728 
    729 	for (i = 0; nam2blk[i].d_name != NULL; i++)
    730 		if (nam2blk[i].d_maj == maj)
    731 			return (nam2blk[i].d_name);
    732 	return (NULL);
    733 }
    734 
    735 static struct device *
    736 getdisk(str, len, defpart, nam2blk, devp)
    737 	char *str;
    738 	int len, defpart;
    739 	struct devnametobdevmaj *nam2blk;
    740 	dev_t *devp;
    741 {
    742 	struct device *dv;
    743 
    744 	if ((dv = parsedisk(str, len, defpart, nam2blk, devp)) == NULL) {
    745 		printf("use one of:");
    746 #ifdef MEMORY_DISK_HOOKS
    747 		printf(" %s[a-%c]", fakemdrootdev.dv_xname,
    748 		    'a' + MAXPARTITIONS - 1);
    749 #endif
    750 		for (dv = alldevs.tqh_first; dv != NULL;
    751 		    dv = dv->dv_list.tqe_next) {
    752 			if (dv->dv_class == DV_DISK)
    753 				printf(" %s[a-%c]", dv->dv_xname,
    754 				    'a' + MAXPARTITIONS - 1);
    755 			if (dv->dv_class == DV_IFNET)
    756 				printf(" %s", dv->dv_xname);
    757 		}
    758 		printf(" halt\n");
    759 	}
    760 	return (dv);
    761 }
    762 
    763 static struct device *
    764 parsedisk(str, len, defpart, nam2blk, devp)
    765 	char *str;
    766 	int len, defpart;
    767 	struct devnametobdevmaj *nam2blk;
    768 	dev_t *devp;
    769 {
    770 	struct device *dv;
    771 	char *cp, c;
    772 	int majdev, part;
    773 
    774 	if (len == 0)
    775 		return (NULL);
    776 
    777 	if (len == 4 && strcmp(str, "halt") == 0)
    778 		boot(RB_HALT, NULL);
    779 
    780 	cp = str + len - 1;
    781 	c = *cp;
    782 	if (c >= 'a' && c <= ('a' + MAXPARTITIONS - 1)) {
    783 		part = c - 'a';
    784 		*cp = '\0';
    785 	} else
    786 		part = defpart;
    787 
    788 #ifdef MEMORY_DISK_HOOKS
    789 	if (strcmp(str, fakemdrootdev.dv_xname) == 0) {
    790 		dv = &fakemdrootdev;
    791 		goto gotdisk;
    792 	}
    793 #endif
    794 
    795 	for (dv = alldevs.tqh_first; dv != NULL; dv = dv->dv_list.tqe_next) {
    796 		if (dv->dv_class == DV_DISK &&
    797 		    strcmp(str, dv->dv_xname) == 0) {
    798 #ifdef MEMORY_DISK_HOOKS
    799  gotdisk:
    800 #endif
    801 			majdev = findblkmajor(dv->dv_xname, nam2blk);
    802 			if (majdev < 0)
    803 				panic("parsedisk");
    804 			*devp = MAKEDISKDEV(majdev, dv->dv_unit, part);
    805 			break;
    806 		}
    807 
    808 		if (dv->dv_class == DV_IFNET &&
    809 		    strcmp(str, dv->dv_xname) == 0) {
    810 			*devp = NODEV;
    811 			break;
    812 		}
    813 	}
    814 
    815 	*cp = c;
    816 	return (dv);
    817 }
    818 
    819 /*
    820  * XXX shouldn't this be a common function?
    821  */
    822 static int
    823 getstr(cp, size)
    824 	char *cp;
    825 	int size;
    826 {
    827 	char *lp;
    828 	int c, len;
    829 
    830 	cnpollc(1);
    831 
    832 	lp = cp;
    833 	len = 0;
    834 	for (;;) {
    835 		c = cngetc();
    836 		switch (c) {
    837 		case '\n':
    838 		case '\r':
    839 			printf("\n");
    840 			*lp++ = '\0';
    841 			cnpollc(0);
    842 			return (len);
    843 		case '\b':
    844 		case '\177':
    845 		case '#':
    846 			if (len) {
    847 				--len;
    848 				--lp;
    849 				printf("\b \b");
    850 			}
    851 			continue;
    852 		case '@':
    853 		case 'u'&037:
    854 			len = 0;
    855 			lp = cp;
    856 			printf("\n");
    857 			continue;
    858 		default:
    859 			if (len + 1 >= size || c < ' ') {
    860 				printf("\007");
    861 				continue;
    862 			}
    863 			printf("%c", c);
    864 			++len;
    865 			*lp++ = c;
    866 		}
    867 	}
    868 }
    869 
    870 /*
    871  * Configure swap space and related parameters.
    872  * XXX This, and swdevt[] in generial, should go away.
    873  */
    874 void
    875 swapconf()
    876 {
    877 	struct swdevt *swp;
    878 	int nblks, maj;
    879 
    880 	for (swp = swdevt; swp->sw_dev != NODEV; swp++) {
    881 		maj = major(swp->sw_dev);
    882 
    883 		if (maj > nblkdev)
    884 			break;
    885 		if (bdevsw[maj].d_psize) {
    886 			nblks = (*bdevsw[maj].d_psize)(swp->sw_dev);
    887 			if (nblks != -1 &&
    888 			    (swp->sw_nblks == 0 || swp->sw_nblks > nblks))
    889 				swp->sw_nblks = nblks;
    890 			else
    891 				swp->sw_nblks = 0;
    892 			swp->sw_nblks = ctod(dtoc(swp->sw_nblks));
    893 		}
    894 	}
    895 }
    896