1
2#include <linux/module.h>
3#include <linux/sched.h>
4#include <linux/ctype.h>
5#include <linux/fd.h>
6#include <linux/tty.h>
7#include <linux/suspend.h>
8#include <linux/root_dev.h>
9#include <linux/security.h>
10#include <linux/delay.h>
11#include <linux/genhd.h>
12#include <linux/mount.h>
13#include <linux/device.h>
14#include <linux/init.h>
15#include <linux/fs.h>
16#include <linux/initrd.h>
17#include <linux/async.h>
18#include <linux/fs_struct.h>
19#include <linux/slab.h>
20#include <linux/ramfs.h>
21#include <linux/shmem_fs.h>
22
23#include <linux/nfs_fs.h>
24#include <linux/nfs_fs_sb.h>
25#include <linux/nfs_mount.h>
26#include <linux/raid/detect.h>
27#include <uapi/linux/mount.h>
28
29#include "do_mounts.h"
30
31int root_mountflags = MS_RDONLY | MS_SILENT;
32static char * __initdata root_device_name;
33static char __initdata saved_root_name[64];
34static int root_wait;
35
36dev_t ROOT_DEV;
37
38static int __init load_ramdisk(char *str)
39{
40 pr_warn("ignoring the deprecated load_ramdisk= option\n");
41 return 1;
42}
43__setup("load_ramdisk=", load_ramdisk);
44
45static int __init readonly(char *str)
46{
47 if (*str)
48 return 0;
49 root_mountflags |= MS_RDONLY;
50 return 1;
51}
52
53static int __init readwrite(char *str)
54{
55 if (*str)
56 return 0;
57 root_mountflags &= ~MS_RDONLY;
58 return 1;
59}
60
61__setup("ro", readonly);
62__setup("rw", readwrite);
63
64#ifdef CONFIG_BLOCK
65struct uuidcmp {
66 const char *uuid;
67 int len;
68};
69
70
71
72
73
74
75
76
77static int match_dev_by_uuid(struct device *dev, const void *data)
78{
79 struct block_device *bdev = dev_to_bdev(dev);
80 const struct uuidcmp *cmp = data;
81
82 if (!bdev->bd_meta_info ||
83 strncasecmp(cmp->uuid, bdev->bd_meta_info->uuid, cmp->len))
84 return 0;
85 return 1;
86}
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101static dev_t devt_from_partuuid(const char *uuid_str)
102{
103 struct uuidcmp cmp;
104 struct device *dev = NULL;
105 dev_t devt = 0;
106 int offset = 0;
107 char *slash;
108
109 cmp.uuid = uuid_str;
110
111 slash = strchr(uuid_str, '/');
112
113 if (slash) {
114 char c = 0;
115
116
117 if (sscanf(slash + 1, "PARTNROFF=%d%c", &offset, &c) != 1)
118 goto clear_root_wait;
119 cmp.len = slash - uuid_str;
120 } else {
121 cmp.len = strlen(uuid_str);
122 }
123
124 if (!cmp.len)
125 goto clear_root_wait;
126
127 dev = class_find_device(&block_class, NULL, &cmp, &match_dev_by_uuid);
128 if (!dev)
129 return 0;
130
131 if (offset) {
132
133
134
135
136 struct block_device *part;
137
138 part = bdget_disk(dev_to_disk(dev),
139 dev_to_bdev(dev)->bd_partno + offset);
140 if (part) {
141 devt = part->bd_dev;
142 bdput(part);
143 }
144 } else {
145 devt = dev->devt;
146 }
147
148 put_device(dev);
149 return devt;
150
151clear_root_wait:
152 pr_err("VFS: PARTUUID= is invalid.\n"
153 "Expected PARTUUID=<valid-uuid-id>[/PARTNROFF=%%d]\n");
154 if (root_wait)
155 pr_err("Disabling rootwait; root= is invalid.\n");
156 root_wait = 0;
157 return 0;
158}
159
160
161
162
163
164
165
166
167static int match_dev_by_label(struct device *dev, const void *data)
168{
169 struct block_device *bdev = dev_to_bdev(dev);
170 const char *label = data;
171
172 if (!bdev->bd_meta_info || strcmp(label, bdev->bd_meta_info->volname))
173 return 0;
174 return 1;
175}
176
177static dev_t devt_from_partlabel(const char *label)
178{
179 struct device *dev;
180 dev_t devt = 0;
181
182 dev = class_find_device(&block_class, NULL, label, &match_dev_by_label);
183 if (dev) {
184 devt = dev->devt;
185 put_device(dev);
186 }
187
188 return devt;
189}
190
191static dev_t devt_from_devname(const char *name)
192{
193 dev_t devt = 0;
194 int part;
195 char s[32];
196 char *p;
197
198 if (strlen(name) > 31)
199 return 0;
200 strcpy(s, name);
201 for (p = s; *p; p++) {
202 if (*p == '/')
203 *p = '!';
204 }
205
206 devt = blk_lookup_devt(s, 0);
207 if (devt)
208 return devt;
209
210
211
212
213
214 while (p > s && isdigit(p[-1]))
215 p--;
216 if (p == s || !*p || *p == '0')
217 return 0;
218
219
220 part = simple_strtoul(p, NULL, 10);
221 *p = '\0';
222 devt = blk_lookup_devt(s, part);
223 if (devt)
224 return devt;
225
226
227 if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
228 return 0;
229 p[-1] = '\0';
230 return blk_lookup_devt(s, part);
231}
232#endif
233
234static dev_t devt_from_devnum(const char *name)
235{
236 unsigned maj, min, offset;
237 dev_t devt = 0;
238 char *p, dummy;
239
240 if (sscanf(name, "%u:%u%c", &maj, &min, &dummy) == 2 ||
241 sscanf(name, "%u:%u:%u:%c", &maj, &min, &offset, &dummy) == 3) {
242 devt = MKDEV(maj, min);
243 if (maj != MAJOR(devt) || min != MINOR(devt))
244 return 0;
245 } else {
246 devt = new_decode_dev(simple_strtoul(name, &p, 16));
247 if (*p)
248 return 0;
249 }
250
251 return devt;
252}
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284dev_t name_to_dev_t(const char *name)
285{
286 if (strcmp(name, "/dev/nfs") == 0)
287 return Root_NFS;
288 if (strcmp(name, "/dev/cifs") == 0)
289 return Root_CIFS;
290 if (strcmp(name, "/dev/ram") == 0)
291 return Root_RAM0;
292#ifdef CONFIG_BLOCK
293 if (strncmp(name, "PARTUUID=", 9) == 0)
294 return devt_from_partuuid(name + 9);
295 if (strncmp(name, "PARTLABEL=", 10) == 0)
296 return devt_from_partlabel(name + 10);
297 if (strncmp(name, "/dev/", 5) == 0)
298 return devt_from_devname(name + 5);
299#endif
300 return devt_from_devnum(name);
301}
302EXPORT_SYMBOL_GPL(name_to_dev_t);
303
304static int __init root_dev_setup(char *line)
305{
306 strlcpy(saved_root_name, line, sizeof(saved_root_name));
307 return 1;
308}
309
310__setup("root=", root_dev_setup);
311
312static int __init rootwait_setup(char *str)
313{
314 if (*str)
315 return 0;
316 root_wait = 1;
317 return 1;
318}
319
320__setup("rootwait", rootwait_setup);
321
322static char * __initdata root_mount_data;
323static int __init root_data_setup(char *str)
324{
325 root_mount_data = str;
326 return 1;
327}
328
329static char * __initdata root_fs_names;
330static int __init fs_names_setup(char *str)
331{
332 root_fs_names = str;
333 return 1;
334}
335
336static unsigned int __initdata root_delay;
337static int __init root_delay_setup(char *str)
338{
339 root_delay = simple_strtoul(str, NULL, 0);
340 return 1;
341}
342
343__setup("rootflags=", root_data_setup);
344__setup("rootfstype=", fs_names_setup);
345__setup("rootdelay=", root_delay_setup);
346
347static void __init get_fs_names(char *page)
348{
349 char *s = page;
350
351 if (root_fs_names) {
352 strcpy(page, root_fs_names);
353 while (*s++) {
354 if (s[-1] == ',')
355 s[-1] = '\0';
356 }
357 } else {
358 int len = get_filesystem_list(page);
359 char *p, *next;
360
361 page[len] = '\0';
362 for (p = page-1; p; p = next) {
363 next = strchr(++p, '\n');
364 if (*p++ != '\t')
365 continue;
366 while ((*s++ = *p++) != '\n')
367 ;
368 s[-1] = '\0';
369 }
370 }
371 *s = '\0';
372}
373
374static int __init do_mount_root(const char *name, const char *fs,
375 const int flags, const void *data)
376{
377 struct super_block *s;
378 struct page *p = NULL;
379 char *data_page = NULL;
380 int ret;
381
382 if (data) {
383
384 p = alloc_page(GFP_KERNEL);
385 if (!p)
386 return -ENOMEM;
387 data_page = page_address(p);
388
389 strncpy(data_page, data, PAGE_SIZE);
390 }
391
392 ret = init_mount(name, "/root", fs, flags, data_page);
393 if (ret)
394 goto out;
395
396 init_chdir("/root");
397 s = current->fs->pwd.dentry->d_sb;
398 ROOT_DEV = s->s_dev;
399 printk(KERN_INFO
400 "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
401 s->s_type->name,
402 sb_rdonly(s) ? " readonly" : "",
403 MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
404
405out:
406 if (p)
407 put_page(p);
408 return ret;
409}
410
411void __init mount_block_root(char *name, int flags)
412{
413 struct page *page = alloc_page(GFP_KERNEL);
414 char *fs_names = page_address(page);
415 char *p;
416 char b[BDEVNAME_SIZE];
417
418 scnprintf(b, BDEVNAME_SIZE, "unknown-block(%u,%u)",
419 MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
420 get_fs_names(fs_names);
421retry:
422 for (p = fs_names; *p; p += strlen(p)+1) {
423 int err = do_mount_root(name, p, flags, root_mount_data);
424 switch (err) {
425 case 0:
426 goto out;
427 case -EACCES:
428 case -EINVAL:
429 continue;
430 }
431
432
433
434
435
436 printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
437 root_device_name, b, err);
438 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
439
440 printk_all_partitions();
441#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
442 printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
443 "explicit textual name for \"root=\" boot option.\n");
444#endif
445 panic("VFS: Unable to mount root fs on %s", b);
446 }
447 if (!(flags & SB_RDONLY)) {
448 flags |= SB_RDONLY;
449 goto retry;
450 }
451
452 printk("List of all partitions:\n");
453 printk_all_partitions();
454 printk("No filesystem could mount root, tried: ");
455 for (p = fs_names; *p; p += strlen(p)+1)
456 printk(" %s", p);
457 printk("\n");
458 panic("VFS: Unable to mount root fs on %s", b);
459out:
460 put_page(page);
461}
462
463#ifdef CONFIG_ROOT_NFS
464
465#define NFSROOT_TIMEOUT_MIN 5
466#define NFSROOT_TIMEOUT_MAX 30
467#define NFSROOT_RETRY_MAX 5
468
469static int __init mount_nfs_root(void)
470{
471 char *root_dev, *root_data;
472 unsigned int timeout;
473 int try, err;
474
475 err = nfs_root_data(&root_dev, &root_data);
476 if (err != 0)
477 return 0;
478
479
480
481
482
483
484 timeout = NFSROOT_TIMEOUT_MIN;
485 for (try = 1; ; try++) {
486 err = do_mount_root(root_dev, "nfs",
487 root_mountflags, root_data);
488 if (err == 0)
489 return 1;
490 if (try > NFSROOT_RETRY_MAX)
491 break;
492
493
494 ssleep(timeout);
495 timeout <<= 1;
496 if (timeout > NFSROOT_TIMEOUT_MAX)
497 timeout = NFSROOT_TIMEOUT_MAX;
498 }
499 return 0;
500}
501#endif
502
503#ifdef CONFIG_CIFS_ROOT
504
505extern int cifs_root_data(char **dev, char **opts);
506
507#define CIFSROOT_TIMEOUT_MIN 5
508#define CIFSROOT_TIMEOUT_MAX 30
509#define CIFSROOT_RETRY_MAX 5
510
511static int __init mount_cifs_root(void)
512{
513 char *root_dev, *root_data;
514 unsigned int timeout;
515 int try, err;
516
517 err = cifs_root_data(&root_dev, &root_data);
518 if (err != 0)
519 return 0;
520
521 timeout = CIFSROOT_TIMEOUT_MIN;
522 for (try = 1; ; try++) {
523 err = do_mount_root(root_dev, "cifs", root_mountflags,
524 root_data);
525 if (err == 0)
526 return 1;
527 if (try > CIFSROOT_RETRY_MAX)
528 break;
529
530 ssleep(timeout);
531 timeout <<= 1;
532 if (timeout > CIFSROOT_TIMEOUT_MAX)
533 timeout = CIFSROOT_TIMEOUT_MAX;
534 }
535 return 0;
536}
537#endif
538
539void __init mount_root(void)
540{
541#ifdef CONFIG_ROOT_NFS
542 if (ROOT_DEV == Root_NFS) {
543 if (!mount_nfs_root())
544 printk(KERN_ERR "VFS: Unable to mount root fs via NFS.\n");
545 return;
546 }
547#endif
548#ifdef CONFIG_CIFS_ROOT
549 if (ROOT_DEV == Root_CIFS) {
550 if (!mount_cifs_root())
551 printk(KERN_ERR "VFS: Unable to mount root fs via SMB.\n");
552 return;
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
568
569void __init prepare_namespace(void)
570{
571 if (root_delay) {
572 printk(KERN_INFO "Waiting %d sec before mounting root device...\n",
573 root_delay);
574 ssleep(root_delay);
575 }
576
577
578
579
580
581
582
583
584 wait_for_device_probe();
585
586 md_run_setup();
587
588 if (saved_root_name[0]) {
589 root_device_name = saved_root_name;
590 if (!strncmp(root_device_name, "mtd", 3) ||
591 !strncmp(root_device_name, "ubi", 3)) {
592 mount_block_root(root_device_name, root_mountflags);
593 goto out;
594 }
595 ROOT_DEV = name_to_dev_t(root_device_name);
596 if (strncmp(root_device_name, "/dev/", 5) == 0)
597 root_device_name += 5;
598 }
599
600 if (initrd_load())
601 goto out;
602
603
604 if ((ROOT_DEV == 0) && root_wait) {
605 printk(KERN_INFO "Waiting for root device %s...\n",
606 saved_root_name);
607 while (driver_probe_done() != 0 ||
608 (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
609 msleep(5);
610 async_synchronize_full();
611 }
612
613 mount_root();
614out:
615 devtmpfs_mount();
616 init_mount(".", "/", NULL, MS_MOVE, NULL);
617 init_chroot(".");
618}
619
620static bool is_tmpfs;
621static int rootfs_init_fs_context(struct fs_context *fc)
622{
623 if (IS_ENABLED(CONFIG_TMPFS) && is_tmpfs)
624 return shmem_init_fs_context(fc);
625
626 return ramfs_init_fs_context(fc);
627}
628
629struct file_system_type rootfs_fs_type = {
630 .name = "rootfs",
631 .init_fs_context = rootfs_init_fs_context,
632 .kill_sb = kill_litter_super,
633};
634
635void __init init_rootfs(void)
636{
637 if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
638 (!root_fs_names || strstr(root_fs_names, "tmpfs")))
639 is_tmpfs = true;
640}
641