Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b79cd8f1 authored by Yinghai Lu's avatar Yinghai Lu Committed by Thomas Gleixner
Browse files

x86: make e820.c to have common functions 



remove the duplicated copy of these functions.

Signed-off-by: default avatarYinghai Lu <yhlu.kernel@gmail.com>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent 833e78bf

arch/x86/kernel/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ obj-y += setup_$(BITS).o i8259_$(BITS).o setup.o 
obj-$(CONFIG_X86_32)	+= sys_i386_32.o i386_ksyms_32.o

obj-$(CONFIG_X86_64)	+= sys_x86_64.o x8664_ksyms_64.o

obj-$(CONFIG_X86_64)	+= syscall_64.o vsyscall_64.o setup64.o

obj-y			+= bootflag.o e820_$(BITS).o

obj-y			+= bootflag.o e820_$(BITS).o e820.o

obj-y			+= pci-dma.o quirks.o i8237.o topology.o kdebugfs.o

obj-y			+= alternative.o i8253.o pci-nommu.o

obj-$(CONFIG_X86_64)	+= bugs_64.o

arch/x86/kernel/e820.c

0 → 100644
+475 −0
Original line number Diff line number Diff line 
/*

 * Handle the memory map.

 * The functions here do the job until bootmem takes over.

 *

 *  Getting sanitize_e820_map() in sync with i386 version by applying change:

 *  -  Provisions for empty E820 memory regions (reported by certain BIOSes).

 *     Alex Achenbach <xela@slit.de>, December 2002.

 *  Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>

 *

 */

#include <linux/kernel.h>

#include <linux/types.h>

#include <linux/init.h>

#include <linux/bootmem.h>

#include <linux/ioport.h>

#include <linux/string.h>

#include <linux/kexec.h>

#include <linux/module.h>

#include <linux/mm.h>

#include <linux/pfn.h>



#include <asm/pgtable.h>

#include <asm/page.h>

#include <asm/e820.h>

#include <asm/setup.h>



struct e820map e820;



/* For PCI or other memory-mapped resources */

unsigned long pci_mem_start = 0xaeedbabe;

#ifdef CONFIG_PCI

EXPORT_SYMBOL(pci_mem_start);

#endif



/*

 * This function checks if any part of the range <start,end> is mapped

 * with type.

 */

int

e820_any_mapped(u64 start, u64 end, unsigned type)

{

	int i;



	for (i = 0; i < e820.nr_map; i++) {

		struct e820entry *ei = &e820.map[i];



		if (type && ei->type != type)

			continue;

		if (ei->addr >= end || ei->addr + ei->size <= start)

			continue;

		return 1;

	}

	return 0;

}

EXPORT_SYMBOL_GPL(e820_any_mapped);



/*

 * This function checks if the entire range <start,end> is mapped with type.

 *

 * Note: this function only works correct if the e820 table is sorted and

 * not-overlapping, which is the case

 */

int __init e820_all_mapped(u64 start, u64 end, unsigned type)

{

	int i;



	for (i = 0; i < e820.nr_map; i++) {

		struct e820entry *ei = &e820.map[i];



		if (type && ei->type != type)

			continue;

		/* is the region (part) in overlap with the current region ?*/

		if (ei->addr >= end || ei->addr + ei->size <= start)

			continue;



		/* if the region is at the beginning of <start,end> we move

		 * start to the end of the region since it's ok until there

		 */

		if (ei->addr <= start)

			start = ei->addr + ei->size;

		/*

		 * if start is now at or beyond end, we're done, full

		 * coverage

		 */

		if (start >= end)

			return 1;

	}

	return 0;

}



/*

 * Add a memory region to the kernel e820 map.

 */

void __init add_memory_region(u64 start, u64 size, int type)

{

	int x = e820.nr_map;



	if (x == E820MAX) {

		printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");

		return;

	}



	e820.map[x].addr = start;

	e820.map[x].size = size;

	e820.map[x].type = type;

	e820.nr_map++;

}



void __init e820_print_map(char *who)

