From 48feb91a400d5939e2268b9e818b64a5568baad6 Mon Sep 17 00:00:00 2001 From: Michael Brown Date: Sat, 9 Apr 2005 15:01:38 +0000 Subject: [PATCH] Rewritten in a much saner way, now that we don't have to worry about continually reallocating the real-mode stack. --- src/arch/i386/firmware/pcbios/basemem.c | 274 +++++++----------------- 1 file changed, 78 insertions(+), 196 deletions(-) diff --git a/src/arch/i386/firmware/pcbios/basemem.c b/src/arch/i386/firmware/pcbios/basemem.c index c93b19e9..11fa6dce 100644 --- a/src/arch/i386/firmware/pcbios/basemem.c +++ b/src/arch/i386/firmware/pcbios/basemem.c @@ -1,112 +1,83 @@ -#ifdef PCBIOS - +#include "stdint.h" +#include "stddef.h" +#include "memsizes.h" #include "etherboot.h" -#include "realmode.h" /* for real_mode_stack */ +#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 (mcb30) - * $Id$ + * + * 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. */ -#define fbms ( ( uint16_t * ) phys_to_virt ( 0x413 ) ) -#define BASE_MEMORY_MAX ( 640 ) +/* "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) ) -#define FREE_BASE_MEMORY ( (uint32_t) ( *fbms << 10 ) ) +union free_base_memory_block { + struct { + uint32_t magic; + uint16_t size_kb; + }; + char bytes[1024]; +}; -/* Prototypes */ -void * _allot_base_memory ( size_t size ); -void _forget_base_memory ( void *ptr, size_t size ); +/* Local prototypes */ +static void free_unused_base_memory ( void ); -typedef struct free_base_memory_block { - uint32_t magic; - uint16_t size_kb; -} free_base_memory_block_t; +#undef DBG +#ifdef DEBUG_BASEMEM +#define DBG(...) printf ( __VA_ARGS__ ) +#else +#define DBG(...) +#endif -/* Return amount of free base memory in bytes +/* + * Return amount of free base memory in bytes + * */ - uint32_t get_free_base_memory ( void ) { - return FREE_BASE_MEMORY; -} - -/* Start of our image in base memory. - */ -#define __text16_nocompress __attribute__ ((section (".text16.nocompress"))) -uint32_t image_basemem __text16_nocompress = 0; -uint32_t image_basemem_size __text16_nocompress = 0; - -/* Allot/free the real-mode stack - */ - -void allot_real_mode_stack ( void ) -{ - void *new_real_mode_stack; - - if ( lock_real_mode_stack ) - return; - - /* This is evil hack. - * Until we have a real_mode stack use 0x7c00. - * Except for 0 - 0x600 membory below 0x7c00 is hardly every used. - * This stack should never be used unless the stack allocation fails, - * or if someone has placed a print statement in a dangerous location. - */ - if (!real_mode_stack) { - real_mode_stack = 0x7c00; - } - new_real_mode_stack = _allot_base_memory ( real_mode_stack_size ); - if ( ! new_real_mode_stack ) { - printf ( "FATAL: No real-mode stack\n" ); - while ( 1 ) {}; - } - real_mode_stack = virt_to_phys ( new_real_mode_stack ); - get_memsizes(); -} - -void forget_real_mode_stack ( void ) -{ - if ( lock_real_mode_stack ) - return; - - if ( real_mode_stack) { - _forget_base_memory ( phys_to_virt(real_mode_stack), - real_mode_stack_size ); - /* get_memsizes() uses the real_mode stack we just freed - * for it's BIOS calls. - */ - get_memsizes(); - real_mode_stack = 0; - } + 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. + * */ - -static void * _allot_base_memory ( size_t size ) -{ +void * alloc_base_memory ( size_t size ) { uint16_t size_kb = ( size + 1023 ) >> 10; - void *ptr = NULL; + void *ptr; -#ifdef DEBUG_BASEMEM - printf ( "Trying to allocate %d kB of base memory from %d kB free\n", - size_kb, *fbms ); -#endif + 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 ) { return NULL; } + 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; + fbms -= size_kb; /* Calculate address of memory allocated */ - ptr = phys_to_virt ( FREE_BASE_MEMORY ); + 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 @@ -119,63 +90,43 @@ static void * _allot_base_memory ( size_t size ) */ memset ( ptr, 0, size_kb << 10 ); -#ifdef DEBUG_BASEMEM - printf ( "Allocated %d kB at [%x,%x)\n", size_kb, - virt_to_phys ( ptr ), - virt_to_phys ( ptr ) + size_kb * 1024 ); -#endif + DBG ( "Allocated %d kB of base memory at [%hx:0000,%hx:0000)\n", + size_kb, ( fbms << 6 ), ( ( fbms + size_kb ) << 6 ) ); - return ptr; -} - -void * allot_base_memory ( size_t size ) -{ - void *ptr; - - /* Free real-mode stack, allocate memory, reallocate real-mode - * stack. - */ - forget_real_mode_stack(); - ptr = _allot_base_memory ( size ); + /* Update our memory map */ get_memsizes(); + return ptr; } -/* Free base memory allocated by allot_base_memory. The BIOS provides +/* 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 allotted blocks, it + * 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 forget_base_memory()). + * 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 allotted. However, since our granularity of allocation is + * 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! :-) + * */ - -static void _forget_base_memory ( void *ptr, size_t size ) -{ - uint16_t remainder = virt_to_phys(ptr) & 1023; +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; - free_base_memory_block_t *free_block = - ( free_base_memory_block_t * ) ( ptr - remainder ); + union free_base_memory_block *free_block = + ( ( void * ) ( 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 + 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 @@ -191,62 +142,51 @@ static void _forget_base_memory ( void *ptr, size_t size ) * keep this in so that debug messages are friendlier. It * probably adds around 8 bytes to the overall code size. */ - while ( size_kb > 0 ) { + 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; - /* Move up by 1 kB */ - free_block = (void *)(((char *)free_block) + (1 << 10)); - size_kb--; } /* Free up unused base memory */ free_unused_base_memory(); -} -void forget_base_memory ( void *ptr, size_t size ) -{ - /* Free memory, free real-mode stack, re-allocate real-mode - * stack. Do this so that we don't end up wasting a huge - * block of memory trapped behind the real-mode stack. - */ - _forget_base_memory ( ptr, size ); - forget_real_mode_stack(); + /* 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 - * forget_base_memory() so that it may be called separately. It + * 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 ) { - free_base_memory_block_t *free_block = NULL; + 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 = ( free_base_memory_block_t * ) - phys_to_virt ( FREE_BASE_MEMORY ); + 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 == BASE_MEMORY_MAX ) || + if ( ( fbms == FBMS_MAX ) || ( free_block->magic != FREE_BLOCK_MAGIC ) ) { break; } /* Return memory to BIOS */ - *fbms += free_block->size_kb; + fbms += free_block->size_kb; -#ifdef DEBUG_BASEMEM - printf ( "Freed %d kB base memory, %d kB now free\n", - free_block->size_kb, *fbms ); -#endif + 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 @@ -254,64 +194,6 @@ static void free_unused_base_memory ( void ) { * memory. */ memset ( free_block, 0, free_block->size_kb << 10 ); + } } - -/* Free base memory used by the prefix. Called once at start of - * Etherboot by arch_main(). - */ -void forget_prefix_base_memory ( void ) -{ - /* runtime_start_kb is _text rounded down to a physical kB boundary */ - uint32_t runtime_start_kb = virt_to_phys(_text) & ~0x3ff; - /* prefix_size_kb is the prefix size excluding any portion - * that overlaps into the first kB used by the runtime image - */ - uint32_t prefix_size_kb = runtime_start_kb - image_basemem; - -#ifdef DEBUG_BASEMEM - printf ( "Attempting to free base memory used by prefix\n" ); -#endif - - /* If the decompressor is in allocated base memory - * *and* the Etherboot text is in base - * memory, then free the decompressor. - */ - if ( ( image_basemem >= FREE_BASE_MEMORY ) && - ( runtime_start_kb >= FREE_BASE_MEMORY ) && - ( runtime_start_kb <= ( BASE_MEMORY_MAX << 10 ) ) ) - { - forget_base_memory ( phys_to_virt ( image_basemem ), - prefix_size_kb ); - /* Update image_basemem and image_basemem_size to - * indicate that our allocation now starts with _text - */ - image_basemem = runtime_start_kb; - image_basemem_size -= prefix_size_kb; - } -} - -/* Free base memory used by the runtime image. Called after - * relocation by arch_relocated_from(). - */ -void forget_runtime_base_memory ( unsigned long old_addr ) -{ - /* text_start_kb is old _text rounded down to a physical KB boundary */ - uint32_t old_text_start_kb = old_addr & ~0x3ff; - -#ifdef DEBUG_BASEMEM - printf ( "Attempting to free base memory used by runtime image\n" ); -#endif - - if ( ( image_basemem >= FREE_BASE_MEMORY ) && - ( image_basemem == old_text_start_kb ) ) - { - forget_base_memory ( phys_to_virt ( image_basemem ), - image_basemem_size ); - /* Update image_basemem to show no longer in use */ - image_basemem = 0; - image_basemem_size = 0; - } -} - -#endif /* PCBIOS */