coreboot January 2013

coreboot@coreboot.org

32 participants
607 discussions

New patch to review for coreboot: 1c0e1ed cbfstool: Update example file.
by Hung-Te Lin 29 Jan '13

29 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/2215 -gerrit commit 1c0e1edcc67aaf9d6d9ed44b423c78fb12494bf0 Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 10:30:17 2013 +0800 cbfstool: Update example file. The syntax of cbfstool has been changed for a while. Updated EXAMPLE file to show the right way to test cbfstool. Change-Id: I5cb41b76712d8c2403fffc9fdad83c61fb2af98c Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/EXAMPLE | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/util/cbfstool/EXAMPLE b/util/cbfstool/EXAMPLE index 0f7aea6..81aa7fb 100644 --- a/util/cbfstool/EXAMPLE +++ b/util/cbfstool/EXAMPLE @@ -1,8 +1,6 @@ rm coreboot.rom; -./cbfstool coreboot.rom create 0x80000 0x10000 /tmp/coreboot.strip -./cbfstool coreboot.rom add-payload /tmp/filo.elf normal/payload l +./cbfstool coreboot.rom create -m x86 -s 256K -B /tmp/coreboot.strip -o 0x1000 +./cbfstool coreboot.rom add-stage -f romstage.bin -n fallback/romstage +./cbfstool coreboot.rom add-payload -f /tmp/filo.elf -n normal/payload -c lzma ./cbfstool coreboot.rom print -#./cbfstool coreboot.rom add-stage /tmp/filo.elf normal/payload - -./cbfstool coreboot.rom print -cp coreboot.rom /home/rminnich/qemutest/ +qemu-system-i386 -bios coreboot.rom -nographic

1 0

New patch to review for coreboot: d998509 cbfstool: Use cbfs_image API for "create" command.
by Hung-Te Lin 29 Jan '13

29 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 d998509fa241d6609cfc82e096ed902e9a548976 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 37b56c3..a70d077 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 fafbd7f..b10054e 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 53944b9..e1a5cc2 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 148e80a..9b6f27d 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; @@ -345,23 +348,69 @@ static int cbfstool_remove(void) static int cbfstool_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 cbfstool_locate_stage(void) @@ -465,7 +514,7 @@ static const struct command commands[] = { {"add-stage", "f:n:t:c:b:vh?", cbfstool_add_stage}, {"add-flat-binary", "f:n:l:e:c:b:vh?", cbfstool_add_flat_binary}, {"remove", "n:vh?", cbfstool_remove}, - {"create", "s:B:a:o:m:vh?", cbfstool_create}, + {"create", "s:B:b:H:a:o:m:vh?", cbfstool_create}, {"locate-stage", "Tf:n:a:vh?", cbfstool_locate_stage}, {"print", "vh?", cbfstool_print}, {"extract", "n:f:vh?", cbfstool_extract}, @@ -583,6 +632,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); @@ -602,6 +655,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

New patch to review for coreboot: a6fe302 cbfstool: Use cbfs_image API for "locate-stage" command.
by Hung-Te Lin 29 Jan '13

