Cope with regions bigger than 4GB.

We now split e820 regions around ourselves, rather than just
truncating the e820 region.  This avoids the worst-case scenario of
losing all memory over 4GB.

It's more important to get the memory map right now that we're
expecting to still be loaded when the OS starts in several situations
(e.g. Linux with UNDI driver, any OS with iSCSI/AoE boot, etc.).

src/arch/i386/firmware/pcbios/e820mangler.S

-#undef CODE16
+/*
-#if defined(PCBIOS)
+ * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
-#define	CODE16
+ *
-#endif
+ * This program is free software; you can redistribute it and/or
-
+ * modify it under the terms of the GNU General Public License as
-#ifdef CODE16
+ * published by the Free Software Foundation; either version 2 of the
-	
+ * License, or any later version.
-#define BOCHSBP xchgw %bx,%bx
+ *
+ * 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
+
 /****************************************************************************
- * Memory map mangling code
+ * Check for overlap
+ *
+ * Parameters:
+ *  %edx:%eax	Region start
+ *  %ecx:%ebx	Region end
+ *  %si		Pointer to hidden region descriptor
+ * Returns:
+ *  CF set	Region overlaps
+ *  CF clear	No overlap
  ****************************************************************************
- */
+ */ 
+	.section ".text16"
+check_overlap:
+	/* If start >= hidden_end, there is no overlap. */
+	testl	%edx, %edx
+	jnz	no_overlap
+	cmpl	4(%si), %eax
+	jae	no_overlap
+	/* If end <= hidden_start, there is no overlap; equivalently,
+	 * if end > hidden_start, there is overlap.
+	*/
+	testl	%ecx, %ecx
+	jnz	overlap
+	cmpl	0(%si), %ebx
+	ja	overlap
+no_overlap:
+	clc
+	ret
+overlap:
+	stc
+	ret
+	.size check_overlap, . - check_overlap
 
-	.globl	e820mangler
+/****************************************************************************
-e820mangler:
+ * Check for overflow/underflow
+ *
+ * Parameters:
+ *  %edx:%eax	Region start
+ *  %ecx:%ebx	Region end
+ * Returns:
+ *  CF set	start < end
+ *  CF clear	start >= end
+ ****************************************************************************
+ */
+	.section ".text16"
+check_overflow:
+	pushl	%ecx
+	pushl	%ebx
+	subl	%eax, %ebx
+	sbbl	%edx, %ecx
+	popl	%ebx
+	popl	%ecx
+	ret
+	.size check_overflow, . - check_overflow
+	
+/****************************************************************************
+ * Truncate towards start of region
+ *
+ * Parameters:
+ *  %edx:%eax	Region start
+ *  %ecx:%ebx	Region end
+ *  %si		Pointer to hidden region descriptor
+ * Returns:
+ *  %edx:%eax	Modified region start
+ *  %ecx:%ebx	Modified region end
+ *  CF set	Region was truncated
+ *  CF clear	Region was not truncated
+ ****************************************************************************
+ */
+	.section ".text16"
+truncate_to_start:
+	/* If overlaps, set region end = hidden region start */
+	call	check_overlap
+	jnc	99f
+	movl	0(%si), %ebx
+	xorl	%ecx, %ecx
+	/* If region end < region start, set region end = region start */
+	call	check_overflow
+	jnc	1f
+	movl	%eax, %ebx
+	movl	%edx, %ecx
+1:	stc
+99:	ret
+	.size truncate_to_start, . - truncate_to_start
 
-/* Macro to calculate offset of labels within code segment in
+/****************************************************************************
- * installed copy of code.
+ * Truncate towards end of region
+ *
+ * Parameters:
+ *  %edx:%eax	Region start
+ *  %ecx:%ebx	Region end
+ *  %si		Pointer to hidden region descriptor
+ * Returns:
+ *  %edx:%eax	Modified region start
+ *  %ecx:%ebx	Modified region end
+ *  CF set	Region was truncated
+ *  CF clear	Region was not truncated
+ ****************************************************************************
  */
