memmap_settings.c File Reference

Memory map settings. More...

#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/init.h>
#include <ipxe/settings.h>
#include <ipxe/memmap.h>

Go to the source code of this file.

Macros
#define	MEMMAP_TAG(start, count, include_start, include_length, ignore, scale)
	Construct memory map setting tag.
#define	MEMMAP_COUNT(tag)
	Extract number of regions from setting tag.
#define	MEMMAP_START(tag)
	Extract starting region from setting tag.
#define	MEMMAP_IGNORE_NONEXISTENT(tag)
	Extract ignore flag from setting tag.
#define	MEMMAP_INCLUDE_LENGTH(tag)
	Extract length inclusion flag from setting tag.
#define	MEMMAP_INCLUDE_START(tag)
	Extract start address inclusion flag from setting tag.
#define	MEMMAP_SCALE(tag)
	Extract scale factor from setting tag.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	memmap_settings_applies (struct settings *settings __unused, const struct setting *setting)
	Check applicability of memory map setting.
static int	memmap_settings_fetch (struct settings *settings, struct setting *setting, void *data, size_t len)
	Fetch value of memory map setting.
static void	memmap_settings_init (void)
	Initialise memory map settings.
struct init_fn memmap_settings_init_fn	__init_fn (INIT_NORMAL)
	Memory map settings initialiser.
const struct setting memsize_setting	__setting (SETTING_MISC, memsize)
	Memory map predefined settings.

Variables
static const struct settings_scope	memmap_settings_scope
	Memory map settings scope.
static struct settings_operations	memmap_settings_operations
	Memory map settings operations.
static struct settings	memmap_settings
	Memory map settings.

Detailed Description

Memory map settings.

Memory map settings are numerically encoded as:

Bits 31-24 Number of regions, minus one Bits 23-16 Starting region Bits 15-11 Unused Bit 10 Ignore non-existent regions (rather than generating an error) Bit 9 Include length Bit 8 Include start address Bits 7-6 Unused Bits 5-0 Scale factor (i.e. right shift count)

Definition in file memmap_settings.c.

Macro Definition Documentation

MEMMAP_TAG

#define MEMMAP_TAG	(		start,
			count,
			include_start,
			include_length,
			ignore,
			scale )

Value:

        ( ( (start) << 16 ) | ( ( (count) - 1 ) << 24 ) |             \
          ( (ignore) << 10 ) | ( (include_length) << 9 ) |              \
          ( (include_start) << 8 ) | (scale) )

Construct memory map setting tag.

Parameters

start	Starting region
count	Number of regions
include_start	Include start address
include_length	Include length
ignore	Ignore non-existent regions
scale	Scale factor

Return values

tag	Setting tag

Definition at line 60 of file memmap_settings.c.

Referenced by __setting().

MEMMAP_COUNT

#define MEMMAP_COUNT

(

tag

)

Value:

( ( ( (tag) >> 24 ) & 0xff ) + 1 )

Extract number of regions from setting tag.

Parameters

tag	Setting tag

Return values

count

Number of regions

Definition at line 72 of file memmap_settings.c.

Referenced by memmap_settings_fetch().

MEMMAP_START

#define MEMMAP_START

(

tag

)

Value:

( ( (tag) >> 16 ) & 0xff )

Extract starting region from setting tag.

Parameters

tag	Setting tag

Return values

start

Starting region

Definition at line 80 of file memmap_settings.c.

Referenced by memmap_settings_fetch().

MEMMAP_IGNORE_NONEXISTENT

#define MEMMAP_IGNORE_NONEXISTENT

(

tag

)

Value:

( (tag) & 0x00000400UL )

Extract ignore flag from setting tag.

Parameters

tag	Setting tag

Return values

ignore

Ignore non-existent regions

Definition at line 88 of file memmap_settings.c.

Referenced by memmap_settings_fetch().

MEMMAP_INCLUDE_LENGTH

#define MEMMAP_INCLUDE_LENGTH

(

tag

)

Value:

( (tag) & 0x00000200UL )

Extract length inclusion flag from setting tag.

Parameters

tag	Setting tag

Return values

include_length

Include length

Definition at line 96 of file memmap_settings.c.

Referenced by memmap_settings_fetch().

MEMMAP_INCLUDE_START

#define MEMMAP_INCLUDE_START

(

tag

)

Value:

( (tag) & 0x00000100UL )

Extract start address inclusion flag from setting tag.

Parameters

tag	Setting tag

Return values

include_start

Include start address

Definition at line 104 of file memmap_settings.c.

Referenced by memmap_settings_fetch().

MEMMAP_SCALE

#define MEMMAP_SCALE

(

tag

)

Value:

( (tag) & 0x3f )

Extract scale factor from setting tag.

Parameters

tag	Setting tag
scale	Scale factor

Definition at line 112 of file memmap_settings.c.

Referenced by memmap_settings_fetch().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

memmap_settings_applies()

int memmap_settings_applies ( struct settings *settings __unused, const struct setting * setting )

static

Check applicability of memory map setting.

Parameters

settings	Settings block
setting	Setting

Return values

applies

Setting applies within this settings block

Definition at line 124 of file memmap_settings.c.

                                                                     {
 
        return ( setting->scope == &memmap_settings_scope );
}

References __unused, memmap_settings_scope, and setting::scope.

memmap_settings_fetch()

int memmap_settings_fetch ( struct settings * settings, struct setting * setting, void * data, size_t len )

static

Fetch value of memory map setting.

