src/core/fdtmem.c - ipxe - Git at Google

 /*
  * Copyright (C) 2025 Michael Brown <mbrown@fensystems.co.uk>.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  *
  * You can also choose to distribute this program under the terms of
  * the Unmodified Binary Distribution Licence (as given in the file
  * COPYING.UBDL), provided that you have satisfied its requirements.
  */

 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

 #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>

 /** @file
  *
  * Flattened Device Tree memory map
  *
  */

 /** Start address of the iPXE image */
 extern char _prefix[];

 /** End address of the iPXE image */
 extern char _end[];

 /** Total in-memory size (calculated by linker) */
 extern size_t ABS_SYMBOL ( _memsz );
 static size_t memsz = ABS_VALUE_INIT ( _memsz );

 /** Relocation required alignment (defined by prefix or linker) */
 extern size_t ABS_SYMBOL ( _max_align );
 static size_t max_align = ABS_VALUE_INIT ( _max_align );

 /** In-use memory region for iPXE and system device tree copy */
 struct used_region fdtmem_used __used_region = {
 	.name = "iPXE/FDT",
 };

 /** Maximum accessible physical address */
 static physaddr_t fdtmem_max;

 /** Maximum 32-bit physical address */
 #define FDTMEM_MAX32 0xffffffff

 /**
  * Update memory region descriptor based on device tree node
  *
  * @v region		Memory region of interest to be updated
  * @v fdt		Device tree
  * @v offset		Starting node offset
  * @v match		Required device type (or NULL)
  * @v flags		Region flags
  * @ret rc		Return status code
  */
 static int fdtmem_update_node ( struct memmap_region *region, struct fdt *fdt,
 				unsigned int offset, const char *match,
 				unsigned int flags ) {
 	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;
 }

 /**
  * Update memory region descriptor based on device tree
  *
  * @v region		Memory region of interest to be updated
  * @v fdt		Device tree
  * @ret rc		Return status code
  */
 static int fdtmem_update_tree ( struct memmap_region *region,
 				struct fdt *fdt ) {
 	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;
 }

 /**
  * Describe memory region
  *
  * @v min		Minimum address
  * @v max		Maximum accessible physical address
  * @v fdt		Device tree
  * @v region		Region descriptor to fill in
  */
 static void fdtmem_describe ( uint64_t min, uint64_t max, struct fdt *fdt,
 			      struct memmap_region *region ) {
 	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 );
 }

 /**
  * Get length for copy of iPXE and device tree
  *
  * @v fdt		Device tree
  * @ret len		Total length
  */
 static size_t fdtmem_len ( struct fdt *fdt ) {
 	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;
 }

 /**
  * Find a relocation address for iPXE
  *
  * @v hdr		FDT header
  * @v max		Maximum accessible physical address
  * @ret 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.
  */
 physaddr_t fdtmem_relocate ( struct fdt_header *hdr, physaddr_t max ) {
 	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;
 }

 /**
  * Copy and register system device tree
  *
  * @v hdr		FDT header
  * @v max		Maximum accessible physical address
  * @ret rc		Return status code
  */
 int fdtmem_register ( struct fdt_header *hdr, physaddr_t max ) {
 	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;
 }

 /**
  * Describe memory region from system memory map
  *
  * @v min		Minimum address
  * @v hide		Hide in-use regions from the memory map
  * @v region		Region descriptor to fill in
  */
 static void fdtmem_describe_region ( uint64_t min, int hide,
 				     struct memmap_region *region ) {

 	/* 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 );
 }

 PROVIDE_MEMMAP ( fdt, memmap_describe, fdtmem_describe_region );
 PROVIDE_MEMMAP_INLINE ( fdt, memmap_sync );
	/*
	* Copyright (C) 2025 Michael Brown <mbrown@fensystems.co.uk>.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License as
	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	* 02110-1301, USA.
	*
	* You can also choose to distribute this program under the terms of
	* the Unmodified Binary Distribution Licence (as given in the file
	* COPYING.UBDL), provided that you have satisfied its requirements.
	*/

	FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

	#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>

	/** @file
	*
	* Flattened Device Tree memory map
	*
	*/

	/** Start address of the iPXE image */
	extern char _prefix[];

	/** End address of the iPXE image */
	extern char _end[];

	/** Total in-memory size (calculated by linker) */
	extern size_t ABS_SYMBOL ( _memsz );
	static size_t memsz = ABS_VALUE_INIT ( _memsz );

	/** Relocation required alignment (defined by prefix or linker) */
	extern size_t ABS_SYMBOL ( _max_align );
	static size_t max_align = ABS_VALUE_INIT ( _max_align );

	/** In-use memory region for iPXE and system device tree copy */
	struct used_region fdtmem_used __used_region = {
	.name = "iPXE/FDT",
	};

	/** Maximum accessible physical address */
	static physaddr_t fdtmem_max;

	/** Maximum 32-bit physical address */
	#define FDTMEM_MAX32 0xffffffff

	/**
	* Update memory region descriptor based on device tree node
	*
	* @v region Memory region of interest to be updated
	* @v fdt Device tree
	* @v offset Starting node offset
	* @v match Required device type (or NULL)
	* @v flags Region flags
	* @ret rc Return status code
	*/
	static int fdtmem_update_node ( struct memmap_region region, struct fdt fdt,
	unsigned int offset, const char *match,
	unsigned int flags ) {
	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;
	}

	/**
	* Update memory region descriptor based on device tree
	*
	* @v region Memory region of interest to be updated
	* @v fdt Device tree
	* @ret rc Return status code
	*/
	static int fdtmem_update_tree ( struct memmap_region *region,
	struct fdt *fdt ) {
	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;
	}

	/**
	* Describe memory region
	*
	* @v min Minimum address
	* @v max Maximum accessible physical address
	* @v fdt Device tree
	* @v region Region descriptor to fill in
	*/
	static void fdtmem_describe ( uint64_t min, uint64_t max, struct fdt *fdt,
	struct memmap_region *region ) {
	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 );
	}

	/**
	* Get length for copy of iPXE and device tree
	*
	* @v fdt Device tree
	* @ret len Total length
	*/
	static size_t fdtmem_len ( struct fdt *fdt ) {
	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;
	}

	/**
	* Find a relocation address for iPXE
	*
	* @v hdr FDT header
	* @v max Maximum accessible physical address
	* @ret 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.
	*/
	physaddr_t fdtmem_relocate ( struct fdt_header *hdr, physaddr_t max ) {
	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;
	}

	/**
	* Copy and register system device tree
	*
	* @v hdr FDT header
	* @v max Maximum accessible physical address
	* @ret rc Return status code
	*/
	int fdtmem_register ( struct fdt_header *hdr, physaddr_t max ) {
	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;
	}

	/**
	* Describe memory region from system memory map
	*
	* @v min Minimum address
	* @v hide Hide in-use regions from the memory map
	* @v region Region descriptor to fill in
	*/
	static void fdtmem_describe_region ( uint64_t min, int hide,
	struct memmap_region *region ) {

	/* 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 );
	}

	PROVIDE_MEMMAP ( fdt, memmap_describe, fdtmem_describe_region );
	PROVIDE_MEMMAP_INLINE ( fdt, memmap_sync );