320b072c7a
Allow for an arbitrary number of splits of the system memory map via INT 15,e820. Features of the new map-mangling algorithm include: Supports random access to e820 map entries. Requires only sequential access support from the underlying e820 map, even if our caller uses random access. Empty regions will always be stripped. Always terminates with %ebx=0, even if the underlying map terminates with CF=1. Allows for an arbitrary number of hidden regions, with underlying regions split into as many subregions as necessary. Total size increase to achieve this is 193 bytes.
561 lines
14 KiB
ArmAsm
561 lines
14 KiB
ArmAsm
/*
|
|
* Copyright (C) 2006 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
.text
|
|
.arch i386
|
|
.section ".text16", "ax", @progbits
|
|
.section ".data16", "aw", @progbits
|
|
.section ".text16.data", "aw", @progbits
|
|
.code16
|
|
|
|
#define SMAP 0x534d4150
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Allowed memory windows
|
|
*
|
|
* There are two ways to view this list. The first is as a list of
|
|
* (non-overlapping) allowed memory regions, sorted by increasing
|
|
* address. The second is as a list of (non-overlapping) hidden
|
|
* memory regions, again sorted by increasing address. The second
|
|
* view is offset by half an entry from the first: think about this
|
|
* for a moment and it should make sense.
|
|
*
|
|
* xxx_memory_window is used to indicate an "allowed region"
|
|
* structure, hidden_xxx_memory is used to indicate a "hidden region"
|
|
* structure. Each structure is 16 bytes in length.
|
|
*
|
|
****************************************************************************
|
|
*/
|
|
.section ".data16"
|
|
.align 16
|
|
.globl hidemem_base
|
|
.globl hidemem_umalloc
|
|
.globl hidemem_text
|
|
memory_windows:
|
|
base_memory_window: .long 0x00000000, 0x00000000 /* Start of memory */
|
|
|
|
hidemem_base: .long 0x000a0000, 0x00000000 /* Changes at runtime */
|
|
ext_memory_window: .long 0x000a0000, 0x00000000 /* 640kB mark */
|
|
|
|
hidemem_umalloc: .long 0xffffffff, 0xffffffff /* Changes at runtime */
|
|
.long 0xffffffff, 0xffffffff /* Changes at runtime */
|
|
|
|
hidemem_text: .long 0xffffffff, 0xffffffff /* Changes at runtime */
|
|
.long 0xffffffff, 0xffffffff /* Changes at runtime */
|
|
|
|
.long 0xffffffff, 0xffffffff /* End of memory */
|
|
memory_windows_end:
|
|
|
|
/****************************************************************************
|
|
* Truncate region to memory window
|
|
*
|
|
* Parameters:
|
|
* %edx:%eax Start of region
|
|
* %ecx:%ebx Length of region
|
|
* %si Memory window
|
|
* Returns:
|
|
* %edx:%eax Start of windowed region
|
|
* %ecx:%ebx Length of windowed region
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
window_region:
|
|
/* Convert (start,len) to (start, end) */
|
|
addl %eax, %ebx
|
|
adcl %edx, %ecx
|
|
/* Truncate to window start */
|
|
cmpl 4(%si), %edx
|
|
jne 1f
|
|
cmpl 0(%si), %eax
|
|
1: jae 2f
|
|
movl 4(%si), %edx
|
|
movl 0(%si), %eax
|
|
2: /* Truncate to window end */
|
|
cmpl 12(%si), %ecx
|
|
jne 1f
|
|
cmpl 8(%si), %ebx
|
|
1: jbe 2f
|
|
movl 12(%si), %ecx
|
|
movl 8(%si), %ebx
|
|
2: /* Convert (start, end) back to (start, len) */
|
|
subl %eax, %ebx
|
|
sbbl %edx, %ecx
|
|
/* If length is <0, set length to 0 */
|
|
jae 1f
|
|
xorl %ebx, %ebx
|
|
xorl %ecx, %ecx
|
|
ret
|
|
.size window_region, . - window_region
|
|
|
|
/****************************************************************************
|
|
* Patch "memory above 1MB" figure
|
|
*
|
|
* Parameters:
|
|
* %ax Memory above 1MB, in 1kB blocks
|
|
* Returns:
|
|
* %ax Modified memory above 1M in 1kB blocks
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
patch_1m:
|
|
pushal
|
|
/* Convert to (start,len) format and call truncate */
|
|
xorl %ecx, %ecx
|
|
movzwl %ax, %ebx
|
|
shll $10, %ebx
|
|
xorl %edx, %edx
|
|
movl $0x100000, %eax
|
|
movw $ext_memory_window, %si
|
|
call window_region
|
|
/* Convert back to "memory above 1MB" format and return via %ax */
|
|
pushfw
|
|
shrl $10, %ebx
|
|
popfw
|
|
movw %sp, %bp
|
|
movw %bx, 28(%bp)
|
|
popal
|
|
ret
|
|
.size patch_1m, . - patch_1m
|
|
|
|
/****************************************************************************
|
|
* Patch "memory above 16MB" figure
|
|
*
|
|
* Parameters:
|
|
* %bx Memory above 16MB, in 64kB blocks
|
|
* Returns:
|
|
* %bx Modified memory above 16M in 64kB blocks
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
patch_16m:
|
|
pushal
|
|
/* Convert to (start,len) format and call truncate */
|
|
xorl %ecx, %ecx
|
|
shll $16, %ebx
|
|
xorl %edx, %edx
|
|
movl $0x1000000, %eax
|
|
movw $ext_memory_window, %si
|
|
call window_region
|
|
/* Convert back to "memory above 16MB" format and return via %bx */
|
|
pushfw
|
|
shrl $16, %ebx
|
|
popfw
|
|
movw %sp, %bp
|
|
movw %bx, 16(%bp)
|
|
popal
|
|
ret
|
|
.size patch_16m, . - patch_16m
|
|
|
|
/****************************************************************************
|
|
* Patch "memory between 1MB and 16MB" and "memory above 16MB" figures
|
|
*
|
|
* Parameters:
|
|
* %ax Memory between 1MB and 16MB, in 1kB blocks
|
|
* %bx Memory above 16MB, in 64kB blocks
|
|
* Returns:
|
|
* %ax Modified memory between 1MB and 16MB, in 1kB blocks
|
|
* %bx Modified memory above 16MB, in 64kB blocks
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
patch_1m_16m:
|
|
call patch_1m
|
|
call patch_16m
|
|
/* If 1M region is no longer full-length, kill off the 16M region */
|
|
cmpw $( 15 * 1024 ), %ax
|
|
je 1f
|
|
xorw %bx, %bx
|
|
1: ret
|
|
.size patch_1m_16m, . - patch_1m_16m
|
|
|
|
/****************************************************************************
|
|
* Get underlying e820 memory region to underlying_e820 buffer
|
|
*
|
|
* Parameters:
|
|
* As for INT 15,e820
|
|
* Returns:
|
|
* As for INT 15,e820
|
|
*
|
|
* Wraps the underlying INT 15,e820 call so that the continuation
|
|
* value (%ebx) is a 16-bit simple sequence counter (with the high 16
|
|
* bits ignored), and termination is always via CF=1 rather than
|
|
* %ebx=0.
|
|
*
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
get_underlying_e820:
|
|
|
|
/* If the requested region is in the cache, return it */
|
|
cmpw %bx, underlying_e820_index
|
|
jne 1f
|
|
pushw %di
|
|
pushw %si
|
|
movw $underlying_e820_cache, %si
|
|
movw $20, %cx
|
|
rep movsb
|
|
popw %si
|
|
popw %di
|
|
movw $20, %cx
|
|
incw %bx
|
|
movl %edx, %eax
|
|
ret
|
|
1:
|
|
/* If the requested region is earlier than the cached region,
|
|
* invalidate the cache.
|
|
*/
|
|
cmpw %bx, underlying_e820_index
|
|
jbe 1f
|
|
movw $0xffff, underlying_e820_index
|
|
1:
|
|
/* If the cache is invalid, reset the underlying %ebx */
|
|
cmpw $0xffff, underlying_e820_index
|
|
jne 1f
|
|
andl $0, underlying_e820_ebx
|
|
1:
|
|
/* If the cache is valid but the continuation value is zero,
|
|
* this means that the previous underlying call returned with
|
|
* %ebx=0. Return with CF=1 in this case.
|
|
*/
|
|
cmpw $0xffff, underlying_e820_index
|
|
je 1f
|
|
cmpl $0, underlying_e820_ebx
|
|
jne 1f
|
|
stc
|
|
ret
|
|
1:
|
|
/* Get the next region into the cache */
|
|
pushl %eax
|
|
pushl %ebx
|
|
pushl %ecx
|
|
pushl %edx
|
|
movl underlying_e820_ebx, %ebx
|
|
stc
|
|
pushfw
|
|
lcall *%cs:int15_vector
|
|
jc 1f /* CF set: error */
|
|
cmpl $SMAP, %eax
|
|
je 2f /* 'SMAP' missing: error */
|
|
1: /* An error occurred: return values returned by underlying e820 call */
|
|
stc /* Force CF set if SMAP was missing */
|
|
addr32 leal 16(%esp), %esp /* avoid changing other flags */
|
|
ret
|
|
2: /* No error occurred */
|
|
movl %ebx, underlying_e820_ebx
|
|
popl %edx
|
|
popl %ecx
|
|
popl %ebx
|
|
popl %eax
|
|
/* Copy result to cache */
|
|
pushw %es
|
|
pushw %fs
|
|
pushw %si
|
|
pushw %di
|
|
pushw %cx
|
|
pushw %es
|
|
popw %fs
|
|
movw %di, %si
|
|
pushw %ds
|
|
popw %es
|
|
movw $underlying_e820_cache, %di
|
|
movw $20, %cx
|
|
fs rep movsb
|
|
popw %cx
|
|
popw %di
|
|
popw %si
|
|
popw %fs
|
|
popw %es
|
|
/* Mark cache as containing this result */
|
|
incw underlying_e820_index
|
|
|
|
/* Loop until found */
|
|
jmp get_underlying_e820
|
|
.size get_underlying_e820, . - get_underlying_e820
|
|
|
|
.section ".data16"
|
|
underlying_e820_index:
|
|
.word 0xffff /* Initialise to an invalid value */
|
|
.size underlying_e820_index, . - underlying_e820_index
|
|
|
|
.section ".bss16"
|
|
underlying_e820_ebx:
|
|
.long 0
|
|
.size underlying_e820_ebx, . - underlying_e820_ebx
|
|
|
|
.section ".bss16"
|
|
underlying_e820_cache:
|
|
.space 20
|
|
.size underlying_e820_cache, . - underlying_e820_cache
|
|
|
|
/****************************************************************************
|
|
* Get windowed e820 region, without empty region stripping
|
|
*
|
|
* Parameters:
|
|
* As for INT 15,e820
|
|
* Returns:
|
|
* As for INT 15,e820
|
|
*
|
|
* Wraps the underlying INT 15,e820 call so that each underlying
|
|
* region is returned N times, windowed to fit within N visible-memory
|
|
* windows. Termination is always via CF=1.
|
|
*
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
get_windowed_e820:
|
|
|
|
/* Preserve registers */
|
|
pushl %esi
|
|
pushw %bp
|
|
|
|
/* Split %ebx into %si:%bx, store original %bx in %bp */
|
|
pushl %ebx
|
|
popw %bp
|
|
popw %si
|
|
|
|
/* %si == 0 => start of memory_windows list */
|
|
testw %si, %si
|
|
jne 1f
|
|
movw $memory_windows, %si
|
|
1:
|
|
/* Get (cached) underlying e820 region to buffer */
|
|
call get_underlying_e820
|
|
jc 99f /* Abort on error */
|
|
|
|
/* Preserve registers */
|
|
pushal
|
|
/* start => %edx:%eax, len => %ecx:%ebx */
|
|
movl %es:0(%di), %eax
|
|
movl %es:4(%di), %edx
|
|
movl %es:8(%di), %ebx
|
|
movl %es:12(%di), %ecx
|
|
/* Truncate region to current window */
|
|
call window_region
|
|
1: /* Store modified values in e820 map entry */
|
|
movl %eax, %es:0(%di)
|
|
movl %edx, %es:4(%di)
|
|
movl %ebx, %es:8(%di)
|
|
movl %ecx, %es:12(%di)
|
|
/* Restore registers */
|
|
popal
|
|
|
|
/* Derive continuation value for next call */
|
|
addw $16, %si
|
|
cmpw $memory_windows_end, %si
|
|
jne 1f
|
|
/* End of memory windows: reset %si and allow %bx to continue */
|
|
xorw %si, %si
|
|
jmp 2f
|
|
1: /* More memory windows to go: restore original %bx */
|
|
movw %bp, %bx
|
|
2: /* Construct %ebx from %si:%bx */
|
|
pushw %si
|
|
pushw %bx
|
|
popl %ebx
|
|
|
|
98: /* Clear CF */
|
|
clc
|
|
99: /* Restore registers and return */
|
|
popw %bp
|
|
popl %esi
|
|
ret
|
|
.size get_windowed_e820, . - get_windowed_e820
|
|
|
|
/****************************************************************************
|
|
* Get windowed e820 region, with empty region stripping
|
|
*
|
|
* Parameters:
|
|
* As for INT 15,e820
|
|
* Returns:
|
|
* As for INT 15,e820
|
|
*
|
|
* Wraps the underlying INT 15,e820 call so that each underlying
|
|
* region is returned up to N times, windowed to fit within N
|
|
* visible-memory windows. Empty windows are never returned.
|
|
* Termination is always via CF=1.
|
|
*
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
get_nonempty_e820:
|
|
|
|
/* Record entry parameters */
|
|
pushl %eax
|
|
pushl %ecx
|
|
pushl %edx
|
|
|
|
/* Get next windowed region */
|
|
call get_windowed_e820
|
|
jc 99f /* abort on error */
|
|
|
|
/* If region is non-empty, finish here */
|
|
cmpl $0, %es:8(%di)
|
|
jne 98f
|
|
cmpl $0, %es:12(%di)
|
|
jne 98f
|
|
|
|
/* Region was empty: restore entry parameters and go to next region */
|
|
popl %edx
|
|
popl %ecx
|
|
popl %eax
|
|
jmp get_nonempty_e820
|
|
|
|
98: /* Clear CF */
|
|
clc
|
|
99: /* Return values from underlying call */
|
|
addr32 leal 12(%esp), %esp /* avoid changing flags */
|
|
ret
|
|
.size get_nonempty_e820, . - get_nonempty_e820
|
|
|
|
/****************************************************************************
|
|
* Get mangled e820 region, with empty region stripping
|
|
*
|
|
* Parameters:
|
|
* As for INT 15,e820
|
|
* Returns:
|
|
* As for INT 15,e820
|
|
*
|
|
* Wraps the underlying INT 15,e820 call so that underlying regions
|
|
* are windowed to the allowed memory regions. Empty regions are
|
|
* stripped from the map. Termination is always via %ebx=0.
|
|
*
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
get_mangled_e820:
|
|
|
|
/* Get a nonempty region */
|
|
call get_nonempty_e820
|
|
jc 99f /* Abort on error */
|
|
|
|
/* Peek ahead to see if there are any further nonempty regions */
|
|
pushal
|
|
subw $20, %sp
|
|
movl $0xe820, %eax
|
|
movl $SMAP, %edx
|
|
movl $20, %ecx
|
|
pushw %ss
|
|
popw %es
|
|
movw %sp, %di
|
|
call get_nonempty_e820
|
|
addr32 leal 20(%esp), %esp /* avoid changing flags */
|
|
popal
|
|
jnc 99f /* There are further nonempty regions */
|
|
|
|
/* No futher nonempty regions: zero %ebx and clear CF */
|
|
xorl %ebx, %ebx
|
|
|
|
99: /* Return */
|
|
ret
|
|
.size get_mangled_e820, . - get_mangled_e820
|
|
|
|
/****************************************************************************
|
|
* INT 15,e820 handler
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
int15_e820:
|
|
pushw %ds
|
|
pushw %cs:rm_ds
|
|
popw %ds
|
|
call get_mangled_e820
|
|
popw %ds
|
|
lret $2
|
|
.size int15_e820, . - int15_e820
|
|
|
|
/****************************************************************************
|
|
* INT 15,e801 handler
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
int15_e801:
|
|
/* Call previous handler */
|
|
pushfw
|
|
lcall *%cs:int15_vector
|
|
pushfw
|
|
/* Edit result */
|
|
pushw %ds
|
|
pushw %cs:rm_ds
|
|
popw %ds
|
|
call patch_1m_16m
|
|
xchgw %ax, %cx
|
|
xchgw %bx, %dx
|
|
call patch_1m_16m
|
|
xchgw %ax, %cx
|
|
xchgw %bx, %dx
|
|
popw %ds
|
|
/* Restore flags returned by previous handler and return */
|
|
popfw
|
|
lret $2
|
|
.size int15_e801, . - int15_e801
|
|
|
|
/****************************************************************************
|
|
* INT 15,88 handler
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
int15_88:
|
|
/* Call previous handler */
|
|
pushfw
|
|
lcall *%cs:int15_vector
|
|
pushfw
|
|
/* Edit result */
|
|
pushw %ds
|
|
pushw %cs:rm_ds
|
|
popw %ds
|
|
call patch_1m
|
|
popw %ds
|
|
/* Restore flags returned by previous handler and return */
|
|
popfw
|
|
lret $2
|
|
.size int15_88, . - int15_88
|
|
|
|
/****************************************************************************
|
|
* INT 15 handler
|
|
****************************************************************************
|
|
*/
|
|
.section ".text16"
|
|
.globl int15
|
|
int15:
|
|
/* See if we want to intercept this call */
|
|
pushfw
|
|
cmpw $0xe820, %ax
|
|
jne 1f
|
|
cmpl $SMAP, %edx
|
|
jne 1f
|
|
popfw
|
|
jmp int15_e820
|
|
1: cmpw $0xe801, %ax
|
|
jne 2f
|
|
popfw
|
|
jmp int15_e801
|
|
2: cmpb $0x88, %ah
|
|
jne 3f
|
|
popfw
|
|
jmp int15_88
|
|
3: popfw
|
|
ljmp *%cs:int15_vector
|
|
.size int15, . - int15
|
|
|
|
.section ".text16.data"
|
|
.globl int15_vector
|
|
int15_vector:
|
|
.long 0
|
|
.size int15_vector, . - int15_vector
|