From cf686bde2d6ca9635333958e52980e2e13f3a703 Mon Sep 17 00:00:00 2001
From: Juan Carrano <j.carrano@fu-berlin.de>
Date: Fri, 20 Apr 2018 11:12:33 +0200
Subject: [PATCH] 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 | 4 +
examples/ccn-lite-relay/Makefile | 3 +-
examples/ccn-lite-relay/main.c | 2 +-
pkg/tlsf/Makefile | 39 +-
pkg/tlsf/Makefile.include | 7 +-
pkg/tlsf/Makefile.tlsf | 3 +
pkg/tlsf/contrib/Makefile | 3 +
pkg/tlsf/contrib/include/tlsf-malloc.h | 78 +++
pkg/tlsf/contrib/tlsf-malloc.c | 129 ++++
pkg/tlsf/doc.txt | 21 +
pkg/tlsf/patch.txt | 578 ------------------
...ining-on-implicit-pointer-conversion.patch | Bin 0 -> 820 bytes
sys/oneway-malloc/include/malloc.h | 2 +
sys/ps/ps.c | 3 +-
14 files changed, 259 insertions(+), 613 deletions(-)
create mode 100644 pkg/tlsf/Makefile.tlsf
create mode 100644 pkg/tlsf/contrib/Makefile
create mode 100644 pkg/tlsf/contrib/include/tlsf-malloc.h
create mode 100644 pkg/tlsf/contrib/tlsf-malloc.c
delete mode 100644 pkg/tlsf/patch.txt
create mode 100644 pkg/tlsf/patches/0001-Fix-warnining-on-implicit-pointer-conversion.patch
diff --git a/Makefile.dep b/Makefile.dep
index fe41873223..0895d9992b 100644
--- a/Makefile.dep
+++ b/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
diff --git a/examples/ccn-lite-relay/Makefile b/examples/ccn-lite-relay/Makefile
index d32e337356..ccebd6c855 100644
--- a/examples/ccn-lite-relay/Makefile
+++ b/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
diff --git a/examples/ccn-lite-relay/main.c b/examples/ccn-lite-relay/main.c
index 05b6d6398f..a1f4eb11af 100644
--- a/examples/ccn-lite-relay/main.c
+++ b/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");
diff --git a/pkg/tlsf/Makefile b/pkg/tlsf/Makefile
index 42c8406081..8ccdebf817 100644
--- a/pkg/tlsf/Makefile
+++ b/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
diff --git a/pkg/tlsf/Makefile.include b/pkg/tlsf/Makefile.include
index 5334016a4d..6328327972 100644
--- a/pkg/tlsf/Makefile.include
+++ b/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
diff --git a/pkg/tlsf/Makefile.tlsf b/pkg/tlsf/Makefile.tlsf
new file mode 100644
index 0000000000..2650a27858
--- /dev/null
+++ b/pkg/tlsf/Makefile.tlsf
@@ -0,0 +1,3 @@
+MODULE = tlsf
+
+include $(RIOTBASE)/Makefile.base
diff --git a/pkg/tlsf/contrib/Makefile b/pkg/tlsf/contrib/Makefile
new file mode 100644
index 0000000000..290de6a16c
--- /dev/null
+++ b/pkg/tlsf/contrib/Makefile
@@ -0,0 +1,3 @@
+MODULE := tlsf-malloc
+
+include $(RIOTBASE)/Makefile.base
diff --git a/pkg/tlsf/contrib/include/tlsf-malloc.h b/pkg/tlsf/contrib/include/tlsf-malloc.h
new file mode 100644
index 0000000000..48ef8952b8
--- /dev/null
+++ b/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 */
+
+/**
+ * @}
+ */
diff --git a/pkg/tlsf/contrib/tlsf-malloc.c b/pkg/tlsf/contrib/tlsf-malloc.c
new file mode 100644
index 0000000000..b62f2111bd
--- /dev/null
+++ b/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);
+}
+
+/**
+ * @}
+ */
diff --git a/pkg/tlsf/doc.txt b/pkg/tlsf/doc.txt
index e69de29bb2..e660fc99bb 100644
--- a/pkg/tlsf/doc.txt
+++ b/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.
+ */
diff --git a/pkg/tlsf/patch.txt b/pkg/tlsf/patch.txt
deleted file mode 100644
index 64d4d05b10..0000000000
--- a/pkg/tlsf/patch.txt
+++ /dev/null
@@ -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
diff --git a/pkg/tlsf/patches/0001-Fix-warnining-on-implicit-pointer-conversion.patch b/pkg/tlsf/patches/0001-Fix-warnining-on-implicit-pointer-conversion.patch
new file mode 100644
index 0000000000000000000000000000000000000000..a900d96b774b6547c0e56aadd44cb4b1760e1884
GIT binary patch
literal 820
zcmcIi+iKh}5Pgmy|1c~p*zu*l?Zs|sHzX{jP$;BtO)-)zZIpFnBg@IsCjZ`%9r94<
zW3lA9$aBujvG%5W0LcngaJg=>CSi>7bVbWeF0(RYSz6|$%qZjemciFf!;R=6-9VC5
z(}FBXQnE*w3cid~!xc4#>JC2K$9#5oa*UWTt<rHLK9Xx{MdhGE$a1*s4ML<_Nb_p7
zs)`JP1R=@I$nFKV75w;i`TgqiPuQyyJW-<+J_o=?)I;AYt}OJO(pDJYoqiN%P@Rqm
ziK2*rZ3h{1cm_npFa@bv0sM~YgJ?pGl^%q#Sm6b}iyP63DU5tV8YLw}(E%ywyH_ao
z>JX(HaROOLzS*whSg@3{l0%v#>!NV%Z#5(c0(h(2?I7Bg+i(NHY%qcCPp#JcPVl4W
zsOmZ66BsPDio;{48f;I}v9<LRZI8luE_VUFH6aY@m%til!U=C2+=TNN=o|l>z;E1V
zQ<d*h@6Sne)*ED(-s09Sdsq$=LIukcc+1|u)r)Y(cX03t7S1l9f`v3f;Gs9_K^-(6
zB8)%Nv$o^MTH=+cu{RI5?;}_6Ke(o8;KKh0C%oXuxF+=`U7d7w-*v6$UMQI};Vl0w
UE8a4v?qA~J4<%Wg#swjN0Ll0JSO5S3
literal 0
HcmV?d00001
diff --git a/sys/oneway-malloc/include/malloc.h b/sys/oneway-malloc/include/malloc.h
index a0844d08e9..657ea27782 100644
--- a/sys/oneway-malloc/include/malloc.h
+++ b/sys/oneway-malloc/include/malloc.h
@@ -20,6 +20,8 @@
*
* @note You should prefer statically allocated memory whenever possible.
*
+ * @see pkg_tlsf
+ *
* @{
* @file
*
diff --git a/sys/ps/ps.c b/sys/ps/ps.c
index 5866863119..b8b53c073c 100644
--- a/sys/ps/ps.c
+++ b/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
}
--
GitLab