ipxe/src/arch/i386/firmware/pcbios/basemem.c

#include "stdint.h"
#include "stddef.h"
#include "memsizes.h"
#include "etherboot.h"
#include "basemem.h"

/* Routines to allocate base memory in a BIOS-compatible way, by
 * updating the Free Base Memory Size counter at 40:13h.
 *
 * Michael Brown <mbrown@fensystems.co.uk> (mcb30)
 *
 * We no longer have anything to do with the real-mode stack.  The
 * only code that can end up creating a huge bubble of wasted base
 * memory is the UNDI driver, so we make it the responsibility of the
 * UNDI driver to reallocate the real-mode stack if required.
 */

/* "fbms" is an alias to the BIOS FBMS counter at 40:13, and acts just
 * like any other uint16_t.  We can't be used under -DKEEP_IT_REAL
 * anyway, so we may as well be efficient.
 */
#define fbms ( * ( ( uint16_t * ) phys_to_virt ( 0x413 ) ) )
#define FBMS_MAX ( 640 )

/* Structure that we use to represent a free block of base memory
 */
#define FREE_BLOCK_MAGIC ( ('!'<<0) + ('F'<<8) + ('R'<<16) + ('E'<<24) )
union free_base_memory_block {
	struct {
		uint32_t	magic;
		uint16_t	size_kb;
	};
	char bytes[1024];
};

/* Local prototypes */
static void free_unused_base_memory ( void );

#undef DBG
#ifdef DEBUG_BASEMEM
#define DBG(...) printf ( __VA_ARGS__ )
#else
#define DBG(...)
#endif

/*
 * Return amount of free base memory in bytes
 *
 */
uint32_t get_free_base_memory ( void ) {
	return fbms << 10;
}

/* Allocate N bytes of base memory.  Amount allocated will be rounded
 * up to the nearest kB, since that's the granularity of the BIOS FBMS
 * counter.  Returns NULL if memory cannot be allocated.
 *
 */
void * alloc_base_memory ( size_t size ) {
	uint16_t size_kb = ( size + 1023 ) >> 10;
	void *ptr;

	DBG ( "Trying to allocate %d bytes of base memory from %d kB free\n",
	      size, fbms );

	/* Free up any unused memory before we start */
	free_unused_base_memory();

	/* Check available base memory */
	if ( size_kb > fbms ) {
		DBG ( "Could not allocate %d kB of base memory: "
		      "only %d kB free\n", size_kb, fbms );
		return NULL;
	}

	/* Reduce available base memory */
	fbms -= size_kb;

	/* Calculate address of memory allocated */
	ptr = phys_to_virt ( fbms << 10 );

	/* Zero out memory.  We do this so that allocation of
	 * already-used space will show up in the form of a crash as
	 * soon as possible.
	 *
	 * Update: there's another reason for doing this.  If we don't
	 * zero the contents, then they could still retain our "free
	 * block" markers and be liable to being freed whenever a
	 * base-memory allocation routine is next called.
	 */
	memset ( ptr, 0, size_kb << 10 );

	DBG ( "Allocated %d kB of base memory at [%hx:0000,%hx:0000)\n",
	      size_kb, ( fbms << 6 ), ( ( fbms + size_kb ) << 6 ) );

	/* Update our memory map */
	get_memsizes();

	return ptr;
}

/* Free base memory allocated by alloc_base_memory.  The BIOS provides
 * nothing better than a LIFO mechanism for freeing memory (i.e. it
 * just has the single "total free memory" counter), but we improve
 * upon this slightly; as long as you free all the allocated blocks, it
 * doesn't matter what order you free them in.  (This will only work
 * for blocks that are freed via free_base_memory()).
 *
 * Yes, it's annoying that you have to remember the size of the blocks
 * you've allocated.  However, since our granularity of allocation is
 * 1K, the alternative is to risk wasting the occasional kB of base
 * memory, which is a Bad Thing.  Really, you should be using as
 * little base memory as possible, so consider the awkwardness of the
 * API to be a feature! :-)
 *
 */
void free_base_memory ( void *ptr, size_t size ) {
	uint16_t remainder = virt_to_phys ( ptr ) & 1023;
	uint16_t size_kb = ( size + remainder + 1023 ) >> 10;
	union free_base_memory_block *free_block = 
		( ( void * ) ( ptr - remainder ) );
	
	if ( ( ptr == NULL ) || ( size == 0 ) ) { 
		return; 
	}

	DBG ( "Trying to free %d bytes base memory at %hx:%hx\n", size,
	      ( virt_to_phys ( ptr - remainder ) >> 4 ),
	      ( virt_to_phys ( ptr - remainder ) & 0xf ) + remainder );

	/* Mark every kilobyte within this block as free.  This is
	 * overkill for normal purposes, but helps when something has
	 * allocated base memory with a granularity finer than the
	 * BIOS granularity of 1kB.  PXE ROMs tend to do this when
	 * they allocate their own memory.  This method allows us to
	 * free their blocks (admittedly in a rather dangerous,
	 * tread-on-anything-either-side sort of way, but there's no
	 * other way to do it).
	 *
	 * Since we're marking every kB as free, there's actually no
	 * need for recording the size of the blocks.  However, we
	 * keep this in so that debug messages are friendlier.  It
	 * probably adds around 8 bytes to the overall code size.
	 */
	for ( ; size_kb > 0 ; free_block++, size_kb-- ) {
		/* Mark this block as unused */
		free_block->magic = FREE_BLOCK_MAGIC;
		free_block->size_kb = size_kb;
	}

	/* Free up unused base memory */
	free_unused_base_memory();

	/* Update our memory map */
	get_memsizes();

	DBG ( "%d kB of base memory now free\n", fbms );
}

/* Do the actual freeing of memory.  This is split out from
 * free_base_memory() so that it may be called separately.  It
 * should be called whenever base memory is deallocated by an external
 * entity (if we can detect that it has done so) so that we get the
 * chance to free up our own blocks.
 */
static void free_unused_base_memory ( void ) {
	union free_base_memory_block *free_block;

	/* Try to release memory back to the BIOS.  Free all
	 * consecutive blocks marked as free.
	 */
	while ( 1 ) {
		/* Calculate address of next potential free block */
		free_block = phys_to_virt ( fbms << 10 );
		
		/* Stop processing if we're all the way up to 640K or
		 * if this is not a free block
		 */
		if ( ( fbms == FBMS_MAX ) ||
		     ( free_block->magic != FREE_BLOCK_MAGIC ) ) {
			break;
		}

		/* Return memory to BIOS */
		fbms += free_block->size_kb;

		DBG ( "Freed %d kB of base memory at [%hx:0000,%hx:0000)\n",
		      free_block->size_kb, ( fbms << 6 ),
		      ( fbms + free_block->size_kb ) << 6 );
		
		/* Zero out freed block.  We do this in case
		 * the block contained any structures that
		 * might be located by scanning through
		 * memory.
		 */
		memset ( free_block, 0, free_block->size_kb << 10 );

	}
}