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

Archive Download this file



interactive