// SPDX-License-Identifier
: GPL-2
.0-only
#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/ramfs
.h>
#include <linux/shmem_fs
.h>
#include <linux/nfs_fs
.h>
#include <linux/nfs_fs_sb
.h>
#include <linux/nfs_mount
.h>
#include <linux/raid/detect
.h>
#include <uapi/linux/mount
.h>
#include "do_mounts
.h"
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
)
{
pr_warn
("ig
noring the deprecated load_ramdisk= option\n"
);
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, const void *data
)
{
const struct uuidcmp *cmp = data;
struct hd_struct *part = dev_
to_part
(dev
);
if
(!part->info
)
go
to no_match;
if
(strncasecmp
(cmp->uuid, part->info->uuid, cmp->len
))
go
to no_match;
return
1;
no_match
:
return 0;
}
/**
* devt_from_partuuid - looks
up the dev_t of a partition by its UUID
* @uuid_str
: 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_str is followed by a "/PARTNROFF=%d", then the num
ber will
be
* extracted and used as an off
set 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 off
set = 0;
bool clear_
root_wait = false;
char *slash;
cmp
.uuid = uuid_str;
slash = strchr
(uuid_str, '/'
);
/* Check for optional partition num
ber off
set attributes
. */
if
(slash
) {
char c = 0;
/* Explicitly fail on poor PARTUUID syntax
. */
if
(sscanf
(slash +
1,
"PARTNROFF=%d%c", &off
set, &c
) !=
1) {
clear_
root_wait = true;
go
to done;
}
cmp
.len = slash - uuid_str;
} else {
cmp
.len = strlen
(uuid_str
);
}
if
(!cmp
.len
) {
clear_
root_wait = true;
go
to done;
}
dev = class_
find_
device(&block_class, NULL, &cmp,
&match_dev_by_uuid
);
if
(!dev
)
go
to done;
res = dev->devt;
/* Attempt
to find the partition by off
set. */
if
(!off
set)
go
to no_off
set;
res = 0;
disk = part_
to_disk
(dev_
to_part
(dev
));
part = disk_get_part
(disk, dev_
to_part
(dev
)->part
no + off
set);
if
(part
) {
res = part_devt
(part
);
put_
device(part_
to_dev
(part
));
}
no_off
set:
put_
device(dev
);
done
:
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;
}
return res;
}
/**
* match_dev_by_la
bel - callback for
finding a partition using its la
bel
* @dev
: device passed in by the caller
* @data
: opaque pointer
to the la
bel
to match
*
* Returns
1 if the
device matches, and 0 otherwise
.
*/
static int match_dev_by_la
bel
(struct
device *dev, const void *data
)
{
const char *la
bel = data;
struct hd_struct *part = dev_
to_part
(dev
);
if
(part->info && !strcmp
(la
bel, part->info->volname
))
return
1;
return 0;
}
#endif
/*
* Convert a name in
to device num
ber
. We accept the following variants
:
*
*
1) <hex_major><hex_mi
nor>
device num
ber in hexadecimal represents itself
*
no leading 0x, for example b302
.
* 2
) /dev/nfs represents
Root_NFS
(0xff
)
* 3
) /dev/<disk_name> represents the
device num
ber of disk
* 4
) /dev/<disk_name><decimal> represents the
device num
ber
* of partition -
device num
ber of disk plus the partition num
ber
* 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=00
112233-4455-6677-8899-AABBCCDDEEFF representing the
* unique id of a partition if the partition table provides it
.
* 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 num
ber
.
* 7
) PARTUUID=<UUID>/PARTNROFF=<int>
to select a partition in relation
to
* a partition
with a k
nown unique id
.
* 8
) <major>
:<mi
nor> major and mi
nor num
ber of the
device separated by
* a colon
.
* 9
) PARTLA
BEL=<name>
with name
being the GPT partition la
bel
.
* MSDOS partitions do
not s
upport la
bels!
*
10
) /dev/cifs represents
Root_CIFS
(0xfe
)
*
* If name doesn't have fall in
to 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
(const 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
)
go
to fail;
go
to done;
} else if
(strncmp
(name, "PARTLA
BEL=",
10
) == 0
) {
struct
device *dev;
dev = class_
find_
device(&block_class, NULL, name +
10,
&match_dev_by_la
bel
);
if
(!dev
)
go
to fail;
res = dev->devt;
put_
device(dev
);
go
to done;
}
#endif
if
(strncmp
(name, "/dev/", 5
) != 0
) {
unsigned maj, min, off
set;
char dummy;
if
((sscanf
(name, "%u
:%u%c", &maj, &min, &dummy
) == 2
) ||
(sscanf
(name, "%u
:%u
:%u
:%c", &maj, &min, &off
set, &dummy
) == 3
)) {
res = MKDEV
(maj, min
);
if
(maj != MAJOR
(res
) || min != MI
NOR
(res
))
go
to fail;
} else {
res = new_decode_dev
(simple_str
toul
(name, &p,
16));
if
(*p
)
go
to fail;
}
go
to done;
}
name += 5;
res =
Root_NFS;
if
(strcmp
(name, "nfs"
) == 0
)
go
to done;
res =
Root_CIFS;
if
(strcmp
(name, "cifs"
) == 0
)
go
to done;
res =
Root_RAM0;
if
(strcmp
(name, "ram"
) == 0
)
go
to done;
if
(strlen
(name
) > 3
1)
go
to fail;
strcpy
(s, name
);
for
(p = s; *p; p++
)
if
(*p == '/'
)
*p = '!';
res = blk_look
up_devt
(s, 0
);
if
(res
)
go
to 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'
)
go
to fail;
/* try disk name
without <part num
ber> */
part = simple_str
toul
(p, NULL,
10
);
*p = '\0';
res = blk_look
up_devt
(s, part
);
if
(res
)
go
to done;
/* try disk name
without p<part num
ber> */
if
(p < s + 2 || !isdigit
(p[-2]
) || p[-
1] != 'p'
)
go
to fail;
p[-
1] = '\0';
res = blk_look
up_devt
(s, part
);
if
(res
)
go
to done;
fail
:
return 0;
done
:
return res;
}
EXPORT_SYMBOL_GPL
(name_
to_dev_t
);
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_str
toul
(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(const char *name, const char *fs,
const int flags, const void *data
)
{
struct s
uper_block *s;
struct page *p = NULL;
char *data_page = NULL;
int ret;
if
(data
) {
/* init_mount
() requires a full page as fifth argument */
p = alloc_page
(GFP_KERNEL
);
if
(!p
)
return -E
NOMEM;
data_page = page_address
(p
);
/* zero-pad
. init_mount
() will make sure it's terminated */
strncpy
(data_page, data, PAGE_SIZE
);
}
ret = init_mount
(name, "/
root", fs, flags, data_page
);
if
(ret
)
go
to out;
init_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,
sb_rdonly
(s
) ? " readonly"
: "",
MAJOR
(ROOT_DEV
), MI
NOR
(ROOT_DEV
));
out
:
if
(p
)
put_page
(p
);
return ret;
}
void __init mount_block_
root(char *name, int flags
)
{
struct page *page = alloc_page
(GFP_KERNEL
);
char *fs_names = page_address
(page
);
char *p;
char b[BDEVNAME_SIZE];
scnprintf
(b, BDEVNAME_SIZE, "unk
nown-block
(%u,%u
)",
MAJOR
(ROOT_DEV
), MI
NOR
(ROOT_DEV
));
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
:
go
to out;
case -EACCES
:
case -EINVAL
:
continue;
}
/*
* Allow the user
to distinguish
between failed sys_open
* and bad s
uperblock on
root device.
* and give them a list of the available
devices
*/
printk
("VFS
: Can
not 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
);
}
if
(!
(flags & SB_RDONLY
)) {
flags |= SB_RDONLY;
go
to retry;
}
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"
);
panic
("VFS
: Unable
to mount
root fs on %s", b
);
out
:
put_page
(page
);
}
#ifdef CONFIG_
ROOT_NFS
#define NFS
ROOT_TIMEOUT_MIN 5
#define NFS
ROOT_TIMEOUT_MAX 30
#define NFS
ROOT_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
. S
top after a few tries in case the client wants
*
to fall back
to other boot methods
.
*/
timeout = NFS
ROOT_TIMEOUT_MIN;
for
(try =
1; ; try++
) {
err = do_mount_
root(root_dev, "nfs",
root_mountflags,
root_data
);
if
(err == 0
)
return
1;
if
(try > NFS
ROOT_RETRY_MAX
)
break;
/* Wait, in case the server refused us immediately */
ssleep
(timeout
);
timeout <<=
1;
if
(timeout > NFS
ROOT_TIMEOUT_MAX
)
timeout = NFS
ROOT_TIMEOUT_MAX;
}
return 0;
}
#endif
#ifdef CONFIG_CIFS_
ROOT
extern int cifs_
root_data
(char **dev, char **opts
);
#define CIFS
ROOT_TIMEOUT_MIN 5
#define CIFS
ROOT_TIMEOUT_MAX 30
#define CIFS
ROOT_RETRY_MAX 5
static int __init mount_cifs_
root(void
)
{
char *
root_dev, *
root_data;
unsigned int timeout;
int try, err;
err = cifs_
root_data
(&
root_dev, &
root_data
);
if
(err != 0
)
return 0;
timeout = CIFS
ROOT_TIMEOUT_MIN;
for
(try =
1; ; try++
) {
err = do_mount_
root(root_dev, "cifs",
root_mountflags,
root_data
);
if
(err == 0
)
return
1;
if
(try > CIFS
ROOT_RETRY_MAX
)
break;
ssleep
(timeout
);
timeout <<=
1;
if
(timeout > CIFS
ROOT_TIMEOUT_MAX
)
timeout = CIFS
ROOT_TIMEOUT_MAX;
}
return 0;
}
#endif
void __init mount_
root(void
)
{
#ifdef CONFIG_
ROOT_NFS
if
(ROOT_DEV ==
Root_NFS
) {
if
(!mount_nfs_
root())
printk
(KERN_ERR "VFS
: Unable
to mount
root fs via NFS
.\n"
);
return;
}
#endif
#ifdef CONFIG_CIFS_
ROOT
if
(ROOT_DEV ==
Root_CIFS
) {
if
(!mount_cifs_
root())
printk
(KERN_ERR "VFS
: Unable
to mount
root fs via SMB
.\n"
);
return;
}
#endif
#ifdef CONFIG_BLOCK
{
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
);
}
#endif
}
/*
* Prepare the namespace - decide what/where
to mount, load ramdisks, etc
.
*/
void __init prepare_namespace
(void
)
{
if
(root_delay
) {
printk
(KERN_INFO "Waiting %d sec
before mounting
root device...\n",
root_delay
);
ssleep
(root_delay
);
}
/*
* wait for the k
nown
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 lap
top
to initialize
.
*/
wait_for_
device_pro
be();
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
);
go
to 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
())
go
to out;
/* wait for any asynchro
nous scanning
to complete */
if
((ROOT_DEV == 0
) &&
root_wait
) {
printk
(KERN_INFO "Waiting for
root device %s
...\n",
saved_
root_name
);
while
(driver_pro
be_done
() != 0 ||
(ROOT_DEV = name_
to_dev_t
(saved_
root_name
)) == 0
)
msleep
(5
);
async_synchronize_full
();
}
mount_
root();
out
:
devtmpfs_mount
();
init_mount
("
.", "/", NULL, MS_MOVE, NULL
);
init_ch
root("
."
);
}
static bool is_tmpfs;
static int
rootfs_init_fs_context
(struct fs_context *fc
)
{
if
(IS_ENABLED
(CONFIG_TMPFS
) && is_tmpfs
)
return shmem_init_fs_context
(fc
);
return ramfs_init_fs_context
(fc
);
}
struct
file_
system_type
rootfs_fs_type = {
.name = "
rootfs",
.init_fs_context =
rootfs_init_fs_context,
.kill_sb = kill_litter_s
uper,
};
void __init init_
rootfs(void
)
{
if
(IS_ENABLED
(CONFIG_TMPFS
) && !saved_
root_name[0] &&
(!
root_fs_names || strstr
(root_fs_names, "tmpfs"
)))
is_tmpfs = true;
}
详细解析一下
扫一扫
5478
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
