@@ -1,5 +1,20 @@

 #if defined(TLSF_MALLOC)

+/**

+ * Copyright inside tlsf_malloc.h

+ */

+

+/**

+ * Sync'ed on Apr 6, 2021 with https://github.com/mattconte/tlsf

+ * - last commit:

+ * https://github.com/mattconte/tlsf/commit/deff9ab509341f264addbd3c8ada533678591905

+ *

+ * Summary of Kamailio specific changes:

+ * - fields to keep the usage statistics

+ * - alloc info structure for debug (file name, line, ...)

+ * - prototypes with debug info parameters

+ */

+

 #include <assert.h>

 #include <limits.h>

 #include <stddef.h>

@@ -7,15 +22,207 @@

 #include <stdlib.h>

 #include <string.h>

-#include "tlsf_malloc.h"

-#include "tlsf_malloc_bits.h"

-#include "src_loc.h"

-#include "memdbg.h"

-#include "memapi.h"

 #include "../dprint.h"

 #include "../cfg/cfg.h"

 #include "../globals.h"

+#include "src_loc.h"

+#include "memdbg.h"

+#include "memapi.h"

+

+#include "tlsf_malloc.h"

+

+#if defined(__cplusplus)

+#define tlsf_decl inline

+#else

+#define tlsf_decl static

+#endif

+

+/*

+** Architecture-specific bit manipulation routines.

+**

+** TLSF achieves O(1) cost for malloc and free operations by limiting

+** the search for a free block to a free list of guaranteed size

+** adequate to fulfill the request, combined with efficient free list

+** queries using bitmasks and architecture-specific bit-manipulation

+** routines.

+**

+** Most modern processors provide instructions to count leading zeroes

+** in a word, find the lowest and highest set bit, etc. These

+** specific implementations will be used when available, falling back

+** to a reasonably efficient generic implementation.

+**

+** NOTE: TLSF spec relies on ffs/fls returning value 0..31.

+** ffs/fls return 1-32 by default, returning 0 for error.

+*/

+

+/*

+** Detect whether or not we are building for a 32- or 64-bit (LP/LLP)

+** architecture. There is no reliable portable method at compile-time.

+*/

+#if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) \

+	|| defined (_WIN64) || defined (__LP64__) || defined (__LLP64__)

+#define TLSF_64BIT

+#endif

+

+/*

+** gcc 3.4 and above have builtin support, specialized for architecture.

+** Some compilers masquerade as gcc; patchlevel test filters them out.

+*/

+#if defined (__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \

+	&& defined (__GNUC_PATCHLEVEL__)

+

+#if defined (__SNC__)

+/* SNC for Playstation 3. */

+

+tlsf_decl int tlsf_ffs(unsigned int word)

+{

+	const unsigned int reverse = word & (~word + 1);

+	const int bit = 32 - __builtin_clz(reverse);

+	return bit - 1;

+}

+

+#else

+

+tlsf_decl int tlsf_ffs(unsigned int word)

+{

+	return __builtin_ffs(word) - 1;

+}

+

+#endif

+

+tlsf_decl int tlsf_fls(unsigned int word)

+{

+	const int bit = word ? 32 - __builtin_clz(word) : 0;

+	return bit - 1;

+}

+

+#elif defined (_MSC_VER) && (_MSC_VER >= 1400) && (defined (_M_IX86) || defined (_M_X64))

+/* Microsoft Visual C++ support on x86/X64 architectures. */

+

+#include <intrin.h>

+

+#pragma intrinsic(_BitScanReverse)

+#pragma intrinsic(_BitScanForward)

+

+tlsf_decl int tlsf_fls(unsigned int word)

+{

+	unsigned long index;

+	return _BitScanReverse(&index, word) ? index : -1;

+}

+

+tlsf_decl int tlsf_ffs(unsigned int word)

+{

+	unsigned long index;

+	return _BitScanForward(&index, word) ? index : -1;

+}

+

+#elif defined (_MSC_VER) && defined (_M_PPC)

+/* Microsoft Visual C++ support on PowerPC architectures. */

+

+#include <ppcintrinsics.h>

+

+tlsf_decl int tlsf_fls(unsigned int word)

+{

+	const int bit = 32 - _CountLeadingZeros(word);

+	return bit - 1;

+}

