?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
acpi_pad: build only on X86
[linux-2.6/linux-acpi-2.6.git] / arch / x86 / mm / srat_64.c
blob2dfcbf9df2ae8410228e25fb4f559cd75ed1982e
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>
18 #include <linux/bootmem.h>
19 #include <linux/mm.h>
20 #include <asm/proto.h>
21 #include <asm/numa.h>
22 #include <asm/e820.h>
23 #include <asm/apic.h>
24 #include <asm/uv/uv.h>
25
26 int acpi_numa __initdata;
27
28 static struct acpi_table_slit *acpi_slit;
29
30 static nodemask_t nodes_parsed __initdata;
31 static nodemask_t cpu_nodes_parsed __initdata;
32 static struct bootnode nodes[MAX_NUMNODES] __initdata;
33 static struct bootnode nodes_add[MAX_NUMNODES];
34
35 static int num_node_memblks __initdata;
36 static struct bootnode node_memblk_range[NR_NODE_MEMBLKS] __initdata;
37 static int memblk_nodeid[NR_NODE_MEMBLKS] __initdata;
38
39 static __init int setup_node(int pxm)
40 {
41 return acpi_map_pxm_to_node(pxm);
42 }
43
44 static __init int conflicting_memblks(unsigned long start, unsigned long end)
45 {
46 int i;
47 for (i = 0; i < num_node_memblks; i++) {
48 struct bootnode *nd = &node_memblk_range[i];
49 if (nd->start == nd->end)
50 continue;
51 if (nd->end > start && nd->start < end)
52 return memblk_nodeid[i];
53 if (nd->end == end && nd->start == start)
54 return memblk_nodeid[i];
55 }
56 return -1;
57 }
58
59 static __init void cutoff_node(int i, unsigned long start, unsigned long end)
60 {
61 struct bootnode *nd = &nodes[i];
62
63 if (nd->start < start) {
64 nd->start = start;
65 if (nd->end < nd->start)
66 nd->start = nd->end;
67 }
68 if (nd->end > end) {
69 nd->end = end;
70 if (nd->start > nd->end)
71 nd->start = nd->end;
72 }
73 }
74
75 static __init void bad_srat(void)
76 {
77 int i;
78 printk(KERN_ERR "SRAT: SRAT not used.\n");
79 acpi_numa = -1;
80 for (i = 0; i < MAX_LOCAL_APIC; i++)
81 apicid_to_node[i] = NUMA_NO_NODE;
82 for (i = 0; i < MAX_NUMNODES; i++)
83 nodes_add[i].start = nodes[i].end = 0;
84 remove_all_active_ranges();
85 }
86
87 static __init inline int srat_disabled(void)
88 {
89 return numa_off || acpi_numa < 0;
90 }
91
92 /* Callback for SLIT parsing */
93 void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
94 {
95 unsigned length;
96 unsigned long phys;
97
98 length = slit->header.length;
99 phys = find_e820_area(0, max_pfn_mapped<<PAGE_SHIFT, length,
100 PAGE_SIZE);
101
102 if (phys == -1L)
103 panic(" Can not save slit!\n");
104
105 acpi_slit = __va(phys);
106 memcpy(acpi_slit, slit, length);
107 reserve_early(phys, phys + length, "ACPI SLIT");
108 }
109
110 /* Callback for Proximity Domain -> x2APIC mapping */
111 void __init
112 acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa)
113 {
114 int pxm, node;
115 int apic_id;
116
117 if (srat_disabled())
118 return;
119 if (pa->header.length < sizeof(struct acpi_srat_x2apic_cpu_affinity)) {
120 bad_srat();
121 return;
122 }
123 if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
124 return;
125 pxm = pa->proximity_domain;
126 node = setup_node(pxm);
127 if (node < 0) {
128 printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
129 bad_srat();
130 return;
131 }
132
133 apic_id = pa->apic_id;
134 apicid_to_node[apic_id] = node;
135 node_set(node, cpu_nodes_parsed);
136 acpi_numa = 1;
137 printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
138 pxm, apic_id, node);
139 }
140
141 /* Callback for Proximity Domain -> LAPIC mapping */
142 void __init
143 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
144 {
145 int pxm, node;
146 int apic_id;
147
148 if (srat_disabled())
149 return;
150 if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) {
151 bad_srat();
152 return;
153 }
154 if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
155 return;
156 pxm = pa->proximity_domain_lo;
157 node = setup_node(pxm);
158 if (node < 0) {
159 printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
160 bad_srat();
161 return;
162 }
163
164 if (get_uv_system_type() >= UV_X2APIC)
165 apic_id = (pa->apic_id << 8) | pa->local_sapic_eid;
166 else
167 apic_id = pa->apic_id;
168 apicid_to_node[apic_id] = node;
169 node_set(node, cpu_nodes_parsed);
170 acpi_numa = 1;
171 printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
172 pxm, apic_id, node);
173 }
174
175 #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
176 static inline int save_add_info(void) {return 1;}
177 #else
178 static inline int save_add_info(void) {return 0;}
179 #endif
180 /*
181 * Update nodes_add[]
182 * This code supports one contiguous hot add area per node
183 */
184 static void __init
185 update_nodes_add(int node, unsigned long start, unsigned long end)
186 {
187 unsigned long s_pfn = start >> PAGE_SHIFT;
188 unsigned long e_pfn = end >> PAGE_SHIFT;
189 int changed = 0;
190 struct bootnode *nd = &nodes_add[node];
191
192 /* I had some trouble with strange memory hotadd regions breaking
193 the boot. Be very strict here and reject anything unexpected.
194 If you want working memory hotadd write correct SRATs.
195
196 The node size check is a basic sanity check to guard against
197 mistakes */
198 if ((signed long)(end - start) < NODE_MIN_SIZE) {
199 printk(KERN_ERR "SRAT: Hotplug area too small\n");
200 return;
201 }
202
203 /* This check might be a bit too strict, but I'm keeping it for now. */
204 if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
205 printk(KERN_ERR
206 "SRAT: Hotplug area %lu -> %lu has existing memory\n",
207 s_pfn, e_pfn);
208 return;
209 }
210
211 /* Looks good */
212
213 if (nd->start == nd->end) {
214 nd->start = start;
215 nd->end = end;
216 changed = 1;
217 } else {
218 if (nd->start == end) {
219 nd->start = start;
220 changed = 1;
221 }
222 if (nd->end == start) {
223 nd->end = end;
224 changed = 1;
225 }
226 if (!changed)
227 printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
228 }
229
230 if (changed)
231 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n",
232 nd->start, nd->end);
233 }
234
235 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
236 void __init
237 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
238 {
239 struct bootnode *nd, oldnode;
240 unsigned long start, end;
241 int node, pxm;
242 int i;
243
244 if (srat_disabled())
245 return;
246 if (ma->header.length != sizeof(struct acpi_srat_mem_affinity)) {
247 bad_srat();
248 return;
249 }
250 if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
251 return;
252
253 if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
254 return;
255 start = ma->base_address;
256 end = start + ma->length;
257 pxm = ma->proximity_domain;
258 node = setup_node(pxm);
259 if (node < 0) {
260 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
261 bad_srat();
262 return;
263 }
264 i = conflicting_memblks(start, end);
265 if (i == node) {
266 printk(KERN_WARNING
267 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
268 pxm, start, end, nodes[i].start, nodes[i].end);
269 } else if (i >= 0) {
270 printk(KERN_ERR
271 "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
272 pxm, start, end, node_to_pxm(i),
273 nodes[i].start, nodes[i].end);
274 bad_srat();
275 return;
276 }
277 nd = &nodes[node];
278 oldnode = *nd;
279 if (!node_test_and_set(node, nodes_parsed)) {
280 nd->start = start;
281 nd->end = end;
282 } else {
283 if (start < nd->start)
284 nd->start = start;
285 if (nd->end < end)
286 nd->end = end;
287 }
288
289 printk(KERN_INFO "SRAT: Node %u PXM %u %lx-%lx\n", node, pxm,
290 start, end);
291 e820_register_active_regions(node, start >> PAGE_SHIFT,
292 end >> PAGE_SHIFT);
293
294 if (ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) {
295 update_nodes_add(node, start, end);
296 /* restore nodes[node] */
297 *nd = oldnode;
298 if ((nd->start | nd->end) == 0)
299 node_clear(node, nodes_parsed);
300 }
301
302 node_memblk_range[num_node_memblks].start = start;
303 node_memblk_range[num_node_memblks].end = end;
304 memblk_nodeid[num_node_memblks] = node;
305 num_node_memblks++;
306 }
307
308 /* Sanity check to catch more bad SRATs (they are amazingly common).
309 Make sure the PXMs cover all memory. */
310 static int __init nodes_cover_memory(const struct bootnode *nodes)
311 {
312 int i;
313 unsigned long pxmram, e820ram;
314
315 pxmram = 0;
316 for_each_node_mask(i, nodes_parsed) {
317 unsigned long s = nodes[i].start >> PAGE_SHIFT;
318 unsigned long e = nodes[i].end >> PAGE_SHIFT;
319 pxmram += e - s;
320 pxmram -= absent_pages_in_range(s, e);
321 if ((long)pxmram < 0)
322 pxmram = 0;
323 }
324
325 e820ram = max_pfn - (e820_hole_size(0, max_pfn<<PAGE_SHIFT)>>PAGE_SHIFT);
326 /* We seem to lose 3 pages somewhere. Allow 1M of slack. */
327 if ((long)(e820ram - pxmram) >= (1<<(20 - PAGE_SHIFT))) {
328 printk(KERN_ERR
329 "SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
330 (pxmram << PAGE_SHIFT) >> 20,
331 (e820ram << PAGE_SHIFT) >> 20);
332 return 0;
333 }
334 return 1;
335 }
336
337 void __init acpi_numa_arch_fixup(void) {}
338
339 /* Use the information discovered above to actually set up the nodes. */
340 int __init acpi_scan_nodes(unsigned long start, unsigned long end)
341 {
342 int i;
343
344 if (acpi_numa <= 0)
345 return -1;
346
347 /* First clean up the node list */
348 for (i = 0; i < MAX_NUMNODES; i++)
349 cutoff_node(i, start, end);
350
351 if (!nodes_cover_memory(nodes)) {
352 bad_srat();
353 return -1;
354 }
355
356 memnode_shift = compute_hash_shift(node_memblk_range, num_node_memblks,
357 memblk_nodeid);
358 if (memnode_shift < 0) {
359 printk(KERN_ERR
360 "SRAT: No NUMA node hash function found. Contact maintainer\n");
361 bad_srat();
362 return -1;
363 }
364
365 /* Account for nodes with cpus and no memory */
366 nodes_or(node_possible_map, nodes_parsed, cpu_nodes_parsed);
367
368 /* Finally register nodes */
369 for_each_node_mask(i, node_possible_map)
370 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
371 /* Try again in case setup_node_bootmem missed one due
372 to missing bootmem */
373 for_each_node_mask(i, node_possible_map)
374 if (!node_online(i))
375 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
376
377 for (i = 0; i < nr_cpu_ids; i++) {
378 int node = early_cpu_to_node(i);
379
380 if (node == NUMA_NO_NODE)
381 continue;
382 if (!node_online(node))
383 numa_clear_node(i);
384 }
385 numa_init_array();
386 return 0;
387 }
388
389 #ifdef CONFIG_NUMA_EMU
390 static int fake_node_to_pxm_map[MAX_NUMNODES] __initdata = {
391 [0 ... MAX_NUMNODES-1] = PXM_INVAL
392 };
393 static s16 fake_apicid_to_node[MAX_LOCAL_APIC] __initdata = {
394 [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
395 };
396 static int __init find_node_by_addr(unsigned long addr)
397 {
398 int ret = NUMA_NO_NODE;
399 int i;
400
401 for_each_node_mask(i, nodes_parsed) {
402 /*
403 * Find the real node that this emulated node appears on. For
404 * the sake of simplicity, we only use a real node's starting
405 * address to determine which emulated node it appears on.
406 */
407 if (addr >= nodes[i].start && addr < nodes[i].end) {
408 ret = i;
409 break;
410 }
411 }
412 return ret;
413 }
414
415 /*
416 * In NUMA emulation, we need to setup proximity domain (_PXM) to node ID
417 * mappings that respect the real ACPI topology but reflect our emulated
418 * environment. For each emulated node, we find which real node it appears on
419 * and create PXM to NID mappings for those fake nodes which mirror that
420 * locality. SLIT will now represent the correct distances between emulated
421 * nodes as a result of the real topology.
422 */
423 void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
424 {
425 int i, j;
426
427 printk(KERN_INFO "Faking PXM affinity for fake nodes on real "
428 "topology.\n");
429 for (i = 0; i < num_nodes; i++) {
430 int nid, pxm;
431
432 nid = find_node_by_addr(fake_nodes[i].start);
433 if (nid == NUMA_NO_NODE)
434 continue;
435 pxm = node_to_pxm(nid);
436 if (pxm == PXM_INVAL)
437 continue;
438 fake_node_to_pxm_map[i] = pxm;
439 /*
440 * For each apicid_to_node mapping that exists for this real
441 * node, it must now point to the fake node ID.
442 */
443 for (j = 0; j < MAX_LOCAL_APIC; j++)
444 if (apicid_to_node[j] == nid)
445 fake_apicid_to_node[j] = i;
446 }
447 for (i = 0; i < num_nodes; i++)
448 __acpi_map_pxm_to_node(fake_node_to_pxm_map[i], i);
449 memcpy(apicid_to_node, fake_apicid_to_node, sizeof(apicid_to_node));
450
451 nodes_clear(nodes_parsed);
452 for (i = 0; i < num_nodes; i++)
453 if (fake_nodes[i].start != fake_nodes[i].end)
454 node_set(i, nodes_parsed);
455 WARN_ON(!nodes_cover_memory(fake_nodes));
456 }
457
458 static int null_slit_node_compare(int a, int b)
459 {
460 return node_to_pxm(a) == node_to_pxm(b);
461 }
462 #else
463 static int null_slit_node_compare(int a, int b)
464 {
465 return a == b;
466 }
467 #endif /* CONFIG_NUMA_EMU */
468
469 int __node_distance(int a, int b)
470 {
471 int index;
472
473 if (!acpi_slit)
474 return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
475 REMOTE_DISTANCE;
476 index = acpi_slit->locality_count * node_to_pxm(a);
477 return acpi_slit->entry[index + node_to_pxm(b)];
478 }
479
480 EXPORT_SYMBOL(__node_distance);
481
482 #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) || defined(CONFIG_ACPI_HOTPLUG_MEMORY)
483 int memory_add_physaddr_to_nid(u64 start)
484 {
485 int i, ret = 0;
486
487 for_each_node(i)
488 if (nodes_add[i].start <= start && nodes_add[i].end > start)
489 ret = i;
490
491 return ret;
492 }
493 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
494 #endif
Linux ACPI git tree (mirror)