From: Simon Glass <simon.glass@canonical.com> Add string.h to files that use string functions like strdup, strcmp, strcpy, etc. These are implicitly available through the malloc.h header but that will soon change. For bouncebuf, take this opportunity to sort the headers correctly. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- arch/arm/mach-zynq/slcr.c | 1 + board/ti/common/cape_detect.c | 1 + boot/expo_build_cb.c | 1 + cmd/printf.c | 1 + common/bouncebuf.c | 5 +++-- common/iomux.c | 1 + common/menu.c | 1 + drivers/crypto/fsl/desc_constr.h | 1 + drivers/crypto/fsl/error.c | 1 + drivers/crypto/fsl/fsl_blob.c | 1 + drivers/crypto/fsl/fsl_hash.c | 1 + drivers/dma/apbh_dma.c | 1 + drivers/fpga/versalpl.c | 1 + drivers/net/fsl-mc/dpio/qbman_portal.c | 1 + drivers/net/qe/uccf.c | 1 + drivers/spi/spi-mem-nodm.c | 1 + drivers/video/imx/ipu_common.c | 1 + lib/circbuf.c | 1 + lib/crypto/x509_helper.c | 2 ++ lib/dhry/dhry_1.c | 1 + lib/libavb/avb_sysdeps_posix.c | 1 + lib/linux_compat.c | 1 + lib/list_sort.c | 1 + lib/mbedtls/mscode_parser.c | 1 + lib/membuf.c | 1 + lib/strto.c | 1 + 26 files changed, 29 insertions(+), 2 deletions(-) diff --git a/arch/arm/mach-zynq/slcr.c b/arch/arm/mach-zynq/slcr.c index ef877df0fe8..b69d5aad961 100644 --- a/arch/arm/mach-zynq/slcr.c +++ b/arch/arm/mach-zynq/slcr.c @@ -5,6 +5,7 @@ #include <asm/io.h> #include <malloc.h> +#include <string.h> #include <asm/arch/hardware.h> #include <asm/arch/sys_proto.h> diff --git a/board/ti/common/cape_detect.c b/board/ti/common/cape_detect.c index da805befabc..4984f7a3a22 100644 --- a/board/ti/common/cape_detect.c +++ b/board/ti/common/cape_detect.c @@ -8,6 +8,7 @@ #include <malloc.h> #include <i2c.h> #include <extension_board.h> +#include <string.h> #include <vsprintf.h> #include "cape_detect.h" diff --git a/boot/expo_build_cb.c b/boot/expo_build_cb.c index 442ad760e79..6dd3dbd92b8 100644 --- a/boot/expo_build_cb.c +++ b/boot/expo_build_cb.c @@ -14,6 +14,7 @@ #include <expo.h> #include <log.h> #include <malloc.h> +#include <string.h> #include <vsprintf.h> #include <asm/cb_sysinfo.h> diff --git a/cmd/printf.c b/cmd/printf.c index a1727ac15a2..52f21c8b842 100644 --- a/cmd/printf.c +++ b/cmd/printf.c @@ -89,6 +89,7 @@ #include <stddef.h> #include <stdio.h> #include <stdlib.h> +#include <string.h> #include <vsprintf.h> #define WANT_HEX_ESCAPES 0 diff --git a/common/bouncebuf.c b/common/bouncebuf.c index b2f87e4d939..5a7d3efa521 100644 --- a/common/bouncebuf.c +++ b/common/bouncebuf.c @@ -5,11 +5,12 @@ * Copyright (C) 2012 Marek Vasut <marex@denx.de> */ +#include <bouncebuf.h> #include <cpu_func.h> +#include <errno.h> #include <log.h> #include <malloc.h> -#include <errno.h> -#include <bouncebuf.h> +#include <string.h> #include <asm/cache.h> #include <linux/dma-mapping.h> diff --git a/common/iomux.c b/common/iomux.c index 1224c15eb71..e488934b29f 100644 --- a/common/iomux.c +++ b/common/iomux.c @@ -7,6 +7,7 @@ #include <console.h> #include <serial.h> #include <malloc.h> +#include <string.h> #if CONFIG_IS_ENABLED(CONSOLE_MUX) void iomux_printdevs(const int console) diff --git a/common/menu.c b/common/menu.c index 5a2126aa01a..b66803337d3 100644 --- a/common/menu.c +++ b/common/menu.c @@ -7,6 +7,7 @@ #include <ansi.h> #include <cli.h> #include <malloc.h> +#include <string.h> #include <errno.h> #include <linux/delay.h> #include <linux/list.h> diff --git a/drivers/crypto/fsl/desc_constr.h b/drivers/crypto/fsl/desc_constr.h index 209557c4ffa..ce938d49887 100644 --- a/drivers/crypto/fsl/desc_constr.h +++ b/drivers/crypto/fsl/desc_constr.h @@ -7,6 +7,7 @@ * Based on desc_constr.h file in linux drivers/crypto/caam */ +#include <string.h> #include <linux/compat.h> #include "desc.h" diff --git a/drivers/crypto/fsl/error.c b/drivers/crypto/fsl/error.c index dfcf5dbab35..9008dccb27c 100644 --- a/drivers/crypto/fsl/error.c +++ b/drivers/crypto/fsl/error.c @@ -9,6 +9,7 @@ #include <log.h> #include <malloc.h> +#include <string.h> #include <vsprintf.h> #include "desc.h" #include "jr.h" diff --git a/drivers/crypto/fsl/fsl_blob.c b/drivers/crypto/fsl/fsl_blob.c index 0ecd6befd25..32beb03e8ae 100644 --- a/drivers/crypto/fsl/fsl_blob.c +++ b/drivers/crypto/fsl/fsl_blob.c @@ -9,6 +9,7 @@ #include <malloc.h> #include <memalign.h> #include <fsl_sec.h> +#include <string.h> #include <asm/cache.h> #include <linux/errno.h> #include "jobdesc.h" diff --git a/drivers/crypto/fsl/fsl_hash.c b/drivers/crypto/fsl/fsl_hash.c index 79b32e2627c..ea90aece64b 100644 --- a/drivers/crypto/fsl/fsl_hash.c +++ b/drivers/crypto/fsl/fsl_hash.c @@ -8,6 +8,7 @@ #include <log.h> #include <malloc.h> #include <memalign.h> +#include <string.h> #include "jobdesc.h" #include "desc.h" #include "jr.h" diff --git a/drivers/dma/apbh_dma.c b/drivers/dma/apbh_dma.c index 331815c469f..89ff00540ae 100644 --- a/drivers/dma/apbh_dma.c +++ b/drivers/dma/apbh_dma.c @@ -16,6 +16,7 @@ #include <linux/list.h> #include <malloc.h> +#include <string.h> #include <linux/errno.h> #include <asm/io.h> #include <asm/arch/clock.h> diff --git a/drivers/fpga/versalpl.c b/drivers/fpga/versalpl.c index 1957e8dcaca..2fba888b8cc 100644 --- a/drivers/fpga/versalpl.c +++ b/drivers/fpga/versalpl.c @@ -8,6 +8,7 @@ #include <log.h> #include <asm/arch/sys_proto.h> #include <memalign.h> +#include <string.h> #include <versalpl.h> #include <zynqmp_firmware.h> #include <asm/cache.h> diff --git a/drivers/net/fsl-mc/dpio/qbman_portal.c b/drivers/net/fsl-mc/dpio/qbman_portal.c index f4e82b0507c..d338fac4def 100644 --- a/drivers/net/fsl-mc/dpio/qbman_portal.c +++ b/drivers/net/fsl-mc/dpio/qbman_portal.c @@ -5,6 +5,7 @@ #include <log.h> #include <malloc.h> +#include <string.h> #include <asm/arch/clock.h> #include <linux/bug.h> #include "qbman_portal.h" diff --git a/drivers/net/qe/uccf.c b/drivers/net/qe/uccf.c index badf4e5db3e..ab411361722 100644 --- a/drivers/net/qe/uccf.c +++ b/drivers/net/qe/uccf.c @@ -8,6 +8,7 @@ #include <malloc.h> #include <stdio.h> +#include <string.h> #include <linux/errno.h> #include <asm/io.h> #include <linux/immap_qe.h> diff --git a/drivers/spi/spi-mem-nodm.c b/drivers/spi/spi-mem-nodm.c index 6d9ab61769a..6a79fda625b 100644 --- a/drivers/spi/spi-mem-nodm.c +++ b/drivers/spi/spi-mem-nodm.c @@ -8,6 +8,7 @@ #include <malloc.h> #include <spi.h> #include <spi-mem.h> +#include <string.h> int spi_mem_exec_op(struct spi_slave *slave, const struct spi_mem_op *op) diff --git a/drivers/video/imx/ipu_common.c b/drivers/video/imx/ipu_common.c index bd1ef0a800d..40d578d3980 100644 --- a/drivers/video/imx/ipu_common.c +++ b/drivers/video/imx/ipu_common.c @@ -13,6 +13,7 @@ /* #define DEBUG */ #include <config.h> #include <log.h> +#include <string.h> #include <linux/delay.h> #include <linux/types.h> #include <linux/err.h> diff --git a/lib/circbuf.c b/lib/circbuf.c index 461c240f788..043b5a60d36 100644 --- a/lib/circbuf.c +++ b/lib/circbuf.c @@ -6,6 +6,7 @@ #include <log.h> #include <malloc.h> +#include <string.h> #include <circbuf.h> diff --git a/lib/crypto/x509_helper.c b/lib/crypto/x509_helper.c index 87e8ff67ae1..bf79d42cd60 100644 --- a/lib/crypto/x509_helper.c +++ b/lib/crypto/x509_helper.c @@ -5,6 +5,8 @@ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) */ + +#include <string.h> #include <linux/err.h> #include <crypto/public_key.h> #include <crypto/x509_parser.h> diff --git a/lib/dhry/dhry_1.c b/lib/dhry/dhry_1.c index 275a89942ea..4287b57e316 100644 --- a/lib/dhry/dhry_1.c +++ b/lib/dhry/dhry_1.c @@ -44,6 +44,7 @@ char SCCSid[] = "@(#) @(#)dhry_1.c:3.4 -- 5/15/91 19:30:21"; #include <malloc.h> #include <stdio.h> +#include <string.h> #include "dhry.h" diff --git a/lib/libavb/avb_sysdeps_posix.c b/lib/libavb/avb_sysdeps_posix.c index 6ffdb0b7eb3..1fde82be4d8 100644 --- a/lib/libavb/avb_sysdeps_posix.c +++ b/lib/libavb/avb_sysdeps_posix.c @@ -7,6 +7,7 @@ #include <malloc.h> #include <stdarg.h> #include <stdlib.h> +#include <string.h> #include "avb_sysdeps.h" diff --git a/lib/linux_compat.c b/lib/linux_compat.c index 985e88eb397..4df9db689ed 100644 --- a/lib/linux_compat.c +++ b/lib/linux_compat.c @@ -1,6 +1,7 @@ #include <malloc.h> #include <memalign.h> +#include <string.h> #include <asm/cache.h> #include <linux/compat.h> diff --git a/lib/list_sort.c b/lib/list_sort.c index a6e54d5bc46..cf5cac17720 100644 --- a/lib/list_sort.c +++ b/lib/list_sort.c @@ -8,6 +8,7 @@ #include <linux/compat.h> #include <malloc.h> #include <linux/printk.h> +#include <string.h> #endif #include <linux/list.h> #include <linux/list_sort.h> diff --git a/lib/mbedtls/mscode_parser.c b/lib/mbedtls/mscode_parser.c index c3805c6503c..956a5a47243 100644 --- a/lib/mbedtls/mscode_parser.c +++ b/lib/mbedtls/mscode_parser.c @@ -8,6 +8,7 @@ #include <linux/kernel.h> #include <linux/err.h> +#include <string.h> #include <crypto/pkcs7.h> #include <crypto/mscode.h> diff --git a/lib/membuf.c b/lib/membuf.c index 207dff5625b..02b0cc8c6b0 100644 --- a/lib/membuf.c +++ b/lib/membuf.c @@ -9,6 +9,7 @@ #include <errno.h> #include <log.h> #include <malloc.h> +#include <string.h> #include <vsprintf.h> #include "membuf.h" diff --git a/lib/strto.c b/lib/strto.c index 206d1e91847..b7b3655f17f 100644 --- a/lib/strto.c +++ b/lib/strto.c @@ -11,6 +11,7 @@ #include <errno.h> #include <malloc.h> +#include <string.h> #include <vsprintf.h> #include <linux/ctype.h> -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Several tests use CONFIG_SYS_MALLOC_LEN to test allocations that should fail due to exceeding pool size. However, the actual malloc pool size is TOTAL_MALLOC_LEN, which includes CONFIG_ENV_SIZE for boards that need to store the environment in RAM. The extra space accommodates: - the hash table allocated via calloc() - strdup() calls for each environment variable key - strdup() calls for each environment variable value This is an estimate and typically consumes less than CONFIG_ENV_SIZE, leaving more free space in the malloc pool than was reserved. On qemu-x86_64, CONFIG_ENV_SIZE is 0x40000, making the actual pool 0x240000 bytes. Tests expecting malloc(CONFIG_SYS_MALLOC_LEN) to fail might unexpectedly succeed since there's more space available. Update all tests to use TOTAL_MALLOC_LEN to correctly reflect the actual malloc pool size. Co-developed-by: Claude <noreply@anthropic.com> --- test/lib/abuf.c | 5 +++-- test/lib/alist.c | 3 ++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/test/lib/abuf.c b/test/lib/abuf.c index 9cbb627d0b6..e97bb8b66bc 100644 --- a/test/lib/abuf.c +++ b/test/lib/abuf.c @@ -5,6 +5,7 @@ */ #include <abuf.h> +#include <env_internal.h> #include <mapmem.h> #include <test/lib.h> #include <test/test.h> @@ -244,7 +245,7 @@ static int lib_test_abuf_large(struct unit_test_state *uts) /* Try an impossible size */ abuf_init(&buf); - ut_asserteq(false, abuf_realloc(&buf, CONFIG_SYS_MALLOC_LEN)); + ut_asserteq(false, abuf_realloc(&buf, TOTAL_MALLOC_LEN)); ut_assertnull(buf.data); ut_asserteq(0, buf.size); ut_asserteq(false, buf.alloced); @@ -264,7 +265,7 @@ static int lib_test_abuf_large(struct unit_test_state *uts) ut_assert(delta > 0); /* try to increase it */ - ut_asserteq(false, abuf_realloc(&buf, CONFIG_SYS_MALLOC_LEN)); + ut_asserteq(false, abuf_realloc(&buf, TOTAL_MALLOC_LEN)); ut_asserteq_ptr(ptr, buf.data); ut_asserteq(TEST_DATA_LEN, buf.size); ut_asserteq(true, buf.alloced); diff --git a/test/lib/alist.c b/test/lib/alist.c index 0bf24578d2e..108eaed8d92 100644 --- a/test/lib/alist.c +++ b/test/lib/alist.c @@ -5,6 +5,7 @@ */ #include <alist.h> +#include <env_internal.h> #include <string.h> #include <test/lib.h> #include <test/test.h> @@ -41,7 +42,7 @@ static int lib_test_alist_init(struct unit_test_state *uts) /* use an impossible size */ ut_asserteq(false, alist_init(&lst, obj_size, - CONFIG_SYS_MALLOC_LEN)); + TOTAL_MALLOC_LEN)); ut_assertnull(lst.data); ut_asserteq(0, lst.count); ut_asserteq(0, lst.alloc); -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add mem_malloc_init() to initialise the malloc heap and sbrk() for heap extension. These are U-Boot-specific functions that manage the memory pool used by dlmalloc. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- common/dlmalloc.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++ include/malloc.h | 27 +++++++++++++++++++++++++ 2 files changed, 78 insertions(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index ba8ca5bd0ae..2be2262ebeb 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -542,6 +542,18 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #define DLMALLOC_EXPORT extern #endif +#ifdef __UBOOT__ +#include <mapmem.h> +#include <asm/global_data.h> + +DECLARE_GLOBAL_DATA_PTR; + +ulong mem_malloc_start; +ulong mem_malloc_end; +ulong mem_malloc_brk; + +#endif /* __UBOOT__ */ + #ifndef WIN32 #ifdef _WIN32 #define WIN32 1 @@ -6290,3 +6302,42 @@ History: structure of old version, but most details differ.) */ + +/* --------------------- U-Boot additions --------------------- */ + +#ifdef __UBOOT__ + +void *sbrk(ptrdiff_t increment) +{ + ulong old = mem_malloc_brk; + ulong new = old + increment; + + /* mem_malloc_end points one byte past the end, so >= is correct */ + if ((new < mem_malloc_start) || (new >= mem_malloc_end)) + return (void *)MORECORE_FAILURE; + + /* + * if we are giving memory back make sure we clear it out since + * we set MORECORE_CLEARS to 1 + */ + if (increment < 0) + memset((void *)new, '\0', -increment); + + mem_malloc_brk = new; + + return (void *)old; +} + +void mem_malloc_init(ulong start, ulong size) +{ + mem_malloc_start = (ulong)map_sysmem(start, size); + mem_malloc_end = mem_malloc_start + size; + mem_malloc_brk = mem_malloc_end; + + debug("using memory %#lx-%#lx for malloc()\n", mem_malloc_start, + mem_malloc_end); +#if CONFIG_IS_ENABLED(SYS_MALLOC_CLEAR_ON_INIT) + memset((void *)mem_malloc_start, '\0', size); +#endif +} +#endif /* __UBOOT__ */ diff --git a/include/malloc.h b/include/malloc.h index 4608082d2e0..e0a5b732203 100644 --- a/include/malloc.h +++ b/include/malloc.h @@ -625,6 +625,33 @@ void mspace_inspect_all(mspace msp, void* arg); #endif /* MSPACES */ +/* --------------------- U-Boot additions --------------------- */ + +#ifdef __UBOOT__ +#include <linux/types.h> + +/* Memory pool boundaries */ +extern ulong mem_malloc_start; +extern ulong mem_malloc_end; +extern ulong mem_malloc_brk; + +/** + * mem_malloc_init() - Initialize the malloc() heap + * + * @start: Start address of heap memory region + * @size: Size of heap memory region in bytes + */ +void mem_malloc_init(ulong start, ulong size); + +/** + * sbrk() - Extend the heap + * + * @increment: Number of bytes to add (or remove if negative) + * Return: Previous break value on success, MORECORE_FAILURE on error + */ +void *sbrk(ptrdiff_t increment); +#endif /* __UBOOT__ */ + #ifdef __cplusplus }; /* end of extern "C" */ #endif -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Include log.h early to prevent an assert() redefinition warning. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- common/dlmalloc.c | 1 + 1 file changed, 1 insertion(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 480dd46c0cf..ff13a779211 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -562,6 +562,7 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #define MALLOC_FAILURE_ACTION #define ABORT do {} while (1) +#include <log.h> #include <malloc.h> #include <mapmem.h> #include <asm/global_data.h> -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> If we are to have driver model before relocation we need to support some way of calling memory allocation routines. The standard malloc() is pretty complicated: 1. It uses some BSS memory for its state, and BSS is not available before relocation 2. It supports algorithms for reducing memory fragmentation and improving performace of free(). Before relocation we could happily just not support free(). 3. It includes about 4KB of code (Thumb 2) and 1KB of data. However since this has been loaded anyway this is not really a problem. The simplest way to support pre-relocation malloc() is to reserve an area of memory and allocate it in increasing blocks as needed. This implementation does this. To enable it, you need to define the size of the malloc() pool as described in the README. It will be located above the pre-relocation stack on supported architectures. Note that this implementation is only useful on machines which have some memory available before dram_init() is called - this includes those that do no DRAM init (like tegra) and those that do it in SPL (quite a few boards). Enabling driver model preior to relocation for the rest of the boards is left for a later exercise. Changes from original commit: - Squash in commit 'malloc: Redirect to malloc_simple before relocation' - Modify dlmalloc/dlfree/dlrealloc/dlmemalign (new 2.8.6 names) - Add #ifdef __UBOOT__ wrapper around the checks - Redirect to malloc_simple()/memalign_simple() instead of embedding code - Add declarations for malloc_simple() and memalign_simple() to malloc.h - Move global_data.h include and DECLARE_GLOBAL_DATA_PTR to top - Add proper documentation for the two new functions Signed-off-by: Simon Glass <sjg@chromium.org> Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> (cherry picked from commit d59476b6446799c21e64147d86483140154c1886) --- common/dlmalloc.c | 38 ++++++++++++++++++++++++++++++++++++++ include/malloc.h | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index baa9b500e10..f0b6db20f5c 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -565,6 +565,7 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #include <log.h> #include <malloc.h> #include <mapmem.h> +#include <vsprintf.h> #include <asm/global_data.h> DECLARE_GLOBAL_DATA_PTR; @@ -4583,6 +4584,11 @@ static void* tmalloc_small(mstate m, size_t nb) { void* dlmalloc(size_t bytes) { #ifdef __UBOOT__ +#if CONFIG_IS_ENABLED(SYS_MALLOC_F) + if (!(gd->flags & GD_FLG_FULL_MALLOC_INIT)) + return malloc_simple(bytes); +#endif + /* Return NULL if not initialized yet */ if (!mem_malloc_start && !mem_malloc_end) return NULL; @@ -4725,6 +4731,13 @@ void* dlmalloc(size_t bytes) { /* ---------------------------- free --------------------------- */ void dlfree(void* mem) { +#ifdef __UBOOT__ +#if CONFIG_IS_ENABLED(SYS_MALLOC_F) + /* free() is a no-op - all the memory will be freed on relocation */ + if (!(gd->flags & GD_FLG_FULL_MALLOC_INIT)) + return; +#endif +#endif /* Consolidate freed chunks with preceeding or succeeding bordering free chunks, if they exist, and then place in a bin. Intermixed @@ -5228,6 +5241,14 @@ static void internal_inspect_all(mstate m, #if !ONLY_MSPACES void* dlrealloc(void* oldmem, size_t bytes) { +#ifdef __UBOOT__ +#if CONFIG_IS_ENABLED(SYS_MALLOC_F) + if (!(gd->flags & GD_FLG_FULL_MALLOC_INIT)) { + /* This is harder to support and should not be needed */ + panic("pre-reloc realloc() is not supported"); + } +#endif +#endif void* mem = 0; if (oldmem == 0) { mem = dlmalloc(bytes); @@ -5304,6 +5325,12 @@ void* dlrealloc_in_place(void* oldmem, size_t bytes) { } void* dlmemalign(size_t alignment, size_t bytes) { +#ifdef __UBOOT__ +#if CONFIG_IS_ENABLED(SYS_MALLOC_F) + if (!(gd->flags & GD_FLG_FULL_MALLOC_INIT)) + return memalign_simple(alignment, bytes); +#endif +#endif if (alignment <= MALLOC_ALIGNMENT) { return dlmalloc(bytes); } @@ -6366,4 +6393,15 @@ void mem_malloc_init(ulong start, ulong size) memset((void *)mem_malloc_start, '\0', size); #endif } + +int initf_malloc(void) +{ +#if CONFIG_IS_ENABLED(SYS_MALLOC_F) + assert(gd->malloc_base); /* Set up by crt0.S */ + gd->malloc_limit = CONFIG_VAL(SYS_MALLOC_F_LEN); + gd->malloc_ptr = 0; +#endif + + return 0; +} #endif /* __UBOOT__ */ diff --git a/include/malloc.h b/include/malloc.h index e0a5b732203..d5cccc96e50 100644 --- a/include/malloc.h +++ b/include/malloc.h @@ -650,6 +650,42 @@ void mem_malloc_init(ulong start, ulong size); * Return: Previous break value on success, MORECORE_FAILURE on error */ void *sbrk(ptrdiff_t increment); + +/** + * malloc_simple() - Allocate memory from the simple malloc pool + * + * Allocates memory from a simple pool used before full malloc() is available. + * This is used before relocation when BSS is not yet available for dlmalloc's + * state. Memory allocated with this function cannot be freed. + * + * @size: Number of bytes to allocate + * Return: Pointer to allocated memory, or NULL if pool is exhausted + */ +void *malloc_simple(size_t size); + +/** + * memalign_simple() - Allocate aligned memory from the simple malloc pool + * + * Allocates aligned memory from a simple pool used before full malloc() is + * available. This is used before relocation when BSS is not yet available + * for dlmalloc's state. Memory allocated with this function cannot be freed. + * + * @alignment: Required alignment (must be a power of 2) + * @bytes: Number of bytes to allocate + * Return: Pointer to allocated memory, or NULL if pool is exhausted + */ +void *memalign_simple(size_t alignment, size_t bytes); + +/** + * initf_malloc() - Set up the early malloc() pool + * + * Sets up the simple malloc() pool which is used before full malloc() + * is available after relocation. + * + * Return: 0 (always succeeds) + */ +int initf_malloc(void); + #endif /* __UBOOT__ */ #ifdef __cplusplus -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Enable INSECURE=1 to skip runtime heap validation checks (except for sandbox), and NO_MALLINFO=1 to remove mallinfo support (except when unit tests are enabled). These reduce code size significantly. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- common/dlmalloc.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 98de6523758..268d3fea52a 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -563,6 +563,14 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #define NO_MALLOC_STATS 1 #define USE_LOCKS 0 #define USE_SPIN_LOCKS 0 + +#if !CONFIG_IS_ENABLED(UNIT_TEST) +#define NO_MALLINFO 1 +#endif +#if !CONFIG_IS_ENABLED(SANDBOX) +#define INSECURE 1 +#endif + #define MALLOC_FAILURE_ACTION #define ABORT do {} while (1) -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> When running sandbox, U-Boot's malloc symbols can be hooked into the GOT before U-Boot code runs. This causes issues because the dynamic linker may call malloc/free before gd is initialized. Use hidden visibility for malloc symbols to prevent them from being hooked into the GOT, so only code in the U-Boot binary itself calls them; any other code calls the standard C library malloc(). Changes from original commit: - Use DLMALLOC_EXPORT mechanism instead of #pragma in malloc.h Cc: Rabin Vincent <rabin@rab.in> Signed-off-by: Stephen Warren <swarren@wwwdotorg.org> Reviewed-by: Tom Rini <trini@konsulko.com> Reviewed-by: Simon Glass <sjg@chromium.org> Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> (cherry picked from commit 2f0bcd4de1a5b990e58d12cd0c7f9d7e9248fec4) --- common/dlmalloc.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 5a8e463671c..d53cbf2f2e1 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -538,6 +538,15 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #define DLMALLOC_VERSION 20806 #endif /* DLMALLOC_VERSION */ +/* + * For U-Boot, use hidden visibility to prevent malloc symbols from being + * hooked into the GOT, avoiding issues during early initialization before + * gd is set up. + */ +#ifdef __UBOOT__ +#define DLMALLOC_EXPORT extern __attribute__((visibility("hidden"))) +#endif + #ifndef DLMALLOC_EXPORT #define DLMALLOC_EXPORT extern #endif -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> In order to allow use of both U-Boot's malloc() and the C library's version, set a prefix for the allocation functions so that they can co-exist. This is only done for sandbox. For other archs everything remains the same. Signed-off-by: Simon Glass <sjg@chromium.org> Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> (cherry picked from cfda60f99ae237494e9341aad9676152d3bac3c9) --- include/malloc.h | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/include/malloc.h b/include/malloc.h index d5cccc96e50..76068032da7 100644 --- a/include/malloc.h +++ b/include/malloc.h @@ -60,6 +60,14 @@ extern "C" { #if !ONLY_MSPACES +/* + * Rename the U-Boot alloc functions so that sandbox can still use the system + * ones + */ +#ifdef CONFIG_SANDBOX +#define USE_DL_PREFIX +#endif + #ifndef USE_DL_PREFIX #define dlcalloc calloc #define dlfree free @@ -82,6 +90,21 @@ extern "C" { #define dlindependent_calloc independent_calloc #define dlindependent_comalloc independent_comalloc #define dlbulk_free bulk_free +#else /* USE_DL_PREFIX */ +/* Ensure that U-Boot actually uses dlmalloc versions */ +#define calloc(n, s) dlcalloc(n, s) +#define free(p) dlfree(p) +#define malloc(s) dlmalloc(s) +#define memalign(a, s) dlmemalign(a, s) +#define posix_memalign(p, a, s) dlposix_memalign(p, a, s) +#define realloc(p, s) dlrealloc(p, s) +#define valloc(s) dlvalloc(s) +#define pvalloc(s) dlpvalloc(s) +#define mallinfo() dlmallinfo() +#define mallopt(p, v) dlmallopt(p, v) +#define malloc_trim(s) dlmalloc_trim(s) +#define malloc_stats() dlmalloc_stats() +#define malloc_usable_size(p) dlmalloc_usable_size(p) #endif /* USE_DL_PREFIX */ #if !NO_MALLINFO -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> It is helpful to test that out-of-memory checks work correctly in code that calls malloc(). Add a simple way to force failure after a given number of malloc() calls. Also add support for realloc() testing (from commit 04894f5ad53). Changes from original commits: - Variable declarations moved to top of U-Boot section (before dlmalloc()) - Adapted to new dlmalloc function names (dlmalloc/dlrealloc vs mALLOc/rEALLOc) Signed-off-by: Simon Glass <sjg@chromium.org> Reviewed-by: Sean Anderson <seanga2@gmail.com> Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> (cherry picked from commit 62d638386c17d17b929ad10956c7f60825335a4e) (cherry picked from commit 04894f5ad53cab0ee03eb3bc1cc1682e22f5dd1b) --- common/dlmalloc.c | 24 ++++++++++++++++++++++++ include/malloc.h | 12 ++++++++++++ 2 files changed, 36 insertions(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 9298fc445e4..aacc9b5db3b 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -592,6 +592,9 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP DECLARE_GLOBAL_DATA_PTR; +static bool malloc_testing; /* enable test mode */ +static int malloc_max_allocs; /* return NULL after this many calls to malloc() */ + ulong mem_malloc_start; ulong mem_malloc_end; ulong mem_malloc_brk; @@ -4614,6 +4617,11 @@ void* dlmalloc(size_t bytes) { /* Return NULL if not initialized yet */ if (!mem_malloc_start && !mem_malloc_end) return NULL; + + if (CONFIG_IS_ENABLED(UNIT_TEST) && malloc_testing) { + if (--malloc_max_allocs < 0) + return NULL; + } #endif /* Basic algorithm: @@ -5328,6 +5336,10 @@ void* dlrealloc(void* oldmem, size_t bytes) { panic("pre-reloc realloc() is not supported"); } #endif + if (CONFIG_IS_ENABLED(UNIT_TEST) && malloc_testing) { + if (--malloc_max_allocs < 0) + return NULL; + } #endif void* mem = 0; if (oldmem == 0) { @@ -6491,6 +6503,17 @@ void mem_malloc_init(ulong start, ulong size) #endif } +void malloc_enable_testing(int max_allocs) +{ + malloc_testing = true; + malloc_max_allocs = max_allocs; +} + +void malloc_disable_testing(void) +{ + malloc_testing = false; +} + int initf_malloc(void) { #if CONFIG_IS_ENABLED(SYS_MALLOC_F) @@ -6501,4 +6524,5 @@ int initf_malloc(void) return 0; } + #endif /* __UBOOT__ */ diff --git a/include/malloc.h b/include/malloc.h index 76068032da7..72db7fdb507 100644 --- a/include/malloc.h +++ b/include/malloc.h @@ -658,6 +658,18 @@ extern ulong mem_malloc_start; extern ulong mem_malloc_end; extern ulong mem_malloc_brk; +/** + * malloc_enable_testing() - Enable malloc failure testing + * + * @max_allocs: Number of allocations to allow before returning NULL + */ +void malloc_enable_testing(int max_allocs); + +/** + * malloc_disable_testing() - Disable malloc failure testing + */ +void malloc_disable_testing(void); + /** * mem_malloc_init() - Initialize the malloc() heap * -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add STATIC_IF_MCHECK macro and rename the main allocation functions to *_impl versions (dlmalloc_impl, dlfree_impl, dlrealloc_impl, dlmemalign_impl, dlcalloc_impl) to prepare for mcheck wrappers. When MCHECK_HEAP_PROTECTION is not defined, the *_impl macros map directly to the original function names, so behavior is unchanged. Changes from original commit: - Adapted to new dlmalloc 2.8.6 function names (dl* vs mALLOc, etc.) - Updated all internal calls to use *_impl versions Signed-off-by: Eugene Uriev <eugeneuriev@gmail.com> Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> (cherry picked from commit c82ff481159d2cf7e637c709df84883e09bba588) --- common/dlmalloc.c | 40 ++++++++++++++++++++++++++++------------ 1 file changed, 28 insertions(+), 12 deletions(-) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 03fd902c9f6..972cadd2e2f 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -557,6 +557,17 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #define DEBUG 1 #endif +#ifdef MCHECK_HEAP_PROTECTION +#define STATIC_IF_MCHECK static +#else +#define STATIC_IF_MCHECK +#define dlmalloc_impl dlmalloc +#define dlfree_impl dlfree +#define dlrealloc_impl dlrealloc +#define dlmemalign_impl dlmemalign +#define dlcalloc_impl dlcalloc +#endif + #define LACKS_FCNTL_H #define LACKS_UNISTD_H #define LACKS_SYS_PARAM_H @@ -4607,7 +4618,8 @@ static void* tmalloc_small(mstate m, size_t nb) { #if !ONLY_MSPACES -void* dlmalloc(size_t bytes) { +STATIC_IF_MCHECK +void* dlmalloc_impl(size_t bytes) { #ifdef __UBOOT__ #if CONFIG_IS_ENABLED(SYS_MALLOC_F) if (!(gd->flags & GD_FLG_FULL_MALLOC_INIT)) @@ -4764,7 +4776,8 @@ void* dlmalloc(size_t bytes) { /* ---------------------------- free --------------------------- */ -void dlfree(void* mem) { +STATIC_IF_MCHECK +void dlfree_impl(void* mem) { #ifdef __UBOOT__ #if CONFIG_IS_ENABLED(SYS_MALLOC_F) /* free() is a no-op - all the memory will be freed on relocation */ @@ -4885,7 +4898,8 @@ void dlfree(void* mem) { #endif /* FOOTERS */ } -void* dlcalloc(size_t n_elements, size_t elem_size) { +STATIC_IF_MCHECK +void* dlcalloc_impl(size_t n_elements, size_t elem_size) { void* mem; size_t req = 0; if (n_elements != 0) { @@ -4894,7 +4908,7 @@ void* dlcalloc(size_t n_elements, size_t elem_size) { (req / n_elements != elem_size)) req = MAX_SIZE_T; /* force downstream failure on overflow */ } - mem = dlmalloc(req); + mem = dlmalloc_impl(req); #ifdef __UBOOT__ #if CONFIG_IS_ENABLED(SYS_MALLOC_F) /* For pre-reloc simple malloc, just zero the memory directly */ @@ -5328,7 +5342,8 @@ static void internal_inspect_all(mstate m, #if !ONLY_MSPACES -void* dlrealloc(void* oldmem, size_t bytes) { +STATIC_IF_MCHECK +void* dlrealloc_impl(void* oldmem, size_t bytes) { #ifdef __UBOOT__ #if CONFIG_IS_ENABLED(SYS_MALLOC_F) if (!(gd->flags & GD_FLG_FULL_MALLOC_INIT)) { @@ -5343,14 +5358,14 @@ void* dlrealloc(void* oldmem, size_t bytes) { #endif void* mem = 0; if (oldmem == 0) { - mem = dlmalloc(bytes); + mem = dlmalloc_impl(bytes); } else if (bytes >= MAX_REQUEST) { MALLOC_FAILURE_ACTION; } #ifdef REALLOC_ZERO_BYTES_FREES else if (bytes == 0) { - dlfree(oldmem); + dlfree_impl(oldmem); } #endif /* REALLOC_ZERO_BYTES_FREES */ else { @@ -5433,7 +5448,8 @@ void* dlrealloc_in_place(void* oldmem, size_t bytes) { return mem; } -void* dlmemalign(size_t alignment, size_t bytes) { +STATIC_IF_MCHECK +void* dlmemalign_impl(size_t alignment, size_t bytes) { #ifdef __UBOOT__ #if CONFIG_IS_ENABLED(SYS_MALLOC_F) if (!(gd->flags & GD_FLG_FULL_MALLOC_INIT)) @@ -5441,7 +5457,7 @@ void* dlmemalign(size_t alignment, size_t bytes) { #endif #endif if (alignment <= MALLOC_ALIGNMENT) { - return dlmalloc(bytes); + return dlmalloc_impl(bytes); } return internal_memalign(gm, alignment, bytes); } @@ -5449,7 +5465,7 @@ void* dlmemalign(size_t alignment, size_t bytes) { int dlposix_memalign(void** pp, size_t alignment, size_t bytes) { void* mem = 0; if (alignment == MALLOC_ALIGNMENT) - mem = dlmalloc(bytes); + mem = dlmalloc_impl(bytes); else { size_t d = alignment / sizeof(void*); size_t r = alignment % sizeof(void*); @@ -5473,14 +5489,14 @@ void* dlvalloc(size_t bytes) { size_t pagesz; ensure_initialization(); pagesz = mparams.page_size; - return dlmemalign(pagesz, bytes); + return dlmemalign_impl(pagesz, bytes); } void* dlpvalloc(size_t bytes) { size_t pagesz; ensure_initialization(); pagesz = mparams.page_size; - return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE)); + return dlmemalign_impl(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE)); } void** dlindependent_calloc(size_t n_elements, size_t elem_size, -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add mcheck wrapper functions for dlmalloc, dlfree, dlrealloc, dlmemalign, and dlcalloc. When MCHECK_HEAP_PROTECTION is enabled, these wrappers call the mcheck hooks around the internal *_impl functions to provide heap corruption detection. Also add the mcheck() and mprobe() API functions. Changes from original commit: - Adapted for dlmalloc 2.8.6 function names (dl* instead of mALLOc) - Updated function signatures (void* instead of Void_t*) Signed-off-by: Eugene Uriev <eugeneuriev@gmail.com> Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> (cherry picked from commit 151493a875071448e2582489f6fa84d1630b3368) --- common/dlmalloc.c | 63 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 4f88e48f4b0..102b6c2bf8d 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -5591,6 +5591,69 @@ size_t dlmalloc_usable_size(const void* mem) { return 0; } +#ifdef MCHECK_HEAP_PROTECTION +#include "mcheck_core.inc.h" + +void *dlmalloc(size_t bytes) +{ + size_t fullsz = mcheck_alloc_prehook(bytes); + void *p = dlmalloc_impl(fullsz); + + if (!p) + return p; + return mcheck_alloc_posthook(p, bytes); +} + +void dlfree(void *mem) { dlfree_impl(mcheck_free_prehook(mem)); } + +void *dlrealloc(void *oldmem, size_t bytes) +{ + if (bytes == 0) { + if (oldmem) + dlfree(oldmem); + return NULL; + } + + if (oldmem == NULL) + return dlmalloc(bytes); + + void *p = mcheck_reallocfree_prehook(oldmem); + size_t newsz = mcheck_alloc_prehook(bytes); + + p = dlrealloc_impl(p, newsz); + if (!p) + return p; + return mcheck_alloc_noclean_posthook(p, bytes); +} + +void *dlmemalign(size_t alignment, size_t bytes) +{ + return NULL; +} + +/* dlpvalloc, dlvalloc redirect to dlmemalign, so they need no wrapping */ + +void *dlcalloc(size_t n, size_t elem_size) +{ + /* NB: no overflow check here */ + size_t fullsz = mcheck_alloc_prehook(n * elem_size); + void *p = dlcalloc_impl(1, fullsz); + + if (!p) + return p; + return mcheck_alloc_noclean_posthook(p, n * elem_size); +} + +/* mcheck API */ +int mcheck(mcheck_abortfunc_t f) +{ + mcheck_initialize(f, 0); + return 0; +} + +enum mcheck_status mprobe(void *__ptr) { return mcheck_mprobe(__ptr); } +#endif /* MCHECK_HEAP_PROTECTION */ + #endif /* !ONLY_MSPACES */ /* ----------------------------- user mspaces ---------------------------- */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add mcheck_pedantic_prehook() calls to dlmalloc, dlrealloc, dlmemalign, and dlcalloc wrapper functions. Also add the mcheck_pedantic() and mcheck_check_all() API functions. The pedantic mode is runtime controlled, so the registry hooks are called on every allocation operation. Changes from original commit: - Uses dl* function names instead of mALLOc style names Signed-off-by: Eugene Uriev <eugeneuriev@gmail.com> Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> (cherry picked from commit 18c1bfafe0ccdd3229d91bbb07ed942e9f233f93) --- common/dlmalloc.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index c9eb18787e8..4ee7c6c133f 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -5596,6 +5596,7 @@ size_t dlmalloc_usable_size(const void* mem) { void *dlmalloc(size_t bytes) { + mcheck_pedantic_prehook(); size_t fullsz = mcheck_alloc_prehook(bytes); void *p = dlmalloc_impl(fullsz); @@ -5608,6 +5609,7 @@ void dlfree(void *mem) { dlfree_impl(mcheck_free_prehook(mem)); } void *dlrealloc(void *oldmem, size_t bytes) { + mcheck_pedantic_prehook(); if (bytes == 0) { if (oldmem) dlfree(oldmem); @@ -5628,6 +5630,7 @@ void *dlrealloc(void *oldmem, size_t bytes) void *dlmemalign(size_t alignment, size_t bytes) { + mcheck_pedantic_prehook(); size_t fullsz = mcheck_memalign_prehook(alignment, bytes); void *p = dlmemalign_impl(alignment, fullsz); @@ -5640,6 +5643,7 @@ void *dlmemalign(size_t alignment, size_t bytes) void *dlcalloc(size_t n, size_t elem_size) { + mcheck_pedantic_prehook(); /* NB: no overflow check here */ size_t fullsz = mcheck_alloc_prehook(n * elem_size); void *p = dlcalloc_impl(1, fullsz); @@ -5650,12 +5654,20 @@ void *dlcalloc(size_t n, size_t elem_size) } /* mcheck API */ +int mcheck_pedantic(mcheck_abortfunc_t f) +{ + mcheck_initialize(f, 1); + return 0; +} + int mcheck(mcheck_abortfunc_t f) { mcheck_initialize(f, 0); return 0; } +void mcheck_check_all(void) { mcheck_pedantic_check(); } + enum mcheck_status mprobe(void *__ptr) { return mcheck_mprobe(__ptr); } #endif /* MCHECK_HEAP_PROTECTION */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move the malloc state initialisation from lazy init in sys_alloc() to explicit init in mem_malloc_init(). This allows is_initialized() to always return true for U-Boot, eliminating runtime checks. The initialisation sets up: - least_addr, seg.base, seg.size, seg.sflags - magic, release_checks, mflags - bins (via init_bins) - top chunk (via init_top) - footprint tracking Add a simplified sys_alloc() for small builds. Since the heap is pre-allocated with fixed size, sys_alloc() only needs to extend via sbrk() if space remains: no mmap, no multiple segments, no comple merging. The helper functions mmap_alloc(), mmap_resize(), prepend_alloc() and add_segment() are thus compiled out for non-sandbox builds. This is controlled by a new SIMPLE_SYSALLOC option, which is the default. Sandbox retains full functionality for testing. With this, the new dlmalloc is approximately at parity with the old one, e.g. about 400 bytes less code on Thumb2 (firefly-rk3288). There is a strange case here with a small number of boards which set up the full malloc() when CONFIG_SYS_MALLOC_SIMPLE is enabled. This cannot work. With CONFIG_SPL_SYS_MALLOC_SIMPLE, all malloc()/free()/realloc() calls are redirected to simple implementations via macros in thhe malloc.h header. In this case, mem_malloc_init() doesn't need to init the dlmalloc state structure (gm) since it will never be used. Initing _gm_ pulls in the entire malloc_state BSS structure (~472 bytes) plus initialisation code (~128 bytes), adding ~600 bytes to SPL on boards that use full malloc (K3 platforms with CONFIG_K3_LOAD_SYSFW). Skip the _gm_ init when SYS_MALLOC_SIMPLE is enabled. These boards call mem_malloc_init() even though it will have no effect: $ ./tools/qconfig.py -f CONFIG_K3_LOAD_SYSFW SPL_SYS_MALLOC_SIMPLE -l am62ax_evm_r5 am62px_evm_r5 am62x_beagleplay_r5 am62x_evm_r5 am62x_evm_r5_ethboot am62x_lpsk_r5 am64x_evm_r5 am68_sk_r5 am69_sk_r5 j721s2_evm_r5 j722s_evm_r5 j784s4_evm_r5 phycore_am62x_r5 phycore_am62x_r5_usbdfu phycore_am64x_r5 verdin-am62_r5 Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- common/dlmalloc.c | 88 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 86 insertions(+), 2 deletions(-) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 4ee7c6c133f..9330848d059 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -595,6 +595,11 @@ static inline void MALLOC_COPY(void *dest, const void *src, size_t sz) { memcpy( #define INSECURE 1 #endif +/* Use simplified sys_alloc for non-sandbox builds */ +#if !IS_ENABLED(CONFIG_SANDBOX) +#define SIMPLE_SYSALLOC 1 +#endif + #define MALLOC_FAILURE_ACTION #define ABORT do {} while (1) @@ -2719,7 +2724,12 @@ static struct malloc_state _gm_; #endif /* !ONLY_MSPACES */ +#if defined(__UBOOT__) && SIMPLE_SYSALLOC +/* U-Boot initializes in mem_malloc_init() so is_initialized() is always true */ +#define is_initialized(M) 1 +#else #define is_initialized(M) ((M)->top != 0) +#endif /* -------------------------- system alloc setup ------------------------- */ @@ -3903,6 +3913,7 @@ static void internal_malloc_stats(mstate m) { requirements (especially in memalign). */ +#if !defined(__UBOOT__) || !SIMPLE_SYSALLOC /* Malloc using mmap */ static void* mmap_alloc(mstate m, size_t nb) { size_t mmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK); @@ -3934,7 +3945,9 @@ static void* mmap_alloc(mstate m, size_t nb) { } return 0; } +#endif /* !defined(__UBOOT__) || !SIMPLE_SYSALLOC */ +#if !defined(__UBOOT__) || !NO_REALLOC_IN_PLACE /* Realloc using mmap */ static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb, int flags) { size_t oldsize = chunksize(oldp); @@ -3969,12 +3982,13 @@ static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb, int flags) { } return 0; } +#endif /* !NO_REALLOC_IN_PLACE */ /* -------------------------- mspace management -------------------------- */ /* Initialize top chunk and its size */ -static void init_top(mstate m, mchunkptr p, size_t psize) { +static void __maybe_unused init_top(mstate m, mchunkptr p, size_t psize) { /* Ensure alignment */ size_t offset = align_offset(chunk2mem(p)); p = (mchunkptr)((char*)p + offset); @@ -3989,7 +4003,7 @@ static void init_top(mstate m, mchunkptr p, size_t psize) { } /* Initialize bins for a new mstate that is otherwise zeroed out */ -static void init_bins(mstate m) { +static void __maybe_unused init_bins(mstate m) { /* Establish circular links for smallbins */ bindex_t i; for (i = 0; i < NSMALLBINS; ++i) { @@ -4017,6 +4031,7 @@ static void reset_on_error(mstate m) { } #endif /* PROCEED_ON_ERROR */ +#if !defined(__UBOOT__) || !SIMPLE_SYSALLOC /* Allocate chunk and prepend remainder with chunk in successor base. */ static void* prepend_alloc(mstate m, char* newbase, char* oldbase, size_t nb) { @@ -4111,9 +4126,62 @@ static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) { check_top_chunk(m, m->top); } +#endif /* !__UBOOT__ || !SIMPLE_SYSALLOC */ /* -------------------------- System allocation -------------------------- */ +#if defined(__UBOOT__) && SIMPLE_SYSALLOC +/* + * U-Boot simplified sys_alloc: The heap is pre-allocated with fixed size in + * mem_malloc_init(), so we can only extend via sbrk() if space remains. + * No mmap, no multiple segments, no complex merging needed. + */ +static void* sys_alloc(mstate m, size_t nb) { + char* tbase; + size_t asize; + size_t tsize; + + asize = granularity_align(nb + SYS_ALLOC_PADDING); + if (asize <= nb) + return NULL; /* wraparound */ + + tbase = (char *)CALL_MORECORE(asize); + if (tbase == CMFAIL) { + MALLOC_FAILURE_ACTION; + return NULL; + } + tsize = asize; + + m->footprint += tsize; + if (m->footprint > m->max_footprint) + m->max_footprint = m->footprint; + + /* Extend the top chunk - sbrk returns contiguous memory */ + if (tbase == m->seg.base + m->seg.size) { + m->seg.size += tsize; + init_top(m, m->top, m->topsize + tsize); + } else { + /* Non-contiguous - shouldn't happen with U-Boot's simple sbrk */ + return NULL; + } + + if (nb < m->topsize) { + size_t rsize = m->topsize -= nb; + mchunkptr p = m->top; + mchunkptr r = m->top = chunk_plus_offset(p, nb); + r->head = rsize | PINUSE_BIT; + set_size_and_pinuse_of_inuse_chunk(m, p, nb); + check_top_chunk(m, m->top); + check_malloced_chunk(m, chunk2mem(p), nb); + return chunk2mem(p); + } + + MALLOC_FAILURE_ACTION; + return NULL; +} + +#else /* !__UBOOT__ || !SIMPLE_SYSALLOC */ + /* Get memory from system using MORECORE or MMAP */ static void* sys_alloc(mstate m, size_t nb) { char* tbase = CMFAIL; @@ -4322,6 +4390,7 @@ static void* sys_alloc(mstate m, size_t nb) { MALLOC_FAILURE_ACTION; return 0; } +#endif /* !__UBOOT__ || !SIMPLE_SYSALLOC */ /* ----------------------- system deallocation -------------------------- */ @@ -6601,6 +6670,21 @@ void mem_malloc_init(ulong start, ulong size) #if CONFIG_IS_ENABLED(SYS_MALLOC_CLEAR_ON_INIT) memset((void *)mem_malloc_start, '\0', size); #endif + +#if !CONFIG_IS_ENABLED(SYS_MALLOC_SIMPLE) + /* Initialize the malloc state so is_initialized() is true */ + gm->least_addr = (char *)mem_malloc_start; + gm->seg.base = (char *)mem_malloc_start; + gm->seg.size = size; + gm->seg.sflags = 0; /* not mmapped */ + gm->magic = mparams.magic; + gm->release_checks = MAX_RELEASE_CHECK_RATE; + gm->mflags = mparams.default_mflags; + init_bins(gm); + init_top(gm, (mchunkptr)mem_malloc_start, size - TOP_FOOT_SIZE); + gm->footprint = size; + gm->max_footprint = size; +#endif } void malloc_enable_testing(int max_allocs) -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> There are quite a few options available which can reduce code size. Most of them only make sense in SPL. Add a Kconfig option to enable a smaller dlmalloc for U-Boot proper and SPL. Signed-off-by: Simon Glass <simon.glass@canonical.com> --- Kconfig | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/Kconfig b/Kconfig index 357f027cc97..c4a65597035 100644 --- a/Kconfig +++ b/Kconfig @@ -464,6 +464,53 @@ config SYS_MALLOC_DEFAULT_TO_INIT If such a scenario is sought choose yes. +config SYS_MALLOC_SMALL + bool "Optimise malloc for code size" + help + Enable code-size optimisations for dlmalloc. This: + + - Disables tree bins for allocations >= 256 bytes, using simple + linked-list bins instead. This changes large-allocation performance + from O(log n) to O(n) but saves ~1.5-2KB. + + - Simplifies memalign() by removing fallback retry logic that attempts + multiple allocation strategies when initial over-allocation fails. + This saves ~100-150 bytes. + + - Disables in-place realloc optimisation, which resizes allocations + without copying if space permits. This saves ~200 bytes. + + - Uses static malloc parameters instead of runtime-configurable ones. + + These optimisations may increase fragmentation and reduce performance + for workloads with many large or aligned allocations, but are suitable + for most U-Boot use cases where code size is more important. + + If unsure, say N. + +config SPL_SYS_MALLOC_SMALL + bool "Optimise malloc for code size in SPL" + depends on SPL && !SPL_SYS_MALLOC_SIMPLE + default y + help + Enable code-size optimisations for dlmalloc in SPL. This: + + - Disables tree bins for allocations >= 256 bytes, using simple + linked-list bins instead. This changes large-allocation performance + from O(log n) to O(n) but saves ~1.5-2KB. + + - Simplifies memalign() by removing fallback retry logic. This saves + ~100-150 bytes. + + - Disables in-place realloc optimisation. This saves ~200 bytes. + + - Uses static malloc parameters instead of runtime-configurable ones. + + SPL typically has predictable memory usage where these optimisations + have minimal impact, making the code size savings worthwhile. + + If unsure, say Y to minimize SPL code size. + config TOOLS_DEBUG bool "Enable debug information for tools" help -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add a new NO_TREE_BINS option to disable binary-tree bins for large allocations (>= 256 bytes). While this is an invasive changes, it saves about 1.25K of code size on arm64 (as well as 250 bytes of data). When enabled, all large chunks use a simple doubly-linked list instead of tree bins, trading O(log n) performance for smaller code size. The tradeoff here is that large allocations use O(n) search instead of O(log n) and fragmentation coud also become worse. So performance will suffer when there are lots of large allocations and frees are done. This is rare in SPL. Implementation: - Add a dedicated mchunkptr largebin field to malloc_state - Replace treebins[NTREEBINS] array with a single linked-list pointer - Implement simplified insert/unlink operations using largebin list - Update allocation functions (tmalloc_small/large) for linear search - Update heap checking functions (do_check_treebin, bin_find) to handle linked list traversal instead of tree traversal It is enabled by CONFIG_SYS_MALLOC_SMALL, i.e. by default in SPL. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- common/dlmalloc.c | 157 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 154 insertions(+), 3 deletions(-) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 4439d278188..13ae0e10918 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -597,6 +597,9 @@ static inline void MALLOC_COPY(void *dest, const void *src, size_t sz) { memcpy( #if CONFIG_IS_ENABLED(SYS_MALLOC_SMALL) #define NO_REALLOC_IN_PLACE 1 +#define NO_TREE_BINS 1 +#else +#define NO_TREE_BINS 0 #endif /* Use simplified sys_alloc for non-sandbox builds */ @@ -2686,7 +2689,11 @@ struct malloc_state { size_t release_checks; size_t magic; mchunkptr smallbins[(NSMALLBINS+1)*2]; +#if defined(__UBOOT__) && NO_TREE_BINS + mchunkptr largebin; /* Single linked list for all large chunks */ +#else tbinptr treebins[NTREEBINS]; +#endif size_t footprint; size_t max_footprint; size_t footprint_limit; /* zero means no limit */ @@ -2914,7 +2921,9 @@ static void do_check_mmapped_chunk(mstate m, mchunkptr p); static void do_check_inuse_chunk(mstate m, mchunkptr p); static void do_check_free_chunk(mstate m, mchunkptr p); static void do_check_malloced_chunk(mstate m, void* mem, size_t s); +#if !defined(__UBOOT__) || !NO_TREE_BINS static void do_check_tree(mstate m, tchunkptr t); +#endif static void do_check_treebin(mstate m, bindex_t i); static void do_check_smallbin(mstate m, bindex_t i); static void do_check_malloc_state(mstate m); @@ -2924,6 +2933,8 @@ static size_t traverse_and_check(mstate m); /* ---------------------------- Indexing Bins ---------------------------- */ +/* When NO_TREE_BINS is enabled, large chunks use a single linked list + in treebin[0] instead of the tree structure */ #define is_small(s) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS) #define small_index(s) (bindex_t)((s) >> SMALLBIN_SHIFT) #define small_index2size(i) ((i) << SMALLBIN_SHIFT) @@ -3397,6 +3408,7 @@ static void do_check_malloced_chunk(mstate m, void* mem, size_t s) { } } +#if !defined(__UBOOT__) || !NO_TREE_BINS /* Check a tree and its subtrees. */ static void do_check_tree(mstate m, tchunkptr t) { tchunkptr head = 0; @@ -3447,9 +3459,28 @@ static void do_check_tree(mstate m, tchunkptr t) { } while (u != t); assert(head != 0); } +#endif /* Check all the chunks in a treebin. */ static void do_check_treebin(mstate m, bindex_t i) { +#if defined(__UBOOT__) && NO_TREE_BINS + /* With NO_TREE_BINS, only index 0 is used for the large bin list */ + if (i == 0) { + mchunkptr p = m->largebin; + if (p != 0) { + /* Check the linked list */ + mchunkptr start = p; + do { + do_check_any_chunk(m, p); + assert(!is_inuse(p)); + assert(!next_pinuse(p)); + assert(p->fd->bk == p); + assert(p->bk->fd == p); + p = p->fd; + } while (p != start); + } + } +#else tbinptr* tb = treebin_at(m, i); tchunkptr t = *tb; int empty = (m->treemap & (1U << i)) == 0; @@ -3457,6 +3488,7 @@ static void do_check_treebin(mstate m, bindex_t i) { assert(empty); if (!empty) do_check_tree(m, t); +#endif } /* Check all the chunks in a smallbin. */ @@ -3498,6 +3530,18 @@ static int bin_find(mstate m, mchunkptr x) { } } else { +#if defined(__UBOOT__) && NO_TREE_BINS + /* With NO_TREE_BINS, all large chunks are in largebin list */ + if (m->largebin != 0) { + mchunkptr p = m->largebin; + mchunkptr start = p; + do { + if (p == x) + return 1; + p = p->fd; + } while (p != start); + } +#else bindex_t tidx; compute_tree_index(size, tidx); if (treemap_is_marked(m, tidx)) { @@ -3515,6 +3559,7 @@ static int bin_find(mstate m, mchunkptr x) { } while ((u = u->fd) != t); } } +#endif } return 0; } @@ -3744,6 +3789,53 @@ static void internal_malloc_stats(mstate m) { /* ------------------------- Operations on trees ------------------------- */ +#if defined(__UBOOT__) && NO_TREE_BINS +/* When tree bins are disabled, use a simple doubly-linked list for all large chunks */ +static void insert_large_chunk(mstate M, tchunkptr X, size_t S) { + mchunkptr XP = (mchunkptr)(X); + mchunkptr F = M->largebin; + (void)S; /* unused in NO_TREE_BINS mode */ + if (F == 0) { + M->largebin = XP; + XP->fd = XP->bk = XP; + } + else if (RTCHECK(ok_address(M, F))) { + mchunkptr B = F->bk; + if (RTCHECK(ok_address(M, B))) { + XP->fd = F; + XP->bk = B; + F->bk = XP; + B->fd = XP; + } + else { + CORRUPTION_ERROR_ACTION(M); + } + } + else { + CORRUPTION_ERROR_ACTION(M); + } +} + +static void unlink_large_chunk(mstate M, tchunkptr X) { + mchunkptr XP = (mchunkptr)(X); + mchunkptr F = XP->fd; + mchunkptr B = XP->bk; + if (F == XP) { + M->largebin = 0; + } + else if (RTCHECK(ok_address(M, F) && F->bk == XP && ok_address(M, B) && B->fd == XP)) { + F->bk = B; + B->fd = F; + if (M->largebin == XP) + M->largebin = F; + } + else { + CORRUPTION_ERROR_ACTION(M); + } +} + +#else /* !defined(__UBOOT__) || !NO_TREE_BINS */ + /* Insert chunk into tree */ #define insert_large_chunk(M, X, S) {\ tbinptr* H;\ @@ -3884,6 +3976,8 @@ static void internal_malloc_stats(mstate m) { }\ } +#endif /* !defined(__UBOOT__) || !NO_TREE_BINS */ + /* Relays to large vs small bin operations */ #define insert_chunk(M, P, S)\ @@ -4593,7 +4687,26 @@ static void dispose_chunk(mstate m, mchunkptr p, size_t psize) { static void* tmalloc_large(mstate m, size_t nb) { tchunkptr v = 0; size_t rsize = -nb; /* Unsigned negation */ +#if !defined(__UBOOT__) || !NO_TREE_BINS tchunkptr t; +#endif +#if defined(__UBOOT__) && NO_TREE_BINS + /* With NO_TREE_BINS, do a linear search through largebin list */ + if (m->largebin != 0) { + mchunkptr p = m->largebin; + mchunkptr start = p; + do { + size_t trem = chunksize(p) - nb; + if (trem < rsize) { + rsize = trem; + v = (tchunkptr)p; + if (rsize == 0) + break; + } + p = p->fd; + } while (p != start); + } +#else bindex_t idx; compute_tree_index(nb, idx); if ((t = *treebin_at(m, idx)) != 0) { @@ -4637,6 +4750,7 @@ static void* tmalloc_large(mstate m, size_t nb) { } t = leftmost_child(t); } +#endif /* If dv is a better fit, return 0 so malloc will use it */ if (v != 0 && rsize < (size_t)(m->dvsize - nb)) { @@ -4662,8 +4776,32 @@ static void* tmalloc_large(mstate m, size_t nb) { /* allocate a small request from the best fitting chunk in a treebin */ static void* tmalloc_small(mstate m, size_t nb) { - tchunkptr t, v; +#if !defined(__UBOOT__) || !NO_TREE_BINS + tchunkptr t; +#endif + tchunkptr v; size_t rsize; +#if defined(__UBOOT__) && NO_TREE_BINS + /* With NO_TREE_BINS, use largebin list for best fit search */ + if (m->largebin != 0) { + mchunkptr p = m->largebin; + mchunkptr best = p; + rsize = chunksize(p) - nb; + /* Scan the list for the best fit */ + mchunkptr start = p; + while ((p = p->fd) != start) { + size_t trem = chunksize(p) - nb; + if (trem < rsize) { + rsize = trem; + best = p; + } + } + v = (tchunkptr)best; + } + else { + return 0; + } +#else bindex_t i; binmap_t leastbit = least_bit(m->treemap); compute_bit2idx(leastbit, i); @@ -4677,6 +4815,7 @@ static void* tmalloc_small(mstate m, size_t nb) { v = t; } } +#endif if (RTCHECK(ok_address(m, v))) { mchunkptr r = chunk_plus_offset(v, nb); @@ -4794,7 +4933,13 @@ void* dlmalloc_impl(size_t bytes) { goto postaction; } - else if (gm->treemap != 0 && (mem = tmalloc_small(gm, nb)) != 0) { + else if ( +#if defined(__UBOOT__) && NO_TREE_BINS + gm->largebin != 0 && +#else + gm->treemap != 0 && +#endif + (mem = tmalloc_small(gm, nb)) != 0) { check_malloced_chunk(gm, mem, nb); goto postaction; } @@ -4804,7 +4949,13 @@ void* dlmalloc_impl(size_t bytes) { nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */ else { nb = pad_request(bytes); - if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) { + if ( +#if defined(__UBOOT__) && NO_TREE_BINS + gm->largebin != 0 && +#else + gm->treemap != 0 && +#endif + (mem = tmalloc_large(gm, nb)) != 0) { check_malloced_chunk(gm, mem, nb); goto postaction; } -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> The insert_small_chunk() and unlink_first_small_chunk() macros are inlined at multiple places in the code. Provide an option to convert these to functions, so the compiler can try to reduce code size. Add braces to the insert_chunk macro. This reduces code size imx8mp_venice SPL by about 208 bytes Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- common/dlmalloc.c | 50 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/common/dlmalloc.c b/common/dlmalloc.c index 65bfb97e1db..54fd2e4a08a 100644 --- a/common/dlmalloc.c +++ b/common/dlmalloc.c @@ -599,6 +599,7 @@ static inline void MALLOC_COPY(void *dest, const void *src, size_t sz) { memcpy( #define NO_REALLOC_IN_PLACE 1 #define SIMPLE_MEMALIGN 1 #define NO_TREE_BINS 1 +#define SMALLCHUNKS_AS_FUNCS 1 #else #define NO_TREE_BINS 0 #define SIMPLE_MEMALIGN 0 @@ -632,6 +633,10 @@ ulong mem_malloc_brk; #endif /* __UBOOT__ */ +#ifndef SMALLCHUNKS_AS_FUNCS +#define SMALLCHUNKS_AS_FUNCS 0 +#endif + #ifndef WIN32 #ifdef _WIN32 #define WIN32 1 @@ -3714,6 +3719,25 @@ static void internal_malloc_stats(mstate m) { */ /* Link a free chunk into a smallbin */ +#if defined(__UBOOT__) && SMALLCHUNKS_AS_FUNCS +static void insert_small_chunk(mstate M, mchunkptr P, size_t S) { + bindex_t I = small_index(S); + mchunkptr B = smallbin_at(M, I); + mchunkptr F = B; + assert(S >= MIN_CHUNK_SIZE); + if (!smallmap_is_marked(M, I)) + mark_smallmap(M, I); + else if (RTCHECK(ok_address(M, B->fd))) + F = B->fd; + else { + CORRUPTION_ERROR_ACTION(M); + } + B->fd = P; + F->bk = P; + P->fd = F; + P->bk = B; +} +#else #define insert_small_chunk(M, P, S) {\ bindex_t I = small_index(S);\ mchunkptr B = smallbin_at(M, I);\ @@ -3731,6 +3755,7 @@ static void internal_malloc_stats(mstate m) { P->fd = F;\ P->bk = B;\ } +#endif /* Unlink a chunk from a smallbin */ #define unlink_small_chunk(M, P, S) {\ @@ -3759,6 +3784,24 @@ static void internal_malloc_stats(mstate m) { } /* Unlink the first chunk from a smallbin */ +#if defined(__UBOOT__) && SMALLCHUNKS_AS_FUNCS +static void unlink_first_small_chunk(mstate M, mchunkptr B, mchunkptr P, bindex_t I) { + mchunkptr F = P->fd; + assert(P != B); + assert(P != F); + assert(chunksize(P) == small_index2size(I)); + if (B == F) { + clear_smallmap(M, I); + } + else if (RTCHECK(ok_address(M, F) && F->bk == P)) { + F->bk = B; + B->fd = F; + } + else { + CORRUPTION_ERROR_ACTION(M); + } +} +#else #define unlink_first_small_chunk(M, B, P, I) {\ mchunkptr F = P->fd;\ assert(P != B);\ @@ -3775,6 +3818,7 @@ static void internal_malloc_stats(mstate m) { CORRUPTION_ERROR_ACTION(M);\ }\ } +#endif /* Replace dv node, binning the old one */ /* Used only when dvsize known to be small */ @@ -3982,9 +4026,15 @@ static void unlink_large_chunk(mstate M, tchunkptr X) { /* Relays to large vs small bin operations */ +#if defined(__UBOOT__) && SMALLCHUNKS_AS_FUNCS +#define insert_chunk(M, P, S)\ + if (is_small(S)) { insert_small_chunk(M, P, S); }\ + else { tchunkptr TP = (tchunkptr)(P); insert_large_chunk(M, TP, S); } +#else #define insert_chunk(M, P, S)\ if (is_small(S)) insert_small_chunk(M, P, S)\ else { tchunkptr TP = (tchunkptr)(P); insert_large_chunk(M, TP, S); } +#endif #define unlink_chunk(M, P, S)\ if (is_small(S)) unlink_small_chunk(M, P, S)\ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add CONFIG_SYS_MALLOC_LEGACY to select the current allocator and adjust the header-file and Makefile rule to use the new dlmalloc implementation. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- Kconfig | 16 ++++++++++++++++ common/Makefile | 4 ++++ include/malloc.h | 19 +++++++------------ 3 files changed, 27 insertions(+), 12 deletions(-) diff --git a/Kconfig b/Kconfig index c4a65597035..378ecfb1867 100644 --- a/Kconfig +++ b/Kconfig @@ -511,6 +511,22 @@ config SPL_SYS_MALLOC_SMALL If unsure, say Y to minimize SPL code size. +config SYS_MALLOC_LEGACY + bool "Use legacy dlmalloc 2.6.6 instead of dlmalloc 2.8.6" + help + Select this option to use the older dlmalloc 2.6.6 implementation + instead of the newer 2.8.6 version. The legacy allocator uses a + simpler bin system, has larger code size in most cases and uses more + static data. + + The legacy allocator may have slightly worse fragmentation behavior + for some workloads but has been well-tested over many years in U-Boot. + + This option is provided for compatibility and testing. New boards + should use the default dlmalloc 2.8.6. + + If unsure, say N to use the modern allocator. + config TOOLS_DEBUG bool "Enable debug information for tools" help diff --git a/common/Makefile b/common/Makefile index ffa46ce5e06..fdf4cff94f4 100644 --- a/common/Makefile +++ b/common/Makefile @@ -71,7 +71,11 @@ obj-$(CONFIG_BOUNCE_BUFFER) += bouncebuf.o obj-$(CONFIG_$(PHASE_)SERIAL) += console.o obj-$(CONFIG_CROS_EC) += cros_ec.o +ifdef CONFIG_SYS_MALLOC_LEGACY obj-y += dlmalloc_old.o +else +obj-y += dlmalloc.o +endif obj-$(CONFIG_$(PHASE_)SYS_MALLOC_F) += malloc_simple.o obj-$(CONFIG_$(PHASE_)CYCLIC) += cyclic.o diff --git a/include/malloc.h b/include/malloc.h index 997651e5c9c..73b2da0c383 100644 --- a/include/malloc.h +++ b/include/malloc.h @@ -1,15 +1,4 @@ /* SPDX-License-Identifier: GPL-2.0+ */ -/* - * Stub header to include the old malloc header - * - * This allows the old malloc implementation to be preserved while - * preparing for a new dlmalloc version. - */ - -#include <malloc_old.h> - -#if 0 /* not active yet */ - /* Default header file for malloc-2.8.x, written by Doug Lea and released to the public domain, as explained at @@ -32,6 +21,12 @@ * If MSPACES is defined, declarations for mspace versions are included. */ +#ifdef CONFIG_SYS_MALLOC_LEGACY + +#include <malloc_old.h> + +#else + #ifndef MALLOC_280_H #define MALLOC_280_H @@ -748,4 +743,4 @@ int initf_malloc(void); #endif /* MALLOC_280_H */ -#endif /* not active yet */ +#endif /* !CONFIG_SYS_MALLOC_LEGACY */ -- 2.43.0