malloc.c File Reference

Dynamic memory allocation. More...

#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <ipxe/io.h>
#include <ipxe/list.h>
#include <ipxe/init.h>
#include <ipxe/refcnt.h>
#include <ipxe/malloc.h>
#include <valgrind/memcheck.h>

Go to the source code of this file.

Data Structures
struct	memory_block
	A free block of memory. More...
struct	autosized_block
	A block of allocated memory complete with size information. More...

Macros
#define	MIN_MEMBLOCK_ALIGN   ( 4 * sizeof ( void * ) )
	Physical address alignment maintained for free blocks of memory.
#define	HEAP_SIZE   ( 4096 * 1024 )
	Heap area size.
#define	HEAP_ALIGN   MIN_MEMBLOCK_ALIGN
	Heap area alignment.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	valgrind_make_blocks_defined (struct heap *heap)
	Mark all blocks in free list as defined.
static void	valgrind_make_blocks_noaccess (struct heap *heap)
	Mark all blocks in free list as inaccessible.
static void	check_blocks (struct heap *heap)
	Check integrity of the blocks in the free list.
static unsigned int	discard_cache (size_t size __unused)
	Discard some cached data.
static void	discard_all_cache (void)
	Discard all cached data.
static void *	heap_alloc_block (struct heap *heap, size_t size, size_t align, size_t offset)
	Allocate a memory block.
static void	heap_free_block (struct heap *heap, void *ptr, size_t size)
	Free a memory block.
void *	heap_realloc (struct heap *heap, void *old_ptr, size_t new_size)
	Reallocate memory.
void *	realloc (void *old_ptr, size_t new_size)
	Reallocate memory.
void *	malloc (size_t size)
	Allocate memory.
void	free (void *ptr)
	Free memory.
void *	zalloc (size_t size)
	Allocate cleared memory.
void	zfree (void *ptr)
	Clear and free memory.
void *	malloc_phys_offset (size_t size, size_t phys_align, size_t offset)
	Allocate memory with specified physical alignment and offset.
void *	malloc_phys (size_t size, size_t phys_align)
	Allocate memory with specified physical alignment.
void	free_phys (void *ptr, size_t size)
	Free memory allocated with malloc_phys().
void	heap_populate (struct heap *heap, void *start, size_t len)
	Add memory to allocation pool.
static void	init_heap (void)
	Initialise the heap.
struct init_fn heap_init_fn	__init_fn (INIT_EARLY)
	Memory allocator initialisation function.
static void	shutdown_cache (int booting __unused)
	Discard all cached data on shutdown.
struct startup_fn heap_startup_fn	__startup_fn (STARTUP_EARLY)
	Memory allocator shutdown function.
void	heap_dump (struct heap *heap)
	Dump free block list (for debugging).

Variables
static char	heap_area [HEAP_SIZE]
	The heap area.
static struct heap	heap
	The global heap.

Detailed Description

Dynamic memory allocation.

Memory allocation via malloc() is provided using a simple free-block list in a fixed-size heap.

The standard C semantics are supported. Calling realloc() with a size of zero is a valid way to free a block. Calling malloc() or realloc() with a size of zero will return a non-NULL value that can safely be passed to free() (meaning that callers can always treat a NULL return value as an error, without having to special-case a zero-length allocation).

(The POSIX semantics of setting a global errno variable on allocation failure are not supported: callers should check for a NULL return value and then return -ENOMEM as per the usual iPXE error propagation conventions.)

Memory allocation assumes that all input parameters are untrusted and must be checked. In particular, buffer sizes are frequently derived from untrusted input obtained via the network (e.g. an HTTP Content-Length header).

In contrast, memory deallocation assumes that the caller is always passing in a valid pointer value.

The internal heap is relatively small. Allocation is expected to sometimes fail in normal operation, and all callers must be prepared to handle it cleanly. Device drivers attempting to allocate receive buffers to refill a receive ring can simply exit the refill loop and do nothing until the next refill opportunity. Other callers will generally have to treat allocation failure as fatal and cleanly terminate their operation (e.g. by closing a connection).

The same internal heap supports both size-tracked allocations (using malloc()/free()) and known-size allocations (using malloc_phys()/free_phys(), where the caller must pass the original size when freeing the block). The latter are typically used for I/O buffers, driver descriptor rings, and other hardware-facing structures.

Depending upon the build platform, the underlying heap implementation may also be used to support external ("user") allocations using umalloc() and ufree().

A cache discard mechanism exists to attempt to alleviate memory pressure by discarding cached information (such as packets held in a TCP out-of-order receive queue) when an allocation attempt would otherwise fail. Code that holds pointers to discardable objects must be careful not to call any allocation functions.

Definition in file malloc.c.

Macro Definition Documentation

MIN_MEMBLOCK_ALIGN

#define MIN_MEMBLOCK_ALIGN   ( 4 * sizeof ( void * ) )

Physical address alignment maintained for free blocks of memory.

We keep memory blocks aligned on a power of two that is at least large enough to hold a struct memory_block.

Definition at line 118 of file malloc.c.

Referenced by init_heap().

HEAP_SIZE

#define HEAP_SIZE   ( 4096 * 1024 )

Heap area size.

Currently fixed at 4MB.

Definition at line 133 of file malloc.c.

HEAP_ALIGN

#define HEAP_ALIGN   MIN_MEMBLOCK_ALIGN

Heap area alignment.

Definition at line 136 of file malloc.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

valgrind_make_blocks_defined()

void valgrind_make_blocks_defined ( struct heap * heap )

inlinestatic

Mark all blocks in free list as defined.

Parameters

heap

Heap

