1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1982, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /*
26 * Configure root, swap and dump devices.
27 */
28
29 #include <sys/types.h>
30 #include <sys/param.h>
31 #include <sys/sysmacros.h>
32 #include <sys/signal.h>
33 #include <sys/cred.h>
34 #include <sys/proc.h>
35 #include <sys/user.h>
36 #include <sys/conf.h>
37 #include <sys/buf.h>
38 #include <sys/systm.h>
39 #include <sys/vm.h>
40 #include <sys/reboot.h>
41 #include <sys/file.h>
42 #include <sys/vfs.h>
43 #include <sys/vnode.h>
44 #include <sys/errno.h>
45 #include <sys/kmem.h>
46 #include <sys/uio.h>
47 #include <sys/open.h>
48 #include <sys/mount.h>
49 #include <sys/kobj.h>
50 #include <sys/bootconf.h>
51 #include <sys/sysconf.h>
52 #include <sys/modctl.h>
53 #include <sys/autoconf.h>
54 #include <sys/debug.h>
55 #include <sys/fs/snode.h>
56 #include <fs/fs_subr.h>
57 #include <sys/socket.h>
58 #include <net/if.h>
59
60 #include <sys/mkdev.h>
61 #include <sys/cmn_err.h>
62 #include <sys/console.h>
63
64 #include <sys/conf.h>
65 #include <sys/ddi.h>
66 #include <sys/sunddi.h>
67 #include <sys/hwconf.h>
68 #include <sys/dc_ki.h>
69 #include <sys/promif.h>
70 #include <sys/bootprops.h>
71
72 /*
73 * Local routines
74 */
75 static int preload_module(struct sysparam *, void *);
76 static struct vfssw *getfstype(char *, char *, size_t);
77 static int getphysdev(char *, char *, size_t);
78 static int load_bootpath_drivers(char *bootpath);
79 static int load_boot_driver(char *drv);
80 static int load_boot_platform_modules(char *drv);
81 static dev_info_t *path_to_devinfo(char *path);
82 static boolean_t netboot_over_ib(char *bootpath);
83 static boolean_t netboot_over_iscsi(void);
84
85 /*
86 * Module linkage information for the kernel.
87 */
88 static struct modlmisc modlmisc = {
89 &mod_miscops, "root and swap configuration"
90 };
91
92 static struct modlinkage modlinkage = {
93 MODREV_1, (void *)&modlmisc, NULL
94 };
95
96 int
97 _init(void)
98 {
99 return (mod_install(&modlinkage));
100 }
101
102 int
103 _fini(void)
104 {
105 return (mod_remove(&modlinkage));
106 }
107
108 int
109 _info(struct modinfo *modinfop)
110 {
111 return (mod_info(&modlinkage, modinfop));
112 }
113
114 extern ib_boot_prop_t *iscsiboot_prop;
115 /*
116 * Configure root file system.
117 */
118 int
119 rootconf(void)
120 {
121 int error;
122 struct vfssw *vsw;
123 extern void pm_init(void);
124 int ret = -1;
125 BMDPRINTF(("rootconf: fstype %s\n", rootfs.bo_fstype));
126 BMDPRINTF(("rootconf: name %s\n", rootfs.bo_name));
127 BMDPRINTF(("rootconf: flags 0x%x\n", rootfs.bo_flags));
128 BMDPRINTF(("rootconf: obp_bootpath %s\n", obp_bootpath));
129
130 /*
131 * Install cluster modules that were only loaded during
132 * loadrootmodules().
133 */
134 if (error = clboot_rootconf())
135 return (error);
136
137 if (root_is_svm) {
138 (void) strncpy(rootfs.bo_name, obp_bootpath, BO_MAXOBJNAME);
139
140 BMDPRINTF(("rootconf: svm: rootfs name %s\n", rootfs.bo_name));
141 BMDPRINTF(("rootconf: svm: svm name %s\n", svm_bootpath));
142 }
143
144 /*
145 * Run _init on the root filesystem (we already loaded it
146 * but we've been waiting until now to _init it) which will
147 * have the side-effect of running vsw_init() on this vfs.
148 * Because all the nfs filesystems are lumped into one
149 * module we need to special case it.
150 */
151 if (strncmp(rootfs.bo_fstype, "nfs", 3) == 0) {
152 if (modload("fs", "nfs") == -1) {
153 cmn_err(CE_CONT, "Cannot initialize %s filesystem\n",
154 rootfs.bo_fstype);
155 return (ENXIO);
156 }
157 } else {
158 if (modload("fs", rootfs.bo_fstype) == -1) {
159 cmn_err(CE_CONT, "Cannot initialize %s filesystem\n",
160 rootfs.bo_fstype);
161 return (ENXIO);
162 }
163 }
164 RLOCK_VFSSW();
165 vsw = vfs_getvfsswbyname(rootfs.bo_fstype);
166 RUNLOCK_VFSSW();
167 if (vsw == NULL) {
168 cmn_err(CE_CONT, "Cannot find %s filesystem\n",
169 rootfs.bo_fstype);
170 return (ENXIO);
171 }
172 VFS_INIT(rootvfs, &vsw->vsw_vfsops, (caddr_t)0);
173 VFS_HOLD(rootvfs);
174
175 if (root_is_svm) {
176 rootvfs->vfs_flag |= VFS_RDONLY;
177 }
178
179 /*
180 * This pm-releated call has to occur before root is mounted since we
181 * need to power up all devices. It is placed after VFS_INIT() such
182 * that opening a device via ddi_lyr_ interface just before root has
183 * been mounted would work.
184 */
185 pm_init();
186
187 if (netboot && iscsiboot_prop) {
188 cmn_err(CE_WARN, "NFS boot and iSCSI boot"
189 " shouldn't happen in the same time");
190 return (EINVAL);
191 }
192
193 if (netboot || iscsiboot_prop) {
194 ret = strplumb();
195 if (ret != 0) {
196 cmn_err(CE_WARN, "Cannot plumb network device %d", ret);
197 return (EFAULT);
198 }
199 }
200
201 if ((ret == 0) && iscsiboot_prop) {
202 ret = modload("drv", "iscsi");
203 /* -1 indicates fail */
204 if (ret == -1) {
205 cmn_err(CE_WARN, "Failed to load iscsi module");
206 iscsi_boot_prop_free();
207 return (EINVAL);
208 } else {
209 if (!i_ddi_attach_pseudo_node("iscsi")) {
210 cmn_err(CE_WARN,
211 "Failed to attach iscsi driver");
212 iscsi_boot_prop_free();
213 return (ENODEV);
214 }
215 }
216 }
217
218 /*
219 * ufs_mountroot() ends up calling getrootdev()
220 * (below) which actually triggers the _init, identify,
221 * probe and attach of the drivers that make up root device
222 * bush; these are also quietly waiting in memory.
223 */
224 BMDPRINTF(("rootconf: calling VFS_MOUNTROOT %s\n", rootfs.bo_fstype));
225
226 error = VFS_MOUNTROOT(rootvfs, ROOT_INIT);
227 vfs_unrefvfssw(vsw);
228 rootdev = rootvfs->vfs_dev;
229
230 if (error)
231 cmn_err(CE_CONT, "Cannot mount root on %s fstype %s\n",
232 rootfs.bo_name, rootfs.bo_fstype);
233 else
234 cmn_err(CE_CONT, "?root on %s fstype %s\n",
235 rootfs.bo_name, rootfs.bo_fstype);
236 return (error);
237 }
238
239 /*
240 * Remount root on an SVM mirror root device
241 * Only supported on UFS filesystems at present
242 */
243 int
244 svm_rootconf(void)
245 {
246 int error;
247 extern int ufs_remountroot(struct vfs *vfsp);
248
249 ASSERT(root_is_svm == 1);
250
251 if (strcmp(rootfs.bo_fstype, "ufs") != 0) {
252 cmn_err(CE_CONT, "Mounting root on %s with filesystem "
253 "type %s is not supported\n",
254 rootfs.bo_name, rootfs.bo_fstype);
255 return (EINVAL);
256 }
257
258 (void) strncpy(rootfs.bo_name, svm_bootpath, BO_MAXOBJNAME);
259
260 BMDPRINTF(("svm_rootconf: rootfs %s\n", rootfs.bo_name));
261
262 error = ufs_remountroot(rootvfs);
263
264 if (error) {
265 cmn_err(CE_CONT, "Cannot remount root on %s fstype %s\n",
266 rootfs.bo_name, rootfs.bo_fstype);
267 } else {
268 cmn_err(CE_CONT, "?root remounted on %s fstype %s\n",
269 rootfs.bo_name, rootfs.bo_fstype);
270 }
271 return (error);
272 }
273
274 /*
275 * Under the assumption that our root file system is on a
276 * disk partition, get the dev_t of the partition in question.
277 *
278 * By now, boot has faithfully loaded all our modules into memory, and
279 * we've taken over resource management. Before we go any further, we
280 * have to fire up the device drivers and stuff we need to mount the
281 * root filesystem. That's what we do here. Fingers crossed.
282 */
283 dev_t
284 getrootdev(void)
285 {
286 dev_t d;
287
288 d = ddi_pathname_to_dev_t(rootfs.bo_name);
289 if ((d == NODEV) && (iscsiboot_prop != NULL)) {
290 /* Give it another try with the 'disk' path */
291 get_iscsi_bootpath_phy(rootfs.bo_name);
292 d = ddi_pathname_to_dev_t(rootfs.bo_name);
293 }
294 if (d == NODEV)
295 cmn_err(CE_CONT, "Cannot assemble drivers for root %s\n",
296 rootfs.bo_name);
297 return (d);
298 }
299
300 /*
301 * If booted with ASKNAME, prompt on the console for a filesystem
302 * name and return it.
303 */
304 void
305 getfsname(char *askfor, char *name, size_t namelen)
306 {
307 if (boothowto & RB_ASKNAME) {
308 printf("%s name: ", askfor);
309 console_gets(name, namelen);
310 }
311 }
312
313 /*ARGSUSED1*/
314 static int
315 preload_module(struct sysparam *sysp, void *p)
316 {
317 static char *wmesg = "forceload of %s failed";
318 char *name;
319
320 name = sysp->sys_ptr;
321 BMDPRINTF(("preload_module: %s\n", name));
322 if (modloadonly(NULL, name) < 0)
323 cmn_err(CE_WARN, wmesg, name);
324 return (0);
325 }
326
327 /*
328 * We want to load all the modules needed to mount the root filesystem,
329 * so that when we start the ball rolling in 'getrootdev', every module
330 * should already be in memory, just waiting to be init-ed.
331 */
332
333 int
334 loadrootmodules(void)
335 {
336 struct vfssw *vsw;
337 char *this;
338 char *name;
339 int err;
340 int i, proplen;
341 extern char *impl_module_list[];
342 extern char *platform_module_list[];
343
344 /* Make sure that the PROM's devinfo tree has been created */
345 ASSERT(ddi_root_node());
346
347 BMDPRINTF(("loadrootmodules: fstype %s\n", rootfs.bo_fstype));
348 BMDPRINTF(("loadrootmodules: name %s\n", rootfs.bo_name));
349 BMDPRINTF(("loadrootmodules: flags 0x%x\n", rootfs.bo_flags));
350
351 /*
352 * zzz We need to honor what's in rootfs if it's not null.
353 * non-null means use what's there. This way we can
354 * change rootfs with /etc/system AND with tunetool.
355 */
356 if (root_is_svm) {
357 /* user replaced rootdev, record obp_bootpath */
358 obp_bootpath[0] = '\0';
359 (void) getphysdev("root", obp_bootpath, BO_MAXOBJNAME);
360 BMDPRINTF(("loadrootmodules: obp_bootpath %s\n", obp_bootpath));
361 } else {
362 /*
363 * Get the root fstype and root device path from boot.
364 */
365 rootfs.bo_fstype[0] = '\0';
366 rootfs.bo_name[0] = '\0';
367 }
368
369 /*
370 * This lookup will result in modloadonly-ing the root
371 * filesystem module - it gets _init-ed in rootconf()
372 */
373 if ((vsw = getfstype("root", rootfs.bo_fstype, BO_MAXFSNAME)) == NULL)
374 return (ENXIO); /* in case we have no file system types */
375
376 (void) strcpy(rootfs.bo_fstype, vsw->vsw_name);
377
378 vfs_unrefvfssw(vsw);
379
380 /*
381 * Load the favored drivers of the implementation.
382 * e.g. 'sbus' and possibly 'zs' (even).
383 *
384 * Called whilst boot is still loaded (because boot does
385 * the i/o for us), and DDI services are unavailable.
386 */
387 BMDPRINTF(("loadrootmodules: impl_module_list\n"));
388 for (i = 0; (this = impl_module_list[i]) != NULL; i++) {
389 if ((err = load_boot_driver(this)) != 0) {
390 cmn_err(CE_WARN, "Cannot load drv/%s", this);
391 return (err);
392 }
393 }
394 /*
395 * Now load the platform modules (if any)
396 */
397 BMDPRINTF(("loadrootmodules: platform_module_list\n"));
398 for (i = 0; (this = platform_module_list[i]) != NULL; i++) {
399 if ((err = load_boot_platform_modules(this)) != 0) {
400 cmn_err(CE_WARN, "Cannot load drv/%s", this);
401 return (err);
402 }
403 }
404
405 loop:
406 (void) getphysdev("root", rootfs.bo_name, BO_MAXOBJNAME);
407 /*
408 * Given a physical pathname, load the correct set of driver
409 * modules into memory, including all possible parents.
410 *
411 * NB: The code sets the variable 'name' for error reporting.
412 */
413 err = 0;
414 BMDPRINTF(("loadrootmodules: rootfs %s\n", rootfs.bo_name));
415 if (root_is_svm == 0) {
416 BMDPRINTF(("loadrootmodules: rootfs %s\n", rootfs.bo_name));
417 name = rootfs.bo_name;
418 err = load_bootpath_drivers(rootfs.bo_name);
419 }
420
421 /*
422 * Load driver modules in obp_bootpath, this is always
423 * required for mountroot to succeed. obp_bootpath is
424 * is set if rootdev is set via /etc/system, which is
425 * the case if booting of a SVM/VxVM mirror.
426 */
427 if ((err == 0) && obp_bootpath[0] != '\0') {
428 BMDPRINTF(("loadrootmodules: obp_bootpath %s\n", obp_bootpath));
429 name = obp_bootpath;
430 err = load_bootpath_drivers(obp_bootpath);
431 }
432
433 if (err != 0) {
434 cmn_err(CE_CONT, "Cannot load drivers for %s\n", name);
435 goto out;
436 }
437
438 /*
439 * Check to see if the booter performed DHCP configuration
440 * ("bootp-response" boot property exists). If so, then before
441 * bootops disappears we need to save the value of this property
442 * such that the userland dhcpagent can adopt the DHCP management
443 * of our primary network interface.
444 */
445 proplen = BOP_GETPROPLEN(bootops, "bootp-response");
446 if (proplen > 0) {
447 dhcack = kmem_zalloc(proplen, KM_SLEEP);
448 if (BOP_GETPROP(bootops, "bootp-response", dhcack) == -1) {
449 cmn_err(CE_WARN, "BOP_GETPROP of "
450 "\"bootp-response\" failed\n");
451 kmem_free(dhcack, dhcacklen);
452 dhcack = NULL;
453 goto out;
454 }
455 dhcacklen = proplen;
456
457 /*
458 * Fetch the "netdev-path" boot property (if it exists), and
459 * stash it for later use by sysinfo(SI_DHCP_CACHE, ...).
460 */
461 proplen = BOP_GETPROPLEN(bootops, "netdev-path");
462 if (proplen > 0) {
463 netdev_path = kmem_zalloc(proplen, KM_SLEEP);
464 if (BOP_GETPROP(bootops, "netdev-path",
465 (uchar_t *)netdev_path) == -1) {
466 cmn_err(CE_WARN, "BOP_GETPROP of "
467 "\"netdev-path\" failed\n");
468 kmem_free(netdev_path, proplen);
469 goto out;
470 }
471 }
472 }
473
474 /*
475 * Preload (load-only, no init) all modules which
476 * were added to the /etc/system file with the
477 * FORCELOAD keyword.
478 */
479 BMDPRINTF(("loadrootmodules: preload_module\n"));
480 (void) mod_sysctl_type(MOD_FORCELOAD, preload_module, NULL);
481
482 /*
483 * If we booted otw then load in the plumbing
484 * routine now while we still can. If we didn't
485 * boot otw then we will load strplumb in main().
486 *
487 * NFS is actually a set of modules, the core routines,
488 * a diskless helper module, rpcmod, and the tli interface. Load
489 * them now while we still can.
490 *
491 * Because we glomb all versions of nfs into a single module
492 * we check based on the initial string "nfs".
493 *
494 * XXX: A better test for this is to see if device_type
495 * XXX: from the PROM is "network".
496 */
497
498 if (strncmp(rootfs.bo_fstype, "nfs", 3) == 0) {
499 ++netboot;
500
501 /*
502 * Preload (load-only, no init) the dacf module. We cannot
503 * init the module because one of its requisite modules is
504 * dld whose _init function will call taskq_create(), which
505 * will panic the system at this point.
506 */
507 if ((err = modloadonly("dacf", "net_dacf")) < 0) {
508 cmn_err(CE_CONT, "Cannot load dacf/net_dacf\n");
509 goto out;
510 }
511 if ((err = modload("misc", "tlimod")) < 0) {
512 cmn_err(CE_CONT, "Cannot load misc/tlimod\n");
513 goto out;
514 }
515 if ((err = modload("strmod", "rpcmod")) < 0) {
516 cmn_err(CE_CONT, "Cannot load strmod/rpcmod\n");
517 goto out;
518 }
519 if ((err = modload("misc", "nfs_dlboot")) < 0) {
520 cmn_err(CE_CONT, "Cannot load misc/nfs_dlboot\n");
521 goto out;
522 }
523 if ((err = modload("mac", "mac_ether")) < 0) {
524 cmn_err(CE_CONT, "Cannot load mac/mac_ether\n");
525 goto out;
526 }
527 if ((err = modload("misc", "strplumb")) < 0) {
528 cmn_err(CE_CONT, "Cannot load misc/strplumb\n");
529 goto out;
530 }
531 if ((err = strplumb_load()) < 0) {
532 goto out;
533 }
534 }
535 if (netboot_over_iscsi() == B_TRUE) {
536 /* iscsi boot */
537 if ((err = modloadonly("dacf", "net_dacf")) < 0) {
538 cmn_err(CE_CONT, "Cannot load dacf/net_dacf\n");
539 goto out;
540 }
541 if ((err = modload("misc", "tlimod")) < 0) {
542 cmn_err(CE_CONT, "Cannot load misc/tlimod\n");
543 goto out;
544 }
545 if ((err = modload("mac", "mac_ether")) < 0) {
546 cmn_err(CE_CONT, "Cannot load mac/mac_ether\n");
547 goto out;
548 }
549 if ((err = modloadonly("drv", "iscsi")) < 0) {
550 cmn_err(CE_CONT, "Cannot load drv/iscsi\n");
551 goto out;
552 }
553 if ((err = modloadonly("drv", "ssd")) < 0) {
554 cmn_err(CE_CONT, "Cannot load drv/ssd\n");
555 goto out;
556 }
557 if ((err = modloadonly("drv", "sd")) < 0) {
558 cmn_err(CE_CONT, "Cannot load drv/sd\n");
559 goto out;
560 }
561 if ((err = modload("misc", "strplumb")) < 0) {
562 cmn_err(CE_CONT, "Cannot load misc/strplumb\n");
563 goto out;
564 }
565 if ((err = strplumb_load()) < 0) {
566 goto out;
567 }
568 }
569 /*
570 * Preload modules needed for booting as a cluster.
571 */
572 err = clboot_loadrootmodules();
573
574 out:
575 if (err != 0 && (boothowto & RB_ASKNAME))
576 goto loop;
577
578 return (err);
579 }
580
581 static int
582 get_bootpath_prop(char *bootpath)
583 {
584 if (root_is_ramdisk) {
585 if (BOP_GETPROP(bootops, "bootarchive", bootpath) == -1)
586 return (-1);
587 (void) strlcat(bootpath, ":a", BO_MAXOBJNAME);
588 } else {
589 /*
590 * Look for the 1275 compliant name 'bootpath' first,
591 * but make certain it has a non-NULL value as well.
592 */
593 if ((BOP_GETPROP(bootops, "bootpath", bootpath) == -1) ||
594 strlen(bootpath) == 0) {
595 if (BOP_GETPROP(bootops,
596 "boot-path", bootpath) == -1)
597 return (-1);
598 }
599 if (memcmp(bootpath, BP_ISCSI_DISK,
600 strlen(BP_ISCSI_DISK)) == 0) {
601 /* iscsi boot */
602 get_iscsi_bootpath_vhci(bootpath);
603 }
604 }
605 return (0);
606 }
607
608 static int
609 get_fstype_prop(char *fstype)
610 {
611 char *prop = (root_is_ramdisk) ? "archive-fstype" : "fstype";
612
613 return (BOP_GETPROP(bootops, prop, fstype));
614 }
615
616 /*
617 * Get the name of the root or swap filesystem type, and return
618 * the corresponding entry in the vfs switch.
619 *
620 * If we're not asking the user, and we're trying to find the
621 * root filesystem type, we ask boot for the filesystem
622 * type that it came from and use that. Similarly, if we're
623 * trying to find the swap filesystem, we try and derive it from
624 * the root filesystem type.
625 *
626 * If we are booting via NFS we currently have these options:
627 * nfs - dynamically choose NFS V2. V3, or V4 (default)
628 * nfs2 - force NFS V2
629 * nfs3 - force NFS V3
630 * nfs4 - force NFS V4
631 * Because we need to maintain backward compatibility with the naming
632 * convention that the NFS V2 filesystem name is "nfs" (see vfs_conf.c)
633 * we need to map "nfs" => "nfsdyn" and "nfs2" => "nfs". The dynamic
634 * nfs module will map the type back to either "nfs", "nfs3", or "nfs4".
635 * This is only for root filesystems, all other uses such as cachefs
636 * will expect that "nfs" == NFS V2.
637 *
638 * If the filesystem isn't already loaded, vfs_getvfssw() will load
639 * it for us, but if (at the time we call it) modrootloaded is
640 * still not set, it won't run the filesystems _init routine (and
641 * implicitly it won't run the filesystems vsw_init() entry either).
642 * We do that explicitly in rootconf().
643 */
644 static struct vfssw *
645 getfstype(char *askfor, char *fsname, size_t fsnamelen)
646 {
647 struct vfssw *vsw;
648 static char defaultfs[BO_MAXFSNAME];
649 int root = 0;
650
651 if (strcmp(askfor, "root") == 0) {
652 (void) get_fstype_prop(defaultfs);
653 root++;
654 } else {
655 (void) strcpy(defaultfs, "swapfs");
656 }
657
658 if (boothowto & RB_ASKNAME) {
659 for (*fsname = '\0'; *fsname == '\0'; *fsname = '\0') {
660 printf("%s filesystem type [%s]: ", askfor, defaultfs);
661 console_gets(fsname, fsnamelen);
662 if (*fsname == '\0')
663 (void) strcpy(fsname, defaultfs);
664 if (root) {
665 if (strcmp(fsname, "nfs2") == 0)
666 (void) strcpy(fsname, "nfs");
667 else if (strcmp(fsname, "nfs") == 0)
668 (void) strcpy(fsname, "nfsdyn");
669 }
670 if ((vsw = vfs_getvfssw(fsname)) != NULL)
671 return (vsw);
672 printf("Unknown filesystem type '%s'\n", fsname);
673 }
674 } else if (*fsname == '\0') {
675 fsname = defaultfs;
676 }
677 if (*fsname == '\0') {
678 return (NULL);
679 }
680
681 if (root) {
682 if (strcmp(fsname, "nfs2") == 0)
683 (void) strcpy(fsname, "nfs");
684 else if (strcmp(fsname, "nfs") == 0)
685 (void) strcpy(fsname, "nfsdyn");
686 }
687
688 return (vfs_getvfssw(fsname));
689 }
690
691
692 /*
693 * Get a physical device name, and maybe load and attach
694 * the driver.
695 *
696 * XXX Need better checking of whether or not a device
697 * actually exists if the user typed in a pathname.
698 *
699 * XXX Are we sure we want to expose users to this sort
700 * of physical namespace gobbledygook (now there's
701 * a word to conjure with..)
702 *
703 * XXX Note that on an OBP machine, we can easily ask the
704 * prom and pretty-print some plausible set of bootable
705 * devices. We can also user the prom to verify any
706 * such device. Later tim.. later.
707 */
708 static int
709 getphysdev(char *askfor, char *name, size_t namelen)
710 {
711 static char fmt[] = "Enter physical name of %s device\n[%s]: ";
712 dev_t dev;
713 static char defaultpath[BO_MAXOBJNAME];
714
715 /*
716 * Establish 'default' values - we get the root device from
717 * boot, and we infer the swap device is the same but with
718 * a 'b' on the end instead of an 'a'. A first stab at
719 * ease-of-use ..
720 */
721 if (strcmp(askfor, "root") == 0) {
722 if (get_bootpath_prop(defaultpath) == -1)
723 boothowto |= RB_ASKNAME | RB_VERBOSE;
724 } else {
725 (void) strcpy(defaultpath, rootfs.bo_name);
726 defaultpath[strlen(defaultpath) - 1] = 'b';
727 }
728
729 retry:
730 if (boothowto & RB_ASKNAME) {
731 printf(fmt, askfor, defaultpath);
732 console_gets(name, namelen);
733 }
734 if (*name == '\0')
735 (void) strcpy(name, defaultpath);
736
737 if (strcmp(askfor, "swap") == 0) {
738
739 /*
740 * Try to load and install the swap device driver.
741 */
742 dev = ddi_pathname_to_dev_t(name);
743
744 if (dev == (dev_t)-1) {
745 printf("Not a supported device for swap.\n");
746 boothowto |= RB_ASKNAME | RB_VERBOSE;
747 goto retry;
748 }
749
750 /*
751 * Ensure that we're not trying to swap on the floppy.
752 */
753 if (strncmp(ddi_major_to_name(getmajor(dev)), "fd", 2) == 0) {
754 printf("Too dangerous to swap on the floppy\n");
755 if (boothowto & RB_ASKNAME)
756 goto retry;
757 return (-1);
758 }
759 }
760
761 return (0);
762 }
763
764
765 /*
766 * Load a driver needed to boot.
767 */
768 static int
769 load_boot_driver(char *drv)
770 {
771 char *drvname;
772 major_t major;
773 #ifdef sparc
774 struct devnames *dnp;
775 ddi_prop_t *propp;
776 char *module;
777 char *dir, *mf;
778 int plen;
779 int mlen;
780 #endif /* sparc */
781
782 if ((major = ddi_name_to_major(drv)) == DDI_MAJOR_T_NONE) {
783 cmn_err(CE_CONT, "%s: no major number\n", drv);
784 return (-1);
785 }
786 /*
787 * resolve aliases
788 */
789 drvname = ddi_major_to_name(major);
790
791 #ifdef DEBUG
792 if (strcmp(drv, drvname) == 0) {
793 BMDPRINTF(("load_boot_driver: %s\n", drv));
794 } else {
795 BMDPRINTF(("load_boot_driver: %s -> %s\n", drv, drvname));
796 }
797 #endif /* DEBUG */
798
799 if (modloadonly("drv", drvname) == -1) {
800 cmn_err(CE_CONT, "%s: cannot load driver\n", drvname);
801 return (-1);
802 }
803
804 #ifdef sparc
805 /*
806 * NOTE: this can be removed when newboot-sparc is delivered.
807 *
808 * Check to see if the driver had a 'ddi-forceload' global driver.conf
809 * property to identify additional modules that need to be loaded.
810 * The driver still needs to use ddi_modopen() to open these modules,
811 * but the 'ddi-forceload' property allows the modules to be loaded
812 * into memory prior to lights-out, so that driver ddi_modopen()
813 * calls during lights-out (when mounting root) will work correctly.
814 * Use of 'ddi-forceload' is only required for drivers involved in
815 * getting root mounted.
816 */
817 dnp = &devnamesp[major];
818 if (dnp->dn_global_prop_ptr && dnp->dn_global_prop_ptr->prop_list &&
819 ((propp = i_ddi_prop_search(DDI_DEV_T_ANY,
820 "ddi-forceload", DDI_PROP_TYPE_STRING,
821 &dnp->dn_global_prop_ptr->prop_list)) != NULL)) {
822
823 module = (char *)propp->prop_val;
824 plen = propp->prop_len;
825 while (plen > 0) {
826 mlen = strlen(module);
827 mf = strrchr(module, '/');
828 if (mf) {
829 dir = module;
830 *mf++ = '\0'; /* '/' -> '\0' */
831 } else {
832 dir = "misc";
833 mf = module;
834 }
835 if (modloadonly(dir, mf) == -1)
836 cmn_err(CE_CONT,
837 "misc/%s: can't load module\n", mf);
838 if (mf != module)
839 *(mf - 1) = '/'; /* '\0' -> '/' */
840
841 module += mlen + 1;
842 plen -= mlen + 1;
843 }
844 }
845 #endif /* sparc */
846
847 return (0);
848 }
849
850
851 /*
852 * For a given instance, load that driver and its parents
853 */
854 static int
855 load_parent_drivers(dev_info_t *dip, char *path)
856 {
857 int rval = 0;
858 major_t major = DDI_MAJOR_T_NONE;
859 char *drv;
860 char *p;
861
862 while (dip) {
863 /* check for path-oriented alias */
864 if (path)
865 major = ddi_name_to_major(path);
866 else
867 major = DDI_MAJOR_T_NONE;
868
869 if (major != DDI_MAJOR_T_NONE)
870 drv = ddi_major_to_name(major);
871 else
872 drv = ddi_binding_name(dip);
873
874 if (load_boot_driver(drv) != 0)
875 rval = -1;
876
877 dip = ddi_get_parent(dip);
878 if (path) {
879 p = strrchr(path, '/');
880 if (p)
881 *p = 0;
882 }
883 }
884
885 return (rval);
886 }
887
888
889 /*
890 * For a given path to a boot device,
891 * load that driver and all its parents.
892 */
893 static int
894 load_bootpath_drivers(char *bootpath)
895 {
896 dev_info_t *dip;
897 char *pathcopy;
898 int pathcopy_len;
899 int rval;
900 char *p;
901 int proplen;
902 char iscsi_network_path[BO_MAXOBJNAME];
903
904 if (bootpath == NULL || *bootpath == 0)
905 return (-1);
906
907 BMDPRINTF(("load_bootpath_drivers: %s\n", bootpath));
908 #ifdef _OBP
909 if (netboot_over_iscsi()) {
910 /* iscsi boot */
911 if (root_is_ramdisk) {
912 if (modloadonly("drv", "ramdisk") < 0)
913 return (-1);
914 }
915 proplen = BOP_GETPROPLEN(bootops, BP_ISCSI_NETWORK_BOOTPATH);
916 if (proplen > 0) {
917 if (BOP_GETPROP(bootops, BP_ISCSI_NETWORK_BOOTPATH,
918 iscsi_network_path) > 0) {
919 p = strchr(iscsi_network_path, ':');
920 if (p != NULL) {
921 *p = '\0';
922 }
923 pathcopy = i_ddi_strdup(iscsi_network_path,
924 KM_SLEEP);
925 pathcopy_len = strlen(pathcopy) + 1;
926 } else {
927 return (-1);
928 }
929 } else {
930 return (-1);
931 }
932 } else {
933 #endif
934 pathcopy = i_ddi_strdup(bootpath, KM_SLEEP);
935 pathcopy_len = strlen(pathcopy) + 1;
936 #ifdef _OBP
937 }
938 #endif
939 dip = path_to_devinfo(pathcopy);
940
941 #if defined(__i386) || defined(__amd64)
942 /*
943 * i386 does not provide stub nodes for all boot devices,
944 * but we should be able to find the node for the parent,
945 * and the leaf of the boot path should be the driver name,
946 * which we go ahead and load here.
947 */
948 if (dip == NULL) {
949 char *leaf;
950
951 /*
952 * Find last slash to build the full path to the
953 * parent of the leaf boot device
954 */
955 p = strrchr(pathcopy, '/');
956 *p++ = 0;
957
958 /*
959 * Now isolate the driver name of the leaf device
960 */
961 leaf = p;
962 p = strchr(leaf, '@');
963 *p = 0;
964
965 BMDPRINTF(("load_bootpath_drivers: parent=%s leaf=%s\n",
966 bootpath, leaf));
967
968 dip = path_to_devinfo(pathcopy);
969 if (leaf) {
970 rval = load_boot_driver(leaf, NULL);
971 if (rval == -1) {
972 kmem_free(pathcopy, pathcopy_len);
973 return (NULL);
974 }
975 }
976 }
977 #endif
978
979 if (dip == NULL) {
980 cmn_err(CE_WARN, "can't bind driver for boot path <%s>",
981 bootpath);
982 kmem_free(pathcopy, pathcopy_len);
983 return (NULL);
984 }
985
986 /*
987 * Load IP over IB driver when netbooting over IB.
988 * As per IB 1275 binding, IP over IB is represented as
989 * service on the top of the HCA node. So, there is no
990 * PROM node and generic framework cannot pre-load
991 * IP over IB driver based on the bootpath. The following
992 * code preloads IP over IB driver when doing netboot over
993 * InfiniBand.
994 */
995 if (netboot_over_ib(bootpath) &&
996 modloadonly("drv", "ibp") == -1) {
997 cmn_err(CE_CONT, "ibp: cannot load platform driver\n");
998 kmem_free(pathcopy, pathcopy_len);
999 return (NULL);
1000 }
1001
1002 /*
1003 * The PROM node for hubs have incomplete compatible
1004 * properties and therefore do not bind to the hubd driver.
1005 * As a result load_bootpath_drivers() loads the usb_mid driver
1006 * for hub nodes rather than the hubd driver. This causes
1007 * mountroot failures when booting off USB storage. To prevent
1008 * this, if we are booting via USB hubs, we preload the hubd driver.
1009 */
1010 if (strstr(bootpath, "/hub@") && modloadonly("drv", "hubd") == -1) {
1011 cmn_err(CE_WARN, "bootpath contains a USB hub, "
1012 "but cannot load hubd driver");
1013 }
1014
1015 /* get rid of minor node at end of copy (if not already done above) */
1016 p = strrchr(pathcopy, '/');
1017 if (p) {
1018 p = strchr(p, ':');
1019 if (p)
1020 *p = 0;
1021 }
1022
1023 rval = load_parent_drivers(dip, pathcopy);
1024 kmem_free(pathcopy, pathcopy_len);
1025 return (rval);
1026 }
1027
1028
1029
1030
1031 /*
1032 * Load drivers required for a platform
1033 * Since all hardware nodes should be available in the device
1034 * tree, walk the per-driver list and load the parents of
1035 * each node found. If not a hardware node, try to load it.
1036 * Pseudo nexus is already loaded.
1037 */
1038 static int
1039 load_boot_platform_modules(char *drv)
1040 {
1041 major_t major;
1042 dev_info_t *dip;
1043 char *drvname;
1044 int rval = 0;
1045
1046 if ((major = ddi_name_to_major(drv)) == DDI_MAJOR_T_NONE) {
1047 cmn_err(CE_CONT, "%s: no major number\n", drv);
1048 return (-1);
1049 }
1050
1051 /*
1052 * resolve aliases
1053 */
1054 drvname = ddi_major_to_name(major);
1055 if ((major = ddi_name_to_major(drvname)) == DDI_MAJOR_T_NONE)
1056 return (-1);
1057
1058 #ifdef DEBUG
1059 if (strcmp(drv, drvname) == 0) {
1060 BMDPRINTF(("load_boot_platform_modules: %s\n", drv));
1061 } else {
1062 BMDPRINTF(("load_boot_platform_modules: %s -> %s\n",
1063 drv, drvname));
1064 }
1065 #endif /* DEBUG */
1066
1067 dip = devnamesp[major].dn_head;
1068 if (dip == NULL) {
1069 /* pseudo node, not-enumerated, needs to be loaded */
1070 if (modloadonly("drv", drvname) == -1) {
1071 cmn_err(CE_CONT, "%s: cannot load platform driver\n",
1072 drvname);
1073 rval = -1;
1074 }
1075 } else {
1076 while (dip) {
1077 if (load_parent_drivers(dip, NULL) != 0)
1078 rval = -1;
1079 dip = ddi_get_next(dip);
1080 }
1081 }
1082
1083 return (rval);
1084 }
1085
1086
1087 /*
1088 * i_find_node: Internal routine used by path_to_devinfo
1089 * to locate a given nodeid in the device tree.
1090 */
1091 struct i_path_findnode {
1092 pnode_t nodeid;
1093 dev_info_t *dip;
1094 };
1095
1096 static int
1097 i_path_find_node(dev_info_t *dev, void *arg)
1098 {
1099 struct i_path_findnode *f = (struct i_path_findnode *)arg;
1100
1101
1102 if (ddi_get_nodeid(dev) == (int)f->nodeid) {
1103 f->dip = dev;
1104 return (DDI_WALK_TERMINATE);
1105 }
1106 return (DDI_WALK_CONTINUE);
1107 }
1108
1109 /*
1110 * Return the devinfo node to a boot device
1111 */
1112 static dev_info_t *
1113 path_to_devinfo(char *path)
1114 {
1115 struct i_path_findnode fn;
1116 extern dev_info_t *top_devinfo;
1117
1118 /*
1119 * Get the nodeid of the given pathname, if such a mapping exists.
1120 */
1121 fn.dip = NULL;
1122 fn.nodeid = prom_finddevice(path);
1123 if (fn.nodeid != OBP_BADNODE) {
1124 /*
1125 * Find the nodeid in our copy of the device tree and return
1126 * whatever name we used to bind this node to a driver.
1127 */
1128 ddi_walk_devs(top_devinfo, i_path_find_node, (void *)(&fn));
1129 }
1130
1131 #ifdef DEBUG
1132 /*
1133 * If we're bound to something other than the nodename,
1134 * note that in the message buffer and system log.
1135 */
1136 if (fn.dip) {
1137 char *p, *q;
1138
1139 p = ddi_binding_name(fn.dip);
1140 q = ddi_node_name(fn.dip);
1141 if (p && q && (strcmp(p, q) != 0)) {
1142 BMDPRINTF(("path_to_devinfo: %s bound to %s\n",
1143 path, p));
1144 }
1145 }
1146 #endif /* DEBUG */
1147
1148 return (fn.dip);
1149 }
1150
1151 /*
1152 * This routine returns B_TRUE if the bootpath corresponds to
1153 * IP over IB driver.
1154 *
1155 * The format of the bootpath for the IP over IB looks like
1156 * /pci@1f,700000/pci@1/ib@0:port=1,pkey=8001,protocol=ip
1157 *
1158 * The minor node portion "port=1,pkey=8001,protocol=ip" represents
1159 * IP over IB driver.
1160 */
1161 static boolean_t
1162 netboot_over_ib(char *bootpath)
1163 {
1164
1165 char *temp;
1166 boolean_t ret = B_FALSE;
1167 pnode_t node = prom_finddevice(bootpath);
1168 int len;
1169 char devicetype[OBP_MAXDRVNAME];
1170
1171 /* Is this IB node ? */
1172 if (node == OBP_BADNODE || node == OBP_NONODE) {
1173 return (B_FALSE);
1174 }
1175 len = prom_getproplen(node, OBP_DEVICETYPE);
1176 if (len <= 1 || len >= OBP_MAXDRVNAME)
1177 return (B_FALSE);
1178
1179 (void) prom_getprop(node, OBP_DEVICETYPE, (caddr_t)devicetype);
1180
1181 if (strncmp("ib", devicetype, 2) == 0) {
1182 /* Check for proper IP over IB string */
1183 if ((temp = strstr(bootpath, ":port=")) != NULL) {
1184 if ((temp = strstr(temp, ",pkey=")) != NULL)
1185 if ((temp = strstr(temp,
1186 ",protocol=ip")) != NULL) {
1187 ret = B_TRUE;
1188 }
1189 }
1190 }
1191 return (ret);
1192 }
1193
1194 static boolean_t
1195 netboot_over_iscsi(void)
1196 {
1197 int proplen;
1198 boolean_t ret = B_FALSE;
1199 char bootpath[OBP_MAXPATHLEN];
1200
1201 proplen = BOP_GETPROPLEN(bootops, BP_BOOTPATH);
1202 if (proplen > 0) {
1203 if (BOP_GETPROP(bootops, BP_BOOTPATH, bootpath) > 0) {
1204 if (memcmp(bootpath, BP_ISCSI_DISK,
1205 strlen(BP_ISCSI_DISK)) == 0) {
1206 ret = B_TRUE;
1207 }
1208 }
1209 }
1210 return (ret);
1211 }