1 /* 2 * Many of the syscalls used in this file expect some of the arguments 3 * to be __user pointers not __kernel pointers. To limit the sparse 4 * noise, turn off sparse checking for this file. 5 */ 6 #ifdef __CHECKER__ 7 #undef __CHECKER__ 8 #warning "Sparse checking disabled for this file" 9 #endif 10 11 #include <linux/module.h> 12 #include <linux/sched.h> 13 #include <linux/ctype.h> 14 #include <linux/fd.h> 15 #include <linux/tty.h> 16 #include <linux/suspend.h> 17 #include <linux/root_dev.h> 18 #include <linux/security.h> 19 #include <linux/delay.h> 20 #include <linux/genhd.h> 21 #include <linux/mount.h> 22 #include <linux/device.h> 23 #include <linux/init.h> 24 #include <linux/fs.h> 25 #include <linux/initrd.h> 26 #include <linux/async.h> 27 #include <linux/fs_struct.h> 28 #include <linux/slab.h> 29 30 #include <linux/nfs_fs.h> 31 #include <linux/nfs_fs_sb.h> 32 #include <linux/nfs_mount.h> 33 34 #include "do_mounts.h" 35 36 int __initdata rd_doload; /* 1 = load RAM disk, 0 = don't load */ 37 38 int root_mountflags = MS_RDONLY | MS_SILENT; 39 static char * __initdata root_device_name; 40 static char __initdata saved_root_name[64]; 41 static int root_wait; 42 43 dev_t ROOT_DEV; 44 45 static int __init load_ramdisk(char *str) 46 { 47 rd_doload = simple_strtol(str,NULL,0) & 3; 48 return 1; 49 } 50 __setup("load_ramdisk=", load_ramdisk); 51 52 static int __init readonly(char *str) 53 { 54 if (*str) 55 return 0; 56 root_mountflags |= MS_RDONLY; 57 return 1; 58 } 59 60 static int __init readwrite(char *str) 61 { 62 if (*str) 63 return 0; 64 root_mountflags &= ~MS_RDONLY; 65 return 1; 66 } 67 68 __setup("ro", readonly); 69 __setup("rw", readwrite); 70 71 #ifdef CONFIG_BLOCK 72 struct uuidcmp { 73 const char *uuid; 74 int len; 75 }; 76 77 /** 78 * match_dev_by_uuid - callback for finding a partition using its uuid 79 * @dev: device passed in by the caller 80 * @data: opaque pointer to the desired struct uuidcmp to match 81 * 82 * Returns 1 if the device matches, and 0 otherwise. 83 */ 84 static int match_dev_by_uuid(struct device *dev, void *data) 85 { 86 struct uuidcmp *cmp = data; 87 struct hd_struct *part = dev_to_part(dev); 88 89 if (!part->info) 90 goto no_match; 91 92 if (strncasecmp(cmp->uuid, part->info->uuid, cmp->len)) 93 goto no_match; 94 95 return 1; 96 no_match: 97 return 0; 98 } 99 100 101 /** 102 * devt_from_partuuid - looks up the dev_t of a partition by its UUID 103 * @uuid: char array containing ascii UUID 104 * 105 * The function will return the first partition which contains a matching 106 * UUID value in its partition_meta_info struct. This does not search 107 * by filesystem UUIDs. 108 * 109 * If @uuid is followed by a "/PARTNROFF=%d", then the number will be 110 * extracted and used as an offset from the partition identified by the UUID. 111 * 112 * Returns the matching dev_t on success or 0 on failure. 113 */ 114 static dev_t devt_from_partuuid(const char *uuid_str) 115 { 116 dev_t res = 0; 117 struct uuidcmp cmp; 118 struct device *dev = NULL; 119 struct gendisk *disk; 120 struct hd_struct *part; 121 int offset = 0; 122 bool clear_root_wait = false; 123 char *slash; 124 125 cmp.uuid = uuid_str; 126 127 slash = strchr(uuid_str, '/'); 128 /* Check for optional partition number offset attributes. */ 129 if (slash) { 130 char c = 0; 131 /* Explicitly fail on poor PARTUUID syntax. */ 132 if (sscanf(slash + 1, 133 "PARTNROFF=%d%c", &offset, &c) != 1) { 134 clear_root_wait = true; 135 goto done; 136 } 137 cmp.len = slash - uuid_str; 138 } else { 139 cmp.len = strlen(uuid_str); 140 } 141 142 if (!cmp.len) { 143 clear_root_wait = true; 144 goto done; 145 } 146 147 dev = class_find_device(&block_class, NULL, &cmp, 148 &match_dev_by_uuid); 149 if (!dev) 150 goto done; 151 152 res = dev->devt; 153 154 /* Attempt to find the partition by offset. */ 155 if (!offset) 156 goto no_offset; 157 158 res = 0; 159 disk = part_to_disk(dev_to_part(dev)); 160 part = disk_get_part(disk, dev_to_part(dev)->partno + offset); 161 if (part) { 162 res = part_devt(part); 163 put_device(part_to_dev(part)); 164 } 165 166 no_offset: 167 put_device(dev); 168 done: 169 if (clear_root_wait) { 170 pr_err("VFS: PARTUUID= is invalid.\n" 171 "Expected PARTUUID=<valid-uuid-id>[/PARTNROFF=%%d]\n"); 172 if (root_wait) 173 pr_err("Disabling rootwait; root= is invalid.\n"); 174 root_wait = 0; 175 } 176 return res; 177 } 178 #endif 179 180 /* 181 * Convert a name into device number. We accept the following variants: 182 * 183 * 1) device number in hexadecimal represents itself 184 * 2) /dev/nfs represents Root_NFS (0xff) 185 * 3) /dev/<disk_name> represents the device number of disk 186 * 4) /dev/<disk_name><decimal> represents the device number 187 * of partition - device number of disk plus the partition number 188 * 5) /dev/<disk_name>p<decimal> - same as the above, that form is 189 * used when disk name of partitioned disk ends on a digit. 190 * 6) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the 191 * unique id of a partition if the partition table provides it. 192 * The UUID may be either an EFI/GPT UUID, or refer to an MSDOS 193 * partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero- 194 * filled hex representation of the 32-bit "NT disk signature", and PP 195 * is a zero-filled hex representation of the 1-based partition number. 196 * 7) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to 197 * a partition with a known unique id. 198 * 199 * If name doesn't have fall into the categories above, we return (0,0). 200 * block_class is used to check if something is a disk name. If the disk 201 * name contains slashes, the device name has them replaced with 202 * bangs. 203 */ 204 205 dev_t name_to_dev_t(char *name) 206 { 207 char s[32]; 208 char *p; 209 dev_t res = 0; 210 int part; 211 212 #ifdef CONFIG_BLOCK 213 if (strncmp(name, "PARTUUID=", 9) == 0) { 214 name += 9; 215 res = devt_from_partuuid(name); 216 if (!res) 217 goto fail; 218 goto done; 219 } 220 #endif 221 222 if (strncmp(name, "/dev/", 5) != 0) { 223 unsigned maj, min; 224 225 if (sscanf(name, "%u:%u", &maj, &min) == 2) { 226 res = MKDEV(maj, min); 227 if (maj != MAJOR(res) || min != MINOR(res)) 228 goto fail; 229 } else { 230 res = new_decode_dev(simple_strtoul(name, &p, 16)); 231 if (*p) 232 goto fail; 233 } 234 goto done; 235 } 236 237 name += 5; 238 res = Root_NFS; 239 if (strcmp(name, "nfs") == 0) 240 goto done; 241 res = Root_RAM0; 242 if (strcmp(name, "ram") == 0) 243 goto done; 244 245 if (strlen(name) > 31) 246 goto fail; 247 strcpy(s, name); 248 for (p = s; *p; p++) 249 if (*p == '/') 250 *p = '!'; 251 res = blk_lookup_devt(s, 0); 252 if (res) 253 goto done; 254 255 /* 256 * try non-existent, but valid partition, which may only exist 257 * after revalidating the disk, like partitioned md devices 258 */ 259 while (p > s && isdigit(p[-1])) 260 p--; 261 if (p == s || !*p || *p == '0') 262 goto fail; 263 264 /* try disk name without <part number> */ 265 part = simple_strtoul(p, NULL, 10); 266 *p = '\0'; 267 res = blk_lookup_devt(s, part); 268 if (res) 269 goto done; 270 271 /* try disk name without p<part number> */ 272 if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p') 273 goto fail; 274 p[-1] = '\0'; 275 res = blk_lookup_devt(s, part); 276 if (res) 277 goto done; 278 279 fail: 280 return 0; 281 done: 282 return res; 283 } 284 285 static int __init root_dev_setup(char *line) 286 { 287 strlcpy(saved_root_name, line, sizeof(saved_root_name)); 288 return 1; 289 } 290 291 __setup("root=", root_dev_setup); 292 293 static int __init rootwait_setup(char *str) 294 { 295 if (*str) 296 return 0; 297 root_wait = 1; 298 return 1; 299 } 300 301 __setup("rootwait", rootwait_setup); 302 303 static char * __initdata root_mount_data; 304 static int __init root_data_setup(char *str) 305 { 306 root_mount_data = str; 307 return 1; 308 } 309 310 static char * __initdata root_fs_names; 311 static int __init fs_names_setup(char *str) 312 { 313 root_fs_names = str; 314 return 1; 315 } 316 317 static unsigned int __initdata root_delay; 318 static int __init root_delay_setup(char *str) 319 { 320 root_delay = simple_strtoul(str, NULL, 0); 321 return 1; 322 } 323 324 __setup("rootflags=", root_data_setup); 325 __setup("rootfstype=", fs_names_setup); 326 __setup("rootdelay=", root_delay_setup); 327 328 static void __init get_fs_names(char *page) 329 { 330 char *s = page; 331 332 if (root_fs_names) { 333 strcpy(page, root_fs_names); 334 while (*s++) { 335 if (s[-1] == ',') 336 s[-1] = '\0'; 337 } 338 } else { 339 int len = get_filesystem_list(page); 340 char *p, *next; 341 342 page[len] = '\0'; 343 for (p = page-1; p; p = next) { 344 next = strchr(++p, '\n'); 345 if (*p++ != '\t') 346 continue; 347 while ((*s++ = *p++) != '\n') 348 ; 349 s[-1] = '\0'; 350 } 351 } 352 *s = '\0'; 353 } 354 355 static int __init do_mount_root(char *name, char *fs, int flags, void *data) 356 { 357 struct super_block *s; 358 int err = sys_mount(name, "/root", fs, flags, data); 359 if (err) 360 return err; 361 362 sys_chdir("/root"); 363 s = current->fs->pwd.dentry->d_sb; 364 ROOT_DEV = s->s_dev; 365 printk(KERN_INFO 366 "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n", 367 s->s_type->name, 368 s->s_flags & MS_RDONLY ? " readonly" : "", 369 MAJOR(ROOT_DEV), MINOR(ROOT_DEV)); 370 return 0; 371 } 372 373 void __init mount_block_root(char *name, int flags) 374 { 375 struct page *page = alloc_page(GFP_KERNEL | 376 __GFP_NOTRACK_FALSE_POSITIVE); 377 char *fs_names = page_address(page); 378 char *p; 379 #ifdef CONFIG_BLOCK 380 char b[BDEVNAME_SIZE]; 381 #else 382 const char *b = name; 383 #endif 384 385 get_fs_names(fs_names); 386 retry: 387 for (p = fs_names; *p; p += strlen(p)+1) { 388 int err = do_mount_root(name, p, flags, root_mount_data); 389 switch (err) { 390 case 0: 391 goto out; 392 case -EACCES: 393 flags |= MS_RDONLY; 394 goto retry; 395 case -EINVAL: 396 continue; 397 } 398 /* 399 * Allow the user to distinguish between failed sys_open 400 * and bad superblock on root device. 401 * and give them a list of the available devices 402 */ 403 #ifdef CONFIG_BLOCK 404 __bdevname(ROOT_DEV, b); 405 #endif 406 printk("VFS: Cannot open root device \"%s\" or %s: error %d\n", 407 root_device_name, b, err); 408 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n"); 409 410 printk_all_partitions(); 411 #ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT 412 printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify " 413 "explicit textual name for \"root=\" boot option.\n"); 414 #endif 415 panic("VFS: Unable to mount root fs on %s", b); 416 } 417 418 printk("List of all partitions:\n"); 419 printk_all_partitions(); 420 printk("No filesystem could mount root, tried: "); 421 for (p = fs_names; *p; p += strlen(p)+1) 422 printk(" %s", p); 423 printk("\n"); 424 #ifdef CONFIG_BLOCK 425 __bdevname(ROOT_DEV, b); 426 #endif 427 panic("VFS: Unable to mount root fs on %s", b); 428 out: 429 put_page(page); 430 } 431 432 #ifdef CONFIG_ROOT_NFS 433 434 #define NFSROOT_TIMEOUT_MIN 5 435 #define NFSROOT_TIMEOUT_MAX 30 436 #define NFSROOT_RETRY_MAX 5 437 438 static int __init mount_nfs_root(void) 439 { 440 char *root_dev, *root_data; 441 unsigned int timeout; 442 int try, err; 443 444 err = nfs_root_data(&root_dev, &root_data); 445 if (err != 0) 446 return 0; 447 448 /* 449 * The server or network may not be ready, so try several 450 * times. Stop after a few tries in case the client wants 451 * to fall back to other boot methods. 452 */ 453 timeout = NFSROOT_TIMEOUT_MIN; 454 for (try = 1; ; try++) { 455 err = do_mount_root(root_dev, "nfs", 456 root_mountflags, root_data); 457 if (err == 0) 458 return 1; 459 if (try > NFSROOT_RETRY_MAX) 460 break; 461 462 /* Wait, in case the server refused us immediately */ 463 ssleep(timeout); 464 timeout <<= 1; 465 if (timeout > NFSROOT_TIMEOUT_MAX) 466 timeout = NFSROOT_TIMEOUT_MAX; 467 } 468 return 0; 469 } 470 #endif 471 472 #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD) 473 void __init change_floppy(char *fmt, ...) 474 { 475 struct termios termios; 476 char buf[80]; 477 char c; 478 int fd; 479 va_list args; 480 va_start(args, fmt); 481 vsprintf(buf, fmt, args); 482 va_end(args); 483 fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0); 484 if (fd >= 0) { 485 sys_ioctl(fd, FDEJECT, 0); 486 sys_close(fd); 487 } 488 printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf); 489 fd = sys_open("/dev/console", O_RDWR, 0); 490 if (fd >= 0) { 491 sys_ioctl(fd, TCGETS, (long)&termios); 492 termios.c_lflag &= ~ICANON; 493 sys_ioctl(fd, TCSETSF, (long)&termios); 494 sys_read(fd, &c, 1); 495 termios.c_lflag |= ICANON; 496 sys_ioctl(fd, TCSETSF, (long)&termios); 497 sys_close(fd); 498 } 499 } 500 #endif 501 502 void __init mount_root(void) 503 { 504 #ifdef CONFIG_ROOT_NFS 505 if (ROOT_DEV == Root_NFS) { 506 if (mount_nfs_root()) 507 return; 508 509 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n"); 510 ROOT_DEV = Root_FD0; 511 } 512 #endif 513 #ifdef CONFIG_BLK_DEV_FD 514 if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) { 515 /* rd_doload is 2 for a dual initrd/ramload setup */ 516 if (rd_doload==2) { 517 if (rd_load_disk(1)) { 518 ROOT_DEV = Root_RAM1; 519 root_device_name = NULL; 520 } 521 } else 522 change_floppy("root floppy"); 523 } 524 #endif 525 #ifdef CONFIG_BLOCK 526 create_dev("/dev/root", ROOT_DEV); 527 mount_block_root("/dev/root", root_mountflags); 528 #endif 529 } 530 531 /* 532 * Prepare the namespace - decide what/where to mount, load ramdisks, etc. 533 */ 534 void __init prepare_namespace(void) 535 { 536 int is_floppy; 537 538 if (root_delay) { 539 printk(KERN_INFO "Waiting %dsec before mounting root device...\n", 540 root_delay); 541 ssleep(root_delay); 542 } 543 544 /* 545 * wait for the known devices to complete their probing 546 * 547 * Note: this is a potential source of long boot delays. 548 * For example, it is not atypical to wait 5 seconds here 549 * for the touchpad of a laptop to initialize. 550 */ 551 wait_for_device_probe(); 552 553 md_run_setup(); 554 555 if (saved_root_name[0]) { 556 root_device_name = saved_root_name; 557 if (!strncmp(root_device_name, "mtd", 3) || 558 !strncmp(root_device_name, "ubi", 3)) { 559 mount_block_root(root_device_name, root_mountflags); 560 goto out; 561 } 562 ROOT_DEV = name_to_dev_t(root_device_name); 563 if (strncmp(root_device_name, "/dev/", 5) == 0) 564 root_device_name += 5; 565 } 566 567 if (initrd_load()) 568 goto out; 569 570 /* wait for any asynchronous scanning to complete */ 571 if ((ROOT_DEV == 0) && root_wait) { 572 printk(KERN_INFO "Waiting for root device %s...\n", 573 saved_root_name); 574 while (driver_probe_done() != 0 || 575 (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0) 576 msleep(100); 577 async_synchronize_full(); 578 } 579 580 is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR; 581 582 if (is_floppy && rd_doload && rd_load_disk(0)) 583 ROOT_DEV = Root_RAM0; 584 585 mount_root(); 586 out: 587 devtmpfs_mount("dev"); 588 sys_mount(".", "/", NULL, MS_MOVE, NULL); 589 sys_chroot("."); 590 } 591