mirror of
https://github.com/RIOT-OS/RIOT.git
synced 2024-12-29 04:50:03 +01:00
cc907fa54e
The correct way to overrride the malloc family of functions in newlib-nano is to provide the *_r (reentrant) variants. Newlib implements the "normal" functions on top of these (see the newlib source code). Also, internally it calls the *_r functions when allocating buffers. If only the "normal" non-reentrant functions are provided this will mean that some of the code will still use the vanilla newlib allocator. Furthermore, if one uses the whole heap as a pool for TLSF then the system may in the best case crash as there is no enough memory for its internall allocations or in the worst case function eratically (this depends on how the heap reserved, there is an upcomming series of commits in that direction). This commit splits the handling between newlib and native. It also prepares the ground for future work on the pool initialization. Right now I could only test this in ARM and native and I cannot ensure it will work on other platforms. Replacing the system's memory allocator is not something that can be taken lightly and will inevitably require diving into the depths of the libc. Therefore I would say that using TLSF as a system wide allocator is ATM supported officially only on those plaftorms. Testing: Aside from reading the newlib sources, you can see the issue in a live system using the debugger. Compile any example (with or without tlsf-malloc), grab a debugger and place a breakpoint in sbrk and _sbrk_r. Doing a backtrace will reveal it gets called by _malloc_r.
124 lines
2.7 KiB
C
124 lines
2.7 KiB
C
/*
|
|
* Copyright (C) 2019 Freie Universität Berlin
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU Lesser
|
|
* General Public License v2.1. See the file LICENSE in the top level
|
|
* directory for more details.
|
|
*/
|
|
/**
|
|
* @ingroup pkg_tlsf_malloc
|
|
* @ingroup pkg
|
|
* @ingroup sys
|
|
* @{
|
|
* @file
|
|
*
|
|
* @brief Definitions to use tlsf as malloc on native.
|
|
* @author Juan I Carrano
|
|
*
|
|
* This assumes glibc is bein used.
|
|
* see: https://www.gnu.org/software/libc/manual/html_node/Replacing-malloc.html
|
|
*
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include "irq.h"
|
|
#include "tlsf.h"
|
|
#include "tlsf-malloc.h"
|
|
#include "tlsf-malloc-internal.h"
|
|
|
|
/* TODO: Add defines for other compilers */
|
|
#if defined(__GNUC__) && !defined(__clang__) /* Clang supports __GNUC__ but
|
|
* not the alloc_size()
|
|
* attribute */
|
|
|
|
#define ATTR_MALLOC __attribute__((malloc, alloc_size(1)))
|
|
#define ATTR_CALLOC __attribute__((malloc, alloc_size(1,2)))
|
|
#define ATTR_MALIGN __attribute__((alloc_align(1), alloc_size(2), malloc))
|
|
#define ATTR_REALLOC __attribute__((alloc_size(2)))
|
|
|
|
#else /* No GNU C -> no alias attribute */
|
|
|
|
#define ATTR_MALLOC
|
|
#define ATTR_CALLOC
|
|
#define ATTR_MALIGN
|
|
#define ATTR_REALLOC
|
|
|
|
#endif /* __GNUC__ */
|
|
|
|
extern tlsf_t tlsf_malloc_gheap;
|
|
|
|
/**
|
|
* Allocate a block of size "bytes"
|
|
*/
|
|
ATTR_MALLOC void *malloc(size_t bytes)
|
|
{
|
|
unsigned old_state = irq_disable();
|
|
void *result = tlsf_malloc(tlsf_malloc_gheap, bytes);
|
|
|
|
if (result == NULL) {
|
|
errno = ENOMEM;
|
|
}
|
|
|
|
irq_restore(old_state);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Allocate and clear a block of size "bytes*count"
|
|
*/
|
|
ATTR_CALLOC void *calloc(size_t count, size_t bytes)
|
|
{
|
|
void *result = malloc(count * bytes);
|
|
|
|
if (result != NULL) {
|
|
memset(result, 0, count * bytes);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Allocate an aligned memory block.
|
|
*/
|
|
ATTR_MALIGN void *memalign(size_t align, size_t bytes)
|
|
{
|
|
unsigned old_state = irq_disable();
|
|
void *result = tlsf_memalign(tlsf_malloc_gheap, align, bytes);
|
|
|
|
if (result == NULL) {
|
|
errno = ENOMEM;
|
|
}
|
|
|
|
irq_restore(old_state);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Deallocate and reallocate with a different size.
|
|
*/
|
|
ATTR_REALLOC void *realloc(void *ptr, size_t size)
|
|
{
|
|
unsigned old_state = irq_disable();
|
|
void *result = tlsf_realloc(tlsf_malloc_gheap, ptr, size);
|
|
|
|
if (result == NULL) {
|
|
errno = ENOMEM;
|
|
}
|
|
|
|
irq_restore(old_state);
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Deallocate a block of data.
|
|
*/
|
|
void free(void *ptr)
|
|
{
|
|
unsigned old_state = irq_disable();
|
|
|
|
tlsf_free(tlsf_malloc_gheap, ptr);
|
|
irq_restore(old_state);
|
|
}
|