do_mounts.c 14.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 * Many of the syscalls used in this file expect some of the arguments
 * to be __user pointers not __kernel pointers.  To limit the sparse
 * noise, turn off sparse checking for this file.
 */
#ifdef __CHECKER__
#undef __CHECKER__
#warning "Sparse checking disabled for this file"
#endif

Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15 16 17 18 19
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/ctype.h>
#include <linux/fd.h>
#include <linux/tty.h>
#include <linux/suspend.h>
#include <linux/root_dev.h>
#include <linux/security.h>
#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
#include <linux/ramfs.h>
30
#include <linux/shmem_fs.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35 36 37 38 39

#include <linux/nfs_fs.h>
#include <linux/nfs_fs_sb.h>
#include <linux/nfs_mount.h>

#include "do_mounts.h"

int __initdata rd_doload;	/* 1 = load RAM disk, 0 = don't load */

40
int root_mountflags = MS_RDONLY | MS_SILENT;
41
static char * __initdata root_device_name;
Linus Torvalds's avatar
Linus Torvalds committed
42
static char __initdata saved_root_name[64];
43
static int root_wait;
Linus Torvalds's avatar
Linus Torvalds committed
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

dev_t ROOT_DEV;

static int __init load_ramdisk(char *str)
{
	rd_doload = simple_strtol(str,NULL,0) & 3;
	return 1;
}
__setup("load_ramdisk=", load_ramdisk);

static int __init readonly(char *str)
{
	if (*str)
		return 0;
	root_mountflags |= MS_RDONLY;
	return 1;
}

static int __init readwrite(char *str)
{
	if (*str)
		return 0;
	root_mountflags &= ~MS_RDONLY;
	return 1;
}

__setup("ro", readonly);
__setup("rw", readwrite);

73
#ifdef CONFIG_BLOCK
74 75 76 77 78
struct uuidcmp {
	const char *uuid;
	int len;
};

79 80 81
/**
 * match_dev_by_uuid - callback for finding a partition using its uuid
 * @dev:	device passed in by the caller
82
 * @data:	opaque pointer to the desired struct uuidcmp to match
83 84 85
 *
 * Returns 1 if the device matches, and 0 otherwise.
 */
86
static int match_dev_by_uuid(struct device *dev, const void *data)
87
{
88
	const struct uuidcmp *cmp = data;
89 90 91 92 93
	struct hd_struct *part = dev_to_part(dev);

	if (!part->info)
		goto no_match;

94 95
	if (strncasecmp(cmp->uuid, part->info->uuid, cmp->len))
		goto no_match;
96 97 98 99 100 101 102 103 104

	return 1;
no_match:
	return 0;
}


/**
 * devt_from_partuuid - looks up the dev_t of a partition by its UUID
105
 * @uuid_str:	char array containing ascii UUID
106 107 108 109 110
 *
 * The function will return the first partition which contains a matching
 * UUID value in its partition_meta_info struct.  This does not search
 * by filesystem UUIDs.
 *
111
 * If @uuid_str is followed by a "/PARTNROFF=%d", then the number will be
112 113
 * extracted and used as an offset from the partition identified by the UUID.
 *
114 115
 * Returns the matching dev_t on success or 0 on failure.
 */
