[J-u-boot.git] / cmd / part.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
 *
 * made from cmd_ext2, which was:
 *
 * (C) Copyright 2004
 * esd gmbh <www.esd-electronics.com>
 * Reinhard Arlt <[email protected]>
 *
 * made from cmd_reiserfs by
 *
 * (C) Copyright 2003 - 2004
 * Sysgo Real-Time Solutions, AG <www.elinos.com>
 * Pavel Bartusek <[email protected]>
 */

#include <config.h>
#include <command.h>
#include <env.h>
#include <part.h>
#include <stdio.h>
#include <vsprintf.h>

enum cmd_part_info {
	CMD_PART_INFO_START = 0,
	CMD_PART_INFO_SIZE,
	CMD_PART_INFO_NUMBER
};

static int do_part_uuid(int argc, char *const argv[])
{
	int part;
	struct blk_desc *dev_desc;
	struct disk_partition info;

	if (argc < 2)
		return CMD_RET_USAGE;
	if (argc > 3)
		return CMD_RET_USAGE;

	part = blk_get_device_part_str(argv[0], argv[1], &dev_desc, &info, 0);
	if (part < 0)
		return 1;

	if (argc > 2)
		env_set(argv[2], info.uuid);
	else
		printf("%s\n", info.uuid);

	return 0;
}

static int do_part_list(int argc, char *const argv[])
{
	int ret;
	struct blk_desc *desc;
	char *var = NULL;
	bool bootable = false;
	int i;

	if (argc < 2)
		return CMD_RET_USAGE;

	if (argc > 2) {
		for (i = 2; i < argc ; i++) {
			if (argv[i][0] == '-') {
				if (!strcmp(argv[i], "-bootable")) {
					bootable = true;
				} else {
					printf("Unknown option %s\n", argv[i]);
					return CMD_RET_USAGE;
				}
			} else {
				var = argv[i];
				break;
			}
		}

		/* Loops should have been exited at the last argument, which
		 * as it contained the variable */
		if (argc != i + 1)
			return CMD_RET_USAGE;
	}

	ret = blk_get_device_by_str(argv[0], argv[1], &desc);
	if (ret < 0)
		return 1;

	if (var != NULL) {
		int p;
		char str[3 * MAX_SEARCH_PARTITIONS] = { '\0', };
		struct disk_partition info;

		for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
			char t[5];
			int r = part_get_info(desc, p, &info);

			if (r != 0)
				continue;

			if (bootable && !info.bootable)
				continue;

			sprintf(t, "%s%x", str[0] ? " " : "", p);
			strcat(str, t);
		}
		env_set(var, str);
		return 0;
	}

	part_print(desc);

	return 0;
}

static int do_part_info(int argc, char *const argv[], enum cmd_part_info param)
{
	struct blk_desc *desc;
	struct disk_partition info;
	char buf[512] = { 0 };
	char *endp;
	int part;
	int err;
	int ret;

	if (argc < 3)
		return CMD_RET_USAGE;
	if (argc > 4)
		return CMD_RET_USAGE;

	ret = blk_get_device_by_str(argv[0], argv[1], &desc);
	if (ret < 0)
		return 1;

	part = simple_strtoul(argv[2], &endp, 0);
	if (*endp == '\0') {
		err = part_get_info(desc, part, &info);
		if (err)
			return 1;
	} else {
		part = part_get_info_by_name(desc, argv[2], &info);
		if (part < 0)
			return 1;
	}

	switch (param) {
	case CMD_PART_INFO_START:
		snprintf(buf, sizeof(buf), LBAF, info.start);
		break;
	case CMD_PART_INFO_SIZE:
		snprintf(buf, sizeof(buf), LBAF, info.size);
		break;
	case CMD_PART_INFO_NUMBER:
		snprintf(buf, sizeof(buf), "0x%x", part);
		break;
	default:
		printf("** Unknown cmd_part_info value: %d\n", param);
		return 1;
	}

	if (argc > 3)
		env_set(argv[3], buf);
	else
		printf("%s\n", buf);

	return 0;
}

static int do_part_start(int argc, char *const argv[])
{
	return do_part_info(argc, argv, CMD_PART_INFO_START);
}

static int do_part_size(int argc, char *const argv[])
{
	return do_part_info(argc, argv, CMD_PART_INFO_SIZE);
}

