diff options
Diffstat (limited to 'common')
| -rw-r--r-- | common/Kconfig | 14 | ||||
| -rw-r--r-- | common/Makefile | 4 | ||||
| -rw-r--r-- | common/console.c | 85 | ||||
| -rw-r--r-- | common/console_common.c | 110 | ||||
| -rw-r--r-- | common/console_none.c | 42 | ||||
| -rw-r--r-- | common/console_simple.c | 83 | ||||
| -rw-r--r-- | common/filetype.c | 52 | ||||
| -rw-r--r-- | common/memsize.c | 3 | ||||
| -rw-r--r-- | common/menu.c | 2 | ||||
| -rw-r--r-- | common/oftree.c | 93 | ||||
| -rw-r--r-- | common/partitions.c | 187 | ||||
| -rw-r--r-- | common/partitions/Kconfig | 32 | ||||
| -rw-r--r-- | common/partitions/Makefile | 2 | ||||
| -rw-r--r-- | common/partitions/dos.c | 88 | ||||
| -rw-r--r-- | common/partitions/efi.c | 477 | ||||
| -rw-r--r-- | common/partitions/efi.h | 123 | ||||
| -rw-r--r-- | common/partitions/parser.h | 37 |
17 files changed, 1114 insertions, 320 deletions
diff --git a/common/Kconfig b/common/Kconfig index 3f6c11ec5c..3a55e017f4 100644 --- a/common/Kconfig +++ b/common/Kconfig @@ -478,19 +478,7 @@ config PARTITION bool prompt "Enable Partitions" -config PARTITION_DISK - depends on PARTITION - bool "DISK partition support" - help - Add support for handling common partition tables on all kind of disk - like devices (harddisks, CF cards, SD cards and so on) - -config PARTITION_DISK_DOS - depends on PARTITION_DISK - default y - bool "DOS partition support" - help - Add support to handle partitions in DOS style. +source common/partitions/Kconfig config DEFAULT_ENVIRONMENT bool diff --git a/common/Makefile b/common/Makefile index 7206eed8b1..1b3b009a3a 100644 --- a/common/Makefile +++ b/common/Makefile @@ -7,7 +7,7 @@ obj-$(CONFIG_ENV_HANDLING) += environment.o obj-$(CONFIG_AUTO_COMPLETE) += complete.o obj-$(CONFIG_POLLER) += poller.o obj-$(CONFIG_BLOCK) += block.o -obj-$(CONFIG_PARTITION_DISK) += partitions.o +obj-$(CONFIG_PARTITION_DISK) += partitions.o partitions/ obj-$(CONFIG_CMD_LOADS) += s_record.o obj-$(CONFIG_OFTREE) += oftree.o @@ -23,7 +23,7 @@ obj-$(CONFIG_MEMINFO) += meminfo.o obj-$(CONFIG_COMMAND_SUPPORT) += command.o obj-$(CONFIG_CONSOLE_FULL) += console.o obj-$(CONFIG_CONSOLE_SIMPLE) += console_simple.o -obj-$(CONFIG_CONSOLE_NONE) += console_none.o +obj-y += console_common.o obj-$(CONFIG_DIGEST) += digest.o obj-$(CONFIG_ENVIRONMENT_VARIABLES) += env.o obj-$(CONFIG_UIMAGE) += image.o diff --git a/common/console.c b/common/console.c index a085e2dfd3..beb37bddc1 100644 --- a/common/console.c +++ b/common/console.c @@ -305,24 +305,6 @@ void console_putc(unsigned int ch, char c) } EXPORT_SYMBOL(console_putc); -int fputc(int fd, char c) -{ - if(list_empty(&console_list)) { - if(!fd) - console_putc(0, c); - return 0; - } - - if (fd == 1) - putchar(c); - else if (fd == 2) - eputc(c); - else - return write(fd, &c, 1); - return 0; -} -EXPORT_SYMBOL(fputc); - int console_puts(unsigned int ch, const char *str) { const char *s = str; @@ -341,17 +323,6 @@ int console_puts(unsigned int ch, const char *str) } EXPORT_SYMBOL(console_puts); -int fputs(int fd, const char *s) -{ - if (fd == 1) - return puts(s); - else if (fd == 2) - return eputs(s); - else - return write(fd, s, strlen(s)); -} -EXPORT_SYMBOL(fputs); - void console_flush(void) { struct console_device *cdev; @@ -363,62 +334,6 @@ void console_flush(void) } EXPORT_SYMBOL(console_flush); -int fprintf(int file, const char *fmt, ...) -{ - va_list args; - char printbuffer[CFG_PBSIZE]; - - va_start (args, fmt); - - /* For this to work, printbuffer must be larger than - * anything we ever want to print. - */ - vsprintf (printbuffer, fmt, args); - va_end (args); - - /* Print the string */ - return fputs(file, printbuffer); -} -EXPORT_SYMBOL(fprintf); - -int printf (const char *fmt, ...) -{ - va_list args; - uint i; - char printbuffer[CFG_PBSIZE]; - - va_start (args, fmt); - - /* For this to work, printbuffer must be larger than - * anything we ever want to print. - */ - i = vsprintf (printbuffer, fmt, args); - va_end (args); - - /* Print the string */ - puts (printbuffer); - - return i; -} -EXPORT_SYMBOL(printf); - -int vprintf (const char *fmt, va_list args) -{ - uint i; - char printbuffer[CFG_PBSIZE]; - - /* For this to work, printbuffer must be larger than - * anything we ever want to print. - */ - i = vsprintf (printbuffer, fmt, args); - - /* Print the string */ - puts (printbuffer); - - return i; -} -EXPORT_SYMBOL(vprintf); - #ifndef ARCH_HAS_CTRLC /* test if ctrl-c was pressed */ int ctrlc (void) diff --git a/common/console_common.c b/common/console_common.c new file mode 100644 index 0000000000..d139d1a8fe --- /dev/null +++ b/common/console_common.c @@ -0,0 +1,110 @@ +/* + * based on code: + * + * (C) Copyright 2000 Paolo Scaffardi, AIRVENT SAM s.p.a - + * RIMINI(ITALY), arsenio@tin.it + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ +#include <common.h> +#include <fs.h> +#include <errno.h> + +#ifndef CONFIG_CONSOLE_NONE + +int printf(const char *fmt, ...) +{ + va_list args; + uint i; + char printbuffer[CFG_PBSIZE]; + + va_start(args, fmt); + + /* + * For this to work, printbuffer must be larger than + * anything we ever want to print. + */ + i = vsprintf (printbuffer, fmt, args); + va_end(args); + + /* Print the string */ + puts(printbuffer); + + return i; +} +EXPORT_SYMBOL(printf); + +int vprintf(const char *fmt, va_list args) +{ + uint i; + char printbuffer[CFG_PBSIZE]; + + /* + * For this to work, printbuffer must be larger than + * anything we ever want to print. + */ + i = vsprintf(printbuffer, fmt, args); + + /* Print the string */ + puts(printbuffer); + + return i; +} +EXPORT_SYMBOL(vprintf); + +#endif /* !CONFIG_CONSOLE_NONE */ + +int fprintf(int file, const char *fmt, ...) +{ + va_list args; + char printbuffer[CFG_PBSIZE]; + + va_start(args, fmt); + + /* + * For this to work, printbuffer must be larger than + * anything we ever want to print. + */ + vsprintf(printbuffer, fmt, args); + va_end(args); + + /* Print the string */ + return fputs(file, printbuffer); +} +EXPORT_SYMBOL(fprintf); + +int fputs(int fd, const char *s) +{ + if (fd == 1) + return puts(s); + else if (fd == 2) + return eputs(s); + else + return write(fd, s, strlen(s)); +} +EXPORT_SYMBOL(fputs); + +int fputc(int fd, char c) +{ + if (fd == 1) + putchar(c); + else if (fd == 2) + eputc(c); + else + return write(fd, &c, 1); + + return 0; +} +EXPORT_SYMBOL(fputc); diff --git a/common/console_none.c b/common/console_none.c deleted file mode 100644 index b6018148d2..0000000000 --- a/common/console_none.c +++ /dev/null @@ -1,42 +0,0 @@ -#include <config.h> -#include <common.h> -#include <fs.h> -#include <errno.h> -#include <debug_ll.h> - -int fputc(int fd, char c) -{ - if (fd != 1 && fd != 2) - return write(fd, &c, 1); - return 0; -} -EXPORT_SYMBOL(fputc); - -int fputs(int fd, const char *s) -{ - if (fd != 1 && fd != 2) - return write(fd, s, strlen(s)); - return 0; -} -EXPORT_SYMBOL(fputs); - -int fprintf(int file, const char *fmt, ...) -{ - va_list args; - uint i; - char printbuffer[CFG_PBSIZE]; - - va_start (args, fmt); - - /* For this to work, printbuffer must be larger than - * anything we ever want to print. - */ - i = vsprintf (printbuffer, fmt, args); - va_end (args); - - /* Print the string */ - fputs(file, printbuffer); - - return i; -} -EXPORT_SYMBOL(fprintf); diff --git a/common/console_simple.c b/common/console_simple.c index a4d4315c72..1fe569ef9d 100644 --- a/common/console_simple.c +++ b/common/console_simple.c @@ -8,65 +8,6 @@ LIST_HEAD(console_list); EXPORT_SYMBOL(console_list); static struct console_device *console; -int printf (const char *fmt, ...) -{ - va_list args; - uint i; - char printbuffer[CFG_PBSIZE]; - - va_start (args, fmt); - - /* For this to work, printbuffer must be larger than - * anything we ever want to print. - */ - i = vsprintf (printbuffer, fmt, args); - va_end (args); - - /* Print the string */ - puts(printbuffer); - - return i; -} -EXPORT_SYMBOL(printf); - -int vprintf (const char *fmt, va_list args) -{ - uint i; - char printbuffer[CFG_PBSIZE]; - - /* For this to work, printbuffer must be larger than - * anything we ever want to print. - */ - i = vsprintf (printbuffer, fmt, args); - - /* Print the string */ - puts (printbuffer); - - return i; -} -EXPORT_SYMBOL(vprintf); - -int fprintf(int file, const char *fmt, ...) -{ - va_list args; - uint i; - char printbuffer[CFG_PBSIZE]; - - va_start (args, fmt); - - /* For this to work, printbuffer must be larger than - * anything we ever want to print. - */ - i = vsprintf (printbuffer, fmt, args); - va_end (args); - - /* Print the string */ - fputs(file, printbuffer); - - return i; -} -EXPORT_SYMBOL(fprintf); - int console_puts(unsigned int ch, const char *str) { const char *s = str; @@ -97,30 +38,6 @@ void console_putc(unsigned int ch, char c) } EXPORT_SYMBOL(console_putc); -int fputc(int fd, char c) -{ - if (fd == 1) - putchar(c); - else if (fd == 2) - eputc(c); - else - return write(fd, &c, 1); - return 0; -} -EXPORT_SYMBOL(fputc); - -int fputs(int fd, const char *s) -{ - if (fd == 1) - puts(s); - else if (fd == 2) - eputs(s); - else - return write(fd, s, strlen(s)); - return 0; -} -EXPORT_SYMBOL(fputs); - int tstc(void) { if (!console) diff --git a/common/filetype.c b/common/filetype.c index 22fc621a14..8652f1d7af 100644 --- a/common/filetype.c +++ b/common/filetype.c @@ -48,6 +48,7 @@ static const struct filetype_str filetype_str[] = { [filetype_bmp] = { "BMP image", "bmp" }, [filetype_png] = { "PNG image", "png" }, [filetype_ext] = { "ext filesystem", "ext" }, + [filetype_gpt] = { "GUID Partition Table", "gpt" }, }; const char *file_type_to_string(enum filetype f) @@ -69,9 +70,53 @@ const char *file_type_to_short_string(enum filetype f) #define MBR_StartSector 8 /* MBR: Offset of Starting Sector in Partition Table Entry */ #define BS_55AA 510 /* Boot sector signature (2) */ #define MBR_Table 446 /* MBR: Partition table offset (2) */ +#define MBR_partition_size 16 /* MBR: Partition table offset (2) */ #define BS_FilSysType32 82 /* File system type (1) */ #define BS_FilSysType 54 /* File system type (1) */ +#define MBR_PART_sys_ind 4 +#define MBR_PART_start_sect 8 +#define MBR_OSTYPE_EFI_GPT 0xee + +static inline int pmbr_part_valid(const uint8_t *buf) +{ + if (buf[MBR_PART_sys_ind] == MBR_OSTYPE_EFI_GPT && + get_unaligned_le32(&buf[MBR_PART_start_sect]) == 1UL) { + return 1; + } + + return 0; +} + +/** + * is_gpt_valid(): test Protective MBR for validity and EFI PART + * @mbr: pointer to a legacy mbr structure + * + * Description: Returns 1 if PMBR is valid and EFI PART, 0 otherwise. + * Validity depends on three things: + * 1) MSDOS signature is in the last two bytes of the MBR + * 2) One partition of type 0xEE is found + * 3) EFI GPT signature is at offset 512 + */ +static int is_gpt_valid(const uint8_t *buf) +{ + int i; + + if (get_unaligned_le16(&buf[BS_55AA]) != 0xAA55) + return 0; + + if (strncmp(&buf[512], "EFI PART", 8)) + return 0; + + buf += MBR_Table; + + for (i = 0; i < 4; i++, buf += MBR_partition_size) { + if (pmbr_part_valid(buf)) + return 1; + } + return 0; +} + enum filetype is_fat_or_mbr(const unsigned char *sector, unsigned long *bootsec) { /* @@ -159,6 +204,13 @@ enum filetype file_detect_type(const void *_buf, size_t bufsize) if (bufsize < 512) return filetype_unknown; + /* + * EFI GPT need to be detected before MBR otherwise + * we will detect a MBR + */ + if (bufsize >= 520 && is_gpt_valid(buf8)) + return filetype_gpt; + type = is_fat_or_mbr(buf8, NULL); if (type != filetype_unknown) return type; diff --git a/common/memsize.c b/common/memsize.c index d149e41845..ef6381babd 100644 --- a/common/memsize.c +++ b/common/memsize.c @@ -33,6 +33,9 @@ * Check memory range for valid RAM. A simple memory test determines * the actually available RAM size between addresses `base' and * `base + maxsize'. + * + * This function modifies the RAM. Do not use it if you're running from + * the RAM you are going to detect! */ long get_ram_size(volatile long *base, long maxsize) { diff --git a/common/menu.c b/common/menu.c index ce93838f74..a672e59c0b 100644 --- a/common/menu.c +++ b/common/menu.c @@ -274,7 +274,7 @@ int menu_show(struct menu *m) printf("Auto Select in"); } else { auto_display_len = strlen(m->auto_display); - printf(m->auto_display); + printf("%s", m->auto_display); } printf(" %2d", countdown--); } diff --git a/common/oftree.c b/common/oftree.c index 0df5209bda..82e5ddd60b 100644 --- a/common/oftree.c +++ b/common/oftree.c @@ -229,6 +229,33 @@ void do_fixup_by_path_u32(struct fdt_header *fdt, const char *path, do_fixup_by_path(fdt, path, prop, &val, sizeof(val), create); } +void do_fixup_by_compatible(struct fdt_header *fdt, const char *compatible, + const char *prop, const void *val, int len, int create) +{ + int off = -1; + + off = fdt_node_offset_by_compatible(fdt, -1, compatible); + while (off != -FDT_ERR_NOTFOUND) { + if (create || (fdt_get_property(fdt, off, prop, 0) != NULL)) + fdt_setprop(fdt, off, prop, val, len); + off = fdt_node_offset_by_compatible(fdt, off, compatible); + } +} + +void do_fixup_by_compatible_u32(struct fdt_header *fdt, const char *compatible, + const char *prop, u32 val, int create) +{ + val = cpu_to_fdt32(val); + do_fixup_by_compatible(fdt, compatible, prop, &val, 4, create); +} + +void do_fixup_by_compatible_string(struct fdt_header *fdt, const char *compatible, + const char *prop, const char *val, int create) +{ + do_fixup_by_compatible(fdt, compatible, prop, val, strlen(val) + 1, + create); +} + int fdt_get_path_or_create(struct fdt_header *fdt, const char *path) { int nodeoffset; @@ -246,6 +273,72 @@ int fdt_get_path_or_create(struct fdt_header *fdt, const char *path) return nodeoffset; } +int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end, int force) +{ + int nodeoffset; + int err, j, total; + u32 tmp; + const char *path; + uint64_t addr, size; + + /* Find the "chosen" node */ + nodeoffset = fdt_path_offset(fdt, "/chosen"); + + /* If there is no "chosen" node in the blob return */ + if (nodeoffset < 0) { + printf("fdt_initrd: %s\n", fdt_strerror(nodeoffset)); + return nodeoffset; + } + + /* just return if initrd_start/end aren't valid */ + if ((initrd_start == 0) || (initrd_end == 0)) + return 0; + + total = fdt_num_mem_rsv(fdt); + + /* + * Look for an existing entry and update it. If we don't find + * the entry, we will j be the next available slot. + */ + for (j = 0; j < total; j++) { + err = fdt_get_mem_rsv(fdt, j, &addr, &size); + if (addr == initrd_start) { + fdt_del_mem_rsv(fdt, j); + break; + } + } + + err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start); + if (err < 0) { + printf("fdt_initrd: %s\n", fdt_strerror(err)); + return err; + } + + path = fdt_getprop(fdt, nodeoffset, "linux,initrd-start", NULL); + if (!path || force) { + tmp = __cpu_to_be32(initrd_start); + err = fdt_setprop(fdt, nodeoffset, + "linux,initrd-start", &tmp, sizeof(tmp)); + if (err < 0) { + printf("WARNING: " + "could not set linux,initrd-start %s.\n", + fdt_strerror(err)); + return err; + } + tmp = __cpu_to_be32(initrd_end); + err = fdt_setprop(fdt, nodeoffset, + "linux,initrd-end", &tmp, sizeof(tmp)); + if (err < 0) { + printf("WARNING: could not set linux,initrd-end %s.\n", + fdt_strerror(err)); + + return err; + } + } + + return 0; +} + static int of_fixup_bootargs(struct fdt_header *fdt) { int nodeoffset; diff --git a/common/partitions.c b/common/partitions.c index 24310a3a4f..dd25160602 100644 --- a/common/partitions.c +++ b/common/partitions.c @@ -27,112 +27,87 @@ #include <block.h> #include <asm/unaligned.h> #include <disks.h> -#include <dma.h> #include <filetype.h> +#include <dma.h> -struct partition { - uint64_t first_sec; - uint64_t size; -}; +#include "partitions/parser.h" -struct partition_desc { - int used_entries; - struct partition parts[8]; -}; +static LIST_HEAD(partition_parser_list); /** - * Guess the size of the disk, based on the partition table entries - * @param dev device to create partitions for - * @param table partition table - * @return sector count + * Register one partition on the given block device + * @param blk Block device to register to + * @param part Partition description + * @param no Partition number + * @return 0 on success */ -static int disk_guess_size(struct device_d *dev, struct partition_entry *table) +static int register_one_partition(struct block_device *blk, + struct partition *part, int no) { - uint64_t size = 0; - int i; - - for (i = 0; i < 4; i++) { - if (table[i].partition_start != 0) { - size += get_unaligned_le32(&table[i].partition_start) - size; - size += get_unaligned_le32(&table[i].partition_size); - } - } + char *partition_name; + int ret; + uint64_t start = part->first_sec * SECTOR_SIZE; + uint64_t size = part->size * SECTOR_SIZE; + + partition_name = asprintf("%s.%d", blk->cdev.name, no); + if (!partition_name) + return -ENOMEM; + dev_dbg(blk->dev, "Registering partition %s on drive %s\n", + partition_name, blk->cdev.name); + ret = devfs_add_partition(blk->cdev.name, + start, size, 0, partition_name); + if (ret) + goto out; - return (int)size; -} + free(partition_name); -/** - * Check if a DOS like partition describes this block device - * @param blk Block device to register to - * @param pd Where to store the partition information - * - * It seems at least on ARM this routine canot use temp. stack space for the - * sector. So, keep the malloc/free. - */ -static void __maybe_unused try_dos_partition(struct block_device *blk, - struct partition_desc *pd) -{ - uint8_t *buffer; - struct partition_entry *table; - struct partition pentry; - int i, rc; + if (!part->name[0]) + return 0; - buffer = dma_alloc(SECTOR_SIZE); + partition_name = asprintf("%s.%s", blk->cdev.name, part->name); + if (!partition_name) + return -ENOMEM; - /* read in the MBR to get the partition table */ - rc = blk->ops->read(blk, buffer, 0, 1); - if (rc != 0) { - dev_err(blk->dev, "Cannot read MBR/partition table\n"); - goto on_error; - } + dev_dbg(blk->dev, "Registering partition %s on drive %s\n", + partition_name, blk->cdev.name); + ret = devfs_add_partition(blk->cdev.name, + start, size, 0, partition_name); - if (is_fat_or_mbr(buffer, NULL) != filetype_mbr) { - dev_info(blk->dev, "No partition table found\n"); - goto on_error; - } + if (ret) + dev_warn(blk->dev, "Registering partition %s on drive %s failed\n", + partition_name, blk->cdev.name); - table = (struct partition_entry *)&buffer[446]; + ret = 0; +out: + free(partition_name); + return 0; +} - /* valid for x86 BIOS based disks only */ - if (IS_ENABLED(CONFIG_DISK_BIOS) && blk->num_blocks == 0) - blk->num_blocks = disk_guess_size(blk->dev, table); +static struct partition_parser *partition_parser_get_by_filetype(uint8_t *buf) +{ + enum filetype type; + struct partition_parser *parser; - for (i = 0; i < 4; i++) { - pentry.first_sec = get_unaligned_le32(&table[i].partition_start); - pentry.size = get_unaligned_le32(&table[i].partition_size); + /* first new partition table as EFI GPT */ + type = file_detect_type(buf, SECTOR_SIZE * 2); - if (pentry.first_sec != 0) { - pd->parts[pd->used_entries].first_sec = pentry.first_sec; - pd->parts[pd->used_entries].size = pentry.size; - pd->used_entries++; - } else { - dev_dbg(blk->dev, "Skipping empty partition %d\n", i); - } + list_for_each_entry(parser, &partition_parser_list, list) { + if (parser->type == type) + return parser; } -on_error: - dma_free(buffer); -} + /* if not parser found search for old one + * so if EFI GPT not enable take it as MBR + * useful for compatibility + */ + type = file_detect_type(buf, SECTOR_SIZE); -/** - * Register one partition on the given block device - * @param blk Block device to register to - * @param part Partition description - * @param no Partition number - * @return 0 on success - */ -static int register_one_partition(struct block_device *blk, - struct partition *part, int no) -{ - char partition_name[19]; + list_for_each_entry(parser, &partition_parser_list, list) { + if (parser->type == type) + return parser; + } - sprintf(partition_name, "%s.%d", blk->cdev.name, no); - dev_dbg(blk->dev, "Registering partition %s on drive %s\n", - partition_name, blk->cdev.name); - return devfs_add_partition(blk->cdev.name, - part->first_sec * SECTOR_SIZE, - part->size * SECTOR_SIZE, - 0, partition_name); + return NULL; } /** @@ -144,19 +119,33 @@ static int register_one_partition(struct block_device *blk, */ int parse_partition_table(struct block_device *blk) { - struct partition_desc pdesc = { .used_entries = 0, }; + struct partition_desc *pdesc; int i; int rc = 0; + struct partition_parser *parser; + uint8_t *buf; -#ifdef CONFIG_PARTITION_DISK_DOS - try_dos_partition(blk, &pdesc); -#endif - if (!pdesc.used_entries) - return 0; + pdesc = xzalloc(sizeof(*pdesc)); + buf = dma_alloc(SECTOR_SIZE * 2); + + rc = blk->ops->read(blk, buf, 0, 2); + if (rc != 0) { + dev_err(blk->dev, "Cannot read MBR/partition table\n"); + goto on_error; + } + + parser = partition_parser_get_by_filetype(buf); + if (!parser) + goto on_error; + + parser->parse(buf, blk, pdesc); + + if (!pdesc->used_entries) + goto on_error; /* at least one partition description found */ - for (i = 0; i < pdesc.used_entries; i++) { - rc = register_one_partition(blk, &pdesc.parts[i], i); + for (i = 0; i < pdesc->used_entries; i++) { + rc = register_one_partition(blk, &pdesc->parts[i], i); if (rc != 0) dev_err(blk->dev, "Failed to register partition %d on %s (%d)\n", @@ -165,5 +154,15 @@ int parse_partition_table(struct block_device *blk) rc = 0; } +on_error: + dma_free(buf); + free(pdesc); return rc; } + +int partition_parser_register(struct partition_parser *p) +{ + list_add_tail(&p->list, &partition_parser_list); + + return 0; +} diff --git a/common/partitions/Kconfig b/common/partitions/Kconfig new file mode 100644 index 0000000000..077091cde2 --- /dev/null +++ b/common/partitions/Kconfig @@ -0,0 +1,32 @@ +config PARTITION_DISK + depends on PARTITION + bool "DISK partition support" + help + Add support for handling common partition tables on all kind of disk + like devices (harddisks, CF cards, SD cards and so on) + +config PARTITION_DISK_DOS + depends on PARTITION_DISK + default y + bool "DOS partition support" + help + Add support to handle partitions in DOS style. + +config PARTITION_DISK_EFI + depends on PARTITION_DISK + select CRC32 + bool "EFI: GPT partition support" + help + Add support to handle partitions in GUID Partition Table style. + +config PARTITION_DISK_EFI_GPT_NO_FORCE + depends on PARTITION_DISK_EFI + default y + bool "EFI: GPT: force test Protective MBR for validity" + help + This will be added to the EFI Spec. per Intel after v1.02 + +config PARTITION_DISK_EFI_GPT_COMPARE + depends on PARTITION_DISK_EFI + default y + bool "EFI: GPT: compare primary and Alternate GPT header for validity" diff --git a/common/partitions/Makefile b/common/partitions/Makefile new file mode 100644 index 0000000000..2b0c5b4b9c --- /dev/null +++ b/common/partitions/Makefile @@ -0,0 +1,2 @@ +obj-$(CONFIG_PARTITION_DISK_DOS) += dos.o +obj-$(CONFIG_PARTITION_DISK_EFI) += efi.o diff --git a/common/partitions/dos.c b/common/partitions/dos.c new file mode 100644 index 0000000000..597f9ba581 --- /dev/null +++ b/common/partitions/dos.c @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2009...2011 Juergen Beisert, Pengutronix + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include <common.h> +#include <disks.h> +#include <init.h> +#include <asm/unaligned.h> + +#include "parser.h" + +/** + * Guess the size of the disk, based on the partition table entries + * @param dev device to create partitions for + * @param table partition table + * @return sector count + */ +static int disk_guess_size(struct device_d *dev, struct partition_entry *table) +{ + uint64_t size = 0; + int i; + + for (i = 0; i < 4; i++) { + if (table[i].partition_start != 0) { + size += get_unaligned_le32(&table[i].partition_start) - size; + size += get_unaligned_le32(&table[i].partition_size); + } + } + + return (int)size; +} + +/** + * Check if a DOS like partition describes this block device + * @param blk Block device to register to + * @param pd Where to store the partition information + * + * It seems at least on ARM this routine canot use temp. stack space for the + * sector. So, keep the malloc/free. + */ +static void dos_partition(void *buf, struct block_device *blk, + struct partition_desc *pd) +{ + struct partition_entry *table; + struct partition pentry; + uint8_t *buffer = buf; + int i; + + table = (struct partition_entry *)&buffer[446]; + + /* valid for x86 BIOS based disks only */ + if (IS_ENABLED(CONFIG_DISK_BIOS) && blk->num_blocks == 0) + blk->num_blocks = disk_guess_size(blk->dev, table); + + for (i = 0; i < 4; i++) { + pentry.first_sec = get_unaligned_le32(&table[i].partition_start); + pentry.size = get_unaligned_le32(&table[i].partition_size); + + if (pentry.first_sec != 0) { + pd->parts[pd->used_entries].first_sec = pentry.first_sec; + pd->parts[pd->used_entries].size = pentry.size; + pd->used_entries++; + } else { + dev_dbg(blk->dev, "Skipping empty partition %d\n", i); + } + } +} + +static struct partition_parser dos = { + .parse = dos_partition, + .type = filetype_mbr, +}; + +static int dos_partition_init(void) +{ + return partition_parser_register(&dos); +} +postconsole_initcall(dos_partition_init); diff --git a/common/partitions/efi.c b/common/partitions/efi.c new file mode 100644 index 0000000000..e450eebf77 --- /dev/null +++ b/common/partitions/efi.c @@ -0,0 +1,477 @@ +/************************************************************ + * EFI GUID Partition Table handling + * + * http://www.uefi.org/specs/ + * http://www.intel.com/technology/efi/ + * + * efi.[ch] by Matt Domsch <Matt_Domsch@dell.com> + * Copyright 2000,2001,2002,2004 Dell Inc. + * + * Copyright (C) 2013 Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com> + * + * Under GPLv2 only + */ + +#include <common.h> +#include <disks.h> +#include <init.h> +#include <asm/unaligned.h> +#include <dma.h> +#include <linux/ctype.h> + +#include "efi.h" +#include "parser.h" + +static int force_gpt = IS_ENABLED(CONFIG_PARTITION_DISK_EFI_GPT_NO_FORCE); + +/** + * efi_crc32() - EFI version of crc32 function + * @buf: buffer to calculate crc32 of + * @len - length of buf + * + * Description: Returns EFI-style CRC32 value for @buf + * + * This function uses the little endian Ethernet polynomial + * but seeds the function with ~0, and xor's with ~0 at the end. + * Note, the EFI Specification, v1.02, has a reference to + * Dr. Dobbs Journal, May 1994 (actually it's in May 1992). + */ +static inline u32 +efi_crc32(const void *buf, unsigned long len) +{ + return crc32(0, buf, len); +} + +/** + * last_lba(): return number of last logical block of device + * @bdev: block device + * + * Description: Returns last LBA value on success, 0 on error. + * This is stored (by sd and ide-geometry) in + * the part[0] entry for this disk, and is the number of + * physical sectors available on the disk. + */ +static u64 last_lba(struct block_device *bdev) +{ + if (!bdev) + return 0; + return bdev->num_blocks; +} + +/** + * alloc_read_gpt_entries(): reads partition entries from disk + * @dev_desc + * @gpt - GPT header + * + * Description: Returns ptes on success, NULL on error. + * Allocates space for PTEs based on information found in @gpt. + * Notes: remember to free pte when you're done! + */ +static gpt_entry *alloc_read_gpt_entries(struct block_device *blk, + gpt_header * pgpt_head) +{ + size_t count = 0; + gpt_entry *pte = NULL; + unsigned long from, size; + int ret; + + count = le32_to_cpu(pgpt_head->num_partition_entries) * + le32_to_cpu(pgpt_head->sizeof_partition_entry); + + if (!count) + return NULL; + pte = kzalloc(count, GFP_KERNEL); + if (!pte) + return NULL; + + from = le64_to_cpu(pgpt_head->partition_entry_lba); + size = count / GPT_BLOCK_SIZE; + ret = blk->ops->read(blk, pte, from, size); + if (ret) { + kfree(pte); + pte=NULL; + return NULL; + } + return pte; +} + +static inline unsigned short bdev_logical_block_size(struct block_device +*bdev) +{ + return SECTOR_SIZE; +} + +/** + * alloc_read_gpt_header(): Allocates GPT header, reads into it from disk + * @state + * @lba is the Logical Block Address of the partition table + * + * Description: returns GPT header on success, NULL on error. Allocates + * and fills a GPT header starting at @ from @state->bdev. + * Note: remember to free gpt when finished with it. + */ +static gpt_header *alloc_read_gpt_header(struct block_device *blk, + u64 lba) +{ + gpt_header *gpt; + unsigned ssz = bdev_logical_block_size(blk); + int ret; + + gpt = kzalloc(ssz, GFP_KERNEL); + if (!gpt) + return NULL; + + ret = blk->ops->read(blk, gpt, lba, 1); + if (ret) { + kfree(gpt); + gpt=NULL; + return NULL; + } + + return gpt; +} + +/** + * is_gpt_valid() - tests one GPT header and PTEs for validity + * + * lba is the logical block address of the GPT header to test + * gpt is a GPT header ptr, filled on return. + * ptes is a PTEs ptr, filled on return. + * + * Description: returns 1 if valid, 0 on error. + * If valid, returns pointers to PTEs. + */ +static int is_gpt_valid(struct block_device *blk, u64 lba, + gpt_header **gpt, gpt_entry **ptes) +{ + u32 crc, origcrc; + u64 lastlba; + + if (!ptes) + return 0; + if (!(*gpt = alloc_read_gpt_header(blk, lba))) + return 0; + + /* Check the GPT header signature */ + if (le64_to_cpu((*gpt)->signature) != GPT_HEADER_SIGNATURE) { + dev_dbg(blk->dev, "GUID Partition Table Header signature is wrong:" + "0x%llX != 0x%llX\n", + (unsigned long long)le64_to_cpu((*gpt)->signature), + (unsigned long long)GPT_HEADER_SIGNATURE); + goto fail; + } + + /* Check the GUID Partition Table CRC */ + origcrc = le32_to_cpu((*gpt)->header_crc32); + (*gpt)->header_crc32 = 0; + crc = efi_crc32((const unsigned char *) (*gpt), le32_to_cpu((*gpt)->header_size)); + + if (crc != origcrc) { + dev_dbg(blk->dev, "GUID Partition Table Header CRC is wrong: %x != %x\n", + crc, origcrc); + goto fail; + } + (*gpt)->header_crc32 = cpu_to_le32(origcrc); + + /* Check that the my_lba entry points to the LBA that contains + * the GUID Partition Table */ + if (le64_to_cpu((*gpt)->my_lba) != lba) { + dev_dbg(blk->dev, "GPT: my_lba incorrect: %llX != %llX\n", + (unsigned long long)le64_to_cpu((*gpt)->my_lba), + (unsigned long long)lba); + goto fail; + } + + /* Check the first_usable_lba and last_usable_lba are within the disk. */ + lastlba = last_lba(blk); + if (le64_to_cpu((*gpt)->first_usable_lba) > lastlba) { + dev_dbg(blk->dev, "GPT: first_usable_lba incorrect: %lld > %lld\n", + (unsigned long long)le64_to_cpu((*gpt)->first_usable_lba), + (unsigned long long)lastlba); + goto fail; + } + if (le64_to_cpu((*gpt)->last_usable_lba) > lastlba) { + dev_dbg(blk->dev, "GPT: last_usable_lba incorrect: %lld > %lld\n", + (unsigned long long)le64_to_cpu((*gpt)->last_usable_lba), + (unsigned long long)lastlba); + goto fail; + } + + if (!(*ptes = alloc_read_gpt_entries(blk, *gpt))) + goto fail; + + /* Check the GUID Partition Table Entry Array CRC */ + crc = efi_crc32((const unsigned char *)*ptes, + le32_to_cpu((*gpt)->num_partition_entries) * + le32_to_cpu((*gpt)->sizeof_partition_entry)); + + if (crc != le32_to_cpu((*gpt)->partition_entry_array_crc32)) { + dev_dbg(blk->dev, "GUID Partitition Entry Array CRC check failed.\n"); + goto fail_ptes; + } + + /* We're done, all's well */ + return 1; + + fail_ptes: + kfree(*ptes); + *ptes = NULL; + fail: + kfree(*gpt); + *gpt = NULL; + return 0; +} + +/** + * is_pte_valid() - tests one PTE for validity + * @pte is the pte to check + * @lastlba is last lba of the disk + * + * Description: returns 1 if valid, 0 on error. + */ +static inline int +is_pte_valid(const gpt_entry *pte, const u64 lastlba) +{ + if ((!efi_guidcmp(pte->partition_type_guid, NULL_GUID)) || + le64_to_cpu(pte->starting_lba) > lastlba || + le64_to_cpu(pte->ending_lba) > lastlba) + return 0; + return 1; +} + +/** + * compare_gpts() - Search disk for valid GPT headers and PTEs + * @pgpt is the primary GPT header + * @agpt is the alternate GPT header + * @lastlba is the last LBA number + * Description: Returns nothing. Sanity checks pgpt and agpt fields + * and prints warnings on discrepancies. + * + */ +static void +compare_gpts(struct device_d *dev, gpt_header *pgpt, gpt_header *agpt, u64 lastlba) +{ + int error_found = 0; + if (!pgpt || !agpt) + return; + if (le64_to_cpu(pgpt->my_lba) != le64_to_cpu(agpt->alternate_lba)) { + dev_warn(dev, + "GPT:Primary header LBA != Alt. header alternate_lba\n"); + dev_warn(dev, "GPT:%lld != %lld\n", + (unsigned long long)le64_to_cpu(pgpt->my_lba), + (unsigned long long)le64_to_cpu(agpt->alternate_lba)); + error_found++; + } + if (le64_to_cpu(pgpt->alternate_lba) != le64_to_cpu(agpt->my_lba)) { + dev_warn(dev, + "GPT:Primary header alternate_lba != Alt. header my_lba\n"); + dev_warn(dev, "GPT:%lld != %lld\n", + (unsigned long long)le64_to_cpu(pgpt->alternate_lba), + (unsigned long long)le64_to_cpu(agpt->my_lba)); + error_found++; + } + if (le64_to_cpu(pgpt->first_usable_lba) != + le64_to_cpu(agpt->first_usable_lba)) { + dev_warn(dev, "GPT:first_usable_lbas don't match.\n"); + dev_warn(dev, "GPT:%lld != %lld\n", + (unsigned long long)le64_to_cpu(pgpt->first_usable_lba), + (unsigned long long)le64_to_cpu(agpt->first_usable_lba)); + error_found++; + } + if (le64_to_cpu(pgpt->last_usable_lba) != + le64_to_cpu(agpt->last_usable_lba)) { + dev_warn(dev, "GPT:last_usable_lbas don't match.\n"); + dev_warn(dev, "GPT:%lld != %lld\n", + (unsigned long long)le64_to_cpu(pgpt->last_usable_lba), + (unsigned long long)le64_to_cpu(agpt->last_usable_lba)); + error_found++; + } + if (efi_guidcmp(pgpt->disk_guid, agpt->disk_guid)) { + dev_warn(dev, "GPT:disk_guids don't match.\n"); + error_found++; + } + if (le32_to_cpu(pgpt->num_partition_entries) != + le32_to_cpu(agpt->num_partition_entries)) { + dev_warn(dev, "GPT:num_partition_entries don't match: " + "0x%x != 0x%x\n", + le32_to_cpu(pgpt->num_partition_entries), + le32_to_cpu(agpt->num_partition_entries)); + error_found++; + } + if (le32_to_cpu(pgpt->sizeof_partition_entry) != + le32_to_cpu(agpt->sizeof_partition_entry)) { + dev_warn(dev, + "GPT:sizeof_partition_entry values don't match: " + "0x%x != 0x%x\n", + le32_to_cpu(pgpt->sizeof_partition_entry), + le32_to_cpu(agpt->sizeof_partition_entry)); + error_found++; + } + if (le32_to_cpu(pgpt->partition_entry_array_crc32) != + le32_to_cpu(agpt->partition_entry_array_crc32)) { + dev_warn(dev, + "GPT:partition_entry_array_crc32 values don't match: " + "0x%x != 0x%x\n", + le32_to_cpu(pgpt->partition_entry_array_crc32), + le32_to_cpu(agpt->partition_entry_array_crc32)); + error_found++; + } + if (le64_to_cpu(pgpt->alternate_lba) != lastlba) { + dev_warn(dev, + "GPT:Primary header thinks Alt. header is not at the end of the disk.\n"); + dev_warn(dev, "GPT:%lld != %lld\n", + (unsigned long long)le64_to_cpu(pgpt->alternate_lba), + (unsigned long long)lastlba); + error_found++; + } + + if (le64_to_cpu(agpt->my_lba) != lastlba) { + dev_warn(dev, + "GPT:Alternate GPT header not at the end of the disk.\n"); + dev_warn(dev, "GPT:%lld != %lld\n", + (unsigned long long)le64_to_cpu(agpt->my_lba), + (unsigned long long)lastlba); + error_found++; + } + + if (error_found) + dev_warn(dev, "GPT: Use GNU Parted to correct GPT errors.\n"); + return; +} + +/** + * find_valid_gpt() - Search disk for valid GPT headers and PTEs + * @state + * @gpt is a GPT header ptr, filled on return. + * @ptes is a PTEs ptr, filled on return. + * Description: Returns 1 if valid, 0 on error. + * If valid, returns pointers to newly allocated GPT header and PTEs. + * Validity depends on PMBR being valid (or being overridden by the + * 'gpt' kernel command line option) and finding either the Primary + * GPT header and PTEs valid, or the Alternate GPT header and PTEs + * valid. If the Primary GPT header is not valid, the Alternate GPT header + * is not checked unless the 'gpt' kernel command line option is passed. + * This protects against devices which misreport their size, and forces + * the user to decide to use the Alternate GPT. + */ +static int find_valid_gpt(void *buf, struct block_device *blk, gpt_header **gpt, + gpt_entry **ptes) +{ + int good_pgpt = 0, good_agpt = 0; + gpt_header *pgpt = NULL, *agpt = NULL; + gpt_entry *pptes = NULL, *aptes = NULL; + u64 lastlba; + + if (!ptes) + return 0; + + lastlba = last_lba(blk); + if (force_gpt) { + /* This will be added to the EFI Spec. per Intel after v1.02. */ + if (file_detect_type(buf, SECTOR_SIZE * 2) != filetype_gpt) + goto fail; + } + + good_pgpt = is_gpt_valid(blk, GPT_PRIMARY_PARTITION_TABLE_LBA, + &pgpt, &pptes); + if (good_pgpt) + good_agpt = is_gpt_valid(blk, + le64_to_cpu(pgpt->alternate_lba), + &agpt, &aptes); + if (!good_agpt && force_gpt) + good_agpt = is_gpt_valid(blk, lastlba, &agpt, &aptes); + + /* The obviously unsuccessful case */ + if (!good_pgpt && !good_agpt) + goto fail; + + if (IS_ENABLED(CONFIG_PARTITION_DISK_EFI_GPT_COMPARE)) + compare_gpts(blk->dev, pgpt, agpt, lastlba); + + /* The good cases */ + if (good_pgpt) { + *gpt = pgpt; + *ptes = pptes; + kfree(agpt); + kfree(aptes); + if (!good_agpt) + dev_warn(blk->dev, "Alternate GPT is invalid, using primary GPT.\n"); + return 1; + } + else if (good_agpt) { + *gpt = agpt; + *ptes = aptes; + kfree(pgpt); + kfree(pptes); + dev_warn(blk->dev, "Primary GPT is invalid, using alternate GPT.\n"); + return 1; + } + + fail: + kfree(pgpt); + kfree(agpt); + kfree(pptes); + kfree(aptes); + *gpt = NULL; + *ptes = NULL; + return 0; +} + +static void part_set_efi_name(gpt_entry *pte, char *dest) +{ + int i; + + for (i = 0; i < GPT_PARTNAME_MAX_SIZE ; i++) { + u8 c; + c = pte->partition_name[i] & 0xff; + c = (c && !isprint(c)) ? '.' : c; + dest[i] = c; + } + dest[i] = 0; +} + +static void efi_partition(void *buf, struct block_device *blk, + struct partition_desc *pd) +{ + gpt_header *gpt = NULL; + gpt_entry *ptes = NULL; + int i = 0; + int nb_part; + struct partition *pentry; + + if (!find_valid_gpt(buf, blk, &gpt, &ptes) || !gpt || !ptes) { + kfree(gpt); + kfree(ptes); + return; + } + + nb_part = le32_to_cpu(gpt->num_partition_entries); + for (i = 0; i < MAX_PARTITION && i < nb_part; i++) { + if (!is_pte_valid(&ptes[i], last_lba(blk))) { + dev_dbg(blk->dev, "Invalid pte %d\n", i); + return; + } + + pentry = &pd->parts[pd->used_entries]; + pentry->first_sec = le64_to_cpu(ptes[i].starting_lba); + pentry->size = le64_to_cpu(ptes[i].ending_lba) - pentry->first_sec; + pentry->size++; + part_set_efi_name(&ptes[i], pentry->name); + pd->used_entries++; + } + + if (i > MAX_PARTITION) + dev_warn(blk->dev, "num_partition_entries (%d) > max partition number (%d)\n", + nb_part, MAX_PARTITION); +} + +static struct partition_parser efi_partition_parser = { + .parse = efi_partition, + .type = filetype_gpt, +}; + +static int efi_partition_init(void) +{ + return partition_parser_register(&efi_partition_parser); +} +postconsole_initcall(efi_partition_init); diff --git a/common/partitions/efi.h b/common/partitions/efi.h new file mode 100644 index 0000000000..c7734bd403 --- /dev/null +++ b/common/partitions/efi.h @@ -0,0 +1,123 @@ +/************************************************************ + * EFI GUID Partition Table + * Per Intel EFI Specification v1.02 + * http://developer.intel.com/technology/efi/efi.htm + * + * By Matt Domsch <Matt_Domsch@dell.com> Fri Sep 22 22:15:56 CDT 2000 + * Copyright 2000,2001 Dell Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + ************************************************************/ + +#ifndef FS_PART_EFI_H_INCLUDED +#define FS_PART_EFI_H_INCLUDED + +#include <linux/efi.h> + +#define MSDOS_MBR_SIGNATURE 0xaa55 +#define EFI_PMBR_OSTYPE_EFI 0xEF +#define EFI_PMBR_OSTYPE_EFI_GPT 0xEE + +#define GPT_BLOCK_SIZE 512 +#define GPT_HEADER_SIGNATURE 0x5452415020494645ULL +#define GPT_HEADER_REVISION_V1 0x00010000 +#define GPT_PRIMARY_PARTITION_TABLE_LBA 1 + +#define PARTITION_SYSTEM_GUID \ + EFI_GUID( 0xC12A7328, 0xF81F, 0x11d2, \ + 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B) +#define LEGACY_MBR_PARTITION_GUID \ + EFI_GUID( 0x024DEE41, 0x33E7, 0x11d3, \ + 0x9D, 0x69, 0x00, 0x08, 0xC7, 0x81, 0xF3, 0x9F) +#define PARTITION_MSFT_RESERVED_GUID \ + EFI_GUID( 0xE3C9E316, 0x0B5C, 0x4DB8, \ + 0x81, 0x7D, 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE) +#define PARTITION_BASIC_DATA_GUID \ + EFI_GUID( 0xEBD0A0A2, 0xB9E5, 0x4433, \ + 0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7) +#define PARTITION_LINUX_RAID_GUID \ + EFI_GUID( 0xa19d880f, 0x05fc, 0x4d3b, \ + 0xa0, 0x06, 0x74, 0x3f, 0x0f, 0x84, 0x91, 0x1e) +#define PARTITION_LINUX_SWAP_GUID \ + EFI_GUID( 0x0657fd6d, 0xa4ab, 0x43c4, \ + 0x84, 0xe5, 0x09, 0x33, 0xc8, 0x4b, 0x4f, 0x4f) +#define PARTITION_LINUX_LVM_GUID \ + EFI_GUID( 0xe6d6d379, 0xf507, 0x44c2, \ + 0xa2, 0x3c, 0x23, 0x8f, 0x2a, 0x3d, 0xf9, 0x28) + +/* based on linux/include/genhd.h */ +struct legacy_partition { + unsigned char boot_ind; /* 0x80 - active */ + unsigned char head; /* starting head */ + unsigned char sector; /* starting sector */ + unsigned char cyl; /* starting cylinder */ + unsigned char sys_ind; /* What partition type */ + unsigned char end_head; /* end head */ + unsigned char end_sector; /* end sector */ + unsigned char end_cyl; /* end cylinder */ + __le32 start_sect; /* starting sector counting from 0 */ + __le32 nr_sects; /* nr of sectors in partition */ +} __attribute__ ((packed)); + +/* based on linux/fs/partitions/efi.h */ +typedef struct _gpt_header { + __le64 signature; + __le32 revision; + __le32 header_size; + __le32 header_crc32; + __le32 reserved1; + __le64 my_lba; + __le64 alternate_lba; + __le64 first_usable_lba; + __le64 last_usable_lba; + efi_guid_t disk_guid; + __le64 partition_entry_lba; + __le32 num_partition_entries; + __le32 sizeof_partition_entry; + __le32 partition_entry_array_crc32; + + /* The rest of the logical block is reserved by UEFI and must be zero. + * EFI standard handles this by: + * + * uint8_t reserved2[ BlockSize - 92 ]; + */ +} __attribute__ ((packed)) gpt_header; + +typedef struct _gpt_entry_attributes { + u64 required_to_function:1; + u64 reserved:47; + u64 type_guid_specific:16; +} __attribute__ ((packed)) gpt_entry_attributes; + +#define GPT_PARTNAME_MAX_SIZE (72 / sizeof (efi_char16_t)) +typedef struct _gpt_entry { + efi_guid_t partition_type_guid; + efi_guid_t unique_partition_guid; + __le64 starting_lba; + __le64 ending_lba; + gpt_entry_attributes attributes; + efi_char16_t partition_name[GPT_PARTNAME_MAX_SIZE]; +} __attribute__ ((packed)) gpt_entry; + +typedef struct _legacy_mbr { + u8 boot_code[440]; + __le32 unique_mbr_signature; + __le16 unknown; + struct legacy_partition partition_record[4]; + __le16 signature; +} __attribute__ ((packed)) legacy_mbr; + +#endif /* _DISK_PART_EFI_H */ diff --git a/common/partitions/parser.h b/common/partitions/parser.h new file mode 100644 index 0000000000..f5bdbd1442 --- /dev/null +++ b/common/partitions/parser.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2013 Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com> + * + * Under GPLv2 only + */ + +#ifndef __PARTITIONS_PARSER_H__ +#define __PARTITIONS_PARSER_H__ + +#include <block.h> +#include <filetype.h> +#include <linux/list.h> + +#define MAX_PARTITION 8 +#define MAX_PARTITION_NAME 38 + +struct partition { + char name[MAX_PARTITION_NAME]; + uint64_t first_sec; + uint64_t size; +}; + +struct partition_desc { + int used_entries; + struct partition parts[MAX_PARTITION]; +}; + +struct partition_parser { + void (*parse)(void *buf, struct block_device *blk, struct partition_desc *pd); + enum filetype type; + + struct list_head list; +}; + +int partition_parser_register(struct partition_parser *p); + +#endif /* __PARTITIONS_PARSER_H__ */ |