116
static dev_t devt_from_partuuid(const char *uuid_str)
117 118
{
	dev_t res = 0;
119
	struct uuidcmp cmp;
120
	struct device *dev = NULL;
121 122 123
	struct gendisk *disk;
	struct hd_struct *part;
	int offset = 0;
124 125
	bool clear_root_wait = false;
	char *slash;
126

127 128
	cmp.uuid = uuid_str;

129
	slash = strchr(uuid_str, '/');
130
	/* Check for optional partition number offset attributes. */
131
	if (slash) {
132 133
		char c = 0;
		/* Explicitly fail on poor PARTUUID syntax. */
134 135 136
		if (sscanf(slash + 1,
			   "PARTNROFF=%d%c", &offset, &c) != 1) {
			clear_root_wait = true;
137 138
			goto done;
		}
139 140 141 142 143 144 145 146
		cmp.len = slash - uuid_str;
	} else {
		cmp.len = strlen(uuid_str);
	}

	if (!cmp.len) {
		clear_root_wait = true;
		goto done;
147
	}
148

149 150
	dev = class_find_device(&block_class, NULL, &cmp,
				&match_dev_by_uuid);
151 152 153 154 155
	if (!dev)
		goto done;

	res = dev->devt;

156 157 158 159 160 161 162 163 164 165 166 167 168 169
	/* Attempt to find the partition by offset. */
	if (!offset)
		goto no_offset;

	res = 0;
	disk = part_to_disk(dev_to_part(dev));
	part = disk_get_part(disk, dev_to_part(dev)->partno + offset);
	if (part) {
		res = part_devt(part);
		put_device(part_to_dev(part));
	}

no_offset:
	put_device(dev);
170
done:
171 172 173 174 175 176 177
	if (clear_root_wait) {
		pr_err("VFS: PARTUUID= is invalid.\n"
		       "Expected PARTUUID=<valid-uuid-id>[/PARTNROFF=%%d]\n");
		if (root_wait)
			pr_err("Disabling rootwait; root= is invalid.\n");
		root_wait = 0;
	}
178 179
	return res;
}
180
#endif
181

Linus Torvalds's avatar
Linus Torvalds committed
182 183 184
/*
 *	Convert a name into device number.  We accept the following variants:
 *
185 186
 *	1) <hex_major><hex_minor> device number in hexadecimal represents itself
 *         no leading 0x, for example b302.
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191 192
 *	2) /dev/nfs represents Root_NFS (0xff)
 *	3) /dev/<disk_name> represents the device number of disk
 *	4) /dev/<disk_name><decimal> represents the device number
 *         of partition - device number of disk plus the partition number
 *	5) /dev/<disk_name>p<decimal> - same as the above, that form is
 *	   used when disk name of partitioned disk ends on a digit.
193 194
 *	6) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
 *	   unique id of a partition if the partition table provides it.
195 196 197 198
 *	   The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
 *	   partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
 *	   filled hex representation of the 32-bit "NT disk signature", and PP
 *	   is a zero-filled hex representation of the 1-based partition number.
199 200
 *	7) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
 *	   a partition with a known unique id.
201 202
 *	8) <major>:<minor> major and minor number of the device separated by
 *	   a colon.
Linus Torvalds's avatar
Linus Torvalds committed
203
 *
204 205 206 207
 *	If name doesn't have fall into the categories above, we return (0,0).
 *	block_class is used to check if something is a disk name. If the disk
 *	name contains slashes, the device name has them replaced with
 *	bangs.
Linus Torvalds's avatar
Linus Torvalds committed
208 209
 */

