projects/linux·blob uaccess-cleanups · refs

520 lines · 11.0 KiB

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