1 /*- 2 * Copyright (c) 1999 Michael Smith 3 * All rights reserved. 4 * Copyright (c) 1999 Poul-Henning Kamp 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD: src/sys/kern/vfs_conf.c,v 1.49.2.5 2003/01/07 11:56:53 joerg Exp $ 29 * $DragonFly: src/sys/kern/vfs_conf.c,v 1.32 2007/06/17 23:50:16 dillon Exp $ 30 */ 31 32 /* 33 * Locate and mount the root filesystem. 34 * 35 * The root filesystem is detailed in the kernel environment variable 36 * vfs.root.mountfrom, which is expected to be in the general format 37 * 38 * <vfsname>:[<path>] 39 * vfsname := the name of a VFS known to the kernel and capable 40 * of being mounted as root 41 * path := disk device name or other data used by the filesystem 42 * to locate its physical store 43 * 44 */ 45 46 #include "opt_rootdevname.h" 47 48 #include <sys/param.h> 49 #include <sys/kernel.h> 50 #include <sys/systm.h> 51 #include <sys/proc.h> 52 #include <sys/vnode.h> 53 #include <sys/mount.h> 54 #include <sys/malloc.h> 55 #include <sys/reboot.h> 56 #include <sys/diskslice.h> 57 #include <sys/conf.h> 58 #include <sys/cons.h> 59 #include <sys/device.h> 60 #include <sys/namecache.h> 61 #include <sys/paths.h> 62 #include <sys/thread2.h> 63 64 #include "opt_ddb.h" 65 #ifdef DDB 66 #include <ddb/ddb.h> 67 #endif 68 69 MALLOC_DEFINE(M_MOUNT, "mount", "vfs mount structure"); 70 71 #define ROOTNAME "root_device" 72 73 struct vnode *rootvnode; 74 struct nchandle rootnch; 75 76 /* 77 * The root specifiers we will try if RB_CDROM is specified. Note that 78 * the ATA driver will accept acd*a and acd*c, but the SCSI driver 79 * will only accept cd*c, so use 'c'. 80 * 81 * XXX TGEN NATA and, presumably, 'old'ATA will also accept the device name 82 * without any fake partition, since the major & minor are identical for all 83 * three (acd*, acd*a and acd*c). However, due to an as-of-yet undiscovered 84 * bug, acd0c ends up with minor 2 when using NATA and booting cold. Since 85 * NATA's acd_open() is unable to fulfill mounts on such 'ghost' cdevs, acd0 86 * and acd1 have been added to the list of CD-ROM root device names. 87 */ 88 static char *cdrom_rootdevnames[] = { 89 "cd9660:cd0c", 90 "cd9660:acd0c", 91 "cd9660:cd1c", 92 "cd9660:acd1c", 93 "cd9660:acd0", 94 "cd9660:acd1", 95 NULL 96 }; 97 98 static void vfs_mountroot(void *junk); 99 static int vfs_mountroot_try(const char *mountfrom); 100 static int vfs_mountroot_ask(void); 101 static int getline(char *cp, int limit); 102 103 /* legacy find-root code */ 104 char *rootdevnames[2] = {NULL, NULL}; 105 static int setrootbyname(char *name); 106 107 SYSINIT(mountroot, SI_SUB_MOUNT_ROOT, SI_ORDER_SECOND, vfs_mountroot, NULL); 108 109 /* 110 * Find and mount the root filesystem 111 */ 112 static void 113 vfs_mountroot(void *junk) 114 { 115 int i; 116 cdev_t save_rootdev = rootdev; 117 118 /* 119 * The root filesystem information is compiled in, and we are 120 * booted with instructions to use it. 121 */ 122 #ifdef ROOTDEVNAME 123 if ((boothowto & RB_DFLTROOT) && 124 !vfs_mountroot_try(ROOTDEVNAME)) 125 return; 126 #endif 127 /* 128 * We are booted with instructions to prompt for the root filesystem, 129 * or to use the compiled-in default when it doesn't exist. 130 */ 131 if (boothowto & (RB_DFLTROOT | RB_ASKNAME)) { 132 if (!vfs_mountroot_ask()) 133 return; 134 } 135 136 /* 137 * We've been given the generic "use CDROM as root" flag. This is 138 * necessary because one media may be used in many different 139 * devices, so we need to search for them. 140 */ 141 if (boothowto & RB_CDROM) { 142 for (i = 0; cdrom_rootdevnames[i] != NULL; i++) { 143 if (!vfs_mountroot_try(cdrom_rootdevnames[i])) 144 return; 145 } 146 } 147 148 /* 149 * Try to use the value read by the loader from /etc/fstab, or 150 * supplied via some other means. This is the preferred 151 * mechanism. 152 */ 153 if (!vfs_mountroot_try(kgetenv("vfs.root.mountfrom"))) 154 return; 155 156 /* 157 * If a vfs set rootdev, try it (XXX VINUM HACK!) 158 */ 159 if (save_rootdev != NULL) { 160 rootdev = save_rootdev; 161 if (!vfs_mountroot_try("")) 162 return; 163 } 164 165 /* 166 * Try values that may have been computed by the machine-dependant 167 * legacy code. 168 */ 169 if (rootdevnames[0] && !vfs_mountroot_try(rootdevnames[0])) 170 return; 171 if (rootdevnames[1] && !vfs_mountroot_try(rootdevnames[1])) 172 return; 173 174 /* 175 * If we have a compiled-in default, and haven't already tried it, try 176 * it now. 177 */ 178 #ifdef ROOTDEVNAME 179 if (!(boothowto & RB_DFLTROOT)) 180 if (!vfs_mountroot_try(ROOTDEVNAME)) 181 return; 182 #endif 183 184 /* 185 * Everything so far has failed, prompt on the console if we haven't 186 * already tried that. 187 */ 188 if (!(boothowto & (RB_DFLTROOT | RB_ASKNAME)) && !vfs_mountroot_ask()) 189 return; 190 panic("Root mount failed, startup aborted."); 191 } 192 193 /* 194 * Mount (mountfrom) as the root filesystem. 195 */ 196 static int 197 vfs_mountroot_try(const char *mountfrom) 198 { 199 struct mount *mp; 200 char *vfsname, *devname; 201 int error; 202 char patt[32]; 203 204 vfsname = NULL; 205 devname = NULL; 206 mp = NULL; 207 error = EINVAL; 208 209 if (mountfrom == NULL) 210 return(error); /* don't complain */ 211 212 crit_enter(); 213 kprintf("Mounting root from %s\n", mountfrom); 214 crit_exit(); 215 216 /* parse vfs name and devname */ 217 vfsname = kmalloc(MFSNAMELEN, M_MOUNT, M_WAITOK); 218 devname = kmalloc(MNAMELEN, M_MOUNT, M_WAITOK); 219 vfsname[0] = devname[0] = 0; 220 ksprintf(patt, "%%%d[a-z0-9]:%%%ds", MFSNAMELEN, MNAMELEN); 221 if (ksscanf(mountfrom, patt, vfsname, devname) < 1) 222 goto done; 223 224 /* allocate a root mount */ 225 error = vfs_rootmountalloc(vfsname, 226 devname[0] != 0 ? devname : ROOTNAME, &mp); 227 if (error != 0) { 228 kprintf("Can't allocate root mount for filesystem '%s': %d\n", 229 vfsname, error); 230 goto done; 231 } 232 mp->mnt_flag |= MNT_ROOTFS; 233 234 /* do our best to set rootdev */ 235 if ((devname[0] != 0) && setrootbyname(devname)) 236 kprintf("setrootbyname failed\n"); 237 238 /* If the root device is a type "memory disk", mount RW */ 239 if (rootdev != NULL && dev_is_good(rootdev) && 240 (dev_dflags(rootdev) & D_MEMDISK)) { 241 mp->mnt_flag &= ~MNT_RDONLY; 242 } 243 244 error = VFS_MOUNT(mp, NULL, NULL, proc0.p_ucred); 245 246 done: 247 if (vfsname != NULL) 248 kfree(vfsname, M_MOUNT); 249 if (devname != NULL) 250 kfree(devname, M_MOUNT); 251 if (error != 0) { 252 if (mp != NULL) { 253 vfs_unbusy(mp); 254 kfree(mp, M_MOUNT); 255 } 256 kprintf("Root mount failed: %d\n", error); 257 } else { 258 /* register with list of mounted filesystems */ 259 mountlist_insert(mp, MNTINS_FIRST); 260 261 /* sanity check system clock against root fs timestamp */ 262 inittodr(mp->mnt_time); 263 vfs_unbusy(mp); 264 } 265 return(error); 266 } 267 268 /* 269 * Spin prompting on the console for a suitable root filesystem 270 */ 271 static int vfs_mountroot_ask_callback(struct dev_ops *ops, void *arg); 272 273 static int 274 vfs_mountroot_ask(void) 275 { 276 char name[128]; 277 int llimit = 100; 278 279 kprintf("\nManual root filesystem specification:\n"); 280 kprintf(" <fstype>:<device> Specify root (e.g. ufs:da0s1a)\n"); 281 kprintf(" ? List valid disk boot devices\n"); 282 kprintf(" panic Just panic\n"); 283 kprintf(" abort Abort manual input\n"); 284 while (llimit--) { 285 kprintf("\nmountroot> "); 286 287 if (getline(name, 128) < 0) 288 break; 289 if (name[0] == 0) { 290 ; 291 } else if (name[0] == '?') { 292 kprintf("Possibly valid devices for 'ufs' root:\n"); 293 dev_ops_scan(vfs_mountroot_ask_callback, NULL); 294 kprintf("\n"); 295 continue; 296 } else if (strcmp(name, "panic") == 0) { 297 panic("panic from console"); 298 } else if (strcmp(name, "abort") == 0) { 299 break; 300 } else if (vfs_mountroot_try(name) == 0) { 301 return(0); 302 } 303 } 304 return(1); 305 } 306 307 static 308 int 309 vfs_mountroot_ask_callback(struct dev_ops *ops, void *arg __unused) 310 { 311 cdev_t dev; 312 313 dev = get_dev(ops->head.maj, 0); 314 if (dev_is_good(dev)) 315 kprintf(" \"%s\"", dev_dname(dev)); 316 return(0); 317 } 318 319 static int 320 getline(char *cp, int limit) 321 { 322 char *lp; 323 int c; 324 325 lp = cp; 326 for (;;) { 327 c = cngetc(); 328 329 switch (c) { 330 case -1: 331 return(-1); 332 case '\n': 333 case '\r': 334 kprintf("\n"); 335 *lp++ = '\0'; 336 return(0); 337 case '\b': 338 case '\177': 339 if (lp > cp) { 340 kprintf("\b \b"); 341 lp--; 342 } else { 343 kprintf("%c", 7); 344 } 345 continue; 346 case '#': 347 kprintf("#"); 348 lp--; 349 if (lp < cp) 350 lp = cp; 351 continue; 352 case '@': 353 case 'u' & 037: 354 lp = cp; 355 kprintf("%c", '\n'); 356 continue; 357 default: 358 if (lp - cp >= limit - 1) { 359 kprintf("%c", 7); 360 } else { 361 kprintf("%c", c); 362 *lp++ = c; 363 } 364 continue; 365 } 366 } 367 } 368 369 /* 370 * Convert a given name to the cdev_t of the disk-like device 371 * it refers to. 372 */ 373 struct kdbn_info { 374 const char *name; 375 int nlen; 376 int minor; 377 cdev_t dev; 378 }; 379 380 static int kgetdiskbyname_callback(struct dev_ops *ops, void *arg); 381 382 cdev_t 383 kgetdiskbyname(const char *name) 384 { 385 char *cp; 386 int nlen; 387 int unit, slice, part; 388 cdev_t rdev; 389 struct kdbn_info info; 390 391 /* 392 * Get the base name of the device 393 */ 394 if (strncmp(name, __SYS_PATH_DEV, sizeof(__SYS_PATH_DEV) - 1) == 0) 395 name += sizeof(__SYS_PATH_DEV) - 1; 396 cp = __DECONST(char *, name); 397 while (*cp == '/') 398 ++cp; 399 while (*cp >= 'a' && *cp <= 'z') 400 ++cp; 401 if (cp == name) { 402 kprintf("missing device name\n"); 403 return (NULL); 404 } 405 nlen = cp - name; 406 407 /* 408 * Get the unit. 409 */ 410 unit = strtol(cp, &cp, 10); 411 if (name + nlen == (const char *)cp || unit < 0 || unit >= DKMAXUNITS) { 412 kprintf("bad unit: %d\n", unit); 413 return (NULL); 414 } 415 416 /* 417 * Get the slice. Note that if no partition or partition 'a' is 418 * specified, and no slice is specified, we will try both 'ad0a' 419 * (which is what you get when slice is 0), and also 'ad0' (the 420 * whole-disk partition, slice == 1). 421 */ 422 if (*cp == 's') { 423 slice = cp[1] - '0'; 424 if (slice >= 1) 425 ++slice; 426 cp += 2; 427 } else { 428 slice = 0; 429 } 430 431 /* 432 * Get the partition. 433 */ 434 if (*cp >= 'a' && *cp <= 'p') { 435 part = *cp - 'a'; 436 ++cp; 437 } else { 438 part = 0; 439 } 440 441 if (*cp != '\0') { 442 kprintf("junk after name\n"); 443 return (NULL); 444 } 445 446 /* 447 * Locate the device 448 */ 449 bzero(&info, sizeof(info)); 450 info.nlen = nlen; 451 info.name = name; 452 info.minor = dkmakeminor(unit, slice, part); 453 dev_ops_scan(kgetdiskbyname_callback, &info); 454 if (info.dev == NULL) { 455 kprintf("no such device '%*.*s'\n", nlen, nlen, name); 456 return (NULL); 457 } 458 459 /* 460 * FOUND DEVICE 461 */ 462 rdev = make_sub_dev(info.dev, info.minor); 463 return(rdev); 464 } 465 466 static 467 int 468 kgetdiskbyname_callback(struct dev_ops *ops, void *arg) 469 { 470 struct kdbn_info *info = arg; 471 cdev_t dev; 472 const char *dname; 473 474 dev = get_dev(ops->head.maj, info->minor); 475 if (dev_is_good(dev) && (dname = dev_dname(dev)) != NULL) { 476 if (strlen(dname) == info->nlen && 477 strncmp(dname, info->name, info->nlen) == 0) { 478 info->dev = dev; 479 return(-1); 480 } 481 } 482 return(0); 483 } 484 485 /* 486 * Set rootdev to match (name), given that we expect it to 487 * refer to a disk-like device. 488 */ 489 static int 490 setrootbyname(char *name) 491 { 492 cdev_t diskdev; 493 494 diskdev = kgetdiskbyname(name); 495 if (diskdev != NULL) { 496 rootdev = diskdev; 497 return (0); 498 } 499 500 return (1); 501 } 502 503 #ifdef DDB 504 DB_SHOW_COMMAND(disk, db_getdiskbyname) 505 { 506 cdev_t dev; 507 508 if (modif[0] == '\0') { 509 db_error("usage: show disk/devicename"); 510 return; 511 } 512 dev = kgetdiskbyname(modif); 513 if (dev != NULL) 514 db_printf("cdev_t = %p\n", dev); 515 else 516 db_printf("No disk device matched.\n"); 517 } 518 #endif 519