{

	int i;



	for (i = 0; i < e820.nr_map; i++) {

		printk(KERN_INFO " %s: %016Lx - %016Lx ", who,

		       (unsigned long long) e820.map[i].addr,

		       (unsigned long long)

		       (e820.map[i].addr + e820.map[i].size));

		switch (e820.map[i].type) {

		case E820_RAM:

			printk(KERN_CONT "(usable)\n");

			break;

		case E820_RESERVED:

			printk(KERN_CONT "(reserved)\n");

			break;

		case E820_ACPI:

			printk(KERN_CONT "(ACPI data)\n");

			break;

		case E820_NVS:

			printk(KERN_CONT "(ACPI NVS)\n");

			break;

		default:

			printk(KERN_CONT "type %u\n", e820.map[i].type);

			break;

		}

	}

}



/*

 * Sanitize the BIOS e820 map.

 *

 * Some e820 responses include overlapping entries. The following

 * replaces the original e820 map with a new one, removing overlaps.

 *

 */

int __init sanitize_e820_map(struct e820entry *biosmap, char *pnr_map)

{

	struct change_member {

		struct e820entry *pbios; /* pointer to original bios entry */

		unsigned long long addr; /* address for this change point */

	};

	static struct change_member change_point_list[2*E820MAX] __initdata;

	static struct change_member *change_point[2*E820MAX] __initdata;

	static struct e820entry *overlap_list[E820MAX] __initdata;

	static struct e820entry new_bios[E820MAX] __initdata;

	struct change_member *change_tmp;

	unsigned long current_type, last_type;

	unsigned long long last_addr;

	int chgidx, still_changing;

	int overlap_entries;

	int new_bios_entry;

	int old_nr, new_nr, chg_nr;

	int i;



	/*

		Visually we're performing the following

		(1,2,3,4 = memory types)...



		Sample memory map (w/overlaps):

		   ____22__________________

		   ______________________4_

		   ____1111________________

		   _44_____________________

		   11111111________________

		   ____________________33__

		   ___________44___________

		   __________33333_________

		   ______________22________

		   ___________________2222_

		   _________111111111______

		   _____________________11_

		   _________________4______



		Sanitized equivalent (no overlap):

		   1_______________________

		   _44_____________________

		   ___1____________________

		   ____22__________________

		   ______11________________

		   _________1______________

		   __________3_____________

		   ___________44___________

		   _____________33_________

		   _______________2________

		   ________________1_______

		   _________________4______

		   ___________________2____

		   ____________________33__

		   ______________________4_

	*/



	/* if there's only one memory region, don't bother */

	if (*pnr_map < 2)

		return -1;



	old_nr = *pnr_map;



	/* bail out if we find any unreasonable addresses in bios map */

	for (i = 0; i < old_nr; i++)

		if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)

			return -1;



	/* create pointers for initial change-point information (for sorting) */

	for (i = 0; i < 2 * old_nr; i++)

		change_point[i] = &change_point_list[i];



	/* record all known change-points (starting and ending addresses),

	   omitting those that are for empty memory regions */

	chgidx = 0;

	for (i = 0; i < old_nr; i++)	{

		if (biosmap[i].size != 0) {

			change_point[chgidx]->addr = biosmap[i].addr;

			change_point[chgidx++]->pbios = &biosmap[i];

			change_point[chgidx]->addr = biosmap[i].addr +

				biosmap[i].size;

			change_point[chgidx++]->pbios = &biosmap[i];

		}

	}

	chg_nr = chgidx;



	/* sort change-point list by memory addresses (low -> high) */

	still_changing = 1;

	while (still_changing)	{

		still_changing = 0;

		for (i = 1; i < chg_nr; i++)  {

			unsigned long long curaddr, lastaddr;

			unsigned long long curpbaddr, lastpbaddr;



			curaddr = change_point[i]->addr;

			lastaddr = change_point[i - 1]->addr;

			curpbaddr = change_point[i]->pbios->addr;

			lastpbaddr = change_point[i - 1]->pbios->addr;



			/*

			 * swap entries, when:

			 *

			 * curaddr > lastaddr or

			 * curaddr == lastaddr and curaddr == curpbaddr and

			 * lastaddr != lastpbaddr

			 */

			if (curaddr < lastaddr ||

			    (curaddr == lastaddr && curaddr == curpbaddr &&

			     lastaddr != lastpbaddr)) {

				change_tmp = change_point[i];

				change_point[i] = change_point[i-1];

				change_point[i-1] = change_tmp;

				still_changing = 1;

			}

		}

	}



	/* create a new bios memory map, removing overlaps */

	overlap_entries = 0;	 /* number of entries in the overlap table */

	new_bios_entry = 0;	 /* index for creating new bios map entries */

	last_type = 0;		 /* start with undefined memory type */

	last_addr = 0;		 /* start with 0 as last starting address */



	/* loop through change-points, determining affect on the new bios map */

	for (chgidx = 0; chgidx < chg_nr; chgidx++) {

		/* keep track of all overlapping bios entries */

		if (change_point[chgidx]->addr ==

		    change_point[chgidx]->pbios->addr) {

			/*

			 * add map entry to overlap list (> 1 entry

			 * implies an overlap)

			 */

			overlap_list[overlap_entries++] =

				change_point[chgidx]->pbios;

		} else {

			/*

			 * remove entry from list (order independent,

			 * so swap with last)

			 */

			for (i = 0; i < overlap_entries; i++) {

				if (overlap_list[i] ==

				    change_point[chgidx]->pbios)

					overlap_list[i] =

						overlap_list[overlap_entries-1];

			}

			overlap_entries--;

		}

		/*

		 * if there are overlapping entries, decide which

		 * "type" to use (larger value takes precedence --

		 * 1=usable, 2,3,4,4+=unusable)

		 */

		current_type = 0;

		for (i = 0; i < overlap_entries; i++)

			if (overlap_list[i]->type > current_type)

				current_type = overlap_list[i]->type;

		/*

		 * continue building up new bios map based on this

		 * information

		 */

		if (current_type != last_type)	{

			if (last_type != 0)	 {

				new_bios[new_bios_entry].size =

					change_point[chgidx]->addr - last_addr;

				/*

				 * move forward only if the new size

				 * was non-zero

				 */

				if (new_bios[new_bios_entry].size != 0)

					/*

					 * no more space left for new

					 * bios entries ?

					 */

					if (++new_bios_entry >= E820MAX)

						break;

			}

			if (current_type != 0)	{

				new_bios[new_bios_entry].addr =

					change_point[chgidx]->addr;

				new_bios[new_bios_entry].type = current_type;

				last_addr = change_point[chgidx]->addr;

			}

			last_type = current_type;

		}

	}

	/* retain count for new bios entries */

	new_nr = new_bios_entry;



	/* copy new bios mapping into original location */

	memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry));

	*pnr_map = new_nr;



	return 0;

}



