mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-11-30 00:21:06 +00:00
bdaeea1b68
This annotates malloc and friends so that valgrind can track the heap. To do this, we need to follow a few rules: * Call VALGRIND_MALLOCLIKE_BLOCK whenever we malloc something * Call VALGRIND_FREELIKE_BLOCK whenever we free something (generally after we have done our bookkeeping) * Call VALGRIND_RESIZEINPLACE_BLOCK whenever we change the size of an allocation. We don't record the original request size of a block, and neither does valgrind. For this reason, we pretend that the old size of the allocation was for 0 bytes. This marks the whole allocaton as undefined, so in order to mark all bits correctly, we must make the whole new allocation defined with VALGRIND_MAKE_MEM_DEFINED. This may cause us to miss some invalid reads, but there is no way to detect these without recording the original size of the allocation. In addition to the above, dlmalloc itself tends to make a lot of accesses which we know are safe, but which would be unsafe outside of dlmalloc. For this reason, we provide a suppression file which ignores errors ocurring in dlmalloc.c Signed-off-by: Sean Anderson <seanga2@gmail.com> Reviewed-by: Simon Glass <sjg@chromium.org>
93 lines
1.7 KiB
C
93 lines
1.7 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Simple malloc implementation
|
|
*
|
|
* Copyright (c) 2014 Google, Inc
|
|
*/
|
|
|
|
#define LOG_CATEGORY LOGC_ALLOC
|
|
|
|
#include <common.h>
|
|
#include <log.h>
|
|
#include <malloc.h>
|
|
#include <mapmem.h>
|
|
#include <asm/global_data.h>
|
|
#include <asm/io.h>
|
|
#include <valgrind/valgrind.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
static void *alloc_simple(size_t bytes, int align)
|
|
{
|
|
ulong addr, new_ptr;
|
|
void *ptr;
|
|
|
|
addr = ALIGN(gd->malloc_base + gd->malloc_ptr, align);
|
|
new_ptr = addr + bytes - gd->malloc_base;
|
|
log_debug("size=%lx, ptr=%lx, limit=%lx: ", (ulong)bytes, new_ptr,
|
|
gd->malloc_limit);
|
|
if (new_ptr > gd->malloc_limit) {
|
|
log_err("alloc space exhausted\n");
|
|
return NULL;
|
|
}
|
|
|
|
ptr = map_sysmem(addr, bytes);
|
|
gd->malloc_ptr = ALIGN(new_ptr, sizeof(new_ptr));
|
|
|
|
return ptr;
|
|
}
|
|
|
|
void *malloc_simple(size_t bytes)
|
|
{
|
|
void *ptr;
|
|
|
|
ptr = alloc_simple(bytes, 1);
|
|
if (!ptr)
|
|
return ptr;
|
|
|
|
log_debug("%lx\n", (ulong)ptr);
|
|
VALGRIND_MALLOCLIKE_BLOCK(ptr, bytes, 0, false);
|
|
|
|
return ptr;
|
|
}
|
|
|
|
void *memalign_simple(size_t align, size_t bytes)
|
|
{
|
|
void *ptr;
|
|
|
|
ptr = alloc_simple(bytes, align);
|
|
if (!ptr)
|
|
return ptr;
|
|
log_debug("aligned to %lx\n", (ulong)ptr);
|
|
VALGRIND_MALLOCLIKE_BLOCK(ptr, bytes, 0, false);
|
|
|
|
return ptr;
|
|
}
|
|
|
|
#if CONFIG_IS_ENABLED(SYS_MALLOC_SIMPLE)
|
|
void *calloc(size_t nmemb, size_t elem_size)
|
|
{
|
|
size_t size = nmemb * elem_size;
|
|
void *ptr;
|
|
|
|
ptr = malloc(size);
|
|
if (!ptr)
|
|
return ptr;
|
|
memset(ptr, '\0', size);
|
|
|
|
return ptr;
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_VALGRIND)
|
|
void free_simple(void *ptr)
|
|
{
|
|
VALGRIND_FREELIKE_BLOCK(ptr, 0);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
void malloc_simple_info(void)
|
|
{
|
|
log_info("malloc_simple: %lx bytes used, %lx remain\n", gd->malloc_ptr,
|
|
CONFIG_VAL(SYS_MALLOC_F_LEN) - gd->malloc_ptr);
|
|
}
|