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.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