fdtmem.c File Reference

Flattened Device Tree memory map. More...

#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <byteswap.h>
#include <ipxe/uaccess.h>
#include <ipxe/memmap.h>
#include <ipxe/io.h>
#include <ipxe/fdt.h>
#include <ipxe/fdtmem.h>

Go to the source code of this file.

Macros
#define	FDTMEM_MAX32   0xffffffff
	Maximum 32-bit physical address.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
size_t	ABS_SYMBOL (_memsz)
	Total in-memory size (calculated by linker)
size_t	ABS_SYMBOL (_max_align)
	Relocation required alignment (defined by prefix or linker)
static int	fdtmem_update_node (struct memmap_region *region, struct fdt *fdt, unsigned int offset, const char *match, unsigned int flags)
	Update memory region descriptor based on device tree node.
static int	fdtmem_update_tree (struct memmap_region *region, struct fdt *fdt)
	Update memory region descriptor based on device tree.
static void	fdtmem_describe (uint64_t min, uint64_t max, struct fdt *fdt, struct memmap_region *region)
	Describe memory region.
static size_t	fdtmem_len (struct fdt *fdt)
	Get length for copy of iPXE and device tree.
physaddr_t	fdtmem_relocate (struct fdt_header *hdr, physaddr_t max)
	Find a relocation address for iPXE.
int	fdtmem_register (struct fdt_header *hdr, physaddr_t max)
	Copy and register system device tree.
static void	fdtmem_describe_region (uint64_t min, int hide, struct memmap_region *region)
	Describe memory region from system memory map.
	PROVIDE_MEMMAP (fdt, memmap_describe, fdtmem_describe_region)
	PROVIDE_MEMMAP_INLINE (fdt, memmap_sync)

Variables
char	_prefix []
	Start address of the iPXE image.
char	_end []
	End address of the iPXE image.
static size_t	memsz = ABS_VALUE_INIT ( _memsz )
static size_t	max_align = ABS_VALUE_INIT ( _max_align )
struct used_region fdtmem_used	__used_region
	In-use memory region for iPXE and system device tree copy.
static physaddr_t	fdtmem_max
	Maximum accessible physical address.

Detailed Description

Flattened Device Tree memory map.

Definition in file fdtmem.c.

Macro Definition Documentation

FDTMEM_MAX32

#define FDTMEM_MAX32   0xffffffff

Maximum 32-bit physical address.

Definition at line 66 of file fdtmem.c.

Referenced by fdtmem_relocate().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

References _end, and _prefix.

ABS_SYMBOL() [1/2]

size_t ABS_SYMBOL ( _memsz )

extern

Total in-memory size (calculated by linker)

ABS_SYMBOL() [2/2]

size_t ABS_SYMBOL ( _max_align )

extern

Relocation required alignment (defined by prefix or linker)

fdtmem_update_node()

int fdtmem_update_node ( struct memmap_region * region, struct fdt * fdt, unsigned int offset, const char * match, unsigned int flags )

static

Update memory region descriptor based on device tree node.

Parameters

region	Memory region of interest to be updated
fdt	Device tree
offset	Starting node offset
match	Required device type (or NULL)
flags	Region flags

Return values

rc	Return status code

