1ad7e89940
This will allow other types of UUID to be stored here, aside from true UUIDs. This also simplifies code that uses this field, since it's usually constructed from a, used as a, or compared to other, strings. Note: A simplistic approach here would be to set uuid_str[36]=0 whenever a /PARTNROFF option was found to be present. However, this modifies the input string, and causes subsequent calls to devt_from_partuuid() not to see the /PARTNROFF option, which causes different results. In order to avoid misleading future maintainers, this parameter is marked const. Signed-off-by: Stephen Warren <swarren@nvidia.com> Cc: Tejun Heo <tj@kernel.org> Cc: Will Drewry <wad@chromium.org> Cc: Kay Sievers <kay.sievers@vrfy.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Jens Axboe <axboe@kernel.dk>
578 lines
13 KiB
C
578 lines
13 KiB
C
/*
|
|
* 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
|
|
|
|
#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>
|
|
#include <linux/genhd.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/device.h>
|
|
#include <linux/init.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/initrd.h>
|
|
#include <linux/async.h>
|
|
#include <linux/fs_struct.h>
|
|
#include <linux/slab.h>
|
|
|
|
#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 */
|
|
|
|
int root_mountflags = MS_RDONLY | MS_SILENT;
|
|
static char * __initdata root_device_name;
|
|
static char __initdata saved_root_name[64];
|
|
static int root_wait;
|
|
|
|
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);
|
|
|
|
#ifdef CONFIG_BLOCK
|
|
struct uuidcmp {
|
|
const char *uuid;
|
|
int len;
|
|
};
|
|
|
|
/**
|
|
* match_dev_by_uuid - callback for finding a partition using its uuid
|
|
* @dev: device passed in by the caller
|
|
* @data: opaque pointer to the desired struct uuidcmp to match
|
|
*
|
|
* Returns 1 if the device matches, and 0 otherwise.
|
|
*/
|
|
static int match_dev_by_uuid(struct device *dev, void *data)
|
|
{
|
|
struct uuidcmp *cmp = data;
|
|
struct hd_struct *part = dev_to_part(dev);
|
|
|
|
if (!part->info)
|
|
goto no_match;
|
|
|
|
if (strncasecmp(cmp->uuid, part->info->uuid, cmp->len))
|
|
goto no_match;
|
|
|
|
return 1;
|
|
no_match:
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* devt_from_partuuid - looks up the dev_t of a partition by its UUID
|
|
* @uuid: char array containing ascii UUID
|
|
*
|
|
* 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.
|
|
*
|
|
* If @uuid is followed by a "/PARTNROFF=%d", then the number will be
|
|
* extracted and used as an offset from the partition identified by the UUID.
|
|
*
|
|
* Returns the matching dev_t on success or 0 on failure.
|
|
*/
|
|
static dev_t devt_from_partuuid(const char *uuid_str)
|
|
{
|
|
dev_t res = 0;
|
|
struct uuidcmp cmp;
|
|
struct device *dev = NULL;
|
|
struct gendisk *disk;
|
|
struct hd_struct *part;
|
|
int offset = 0;
|
|
|
|
if (strlen(uuid_str) < 36)
|
|
goto done;
|
|
|
|
cmp.uuid = uuid_str;
|
|
cmp.len = 36;
|
|
|
|
/* Check for optional partition number offset attributes. */
|
|
if (uuid_str[36]) {
|
|
char c = 0;
|
|
/* Explicitly fail on poor PARTUUID syntax. */
|
|
if (sscanf(&uuid_str[36],
|
|
"/PARTNROFF=%d%c", &offset, &c) != 1) {
|
|
printk(KERN_ERR "VFS: PARTUUID= is invalid.\n"
|
|
"Expected PARTUUID=<valid-uuid-id>[/PARTNROFF=%%d]\n");
|
|
if (root_wait)
|
|
printk(KERN_ERR
|
|
"Disabling rootwait; root= is invalid.\n");
|
|
root_wait = 0;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
dev = class_find_device(&block_class, NULL, &cmp,
|
|
&match_dev_by_uuid);
|
|
if (!dev)
|
|
goto done;
|
|
|
|
res = dev->devt;
|
|
|
|
/* 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);
|
|
done:
|
|
return res;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Convert a name into device number. We accept the following variants:
|
|
*
|
|
* 1) device number in hexadecimal represents itself
|
|
* 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.
|
|
* 6) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
|
|
* unique id of a partition if the partition table provides it.
|
|
* 7) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
|
|
* a partition with a known unique id.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
dev_t name_to_dev_t(char *name)
|
|
{
|
|
char s[32];
|
|
char *p;
|
|
dev_t res = 0;
|
|
int part;
|
|
|
|
#ifdef CONFIG_BLOCK
|
|
if (strncmp(name, "PARTUUID=", 9) == 0) {
|
|
name += 9;
|
|
res = devt_from_partuuid(name);
|
|
if (!res)
|
|
goto fail;
|
|
goto done;
|
|
}
|
|
#endif
|
|
|
|
if (strncmp(name, "/dev/", 5) != 0) {
|
|
unsigned maj, min;
|
|
|
|
if (sscanf(name, "%u:%u", &maj, &min) == 2) {
|
|
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;
|
|
}
|
|
|
|
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 = '!';
|
|
res = blk_lookup_devt(s, 0);
|
|
if (res)
|
|
goto done;
|
|
|
|
/*
|
|
* try non-existent, but valid partition, which may only exist
|
|
* 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);
|
|
if (res)
|
|
goto done;
|
|
|
|
fail:
|
|
return 0;
|
|
done:
|
|
return res;
|
|
}
|
|
|
|
static int __init root_dev_setup(char *line)
|
|
{
|
|
strlcpy(saved_root_name, line, sizeof(saved_root_name));
|
|
return 1;
|
|
}
|
|
|
|
__setup("root=", root_dev_setup);
|
|
|
|
static int __init rootwait_setup(char *str)
|
|
{
|
|
if (*str)
|
|
return 0;
|
|
root_wait = 1;
|
|
return 1;
|
|
}
|
|
|
|
__setup("rootwait", rootwait_setup);
|
|
|
|
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)
|
|
{
|
|
struct super_block *s;
|
|
int err = sys_mount(name, "/root", fs, flags, data);
|
|
if (err)
|
|
return err;
|
|
|
|
sys_chdir("/root");
|
|
s = current->fs->pwd.dentry->d_sb;
|
|
ROOT_DEV = s->s_dev;
|
|
printk(KERN_INFO
|
|
"VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
|
|
s->s_type->name,
|
|
s->s_flags & MS_RDONLY ? " readonly" : "",
|
|
MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
|
|
return 0;
|
|
}
|
|
|
|
void __init mount_block_root(char *name, int flags)
|
|
{
|
|
struct page *page = alloc_page(GFP_KERNEL |
|
|
__GFP_NOTRACK_FALSE_POSITIVE);
|
|
char *fs_names = page_address(page);
|
|
char *p;
|
|
#ifdef CONFIG_BLOCK
|
|
char b[BDEVNAME_SIZE];
|
|
#else
|
|
const char *b = name;
|
|
#endif
|
|
|
|
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:
|
|
flags |= MS_RDONLY;
|
|
goto retry;
|
|
case -EINVAL:
|
|
continue;
|
|
}
|
|
/*
|
|
* Allow the user to distinguish between failed sys_open
|
|
* and bad superblock on root device.
|
|
* and give them a list of the available devices
|
|
*/
|
|
#ifdef CONFIG_BLOCK
|
|
__bdevname(ROOT_DEV, b);
|
|
#endif
|
|
printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
|
|
root_device_name, b, err);
|
|
printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
|
|
|
|
printk_all_partitions();
|
|
#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
|
|
panic("VFS: Unable to mount root fs on %s", b);
|
|
}
|
|
|
|
printk("List of all partitions:\n");
|
|
printk_all_partitions();
|
|
printk("No filesystem could mount root, tried: ");
|
|
for (p = fs_names; *p; p += strlen(p)+1)
|
|
printk(" %s", p);
|
|
printk("\n");
|
|
#ifdef CONFIG_BLOCK
|
|
__bdevname(ROOT_DEV, b);
|
|
#endif
|
|
panic("VFS: Unable to mount root fs on %s", b);
|
|
out:
|
|
put_page(page);
|
|
}
|
|
|
|
#ifdef CONFIG_ROOT_NFS
|
|
|
|
#define NFSROOT_TIMEOUT_MIN 5
|
|
#define NFSROOT_TIMEOUT_MAX 30
|
|
#define NFSROOT_RETRY_MAX 5
|
|
|
|
static int __init mount_nfs_root(void)
|
|
{
|
|
char *root_dev, *root_data;
|
|
unsigned int timeout;
|
|
int try, err;
|
|
|
|
err = nfs_root_data(&root_dev, &root_data);
|
|
if (err != 0)
|
|
return 0;
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
#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
|
|
if (ROOT_DEV == Root_NFS) {
|
|
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
|
|
#ifdef CONFIG_BLOCK
|
|
create_dev("/dev/root", ROOT_DEV);
|
|
mount_block_root("/dev/root", root_mountflags);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Prepare the namespace - decide what/where to mount, load ramdisks, etc.
|
|
*/
|
|
void __init prepare_namespace(void)
|
|
{
|
|
int is_floppy;
|
|
|
|
if (root_delay) {
|
|
printk(KERN_INFO "Waiting %dsec before mounting root device...\n",
|
|
root_delay);
|
|
ssleep(root_delay);
|
|
}
|
|
|
|
/*
|
|
* 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();
|
|
|
|
md_run_setup();
|
|
|
|
if (saved_root_name[0]) {
|
|
root_device_name = saved_root_name;
|
|
if (!strncmp(root_device_name, "mtd", 3) ||
|
|
!strncmp(root_device_name, "ubi", 3)) {
|
|
mount_block_root(root_device_name, root_mountflags);
|
|
goto out;
|
|
}
|
|
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;
|
|
|
|
/* 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)
|
|
msleep(100);
|
|
async_synchronize_full();
|
|
}
|
|
|
|
is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
|
|
|
|
if (is_floppy && rd_doload && rd_load_disk(0))
|
|
ROOT_DEV = Root_RAM0;
|
|
|
|
mount_root();
|
|
out:
|
|
devtmpfs_mount("dev");
|
|
sys_mount(".", "/", NULL, MS_MOVE, NULL);
|
|
sys_chroot(".");
|
|
}
|