/*

 * Copy the BIOS e820 map into a safe place.

 *

 * Sanity-check it while we're at it..

 *

 * If we're lucky and live on a modern system, the setup code

 * will have given us a memory map that we can use to properly

 * set up memory.  If we aren't, we'll fake a memory map.

 */

int __init copy_e820_map(struct e820entry *biosmap, int nr_map)

{

	/* Only one memory region (or negative)? Ignore it */

	if (nr_map < 2)

		return -1;



	do {

		u64 start = biosmap->addr;

		u64 size = biosmap->size;

		u64 end = start + size;

		u32 type = biosmap->type;



		/* Overflow in 64 bits? Ignore the memory map. */

		if (start > end)

			return -1;



		add_memory_region(start, size, type);

	} while (biosmap++, --nr_map);

	return 0;

}



u64 __init update_memory_range(u64 start, u64 size, unsigned old_type,

				unsigned new_type)

{

	int i;

	u64 real_updated_size = 0;



	BUG_ON(old_type == new_type);



	for (i = 0; i < e820.nr_map; i++) {

		struct e820entry *ei = &e820.map[i];

		u64 final_start, final_end;

		if (ei->type != old_type)

			continue;

		/* totally covered? */

		if (ei->addr >= start &&

		    (ei->addr + ei->size) <= (start + size)) {

			ei->type = new_type;

			real_updated_size += ei->size;

			continue;

		}

		/* partially covered */

		final_start = max(start, ei->addr);

		final_end = min(start + size, ei->addr + ei->size);

		if (final_start >= final_end)

			continue;

		add_memory_region(final_start, final_end - final_start,

					 new_type);

		real_updated_size += final_end - final_start;

	}

	return real_updated_size;

}



