LXR linux/init/do

   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/genhd.h>
  11#include <linux/mount.h>
  12#include <linux/device.h>
  13#include <linux/init.h>
  14#include <linux/fs.h>
  15#include <linux/initrd.h>
  16
  17#include <linux/nfs_fs.h>
  18#include <linux/nfs_fs_sb.h>
  19#include <linux/nfs_mount.h>
  20
  21#include "do_mounts.h"
  22
  23int __initdata rd_doload;       /* 1 = load RAM disk, 0 = don't load */
  24
  25int root_mountflags = MS_RDONLY | MS_SILENT;
  26static char * __initdata root_device_name;
  27static char __initdata saved_root_name[64];
  28static int __initdata root_wait;
  29
  30dev_t ROOT_DEV;
  31
  32static int __init load_ramdisk(char *str)
  33{
  34        rd_doload = simple_strtol(str,NULL,0) & 3;
  35        return 1;
  36}
  37__setup("load_ramdisk=", load_ramdisk);
  38
  39static int __init readonly(char *str)
  40{
  41        if (*str)
  42                return 0;
  43        root_mountflags |= MS_RDONLY;
  44        return 1;
  45}
  46
  47static int __init readwrite(char *str)
  48{
  49        if (*str)
  50                return 0;
  51        root_mountflags &= ~MS_RDONLY;
  52        return 1;
  53}
  54
  55__setup("ro", readonly);
  56__setup("rw", readwrite);
  57
  58/*
  59 *      Convert a name into device number.  We accept the following variants:
  60 *
  61 *      1) device number in hexadecimal represents itself
  62 *      2) /dev/nfs represents Root_NFS (0xff)
  63 *      3) /dev/<disk_name> represents the device number of disk
  64 *      4) /dev/<disk_name><decimal> represents the device number
  65 *         of partition - device number of disk plus the partition number
  66 *      5) /dev/<disk_name>p<decimal> - same as the above, that form is
  67 *         used when disk name of partitioned disk ends on a digit.
  68 *
  69 *      If name doesn't have fall into the categories above, we return (0,0).
  70 *      block_class is used to check if something is a disk name. If the disk
  71 *      name contains slashes, the device name has them replaced with
  72 *      bangs.
  73 */
  74
  75dev_t name_to_dev_t(char *name)
  76{
  77        char s[32];
  78        char *p;
  79        dev_t res = 0;
  80        int part;
  81
  82        if (strncmp(name, "/dev/", 5) != 0) {
  83                unsigned maj, min;
  84
  85                if (sscanf(name, "%u:%u", &maj, &min) == 2) {
  86                        res = MKDEV(maj, min);
  87                        if (maj != MAJOR(res) || min != MINOR(res))
  88                                goto fail;
  89                } else {
  90                        res = new_decode_dev(simple_strtoul(name, &p, 16));
  91                        if (*p)
  92                                goto fail;
  93                }
  94                goto done;
  95        }
  96
  97        name += 5;
  98        res = Root_NFS;
  99        if (strcmp(name, "nfs") == 0)
 100                goto done;
 101        res = Root_RAM0;
 102        if (strcmp(name, "ram") == 0)
 103                goto done;
 104
 105        if (strlen(name) > 31)
 106                goto fail;
 107        strcpy(s, name);
 108        for (p = s; *p; p++)
 109                if (*p == '/')
 110                        *p = '!';
 111        res = blk_lookup_devt(s, 0);
 112        if (res)
 113                goto done;
 114
 115        /*
 116         * try non-existant, but valid partition, which may only exist
 117         * after revalidating the disk, like partitioned md devices
 118         */
 119        while (p > s && isdigit(p[-1]))
 120                p--;
 121        if (p == s || !*p || *p == '0')
 122                goto fail;
 123
 124        /* try disk name without <part number> */
 125        part = simple_strtoul(p, NULL, 10);
 126        *p = '\0';
 127        res = blk_lookup_devt(s, part);
 128        if (res)
 129                goto done;
 130
 131        /* try disk name without p<part number> */
 132        if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
 133                goto fail;
 134        p[-1] = '\0';
 135        res = blk_lookup_devt(s, part);
 136        if (res)
 137                goto done;
 138
 139fail:
 140        return 0;
 141done:
 142        return res;
 143}
 144
 145static int __init root_dev_setup(char *line)
 146{
 147        strlcpy(saved_root_name, line, sizeof(saved_root_name));
 148        return 1;
 149}
 150
 151__setup("root=", root_dev_setup);
 152
 153static int __init rootwait_setup(char *str)
 154{
 155        if (*str)
 156                return 0;
 157        root_wait = 1;
 158        return 1;
 159}
 160
 161__setup("rootwait", rootwait_setup);
 162
 163static char * __initdata root_mount_data;
 164static int __init root_data_setup(char *str)
 165{
 166        root_mount_data = str;
 167        return 1;
 168}
 169
 170static char * __initdata root_fs_names;
 171static int __init fs_names_setup(char *str)
 172{
 173        root_fs_names = str;
 174        return 1;
 175}
 176
 177static unsigned int __initdata root_delay;
 178static int __init root_delay_setup(char *str)
 179{
 180        root_delay = simple_strtoul(str, NULL, 0);
 181        return 1;
 182}
 183
 184__setup("rootflags=", root_data_setup);
 185__setup("rootfstype=", fs_names_setup);
 186__setup("rootdelay=", root_delay_setup);
 187
 188static void __init get_fs_names(char *page)
 189{
 190        char *s = page;
 191
 192        if (root_fs_names) {
 193                strcpy(page, root_fs_names);
 194                while (*s++) {
 195                        if (s[-1] == ',')
 196                                s[-1] = '\0';
 197                }
 198        } else {
 199                int len = get_filesystem_list(page);
 200                char *p, *next;
 201
 202                page[len] = '\0';
 203                for (p = page-1; p; p = next) {
 204                        next = strchr(++p, '\n');
 205                        if (*p++ != '\t')
 206                                continue;
 207                        while ((*s++ = *p++) != '\n')
 208                                ;
 209                        s[-1] = '\0';
 210                }
 211        }
 212        *s = '\0';
 213}
 214
 215static int __init do_mount_root(char *name, char *fs, int flags, void *data)
 216{
 217        int err = sys_mount(name, "/root", fs, flags, data);
 218        if (err)
 219                return err;
 220
 221        sys_chdir("/root");
 222        ROOT_DEV = current->fs->pwd.mnt->mnt_sb->s_dev;
 223        printk("VFS: Mounted root (%s filesystem)%s.\n",
 224               current->fs->pwd.mnt->mnt_sb->s_type->name,
 225               current->fs->pwd.mnt->mnt_sb->s_flags & MS_RDONLY ?
 226               " readonly" : "");
 227        return 0;
 228}
 229
 230void __init mount_block_root(char *name, int flags)
 231{
 232        char *fs_names = __getname();
 233        char *p;
 234#ifdef CONFIG_BLOCK
 235        char b[BDEVNAME_SIZE];
 236#else
 237        const char *b = name;
 238#endif
 239
 240        get_fs_names(fs_names);
 241retry:
 242        for (p = fs_names; *p; p += strlen(p)+1) {
 243                int err = do_mount_root(name, p, flags, root_mount_data);
 244                switch (err) {
 245                        case 0:
 246                                goto out;
 247                        case -EACCES:
 248                                flags |= MS_RDONLY;
 249                                goto retry;
 250                        case -EINVAL:
 251                                continue;
 252                }
 253                /*
 254                 * Allow the user to distinguish between failed sys_open
 255                 * and bad superblock on root device.
 256                 * and give them a list of the available devices
 257                 */
 258#ifdef CONFIG_BLOCK
 259                __bdevname(ROOT_DEV, b);
 260#endif
 261                printk("VFS: Cannot open root device \"%s\" or %s\n",
 262                                root_device_name, b);
 263                printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
 264
 265                printk_all_partitions();
 266                panic("VFS: Unable to mount root fs on %s", b);
 267        }
 268
 269        printk("List of all partitions:\n");
 270        printk_all_partitions();
 271        printk("No filesystem could mount root, tried: ");
 272        for (p = fs_names; *p; p += strlen(p)+1)
 273                printk(" %s", p);
 274        printk("\n");
 275#ifdef CONFIG_BLOCK
 276        __bdevname(ROOT_DEV, b);
 277#endif
 278        panic("VFS: Unable to mount root fs on %s", b);
 279out:
 280        putname(fs_names);
 281}
 282 
 283#ifdef CONFIG_ROOT_NFS
 284static int __init mount_nfs_root(void)
 285{
 286        void *data = nfs_root_data();
 287
 288        create_dev("/dev/root", ROOT_DEV);
 289        if (data &&
 290            do_mount_root("/dev/root", "nfs", root_mountflags, data) == 0)
 291                return 1;
 292        return 0;
 293}
 294#endif
 295
 296#if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
 297void __init change_floppy(char *fmt, ...)
 298{
 299        struct termios termios;
 300        char buf[80];
 301        char c;
 302        int fd;
 303        va_list args;
 304        va_start(args, fmt);
 305        vsprintf(buf, fmt, args);
 306        va_end(args);
 307        fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0);
 308        if (fd >= 0) {
 309                sys_ioctl(fd, FDEJECT, 0);
 310                sys_close(fd);
 311        }
 312        printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
 313        fd = sys_open("/dev/console", O_RDWR, 0);
 314        if (fd >= 0) {
 315                sys_ioctl(fd, TCGETS, (long)&termios);
 316                termios.c_lflag &= ~ICANON;
 317                sys_ioctl(fd, TCSETSF, (long)&termios);
 318                sys_read(fd, &c, 1);
 319                termios.c_lflag |= ICANON;
 320                sys_ioctl(fd, TCSETSF, (long)&termios);
 321                sys_close(fd);
 322        }
 323}
 324#endif
 325
 326void __init mount_root(void)
 327{
 328#ifdef CONFIG_ROOT_NFS
 329        if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) {
 330                if (mount_nfs_root())
 331                        return;
 332
 333                printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
 334                ROOT_DEV = Root_FD0;
 335        }
 336#endif
 337#ifdef CONFIG_BLK_DEV_FD
 338        if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
 339                /* rd_doload is 2 for a dual initrd/ramload setup */
 340                if (rd_doload==2) {
 341                        if (rd_load_disk(1)) {
 342                                ROOT_DEV = Root_RAM1;
 343                                root_device_name = NULL;
 344                        }
 345                } else
 346                        change_floppy("root floppy");
 347        }
 348#endif
 349#ifdef CONFIG_BLOCK
 350        create_dev("/dev/root", ROOT_DEV);
 351        mount_block_root("/dev/root", root_mountflags);
 352#endif
 353}
 354
 355/*
 356 * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
 357 */
 358void __init prepare_namespace(void)
 359{
 360        int is_floppy;
 361
 362        if (root_delay) {
 363                printk(KERN_INFO "Waiting %dsec before mounting root device...\n",
 364                       root_delay);
 365                ssleep(root_delay);
 366        }
 367
 368        /* wait for the known devices to complete their probing */
 369        while (driver_probe_done() != 0)
 370                msleep(100);
 371
 372        md_run_setup();
 373
 374        if (saved_root_name[0]) {
 375                root_device_name = saved_root_name;
 376                if (!strncmp(root_device_name, "mtd", 3) ||
 377                    !strncmp(root_device_name, "ubi", 3)) {
 378                        mount_block_root(root_device_name, root_mountflags);
 379                        goto out;
 380                }
 381                ROOT_DEV = name_to_dev_t(root_device_name);
 382                if (strncmp(root_device_name, "/dev/", 5) == 0)
 383                        root_device_name += 5;
 384        }
 385
 386        if (initrd_load())
 387                goto out;
 388
 389        /* wait for any asynchronous scanning to complete */
 390        if ((ROOT_DEV == 0) && root_wait) {
 391                printk(KERN_INFO "Waiting for root device %s...\n",
 392                        saved_root_name);
 393                while (driver_probe_done() != 0 ||
 394                        (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
 395                        msleep(100);
 396        }
 397
 398        is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
 399
 400        if (is_floppy && rd_doload && rd_load_disk(0))
 401                ROOT_DEV = Root_RAM0;
 402
 403        mount_root();
 404out:
 405        sys_mount(".", "/", NULL, MS_MOVE, NULL);
 406        sys_chroot(".");
 407}
 408
 409