Root/init/do_mounts.c

1/*
2 * Many of the syscalls used in this file expect some of the arguments
3 * to be __user pointers not __kernel pointers. To limit the sparse
4 * noise, turn off sparse checking for this file.
5 */
6#ifdef __CHECKER__
7#undef __CHECKER__
8#warning "Sparse checking disabled for this file"
9#endif
10
11#include <linux/module.h>
12#include <linux/sched.h>
13#include <linux/ctype.h>
14#include <linux/fd.h>
15#include <linux/tty.h>
16#include <linux/suspend.h>
17#include <linux/root_dev.h>
18#include <linux/security.h>
19#include <linux/delay.h>
20#include <linux/genhd.h>
21#include <linux/mount.h>
22#include <linux/device.h>
23#include <linux/init.h>
24#include <linux/fs.h>
25#include <linux/initrd.h>
26#include <linux/async.h>
27#include <linux/fs_struct.h>
28#include <linux/slab.h>
29#include <linux/ramfs.h>
30#include <linux/shmem_fs.h>
31
32#include <linux/nfs_fs.h>
33#include <linux/nfs_fs_sb.h>
34#include <linux/nfs_mount.h>
35
36#include "do_mounts.h"
37
38int __initdata rd_doload; /* 1 = load RAM disk, 0 = don't load */
39
40int root_mountflags = MS_RDONLY | MS_SILENT;
41static char * __initdata root_device_name;
42static char __initdata saved_root_name[64];
43static int root_wait;
44
45dev_t ROOT_DEV;
46
47static int __init load_ramdisk(char *str)
48{
49    rd_doload = simple_strtol(str,NULL,0) & 3;
50    return 1;
51}
52__setup("load_ramdisk=", load_ramdisk);
53
54static int __init readonly(char *str)
55{
56    if (*str)
57        return 0;
58    root_mountflags |= MS_RDONLY;
59    return 1;
60}
61
62static int __init readwrite(char *str)
63{
64    if (*str)
65        return 0;
66    root_mountflags &= ~MS_RDONLY;
67    return 1;
68}
69
70__setup("ro", readonly);
71__setup("rw", readwrite);
72
73#ifdef CONFIG_BLOCK
74struct uuidcmp {
75    const char *uuid;
76    int len;
77};
78
79/**
80 * match_dev_by_uuid - callback for finding a partition using its uuid
81 * @dev: device passed in by the caller
82 * @data: opaque pointer to the desired struct uuidcmp to match
83 *
84 * Returns 1 if the device matches, and 0 otherwise.
85 */
86static int match_dev_by_uuid(struct device *dev, const void *data)
87{
88    const struct uuidcmp *cmp = data;
89    struct hd_struct *part = dev_to_part(dev);
90
91    if (!part->info)
92        goto no_match;
93
94    if (strncasecmp(cmp->uuid, part->info->uuid, cmp->len))
95        goto no_match;
96
97    return 1;
98no_match:
99    return 0;
100}
101
102
103/**
104 * devt_from_partuuid - looks up the dev_t of a partition by its UUID
105 * @uuid: char array containing ascii UUID
106 *
107 * The function will return the first partition which contains a matching
108 * UUID value in its partition_meta_info struct. This does not search
109 * by filesystem UUIDs.
110 *
111 * If @uuid is followed by a "/PARTNROFF=%d", then the number will be
112 * extracted and used as an offset from the partition identified by the UUID.
113 *
114 * Returns the matching dev_t on success or 0 on failure.
115 */
116static dev_t devt_from_partuuid(const char *uuid_str)
117{
118    dev_t res = 0;
119    struct uuidcmp cmp;
120    struct device *dev = NULL;
121    struct gendisk *disk;
122    struct hd_struct *part;
123    int offset = 0;
124    bool clear_root_wait = false;
125    char *slash;
126
127    cmp.uuid = uuid_str;
128
129    slash = strchr(uuid_str, '/');
130    /* Check for optional partition number offset attributes. */
131    if (slash) {
132        char c = 0;
133        /* Explicitly fail on poor PARTUUID syntax. */
134        if (sscanf(slash + 1,
135               "PARTNROFF=%d%c", &offset, &c) != 1) {
136            clear_root_wait = true;
137            goto done;
138        }
139        cmp.len = slash - uuid_str;
140    } else {
141        cmp.len = strlen(uuid_str);
142    }
143
144    if (!cmp.len) {
145        clear_root_wait = true;
146        goto done;
147    }
148
149    dev = class_find_device(&block_class, NULL, &cmp,
150                &match_dev_by_uuid);
151    if (!dev)
152        goto done;
153
154    res = dev->devt;
155
156    /* Attempt to find the partition by offset. */
157    if (!offset)
158        goto no_offset;
159
160    res = 0;
161    disk = part_to_disk(dev_to_part(dev));
162    part = disk_get_part(disk, dev_to_part(dev)->partno + offset);
163    if (part) {
164        res = part_devt(part);
165        put_device(part_to_dev(part));
166    }
167
168no_offset:
169    put_device(dev);
170done:
171    if (clear_root_wait) {
172        pr_err("VFS: PARTUUID= is invalid.\n"
173               "Expected PARTUUID=<valid-uuid-id>[/PARTNROFF=%%d]\n");
174        if (root_wait)
175            pr_err("Disabling rootwait; root= is invalid.\n");
176        root_wait = 0;
177    }
178    return res;
179}
180#endif
181
182/*
183 * Convert a name into device number. We accept the following variants:
184 *
185 * 1) device number in hexadecimal represents itself
186 * 2) /dev/nfs represents Root_NFS (0xff)
187 * 3) /dev/<disk_name> represents the device number of disk
188 * 4) /dev/<disk_name><decimal> represents the device number
189 * of partition - device number of disk plus the partition number
190 * 5) /dev/<disk_name>p<decimal> - same as the above, that form is
191 * used when disk name of partitioned disk ends on a digit.
192 * 6) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
193 * unique id of a partition if the partition table provides it.
194 * The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
195 * partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
196 * filled hex representation of the 32-bit "NT disk signature", and PP
197 * is a zero-filled hex representation of the 1-based partition number.
198 * 7) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
199 * a partition with a known unique id.
200 *
201 * If name doesn't have fall into the categories above, we return (0,0).
202 * block_class is used to check if something is a disk name. If the disk
203 * name contains slashes, the device name has them replaced with
204 * bangs.
205 */
206
207dev_t name_to_dev_t(char *name)
208{
209    char s[32];
210    char *p;
211    dev_t res = 0;
212    int part;
213
214#ifdef CONFIG_BLOCK
215    if (strncmp(name, "PARTUUID=", 9) == 0) {
216        name += 9;
217        res = devt_from_partuuid(name);
218        if (!res)
219            goto fail;
220        goto done;
221    }
222#endif
223
224    if (strncmp(name, "/dev/", 5) != 0) {
225        unsigned maj, min;
226
227        if (sscanf(name, "%u:%u", &maj, &min) == 2) {
228            res = MKDEV(maj, min);
229            if (maj != MAJOR(res) || min != MINOR(res))
230                goto fail;
231        } else {
232            res = new_decode_dev(simple_strtoul(name, &p, 16));
233            if (*p)
234                goto fail;
235        }
236        goto done;
237    }
238
239    name += 5;
240    res = Root_NFS;
241    if (strcmp(name, "nfs") == 0)
242        goto done;
243    res = Root_RAM0;
244    if (strcmp(name, "ram") == 0)
245        goto done;
246
247    if (strlen(name) > 31)
248        goto fail;
249    strcpy(s, name);
250    for (p = s; *p; p++)
251        if (*p == '/')
252            *p = '!';
253    res = blk_lookup_devt(s, 0);
254    if (res)
255        goto done;
256
257    /*
258     * try non-existent, but valid partition, which may only exist
259     * after revalidating the disk, like partitioned md devices
260     */
261    while (p > s && isdigit(p[-1]))
262        p--;
263    if (p == s || !*p || *p == '0')
264        goto fail;
265
266    /* try disk name without <part number> */
267    part = simple_strtoul(p, NULL, 10);
268    *p = '\0';
269    res = blk_lookup_devt(s, part);
270    if (res)
271        goto done;
272
273    /* try disk name without p<part number> */
274    if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
275        goto fail;
276    p[-1] = '\0';
277    res = blk_lookup_devt(s, part);
278    if (res)
279        goto done;
280
281fail:
282    return 0;
283done:
284    return res;
285}
286
287static int __init root_dev_setup(char *line)
288{
289    strlcpy(saved_root_name, line, sizeof(saved_root_name));
290    return 1;
291}
292
293__setup("root=", root_dev_setup);
294
295static int __init rootwait_setup(char *str)
296{
297    if (*str)
298        return 0;
299    root_wait = 1;
300    return 1;
301}
302
303__setup("rootwait", rootwait_setup);
304
305static char * __initdata root_mount_data;
306static int __init root_data_setup(char *str)
307{
308    root_mount_data = str;
309    return 1;
310}
311
312static char * __initdata root_fs_names;
313static int __init fs_names_setup(char *str)
314{
315    root_fs_names = str;
316    return 1;
317}
318
319static unsigned int __initdata root_delay;
320static int __init root_delay_setup(char *str)
321{
322    root_delay = simple_strtoul(str, NULL, 0);
323    return 1;
324}
325
326__setup("rootflags=", root_data_setup);
327__setup("rootfstype=", fs_names_setup);
328__setup("rootdelay=", root_delay_setup);
329
330static void __init get_fs_names(char *page)
331{
332    char *s = page;
333
334    if (root_fs_names) {
335        strcpy(page, root_fs_names);
336        while (*s++) {
337            if (s[-1] == ',')
338                s[-1] = '\0';
339        }
340    } else {
341        int len = get_filesystem_list(page);
342        char *p, *next;
343
344        page[len] = '\0';
345        for (p = page-1; p; p = next) {
346            next = strchr(++p, '\n');
347            if (*p++ != '\t')
348                continue;
349            while ((*s++ = *p++) != '\n')
350                ;
351            s[-1] = '\0';
352        }
353    }
354    *s = '\0';
355}
356
357static int __init do_mount_root(char *name, char *fs, int flags, void *data)
358{
359    struct super_block *s;
360    int err = sys_mount(name, "/root", fs, flags, data);
361    if (err)
362        return err;
363
364    sys_chdir("/root");
365    s = current->fs->pwd.dentry->d_sb;
366    ROOT_DEV = s->s_dev;
367    printk(KERN_INFO
368           "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
369           s->s_type->name,
370           s->s_flags & MS_RDONLY ? " readonly" : "",
371           MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
372    return 0;
373}
374
375void __init mount_block_root(char *name, int flags)
376{
377    struct page *page = alloc_page(GFP_KERNEL |
378                    __GFP_NOTRACK_FALSE_POSITIVE);
379    char *fs_names = page_address(page);
380    char *p;
381#ifdef CONFIG_BLOCK
382    char b[BDEVNAME_SIZE];
383#else
384    const char *b = name;
385#endif
386
387    get_fs_names(fs_names);
388retry:
389    for (p = fs_names; *p; p += strlen(p)+1) {
390        int err = do_mount_root(name, p, flags, root_mount_data);
391        switch (err) {
392            case 0:
393                goto out;
394            case -EACCES:
395                flags |= MS_RDONLY;
396                goto retry;
397            case -EINVAL:
398                continue;
399        }
400            /*
401         * Allow the user to distinguish between failed sys_open
402         * and bad superblock on root device.
403         * and give them a list of the available devices
404         */
405#ifdef CONFIG_BLOCK
406        __bdevname(ROOT_DEV, b);
407#endif
408        printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
409                root_device_name, b, err);
410        printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
411
412        printk_all_partitions();
413#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
414        printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
415               "explicit textual name for \"root=\" boot option.\n");
416#endif
417        panic("VFS: Unable to mount root fs on %s", b);
418    }
419
420    printk("List of all partitions:\n");
421    printk_all_partitions();
422    printk("No filesystem could mount root, tried: ");
423    for (p = fs_names; *p; p += strlen(p)+1)
424        printk(" %s", p);
425    printk("\n");
426#ifdef CONFIG_BLOCK
427    __bdevname(ROOT_DEV, b);
428#endif
429    panic("VFS: Unable to mount root fs on %s", b);
430out:
431    put_page(page);
432}
433 
434#ifdef CONFIG_ROOT_NFS
435
436#define NFSROOT_TIMEOUT_MIN 5
437#define NFSROOT_TIMEOUT_MAX 30
438#define NFSROOT_RETRY_MAX 5
439
440static int __init mount_nfs_root(void)
441{
442    char *root_dev, *root_data;
443    unsigned int timeout;
444    int try, err;
445
446    err = nfs_root_data(&root_dev, &root_data);
447    if (err != 0)
448        return 0;
449
450    /*
451     * The server or network may not be ready, so try several
452     * times. Stop after a few tries in case the client wants
453     * to fall back to other boot methods.
454     */
455    timeout = NFSROOT_TIMEOUT_MIN;
456    for (try = 1; ; try++) {
457        err = do_mount_root(root_dev, "nfs",
458                    root_mountflags, root_data);
459        if (err == 0)
460            return 1;
461        if (try > NFSROOT_RETRY_MAX)
462            break;
463
464        /* Wait, in case the server refused us immediately */
465        ssleep(timeout);
466        timeout <<= 1;
467        if (timeout > NFSROOT_TIMEOUT_MAX)
468            timeout = NFSROOT_TIMEOUT_MAX;
469    }
470    return 0;
471}
472#endif
473
474#if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
475void __init change_floppy(char *fmt, ...)
476{
477    struct termios termios;
478    char buf[80];
479    char c;
480    int fd;
481    va_list args;
482    va_start(args, fmt);
483    vsprintf(buf, fmt, args);
484    va_end(args);
485    fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0);
486    if (fd >= 0) {
487        sys_ioctl(fd, FDEJECT, 0);
488        sys_close(fd);
489    }
490    printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
491    fd = sys_open("/dev/console", O_RDWR, 0);
492    if (fd >= 0) {
493        sys_ioctl(fd, TCGETS, (long)&termios);
494        termios.c_lflag &= ~ICANON;
495        sys_ioctl(fd, TCSETSF, (long)&termios);
496        sys_read(fd, &c, 1);
497        termios.c_lflag |= ICANON;
498        sys_ioctl(fd, TCSETSF, (long)&termios);
499        sys_close(fd);
500    }
501}
502#endif
503
504void __init mount_root(void)
505{
506#ifdef CONFIG_ROOT_NFS
507    if (ROOT_DEV == Root_NFS) {
508        if (mount_nfs_root())
509            return;
510
511        printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
512        ROOT_DEV = Root_FD0;
513    }
514#endif
515#ifdef CONFIG_BLK_DEV_FD
516    if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
517        /* rd_doload is 2 for a dual initrd/ramload setup */
518        if (rd_doload==2) {
519            if (rd_load_disk(1)) {
520                ROOT_DEV = Root_RAM1;
521                root_device_name = NULL;
522            }
523        } else
524            change_floppy("root floppy");
525    }
526#endif
527#ifdef CONFIG_BLOCK
528    create_dev("/dev/root", ROOT_DEV);
529    mount_block_root("/dev/root", root_mountflags);
530#endif
531}
532
533/*
534 * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
535 */
536void __init prepare_namespace(void)
537{
538    int is_floppy;
539
540    if (root_delay) {
541        printk(KERN_INFO "Waiting %d sec before mounting root device...\n",
542               root_delay);
543        ssleep(root_delay);
544    }
545
546    /*
547     * wait for the known devices to complete their probing
548     *
549     * Note: this is a potential source of long boot delays.
550     * For example, it is not atypical to wait 5 seconds here
551     * for the touchpad of a laptop to initialize.
552     */
553    wait_for_device_probe();
554
555    md_run_setup();
556
557    if (saved_root_name[0]) {
558        root_device_name = saved_root_name;
559        if (!strncmp(root_device_name, "mtd", 3) ||
560            !strncmp(root_device_name, "ubi", 3)) {
561            mount_block_root(root_device_name, root_mountflags);
562            goto out;
563        }
564        ROOT_DEV = name_to_dev_t(root_device_name);
565        if (strncmp(root_device_name, "/dev/", 5) == 0)
566            root_device_name += 5;
567    }
568
569    if (initrd_load())
570        goto out;
571
572    /* wait for any asynchronous scanning to complete */
573    if ((ROOT_DEV == 0) && root_wait) {
574        printk(KERN_INFO "Waiting for root device %s...\n",
575            saved_root_name);
576        while (driver_probe_done() != 0 ||
577            (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
578            msleep(100);
579        async_synchronize_full();
580    }
581
582    is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
583
584    if (is_floppy && rd_doload && rd_load_disk(0))
585        ROOT_DEV = Root_RAM0;
586
587    mount_root();
588out:
589    devtmpfs_mount("dev");
590    sys_mount(".", "/", NULL, MS_MOVE, NULL);
591    sys_chroot(".");
592}
593
594static bool is_tmpfs;
595static struct dentry *rootfs_mount(struct file_system_type *fs_type,
596    int flags, const char *dev_name, void *data)
597{
598    static unsigned long once;
599    void *fill = ramfs_fill_super;
600
601    if (test_and_set_bit(0, &once))
602        return ERR_PTR(-ENODEV);
603
604    if (IS_ENABLED(CONFIG_TMPFS) && is_tmpfs)
605        fill = shmem_fill_super;
606
607    return mount_nodev(fs_type, flags, data, fill);
608}
609
610static struct file_system_type rootfs_fs_type = {
611    .name = "rootfs",
612    .mount = rootfs_mount,
613    .kill_sb = kill_litter_super,
614};
615
616int __init init_rootfs(void)
617{
618    int err = register_filesystem(&rootfs_fs_type);
619
620    if (err)
621        return err;
622
623    if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
624        (!root_fs_names || strstr(root_fs_names, "tmpfs"))) {
625        err = shmem_init();
626        is_tmpfs = true;
627    } else {
628        err = init_ramfs_fs();
629    }
630
631    if (err)
632        unregister_filesystem(&rootfs_fs_type);
633
634    return err;
635}
636

Archive Download this file



interactive