Definition at line 146 of file malloc.c.

                                                                      {
        struct memory_block *block;
 
        /* Do nothing unless running under Valgrind */
        if ( RUNNING_ON_VALGRIND <= 0 )
                return;
 
        /* Traverse free block list, marking each block structure as
         * defined.  Some contortions are necessary to avoid errors
         * from list_check().
         */
 
        /* Mark block list itself as defined */
        VALGRIND_MAKE_MEM_DEFINED ( &heap->blocks, sizeof ( heap->blocks ) );
 
        /* Mark areas accessed by list_check() as defined */
        VALGRIND_MAKE_MEM_DEFINED ( &heap->blocks.prev->next,
                                    sizeof ( heap->blocks.prev->next ) );
        VALGRIND_MAKE_MEM_DEFINED ( heap->blocks.next,
                                    sizeof ( *heap->blocks.next ) );
        VALGRIND_MAKE_MEM_DEFINED ( &heap->blocks.next->next->prev,
                                    sizeof ( heap->blocks.next->next->prev ) );
 
        /* Mark each block in list as defined */
        list_for_each_entry ( block, &heap->blocks, list ) {
 
                /* Mark block as defined */
                VALGRIND_MAKE_MEM_DEFINED ( block, sizeof ( *block ) );
 
                /* Mark areas accessed by list_check() as defined */
                VALGRIND_MAKE_MEM_DEFINED ( block->list.next,
                                            sizeof ( *block->list.next ) );
                VALGRIND_MAKE_MEM_DEFINED ( &block->list.next->next->prev,
                                      sizeof ( block->list.next->next->prev ) );
        }
}

References block, heap::blocks, memory_block::list, list_for_each_entry, list_head::next, list_head::prev, RUNNING_ON_VALGRIND, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by heap_alloc_block(), and heap_free_block().

valgrind_make_blocks_noaccess()

void valgrind_make_blocks_noaccess ( struct heap * heap )

inlinestatic

Mark all blocks in free list as inaccessible.

Parameters

heap

Heap

Definition at line 188 of file malloc.c.

                                                                       {
        struct memory_block *block;
        struct memory_block *prev = NULL;
 
        /* Do nothing unless running under Valgrind */
        if ( RUNNING_ON_VALGRIND <= 0 )
                return;
 
        /* Traverse free block list, marking each block structure as
         * inaccessible.  Some contortions are necessary to avoid
         * errors from list_check().
         */
 
        /* Mark each block in list as inaccessible */
        list_for_each_entry ( block, &heap->blocks, list ) {
 
                /* Mark previous block (if any) as inaccessible. (Current
                 * block will be accessed by list_check().)
                 */
                if ( prev )
                        VALGRIND_MAKE_MEM_NOACCESS ( prev, sizeof ( *prev ) );
                prev = block;
 
                /* At the end of the list, list_check() will end up
                 * accessing the first list item.  Temporarily mark
                 * this area as defined.
                 */
                VALGRIND_MAKE_MEM_DEFINED ( &heap->blocks.next->prev,
                                            sizeof ( heap->blocks.next->prev ));
        }
        /* Mark last block (if any) as inaccessible */
        if ( prev )
                VALGRIND_MAKE_MEM_NOACCESS ( prev, sizeof ( *prev ) );
 
        /* Mark as inaccessible the area that was temporarily marked
         * as defined to avoid errors from list_check().
         */
        VALGRIND_MAKE_MEM_NOACCESS ( &heap->blocks.next->prev,
                                     sizeof ( heap->blocks.next->prev ) );
 
        /* Mark block list itself as inaccessible */
        VALGRIND_MAKE_MEM_NOACCESS ( &heap->blocks, sizeof ( heap->blocks ) );
}

References block, heap::blocks, memory_block::list, list_for_each_entry, list_head::next, NULL, list_head::prev, RUNNING_ON_VALGRIND, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by heap_alloc_block(), and heap_free_block().

check_blocks()

void check_blocks ( struct heap * heap )

inlinestatic

Check integrity of the blocks in the free list.

Parameters

heap

Heap

Definition at line 237 of file malloc.c.

                                                      {
        struct memory_block *block;
        struct memory_block *prev = NULL;
 
        if ( ! ASSERTING )
                return;
 
        list_for_each_entry ( block, &heap->blocks, list ) {
 
                /* Check alignment */
                assert ( ( virt_to_phys ( block ) &
                           ( heap->align - 1 ) ) == 0 );
 
                /* Check that list structure is intact */
                list_check ( &block->list );
 
                /* Check that block size is not too small */
                assert ( block->size >= sizeof ( *block ) );
                assert ( block->size >= heap->align );
 
                /* Check that block does not wrap beyond end of address space */
                assert ( ( ( void * ) block + block->size ) >
                         ( ( void * ) block ) );
 
                /* Check that blocks remain in ascending order, and
                 * that adjacent blocks have been merged.
                 */
                if ( prev ) {
                        assert ( ( ( void * ) block ) > ( ( void * ) prev ) );
                        assert ( ( ( void * ) block ) >
                                 ( ( ( void * ) prev ) + prev->size ) );
                }
                prev = block;
        }
}

References heap::align, assert, ASSERTING, block, heap::blocks, memory_block::list, list_check, list_for_each_entry, and NULL.

Referenced by heap_alloc_block(), and heap_free_block().

discard_cache()

unsigned int discard_cache ( size_t size __unused )

static

Discard some cached data.

Parameters

size	Failed allocation size

Return values

discarded

Number of cached items discarded

Definition at line 279 of file malloc.c.

                                                           {
        struct cache_discarder *discarder;
        unsigned int discarded;
 
        for_each_table_entry ( discarder, CACHE_DISCARDERS ) {
                discarded = discarder->discard();
                if ( discarded )
                        return discarded;
        }
        return 0;
}

References __unused, CACHE_DISCARDERS, cache_discarder::discard, for_each_table_entry, and size.

Referenced by discard_all_cache().

discard_all_cache()

void discard_all_cache ( void )

static

Discard all cached data.

Definition at line 295 of file malloc.c.

                                       {
        unsigned int discarded;
 
        do {
                discarded = discard_cache ( 0 );
        } while ( discarded );
}

References discard_cache().

Referenced by shutdown_cache().

heap_alloc_block()

void * heap_alloc_block ( struct heap * heap, size_t size, size_t align, size_t offset )

static

Allocate a memory block.

Parameters

heap	Heap
size	Requested size
align	Physical alignment
offset	Offset from physical alignment

Return values

ptr	Memory block, or NULL

Allocates a memory block physically aligned as requested. No guarantees are provided for the alignment of the virtual address.