static int do_part_number(int argc, char *const argv[])
{
	return do_part_info(argc, argv, CMD_PART_INFO_NUMBER);
}

static int do_part_set(int argc, char *const argv[])
{
	const char *devname, *partstr, *typestr;
	struct blk_desc *desc;
	int dev;

	if (argc < 3)
		return CMD_RET_USAGE;

	/* Look up the device */
	devname = argv[0];
	partstr = argv[1];
	typestr = argv[2];
	dev = blk_get_device_by_str(devname, partstr, &desc);
	if (dev < 0) {
		printf("** Bad device specification %s %s **\n", devname,
		       partstr);
		return CMD_RET_FAILURE;
	}

	desc->part_type = part_get_type_by_name(typestr);
	if (!desc->part_type) {
		printf("Unknown partition type '%s'\n", typestr);
		return CMD_RET_FAILURE;
	}
	part_print(desc);

	return 0;
}

#ifdef CONFIG_PARTITION_TYPE_GUID
static int do_part_type(int argc, char *const argv[])
{
	int part;
	struct blk_desc *dev_desc;
	struct disk_partition info;

	if (argc < 2)
		return CMD_RET_USAGE;
	if (argc > 3)
		return CMD_RET_USAGE;

	part = blk_get_device_part_str(argv[0], argv[1], &dev_desc, &info, 0);
	if (part < 0)
		return 1;

	if (argc > 2)
		env_set(argv[2], info.type_guid);
	else
		printf("%s\n", info.type_guid);

	return 0;
}
#endif

static int do_part_types(int argc, char * const argv[])
{
	struct part_driver *drv = ll_entry_start(struct part_driver,
						 part_driver);
	const int n_ents = ll_entry_count(struct part_driver, part_driver);
	struct part_driver *entry;
	int i = 0;

	puts("Supported partition tables");

	for (entry = drv; entry != drv + n_ents; entry++) {
		printf("%c %s", i ? ',' : ':', entry->name);
		i++;
	}
	if (!i)
		puts(": <none>");
	puts("\n");
	return CMD_RET_SUCCESS;
}

static int do_part(struct cmd_tbl *cmdtp, int flag, int argc,
		   char *const argv[])
{
	if (argc < 2)
		return CMD_RET_USAGE;

	if (!strcmp(argv[1], "uuid"))
		return do_part_uuid(argc - 2, argv + 2);
	else if (!strcmp(argv[1], "list"))
		return do_part_list(argc - 2, argv + 2);
	else if (!strcmp(argv[1], "start"))
		return do_part_start(argc - 2, argv + 2);
	else if (!strcmp(argv[1], "size"))
		return do_part_size(argc - 2, argv + 2);
	else if (!strcmp(argv[1], "number"))
		return do_part_number(argc - 2, argv + 2);
	else if (!strcmp(argv[1], "types"))
		return do_part_types(argc - 2, argv + 2);
	else if (!strcmp(argv[1], "set"))
		return do_part_set(argc - 2, argv + 2);
#ifdef CONFIG_PARTITION_TYPE_GUID
	else if (!strcmp(argv[1], "type"))
		return do_part_type(argc - 2, argv + 2);
#endif
	return CMD_RET_USAGE;
}

