[deliverable/linux.git] / arch / x86_64 / mm / srat.c

/*
 * ACPI 3.0 based NUMA setup
 * Copyright 2004 Andi Kleen, SuSE Labs.
 *
 * Reads the ACPI SRAT table to figure out what memory belongs to which CPUs.
 *
 * Called from acpi_numa_init while reading the SRAT and SLIT tables.
 * Assumes all memory regions belonging to a single proximity domain
 * are in one chunk. Holes between them will be included in the node.
 */

#include <linux/kernel.h>
#include <linux/acpi.h>
#include <linux/mmzone.h>
#include <linux/bitmap.h>
#include <linux/module.h>
#include <linux/topology.h>
#include <linux/bootmem.h>
#include <linux/mm.h>
#include <asm/proto.h>
#include <asm/numa.h>
#include <asm/e820.h>

int acpi_numa __initdata;

static struct acpi_table_slit *acpi_slit;

static nodemask_t nodes_parsed __initdata;
static struct bootnode nodes[MAX_NUMNODES] __initdata;
static struct bootnode nodes_add[MAX_NUMNODES] __initdata;
static int found_add_area __initdata;
int hotadd_percent __initdata = 0;

/* Too small nodes confuse the VM badly. Usually they result
   from BIOS bugs. */
#define NODE_MIN_SIZE (4*1024*1024)

static __init int setup_node(int pxm)
{
	return acpi_map_pxm_to_node(pxm);
}

static __init int conflicting_nodes(unsigned long start, unsigned long end)
{
	int i;
	for_each_node_mask(i, nodes_parsed) {
		struct bootnode *nd = &nodes[i];
		if (nd->start == nd->end)
			continue;
		if (nd->end > start && nd->start < end)
			return i;
		if (nd->end == end && nd->start == start)
			return i;
	}
	return -1;
}

static __init void cutoff_node(int i, unsigned long start, unsigned long end)
{
	struct bootnode *nd = &nodes[i];

	if (found_add_area)
		return;

	if (nd->start < start) {
		nd->start = start;
		if (nd->end < nd->start)
			nd->start = nd->end;
	}
	if (nd->end > end) {
		nd->end = end;
		if (nd->start > nd->end)
			nd->start = nd->end;
	}
}

static __init void bad_srat(void)
{
	int i;
	printk(KERN_ERR "SRAT: SRAT not used.\n");
	acpi_numa = -1;
	found_add_area = 0;
	for (i = 0; i < MAX_LOCAL_APIC; i++)
		apicid_to_node[i] = NUMA_NO_NODE;
	for (i = 0; i < MAX_NUMNODES; i++)
		nodes_add[i].start = nodes[i].end = 0;
	remove_all_active_ranges();
}

static __init inline int srat_disabled(void)
{
	return numa_off || acpi_numa < 0;
}

/*
 * A lot of BIOS fill in 10 (= no distance) everywhere. This messes
 * up the NUMA heuristics which wants the local node to have a smaller
 * distance than the others.
 * Do some quick checks here and only use the SLIT if it passes.
 */
static __init int slit_valid(struct acpi_table_slit *slit)
{
	int i, j;
	int d = slit->localities;
	for (i = 0; i < d; i++) {
		for (j = 0; j < d; j++)  {
			u8 val = slit->entry[d*i + j];
			if (i == j) {
				if (val != 10)
					return 0;
			} else if (val <= 10)
				return 0;
		}
	}
	return 1;
}

/* Callback for SLIT parsing */
void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
{
	if (!slit_valid(slit)) {
		printk(KERN_INFO "ACPI: SLIT table looks invalid. Not used.\n");
		return;
	}
	acpi_slit = slit;
}

/* Callback for Proximity Domain -> LAPIC mapping */
void __init
acpi_numa_processor_affinity_init(struct acpi_table_processor_affinity *pa)
{
	int pxm, node;
	if (srat_disabled())
		return;
	if (pa->header.length != sizeof(struct acpi_table_processor_affinity)) {
		bad_srat();
		return;
	}
	if (pa->flags.enabled == 0)
		return;
	pxm = pa->proximity_domain;
	node = setup_node(pxm);
	if (node < 0) {
		printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
		bad_srat();
		return;
	}
	apicid_to_node[pa->apic_id] = node;
	acpi_numa = 1;
	printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
	       pxm, pa->apic_id, node);
}

