[thirdparty/kernel/linux.git] / block / partitions / cmdline.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2013 HUAWEI
 * Author: Cai Zhiyong <caizhiyong@huawei.com>
 *
 * Read block device partition table from the command line.
 * Typically used for fixed block (eMMC) embedded devices.
 * It has no MBR, so saves storage space. Bootloader can be easily accessed
 * by absolute address of data on the block device.
 * Users can easily change the partition.
 *
 * The format for the command line is just like mtdparts.
 *
 * For further information, see "Documentation/block/cmdline-partition.rst"
 *
 */
#include <linux/blkdev.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include "check.h"


/* partition flags */
#define PF_RDONLY                   0x01 /* Device is read only */
#define PF_POWERUP_LOCK             0x02 /* Always locked after reset */

struct cmdline_subpart {
	char name[BDEVNAME_SIZE]; /* partition name, such as 'rootfs' */
	sector_t from;
	sector_t size;
	int flags;
	struct cmdline_subpart *next_subpart;
};

struct cmdline_parts {
	char name[BDEVNAME_SIZE]; /* block device, such as 'mmcblk0' */
	unsigned int nr_subparts;
	struct cmdline_subpart *subpart;
	struct cmdline_parts *next_parts;
};

static int parse_subpart(struct cmdline_subpart **subpart, char *partdef)
{
	int ret = 0;
	struct cmdline_subpart *new_subpart;

	*subpart = NULL;

	new_subpart = kzalloc(sizeof(struct cmdline_subpart), GFP_KERNEL);
	if (!new_subpart)
		return -ENOMEM;

	if (*partdef == '-') {
		new_subpart->size = (sector_t)(~0ULL);
		partdef++;
	} else {
		new_subpart->size = (sector_t)memparse(partdef, &partdef);
		if (new_subpart->size < (sector_t)PAGE_SIZE) {
			pr_warn("cmdline partition size is invalid.");
			ret = -EINVAL;
			goto fail;
		}
	}

	if (*partdef == '@') {
		partdef++;
		new_subpart->from = (sector_t)memparse(partdef, &partdef);
	} else {
		new_subpart->from = (sector_t)(~0ULL);
	}

	if (*partdef == '(') {
		partdef++;
		char *next = strsep(&partdef, ")");

		if (!next) {
			pr_warn("cmdline partition format is invalid.");
			ret = -EINVAL;
			goto fail;
		}

		strscpy(new_subpart->name, next, sizeof(new_subpart->name));
	} else
		new_subpart->name[0] = '\0';

	new_subpart->flags = 0;

	if (!strncmp(partdef, "ro", 2)) {
		new_subpart->flags |= PF_RDONLY;
		partdef += 2;
	}

	if (!strncmp(partdef, "lk", 2)) {
		new_subpart->flags |= PF_POWERUP_LOCK;
		partdef += 2;
	}

	*subpart = new_subpart;
	return 0;
fail:
	kfree(new_subpart);
	return ret;
}

static void free_subpart(struct cmdline_parts *parts)
{
	struct cmdline_subpart *subpart;

	while (parts->subpart) {
		subpart = parts->subpart;
		parts->subpart = subpart->next_subpart;
		kfree(subpart);
	}
}

static int parse_parts(struct cmdline_parts **parts, char *bdevdef)
{
	int ret = -EINVAL;
	char *next;
	struct cmdline_subpart **next_subpart;
	struct cmdline_parts *newparts;

	*parts = NULL;

	newparts = kzalloc(sizeof(struct cmdline_parts), GFP_KERNEL);
	if (!newparts)
		return -ENOMEM;

	next = strsep(&bdevdef, ":");
	if (!next) {
		pr_warn("cmdline partition has no block device.");
		goto fail;
	}

	strscpy(newparts->name, next, sizeof(newparts->name));
	newparts->nr_subparts = 0;

	next_subpart = &newparts->subpart;

	while ((next = strsep(&bdevdef, ","))) {
		ret = parse_subpart(next_subpart, next);
		if (ret)
			goto fail;

		newparts->nr_subparts++;
		next_subpart = &(*next_subpart)->next_subpart;
	}

	if (!newparts->subpart) {
		pr_warn("cmdline partition has no valid partition.");
		ret = -EINVAL;
		goto fail;
	}

	*parts = newparts;

	return 0;
fail:
	free_subpart(newparts);
	kfree(newparts);
	return ret;
}

