xref: /linux/init/do_mounts.c (revision 621cde16e49b3ecf7d59a8106a20aaebfb4a59a9)
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/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 #include <linux/ktime.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 
31 int root_mountflags = MS_RDONLY | MS_SILENT;
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 	pr_warn("ignoring the deprecated load_ramdisk= option\n");
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 
root_dev_setup(char * line)63 static int __init root_dev_setup(char *line)
64 {
65 	strscpy(saved_root_name, line, sizeof(saved_root_name));
66 	return 1;
67 }
68 
69 __setup("root=", root_dev_setup);
70 
rootwait_setup(char * str)71 static int __init rootwait_setup(char *str)
72 {
73 	if (*str)
74 		return 0;
75 	root_wait = -1;
76 	return 1;
77 }
78 
79 __setup("rootwait", rootwait_setup);
80 
rootwait_timeout_setup(char * str)81 static int __init rootwait_timeout_setup(char *str)
82 {
83 	int sec;
84 
85 	if (kstrtoint(str, 0, &sec) || sec < 0) {
86 		pr_warn("ignoring invalid rootwait value\n");
87 		goto ignore;
88 	}
89 
90 	if (check_mul_overflow(sec, MSEC_PER_SEC, &root_wait)) {
91 		pr_warn("ignoring excessive rootwait value\n");
92 		goto ignore;
93 	}
94 
95 	return 1;
96 
97 ignore:
98 	/* Fallback to indefinite wait */
99 	root_wait = -1;
100 
101 	return 1;
102 }
103 
104 __setup("rootwait=", rootwait_timeout_setup);
105 
106 static char * __initdata root_mount_data;
root_data_setup(char * str)107 static int __init root_data_setup(char *str)
108 {
109 	root_mount_data = str;
110 	return 1;
111 }
112 
113 static char * __initdata root_fs_names;
fs_names_setup(char * str)114 static int __init fs_names_setup(char *str)
115 {
116 	root_fs_names = str;
117 	return 1;
118 }
119 
120 static unsigned int __initdata root_delay;
root_delay_setup(char * str)121 static int __init root_delay_setup(char *str)
122 {
123 	root_delay = simple_strtoul(str, NULL, 0);
124 	return 1;
125 }
126 
127 __setup("rootflags=", root_data_setup);
128 __setup("rootfstype=", fs_names_setup);
129 __setup("rootdelay=", root_delay_setup);
130 
131 /* This can return zero length strings. Caller should check */
split_fs_names(char * page,size_t size)132 static int __init split_fs_names(char *page, size_t size)
133 {
134 	int count = 1;
135 	char *p = page;
136 
137 	strscpy(p, root_fs_names, size);
138 	while (*p++) {
139 		if (p[-1] == ',') {
140 			p[-1] = '\0';
141 			count++;
142 		}
143 	}
144 
145 	return count;
146 }
147 
do_mount_root(const char * name,const char * fs,const int flags,const void * data)148 static int __init do_mount_root(const char *name, const char *fs,
149 				 const int flags, const void *data)
150 {
151 	struct super_block *s;
152 	struct page *p = NULL;
153 	char *data_page = NULL;
154 	int ret;
155 
156 	if (data) {
157 		/* init_mount() requires a full page as fifth argument */
158 		p = alloc_page(GFP_KERNEL);
159 		if (!p)
160 			return -ENOMEM;
161 		data_page = page_address(p);
162 		strscpy_pad(data_page, data, PAGE_SIZE);
163 	}
164 
165 	ret = init_mount(name, "/root", fs, flags, data_page);
166 	if (ret)
167 		goto out;
168 
169 	init_chdir("/root");
170 	s = current->fs->pwd.dentry->d_sb;
171 	ROOT_DEV = s->s_dev;
172 	printk(KERN_INFO
173 	       "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
174 	       s->s_type->name,
175 	       sb_rdonly(s) ? " readonly" : "",
176 	       MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
177 
178 out:
179 	if (p)
180 		put_page(p);
181 	return ret;
182 }
183 
mount_root_generic(char * name,char * pretty_name,int flags)184 void __init mount_root_generic(char *name, char *pretty_name, int flags)
185 {
186 	struct page *page = alloc_page(GFP_KERNEL);
187 	char *fs_names = page_address(page);
188 	char *p;
189 	char b[BDEVNAME_SIZE];
190 	int num_fs, i;
191 
192 	scnprintf(b, BDEVNAME_SIZE, "unknown-block(%u,%u)",
193 		  MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
194 	if (root_fs_names)
195 		num_fs = split_fs_names(fs_names, PAGE_SIZE);
196 	else
197 		num_fs = list_bdev_fs_names(fs_names, PAGE_SIZE);
198 retry:
199 	for (i = 0, p = fs_names; i < num_fs; i++, p += strlen(p)+1) {
200 		int err;
201 
202 		if (!*p)
203 			continue;
204 		err = do_mount_root(name, p, flags, root_mount_data);
205 		switch (err) {
206 			case 0:
207 				goto out;
208 			case -EACCES:
209 			case -EINVAL:
210 #ifdef CONFIG_BLOCK
211 				init_flush_fput();
212 #endif
213 				continue;
214 		}
215 	        /*
216 		 * Allow the user to distinguish between failed sys_open
217 		 * and bad superblock on root device.
218 		 * and give them a list of the available devices
219 		 */
220 		printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
221 				pretty_name, b, err);
222 		printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
223 		printk_all_partitions();
224 
225 		if (root_fs_names)
226 			num_fs = list_bdev_fs_names(fs_names, PAGE_SIZE);
227 		if (!num_fs)
228 			pr_err("Can't find any bdev filesystem to be used for mount!\n");
229 		else {
230 			pr_err("List of all bdev filesystems:\n");
231 			for (i = 0, p = fs_names; i < num_fs; i++, p += strlen(p)+1)
232 				pr_err(" %s", p);
233 			pr_err("\n");
234 		}
235 
236 		panic("VFS: Unable to mount root fs on %s", b);
237 	}
238 	if (!(flags & SB_RDONLY)) {
239 		flags |= SB_RDONLY;
240 		goto retry;
241 	}
242 
243 	printk("List of all partitions:\n");
244 	printk_all_partitions();
245 	printk("No filesystem could mount root, tried: ");
246 	for (i = 0, p = fs_names; i < num_fs; i++, p += strlen(p)+1)
247 		printk(" %s", p);
248 	printk("\n");
249 	panic("VFS: Unable to mount root fs on \"%s\" or %s", pretty_name, b);
250 out:
251 	put_page(page);
252 }
253 
254 #ifdef CONFIG_ROOT_NFS
255 
256 #define NFSROOT_TIMEOUT_MIN	5
257 #define NFSROOT_TIMEOUT_MAX	30
258 #define NFSROOT_RETRY_MAX	5
259 
mount_nfs_root(void)260 static void __init mount_nfs_root(void)
261 {
262 	char *root_dev, *root_data;
263 	unsigned int timeout;
264 	int try;
265 
266 	if (nfs_root_data(&root_dev, &root_data))
267 		goto fail;
268 
269 	/*
270 	 * The server or network may not be ready, so try several
271 	 * times.  Stop after a few tries in case the client wants
272 	 * to fall back to other boot methods.
273 	 */
274 	timeout = NFSROOT_TIMEOUT_MIN;
275 	for (try = 1; ; try++) {
276 		if (!do_mount_root(root_dev, "nfs", root_mountflags, root_data))
277 			return;
278 		if (try > NFSROOT_RETRY_MAX)
279 			break;
280 
281 		/* Wait, in case the server refused us immediately */
282 		ssleep(timeout);
283 		timeout <<= 1;
284 		if (timeout > NFSROOT_TIMEOUT_MAX)
285 			timeout = NFSROOT_TIMEOUT_MAX;
286 	}
287 fail:
288 	pr_err("VFS: Unable to mount root fs via NFS.\n");
289 }
290 #else
mount_nfs_root(void)291 static inline void mount_nfs_root(void)
292 {
293 }
294 #endif /* CONFIG_ROOT_NFS */
295 
296 #ifdef CONFIG_CIFS_ROOT
297 
298 #define CIFSROOT_TIMEOUT_MIN	5
299 #define CIFSROOT_TIMEOUT_MAX	30
300 #define CIFSROOT_RETRY_MAX	5
301 
mount_cifs_root(void)302 static void __init mount_cifs_root(void)
303 {
304 	char *root_dev, *root_data;
305 	unsigned int timeout;
306 	int try;
307 
308 	if (cifs_root_data(&root_dev, &root_data))
309 		goto fail;
310 
311 	timeout = CIFSROOT_TIMEOUT_MIN;
312 	for (try = 1; ; try++) {
313 		if (!do_mount_root(root_dev, "cifs", root_mountflags,
314 				   root_data))
315 			return;
316 		if (try > CIFSROOT_RETRY_MAX)
317 			break;
318 
319 		ssleep(timeout);
320 		timeout <<= 1;
321 		if (timeout > CIFSROOT_TIMEOUT_MAX)
322 			timeout = CIFSROOT_TIMEOUT_MAX;
323 	}
324 fail:
325 	pr_err("VFS: Unable to mount root fs via SMB.\n");
326 }
327 #else
mount_cifs_root(void)328 static inline void mount_cifs_root(void)
329 {
330 }
331 #endif /* CONFIG_CIFS_ROOT */
332 
fs_is_nodev(char * fstype)333 static bool __init fs_is_nodev(char *fstype)
334 {
335 	struct file_system_type *fs = get_fs_type(fstype);
336 	bool ret = false;
337 
338 	if (fs) {
339 		ret = !(fs->fs_flags & FS_REQUIRES_DEV);
340 		put_filesystem(fs);
341 	}
342 
343 	return ret;
344 }
345 
mount_nodev_root(char * root_device_name)346 static int __init mount_nodev_root(char *root_device_name)
347 {
348 	char *fs_names, *fstype;
349 	int err = -EINVAL;
350 	int num_fs, i;
351 
352 	fs_names = (void *)__get_free_page(GFP_KERNEL);
353 	if (!fs_names)
354 		return -EINVAL;
355 	num_fs = split_fs_names(fs_names, PAGE_SIZE);
356 
357 	for (i = 0, fstype = fs_names; i < num_fs;
358 	     i++, fstype += strlen(fstype) + 1) {
359 		if (!*fstype)
360 			continue;
361 		if (!fs_is_nodev(fstype))
362 			continue;
363 		err = do_mount_root(root_device_name, fstype, root_mountflags,
364 				    root_mount_data);
365 		if (!err)
366 			break;
367 	}
368 
369 	free_page((unsigned long)fs_names);
370 	return err;
371 }
372 
373 #ifdef CONFIG_BLOCK
mount_block_root(char * root_device_name)374 static void __init mount_block_root(char *root_device_name)
375 {
376 	int err = create_dev("/dev/root", ROOT_DEV);
377 
378 	if (err < 0)
379 		pr_emerg("Failed to create /dev/root: %d\n", err);
380 	mount_root_generic("/dev/root", root_device_name, root_mountflags);
381 }
382 #else
mount_block_root(char * root_device_name)383 static inline void mount_block_root(char *root_device_name)
384 {
385 }
386 #endif /* CONFIG_BLOCK */
387 
mount_root(char * root_device_name)388 void __init mount_root(char *root_device_name)
389 {
390 	switch (ROOT_DEV) {
391 	case Root_NFS:
392 		mount_nfs_root();
393 		break;
394 	case Root_CIFS:
395 		mount_cifs_root();
396 		break;
397 	case Root_Generic:
398 		mount_root_generic(root_device_name, root_device_name,
399 				   root_mountflags);
400 		break;
401 	case 0:
402 		if (root_device_name && root_fs_names &&
403 		    mount_nodev_root(root_device_name) == 0)
404 			break;
405 		fallthrough;
406 	default:
407 		mount_block_root(root_device_name);
408 		break;
409 	}
410 }
411 
412 /* wait for any asynchronous scanning to complete */
wait_for_root(char * root_device_name)413 static void __init wait_for_root(char *root_device_name)
414 {
415 	ktime_t end;
416 
417 	if (ROOT_DEV != 0)
418 		return;
419 
420 	pr_info("Waiting for root device %s...\n", root_device_name);
421 
422 	end = ktime_add_ms(ktime_get_raw(), root_wait);
423 
424 	while (!driver_probe_done() ||
425 	       early_lookup_bdev(root_device_name, &ROOT_DEV) < 0) {
426 		msleep(5);
427 		if (root_wait > 0 && ktime_after(ktime_get_raw(), end))
428 			break;
429 	}
430 
431 	async_synchronize_full();
432 
433 }
434 
parse_root_device(char * root_device_name)435 static dev_t __init parse_root_device(char *root_device_name)
436 {
437 	int error;
438 	dev_t dev;
439 
440 	if (!strncmp(root_device_name, "mtd", 3) ||
441 	    !strncmp(root_device_name, "ubi", 3))
442 		return Root_Generic;
443 	if (strcmp(root_device_name, "/dev/nfs") == 0)
444 		return Root_NFS;
445 	if (strcmp(root_device_name, "/dev/cifs") == 0)
446 		return Root_CIFS;
447 	if (strcmp(root_device_name, "/dev/ram") == 0)
448 		return Root_RAM0;
449 
450 	error = early_lookup_bdev(root_device_name, &dev);
451 	if (error) {
452 		if (error == -EINVAL && root_wait) {
453 			pr_err("Disabling rootwait; root= is invalid.\n");
454 			root_wait = 0;
455 		}
456 		return 0;
457 	}
458 	return dev;
459 }
460 
461 /*
462  * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
463  */
prepare_namespace(void)464 void __init prepare_namespace(void)
465 {
466 	if (root_delay) {
467 		printk(KERN_INFO "Waiting %d sec before mounting root device...\n",
468 		       root_delay);
469 		ssleep(root_delay);
470 	}
471 
472 	/*
473 	 * wait for the known devices to complete their probing
474 	 *
475 	 * Note: this is a potential source of long boot delays.
476 	 * For example, it is not atypical to wait 5 seconds here
477 	 * for the touchpad of a laptop to initialize.
478 	 */
479 	wait_for_device_probe();
480 
481 	md_run_setup();
482 
483 	if (saved_root_name[0])
484 		ROOT_DEV = parse_root_device(saved_root_name);
485 
486 	if (initrd_load(saved_root_name))
487 		goto out;
488 
489 	if (root_wait)
490 		wait_for_root(saved_root_name);
491 	mount_root(saved_root_name);
492 out:
493 	devtmpfs_mount();
494 	init_mount(".", "/", NULL, MS_MOVE, NULL);
495 	init_chroot(".");
496 }
497 
498 static bool is_tmpfs;
rootfs_init_fs_context(struct fs_context * fc)499 static int rootfs_init_fs_context(struct fs_context *fc)
500 {
501 	if (IS_ENABLED(CONFIG_TMPFS) && is_tmpfs)
502 		return shmem_init_fs_context(fc);
503 
504 	return ramfs_init_fs_context(fc);
505 }
506 
507 struct file_system_type rootfs_fs_type = {
508 	.name		= "rootfs",
509 	.init_fs_context = rootfs_init_fs_context,
510 	.kill_sb	= kill_litter_super,
511 };
512 
init_rootfs(void)513 void __init init_rootfs(void)
514 {
515 	if (IS_ENABLED(CONFIG_TMPFS)) {
516 		if (!saved_root_name[0] && !root_fs_names)
517 			is_tmpfs = true;
518 		else if (root_fs_names && !!strstr(root_fs_names, "tmpfs"))
519 			is_tmpfs = true;
520 	}
521 }
522