coreboot-gerrit May 2015

coreboot-gerrit@coreboot.org

1 participants
1299 discussions

Patch set updated for coreboot: 1b75c50 cbfstool: Add version code, flags, variable-width hash to file headers
by Patrick Georgi 08 May '15

08 May '15

Patrick Georgi (pgeorgi(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/10147 -gerrit commit 1b75c501b89e09ce9b6a737e2d8c5565cbd0d5f2 Author: Sol Boucher <solb(a)chromium.org> Date: Thu May 7 21:00:05 2015 -0700 cbfstool: Add version code, flags, variable-width hash to file headers This new format is intended to fully replace the CBFS master header, and is only used when working with new-format images without one. The cbfstool utility remains backwards-compatible with legacy images that still use a master header, and will continue to generate old-format headers when operating on such files. However, because it always generates updated headers when working with new-format images, the very first version of cbfstool to support the new layout will be unable to read/write images created/edited by this and future versions. For the first time, cbfstool actually supports hashing files as they are added; invoking an add action with the -A switch set to sha1, sha256, or sha512 will generate a hash and store it in the entry header's new hash field. Subsequent print actions will detect the hashes and verify them using the same algorithm. BUG=chromium:482652 TEST=Build panther and nyan_big coreboot.rom and image.bin images with and without this patch, diff their hexdumps, and note that no locations differ except for those that do between subsequent builds of the same codebase. Try adding hashed files, ensuring that the stored hashes match those produced by the sha1sum, sha256sum, and sha512 commands, and that the print action correctly detects hashes that match and don't (due to intentional tampering). BRANCH=None Change-Id: Ibef7989b9b5830666925e5f8b5cad14cec2e3551 Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Change-Id: I1a117a9473e895feaf455bb30d0f945f57de51eb Original-Signed-off-by: Sol Boucher <solb(a)chromium.org> --- 3rdparty/vboot | 2 +- src/cpu/ti/am335x/Makefile.inc | 2 +- util/cbfstool/Makefile | 11 ++ util/cbfstool/Makefile.inc | 15 +++ util/cbfstool/cbfs.h | 35 ++++-- util/cbfstool/cbfs_image.c | 276 ++++++++++++++++++++++++++++++++++------- util/cbfstool/cbfs_image.h | 25 +++- util/cbfstool/cbfstool.c | 138 +++++++++++---------- util/cbfstool/common.c | 20 ++- util/cbfstool/common.h | 11 +- util/cbfstool/swab.h | 12 ++ 11 files changed, 413 insertions(+), 134 deletions(-) diff --git a/3rdparty/vboot b/3rdparty/vboot index 7dd3bd0..f81fce9 160000 --- a/3rdparty/vboot +++ b/3rdparty/vboot @@ -1 +1 @@ -Subproject commit 7dd3bd0fcf565901aacc512cd29cefe19291c2e7 +Subproject commit f81fce91bf885293f1447c1197bb0c4143d8fced diff --git a/src/cpu/ti/am335x/Makefile.inc b/src/cpu/ti/am335x/Makefile.inc index 8e8dab1..e9fd4b7 100644 --- a/src/cpu/ti/am335x/Makefile.inc +++ b/src/cpu/ti/am335x/Makefile.inc @@ -27,7 +27,7 @@ header_ld = $(obj)/cpu/ti/am335x/header.omap-header.ld get_header_size= \ $(eval omap_header_info=$(shell $(CBFSTOOL) $(1) print | grep $(2))) \ $(shell echo $$(($(word 2,$(omap_header_info)) + \ - $(word 4,$(omap_header_info))))) + $(word 6,$(omap_header_info))))) $(obj)/omap-header.bin: $$(omap-header-objs) $(obj)/coreboot.rom @printf " CC $(subst $(obj)/,,$(@))\n" diff --git a/util/cbfstool/Makefile b/util/cbfstool/Makefile index 4238445..8094af8 100644 --- a/util/cbfstool/Makefile +++ b/util/cbfstool/Makefile @@ -8,7 +8,10 @@ CFLAGS += -Wcast-qual -Wmissing-prototypes -Wredundant-decls -Wshadow CFLAGS += -Wstrict-prototypes -Wwrite-strings CPPFLAGS += -D_DEFAULT_SOURCE # memccpy() from string.h CPPFLAGS += -D_POSIX_C_SOURCE=200809L # strdup() from string.h +CPPFLAGS += -DNEED_VB2_SHA_LIBRARY CPPFLAGS += -Iflashmap +CPPFLAGS += -I../../3rdparty/vboot/firmware/include +CPPFLAGS += -I../../3rdparty/vboot/firmware/2lib/include LDFLAGS += -g3 CBFSTOOL_BINARY:=$(obj)/cbfstool @@ -23,6 +26,11 @@ CBFSTOOL_COMMON+=flashmap/fmap.o CBFSTOOL_COMMON+=flashmap/kv_pair.o flashmap/valstr.o CBFSTOOL_COMMON:=$(addprefix $(obj)/,$(CBFSTOOL_COMMON)) +# CRYPTOLIB +CBFSTOOL_COMMON+=../../3rdparty/vboot/firmware/2lib/2sha_utility.o +CBFSTOOL_COMMON+=../../3rdparty/vboot/firmware/2lib/2sha1.o +CBFSTOOL_COMMON+=../../3rdparty/vboot/firmware/2lib/2sha256.o +CBFSTOOL_COMMON+=../../3rdparty/vboot/firmware/2lib/2sha512.o FMAPTOOL_BINARY:=$(obj)/fmaptool FMAPTOOL_COMMON:=cbfs_sections.o fmap_from_fmd.o @@ -97,5 +105,8 @@ $(obj)/fmd_parser.o: CFLAGS += -Wno-redundant-decls $(obj)/fmd_scanner.o: CFLAGS += -Wno-unused-function # Tolerate lzma sdk warnings $(obj)/lzma/C/LzmaEnc.o: CFLAGS += -Wno-sign-compare -Wno-cast-qual +# Tolerate vboot warnings +../../3rdparty/vboot/firmware/2lib/2sha_utility.o: CFLAGS += -Wno-sign-compare +../../3rdparty/vboot/firmware/2lib/2sha1.o: CFLAGS += -Wno-cast-qual -include .dependencies diff --git a/util/cbfstool/Makefile.inc b/util/cbfstool/Makefile.inc index 1aa9d76..41991d8 100644 --- a/util/cbfstool/Makefile.inc +++ b/util/cbfstool/Makefile.inc @@ -14,6 +14,11 @@ cbfsobj += lzma.o cbfsobj += LzFind.o cbfsobj += LzmaDec.o cbfsobj += LzmaEnc.o +# CRYPTOLIB +cbfsobj += 2sha_utility.o +cbfsobj += 2sha1.o +cbfsobj += 2sha256.o +cbfsobj += 2sha512.o # FMAP cbfsobj += fmap.o cbfsobj += kv_pair.o @@ -46,7 +51,10 @@ TOOLCFLAGS += -Wcast-qual -Wmissing-prototypes -Wredundant-decls -Wshadow TOOLCFLAGS += -Wstrict-prototypes -Wwrite-strings TOOLCPPFLAGS ?= -D_DEFAULT_SOURCE # memccpy() from string.h TOOLCPPFLAGS += -D_POSIX_C_SOURCE=200809L # strdup() from string.h +TOOLCPPFLAGS += -DNEED_VB2_SHA_LIBRARY TOOLCPPFLAGS += -I$(top)/util/cbfstool/flashmap +TOOLCPPFLAGS += -I$(top)/3rdparty/vboot/firmware/include +TOOLCPPFLAGS += -I$(top)/3rdparty/vboot/firmware/2lib/include TOOLLDFLAGS ?= ifeq ($(shell uname -s | cut -c-7 2>/dev/null), MINGW32) @@ -69,6 +77,10 @@ $(objutil)/cbfstool/%.o: $(top)/util/cbfstool/lzma/C/%.c printf " HOSTCC $(subst $(objutil)/,,$(@))\n" $(HOSTCC) $(TOOLCPPFLAGS) $(TOOLCFLAGS) $(HOSTCFLAGS) -c -o $@ $< +$(objutil)/cbfstool/%.o: $(top)/3rdparty/vboot/firmware/2lib/%.c + printf " HOSTCC $(subst $(objutil)/,,$(@))\n" + $(HOSTCC) $(TOOLCPPFLAGS) $(TOOLCFLAGS) $(HOSTCFLAGS) -c -o $@ $< + $(objutil)/cbfstool/cbfstool: $(addprefix $(objutil)/cbfstool/,$(cbfsobj)) printf " HOSTCC $(subst $(objutil)/,,$(@)) (link)\n" $(HOSTCC) $(TOOLLDFLAGS) -o $@ $(addprefix $(objutil)/cbfstool/,$(cbfsobj)) @@ -87,6 +99,9 @@ $(objutil)/cbfstool/fmd_parser.o: TOOLCFLAGS += -Wno-redundant-decls $(objutil)/cbfstool/fmd_scanner.o: TOOLCFLAGS += -Wno-unused-function # Tolerate lzma sdk warnings $(objutil)/cbfstool/LzmaEnc.o: TOOLCFLAGS += -Wno-sign-compare -Wno-cast-qual +# Tolerate vboot warnings +$(objutil)/cbfstool/2sha_utility.o: TOOLCFLAGS += -Wno-sign-compare +$(objutil)/cbfstool/2sha1.o: TOOLCFLAGS += -Wno-cast-qual ifeq ($(CONFIG_FMD_GENPARSER),y) TOOLLEX := lex diff --git a/util/cbfstool/cbfs.h b/util/cbfstool/cbfs.h index ef39594..95c36c4 100644 --- a/util/cbfstool/cbfs.h +++ b/util/cbfstool/cbfs.h @@ -21,6 +21,9 @@ #include <stdint.h> +/* Endianess */ +#include "swab.h" + /* create a magic number in host-byte order. * b3 is the high order byte. * in the coreboot tools, we go with the 32-bit @@ -60,14 +63,22 @@ struct cbfs_header { #define CBFS_ARCHITECTURE_RISCV 0xc001d0de #define CBFS_FILE_MAGIC "LARCHIVE" +#define CBFS_FILE_VERSION 1 +#define CBFS_FILE_V0_LEN (6 * sizeof(uint32_t)) struct cbfs_file { uint8_t magic[8]; - uint32_t len; + uint32_t len; /* Of the file described by this header */ uint32_t type; - uint32_t checksum; - uint32_t offset; + uint16_t version; + uint16_t flags; /* V1 */ + uint32_t offset; /* To the file described by this header */ + uint32_t header_len; /* V1: Of header, up to the *beginning* of name */ + uint16_t hash_type; /* V1: Also determines size of the hash */ + uint16_t hash_offset; /* V1: From the beginning of header */ } __attribute__ ((packed)); +/* Should be immediately followed by the hash (and any future variable-width + fields), then the (NUL-terminated) variable-length name. */ struct cbfs_stage { uint32_t compression; @@ -128,15 +139,23 @@ struct cbfs_payload { */ #define CBFS_COMPONENT_NULL 0xFFFFFFFF -#define CBFS_NAME(_c) (((char *) (_c)) + sizeof(struct cbfs_file)) -#define CBFS_SUBHEADER(_p) ( (void *) ((((uint8_t *) (_p)) + ntohl((_p)->offset))) ) -/* cbfs_image.c */ -uint32_t get_cbfs_entry_type(const char *name, uint32_t default_value); -uint32_t get_cbfs_compression(const char *name, uint32_t unknown); +#define CBFS_HEADER_LEN(_c) (ntohs((_c)->version) >= 1 ? \ + ntohl((_c)->header_len) : CBFS_FILE_V0_LEN) +#define CBFS_NAME(_c) (ntohs((_c)->version) >= 1 ? \ + ((char *) (_c)) + ntohl((_c)->header_len) : \ + ((char *) (_c)) + CBFS_FILE_V0_LEN) +#define CBFS_SUBHEADER(_p) ((void *) (((uint8_t *) (_p)) + ntohl((_p)->offset))) +#define CBFS_HASH(_c) ((_c)->version >= 1 && (_c)->hash_type && \ + (_c)->hash_offset ? \ + (((uint8_t *) (_c)) + ntohs((_c)->hash_offset)) : NULL) /* common.c */ void cbfs_file_get_header(struct buffer *buf, struct cbfs_file *file); +/* cbfs_image.c */ +uint32_t get_cbfs_entry_type(const char *name, uint32_t default_value); +uint32_t get_cbfs_compression(const char *name, uint32_t unknown); + /* cbfs-mkpayload.c */ void xdr_segs(struct buffer *output, struct cbfs_payload_segment *segs, int nseg); diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index 8fb2a60..29c3593 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -77,15 +77,32 @@ static const struct typedesc_t types_cbfs_entry[] = { {CBFS_COMPONENT_MRC_CACHE, "mrc_cache"}, {CBFS_COMPONENT_DELETED, "deleted"}, {CBFS_COMPONENT_NULL, "null"}, - {0, NULL}, + {0, NULL} }; static const struct typedesc_t types_cbfs_compression[] = { {CBFS_COMPRESS_NONE, "none"}, {CBFS_COMPRESS_LZMA, "LZMA"}, - {0, NULL}, + {0, NULL} }; +static const struct typedesc_t types_cbfs_hash[] = { + {VB2_HASH_INVALID, "none"}, + {VB2_HASH_SHA1, "sha1"}, + {VB2_HASH_SHA256, "sha256"}, + {VB2_HASH_SHA512, "sha512"}, + {0, NULL} +}; + +static size_t widths_cbfs_hash[] = { + [VB2_HASH_INVALID] = 0, + [VB2_HASH_SHA1] = 20, + [VB2_HASH_SHA256] = 32, + [VB2_HASH_SHA512] = 64, +}; +#define CBFS_NUM_SUPPORTED_HASHES (sizeof(widths_cbfs_hash) / \ + sizeof(*(widths_cbfs_hash))) + static const char *lookup_name_by_type(const struct typedesc_t *desc, uint32_t type, const char *default_value) { @@ -96,17 +113,46 @@ static const char *lookup_name_by_type(const struct typedesc_t *desc, uint32_t t return default_value; } +static int lookup_type_by_name(const struct typedesc_t *desc, const char *name) +{ + int i; + for (i = 0; desc[i].name && strcasecmp(name, desc[i].name); ++i); + return desc[i].name ? (int)desc[i].type : -1; +} + static const char *get_cbfs_entry_type_name(uint32_t type) { return lookup_name_by_type(types_cbfs_entry, type, "(unknown)"); } +int cbfs_parse_comp_algo(const char *name) +{ + return lookup_type_by_name(types_cbfs_compression, name); +} + +int cbfs_parse_hash_algo(const char *name) +{ + return lookup_type_by_name(types_cbfs_hash, name); +} + /* CBFS image */ -static size_t cbfs_calculate_file_header_size(const char *name) +static size_t cbfs_calculate_file_header_size_without_name( + enum vb2_hash_algorithm hash, bool legacy) { - return (sizeof(struct cbfs_file) + - align_up(strlen(name) + 1, CBFS_FILENAME_ALIGN)); + if (legacy) + return CBFS_FILE_V0_LEN; + else + return sizeof(struct cbfs_file) + widths_cbfs_hash[hash]; +} + +static size_t cbfs_calculate_file_header_size(const char *name, + enum vb2_hash_algorithm hash, + bool legacy) +{ + return align_up( + cbfs_calculate_file_header_size_without_name(hash, legacy) + + strlen(name) + 1, CBFS_FILENAME_ALIGN); } /* Only call on legacy CBFSes possessing a master header. */ @@ -190,7 +236,8 @@ int cbfs_image_create(struct cbfs_image *image, size_t entries_size) assert(image); assert(image->buffer.data); - size_t empty_header_len = cbfs_calculate_file_header_size(""); + size_t empty_header_len = cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image)); uint32_t entries_offset = 0; uint32_t align = CBFS_ENTRY_ALIGNMENT; if (image->has_header) { @@ -231,7 +278,8 @@ int cbfs_image_create(struct cbfs_image *image, size_t entries_size) size_t capacity = entries_size - empty_header_len; LOG("Created CBFS (capacity = %zu bytes)\n", capacity); - return cbfs_create_empty_entry(entry_header, capacity, ""); + return cbfs_create_empty_entry(entry_header, capacity, "", 0, + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image)); } int cbfs_legacy_image_create(struct cbfs_image *image, @@ -422,12 +470,13 @@ int cbfs_copy_instance(struct cbfs_image *image, size_t copy_offset, /* Last entry size is all the room above it. */ last_entry_size = copy_end - ((char *)dst_entry - image->buffer.data) - - cbfs_calculate_file_header_size(""); + - cbfs_calculate_file_header_size("", VB2_HASH_INVALID, true); if (last_entry_size < 0) WARN("No room to create the last entry!\n") else - cbfs_create_empty_entry(dst_entry, last_entry_size, ""); + cbfs_create_empty_entry(dst_entry, last_entry_size, "", 0, + VB2_HASH_INVALID, true); return 0; } @@ -441,20 +490,84 @@ int cbfs_image_delete(struct cbfs_image *image) return 0; } +/* Might be out of range. VB2_HASH_INVALID if file isn't protected by a hash. */ +static uint16_t cbfs_read_hash_type(struct cbfs_file *entry) +{ + return ntohs(entry->version) >= 1 ? + ntohs(entry->hash_type) : VB2_HASH_INVALID; +} + +/* Retrieve hash field and its type. Returns < 0 for unknown/truncated hash. */ +static int cbfs_read_file_hash(uint8_t **hash, struct cbfs_file *entry) +{ + uint16_t type = cbfs_read_hash_type(entry); + if (type >= CBFS_NUM_SUPPORTED_HASHES) { + WARN("This version of cbfstool is too old to process hashes of the type used for this file\n"); + return -1; + } + + size_t width = widths_cbfs_hash[type]; + uint8_t *stored = CBFS_HASH(entry); + if (stored && ((uintptr_t)stored) - ((uintptr_t)entry) + + ((uintptr_t)width) > CBFS_HEADER_LEN(entry)) { + ERROR("This file header's hash field is truncated\n"); + return -1; + } + if (hash) + *hash = stored; + return type; +} + +/* 0 on success */ +static int cbfs_populate_file_hash(struct cbfs_file *entry) +{ + uint8_t *hash = NULL; + int type = cbfs_read_file_hash(&hash, entry); + if (type > 0) { + return vb2_digest_buffer(CBFS_SUBHEADER(entry), + ntohl(entry->len), type, hash, + widths_cbfs_hash[type]) != VB2_SUCCESS; + } + return type; +} + +/* 0 on match, 1 on mismatch, < 0 on error */ +static int cbfs_check_hash(struct cbfs_file *entry) +{ + uint8_t *stored = NULL; + int type = cbfs_read_file_hash(&stored, entry); + if (type < 0) + return type; + + size_t width = widths_cbfs_hash[type]; + if (!width) + return 0; + + uint8_t computed[width]; + if (vb2_digest_buffer(CBFS_SUBHEADER(entry), ntohl(entry->len), type, + computed, width) != VB2_SUCCESS) + return -1; + return memcmp(computed, stored, width) == 0 ? 0 : 1; +} + /* Tries to add an entry with its data (CBFS_SUBHEADER) at given offset. */ static int cbfs_add_entry_at(struct cbfs_image *image, struct cbfs_file *entry, uint32_t size, const char *name, uint32_t type, + uint16_t flags, + enum vb2_hash_algorithm hash, const void *data, uint32_t content_offset) { struct cbfs_file *next = cbfs_find_next_entry(image, entry); uint32_t addr = cbfs_get_entry_addr(image, entry), addr_next = cbfs_get_entry_addr(image, next); - uint32_t header_size = cbfs_calculate_file_header_size(name), - min_entry_size = cbfs_calculate_file_header_size(""); + uint32_t header_size = cbfs_calculate_file_header_size(name, hash, + cbfs_is_legacy_cbfs(image)), + min_entry_size = cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image)); uint32_t len, target; uint32_t align = image->has_header ? image->header.align : CBFS_ENTRY_ALIGNMENT; @@ -471,14 +584,16 @@ static int cbfs_add_entry_at(struct cbfs_image *image, if (target - addr > min_entry_size) { DEBUG("|min|...|header|content|... <create new entry>\n"); len = target - addr - min_entry_size; - cbfs_create_empty_entry(entry, len, ""); + cbfs_create_empty_entry(entry, len, "", 0, VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); if (verbose > 1) cbfs_print_entry_info(image, entry, stderr); entry = cbfs_find_next_entry(image, entry); addr = cbfs_get_entry_addr(image, entry); } len = size + (content_offset - addr - header_size); - cbfs_create_empty_entry(entry, len, name); + cbfs_create_empty_entry(entry, len, name, flags, hash, + cbfs_is_legacy_cbfs(image)); if (len != size) { DEBUG("|..|header|content|... <use offset to create entry>\n"); DEBUG("before: offset=0x%x, len=0x%x\n", @@ -499,6 +614,7 @@ static int cbfs_add_entry_at(struct cbfs_image *image, assert((char*)CBFS_SUBHEADER(entry) - image->buffer.data == (ptrdiff_t)content_offset); memcpy(CBFS_SUBHEADER(entry), data, size); + cbfs_populate_file_hash(entry); if (verbose > 1) cbfs_print_entry_info(image, entry, stderr); // Process buffer AFTER entry. @@ -518,13 +634,15 @@ static int cbfs_add_entry_at(struct cbfs_image *image, } len = addr_next - addr - min_entry_size; - cbfs_create_empty_entry(entry, len, ""); + cbfs_create_empty_entry(entry, len, "", 0, VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); if (verbose > 1) cbfs_print_entry_info(image, entry, stderr); return 0; } int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, - const char *name, uint32_t type, uint32_t content_offset) + const char *name, uint32_t type, uint16_t flags, + enum vb2_hash_algorithm hash, uint32_t content_offset) { assert(image); assert(buffer); @@ -537,7 +655,8 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, struct cbfs_file *entry, *next; uint32_t header_size, need_size, new_size; - header_size = cbfs_calculate_file_header_size(name); + header_size = cbfs_calculate_file_header_size(name, hash, + cbfs_is_legacy_cbfs(image)); need_size = header_size + buffer->size; DEBUG("cbfs_add_entry('%s'@0x%x) => need_size = %u+%zu=%u\n", @@ -572,9 +691,12 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, if (!content_offset || content_offset == addr + header_size) { DEBUG("Filling new entry data (%zd bytes).\n", buffer->size); - cbfs_create_empty_entry(entry, buffer->size, name); + cbfs_create_empty_entry(entry, buffer->size, name, + flags, hash, + cbfs_is_legacy_cbfs(image)); entry->type = htonl(type); memcpy(CBFS_SUBHEADER(entry), buffer->data, buffer->size); + cbfs_populate_file_hash(entry); if (verbose) cbfs_print_entry_info(image, entry, stderr); @@ -585,7 +707,9 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, cbfs_get_entry_addr(image, entry)); /* Entry was added and no space for new "empty" entry */ - if (new_size < cbfs_calculate_file_header_size("")) { + if (new_size < cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image))) { DEBUG("No need for new \"empty\" entry\n"); /* No need to increase the size of the just * stored file to extend to next file. Alignment @@ -593,9 +717,13 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, */ return 0; } - new_size -= cbfs_calculate_file_header_size(""); + new_size -= cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); DEBUG("new size: %d\n", new_size); - cbfs_create_empty_entry(entry, new_size, ""); + cbfs_create_empty_entry(entry, new_size, "", 0, + VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); if (verbose) cbfs_print_entry_info(image, entry, stderr); return 0; @@ -624,7 +752,7 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, addr, addr_next - addr, content_offset); if (cbfs_add_entry_at(image, entry, buffer->size, name, type, - buffer->data, content_offset) == 0) { + flags, hash, buffer->data, content_offset) == 0) { return 0; } break; @@ -662,6 +790,19 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, entry_name, cbfs_get_entry_addr(image, entry), get_cbfs_entry_type_name(ntohl(entry->type)), ntohl(entry->len)); + if (cbfs_read_hash_type(entry) != VB2_HASH_INVALID) { + switch (cbfs_check_hash(entry)) { + case 0: // match + LOG("File hash successfully verified\n"); + break; + case 1: // mismatch + WARN("File hash mismatch (corrupt file?)\n"); + break; + default: // error + WARN("Unable to verify file consistency; attempting to extract anyway\n"); + } + } + if (ntohl(entry->type) != CBFS_COMPONENT_RAW) { WARN("Only 'raw' files are safe to extract.\n"); } @@ -682,25 +823,26 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, int cbfs_remove_entry(struct cbfs_image *image, const char *name) { - struct cbfs_file *entry, *next; - size_t len; - entry = cbfs_get_entry(image, name); + struct cbfs_file *entry = cbfs_get_entry(image, name); if (!entry) { ERROR("CBFS file %s not found.\n", name); return -1; } - next = cbfs_find_next_entry(image, entry); + struct cbfs_file *next = cbfs_find_next_entry(image, entry); assert(next); + ptrdiff_t len = (uintptr_t)next - (uintptr_t)entry - + cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image)); + if (len < 0) { + // Not enough space to fit current generation empty header. + ERROR("Only the older version of cbfstool that created this image can remove that file\n"); + return -1; + } + cbfs_create_empty_entry(entry, len, "", 0, VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); + entry->type = htonl(CBFS_COMPONENT_DELETED); DEBUG("cbfs_remove_entry: Removed %s @ 0x%x\n", CBFS_NAME(entry), cbfs_get_entry_addr(image, entry)); - entry->type = htonl(CBFS_COMPONENT_DELETED); - len = (cbfs_get_entry_addr(image, next) - - cbfs_get_entry_addr(image, entry)); - entry->offset = htonl(cbfs_calculate_file_header_size("")); - entry->len = htonl(len - ntohl(entry->offset)); - memset(CBFS_NAME(entry), 0, ntohl(entry->offset) - sizeof(*entry)); - memset(CBFS_SUBHEADER(entry), CBFS_CONTENT_DEFAULT_VALUE, - ntohl(entry->len)); return 0; } @@ -799,10 +941,30 @@ int cbfs_print_entry_info(struct cbfs_image *image, struct cbfs_file *entry, if (!fp) fp = stdout; - fprintf(fp, "%-30s 0x%-8x %-12s %d\n", + char hash_status[20]; + uint16_t type = cbfs_read_hash_type(entry); + const char *typename = + lookup_name_by_type(types_cbfs_hash, type, "unrecognized"); + const char *status = "N/A"; + if (type != VB2_HASH_INVALID) { + switch (cbfs_check_hash(entry)) { + case 0: // match + status = "verified"; + break; + case 1: // mismatch + status = "MISMATCH"; + break; + default: // error + status = "?!"; + } + } + sprintf(hash_status, "%s (%s)", status, typename); + + fprintf(fp, "%-30s 0x%-8x %-12s %-20s %d\n", *name ? name : "(empty)", cbfs_get_entry_addr(image, entry), get_cbfs_entry_type_name(ntohl(entry->type)), + hash_status, ntohl(entry->len)); if (!verbose) @@ -844,7 +1006,8 @@ int cbfs_print_directory(struct cbfs_image *image) { if (cbfs_is_legacy_cbfs(image)) cbfs_print_header_info(image); - printf("%-30s %-10s %-12s Size\n", "Name", "Offset", "Type"); + printf("%-30s %-10s %-12s %-20s Size\n", + "Name", "Offset", "Type", "Hash"); cbfs_walk(image, cbfs_print_entry_info, NULL); return 0; } @@ -883,10 +1046,11 @@ int cbfs_merge_empty_entry(struct cbfs_image *image, struct cbfs_file *entry, DEBUG("join_empty_entry: combine 0x%x+0x%x and 0x%x+0x%x.\n", cbfs_get_entry_addr(image, entry), ntohl(entry->len), cbfs_get_entry_addr(image, next), ntohl(next->len)); - cbfs_create_empty_entry(entry, - (last_addr - addr - - cbfs_calculate_file_header_size("")), - ""); + cbfs_create_empty_entry(entry, (last_addr - addr - + cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image))), + "", 0, VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); DEBUG("new empty entry: length=0x%x\n", ntohl(entry->len)); next = cbfs_find_next_entry(image, entry); } @@ -1016,16 +1180,32 @@ int cbfs_is_valid_entry(struct cbfs_image *image, struct cbfs_file *entry) strlen(CBFS_FILE_MAGIC)); } -int cbfs_create_empty_entry(struct cbfs_file *entry, - size_t len, const char *name) +int cbfs_create_empty_entry(struct cbfs_file *entry, size_t len, + const char *name, uint16_t flags, + enum vb2_hash_algorithm hash, bool legacy) { memset(entry, CBFS_CONTENT_DEFAULT_VALUE, sizeof(*entry)); memcpy(entry->magic, CBFS_FILE_MAGIC, sizeof(entry->magic)); entry->type = htonl(CBFS_COMPONENT_NULL); entry->len = htonl(len); - entry->checksum = 0; // TODO Build a checksum algorithm. - entry->offset = htonl(cbfs_calculate_file_header_size(name)); - memset(CBFS_NAME(entry), 0, ntohl(entry->offset) - sizeof(*entry)); + entry->offset = htonl(cbfs_calculate_file_header_size(name, hash, + legacy)); + if (legacy) { + entry->version = 0; + entry->flags = 0; + } else { + entry->version = htons(CBFS_FILE_VERSION); + entry->flags = htons(flags); + entry->header_len = + htonl(cbfs_calculate_file_header_size_without_name(hash, + false)); + entry->hash_type = htons(hash); + entry->hash_offset = htons(sizeof(*entry)); + memset((uint8_t *)entry + sizeof(*entry), 0, + CBFS_HEADER_LEN(entry) - sizeof(*entry)); + } + memset(CBFS_NAME(entry), 0, + ntohl(entry->offset) - CBFS_HEADER_LEN(entry)); strcpy(CBFS_NAME(entry), name); memset(CBFS_SUBHEADER(entry), CBFS_CONTENT_DEFAULT_VALUE, len); return 0; @@ -1049,7 +1229,8 @@ static int is_in_range(uint32_t start, uint32_t end, uint32_t header_len, } int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, - uint32_t size, uint32_t page_size, uint32_t align) + uint32_t size, enum vb2_hash_algorithm hash, + uint32_t page_size, uint32_t align) { struct cbfs_file *entry; size_t need_len; @@ -1077,8 +1258,9 @@ int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, * (type) param in future. For right now, we assume cbfs_stage is the * largest structure and add it into header size. */ assert(sizeof(struct cbfs_stage) >= sizeof(struct cbfs_payload)); - header_len = (cbfs_calculate_file_header_size(name) + - sizeof(struct cbfs_stage)); + header_len = (cbfs_calculate_file_header_size(name, hash, + cbfs_is_legacy_cbfs(image)) + + sizeof(struct cbfs_stage)); need_len = header_len + size; // Merge empty entries to build get max available space. diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index 5ff8a9a..31cb83a 100644 --- a/util/cbfstool/cbfs_image.h +++ b/util/cbfstool/cbfs_image.h @@ -19,6 +19,10 @@ #ifndef __CBFS_IMAGE_H #define __CBFS_IMAGE_H + +#include <stddef.h> +#include <vb2_api.h> + #include "common.h" #include "cbfs.h" @@ -32,6 +36,14 @@ struct cbfs_image { struct cbfs_header header; }; +/* Given the string name of a compression algorithm, return the corresponding + * enum comp_algo if it's supported, or a number < 0 otherwise. */ +int cbfs_parse_comp_algo(const char *name); + +/* Given the string name of a hash algorithm, return the corresponding + * enum vb2_hash_algorithm if it's supported, or a number < 0 otherwise. */ +int cbfs_parse_hash_algo(const char *name); + /* Given a pointer, serialize the header from host-native byte format * to cbfs format, i.e. big-endian. */ void cbfs_put_header(void *dest, const struct cbfs_header *header); @@ -89,22 +101,27 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, * Never pass this function a top-aligned address: convert it to an offset. * Returns 0 on success, otherwise non-zero. */ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, - const char *name, uint32_t type, uint32_t content_offset); + const char *name, uint32_t type, uint16_t flags, + enum vb2_hash_algorithm hash, uint32_t content_offset); /* Removes an entry from CBFS image. Returns 0 on success, otherwise non-zero. */ int cbfs_remove_entry(struct cbfs_image *image, const char *name); /* Initializes a new empty (type = NULL) entry with size and name in CBFS image. + * If a legacy entry is requested, it will be a version 0 header; otherwise, the + * most recently released revision will be chosen. * Returns 0 on success, otherwise (ex, not found) non-zero. */ -int cbfs_create_empty_entry(struct cbfs_file *entry, - size_t len, const char *name); +int cbfs_create_empty_entry(struct cbfs_file *entry, size_t len, + const char *name, uint16_t flags, + enum vb2_hash_algorithm hash, bool legacy); /* Finds a location to put given content by specified criteria: * "page_size" limits the content to fit on same memory page, and * "align" specifies starting address alignment. * Returns a valid offset, or -1 on failure. */ int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, - uint32_t size, uint32_t page_size, uint32_t align); + uint32_t size, enum vb2_hash_algorithm hash, + uint32_t page_size, uint32_t align); /* Callback function used by cbfs_walk. * Returns 0 on success, or non-zero to stop further iteration. */ diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 11353b6..ca5c599 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -75,14 +75,16 @@ static struct param { bool fill_partial_downward; bool show_immutable; int fit_empty_entries; - enum comp_algo algo; + enum comp_algo compression; + enum vb2_hash_algorithm hash; /* for linux payloads */ char *initrd; char *cmdline; } param = { /* All variables not listed are initialized as zero. */ .arch = CBFS_ARCHITECTURE_UNKNOWN, - .algo = CBFS_COMPRESS_NONE, + .compression = CBFS_COMPRESS_NONE, + .hash = VB2_HASH_INVALID, .headeroffset = ~0, .region_name = SECTION_NAME_PRIMARY_CBFS, }; @@ -150,8 +152,8 @@ static int cbfs_add_integer_component(const char *name, offset = convert_to_from_top_aligned(param.image_region, -offset); - if (cbfs_add_entry(&image, &buffer, name, CBFS_COMPONENT_RAW, offset) != - 0) { + if (cbfs_add_entry(&image, &buffer, name, CBFS_COMPONENT_RAW, 0, + param.hash, offset) != 0) { ERROR("Failed to add %llu into ROM image as '%s'.\n", (long long unsigned)u64val, name); goto done; @@ -212,7 +214,8 @@ static int cbfs_add_component(const char *filename, offset = convert_to_from_top_aligned(param.image_region, -offset); - if (cbfs_add_entry(&image, &buffer, name, type, offset) != 0) { + if (cbfs_add_entry(&image, &buffer, name, type, 0, param.hash, offset) + != 0) { ERROR("Failed to add '%s' into ROM image.\n", filename); buffer_delete(&buffer); return 1; @@ -225,10 +228,8 @@ static int cbfs_add_component(const char *filename, static int cbfstool_convert_mkstage(struct buffer *buffer, uint32_t *offset) { struct buffer output; - int ret; - ret = parse_elf_to_stage(buffer, &output, param.algo, offset, - param.ignore_section); - if (ret != 0) + if (parse_elf_to_stage(buffer, &output, param.compression, offset, + param.ignore_section) != 0) return -1; buffer_delete(buffer); // direct assign, no dupe. @@ -242,16 +243,16 @@ static int cbfstool_convert_mkpayload(struct buffer *buffer, struct buffer output; int ret; /* per default, try and see if payload is an ELF binary */ - ret = parse_elf_to_payload(buffer, &output, param.algo); + ret = parse_elf_to_payload(buffer, &output, param.compression); /* If it's not an ELF, see if it's a UEFI FV */ if (ret != 0) - ret = parse_fv_to_payload(buffer, &output, param.algo); + ret = parse_fv_to_payload(buffer, &output, param.compression); /* If it's neither ELF nor UEFI Fv, try bzImage */ if (ret != 0) ret = parse_bzImage_to_payload(buffer, &output, - param.initrd, param.cmdline, param.algo); + param.initrd, param.cmdline, param.compression); /* Not a supported payload type */ if (ret != 0) { @@ -273,7 +274,7 @@ static int cbfstool_convert_mkflatpayload(struct buffer *buffer, if (parse_flat_binary_to_payload(buffer, &output, param.loadaddress, param.entrypoint, - param.algo) != 0) { + param.compression) != 0) { return -1; } buffer_delete(buffer); @@ -474,7 +475,7 @@ static int cbfs_locate(void) } int32_t address = cbfs_locate_entry(&image, param.name, buffer.size, - param.pagesize, param.alignment); + param.hash, param.pagesize, param.alignment); buffer_delete(&buffer); if (address == -1) { @@ -736,16 +737,17 @@ static bool cbfs_is_legacy_format(struct buffer *buffer) } static const struct command commands[] = { - {"add", "H:r:f:n:t:b:vh?", cbfs_add, true, true}, - {"add-flat-binary", "H:r:f:n:l:e:c:b:vh?", cbfs_add_flat_binary, true, + {"add", "H:r:f:n:t:A:b:vh?", cbfs_add, true, true}, + {"add-flat-binary", "H:r:f:n:l:e:A:c:b:vh?", cbfs_add_flat_binary, true, true}, - {"add-payload", "H:r:f:n:t:c:b:C:I:vh?", cbfs_add_payload, true, true}, - {"add-stage", "H:r:f:n:t:c:b:S:vh?", cbfs_add_stage, true, true}, - {"add-int", "H:r:i:n:b:vh?", cbfs_add_integer, true, true}, + {"add-payload", "H:r:f:n:t:A:c:b:C:I:vh?", cbfs_add_payload, true, + true}, + {"add-stage", "H:r:f:n:t:A:c:b:S:vh?", cbfs_add_stage, true, true}, + {"add-int", "H:r:i:n:A:b:vh?", cbfs_add_integer, true, true}, {"copy", "H:D:s:h?", cbfs_copy, true, true}, {"create", "M:r:s:B:b:H:a:o:m:vh?", cbfs_create, true, true}, {"extract", "H:r:n:f:vh?", cbfs_extract, true, false}, - {"locate", "H:r:f:n:P:a:Tvh?", cbfs_locate, true, false}, + {"locate", "H:r:f:n:A:P:a:Tvh?", cbfs_locate, true, false}, {"layout", "wvh?", cbfs_layout, false, false}, {"print", "H:r:vh?", cbfs_print, true, false}, {"read", "r:f:vh?", cbfs_read, true, false}, @@ -755,35 +757,36 @@ static const struct command commands[] = { }; static struct option long_options[] = { - {"alignment", required_argument, 0, 'a' }, - {"base-address", required_argument, 0, 'b' }, - {"bootblock", required_argument, 0, 'B' }, - {"cmdline", required_argument, 0, 'C' }, - {"compression", required_argument, 0, 'c' }, - {"copy-offset", required_argument, 0, 'D' }, - {"empty-fits", required_argument, 0, 'x' }, - {"entry-point", required_argument, 0, 'e' }, - {"file", required_argument, 0, 'f' }, - {"fill-downward", no_argument, 0, 'd' }, - {"fill-upward", no_argument, 0, 'u' }, - {"flashmap", required_argument, 0, 'M' }, - {"fmap-regions", required_argument, 0, 'r' }, - {"header-offset", required_argument, 0, 'H' }, - {"help", no_argument, 0, 'h' }, - {"ignore-sec", required_argument, 0, 'S' }, - {"initrd", required_argument, 0, 'I' }, - {"int", required_argument, 0, 'i' }, - {"load-address", required_argument, 0, 'l' }, - {"machine", required_argument, 0, 'm' }, - {"name", required_argument, 0, 'n' }, - {"offset", required_argument, 0, 'o' }, - {"page-size", required_argument, 0, 'P' }, - {"size", required_argument, 0, 's' }, - {"top-aligned", required_argument, 0, 'T' }, - {"type", required_argument, 0, 't' }, - {"verbose", no_argument, 0, 'v' }, - {"with-readonly", no_argument, 0, 'w' }, - {NULL, 0, 0, 0 } + {"alignment", required_argument, 0, 'a' }, + {"base-address", required_argument, 0, 'b' }, + {"bootblock", required_argument, 0, 'B' }, + {"cmdline", required_argument, 0, 'C' }, + {"compression", required_argument, 0, 'c' }, + {"copy-offset", required_argument, 0, 'D' }, + {"empty-fits", required_argument, 0, 'x' }, + {"entry-point", required_argument, 0, 'e' }, + {"file", required_argument, 0, 'f' }, + {"fill-downward", no_argument, 0, 'd' }, + {"fill-upward", no_argument, 0, 'u' }, + {"flashmap", required_argument, 0, 'M' }, + {"fmap-regions", required_argument, 0, 'r' }, + {"hash-algorithm", required_argument, 0, 'A' }, + {"header-offset", required_argument, 0, 'H' }, + {"help", no_argument, 0, 'h' }, + {"ignore-sec", required_argument, 0, 'S' }, + {"initrd", required_argument, 0, 'I' }, + {"int", required_argument, 0, 'i' }, + {"load-address", required_argument, 0, 'l' }, + {"machine", required_argument, 0, 'm' }, + {"name", required_argument, 0, 'n' }, + {"offset", required_argument, 0, 'o' }, + {"page-size", required_argument, 0, 'P' }, + {"size", required_argument, 0, 's' }, + {"top-aligned", required_argument, 0, 'T' }, + {"type", required_argument, 0, 't' }, + {"verbose", no_argument, 0, 'v' }, + {"with-readonly", no_argument, 0, 'w' }, + {NULL, 0, 0, 0 } }; static int dispatch_command(struct command command) @@ -850,19 +853,19 @@ static void usage(char *name) " -v Provide verbose output\n" " -h Display this help message\n\n" "COMMANDs:\n" - " add [-r image,regions] -f FILE -n NAME -t TYPE \\\n" + " add [-r image,regions] -f FILE -n NAME -t TYPE [-A hash] \\\n" " [-b base-address] " "Add a component\n" - " add-payload [-r image,regions] -f FILE -n NAME \\\n" + " add-payload [-r image,regions] -f FILE -n NAME [-A hash] \\\n" " [-c compression] [-b base-address] " "Add a payload to the ROM\n" " (linux specific: [-C cmdline] [-I initrd])\n" - " add-stage [-r image,regions] -f FILE -n NAME \\\n" + " add-stage [-r image,regions] -f FILE -n NAME [-A hash] \\\n" " [-c compression] [-b base] [-S section-to-ignore] " "Add a stage to the ROM\n" " add-flat-binary [-r image,regions] -f FILE -n NAME \\\n" - " -l load-address -e entry-point [-c compression] \\\n" - " [-b base] " + " -l load-address -e entry-point [-A hash] \\\n" + " [-c compression] [-b base] " "Add a 32bit flat mode binary\n" " add-int [-r image,regions] -i INTEGER -n NAME [-b base] " "Add a raw 64-bit integer value\n" @@ -877,8 +880,8 @@ static void usage(char *name) "Create a legacy ROM file with CBFS master header*\n" " create -M flashmap [-r list,of,regions,containing,cbfses] " "Create a new-style partitioned firmware image\n" - " locate [-r image,regions] -f FILE -n NAME [-P page-size] \\\n" - " [-a align] [-T] " + " locate [-r image,regions] -f FILE -n NAME [-A hash] \\\n" + " [-P page-size] [-a align] [-T] " "Find a place for a file of that size\n" " layout [-w] " "List mutable (or, with -w, readable) image regions\n" @@ -974,15 +977,24 @@ int main(int argc, char **argv) WARN("Unknown type '%s' ignored\n", optarg); break; - case 'c': - if (!strncasecmp(optarg, "lzma", 5)) - param.algo = CBFS_COMPRESS_LZMA; - else if (!strncasecmp(optarg, "none", 5)) - param.algo = CBFS_COMPRESS_NONE; + case 'c': { + int algo = cbfs_parse_comp_algo(optarg); + if (algo >= 0) + param.compression = algo; else - WARN("Unknown compression '%s'" - " ignored.\n", optarg); + WARN("Unknown compression '%s' ignored.\n", + optarg); break; + } + case 'A': { + int algo = cbfs_parse_hash_algo(optarg); + if (algo >= 0) + param.hash = algo; + else + WARN("Unknown hashing scheme '%s' ignored.\n", + optarg); + break; + } case 'M': param.fmap = optarg; break; diff --git a/util/cbfstool/common.c b/util/cbfstool/common.c index 8773fe4..364ec02 100644 --- a/util/cbfstool/common.c +++ b/util/cbfstool/common.c @@ -19,6 +19,7 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA */ +#include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -26,6 +27,7 @@ #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> +#include <vb2_api.h> #include <libgen.h> #include "common.h" #include "cbfs.h" @@ -128,11 +130,23 @@ void buffer_delete(struct buffer *buffer) void cbfs_file_get_header(struct buffer *buf, struct cbfs_file *file) { + // Fields that were present from the "zeroth" revision bgets(buf, &file->magic, sizeof(file->magic)); file->len = xdr_be.get32(buf); file->type = xdr_be.get32(buf); - file->checksum = xdr_be.get32(buf); + file->version = xdr_be.get16(buf); + file->flags = xdr_be.get16(buf); file->offset = xdr_be.get32(buf); + + // Fields that were added in subsequent header versions + file->header_len = CBFS_FILE_V0_LEN; + file->hash_type = VB2_HASH_INVALID; + file->hash_offset = 0; + if (file->version >= 1) { + file->header_len = xdr_be.get32(buf); + file->hash_type = xdr_be.get16(buf); + file->hash_offset = xdr_be.get16(buf); + } } static struct { @@ -149,7 +163,7 @@ static struct { uint32_t string_to_arch(const char *arch_string) { - int i; + unsigned i; uint32_t ret = CBFS_ARCHITECTURE_UNKNOWN; for (i = 0; i < ARRAY_SIZE(arch_names); i++) { @@ -164,7 +178,7 @@ uint32_t string_to_arch(const char *arch_string) const char *arch_to_string(uint32_t a) { - int i; + unsigned i; const char *ret = NULL; for (i = 0; i < ARRAY_SIZE(arch_names); i++) { diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index ddec1a7..e86e9e2 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -28,13 +28,6 @@ /* Endianess */ #include "swab.h" -#ifndef __APPLE__ -#define ntohl(x) (is_big_endian() ? (uint32_t)(x) : swab32(x)) -#define htonl(x) (is_big_endian() ? (uint32_t)(x) : swab32(x)) -#endif -#define ntohll(x) (is_big_endian() ? (uint64_t)(x) : swab64(x)) -#define htonll(x) (is_big_endian() ? (uint64_t)(x) : swab64(x)) -int is_big_endian(void); /* Message output */ extern int verbose; @@ -45,7 +38,9 @@ extern int verbose; #define DEBUG(...) { if (verbose > 1) fprintf(stderr, "DEBUG: " __VA_ARGS__); } /* Helpers */ +#ifndef ARRAY_SIZE #define ARRAY_SIZE(a) (int)(sizeof(a) / sizeof((a)[0])) +#endif #define ALIGN(val, by) (((val) + (by)-1)&~((by)-1)) #define MAX(x, y) ((x) > (y) ? (x) : (y)) #define MIN(x, y) ((x) < (y) ? (x) : (y)) @@ -157,6 +152,8 @@ typedef int (*comp_func_ptr) (char *, int, char *, int *); enum comp_algo { CBFS_COMPRESS_NONE = 0, CBFS_COMPRESS_LZMA = 1 }; comp_func_ptr compression_function(enum comp_algo algo); +typedef uint8_t *(*hash_func_ptr)(const uint8_t *, uint64_t, uint8_t *); + uint64_t intfiletype(const char *name); diff --git a/util/cbfstool/swab.h b/util/cbfstool/swab.h index c5e4370..cf594d0 100644 --- a/util/cbfstool/swab.h +++ b/util/cbfstool/swab.h @@ -15,6 +15,15 @@ * */ +#ifndef __APPLE__ +#define ntohs(x) (is_big_endian() ? (uint16_t)(x) : swab16(x)) +#define htons(x) (is_big_endian() ? (uint16_t)(x) : swab16(x)) +#define ntohl(x) (is_big_endian() ? (uint32_t)(x) : swab32(x)) +#define htonl(x) (is_big_endian() ? (uint32_t)(x) : swab32(x)) +#endif +#define ntohll(x) (is_big_endian() ? (uint64_t)(x) : swab64(x)) +#define htonll(x) (is_big_endian() ? (uint64_t)(x) : swab64(x)) + /* casts are necessary for constants, because we never know how for sure * how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way. */ @@ -41,4 +50,7 @@ (((uint64_t)(x) & (uint64_t)0x00ff000000000000ULL) >> 40) | \ (((uint64_t)(x) & (uint64_t)0xff00000000000000ULL) >> 56) )) +/* common.c */ +int is_big_endian(void); + #endif /* _SWAB_H */

