coreboot January 2013

coreboot@coreboot.org

32 participants
607 discussions

RFC: Allow CBFS to read from multiple arbitrary source media.
by Hung-Te Lin 29 Jan '13

29 Jan '13

Greetings, I've uploaded some CBFS changes for discussion: http://review.coreboot.org/#/c/2182/ http://review.coreboot.org/#/c/2191/ CBFS used to work only on memory-mapped ROM (all x86). For platforms like ARM, the ROM may come from USB, UART, or SPI -- any serial devices and not available for memory mapping. The idea is to allow (1) using CBFS on platforms without memory-mapped ROM (ex, ARM), and (2) reading CBFS from multiple source at the same time (ex, receive updates from USB or UART cable). The first patch is for coreboot itself, and the second one is to provide some implementation on libpayload. I tried to minimize necessary changes to existing source, although the API names are changed - but rewriting should be easy. In summary, if you don't need to read from multiple sources at the same time, just add a CBFS_DEFAULT_MEDIA param to every CBFS functions. The major reader APIs are renamed because we don't "find" anymore: struct cbfs_file *f = cbfs_find(name); => f = cbfs_get_file(media, name); void *p = cbfs_find_file(name, type) => p = cbfs_get_file_content(media, name, type); (One function is deprecated: cbfs_get_file => it can be replaced with cbfs_get_file_content with correct type, although I don't see anyone using it in source tree now) To read from multiple source, libpayload used to do this: setup_cbfs_from_ram(); cbfs_find_file(...); do_something_and_not_sure_if_it_reads_cbfs(); setup_cbfs_from_flash(); which is hard to figure out current cbfs source inside function calls. With the new API, we can rewrite as: cbfs_media *ram = create_cbfs_ram_media(), *default = create_cbfs_flash_media(); do_something_with_file_from_ram(cbfs_get_file_content(ram, name)); do_something_with_file_from_rom(cbfs_get_file_content(default, name)); The CL is tested to work on both ARM and x86/qemu. I would be really happy to see people checking the patch, and especially checking that my implementation is correct. I'm also happy to hear about improvements, bug fixes, and other ideas. Thanks for listening, Hung-Te

1 0

Re: [coreboot] gerrit: patch iterations in email [was: differences between patchset iterations]
by Patrick Georgi 29 Jan '13

29 Jan '13

Am 2013-01-28 23:54, schrieb David Hendricks: > - Should we continue to have gerrit send e-mails for every patch > iteration? Option 2: create a new mailing list, subscribe everyone over there by default, and let people unsubscribe if they don't want it. Downside: People with filter rules get commit messages in the inbox. > - Can we remove the hash from the "Patch set updated" e-mails so they > appear in a single thread? Mail headers should be enough - I'll look into it. > - Is there a way to make gerrit *not* send update notifications if > no actual code changes were made, for example if the patch was > inserted into a series or if the commit message was changed? rebase: is a code change inserting commit in a series: is a code change It helps for developers to create "upstream branches" that contain _only_ the subset of interdependent changes. There is no other way for a tool to know which change is relevant and which is not, and it avoids updating 15 patchsets just because one commit has changed (which might have nothing to do with everything else). Patrick

1 0

New patch to review for coreboot: 4e2d16a cbfstool: Use cbfs_image api for "add" command.
by Hung-Te Lin 28 Jan '13

28 Jan '13