void __init update_e820(void)

{

	u8 nr_map;



	nr_map = e820.nr_map;

	if (sanitize_e820_map(e820.map, &nr_map))

		return;

	e820.nr_map = nr_map;

	printk(KERN_INFO "modified physical RAM map:\n");

	e820_print_map("modified");

}



/*

 * Search for the biggest gap in the low 32 bits of the e820

 * memory space.  We pass this space to PCI to assign MMIO resources

 * for hotplug or unconfigured devices in.

 * Hopefully the BIOS let enough space left.

 */

__init void e820_setup_gap(void)

{

	unsigned long gapstart, gapsize, round;

	unsigned long long last;

	int i;

	int found = 0;



	last = 0x100000000ull;

	gapstart = 0x10000000;

	gapsize = 0x400000;

	i = e820.nr_map;

	while (--i >= 0) {

		unsigned long long start = e820.map[i].addr;

		unsigned long long end = start + e820.map[i].size;



		/*

		 * Since "last" is at most 4GB, we know we'll

		 * fit in 32 bits if this condition is true

		 */

		if (last > end) {

			unsigned long gap = last - end;



			if (gap > gapsize) {

				gapsize = gap;

				gapstart = end;

				found = 1;

			}

		}

		if (start < last)

			last = start;

	}



#ifdef CONFIG_X86_64

	if (!found) {

		gapstart = (end_pfn << PAGE_SHIFT) + 1024*1024;

		printk(KERN_ERR "PCI: Warning: Cannot find a gap in the 32bit "

		       "address range\n"

		       KERN_ERR "PCI: Unassigned devices with 32bit resource "

		       "registers may break!\n");

	}

#endif



	/*

	 * See how much we want to round up: start off with

	 * rounding to the next 1MB area.

	 */

	round = 0x100000;

	while ((gapsize >> 4) > round)

		round += round;

	/* Fun with two's complement */

	pci_mem_start = (gapstart + round) & -round;



	printk(KERN_INFO

	       "Allocating PCI resources starting at %lx (gap: %lx:%lx)\n",

	       pci_mem_start, gapstart, gapsize);

}

arch/x86/kernel/e820_32.c

+5 −406

File changed.

Preview size limit exceeded, changes collapsed.

arch/x86/kernel/e820_64.c

+0 −444
Original line number Diff line number Diff line
@@ -29,8 +29,6 @@ 
#include <asm/kdebug.h>

#include <asm/trampoline.h>



struct e820map e820;



/*

 * PFN of last memory page.

 */
@@ -176,62 +174,6 @@ again: 
	}

	return changed;

}

/*

 * This function checks if any part of the range <start,end> is mapped

 * with type.

 */

int

e820_any_mapped(unsigned long start, unsigned long end, unsigned type)

{

	int i;



	for (i = 0; i < e820.nr_map; i++) {

		struct e820entry *ei = &e820.map[i];



		if (type && ei->type != type)

			continue;

		if (ei->addr >= end || ei->addr + ei->size <= start)

			continue;

		return 1;

	}

	return 0;

}

EXPORT_SYMBOL_GPL(e820_any_mapped);



/*

 * This function checks if the entire range <start,end> is mapped with type.

 *

 * Note: this function only works correct if the e820 table is sorted and

 * not-overlapping, which is the case

 */

int __init e820_all_mapped(unsigned long start, unsigned long end,

			   unsigned type)

{

	int i;



	for (i = 0; i < e820.nr_map; i++) {

		struct e820entry *ei = &e820.map[i];



		if (type && ei->type != type)

			continue;

		/* is the region (part) in overlap with the current region ?*/

		if (ei->addr >= end || ei->addr + ei->size <= start)

			continue;



		/* if the region is at the beginning of <start,end> we move

		 * start to the end of the region since it's ok until there

		 */

		if (ei->addr <= start)

			start = ei->addr + ei->size;

		/*

		 * if start is now at or beyond end, we're done, full

		 * coverage

		 */

		if (start >= end)

			return 1;

	}

	return 0;

}



