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. More...
#define	HEAP_SIZE   ( 4096 * 1024 )
	Heap area size. More...
#define	HEAP_ALIGN   MIN_MEMBLOCK_ALIGN
	Heap area alignment. More...

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

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

Detailed Description

Dynamic memory allocation.

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 67 of file malloc.c.

HEAP_SIZE

#define HEAP_SIZE   ( 4096 * 1024 )

Heap area size.

Currently fixed at 4MB.

Definition at line 82 of file malloc.c.

HEAP_ALIGN

#define HEAP_ALIGN   MIN_MEMBLOCK_ALIGN

Heap area alignment.

Definition at line 85 of file malloc.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

valgrind_make_blocks_defined()

static void valgrind_make_blocks_defined ( struct heap *  heap )

inlinestatic

Mark all blocks in free list as defined.

Parameters

heap

Heap

Definition at line 95 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()

static void valgrind_make_blocks_noaccess ( struct heap *  heap )

inlinestatic

Mark all blocks in free list as inaccessible.

Parameters

heap

Heap

Definition at line 137 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()

static void check_blocks ( struct heap *  heap )

inlinestatic

Check integrity of the blocks in the free list.

Parameters

heap

Heap

Definition at line 186 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()

static 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 228 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 CACHE_DISCARDERS, cache_discarder::discard, and for_each_table_entry.

Referenced by discard_all_cache().

discard_all_cache()

static void discard_all_cache ( void  )

static

Discard all cached data.

Definition at line 244 of file malloc.c.

                                       {
        unsigned int discarded;

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

References discard_cache().

Referenced by shutdown_cache().

heap_alloc_block()

static 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 266 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 */
        assert ( size != 0 );
        assert ( ( align == 0 ) || ( ( align & ( align - 1 ) ) == 0 ) );
        valgrind_make_blocks_defined ( heap );
        check_blocks ( heap );

        /* Limit offset to requested alignment */
        offset &= ( align ? ( align - 1 ) : 0 );

        /* Calculate offset of memory block */
        actual_offset = ( offset & ~( heap->align - 1 ) );
        assert ( actual_offset <= offset );

        /* Calculate size of memory block */
        actual_size = ( ( size + offset - actual_offset + heap->align - 1 )
                        & ~( heap->align - 1 ) );
        if ( ! actual_size ) {
                /* The requested size is not permitted to be zero.  A
                 * zero result at this point indicates that either the
                 * original requested size was zero, or that unsigned
                 * integer overflow has occurred.
                 */
                ptr = NULL;
                goto done;
        }
        assert ( actual_size >= size );

        /* 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, size, memory_block::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()

static 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 407 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, 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 537 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, data, autosized_block::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 607 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 621 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(), deflate_test_exec(), der_asn1(), derwin(), dhcpv6_rx(), dhe_key(), dupwin(), eap_rx_mschapv2_request(), eap_tx_response(), ecdsa_alloc(), efi_block_label(), efi_boot_path(), efi_cacert_all(), efi_cmdline_init(), efi_download_start(), efi_load_path(), efi_local_check_volume_name(), efi_local_len(), efi_locate_device(), efi_vasprintf(), efivars_fetch(), eisabus_probe(), fc_ulp_login(), fetch_setting_copy(), 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(), storef_setting(), storen_setting(), strndup(), t509bus_probe(), tls_new_server_key_exchange(), tls_new_session_ticket(), tls_select_handshake(), 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 642 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 662 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(), 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_fcp_path(), efi_file_open_image(), efi_ib_srp_path(), efi_image_path(), 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(), hw_open(), 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_session(), tls_set_cipher(), 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(), virtnet_open_legacy(), virtnet_open_modern(), 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().

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 685 of file malloc.c.

                                                                            {
        void * ptr;

        ptr = heap_alloc_block ( &heap, size, phys_align, offset );
        if ( ptr && size ) {
                assert ( ( phys_align == 0 ) ||
                         ( ( ( 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 707 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(), tg3_alloc_consistent(), tg3_test_dma(), 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 723 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(), tg3_free_consistent(), tg3_rx_prodring_fini(), tg3_test_dma(), 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 739 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()

static void init_heap ( void  )

static

Initialise the heap.

Definition at line 756 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.

__init_fn()

struct init_fn heap_init_fn __init_fn

(

INIT_EARLY

)

Memory allocator initialisation function.

shutdown_cache()

static void shutdown_cache ( int booting  __unused )

static

Discard all cached data on shutdown.

Definition at line 777 of file malloc.c.

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

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

__startup_fn()

struct startup_fn heap_startup_fn __startup_fn

(

STARTUP_EARLY

)

Memory allocator shutdown function.

heap_dump()

void heap_dump

(

struct heap *

heap

)

Dump free block list (for debugging)

Definition at line 793 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 88 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 593 of file malloc.c.