#ifdef CONFIG_MEMORY_HOTPLUG_RESERVE
/*
 * Protect against too large hotadd areas that would fill up memory.
 */
static int hotadd_enough_memory(struct bootnode *nd)
{
	static unsigned long allocated;
	static unsigned long last_area_end;
	unsigned long pages = (nd->end - nd->start) >> PAGE_SHIFT;
	long mem = pages * sizeof(struct page);
	unsigned long addr;
	unsigned long allowed;
	unsigned long oldpages = pages;

	if (mem < 0)
		return 0;
	allowed = (end_pfn - absent_pages_in_range(0, end_pfn)) * PAGE_SIZE;
	allowed = (allowed / 100) * hotadd_percent;
	if (allocated + mem > allowed) {
		unsigned long range;
		/* Give them at least part of their hotadd memory upto hotadd_percent
		   It would be better to spread the limit out
		   over multiple hotplug areas, but that is too complicated
		   right now */
		if (allocated >= allowed)
			return 0;
		range = allowed - allocated;
		pages = (range / PAGE_SIZE);
		mem = pages * sizeof(struct page);
		nd->end = nd->start + range;
	}
	/* Not completely fool proof, but a good sanity check */
	addr = find_e820_area(last_area_end, end_pfn<<PAGE_SHIFT, mem);
	if (addr == -1UL)
		return 0;
	if (pages != oldpages)
		printk(KERN_NOTICE "SRAT: Hotadd area limited to %lu bytes\n",
			pages << PAGE_SHIFT);
	last_area_end = addr + mem;
	allocated += mem;
	return 1;
}

static int update_end_of_memory(unsigned long end)
{
	found_add_area = 1;
	if ((end >> PAGE_SHIFT) > end_pfn)
		end_pfn = end >> PAGE_SHIFT;
	return 1;
}

static inline int save_add_info(void)
{
	return hotadd_percent > 0;
}
#else
int update_end_of_memory(unsigned long end) {return 0;}
static int hotadd_enough_memory(struct bootnode *nd) {return 1;}
#ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
static inline int save_add_info(void) {return 1;}
#else
static inline int save_add_info(void) {return 0;}
#endif
#endif
/*
 * Update nodes_add and decide if to include add are in the zone.
 * Both SPARSE and RESERVE need nodes_add infomation.
 * This code supports one contigious hot add area per node.
 */
static int reserve_hotadd(int node, unsigned long start, unsigned long end)
{
	unsigned long s_pfn = start >> PAGE_SHIFT;
	unsigned long e_pfn = end >> PAGE_SHIFT;
	int ret = 0, changed = 0;
	struct bootnode *nd = &nodes_add[node];

	/* I had some trouble with strange memory hotadd regions breaking
	   the boot. Be very strict here and reject anything unexpected.
	   If you want working memory hotadd write correct SRATs.

	   The node size check is a basic sanity check to guard against
	   mistakes */
	if ((signed long)(end - start) < NODE_MIN_SIZE) {
		printk(KERN_ERR "SRAT: Hotplug area too small\n");
		return -1;
	}

	/* This check might be a bit too strict, but I'm keeping it for now. */
	if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
		printk(KERN_ERR
			"SRAT: Hotplug area %lu -> %lu has existing memory\n",
			s_pfn, e_pfn);
		return -1;
	}

	if (!hotadd_enough_memory(&nodes_add[node]))  {
		printk(KERN_ERR "SRAT: Hotplug area too large\n");
		return -1;
	}

	/* Looks good */

	if (nd->start == nd->end) {
 		nd->start = start;
 		nd->end = end;
		changed = 1;
 	} else {
 		if (nd->start == end) {
 			nd->start = start;
			changed = 1;
		}
 		if (nd->end == start) {
 			nd->end = end;
			changed = 1;
		}
		if (!changed)
			printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
 	}

	ret = update_end_of_memory(nd->end);

	if (changed)
	 	printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
	return ret;
}

/* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
void __init
acpi_numa_memory_affinity_init(struct acpi_table_memory_affinity *ma)
{
	struct bootnode *nd, oldnode;
	unsigned long start, end;
	int node, pxm;
	int i;

	if (srat_disabled())
		return;
	if (ma->header.length != sizeof(struct acpi_table_memory_affinity)) {
		bad_srat();
		return;
	}
	if (ma->flags.enabled == 0)
		return;
 	if (ma->flags.hot_pluggable && !save_add_info())
		return;
	start = ma->base_addr_lo | ((u64)ma->base_addr_hi << 32);
	end = start + (ma->length_lo | ((u64)ma->length_hi << 32));
	pxm = ma->proximity_domain;
	node = setup_node(pxm);
	if (node < 0) {
		printk(KERN_ERR "SRAT: Too many proximity domains.\n");
		bad_srat();
		return;
	}
	i = conflicting_nodes(start, end);
	if (i == node) {
		printk(KERN_WARNING
		"SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
			pxm, start, end, nodes[i].start, nodes[i].end);
	} else if (i >= 0) {
		printk(KERN_ERR
		       "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
		       pxm, start, end, node_to_pxm(i),
			nodes[i].start, nodes[i].end);
		bad_srat();
		return;
	}
	nd = &nodes[node];
	oldnode = *nd;
	if (!node_test_and_set(node, nodes_parsed)) {
		nd->start = start;
		nd->end = end;
	} else {
		if (start < nd->start)
			nd->start = start;
		if (nd->end < end)
			nd->end = end;
	}

	printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
	       nd->start, nd->end);
	e820_register_active_regions(node, nd->start >> PAGE_SHIFT,
						nd->end >> PAGE_SHIFT);
	push_node_boundaries(node, nd->start >> PAGE_SHIFT,
						nd->end >> PAGE_SHIFT);

 	if (ma->flags.hot_pluggable && !reserve_hotadd(node, start, end) < 0) {
		/* Ignore hotadd region. Undo damage */
		printk(KERN_NOTICE "SRAT: Hotplug region ignored\n");
		*nd = oldnode;
		if ((nd->start | nd->end) == 0)
			node_clear(node, nodes_parsed);
	}
}

/* Sanity check to catch more bad SRATs (they are amazingly common).
   Make sure the PXMs cover all memory. */
static int nodes_cover_memory(void)
{
	int i;
	unsigned long pxmram, e820ram;

	pxmram = 0;
	for_each_node_mask(i, nodes_parsed) {
		unsigned long s = nodes[i].start >> PAGE_SHIFT;
		unsigned long e = nodes[i].end >> PAGE_SHIFT;
		pxmram += e - s;
		pxmram -= absent_pages_in_range(s, e);
		if ((long)pxmram < 0)
			pxmram = 0;
	}

	e820ram = end_pfn - absent_pages_in_range(0, end_pfn);
	/* We seem to lose 3 pages somewhere. Allow a bit of slack. */
	if ((long)(e820ram - pxmram) >= 1*1024*1024) {
		printk(KERN_ERR
	"SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
			(pxmram << PAGE_SHIFT) >> 20,
			(e820ram << PAGE_SHIFT) >> 20);
		return 0;
	}
	return 1;
}

static void unparse_node(int node)
{
	int i;
	node_clear(node, nodes_parsed);
	for (i = 0; i < MAX_LOCAL_APIC; i++) {
		if (apicid_to_node[i] == node)
			apicid_to_node[i] = NUMA_NO_NODE;
	}
}

void __init acpi_numa_arch_fixup(void) {}

/* Use the information discovered above to actually set up the nodes. */
int __init acpi_scan_nodes(unsigned long start, unsigned long end)
{
	int i;

	/* First clean up the node list */
	for (i = 0; i < MAX_NUMNODES; i++) {
 		cutoff_node(i, start, end);
		if ((nodes[i].end - nodes[i].start) < NODE_MIN_SIZE) {
			unparse_node(i);
			node_set_offline(i);
		}
	}

	if (acpi_numa <= 0)
		return -1;

	if (!nodes_cover_memory()) {
		bad_srat();
		return -1;
	}

	memnode_shift = compute_hash_shift(nodes, MAX_NUMNODES);
	if (memnode_shift < 0) {
		printk(KERN_ERR
		     "SRAT: No NUMA node hash function found. Contact maintainer\n");
		bad_srat();
		return -1;
	}

	/* Finally register nodes */
	for_each_node_mask(i, nodes_parsed)
		setup_node_bootmem(i, nodes[i].start, nodes[i].end);
	/* Try again in case setup_node_bootmem missed one due
	   to missing bootmem */
	for_each_node_mask(i, nodes_parsed)
		if (!node_online(i))
			setup_node_bootmem(i, nodes[i].start, nodes[i].end);

	for (i = 0; i < NR_CPUS; i++) { 
		if (cpu_to_node[i] == NUMA_NO_NODE)
			continue;
		if (!node_isset(cpu_to_node[i], nodes_parsed))
			numa_set_node(i, NUMA_NO_NODE);
	}
	numa_init_array();
	return 0;
}

