The conversion to bintools broke the invocation of the utility, since the arguments are not correct. Fix it.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/btool/futility.py | 4 ++-- tools/binman/etype/vblock.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tools/binman/btool/futility.py b/tools/binman/btool/futility.py index 614daaade4..8d00966a9d 100644 --- a/tools/binman/btool/futility.py +++ b/tools/binman/btool/futility.py @@ -106,7 +106,7 @@ class Bintoolfutility(bintool.Bintool): Returns: str: Tool output """ - args = ['gbb_utility' + args = ['gbb_utility', '-s', f'--hwid={hwid}', f'--rootkey={rootkey}', @@ -139,7 +139,7 @@ class Bintoolfutility(bintool.Bintool): '--keyblock', keyblock, '--signprivate', signprivate, '--version', version, - '--fw', firmware, + '--fv', firmware, '--kernelkey', kernelkey, '--flags', flags ] diff --git a/tools/binman/etype/vblock.py b/tools/binman/etype/vblock.py index a1de98290b..0074c577a2 100644 --- a/tools/binman/etype/vblock.py +++ b/tools/binman/etype/vblock.py @@ -73,7 +73,7 @@ class Entry_vblock(Entry_collection): vblock=output_fname, keyblock=prefix + self.keyblock, signprivate=prefix + self.signprivate, - version=f'{self.version,}', + version=f'{self.version:d}', firmware=input_fname, kernelkey=prefix + self.kernelkey, flags=f'{self.preamble_flags}')

If the buffer is empty and not allocated, then abuf_realloc() tries to copy invalid data. This happens because an incorrect change to use memdup() was added after the original code was written.

Signed-off-by: Simon Glass sjg@chromium.org ---

lib/abuf.c | 4 +++- test/lib/abuf.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/lib/abuf.c b/lib/abuf.c index 4b17e0b8c0..1635d58682 100644 --- a/lib/abuf.c +++ b/lib/abuf.c @@ -51,9 +51,11 @@ bool abuf_realloc(struct abuf *abuf, size_t new_size) /* not currently allocated and new size is larger. Alloc and * copy in data. The new space is not inited. */ - ptr = memdup(abuf->data, new_size); + ptr = malloc(new_size); if (!ptr) return false; + if (abuf->size) + memcpy(ptr, abuf->data, abuf->size); abuf->data = ptr; abuf->size = new_size; abuf->alloced = true; diff --git a/test/lib/abuf.c b/test/lib/abuf.c index 086c9b2282..42ee4c1755 100644 --- a/test/lib/abuf.c +++ b/test/lib/abuf.c @@ -126,6 +126,35 @@ static int lib_test_abuf_realloc(struct unit_test_state *uts) } LIB_TEST(lib_test_abuf_realloc, 0);

+/* Test abuf_realloc() on an non-allocated buffer of zero size */ +static int lib_test_abuf_realloc_size(struct unit_test_state *uts) +{ + struct abuf buf; + ulong start; + + start = ut_check_free(); + + abuf_init(&buf); + + /* Allocate some space */ + ut_asserteq(true, abuf_realloc(&buf, TEST_DATA_LEN)); + ut_assertnonnull(buf.data); + ut_asserteq(TEST_DATA_LEN, buf.size); + ut_asserteq(true, buf.alloced); + + /* Free it */ + ut_asserteq(true, abuf_realloc(&buf, 0)); + ut_assertnull(buf.data); + ut_asserteq(0, buf.size); + ut_asserteq(false, buf.alloced); + + /* Check for memory leaks */ + ut_assertok(ut_check_delta(start)); + + return 0; +} +LIB_TEST(lib_test_abuf_realloc_size, 0); + /* Test handling of buffers that are too large */ static int lib_test_abuf_large(struct unit_test_state *uts) {

We don't use an appended tree for sandbox and the required symbols are not present. Add a condition to avoid a build error.

Signed-off-by: Simon Glass sjg@chromium.org ---

lib/fdtdec.c | 3 +++ 1 file changed, 3 insertions(+)

diff --git a/lib/fdtdec.c b/lib/fdtdec.c index 086f0c732a..0c0ec034ec 100644 --- a/lib/fdtdec.c +++ b/lib/fdtdec.c @@ -1225,6 +1225,9 @@ static void *fdt_find_separate(void) { void *fdt_blob = NULL;

+ if (IS_ENABLED(CONFIG_SANDBOX)) + return NULL; + #ifdef CONFIG_SPL_BUILD /* FDT is at end of BSS unless it is in a different memory region */ if (CONFIG_IS_ENABLED(SEPARATE_BSS))

Add definitions for a payload or 'self', which is like an unpacked ELF file.

Signed-off-by: Simon Glass sjg@chromium.org ---

include/cbfs.h | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)

diff --git a/include/cbfs.h b/include/cbfs.h index 7449873b49..38efb1d2b0 100644 --- a/include/cbfs.h +++ b/include/cbfs.h @@ -24,6 +24,8 @@ enum cbfs_filetype { CBFS_TYPE_CBFSHEADER = 0x02, CBFS_TYPE_STAGE = 0x10, CBFS_TYPE_PAYLOAD = 0x20, + CBFS_TYPE_SELF = CBFS_TYPE_PAYLOAD, + CBFS_TYPE_FIT = 0x21, CBFS_TYPE_OPTIONROM = 0x30, CBFS_TYPE_BOOTSPLASH = 0x40, @@ -120,6 +122,47 @@ struct cbfs_file_attr_hash { u8 hash_data[]; } __packed;

+/*** Component sub-headers ***/ + +/* Following are component sub-headers for the "standard" component types */ + +/** + * struct cbfs_stage - sub-header for stage components + * + * Stages are loaded by coreboot during the normal boot process + */ +struct cbfs_stage { + u32 compression; /** Compression type */ + u64 entry; /** entry point */ + u64 load; /** Where to load in memory */ + u32 len; /** length of data to load */ + u32 memlen; /** total length of object in memory */ +} __packed; + +/** + * struct cbfs_payload_segment - sub-header for payload components + * + * Payloads are loaded by coreboot at the end of the boot process + */ +struct cbfs_payload_segment { + u32 type; + u32 compression; + u32 offset; + u64 load_addr; + u32 len; + u32 mem_len; +} __packed; + +struct cbfs_payload { + struct cbfs_payload_segment segments; +}; + +#define PAYLOAD_SEGMENT_CODE 0x45444F43 +#define PAYLOAD_SEGMENT_DATA 0x41544144 +#define PAYLOAD_SEGMENT_BSS 0x20535342 +#define PAYLOAD_SEGMENT_PARAMS 0x41524150 +#define PAYLOAD_SEGMENT_ENTRY 0x52544E45 + struct cbfs_cachenode { struct cbfs_cachenode *next; void *data;

When SPI flash is used in SPL there is no console, so ctrlc() cannot be called. Add a condition to fix this.

Signed-off-by: Simon Glass sjg@chromium.org ---

drivers/mtd/spi/spi-nor-core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/mtd/spi/spi-nor-core.c b/drivers/mtd/spi/spi-nor-core.c index a70fbda4bb..3b7c817c02 100644 --- a/drivers/mtd/spi/spi-nor-core.c +++ b/drivers/mtd/spi/spi-nor-core.c @@ -929,7 +929,7 @@ static int spi_nor_erase(struct mtd_info *mtd, struct erase_info *instr)

while (len) { WATCHDOG_RESET(); - if (ctrlc()) { + if (!IS_ENABLED(CONFIG_SPL_BUILD) && ctrlc()) { addr_known = false; ret = -EINTR; goto erase_err;

If this value is not provided it causes a hang in the build. Add a default value to avoid this.

Signed-off-by: Simon Glass sjg@chromium.org ---

common/spl/Kconfig | 1 + 1 file changed, 1 insertion(+)

diff --git a/common/spl/Kconfig b/common/spl/Kconfig index 9418d37b2e..b59215fe4f 100644 --- a/common/spl/Kconfig +++ b/common/spl/Kconfig @@ -1412,6 +1412,7 @@ config TPL_POWER

config TPL_TEXT_BASE hex "Base address for the .text section of the TPL stage" + default 0 help The base address for the .text section of the TPL stage.

This file uses struct driver, so declare it at the top in case the header-inclusion order is not as expected.

Signed-off-by: Simon Glass sjg@chromium.org ---

include/dm/device-internal.h | 1 + 1 file changed, 1 insertion(+)

diff --git a/include/dm/device-internal.h b/include/dm/device-internal.h index 02002acb78..46ae0e1f1f 100644 --- a/include/dm/device-internal.h +++ b/include/dm/device-internal.h @@ -14,6 +14,7 @@ #include <dm/ofnode.h>

struct device_node; +struct driver_info; struct udevice;

/*

Add some functions which support iteration before probing. Also add tests for the functions.

Signed-off-by: Simon Glass sjg@chromium.org ---

drivers/block/blk-uclass.c | 24 ++++++++ include/blk.h | 45 +++++++++++++++ test/dm/blk.c | 111 +++++++++++++++++++++++++++++++++++++ 3 files changed, 180 insertions(+)

diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c index bee1cd6f0d..84502bb47c 100644 --- a/drivers/block/blk-uclass.c +++ b/drivers/block/blk-uclass.c @@ -552,6 +552,30 @@ static int blk_flags_check(struct udevice *dev, enum blk_flag_t req_flags) return flags & req_flags ? 0 : 1; }

+int blk_find_first(enum blk_flag_t flags, struct udevice **devp) +{ + int ret; + + for (ret = uclass_find_first_device(UCLASS_BLK, devp); + *devp && !blk_flags_check(*devp, flags); + ret = uclass_find_next_device(devp)) + return 0; + + return -ENODEV; +} + +int blk_find_next(enum blk_flag_t flags, struct udevice **devp) +{ + int ret; + + for (ret = uclass_find_next_device(devp); + *devp && !blk_flags_check(*devp, flags); + ret = uclass_find_next_device(devp)) + return 0; + + return -ENODEV; +} + int blk_first_device_err(enum blk_flag_t flags, struct udevice **devp) { int ret; diff --git a/include/blk.h b/include/blk.h index d06098bc13..dbe9ae219d 100644 --- a/include/blk.h +++ b/include/blk.h @@ -731,6 +731,51 @@ int blk_first_device_err(enum blk_flag_t flags, struct udevice **devp); */ int blk_next_device_err(enum blk_flag_t flags, struct udevice **devp);

+/** + * blk_find_first() - Return the first matching block device + * @flags: Indicates type of device to return + * @devp: Returns pointer to device, or NULL on error + * + * The device is not prepared for use - this is an internal function. + * The function uclass_get_device_tail() can be used to probe the device. + * + * Note that some devices are considered removable until they have been probed + * + * @return 0 if found, -ENODEV if not found + */ +int blk_find_first(enum blk_flag_t flags, struct udevice **devp); + +/** + * blk_find_next() - Return the next matching block device + * @flags: Indicates type of device to return + * @devp: On entry, pointer to device to lookup. On exit, returns pointer + * to the next device in the same uclass, or NULL if none + * + * The device is not prepared for use - this is an internal function. + * The function uclass_get_device_tail() can be used to probe the device. + * + * Note that some devices are considered removable until they have been probed + * + * @return 0 if found, -ENODEV if not found + */ +int blk_find_next(enum blk_flag_t flags, struct udevice **devp); + +/** + * blk_foreach() - iterate through block devices + * + * This creates a for() loop which works through the available block devices in + * order from start to end. + * + * If for some reason the uclass cannot be found, this does nothing. + * + * @_flags: Indicates type of device to return + * @_pos: struct udevice * to hold the current device. Set to NULL when there + * are no more devices. + */ +#define blk_foreach(_flags, _pos) \ + for (int _ret = blk_find_first(_flags, &_pos); !_ret && _pos; \ + _ret = blk_find_next(_flags, &_pos)) + /** * blk_foreach_probe() - Helper function to iteration through block devices * diff --git a/test/dm/blk.c b/test/dm/blk.c index deccf05289..8556cc7159 100644 --- a/test/dm/blk.c +++ b/test/dm/blk.c @@ -217,3 +217,114 @@ static int dm_test_blk_iter(struct unit_test_state *uts) return 0; } DM_TEST(dm_test_blk_iter, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); + +/* Test finding fixed/removable block devices */ +static int dm_test_blk_flags(struct unit_test_state *uts) +{ + struct udevice *dev; + + /* Iterate through devices without probing them */ + ut_assertok(blk_find_first(BLKF_BOTH, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc2.blk", dev->name); + + ut_assertok(blk_find_next(BLKF_BOTH, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc1.blk", dev->name); + + ut_assertok(blk_find_next(BLKF_BOTH, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc0.blk", dev->name); + + ut_asserteq(-ENODEV, blk_find_next(BLKF_BOTH, &dev)); + ut_assertnull(dev); + + /* All devices are removable until probed */ + ut_asserteq(-ENODEV, blk_find_first(BLKF_FIXED, &dev)); + + ut_assertok(blk_find_first(BLKF_REMOVABLE, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc2.blk", dev->name); + + /* Now probe them and iterate again */ + ut_assertok(blk_first_device_err(BLKF_BOTH, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc2.blk", dev->name); + + ut_assertok(blk_next_device_err(BLKF_BOTH, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc1.blk", dev->name); + + ut_assertok(blk_next_device_err(BLKF_BOTH, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc0.blk", dev->name); + + ut_asserteq(-ENODEV, blk_next_device_err(BLKF_BOTH, &dev)); + + /* Look only for fixed devices */ + ut_assertok(blk_first_device_err(BLKF_FIXED, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc2.blk", dev->name); + + ut_asserteq(-ENODEV, blk_next_device_err(BLKF_FIXED, &dev)); + + /* Look only for removable devices */ + ut_assertok(blk_first_device_err(BLKF_REMOVABLE, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc1.blk", dev->name); + + ut_assertok(blk_next_device_err(BLKF_REMOVABLE, &dev)); + ut_assertnonnull(dev); + ut_asserteq_str("mmc0.blk", dev->name); + + ut_asserteq(-ENODEV, blk_next_device_err(BLKF_REMOVABLE, &dev)); + + return 0; +} +DM_TEST(dm_test_blk_flags, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); + +/* Test blk_foreach() and friend */ +static int dm_test_blk_foreach(struct unit_test_state *uts) +{ + struct udevice *dev; + int found; + + /* Test blk_foreach() - use the 3rd bytes of the name (0/1/2) */ + found = 0; + blk_foreach(BLKF_BOTH, dev) + found |= 1 << dectoul(&dev->name[3], NULL); + ut_asserteq(7, found); + + /* All devices are removable until probed */ + found = 0; + blk_foreach(BLKF_FIXED, dev) + found |= 1 << dectoul(&dev->name[3], NULL); + ut_asserteq(0, found); + + found = 0; + blk_foreach(BLKF_REMOVABLE, dev) + found |= 1 << dectoul(&dev->name[3], NULL); + ut_asserteq(7, found); + + /* Now try again with the probing functions */ + found = 0; + blk_foreach_probe(BLKF_BOTH, dev) + found |= 1 << dectoul(&dev->name[3], NULL); + ut_asserteq(7, found); + ut_asserteq(3, blk_count_devices(BLKF_BOTH)); + + found = 0; + blk_foreach_probe(BLKF_FIXED, dev) + found |= 1 << dectoul(&dev->name[3], NULL); + ut_asserteq(4, found); + ut_asserteq(1, blk_count_devices(BLKF_FIXED)); + + found = 0; + blk_foreach_probe(BLKF_REMOVABLE, dev) + found |= 1 << dectoul(&dev->name[3], NULL); + ut_asserteq(3, found); + ut_asserteq(2, blk_count_devices(BLKF_REMOVABLE)); + + return 0; +} +DM_TEST(dm_test_blk_foreach, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);