align must be a power of two. size may not be zero.

Definition at line 317 of file malloc.c.

                                                 {
        struct memory_block *block;
        size_t actual_offset;
        size_t align_mask;
        size_t actual_size;
        size_t pre_size;
        size_t post_size;
        struct memory_block *pre;
        struct memory_block *post;
        unsigned int grown;
        void *ptr;
 
        /* Sanity checks */
        valgrind_make_blocks_defined ( heap );
        check_blocks ( heap );
 
        /* Validate inputs */
        if ( ( size == 0 ) || ( align == 0 ) || ( align & ( align - 1 ) ) ) {
                /* This is unreachable from any of our callers and
                 * could instead be an assertion, but we perform a
                 * runtime check anyway to guard against future
                 * possible code changes.
                 */
                DBGC ( heap, "HEAP malformed allocation %#zx (aligned "
                       "%#zx+%#zx)\n", size, align, offset );
                ptr = NULL;
                goto done;
        }
 
        /* Limit offset to requested alignment */
        offset &= ( align - 1 );
 
        /* Calculate offset of memory block */
        actual_offset = ( offset & ~( heap->align - 1 ) );
        assert ( actual_offset <= offset );
 
        /* Calculate size of memory block and check for overflow */
        actual_size = ( ( size + offset - actual_offset + heap->align - 1 )
                        & ~( heap->align - 1 ) );
        if ( actual_size < size ) {
                ptr = NULL;
                goto done;
        }
 
        /* Calculate alignment mask */
        align_mask = ( ( align - 1 ) | ( heap->align - 1 ) );
 
        DBGC2 ( heap, "HEAP allocating %#zx (aligned %#zx+%#zx)\n",
                size, align, offset );
        while ( 1 ) {
                /* Search through blocks for the first one with enough space */
                list_for_each_entry ( block, &heap->blocks, list ) {
                        pre_size = ( ( actual_offset - virt_to_phys ( block ) )
                                     & align_mask );
                        if ( ( block->size < pre_size ) ||
                             ( ( block->size - pre_size ) < actual_size ) )
                                continue;
                        post_size = ( block->size - pre_size - actual_size );
                        /* Split block into pre-block, block, and
                         * post-block.  After this split, the "pre"
                         * block is the one currently linked into the
                         * free list.
                         */
                        pre   = block;
                        block = ( ( ( void * ) pre   ) + pre_size );
                        post  = ( ( ( void * ) block ) + actual_size );
                        DBGC2 ( heap, "HEAP splitting [%p,%p) -> [%p,%p) "
                                "+ [%p,%p)\n", pre,
                                ( ( ( void * ) pre ) + pre->size ), pre, block,
                                post, ( ( ( void * ) pre ) + pre->size ) );
                        /* If there is a "post" block, add it in to
                         * the free list.
                         */
                        if ( post_size ) {
                                assert ( post_size >= sizeof ( *block ) );
                                assert ( ( post_size &
                                           ( heap->align - 1 ) ) == 0 );
                                VALGRIND_MAKE_MEM_UNDEFINED ( post,
                                                              sizeof ( *post ));
                                post->size = post_size;
                                list_add ( &post->list, &pre->list );
                        }
                        /* Shrink "pre" block, leaving the main block
                         * isolated and no longer part of the free
                         * list.
                         */
                        pre->size = pre_size;
                        /* If there is no "pre" block, remove it from
                         * the list.
                         */
                        if ( ! pre_size ) {
                                list_del ( &pre->list );
                                VALGRIND_MAKE_MEM_NOACCESS ( pre,
                                                             sizeof ( *pre ) );
                        } else {
                                assert ( pre_size >= sizeof ( *block ) );
                                assert ( ( pre_size &
                                           ( heap->align - 1 ) ) == 0 );
                        }
                        /* Update memory usage statistics */
                        heap->freemem -= actual_size;
                        heap->usedmem += actual_size;
                        if ( heap->usedmem > heap->maxusedmem )
                                heap->maxusedmem = heap->usedmem;
                        /* Return allocated block */
                        ptr = ( ( ( void * ) block ) + offset - actual_offset );
                        DBGC2 ( heap, "HEAP allocated [%p,%p) within "
                                "[%p,%p)\n", ptr, ( ptr + size ), block,
                                ( ( ( void * ) block ) + actual_size ) );
                        VALGRIND_MAKE_MEM_UNDEFINED ( ptr, size );
                        goto done;
                }
 
                /* Attempt to grow heap to satisfy allocation */
                DBGC ( heap, "HEAP attempting to grow for %#zx (aligned "
                       "%#zx+%zx), used %zdkB\n", size, align, offset,
                       ( heap->usedmem >> 10 ) );
                valgrind_make_blocks_noaccess ( heap );
                grown = ( heap->grow ? heap->grow ( actual_size ) : 0 );
                valgrind_make_blocks_defined ( heap );
                check_blocks ( heap );
                if ( ! grown ) {
                        /* Heap did not grow: fail allocation */
                        DBGC ( heap, "HEAP failed to allocate %#zx (aligned "
                               "%#zx)\n", size, align );
                        ptr = NULL;
                        goto done;
                }
        }
 
 done:
        check_blocks ( heap );
        valgrind_make_blocks_noaccess ( heap );
        return ptr;
}

References heap::align, assert, block, heap::blocks, check_blocks(), DBGC, DBGC2, done, heap::freemem, heap::grow, memory_block::list, list_add, list_del, list_for_each_entry, heap::maxusedmem, NULL, offset, memory_block::size, size, heap::usedmem, valgrind_make_blocks_defined(), valgrind_make_blocks_noaccess(), VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by heap_realloc(), and malloc_phys_offset().

heap_free_block()

void heap_free_block ( struct heap * heap, void * ptr, size_t size )

static

Free a memory block.

Parameters

heap	Heap
ptr	Memory allocated by heap_alloc_block(), or NULL
size	Size of the memory

If ptr is NULL, no action is taken.

