blob: 18f7e584050780c663e0d51f8f4c6691e63c8bbf [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
richardretanubun07f3d782008-09-26 11:13:22 -04002/*
3 * Copyright (C) 2008 RuggedCom, Inc.
4 * Richard Retanubun <RichardRetanubun@RuggedCom.com>
richardretanubun07f3d782008-09-26 11:13:22 -04005 */
6
7/*
Steve Raee04350d2014-05-26 11:52:23 -07008 * NOTE:
9 * when CONFIG_SYS_64BIT_LBA is not defined, lbaint_t is 32 bits; this
Heinrich Schuchardt643b5e72020-09-17 17:57:21 +020010 * limits the maximum size of addressable storage to < 2 tebibytes
richardretanubun07f3d782008-09-26 11:13:22 -040011 */
Simon Glasse6f6f9e2020-05-10 11:39:58 -060012#include <common.h>
13#include <blk.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060014#include <log.h>
Simon Glasse6f6f9e2020-05-10 11:39:58 -060015#include <part.h>
Simon Glassba06b3c2020-05-10 11:39:52 -060016#include <uuid.h>
Simon Glass90526e92020-05-10 11:39:56 -060017#include <asm/cache.h>
Simon Glass401d1c42020-10-30 21:38:53 -060018#include <asm/global_data.h>
Marc Dietrich8faefad2013-03-29 07:57:10 +000019#include <asm/unaligned.h>
richardretanubun07f3d782008-09-26 11:13:22 -040020#include <command.h>
Philipp Tomsich02e43532017-03-01 21:10:39 +010021#include <fdtdec.h>
richardretanubun07f3d782008-09-26 11:13:22 -040022#include <ide.h>
23#include <malloc.h>
Simon Glasscf92e052015-09-02 17:24:58 -060024#include <memalign.h>
Chang Hyun Parkfae2bf22012-12-11 11:09:45 +010025#include <part_efi.h>
Simon Glass7de8bd02021-08-07 07:24:01 -060026#include <dm/ofnode.h>
Philipp Tomsich02e43532017-03-01 21:10:39 +010027#include <linux/compiler.h>
Lei Wen6eecc032011-09-07 18:11:19 +000028#include <linux/ctype.h>
Simon Glass3db71102019-11-14 12:57:16 -070029#include <u-boot/crc.h>
richardretanubun07f3d782008-09-26 11:13:22 -040030
Simon Glassa594b412021-07-02 12:36:14 -060031/* GUID for basic data partitons */
32#if CONFIG_IS_ENABLED(EFI_PARTITION)
33static const efi_guid_t partition_basic_data_guid = PARTITION_BASIC_DATA_GUID;
34#endif
35
richardretanubun07f3d782008-09-26 11:13:22 -040036/**
37 * efi_crc32() - EFI version of crc32 function
38 * @buf: buffer to calculate crc32 of
39 * @len - length of buf
40 *
41 * Description: Returns EFI-style CRC32 value for @buf
42 */
Chang Hyun Parkfae2bf22012-12-11 11:09:45 +010043static inline u32 efi_crc32(const void *buf, u32 len)
richardretanubun07f3d782008-09-26 11:13:22 -040044{
45 return crc32(0, buf, len);
46}
47
48/*
49 * Private function prototypes
50 */
51
52static int pmbr_part_valid(struct partition *part);
53static int is_pmbr_valid(legacy_mbr * mbr);
Simon Glass4101f682016-02-29 15:25:34 -070054static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
Steve Raee04350d2014-05-26 11:52:23 -070055 gpt_header *pgpt_head, gpt_entry **pgpt_pte);
Simon Glass4101f682016-02-29 15:25:34 -070056static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
57 gpt_header *pgpt_head);
richardretanubun07f3d782008-09-26 11:13:22 -040058static int is_pte_valid(gpt_entry * pte);
Urja Rannikko20c568c2019-04-11 20:27:50 +000059static int find_valid_gpt(struct blk_desc *dev_desc, gpt_header *gpt_head,
60 gpt_entry **pgpt_pte);
richardretanubun07f3d782008-09-26 11:13:22 -040061
Lei Wen6eecc032011-09-07 18:11:19 +000062static char *print_efiname(gpt_entry *pte)
63{
64 static char name[PARTNAME_SZ + 1];
65 int i;
66 for (i = 0; i < PARTNAME_SZ; i++) {
67 u8 c;
68 c = pte->partition_name[i] & 0xff;
69 c = (c && !isprint(c)) ? '.' : c;
70 name[i] = c;
71 }
72 name[PARTNAME_SZ] = 0;
73 return name;
74}
75
Heinrich Schuchardt7de24b22019-01-12 11:25:25 +010076static const efi_guid_t system_guid = PARTITION_SYSTEM_GUID;
Stephen Warrenb4414f42012-10-08 08:14:37 +000077
Heinrich Schuchardt25801ac2020-03-19 13:49:34 +010078static int get_bootable(gpt_entry *p)
Stephen Warrenb4414f42012-10-08 08:14:37 +000079{
Heinrich Schuchardt25801ac2020-03-19 13:49:34 +010080 int ret = 0;
81
82 if (!memcmp(&p->partition_type_guid, &system_guid, sizeof(efi_guid_t)))
83 ret |= PART_EFI_SYSTEM_PARTITION;
84 if (p->attributes.fields.legacy_bios_bootable)
85 ret |= PART_BOOTABLE;
86 return ret;
Stephen Warrenb4414f42012-10-08 08:14:37 +000087}
88
Steve Raee1f6b0a2014-12-18 12:13:42 +010089static int validate_gpt_header(gpt_header *gpt_h, lbaint_t lba,
90 lbaint_t lastlba)
91{
92 uint32_t crc32_backup = 0;
93 uint32_t calc_crc32;
94
95 /* Check the GPT header signature */
Simon Glass67b90522018-10-01 12:22:35 -060096 if (le64_to_cpu(gpt_h->signature) != GPT_HEADER_SIGNATURE_UBOOT) {
Simon Glass3e62adc2022-10-20 18:22:40 -060097 log_debug("%s signature is wrong: %#llX != %#llX\n",
98 "GUID Partition Table Header",
99 le64_to_cpu(gpt_h->signature),
100 GPT_HEADER_SIGNATURE_UBOOT);
Steve Raee1f6b0a2014-12-18 12:13:42 +0100101 return -1;
102 }
103
104 /* Check the GUID Partition Table CRC */
105 memcpy(&crc32_backup, &gpt_h->header_crc32, sizeof(crc32_backup));
106 memset(&gpt_h->header_crc32, 0, sizeof(gpt_h->header_crc32));
107
108 calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
109 le32_to_cpu(gpt_h->header_size));
110
111 memcpy(&gpt_h->header_crc32, &crc32_backup, sizeof(crc32_backup));
112
113 if (calc_crc32 != le32_to_cpu(crc32_backup)) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600114 log_debug("%s: CRC is wrong: %#x != %#x\n",
115 "GUID Partition Table Header",
116 le32_to_cpu(crc32_backup), calc_crc32);
Steve Raee1f6b0a2014-12-18 12:13:42 +0100117 return -1;
118 }
119
120 /*
121 * Check that the my_lba entry points to the LBA that contains the GPT
122 */
123 if (le64_to_cpu(gpt_h->my_lba) != lba) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600124 log_debug("GPT: my_lba incorrect: %llX != " LBAF "\n",
125 le64_to_cpu(gpt_h->my_lba), lba);
Steve Raee1f6b0a2014-12-18 12:13:42 +0100126 return -1;
127 }
128
129 /*
130 * Check that the first_usable_lba and that the last_usable_lba are
131 * within the disk.
132 */
133 if (le64_to_cpu(gpt_h->first_usable_lba) > lastlba) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600134 log_debug("GPT: first_usable_lba incorrect: %llX > " LBAF "\n",
135 le64_to_cpu(gpt_h->first_usable_lba), lastlba);
Steve Raee1f6b0a2014-12-18 12:13:42 +0100136 return -1;
137 }
138 if (le64_to_cpu(gpt_h->last_usable_lba) > lastlba) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600139 log_debug("GPT: last_usable_lba incorrect: %llX > " LBAF "\n",
140 le64_to_cpu(gpt_h->last_usable_lba), lastlba);
Steve Raee1f6b0a2014-12-18 12:13:42 +0100141 return -1;
142 }
143
144 debug("GPT: first_usable_lba: %llX last_usable_lba: %llX last lba: "
145 LBAF "\n", le64_to_cpu(gpt_h->first_usable_lba),
146 le64_to_cpu(gpt_h->last_usable_lba), lastlba);
147
148 return 0;
149}
150
151static int validate_gpt_entries(gpt_header *gpt_h, gpt_entry *gpt_e)
152{
153 uint32_t calc_crc32;
154
155 /* Check the GUID Partition Table Entry Array CRC */
156 calc_crc32 = efi_crc32((const unsigned char *)gpt_e,
157 le32_to_cpu(gpt_h->num_partition_entries) *
158 le32_to_cpu(gpt_h->sizeof_partition_entry));
159
160 if (calc_crc32 != le32_to_cpu(gpt_h->partition_entry_array_crc32)) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600161 log_debug("%s: %#x != %#x\n",
162 "GUID Partition Table Entry Array CRC is wrong",
163 le32_to_cpu(gpt_h->partition_entry_array_crc32),
164 calc_crc32);
Steve Raee1f6b0a2014-12-18 12:13:42 +0100165 return -1;
166 }
167
168 return 0;
169}
170
171static void prepare_backup_gpt_header(gpt_header *gpt_h)
172{
173 uint32_t calc_crc32;
174 uint64_t val;
175
176 /* recalculate the values for the Backup GPT Header */
177 val = le64_to_cpu(gpt_h->my_lba);
178 gpt_h->my_lba = gpt_h->alternate_lba;
179 gpt_h->alternate_lba = cpu_to_le64(val);
Steve Rae0ff7e582014-12-12 15:51:54 -0800180 gpt_h->partition_entry_lba =
181 cpu_to_le64(le64_to_cpu(gpt_h->last_usable_lba) + 1);
Steve Raee1f6b0a2014-12-18 12:13:42 +0100182 gpt_h->header_crc32 = 0;
183
184 calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
185 le32_to_cpu(gpt_h->header_size));
186 gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
187}
188
Patrick Delaunaybd42a942017-01-27 11:00:41 +0100189#if CONFIG_IS_ENABLED(EFI_PARTITION)
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000190/*
191 * Public Functions (include/part.h)
192 */
193
Alison Chaiken73d6d182017-06-25 16:43:23 -0700194/*
195 * UUID is displayed as 32 hexadecimal digits, in 5 groups,
196 * separated by hyphens, in the form 8-4-4-4-12 for a total of 36 characters
197 */
198int get_disk_guid(struct blk_desc * dev_desc, char *guid)
199{
200 ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
201 gpt_entry *gpt_pte = NULL;
202 unsigned char *guid_bin;
203
204 /* This function validates AND fills in the GPT header and PTE */
Urja Rannikko20c568c2019-04-11 20:27:50 +0000205 if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
206 return -EINVAL;
Alison Chaiken73d6d182017-06-25 16:43:23 -0700207
208 guid_bin = gpt_head->disk_guid.b;
209 uuid_bin_to_str(guid_bin, guid, UUID_STR_FORMAT_GUID);
210
Eugeniu Rosca1cfe9692019-04-30 04:53:44 +0200211 /* Remember to free pte */
212 free(gpt_pte);
Alison Chaiken73d6d182017-06-25 16:43:23 -0700213 return 0;
214}
215
Simon Glass084bf4c2016-02-29 15:26:04 -0700216void part_print_efi(struct blk_desc *dev_desc)
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000217{
Egbert Eichae1768a2013-04-09 06:03:36 +0000218 ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000219 gpt_entry *gpt_pte = NULL;
220 int i = 0;
Heinrich Schuchardta4492ee2022-01-16 12:23:19 +0100221 unsigned char *uuid;
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000222
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000223 /* This function validates AND fills in the GPT header and PTE */
Urja Rannikko20c568c2019-04-11 20:27:50 +0000224 if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
225 return;
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000226
227 debug("%s: gpt-entry at %p\n", __func__, gpt_pte);
228
229 printf("Part\tStart LBA\tEnd LBA\t\tName\n");
Stephen Warren13bf2f52012-10-08 08:14:36 +0000230 printf("\tAttributes\n");
Przemyslaw Marczakd718ded2014-04-02 10:20:03 +0200231 printf("\tType GUID\n");
232 printf("\tPartition GUID\n");
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000233
Chang Hyun Parkfae2bf22012-12-11 11:09:45 +0100234 for (i = 0; i < le32_to_cpu(gpt_head->num_partition_entries); i++) {
Heinrich Schuchardt504dbd22022-01-11 15:43:05 +0100235 /* Skip invalid PTE */
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000236 if (!is_pte_valid(&gpt_pte[i]))
Heinrich Schuchardt504dbd22022-01-11 15:43:05 +0100237 continue;
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000238
239 printf("%3d\t0x%08llx\t0x%08llx\t\"%s\"\n", (i + 1),
Chang Hyun Parkfae2bf22012-12-11 11:09:45 +0100240 le64_to_cpu(gpt_pte[i].starting_lba),
241 le64_to_cpu(gpt_pte[i].ending_lba),
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000242 print_efiname(&gpt_pte[i]));
Stephen Warren13bf2f52012-10-08 08:14:36 +0000243 printf("\tattrs:\t0x%016llx\n", gpt_pte[i].attributes.raw);
Heinrich Schuchardta4492ee2022-01-16 12:23:19 +0100244 uuid = (unsigned char *)gpt_pte[i].partition_type_guid.b;
245 if (CONFIG_IS_ENABLED(PARTITION_TYPE_GUID))
246 printf("\ttype:\t%pUl\n\t\t(%pUs)\n", uuid, uuid);
247 else
248 printf("\ttype:\t%pUl\n", uuid);
249 uuid = (unsigned char *)gpt_pte[i].unique_partition_guid.b;
250 printf("\tguid:\t%pUl\n", uuid);
Stephen Warrenf07cd2c2012-10-08 08:14:34 +0000251 }
252
253 /* Remember to free pte */
254 free(gpt_pte);
255 return;
256}
Stephen Warren894bfbb2012-09-21 09:50:59 +0000257
Simon Glass3e8bd462016-02-29 15:25:48 -0700258int part_get_info_efi(struct blk_desc *dev_desc, int part,
Simon Glass05289792020-05-10 11:39:57 -0600259 struct disk_partition *info)
richardretanubun07f3d782008-09-26 11:13:22 -0400260{
Egbert Eichae1768a2013-04-09 06:03:36 +0000261 ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_head, 1, dev_desc->blksz);
Doug Andersondeb5ca82011-10-19 09:47:31 +0000262 gpt_entry *gpt_pte = NULL;
richardretanubun07f3d782008-09-26 11:13:22 -0400263
264 /* "part" argument must be at least 1 */
Simon Glass4708a072016-03-16 07:45:36 -0600265 if (part < 1) {
Simon Glassf337fb92022-10-11 09:47:11 -0600266 log_debug("Invalid Argument(s)\n");
267 return -EINVAL;
richardretanubun07f3d782008-09-26 11:13:22 -0400268 }
269
270 /* This function validates AND fills in the GPT header and PTE */
Urja Rannikko20c568c2019-04-11 20:27:50 +0000271 if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
Simon Glassf337fb92022-10-11 09:47:11 -0600272 return -EINVAL;
richardretanubun07f3d782008-09-26 11:13:22 -0400273
Chang Hyun Parkfae2bf22012-12-11 11:09:45 +0100274 if (part > le32_to_cpu(gpt_head->num_partition_entries) ||
Stephen Warrenc04d68c2012-09-21 09:50:58 +0000275 !is_pte_valid(&gpt_pte[part - 1])) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600276 log_debug("Invalid partition number %d\n", part);
Mark Langsdorf6d2ee5a2013-09-10 15:14:56 -0500277 free(gpt_pte);
Simon Glassf337fb92022-10-11 09:47:11 -0600278 return -EPERM;
Stephen Warrenc04d68c2012-09-21 09:50:58 +0000279 }
280
Steve Raee04350d2014-05-26 11:52:23 -0700281 /* The 'lbaint_t' casting may limit the maximum disk size to 2 TB */
282 info->start = (lbaint_t)le64_to_cpu(gpt_pte[part - 1].starting_lba);
Richard Retanubun50970832009-01-26 08:45:14 -0500283 /* The ending LBA is inclusive, to calculate size, add 1 to it */
Steve Raee04350d2014-05-26 11:52:23 -0700284 info->size = (lbaint_t)le64_to_cpu(gpt_pte[part - 1].ending_lba) + 1
Richard Retanubun50970832009-01-26 08:45:14 -0500285 - info->start;
Egbert Eichae1768a2013-04-09 06:03:36 +0000286 info->blksz = dev_desc->blksz;
richardretanubun07f3d782008-09-26 11:13:22 -0400287
Heinrich Schuchardt5375ee52019-07-05 21:27:13 +0200288 snprintf((char *)info->name, sizeof(info->name), "%s",
289 print_efiname(&gpt_pte[part - 1]));
Ben Whitten192bc692015-12-30 13:05:58 +0000290 strcpy((char *)info->type, "U-Boot");
Heinrich Schuchardt25801ac2020-03-19 13:49:34 +0100291 info->bootable = get_bootable(&gpt_pte[part - 1]);
Patrick Delaunayb331cd62017-01-27 11:00:42 +0100292#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
Przemyslaw Marczakd718ded2014-04-02 10:20:03 +0200293 uuid_bin_to_str(gpt_pte[part - 1].unique_partition_guid.b, info->uuid,
294 UUID_STR_FORMAT_GUID);
Stephen Warren894bfbb2012-09-21 09:50:59 +0000295#endif
Patrick Delaunay7561b252015-10-27 11:00:27 +0100296#ifdef CONFIG_PARTITION_TYPE_GUID
297 uuid_bin_to_str(gpt_pte[part - 1].partition_type_guid.b,
298 info->type_guid, UUID_STR_FORMAT_GUID);
299#endif
richardretanubun07f3d782008-09-26 11:13:22 -0400300
Simon Glassf337fb92022-10-11 09:47:11 -0600301 log_debug("start 0x" LBAF ", size 0x" LBAF ", name %s\n", info->start,
302 info->size, info->name);
richardretanubun07f3d782008-09-26 11:13:22 -0400303
304 /* Remember to free pte */
Doug Andersondeb5ca82011-10-19 09:47:31 +0000305 free(gpt_pte);
richardretanubun07f3d782008-09-26 11:13:22 -0400306 return 0;
307}
308
Simon Glass084bf4c2016-02-29 15:26:04 -0700309static int part_test_efi(struct blk_desc *dev_desc)
richardretanubun07f3d782008-09-26 11:13:22 -0400310{
Egbert Eichae1768a2013-04-09 06:03:36 +0000311 ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, legacymbr, 1, dev_desc->blksz);
richardretanubun07f3d782008-09-26 11:13:22 -0400312
313 /* Read legacy MBR from block 0 and validate it */
Simon Glass2a981dc2016-02-29 15:25:52 -0700314 if ((blk_dread(dev_desc, 0, 1, (ulong *)legacymbr) != 1)
Anton staaff75dd582011-10-12 13:56:04 +0000315 || (is_pmbr_valid(legacymbr) != 1)) {
richardretanubun07f3d782008-09-26 11:13:22 -0400316 return -1;
317 }
318 return 0;
319}
320
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100321/**
322 * set_protective_mbr(): Set the EFI protective MBR
323 * @param dev_desc - block device descriptor
324 *
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100325 * Return: - zero on success, otherwise error
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100326 */
Simon Glass4101f682016-02-29 15:25:34 -0700327static int set_protective_mbr(struct blk_desc *dev_desc)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100328{
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100329 /* Setup the Protective MBR */
Patrick Delaunay3cc56612017-11-17 10:08:18 +0100330 ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, p_mbr, 1, dev_desc->blksz);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100331 if (p_mbr == NULL) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600332 log_debug("calloc failed!\n");
333 return -ENOMEM;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100334 }
Vincent Tinellie163a932017-01-30 15:46:07 +0300335
336 /* Read MBR to backup boot code if it exists */
337 if (blk_dread(dev_desc, 0, 1, p_mbr) != 1) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600338 log_debug("** Can't read from device %d **\n",
339 dev_desc->devnum);
340 return -EIO;
Vincent Tinellie163a932017-01-30 15:46:07 +0300341 }
342
Sam Protsenko955575c2018-05-22 02:04:21 +0300343 /* Clear all data in MBR except of backed up boot code */
344 memset((char *)p_mbr + MSDOS_MBR_BOOT_CODE_SIZE, 0, sizeof(*p_mbr) -
345 MSDOS_MBR_BOOT_CODE_SIZE);
346
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100347 /* Append signature */
348 p_mbr->signature = MSDOS_MBR_SIGNATURE;
349 p_mbr->partition_record[0].sys_ind = EFI_PMBR_OSTYPE_EFI_GPT;
350 p_mbr->partition_record[0].start_sect = 1;
Maxime Ripardb349abb2015-01-08 12:26:44 +0100351 p_mbr->partition_record[0].nr_sects = (u32) dev_desc->lba - 1;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100352
353 /* Write MBR sector to the MMC device */
Simon Glass2a981dc2016-02-29 15:25:52 -0700354 if (blk_dwrite(dev_desc, 0, 1, p_mbr) != 1) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600355 log_debug("** Can't write to device %d **\n", dev_desc->devnum);
356 return -EIO;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100357 }
358
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100359 return 0;
360}
361
Simon Glass4101f682016-02-29 15:25:34 -0700362int write_gpt_table(struct blk_desc *dev_desc,
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100363 gpt_header *gpt_h, gpt_entry *gpt_e)
364{
Egbert Eichae1768a2013-04-09 06:03:36 +0000365 const int pte_blk_cnt = BLOCK_CNT((gpt_h->num_partition_entries
366 * sizeof(gpt_entry)), dev_desc);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100367 u32 calc_crc32;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100368
369 debug("max lba: %x\n", (u32) dev_desc->lba);
370 /* Setup the Protective MBR */
371 if (set_protective_mbr(dev_desc) < 0)
372 goto err;
373
374 /* Generate CRC for the Primary GPT Header */
375 calc_crc32 = efi_crc32((const unsigned char *)gpt_e,
376 le32_to_cpu(gpt_h->num_partition_entries) *
377 le32_to_cpu(gpt_h->sizeof_partition_entry));
378 gpt_h->partition_entry_array_crc32 = cpu_to_le32(calc_crc32);
379
380 calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
381 le32_to_cpu(gpt_h->header_size));
382 gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
383
384 /* Write the First GPT to the block right after the Legacy MBR */
Simon Glass2a981dc2016-02-29 15:25:52 -0700385 if (blk_dwrite(dev_desc, 1, 1, gpt_h) != 1)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100386 goto err;
387
Philipp Tomsich02e43532017-03-01 21:10:39 +0100388 if (blk_dwrite(dev_desc, le64_to_cpu(gpt_h->partition_entry_lba),
389 pte_blk_cnt, gpt_e) != pte_blk_cnt)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100390 goto err;
391
Steve Raee1f6b0a2014-12-18 12:13:42 +0100392 prepare_backup_gpt_header(gpt_h);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100393
Simon Glass2a981dc2016-02-29 15:25:52 -0700394 if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->last_usable_lba)
395 + 1, pte_blk_cnt, gpt_e) != pte_blk_cnt)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100396 goto err;
397
Simon Glass2a981dc2016-02-29 15:25:52 -0700398 if (blk_dwrite(dev_desc, (lbaint_t)le64_to_cpu(gpt_h->my_lba), 1,
399 gpt_h) != 1)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100400 goto err;
401
402 debug("GPT successfully written to block device!\n");
403 return 0;
404
405 err:
Simon Glass3e62adc2022-10-20 18:22:40 -0600406 log_debug("** Can't write to device %d **\n", dev_desc->devnum);
407 return -EIO;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100408}
409
Maxime Ripard47d7ee42017-08-23 16:01:32 +0200410int gpt_fill_pte(struct blk_desc *dev_desc,
411 gpt_header *gpt_h, gpt_entry *gpt_e,
Simon Glass05289792020-05-10 11:39:57 -0600412 struct disk_partition *partitions, int parts)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100413{
Steve Raee04350d2014-05-26 11:52:23 -0700414 lbaint_t offset = (lbaint_t)le64_to_cpu(gpt_h->first_usable_lba);
Steve Raee04350d2014-05-26 11:52:23 -0700415 lbaint_t last_usable_lba = (lbaint_t)
416 le64_to_cpu(gpt_h->last_usable_lba);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100417 int i, k;
Marek Vasut67cd4a62013-05-19 12:53:34 +0000418 size_t efiname_len, dosname_len;
Patrick Delaunayb331cd62017-01-27 11:00:42 +0100419#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100420 char *str_uuid;
Przemyslaw Marczaka96a0e62014-04-02 10:20:02 +0200421 unsigned char *bin_uuid;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100422#endif
Patrick Delaunay7561b252015-10-27 11:00:27 +0100423#ifdef CONFIG_PARTITION_TYPE_GUID
424 char *str_type_guid;
425 unsigned char *bin_type_guid;
426#endif
Maxime Ripard79c59122017-08-23 16:01:33 +0200427 size_t hdr_start = gpt_h->my_lba;
428 size_t hdr_end = hdr_start + 1;
429
430 size_t pte_start = gpt_h->partition_entry_lba;
431 size_t pte_end = pte_start +
432 gpt_h->num_partition_entries * gpt_h->sizeof_partition_entry /
433 dev_desc->blksz;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100434
435 for (i = 0; i < parts; i++) {
436 /* partition starting lba */
Maxime Ripard5276e8b2017-08-23 16:01:31 +0200437 lbaint_t start = partitions[i].start;
438 lbaint_t size = partitions[i].size;
439
Maxime Ripard79c59122017-08-23 16:01:33 +0200440 if (start) {
441 offset = start + size;
442 } else {
443 start = offset;
444 offset += size;
445 }
446
447 /*
448 * If our partition overlaps with either the GPT
449 * header, or the partition entry, reject it.
450 */
Patrick Delaunayae0e0222017-10-18 15:11:05 +0200451 if (((start < hdr_end && hdr_start < (start + size)) ||
452 (start < pte_end && pte_start < (start + size)))) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600453 log_debug("Partition overlap\n");
454 return -ENOSPC;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100455 }
Maxime Ripard5276e8b2017-08-23 16:01:31 +0200456
Maxime Ripard79c59122017-08-23 16:01:33 +0200457 gpt_e[i].starting_lba = cpu_to_le64(start);
458
Patrick Delaunaya5653862016-05-02 14:43:33 +0200459 if (offset > (last_usable_lba + 1)) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600460 log_debug("Partitions layout exceeds disk size\n");
461 return -E2BIG;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100462 }
463 /* partition ending lba */
Maxime Ripard5276e8b2017-08-23 16:01:31 +0200464 if ((i == parts - 1) && (size == 0))
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100465 /* extend the last partition to maximuim */
466 gpt_e[i].ending_lba = gpt_h->last_usable_lba;
467 else
468 gpt_e[i].ending_lba = cpu_to_le64(offset - 1);
469
Patrick Delaunay7561b252015-10-27 11:00:27 +0100470#ifdef CONFIG_PARTITION_TYPE_GUID
471 str_type_guid = partitions[i].type_guid;
472 bin_type_guid = gpt_e[i].partition_type_guid.b;
473 if (strlen(str_type_guid)) {
474 if (uuid_str_to_bin(str_type_guid, bin_type_guid,
475 UUID_STR_FORMAT_GUID)) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600476 log_debug("Partition no. %d: invalid type guid: %s\n",
477 i, str_type_guid);
478 return -EINVAL;
Patrick Delaunay7561b252015-10-27 11:00:27 +0100479 }
480 } else {
481 /* default partition type GUID */
482 memcpy(bin_type_guid,
Heinrich Schuchardt44ab2d32018-06-09 17:50:18 +0200483 &partition_basic_data_guid, 16);
Patrick Delaunay7561b252015-10-27 11:00:27 +0100484 }
485#else
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100486 /* partition type GUID */
487 memcpy(gpt_e[i].partition_type_guid.b,
Heinrich Schuchardt44ab2d32018-06-09 17:50:18 +0200488 &partition_basic_data_guid, 16);
Patrick Delaunay7561b252015-10-27 11:00:27 +0100489#endif
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100490
Patrick Delaunayb331cd62017-01-27 11:00:42 +0100491#if CONFIG_IS_ENABLED(PARTITION_UUIDS)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100492 str_uuid = partitions[i].uuid;
Przemyslaw Marczaka96a0e62014-04-02 10:20:02 +0200493 bin_uuid = gpt_e[i].unique_partition_guid.b;
494
Vincent Tinelli9da52f82017-02-27 16:11:15 +0200495 if (uuid_str_to_bin(str_uuid, bin_uuid, UUID_STR_FORMAT_GUID)) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600496 log_debug("Partition no. %d: invalid guid: %s\n",
497 i, str_uuid);
498 return -EINVAL;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100499 }
500#endif
501
502 /* partition attributes */
503 memset(&gpt_e[i].attributes, 0,
504 sizeof(gpt_entry_attributes));
505
Heinrich Schuchardt25801ac2020-03-19 13:49:34 +0100506 if (partitions[i].bootable & PART_BOOTABLE)
Patrick Delaunaycfdaf4c2015-11-17 11:36:52 +0100507 gpt_e[i].attributes.fields.legacy_bios_bootable = 1;
508
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100509 /* partition name */
Marek Vasut67cd4a62013-05-19 12:53:34 +0000510 efiname_len = sizeof(gpt_e[i].partition_name)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100511 / sizeof(efi_char16_t);
Marek Vasut67cd4a62013-05-19 12:53:34 +0000512 dosname_len = sizeof(partitions[i].name);
513
514 memset(gpt_e[i].partition_name, 0,
515 sizeof(gpt_e[i].partition_name));
516
517 for (k = 0; k < min(dosname_len, efiname_len); k++)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100518 gpt_e[i].partition_name[k] =
519 (efi_char16_t)(partitions[i].name[k]);
520
Steve Raee04350d2014-05-26 11:52:23 -0700521 debug("%s: name: %s offset[%d]: 0x" LBAF
522 " size[%d]: 0x" LBAF "\n",
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100523 __func__, partitions[i].name, i,
Maxime Ripard5276e8b2017-08-23 16:01:31 +0200524 offset, i, size);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100525 }
526
527 return 0;
528}
529
Philipp Tomsich02e43532017-03-01 21:10:39 +0100530static uint32_t partition_entries_offset(struct blk_desc *dev_desc)
531{
532 uint32_t offset_blks = 2;
Maxime Ripard89d33a22017-08-23 16:01:30 +0200533 uint32_t __maybe_unused offset_bytes;
Philipp Tomsich02e43532017-03-01 21:10:39 +0100534 int __maybe_unused config_offset;
535
536#if defined(CONFIG_EFI_PARTITION_ENTRIES_OFF)
537 /*
538 * Some architectures require their SPL loader at a fixed
539 * address within the first 16KB of the disk. To avoid an
540 * overlap with the partition entries of the EFI partition
541 * table, the first safe offset (in bytes, from the start of
542 * the disk) for the entries can be set in
543 * CONFIG_EFI_PARTITION_ENTRIES_OFF.
544 */
Maxime Ripard89d33a22017-08-23 16:01:30 +0200545 offset_bytes =
Philipp Tomsich02e43532017-03-01 21:10:39 +0100546 PAD_TO_BLOCKSIZE(CONFIG_EFI_PARTITION_ENTRIES_OFF, dev_desc);
Maxime Ripard89d33a22017-08-23 16:01:30 +0200547 offset_blks = offset_bytes / dev_desc->blksz;
Philipp Tomsich02e43532017-03-01 21:10:39 +0100548#endif
549
550#if defined(CONFIG_OF_CONTROL)
551 /*
552 * Allow the offset of the first partition entires (in bytes
553 * from the start of the device) to be specified as a property
554 * of the device tree '/config' node.
555 */
Simon Glass7de8bd02021-08-07 07:24:01 -0600556 config_offset = ofnode_conf_read_int(
557 "u-boot,efi-partition-entries-offset", -EINVAL);
Maxime Ripard89d33a22017-08-23 16:01:30 +0200558 if (config_offset != -EINVAL) {
559 offset_bytes = PAD_TO_BLOCKSIZE(config_offset, dev_desc);
560 offset_blks = offset_bytes / dev_desc->blksz;
561 }
Philipp Tomsich02e43532017-03-01 21:10:39 +0100562#endif
563
564 debug("efi: partition entries offset (in blocks): %d\n", offset_blks);
565
566 /*
567 * The earliest LBA this can be at is LBA#2 (i.e. right behind
568 * the (protective) MBR and the GPT header.
569 */
570 if (offset_blks < 2)
571 offset_blks = 2;
572
573 return offset_blks;
574}
575
Simon Glass4101f682016-02-29 15:25:34 -0700576int gpt_fill_header(struct blk_desc *dev_desc, gpt_header *gpt_h,
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100577 char *str_guid, int parts_count)
578{
Simon Glass67b90522018-10-01 12:22:35 -0600579 gpt_h->signature = cpu_to_le64(GPT_HEADER_SIGNATURE_UBOOT);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100580 gpt_h->revision = cpu_to_le32(GPT_HEADER_REVISION_V1);
581 gpt_h->header_size = cpu_to_le32(sizeof(gpt_header));
582 gpt_h->my_lba = cpu_to_le64(1);
583 gpt_h->alternate_lba = cpu_to_le64(dev_desc->lba - 1);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100584 gpt_h->last_usable_lba = cpu_to_le64(dev_desc->lba - 34);
Philipp Tomsich02e43532017-03-01 21:10:39 +0100585 gpt_h->partition_entry_lba =
586 cpu_to_le64(partition_entries_offset(dev_desc));
587 gpt_h->first_usable_lba =
588 cpu_to_le64(le64_to_cpu(gpt_h->partition_entry_lba) + 32);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100589 gpt_h->num_partition_entries = cpu_to_le32(GPT_ENTRY_NUMBERS);
590 gpt_h->sizeof_partition_entry = cpu_to_le32(sizeof(gpt_entry));
591 gpt_h->header_crc32 = 0;
592 gpt_h->partition_entry_array_crc32 = 0;
593
Przemyslaw Marczakd718ded2014-04-02 10:20:03 +0200594 if (uuid_str_to_bin(str_guid, gpt_h->disk_guid.b, UUID_STR_FORMAT_GUID))
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100595 return -1;
596
597 return 0;
598}
599
Simon Glass4101f682016-02-29 15:25:34 -0700600int gpt_restore(struct blk_desc *dev_desc, char *str_disk_guid,
Simon Glass05289792020-05-10 11:39:57 -0600601 struct disk_partition *partitions, int parts_count)
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100602{
Lukasz Majewskibb021012017-10-27 12:28:10 +0200603 gpt_header *gpt_h;
Egbert Eichae1768a2013-04-09 06:03:36 +0000604 gpt_entry *gpt_e;
Lukasz Majewskibb021012017-10-27 12:28:10 +0200605 int ret, size;
Egbert Eichae1768a2013-04-09 06:03:36 +0000606
Lukasz Majewskibb021012017-10-27 12:28:10 +0200607 size = PAD_TO_BLOCKSIZE(sizeof(gpt_header), dev_desc);
608 gpt_h = malloc_cache_aligned(size);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100609 if (gpt_h == NULL) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600610 log_debug("calloc failed!\n");
611 return -ENOMEM;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100612 }
Lukasz Majewskibb021012017-10-27 12:28:10 +0200613 memset(gpt_h, 0, size);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100614
Lukasz Majewskibb021012017-10-27 12:28:10 +0200615 size = PAD_TO_BLOCKSIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry),
616 dev_desc);
617 gpt_e = malloc_cache_aligned(size);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100618 if (gpt_e == NULL) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600619 log_debug("calloc failed!\n");
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100620 free(gpt_h);
Simon Glass3e62adc2022-10-20 18:22:40 -0600621 return -ENOMEM;
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100622 }
Lukasz Majewskibb021012017-10-27 12:28:10 +0200623 memset(gpt_e, 0, size);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100624
625 /* Generate Primary GPT header (LBA1) */
626 ret = gpt_fill_header(dev_desc, gpt_h, str_disk_guid, parts_count);
627 if (ret)
628 goto err;
629
630 /* Generate partition entries */
Maxime Ripard47d7ee42017-08-23 16:01:32 +0200631 ret = gpt_fill_pte(dev_desc, gpt_h, gpt_e, partitions, parts_count);
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100632 if (ret)
633 goto err;
634
635 /* Write GPT partition table */
636 ret = write_gpt_table(dev_desc, gpt_h, gpt_e);
637
638err:
639 free(gpt_e);
640 free(gpt_h);
641 return ret;
642}
Steve Rae0ff7e582014-12-12 15:51:54 -0800643
Heinrich Schuchardt06e921b2019-07-14 18:12:32 +0200644/**
645 * gpt_convert_efi_name_to_char() - convert u16 string to char string
646 *
647 * TODO: this conversion only supports ANSI characters
648 *
649 * @s: target buffer
650 * @es: u16 string to be converted
651 * @n: size of target buffer
652 */
653static void gpt_convert_efi_name_to_char(char *s, void *es, int n)
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100654{
Heinrich Schuchardt06e921b2019-07-14 18:12:32 +0200655 char *ess = es;
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100656 int i, j;
657
658 memset(s, '\0', n);
659
660 for (i = 0, j = 0; j < n; i += 2, j++) {
661 s[j] = ess[i];
662 if (!ess[i])
663 return;
664 }
665}
666
Simon Glass4101f682016-02-29 15:25:34 -0700667int gpt_verify_headers(struct blk_desc *dev_desc, gpt_header *gpt_head,
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100668 gpt_entry **gpt_pte)
669{
670 /*
671 * This function validates AND
672 * fills in the GPT header and PTE
673 */
674 if (is_gpt_valid(dev_desc,
675 GPT_PRIMARY_PARTITION_TABLE_LBA,
676 gpt_head, gpt_pte) != 1) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600677 log_debug("Invalid GPT\n");
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100678 return -1;
679 }
Eugeniu Rosca716f9192019-04-30 04:53:45 +0200680
681 /* Free pte before allocating again */
682 free(*gpt_pte);
683
Stefan Herbrechtsmeierd4693382021-03-08 16:07:11 +0000684 /*
685 * Check that the alternate_lba entry points to the last LBA
686 */
687 if (le64_to_cpu(gpt_head->alternate_lba) != (dev_desc->lba - 1)) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600688 log_debug("Misplaced Backup GPT\n");
Stefan Herbrechtsmeierd4693382021-03-08 16:07:11 +0000689 return -1;
690 }
691
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100692 if (is_gpt_valid(dev_desc, (dev_desc->lba - 1),
693 gpt_head, gpt_pte) != 1) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600694 log_debug("Invalid Backup GPT\n");
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100695 return -1;
696 }
697
698 return 0;
699}
700
Philippe Reynes5c783b52022-04-22 17:46:48 +0200701static void restore_primary_gpt_header(gpt_header *gpt_h, struct blk_desc *dev_desc)
702{
703 u32 calc_crc32;
704 u64 val;
705
706 /* recalculate the values for the Primary GPT Header */
707 val = le64_to_cpu(gpt_h->my_lba);
708 gpt_h->my_lba = gpt_h->alternate_lba;
709 gpt_h->alternate_lba = cpu_to_le64(val);
710 gpt_h->partition_entry_lba = cpu_to_le64(partition_entries_offset(dev_desc));
711
712 gpt_h->header_crc32 = 0;
713
714 calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
715 le32_to_cpu(gpt_h->header_size));
716 gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
717}
718
719static int write_one_gpt_table(struct blk_desc *dev_desc,
720 gpt_header *gpt_h, gpt_entry *gpt_e)
721{
722 const int pte_blk_cnt = BLOCK_CNT((gpt_h->num_partition_entries
723 * sizeof(gpt_entry)), dev_desc);
724 lbaint_t start;
725 int ret = 0;
726
727 start = le64_to_cpu(gpt_h->my_lba);
728 if (blk_dwrite(dev_desc, start, 1, gpt_h) != 1) {
729 ret = -1;
730 goto out;
731 }
732
733 start = le64_to_cpu(gpt_h->partition_entry_lba);
734 if (blk_dwrite(dev_desc, start, pte_blk_cnt, gpt_e) != pte_blk_cnt) {
735 ret = -1;
736 goto out;
737 }
738
739 out:
740 return ret;
741}
742
743int gpt_repair_headers(struct blk_desc *dev_desc)
744{
745 ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_h1, 1, dev_desc->blksz);
746 ALLOC_CACHE_ALIGN_BUFFER_PAD(gpt_header, gpt_h2, 1, dev_desc->blksz);
747 gpt_entry *gpt_e1 = NULL, *gpt_e2 = NULL;
748 int is_gpt1_valid, is_gpt2_valid;
749 int ret = -1;
750
751 is_gpt1_valid = is_gpt_valid(dev_desc, GPT_PRIMARY_PARTITION_TABLE_LBA,
752 gpt_h1, &gpt_e1);
753 is_gpt2_valid = is_gpt_valid(dev_desc, dev_desc->lba - 1,
754 gpt_h2, &gpt_e2);
755
756 if (is_gpt1_valid && is_gpt2_valid) {
757 ret = 0;
758 goto out;
759 }
760
761 if (is_gpt1_valid && !is_gpt2_valid) {
762 prepare_backup_gpt_header(gpt_h1);
763 ret = write_one_gpt_table(dev_desc, gpt_h1, gpt_e1);
764 goto out;
765 }
766
767 if (!is_gpt1_valid && is_gpt2_valid) {
768 restore_primary_gpt_header(gpt_h2, dev_desc);
769 ret = write_one_gpt_table(dev_desc, gpt_h2, gpt_e2);
770 goto out;
771 }
772
773 if (!is_gpt1_valid && !is_gpt2_valid) {
774 ret = -1;
775 goto out;
776 }
777
778 out:
779 if (is_gpt1_valid)
780 free(gpt_e1);
781 if (is_gpt2_valid)
782 free(gpt_e2);
783
784 return ret;
785}
786
Simon Glass4101f682016-02-29 15:25:34 -0700787int gpt_verify_partitions(struct blk_desc *dev_desc,
Simon Glass05289792020-05-10 11:39:57 -0600788 struct disk_partition *partitions, int parts,
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100789 gpt_header *gpt_head, gpt_entry **gpt_pte)
790{
791 char efi_str[PARTNAME_SZ + 1];
792 u64 gpt_part_size;
793 gpt_entry *gpt_e;
794 int ret, i;
795
796 ret = gpt_verify_headers(dev_desc, gpt_head, gpt_pte);
797 if (ret)
798 return ret;
799
800 gpt_e = *gpt_pte;
801
802 for (i = 0; i < parts; i++) {
803 if (i == gpt_head->num_partition_entries) {
Masahiro Yamada9b643e32017-09-16 14:10:41 +0900804 pr_err("More partitions than allowed!\n");
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100805 return -1;
806 }
807
808 /* Check if GPT and ENV partition names match */
809 gpt_convert_efi_name_to_char(efi_str, gpt_e[i].partition_name,
810 PARTNAME_SZ + 1);
811
812 debug("%s: part: %2d name - GPT: %16s, ENV: %16s ",
813 __func__, i, efi_str, partitions[i].name);
814
815 if (strncmp(efi_str, (char *)partitions[i].name,
816 sizeof(partitions->name))) {
Masahiro Yamada9b643e32017-09-16 14:10:41 +0900817 pr_err("Partition name: %s does not match %s!\n",
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100818 efi_str, (char *)partitions[i].name);
819 return -1;
820 }
821
822 /* Check if GPT and ENV sizes match */
823 gpt_part_size = le64_to_cpu(gpt_e[i].ending_lba) -
824 le64_to_cpu(gpt_e[i].starting_lba) + 1;
825 debug("size(LBA) - GPT: %8llu, ENV: %8llu ",
Simon Glassf8d61652016-02-29 15:25:36 -0700826 (unsigned long long)gpt_part_size,
827 (unsigned long long)partitions[i].size);
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100828
829 if (le64_to_cpu(gpt_part_size) != partitions[i].size) {
Kever Yangc2fdd342016-07-29 11:12:18 +0800830 /* We do not check the extend partition size */
831 if ((i == parts - 1) && (partitions[i].size == 0))
832 continue;
833
Masahiro Yamada9b643e32017-09-16 14:10:41 +0900834 pr_err("Partition %s size: %llu does not match %llu!\n",
Simon Glassf8d61652016-02-29 15:25:36 -0700835 efi_str, (unsigned long long)gpt_part_size,
836 (unsigned long long)partitions[i].size);
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100837 return -1;
838 }
839
840 /*
841 * Start address is optional - check only if provided
842 * in '$partition' variable
843 */
844 if (!partitions[i].start) {
845 debug("\n");
846 continue;
847 }
848
849 /* Check if GPT and ENV start LBAs match */
850 debug("start LBA - GPT: %8llu, ENV: %8llu\n",
851 le64_to_cpu(gpt_e[i].starting_lba),
Simon Glassf8d61652016-02-29 15:25:36 -0700852 (unsigned long long)partitions[i].start);
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100853
854 if (le64_to_cpu(gpt_e[i].starting_lba) != partitions[i].start) {
Masahiro Yamada9b643e32017-09-16 14:10:41 +0900855 pr_err("Partition %s start: %llu does not match %llu!\n",
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100856 efi_str, le64_to_cpu(gpt_e[i].starting_lba),
Simon Glassf8d61652016-02-29 15:25:36 -0700857 (unsigned long long)partitions[i].start);
Lukasz Majewskicef68bf2015-11-20 08:06:16 +0100858 return -1;
859 }
860 }
861
862 return 0;
863}
864
Simon Glass4101f682016-02-29 15:25:34 -0700865int is_valid_gpt_buf(struct blk_desc *dev_desc, void *buf)
Steve Rae0ff7e582014-12-12 15:51:54 -0800866{
867 gpt_header *gpt_h;
868 gpt_entry *gpt_e;
869
870 /* determine start of GPT Header in the buffer */
871 gpt_h = buf + (GPT_PRIMARY_PARTITION_TABLE_LBA *
872 dev_desc->blksz);
873 if (validate_gpt_header(gpt_h, GPT_PRIMARY_PARTITION_TABLE_LBA,
874 dev_desc->lba))
875 return -1;
876
877 /* determine start of GPT Entries in the buffer */
878 gpt_e = buf + (le64_to_cpu(gpt_h->partition_entry_lba) *
879 dev_desc->blksz);
880 if (validate_gpt_entries(gpt_h, gpt_e))
881 return -1;
882
883 return 0;
884}
885
Simon Glass4101f682016-02-29 15:25:34 -0700886int write_mbr_and_gpt_partitions(struct blk_desc *dev_desc, void *buf)
Steve Rae0ff7e582014-12-12 15:51:54 -0800887{
888 gpt_header *gpt_h;
889 gpt_entry *gpt_e;
890 int gpt_e_blk_cnt;
891 lbaint_t lba;
892 int cnt;
893
894 if (is_valid_gpt_buf(dev_desc, buf))
895 return -1;
896
897 /* determine start of GPT Header in the buffer */
898 gpt_h = buf + (GPT_PRIMARY_PARTITION_TABLE_LBA *
899 dev_desc->blksz);
900
901 /* determine start of GPT Entries in the buffer */
902 gpt_e = buf + (le64_to_cpu(gpt_h->partition_entry_lba) *
903 dev_desc->blksz);
904 gpt_e_blk_cnt = BLOCK_CNT((le32_to_cpu(gpt_h->num_partition_entries) *
905 le32_to_cpu(gpt_h->sizeof_partition_entry)),
906 dev_desc);
907
908 /* write MBR */
909 lba = 0; /* MBR is always at 0 */
910 cnt = 1; /* MBR (1 block) */
Simon Glass2a981dc2016-02-29 15:25:52 -0700911 if (blk_dwrite(dev_desc, lba, cnt, buf) != cnt) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600912 log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
913 "MBR", cnt, lba);
Steve Rae0ff7e582014-12-12 15:51:54 -0800914 return 1;
915 }
916
917 /* write Primary GPT */
918 lba = GPT_PRIMARY_PARTITION_TABLE_LBA;
919 cnt = 1; /* GPT Header (1 block) */
Simon Glass2a981dc2016-02-29 15:25:52 -0700920 if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600921 log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
922 "Primary GPT Header", cnt, lba);
Steve Rae0ff7e582014-12-12 15:51:54 -0800923 return 1;
924 }
925
926 lba = le64_to_cpu(gpt_h->partition_entry_lba);
927 cnt = gpt_e_blk_cnt;
Simon Glass2a981dc2016-02-29 15:25:52 -0700928 if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600929 log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
930 "Primary GPT Entries", cnt, lba);
Steve Rae0ff7e582014-12-12 15:51:54 -0800931 return 1;
932 }
933
934 prepare_backup_gpt_header(gpt_h);
935
936 /* write Backup GPT */
937 lba = le64_to_cpu(gpt_h->partition_entry_lba);
938 cnt = gpt_e_blk_cnt;
Simon Glass2a981dc2016-02-29 15:25:52 -0700939 if (blk_dwrite(dev_desc, lba, cnt, gpt_e) != cnt) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600940 log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
941 "Backup GPT Entries", cnt, lba);
Steve Rae0ff7e582014-12-12 15:51:54 -0800942 return 1;
943 }
944
945 lba = le64_to_cpu(gpt_h->my_lba);
946 cnt = 1; /* GPT Header (1 block) */
Simon Glass2a981dc2016-02-29 15:25:52 -0700947 if (blk_dwrite(dev_desc, lba, cnt, gpt_h) != cnt) {
Simon Glass3e62adc2022-10-20 18:22:40 -0600948 log_debug("failed writing '%s' (%d blks at 0x" LBAF ")\n",
949 "Backup GPT Header", cnt, lba);
Steve Rae0ff7e582014-12-12 15:51:54 -0800950 return 1;
951 }
952
Gary Bisson4e9bd062021-01-26 14:56:23 +0100953 /* Update the partition table entries*/
954 part_init(dev_desc);
955
Steve Rae0ff7e582014-12-12 15:51:54 -0800956 return 0;
957}
Lukasz Majewski40684dd2012-12-11 11:09:46 +0100958#endif
959
richardretanubun07f3d782008-09-26 11:13:22 -0400960/*
961 * Private functions
962 */
963/*
964 * pmbr_part_valid(): Check for EFI partition signature
965 *
966 * Returns: 1 if EFI GPT partition type is found.
967 */
968static int pmbr_part_valid(struct partition *part)
969{
970 if (part->sys_ind == EFI_PMBR_OSTYPE_EFI_GPT &&
Marc Dietrich8faefad2013-03-29 07:57:10 +0000971 get_unaligned_le32(&part->start_sect) == 1UL) {
richardretanubun07f3d782008-09-26 11:13:22 -0400972 return 1;
973 }
974
975 return 0;
976}
977
978/*
979 * is_pmbr_valid(): test Protective MBR for validity
980 *
981 * Returns: 1 if PMBR is valid, 0 otherwise.
982 * Validity depends on two things:
983 * 1) MSDOS signature is in the last two bytes of the MBR
984 * 2) One partition of type 0xEE is found, checked by pmbr_part_valid()
985 */
986static int is_pmbr_valid(legacy_mbr * mbr)
987{
988 int i = 0;
989
Chang Hyun Parkfae2bf22012-12-11 11:09:45 +0100990 if (!mbr || le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE)
richardretanubun07f3d782008-09-26 11:13:22 -0400991 return 0;
richardretanubun07f3d782008-09-26 11:13:22 -0400992
993 for (i = 0; i < 4; i++) {
994 if (pmbr_part_valid(&mbr->partition_record[i])) {
995 return 1;
996 }
997 }
998 return 0;
999}
1000
1001/**
1002 * is_gpt_valid() - tests one GPT header and PTEs for validity
1003 *
1004 * lba is the logical block address of the GPT header to test
1005 * gpt is a GPT header ptr, filled on return.
1006 * ptes is a PTEs ptr, filled on return.
1007 *
Urja Rannikko0557d462019-04-11 20:27:51 +00001008 * Description: returns 1 if valid, 0 on error, 2 if ignored header
richardretanubun07f3d782008-09-26 11:13:22 -04001009 * If valid, returns pointers to PTEs.
1010 */
Simon Glass4101f682016-02-29 15:25:34 -07001011static int is_gpt_valid(struct blk_desc *dev_desc, u64 lba,
Steve Raee04350d2014-05-26 11:52:23 -07001012 gpt_header *pgpt_head, gpt_entry **pgpt_pte)
richardretanubun07f3d782008-09-26 11:13:22 -04001013{
Tom Rinib351ccf2017-10-03 09:38:44 -04001014 /* Confirm valid arguments prior to allocation. */
richardretanubun07f3d782008-09-26 11:13:22 -04001015 if (!dev_desc || !pgpt_head) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001016 log_debug("Invalid Argument(s)\n");
richardretanubun07f3d782008-09-26 11:13:22 -04001017 return 0;
1018 }
1019
Patrick Delaunay3cc56612017-11-17 10:08:18 +01001020 ALLOC_CACHE_ALIGN_BUFFER_PAD(legacy_mbr, mbr, 1, dev_desc->blksz);
Tom Rinib351ccf2017-10-03 09:38:44 -04001021
Peter Jonesff98cb92017-09-13 18:05:25 -04001022 /* Read MBR Header from device */
1023 if (blk_dread(dev_desc, 0, 1, (ulong *)mbr) != 1) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001024 log_debug("Can't read MBR header\n");
Peter Jonesff98cb92017-09-13 18:05:25 -04001025 return 0;
1026 }
1027
richardretanubun07f3d782008-09-26 11:13:22 -04001028 /* Read GPT Header from device */
Simon Glass2a981dc2016-02-29 15:25:52 -07001029 if (blk_dread(dev_desc, (lbaint_t)lba, 1, pgpt_head) != 1) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001030 log_debug("Can't read GPT header\n");
richardretanubun07f3d782008-09-26 11:13:22 -04001031 return 0;
1032 }
1033
Urja Rannikko0557d462019-04-11 20:27:51 +00001034 /* Invalid but nothing to yell about. */
1035 if (le64_to_cpu(pgpt_head->signature) == GPT_HEADER_CHROMEOS_IGNORE) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001036 log_debug("ChromeOS 'IGNOREME' GPT header found and ignored\n");
Urja Rannikko0557d462019-04-11 20:27:51 +00001037 return 2;
1038 }
1039
Steve Raee1f6b0a2014-12-18 12:13:42 +01001040 if (validate_gpt_header(pgpt_head, (lbaint_t)lba, dev_desc->lba))
richardretanubun07f3d782008-09-26 11:13:22 -04001041 return 0;
richardretanubun07f3d782008-09-26 11:13:22 -04001042
Peter Jonesff98cb92017-09-13 18:05:25 -04001043 if (dev_desc->sig_type == SIG_TYPE_NONE) {
1044 efi_guid_t empty = {};
1045 if (memcmp(&pgpt_head->disk_guid, &empty, sizeof(empty))) {
1046 dev_desc->sig_type = SIG_TYPE_GUID;
1047 memcpy(&dev_desc->guid_sig, &pgpt_head->disk_guid,
1048 sizeof(empty));
1049 } else if (mbr->unique_mbr_signature != 0) {
1050 dev_desc->sig_type = SIG_TYPE_MBR;
1051 dev_desc->mbr_sig = mbr->unique_mbr_signature;
1052 }
1053 }
1054
richardretanubun07f3d782008-09-26 11:13:22 -04001055 /* Read and allocate Partition Table Entries */
1056 *pgpt_pte = alloc_read_gpt_entries(dev_desc, pgpt_head);
Heinrich Schuchardt1291c2d2022-05-09 21:35:44 +02001057 if (!*pgpt_pte)
richardretanubun07f3d782008-09-26 11:13:22 -04001058 return 0;
richardretanubun07f3d782008-09-26 11:13:22 -04001059
Steve Raee1f6b0a2014-12-18 12:13:42 +01001060 if (validate_gpt_entries(pgpt_head, *pgpt_pte)) {
Doug Andersondeb5ca82011-10-19 09:47:31 +00001061 free(*pgpt_pte);
richardretanubun07f3d782008-09-26 11:13:22 -04001062 return 0;
1063 }
1064
1065 /* We're done, all's well */
1066 return 1;
1067}
1068
1069/**
Urja Rannikko20c568c2019-04-11 20:27:50 +00001070 * find_valid_gpt() - finds a valid GPT header and PTEs
1071 *
1072 * gpt is a GPT header ptr, filled on return.
1073 * ptes is a PTEs ptr, filled on return.
1074 *
1075 * Description: returns 1 if found a valid gpt, 0 on error.
1076 * If valid, returns pointers to PTEs.
1077 */
1078static int find_valid_gpt(struct blk_desc *dev_desc, gpt_header *gpt_head,
1079 gpt_entry **pgpt_pte)
1080{
Urja Rannikko0557d462019-04-11 20:27:51 +00001081 int r;
1082
1083 r = is_gpt_valid(dev_desc, GPT_PRIMARY_PARTITION_TABLE_LBA, gpt_head,
1084 pgpt_pte);
1085
1086 if (r != 1) {
1087 if (r != 2)
Simon Glass3e62adc2022-10-20 18:22:40 -06001088 log_debug("Invalid GPT\n");
Urja Rannikko0557d462019-04-11 20:27:51 +00001089
1090 if (is_gpt_valid(dev_desc, (dev_desc->lba - 1), gpt_head,
1091 pgpt_pte) != 1) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001092 log_debug("Invalid Backup GPT\n");
Urja Rannikko20c568c2019-04-11 20:27:50 +00001093 return 0;
1094 }
Urja Rannikko0557d462019-04-11 20:27:51 +00001095 if (r != 2)
Simon Glass3e62adc2022-10-20 18:22:40 -06001096 log_debug(" Using Backup GPT\n");
Urja Rannikko20c568c2019-04-11 20:27:50 +00001097 }
1098 return 1;
1099}
1100
1101/**
richardretanubun07f3d782008-09-26 11:13:22 -04001102 * alloc_read_gpt_entries(): reads partition entries from disk
1103 * @dev_desc
1104 * @gpt - GPT header
1105 *
1106 * Description: Returns ptes on success, NULL on error.
1107 * Allocates space for PTEs based on information found in @gpt.
1108 * Notes: remember to free pte when you're done!
1109 */
Simon Glass4101f682016-02-29 15:25:34 -07001110static gpt_entry *alloc_read_gpt_entries(struct blk_desc *dev_desc,
1111 gpt_header *pgpt_head)
richardretanubun07f3d782008-09-26 11:13:22 -04001112{
Egbert Eichae1768a2013-04-09 06:03:36 +00001113 size_t count = 0, blk_cnt;
Stephen Warren7c4213f2015-12-07 11:38:48 -07001114 lbaint_t blk;
richardretanubun07f3d782008-09-26 11:13:22 -04001115 gpt_entry *pte = NULL;
1116
1117 if (!dev_desc || !pgpt_head) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001118 log_debug("Invalid Argument(s)\n");
richardretanubun07f3d782008-09-26 11:13:22 -04001119 return NULL;
1120 }
1121
Chang Hyun Parkfae2bf22012-12-11 11:09:45 +01001122 count = le32_to_cpu(pgpt_head->num_partition_entries) *
1123 le32_to_cpu(pgpt_head->sizeof_partition_entry);
richardretanubun07f3d782008-09-26 11:13:22 -04001124
Simon Glass3e62adc2022-10-20 18:22:40 -06001125 log_debug("count = %u * %u = %lu\n",
1126 (u32)le32_to_cpu(pgpt_head->num_partition_entries),
1127 (u32)le32_to_cpu(pgpt_head->sizeof_partition_entry),
1128 (ulong)count);
richardretanubun07f3d782008-09-26 11:13:22 -04001129
1130 /* Allocate memory for PTE, remember to FREE */
1131 if (count != 0) {
Egbert Eichae1768a2013-04-09 06:03:36 +00001132 pte = memalign(ARCH_DMA_MINALIGN,
1133 PAD_TO_BLOCKSIZE(count, dev_desc));
richardretanubun07f3d782008-09-26 11:13:22 -04001134 }
1135
1136 if (count == 0 || pte == NULL) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001137 log_debug("ERROR: Can't allocate %#lX bytes for GPT Entries\n",
1138 (ulong)count);
richardretanubun07f3d782008-09-26 11:13:22 -04001139 return NULL;
1140 }
1141
1142 /* Read GPT Entries from device */
Stephen Warren7c4213f2015-12-07 11:38:48 -07001143 blk = le64_to_cpu(pgpt_head->partition_entry_lba);
Egbert Eichae1768a2013-04-09 06:03:36 +00001144 blk_cnt = BLOCK_CNT(count, dev_desc);
Simon Glass2a981dc2016-02-29 15:25:52 -07001145 if (blk_dread(dev_desc, blk, (lbaint_t)blk_cnt, pte) != blk_cnt) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001146 log_debug("Can't read GPT Entries\n");
richardretanubun07f3d782008-09-26 11:13:22 -04001147 free(pte);
1148 return NULL;
1149 }
1150 return pte;
1151}
1152
1153/**
1154 * is_pte_valid(): validates a single Partition Table Entry
1155 * @gpt_entry - Pointer to a single Partition Table Entry
1156 *
1157 * Description: returns 1 if valid, 0 on error.
1158 */
1159static int is_pte_valid(gpt_entry * pte)
1160{
1161 efi_guid_t unused_guid;
1162
1163 if (!pte) {
Simon Glass3e62adc2022-10-20 18:22:40 -06001164 log_debug("Invalid Argument(s)\n");
richardretanubun07f3d782008-09-26 11:13:22 -04001165 return 0;
1166 }
1167
1168 /* Only one validation for now:
1169 * The GUID Partition Type != Unused Entry (ALL-ZERO)
1170 */
1171 memset(unused_guid.b, 0, sizeof(unused_guid.b));
1172
1173 if (memcmp(pte->partition_type_guid.b, unused_guid.b,
1174 sizeof(unused_guid.b)) == 0) {
1175
Simon Glass3e62adc2022-10-20 18:22:40 -06001176 log_debug("Found an unused PTE GUID at 0x%08X\n",
1177 (unsigned int)(uintptr_t)pte);
richardretanubun07f3d782008-09-26 11:13:22 -04001178
1179 return 0;
1180 } else {
1181 return 1;
1182 }
1183}
Simon Glass96e5b032016-02-29 15:25:47 -07001184
1185/*
1186 * Add an 'a_' prefix so it comes before 'dos' in the linker list. We need to
1187 * check EFI first, since a DOS partition is often used as a 'protective MBR'
1188 * with EFI.
1189 */
1190U_BOOT_PART_TYPE(a_efi) = {
1191 .name = "EFI",
1192 .part_type = PART_TYPE_EFI,
Petr Kulhavy87b85302016-09-09 10:27:15 +02001193 .max_entries = GPT_ENTRY_NUMBERS,
Simon Glass3e8bd462016-02-29 15:25:48 -07001194 .get_info = part_get_info_ptr(part_get_info_efi),
Simon Glass084bf4c2016-02-29 15:26:04 -07001195 .print = part_print_ptr(part_print_efi),
1196 .test = part_test_efi,
Simon Glass96e5b032016-02-29 15:25:47 -07001197};