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.33 2007/08/26 16:54:51 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 int 308 vfs_mountroot_ask_callback(struct dev_ops *ops, void *arg __unused) 309 { 310 cdev_t dev; 311 312 dev = get_dev(ops->head.maj, 0); 313 if (dev_is_good(dev) && (dev_dflags(dev) & D_DISK)) 314 kprintf(" \"%s\"", dev_dname(dev)); 315 return(0); 316 } 317 318 static int 319 getline(char *cp, int limit) 320 { 321 char *lp; 322 int c; 323 324 lp = cp; 325 for (;;) { 326 c = cngetc(); 327 328 switch (c) { 329 case -1: 330 return(-1); 331 case '\n': 332 case '\r': 333 kprintf("\n"); 334 *lp++ = '\0'; 335 return(0); 336 case '\b': 337 case '\177': 338 if (lp > cp) { 339 kprintf("\b \b"); 340 lp--; 341 } else { 342 kprintf("%c", 7); 343 } 344 continue; 345 case '#': 346 kprintf("#"); 347 lp--; 348 if (lp < cp) 349 lp = cp; 350 continue; 351 case '@': 352 case 'u' & 037: 353 lp = cp; 354 kprintf("%c", '\n'); 355 continue; 356 default: 357 if (lp - cp >= limit - 1) { 358 kprintf("%c", 7); 359 } else { 360 kprintf("%c", c); 361 *lp++ = c; 362 } 363 continue; 364 } 365 } 366 } 367 368 /* 369 * Convert a given name to the cdev_t of the disk-like device 370 * it refers to. 371 */ 372 struct kdbn_info { 373 const char *name; 374 int nlen; 375 int minor; 376 cdev_t dev; 377 }; 378 379 static int kgetdiskbyname_callback(struct dev_ops *ops, void *arg); 380 381 cdev_t 382 kgetdiskbyname(const char *name) 383 { 384 char *cp; 385 int nlen; 386 int unit, slice, part; 387 cdev_t rdev; 388 struct kdbn_info info; 389 390 /* 391 * Get the base name of the device 392 */ 393 if (strncmp(name, __SYS_PATH_DEV, sizeof(__SYS_PATH_DEV) - 1) == 0) 394 name += sizeof(__SYS_PATH_DEV) - 1; 395 cp = __DECONST(char *, name); 396 while (*cp == '/') 397 ++cp; 398 while (*cp >= 'a' && *cp <= 'z') 399 ++cp; 400 if (cp == name) { 401 kprintf("missing device name\n"); 402 return (NULL); 403 } 404 nlen = cp - name; 405 406 /* 407 * Get the unit. 408 */ 409 unit = strtol(cp, &cp, 10); 410 if (name + nlen == (const char *)cp || unit < 0 || unit >= DKMAXUNITS) { 411 kprintf("bad unit: %d\n", unit); 412 return (NULL); 413 } 414 415 /* 416 * Get the slice. Note that if no partition or partition 'a' is 417 * specified, and no slice is specified, we will try both 'ad0a' 418 * (which is what you get when slice is 0), and also 'ad0' (the 419 * whole-disk partition, slice == 1). 420 */ 421 if (*cp == 's') { 422 slice = cp[1] - '0'; 423 if (slice >= 1) 424 ++slice; 425 cp += 2; 426 } else { 427 slice = 0; 428 } 429 430 /* 431 * Get the partition. 432 */ 433 if (*cp >= 'a' && *cp <= 'p') { 434 part = *cp - 'a'; 435 ++cp; 436 } else { 437 part = 0; 438 } 439 440 if (*cp != '\0') { 441 kprintf("junk after name: %s\n", cp); 442 return (NULL); 443 } 444 445 /* 446 * Locate the device 447 */ 448 bzero(&info, sizeof(info)); 449 info.nlen = nlen; 450 info.name = name; 451 info.minor = dkmakeminor(unit, slice, part); 452 dev_ops_scan(kgetdiskbyname_callback, &info); 453 if (info.dev == NULL) { 454 kprintf("no disk named '%s'\n", name); 455 return (NULL); 456 } 457 458 /* 459 * FOUND DEVICE 460 */ 461 rdev = make_sub_dev(info.dev, info.minor); 462 return(rdev); 463 } 464 465 static int 466 kgetdiskbyname_callback(struct dev_ops *ops, void *arg) 467 { 468 struct kdbn_info *info = arg; 469 cdev_t dev; 470 const char *dname; 471 472 dev = get_dev(ops->head.maj, info->minor); 473 if (dev_is_good(dev) && (dname = dev_dname(dev)) != NULL) { 474 if (strlen(dname) == info->nlen && 475 strncmp(dname, info->name, info->nlen) == 0) { 476 info->dev = dev; 477 return(-1); 478 } 479 } 480 return(0); 481 } 482 483 /* 484 * Set rootdev to match (name), given that we expect it to 485 * refer to a disk-like device. 486 */ 487 static int 488 setrootbyname(char *name) 489 { 490 cdev_t diskdev; 491 492 diskdev = kgetdiskbyname(name); 493 if (diskdev != NULL) { 494 rootdev = diskdev; 495 return (0); 496 } 497 498 return (1); 499 } 500 501 #ifdef DDB 502 DB_SHOW_COMMAND(disk, db_getdiskbyname) 503 { 504 cdev_t dev; 505 506 if (modif[0] == '\0') { 507 db_error("usage: show disk/devicename"); 508 return; 509 } 510 dev = kgetdiskbyname(modif); 511 if (dev != NULL) 512 db_printf("cdev_t = %p\n", dev); 513 else 514 db_printf("No disk device matched.\n"); 515 } 516 #endif 517