[coreboot-gerrit] Patch set updated for coreboot: eb072f9 cbfstool: add a command to duplicate a cbfs instance
Patrick Georgi (pgeorgi@google.com)
gerrit at coreboot.org
Fri Apr 17 10:40:29 CEST 2015
Patrick Georgi (pgeorgi at google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/9742
-gerrit
commit eb072f9e48a956b0d88f295b52fba8b70f44d36a
Author: Vadim Bendebury <vbendeb at chromium.org>
Date: Tue Dec 23 19:26:54 2014 -0800
cbfstool: add a command to duplicate a cbfs instance
The new command allows to create a file where the original CBFS image
is duplicated at a different offset.
The required options of the new command are -D, the offset where the
copy CBFS header is placed, and -s, the size of the new CBFS copy.
When a CBFS is copied, the bootblock area of the source CBFS is
ignored, as well as empty and deleted files in the source CBFS. The
size of the destination CBFS is calculated as the rombase size of the
source CBFS less the bootblock size.
The copy instance can be created in the image only above the original,
which rules out the use of this new command for x86 images. If
necessary, this limitation could be addressed later.
As with other cbfstool commands, unless explicitly specified the
lowest CBFS instance in the image is considered the source. If
necessary, the user can specify the source CBFS using the -H option.
BRANCH=storm
BUG=chrome-os-partner:34161, chromium:445938
TEST=run multiple cbfstool commands on a storm image:
$ cd /tmp
$ cp /build/storm/firmware/image.serial.bin storm.bin
$ cbfstool storm.bin print
storm.bin: 8192 kB, bootblocksize 34472, romsize 458752, offset 0x8700
alignment: 64 bytes, architecture: arm
Name Offset Type Size
cdt.mbn 0x8700 raw 416
ddr.mbn 0x8900 raw 25836
rpm.mbn 0xee40 raw 78576
tz.mbn 0x22180 raw 85360
fallback/verstage 0x36f40 stage 41620
fallback/romstage 0x41240 stage 19556
fallback/ramstage 0x45f00 stage 25579
config 0x4c340 raw 2878
fallback/payload 0x4cec0 payload 64811
u-boot.dtb 0x5cc40 (unknown) 2993
(empty) 0x5d840 null 75608
$ cbfstool storm.bin copy -D 0x420000
E: You need to specify -s/--size.
$ cbfstool storm.bin copy -D 0x420000 -s 0x70000
$ cbfstool storm.bin print
W: Multiple (2) CBFS headers found, using the first one.
storm.bin: 8192 kB, bootblocksize 34472, romsize 458752, offset 0x8700
alignment: 64 bytes, architecture: arm
Name Offset Type Size
cdt.mbn 0x8700 raw 416
ddr.mbn 0x8900 raw 25836
rpm.mbn 0xee40 raw 78576
tz.mbn 0x22180 raw 85360
fallback/verstage 0x36f40 stage 41620
fallback/romstage 0x41240 stage 19556
fallback/ramstage 0x45f00 stage 25579
config 0x4c340 raw 2878
fallback/payload 0x4cec0 payload 64811
u-boot.dtb 0x5cc40 (unknown) 2993
(empty) 0x5d840 null 75608
cbfstool storm.bin print -H 0x420000
storm.bin: 8192 kB, bootblocksize 0, romsize 4784128, offset 0x420040
alignment: 64 bytes, architecture: arm
Name Offset Type Size
cdt.mbn 0x420040 raw 416
ddr.mbn 0x420240 raw 25836
rpm.mbn 0x426780 raw 78576
tz.mbn 0x439ac0 raw 85360
fallback/verstage 0x44e880 stage 41620
fallback/romstage 0x458b80 stage 19556
fallback/ramstage 0x45d840 stage 25579
config 0x463c80 raw 2878
fallback/payload 0x464800 payload 64811
u-boot.dtb 0x474580 (unknown) 2993
(empty) 0x475180 null 110168
$ cbfstool storm.bin remove -n config -H 0x420000
$ cbfstool storm.bin copy -H 0x420000 -D 0x620000 -s 0x70000
$ cbfstool storm.bin print -H 0x620000
storm.bin: 8192 kB, bootblocksize 0, romsize 6881280, offset 0x620040
alignment: 64 bytes, architecture: arm
Name Offset Type Size
cdt.mbn 0x620040 raw 416
ddr.mbn 0x620240 raw 25836
rpm.mbn 0x626780 raw 78576
tz.mbn 0x639ac0 raw 85360
fallback/verstage 0x64e880 stage 41620
fallback/romstage 0x658b80 stage 19556
fallback/ramstage 0x65d840 stage 25579
fallback/payload 0x663c80 payload 64811
u-boot.dtb 0x673a00 (unknown) 2993
(empty) 0x674600 null 113112
$ cbfstool /build/storm/firmware/image.serial.bin extract -n fallback/payload -f payload1
[..]
$ cbfstool storm.bin extract -H 0x620000 -n fallback/payload -f payload2
[..]
$ diff payload1 payload2
Change-Id: Ieb9205848aec361bb870de0d284dff06c597564f
Signed-off-by: Patrick Georgi <pgeorgi at chromium.org>
Original-Commit-Id: b8d3c1b09a47ca24d2d2effc6de0e89d1b0a8903
Original-Signed-off-by: Aaron Durbin <adurbin at chromium.org>
Original-Signed-off-by: Vadim Bendebury <vbendeb at chromium.org>
Original-Change-Id: I227e607ccf7a9a8e2a1f3c6bbc506b8d29a35b1b
Original-Reviewed-on: https://chromium-review.googlesource.com/237561
---
util/cbfstool/cbfs_image.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++
util/cbfstool/cbfs_image.h | 4 +++
util/cbfstool/cbfstool.c | 36 ++++++++++++++++++++
3 files changed, 122 insertions(+)
diff --git a/util/cbfstool/cbfs_image.c b/util/cbfstool/cbfs_image.c
index 621a35d..9df2030 100644
--- a/util/cbfstool/cbfs_image.c
+++ b/util/cbfstool/cbfs_image.c
@@ -294,6 +294,88 @@ int cbfs_image_from_file(struct cbfs_image *image,
return 0;
}
+int cbfs_copy_instance(struct cbfs_image *image, size_t copy_offset,
+ size_t copy_size)
+{
+ struct cbfs_file *src_entry, *dst_entry;
+ struct cbfs_header *copy_header;
+ size_t align, entry_offset;
+ ssize_t last_entry_size;
+
+ size_t header_offset, header_end;
+ size_t cbfs_offset, cbfs_end;
+ size_t copy_end = copy_offset + copy_size;
+
+ align = htonl(image->header->align);
+
+ header_offset = (char *)image->header - image->buffer.data;
+ header_end = header_offset + sizeof(image->header);
+
+ cbfs_offset = htonl(image->header->offset);
+ cbfs_end = htonl(image->header->romsize);
+
+ if (copy_end > image->buffer.size) {
+ ERROR("Copy offset out of range: [%zx:%zx)\n",
+ copy_offset, copy_end);
+ return 1;
+ }
+
+ /* Range check requested copy region with header and source cbfs. */
+ if ((copy_offset >= header_offset && copy_offset < header_end) ||
+ (copy_end >= header_offset && copy_end <= header_end)) {
+ ERROR("New image would overlap old header.\n");
+ }
+
+ if ((copy_offset >= cbfs_offset && copy_offset < cbfs_end) ||
+ (copy_end >= cbfs_offset && copy_end <= cbfs_end)) {
+ ERROR("New image would overlap old one.\n");
+ return 1;
+ }
+
+ /* This will work, let's create a copy. */
+ copy_header = (struct cbfs_header *)(image->buffer.data + copy_offset);
+ *copy_header = *image->header;
+
+ copy_header->bootblocksize = 0;
+ /* Romsize is a misnomer. It's the absolute limit of cbfs content.*/
+ copy_header->romsize = htonl(copy_end);
+ entry_offset = align_up(copy_offset + sizeof(*copy_header), align);
+ copy_header->offset = htonl(entry_offset);
+ dst_entry = (struct cbfs_file *)(image->buffer.data + entry_offset);
+
+ /* Copy non-empty files */
+ for (src_entry = cbfs_find_first_entry(image);
+ src_entry && cbfs_is_valid_entry(image, src_entry);
+ src_entry = cbfs_find_next_entry(image, src_entry)) {
+ size_t entry_size;
+
+ if ((src_entry->type == htonl(CBFS_COMPONENT_NULL)) ||
+ (src_entry->type == htonl(CBFS_COMPONENT_DELETED)))
+ continue;
+
+ entry_size = htonl(src_entry->len) + htonl(src_entry->offset);
+ memcpy(dst_entry, src_entry, entry_size);
+ dst_entry = (struct cbfs_file *)(
+ (uintptr_t)dst_entry + align_up(entry_size, align));
+
+ if (((char *)dst_entry - image->buffer.data) >= copy_end) {
+ ERROR("Ran out of room in copy region.\n");
+ return 1;
+ }
+ }
+
+ /* Last entry size is all the room above it. */
+ last_entry_size = copy_end - ((char *)dst_entry - image->buffer.data)
+ - cbfs_calculate_file_header_size("");
+
+ if (last_entry_size < 0)
+ WARN("No room to create the last entry!\n")
+ else
+ cbfs_create_empty_entry(image, dst_entry, last_entry_size, "");
+
+ return 0;
+}
+
int cbfs_image_write_file(struct cbfs_image *image, const char *filename)
{
assert(image && image->buffer.data);
diff --git a/util/cbfstool/cbfs_image.h b/util/cbfstool/cbfs_image.h
index 2c1be3d..1e5a99f 100644
--- a/util/cbfstool/cbfs_image.h
+++ b/util/cbfstool/cbfs_image.h
@@ -55,6 +55,10 @@ int cbfs_image_create(struct cbfs_image *image,
int cbfs_image_from_file(struct cbfs_image *image,
const char *filename, uint32_t offset);
+/* Create a duplicate CBFS image. Returns 0 on success, otherwise non-zero. */
+int cbfs_copy_instance(struct cbfs_image *image, size_t copy_offset,
+ size_t copy_size);
+
/* 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);
diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c
index 20e5e0c..3ccc786 100644
--- a/util/cbfstool/cbfstool.c
+++ b/util/cbfstool/cbfstool.c
@@ -47,6 +47,8 @@ static struct param {
uint32_t baseaddress;
uint32_t baseaddress_assigned;
uint32_t loadaddress;
+ uint32_t copyoffset;
+ uint32_t copyoffset_assigned;
uint32_t headeroffset;
uint32_t headeroffset_assigned;
uint32_t entrypoint;
@@ -550,6 +552,32 @@ static int cbfs_update_fit(void)
return ret;
}
+static int cbfs_copy(void)
+{
+ struct cbfs_image image;
+
+ if (!param.copyoffset_assigned) {
+ ERROR("You need to specify -D/--copy_offset.\n");
+ return 1;
+ }
+
+ if (!param.size) {
+ ERROR("You need to specify -s/--size.\n");
+ return 1;
+ }
+
+ if (cbfs_image_from_file(&image, param.cbfs_name,
+ param.headeroffset) != 0)
+ return 1;
+
+ if (cbfs_copy_instance(&image, param.copyoffset, param.size))
+ return 1;
+
+ /* Save the new image. */
+ return buffer_write_file(&image.buffer, param.cbfs_name);
+
+}
+
static const struct command commands[] = {
{"add", "H;f:n:t:b:vh?", cbfs_add},
{"add-payload", "H:f:n:t:c:b:vh?C:I:", cbfs_add_payload},
@@ -557,6 +585,7 @@ static const struct command commands[] = {
{"add-flat-binary", "H:f:n:l:e:c:b:vh?", cbfs_add_flat_binary},
{"add-int", "H:i:n:b:vh?", cbfs_add_integer},
{"remove", "H:n:vh?", cbfs_remove},
+ {"copy", "H:D:s:", cbfs_copy},
{"create", "s:B:b:H:a:o:m:vh?", cbfs_create},
{"locate", "H:f:n:P:a:Tvh?", cbfs_locate},
{"print", "H:vh?", cbfs_print},
@@ -571,6 +600,7 @@ static struct option long_options[] = {
{"base-address", required_argument, 0, 'b' },
{"load-address", required_argument, 0, 'l' },
{"top-aligned", required_argument, 0, 'T' },
+ {"copy-offset", required_argument, 0, 'D' },
{"entry-point", required_argument, 0, 'e' },
{"size", required_argument, 0, 's' },
{"bootblock", required_argument, 0, 'B' },
@@ -616,6 +646,9 @@ static void usage(char *name)
"Add a raw 64-bit integer value\n"
" remove -n NAME "
"Remove a component\n"
+ " copy -D new_header_offset -s region size \\\n"
+ " [-H source header offset] "
+ "Create a copy (duplicate) cbfs instance\n"
" create -s size -m ARCH [-B bootblock] [-b bootblock offset] \\\n"
" [-o CBFS offset] [-H header offset] [-a align] "
"Create a ROM file\n"
@@ -722,6 +755,9 @@ int main(int argc, char **argv)
optarg, NULL, 0);
param.headeroffset_assigned = 1;
break;
+ case 'D':
+ param.copyoffset = strtoul(optarg, NULL, 0);
+ param.copyoffset_assigned = 1;
case 'a':
param.alignment = strtoul(optarg, NULL, 0);
break;
More information about the coreboot-gerrit
mailing list