+

+tlsf_decl int tlsf_ffs(unsigned int word)

+{

+	const unsigned int reverse = word & (~word + 1);

+	const int bit = 32 - _CountLeadingZeros(reverse);

+	return bit - 1;

+}

+

+#elif defined (__ARMCC_VERSION)

+/* RealView Compilation Tools for ARM */

+

+tlsf_decl int tlsf_ffs(unsigned int word)

+{

+	const unsigned int reverse = word & (~word + 1);

+	const int bit = 32 - __clz(reverse);

+	return bit - 1;

+}

+

+tlsf_decl int tlsf_fls(unsigned int word)

+{

+	const int bit = word ? 32 - __clz(word) : 0;

+	return bit - 1;

+}

+

+#elif defined (__ghs__)

+/* Green Hills support for PowerPC */

+

+#include <ppc_ghs.h>

+

+tlsf_decl int tlsf_ffs(unsigned int word)

+{

+	const unsigned int reverse = word & (~word + 1);

+	const int bit = 32 - __CLZ32(reverse);

+	return bit - 1;

+}

+

+tlsf_decl int tlsf_fls(unsigned int word)

+{

+	const int bit = word ? 32 - __CLZ32(word) : 0;

+	return bit - 1;

+}

+

+#else

+/* Fall back to generic implementation. */

+

+tlsf_decl int tlsf_fls_generic(unsigned int word)

+{

+	int bit = 32;

+

+	if (!word) bit -= 1;

+	if (!(word & 0xffff0000)) { word <<= 16; bit -= 16; }

+	if (!(word & 0xff000000)) { word <<= 8; bit -= 8; }

+	if (!(word & 0xf0000000)) { word <<= 4; bit -= 4; }

+	if (!(word & 0xc0000000)) { word <<= 2; bit -= 2; }

+	if (!(word & 0x80000000)) { word <<= 1; bit -= 1; }

+

+	return bit;

+}

+

+/* Implement ffs in terms of fls. */

+tlsf_decl int tlsf_ffs(unsigned int word)

+{

+	return tlsf_fls_generic(word & (~word + 1)) - 1;

+}

+

+tlsf_decl int tlsf_fls(unsigned int word)

+{

+	return tlsf_fls_generic(word) - 1;

+}

+

+#endif

+

+/* Possibly 64-bit version of tlsf_fls. */

+#if defined (TLSF_64BIT)

+tlsf_decl int tlsf_fls_sizet(size_t size)

+{

+	int high = (int)(size >> 32);

+	int bits = 0;

+	if (high)

+	{

+		bits = 32 + tlsf_fls(high);

+	}

+	else

+	{

+		bits = tlsf_fls((int)size & 0xffffffff);

+

+	}

+	return bits;

+}

+#else

+#define tlsf_fls_sizet tlsf_fls

+#endif

+

+#undef tlsf_decl

+

+

 /*

 ** Constants.

 */

@@ -23,7 +230,10 @@

 /* Public constants: may be modified. */

 enum tlsf_public

 {

-	/* log2 of number of linear subdivisions of block sizes. */

+	/* log2 of number of linear subdivisions of block sizes. Larger

+	** values require more memory in the control structure. Values of

+	** 4 or 5 are typical.

+	*/

 	SL_INDEX_COUNT_LOG2 = 5,

 };

@@ -104,14 +314,16 @@ tlsf_static_assert(ALIGN_SIZE == SMALL_BLOCK_SIZE / SL_INDEX_COUNT);

 /*

 ** Data structures and associated constants.

 */

+

 #ifdef DBG_TLSF_MALLOC