Definition at line 463 of file malloc.c.

                                                                          {
        struct memory_block *freeing;
        struct memory_block *block;
        struct memory_block *tmp;
        size_t sub_offset;
        size_t actual_size;
        ssize_t gap_before;
        ssize_t gap_after = -1;
 
        /* Allow for ptr==NULL */
        if ( ! ptr )
                return;
        VALGRIND_MAKE_MEM_NOACCESS ( ptr, size );
 
        /* Sanity checks */
        valgrind_make_blocks_defined ( heap );
        check_blocks ( heap );
 
        /* Round up to match actual block that heap_alloc_block() would
         * have allocated.
         */
        assert ( size != 0 );
        sub_offset = ( virt_to_phys ( ptr ) & ( heap->align - 1 ) );
        freeing = ( ptr - sub_offset );
        actual_size = ( ( size + sub_offset + heap->align - 1 ) &
                        ~( heap->align - 1 ) );
        DBGC2 ( heap, "HEAP freeing [%p,%p) within [%p,%p)\n",
                ptr, ( ptr + size ), freeing,
                ( ( ( void * ) freeing ) + actual_size ) );
        VALGRIND_MAKE_MEM_UNDEFINED ( freeing, sizeof ( *freeing ) );
 
        /* Check that this block does not overlap the free list */
        if ( ASSERTING ) {
                list_for_each_entry ( block, &heap->blocks, list ) {
                        if ( ( ( ( void * ) block ) <
                               ( ( void * ) freeing + actual_size ) ) &&
                             ( ( void * ) freeing <
                               ( ( void * ) block + block->size ) ) ) {
                                assert ( 0 );
                                DBGC ( heap, "HEAP double free of [%p,%p) "
                                       "overlapping [%p,%p) detected from %p\n",
                                       freeing,
                                       ( ( ( void * ) freeing ) + size ), block,
                                       ( ( void * ) block + block->size ),
                                       __builtin_return_address ( 0 ) );
                        }
                }
        }
 
        /* Insert/merge into free list */
        freeing->size = actual_size;
        list_for_each_entry_safe ( block, tmp, &heap->blocks, list ) {
                /* Calculate gaps before and after the "freeing" block */
                gap_before = ( ( ( void * ) freeing ) - 
                               ( ( ( void * ) block ) + block->size ) );
                gap_after = ( ( ( void * ) block ) - 
                              ( ( ( void * ) freeing ) + freeing->size ) );
                /* Merge with immediately preceding block, if possible */
                if ( gap_before == 0 ) {
                        DBGC2 ( heap, "HEAP merging [%p,%p) + [%p,%p) -> "
                                "[%p,%p)\n", block,
                                ( ( ( void * ) block ) + block->size ), freeing,
                                ( ( ( void * ) freeing ) + freeing->size ),
                                block,
                                ( ( ( void * ) freeing ) + freeing->size ) );
                        block->size += actual_size;
                        list_del ( &block->list );
                        VALGRIND_MAKE_MEM_NOACCESS ( freeing,
                                                     sizeof ( *freeing ) );
                        freeing = block;
                }
                /* Stop processing as soon as we reach a following block */
                if ( gap_after >= 0 )
                        break;
        }
 
        /* Insert before the immediately following block.  If
         * possible, merge the following block into the "freeing"
         * block.
         */
        DBGC2 ( heap, "HEAP freed [%p,%p)\n",
                freeing, ( ( ( void * ) freeing ) + freeing->size ) );
        list_add_tail ( &freeing->list, &block->list );
        if ( gap_after == 0 ) {
                DBGC2 ( heap, "HEAP merging [%p,%p) + [%p,%p) -> [%p,%p)\n",
                        freeing, ( ( ( void * ) freeing ) + freeing->size ),
                        block, ( ( ( void * ) block ) + block->size ), freeing,
                        ( ( ( void * ) block ) + block->size ) );
                freeing->size += block->size;
                list_del ( &block->list );
                VALGRIND_MAKE_MEM_NOACCESS ( block, sizeof ( *block ) );
        }
 
        /* Update memory usage statistics */
        heap->freemem += actual_size;
        heap->usedmem -= actual_size;
 
        /* Allow heap to shrink */
        if ( heap->shrink && heap->shrink ( freeing, freeing->size ) ) {
                list_del ( &freeing->list );
                heap->freemem -= freeing->size;
                VALGRIND_MAKE_MEM_UNDEFINED ( freeing, freeing->size );
        }
 
        /* Sanity checks */
        check_blocks ( heap );
        valgrind_make_blocks_noaccess ( heap );
}

References heap::align, assert, ASSERTING, block, heap::blocks, check_blocks(), DBGC, DBGC2, heap::freemem, memory_block::list, list_add_tail, list_del, list_for_each_entry, list_for_each_entry_safe, heap::shrink, memory_block::size, size, tmp, heap::usedmem, valgrind_make_blocks_defined(), valgrind_make_blocks_noaccess(), VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by free_phys(), heap_populate(), and heap_realloc().

heap_realloc()

void * heap_realloc	(	struct heap *	heap,
		void *	old_ptr,
		size_t	new_size )

Reallocate memory.

Parameters

heap	Heap
old_ptr	Memory previously allocated by heap_realloc(), or NULL
new_size	Requested size

Return values

new_ptr

Allocated memory, or NULL

Allocates memory with no particular alignment requirement. new_ptr will be aligned to at least a multiple of sizeof(void*). If old_ptr is non-NULL, then the contents of the newly allocated memory will be the same as the contents of the previously allocated memory, up to the minimum of the old and new sizes. The old memory will be freed.

If allocation fails the previously allocated block is left untouched and NULL is returned.

Calling heap_realloc() with a new size of zero is a valid way to free a memory block.

