malloc.c File Reference

Dynamic memory allocation. More...

#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <strings.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	MEMBLOCK_ALIGN   ( ( size_t ) ( 1 << ( fls ( sizeof ( struct memory_block ) - 1 ) ) ) )
	Physical address alignment maintained for free blocks of memory. More...
#define	NOWHERE   ( ( void * ) ~( ( intptr_t ) 0 ) )
	Address for zero-length memory blocks. More...
#define	HEAP_SIZE   ( 512 * 1024 )
	Heap size. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static	LIST_HEAD (free_blocks)
	List of free memory blocks. More...
static void	valgrind_make_blocks_defined (void)
	Mark all blocks in free list as defined. More...
static void	valgrind_make_blocks_noaccess (void)
	Mark all blocks in free list as inaccessible. More...
static void	check_blocks (void)
	Check integrity of the blocks in the free list. More...
static unsigned int	discard_cache (void)
	Discard some cached data. More...
static void	discard_all_cache (void)
	Discard all cached data. More...
void *	alloc_memblock (size_t size, size_t align, size_t offset)
	Allocate a memory block. More...
void	free_memblock (void *ptr, size_t size)
	Free a memory block. 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...
static void	mpopulate (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	mdumpfree (void)
	Dump free block list (for debugging) More...

Variables
size_t	freemem
	Total amount of free memory. More...
size_t	usedmem
	Total amount of used memory. More...
size_t	maxusedmem
	Maximum amount of used memory. More...
static char	heap [HEAP_SIZE]
	The heap itself. More...

Detailed Description

Dynamic memory allocation.

Definition in file malloc.c.

Macro Definition Documentation

MEMBLOCK_ALIGN

#define MEMBLOCK_ALIGN   ( ( size_t ) ( 1 << ( fls ( sizeof ( struct memory_block ) - 1 ) ) ) )

Physical address alignment maintained for free blocks of memory.

Definition at line 63 of file malloc.c.

NOWHERE

#define NOWHERE   ( ( void * ) ~( ( intptr_t ) 0 ) )

Address for zero-length memory blocks.

malloc(0) or realloc(ptr,0) will return the special value NOWHERE. Calling free(NOWHERE) will have no effect.

This is consistent with the ANSI C standards, which state that "either NULL or a pointer suitable to be passed to free()" must be returned in these cases. Using a special non-NULL value means that the caller can take a NULL return value to indicate failure, without first having to check for a requested size of zero.

Code outside of malloc.c do not ever need to refer to the actual value of NOWHERE; this is an internal definition.

Definition at line 89 of file malloc.c.

HEAP_SIZE

#define HEAP_SIZE   ( 512 * 1024 )

Heap size.

Currently fixed at 512kB.

Definition at line 108 of file malloc.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

LIST_HEAD()

static LIST_HEAD ( free_blocks  )

static

List of free memory blocks.

valgrind_make_blocks_defined()

static void valgrind_make_blocks_defined ( void  )

inlinestatic

Mark all blocks in free list as defined.

Definition at line 117 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 ( &free_blocks, sizeof ( free_blocks ) );

        /* Mark areas accessed by list_check() as defined */
        VALGRIND_MAKE_MEM_DEFINED ( &free_blocks.prev->next,
                                    sizeof ( free_blocks.prev->next ) );
        VALGRIND_MAKE_MEM_DEFINED ( free_blocks.next,
                                    sizeof ( *free_blocks.next ) );
        VALGRIND_MAKE_MEM_DEFINED ( &free_blocks.next->next->prev,
                                    sizeof ( free_blocks.next->next->prev ) );

        /* Mark each block in list as defined */
        list_for_each_entry ( block, &free_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, memory_block::list, list_for_each_entry, RUNNING_ON_VALGRIND, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by alloc_memblock(), and free_memblock().

valgrind_make_blocks_noaccess()

static void valgrind_make_blocks_noaccess ( void  )

inlinestatic

Mark all blocks in free list as inaccessible.

Definition at line 158 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, &free_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 ( &free_blocks.next->prev,
                                            sizeof ( free_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 ( &free_blocks.next->prev,
                                     sizeof ( free_blocks.next->prev ) );

        /* Mark block list itself as inaccessible */
        VALGRIND_MAKE_MEM_NOACCESS ( &free_blocks, sizeof ( free_blocks ) );
}

References block, memory_block::list, list_for_each_entry, NULL, RUNNING_ON_VALGRIND, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by alloc_memblock(), and free_memblock().

check_blocks()

static void check_blocks ( void  )

inlinestatic

Check integrity of the blocks in the free list.

Definition at line 206 of file malloc.c.

                                         {
        struct memory_block *block;
        struct memory_block *prev = NULL;

        if ( ! ASSERTING )
                return;

        list_for_each_entry ( block, &free_blocks, list ) {

                /* Check alignment */
                assert ( ( virt_to_phys ( block ) &
                           ( MEMBLOCK_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 >= MEMBLOCK_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 assert(), ASSERTING, block, memory_block::list, list_check, list_for_each_entry, MEMBLOCK_ALIGN, NULL, and virt_to_phys().

Referenced by alloc_memblock(), and free_memblock().

discard_cache()

static unsigned int discard_cache ( void  )

static

Discard some cached data.

Return values

discarded

Number of cached items discarded

Definition at line 247 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 alloc_memblock(), and discard_all_cache().

discard_all_cache()

static void discard_all_cache ( void  )

static

Discard all cached data.

Definition at line 263 of file malloc.c.

                                       {
        unsigned int discarded;

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

References discard_cache().

Referenced by shutdown_cache().

alloc_memblock()

void* alloc_memblock	(	size_t	size,
		size_t	align,
		size_t	offset
	)

Allocate a memory block.

Parameters

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 284 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 discarded;
        void *ptr;

        /* Sanity checks */
        assert ( size != 0 );
        assert ( ( align == 0 ) || ( ( align & ( align - 1 ) ) == 0 ) );
        valgrind_make_blocks_defined();
        check_blocks();

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

        /* Calculate size of memory block */
        actual_size = ( ( size + offset - actual_offset + MEMBLOCK_ALIGN - 1 )
                        & ~( MEMBLOCK_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 ) | ( MEMBLOCK_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, &free_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 >= MEMBLOCK_ALIGN );
                                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 >= MEMBLOCK_ALIGN );
                        }
                        /* Update memory usage statistics */
                        freemem -= actual_size;
                        usedmem += actual_size;
                        if ( usedmem > maxusedmem )
                                maxusedmem = 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;
                }

                /* Try discarding some cached data to free up memory */
                DBGC ( &heap, "HEAP attempting discard for %#zx (aligned "
                       "%#zx+%zx), used %zdkB\n", size, align, offset,
                       ( usedmem >> 10 ) );
                valgrind_make_blocks_noaccess();
                discarded = discard_cache();
                valgrind_make_blocks_defined();
                check_blocks();
                if ( ! discarded ) {
                        /* Nothing available to discard */
                        DBGC ( &heap, "HEAP failed to allocate %#zx (aligned "
                               "%#zx)\n", size, align );
                        ptr = NULL;
                        goto done;
                }
        }

 done:
        check_blocks();
        valgrind_make_blocks_noaccess();
        return ptr;
}

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

Referenced by malloc_phys_offset(), and realloc().

free_memblock()

void free_memblock	(	void *	ptr,
		size_t	size
	)

Free a memory block.

Parameters

ptr	Memory allocated by alloc_memblock(), or NULL
size	Size of the memory

If ptr is NULL, no action is taken.

Definition at line 416 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();
        check_blocks();

        /* Round up to match actual block that alloc_memblock() would
         * have allocated.
         */
        assert ( size != 0 );
        sub_offset = ( virt_to_phys ( ptr ) & ( MEMBLOCK_ALIGN - 1) );
        freeing = ( ptr - sub_offset );
        actual_size = ( ( size + sub_offset + MEMBLOCK_ALIGN - 1 ) &
                        ~( MEMBLOCK_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, &free_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, &free_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 */
        freemem += actual_size;
        usedmem -= actual_size;

        check_blocks();
        valgrind_make_blocks_noaccess();
}

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

Referenced by free_phys(), mpopulate(), and 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

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 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;
        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 +
                                   offsetof ( struct autosized_block, data ) );
                if ( new_total_size < new_size )
                        return NULL;
                new_block = alloc_memblock ( new_total_size, 1, 0 );
                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 );
        }

        /* 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 -
                             offsetof ( struct autosized_block, data ) );
                memcpy ( new_ptr, old_ptr,
                         ( ( old_size < new_size ) ? old_size : new_size ) );
                VALGRIND_FREELIKE_BLOCK ( old_ptr, 0 );
                free_memblock ( 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 alloc_memblock(), assert(), ASSERTED, container_of, data, autosized_block::data, DBGC, free_memblock(), heap, memcpy(), NOWHERE, NULL, offsetof, autosized_block::size, VALGRIND_FREELIKE_BLOCK, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MALLOCLIKE_BLOCK.

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 599 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, heap, NULL, realloc(), and size.

Referenced by add_ipv4_miniroute(), add_tls(), aes_unwrap(), aes_wrap(), alloc_iob_raw(), apply_dns_search(), ath5k_hw_rfregs_init(), chap_init(), cmdline_init(), cms_decrypt(), deflate_test_exec(), der_asn1(), derwin(), dhcpv6_rx(), dhe_key(), dupwin(), eap_rx_mschapv2_request(), eap_tx_response(), efi_block_label(), efi_cmdline_init(), efi_download_start(), 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(), 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(), tls_send_plaintext(), 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 620 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, heap, 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 640 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, heap, malloc(), memset(), and size.

Referenced by add_dynui_item(), add_parameter(), alloc_form(), alloc_ibdev(), alloc_image(), alloc_netdev(), alloc_pixbuf(), alloc_sandev(), 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(), create_downloader(), create_dynui(), create_parameters(), create_pinger(), create_validator(), dhcp_deliver(), dhcpv6_register(), dns_resolv(), 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_send_certificate(), 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().

mpopulate()

static void mpopulate ( void *  start, size_t  len  )

static

Add memory to allocation pool.

Parameters

start	Start address
len	Length of memory

Adds a block of memory to the allocation pool. This is a one-way operation; there is no way to reclaim this memory.

Definition at line 662 of file malloc.c.

                                                  {
        size_t skip;

        /* Align start of block */
        skip = ( ( -virt_to_phys ( start ) ) & ( MEMBLOCK_ALIGN - 1 ) );
        if ( skip > len )
                return;
        start += skip;
        len -= skip;

        /* Align end of block */
        len &= ~( MEMBLOCK_ALIGN - 1 );
        if ( ! len )
                return;

        /* Add to allocation pool */
        free_memblock ( start, len );

        /* Fix up memory usage statistics */
        usedmem += len;
}

References free_memblock(), len, MEMBLOCK_ALIGN, start, usedmem, and virt_to_phys().

Referenced by init_heap().

init_heap()

static void init_heap ( void  )

static

Initialise the heap.

Definition at line 688 of file malloc.c.

                               {
        VALGRIND_MAKE_MEM_NOACCESS ( heap, sizeof ( heap ) );
        VALGRIND_MAKE_MEM_NOACCESS ( &free_blocks, sizeof ( free_blocks ) );
        mpopulate ( heap, sizeof ( heap ) );
}

References heap, mpopulate(), 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 703 of file malloc.c.

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

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

__startup_fn()

struct startup_fn heap_startup_fn __startup_fn

(

STARTUP_EARLY

)

Memory allocator shutdown function.

mdumpfree()

void mdumpfree

(

void

)

Dump free block list (for debugging)

Definition at line 718 of file malloc.c.

                        {
        struct memory_block *block;

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

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

Variable Documentation

freemem

size_t freemem

Total amount of free memory.

Definition at line 95 of file malloc.c.

Referenced by alloc_memblock(), and free_memblock().

usedmem

size_t usedmem

Total amount of used memory.

Definition at line 98 of file malloc.c.

Referenced by alloc_memblock(), free_memblock(), and mpopulate().

maxusedmem

size_t maxusedmem

Maximum amount of used memory.

Definition at line 101 of file malloc.c.

Referenced by alloc_memblock(), and shutdown_cache().

heap

char heap[HEAP_SIZE]

static

The heap itself.

Definition at line 111 of file malloc.c.

Referenced by alloc_memblock(), free(), free_memblock(), init_heap(), malloc(), realloc(), shutdown_cache(), and zalloc().