-typedef struct {

+typedef struct alloc_info {

 	const char* file;

 	const char* func;

 	const char* mname;

 	unsigned int line;

 } alloc_info_t;

 #endif

+

 /*

 ** Block header structure.

 **

@@ -171,20 +383,30 @@ static const size_t block_size_min =

 	sizeof(block_header_t) - sizeof(block_header_t*);

 static const size_t block_size_max = tlsf_cast(size_t, 1) << FL_INDEX_MAX;

-#define TLSF_INCREASE_REAL_USED(control, increment) do {control->real_used += (increment) ; control->max_used = tlsf_max(control->real_used, control->max_used);}while(0)

-#define TLSF_INCREASE_FRAGMENTS(control) do {control->fragments++ ; control->max_fragments = tlsf_max(control->fragments, control->max_fragments);}while(0)

+#define TLSF_INCREASE_REAL_USED(control, increment) do { \

+		control->real_used += (increment); \

+		control->max_used = tlsf_max(control->real_used, control->max_used); \

+	} while(0)

+#define TLSF_INCREASE_FRAGMENTS(control) do { \

+		control->fragments++; \

+		control->max_fragments = tlsf_max(control->fragments, \

+				control->max_fragments);\

+	} while(0)

 /* The TLSF control structure. */

 typedef struct control_t

 {

 	/* Empty lists point at this block to indicate they are free. */

 	block_header_t block_null;

+

+	/* Kamailio statistics */

 	size_t total_size;

 	size_t allocated;

 	size_t real_used;

 	size_t max_used;

 	size_t fragments;

 	size_t max_fragments;

+

 	/* Bitmaps for free lists. */

 	unsigned int fl_bitmap;

 	unsigned int sl_bitmap[FL_INDEX_COUNT];

@@ -213,7 +435,7 @@ static void block_set_size(block_header_t* block, size_t size)

 static int block_is_last(const block_header_t* block)

 {

-	return 0 == block_size(block);

+	return block_size(block) == 0;

 }

 static int block_is_free(const block_header_t* block)

@@ -267,6 +489,7 @@ static block_header_t* offset_to_block(const void* ptr, size_t size)

 /* Return location of previous block. */

 static block_header_t* block_prev(const block_header_t* block)

 {

+	tlsf_assert(block_is_prev_free(block) && "previous block must be free");

 	return block->prev_phys_block;

 }

@@ -274,7 +497,7 @@ static block_header_t* block_prev(const block_header_t* block)

 static block_header_t* block_next(const block_header_t* block)

 {

 	block_header_t* next = offset_to_block(block_to_ptr(block),

-		block_size(block) - sizeof(block_header_t*));

+		block_size(block) - block_header_overhead);

 	tlsf_assert(!block_is_last(block));

 	return next;

 }

@@ -329,10 +552,15 @@ static void* align_ptr(const void* ptr, size_t align)

 static size_t adjust_request_size(size_t size, size_t align)

 {

 	size_t adjust = 0;

-	if (size && size < block_size_max)

+	if (size)

 	{

 		const size_t aligned = align_up(size, align);

-		adjust = tlsf_max(aligned, block_size_min);

+

+		/* aligned sized must not exceed block_size_max or we'll go out of bounds on sl_bitmap */

+		if (aligned < block_size_max)

+		{

+			adjust = tlsf_max(aligned, block_size_min);

+		}

 	}

 	return adjust;

 }

@@ -364,7 +592,7 @@ static void mapping_insert(size_t size, int* fli, int* sli)

 /* This version rounds up to the next block size (for allocations) */

 static void mapping_search(size_t size, int* fli, int* sli)

 {

-	if (size >= (1 << SL_INDEX_COUNT_LOG2))

+	if (size >= SMALL_BLOCK_SIZE)

 	{

 		const size_t round = (1 << (tlsf_fls_sizet(size) - SL_INDEX_COUNT_LOG2)) - 1;

 		size += round;

@@ -381,11 +609,11 @@ static block_header_t* search_suitable_block(control_t* control, int* fli, int*

 	** First, search for a block in the list associated with the given

 	** fl/sl index.

 	*/

-	unsigned int sl_map = control->sl_bitmap[fl] & (~0 << sl);

+	unsigned int sl_map = control->sl_bitmap[fl] & (~0U << sl);

 	if (!sl_map)

 	{

 		/* No block exists. Search in the next largest first-level list. */

-		const unsigned int fl_map = control->fl_bitmap & (~0 << (fl + 1));

+		const unsigned int fl_map = control->fl_bitmap & (~0U << (fl + 1));

 		if (!fl_map)

 		{

 			/* No free blocks available, memory has been exhausted. */

@@ -451,8 +679,9 @@ static void insert_free_block(control_t* control, block_header_t* block, int fl,

 	** and second-level bitmaps appropriately.

 	*/

 	control->blocks[fl][sl] = block;

-	control->fl_bitmap |= (1 << fl);

-	control->sl_bitmap[fl] |= (1 << sl);

+	control->fl_bitmap |= (1U << fl);

+	control->sl_bitmap[fl] |= (1U << sl);

+

 	TLSF_INCREASE_FRAGMENTS(control);

 }

@@ -482,7 +711,7 @@ static block_header_t* block_split(block_header_t* block, size_t size)

 {

 	/* Calculate the amount of space left in the remaining block. */

 	block_header_t* remaining =

-		offset_to_block(block_to_ptr(block), size - sizeof(block_header_t*));

+		offset_to_block(block_to_ptr(block), size - block_header_overhead);

 	const size_t remain_size = block_size(block) - (size + block_header_overhead);

@@ -491,6 +720,7 @@ static block_header_t* block_split(block_header_t* block, size_t size)

 	tlsf_assert(block_size(block) == remain_size + size + block_header_overhead);

 	block_set_size(remaining, remain_size);

+	tlsf_assert(block_size(remaining) >= block_size_min && "block split with invalid size");

 	block_set_size(block, size);

 	block_mark_as_free(remaining);

@@ -501,7 +731,7 @@ static block_header_t* block_split(block_header_t* block, size_t size)

 /* Absorb a free block's storage into an adjacent previous free block. */

 static block_header_t* block_absorb(block_header_t* prev, block_header_t* block)

 {

-	tlsf_assert(!block_is_last(prev) && "previous block can't be last!");

+	tlsf_assert(!block_is_last(prev) && "previous block can't be last");

 	/* Note: Leaves flags untouched. */

 	prev->size += block_size(block) + block_header_overhead;

 	block_link_next(prev);

@@ -531,7 +761,7 @@ static block_header_t* block_merge_next(control_t* control, block_header_t* bloc

 	if (block_is_free(next))

 	{

-		tlsf_assert(!block_is_last(block) && "previous block can't be last!");

+		tlsf_assert(!block_is_last(block) && "previous block can't be last");

 		block_remove(control, next);

 		block = block_absorb(block, next);

 	}

@@ -577,6 +807,22 @@ 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)

+{

+	block_header_t* remaining_block = block;

+	if (block_can_split(block, size))

+	{

+		/* We want the 2nd block. */

+		remaining_block = block_split(block, size - block_header_overhead);

+		block_set_prev_free(remaining_block);

+

+		block_link_next(block);

+		block_insert(control, block);

+	}

+

+	return remaining_block;

+}

+

 static block_header_t* block_locate_free(control_t* control, size_t size)

 {

 	int fl = 0, sl = 0;

@@ -585,7 +831,17 @@ static block_header_t* block_locate_free(control_t* control, size_t size)

 	if (size)

 	{

 		mapping_search(size, &fl, &sl);

-		block = search_suitable_block(control, &fl, &sl);

+

+		/*

+		** mapping_search can futz with the size, so for excessively large sizes it can sometimes wind up

+		** with indices that are off the end of the block array.

+		** So, we protect against that here, since this is the only callsite of mapping_search.

+		** Note that we don't need to check sl, since it comes from a modulo operation that guarantees it's always in range.

+		*/

+		if (fl < FL_INDEX_COUNT)

+		{

+			block = search_suitable_block(control, &fl, &sl);

+		}

 	}

 	if (block)

@@ -606,11 +862,13 @@ static void* block_prepare_used(control_t* control, block_header_t* block, size_

 	void* p = 0;

 	if (block)

 	{

+		tlsf_assert(size && "size must be non-zero");

 		block_trim_free(control, block, size);

 		block_mark_as_used(block);

 		p = block_to_ptr(block);

 		TLSF_INCREASE_REAL_USED(control, block_size(block) + (p - (void *)block

-				/* prev_phys_block is melted in the previous block when the current block is used */

+				/* prev_phys_block is melted in the previous block

+				 * when the current block is used */

 				+ sizeof(block->prev_phys_block)));

 		control->allocated += block_size(block);

 #ifdef DBG_TLSF_MALLOC

@@ -663,6 +921,7 @@ static void integrity_walker(void* ptr, size_t size, int used, void* user)

 	const size_t this_block_size = block_size(block);

 	int status = 0;

+	(void)used;

 	tlsf_insist(integ->prev_status == this_prev_status && "prev status incorrect");

 	tlsf_insist(size == this_block_size && "block size incorrect");

@@ -682,9 +941,9 @@ 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 fl_map = control->fl_bitmap & (1U << i);

 			const int sl_list = control->sl_bitmap[i];

-			const int sl_map = sl_list & (1 << j);

+			const int sl_map = sl_list & (1U << j);

 			const block_header_t* block = control->blocks[i][j];

 			/* Check that first- and second-level lists agree. */

@@ -733,7 +992,8 @@ static void default_walker(void* ptr, size_t size, int used, void* user)

 void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user)

 {

 	tlsf_walker pool_walker = walker ? walker : default_walker;

-	block_header_t* block = pool + tlsf_size() - sizeof(block_header_t*);

+	block_header_t* block =

+		offset_to_block(pool, -(int)block_header_overhead);

 	while (block && !block_is_last(block))

 	{

@@ -770,22 +1030,22 @@ int tlsf_check_pool(pool_t pool)

 ** 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()

+size_t tlsf_size(void)

 {

 	return sizeof(control_t);

 }

-size_t tlsf_align_size()

+size_t tlsf_align_size(void)

 {

 	return ALIGN_SIZE;

 }

-size_t tlsf_block_size_min()

+size_t tlsf_block_size_min(void)

 {

 	return block_size_min;

 }

-size_t tlsf_block_size_max()

+size_t tlsf_block_size_max(void)

 {

 	return block_size_max;

 }

@@ -795,12 +1055,12 @@ size_t tlsf_block_size_max()

 ** tlsf_add_pool, equal to the overhead of a free block and the

 ** sentinel block.

 */

-size_t tlsf_pool_overhead()

+size_t tlsf_pool_overhead(void)

 {

 	return 2 * block_header_overhead;

 }

-size_t tlsf_alloc_overhead()

+size_t tlsf_alloc_overhead(void)

 {

 	return block_header_overhead;

 }

@@ -839,17 +1099,19 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)

 	** so that the prev_phys_block field falls outside of the pool -

 	** it will never be used.

 	*/

-	block = mem - sizeof (size_t);/*offset_to_block(mem, -(tlsfptr_t)block_header_overhead);*/

+	block = offset_to_block(mem, -(tlsfptr_t)block_header_overhead);

 	block_set_size(block, pool_bytes);

 	block_set_free(block);

 	block_set_prev_used(block);

 	block_insert(tlsf_cast(control_t*, tlsf), block);

+

 	tlsf_cast(control_t*, tlsf)->total_size += block_size(block);

 #ifdef DBG_TLSF_MALLOC

 	block->alloc_info.file = _SRC_LOC_;

 	block->alloc_info.func = _SRC_FUNCTION_;

 	block->alloc_info.line = _SRC_LINE_;

 #endif

+

 	/* Split the block to create a zero-size sentinel block. */

 	next = block_link_next(block);

 	block_set_size(next, 0);

@@ -872,6 +1134,7 @@ void tlsf_remove_pool(tlsf_t tlsf, pool_t pool)

 	mapping_insert(block_size(block), &fl, &sl);

 	remove_free_block(control, block, fl, sl);

+

 	tlsf_cast(control_t*, tlsf)->total_size -= block_size(block);

 }

@@ -901,7 +1164,7 @@ int test_ffs_fls()

 	if (rv)

 	{

-		printf("tlsf_create: %x ffs/fls tests failed!\n", rv);

+		printf("test_ffs_fls: %x ffs/fls tests failed!\n", rv);

 	}

 	return rv;

 }

@@ -924,12 +1187,14 @@ tlsf_t tlsf_create(void* mem)

 	}

 	control_construct(tlsf_cast(control_t*, mem));

+

 	tlsf_cast(control_t*, mem)->real_used = tlsf_size();

 	tlsf_cast(control_t*, mem)->max_used = tlsf_size();

 	tlsf_cast(control_t*, mem)->allocated = 0;

 	tlsf_cast(control_t*, mem)->total_size = tlsf_size();

 	tlsf_cast(control_t*, mem)->fragments = 0;

 	tlsf_cast(control_t*, mem)->max_fragments = 0;

+

 	return tlsf_cast(tlsf_t, mem);

 }

@@ -996,6 +1261,73 @@ void* tlsf_mallocxz(tlsf_t tlsf, size_t size)

 }

+#ifdef DBG_TLSF_MALLOC

+void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size,

+		const char *file, const char *function, unsigned int line, const char *mname)

+#else

+void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size)

+#endif

+{

+	control_t* control = tlsf_cast(control_t*, tlsf);

+	const size_t adjust = adjust_request_size(size, ALIGN_SIZE);

+

+	/*

+	** We must allocate an additional minimum block size bytes so that if

+	** our free block will leave an alignment gap which is smaller, we can

+	** trim a leading free block and release it back to the pool. We must

+	** do this because the previous physical block is in use, therefore

+	** the prev_phys_block field is not valid, and we can't simply adjust

+	** the size of that block.

+	*/

+	const size_t gap_minimum = sizeof(block_header_t);

+	const size_t size_with_gap = adjust_request_size(adjust + align + gap_minimum, align);

+

+	/*

+	** If alignment is less than or equals base alignment, we're done.

+	** If we requested 0 bytes, return null, as tlsf_malloc(0) does.

+	*/

+	const size_t aligned_size = (adjust && align > ALIGN_SIZE) ? size_with_gap : adjust;

+

+	block_header_t* block = block_locate_free(control, aligned_size);

+

+	/* This can't be a static assert. */

+	tlsf_assert(sizeof(block_header_t) == block_size_min + block_header_overhead);

+

+	if (block)

+	{

+		void* ptr = block_to_ptr(block);

+		void* aligned = align_ptr(ptr, align);

+		size_t gap = tlsf_cast(size_t,

+			tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr));

+

+		/* If gap size is too small, offset to next aligned boundary. */

+		if (gap && gap < gap_minimum)

+		{

+			const size_t gap_remain = gap_minimum - gap;

+			const size_t offset = tlsf_max(gap_remain, align);

+			const void* next_aligned = tlsf_cast(void*,

+				tlsf_cast(tlsfptr_t, aligned) + offset);

+

+			aligned = align_ptr(next_aligned, align);

+			gap = tlsf_cast(size_t,

+				tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr));

+		}

+

+		if (gap)

+		{

+			tlsf_assert(gap >= gap_minimum && "gap size too small");

+			block = block_trim_free_leading(control, block, gap);

+		}

+	}

+

+#ifdef DBG_TLSF_MALLOC

+	return block_prepare_used(control, block, adjust, file, function, line, mname);

+#else

+	return block_prepare_used(control, block, adjust);

+#endif

+}

+

+

 #ifdef DBG_TLSF_MALLOC

 void tlsf_free(tlsf_t tlsf, void* ptr,

 		const char *file, const char *function, unsigned int line, const char *mname)

@@ -1011,6 +1343,8 @@ void tlsf_free(tlsf_t tlsf, void* ptr)

 	{

 		control_t* control = tlsf_cast(control_t*, tlsf);

 		block_header_t* block = block_from_ptr(ptr);

+

+		/* tlsf_assert(!block_is_free(block) && "block already marked as free"); */

 		if (block_is_free(block)) {

 			LOG(L_CRIT, "BUG: tlsf_free: freeing already freed pointer (%p)"

 #ifdef DBG_TLSF_MALLOC

@@ -1028,6 +1362,7 @@ void tlsf_free(tlsf_t tlsf, void* ptr)

 			}

 		}

+

 		control->allocated -= block_size(block);

 		control->real_used -= (block_size(block) + (ptr - (void *)block

 				/* prev_phys_block is melted in the previous block when the current block is used */

@@ -1038,13 +1373,15 @@ void tlsf_free(tlsf_t tlsf, void* ptr)

 		block->alloc_info.line = line;

 		block->alloc_info.mname = mname;

 #endif

+

 		block_mark_as_free(block);

 		block = block_merge_prev(control, block);

 		block = block_merge_next(control, block);

 		block_insert(control, block);

 	} else {

 #ifdef DBG_TLSF_MALLOC

-		LOG(L_WARN, "tlsf_free: free(0) called from %s: %s(%u)\n", file, function, line);

+		LOG(L_WARN, "tlsf_free: free(0) called from %s: %s(%u)\n",

+				file, function, line);

 #else

 		LOG(L_WARN, "tlsf_free: free(0) called\n");

 #endif

@@ -1129,6 +1466,7 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)

 		{

 			control->allocated -= block_size(block);

 			control->real_used -= block_size(block);

+

 			/* Do we need to expand to the next block? */

 			if (adjust > cursize)

 			{

@@ -1139,6 +1477,7 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size)

 			/* Trim the resulting block and return the original pointer. */

 			block_trim_used(control, block, adjust);

 			p = ptr;

+

 			control->allocated +=block_size(block);

 			TLSF_INCREASE_REAL_USED(control, block_size(block));

 		}

@@ -1174,6 +1513,14 @@ void* tlsf_reallocxf(tlsf_t tlsf, void* ptr, size_t size)

 	return r;

 }

+/* end of included tlsf.c from original project

+ * - includes the kamailio mallocxz and reallocxf specific functions */

+

+/* Kamailio memory API functions */

+

+/**

+ *

+ */

 void tlsf_meminfo(tlsf_t pool, struct mem_info *info)

 {

 	control_t* control = tlsf_cast(control_t*, pool);

@@ -4,18 +4,40 @@

 #if defined(TLSF_MALLOC)

 /*

-** Two Level Segregated Fit memory allocator, version 3.0.

-** Written by Matthew Conte, and placed in the Public Domain.

+** Two Level Segregated Fit memory allocator, version 3.1.

+** Written by Matthew Conte

 **	http://tlsf.baisoku.org

 **

 ** Based on the original documentation by Miguel Masmano:

-**	http://rtportal.upv.es/rtmalloc/allocators/tlsf/index.shtml

-**

-** Please see the accompanying Readme.txt for implementation

-** notes and caveats.

+**	http://www.gii.upv.es/tlsf/main/docs

 **

 ** This implementation was written to the specification

 ** of the document, therefore no GPL restrictions apply.

+**

+** Copyright (c) 2006-2016, Matthew Conte

+** All rights reserved.

+**

+** Redistribution and use in source and binary forms, with or without

+** modification, are permitted provided that the following conditions are met:

+**     * Redistributions of source code must retain the above copyright

+**       notice, this list of conditions and the following disclaimer.

+**     * Redistributions in binary form must reproduce the above copyright

+**       notice, this list of conditions and the following disclaimer in the

+**       documentation and/or other materials provided with the distribution.

+**     * Neither the name of the copyright holder nor the

+**       names of its contributors may be used to endorse or promote products

+**       derived from this software without specific prior written permission.

+**

+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+** DISCLAIMED. IN NO EVENT SHALL MATTHEW CONTE BE LIABLE FOR ANY

+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

 #include <stddef.h>

@@ -50,6 +72,8 @@ void* tlsf_malloc(tlsf_t tlsf, size_t size,

 		const char *file, const char *function, unsigned int line, const char *mname);

 void* tlsf_mallocxz(tlsf_t tlsf, size_t size,

 		const char *file, const char *function, unsigned int line, const char *mname);

+void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size,

+		const char *file, const char *function, unsigned int line, const char *mname);

 void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size,

 		const char *file, const char *function, unsigned int line, const char *mname);

 void* tlsf_reallocxf(tlsf_t tlsf, void* ptr, size_t size,

@@ -59,6 +83,7 @@ void tlsf_free(tlsf_t tlsf, void* ptr,

 #else

 void* tlsf_malloc(tlsf_t tlsf, size_t bytes);

 void* tlsf_mallocxz(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_reallocxf(tlsf_t tlsf, void* ptr, size_t size);

 void tlsf_free(tlsf_t tlsf, void* ptr);

@@ -68,12 +93,12 @@ void tlsf_free(tlsf_t tlsf, void* ptr);

 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();

+size_t tlsf_size(void);

+size_t tlsf_align_size(void);

+size_t tlsf_block_size_min(void);

+size_t tlsf_block_size_max(void);

+size_t tlsf_pool_overhead(void);

+size_t tlsf_alloc_overhead(void);

 /* Debugging. */

 typedef void (*tlsf_walker)(void* ptr, size_t size, int used, void* user);