2 * ACPI 3.0 based NUMA setup
3 * Copyright 2004 Andi Kleen, SuSE Labs.
5 * Reads the ACPI SRAT table to figure out what memory belongs to which CPUs.
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.
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>
20 #include <asm/proto.h>
24 int acpi_numa __initdata;
26 static struct acpi_table_slit *acpi_slit;
28 static nodemask_t nodes_parsed __initdata;
29 static struct bootnode nodes[MAX_NUMNODES] __initdata;
30 static struct bootnode nodes_add[MAX_NUMNODES];
31 static int found_add_area __initdata;
32 int hotadd_percent __initdata = 0;
34 /* Too small nodes confuse the VM badly. Usually they result
36 #define NODE_MIN_SIZE (4*1024*1024)
38 static __init int setup_node(int pxm)
40 return acpi_map_pxm_to_node(pxm);
43 static __init int conflicting_nodes(unsigned long start, unsigned long end)
46 for_each_node_mask(i, nodes_parsed) {
47 struct bootnode *nd = &nodes[i];
48 if (nd->start == nd->end)
50 if (nd->end > start && nd->start < end)
52 if (nd->end == end && nd->start == start)
58 static __init void cutoff_node(int i, unsigned long start, unsigned long end)
60 struct bootnode *nd = &nodes[i];
65 if (nd->start < start) {
67 if (nd->end < nd->start)
72 if (nd->start > nd->end)
77 static __init void bad_srat(void)
80 printk(KERN_ERR "SRAT: SRAT not used.\n");
83 for (i = 0; i < MAX_LOCAL_APIC; i++)
84 apicid_to_node[i] = NUMA_NO_NODE;
85 for (i = 0; i < MAX_NUMNODES; i++)
86 nodes_add[i].start = nodes[i].end = 0;
87 remove_all_active_ranges();
90 static __init inline int srat_disabled(void)
92 return numa_off || acpi_numa < 0;
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.
101 static __init int slit_valid(struct acpi_table_slit *slit)
104 int d = slit->locality_count;
105 for (i = 0; i < d; i++) {
106 for (j = 0; j < d; j++) {
107 u8 val = slit->entry[d*i + j];
109 if (val != LOCAL_DISTANCE)
111 } else if (val <= LOCAL_DISTANCE)
118 /* Callback for SLIT parsing */
119 void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
121 if (!slit_valid(slit)) {
122 printk(KERN_INFO "ACPI: SLIT table looks invalid. Not used.\n");
128 /* Callback for Proximity Domain -> LAPIC mapping */
130 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
135 apic_id = pa->apic_id;
138 if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) {
142 if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
144 pxm = pa->proximity_domain_lo;
145 node = setup_node(pxm);
147 printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
151 apicid_to_node[apic_id] = node;
153 printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
157 int update_end_of_memory(unsigned long end) {return -1;}
158 static int hotadd_enough_memory(struct bootnode *nd) {return 1;}
159 #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
160 static inline int save_add_info(void) {return 1;}
162 static inline int save_add_info(void) {return 0;}
165 * Update nodes_add and decide if to include add are in the zone.
166 * Both SPARSE and RESERVE need nodes_add information.
167 * This code supports one contiguous hot add area per node.
169 static int reserve_hotadd(int node, unsigned long start, unsigned long end)
171 unsigned long s_pfn = start >> PAGE_SHIFT;
172 unsigned long e_pfn = end >> PAGE_SHIFT;
173 int ret = 0, changed = 0;
174 struct bootnode *nd = &nodes_add[node];
176 /* I had some trouble with strange memory hotadd regions breaking
177 the boot. Be very strict here and reject anything unexpected.
178 If you want working memory hotadd write correct SRATs.
180 The node size check is a basic sanity check to guard against
182 if ((signed long)(end - start) < NODE_MIN_SIZE) {
183 printk(KERN_ERR "SRAT: Hotplug area too small\n");
187 /* This check might be a bit too strict, but I'm keeping it for now. */
188 if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
190 "SRAT: Hotplug area %lu -> %lu has existing memory\n",
195 if (!hotadd_enough_memory(&nodes_add[node])) {
196 printk(KERN_ERR "SRAT: Hotplug area too large\n");
202 if (nd->start == nd->end) {
207 if (nd->start == end) {
211 if (nd->end == start) {
216 printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
219 ret = update_end_of_memory(nd->end);
222 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
226 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
228 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
230 struct bootnode *nd, oldnode;
231 unsigned long start, end;
237 if (ma->header.length != sizeof(struct acpi_srat_mem_affinity)) {
241 if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
244 if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
246 start = ma->base_address;
247 end = start + ma->length;
248 pxm = ma->proximity_domain;
249 node = setup_node(pxm);
251 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
255 i = conflicting_nodes(start, end);
258 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
259 pxm, start, end, nodes[i].start, nodes[i].end);
262 "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
263 pxm, start, end, node_to_pxm(i),
264 nodes[i].start, nodes[i].end);
270 if (!node_test_and_set(node, nodes_parsed)) {
274 if (start < nd->start)
280 printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
282 e820_register_active_regions(node, nd->start >> PAGE_SHIFT,
283 nd->end >> PAGE_SHIFT);
284 push_node_boundaries(node, nd->start >> PAGE_SHIFT,
285 nd->end >> PAGE_SHIFT);
287 if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) &&
288 (reserve_hotadd(node, start, end) < 0)) {
289 /* Ignore hotadd region. Undo damage */
290 printk(KERN_NOTICE "SRAT: Hotplug region ignored\n");
292 if ((nd->start | nd->end) == 0)
293 node_clear(node, nodes_parsed);
297 /* Sanity check to catch more bad SRATs (they are amazingly common).
298 Make sure the PXMs cover all memory. */
299 static int __init nodes_cover_memory(const struct bootnode *nodes)
302 unsigned long pxmram, e820ram;
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;
309 pxmram -= absent_pages_in_range(s, e);
310 if ((long)pxmram < 0)
314 e820ram = end_pfn - absent_pages_in_range(0, end_pfn);
315 /* We seem to lose 3 pages somewhere. Allow a bit of slack. */
316 if ((long)(e820ram - pxmram) >= 1*1024*1024) {
318 "SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
319 (pxmram << PAGE_SHIFT) >> 20,
320 (e820ram << PAGE_SHIFT) >> 20);
326 static void unparse_node(int node)
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;
336 void __init acpi_numa_arch_fixup(void) {}
338 /* Use the information discovered above to actually set up the nodes. */
339 int __init acpi_scan_nodes(unsigned long start, unsigned long end)
346 /* First clean up the node list */
347 for (i = 0; i < MAX_NUMNODES; i++) {
348 cutoff_node(i, start, end);
349 /* ZZZ why was this needed. At least add a comment */
350 if (nodes[i].end && (nodes[i].end - nodes[i].start) < NODE_MIN_SIZE) {
356 if (!nodes_cover_memory(nodes)) {
361 memnode_shift = compute_hash_shift(nodes, MAX_NUMNODES);
362 if (memnode_shift < 0) {
364 "SRAT: No NUMA node hash function found. Contact maintainer\n");
369 node_possible_map = nodes_parsed;
371 /* Finally register nodes */
372 for_each_node_mask(i, node_possible_map)
373 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
374 /* Try again in case setup_node_bootmem missed one due
375 to missing bootmem */
376 for_each_node_mask(i, node_possible_map)
378 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
380 for (i = 0; i < NR_CPUS; i++) {
381 if (cpu_to_node(i) == NUMA_NO_NODE)
383 if (!node_isset(cpu_to_node(i), node_possible_map))
384 numa_set_node(i, NUMA_NO_NODE);
390 #ifdef CONFIG_NUMA_EMU
391 static int fake_node_to_pxm_map[MAX_NUMNODES] __initdata = {
392 [0 ... MAX_NUMNODES-1] = PXM_INVAL
394 static unsigned char fake_apicid_to_node[MAX_LOCAL_APIC] __initdata = {
395 [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
397 static int __init find_node_by_addr(unsigned long addr)
399 int ret = NUMA_NO_NODE;
402 for_each_node_mask(i, nodes_parsed) {
404 * Find the real node that this emulated node appears on. For
405 * the sake of simplicity, we only use a real node's starting
406 * address to determine which emulated node it appears on.
408 if (addr >= nodes[i].start && addr < nodes[i].end) {
417 * In NUMA emulation, we need to setup proximity domain (_PXM) to node ID
418 * mappings that respect the real ACPI topology but reflect our emulated
419 * environment. For each emulated node, we find which real node it appears on
420 * and create PXM to NID mappings for those fake nodes which mirror that
421 * locality. SLIT will now represent the correct distances between emulated
422 * nodes as a result of the real topology.
424 void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
428 printk(KERN_INFO "Faking PXM affinity for fake nodes on real "
430 for (i = 0; i < num_nodes; i++) {
433 nid = find_node_by_addr(fake_nodes[i].start);
434 if (nid == NUMA_NO_NODE)
436 pxm = node_to_pxm(nid);
437 if (pxm == PXM_INVAL)
439 fake_node_to_pxm_map[i] = pxm;
441 * For each apicid_to_node mapping that exists for this real
442 * node, it must now point to the fake node ID.
444 for (j = 0; j < MAX_LOCAL_APIC; j++)
445 if (apicid_to_node[j] == nid)
446 fake_apicid_to_node[j] = i;
448 for (i = 0; i < num_nodes; i++)
449 __acpi_map_pxm_to_node(fake_node_to_pxm_map[i], i);
450 memcpy(apicid_to_node, fake_apicid_to_node, sizeof(apicid_to_node));
452 nodes_clear(nodes_parsed);
453 for (i = 0; i < num_nodes; i++)
454 if (fake_nodes[i].start != fake_nodes[i].end)
455 node_set(i, nodes_parsed);
456 WARN_ON(!nodes_cover_memory(fake_nodes));
459 static int null_slit_node_compare(int a, int b)
461 return node_to_pxm(a) == node_to_pxm(b);
464 static int null_slit_node_compare(int a, int b)
468 #endif /* CONFIG_NUMA_EMU */
470 void __init srat_reserve_add_area(int nodeid)
472 if (found_add_area && nodes_add[nodeid].end) {
475 printk(KERN_INFO "SRAT: Reserving hot-add memory space "
476 "for node %d at %Lx-%Lx\n",
477 nodeid, nodes_add[nodeid].start, nodes_add[nodeid].end);
478 total_mb = (nodes_add[nodeid].end - nodes_add[nodeid].start)
480 total_mb *= sizeof(struct page);
482 printk(KERN_INFO "SRAT: This will cost you %Lu MB of "
483 "pre-allocated memory.\n", (unsigned long long)total_mb);
484 reserve_bootmem_node(NODE_DATA(nodeid), nodes_add[nodeid].start,
485 nodes_add[nodeid].end - nodes_add[nodeid].start);
489 int __node_distance(int a, int b)
494 return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
496 index = acpi_slit->locality_count * node_to_pxm(a);
497 return acpi_slit->entry[index + node_to_pxm(b)];
500 EXPORT_SYMBOL(__node_distance);
502 int memory_add_physaddr_to_nid(u64 start)
507 if (nodes_add[i].start <= start && nodes_add[i].end > start)
512 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);