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