mem.c File Reference

#include "lwip/opt.h"
#include "lwip/mem.h"
#include "lwip/def.h"
#include "lwip/sys.h"
#include "lwip/stats.h"
#include "lwip/err.h"
#include <string.h>

Include dependency graph for mem.c:

Classes
struct	mem

Macros
#define	LWIP_MEM_ILLEGAL_FREE(msg)   LWIP_ASSERT(msg, 0)
#define	MEM_STATS_INC_LOCKED(x)   SYS_ARCH_LOCKED(MEM_STATS_INC(x))
#define	MEM_STATS_INC_USED_LOCKED(x, y)   SYS_ARCH_LOCKED(MEM_STATS_INC_USED(x, y))
#define	MEM_STATS_DEC_USED_LOCKED(x, y)   SYS_ARCH_LOCKED(MEM_STATS_DEC_USED(x, y))
#define	MEM_SANITY_OFFSET   0
#define	MEM_SANITY_OVERHEAD   0
#define	MIN_SIZE   12
#define	MIN_SIZE_ALIGNED   LWIP_MEM_ALIGN_SIZE(MIN_SIZE)
#define	SIZEOF_STRUCT_MEM   LWIP_MEM_ALIGN_SIZE(sizeof(struct mem))
#define	MEM_SIZE_ALIGNED   LWIP_MEM_ALIGN_SIZE(MEM_SIZE)
#define	LWIP_RAM_HEAP_POINTER   ram_heap
#define	LWIP_MEM_FREE_DECL_PROTECT()
#define	LWIP_MEM_FREE_PROTECT()   sys_mutex_lock(&mem_mutex)
#define	LWIP_MEM_FREE_UNPROTECT()   sys_mutex_unlock(&mem_mutex)
#define	LWIP_MEM_ALLOC_DECL_PROTECT()
#define	LWIP_MEM_ALLOC_PROTECT()
#define	LWIP_MEM_ALLOC_UNPROTECT()
#define	LWIP_MEM_LFREE_VOLATILE
#define	MEM_SANITY()
#define	mem_overflow_init_element(mem, size)
#define	mem_overflow_check_element(mem)

Functions
	LWIP_DECLARE_MEMORY_ALIGNED (ram_heap, MEM_SIZE_ALIGNED+(2U *SIZEOF_STRUCT_MEM))
static struct mem *	ptr_to_mem (mem_size_t ptr)
static mem_size_t	mem_to_ptr (void *mem)
static void	plug_holes (struct mem *mem)
void	mem_init (void)
static int	mem_link_valid (struct mem *mem)
void	mem_free (void *rmem)
void *	mem_trim (void *rmem, mem_size_t new_size)
void *	mem_malloc (mem_size_t size_in)
void *	mem_calloc (mem_size_t count, mem_size_t size)

Variables
static u8_t *	ram
static struct mem *	ram_end
static sys_mutex_t	mem_mutex
static struct mem *LWIP_MEM_LFREE_VOLATILE	lfree

Detailed Description

Dynamic memory manager

This is a lightweight replacement for the standard C library malloc().

If you want to use the standard C library malloc() instead, define MEM_LIBC_MALLOC to 1 in your lwipopts.h

To let mem_malloc() use pools (prevents fragmentation and is much faster than a heap but might waste some memory), define MEM_USE_POOLS to 1, define MEMP_USE_CUSTOM_POOLS to 1 and create a file "lwippools.h" that includes a list of pools like this (more pools can be added between _START and _END):

Define three pools with sizes 256, 512, and 1512 bytes LWIP_MALLOC_MEMPOOL_START LWIP_MALLOC_MEMPOOL(20, 256) LWIP_MALLOC_MEMPOOL(10, 512) LWIP_MALLOC_MEMPOOL(5, 1512) LWIP_MALLOC_MEMPOOL_END

Macro Definition Documentation

LWIP_MEM_ALLOC_DECL_PROTECT

#define LWIP_MEM_ALLOC_DECL_PROTECT

(

)

LWIP_MEM_ALLOC_PROTECT

#define LWIP_MEM_ALLOC_PROTECT

(

)

LWIP_MEM_ALLOC_UNPROTECT

#define LWIP_MEM_ALLOC_UNPROTECT

(

)

LWIP_MEM_FREE_DECL_PROTECT

#define LWIP_MEM_FREE_DECL_PROTECT

(

)

LWIP_MEM_FREE_PROTECT

#define LWIP_MEM_FREE_PROTECT

(

)

sys_mutex_lock(&mem_mutex)

LWIP_MEM_FREE_UNPROTECT

#define LWIP_MEM_FREE_UNPROTECT

(

)

sys_mutex_unlock(&mem_mutex)

LWIP_MEM_ILLEGAL_FREE

#define LWIP_MEM_ILLEGAL_FREE

(

msg

)

LWIP_ASSERT(msg, 0)

