sys/kern/vfs_conf.c

   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