-#define INSTALLED(x) ( (x) - e820mangler )
+	.section ".text16"
+truncate_to_end:
+	/* If overlaps, set region start = hidden region end */
+	call	check_overlap
+	jnc	99f
+	movl	4(%si), %eax
+	xorl	%edx, %edx
+	/* If region start > region end, set region start = region end */
+	call	check_overflow
+	jnc	1f
+	movl	%ebx, %eax
+	movl	%ecx, %edx
+1:	stc
+99:	ret
+	.size truncate_to_end, . - truncate_to_end
 	
 /****************************************************************************
- * Intercept INT 15 memory calls and remove the hidden memory ranges
+ * Truncate region
- * from the resulting memory map.
+ *
+ * Parameters:
+ *  %edx:%eax	Region start
+ *  %ecx:%ebx	Region length (*not* region end)
+ *  %bp		truncate_to_start or truncate_to_end
+ * Returns:
+ *  %edx:%eax	Modified region start
+ *  %ecx:%ebx	Modified region length
+ *  CF set	Region was truncated
+ *  CF clear	Region was not truncated
  ****************************************************************************
  */
-	.globl	_intercept_int15
+	.section ".text16"
-_intercept_int15:
+truncate:
-	/* Preserve registers */
+	pushw	%si
-	pushw	%bp
-	/* Store %ax for future reference */
-	pushw	%ax
-	/* Make INT-style call to old INT15 routine */
 	pushfw
-	lcall	%cs:*INSTALLED(_intercepted_int15)
+	/* Convert (start,len) to (start,end) */
-	/* Preserve flags returned by original E820 routine */
+	addl	%eax, %ebx
+	adcl	%edx, %ecx
+	/* Hide all hidden regions, truncating as directed */
+	movw	$hidden_regions, %si
+1:	call	*%bp
+	jnc	2f
+	popfw	/* If CF was set, set stored CF in flags word on stack */
+	stc
 	pushfw
-	/* Check for valid INT15 routine */
+2:	addw	$8, %si
-	jc	intercept_int15_exit
+	cmpl	$0, 0(%si)
-	/* Check for a routine we want to intercept */
+	jne	1b
-	movw	%sp, %bp
+	/* Convert modified (start,end) back to (start,len) */
-	cmpw	$0xe820, 2(%bp)
+	subl	%eax, %ebx
-	je	intercept_e820
+	sbbl	%edx, %ecx
-	cmpw	$0xe801, 2(%bp)
-	je	intercept_e801
-	cmpb	$0x88, 3(%bp)
-	je	intercept_88
-intercept_int15_exit:
-	/* Restore registers and return */
 	popfw
-	popw	%bp			/* discard original %ax */
+	popw	%si
-	popw	%bp
+	ret
-	lret	$2			/* 'iret' - flags already loaded */
+	.size truncate, . - truncate
 
-	.globl	_intercepted_int15
-_intercepted_int15:	.word 0,0
-		
 /****************************************************************************
- * Exclude an address range from a potentially overlapping address range
+ * Patch "memory above 1MB" figure
- *
- * Note: this *can* be called even if the range doesn't overlap; it
- * will simply return the range unaltered.  It copes with all the
- * possible cases of overlap, including total overlap (which will
- * modify the range to length zero).  If the to-be-excluded range is
- * in the middle of the target range, then the larger remaining
- * portion will be returned.  If %di is nonzero on entry then the
- * range will only be truncated from the high end, i.e. the base
- * address will never be altered.  All this in less than 30
- * instructions.  :)
  *
  * Parameters:
- *  %eax	Base address of memory range
+ *  %ax		Memory above 1MB, in 1kB blocks
- *  %ecx	Length of memory range
- *  %ebx	Base address of memory range to exclude
- *  %edx	Length of memory range to exclude
- *  %di		0 => truncate either end, 1 => truncate high end only
  * Returns:
- *  %eax	Updated base address of range
+ *  %ax		Modified memory above 1M in 1kB blocks
- *  %ecx	Updated length of range
+ *  CF set	Region was truncated
- *  %ebx,%edx	Undefined
+ *  CF clear	Region was not truncated
- *		All other registers (including %di) preserved
+ ****************************************************************************
+ */
+	.section ".text16"
+patch_1m:
+	pushal
+	/* Convert to (start,len) format and call truncate */
+	movw	$truncate_to_start, %bp
+	xorl	%ecx, %ecx
+	movzwl	%ax, %ebx
+	shll	$10, %ebx
+	xorl	%edx, %edx
+	movl	$0x100000, %eax
+	call	truncate
+	/* 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
  *
- * Note: "ja" is used rather than "jg" because we are comparing
+ * Parameters:
- * unsigned ints
+ *  %bx		Memory above 16MB, in 64kB blocks
+ * Returns:
+ *  %bx		Modified memory above 16M in 64kB blocks
+ *  CF set	Region was truncated
+ *  CF clear	Region was not truncated
  ****************************************************************************
  */