Definition at line 78 of file fdtmem.c.

                                                     {
        struct fdt_descriptor desc;
        struct fdt_reg_cells regs;
        const char *devtype;
        uint64_t start;
        uint64_t size;
        int depth;
        int count;
        int index;
        int rc;
 
        /* Parse region cell sizes */
        fdt_reg_cells ( fdt, offset, &regs );
 
        /* Scan through reservations */
        for ( depth = -1 ; ; depth += desc.depth, offset = desc.next ) {
 
                /* Describe token */
                if ( ( rc = fdt_describe ( fdt, offset, &desc ) ) != 0 ) {
                        DBGC ( region, "FDTMEM has malformed node: %s\n",
                               strerror ( rc ) );
                        return rc;
                }
 
                /* Terminate when we exit this node */
                if ( ( depth == 0 ) && ( desc.depth < 0 ) )
                        break;
 
                /* Ignore any non-immediate child nodes */
                if ( ! ( ( depth == 0 ) && desc.name && ( ! desc.data ) ) )
                        continue;
 
                /* Ignore any non-matching children */
                if ( match ) {
                        devtype = fdt_string ( fdt, desc.offset,
                                               "device_type" );
                        if ( ! devtype )
                                continue;
                        if ( strcmp ( devtype, match ) != 0 )
                                continue;
                }
 
                /* Count regions */
                count = fdt_reg_count ( fdt, desc.offset, &regs );
                if ( count < 0 ) {
                        if ( flags & MEMMAP_FL_RESERVED ) {
                                /* Assume this is a non-fixed reservation */
                                continue;
                        }
                        rc = count;
                        DBGC ( region, "FDTMEM has malformed region %s: %s\n",
                               desc.name, strerror ( rc ) );
                        continue;
                }
 
                /* Scan through this region */
                for ( index = 0 ; index < count ; index++ ) {
 
                        /* Get region starting address and size */
                        if ( ( rc = fdt_reg_address ( fdt, desc.offset, &regs,
                                                      index, &start ) ) != 0 ){
                                DBGC ( region, "FDTMEM %s region %d has "
                                       "malformed start address: %s\n",
                                       desc.name, index, strerror ( rc ) );
                                break;
                        }
                        if ( ( rc = fdt_reg_size ( fdt, desc.offset, &regs,
                                                   index, &size ) ) != 0 ) {
                                DBGC ( region, "FDTMEM %s region %d has "
                                       "malformed size: %s\n",
                                       desc.name, index, strerror ( rc ) );
                                break;
                        }
 
                        /* Update memory region descriptor */
                        memmap_update ( region, start, size, flags,
                                        desc.name );
                }
        }
 
        return 0;
}

References count, DBGC, desc, fdt_describe(), fdt_reg_address(), fdt_reg_cells(), fdt_reg_count(), fdt_reg_size(), fdt_string(), flags, index, MEMMAP_FL_RESERVED, memmap_update(), offset, rc, regs, size, start, strcmp(), and strerror().

Referenced by fdtmem_update_tree().

fdtmem_update_tree()

int fdtmem_update_tree ( struct memmap_region * region, struct fdt * fdt )

static

Update memory region descriptor based on device tree.

Parameters

region	Memory region of interest to be updated
fdt	Device tree

Return values

rc	Return status code

Definition at line 170 of file fdtmem.c.

                                                  {
        const struct fdt_reservation *rsv;
        unsigned int offset;
        int rc;
 
        /* Update based on memory regions in the root node */
        if ( ( rc = fdtmem_update_node ( region, fdt, 0, "memory",
                                         MEMMAP_FL_MEMORY ) ) != 0 )
                return rc;
 
        /* Update based on memory reservations block */
        for_each_fdt_reservation ( rsv, fdt ) {
                memmap_update ( region, be64_to_cpu ( rsv->start ),
                                be64_to_cpu ( rsv->size ), MEMMAP_FL_RESERVED,
                                NULL );
        }
 
        /* Locate reserved-memory node */
        if ( ( rc = fdt_path ( fdt, "/reserved-memory", &offset ) ) != 0 ) {
                DBGC ( region, "FDTMEM could not locate /reserved-memory: "
                       "%s\n", strerror ( rc ) );
                return rc;
        }
 
        /* Update based on memory regions in the reserved-memory node */
        if ( ( rc = fdtmem_update_node ( region, fdt, offset, NULL,
                                         MEMMAP_FL_RESERVED ) ) != 0 )
                return rc;
 
        return 0;
}

References be64_to_cpu, DBGC, fdt_path(), fdtmem_update_node(), for_each_fdt_reservation, MEMMAP_FL_MEMORY, MEMMAP_FL_RESERVED, memmap_update(), NULL, offset, rc, fdt_reservation::size, fdt_reservation::start, and strerror().

Referenced by fdtmem_describe().

fdtmem_describe()

void fdtmem_describe ( uint64_t min, uint64_t max, struct fdt * fdt, struct memmap_region * region )

static

Describe memory region.

Parameters

min	Minimum address
max	Maximum accessible physical address
fdt	Device tree
region	Region descriptor to fill in

Definition at line 211 of file fdtmem.c.

                                                             {
        uint64_t inaccessible;
 
        /* Initialise region */
        memmap_init ( min, region );
 
        /* Update region based on device tree */
        fdtmem_update_tree ( region, fdt );
 
        /* Treat inaccessible physical memory as such */
        inaccessible = ( max + 1 );
        memmap_update ( region, inaccessible, -inaccessible,
                        MEMMAP_FL_INACCESSIBLE, NULL );
}