Definition at line 593 of file malloc.c.

                                                                          {
        struct autosized_block *old_block;
        struct autosized_block *new_block;
        size_t old_total_size;
        size_t new_total_size;
        size_t old_size;
        size_t offset = offsetof ( struct autosized_block, data );
        void *new_ptr = NOWHERE;
 
        /* Allocate new memory if necessary.  If allocation fails,
         * return without touching the old block.
         */
        if ( new_size ) {
                new_total_size = ( new_size + offset );
                if ( new_total_size < new_size )
                        return NULL;
                new_block = heap_alloc_block ( heap, new_total_size,
                                               heap->ptr_align, -offset );
                if ( ! new_block )
                        return NULL;
                new_block->size = new_total_size;
                VALGRIND_MAKE_MEM_NOACCESS ( &new_block->size,
                                             sizeof ( new_block->size ) );
                new_ptr = &new_block->data;
                VALGRIND_MALLOCLIKE_BLOCK ( new_ptr, new_size, 0, 0 );
                assert ( ( ( ( intptr_t ) new_ptr ) &
                           ( heap->ptr_align - 1 ) ) == 0 );
        }
 
        /* Copy across relevant part of the old data region (if any),
         * then free it.  Note that at this point either (a) new_ptr
         * is valid, or (b) new_size is 0; either way, the memcpy() is
         * valid.
         */
        if ( old_ptr && ( old_ptr != NOWHERE ) ) {
                old_block = container_of ( old_ptr, struct autosized_block,
                                           data );
                VALGRIND_MAKE_MEM_DEFINED ( &old_block->size,
                                            sizeof ( old_block->size ) );
                old_total_size = old_block->size;
                assert ( old_total_size != 0 );
                old_size = ( old_total_size - offset );
                memcpy ( new_ptr, old_ptr,
                         ( ( old_size < new_size ) ? old_size : new_size ) );
                VALGRIND_FREELIKE_BLOCK ( old_ptr, 0 );
                heap_free_block ( heap, old_block, old_total_size );
        }
 
        if ( ASSERTED ) {
                DBGC ( heap, "HEAP detected possible memory corruption "
                       "from %p\n", __builtin_return_address ( 0 ) );
        }
        return new_ptr;
}

References assert, ASSERTED, container_of, autosized_block::data, data, DBGC, heap_alloc_block(), heap_free_block(), memcpy(), NOWHERE, NULL, offset, offsetof, heap::ptr_align, autosized_block::size, VALGRIND_FREELIKE_BLOCK, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MALLOCLIKE_BLOCK.

Referenced by realloc(), and uheap_realloc().

realloc()

void * realloc	(	void *	old_ptr,
		size_t	new_size )

Reallocate memory.

Parameters

old_ptr	Memory previously allocated by malloc(), or NULL
new_size	Requested size

Return values

new_ptr

Allocated memory, or NULL

Definition at line 663 of file malloc.c.

                                                  {
 
        return heap_realloc ( &heap, old_ptr, new_size );
}

References heap_realloc().

Referenced by __attribute__(), asn1_grow(), bitmap_resize(), cachedhcp_record(), dhcpopt_init(), efi_ifr_op(), efi_ifr_string(), efivars_find(), free(), ibft_alloc_string(), ibft_install(), line_buffer(), malloc(), nvo_realloc(), process_script(), and xferbuf_malloc_realloc().

malloc()

void * malloc

(

size_t

size

)

Allocate memory.

Parameters

size	Requested size

Return values

ptr	Memory, or NULL

Allocates memory with no particular alignment requirement. ptr will be aligned to at least a multiple of sizeof(void*).

Definition at line 677 of file malloc.c.

                              {
        void *ptr;
 
        ptr = realloc ( NULL, size );
        if ( ASSERTED ) {
                DBGC ( &heap, "HEAP detected possible memory corruption "
                       "from %p\n", __builtin_return_address ( 0 ) );
        }
        return ptr;
}

References ASSERTED, DBGC, NULL, realloc(), and size.

Referenced by add_tls(), aes_unwrap(), aes_wrap(), alloc_iob_raw(), apply_dns_search(), ath5k_hw_rfregs_init(), chap_init(), datauri_open(), deflate_test_exec(), der_asn1(), derwin(), dhcpv6_rx(), dupwin(), eap_rx_mschapv2_request(), eap_tx_response(), ecdsa_alloc(), efi_block_label(), efi_boot_path(), efi_cacert_all(), efi_download_start(), efi_load_path(), efi_local_check_volume_name(), efi_local_len(), efi_locate_device(), efi_vasprintf(), efivars_fetch(), eisabus_probe(), exchange_okx(), fc_ulp_login(), fetch_setting_copy(), ffdhe(), format_uri_alloc(), http_format_ntlm_auth(), icert_encode(), int13_hook(), ipair_rx_pubkey(), ipoib_map_remac(), ipv4_add_miniroute(), isabus_probe(), isapnpbus_probe(), iscsi_handle_chap_c_value(), iscsi_handle_chap_r_value(), iscsi_rx_buffered_data(), iscsi_scsi_command(), jme_alloc_rx_resources(), jme_alloc_tx_resources(), lldp_rx(), loopback_test(), mcabus_probe(), memcpy_test_speed(), mlx_memory_alloc_priv(), net80211_probe_start(), net80211_register(), newwin(), nfs_uri_symlink(), ntlm_authenticate_okx(), ocsp_response(), ocsp_uri_string(), parse_kv(), parse_net_args(), pci_vpd_resize(), pcibus_probe(), peerblk_decrypt(), peerblk_parse_header(), pem_asn1(), rsa_alloc(), sandev_parse_iso9660(), slirp_timer_new(), storef_setting(), storen_setting(), strndup(), t509bus_probe(), tls_new_session_ticket(), tls_send_client_key_exchange_dhe(), uhci_enqueue(), usb_config_descriptor(), usb_get_string_descriptor(), usbio_config(), usbio_path(), vasprintf(), vesafb_mode_list(), vmbus_open(), wpa_make_rsn_ie(), wpa_start(), and zalloc().

free()

void free

(

void *

ptr

)

Free memory.

Parameters

ptr	Memory allocated by malloc(), or NULL

Memory allocated with malloc_phys() cannot be freed with free(); it must be freed with free_phys() instead.

If ptr is NULL, no action is taken.

Definition at line 698 of file malloc.c.

                        {
 
        realloc ( ptr, 0 );
        if ( ASSERTED ) {
                DBGC ( &heap, "HEAP detected possible memory corruption "
                       "from %p\n", __builtin_return_address ( 0 ) );
        }
}

References ASSERTED, DBGC, and realloc().

