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
	struct page *page = alloc_page(GFP_KERNEL);
384
	char *fs_names = page_address(page);
Linus Torvalds's avatar
Linus Torvalds committed
385
	char *p;
386
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
387
	char b[BDEVNAME_SIZE];
388 389 390
#else
	const char *b = name;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405

	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.
406
		 * and give them a list of the available devices
Linus Torvalds's avatar
Linus Torvalds committed
407
		 */
408
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
409
		__bdevname(ROOT_DEV, b);
410
#endif
411 412
		printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
				root_device_name, b, err);
413
		printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
Linus Torvalds's avatar
Linus Torvalds committed
414

415
		printk_all_partitions();
416 417 418 419
#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
420 421
		panic("VFS: Unable to mount root fs on %s", b);
	}
422 423
	if (!(flags & SB_RDONLY)) {
		flags |= SB_RDONLY;
424 425
		goto retry;
	}
426

427 428
	printk("List of all partitions:\n");
	printk_all_partitions();
429 430 431 432
	printk("No filesystem could mount root, tried: ");
	for (p = fs_names; *p; p += strlen(p)+1)
		printk(" %s", p);
	printk("\n");
433 434 435 436
#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
437
out:
438
	put_page(page);
Linus Torvalds's avatar
Linus Torvalds committed
439 440 441
}
 
#ifdef CONFIG_ROOT_NFS
Chuck Lever's avatar
Chuck Lever committed
442 443 444 445 446

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

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

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

	/*
	 * 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
478 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
}
#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
514
	if (ROOT_DEV == Root_NFS) {
Linus Torvalds's avatar
Linus Torvalds committed
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
		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
534
#ifdef CONFIG_BLOCK
535 536 537 538 539 540 541
	{
		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);
	}
542
#endif
Linus Torvalds's avatar
Linus Torvalds committed
543 544 545 546 547 548 549 550 551 552
}

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

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

558 559 560 561 562 563 564 565
	/*
	 * 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();
566

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

	if (saved_root_name[0]) {
		root_device_name = saved_root_name;
571 572
		if (!strncmp(root_device_name, "mtd", 3) ||
		    !strncmp(root_device_name, "ubi", 3)) {
573 574 575
			mount_block_root(root_device_name, root_mountflags);
			goto out;
		}
Linus Torvalds's avatar
Linus Torvalds committed
576 577 578 579 580 581 582 583
		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;

584 585 586 587 588 589
	/* 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)
590
			msleep(5);
591
		async_synchronize_full();
592 593 594 595
	}

	is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;

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

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

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

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

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

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

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;

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

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

	return err;
}