U_BOOT_CMD(
	part,	CONFIG_SYS_MAXARGS,	1,	do_part,
	"disk partition related commands",
	"uuid <interface> <dev>:<part>\n"
	"    - print partition UUID\n"
	"part uuid <interface> <dev>:<part> <varname>\n"
	"    - set environment variable to partition UUID\n"
	"part list <interface> <dev>\n"
	"    - print a device's partition table\n"
	"part list <interface> <dev> [flags] <varname>\n"
	"    - set environment variable to the list of partitions\n"
	"      flags can be -bootable (list only bootable partitions)\n"
	"part start <interface> <dev> <part> <varname>\n"
	"    - set environment variable to the start of the partition (in blocks)\n"
	"      part can be either partition number or partition name\n"
	"part size <interface> <dev> <part> <varname>\n"
	"    - set environment variable to the size of the partition (in blocks)\n"
	"      part can be either partition number or partition name\n"
	"part number <interface> <dev> <part> <varname>\n"
	"    - set environment variable to the partition number using the partition name\n"
	"      part must be specified as partition name\n"
#ifdef CONFIG_PARTITION_TYPE_GUID
	"part type <interface> <dev>:<part>\n"
	"    - print partition type\n"
	"part type <interface> <dev>:<part> <varname>\n"
	"    - set environment variable to partition type\n"
#endif
	"part set <interface> <dev> type\n"
	"    - set partition type for a device\n"
	"part types\n"
	"    - list supported partition table types"
);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
5cf41dcc SW	2	/*
	3	* Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
	4	*
	5	* made from cmd_ext2, which was:
	6	*
	7	* (C) Copyright 2004
	8	* esd gmbh <www.esd-electronics.com>
	9	* Reinhard Arlt <[email protected]>
	10	*
	11	* made from cmd_reiserfs by
	12	*
	13	* (C) Copyright 2003 - 2004
	14	* Sysgo Real-Time Solutions, AG <www.elinos.com>
	15	* Pavel Bartusek <[email protected]>
5cf41dcc SW	16	*/
5cf41dcc SW	17
5cf41dcc SW	18	#include <config.h>
5cf41dcc SW	19	#include <command.h>
9fb625ce	20	#include <env.h>
5cf41dcc	21	#include <part.h>
cb73fe9e	22	#include <stdio.h>
5cf41dcc SW	23	#include <vsprintf.h>
5cf41dcc SW	24
64e6a49a SP	25	enum cmd_part_info {
	26	CMD_PART_INFO_START = 0,
	27	CMD_PART_INFO_SIZE,
be683756	28	CMD_PART_INFO_NUMBER
64e6a49a SP	29	};
64e6a49a SP	30
09140113	31	static int do_part_uuid(int argc, char *const argv[])
5cf41dcc SW	32	{
5cf41dcc SW	33	int part;
4101f687	34	struct blk_desc *dev_desc;
0528979f	35	struct disk_partition info;
5cf41dcc SW	36
	37	if (argc < 2)
	38	return CMD_RET_USAGE;
	39	if (argc > 3)
	40	return CMD_RET_USAGE;
	41
e35929e4	42	part = blk_get_device_part_str(argv[0], argv[1], &dev_desc, &info, 0);
5cf41dcc SW	43	if (part < 0)
	44	return 1;
	45
	46	if (argc > 2)
382bee57	47	env_set(argv[2], info.uuid);
5cf41dcc SW	48	else
	49	printf("%s\n", info.uuid);
	50
	51	return 0;
	52	}
	53
09140113	54	static int do_part_list(int argc, char *const argv[])
5cf41dcc SW	55	{
5cf41dcc SW	56	int ret;
4101f687	57	struct blk_desc *desc;
0798d6fd SS	58	char *var = NULL;
	59	bool bootable = false;
	60	int i;
5cf41dcc	61
0798d6fd	62	if (argc < 2)
5cf41dcc SW	63	return CMD_RET_USAGE;
5cf41dcc SW	64
0798d6fd SS	65	if (argc > 2) {
	66	for (i = 2; i < argc ; i++) {
	67	if (argv[i][0] == '-') {
	68	if (!strcmp(argv[i], "-bootable")) {
	69	bootable = true;
	70	} else {
	71	printf("Unknown option %s\n", argv[i]);
	72	return CMD_RET_USAGE;
	73	}
	74	} else {
	75	var = argv[i];
	76	break;
	77	}
	78	}
	79
	80	/* Loops should have been exited at the last argument, which
	81	* as it contained the variable */
	82	if (argc != i + 1)
	83	return CMD_RET_USAGE;
	84	}
	85
ebac37cf	86	ret = blk_get_device_by_str(argv[0], argv[1], &desc);
5cf41dcc SW	87	if (ret < 0)
	88	return 1;
	89
0798d6fd	90	if (var != NULL) {
e86df6ef	91	int p;
bc314f8e	92	char str[3 * MAX_SEARCH_PARTITIONS] = { '\0', };
0528979f	93	struct disk_partition info;
e86df6ef	94
bc314f8e	95	for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
0798d6fd	96	char t[5];
3e8bd469	97	int r = part_get_info(desc, p, &info);
e86df6ef	98
0798d6fd SS	99	if (r != 0)
	100	continue;
	101
	102	if (bootable && !info.bootable)
	103	continue;
	104
653447b4	105	sprintf(t, "%s%x", str[0] ? " " : "", p);
0798d6fd	106	strcat(str, t);
e86df6ef	107	}
382bee57	108	env_set(var, str);
e86df6ef SS	109	return 0;
	110	}
	111
