malhuda/msm-4.14
1
0
Fork 0
mirror of https://github.com/rd-stuffs/msm-4.14.git synced 2025-02-20 11:45:48 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

ANDROID: Update init/do_mounts_dm.c to the latest ChromiumOS version.

Browse Source 
This is needed for AVB.

Bug: None
Test: Compiles.
Change-Id: I45b5d435652ab66ec07420ab17f2c7889f7e4d95
Signed-off-by: David Zeuthen <zeuthen@google.com>
This commit is contained in:
David Zeuthen 2017-05-19 17:20:18 -04:00 committed by Amit Pundir
parent c32df75602
commit 9410591063
3 changed files with 310 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/md/dm.h
View File

@ -80,8 +80,6 @@ void dm_set_md_type(struct mapped_device *md, enum dm_queue_mode type);
enum dm_queue_mode dm_get_md_type(struct mapped_device *md); enum dm_queue_mode dm_get_md_type(struct mapped_device *md);
struct target_type *dm_get_immutable_target_type(struct mapped_device *md); struct target_type *dm_get_immutable_target_type(struct mapped_device *md);
int dm_setup_md_queue(struct mapped_device *md, struct dm_table *t);
/* /*
* To check the return value from dm_table_find_target(). * To check the return value from dm_table_find_target().
*/ */

7
include/linux/device-mapper.h
View File

@ -468,6 +468,13 @@ union map_info *dm_get_rq_mapinfo(struct request *rq);
struct queue_limits *dm_get_queue_limits(struct mapped_device *md); 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, struct dm_table *t);
unsigned dm_table_get_type(struct dm_table *t);
/* /*
* Geometry functions. * Geometry functions.
*/ */

562
init/do_mounts_dm.c
View File