zalloc()

void * zalloc

(

size_t

size

)

Allocate cleared memory.

Parameters

size	Requested size

Return values

ptr	Allocated memory

Allocate memory as per malloc(), and zero it.

This function name is non-standard, but pretty intuitive. zalloc(size) is always equivalent to calloc(1,size)

Definition at line 718 of file malloc.c.

                              {
        void *data;
 
        data = malloc ( size );
        if ( data )
                memset ( data, 0, size );
        if ( ASSERTED ) {
                DBGC ( &heap, "HEAP detected possible memory corruption "
                       "from %p\n", __builtin_return_address ( 0 ) );
        }
        return data;
}

References ASSERTED, data, DBGC, malloc(), memset(), and size.

Referenced by add_dynui_item(), add_parameter(), alloc_form(), alloc_gpios(), alloc_ibdev(), alloc_image(), alloc_netdev(), alloc_pixbuf(), alloc_sandev(), alloc_uart(), alloc_usb(), alloc_usb_bus(), alloc_usb_hub(), aoecmd_create(), aoedev_open(), ar9300_eeprom_restore_internal(), arbel_alloc(), arbel_create_cq(), arbel_create_qp(), ata_open(), atadev_command(), ath5k_hw_attach(), ath5k_probe(), ath9k_init_softc(), ath_descdma_setup(), atl1e_setup_ring_resources(), autovivify_child_settings(), blob_open(), block_translate(), cachedhcp_record(), calloc(), cms_message(), cms_parse_participants(), concat_args(), cpio_okx(), create_downloader(), create_dynui(), create_parameters(), create_pinger(), create_validator(), dhcp_deliver(), dhcpv6_register(), dns_resolv(), dt_probe_node(), dwgpio_group_probe(), dwusb_probe(), efi_block_exec(), efi_block_install(), efi_cmdline_init(), efi_fcp_path(), efi_file_open_image(), efi_ib_srp_path(), efi_image_filepath(), efi_image_uripath(), efi_iscsi_path(), efi_local_open(), efi_netdev_path(), efi_path_uri(), efi_paths(), efi_pxe_install(), efi_snp_hii_fetch(), efi_snp_hii_install(), efi_snp_hii_process(), efi_snp_hii_store(), efi_snp_probe(), efi_uri_path(), efi_usb_install(), efi_usb_open(), efi_usb_path(), efi_usb_probe(), efidev_alloc(), efipci_start(), efivars_find(), ehci_endpoint_open(), ehci_probe(), ehci_ring_alloc(), eoib_create_peer(), exanic_probe(), fc_els_create(), fc_ns_query(), fc_peer_create(), fc_port_open(), fc_ulp_create(), fc_xchg_create(), fcpdev_open(), fcpdev_scsi_command(), fetch_string_setting_copy_alloc(), fetchf_setting_copy(), flexboot_nodnic_create_cq(), flexboot_nodnic_create_qp(), flexboot_nodnic_eth_open(), flexboot_nodnic_probe(), fragment_reassemble(), ftp_open(), generic_settings_store(), golan_alloc(), golan_create_cq(), golan_create_qp_aux(), guestinfo_fetch_type(), hermon_alloc(), hermon_create_cq(), hermon_create_qp(), http_connect(), http_open(), http_open_uri(), hub_probe(), hv_probe(), hvm_probe(), ib_cmrc_open(), ib_create_conn(), ib_create_cq(), ib_create_madx(), ib_create_mi(), ib_create_path(), ib_create_qp(), ib_mcast_attach(), ib_srp_open(), ibft_install(), icert_certs(), imux_probe(), init_mlx_utils(), ipair_create(), ipv6_add_miniroute(), iscsi_open(), linda_create_send_wq(), mlx_memory_zalloc_priv(), ndp_register_settings(), neighbour_create(), net80211_handle_mgmt(), net80211_prepare_assoc(), net80211_probe_start(), net80211_probe_step(), net80211_step_associate(), nfs_open(), nii_map(), numeric_resolv(), ocsp_check(), ocsp_uri_string(), open(), parse_uri(), pcibridge_probe(), peerblk_open(), peerdisc_create(), peerdisc_discovered(), peermux_filter(), ping_open(), png_pixbuf(), pxe_menu_parse(), qib7322_create_send_bufs(), qib7322_create_send_wq(), qib7322_probe(), rc80211_init(), resolv(), resolv_setting(), rtl818x_probe(), scsi_open(), scsidev_command(), sec80211_install(), sis190_mii_probe(), skge_probe(), skge_ring_alloc(), sky2_probe(), sky2_up(), slam_open(), srp_open(), srpdev_scsi_command(), start_dhcp(), start_dhcpv6(), start_ipv6conf(), start_ntp(), start_pxebs(), tcp_open(), tftp_core_open(), tg3_alloc_consistent(), tls_agree_ephemeral(), tls_session(), tls_set_cipher(), tls_set_digest(), txnic_bgx_probe(), txnic_pf_probe(), ucode_exec(), udp_open_common(), uhci_endpoint_open(), uhci_probe(), undipci_probe(), undirom_probe(), uri_dup(), usb_probe_all(), usbblk_probe(), usbio_endpoint_open(), usbio_interfaces(), usbio_interrupt_open(), usbio_start(), usbkbd_probe(), validator_start_download(), vmbus_probe(), vmbus_probe_channels(), vxge_hw_device_initialize(), x509_alloc_chain(), x509_append(), x509_certificate(), xcm_create(), xenbus_probe_device(), xenstore_response(), xfer_open_named_socket(), xhci_bus_open(), xhci_device_open(), xhci_endpoint_open(), xhci_probe(), xhci_ring_alloc(), xsigo_ib_probe(), xve_create(), and zlib_deflate().

zfree()

void zfree

(

void *

ptr

)

Clear and free memory.

Parameters

ptr	Memory allocated by malloc(), or NULL

If ptr is NULL, no action is taken.