Parameters

settings	Settings block
setting	Setting to fetch
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 139 of file memmap_settings.c.

                                                            {
        struct memmap_region region;
        uint64_t result = 0;
        unsigned int index = 0;
        unsigned int start;
        unsigned int count;
        unsigned int scale;
        int include_start;
        int include_length;
        int ignore_nonexistent;
 
        /* Parse settings tag */
        start = MEMMAP_START ( setting->tag );
        count = MEMMAP_COUNT ( setting->tag );
        scale = MEMMAP_SCALE ( setting->tag );
        include_start = MEMMAP_INCLUDE_START ( setting->tag );
        include_length = MEMMAP_INCLUDE_LENGTH ( setting->tag );
        ignore_nonexistent = MEMMAP_IGNORE_NONEXISTENT ( setting->tag );
        DBGC ( settings, "MEMMAP start %d count %d %s%s%s%s scale %d\n",
               start, count, ( include_start ? "start" : "" ),
               ( ( include_start && include_length ) ? "+" : "" ),
               ( include_length ? "length" : "" ),
               ( ignore_nonexistent ? " ignore" : "" ), scale );
 
        /* Extract results from memory map */
        for_each_memmap ( &region, 0 ) {
 
                /* Skip non-memory regions */
                if ( ! ( region.flags & MEMMAP_FL_MEMORY ) )
                        continue;
 
                /* Ignore unwanted regions */
                if ( index++ < start )
                        continue;
 
                /* Extract results from this region */
                if ( include_start ) {
                        result += region.min;
                        DBGC ( settings, "MEMMAP %d start %#08llx\n", index,
                               ( ( unsigned long long ) region.min ) );
                }
                if ( include_length ) {
                        result += memmap_size ( &region );
                        DBGC ( settings, "MEMMAP %d length %#08llx\n", index,
                               ( ( unsigned long long )
                                 memmap_size ( &region ) ) );
                }
 
                /* Stop when we have accumulated sufficient regions */
                if ( --count == 0 )
                        break;
        }
 
        /* Check for nonexistent regions */
        if ( count && ( ! ignore_nonexistent ) ) {
                DBGC ( settings, "MEMMAP regions %d-%d do not exist\n",
                       index, ( index + count - 1 ) );
                return -ENOENT;
        }
 
        /* Scale result */
        result >>= scale;
 
        /* Return result */
        result = cpu_to_be64 ( result );
        if ( len > sizeof ( result ) )
                len = sizeof ( result );
        memcpy ( data, &result, len );
 
        /* Set type if not already specified */
        if ( ! setting->type )
                setting->type = &setting_type_hexraw;
 
        return sizeof ( result );
}

References count, cpu_to_be64, data, DBGC, ENOENT, memmap_region::flags, for_each_memmap, index, len, memcpy(), MEMMAP_COUNT, MEMMAP_FL_MEMORY, MEMMAP_IGNORE_NONEXISTENT, MEMMAP_INCLUDE_LENGTH, MEMMAP_INCLUDE_START, MEMMAP_SCALE, memmap_size(), MEMMAP_START, memmap_region::min, result, start, setting::tag, and setting::type.

memmap_settings_init()

void memmap_settings_init ( void )

static

Initialise memory map settings.

Definition at line 233 of file memmap_settings.c.

                                          {
        int rc;
 
        if ( ( rc = register_settings ( &memmap_settings, NULL,
                                        "memmap" ) ) != 0 ) {
                DBG ( "MEMMAP could not register settings: %s\n",
                      strerror ( rc ) );
                return;
        }
}

References DBG, memmap_settings, NULL, rc, register_settings(), and strerror().

Referenced by __init_fn().

__init_fn()

struct init_fn memmap_settings_init_fn __init_fn

(

INIT_NORMAL

)

Memory map settings initialiser.

References __init_fn, INIT_NORMAL, and memmap_settings_init().

__setting()

const struct setting memsize_setting __setting	(	SETTING_MISC	,
		memsize	)

Memory map predefined settings.

References __setting, memmap_settings_scope, MEMMAP_TAG, and SETTING_MISC.

Variable Documentation

memmap_settings_scope

const struct settings_scope memmap_settings_scope

static

Memory map settings scope.

Definition at line 115 of file memmap_settings.c.

Referenced by __setting(), and memmap_settings_applies().

memmap_settings_operations

struct settings_operations memmap_settings_operations

static

Initial value:

= {
        .applies = memmap_settings_applies,
        .fetch = memmap_settings_fetch,
}

Memory map settings operations.

Definition at line 218 of file memmap_settings.c.

                                                               {
        .applies = memmap_settings_applies,
        .fetch = memmap_settings_fetch,
};

memmap_settings

struct settings memmap_settings

static

Initial value:

= {
        .refcnt = NULL,
        .siblings = LIST_HEAD_INIT ( memmap_settings.siblings ),
        .children = LIST_HEAD_INIT ( memmap_settings.children ),
        .op = &memmap_settings_operations,
        .default_scope = &memmap_settings_scope,
}

Memory map settings.

Definition at line 224 of file memmap_settings.c.

                                         {
        .refcnt = NULL,
        .siblings = LIST_HEAD_INIT ( memmap_settings.siblings ),
        .children = LIST_HEAD_INIT ( memmap_settings.children ),
        .op = &memmap_settings_operations,
        .default_scope = &memmap_settings_scope,
};

Referenced by memmap_settings_init(), and REQUIRE_OBJECT().