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 static int __init load_ramdisk(char *str) 37 { 38 pr_warn("ignoring the deprecated load_ramdisk= option\n"); 39 return 1; 40 } 41 __setup("load_ramdisk=", load_ramdisk); 42 43 static int __init readonly(char *str) 44 { 45 if (*str) 46 return 0; 47 root_mountflags |= MS_RDONLY; 48 return 1; 49 } 50 51 static int __init readwrite(char *str) 52 { 53 if (*str) 54 return 0; 55 root_mountflags &= ~MS_RDONLY; 56 return 1; 57 } 58 59 __setup("ro", readonly); 60 __setup("rw", readwrite); 61 62 static int __init root_dev_setup(char *line) 63 { 64 strscpy(saved_root_name, line, sizeof(saved_root_name)); 65 return 1; 66 } 67 68 __setup("root=", root_dev_setup); 69 70 static int __init rootwait_setup(char *str) 71 { 72 if (*str) 73 return 0; 74 root_wait = 1; 75 return 1; 76 } 77 78 __setup("rootwait", rootwait_setup); 79 80 static char * __initdata root_mount_data; 81 static int __init root_data_setup(char *str) 82 { 83 root_mount_data = str; 84 return 1; 85 } 86 87 static char * __initdata root_fs_names; 88 static int __init fs_names_setup(char *str) 89 { 90 root_fs_names = str; 91 return 1; 92 } 93 94 static unsigned int __initdata root_delay; 95 static int __init root_delay_setup(char *str) 96 { 97 root_delay = simple_strtoul(str, NULL, 0); 98 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 static int __init split_fs_names(char *page, size_t size) 107 { 108 int count = 1; 109 char *p = page; 110 111 strscpy(p, root_fs_names, size); 112 while (*p++) { 113 if (p[-1] == ',') { 114 p[-1] = '\0'; 115 count++; 116 } 117 } 118 119 return count; 120 } 121 122 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 struct page *p = NULL; 127 char *data_page = NULL; 128 int ret; 129 130 if (data) { 131 /* init_mount() requires a full page as fifth argument */ 132 p = alloc_page(GFP_KERNEL); 133 if (!p) 134 return -ENOMEM; 135 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 ret = init_mount(name, "/root", fs, flags, data_page); 141 if (ret) 142 goto out; 143 144 init_chdir("/root"); 145 s = current->fs->pwd.dentry->d_sb; 146 ROOT_DEV = s->s_dev; 147 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 if (p) 155 put_page(p); 156 return ret; 157 } 158 159 void __init mount_root_generic(char *name, char *pretty_name, int flags) 160 { 161 struct page *page = alloc_page(GFP_KERNEL); 162 char *fs_names = page_address(page); 163 char *p; 164 char b[BDEVNAME_SIZE]; 165 int num_fs, i; 166 167 scnprintf(b, BDEVNAME_SIZE, "unknown-block(%u,%u)", 168 MAJOR(ROOT_DEV), MINOR(ROOT_DEV)); 169 if (root_fs_names) 170 num_fs = split_fs_names(fs_names, PAGE_SIZE); 171 else 172 num_fs = list_bdev_fs_names(fs_names, PAGE_SIZE); 173 retry: 174 for (i = 0, p = fs_names; i < num_fs; i++, p += strlen(p)+1) { 175 int err; 176 177 if (!*p) 178 continue; 179 err = do_mount_root(name, p, flags, root_mount_data); 180 switch (err) { 181 case 0: 182 goto out; 183 case -EACCES: 184 case -EINVAL: 185 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 printk("VFS: Cannot open root device \"%s\" or %s: error %d\n", 193 pretty_name, b, err); 194 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n"); 195 printk_all_partitions(); 196 197 if (root_fs_names) 198 num_fs = list_bdev_fs_names(fs_names, PAGE_SIZE); 199 if (!num_fs) 200 pr_err("Can't find any bdev filesystem to be used for mount!\n"); 201 else { 202 pr_err("List of all bdev filesystems:\n"); 203 for (i = 0, p = fs_names; i < num_fs; i++, p += strlen(p)+1) 204 pr_err(" %s", p); 205 pr_err("\n"); 206 } 207 208 panic("VFS: Unable to mount root fs on %s", b); 209 } 210 if (!(flags & SB_RDONLY)) { 211 flags |= SB_RDONLY; 212 goto retry; 213 } 214 215 printk("List of all partitions:\n"); 216 printk_all_partitions(); 217 printk("No filesystem could mount root, tried: "); 218 for (i = 0, p = fs_names; i < num_fs; i++, p += strlen(p)+1) 219 printk(" %s", p); 220 printk("\n"); 221 panic("VFS: Unable to mount root fs on %s", b); 222 out: 223 put_page(page); 224 } 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 static bool __init fs_is_nodev(char *fstype) 306 { 307 struct file_system_type *fs = get_fs_type(fstype); 308 bool ret = false; 309 310 if (fs) { 311 ret = !(fs->fs_flags & FS_REQUIRES_DEV); 312 put_filesystem(fs); 313 } 314 315 return ret; 316 } 317 318 static int __init mount_nodev_root(char *root_device_name) 319 { 320 char *fs_names, *fstype; 321 int err = -EINVAL; 322 int num_fs, i; 323 324 fs_names = (void *)__get_free_page(GFP_KERNEL); 325 if (!fs_names) 326 return -EINVAL; 327 num_fs = split_fs_names(fs_names, PAGE_SIZE); 328 329 for (i = 0, fstype = fs_names; i < num_fs; 330 i++, fstype += strlen(fstype) + 1) { 331 if (!*fstype) 332 continue; 333 if (!fs_is_nodev(fstype)) 334 continue; 335 err = do_mount_root(root_device_name, fstype, root_mountflags, 336 root_mount_data); 337 if (!err) 338 break; 339 } 340 341 free_page((unsigned long)fs_names); 342 return err; 343 } 344 345 #ifdef CONFIG_BLOCK 346 static void __init mount_block_root(char *root_device_name) 347 { 348 int err = create_dev("/dev/root", ROOT_DEV); 349 350 if (err < 0) 351 pr_emerg("Failed to create /dev/root: %d\n", err); 352 mount_root_generic("/dev/root", root_device_name, root_mountflags); 353 } 354 #else 355 static inline void mount_block_root(char *root_device_name) 356 { 357 } 358 #endif /* CONFIG_BLOCK */ 359 360 void __init mount_root(char *root_device_name) 361 { 362 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 mount_root_generic(root_device_name, root_device_name, 371 root_mountflags); 372 break; 373 case 0: 374 if (root_device_name && root_fs_names && 375 mount_nodev_root(root_device_name) == 0) 376 break; 377 fallthrough; 378 default: 379 mount_block_root(root_device_name); 380 break; 381 } 382 } 383 384 /* wait for any asynchronous scanning to complete */ 385 static void __init wait_for_root(char *root_device_name) 386 { 387 if (ROOT_DEV != 0) 388 return; 389 390 pr_info("Waiting for root device %s...\n", root_device_name); 391 392 while (!driver_probe_done() || 393 early_lookup_bdev(root_device_name, &ROOT_DEV) < 0) 394 msleep(5); 395 async_synchronize_full(); 396 397 } 398 399 static dev_t __init parse_root_device(char *root_device_name) 400 { 401 int error; 402 dev_t dev; 403 404 if (!strncmp(root_device_name, "mtd", 3) || 405 !strncmp(root_device_name, "ubi", 3)) 406 return Root_Generic; 407 if (strcmp(root_device_name, "/dev/nfs") == 0) 408 return Root_NFS; 409 if (strcmp(root_device_name, "/dev/cifs") == 0) 410 return Root_CIFS; 411 if (strcmp(root_device_name, "/dev/ram") == 0) 412 return Root_RAM0; 413 414 error = early_lookup_bdev(root_device_name, &dev); 415 if (error) { 416 if (error == -EINVAL && root_wait) { 417 pr_err("Disabling rootwait; root= is invalid.\n"); 418 root_wait = 0; 419 } 420 return 0; 421 } 422 return dev; 423 } 424 425 /* 426 * Prepare the namespace - decide what/where to mount, load ramdisks, etc. 427 */ 428 void __init prepare_namespace(void) 429 { 430 if (root_delay) { 431 printk(KERN_INFO "Waiting %d sec before mounting root device...\n", 432 root_delay); 433 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 wait_for_device_probe(); 444 445 md_run_setup(); 446 447 if (saved_root_name[0]) 448 ROOT_DEV = parse_root_device(saved_root_name); 449 450 if (initrd_load(saved_root_name)) 451 goto out; 452 453 if (root_wait) 454 wait_for_root(saved_root_name); 455 mount_root(saved_root_name); 456 out: 457 devtmpfs_mount(); 458 init_mount(".", "/", NULL, MS_MOVE, NULL); 459 init_chroot("."); 460 } 461 462 static bool is_tmpfs; 463 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 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 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 } 483