Definition at line 738 of file malloc.c.

                         {
        struct autosized_block *block;
 
        if ( ptr && ( ptr != NOWHERE ) ) {
                block = container_of ( ptr, struct autosized_block, data );
                VALGRIND_MAKE_MEM_DEFINED ( &block->size,
                                            sizeof ( block->size ) );
                assert ( block->size >= sizeof ( *block ) );
                memset ( ptr, 0, ( block->size - sizeof ( *block ) ) );
                VALGRIND_MAKE_MEM_NOACCESS ( &block->size,
                                             sizeof ( block->size ) );
        }
        free ( ptr );
        if ( ASSERTED ) {
                DBGC ( &heap, "HEAP detected possible memory corruption "
                       "from %p\n", __builtin_return_address ( 0 ) );
        }
}

References assert, ASSERTED, block, container_of, data, DBGC, free, memset(), NOWHERE, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by aes_unwrap(), aes_wrap(), asn1_grow(), chap_finish(), cms_cipher_key(), ecdsa_free(), ffdhe(), free_tls(), free_tls_session(), privkey_apply_settings(), privkey_free(), rsa_free(), tls_agree_ephemeral(), tls_clear_cipher(), tls_clear_digest(), tls_new_finished(), tls_new_session_ticket(), tls_send_certificate_verify(), tls_send_client_key_exchange_dhe(), and tls_send_client_key_exchange_pubkey().

malloc_phys_offset()

void * malloc_phys_offset	(	size_t	size,
		size_t	phys_align,
		size_t	offset )

Allocate memory with specified physical alignment and offset.

Parameters

size	Requested size
align	Physical alignment
offset	Offset from physical alignment

Return values

ptr	Memory, or NULL

align must be a power of two. size may not be zero.

Definition at line 767 of file malloc.c.

                                                                            {
        void * ptr;
 
        assert ( phys_align != 0 );
        ptr = heap_alloc_block ( &heap, size, phys_align, offset );
        if ( ptr && size ) {
                assert ( ( ( virt_to_phys ( ptr ) ^ offset ) &
                           ( phys_align - 1 ) ) == 0 );
                VALGRIND_MALLOCLIKE_BLOCK ( ptr, size, 0, 0 );
        }
        return ptr;
}

References assert, heap_alloc_block(), offset, size, and VALGRIND_MALLOCLIKE_BLOCK.

Referenced by alloc_iob_raw(), and malloc_phys().

malloc_phys()

void * malloc_phys	(	size_t	size,
		size_t	phys_align )

Allocate memory with specified physical alignment.

Parameters

size	Requested size
align	Physical alignment

Return values

ptr	Memory, or NULL

align must be a power of two. size may not be zero.

Definition at line 789 of file malloc.c.

                                                      {
 
        return malloc_phys_offset ( size, phys_align, 0 );
}

References malloc_phys_offset(), and size.

Referenced by __vxge_hw_fifo_create(), __vxge_hw_ring_create(), a3c90x_setup_rx_ring(), a3c90x_setup_tx_ring(), arbel_alloc(), arbel_alloc_icm(), arbel_create_cq(), arbel_create_eq(), arbel_create_recv_wq(), arbel_create_send_wq(), ath5k_desc_alloc(), ath_descdma_setup(), atl1e_setup_ring_resources(), b44_init_rx_ring(), b44_init_tx_ring(), efx_hunt_alloc_special_buffer(), ehci_bus_open(), ehci_ring_alloc(), ena_create_admin(), ena_create_async(), ena_create_cq(), ena_create_sq(), ena_probe(), exanic_probe(), falcon_alloc_special_buffer(), golan_cmd_init(), golan_create_cq(), golan_create_eq(), golan_create_qp_aux(), hermon_alloc(), hermon_create_cq(), hermon_create_eq(), hermon_create_qp(), hv_alloc_message(), hv_alloc_pages(), hvm_map_hypercall(), icplus_create_ring(), ifec_net_open(), ifec_tx_setup(), igbvf_setup_rx_resources(), igbvf_setup_tx_resources(), jme_alloc_rx_resources(), jme_alloc_tx_resources(), legacy_probe(), linda_create_recv_wq(), linda_init_send(), mlx_memory_alloc_dma_priv(), myri10ge_net_open(), myson_create_ring(), natsemi_create_ring(), netfront_create_ring(), nv_init_rings(), pcnet32_setup_rx_resources(), pcnet32_setup_tx_resources(), phantom_create_rx_ctx(), phantom_create_tx_ctx(), phantom_open(), qib7322_create_recv_wq(), qib7322_init_send(), rhine_create_ring(), rtl818x_init_rx_ring(), rtl818x_init_tx_ring(), sis190_open(), skge_up(), sky2_probe(), sky2_up(), uhci_bus_open(), uhci_enqueue(), uhci_ring_alloc(), velocity_alloc_rings(), vmbus_open(), and vmxnet3_open().

free_phys()

void free_phys	(	void *	ptr,
		size_t	size )

Free memory allocated with malloc_phys().

Parameters

ptr	Memory allocated by malloc_phys(), or NULL
size	Size of memory, as passed to malloc_phys()

Memory allocated with malloc_phys() can only be freed with free_phys(); it cannot be freed with the standard free().

If ptr is NULL, no action is taken.

Definition at line 805 of file malloc.c.

                                          {
 
        VALGRIND_FREELIKE_BLOCK ( ptr, 0 );
        heap_free_block ( &heap, ptr, size );
}

References heap_free_block(), size, and VALGRIND_FREELIKE_BLOCK.

