Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq
[linux-2.6] / arch / x86_64 / mm / numa.c
1 /* 
2  * Generic VM initialization for x86-64 NUMA setups.
3  * Copyright 2002,2003 Andi Kleen, SuSE Labs.
4  */ 
5 #include <linux/kernel.h>
6 #include <linux/mm.h>
7 #include <linux/string.h>
8 #include <linux/init.h>
9 #include <linux/bootmem.h>
10 #include <linux/mmzone.h>
11 #include <linux/ctype.h>
12 #include <linux/module.h>
13 #include <linux/nodemask.h>
14
15 #include <asm/e820.h>
16 #include <asm/proto.h>
17 #include <asm/dma.h>
18 #include <asm/numa.h>
19 #include <asm/acpi.h>
20
21 #ifndef Dprintk
22 #define Dprintk(x...)
23 #endif
24
25 struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
26 bootmem_data_t plat_node_bdata[MAX_NUMNODES];
27
28 int memnode_shift;
29 u8  memnodemap[NODEMAPSIZE];
30
31 unsigned char cpu_to_node[NR_CPUS] __read_mostly = {
32         [0 ... NR_CPUS-1] = NUMA_NO_NODE
33 };
34 unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata = {
35         [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
36 };
37 cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly;
38
39 int numa_off __initdata;
40
41 int __init compute_hash_shift(struct node *nodes, int numnodes)
42 {
43         int i; 
44         int shift = 20;
45         unsigned long addr,maxend=0;
46         
47         for (i = 0; i < numnodes; i++)
48                 if ((nodes[i].start != nodes[i].end) && (nodes[i].end > maxend))
49                                 maxend = nodes[i].end;
50
51         while ((1UL << shift) <  (maxend / NODEMAPSIZE))
52                 shift++;
53
54         printk (KERN_DEBUG"Using %d for the hash shift. Max adder is %lx \n",
55                         shift,maxend);
56         memset(memnodemap,0xff,sizeof(*memnodemap) * NODEMAPSIZE);
57         for (i = 0; i < numnodes; i++) {
58                 if (nodes[i].start == nodes[i].end)
59                         continue;
60                 for (addr = nodes[i].start;
61                      addr < nodes[i].end;
62                      addr += (1UL << shift)) {
63                         if (memnodemap[addr >> shift] != 0xff) {
64                                 printk(KERN_INFO
65         "Your memory is not aligned you need to rebuild your kernel "
66         "with a bigger NODEMAPSIZE shift=%d adder=%lu\n",
67                                         shift,addr);
68                                 return -1;
69                         } 
70                         memnodemap[addr >> shift] = i;
71                 } 
72         } 
73         return shift;
74 }
75
76 #ifdef CONFIG_SPARSEMEM
77 int early_pfn_to_nid(unsigned long pfn)
78 {
79         return phys_to_nid(pfn << PAGE_SHIFT);
80 }
81 #endif
82
83 /* Initialize bootmem allocator for a node */
84 void __init setup_node_bootmem(int nodeid, unsigned long start, unsigned long end)
85
86         unsigned long start_pfn, end_pfn, bootmap_pages, bootmap_size, bootmap_start; 
87         unsigned long nodedata_phys;
88         const int pgdat_size = round_up(sizeof(pg_data_t), PAGE_SIZE);
89
90         start = round_up(start, ZONE_ALIGN); 
91
92         printk("Bootmem setup node %d %016lx-%016lx\n", nodeid, start, end);
93
94         start_pfn = start >> PAGE_SHIFT;
95         end_pfn = end >> PAGE_SHIFT;
96
97         memory_present(nodeid, start_pfn, end_pfn);
98         nodedata_phys = find_e820_area(start, end, pgdat_size); 
99         if (nodedata_phys == -1L) 
100                 panic("Cannot find memory pgdat in node %d\n", nodeid);
101
102         Dprintk("nodedata_phys %lx\n", nodedata_phys); 
103
104         node_data[nodeid] = phys_to_virt(nodedata_phys);
105         memset(NODE_DATA(nodeid), 0, sizeof(pg_data_t));
106         NODE_DATA(nodeid)->bdata = &plat_node_bdata[nodeid];
107         NODE_DATA(nodeid)->node_start_pfn = start_pfn;
108         NODE_DATA(nodeid)->node_spanned_pages = end_pfn - start_pfn;
109
110         /* Find a place for the bootmem map */
111         bootmap_pages = bootmem_bootmap_pages(end_pfn - start_pfn); 
112         bootmap_start = round_up(nodedata_phys + pgdat_size, PAGE_SIZE);
113         bootmap_start = find_e820_area(bootmap_start, end, bootmap_pages<<PAGE_SHIFT);
114         if (bootmap_start == -1L) 
115                 panic("Not enough continuous space for bootmap on node %d", nodeid); 
116         Dprintk("bootmap start %lu pages %lu\n", bootmap_start, bootmap_pages); 
117         
118         bootmap_size = init_bootmem_node(NODE_DATA(nodeid),
119                                          bootmap_start >> PAGE_SHIFT, 
120                                          start_pfn, end_pfn); 
121
122         e820_bootmem_free(NODE_DATA(nodeid), start, end);
123
124         reserve_bootmem_node(NODE_DATA(nodeid), nodedata_phys, pgdat_size); 
125         reserve_bootmem_node(NODE_DATA(nodeid), bootmap_start, bootmap_pages<<PAGE_SHIFT);
126         node_set_online(nodeid);
127
128
129 /* Initialize final allocator for a zone */
130 void __init setup_node_zones(int nodeid)
131
132         unsigned long start_pfn, end_pfn; 
133         unsigned long zones[MAX_NR_ZONES];
134         unsigned long holes[MAX_NR_ZONES];
135         unsigned long dma_end_pfn;
136
137         memset(zones, 0, sizeof(unsigned long) * MAX_NR_ZONES); 
138         memset(holes, 0, sizeof(unsigned long) * MAX_NR_ZONES);
139
140         start_pfn = node_start_pfn(nodeid);
141         end_pfn = node_end_pfn(nodeid);
142
143         Dprintk(KERN_INFO "setting up node %d %lx-%lx\n", nodeid, start_pfn, end_pfn);
144         
145         /* All nodes > 0 have a zero length zone DMA */ 
146         dma_end_pfn = __pa(MAX_DMA_ADDRESS) >> PAGE_SHIFT; 
147         if (start_pfn < dma_end_pfn) { 
148                 zones[ZONE_DMA] = dma_end_pfn - start_pfn;
149                 holes[ZONE_DMA] = e820_hole_size(start_pfn, dma_end_pfn);
150                 zones[ZONE_NORMAL] = end_pfn - dma_end_pfn; 
151                 holes[ZONE_NORMAL] = e820_hole_size(dma_end_pfn, end_pfn);
152
153         } else { 
154                 zones[ZONE_NORMAL] = end_pfn - start_pfn; 
155                 holes[ZONE_NORMAL] = e820_hole_size(start_pfn, end_pfn);
156         } 
157     
158         free_area_init_node(nodeid, NODE_DATA(nodeid), zones,
159                             start_pfn, holes);
160
161
162 void __init numa_init_array(void)
163 {
164         int rr, i;
165         /* There are unfortunately some poorly designed mainboards around
166            that only connect memory to a single CPU. This breaks the 1:1 cpu->node
167            mapping. To avoid this fill in the mapping for all possible
168            CPUs, as the number of CPUs is not known yet. 
169            We round robin the existing nodes. */
170         rr = first_node(node_online_map);
171         for (i = 0; i < NR_CPUS; i++) {
172                 if (cpu_to_node[i] != NUMA_NO_NODE)
173                         continue;
174                 cpu_to_node[i] = rr;
175                 rr = next_node(rr, node_online_map);
176                 if (rr == MAX_NUMNODES)
177                         rr = first_node(node_online_map);
178         }
179
180 }
181
182 #ifdef CONFIG_NUMA_EMU
183 int numa_fake __initdata = 0;
184
185 /* Numa emulation */
186 static int numa_emulation(unsigned long start_pfn, unsigned long end_pfn)
187 {
188         int i;
189         struct node nodes[MAX_NUMNODES];
190         unsigned long sz = ((end_pfn - start_pfn)<<PAGE_SHIFT) / numa_fake;
191
192         /* Kludge needed for the hash function */
193         if (hweight64(sz) > 1) {
194                 unsigned long x = 1;
195                 while ((x << 1) < sz)
196                         x <<= 1;
197                 if (x < sz/2)
198                         printk("Numa emulation unbalanced. Complain to maintainer\n");
199                 sz = x;
200         }
201
202         memset(&nodes,0,sizeof(nodes));
203         for (i = 0; i < numa_fake; i++) {
204                 nodes[i].start = (start_pfn<<PAGE_SHIFT) + i*sz;
205                 if (i == numa_fake-1)
206                         sz = (end_pfn<<PAGE_SHIFT) - nodes[i].start;
207                 nodes[i].end = nodes[i].start + sz;
208                 if (i != numa_fake-1)
209                         nodes[i].end--;
210                 printk(KERN_INFO "Faking node %d at %016Lx-%016Lx (%LuMB)\n",
211                        i,
212                        nodes[i].start, nodes[i].end,
213                        (nodes[i].end - nodes[i].start) >> 20);
214                 node_set_online(i);
215         }
216         memnode_shift = compute_hash_shift(nodes, numa_fake);
217         if (memnode_shift < 0) {
218                 memnode_shift = 0;
219                 printk(KERN_ERR "No NUMA hash function found. Emulation disabled.\n");
220                 return -1;
221         }
222         for_each_online_node(i)
223                 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
224         numa_init_array();
225         return 0;
226 }
227 #endif
228
229 void __init numa_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
230
231         int i;
232
233 #ifdef CONFIG_NUMA_EMU
234         if (numa_fake && !numa_emulation(start_pfn, end_pfn))
235                 return;
236 #endif
237
238 #ifdef CONFIG_ACPI_NUMA
239         if (!numa_off && !acpi_scan_nodes(start_pfn << PAGE_SHIFT,
240                                           end_pfn << PAGE_SHIFT))
241                 return;
242 #endif
243
244 #ifdef CONFIG_K8_NUMA
245         if (!numa_off && !k8_scan_nodes(start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT))
246                 return;
247 #endif
248         printk(KERN_INFO "%s\n",
249                numa_off ? "NUMA turned off" : "No NUMA configuration found");
250
251         printk(KERN_INFO "Faking a node at %016lx-%016lx\n", 
252                start_pfn << PAGE_SHIFT,
253                end_pfn << PAGE_SHIFT); 
254                 /* setup dummy node covering all memory */ 
255         memnode_shift = 63; 
256         memnodemap[0] = 0;
257         nodes_clear(node_online_map);
258         node_set_online(0);
259         for (i = 0; i < NR_CPUS; i++)
260                 cpu_to_node[i] = 0;
261         node_to_cpumask[0] = cpumask_of_cpu(0);
262         setup_node_bootmem(0, start_pfn << PAGE_SHIFT, end_pfn << PAGE_SHIFT);
263 }
264
265 __cpuinit void numa_add_cpu(int cpu)
266 {
267         set_bit(cpu, &node_to_cpumask[cpu_to_node(cpu)]);
268
269
270 unsigned long __init numa_free_all_bootmem(void) 
271
272         int i;
273         unsigned long pages = 0;
274         for_each_online_node(i) {
275                 pages += free_all_bootmem_node(NODE_DATA(i));
276         }
277         return pages;
278
279
280 void __init paging_init(void)
281
282         int i;
283         for_each_online_node(i) {
284                 setup_node_zones(i); 
285         }
286
287
288 /* [numa=off] */
289 __init int numa_setup(char *opt) 
290
291         if (!strncmp(opt,"off",3))
292                 numa_off = 1;
293 #ifdef CONFIG_NUMA_EMU
294         if(!strncmp(opt, "fake=", 5)) {
295                 numa_fake = simple_strtoul(opt+5,NULL,0); ;
296                 if (numa_fake >= MAX_NUMNODES)
297                         numa_fake = MAX_NUMNODES;
298         }
299 #endif
300 #ifdef CONFIG_ACPI_NUMA
301         if (!strncmp(opt,"noacpi",6))
302                 acpi_numa = -1;
303 #endif
304         return 1;
305
306
307 EXPORT_SYMBOL(cpu_to_node);
308 EXPORT_SYMBOL(node_to_cpumask);
309 EXPORT_SYMBOL(memnode_shift);
310 EXPORT_SYMBOL(memnodemap);
311 EXPORT_SYMBOL(node_data);