[linux-2.6-block.git] / arch / x86 / 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/memblock.h>
#include <linux/mm.h>
#include <asm/proto.h>
#include <asm/numa.h>
#include <asm/e820.h>
#include <asm/apic.h>
#include <asm/uv/uv.h>

int acpi_numa __initdata;

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

static __init void bad_srat(void)
{
	printk(KERN_ERR "SRAT: SRAT not used.\n");
	acpi_numa = -1;
}

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

/*
 * Callback for SLIT parsing.  pxm_to_node() returns NUMA_NO_NODE for
 * I/O localities since SRAT does not list them.  I/O localities are
 * not supported at this point.
 */
void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
{
	int i, j;

	for (i = 0; i < slit->locality_count; i++) {
		if (pxm_to_node(i) == NUMA_NO_NODE)
			continue;
		for (j = 0; j < slit->locality_count; j++) {
			if (pxm_to_node(j) == NUMA_NO_NODE)
				continue;
			numa_set_distance(pxm_to_node(i), pxm_to_node(j),
				slit->entry[slit->locality_count * i + j]);
		}
	}
}

/* Callback for Proximity Domain -> x2APIC mapping */
void __init
acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa)
{
	int pxm, node;
	int apic_id;

	if (srat_disabled())
		return;
	if (pa->header.length < sizeof(struct acpi_srat_x2apic_cpu_affinity)) {
		bad_srat();
		return;
	}
	if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
		return;
	pxm = pa->proximity_domain;
	apic_id = pa->apic_id;
	if (!apic->apic_id_valid(apic_id)) {
		printk(KERN_INFO "SRAT: PXM %u -> X2APIC 0x%04x ignored\n",
			 pxm, apic_id);
		return;
	}
	node = setup_node(pxm);
	if (node < 0) {
		printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
		bad_srat();
		return;
	}

	if (apic_id >= MAX_LOCAL_APIC) {
		printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%04x -> Node %u skipped apicid that is too big\n", pxm, apic_id, node);
		return;
	}
	set_apicid_to_node(apic_id, node);
	node_set(node, numa_nodes_parsed);
	acpi_numa = 1;
	printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%04x -> Node %u\n",
	       pxm, apic_id, node);
}

/* Callback for Proximity Domain -> LAPIC mapping */
void __init
acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
{
	int pxm, node;
	int apic_id;

	if (srat_disabled())
		return;
	if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) {
		bad_srat();
		return;
	}
	if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
		return;
	pxm = pa->proximity_domain_lo;
	if (acpi_srat_revision >= 2)
		pxm |= *((unsigned int*)pa->proximity_domain_hi) << 8;
	node = setup_node(pxm);
	if (node < 0) {
		printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
		bad_srat();
		return;
	}

	if (get_uv_system_type() >= UV_X2APIC)
		apic_id = (pa->apic_id << 8) | pa->local_sapic_eid;
	else
		apic_id = pa->apic_id;

	if (apic_id >= MAX_LOCAL_APIC) {
		printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%02x -> Node %u skipped apicid that is too big\n", pxm, apic_id, node);
		return;
	}

	set_apicid_to_node(apic_id, node);
	node_set(node, numa_nodes_parsed);
	acpi_numa = 1;
	printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%02x -> Node %u\n",
	       pxm, apic_id, node);
}

#ifdef CONFIG_MEMORY_HOTPLUG
static inline int save_add_info(void) {return 1;}
#else
static inline int save_add_info(void) {return 0;}
#endif

/* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
int __init
acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
{
	u64 start, end;
	u32 hotpluggable;
	int node, pxm;

	if (srat_disabled())
		goto out_err;
	if (ma->header.length != sizeof(struct acpi_srat_mem_affinity))
		goto out_err_bad_srat;
	if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
		goto out_err;
	hotpluggable = ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE;
	if (hotpluggable && !save_add_info())
		goto out_err;

	start = ma->base_address;
	end = start + ma->length;
	pxm = ma->proximity_domain;
	if (acpi_srat_revision <= 1)
		pxm &= 0xff;

	node = setup_node(pxm);
	if (node < 0) {
		printk(KERN_ERR "SRAT: Too many proximity domains.\n");
		goto out_err_bad_srat;
	}

	if (numa_add_memblk(node, start, end) < 0)
		goto out_err_bad_srat;

	node_set(node, numa_nodes_parsed);

	pr_info("SRAT: Node %u PXM %u [mem %#010Lx-%#010Lx]%s\n",
		node, pxm,
		(unsigned long long) start, (unsigned long long) end - 1,
		hotpluggable ? " hotplug" : "");

	/* Mark hotplug range in memblock. */
	if (hotpluggable && memblock_mark_hotplug(start, ma->length))
		pr_warn("SRAT: Failed to mark hotplug range [mem %#010Lx-%#010Lx] in memblock\n",
			(unsigned long long)start, (unsigned long long)end - 1);

	return 0;