static void cmdline_parts_free(struct cmdline_parts **parts)
{
	struct cmdline_parts *next_parts;

	while (*parts) {
		next_parts = (*parts)->next_parts;
		free_subpart(*parts);
		kfree(*parts);
		*parts = next_parts;
	}
}

static int cmdline_parts_parse(struct cmdline_parts **parts,
		const char *cmdline)
{
	int ret;
	char *buf;
	char *pbuf;
	char *next;
	struct cmdline_parts **next_parts;

	*parts = NULL;

	pbuf = buf = kstrdup(cmdline, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	next_parts = parts;

	while ((next = strsep(&pbuf, ";"))) {
		ret = parse_parts(next_parts, next);
		if (ret)
			goto fail;

		next_parts = &(*next_parts)->next_parts;
	}

	if (!*parts) {
		pr_warn("cmdline partition has no valid partition.");
		ret = -EINVAL;
		goto fail;
	}

	ret = 0;
done:
	kfree(buf);
	return ret;

fail:
	cmdline_parts_free(parts);
	goto done;
}

static struct cmdline_parts *cmdline_parts_find(struct cmdline_parts *parts,
					 const char *bdev)
{
	while (parts && strncmp(bdev, parts->name, sizeof(parts->name)))
		parts = parts->next_parts;
	return parts;
}

static char *cmdline;
static struct cmdline_parts *bdev_parts;

static int add_part(int slot, struct cmdline_subpart *subpart,
		struct parsed_partitions *state)
{
	struct partition_meta_info *info;
	char tmp[sizeof(info->volname) + 4];

	if (slot >= state->limit)
		return 1;

	put_partition(state, slot, subpart->from >> 9,
		      subpart->size >> 9);

	info = &state->parts[slot].info;

	strscpy(info->volname, subpart->name, sizeof(info->volname));

	snprintf(tmp, sizeof(tmp), "(%s)", info->volname);
	strlcat(state->pp_buf, tmp, PAGE_SIZE);

	state->parts[slot].has_info = true;

	return 0;
}

static int cmdline_parts_set(struct cmdline_parts *parts, sector_t disk_size,
		struct parsed_partitions *state)
{
	sector_t from = 0;
	struct cmdline_subpart *subpart;
	int slot = 1;

	for (subpart = parts->subpart; subpart;
	     subpart = subpart->next_subpart, slot++) {
		if (subpart->from == (sector_t)(~0ULL))
			subpart->from = from;
		else
			from = subpart->from;

		if (from >= disk_size)
			break;

		if (subpart->size > (disk_size - from))
			subpart->size = disk_size - from;

		from += subpart->size;

		if (add_part(slot, subpart, state))
			break;
	}

	return slot;
}

static int __init cmdline_parts_setup(char *s)
{
	cmdline = s;
	return 1;
}
__setup("blkdevparts=", cmdline_parts_setup);

static bool has_overlaps(sector_t from, sector_t size,
			 sector_t from2, sector_t size2)
{
	sector_t end = from + size;
	sector_t end2 = from2 + size2;

	if (from >= from2 && from < end2)
		return true;

	if (end > from2 && end <= end2)
		return true;

	if (from2 >= from && from2 < end)
		return true;

	if (end2 > from && end2 <= end)
		return true;

	return false;
}

static inline void overlaps_warns_header(void)
{
	pr_warn("Overlapping partitions are used in command line partitions.");
	pr_warn("Don't use filesystems on overlapping partitions:");
}

static void cmdline_parts_verifier(int slot, struct parsed_partitions *state)
{
	int i;
	bool header = true;

	for (; slot < state->limit && state->parts[slot].has_info; slot++) {
		for (i = slot+1; i < state->limit && state->parts[i].has_info;
		     i++) {
			if (has_overlaps(state->parts[slot].from,
					 state->parts[slot].size,
					 state->parts[i].from,
					 state->parts[i].size)) {
				if (header) {
					header = false;
					overlaps_warns_header();
				}
				pr_warn("%s[%llu,%llu] overlaps with "
					"%s[%llu,%llu].",
					state->parts[slot].info.volname,
					(u64)state->parts[slot].from << 9,
					(u64)state->parts[slot].size << 9,
					state->parts[i].info.volname,
					(u64)state->parts[i].from << 9,
					(u64)state->parts[i].size << 9);
			}
		}
	}
}

/*
 * Purpose: allocate cmdline partitions.
 * Returns:
 * -1 if unable to read the partition table
 *  0 if this isn't our partition table
 *  1 if successful
 */
int cmdline_partition(struct parsed_partitions *state)
{
	sector_t disk_size;
	struct cmdline_parts *parts;

	if (cmdline) {
		if (bdev_parts)
			cmdline_parts_free(&bdev_parts);

		if (cmdline_parts_parse(&bdev_parts, cmdline)) {
			cmdline = NULL;
			return -1;
		}
		cmdline = NULL;
	}

	if (!bdev_parts)
		return 0;

	parts = cmdline_parts_find(bdev_parts, state->disk->disk_name);
	if (!parts)
		return 0;

	disk_size = get_capacity(state->disk) << 9;

	cmdline_parts_set(parts, disk_size, state);
	cmdline_parts_verifier(1, state);

	strlcat(state->pp_buf, "\n", PAGE_SIZE);

	return 1;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
bab55417 CZ	2	/*
	3	* Copyright (C) 2013 HUAWEI
	4	* Author: Cai Zhiyong <caizhiyong@huawei.com>
	5	*
080506ad PG	6	* Read block device partition table from the command line.
	7	* Typically used for fixed block (eMMC) embedded devices.
	8	* It has no MBR, so saves storage space. Bootloader can be easily accessed
bab55417 CZ	9	* by absolute address of data on the block device.
	10	* Users can easily change the partition.
	11	*
	12	* The format for the command line is just like mtdparts.
	13	*
898bd37a	14	* For further information, see "Documentation/block/cmdline-partition.rst"
bab55417 CZ	15	*
bab55417 CZ	16	*/
2164877c CH	17	#include <linux/blkdev.h>
	18	#include <linux/fs.h>
	19	#include <linux/slab.h>
	20	#include "check.h"
bab55417	21
bab55417	22
2164877c CH	23	/* partition flags */
	24	#define PF_RDONLY 0x01 /* Device is read only */
	25	#define PF_POWERUP_LOCK 0x02 /* Always locked after reset */
	26
	27	struct cmdline_subpart {
	28	char name[BDEVNAME_SIZE]; /* partition name, such as 'rootfs' */
	29	sector_t from;
	30	sector_t size;
	31	int flags;
	32	struct cmdline_subpart *next_subpart;
	33	};
	34
	35	struct cmdline_parts {
	36	char name[BDEVNAME_SIZE]; /* block device, such as 'mmcblk0' */
	37	unsigned int nr_subparts;
	38	struct cmdline_subpart *subpart;
	39	struct cmdline_parts *next_parts;
	40	};
	41
	42	static int parse_subpart(struct cmdline_subpart *subpart, char partdef)
	43	{
	44	int ret = 0;
	45	struct cmdline_subpart *new_subpart;
	46
	47	*subpart = NULL;
	48
	49	new_subpart = kzalloc(sizeof(struct cmdline_subpart), GFP_KERNEL);
	50	if (!new_subpart)
	51	return -ENOMEM;
	52
	53	if (*partdef == '-') {
	54	new_subpart->size = (sector_t)(~0ULL);
	55	partdef++;
	56	} else {
	57	new_subpart->size = (sector_t)memparse(partdef, &partdef);
	58	if (new_subpart->size < (sector_t)PAGE_SIZE) {
	59	pr_warn("cmdline partition size is invalid.");
	60	ret = -EINVAL;
	61	goto fail;
	62	}
	63	}
	64
	65	if (*partdef == '@') {
	66	partdef++;
	67	new_subpart->from = (sector_t)memparse(partdef, &partdef);
	68	} else {
	69	new_subpart->from = (sector_t)(~0ULL);
	70	}
	71
	72	if (*partdef == '(') {
bc2e07df IH	73	partdef++;
bc2e07df IH	74	char *next = strsep(&partdef, ")");
2164877c CH	75
	76	if (!next) {
	77	pr_warn("cmdline partition format is invalid.");
	78	ret = -EINVAL;
	79	goto fail;
	80	}
	81
bc2e07df	82	strscpy(new_subpart->name, next, sizeof(new_subpart->name));
2164877c CH	83	} else
	84	new_subpart->name[0] = '\0';
	85
	86	new_subpart->flags = 0;
	87
	88	if (!strncmp(partdef, "ro", 2)) {
	89	new_subpart->flags \|= PF_RDONLY;
	90	partdef += 2;
	91	}
	92
	93	if (!strncmp(partdef, "lk", 2)) {
	94	new_subpart->flags \|= PF_POWERUP_LOCK;
	95	partdef += 2;
	96	}
	97
	98	*subpart = new_subpart;
	99	return 0;
	100	fail:
	101	kfree(new_subpart);
	102	return ret;
	103	}
	104
	105	static void free_subpart(struct cmdline_parts *parts)
	106	{
	107	struct cmdline_subpart *subpart;
	108
	109	while (parts->subpart) {
	110	subpart = parts->subpart;
	111	parts->subpart = subpart->next_subpart;
	112	kfree(subpart);
	113	}
	114	}
	115
bc2e07df	116	static int parse_parts(struct cmdline_parts *parts, char bdevdef)
2164877c CH	117	{
	118	int ret = -EINVAL;
	119	char *next;
2164877c CH	120	struct cmdline_subpart **next_subpart;
2164877c CH	121	struct cmdline_parts *newparts;
2164877c CH	122
	123	*parts = NULL;
	124
	125	newparts = kzalloc(sizeof(struct cmdline_parts), GFP_KERNEL);
	126	if (!newparts)
	127	return -ENOMEM;
	128
bc2e07df	129	next = strsep(&bdevdef, ":");
2164877c CH	130	if (!next) {
	131	pr_warn("cmdline partition has no block device.");
	132	goto fail;
	133	}
	134
bc2e07df	135	strscpy(newparts->name, next, sizeof(newparts->name));
2164877c CH	136	newparts->nr_subparts = 0;
	137
	138	next_subpart = &newparts->subpart;
	139
bc2e07df IH	140	while ((next = strsep(&bdevdef, ","))) {
bc2e07df IH	141	ret = parse_subpart(next_subpart, next);
2164877c CH	142	if (ret)
	143	goto fail;
	144
	145	newparts->nr_subparts++;
	146	next_subpart = &(*next_subpart)->next_subpart;
	147	}
	148
	149	if (!newparts->subpart) {
	150	pr_warn("cmdline partition has no valid partition.");
	151	ret = -EINVAL;
	152	goto fail;
	153	}
	154
	155	*parts = newparts;
	156
	157	return 0;
	158	fail:
	159	free_subpart(newparts);
	160	kfree(newparts);
	161	return ret;
	162	}
	163
	164	static void cmdline_parts_free(struct cmdline_parts **parts)
	165	{
	166	struct cmdline_parts *next_parts;
	167
	168	while (*parts) {
	169	next_parts = (*parts)->next_parts;
	170	free_subpart(*parts);
	171	kfree(*parts);
	172	*parts = next_parts;
	173	}
	174	}
	175
	176	static int cmdline_parts_parse(struct cmdline_parts **parts,
	177	const char *cmdline)
	178	{
	179	int ret;
	180	char *buf;
	181	char *pbuf;
	182	char *next;
	183	struct cmdline_parts **next_parts;
	184
	185	*parts = NULL;
	186
bc2e07df	187	pbuf = buf = kstrdup(cmdline, GFP_KERNEL);
2164877c CH	188	if (!buf)
	189	return -ENOMEM;
	190
	191	next_parts = parts;
	192
bc2e07df IH	193	while ((next = strsep(&pbuf, ";"))) {
bc2e07df IH	194	ret = parse_parts(next_parts, next);
2164877c CH	195	if (ret)
	196	goto fail;
	197
2164877c CH	198	next_parts = &(*next_parts)->next_parts;
	199	}
	200
	201	if (!*parts) {
	202	pr_warn("cmdline partition has no valid partition.");
	203	ret = -EINVAL;
	204	goto fail;
	205	}
	206
	207	ret = 0;
	208	done:
	209	kfree(buf);
	210	return ret;
	211
	212	fail:
	213	cmdline_parts_free(parts);
	214	goto done;
	215	}
	216
	217	static struct cmdline_parts cmdline_parts_find(struct cmdline_parts parts,
	218	const char *bdev)
	219	{
	220	while (parts && strncmp(bdev, parts->name, sizeof(parts->name)))
	221	parts = parts->next_parts;
	222	return parts;
	223	}
bab55417 CZ	224
	225	static char *cmdline;
	226	static struct cmdline_parts *bdev_parts;
	227
2164877c CH	228	static int add_part(int slot, struct cmdline_subpart *subpart,
2164877c CH	229	struct parsed_partitions *state)
bab55417	230	{
bab55417 CZ	231	struct partition_meta_info *info;
bab55417 CZ	232	char tmp[sizeof(info->volname) + 4];
bab55417 CZ	233
	234	if (slot >= state->limit)
	235	return 1;
	236
	237	put_partition(state, slot, subpart->from >> 9,
	238	subpart->size >> 9);
	239
	240	info = &state->parts[slot].info;
	241
bc2e07df	242	strscpy(info->volname, subpart->name, sizeof(info->volname));
bab55417 CZ	243
	244	snprintf(tmp, sizeof(tmp), "(%s)", info->volname);
	245	strlcat(state->pp_buf, tmp, PAGE_SIZE);
	246
	247	state->parts[slot].has_info = true;
	248
	249	return 0;
	250	}
	251
2164877c CH	252	static int cmdline_parts_set(struct cmdline_parts *parts, sector_t disk_size,
	253	struct parsed_partitions *state)
	254	{
	255	sector_t from = 0;
	256	struct cmdline_subpart *subpart;
	257	int slot = 1;
	258
	259	for (subpart = parts->subpart; subpart;
	260	subpart = subpart->next_subpart, slot++) {
	261	if (subpart->from == (sector_t)(~0ULL))
	262	subpart->from = from;
	263	else
	264	from = subpart->from;
	265
	266	if (from >= disk_size)
	267	break;
	268
	269	if (subpart->size > (disk_size - from))
	270	subpart->size = disk_size - from;
	271
	272	from += subpart->size;
	273
	274	if (add_part(slot, subpart, state))
	275	break;
	276	}
	277
	278	return slot;
	279	}
	280
bab55417 CZ	281	static int __init cmdline_parts_setup(char *s)
	282	{
	283	cmdline = s;
	284	return 1;
	285	}
	286	__setup("blkdevparts=", cmdline_parts_setup);
	287
645d4095 WY	288	static bool has_overlaps(sector_t from, sector_t size,
	289	sector_t from2, sector_t size2)
	290	{
	291	sector_t end = from + size;
	292	sector_t end2 = from2 + size2;
	293
	294	if (from >= from2 && from < end2)
	295	return true;
	296
	297	if (end > from2 && end <= end2)
	298	return true;
	299
	300	if (from2 >= from && from2 < end)
	301	return true;
	302
	303	if (end2 > from && end2 <= end)
	304	return true;
	305
	306	return false;
	307	}
	308
	309	static inline void overlaps_warns_header(void)
	310	{
	311	pr_warn("Overlapping partitions are used in command line partitions.");
	312	pr_warn("Don't use filesystems on overlapping partitions:");
	313	}
	314
	315	static void cmdline_parts_verifier(int slot, struct parsed_partitions *state)
	316	{
	317	int i;
	318	bool header = true;
	319
	320	for (; slot < state->limit && state->parts[slot].has_info; slot++) {
	321	for (i = slot+1; i < state->limit && state->parts[i].has_info;
	322	i++) {
	323	if (has_overlaps(state->parts[slot].from,
	324	state->parts[slot].size,
	325	state->parts[i].from,
	326	state->parts[i].size)) {
	327	if (header) {
	328	header = false;
	329	overlaps_warns_header();
	330	}
	331	pr_warn("%s[%llu,%llu] overlaps with "
	332	"%s[%llu,%llu].",
	333	state->parts[slot].info.volname,
	334	(u64)state->parts[slot].from << 9,
	335	(u64)state->parts[slot].size << 9,
	336	state->parts[i].info.volname,
	337	(u64)state->parts[i].from << 9,
	338	(u64)state->parts[i].size << 9);
	339	}
	340	}
	341	}
	342	}
	343
bab55417 CZ	344	/*
	345	* Purpose: allocate cmdline partitions.
	346	* Returns:
	347	* -1 if unable to read the partition table
	348	* 0 if this isn't our partition table
	349	* 1 if successful
	350	*/
	351	int cmdline_partition(struct parsed_partitions *state)
	352	{
	353	sector_t disk_size;
bab55417 CZ	354	struct cmdline_parts *parts;
	355
	356	if (cmdline) {
	357	if (bdev_parts)
	358	cmdline_parts_free(&bdev_parts);
	359
	360	if (cmdline_parts_parse(&bdev_parts, cmdline)) {
	361	cmdline = NULL;
	362	return -1;
	363	}
	364	cmdline = NULL;
	365	}
	366
	367	if (!bdev_parts)
	368	return 0;
	369
a08aa9bc	370	parts = cmdline_parts_find(bdev_parts, state->disk->disk_name);
bab55417 CZ	371	if (!parts)
	372	return 0;
	373
a08aa9bc	374	disk_size = get_capacity(state->disk) << 9;
bab55417	375
2164877c	376	cmdline_parts_set(parts, disk_size, state);
645d4095	377	cmdline_parts_verifier(1, state);
bab55417 CZ	378
	379	strlcat(state->pp_buf, "\n", PAGE_SIZE);
	380
	381	return 1;
	382	}