Merge pull request #1215 from Kijewski/tlsf

Add TLSF (two level segregated fit) PKG

pkg/tlsf/.gitignore

+/tlsf-*.zip

pkg/tlsf/Makefile

+PKG_NAME = tlsf
+PKG_VERSION = 3.0
+PKG_FILE = tlsf-$(PKG_VERSION).zip
+PKG_URL = http://tlsf.baisoku.org/$(PKG_FILE)
+
+ifeq (, $(UNZIP))
+  ifeq (0, $(shell which unzip 2>&1 > /dev/null ; echo $$?))
+    UNZIP := $(shell which unzip)
+  else
+    ifeq (0, $(shell which 7z 2>&1 > /dev/null ; echo $$?))
+      UNZIP := $(shell which 7z) x
+    else
+      $(error "Neither unzip nor 7z is installed.")
+    endif
+  endif
+endif
+
+.PHONY: all clean patch reset
+
+all: $(BINDIR)$(PKG_NAME).a
+
+$(BINDIR)$(PKG_NAME).a: $(BINDIR)$(PKG_NAME)-src/Makefile
+	$(AD)make -C $(<D)
+
+$(BINDIR)$(PKG_NAME)-src/Makefile: $(CURDIR)/$(PKG_FILE) $(CURDIR)/patch.txt
+	@rm -rf $(@D)
+	@mkdir -p $(@D)
+	$(AD)cd $(@D) && $(UNZIP) $(CURDIR)/$(PKG_FILE)
+	$(AD)cd $(@D) && patch --binary -p0 -N -i $(CURDIR)/patch.txt
+
+$(CURDIR)/$(PKG_FILE):
+	$(AD)wget -nv -c -O $@ $(PKG_URL)
+
+clean::
+	rm -rf $(BINDIR)$(PKG_NAME)-src/
+
+distclean:: clean
+	rm -f $(CURDIR)/$(PKG_FILE)
+
+Makefile.include:
+	@true

pkg/tlsf/Makefile.include

+INCLUDES += -I$(BINDIR)tlsf-src

pkg/tlsf/patch.txt