void __init srat_reserve_add_area(int nodeid)
{
	if (found_add_area && nodes_add[nodeid].end) {
		u64 total_mb;

		printk(KERN_INFO "SRAT: Reserving hot-add memory space "
				"for node %d at %Lx-%Lx\n",
			nodeid, nodes_add[nodeid].start, nodes_add[nodeid].end);
		total_mb = (nodes_add[nodeid].end - nodes_add[nodeid].start)
					>> PAGE_SHIFT;
		total_mb *= sizeof(struct page);
		total_mb >>= 20;
		printk(KERN_INFO "SRAT: This will cost you %Lu MB of "
				"pre-allocated memory.\n", (unsigned long long)total_mb);
		reserve_bootmem_node(NODE_DATA(nodeid), nodes_add[nodeid].start,
			       nodes_add[nodeid].end - nodes_add[nodeid].start);
	}
}

int __node_distance(int a, int b)
{
	int index;

	if (!acpi_slit)
		return a == b ? 10 : 20;
	index = acpi_slit->localities * node_to_pxm(a);
	return acpi_slit->entry[index + node_to_pxm(b)];
}

EXPORT_SYMBOL(__node_distance);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ACPI 3.0 based NUMA setup
	3	* Copyright 2004 Andi Kleen, SuSE Labs.
	4	*
	5	* Reads the ACPI SRAT table to figure out what memory belongs to which CPUs.
	6	*
	7	* Called from acpi_numa_init while reading the SRAT and SLIT tables.
	8	* Assumes all memory regions belonging to a single proximity domain
	9	* are in one chunk. Holes between them will be included in the node.
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/acpi.h>
	14	#include <linux/mmzone.h>
	15	#include <linux/bitmap.h>
	16	#include <linux/module.h>
	17	#include <linux/topology.h>
68a3a7fe AK	18	#include <linux/bootmem.h>
68a3a7fe AK	19	#include <linux/mm.h>
1da177e4 LT	20	#include <asm/proto.h>
1da177e4 LT	21	#include <asm/numa.h>
8a6fdd3e	22	#include <asm/e820.h>
1da177e4	23
c31fbb1a AK	24	int acpi_numa __initdata;
c31fbb1a AK	25
1da177e4 LT	26	static struct acpi_table_slit *acpi_slit;
	27
	28	static nodemask_t nodes_parsed __initdata;
abe059e7	29	static struct bootnode nodes[MAX_NUMNODES] __initdata;
68a3a7fe AK	30	static struct bootnode nodes_add[MAX_NUMNODES] __initdata;
68a3a7fe AK	31	static int found_add_area __initdata;
fad7906d	32	int hotadd_percent __initdata = 0;
1da177e4	33
9391a3f9 AK	34	/* Too small nodes confuse the VM badly. Usually they result
	35	from BIOS bugs. */
	36	#define NODE_MIN_SIZE (410241024)
	37
