src/arch/x86/image/initrd.c - ipxe - Git at Google

 /*
  * Copyright (C) 2012 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 <errno.h>
 #include <initrd.h>
 #include <ipxe/image.h>
 #include <ipxe/uaccess.h>
 #include <ipxe/init.h>
 #include <ipxe/memblock.h>
 #include <ipxe/cpio.h>

 /** @file
  *
  * Initial ramdisk (initrd) reshuffling
  *
  */

 /** Maximum address available for initrd */
 userptr_t initrd_top;

 /** Minimum address available for initrd */
 userptr_t initrd_bottom;

 /**
  * Squash initrds as high as possible in memory
  *
  * @v top		Highest possible address
  * @ret used		Lowest address used by initrds
  */
 static userptr_t initrd_squash_high ( userptr_t top ) {
 	userptr_t current = top;
 	struct image *initrd;
 	struct image *highest;
 	size_t len;

 	/* Squash up any initrds already within or below the region */
 	while ( 1 ) {

 		/* Find the highest image not yet in its final position */
 		highest = NULL;
 		for_each_image ( initrd ) {
 			if ( ( userptr_sub ( initrd->data, current ) < 0 ) &&
 			     ( ( highest == NULL ) ||
 			       ( userptr_sub ( initrd->data,
 					       highest->data ) > 0 ) ) ) {
 				highest = initrd;
 			}
 		}
 		if ( ! highest )
 			break;

 		/* Move this image to its final position */
 		len = ( ( highest->len + INITRD_ALIGN - 1 ) &
 			~( INITRD_ALIGN - 1 ) );
 		current = userptr_sub ( current, len );
 		DBGC ( &images, "INITRD squashing %s [%#08lx,%#08lx)->"
 		       "[%#08lx,%#08lx)\n", highest->name,
 		       user_to_phys ( highest->data, 0 ),
 		       user_to_phys ( highest->data, highest->len ),
 		       user_to_phys ( current, 0 ),
 		       user_to_phys ( current, highest->len ) );
 		memmove_user ( current, 0, highest->data, 0, highest->len );
 		highest->data = current;
 	}

 	/* Copy any remaining initrds (e.g. embedded images) to the region */
 	for_each_image ( initrd ) {
 		if ( userptr_sub ( initrd->data, top ) >= 0 ) {
 			len = ( ( initrd->len + INITRD_ALIGN - 1 ) &
 				~( INITRD_ALIGN - 1 ) );
 			current = userptr_sub ( current, len );
 			DBGC ( &images, "INITRD copying %s [%#08lx,%#08lx)->"
 			       "[%#08lx,%#08lx)\n", initrd->name,
 			       user_to_phys ( initrd->data, 0 ),
 			       user_to_phys ( initrd->data, initrd->len ),
 			       user_to_phys ( current, 0 ),
 			       user_to_phys ( current, initrd->len ) );
 			memcpy_user ( current, 0, initrd->data, 0,
 				      initrd->len );
 			initrd->data = current;
 		}
 	}

 	return current;
 }

 /**
  * Swap position of two adjacent initrds
  *
  * @v low		Lower initrd
  * @v high		Higher initrd
  * @v free		Free space
  * @v free_len		Length of free space
  */
 static void initrd_swap ( struct image *low, struct image *high,
 			  userptr_t free, size_t free_len ) {
 	size_t len = 0;
 	size_t frag_len;
 	size_t new_len;

 	DBGC ( &images, "INITRD swapping %s [%#08lx,%#08lx)<->[%#08lx,%#08lx) "
 	       "%s\n", low->name, user_to_phys ( low->data, 0 ),
 	       user_to_phys ( low->data, low->len ),
 	       user_to_phys ( high->data, 0 ),
 	       user_to_phys ( high->data, high->len ), high->name );

 	/* Round down length of free space */
 	free_len &= ~( INITRD_ALIGN - 1 );
 	assert ( free_len > 0 );

 	/* Swap image data */
 	while ( len < high->len ) {

 		/* Calculate maximum fragment length */
 		frag_len = ( high->len - len );
 		if ( frag_len > free_len )
 			frag_len = free_len;
 		new_len = ( ( len + frag_len + INITRD_ALIGN - 1 ) &
 			    ~( INITRD_ALIGN - 1 ) );

 		/* Swap fragments */
 		memcpy_user ( free, 0, high->data, len, frag_len );
 		memmove_user ( low->data, new_len, low->data, len, low->len );
 		memcpy_user ( low->data, len, free, 0, frag_len );
 		len = new_len;
 	}

 	/* Adjust data pointers */
 	high->data = low->data;
 	low->data = userptr_add ( low->data, len );
 }

 /**
  * Swap position of any two adjacent initrds not currently in the correct order
  *
  * @v free		Free space
  * @v free_len		Length of free space
  * @ret swapped		A pair of initrds was swapped
  */
 static int initrd_swap_any ( userptr_t free, size_t free_len ) {
 	struct image *low;
 	struct image *high;
 	size_t padded_len;
 	userptr_t adjacent;

 	/* Find any pair of initrds that can be swapped */
 	for_each_image ( low ) {

 		/* Calculate location of adjacent image (if any) */
 		padded_len = ( ( low->len + INITRD_ALIGN - 1 ) &
 			       ~( INITRD_ALIGN - 1 ) );
 		adjacent = userptr_add ( low->data, padded_len );

 		/* Search for adjacent image */
 		for_each_image ( high ) {

 			/* Stop search if all remaining potential
 			 * adjacent images are already in the correct
 			 * order.
 			 */
 			if ( high == low )
 				break;

 			/* If we have found the adjacent image, swap and exit */
 			if ( high->data == adjacent ) {
 				initrd_swap ( low, high, free, free_len );
 				return 1;
 			}
 		}
 	}

 	/* Nothing swapped */
 	return 0;
 }

 /**
  * Dump initrd locations (for debug)
  *
  */
 static void initrd_dump ( void ) {
 	struct image *initrd;

 	/* Do nothing unless debugging is enabled */
 	if ( ! DBG_LOG )
 		return;

 	/* Dump initrd locations */
 	for_each_image ( initrd ) {
 		DBGC ( &images, "INITRD %s at [%#08lx,%#08lx)\n",
 		       initrd->name, user_to_phys ( initrd->data, 0 ),
 		       user_to_phys ( initrd->data, initrd->len ) );
 		DBGC2_MD5A ( &images, user_to_phys ( initrd->data, 0 ),
 			     user_to_virt ( initrd->data, 0 ), initrd->len );
 	}
 }

 /**
  * Reshuffle initrds into desired order at top of memory
  *
  * @v bottom		Lowest address available for initrds
  *
  * After this function returns, the initrds have been rearranged in
  * memory and the external heap structures will have been corrupted.
  * Reshuffling must therefore take place immediately prior to jumping
  * to the loaded OS kernel; no further execution within iPXE is
  * permitted.
  */
 void initrd_reshuffle ( userptr_t bottom ) {
 	userptr_t top;
 	userptr_t used;
 	userptr_t free;
 	size_t free_len;

 	/* Calculate limits of available space for initrds */
 	top = initrd_top;
 	if ( userptr_sub ( initrd_bottom, bottom ) > 0 )
 		bottom = initrd_bottom;

 	/* Debug */
 	DBGC ( &images, "INITRD region [%#08lx,%#08lx)\n",
 	       user_to_phys ( bottom, 0 ), user_to_phys ( top, 0 ) );
 	initrd_dump();

 	/* Squash initrds as high as possible in memory */
 	used = initrd_squash_high ( top );

 	/* Calculate available free space */
 	free = bottom;
 	free_len = userptr_sub ( used, free );

 	/* Bubble-sort initrds into desired order */
 	while ( initrd_swap_any ( free, free_len ) ) {}

 	/* Debug */
 	initrd_dump();
 }

 /**
  * Check that there is enough space to reshuffle initrds
  *
  * @v len		Total length of initrds (including padding)
  * @v bottom		Lowest address available for initrds
  * @ret rc		Return status code
  */
 int initrd_reshuffle_check ( size_t len, userptr_t bottom ) {
 	userptr_t top;
 	size_t available;

 	/* Calculate limits of available space for initrds */
 	top = initrd_top;
 	if ( userptr_sub ( initrd_bottom, bottom ) > 0 )
 		bottom = initrd_bottom;
 	available = userptr_sub ( top, bottom );

 	/* Allow for a sensible minimum amount of free space */
 	len += INITRD_MIN_FREE_LEN;

 	/* Check for available space */
 	return ( ( len < available ) ? 0 : -ENOBUFS );
 }

 /**
  * initrd startup function
  *
  */
 static void initrd_startup ( void ) {
 	size_t len;

 	/* Record largest memory block available.  Do this after any
 	 * allocations made during driver startup (e.g. large host
 	 * memory blocks for Infiniband devices, which may still be in
 	 * use at the time of rearranging if a SAN device is hooked)
 	 * but before any allocations for downloaded images (which we
 	 * can safely reuse when rearranging).
 	 */
 	len = largest_memblock ( &initrd_bottom );
 	initrd_top = userptr_add ( initrd_bottom, len );
 }

 /** initrd startup function */
 struct startup_fn startup_initrd __startup_fn ( STARTUP_LATE ) = {
 	.name = "initrd",
 	.startup = initrd_startup,
 };
	/*
	* Copyright (C) 2012 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 <errno.h>
	#include <initrd.h>
	#include <ipxe/image.h>
	#include <ipxe/uaccess.h>
	#include <ipxe/init.h>
	#include <ipxe/memblock.h>
	#include <ipxe/cpio.h>

	/** @file
	*
	* Initial ramdisk (initrd) reshuffling
	*
	*/

	/** Maximum address available for initrd */
	userptr_t initrd_top;

	/** Minimum address available for initrd */
	userptr_t initrd_bottom;

	/**
	* Squash initrds as high as possible in memory
	*
	* @v top Highest possible address
	* @ret used Lowest address used by initrds
	*/
	static userptr_t initrd_squash_high ( userptr_t top ) {
	userptr_t current = top;
	struct image *initrd;
	struct image *highest;
	size_t len;

	/* Squash up any initrds already within or below the region */
	while ( 1 ) {

	/* Find the highest image not yet in its final position */
	highest = NULL;
	for_each_image ( initrd ) {
	if ( ( userptr_sub ( initrd->data, current ) < 0 ) &&
	( ( highest == NULL ) \|\|
	( userptr_sub ( initrd->data,
	highest->data ) > 0 ) ) ) {
	highest = initrd;
	}
	}
	if ( ! highest )
	break;

	/* Move this image to its final position */
	len = ( ( highest->len + INITRD_ALIGN - 1 ) &
	~( INITRD_ALIGN - 1 ) );
	current = userptr_sub ( current, len );
	DBGC ( &images, "INITRD squashing %s [%#08lx,%#08lx)->"
	"[%#08lx,%#08lx)\n", highest->name,
	user_to_phys ( highest->data, 0 ),
	user_to_phys ( highest->data, highest->len ),
	user_to_phys ( current, 0 ),
	user_to_phys ( current, highest->len ) );
	memmove_user ( current, 0, highest->data, 0, highest->len );
	highest->data = current;
	}

	/* Copy any remaining initrds (e.g. embedded images) to the region */
	for_each_image ( initrd ) {
	if ( userptr_sub ( initrd->data, top ) >= 0 ) {
	len = ( ( initrd->len + INITRD_ALIGN - 1 ) &
	~( INITRD_ALIGN - 1 ) );
	current = userptr_sub ( current, len );
	DBGC ( &images, "INITRD copying %s [%#08lx,%#08lx)->"
	"[%#08lx,%#08lx)\n", initrd->name,
	user_to_phys ( initrd->data, 0 ),
	user_to_phys ( initrd->data, initrd->len ),
	user_to_phys ( current, 0 ),
	user_to_phys ( current, initrd->len ) );
	memcpy_user ( current, 0, initrd->data, 0,
	initrd->len );
	initrd->data = current;
	}
	}

	return current;
	}

	/**
	* Swap position of two adjacent initrds
	*
	* @v low Lower initrd
	* @v high Higher initrd
	* @v free Free space
	* @v free_len Length of free space
	*/
	static void initrd_swap ( struct image low, struct image high,
	userptr_t free, size_t free_len ) {
	size_t len = 0;
	size_t frag_len;
	size_t new_len;

	DBGC ( &images, "INITRD swapping %s [%#08lx,%#08lx)<->[%#08lx,%#08lx) "
	"%s\n", low->name, user_to_phys ( low->data, 0 ),
	user_to_phys ( low->data, low->len ),
	user_to_phys ( high->data, 0 ),
	user_to_phys ( high->data, high->len ), high->name );

	/* Round down length of free space */
	free_len &= ~( INITRD_ALIGN - 1 );
	assert ( free_len > 0 );

	/* Swap image data */
	while ( len < high->len ) {

	/* Calculate maximum fragment length */
	frag_len = ( high->len - len );
	if ( frag_len > free_len )
	frag_len = free_len;
	new_len = ( ( len + frag_len + INITRD_ALIGN - 1 ) &
	~( INITRD_ALIGN - 1 ) );

	/* Swap fragments */
	memcpy_user ( free, 0, high->data, len, frag_len );
	memmove_user ( low->data, new_len, low->data, len, low->len );
	memcpy_user ( low->data, len, free, 0, frag_len );
	len = new_len;
	}

	/* Adjust data pointers */
	high->data = low->data;
	low->data = userptr_add ( low->data, len );
	}

	/**
	* Swap position of any two adjacent initrds not currently in the correct order
	*
	* @v free Free space
	* @v free_len Length of free space
	* @ret swapped A pair of initrds was swapped
	*/
	static int initrd_swap_any ( userptr_t free, size_t free_len ) {
	struct image *low;
	struct image *high;
	size_t padded_len;
	userptr_t adjacent;

	/* Find any pair of initrds that can be swapped */
	for_each_image ( low ) {

	/* Calculate location of adjacent image (if any) */
	padded_len = ( ( low->len + INITRD_ALIGN - 1 ) &
	~( INITRD_ALIGN - 1 ) );
	adjacent = userptr_add ( low->data, padded_len );

	/* Search for adjacent image */
	for_each_image ( high ) {

	/* Stop search if all remaining potential
	* adjacent images are already in the correct
	* order.
	*/
	if ( high == low )
	break;

	/* If we have found the adjacent image, swap and exit */
	if ( high->data == adjacent ) {
	initrd_swap ( low, high, free, free_len );
	return 1;
	}
	}
	}

	/* Nothing swapped */
	return 0;
	}

	/**
	* Dump initrd locations (for debug)
	*
	*/
	static void initrd_dump ( void ) {
	struct image *initrd;

	/* Do nothing unless debugging is enabled */
	if ( ! DBG_LOG )
	return;

	/* Dump initrd locations */
	for_each_image ( initrd ) {
	DBGC ( &images, "INITRD %s at [%#08lx,%#08lx)\n",
	initrd->name, user_to_phys ( initrd->data, 0 ),
	user_to_phys ( initrd->data, initrd->len ) );
	DBGC2_MD5A ( &images, user_to_phys ( initrd->data, 0 ),
	user_to_virt ( initrd->data, 0 ), initrd->len );
	}
	}

	/**
	* Reshuffle initrds into desired order at top of memory
	*
	* @v bottom Lowest address available for initrds
	*
	* After this function returns, the initrds have been rearranged in
	* memory and the external heap structures will have been corrupted.
	* Reshuffling must therefore take place immediately prior to jumping
	* to the loaded OS kernel; no further execution within iPXE is
	* permitted.
	*/
	void initrd_reshuffle ( userptr_t bottom ) {
	userptr_t top;
	userptr_t used;
	userptr_t free;
	size_t free_len;

	/* Calculate limits of available space for initrds */
	top = initrd_top;
	if ( userptr_sub ( initrd_bottom, bottom ) > 0 )
	bottom = initrd_bottom;

	/* Debug */
	DBGC ( &images, "INITRD region [%#08lx,%#08lx)\n",
	user_to_phys ( bottom, 0 ), user_to_phys ( top, 0 ) );
	initrd_dump();

	/* Squash initrds as high as possible in memory */
	used = initrd_squash_high ( top );

	/* Calculate available free space */
	free = bottom;
	free_len = userptr_sub ( used, free );

	/* Bubble-sort initrds into desired order */
	while ( initrd_swap_any ( free, free_len ) ) {}

	/* Debug */
	initrd_dump();
	}

	/**
	* Check that there is enough space to reshuffle initrds
	*
	* @v len Total length of initrds (including padding)
	* @v bottom Lowest address available for initrds
	* @ret rc Return status code
	*/
	int initrd_reshuffle_check ( size_t len, userptr_t bottom ) {
	userptr_t top;
	size_t available;

	/* Calculate limits of available space for initrds */
	top = initrd_top;
	if ( userptr_sub ( initrd_bottom, bottom ) > 0 )
	bottom = initrd_bottom;
	available = userptr_sub ( top, bottom );

	/* Allow for a sensible minimum amount of free space */
	len += INITRD_MIN_FREE_LEN;

	/* Check for available space */
	return ( ( len < available ) ? 0 : -ENOBUFS );
	}

	/**
	* initrd startup function
	*
	*/
	static void initrd_startup ( void ) {
	size_t len;

	/* Record largest memory block available. Do this after any
	* allocations made during driver startup (e.g. large host
	* memory blocks for Infiniband devices, which may still be in
	* use at the time of rearranging if a SAN device is hooked)
	* but before any allocations for downloaded images (which we
	* can safely reuse when rearranging).
	*/
	len = largest_memblock ( &initrd_bottom );
	initrd_top = userptr_add ( initrd_bottom, len );
	}

	/** initrd startup function */
	struct startup_fn startup_initrd __startup_fn ( STARTUP_LATE ) = {
	.name = "initrd",
	.startup = initrd_startup,
	};