References fdtmem_update_tree(), max, MEMMAP_FL_INACCESSIBLE, memmap_init(), memmap_update(), min, and NULL.

Referenced by fdtmem_describe_region(), and fdtmem_relocate().

fdtmem_len()

size_t fdtmem_len ( struct fdt * fdt )

static

Get length for copy of iPXE and device tree.

Parameters

fdt	Device tree

Return values

len	Total length

Definition at line 233 of file fdtmem.c.

                                             {
        size_t len;
 
        /* Calculate total length and check device tree alignment */
        len = ( memsz + fdt->len );
        assert ( ( memsz % FDT_MAX_ALIGN ) == 0 );
 
        /* Align length.  Not technically necessary, but keeps the
         * resulting memory maps looking relatively sane.
         */
        len = ( ( len + PAGE_SIZE - 1 ) & ~( PAGE_SIZE - 1 ) );
 
        return len;
}

References assert, FDT_MAX_ALIGN, fdt::len, len, memsz, and PAGE_SIZE.

Referenced by fdtmem_register(), and fdtmem_relocate().

fdtmem_relocate()

physaddr_t fdtmem_relocate	(	struct fdt_header *	hdr,
		physaddr_t	max )

Find a relocation address for iPXE.

Parameters

hdr	FDT header
max	Maximum accessible physical address

Return values

new	New physical address for relocation

Find a suitably aligned address towards the top of existent 32-bit memory to which iPXE may be relocated, along with a copy of the system device tree.

This function may be called very early in initialisation, before .data is writable or .bss has been zeroed. Neither this function nor any function that it calls may write to or rely upon the zero initialisation of any static variables.

Definition at line 264 of file fdtmem.c.

                                                                      {
        struct fdt fdt;
        struct memmap_region region;
        physaddr_t addr;
        physaddr_t next;
        physaddr_t old;
        physaddr_t new;
        physaddr_t try;
        size_t len;
        int rc;
 
        /* Sanity check */
        assert ( ( max_align & ( max_align - 1 ) ) == 0 );
 
        /* Get current physical address */
        old = virt_to_phys ( _prefix );
 
        /* Parse FDT */
        if ( ( rc = fdt_parse ( &fdt, hdr, -1UL ) ) != 0 ) {
                DBGC ( hdr, "FDTMEM could not parse FDT: %s\n",
                       strerror ( rc ) );
                /* Refuse relocation if we have no FDT */
                return old;
        }
 
        /* Determine required length */
        len = fdtmem_len ( &fdt );
        assert ( len > 0 );
        DBGC ( hdr, "FDTMEM requires %#zx + %#zx => %#zx bytes for "
               "relocation\n", memsz, fdt.len, len );
 
        /* Limit relocation to 32-bit address space
         *
         * Devices with only 32-bit DMA addressing are relatively
         * common even on systems with 64-bit CPUs.  Limit relocation
         * of iPXE to 32-bit address space so that I/O buffers and
         * other DMA allocations will be accessible by 32-bit devices.
         */
        if ( max > FDTMEM_MAX32 )
                max = FDTMEM_MAX32;
 
        /* Construct memory map and choose a relocation address */
        new = old;
        for ( addr = 0, next = 1 ; next ; addr = next ) {
 
                /* Describe region and in-use memory */
                fdtmem_describe ( addr, max, &fdt, &region );
                memmap_update ( &region, old, memsz, MEMMAP_FL_USED, "iPXE" );
                memmap_update ( &region, virt_to_phys ( hdr ), fdt.len,
                                MEMMAP_FL_RESERVED, "FDT" );
                next = ( region.max + 1 );
 
                /* Dump region descriptor (for debugging) */
                DBGC_MEMMAP ( hdr, &region );
                assert ( region.max >= region.min );
 
                /* Use highest possible region */
                if ( memmap_is_usable ( &region ) &&
                     ( ( next == 0 ) || ( next >= len ) ) ) {
 
                        /* Determine candidate address after alignment */
                        try = ( ( next - len ) & ~( max_align - 1 ) );
 
                        /* Use this address if within region */
                        if ( try >= addr )
                                new = try;
                }
        }
 
        DBGC ( hdr, "FDTMEM relocating %#08lx => [%#08lx,%#08lx]\n",
               old, new, ( ( physaddr_t ) ( new + len - 1 ) ) );
        return new;
}

