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