memmap.h File Reference

System memory map. More...

#include <stddef.h>
#include <stdint.h>
#include <ipxe/api.h>
#include <ipxe/tables.h>
#include <config/ioapi.h>
#include <ipxe/null_memmap.h>
#include <ipxe/fdtmem.h>
#include <bits/memmap.h>

Go to the source code of this file.

Data Structures
struct	memmap_region
	A memory region descriptor. More...
struct	used_region
	An in-use memory region. More...

Macros
#define	MEMMAP_INLINE(_subsys, _api_func)
	Calculate static inline memory map API function name.
#define	PROVIDE_MEMMAP(_subsys, _api_func, _func)
	Provide a memory map API implementation.
#define	PROVIDE_MEMMAP_INLINE(_subsys, _api_func)
	Provide a static inline memory map API implementation.
#define	MEMMAP_FL_MEMORY   0x0001
	Contains memory.
#define	MEMMAP_FL_RESERVED   0x0002
	Is reserved.
#define	MEMMAP_FL_USED   0x0004
	Is in use by iPXE.
#define	MEMMAP_FL_INACCESSIBLE   0x0008
	Outside of addressable range.
#define	USED_REGIONS   __table ( struct used_region, "used_regions" )
	In-use memory region table.
#define	__used_region   __table_entry ( USED_REGIONS, 01 )
	Declare an in-use memory region.
#define	for_each_memmap_from(region, start, hide)
	Iterate over memory regions from a given starting address.
#define	for_each_memmap(region, hide)
	Iterate over memory regions.
#define	DBG_MEMMAP_IF(level, region)
#define	DBGC_MEMMAP_IF(level, id, ...)
#define	DBGC_MEMMAP(...)
#define	DBGC2_MEMMAP(...)
#define	DBGCP_MEMMAP(...)

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	memmap_init (uint64_t min, struct memmap_region *region)
	Initialise memory region descriptor.
static int	memmap_is_usable (const struct memmap_region *region)
	Check if memory region is usable.
static uint64_t	memmap_size (const struct memmap_region *region)
	Get remaining size of memory region (from the described address upwards)
void	memmap_describe (uint64_t min, int hide, struct memmap_region *region)
	Describe memory region from system memory map.
void	memmap_sync (void)
	Synchronise in-use regions with the externally visible system memory map.
static void	memmap_use (struct used_region *used, physaddr_t start, size_t size)
	Update an in-use memory region.
static void	memmap_dump_all (int hide)
	Dump system memory map (for debugging)
void	memmap_update (struct memmap_region *region, uint64_t start, uint64_t size, unsigned int flags, const char *name)
	Update memory region descriptor.
void	memmap_update_used (struct memmap_region *region)
	Update memory region descriptor based on all in-use memory regions.
size_t	memmap_largest (physaddr_t *start)
	Find largest usable memory region.

Detailed Description

System memory map.

Definition in file memmap.h.

Macro Definition Documentation

MEMMAP_INLINE

#define MEMMAP_INLINE	(		_subsys,
			_api_func )