210
dev_t name_to_dev_t(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
211 212 213 214
{
	char s[32];
	char *p;
	dev_t res = 0;
215
	int part;
Linus Torvalds's avatar
Linus Torvalds committed
216

217
#ifdef CONFIG_BLOCK
218 219 220 221 222 223 224
	if (strncmp(name, "PARTUUID=", 9) == 0) {
		name += 9;
		res = devt_from_partuuid(name);
		if (!res)
			goto fail;
		goto done;
	}
225
#endif
226

Linus Torvalds's avatar
Linus Torvalds committed
227
	if (strncmp(name, "/dev/", 5) != 0) {
228
		unsigned maj, min, offset;
229
		char dummy;
Linus Torvalds's avatar
Linus Torvalds committed
230

231 232
		if ((sscanf(name, "%u:%u%c", &maj, &min, &dummy) == 2) ||
		    (sscanf(name, "%u:%u:%u:%c", &maj, &min, &offset, &dummy) == 3)) {
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236 237 238 239 240 241 242
			res = MKDEV(maj, min);
			if (maj != MAJOR(res) || min != MINOR(res))
				goto fail;
		} else {
			res = new_decode_dev(simple_strtoul(name, &p, 16));
			if (*p)
				goto fail;
		}
		goto done;
	}
243

Linus Torvalds's avatar
Linus Torvalds committed
244 245 246 247 248 249 250 251 252 253 254 255 256 257
	name += 5;
	res = Root_NFS;
	if (strcmp(name, "nfs") == 0)
		goto done;
	res = Root_RAM0;
	if (strcmp(name, "ram") == 0)
		goto done;

	if (strlen(name) > 31)
		goto fail;
	strcpy(s, name);
	for (p = s; *p; p++)
		if (*p == '/')
			*p = '!';
258 259 260 261 262
	res = blk_lookup_devt(s, 0);
	if (res)
		goto done;

	/*
Lucas De Marchi's avatar
Lucas De Marchi committed
263
	 * try non-existent, but valid partition, which may only exist
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
	 * after revalidating the disk, like partitioned md devices
	 */
	while (p > s && isdigit(p[-1]))
		p--;
	if (p == s || !*p || *p == '0')
		goto fail;

	/* try disk name without <part number> */
	part = simple_strtoul(p, NULL, 10);
	*p = '\0';
	res = blk_lookup_devt(s, part);
	if (res)
		goto done;

	/* try disk name without p<part number> */
	if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
		goto fail;
	p[-1] = '\0';
	res = blk_lookup_devt(s, part);
Linus Torvalds's avatar
Linus Torvalds committed
283 284 285
	if (res)
		goto done;

286 287
fail:
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
288 289 290
done:
	return res;
}
291
EXPORT_SYMBOL_GPL(name_to_dev_t);
Linus Torvalds's avatar
Linus Torvalds committed
292 293 294 295 296 297 298 299 300

static int __init root_dev_setup(char *line)
{
	strlcpy(saved_root_name, line, sizeof(saved_root_name));
	return 1;
}

__setup("root=", root_dev_setup);

301 302 303 304 305 306 307 308 309 310
static int __init rootwait_setup(char *str)
{
	if (*str)
		return 0;
	root_wait = 1;
	return 1;
}

__setup("rootwait", rootwait_setup);

Linus Torvalds's avatar
Linus Torvalds committed
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
static char * __initdata root_mount_data;
static int __init root_data_setup(char *str)
{
	root_mount_data = str;
	return 1;
}

static char * __initdata root_fs_names;
static int __init fs_names_setup(char *str)
{
	root_fs_names = str;
	return 1;
}

static unsigned int __initdata root_delay;
static int __init root_delay_setup(char *str)
{
	root_delay = simple_strtoul(str, NULL, 0);
	return 1;
}

__setup("rootflags=", root_data_setup);
__setup("rootfstype=", fs_names_setup);
__setup("rootdelay=", root_delay_setup);

static void __init get_fs_names(char *page)
{
	char *s = page;

	if (root_fs_names) {
		strcpy(page, root_fs_names);
		while (*s++) {
			if (s[-1] == ',')
				s[-1] = '\0';
		}
	} else {
		int len = get_filesystem_list(page);
		char *p, *next;

		page[len] = '\0';
		for (p = page-1; p; p = next) {
			next = strchr(++p, '\n');
			if (*p++ != '\t')
				continue;
			while ((*s++ = *p++) != '\n')
				;
			s[-1] = '\0';
		}
	}
	*s = '\0';
}

static int __init do_mount_root(char *name, char *fs, int flags, void *data)
{
365
	struct super_block *s;
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369
	int err = sys_mount(name, "/root", fs, flags, data);
	if (err)
		return err;

370
	sys_chdir("/root");
371 372
	s = current->fs->pwd.dentry->d_sb;
	ROOT_DEV = s->s_dev;
373 374
	printk(KERN_INFO
	       "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
375
	       s->s_type->name,
376
	       sb_rdonly(s) ? " readonly" : "",
377
	       MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
Linus Torvalds's avatar
Linus Torvalds committed
378 379 380 381 382
	return 0;
}

void __init mount_block_root(char *name, int flags)
{
383 384 385
	struct page *page = alloc_page(GFP_KERNEL |
					__GFP_NOTRACK_FALSE_POSITIVE);
	char *fs_names = page_address(page);
Linus Torvalds's avatar
Linus Torvalds committed
386
	char *p;
387
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
388
	char b[BDEVNAME_SIZE];
389 390 391
#else
	const char *b = name;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406

	get_fs_names(fs_names);
retry:
	for (p = fs_names; *p; p += strlen(p)+1) {
		int err = do_mount_root(name, p, flags, root_mount_data);
		switch (err) {
			case 0:
				goto out;
			case -EACCES:
			case -EINVAL:
				continue;
		}
	        /*
		 * Allow the user to distinguish between failed sys_open
		 * and bad superblock on root device.
407
		 * and give them a list of the available devices
Linus Torvalds's avatar
Linus Torvalds committed
408
		 */
409
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
410
		__bdevname(ROOT_DEV, b);
411
#endif
412 413
		printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
				root_device_name, b, err);
414
		printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
Linus Torvalds's avatar
Linus Torvalds committed
415

416
		printk_all_partitions();
417 418 419 420
#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
		printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
		       "explicit textual name for \"root=\" boot option.\n");
#endif
Linus Torvalds's avatar
Linus Torvalds committed
421 422
		panic("VFS: Unable to mount root fs on %s", b);
	}
423 424
	if (!(flags & SB_RDONLY)) {
		flags |= SB_RDONLY;
425 426
		goto retry;
	}
427

428 429
	printk("List of all partitions:\n");
	printk_all_partitions();
430 431 432 433
	printk("No filesystem could mount root, tried: ");
	for (p = fs_names; *p; p += strlen(p)+1)
		printk(" %s", p);
	printk("\n");
434 435 436 437
#ifdef CONFIG_BLOCK
	__bdevname(ROOT_DEV, b);
#endif
	panic("VFS: Unable to mount root fs on %s", b);
Linus Torvalds's avatar
Linus Torvalds committed
438
out:
439
	put_page(page);
Linus Torvalds's avatar
Linus Torvalds committed
440 441 442
}
 
