1
2
3
4
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;
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
81
82
83
84
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
105
106
107
108
109
110
111
112
113
114
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
131 if (slash) {
132 char c = 0;
133
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
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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210dev_t name_to_dev_t(const char *name)
211{
212 char s[32];
213 char *p;
214 dev_t res = 0;
215 int part;
216
217#ifdef CONFIG_BLOCK
218 if (strncmp(name, "PARTUUID=", 9) == 0) {
219 name += 9;
220 res = devt_from_partuuid(name);
221 if (!res)
222 goto fail;
223 goto done;
224 }
225#endif
226
227 if (strncmp(name, "/dev/", 5) != 0) {
228 unsigned maj, min, offset;
229 char dummy;
230
231 if ((sscanf(name, "%u:%u%c", &maj, &min, &dummy) == 2) ||
232 (sscanf(name, "%u:%u:%u:%c", &maj, &min, &offset, &dummy) == 3)) {
233 res = MKDEV(maj, min);
234 if (maj != MAJOR(res) || min != MINOR(res))
235 goto fail;
236 } else {
237 res = new_decode_dev(simple_strtoul(name, &p, 16));
238 if (*p)
239 goto fail;
240 }
241 goto done;
242 }
243
244 name += 5;
245 res = Root_NFS;
246 if (strcmp(name, "nfs") == 0)
247 goto done;
248 res = Root_RAM0;
249 if (strcmp(name, "ram") == 0)
250 goto done;
251
252 if (strlen(name) > 31)
253 goto fail;
254 strcpy(s, name);
255 for (p = s; *p; p++)
256 if (*p == '/')
257 *p = '!';
258 res = blk_lookup_devt(s, 0);
259 if (res)
260 goto done;
261
262
263
264
265
266 while (p > s && isdigit(p[-1]))
267 p--;
268 if (p == s || !*p || *p == '0')
269 goto fail;
270
271
272 part = simple_strtoul(p, NULL, 10);
273 *p = '\0';
274 res = blk_lookup_devt(s, part);
275 if (res)
276 goto done;
277
278
279 if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
280 goto fail;
281 p[-1] = '\0';
282 res = blk_lookup_devt(s, part);
283 if (res)
284 goto done;
285
286fail:
287 return 0;
288done:
289 return res;
290}
291EXPORT_SYMBOL_GPL(name_to_dev_t);
292
293static int __init root_dev_setup(char *line)
294{
295 strlcpy(saved_root_name, line, sizeof(saved_root_name));
296 return 1;
297}
298
299__setup("root=", root_dev_setup);
300
301static int __init rootwait_setup(char *str)
302{
303 if (*str)
304 return 0;
305 root_wait = 1;
306 return 1;
307}
308
309__setup("rootwait", rootwait_setup);
310
311static char * __initdata root_mount_data;
312static int __init root_data_setup(char *str)
313{
314 root_mount_data = str;
315 return 1;
316}
317
318static char * __initdata root_fs_names;
319static int __init fs_names_setup(char *str)
320{
321 root_fs_names = str;
322 return 1;
323}
324
325static unsigned int __initdata root_delay;
326static int __init root_delay_setup(char *str)
327{
328 root_delay = simple_strtoul(str, NULL, 0);
329 return 1;
330}
331
332__setup("rootflags=", root_data_setup);
333__setup("rootfstype=", fs_names_setup);
334__setup("rootdelay=", root_delay_setup);
335
336static void __init get_fs_names(char *page)
337{
338 char *s = page;
339
340 if (root_fs_names) {
341 strcpy(page, root_fs_names);
342 while (*s++) {
343 if (s[-1] == ',')
344 s[-1] = '\0';
345 }
346 } else {
347 int len = get_filesystem_list(page);
348 char *p, *next;
349
350 page[len] = '\0';
351 for (p = page-1; p; p = next) {
352 next = strchr(++p, '\n');
353 if (*p++ != '\t')
354 continue;
355 while ((*s++ = *p++) != '\n')
356 ;
357 s[-1] = '\0';
358 }
359 }
360 *s = '\0';
361}
362
363static int __init do_mount_root(char *name, char *fs, int flags, void *data)
364{
365 struct super_block *s;
366 int err = ksys_mount(name, "/root", fs, flags, data);
367 if (err)
368 return err;
369
370 ksys_chdir("/root");
371 s = current->fs->pwd.dentry->d_sb;
372 ROOT_DEV = s->s_dev;
373 printk(KERN_INFO
374 "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
375 s->s_type->name,
376 sb_rdonly(s) ? " readonly" : "",
377 MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
378 return 0;
379}
380
381void __init mount_block_root(char *name, int flags)
382{
383 struct page *page = alloc_page(GFP_KERNEL);
384 char *fs_names = page_address(page);
385 char *p;
386#ifdef CONFIG_BLOCK
387 char b[BDEVNAME_SIZE];
388#else
389 const char *b = name;
390#endif
391
392 get_fs_names(fs_names);
393retry:
394 for (p = fs_names; *p; p += strlen(p)+1) {
395 int err = do_mount_root(name, p, flags, root_mount_data);
396 switch (err) {
397 case 0:
398 goto out;
399 case -EACCES:
400 case -EINVAL:
401 continue;
402 }
403
404
405
406
407
408#ifdef CONFIG_BLOCK
409 __bdevname(ROOT_DEV, b);
410#endif
411 printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
412 root_device_name, b, err);
413 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
414
415 printk_all_partitions();
416#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
417 printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
418 "explicit textual name for \"root=\" boot option.\n");
419#endif
420 panic("VFS: Unable to mount root fs on %s", b);
421 }
422 if (!(flags & SB_RDONLY)) {
423 flags |= SB_RDONLY;
424 goto retry;
425 }
426
427 printk("List of all partitions:\n");
428 printk_all_partitions();
429 printk("No filesystem could mount root, tried: ");
430 for (p = fs_names; *p; p += strlen(p)+1)
431 printk(" %s", p);
432 printk("\n");
433#ifdef CONFIG_BLOCK
434 __bdevname(ROOT_DEV, b);
435#endif
436 panic("VFS: Unable to mount root fs on %s", b);
437out:
438 put_page(page);
439}
440
441#ifdef CONFIG_ROOT_NFS
442
443#define NFSROOT_TIMEOUT_MIN 5
444#define NFSROOT_TIMEOUT_MAX 30
445#define NFSROOT_RETRY_MAX 5
446
447static int __init mount_nfs_root(void)
448{
449 char *root_dev, *root_data;
450 unsigned int timeout;
451 int try, err;
452
453 err = nfs_root_data(&root_dev, &root_data);
454 if (err != 0)
455 return 0;
456
457
458
459
460
461
462 timeout = NFSROOT_TIMEOUT_MIN;
463 for (try = 1; ; try++) {
464 err = do_mount_root(root_dev, "nfs",
465 root_mountflags, root_data);
466 if (err == 0)
467 return 1;
468 if (try > NFSROOT_RETRY_MAX)
469 break;
470
471
472 ssleep(timeout);
473 timeout <<= 1;
474 if (timeout > NFSROOT_TIMEOUT_MAX)
475 timeout = NFSROOT_TIMEOUT_MAX;
476 }
477 return 0;
478}
479#endif
480
481#if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
482void __init change_floppy(char *fmt, ...)
483{
484 struct termios termios;
485 char buf[80];
486 char c;
487 int fd;
488 va_list args;
489 va_start(args, fmt);
490 vsprintf(buf, fmt, args);
491 va_end(args);
492 fd = ksys_open("/dev/root", O_RDWR | O_NDELAY, 0);
493 if (fd >= 0) {
494 ksys_ioctl(fd, FDEJECT, 0);
495 ksys_close(fd);
496 }
497 printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
498 fd = ksys_open("/dev/console", O_RDWR, 0);
499 if (fd >= 0) {
500 ksys_ioctl(fd, TCGETS, (long)&termios);
501 termios.c_lflag &= ~ICANON;
502 ksys_ioctl(fd, TCSETSF, (long)&termios);
503 ksys_read(fd, &c, 1);
504 termios.c_lflag |= ICANON;
505 ksys_ioctl(fd, TCSETSF, (long)&termios);
506 ksys_close(fd);
507 }
508}
509#endif
510
511void __init mount_root(void)
512{
513#ifdef CONFIG_ROOT_NFS
514 if (ROOT_DEV == Root_NFS) {
515 if (mount_nfs_root())
516 return;
517
518 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
519 ROOT_DEV = Root_FD0;
520 }
521#endif
522#ifdef CONFIG_BLK_DEV_FD
523 if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
524
525 if (rd_doload==2) {
526 if (rd_load_disk(1)) {
527 ROOT_DEV = Root_RAM1;
528 root_device_name = NULL;
529 }
530 } else
531 change_floppy("root floppy");
532 }
533#endif
534#ifdef CONFIG_BLOCK
535 {
536 int err = create_dev("/dev/root", ROOT_DEV);
537
538 if (err < 0)
539 pr_emerg("Failed to create /dev/root: %d\n", err);
540 mount_block_root("/dev/root", root_mountflags);
541 }
542#endif
543}
544
545
546
547
548void __init prepare_namespace(void)
549{
550 int is_floppy;
551
552 if (root_delay) {
553 printk(KERN_INFO "Waiting %d sec before mounting root device...\n",
554 root_delay);
555 ssleep(root_delay);
556 }
557
558
559
560
561
562
563
564
565 wait_for_device_probe();
566
567 md_run_setup();
568
569 if (saved_root_name[0]) {
570 root_device_name = saved_root_name;
571 if (!strncmp(root_device_name, "mtd", 3) ||
572 !strncmp(root_device_name, "ubi", 3)) {
573 mount_block_root(root_device_name, root_mountflags);
574 goto out;
575 }
576 ROOT_DEV = name_to_dev_t(root_device_name);
577 if (strncmp(root_device_name, "/dev/", 5) == 0)
578 root_device_name += 5;
579 }
580
581 if (initrd_load())
582 goto out;
583
584
585 if ((ROOT_DEV == 0) && root_wait) {
586 printk(KERN_INFO "Waiting for root device %s...\n",
587 saved_root_name);
588 while (driver_probe_done() != 0 ||
589 (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
590 msleep(5);
591 async_synchronize_full();
592 }
593
594 is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
595
596 if (is_floppy && rd_doload && rd_load_disk(0))
597 ROOT_DEV = Root_RAM0;
598
599 mount_root();
600out:
601 devtmpfs_mount("dev");
602 ksys_mount(".", "/", NULL, MS_MOVE, NULL);
603 ksys_chroot(".");
604}
605
606static bool is_tmpfs;
607static struct dentry *rootfs_mount(struct file_system_type *fs_type,
608 int flags, const char *dev_name, void *data)
609{
610 static unsigned long once;
611 void *fill = ramfs_fill_super;
612
613 if (test_and_set_bit(0, &once))
614 return ERR_PTR(-ENODEV);
615
616 if (IS_ENABLED(CONFIG_TMPFS) && is_tmpfs)
617 fill = shmem_fill_super;
618
619 return mount_nodev(fs_type, flags, data, fill);
620}
621
622static struct file_system_type rootfs_fs_type = {
623 .name = "rootfs",
624 .mount = rootfs_mount,
625 .kill_sb = kill_litter_super,
626};
627
628int __init init_rootfs(void)
629{
630 int err = register_filesystem(&rootfs_fs_type);
631
632 if (err)
633 return err;
634
635 if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
636 (!root_fs_names || strstr(root_fs_names, "tmpfs"))) {
637 err = shmem_init();
638 is_tmpfs = true;
639 } else {
640 err = init_ramfs_fs();
641 }
642
643 if (err)
644 unregister_filesystem(&rootfs_fs_type);
645
646 return err;
647}
648