out_err_bad_srat:
	bad_srat();
out_err:
	return -1;
}

void __init acpi_numa_arch_fixup(void) {}

int __init x86_acpi_numa_init(void)
{
	int ret;

	ret = acpi_numa_init();
	if (ret < 0)
		return ret;
	return srat_disabled() ? -EINVAL : 0;
}
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	18	#include <linux/bootmem.h>
a9ce6bc1	19	#include <linux/memblock.h>
68a3a7fe	20	#include <linux/mm.h>
1da177e4 LT	21	#include <asm/proto.h>
1da177e4 LT	22	#include <asm/numa.h>
8a6fdd3e	23	#include <asm/e820.h>
7b6aa335	24	#include <asm/apic.h>
4ec71fa2	25	#include <asm/uv/uv.h>
1da177e4	26
c31fbb1a AK	27	int acpi_numa __initdata;
c31fbb1a AK	28
1da177e4 LT	29	static __init int setup_node(int pxm)
1da177e4 LT	30	{
762834e8	31	return acpi_map_pxm_to_node(pxm);
1da177e4 LT	32	}
1da177e4 LT	33
1da177e4 LT	34	static __init void bad_srat(void)
	35	{
	36	printk(KERN_ERR "SRAT: SRAT not used.\n");
	37	acpi_numa = -1;
	38	}
	39
	40	static __init inline int srat_disabled(void)
	41	{
ffe77a46	42	return acpi_numa < 0;
1da177e4 LT	43	}
1da177e4 LT	44
a85eba88 TK	45	/*
	46	* Callback for SLIT parsing. pxm_to_node() returns NUMA_NO_NODE for
	47	* I/O localities since SRAT does not list them. I/O localities are
	48	* not supported at this point.
	49	*/
1da177e4 LT	50	void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
1da177e4 LT	51	{
ac7136b6	52	int i, j;
f302a5bb	53
a85eba88 TK	54	for (i = 0; i < slit->locality_count; i++) {
	55	if (pxm_to_node(i) == NUMA_NO_NODE)
	56	continue;
	57	for (j = 0; j < slit->locality_count; j++) {
	58	if (pxm_to_node(j) == NUMA_NO_NODE)
	59	continue;
ac7136b6 TH	60	numa_set_distance(pxm_to_node(i), pxm_to_node(j),
ac7136b6 TH	61	slit->entry[slit->locality_count * i + j]);
a85eba88 TK	62	}
a85eba88 TK	63	}
1da177e4 LT	64	}
1da177e4 LT	65
7237d3de SS	66	/* Callback for Proximity Domain -> x2APIC mapping */
	67	void __init
	68	acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa)
	69	{
	70	int pxm, node;
	71	int apic_id;
	72
	73	if (srat_disabled())
	74	return;
	75	if (pa->header.length < sizeof(struct acpi_srat_x2apic_cpu_affinity)) {
	76	bad_srat();
	77	return;
	78	}
	79	if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
	80	return;
	81	pxm = pa->proximity_domain;
a35fd282	82	apic_id = pa->apic_id;
b7157acf	83	if (!apic->apic_id_valid(apic_id)) {
a35fd282 YL	84	printk(KERN_INFO "SRAT: PXM %u -> X2APIC 0x%04x ignored\n",
	85	pxm, apic_id);
	86	return;
	87	}
7237d3de SS	88	node = setup_node(pxm);
	89	if (node < 0) {
	90	printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
	91	bad_srat();
	92	return;
	93	}
	94
d3bd0588 YL	95	if (apic_id >= MAX_LOCAL_APIC) {
	96	printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%04x -> Node %u skipped apicid that is too big\n", pxm, apic_id, node);
	97	return;
	98	}
bbc9e2f4	99	set_apicid_to_node(apic_id, node);
92d4a437	100	node_set(node, numa_nodes_parsed);
7237d3de	101	acpi_numa = 1;
163d3866	102	printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%04x -> Node %u\n",
7237d3de SS	103	pxm, apic_id, node);
	104	}
	105