1da177e4 LT	38	static __init int setup_node(int pxm)
1da177e4 LT	39	{
762834e8	40	return acpi_map_pxm_to_node(pxm);
1da177e4 LT	41	}
	42
	43	static __init int conflicting_nodes(unsigned long start, unsigned long end)
	44	{
	45	int i;
4b6a455c	46	for_each_node_mask(i, nodes_parsed) {
abe059e7	47	struct bootnode *nd = &nodes[i];
1da177e4 LT	48	if (nd->start == nd->end)
	49	continue;
	50	if (nd->end > start && nd->start < end)
05d1fa4b	51	return i;
1da177e4	52	if (nd->end == end && nd->start == start)
05d1fa4b	53	return i;
1da177e4 LT	54	}
	55	return -1;
	56	}
	57
	58	static __init void cutoff_node(int i, unsigned long start, unsigned long end)
	59	{
abe059e7	60	struct bootnode *nd = &nodes[i];
68a3a7fe AK	61
	62	if (found_add_area)
	63	return;
	64
1da177e4 LT	65	if (nd->start < start) {
	66	nd->start = start;
	67	if (nd->end < nd->start)
	68	nd->start = nd->end;
	69	}
	70	if (nd->end > end) {
1da177e4 LT	71	nd->end = end;
	72	if (nd->start > nd->end)
	73	nd->start = nd->end;
	74	}
	75	}
	76
	77	static __init void bad_srat(void)
	78	{
2bce2b54	79	int i;
1da177e4 LT	80	printk(KERN_ERR "SRAT: SRAT not used.\n");
1da177e4 LT	81	acpi_numa = -1;
fad7906d	82	found_add_area = 0;
2bce2b54 AK	83	for (i = 0; i < MAX_LOCAL_APIC; i++)
2bce2b54 AK	84	apicid_to_node[i] = NUMA_NO_NODE;
68a3a7fe AK	85	for (i = 0; i < MAX_NUMNODES; i++)
68a3a7fe AK	86	nodes_add[i].start = nodes[i].end = 0;
5cb248ab	87	remove_all_active_ranges();
1da177e4 LT	88	}
	89
	90	static __init inline int srat_disabled(void)
	91	{
	92	return numa_off \|\| acpi_numa < 0;
	93	}
	94
1584b89c AK	95	/*
	96	* A lot of BIOS fill in 10 (= no distance) everywhere. This messes
	97	* up the NUMA heuristics which wants the local node to have a smaller
	98	* distance than the others.
	99	* Do some quick checks here and only use the SLIT if it passes.
	100	*/
	101	static __init int slit_valid(struct acpi_table_slit *slit)
	102	{
	103	int i, j;
	104	int d = slit->localities;
	105	for (i = 0; i < d; i++) {
	106	for (j = 0; j < d; j++) {
	107	u8 val = slit->entry[d*i + j];
	108	if (i == j) {
	109	if (val != 10)
	110	return 0;
	111	} else if (val <= 10)
	112	return 0;
	113	}
	114	}
	115	return 1;
	116	}
	117
1da177e4 LT	118	/* Callback for SLIT parsing */
	119	void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
	120	{
1584b89c AK	121	if (!slit_valid(slit)) {
	122	printk(KERN_INFO "ACPI: SLIT table looks invalid. Not used.\n");
	123	return;
	124	}
1da177e4 LT	125	acpi_slit = slit;
	126	}
	127
	128	/* Callback for Proximity Domain -> LAPIC mapping */
	129	void __init
	130	acpi_numa_processor_affinity_init(struct acpi_table_processor_affinity *pa)
	131	{
	132	int pxm, node;
d22fe808 AK	133	if (srat_disabled())
d22fe808 AK	134	return;
fad7906d AK	135	if (pa->header.length != sizeof(struct acpi_table_processor_affinity)) {
fad7906d AK	136	bad_srat();
d22fe808 AK	137	return;
	138	}
	139	if (pa->flags.enabled == 0)
1da177e4 LT	140	return;
	141	pxm = pa->proximity_domain;
	142	node = setup_node(pxm);
	143	if (node < 0) {
	144	printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
	145	bad_srat();
	146	return;
	147	}
0b07e984	148	apicid_to_node[pa->apic_id] = node;
1da177e4	149	acpi_numa = 1;
0b07e984 AK	150	printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
0b07e984 AK	151	pxm, pa->apic_id, node);
1da177e4 LT	152	}
1da177e4 LT	153
71efa8fd	154	#ifdef CONFIG_MEMORY_HOTPLUG_RESERVE
68a3a7fe AK	155	/*
	156	* Protect against too large hotadd areas that would fill up memory.
	157	*/
	158	static int hotadd_enough_memory(struct bootnode *nd)
	159	{
	160	static unsigned long allocated;
	161	static unsigned long last_area_end;
	162	unsigned long pages = (nd->end - nd->start) >> PAGE_SHIFT;
	163	long mem = pages * sizeof(struct page);
	164	unsigned long addr;
	165	unsigned long allowed;
	166	unsigned long oldpages = pages;
	167
	168	if (mem < 0)
	169	return 0;
5cb248ab	170	allowed = (end_pfn - absent_pages_in_range(0, end_pfn)) * PAGE_SIZE;
68a3a7fe AK	171	allowed = (allowed / 100) * hotadd_percent;
68a3a7fe AK	172	if (allocated + mem > allowed) {
fad7906d	173	unsigned long range;
68a3a7fe AK	174	/* Give them at least part of their hotadd memory upto hotadd_percent
	175	It would be better to spread the limit out
	176	over multiple hotplug areas, but that is too complicated
	177	right now */
	178	if (allocated >= allowed)
	179	return 0;
fad7906d AK	180	range = allowed - allocated;
fad7906d AK	181	pages = (range / PAGE_SIZE);
68a3a7fe	182	mem = pages * sizeof(struct page);
fad7906d	183	nd->end = nd->start + range;
68a3a7fe AK	184	}
	185	/* Not completely fool proof, but a good sanity check */
	186	addr = find_e820_area(last_area_end, end_pfn<<PAGE_SHIFT, mem);
	187	if (addr == -1UL)
	188	return 0;
	189	if (pages != oldpages)
	190	printk(KERN_NOTICE "SRAT: Hotadd area limited to %lu bytes\n",
	191	pages << PAGE_SHIFT);
	192	last_area_end = addr + mem;
	193	allocated += mem;
	194	return 1;
	195	}
	196
