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