Value:

        SINGLE_API_INLINE ( MEMMAP_PREFIX_ ## _subsys, _api_func )

Calculate static inline memory map API function name.

Parameters

_prefix	Subsystem prefix
_api_func	API function

Return values

_subsys_func

Subsystem API function

Definition at line 26 of file memmap.h.

#define MEMMAP_INLINE( _subsys, _api_func ) \
        SINGLE_API_INLINE ( MEMMAP_PREFIX_ ## _subsys, _api_func )

PROVIDE_MEMMAP

#define PROVIDE_MEMMAP	(		_subsys,
			_api_func,
			_func )

Value:

        PROVIDE_SINGLE_API ( MEMMAP_PREFIX_ ## _subsys, _api_func, _func )

Provide a memory map API implementation.

Parameters

_prefix	Subsystem prefix
_api_func	API function
_func	Implementing function

Definition at line 36 of file memmap.h.

#define PROVIDE_MEMMAP( _subsys, _api_func, _func ) \
        PROVIDE_SINGLE_API ( MEMMAP_PREFIX_ ## _subsys, _api_func, _func )

PROVIDE_MEMMAP_INLINE

#define PROVIDE_MEMMAP_INLINE	(		_subsys,
			_api_func )

Value:

        PROVIDE_SINGLE_API_INLINE ( MEMMAP_PREFIX_ ## _subsys, _api_func )

Provide a static inline memory map API implementation.

Parameters

_prefix	Subsystem prefix
_api_func	API function

Definition at line 45 of file memmap.h.

#define PROVIDE_MEMMAP_INLINE( _subsys, _api_func ) \
        PROVIDE_SINGLE_API_INLINE ( MEMMAP_PREFIX_ ## _subsys, _api_func )

MEMMAP_FL_MEMORY

#define MEMMAP_FL_MEMORY   0x0001

Contains memory.

Definition at line 60 of file memmap.h.

Referenced by fdtmem_update_tree(), initrd_region(), int15_describe(), lkrn_ram(), meme820(), memmap_is_usable(), memmap_settings_fetch(), and multiboot_build_memmap().

MEMMAP_FL_RESERVED

#define MEMMAP_FL_RESERVED   0x0002

Is reserved.

Definition at line 61 of file memmap.h.

Referenced by fdtmem_relocate(), fdtmem_update_node(), and fdtmem_update_tree().

MEMMAP_FL_USED

#define MEMMAP_FL_USED   0x0004

Is in use by iPXE.

Definition at line 62 of file memmap.h.

Referenced by fdtmem_relocate(), and memmap_update_used().

MEMMAP_FL_INACCESSIBLE

#define MEMMAP_FL_INACCESSIBLE   0x0008

Outside of addressable range.

Definition at line 63 of file memmap.h.

Referenced by fdtmem_describe(), and int15_describe().

USED_REGIONS

#define USED_REGIONS   __table ( struct used_region, "used_regions" )

In-use memory region table.

Definition at line 116 of file memmap.h.

Referenced by memmap_update_used().

__used_region

#define __used_region   __table_entry ( USED_REGIONS, 01 )

Declare an in-use memory region.

Definition at line 119 of file memmap.h.

for_each_memmap_from

#define for_each_memmap_from	(		region,
			start,
			hide )

Value:

        for ( (region)->min = (start), (region)->max = 0 ;           \
              ( ( ( (region)->max + 1 ) != 0 ) &&                       \
                ( memmap_describe ( (region)->min, (hide),            \
                                    (region) ), 1 ) ) ;                 \
              (region)->min = ( (region)->max + 1 ) )

Iterate over memory regions from a given starting address.

Parameters

region	Region descriptor
start	Starting address
hide	Hide in-use regions from the memory map

Definition at line 171 of file memmap.h.

#define for_each_memmap_from( region, start, hide )                     \
        for ( (region)->min = (start), (region)->max = 0 ;              \
              ( ( ( (region)->max + 1 ) != 0 ) &&                       \
                ( memmap_describe ( (region)->min, (hide),              \
                                    (region) ), 1 ) ) ;                 \
              (region)->min = ( (region)->max + 1 ) )

Referenced by relocate().

for_each_memmap

#define for_each_memmap	(		region,
			hide )

Value:

        for_each_memmap_from ( (region), 0, (hide) )

Iterate over memory regions.

Parameters

region	Region descriptor
hide	Hide in-use regions from the memory map

Definition at line 184 of file memmap.h.

#define for_each_memmap( region, hide )                                 \
        for_each_memmap_from ( (region), 0, (hide) )

Referenced by lkrn_ram(), memmap_dump_all(), memmap_largest(), memmap_settings_fetch(), and multiboot_build_memmap().

DBG_MEMMAP_IF

#define DBG_MEMMAP_IF	(		level,
			region )

Value:

        do {                            \
        const char *name = (region)->name;                              \
        unsigned int flags = (region)->flags;                         \
                                                                        \
        DBG_IF ( level, "MEMMAP (%s%s%s%s) [%#08llx,%#08llx]%s%s\n",    \
                 ( ( flags & MEMMAP_FL_MEMORY ) ? "M" : "-" ),             \
                 ( ( flags & MEMMAP_FL_RESERVED ) ? "R" : "-" ), \
                 ( ( flags & MEMMAP_FL_USED ) ? "U" : "-" ),         \
                 ( ( flags & MEMMAP_FL_INACCESSIBLE ) ? "X" : "-" ), \
                 ( ( unsigned long long ) (region)->min ),           \
                 ( ( unsigned long long ) (region)->max ),           \
                 ( name ? " " : "" ), ( name ? name : "" ) );               \
        } while ( 0 )

Definition at line 187 of file memmap.h.

#define DBG_MEMMAP_IF( level, region ) do {                             \
        const char *name = (region)->name;                              \
        unsigned int flags = (region)->flags;                           \
                                                                        \
        DBG_IF ( level, "MEMMAP (%s%s%s%s) [%#08llx,%#08llx]%s%s\n",    \
                 ( ( flags & MEMMAP_FL_MEMORY ) ? "M" : "-" ),          \
                 ( ( flags & MEMMAP_FL_RESERVED ) ? "R" : "-" ),        \
                 ( ( flags & MEMMAP_FL_USED ) ? "U" : "-" ),            \
                 ( ( flags & MEMMAP_FL_INACCESSIBLE ) ? "X" : "-" ),    \
                 ( ( unsigned long long ) (region)->min ),              \
                 ( ( unsigned long long ) (region)->max ),              \
                 ( name ? " " : "" ), ( name ? name : "" ) );           \
        } while ( 0 )

