relocate.c File Reference

#include <gpxe/io.h>
#include <registers.h>
#include <gpxe/memmap.h>

Go to the source code of this file.

Defines
#define	max_align   ( ( unsigned int ) _max_align )
#define	MAX_ADDR   (0xfff00000UL)
Functions
	FILE_LICENCE (GPL2_OR_LATER)
__asmcall void	relocate (struct i386_all_regs *ix86)
	Relocate Etherboot.
Variables
char	_max_align []
char	_textdata []
char	_etextdata []

---

Define Documentation

#define max_align   ( ( unsigned int ) _max_align )

Definition at line 20 of file relocate.c.

Referenced by relocate().

#define MAX_ADDR   (0xfff00000UL)

Definition at line 32 of file relocate.c.

Referenced by relocate().

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

__asmcall void relocate

(

struct i386_all_regs *

ix86

)

Relocate Etherboot.

Parameters:

ix86

x86 register dump from prefix

Return values:

ix86

x86 registers to return to prefix

This finds a suitable location for Etherboot near the top of 32-bit address space, and returns the physical address of the new location to the prefix in edi.

Definition at line 44 of file relocate.c.

References _etextdata, _textdata, memory_map::count, DBG, i386_regs::ecx, i386_regs::edi, memory_region::end, i386_regs::esi, get_memmap(), MAX_ADDR, max_align, memory_map::regions, i386_all_regs::regs, size, memory_region::start, and virt_to_phys().

                                                       {
        struct memory_map memmap;
        unsigned long start, end, size, padded_size;
        unsigned long new_start, new_end;
        unsigned i;

        /* Get memory map and current location */
        get_memmap ( &memmap );
        start = virt_to_phys ( _textdata );
        end = virt_to_phys ( _etextdata );
        size = ( end - start );
        padded_size = ( size + max_align - 1 );

        DBG ( "Relocate: currently at [%lx,%lx)\n"
              "...need %lx bytes for %d-byte alignment\n",
              start, end, padded_size, max_align );

        /* Walk through the memory map and find the highest address
         * below 4GB that etherboot will fit into.  Ensure etherboot
         * lies entirely within a range with A20=0.  This means that
         * even if something screws up the state of the A20 line, the
         * etherboot code is still visible and we have a chance to
         * diagnose the problem.
         */
        new_end = end;
        for ( i = 0 ; i < memmap.count ; i++ ) {
                struct memory_region *region = &memmap.regions[i];
                unsigned long r_start, r_end;

                DBG ( "Considering [%llx,%llx)\n", region->start, region->end);
                
                /* Truncate block to MAX_ADDR.  This will be less than
                 * 4GB, which means that we can get away with using
                 * just 32-bit arithmetic after this stage.
                 */
                if ( region->start > MAX_ADDR ) {
                        DBG ( "...starts after MAX_ADDR=%lx\n", MAX_ADDR );
                        continue;
                }
                r_start = region->start;
                if ( region->end > MAX_ADDR ) {
                        DBG ( "...end truncated to MAX_ADDR=%lx\n", MAX_ADDR );
                        r_end = MAX_ADDR;
                } else {
                        r_end = region->end;
                }
                
                /* Shrink the range down to use only even megabytes
                 * (i.e. A20=0).
                 */
                if ( ( r_end - 1 ) & 0x100000 ) {
                        /* If last byte that might be used (r_end-1)
                         * is in an odd megabyte, round down r_end to
                         * the top of the next even megabyte.
                         *
                         * Make sure that we don't accidentally wrap
                         * r_end below 0.
                         */
                        if ( r_end >= 1 ) {
                                r_end = ( r_end - 1 ) & ~0xfffff;
                                DBG ( "...end truncated to %lx "
                                      "(avoid ending in odd megabyte)\n",
                                      r_end );
                        }
                } else if ( ( r_end - size ) & 0x100000 ) {
                        /* If the last byte that might be used
                         * (r_end-1) is in an even megabyte, but the
                         * first byte that might be used (r_end-size)
                         * is an odd megabyte, round down to the top
                         * of the next even megabyte.
                         * 
                         * Make sure that we don't accidentally wrap
                         * r_end below 0.
                         */
                        if ( r_end >= 0x100000 ) {
                                r_end = ( r_end - 0x100000 ) & ~0xfffff;
                                DBG ( "...end truncated to %lx "
                                      "(avoid starting in odd megabyte)\n",
                                      r_end );
                        }
                }

                DBG ( "...usable portion is [%lx,%lx)\n", r_start, r_end );

                /* If we have rounded down r_end below r_ start, skip
                 * this block.
                 */
                if ( r_end < r_start ) {
                        DBG ( "...truncated to negative size\n" );
                        continue;
                }

                /* Check that there is enough space to fit in Etherboot */
                if ( ( r_end - r_start ) < size ) {
                        DBG ( "...too small (need %lx bytes)\n", size );
                        continue;
                }

                /* If the start address of the Etherboot we would
                 * place in this block is higher than the end address
                 * of the current highest block, use this block.
                 *
                 * Note that this avoids overlaps with the current
                 * Etherboot, as well as choosing the highest of all
                 * viable blocks.
                 */
                if ( ( r_end - size ) > new_end ) {
                        new_end = r_end;
                        DBG ( "...new best block found.\n" );
                }
        }

        /* Calculate new location of Etherboot, and align it to the
         * required alignemnt.
         */
        new_start = new_end - padded_size;
        new_start += ( start - new_start ) & ( max_align - 1 );
        new_end = new_start + size;

        DBG ( "Relocating from [%lx,%lx) to [%lx,%lx)\n",
              start, end, new_start, new_end );
        
        /* Let prefix know what to copy */
        ix86->regs.esi = start;
        ix86->regs.edi = new_start;
        ix86->regs.ecx = size;
}

---

Variable Documentation

char _max_align[]

char _textdata[]

Referenced by hide_etherboot(), hide_textdata(), hide_umalloc(), and relocate().

char _etextdata[]

Referenced by hide_textdata(), and relocate().