71efa8fd KM	197	static int update_end_of_memory(unsigned long end)
	198	{
	199	found_add_area = 1;
	200	if ((end >> PAGE_SHIFT) > end_pfn)
	201	end_pfn = end >> PAGE_SHIFT;
	202	return 1;
	203	}
	204
	205	static inline int save_add_info(void)
	206	{
	207	return hotadd_percent > 0;
	208	}
	209	#else
	210	int update_end_of_memory(unsigned long end) {return 0;}
	211	static int hotadd_enough_memory(struct bootnode *nd) {return 1;}
	212	#ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
	213	static inline int save_add_info(void) {return 1;}
	214	#else
	215	static inline int save_add_info(void) {return 0;}
	216	#endif
	217	#endif
68a3a7fe	218	/*
71efa8fd KM	219	* Update nodes_add and decide if to include add are in the zone.
71efa8fd KM	220	* Both SPARSE and RESERVE need nodes_add infomation.
68a3a7fe AK	221	* This code supports one contigious hot add area per node.
	222	*/
	223	static int reserve_hotadd(int node, unsigned long start, unsigned long end)
	224	{
	225	unsigned long s_pfn = start >> PAGE_SHIFT;
	226	unsigned long e_pfn = end >> PAGE_SHIFT;
71efa8fd	227	int ret = 0, changed = 0;
68a3a7fe AK	228	struct bootnode *nd = &nodes_add[node];
	229
	230	/* I had some trouble with strange memory hotadd regions breaking
	231	the boot. Be very strict here and reject anything unexpected.
	232	If you want working memory hotadd write correct SRATs.
	233
	234	The node size check is a basic sanity check to guard against
	235	mistakes */
	236	if ((signed long)(end - start) < NODE_MIN_SIZE) {
	237	printk(KERN_ERR "SRAT: Hotplug area too small\n");
	238	return -1;
	239	}
	240
	241	/* This check might be a bit too strict, but I'm keeping it for now. */
5cb248ab	242	if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
9c7cd687 MG	243	printk(KERN_ERR
	244	"SRAT: Hotplug area %lu -> %lu has existing memory\n",
	245	s_pfn, e_pfn);
68a3a7fe AK	246	return -1;
	247	}
	248
	249	if (!hotadd_enough_memory(&nodes_add[node])) {
	250	printk(KERN_ERR "SRAT: Hotplug area too large\n");
	251	return -1;
	252	}
	253
	254	/* Looks good */
	255
68a3a7fe AK	256	if (nd->start == nd->end) {
	257	nd->start = start;
	258	nd->end = end;
	259	changed = 1;
	260	} else {
	261	if (nd->start == end) {
	262	nd->start = start;
	263	changed = 1;
	264	}
	265	if (nd->end == start) {
	266	nd->end = end;
	267	changed = 1;
	268	}
	269	if (!changed)
	270	printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
	271	}
	272
71efa8fd	273	ret = update_end_of_memory(nd->end);
68a3a7fe AK	274
	275	if (changed)
	276	printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
