From: Lukasz Majewski l.majewski@samsung.com
The restoration of GPT table (both primary and secondary) is now possible. Simple GUID generation is supported.
Signed-off-by: Lukasz Majewski l.majewski@samsung.com Signed-off-by: Piotr Wilczek p.wilczek@samsung.com Signed-off-by: Kyungmin Park kyungmin.park@samsung.com --- Changes for v2: - Move GPT Header and Page Table Entries generation code to cmd_gpt.c - Provide clean API to use set_gpt_table function for GPT restoration on a block device
Changes for v3: - Replace printf with puts
Changes for v4: - Add public functions for fill gpt header and entries - Add public function for fill and save gpt tables on the basis of simple partions list information --- disk/part_efi.c | 342 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ include/part.h | 8 ++ 2 files changed, 350 insertions(+), 0 deletions(-)
diff --git a/disk/part_efi.c b/disk/part_efi.c index bacb40a..e501ac1 100644 --- a/disk/part_efi.c +++ b/disk/part_efi.c @@ -37,6 +37,8 @@ #include <part_efi.h> #include <linux/ctype.h>
+DECLARE_GLOBAL_DATA_PTR; + #if defined(CONFIG_CMD_IDE) || \ defined(CONFIG_CMD_SATA) || \ defined(CONFIG_CMD_SCSI) || \ @@ -71,6 +73,16 @@ static gpt_entry *alloc_read_gpt_entries(block_dev_desc_t * dev_desc,
static int is_pte_valid(gpt_entry * pte);
+static int set_protective_mbr(block_dev_desc_t *dev_desc); + +static void guid_dump(u8 *guid, int i); + +static void guid_gen(const u32 *pool, u8 *guid); + +static int convert_uuid(char *uuid, u8 *dst); + +static void set_part_name(efi_char16_t *part_name, char *name); + static char *print_efiname(gpt_entry *pte) { static char name[PARTNAME_SZ + 1]; @@ -225,6 +237,197 @@ int test_part_efi(block_dev_desc_t * dev_desc) return 0; }
+/** + * set_gpt_table() - Restore the GUID Partition Table + * + * @param dev_desc - block device descriptor + * @param parts - number of partitions + * @param size - pointer to array with each partition size + * @param name - pointer to array with each partition name + * + * @return - zero on success, otherwise error + */ +int set_gpt_table(block_dev_desc_t *dev_desc, + gpt_header *gpt_h, gpt_entry *gpt_e) +{ + const int pte_blk_num = (GPT_ENTRY_NUMBERS * sizeof(gpt_entry)) / + dev_desc->blksz; + u32 calc_crc32; + u64 val; + + debug("max lba: %x\n", (u32) dev_desc->lba); + /* Setup the Protective MBR */ + if (set_protective_mbr(dev_desc) < 0) + goto err; + + /* Generate CRC for the Primary GPT Header */ + calc_crc32 = efi_crc32((const unsigned char *)gpt_e, + le32_to_cpu(gpt_h->num_partition_entries) * + le32_to_cpu(gpt_h->sizeof_partition_entry)); + gpt_h->partition_entry_array_crc32 = cpu_to_le32(calc_crc32); + + calc_crc32 = efi_crc32((const unsigned char *)gpt_h, + le32_to_cpu(gpt_h->header_size)); + gpt_h->header_crc32 = cpu_to_le32(calc_crc32); + + /* Write the First GPT to the block right after the Legacy MBR */ + if (dev_desc->block_write(dev_desc->dev, 1, 1, gpt_h) != 1) + goto err; + + if (dev_desc->block_write(dev_desc->dev, 2, pte_blk_num, gpt_e) + != pte_blk_num) + goto err; + + /* recalculate the values for the Second GPT Header*/ + val = le64_to_cpu(gpt_h->my_lba); + gpt_h->my_lba = gpt_h->alternate_lba; + gpt_h->alternate_lba = cpu_to_le64(val); + gpt_h->header_crc32 = 0; + + calc_crc32 = efi_crc32((const unsigned char *)gpt_h, + le32_to_cpu(gpt_h->header_size)); + gpt_h->header_crc32 = cpu_to_le32(calc_crc32); + + if (dev_desc->block_write(dev_desc->dev, + le32_to_cpu(gpt_h->last_usable_lba + 1), + pte_blk_num, gpt_e) != pte_blk_num) + goto err; + + if (dev_desc->block_write(dev_desc->dev, + le32_to_cpu(gpt_h->my_lba), 1, gpt_h) != 1) + goto err; + + puts("GPT successfully written to block device!\n"); + return 0; + + err: + printf("** Can't write to device %d **\n", + dev_desc->dev); + return -1; +} + +/** + * gpt_fill_pte(): Fill the GPT partition table entry + * + * @param gpt_h - GPT header representation + * @param gpt_e - GPT partition table entries + * @param partitions - list of partitions + * @param parts - number of partitions + */ +void gpt_fill_pte(gpt_header *gpt_h, gpt_entry *gpt_e, + disk_partition_t *partitions[], int parts) +{ + u32 offset = (u32) le32_to_cpu(gpt_h->first_usable_lba); + u8 guid[sizeof(efi_guid_t)]; + char *str_uuid; + ulong start; + int i; + + for (i = 0; i < parts; i++) { + /* partition starting lba */ + start = partitions[i]->start; + if (start && (offset <= start)) + gpt_e[i].starting_lba = cpu_to_le32(start); + else + gpt_e[i].starting_lba = cpu_to_le32(offset); + + offset = le32_to_cpu(gpt_e[i].starting_lba) + + partitions[i]->size; + if (offset >= gpt_h->last_usable_lba) { + printf("Partitions layout excedds disk size\n"); + return; + } + /* partition ending lba */ + if (i != parts - 1) + gpt_e[i].ending_lba = + cpu_to_le64(offset - 1); + else + gpt_e[i].ending_lba = gpt_h->last_usable_lba; + + /* partition type GUID*/ + memcpy(gpt_e[i].partition_type_guid.b, + &PARTITION_BASIC_DATA_GUID, 16); + + str_uuid = NULL; +#ifdef CONFIG_PARTITION_UUIDS + str_uuid = partitions[i]->uuid; +#endif + if (convert_uuid(str_uuid, gpt_e[i].unique_partition_guid.b)) { + guid_gen((((u32 *) gd->start_addr_sp) - i - 1), + guid); + memcpy(gpt_e[i].unique_partition_guid.b, guid, + sizeof(efi_guid_t)); + } + + /* partition attributes */ + memset(&gpt_e[i].attributes, 0, + sizeof(gpt_entry_attributes)); + + /* partition name */ + set_part_name(gpt_e[i].partition_name, + (char *)partitions[i]->name); + + debug("%s: name: %s offset[%d]: 0x%x size[%d]: 0x%lx\n", + __func__, partitions[i]->name, i, + offset, i, partitions[i]->size); + } +} + +/** + * gpt_fill_header(): Fill the GPT header + * + * @param dev_desc - block device descriptor + * @param gpt_h - GPT header representation + */ +void gpt_fill_header(block_dev_desc_t *dev_desc, gpt_header *gpt_h) +{ + u8 guid[sizeof(gpt_h->disk_guid.b)]; + char *s; + + gpt_h->signature = cpu_to_le64(GPT_HEADER_SIGNATURE); + gpt_h->revision = cpu_to_le32(GPT_HEADER_REVISION_V1); + gpt_h->header_size = cpu_to_le32(sizeof(gpt_header)); + gpt_h->my_lba = cpu_to_le64(1); + gpt_h->alternate_lba = cpu_to_le64(dev_desc->lba - 1); + gpt_h->first_usable_lba = cpu_to_le64(34); + gpt_h->last_usable_lba = cpu_to_le64(dev_desc->lba - 34); + gpt_h->partition_entry_lba = cpu_to_le64(2); + gpt_h->num_partition_entries = cpu_to_le32(GPT_ENTRY_NUMBERS); + gpt_h->sizeof_partition_entry = cpu_to_le32(sizeof(gpt_entry)); + gpt_h->header_crc32 = 0; + gpt_h->partition_entry_array_crc32 = 0; + + s = getenv("uuid_gpt_disk"); + if (!convert_uuid(s, gpt_h->disk_guid.b)) { + guid_gen((u32 *)gd->start_addr_sp, guid); + memcpy(gpt_h->disk_guid.b, guid, sizeof(efi_guid_t)); + } +} + +/** + * gpt_fill(): Fill the GPT header + * + * @param dev_desc - block device descriptor + * @param partitions - list of partitions + * @param parts - number of partitions + */ +void gpt_fill(block_dev_desc_t *dev_desc, disk_partition_t *partitions[], + const int parts_count) +{ + gpt_header *gpt_h = calloc(sizeof(gpt_header), 1); + gpt_entry *gpt_e = calloc(sizeof(gpt_entry), GPT_ENTRY_NUMBERS); + + /* Generate Primary GPT header (LBA1) */ + gpt_fill_header(dev_desc, gpt_h); + gpt_fill_pte(gpt_h, gpt_e, partitions, parts_count); + + puts("save the GPT ...\n"); + set_gpt_table(dev_desc, gpt_h, gpt_e); + + free(gpt_e); + free(gpt_h); +} + /* * Private functions */ @@ -453,4 +656,143 @@ static int is_pte_valid(gpt_entry * pte) return 1; } } + +/** + * set_protective_mbr(): Set the EFI protective MBR + * @param dev_desc - block device descriptor + * + * @return - zero on success, otherwise error + */ +static int set_protective_mbr(block_dev_desc_t *dev_desc) +{ + legacy_mbr p_mbr; + + /* Setup the Protective MBR */ + memset((u32 *) &p_mbr, 0x00, sizeof(p_mbr)); + /* Append signature */ + p_mbr.signature = MSDOS_MBR_SIGNATURE; + p_mbr.partition_record[0].sys_ind = EFI_PMBR_OSTYPE_EFI_GPT; + p_mbr.partition_record[0].start_sect = 1; + p_mbr.partition_record[0].nr_sects = (u32) dev_desc->lba; + + /* Write MBR sector to the MMC device */ + if (dev_desc->block_write(dev_desc->dev, 0, 1, &p_mbr) != 1) { + printf("** Can't write to device %d **\n", + dev_desc->dev); + return -1; + } + + return 0; +} + +#ifdef DEBUG +/** + * guid_dump(): Dump guid content + * + * @param guid - pinter to guid + * @param i - number of bytes to dump + */ +static void guid_dump(u8 *guid, int i) +{ + int k; + + debug("GUID: "); + for (k = 0; k < i; k++, guid++) + debug(" %x ", *guid); + debug("\n"); +} +#else +static void guid_dump(u8 *guid, int i) {} +#endif + +/** + * guid_gen(): Generate UUID + * + * @param pool - pointer to pseudo random data (e.g. SP) + * @param guid - pointer to guid table + * + * @return - generated UUID table + * + * NOTE: The entrophy of this function is small + */ +static void guid_gen(const u32 *pool, u8 *guid) +{ + int k = 0; + u32 *ptr = (u32 *) guid; + + debug("%s: pool: 0x%p guid: 0x%p\n", __func__, pool, guid); + for (k = 0; k < 4; k++) + *(ptr + k) = crc32((u32) pool, (const void *) (pool - k), 512); + + guid_dump(guid, sizeof(efi_guid_t)); +} + +/** + * convert_uuid(); Convert UUID stored as string to bytes + * + * @param uuid - UUID represented as string + * @param dst - GUID buffer + * + * @return return 0 on successful conversion + */ +static int convert_uuid(char *uuid, u8 *dst) +{ + efi_guid_t guid; + u16 b, c, d; + u64 e; + u32 a; + u8 *p; + u8 i; + + const u8 uuid_str_len = 36; + + /* The UUID is written in text: */ + /* 1 9 14 19 24 */ + /* xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx */ + + debug("%s: uuid: %s\n", __func__, uuid); + + if (strlen(uuid) != uuid_str_len) + return -1; + + for (i = 0; i < uuid_str_len; i++) { + if ((i == 8) || (i == 13) || (i == 18) || (i == 23)) { + if (uuid[i] != '-') + return -1; + } else { + if (!isxdigit(uuid[i])) + return -1; + } + } + + a = (u32)simple_strtoul(uuid, NULL, 16); + b = (u16)simple_strtoul(uuid + 9, NULL, 16); + c = (u16)simple_strtoul(uuid + 14, NULL, 16); + d = (u16)simple_strtoul(uuid + 19, NULL, 16); + e = (u64)simple_strtoull(uuid + 24, NULL, 16); + + p = (u8 *) &e; + guid = EFI_GUID(a, b, c, d >> 8, d & 0xFF, + *(p + 5), *(p + 4), *(p + 3), + *(p + 2), *(p + 1) , *p); + + guid_dump(guid.b, sizeof(efi_guid_t)); + memcpy(dst, guid.b, sizeof(efi_guid_t)); + + return 0; +} + +static void set_part_name(efi_char16_t *part_name, char *name) +{ + int k, j; + char p[PARTNAME_SZ]; + + memset(p, 0x00, sizeof(p)); + for (k = 0, j = 0; k < strlen(name); k++, j += 2) { + p[j] = *(name + k); + p[j + 1] = '.'; + } + memcpy(part_name, p, strlen(p)); +} + #endif diff --git a/include/part.h b/include/part.h index 27ea283..40e175a 100644 --- a/include/part.h +++ b/include/part.h @@ -176,10 +176,18 @@ int test_part_amiga (block_dev_desc_t *dev_desc); #endif
#ifdef CONFIG_EFI_PARTITION +#include <part_efi.h> /* disk/part_efi.c */ int get_partition_info_efi (block_dev_desc_t * dev_desc, int part, disk_partition_t *info); void print_part_efi (block_dev_desc_t *dev_desc); int test_part_efi (block_dev_desc_t *dev_desc); +int set_gpt_table(block_dev_desc_t *dev_desc, + gpt_header *gpt_h, gpt_entry *gpt_e); +void gpt_fill_pte(gpt_header *gpt_h, gpt_entry *gpt_e, + disk_partition_t *partitions[], int parts); +void gpt_fill_header(block_dev_desc_t *dev_desc, gpt_header *gpt_h); +void gpt_fill(block_dev_desc_t *dev_desc, disk_partition_t *partitions[], + const int parts_count); #endif
#endif /* _PART_H */