1*83d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
22e192b24SSimon Glass /*
32e192b24SSimon Glass * cmd_gpt.c -- GPT (GUID Partition Table) handling command
42e192b24SSimon Glass *
52e192b24SSimon Glass * Copyright (C) 2015
62e192b24SSimon Glass * Lukasz Majewski <l.majewski@majess.pl>
72e192b24SSimon Glass *
82e192b24SSimon Glass * Copyright (C) 2012 Samsung Electronics
92e192b24SSimon Glass * author: Lukasz Majewski <l.majewski@samsung.com>
102e192b24SSimon Glass * author: Piotr Wilczek <p.wilczek@samsung.com>
112e192b24SSimon Glass */
122e192b24SSimon Glass
132e192b24SSimon Glass #include <common.h>
142e192b24SSimon Glass #include <malloc.h>
152e192b24SSimon Glass #include <command.h>
162e192b24SSimon Glass #include <part_efi.h>
172e192b24SSimon Glass #include <exports.h>
182e192b24SSimon Glass #include <linux/ctype.h>
192e192b24SSimon Glass #include <div64.h>
202e192b24SSimon Glass #include <memalign.h>
2109a49930SAlison Chaiken #include <linux/compat.h>
22203f9b48SAlison Chaiken #include <linux/sizes.h>
23203f9b48SAlison Chaiken #include <stdlib.h>
2409a49930SAlison Chaiken
2509a49930SAlison Chaiken static LIST_HEAD(disk_partitions);
262e192b24SSimon Glass
272e192b24SSimon Glass /**
282e192b24SSimon Glass * extract_env(): Expand env name from string format '&{env_name}'
292e192b24SSimon Glass * and return pointer to the env (if the env is set)
302e192b24SSimon Glass *
312e192b24SSimon Glass * @param str - pointer to string
322e192b24SSimon Glass * @param env - pointer to pointer to extracted env
332e192b24SSimon Glass *
342e192b24SSimon Glass * @return - zero on successful expand and env is set
352e192b24SSimon Glass */
extract_env(const char * str,char ** env)362e192b24SSimon Glass static int extract_env(const char *str, char **env)
372e192b24SSimon Glass {
382e192b24SSimon Glass int ret = -1;
392e192b24SSimon Glass char *e, *s;
402e192b24SSimon Glass #ifdef CONFIG_RANDOM_UUID
412e192b24SSimon Glass char uuid_str[UUID_STR_LEN + 1];
422e192b24SSimon Glass #endif
432e192b24SSimon Glass
442e192b24SSimon Glass if (!str || strlen(str) < 4)
452e192b24SSimon Glass return -1;
462e192b24SSimon Glass
472e192b24SSimon Glass if (!((strncmp(str, "${", 2) == 0) && (str[strlen(str) - 1] == '}')))
482e192b24SSimon Glass return -1;
492e192b24SSimon Glass
502e192b24SSimon Glass s = strdup(str);
512e192b24SSimon Glass if (s == NULL)
522e192b24SSimon Glass return -1;
532e192b24SSimon Glass
542e192b24SSimon Glass memset(s + strlen(s) - 1, '\0', 1);
552e192b24SSimon Glass memmove(s, s + 2, strlen(s) - 1);
562e192b24SSimon Glass
5700caae6dSSimon Glass e = env_get(s);
582e192b24SSimon Glass if (e == NULL) {
592e192b24SSimon Glass #ifdef CONFIG_RANDOM_UUID
602e192b24SSimon Glass debug("%s unset. ", str);
619da52f8fSVincent Tinelli gen_rand_uuid_str(uuid_str, UUID_STR_FORMAT_GUID);
62382bee57SSimon Glass env_set(s, uuid_str);
632e192b24SSimon Glass
6400caae6dSSimon Glass e = env_get(s);
652e192b24SSimon Glass if (e) {
662e192b24SSimon Glass debug("Set to random.\n");
672e192b24SSimon Glass ret = 0;
682e192b24SSimon Glass } else {
692e192b24SSimon Glass debug("Can't get random UUID.\n");
702e192b24SSimon Glass }
712e192b24SSimon Glass #else
722e192b24SSimon Glass debug("%s unset.\n", str);
732e192b24SSimon Glass #endif
742e192b24SSimon Glass } else {
752e192b24SSimon Glass debug("%s get from environment.\n", str);
762e192b24SSimon Glass ret = 0;
772e192b24SSimon Glass }
782e192b24SSimon Glass
792e192b24SSimon Glass *env = e;
802e192b24SSimon Glass free(s);
812e192b24SSimon Glass
822e192b24SSimon Glass return ret;
832e192b24SSimon Glass }
842e192b24SSimon Glass
852e192b24SSimon Glass /**
862e192b24SSimon Glass * extract_val(): Extract value from a key=value pair list (comma separated).
872e192b24SSimon Glass * Only value for the given key is returend.
882e192b24SSimon Glass * Function allocates memory for the value, remember to free!
892e192b24SSimon Glass *
902e192b24SSimon Glass * @param str - pointer to string with key=values pairs
912e192b24SSimon Glass * @param key - pointer to the key to search for
922e192b24SSimon Glass *
932e192b24SSimon Glass * @return - pointer to allocated string with the value
942e192b24SSimon Glass */
extract_val(const char * str,const char * key)952e192b24SSimon Glass static char *extract_val(const char *str, const char *key)
962e192b24SSimon Glass {
972e192b24SSimon Glass char *v, *k;
982e192b24SSimon Glass char *s, *strcopy;
992e192b24SSimon Glass char *new = NULL;
1002e192b24SSimon Glass
1012e192b24SSimon Glass strcopy = strdup(str);
1022e192b24SSimon Glass if (strcopy == NULL)
1032e192b24SSimon Glass return NULL;
1042e192b24SSimon Glass
1052e192b24SSimon Glass s = strcopy;
1062e192b24SSimon Glass while (s) {
1072e192b24SSimon Glass v = strsep(&s, ",");
1082e192b24SSimon Glass if (!v)
1092e192b24SSimon Glass break;
1102e192b24SSimon Glass k = strsep(&v, "=");
1112e192b24SSimon Glass if (!k)
1122e192b24SSimon Glass break;
1132e192b24SSimon Glass if (strcmp(k, key) == 0) {
1142e192b24SSimon Glass new = strdup(v);
1152e192b24SSimon Glass break;
1162e192b24SSimon Glass }
1172e192b24SSimon Glass }
1182e192b24SSimon Glass
1192e192b24SSimon Glass free(strcopy);
1202e192b24SSimon Glass
1212e192b24SSimon Glass return new;
1222e192b24SSimon Glass }
1232e192b24SSimon Glass
1242e192b24SSimon Glass /**
1252e192b24SSimon Glass * found_key(): Found key without value in parameter list (comma separated).
1262e192b24SSimon Glass *
1272e192b24SSimon Glass * @param str - pointer to string with key
1282e192b24SSimon Glass * @param key - pointer to the key to search for
1292e192b24SSimon Glass *
1302e192b24SSimon Glass * @return - true on found key
1312e192b24SSimon Glass */
found_key(const char * str,const char * key)1322e192b24SSimon Glass static bool found_key(const char *str, const char *key)
1332e192b24SSimon Glass {
1342e192b24SSimon Glass char *k;
1352e192b24SSimon Glass char *s, *strcopy;
1362e192b24SSimon Glass bool result = false;
1372e192b24SSimon Glass
1382e192b24SSimon Glass strcopy = strdup(str);
1392e192b24SSimon Glass if (!strcopy)
1402e192b24SSimon Glass return NULL;
1412e192b24SSimon Glass
1422e192b24SSimon Glass s = strcopy;
1432e192b24SSimon Glass while (s) {
1442e192b24SSimon Glass k = strsep(&s, ",");
1452e192b24SSimon Glass if (!k)
1462e192b24SSimon Glass break;
1472e192b24SSimon Glass if (strcmp(k, key) == 0) {
1482e192b24SSimon Glass result = true;
1492e192b24SSimon Glass break;
1502e192b24SSimon Glass }
1512e192b24SSimon Glass }
1522e192b24SSimon Glass
1532e192b24SSimon Glass free(strcopy);
1542e192b24SSimon Glass
1552e192b24SSimon Glass return result;
1562e192b24SSimon Glass }
1572e192b24SSimon Glass
calc_parts_list_len(int numparts)1582fcaa413SAlison Chaiken static int calc_parts_list_len(int numparts)
1592fcaa413SAlison Chaiken {
1602fcaa413SAlison Chaiken int partlistlen = UUID_STR_LEN + 1 + strlen("uuid_disk=");
1612fcaa413SAlison Chaiken /* for the comma */
1622fcaa413SAlison Chaiken partlistlen++;
1632fcaa413SAlison Chaiken
1642fcaa413SAlison Chaiken /* per-partition additions; numparts starts at 1, so this should be correct */
1652fcaa413SAlison Chaiken partlistlen += numparts * (strlen("name=,") + PART_NAME_LEN + 1);
1662fcaa413SAlison Chaiken /* see part.h for definition of struct disk_partition */
1672fcaa413SAlison Chaiken partlistlen += numparts * (strlen("start=MiB,") + sizeof(lbaint_t) + 1);
1682fcaa413SAlison Chaiken partlistlen += numparts * (strlen("size=MiB,") + sizeof(lbaint_t) + 1);
1692fcaa413SAlison Chaiken partlistlen += numparts * (strlen("uuid=;") + UUID_STR_LEN + 1);
1702fcaa413SAlison Chaiken /* for the terminating null */
1712fcaa413SAlison Chaiken partlistlen++;
1722fcaa413SAlison Chaiken debug("Length of partitions_list is %d for %d partitions\n", partlistlen,
1732fcaa413SAlison Chaiken numparts);
1742fcaa413SAlison Chaiken return partlistlen;
1752fcaa413SAlison Chaiken }
1762fcaa413SAlison Chaiken
17709a49930SAlison Chaiken #ifdef CONFIG_CMD_GPT_RENAME
del_gpt_info(void)17809a49930SAlison Chaiken static void del_gpt_info(void)
17909a49930SAlison Chaiken {
18009a49930SAlison Chaiken struct list_head *pos = &disk_partitions;
18109a49930SAlison Chaiken struct disk_part *curr;
18209a49930SAlison Chaiken while (!list_empty(pos)) {
18309a49930SAlison Chaiken curr = list_entry(pos->next, struct disk_part, list);
18409a49930SAlison Chaiken list_del(pos->next);
18509a49930SAlison Chaiken free(curr);
18609a49930SAlison Chaiken }
18709a49930SAlison Chaiken }
18809a49930SAlison Chaiken
allocate_disk_part(disk_partition_t * info,int partnum)18909a49930SAlison Chaiken static struct disk_part *allocate_disk_part(disk_partition_t *info, int partnum)
19009a49930SAlison Chaiken {
19109a49930SAlison Chaiken struct disk_part *newpart;
192f66bc0e0SHeinrich Schuchardt newpart = calloc(1, sizeof(struct disk_part));
19309a49930SAlison Chaiken if (!newpart)
19409a49930SAlison Chaiken return ERR_PTR(-ENOMEM);
19509a49930SAlison Chaiken
19609a49930SAlison Chaiken newpart->gpt_part_info.start = info->start;
19709a49930SAlison Chaiken newpart->gpt_part_info.size = info->size;
19809a49930SAlison Chaiken newpart->gpt_part_info.blksz = info->blksz;
19909a49930SAlison Chaiken strncpy((char *)newpart->gpt_part_info.name, (const char *)info->name,
20009a49930SAlison Chaiken PART_NAME_LEN);
20109a49930SAlison Chaiken newpart->gpt_part_info.name[PART_NAME_LEN - 1] = '\0';
20209a49930SAlison Chaiken strncpy((char *)newpart->gpt_part_info.type, (const char *)info->type,
20309a49930SAlison Chaiken PART_TYPE_LEN);
20409a49930SAlison Chaiken newpart->gpt_part_info.type[PART_TYPE_LEN - 1] = '\0';
20509a49930SAlison Chaiken newpart->gpt_part_info.bootable = info->bootable;
20609a49930SAlison Chaiken #ifdef CONFIG_PARTITION_UUIDS
20709a49930SAlison Chaiken strncpy(newpart->gpt_part_info.uuid, (const char *)info->uuid,
20809a49930SAlison Chaiken UUID_STR_LEN);
20909a49930SAlison Chaiken /* UUID_STR_LEN is correct, as uuid[]'s length is UUID_STR_LEN+1 chars */
21009a49930SAlison Chaiken newpart->gpt_part_info.uuid[UUID_STR_LEN] = '\0';
21109a49930SAlison Chaiken #endif
21209a49930SAlison Chaiken newpart->partnum = partnum;
21309a49930SAlison Chaiken
21409a49930SAlison Chaiken return newpart;
21509a49930SAlison Chaiken }
21609a49930SAlison Chaiken
prettyprint_part_size(char * sizestr,lbaint_t partsize,lbaint_t blksize)217203f9b48SAlison Chaiken static void prettyprint_part_size(char *sizestr, lbaint_t partsize,
218203f9b48SAlison Chaiken lbaint_t blksize)
219203f9b48SAlison Chaiken {
220203f9b48SAlison Chaiken unsigned long long partbytes, partmegabytes;
221203f9b48SAlison Chaiken
222203f9b48SAlison Chaiken partbytes = partsize * blksize;
223203f9b48SAlison Chaiken partmegabytes = lldiv(partbytes, SZ_1M);
224203f9b48SAlison Chaiken snprintf(sizestr, 16, "%lluMiB", partmegabytes);
225203f9b48SAlison Chaiken }
226203f9b48SAlison Chaiken
print_gpt_info(void)22709a49930SAlison Chaiken static void print_gpt_info(void)
22809a49930SAlison Chaiken {
22909a49930SAlison Chaiken struct list_head *pos;
23009a49930SAlison Chaiken struct disk_part *curr;
231203f9b48SAlison Chaiken char partstartstr[16];
232203f9b48SAlison Chaiken char partsizestr[16];
23309a49930SAlison Chaiken
23409a49930SAlison Chaiken list_for_each(pos, &disk_partitions) {
23509a49930SAlison Chaiken curr = list_entry(pos, struct disk_part, list);
236203f9b48SAlison Chaiken prettyprint_part_size(partstartstr, curr->gpt_part_info.start,
237203f9b48SAlison Chaiken curr->gpt_part_info.blksz);
238203f9b48SAlison Chaiken prettyprint_part_size(partsizestr, curr->gpt_part_info.size,
239203f9b48SAlison Chaiken curr->gpt_part_info.blksz);
240203f9b48SAlison Chaiken
24109a49930SAlison Chaiken printf("Partition %d:\n", curr->partnum);
242203f9b48SAlison Chaiken printf("Start %s, size %s\n", partstartstr, partsizestr);
24309a49930SAlison Chaiken printf("Block size %lu, name %s\n", curr->gpt_part_info.blksz,
24409a49930SAlison Chaiken curr->gpt_part_info.name);
24509a49930SAlison Chaiken printf("Type %s, bootable %d\n", curr->gpt_part_info.type,
24609a49930SAlison Chaiken curr->gpt_part_info.bootable);
24709a49930SAlison Chaiken #ifdef CONFIG_PARTITION_UUIDS
24809a49930SAlison Chaiken printf("UUID %s\n", curr->gpt_part_info.uuid);
24909a49930SAlison Chaiken #endif
25009a49930SAlison Chaiken printf("\n");
25109a49930SAlison Chaiken }
25209a49930SAlison Chaiken }
25309a49930SAlison Chaiken
254203f9b48SAlison Chaiken /*
255203f9b48SAlison Chaiken * create the string that upstream 'gpt write' command will accept as an
256203f9b48SAlison Chaiken * argument
257203f9b48SAlison Chaiken *
258203f9b48SAlison Chaiken * From doc/README.gpt, Format of partitions layout:
259203f9b48SAlison Chaiken * "uuid_disk=...;name=u-boot,size=60MiB,uuid=...;
260203f9b48SAlison Chaiken * name=kernel,size=60MiB,uuid=...;"
261203f9b48SAlison Chaiken * The fields 'name' and 'size' are mandatory for every partition.
262203f9b48SAlison Chaiken * The field 'start' is optional. The fields 'uuid' and 'uuid_disk'
263203f9b48SAlison Chaiken * are optional if CONFIG_RANDOM_UUID is enabled.
264203f9b48SAlison Chaiken */
create_gpt_partitions_list(int numparts,const char * guid,char * partitions_list)265203f9b48SAlison Chaiken static int create_gpt_partitions_list(int numparts, const char *guid,
266203f9b48SAlison Chaiken char *partitions_list)
267203f9b48SAlison Chaiken {
268203f9b48SAlison Chaiken struct list_head *pos;
269203f9b48SAlison Chaiken struct disk_part *curr;
270203f9b48SAlison Chaiken char partstr[PART_NAME_LEN + 1];
271203f9b48SAlison Chaiken
272203f9b48SAlison Chaiken if (!partitions_list)
273203f9b48SAlison Chaiken return -EINVAL;
274203f9b48SAlison Chaiken
275203f9b48SAlison Chaiken strcpy(partitions_list, "uuid_disk=");
276203f9b48SAlison Chaiken strncat(partitions_list, guid, UUID_STR_LEN + 1);
277203f9b48SAlison Chaiken strcat(partitions_list, ";");
278203f9b48SAlison Chaiken
279203f9b48SAlison Chaiken list_for_each(pos, &disk_partitions) {
280203f9b48SAlison Chaiken curr = list_entry(pos, struct disk_part, list);
281203f9b48SAlison Chaiken strcat(partitions_list, "name=");
282203f9b48SAlison Chaiken strncat(partitions_list, (const char *)curr->gpt_part_info.name,
283203f9b48SAlison Chaiken PART_NAME_LEN + 1);
2843a2605faSPatrick Delaunay sprintf(partstr, ",start=0x%llx",
2853a2605faSPatrick Delaunay (unsigned long long)curr->gpt_part_info.start *
2863a2605faSPatrick Delaunay curr->gpt_part_info.blksz);
287203f9b48SAlison Chaiken /* one extra byte for NULL */
288203f9b48SAlison Chaiken strncat(partitions_list, partstr, PART_NAME_LEN + 1);
2893a2605faSPatrick Delaunay sprintf(partstr, ",size=0x%llx",
2903a2605faSPatrick Delaunay (unsigned long long)curr->gpt_part_info.size *
291203f9b48SAlison Chaiken curr->gpt_part_info.blksz);
292203f9b48SAlison Chaiken strncat(partitions_list, partstr, PART_NAME_LEN + 1);
293203f9b48SAlison Chaiken
294203f9b48SAlison Chaiken strcat(partitions_list, ",uuid=");
295203f9b48SAlison Chaiken strncat(partitions_list, curr->gpt_part_info.uuid,
296203f9b48SAlison Chaiken UUID_STR_LEN + 1);
297203f9b48SAlison Chaiken strcat(partitions_list, ";");
298203f9b48SAlison Chaiken }
299203f9b48SAlison Chaiken return 0;
300203f9b48SAlison Chaiken }
301203f9b48SAlison Chaiken
30209a49930SAlison Chaiken /*
30309a49930SAlison Chaiken * read partition info into disk_partitions list where
30409a49930SAlison Chaiken * it can be printed or modified
30509a49930SAlison Chaiken */
get_gpt_info(struct blk_desc * dev_desc)30609a49930SAlison Chaiken static int get_gpt_info(struct blk_desc *dev_desc)
30709a49930SAlison Chaiken {
30809a49930SAlison Chaiken /* start partition numbering at 1, as U-Boot does */
30909a49930SAlison Chaiken int valid_parts = 0, p, ret;
31009a49930SAlison Chaiken disk_partition_t info;
31109a49930SAlison Chaiken struct disk_part *new_disk_part;
31209a49930SAlison Chaiken
313203f9b48SAlison Chaiken /*
314203f9b48SAlison Chaiken * Always re-read partition info from device, in case
315203f9b48SAlison Chaiken * it has changed
316203f9b48SAlison Chaiken */
31709a49930SAlison Chaiken INIT_LIST_HEAD(&disk_partitions);
31809a49930SAlison Chaiken
31909a49930SAlison Chaiken for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
32009a49930SAlison Chaiken ret = part_get_info(dev_desc, p, &info);
32109a49930SAlison Chaiken if (ret)
32209a49930SAlison Chaiken continue;
32309a49930SAlison Chaiken
32409a49930SAlison Chaiken /* Add 1 here because counter is zero-based but p1 is
32509a49930SAlison Chaiken the first partition */
32609a49930SAlison Chaiken new_disk_part = allocate_disk_part(&info, valid_parts+1);
32709a49930SAlison Chaiken if (IS_ERR(new_disk_part))
32809a49930SAlison Chaiken goto out;
32909a49930SAlison Chaiken
33009a49930SAlison Chaiken list_add_tail(&new_disk_part->list, &disk_partitions);
33109a49930SAlison Chaiken valid_parts++;
33209a49930SAlison Chaiken }
33309a49930SAlison Chaiken if (valid_parts == 0) {
33409a49930SAlison Chaiken printf("** No valid partitions found **\n");
33509a49930SAlison Chaiken goto out;
33609a49930SAlison Chaiken }
33709a49930SAlison Chaiken return valid_parts;
33809a49930SAlison Chaiken out:
33909a49930SAlison Chaiken if (valid_parts >= 1)
34009a49930SAlison Chaiken del_gpt_info();
34109a49930SAlison Chaiken return -ENODEV;
34209a49930SAlison Chaiken }
34309a49930SAlison Chaiken
34409a49930SAlison Chaiken /* a wrapper to test get_gpt_info */
do_get_gpt_info(struct blk_desc * dev_desc)34509a49930SAlison Chaiken static int do_get_gpt_info(struct blk_desc *dev_desc)
34609a49930SAlison Chaiken {
34709a49930SAlison Chaiken int ret;
34809a49930SAlison Chaiken
34909a49930SAlison Chaiken ret = get_gpt_info(dev_desc);
35009a49930SAlison Chaiken if (ret > 0) {
35109a49930SAlison Chaiken print_gpt_info();
35209a49930SAlison Chaiken del_gpt_info();
35309a49930SAlison Chaiken return 0;
35409a49930SAlison Chaiken }
35509a49930SAlison Chaiken return ret;
35609a49930SAlison Chaiken }
35709a49930SAlison Chaiken #endif
35809a49930SAlison Chaiken
3592e192b24SSimon Glass /**
3602e192b24SSimon Glass * set_gpt_info(): Fill partition information from string
3612e192b24SSimon Glass * function allocates memory, remember to free!
3622e192b24SSimon Glass *
3632e192b24SSimon Glass * @param dev_desc - pointer block device descriptor
3642e192b24SSimon Glass * @param str_part - pointer to string with partition information
3652e192b24SSimon Glass * @param str_disk_guid - pointer to pointer to allocated string with disk guid
3662e192b24SSimon Glass * @param partitions - pointer to pointer to allocated partitions array
3672e192b24SSimon Glass * @param parts_count - number of partitions
3682e192b24SSimon Glass *
3692e192b24SSimon Glass * @return - zero on success, otherwise error
3702e192b24SSimon Glass *
3712e192b24SSimon Glass */
set_gpt_info(struct blk_desc * dev_desc,const char * str_part,char ** str_disk_guid,disk_partition_t ** partitions,u8 * parts_count)3724101f687SSimon Glass static int set_gpt_info(struct blk_desc *dev_desc,
3732e192b24SSimon Glass const char *str_part,
3742e192b24SSimon Glass char **str_disk_guid,
3752e192b24SSimon Glass disk_partition_t **partitions,
3762e192b24SSimon Glass u8 *parts_count)
3772e192b24SSimon Glass {
3782e192b24SSimon Glass char *tok, *str, *s;
3792e192b24SSimon Glass int i;
3802e192b24SSimon Glass char *val, *p;
3812e192b24SSimon Glass int p_count;
3822e192b24SSimon Glass disk_partition_t *parts;
3832e192b24SSimon Glass int errno = 0;
3842e192b24SSimon Glass uint64_t size_ll, start_ll;
38566636235SMichael Trimarchi lbaint_t offset = 0;
3862fcaa413SAlison Chaiken int max_str_part = calc_parts_list_len(MAX_SEARCH_PARTITIONS);
3872e192b24SSimon Glass
3882e192b24SSimon Glass debug("%s: lba num: 0x%x %d\n", __func__,
3892e192b24SSimon Glass (unsigned int)dev_desc->lba, (unsigned int)dev_desc->lba);
3902e192b24SSimon Glass
3912e192b24SSimon Glass if (str_part == NULL)
3922e192b24SSimon Glass return -1;
3932e192b24SSimon Glass
3942e192b24SSimon Glass str = strdup(str_part);
395203f9b48SAlison Chaiken if (str == NULL)
396203f9b48SAlison Chaiken return -ENOMEM;
3972e192b24SSimon Glass
3982e192b24SSimon Glass /* extract disk guid */
3992e192b24SSimon Glass s = str;
4002e192b24SSimon Glass val = extract_val(str, "uuid_disk");
4012e192b24SSimon Glass if (!val) {
4022e192b24SSimon Glass #ifdef CONFIG_RANDOM_UUID
4032e192b24SSimon Glass *str_disk_guid = malloc(UUID_STR_LEN + 1);
404bf52fcdeSTom Rini if (*str_disk_guid == NULL)
4052fcaa413SAlison Chaiken return -ENOMEM;
4062e192b24SSimon Glass gen_rand_uuid_str(*str_disk_guid, UUID_STR_FORMAT_STD);
4072e192b24SSimon Glass #else
4082e192b24SSimon Glass free(str);
4092e192b24SSimon Glass return -2;
4102e192b24SSimon Glass #endif
4112e192b24SSimon Glass } else {
4122e192b24SSimon Glass val = strsep(&val, ";");
4132e192b24SSimon Glass if (extract_env(val, &p))
4142e192b24SSimon Glass p = val;
4152e192b24SSimon Glass *str_disk_guid = strdup(p);
4162e192b24SSimon Glass free(val);
4172e192b24SSimon Glass /* Move s to first partition */
4182e192b24SSimon Glass strsep(&s, ";");
4192e192b24SSimon Glass }
4202fcaa413SAlison Chaiken if (s == NULL) {
4212fcaa413SAlison Chaiken printf("Error: is the partitions string NULL-terminated?\n");
4222fcaa413SAlison Chaiken return -EINVAL;
4232fcaa413SAlison Chaiken }
4242fcaa413SAlison Chaiken if (strnlen(s, max_str_part) == 0)
4252e192b24SSimon Glass return -3;
4262e192b24SSimon Glass
4272fcaa413SAlison Chaiken i = strnlen(s, max_str_part) - 1;
4282e192b24SSimon Glass if (s[i] == ';')
4292e192b24SSimon Glass s[i] = '\0';
4302e192b24SSimon Glass
4312e192b24SSimon Glass /* calculate expected number of partitions */
4322e192b24SSimon Glass p_count = 1;
4332e192b24SSimon Glass p = s;
4342e192b24SSimon Glass while (*p) {
4352e192b24SSimon Glass if (*p++ == ';')
4362e192b24SSimon Glass p_count++;
4372e192b24SSimon Glass }
4382e192b24SSimon Glass
4392e192b24SSimon Glass /* allocate memory for partitions */
4402e192b24SSimon Glass parts = calloc(sizeof(disk_partition_t), p_count);
4412fcaa413SAlison Chaiken if (parts == NULL)
4422fcaa413SAlison Chaiken return -ENOMEM;
4432e192b24SSimon Glass
4442e192b24SSimon Glass /* retrieve partitions data from string */
4452e192b24SSimon Glass for (i = 0; i < p_count; i++) {
4462e192b24SSimon Glass tok = strsep(&s, ";");
4472e192b24SSimon Glass
4482e192b24SSimon Glass if (tok == NULL)
4492e192b24SSimon Glass break;
4502e192b24SSimon Glass
4512e192b24SSimon Glass /* uuid */
4522e192b24SSimon Glass val = extract_val(tok, "uuid");
4532e192b24SSimon Glass if (!val) {
4542e192b24SSimon Glass /* 'uuid' is optional if random uuid's are enabled */
4552e192b24SSimon Glass #ifdef CONFIG_RANDOM_UUID
4562e192b24SSimon Glass gen_rand_uuid_str(parts[i].uuid, UUID_STR_FORMAT_STD);
4572e192b24SSimon Glass #else
4582e192b24SSimon Glass errno = -4;
4592e192b24SSimon Glass goto err;
4602e192b24SSimon Glass #endif
4612e192b24SSimon Glass } else {
4622e192b24SSimon Glass if (extract_env(val, &p))
4632e192b24SSimon Glass p = val;
4642fcaa413SAlison Chaiken if (strnlen(p, max_str_part) >= sizeof(parts[i].uuid)) {
4652e192b24SSimon Glass printf("Wrong uuid format for partition %d\n", i);
4662e192b24SSimon Glass errno = -4;
4672e192b24SSimon Glass goto err;
4682e192b24SSimon Glass }
4692fcaa413SAlison Chaiken strncpy((char *)parts[i].uuid, p, max_str_part);
4702e192b24SSimon Glass free(val);
4712e192b24SSimon Glass }
4722e192b24SSimon Glass #ifdef CONFIG_PARTITION_TYPE_GUID
4732e192b24SSimon Glass /* guid */
4742e192b24SSimon Glass val = extract_val(tok, "type");
4752e192b24SSimon Glass if (val) {
4762e192b24SSimon Glass /* 'type' is optional */
4772e192b24SSimon Glass if (extract_env(val, &p))
4782e192b24SSimon Glass p = val;
4792fcaa413SAlison Chaiken if (strnlen(p, max_str_part) >= sizeof(parts[i].type_guid)) {
4802e192b24SSimon Glass printf("Wrong type guid format for partition %d\n",
4812e192b24SSimon Glass i);
4822e192b24SSimon Glass errno = -4;
4832e192b24SSimon Glass goto err;
4842e192b24SSimon Glass }
4852fcaa413SAlison Chaiken strncpy((char *)parts[i].type_guid, p, max_str_part);
4862e192b24SSimon Glass free(val);
4872e192b24SSimon Glass }
4882e192b24SSimon Glass #endif
4892e192b24SSimon Glass /* name */
4902e192b24SSimon Glass val = extract_val(tok, "name");
4912e192b24SSimon Glass if (!val) { /* name is mandatory */
4922e192b24SSimon Glass errno = -4;
4932e192b24SSimon Glass goto err;
4942e192b24SSimon Glass }
4952e192b24SSimon Glass if (extract_env(val, &p))
4962e192b24SSimon Glass p = val;
4972fcaa413SAlison Chaiken if (strnlen(p, max_str_part) >= sizeof(parts[i].name)) {
4982e192b24SSimon Glass errno = -4;
4992e192b24SSimon Glass goto err;
5002e192b24SSimon Glass }
5012fcaa413SAlison Chaiken strncpy((char *)parts[i].name, p, max_str_part);
5022e192b24SSimon Glass free(val);
5032e192b24SSimon Glass
5042e192b24SSimon Glass /* size */
5052e192b24SSimon Glass val = extract_val(tok, "size");
5062e192b24SSimon Glass if (!val) { /* 'size' is mandatory */
5072e192b24SSimon Glass errno = -4;
5082e192b24SSimon Glass goto err;
5092e192b24SSimon Glass }
5102e192b24SSimon Glass if (extract_env(val, &p))
5112e192b24SSimon Glass p = val;
51266636235SMichael Trimarchi if ((strcmp(p, "-") == 0)) {
513c2fdd345SKever Yang /* Let part efi module to auto extend the size */
514c2fdd345SKever Yang parts[i].size = 0;
51566636235SMichael Trimarchi } else {
5162e192b24SSimon Glass size_ll = ustrtoull(p, &p, 0);
5172e192b24SSimon Glass parts[i].size = lldiv(size_ll, dev_desc->blksz);
51866636235SMichael Trimarchi }
51966636235SMichael Trimarchi
5202e192b24SSimon Glass free(val);
5212e192b24SSimon Glass
5222e192b24SSimon Glass /* start address */
5232e192b24SSimon Glass val = extract_val(tok, "start");
5242e192b24SSimon Glass if (val) { /* start address is optional */
5252e192b24SSimon Glass if (extract_env(val, &p))
5262e192b24SSimon Glass p = val;
5272e192b24SSimon Glass start_ll = ustrtoull(p, &p, 0);
5282e192b24SSimon Glass parts[i].start = lldiv(start_ll, dev_desc->blksz);
5292e192b24SSimon Glass free(val);
5302e192b24SSimon Glass }
5312e192b24SSimon Glass
53266636235SMichael Trimarchi offset += parts[i].size + parts[i].start;
53366636235SMichael Trimarchi
5342e192b24SSimon Glass /* bootable */
5352e192b24SSimon Glass if (found_key(tok, "bootable"))
5362e192b24SSimon Glass parts[i].bootable = 1;
5372e192b24SSimon Glass }
5382e192b24SSimon Glass
5392e192b24SSimon Glass *parts_count = p_count;
5402e192b24SSimon Glass *partitions = parts;
5412e192b24SSimon Glass free(str);
5422e192b24SSimon Glass
5432e192b24SSimon Glass return 0;
5442e192b24SSimon Glass err:
5452e192b24SSimon Glass free(str);
5462e192b24SSimon Glass free(*str_disk_guid);
5472e192b24SSimon Glass free(parts);
5482e192b24SSimon Glass
5492e192b24SSimon Glass return errno;
5502e192b24SSimon Glass }
5512e192b24SSimon Glass
gpt_default(struct blk_desc * blk_dev_desc,const char * str_part)5524101f687SSimon Glass static int gpt_default(struct blk_desc *blk_dev_desc, const char *str_part)
5532e192b24SSimon Glass {
5542e192b24SSimon Glass int ret;
5552e192b24SSimon Glass char *str_disk_guid;
5562e192b24SSimon Glass u8 part_count = 0;
5572e192b24SSimon Glass disk_partition_t *partitions = NULL;
5582e192b24SSimon Glass
5592e192b24SSimon Glass /* fill partitions */
5602e192b24SSimon Glass ret = set_gpt_info(blk_dev_desc, str_part,
5612e192b24SSimon Glass &str_disk_guid, &partitions, &part_count);
5622e192b24SSimon Glass if (ret) {
5632e192b24SSimon Glass if (ret == -1)
5642e192b24SSimon Glass printf("No partition list provided\n");
5652e192b24SSimon Glass if (ret == -2)
5662e192b24SSimon Glass printf("Missing disk guid\n");
5672e192b24SSimon Glass if ((ret == -3) || (ret == -4))
5682e192b24SSimon Glass printf("Partition list incomplete\n");
5692e192b24SSimon Glass return -1;
5702e192b24SSimon Glass }
5712e192b24SSimon Glass
5722e192b24SSimon Glass /* save partitions layout to disk */
5732e192b24SSimon Glass ret = gpt_restore(blk_dev_desc, str_disk_guid, partitions, part_count);
5742e192b24SSimon Glass free(str_disk_guid);
5752e192b24SSimon Glass free(partitions);
5762e192b24SSimon Glass
5772e192b24SSimon Glass return ret;
5782e192b24SSimon Glass }
5792e192b24SSimon Glass
gpt_verify(struct blk_desc * blk_dev_desc,const char * str_part)5804101f687SSimon Glass static int gpt_verify(struct blk_desc *blk_dev_desc, const char *str_part)
5812e192b24SSimon Glass {
5822e192b24SSimon Glass ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1,
5832e192b24SSimon Glass blk_dev_desc->blksz);
5842e192b24SSimon Glass disk_partition_t *partitions = NULL;
5852e192b24SSimon Glass gpt_entry *gpt_pte = NULL;
5862e192b24SSimon Glass char *str_disk_guid;
5872e192b24SSimon Glass u8 part_count = 0;
5882e192b24SSimon Glass int ret = 0;
5892e192b24SSimon Glass
5902e192b24SSimon Glass /* fill partitions */
5912e192b24SSimon Glass ret = set_gpt_info(blk_dev_desc, str_part,
5922e192b24SSimon Glass &str_disk_guid, &partitions, &part_count);
5932e192b24SSimon Glass if (ret) {
5942e192b24SSimon Glass if (ret == -1) {
5952e192b24SSimon Glass printf("No partition list provided - only basic check\n");
5962e192b24SSimon Glass ret = gpt_verify_headers(blk_dev_desc, gpt_head,
5972e192b24SSimon Glass &gpt_pte);
5982e192b24SSimon Glass goto out;
5992e192b24SSimon Glass }
6002e192b24SSimon Glass if (ret == -2)
6012e192b24SSimon Glass printf("Missing disk guid\n");
6022e192b24SSimon Glass if ((ret == -3) || (ret == -4))
6032e192b24SSimon Glass printf("Partition list incomplete\n");
6042e192b24SSimon Glass return -1;
6052e192b24SSimon Glass }
6062e192b24SSimon Glass
6072e192b24SSimon Glass /* Check partition layout with provided pattern */
6082e192b24SSimon Glass ret = gpt_verify_partitions(blk_dev_desc, partitions, part_count,
6092e192b24SSimon Glass gpt_head, &gpt_pte);
6102e192b24SSimon Glass free(str_disk_guid);
6112e192b24SSimon Glass free(partitions);
6122e192b24SSimon Glass out:
6132e192b24SSimon Glass free(gpt_pte);
6142e192b24SSimon Glass return ret;
6152e192b24SSimon Glass }
6162e192b24SSimon Glass
do_disk_guid(struct blk_desc * dev_desc,char * const namestr)61773d6d18bSAlison Chaiken static int do_disk_guid(struct blk_desc *dev_desc, char * const namestr)
61873d6d18bSAlison Chaiken {
61973d6d18bSAlison Chaiken int ret;
62073d6d18bSAlison Chaiken char disk_guid[UUID_STR_LEN + 1];
62173d6d18bSAlison Chaiken
62273d6d18bSAlison Chaiken ret = get_disk_guid(dev_desc, disk_guid);
62373d6d18bSAlison Chaiken if (ret < 0)
62473d6d18bSAlison Chaiken return CMD_RET_FAILURE;
62573d6d18bSAlison Chaiken
62673d6d18bSAlison Chaiken if (namestr)
627382bee57SSimon Glass env_set(namestr, disk_guid);
62873d6d18bSAlison Chaiken else
62973d6d18bSAlison Chaiken printf("%s\n", disk_guid);
63073d6d18bSAlison Chaiken
63173d6d18bSAlison Chaiken return ret;
63273d6d18bSAlison Chaiken }
63373d6d18bSAlison Chaiken
634203f9b48SAlison Chaiken #ifdef CONFIG_CMD_GPT_RENAME
63518030d04SAlison Chaiken /*
63618030d04SAlison Chaiken * There are 3 malloc() calls in set_gpt_info() and there is no info about which
63718030d04SAlison Chaiken * failed.
63818030d04SAlison Chaiken */
set_gpt_cleanup(char ** str_disk_guid,disk_partition_t ** partitions)63918030d04SAlison Chaiken static void set_gpt_cleanup(char **str_disk_guid,
64018030d04SAlison Chaiken disk_partition_t **partitions)
64118030d04SAlison Chaiken {
64218030d04SAlison Chaiken #ifdef CONFIG_RANDOM_UUID
64318030d04SAlison Chaiken if (str_disk_guid)
64418030d04SAlison Chaiken free(str_disk_guid);
64518030d04SAlison Chaiken #endif
64618030d04SAlison Chaiken if (partitions)
64718030d04SAlison Chaiken free(partitions);
64818030d04SAlison Chaiken }
64918030d04SAlison Chaiken
do_rename_gpt_parts(struct blk_desc * dev_desc,char * subcomm,char * name1,char * name2)650203f9b48SAlison Chaiken static int do_rename_gpt_parts(struct blk_desc *dev_desc, char *subcomm,
651203f9b48SAlison Chaiken char *name1, char *name2)
652203f9b48SAlison Chaiken {
653203f9b48SAlison Chaiken struct list_head *pos;
654203f9b48SAlison Chaiken struct disk_part *curr;
655203f9b48SAlison Chaiken disk_partition_t *new_partitions = NULL;
656203f9b48SAlison Chaiken char disk_guid[UUID_STR_LEN + 1];
657203f9b48SAlison Chaiken char *partitions_list, *str_disk_guid;
658203f9b48SAlison Chaiken u8 part_count = 0;
659203f9b48SAlison Chaiken int partlistlen, ret, numparts = 0, partnum, i = 1, ctr1 = 0, ctr2 = 0;
660203f9b48SAlison Chaiken
661203f9b48SAlison Chaiken if ((subcomm == NULL) || (name1 == NULL) || (name2 == NULL) ||
662203f9b48SAlison Chaiken (strcmp(subcomm, "swap") && (strcmp(subcomm, "rename"))))
663203f9b48SAlison Chaiken return -EINVAL;
664203f9b48SAlison Chaiken
665203f9b48SAlison Chaiken ret = get_disk_guid(dev_desc, disk_guid);
666203f9b48SAlison Chaiken if (ret < 0)
667203f9b48SAlison Chaiken return ret;
66818030d04SAlison Chaiken /*
66918030d04SAlison Chaiken * Allocates disk_partitions, requiring matching call to del_gpt_info()
67018030d04SAlison Chaiken * if successful.
67118030d04SAlison Chaiken */
672203f9b48SAlison Chaiken numparts = get_gpt_info(dev_desc);
673203f9b48SAlison Chaiken if (numparts <= 0)
674203f9b48SAlison Chaiken return numparts ? numparts : -ENODEV;
675203f9b48SAlison Chaiken
676203f9b48SAlison Chaiken partlistlen = calc_parts_list_len(numparts);
677203f9b48SAlison Chaiken partitions_list = malloc(partlistlen);
67818030d04SAlison Chaiken if (!partitions_list) {
67918030d04SAlison Chaiken del_gpt_info();
680203f9b48SAlison Chaiken return -ENOMEM;
68118030d04SAlison Chaiken }
682203f9b48SAlison Chaiken memset(partitions_list, '\0', partlistlen);
683203f9b48SAlison Chaiken
684203f9b48SAlison Chaiken ret = create_gpt_partitions_list(numparts, disk_guid, partitions_list);
68518030d04SAlison Chaiken if (ret < 0) {
68618030d04SAlison Chaiken free(partitions_list);
687203f9b48SAlison Chaiken return ret;
68818030d04SAlison Chaiken }
689203f9b48SAlison Chaiken /*
690203f9b48SAlison Chaiken * Uncomment the following line to print a string that 'gpt write'
691203f9b48SAlison Chaiken * or 'gpt verify' will accept as input.
692203f9b48SAlison Chaiken */
693203f9b48SAlison Chaiken debug("OLD partitions_list is %s with %u chars\n", partitions_list,
694203f9b48SAlison Chaiken (unsigned)strlen(partitions_list));
695203f9b48SAlison Chaiken
69618030d04SAlison Chaiken /* set_gpt_info allocates new_partitions and str_disk_guid */
697203f9b48SAlison Chaiken ret = set_gpt_info(dev_desc, partitions_list, &str_disk_guid,
698203f9b48SAlison Chaiken &new_partitions, &part_count);
69918030d04SAlison Chaiken if (ret < 0) {
70018030d04SAlison Chaiken del_gpt_info();
70118030d04SAlison Chaiken free(partitions_list);
70218030d04SAlison Chaiken if (ret == -ENOMEM)
70318030d04SAlison Chaiken set_gpt_cleanup(&str_disk_guid, &new_partitions);
70418030d04SAlison Chaiken else
70518030d04SAlison Chaiken goto out;
70618030d04SAlison Chaiken }
707203f9b48SAlison Chaiken
708203f9b48SAlison Chaiken if (!strcmp(subcomm, "swap")) {
709203f9b48SAlison Chaiken if ((strlen(name1) > PART_NAME_LEN) || (strlen(name2) > PART_NAME_LEN)) {
710203f9b48SAlison Chaiken printf("Names longer than %d characters are truncated.\n", PART_NAME_LEN);
71118030d04SAlison Chaiken ret = -EINVAL;
71218030d04SAlison Chaiken goto out;
713203f9b48SAlison Chaiken }
714203f9b48SAlison Chaiken list_for_each(pos, &disk_partitions) {
715203f9b48SAlison Chaiken curr = list_entry(pos, struct disk_part, list);
716203f9b48SAlison Chaiken if (!strcmp((char *)curr->gpt_part_info.name, name1)) {
717203f9b48SAlison Chaiken strcpy((char *)curr->gpt_part_info.name, name2);
718203f9b48SAlison Chaiken ctr1++;
719203f9b48SAlison Chaiken } else if (!strcmp((char *)curr->gpt_part_info.name, name2)) {
720203f9b48SAlison Chaiken strcpy((char *)curr->gpt_part_info.name, name1);
721203f9b48SAlison Chaiken ctr2++;
722203f9b48SAlison Chaiken }
723203f9b48SAlison Chaiken }
724203f9b48SAlison Chaiken if ((ctr1 + ctr2 < 2) || (ctr1 != ctr2)) {
725203f9b48SAlison Chaiken printf("Cannot swap partition names except in pairs.\n");
72618030d04SAlison Chaiken ret = -EINVAL;
72718030d04SAlison Chaiken goto out;
728203f9b48SAlison Chaiken }
729203f9b48SAlison Chaiken } else { /* rename */
730203f9b48SAlison Chaiken if (strlen(name2) > PART_NAME_LEN) {
731203f9b48SAlison Chaiken printf("Names longer than %d characters are truncated.\n", PART_NAME_LEN);
73218030d04SAlison Chaiken ret = -EINVAL;
73318030d04SAlison Chaiken goto out;
734203f9b48SAlison Chaiken }
735203f9b48SAlison Chaiken partnum = (int)simple_strtol(name1, NULL, 10);
736203f9b48SAlison Chaiken if ((partnum < 0) || (partnum > numparts)) {
737203f9b48SAlison Chaiken printf("Illegal partition number %s\n", name1);
73818030d04SAlison Chaiken ret = -EINVAL;
73918030d04SAlison Chaiken goto out;
740203f9b48SAlison Chaiken }
741203f9b48SAlison Chaiken ret = part_get_info(dev_desc, partnum, new_partitions);
742203f9b48SAlison Chaiken if (ret < 0)
74318030d04SAlison Chaiken goto out;
744203f9b48SAlison Chaiken
745203f9b48SAlison Chaiken /* U-Boot partition numbering starts at 1 */
746203f9b48SAlison Chaiken list_for_each(pos, &disk_partitions) {
747203f9b48SAlison Chaiken curr = list_entry(pos, struct disk_part, list);
748203f9b48SAlison Chaiken if (i == partnum) {
749203f9b48SAlison Chaiken strcpy((char *)curr->gpt_part_info.name, name2);
750203f9b48SAlison Chaiken break;
751203f9b48SAlison Chaiken }
752203f9b48SAlison Chaiken i++;
753203f9b48SAlison Chaiken }
754203f9b48SAlison Chaiken }
755203f9b48SAlison Chaiken
756203f9b48SAlison Chaiken ret = create_gpt_partitions_list(numparts, disk_guid, partitions_list);
757203f9b48SAlison Chaiken if (ret < 0)
75818030d04SAlison Chaiken goto out;
759203f9b48SAlison Chaiken debug("NEW partitions_list is %s with %u chars\n", partitions_list,
760203f9b48SAlison Chaiken (unsigned)strlen(partitions_list));
761203f9b48SAlison Chaiken
762203f9b48SAlison Chaiken ret = set_gpt_info(dev_desc, partitions_list, &str_disk_guid,
763203f9b48SAlison Chaiken &new_partitions, &part_count);
76418030d04SAlison Chaiken /*
76518030d04SAlison Chaiken * Even though valid pointers are here passed into set_gpt_info(),
76618030d04SAlison Chaiken * it mallocs again, and there's no way to tell which failed.
76718030d04SAlison Chaiken */
76818030d04SAlison Chaiken if (ret < 0) {
76918030d04SAlison Chaiken del_gpt_info();
77018030d04SAlison Chaiken free(partitions_list);
77118030d04SAlison Chaiken if (ret == -ENOMEM)
77218030d04SAlison Chaiken set_gpt_cleanup(&str_disk_guid, &new_partitions);
77318030d04SAlison Chaiken else
77418030d04SAlison Chaiken goto out;
77518030d04SAlison Chaiken }
776203f9b48SAlison Chaiken
777203f9b48SAlison Chaiken debug("Writing new partition table\n");
778203f9b48SAlison Chaiken ret = gpt_restore(dev_desc, disk_guid, new_partitions, numparts);
779203f9b48SAlison Chaiken if (ret < 0) {
780203f9b48SAlison Chaiken printf("Writing new partition table failed\n");
78118030d04SAlison Chaiken goto out;
782203f9b48SAlison Chaiken }
783203f9b48SAlison Chaiken
784203f9b48SAlison Chaiken debug("Reading back new partition table\n");
78518030d04SAlison Chaiken /*
78618030d04SAlison Chaiken * Empty the existing disk_partitions list, as otherwise the memory in
78718030d04SAlison Chaiken * the original list is unreachable.
78818030d04SAlison Chaiken */
78918030d04SAlison Chaiken del_gpt_info();
790203f9b48SAlison Chaiken numparts = get_gpt_info(dev_desc);
79118030d04SAlison Chaiken if (numparts <= 0) {
79218030d04SAlison Chaiken ret = numparts ? numparts : -ENODEV;
79318030d04SAlison Chaiken goto out;
79418030d04SAlison Chaiken }
795203f9b48SAlison Chaiken printf("new partition table with %d partitions is:\n", numparts);
796203f9b48SAlison Chaiken print_gpt_info();
797203f9b48SAlison Chaiken del_gpt_info();
79818030d04SAlison Chaiken out:
799203f9b48SAlison Chaiken free(new_partitions);
80018030d04SAlison Chaiken free(str_disk_guid);
80118030d04SAlison Chaiken free(partitions_list);
802203f9b48SAlison Chaiken return ret;
803203f9b48SAlison Chaiken }
804203f9b48SAlison Chaiken #endif
805203f9b48SAlison Chaiken
8062e192b24SSimon Glass /**
8072e192b24SSimon Glass * do_gpt(): Perform GPT operations
8082e192b24SSimon Glass *
8092e192b24SSimon Glass * @param cmdtp - command name
8102e192b24SSimon Glass * @param flag
8112e192b24SSimon Glass * @param argc
8122e192b24SSimon Glass * @param argv
8132e192b24SSimon Glass *
8142e192b24SSimon Glass * @return zero on success; otherwise error
8152e192b24SSimon Glass */
do_gpt(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])8162e192b24SSimon Glass static int do_gpt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
8172e192b24SSimon Glass {
8182e192b24SSimon Glass int ret = CMD_RET_SUCCESS;
8192e192b24SSimon Glass int dev = 0;
8202e192b24SSimon Glass char *ep;
8214101f687SSimon Glass struct blk_desc *blk_dev_desc = NULL;
8222e192b24SSimon Glass
823203f9b48SAlison Chaiken #ifndef CONFIG_CMD_GPT_RENAME
8242e192b24SSimon Glass if (argc < 4 || argc > 5)
825203f9b48SAlison Chaiken #else
826203f9b48SAlison Chaiken if (argc < 4 || argc > 6)
827203f9b48SAlison Chaiken #endif
8282e192b24SSimon Glass return CMD_RET_USAGE;
8292e192b24SSimon Glass
8302e192b24SSimon Glass dev = (int)simple_strtoul(argv[3], &ep, 10);
8312e192b24SSimon Glass if (!ep || ep[0] != '\0') {
8322e192b24SSimon Glass printf("'%s' is not a number\n", argv[3]);
8332e192b24SSimon Glass return CMD_RET_USAGE;
8342e192b24SSimon Glass }
835db1d9e78SSimon Glass blk_dev_desc = blk_get_dev(argv[2], dev);
8362e192b24SSimon Glass if (!blk_dev_desc) {
8372e192b24SSimon Glass printf("%s: %s dev %d NOT available\n",
8382e192b24SSimon Glass __func__, argv[2], dev);
8392e192b24SSimon Glass return CMD_RET_FAILURE;
8402e192b24SSimon Glass }
8412e192b24SSimon Glass
8422e192b24SSimon Glass if ((strcmp(argv[1], "write") == 0) && (argc == 5)) {
8432e192b24SSimon Glass printf("Writing GPT: ");
8442e192b24SSimon Glass ret = gpt_default(blk_dev_desc, argv[4]);
8452e192b24SSimon Glass } else if ((strcmp(argv[1], "verify") == 0)) {
8462e192b24SSimon Glass ret = gpt_verify(blk_dev_desc, argv[4]);
8472e192b24SSimon Glass printf("Verify GPT: ");
84873d6d18bSAlison Chaiken } else if (strcmp(argv[1], "guid") == 0) {
84973d6d18bSAlison Chaiken ret = do_disk_guid(blk_dev_desc, argv[4]);
85009a49930SAlison Chaiken #ifdef CONFIG_CMD_GPT_RENAME
85109a49930SAlison Chaiken } else if (strcmp(argv[1], "read") == 0) {
85209a49930SAlison Chaiken ret = do_get_gpt_info(blk_dev_desc);
853203f9b48SAlison Chaiken } else if ((strcmp(argv[1], "swap") == 0) ||
854203f9b48SAlison Chaiken (strcmp(argv[1], "rename") == 0)) {
855203f9b48SAlison Chaiken ret = do_rename_gpt_parts(blk_dev_desc, argv[1], argv[4], argv[5]);
85609a49930SAlison Chaiken #endif
8572e192b24SSimon Glass } else {
8582e192b24SSimon Glass return CMD_RET_USAGE;
8592e192b24SSimon Glass }
8602e192b24SSimon Glass
8612e192b24SSimon Glass if (ret) {
8622e192b24SSimon Glass printf("error!\n");
8632e192b24SSimon Glass return CMD_RET_FAILURE;
8642e192b24SSimon Glass }
8652e192b24SSimon Glass
8662e192b24SSimon Glass printf("success!\n");
8672e192b24SSimon Glass return CMD_RET_SUCCESS;
8682e192b24SSimon Glass }
8692e192b24SSimon Glass
8702e192b24SSimon Glass U_BOOT_CMD(gpt, CONFIG_SYS_MAXARGS, 1, do_gpt,
8712e192b24SSimon Glass "GUID Partition Table",
8722e192b24SSimon Glass "<command> <interface> <dev> <partitions_list>\n"
8732e192b24SSimon Glass " - GUID partition table restoration and validity check\n"
8742e192b24SSimon Glass " Restore or verify GPT information on a device connected\n"
8752e192b24SSimon Glass " to interface\n"
8762e192b24SSimon Glass " Example usage:\n"
8772e192b24SSimon Glass " gpt write mmc 0 $partitions\n"
8782e192b24SSimon Glass " gpt verify mmc 0 $partitions\n"
87909a49930SAlison Chaiken " read <interface> <dev>\n"
88009a49930SAlison Chaiken " - read GPT into a data structure for manipulation\n"
88173d6d18bSAlison Chaiken " guid <interface> <dev>\n"
88273d6d18bSAlison Chaiken " - print disk GUID\n"
88373d6d18bSAlison Chaiken " guid <interface> <dev> <varname>\n"
88473d6d18bSAlison Chaiken " - set environment variable to disk GUID\n"
88573d6d18bSAlison Chaiken " Example usage:\n"
88673d6d18bSAlison Chaiken " gpt guid mmc 0\n"
88773d6d18bSAlison Chaiken " gpt guid mmc 0 varname\n"
888203f9b48SAlison Chaiken #ifdef CONFIG_CMD_GPT_RENAME
889203f9b48SAlison Chaiken "gpt partition renaming commands:\n"
890203f9b48SAlison Chaiken "gpt swap <interface> <dev> <name1> <name2>\n"
891203f9b48SAlison Chaiken " - change all partitions named name1 to name2\n"
892203f9b48SAlison Chaiken " and vice-versa\n"
893203f9b48SAlison Chaiken "gpt rename <interface> <dev> <part> <name>\n"
894203f9b48SAlison Chaiken " - rename the specified partition\n"
895203f9b48SAlison Chaiken " Example usage:\n"
896203f9b48SAlison Chaiken " gpt swap mmc 0 foo bar\n"
897203f9b48SAlison Chaiken " gpt rename mmc 0 3 foo\n"
898203f9b48SAlison Chaiken #endif
8992e192b24SSimon Glass );
900