uboot/disk/part_efi.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (C) 2008 RuggedCom, Inc.
   4 * Richard Retanubun <RichardRetanubun@RuggedCom.com>
   5 */
   6
   7/*
   8 * NOTE:
   9 *   when CONFIG_SYS_64BIT_LBA is not defined, lbaint_t is 32 bits; this
  10 *   limits the maximum size of addressable storage to < 2 Terra Bytes
  11 */
  12#include <asm/unaligned.h>
  13#include <common.h>
  14#include <command.h>
  15#include <fdtdec.h>
  16#include <ide.h>
  17#include <malloc.h>
  18#include <memalign.h>
  19#include <part_efi.h>
  20#include <linux/compiler.h>
  21#include <linux/ctype.h>
  22#include <u-boot/crc.h>
  23
  24DECLARE_GLOBAL_DATA_PTR;
  25
  26/*
  27 * GUID for basic data partions.
  28 */
  29static const efi_guid_t partition_basic_data_guid = PARTITION_BASIC_DATA_GUID;
  30
  31#ifdef CONFIG_HAVE_BLOCK_DEVICE
  32/**
  33 * efi_crc32() - EFI version of crc32 function
  34 * @buf: buffer to calculate crc32 of
  35 * @len - length of buf
  36 *
  37 * Description: Returns EFI-style CRC32 value for @buf
  38 */
  39static inline u32 efi_crc32(const void *buf, u32 len)
  40{
  41        return crc32(0, buf, len);
  42}
  43
  44/*
  45 * Private function prototypes
  46 */
  47
  48static int pmbr_part_valid(struct partition *part);
  49static int is_pmbr_valid(legacy_mbr * mbr);
  50static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
  51                                gpt_header *pgpt_head, gpt_entry **pgpt_pte);
  52static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
  53                                         gpt_header *pgpt_head);
  54static int is_pte_valid(gpt_entry * pte);
  55static int find_valid_gpt(struct blk_desc *dev_desc, gpt_header *gpt_head,
  56                          gpt_entry **pgpt_pte);
  57
  58static char *print_efiname(gpt_entry *pte)
  59{
  60        static char name[PARTNAME_SZ + 1];
  61        int i;
  62        for (i = 0; i < PARTNAME_SZ; i++) {
  63                u8 c;
  64                c = pte->partition_name[i] & 0xff;
  65                c = (c && !isprint(c)) ? '.' : c;
  66                name[i] = c;
  67        }
  68        name[PARTNAME_SZ] = 0;
  69        return name;
  70}
  71
  72static const efi_guid_t system_guid = PARTITION_SYSTEM_GUID;
  73
  74static inline int is_bootable(gpt_entry *p)
  75{
  76        return p->attributes.fields.legacy_bios_bootable ||
  77                !memcmp(&(p->partition_type_guid), &system_guid,
  78                        sizeof(efi_guid_t));
  79}
  80
  81static int validate_gpt_header(gpt_header *gpt_h, lbaint_t lba,
  82                lbaint_t lastlba)
  83{
  84        uint32_t crc32_backup = 0;
  85        uint32_t calc_crc32;
  86
  87        /* Check the GPT header signature */
  88        if (le64_to_cpu(gpt_h->signature) != GPT_HEADER_SIGNATURE_UBOOT) {
  89                printf("%s signature is wrong: 0x%llX != 0x%llX\n",
  90                       "GUID Partition Table Header",
  91                       le64_to_cpu(gpt_h->signature),
  92                       GPT_HEADER_SIGNATURE_UBOOT);
  93                return -1;
  94        }
  95
  96        /* Check the GUID Partition Table CRC */
  97        memcpy(&crc32_backup, &gpt_h->header_crc32, sizeof(crc32_backup));
  98        memset(&gpt_h->header_crc32, 0, sizeof(gpt_h->header_crc32));
  99
 100        calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
 101                le32_to_cpu(gpt_h->header_size));
 102
 103        memcpy(&gpt_h->header_crc32, &crc32_backup, sizeof(crc32_backup));
 104
 105        if (calc_crc32 != le32_to_cpu(crc32_backup)) {
 106                printf("%s CRC is wrong: 0x%x != 0x%x\n",
 107                       "GUID Partition Table Header",
 108                       le32_to_cpu(crc32_backup), calc_crc32);
 109                return -1;
 110        }
 111
 112        /*
 113         * Check that the my_lba entry points to the LBA that contains the GPT
 114         */
 115        if (le64_to_cpu(gpt_h->my_lba) != lba) {
 116                printf("GPT: my_lba incorrect: %llX != " LBAF "\n",
 117                       le64_to_cpu(gpt_h->my_lba),
 118                       lba);
 119                return -1;
 120        }
 121
 122        /*
 123         * Check that the first_usable_lba and that the last_usable_lba are
 124         * within the disk.
 125         */
 126        if (le64_to_cpu(gpt_h->first_usable_lba) > lastlba) {
 127                printf("GPT: first_usable_lba incorrect: %llX > " LBAF "\n",
 128                       le64_to_cpu(gpt_h->first_usable_lba), lastlba);
 129                return -1;
 130        }
 131        if (le64_to_cpu(gpt_h->last_usable_lba) > lastlba) {
 132                printf("GPT: last_usable_lba incorrect: %llX > " LBAF "\n",
 133                       le64_to_cpu(gpt_h->last_usable_lba), lastlba);
 134                return -1;
 135        }
 136
 137        debug("GPT: first_usable_lba: %llX last_usable_lba: %llX last lba: "
 138              LBAF "\n", le64_to_cpu(gpt_h->first_usable_lba),
 139              le64_to_cpu(gpt_h->last_usable_lba), lastlba);
 140
 141        return 0;
 142}
 143
 144static int validate_gpt_entries(gpt_header *gpt_h, gpt_entry *gpt_e)
 145{
 146        uint32_t calc_crc32;
 147
 148        /* Check the GUID Partition Table Entry Array CRC */
 149        calc_crc32 = efi_crc32((const unsigned char *)gpt_e,
 150                le32_to_cpu(gpt_h->num_partition_entries) *
 151                le32_to_cpu(gpt_h->sizeof_partition_entry));
 152
 153        if (calc_crc32 != le32_to_cpu(gpt_h->partition_entry_array_crc32)) {
 154                printf("%s: 0x%x != 0x%x\n",
 155                       "GUID Partition Table Entry Array CRC is wrong",
 156                       le32_to_cpu(gpt_h->partition_entry_array_crc32),
 157                       calc_crc32);
 158                return -1;
 159        }
 160
 161        return 0;
 162}
 163
 164static void prepare_backup_gpt_header(gpt_header *gpt_h)
 165{
 166        uint32_t calc_crc32;
 167        uint64_t val;
 168
 169        /* recalculate the values for the Backup GPT Header */
 170        val = le64_to_cpu(gpt_h->my_lba);
 171        gpt_h->my_lba = gpt_h->alternate_lba;
 172        gpt_h->alternate_lba = cpu_to_le64(val);
 173        gpt_h->partition_entry_lba =
 174                        cpu_to_le64(le64_to_cpu(gpt_h->last_usable_lba) + 1);
 175        gpt_h->header_crc32 = 0;
 176
 177        calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
 178                               le32_to_cpu(gpt_h->header_size));
 179        gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
 180}
 181
 182#if CONFIG_IS_ENABLED(EFI_PARTITION)
 183/*
 184 * Public Functions (include/part.h)
 185 */
 186
 187/*
 188 * UUID is displayed as 32 hexadecimal digits, in 5 groups,
 189 * separated by hyphens, in the form 8-4-4-4-12 for a total of 36 characters
 190 */
 191int get_disk_guid(struct blk_desc * dev_desc, char *guid)
 192{
 193        ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
 194        gpt_entry *gpt_pte = NULL;
 195        unsigned char *guid_bin;
 196
 197        /* This function validates AND fills in the GPT header and PTE */
 198        if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
 199                return -EINVAL;
 200
 201        guid_bin = gpt_head->disk_guid.b;
 202        uuid_bin_to_str(guid_bin, guid, UUID_STR_FORMAT_GUID);
 203
 204        /* Remember to free pte */
 205        free(gpt_pte);
 206        return 0;
 207}
 208
 209void part_print_efi(struct blk_desc *dev_desc)
 210{
 211        ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
 212        gpt_entry *gpt_pte = NULL;
 213        int i = 0;
 214        char uuid[UUID_STR_LEN + 1];
 215        unsigned char *uuid_bin;
 216
 217        /* This function validates AND fills in the GPT header and PTE */
 218        if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
 219                return;
 220
 221        debug("%s: gpt-entry at %p\n", __func__, gpt_pte);
 222
 223        printf("Part\tStart LBA\tEnd LBA\t\tName\n");
 224        printf("\tAttributes\n");
 225        printf("\tType GUID\n");
 226        printf("\tPartition GUID\n");
 227
 228        for (i = 0; i < le32_to_cpu(gpt_head->num_partition_entries); i++) {
 229                /* Stop at the first non valid PTE */
 230                if (!is_pte_valid(&gpt_pte[i]))
 231                        break;
 232
 233                printf("%3d\t0x%08llx\t0x%08llx\t\"%s\"\n", (i + 1),
 234                        le64_to_cpu(gpt_pte[i].starting_lba),
 235                        le64_to_cpu(gpt_pte[i].ending_lba),
 236                        print_efiname(&gpt_pte[i]));
 237                printf("\tattrs:\t0x%016llx\n", gpt_pte[i].attributes.raw);
 238                uuid_bin = (unsigned char *)gpt_pte[i].partition_type_guid.b;
 239                uuid_bin_to_str(uuid_bin, uuid, UUID_STR_FORMAT_GUID);
 240                printf("\ttype:\t%s\n", uuid);
 241#ifdef CONFIG_PARTITION_TYPE_GUID
 242                if (!uuid_guid_get_str(uuid_bin, uuid))
 243                        printf("\ttype:\t%s\n", uuid);
 244#endif
 245                uuid_bin = (unsigned char *)gpt_pte[i].unique_partition_guid.b;
 246                uuid_bin_to_str(uuid_bin, uuid, UUID_STR_FORMAT_GUID);
 247                printf("\tguid:\t%s\n", uuid);
 248        }
 249
 250        /* Remember to free pte */
 251        free(gpt_pte);
 252        return;
 253}
 254
 255int part_get_info_efi(struct blk_desc *dev_desc, int part,
 256                      disk_partition_t *info)
 257{
 258        ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
 259        gpt_entry *gpt_pte = NULL;
 260
 261        /* "part" argument must be at least 1 */
 262        if (part < 1) {
 263                printf("%s: Invalid Argument(s)\n", __func__);
 264                return -1;
 265        }
 266
 267        /* This function validates AND fills in the GPT header and PTE */
 268        if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
 269                return -1;
 270
 271        if (part > le32_to_cpu(gpt_head->num_partition_entries) ||
 272            !is_pte_valid(&gpt_pte[part - 1])) {
 273                debug("%s: *** ERROR: Invalid partition number %d ***\n",
 274                        __func__, part);
 275                free(gpt_pte);
 276                return -1;
 277        }
 278
 279        /* The 'lbaint_t' casting may limit the maximum disk size to 2 TB */
 280        info->start = (lbaint_t)le64_to_cpu(gpt_pte[part - 1].starting_lba);
 281        /* The ending LBA is inclusive, to calculate size, add 1 to it */
 282        info->size = (lbaint_t)le64_to_cpu(gpt_pte[part - 1].ending_lba) + 1
 283                     - info->start;
 284        info->blksz = dev_desc->blksz;
 285
 286        snprintf((char *)info->name, sizeof(info->name), "%s",
 287                 print_efiname(&gpt_pte[part - 1]));
 288        strcpy((char *)info->type, "U-Boot");
 289        info->bootable = is_bootable(&gpt_pte[part - 1]);
 290#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
 291        uuid_bin_to_str(gpt_pte[part - 1].unique_partition_guid.b, info->uuid,
 292                        UUID_STR_FORMAT_GUID);
 293#endif
 294#ifdef CONFIG_PARTITION_TYPE_GUID
 295        uuid_bin_to_str(gpt_pte[part - 1].partition_type_guid.b,
 296                        info->type_guid, UUID_STR_FORMAT_GUID);
 297#endif
 298
 299        debug("%s: start 0x" LBAF ", size 0x" LBAF ", name %s\n", __func__,
 300              info->start, info->size, info->name);
 301
 302        /* Remember to free pte */
 303        free(gpt_pte);
 304        return 0;
 305}
 306
 307static int part_test_efi(struct blk_desc *dev_desc)
 308{
 309        ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, legacymbr, 1, dev_desc->blksz);
 310
 311        /* Read legacy MBR from block 0 and validate it */
 312        if ((blk_dread(dev_desc, 0, 1, (ulong *)legacymbr) != 1)
 313                || (is_pmbr_valid(legacymbr) != 1)) {
 314                return -1;
 315        }
 316        return 0;
 317}
 318
 319/**
 320 * set_protective_mbr(): Set the EFI protective MBR
 321 * @param dev_desc - block device descriptor
 322 *
 323 * @return - zero on success, otherwise error
 324 */
 325static int set_protective_mbr(struct blk_desc *dev_desc)
 326{
 327        /* Setup the Protective MBR */
 328        ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, p_mbr, 1, dev_desc->blksz);
 329        if (p_mbr == NULL) {
 330                printf("%s: calloc failed!\n", __func__);
 331                return -1;
 332        }
 333
 334        /* Read MBR to backup boot code if it exists */
 335        if (blk_dread(dev_desc, 0, 1, p_mbr) != 1) {
 336                pr_err("** Can't read from device %d **\n", dev_desc->devnum);
 337                return -1;
 338        }
 339
 340        /* Clear all data in MBR except of backed up boot code */
 341        memset((char *)p_mbr + MSDOS_MBR_BOOT_CODE_SIZE, 0, sizeof(*p_mbr) -
 342                        MSDOS_MBR_BOOT_CODE_SIZE);
 343
 344        /* Append signature */
 345        p_mbr->signature = MSDOS_MBR_SIGNATURE;
 346        p_mbr->partition_record[0].sys_ind = EFI_PMBR_OSTYPE_EFI_GPT;
 347        p_mbr->partition_record[0].start_sect = 1;
 348        p_mbr->partition_record[0].nr_sects = (u32) dev_desc->lba - 1;
 349
 350        /* Write MBR sector to the MMC device */
 351        if (blk_dwrite(dev_desc, 0, 1, p_mbr) != 1) {
 352                printf("** Can't write to device %d **\n",
 353                        dev_desc->devnum);
 354                return -1;
 355        }
 356
 357        return 0;
 358}
 359
 360int write_gpt_table(struct blk_desc *dev_desc,
 361                gpt_header *gpt_h, gpt_entry *gpt_e)
 362{
 363        const int pte_blk_cnt = BLOCK_CNT((gpt_h->num_partition_entries
 364                                           * sizeof(gpt_entry)), dev_desc);
 365        u32 calc_crc32;
 366
 367        debug("max lba: %x\n", (u32) dev_desc->lba);
 368        /* Setup the Protective MBR */
 369        if (set_protective_mbr(dev_desc) < 0)
 370                goto err;
 371
 372        /* Generate CRC for the Primary GPT Header */
 373        calc_crc32 = efi_crc32((const unsigned char *)gpt_e,
 374                              le32_to_cpu(gpt_h->num_partition_entries) *
 375                              le32_to_cpu(gpt_h->sizeof_partition_entry));
 376        gpt_h->partition_entry_array_crc32 = cpu_to_le32(calc_crc32);
 377
 378        calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
 379                              le32_to_cpu(gpt_h->header_size));
 380        gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
 381
 382        /* Write the First GPT to the block right after the Legacy MBR */
 383        if (blk_dwrite(dev_desc, 1, 1, gpt_h) != 1)
 384                goto err;
 385
 386        if (blk_dwrite(dev_desc, le64_to_cpu(gpt_h->partition_entry_lba),
 387                       pte_blk_cnt, gpt_e) != pte_blk_cnt)
 388                goto err;
 389
 390        prepare_backup_gpt_header(gpt_h);
 391
 392        if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->last_usable_lba)
 393                       + 1, pte_blk_cnt, gpt_e) != pte_blk_cnt)
 394                goto err;
 395
 396        if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->my_lba), 1,
 397                       gpt_h) != 1)
 398                goto err;
 399
 400        debug("GPT successfully written to block device!\n");
 401        return 0;
 402
 403 err:
 404        printf("** Can't write to device %d **\n", dev_desc->devnum);
 405        return -1;
 406}
 407
 408int gpt_fill_pte(struct blk_desc *dev_desc,
 409                 gpt_header *gpt_h, gpt_entry *gpt_e,
 410                 disk_partition_t *partitions, int parts)
 411{
 412        lbaint_t offset = (lbaint_t)le64_to_cpu(gpt_h->first_usable_lba);
 413        lbaint_t last_usable_lba = (lbaint_t)
 414                        le64_to_cpu(gpt_h->last_usable_lba);
 415        int i, k;
 416        size_t efiname_len, dosname_len;
 417#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
 418        char *str_uuid;
 419        unsigned char *bin_uuid;
 420#endif
 421#ifdef CONFIG_PARTITION_TYPE_GUID
 422        char *str_type_guid;
 423        unsigned char *bin_type_guid;
 424#endif
 425        size_t hdr_start = gpt_h->my_lba;
 426        size_t hdr_end = hdr_start + 1;
 427
 428        size_t pte_start = gpt_h->partition_entry_lba;
 429        size_t pte_end = pte_start +
 430                gpt_h->num_partition_entries * gpt_h->sizeof_partition_entry /
 431                dev_desc->blksz;
 432
 433        for (i = 0; i < parts; i++) {
 434                /* partition starting lba */
 435                lbaint_t start = partitions[i].start;
 436                lbaint_t size = partitions[i].size;
 437
 438                if (start) {
 439                        offset = start + size;
 440                } else {
 441                        start = offset;
 442                        offset += size;
 443                }
 444
 445                /*
 446                 * If our partition overlaps with either the GPT
 447                 * header, or the partition entry, reject it.
 448                 */
 449                if (((start < hdr_end && hdr_start < (start + size)) ||
 450                     (start < pte_end && pte_start < (start + size)))) {
 451                        printf("Partition overlap\n");
 452                        return -1;
 453                }
 454
 455                gpt_e[i].starting_lba = cpu_to_le64(start);
 456
 457                if (offset > (last_usable_lba + 1)) {
 458                        printf("Partitions layout exceds disk size\n");
 459                        return -1;
 460                }
 461                /* partition ending lba */
 462                if ((i == parts - 1) && (size == 0))
 463                        /* extend the last partition to maximuim */
 464                        gpt_e[i].ending_lba = gpt_h->last_usable_lba;
 465                else
 466                        gpt_e[i].ending_lba = cpu_to_le64(offset - 1);
 467
 468#ifdef CONFIG_PARTITION_TYPE_GUID
 469                str_type_guid = partitions[i].type_guid;
 470                bin_type_guid = gpt_e[i].partition_type_guid.b;
 471                if (strlen(str_type_guid)) {
 472                        if (uuid_str_to_bin(str_type_guid, bin_type_guid,
 473                                            UUID_STR_FORMAT_GUID)) {
 474                                printf("Partition no. %d: invalid type guid: %s\n",
 475                                       i, str_type_guid);
 476                                return -1;
 477                        }
 478                } else {
 479                        /* default partition type GUID */
 480                        memcpy(bin_type_guid,
 481                               &partition_basic_data_guid, 16);
 482                }
 483#else
 484                /* partition type GUID */
 485                memcpy(gpt_e[i].partition_type_guid.b,
 486                        &partition_basic_data_guid, 16);
 487#endif
 488
 489#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
 490                str_uuid = partitions[i].uuid;
 491                bin_uuid = gpt_e[i].unique_partition_guid.b;
 492
 493                if (uuid_str_to_bin(str_uuid, bin_uuid, UUID_STR_FORMAT_GUID)) {
 494                        printf("Partition no. %d: invalid guid: %s\n",
 495                                i, str_uuid);
 496                        return -1;
 497                }
 498#endif
 499
 500                /* partition attributes */
 501                memset(&gpt_e[i].attributes, 0,
 502                       sizeof(gpt_entry_attributes));
 503
 504                if (partitions[i].bootable)
 505                        gpt_e[i].attributes.fields.legacy_bios_bootable = 1;
 506
 507                /* partition name */
 508                efiname_len = sizeof(gpt_e[i].partition_name)
 509                        / sizeof(efi_char16_t);
 510                dosname_len = sizeof(partitions[i].name);
 511
 512                memset(gpt_e[i].partition_name, 0,
 513                       sizeof(gpt_e[i].partition_name));
 514
 515                for (k = 0; k < min(dosname_len, efiname_len); k++)
 516                        gpt_e[i].partition_name[k] =
 517                                (efi_char16_t)(partitions[i].name[k]);
 518
 519                debug("%s: name: %s offset[%d]: 0x" LBAF
 520                      " size[%d]: 0x" LBAF "\n",
 521                      __func__, partitions[i].name, i,
 522                      offset, i, size);
 523        }
 524
 525        return 0;
 526}
 527
 528static uint32_t partition_entries_offset(struct blk_desc *dev_desc)
 529{
 530        uint32_t offset_blks = 2;
 531        uint32_t __maybe_unused offset_bytes;
 532        int __maybe_unused config_offset;
 533
 534#if defined(CONFIG_EFI_PARTITION_ENTRIES_OFF)
 535        /*
 536         * Some architectures require their SPL loader at a fixed
 537         * address within the first 16KB of the disk.  To avoid an
 538         * overlap with the partition entries of the EFI partition
 539         * table, the first safe offset (in bytes, from the start of
 540         * the disk) for the entries can be set in
 541         * CONFIG_EFI_PARTITION_ENTRIES_OFF.
 542         */
 543        offset_bytes =
 544                PAD_TO_BLOCKSIZE(CONFIG_EFI_PARTITION_ENTRIES_OFF, dev_desc);
 545        offset_blks = offset_bytes / dev_desc->blksz;
 546#endif
 547
 548#if defined(CONFIG_OF_CONTROL)
 549        /*
 550         * Allow the offset of the first partition entires (in bytes
 551         * from the start of the device) to be specified as a property
 552         * of the device tree '/config' node.
 553         */
 554        config_offset = fdtdec_get_config_int(gd->fdt_blob,
 555                                              "u-boot,efi-partition-entries-offset",
 556                                              -EINVAL);
 557        if (config_offset != -EINVAL) {
 558                offset_bytes = PAD_TO_BLOCKSIZE(config_offset, dev_desc);
 559                offset_blks = offset_bytes / dev_desc->blksz;
 560        }
 561#endif
 562
 563        debug("efi: partition entries offset (in blocks): %d\n", offset_blks);
 564
 565        /*
 566         * The earliest LBA this can be at is LBA#2 (i.e. right behind
 567         * the (protective) MBR and the GPT header.
 568         */
 569        if (offset_blks < 2)
 570                offset_blks = 2;
 571
 572        return offset_blks;
 573}
 574
 575int gpt_fill_header(struct blk_desc *dev_desc, gpt_header *gpt_h,
 576                char *str_guid, int parts_count)
 577{
 578        gpt_h->signature = cpu_to_le64(GPT_HEADER_SIGNATURE_UBOOT);
 579        gpt_h->revision = cpu_to_le32(GPT_HEADER_REVISION_V1);
 580        gpt_h->header_size = cpu_to_le32(sizeof(gpt_header));
 581        gpt_h->my_lba = cpu_to_le64(1);
 582        gpt_h->alternate_lba = cpu_to_le64(dev_desc->lba - 1);
 583        gpt_h->last_usable_lba = cpu_to_le64(dev_desc->lba - 34);
 584        gpt_h->partition_entry_lba =
 585                cpu_to_le64(partition_entries_offset(dev_desc));
 586        gpt_h->first_usable_lba =
 587                cpu_to_le64(le64_to_cpu(gpt_h->partition_entry_lba) + 32);
 588        gpt_h->num_partition_entries = cpu_to_le32(GPT_ENTRY_NUMBERS);
 589        gpt_h->sizeof_partition_entry = cpu_to_le32(sizeof(gpt_entry));
 590        gpt_h->header_crc32 = 0;
 591        gpt_h->partition_entry_array_crc32 = 0;
 592
 593        if (uuid_str_to_bin(str_guid, gpt_h->disk_guid.b, UUID_STR_FORMAT_GUID))
 594                return -1;
 595
 596        return 0;
 597}
 598
 599int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid,
 600                disk_partition_t *partitions, int parts_count)
 601{
 602        gpt_header *gpt_h;
 603        gpt_entry *gpt_e;
 604        int ret, size;
 605
 606        size = PAD_TO_BLOCKSIZE(sizeof(gpt_header), dev_desc);
 607        gpt_h = malloc_cache_aligned(size);
 608        if (gpt_h == NULL) {
 609                printf("%s: calloc failed!\n", __func__);
 610                return -1;
 611        }
 612        memset(gpt_h, 0, size);
 613
 614        size = PAD_TO_BLOCKSIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry),
 615                                dev_desc);
 616        gpt_e = malloc_cache_aligned(size);
 617        if (gpt_e == NULL) {
 618                printf("%s: calloc failed!\n", __func__);
 619                free(gpt_h);
 620                return -1;
 621        }
 622        memset(gpt_e, 0, size);
 623
 624        /* Generate Primary GPT header (LBA1) */
 625        ret = gpt_fill_header(dev_desc, gpt_h, str_disk_guid, parts_count);
 626        if (ret)
 627                goto err;
 628
 629        /* Generate partition entries */
 630        ret = gpt_fill_pte(dev_desc, gpt_h, gpt_e, partitions, parts_count);
 631        if (ret)
 632                goto err;
 633
 634        /* Write GPT partition table */
 635        ret = write_gpt_table(dev_desc, gpt_h, gpt_e);
 636
 637err:
 638        free(gpt_e);
 639        free(gpt_h);
 640        return ret;
 641}
 642
 643/**
 644 * gpt_convert_efi_name_to_char() - convert u16 string to char string
 645 *
 646 * TODO: this conversion only supports ANSI characters
 647 *
 648 * @s:  target buffer
 649 * @es: u16 string to be converted
 650 * @n:  size of target buffer
 651 */
 652static void gpt_convert_efi_name_to_char(char *s, void *es, int n)
 653{
 654        char *ess = es;
 655        int i, j;
 656
 657        memset(s, '\0', n);
 658
 659        for (i = 0, j = 0; j < n; i += 2, j++) {
 660                s[j] = ess[i];
 661                if (!ess[i])
 662                        return;
 663        }
 664}
 665
 666int gpt_verify_headers(struct blk_desc *dev_desc, gpt_header *gpt_head,
 667                       gpt_entry **gpt_pte)
 668{
 669        /*
 670         * This function validates AND
 671         * fills in the GPT header and PTE
 672         */
 673        if (is_gpt_valid(dev_desc,
 674                         GPT_PRIMARY_PARTITION_TABLE_LBA,
 675                         gpt_head, gpt_pte) != 1) {
 676                printf("%s: *** ERROR: Invalid GPT ***\n",
 677                       __func__);
 678                return -1;
 679        }
 680
 681        /* Free pte before allocating again */
 682        free(*gpt_pte);
 683
 684        if (is_gpt_valid(dev_desc, (dev_desc->lba - 1),
 685                         gpt_head, gpt_pte) != 1) {
 686                printf("%s: *** ERROR: Invalid Backup GPT ***\n",
 687                       __func__);
 688                return -1;
 689        }
 690
 691        return 0;
 692}
 693
 694int gpt_verify_partitions(struct blk_desc *dev_desc,
 695                          disk_partition_t *partitions, int parts,
 696                          gpt_header *gpt_head, gpt_entry **gpt_pte)
 697{
 698        char efi_str[PARTNAME_SZ + 1];
 699        u64 gpt_part_size;
 700        gpt_entry *gpt_e;
 701        int ret, i;
 702
 703        ret = gpt_verify_headers(dev_desc, gpt_head, gpt_pte);
 704        if (ret)
 705                return ret;
 706
 707        gpt_e = *gpt_pte;
 708
 709        for (i = 0; i < parts; i++) {
 710                if (i == gpt_head->num_partition_entries) {
 711                        pr_err("More partitions than allowed!\n");
 712                        return -1;
 713                }
 714
 715                /* Check if GPT and ENV partition names match */
 716                gpt_convert_efi_name_to_char(efi_str, gpt_e[i].partition_name,
 717                                             PARTNAME_SZ + 1);
 718
 719                debug("%s: part: %2d name - GPT: %16s, ENV: %16s ",
 720                      __func__, i, efi_str, partitions[i].name);
 721
 722                if (strncmp(efi_str, (char *)partitions[i].name,
 723                            sizeof(partitions->name))) {
 724                        pr_err("Partition name: %s does not match %s!\n",
 725                              efi_str, (char *)partitions[i].name);
 726                        return -1;
 727                }
 728
 729                /* Check if GPT and ENV sizes match */
 730                gpt_part_size = le64_to_cpu(gpt_e[i].ending_lba) -
 731                        le64_to_cpu(gpt_e[i].starting_lba) + 1;
 732                debug("size(LBA) - GPT: %8llu, ENV: %8llu ",
 733                      (unsigned long long)gpt_part_size,
 734                      (unsigned long long)partitions[i].size);
 735
 736                if (le64_to_cpu(gpt_part_size) != partitions[i].size) {
 737                        /* We do not check the extend partition size */
 738                        if ((i == parts - 1) && (partitions[i].size == 0))
 739                                continue;
 740
 741                        pr_err("Partition %s size: %llu does not match %llu!\n",
 742                              efi_str, (unsigned long long)gpt_part_size,
 743                              (unsigned long long)partitions[i].size);
 744                        return -1;
 745                }
 746
 747                /*
 748                 * Start address is optional - check only if provided
 749                 * in '$partition' variable
 750                 */
 751                if (!partitions[i].start) {
 752                        debug("\n");
 753                        continue;
 754                }
 755
 756                /* Check if GPT and ENV start LBAs match */
 757                debug("start LBA - GPT: %8llu, ENV: %8llu\n",
 758                      le64_to_cpu(gpt_e[i].starting_lba),
 759                      (unsigned long long)partitions[i].start);
 760
 761                if (le64_to_cpu(gpt_e[i].starting_lba) != partitions[i].start) {
 762                        pr_err("Partition %s start: %llu does not match %llu!\n",
 763                              efi_str, le64_to_cpu(gpt_e[i].starting_lba),
 764                              (unsigned long long)partitions[i].start);
 765                        return -1;
 766                }
 767        }
 768
 769        return 0;
 770}
 771
 772int is_valid_gpt_buf(struct blk_desc *dev_desc, void *buf)
 773{
 774        gpt_header *gpt_h;
 775        gpt_entry *gpt_e;
 776
 777        /* determine start of GPT Header in the buffer */
 778        gpt_h = buf + (GPT_PRIMARY_PARTITION_TABLE_LBA *
 779                       dev_desc->blksz);
 780        if (validate_gpt_header(gpt_h, GPT_PRIMARY_PARTITION_TABLE_LBA,
 781                                dev_desc->lba))
 782                return -1;
 783
 784        /* determine start of GPT Entries in the buffer */
 785        gpt_e = buf + (le64_to_cpu(gpt_h->partition_entry_lba) *
 786                       dev_desc->blksz);
 787        if (validate_gpt_entries(gpt_h, gpt_e))
 788                return -1;
 789
 790        return 0;
 791}
 792
 793int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
 794{
 795        gpt_header *gpt_h;
 796        gpt_entry *gpt_e;
 797        int gpt_e_blk_cnt;
 798        lbaint_t lba;
 799        int cnt;
 800
 801        if (is_valid_gpt_buf(dev_desc, buf))
 802                return -1;
 803
 804        /* determine start of GPT Header in the buffer */
 805        gpt_h = buf + (GPT_PRIMARY_PARTITION_TABLE_LBA *
 806                       dev_desc->blksz);
 807
 808        /* determine start of GPT Entries in the buffer */
 809        gpt_e = buf + (le64_to_cpu(gpt_h->partition_entry_lba) *
 810                       dev_desc->blksz);
 811        gpt_e_blk_cnt = BLOCK_CNT((le32_to_cpu(gpt_h->num_partition_entries) *
 812                                   le32_to_cpu(gpt_h->sizeof_partition_entry)),
 813                                  dev_desc);
 814
 815        /* write MBR */
 816        lba = 0;        /* MBR is always at 0 */
 817        cnt = 1;        /* MBR (1 block) */
 818        if (blk_dwrite(dev_desc, lba, cnt, buf) != cnt) {
 819                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
 820                       __func__, "MBR", cnt, lba);
 821                return 1;
 822        }
 823
 824        /* write Primary GPT */
 825        lba = GPT_PRIMARY_PARTITION_TABLE_LBA;
 826        cnt = 1;        /* GPT Header (1 block) */
 827        if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) {
 828                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
 829                       __func__, "Primary GPT Header", cnt, lba);
 830                return 1;
 831        }
 832
 833        lba = le64_to_cpu(gpt_h->partition_entry_lba);
 834        cnt = gpt_e_blk_cnt;
 835        if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) {
 836                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
 837                       __func__, "Primary GPT Entries", cnt, lba);
 838                return 1;
 839        }
 840
 841        prepare_backup_gpt_header(gpt_h);
 842
 843        /* write Backup GPT */
 844        lba = le64_to_cpu(gpt_h->partition_entry_lba);
 845        cnt = gpt_e_blk_cnt;
 846        if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) {
 847                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
 848                       __func__, "Backup GPT Entries", cnt, lba);
 849                return 1;
 850        }
 851
 852        lba = le64_to_cpu(gpt_h->my_lba);
 853        cnt = 1;        /* GPT Header (1 block) */
 854        if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) {
 855                printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
 856                       __func__, "Backup GPT Header", cnt, lba);
 857                return 1;
 858        }
 859
 860        return 0;
 861}
 862#endif
 863
 864/*
 865 * Private functions
 866 */
 867/*
 868 * pmbr_part_valid(): Check for EFI partition signature
 869 *
 870 * Returns: 1 if EFI GPT partition type is found.
 871 */
 872static int pmbr_part_valid(struct partition *part)
 873{
 874        if (part->sys_ind == EFI_PMBR_OSTYPE_EFI_GPT &&
 875                get_unaligned_le32(&part->start_sect) == 1UL) {
 876                return 1;
 877        }
 878
 879        return 0;
 880}
 881
 882/*
 883 * is_pmbr_valid(): test Protective MBR for validity
 884 *
 885 * Returns: 1 if PMBR is valid, 0 otherwise.
 886 * Validity depends on two things:
 887 *  1) MSDOS signature is in the last two bytes of the MBR
 888 *  2) One partition of type 0xEE is found, checked by pmbr_part_valid()
 889 */
 890static int is_pmbr_valid(legacy_mbr * mbr)
 891{
 892        int i = 0;
 893
 894        if (!mbr || le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE)
 895                return 0;
 896
 897        for (i = 0; i < 4; i++) {
 898                if (pmbr_part_valid(&mbr->partition_record[i])) {
 899                        return 1;
 900                }
 901        }
 902        return 0;
 903}
 904
 905/**
 906 * is_gpt_valid() - tests one GPT header and PTEs for validity
 907 *
 908 * lba is the logical block address of the GPT header to test
 909 * gpt is a GPT header ptr, filled on return.
 910 * ptes is a PTEs ptr, filled on return.
 911 *
 912 * Description: returns 1 if valid,  0 on error, 2 if ignored header
 913 * If valid, returns pointers to PTEs.
 914 */
 915static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
 916                        gpt_header *pgpt_head, gpt_entry **pgpt_pte)
 917{
 918        /* Confirm valid arguments prior to allocation. */
 919        if (!dev_desc || !pgpt_head) {
 920                printf("%s: Invalid Argument(s)\n", __func__);
 921                return 0;
 922        }
 923
 924        ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, mbr, 1, dev_desc->blksz);
 925
 926        /* Read MBR Header from device */
 927        if (blk_dread(dev_desc, 0, 1, (ulong *)mbr) != 1) {
 928                printf("*** ERROR: Can't read MBR header ***\n");
 929                return 0;
 930        }
 931
 932        /* Read GPT Header from device */
 933        if (blk_dread(dev_desc, (lbaint_t)lba, 1, pgpt_head) != 1) {
 934                printf("*** ERROR: Can't read GPT header ***\n");
 935                return 0;
 936        }
 937
 938        /* Invalid but nothing to yell about. */
 939        if (le64_to_cpu(pgpt_head->signature) == GPT_HEADER_CHROMEOS_IGNORE) {
 940                debug("ChromeOS 'IGNOREME' GPT header found and ignored\n");
 941                return 2;
 942        }
 943
 944        if (validate_gpt_header(pgpt_head, (lbaint_t)lba, dev_desc->lba))
 945                return 0;
 946
 947        if (dev_desc->sig_type == SIG_TYPE_NONE) {
 948                efi_guid_t empty = {};
 949                if (memcmp(&pgpt_head->disk_guid, &empty, sizeof(empty))) {
 950                        dev_desc->sig_type = SIG_TYPE_GUID;
 951                        memcpy(&dev_desc->guid_sig, &pgpt_head->disk_guid,
 952                              sizeof(empty));
 953                } else if (mbr->unique_mbr_signature != 0) {
 954                        dev_desc->sig_type = SIG_TYPE_MBR;
 955                        dev_desc->mbr_sig = mbr->unique_mbr_signature;
 956                }
 957        }
 958
 959        /* Read and allocate Partition Table Entries */
 960        *pgpt_pte = alloc_read_gpt_entries(dev_desc, pgpt_head);
 961        if (*pgpt_pte == NULL) {
 962                printf("GPT: Failed to allocate memory for PTE\n");
 963                return 0;
 964        }
 965
 966        if (validate_gpt_entries(pgpt_head, *pgpt_pte)) {
 967                free(*pgpt_pte);
 968                return 0;
 969        }
 970
 971        /* We're done, all's well */
 972        return 1;
 973}
 974
 975/**
 976 * find_valid_gpt() - finds a valid GPT header and PTEs
 977 *
 978 * gpt is a GPT header ptr, filled on return.
 979 * ptes is a PTEs ptr, filled on return.
 980 *
 981 * Description: returns 1 if found a valid gpt,  0 on error.
 982 * If valid, returns pointers to PTEs.
 983 */
 984static int find_valid_gpt(struct blk_desc *dev_desc, gpt_header *gpt_head,
 985                          gpt_entry **pgpt_pte)
 986{
 987        int r;
 988
 989        r = is_gpt_valid(dev_desc, GPT_PRIMARY_PARTITION_TABLE_LBA, gpt_head,
 990                         pgpt_pte);
 991
 992        if (r != 1) {
 993                if (r != 2)
 994                        printf("%s: *** ERROR: Invalid GPT ***\n", __func__);
 995
 996                if (is_gpt_valid(dev_desc, (dev_desc->lba - 1), gpt_head,
 997                                 pgpt_pte) != 1) {
 998                        printf("%s: *** ERROR: Invalid Backup GPT ***\n",
 999                               __func__);
1000                        return 0;
1001                }
1002                if (r != 2)
1003                        printf("%s: ***        Using Backup GPT ***\n",
1004                               __func__);
1005        }
1006        return 1;
1007}
1008
1009/**
1010 * alloc_read_gpt_entries(): reads partition entries from disk
1011 * @dev_desc
1012 * @gpt - GPT header
1013 *
1014 * Description: Returns ptes on success,  NULL on error.
1015 * Allocates space for PTEs based on information found in @gpt.
1016 * Notes: remember to free pte when you're done!
1017 */
1018static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
1019                                         gpt_header *pgpt_head)
1020{
1021        size_t count = 0, blk_cnt;
1022        lbaint_t blk;
1023        gpt_entry *pte = NULL;
1024
1025        if (!dev_desc || !pgpt_head) {
1026                printf("%s: Invalid Argument(s)\n", __func__);
1027                return NULL;
1028        }
1029
1030        count = le32_to_cpu(pgpt_head->num_partition_entries) *
1031                le32_to_cpu(pgpt_head->sizeof_partition_entry);
1032
1033        debug("%s: count = %u * %u = %lu\n", __func__,
1034              (u32) le32_to_cpu(pgpt_head->num_partition_entries),
1035              (u32) le32_to_cpu(pgpt_head->sizeof_partition_entry),
1036              (ulong)count);
1037
1038        /* Allocate memory for PTE, remember to FREE */
1039        if (count != 0) {
1040                pte = memalign(ARCH_DMA_MINALIGN,
1041                               PAD_TO_BLOCKSIZE(count, dev_desc));
1042        }
1043
1044        if (count == 0 || pte == NULL) {
1045                printf("%s: ERROR: Can't allocate %#lX bytes for GPT Entries\n",
1046                       __func__, (ulong)count);
1047                return NULL;
1048        }
1049
1050        /* Read GPT Entries from device */
1051        blk = le64_to_cpu(pgpt_head->partition_entry_lba);
1052        blk_cnt = BLOCK_CNT(count, dev_desc);
1053        if (blk_dread(dev_desc, blk, (lbaint_t)blk_cnt, pte) != blk_cnt) {
1054                printf("*** ERROR: Can't read GPT Entries ***\n");
1055                free(pte);
1056                return NULL;
1057        }
1058        return pte;
1059}
1060
1061/**
1062 * is_pte_valid(): validates a single Partition Table Entry
1063 * @gpt_entry - Pointer to a single Partition Table Entry
1064 *
1065 * Description: returns 1 if valid,  0 on error.
1066 */
1067static int is_pte_valid(gpt_entry * pte)
1068{
1069        efi_guid_t unused_guid;
1070
1071        if (!pte) {
1072                printf("%s: Invalid Argument(s)\n", __func__);
1073                return 0;
1074        }
1075
1076        /* Only one validation for now:
1077         * The GUID Partition Type != Unused Entry (ALL-ZERO)
1078         */
1079        memset(unused_guid.b, 0, sizeof(unused_guid.b));
1080
1081        if (memcmp(pte->partition_type_guid.b, unused_guid.b,
1082                sizeof(unused_guid.b)) == 0) {
1083
1084                debug("%s: Found an unused PTE GUID at 0x%08X\n", __func__,
1085                      (unsigned int)(uintptr_t)pte);
1086
1087                return 0;
1088        } else {
1089                return 1;
1090        }
1091}
1092
1093/*
1094 * Add an 'a_' prefix so it comes before 'dos' in the linker list. We need to
1095 * check EFI first, since a DOS partition is often used as a 'protective MBR'
1096 * with EFI.
1097 */
1098U_BOOT_PART_TYPE(a_efi) = {
1099        .name           = "EFI",
1100        .part_type      = PART_TYPE_EFI,
1101        .max_entries    = GPT_ENTRY_NUMBERS,
1102        .get_info       = part_get_info_ptr(part_get_info_efi),
1103        .print          = part_print_ptr(part_print_efi),
1104        .test           = part_test_efi,
1105};
1106#endif
1107