-#ifdef TEST_EXCLUDE_ALGORITHM
+	.section ".text16"
-	.code32
+patch_16m:
-#endif /* TEST_EXCLUDE_ALGORITHM */
+	pushal
-exclude_memory_range:
+	/* Convert to (start,len) format and call truncate */
-	/* Convert (start,length) to (start,end) */
+	movw	$truncate_to_start, %bp
-	addl	%eax, %ecx
+	xorl	%ecx, %ecx
-	addl	%ebx, %edx
+	shll	$16, %ebx
-	/* Calculate "prefix" length */
+	xorl	%edx, %edx
-	subl	%eax, %ebx		/* %ebx = "prefix" length */
+	movl	$0x1000000, %eax
-	ja	1f
+	call	truncate
-	xorl	%ebx, %ebx		/* Truncate to zero if negative */
+	/* Convert back to "memory above 16MB" format and return via %bx */
-1:	/* %di == 0 => truncate either end
+	pushfw
-	 * %di != 0 => truncate only high end
+	shrl	$16, %ebx
-	 */
+	popfw
-	testw	%di, %di
+	movw	%sp, %bp
-	je	use_either
+	movw	%bx, 24(%bp)
-	cmpl	%eax, %edx
+	popal
-	jbe	99f			/* excl. range is below target range */
-use_prefix:	/* Use prefix, discard suffix */
-	addl	%eax, %ebx		/* %ebx = candidate end address */
-	cmpl	%ecx, %ebx		/* %ecx = min ( %ebx, %ecx ) */
-	ja	1f
-	movl	%ebx, %ecx
-1:	jmp	99f
-use_either:		
-	/* Calculate "suffix" length */
-	subl	%ecx, %edx		/* %edx = -( "suffix" length ) */
-	jb	1f
-	xorl	%edx, %edx		/* Truncate to zero if negative */
-1:	negl	%edx			/* %edx = "suffix" length */
-	/* Use whichever is longest of "prefix" and "suffix" */
-	cmpl	%ebx, %edx
-	jbe	use_prefix
-use_suffix:	/* Use suffix, discard prefix */
-	negl	%edx
-	addl	%ecx, %edx		/* %edx = candidate start address */
-	cmpl	%eax, %edx		/* %eax = max ( %eax, %edx ) */
-	jb	1f
-	movl	%edx, %eax
-1:	
-99:	subl	%eax, %ecx		/* Convert back to (start,length) */
 	ret
+	.size patch_16m, . - patch_16m
 
-#ifdef TEST_EXCLUDE_ALGORITHM
+/****************************************************************************
-	.globl	__test_exclude
+ * Patch "memory between 1MB and 16MB" and "memory above 16MB" figures
-__test_exclude:
+ *
-	pushl   %ebx
+ * Parameters:
-	pushl	%edi
+ *  %ax		Memory between 1MB and 16MB, in 1kB blocks
-	movl    12(%esp), %eax
+ *  %bx		Memory above 16MB, in 64kB blocks
-	movl    16(%esp), %ecx
+ * Returns:
-	movl    20(%esp), %ebx
+ *  %ax		Modified memory between 1MB and 16MB, in 1kB blocks
-	movl    24(%esp), %edx
+ *  %bx		Modified memory above 16MB, in 64kB blocks
-	movl	28(%esp), %edi
+ *  CF set	Region was truncated
-	call    exclude_memory_range
+ *  CF clear	Region was not truncated
-	shll    $16, %eax
+ ****************************************************************************
-	orl     %ecx, %eax
+ */
-	popl	%edi
+	.section ".text16"
-	popl	%ebx
+patch_1m_16m:
+	call	patch_1m
+	jc	1f
+	call	patch_16m
 	ret