LWIP_MEM_LFREE_VOLATILE

#define LWIP_MEM_LFREE_VOLATILE

LWIP_RAM_HEAP_POINTER

#define LWIP_RAM_HEAP_POINTER   ram_heap

mem_overflow_check_element

#define mem_overflow_check_element

(

mem

)

mem_overflow_init_element

#define mem_overflow_init_element	(		mem,
			size
	)

MEM_SANITY

#define MEM_SANITY

(

)

MEM_SANITY_OFFSET

#define MEM_SANITY_OFFSET   0

MEM_SANITY_OVERHEAD

#define MEM_SANITY_OVERHEAD   0

MEM_SIZE_ALIGNED

#define MEM_SIZE_ALIGNED   LWIP_MEM_ALIGN_SIZE(MEM_SIZE)

MEM_STATS_DEC_USED_LOCKED

#define MEM_STATS_DEC_USED_LOCKED	(		x,
			y
	)		SYS_ARCH_LOCKED(MEM_STATS_DEC_USED(x, y))

MEM_STATS_INC_LOCKED

#define MEM_STATS_INC_LOCKED

(

x

)

SYS_ARCH_LOCKED(MEM_STATS_INC(x))

MEM_STATS_INC_USED_LOCKED

#define MEM_STATS_INC_USED_LOCKED	(		x,
			y
	)		SYS_ARCH_LOCKED(MEM_STATS_INC_USED(x, y))

MIN_SIZE

#define MIN_SIZE   12

All allocated blocks will be MIN_SIZE bytes big, at least! MIN_SIZE can be overridden to suit your needs. Smaller values save space, larger values could prevent too small blocks to fragment the RAM too much.

MIN_SIZE_ALIGNED

#define MIN_SIZE_ALIGNED   LWIP_MEM_ALIGN_SIZE(MIN_SIZE)

SIZEOF_STRUCT_MEM

#define SIZEOF_STRUCT_MEM   LWIP_MEM_ALIGN_SIZE(sizeof(struct mem))

Function Documentation

LWIP_DECLARE_MEMORY_ALIGNED()

LWIP_DECLARE_MEMORY_ALIGNED	(	ram_heap	,
		MEM_SIZE_ALIGNED+	2U *SIZEOF_STRUCT_MEM
	)

If you want to relocate the heap to external memory, simply define LWIP_RAM_HEAP_POINTER as a void-pointer to that location. If so, make sure the memory at that location is big enough (see below on how that space is calculated). the heap. we need one struct mem at the end and some room for alignment

mem_calloc()

void* mem_calloc	(	mem_size_t	count,
		mem_size_t	size
	)

Contiguously allocates enough space for count objects that are size bytes of memory each and returns a pointer to the allocated memory.

The allocated memory is filled with bytes of value zero.

Parameters

count	number of objects to allocate
size	size of the objects to allocate

Returns

pointer to allocated memory / NULL pointer if there is an error

References LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF, MEM_DEBUG, mem_malloc(), NULL, and SZT_F.

Referenced by bridgeif_fdb_init().

Here is the call graph for this function:

Here is the caller graph for this function:

mem_free()

void mem_free

(

void *

rmem

)

Put a struct mem back on the heap

Parameters

rmem	is the data portion of a struct mem as returned by a previous call to mem_malloc()

References lfree, LWIP_DBG_LEVEL_SERIOUS, LWIP_DBG_LEVEL_SEVERE, LWIP_DBG_TRACE, LWIP_DEBUGF, LWIP_MEM_FREE_DECL_PROTECT, LWIP_MEM_FREE_PROTECT, LWIP_MEM_FREE_UNPROTECT, LWIP_MEM_ILLEGAL_FREE, MEM_ALIGNMENT, MEM_DEBUG, mem_link_valid(), mem_overflow_check_element, MEM_SANITY, MEM_SANITY_OFFSET, MEM_STATS_DEC_USED, MEM_STATS_INC_LOCKED, mem::next, NULL, plug_holes(), ram, ram_end, SIZEOF_STRUCT_MEM, and mem::used.

Referenced by do_memp_free_pool(), mem_free_callback(), pbuf_free(), and slipif_init().

Here is the call graph for this function:

Here is the caller graph for this function:

mem_init()

void mem_init

(

void

)

Zero the heap and initialise start, end and lowest-free

References ERR_OK, lfree, LWIP_ASSERT, LWIP_MEM_ALIGN, LWIP_RAM_HEAP_POINTER, MEM_ALIGNMENT, mem_mutex, MEM_SANITY, MEM_SIZE_ALIGNED, MEM_STATS_AVAIL, mem::next, mem::prev, ptr_to_mem(), ram, ram_end, SIZEOF_STRUCT_MEM, sys_mutex_new(), and mem::used.

Referenced by lwip_init().

Here is the call graph for this function:

Here is the caller graph for this function:

mem_link_valid()