29 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 a6fe302e9b61de92d5f5d8ac85ef67014de38a99 Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 03:46:02 2013 +0800 cbfstool: Use cbfs_image API for "locate-stage" command. "locate-stage" command now outputs platform independent offset. To retrieve x86 top-aligned virtual address, add "-T". To test: cbfstool coreboot.rom locate-stage -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 | 136 +++++++++++++++++++++++++++++++++++++++++++++ util/cbfstool/cbfs_image.h | 15 +++++ util/cbfstool/cbfstool.c | 51 ++++++++++++++--- 4 files changed, 195 insertions(+), 9 deletions(-) diff --git a/src/arch/x86/Makefile.inc b/src/arch/x86/Makefile.inc index 1956ceb..cb446bb 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-stage -f $(objcbfs)/romstage_null.bin -n $(CONFIG_CBFS_PREFIX)/romstage -a $(CONFIG_XIP_ROM_SIZE) > $@.tmp \ + $(CBFSTOOL) $(obj)/coreboot.pre1 locate-stage -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..fafbd7f 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,96 @@ 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_stage(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_stage page does not align with CBFS image.\n"); + + 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_stage: 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_stage: OVERLAP (PAGE2)."); + return addr2; + } + + addr3 = addr2 + page_size; + if (addr3 < addr_next && addr_next - addr3 >= size && + addr3 - addr >= header_len) { + DEBUG("cbfs_locate_stage: OVERLAP+ (PAGE3)."); + return addr3; + } + } + return -1; +} diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h index e9f64a4..53944b9 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 whole cbfs_stage content in same memory page. + * Returns a valid offset, or -1 on failure. */ +int32_t cbfs_locate_stage(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 7dda508..148e80a 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. */ @@ -363,9 +364,11 @@ static int cbfstool_create(void) param.alignment, param.offset); } -static int cbfs_locate_stage(void) +static int cbfstool_locate_stage(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"); @@ -377,13 +380,42 @@ static int cbfs_locate_stage(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_stage(&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_stage_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 cbfstool_print(void) @@ -478,7 +510,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-stage -f FILE -n NAME [-a align] " + " locate-stage -f FILE -n NAME [-a align] [-T] " "Find a place for a stage file of that size\n" " print " "Show the contents of the ROM\n" @@ -579,6 +611,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

New patch to review for coreboot: 25ceccf cbfstool: Change command line functions to prefix with "cbfstool_".
by Hung-Te Lin 29 Jan '13

29 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/2212 -gerrit commit 25ceccf426626a4d4b90699aa1d81c4cb8ffdefb Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 03:48:07 2013 +0800 cbfstool: Change command line functions to prefix with "cbfstool_". The command line (cbfstool.c) uses "cbfs_" prefix, just like other engine / backend (common.c, cbfs_image.c) and may cause conflict: like "cbfs_add" or "cbfs_locate_stage" - we may have same function name in command line processing and both CBFS image manipulation. Renaming all command line functions to "cbfstool_*" will make it more clear. Change-Id: Iea125ab931e9ad892067d4c2444d3e0b10347bd0 Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/cbfstool.c | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c index caf9942..7dda508 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -54,7 +54,7 @@ static struct param { .algo = CBFS_COMPRESS_NONE, }; -static int cbfs_add(void) +static int cbfstool_add(void) { uint32_t filesize = 0; void *rom, *filedata, *cbfsfile; @@ -110,7 +110,7 @@ static int cbfs_add(void) return 0; } -static int cbfs_add_payload(void) +static int cbfstool_add_payload(void) { uint32_t filesize = 0; void *rom, *filedata, *cbfsfile; @@ -174,7 +174,7 @@ static int cbfs_add_payload(void) return 0; } -static int cbfs_add_stage(void) +static int cbfstool_add_stage(void) { uint32_t filesize = 0; void *rom, *filedata, *cbfsfile; @@ -232,7 +232,7 @@ static int cbfs_add_stage(void) return 0; } -static int cbfs_add_flat_binary(void) +static int cbfstool_add_flat_binary(void) { uint32_t filesize = 0; void *rom, *filedata, *cbfsfile; @@ -311,7 +311,7 @@ static int cbfs_add_flat_binary(void) return 0; } -static int cbfs_remove(void) +static int cbfstool_remove(void) { int result = 1; struct cbfs_image image; @@ -342,7 +342,7 @@ static int cbfs_remove(void) return result; } -static int cbfs_create(void) +static int cbfstool_create(void) { if (param.size == 0) { ERROR("You need to specify a valid -s/--size.\n"); @@ -386,7 +386,7 @@ static int cbfs_locate_stage(void) return location == 0 ? 1 : 0; } -static int cbfs_print(void) +static int cbfstool_print(void) { struct cbfs_image image; if (cbfs_image_from_file(&image, param.cbfs_name) != 0) { @@ -399,7 +399,7 @@ static int cbfs_print(void) return 0; } -static int cbfs_extract(void) +static int cbfstool_extract(void) { int result = 0; struct cbfs_image image; @@ -428,15 +428,15 @@ static int cbfs_extract(void) } static const struct command commands[] = { - {"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-stage", "f:n:a:vh?", cbfs_locate_stage}, - {"print", "vh?", cbfs_print}, - {"extract", "n:f:vh?", cbfs_extract}, + {"add", "f:n:t:b:vh?", cbfstool_add}, + {"add-payload", "f:n:t:c:b:vh?", cbfstool_add_payload}, + {"add-stage", "f:n:t:c:b:vh?", cbfstool_add_stage}, + {"add-flat-binary", "f:n:l:e:c:b:vh?", cbfstool_add_flat_binary}, + {"remove", "n:vh?", cbfstool_remove}, + {"create", "s:B:a:o:m:vh?", cbfstool_create}, + {"locate-stage", "Tf:n:a:vh?", cbfstool_locate_stage}, + {"print", "vh?", cbfstool_print}, + {"extract", "n:f:vh?", cbfstool_extract}, }; static struct option long_options[] = {

1 0

New patch to review for coreboot: d3b580b cbfstool: Fix incorrect CBFS free space by old cbfstool.
by Hung-Te Lin 29 Jan '13

29 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/2211 -gerrit commit d3b580bf1ad90c21be98becb3def561c0fc573cd Author: Hung-Te Lin <hungte(a)chromium.org> Date: Tue Jan 29 03:16:20 2013 +0800 cbfstool: Fix incorrect CBFS free space by old cbfstool. Old CBFStool may produce CBFS image with calculation error in size of last empty entry, and then corrupts master header data when you really use every bits in last entry. This CL will correct size when you load ROM images with cbfs_image API (cbfs_image_from_file). Change-Id: I2ada319728ef69ab9296ae446c77d37e05d05fce Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- util/cbfstool/cbfs_image.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c index 24759c9..e7e5053 100644 --- a/util/cbfstool/cbfs_image.c +++ b/util/cbfstool/cbfs_image.c @@ -104,6 +104,31 @@ static int cbfs_calculate_file_header_size(const char *name) { align_up(strlen(name) + 1, CBFS_FILENAME_ALIGN)); } +static int cbfs_fix_legacy_size(struct cbfs_image *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. + + struct cbfs_file *entry, *first = NULL, *last = NULL; + for (first = entry = cbfs_find_first_entry(image); + entry && cbfs_is_valid_entry(entry); + entry = cbfs_find_next_entry(image, entry)) { + last = entry; + } + if ((char *)first < (char *)image->header && + (char *)entry > (char *)image->header) { + WARN("CBFS image was created with old cbfstool with size bug. " + "Fixing size in last entry...\n"); + last->len = htonl(ntohl(last->len) - + ntohl(image->header->align)); + DEBUG("Last entry has been changed from 0x%x to 0x%x.\n", + cbfs_get_entry_addr(image, entry), + cbfs_get_entry_addr(image, + cbfs_find_next_entry(image, last))); + } + return 0; +} + int cbfs_image_from_file(struct cbfs_image *image, const char *filename) { if (buffer_from_file(&image->buffer, filename) != 0) return -1; @@ -116,6 +141,7 @@ int cbfs_image_from_file(struct cbfs_image *image, const char *filename) { cbfs_image_delete(image); return -1; } + cbfs_fix_legacy_size(image); return 0; }

1 0

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

29 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 ca0a8455275096942dd3120d4ce5b361a753e98e 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 c1f68bf..edab7e3 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 3e48534..bf4f7b0 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 6d7a7fd..ba6fab3 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: 511a3d9 cbfstool: Change "locate" to "locate-stage".
by Hung-Te Lin 29 Jan '13

29 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/2198 -gerrit commit 511a3d93a9bd2b75bf52ef3f40adebd2c8f97fea Author: Hung-Te Lin <hungte(a)chromium.org> Date: Mon Jan 28 15:27:48 2013 +0800 cbfstool: Change "locate" to "locate-stage". The "locate" has an implicit rule of constructing stage-style files (adding extra sizeof(struct cbfs_stage) bytes to header size requirement). In other words, if we try to add a component with header larger than stage, it may fail to fit in the space. To prevent confusion, the command should be renamed to show that it's designed for stage files. Change-Id: I168ed20d2cb682c22e0f03d42d0d071ec68b5ba7 Signed-off-by: Hung-Te Lin <hungte(a)chromium.org> --- src/arch/armv7/Makefile.inc | 2 +- src/arch/x86/Makefile.inc | 2 +- util/cbfstool/cbfstool.c | 12 ++++++------ util/cbfstool/common.c | 4 ++-- util/cbfstool/common.h | 4 ++-- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/arch/armv7/Makefile.inc b/src/arch/armv7/Makefile.inc index ba734a6..37b56c3 100644 --- a/src/arch/armv7/Makefile.inc +++ b/src/arch/armv7/Makefile.inc @@ -314,7 +314,7 @@ $(objgenerated)/romstage_xip.ld: $(objgenerated)/romstage_null.ld $(objcbfs)/bas $(objcbfs)/base_xip.txt: $(obj)/coreboot.pre1 $(objcbfs)/romstage_null.bin @printf " generating base_xip.txt\n" 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-stage -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/src/arch/x86/Makefile.inc b/src/arch/x86/Makefile.inc index 190f7cb..1956ceb 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-stage -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/cbfstool.c b/util/cbfstool/cbfstool.c index 942baad..c1f68bf 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -363,7 +363,7 @@ static int cbfs_create(void) param.alignment, param.offset); } -static int cbfs_locate(void) +static int cbfs_locate_stage(void) { uint32_t filesize, location; @@ -379,8 +379,8 @@ static int cbfs_locate(void) filesize = getfilesize(param.filename); - location = cbfs_find_location(param.cbfs_name, filesize, - param.name, param.alignment); + location = cbfs_find_stage_location(param.cbfs_name, filesize, + param.name, param.alignment); printf("0x%x\n", location); return location == 0 ? 1 : 0; @@ -438,7 +438,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-stage", "f:n:a:vh?", cbfs_locate_stage}, {"print", "vh?", cbfs_print}, {"extract", "n:f:vh?", cbfs_extract}, }; @@ -482,8 +482,8 @@ 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 " - "Find a place for a file of that size\n" + " locate-stage -f FILE -n NAME [-a align] " + "Find a place for a stage file of that size\n" " print " "Show the contents of the ROM\n" " extract -n NAME -f FILE " diff --git a/util/cbfstool/common.c b/util/cbfstool/common.c index 8b4b4b4..3e48534 100644 --- a/util/cbfstool/common.c +++ b/util/cbfstool/common.c @@ -711,8 +711,8 @@ static int in_segment(int addr, int size, int gran) return ((addr & ~(gran - 1)) == ((addr + size) & ~(gran - 1))); } -uint32_t cbfs_find_location(const char *romfile, uint32_t filesize, - const char *filename, uint32_t alignment) +uint32_t cbfs_find_stage_location(const char *romfile, uint32_t filesize, + const char *filename, uint32_t alignment) { void *rom; size_t filename_size, headersize, totalsize; diff --git a/util/cbfstool/common.h b/util/cbfstool/common.h index 807c22c..6d7a7fd 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -95,8 +95,8 @@ void print_cbfs_directory(const char *filename); int extract_file_from_cbfs(const char *filename, const char *payloadname, const char *outpath); int remove_file_from_cbfs(const char *filename); -uint32_t cbfs_find_location(const char *romfile, uint32_t filesize, - const char *filename, uint32_t align); +uint32_t cbfs_find_stage_location(const char *romfile, uint32_t filesize, + const char *filename, uint32_t align); void print_supported_filetypes(void);

1 0

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

29 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 e27b74e96742ad0274d135b8f2e5ab1ce575d299 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 | 52 ++++++++++++++++++++++++++++++++++++++++++ util/cbfstool/cbfstool.c | 52 +++++++++--------------------------------- util/cbfstool/common.h | 6 +++++ 3 files changed, 69 insertions(+), 41 deletions(-) diff --git a/util/cbfstool/cbfs-mkpayload.c b/util/cbfstool/cbfs-mkpayload.c index da04a75..5e69ed5 100644 --- a/util/cbfstool/cbfs-mkpayload.c +++ b/util/cbfstool/cbfs-mkpayload.c @@ -202,3 +202,55 @@ 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 */ + 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); + + /* TODO what if compressed file size is bigger than original? */ + 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) { + 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 41dccc0..c439a57 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,25 @@ 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); + if ((int)filesize <= 0) { + ERROR("Adding payload '%s' failed.\n", + param.filename); free(rom); return 1; } - 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); + cbfsfile = create_cbfs_file(param.name, payload, &filesize, + 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..807c22c 100644 --- a/util/cbfstool/common.h +++ b/util/cbfstool/common.h @@ -72,11 +72,17 @@ 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); + void *create_cbfs_file(const char *filename, void *data, uint32_t * datasize, uint32_t type, uint32_t * location);

1 0

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

29 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 e4e5da871366902ae2e027363d79f0144af6ad85 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 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 | 112 ++++++++++++++++++++--------------------- util/cbfstool/common.c | 90 ++++++++++++++++----------------- util/cbfstool/common.h | 8 +++ util/cbfstool/compress.c | 2 +- 6 files changed, 115 insertions(+), 111 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 824b40e..41dccc0 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[] = { @@ -493,11 +493,11 @@ static struct option long_options[] = { static void usage(char *name) { - printf - ("cbfstool: Management utility for CBFS formatted ROM images\n\n" + LOG("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 +570,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 +585,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 +594,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 +645,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: 210c63c cbfstool: Use cbfs_image API for "remove" command.
by Hung-Te Lin 29 Jan '13

29 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 210c63c6e14d7c8965e406c5b973c8c6431fdf73 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 4a44005..caf9942 100644 --- a/util/cbfstool/cbfstool.c +++ b/util/cbfstool/cbfstool.c @@ -313,34 +313,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

← Newer
1
...
11
12
13
14
15
16
17
...
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