Referenced by __vxge_hw_fifo_delete(), __vxge_hw_ring_delete(), a3c90x_free_rx_ring(), a3c90x_free_tx_ring(), alloc_iob_raw(), arbel_alloc(), arbel_alloc_icm(), arbel_create_cq(), arbel_create_eq(), arbel_create_qp(), arbel_create_recv_wq(), arbel_destroy_cq(), arbel_destroy_eq(), arbel_destroy_qp(), arbel_free(), arbel_free_icm(), ath5k_desc_alloc(), ath5k_desc_free(), ath_descdma_cleanup(), ath_descdma_setup(), atl1e_free_ring_resources(), b44_free_rx_ring(), b44_free_tx_ring(), b44_init_rx_ring(), b44_init_tx_ring(), efx_hunt_free_special_buffer(), ehci_bus_close(), ehci_bus_open(), ehci_ring_alloc(), ehci_ring_free(), ena_create_admin(), ena_create_async(), ena_create_cq(), ena_create_sq(), ena_destroy_admin(), ena_destroy_async(), ena_destroy_cq(), ena_destroy_sq(), ena_probe(), ena_remove(), exanic_probe(), exanic_remove(), falcon_free_special_buffer(), free_iob(), golan_cmd_init(), golan_cmd_uninit(), golan_create_cq(), golan_create_eq(), golan_create_qp_aux(), golan_destory_eq(), golan_destroy_cq(), golan_destroy_qp(), hermon_alloc(), hermon_create_cq(), hermon_create_eq(), hermon_create_qp(), hermon_destroy_cq(), hermon_destroy_eq(), hermon_destroy_qp(), hermon_free(), hv_alloc_pages(), hv_free_message(), hv_free_pages(), hvm_unmap_hypercall(), icplus_create_ring(), icplus_destroy_ring(), ifec_free(), ifec_net_open(), igbvf_free_rx_resources(), igbvf_free_tx_resources(), jme_free_rx_resources(), jme_free_tx_resources(), legacy_probe(), legacy_remove(), linda_create_recv_wq(), linda_destroy_recv_wq(), linda_fini_send(), linda_init_send(), mlx_memory_free_dma_priv(), myri10ge_net_close(), myri10ge_net_open(), myson_create_ring(), myson_destroy_ring(), natsemi_create_ring(), natsemi_destroy_ring(), netfront_create_ring(), netfront_destroy_ring(), nv_free_rxtx_resources(), pcnet32_free_rx_resources(), pcnet32_free_tx_resources(), phantom_close(), phantom_create_rx_ctx(), phantom_create_tx_ctx(), phantom_open(), qib7322_create_recv_wq(), qib7322_destroy_recv_wq(), qib7322_fini_send(), qib7322_init_send(), rhine_destroy_ring(), rtl818x_free_rx_ring(), rtl818x_free_tx_ring(), sis190_free(), skge_free(), sky2_free_rings(), sky2_probe(), sky2_remove(), uhci_bus_close(), uhci_bus_open(), uhci_dequeue(), uhci_enqueue(), uhci_ring_alloc(), uhci_ring_free(), velocity_alloc_rings(), velocity_close(), vmbus_close(), vmbus_open(), vmxnet3_close(), and vmxnet3_open().

heap_populate()

void heap_populate	(	struct heap *	heap,
		void *	start,
		size_t	len )

Add memory to allocation pool.

Parameters

heap	Heap
start	Start address
len	Length of memory

Adds a block of memory to the allocation pool. The memory must be aligned to the heap's required free memory block alignment.

Definition at line 821 of file malloc.c.

                                                                  {
 
        /* Sanity checks */
        assert ( ( virt_to_phys ( start ) & ( heap->align - 1 ) ) == 0 );
        assert ( ( len & ( heap->align - 1 ) ) == 0 );
 
        /* Add to allocation pool */
        heap_free_block ( heap, start, len );
 
        /* Fix up memory usage statistics */
        heap->usedmem += len;
}

References heap::align, assert, heap_free_block(), len, start, and heap::usedmem.

Referenced by init_heap(), and uheap_grow().

init_heap()

void init_heap ( void )

static

Initialise the heap.

Definition at line 838 of file malloc.c.

                               {
 
        /* Sanity check */
        build_assert ( MIN_MEMBLOCK_ALIGN >= sizeof ( struct memory_block ) );
 
        /* Populate heap */
        VALGRIND_MAKE_MEM_NOACCESS ( heap_area, sizeof ( heap_area ) );
        VALGRIND_MAKE_MEM_NOACCESS ( &heap.blocks, sizeof ( heap.blocks ) );
        heap_populate ( &heap, heap_area, sizeof ( heap_area ) );
}

References heap::blocks, build_assert, heap_area, heap_populate(), MIN_MEMBLOCK_ALIGN, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by __init_fn().

__init_fn()

struct init_fn heap_init_fn __init_fn

(

INIT_EARLY

)

Memory allocator initialisation function.

References __init_fn, INIT_EARLY, and init_heap().

shutdown_cache()

void shutdown_cache ( int booting __unused )

static

Discard all cached data on shutdown.

Definition at line 859 of file malloc.c.

                                                    {
        discard_all_cache();
        DBGC ( &heap, "HEAP maximum usage %zdkB\n",
               ( heap.maxusedmem >> 10 ) );
}

References __unused, DBGC, discard_all_cache(), and heap::maxusedmem.

Referenced by __startup_fn().

__startup_fn()

struct startup_fn heap_startup_fn __startup_fn

(

STARTUP_EARLY

)

Memory allocator shutdown function.

References __startup_fn, shutdown_cache(), and STARTUP_EARLY.

heap_dump()

void heap_dump

(

struct heap *

heap

)

Dump free block list (for debugging).

Definition at line 875 of file malloc.c.

                                     {
        struct memory_block *block;
 
        dbg_printf ( "HEAP free block list:\n" );
        list_for_each_entry ( block, &heap->blocks, list ) {
                dbg_printf ( "...[%p,%p] (size %#zx)\n", block,
                             ( ( ( void * ) block ) + block->size ),
                             block->size );
        }
}

References block, heap::blocks, dbg_printf(), memory_block::list, and list_for_each_entry.

Variable Documentation

heap_area

char heap_area[HEAP_SIZE]

static

The heap area.

Definition at line 139 of file malloc.c.

Referenced by init_heap().

heap

struct heap heap

static

Initial value:

                 = {
        .blocks = LIST_HEAD_INIT ( heap.blocks ),
        .align = MIN_MEMBLOCK_ALIGN,
        .ptr_align = sizeof ( void * ),
        .grow = discard_cache,
}

The global heap.

Definition at line 649 of file malloc.c.

                        {
        .blocks = LIST_HEAD_INIT ( heap.blocks ),
        .align = MIN_MEMBLOCK_ALIGN,
        .ptr_align = sizeof ( void * ),
        .grow = discard_cache,
};