Hung-Te Lin (hungte(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/2216 -gerrit commit 4e2d16a0916625bb0af44e7db60aebc47bfead73 Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 10:24:00 2013 +0800 cbfstool: Use cbfs_image api for "add" command. All addresses (-b, -H, -l) can now be ROM offset (address < 0x8000000) or x86 top-aligned address (address > 0x80000000). Example: cbfstool coreboot.rom add -f config -n config -t raw -b 0x2000 cbfstool coreboot.rom add-stage -f stage -n newstage -b 0xffffd1c0 Verified boot-able on both ARM(snow) and x86(QEMU) system. Change-Id: I485e4e88b5e269494a4b138e0a83f793ffc5a084 Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/cbfs_image.c | 183 +++++++++++++++++++++++++++++++++++++++++++++ util/cbfstool/cbfs_image.h | 6 ++ util/cbfstool/cbfstool.c | 78 ++++++++++++------- 3 files changed, 239 insertions(+), 28 deletions(-) diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index 0fb703c..afc1359 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -245,6 +245,180 @@ int cbfs_image_delete(struct cbfs_image *image) { return 0; } +/* 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, + 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 len, target; + uint32_t align = ntohl(image->header->align); + + target = content_offset - header_size; + if (target % align) + target -= target % align; + if (target < addr) { + ERROR("No space to hold cbfs_file header."); + return -1; + } + + // Process buffer BEFORE content_offset. + if (target - addr > min_entry_size) { + DEBUG("|min|...|header|content|... <create new entry>\n"); + len = target - addr - min_entry_size; + cbfs_create_empty_entry(image, entry, len, ""); + 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(image, entry, len, name); + if (len != size) { + DEBUG("|..|header|content|... <use offset to create entry>\n"); + DEBUG("before: offset=0x%x, len=0x%x\n", + ntohl(entry->offset), ntohl(entry->len)); + // TODO reset expanded name buffer to 0xFF. + entry->offset = htonl(ntohl(entry->offset) + (len - size)); + entry->len = htonl(size); + DEBUG("after: offset=0x%x, len=0x%x\n", + ntohl(entry->offset), ntohl(entry->len)); + } + + // Ready to fill data into entry. + assert(ntohl(entry->len) == size); + entry->type = htonl(type); + DEBUG("content_offset: 0x%x, entry location: %x\n", + content_offset, (int)((char*)CBFS_SUBHEADER(entry) - + image->buffer.data)); + assert((char*)CBFS_SUBHEADER(entry) - image->buffer.data == + content_offset); + memcpy(CBFS_SUBHEADER(entry), data, size); + if (verbose > 1) cbfs_print_entry_info(image, entry, stderr); + + // Process buffer AFTER entry. + entry = cbfs_find_next_entry(image, entry); + addr = cbfs_get_entry_addr(image, entry); + assert(addr < addr_next); + + if (addr_next - addr < min_entry_size) { + DEBUG("No space after content to keep CBFS structure.\n"); + return -1; + } + + len = addr_next - addr - min_entry_size; + cbfs_create_empty_entry(image, entry, len, ""); + 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) { + uint32_t entry_type; + uint32_t addr, addr_next; + struct cbfs_file *entry, *next; + uint32_t header_size, need_size, new_size; + + header_size = cbfs_calculate_file_header_size(name); + + need_size = header_size + buffer->size; + 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)) { + // legacy cbfstool takes top-aligned address. + uint32_t romsize = ntohl(image->header->romsize); + INFO("Converting top-aligned address 0x%x to offset: 0x%x\n", + content_offset, content_offset + romsize); + content_offset += romsize; + } + + // Merge empty entries. + DEBUG("(trying to merge empty entries...)\n"); + cbfs_walk(image, cbfs_merge_empty_entry, NULL); + + for (entry = cbfs_find_first_entry(image); + entry && cbfs_is_valid_entry(entry); + entry = cbfs_find_next_entry(image, entry)) { + + entry_type = ntohl(entry->type); + if (entry_type != CBFS_COMPONENT_NULL) + continue; + + addr = cbfs_get_entry_addr(image, entry); + next = cbfs_find_next_entry(image, entry); + addr_next = cbfs_get_entry_addr(image, next); + + DEBUG("cbfs_add_entry: space at 0x%x+0x%x(%d) bytes\n", + addr, addr_next - addr, addr_next - addr); + if (addr + need_size > addr_next) + continue; + + // Can we simply put object here? + if (!content_offset || content_offset == addr + header_size) { + DEBUG("Filling new entry data (%zd bytes).\n", + buffer->size); + cbfs_create_empty_entry(image, entry, buffer->size, + name); + entry->type = htonl(type); + memcpy(CBFS_SUBHEADER(entry), buffer->data, buffer->size); + if (verbose) + cbfs_print_entry_info(image, entry, stderr); + + // setup new entry + DEBUG("Seting new empty entry.\n"); + entry = cbfs_find_next_entry(image, entry); + new_size = (cbfs_get_entry_addr(image, next) - + cbfs_get_entry_addr(image, entry)); + new_size -= cbfs_calculate_file_header_size(""); + DEBUG("new size: %d\n", new_size); + cbfs_create_empty_entry(image, entry, new_size, ""); + if (verbose) + cbfs_print_entry_info(image, entry, stderr); + return 0; + } + + // We need to put content here, and the case is really + // complicated... + assert(content_offset); + if (addr_next < content_offset) { + DEBUG("Not for specified offset yet"); + continue; + } else if (addr > content_offset) { + DEBUG("Exceed specified content_offset."); + break; + } else if (addr + header_size > content_offset) { + ERROR("Not enough space for header.\n"); + break; + } else if (content_offset + buffer->size > addr_next) { + ERROR("Not enough space for content.\n"); + break; + } + + // TODO there are more few tricky cases that we may + // want to fit by altering offset. + DEBUG("section 0x%x+0x%x for content_offset 0x%x.\n", + addr, addr_next - addr, content_offset); + + if (cbfs_add_entry_at(image, entry, buffer->size, name, type, + buffer->data, content_offset) == 0) { + return 0; + } + break; + } + + ERROR("Could not add [%s, %zd bytes (%zd KB)@0x%x]; too big?\n", + buffer->name, buffer->size, buffer->size / 1024, content_offset); + return 0; +} + struct cbfs_file *cbfs_get_entry(struct cbfs_image *image, const char *name) { struct cbfs_file *entry; for (entry = cbfs_find_first_entry(image); @@ -563,6 +737,15 @@ int cbfs_is_valid_entry(struct cbfs_file *entry) { sizeof(entry->magic)) == 0); } +int cbfs_init_entry(struct cbfs_file *entry, + struct buffer *buffer) { + memset(entry, 0, sizeof(*entry)); + memcpy(entry->magic, CBFS_FILE_MAGIC, sizeof(entry->magic)); + entry->len = htonl(buffer->size); + entry->offset = htonl(sizeof(*entry) + strlen(buffer->name) + 1); + return 0; +} + int cbfs_create_empty_entry(struct cbfs_image *image, struct cbfs_file *entry, size_t len, const char *name) { memset(entry, CBFS_CONTENT_DEFAULT_VALUE, sizeof(*entry)); diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index ba1c342..9643537 100644 --- a/util/cbfstool/cbfs_image.h +++ b/util/cbfstool/cbfs_image.h @@ -62,6 +62,12 @@ struct cbfs_file *cbfs_get_entry(struct cbfs_image *image, const char *name); int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, const char *filename); +/* 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. + * 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); + /* Removes an entry from CBFS image. Returns 0 on success, otherwise non-zero. */ int cbfs_remove_entry(struct cbfs_image *image, const char *name); diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 970c93a..b9c9eb2 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -58,62 +58,84 @@ static struct param { .algo = CBFS_COMPRESS_NONE, }; -static int cbfs_add(void) -{ - uint32_t filesize = 0; - void *rom, *filedata, *cbfsfile; +typedef int (*convert_buffer_t)(struct buffer *buffer); + +static int cbfs_add_component(const char *cbfs_name, + const char *filename, + const char *name, + uint32_t type, + uint32_t offset, + convert_buffer_t convert) { + struct cbfs_image image; + struct buffer buffer; - if (!param.filename) { + if (!filename) { ERROR("You need to specify -f/--filename.\n"); return 1; } - if (!param.name) { + if (!name) { ERROR("You need to specify -n/--name.\n"); return 1; } - if (param.type == 0) { + if (type == 0) { ERROR("You need to specify a valid -t/--type.\n"); return 1; } - rom = loadrom(param.cbfs_name); - if (rom == NULL) { - ERROR("Could not load ROM image '%s'.\n", - param.cbfs_name); + if (buffer_from_file(&buffer, filename) != 0) { + ERROR("Could not load file '%s'.\n", filename); return 1; } - filedata = loadfile(param.filename, &filesize, 0, SEEK_SET); - if (filedata == NULL) { - ERROR("Could not load file '%s'.\n", - param.filename); - free(rom); + if (convert && convert(&buffer) != 0) { + ERROR("Failed to parse file '%s'.\n", filename); + buffer_delete(&buffer); return 1; } - cbfsfile = create_cbfs_file(param.name, filedata, &filesize, - param.type, &param.baseaddress); - free(filedata); + if (cbfs_image_from_file(&image, cbfs_name) != 0) { + ERROR("Could not load ROM image '%s'.\n", cbfs_name); + buffer_delete(&buffer); + return 1; + } - if (add_file_to_cbfs(cbfsfile, filesize, param.baseaddress)) { - ERROR("Adding file '%s' failed.\n", param.filename); - free(cbfsfile); - free(rom); + if (cbfs_get_entry(&image, name)) { + ERROR("'%s' already in ROM image.\n", name); + buffer_delete(&buffer); + cbfs_image_delete(&image); return 1; } - if (writerom(param.cbfs_name, rom, romsize)) { - free(cbfsfile); - free(rom); + + if (cbfs_add_entry(&image, &buffer, name, type, offset) != 0) { + ERROR("Failed to add '%s' into ROM image.\n", filename); + buffer_delete(&buffer); + cbfs_image_delete(&image); return 1; } - free(cbfsfile); - free(rom); + if (cbfs_image_write_file(&image, cbfs_name) != 0) { + buffer_delete(&buffer); + cbfs_image_delete(&image); + return 1; + } + + buffer_delete(&buffer); + cbfs_image_delete(&image); return 0; } +static int cbfs_add(void) +{ + return cbfs_add_component(param.cbfs_name, + param.filename, + param.name, + param.type, + param.baseaddress, + NULL); +} + static int cbfs_add_payload(void) { uint32_t filesize = 0;

1 0

Patch set updated for coreboot: 957be14 cbfstool: Make endian detection functions to work without prior setup.
by Hung-Te Lin 28 Jan '13

28 Jan '13

Hung-Te Lin (hungte(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/2199 -gerrit commit 957be1481b7695d1f48ab9877071d8353304db5f Author: Hung-Te Lin <hungte(a)chromium.org> Date: Mon Jan 28 15:53:34 2013 +0800 cbfstool: Make endian detection functions to work without prior setup. The 'host_bigendian' variable (and functions rely on it like ntohl/htonl) requires system detection by calling static which_endian() first, which may be easily forgotten by developers. It's now changed as a public function in common.c and doesn't need initialization anymore. Change-Id: I13dabd1ad15d2d6657137d29138e0878040cb205 Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/cbfs-mkstage.c | 2 +- util/cbfstool/cbfstool.c | 14 -------------- util/cbfstool/common.c | 13 +++++++++++++ util/cbfstool/common.h | 11 +++++++---- 4 files changed, 21 insertions(+), 19 deletions(-) diff --git a/util/cbfstool/cbfs-mkstage.c b/util/cbfstool/cbfs-mkstage.c index ef5182a..4374bda 100644 --- a/util/cbfstool/cbfs-mkstage.c +++ b/util/cbfstool/cbfs-mkstage.c @@ -77,7 +77,7 @@ int parse_elf_to_stage(unsigned char *input, unsigned char **output, if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) { elf_bigendian = 1; } - if (elf_bigendian != host_bigendian) { + if (elf_bigendian != is_big_endian()) { elf32_to_native = swap32; } diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 1ad270b..11f1914 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -496,18 +496,6 @@ static void usage(char *name) print_supported_filetypes(); } -/* Small, OS/libc independent runtime check for endianess */ -int host_bigendian = 0; - -static void which_endian(void) -{ - static const uint32_t inttest = 0x12345678; - uint8_t inttest_lsb = *(uint8_t *)&inttest; - if (inttest_lsb == 0x12) { - host_bigendian = 1; - } -} - int main(int argc, char **argv) { size_t i; @@ -518,8 +506,6 @@ int main(int argc, char **argv) return 1; } - which_endian(); - param.cbfs_name = argv[1]; char *cmd = argv[2]; optind += 2; diff --git a/util/cbfstool/common.c b/util/cbfstool/common.c index 8b4b4b4..6e362d9 100644 --- a/util/cbfstool/common.c +++ b/util/cbfstool/common.c @@ -27,6 +27,19 @@ #include "cbfs.h" #include "elf.h" +/* Utilities */ + +/* Small, OS/libc independent runtime check for endianess */ +int is_big_endian(void) +{ + static const uint32_t inttest = 0x12345678; + uint8_t inttest_lsb = *(uint8_t *)&inttest; + if (inttest_lsb == 0x12) { + return 1; + } + return 0; +} + size_t getfilesize(const char *filename) { size_t size; diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index bd5ef65..5315e69 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -21,13 +21,16 @@ #define __CBFSTOOL_COMMON_H #include <stdint.h> + +/* Endianess */ #include "swab.h" #ifndef __APPLE__ -#define ntohl(x) (host_bigendian?(x):swab32(x)) -#define htonl(x) (host_bigendian?(x):swab32(x)) +#define ntohl(x) (is_big_endian() ? (x) : swab32(x)) +#define htonl(x) (is_big_endian() ? (x) : swab32(x)) #endif -#define ntohll(x) (host_bigendian?(x):swab64(x)) -#define htonll(x) (host_bigendian?(x):swab64(x)) +#define ntohll(x) (is_big_endian() ? (x) : swab64(x)) +#define htonll(x) (is_big_endian() ? (x) : swab64(x)) +extern int is_big_endian(void); /* Message output */ extern int verbose;

1 0

Patch set updated for coreboot: 7a6528d cbfstool: Use cbfs_image API for "locate" command.
by Hung-Te Lin 28 Jan '13

28 Jan '13

Hung-Te Lin (hungte(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/2213 -gerrit commit 7a6528d0dbb0bb42bef1de8cce4d601eb228185f Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 03:46:02 2013 +0800 cbfstool: Use cbfs_image API for "locate" command. "locate" command now outputs platform independent offset. To retrieve x86 top-aligned virtual address, add "-T". To test: cbfstool coreboot.rom locate -f stage -n stage -a 0x100000 -T # Example output: 0xffffdc10 Change-Id: I474703c4197b36524b75407a91faab1194edc64d Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- src/arch/x86/Makefile.inc | 2 +- util/cbfstool/cbfs_image.c | 139 +++++++++++++++++++++++++++++++++++++++++++++ util/cbfstool/cbfs_image.h | 15 +++++ util/cbfstool/cbfstool.c | 52 ++++++++++++++--- 4 files changed, 199 insertions(+), 9 deletions(-) diff --git a/src/arch/x86/Makefile.inc b/src/arch/x86/Makefile.inc index 190f7cb..4645bc6 100644 --- a/src/arch/x86/Makefile.inc +++ b/src/arch/x86/Makefile.inc @@ -375,7 +375,7 @@ $(objgenerated)/romstage_xip.ld: $(objgenerated)/romstage_null.ld $(objcbfs)/bas $(objcbfs)/base_xip.txt: $(obj)/coreboot.pre1 $(objcbfs)/romstage_null.bin rm -f $@ - $(CBFSTOOL) $(obj)/coreboot.pre1 locate -f $(objcbfs)/romstage_null.bin -n $(CONFIG_CBFS_PREFIX)/romstage -a $(CONFIG_XIP_ROM_SIZE) > $@.tmp \ + $(CBFSTOOL) $(obj)/coreboot.pre1 locate -T -f $(objcbfs)/romstage_null.bin -n $(CONFIG_CBFS_PREFIX)/romstage -a $(CONFIG_XIP_ROM_SIZE) > $@.tmp \ || { echo "The romstage is larger than XIP size. Please expand the CONFIG_XIP_ROM_SIZE" ; exit 1; } mv $@.tmp $@ diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index e7e5053..878a7a1 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -356,6 +356,49 @@ int cbfs_print_directory(struct cbfs_image *image) { return 0; } +int cbfs_merge_empty_entry(struct cbfs_image *image, struct cbfs_file *entry, + void *arg) { + struct cbfs_file *next; + uint32_t type, addr, last_addr; + + type = ntohl(entry->type); + if (type == CBFS_COMPONENT_DELETED) { + // Ready to be recycled. + type = CBFS_COMPONENT_NULL; + entry->type = htonl(type); + } + if (type != CBFS_COMPONENT_NULL) + return 0; + + next = cbfs_find_next_entry(image, entry); + + while (next && cbfs_is_valid_entry(next)) { + type = ntohl(next->type); + if (type == CBFS_COMPONENT_DELETED) { + type = CBFS_COMPONENT_NULL; + next->type = htonl(type); + } + if (type != CBFS_COMPONENT_NULL) + return 0; + + addr = cbfs_get_entry_addr(image, entry); + last_addr = cbfs_get_entry_addr( + image, cbfs_find_next_entry(image, next)); + + // Now, we find two deleted/empty entries; try to merge now. + 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(image, entry, + (last_addr - addr - + cbfs_calculate_file_header_size("")), + ""); + DEBUG("new empty entry: length=0x%x\n", ntohl(entry->len)); + next = cbfs_find_next_entry(image, entry); + } + return 0; +} + int cbfs_walk(struct cbfs_image *image, cbfs_entry_callback callback, void *arg) { int count = 0; @@ -432,3 +475,99 @@ int cbfs_is_valid_entry(struct cbfs_file *entry) { sizeof(entry->magic)) == 0); } +int cbfs_create_empty_entry(struct cbfs_image *image, struct cbfs_file *entry, + size_t len, const char *name) { + 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)); + strcpy(CBFS_NAME(entry), name); + memset(CBFS_SUBHEADER(entry), CBFS_CONTENT_DEFAULT_VALUE, len); + return 0; +} + +/* Finds a place to hold whole stage data in same memory page. + */ +static int is_in_same_page(uint32_t start, uint32_t size, uint32_t page) { + if (!page) + return 1; + return (start / page) == (start + size - 1) / page; +} + +int32_t cbfs_locate_entry(struct cbfs_image *image, const char *name, + uint32_t size, uint32_t page_size) { + struct cbfs_file *entry; + size_t need_len; + uint32_t addr, addr_next, addr2, addr3, header_len; + assert(size < page_size); + + if (page_size % ntohl(image->header->align)) + WARN("locate_entry: page does not align with CBFS image.\n"); + + /* TODO Old cbfstool always assume input is a stage file (and adding + * sizeof(cbfs_stage) for header. We should fix that by adding "-t" + * (type) param in future. For right now, follow old behavior. */ + header_len = (cbfs_calculate_file_header_size(name) + + sizeof(struct cbfs_stage)); + need_len = header_len + size; + + // Merge empty entries to build get max available pages. + cbfs_walk(image, cbfs_merge_empty_entry, NULL); + + /* Three cases of content location on memory page: + * case 1. + * | PAGE 1 | PAGE 2 | + * | <header><content>| Fit. Return start of content. + * + * case 2. + * | PAGE 1 | PAGE 2 | + * | <header><content> | Fits when we shift content to align + * shift-> | <header>|<content> | at starting of PAGE 2. + * + * case 3. (large content filling whole page) + * | PAGE 1 | PAGE 2 | PAGE 3| + * | <header>< content > | | Can't fit. If we shift content to + * | { free space . } PAGE 2, header can't fit in free + * | shift-> <header><content> space, so we must use PAGE 3. + * + * The returned address will be used to re-link stage file, and then + * assigned to add-stage command (-b), which will be then re-calculated + * by ELF loader and positioned by cbfs_add_entry. + */ + for (entry = cbfs_find_first_entry(image); + entry && cbfs_is_valid_entry(entry); + entry = cbfs_find_next_entry(image, entry)) { + + uint32_t type = ntohl(entry->type); + if (type != CBFS_COMPONENT_NULL) + continue; + + addr = cbfs_get_entry_addr(image, entry); + addr_next = cbfs_get_entry_addr(image, cbfs_find_next_entry( + image, entry)); + if (addr_next - addr < need_len) + continue; + if (is_in_same_page(addr + header_len, size, page_size)) { + DEBUG("cbfs_locate_entry: FIT (PAGE1)."); + return addr + header_len; + } + + addr2 = align_up(addr, page_size); + if (addr2 < addr_next && addr_next - addr2 >= size && + addr2 - addr >= header_len) { + DEBUG("cbfs_locate_entry: OVERLAP (PAGE2)."); + return addr2; + } + + addr3 = addr2 + page_size; + if (addr3 < addr_next && addr_next - addr3 >= size && + addr3 - addr >= header_len) { + DEBUG("cbfs_locate_entry: OVERLAP+ (PAGE3)."); + return addr3; + } + } + return -1; +} diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index e9f64a4..4fce3e5 100644 --- a/util/cbfstool/cbfs_image.h +++ b/util/cbfstool/cbfs_image.h @@ -49,6 +49,16 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, /* 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. + * Returns 0 on success, otherwise (ex, not found) non-zero. */ +int cbfs_create_empty_entry(struct cbfs_image *image, struct cbfs_file *entry, + size_t len, const char *name); + +/* Finds a location to put given content in same memory page. + * 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); + /* Callback function used by cbfs_walk. * Returns 0 on success, or non-zero to stop further iteration. */ typedef int (*cbfs_entry_callback)(struct cbfs_image *image, @@ -90,4 +100,9 @@ int cbfs_print_header_info(struct cbfs_image *image); int cbfs_print_entry_info(struct cbfs_image *image, struct cbfs_file *entry, void *arg); +/* Merge empty entries starting from given entry. + * Returns 0 on success, otherwise non-zero. */ +int cbfs_merge_empty_entry(struct cbfs_image *image, struct cbfs_file *entry, + void *arg); + #endif diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 2ae484e..b2200a3 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -48,6 +48,7 @@ static struct param { uint32_t size; uint32_t alignment; uint32_t offset; + uint32_t top_aligned; comp_algo algo; } param = { /* All variables not listed are initialized as zero. */ @@ -364,7 +365,9 @@ static int cbfs_create(void) static int cbfs_locate(void) { - uint32_t filesize, location; + struct cbfs_image image; + struct buffer buffer; + int32_t address; if (!param.filename) { ERROR("You need to specify -f/--filename.\n"); @@ -376,13 +379,42 @@ static int cbfs_locate(void) return 1; } - filesize = getfilesize(param.filename); + if (cbfs_image_from_file(&image, param.cbfs_name) != 0) { + ERROR("Failed to load %s.\n", param.cbfs_name); + return 1; + } + + if (buffer_from_file(&buffer, param.filename) != 0) { + ERROR("Cannot load %s.\n", param.filename); + cbfs_image_delete(&image); + return 1; + } + + if (cbfs_get_entry(&image, param.name)) { + ERROR("'%s' already in CBFS.\n", param.name); + buffer_delete(&buffer); + cbfs_image_delete(&image); + return 1; + } + + address = cbfs_locate_entry(&image, param.name, buffer.size, + param.alignment); + if (address == -1) { + ERROR("'%s' can't fit in CBFS for align 0x%x.\n", + param.name, param.alignment); + buffer_delete(&buffer); + cbfs_image_delete(&image); + return 1; + } - location = cbfs_find_location(param.cbfs_name, filesize, - param.name, param.alignment); + if (param.top_aligned) { + address = address - ntohl(image.header->romsize); + } - printf("0x%x\n", location); - return location == 0 ? 1 : 0; + buffer_delete(&buffer); + cbfs_image_delete(&image); + printf("0x%x\n", address); + return 0; } static int cbfs_print(void) @@ -433,7 +465,7 @@ static const struct command commands[] = { {"add-flat-binary", "f:n:l:e:c:b:vh?", cbfs_add_flat_binary}, {"remove", "n:vh?", cbfs_remove}, {"create", "s:B:a:o:m:vh?", cbfs_create}, - {"locate", "f:n:a:vh?", cbfs_locate}, + {"locate", "f:n:a:Tvh?", cbfs_locate}, {"print", "vh?", cbfs_print}, {"extract", "n:f:vh?", cbfs_extract}, }; @@ -462,6 +494,7 @@ static void usage(char *name) ("cbfstool: Management utility for CBFS formatted ROM images\n\n" "USAGE:\n" " %s [-h]\n" " %s FILE COMMAND [-v] [PARAMETERS]...\n\n" "OPTIONs:\n" + " -T Output top-aligned memory address\n" " -v Provide verbose output\n" " -h Display this help message\n\n" "COMMANDs:\n" @@ -478,7 +511,7 @@ static void usage(char *name) "Remove a component\n" " create -s size -B bootblock -m ARCH [-a align] [-o offset] " "Create a ROM file\n" - " locate -f FILE -n NAME -a align " + " locate -f FILE -n NAME [-a align] [-T] " "Find a place for a file of that size\n" " print " "Show the contents of the ROM\n" @@ -579,6 +612,9 @@ int main(int argc, char **argv) case 'f': param.filename = optarg; break; + case 'T': + param.top_aligned = 1; + break; case 'v': verbose++; break;

1 0

Patch set updated for coreboot: a7c73d0 cbfstool: move flat-binary parsing to cbfs-mkpayload.
by Hung-Te Lin 28 Jan '13

28 Jan '13

Hung-Te Lin (hungte(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/2197 -gerrit commit a7c73d0e15ccb8e6a09306a4c0e7d8b18b67008f Author: Hung-Te Lin <hungte(a)chromium.org> Date: Mon Jan 28 15:04:30 2013 +0800 cbfstool: move flat-binary parsing to cbfs-mkpayload. The ELF parsing and payload building in add-flat-binary command should be isolated just like mkpayload and mkstage. Since it's for creating a payload in the end, move payload processing to cbfs-mkpayload.c. To test: cbfstool coreboot.rom add-flat-binary -f u-boot.bin -n fallback/payload \ -l 0x100000 -e 0x100020 To verify, get output from "cbfstool coreboot.rom print -v": fallback/payload 0x73ccc0 payload 124920 INFO: code (no compression, offset: 0x38, load: 0x1110000, length:..) Change-Id: Ia7bd2e6160507c0a1e8e20bc1d08397ce9826e0d Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/cbfs-mkpayload.c | 53 +++++++++++++++++++++++++++++++++++++++ util/cbfstool/cbfstool.c | 57 ++++++++++-------------------------------- util/cbfstool/common.h | 5 ++++ 3 files changed, 71 insertions(+), 44 deletions(-) diff --git a/util/cbfstool/cbfs-mkpayload.c b/util/cbfstool/cbfs-mkpayload.c index da04a75..060e9ee 100644 --- a/util/cbfstool/cbfs-mkpayload.c +++ b/util/cbfstool/cbfs-mkpayload.c @@ -202,3 +202,56 @@ int parse_elf_to_payload(unsigned char *input, unsigned char **output, err: return -1; } + +int parse_flat_binary_to_payload(unsigned char *input, unsigned char **output, + int32_t input_size, + uint32_t loadaddress, + uint32_t entrypoint, + comp_algo algo) +{ + comp_func_ptr compress; + unsigned char *payload; + struct cbfs_payload_segment *segs; + int doffset, len = 0; + + compress = compression_function(algo); + if (!compress) + return -1; + + DEBUG("start: parse_flat_binary_to_payload\n"); + + /* FIXME compressed file size might be bigger than original file and + * causing buffer overflow. */ + payload = calloc((2 * sizeof(struct cbfs_payload_segment)) + input_size, 1); + if (payload == NULL) { + ERROR("Could not allocate memory.\n"); + return -1; + } + + segs = (struct cbfs_payload_segment *)payload; + doffset = (2 * sizeof(*segs)); + + /* Prepare code segment */ + segs[0].type = PAYLOAD_SEGMENT_CODE; + segs[0].load_addr = htonll(loadaddress); + segs[0].mem_len = htonl(input_size); + segs[0].offset = htonl(doffset); + + compress((char*)input, input_size, (char*)payload + doffset, &len); + segs[0].compression = htonl(algo); + segs[0].len = htonl(len); + + if ((unsigned int)len >= input_size) { + WARN("Compressing data would make it bigger - disabled.\n"); + segs[0].compression = 0; + segs[0].len = htonl(input_size); + memcpy(payload + doffset, input, input_size); + } + + /* prepare entry point segment */ + segs[1].type = PAYLOAD_SEGMENT_ENTRY; + segs[1].load_addr = htonll(entrypoint); + *output = payload; + + return doffset + ntohl(segs[0].len); +} diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 2857264..1ad270b 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -234,12 +234,8 @@ static int cbfs_add_stage(void) static int cbfs_add_flat_binary(void) { uint32_t filesize = 0; - uint32_t final_size; void *rom, *filedata, *cbfsfile; unsigned char *payload; - comp_func_ptr compress; - struct cbfs_payload_segment *segs; - int doffset, len = 0; if (!param.filename) { ERROR("You need to specify -f/--filename.\n"); @@ -263,10 +259,6 @@ static int cbfs_add_flat_binary(void) return 1; } - compress = compression_function(param.algo); - if (!compress) - return 1; - rom = loadrom(param.cbfs_name); if (rom == NULL) { ERROR("Could not load ROM image '%s'.\n", @@ -282,47 +274,24 @@ static int cbfs_add_flat_binary(void) return 1; } - /* FIXME compressed file size might be bigger than original file */ - payload = calloc((2 * sizeof(struct cbfs_payload_segment)) + filesize, 1); - if (payload == NULL) { - ERROR("Could not allocate memory.\n"); - free(filedata); + filesize = parse_flat_binary_to_payload(filedata, &payload, + filesize, + param.loadaddress, + param.entrypoint, + param.algo); + free(filedata); + + if ((int)filesize <= 0) { + ERROR("Adding payload '%s' failed.\n", + param.filename); free(rom); return 1; } + cbfsfile = create_cbfs_file(param.name, payload, &filesize, + CBFS_COMPONENT_PAYLOAD, &param.baseaddress); - segs = (struct cbfs_payload_segment *)payload; - doffset = (2 * sizeof(struct cbfs_payload_segment)); - - /* Prepare code segment */ - segs[0].type = PAYLOAD_SEGMENT_CODE; - segs[0].load_addr = (uint64_t)htonll(param.loadaddress); - segs[0].mem_len = (uint32_t)htonl(filesize); - segs[0].offset = (uint32_t)htonl(doffset); - - compress(filedata, filesize, (char *)(payload + doffset), &len); - segs[0].compression = htonl(param.algo); - segs[0].len = htonl(len); - - if ((unsigned int)len >= filesize) { - segs[0].compression = 0; - segs[0].len = htonl(filesize); - memcpy((char *)(payload + doffset), filedata, filesize); - } - - /* prepare entry point segment */ - segs[1].type = PAYLOAD_SEGMENT_ENTRY; - segs[1].load_addr = (uint64_t)htonll(param.entrypoint); - - final_size = doffset + ntohl(segs[0].len); - cbfsfile = - create_cbfs_file(param.name, payload, &final_size, - CBFS_COMPONENT_PAYLOAD, &param.baseaddress); - - free(filedata); free(payload); - - if (add_file_to_cbfs(cbfsfile, final_size, param.baseaddress)) { + if (add_file_to_cbfs(cbfsfile, filesize, param.baseaddress)) { ERROR("Adding payload '%s' failed.\n", param.filename); free(cbfsfile); diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index bb18ee1..bd5ef65 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -72,8 +72,13 @@ comp_func_ptr compression_function(comp_algo algo); uint64_t intfiletype(const char *name); +/* cbfs-mkpayload.c */ int parse_elf_to_payload(unsigned char *input, unsigned char **output, comp_algo algo); +int parse_flat_binary_to_payload(unsigned char *input, unsigned char **output, + int32_t input_size, uint32_t loadaddress, + uint32_t entrypoint, comp_algo algo); +/* cbfs-mkstage.c */ int parse_elf_to_stage(unsigned char *input, unsigned char **output, comp_algo algo, uint32_t * location);

1 0

Patch set updated for coreboot: b389134 cbfstool: Use cbfs_image API for "create" command.
by Hung-Te Lin 28 Jan '13

28 Jan '13

Hung-Te Lin (hungte(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/2214 -gerrit commit b389134bad5fd5899bcb1be911376ab91094f841 Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 09:45:12 2013 +0800 cbfstool: Use cbfs_image API for "create" command. To support platforms with different memory layout, "create" takes two extra optional params: "-b": base address (or offset) for bootblock. When omitted, put bootblock in end of ROM (x86 style). "-H": header offset. When omitted, put header right before bootblock, and update a top-aligned virtual address reference in end of ROM. Example: (can be found in ARM MAkefile): cbfstool coreboot.rom create -m armv7 -s 4096K -B bootblock.bin \ -a 64 -b 0x0000 -H 0x2040 -o 0x5000 Verified to boot on ARM (Snow) and X86 (QEMU). Change-Id: Ida2a9e32f9a459787b577db5e6581550d9d7017b Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- src/arch/armv7/Makefile.inc | 3 +- util/cbfstool/cbfs_image.c | 88 +++++++++++++++++++++++++++++++++++++++++++++ util/cbfstool/cbfs_image.h | 16 +++++++++ util/cbfstool/cbfstool.c | 66 +++++++++++++++++++++++++++++++--- 4 files changed, 168 insertions(+), 5 deletions(-) diff --git a/src/arch/armv7/Makefile.inc b/src/arch/armv7/Makefile.inc index ba734a6..ffa0653 100644 --- a/src/arch/armv7/Makefile.inc +++ b/src/arch/armv7/Makefile.inc @@ -46,9 +46,10 @@ prebuild-files = \ $(if $(call extract_nth,4,$(file)),-b $(call extract_nth,4,$(file))) &&) prebuilt-files = $(foreach file,$(cbfs-files), $(call extract_nth,1,$(file))) +# TODO Change -b, -H, -o to Kconfig variables. $(obj)/coreboot.pre1: $(objcbfs)/bootblock.bin $$(prebuilt-files) $(CBFSTOOL) $(CBFSTOOL) $@.tmp create -m armv7 -s $(CONFIG_COREBOOT_ROMSIZE_KB)K \ - -B $(objcbfs)/bootblock.bin -a 64 + -B $(objcbfs)/bootblock.bin -a 64 -b 0x0000 -H 0x2040 -o 0x5000 $(prebuild-files) true mv $@.tmp $@ else diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index 878a7a1..0fb703c 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -129,6 +129,94 @@ static int cbfs_fix_legacy_size(struct cbfs_image *image) { return 0; } +int cbfs_image_create(struct cbfs_image *image, + uint32_t arch, + size_t size, + uint32_t align, + struct buffer *bootblock, + int32_t bootblock_offset, + int32_t header_offset, + int32_t entries_offset) +{ + struct cbfs_header *header; + struct cbfs_file *entry; + uint32_t cbfs_len; + + 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(*header), entries_offset); + + if (buffer_create(&image->buffer, size, "(new)") != 0) + return -1; + image->header = NULL; + memset(image->buffer.data, CBFS_CONTENT_DEFAULT_VALUE, size); + + // Adjust legcay top-aligned address to ROM offset. + if (IS_TOP_ALIGNED_ADDRESS(entries_offset)) + entries_offset += (int32_t)size; + if (IS_TOP_ALIGNED_ADDRESS(bootblock_offset)) + bootblock_offset += (int32_t)size; + if (IS_TOP_ALIGNED_ADDRESS(header_offset)) + header_offset += (int32_t) size; + + DEBUG("cbfs_create_image: (real offset) bootblock=0x%x, " + "header=0x%x, entries_offset=0x%x\n", + bootblock_offset, header_offset, entries_offset); + + if (align == 0) + align = 64; // default align size. + + // Prepare bootblock + if (bootblock_offset + bootblock->size > size) { + ERROR("Bootblock (0x%x+0x%zx) exceed ROM size (0x%zx)\n", + bootblock_offset, bootblock->size, size); + return -1; + } + memcpy(image->buffer.data + bootblock_offset, bootblock->data, + bootblock->size); + + // Prepare header + if (header_offset + sizeof(*header) > size) { + ERROR("Header (0x%x+0x%zx) exceed ROM size (0x%zx)\n", + header_offset, sizeof(*header), size); + return -1; + } + header = (struct cbfs_header *)(image->buffer.data + header_offset); + image->header = header; + header->magic = htonl(CBFS_HEADER_MAGIC); + header->version = htonl(CBFS_HEADER_VERSION); + header->romsize = htonl(size); + header->bootblocksize = htonl(bootblock->size); + header->align = htonl(align); + header->offset = htonl(entries_offset); + header->architecture = htonl(arch); + + // Prepare entries + if (align_up(entries_offset, align) != entries_offset) { + ERROR("Offset (0x%x) must be aligned to 0x%x.\n", + entries_offset, align); + return -1; + } + if (entries_offset + sizeof(*entry) > size) { + ERROR("Offset (0x%x+0x%zx) exceed ROM size(0x%zx)\n", + entries_offset, sizeof(*entry), size); + return -1; + } + entry = (struct cbfs_file *)(image->buffer.data + entries_offset); + // To calculate available length, find + // e = min(bootblock, header, size) where e > entries_offset. + cbfs_len = size; + if (bootblock_offset > entries_offset && bootblock_offset < cbfs_len) + cbfs_len = bootblock_offset; + if (header_offset > entries_offset && header_offset < cbfs_len) + cbfs_len = header_offset; + cbfs_len -= entries_offset + align; + cbfs_create_empty_entry(image, entry, cbfs_len, ""); + LOG("Created CBFS image (capacity = %d bytes)\n", cbfs_len); + return 0; +} + int cbfs_image_from_file(struct cbfs_image *image, const char *filename) { if (buffer_from_file(&image->buffer, filename) != 0) return -1; diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index 4fce3e5..ba1c342 100644 --- a/util/cbfstool/cbfs_image.h +++ b/util/cbfstool/cbfs_image.h @@ -22,6 +22,8 @@ #include "common.h" #include "cbfs.h" +#define IS_TOP_ALIGNED_ADDRESS(x) ((uint32_t)(x) > 0x80000000) + /* CBFS image processing */ struct cbfs_image { @@ -29,6 +31,20 @@ struct cbfs_image { struct cbfs_header *header; }; +/* 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, + size_t size, + uint32_t align, + struct buffer *bootblock, + int32_t bootblock_offset, + int32_t header_offset, + int32_t entries_offset); + /* Loads a CBFS image from file. Returns 0 on success, otherwise non-zero. */ int cbfs_image_from_file(struct cbfs_image *image, const char *filename); diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index b2200a3..970c93a 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -43,7 +43,10 @@ static struct param { char *bootblock; uint32_t type; uint32_t baseaddress; + uint32_t baseaddress_assigned; uint32_t loadaddress; + uint32_t headeroffset; + uint32_t headeroffset_assigned; uint32_t entrypoint; uint32_t size; uint32_t alignment; @@ -344,23 +347,69 @@ static int cbfs_remove(void) static int cbfs_create(void) { + struct cbfs_image image; + struct buffer bootblock; + if (param.size == 0) { ERROR("You need to specify a valid -s/--size.\n"); return 1; } if (!param.bootblock) { - ERROR("You need to specify -b/--bootblock.\n"); + ERROR("You need to specify -B/--bootblock.\n"); return 1; } + // TODO Remove arch or pack into param. if (arch == CBFS_ARCHITECTURE_UNKNOWN) { ERROR("You need to specify -m/--machine arch\n"); return 1; } - return create_cbfs_image(param.cbfs_name, param.size, param.bootblock, - param.alignment, param.offset); + if (buffer_from_file(&bootblock, param.bootblock) != 0) { + return 1; + } + + // Setup default boot offset and header offset. + if (!param.baseaddress_assigned) { + // put boot block before end of ROM. + param.baseaddress = param.size - bootblock.size; + DEBUG("bootblock in end of ROM.\n"); + } + if (!param.headeroffset_assigned) { + // Put header before bootblock, and make a reference in end of + // bootblock. + param.headeroffset = ( + param.baseaddress - + sizeof(struct cbfs_header)); + if (bootblock.size >= sizeof(uint32_t)) { + // TODO this only works for 32b top-aligned system now... + uint32_t ptr = param.headeroffset - param.size; + uint32_t *sig = (uint32_t *)(bootblock.data + + bootblock.size - + sizeof(ptr)); + *sig = ptr; + DEBUG("CBFS header reference in end of bootblock.\n"); + } + } + + if (cbfs_image_create(&image, + arch, + param.size, + param.alignment, + &bootblock, + param.baseaddress, + param.headeroffset, + param.offset) != 0) { + ERROR("Failed to create %s.\n", param.cbfs_name); + return 1; + } + if (cbfs_image_write_file(&image, param.cbfs_name) != 0) { + ERROR("Failed to write %s.\n", param.cbfs_name); + return 1; + } + cbfs_image_delete(&image); + return 0; } static int cbfs_locate(void) @@ -464,7 +513,7 @@ static const struct command commands[] = { {"add-stage", "f:n:t:c:b:vh?", cbfs_add_stage}, {"add-flat-binary", "f:n:l:e:c:b:vh?", cbfs_add_flat_binary}, {"remove", "n:vh?", cbfs_remove}, - {"create", "s:B:a:o:m:vh?", cbfs_create}, + {"create", "s:B:b:H:a:o:m:vh?", cbfs_create}, {"locate", "f:n:a:Tvh?", cbfs_locate}, {"print", "vh?", cbfs_print}, {"extract", "n:f:vh?", cbfs_extract}, @@ -584,6 +633,10 @@ int main(int argc, char **argv) break; case 'b': param.baseaddress = strtoul(optarg, NULL, 0); + // baseaddress may be zero on non-x86, so we + // need an explicit "baseaddress_assigned". + param.baseaddress = strtoul(optarg, NULL, 0); + param.baseaddress_assigned = 1; break; case 'l': param.loadaddress = strtoul(optarg, NULL, 0); @@ -603,6 +656,11 @@ int main(int argc, char **argv) case 'B': param.bootblock = optarg; break; + case 'H': + param.headeroffset = strtoul( + optarg, NULL, 0); + param.headeroffset_assigned = 1; + break; case 'a': param.alignment = strtoul(optarg, NULL, 0); break;

1 0

Patch set updated for coreboot: 58ca5af cbfstool: Add -v (verbose) output.
by Hung-Te Lin 28 Jan '13

28 Jan '13

Hung-Te Lin (hungte(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/2196 -gerrit commit 58ca5af6f5be3b4e1fc339c5572ac70b39134a9d Author: Hung-Te Lin <hungte(a)chromium.org> Date: Mon Jan 28 14:39:43 2013 +0800 cbfstool: Add -v (verbose) output. Add -v (verbose) to every commands, and allow printing debug messages. Revised logging and debugging functions (fprintf(stderr,...), dprintf...) and verbose message printing with following macros: ERROR(xxx): E: xxx WARN(xxx) W: xxx LOG(xxx) xxx INFO(...) INFO: xxx (only when runs with -v ) DEBUG(...) DEBUG: xxx (only when runs with more than one -v) Example: cbfstool coreboot.rom print -v cbfstool coreboot.rom add -f file -n file -t raw -v -v Normal output (especially for parsing) should use printf, not any of these macros (See usage() and cbfs_locate(), cbfs_print_directory() for example). Change-Id: I167617da1a6eea2b07075b0eb38e3c9d85ea75dc Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/cbfs-mkpayload.c | 4 +- util/cbfstool/cbfs-mkstage.c | 10 ++-- util/cbfstool/cbfstool.c | 109 +++++++++++++++++++++-------------------- util/cbfstool/common.c | 90 ++++++++++++++++------------------ util/cbfstool/common.h | 8 +++ util/cbfstool/compress.c | 2 +- 6 files changed, 114 insertions(+), 109 deletions(-) diff --git a/util/cbfstool/cbfs-mkpayload.c b/util/cbfstool/cbfs-mkpayload.c index 7f01024..da04a75 100644 --- a/util/cbfstool/cbfs-mkpayload.c +++ b/util/cbfstool/cbfs-mkpayload.c @@ -44,13 +44,13 @@ int parse_elf_to_payload(unsigned char *input, unsigned char **output, int i; if(!iself(input)){ - fprintf(stderr, "E: The payload file is not in ELF format!\n"); + ERROR("The payload file is not in ELF format!\n"); return -1; } if (!((ehdr->e_machine == EM_ARM) && (arch == CBFS_ARCHITECTURE_ARMV7)) && !((ehdr->e_machine == EM_386) && (arch == CBFS_ARCHITECTURE_X86))) { - fprintf(stderr, "E: The payload file has the wrong architecture\n"); + ERROR("The payload file has the wrong architecture\n"); return -1; } diff --git a/util/cbfstool/cbfs-mkstage.c b/util/cbfstool/cbfs-mkstage.c index b54af10..ef5182a 100644 --- a/util/cbfstool/cbfs-mkstage.c +++ b/util/cbfstool/cbfs-mkstage.c @@ -64,13 +64,13 @@ int parse_elf_to_stage(unsigned char *input, unsigned char **output, return -1; if (!iself(input)) { - fprintf(stderr, "E: The stage file is not in ELF format!\n"); + ERROR("The stage file is not in ELF format!\n"); return -1; } if (!((ehdr->e_machine == EM_ARM) && (arch == CBFS_ARCHITECTURE_ARMV7)) && !((ehdr->e_machine == EM_386) && (arch == CBFS_ARCHITECTURE_X86))) { - fprintf(stderr, "E: The stage file has the wrong architecture\n"); + ERROR("The stage file has the wrong architecture\n"); return -1; } @@ -126,7 +126,7 @@ int parse_elf_to_stage(unsigned char *input, unsigned char **output, } if (data_end <= data_start) { - fprintf(stderr, "E: data ends before it starts. Make sure the " + ERROR("data ends before it starts. Make sure the " "ELF file is correct and resides in ROM space.\n"); exit(1); } @@ -135,7 +135,7 @@ int parse_elf_to_stage(unsigned char *input, unsigned char **output, buffer = calloc(data_end - data_start, 1); if (buffer == NULL) { - fprintf(stderr, "E: Unable to allocate memory: %m\n"); + ERROR("Unable to allocate memory: %m\n"); return -1; } @@ -165,7 +165,7 @@ int parse_elf_to_stage(unsigned char *input, unsigned char **output, out = calloc(sizeof(struct cbfs_stage) + data_end - data_start, 1); if (out == NULL) { - fprintf(stderr, "E: Unable to allocate memory: %m\n"); + ERROR("Unable to allocate memory: %m\n"); return -1; } diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index cbf1d5e..2857264 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -59,30 +59,30 @@ static int cbfs_add(void) void *rom, *filedata, *cbfsfile; if (!param.filename) { - fprintf(stderr, "E: You need to specify -f/--filename.\n"); + ERROR("You need to specify -f/--filename.\n"); return 1; } if (!param.name) { - fprintf(stderr, "E: You need to specify -n/--name.\n"); + ERROR("You need to specify -n/--name.\n"); return 1; } if (param.type == 0) { - fprintf(stderr, "E: You need to specify a valid -t/--type.\n"); + ERROR("You need to specify a valid -t/--type.\n"); return 1; } rom = loadrom(param.cbfs_name); if (rom == NULL) { - fprintf(stderr, "E: Could not load ROM image '%s'.\n", + ERROR("Could not load ROM image '%s'.\n", param.cbfs_name); return 1; } filedata = loadfile(param.filename, &filesize, 0, SEEK_SET); if (filedata == NULL) { - fprintf(stderr, "E: Could not load file '%s'.\n", + ERROR("Could not load file '%s'.\n", param.filename); free(rom); return 1; @@ -93,7 +93,7 @@ static int cbfs_add(void) free(filedata); if (add_file_to_cbfs(cbfsfile, filesize, param.baseaddress)) { - fprintf(stderr, "E: Adding file '%s' failed.\n", param.filename); + ERROR("Adding file '%s' failed.\n", param.filename); free(cbfsfile); free(rom); return 1; @@ -116,25 +116,25 @@ static int cbfs_add_payload(void) unsigned char *payload; if (!param.filename) { - fprintf(stderr, "E: You need to specify -f/--filename.\n"); + ERROR("You need to specify -f/--filename.\n"); return 1; } if (!param.name) { - fprintf(stderr, "E: You need to specify -n/--name.\n"); + ERROR("You need to specify -n/--name.\n"); return 1; } rom = loadrom(param.cbfs_name); if (rom == NULL) { - fprintf(stderr, "E: Could not load ROM image '%s'.\n", + ERROR("Could not load ROM image '%s'.\n", param.cbfs_name); return 1; } filedata = loadfile(param.filename, &filesize, 0, SEEK_SET); if (filedata == NULL) { - fprintf(stderr, "E: Could not load file '%s'.\n", + ERROR("Could not load file '%s'.\n", param.filename); free(rom); return 1; @@ -142,7 +142,7 @@ static int cbfs_add_payload(void) filesize = parse_elf_to_payload(filedata, &payload, param.algo); if (filesize <= 0) { - fprintf(stderr, "E: Adding payload '%s' failed.\n", + ERROR("Adding payload '%s' failed.\n", param.filename); free(rom); return 1; @@ -155,7 +155,7 @@ static int cbfs_add_payload(void) free(payload); if (add_file_to_cbfs(cbfsfile, filesize, param.baseaddress)) { - fprintf(stderr, "E: Adding payload '%s' failed.\n", + ERROR("Adding payload '%s' failed.\n", param.filename); free(cbfsfile); free(rom); @@ -180,25 +180,25 @@ static int cbfs_add_stage(void) unsigned char *stage; if (!param.filename) { - fprintf(stderr, "E: You need to specify -f/--filename.\n"); + ERROR("You need to specify -f/--filename.\n"); return 1; } if (!param.name) { - fprintf(stderr, "E: You need to specify -n/--name.\n"); + ERROR("You need to specify -n/--name.\n"); return 1; } rom = loadrom(param.cbfs_name); if (rom == NULL) { - fprintf(stderr, "E: Could not load ROM image '%s'.\n", + ERROR("Could not load ROM image '%s'.\n", param.cbfs_name); return 1; } filedata = loadfile(param.filename, &filesize, 0, SEEK_SET); if (filedata == NULL) { - fprintf(stderr, "E: Could not load file '%s'.\n", + ERROR("Could not load file '%s'.\n", param.filename); free(rom); return 1; @@ -213,7 +213,7 @@ static int cbfs_add_stage(void) free(stage); if (add_file_to_cbfs(cbfsfile, filesize, param.baseaddress)) { - fprintf(stderr, "E: Adding stage '%s' failed.\n", + ERROR("Adding stage '%s' failed.\n", param.filename); free(cbfsfile); free(rom); @@ -242,23 +242,23 @@ static int cbfs_add_flat_binary(void) int doffset, len = 0; if (!param.filename) { - fprintf(stderr, "E: You need to specify -f/--filename.\n"); + ERROR("You need to specify -f/--filename.\n"); return 1; } if (!param.name) { - fprintf(stderr, "E: You need to specify -n/--name.\n"); + ERROR("You need to specify -n/--name.\n"); return 1; } if (param.loadaddress == 0) { - fprintf(stderr, "E: You need to specify a valid " + ERROR("You need to specify a valid " "-l/--load-address.\n"); return 1; } if (param.entrypoint == 0) { - fprintf(stderr, "E: You need to specify a valid " + ERROR("You need to specify a valid " "-e/--entry-point.\n"); return 1; } @@ -269,14 +269,14 @@ static int cbfs_add_flat_binary(void) rom = loadrom(param.cbfs_name); if (rom == NULL) { - fprintf(stderr, "E: Could not load ROM image '%s'.\n", + ERROR("Could not load ROM image '%s'.\n", param.cbfs_name); return 1; } filedata = loadfile(param.filename, &filesize, 0, SEEK_SET); if (filedata == NULL) { - fprintf(stderr, "E: Could not load file '%s'.\n", + ERROR("Could not load file '%s'.\n", param.filename); free(rom); return 1; @@ -285,7 +285,7 @@ static int cbfs_add_flat_binary(void) /* FIXME compressed file size might be bigger than original file */ payload = calloc((2 * sizeof(struct cbfs_payload_segment)) + filesize, 1); if (payload == NULL) { - fprintf(stderr, "E: Could not allocate memory.\n"); + ERROR("Could not allocate memory.\n"); free(filedata); free(rom); return 1; @@ -323,7 +323,7 @@ static int cbfs_add_flat_binary(void) free(payload); if (add_file_to_cbfs(cbfsfile, final_size, param.baseaddress)) { - fprintf(stderr, "E: Adding payload '%s' failed.\n", + ERROR("Adding payload '%s' failed.\n", param.filename); free(cbfsfile); free(rom); @@ -345,19 +345,19 @@ static int cbfs_remove(void) void *rom; if (!param.name) { - fprintf(stderr, "E: You need to specify -n/--name.\n"); + ERROR("You need to specify -n/--name.\n"); return 1; } rom = loadrom(param.cbfs_name); if (rom == NULL) { - fprintf(stderr, "E: Could not load ROM image '%s'.\n", + ERROR("Could not load ROM image '%s'.\n", param.cbfs_name); return 1; } if (remove_file_from_cbfs(param.name)) { - fprintf(stderr, "E: Removing file '%s' failed.\n", + ERROR("Removing file '%s' failed.\n", param.name); free(rom); return 1; @@ -375,17 +375,17 @@ static int cbfs_remove(void) static int cbfs_create(void) { if (param.size == 0) { - fprintf(stderr, "E: You need to specify a valid -s/--size.\n"); + ERROR("You need to specify a valid -s/--size.\n"); return 1; } if (!param.bootblock) { - fprintf(stderr, "E: You need to specify -b/--bootblock.\n"); + ERROR("You need to specify -b/--bootblock.\n"); return 1; } if (arch == CBFS_ARCHITECTURE_UNKNOWN) { - fprintf(stderr, "E: You need to specify -m/--machine arch\n"); + ERROR("You need to specify -m/--machine arch\n"); return 1; } @@ -398,12 +398,12 @@ static int cbfs_locate(void) uint32_t filesize, location; if (!param.filename) { - fprintf(stderr, "E: You need to specify -f/--filename.\n"); + ERROR("You need to specify -f/--filename.\n"); return 1; } if (!param.name) { - fprintf(stderr, "E: You need to specify -n/--name.\n"); + ERROR("You need to specify -n/--name.\n"); return 1; } @@ -422,7 +422,7 @@ static int cbfs_print(void) rom = loadrom(param.cbfs_name); if (rom == NULL) { - fprintf(stderr, "E: Could not load ROM image '%s'.\n", + ERROR("Could not load ROM image '%s'.\n", param.cbfs_name); return 1; } @@ -439,18 +439,18 @@ static int cbfs_extract(void) int ret; if (!param.filename) { - fprintf(stderr, "E: You need to specify -f/--filename.\n"); + ERROR("You need to specify -f/--filename.\n"); return 1; } if (!param.name) { - fprintf(stderr, "E: You need to specify -n/--name.\n"); + ERROR("You need to specify -n/--name.\n"); return 1; } rom = loadrom(param.cbfs_name); if (rom == NULL) { - fprintf(stderr, "E: Could not load ROM image '%s'.\n", + ERROR("Could not load ROM image '%s'.\n", param.cbfs_name); return 1; } @@ -462,15 +462,15 @@ static int cbfs_extract(void) } static const struct command commands[] = { - {"add", "f:n:t:b:h?", cbfs_add}, - {"add-payload", "f:n:t:c:b:h?", cbfs_add_payload}, - {"add-stage", "f:n:t:c:b:h?", cbfs_add_stage}, - {"add-flat-binary", "f:n:l:e:c:b:h?", cbfs_add_flat_binary}, - {"remove", "n:h?", cbfs_remove}, - {"create", "s:B:a:o:m:h?", cbfs_create}, - {"locate", "f:n:a:h?", cbfs_locate}, - {"print", "h?", cbfs_print}, - {"extract", "n:f:h?", cbfs_extract}, + {"add", "f:n:t:b:vh?", cbfs_add}, + {"add-payload", "f:n:t:c:b:vh?", cbfs_add_payload}, + {"add-stage", "f:n:t:c:b:vh?", cbfs_add_stage}, + {"add-flat-binary", "f:n:l:e:c:b:vh?", cbfs_add_flat_binary}, + {"remove", "n:vh?", cbfs_remove}, + {"create", "s:B:a:o:m:vh?", cbfs_create}, + {"locate", "f:n:a:vh?", cbfs_locate}, + {"print", "vh?", cbfs_print}, + {"extract", "n:f:vh?", cbfs_extract}, }; static struct option long_options[] = { @@ -496,8 +496,9 @@ static void usage(char *name) printf ("cbfstool: Management utility for CBFS formatted ROM images\n\n" "USAGE:\n" " %s [-h]\n" - " %s FILE COMMAND [PARAMETERS]...\n\n" "OPTIONs:\n" - " -h Display this help message\n\n" + " %s FILE COMMAND [-v] [PARAMETERS]...\n\n" "OPTIONs:\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 a component\n" @@ -570,8 +571,8 @@ int main(int argc, char **argv) /* filter out illegal long options */ if (strchr(commands[i].optstring, c) == NULL) { /* TODO maybe print actual long option instead */ - printf("%s: invalid option -- '%c'\n", - argv[0], c); + ERROR("%s: invalid option -- '%c'\n", + argv[0], c); c = '?'; } @@ -585,7 +586,7 @@ int main(int argc, char **argv) else param.type = strtoul(optarg, NULL, 0); if (param.type == 0) - printf("W: Unknown type '%s' ignored\n", + WARN("Unknown type '%s' ignored\n", optarg); break; case 'c': @@ -594,8 +595,8 @@ int main(int argc, char **argv) else if (!strncasecmp(optarg, "none", 5)) param.algo = CBFS_COMPRESS_NONE; else - printf("W: Unknown compression '%s'" - " ignored.\n", optarg); + WARN("Unknown compression '%s'" + " ignored.\n", optarg); break; case 'b': param.baseaddress = strtoul(optarg, NULL, 0); @@ -645,7 +646,7 @@ int main(int argc, char **argv) return commands[i].function(); } - printf("Unknown command '%s'.\n", cmd); + ERROR("Unknown command '%s'.\n", cmd); usage(argv[0]); return 1; } diff --git a/util/cbfstool/common.c b/util/cbfstool/common.c index 97bf168..8b4b4b4 100644 --- a/util/cbfstool/common.c +++ b/util/cbfstool/common.c @@ -27,8 +27,6 @@ #include "cbfs.h" #include "elf.h" -#define dprintf(x...) - size_t getfilesize(const char *filename) { size_t size; @@ -55,15 +53,15 @@ void *loadfile(const char *filename, uint32_t * romsize_p, void *content, if (!content) { content = malloc(*romsize_p); if (!content) { - fprintf(stderr, "E: Could not get %d bytes for file %s\n", - *romsize_p, filename); + ERROR("Could not get %d bytes for file %s\n", + *romsize_p, filename); exit(1); } } else if (place == SEEK_END) content -= *romsize_p; if (!fread(content, *romsize_p, 1, file)) { - fprintf(stderr, "E: Failed to read %s\n", filename); + ERROR("Failed to read %s\n", filename); return NULL; } fclose(file); @@ -138,14 +136,14 @@ int find_master_header(void *romarea, size_t size) void recalculate_rom_geometry(void *romarea) { if (find_master_header(romarea, romsize)) { - fprintf(stderr, "E: Cannot find master header\n"); + ERROR("Cannot find master header\n"); exit(1); } /* Update old headers */ if (master_header->version == CBFS_HEADER_VERSION1 && ntohl(master_header->architecture) == CBFS_ARCHITECTURE_UNKNOWN) { - dprintf("Updating CBFS master header to version 2\n"); + DEBUG("Updating CBFS master header to version 2\n"); master_header->architecture = htonl(CBFS_ARCHITECTURE_X86); } @@ -165,7 +163,7 @@ void recalculate_rom_geometry(void *romarea) sizeof(struct cbfs_header)) & 0xffffffff; break; default: - fprintf(stderr, "E: Unknown architecture\n"); + ERROR("Unknown architecture\n"); exit(1); } @@ -185,13 +183,13 @@ int writerom(const char *filename, void *start, uint32_t size) { FILE *file = fopen(filename, "wb"); if (!file) { - fprintf(stderr, "Could not open '%s' for writing: ", filename); + ERROR("Could not open '%s' for writing: ", filename); perror(""); return 1; } if (fwrite(start, size, 1, file) != 1) { - fprintf(stderr, "Could not write to '%s': ", filename); + ERROR("Could not write to '%s': ", filename); perror(""); return 1; } @@ -247,9 +245,9 @@ void print_supported_filetypes(void) int i, number = ARRAY_SIZE(filetypes); for (i=0; i<number; i++) { - printf(" %s%c", filetypes[i].name, (i==(number-1))?'\n':','); + LOG(" %s%c", filetypes[i].name, (i==(number-1))?'\n':','); if ((i%8) == 7) - printf("\n"); + LOG("\n"); } } @@ -273,11 +271,12 @@ uint64_t intfiletype(const char *name) void print_cbfs_directory(const char *filename) { - printf - ("%s: %d kB, bootblocksize %d, romsize %d, offset 0x%x\n" - "alignment: %d bytes, architecture: %s\n\n", - basename((char *)filename), romsize / 1024, ntohl(master_header->bootblocksize), - romsize, ntohl(master_header->offset), align, arch_to_string(arch)); + printf("%s: %d kB, bootblocksize %d, romsize %d, offset 0x%x\n" + "alignment: %d bytes, architecture: %s\n\n", + basename((char *)filename), romsize / 1024, + ntohl(master_header->bootblocksize), + romsize, ntohl(master_header->offset), align, + arch_to_string(arch)); printf("%-30s %-10s %-12s Size\n", "Name", "Offset", "Type"); uint32_t current = phys_start; while (current < phys_end) { @@ -301,7 +300,7 @@ void print_cbfs_directory(const char *filename) case CBFS_COMPONENT_STAGE: { struct cbfs_stage *stage = CBFS_SUBHEADER(thisfile); - dprintf(" %s compression, entry: 0x%llx, load: 0x%llx, length: %d/%d\n", + INFO(" %s compression, entry: 0x%llx, load: 0x%llx, length: %d/%d\n", stage->compression == CBFS_COMPRESS_LZMA ? "LZMA" : "no", (unsigned long long)stage->entry, (unsigned long long)stage->load, @@ -316,7 +315,7 @@ void print_cbfs_directory(const char *filename) switch(payload->type) { case PAYLOAD_SEGMENT_CODE: case PAYLOAD_SEGMENT_DATA: - dprintf(" %s (%s compression, offset: 0x%x, load: 0x%llx, length: %d/%d)\n", + INFO(" %s (%s compression, offset: 0x%x, load: 0x%llx, length: %d/%d)\n", payload->type == PAYLOAD_SEGMENT_CODE ? "code " : "data" , payload->compression == CBFS_COMPRESS_LZMA ? "LZMA" : "no", ntohl(payload->offset), @@ -324,16 +323,16 @@ void print_cbfs_directory(const char *filename) ntohl(payload->len), ntohl(payload->mem_len)); break; case PAYLOAD_SEGMENT_ENTRY: - dprintf(" entry (0x%llx)\n", (unsigned long long)ntohll(payload->load_addr)); + INFO(" entry (0x%llx)\n", (unsigned long long)ntohll(payload->load_addr)); break; case PAYLOAD_SEGMENT_BSS: - dprintf(" BSS (address 0x%016llx, length 0x%x)\n", (unsigned long long)ntohll(payload->load_addr), ntohl(payload->len)); + INFO(" BSS (address 0x%016llx, length 0x%x)\n", (unsigned long long)ntohll(payload->load_addr), ntohl(payload->len)); break; case PAYLOAD_SEGMENT_PARAMS: - dprintf(" parameters\n"); + INFO(" parameters\n"); break; default: - dprintf(" %x (%s compression, offset: 0x%x, load: 0x%llx, length: %d/%d\n", + INFO(" %x (%s compression, offset: 0x%x, load: 0x%llx, length: %d/%d\n", payload->type, payload->compression == CBFS_COMPRESS_LZMA ? "LZMA" : "no", ntohl(payload->offset), @@ -387,7 +386,7 @@ int extract_file_from_cbfs(const char *filename, const char *payloadname, const } // Else, it's our file. - printf("Found file %.30s at 0x%x, type %.12s, size %d\n", fname, + LOG("Found file %.30s at 0x%x, type %.12s, size %d\n", fname, current - phys_start, strfiletype(ntohl(thisfile->type)), length); @@ -395,25 +394,25 @@ int extract_file_from_cbfs(const char *filename, const char *payloadname, const outfile = fopen(outpath, "wb"); if (!outfile) { - fprintf(stderr, "E: Could not open the file %s for writing.\n", outpath); + ERROR("Could not open the file %s for writing.\n", outpath); return 1; } if (ntohl(thisfile->type) != CBFS_COMPONENT_RAW) { - fprintf(stderr, "W: Only 'raw' files are safe to extract.\n"); + WARN("Only 'raw' files are safe to extract.\n"); } fwrite(((char *)thisfile) + ntohl(thisfile->offset), length, 1, outfile); fclose(outfile); - printf("Successfully dumped the file.\n"); + LOG("Successfully dumped the file.\n"); // We'll only dump one file. return 0; } - fprintf(stderr, "E: File %s not found.\n", payloadname); + ERROR("File %s not found.\n", payloadname); return 1; } @@ -430,18 +429,17 @@ int add_file_to_cbfs(void *content, uint32_t contentsize, uint32_t location) (struct cbfs_file *)phys_to_virt(current); uint32_t length = ntohl(thisfile->len); - dprintf("at %x, %x bytes\n", current, length); + DEBUG("at %x, %x bytes\n", current, length); /* Is this a free chunk? */ if ((thisfile->type == CBFS_COMPONENT_DELETED) || (thisfile->type == CBFS_COMPONENT_NULL)) { - dprintf("null||deleted at %x, %x bytes\n", current, + DEBUG("null||deleted at %x, %x bytes\n", current, length); /* if this is the right size, and if specified, the right location, use it */ if ((contentsize <= length) && ((location == 0) || (current == location))) { if (contentsize < length) { - dprintf - ("this chunk is %x bytes, we need %x. create a new chunk at %x with %x bytes\n", + DEBUG("this chunk is %x bytes, we need %x. create a new chunk at %x with %x bytes\n", length, contentsize, ALIGN(current + contentsize, align), @@ -454,7 +452,7 @@ int add_file_to_cbfs(void *content, uint32_t contentsize, uint32_t location) sizeof(struct cbfs_file); cbfs_create_empty_file(start, size); } - dprintf("copying data\n"); + DEBUG("copying data\n"); memcpy(phys_to_virt(current), content, contentsize); return 0; @@ -463,8 +461,7 @@ int add_file_to_cbfs(void *content, uint32_t contentsize, uint32_t location) /* CBFS has the constraint that the chain always moves up in memory. so once we're past the place we seek, we don't need to look any further */ if (current > location) { - fprintf - (stderr, "E: The requested space is not available\n"); + ERROR("The requested space is not available\n"); return 1; } @@ -473,7 +470,7 @@ int add_file_to_cbfs(void *content, uint32_t contentsize, uint32_t location) && ((location + contentsize) <= (current + length))) { /* Split it up. In the next iteration the code will be at the right place. */ - dprintf("split up. new length: %x\n", + DEBUG("split up. new length: %x\n", location - current - ntohl(thisfile->offset)); thisfile->len = @@ -490,8 +487,8 @@ int add_file_to_cbfs(void *content, uint32_t contentsize, uint32_t location) ALIGN(current + ntohl(thisfile->len) + ntohl(thisfile->offset), align); } - fprintf(stderr, "E: Could not add the file to CBFS, it's probably too big.\n"); - fprintf(stderr, "E: File size: %d bytes (%d KB).\n", contentsize, contentsize/1024); + ERROR("Could not add the file to CBFS, it's probably too big.\n"); + ERROR("File size: %d bytes (%d KB).\n", contentsize, contentsize/1024); return 1; } @@ -546,7 +543,7 @@ int remove_file_from_cbfs(const char *filename) return 0; } - fprintf(stderr, "E: CBFS file %s not found.\n", filename); + ERROR("CBFS file %s not found.\n", filename); return 1; } @@ -572,7 +569,7 @@ void *create_cbfs_file(const char *filename, void *data, uint32_t * datasize, } void *newdata = malloc(*datasize + headersize); if (!newdata) { - fprintf(stderr, "E: Could not get %d bytes for CBFS file.\n", *datasize + + ERROR("Could not get %d bytes for CBFS file.\n", *datasize + headersize); exit(1); } @@ -599,7 +596,7 @@ int create_cbfs_image(const char *romfile, uint32_t _romsize, romsize = _romsize; romarea = malloc(romsize); if (!romarea) { - fprintf(stderr, "E: Could not get %d bytes of memory" + ERROR("Could not get %d bytes of memory" " for CBFS image.\n", romsize); exit(1); } @@ -611,7 +608,7 @@ int create_cbfs_image(const char *romfile, uint32_t _romsize, bootblk = loadfile(bootblock, &bootblocksize, romarea + romsize, SEEK_END); if (!bootblk) { - fprintf(stderr, "E: Could not load bootblock %s.\n", + ERROR("Could not load bootblock %s.\n", bootblock); free(romarea); return 1; @@ -641,8 +638,8 @@ int create_cbfs_image(const char *romfile, uint32_t _romsize, if (*(uint32_t *)p == 0xdeadbeef) break; if (p >= (romarea + _romsize)) { - fprintf(stderr, "E: Could not determine CBFS " - "header location.\n", bootblock); + ERROR("Could not determine CBFS " + "header location.\n"); return 1; } p += (sizeof(unsigned int)); @@ -700,7 +697,7 @@ int create_cbfs_image(const char *romfile, uint32_t _romsize, default: // Should not happen. - fprintf(stderr, "E: You found a bug in cbfstool.\n"); + ERROR("You found a bug in cbfstool.\n"); exit(1); } @@ -724,8 +721,7 @@ uint32_t cbfs_find_location(const char *romfile, uint32_t filesize, rom = loadrom(romfile); if (rom == NULL) { - fprintf(stderr, "E: Could not load ROM image '%s'.\n", - romfile); + ERROR("Could not load ROM image '%s'.\n", romfile); return 0; } diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index 853e529..bb18ee1 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -29,6 +29,14 @@ #define ntohll(x) (host_bigendian?(x):swab64(x)) #define htonll(x) (host_bigendian?(x):swab64(x)) +/* Message output */ +extern int verbose; +#define ERROR(x...) { fprintf(stderr, "E: " x); } +#define WARN(x...) { fprintf(stderr, "W: " x); } +#define LOG(x...) { fprintf(stderr, x); } +#define INFO(x...) { if (verbose > 0) fprintf(stderr, "INFO: " x); } +#define DEBUG(x...) { if (verbose > 1) fprintf(stderr, "DEBUG: " x); } + extern void *offset; extern uint32_t romsize; extern int host_bigendian; diff --git a/util/cbfstool/compress.c b/util/cbfstool/compress.c index 2222dab..22f3020 100644 --- a/util/cbfstool/compress.c +++ b/util/cbfstool/compress.c @@ -50,7 +50,7 @@ comp_func_ptr compression_function(comp_algo algo) compress = lzma_compress; break; default: - fprintf(stderr, "E: Unknown compression algorithm %d!\n", algo); + ERROR("Unknown compression algorithm %d!\n", algo); return NULL; } return compress;

1 0

Patch set updated for coreboot: 912d261 cbfstool: Use cbfs_image API for "remove" command.
by Hung-Te Lin 28 Jan '13

28 Jan '13

Hung-Te Lin (hungte(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/2208 -gerrit commit 912d261eb45feda6a6173c07c64f21f642f8ae90 Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 02:38:40 2013 +0800 cbfstool: Use cbfs_image API for "remove" command. To delete a component from existing CBFS ROM image. To test: cbfstool coreboot.rom remove -n fallback/romstage # and compare with old cbfstool output result. Change-Id: If39ef9be0b34d8e3df77afb6c9f944e02f08bc4e Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/cbfs_image.c | 30 ++++++++++++++++++++++++++++++ util/cbfstool/cbfs_image.h | 3 +++ util/cbfstool/cbfstool.c | 21 ++++++++++----------- 3 files changed, 43 insertions(+), 11 deletions(-) diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index 4e2c8a9..24759c9 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -97,6 +97,13 @@ uint32_t get_cbfs_compression(const char *name, uint32_t unknown) { return lookup_type_by_name(types_cbfs_compression, name, unknown); } +/* CBFS image */ + +static int cbfs_calculate_file_header_size(const char *name) { + return (sizeof(struct cbfs_file) + + align_up(strlen(name) + 1, CBFS_FILENAME_ALIGN)); +} + int cbfs_image_from_file(struct cbfs_image *image, const char *filename) { if (buffer_from_file(&image->buffer, filename) != 0) return -1; @@ -165,6 +172,29 @@ int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, return 0; } +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); + if (!entry) { + ERROR("CBFS file %s not found.\n", name); + return -1; + } + next = cbfs_find_next_entry(image, entry); + assert(next); + 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; +} + int cbfs_print_header_info(struct cbfs_image *image) { assert(image && image->header); printf("%s: %zd kB, bootblocksize %d, romsize %d, offset 0x%x\n" diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index 1be2a66..e9f64a4 100644 --- a/util/cbfstool/cbfs_image.h +++ b/util/cbfstool/cbfs_image.h @@ -46,6 +46,9 @@ struct cbfs_file *cbfs_get_entry(struct cbfs_image *image, const char *name); int cbfs_export_entry(struct cbfs_image *image, const char *entry_name, const char *filename); +/* Removes an entry from CBFS image. Returns 0 on success, otherwise non-zero. */ +int cbfs_remove_entry(struct cbfs_image *image, const char *name); + /* Callback function used by cbfs_walk. * Returns 0 on success, or non-zero to stop further iteration. */ typedef int (*cbfs_entry_callback)(struct cbfs_image *image, diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index 9d22552..2ae484e 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -312,34 +312,33 @@ static int cbfs_add_flat_binary(void) static int cbfs_remove(void) { - void *rom; + int result = 1; + struct cbfs_image image; if (!param.name) { ERROR("You need to specify -n/--name.\n"); return 1; } - rom = loadrom(param.cbfs_name); - if (rom == NULL) { + if (cbfs_image_from_file(&image, param.cbfs_name) != 0) { ERROR("Could not load ROM image '%s'.\n", param.cbfs_name); return 1; } - if (remove_file_from_cbfs(param.name)) { + if (cbfs_remove_entry(&image, param.name) != 0) { ERROR("Removing file '%s' failed.\n", - param.name); - free(rom); + param.name); + cbfs_image_delete(&image); return 1; } - - if (writerom(param.cbfs_name, rom, romsize)) { - free(rom); + if (cbfs_image_write_file(&image, param.cbfs_name) != 0) { + cbfs_image_delete(&image); return 1; } - free(rom); - return 0; + cbfs_image_delete(&image); + return result; } static int cbfs_create(void)

1 0

Patch set updated for coreboot: ea76535 cbfstool: Add cbfs_image new CBFS image manipulation API.
by Hung-Te Lin 28 Jan '13

28 Jan '13

Hung-Te Lin (hungte(a)chromium.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/2194 -gerrit commit ea76535169f4eadeb22ad6c3cc07b5843ab16754 Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 01:56:17 2013 +0800 cbfstool: Add cbfs_image new CBFS image manipulation API. Current cbfstool implementation is relying on global variables to pass some processed data, and the calculation of address is based on x86 architecture, not easy to be used on platforms without top-aligned memory mapping. This CL is a first step to start a new cbfstool without global variables, and to prevent having everything layout in x86 mode. The first published APIs are for reading and writing existing CBFS ROM image files (and to find file entries in a ROM file). Read cbfs_image.h for detail usage of each API function. Change-Id: I28c737c8f290e51332119188248ac9e28042024c Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/Makefile | 2 +- util/cbfstool/Makefile.inc | 1 + util/cbfstool/cbfs.h | 2 + util/cbfstool/cbfs_image.c | 128 +++++++++++++++++++++++++++++++++++++++++++++ util/cbfstool/cbfs_image.h | 65 +++++++++++++++++++++++ 5 files changed, 197 insertions(+), 1 deletion(-) diff --git a/util/cbfstool/Makefile b/util/cbfstool/Makefile index 17b00a7..3ace744 100644 --- a/util/cbfstool/Makefile +++ b/util/cbfstool/Makefile @@ -7,7 +7,7 @@ CFLAGS += -D_7ZIP_ST BINARY:=$(obj)/cbfstool -COMMON:=cbfstool.o common.o compress.o +COMMON:=cbfstool.o common.o cbfs_image.o compress.o COMMON+=cbfs-mkstage.o cbfs-mkpayload.o # LZMA COMMON+=lzma/lzma.o diff --git a/util/cbfstool/Makefile.inc b/util/cbfstool/Makefile.inc index 5795507..2cee794 100644 --- a/util/cbfstool/Makefile.inc +++ b/util/cbfstool/Makefile.inc @@ -2,6 +2,7 @@ cbfsobj := cbfsobj += cbfstool.o cbfsobj += common.o cbfsobj += compress.o +cbfsobj += cbfs_image.o cbfsobj += cbfs-mkstage.o cbfsobj += cbfs-mkpayload.o # LZMA diff --git a/util/cbfstool/cbfs.h b/util/cbfstool/cbfs.h index 3dbeefd..4a3ff94 100644 --- a/util/cbfstool/cbfs.h +++ b/util/cbfstool/cbfs.h @@ -42,6 +42,8 @@ struct cbfs_header { #define CBFS_ARCHITECTURE_X86 0x00000001 #define CBFS_ARCHITECTURE_ARMV7 0x00000010 +#define CBFS_FILE_MAGIC "LARCHIVE" + struct cbfs_file { uint8_t magic[8]; uint32_t len; diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c new file mode 100644 index 0000000..569d108 --- /dev/null +++ b/util/cbfstool/cbfs_image.c @@ -0,0 +1,128 @@ +/* + * CBFS Image Manipulation + * + * Copyright (C) 2013 The ChromiumOS Authors. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "common.h" +#include "cbfs_image.h" + +/* The file name align is not defined in CBFS spec -- only a preference by + * (old) cbfstool. */ +#define CBFS_FILENAME_ALIGN (16) + +/* To make CBFS more friendly to ROM, fill -1 (0xFF) instead of zero. */ +#define CBFS_CONTENT_DEFAULT_VALUE (-1) + +static uint32_t align_up(uint32_t value, uint32_t align) { + if (value % align) + value += align - (value % align); + return value; +} + +int cbfs_image_from_file(struct cbfs_image *image, const char *filename) { + if (buffer_from_file(&image->buffer, filename) != 0) + return -1; + DEBUG("read_cbfs_image: %s (%zd bytes)\n", image->buffer.name, + image->buffer.size); + image->header = cbfs_find_header(image->buffer.data, + image->buffer.size); + if (!image->header) { + ERROR("%s does not have CBFS master header.\n", filename); + cbfs_image_delete(image); + return -1; + } + + return 0; +} + +int cbfs_image_write_file(struct cbfs_image *image, const char *filename) { + assert(image && image->buffer.data); + return buffer_write_file(&image->buffer, filename); +} + +int cbfs_image_delete(struct cbfs_image *image) { + buffer_delete(&image->buffer); + image->header = NULL; + return 0; +} + +struct cbfs_header *cbfs_find_header(char *data, size_t size) { + size_t offset; + int found = 0; + uint32_t x86sig; + struct cbfs_header *header, *result = NULL; + + // Try x86 style (check signature in bottom) header first. + x86sig = *(uint32_t *)(data + size - sizeof(uint32_t)); + offset = (x86sig + (uint32_t)size); + DEBUG("x86sig: 0x%x, offset: 0x%zx\n", x86sig, offset); + if (offset >= size - sizeof(*header) || + ntohl(((struct cbfs_header *)(data + offset))->magic) != + CBFS_HEADER_MAGIC) + offset = 0; + + for (; offset + sizeof(*header) < size; offset++) { + header = (struct cbfs_header *)(data + offset); + if (ntohl(header->magic) !=(CBFS_HEADER_MAGIC)) + continue; + if (ntohl(header->version) != CBFS_HEADER_VERSION1 && + ntohl(header->version) != CBFS_HEADER_VERSION2) { + // Probably not a real CBFS header? + continue; + } + found++; + result = header; + } + if (found > 1) { + ERROR("multiple (%d) CBFS headers found!\n", + found); + result = NULL; + } + return result; +} + + +struct cbfs_file *cbfs_find_first_entry(struct cbfs_image *image) { + assert(image && image->header); + return (struct cbfs_file *)(image->buffer.data + + ntohl(image->header->offset)); +} + +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 = ntohl(image->header->align); + assert(entry && cbfs_is_valid_entry(entry)); + addr += ntohl(entry->offset) + ntohl(entry->len); + addr = align_up(addr, align); + return (struct cbfs_file *)(image->buffer.data + addr); +} + +uint32_t cbfs_get_entry_addr(struct cbfs_image *image, struct cbfs_file *entry) { + assert(image && image->buffer.data && entry); + return (int32_t)((char *)entry - image->buffer.data); +} + +int cbfs_is_valid_entry(struct cbfs_file *entry) { + return (entry &&memcmp(entry->magic, CBFS_FILE_MAGIC, + sizeof(entry->magic)) == 0); +} + diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h new file mode 100644 index 0000000..617a716 --- /dev/null +++ b/util/cbfstool/cbfs_image.h @@ -0,0 +1,65 @@ +/* + * CBFS Image Manipulation + * + * Copyright (C) 2013 The ChromiumOS Authors. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA + */ + +#ifndef __CBFS_IMAGE_H +#define __CBFS_IMAGE_H +#include "common.h" +#include "cbfs.h" + +/* CBFS image processing */ + +struct cbfs_image { + struct buffer buffer; + struct cbfs_header *header; +}; + +/* Loads a CBFS image from file. Returns 0 on success, otherwise non-zero. */ +int cbfs_image_from_file(struct cbfs_image *image, const char *filename); + +/* Writes a CBFS image into file. Returns 0 on success, otherwise non-zero. */ +int cbfs_image_write_file(struct cbfs_image *image, const char *filename); + +/* Releases the CBFS image. Returns 0 on success, otherwise non-zero. */ +int cbfs_image_delete(struct cbfs_image *image); + +/* Primitive CBFS utilities */ + +/* Returns a pointer to the only valid CBFS header in give buffer, otherwise + * NULL (including when multiple headers were found). If there is a X86 ROM + * style signature (pointer at 0xfffffffc) found in ROM, it will be selected as + * the only header.*/ +struct cbfs_header *cbfs_find_header(char *data, size_t size); + +/* Returns the first cbfs_file entry in CBFS image by CBFS header (no matter if + * the entry has valid content or not), otherwise NULL. */ +struct cbfs_file *cbfs_find_first_entry(struct cbfs_image *image); + +/* Returns next cbfs_file entry (no matter if its content is valid or not), or + * NULL on failure. */ +struct cbfs_file *cbfs_find_next_entry(struct cbfs_image *image, + struct cbfs_file *entry); + +/* Returns ROM address (offset) of entry. + * 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 entry has valid data (by checking magic number), otherwise 0. */ +int cbfs_is_valid_entry(struct cbfs_file *entry); + +#endif

1 0

← Newer
1
...
9
10
11
12
13
14
15
...
61
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

coreboot January 2013