#ifdef CONFIG_ROOT_NFS
Chuck Lever's avatar
Chuck Lever committed
443 444 445 446 447

#define NFSROOT_TIMEOUT_MIN	5
#define NFSROOT_TIMEOUT_MAX	30
#define NFSROOT_RETRY_MAX	5

Linus Torvalds's avatar
Linus Torvalds committed
448 449
static int __init mount_nfs_root(void)
{
450
	char *root_dev, *root_data;
Chuck Lever's avatar
Chuck Lever committed
451 452
	unsigned int timeout;
	int try, err;
Linus Torvalds's avatar
Linus Torvalds committed
453

Chuck Lever's avatar
Chuck Lever committed
454 455
	err = nfs_root_data(&root_dev, &root_data);
	if (err != 0)
456
		return 0;
Chuck Lever's avatar
Chuck Lever committed
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478

	/*
	 * The server or network may not be ready, so try several
	 * times.  Stop after a few tries in case the client wants
	 * to fall back to other boot methods.
	 */
	timeout = NFSROOT_TIMEOUT_MIN;
	for (try = 1; ; try++) {
		err = do_mount_root(root_dev, "nfs",
					root_mountflags, root_data);
		if (err == 0)
			return 1;
		if (try > NFSROOT_RETRY_MAX)
			break;

		/* Wait, in case the server refused us immediately */
		ssleep(timeout);
		timeout <<= 1;
		if (timeout > NFSROOT_TIMEOUT_MAX)
			timeout = NFSROOT_TIMEOUT_MAX;
	}
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
}
#endif

#if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
void __init change_floppy(char *fmt, ...)
{
	struct termios termios;
	char buf[80];
	char c;
	int fd;
	va_list args;
	va_start(args, fmt);
	vsprintf(buf, fmt, args);
	va_end(args);
	fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0);
	if (fd >= 0) {
		sys_ioctl(fd, FDEJECT, 0);
		sys_close(fd);
	}
	printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
	fd = sys_open("/dev/console", O_RDWR, 0);
	if (fd >= 0) {
		sys_ioctl(fd, TCGETS, (long)&termios);
		termios.c_lflag &= ~ICANON;
		sys_ioctl(fd, TCSETSF, (long)&termios);
		sys_read(fd, &c, 1);
		termios.c_lflag |= ICANON;
		sys_ioctl(fd, TCSETSF, (long)&termios);
		sys_close(fd);
	}
}
#endif

