| From 6a6a7657c231e947233c43ae0522bbd4edf0139e Mon Sep 17 00:00:00 2001 |
| From: David Zeuthen <zeuthen@google.com> |
| Date: Tue, 24 Jan 2017 13:02:35 -0500 |
| Subject: [PATCH 1/2] ANDROID: Update init/do_mounts_dm.c to the latest |
| ChromiumOS version. |
| |
| This is needed for AVB integration work. |
| |
| Bug: 31796270 |
| Test: Manually tested (other arch). |
| Change-Id: I32fd37c1578c6414e3e6ff277d16ad94df7886b8 |
| Signed-off-by: David Zeuthen <zeuthen@google.com> |
| --- |
| include/linux/device-mapper.h | 7 + |
| init/do_mounts_dm.c | 556 +++++++++++++++++++++++------------------- |
| 2 files changed, 307 insertions(+), 256 deletions(-) |
| |
| diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h |
| index b874d5b61ffc..f3f87db34429 100644 |
| --- a/include/linux/device-mapper.h |
| +++ b/include/linux/device-mapper.h |
| @@ -415,6 +415,13 @@ union map_info *dm_get_rq_mapinfo(struct request *rq); |
| |
| struct queue_limits *dm_get_queue_limits(struct mapped_device *md); |
| |
| +void dm_lock_md_type(struct mapped_device *md); |
| +void dm_unlock_md_type(struct mapped_device *md); |
| +void dm_set_md_type(struct mapped_device *md, unsigned type); |
| +unsigned dm_get_md_type(struct mapped_device *md); |
| +int dm_setup_md_queue(struct mapped_device *md); |
| +unsigned dm_table_get_type(struct dm_table *t); |
| + |
| /* |
| * Geometry functions. |
| */ |
| diff --git a/init/do_mounts_dm.c b/init/do_mounts_dm.c |
| index ecda58df9a19..bce1c2fbb915 100644 |
| --- a/init/do_mounts_dm.c |
| +++ b/init/do_mounts_dm.c |
| @@ -5,13 +5,17 @@ |
| * |
| * This file is released under the GPL. |
| */ |
| +#include <linux/async.h> |
| +#include <linux/ctype.h> |
| #include <linux/device-mapper.h> |
| #include <linux/fs.h> |
| #include <linux/string.h> |
| +#include <linux/delay.h> |
| |
| #include "do_mounts.h" |
| -#include "../drivers/md/dm.h" |
| |
| +#define DM_MAX_DEVICES 256 |
| +#define DM_MAX_TARGETS 256 |
| #define DM_MAX_NAME 32 |
| #define DM_MAX_UUID 129 |
| #define DM_NO_UUID "none" |
| @@ -19,14 +23,47 @@ |
| #define DM_MSG_PREFIX "init" |
| |
| /* Separators used for parsing the dm= argument. */ |
| -#define DM_FIELD_SEP ' ' |
| -#define DM_LINE_SEP ',' |
| +#define DM_FIELD_SEP " " |
| +#define DM_LINE_SEP "," |
| +#define DM_ANY_SEP DM_FIELD_SEP DM_LINE_SEP |
| |
| /* |
| * When the device-mapper and any targets are compiled into the kernel |
| - * (not a module), one target may be created and used as the root device at |
| - * boot time with the parameters given with the boot line dm=... |
| - * The code for that is here. |
| + * (not a module), one or more device-mappers may be created and used |
| + * as the root device at boot time with the parameters given with the |
| + * boot line dm=... |
| + * |
| + * Multiple device-mappers can be stacked specifing the number of |
| + * devices. A device can have multiple targets if the the number of |
| + * targets is specified. |
| + * |
| + * TODO(taysom:defect 32847) |
| + * In the future, the <num> field will be mandatory. |
| + * |
| + * <device> ::= [<num>] <device-mapper>+ |
| + * <device-mapper> ::= <head> "," <target>+ |
| + * <head> ::= <name> <uuid> <mode> [<num>] |
| + * <target> ::= <start> <length> <type> <options> "," |
| + * <mode> ::= "ro" | "rw" |
| + * <uuid> ::= xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | "none" |
| + * <type> ::= "verity" | "bootcache" | ... |
| + * |
| + * Example: |
| + * 2 vboot none ro 1, |
| + * 0 1768000 bootcache |
| + * device=aa55b119-2a47-8c45-946a-5ac57765011f+1 |
| + * signature=76e9be054b15884a9fa85973e9cb274c93afadb6 |
| + * cache_start=1768000 max_blocks=100000 size_limit=23 max_trace=20000, |
| + * vroot none ro 1, |
| + * 0 1740800 verity payload=254:0 hashtree=254:0 hashstart=1740800 alg=sha1 |
| + * root_hexdigest=76e9be054b15884a9fa85973e9cb274c93afadb6 |
| + * salt=5b3549d54d6c7a3837b9b81ed72e49463a64c03680c47835bef94d768e5646fe |
| + * |
| + * Notes: |
| + * 1. uuid is a label for the device and we set it to "none". |
| + * 2. The <num> field will be optional initially and assumed to be 1. |
| + * Once all the scripts that set these fields have been set, it will |
| + * be made mandatory. |
| */ |
| |
| struct dm_setup_target { |
| @@ -38,381 +75,388 @@ struct dm_setup_target { |
| struct dm_setup_target *next; |
| }; |
| |
| -static struct { |
| +struct dm_device { |
| int minor; |
| int ro; |
| char name[DM_MAX_NAME]; |
| char uuid[DM_MAX_UUID]; |
| - char *targets; |
| + unsigned long num_targets; |
| struct dm_setup_target *target; |
| int target_count; |
| + struct dm_device *next; |
| +}; |
| + |
| +struct dm_option { |
| + char *start; |
| + char *next; |
| + size_t len; |
| + char delim; |
| +}; |
| + |
| +static struct { |
| + unsigned long num_devices; |
| + char *str; |
| } dm_setup_args __initdata; |
| |
| static __initdata int dm_early_setup; |
| |
| -static size_t __init get_dm_option(char *str, char **next, char sep) |
| +static int __init get_dm_option(struct dm_option *opt, const char *accept) |
| { |
| - size_t len = 0; |
| - char *endp = NULL; |
| + char *str = opt->next; |
| + char *endp; |
| |
| if (!str) |
| return 0; |
| |
| - endp = strchr(str, sep); |
| + str = skip_spaces(str); |
| + opt->start = str; |
| + endp = strpbrk(str, accept); |
| if (!endp) { /* act like strchrnul */ |
| - len = strlen(str); |
| - endp = str + len; |
| + opt->len = strlen(str); |
| + endp = str + opt->len; |
| } else { |
| - len = endp - str; |
| + opt->len = endp - str; |
| } |
| - |
| - if (endp == str) |
| - return 0; |
| - |
| - if (!next) |
| - return len; |
| - |
| + opt->delim = *endp; |
| if (*endp == 0) { |
| /* Don't advance past the nul. */ |
| - *next = endp; |
| + opt->next = endp; |
| } else { |
| - *next = endp + 1; |
| + opt->next = endp + 1; |
| } |
| - return len; |
| -} |
| - |
| -static int __init dm_setup_args_init(void) |
| -{ |
| - dm_setup_args.minor = 0; |
| - dm_setup_args.ro = 0; |
| - dm_setup_args.target = NULL; |
| - dm_setup_args.target_count = 0; |
| - return 0; |
| + return opt->len != 0; |
| } |
| |
| -static int __init dm_setup_cleanup(void) |
| +static int __init dm_setup_cleanup(struct dm_device *devices) |
| { |
| - struct dm_setup_target *target = dm_setup_args.target; |
| - struct dm_setup_target *old_target = NULL; |
| - while (target) { |
| - kfree(target->type); |
| - kfree(target->params); |
| - old_target = target; |
| - target = target->next; |
| - kfree(old_target); |
| - dm_setup_args.target_count--; |
| + struct dm_device *dev = devices; |
| + |
| + while (dev) { |
| + struct dm_device *old_dev = dev; |
| + struct dm_setup_target *target = dev->target; |
| + while (target) { |
| + struct dm_setup_target *old_target = target; |
| + kfree(target->type); |
| + kfree(target->params); |
| + target = target->next; |
| + kfree(old_target); |
| + dev->target_count--; |
| + } |
| + BUG_ON(dev->target_count); |
| + dev = dev->next; |
| + kfree(old_dev); |
| } |
| - BUG_ON(dm_setup_args.target_count); |
| return 0; |
| } |
| |
| -static char * __init dm_setup_parse_device_args(char *str) |
| +static char * __init dm_parse_device(struct dm_device *dev, char *str) |
| { |
| - char *next = NULL; |
| - size_t len = 0; |
| + struct dm_option opt; |
| + size_t len; |
| |
| /* Grab the logical name of the device to be exported to udev */ |
| - len = get_dm_option(str, &next, DM_FIELD_SEP); |
| - if (!len) { |
| + opt.next = str; |
| + if (!get_dm_option(&opt, DM_FIELD_SEP)) { |
| DMERR("failed to parse device name"); |
| goto parse_fail; |
| } |
| - len = min(len + 1, sizeof(dm_setup_args.name)); |
| - strlcpy(dm_setup_args.name, str, len); /* includes nul */ |
| - str = skip_spaces(next); |
| + len = min(opt.len + 1, sizeof(dev->name)); |
| + strlcpy(dev->name, opt.start, len); /* includes nul */ |
| |
| /* Grab the UUID value or "none" */ |
| - len = get_dm_option(str, &next, DM_FIELD_SEP); |
| - if (!len) { |
| + if (!get_dm_option(&opt, DM_FIELD_SEP)) { |
| DMERR("failed to parse device uuid"); |
| goto parse_fail; |
| } |
| - len = min(len + 1, sizeof(dm_setup_args.uuid)); |
| - strlcpy(dm_setup_args.uuid, str, len); |
| - str = skip_spaces(next); |
| + len = min(opt.len + 1, sizeof(dev->uuid)); |
| + strlcpy(dev->uuid, opt.start, len); |
| |
| /* Determine if the table/device will be read only or read-write */ |
| - if (!strncmp("ro,", str, 3)) { |
| - dm_setup_args.ro = 1; |
| - } else if (!strncmp("rw,", str, 3)) { |
| - dm_setup_args.ro = 0; |
| + get_dm_option(&opt, DM_ANY_SEP); |
| + if (!strncmp("ro", opt.start, opt.len)) { |
| + dev->ro = 1; |
| + } else if (!strncmp("rw", opt.start, opt.len)) { |
| + dev->ro = 0; |
| } else { |
| DMERR("failed to parse table mode"); |
| goto parse_fail; |
| } |
| - str = skip_spaces(str + 3); |
| |
| - return str; |
| + /* Optional number field */ |
| + /* XXX: The <num> field will be mandatory in the next round */ |
| + if (opt.delim == DM_FIELD_SEP[0]) { |
| + if (!get_dm_option(&opt, DM_LINE_SEP)) |
| + return NULL; |
| + dev->num_targets = simple_strtoul(opt.start, NULL, 10); |
| + } else { |
| + dev->num_targets = 1; |
| + } |
| + if (dev->num_targets > DM_MAX_TARGETS) { |
| + DMERR("too many targets %lu > %d", |
| + dev->num_targets, DM_MAX_TARGETS); |
| + } |
| + return opt.next; |
| |
| parse_fail: |
| return NULL; |
| } |
| |
| -static void __init dm_substitute_devices(char *str, size_t str_len) |
| +static char * __init dm_parse_targets(struct dm_device *dev, char *str) |
| { |
| - char *candidate = str; |
| - char *candidate_end = str; |
| - char old_char; |
| - size_t len = 0; |
| - dev_t dev; |
| - |
| - if (str_len < 3) |
| - return; |
| - |
| - while (str && *str) { |
| - candidate = strchr(str, '/'); |
| - if (!candidate) |
| - break; |
| - |
| - /* Avoid embedded slashes */ |
| - if (candidate != str && *(candidate - 1) != DM_FIELD_SEP) { |
| - str = strchr(candidate, DM_FIELD_SEP); |
| - continue; |
| - } |
| - |
| - len = get_dm_option(candidate, &candidate_end, DM_FIELD_SEP); |
| - str = skip_spaces(candidate_end); |
| - if (len < 3 || len > 37) /* name_to_dev_t max; maj:mix min */ |
| - continue; |
| - |
| - /* Temporarily terminate with a nul */ |
| - if (*candidate_end) |
| - candidate_end--; |
| - old_char = *candidate_end; |
| - *candidate_end = '\0'; |
| - |
| - DMDEBUG("converting candidate device '%s' to dev_t", candidate); |
| - /* Use the boot-time specific device naming */ |
| - dev = name_to_dev_t(candidate); |
| - *candidate_end = old_char; |
| - |
| - DMDEBUG(" -> %u", dev); |
| - /* No suitable replacement found */ |
| - if (!dev) |
| - continue; |
| - |
| - /* Rewrite the /dev/path as a major:minor */ |
| - len = snprintf(candidate, len, "%u:%u", MAJOR(dev), MINOR(dev)); |
| - if (!len) { |
| - DMERR("error substituting device major/minor."); |
| - break; |
| - } |
| - candidate += len; |
| - /* Pad out with spaces (fixing our nul) */ |
| - while (candidate < candidate_end) |
| - *(candidate++) = DM_FIELD_SEP; |
| - } |
| -} |
| - |
| -static int __init dm_setup_parse_targets(char *str) |
| -{ |
| - char *next = NULL; |
| - size_t len = 0; |
| - struct dm_setup_target **target = NULL; |
| + struct dm_option opt; |
| + struct dm_setup_target **target = &dev->target; |
| + unsigned long num_targets = dev->num_targets; |
| + unsigned long i; |
| |
| /* Targets are defined as per the table format but with a |
| * comma as a newline separator. */ |
| - target = &dm_setup_args.target; |
| - while (str && *str) { |
| + opt.next = str; |
| + for (i = 0; i < num_targets; i++) { |
| *target = kzalloc(sizeof(struct dm_setup_target), GFP_KERNEL); |
| if (!*target) { |
| - DMERR("failed to allocate memory for target %d", |
| - dm_setup_args.target_count); |
| + DMERR("failed to allocate memory for target %s<%ld>", |
| + dev->name, i); |
| goto parse_fail; |
| } |
| - dm_setup_args.target_count++; |
| + dev->target_count++; |
| |
| - (*target)->begin = simple_strtoull(str, &next, 10); |
| - if (!next || *next != DM_FIELD_SEP) { |
| - DMERR("failed to parse starting sector for target %d", |
| - dm_setup_args.target_count - 1); |
| + if (!get_dm_option(&opt, DM_FIELD_SEP)) { |
| + DMERR("failed to parse starting sector" |
| + " for target %s<%ld>", dev->name, i); |
| goto parse_fail; |
| } |
| - str = skip_spaces(next + 1); |
| + (*target)->begin = simple_strtoull(opt.start, NULL, 10); |
| |
| - (*target)->length = simple_strtoull(str, &next, 10); |
| - if (!next || *next != DM_FIELD_SEP) { |
| - DMERR("failed to parse length for target %d", |
| - dm_setup_args.target_count - 1); |
| + if (!get_dm_option(&opt, DM_FIELD_SEP)) { |
| + DMERR("failed to parse length for target %s<%ld>", |
| + dev->name, i); |
| goto parse_fail; |
| } |
| - str = skip_spaces(next + 1); |
| - |
| - len = get_dm_option(str, &next, DM_FIELD_SEP); |
| - if (!len || |
| - !((*target)->type = kstrndup(str, len, GFP_KERNEL))) { |
| - DMERR("failed to parse type for target %d", |
| - dm_setup_args.target_count - 1); |
| + (*target)->length = simple_strtoull(opt.start, NULL, 10); |
| + |
| + if (get_dm_option(&opt, DM_FIELD_SEP)) |
| + (*target)->type = kstrndup(opt.start, opt.len, |
| + GFP_KERNEL); |
| + if (!((*target)->type)) { |
| + DMERR("failed to parse type for target %s<%ld>", |
| + dev->name, i); |
| goto parse_fail; |
| } |
| - str = skip_spaces(next); |
| - |
| - len = get_dm_option(str, &next, DM_LINE_SEP); |
| - if (!len || |
| - !((*target)->params = kstrndup(str, len, GFP_KERNEL))) { |
| - DMERR("failed to parse params for target %d", |
| - dm_setup_args.target_count - 1); |
| + if (get_dm_option(&opt, DM_LINE_SEP)) |
| + (*target)->params = kstrndup(opt.start, opt.len, |
| + GFP_KERNEL); |
| + if (!((*target)->params)) { |
| + DMERR("failed to parse params for target %s<%ld>", |
| + dev->name, i); |
| goto parse_fail; |
| } |
| - str = skip_spaces(next); |
| - |
| - /* Before moving on, walk through the copied target and |
| - * attempt to replace all /dev/xxx with the major:minor number. |
| - * It may not be possible to resolve them traditionally at |
| - * boot-time. */ |
| - dm_substitute_devices((*target)->params, len); |
| - |
| target = &((*target)->next); |
| } |
| - DMDEBUG("parsed %d targets", dm_setup_args.target_count); |
| + DMDEBUG("parsed %d targets", dev->target_count); |
| |
| - return 0; |
| + return opt.next; |
| |
| parse_fail: |
| - return 1; |
| + return NULL; |
| +} |
| + |
| +static struct dm_device * __init dm_parse_args(void) |
| +{ |
| + struct dm_device *devices = NULL; |
| + struct dm_device **tail = &devices; |
| + struct dm_device *dev; |
| + char *str = dm_setup_args.str; |
| + unsigned long num_devices = dm_setup_args.num_devices; |
| + unsigned long i; |
| + |
| + if (!str) |
| + return NULL; |
| + for (i = 0; i < num_devices; i++) { |
| + dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
| + if (!dev) { |
| + DMERR("failed to allocated memory for dev"); |
| + goto error; |
| + } |
| + *tail = dev; |
| + tail = &dev->next; |
| + /* |
| + * devices are given minor numbers 0 - n-1 |
| + * in the order they are found in the arg |
| + * string. |
| + */ |
| + dev->minor = i; |
| + str = dm_parse_device(dev, str); |
| + if (!str) /* NULL indicates error in parsing, bail */ |
| + goto error; |
| + |
| + str = dm_parse_targets(dev, str); |
| + if (!str) |
| + goto error; |
| + } |
| + return devices; |
| +error: |
| + dm_setup_cleanup(devices); |
| + return NULL; |
| } |
| |
| /* |
| * Parse the command-line parameters given our kernel, but do not |
| * actually try to invoke the DM device now; that is handled by |
| - * dm_setup_drive after the low-level disk drivers have initialised. |
| - * dm format is as follows: |
| - * dm="name uuid fmode,[table line 1],[table line 2],..." |
| - * May be used with root=/dev/dm-0 as it always uses the first dm minor. |
| + * dm_setup_drives after the low-level disk drivers have initialised. |
| + * dm format is described at the top of the file. |
| + * |
| + * Because dm minor numbers are assigned in assending order starting with 0, |
| + * You can assume the first device is /dev/dm-0, the next device is /dev/dm-1, |
| + * and so forth. |
| */ |
| - |
| static int __init dm_setup(char *str) |
| { |
| - dm_setup_args_init(); |
| + struct dm_option opt; |
| + unsigned long num_devices; |
| |
| - str = dm_setup_parse_device_args(str); |
| if (!str) { |
| DMDEBUG("str is NULL"); |
| goto parse_fail; |
| } |
| - |
| - /* Target parsing is delayed until we have dynamic memory */ |
| - dm_setup_args.targets = str; |
| - |
| - printk(KERN_INFO "dm: will configure '%s' on dm-%d\n", |
| - dm_setup_args.name, dm_setup_args.minor); |
| - |
| + opt.next = str; |
| + if (!get_dm_option(&opt, DM_FIELD_SEP)) |
| + goto parse_fail; |
| + if (isdigit(opt.start[0])) { /* XXX: Optional number field */ |
| + num_devices = simple_strtoul(opt.start, NULL, 10); |
| + str = opt.next; |
| + } else { |
| + num_devices = 1; |
| + /* Don't advance str */ |
| + } |
| + if (num_devices > DM_MAX_DEVICES) { |
| + DMDEBUG("too many devices %lu > %d", |
| + num_devices, DM_MAX_DEVICES); |
| + } |
| + dm_setup_args.str = str; |
| + dm_setup_args.num_devices = num_devices; |
| + DMINFO("will configure %lu devices", num_devices); |
| dm_early_setup = 1; |
| return 1; |
| |
| parse_fail: |
| - printk(KERN_WARNING "dm: Invalid arguments supplied to dm=.\n"); |
| + DMWARN("Invalid arguments supplied to dm=."); |
| return 0; |
| } |
| |
| - |
| -static void __init dm_setup_drive(void) |
| +static void __init dm_setup_drives(void) |
| { |
| struct mapped_device *md = NULL; |
| struct dm_table *table = NULL; |
| struct dm_setup_target *target; |
| - char *uuid = dm_setup_args.uuid; |
| + struct dm_device *dev; |
| + char *uuid; |
| fmode_t fmode = FMODE_READ; |
| + struct dm_device *devices; |
| |
| - /* Finish parsing the targets. */ |
| - if (dm_setup_parse_targets(dm_setup_args.targets)) |
| - goto parse_fail; |
| - |
| - if (dm_create(dm_setup_args.minor, &md)) { |
| - DMDEBUG("failed to create the device"); |
| - goto dm_create_fail; |
| - } |
| - DMDEBUG("created device '%s'", dm_device_name(md)); |
| - |
| - /* In addition to flagging the table below, the disk must be |
| - * set explicitly ro/rw. */ |
| - set_disk_ro(dm_disk(md), dm_setup_args.ro); |
| + devices = dm_parse_args(); |
| |
| - if (!dm_setup_args.ro) |
| - fmode |= FMODE_WRITE; |
| - if (dm_table_create(&table, fmode, dm_setup_args.target_count, md)) { |
| - DMDEBUG("failed to create the table"); |
| - goto dm_table_create_fail; |
| - } |
| + for (dev = devices; dev; dev = dev->next) { |
| + if (dm_create(dev->minor, &md)) { |
| + DMDEBUG("failed to create the device"); |
| + goto dm_create_fail; |
| + } |
| + DMDEBUG("created device '%s'", dm_device_name(md)); |
| + |
| + /* |
| + * In addition to flagging the table below, the disk must be |
| + * set explicitly ro/rw. |
| + */ |
| + set_disk_ro(dm_disk(md), dev->ro); |
| + |
| + if (!dev->ro) |
| + fmode |= FMODE_WRITE; |
| + if (dm_table_create(&table, fmode, dev->target_count, md)) { |
| + DMDEBUG("failed to create the table"); |
| + goto dm_table_create_fail; |
| + } |
| |
| - dm_lock_md_type(md); |
| - target = dm_setup_args.target; |
| - while (target) { |
| - DMINFO("adding target '%llu %llu %s %s'", |
| - (unsigned long long) target->begin, |
| - (unsigned long long) target->length, target->type, |
| - target->params); |
| - if (dm_table_add_target(table, target->type, target->begin, |
| - target->length, target->params)) { |
| - DMDEBUG("failed to add the target to the table"); |
| - goto add_target_fail; |
| + dm_lock_md_type(md); |
| + |
| + for (target = dev->target; target; target = target->next) { |
| + DMINFO("adding target '%llu %llu %s %s'", |
| + (unsigned long long) target->begin, |
| + (unsigned long long) target->length, |
| + target->type, target->params); |
| + if (dm_table_add_target(table, target->type, |
| + target->begin, |
| + target->length, |
| + target->params)) { |
| + DMDEBUG("failed to add the target" |
| + " to the table"); |
| + goto add_target_fail; |
| + } |
| + } |
| + if (dm_table_complete(table)) { |
| + DMDEBUG("failed to complete the table"); |
| + goto table_complete_fail; |
| } |
| - target = target->next; |
| - } |
| |
| - if (dm_table_complete(table)) { |
| - DMDEBUG("failed to complete the table"); |
| - goto table_complete_fail; |
| - } |
| + /* Suspend the device so that we can bind it to the table. */ |
| + if (dm_suspend(md, 0)) { |
| + DMDEBUG("failed to suspend the device pre-bind"); |
| + goto suspend_fail; |
| + } |
| |
| - if (dm_get_md_type(md) == DM_TYPE_NONE) { |
| + /* Initial table load: acquire type of table. */ |
| dm_set_md_type(md, dm_table_get_type(table)); |
| + |
| + /* Setup md->queue to reflect md's type. */ |
| if (dm_setup_md_queue(md)) { |
| DMWARN("unable to set up device queue for new table."); |
| goto setup_md_queue_fail; |
| } |
| - } else if (dm_get_md_type(md) != dm_table_get_type(table)) { |
| - DMWARN("can't change device type after initial table load."); |
| - goto setup_md_queue_fail; |
| - } |
| - |
| - /* Suspend the device so that we can bind it to the table. */ |
| - if (dm_suspend(md, 0)) { |
| - DMDEBUG("failed to suspend the device pre-bind"); |
| - goto suspend_fail; |
| - } |
| |
| - /* Bind the table to the device. This is the only way to associate |
| - * md->map with the table and set the disk capacity directly. */ |
| - if (dm_swap_table(md, table)) { /* should return NULL. */ |
| - DMDEBUG("failed to bind the device to the table"); |
| - goto table_bind_fail; |
| - } |
| + /* |
| + * Bind the table to the device. This is the only way |
| + * to associate md->map with the table and set the disk |
| + * capacity directly. |
| + */ |
| + if (dm_swap_table(md, table)) { /* should return NULL. */ |
| + DMDEBUG("failed to bind the device to the table"); |
| + goto table_bind_fail; |
| + } |
| |
| - /* Finally, resume and the device should be ready. */ |
| - if (dm_resume(md)) { |
| - DMDEBUG("failed to resume the device"); |
| - goto resume_fail; |
| - } |
| + /* Finally, resume and the device should be ready. */ |
| + if (dm_resume(md)) { |
| + DMDEBUG("failed to resume the device"); |
| + goto resume_fail; |
| + } |
| |
| - /* Export the dm device via the ioctl interface */ |
| - if (!strcmp(DM_NO_UUID, dm_setup_args.uuid)) |
| - uuid = NULL; |
| - if (dm_ioctl_export(md, dm_setup_args.name, uuid)) { |
| - DMDEBUG("failed to export device with given name and uuid"); |
| - goto export_fail; |
| - } |
| - printk(KERN_INFO "dm: dm-%d is ready\n", dm_setup_args.minor); |
| + /* Export the dm device via the ioctl interface */ |
| + if (!strcmp(DM_NO_UUID, dev->uuid)) |
| + uuid = NULL; |
| + if (dm_ioctl_export(md, dev->name, uuid)) { |
| + DMDEBUG("failed to export device with given" |
| + " name and uuid"); |
| + goto export_fail; |
| + } |
| |
| - dm_unlock_md_type(md); |
| - dm_setup_cleanup(); |
| + dm_unlock_md_type(md); |
| + |
| + DMINFO("dm-%d is ready", dev->minor); |
| + } |
| + dm_setup_cleanup(devices); |
| return; |
| |
| export_fail: |
| resume_fail: |
| table_bind_fail: |
| -suspend_fail: |
| setup_md_queue_fail: |
| +suspend_fail: |
| table_complete_fail: |
| add_target_fail: |
| dm_unlock_md_type(md); |
| dm_table_create_fail: |
| dm_put(md); |
| dm_create_fail: |
| - dm_setup_cleanup(); |
| -parse_fail: |
| - printk(KERN_WARNING "dm: starting dm-%d (%s) failed\n", |
| - dm_setup_args.minor, dm_setup_args.name); |
| + DMWARN("starting dm-%d (%s) failed", |
| + dev->minor, dev->name); |
| + dm_setup_cleanup(devices); |
| } |
| |
| __setup("dm=", dm_setup); |
| @@ -421,6 +465,6 @@ void __init dm_run_setup(void) |
| { |
| if (!dm_early_setup) |
| return; |
| - printk(KERN_INFO "dm: attempting early device configuration.\n"); |
| - dm_setup_drive(); |
| + DMINFO("attempting early device configuration."); |
| + dm_setup_drives(); |
| } |
| -- |
| 2.14.1.581.gf28d330327-goog |
| |