Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Written by: Patricia Gaughen <gone@us.ibm.com>, IBM Corporation | |
3 | * August 2002: added remote node KVA remap - Martin J. Bligh | |
4 | * | |
5 | * Copyright (C) 2002, IBM Corp. | |
6 | * | |
7 | * All rights reserved. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, but | |
15 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or | |
17 | * NON INFRINGEMENT. See the GNU General Public License for more | |
18 | * details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; if not, write to the Free Software | |
22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
23 | */ | |
24 | ||
1da177e4 LT |
25 | #include <linux/mm.h> |
26 | #include <linux/bootmem.h> | |
a9ce6bc1 | 27 | #include <linux/memblock.h> |
1da177e4 LT |
28 | #include <linux/mmzone.h> |
29 | #include <linux/highmem.h> | |
30 | #include <linux/initrd.h> | |
31 | #include <linux/nodemask.h> | |
129f6946 | 32 | #include <linux/module.h> |
1bc3b91a | 33 | #include <linux/kexec.h> |
22a9835c | 34 | #include <linux/pfn.h> |
28aa483f | 35 | #include <linux/swap.h> |
1b000a5d | 36 | #include <linux/acpi.h> |
1bc3b91a | 37 | |
1da177e4 LT |
38 | #include <asm/e820.h> |
39 | #include <asm/setup.h> | |
40 | #include <asm/mmzone.h> | |
ce3fe6b2 | 41 | #include <asm/bios_ebda.h> |
287572cb | 42 | #include <asm/proto.h> |
1da177e4 | 43 | |
6c231b7b | 44 | struct pglist_data *node_data[MAX_NUMNODES] __read_mostly; |
129f6946 | 45 | EXPORT_SYMBOL(node_data); |
1da177e4 LT |
46 | |
47 | /* | |
d254c8f7 | 48 | * numa interface - we expect the numa architecture specific code to have |
1da177e4 LT |
49 | * populated the following initialisation. |
50 | * | |
51 | * 1) node_online_map - the map of all nodes configured (online) in the system | |
05b79bdc | 52 | * 2) node_start_pfn - the starting page frame number for a node |
1da177e4 LT |
53 | * 3) node_end_pfn - the ending page fram number for a node |
54 | */ | |
6c231b7b RT |
55 | unsigned long node_start_pfn[MAX_NUMNODES] __read_mostly; |
56 | unsigned long node_end_pfn[MAX_NUMNODES] __read_mostly; | |
05b79bdc | 57 | |
1da177e4 | 58 | |
05b79bdc | 59 | #ifdef CONFIG_DISCONTIGMEM |
1da177e4 | 60 | /* |
05b79bdc | 61 | * 4) physnode_map - the mapping between a pfn and owning node |
1da177e4 | 62 | * physnode_map keeps track of the physical memory layout of a generic |
ba924c81 YL |
63 | * numa node on a 64Mb break (each element of the array will |
64 | * represent 64Mb of memory and will be marked by the node id. so, | |
1da177e4 LT |
65 | * if the first gig is on node 0, and the second gig is on node 1 |
66 | * physnode_map will contain: | |
67 | * | |
ba924c81 YL |
68 | * physnode_map[0-15] = 0; |
69 | * physnode_map[16-31] = 1; | |
70 | * physnode_map[32- ] = -1; | |
1da177e4 | 71 | */ |
6c231b7b | 72 | s8 physnode_map[MAX_ELEMENTS] __read_mostly = { [0 ... (MAX_ELEMENTS - 1)] = -1}; |
129f6946 | 73 | EXPORT_SYMBOL(physnode_map); |
1da177e4 LT |
74 | |
75 | void memory_present(int nid, unsigned long start, unsigned long end) | |
76 | { | |
77 | unsigned long pfn; | |
78 | ||
c0943457 | 79 | printk(KERN_INFO "Node: %d, start_pfn: %lx, end_pfn: %lx\n", |
1da177e4 LT |
80 | nid, start, end); |
81 | printk(KERN_DEBUG " Setting physnode_map array to node %d for pfns:\n", nid); | |
82 | printk(KERN_DEBUG " "); | |
83 | for (pfn = start; pfn < end; pfn += PAGES_PER_ELEMENT) { | |
84 | physnode_map[pfn / PAGES_PER_ELEMENT] = nid; | |
c0943457 | 85 | printk(KERN_CONT "%lx ", pfn); |
1da177e4 | 86 | } |
ba924c81 | 87 | printk(KERN_CONT "\n"); |
1da177e4 LT |
88 | } |
89 | ||
90 | unsigned long node_memmap_size_bytes(int nid, unsigned long start_pfn, | |
91 | unsigned long end_pfn) | |
92 | { | |
93 | unsigned long nr_pages = end_pfn - start_pfn; | |
94 | ||
95 | if (!nr_pages) | |
96 | return 0; | |
97 | ||
98 | return (nr_pages + 1) * sizeof(struct page); | |
99 | } | |
05b79bdc | 100 | #endif |
1da177e4 LT |
101 | |
102 | extern unsigned long find_max_low_pfn(void); | |
1da177e4 | 103 | extern unsigned long highend_pfn, highstart_pfn; |
1da177e4 LT |
104 | |
105 | #define LARGE_PAGE_BYTES (PTRS_PER_PTE * PAGE_SIZE) | |
106 | ||
59659f14 | 107 | static void *node_remap_start_vaddr[MAX_NUMNODES]; |
1da177e4 LT |
108 | void set_pmd_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags); |
109 | ||
110 | /* | |
111 | * FLAT - support for basic PC memory model with discontig enabled, essentially | |
112 | * a single node with all available processors in it with a flat | |
113 | * memory map. | |
114 | */ | |
daf4f480 | 115 | static int __init get_memcfg_numa_flat(void) |
1da177e4 | 116 | { |
c0943457 | 117 | printk(KERN_DEBUG "NUMA - single node, flat memory mode\n"); |
1da177e4 | 118 | |
1da177e4 LT |
119 | node_start_pfn[0] = 0; |
120 | node_end_pfn[0] = max_pfn; | |
a9ce6bc1 | 121 | memblock_x86_register_active_regions(0, 0, max_pfn); |
1da177e4 LT |
122 | |
123 | /* Indicate there is one node available. */ | |
124 | nodes_clear(node_online_map); | |
125 | node_set_online(0); | |
126 | return 1; | |
127 | } | |
128 | ||
129 | /* | |
130 | * Find the highest page frame number we have available for the node | |
131 | */ | |
fa5c4639 | 132 | static void __init propagate_e820_map_node(int nid) |
1da177e4 LT |
133 | { |
134 | if (node_end_pfn[nid] > max_pfn) | |
135 | node_end_pfn[nid] = max_pfn; | |
136 | /* | |
137 | * if a user has given mem=XXXX, then we need to make sure | |
138 | * that the node _starts_ before that, too, not just ends | |
139 | */ | |
140 | if (node_start_pfn[nid] > max_pfn) | |
141 | node_start_pfn[nid] = max_pfn; | |
8d8f3cbe | 142 | BUG_ON(node_start_pfn[nid] > node_end_pfn[nid]); |
1da177e4 LT |
143 | } |
144 | ||
145 | /* | |
146 | * Allocate memory for the pg_data_t for this node via a crude pre-bootmem | |
147 | * method. For node zero take this from the bottom of memory, for | |
148 | * subsequent nodes place them at node_remap_start_vaddr which contains | |
149 | * node local data in physically node local memory. See setup_memory() | |
150 | * for details. | |
151 | */ | |
152 | static void __init allocate_pgdat(int nid) | |
153 | { | |
996cf443 YL |
154 | char buf[16]; |
155 | ||
b2e3e4fa TH |
156 | NODE_DATA(nid) = alloc_remap(nid, ALIGN(sizeof(pg_data_t), PAGE_SIZE)); |
157 | if (!NODE_DATA(nid)) { | |
16387295 | 158 | unsigned long pgdat_phys; |
a9ce6bc1 | 159 | pgdat_phys = memblock_find_in_range(min_low_pfn<<PAGE_SHIFT, |
996cf443 | 160 | max_pfn_mapped<<PAGE_SHIFT, |
6af61a76 | 161 | sizeof(pg_data_t), |
16387295 YL |
162 | PAGE_SIZE); |
163 | NODE_DATA(nid) = (pg_data_t *)(pfn_to_kaddr(pgdat_phys>>PAGE_SHIFT)); | |
996cf443 YL |
164 | memset(buf, 0, sizeof(buf)); |
165 | sprintf(buf, "NODE_DATA %d", nid); | |
a9ce6bc1 | 166 | memblock_x86_reserve_range(pgdat_phys, pgdat_phys + sizeof(pg_data_t), buf); |
1da177e4 | 167 | } |
e8c27ac9 YL |
168 | printk(KERN_DEBUG "allocate_pgdat: node %d NODE_DATA %08lx\n", |
169 | nid, (unsigned long)NODE_DATA(nid)); | |
1da177e4 LT |
170 | } |
171 | ||
1b000a5d | 172 | /* |
993ba158 | 173 | * Remap memory allocator |
1b000a5d MG |
174 | */ |
175 | static unsigned long node_remap_start_pfn[MAX_NUMNODES]; | |
176 | static void *node_remap_end_vaddr[MAX_NUMNODES]; | |
177 | static void *node_remap_alloc_vaddr[MAX_NUMNODES]; | |
1b000a5d | 178 | |
993ba158 TH |
179 | /** |
180 | * alloc_remap - Allocate remapped memory | |
181 | * @nid: NUMA node to allocate memory from | |
182 | * @size: The size of allocation | |
183 | * | |
184 | * Allocate @size bytes from the remap area of NUMA node @nid. The | |
185 | * size of the remap area is predetermined by init_alloc_remap() and | |
186 | * only the callers considered there should call this function. For | |
187 | * more info, please read the comment on top of init_alloc_remap(). | |
188 | * | |
189 | * The caller must be ready to handle allocation failure from this | |
190 | * function and fall back to regular memory allocator in such cases. | |
191 | * | |
192 | * CONTEXT: | |
193 | * Single CPU early boot context. | |
194 | * | |
195 | * RETURNS: | |
196 | * Pointer to the allocated memory on success, %NULL on failure. | |
197 | */ | |
6f167ec7 DH |
198 | void *alloc_remap(int nid, unsigned long size) |
199 | { | |
200 | void *allocation = node_remap_alloc_vaddr[nid]; | |
201 | ||
202 | size = ALIGN(size, L1_CACHE_BYTES); | |
203 | ||
3fe14ab5 | 204 | if (!allocation || (allocation + size) > node_remap_end_vaddr[nid]) |
2366c298 | 205 | return NULL; |
6f167ec7 DH |
206 | |
207 | node_remap_alloc_vaddr[nid] += size; | |
208 | memset(allocation, 0, size); | |
209 | ||
210 | return allocation; | |
211 | } | |
212 | ||
97a70e54 RW |
213 | #ifdef CONFIG_HIBERNATION |
214 | /** | |
215 | * resume_map_numa_kva - add KVA mapping to the temporary page tables created | |
216 | * during resume from hibernation | |
217 | * @pgd_base - temporary resume page directory | |
218 | */ | |
219 | void resume_map_numa_kva(pgd_t *pgd_base) | |
220 | { | |
221 | int node; | |
222 | ||
223 | for_each_online_node(node) { | |
198bd06b | 224 | unsigned long start_va, start_pfn, nr_pages, pfn; |
97a70e54 RW |
225 | |
226 | start_va = (unsigned long)node_remap_start_vaddr[node]; | |
227 | start_pfn = node_remap_start_pfn[node]; | |
198bd06b TH |
228 | nr_pages = (node_remap_end_vaddr[node] - |
229 | node_remap_start_vaddr[node]) >> PAGE_SHIFT; | |
97a70e54 | 230 | |
9b4778f6 | 231 | printk(KERN_DEBUG "%s: node %d\n", __func__, node); |
97a70e54 | 232 | |
198bd06b | 233 | for (pfn = 0; pfn < nr_pages; pfn += PTRS_PER_PTE) { |
97a70e54 RW |
234 | unsigned long vaddr = start_va + (pfn << PAGE_SHIFT); |
235 | pgd_t *pgd = pgd_base + pgd_index(vaddr); | |
236 | pud_t *pud = pud_offset(pgd, vaddr); | |
237 | pmd_t *pmd = pmd_offset(pud, vaddr); | |
238 | ||
239 | set_pmd(pmd, pfn_pmd(start_pfn + pfn, | |
240 | PAGE_KERNEL_LARGE_EXEC)); | |
241 | ||
242 | printk(KERN_DEBUG "%s: %08lx -> pfn %08lx\n", | |
9b4778f6 | 243 | __func__, vaddr, start_pfn + pfn); |
97a70e54 RW |
244 | } |
245 | } | |
246 | } | |
247 | #endif | |
248 | ||
993ba158 TH |
249 | /** |
250 | * init_alloc_remap - Initialize remap allocator for a NUMA node | |
251 | * @nid: NUMA node to initizlie remap allocator for | |
252 | * | |
253 | * NUMA nodes may end up without any lowmem. As allocating pgdat and | |
254 | * memmap on a different node with lowmem is inefficient, a special | |
255 | * remap allocator is implemented which can be used by alloc_remap(). | |
256 | * | |
257 | * For each node, the amount of memory which will be necessary for | |
258 | * pgdat and memmap is calculated and two memory areas of the size are | |
259 | * allocated - one in the node and the other in lowmem; then, the area | |
260 | * in the node is remapped to the lowmem area. | |
261 | * | |
262 | * As pgdat and memmap must be allocated in lowmem anyway, this | |
263 | * doesn't waste lowmem address space; however, the actual lowmem | |
264 | * which gets remapped over is wasted. The amount shouldn't be | |
265 | * problematic on machines this feature will be used. | |
266 | * | |
267 | * Initialization failure isn't fatal. alloc_remap() is used | |
268 | * opportunistically and the callers will fall back to other memory | |
269 | * allocation mechanisms on failure. | |
270 | */ | |
1d85b61b | 271 | static __init void init_alloc_remap(int nid) |
1da177e4 | 272 | { |
2a286344 | 273 | unsigned long size, pfn; |
0e9f93c1 TH |
274 | u64 node_pa, remap_pa; |
275 | void *remap_va; | |
5510db9c TH |
276 | |
277 | /* | |
278 | * The acpi/srat node info can show hot-add memroy zones where | |
279 | * memory could be added but not currently present. | |
280 | */ | |
281 | printk(KERN_DEBUG "node %d pfn: [%lx - %lx]\n", | |
282 | nid, node_start_pfn[nid], node_end_pfn[nid]); | |
283 | if (node_start_pfn[nid] > max_pfn) | |
1d85b61b | 284 | return; |
5510db9c | 285 | if (!node_end_pfn[nid]) |
1d85b61b | 286 | return; |
5510db9c TH |
287 | if (node_end_pfn[nid] > max_pfn) |
288 | node_end_pfn[nid] = max_pfn; | |
289 | ||
7210cf92 TH |
290 | /* calculate the necessary space aligned to large page size */ |
291 | size = node_memmap_size_bytes(nid, node_start_pfn[nid], | |
292 | min(node_end_pfn[nid], max_pfn)); | |
5510db9c | 293 | size += ALIGN(sizeof(pg_data_t), PAGE_SIZE); |
af7c1a6e | 294 | size = ALIGN(size, LARGE_PAGE_BYTES); |
5510db9c | 295 | |
0e9f93c1 | 296 | /* allocate node memory and the lowmem remap area */ |
c4d4f577 TH |
297 | node_pa = memblock_find_in_range(node_start_pfn[nid] << PAGE_SHIFT, |
298 | (u64)node_end_pfn[nid] << PAGE_SHIFT, | |
af7c1a6e | 299 | size, LARGE_PAGE_BYTES); |
82044c32 TH |
300 | if (node_pa == MEMBLOCK_ERROR) { |
301 | pr_warning("remap_alloc: failed to allocate %lu bytes for node %d\n", | |
302 | size, nid); | |
1d85b61b | 303 | return; |
82044c32 | 304 | } |
0e9f93c1 TH |
305 | memblock_x86_reserve_range(node_pa, node_pa + size, "KVA RAM"); |
306 | ||
307 | remap_pa = memblock_find_in_range(min_low_pfn << PAGE_SHIFT, | |
308 | max_low_pfn << PAGE_SHIFT, | |
309 | size, LARGE_PAGE_BYTES); | |
310 | if (remap_pa == MEMBLOCK_ERROR) { | |
311 | pr_warning("remap_alloc: failed to allocate %lu bytes remap area for node %d\n", | |
312 | size, nid); | |
313 | memblock_x86_free_range(node_pa, node_pa + size); | |
1d85b61b | 314 | return; |
0e9f93c1 TH |
315 | } |
316 | memblock_x86_reserve_range(remap_pa, remap_pa + size, "KVA PG"); | |
317 | remap_va = phys_to_virt(remap_pa); | |
5510db9c | 318 | |
2a286344 TH |
319 | /* perform actual remap */ |
320 | for (pfn = 0; pfn < size >> PAGE_SHIFT; pfn += PTRS_PER_PTE) | |
321 | set_pmd_pfn((unsigned long)remap_va + (pfn << PAGE_SHIFT), | |
322 | (node_pa >> PAGE_SHIFT) + pfn, | |
323 | PAGE_KERNEL_LARGE); | |
324 | ||
0e9f93c1 TH |
325 | /* initialize remap allocator parameters */ |
326 | node_remap_start_pfn[nid] = node_pa >> PAGE_SHIFT; | |
0e9f93c1 TH |
327 | node_remap_start_vaddr[nid] = remap_va; |
328 | node_remap_end_vaddr[nid] = remap_va + size; | |
b2e3e4fa | 329 | node_remap_alloc_vaddr[nid] = remap_va; |
5510db9c | 330 | |
0e9f93c1 TH |
331 | printk(KERN_DEBUG "remap_alloc: node %d [%08llx-%08llx) -> [%p-%p)\n", |
332 | nid, node_pa, node_pa + size, remap_va, remap_va + size); | |
1da177e4 LT |
333 | } |
334 | ||
daf4f480 TH |
335 | static void get_memcfg_numa(void) |
336 | { | |
337 | if (get_memcfg_numaq()) | |
338 | return; | |
339 | if (get_memcfg_from_srat()) | |
340 | return; | |
341 | get_memcfg_numa_flat(); | |
342 | } | |
343 | ||
d8fc3afc | 344 | void __init initmem_init(void) |
1da177e4 LT |
345 | { |
346 | int nid; | |
1da177e4 | 347 | |
1da177e4 | 348 | get_memcfg_numa(); |
8db78cc4 | 349 | numa_init_array(); |
1da177e4 | 350 | |
5510db9c | 351 | for_each_online_node(nid) |
1d85b61b | 352 | init_alloc_remap(nid); |
0e9f93c1 | 353 | |
1da177e4 LT |
354 | #ifdef CONFIG_HIGHMEM |
355 | highstart_pfn = highend_pfn = max_pfn; | |
2ec65f8b YL |
356 | if (max_pfn > max_low_pfn) |
357 | highstart_pfn = max_low_pfn; | |
1da177e4 LT |
358 | printk(KERN_NOTICE "%ldMB HIGHMEM available.\n", |
359 | pages_to_mb(highend_pfn - highstart_pfn)); | |
ba9c231f JB |
360 | num_physpages = highend_pfn; |
361 | high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1; | |
362 | #else | |
2ec65f8b YL |
363 | num_physpages = max_low_pfn; |
364 | high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1; | |
1da177e4 LT |
365 | #endif |
366 | printk(KERN_NOTICE "%ldMB LOWMEM available.\n", | |
2ec65f8b | 367 | pages_to_mb(max_low_pfn)); |
c0943457 YL |
368 | printk(KERN_DEBUG "max_low_pfn = %lx, highstart_pfn = %lx\n", |
369 | max_low_pfn, highstart_pfn); | |
1da177e4 | 370 | |
c0943457 | 371 | printk(KERN_DEBUG "Low memory ends at vaddr %08lx\n", |
1da177e4 | 372 | (ulong) pfn_to_kaddr(max_low_pfn)); |
0e9f93c1 | 373 | for_each_online_node(nid) |
1da177e4 | 374 | allocate_pgdat(nid); |
3a58a2a6 | 375 | |
c0943457 | 376 | printk(KERN_DEBUG "High memory starts at vaddr %08lx\n", |
1da177e4 | 377 | (ulong) pfn_to_kaddr(highstart_pfn)); |
1da177e4 | 378 | for_each_online_node(nid) |
fa5c4639 | 379 | propagate_e820_map_node(nid); |
1da177e4 | 380 | |
a71edd1f | 381 | for_each_online_node(nid) { |
3a58a2a6 | 382 | memset(NODE_DATA(nid), 0, sizeof(struct pglist_data)); |
59be5a8e | 383 | NODE_DATA(nid)->node_id = nid; |
a71edd1f | 384 | } |
3a58a2a6 | 385 | |
1da177e4 | 386 | setup_bootmem_allocator(); |
1da177e4 LT |
387 | } |
388 | ||
7c7e9425 | 389 | #ifdef CONFIG_MEMORY_HOTPLUG |
fb8c177f | 390 | static int paddr_to_nid(u64 addr) |
7c7e9425 YG |
391 | { |
392 | int nid; | |
393 | unsigned long pfn = PFN_DOWN(addr); | |
394 | ||
395 | for_each_node(nid) | |
396 | if (node_start_pfn[nid] <= pfn && | |
397 | pfn < node_end_pfn[nid]) | |
398 | return nid; | |
399 | ||
400 | return -1; | |
401 | } | |
402 | ||
403 | /* | |
404 | * This function is used to ask node id BEFORE memmap and mem_section's | |
405 | * initialization (pfn_to_nid() can't be used yet). | |
406 | * If _PXM is not defined on ACPI's DSDT, node id must be found by this. | |
407 | */ | |
408 | int memory_add_physaddr_to_nid(u64 addr) | |
409 | { | |
410 | int nid = paddr_to_nid(addr); | |
411 | return (nid >= 0) ? nid : 0; | |
412 | } | |
413 | ||
414 | EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid); | |
415 | #endif | |
2772f54b | 416 | |
b0d31080 TH |
417 | /* temporary shim, will go away soon */ |
418 | int __init numa_add_memblk(int nid, u64 start, u64 end) | |
419 | { | |
420 | unsigned long start_pfn = start >> PAGE_SHIFT; | |
421 | unsigned long end_pfn = end >> PAGE_SHIFT; | |
422 | ||
423 | printk(KERN_DEBUG "nid %d start_pfn %08lx end_pfn %08lx\n", | |
424 | nid, start_pfn, end_pfn); | |
425 | ||
426 | if (start >= (u64)max_pfn << PAGE_SHIFT) { | |
427 | printk(KERN_INFO "Ignoring SRAT pfns: %08lx - %08lx\n", | |
428 | start_pfn, end_pfn); | |
429 | return 0; | |
430 | } | |
431 | ||
432 | node_set_online(nid); | |
433 | memblock_x86_register_active_regions(nid, start_pfn, | |
434 | min(end_pfn, max_pfn)); | |
435 | ||
436 | if (!node_has_online_mem(nid)) { | |
437 | node_start_pfn[nid] = start_pfn; | |
438 | node_end_pfn[nid] = end_pfn; | |
439 | } else { | |
440 | node_start_pfn[nid] = min(node_start_pfn[nid], start_pfn); | |
441 | node_end_pfn[nid] = max(node_end_pfn[nid], end_pfn); | |
442 | } | |
443 | return 0; | |
444 | } | |
445 | ||
446 | /* temporary shim, will go away soon */ | |
447 | void __init numa_set_distance(int from, int to, int distance) | |
448 | { | |
449 | /* nada */ | |
450 | } |