71efa8fd	277	return ret;
68a3a7fe	278	}
68a3a7fe	279
1da177e4 LT	280	/* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
	281	void __init
	282	acpi_numa_memory_affinity_init(struct acpi_table_memory_affinity *ma)
	283	{
68a3a7fe	284	struct bootnode *nd, oldnode;
1da177e4 LT	285	unsigned long start, end;
	286	int node, pxm;
	287	int i;
	288
d22fe808	289	if (srat_disabled())
1da177e4	290	return;
d22fe808 AK	291	if (ma->header.length != sizeof(struct acpi_table_memory_affinity)) {
	292	bad_srat();
	293	return;
	294	}
	295	if (ma->flags.enabled == 0)
	296	return;
71efa8fd	297	if (ma->flags.hot_pluggable && !save_add_info())
68a3a7fe	298	return;
d22fe808 AK	299	start = ma->base_addr_lo \| ((u64)ma->base_addr_hi << 32);
d22fe808 AK	300	end = start + (ma->length_lo \| ((u64)ma->length_hi << 32));
1da177e4 LT	301	pxm = ma->proximity_domain;
	302	node = setup_node(pxm);
	303	if (node < 0) {
	304	printk(KERN_ERR "SRAT: Too many proximity domains.\n");
	305	bad_srat();
	306	return;
	307	}
1da177e4	308	i = conflicting_nodes(start, end);
05d1fa4b AK	309	if (i == node) {
	310	printk(KERN_WARNING
	311	"SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
	312	pxm, start, end, nodes[i].start, nodes[i].end);
	313	} else if (i >= 0) {
1da177e4	314	printk(KERN_ERR
05d1fa4b AK	315	"SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
	316	pxm, start, end, node_to_pxm(i),
	317	nodes[i].start, nodes[i].end);
1da177e4 LT	318	bad_srat();
	319	return;
	320	}
	321	nd = &nodes[node];
68a3a7fe	322	oldnode = *nd;
1da177e4 LT	323	if (!node_test_and_set(node, nodes_parsed)) {
	324	nd->start = start;
	325	nd->end = end;
	326	} else {
	327	if (start < nd->start)
	328	nd->start = start;
	329	if (nd->end < end)
	330	nd->end = end;
	331	}
68a3a7fe	332
1da177e4 LT	333	printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
1da177e4 LT	334	nd->start, nd->end);
5cb248ab MG	335	e820_register_active_regions(node, nd->start >> PAGE_SHIFT,
5cb248ab MG	336	nd->end >> PAGE_SHIFT);
fb01439c MG	337	push_node_boundaries(node, nd->start >> PAGE_SHIFT,
fb01439c MG	338	nd->end >> PAGE_SHIFT);
68a3a7fe	339
71efa8fd	340	if (ma->flags.hot_pluggable && !reserve_hotadd(node, start, end) < 0) {
68a3a7fe AK	341	/* Ignore hotadd region. Undo damage */
	342	printk(KERN_NOTICE "SRAT: Hotplug region ignored\n");
	343	*nd = oldnode;
	344	if ((nd->start \| nd->end) == 0)
	345	node_clear(node, nodes_parsed);
	346	}
1da177e4 LT	347	}
1da177e4 LT	348
8a6fdd3e AK	349	/* Sanity check to catch more bad SRATs (they are amazingly common).
	350	Make sure the PXMs cover all memory. */
	351	static int nodes_cover_memory(void)
	352	{
	353	int i;
	354	unsigned long pxmram, e820ram;
	355
	356	pxmram = 0;
	357	for_each_node_mask(i, nodes_parsed) {
	358	unsigned long s = nodes[i].start >> PAGE_SHIFT;
	359	unsigned long e = nodes[i].end >> PAGE_SHIFT;
	360	pxmram += e - s;
5cb248ab	361	pxmram -= absent_pages_in_range(s, e);
68a3a7fe AK	362	if ((long)pxmram < 0)
68a3a7fe AK	363	pxmram = 0;
8a6fdd3e AK	364	}
8a6fdd3e AK	365
5cb248ab	366	e820ram = end_pfn - absent_pages_in_range(0, end_pfn);
fdb9df94 AK	367	/* We seem to lose 3 pages somewhere. Allow a bit of slack. */
fdb9df94 AK	368	if ((long)(e820ram - pxmram) >= 110241024) {
8a6fdd3e AK	369	printk(KERN_ERR
	370	"SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
	371	(pxmram << PAGE_SHIFT) >> 20,
	372	(e820ram << PAGE_SHIFT) >> 20);
	373	return 0;
	374	}
	375	return 1;
	376	}
	377
