uheap.c File Reference

External ("user") heap. More...

#include <ipxe/io.h>
#include <ipxe/memmap.h>
#include <ipxe/malloc.h>
#include <ipxe/umalloc.h>

Go to the source code of this file.

Macros
#define	UHEAP_ALIGN   PAGE_SIZE
	Alignment for external heap allocations.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static void	uheap_resize (ssize_t delta)
	Adjust size of external heap in-use memory region.
static void	uheap_find (void)
	Find an external heap region.
static unsigned int	uheap_grow (size_t size)
	Attempt to grow external heap.
static unsigned int	uheap_shrink (void *ptr, size_t size)
	Allow external heap to shrink.
static void *	uheap_realloc (void *old_ptr, size_t new_size)
	Reallocate external memory.
	PROVIDE_UMALLOC (uheap, urealloc, uheap_realloc)

Variables
static struct heap	uheap
	The external heap.
physaddr_t	uheap_limit
	Minimum possible start of external heap.
physaddr_t	uheap_start
	Start of external heap.
physaddr_t	uheap_end
	End of external heap.
struct used_region uheap_used	__used_region
	In-use memory region.

Detailed Description

External ("user") heap.

This file implements an external heap (for umalloc()) that grows downwards from the top of the largest contiguous accessible block in the system memory map.

Definition in file uheap.c.

Macro Definition Documentation

UHEAP_ALIGN

#define UHEAP_ALIGN   PAGE_SIZE

Alignment for external heap allocations.

Historically, umalloc() has produced page-aligned allocations, and the hidden region in the system memory map has been aligned to a page boundary. Preserve this behaviour, to avoid needing to inspect and update large amounts of driver code, and also because it keeps the resulting memory maps easy to read.

Definition at line 49 of file uheap.c.

Referenced by uheap_find(), and uheap_resize().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

uheap_resize()

void uheap_resize ( ssize_t delta )

static

Adjust size of external heap in-use memory region.

Parameters

delta

Size change

Definition at line 72 of file uheap.c.

                                           {
 
        /* Update in-use memory region */
        assert ( ( delta & ( UHEAP_ALIGN - 1 ) ) == 0 );
        uheap_start -= delta;
        assert ( uheap_limit <= uheap_start );
        assert ( uheap_start <= uheap_end );
        assert ( ( uheap_limit & ( UHEAP_ALIGN - 1 ) ) == 0 );
        assert ( ( uheap_start & ( UHEAP_ALIGN - 1 ) ) == 0 );
        assert ( ( uheap_end & ( UHEAP_ALIGN - 1 ) ) == 0 );
        memmap_use ( &uheap_used, uheap_start, ( uheap_end - uheap_start ) );
        DBGC ( &uheap, "UHEAP now at (%#08lx)...[%#08lx,%#08lx)\n",
               uheap_limit, uheap_start, uheap_end );
        memmap_dump_all ( 1 );
}

References assert, DBGC, memmap_dump_all(), memmap_use(), uheap, UHEAP_ALIGN, uheap_end, uheap_limit, and uheap_start.

Referenced by uheap_find(), uheap_grow(), and uheap_shrink().

uheap_find()

void uheap_find ( void )

static

Find an external heap region.

Definition at line 92 of file uheap.c.

                                {
        physaddr_t start;
        physaddr_t end;
        size_t before;
        size_t after;
        size_t strip;
        size_t size;
 
        /* Sanity checks */
        assert ( uheap_start == uheap_end );
        assert ( uheap_limit == uheap_end );
        assert ( uheap_used.size == 0 );
 
        /* Find the largest region within the system memory map */
        size = memmap_largest ( &start );
        end = ( start + size );
        DBGC ( &uheap, "UHEAP largest region is [%#08lx,%#08lx)\n",
               start, end );
 
        /* Align start and end addresses, and prevent overflow to zero */
        after = ( end ? ( end & ( UHEAP_ALIGN - 1 ) ) : UHEAP_ALIGN );
        before = ( ( -start ) & ( UHEAP_ALIGN - 1 ) );
        strip = ( before + after );
        if ( strip > size )
                return;
        start += before;
        end -= after;
        size -= strip;
        assert ( ( end - start ) == size );
 
        /* Record region */
        uheap_limit = start;
        uheap_start = end;
        uheap_end = end;
        uheap_resize ( 0 );
}

