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