Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6a6a7657 authored by David Zeuthen's avatar David Zeuthen
Browse files

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: default avatarDavid Zeuthen <zeuthen@google.com>
parent d77312ae

include/linux/device-mapper.h

+7 −0
Original line number Diff line number Diff line
@@ -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.

 */

init/do_mounts_dm.c

+300 −256
Original line number Diff line number Diff line
@@ -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,342 +75,347 @@ 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;

	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;

	dm_setup_args.ro = 0;

	dm_setup_args.target = NULL;

	dm_setup_args.target_count = 0;

	return 0;

}

	struct dm_device *dev = devices;



static int __init dm_setup_cleanup(void)

{

	struct dm_setup_target *target = dm_setup_args.target;

	struct dm_setup_target *old_target = NULL;

	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);

		old_target = target;

			target = target->next;

			kfree(old_target);

		dm_setup_args.target_count--;

			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;



parse_fail:

	/* 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;

	}



static void __init dm_substitute_devices(char *str, size_t str_len)

{

	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;

	if (dev->num_targets > DM_MAX_TARGETS) {

		DMERR("too many targets %lu > %d",

			dev->num_targets, DM_MAX_TARGETS);

	}

	return opt.next;



		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;

	}

parse_fail:

	return NULL;

}



static int __init dm_setup_parse_targets(char *str)

static char * __init dm_parse_targets(struct dm_device *dev, 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);

		(*target)->length = simple_strtoull(opt.start, NULL, 10);



		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);

		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;

	devices = dm_parse_args();



	if (dm_create(dm_setup_args.minor, &md)) {

	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), dm_setup_args.ro);

		/*

		 * In addition to flagging the table below, the disk must be

		 * set explicitly ro/rw.

		 */

		set_disk_ro(dm_disk(md), dev->ro);



	if (!dm_setup_args.ro)

		if (!dev->ro)

			fmode |= FMODE_WRITE;

	if (dm_table_create(&table, fmode, dm_setup_args.target_count, md)) {

		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) {



		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");

			       (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;

		}



		if (dm_table_complete(table)) {

			DMDEBUG("failed to complete the table");

			goto table_complete_fail;

		}



	if (dm_get_md_type(md) == DM_TYPE_NONE) {

		dm_set_md_type(md, dm_table_get_type(table));

		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. */

		/* 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;

		}



		/*

		 * 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;
@@ -386,33 +428,35 @@ static void __init dm_setup_drive(void) 
		}



		/* Export the dm device via the ioctl interface */

	if (!strcmp(DM_NO_UUID, dm_setup_args.uuid))

		if (!strcmp(DM_NO_UUID, dev->uuid))

			uuid = NULL;

	if (dm_ioctl_export(md, dm_setup_args.name, uuid)) {

		DMDEBUG("failed to export device with given name and uuid");

		if (dm_ioctl_export(md, dev->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();



		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();

}