1 /* $NetBSD: kern_subr.c,v 1.231 2023/01/19 07:40:58 mlelstv Exp $ */
2
3 /*-
4 * Copyright (c) 1997, 1998, 1999, 2002, 2007, 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 * NASA Ames Research Center, and by Luke Mewburn.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 /*
34 * Copyright (c) 1982, 1986, 1991, 1993
35 * The Regents of the University of California. All rights reserved.
36 * (c) UNIX System Laboratories, Inc.
37 * All or some portions of this file are derived from material licensed
38 * to the University of California by American Telephone and Telegraph
39 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
40 * the permission of UNIX System Laboratories, Inc.
41 *
42 * Copyright (c) 1992, 1993
43 * The Regents of the University of California. All rights reserved.
44 *
45 * This software was developed by the Computer Systems Engineering group
46 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
47 * contributed to Berkeley.
48 *
49 * All advertising materials mentioning features or use of this software
50 * must display the following acknowledgement:
51 * This product includes software developed by the University of
52 * California, Lawrence Berkeley Laboratory.
53 *
54 * Redistribution and use in source and binary forms, with or without
55 * modification, are permitted provided that the following conditions
56 * are met:
57 * 1. Redistributions of source code must retain the above copyright
58 * notice, this list of conditions and the following disclaimer.
59 * 2. Redistributions in binary form must reproduce the above copyright
60 * notice, this list of conditions and the following disclaimer in the
61 * documentation and/or other materials provided with the distribution.
62 * 3. Neither the name of the University nor the names of its contributors
63 * may be used to endorse or promote products derived from this software
64 * without specific prior written permission.
65 *
66 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
67 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
68 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
69 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
70 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
71 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
72 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
73 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
74 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
75 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
76 * SUCH DAMAGE.
77 *
78 * @(#)kern_subr.c 8.4 (Berkeley) 2/14/95
79 */
80
81 #include <sys/cdefs.h>
82 __KERNEL_RCSID(0, "$NetBSD: kern_subr.c,v 1.231 2023/01/19 07:40:58 mlelstv Exp $");
83
84 #include "opt_ddb.h"
85 #include "opt_md.h"
86 #include "opt_tftproot.h"
87
88 #include <sys/param.h>
89 #include <sys/systm.h>
90 #include <sys/proc.h>
91 #include <sys/mount.h>
92 #include <sys/device.h>
93 #include <sys/reboot.h>
94 #include <sys/conf.h>
95 #include <sys/disk.h>
96 #include <sys/disklabel.h>
97 #include <sys/queue.h>
98 #include <sys/fcntl.h>
99 #include <sys/kauth.h>
100 #include <sys/stat.h>
101 #include <sys/vnode.h>
102 #include <sys/module.h>
103
104 #include <dev/cons.h>
105
106 #include <net/if.h>
107
108 /* XXX these should eventually move to subr_autoconf.c */
109 static device_t finddevice(const char *);
110 static device_t getdisk(const char *, int, int, dev_t *, int);
111 static device_t parsedisk(const char *, int, int, dev_t *);
112 static const char *getwedgename(const char *, int);
113
114 static void setroot_nfs(device_t);
115 static void setroot_md(device_t *);
116 static void setroot_ask(device_t, int);
117 static void setroot_root(device_t, int);
118 static void setroot_dump(device_t, device_t);
119
120
121 #ifdef TFTPROOT
122 int tftproot_dhcpboot(device_t);
123 #endif
124
125 dev_t dumpcdev; /* for savecore */
126
127 static int
isswap(device_t dv)128 isswap(device_t dv)
129 {
130 struct dkwedge_info wi;
131 struct vnode *vn;
132 int error;
133
134 if (device_class(dv) != DV_DISK || !device_is_a(dv, "dk"))
135 return 0;
136
137 if ((vn = opendisk(dv)) == NULL)
138 return 0;
139
140 VOP_UNLOCK(vn);
141 error = VOP_IOCTL(vn, DIOCGWEDGEINFO, &wi, FREAD, NOCRED);
142 vn_lock(vn, LK_EXCLUSIVE | LK_RETRY);
143 VOP_CLOSE(vn, FREAD, NOCRED);
144 vput(vn);
145 if (error) {
146 #ifdef DEBUG_WEDGE
147 printf("%s: Get wedge info returned %d\n", device_xname(dv), error);
148 #endif
149 return 0;
150 }
151 return strcmp(wi.dkw_ptype, DKW_PTYPE_SWAP) == 0;
152 }
153
154 /*
155 * Determine the root device and, if instructed to, the root file system.
156 */
157
158 #ifdef MEMORY_DISK_IS_ROOT
159 int md_is_root = 1;
160 #else
161 int md_is_root = 0;
162 #endif
163
164 /*
165 * The device and partition that we booted from.
166 *
167 * This data might be initialized by MD code, but is defined here.
168 */
169 device_t booted_device;
170 const char *booted_method;
171 int booted_partition;
172 daddr_t booted_startblk;
173 uint64_t booted_nblks;
174 char *bootspec;
175
176 /*
177 * Time to wait for a specified boot device to appear.
178 */
179 #ifndef ROOT_WAITTIME
180 #define ROOT_WAITTIME 20
181 #endif
182
183 /*
184 * Use partition letters if it's a disk class but not a wedge or flash.
185 * XXX Check for wedge/flash is kinda gross.
186 */
187 #define DEV_USES_PARTITIONS(dv) \
188 (device_class((dv)) == DV_DISK && \
189 !device_is_a((dv), "dk") && \
190 !device_is_a((dv), "flash"))
191
192 void
setroot(device_t bootdv,int bootpartition)193 setroot(device_t bootdv, int bootpartition)
194 {
195 time_t waitend;
196
197 /*
198 * Let bootcode augment "rootspec", ensure that
199 * rootdev is invalid to avoid confusion.
200 */
201 if (rootspec == NULL) {
202 rootspec = bootspec;
203 rootdev = NODEV;
204 }
205
206 /*
207 * force boot device to md0
208 */
209 if (md_is_root)
210 setroot_md(&bootdv);
211
212 #ifdef TFTPROOT
213 /*
214 * XXX
215 * if rootspec specifies an interface
216 * sets root_device to that interface
217 * reuses NFS init code to set up network
218 * fetch image into ram disk
219 *
220 * if successful, we change boot device
221 */
222 if (tftproot_dhcpboot(bootdv) == 0)
223 setroot_md(&bootdv);
224 #endif
225
226 /*
227 * quirk for
228 * evbarm/mini2440
229 * hpcarm
230 * hpcmips
231 * hpcsh
232 *
233 * if rootfstype is set to NFS and the
234 * kernel supports NFS and the boot device
235 * is unknown or not a network interface
236 * -> chose the first network interface you find
237 *
238 * hp300 has similar MD code
239 */
240 setroot_nfs(bootdv);
241
242 /*
243 * If no bootdv was found by MD code and no
244 * root specified ask the user.
245 */
246 if (rootspec == NULL && bootdv == NULL)
247 boothowto |= RB_ASKNAME;
248
249 /*
250 * loop until a root device is specified
251 */
252 waitend = time_uptime + ROOT_WAITTIME;
253 do {
254 if (boothowto & RB_ASKNAME)
255 setroot_ask(bootdv, bootpartition);
256 else {
257 setroot_root(bootdv, bootpartition);
258 if (root_device == NULL) {
259 if (time_uptime < waitend) {
260 kpause("root", false, hz, NULL);
261 } else
262 boothowto |= RB_ASKNAME;
263 }
264 }
265 } while (root_device == NULL);
266 }
267
268 /*
269 * If NFS is specified as the file system, and we found
270 * a DV_DISK boot device (or no boot device at all), then
271 * find a reasonable network interface for "rootspec".
272 */
273 static void
setroot_nfs(device_t dv)274 setroot_nfs(device_t dv)
275 {
276 struct vfsops *vops;
277 struct ifnet *ifp;
278
279 vops = vfs_getopsbyname(MOUNT_NFS);
280 if (vops != NULL && strcmp(rootfstype, MOUNT_NFS) == 0 &&
281 rootspec == NULL &&
282 (dv == NULL || device_class(dv) != DV_IFNET)) {
283 int s = pserialize_read_enter();
284 IFNET_READER_FOREACH(ifp) {
285 if ((ifp->if_flags &
286 (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0)
287 break;
288 }
289 if (ifp != NULL) {
290 /*
291 * Have a suitable interface; behave as if
292 * the user specified this interface.
293 */
294 rootspec = (const char *)ifp->if_xname;
295 }
296 pserialize_read_exit(s);
297 }
298 if (vops != NULL)
299 vfs_delref(vops);
300 }
301
302 /*
303 * Change boot device to md0
304 *
305 * md0 only exists when it is opened once.
306 */
307 static void
setroot_md(device_t * dvp)308 setroot_md(device_t *dvp)
309 {
310 int md_major;
311 dev_t md_dev;
312
313 md_major = devsw_name2blk("md", NULL, 0);
314 if (md_major >= 0) {
315 md_dev = MAKEDISKDEV(md_major, 0, RAW_PART);
316 if (bdev_open(md_dev, FREAD, S_IFBLK, curlwp) == 0)
317 *dvp = device_find_by_xname("md0");
318 }
319 }
320
321 static void
setroot_ask(device_t bootdv,int bootpartition)322 setroot_ask(device_t bootdv, int bootpartition)
323 {
324 device_t dv, defdumpdv, rootdv, dumpdv;
325 dev_t nrootdev, ndumpdev;
326 struct vfsops *vops;
327 const char *deffsname;
328 int len;
329 char buf[128];
330
331 for (;;) {
332 printf("root device");
333 if (bootdv != NULL) {
334 printf(" (default %s", device_xname(bootdv));
335 if (DEV_USES_PARTITIONS(bootdv))
336 printf("%c", bootpartition + 'a');
337 printf(")");
338 }
339 printf(": ");
340 len = cngetsn(buf, sizeof(buf));
341 if (len == 0 && bootdv != NULL) {
342 strlcpy(buf, device_xname(bootdv), sizeof(buf));
343 len = strlen(buf);
344 }
345 if (len > 0 && buf[len - 1] == '*') {
346 buf[--len] = '\0';
347 dv = getdisk(buf, len, 1, &nrootdev, 0);
348 if (dv != NULL) {
349 rootdv = dv;
350 break;
351 }
352 }
353 dv = getdisk(buf, len, bootpartition, &nrootdev, 0);
354 if (dv != NULL) {
355 rootdv = dv;
356 break;
357 }
358 }
359 rootdev = nrootdev;
360
361 /*
362 * Set up the default dump device. If root is on
363 * a network device or a disk without partitions,
364 * there is no default dump device.
365 */
366 if (DEV_USES_PARTITIONS(rootdv) == 0)
367 defdumpdv = NULL;
368 else
369 defdumpdv = rootdv;
370
371 ndumpdev = NODEV;
372 for (;;) {
373 printf("dump device");
374 if (defdumpdv != NULL) {
375 /*
376 * Note, we know it's a disk if we get here.
377 */
378 printf(" (default %sb)", device_xname(defdumpdv));
379 }
380 printf(": ");
381 len = cngetsn(buf, sizeof(buf));
382 if (len == 0) {
383 if (defdumpdv != NULL) {
384 ndumpdev = MAKEDISKDEV(major(nrootdev),
385 DISKUNIT(nrootdev), 1);
386 }
387 dumpdv = defdumpdv;
388 break;
389 }
390 if (len == 4 && strcmp(buf, "none") == 0) {
391 dumpdv = NULL;
392 break;
393 }
394 dv = getdisk(buf, len, 1, &ndumpdev, 1);
395 if (dv != NULL) {
396 dumpdv = dv;
397 break;
398 }
399 }
400 dumpdev = ndumpdev;
401
402 for (vops = LIST_FIRST(&vfs_list); vops != NULL;
403 vops = LIST_NEXT(vops, vfs_list)) {
404 if (vops->vfs_mountroot != NULL &&
405 strcmp(rootfstype, vops->vfs_name) == 0)
406 break;
407 }
408
409 if (vops == NULL) {
410 deffsname = "generic";
411 } else
412 deffsname = vops->vfs_name;
413
414 for (;;) {
415 printf("file system (default %s): ", deffsname);
416 len = cngetsn(buf, sizeof(buf));
417 if (len == 0) {
418 if (strcmp(deffsname, "generic") == 0)
419 rootfstype = ROOT_FSTYPE_ANY;
420 break;
421 }
422 if (len == 4 && strcmp(buf, "halt") == 0)
423 kern_reboot(RB_HALT, NULL);
424 else if (len == 6 && strcmp(buf, "reboot") == 0)
425 kern_reboot(0, NULL);
426 #if defined(DDB)
427 else if (len == 3 && strcmp(buf, "ddb") == 0) {
428 console_debugger();
429 }
430 #endif
431 else if (len == 7 && strcmp(buf, "generic") == 0) {
432 rootfstype = ROOT_FSTYPE_ANY;
433 break;
434 }
435 vops = vfs_getopsbyname(buf);
436 if (vops == NULL || vops->vfs_mountroot == NULL) {
437 printf("use one of: generic");
438 for (vops = LIST_FIRST(&vfs_list);
439 vops != NULL;
440 vops = LIST_NEXT(vops, vfs_list)) {
441 if (vops->vfs_mountroot != NULL)
442 printf(" %s", vops->vfs_name);
443 }
444 if (vops != NULL)
445 vfs_delref(vops);
446 #if defined(DDB)
447 printf(" ddb");
448 #endif
449 printf(" halt reboot\n");
450 } else {
451 /*
452 * XXX If *vops gets freed between here and
453 * the call to mountroot(), rootfstype will
454 * point to something unexpected. But in
455 * this case the system will fail anyway.
456 */
457 rootfstype = vops->vfs_name;
458 vfs_delref(vops);
459 break;
460 }
461 }
462
463 switch (device_class(rootdv)) {
464 case DV_IFNET:
465 case DV_DISK:
466 aprint_normal("root on %s", device_xname(rootdv));
467 if (DEV_USES_PARTITIONS(rootdv))
468 aprint_normal("%c", (int)DISKPART(rootdev) + 'a');
469 break;
470 default:
471 printf("can't determine root device\n");
472 return;
473 }
474
475 root_device = rootdv;
476 setroot_dump(rootdv, dumpdv);
477 }
478
479 /*
480 * configure
481 * device_t root_device
482 * dev_t rootdev (for disks)
483 *
484 */
485 static void
setroot_root(device_t bootdv,int bootpartition)486 setroot_root(device_t bootdv, int bootpartition)
487 {
488 device_t rootdv;
489 int majdev;
490 const char *rootdevname;
491 char buf[128];
492 dev_t nrootdev;
493
494 if (rootspec == NULL) {
495
496 /*
497 * Wildcarded root; use the boot device.
498 */
499 rootdv = bootdv;
500
501 if (bootdv)
502 majdev = devsw_name2blk(device_xname(bootdv), NULL, 0);
503 else
504 majdev = -1;
505 if (majdev >= 0) {
506 /*
507 * Root is on a disk. `bootpartition' is root,
508 * unless the device does not use partitions.
509 */
510 if (DEV_USES_PARTITIONS(bootdv))
511 rootdev = MAKEDISKDEV(majdev,
512 device_unit(bootdv),
513 bootpartition);
514 else
515 rootdev = makedev(majdev, device_unit(bootdv));
516 }
517 } else {
518
519 /*
520 * `root on <dev> ...'
521 */
522
523 /*
524 * If rootspec can be parsed, just use it.
525 */
526 rootdv = parsedisk(rootspec, strlen(rootspec), 0, &nrootdev);
527 if (rootdv != NULL) {
528 rootdev = nrootdev;
529 goto haveroot;
530 }
531
532 /*
533 * Fall back to rootdev, compute rootdv for it
534 */
535 rootdevname = devsw_blk2name(major(rootdev));
536 if (rootdevname == NULL) {
537 printf("unknown device major 0x%llx\n",
538 (unsigned long long)rootdev);
539 return;
540 }
541 memset(buf, 0, sizeof(buf));
542 snprintf(buf, sizeof(buf), "%s%llu", rootdevname,
543 (unsigned long long)DISKUNIT(rootdev));
544
545 rootdv = finddevice(buf);
546 if (rootdv == NULL) {
547 printf("device %s (0x%llx) not configured\n",
548 buf, (unsigned long long)rootdev);
549 return;
550 }
551 }
552
553 haveroot:
554 switch (device_class(rootdv)) {
555 case DV_IFNET:
556 case DV_DISK:
557 aprint_normal("root on %s", device_xname(rootdv));
558 if (DEV_USES_PARTITIONS(rootdv))
559 aprint_normal("%c", (int)DISKPART(rootdev) + 'a');
560 break;
561 default:
562 printf("can't determine root device\n");
563 return;
564 }
565
566 root_device = rootdv;
567 setroot_dump(rootdv, NULL);
568 }
569
570 /*
571 * configure
572 * dev_t dumpdev
573 * dev_t dumpcdev
574 *
575 * set to NODEV if device not found
576 */
577 static void
setroot_dump(device_t rootdv,device_t dumpdv)578 setroot_dump(device_t rootdv, device_t dumpdv)
579 {
580 device_t dv;
581 deviter_t di;
582 const char *dumpdevname;
583 int majdev;
584 char buf[128];
585
586 /*
587 * Now configure the dump device.
588 *
589 * If we haven't figured out the dump device, do so, with
590 * the following rules:
591 *
592 * (a) We already know dumpdv in the RB_ASKNAME case.
593 *
594 * (b) If dumpspec is set, try to use it. If the device
595 * is not available, punt.
596 *
597 * (c) If dumpspec is not set, the dump device is
598 * wildcarded or unspecified. If the root device
599 * is DV_IFNET, punt. Otherwise, use partition b
600 * of the root device.
601 */
602
603 if (boothowto & RB_ASKNAME) { /* (a) */
604 if (dumpdv == NULL)
605 goto nodumpdev;
606 } else if (dumpspec != NULL) { /* (b) */
607 if (strcmp(dumpspec, "none") == 0 || dumpdev == NODEV) {
608 /*
609 * Operator doesn't want a dump device.
610 * Or looks like they tried to pick a network
611 * device. Oops.
612 */
613 goto nodumpdev;
614 }
615
616 dumpdevname = devsw_blk2name(major(dumpdev));
617 if (dumpdevname == NULL)
618 goto nodumpdev;
619 memset(buf, 0, sizeof(buf));
620 snprintf(buf, sizeof(buf), "%s%llu", dumpdevname,
621 (unsigned long long)DISKUNIT(dumpdev));
622
623 dumpdv = finddevice(buf);
624 if (dumpdv == NULL) {
625 /*
626 * Device not configured.
627 */
628 goto nodumpdev;
629 }
630 } else { /* (c) */
631 if (DEV_USES_PARTITIONS(rootdv) == 0) {
632 for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST);
633 dv != NULL;
634 dv = deviter_next(&di))
635 if (isswap(dv))
636 break;
637 deviter_release(&di);
638 if (dv == NULL)
639 goto nodumpdev;
640
641 majdev = devsw_name2blk(device_xname(dv), NULL, 0);
642 if (majdev < 0)
643 goto nodumpdev;
644 dumpdv = dv;
645 dumpdev = makedev(majdev, device_unit(dumpdv));
646 } else {
647 dumpdv = rootdv;
648 dumpdev = MAKEDISKDEV(major(rootdev),
649 device_unit(dumpdv), 1);
650 }
651 }
652
653 dumpcdev = devsw_blk2chr(dumpdev);
654 aprint_normal(" dumps on %s", device_xname(dumpdv));
655 if (DEV_USES_PARTITIONS(dumpdv))
656 aprint_normal("%c", (int)DISKPART(dumpdev) + 'a');
657 aprint_normal("\n");
658 return;
659
660 nodumpdev:
661 dumpdev = NODEV;
662 dumpcdev = NODEV;
663 aprint_normal("\n");
664 }
665
666 static device_t
finddevice(const char * name)667 finddevice(const char *name)
668 {
669 const char *wname;
670
671 if ((wname = getwedgename(name, strlen(name))) != NULL)
672 return dkwedge_find_by_wname(wname);
673
674 return device_find_by_xname(name);
675 }
676
677 static device_t
getdisk(const char * str,int len,int defpart,dev_t * devp,int isdump)678 getdisk(const char *str, int len, int defpart, dev_t *devp, int isdump)
679 {
680 device_t dv;
681 deviter_t di;
682
683 if (len == 4 && strcmp(str, "halt") == 0)
684 kern_reboot(RB_HALT, NULL);
685 else if (len == 6 && strcmp(str, "reboot") == 0)
686 kern_reboot(0, NULL);
687 #if defined(DDB)
688 else if (len == 3 && strcmp(str, "ddb") == 0) {
689 console_debugger();
690 return NULL;
691 }
692 #endif
693
694 if ((dv = parsedisk(str, len, defpart, devp)) == NULL) {
695 printf("use one of:");
696 for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST); dv != NULL;
697 dv = deviter_next(&di)) {
698 if (DEV_USES_PARTITIONS(dv))
699 printf(" %s[a-%c]", device_xname(dv),
700 'a' + MAXPARTITIONS - 1);
701 else if (device_class(dv) == DV_DISK)
702 printf(" %s", device_xname(dv));
703 if (isdump == 0 && device_class(dv) == DV_IFNET)
704 printf(" %s", device_xname(dv));
705 }
706 deviter_release(&di);
707 dkwedge_print_wnames();
708 if (isdump)
709 printf(" none");
710 #if defined(DDB)
711 printf(" ddb");
712 #endif
713 printf(" halt reboot\n");
714 }
715 return dv;
716 }
717
718 static const char *
getwedgename(const char * name,int namelen)719 getwedgename(const char *name, int namelen)
720 {
721 const char *wpfx1 = "wedge:";
722 const char *wpfx2 = "NAME=";
723 const int wpfx1len = strlen(wpfx1);
724 const int wpfx2len = strlen(wpfx2);
725
726 if (namelen > wpfx1len && strncmp(name, wpfx1, wpfx1len) == 0)
727 return name + wpfx1len;
728
729 if (namelen > wpfx2len && strncasecmp(name, wpfx2, wpfx2len) == 0)
730 return name + wpfx2len;
731
732 return NULL;
733 }
734
735 static device_t
parsedisk(const char * str,int len,int defpart,dev_t * devp)736 parsedisk(const char *str, int len, int defpart, dev_t *devp)
737 {
738 device_t dv;
739 const char *wname;
740 char c;
741 int majdev, part;
742 char xname[16]; /* same size as dv_xname */
743
744 if (len == 0)
745 return (NULL);
746
747 if ((wname = getwedgename(str, len)) != NULL) {
748 if ((dv = dkwedge_find_by_wname(wname)) == NULL)
749 return NULL;
750 part = defpart;
751 goto gotdisk;
752 }
753
754 c = str[len-1];
755 if (c >= 'a' && c <= ('a' + MAXPARTITIONS - 1)) {
756 part = c - 'a';
757 len--;
758 if (len > sizeof(xname)-1)
759 return NULL;
760 memcpy(xname, str, len);
761 xname[len] = '\0';
762 str = xname;
763 } else
764 part = defpart;
765
766 dv = finddevice(str);
767 if (dv != NULL) {
768 if (device_class(dv) == DV_DISK) {
769 gotdisk:
770 majdev = devsw_name2blk(device_xname(dv), NULL, 0);
771 if (majdev < 0)
772 panic("parsedisk");
773 if (DEV_USES_PARTITIONS(dv))
774 *devp = MAKEDISKDEV(majdev, device_unit(dv),
775 part);
776 else
777 *devp = makedev(majdev, device_unit(dv));
778 }
779
780 if (device_class(dv) == DV_IFNET)
781 *devp = NODEV;
782 }
783
784 return (dv);
785 }
786