git.sur5r.net Git - u-boot/blob - cmd/gpt.c

   1 /*
   2  * cmd_gpt.c -- GPT (GUID Partition Table) handling command
   3  *
   4  * Copyright (C) 2015
   5  * Lukasz Majewski <l.majewski@majess.pl>
   6  *
   7  * Copyright (C) 2012 Samsung Electronics
   8  * author: Lukasz Majewski <l.majewski@samsung.com>
   9  * author: Piotr Wilczek <p.wilczek@samsung.com>
  10  *
  11  * SPDX-License-Identifier:     GPL-2.0+
  12  */
  13
  14 #include <common.h>
  15 #include <malloc.h>
  16 #include <command.h>
  17 #include <part_efi.h>
  18 #include <exports.h>
  19 #include <linux/ctype.h>
  20 #include <div64.h>
  21 #include <memalign.h>
  22 #include <linux/compat.h>
  23 #include <linux/sizes.h>
  24 #include <stdlib.h>
  25
  26 static LIST_HEAD(disk_partitions);
  27
  28 /**
  29  * extract_env(): Expand env name from string format '&{env_name}'
  30  *                and return pointer to the env (if the env is set)
  31  *
  32  * @param str - pointer to string
  33  * @param env - pointer to pointer to extracted env
  34  *
  35  * @return - zero on successful expand and env is set
  36  */
  37 static int extract_env(const char *str, char **env)
  38 {
  39         int ret = -1;
  40         char *e, *s;
  41 #ifdef CONFIG_RANDOM_UUID
  42         char uuid_str[UUID_STR_LEN + 1];
  43 #endif
  44
  45         if (!str || strlen(str) < 4)
  46                 return -1;
  47
  48         if (!((strncmp(str, "${", 2) == 0) && (str[strlen(str) - 1] == '}')))
  49                 return -1;
  50
  51         s = strdup(str);
  52         if (s == NULL)
  53                 return -1;
  54
  55         memset(s + strlen(s) - 1, '\0', 1);
  56         memmove(s, s + 2, strlen(s) - 1);
  57
  58         e = env_get(s);
  59         if (e == NULL) {
  60 #ifdef CONFIG_RANDOM_UUID
  61                 debug("%s unset. ", str);
  62                 gen_rand_uuid_str(uuid_str, UUID_STR_FORMAT_GUID);
  63                 env_set(s, uuid_str);
  64
  65                 e = env_get(s);
  66                 if (e) {
  67                         debug("Set to random.\n");
  68                         ret = 0;
  69                 } else {
  70                         debug("Can't get random UUID.\n");
  71                 }
  72 #else
  73                 debug("%s unset.\n", str);
  74 #endif
  75         } else {
  76                 debug("%s get from environment.\n", str);
  77                 ret = 0;
  78         }
  79
  80         *env = e;
  81         free(s);
  82
  83         return ret;
  84 }
  85
  86 /**
  87  * extract_val(): Extract value from a key=value pair list (comma separated).
  88  *                Only value for the given key is returend.
  89  *                Function allocates memory for the value, remember to free!
  90  *
  91  * @param str - pointer to string with key=values pairs
  92  * @param key - pointer to the key to search for
  93  *
  94  * @return - pointer to allocated string with the value
  95  */
  96 static char *extract_val(const char *str, const char *key)
  97 {
  98         char *v, *k;
  99         char *s, *strcopy;
 100         char *new = NULL;
 101
 102         strcopy = strdup(str);
 103         if (strcopy == NULL)
 104                 return NULL;
 105
 106         s = strcopy;
 107         while (s) {
 108                 v = strsep(&s, ",");
 109                 if (!v)
 110                         break;
 111                 k = strsep(&v, "=");
 112                 if (!k)
 113                         break;
 114                 if  (strcmp(k, key) == 0) {
 115                         new = strdup(v);
 116                         break;
 117                 }
 118         }
 119
 120         free(strcopy);
 121
 122         return new;
 123 }
 124
 125 /**
 126  * found_key(): Found key without value in parameter list (comma separated).
 127  *
 128  * @param str - pointer to string with key
 129  * @param key - pointer to the key to search for
 130  *
 131  * @return - true on found key
 132  */
 133 static bool found_key(const char *str, const char *key)
 134 {
 135         char *k;
 136         char *s, *strcopy;
 137         bool result = false;
 138
 139         strcopy = strdup(str);
 140         if (!strcopy)
 141                 return NULL;
 142
 143         s = strcopy;
 144         while (s) {
 145                 k = strsep(&s, ",");
 146                 if (!k)
 147                         break;
 148                 if  (strcmp(k, key) == 0) {
 149                         result = true;
 150                         break;
 151                 }
 152         }
 153
 154         free(strcopy);
 155
 156         return result;
 157 }
 158
 159 static int calc_parts_list_len(int numparts)
 160 {
 161         int partlistlen = UUID_STR_LEN + 1 + strlen("uuid_disk=");
 162         /* for the comma */
 163         partlistlen++;
 164
 165         /* per-partition additions; numparts starts at 1, so this should be correct */
 166         partlistlen += numparts * (strlen("name=,") + PART_NAME_LEN + 1);
 167         /* see part.h for definition of struct disk_partition */
 168         partlistlen += numparts * (strlen("start=MiB,") + sizeof(lbaint_t) + 1);
 169         partlistlen += numparts * (strlen("size=MiB,") + sizeof(lbaint_t) + 1);
 170         partlistlen += numparts * (strlen("uuid=;") + UUID_STR_LEN + 1);
 171         /* for the terminating null */
 172         partlistlen++;
 173         debug("Length of partitions_list is %d for %d partitions\n", partlistlen,
 174               numparts);
 175         return partlistlen;
 176 }
 177
 178 #ifdef CONFIG_CMD_GPT_RENAME
 179 static void del_gpt_info(void)
 180 {
 181         struct list_head *pos = &disk_partitions;
 182         struct disk_part *curr;
 183         while (!list_empty(pos)) {
 184                 curr = list_entry(pos->next, struct disk_part, list);
 185                 list_del(pos->next);
 186                 free(curr);
 187         }
 188 }
 189
 190 static struct disk_part *allocate_disk_part(disk_partition_t *info, int partnum)
 191 {
 192         struct disk_part *newpart;
 193         newpart = calloc(1, sizeof(struct disk_part));
 194         if (!newpart)
 195                 return ERR_PTR(-ENOMEM);
 196
 197         newpart->gpt_part_info.start = info->start;
 198         newpart->gpt_part_info.size = info->size;
 199         newpart->gpt_part_info.blksz = info->blksz;
 200         strncpy((char *)newpart->gpt_part_info.name, (const char *)info->name,
 201                 PART_NAME_LEN);
 202         newpart->gpt_part_info.name[PART_NAME_LEN - 1] = '\0';
 203         strncpy((char *)newpart->gpt_part_info.type, (const char *)info->type,
 204                 PART_TYPE_LEN);
 205         newpart->gpt_part_info.type[PART_TYPE_LEN - 1] = '\0';
 206         newpart->gpt_part_info.bootable = info->bootable;
 207 #ifdef CONFIG_PARTITION_UUIDS
 208         strncpy(newpart->gpt_part_info.uuid, (const char *)info->uuid,
 209                 UUID_STR_LEN);
 210         /* UUID_STR_LEN is correct, as uuid[]'s length is UUID_STR_LEN+1 chars */
 211         newpart->gpt_part_info.uuid[UUID_STR_LEN] = '\0';
 212 #endif
 213         newpart->partnum = partnum;
 214
 215         return newpart;
 216 }
 217
 218 static void prettyprint_part_size(char *sizestr, lbaint_t partsize,
 219                                   lbaint_t blksize)
 220 {
 221         unsigned long long partbytes, partmegabytes;
 222
 223         partbytes = partsize * blksize;
 224         partmegabytes = lldiv(partbytes, SZ_1M);
 225         snprintf(sizestr, 16, "%lluMiB", partmegabytes);
 226 }
 227
 228 static void print_gpt_info(void)
 229 {
 230         struct list_head *pos;
 231         struct disk_part *curr;
 232         char partstartstr[16];
 233         char partsizestr[16];
 234
 235         list_for_each(pos, &disk_partitions) {
 236                 curr = list_entry(pos, struct disk_part, list);
 237                 prettyprint_part_size(partstartstr, curr->gpt_part_info.start,
 238                                       curr->gpt_part_info.blksz);
 239                 prettyprint_part_size(partsizestr, curr->gpt_part_info.size,
 240                                       curr->gpt_part_info.blksz);
 241
 242                 printf("Partition %d:\n", curr->partnum);
 243                 printf("Start %s, size %s\n", partstartstr, partsizestr);
 244                 printf("Block size %lu, name %s\n", curr->gpt_part_info.blksz,
 245                        curr->gpt_part_info.name);
 246                 printf("Type %s, bootable %d\n", curr->gpt_part_info.type,
 247                        curr->gpt_part_info.bootable);
 248 #ifdef CONFIG_PARTITION_UUIDS
 249                 printf("UUID %s\n", curr->gpt_part_info.uuid);
 250 #endif
 251                 printf("\n");
 252         }
 253 }
 254
 255 /*
 256  * create the string that upstream 'gpt write' command will accept as an
 257  * argument
 258  *
 259  * From doc/README.gpt, Format of partitions layout:
 260  *    "uuid_disk=...;name=u-boot,size=60MiB,uuid=...;
 261  *      name=kernel,size=60MiB,uuid=...;"
 262  * The fields 'name' and 'size' are mandatory for every partition.
 263  * The field 'start' is optional. The fields 'uuid' and 'uuid_disk'
 264  * are optional if CONFIG_RANDOM_UUID is enabled.
 265  */
 266 static int create_gpt_partitions_list(int numparts, const char *guid,
 267                                       char *partitions_list)
 268 {
 269         struct list_head *pos;
 270         struct disk_part *curr;
 271         char partstr[PART_NAME_LEN + 1];
 272
 273         if (!partitions_list)
 274                 return -EINVAL;
 275
 276         strcpy(partitions_list, "uuid_disk=");
 277         strncat(partitions_list, guid, UUID_STR_LEN + 1);
 278         strcat(partitions_list, ";");
 279
 280         list_for_each(pos, &disk_partitions) {
 281                 curr = list_entry(pos, struct disk_part, list);
 282                 strcat(partitions_list, "name=");
 283                 strncat(partitions_list, (const char *)curr->gpt_part_info.name,
 284                         PART_NAME_LEN + 1);
 285                 sprintf(partstr, ",start=0x%llx",
 286                         (unsigned long long)curr->gpt_part_info.start *
 287                                             curr->gpt_part_info.blksz);
 288                 /* one extra byte for NULL */
 289                 strncat(partitions_list, partstr, PART_NAME_LEN + 1);
 290                 sprintf(partstr, ",size=0x%llx",
 291                         (unsigned long long)curr->gpt_part_info.size *
 292                                             curr->gpt_part_info.blksz);
 293                 strncat(partitions_list, partstr, PART_NAME_LEN + 1);
 294
 295                 strcat(partitions_list, ",uuid=");
 296                 strncat(partitions_list, curr->gpt_part_info.uuid,
 297                         UUID_STR_LEN + 1);
 298                 strcat(partitions_list, ";");
 299         }
 300         return 0;
 301 }
 302
 303 /*
 304  * read partition info into disk_partitions list where
 305  * it can be printed or modified
 306  */
 307 static int get_gpt_info(struct blk_desc *dev_desc)
 308 {
 309         /* start partition numbering at 1, as U-Boot does */
 310         int valid_parts = 0, p, ret;
 311         disk_partition_t info;
 312         struct disk_part *new_disk_part;
 313
 314         /*
 315          * Always re-read partition info from device, in case
 316          * it has changed
 317          */
 318         INIT_LIST_HEAD(&disk_partitions);
 319
 320         for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
 321                 ret = part_get_info(dev_desc, p, &info);
 322                 if (ret)
 323                         continue;
 324
 325                 /* Add 1 here because counter is zero-based but p1 is
 326                    the first partition */
 327                 new_disk_part = allocate_disk_part(&info, valid_parts+1);
 328                 if (IS_ERR(new_disk_part))
 329                         goto out;
 330
 331                 list_add_tail(&new_disk_part->list, &disk_partitions);
 332                 valid_parts++;
 333         }
 334         if (valid_parts == 0) {
 335                 printf("** No valid partitions found **\n");
 336                 goto out;
 337         }
 338         return valid_parts;
 339  out:
 340         if (valid_parts >= 1)
 341                 del_gpt_info();
 342         return -ENODEV;
 343 }
 344
 345 /* a wrapper to test get_gpt_info */
 346 static int do_get_gpt_info(struct blk_desc *dev_desc)
 347 {
 348         int ret;
 349
 350         ret = get_gpt_info(dev_desc);
 351         if (ret > 0) {
 352                 print_gpt_info();
 353                 del_gpt_info();
 354                 return 0;
 355         }
 356         return ret;
 357 }
 358 #endif
 359
 360 /**
 361  * set_gpt_info(): Fill partition information from string
 362  *              function allocates memory, remember to free!
 363  *
 364  * @param dev_desc - pointer block device descriptor
 365  * @param str_part - pointer to string with partition information
 366  * @param str_disk_guid - pointer to pointer to allocated string with disk guid
 367  * @param partitions - pointer to pointer to allocated partitions array
 368  * @param parts_count - number of partitions
 369  *
 370  * @return - zero on success, otherwise error
 371  *
 372  */
 373 static int set_gpt_info(struct blk_desc *dev_desc,
 374                         const char *str_part,
 375                         char **str_disk_guid,
 376                         disk_partition_t **partitions,
 377                         u8 *parts_count)
 378 {
 379         char *tok, *str, *s;
 380         int i;
 381         char *val, *p;
 382         int p_count;
 383         disk_partition_t *parts;
 384         int errno = 0;
 385         uint64_t size_ll, start_ll;
 386         lbaint_t offset = 0;
 387         int max_str_part = calc_parts_list_len(MAX_SEARCH_PARTITIONS);
 388
 389         debug("%s:  lba num: 0x%x %d\n", __func__,
 390               (unsigned int)dev_desc->lba, (unsigned int)dev_desc->lba);
 391
 392         if (str_part == NULL)
 393                 return -1;
 394
 395         str = strdup(str_part);
 396         if (str == NULL)
 397                 return -ENOMEM;
 398
 399         /* extract disk guid */
 400         s = str;
 401         val = extract_val(str, "uuid_disk");
 402         if (!val) {
 403 #ifdef CONFIG_RANDOM_UUID
 404                 *str_disk_guid = malloc(UUID_STR_LEN + 1);
 405                 if (*str_disk_guid == NULL)
 406                         return -ENOMEM;
 407                 gen_rand_uuid_str(*str_disk_guid, UUID_STR_FORMAT_STD);
 408 #else
 409                 free(str);
 410                 return -2;
 411 #endif
 412         } else {
 413                 val = strsep(&val, ";");
 414                 if (extract_env(val, &p))
 415                         p = val;
 416                 *str_disk_guid = strdup(p);
 417                 free(val);
 418                 /* Move s to first partition */
 419                 strsep(&s, ";");
 420         }
 421         if (s == NULL) {
 422                 printf("Error: is the partitions string NULL-terminated?\n");
 423                 return -EINVAL;
 424         }
 425         if (strnlen(s, max_str_part) == 0)
 426                 return -3;
 427
 428         i = strnlen(s, max_str_part) - 1;
 429         if (s[i] == ';')
 430                 s[i] = '\0';
 431
 432         /* calculate expected number of partitions */
 433         p_count = 1;
 434         p = s;
 435         while (*p) {
 436                 if (*p++ == ';')
 437                         p_count++;
 438         }
 439
 440         /* allocate memory for partitions */
 441         parts = calloc(sizeof(disk_partition_t), p_count);
 442         if (parts == NULL)
 443                 return -ENOMEM;
 444
 445         /* retrieve partitions data from string */
 446         for (i = 0; i < p_count; i++) {
 447                 tok = strsep(&s, ";");
 448
 449                 if (tok == NULL)
 450                         break;
 451
 452                 /* uuid */
 453                 val = extract_val(tok, "uuid");
 454                 if (!val) {
 455                         /* 'uuid' is optional if random uuid's are enabled */
 456 #ifdef CONFIG_RANDOM_UUID
 457                         gen_rand_uuid_str(parts[i].uuid, UUID_STR_FORMAT_STD);
 458 #else
 459                         errno = -4;
 460                         goto err;
 461 #endif
 462                 } else {
 463                         if (extract_env(val, &p))
 464                                 p = val;
 465                         if (strnlen(p, max_str_part) >= sizeof(parts[i].uuid)) {
 466                                 printf("Wrong uuid format for partition %d\n", i);
 467                                 errno = -4;
 468                                 goto err;
 469                         }
 470                         strncpy((char *)parts[i].uuid, p, max_str_part);
 471                         free(val);
 472                 }
 473 #ifdef CONFIG_PARTITION_TYPE_GUID
 474                 /* guid */
 475                 val = extract_val(tok, "type");
 476                 if (val) {
 477                         /* 'type' is optional */
 478                         if (extract_env(val, &p))
 479                                 p = val;
 480                         if (strnlen(p, max_str_part) >= sizeof(parts[i].type_guid)) {
 481                                 printf("Wrong type guid format for partition %d\n",
 482                                        i);
 483                                 errno = -4;
 484                                 goto err;
 485                         }
 486                         strncpy((char *)parts[i].type_guid, p, max_str_part);
 487                         free(val);
 488                 }
 489 #endif
 490                 /* name */
 491                 val = extract_val(tok, "name");
 492                 if (!val) { /* name is mandatory */
 493                         errno = -4;
 494                         goto err;
 495                 }
 496                 if (extract_env(val, &p))
 497                         p = val;
 498                 if (strnlen(p, max_str_part) >= sizeof(parts[i].name)) {
 499                         errno = -4;
 500                         goto err;
 501                 }
 502                 strncpy((char *)parts[i].name, p, max_str_part);
 503                 free(val);
 504
 505                 /* size */
 506                 val = extract_val(tok, "size");
 507                 if (!val) { /* 'size' is mandatory */
 508                         errno = -4;
 509                         goto err;
 510                 }
 511                 if (extract_env(val, &p))
 512                         p = val;
 513                 if ((strcmp(p, "-") == 0)) {
 514                         /* Let part efi module to auto extend the size */
 515                         parts[i].size = 0;
 516                 } else {
 517                         size_ll = ustrtoull(p, &p, 0);
 518                         parts[i].size = lldiv(size_ll, dev_desc->blksz);
 519                 }
 520
 521                 free(val);
 522
 523                 /* start address */
 524                 val = extract_val(tok, "start");
 525                 if (val) { /* start address is optional */
 526                         if (extract_env(val, &p))
 527                                 p = val;
 528                         start_ll = ustrtoull(p, &p, 0);
 529                         parts[i].start = lldiv(start_ll, dev_desc->blksz);
 530                         free(val);
 531                 }
 532
 533                 offset += parts[i].size + parts[i].start;
 534
 535                 /* bootable */
 536                 if (found_key(tok, "bootable"))
 537                         parts[i].bootable = 1;
 538         }
 539
 540         *parts_count = p_count;
 541         *partitions = parts;
 542         free(str);
 543
 544         return 0;
 545 err:
 546         free(str);
 547         free(*str_disk_guid);
 548         free(parts);
 549
 550         return errno;
 551 }
 552
 553 static int gpt_default(struct blk_desc *blk_dev_desc, const char *str_part)
 554 {
 555         int ret;
 556         char *str_disk_guid;
 557         u8 part_count = 0;
 558         disk_partition_t *partitions = NULL;
 559
 560         /* fill partitions */
 561         ret = set_gpt_info(blk_dev_desc, str_part,
 562                         &str_disk_guid, &partitions, &part_count);
 563         if (ret) {
 564                 if (ret == -1)
 565                         printf("No partition list provided\n");
 566                 if (ret == -2)
 567                         printf("Missing disk guid\n");
 568                 if ((ret == -3) || (ret == -4))
 569                         printf("Partition list incomplete\n");
 570                 return -1;
 571         }
 572
 573         /* save partitions layout to disk */
 574         ret = gpt_restore(blk_dev_desc, str_disk_guid, partitions, part_count);
 575         free(str_disk_guid);
 576         free(partitions);
 577
 578         return ret;
 579 }
 580
 581 static int gpt_verify(struct blk_desc *blk_dev_desc, const char *str_part)
 582 {
 583         ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1,
 584                                      blk_dev_desc->blksz);
 585         disk_partition_t *partitions = NULL;
 586         gpt_entry *gpt_pte = NULL;
 587         char *str_disk_guid;
 588         u8 part_count = 0;
 589         int ret = 0;
 590
 591         /* fill partitions */
 592         ret = set_gpt_info(blk_dev_desc, str_part,
 593                         &str_disk_guid, &partitions, &part_count);
 594         if (ret) {
 595                 if (ret == -1) {
 596                         printf("No partition list provided - only basic check\n");
 597                         ret = gpt_verify_headers(blk_dev_desc, gpt_head,
 598                                                  &gpt_pte);
 599                         goto out;
 600                 }
 601                 if (ret == -2)
 602                         printf("Missing disk guid\n");
 603                 if ((ret == -3) || (ret == -4))
 604                         printf("Partition list incomplete\n");
 605                 return -1;
 606         }
 607
 608         /* Check partition layout with provided pattern */
 609         ret = gpt_verify_partitions(blk_dev_desc, partitions, part_count,
 610                                     gpt_head, &gpt_pte);
 611         free(str_disk_guid);
 612         free(partitions);
 613  out:
 614         free(gpt_pte);
 615         return ret;
 616 }
 617
 618 static int do_disk_guid(struct blk_desc *dev_desc, char * const namestr)
 619 {
 620         int ret;
 621         char disk_guid[UUID_STR_LEN + 1];
 622
 623         ret = get_disk_guid(dev_desc, disk_guid);
 624         if (ret < 0)
 625                 return CMD_RET_FAILURE;
 626
 627         if (namestr)
 628                 env_set(namestr, disk_guid);
 629         else
 630                 printf("%s\n", disk_guid);
 631
 632         return ret;
 633 }
 634
 635 #ifdef CONFIG_CMD_GPT_RENAME
 636 /*
 637  * There are 3 malloc() calls in set_gpt_info() and there is no info about which
 638  * failed.
 639  */
 640 static void set_gpt_cleanup(char **str_disk_guid,
 641                             disk_partition_t **partitions)
 642 {
 643 #ifdef CONFIG_RANDOM_UUID
 644         if (str_disk_guid)
 645                 free(str_disk_guid);
 646 #endif
 647         if (partitions)
 648                 free(partitions);
 649 }
 650
 651 static int do_rename_gpt_parts(struct blk_desc *dev_desc, char *subcomm,
 652                                char *name1, char *name2)
 653 {
 654         struct list_head *pos;
 655         struct disk_part *curr;
 656         disk_partition_t *new_partitions = NULL;
 657         char disk_guid[UUID_STR_LEN + 1];
 658         char *partitions_list, *str_disk_guid;
 659         u8 part_count = 0;
 660         int partlistlen, ret, numparts = 0, partnum, i = 1, ctr1 = 0, ctr2 = 0;
 661
 662         if ((subcomm == NULL) || (name1 == NULL) || (name2 == NULL) ||
 663             (strcmp(subcomm, "swap") && (strcmp(subcomm, "rename"))))
 664                 return -EINVAL;
 665
 666         ret = get_disk_guid(dev_desc, disk_guid);
 667         if (ret < 0)
 668                 return ret;
 669         /*
 670          * Allocates disk_partitions, requiring matching call to del_gpt_info()
 671          * if successful.
 672          */
 673         numparts = get_gpt_info(dev_desc);
 674         if (numparts <=  0)
 675                 return numparts ? numparts : -ENODEV;
 676
 677         partlistlen = calc_parts_list_len(numparts);
 678         partitions_list = malloc(partlistlen);
 679         if (!partitions_list) {
 680                 del_gpt_info();
 681                 return -ENOMEM;
 682         }
 683         memset(partitions_list, '\0', partlistlen);
 684
 685         ret = create_gpt_partitions_list(numparts, disk_guid, partitions_list);
 686         if (ret < 0) {
 687                 free(partitions_list);
 688                 return ret;
 689         }
 690         /*
 691          * Uncomment the following line to print a string that 'gpt write'
 692          * or 'gpt verify' will accept as input.
 693          */
 694         debug("OLD partitions_list is %s with %u chars\n", partitions_list,
 695               (unsigned)strlen(partitions_list));
 696
 697         /* set_gpt_info allocates new_partitions and str_disk_guid */
 698         ret = set_gpt_info(dev_desc, partitions_list, &str_disk_guid,
 699                            &new_partitions, &part_count);
 700         if (ret < 0) {
 701                 del_gpt_info();
 702                 free(partitions_list);
 703                 if (ret == -ENOMEM)
 704                         set_gpt_cleanup(&str_disk_guid, &new_partitions);
 705                 else
 706                         goto out;
 707         }
 708
 709         if (!strcmp(subcomm, "swap")) {
 710                 if ((strlen(name1) > PART_NAME_LEN) || (strlen(name2) > PART_NAME_LEN)) {
 711                         printf("Names longer than %d characters are truncated.\n", PART_NAME_LEN);
 712                         ret = -EINVAL;
 713                         goto out;
 714                 }
 715                 list_for_each(pos, &disk_partitions) {
 716                         curr = list_entry(pos, struct disk_part, list);
 717                         if (!strcmp((char *)curr->gpt_part_info.name, name1)) {
 718                                 strcpy((char *)curr->gpt_part_info.name, name2);
 719                                 ctr1++;
 720                         } else if (!strcmp((char *)curr->gpt_part_info.name, name2)) {
 721                                 strcpy((char *)curr->gpt_part_info.name, name1);
 722                                 ctr2++;
 723                         }
 724                 }
 725                 if ((ctr1 + ctr2 < 2) || (ctr1 != ctr2)) {
 726                         printf("Cannot swap partition names except in pairs.\n");
 727                         ret = -EINVAL;
 728                         goto out;
 729                 }
 730         } else { /* rename */
 731                 if (strlen(name2) > PART_NAME_LEN) {
 732                         printf("Names longer than %d characters are truncated.\n", PART_NAME_LEN);
 733                         ret = -EINVAL;
 734                         goto out;
 735                 }
 736                 partnum = (int)simple_strtol(name1, NULL, 10);
 737                 if ((partnum < 0) || (partnum > numparts)) {
 738                         printf("Illegal partition number %s\n", name1);
 739                         ret = -EINVAL;
 740                         goto out;
 741                 }
 742                 ret = part_get_info(dev_desc, partnum, new_partitions);
 743                 if (ret < 0)
 744                         goto out;
 745
 746                 /* U-Boot partition numbering starts at 1 */
 747                 list_for_each(pos, &disk_partitions) {
 748                         curr = list_entry(pos, struct disk_part, list);
 749                         if (i == partnum) {
 750                                 strcpy((char *)curr->gpt_part_info.name, name2);
 751                                 break;
 752                         }
 753                         i++;
 754                 }
 755         }
 756
 757         ret = create_gpt_partitions_list(numparts, disk_guid, partitions_list);
 758         if (ret < 0)
 759                 goto out;
 760         debug("NEW partitions_list is %s with %u chars\n", partitions_list,
 761               (unsigned)strlen(partitions_list));
 762
 763         ret = set_gpt_info(dev_desc, partitions_list, &str_disk_guid,
 764                            &new_partitions, &part_count);
 765         /*
 766          * Even though valid pointers are here passed into set_gpt_info(),
 767          * it mallocs again, and there's no way to tell which failed.
 768          */
 769         if (ret < 0) {
 770                 del_gpt_info();
 771                 free(partitions_list);
 772                 if (ret == -ENOMEM)
 773                         set_gpt_cleanup(&str_disk_guid, &new_partitions);
 774                 else
 775                         goto out;
 776         }
 777
 778         debug("Writing new partition table\n");
 779         ret = gpt_restore(dev_desc, disk_guid, new_partitions, numparts);
 780         if (ret < 0) {
 781                 printf("Writing new partition table failed\n");
 782                 goto out;
 783         }
 784
 785         debug("Reading back new partition table\n");
 786         /*
 787          * Empty the existing disk_partitions list, as otherwise the memory in
 788          * the original list is unreachable.
 789          */
 790         del_gpt_info();
 791         numparts = get_gpt_info(dev_desc);
 792         if (numparts <=  0) {
 793                 ret = numparts ? numparts : -ENODEV;
 794                 goto out;
 795         }
 796         printf("new partition table with %d partitions is:\n", numparts);
 797         print_gpt_info();
 798         del_gpt_info();
 799  out:
 800         free(new_partitions);
 801         free(str_disk_guid);
 802         free(partitions_list);
 803         return ret;
 804 }
 805 #endif
 806
 807 /**
 808  * do_gpt(): Perform GPT operations
 809  *
 810  * @param cmdtp - command name
 811  * @param flag
 812  * @param argc
 813  * @param argv
 814  *
 815  * @return zero on success; otherwise error
 816  */
 817 static int do_gpt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 818 {
 819         int ret = CMD_RET_SUCCESS;
 820         int dev = 0;
 821         char *ep;
 822         struct blk_desc *blk_dev_desc = NULL;
 823
 824 #ifndef CONFIG_CMD_GPT_RENAME
 825         if (argc < 4 || argc > 5)
 826 #else
 827         if (argc < 4 || argc > 6)
 828 #endif
 829                 return CMD_RET_USAGE;
 830
 831         dev = (int)simple_strtoul(argv[3], &ep, 10);
 832         if (!ep || ep[0] != '\0') {
 833                 printf("'%s' is not a number\n", argv[3]);
 834                 return CMD_RET_USAGE;
 835         }
 836         blk_dev_desc = blk_get_dev(argv[2], dev);
 837         if (!blk_dev_desc) {
 838                 printf("%s: %s dev %d NOT available\n",
 839                        __func__, argv[2], dev);
 840                 return CMD_RET_FAILURE;
 841         }
 842
 843         if ((strcmp(argv[1], "write") == 0) && (argc == 5)) {
 844                 printf("Writing GPT: ");
 845                 ret = gpt_default(blk_dev_desc, argv[4]);
 846         } else if ((strcmp(argv[1], "verify") == 0)) {
 847                 ret = gpt_verify(blk_dev_desc, argv[4]);
 848                 printf("Verify GPT: ");
 849         } else if (strcmp(argv[1], "guid") == 0) {
 850                 ret = do_disk_guid(blk_dev_desc, argv[4]);
 851 #ifdef CONFIG_CMD_GPT_RENAME
 852         } else if (strcmp(argv[1], "read") == 0) {
 853                 ret = do_get_gpt_info(blk_dev_desc);
 854         } else if ((strcmp(argv[1], "swap") == 0) ||
 855                    (strcmp(argv[1], "rename") == 0)) {
 856                 ret = do_rename_gpt_parts(blk_dev_desc, argv[1], argv[4], argv[5]);
 857 #endif
 858         } else {
 859                 return CMD_RET_USAGE;
 860         }
 861
 862         if (ret) {
 863                 printf("error!\n");
 864                 return CMD_RET_FAILURE;
 865         }
 866
 867         printf("success!\n");
 868         return CMD_RET_SUCCESS;
 869 }
 870
 871 U_BOOT_CMD(gpt, CONFIG_SYS_MAXARGS, 1, do_gpt,
 872         "GUID Partition Table",
 873         "<command> <interface> <dev> <partitions_list>\n"
 874         " - GUID partition table restoration and validity check\n"
 875         " Restore or verify GPT information on a device connected\n"
 876         " to interface\n"
 877         " Example usage:\n"
 878         " gpt write mmc 0 $partitions\n"
 879         " gpt verify mmc 0 $partitions\n"
 880         " read <interface> <dev>\n"
 881         "    - read GPT into a data structure for manipulation\n"
 882         " guid <interface> <dev>\n"
 883         "    - print disk GUID\n"
 884         " guid <interface> <dev> <varname>\n"
 885         "    - set environment variable to disk GUID\n"
 886         " Example usage:\n"
 887         " gpt guid mmc 0\n"
 888         " gpt guid mmc 0 varname\n"
 889 #ifdef CONFIG_CMD_GPT_RENAME
 890         "gpt partition renaming commands:\n"
 891         "gpt swap <interface> <dev> <name1> <name2>\n"
 892         "    - change all partitions named name1 to name2\n"
 893         "      and vice-versa\n"
 894         "gpt rename <interface> <dev> <part> <name>\n"
 895         "    - rename the specified partition\n"
 896         " Example usage:\n"
 897         " gpt swap mmc 0 foo bar\n"
 898         " gpt rename mmc 0 3 foo\n"
 899 #endif
 900 );