cmd/gpt.c

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