+diff -NdaU0 tlsf.c tlsf.c
+--- tlsf.c
++++ tlsf.c
+@@ -25,4 +24,0 @@
+-#if defined (TLSF_64BIT)
+-	/* All allocation sizes and addresses are aligned to 8 bytes. */
+-	ALIGN_SIZE_LOG2 = 3,
+-#else
+@@ -30,3 +26,2 @@
+-	ALIGN_SIZE_LOG2 = 2,
+-#endif
+-	ALIGN_SIZE = (1 << ALIGN_SIZE_LOG2),
++#define ALIGN_SIZE_LOG2 (2)
++#define ALIGN_SIZE (1 << ALIGN_SIZE_LOG2)
+@@ -45,7 +39,0 @@
+-#if defined (TLSF_64BIT)
+-	/*
+-	** TODO: We can increase this to support larger sizes, at the expense
+-	** of more overhead in the TLSF structure.
+-	*/
+-	FL_INDEX_MAX = 32,
+-#else
+@@ -53 +40,0 @@
+-#endif
+@@ -73 +60 @@
+-#define tlsf_assert assert
++#define tlsf_assert(X) do { if (0) { (void) (X); } } while (0)
+@@ -165,0 +153,14 @@
++static control_t control __attribute__ ((aligned(ALIGN_SIZE))) = {
++	.block_null = {
++		.next_free = &control.block_null,
++		.prev_free = &control.block_null,
++	},
++	.fl_bitmap = 0,
++	.sl_bitmap = {0},
++	.blocks = {
++		[0 ... FL_INDEX_COUNT-1] = {
++			[0 ... SL_INDEX_COUNT-1] = &control.block_null
++		}
++	}
++};
++
+@@ -345 +346 @@
+-static block_header_t* search_suitable_block(control_t* control, int* fli, int* sli)
++static block_header_t* search_suitable_block(int* fli, int* sli)
+@@ -354 +355 @@
+-	unsigned int sl_map = control->sl_bitmap[fl] & (~0 << sl);
++	unsigned int sl_map = control.sl_bitmap[fl] & (~0 << sl);
+@@ -358 +359 @@
+-		const unsigned int fl_map = control->fl_bitmap & (~0 << (fl + 1));
++		const unsigned int fl_map = control.fl_bitmap & (~0 << (fl + 1));
+@@ -367 +368 @@
+-		sl_map = control->sl_bitmap[fl];
++		sl_map = control.sl_bitmap[fl];
+@@ -374 +375 @@
+-	return control->blocks[fl][sl];
++	return control.blocks[fl][sl];
+@@ -378 +379 @@
+-static void remove_free_block(control_t* control, block_header_t* block, int fl, int sl)
++static void remove_free_block(block_header_t* block, int fl, int sl)
+@@ -388 +389 @@
+-	if (control->blocks[fl][sl] == block)
++	if (control.blocks[fl][sl] == block)
+@@ -390 +391 @@
+-		control->blocks[fl][sl] = next;
++		control.blocks[fl][sl] = next;
+@@ -393 +394 @@
+-		if (next == &control->block_null)
++		if (next == &control.block_null)
+@@ -395 +396 @@
+-			control->sl_bitmap[fl] &= ~(1 << sl);
++			control.sl_bitmap[fl] &= ~(1 << sl);
+@@ -398 +399 @@
+-			if (!control->sl_bitmap[fl])
++			if (!control.sl_bitmap[fl])
+@@ -400 +401 @@
+-				control->fl_bitmap &= ~(1 << fl);
++				control.fl_bitmap &= ~(1 << fl);
+@@ -407 +408 @@
+-static void insert_free_block(control_t* control, block_header_t* block, int fl, int sl)
++static void insert_free_block(block_header_t* block, int fl, int sl)
+@@ -409 +410 @@
+-	block_header_t* current = control->blocks[fl][sl];
++	block_header_t* current = control.blocks[fl][sl];
+@@ -413 +414 @@
+-	block->prev_free = &control->block_null;
++	block->prev_free = &control.block_null;
+@@ -422,3 +423,3 @@
+-	control->blocks[fl][sl] = block;
+-	control->fl_bitmap |= (1 << fl);
+-	control->sl_bitmap[fl] |= (1 << sl);
++	control.blocks[fl][sl] = block;
++	control.fl_bitmap |= (1 << fl);
++	control.sl_bitmap[fl] |= (1 << sl);
+@@ -428 +429 @@
+-static void block_remove(control_t* control, block_header_t* block)
++static void block_remove(block_header_t* block)
+@@ -432 +433 @@
+-	remove_free_block(control, block, fl, sl);
++	remove_free_block(block, fl, sl);
+@@ -436 +437 @@
+-static void block_insert(control_t* control, block_header_t* block)
++static void block_insert(block_header_t* block)
+@@ -440 +441 @@
+-	insert_free_block(control, block, fl, sl);
++	insert_free_block(block, fl, sl);
+@@ -481 +482 @@
+-static block_header_t* block_merge_prev(control_t* control, block_header_t* block)
++static block_header_t* block_merge_prev(block_header_t* block)
+@@ -488 +489 @@
+-		block_remove(control, prev);
++		block_remove(prev);
+@@ -496 +497 @@
+-static block_header_t* block_merge_next(control_t* control, block_header_t* block)
++static block_header_t* block_merge_next(block_header_t* block)
+@@ -504 +505 @@
+-		block_remove(control, next);
++		block_remove(next);
+@@ -512 +513 @@
+-static void block_trim_free(control_t* control, block_header_t* block, size_t size)
++static void block_trim_free(block_header_t* block, size_t size)
+@@ -520 +521 @@
+-		block_insert(control, remaining_block);
++		block_insert(remaining_block);
+@@ -525 +526 @@
+-static void block_trim_used(control_t* control, block_header_t* block, size_t size)
++static void block_trim_used(block_header_t* block, size_t size)
+@@ -534,2 +535,2 @@
+-		remaining_block = block_merge_next(control, remaining_block);
+-		block_insert(control, remaining_block);
++		remaining_block = block_merge_next(remaining_block);
++		block_insert(remaining_block);
+@@ -539 +540 @@
+-static block_header_t* block_trim_free_leading(control_t* control, block_header_t* block, size_t size)
++static block_header_t* block_trim_free_leading(block_header_t* block, size_t size)
+@@ -549 +550 @@
+-		block_insert(control, block);
++		block_insert(block);
+@@ -555 +556 @@
+-static block_header_t* block_locate_free(control_t* control, size_t size)
++static block_header_t* block_locate_free(size_t size)
+@@ -563 +564 @@
+-		block = search_suitable_block(control, &fl, &sl);
++		block = search_suitable_block(&fl, &sl);
+@@ -569 +570 @@
+-		remove_free_block(control, block, fl, sl);
++		remove_free_block(block, fl, sl);
+@@ -575 +576 @@
+-static void* block_prepare_used(control_t* control, block_header_t* block, size_t size)
++static void* block_prepare_used(block_header_t* block, size_t size)
+@@ -580 +581 @@
+-		block_trim_free(control, block, size);
++		block_trim_free(block, size);
+@@ -587,184 +588 @@
+-/* Clear structure and point all empty lists at the null block. */
+-static void control_construct(control_t* control)
+-{
+-	int i, j;
+-
+-	control->block_null.next_free = &control->block_null;
+-	control->block_null.prev_free = &control->block_null;
+-
+-	control->fl_bitmap = 0;
+-	for (i = 0; i < FL_INDEX_COUNT; ++i)
+-	{
+-		control->sl_bitmap[i] = 0;
+-		for (j = 0; j < SL_INDEX_COUNT; ++j)
+-		{
+-			control->blocks[i][j] = &control->block_null;
+-		}
+-	}
+-}
+-
+-/*
+-** Debugging utilities.
+-*/
+-
+-typedef struct integrity_t
+-{
+-	int prev_status;
+-	int status;
+-} integrity_t;
+-
+-#define tlsf_insist(x) { tlsf_assert(x); if (!(x)) { status--; } }
+-
+-static void integrity_walker(void* ptr, size_t size, int used, void* user)
+-{
+-	block_header_t* block = block_from_ptr(ptr);
+-	integrity_t* integ = tlsf_cast(integrity_t*, user);
+-	const int this_prev_status = block_is_prev_free(block) ? 1 : 0;
+-	const int this_status = block_is_free(block) ? 1 : 0;
+-	const size_t this_block_size = block_size(block);
+-
+-	int status = 0;
+-	tlsf_insist(integ->prev_status == this_prev_status && "prev status incorrect");
+-	tlsf_insist(size == this_block_size && "block size incorrect");
+-
+-	integ->prev_status = this_status;
+-	integ->status += status;
+-}
+-
+-int tlsf_check(tlsf_t tlsf)
+-{
+-	int i, j;
+-
+-	control_t* control = tlsf_cast(control_t*, tlsf);
+-	int status = 0;
+-
+-	/* Check that the free lists and bitmaps are accurate. */
+-	for (i = 0; i < FL_INDEX_COUNT; ++i)
+-	{
+-		for (j = 0; j < SL_INDEX_COUNT; ++j)
+-		{
+-			const int fl_map = control->fl_bitmap & (1 << i);
+-			const int sl_list = control->sl_bitmap[i];
+-			const int sl_map = sl_list & (1 << j);
+-			const block_header_t* block = control->blocks[i][j];
+-
+-			/* Check that first- and second-level lists agree. */
+-			if (!fl_map)
+-			{
+-				tlsf_insist(!sl_map && "second-level map must be null");
+-			}
+-
+-			if (!sl_map)
+-			{
+-				tlsf_insist(block == &control->block_null && "block list must be null");
+-				continue;
+-			}
+-
+-			/* Check that there is at least one free block. */
+-			tlsf_insist(sl_list && "no free blocks in second-level map");
+-			tlsf_insist(block != &control->block_null && "block should not be null");
+-
+-			while (block != &control->block_null)
+-			{
+-				int fli, sli;
+-				tlsf_insist(block_is_free(block) && "block should be free");
+-				tlsf_insist(!block_is_prev_free(block) && "blocks should have coalesced");
+-				tlsf_insist(!block_is_free(block_next(block)) && "blocks should have coalesced");
+-				tlsf_insist(block_is_prev_free(block_next(block)) && "block should be free");
+-				tlsf_insist(block_size(block) >= block_size_min && "block not minimum size");
+-
+-				mapping_insert(block_size(block), &fli, &sli);
+-				tlsf_insist(fli == i && sli == j && "block size indexed in wrong list");
+-				block = block->next_free;
+-			}
+-		}
+-	}
+-
+-	return status;
+-}
+-
+-#undef tlsf_insist
+-
+-static void default_walker(void* ptr, size_t size, int used, void* user)
+-{
+-	(void)user;
+-	printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, block_from_ptr(ptr));
+-}
+-
+-void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user)
+-{
+-	tlsf_walker pool_walker = walker ? walker : default_walker;
+-	block_header_t* block =
+-		offset_to_block(pool, -(int)block_header_overhead);
+-
+-	while (block && !block_is_last(block))
+-	{
+-		pool_walker(
+-			block_to_ptr(block),
+-			block_size(block),
+-			!block_is_free(block),
+-			user);
+-		block = block_next(block);
+-	}
+-}
+-
+-size_t tlsf_block_size(void* ptr)
+-{
+-	size_t size = 0;
+-	if (ptr)
+-	{
+-		const block_header_t* block = block_from_ptr(ptr);
+-		size = block_size(block);
+-	}
+-	return size;
+-}
+-
+-int tlsf_check_pool(pool_t pool)
+-{
+-	/* Check that the blocks are physically correct. */
+-	integrity_t integ = { 0, 0 };
+-	tlsf_walk_pool(pool, integrity_walker, &integ);
+-
+-	return integ.status;
+-}
+-
+-/*
+-** Size of the TLSF structures in a given memory block passed to
+-** tlsf_create, equal to the size of a control_t
+-*/
+-size_t tlsf_size()
+-{
+-	return sizeof(control_t);
+-}
+-
+-size_t tlsf_align_size()
+-{
+-	return ALIGN_SIZE;
+-}
+-
+-size_t tlsf_block_size_min()
+-{
+-	return block_size_min;
+-}
+-
+-size_t tlsf_block_size_max()
+-{
+-	return block_size_max;
+-}
+-
+-/*
+-** Overhead of the TLSF structures in a given memory block passes to
+-** tlsf_add_pool, equal to the overhead of a free block and the
+-** sentinel block.
+-*/
+-size_t tlsf_pool_overhead()
+-{
+-	return 2 * block_header_overhead;
+-}
+-
+-size_t tlsf_alloc_overhead()
+-{
+-	return block_header_overhead;
+-}
+-
+-pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
++int tlsf_add_pool(void* mem, size_t bytes)
+@@ -775 +593 @@
+-	const size_t pool_overhead = tlsf_pool_overhead();
++	const size_t pool_overhead = 2 * block_header_overhead;
+@@ -787,5 +604,0 @@
+-#if defined (TLSF_64BIT)
+-		printf("tlsf_add_pool: Memory size must be between 0x%x and 0x%x00 bytes.\n", 
+-			(unsigned int)(pool_overhead + block_size_min),
+-			(unsigned int)((pool_overhead + block_size_max) / 256));
+-#else
+@@ -795 +607,0 @@
+-#endif
+@@ -808 +620 @@
+-	block_insert(tlsf_cast(control_t*, tlsf), block);
++	block_insert(block);
+@@ -816,16 +628 @@
+-	return mem;
+-}
+-
+-void tlsf_remove_pool(tlsf_t tlsf, pool_t pool)
+-{
+-	control_t* control = tlsf_cast(control_t*, tlsf);
+-	block_header_t* block = offset_to_block(pool, -(int)block_header_overhead);
+-
+-	int fl = 0, sl = 0;
+-
+-	tlsf_assert(block_is_free(block) && "block should be free");
+-	tlsf_assert(!block_is_free(block_next(block)) && "next block should not be free");
+-	tlsf_assert(block_size(block_next(block)) == 0 && "next block size should be zero");
+-
+-	mapping_insert(block_size(block), &fl, &sl);
+-	remove_free_block(control, block, fl, sl);
++	return 1;
+@@ -838,68 +635 @@
+-#if _DEBUG
+-int test_ffs_fls()
+-{
+-	/* Verify ffs/fls work properly. */
+-	int rv = 0;
+-	rv += (tlsf_ffs(0) == -1) ? 0 : 0x1;
+-	rv += (tlsf_fls(0) == -1) ? 0 : 0x2;
+-	rv += (tlsf_ffs(1) == 0) ? 0 : 0x4;
+-	rv += (tlsf_fls(1) == 0) ? 0 : 0x8;
+-	rv += (tlsf_ffs(0x80000000) == 31) ? 0 : 0x10;
+-	rv += (tlsf_ffs(0x80008000) == 15) ? 0 : 0x20;
+-	rv += (tlsf_fls(0x80000008) == 31) ? 0 : 0x40;
+-	rv += (tlsf_fls(0x7FFFFFFF) == 30) ? 0 : 0x80;
+-
+-#if defined (TLSF_64BIT)
+-	rv += (tlsf_fls_sizet(0x80000000) == 31) ? 0 : 0x100;
+-	rv += (tlsf_fls_sizet(0x100000000) == 32) ? 0 : 0x200;
+-	rv += (tlsf_fls_sizet(0xffffffffffffffff) == 63) ? 0 : 0x400; 
+-#endif
+-
+-	if (rv)
+-	{
+-		printf("tlsf_create: %x ffs/fls tests failed!\n", rv);
+-	}
+-	return rv;
+-}
+-#endif
+-
+-tlsf_t tlsf_create(void* mem)
+-{
+-#if _DEBUG
+-	if (test_ffs_fls())
+-	{
+-		return 0;
+-	}
+-#endif
+-
+-	if (((tlsfptr_t)mem % ALIGN_SIZE) != 0)
+-	{
+-		printf("tlsf_create: Memory must be aligned to %u bytes.\n",
+-			(unsigned int)ALIGN_SIZE);
+-		return 0;
+-	}
+-
+-	control_construct(tlsf_cast(control_t*, mem));
+-
+-	return tlsf_cast(tlsf_t, mem);
+-}
+-
+-tlsf_t tlsf_create_with_pool(void* mem, size_t bytes)
+-{
+-	tlsf_t tlsf = tlsf_create(mem);
+-	tlsf_add_pool(tlsf, (char*)mem + tlsf_size(), bytes - tlsf_size());
+-	return tlsf;
+-}
+-
+-void tlsf_destroy(tlsf_t tlsf)
+-{
+-	/* Nothing to do. */
+-	(void)tlsf;
+-}
+-
+-pool_t tlsf_get_pool(tlsf_t tlsf)
+-{
+-	return tlsf_cast(pool_t, (char*)tlsf + tlsf_size());
+-}
+-
+-void* tlsf_malloc(tlsf_t tlsf, size_t size)
++void* tlsf_malloc(size_t size)
+@@ -907 +636,0 @@
+-	control_t* control = tlsf_cast(control_t*, tlsf);
+@@ -909,2 +638,2 @@
+-	block_header_t* block = block_locate_free(control, adjust);
+-	return block_prepare_used(control, block, adjust);
++	block_header_t* block = block_locate_free(adjust);
++	return block_prepare_used(block, adjust);
+@@ -913 +642 @@
+-void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
++void* tlsf_memalign(size_t align, size_t size)
+@@ -915 +643,0 @@
+-	control_t* control = tlsf_cast(control_t*, tlsf);
+@@ -932 +660 @@
+-	block_header_t* block = block_locate_free(control, aligned_size);
++	block_header_t* block = block_locate_free(aligned_size);
+@@ -960 +688 @@
+-			block = block_trim_free_leading(control, block, gap);
++			block = block_trim_free_leading(block, gap);
+@@ -964 +692 @@
+-	return block_prepare_used(control, block, adjust);
++	return block_prepare_used(block, adjust);
+@@ -967 +695 @@
+-void tlsf_free(tlsf_t tlsf, void* ptr)
++void tlsf_free(void* ptr)
+@@ -972 +699,0 @@
+-		control_t* control = tlsf_cast(control_t*, tlsf);
+@@ -976,3 +703,3 @@
+-		block = block_merge_prev(control, block);
+-		block = block_merge_next(control, block);
+-		block_insert(control, block);
++		block = block_merge_prev(block);
++		block = block_merge_next(block);
++		block_insert(block);
+@@ -995 +722 @@
+-void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
++void* tlsf_realloc(void* ptr, size_t size)
+@@ -997 +723,0 @@
+-	control_t* control = tlsf_cast(control_t*, tlsf);
+@@ -1003 +729 @@
+-		tlsf_free(tlsf, ptr);
++		tlsf_free(ptr);
+@@ -1008 +734 @@
+-		p = tlsf_malloc(tlsf, size);
++		p = tlsf_malloc(size);
+@@ -1027 +753 @@
+-			p = tlsf_malloc(tlsf, size);
++			p = tlsf_malloc(size);
+@@ -1032 +758 @@
+-				tlsf_free(tlsf, ptr);
++				tlsf_free(ptr);
+@@ -1040 +766 @@
+-				block_merge_next(control, block);
++				block_merge_next(block);
+@@ -1045 +771 @@
+-			block_trim_used(control, block, adjust);
++			block_trim_used(block, adjust);
+diff -NdaU0 tlsf.h tlsf.h
+--- tlsf.h
++++ tlsf.h
+@@ -21,15 +20,0 @@
+-#if defined(__cplusplus)
+-extern "C" {
+-#endif
+-
+-/* tlsf_t: a TLSF structure. Can contain 1 to N pools. */
+-/* pool_t: a block of memory that TLSF can manage. */
+-typedef void* tlsf_t;
+-typedef void* pool_t;
+-
+-/* Create/destroy a memory pool. */
+-tlsf_t tlsf_create(void* mem);
+-tlsf_t tlsf_create_with_pool(void* mem, size_t bytes);
+-void tlsf_destroy(tlsf_t tlsf);
+-pool_t tlsf_get_pool(tlsf_t tlsf);
+-
+@@ -37,2 +22 @@
+-pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes);
+-void tlsf_remove_pool(tlsf_t tlsf, pool_t pool);
++int tlsf_add_pool(void* mem, size_t bytes);
+@@ -41,26 +25,4 @@
+-void* tlsf_malloc(tlsf_t tlsf, size_t bytes);
+-void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t bytes);
+-void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size);
+-void tlsf_free(tlsf_t tlsf, void* ptr);
+-
+-/* Returns internal block size, not original request size */
+-size_t tlsf_block_size(void* ptr);
+-
+-/* Overheads/limits of internal structures. */
+-size_t tlsf_size();
+-size_t tlsf_align_size();
+-size_t tlsf_block_size_min();
+-size_t tlsf_block_size_max();
+-size_t tlsf_pool_overhead();
+-size_t tlsf_alloc_overhead();
+-
+-/* Debugging. */
+-typedef void (*tlsf_walker)(void* ptr, size_t size, int used, void* user);
+-void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user);
+-/* Returns nonzero if any internal consistency check fails. */
+-int tlsf_check(tlsf_t tlsf);
+-int tlsf_check_pool(pool_t pool);
+-
+-#if defined(__cplusplus)
+-};
+-#endif
++void* tlsf_malloc(size_t bytes);
++void* tlsf_memalign(size_t align, size_t bytes);
++void* tlsf_realloc(void* ptr, size_t size);
++void tlsf_free(void* ptr);
+diff -NdaU0 Makefile Makefile
+--- Makefile
++++ Makefile
+@@ -0,0 +1,3 @@
++MODULE = tlsf
++
++include $(RIOTBASE)/Makefile.base
+diff -NdaU0 tlsf-malloc.c tlsf-malloc.c
+--- tlsf-malloc.c
++++ tlsf-malloc.c
+@@ -0,0 +1,44 @@
++#include "irq.h"
++#include "tlsf-malloc.h"
++
++#include <string.h>
++
++void *TLSF_MALLOC_NAME(malloc)(size_t bytes)
++{
++    unsigned old_state = disableIRQ();
++    void *result = tlsf_malloc(bytes);
++    restoreIRQ(old_state);
++    return result;
++}
++
++void *TLSF_MALLOC_NAME(calloc)(size_t count, size_t bytes)
++{
++    void *result = tlsf_malloc(count * bytes);
++    if (result) {
++        memset(result, 0, count * bytes);
++    }
++    return result;
++}
++
++void *TLSF_MALLOC_NAME(memalign)(size_t align, size_t bytes)
++{
++    unsigned old_state = disableIRQ();
++    void *result = tlsf_memalign(align, bytes);
++    restoreIRQ(old_state);
++    return result;
++}
++
++void *TLSF_MALLOC_NAME(realloc)(void *ptr, size_t size)
++{
++    unsigned old_state = disableIRQ();
++    void *result = tlsf_realloc(ptr, size);
++    restoreIRQ(old_state);
++    return result;
++}
++
++void TLSF_MALLOC_NAME(free)(void *ptr)
++{
++    unsigned old_state = disableIRQ();
++    tlsf_free(ptr);
++    restoreIRQ(old_state);
++}
+diff -NdaU0 tlsf-malloc.h tlsf-malloc.h
+--- tlsf-malloc.h
++++ tlsf-malloc.h
+@@ -0,0 +1,26 @@
++#ifndef __TLSF_MALLOC_H
++#define __TLSF_MALLOC_H
++
++#include <stdbool.h>
++#include <stddef.h>
++
++#include "tlsf.h"
++
++#ifndef TLSF_MALLOC_PREFIX
++#   define TLSF_MALLOC_PREFIX
++#endif
++#define __TLSF_MALLOC_NAME(A, B) A ## B
++#define _TLSF_MALLOC_NAME(A, B) __TLSF_MALLOC_NAME(A, B)
++#define TLSF_MALLOC_NAME(NAME) _TLSF_MALLOC_NAME(TLSF_MALLOC_PREFIX, NAME)
++
++void *TLSF_MALLOC_NAME(malloc)(size_t bytes);
++
++void *TLSF_MALLOC_NAME(calloc)(size_t count, size_t bytes);
++
++void *TLSF_MALLOC_NAME(memalign)(size_t align, size_t bytes);
++
++void *TLSF_MALLOC_NAME(realloc)(void *ptr, size_t size);
++
++void TLSF_MALLOC_NAME(free)(void *ptr);
++
++#endif