1 0

New patch to review for coreboot: 47faa8a cbfstool: Add version code, flags, variable-width hash to file headers
by Sol Boucher 08 May '15

08 May '15

Sol Boucher (solb(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/10147 -gerrit commit 47faa8a45e60a4cefdd79513c6a41f9becb9d56b Author: Sol Boucher <solb(a)chromium.org> Date: Thu May 7 21:00:05 2015 -0700 cbfstool: Add version code, flags, variable-width hash to file headers This new format is intended to fully replace the CBFS master header, and is only used when working with new-format images without one. The cbfstool utility remains backwards-compatible with legacy images that still use a master header, and will continue to generate old-format headers when operating on such files. However, because it always generates updated headers when working with new-format images, the very first version of cbfstool to support the new layout will be unable to read/write images created/edited by this and future versions. For the first time, cbfstool actually supports hashing files as they are added; invoking an add action with the -A switch set to sha1, sha256, or sha512 will generate a hash and store it in the entry header's new hash field. Subsequent print actions will detect the hashes and verify them using the same algorithm. BUG=chromium:482652 TEST=Build panther and nyan_big coreboot.rom and image.bin images with and without this patch, diff their hexdumps, and note that no locations differ except for those that do between subsequent builds of the same codebase. Try adding hashed files, ensuring that the stored hashes match those produced by the sha1sum, sha256sum, and sha512 commands, and that the print action correctly detects hashes that match and don't (due to intentional tampering). BRANCH=None Change-Id: Ibef7989b9b5830666925e5f8b5cad14cec2e3551 Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Change-Id: I1a117a9473e895feaf455bb30d0f945f57de51eb Original-Signed-off-by: Sol Boucher <solb(a)chromium.org> --- 3rdparty/vboot | 2 +- util/cbfstool/Makefile | 11 ++ util/cbfstool/Makefile.inc | 15 +++ util/cbfstool/cbfs.h | 35 ++++-- util/cbfstool/cbfs_image.c | 276 +++++++++++++++++++++++++++++++++++++-------- util/cbfstool/cbfs_image.h | 25 +++- util/cbfstool/cbfstool.c | 138 ++++++++++++----------- util/cbfstool/common.c | 20 +++- util/cbfstool/common.h | 11 +- util/cbfstool/swab.h | 12 ++ 10 files changed, 412 insertions(+), 133 deletions(-) diff --git a/3rdparty/vboot b/3rdparty/vboot index 7dd3bd0..f81fce9 160000 --- a/3rdparty/vboot +++ b/3rdparty/vboot @@ -1 +1 @@ -Subproject commit 7dd3bd0fcf565901aacc512cd29cefe19291c2e7 +Subproject commit f81fce91bf885293f1447c1197bb0c4143d8fced diff --git a/util/cbfstool/Makefile b/util/cbfstool/Makefile index 4238445..8094af8 100644 --- a/util/cbfstool/Makefile +++ b/util/cbfstool/Makefile @@ -8,7 +8,10 @@ CFLAGS += -Wcast-qual -Wmissing-prototypes -Wredundant-decls -Wshadow CFLAGS += -Wstrict-prototypes -Wwrite-strings CPPFLAGS += -D_DEFAULT_SOURCE # memccpy() from string.h CPPFLAGS += -D_POSIX_C_SOURCE=200809L # strdup() from string.h +CPPFLAGS += -DNEED_VB2_SHA_LIBRARY CPPFLAGS += -Iflashmap +CPPFLAGS += -I../../3rdparty/vboot/firmware/include +CPPFLAGS += -I../../3rdparty/vboot/firmware/2lib/include LDFLAGS += -g3 CBFSTOOL_BINARY:=$(obj)/cbfstool @@ -23,6 +26,11 @@ CBFSTOOL_COMMON+=flashmap/fmap.o CBFSTOOL_COMMON+=flashmap/kv_pair.o flashmap/valstr.o CBFSTOOL_COMMON:=$(addprefix $(obj)/,$(CBFSTOOL_COMMON)) +# CRYPTOLIB +CBFSTOOL_COMMON+=../../3rdparty/vboot/firmware/2lib/2sha_utility.o +CBFSTOOL_COMMON+=../../3rdparty/vboot/firmware/2lib/2sha1.o +CBFSTOOL_COMMON+=../../3rdparty/vboot/firmware/2lib/2sha256.o +CBFSTOOL_COMMON+=../../3rdparty/vboot/firmware/2lib/2sha512.o FMAPTOOL_BINARY:=$(obj)/fmaptool FMAPTOOL_COMMON:=cbfs_sections.o fmap_from_fmd.o @@ -97,5 +105,8 @@ $(obj)/fmd_parser.o: CFLAGS += -Wno-redundant-decls $(obj)/fmd_scanner.o: CFLAGS += -Wno-unused-function # Tolerate lzma sdk warnings $(obj)/lzma/C/LzmaEnc.o: CFLAGS += -Wno-sign-compare -Wno-cast-qual +# Tolerate vboot warnings +../../3rdparty/vboot/firmware/2lib/2sha_utility.o: CFLAGS += -Wno-sign-compare +../../3rdparty/vboot/firmware/2lib/2sha1.o: CFLAGS += -Wno-cast-qual -include .dependencies diff --git a/util/cbfstool/Makefile.inc b/util/cbfstool/Makefile.inc index 1aa9d76..41991d8 100644 --- a/util/cbfstool/Makefile.inc +++ b/util/cbfstool/Makefile.inc @@ -14,6 +14,11 @@ cbfsobj += lzma.o cbfsobj += LzFind.o cbfsobj += LzmaDec.o cbfsobj += LzmaEnc.o +# CRYPTOLIB +cbfsobj += 2sha_utility.o +cbfsobj += 2sha1.o +cbfsobj += 2sha256.o +cbfsobj += 2sha512.o # FMAP cbfsobj += fmap.o cbfsobj += kv_pair.o @@ -46,7 +51,10 @@ TOOLCFLAGS += -Wcast-qual -Wmissing-prototypes -Wredundant-decls -Wshadow TOOLCFLAGS += -Wstrict-prototypes -Wwrite-strings TOOLCPPFLAGS ?= -D_DEFAULT_SOURCE # memccpy() from string.h TOOLCPPFLAGS += -D_POSIX_C_SOURCE=200809L # strdup() from string.h +TOOLCPPFLAGS += -DNEED_VB2_SHA_LIBRARY TOOLCPPFLAGS += -I$(top)/util/cbfstool/flashmap +TOOLCPPFLAGS += -I$(top)/3rdparty/vboot/firmware/include +TOOLCPPFLAGS += -I$(top)/3rdparty/vboot/firmware/2lib/include TOOLLDFLAGS ?= ifeq ($(shell uname -s | cut -c-7 2>/dev/null), MINGW32) @@ -69,6 +77,10 @@ $(objutil)/cbfstool/%.o: $(top)/util/cbfstool/lzma/C/%.c printf " HOSTCC $(subst $(objutil)/,,$(@))\n" $(HOSTCC) $(TOOLCPPFLAGS) $(TOOLCFLAGS) $(HOSTCFLAGS) -c -o $@ $< +$(objutil)/cbfstool/%.o: $(top)/3rdparty/vboot/firmware/2lib/%.c + printf " HOSTCC $(subst $(objutil)/,,$(@))\n" + $(HOSTCC) $(TOOLCPPFLAGS) $(TOOLCFLAGS) $(HOSTCFLAGS) -c -o $@ $< + $(objutil)/cbfstool/cbfstool: $(addprefix $(objutil)/cbfstool/,$(cbfsobj)) printf " HOSTCC $(subst $(objutil)/,,$(@)) (link)\n" $(HOSTCC) $(TOOLLDFLAGS) -o $@ $(addprefix $(objutil)/cbfstool/,$(cbfsobj)) @@ -87,6 +99,9 @@ $(objutil)/cbfstool/fmd_parser.o: TOOLCFLAGS += -Wno-redundant-decls $(objutil)/cbfstool/fmd_scanner.o: TOOLCFLAGS += -Wno-unused-function # Tolerate lzma sdk warnings $(objutil)/cbfstool/LzmaEnc.o: TOOLCFLAGS += -Wno-sign-compare -Wno-cast-qual +# Tolerate vboot warnings +$(objutil)/cbfstool/2sha_utility.o: TOOLCFLAGS += -Wno-sign-compare +$(objutil)/cbfstool/2sha1.o: TOOLCFLAGS += -Wno-cast-qual ifeq ($(CONFIG_FMD_GENPARSER),y) TOOLLEX := lex diff --git a/util/cbfstool/cbfs.h b/util/cbfstool/cbfs.h index ef39594..95c36c4 100644 --- a/util/cbfstool/cbfs.h +++ b/util/cbfstool/cbfs.h @@ -21,6 +21,9 @@ #include <stdint.h> +/* Endianess */ +#include "swab.h" + /* create a magic number in host-byte order. * b3 is the high order byte. * in the coreboot tools, we go with the 32-bit @@ -60,14 +63,22 @@ struct cbfs_header { #define CBFS_ARCHITECTURE_RISCV 0xc001d0de #define CBFS_FILE_MAGIC "LARCHIVE" +#define CBFS_FILE_VERSION 1 +#define CBFS_FILE_V0_LEN (6 * sizeof(uint32_t)) struct cbfs_file { uint8_t magic[8]; - uint32_t len; + uint32_t len; /* Of the file described by this header */ uint32_t type; - uint32_t checksum; - uint32_t offset; + uint16_t version; + uint16_t flags; /* V1 */ + uint32_t offset; /* To the file described by this header */ + uint32_t header_len; /* V1: Of header, up to the *beginning* of name */ + uint16_t hash_type; /* V1: Also determines size of the hash */ + uint16_t hash_offset; /* V1: From the beginning of header */ } __attribute__ ((packed)); +/* Should be immediately followed by the hash (and any future variable-width + fields), then the (NUL-terminated) variable-length name. */ struct cbfs_stage { uint32_t compression; @@ -128,15 +139,23 @@ struct cbfs_payload { */ #define CBFS_COMPONENT_NULL 0xFFFFFFFF -#define CBFS_NAME(_c) (((char *) (_c)) + sizeof(struct cbfs_file)) -#define CBFS_SUBHEADER(_p) ( (void *) ((((uint8_t *) (_p)) + ntohl((_p)->offset))) ) -/* cbfs_image.c */ -uint32_t get_cbfs_entry_type(const char *name, uint32_t default_value); -uint32_t get_cbfs_compression(const char *name, uint32_t unknown); +#define CBFS_HEADER_LEN(_c) (ntohs((_c)->version) >= 1 ? \ + ntohl((_c)->header_len) : CBFS_FILE_V0_LEN) +#define CBFS_NAME(_c) (ntohs((_c)->version) >= 1 ? \ + ((char *) (_c)) + ntohl((_c)->header_len) : \ + ((char *) (_c)) + CBFS_FILE_V0_LEN) +#define CBFS_SUBHEADER(_p) ((void *) (((uint8_t *) (_p)) + ntohl((_p)->offset))) +#define CBFS_HASH(_c) ((_c)->version >= 1 && (_c)->hash_type && \ + (_c)->hash_offset ? \ + (((uint8_t *) (_c)) + ntohs((_c)->hash_offset)) : NULL) /* common.c */ void cbfs_file_get_header(struct buffer *buf, struct cbfs_file *file); +/* cbfs_image.c */ +uint32_t get_cbfs_entry_type(const char *name, uint32_t default_value); +uint32_t get_cbfs_compression(const char *name, uint32_t unknown); + /* cbfs-mkpayload.c */ void xdr_segs(struct buffer *output, struct cbfs_payload_segment *segs, int nseg); diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index 8fb2a60..29c3593 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -77,15 +77,32 @@ static const struct typedesc_t types_cbfs_entry[] = { {CBFS_COMPONENT_MRC_CACHE, "mrc_cache"}, {CBFS_COMPONENT_DELETED, "deleted"}, {CBFS_COMPONENT_NULL, "null"}, - {0, NULL}, + {0, NULL} }; static const struct typedesc_t types_cbfs_compression[] = { {CBFS_COMPRESS_NONE, "none"}, {CBFS_COMPRESS_LZMA, "LZMA"}, - {0, NULL}, + {0, NULL} }; +static const struct typedesc_t types_cbfs_hash[] = { + {VB2_HASH_INVALID, "none"}, + {VB2_HASH_SHA1, "sha1"}, + {VB2_HASH_SHA256, "sha256"}, + {VB2_HASH_SHA512, "sha512"}, + {0, NULL} +}; + +static size_t widths_cbfs_hash[] = { + [VB2_HASH_INVALID] = 0, + [VB2_HASH_SHA1] = 20, + [VB2_HASH_SHA256] = 32, + [VB2_HASH_SHA512] = 64, +}; +#define CBFS_NUM_SUPPORTED_HASHES (sizeof(widths_cbfs_hash) / \ + sizeof(*(widths_cbfs_hash))) + static const char *lookup_name_by_type(const struct typedesc_t *desc, uint32_t type, const char *default_value) { @@ -96,17 +113,46 @@ static const char *lookup_name_by_type(const struct typedesc_t *desc, uint32_t t return default_value; } +static int lookup_type_by_name(const struct typedesc_t *desc, const char *name) +{ + int i; + for (i = 0; desc[i].name && strcasecmp(name, desc[i].name); ++i); + return desc[i].name ? (int)desc[i].type : -1; +} + static const char *get_cbfs_entry_type_name(uint32_t type) { return lookup_name_by_type(types_cbfs_entry, type, "(unknown)"); } +int cbfs_parse_comp_algo(const char *name) +{ + return lookup_type_by_name(types_cbfs_compression, name); +} + +int cbfs_parse_hash_algo(const char *name) +{ + return lookup_type_by_name(types_cbfs_hash, name); +} + /* CBFS image */ -static size_t cbfs_calculate_file_header_size(const char *name) +static size_t cbfs_calculate_file_header_size_without_name( + enum vb2_hash_algorithm hash, bool legacy) { - return (sizeof(struct cbfs_file) + - align_up(strlen(name) + 1, CBFS_FILENAME_ALIGN)); + if (legacy) + return CBFS_FILE_V0_LEN; + else + return sizeof(struct cbfs_file) + widths_cbfs_hash[hash]; +} + +static size_t cbfs_calculate_file_header_size(const char *name, + enum vb2_hash_algorithm hash, + bool legacy) +{ + return align_up( + cbfs_calculate_file_header_size_without_name(hash, legacy) + + strlen(name) + 1, CBFS_FILENAME_ALIGN); } /* Only call on legacy CBFSes possessing a master header. */ @@ -190,7 +236,8 @@ int cbfs_image_create(struct cbfs_image *image, size_t entries_size) assert(image); assert(image->buffer.data); - size_t empty_header_len = cbfs_calculate_file_header_size(""); + size_t empty_header_len = cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image)); uint32_t entries_offset = 0; uint32_t align = CBFS_ENTRY_ALIGNMENT; if (image->has_header) { @@ -231,7 +278,8 @@ int cbfs_image_create(struct cbfs_image *image, size_t entries_size) size_t capacity = entries_size - empty_header_len; LOG("Created CBFS (capacity = %zu bytes)\n", capacity); - return cbfs_create_empty_entry(entry_header, capacity, ""); + return cbfs_create_empty_entry(entry_header, capacity, "", 0, + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image)); } int cbfs_legacy_image_create(struct cbfs_image *image, @@ -422,12 +470,13 @@ int cbfs_copy_instance(struct cbfs_image *image, size_t copy_offset, /* Last entry size is all the room above it. */ last_entry_size = copy_end - ((char *)dst_entry - image->buffer.data) - - cbfs_calculate_file_header_size(""); + - cbfs_calculate_file_header_size("", VB2_HASH_INVALID, true); if (last_entry_size < 0) WARN("No room to create the last entry!\n") else - cbfs_create_empty_entry(dst_entry, last_entry_size, ""); + cbfs_create_empty_entry(dst_entry, last_entry_size, "", 0, + VB2_HASH_INVALID, true); return 0; } @@ -441,20 +490,84 @@ int cbfs_image_delete(struct cbfs_image *image) return 0; } +/* Might be out of range. VB2_HASH_INVALID if file isn't protected by a hash. */ +static uint16_t cbfs_read_hash_type(struct cbfs_file *entry) +{ + return ntohs(entry->version) >= 1 ? + ntohs(entry->hash_type) : VB2_HASH_INVALID; +} + +/* Retrieve hash field and its type. Returns < 0 for unknown/truncated hash. */ +static int cbfs_read_file_hash(uint8_t **hash, struct cbfs_file *entry) +{ + uint16_t type = cbfs_read_hash_type(entry); + if (type >= CBFS_NUM_SUPPORTED_HASHES) { + WARN("This version of cbfstool is too old to process hashes of the type used for this file\n"); + return -1; + } + + size_t width = widths_cbfs_hash[type]; + uint8_t *stored = CBFS_HASH(entry); + if (stored && ((uintptr_t)stored) - ((uintptr_t)entry) + + ((uintptr_t)width) > CBFS_HEADER_LEN(entry)) { + ERROR("This file header's hash field is truncated\n"); + return -1; + } + if (hash) + *hash = stored; + return type; +} + +/* 0 on success */ +static int cbfs_populate_file_hash(struct cbfs_file *entry) +{ + uint8_t *hash = NULL; + int type = cbfs_read_file_hash(&hash, entry); + if (type > 0) { + return vb2_digest_buffer(CBFS_SUBHEADER(entry), + ntohl(entry->len), type, hash, + widths_cbfs_hash[type]) != VB2_SUCCESS; + } + return type; +} + +/* 0 on match, 1 on mismatch, < 0 on error */ +static int cbfs_check_hash(struct cbfs_file *entry) +{ + uint8_t *stored = NULL; + int type = cbfs_read_file_hash(&stored, entry); + if (type < 0) + return type; + + size_t width = widths_cbfs_hash[type]; + if (!width) + return 0; + + uint8_t computed[width]; + if (vb2_digest_buffer(CBFS_SUBHEADER(entry), ntohl(entry->len), type, + computed, width) != VB2_SUCCESS) + return -1; + return memcmp(computed, stored, width) == 0 ? 0 : 1; +} + /* Tries to add an entry with its data (CBFS_SUBHEADER) at given offset. */ static int cbfs_add_entry_at(struct cbfs_image *image, struct cbfs_file *entry, uint32_t size, const char *name, uint32_t type, + uint16_t flags, + enum vb2_hash_algorithm hash, const void *data, uint32_t content_offset) { struct cbfs_file *next = cbfs_find_next_entry(image, entry); uint32_t addr = cbfs_get_entry_addr(image, entry), addr_next = cbfs_get_entry_addr(image, next); - uint32_t header_size = cbfs_calculate_file_header_size(name), - min_entry_size = cbfs_calculate_file_header_size(""); + uint32_t header_size = cbfs_calculate_file_header_size(name, hash, + cbfs_is_legacy_cbfs(image)), + min_entry_size = cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image)); uint32_t len, target; uint32_t align = image->has_header ? image->header.align : CBFS_ENTRY_ALIGNMENT; @@ -471,14 +584,16 @@ static int cbfs_add_entry_at(struct cbfs_image *image, if (target - addr > min_entry_size) { DEBUG("|min|...|header|content|... <create new entry>\n"); len = target - addr - min_entry_size; - cbfs_create_empty_entry(entry, len, ""); + cbfs_create_empty_entry(entry, len, "", 0, VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); if (verbose > 1) cbfs_print_entry_info(image, entry, stderr); entry = cbfs_find_next_entry(image, entry); addr = cbfs_get_entry_addr(image, entry); } len = size + (content_offset - addr - header_size); - cbfs_create_empty_entry(entry, len, name); + cbfs_create_empty_entry(entry, len, name, flags, hash, + cbfs_is_legacy_cbfs(image)); if (len != size) { DEBUG("|..|header|content|... <use offset to create entry>\n"); DEBUG("before: offset=0x%x, len=0x%x\n", @@ -499,6 +614,7 @@ static int cbfs_add_entry_at(struct cbfs_image *image, assert((char*)CBFS_SUBHEADER(entry) - image->buffer.data == (ptrdiff_t)content_offset); memcpy(CBFS_SUBHEADER(entry), data, size); + cbfs_populate_file_hash(entry); if (verbose > 1) cbfs_print_entry_info(image, entry, stderr); // Process buffer AFTER entry. @@ -518,13 +634,15 @@ static int cbfs_add_entry_at(struct cbfs_image *image, } len = addr_next - addr - min_entry_size; - cbfs_create_empty_entry(entry, len, ""); + cbfs_create_empty_entry(entry, len, "", 0, VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); if (verbose > 1) cbfs_print_entry_info(image, entry, stderr); return 0; } int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, - const char *name, uint32_t type, uint32_t content_offset) + const char *name, uint32_t type, uint16_t flags, + enum vb2_hash_algorithm hash, uint32_t content_offset) { assert(image); assert(buffer); @@ -537,7 +655,8 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, struct cbfs_file *entry, *next; uint32_t header_size, need_size, new_size; - header_size = cbfs_calculate_file_header_size(name); + header_size = cbfs_calculate_file_header_size(name, hash, + cbfs_is_legacy_cbfs(image)); need_size = header_size + buffer->size; DEBUG("cbfs_add_entry('%s'@0x%x) => need_size = %u+%zu=%u\n", @@ -572,9 +691,12 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, if (!content_offset || content_offset == addr + header_size) { DEBUG("Filling new entry data (%zd bytes).\n", buffer->size); - cbfs_create_empty_entry(entry, buffer->size, name); + cbfs_create_empty_entry(entry, buffer->size, name, + flags, hash, + cbfs_is_legacy_cbfs(image)); entry->type = htonl(type); memcpy(CBFS_SUBHEADER(entry), buffer->data, buffer->size); + cbfs_populate_file_hash(entry); if (verbose) cbfs_print_entry_info(image, entry, stderr); @@ -585,7 +707,9 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, cbfs_get_entry_addr(image, entry)); /* Entry was added and no space for new "empty" entry */ - if (new_size < cbfs_calculate_file_header_size("")) { + if (new_size < cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image))) { DEBUG("No need for new \"empty\" entry\n"); /* No need to increase the size of the just * stored file to extend to next file. Alignment @@ -593,9 +717,13 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, */ return 0; } - new_size -= cbfs_calculate_file_header_size(""); + new_size -= cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); DEBUG("new size: %d\n", new_size); - cbfs_create_empty_entry(entry, new_size, ""); + cbfs_create_empty_entry(entry, new_size, "", 0, + VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); if (verbose) cbfs_print_entry_info(image, entry, stderr); return 0; @@ -624,7 +752,7 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, addr, addr_next - addr, content_offset); if (cbfs_add_entry_at(image, entry, buffer->size, name, type, - buffer->data, content_offset) == 0) { + flags, hash, buffer->data, content_offset) == 0) { return 0; } break; @@ -662,6 +790,19 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, entry_name, cbfs_get_entry_addr(image, entry), get_cbfs_entry_type_name(ntohl(entry->type)), ntohl(entry->len)); + if (cbfs_read_hash_type(entry) != VB2_HASH_INVALID) { + switch (cbfs_check_hash(entry)) { + case 0: // match + LOG("File hash successfully verified\n"); + break; + case 1: // mismatch + WARN("File hash mismatch (corrupt file?)\n"); + break; + default: // error + WARN("Unable to verify file consistency; attempting to extract anyway\n"); + } + } + if (ntohl(entry->type) != CBFS_COMPONENT_RAW) { WARN("Only 'raw' files are safe to extract.\n"); } @@ -682,25 +823,26 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, int cbfs_remove_entry(struct cbfs_image *image, const char *name) { - struct cbfs_file *entry, *next; - size_t len; - entry = cbfs_get_entry(image, name); + struct cbfs_file *entry = cbfs_get_entry(image, name); if (!entry) { ERROR("CBFS file %s not found.\n", name); return -1; } - next = cbfs_find_next_entry(image, entry); + struct cbfs_file *next = cbfs_find_next_entry(image, entry); assert(next); + ptrdiff_t len = (uintptr_t)next - (uintptr_t)entry - + cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image)); + if (len < 0) { + // Not enough space to fit current generation empty header. + ERROR("Only the older version of cbfstool that created this image can remove that file\n"); + return -1; + } + cbfs_create_empty_entry(entry, len, "", 0, VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); + entry->type = htonl(CBFS_COMPONENT_DELETED); DEBUG("cbfs_remove_entry: Removed %s @ 0x%x\n", CBFS_NAME(entry), cbfs_get_entry_addr(image, entry)); - entry->type = htonl(CBFS_COMPONENT_DELETED); - len = (cbfs_get_entry_addr(image, next) - - cbfs_get_entry_addr(image, entry)); - entry->offset = htonl(cbfs_calculate_file_header_size("")); - entry->len = htonl(len - ntohl(entry->offset)); - memset(CBFS_NAME(entry), 0, ntohl(entry->offset) - sizeof(*entry)); - memset(CBFS_SUBHEADER(entry), CBFS_CONTENT_DEFAULT_VALUE, - ntohl(entry->len)); return 0; } @@ -799,10 +941,30 @@ int cbfs_print_entry_info(struct cbfs_image *image, struct cbfs_file *entry, if (!fp) fp = stdout; - fprintf(fp, "%-30s 0x%-8x %-12s %d\n", + char hash_status[20]; + uint16_t type = cbfs_read_hash_type(entry); + const char *typename = + lookup_name_by_type(types_cbfs_hash, type, "unrecognized"); + const char *status = "N/A"; + if (type != VB2_HASH_INVALID) { + switch (cbfs_check_hash(entry)) { + case 0: // match + status = "verified"; + break; + case 1: // mismatch + status = "MISMATCH"; + break; + default: // error + status = "?!"; + } + } + sprintf(hash_status, "%s (%s)", status, typename); + + fprintf(fp, "%-30s 0x%-8x %-12s %-20s %d\n", *name ? name : "(empty)", cbfs_get_entry_addr(image, entry), get_cbfs_entry_type_name(ntohl(entry->type)), + hash_status, ntohl(entry->len)); if (!verbose) @@ -844,7 +1006,8 @@ int cbfs_print_directory(struct cbfs_image *image) { if (cbfs_is_legacy_cbfs(image)) cbfs_print_header_info(image); - printf("%-30s %-10s %-12s Size\n", "Name", "Offset", "Type"); + printf("%-30s %-10s %-12s %-20s Size\n", + "Name", "Offset", "Type", "Hash"); cbfs_walk(image, cbfs_print_entry_info, NULL); return 0; } @@ -883,10 +1046,11 @@ int cbfs_merge_empty_entry(struct cbfs_image *image, struct cbfs_file *entry, DEBUG("join_empty_entry: combine 0x%x+0x%x and 0x%x+0x%x.\n", cbfs_get_entry_addr(image, entry), ntohl(entry->len), cbfs_get_entry_addr(image, next), ntohl(next->len)); - cbfs_create_empty_entry(entry, - (last_addr - addr - - cbfs_calculate_file_header_size("")), - ""); + cbfs_create_empty_entry(entry, (last_addr - addr - + cbfs_calculate_file_header_size("", + VB2_HASH_INVALID, cbfs_is_legacy_cbfs(image))), + "", 0, VB2_HASH_INVALID, + cbfs_is_legacy_cbfs(image)); DEBUG("new empty entry: length=0x%x\n", ntohl(entry->len)); next = cbfs_find_next_entry(image, entry); } @@ -1016,16 +1180,32 @@ int cbfs_is_valid_entry(struct cbfs_image *image, struct cbfs_file *entry) strlen(CBFS_FILE_MAGIC)); } -int cbfs_create_empty_entry(struct cbfs_file *entry, - size_t len, const char *name) +int cbfs_create_empty_entry(struct cbfs_file *entry, size_t len, + const char *name, uint16_t flags, + enum vb2_hash_algorithm hash, bool legacy) { memset(entry, CBFS_CONTENT_DEFAULT_VALUE, sizeof(*entry)); memcpy(entry->magic, CBFS_FILE_MAGIC, sizeof(entry->magic)); entry->type = htonl(CBFS_COMPONENT_NULL); entry->len = htonl(len); - entry->checksum = 0; // TODO Build a checksum algorithm. - entry->offset = htonl(cbfs_calculate_file_header_size(name)); - memset(CBFS_NAME(entry), 0, ntohl(entry->offset) - sizeof(*entry)); + entry->offset = htonl(cbfs_calculate_file_header_size(name, hash, + legacy)); + if (legacy) { + entry->version = 0; + entry->flags = 0; + } else { + entry->version = htons(CBFS_FILE_VERSION); + entry->flags = htons(flags); + entry->header_len = + htonl(cbfs_calculate_file_header_size_without_name(hash, + false)); + entry->hash_type = htons(hash); + entry->hash_offset = htons(sizeof(*entry)); + memset((uint8_t *)entry + sizeof(*entry), 0, + CBFS_HEADER_LEN(entry) - sizeof(*entry)); + } + memset(CBFS_NAME(entry), 0, + ntohl(entry->offset) - CBFS_HEADER_LEN(entry)); strcpy(CBFS_NAME(entry), name); memset(CBFS_SUBHEADER(entry), CBFS_CONTENT_DEFAULT_VALUE, len); return 0; @@ -1049,7 +1229,8 @@ static int is_in_range(uint32_t start, uint32_t end, uint32_t header_len, } int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, - uint32_t size, uint32_t page_size, uint32_t align) + uint32_t size, enum vb2_hash_algorithm hash, + uint32_t page_size, uint32_t align) { struct cbfs_file *entry; size_t need_len; @@ -1077,8 +1258,9 @@ int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, * (type) param in future. For right now, we assume cbfs_stage is the * largest structure and add it into header size. */ assert(sizeof(struct cbfs_stage) >= sizeof(struct cbfs_payload)); - header_len = (cbfs_calculate_file_header_size(name) + - sizeof(struct cbfs_stage)); + header_len = (cbfs_calculate_file_header_size(name, hash, + cbfs_is_legacy_cbfs(image)) + + sizeof(struct cbfs_stage)); need_len = header_len + size; // Merge empty entries to build get max available space. diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index 5ff8a9a..31cb83a 100644 --- a/util/cbfstool/cbfs_image.h +++ b/util/cbfstool/cbfs_image.h @@ -19,6 +19,10 @@ #ifndef __CBFS_IMAGE_H #define __CBFS_IMAGE_H + +#include <stddef.h> +#include <vb2_api.h> + #include "common.h" #include "cbfs.h" @@ -32,6 +36,14 @@ struct cbfs_image { struct cbfs_header header; }; +/* Given the string name of a compression algorithm, return the corresponding + * enum comp_algo if it's supported, or a number < 0 otherwise. */ +int cbfs_parse_comp_algo(const char *name); + +/* Given the string name of a hash algorithm, return the corresponding + * enum vb2_hash_algorithm if it's supported, or a number < 0 otherwise. */ +int cbfs_parse_hash_algo(const char *name); + /* Given a pointer, serialize the header from host-native byte format * to cbfs format, i.e. big-endian. */ void cbfs_put_header(void *dest, const struct cbfs_header *header); @@ -89,22 +101,27 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, * Never pass this function a top-aligned address: convert it to an offset. * Returns 0 on success, otherwise non-zero. */ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, - const char *name, uint32_t type, uint32_t content_offset); + const char *name, uint32_t type, uint16_t flags, + enum vb2_hash_algorithm hash, uint32_t content_offset); /* Removes an entry from CBFS image. Returns 0 on success, otherwise non-zero. */ int cbfs_remove_entry(struct cbfs_image *image, const char *name); /* Initializes a new empty (type = NULL) entry with size and name in CBFS image. + * If a legacy entry is requested, it will be a version 0 header; otherwise, the + * most recently released revision will be chosen. * Returns 0 on success, otherwise (ex, not found) non-zero. */ -int cbfs_create_empty_entry(struct cbfs_file *entry, - size_t len, const char *name); +int cbfs_create_empty_entry(struct cbfs_file *entry, size_t len, + const char *name, uint16_t flags, + enum vb2_hash_algorithm hash, bool legacy); /* Finds a location to put given content by specified criteria: * "page_size" limits the content to fit on same memory page, and * "align" specifies starting address alignment. * Returns a valid offset, or -1 on failure. */ int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, - uint32_t size, uint32_t page_size, uint32_t align); + uint32_t size, enum vb2_hash_algorithm hash, + uint32_t page_size, uint32_t align); /* Callback function used by cbfs_walk. * Returns 0 on success, or non-zero to stop further iteration. */ diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 11353b6..ca5c599 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -75,14 +75,16 @@ static struct param { bool fill_partial_downward; bool show_immutable; int fit_empty_entries; - enum comp_algo algo; + enum comp_algo compression; + enum vb2_hash_algorithm hash; /* for linux payloads */ char *initrd; char *cmdline; } param = { /* All variables not listed are initialized as zero. */ .arch = CBFS_ARCHITECTURE_UNKNOWN, - .algo = CBFS_COMPRESS_NONE, + .compression = CBFS_COMPRESS_NONE, + .hash = VB2_HASH_INVALID, .headeroffset = ~0, .region_name = SECTION_NAME_PRIMARY_CBFS, }; @@ -150,8 +152,8 @@ static int cbfs_add_integer_component(const char *name, offset = convert_to_from_top_aligned(param.image_region, -offset); - if (cbfs_add_entry(&image, &buffer, name, CBFS_COMPONENT_RAW, offset) != - 0) { + if (cbfs_add_entry(&image, &buffer, name, CBFS_COMPONENT_RAW, 0, + param.hash, offset) != 0) { ERROR("Failed to add %llu into ROM image as '%s'.\n", (long long unsigned)u64val, name); goto done; @@ -212,7 +214,8 @@ static int cbfs_add_component(const char *filename, offset = convert_to_from_top_aligned(param.image_region, -offset); - if (cbfs_add_entry(&image, &buffer, name, type, offset) != 0) { + if (cbfs_add_entry(&image, &buffer, name, type, 0, param.hash, offset) + != 0) { ERROR("Failed to add '%s' into ROM image.\n", filename); buffer_delete(&buffer); return 1; @@ -225,10 +228,8 @@ static int cbfs_add_component(const char *filename, static int cbfstool_convert_mkstage(struct buffer *buffer, uint32_t *offset) { struct buffer output; - int ret; - ret = parse_elf_to_stage(buffer, &output, param.algo, offset, - param.ignore_section); - if (ret != 0) + if (parse_elf_to_stage(buffer, &output, param.compression, offset, + param.ignore_section) != 0) return -1; buffer_delete(buffer); // direct assign, no dupe. @@ -242,16 +243,16 @@ static int cbfstool_convert_mkpayload(struct buffer *buffer, struct buffer output; int ret; /* per default, try and see if payload is an ELF binary */ - ret = parse_elf_to_payload(buffer, &output, param.algo); + ret = parse_elf_to_payload(buffer, &output, param.compression); /* If it's not an ELF, see if it's a UEFI FV */ if (ret != 0) - ret = parse_fv_to_payload(buffer, &output, param.algo); + ret = parse_fv_to_payload(buffer, &output, param.compression); /* If it's neither ELF nor UEFI Fv, try bzImage */ if (ret != 0) ret = parse_bzImage_to_payload(buffer, &output, - param.initrd, param.cmdline, param.algo); + param.initrd, param.cmdline, param.compression); /* Not a supported payload type */ if (ret != 0) { @@ -273,7 +274,7 @@ static int cbfstool_convert_mkflatpayload(struct buffer *buffer, if (parse_flat_binary_to_payload(buffer, &output, param.loadaddress, param.entrypoint, - param.algo) != 0) { + param.compression) != 0) { return -1; } buffer_delete(buffer); @@ -474,7 +475,7 @@ static int cbfs_locate(void) } int32_t address = cbfs_locate_entry(&image, param.name, buffer.size, - param.pagesize, param.alignment); + param.hash, param.pagesize, param.alignment); buffer_delete(&buffer); if (address == -1) { @@ -736,16 +737,17 @@ static bool cbfs_is_legacy_format(struct buffer *buffer) } static const struct command commands[] = { - {"add", "H:r:f:n:t:b:vh?", cbfs_add, true, true}, - {"add-flat-binary", "H:r:f:n:l:e:c:b:vh?", cbfs_add_flat_binary, true, + {"add", "H:r:f:n:t:A:b:vh?", cbfs_add, true, true}, + {"add-flat-binary", "H:r:f:n:l:e:A:c:b:vh?", cbfs_add_flat_binary, true, true}, - {"add-payload", "H:r:f:n:t:c:b:C:I:vh?", cbfs_add_payload, true, true}, - {"add-stage", "H:r:f:n:t:c:b:S:vh?", cbfs_add_stage, true, true}, - {"add-int", "H:r:i:n:b:vh?", cbfs_add_integer, true, true}, + {"add-payload", "H:r:f:n:t:A:c:b:C:I:vh?", cbfs_add_payload, true, + true}, + {"add-stage", "H:r:f:n:t:A:c:b:S:vh?", cbfs_add_stage, true, true}, + {"add-int", "H:r:i:n:A:b:vh?", cbfs_add_integer, true, true}, {"copy", "H:D:s:h?", cbfs_copy, true, true}, {"create", "M:r:s:B:b:H:a:o:m:vh?", cbfs_create, true, true}, {"extract", "H:r:n:f:vh?", cbfs_extract, true, false}, - {"locate", "H:r:f:n:P:a:Tvh?", cbfs_locate, true, false}, + {"locate", "H:r:f:n:A:P:a:Tvh?", cbfs_locate, true, false}, {"layout", "wvh?", cbfs_layout, false, false}, {"print", "H:r:vh?", cbfs_print, true, false}, {"read", "r:f:vh?", cbfs_read, true, false}, @@ -755,35 +757,36 @@ static const struct command commands[] = { }; static struct option long_options[] = { - {"alignment", required_argument, 0, 'a' }, - {"base-address", required_argument, 0, 'b' }, - {"bootblock", required_argument, 0, 'B' }, - {"cmdline", required_argument, 0, 'C' }, - {"compression", required_argument, 0, 'c' }, - {"copy-offset", required_argument, 0, 'D' }, - {"empty-fits", required_argument, 0, 'x' }, - {"entry-point", required_argument, 0, 'e' }, - {"file", required_argument, 0, 'f' }, - {"fill-downward", no_argument, 0, 'd' }, - {"fill-upward", no_argument, 0, 'u' }, - {"flashmap", required_argument, 0, 'M' }, - {"fmap-regions", required_argument, 0, 'r' }, - {"header-offset", required_argument, 0, 'H' }, - {"help", no_argument, 0, 'h' }, - {"ignore-sec", required_argument, 0, 'S' }, - {"initrd", required_argument, 0, 'I' }, - {"int", required_argument, 0, 'i' }, - {"load-address", required_argument, 0, 'l' }, - {"machine", required_argument, 0, 'm' }, - {"name", required_argument, 0, 'n' }, - {"offset", required_argument, 0, 'o' }, - {"page-size", required_argument, 0, 'P' }, - {"size", required_argument, 0, 's' }, - {"top-aligned", required_argument, 0, 'T' }, - {"type", required_argument, 0, 't' }, - {"verbose", no_argument, 0, 'v' }, - {"with-readonly", no_argument, 0, 'w' }, - {NULL, 0, 0, 0 } + {"alignment", required_argument, 0, 'a' }, + {"base-address", required_argument, 0, 'b' }, + {"bootblock", required_argument, 0, 'B' }, + {"cmdline", required_argument, 0, 'C' }, + {"compression", required_argument, 0, 'c' }, + {"copy-offset", required_argument, 0, 'D' }, + {"empty-fits", required_argument, 0, 'x' }, + {"entry-point", required_argument, 0, 'e' }, + {"file", required_argument, 0, 'f' }, + {"fill-downward", no_argument, 0, 'd' }, + {"fill-upward", no_argument, 0, 'u' }, + {"flashmap", required_argument, 0, 'M' }, + {"fmap-regions", required_argument, 0, 'r' }, + {"hash-algorithm", required_argument, 0, 'A' }, + {"header-offset", required_argument, 0, 'H' }, + {"help", no_argument, 0, 'h' }, + {"ignore-sec", required_argument, 0, 'S' }, + {"initrd", required_argument, 0, 'I' }, + {"int", required_argument, 0, 'i' }, + {"load-address", required_argument, 0, 'l' }, + {"machine", required_argument, 0, 'm' }, + {"name", required_argument, 0, 'n' }, + {"offset", required_argument, 0, 'o' }, + {"page-size", required_argument, 0, 'P' }, + {"size", required_argument, 0, 's' }, + {"top-aligned", required_argument, 0, 'T' }, + {"type", required_argument, 0, 't' }, + {"verbose", no_argument, 0, 'v' }, + {"with-readonly", no_argument, 0, 'w' }, + {NULL, 0, 0, 0 } }; static int dispatch_command(struct command command) @@ -850,19 +853,19 @@ static void usage(char *name) " -v Provide verbose output\n" " -h Display this help message\n\n" "COMMANDs:\n" - " add [-r image,regions] -f FILE -n NAME -t TYPE \\\n" + " add [-r image,regions] -f FILE -n NAME -t TYPE [-A hash] \\\n" " [-b base-address] " "Add a component\n" - " add-payload [-r image,regions] -f FILE -n NAME \\\n" + " add-payload [-r image,regions] -f FILE -n NAME [-A hash] \\\n" " [-c compression] [-b base-address] " "Add a payload to the ROM\n" " (linux specific: [-C cmdline] [-I initrd])\n" - " add-stage [-r image,regions] -f FILE -n NAME \\\n" + " add-stage [-r image,regions] -f FILE -n NAME [-A hash] \\\n" " [-c compression] [-b base] [-S section-to-ignore] " "Add a stage to the ROM\n" " add-flat-binary [-r image,regions] -f FILE -n NAME \\\n" - " -l load-address -e entry-point [-c compression] \\\n" - " [-b base] " + " -l load-address -e entry-point [-A hash] \\\n" + " [-c compression] [-b base] " "Add a 32bit flat mode binary\n" " add-int [-r image,regions] -i INTEGER -n NAME [-b base] " "Add a raw 64-bit integer value\n" @@ -877,8 +880,8 @@ static void usage(char *name) "Create a legacy ROM file with CBFS master header*\n" " create -M flashmap [-r list,of,regions,containing,cbfses] " "Create a new-style partitioned firmware image\n" - " locate [-r image,regions] -f FILE -n NAME [-P page-size] \\\n" - " [-a align] [-T] " + " locate [-r image,regions] -f FILE -n NAME [-A hash] \\\n" + " [-P page-size] [-a align] [-T] " "Find a place for a file of that size\n" " layout [-w] " "List mutable (or, with -w, readable) image regions\n" @@ -974,15 +977,24 @@ int main(int argc, char **argv) WARN("Unknown type '%s' ignored\n", optarg); break; - case 'c': - if (!strncasecmp(optarg, "lzma", 5)) - param.algo = CBFS_COMPRESS_LZMA; - else if (!strncasecmp(optarg, "none", 5)) - param.algo = CBFS_COMPRESS_NONE; + case 'c': { + int algo = cbfs_parse_comp_algo(optarg); + if (algo >= 0) + param.compression = algo; else - WARN("Unknown compression '%s'" - " ignored.\n", optarg); + WARN("Unknown compression '%s' ignored.\n", + optarg); break; + } + case 'A': { + int algo = cbfs_parse_hash_algo(optarg); + if (algo >= 0) + param.hash = algo; + else + WARN("Unknown hashing scheme '%s' ignored.\n", + optarg); + break; + } case 'M': param.fmap = optarg; break; diff --git a/util/cbfstool/common.c b/util/cbfstool/common.c index 8773fe4..364ec02 100644 --- a/util/cbfstool/common.c +++ b/util/cbfstool/common.c @@ -19,6 +19,7 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA */ +#include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -26,6 +27,7 @@ #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> +#include <vb2_api.h> #include <libgen.h> #include "common.h" #include "cbfs.h" @@ -128,11 +130,23 @@ void buffer_delete(struct buffer *buffer) void cbfs_file_get_header(struct buffer *buf, struct cbfs_file *file) { + // Fields that were present from the "zeroth" revision bgets(buf, &file->magic, sizeof(file->magic)); file->len = xdr_be.get32(buf); file->type = xdr_be.get32(buf); - file->checksum = xdr_be.get32(buf); + file->version = xdr_be.get16(buf); + file->flags = xdr_be.get16(buf); file->offset = xdr_be.get32(buf); + + // Fields that were added in subsequent header versions + file->header_len = CBFS_FILE_V0_LEN; + file->hash_type = VB2_HASH_INVALID; + file->hash_offset = 0; + if (file->version >= 1) { + file->header_len = xdr_be.get32(buf); + file->hash_type = xdr_be.get16(buf); + file->hash_offset = xdr_be.get16(buf); + } } static struct { @@ -149,7 +163,7 @@ static struct { uint32_t string_to_arch(const char *arch_string) { - int i; + unsigned i; uint32_t ret = CBFS_ARCHITECTURE_UNKNOWN; for (i = 0; i < ARRAY_SIZE(arch_names); i++) { @@ -164,7 +178,7 @@ uint32_t string_to_arch(const char *arch_string) const char *arch_to_string(uint32_t a) { - int i; + unsigned i; const char *ret = NULL; for (i = 0; i < ARRAY_SIZE(arch_names); i++) { diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index ddec1a7..e86e9e2 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -28,13 +28,6 @@ /* Endianess */ #include "swab.h" -#ifndef __APPLE__ -#define ntohl(x) (is_big_endian() ? (uint32_t)(x) : swab32(x)) -#define htonl(x) (is_big_endian() ? (uint32_t)(x) : swab32(x)) -#endif -#define ntohll(x) (is_big_endian() ? (uint64_t)(x) : swab64(x)) -#define htonll(x) (is_big_endian() ? (uint64_t)(x) : swab64(x)) -int is_big_endian(void); /* Message output */ extern int verbose; @@ -45,7 +38,9 @@ extern int verbose; #define DEBUG(...) { if (verbose > 1) fprintf(stderr, "DEBUG: " __VA_ARGS__); } /* Helpers */ +#ifndef ARRAY_SIZE #define ARRAY_SIZE(a) (int)(sizeof(a) / sizeof((a)[0])) +#endif #define ALIGN(val, by) (((val) + (by)-1)&~((by)-1)) #define MAX(x, y) ((x) > (y) ? (x) : (y)) #define MIN(x, y) ((x) < (y) ? (x) : (y)) @@ -157,6 +152,8 @@ typedef int (*comp_func_ptr) (char *, int, char *, int *); enum comp_algo { CBFS_COMPRESS_NONE = 0, CBFS_COMPRESS_LZMA = 1 }; comp_func_ptr compression_function(enum comp_algo algo); +typedef uint8_t *(*hash_func_ptr)(const uint8_t *, uint64_t, uint8_t *); + uint64_t intfiletype(const char *name); diff --git a/util/cbfstool/swab.h b/util/cbfstool/swab.h index c5e4370..cf594d0 100644 --- a/util/cbfstool/swab.h +++ b/util/cbfstool/swab.h @@ -15,6 +15,15 @@ * */ +#ifndef __APPLE__ +#define ntohs(x) (is_big_endian() ? (uint16_t)(x) : swab16(x)) +#define htons(x) (is_big_endian() ? (uint16_t)(x) : swab16(x)) +#define ntohl(x) (is_big_endian() ? (uint32_t)(x) : swab32(x)) +#define htonl(x) (is_big_endian() ? (uint32_t)(x) : swab32(x)) +#endif +#define ntohll(x) (is_big_endian() ? (uint64_t)(x) : swab64(x)) +#define htonll(x) (is_big_endian() ? (uint64_t)(x) : swab64(x)) + /* casts are necessary for constants, because we never know how for sure * how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way. */ @@ -41,4 +50,7 @@ (((uint64_t)(x) & (uint64_t)0x00ff000000000000ULL) >> 40) | \ (((uint64_t)(x) & (uint64_t)0xff00000000000000ULL) >> 56) )) +/* common.c */ +int is_big_endian(void); + #endif /* _SWAB_H */

1 0

Patch merged into coreboot/master: 023e829 fmaptool: Add listing of annotated CBFS sections and generate header
by gerrit＠coreboot.org 08 May '15

08 May '15

the following patch was just integrated into master: commit 023e8294236d3bd7e39b7af0a4929137c30f089d Author: Sol Boucher <solb(a)chromium.org> Date: Wed Mar 18 10:13:48 2015 -0700 fmaptool: Add listing of annotated CBFS sections and generate header The fmd compiler now processes "(CBFS)" annotations, distilling them into a comma-separated list of the names of sections containing CBFSes. This list is the only thing printed to standard output to enable easy capture and machine consumption by other tools. Additionally, the ability to generate a tiny header with a define for the primary CBFS's size is implemented and can be requested via a new command-line switch. Here's an example of how to use the new features: $ ./fmaptool -h layout.h layout_arm_8192.fmd layout.fmap 2>/dev/null FW_MAIN_A,FW_MAIN_B,COREBOOT The hypothetical fmd file contains three sections annotated as (CBFS), the names of which are printed to standard output. As before, a binary FMAP file named layout.fmap is created; however, because the command was invoked with -h, a header #define ing the offset of its FMAP section (i.e. where it will be relative to the base of flash once the boot image is assembled) is also generated. BUG=chromium:470407 TEST=Verify that fmd files without a "COREBOOT" section or with one that isn't annotated as "(CBFS)" are not accepted. Ensure that the list of CBFS sections matches the descriptor file's annotations and is led by the "COREBOOT" section. Invoke with the header generation switch and check that output file for reasonableness. BRANCH=None Change-Id: I496dd937f69467bfd9233c28df59c7608e89538f Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Commit-Id: 9227698adecf675770b2983380eb570676c2b5d2 Original-Change-Id: I8b32f6ef19cabe2f6760106e676683c4565bbaad Original-Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Reviewed-on: https://chromium-review.googlesource.com/262956 Original-Reviewed-by: Duncan Laurie <dlaurie(a)chromium.org> Original-Reviewed-by: Julius Werner <jwerner(a)chromium.org> Reviewed-on: http://review.coreboot.org/9967 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi(a)google.com> See http://review.coreboot.org/9967 for details. -gerrit

1 0

Patch merged into coreboot/master: b974081 fmaptool: Conform to cbfstool's error message format
by gerrit＠coreboot.org 08 May '15

08 May '15

the following patch was just integrated into master: commit b974081c13ad203a78fcdb28021706f55eaa5010 Author: Sol Boucher <solb(a)chromium.org> Date: Wed Mar 18 10:13:48 2015 -0700 fmaptool: Conform to cbfstool's error message format The tool now makes use of the ERROR() macros from common.h. Change-Id: Ie38f40c65f7b6d3bc2adb97e246224cd38d4cb99 Signed-off-by: Sol Boucher <solb(a)chromium.org> Reviewed-on: http://review.coreboot.org/10048 Tested-by: build bot (Jenkins) Reviewed-by: Paul Menzel <paulepanter(a)users.sourceforge.net> Reviewed-by: Patrick Georgi <pgeorgi(a)google.com> See http://review.coreboot.org/10048 for details. -gerrit

1 0

New patch to review for coreboot: b7b6d12 cbfstool: Don't typedef the comp_algo enum
by Sol Boucher 08 May '15

08 May '15

Sol Boucher (solb(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/10146 -gerrit commit b7b6d1269b37076d2f687eba23c9c2531eb38354 Author: Sol Boucher <solb(a)chromium.org> Date: Thu May 7 21:12:28 2015 -0700 cbfstool: Don't typedef the comp_algo enum Our style discourages unnecessary typedefs, and this one doesn't gain us anything, nor is it consistent with the surrounding code: there's a function pointer typedef'd nearby, but non-opaque structs aren't. BUG=chromium:482652 TEST=None BRANCH=None Change-Id: Ie7565240639e5b1aeebb08ea005099aaa3557a27 Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Change-Id: I4285e6b56f99b85b9684f2b98b35e9b35a6c4cb7 Original-Signed-off-by: Sol Boucher <solb(a)chromium.org> --- util/cbfstool/cbfs-mkpayload.c | 8 ++++---- util/cbfstool/cbfs-mkstage.c | 2 +- util/cbfstool/cbfs-payload-linux.c | 6 +++--- util/cbfstool/cbfstool.c | 2 +- util/cbfstool/common.h | 16 ++++++++-------- util/cbfstool/compress.c | 2 +- 6 files changed, 18 insertions(+), 18 deletions(-) diff --git a/util/cbfstool/cbfs-mkpayload.c b/util/cbfstool/cbfs-mkpayload.c index 6eebbef..5bebf51 100644 --- a/util/cbfstool/cbfs-mkpayload.c +++ b/util/cbfstool/cbfs-mkpayload.c @@ -68,7 +68,7 @@ void xdr_get_seg(struct cbfs_payload_segment *out, } int parse_elf_to_payload(const struct buffer *input, struct buffer *output, - comp_algo algo) + enum comp_algo algo) { Elf64_Phdr *phdr; Elf64_Ehdr ehdr; @@ -249,7 +249,7 @@ int parse_flat_binary_to_payload(const struct buffer *input, struct buffer *output, uint32_t loadaddress, uint32_t entrypoint, - comp_algo algo) + enum comp_algo algo) { comp_func_ptr compress; struct cbfs_payload_segment segs[2]; @@ -293,8 +293,8 @@ int parse_flat_binary_to_payload(const struct buffer *input, return 0; } -int parse_fv_to_payload(const struct buffer *input, - struct buffer *output, comp_algo algo) +int parse_fv_to_payload(const struct buffer *input, struct buffer *output, + enum comp_algo algo) { comp_func_ptr compress; struct cbfs_payload_segment segs[2]; diff --git a/util/cbfstool/cbfs-mkstage.c b/util/cbfstool/cbfs-mkstage.c index f8a39bc..d8ca7ac 100644 --- a/util/cbfstool/cbfs-mkstage.c +++ b/util/cbfstool/cbfs-mkstage.c @@ -95,7 +95,7 @@ static Elf64_Shdr *find_ignored_section_header(struct parsed_elf *pelf, * works for all elf files, not just the restricted set. */ int parse_elf_to_stage(const struct buffer *input, struct buffer *output, - comp_algo algo, uint32_t *location, + enum comp_algo algo, uint32_t *location, const char *ignore_section) { struct parsed_elf pelf; diff --git a/util/cbfstool/cbfs-payload-linux.c b/util/cbfstool/cbfs-payload-linux.c index 9e9a874..0a230b2 100644 --- a/util/cbfstool/cbfs-payload-linux.c +++ b/util/cbfstool/cbfs-payload-linux.c @@ -51,14 +51,14 @@ struct bzpayload { struct buffer cmdline; struct buffer initrd; /* Output variables. */ - comp_algo algo; + enum comp_algo algo; comp_func_ptr compress; struct buffer output; size_t offset; struct cbfs_payload_segment *out_seg; }; -static int bzp_init(struct bzpayload *bzp, comp_algo algo) +static int bzp_init(struct bzpayload *bzp, enum comp_algo algo) { memset(bzp, 0, sizeof(*bzp)); @@ -203,7 +203,7 @@ static void bzp_output_segment(struct bzpayload *bzp, struct buffer *b, */ int parse_bzImage_to_payload(const struct buffer *input, struct buffer *output, const char *initrd_name, - char *cmdline, comp_algo algo) + char *cmdline, enum comp_algo algo) { struct bzpayload bzp; unsigned int initrd_base = 64*1024*1024; diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 4cf343f..11353b6 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -75,7 +75,7 @@ static struct param { bool fill_partial_downward; bool show_immutable; int fit_empty_entries; - comp_algo algo; + enum comp_algo algo; /* for linux payloads */ char *initrd; char *cmdline; diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index 392ec80..ddec1a7 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -154,28 +154,28 @@ const char *arch_to_string(uint32_t a); uint32_t string_to_arch(const char *arch_string); typedef int (*comp_func_ptr) (char *, int, char *, int *); -typedef enum { CBFS_COMPRESS_NONE = 0, CBFS_COMPRESS_LZMA = 1 } comp_algo; +enum comp_algo { CBFS_COMPRESS_NONE = 0, CBFS_COMPRESS_LZMA = 1 }; -comp_func_ptr compression_function(comp_algo algo); +comp_func_ptr compression_function(enum comp_algo algo); uint64_t intfiletype(const char *name); /* cbfs-mkpayload.c */ int parse_elf_to_payload(const struct buffer *input, struct buffer *output, - comp_algo algo); -int parse_fv_to_payload(const struct buffer *input, - struct buffer *output, comp_algo algo); + enum comp_algo algo); +int parse_fv_to_payload(const struct buffer *input, struct buffer *output, + enum comp_algo algo); int parse_bzImage_to_payload(const struct buffer *input, struct buffer *output, const char *initrd, - char *cmdline, comp_algo algo); + char *cmdline, enum comp_algo algo); int parse_flat_binary_to_payload(const struct buffer *input, struct buffer *output, uint32_t loadaddress, uint32_t entrypoint, - comp_algo algo); + enum comp_algo algo); /* cbfs-mkstage.c */ int parse_elf_to_stage(const struct buffer *input, struct buffer *output, - comp_algo algo, uint32_t *location, + enum comp_algo algo, uint32_t *location, const char *ignore_section); void print_supported_filetypes(void); diff --git a/util/cbfstool/compress.c b/util/cbfstool/compress.c index 5b916ce..9f865fb 100644 --- a/util/cbfstool/compress.c +++ b/util/cbfstool/compress.c @@ -38,7 +38,7 @@ static int none_compress(char *in, int in_len, char *out, int *out_len) return 0; } -comp_func_ptr compression_function(comp_algo algo) +comp_func_ptr compression_function(enum comp_algo algo) { comp_func_ptr compress; switch (algo) {

1 0

Patch set updated for coreboot: b2b9d98 cbfstool: Make update-fit action work on new-style images
by Sol Boucher 08 May '15

08 May '15

Sol Boucher (solb(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/10137 -gerrit commit b2b9d9828104b186d5258f390c8c77700c96e3f1 Author: Sol Boucher <solb(a)chromium.org> Date: Wed May 6 14:44:40 2015 -0700 cbfstool: Make update-fit action work on new-style images Because new images place the bootblock in a separate region from the primary CBFS, performing an update-fit operation requires reading an additional section and choosing a different destination for the write based on the image type. Since other actions are not affected by these requirements, the logic for the optional read and all writing is implemented in the cbfs_update_fit() function itself, rather than relying on the main() function for writing as the other actions do. Change-Id: I2024c59715120ecc3b9b158e007ebce75acff023 Signed-off-by: Sol Boucher <solb(a)chromium.org> --- util/cbfstool/cbfstool.c | 23 +++++++++++++++++++-- util/cbfstool/fit.c | 54 ++++++++++++++++++++++++++---------------------- util/cbfstool/fit.h | 17 +++++++++++++-- 3 files changed, 65 insertions(+), 29 deletions(-) diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 36e27c6..4cf343f 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -33,6 +33,8 @@ #include "fit.h" #include "partitioned_file.h" +#define SECTION_WITH_FIT_TABLE "BOOTBLOCK" + struct command { const char *name; const char *optstring; @@ -677,12 +679,29 @@ static int cbfs_update_fit(void) return 1; } + // Decide which region to read/write the FIT table from/to. + struct buffer bootblock; + if (partitioned_file_is_partitioned(param.image_file)) { + if (!partitioned_file_read_region(&bootblock, param.image_file, + SECTION_WITH_FIT_TABLE)) + return 1; + } else { + // In legacy images, the bootblock is part of the CBFS. + buffer_clone(&bootblock, param.image_region); + } + struct cbfs_image image; if (cbfs_image_from_buffer(&image, param.image_region, param.headeroffset)) return 1; - return fit_update_table(&image, param.fit_empty_entries, param.name); + if (fit_update_table(&bootblock, &image, param.name, + param.fit_empty_entries, convert_to_from_top_aligned)) + return 1; + + // The region to be written depends on the type of image, so we write it + // here rather than having main() write the CBFS region back as usual. + return !partitioned_file_write_region(param.image_file, &bootblock); } static int cbfs_copy(void) @@ -731,7 +750,7 @@ static const struct command commands[] = { {"print", "H:r:vh?", cbfs_print, true, false}, {"read", "r:f:vh?", cbfs_read, true, false}, {"remove", "H:r:n:vh?", cbfs_remove, true, true}, - {"update-fit", "H:r:n:x:vh?", cbfs_update_fit, true, true}, + {"update-fit", "H:r:n:x:vh?", cbfs_update_fit, true, false}, {"write", "r:f:udvh?", cbfs_write, true, true}, }; diff --git a/util/cbfstool/fit.c b/util/cbfstool/fit.c index 7dbfc51..97341b5 100644 --- a/util/cbfstool/fit.c +++ b/util/cbfstool/fit.c @@ -18,13 +18,10 @@ */ #include <stdint.h> +#include <stdio.h> #include <stdlib.h> #include <string.h> -#include <stdio.h> -#include "common.h" -#include "cbfs.h" -#include "cbfs_image.h" #include "fit.h" /* FIXME: This code assumes it is being executed on a little endian machine. */ @@ -69,9 +66,9 @@ struct microcode_entry { int size; }; -static inline void *rom_buffer_pointer(struct cbfs_image *image, int offset) +static inline void *rom_buffer_pointer(struct buffer *buffer, int offset) { - return &image->buffer.data[offset]; + return &buffer->data[offset]; } static inline int fit_entry_size_bytes(struct fit_entry *entry) @@ -104,9 +101,10 @@ static inline int fit_entry_type(struct fit_entry *entry) * in the host address space at [4G - romsize -> 4G). It also assume all * pointers have values within this address range. */ -static inline int ptr_to_offset(uint32_t theromsize, uint32_t host_ptr) +static inline int ptr_to_offset(fit_offset_converter_t helper, + const struct buffer *region, uint32_t host_ptr) { - return (int)(theromsize + host_ptr); + return helper(region, -host_ptr); } /* @@ -114,25 +112,28 @@ static inline int ptr_to_offset(uint32_t theromsize, uint32_t host_ptr) * in the host address space at [4G - romsize -> 4G). It also assume all * pointers have values within this address range. */ -static inline uint32_t offset_to_ptr(uint32_t theromsize, int offset) +static inline uint32_t offset_to_ptr(fit_offset_converter_t helper, + const struct buffer *region, int offset) { - return -(theromsize - (uint32_t )offset); + return -helper(region, offset); } -static struct fit_table *locate_fit_table(struct cbfs_image *image) +static struct fit_table *locate_fit_table(fit_offset_converter_t offset_helper, + struct buffer *buffer) { struct fit_table *table; uint32_t *fit_pointer; - fit_pointer = rom_buffer_pointer(image, - ptr_to_offset(image->buffer.size, FIT_POINTER_LOCATION)); + fit_pointer = rom_buffer_pointer(buffer, + ptr_to_offset(offset_helper, buffer, + FIT_POINTER_LOCATION)); /* Ensure pointer is below 4GiB and within 16MiB of 4GiB */ if (fit_pointer[1] != 0 || fit_pointer[0] < FIT_TABLE_LOWEST_ADDRESS) return NULL; - table = rom_buffer_pointer(image, - ptr_to_offset(image->buffer.size, *fit_pointer)); + table = rom_buffer_pointer(buffer, + ptr_to_offset(offset_helper, buffer, *fit_pointer)); /* Check that the address field has the proper signature. */ if (strncmp((const char *)&table->header.address, FIT_HEADER_ADDRESS, @@ -168,9 +169,10 @@ static void update_fit_checksum(struct fit_table *fit) fit->header.checksum = -result; } -static void add_microcodde_entries(struct cbfs_image *image, - struct fit_table *fit, - struct microcode_entry *mcus, int num_mcus) +static void add_microcodde_entries(struct fit_table *fit, + const struct cbfs_image *image, + int num_mcus, struct microcode_entry *mcus, + fit_offset_converter_t offset_helper) { int i; @@ -178,7 +180,8 @@ static void add_microcodde_entries(struct cbfs_image *image, struct fit_entry *entry = &fit->entries[i]; struct microcode_entry *mcu = &mcus[i]; - entry->address = offset_to_ptr(image->buffer.size, mcu->offset); + entry->address = offset_to_ptr(offset_helper, &image->buffer, + mcu->offset); fit_entry_update_size(entry, mcu->size); entry->version = FIT_MICROCODE_VERSION; entry->type_checksum_valid = FIT_TYPE_MICROCODE; @@ -213,9 +216,9 @@ static int parse_microcode_blob(struct cbfs_image *image, num_mcus = 0; while (file_length > sizeof(struct microcode_header)) { - struct microcode_header *mcu_header; + const struct microcode_header *mcu_header; - mcu_header = rom_buffer_pointer(image, current_offset); + mcu_header = rom_buffer_pointer(&image->buffer, current_offset); /* Quickly sanity check a prospective microcode update. */ if (mcu_header->total_size < sizeof(*mcu_header)) @@ -243,8 +246,9 @@ static int parse_microcode_blob(struct cbfs_image *image, return 0; } -int fit_update_table(struct cbfs_image *image, int empty_entries, - const char *microcode_blob_name) +int fit_update_table(struct buffer *bootblock, struct cbfs_image *image, + const char *microcode_blob_name, int empty_entries, + fit_offset_converter_t offset_fn) { struct fit_table *fit; struct cbfs_file *mcode_file; @@ -252,7 +256,7 @@ int fit_update_table(struct cbfs_image *image, int empty_entries, int ret = 0; // struct rom_image image = { .rom = rom, .size = romsize, }; - fit = locate_fit_table(image); + fit = locate_fit_table(offset_fn, bootblock); if (!fit) { ERROR("FIT not found.\n"); @@ -279,7 +283,7 @@ int fit_update_table(struct cbfs_image *image, int empty_entries, goto out; } - add_microcodde_entries(image, fit, mcus, empty_entries); + add_microcodde_entries(fit, image, empty_entries, mcus, offset_fn); update_fit_checksum(fit); out: diff --git a/util/cbfstool/fit.h b/util/cbfstool/fit.h index 63e22f4..4dd0dc7 100644 --- a/util/cbfstool/fit.h +++ b/util/cbfstool/fit.h @@ -20,6 +20,19 @@ #ifndef __CBFSTOOL_FIT_H #define __CBFSTOOL_FIT_H -int fit_update_table(struct cbfs_image *image, - int empty_entries, const char *microcode_blob_name); +#include "cbfs_image.h" +#include "common.h" + +/* + * Converts between offsets from the start of the specified image region and + * "top-aligned" offsets from the top of the entire flash image. Should work in + * both directions: accepts either type of offset and produces the other type. + * The implementation must have some notion of the flash image's total size. + */ +typedef unsigned (*fit_offset_converter_t)(const struct buffer *region, + unsigned offset); + +int fit_update_table(struct buffer *bootblock, struct cbfs_image *image, + const char *microcode_blob_name, int empty_entries, + fit_offset_converter_t offset_fn); #endif

1 0

Patch set updated for coreboot: 88470ed cbfstool: Support top-aligned addresses for new-format images
by Sol Boucher 08 May '15

08 May '15

Sol Boucher (solb(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/10136 -gerrit commit 88470ed6bedd167f339d5bfbc88114f2f8ed5517 Author: Sol Boucher <solb(a)chromium.org> Date: Thu May 7 02:39:22 2015 -0700 cbfstool: Support top-aligned addresses for new-format images The cbfstool handling of new-style FMAP-driven "partitioned" images originally disallowed the use of x86-style top-aligned addresses with the add.* and layout actions because it wasn't obvious how they should work, especially since the normal addressing is done relative to each individual region for these types of images. Not surprisingly, however, the x86 portions of the build system make copious use of top-aligned addresses, so this allows their use with new images and specifies their behavior as being relative to the *image* end---not the region end---just as it is for legacy images. Change-Id: Icecc843f4f8b6bb52aa0ea16df771faa278228d2 Signed-off-by: Sol Boucher <solb(a)chromium.org> --- util/cbfstool/cbfs_image.c | 19 ++++++------------ util/cbfstool/cbfs_image.h | 4 +--- util/cbfstool/cbfstool.c | 43 ++++++++++++++++++++++++++++++---------- util/cbfstool/common.h | 2 ++ util/cbfstool/partitioned_file.c | 7 +++++++ util/cbfstool/partitioned_file.h | 3 +++ 6 files changed, 52 insertions(+), 26 deletions(-) diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index 4ecb461..8fb2a60 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -526,6 +526,12 @@ static int cbfs_add_entry_at(struct cbfs_image *image, int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, const char *name, uint32_t type, uint32_t content_offset) { + assert(image); + assert(buffer); + assert(buffer->data); + assert(name); + assert(!IS_TOP_ALIGNED_ADDRESS(content_offset)); + uint32_t entry_type; uint32_t addr, addr_next; struct cbfs_file *entry, *next; @@ -537,19 +543,6 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, DEBUG("cbfs_add_entry('%s'@0x%x) => need_size = %u+%zu=%u\n", name, content_offset, header_size, buffer->size, need_size); - if (IS_TOP_ALIGNED_ADDRESS(content_offset)) { - if (!cbfs_is_legacy_cbfs(image)) { - ERROR("Top-aligned offsets are only supported for legacy CBFSes (with master headers)\n"); - return -1; - } - - // legacy cbfstool takes top-aligned address. - uint32_t theromsize = image->header.romsize; - INFO("Converting top-aligned address 0x%x to offset: 0x%x\n", - content_offset, content_offset + theromsize); - content_offset = theromsize + (int32_t)content_offset; - } - // Merge empty entries. DEBUG("(trying to merge empty entries...)\n"); cbfs_walk(image, cbfs_merge_empty_entry, NULL); diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index 024edc5..5ff8a9a 100644 --- a/util/cbfstool/cbfs_image.h +++ b/util/cbfstool/cbfs_image.h @@ -22,8 +22,6 @@ #include "common.h" #include "cbfs.h" -#define IS_TOP_ALIGNED_ADDRESS(x) ((uint32_t)(x) > 0x80000000) - /* CBFS image processing */ struct cbfs_image { @@ -88,7 +86,7 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, /* Adds an entry to CBFS image by given name and type. If content_offset is * non-zero, try to align "content" (CBFS_SUBHEADER(p)) at content_offset. - * Note that top-aligned addresses are only supported for legacy CBFSes. + * Never pass this function a top-aligned address: convert it to an offset. * Returns 0 on success, otherwise non-zero. */ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, const char *name, uint32_t type, uint32_t content_offset); diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index cb2f01a..36e27c6 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -98,6 +98,21 @@ static bool region_is_modern_cbfs(const char *region) CBFS_FILE_MAGIC, strlen(CBFS_FILE_MAGIC)); } +/* + * Converts between offsets from the start of the specified image region and + * "top-aligned" offsets from the top of the entire flash image. Works in either + * direction: pass in one type of offset and receive the other type. + * N.B. A top-aligned offset is always a positive number, and should not be + * confused with a top-aliged *address*, which is its arithmetic inverse. */ +static unsigned convert_to_from_top_aligned(const struct buffer *region, + unsigned offset) +{ + assert(region); + + size_t image_size = partitioned_file_total_size(param.image_file); + return image_size - region->offset - offset; +} + typedef int (*convert_buffer_t)(struct buffer *buffer, uint32_t *offset); static int cbfs_add_integer_component(const char *name, @@ -129,6 +144,10 @@ static int cbfs_add_integer_component(const char *name, goto done; } + if (IS_TOP_ALIGNED_ADDRESS(offset)) + offset = convert_to_from_top_aligned(param.image_region, + -offset); + if (cbfs_add_entry(&image, &buffer, name, CBFS_COMPONENT_RAW, offset) != 0) { ERROR("Failed to add %llu into ROM image as '%s'.\n", @@ -187,6 +206,10 @@ static int cbfs_add_component(const char *filename, return 1; } + if (IS_TOP_ALIGNED_ADDRESS(offset)) + offset = convert_to_from_top_aligned(param.image_region, + -offset); + if (cbfs_add_entry(&image, &buffer, name, type, offset) != 0) { ERROR("Failed to add '%s' into ROM image.\n", filename); buffer_delete(&buffer); @@ -439,11 +462,6 @@ static int cbfs_locate(void) param.headeroffset)) return 1; - if (!cbfs_is_legacy_cbfs(&image) && param.top_aligned) { - ERROR("The -T switch is only valid on legacy images having CBFS master headers\n"); - return 1; - } - if (cbfs_get_entry(&image, param.name)) WARN("'%s' already in CBFS.\n", param.name); @@ -464,7 +482,8 @@ static int cbfs_locate(void) } if (param.top_aligned) - address = address - image.header.romsize; + address = -convert_to_from_top_aligned(param.image_region, + address); printf("0x%x\n", address); return 0; @@ -806,7 +825,7 @@ static void usage(char *name) "USAGE:\n" " %s [-h]\n" " %s FILE COMMAND [-v] [PARAMETERS]...\n\n" "OPTIONs:\n" " -H header_offset Do not search for header; use this offset*\n" - " -T Output top-aligned memory address*\n" + " -T Output top-aligned memory address\n" " -u Accept short data; fill upward/from bottom\n" " -d Accept short data; fill downward/from top\n" " -v Provide verbose output\n" @@ -857,8 +876,8 @@ static void usage(char *name) "Updates the FIT table with microcode entries\n" "\n" "OFFSETs:\n" - " Numbers accompanying -b, -H, and -o switches may be provided\n" - " in two possible formats*: if their value is greater than\n" + " Numbers accompanying -b, -H, and -o switches* may be provided\n" + " in two possible formats: if their value is greater than\n" " 0x80000000, they are interpreted as a top-aligned x86 memory\n" " address; otherwise, they are treated as an offset into flash.\n" "ARCHes:\n" @@ -878,7 +897,11 @@ static void usage(char *name) " that, when working with such images, the -F and -r switches\n" " default to '%s' for convenience, and both the -b switch to\n" " CBFS operations and the output of the locate action become\n" - " relative to the selected CBFS region's lowest address.\n", + " relative to the selected CBFS region's lowest address.\n" + " The one exception to this rule is the top-aligned address,\n" + " which is always relative to the end of the entire image\n" + " rather than relative to the local region; this is true for\n" + " for both input (sufficiently large) and output (-T) data.\n", SECTION_NAME_FMAP, SECTION_NAME_PRIMARY_CBFS, SECTION_NAME_PRIMARY_CBFS ); diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index 831d3eb..392ec80 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -50,6 +50,8 @@ extern int verbose; #define MAX(x, y) ((x) > (y) ? (x) : (y)) #define MIN(x, y) ((x) < (y) ? (x) : (y)) +#define IS_TOP_ALIGNED_ADDRESS(x) ((uint32_t)(x) > 0x80000000) + #define unused __attribute__((unused)) static inline uint32_t align_up(uint32_t value, uint32_t align) diff --git a/util/cbfstool/partitioned_file.c b/util/cbfstool/partitioned_file.c index 6473963..0b25272 100644 --- a/util/cbfstool/partitioned_file.c +++ b/util/cbfstool/partitioned_file.c @@ -290,6 +290,13 @@ bool partitioned_file_is_partitioned(const partitioned_file_t *file) return partitioned_file_get_fmap(file) != NULL; } +size_t partitioned_file_total_size(const partitioned_file_t *file) +{ + assert(file); + + return file->buffer.size; +} + bool partitioned_file_region_check_magic(const partitioned_file_t *file, const char *region, const char *magic, size_t magic_len) { diff --git a/util/cbfstool/partitioned_file.h b/util/cbfstool/partitioned_file.h index 97d1b57..92f228e 100644 --- a/util/cbfstool/partitioned_file.h +++ b/util/cbfstool/partitioned_file.h @@ -133,6 +133,9 @@ void partitioned_file_close(partitioned_file_t *file); /** @return Whether the file is partitioned (i.e. not flat). */ bool partitioned_file_is_partitioned(const partitioned_file_t *file); +/** @return The image's overall filesize, regardless of whether it's flat. */ +size_t partitioned_file_total_size(const partitioned_file_t *file); + /** @return Whether the specified region begins with the magic bytes. */ bool partitioned_file_region_check_magic(const partitioned_file_t *file, const char *region, const char *magic, size_t magic_len);

1 0

Patch set updated for coreboot: 69ecdfc cbfstool: New image format w/ required FMAP and w/o CBFS master header
by Sol Boucher 08 May '15

08 May '15

Sol Boucher (solb(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/10135 -gerrit commit 69ecdfcfc41cf9afd9a03bf98a30135688255327 Author: Sol Boucher <solb(a)chromium.org> Date: Wed Mar 18 12:36:27 2015 -0700 cbfstool: New image format w/ required FMAP and w/o CBFS master header These new-style firmware images use the FMAP of the root of knowledge about their layout, which allows them to have sections containing raw data whose offset and size can easily be determined at runtime or when modifying or flashing the image. Furthermore, they can even have multiple CBFSes, each of which occupies a different FMAP region. It is assumed that the first entry of each CBFS, including the primary one, will be located right at the start of its region. This means that the bootblock needs to be moved into its own FMAP region, but makes the CBFS master header obsolete because, with the exception of the version and alignment, all its fields are redundant once its CBFS has an entry in the FMAP. The version code will be addressed in a future commit before the new format comes into use, while the alignment will just be defined to 64 bytes in both cbfstool and coreboot itself, since there's almost no reason to ever change it in practice. The version code field and all necessary coreboot changes will come separately. BUG=chromium:470407 TEST=Build panther and nyan_big coreboot.rom and image.bin images with and without this patch, diff their hexdumps, and note that no locations differ except for those that do between subsequent builds of the same codebase. Try working with new-style images: use fmaptool to produce an FMAP section from an fmd file having raw sections and multiple CBFSes, pass the resulting file to cbfstool create -M -F, then try printing its layout and CBFSes' contents, add and remove CBFS files, and read and write raw sections. BRANCH=None Change-Id: I7dd2578d2143d0cedd652fdba5b22221fcc2184a Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Commit-Id: 8a670322297f83135b929a5b20ff2bd0e7d2abd3 Original-Change-Id: Ib86fb50edc66632f4e6f717909bbe4efb6c874e5 Original-Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Reviewed-on: https://chromium-review.googlesource.com/265863 Original-Reviewed-by: Aaron Durbin <adurbin(a)chromium.org> --- util/cbfstool/cbfs.h | 3 + util/cbfstool/cbfs_image.c | 154 ++++++++++---- util/cbfstool/cbfs_image.h | 39 +++- util/cbfstool/cbfstool.c | 519 ++++++++++++++++++++++++++++++++++++--------- util/cbfstool/common.h | 2 + 5 files changed, 563 insertions(+), 154 deletions(-) diff --git a/util/cbfstool/cbfs.h b/util/cbfstool/cbfs.h index f26b14c..ef39594 100644 --- a/util/cbfstool/cbfs.h +++ b/util/cbfstool/cbfs.h @@ -32,6 +32,9 @@ #define makemagic(b3, b2, b1, b0)\ (((b3)<<24) | ((b2) << 16) | ((b1) << 8) | (b0)) +// Alignment (in bytes) to be used when no master header is present +#define CBFS_ENTRY_ALIGNMENT 64 + #define CBFS_HEADER_MAGIC 0x4F524243 #define CBFS_HEADPTR_ADDR_X86 0xFFFFFFFC #define CBFS_HEADER_VERSION1 0x31313131 diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index d07f806..4ecb461 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -109,8 +109,11 @@ static size_t cbfs_calculate_file_header_size(const char *name) align_up(strlen(name) + 1, CBFS_FILENAME_ALIGN)); } +/* Only call on legacy CBFSes possessing a master header. */ static int cbfs_fix_legacy_size(struct cbfs_image *image, char *hdr_loc) { + assert(image); + assert(cbfs_is_legacy_cbfs(image)); // A bug in old cbfstool may produce extra few bytes (by alignment) and // cause cbfstool to overwrite things after free space -- which is // usually CBFS header on x86. We need to workaround that. @@ -182,41 +185,78 @@ void cbfs_get_header(struct cbfs_header *header, void *src) header->architecture = xdr_be.get32(&outheader); } -int cbfs_image_create(struct cbfs_image *image, - uint32_t architecture, - uint32_t align, - struct buffer *bootblock, - uint32_t bootblock_offset, - uint32_t header_offset, - uint32_t entries_offset) +int cbfs_image_create(struct cbfs_image *image, size_t entries_size) { assert(image); assert(image->buffer.data); - assert(bootblock); - struct cbfs_file *entry; - int32_t *rel_offset; - uint32_t cbfs_len; - void *header_loc; - size_t empty_header_len; - size_t size = image->buffer.size; + size_t empty_header_len = cbfs_calculate_file_header_size(""); + uint32_t entries_offset = 0; + uint32_t align = CBFS_ENTRY_ALIGNMENT; + if (image->has_header) { + entries_offset = image->header.offset; - DEBUG("cbfs_image_create: bootblock=0x%x+0x%zx, " - "header=0x%x+0x%zx, entries_offset=0x%x\n", - bootblock_offset, bootblock->size, header_offset, - sizeof(image->header), entries_offset); + if (entries_offset > image->buffer.size) { + ERROR("CBFS file entries are located outside CBFS itself\n"); + return -1; + } + + align = image->header.align; + } // This attribute must be given in order to prove that this module // correctly preserves certain CBFS properties. See the block comment // near the top of this file (and the associated commit message). - empty_header_len = cbfs_calculate_file_header_size(""); if (align < empty_header_len) { ERROR("CBFS must be aligned to at least %zu bytes\n", empty_header_len); return -1; } - // Adjust legcay top-aligned address to ROM offset. + if (entries_size > image->buffer.size - entries_offset) { + ERROR("CBFS doesn't have enough space to fit its file entries\n"); + return -1; + } + + if (empty_header_len > entries_size) { + ERROR("CBFS is too small to fit any header\n"); + return -1; + } + struct cbfs_file *entry_header = + (struct cbfs_file *)(image->buffer.data + entries_offset); + // This alignment is necessary in order to prove that this module + // correctly preserves certain CBFS properties. See the block comment + // near the top of this file (and the associated commit message). + entries_size -= entries_size % align; + + size_t capacity = entries_size - empty_header_len; + LOG("Created CBFS (capacity = %zu bytes)\n", capacity); + return cbfs_create_empty_entry(entry_header, capacity, ""); +} + +int cbfs_legacy_image_create(struct cbfs_image *image, + uint32_t architecture, + uint32_t align, + struct buffer *bootblock, + uint32_t bootblock_offset, + uint32_t header_offset, + uint32_t entries_offset) +{ + assert(image); + assert(image->buffer.data); + assert(bootblock); + + int32_t *rel_offset; + uint32_t cbfs_len; + void *header_loc; + size_t size = image->buffer.size; + + DEBUG("cbfs_image_create: bootblock=0x%x+0x%zx, " + "header=0x%x+0x%zx, entries_offset=0x%x\n", + bootblock_offset, bootblock->size, header_offset, + sizeof(image->header), entries_offset); + + // Adjust legacy top-aligned address to ROM offset. if (IS_TOP_ALIGNED_ADDRESS(entries_offset)) entries_offset = size + (int32_t)entries_offset; if (IS_TOP_ALIGNED_ADDRESS(bootblock_offset)) @@ -259,6 +299,7 @@ int cbfs_image_create(struct cbfs_image *image, header_loc = (image->buffer.data + header_offset); cbfs_put_header(header_loc, &image->header); + image->has_header = true; // The last 4 byte of the image contain the relative offset from the end // of the image to the master header as a 32-bit signed integer. x86 @@ -274,12 +315,6 @@ int cbfs_image_create(struct cbfs_image *image, entries_offset, align); return -1; } - if (entries_offset + empty_header_len > size) { - ERROR("Offset (0x%x+0x%zx) exceed ROM size(0x%zx)\n", - entries_offset, empty_header_len, size); - return -1; - } - entry = (struct cbfs_file *)(image->buffer.data + entries_offset); // To calculate available length, find // e = min(bootblock, header, rel_offset) where e > entries_offset. cbfs_len = size - sizeof(int32_t); @@ -287,13 +322,9 @@ int cbfs_image_create(struct cbfs_image *image, cbfs_len = bootblock_offset; if (header_offset > entries_offset && header_offset < cbfs_len) cbfs_len = header_offset; - // This alignment is necessary in order to prove that this module - // correctly preserves certain CBFS properties. See the block comment - // near the top of this file (and the associated commit message). - cbfs_len -= cbfs_len % align; - cbfs_len -= entries_offset + empty_header_len; - cbfs_create_empty_entry(entry, cbfs_len, ""); - LOG("Created CBFS image (capacity = %d bytes)\n", cbfs_len); + + if (cbfs_image_create(image, cbfs_len - entries_offset)) + return -1; return 0; } @@ -305,17 +336,31 @@ int cbfs_image_from_buffer(struct cbfs_image *out, struct buffer *in, assert(in->data); buffer_clone(&out->buffer, in); + out->has_header = false; + void *header_loc = cbfs_find_header(in->data, in->size, offset); if (header_loc) { cbfs_get_header(&out->header, header_loc); + out->has_header = true; cbfs_fix_legacy_size(out, header_loc); + } else if (offset != ~0u) { + ERROR("The -H switch is only valid on legacy images having CBFS master headers.\n"); + return 1; + } else if (!cbfs_is_valid_cbfs(out)) { + ERROR("Selected image region is not a valid CBFS.\n"); + return 1; } - return !header_loc; + + return 0; } int cbfs_copy_instance(struct cbfs_image *image, size_t copy_offset, size_t copy_size) { + assert(image); + if (!cbfs_is_legacy_cbfs(image)) + return -1; + struct cbfs_file *src_entry, *dst_entry; struct cbfs_header *copy_header; size_t align, entry_offset; @@ -411,7 +456,8 @@ static int cbfs_add_entry_at(struct cbfs_image *image, uint32_t header_size = cbfs_calculate_file_header_size(name), min_entry_size = cbfs_calculate_file_header_size(""); uint32_t len, target; - uint32_t align = image->header.align; + uint32_t align = image->has_header ? image->header.align : + CBFS_ENTRY_ALIGNMENT; target = content_offset - header_size; if (target % align) @@ -492,6 +538,11 @@ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, name, content_offset, header_size, buffer->size, need_size); if (IS_TOP_ALIGNED_ADDRESS(content_offset)) { + if (!cbfs_is_legacy_cbfs(image)) { + ERROR("Top-aligned offsets are only supported for legacy CBFSes (with master headers)\n"); + return -1; + } + // legacy cbfstool takes top-aligned address. uint32_t theromsize = image->header.romsize; INFO("Converting top-aligned address 0x%x to offset: 0x%x\n", @@ -798,7 +849,8 @@ int cbfs_print_entry_info(struct cbfs_image *image, struct cbfs_file *entry, int cbfs_print_directory(struct cbfs_image *image) { - cbfs_print_header_info(image); + if (cbfs_is_legacy_cbfs(image)) + cbfs_print_header_info(image); printf("%-30s %-10s %-12s Size\n", "Name", "Offset", "Type"); cbfs_walk(image, cbfs_print_entry_info, NULL); return 0; @@ -923,15 +975,17 @@ struct cbfs_header *cbfs_find_header(char *data, size_t size, struct cbfs_file *cbfs_find_first_entry(struct cbfs_image *image) { assert(image); - return (struct cbfs_file *)(image->buffer.data + - image->header.offset); + return image->has_header ? (struct cbfs_file *)(image->buffer.data + + image->header.offset) : + (struct cbfs_file *)image->buffer.data; } struct cbfs_file *cbfs_find_next_entry(struct cbfs_image *image, struct cbfs_file *entry) { uint32_t addr = cbfs_get_entry_addr(image, entry); - int align = image->header.align; + int align = image->has_header ? image->header.align : + CBFS_ENTRY_ALIGNMENT; assert(entry && cbfs_is_valid_entry(image, entry)); addr += ntohl(entry->offset) + ntohl(entry->len); addr = align_up(addr, align); @@ -944,6 +998,17 @@ uint32_t cbfs_get_entry_addr(struct cbfs_image *image, struct cbfs_file *entry) return (int32_t)((char *)entry - image->buffer.data); } +int cbfs_is_valid_cbfs(struct cbfs_image *image) +{ + return buffer_check_magic(&image->buffer, CBFS_FILE_MAGIC, + strlen(CBFS_FILE_MAGIC)); +} + +int cbfs_is_legacy_cbfs(struct cbfs_image *image) +{ + return image->has_header; +} + int cbfs_is_valid_entry(struct cbfs_image *image, struct cbfs_file *entry) { uint32_t offset = cbfs_get_entry_addr(image, entry); @@ -955,7 +1020,7 @@ int cbfs_is_valid_entry(struct cbfs_image *image, struct cbfs_file *entry) buffer_clone(&entry_data, &image->buffer); buffer_seek(&entry_data, offset); return buffer_check_magic(&entry_data, CBFS_FILE_MAGIC, - strlen(CBFS_FILE_MAGIC)); + strlen(CBFS_FILE_MAGIC)); } int cbfs_create_empty_entry(struct cbfs_file *entry, @@ -999,7 +1064,8 @@ int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, /* Default values: allow fitting anywhere in ROM. */ if (!page_size) - page_size = image->header.romsize; + page_size = image->has_header ? image->header.romsize : + image->buffer.size; if (!align) align = 1; @@ -1007,9 +1073,11 @@ int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, ERROR("Input file size (%d) greater than page size (%d).\n", size, page_size); - if (page_size % image->header.align) + uint32_t image_align = image->has_header ? image->header.align : + CBFS_ENTRY_ALIGNMENT; + if (page_size % image_align) WARN("%s: Page size (%#x) not aligned with CBFS image (%#x).\n", - __func__, page_size, image->header.align); + __func__, page_size, image_align); /* TODO Old cbfstool always assume input is a stage file (and adding * sizeof(cbfs_stage) for header. We should fix that by adding "-t" diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index ddee3a7..024edc5 100644 --- a/util/cbfstool/cbfs_image.h +++ b/util/cbfstool/cbfs_image.h @@ -28,6 +28,9 @@ struct cbfs_image { struct buffer buffer; + /* An image has a header iff it's a legacy CBFS. */ + bool has_header; + /* Only meaningful if has_header is selected. */ struct cbfs_header header; }; @@ -37,18 +40,28 @@ void cbfs_put_header(void *dest, const struct cbfs_header *header); /* Or deserialize into host-native format */ void cbfs_get_header(struct cbfs_header *header, void *src); +/* Populates a CBFS with a single empty entry filling all available space + * (entries_size bytes). If image's header field is already present, its + * contents will be used to place an empty entry of the requested length at the + * appropriate position in the existing buffer; otherwise, if not has_header, + * the first entries_size bytes of buffer will be filled exclusively with the + * single empty entry (and no CBFS master header). + * Returns 0 on success, otherwise nonzero. */ +int cbfs_image_create(struct cbfs_image *image, size_t entries_size); + /* Creates an empty CBFS image by given size, and description to its content * (bootblock, align, header location, starting offset of CBFS entries). * The output image will contain a valid cbfs_header, with one cbfs_file * entry with type CBFS_COMPONENT_NULL, with max available size. - * Returns 0 on success, otherwise none-zero. */ -int cbfs_image_create(struct cbfs_image *image, - uint32_t arch, - uint32_t align, - struct buffer *bootblock, - uint32_t bootblock_offset, - uint32_t header_offset, - uint32_t entries_offset); + * Only call this if you want a legacy CBFS with a master header. + * Returns 0 on success, otherwise nonzero. */ +int cbfs_legacy_image_create(struct cbfs_image *image, + uint32_t arch, + uint32_t align, + struct buffer *bootblock, + uint32_t bootblock_offset, + uint32_t header_offset, + uint32_t entries_offset); /* Constructs a cbfs_image from a buffer. The resulting image contains a shallow * copy of the buffer; releasing either one is the legal way to clean up after @@ -57,7 +70,8 @@ int cbfs_image_create(struct cbfs_image *image, int cbfs_image_from_buffer(struct cbfs_image *out, struct buffer *in, uint32_t offset); -/* Create a duplicate CBFS image. Returns 0 on success, otherwise non-zero. */ +/* Create a duplicate CBFS image. Returns 0 on success, otherwise non-zero. + * Will not succeed on new-style images without a master header. */ int cbfs_copy_instance(struct cbfs_image *image, size_t copy_offset, size_t copy_size); @@ -74,6 +88,7 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, /* Adds an entry to CBFS image by given name and type. If content_offset is * non-zero, try to align "content" (CBFS_SUBHEADER(p)) at content_offset. + * Note that top-aligned addresses are only supported for legacy CBFSes. * Returns 0 on success, otherwise non-zero. */ int cbfs_add_entry(struct cbfs_image *image, struct buffer *buffer, const char *name, uint32_t type, uint32_t content_offset); @@ -126,6 +141,12 @@ struct cbfs_file *cbfs_find_next_entry(struct cbfs_image *image, * This is different from entry->offset (pointer to content). */ uint32_t cbfs_get_entry_addr(struct cbfs_image *image, struct cbfs_file *entry); +/* Returns 1 if valid new-format CBFS (without a master header), otherwise 0. */ +int cbfs_is_valid_cbfs(struct cbfs_image *image); + +/* Returns 1 if valid legacy CBFS (with a master header), otherwise 0. */ +int cbfs_is_legacy_cbfs(struct cbfs_image *image); + /* Returns 1 if entry has valid data (by checking magic number), otherwise 0. */ int cbfs_is_valid_entry(struct cbfs_image *image, struct cbfs_file *entry); diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index a242a94..cb2f01a 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -46,10 +46,12 @@ struct command { static struct param { partitioned_file_t *image_file; struct buffer *image_region; - char *name; - char *filename; - char *bootblock; - char *ignore_section; + const char *name; + const char *filename; + const char *fmap; + const char *region_name; + const char *bootblock; + const char *ignore_section; uint64_t u64val; uint32_t type; uint32_t baseaddress; @@ -65,8 +67,11 @@ static struct param { uint32_t pagesize; uint32_t cbfsoffset; uint32_t cbfsoffset_assigned; - uint32_t top_aligned; uint32_t arch; + bool top_aligned; + bool fill_partial_upward; + bool fill_partial_downward; + bool show_immutable; int fit_empty_entries; comp_algo algo; /* for linux payloads */ @@ -77,8 +82,22 @@ static struct param { .arch = CBFS_ARCHITECTURE_UNKNOWN, .algo = CBFS_COMPRESS_NONE, .headeroffset = ~0, + .region_name = SECTION_NAME_PRIMARY_CBFS, }; +static bool region_is_flashmap(const char *region) +{ + return partitioned_file_region_check_magic(param.image_file, region, + FMAP_SIGNATURE, strlen(FMAP_SIGNATURE)); +} + +/* @return Same as cbfs_is_valid_cbfs(), but for a named region. */ +static bool region_is_modern_cbfs(const char *region) +{ + return partitioned_file_region_check_magic(param.image_file, region, + CBFS_FILE_MAGIC, strlen(CBFS_FILE_MAGIC)); +} + typedef int (*convert_buffer_t)(struct buffer *buffer, uint32_t *offset); static int cbfs_add_integer_component(const char *name, @@ -147,10 +166,8 @@ static int cbfs_add_component(const char *filename, } struct cbfs_image image; - if (cbfs_image_from_buffer(&image, param.image_region, headeroffset)) { - ERROR("Selected image region is not a CBFS.\n"); + if (cbfs_image_from_buffer(&image, param.image_region, headeroffset)) return 1; - } struct buffer buffer; if (buffer_from_file(&buffer, filename) != 0) { @@ -307,10 +324,8 @@ static int cbfs_remove(void) struct cbfs_image image; if (cbfs_image_from_buffer(&image, param.image_region, - param.headeroffset)) { - ERROR("Selected image region is not a CBFS.\n"); + param.headeroffset)) return 1; - } if (cbfs_remove_entry(&image, param.name) != 0) { ERROR("Removing file '%s' failed.\n", @@ -323,6 +338,24 @@ static int cbfs_remove(void) static int cbfs_create(void) { + struct cbfs_image image; + memset(&image, 0, sizeof(image)); + buffer_clone(&image.buffer, param.image_region); + + if (param.fmap) { + if (param.arch != CBFS_ARCHITECTURE_UNKNOWN || param.size || + param.baseaddress_assigned || + param.headeroffset_assigned || + param.cbfsoffset_assigned || + param.alignment || + param.bootblock) { + ERROR("Since -M was provided, -m, -s, -b, -o, -H, -a, and -B should be omitted\n"); + return 1; + } + + return cbfs_image_create(&image, image.buffer.size); + } + if (param.arch == CBFS_ARCHITECTURE_UNKNOWN) { ERROR("You need to specify -m/--machine arch.\n"); return 1; @@ -343,9 +376,8 @@ static int cbfs_create(void) if (!param.baseaddress_assigned) { if (param.arch == CBFS_ARCHITECTURE_X86) { // Make sure there's at least enough room for rel_offset - param.baseaddress = param.size - ( - bootblock.size > sizeof(int32_t) ? - bootblock.size : sizeof(int32_t)); + param.baseaddress = param.size - + MAX(bootblock.size, sizeof(int32_t)); DEBUG("x86 -> bootblock lies at end of ROM (%#x).\n", param.baseaddress); } else { @@ -379,25 +411,15 @@ static int cbfs_create(void) } } - struct cbfs_image image; - if (!cbfs_image_from_buffer(&image, param.image_region, -1)) - // It *already* contains a CBFS?! This should be a blank file. - assert(false); - - if (cbfs_image_create(&image, - param.arch, - param.alignment, - &bootblock, - param.baseaddress, - param.headeroffset, - param.cbfsoffset) != 0) { - ERROR("Failed to initialize CBFS structure.\n"); - buffer_delete(&bootblock); - return 1; - } - + int ret = cbfs_legacy_image_create(&image, + param.arch, + param.alignment, + &bootblock, + param.baseaddress, + param.headeroffset, + param.cbfsoffset); buffer_delete(&bootblock); - return 0; + return ret; } static int cbfs_locate(void) @@ -414,8 +436,11 @@ static int cbfs_locate(void) struct cbfs_image image; if (cbfs_image_from_buffer(&image, param.image_region, - param.headeroffset)) { - ERROR("Selected image region is not a CBFS.\n"); + param.headeroffset)) + return 1; + + if (!cbfs_is_legacy_cbfs(&image) && param.top_aligned) { + ERROR("The -T switch is only valid on legacy images having CBFS master headers\n"); return 1; } @@ -445,15 +470,76 @@ static int cbfs_locate(void) return 0; } +static int cbfs_layout(void) +{ + const struct fmap *fmap = partitioned_file_get_fmap(param.image_file); + if (!fmap) { + LOG("This is a legacy image composed entirely of a single CBFS.\n"); + return 1; + } + + printf("This image contains the following sections that can be %s with this tool:\n", + param.show_immutable ? "accessed" : "manipulated"); + puts(""); + for (unsigned index = 0; index < fmap->nareas; ++index) { + const struct fmap_area *current = fmap->areas + index; + + bool readonly = partitioned_file_fmap_count(param.image_file, + partitioned_file_fmap_select_children_of, current) || + region_is_flashmap((const char *)current->name); + if (!param.show_immutable && readonly) + continue; + + printf("'%s'", current->name); + + // Detect consecutive sections that describe the same region and + // show them as aliases. This cannot find equivalent entries + // that aren't adjacent; however, fmaptool doesn't generate + // FMAPs with such sections, so this convenience feature works + // for all but the strangest manually created FMAP binaries. + // TODO: This could be done by parsing the FMAP into some kind + // of tree that had duplicate lists in addition to child lists, + // which would allow covering that weird, unlikely case as well. + unsigned lookahead; + for (lookahead = 1; index + lookahead < fmap->nareas; + ++lookahead) { + const struct fmap_area *consecutive = + fmap->areas + index + lookahead; + if (consecutive->offset != current->offset || + consecutive->size != current->size) + break; + printf(", '%s'", consecutive->name); + } + if (lookahead > 1) + fputs(" are aliases for the same region", stdout); + + const char *qualifier = ""; + if (readonly) + qualifier = "read-only, "; + else if (region_is_modern_cbfs((const char *)current->name)) + qualifier = "CBFS, "; + printf(" (%ssize %u)\n", qualifier, current->size); + + index += lookahead - 1; + } + puts(""); + + if (param.show_immutable) { + puts("It is at least possible to perform the read action on every section listed above."); + } else { + puts("It is possible to perform either the write action or the CBFS add/remove actions on every section listed above."); + puts("To see the image's read-only sections as well, rerun with the -w option."); + } + + return 0; +} + static int cbfs_print(void) { struct cbfs_image image; if (cbfs_image_from_buffer(&image, param.image_region, - param.headeroffset)) { - ERROR("Selected image region is not a CBFS.\n"); + param.headeroffset)) return 1; - } - cbfs_print_directory(&image); return 0; } @@ -472,14 +558,93 @@ static int cbfs_extract(void) struct cbfs_image image; if (cbfs_image_from_buffer(&image, param.image_region, - param.headeroffset)) { - ERROR("Selected image region is not a CBFS.\n"); + param.headeroffset)) return 1; - } return cbfs_export_entry(&image, param.name, param.filename); } +static int cbfs_write(void) +{ + if (!param.filename) { + ERROR("You need to specify a valid input -f/--file.\n"); + return 1; + } + if (!partitioned_file_is_partitioned(param.image_file)) { + ERROR("This operation isn't valid on legacy images having CBFS master headers\n"); + return 1; + } + + if (region_is_modern_cbfs(param.region_name)) { + ERROR("Target image region '%s' is a CBFS and must be manipulated using add and remove\n", + param.region_name); + return 1; + } + + struct buffer new_content; + if (buffer_from_file(&new_content, param.filename)) + return 1; + + if (buffer_check_magic(&new_content, FMAP_SIGNATURE, + strlen(FMAP_SIGNATURE))) { + ERROR("File '%s' appears to be an FMAP and cannot be added to an existing image\n", + param.filename); + buffer_delete(&new_content); + return 1; + } + if (buffer_check_magic(&new_content, CBFS_FILE_MAGIC, + strlen(CBFS_FILE_MAGIC))) { + ERROR("File '%s' appears to be a CBFS and cannot be inserted into a raw region\n", + param.filename); + buffer_delete(&new_content); + return 1; + } + + unsigned offset = 0; + if (param.fill_partial_upward && param.fill_partial_downward) { + ERROR("You may only specify one of -u and -d.\n"); + buffer_delete(&new_content); + return 1; + } else if (!param.fill_partial_upward && !param.fill_partial_downward) { + if (new_content.size != param.image_region->size) { + ERROR("File to add is %zu bytes and would not fill %zu-byte target region (did you mean to pass either -u or -d?)\n", + new_content.size, param.image_region->size); + buffer_delete(&new_content); + return 1; + } + } else { + if (new_content.size > param.image_region->size) { + ERROR("File to add is %zu bytes and would overflow %zu-byte target region\n", + new_content.size, param.image_region->size); + buffer_delete(&new_content); + return 1; + } + WARN("Written area will abut %s of target region: any unused space will keep its current contents\n", + param.fill_partial_upward ? "bottom" : "top"); + if (param.fill_partial_downward) + offset = param.image_region->size - new_content.size; + } + + memcpy(param.image_region->data + offset, new_content.data, + new_content.size); + buffer_delete(&new_content); + return 0; +} + +static int cbfs_read(void) +{ + if (!param.filename) { + ERROR("You need to specify a valid output -f/--file.\n"); + return 1; + } + if (!partitioned_file_is_partitioned(param.image_file)) { + ERROR("This operation isn't valid on legacy images having CBFS master headers\n"); + return 1; + } + + return buffer_write_file(param.image_region, param.filename); +} + static int cbfs_update_fit(void) { if (!param.name) { @@ -495,10 +660,8 @@ static int cbfs_update_fit(void) struct cbfs_image image; if (cbfs_image_from_buffer(&image, param.image_region, - param.headeroffset)) { - ERROR("Selected image region is not a CBFS.\n"); + param.headeroffset)) return 1; - } return fit_update_table(&image, param.fit_empty_entries, param.name); } @@ -517,28 +680,40 @@ static int cbfs_copy(void) struct cbfs_image image; if (cbfs_image_from_buffer(&image, param.image_region, - param.headeroffset)) { - ERROR("Selected image region is not a CBFS.\n"); + param.headeroffset)) + return 1; + + if (!cbfs_is_legacy_cbfs(&image)) { + ERROR("This operation is only valid on legacy images having CBFS master headers\n"); return 1; } return cbfs_copy_instance(&image, param.copyoffset, param.size); } +static bool cbfs_is_legacy_format(struct buffer *buffer) +{ + // Legacy CBFSes are those containing the deprecated CBFS master header. + return cbfs_find_header(buffer->data, buffer->size, -1); +} + static const struct command commands[] = { - {"add", "H:f:n:t:b:vh?", cbfs_add, true, true}, - {"add-flat-binary", "H:f:n:l:e:c:b:vh?", cbfs_add_flat_binary, true, + {"add", "H:r:f:n:t:b:vh?", cbfs_add, true, true}, + {"add-flat-binary", "H:r:f:n:l:e:c:b:vh?", cbfs_add_flat_binary, true, true}, - {"add-payload", "H:f:n:t:c:b:vh?C:I:", cbfs_add_payload, true, true}, - {"add-stage", "H:f:n:t:c:b:S:vh?", cbfs_add_stage, true, true}, - {"add-int", "H:i:n:b:vh?", cbfs_add_integer, true, true}, - {"copy", "H:D:s:", cbfs_copy, true, true}, - {"create", "s:B:b:H:a:o:m:vh?", cbfs_create, true, true}, - {"extract", "H:n:f:vh?", cbfs_extract, true, false}, - {"locate", "H:f:n:P:a:Tvh?", cbfs_locate, true, false}, - {"print", "H:vh?", cbfs_print, true, false}, - {"remove", "H:n:vh?", cbfs_remove, true, true}, - {"update-fit", "H:n:x:vh?", cbfs_update_fit, true, true}, + {"add-payload", "H:r:f:n:t:c:b:C:I:vh?", cbfs_add_payload, true, true}, + {"add-stage", "H:r:f:n:t:c:b:S:vh?", cbfs_add_stage, true, true}, + {"add-int", "H:r:i:n:b:vh?", cbfs_add_integer, true, true}, + {"copy", "H:D:s:h?", cbfs_copy, true, true}, + {"create", "M:r:s:B:b:H:a:o:m:vh?", cbfs_create, true, true}, + {"extract", "H:r:n:f:vh?", cbfs_extract, true, false}, + {"locate", "H:r:f:n:P:a:Tvh?", cbfs_locate, true, false}, + {"layout", "wvh?", cbfs_layout, false, false}, + {"print", "H:r:vh?", cbfs_print, true, false}, + {"read", "r:f:vh?", cbfs_read, true, false}, + {"remove", "H:r:n:vh?", cbfs_remove, true, true}, + {"update-fit", "H:r:n:x:vh?", cbfs_update_fit, true, true}, + {"write", "r:f:udvh?", cbfs_write, true, true}, }; static struct option long_options[] = { @@ -551,6 +726,10 @@ static struct option long_options[] = { {"empty-fits", required_argument, 0, 'x' }, {"entry-point", required_argument, 0, 'e' }, {"file", required_argument, 0, 'f' }, + {"fill-downward", no_argument, 0, 'd' }, + {"fill-upward", no_argument, 0, 'u' }, + {"flashmap", required_argument, 0, 'M' }, + {"fmap-regions", required_argument, 0, 'r' }, {"header-offset", required_argument, 0, 'H' }, {"help", no_argument, 0, 'h' }, {"ignore-sec", required_argument, 0, 'S' }, @@ -565,53 +744,121 @@ static struct option long_options[] = { {"top-aligned", required_argument, 0, 'T' }, {"type", required_argument, 0, 't' }, {"verbose", no_argument, 0, 'v' }, + {"with-readonly", no_argument, 0, 'w' }, {NULL, 0, 0, 0 } }; +static int dispatch_command(struct command command) +{ + if (command.accesses_region) { + assert(param.image_file); + + if (partitioned_file_is_partitioned(param.image_file)) { + LOG("Performing operation on '%s' region...\n", + param.region_name); + } + if (!partitioned_file_read_region(param.image_region, + param.image_file, param.region_name)) { + ERROR("The image will be left unmodified.\n"); + return 1; + } + + if (command.modifies_region) { + // We (intentionally) don't support overwriting the FMAP + // section. If you find yourself wanting to do this, + // consider creating a new image rather than performing + // whatever hacky transformation you were planning. + if (region_is_flashmap(param.region_name)) { + ERROR("Image region '%s' is read-only because it contains the FMAP.\n", + param.region_name); + ERROR("The image will be left unmodified.\n"); + return 1; + } + // We don't allow writing raw data to regions that + // contain nested regions, since doing so would + // overwrite all such subregions. + if (partitioned_file_region_contains_nested( + param.image_file, param.region_name)) { + ERROR("Image region '%s' is read-only because it contains nested regions.\n", + param.region_name); + ERROR("The image will be left unmodified.\n"); + return 1; + } + } + } + + if (command.function()) { + if (partitioned_file_is_partitioned(param.image_file)) { + ERROR("Failed while operating on '%s' region!\n", + param.region_name); + ERROR("The image will be left unmodified.\n"); + } + return 1; + } + + return 0; +} + static void usage(char *name) { printf ("cbfstool: Management utility for CBFS formatted ROM images\n\n" "USAGE:\n" " %s [-h]\n" " %s FILE COMMAND [-v] [PARAMETERS]...\n\n" "OPTIONs:\n" - " -H header_offset Do not search for header, use this offset\n" - " -T Output top-aligned memory address\n" - " -v Provide verbose output\n" - " -h Display this help message\n\n" + " -H header_offset Do not search for header; use this offset*\n" + " -T Output top-aligned memory address*\n" + " -u Accept short data; fill upward/from bottom\n" + " -d Accept short data; fill downward/from top\n" + " -v Provide verbose output\n" + " -h Display this help message\n\n" "COMMANDs:\n" - " add -f FILE -n NAME -t TYPE [-b base-address] " + " add [-r image,regions] -f FILE -n NAME -t TYPE \\\n" + " [-b base-address] " "Add a component\n" - " add-payload -f FILE -n NAME [-c compression] [-b base] " + " add-payload [-r image,regions] -f FILE -n NAME \\\n" + " [-c compression] [-b base-address] " "Add a payload to the ROM\n" " (linux specific: [-C cmdline] [-I initrd])\n" - " add-stage -f FILE -n NAME [-c compression] [-b base] \\\n" - " [-S section-to-ignore] " + " add-stage [-r image,regions] -f FILE -n NAME \\\n" + " [-c compression] [-b base] [-S section-to-ignore] " "Add a stage to the ROM\n" - " add-flat-binary -f FILE -n NAME -l load-address \\\n" - " -e entry-point [-c compression] [-b base] " + " add-flat-binary [-r image,regions] -f FILE -n NAME \\\n" + " -l load-address -e entry-point [-c compression] \\\n" + " [-b base] " "Add a 32bit flat mode binary\n" - " add-int -i INTEGER -n NAME [-b base] " + " add-int [-r image,regions] -i INTEGER -n NAME [-b base] " "Add a raw 64-bit integer value\n" - " remove -n NAME " + " remove [-r image,regions] -n NAME " "Remove a component\n" " copy -D new_header_offset -s region size \\\n" - " [-H source header offset] " - "Create a copy (duplicate) cbfs instance\n" - " create -s size -m ARCH [-B bootblock] [-b bootblock offset] \\\n" - " [-o CBFS offset] [-H header offset] [-a align] " - "Create a ROM file\n" - " locate -f FILE -n NAME [-P page-size] [-a align] [-T] " + " [-H source header offset] " + "Create a copy (duplicate) cbfs instance*\n" + " create -m ARCH -s size [-b bootblock offset] \\\n" + " [-o CBFS offset] [-H header offset] [-B bootblock] \\\n" + " [-a align] " + "Create a legacy ROM file with CBFS master header*\n" + " create -M flashmap [-r list,of,regions,containing,cbfses] " + "Create a new-style partitioned firmware image\n" + " locate [-r image,regions] -f FILE -n NAME [-P page-size] \\\n" + " [-a align] [-T] " "Find a place for a file of that size\n" - " print " + " layout [-w] " + "List mutable (or, with -w, readable) image regions\n" + " print [-r image,regions] " "Show the contents of the ROM\n" - " extract -n NAME -f FILE " + " extract [-r image,regions] -n NAME -f FILE " "Extracts a raw payload from ROM\n" - " update-fit -n MICROCODE_BLOB_NAME -x EMTPY_FIT_ENTRIES\n " + " write -r image,regions -f file [-u | -d] " + "Write file into same-size [or larger] raw region\n" + " read [-r fmap-region] -f file " + "Extract raw region contents into binary file\n" + " update-fit [-r image,regions] -n MICROCODE_BLOB_NAME \\\n" + " -x EMTPY_FIT_ENTRIES " "Updates the FIT table with microcode entries\n" "\n" "OFFSETs:\n" " Numbers accompanying -b, -H, and -o switches may be provided\n" - " in two possible formats: if their value is greater than\n" + " in two possible formats*: if their value is greater than\n" " 0x80000000, they are interpreted as a top-aligned x86 memory\n" " address; otherwise, they are treated as an offset into flash.\n" "ARCHes:\n" @@ -619,6 +866,22 @@ static void usage(char *name) "TYPEs:\n", name, name ); print_supported_filetypes(); + + printf( + "\n* Note that these actions and switches are only valid when\n" + " working with legacy images whose structure is described\n" + " primarily by a CBFS master header. New-style images, in\n" + " contrast, exclusively make use of an FMAP to describe their\n" + " layout: this must minimally contain an '%s' section\n" + " specifying the location of this FMAP itself and a '%s'\n" + " section describing the primary CBFS. It should also be noted\n" + " that, when working with such images, the -F and -r switches\n" + " default to '%s' for convenience, and both the -b switch to\n" + " CBFS operations and the output of the locate action become\n" + " relative to the selected CBFS region's lowest address.\n", + SECTION_NAME_FMAP, SECTION_NAME_PRIMARY_CBFS, + SECTION_NAME_PRIMARY_CBFS + ); } int main(int argc, char **argv) @@ -678,6 +941,12 @@ int main(int argc, char **argv) WARN("Unknown compression '%s'" " ignored.\n", optarg); break; + case 'M': + param.fmap = optarg; + break; + case 'r': + param.region_name = optarg; + break; case 'b': param.baseaddress = strtoul(optarg, NULL, 0); // baseaddress may be zero on non-x86, so we @@ -729,7 +998,16 @@ int main(int argc, char **argv) param.u64val = strtoull(optarg, NULL, 0); break; case 'T': - param.top_aligned = 1; + param.top_aligned = true; + break; + case 'u': + param.fill_partial_upward = true; + break; + case 'd': + param.fill_partial_downward = true; + break; + case 'w': + param.show_immutable = true; break; case 'x': param.fit_empty_entries = strtol(optarg, NULL, 0); @@ -759,20 +1037,33 @@ int main(int argc, char **argv) } if (commands[i].function == cbfs_create) { - if (param.size == 0) { - ERROR("You need to specify a valid -s/--size.\n"); + if (param.fmap) { + struct buffer flashmap; + if (buffer_from_file(&flashmap, param.fmap)) + return 1; + param.image_file = partitioned_file_create( + image_name, &flashmap); + buffer_delete(&flashmap); + } else if (param.size) { + param.image_file = partitioned_file_create_flat( + image_name, param.size); + } else { + ERROR("You need to specify a valid -M/--flashmap or -s/--size.\n"); return 1; } - param.image_file = partitioned_file_create_flat( - image_name, param.size); } else { param.image_file = partitioned_file_reopen(image_name, - partitioned_file_open_as_flat); + cbfs_is_legacy_format); } if (!param.image_file) return 1; + unsigned num_regions = 1; + for (const char *list = strchr(param.region_name, ','); list; + list = strchr(list + 1, ',')) + ++num_regions; + // If the action needs to read an image region, as indicated by // having accesses_region set in its command struct, that // region's buffer struct will be stored here and the client @@ -781,36 +1072,60 @@ int main(int argc, char **argv) // since this behavior can be requested via its modifies_region // field. Additionally, it should never free the region buffer, // as that is performed automatically once it completes. - struct buffer image_region; - memset(&image_region, 0, sizeof(image_region)); + struct buffer image_regions[num_regions]; + memset(image_regions, 0, sizeof(image_regions)); + + bool seen_primary_cbfs = false; + char region_name_scratch[strlen(param.region_name) + 1]; + strcpy(region_name_scratch, param.region_name); + param.region_name = strtok(region_name_scratch, ","); + for (unsigned region = 0; region < num_regions; ++region) { + if (!param.region_name) { + ERROR("Encountered illegal degenerate region name in -r list\n"); + ERROR("The image will be left unmodified.\n"); + partitioned_file_close(param.image_file); + return 1; + } - if (commands[i].accesses_region) { - assert(param.image_file); + if (strcmp(param.region_name, SECTION_NAME_PRIMARY_CBFS) + == 0) + seen_primary_cbfs = true; - if (!partitioned_file_read_region(&image_region, - param.image_file, SECTION_NAME_PRIMARY_CBFS)) { + param.image_region = image_regions + region; + if (dispatch_command(commands[i])) { partitioned_file_close(param.image_file); return 1; } - param.image_region = &image_region; + + param.region_name = strtok(NULL, ","); } - int error = commands[i].function(); + if (commands[i].function == cbfs_create && !seen_primary_cbfs) { + ERROR("The creation -r list must include the mandatory '%s' section.\n", + SECTION_NAME_PRIMARY_CBFS); + ERROR("The image will be left unmodified.\n"); + partitioned_file_close(param.image_file); + return 1; + } - if (!error && commands[i].modifies_region) { + if (commands[i].modifies_region) { assert(param.image_file); assert(commands[i].accesses_region); - - if (!partitioned_file_write_region(param.image_file, - &image_region)) { - partitioned_file_close(param.image_file); - return 1; + for (unsigned region = 0; region < num_regions; + ++region) { + + if (!partitioned_file_write_region( + param.image_file, + image_regions + region)) { + partitioned_file_close( + param.image_file); + return 1; + } } } partitioned_file_close(param.image_file); - - return error; + return 0; } ERROR("Unknown command '%s'.\n", cmd); diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index 416d0a4..831d3eb 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -47,6 +47,8 @@ extern int verbose; /* Helpers */ #define ARRAY_SIZE(a) (int)(sizeof(a) / sizeof((a)[0])) #define ALIGN(val, by) (((val) + (by)-1)&~((by)-1)) +#define MAX(x, y) ((x) > (y) ? (x) : (y)) +#define MIN(x, y) ((x) < (y) ? (x) : (y)) #define unused __attribute__((unused))

1 0

Patch merged into coreboot/master: e3260a0 cbfstool: Restructure around support for reading/writing portions of files
by gerrit＠coreboot.org 08 May '15

08 May '15

the following patch was just integrated into master: commit e3260a042f438cedb446c5e7b3dc6f55a3b9aa95 Author: Sol Boucher <solb(a)chromium.org> Date: Wed Mar 25 13:40:08 2015 -0700 cbfstool: Restructure around support for reading/writing portions of files The buffer API that cbfstool uses to read and write files only directly supports one-shot operations on whole files. This adds an intermediate partitioned_file module that sits on top of the buffer system and has an awareness of FMAP entries. It provides an easy way to get a buffer for an individual region of a larger image file based on FMAP section name, as well as incrementally write those smaller buffers back to the backing file at the appropriate offset. The module has two distinct modes of operation: - For new images whose layout is described exclusively by an FMAP section, all the aforementioned functionality will be available. - For images in the current format, where the CBFS master header serves as the root of knowledge of the image's size and layout, the module falls back to a legacy operation mode, where it only allows manipulation of the entire image as one unit, but exposes this support through the same interface by mapping the region named SECTION_NAME_PRIMARY_CBFS ("COREBOOT") to the whole file. The tool is presently only ported onto the new module running in legacy mode: higher-level support for true "partitioned" images will be forthcoming. However, as part of this change, the crusty cbfs_image_from_file() and cbfs_image_write_file() abstractions are removed and replaced with a single cbfs_image function, cbfs_image_from_buffer(), as well as centralized image reading/writing directly in cbfstool's main() function. This reduces the boilerplate required to implement each new action, makes the create action much more similar to the others, and will make implementing additional actions and adding in support for the new format much easier. BUG=chromium:470407 TEST=Build panther and nyan_big coreboot.rom images with and without this patch and diff their hexdumps. Ensure that no differences occur at different locations from the diffs between subsequent builds of an identical source tree. Then flash a full new build onto nyan_big and watch it boot normally. BRANCH=None Change-Id: I25578c7b223bc8434c3074cb0dd8894534f8c500 Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Commit-Id: 7e1c96a48e7a27fc6b90289d35e6e169d5e7ad20 Original-Change-Id: Ia4a1a4c48df42b9ec2d6b9471b3a10eb7b24bb39 Original-Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Reviewed-on: https://chromium-review.googlesource.com/265581 Original-Reviewed-by: Aaron Durbin <adurbin(a)chromium.org> Reviewed-on: http://review.coreboot.org/10134 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi(a)google.com> See http://review.coreboot.org/10134 for details. -gerrit

1 0

Patch merged into coreboot/master: 64c6cd7 cbfstool: Add offset field to cbfstool directory's struct buffer
by gerrit＠coreboot.org 08 May '15

08 May '15

the following patch was just integrated into master: commit 64c6cd73f3567e893a9cde7d08eb5505c1a19c62 Author: Sol Boucher <solb(a)chromium.org> Date: Sun Apr 26 02:32:43 2015 -0700 cbfstool: Add offset field to cbfstool directory's struct buffer This allows calls to buffer_delete() to work on a buffer that has been buffer_seek()ed or the buffer created by a buffer_splice(). The same information could also be useful for other purposes, such as writing slices back to a file at the offset they originally occupied. BUG=chromium:470407 TEST=Attempt to perform the following sequence of buffer actions, then run it through valgrind to check for memory errors: for (int pos = 0; pos <= 3; ++pos) { struct buffer seek_test; buffer_create(&seek_test, 3, "seek_test"); if (pos == 0) { buffer_delete(&seek_test); continue; } buffer_seek(&seek_test, 1); if (pos == 1) { buffer_delete(&seek_test); continue; } buffer_seek(&seek_test, 1); if (pos == 2) { buffer_delete(&seek_test); continue; } buffer_seek(&seek_test, 1); if (pos == 3) { buffer_delete(&seek_test); continue; } } for (int pos = 0; pos <= 14; ++pos) { struct buffer slice_test; buffer_create(&slice_test, 3, "slice_test"); if (pos == 0) { buffer_delete(&slice_test); continue; } struct buffer sliced_once; buffer_splice(&sliced_once, &slice_test, 1, 2); if (pos == 1) { buffer_delete(&slice_test); continue; } if (pos == 2) { buffer_delete(&sliced_once); continue; } struct buffer sliced_twice; buffer_splice(&sliced_twice, &sliced_once, 2, 1); if (pos == 3) { buffer_delete(&slice_test); continue; } if (pos == 4) { buffer_delete(&sliced_once); continue; } if (pos == 5) { buffer_delete(&sliced_twice); continue; } struct buffer sliced_same; buffer_splice(&sliced_same, &slice_test, 1, 1); if (pos == 6) { buffer_delete(&slice_test); continue; } if (pos == 7) { buffer_delete(&sliced_once); continue; } if (pos == 8) { buffer_delete(&sliced_twice); continue; } if (pos == 9) { buffer_delete(&sliced_same); continue; } struct buffer sliced_thrice; buffer_splice(&sliced_thrice, &sliced_twice, 1, 0); if (pos == 10) { buffer_delete(&slice_test); continue; } if (pos == 11) { buffer_delete(&sliced_once); continue; } if (pos == 12) { buffer_delete(&sliced_twice); continue; } if (pos == 13) { buffer_delete(&sliced_same); continue; } if (pos == 14) { buffer_delete(&sliced_thrice); continue; } } BRANCH=None Change-Id: Id67734654a62302c0de37746d8a978d49b240505 Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Commit-Id: 00c40982a21a91a488587dd3cead7109f3a30d98 Original-Change-Id: Ie99839d36500d3270e4924a3477e076a6d27ffc8 Original-Signed-off-by: Sol Boucher <solb(a)chromium.org> Original-Reviewed-on: https://chromium-review.googlesource.com/267467 Original-Reviewed-by: Aaron Durbin <adurbin(a)chromium.org> Reviewed-on: http://review.coreboot.org/10133 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi(a)google.com> See http://review.coreboot.org/10133 for details. -gerrit

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

coreboot-gerrit May 2015