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
load_ramdisk(char * str)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
readonly(char * str)44 static int __init readonly(char *str)
45 {
46 if (*str)
47 return 0;
48 root_mountflags |= MS_RDONLY;
49 return 1;
50 }
51
readwrite(char * str)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 */
match_dev_by_uuid(struct device * dev,const void * data)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 */
devt_from_partuuid(const char * uuid_str)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 #endif
171
172 /*
173 * Convert a name into device number. We accept the following variants:
174 *
175 * 1) <hex_major><hex_minor> device number in hexadecimal represents itself
176 * no leading 0x, for example b302.
177 * 2) /dev/nfs represents Root_NFS (0xff)
178 * 3) /dev/<disk_name> represents the device number of disk
179 * 4) /dev/<disk_name><decimal> represents the device number
180 * of partition - device number of disk plus the partition number
181 * 5) /dev/<disk_name>p<decimal> - same as the above, that form is
182 * used when disk name of partitioned disk ends on a digit.
183 * 6) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
184 * unique id of a partition if the partition table provides it.
185 * The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
186 * partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
187 * filled hex representation of the 32-bit "NT disk signature", and PP
188 * is a zero-filled hex representation of the 1-based partition number.
189 * 7) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
190 * a partition with a known unique id.
191 * 8) <major>:<minor> major and minor number of the device separated by
192 * a colon.
193 *
194 * If name doesn't have fall into the categories above, we return (0,0).
195 * block_class is used to check if something is a disk name. If the disk
196 * name contains slashes, the device name has them replaced with
197 * bangs.
198 */
199
name_to_dev_t(const char * name)200 dev_t name_to_dev_t(const char *name)
201 {
202 char s[32];
203 char *p;
204 dev_t res = 0;
205 int part;
206
207 #ifdef CONFIG_BLOCK
208 if (strncmp(name, "PARTUUID=", 9) == 0) {
209 name += 9;
210 res = devt_from_partuuid(name);
211 if (!res)
212 goto fail;
213 goto done;
214 }
215 #endif
216
217 if (strncmp(name, "/dev/", 5) != 0) {
218 unsigned maj, min, offset;
219 char dummy;
220
221 if ((sscanf(name, "%u:%u%c", &maj, &min, &dummy) == 2) ||
222 (sscanf(name, "%u:%u:%u:%c", &maj, &min, &offset, &dummy) == 3)) {
223 res = MKDEV(maj, min);
224 if (maj != MAJOR(res) || min != MINOR(res))
225 goto fail;
226 } else {
227 res = new_decode_dev(simple_strtoul(name, &p, 16));
228 if (*p)
229 goto fail;
230 }
231 goto done;
232 }
233
234 name += 5;
235 res = Root_NFS;
236 if (strcmp(name, "nfs") == 0)
237 goto done;
238 res = Root_RAM0;
239 if (strcmp(name, "ram") == 0)
240 goto done;
241
242 if (strlen(name) > 31)
243 goto fail;
244 strcpy(s, name);
245 for (p = s; *p; p++)
246 if (*p == '/')
247 *p = '!';
248 res = blk_lookup_devt(s, 0);
249 if (res)
250 goto done;
251
252 /*
253 * try non-existent, but valid partition, which may only exist
254 * after revalidating the disk, like partitioned md devices
255 */
256 while (p > s && isdigit(p[-1]))
257 p--;
258 if (p == s || !*p || *p == '0')
259 goto fail;
260
261 /* try disk name without <part number> */
262 part = simple_strtoul(p, NULL, 10);
263 *p = '\0';
264 res = blk_lookup_devt(s, part);
265 if (res)
266 goto done;
267
268 /* try disk name without p<part number> */
269 if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
270 goto fail;
271 p[-1] = '\0';
272 res = blk_lookup_devt(s, part);
273 if (res)
274 goto done;
275
276 fail:
277 return 0;
278 done:
279 return res;
280 }
281 EXPORT_SYMBOL_GPL(name_to_dev_t);
282
root_dev_setup(char * line)283 static int __init root_dev_setup(char *line)
284 {
285 strlcpy(saved_root_name, line, sizeof(saved_root_name));
286 return 1;
287 }
288
289 __setup("root=", root_dev_setup);
290
rootwait_setup(char * str)291 static int __init rootwait_setup(char *str)
292 {
293 if (*str)
294 return 0;
295 root_wait = 1;
296 return 1;
297 }
298
299 __setup("rootwait", rootwait_setup);
300
301 static char * __initdata root_mount_data;
root_data_setup(char * str)302 static int __init root_data_setup(char *str)
303 {
304 root_mount_data = str;
305 return 1;
306 }
307
308 static char * __initdata root_fs_names;
fs_names_setup(char * str)309 static int __init fs_names_setup(char *str)
310 {
311 root_fs_names = str;
312 return 1;
313 }
314
315 static unsigned int __initdata root_delay;
root_delay_setup(char * str)316 static int __init root_delay_setup(char *str)
317 {
318 root_delay = simple_strtoul(str, NULL, 0);
319 return 1;
320 }
321
322 __setup("rootflags=", root_data_setup);
323 __setup("rootfstype=", fs_names_setup);
324 __setup("rootdelay=", root_delay_setup);
325
get_fs_names(char * page)326 static void __init get_fs_names(char *page)
327 {
328 char *s = page;
329
330 if (root_fs_names) {
331 strcpy(page, root_fs_names);
332 while (*s++) {
333 if (s[-1] == ',')
334 s[-1] = '\0';
335 }
336 } else {
337 int len = get_filesystem_list(page);
338 char *p, *next;
339
340 page[len] = '\0';
341 for (p = page-1; p; p = next) {
342 next = strchr(++p, '\n');
343 if (*p++ != '\t')
344 continue;
345 while ((*s++ = *p++) != '\n')
346 ;
347 s[-1] = '\0';
348 }
349 }
350 *s = '\0';
351 }
352
do_mount_root(char * name,char * fs,int flags,void * data)353 static int __init do_mount_root(char *name, char *fs, int flags, void *data)
354 {
355 struct super_block *s;
356 int err = ksys_mount(name, "/root", fs, flags, data);
357 if (err)
358 return err;
359
360 ksys_chdir("/root");
361 s = current->fs->pwd.dentry->d_sb;
362 ROOT_DEV = s->s_dev;
363 printk(KERN_INFO
364 "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
365 s->s_type->name,
366 sb_rdonly(s) ? " readonly" : "",
367 MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
368 return 0;
369 }
370
mount_block_root(char * name,int flags)371 void __init mount_block_root(char *name, int flags)
372 {
373 struct page *page = alloc_page(GFP_KERNEL);
374 char *fs_names = page_address(page);
375 char *p;
376 #ifdef CONFIG_BLOCK
377 char b[BDEVNAME_SIZE];
378 #else
379 const char *b = name;
380 #endif
381
382 get_fs_names(fs_names);
383 retry:
384 for (p = fs_names; *p; p += strlen(p)+1) {
385 int err = do_mount_root(name, p, flags, root_mount_data);
386 switch (err) {
387 case 0:
388 goto out;
389 case -EACCES:
390 case -EINVAL:
391 continue;
392 }
393 /*
394 * Allow the user to distinguish between failed sys_open
395 * and bad superblock on root device.
396 * and give them a list of the available devices
397 */
398 #ifdef CONFIG_BLOCK
399 __bdevname(ROOT_DEV, b);
400 #endif
401 printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
402 root_device_name, b, err);
403 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
404
405 printk_all_partitions();
406 #ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
407 printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
408 "explicit textual name for \"root=\" boot option.\n");
409 #endif
410 panic("VFS: Unable to mount root fs on %s", b);
411 }
412 if (!(flags & SB_RDONLY)) {
413 flags |= SB_RDONLY;
414 goto retry;
415 }
416
417 printk("List of all partitions:\n");
418 printk_all_partitions();
419 printk("No filesystem could mount root, tried: ");
420 for (p = fs_names; *p; p += strlen(p)+1)
421 printk(" %s", p);
422 printk("\n");
423 #ifdef CONFIG_BLOCK
424 __bdevname(ROOT_DEV, b);
425 #endif
426 panic("VFS: Unable to mount root fs on %s", b);
427 out:
428 put_page(page);
429 }
430
431 #ifdef CONFIG_ROOT_NFS
432
433 #define NFSROOT_TIMEOUT_MIN 5
434 #define NFSROOT_TIMEOUT_MAX 30
435 #define NFSROOT_RETRY_MAX 5
436
mount_nfs_root(void)437 static int __init mount_nfs_root(void)
438 {
439 char *root_dev, *root_data;
440 unsigned int timeout;
441 int try, err;
442
443 err = nfs_root_data(&root_dev, &root_data);
444 if (err != 0)
445 return 0;
446
447 /*
448 * The server or network may not be ready, so try several
449 * times. Stop after a few tries in case the client wants
450 * to fall back to other boot methods.
451 */
452 timeout = NFSROOT_TIMEOUT_MIN;
453 for (try = 1; ; try++) {
454 err = do_mount_root(root_dev, "nfs",
455 root_mountflags, root_data);
456 if (err == 0)
457 return 1;
458 if (try > NFSROOT_RETRY_MAX)
459 break;
460
461 /* Wait, in case the server refused us immediately */
462 ssleep(timeout);
463 timeout <<= 1;
464 if (timeout > NFSROOT_TIMEOUT_MAX)
465 timeout = NFSROOT_TIMEOUT_MAX;
466 }
467 return 0;
468 }
469 #endif
470
471 #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
change_floppy(char * fmt,...)472 void __init change_floppy(char *fmt, ...)
473 {
474 struct termios termios;
475 char buf[80];
476 char c;
477 int fd;
478 va_list args;
479 va_start(args, fmt);
480 vsprintf(buf, fmt, args);
481 va_end(args);
482 fd = ksys_open("/dev/root", O_RDWR | O_NDELAY, 0);
483 if (fd >= 0) {
484 ksys_ioctl(fd, FDEJECT, 0);
485 ksys_close(fd);
486 }
487 printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
488 fd = ksys_open("/dev/console", O_RDWR, 0);
489 if (fd >= 0) {
490 ksys_ioctl(fd, TCGETS, (long)&termios);
491 termios.c_lflag &= ~ICANON;
492 ksys_ioctl(fd, TCSETSF, (long)&termios);
493 ksys_read(fd, &c, 1);
494 termios.c_lflag |= ICANON;
495 ksys_ioctl(fd, TCSETSF, (long)&termios);
496 ksys_close(fd);
497 }
498 }
499 #endif
500
mount_root(void)501 void __init mount_root(void)
502 {
503 #ifdef CONFIG_ROOT_NFS
504 if (ROOT_DEV == Root_NFS) {
505 if (mount_nfs_root())
506 return;
507
508 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
509 ROOT_DEV = Root_FD0;
510 }
511 #endif
512 #ifdef CONFIG_BLK_DEV_FD
513 if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
514 /* rd_doload is 2 for a dual initrd/ramload setup */
515 if (rd_doload==2) {
516 if (rd_load_disk(1)) {
517 ROOT_DEV = Root_RAM1;
518 root_device_name = NULL;
519 }
520 } else
521 change_floppy("root floppy");
522 }
523 #endif
524 #ifdef CONFIG_BLOCK
525 {
526 int err = create_dev("/dev/root", ROOT_DEV);
527
528 if (err < 0)
529 pr_emerg("Failed to create /dev/root: %d\n", err);
530 mount_block_root("/dev/root", root_mountflags);
531 }
532 #endif
533 }
534
535 /*
536 * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
537 */
prepare_namespace(void)538 void __init prepare_namespace(void)
539 {
540 int is_floppy;
541
542 if (root_delay) {
543 printk(KERN_INFO "Waiting %d sec before mounting root device...\n",
544 root_delay);
545 ssleep(root_delay);
546 }
547
548 /*
549 * wait for the known devices to complete their probing
550 *
551 * Note: this is a potential source of long boot delays.
552 * For example, it is not atypical to wait 5 seconds here
553 * for the touchpad of a laptop to initialize.
554 */
555 wait_for_device_probe();
556
557 md_run_setup();
558
559 if (saved_root_name[0]) {
560 root_device_name = saved_root_name;
561 if (!strncmp(root_device_name, "mtd", 3) ||
562 !strncmp(root_device_name, "ubi", 3)) {
563 mount_block_root(root_device_name, root_mountflags);
564 goto out;
565 }
566 ROOT_DEV = name_to_dev_t(root_device_name);
567 if (strncmp(root_device_name, "/dev/", 5) == 0)
568 root_device_name += 5;
569 }
570
571 if (initrd_load())
572 goto out;
573
574 /* wait for any asynchronous scanning to complete */
575 if ((ROOT_DEV == 0) && root_wait) {
576 printk(KERN_INFO "Waiting for root device %s...\n",
577 saved_root_name);
578 while (driver_probe_done() != 0 ||
579 (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
580 msleep(5);
581 async_synchronize_full();
582 }
583
584 is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
585
586 if (is_floppy && rd_doload && rd_load_disk(0))
587 ROOT_DEV = Root_RAM0;
588
589 mount_root();
590 out:
591 devtmpfs_mount("dev");
592 ksys_mount(".", "/", NULL, MS_MOVE, NULL);
593 ksys_chroot(".");
594 }
595
596 static bool is_tmpfs;
rootfs_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data)597 static struct dentry *rootfs_mount(struct file_system_type *fs_type,
598 int flags, const char *dev_name, void *data)
599 {
600 static unsigned long once;
601 void *fill = ramfs_fill_super;
602
603 if (test_and_set_bit(0, &once))
604 return ERR_PTR(-ENODEV);
605
606 if (IS_ENABLED(CONFIG_TMPFS) && is_tmpfs)
607 fill = shmem_fill_super;
608
609 return mount_nodev(fs_type, flags, data, fill);
610 }
611
612 static struct file_system_type rootfs_fs_type = {
613 .name = "rootfs",
614 .mount = rootfs_mount,
615 .kill_sb = kill_litter_super,
616 };
617
init_rootfs(void)618 int __init init_rootfs(void)
619 {
620 int err = register_filesystem(&rootfs_fs_type);
621
622 if (err)
623 return err;
624
625 if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
626 (!root_fs_names || strstr(root_fs_names, "tmpfs"))) {
627 err = shmem_init();
628 is_tmpfs = true;
629 } else {
630 err = init_ramfs_fs();
631 }
632
633 if (err)
634 unregister_filesystem(&rootfs_fs_type);
635
636 return err;
637 }
638