/*

 * Find a free area with specified alignment in a specific range.
@@ -434,24 +376,6 @@ e820_register_active_regions(int nid, unsigned long start_pfn, 
			add_active_range(nid, ei_startpfn, ei_endpfn);

}



/*

 * Add a memory region to the kernel e820 map.

 */

void __init add_memory_region(unsigned long start, unsigned long size, int type)

{

	int x = e820.nr_map;



	if (x == E820MAX) {

		printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");

		return;

	}



	e820.map[x].addr = start;

	e820.map[x].size = size;

	e820.map[x].type = type;

	e820.nr_map++;

}



/*

 * Find the hole size (in bytes) in the memory range.

 * @start: starting address of the memory range to scan
@@ -473,266 +397,6 @@ unsigned long __init e820_hole_size(unsigned long start, unsigned long end) 
	return end - start - (ram << PAGE_SHIFT);

}



static void __init e820_print_map(char *who)

{

	int i;



	for (i = 0; i < e820.nr_map; i++) {

		printk(KERN_INFO " %s: %016Lx - %016Lx ", who,

		       (unsigned long long) e820.map[i].addr,

		       (unsigned long long)

		       (e820.map[i].addr + e820.map[i].size));

		switch (e820.map[i].type) {

		case E820_RAM:

			printk(KERN_CONT "(usable)\n");

			break;

		case E820_RESERVED:

			printk(KERN_CONT "(reserved)\n");

			break;

		case E820_ACPI:

			printk(KERN_CONT "(ACPI data)\n");

			break;

		case E820_NVS:

			printk(KERN_CONT "(ACPI NVS)\n");

			break;

		default:

			printk(KERN_CONT "type %u\n", e820.map[i].type);

			break;

		}

	}

}



/*

 * Sanitize the BIOS e820 map.

 *

 * Some e820 responses include overlapping entries. The following

 * replaces the original e820 map with a new one, removing overlaps.

 *

 */

static int __init sanitize_e820_map(struct e820entry *biosmap, char *pnr_map)

