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