init/do_mounts.c

   1 #include <linux/module.h>
   2 #include <linux/sched.h>
   3 #include <linux/ctype.h>
   4 #include <linux/fd.h>
   5 #include <linux/tty.h>
   6 #include <linux/suspend.h>
   7 #include <linux/root_dev.h>
   8 #include <linux/security.h>
   9 #include <linux/delay.h>
  10 #include <linux/mount.h>
  11
  12 #include <linux/nfs_fs.h>
  13 #include <linux/nfs_fs_sb.h>
  14 #include <linux/nfs_mount.h>
  15
  16 #include "do_mounts.h"
  17
  18 extern int get_filesystem_list(char * buf);
  19
  20 int __initdata rd_doload;       /* 1 = load RAM disk, 0 = don't load */
  21
  22 int root_mountflags = MS_RDONLY | MS_SILENT;
  23 char * __initdata root_device_name;
  24 static char __initdata saved_root_name[64];
  25
  26 dev_t ROOT_DEV;
  27
  28 static int __init load_ramdisk(char *str)
  29 {
  30         rd_doload = simple_strtol(str,NULL,0) & 3;
  31         return 1;
  32 }
  33 __setup("load_ramdisk=", load_ramdisk);
  34
  35 static int __init readonly(char *str)
  36 {
  37         if (*str)
  38                 return 0;
  39         root_mountflags |= MS_RDONLY;
  40         return 1;
  41 }
  42
  43 static int __init readwrite(char *str)
  44 {
  45         if (*str)
  46                 return 0;
  47         root_mountflags &= ~MS_RDONLY;
  48         return 1;
  49 }
  50
  51 __setup("ro", readonly);
  52 __setup("rw", readwrite);
  53
  54 static dev_t try_name(char *name, int part)
  55 {
  56         char path[64];
  57         char buf[32];
  58         int range;
  59         dev_t res;
  60         char *s;
  61         int len;
  62         int fd;
  63         unsigned int maj, min;
  64
  65         /* read device number from .../dev */
  66
  67         sprintf(path, "/sys/block/%s/dev", name);
  68         fd = sys_open(path, 0, 0);
  69         if (fd < 0)
  70                 goto fail;
  71         len = sys_read(fd, buf, 32);
  72         sys_close(fd);
  73         if (len <= 0 || len == 32 || buf[len - 1] != '\n')
  74                 goto fail;
  75         buf[len - 1] = '\0';
  76         if (sscanf(buf, "%u:%u", &maj, &min) == 2) {
  77                 /*
  78                  * Try the %u:%u format -- see print_dev_t()
  79                  */
  80                 res = MKDEV(maj, min);
  81                 if (maj != MAJOR(res) || min != MINOR(res))
  82                         goto fail;
  83         } else {
  84                 /*
  85                  * Nope.  Try old-style "0321"
  86                  */
  87                 res = new_decode_dev(simple_strtoul(buf, &s, 16));
  88                 if (*s)
  89                         goto fail;
  90         }
  91
  92         /* if it's there and we are not looking for a partition - that's it */
  93         if (!part)
  94                 return res;
  95
  96         /* otherwise read range from .../range */
  97         sprintf(path, "/sys/block/%s/range", name);
  98         fd = sys_open(path, 0, 0);
  99         if (fd < 0)
 100                 goto fail;
 101         len = sys_read(fd, buf, 32);
 102         sys_close(fd);
 103         if (len <= 0 || len == 32 || buf[len - 1] != '\n')
 104                 goto fail;
 105         buf[len - 1] = '\0';
 106         range = simple_strtoul(buf, &s, 10);
 107         if (*s)
 108                 goto fail;
 109
 110         /* if partition is within range - we got it */
 111         if (part < range)
 112                 return res + part;
 113 fail:
 114         return 0;
 115 }
 116
 117 /*
 118  *      Convert a name into device number.  We accept the following variants:
 119  *
 120  *      1) device number in hexadecimal represents itself
 121  *      2) /dev/nfs represents Root_NFS (0xff)
 122  *      3) /dev/<disk_name> represents the device number of disk
 123  *      4) /dev/<disk_name><decimal> represents the device number
 124  *         of partition - device number of disk plus the partition number
 125  *      5) /dev/<disk_name>p<decimal> - same as the above, that form is
 126  *         used when disk name of partitioned disk ends on a digit.
 127  *
 128  *      If name doesn't have fall into the categories above, we return 0.
 129  *      Sysfs is used to check if something is a disk name - it has
 130  *      all known disks under bus/block/devices.  If the disk name
 131  *      contains slashes, name of sysfs node has them replaced with
 132  *      bangs.  try_name() does the actual checks, assuming that sysfs
 133  *      is mounted on rootfs /sys.
 134  */
 135
 136 dev_t name_to_dev_t(char *name)
 137 {
 138         char s[32];
 139         char *p;
 140         dev_t res = 0;
 141         int part, mount_result;
 142
 143 #ifdef CONFIG_SYSFS
 144         int mkdir_err = sys_mkdir("/sys", 0700);
 145         /*
 146          * When changing resume2 parameter for Software Suspend, sysfs may
 147          * already be mounted.
 148          */
 149         mount_result = sys_mount("sysfs", "/sys", "sysfs", 0, NULL);
 150         if (mount_result < 0 && mount_result != -EBUSY)
 151                 goto out;
 152 #endif
 153
 154         if (strncmp(name, "/dev/", 5) != 0) {
 155                 unsigned maj, min;
 156
 157                 if (sscanf(name, "%u:%u", &maj, &min) == 2) {
 158                         res = MKDEV(maj, min);
 159                         if (maj != MAJOR(res) || min != MINOR(res))
 160                                 goto fail;
 161                 } else {
 162                         res = new_decode_dev(simple_strtoul(name, &p, 16));
 163                         if (*p)
 164                                 goto fail;
 165                 }
 166                 goto done;
 167         }
 168         name += 5;
 169         res = Root_NFS;
 170         if (strcmp(name, "nfs") == 0)
 171                 goto done;
 172         res = Root_RAM0;
 173         if (strcmp(name, "ram") == 0)
 174                 goto done;
 175
 176         if (strlen(name) > 31)
 177                 goto fail;
 178         strcpy(s, name);
 179         for (p = s; *p; p++)
 180                 if (*p == '/')
 181                         *p = '!';
 182         res = try_name(s, 0);
 183         if (res)
 184                 goto done;
 185
 186         while (p > s && isdigit(p[-1]))
 187                 p--;
 188         if (p == s || !*p || *p == '0')
 189                 goto fail;
 190         part = simple_strtoul(p, NULL, 10);
 191         *p = '\0';
 192         res = try_name(s, part);
 193         if (res)
 194                 goto done;
 195
 196         if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
 197                 goto fail;
 198         p[-1] = '\0';
 199         res = try_name(s, part);
 200 done:
 201 #ifdef CONFIG_SYSFS
 202         if (mount_result >= 0)
 203                 sys_umount("/sys", 0);
 204 out:
 205         if (!mkdir_err)
 206                 sys_rmdir("/sys");
 207 #endif
 208         return res;
 209 fail:
 210         res = 0;
 211         goto done;
 212 }
 213
 214 static int __init root_dev_setup(char *line)
 215 {
 216         strlcpy(saved_root_name, line, sizeof(saved_root_name));
 217         return 1;
 218 }
 219
 220 __setup("root=", root_dev_setup);
 221
 222 static char * __initdata root_mount_data;
 223 static int __init root_data_setup(char *str)
 224 {
 225         root_mount_data = str;
 226         return 1;
 227 }
 228
 229 static char * __initdata root_fs_names;
 230 static int __init fs_names_setup(char *str)
 231 {
 232         root_fs_names = str;
 233         return 1;
 234 }
 235
 236 static unsigned int __initdata root_delay;
 237 static int __init root_delay_setup(char *str)
 238 {
 239         root_delay = simple_strtoul(str, NULL, 0);
 240         return 1;
 241 }
 242
 243 __setup("rootflags=", root_data_setup);
 244 __setup("rootfstype=", fs_names_setup);
 245 __setup("rootdelay=", root_delay_setup);
 246
 247 static void __init get_fs_names(char *page)
 248 {
 249         char *s = page;
 250
 251         if (root_fs_names) {
 252                 strcpy(page, root_fs_names);
 253                 while (*s++) {
 254                         if (s[-1] == ',')
 255                                 s[-1] = '\0';
 256                 }
 257         } else {
 258                 int len = get_filesystem_list(page);
 259                 char *p, *next;
 260
 261                 page[len] = '\0';
 262                 for (p = page-1; p; p = next) {
 263                         next = strchr(++p, '\n');
 264                         if (*p++ != '\t')
 265                                 continue;
 266                         while ((*s++ = *p++) != '\n')
 267                                 ;
 268                         s[-1] = '\0';
 269                 }
 270         }
 271         *s = '\0';
 272 }
 273
 274 static int __init do_mount_root(char *name, char *fs, int flags, void *data)
 275 {
 276         int err = sys_mount(name, "/root", fs, flags, data);
 277         if (err)
 278                 return err;
 279
 280         sys_chdir("/root");
 281         ROOT_DEV = current->fs->pwdmnt->mnt_sb->s_dev;
 282         printk("VFS: Mounted root (%s filesystem)%s.\n",
 283                current->fs->pwdmnt->mnt_sb->s_type->name,
 284                current->fs->pwdmnt->mnt_sb->s_flags & MS_RDONLY ?
 285                " readonly" : "");
 286         return 0;
 287 }
 288
 289 void __init mount_block_root(char *name, int flags)
 290 {
 291         char *fs_names = __getname();
 292         char *p;
 293         char b[BDEVNAME_SIZE];
 294
 295         get_fs_names(fs_names);
 296 retry:
 297         for (p = fs_names; *p; p += strlen(p)+1) {
 298                 int err = do_mount_root(name, p, flags, root_mount_data);
 299                 switch (err) {
 300                         case 0:
 301                                 goto out;
 302                         case -EACCES:
 303                                 flags |= MS_RDONLY;
 304                                 goto retry;
 305                         case -EINVAL:
 306                                 continue;
 307                 }
 308                 /*
 309                  * Allow the user to distinguish between failed sys_open
 310                  * and bad superblock on root device.
 311                  */
 312                 __bdevname(ROOT_DEV, b);
 313                 printk("VFS: Cannot open root device \"%s\" or %s\n",
 314                                 root_device_name, b);
 315                 printk("Please append a correct \"root=\" boot option\n");
 316
 317                 panic("VFS: Unable to mount root fs on %s", b);
 318         }
 319
 320         printk("No filesystem could mount root, tried: ");
 321         for (p = fs_names; *p; p += strlen(p)+1)
 322                 printk(" %s", p);
 323         printk("\n");
 324         panic("VFS: Unable to mount root fs on %s", __bdevname(ROOT_DEV, b));
 325 out:
 326         putname(fs_names);
 327 }
 328
 329 #ifdef CONFIG_ROOT_NFS
 330 static int __init mount_nfs_root(void)
 331 {
 332         void *data = nfs_root_data();
 333
 334         create_dev("/dev/root", ROOT_DEV);
 335         if (data &&
 336             do_mount_root("/dev/root", "nfs", root_mountflags, data) == 0)
 337                 return 1;
 338         return 0;
 339 }
 340 #endif
 341
 342 #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
 343 void __init change_floppy(char *fmt, ...)
 344 {
 345         struct termios termios;
 346         char buf[80];
 347         char c;
 348         int fd;
 349         va_list args;
 350         va_start(args, fmt);
 351         vsprintf(buf, fmt, args);
 352         va_end(args);
 353         fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0);
 354         if (fd >= 0) {
 355                 sys_ioctl(fd, FDEJECT, 0);
 356                 sys_close(fd);
 357         }
 358         printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
 359         fd = sys_open("/dev/console", O_RDWR, 0);
 360         if (fd >= 0) {
 361                 sys_ioctl(fd, TCGETS, (long)&termios);
 362                 termios.c_lflag &= ~ICANON;
 363                 sys_ioctl(fd, TCSETSF, (long)&termios);
 364                 sys_read(fd, &c, 1);
 365                 termios.c_lflag |= ICANON;
 366                 sys_ioctl(fd, TCSETSF, (long)&termios);
 367                 sys_close(fd);
 368         }
 369 }
 370 #endif
 371
 372 void __init mount_root(void)
 373 {
 374 #ifdef CONFIG_ROOT_NFS
 375         if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) {
 376                 if (mount_nfs_root())
 377                         return;
 378
 379                 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
 380                 ROOT_DEV = Root_FD0;
 381         }
 382 #endif
 383 #ifdef CONFIG_BLK_DEV_FD
 384         if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
 385                 /* rd_doload is 2 for a dual initrd/ramload setup */
 386                 if (rd_doload==2) {
 387                         if (rd_load_disk(1)) {
 388                                 ROOT_DEV = Root_RAM1;
 389                                 root_device_name = NULL;
 390                         }
 391                 } else
 392                         change_floppy("root floppy");
 393         }
 394 #endif
 395         create_dev("/dev/root", ROOT_DEV);
 396         mount_block_root("/dev/root", root_mountflags);
 397 }
 398
 399 /*
 400  * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
 401  */
 402 void __init prepare_namespace(void)
 403 {
 404         int is_floppy;
 405
 406         if (root_delay) {
 407                 printk(KERN_INFO "Waiting %dsec before mounting root device...\n",
 408                        root_delay);
 409                 ssleep(root_delay);
 410         }
 411
 412         md_run_setup();
 413
 414         if (saved_root_name[0]) {
 415                 root_device_name = saved_root_name;
 416                 if (!strncmp(root_device_name, "mtd", 3)) {
 417                         mount_block_root(root_device_name, root_mountflags);
 418                         goto out;
 419                 }
 420                 ROOT_DEV = name_to_dev_t(root_device_name);
 421                 if (strncmp(root_device_name, "/dev/", 5) == 0)
 422                         root_device_name += 5;
 423         }
 424
 425         is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
 426
 427         /* Suspend2:
 428          * By this point, suspend_early_init has been called to initialise our
 429          * sysfs interface. If modules are built in, they have registered (all
 430          * of the above via initcalls).
 431          *
 432          * We have not yet looked to see if an image exists, however. If we
 433          * have an initrd, it is expected that the user will have set it up
 434          * to echo > /sys/power/suspend2/do_resume and thus initiate any
 435          * resume. If they don't do that, we do it immediately after the initrd
 436          * is finished (major issues if they mount filesystems rw from the
 437          * initrd! - they are warned. If there's no usable initrd, we do our
 438          * check next.
 439          */
 440         if (initrd_load())
 441                 goto out;
 442
 443         if (is_floppy && rd_doload && rd_load_disk(0))
 444                 ROOT_DEV = Root_RAM0;
 445
 446         check_resume_attempted();
 447
 448         mount_root();
 449 out:
 450         sys_mount(".", "/", NULL, MS_MOVE, NULL);
 451         sys_chroot(".");
 452         security_sb_post_mountroot();
 453 }
 454