{

	struct change_member {

		struct e820entry *pbios; /* pointer to original bios entry */

		unsigned long long addr; /* address for this change point */

	};

	static struct change_member change_point_list[2*E820MAX] __initdata;

	static struct change_member *change_point[2*E820MAX] __initdata;

	static struct e820entry *overlap_list[E820MAX] __initdata;

	static struct e820entry new_bios[E820MAX] __initdata;

	struct change_member *change_tmp;

	unsigned long current_type, last_type;

	unsigned long long last_addr;

	int chgidx, still_changing;

	int overlap_entries;

	int new_bios_entry;

	int old_nr, new_nr, chg_nr;

	int i;



	/*

		Visually we're performing the following

		(1,2,3,4 = memory types)...



		Sample memory map (w/overlaps):

		   ____22__________________

		   ______________________4_

		   ____1111________________

		   _44_____________________

		   11111111________________

		   ____________________33__

		   ___________44___________

		   __________33333_________

		   ______________22________

		   ___________________2222_

		   _________111111111______

		   _____________________11_

		   _________________4______



		Sanitized equivalent (no overlap):

		   1_______________________

		   _44_____________________

		   ___1____________________

		   ____22__________________

		   ______11________________

		   _________1______________

		   __________3_____________

		   ___________44___________

		   _____________33_________

		   _______________2________

		   ________________1_______

		   _________________4______

		   ___________________2____

		   ____________________33__

		   ______________________4_

	*/



	/* if there's only one memory region, don't bother */

	if (*pnr_map < 2)

		return -1;



	old_nr = *pnr_map;



	/* bail out if we find any unreasonable addresses in bios map */

	for (i = 0; i < old_nr; i++)

		if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)

			return -1;



	/* create pointers for initial change-point information (for sorting) */

	for (i = 0; i < 2 * old_nr; i++)

		change_point[i] = &change_point_list[i];



	/* record all known change-points (starting and ending addresses),

	   omitting those that are for empty memory regions */

	chgidx = 0;

	for (i = 0; i < old_nr; i++)	{

		if (biosmap[i].size != 0) {

			change_point[chgidx]->addr = biosmap[i].addr;

			change_point[chgidx++]->pbios = &biosmap[i];

			change_point[chgidx]->addr = biosmap[i].addr +

				biosmap[i].size;

			change_point[chgidx++]->pbios = &biosmap[i];

		}

	}

	chg_nr = chgidx;



	/* sort change-point list by memory addresses (low -> high) */

	still_changing = 1;

	while (still_changing)	{

		still_changing = 0;

		for (i = 1; i < chg_nr; i++)  {

			unsigned long long curaddr, lastaddr;

			unsigned long long curpbaddr, lastpbaddr;



			curaddr = change_point[i]->addr;

			lastaddr = change_point[i - 1]->addr;

			curpbaddr = change_point[i]->pbios->addr;

			lastpbaddr = change_point[i - 1]->pbios->addr;



			/*

			 * swap entries, when:

			 *

			 * curaddr > lastaddr or

			 * curaddr == lastaddr and curaddr == curpbaddr and

			 * lastaddr != lastpbaddr

			 */

			if (curaddr < lastaddr ||

			    (curaddr == lastaddr && curaddr == curpbaddr &&

			     lastaddr != lastpbaddr)) {

				change_tmp = change_point[i];

				change_point[i] = change_point[i-1];

				change_point[i-1] = change_tmp;

				still_changing = 1;

			}

		}

	}



	/* create a new bios memory map, removing overlaps */

	overlap_entries = 0;	 /* number of entries in the overlap table */

	new_bios_entry = 0;	 /* index for creating new bios map entries */

	last_type = 0;		 /* start with undefined memory type */

	last_addr = 0;		 /* start with 0 as last starting address */



	/* loop through change-points, determining affect on the new bios map */

	for (chgidx = 0; chgidx < chg_nr; chgidx++) {

		/* keep track of all overlapping bios entries */

		if (change_point[chgidx]->addr ==

		    change_point[chgidx]->pbios->addr) {

			/*

			 * add map entry to overlap list (> 1 entry

			 * implies an overlap)

			 */

			overlap_list[overlap_entries++] =

				change_point[chgidx]->pbios;

		} else {

			/*

			 * remove entry from list (order independent,

			 * so swap with last)

			 */

			for (i = 0; i < overlap_entries; i++) {

				if (overlap_list[i] ==

				    change_point[chgidx]->pbios)

					overlap_list[i] =

						overlap_list[overlap_entries-1];

			}

			overlap_entries--;

		}

		/*

		 * if there are overlapping entries, decide which

		 * "type" to use (larger value takes precedence --

		 * 1=usable, 2,3,4,4+=unusable)

		 */

		current_type = 0;

		for (i = 0; i < overlap_entries; i++)

			if (overlap_list[i]->type > current_type)

				current_type = overlap_list[i]->type;

		/*

		 * continue building up new bios map based on this

		 * information

		 */

		if (current_type != last_type)	{

			if (last_type != 0)	 {

				new_bios[new_bios_entry].size =

					change_point[chgidx]->addr - last_addr;

				/*

				 * move forward only if the new size

				 * was non-zero

				 */

				if (new_bios[new_bios_entry].size != 0)

					/*

					 * no more space left for new

					 * bios entries ?

					 */

					if (++new_bios_entry >= E820MAX)

						break;

			}

			if (current_type != 0)	{

				new_bios[new_bios_entry].addr =

					change_point[chgidx]->addr;

				new_bios[new_bios_entry].type = current_type;

				last_addr = change_point[chgidx]->addr;

			}

			last_type = current_type;

		}

	}

	/* retain count for new bios entries */

	new_nr = new_bios_entry;



	/* copy new bios mapping into original location */

	memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry));

	*pnr_map = new_nr;



	return 0;

}



/*

 * Copy the BIOS e820 map into a safe place.

 *

 * Sanity-check it while we're at it..

 *

 * If we're lucky and live on a modern system, the setup code

 * will have given us a memory map that we can use to properly

 * set up memory.  If we aren't, we'll fake a memory map.

 */

static int __init copy_e820_map(struct e820entry *biosmap, int nr_map)