@ -5,13 +5,17 @@
* *
* This file is released under the GPL. * This file is released under the GPL.
*/ */
#include <linux/async.h>
#include <linux/ctype.h>
#include <linux/device-mapper.h> #include <linux/device-mapper.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/delay.h>
#include "do_mounts.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_NAME 32
#define DM_MAX_UUID 129 #define DM_MAX_UUID 129
#define DM_NO_UUID "none" #define DM_NO_UUID "none"
@ -19,14 +23,47 @@
#define DM_MSG_PREFIX "init" #define DM_MSG_PREFIX "init"
/* Separators used for parsing the dm= argument. */ /* Separators used for parsing the dm= argument. */
#define DM_FIELD_SEP ' ' #define DM_FIELD_SEP " "
#define DM_LINE_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 * 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 * (not a module), one or more device-mappers may be created and used
* boot time with the parameters given with the boot line dm=... * as the root device at boot time with the parameters given with the
* The code for that is here. * 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 { struct dm_setup_target {
@ -38,381 +75,388 @@ struct dm_setup_target {
struct dm_setup_target *next; struct dm_setup_target *next;
}; };
static struct { struct dm_device {
int minor; int minor;
int ro; int ro;
char name[DM_MAX_NAME]; char name[DM_MAX_NAME];
char uuid[DM_MAX_UUID]; char uuid[DM_MAX_UUID];
char *targets; unsigned long num_targets;
struct dm_setup_target *target; struct dm_setup_target *target;
int target_count; 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; } dm_setup_args __initdata;
static __initdata int dm_early_setup; 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 *str = opt->next;
char *endp = NULL; char *endp;
if (!str) if (!str)
return 0; return 0;
endp = strchr(str, sep); str = skip_spaces(str);
opt->start = str;
endp = strpbrk(str, accept);
if (!endp) { /* act like strchrnul */ if (!endp) { /* act like strchrnul */
len = strlen(str); opt->len = strlen(str);
endp = str + len; endp = str + opt->len;
} else { } else {
len = endp - str; opt->len = endp - str;
} }
opt->delim = *endp;
if (endp == str)
return 0;
if (!next)
return len;
if (*endp == 0) { if (*endp == 0) {
/* Don't advance past the nul. */ /* Don't advance past the nul. */
*next = endp; opt->next = endp;
} else { } else {
*next = endp + 1; opt->next = endp + 1;
} }
return len; return opt->len != 0;
} }
static int __init dm_setup_args_init(void) static int __init dm_setup_cleanup(struct dm_device *devices)
{ {
dm_setup_args.minor = 0; struct dm_device *dev = devices;
dm_setup_args.ro = 0;
dm_setup_args.target = NULL; while (dev) {
dm_setup_args.target_count = 0; 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);
}
return 0; return 0;
} }
static int __init dm_setup_cleanup(void) static char * __init dm_parse_device(struct dm_device *dev, char *str)
{ {
struct dm_setup_target *target = dm_setup_args.target; struct dm_option opt;
struct dm_setup_target *old_target = NULL; size_t len;
while (target) {
kfree(target->type);
kfree(target->params);
old_target = target;
target = target->next;
kfree(old_target);
dm_setup_args.target_count--;
}
BUG_ON(dm_setup_args.target_count);
return 0;
}
static char * __init dm_setup_parse_device_args(char *str)
{
char *next = NULL;
size_t len = 0;
/* Grab the logical name of the device to be exported to udev */ /* Grab the logical name of the device to be exported to udev */
len = get_dm_option(str, &next, DM_FIELD_SEP); opt.next = str;
if (!len) { if (!get_dm_option(&opt, DM_FIELD_SEP)) {
DMERR("failed to parse device name"); DMERR("failed to parse device name");
goto parse_fail; goto parse_fail;
} }
len = min(len + 1, sizeof(dm_setup_args.name)); len = min(opt.len + 1, sizeof(dev->name));
strlcpy(dm_setup_args.name, str, len); /* includes nul */ strlcpy(dev->name, opt.start, len); /* includes nul */
str = skip_spaces(next);
/* Grab the UUID value or "none" */ /* Grab the UUID value or "none" */
len = get_dm_option(str, &next, DM_FIELD_SEP); if (!get_dm_option(&opt, DM_FIELD_SEP)) {
if (!len) {
DMERR("failed to parse device uuid"); DMERR("failed to parse device uuid");
goto parse_fail; goto parse_fail;
} }
len = min(len + 1, sizeof(dm_setup_args.uuid)); len = min(opt.len + 1, sizeof(dev->uuid));
strlcpy(dm_setup_args.uuid, str, len); strlcpy(dev->uuid, opt.start, len);
str = skip_spaces(next);
/* Determine if the table/device will be read only or read-write */ /* Determine if the table/device will be read only or read-write */
if (!strncmp("ro,", str, 3)) { get_dm_option(&opt, DM_ANY_SEP);
dm_setup_args.ro = 1; if (!strncmp("ro", opt.start, opt.len)) {
} else if (!strncmp("rw,", str, 3)) { dev->ro = 1;
dm_setup_args.ro = 0; } else if (!strncmp("rw", opt.start, opt.len)) {
dev->ro = 0;
} else { } else {
DMERR("failed to parse table mode"); DMERR("failed to parse table mode");
goto parse_fail; 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: parse_fail:
return NULL; 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; struct dm_option opt;
char *candidate_end = str; struct dm_setup_target **target = &dev->target;
char old_char; unsigned long num_targets = dev->num_targets;
size_t len = 0; unsigned long i;
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;
/* Targets are defined as per the table format but with a /* Targets are defined as per the table format but with a
* comma as a newline separator. */ * comma as a newline separator. */
target = &dm_setup_args.target; opt.next = str;
while (str && *str) { for (i = 0; i < num_targets; i++) {
*target = kzalloc(sizeof(struct dm_setup_target), GFP_KERNEL); *target = kzalloc(sizeof(struct dm_setup_target), GFP_KERNEL);
if (!*target) { if (!*target) {
DMERR("failed to allocate memory for target %d", DMERR("failed to allocate memory for target %s<%ld>",
dm_setup_args.target_count); dev->name, i);
goto parse_fail; goto parse_fail;
} }
dm_setup_args.target_count++; dev->target_count++;
(*target)->begin = simple_strtoull(str, &next, 10); if (!get_dm_option(&opt, DM_FIELD_SEP)) {
if (!next || *next != DM_FIELD_SEP) { DMERR("failed to parse starting sector"
DMERR("failed to parse starting sector for target %d", " for target %s<%ld>", dev->name, i);
dm_setup_args.target_count - 1);
goto parse_fail; goto parse_fail;
} }
str = skip_spaces(next + 1); (*target)->begin = simple_strtoull(opt.start, NULL, 10);
(*target)->length = simple_strtoull(str, &next, 10); if (!get_dm_option(&opt, DM_FIELD_SEP)) {
if (!next || *next != DM_FIELD_SEP) { DMERR("failed to parse length for target %s<%ld>",
DMERR("failed to parse length for target %d", dev->name, i);
dm_setup_args.target_count - 1);
goto parse_fail; goto parse_fail;
} }
str = skip_spaces(next + 1); (*target)->length = simple_strtoull(opt.start, NULL, 10);
len = get_dm_option(str, &next, DM_FIELD_SEP); if (get_dm_option(&opt, DM_FIELD_SEP))
if (!len || (*target)->type = kstrndup(opt.start, opt.len,
!((*target)->type = kstrndup(str, len, GFP_KERNEL))) { GFP_KERNEL);
DMERR("failed to parse type for target %d", if (!((*target)->type)) {
dm_setup_args.target_count - 1); DMERR("failed to parse type for target %s<%ld>",
dev->name, i);
goto parse_fail; goto parse_fail;
} }
str = skip_spaces(next); if (get_dm_option(&opt, DM_LINE_SEP))
(*target)->params = kstrndup(opt.start, opt.len,
len = get_dm_option(str, &next, DM_LINE_SEP); GFP_KERNEL);
if (!len || if (!((*target)->params)) {
!((*target)->params = kstrndup(str, len, GFP_KERNEL))) { DMERR("failed to parse params for target %s<%ld>",
DMERR("failed to parse params for target %d", dev->name, i);
dm_setup_args.target_count - 1);
goto parse_fail; 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); 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: 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 * Parse the command-line parameters given our kernel, but do not
* actually try to invoke the DM device now; that is handled by * actually try to invoke the DM device now; that is handled by
* dm_setup_drive after the low-level disk drivers have initialised. * dm_setup_drives after the low-level disk drivers have initialised.
* dm format is as follows: * dm format is described at the top of the file.
* 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. * 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) 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) { if (!str) {
DMDEBUG("str is NULL"); DMDEBUG("str is NULL");
goto parse_fail; goto parse_fail;
} }
opt.next = str;
/* Target parsing is delayed until we have dynamic memory */ if (!get_dm_option(&opt, DM_FIELD_SEP))
dm_setup_args.targets = str; goto parse_fail;
if (isdigit(opt.start[0])) { /* XXX: Optional number field */
printk(KERN_INFO "dm: will configure '%s' on dm-%d\n", num_devices = simple_strtoul(opt.start, NULL, 10);
dm_setup_args.name, dm_setup_args.minor); 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; dm_early_setup = 1;
return 1; return 1;
parse_fail: parse_fail:
printk(KERN_WARNING "dm: Invalid arguments supplied to dm=.\n"); DMWARN("Invalid arguments supplied to dm=.");
return 0; return 0;
} }
static void __init dm_setup_drives(void)
static void __init dm_setup_drive(void)
{ {
struct mapped_device *md = NULL; struct mapped_device *md = NULL;
struct dm_table *table = NULL; struct dm_table *table = NULL;
struct dm_setup_target *target; struct dm_setup_target *target;
char *uuid = dm_setup_args.uuid; struct dm_device *dev;
char *uuid;
fmode_t fmode = FMODE_READ; fmode_t fmode = FMODE_READ;
struct dm_device *devices;
/* Finish parsing the targets. */ devices = dm_parse_args();
if (dm_setup_parse_targets(dm_setup_args.targets))
goto parse_fail;
if (dm_create(dm_setup_args.minor, &md)) { for (dev = devices; dev; dev = dev->next) {
DMDEBUG("failed to create the device"); if (dm_create(dev->minor, &md)) {
goto dm_create_fail; 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);
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;
}
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;
} }
target = target->next; DMDEBUG("created device '%s'", dm_device_name(md));
}
if (dm_table_complete(table)) { /*
DMDEBUG("failed to complete the table"); * In addition to flagging the table below, the disk must be
goto table_complete_fail; * set explicitly ro/rw.
} */
set_disk_ro(dm_disk(md), dev->ro);
if (dm_get_md_type(md) == DM_TYPE_NONE) { 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);
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;
}
/* 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;
}
/* Initial table load: acquire type of table. */
dm_set_md_type(md, dm_table_get_type(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, table)) { if (dm_setup_md_queue(md, table)) {
DMWARN("unable to set up device queue for new table."); DMWARN("unable to set up device queue for new table.");
goto setup_md_queue_fail; 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)) { * Bind the table to the device. This is the only way
DMDEBUG("failed to suspend the device pre-bind"); * to associate md->map with the table and set the disk
goto suspend_fail; * 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;
}
/* 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);
DMINFO("dm-%d is ready", dev->minor);
} }
dm_setup_cleanup(devices);
/* 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;
}
/* 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);
dm_unlock_md_type(md);
dm_setup_cleanup();
return; return;
export_fail: export_fail:
resume_fail: resume_fail:
table_bind_fail: table_bind_fail:
suspend_fail:
setup_md_queue_fail: setup_md_queue_fail:
suspend_fail:
table_complete_fail: table_complete_fail:
add_target_fail: add_target_fail:
dm_unlock_md_type(md); dm_unlock_md_type(md);
dm_table_create_fail: dm_table_create_fail:
dm_put(md); dm_put(md);
dm_create_fail: dm_create_fail:
dm_setup_cleanup(); DMWARN("starting dm-%d (%s) failed",
parse_fail: dev->minor, dev->name);
printk(KERN_WARNING "dm: starting dm-%d (%s) failed\n", dm_setup_cleanup(devices);
dm_setup_args.minor, dm_setup_args.name);
} }
__setup("dm=", dm_setup); __setup("dm=", dm_setup);
@ -421,6 +465,6 @@ void __init dm_run_setup(void)
{ {
if (!dm_early_setup) if (!dm_early_setup)
return; return;
printk(KERN_INFO "dm: attempting early device configuration.\n"); DMINFO("attempting early device configuration.");
dm_setup_drive(); dm_setup_drives();
} }