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