static int mem_link_valid ( struct mem *  mem )

static

References MEM_SIZE_ALIGNED, mem_to_ptr(), mem::next, mem::prev, ptr_to_mem(), and ram_end.

Referenced by mem_free().

Here is the call graph for this function:

Here is the caller graph for this function:

mem_malloc()

void* mem_malloc

(

mem_size_t

size_in

)

Allocate a block of memory with a minimum of 'size' bytes.

Parameters

size_in

is the minimum size of the requested block in bytes.

Returns

pointer to allocated memory or NULL if no free memory was found.

Note that the returned value will always be aligned (as defined by MEM_ALIGNMENT).

References lfree, LWIP_ASSERT, LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF, LWIP_MEM_ALIGN_SIZE, LWIP_MEM_ALLOC_DECL_PROTECT, LWIP_MEM_ALLOC_PROTECT, LWIP_MEM_ALLOC_UNPROTECT, MEM_ALIGNMENT, MEM_DEBUG, mem_mutex, mem_overflow_init_element, MEM_SANITY, MEM_SANITY_OFFSET, MEM_SIZE_ALIGNED, MEM_STATS_INC, MEM_STATS_INC_USED, mem_to_ptr(), MIN_SIZE_ALIGNED, mem::next, NULL, mem::prev, ptr_to_mem(), ram_end, S16_F, SIZEOF_STRUCT_MEM, sys_mutex_lock(), sys_mutex_unlock(), and mem::used.

Referenced by do_memp_malloc_pool(), mem_calloc(), pbuf_alloc(), and slipif_init().

Here is the call graph for this function:

Here is the caller graph for this function:

mem_to_ptr()

static mem_size_t mem_to_ptr ( void *  mem )

static

References ram.

Referenced by mem_link_valid(), mem_malloc(), mem_trim(), and plug_holes().

Here is the caller graph for this function:

mem_trim()

void* mem_trim	(	void *	rmem,
		mem_size_t	new_size
	)

Shrink memory returned by mem_malloc().

Parameters

rmem	pointer to memory allocated by mem_malloc the is to be shrinked
new_size	required size after shrinking (needs to be smaller than or equal to the previous size)

Returns

for compatibility reasons: is always == rmem, at the moment or NULL if newsize is > old size, in which case rmem is NOT touched or freed!

References lfree, LWIP_ASSERT, LWIP_DBG_LEVEL_SEVERE, LWIP_DEBUGF, LWIP_MEM_ALIGN_SIZE, LWIP_MEM_FREE_DECL_PROTECT, LWIP_MEM_FREE_PROTECT, LWIP_MEM_FREE_UNPROTECT, MEM_DEBUG, mem_overflow_check_element, mem_overflow_init_element, MEM_SANITY, MEM_SANITY_OFFSET, MEM_SANITY_OVERHEAD, MEM_SIZE_ALIGNED, MEM_STATS_DEC_USED, MEM_STATS_INC_LOCKED, mem_to_ptr(), MIN_SIZE_ALIGNED, mem::next, NULL, mem::prev, ptr_to_mem(), ram, ram_end, SIZEOF_STRUCT_MEM, and mem::used.

Referenced by pbuf_realloc().

Here is the call graph for this function:

Here is the caller graph for this function:

plug_holes()

static void plug_holes ( struct mem *  mem )

static

"Plug holes" by combining adjacent empty struct mems. After this function is through, there should not exist one empty struct mem pointing to another empty struct mem.

Parameters

mem	this points to a struct mem which just has been freed

References lfree, LWIP_ASSERT, MEM_SIZE_ALIGNED, mem_to_ptr(), mem::next, mem::prev, ptr_to_mem(), ram, ram_end, and mem::used.

Referenced by mem_free().

Here is the call graph for this function:

Here is the caller graph for this function:

ptr_to_mem()

static struct mem* ptr_to_mem ( mem_size_t  ptr )

static

References ram.

Referenced by mem_init(), mem_link_valid(), mem_malloc(), mem_trim(), and plug_holes().

Here is the caller graph for this function:

Variable Documentation

lfree

struct mem* LWIP_MEM_LFREE_VOLATILE lfree

static

pointer to the lowest free block, this is used for faster search

Referenced by mem_free(), mem_init(), mem_malloc(), mem_trim(), and plug_holes().

mem_mutex

sys_mutex_t mem_mutex

static

concurrent access protection

Referenced by mem_init(), and mem_malloc().

ram

u8_t* ram

static

pointer to the heap (ram_heap): for alignment, ram is now a pointer instead of an array

Referenced by mem_free(), mem_init(), mem_to_ptr(), mem_trim(), plug_holes(), and ptr_to_mem().

ram_end

struct mem* ram_end

static

the last entry, always unused!

Referenced by mem_free(), mem_init(), mem_link_valid(), mem_malloc(), mem_trim(), and plug_holes().