pkg/tlsf: Refactor the TLSF package and bring back original TLSF api.

- Cleanup package makefile.
- Download directly from git.
- Remove giant patch.
- Implement malloc function as a contrib package.
- Update ccn example.
- Update ps command.

Makefile.dep

@@ -723,6 +723,10 @@ ifneq (,$(filter rdcli_common,$(USEMODULE)))
   USEMODULE += luid
 endif
 
+ifneq (,$(filter tlsf-malloc,$(USEMODULE)))
+  USEPKG += tlsf
+endif
+
 # always select gpio (until explicit dependencies are sorted out)
 FEATURES_OPTIONAL += periph_gpio
 

examples/ccn-lite-relay/Makefile

@@ -37,8 +37,7 @@ USEMODULE += timex
 USEMODULE += xtimer
 USEMODULE += random
 USEMODULE += prng_xorshift
-
-USEPKG += tlsf
+USEMODULE += tlsf-malloc
 
 USEPKG += ccn-lite
 

examples/ccn-lite-relay/main.c

@@ -37,7 +37,7 @@ static uint32_t _tlsf_heap[TLSF_BUFFER];
 
 int main(void)
 {
-    tlsf_create_with_pool(_tlsf_heap, sizeof(_tlsf_heap));
+    tlsf_add_global_pool(_tlsf_heap, sizeof(_tlsf_heap));
     msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE);
 
     puts("Basic CCN-Lite example");

pkg/tlsf/Makefile

@@ -1,34 +1,13 @@
-PKG_NAME = tlsf
-PKG_VERSION = 3.0
-PKG_FILE = tlsf-$(PKG_VERSION).zip
-PKG_URL = http://download.riot-os.org/$(PKG_FILE)
-PKG_MD5 = 176965d58af525347e582e1630ea9604
-PKG_LICENSE = PD
-PKG_DIR=$(CURDIR)
-PKG_BUILDDIR=$(PKGDIRBASE)/$(PKG_NAME)
-PKG_SRCDIR=$(PKG_BUILDDIR)/src
+PKG_NAME=tlsf
+PKG_URL=https://github.com/mattconte/tlsf
+PKG_VERSION=a1f743ffac0305408b39e791e0ffb45f6d9bc777
+PKG_LICENSE=BSD
 
-.PHONY: all prepare clean distclean
+.PHONY: all
 
-all: $(PKG_SRCDIR)/$(PKG_NAME).a
+all: Makefile.tlsf
+	@cp Makefile.tlsf $(PKG_BUILDDIR)/Makefile
+	"$(MAKE)" -C $(PKG_BUILDDIR)
 
-prepare: $(PKG_SRCDIR)/Makefile
 
-$(PKG_SRCDIR)/$(PKG_NAME).a: $(PKG_SRCDIR)/Makefile
-	$(Q)"$(MAKE)" -C $(<D)
-
-$(PKG_SRCDIR)/Makefile: $(PKG_BUILDDIR)/$(PKG_FILE) $(CURDIR)/patch.txt
-	rm -rf $(@D)
-	mkdir -p $(@D)
-	$(Q)cd $(@D) && $(UNZIP_HERE) $(PKG_BUILDDIR)/$(PKG_FILE)
-	$(Q)cd $(@D) && patch --binary -p0 -N -i $(CURDIR)/patch.txt
-
-$(PKG_BUILDDIR)/$(PKG_FILE):
-	@mkdir -p $(@D)
-	$(Q)$(DLCACHE) $(PKG_URL) $(PKG_MD5) $@
-
-clean::
-	rm -rf $(PKG_SRCDIR)/
-
-distclean::
-	rm -rf $(PKG_BUILDDIR)/
+include $(RIOTBASE)/pkg/pkg.mk

pkg/tlsf/Makefile.include

@@ -1 +1,6 @@
-INCLUDES += -I$(PKGDIRBASE)/tlsf/src
+INCLUDES += -I$(PKGDIRBASE)/tlsf
+
+ifneq (,$(filter tlsf-malloc,$(USEMODULE)))
+  INCLUDES += -I$(RIOTPKG)/tlsf/contrib/include
+  DIRS += $(RIOTPKG)/tlsf/contrib
+endif

