845001c617cc7130697b5e659f3e5ce0e71eb936
[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/mm.h>
20 #include <asm/proto.h>
21 #include <asm/numa.h>
22 #include <asm/e820.h>
23
24 int acpi_numa __initdata;
25
26 static struct acpi_table_slit *acpi_slit;
27
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;
33
34 /* Too small nodes confuse the VM badly. Usually they result
35    from BIOS bugs. */
36 #define NODE_MIN_SIZE (4*1024*1024)
37
38 static __init int setup_node(int pxm)
39 {
40         return acpi_map_pxm_to_node(pxm);
41 }
42
43 static __init int conflicting_nodes(unsigned long start, unsigned long end)
44 {
45         int i;
46         for_each_node_mask(i, nodes_parsed) {
47                 struct bootnode *nd = &nodes[i];
48                 if (nd->start == nd->end)
49                         continue;
50                 if (nd->end > start && nd->start < end)
51                         return i;
52                 if (nd->end == end && nd->start == start)
53                         return i;
54         }
55         return -1;
56 }
57
58 static __init void cutoff_node(int i, unsigned long start, unsigned long end)
59 {
60         struct bootnode *nd = &nodes[i];
61
62         if (found_add_area)
63                 return;
64
65         if (nd->start < start) {
66                 nd->start = start;
67                 if (nd->end < nd->start)
68                         nd->start = nd->end;
69         }
70         if (nd->end > end) {
71                 nd->end = end;
72                 if (nd->start > nd->end)
73                         nd->start = nd->end;
74         }
75 }
76
77 static __init void bad_srat(void)
78 {
79         int i;
80         printk(KERN_ERR "SRAT: SRAT not used.\n");
81         acpi_numa = -1;
82         found_add_area = 0;
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();
88 }
89
90 static __init inline int srat_disabled(void)
91 {
92         return numa_off || acpi_numa < 0;
93 }
94
95 /*
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.
100  */
101 static __init int slit_valid(struct acpi_table_slit *slit)
102 {
103         int i, j;
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];
108                         if (i == j) {
109                                 if (val != LOCAL_DISTANCE)
110                                         return 0;
111                         } else if (val <= LOCAL_DISTANCE)
112                                 return 0;
113                 }
114         }
115         return 1;
116 }
117
118 /* Callback for SLIT parsing */
119 void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
120 {
121         if (!slit_valid(slit)) {
122                 printk(KERN_INFO "ACPI: SLIT table looks invalid. Not used.\n");
123                 return;
124         }
125         acpi_slit = slit;
126 }
127
128 /* Callback for Proximity Domain -> LAPIC mapping */
129 void __init
130 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
131 {
132         int pxm, node;
133         int apic_id;
134
135         apic_id = pa->apic_id;
136         if (srat_disabled())
137                 return;
138         if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) {
139                 bad_srat();
140                 return;
141         }
142         if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
143                 return;
144         pxm = pa->proximity_domain_lo;
145         node = setup_node(pxm);
146         if (node < 0) {
147                 printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
148                 bad_srat();
149                 return;
150         }
151         apicid_to_node[apic_id] = node;
152         acpi_numa = 1;
153         printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
154                pxm, apic_id, node);
155 }
156
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;}
161 #else
162 static inline int save_add_info(void) {return 0;}
163 #endif
164 /*
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.
168  */
169 static int __init
170 reserve_hotadd(int node, unsigned long start, unsigned long end)
171 {
172         unsigned long s_pfn = start >> PAGE_SHIFT;
173         unsigned long e_pfn = end >> PAGE_SHIFT;
174         int ret = 0, changed = 0;
175         struct bootnode *nd = &nodes_add[node];
176
177         /* I had some trouble with strange memory hotadd regions breaking
178            the boot. Be very strict here and reject anything unexpected.
179            If you want working memory hotadd write correct SRATs.
180
181            The node size check is a basic sanity check to guard against
182            mistakes */
183         if ((signed long)(end - start) < NODE_MIN_SIZE) {
184                 printk(KERN_ERR "SRAT: Hotplug area too small\n");
185                 return -1;
186         }
187
188         /* This check might be a bit too strict, but I'm keeping it for now. */
189         if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
190                 printk(KERN_ERR
191                         "SRAT: Hotplug area %lu -> %lu has existing memory\n",
192                         s_pfn, e_pfn);
193                 return -1;
194         }
195
196         if (!hotadd_enough_memory(&nodes_add[node]))  {
197                 printk(KERN_ERR "SRAT: Hotplug area too large\n");
198                 return -1;
199         }
200
201         /* Looks good */
202
203         if (nd->start == nd->end) {
204                 nd->start = start;
205                 nd->end = end;
206                 changed = 1;
207         } else {
208                 if (nd->start == end) {
209                         nd->start = start;
210                         changed = 1;
211                 }
212                 if (nd->end == start) {
213                         nd->end = end;
214                         changed = 1;
215                 }
216                 if (!changed)
217                         printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
218         }
219
220         ret = update_end_of_memory(nd->end);
221
222         if (changed)
223                 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
224         return ret;
225 }
226
227 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
228 void __init
229 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
230 {
231         struct bootnode *nd, oldnode;
232         unsigned long start, end;
233         int node, pxm;
234         int i;
235
236         if (srat_disabled())
237                 return;
238         if (ma->header.length != sizeof(struct acpi_srat_mem_affinity)) {
239                 bad_srat();
240                 return;
241         }
242         if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
243                 return;
244
245         if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
246                 return;
247         start = ma->base_address;
248         end = start + ma->length;
249         pxm = ma->proximity_domain;
250         node = setup_node(pxm);
251         if (node < 0) {
252                 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
253                 bad_srat();
254                 return;
255         }
256         i = conflicting_nodes(start, end);
257         if (i == node) {
258                 printk(KERN_WARNING
259                 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
260                         pxm, start, end, nodes[i].start, nodes[i].end);
261         } else if (i >= 0) {
262                 printk(KERN_ERR
263                        "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
264                        pxm, start, end, node_to_pxm(i),
265                         nodes[i].start, nodes[i].end);
266                 bad_srat();
267                 return;
268         }
269         nd = &nodes[node];
270         oldnode = *nd;
271         if (!node_test_and_set(node, nodes_parsed)) {
272                 nd->start = start;
273                 nd->end = end;
274         } else {
275                 if (start < nd->start)
276                         nd->start = start;
277                 if (nd->end < end)
278                         nd->end = end;
279         }
280
281         printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
282                nd->start, nd->end);
283         e820_register_active_regions(node, nd->start >> PAGE_SHIFT,
284                                                 nd->end >> PAGE_SHIFT);
285         push_node_boundaries(node, nd->start >> PAGE_SHIFT,
286                                                 nd->end >> PAGE_SHIFT);
287
288         if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) &&
289             (reserve_hotadd(node, start, end) < 0)) {
290                 /* Ignore hotadd region. Undo damage */
291                 printk(KERN_NOTICE "SRAT: Hotplug region ignored\n");
292                 *nd = oldnode;
293                 if ((nd->start | nd->end) == 0)
294                         node_clear(node, nodes_parsed);
295         }
296 }
297
298 /* Sanity check to catch more bad SRATs (they are amazingly common).
299    Make sure the PXMs cover all memory. */
300 static int __init nodes_cover_memory(const struct bootnode *nodes)
301 {
302         int i;
303         unsigned long pxmram, e820ram;
304
305         pxmram = 0;
306         for_each_node_mask(i, nodes_parsed) {
307                 unsigned long s = nodes[i].start >> PAGE_SHIFT;
308                 unsigned long e = nodes[i].end >> PAGE_SHIFT;
309                 pxmram += e - s;
310                 pxmram -= absent_pages_in_range(s, e);
311                 if ((long)pxmram < 0)
312                         pxmram = 0;
313         }
314
315         e820ram = end_pfn - absent_pages_in_range(0, end_pfn);
316         /* We seem to lose 3 pages somewhere. Allow a bit of slack. */
317         if ((long)(e820ram - pxmram) >= 1*1024*1024) {
318                 printk(KERN_ERR
319         "SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
320                         (pxmram << PAGE_SHIFT) >> 20,
321                         (e820ram << PAGE_SHIFT) >> 20);
322                 return 0;
323         }
324         return 1;
325 }
326
327 static void __init unparse_node(int node)
328 {
329         int i;
330         node_clear(node, nodes_parsed);
331         for (i = 0; i < MAX_LOCAL_APIC; i++) {
332                 if (apicid_to_node[i] == node)
333                         apicid_to_node[i] = NUMA_NO_NODE;
334         }
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                  * don't confuse VM with a node that doesn't have the
352                  * minimum memory.
353                  */
354                 if (nodes[i].end &&
355                         (nodes[i].end - nodes[i].start) < NODE_MIN_SIZE) {
356                         unparse_node(i);
357                         node_set_offline(i);
358                 }
359         }
360
361         if (!nodes_cover_memory(nodes)) {
362                 bad_srat();
363                 return -1;
364         }
365
366         memnode_shift = compute_hash_shift(nodes, MAX_NUMNODES);
367         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         }
373
374         node_possible_map = nodes_parsed;
375
376         /* Finally register nodes */
377         for_each_node_mask(i, node_possible_map)
378                 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
379         /* Try again in case setup_node_bootmem missed one due
380            to missing bootmem */
381         for_each_node_mask(i, node_possible_map)
382                 if (!node_online(i))
383                         setup_node_bootmem(i, nodes[i].start, nodes[i].end);
384
385         for (i = 0; i < NR_CPUS; i++) {
386                 int node = early_cpu_to_node(i);
387
388                 if (node == NUMA_NO_NODE)
389                         continue;
390                 if (!node_isset(node, node_possible_map))
391                         numa_set_node(i, NUMA_NO_NODE);
392         }
393         numa_init_array();
394         return 0;
395 }
396
397 #ifdef CONFIG_NUMA_EMU
398 static int fake_node_to_pxm_map[MAX_NUMNODES] __initdata = {
399         [0 ... MAX_NUMNODES-1] = PXM_INVAL
400 };
401 static s16 fake_apicid_to_node[MAX_LOCAL_APIC] __initdata = {
402         [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
403 };
404 static 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         }
420         return ret;
421 }
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  */
431 void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
432 {
433         int i, j;
434
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;
447                 /*
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;
454         }
455         for (i = 0; i < num_nodes; i++)
456                 __acpi_map_pxm_to_node(fake_node_to_pxm_map[i], i);
457         memcpy(apicid_to_node, fake_apicid_to_node, sizeof(apicid_to_node));
458
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
466 static int null_slit_node_compare(int a, int b)
467 {
468         return node_to_pxm(a) == node_to_pxm(b);
469 }
470 #else
471 static int null_slit_node_compare(int a, int b)
472 {
473         return a == b;
474 }
475 #endif /* CONFIG_NUMA_EMU */
476
477 void __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,
492                                nodes_add[nodeid].end - nodes_add[nodeid].start,
493                                BOOTMEM_DEFAULT);
494         }
495 }
496
497 int __node_distance(int a, int b)
498 {
499         int index;
500
501         if (!acpi_slit)
502                 return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
503                                                       REMOTE_DISTANCE;
504         index = acpi_slit->locality_count * node_to_pxm(a);
505         return acpi_slit->entry[index + node_to_pxm(b)];
506 }
507
508 EXPORT_SYMBOL(__node_distance);
509
510 int memory_add_physaddr_to_nid(u64 start)
511 {
512         int i, ret = 0;
513
514         for_each_node(i)
515                 if (nodes_add[i].start <= start && nodes_add[i].end > start)
516                         ret = i;
517
518         return ret;
519 }
520 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
521