DBGC_MEMMAP_IF

#define DBGC_MEMMAP_IF	(		level,
			id,
			... )

Value:

                do {                            \
                DBG_AC_IF ( level, id );                                \
                DBG_MEMMAP_IF ( level, __VA_ARGS__ );                   \
                DBG_DC_IF ( level );                                    \
        } while ( 0 )

Definition at line 201 of file memmap.h.

#define DBGC_MEMMAP_IF( level, id, ... ) do {                           \
                DBG_AC_IF ( level, id );                                \
                DBG_MEMMAP_IF ( level, __VA_ARGS__ );                   \
                DBG_DC_IF ( level );                                    \
        } while ( 0 )

DBGC_MEMMAP

#define DBGC_MEMMAP

(

...

)

Value:

DBGC_MEMMAP_IF ( LOG, ##__VA_ARGS__ )

Definition at line 207 of file memmap.h.

Referenced by fdtmem_relocate(), lkrn_ram(), memmap_dump_all(), memmap_largest(), multiboot_build_memmap(), prep_segment(), and relocate().

DBGC2_MEMMAP

#define DBGC2_MEMMAP

(

...

)

Value:

DBGC_MEMMAP_IF ( EXTRA, ##__VA_ARGS__ )

Definition at line 208 of file memmap.h.

DBGCP_MEMMAP

#define DBGCP_MEMMAP

(

...

)

Value:

DBGC_MEMMAP_IF ( PROFILE, ##__VA_ARGS__ )

Definition at line 209 of file memmap.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

memmap_init()

void memmap_init ( uint64_t min, struct memmap_region * region )

inlinestatic

Initialise memory region descriptor.

Parameters

min	Minimum address
region	Region descriptor to fill in

Definition at line 72 of file memmap.h.

                                                           {
 
        region->min = min;
        region->max = ~( ( uint64_t ) 0 );
        region->flags = 0;
        region->name = NULL;
}

References memmap_region::flags, memmap_region::max, memmap_region::min, min, memmap_region::name, and NULL.

Referenced by fdtmem_describe(), int15_describe(), and memmap_describe().

memmap_is_usable()

int memmap_is_usable ( const struct memmap_region * region )

inlinestatic

Check if memory region is usable.

Parameters

region

Region descriptor

Return values

is_usable

Memory region is usable

Definition at line 87 of file memmap.h.

                                                        {
 
        return ( region->flags == MEMMAP_FL_MEMORY );
}

References memmap_region::flags, and MEMMAP_FL_MEMORY.

Referenced by com32_exec_loop(), fdtmem_relocate(), memmap_largest(), prep_segment(), and relocate().

memmap_size()

uint64_t memmap_size ( const struct memmap_region * region )

inlinestatic

Get remaining size of memory region (from the described address upwards)

Parameters

region

Region descriptor

Return values

size	Size of memory region

Definition at line 99 of file memmap.h.

                                                   {
 
        /* Calculate size, assuming overflow is known to be impossible */
        return ( region->max - region->min + 1 );
}

References memmap_region::max, and memmap_region::min.

Referenced by com32_exec_loop(), lkrn_exec(), memmap_largest(), memmap_settings_fetch(), multiboot_build_memmap(), and relocate().

memmap_describe()

void memmap_describe	(	uint64_t	min,
		int	hide,
		struct memmap_region *	region )

Describe memory region from system memory map.

Parameters

min	Minimum address
hide	Hide in-use regions from the memory map
region	Region descriptor to fill in

Definition at line 29 of file null_memmap.h.

                                                                         {
 
        /* Initialise region as empty */
        memmap_init ( min, region );
}

References __unused, memmap_describe(), memmap_init(), and min.

Referenced by com32_exec_loop(), memmap_describe(), memmap_dump_all(), prep_segment(), PROVIDE_MEMMAP(), PROVIDE_MEMMAP(), and PROVIDE_MEMMAP_INLINE().

memmap_sync()

void memmap_sync

(

void

)

Synchronise in-use regions with the externally visible system memory map.

In environments such as x86 BIOS, we need to patch the global system memory map to hide our in-use regions, since there is no other way to communicate this information to external code.

Definition at line 26 of file fdtmem.h.

                                            {
        /* Nothing to do */
}

References memmap_sync().

Referenced by memmap_sync(), memmap_use(), PROVIDE_MEMMAP(), PROVIDE_MEMMAP_INLINE(), and PROVIDE_MEMMAP_INLINE().

memmap_use()

void memmap_use ( struct used_region * used, physaddr_t start, size_t size )

inlinestatic

Update an in-use memory region.

Parameters

used	In-use memory region
start	Start address
size	Length of region

Definition at line 154 of file memmap.h.

                                                                       {
 
        /* Record region */
        used->start = start;
        used->size = size;
 
        /* Synchronise externally visible memory map */
        memmap_sync();
}

References memmap_sync(), size, used_region::size, start, and used_region::start.

Referenced by fdtmem_register(), and uheap_resize().

memmap_dump_all()

void memmap_dump_all ( int hide )

inlinestatic

Dump system memory map (for debugging)

Parameters

hide	Hide in-use regions from the memory map

Definition at line 216 of file memmap.h.

                                                {
        struct memmap_region region;
 
        /* Do nothing unless debugging is enabled */
        if ( ! DBG_LOG )
                return;
 
        /* Describe all memory regions */
        DBGC ( &memmap_describe, "MEMMAP with in-use regions %s:\n",
               ( hide ? "hidden" : "ignored" ) );
        for_each_memmap ( &region, hide )
                DBGC_MEMMAP ( &memmap_describe, &region );
}

References DBG_LOG, DBGC, DBGC_MEMMAP, for_each_memmap, and memmap_describe().

Referenced by fdtmem_register(), hide_etherboot(), int13_boot(), relocate(), uheap_resize(), and unhide_etherboot().

memmap_update()

void memmap_update ( struct memmap_region * region, uint64_t start, uint64_t size, unsigned int flags, const char * name )

extern

Update memory region descriptor.

Parameters

region	Memory region of interest to be updated
start	Start address of known region
size	Size of known region
flags	Flags for known region
name	Name of known region (for debugging)

Update a memory region descriptor based on a known existent region.

Definition at line 47 of file memmap.c.

                                                                           {
        uint64_t max;
 
        /* Sanity check */
        assert ( region->max >= region->min );
 
        /* Ignore empty regions */
        if ( ! size )
                return;
 
        /* Calculate max addresses (and truncate if necessary) */
        max = ( start + size - 1 );
        if ( max < start ) {
                max = ~( ( uint64_t ) 0 );
                DBGC ( region, "MEMMAP [%#08llx,%#08llx] %s truncated "
                       "(invalid size %#08llx)\n",
                       ( ( unsigned long long ) start ),
                       ( ( unsigned long long ) max ), name,
                       ( ( unsigned long long ) size ) );
        }
 
        /* Ignore regions entirely below the region of interest */
        if ( max < region->min )
                return;
 
        /* Ignore regions entirely above the region of interest */
        if ( start > region->max )
                return;
 
        /* Update region of interest as applicable */
        if ( start <= region->min ) {
 
                /* Record this region as covering the region of interest */
                region->flags |= flags;
                if ( name )
                        region->name = name;
 
                /* Update max address if no closer boundary exists */
                if ( max < region->max )
                        region->max = max;
 
        } else if ( start < region->max ) {
 
                /* Update max address if no closer boundary exists */
                region->max = ( start - 1 );
        }
 
        /* Sanity check */
        assert ( region->max >= region->min );
}

References assert, DBGC, flags, memmap_region::flags, max, memmap_region::max, memmap_region::min, min, memmap_region::name, name, size, and start.

Referenced by fdtmem_describe(), fdtmem_relocate(), fdtmem_update_node(), fdtmem_update_tree(), int15_describe(), meme820(), and memmap_update_used().

memmap_update_used()

void memmap_update_used ( struct memmap_region * region )

extern

Update memory region descriptor based on all in-use memory regions.

Parameters

region

Memory region of interest to be updated

Definition at line 104 of file memmap.c.

                                                         {
        struct used_region *used;
 
        /* Update descriptor to hide all in-use regions */
        for_each_table_entry ( used, USED_REGIONS ) {
                memmap_update ( region, used->start, used->size,
                                MEMMAP_FL_USED, used->name );
        }
}

References for_each_table_entry, MEMMAP_FL_USED, memmap_update(), used_region::name, used_region::size, used_region::start, and USED_REGIONS.

Referenced by fdtmem_describe_region().

memmap_largest()

size_t memmap_largest ( physaddr_t * start )

extern

Find largest usable memory region.

Parameters

start

Start address to fill in

Return values

len	Length of region

Definition at line 120 of file memmap.c.

                                            {
        struct memmap_region region;
        size_t largest;
        size_t size;
 
        /* Find largest usable region */
        DBGC ( &region, "MEMMAP finding largest usable region\n" );
        *start = 0;
        largest = 0;
        for_each_memmap ( &region, 1 ) {
                DBGC_MEMMAP ( &region, &region );
                if ( ! memmap_is_usable ( &region ) )
                        continue;
                size = memmap_size ( &region );
                if ( size > largest ) {
                        DBGC ( &region, "...new largest region found\n" );
                        largest = size;
                        *start = region.min;
                }
        }
        return largest;
}

References DBGC, DBGC_MEMMAP, for_each_memmap, memmap_is_usable(), memmap_size(), memmap_region::min, size, and start.

Referenced by uheap_find().