References after, assert, before, DBGC, end, memmap_largest(), size, start, uheap, UHEAP_ALIGN, uheap_end, uheap_limit, uheap_resize(), and uheap_start.

Referenced by uheap_grow().

uheap_grow()

unsigned int uheap_grow ( size_t size )

static

Attempt to grow external heap.

Parameters

size	Failed allocation size

Return values

grown

Heap has grown: retry allocations

Definition at line 135 of file uheap.c.

                                               {
        void *new;
 
        /* Initialise heap, if it does not yet exist */
        if ( uheap_limit == uheap_end )
                uheap_find();
 
        /* Fail if insufficient space remains */
        if ( size > ( uheap_start - uheap_limit ) )
                return 0;
 
        /* Grow heap */
        new = ( phys_to_virt ( uheap_start ) - size );
        heap_populate ( &uheap, new, size );
        uheap_resize ( size );
 
        return 1;
}

References heap_populate(), size, uheap, uheap_end, uheap_find(), uheap_limit, uheap_resize(), and uheap_start.

uheap_shrink()

unsigned int uheap_shrink ( void * ptr, size_t size )

static

Allow external heap to shrink.

Parameters

ptr	Start of free block
size	Size of free block

Return values

shrunk

Heap has shrunk: discard block

Definition at line 161 of file uheap.c.

                                                            {
 
        /* Do nothing unless this is the lowest block in the heap */
        if ( virt_to_phys ( ptr ) != uheap_start )
                return 0;
 
        /* Shrink heap */
        uheap_resize ( -size );
 
        return 1;
}

References size, uheap_resize(), and uheap_start.

uheap_realloc()

void * uheap_realloc ( void * old_ptr, size_t new_size )

static

Reallocate external memory.

Parameters

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

Return values

new_ptr

Allocated memory, or NULL

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

Definition at line 192 of file uheap.c.

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

References heap_realloc(), and uheap.

Referenced by PROVIDE_UMALLOC().

PROVIDE_UMALLOC()

PROVIDE_UMALLOC	(	uheap	,
		urealloc	,
		uheap_realloc	)

References uheap, uheap_realloc(), and urealloc().

Variable Documentation

uheap

struct heap uheap

static

Initial value:

= {
        .blocks = LIST_HEAD_INIT ( uheap.blocks ),
        .align = UHEAP_ALIGN,
        .ptr_align = UHEAP_ALIGN,
        .grow = uheap_grow,
        .shrink = uheap_shrink,
}

The external heap.

Definition at line 51 of file uheap.c.

Referenced by PROVIDE_UMALLOC(), uheap_find(), uheap_grow(), uheap_realloc(), and uheap_resize().

uheap_limit

physaddr_t uheap_limit

Minimum possible start of external heap.

Definition at line 54 of file uheap.c.

Referenced by initrd_region(), initrd_reshuffle(), uheap_find(), uheap_grow(), and uheap_resize().

uheap_start

physaddr_t uheap_start

Start of external heap.

Definition at line 57 of file uheap.c.

Referenced by initrd_startup(), int15_sync(), uheap_find(), uheap_grow(), uheap_resize(), and uheap_shrink().

uheap_end

physaddr_t uheap_end

End of external heap.

Definition at line 60 of file uheap.c.

Referenced by initrd_region(), initrd_reshuffle(), int15_sync(), uheap_find(), uheap_grow(), and uheap_resize().

__used_region

struct used_region uheap_used __used_region

Initial value:

= {
        .name = "uheap",
}

In-use memory region.

Definition at line 63 of file uheap.c.

                                              {
        .name = "uheap",
};