void __init mount_root(void)
{
#ifdef CONFIG_ROOT_NFS
515
	if (ROOT_DEV == Root_NFS) {
Linus Torvalds's avatar
Linus Torvalds committed
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
		if (mount_nfs_root())
			return;

		printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
		ROOT_DEV = Root_FD0;
	}
#endif
#ifdef CONFIG_BLK_DEV_FD
	if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
		/* rd_doload is 2 for a dual initrd/ramload setup */
		if (rd_doload==2) {
			if (rd_load_disk(1)) {
				ROOT_DEV = Root_RAM1;
				root_device_name = NULL;
			}
		} else
			change_floppy("root floppy");
	}
#endif
535
#ifdef CONFIG_BLOCK
536 537 538 539 540 541 542
	{
		int err = create_dev("/dev/root", ROOT_DEV);

		if (err < 0)
			pr_emerg("Failed to create /dev/root: %d\n", err);
		mount_block_root("/dev/root", root_mountflags);
	}
543
#endif
Linus Torvalds's avatar
Linus Torvalds committed
544 545 546 547 548 549 550 551 552 553
}

/*
 * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
 */
void __init prepare_namespace(void)
{
	int is_floppy;

	if (root_delay) {
554
		printk(KERN_INFO "Waiting %d sec before mounting root device...\n",
Linus Torvalds's avatar
Linus Torvalds committed
555 556 557 558
		       root_delay);
		ssleep(root_delay);
	}

559 560 561 562 563 564 565 566
	/*
	 * wait for the known devices to complete their probing
	 *
	 * Note: this is a potential source of long boot delays.
	 * For example, it is not atypical to wait 5 seconds here
	 * for the touchpad of a laptop to initialize.
	 */
	wait_for_device_probe();
567

Linus Torvalds's avatar
Linus Torvalds committed
568 569 570 571
	md_run_setup();

	if (saved_root_name[0]) {
		root_device_name = saved_root_name;
572 573
		if (!strncmp(root_device_name, "mtd", 3) ||
		    !strncmp(root_device_name, "ubi", 3)) {
574 575 576
			mount_block_root(root_device_name, root_mountflags);
			goto out;
		}
Linus Torvalds's avatar
Linus Torvalds committed
577 578 579 580 581 582 583 584
		ROOT_DEV = name_to_dev_t(root_device_name);
		if (strncmp(root_device_name, "/dev/", 5) == 0)
			root_device_name += 5;
	}

	if (initrd_load())
		goto out;

585 586 587 588 589 590
	/* wait for any asynchronous scanning to complete */
	if ((ROOT_DEV == 0) && root_wait) {
		printk(KERN_INFO "Waiting for root device %s...\n",
			saved_root_name);
		while (driver_probe_done() != 0 ||
			(ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
591
			msleep(5);
592
		async_synchronize_full();
593 594 595 596
	}

	is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;

Linus Torvalds's avatar
Linus Torvalds committed
597 598 599 600 601
	if (is_floppy && rd_doload && rd_load_disk(0))
		ROOT_DEV = Root_RAM0;

	mount_root();
out:
602
	devtmpfs_mount("dev");
Linus Torvalds's avatar
Linus Torvalds committed
603
	sys_mount(".", "/", NULL, MS_MOVE, NULL);
604
	sys_chroot(".");
Linus Torvalds's avatar
Linus Torvalds committed
605
}
606

607
static bool is_tmpfs;
608 609 610 611
static struct dentry *rootfs_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
{
	static unsigned long once;
612
	void *fill = ramfs_fill_super;
613 614 615 616

	if (test_and_set_bit(0, &once))
		return ERR_PTR(-ENODEV);

617 618 619 620
	if (IS_ENABLED(CONFIG_TMPFS) && is_tmpfs)
		fill = shmem_fill_super;

	return mount_nodev(fs_type, flags, data, fill);
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
}

static struct file_system_type rootfs_fs_type = {
	.name		= "rootfs",
	.mount		= rootfs_mount,
	.kill_sb	= kill_litter_super,
};

int __init init_rootfs(void)
{
	int err = register_filesystem(&rootfs_fs_type);

	if (err)
		return err;

636 637
	if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
		(!root_fs_names || strstr(root_fs_names, "tmpfs"))) {
638
		err = shmem_init();
639 640
		is_tmpfs = true;
	} else {
641
		err = init_ramfs_fs();
642
	}
643

644 645 646 647 648
	if (err)
		unregister_filesystem(&rootfs_fs_type);

	return err;
}