References _prefix, addr, assert, DBGC, DBGC_MEMMAP, fdt_parse(), fdtmem_describe(), fdtmem_len(), FDTMEM_MAX32, hdr, fdt::len, len, max, memmap_region::max, max_align, MEMMAP_FL_RESERVED, MEMMAP_FL_USED, memmap_is_usable(), memmap_update(), memsz, memmap_region::min, next, old, rc, and strerror().

fdtmem_register()

int fdtmem_register	(	struct fdt_header *	hdr,
		physaddr_t	max )

Copy and register system device tree.

Parameters

hdr	FDT header
max	Maximum accessible physical address

Return values

rc	Return status code

Definition at line 345 of file fdtmem.c.

                                                               {
        struct fdt_header *copy;
        struct fdt fdt;
        int rc;
 
        /* Record maximum accessible physical address */
        fdtmem_max = max;
 
        /* Parse FDT to obtain length */
        if ( ( rc = fdt_parse ( &fdt, hdr, -1UL ) ) != 0 ) {
                DBGC ( hdr, "FDTMEM could not parse FDT: %s\n",
                       strerror ( rc ) );
                return rc;
        }
 
        /* Copy device tree to end of iPXE image */
        copy = ( ( void * ) _end );
        memcpy ( copy, hdr, fdt.len );
 
        /* Update in-use memory region */
        memmap_use ( &fdtmem_used, virt_to_phys ( _prefix ),
                     fdtmem_len ( &fdt ) );
 
        /* Register copy as system device tree */
        if ( ( rc = fdt_parse ( &sysfdt, copy, -1UL ) ) != 0 ) {
                DBGC ( hdr, "FDTMEM could not register FDT: %s\n",
                       strerror ( rc ) );
                return rc;
        }
        assert ( sysfdt.len == fdt.len );
 
        /* Dump system memory map (for debugging) */
        memmap_dump_all ( 1 );
 
        return 0;
}

References _end, _prefix, assert, DBGC, fdt_parse(), fdtmem_len(), fdtmem_max, hdr, fdt::len, max, memcpy(), memmap_dump_all(), memmap_use(), rc, strerror(), and sysfdt.

fdtmem_describe_region()

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

static

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 389 of file fdtmem.c.

                                                                    {
 
        /* Describe memory region based on device tree */
        fdtmem_describe ( min, fdtmem_max, &sysfdt, region );
 
        /* Update memory region based on in-use regions, if applicable */
        if ( hide )
                memmap_update_used ( region );
}

References fdtmem_describe(), fdtmem_max, memmap_update_used(), min, and sysfdt.

Referenced by PROVIDE_MEMMAP().

PROVIDE_MEMMAP()

PROVIDE_MEMMAP	(	fdt	,
		memmap_describe	,
		fdtmem_describe_region	)

References fdtmem_describe_region(), and memmap_describe().

PROVIDE_MEMMAP_INLINE()

PROVIDE_MEMMAP_INLINE	(	fdt	,
		memmap_sync	)

References memmap_sync().

Variable Documentation

_prefix

char _prefix[]

extern

Start address of the iPXE image.

Referenced by fdtmem_register(), fdtmem_relocate(), and FILE_LICENCE().

_end

char _end[]

extern

End address of the iPXE image.

Referenced by fdtmem_register(), and FILE_LICENCE().

memsz

size_t memsz = ABS_VALUE_INIT ( _memsz )

static

Definition at line 51 of file fdtmem.c.

Referenced by com32_load_image(), com32_prepare_bounce_buffer(), comboot_prepare_segment(), fdtmem_len(), fdtmem_relocate(), FILE_LICENCE(), multiboot_load_raw(), nbi_load_segment(), nbi_prepare_segment(), nbi_process_segments(), and prep_segment().

max_align

size_t max_align = ABS_VALUE_INIT ( _max_align )

static

Definition at line 55 of file fdtmem.c.

Referenced by fdtmem_relocate().

__used_region

struct used_region fdtmem_used __used_region

Initial value:

= {
        .name = "iPXE/FDT",
}

In-use memory region for iPXE and system device tree copy.

Definition at line 58 of file fdtmem.c.

                                               {
        .name = "iPXE/FDT",
};

fdtmem_max

physaddr_t fdtmem_max

static

Maximum accessible physical address.

Definition at line 63 of file fdtmem.c.

Referenced by fdtmem_describe_region(), and fdtmem_register().