x86: change size of node ids from u8 to u16
[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 reserve_hotadd(int node, unsigned long start, unsigned long end)
170 {
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];
175
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.
179
180            The node size check is a basic sanity check to guard against
181            mistakes */
182         if ((signed long)(end - start) < NODE_MIN_SIZE) {
183                 printk(KERN_ERR "SRAT: Hotplug area too small\n");
184                 return -1;
185         }
186
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) {
189                 printk(KERN_ERR
190                         "SRAT: Hotplug area %lu -> %lu has existing memory\n",
191                         s_pfn, e_pfn);
192                 return -1;
193         }
194
195         if (!hotadd_enough_memory(&nodes_add[node]))  {
196                 printk(KERN_ERR "SRAT: Hotplug area too large\n");
197                 return -1;
198         }
199
200         /* Looks good */
201
202         if (nd->start == nd->end) {
203                 nd->start = start;
204                 nd->end = end;
205                 changed = 1;
206         } else {
207                 if (nd->start == end) {
208                         nd->start = start;
209                         changed = 1;
210                 }
211                 if (nd->end == start) {
212                         nd->end = end;
213                         changed = 1;
214                 }
215                 if (!changed)
216                         printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
217         }
218
219         ret = update_end_of_memory(nd->end);
220
221         if (changed)
222                 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
223         return ret;
224 }
225
226 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
227 void __init
228 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
229 {
230         struct bootnode *nd, oldnode;
231         unsigned long start, end;
232         int node, pxm;
233         int i;
234
235         if (srat_disabled())
236                 return;
237         if (ma->header.length != sizeof(struct acpi_srat_mem_affinity)) {
238                 bad_srat();
239                 return;
240         }
241         if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
242                 return;
243
244         if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
245                 return;
246         start = ma->base_address;
247         end = start + ma->length;
248         pxm = ma->proximity_domain;
249         node = setup_node(pxm);
250         if (node < 0) {
251                 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
252                 bad_srat();
253                 return;
254         }
255         i = conflicting_nodes(start, end);
256         if (i == node) {
257                 printk(KERN_WARNING
258                 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
259                         pxm, start, end, nodes[i].start, nodes[i].end);
260         } else if (i >= 0) {
261                 printk(KERN_ERR
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);
265                 bad_srat();
266                 return;
267         }
268         nd = &nodes[node];
269         oldnode = *nd;
270         if (!node_test_and_set(node, nodes_parsed)) {
271                 nd->start = start;
272                 nd->end = end;
273         } else {
274                 if (start < nd->start)
275                         nd->start = start;
276                 if (nd->end < end)
277                         nd->end = end;
278         }
279
280         printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
281                nd->start, nd->end);
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);
286
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");
291                 *nd = oldnode;
292                 if ((nd->start | nd->end) == 0)
293                         node_clear(node, nodes_parsed);
294         }
295 }
296
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)
300 {
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;
309                 pxmram -= absent_pages_in_range(s, e);
310                 if ((long)pxmram < 0)
311                         pxmram = 0;
312         }
313
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) {
317                 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
326 static void unparse_node(int node)
327 {
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
336 void __init acpi_numa_arch_fixup(void) {}
337
338 /* Use the information discovered above to actually set up the nodes. */
339 int __init acpi_scan_nodes(unsigned long start, unsigned long end)
340 {
341         int i;
342
343         if (acpi_numa <= 0)
344                 return -1;
345
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) {
351                         unparse_node(i);
352                         node_set_offline(i);
353                 }
354         }
355
356         if (!nodes_cover_memory(nodes)) {
357                 bad_srat();
358                 return -1;
359         }
360
361         memnode_shift = compute_hash_shift(nodes, MAX_NUMNODES);
362         if (memnode_shift < 0) {
363                 printk(KERN_ERR
364                      "SRAT: No NUMA node hash function found. Contact maintainer\n");
365                 bad_srat();
366                 return -1;
367         }
368
369         node_possible_map = nodes_parsed;
370
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)
377                 if (!node_online(i))
378                         setup_node_bootmem(i, nodes[i].start, nodes[i].end);
379
380         for (i = 0; i < NR_CPUS; i++) {
381                 if (cpu_to_node(i) == NUMA_NO_NODE)
382                         continue;
383                 if (!node_isset(cpu_to_node(i), node_possible_map))
384                         numa_set_node(i, NUMA_NO_NODE);
385         }
386         numa_init_array();
387         return 0;
388 }
389
390 #ifdef CONFIG_NUMA_EMU
391 static int fake_node_to_pxm_map[MAX_NUMNODES] __initdata = {
392         [0 ... MAX_NUMNODES-1] = PXM_INVAL
393 };
394 static u16 fake_apicid_to_node[MAX_LOCAL_APIC] __initdata = {
395         [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
396 };
397 static int __init find_node_by_addr(unsigned long addr)
398 {
399         int ret = NUMA_NO_NODE;
400         int i;
401
402         for_each_node_mask(i, nodes_parsed) {
403                 /*
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.
407                  */
408                 if (addr >= nodes[i].start && addr < nodes[i].end) {
409                         ret = i;
410                         break;
411                 }
412         }
413         return i;
414 }
415
416 /*
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.
423  */
424 void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
425 {
426         int i, j;
427
428         printk(KERN_INFO "Faking PXM affinity for fake nodes on real "
429                          "topology.\n");
430         for (i = 0; i < num_nodes; i++) {
431                 int nid, pxm;
432
433                 nid = find_node_by_addr(fake_nodes[i].start);
434                 if (nid == NUMA_NO_NODE)
435                         continue;
436                 pxm = node_to_pxm(nid);
437                 if (pxm == PXM_INVAL)
438                         continue;
439                 fake_node_to_pxm_map[i] = pxm;
440                 /*
441                  * For each apicid_to_node mapping that exists for this real
442                  * node, it must now point to the fake node ID.
443                  */
444                 for (j = 0; j < MAX_LOCAL_APIC; j++)
445                         if (apicid_to_node[j] == nid)
446                                 fake_apicid_to_node[j] = i;
447         }
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));
451
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));
457 }
458
459 static int null_slit_node_compare(int a, int b)
460 {
461         return node_to_pxm(a) == node_to_pxm(b);
462 }
463 #else
464 static int null_slit_node_compare(int a, int b)
465 {
466         return a == b;
467 }
468 #endif /* CONFIG_NUMA_EMU */
469
470 void __init srat_reserve_add_area(int nodeid)
471 {
472         if (found_add_area && nodes_add[nodeid].end) {
473                 u64 total_mb;
474
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)
479                                         >> PAGE_SHIFT;
480                 total_mb *= sizeof(struct page);
481                 total_mb >>= 20;
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);
486         }
487 }
488
489 int __node_distance(int a, int b)
490 {
491         int index;
492
493         if (!acpi_slit)
494                 return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
495                                                       REMOTE_DISTANCE;
496         index = acpi_slit->locality_count * node_to_pxm(a);
497         return acpi_slit->entry[index + node_to_pxm(b)];
498 }
499
500 EXPORT_SYMBOL(__node_distance);
501
502 int memory_add_physaddr_to_nid(u64 start)
503 {
504         int i, ret = 0;
505
506         for_each_node(i)
507                 if (nodes_add[i].start <= start && nodes_add[i].end > start)
508                         ret = i;
509
510         return ret;
511 }
512 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
513