malloc.h File Reference

Dynamic memory allocation. More...

#include <stdint.h>
#include <stdlib.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
void *__malloc	alloc_memblock (size_t size, size_t align)
	Allocate a memory block.
void	free_memblock (void *ptr, size_t size)
	Free a memory block.
void	mpopulate (void *start, size_t len)
	Add memory to allocation pool.
void	mdumpfree (void)
static void *__malloc	malloc_dma (size_t size, size_t phys_align)
	Allocate memory for DMA.
static void	free_dma (void *ptr, size_t size)
	Free memory allocated with malloc_dma().
Variables
size_t	freemem
	Total amount of free memory.

---

Detailed Description

Dynamic memory allocation.

Definition in file malloc.h.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

void* __malloc alloc_memblock	(	size_t	size,
		size_t	align
	)

Allocate a memory block.

Parameters:

	size	Requested size
	align	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 100 of file malloc.c.

References DBG, freemem, memory_block::list, list_add, list_del, list_for_each_entry, MIN_MEMBLOCK_SIZE, NULL, memory_block::size, and virt_to_phys().

Referenced by malloc_dma(), mtnic_alloc_aligned(), and realloc().

                                                    {
        struct memory_block *block;
        size_t align_mask;
        size_t pre_size;
        ssize_t post_size;
        struct memory_block *pre;
        struct memory_block *post;

        /* Round up size to multiple of MIN_MEMBLOCK_SIZE and
         * calculate alignment mask.
         */
        size = ( size + MIN_MEMBLOCK_SIZE - 1 ) & ~( MIN_MEMBLOCK_SIZE - 1 );
        align_mask = ( align - 1 ) | ( MIN_MEMBLOCK_SIZE - 1 );

        DBG ( "Allocating %#zx (aligned %#zx)\n", size, align );

        /* Search through blocks for the first one with enough space */
        list_for_each_entry ( block, &free_blocks, list ) {
                pre_size = ( - virt_to_phys ( block ) ) & align_mask;
                post_size = block->size - pre_size - size;
                if ( post_size >= 0 ) {
                        /* 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 ) + size     );
                        DBG ( "[%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.  Leak it if it is too small
                         * (which can happen only at the very end of
                         * the heap).
                         */
                        if ( ( size_t ) post_size >= MIN_MEMBLOCK_SIZE ) {
                                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.  Also remove it (i.e. leak it) if
                         * it is too small, which can happen only at
                         * the very start of the heap.
                         */
                        if ( pre_size < MIN_MEMBLOCK_SIZE )
                                list_del ( &pre->list );
                        /* Update total free memory */
                        freemem -= size;
                        /* Return allocated block */
                        DBG ( "Allocated [%p,%p)\n", block,
                              ( ( ( void * ) block ) + size ) );
                        return block;
                }
        }

        DBG ( "Failed to allocate %#zx (aligned %#zx)\n", size, align );
        return NULL;
}

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

References DBG, freemem, memory_block::list, list_add_tail, list_del, list_for_each_entry, MIN_MEMBLOCK_SIZE, and memory_block::size.

Referenced by free_dma(), mpopulate(), mtnic_alloc_cq(), mtnic_alloc_resources(), mtnic_alloc_ring(), mtnic_close(), mtnic_disable(), mtnic_init_card(), mtnic_open(), and realloc().

                                              {
        struct memory_block *freeing;
        struct memory_block *block;
        ssize_t gap_before;
        ssize_t gap_after = -1;

        /* Allow for ptr==NULL */
        if ( ! ptr )
                return;

        /* Round up size to match actual size that alloc_memblock()
         * would have used.
         */
        size = ( size + MIN_MEMBLOCK_SIZE - 1 ) & ~( MIN_MEMBLOCK_SIZE - 1 );
        freeing = ptr;
        freeing->size = size;
        DBG ( "Freeing [%p,%p)\n", freeing, ( ( ( void * ) freeing ) + size ));

        /* Insert/merge into free list */
        list_for_each_entry ( block, &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 ) {
                        DBG ( "[%p,%p) + [%p,%p) -> [%p,%p)\n", block,
                              ( ( ( void * ) block ) + block->size ), freeing,
                              ( ( ( void * ) freeing ) + freeing->size ),block,
                              ( ( ( void * ) freeing ) + freeing->size ) );
                        block->size += size;
                        list_del ( &block->list );
                        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.
         */
        DBG ( "[%p,%p)\n", freeing, ( ( ( void * ) freeing ) + freeing->size));
        list_add_tail ( &freeing->list, &block->list );
        if ( gap_after == 0 ) {
                DBG ( "[%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 );
        }

        /* Update free memory counter */
        freemem += size;
}

void mpopulate	(	void *	start,
		size_t	len
	)

Add memory to allocation pool.

Parameters:

	start	Start address
	end	End address

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

start must be aligned to at least a multiple of sizeof(void*).

Definition at line 351 of file malloc.c.

References free_memblock(), and MIN_MEMBLOCK_SIZE.

Referenced by init_heap().

                                           {
        /* Prevent free_memblock() from rounding up len beyond the end
         * of what we were actually given...
         */
        free_memblock ( start, ( len & ~( MIN_MEMBLOCK_SIZE - 1 ) ) );
}

void mdumpfree

(

void

)

static void* __malloc malloc_dma	(	size_t	size,
		size_t	phys_align
	)			[inline, static]

Allocate memory for DMA.

Parameters:

	size	Requested size
	align	Physical alignment

Return values:

ptr

Memory, or NULL

Allocates physically-aligned memory for DMA.

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

Definition at line 40 of file malloc.h.

References alloc_memblock().

Referenced by __vxge_hw_fifo_create(), __vxge_hw_ring_create(), a3c90x_setup_rx_ring(), a3c90x_setup_tx_ring(), alloc_iob(), arbel_create_cq(), arbel_create_eq(), arbel_create_recv_wq(), arbel_create_send_wq(), arbel_probe(), ath5k_desc_alloc(), atl1e_setup_ring_resources(), b44_init_rx_ring(), b44_init_tx_ring(), e1000_setup_rx_resources(), e1000_setup_tx_resources(), e1000e_setup_rx_resources(), e1000e_setup_tx_resources(), falcon_alloc_special_buffer(), hermon_create_cq(), hermon_create_eq(), hermon_create_qp(), hermon_probe(), ifec_net_open(), ifec_tx_setup(), igb_setup_rx_resources(), igb_setup_tx_resources(), linda_create_recv_wq(), linda_init_send(), myri10ge_net_open(), phantom_create_rx_ctx(), phantom_create_tx_ctx(), phantom_open(), rtl8169_setup_rx_resources(), rtl8169_setup_tx_resources(), rtl818x_init_rx_ring(), rtl818x_init_tx_ring(), sis190_open(), skge_up(), sky2_probe(), and sky2_up().

                                                                            {
        return alloc_memblock ( size, phys_align );
}

static void free_dma	(	void *	ptr,
		size_t	size
	)			[inline, static]

Free memory allocated with malloc_dma().

Parameters:

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

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

If ptr is NULL, no action is taken.

Definition at line 55 of file malloc.h.

References free_memblock().

Referenced by __vxge_hw_fifo_delete(), __vxge_hw_ring_delete(), a3c90x_free_rx_ring(), a3c90x_free_tx_ring(), arbel_create_cq(), arbel_create_eq(), arbel_create_qp(), arbel_destroy_cq(), arbel_destroy_eq(), arbel_destroy_qp(), arbel_probe(), arbel_remove(), ath5k_desc_alloc(), ath5k_desc_free(), atl1e_free_ring_resources(), b44_free_rx_ring(), b44_free_tx_ring(), e1000_free_rx_resources(), e1000_free_tx_resources(), e1000e_free_rx_resources(), e1000e_free_tx_resources(), falcon_free_special_buffer(), free_iob(), hermon_create_cq(), hermon_create_eq(), hermon_create_qp(), hermon_destroy_cq(), hermon_destroy_eq(), hermon_destroy_qp(), hermon_probe(), hermon_remove(), ifec_free(), ifec_net_open(), igb_free_rx_resources(), igb_free_tx_resources(), linda_create_recv_wq(), linda_destroy_recv_wq(), linda_fini_send(), linda_init_send(), myri10ge_net_close(), myri10ge_net_open(), phantom_close(), phantom_create_rx_ctx(), phantom_create_tx_ctx(), phantom_open(), rtl8169_free_rx_resources(), rtl8169_free_tx_resources(), rtl818x_free_rx_ring(), rtl818x_free_tx_ring(), sis190_free(), skge_free(), sky2_free_rings(), sky2_probe(), and sky2_remove().

                                                       {
        free_memblock ( ptr, size );
}

---

Variable Documentation

size_t freemem

Total amount of free memory.

Definition at line 76 of file malloc.c.

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