pkg/tlsf/Makefile.tlsf

@@ -0,0 +1,3 @@
+MODULE = tlsf
+
+include $(RIOTBASE)/Makefile.base

pkg/tlsf/contrib/Makefile

@@ -0,0 +1,3 @@
+MODULE := tlsf-malloc
+
+include $(RIOTBASE)/Makefile.base

pkg/tlsf/contrib/include/tlsf-malloc.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2014-2018 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.
+ */
+/**
+ * @defgroup pkg_tlsf_malloc TLSF-based malloc.
+ * @ingroup  pkg
+ * @ingroup  sys
+ *
+ * @brief    TLSF-based global memory allocator.
+ *
+ * This is a malloc/free implementation built on top of the TLSF allocator.
+ * It defines a global tlsf_control block and performs allocations on that
+ * block. This implemetation replaces the system malloc
+ *
+ * Additionally, the calls to TLSF are wrapped in irq_disable()/irq_restore(),
+ * to make it thread-safe.
+ *
+ * If this module is used as the system memory allocator, then the global memory
+ * control block should be initialized as the first thing before the stdlib is
+ * used. Boards should use tlsf_add_global_pool() at startup to add all the memory
+ * regions they want to make available for dynamic allocation via malloc().
+ *
+ * @{
+ * @file
+ *
+ * @brief   TLSF-based global memory allocator.
+ * @author  René Kijewski
+ * @author  Juan I Carrano
+ *
+ */
+
+#ifndef TLSF_MALLOC_H
+#define TLSF_MALLOC_H
+
+#include <stddef.h>
+#include "tlsf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Add an area of memory to the global allocator pool.
+ *
+ * The first time this function is called, it will automatically perform a
+ * tlsf_create() on the global tlsf_control block.
+ *
+ * @warning If this module is used, then this function MUST be called at least
+ *          once, before any allocations take place.
+ *
+ * @param   mem        Pointer to memory area. Should be aligned to 4 bytes.
+ * @param   bytes      Size in bytes of the memory area.
+ *
+ * @return  0 on success, nonzero on failure.
+ */
+int tlsf_add_global_pool(void *mem, size_t bytes);
+
+/**
+ * Get a pointer to the global tlsf_control block.
+ *
+ * Use for debugging purposes only.
+ */
+tlsf_t *_tlsf_get_global_control(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TLSF_MALLOC_H */
+
+/**
+ * @}
+ */

pkg/tlsf/contrib/tlsf-malloc.c

@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2014-2018 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   TLSF-based global memory allocator.
+ * @author  René Kijewski
+ * @author  Juan I Carrano
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "irq.h"
+#include "tlsf.h"
+#include "tlsf-malloc.h"
+
+/**
+ * Global memory heap (really a collection of pools, or areas)
+ **/
+static tlsf_t gheap = NULL;
+
+/* TODO: Add defines for other compilers */
+#ifdef __GNUC__
+
+#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__ */
+
+int tlsf_add_global_pool(void *mem, size_t bytes)
+{
+    if (gheap == NULL) {
+        gheap = tlsf_create_with_pool(mem, bytes);
+        return gheap == NULL;
+    }
+    else {
+        return tlsf_add_pool(gheap, mem, bytes) == NULL;
+    }
+}
+
+tlsf_t *_tlsf_get_global_control(void)
+{
+    return gheap;
+}
+
+/**
+ * Allocate a block of size "bytes"
+ */
+ATTR_MALLOC void *malloc(size_t bytes)
+{
+    unsigned old_state = irq_disable();
+    void *result = tlsf_malloc(gheap, bytes);
+
+    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) {
+        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(gheap, align, bytes);
+
+    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(gheap, ptr, size);
+
+    irq_restore(old_state);
+    return result;
+}
+
+
+/**
+ * Deallocate a block of data.
+ */
+void free(void *ptr)
+{
+    unsigned old_state = irq_disable();
+
+    tlsf_free(gheap, ptr);
+    irq_restore(old_state);
+}
+
+/**
+ * @}
+ */

pkg/tlsf/doc.txt

@@ -0,0 +1,21 @@
+/**
+ * @defgroup pkg_tlsf	Two-Level Segregated Fit memory allocator
+ * @ingroup  pkg
+ * @brief    TLSF is a general purpose dynamic memory allocator specifically
+ *            designed to meet real-time requirements:
+ * @see      http://www.gii.upv.es/tlsf/
+ * @see      https://github.com/mattconte/tlsf
+ *
+ * TLSF provides an implementation of malloc/realloc/free/etc with the following
+ * characteristics:
+ *
+ *  - O(1) Performance
+ *  - Works on a user supplied block of memory instead of a global heap.
+ *  - Efficient both in terms of memory overhead and processor time.
+ *  - Low fragmentation.
+ *
+ * Additionally, a contrib package @see pkg_tlsf_malloc implements a global heap
+ * allocator with the standard malloc/free functions.
+ *
+ *  @todo    The tlsf code uses printf to report errors. This is not OK.
+ */

pkg/tlsf/patch.txt

@@ -1,578 +0,0 @@
-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..99c84b2 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;
-@@ -168,0 +157,4 @@ typedef ptrdiff_t tlsfptr_t;
-+#ifdef DEVELHELP
-+void *default_pool;
-+#endif
-+
-@@ -345 +337 @@ 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)
-@@ -354 +346 @@ static block_header_t* search_suitable_block(control_t* control, int* fli, int*
--	unsigned int sl_map = control->sl_bitmap[fl] & (~0 << sl);
-+	unsigned int sl_map = control->sl_bitmap[fl] & (((unsigned int)~0) << sl);
-@@ -358 +350 @@ static block_header_t* search_suitable_block(control_t* control, int* fli, int*
--		const unsigned int fl_map = control->fl_bitmap & (~0 << (fl + 1));
-+		const unsigned int fl_map = control->fl_bitmap & (((unsigned int)~0) << (fl + 1));
-@@ -378 +370 @@ 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 +399 @@ 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 +420 @@ 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 +424 @@ 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 +428 @@ 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 +432 @@ 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 +473 @@ 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 +480 @@ static block_header_t* block_merge_prev(control_t* control, block_header_t* bloc
--		block_remove(control, prev);
-+		block_remove(prev);
-@@ -496 +488 @@ 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 +496 @@ static block_header_t* block_merge_next(control_t* control, block_header_t* bloc
--		block_remove(control, next);
-+		block_remove(next);
-@@ -512 +504 @@ 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 +512 @@ 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 +517 @@ 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 +526,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 +531 @@ 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 +541 @@ static block_header_t* block_trim_free_leading(control_t* control, block_header_
--		block_insert(control, block);
-+		block_insert(block);
-@@ -555 +547 @@ 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 +555 @@ 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 +561 @@ 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 +567 @@ 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 +572 @@ 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 +580 @@ 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)
-@@ -605,0 +598 @@ static void control_construct(control_t* control)
-+#ifdef DEVELHELP
-@@ -608,0 +602 @@ static void control_construct(control_t* control)
-+typedef void (*tlsf_walker)(void* ptr, size_t size, int used);
-@@ -610 +604 @@ static void control_construct(control_t* control)
--typedef struct integrity_t
-+static void default_walker(void* ptr, size_t size, int used)
-@@ -612,20 +606,2 @@ 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;
-+	printf("\tMemory @ %p is %s, size: %u (block: %p)\n", ptr, used ? "used" : "free",
-+			(unsigned int)size, (void*) block_from_ptr(ptr));
-@@ -634 +610 @@ static void integrity_walker(void* ptr, size_t size, int used, void* user)
--int tlsf_check(tlsf_t tlsf)
-+void tlsf_walk_pool(void *pool)
-@@ -636,7 +612 @@ 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)
-+	if (!pool)
-@@ -644,37 +614 @@ int tlsf_check(tlsf_t tlsf)
--		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;
--			}
--		}
-+		pool = default_pool;
-@@ -682,15 +615,0 @@ int tlsf_check(tlsf_t tlsf)
--
--	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;
-@@ -702 +621 @@ void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user)
--		pool_walker(
-+		default_walker(
-@@ -705,2 +624 @@ void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user)
--			!block_is_free(block),
--			user);
-+			!block_is_free(block));
-@@ -720,0 +639 @@ size_t tlsf_block_size(void* ptr)
-+#endif
-@@ -722,49 +641 @@ size_t tlsf_block_size(void* ptr)
--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 +646 @@ 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 +658 @@ 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 +660,0 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
--#endif
-@@ -808 +673 @@ 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,13 +681,3 @@ 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");
-+#ifdef DEVELHELP
-+    default_pool = mem;
-+#endif
-@@ -830,2 +685 @@ void tlsf_remove_pool(tlsf_t tlsf, pool_t pool)
--	mapping_insert(block_size(block), &fl, &sl);
--	remove_free_block(control, block, fl, sl);
-+	return 1;
-@@ -838,2 +692 @@ void tlsf_remove_pool(tlsf_t tlsf, pool_t pool)
--#if _DEBUG
--int test_ffs_fls()
-+void tlsf_create(void* mem)
-@@ -841,34 +693,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 +698 @@ tlsf_t tlsf_create(void* mem)
--		return 0;
-+		return;
-@@ -882 +701 @@ tlsf_t tlsf_create(void* mem)
--	control_construct(tlsf_cast(control_t*, mem));
-+	control = tlsf_cast(control_t*, mem);
-@@ -884,14 +703 @@ 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 +706 @@ 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 +708,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 +712 @@ pool_t tlsf_get_pool(tlsf_t tlsf)
--void* tlsf_malloc(tlsf_t tlsf, size_t size)
-+void* tlsf_malloc(size_t size)
-@@ -907 +713,0 @@ void* tlsf_malloc(tlsf_t tlsf, size_t size)
--	control_t* control = tlsf_cast(control_t*, tlsf);
-@@ -909,2 +715,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 +719 @@ 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 +720,0 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)
--	control_t* control = tlsf_cast(control_t*, tlsf);
-@@ -932 +737 @@ 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 +765 @@ 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 +769 @@ 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 +772 @@ 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 +776,0 @@ void tlsf_free(tlsf_t tlsf, void* ptr)
--		control_t* control = tlsf_cast(control_t*, tlsf);
-@@ -976,3 +780,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 +799 @@ 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 +800,0 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
--	control_t* control = tlsf_cast(control_t*, tlsf);
-@@ -1003 +806 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
--		tlsf_free(tlsf, ptr);
-+		tlsf_free(ptr);
-@@ -1008 +811 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
--		p = tlsf_malloc(tlsf, size);
-+		p = tlsf_malloc(size);
-@@ -1027 +830 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
--			p = tlsf_malloc(tlsf, size);
-+			p = tlsf_malloc(size);
-@@ -1032 +835 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
--				tlsf_free(tlsf, ptr);
-+				tlsf_free(ptr);
-@@ -1040 +843 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)
--				block_merge_next(control, block);
-+				block_merge_next(block);
-@@ -1045 +848 @@ 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..6c945e5 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,7 +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);
-+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);
-@@ -49,14 +38,3 @@ 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);
-+#ifdef DEVELHELP
-+void tlsf_walk_pool(void *pool);
-+#endif

sys/oneway-malloc/include/malloc.h

@@ -20,6 +20,8 @@
  *
  * @note        You should prefer statically allocated memory whenever possible.
  *
+ * @see         pkg_tlsf
+ *
  * @{
  * @file
  *

sys/ps/ps.c

@@ -28,6 +28,7 @@
 
 #ifdef MODULE_TLSF
 #include "tlsf.h"
+#include "tlsf-malloc.h"
 #endif
 
 /* list of states copied from tcb.h */
@@ -146,7 +147,7 @@ void ps(void)
            overall_stacksz, overall_used);
 #   ifdef MODULE_TLSF
     puts("\nHeap usage:");
-    tlsf_walk_pool(NULL);
+    tlsf_walk_pool(tlsf_get_pool(_tlsf_get_global_control()), NULL, NULL);
 #   endif
 #endif
 }