1da177e4 LT	106	/* Callback for Proximity Domain -> LAPIC mapping */
1da177e4 LT	107	void __init
15a58ed1	108	acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
1da177e4 LT	109	{
1da177e4 LT	110	int pxm, node;
ef97001f	111	int apic_id;
ef97001f	112
d22fe808 AK	113	if (srat_disabled())
d22fe808 AK	114	return;
15a58ed1	115	if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) {
fad7906d	116	bad_srat();
d22fe808 AK	117	return;
d22fe808 AK	118	}
15a58ed1	119	if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
1da177e4	120	return;
15a58ed1	121	pxm = pa->proximity_domain_lo;
cd298f60 KG	122	if (acpi_srat_revision >= 2)
cd298f60 KG	123	pxm \|= ((unsigned int)pa->proximity_domain_hi) << 8;
1da177e4 LT	124	node = setup_node(pxm);
	125	if (node < 0) {
	126	printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
	127	bad_srat();
	128	return;
	129	}
beafe91f	130
2e42060c	131	if (get_uv_system_type() >= UV_X2APIC)
a65d1d64 JS	132	apic_id = (pa->apic_id << 8) \| pa->local_sapic_eid;
	133	else
	134	apic_id = pa->apic_id;
d3bd0588 YL	135
	136	if (apic_id >= MAX_LOCAL_APIC) {
	137	printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%02x -> Node %u skipped apicid that is too big\n", pxm, apic_id, node);
	138	return;
	139	}
	140
bbc9e2f4	141	set_apicid_to_node(apic_id, node);
92d4a437	142	node_set(node, numa_nodes_parsed);
1da177e4	143	acpi_numa = 1;
163d3866	144	printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%02x -> Node %u\n",
ef97001f	145	pxm, apic_id, node);
1da177e4 LT	146	}
1da177e4 LT	147
9688678a	148	#ifdef CONFIG_MEMORY_HOTPLUG
71efa8fd KM	149	static inline int save_add_info(void) {return 1;}
	150	#else
	151	static inline int save_add_info(void) {return 0;}
	152	#endif
68a3a7fe	153
1da177e4	154	/* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
095adbb6	155	int __init
15a58ed1	156	acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
1da177e4	157	{
eca9ad31	158	u64 start, end;
d7b2c3d8	159	u32 hotpluggable;
1da177e4	160	int node, pxm;
1da177e4	161
d22fe808	162	if (srat_disabled())
479a99a8 DB	163	goto out_err;
	164	if (ma->header.length != sizeof(struct acpi_srat_mem_affinity))
	165	goto out_err_bad_srat;
15a58ed1	166	if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
479a99a8	167	goto out_err;
d7b2c3d8 TC	168	hotpluggable = ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE;
d7b2c3d8 TC	169	if (hotpluggable && !save_add_info())
479a99a8 DB	170	goto out_err;
479a99a8 DB	171
15a58ed1 AS	172	start = ma->base_address;
15a58ed1 AS	173	end = start + ma->length;
1da177e4	174	pxm = ma->proximity_domain;
cd298f60 KG	175	if (acpi_srat_revision <= 1)
cd298f60 KG	176	pxm &= 0xff;
479a99a8	177
1da177e4 LT	178	node = setup_node(pxm);
	179	if (node < 0) {
	180	printk(KERN_ERR "SRAT: Too many proximity domains.\n");
479a99a8	181	goto out_err_bad_srat;
1da177e4	182	}
ef396ec9	183
479a99a8 DB	184	if (numa_add_memblk(node, start, end) < 0)
479a99a8 DB	185	goto out_err_bad_srat;
68a3a7fe	186
4af463d2 YI	187	node_set(node, numa_nodes_parsed);
4af463d2 YI	188
d7b2c3d8 TC	189	pr_info("SRAT: Node %u PXM %u [mem %#010Lx-%#010Lx]%s\n",
	190	node, pxm,
	191	(unsigned long long) start, (unsigned long long) end - 1,
	192	hotpluggable ? " hotplug" : "");
479a99a8	193
05d1d8cb TC	194	/* Mark hotplug range in memblock. */
	195	if (hotpluggable && memblock_mark_hotplug(start, ma->length))
	196	pr_warn("SRAT: Failed to mark hotplug range [mem %#010Lx-%#010Lx] in memblock\n",
	197	(unsigned long long)start, (unsigned long long)end - 1);
	198
095adbb6	199	return 0;
479a99a8 DB	200	out_err_bad_srat:
	201	bad_srat();
	202	out_err:
	203	return -1;
1da177e4 LT	204	}
	205
	206	void __init acpi_numa_arch_fixup(void) {}
	207
a9aec56a TH	208	int __init x86_acpi_numa_init(void)
	209	{
	210	int ret;
	211
	212	ret = acpi_numa_init();
	213	if (ret < 0)
	214	return ret;
	215	return srat_disabled() ? -EINVAL : 0;
	216	}