522 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2#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 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 44static int __init readonly(char *str)45{46 if (*str)47 return 0;48 root_mountflags |= MS_RDONLY;49 return 1;50}51 52static 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 63static 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 71static 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 81static 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 97ignore:98 /* Fallback to indefinite wait */99 root_wait = -1;100 101 return 1;102}103 104__setup("rootwait=", rootwait_timeout_setup);105 106static char * __initdata root_mount_data;107static int __init root_data_setup(char *str)108{109 root_mount_data = str;110 return 1;111}112 113static char * __initdata root_fs_names;114static int __init fs_names_setup(char *str)115{116 root_fs_names = str;117 return 1;118}119 120static unsigned int __initdata root_delay;121static 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 */132static 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 148static 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_INFO173 "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 178out:179 if (p)180 put_page(p);181 return ret;182}183 184void __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 else197 num_fs = list_bdev_fs_names(fs_names, PAGE_SIZE);198retry: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_BLOCK211 init_flush_fput();212#endif213 continue;214 }215 /*216 * Allow the user to distinguish between failed sys_open217 * and bad superblock on root device.218 * and give them a list of the available devices219 */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);250out:251 put_page(page);252}253 254#ifdef CONFIG_ROOT_NFS255 256#define NFSROOT_TIMEOUT_MIN 5257#define NFSROOT_TIMEOUT_MAX 30258#define NFSROOT_RETRY_MAX 5259 260static 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 several271 * times. Stop after a few tries in case the client wants272 * 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 }287fail:288 pr_err("VFS: Unable to mount root fs via NFS.\n");289}290#else291static inline void mount_nfs_root(void)292{293}294#endif /* CONFIG_ROOT_NFS */295 296#ifdef CONFIG_CIFS_ROOT297 298#define CIFSROOT_TIMEOUT_MIN 5299#define CIFSROOT_TIMEOUT_MAX 30300#define CIFSROOT_RETRY_MAX 5301 302static 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 }324fail:325 pr_err("VFS: Unable to mount root fs via SMB.\n");326}327#else328static inline void mount_cifs_root(void)329{330}331#endif /* CONFIG_CIFS_ROOT */332 333static 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 346static 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_BLOCK374static 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#else383static inline void mount_block_root(char *root_device_name)384{385}386#endif /* CONFIG_BLOCK */387 388void __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 */413static HWJS_SUSPENDS 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 435static 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 */464void __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 probing474 *475 * Note: this is a potential source of long boot delays.476 * For example, it is not atypical to wait 5 seconds here477 * 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);492out:493 devtmpfs_mount();494 init_mount(".", "/", NULL, MS_MOVE, NULL);495 init_chroot(".");496}497 498static bool is_tmpfs;499static 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 507struct 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 513void __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