9391a3f9 AK	378	static void unparse_node(int node)
	379	{
	380	int i;
	381	node_clear(node, nodes_parsed);
	382	for (i = 0; i < MAX_LOCAL_APIC; i++) {
	383	if (apicid_to_node[i] == node)
	384	apicid_to_node[i] = NUMA_NO_NODE;
	385	}
	386	}
	387
1da177e4 LT	388	void __init acpi_numa_arch_fixup(void) {}
	389
	390	/* Use the information discovered above to actually set up the nodes. */
	391	int __init acpi_scan_nodes(unsigned long start, unsigned long end)
	392	{
	393	int i;
8a6fdd3e	394
e58e0d03	395	/* First clean up the node list */
9391a3f9	396	for (i = 0; i < MAX_NUMNODES; i++) {
68a3a7fe	397	cutoff_node(i, start, end);
0d015324	398	if ((nodes[i].end - nodes[i].start) < NODE_MIN_SIZE) {
9391a3f9	399	unparse_node(i);
0d015324 DY	400	node_set_offline(i);
0d015324 DY	401	}
e58e0d03 AK	402	}
e58e0d03 AK	403
9391a3f9 AK	404	if (acpi_numa <= 0)
	405	return -1;
	406
8a6fdd3e AK	407	if (!nodes_cover_memory()) {
	408	bad_srat();
	409	return -1;
	410	}
	411
2aed711a	412	memnode_shift = compute_hash_shift(nodes, MAX_NUMNODES);
1da177e4 LT	413	if (memnode_shift < 0) {
	414	printk(KERN_ERR
	415	"SRAT: No NUMA node hash function found. Contact maintainer\n");
	416	bad_srat();
	417	return -1;
	418	}
e58e0d03 AK	419
	420	/* Finally register nodes */
	421	for_each_node_mask(i, nodes_parsed)
1da177e4	422	setup_node_bootmem(i, nodes[i].start, nodes[i].end);
a8062231 AK	423	/* Try again in case setup_node_bootmem missed one due
	424	to missing bootmem */
	425	for_each_node_mask(i, nodes_parsed)
	426	if (!node_online(i))
	427	setup_node_bootmem(i, nodes[i].start, nodes[i].end);
	428
1da177e4 LT	429	for (i = 0; i < NR_CPUS; i++) {
	430	if (cpu_to_node[i] == NUMA_NO_NODE)
	431	continue;
	432	if (!node_isset(cpu_to_node[i], nodes_parsed))
69d81fcd	433	numa_set_node(i, NUMA_NO_NODE);
1da177e4 LT	434	}
	435	numa_init_array();
	436	return 0;
	437	}
	438
68a3a7fe AK	439	void __init srat_reserve_add_area(int nodeid)
	440	{
	441	if (found_add_area && nodes_add[nodeid].end) {
	442	u64 total_mb;
	443
	444	printk(KERN_INFO "SRAT: Reserving hot-add memory space "
	445	"for node %d at %Lx-%Lx\n",
	446	nodeid, nodes_add[nodeid].start, nodes_add[nodeid].end);
	447	total_mb = (nodes_add[nodeid].end - nodes_add[nodeid].start)
	448	>> PAGE_SHIFT;
	449	total_mb *= sizeof(struct page);
	450	total_mb >>= 20;
	451	printk(KERN_INFO "SRAT: This will cost you %Lu MB of "
	452	"pre-allocated memory.\n", (unsigned long long)total_mb);
	453	reserve_bootmem_node(NODE_DATA(nodeid), nodes_add[nodeid].start,
	454	nodes_add[nodeid].end - nodes_add[nodeid].start);
	455	}
	456	}
	457
1da177e4 LT	458	int __node_distance(int a, int b)
	459	{
	460	int index;
	461
	462	if (!acpi_slit)
	463	return a == b ? 10 : 20;
	464	index = acpi_slit->localities * node_to_pxm(a);
	465	return acpi_slit->entry[index + node_to_pxm(b)];
	466	}
	467
	468	EXPORT_SYMBOL(__node_distance);