-	.code16
+1:	/* 1m region was truncated; kill the 16m region */
-#endif /* TEST_EXCLUDE_ALGORITHM */
+	xorw	%bx, %bx
-	
+	ret
+	.size patch_1m_16m, . - patch_1m_16m
+
 /****************************************************************************
- * Exclude Etherboot-reserved address ranges from a potentially
+ * Patch E820 memory map entry
- * overlapping address range
  *
  * Parameters:
- *  %eax	Base address of memory range
+ *  %es:di	Pointer to E820 memory map descriptor
- *  %ecx	Length of memory range
+ *  %bp		truncate_to_start or truncate_to_end
- *  %di		0 => truncate either end, 1 => truncate high end only
  * Returns:
- *  %eax	Updated base address of range
+ *  %es:di	Pointer to now-modified E820 memory map descriptor
- *  %ecx	Updated length of range
+ *  CF set	Region was truncated
- *		All other registers (including %di) preserved
+ *  CF clear	Region was not truncated
  ****************************************************************************
  */
-exclude_hidden_memory_ranges:
+	.section ".text16"
-	pushw	%si
+patch_e820:
-	pushl	%ebx
+	pushal
-	pushl	%edx
+	movl	%es:0(%di), %eax
-	movw	$INSTALLED(_hide_memory), %si
+	movl	%es:4(%di), %edx
-2:	movl	%cs:0(%si), %ebx
+	movl	%es:8(%di), %ebx
-	movl	%cs:4(%si), %edx
+	movl	%es:12(%di), %ecx
-	call	exclude_memory_range
+	call	truncate
-	addw	$8, %si
+	movl	%eax, %es:0(%di)
-	cmpw	$INSTALLED(_hide_memory_end), %si
+	movl	%edx, %es:4(%di)
-	jl	2b
+	movl	%ebx, %es:8(%di)
-	popl	%edx
+	movl	%ecx, %es:12(%di)
-	popl	%ebx
+	popal
-	popw	%si
 	ret
-	
+	.size patch_e820, . - patch_e820
-	.globl	_hide_memory	
-_hide_memory:
-	.long	0,0			/* Etherboot text (base,length) */
-	.long	0,0			/* Heap (base,length) */
-_hide_memory_end:
 
 /****************************************************************************
- * Intercept INT 15,E820 calls and remove the hidden memory ranges
+ * INT 15,e820 handler
- * from the resulting memory map.
  ****************************************************************************
  */
-#define SMAP ( 0x534d4150 )
+	.section ".text16"
-intercept_e820:
+int15_e820:
-	/* Check for valid E820 routine */
+	pushw	%si
-	cmpl	$SMAP, %eax
+	pushw	%bp
-	jne	intercept_int15_exit
+	/* Caller's %bx => %si, real %ebx to %ebx, call previous handler */
-	/* If base address isn't in the low 4GB, return unaltered
+	pushfw
-	 * (since we never claim memory above 4GB).  WARNING: we cheat
+	movw	%bx, %si
-	 * by assuming that no E820 region will straddle the 4GB
+	testl	%ebx, %ebx
-	 * boundary: if this is not a valid assumption then things
+	jnz	1f
-	 * will probably break.
+	movl	%ebx, %cs:real_ebx
-	 */
+1:	movl	%cs:real_ebx, %ebx
-	cmpl	$0, %es:4(%di)
+	lcall	*%cs:int15_vector
-	jne	intercept_int15_exit
+	pushfw
-	/* Preserve registers */
+	/* Edit result */
-	pushl	%eax
+	pushw	%ds
-	pushl	%ecx
+	pushw	%cs:rm_ds
-	/* Update returned memory range */
+	popw	%ds
-	movl	%es:0(%di), %eax	/* Base */
+	movw	$truncate_to_start, %bp
-	movl	%es:8(%di), %ecx	/* Length */
+	incw	%si
-	pushw	%di
+	jns	2f
-	xorw	%di, %di		/* "truncate either end" flag */
+	movw	$truncate_to_end, %bp
-	call	exclude_hidden_memory_ranges
+2:	call	patch_e820
-	popw	%di
+	jnc	3f
-	movl	%eax, %es:0(%di)	/* Store updated base */
+	xorw	$0x8000, %si
-	movl	%ecx, %es:8(%di)	/* Store updated length */
+3:	testw	%si, %si
-	/* Restore registers and return */
+	js	4f
-	popl	%ecx
+	movl	%ebx, %cs:real_ebx
-	popl	%eax
+	testl	%ebx, %ebx
-	jmp	intercept_int15_exit
+	jz	5f
+4:	movw	%si, %bx
+5:	popw	%ds
+	/* Restore flags returned by previous handler and return */
+	popfw
+	popw	%bp
+	popw	%si
+	lret	$2
+	.size int15_e820, . - int15_e820
 
