blob: 1b4763e26ea96f52b6240475e85a04cb3a06dc4b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Andi Kleen68a3a7f2006-04-07 19:49:18 +020018#include <linux/bootmem.h>
19#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <asm/proto.h>
21#include <asm/numa.h>
Andi Kleen8a6fdd32006-01-11 22:44:39 +010022#include <asm/e820.h>
Jack Steinera65d1d62008-03-28 14:12:08 -050023#include <asm/genapic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Andi Kleenc31fbb12006-09-26 10:52:33 +020025int acpi_numa __initdata;
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027static struct acpi_table_slit *acpi_slit;
28
29static nodemask_t nodes_parsed __initdata;
Andi Kleenabe059e2006-03-25 16:29:12 +010030static struct bootnode nodes[MAX_NUMNODES] __initdata;
Keith Mannthey4942e992006-09-30 23:27:06 -070031static struct bootnode nodes_add[MAX_NUMNODES];
Andi Kleen68a3a7f2006-04-07 19:49:18 +020032static int found_add_area __initdata;
Andi Kleenfad79062006-05-15 18:19:44 +020033int hotadd_percent __initdata = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -070035static int num_node_memblks __initdata;
36static struct bootnode node_memblk_range[NR_NODE_MEMBLKS] __initdata;
37static int memblk_nodeid[NR_NODE_MEMBLKS] __initdata;
38
Andi Kleen9391a3f2006-02-03 21:51:17 +010039/* Too small nodes confuse the VM badly. Usually they result
40 from BIOS bugs. */
41#define NODE_MIN_SIZE (4*1024*1024)
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043static __init int setup_node(int pxm)
44{
Yasunori Goto762834e2006-06-23 02:03:19 -070045 return acpi_map_pxm_to_node(pxm);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046}
47
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -070048static __init int conflicting_memblks(unsigned long start, unsigned long end)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049{
50 int i;
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -070051 for (i = 0; i < num_node_memblks; i++) {
52 struct bootnode *nd = &node_memblk_range[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 if (nd->start == nd->end)
54 continue;
55 if (nd->end > start && nd->start < end)
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -070056 return memblk_nodeid[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 if (nd->end == end && nd->start == start)
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -070058 return memblk_nodeid[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 }
60 return -1;
61}
62
63static __init void cutoff_node(int i, unsigned long start, unsigned long end)
64{
Andi Kleenabe059e2006-03-25 16:29:12 +010065 struct bootnode *nd = &nodes[i];
Andi Kleen68a3a7f2006-04-07 19:49:18 +020066
67 if (found_add_area)
68 return;
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 if (nd->start < start) {
71 nd->start = start;
72 if (nd->end < nd->start)
73 nd->start = nd->end;
74 }
75 if (nd->end > end) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 nd->end = end;
77 if (nd->start > nd->end)
78 nd->start = nd->end;
79 }
80}
81
82static __init void bad_srat(void)
83{
Andi Kleen2bce2b52005-09-12 18:49:25 +020084 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 printk(KERN_ERR "SRAT: SRAT not used.\n");
86 acpi_numa = -1;
Andi Kleenfad79062006-05-15 18:19:44 +020087 found_add_area = 0;
Andi Kleen2bce2b52005-09-12 18:49:25 +020088 for (i = 0; i < MAX_LOCAL_APIC; i++)
89 apicid_to_node[i] = NUMA_NO_NODE;
Andi Kleen68a3a7f2006-04-07 19:49:18 +020090 for (i = 0; i < MAX_NUMNODES; i++)
91 nodes_add[i].start = nodes[i].end = 0;
Mel Gorman5cb248a2006-09-27 01:49:52 -070092 remove_all_active_ranges();
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94
95static __init inline int srat_disabled(void)
96{
97 return numa_off || acpi_numa < 0;
98}
99
100/* Callback for SLIT parsing */
101void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
102{
Yinghai Luf302a5bb2008-07-10 20:36:37 -0700103 unsigned length;
104 unsigned long phys;
105
106 length = slit->header.length;
107 phys = find_e820_area(0, max_pfn_mapped<<PAGE_SHIFT, length,
108 PAGE_SIZE);
109
110 if (phys == -1L)
111 panic(" Can not save slit!\n");
112
113 acpi_slit = __va(phys);
114 memcpy(acpi_slit, slit, length);
115 reserve_early(phys, phys + length, "ACPI SLIT");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116}
117
118/* Callback for Proximity Domain -> LAPIC mapping */
119void __init
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300120acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
122 int pxm, node;
travis@sgi.comef970012008-01-30 13:33:10 +0100123 int apic_id;
124
Andi Kleend22fe802006-02-03 21:51:26 +0100125 if (srat_disabled())
126 return;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300127 if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) {
Andi Kleenfad79062006-05-15 18:19:44 +0200128 bad_srat();
Andi Kleend22fe802006-02-03 21:51:26 +0100129 return;
130 }
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300131 if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 return;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300133 pxm = pa->proximity_domain_lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 node = setup_node(pxm);
135 if (node < 0) {
136 printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
137 bad_srat();
138 return;
139 }
Yinghai Lubeafe912008-02-16 23:00:22 -0800140
Jack Steinera65d1d62008-03-28 14:12:08 -0500141 if (is_uv_system())
142 apic_id = (pa->apic_id << 8) | pa->local_sapic_eid;
143 else
144 apic_id = pa->apic_id;
travis@sgi.comef970012008-01-30 13:33:10 +0100145 apicid_to_node[apic_id] = node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 acpi_numa = 1;
Andi Kleen0b07e982005-09-12 18:49:24 +0200147 printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
travis@sgi.comef970012008-01-30 13:33:10 +0100148 pxm, apic_id, node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149}
150
Ingo Molnara4928cf2008-04-23 13:20:56 +0200151static int update_end_of_memory(unsigned long end) {return -1;}
Keith Mannthey71efa8f2006-09-30 23:27:05 -0700152static int hotadd_enough_memory(struct bootnode *nd) {return 1;}
153#ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
154static inline int save_add_info(void) {return 1;}
155#else
156static inline int save_add_info(void) {return 0;}
157#endif
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200158/*
Keith Mannthey71efa8f2006-09-30 23:27:05 -0700159 * Update nodes_add and decide if to include add are in the zone.
Joe Perchesab4a5742008-01-30 13:31:42 +0100160 * Both SPARSE and RESERVE need nodes_add information.
Simon Arlott676b1852007-10-20 01:25:36 +0200161 * This code supports one contiguous hot add area per node.
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200162 */
Sam Ravnborgd01b9ad2008-02-17 13:22:58 +0100163static int __init
164reserve_hotadd(int node, unsigned long start, unsigned long end)
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200165{
166 unsigned long s_pfn = start >> PAGE_SHIFT;
167 unsigned long e_pfn = end >> PAGE_SHIFT;
Keith Mannthey71efa8f2006-09-30 23:27:05 -0700168 int ret = 0, changed = 0;
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200169 struct bootnode *nd = &nodes_add[node];
170
171 /* I had some trouble with strange memory hotadd regions breaking
172 the boot. Be very strict here and reject anything unexpected.
173 If you want working memory hotadd write correct SRATs.
174
175 The node size check is a basic sanity check to guard against
176 mistakes */
177 if ((signed long)(end - start) < NODE_MIN_SIZE) {
178 printk(KERN_ERR "SRAT: Hotplug area too small\n");
179 return -1;
180 }
181
182 /* This check might be a bit too strict, but I'm keeping it for now. */
Mel Gorman5cb248a2006-09-27 01:49:52 -0700183 if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
Mel Gorman9c7cd682006-09-27 01:49:58 -0700184 printk(KERN_ERR
185 "SRAT: Hotplug area %lu -> %lu has existing memory\n",
186 s_pfn, e_pfn);
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200187 return -1;
188 }
189
190 if (!hotadd_enough_memory(&nodes_add[node])) {
191 printk(KERN_ERR "SRAT: Hotplug area too large\n");
192 return -1;
193 }
194
195 /* Looks good */
196
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200197 if (nd->start == nd->end) {
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300198 nd->start = start;
199 nd->end = end;
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200200 changed = 1;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300201 } else {
202 if (nd->start == end) {
203 nd->start = start;
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200204 changed = 1;
205 }
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300206 if (nd->end == start) {
207 nd->end = end;
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200208 changed = 1;
209 }
210 if (!changed)
211 printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300212 }
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200213
Keith Mannthey71efa8f2006-09-30 23:27:05 -0700214 ret = update_end_of_memory(nd->end);
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200215
216 if (changed)
217 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
Keith Mannthey71efa8f2006-09-30 23:27:05 -0700218 return ret;
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200219}
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200220
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221/* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
222void __init
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300223acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224{
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200225 struct bootnode *nd, oldnode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 unsigned long start, end;
227 int node, pxm;
228 int i;
229
Andi Kleend22fe802006-02-03 21:51:26 +0100230 if (srat_disabled())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300232 if (ma->header.length != sizeof(struct acpi_srat_mem_affinity)) {
Andi Kleend22fe802006-02-03 21:51:26 +0100233 bad_srat();
234 return;
235 }
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300236 if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
Andi Kleend22fe802006-02-03 21:51:26 +0100237 return;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300238
239 if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200240 return;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300241 start = ma->base_address;
242 end = start + ma->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 pxm = ma->proximity_domain;
244 node = setup_node(pxm);
245 if (node < 0) {
246 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
247 bad_srat();
248 return;
249 }
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -0700250 i = conflicting_memblks(start, end);
Andi Kleen05d1fa42005-09-12 18:49:24 +0200251 if (i == node) {
252 printk(KERN_WARNING
253 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
254 pxm, start, end, nodes[i].start, nodes[i].end);
255 } else if (i >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 printk(KERN_ERR
Andi Kleen05d1fa42005-09-12 18:49:24 +0200257 "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
258 pxm, start, end, node_to_pxm(i),
259 nodes[i].start, nodes[i].end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 bad_srat();
261 return;
262 }
263 nd = &nodes[node];
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200264 oldnode = *nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 if (!node_test_and_set(node, nodes_parsed)) {
266 nd->start = start;
267 nd->end = end;
268 } else {
269 if (start < nd->start)
270 nd->start = start;
271 if (nd->end < end)
272 nd->end = end;
273 }
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200274
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -0700275 printk(KERN_INFO "SRAT: Node %u PXM %u %lx-%lx\n", node, pxm,
276 start, end);
277 e820_register_active_regions(node, start >> PAGE_SHIFT,
278 end >> PAGE_SHIFT);
Mel Gormanfb014392006-09-27 01:49:59 -0700279 push_node_boundaries(node, nd->start >> PAGE_SHIFT,
280 nd->end >> PAGE_SHIFT);
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200281
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300282 if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) &&
283 (reserve_hotadd(node, start, end) < 0)) {
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200284 /* Ignore hotadd region. Undo damage */
285 printk(KERN_NOTICE "SRAT: Hotplug region ignored\n");
286 *nd = oldnode;
287 if ((nd->start | nd->end) == 0)
288 node_clear(node, nodes_parsed);
289 }
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -0700290
291 node_memblk_range[num_node_memblks].start = start;
292 node_memblk_range[num_node_memblks].end = end;
293 memblk_nodeid[num_node_memblks] = node;
294 num_node_memblks++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
Andi Kleen8a6fdd32006-01-11 22:44:39 +0100297/* Sanity check to catch more bad SRATs (they are amazingly common).
298 Make sure the PXMs cover all memory. */
David Rientjes3484d792007-07-21 17:10:32 +0200299static int __init nodes_cover_memory(const struct bootnode *nodes)
Andi Kleen8a6fdd32006-01-11 22:44:39 +0100300{
301 int i;
302 unsigned long pxmram, e820ram;
303
304 pxmram = 0;
305 for_each_node_mask(i, nodes_parsed) {
306 unsigned long s = nodes[i].start >> PAGE_SHIFT;
307 unsigned long e = nodes[i].end >> PAGE_SHIFT;
308 pxmram += e - s;
Mel Gorman5cb248a2006-09-27 01:49:52 -0700309 pxmram -= absent_pages_in_range(s, e);
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200310 if ((long)pxmram < 0)
311 pxmram = 0;
Andi Kleen8a6fdd32006-01-11 22:44:39 +0100312 }
313
Yinghai Luc987d122008-06-24 22:14:09 -0700314 e820ram = max_pfn - absent_pages_in_range(0, max_pfn);
Andi Kleenfdb9df92006-02-16 23:42:13 +0100315 /* We seem to lose 3 pages somewhere. Allow a bit of slack. */
316 if ((long)(e820ram - pxmram) >= 1*1024*1024) {
Andi Kleen8a6fdd32006-01-11 22:44:39 +0100317 printk(KERN_ERR
318 "SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
319 (pxmram << PAGE_SHIFT) >> 20,
320 (e820ram << PAGE_SHIFT) >> 20);
321 return 0;
322 }
323 return 1;
324}
325
Sam Ravnborg1e296f52008-01-30 13:33:37 +0100326static void __init unparse_node(int node)
Andi Kleen9391a3f2006-02-03 21:51:17 +0100327{
328 int i;
329 node_clear(node, nodes_parsed);
330 for (i = 0; i < MAX_LOCAL_APIC; i++) {
331 if (apicid_to_node[i] == node)
332 apicid_to_node[i] = NUMA_NO_NODE;
333 }
334}
335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336void __init acpi_numa_arch_fixup(void) {}
337
338/* Use the information discovered above to actually set up the nodes. */
339int __init acpi_scan_nodes(unsigned long start, unsigned long end)
340{
341 int i;
Andi Kleen8a6fdd32006-01-11 22:44:39 +0100342
David Rientjesae2c6dc2007-07-21 17:09:56 +0200343 if (acpi_numa <= 0)
344 return -1;
345
Andi Kleen9391a3f2006-02-03 21:51:17 +0100346 /* First clean up the node list */
347 for (i = 0; i < MAX_NUMNODES; i++) {
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300348 cutoff_node(i, start, end);
Mike Travis693e3c52008-01-30 13:33:14 +0100349 /*
350 * don't confuse VM with a node that doesn't have the
351 * minimum memory.
352 */
353 if (nodes[i].end &&
354 (nodes[i].end - nodes[i].start) < NODE_MIN_SIZE) {
Andi Kleen9391a3f2006-02-03 21:51:17 +0100355 unparse_node(i);
Daniel Yeisley0d015322006-05-30 22:47:57 +0200356 node_set_offline(i);
357 }
Andi Kleen9391a3f2006-02-03 21:51:17 +0100358 }
359
David Rientjes3484d792007-07-21 17:10:32 +0200360 if (!nodes_cover_memory(nodes)) {
Andi Kleen8a6fdd32006-01-11 22:44:39 +0100361 bad_srat();
362 return -1;
363 }
364
Suresh Siddha6ec6e0d2008-03-25 10:14:35 -0700365 memnode_shift = compute_hash_shift(node_memblk_range, num_node_memblks,
366 memblk_nodeid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 if (memnode_shift < 0) {
368 printk(KERN_ERR
369 "SRAT: No NUMA node hash function found. Contact maintainer\n");
370 bad_srat();
371 return -1;
372 }
Andi Kleene58e0d02005-09-12 18:49:25 +0200373
Suresh Siddhae3f1cae2007-05-02 19:27:20 +0200374 node_possible_map = nodes_parsed;
375
Andi Kleene58e0d02005-09-12 18:49:25 +0200376 /* Finally register nodes */
Suresh Siddhae3f1cae2007-05-02 19:27:20 +0200377 for_each_node_mask(i, node_possible_map)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
Andi Kleena8062232006-04-07 19:49:21 +0200379 /* Try again in case setup_node_bootmem missed one due
380 to missing bootmem */
Suresh Siddhae3f1cae2007-05-02 19:27:20 +0200381 for_each_node_mask(i, node_possible_map)
Andi Kleena8062232006-04-07 19:49:21 +0200382 if (!node_online(i))
383 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
384
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300385 for (i = 0; i < NR_CPUS; i++) {
Mike Travis0164fe12008-01-30 13:33:21 +0100386 int node = early_cpu_to_node(i);
387
travis@sgi.com834beda12008-01-30 13:33:21 +0100388 if (node == NUMA_NO_NODE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 continue;
travis@sgi.com834beda12008-01-30 13:33:21 +0100390 if (!node_isset(node, node_possible_map))
Mike Travis23ca4bb2008-05-12 21:21:12 +0200391 numa_clear_node(i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393 numa_init_array();
394 return 0;
395}
396
David Rientjes3484d792007-07-21 17:10:32 +0200397#ifdef CONFIG_NUMA_EMU
travis@sgi.comef970012008-01-30 13:33:10 +0100398static int fake_node_to_pxm_map[MAX_NUMNODES] __initdata = {
399 [0 ... MAX_NUMNODES-1] = PXM_INVAL
400};
travis@sgi.com602a54a2008-01-30 13:33:21 +0100401static s16 fake_apicid_to_node[MAX_LOCAL_APIC] __initdata = {
travis@sgi.comef970012008-01-30 13:33:10 +0100402 [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
403};
David Rientjes3484d792007-07-21 17:10:32 +0200404static int __init find_node_by_addr(unsigned long addr)
405{
406 int ret = NUMA_NO_NODE;
407 int i;
408
409 for_each_node_mask(i, nodes_parsed) {
410 /*
411 * Find the real node that this emulated node appears on. For
412 * the sake of simplicity, we only use a real node's starting
413 * address to determine which emulated node it appears on.
414 */
415 if (addr >= nodes[i].start && addr < nodes[i].end) {
416 ret = i;
417 break;
418 }
419 }
Minoru Usui9a1b62f2008-01-30 13:33:35 +0100420 return ret;
David Rientjes3484d792007-07-21 17:10:32 +0200421}
422
423/*
424 * In NUMA emulation, we need to setup proximity domain (_PXM) to node ID
425 * mappings that respect the real ACPI topology but reflect our emulated
426 * environment. For each emulated node, we find which real node it appears on
427 * and create PXM to NID mappings for those fake nodes which mirror that
428 * locality. SLIT will now represent the correct distances between emulated
429 * nodes as a result of the real topology.
430 */
431void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
432{
David Rientjes08705b82007-07-21 17:10:33 +0200433 int i, j;
David Rientjes3484d792007-07-21 17:10:32 +0200434
435 printk(KERN_INFO "Faking PXM affinity for fake nodes on real "
436 "topology.\n");
437 for (i = 0; i < num_nodes; i++) {
438 int nid, pxm;
439
440 nid = find_node_by_addr(fake_nodes[i].start);
441 if (nid == NUMA_NO_NODE)
442 continue;
443 pxm = node_to_pxm(nid);
444 if (pxm == PXM_INVAL)
445 continue;
446 fake_node_to_pxm_map[i] = pxm;
David Rientjes08705b82007-07-21 17:10:33 +0200447 /*
448 * For each apicid_to_node mapping that exists for this real
449 * node, it must now point to the fake node ID.
450 */
451 for (j = 0; j < MAX_LOCAL_APIC; j++)
452 if (apicid_to_node[j] == nid)
453 fake_apicid_to_node[j] = i;
David Rientjes3484d792007-07-21 17:10:32 +0200454 }
455 for (i = 0; i < num_nodes; i++)
456 __acpi_map_pxm_to_node(fake_node_to_pxm_map[i], i);
David Rientjes08705b82007-07-21 17:10:33 +0200457 memcpy(apicid_to_node, fake_apicid_to_node, sizeof(apicid_to_node));
David Rientjes3484d792007-07-21 17:10:32 +0200458
459 nodes_clear(nodes_parsed);
460 for (i = 0; i < num_nodes; i++)
461 if (fake_nodes[i].start != fake_nodes[i].end)
462 node_set(i, nodes_parsed);
463 WARN_ON(!nodes_cover_memory(fake_nodes));
464}
465
466static int null_slit_node_compare(int a, int b)
467{
468 return node_to_pxm(a) == node_to_pxm(b);
469}
470#else
471static int null_slit_node_compare(int a, int b)
472{
473 return a == b;
474}
475#endif /* CONFIG_NUMA_EMU */
476
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200477void __init srat_reserve_add_area(int nodeid)
478{
479 if (found_add_area && nodes_add[nodeid].end) {
480 u64 total_mb;
481
482 printk(KERN_INFO "SRAT: Reserving hot-add memory space "
483 "for node %d at %Lx-%Lx\n",
484 nodeid, nodes_add[nodeid].start, nodes_add[nodeid].end);
485 total_mb = (nodes_add[nodeid].end - nodes_add[nodeid].start)
486 >> PAGE_SHIFT;
487 total_mb *= sizeof(struct page);
488 total_mb >>= 20;
489 printk(KERN_INFO "SRAT: This will cost you %Lu MB of "
490 "pre-allocated memory.\n", (unsigned long long)total_mb);
491 reserve_bootmem_node(NODE_DATA(nodeid), nodes_add[nodeid].start,
Bernhard Walle72a7fe32008-02-07 00:15:17 -0800492 nodes_add[nodeid].end - nodes_add[nodeid].start,
493 BOOTMEM_DEFAULT);
Andi Kleen68a3a7f2006-04-07 19:49:18 +0200494 }
495}
496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497int __node_distance(int a, int b)
498{
499 int index;
500
501 if (!acpi_slit)
David Rientjes3484d792007-07-21 17:10:32 +0200502 return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
503 REMOTE_DISTANCE;
Alexey Starikovskiy15a58ed2007-02-02 19:48:22 +0300504 index = acpi_slit->locality_count * node_to_pxm(a);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 return acpi_slit->entry[index + node_to_pxm(b)];
506}
507
508EXPORT_SYMBOL(__node_distance);
Keith Mannthey4942e992006-09-30 23:27:06 -0700509
Thomas Gleixner6a1673a2008-05-12 15:43:38 +0200510#if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) || defined(CONFIG_ACPI_HOTPLUG_MEMORY)
Keith Mannthey4942e992006-09-30 23:27:06 -0700511int memory_add_physaddr_to_nid(u64 start)
512{
513 int i, ret = 0;
514
515 for_each_node(i)
516 if (nodes_add[i].start <= start && nodes_add[i].end > start)
517 ret = i;
518
519 return ret;
520}
Keith Mannthey8c2676a2006-09-30 23:27:07 -0700521EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
Thomas Gleixner6a1673a2008-05-12 15:43:38 +0200522#endif