3e8bd469	112	part_print(desc);
5cf41dcc SW	113
	114	return 0;
	115	}
	116
09140113	117	static int do_part_info(int argc, char *const argv[], enum cmd_part_info param)
8607c4f1	118	{
4101f687	119	struct blk_desc *desc;
0528979f	120	struct disk_partition info;
8607c4f1	121	char buf[512] = { 0 };
36df616a	122	char *endp;
8607c4f1 PK	123	int part;
	124	int err;
	125	int ret;
	126
	127	if (argc < 3)
	128	return CMD_RET_USAGE;
	129	if (argc > 4)
	130	return CMD_RET_USAGE;
	131
ebac37cf	132	ret = blk_get_device_by_str(argv[0], argv[1], &desc);
8607c4f1 PK	133	if (ret < 0)
	134	return 1;
	135
36df616a SP	136	part = simple_strtoul(argv[2], &endp, 0);
	137	if (*endp == '\0') {
	138	err = part_get_info(desc, part, &info);
	139	if (err)
	140	return 1;
	141	} else {
	142	part = part_get_info_by_name(desc, argv[2], &info);
7cb31e39	143	if (part < 0)
36df616a SP	144	return 1;
36df616a SP	145	}
8607c4f1	146
64e6a49a SP	147	switch (param) {
	148	case CMD_PART_INFO_START:
	149	snprintf(buf, sizeof(buf), LBAF, info.start);
	150	break;
	151	case CMD_PART_INFO_SIZE:
	152	snprintf(buf, sizeof(buf), LBAF, info.size);
	153	break;
be683756	154	case CMD_PART_INFO_NUMBER:
400b9554	155	snprintf(buf, sizeof(buf), "0x%x", part);
be683756	156	break;
64e6a49a SP	157	default:
	158	printf("** Unknown cmd_part_info value: %d\n", param);
	159	return 1;
	160	}
8607c4f1 PK	161
8607c4f1 PK	162	if (argc > 3)
382bee57	163	env_set(argv[3], buf);
8607c4f1 PK	164	else
	165	printf("%s\n", buf);
	166
	167	return 0;
	168	}
	169
09140113	170	static int do_part_start(int argc, char *const argv[])
8607c4f1	171	{
64e6a49a SP	172	return do_part_info(argc, argv, CMD_PART_INFO_START);
64e6a49a SP	173	}
8607c4f1	174
09140113	175	static int do_part_size(int argc, char *const argv[])
64e6a49a SP	176	{
64e6a49a SP	177	return do_part_info(argc, argv, CMD_PART_INFO_SIZE);
8607c4f1 PK	178	}
8607c4f1 PK	179
09140113	180	static int do_part_number(int argc, char *const argv[])
be683756 RT	181	{
	182	return do_part_info(argc, argv, CMD_PART_INFO_NUMBER);
	183	}
	184
125194e6 SG	185	static int do_part_set(int argc, char *const argv[])
	186	{
	187	const char devname, partstr, *typestr;
	188	struct blk_desc *desc;
	189	int dev;
	190
	191	if (argc < 3)
	192	return CMD_RET_USAGE;
	193
	194	/* Look up the device */
	195	devname = argv[0];
	196	partstr = argv[1];
	197	typestr = argv[2];
	198	dev = blk_get_device_by_str(devname, partstr, &desc);
	199	if (dev < 0) {
	200	printf(" Bad device specification %s %s \n", devname,
	201	partstr);
	202	return CMD_RET_FAILURE;
	203	}
	204
	205	desc->part_type = part_get_type_by_name(typestr);
	206	if (!desc->part_type) {
	207	printf("Unknown partition type '%s'\n", typestr);
	208	return CMD_RET_FAILURE;
	209	}
	210	part_print(desc);
	211
	212	return 0;
	213	}
	214
22e7f1d1 EBS	215	#ifdef CONFIG_PARTITION_TYPE_GUID
	216	static int do_part_type(int argc, char *const argv[])
	217	{
	218	int part;
	219	struct blk_desc *dev_desc;
	220	struct disk_partition info;
	221
	222	if (argc < 2)
	223	return CMD_RET_USAGE;
	224	if (argc > 3)
	225	return CMD_RET_USAGE;
	226
	227	part = blk_get_device_part_str(argv[0], argv[1], &dev_desc, &info, 0);
	228	if (part < 0)
	229	return 1;
	230
	231	if (argc > 2)
	232	env_set(argv[2], info.type_guid);
	233	else
	234	printf("%s\n", info.type_guid);
	235
	236	return 0;
	237	}
	238	#endif
	239
