RIOT/pkg/tlsf/patch.txt

diff --git Makefile Makefile
new file mode 100644
index 0000000..a51d6c2
--- /dev/null
+++ Makefile
@@ -0,0 +1,3 @@
+MODULE = tlsf
+
+include $(RIOTBASE)/Makefile.base
diff --git tlsf-malloc.c tlsf-malloc.c
new file mode 100644
index 0000000..cb16af8
--- /dev/null
+++ 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 = irq_disable();
+    void *result = tlsf_malloc(bytes);
+    irq_restore(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 = irq_disable();
+    void *result = tlsf_memalign(align, bytes);
+    irq_restore(old_state);
+    return result;
+}
+
+void *TLSF_MALLOC_NAME(realloc)(void *ptr, size_t size)
+{
+    unsigned old_state = irq_disable();
+    void *result = tlsf_realloc(ptr, size);
+    irq_restore(old_state);
+    return result;
+}
+
+void TLSF_MALLOC_NAME(free)(void *ptr)
+{
+    unsigned old_state = irq_disable();
+    tlsf_free(ptr);
+    irq_restore(old_state);
+}
diff --git tlsf-malloc.h tlsf-malloc.h
new file mode 100644
index 0000000..2d8bb4d
--- /dev/null
+++ 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
diff --git tlsf.c tlsf.c
index 3fb5ebd..4225213 100644
--- tlsf.c
+++ tlsf.c
@@ -25,4 +24,0 @@ enum tlsf_private
-#if defined (TLSF_64BIT)
-	/* All allocation sizes and addresses are aligned to 8 bytes. */
-	ALIGN_SIZE_LOG2 = 3,
-#else
@@ -30,3 +26,2 @@ enum tlsf_private
-	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 @@ enum tlsf_private
-#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 @@ enum tlsf_private
-#endif
@@ -73 +60 @@ enum tlsf_private
-#define tlsf_assert assert
+#define tlsf_assert(X) do { if (0) { (void) (X); } } while (0)
@@ -147 +134 @@ static const size_t block_start_offset =
-static const size_t block_size_min = 
+static const size_t block_size_min =
@@ -165,0 +153 @@ typedef struct control_t
+static control_t *control;
@@ -345 +333 @@ static void mapping_search(size_t size, int* fli, int* sli)
-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)
@@ -378 +366 @@ static block_header_t* search_suitable_block(control_t* control, int* fli, int*
-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)
@@ -407 +395 @@ static void remove_free_block(control_t* control, block_header_t* block, int fl,
-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)
@@ -428 +416 @@ static void insert_free_block(control_t* control, block_header_t* block, int fl,
-static void block_remove(control_t* control, block_header_t* block)
+static void block_remove(block_header_t* block)
@@ -432 +420 @@ static void block_remove(control_t* control, block_header_t* block)
-	remove_free_block(control, block, fl, sl);
+	remove_free_block(block, fl, sl);
@@ -436 +424 @@ static void block_remove(control_t* control, block_header_t* block)
-static void block_insert(control_t* control, block_header_t* block)
+static void block_insert(block_header_t* block)
@@ -440 +428 @@ static void block_insert(control_t* control, block_header_t* block)
-	insert_free_block(control, block, fl, sl);
+	insert_free_block(block, fl, sl);
@@ -481 +469 @@ static block_header_t* block_absorb(block_header_t* prev, block_header_t* block)
-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 +476 @@ static block_header_t* block_merge_prev(control_t* control, block_header_t* bloc
-		block_remove(control, prev);
+		block_remove(prev);
@@ -496 +484 @@ static block_header_t* block_merge_prev(control_t* control, block_header_t* bloc
-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 +492 @@ static block_header_t* block_merge_next(control_t* control, block_header_t* bloc
-		block_remove(control, next);
+		block_remove(next);
@@ -512 +500 @@ static block_header_t* block_merge_next(control_t* control, block_header_t* bloc
-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 +508 @@ static void block_trim_free(control_t* control, block_header_t* block, size_t si
-		block_insert(control, remaining_block);
+		block_insert(remaining_block);
@@ -525 +513 @@ static void block_trim_free(control_t* control, block_header_t* block, size_t si
-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 +522,2 @@ static void block_trim_used(control_t* control, block_header_t* block, size_t si
-		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 +527 @@ static void block_trim_used(control_t* control, block_header_t* block, size_t si
-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 +537 @@ static block_header_t* block_trim_free_leading(control_t* control, block_header_
-		block_insert(control, block);
+		block_insert(block);
@@ -555 +543 @@ static block_header_t* block_trim_free_leading(control_t* control, block_header_
-static block_header_t* block_locate_free(control_t* control, size_t size)
+static block_header_t* block_locate_free(size_t size)
@@ -563 +551 @@ static block_header_t* block_locate_free(control_t* control, size_t size)
-		block = search_suitable_block(control, &fl, &sl);
+		block = search_suitable_block(&fl, &sl);
@@ -569 +557 @@ static block_header_t* block_locate_free(control_t* control, size_t size)
-		remove_free_block(control, block, fl, sl);
+		remove_free_block(block, fl, sl);
@@ -575 +563 @@ static block_header_t* block_locate_free(control_t* control, size_t size)
-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 +568 @@ static void* block_prepare_used(control_t* control, block_header_t* block, size_
-		block_trim_free(control, block, size);
+		block_trim_free(block, size);
@@ -588 +576 @@ static void* block_prepare_used(control_t* control, block_header_t* block, size_
-static void control_construct(control_t* control)
+static void control_construct(void)
@@ -606,165 +594 @@ static void control_construct(control_t* control)
-/*
-** 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 +599 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
-	const size_t pool_overhead = tlsf_pool_overhead();
+	const size_t pool_overhead = 2 * block_header_overhead;
@@ -787,6 +611 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
-#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
-		printf("tlsf_add_pool: Memory size must be between %u and %u bytes.\n", 
+		printf("tlsf_add_pool: Memory size must be between %u and %u bytes.\n",
@@ -795 +613,0 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
-#endif
@@ -808 +626 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
-	block_insert(tlsf_cast(control_t*, tlsf), block);
+	block_insert(block);
@@ -816,16 +634 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
-	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,2 +641 @@ void tlsf_remove_pool(tlsf_t tlsf, pool_t pool)
-#if _DEBUG
-int test_ffs_fls()
+void tlsf_create(void* mem)
@@ -841,34 +642,0 @@ 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
-
@@ -879 +647 @@ tlsf_t tlsf_create(void* mem)
-		return 0;
+		return;
@@ -882 +650 @@ tlsf_t tlsf_create(void* mem)
-	control_construct(tlsf_cast(control_t*, mem));
+    control = tlsf_cast(control_t*, mem);
@@ -884,14 +652 @@ tlsf_t tlsf_create(void* 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;
+	control_construct();
@@ -900 +655 @@ void tlsf_destroy(tlsf_t tlsf)
-pool_t tlsf_get_pool(tlsf_t tlsf)
+void tlsf_create_with_pool(void* mem, size_t bytes)
@@ -902 +657,2 @@ pool_t tlsf_get_pool(tlsf_t tlsf)
-	return tlsf_cast(pool_t, (char*)tlsf + tlsf_size());
+	tlsf_create(mem);
+	tlsf_add_pool((char*)mem + sizeof(control_t), bytes - sizeof(control_t));
@@ -905 +661 @@ pool_t tlsf_get_pool(tlsf_t tlsf)
-void* tlsf_malloc(tlsf_t tlsf, size_t size)
+void* tlsf_malloc(size_t size)
@@ -907 +662,0 @@ void* tlsf_malloc(tlsf_t tlsf, size_t size)
-	control_t* control = tlsf_cast(control_t*, tlsf);
@@ -909,2 +664,2 @@ void* tlsf_malloc(tlsf_t tlsf, size_t size)
-	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 +668 @@ void* tlsf_malloc(tlsf_t tlsf, size_t size)
-void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
+void* tlsf_memalign(size_t align, size_t size)
@@ -915 +669,0 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
-	control_t* control = tlsf_cast(control_t*, tlsf);
@@ -932 +686 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
-	block_header_t* block = block_locate_free(control, aligned_size);
+	block_header_t* block = block_locate_free(aligned_size);
@@ -960 +714 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
-			block = block_trim_free_leading(control, block, gap);
+			block = block_trim_free_leading(block, gap);
@@ -964 +718 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
-	return block_prepare_used(control, block, adjust);
+	return block_prepare_used(block, adjust);
@@ -967 +721 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
-void tlsf_free(tlsf_t tlsf, void* ptr)
+void tlsf_free(void* ptr)
@@ -972 +725,0 @@ void tlsf_free(tlsf_t tlsf, void* ptr)
-		control_t* control = tlsf_cast(control_t*, tlsf);
@@ -976,3 +729,3 @@ void tlsf_free(tlsf_t tlsf, void* ptr)
-		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 +748 @@ void tlsf_free(tlsf_t tlsf, void* ptr)
-void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
+void* tlsf_realloc(void* ptr, size_t size)
@@ -997 +749,0 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
-	control_t* control = tlsf_cast(control_t*, tlsf);
@@ -1003 +755 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
-		tlsf_free(tlsf, ptr);
+		tlsf_free(ptr);
@@ -1008 +760 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
-		p = tlsf_malloc(tlsf, size);
+		p = tlsf_malloc(size);
@@ -1027 +779 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
-			p = tlsf_malloc(tlsf, size);
+			p = tlsf_malloc(size);
@@ -1032 +784 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
-				tlsf_free(tlsf, ptr);
+				tlsf_free(ptr);
@@ -1040 +792 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
-				block_merge_next(control, block);
+				block_merge_next(block);
@@ -1045 +797 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
-			block_trim_used(control, block, adjust);
+			block_trim_used(block, adjust);
diff --git tlsf.h tlsf.h
index 72496a1..da6a30f 100644
--- tlsf.h
+++ tlsf.h
@@ -25,5 +24,0 @@ extern "C" {
-/* 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;
-
@@ -31,4 +26,2 @@ typedef void* pool_t;
-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);
+void tlsf_create(void* mem);
+void tlsf_create_with_pool(void* mem, size_t bytes);
@@ -37,2 +30 @@ pool_t tlsf_get_pool(tlsf_t tlsf);
-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,22 +33,4 @@ void tlsf_remove_pool(tlsf_t tlsf, pool_t pool);
-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);
+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);