{

	/* Only one memory region (or negative)? Ignore it */

	if (nr_map < 2)

		return -1;



	do {

		u64 start = biosmap->addr;

		u64 size = biosmap->size;

		u64 end = start + size;

		u32 type = biosmap->type;



		/* Overflow in 64 bits? Ignore the memory map. */

		if (start > end)

			return -1;



		add_memory_region(start, size, type);

	} while (biosmap++, --nr_map);

	return 0;

}



static void early_panic(char *msg)

{

	early_printk(msg);
@@ -829,114 +493,6 @@ void __init finish_e820_parsing(void) 
	}

}



u64 __init update_memory_range(u64 start, u64 size, unsigned old_type,

				unsigned new_type)

{

	int i;

	u64 real_updated_size = 0;



	BUG_ON(old_type == new_type);



	for (i = 0; i < e820.nr_map; i++) {

		struct e820entry *ei = &e820.map[i];

		u64 final_start, final_end;

		if (ei->type != old_type)

			continue;

		/* totally covered? */

		if (ei->addr >= start &&

		    (ei->addr + ei->size) <= (start + size)) {

			ei->type = new_type;

			real_updated_size += ei->size;

			continue;

		}

		/* partially covered */

		final_start = max(start, ei->addr);

		final_end = min(start + size, ei->addr + ei->size);

		if (final_start >= final_end)

			continue;

		add_memory_region(final_start, final_end - final_start,

					 new_type);

		real_updated_size += final_end - final_start;

	}

	return real_updated_size;

}



void __init update_e820(void)

{

	u8 nr_map;



	nr_map = e820.nr_map;

	if (sanitize_e820_map(e820.map, &nr_map))

		return;

	e820.nr_map = nr_map;

	printk(KERN_INFO "modified physical RAM map:\n");

	e820_print_map("modified");

}



unsigned long pci_mem_start = 0xaeedbabe;

EXPORT_SYMBOL(pci_mem_start);



/*

 * Search for the biggest gap in the low 32 bits of the e820

 * memory space.  We pass this space to PCI to assign MMIO resources

 * for hotplug or unconfigured devices in.

 * Hopefully the BIOS let enough space left.

 */

__init void e820_setup_gap(void)

{

	unsigned long gapstart, gapsize, round;

	unsigned long last;

	int i;

	int found = 0;



	last = 0x100000000ull;

	gapstart = 0x10000000;

	gapsize = 0x400000;

	i = e820.nr_map;

	while (--i >= 0) {

		unsigned long long start = e820.map[i].addr;

		unsigned long long end = start + e820.map[i].size;



		/*

		 * Since "last" is at most 4GB, we know we'll

		 * fit in 32 bits if this condition is true

		 */

		if (last > end) {

			unsigned long gap = last - end;



			if (gap > gapsize) {

				gapsize = gap;

				gapstart = end;

				found = 1;

			}

		}

		if (start < last)

			last = start;

	}



	if (!found) {

		gapstart = (end_pfn << PAGE_SHIFT) + 1024*1024;

		printk(KERN_ERR "PCI: Warning: Cannot find a gap in the 32bit "

		       "address range\n"

		       KERN_ERR "PCI: Unassigned devices with 32bit resource "

		       "registers may break!\n");

	}



	/*

	 * See how much we want to round up: start off with

	 * rounding to the next 1MB area.

	 */

	round = 0x100000;

	while ((gapsize >> 4) > round)

		round += round;

	/* Fun with two's complement */

	pci_mem_start = (gapstart + round) & -round;



	printk(KERN_INFO

	       "Allocating PCI resources starting at %lx (gap: %lx:%lx)\n",

	       pci_mem_start, gapstart, gapsize);

}



int __init arch_get_ram_range(int slot, u64 *addr, u64 *size)

{

	int i;

arch/x86/kernel/setup_32.c

+1 −1
Original line number Diff line number Diff line
@@ -875,7 +875,7 @@ void __init setup_arch(char **cmdline_p) 
		get_smp_config();

#endif



	e820_register_memory();

	e820_setup_gap();

	e820_mark_nosave_regions();



#ifdef CONFIG_VT