0ffdfbd1 NF	240	static int do_part_types(int argc, char * const argv[])
	241	{
	242	struct part_driver *drv = ll_entry_start(struct part_driver,
	243	part_driver);
	244	const int n_ents = ll_entry_count(struct part_driver, part_driver);
	245	struct part_driver *entry;
	246	int i = 0;
	247
	248	puts("Supported partition tables");
	249
	250	for (entry = drv; entry != drv + n_ents; entry++) {
	251	printf("%c %s", i ? ',' : ':', entry->name);
	252	i++;
	253	}
	254	if (!i)
	255	puts(": <none>");
	256	puts("\n");
	257	return CMD_RET_SUCCESS;
	258	}
	259
09140113 SG	260	static int do_part(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	261	char *const argv[])
5cf41dcc SW	262	{
	263	if (argc < 2)
	264	return CMD_RET_USAGE;
	265
	266	if (!strcmp(argv[1], "uuid"))
	267	return do_part_uuid(argc - 2, argv + 2);
	268	else if (!strcmp(argv[1], "list"))
	269	return do_part_list(argc - 2, argv + 2);
8607c4f1 PK	270	else if (!strcmp(argv[1], "start"))
	271	return do_part_start(argc - 2, argv + 2);
	272	else if (!strcmp(argv[1], "size"))
	273	return do_part_size(argc - 2, argv + 2);
be683756 RT	274	else if (!strcmp(argv[1], "number"))
be683756 RT	275	return do_part_number(argc - 2, argv + 2);
0ffdfbd1 NF	276	else if (!strcmp(argv[1], "types"))
0ffdfbd1 NF	277	return do_part_types(argc - 2, argv + 2);
125194e6 SG	278	else if (!strcmp(argv[1], "set"))
125194e6 SG	279	return do_part_set(argc - 2, argv + 2);
22e7f1d1 EBS	280	#ifdef CONFIG_PARTITION_TYPE_GUID
	281	else if (!strcmp(argv[1], "type"))
	282	return do_part_type(argc - 2, argv + 2);
	283	#endif
5cf41dcc SW	284	return CMD_RET_USAGE;
	285	}
	286
	287	U_BOOT_CMD(
0798d6fd	288	part, CONFIG_SYS_MAXARGS, 1, do_part,
5cf41dcc	289	"disk partition related commands",
8ca584ec	290	"uuid <interface> <dev>:<part>\n"
5cf41dcc SW	291	" - print partition UUID\n"
	292	"part uuid <interface> <dev>:<part> <varname>\n"
	293	" - set environment variable to partition UUID\n"
	294	"part list <interface> <dev>\n"
e86df6ef	295	" - print a device's partition table\n"
0798d6fd SS	296	"part list <interface> <dev> [flags] <varname>\n"
0798d6fd SS	297	" - set environment variable to the list of partitions\n"
8607c4f1 PK	298	" flags can be -bootable (list only bootable partitions)\n"
	299	"part start <interface> <dev> <part> <varname>\n"
	300	" - set environment variable to the start of the partition (in blocks)\n"
36df616a	301	" part can be either partition number or partition name\n"
8607c4f1	302	"part size <interface> <dev> <part> <varname>\n"
36df616a	303	" - set environment variable to the size of the partition (in blocks)\n"
be683756 RT	304	" part can be either partition number or partition name\n"
	305	"part number <interface> <dev> <part> <varname>\n"
	306	" - set environment variable to the partition number using the partition name\n"
0ffdfbd1	307	" part must be specified as partition name\n"
22e7f1d1 EBS	308	#ifdef CONFIG_PARTITION_TYPE_GUID
	309	"part type <interface> <dev>:<part>\n"
	310	" - print partition type\n"
22e7f1d1 EBS	311	"part type <interface> <dev>:<part> <varname>\n"
22e7f1d1 EBS	312	" - set environment variable to partition type\n"
97135d9f	313	#endif
125194e6 SG	314	"part set <interface> <dev> type\n"
125194e6 SG	315	" - set partition type for a device\n"
0ffdfbd1 NF	316	"part types\n"
0ffdfbd1 NF	317	" - list supported partition table types"
5cf41dcc	318	);