+	.section ".text16.data"
+real_ebx:
+	.long 0
+	.size real_ebx, . - real_ebx
+	
 /****************************************************************************
- * Intercept INT 15,E801 calls and remove the hidden memory ranges
+ * INT 15,e801 handler
- * from the resulting memory map.
  ****************************************************************************
  */
-intercept_e801:
+	.section ".text16"
-	/* Adjust return values */
+int15_e801:
-	call	e801_adjust
+	/* 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	e801_adjust
+	call	patch_1m_16m
 	xchgw	%ax, %cx
 	xchgw	%bx, %dx
-	jmp	intercept_int15_exit
+	popw	%ds
-	
+	/* Restore flags returned by previous handler and return */
-	/* %ax = #KB from 1MB+, %bx = #64KB from 16MB+
+	popfw
-	 * Return with modified values in %ax, %bx.  Preserver other regs.
+	lret	$2
-	 */
+	.size int15_e801, . - int15_e801
-e801_adjust:
-	pushw	%di
-	pushl	%ecx
-	pushl	%eax
-	movw	$1, %di			/* "truncate only high end" flag */
-
-	/* Truncate #64KB from 16MB+ as appropriate */
-	movw	%bx, %cx		/* (no need to zero high word) */
-	shll	$16, %ecx		/* %ecx = length in bytes */
-	movl	$(1<<24), %eax		/* 16MB start address */
-	call	exclude_hidden_memory_ranges
-	shrl	$16, %ecx		/* %cx = updated length in 64KB */
-	movw	%cx, %bx		/* Return in %bx */
-	
-	/* Truncate #KB from 1MB+ as appropriate */
-	popw	%cx			/* Orig. %ax (high word already 0) */
-	shll	$10, %ecx		/* %ecx = length in bytes */
-	shrl	$4, %eax		/* 1MB start address */
-	call	exclude_hidden_memory_ranges
-	shrl	$10, %ecx		/* %cx = updated length in KB */
-	pushw	%cx			/* Will be picked up in %eax */
 	
-	popl	%eax
-	popl	%ecx
-	popw	%di
-	ret
-
 /****************************************************************************
- * Intercept INT 15,88 calls and remove the hidden memory ranges
+ * INT 15,88 handler
- * from the resulting memory map.
  ****************************************************************************
  */
-intercept_88:
+	.section ".text16"
-	pushw	%bx			/* E801 adjust, ignore %bx */
+int15_88:
-	call	e801_adjust
+	/* Call previous handler */
-	popw	%bx
+	pushfw
-	jmp	intercept_int15_exit
+	lcall	*%cs:int15_vector
-
+	pushfw
-	.globl	e820mangler_end
+	/* Edit result */
-e820mangler_end:
+	pushw	%ds
-
+	pushw	%cs:rm_ds
-	.globl	_e820mangler_size
+	popw	%ds
-	.equ	_e820mangler_size, e820mangler_end - e820mangler
+	call	patch_1m
-	.globl	e820mangler_size
+	popw	%ds
-e820mangler_size:
+	/* Restore flags returned by previous handler and return */
-	.word	_e820mangler_size
+	popfw
-
+	lret	$2
-#else
+	.size int15_88, . - int15_88
-
+		
-	.globl	_e820mangler_size
+/****************************************************************************
-	.equ	_e820mangler_size, 0
+ * 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
 	
-#endif /* CODE16 */
+	.section ".text16.data"
+	.globl int15_vector
+int15_vector:
+	.long 0
+	.size int15_vector, . - int15_vector