init/do_mounts_dm.c - nest-hello/linux-3.10 - Git at Google

 /*
  * do_mounts_dm.c
  * Copyright (C) 2010 The Chromium OS Authors <chromium-os-dev@chromium.org>
  * Based on do_mounts_md.c
  *
  * This file is released under the GPLv2.
  */
 #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"

 #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"

 #define DM_MSG_PREFIX "init"
 #define DMERR_PARSE(fmt, args...) \
 	DMERR("failed to parse " fmt " for device %s<%lu>", args)

 /* Separators used for parsing the dm= argument. */
 #define DM_FIELD_SEP " "
 #define DM_LINE_SEP ","
 #define DM_ANY_SEP DM_FIELD_SEP DM_LINE_SEP

 /* See Documentation/device-mapper/boot.txt for dm="..." format details. */

 struct dm_setup_table {
 	sector_t begin;
 	sector_t length;
 	char *type;
 	char *params;
 	/* simple singly linked list */
 	struct dm_setup_table *next;
 };

 struct dm_device {
 	int minor;
 	int ro;
 	char name[DM_MAX_NAME];
 	char uuid[DM_MAX_UUID];
 	unsigned long num_tables;
 	struct dm_setup_table *table;
 	int table_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 int dm_early_setup __initdata;

 static int __init get_dm_option(struct dm_option *opt, const char *accept)
 {
 	char *str = opt->next;
 	char *endp;

 	if (!str)
 		return 0;

 	str = skip_spaces(str);
 	opt->start = str;
 	endp = strpbrk(str, accept);
 	if (!endp) {  /* act like strchrnul */
 		opt->len = strlen(str);
 		endp = str + opt->len;
 	} else {
 		opt->len = endp - str;
 	}
 	opt->delim = *endp;
 	if (*endp == 0) {
 		/* Don't advance past the nul. */
 		opt->next = endp;
 	} else {
 		opt->next = endp + 1;
 	}
 	return opt->len != 0;
 }

 static int __init get_dm_option_u64(struct dm_option *opt, const char *sep,
 				    unsigned long long *result)
 {
 	char buf[32];

 	if (!get_dm_option(opt, sep))
 		return -EINVAL;

 	strlcpy(buf, opt->start, min(sizeof(buf), opt->len + 1));
 	return kstrtoull(buf, 0, result);
 }

 static void __init dm_setup_cleanup(struct dm_device *devices)
 {
 	struct dm_device *dev = devices;

 	while (dev) {
 		struct dm_device *old_dev = dev;
 		struct dm_setup_table *table = dev->table;

 		while (table) {
 			struct dm_setup_table *old_table = table;

 			kfree(table->type);
 			kfree(table->params);
 			table = table->next;
 			kfree(old_table);
 			dev->table_count--;
 		}
 		WARN_ON(dev->table_count);
 		dev = dev->next;
 		kfree(old_dev);
 	}
 }

 static char * __init dm_parse_device(struct dm_device *dev, char *str,
 				     unsigned long idx)
 {
 	struct dm_option opt;
 	size_t len;
 	unsigned long long num_tables;

 	/* Grab the logical name of the device to be exported to udev */
 	opt.next = str;
 	if (!get_dm_option(&opt, DM_FIELD_SEP)) {
 		DMERR_PARSE("name", "", idx);
 		goto parse_fail;
 	}
 	len = min(opt.len + 1, sizeof(dev->name));
 	strlcpy(dev->name, opt.start, len);  /* includes nul */

 	/* Grab the UUID value or "none" */
 	if (!get_dm_option(&opt, DM_FIELD_SEP)) {
 		DMERR_PARSE("uuid", dev->name, idx);
 		goto parse_fail;
 	}
 	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 */
 	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_PARSE("table mode", dev->name, idx);
 		goto parse_fail;
 	}

 	/* Optional number field */
 	if (opt.delim == DM_FIELD_SEP[0]) {
 		if (get_dm_option_u64(&opt, DM_LINE_SEP, &num_tables)) {
 			DMERR_PARSE("number of tables", dev->name, idx);
 			goto parse_fail;
 		}
 	} else {
 		num_tables = 1;
 	}
 	if (num_tables > DM_MAX_TARGETS) {
 		DMERR_PARSE("too many tables (%llu > %d)", num_tables,
 			    DM_MAX_TARGETS, dev->name, idx);
 	}
 	dev->num_tables = num_tables;

 	return opt.next;

 parse_fail:
 	return NULL;
 }

 static char * __init dm_parse_tables(struct dm_device *dev, char *str,
 				     unsigned long idx)
 {
 	struct dm_option opt;
 	struct dm_setup_table **table = &dev->table;
 	unsigned long num_tables = dev->num_tables;
 	unsigned long i;
 	unsigned long long value;

 	/*
 	 * Tables are defined as per the normal table format but with a
 	 * comma as a newline separator.
 	 */
 	opt.next = str;
 	for (i = 0; i < num_tables; i++) {
 		*table = kzalloc(sizeof(struct dm_setup_table), GFP_KERNEL);
 		if (!*table) {
 			DMERR_PARSE("table %lu (out of memory)", i, dev->name,
 				    idx);
 			goto parse_fail;
 		}
 		dev->table_count++;

 		if (get_dm_option_u64(&opt, DM_FIELD_SEP, &value)) {
 			DMERR_PARSE("starting sector for table %lu", i,
 				    dev->name, idx);
 			goto parse_fail;
 		}
 		(*table)->begin = value;

 		if (get_dm_option_u64(&opt, DM_FIELD_SEP, &value)) {
 			DMERR_PARSE("length for table %lu", i, dev->name, idx);
 			goto parse_fail;
 		}
 		(*table)->length = value;

 		if (get_dm_option(&opt, DM_FIELD_SEP))
 			(*table)->type = kstrndup(opt.start, opt.len,
 							GFP_KERNEL);
 		if (!((*table)->type)) {
 			DMERR_PARSE("type for table %lu", i, dev->name, idx);
 			goto parse_fail;
 		}
 		if (get_dm_option(&opt, DM_LINE_SEP))
 			(*table)->params = kstrndup(opt.start, opt.len,
 						    GFP_KERNEL);
 		if (!((*table)->params)) {
 			DMERR_PARSE("params for table %lu", i, dev->name, idx);
 			goto parse_fail;
 		}
 		table = &((*table)->next);
 	}
 	DMDEBUG("tables parsed: %d", dev->table_count);

 	return opt.next;

 parse_fail:
 	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 device %lu", i);
 			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, i);
 		if (!str)	/* NULL indicates error in parsing, bail */
 			goto error;

 		str = dm_parse_tables(dev, str, i);
 		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_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)
 {
 	struct dm_option opt;
 	unsigned long long num_devices;

 	if (!str) {
 		DMERR("setup str is NULL");
 		goto parse_fail;
 	}

 	DMDEBUG("Want to parse \"%s\"", str);
 	opt.next = str;
 	if (get_dm_option_u64(&opt, DM_FIELD_SEP, &num_devices))
 		goto parse_fail;
 	str = opt.next;
 	if (num_devices > DM_MAX_DEVICES) {
 		DMERR("too many devices %llu > %d", num_devices,
 		      DM_MAX_DEVICES);
 	}
 	dm_setup_args.num_devices = num_devices;
 	dm_setup_args.str = str;

 	DMINFO("will configure %lu device%s", dm_setup_args.num_devices,
 	       dm_setup_args.num_devices == 1 ? "" : "s");
 	dm_early_setup = 1;
 	return 1;

 parse_fail:
 	DMWARN("Invalid arguments supplied to dm=.");
 	return 0;
 }

 static void __init dm_setup_drives(void)
 {
 	struct mapped_device *md = NULL;
 	struct dm_table *tables = NULL;
 	struct dm_setup_table *table;
 	struct dm_device *dev;
 	char *uuid;
 	fmode_t fmode = FMODE_READ;
 	struct dm_device *devices;

 	devices = dm_parse_args();

 	for (dev = devices; dev; dev = dev->next) {
 		if (dm_create(dev->minor, &md)) {
 			DMERR("failed to create device %s", dev->name);
 			goto 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(&tables, fmode, dev->table_count, md)) {
 			DMERR("failed to create device %s tables", dev->name);
 			goto fail_put;
 		}
 		for (table = dev->table; table; table = table->next) {
 			DMINFO("device %s adding table '%llu %llu %s %s'",
 			       dev->name,
 			       (unsigned long long) table->begin,
 			       (unsigned long long) table->length,
 			       table->type, table->params);
 			if (dm_table_add_target(tables, table->type,
 						table->begin,
 						table->length,
 						table->params)) {
 				DMERR("failed to add table to device %s",
 					dev->name);
 				goto fail_put;
 			}
 		}
 		dm_lock_md_type(md);
 		if (dm_table_complete(tables)) {
 			DMERR("failed to complete device %s tables",
 				dev->name);
 			dm_unlock_md_type(md);
 			goto fail_put;
 		}
 		dm_unlock_md_type(md);

 		/* Suspend the device so that we can bind it to the tables. */
 		if (dm_suspend(md, 0)) {
 			DMERR("failed to suspend device %s pre-bind",
 				dev->name);
 			goto fail_put;
 		}

 		/*
 		 * Bind the tables to the device. This is the only way
 		 * to associate md->map with the tables and set the disk
 		 * capacity directly.
 		 */
 		if (dm_swap_table(md, tables)) {  /* should return NULL. */
 			DMERR("failed to bind device %s to tables",
 				dev->name);
 			goto fail_put;
 		}

 		/* Finally, resume and the device should be ready. */
 		if (dm_resume(md)) {
 			DMERR("failed to resume device %s", dev->name);
 			goto fail_put;
 		}

 		/* 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)) {
 			DMERR("failed to export device %s", dev->name);
 			goto fail_put;
 		}
 		DMINFO("dm-%d (%s) is ready", dev->minor, dev->name);
 	}
 	dm_setup_cleanup(devices);
 	return;

 fail_put:
 	dm_put(md);
 fail:
 	DMERR("starting dm-%d (%s) failed", dev->minor, dev->name);
 	dm_setup_cleanup(devices);
 }

 __setup("dm=", dm_setup);

 void __init dm_run_setup(void)
 {
 	if (!dm_early_setup)
 		return;
 	DMINFO("attempting early device configuration.");
 	dm_setup_drives();
 }
	/*
	* do_mounts_dm.c
	* Copyright (C) 2010 The Chromium OS Authors <chromium-os-dev@chromium.org>
	* Based on do_mounts_md.c
	*
	* This file is released under the GPLv2.
	*/
	#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"

	#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"

	#define DM_MSG_PREFIX "init"
	#define DMERR_PARSE(fmt, args...) \
	DMERR("failed to parse " fmt " for device %s<%lu>", args)

	/* Separators used for parsing the dm= argument. */
	#define DM_FIELD_SEP " "
	#define DM_LINE_SEP ","
	#define DM_ANY_SEP DM_FIELD_SEP DM_LINE_SEP

	/* See Documentation/device-mapper/boot.txt for dm="..." format details. */

	struct dm_setup_table {
	sector_t begin;
	sector_t length;
	char *type;
	char *params;
	/* simple singly linked list */
	struct dm_setup_table *next;
	};

	struct dm_device {
	int minor;
	int ro;
	char name[DM_MAX_NAME];
	char uuid[DM_MAX_UUID];
	unsigned long num_tables;
	struct dm_setup_table *table;
	int table_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 int dm_early_setup __initdata;

	static int __init get_dm_option(struct dm_option opt, const char accept)
	{
	char *str = opt->next;
	char *endp;

	if (!str)
	return 0;

	str = skip_spaces(str);
	opt->start = str;
	endp = strpbrk(str, accept);
	if (!endp) { /* act like strchrnul */
	opt->len = strlen(str);
	endp = str + opt->len;
	} else {
	opt->len = endp - str;
	}
	opt->delim = *endp;
	if (*endp == 0) {
	/* Don't advance past the nul. */
	opt->next = endp;
	} else {
	opt->next = endp + 1;
	}
	return opt->len != 0;
	}

	static int __init get_dm_option_u64(struct dm_option opt, const char sep,
	unsigned long long *result)
	{
	char buf[32];

	if (!get_dm_option(opt, sep))
	return -EINVAL;

	strlcpy(buf, opt->start, min(sizeof(buf), opt->len + 1));
	return kstrtoull(buf, 0, result);
	}

	static void __init dm_setup_cleanup(struct dm_device *devices)
	{
	struct dm_device *dev = devices;

	while (dev) {
	struct dm_device *old_dev = dev;
	struct dm_setup_table *table = dev->table;

	while (table) {
	struct dm_setup_table *old_table = table;

	kfree(table->type);
	kfree(table->params);
	table = table->next;
	kfree(old_table);
	dev->table_count--;
	}
	WARN_ON(dev->table_count);
	dev = dev->next;
	kfree(old_dev);
	}
	}

	static char * __init dm_parse_device(struct dm_device dev, char str,
	unsigned long idx)
	{
	struct dm_option opt;
	size_t len;
	unsigned long long num_tables;

	/* Grab the logical name of the device to be exported to udev */
	opt.next = str;
	if (!get_dm_option(&opt, DM_FIELD_SEP)) {
	DMERR_PARSE("name", "", idx);
	goto parse_fail;
	}
	len = min(opt.len + 1, sizeof(dev->name));
	strlcpy(dev->name, opt.start, len); /* includes nul */

	/* Grab the UUID value or "none" */
	if (!get_dm_option(&opt, DM_FIELD_SEP)) {
	DMERR_PARSE("uuid", dev->name, idx);
	goto parse_fail;
	}
	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 */
	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_PARSE("table mode", dev->name, idx);
	goto parse_fail;
	}

	/* Optional number field */
	if (opt.delim == DM_FIELD_SEP[0]) {
	if (get_dm_option_u64(&opt, DM_LINE_SEP, &num_tables)) {
	DMERR_PARSE("number of tables", dev->name, idx);
	goto parse_fail;
	}
	} else {
	num_tables = 1;
	}
	if (num_tables > DM_MAX_TARGETS) {
	DMERR_PARSE("too many tables (%llu > %d)", num_tables,
	DM_MAX_TARGETS, dev->name, idx);
	}
	dev->num_tables = num_tables;

	return opt.next;

	parse_fail:
	return NULL;
	}

	static char * __init dm_parse_tables(struct dm_device dev, char str,
	unsigned long idx)
	{
	struct dm_option opt;
	struct dm_setup_table **table = &dev->table;
	unsigned long num_tables = dev->num_tables;
	unsigned long i;
	unsigned long long value;

	/*
	* Tables are defined as per the normal table format but with a
	* comma as a newline separator.
	*/
	opt.next = str;
	for (i = 0; i < num_tables; i++) {
	*table = kzalloc(sizeof(struct dm_setup_table), GFP_KERNEL);
	if (!*table) {
	DMERR_PARSE("table %lu (out of memory)", i, dev->name,
	idx);
	goto parse_fail;
	}
	dev->table_count++;

	if (get_dm_option_u64(&opt, DM_FIELD_SEP, &value)) {
	DMERR_PARSE("starting sector for table %lu", i,
	dev->name, idx);
	goto parse_fail;
	}
	(*table)->begin = value;

	if (get_dm_option_u64(&opt, DM_FIELD_SEP, &value)) {
	DMERR_PARSE("length for table %lu", i, dev->name, idx);
	goto parse_fail;
	}
	(*table)->length = value;

	if (get_dm_option(&opt, DM_FIELD_SEP))
	(*table)->type = kstrndup(opt.start, opt.len,
	GFP_KERNEL);
	if (!((*table)->type)) {
	DMERR_PARSE("type for table %lu", i, dev->name, idx);
	goto parse_fail;
	}
	if (get_dm_option(&opt, DM_LINE_SEP))
	(*table)->params = kstrndup(opt.start, opt.len,
	GFP_KERNEL);
	if (!((*table)->params)) {
	DMERR_PARSE("params for table %lu", i, dev->name, idx);
	goto parse_fail;
	}
	table = &((*table)->next);
	}
	DMDEBUG("tables parsed: %d", dev->table_count);

	return opt.next;

	parse_fail:
	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 device %lu", i);
	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, i);
	if (!str) /* NULL indicates error in parsing, bail */
	goto error;

	str = dm_parse_tables(dev, str, i);
	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_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)
	{
	struct dm_option opt;
	unsigned long long num_devices;

	if (!str) {
	DMERR("setup str is NULL");
	goto parse_fail;
	}

	DMDEBUG("Want to parse \"%s\"", str);
	opt.next = str;
	if (get_dm_option_u64(&opt, DM_FIELD_SEP, &num_devices))
	goto parse_fail;
	str = opt.next;
	if (num_devices > DM_MAX_DEVICES) {
	DMERR("too many devices %llu > %d", num_devices,
	DM_MAX_DEVICES);
	}
	dm_setup_args.num_devices = num_devices;
	dm_setup_args.str = str;

	DMINFO("will configure %lu device%s", dm_setup_args.num_devices,
	dm_setup_args.num_devices == 1 ? "" : "s");
	dm_early_setup = 1;
	return 1;

	parse_fail:
	DMWARN("Invalid arguments supplied to dm=.");
	return 0;
	}

	static void __init dm_setup_drives(void)
	{
	struct mapped_device *md = NULL;
	struct dm_table *tables = NULL;
	struct dm_setup_table *table;
	struct dm_device *dev;
	char *uuid;
	fmode_t fmode = FMODE_READ;
	struct dm_device *devices;

	devices = dm_parse_args();

	for (dev = devices; dev; dev = dev->next) {
	if (dm_create(dev->minor, &md)) {
	DMERR("failed to create device %s", dev->name);
	goto 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(&tables, fmode, dev->table_count, md)) {
	DMERR("failed to create device %s tables", dev->name);
	goto fail_put;
	}
	for (table = dev->table; table; table = table->next) {
	DMINFO("device %s adding table '%llu %llu %s %s'",
	dev->name,
	(unsigned long long) table->begin,
	(unsigned long long) table->length,
	table->type, table->params);
	if (dm_table_add_target(tables, table->type,
	table->begin,
	table->length,
	table->params)) {
	DMERR("failed to add table to device %s",
	dev->name);
	goto fail_put;
	}
	}
	dm_lock_md_type(md);
	if (dm_table_complete(tables)) {
	DMERR("failed to complete device %s tables",
	dev->name);
	dm_unlock_md_type(md);
	goto fail_put;
	}
	dm_unlock_md_type(md);

	/* Suspend the device so that we can bind it to the tables. */
	if (dm_suspend(md, 0)) {
	DMERR("failed to suspend device %s pre-bind",
	dev->name);
	goto fail_put;
	}

	/*
	* Bind the tables to the device. This is the only way
	* to associate md->map with the tables and set the disk
	* capacity directly.
	*/
	if (dm_swap_table(md, tables)) { /* should return NULL. */
	DMERR("failed to bind device %s to tables",
	dev->name);
	goto fail_put;
	}

	/* Finally, resume and the device should be ready. */
	if (dm_resume(md)) {
	DMERR("failed to resume device %s", dev->name);
	goto fail_put;
	}

	/* 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)) {
	DMERR("failed to export device %s", dev->name);
	goto fail_put;
	}
	DMINFO("dm-%d (%s) is ready", dev->minor, dev->name);
	}
	dm_setup_cleanup(devices);
	return;

	fail_put:
	dm_put(md);
	fail:
	DMERR("starting dm-%d (%s) failed", dev->minor, dev->name);
	dm_setup_cleanup(devices);
	}

	__setup("dm=", dm_setup);

	void __init dm_run_setup(void)
	{
	if (!dm_early_setup)
	return;
	DMINFO("attempting early device configuration.");
	dm_setup_drives();
	}