#include "etherboot.h" #define DEBUG_BASEMEM /* 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) * $Id: basemem.c,v 1.5 2004/06/17 12:48:08 fengshuo Exp $ */ #define fbms ( ( uint16_t * ) phys_to_virt ( 0x413 ) ) #define BASE_MEMORY_MAX ( 640 ) #define FREE_BLOCK_MAGIC ( ('!'<<0) + ('F'<<8) + ('R'<<16) + ('E'<<24) ) typedef struct free_base_memory_block { uint32_t magic; uint16_t size_kb; } free_base_memory_block_t; /* Return amount of free base memory in bytes */ uint32_t get_free_base_memory ( void ) { return *fbms << 10; } /* Adjust the real mode stack pointer. We keep the real mode stack at * the top of free base memory, rather than allocating space for it. */ static inline void adjust_real_mode_stack ( void ) { /* real_mode_stack = ( *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 * allot_base_memory ( size_t size ) { uint16_t size_kb = ( size + 1023 ) >> 10; void *ptr = NULL; #ifdef DEBUG_BASEMEM printf ( "Trying to allocate %d kB of base memory, %d kB free\n", size_kb, *fbms ); #endif /* Free up any unused memory before we start */ free_unused_base_memory(); /* Check available base memory */ if ( size_kb > *fbms ) { return NULL; } /* Reduce available base memory */ *fbms -= size_kb; /* Calculate address of memory allocated */ ptr = phys_to_virt ( *fbms << 10 ); #ifdef DEBUG_BASEMEM /* 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. */ memset ( ptr, 0, size_kb << 10 ); #endif /* Adjust real mode stack pointer */ adjust_real_mode_stack (); return ptr; } /* Free base memory allocated by allot_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 allotted blocks, it * doesn't matter what order you free them in. (This will only work * for blocks that are freed via forget_base_memory()). * * Yes, it's annoying that you have to remember the size of the blocks * you've allotted. 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 forget_base_memory ( void *ptr, size_t size ) { uint16_t remainder = virt_to_phys(ptr) & 1023; uint16_t size_kb = ( size + remainder + 1023 ) >> 10; free_base_memory_block_t *free_block = ( free_base_memory_block_t * ) ( ptr - remainder ); if ( ( ptr == NULL ) || ( size == 0 ) ) { return; } #ifdef DEBUG_BASEMEM printf ( "Trying to free %d bytes base memory at 0x%x\n", size, virt_to_phys ( ptr ) ); if ( remainder > 0 ) { printf ( "WARNING: destructively expanding free block " "downwards to 0x%x\n", virt_to_phys ( ptr - remainder ) ); } #endif /* 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. */ while ( size_kb > 0 ) { /* Mark this block as unused */ free_block->magic = FREE_BLOCK_MAGIC; free_block->size_kb = size_kb; /* Move up by 1 kB */ free_block = (void *)free_block + ( 1 << 10 ); size_kb--; } /* Free up unused base memory */ free_unused_base_memory(); } /* Do the actual freeing of memory. This is split out from * forget_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. */ void free_unused_base_memory ( void ) { free_base_memory_block_t *free_block = NULL; /* 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 = ( free_base_memory_block_t * ) 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 == BASE_MEMORY_MAX ) || ( free_block->magic != FREE_BLOCK_MAGIC ) ) { break; } /* Return memory to BIOS */ *fbms += free_block->size_kb; #ifdef DEBUG_BASEMEM printf ( "Freed %d kB base memory, %d kB now free\n", free_block->size_kb, *fbms ); /* 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 ); #endif } /* Adjust real mode stack pointer */ adjust_real_mode_stack (); }
