1 /*
2 * linux/arch/x86_64/mm/init.c
3 *
4 * Copyright (C) 1995 Linus Torvalds
5 * Copyright (C) 2000 Pavel Machek <pavel@ucw.cz>
6 * Copyright (C) 2002,2003 Andi Kleen <ak@suse.de>
7 */
8
9 #include <linux/signal.h>
10 #include <linux/sched.h>
11 #include <linux/kernel.h>
12 #include <linux/errno.h>
13 #include <linux/string.h>
14 #include <linux/types.h>
15 #include <linux/ptrace.h>
16 #include <linux/mman.h>
17 #include <linux/mm.h>
18 #include <linux/swap.h>
19 #include <linux/smp.h>
20 #include <linux/init.h>
21 #include <linux/initrd.h>
22 #include <linux/pagemap.h>
23 #include <linux/bootmem.h>
24 #include <linux/memblock.h>
25 #include <linux/proc_fs.h>
26 #include <linux/pci.h>
27 #include <linux/pfn.h>
28 #include <linux/poison.h>
29 #include <linux/dma-mapping.h>
30 #include <linux/memory.h>
31 #include <linux/memory_hotplug.h>
32 #include <linux/memremap.h>
33 #include <linux/nmi.h>
34 #include <linux/gfp.h>
35 #include <linux/kcore.h>
36
37 #include <asm/processor.h>
38 #include <asm/bios_ebda.h>
39 #include <asm/uaccess.h>
40 #include <asm/pgtable.h>
41 #include <asm/pgalloc.h>
42 #include <asm/dma.h>
43 #include <asm/fixmap.h>
44 #include <asm/e820.h>
45 #include <asm/apic.h>
46 #include <asm/tlb.h>
47 #include <asm/mmu_context.h>
48 #include <asm/proto.h>
49 #include <asm/smp.h>
50 #include <asm/sections.h>
51 #include <asm/kdebug.h>
52 #include <asm/numa.h>
53 #include <asm/cacheflush.h>
54 #include <asm/init.h>
55 #include <asm/uv/uv.h>
56 #include <asm/setup.h>
57
58 #include "mm_internal.h"
59
60 #include "ident_map.c"
61
62 /*
63 * NOTE: pagetable_init alloc all the fixmap pagetables contiguous on the
64 * physical space so we can cache the place of the first one and move
65 * around without checking the pgd every time.
66 */
67
68 pteval_t __supported_pte_mask __read_mostly = ~0;
69 EXPORT_SYMBOL_GPL(__supported_pte_mask);
70
71 int force_personality32;
72
73 /*
74 * noexec32=on|off
75 * Control non executable heap for 32bit processes.
76 * To control the stack too use noexec=off
77 *
78 * on PROT_READ does not imply PROT_EXEC for 32-bit processes (default)
79 * off PROT_READ implies PROT_EXEC
80 */
nonx32_setup(char * str)81 static int __init nonx32_setup(char *str)
82 {
83 if (!strcmp(str, "on"))
84 force_personality32 &= ~READ_IMPLIES_EXEC;
85 else if (!strcmp(str, "off"))
86 force_personality32 |= READ_IMPLIES_EXEC;
87 return 1;
88 }
89 __setup("noexec32=", nonx32_setup);
90
91 /*
92 * When memory was added/removed make sure all the processes MM have
93 * suitable PGD entries in the local PGD level page.
94 */
sync_global_pgds(unsigned long start,unsigned long end,int removed)95 void sync_global_pgds(unsigned long start, unsigned long end, int removed)
96 {
97 unsigned long addr;
98
99 for (addr = start; addr <= end; addr = ALIGN(addr + 1, PGDIR_SIZE)) {
100 const pgd_t *pgd_ref = pgd_offset_k(addr);
101 struct page *page;
102
103 /*
104 * When it is called after memory hot remove, pgd_none()
105 * returns true. In this case (removed == 1), we must clear
106 * the PGD entries in the local PGD level page.
107 */
108 if (pgd_none(*pgd_ref) && !removed)
109 continue;
110
111 spin_lock(&pgd_lock);
112 list_for_each_entry(page, &pgd_list, lru) {
113 pgd_t *pgd;
114 spinlock_t *pgt_lock;
115
116 pgd = (pgd_t *)page_address(page) + pgd_index(addr);
117 /* the pgt_lock only for Xen */
118 pgt_lock = &pgd_page_get_mm(page)->page_table_lock;
119 spin_lock(pgt_lock);
120
121 if (!pgd_none(*pgd_ref) && !pgd_none(*pgd))
122 BUG_ON(pgd_page_vaddr(*pgd)
123 != pgd_page_vaddr(*pgd_ref));
124
125 if (removed) {
126 if (pgd_none(*pgd_ref) && !pgd_none(*pgd))
127 pgd_clear(pgd);
128 } else {
129 if (pgd_none(*pgd))
130 set_pgd(pgd, *pgd_ref);
131 }
132
133 spin_unlock(pgt_lock);
134 }
135 spin_unlock(&pgd_lock);
136 }
137 }
138
139 /*
140 * NOTE: This function is marked __ref because it calls __init function
141 * (alloc_bootmem_pages). It's safe to do it ONLY when after_bootmem == 0.
142 */
spp_getpage(void)143 static __ref void *spp_getpage(void)
144 {
145 void *ptr;
146
147 if (after_bootmem)
148 ptr = (void *) get_zeroed_page(GFP_ATOMIC | __GFP_NOTRACK);
149 else
150 ptr = alloc_bootmem_pages(PAGE_SIZE);
151
152 if (!ptr || ((unsigned long)ptr & ~PAGE_MASK)) {
153 panic("set_pte_phys: cannot allocate page data %s\n",
154 after_bootmem ? "after bootmem" : "");
155 }
156
157 pr_debug("spp_getpage %p\n", ptr);
158
159 return ptr;
160 }
161
fill_pud(pgd_t * pgd,unsigned long vaddr)162 static pud_t *fill_pud(pgd_t *pgd, unsigned long vaddr)
163 {
164 if (pgd_none(*pgd)) {
165 pud_t *pud = (pud_t *)spp_getpage();
166 pgd_populate(&init_mm, pgd, pud);
167 if (pud != pud_offset(pgd, 0))
168 printk(KERN_ERR "PAGETABLE BUG #00! %p <-> %p\n",
169 pud, pud_offset(pgd, 0));
170 }
171 return pud_offset(pgd, vaddr);
172 }
173
fill_pmd(pud_t * pud,unsigned long vaddr)174 static pmd_t *fill_pmd(pud_t *pud, unsigned long vaddr)
175 {
176 if (pud_none(*pud)) {
177 pmd_t *pmd = (pmd_t *) spp_getpage();
178 pud_populate(&init_mm, pud, pmd);
179 if (pmd != pmd_offset(pud, 0))
180 printk(KERN_ERR "PAGETABLE BUG #01! %p <-> %p\n",
181 pmd, pmd_offset(pud, 0));
182 }
183 return pmd_offset(pud, vaddr);
184 }
185
fill_pte(pmd_t * pmd,unsigned long vaddr)186 static pte_t *fill_pte(pmd_t *pmd, unsigned long vaddr)
187 {
188 if (pmd_none(*pmd)) {
189 pte_t *pte = (pte_t *) spp_getpage();
190 pmd_populate_kernel(&init_mm, pmd, pte);
191 if (pte != pte_offset_kernel(pmd, 0))
192 printk(KERN_ERR "PAGETABLE BUG #02!\n");
193 }
194 return pte_offset_kernel(pmd, vaddr);
195 }
196
set_pte_vaddr_pud(pud_t * pud_page,unsigned long vaddr,pte_t new_pte)197 void set_pte_vaddr_pud(pud_t *pud_page, unsigned long vaddr, pte_t new_pte)
198 {
199 pud_t *pud;
200 pmd_t *pmd;
201 pte_t *pte;
202
203 pud = pud_page + pud_index(vaddr);
204 pmd = fill_pmd(pud, vaddr);
205 pte = fill_pte(pmd, vaddr);
206
207 set_pte(pte, new_pte);
208
209 /*
210 * It's enough to flush this one mapping.
211 * (PGE mappings get flushed as well)
212 */
213 __flush_tlb_one(vaddr);
214 }
215
set_pte_vaddr(unsigned long vaddr,pte_t pteval)216 void set_pte_vaddr(unsigned long vaddr, pte_t pteval)
217 {
218 pgd_t *pgd;
219 pud_t *pud_page;
220
221 pr_debug("set_pte_vaddr %lx to %lx\n", vaddr, native_pte_val(pteval));
222
223 pgd = pgd_offset_k(vaddr);
224 if (pgd_none(*pgd)) {
225 printk(KERN_ERR
226 "PGD FIXMAP MISSING, it should be setup in head.S!\n");
227 return;
228 }
229 pud_page = (pud_t*)pgd_page_vaddr(*pgd);
230 set_pte_vaddr_pud(pud_page, vaddr, pteval);
231 }
232
populate_extra_pmd(unsigned long vaddr)233 pmd_t * __init populate_extra_pmd(unsigned long vaddr)
234 {
235 pgd_t *pgd;
236 pud_t *pud;
237
238 pgd = pgd_offset_k(vaddr);
239 pud = fill_pud(pgd, vaddr);
240 return fill_pmd(pud, vaddr);
241 }
242
populate_extra_pte(unsigned long vaddr)243 pte_t * __init populate_extra_pte(unsigned long vaddr)
244 {
245 pmd_t *pmd;
246
247 pmd = populate_extra_pmd(vaddr);
248 return fill_pte(pmd, vaddr);
249 }
250
251 /*
252 * Create large page table mappings for a range of physical addresses.
253 */
__init_extra_mapping(unsigned long phys,unsigned long size,enum page_cache_mode cache)254 static void __init __init_extra_mapping(unsigned long phys, unsigned long size,
255 enum page_cache_mode cache)
256 {
257 pgd_t *pgd;
258 pud_t *pud;
259 pmd_t *pmd;
260 pgprot_t prot;
261
262 pgprot_val(prot) = pgprot_val(PAGE_KERNEL_LARGE) |
263 pgprot_val(pgprot_4k_2_large(cachemode2pgprot(cache)));
264 BUG_ON((phys & ~PMD_MASK) || (size & ~PMD_MASK));
265 for (; size; phys += PMD_SIZE, size -= PMD_SIZE) {
266 pgd = pgd_offset_k((unsigned long)__va(phys));
267 if (pgd_none(*pgd)) {
268 pud = (pud_t *) spp_getpage();
269 set_pgd(pgd, __pgd(__pa(pud) | _KERNPG_TABLE |
270 _PAGE_USER));
271 }
272 pud = pud_offset(pgd, (unsigned long)__va(phys));
273 if (pud_none(*pud)) {
274 pmd = (pmd_t *) spp_getpage();
275 set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE |
276 _PAGE_USER));
277 }
278 pmd = pmd_offset(pud, phys);
279 BUG_ON(!pmd_none(*pmd));
280 set_pmd(pmd, __pmd(phys | pgprot_val(prot)));
281 }
282 }
283
init_extra_mapping_wb(unsigned long phys,unsigned long size)284 void __init init_extra_mapping_wb(unsigned long phys, unsigned long size)
285 {
286 __init_extra_mapping(phys, size, _PAGE_CACHE_MODE_WB);
287 }
288
init_extra_mapping_uc(unsigned long phys,unsigned long size)289 void __init init_extra_mapping_uc(unsigned long phys, unsigned long size)
290 {
291 __init_extra_mapping(phys, size, _PAGE_CACHE_MODE_UC);
292 }
293
294 /*
295 * The head.S code sets up the kernel high mapping:
296 *
297 * from __START_KERNEL_map to __START_KERNEL_map + size (== _end-_text)
298 *
299 * phys_base holds the negative offset to the kernel, which is added
300 * to the compile time generated pmds. This results in invalid pmds up
301 * to the point where we hit the physaddr 0 mapping.
302 *
303 * We limit the mappings to the region from _text to _brk_end. _brk_end
304 * is rounded up to the 2MB boundary. This catches the invalid pmds as
305 * well, as they are located before _text:
306 */
cleanup_highmap(void)307 void __init cleanup_highmap(void)
308 {
309 unsigned long vaddr = __START_KERNEL_map;
310 unsigned long vaddr_end = __START_KERNEL_map + KERNEL_IMAGE_SIZE;
311 unsigned long end = roundup((unsigned long)_brk_end, PMD_SIZE) - 1;
312 pmd_t *pmd = level2_kernel_pgt;
313
314 /*
315 * Native path, max_pfn_mapped is not set yet.
316 * Xen has valid max_pfn_mapped set in
317 * arch/x86/xen/mmu.c:xen_setup_kernel_pagetable().
318 */
319 if (max_pfn_mapped)
320 vaddr_end = __START_KERNEL_map + (max_pfn_mapped << PAGE_SHIFT);
321
322 for (; vaddr + PMD_SIZE - 1 < vaddr_end; pmd++, vaddr += PMD_SIZE) {
323 if (pmd_none(*pmd))
324 continue;
325 if (vaddr < (unsigned long) _text || vaddr > end)
326 set_pmd(pmd, __pmd(0));
327 else if (kaiser_enabled) {
328 /*
329 * level2_kernel_pgt is initialized with _PAGE_GLOBAL:
330 * clear that now. This is not important, so long as
331 * CR4.PGE remains clear, but it removes an anomaly.
332 * Physical mapping setup below avoids _PAGE_GLOBAL
333 * by use of massage_pgprot() inside pfn_pte() etc.
334 */
335 set_pmd(pmd, pmd_clear_flags(*pmd, _PAGE_GLOBAL));
336 }
337 }
338 }
339
340 /*
341 * Create PTE level page table mapping for physical addresses.
342 * It returns the last physical address mapped.
343 */
344 static unsigned long __meminit
phys_pte_init(pte_t * pte_page,unsigned long paddr,unsigned long paddr_end,pgprot_t prot)345 phys_pte_init(pte_t *pte_page, unsigned long paddr, unsigned long paddr_end,
346 pgprot_t prot)
347 {
348 unsigned long pages = 0, paddr_next;
349 unsigned long paddr_last = paddr_end;
350 pte_t *pte;
351 int i;
352
353 pte = pte_page + pte_index(paddr);
354 i = pte_index(paddr);
355
356 for (; i < PTRS_PER_PTE; i++, paddr = paddr_next, pte++) {
357 paddr_next = (paddr & PAGE_MASK) + PAGE_SIZE;
358 if (paddr >= paddr_end) {
359 if (!after_bootmem &&
360 !e820_any_mapped(paddr & PAGE_MASK, paddr_next,
361 E820_RAM) &&
362 !e820_any_mapped(paddr & PAGE_MASK, paddr_next,
363 E820_RESERVED_KERN))
364 set_pte(pte, __pte(0));
365 continue;
366 }
367
368 /*
369 * We will re-use the existing mapping.
370 * Xen for example has some special requirements, like mapping
371 * pagetable pages as RO. So assume someone who pre-setup
372 * these mappings are more intelligent.
373 */
374 if (!pte_none(*pte)) {
375 if (!after_bootmem)
376 pages++;
377 continue;
378 }
379
380 if (0)
381 pr_info(" pte=%p addr=%lx pte=%016lx\n", pte, paddr,
382 pfn_pte(paddr >> PAGE_SHIFT, PAGE_KERNEL).pte);
383 pages++;
384 set_pte(pte, pfn_pte(paddr >> PAGE_SHIFT, prot));
385 paddr_last = (paddr & PAGE_MASK) + PAGE_SIZE;
386 }
387
388 update_page_count(PG_LEVEL_4K, pages);
389
390 return paddr_last;
391 }
392
393 /*
394 * Create PMD level page table mapping for physical addresses. The virtual
395 * and physical address have to be aligned at this level.
396 * It returns the last physical address mapped.
397 */
398 static unsigned long __meminit
phys_pmd_init(pmd_t * pmd_page,unsigned long paddr,unsigned long paddr_end,unsigned long page_size_mask,pgprot_t prot)399 phys_pmd_init(pmd_t *pmd_page, unsigned long paddr, unsigned long paddr_end,
400 unsigned long page_size_mask, pgprot_t prot)
401 {
402 unsigned long pages = 0, paddr_next;
403 unsigned long paddr_last = paddr_end;
404
405 int i = pmd_index(paddr);
406
407 for (; i < PTRS_PER_PMD; i++, paddr = paddr_next) {
408 pmd_t *pmd = pmd_page + pmd_index(paddr);
409 pte_t *pte;
410 pgprot_t new_prot = prot;
411
412 paddr_next = (paddr & PMD_MASK) + PMD_SIZE;
413 if (paddr >= paddr_end) {
414 if (!after_bootmem &&
415 !e820_any_mapped(paddr & PMD_MASK, paddr_next,
416 E820_RAM) &&
417 !e820_any_mapped(paddr & PMD_MASK, paddr_next,
418 E820_RESERVED_KERN))
419 set_pmd(pmd, __pmd(0));
420 continue;
421 }
422
423 if (!pmd_none(*pmd)) {
424 if (!pmd_large(*pmd)) {
425 spin_lock(&init_mm.page_table_lock);
426 pte = (pte_t *)pmd_page_vaddr(*pmd);
427 paddr_last = phys_pte_init(pte, paddr,
428 paddr_end, prot);
429 spin_unlock(&init_mm.page_table_lock);
430 continue;
431 }
432 /*
433 * If we are ok with PG_LEVEL_2M mapping, then we will
434 * use the existing mapping,
435 *
436 * Otherwise, we will split the large page mapping but
437 * use the same existing protection bits except for
438 * large page, so that we don't violate Intel's TLB
439 * Application note (317080) which says, while changing
440 * the page sizes, new and old translations should
441 * not differ with respect to page frame and
442 * attributes.
443 */
444 if (page_size_mask & (1 << PG_LEVEL_2M)) {
445 if (!after_bootmem)
446 pages++;
447 paddr_last = paddr_next;
448 continue;
449 }
450 new_prot = pte_pgprot(pte_clrhuge(*(pte_t *)pmd));
451 }
452
453 if (page_size_mask & (1<<PG_LEVEL_2M)) {
454 pages++;
455 spin_lock(&init_mm.page_table_lock);
456 set_pte((pte_t *)pmd,
457 pfn_pte((paddr & PMD_MASK) >> PAGE_SHIFT,
458 __pgprot(pgprot_val(prot) | _PAGE_PSE)));
459 spin_unlock(&init_mm.page_table_lock);
460 paddr_last = paddr_next;
461 continue;
462 }
463
464 pte = alloc_low_page();
465 paddr_last = phys_pte_init(pte, paddr, paddr_end, new_prot);
466
467 spin_lock(&init_mm.page_table_lock);
468 pmd_populate_kernel(&init_mm, pmd, pte);
469 spin_unlock(&init_mm.page_table_lock);
470 }
471 update_page_count(PG_LEVEL_2M, pages);
472 return paddr_last;
473 }
474
475 /*
476 * Create PUD level page table mapping for physical addresses. The virtual
477 * and physical address do not have to be aligned at this level. KASLR can
478 * randomize virtual addresses up to this level.
479 * It returns the last physical address mapped.
480 */
481 static unsigned long __meminit
phys_pud_init(pud_t * pud_page,unsigned long paddr,unsigned long paddr_end,unsigned long page_size_mask)482 phys_pud_init(pud_t *pud_page, unsigned long paddr, unsigned long paddr_end,
483 unsigned long page_size_mask)
484 {
485 unsigned long pages = 0, paddr_next;
486 unsigned long paddr_last = paddr_end;
487 unsigned long vaddr = (unsigned long)__va(paddr);
488 int i = pud_index(vaddr);
489
490 for (; i < PTRS_PER_PUD; i++, paddr = paddr_next) {
491 pud_t *pud;
492 pmd_t *pmd;
493 pgprot_t prot = PAGE_KERNEL;
494
495 vaddr = (unsigned long)__va(paddr);
496 pud = pud_page + pud_index(vaddr);
497 paddr_next = (paddr & PUD_MASK) + PUD_SIZE;
498
499 if (paddr >= paddr_end) {
500 if (!after_bootmem &&
501 !e820_any_mapped(paddr & PUD_MASK, paddr_next,
502 E820_RAM) &&
503 !e820_any_mapped(paddr & PUD_MASK, paddr_next,
504 E820_RESERVED_KERN))
505 set_pud(pud, __pud(0));
506 continue;
507 }
508
509 if (!pud_none(*pud)) {
510 if (!pud_large(*pud)) {
511 pmd = pmd_offset(pud, 0);
512 paddr_last = phys_pmd_init(pmd, paddr,
513 paddr_end,
514 page_size_mask,
515 prot);
516 __flush_tlb_all();
517 continue;
518 }
519 /*
520 * If we are ok with PG_LEVEL_1G mapping, then we will
521 * use the existing mapping.
522 *
523 * Otherwise, we will split the gbpage mapping but use
524 * the same existing protection bits except for large
525 * page, so that we don't violate Intel's TLB
526 * Application note (317080) which says, while changing
527 * the page sizes, new and old translations should
528 * not differ with respect to page frame and
529 * attributes.
530 */
531 if (page_size_mask & (1 << PG_LEVEL_1G)) {
532 if (!after_bootmem)
533 pages++;
534 paddr_last = paddr_next;
535 continue;
536 }
537 prot = pte_pgprot(pte_clrhuge(*(pte_t *)pud));
538 }
539
540 if (page_size_mask & (1<<PG_LEVEL_1G)) {
541 pages++;
542 spin_lock(&init_mm.page_table_lock);
543 set_pte((pte_t *)pud,
544 pfn_pte((paddr & PUD_MASK) >> PAGE_SHIFT,
545 PAGE_KERNEL_LARGE));
546 spin_unlock(&init_mm.page_table_lock);
547 paddr_last = paddr_next;
548 continue;
549 }
550
551 pmd = alloc_low_page();
552 paddr_last = phys_pmd_init(pmd, paddr, paddr_end,
553 page_size_mask, prot);
554
555 spin_lock(&init_mm.page_table_lock);
556 pud_populate(&init_mm, pud, pmd);
557 spin_unlock(&init_mm.page_table_lock);
558 }
559 __flush_tlb_all();
560
561 update_page_count(PG_LEVEL_1G, pages);
562
563 return paddr_last;
564 }
565
566 /*
567 * Create page table mapping for the physical memory for specific physical
568 * addresses. The virtual and physical addresses have to be aligned on PMD level
569 * down. It returns the last physical address mapped.
570 */
571 unsigned long __meminit
kernel_physical_mapping_init(unsigned long paddr_start,unsigned long paddr_end,unsigned long page_size_mask)572 kernel_physical_mapping_init(unsigned long paddr_start,
573 unsigned long paddr_end,
574 unsigned long page_size_mask)
575 {
576 bool pgd_changed = false;
577 unsigned long vaddr, vaddr_start, vaddr_end, vaddr_next, paddr_last;
578
579 paddr_last = paddr_end;
580 vaddr = (unsigned long)__va(paddr_start);
581 vaddr_end = (unsigned long)__va(paddr_end);
582 vaddr_start = vaddr;
583
584 for (; vaddr < vaddr_end; vaddr = vaddr_next) {
585 pgd_t *pgd = pgd_offset_k(vaddr);
586 pud_t *pud;
587
588 vaddr_next = (vaddr & PGDIR_MASK) + PGDIR_SIZE;
589
590 if (pgd_val(*pgd)) {
591 pud = (pud_t *)pgd_page_vaddr(*pgd);
592 paddr_last = phys_pud_init(pud, __pa(vaddr),
593 __pa(vaddr_end),
594 page_size_mask);
595 continue;
596 }
597
598 pud = alloc_low_page();
599 paddr_last = phys_pud_init(pud, __pa(vaddr), __pa(vaddr_end),
600 page_size_mask);
601
602 spin_lock(&init_mm.page_table_lock);
603 pgd_populate(&init_mm, pgd, pud);
604 spin_unlock(&init_mm.page_table_lock);
605 pgd_changed = true;
606 }
607
608 if (pgd_changed)
609 sync_global_pgds(vaddr_start, vaddr_end - 1, 0);
610
611 __flush_tlb_all();
612
613 return paddr_last;
614 }
615
616 #ifndef CONFIG_NUMA
initmem_init(void)617 void __init initmem_init(void)
618 {
619 memblock_set_node(0, (phys_addr_t)ULLONG_MAX, &memblock.memory, 0);
620 }
621 #endif
622
paging_init(void)623 void __init paging_init(void)
624 {
625 sparse_memory_present_with_active_regions(MAX_NUMNODES);
626 sparse_init();
627
628 /*
629 * clear the default setting with node 0
630 * note: don't use nodes_clear here, that is really clearing when
631 * numa support is not compiled in, and later node_set_state
632 * will not set it back.
633 */
634 node_clear_state(0, N_MEMORY);
635 if (N_MEMORY != N_NORMAL_MEMORY)
636 node_clear_state(0, N_NORMAL_MEMORY);
637
638 zone_sizes_init();
639 }
640
641 /*
642 * Memory hotplug specific functions
643 */
644 #ifdef CONFIG_MEMORY_HOTPLUG
645 /*
646 * After memory hotplug the variables max_pfn, max_low_pfn and high_memory need
647 * updating.
648 */
update_end_of_memory_vars(u64 start,u64 size)649 static void update_end_of_memory_vars(u64 start, u64 size)
650 {
651 unsigned long end_pfn = PFN_UP(start + size);
652
653 if (end_pfn > max_pfn) {
654 max_pfn = end_pfn;
655 max_low_pfn = end_pfn;
656 high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
657 }
658 }
659
660 /*
661 * Memory is added always to NORMAL zone. This means you will never get
662 * additional DMA/DMA32 memory.
663 */
arch_add_memory(int nid,u64 start,u64 size,bool for_device)664 int arch_add_memory(int nid, u64 start, u64 size, bool for_device)
665 {
666 struct pglist_data *pgdat = NODE_DATA(nid);
667 struct zone *zone = pgdat->node_zones +
668 zone_for_memory(nid, start, size, ZONE_NORMAL, for_device);
669 unsigned long start_pfn = start >> PAGE_SHIFT;
670 unsigned long nr_pages = size >> PAGE_SHIFT;
671 int ret;
672
673 init_memory_mapping(start, start + size);
674
675 ret = __add_pages(nid, zone, start_pfn, nr_pages);
676 WARN_ON_ONCE(ret);
677
678 /* update max_pfn, max_low_pfn and high_memory */
679 update_end_of_memory_vars(start, size);
680
681 return ret;
682 }
683 EXPORT_SYMBOL_GPL(arch_add_memory);
684
685 #define PAGE_INUSE 0xFD
686
free_pagetable(struct page * page,int order)687 static void __meminit free_pagetable(struct page *page, int order)
688 {
689 unsigned long magic;
690 unsigned int nr_pages = 1 << order;
691 struct vmem_altmap *altmap = to_vmem_altmap((unsigned long) page);
692
693 if (altmap) {
694 vmem_altmap_free(altmap, nr_pages);
695 return;
696 }
697
698 /* bootmem page has reserved flag */
699 if (PageReserved(page)) {
700 __ClearPageReserved(page);
701
702 magic = (unsigned long)page->freelist;
703 if (magic == SECTION_INFO || magic == MIX_SECTION_INFO) {
704 while (nr_pages--)
705 put_page_bootmem(page++);
706 } else
707 while (nr_pages--)
708 free_reserved_page(page++);
709 } else
710 free_pages((unsigned long)page_address(page), order);
711 }
712
free_pte_table(pte_t * pte_start,pmd_t * pmd)713 static void __meminit free_pte_table(pte_t *pte_start, pmd_t *pmd)
714 {
715 pte_t *pte;
716 int i;
717
718 for (i = 0; i < PTRS_PER_PTE; i++) {
719 pte = pte_start + i;
720 if (!pte_none(*pte))
721 return;
722 }
723
724 /* free a pte talbe */
725 free_pagetable(pmd_page(*pmd), 0);
726 spin_lock(&init_mm.page_table_lock);
727 pmd_clear(pmd);
728 spin_unlock(&init_mm.page_table_lock);
729 }
730
free_pmd_table(pmd_t * pmd_start,pud_t * pud)731 static void __meminit free_pmd_table(pmd_t *pmd_start, pud_t *pud)
732 {
733 pmd_t *pmd;
734 int i;
735
736 for (i = 0; i < PTRS_PER_PMD; i++) {
737 pmd = pmd_start + i;
738 if (!pmd_none(*pmd))
739 return;
740 }
741
742 /* free a pmd talbe */
743 free_pagetable(pud_page(*pud), 0);
744 spin_lock(&init_mm.page_table_lock);
745 pud_clear(pud);
746 spin_unlock(&init_mm.page_table_lock);
747 }
748
749 static void __meminit
remove_pte_table(pte_t * pte_start,unsigned long addr,unsigned long end,bool direct)750 remove_pte_table(pte_t *pte_start, unsigned long addr, unsigned long end,
751 bool direct)
752 {
753 unsigned long next, pages = 0;
754 pte_t *pte;
755 void *page_addr;
756 phys_addr_t phys_addr;
757
758 pte = pte_start + pte_index(addr);
759 for (; addr < end; addr = next, pte++) {
760 next = (addr + PAGE_SIZE) & PAGE_MASK;
761 if (next > end)
762 next = end;
763
764 if (!pte_present(*pte))
765 continue;
766
767 /*
768 * We mapped [0,1G) memory as identity mapping when
769 * initializing, in arch/x86/kernel/head_64.S. These
770 * pagetables cannot be removed.
771 */
772 phys_addr = pte_val(*pte) + (addr & PAGE_MASK);
773 if (phys_addr < (phys_addr_t)0x40000000)
774 return;
775
776 if (PAGE_ALIGNED(addr) && PAGE_ALIGNED(next)) {
777 /*
778 * Do not free direct mapping pages since they were
779 * freed when offlining, or simplely not in use.
780 */
781 if (!direct)
782 free_pagetable(pte_page(*pte), 0);
783
784 spin_lock(&init_mm.page_table_lock);
785 pte_clear(&init_mm, addr, pte);
786 spin_unlock(&init_mm.page_table_lock);
787
788 /* For non-direct mapping, pages means nothing. */
789 pages++;
790 } else {
791 /*
792 * If we are here, we are freeing vmemmap pages since
793 * direct mapped memory ranges to be freed are aligned.
794 *
795 * If we are not removing the whole page, it means
796 * other page structs in this page are being used and
797 * we canot remove them. So fill the unused page_structs
798 * with 0xFD, and remove the page when it is wholly
799 * filled with 0xFD.
800 */
801 memset((void *)addr, PAGE_INUSE, next - addr);
802
803 page_addr = page_address(pte_page(*pte));
804 if (!memchr_inv(page_addr, PAGE_INUSE, PAGE_SIZE)) {
805 free_pagetable(pte_page(*pte), 0);
806
807 spin_lock(&init_mm.page_table_lock);
808 pte_clear(&init_mm, addr, pte);
809 spin_unlock(&init_mm.page_table_lock);
810 }
811 }
812 }
813
814 /* Call free_pte_table() in remove_pmd_table(). */
815 flush_tlb_all();
816 if (direct)
817 update_page_count(PG_LEVEL_4K, -pages);
818 }
819
820 static void __meminit
remove_pmd_table(pmd_t * pmd_start,unsigned long addr,unsigned long end,bool direct)821 remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end,
822 bool direct)
823 {
824 unsigned long next, pages = 0;
825 pte_t *pte_base;
826 pmd_t *pmd;
827 void *page_addr;
828
829 pmd = pmd_start + pmd_index(addr);
830 for (; addr < end; addr = next, pmd++) {
831 next = pmd_addr_end(addr, end);
832
833 if (!pmd_present(*pmd))
834 continue;
835
836 if (pmd_large(*pmd)) {
837 if (IS_ALIGNED(addr, PMD_SIZE) &&
838 IS_ALIGNED(next, PMD_SIZE)) {
839 if (!direct)
840 free_pagetable(pmd_page(*pmd),
841 get_order(PMD_SIZE));
842
843 spin_lock(&init_mm.page_table_lock);
844 pmd_clear(pmd);
845 spin_unlock(&init_mm.page_table_lock);
846 pages++;
847 } else {
848 /* If here, we are freeing vmemmap pages. */
849 memset((void *)addr, PAGE_INUSE, next - addr);
850
851 page_addr = page_address(pmd_page(*pmd));
852 if (!memchr_inv(page_addr, PAGE_INUSE,
853 PMD_SIZE)) {
854 free_pagetable(pmd_page(*pmd),
855 get_order(PMD_SIZE));
856
857 spin_lock(&init_mm.page_table_lock);
858 pmd_clear(pmd);
859 spin_unlock(&init_mm.page_table_lock);
860 }
861 }
862
863 continue;
864 }
865
866 pte_base = (pte_t *)pmd_page_vaddr(*pmd);
867 remove_pte_table(pte_base, addr, next, direct);
868 free_pte_table(pte_base, pmd);
869 }
870
871 /* Call free_pmd_table() in remove_pud_table(). */
872 if (direct)
873 update_page_count(PG_LEVEL_2M, -pages);
874 }
875
876 static void __meminit
remove_pud_table(pud_t * pud_start,unsigned long addr,unsigned long end,bool direct)877 remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end,
878 bool direct)
879 {
880 unsigned long next, pages = 0;
881 pmd_t *pmd_base;
882 pud_t *pud;
883 void *page_addr;
884
885 pud = pud_start + pud_index(addr);
886 for (; addr < end; addr = next, pud++) {
887 next = pud_addr_end(addr, end);
888
889 if (!pud_present(*pud))
890 continue;
891
892 if (pud_large(*pud)) {
893 if (IS_ALIGNED(addr, PUD_SIZE) &&
894 IS_ALIGNED(next, PUD_SIZE)) {
895 if (!direct)
896 free_pagetable(pud_page(*pud),
897 get_order(PUD_SIZE));
898
899 spin_lock(&init_mm.page_table_lock);
900 pud_clear(pud);
901 spin_unlock(&init_mm.page_table_lock);
902 pages++;
903 } else {
904 /* If here, we are freeing vmemmap pages. */
905 memset((void *)addr, PAGE_INUSE, next - addr);
906
907 page_addr = page_address(pud_page(*pud));
908 if (!memchr_inv(page_addr, PAGE_INUSE,
909 PUD_SIZE)) {
910 free_pagetable(pud_page(*pud),
911 get_order(PUD_SIZE));
912
913 spin_lock(&init_mm.page_table_lock);
914 pud_clear(pud);
915 spin_unlock(&init_mm.page_table_lock);
916 }
917 }
918
919 continue;
920 }
921
922 pmd_base = (pmd_t *)pud_page_vaddr(*pud);
923 remove_pmd_table(pmd_base, addr, next, direct);
924 free_pmd_table(pmd_base, pud);
925 }
926
927 if (direct)
928 update_page_count(PG_LEVEL_1G, -pages);
929 }
930
931 /* start and end are both virtual address. */
932 static void __meminit
remove_pagetable(unsigned long start,unsigned long end,bool direct)933 remove_pagetable(unsigned long start, unsigned long end, bool direct)
934 {
935 unsigned long next;
936 unsigned long addr;
937 pgd_t *pgd;
938 pud_t *pud;
939
940 for (addr = start; addr < end; addr = next) {
941 next = pgd_addr_end(addr, end);
942
943 pgd = pgd_offset_k(addr);
944 if (!pgd_present(*pgd))
945 continue;
946
947 pud = (pud_t *)pgd_page_vaddr(*pgd);
948 remove_pud_table(pud, addr, next, direct);
949 }
950
951 flush_tlb_all();
952 }
953
vmemmap_free(unsigned long start,unsigned long end)954 void __ref vmemmap_free(unsigned long start, unsigned long end)
955 {
956 remove_pagetable(start, end, false);
957 }
958
959 #ifdef CONFIG_MEMORY_HOTREMOVE
960 static void __meminit
kernel_physical_mapping_remove(unsigned long start,unsigned long end)961 kernel_physical_mapping_remove(unsigned long start, unsigned long end)
962 {
963 start = (unsigned long)__va(start);
964 end = (unsigned long)__va(end);
965
966 remove_pagetable(start, end, true);
967 }
968
arch_remove_memory(u64 start,u64 size)969 int __ref arch_remove_memory(u64 start, u64 size)
970 {
971 unsigned long start_pfn = start >> PAGE_SHIFT;
972 unsigned long nr_pages = size >> PAGE_SHIFT;
973 struct page *page = pfn_to_page(start_pfn);
974 struct vmem_altmap *altmap;
975 struct zone *zone;
976 int ret;
977
978 /* With altmap the first mapped page is offset from @start */
979 altmap = to_vmem_altmap((unsigned long) page);
980 if (altmap)
981 page += vmem_altmap_offset(altmap);
982 zone = page_zone(page);
983 ret = __remove_pages(zone, start_pfn, nr_pages);
984 WARN_ON_ONCE(ret);
985 kernel_physical_mapping_remove(start, start + size);
986
987 return ret;
988 }
989 #endif
990 #endif /* CONFIG_MEMORY_HOTPLUG */
991
992 static struct kcore_list kcore_vsyscall;
993
register_page_bootmem_info(void)994 static void __init register_page_bootmem_info(void)
995 {
996 #ifdef CONFIG_NUMA
997 int i;
998
999 for_each_online_node(i)
1000 register_page_bootmem_info_node(NODE_DATA(i));
1001 #endif
1002 }
1003
mem_init(void)1004 void __init mem_init(void)
1005 {
1006 pci_iommu_alloc();
1007
1008 /* clear_bss() already clear the empty_zero_page */
1009
1010 register_page_bootmem_info();
1011
1012 /* this will put all memory onto the freelists */
1013 free_all_bootmem();
1014 after_bootmem = 1;
1015
1016 /* Register memory areas for /proc/kcore */
1017 kclist_add(&kcore_vsyscall, (void *)VSYSCALL_ADDR,
1018 PAGE_SIZE, KCORE_OTHER);
1019
1020 mem_init_print_info(NULL);
1021 }
1022
1023 const int rodata_test_data = 0xC3;
1024 EXPORT_SYMBOL_GPL(rodata_test_data);
1025
1026 int kernel_set_to_readonly;
1027
set_kernel_text_rw(void)1028 void set_kernel_text_rw(void)
1029 {
1030 unsigned long start = PFN_ALIGN(_text);
1031 unsigned long end = PFN_ALIGN(__stop___ex_table);
1032
1033 if (!kernel_set_to_readonly)
1034 return;
1035
1036 pr_debug("Set kernel text: %lx - %lx for read write\n",
1037 start, end);
1038
1039 /*
1040 * Make the kernel identity mapping for text RW. Kernel text
1041 * mapping will always be RO. Refer to the comment in
1042 * static_protections() in pageattr.c
1043 */
1044 set_memory_rw(start, (end - start) >> PAGE_SHIFT);
1045 }
1046
set_kernel_text_ro(void)1047 void set_kernel_text_ro(void)
1048 {
1049 unsigned long start = PFN_ALIGN(_text);
1050 unsigned long end = PFN_ALIGN(__stop___ex_table);
1051
1052 if (!kernel_set_to_readonly)
1053 return;
1054
1055 pr_debug("Set kernel text: %lx - %lx for read only\n",
1056 start, end);
1057
1058 /*
1059 * Set the kernel identity mapping for text RO.
1060 */
1061 set_memory_ro(start, (end - start) >> PAGE_SHIFT);
1062 }
1063
mark_rodata_ro(void)1064 void mark_rodata_ro(void)
1065 {
1066 unsigned long start = PFN_ALIGN(_text);
1067 unsigned long rodata_start = PFN_ALIGN(__start_rodata);
1068 unsigned long end = (unsigned long) &__end_rodata_hpage_align;
1069 unsigned long text_end = PFN_ALIGN(&__stop___ex_table);
1070 unsigned long rodata_end = PFN_ALIGN(&__end_rodata);
1071 unsigned long all_end;
1072
1073 printk(KERN_INFO "Write protecting the kernel read-only data: %luk\n",
1074 (end - start) >> 10);
1075 set_memory_ro(start, (end - start) >> PAGE_SHIFT);
1076
1077 kernel_set_to_readonly = 1;
1078
1079 /*
1080 * The rodata/data/bss/brk section (but not the kernel text!)
1081 * should also be not-executable.
1082 *
1083 * We align all_end to PMD_SIZE because the existing mapping
1084 * is a full PMD. If we would align _brk_end to PAGE_SIZE we
1085 * split the PMD and the reminder between _brk_end and the end
1086 * of the PMD will remain mapped executable.
1087 *
1088 * Any PMD which was setup after the one which covers _brk_end
1089 * has been zapped already via cleanup_highmem().
1090 */
1091 all_end = roundup((unsigned long)_brk_end, PMD_SIZE);
1092 set_memory_nx(text_end, (all_end - text_end) >> PAGE_SHIFT);
1093
1094 rodata_test();
1095
1096 #ifdef CONFIG_CPA_DEBUG
1097 printk(KERN_INFO "Testing CPA: undo %lx-%lx\n", start, end);
1098 set_memory_rw(start, (end-start) >> PAGE_SHIFT);
1099
1100 printk(KERN_INFO "Testing CPA: again\n");
1101 set_memory_ro(start, (end-start) >> PAGE_SHIFT);
1102 #endif
1103
1104 free_init_pages("unused kernel",
1105 (unsigned long) __va(__pa_symbol(text_end)),
1106 (unsigned long) __va(__pa_symbol(rodata_start)));
1107 free_init_pages("unused kernel",
1108 (unsigned long) __va(__pa_symbol(rodata_end)),
1109 (unsigned long) __va(__pa_symbol(_sdata)));
1110
1111 debug_checkwx();
1112 }
1113
kern_addr_valid(unsigned long addr)1114 int kern_addr_valid(unsigned long addr)
1115 {
1116 unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
1117 pgd_t *pgd;
1118 pud_t *pud;
1119 pmd_t *pmd;
1120 pte_t *pte;
1121
1122 if (above != 0 && above != -1UL)
1123 return 0;
1124
1125 pgd = pgd_offset_k(addr);
1126 if (pgd_none(*pgd))
1127 return 0;
1128
1129 pud = pud_offset(pgd, addr);
1130 if (pud_none(*pud))
1131 return 0;
1132
1133 if (pud_large(*pud))
1134 return pfn_valid(pud_pfn(*pud));
1135
1136 pmd = pmd_offset(pud, addr);
1137 if (pmd_none(*pmd))
1138 return 0;
1139
1140 if (pmd_large(*pmd))
1141 return pfn_valid(pmd_pfn(*pmd));
1142
1143 pte = pte_offset_kernel(pmd, addr);
1144 if (pte_none(*pte))
1145 return 0;
1146
1147 return pfn_valid(pte_pfn(*pte));
1148 }
1149
probe_memory_block_size(void)1150 static unsigned long probe_memory_block_size(void)
1151 {
1152 unsigned long bz = MIN_MEMORY_BLOCK_SIZE;
1153
1154 /* if system is UV or has 64GB of RAM or more, use large blocks */
1155 if (is_uv_system() || ((max_pfn << PAGE_SHIFT) >= (64UL << 30)))
1156 bz = 2UL << 30; /* 2GB */
1157
1158 pr_info("x86/mm: Memory block size: %ldMB\n", bz >> 20);
1159
1160 return bz;
1161 }
1162
1163 static unsigned long memory_block_size_probed;
memory_block_size_bytes(void)1164 unsigned long memory_block_size_bytes(void)
1165 {
1166 if (!memory_block_size_probed)
1167 memory_block_size_probed = probe_memory_block_size();
1168
1169 return memory_block_size_probed;
1170 }
1171
1172 #ifdef CONFIG_SPARSEMEM_VMEMMAP
1173 /*
1174 * Initialise the sparsemem vmemmap using huge-pages at the PMD level.
1175 */
1176 static long __meminitdata addr_start, addr_end;
1177 static void __meminitdata *p_start, *p_end;
1178 static int __meminitdata node_start;
1179
vmemmap_populate_hugepages(unsigned long start,unsigned long end,int node,struct vmem_altmap * altmap)1180 static int __meminit vmemmap_populate_hugepages(unsigned long start,
1181 unsigned long end, int node, struct vmem_altmap *altmap)
1182 {
1183 unsigned long addr;
1184 unsigned long next;
1185 pgd_t *pgd;
1186 pud_t *pud;
1187 pmd_t *pmd;
1188
1189 for (addr = start; addr < end; addr = next) {
1190 next = pmd_addr_end(addr, end);
1191
1192 pgd = vmemmap_pgd_populate(addr, node);
1193 if (!pgd)
1194 return -ENOMEM;
1195
1196 pud = vmemmap_pud_populate(pgd, addr, node);
1197 if (!pud)
1198 return -ENOMEM;
1199
1200 pmd = pmd_offset(pud, addr);
1201 if (pmd_none(*pmd)) {
1202 void *p;
1203
1204 p = __vmemmap_alloc_block_buf(PMD_SIZE, node, altmap);
1205 if (p) {
1206 pte_t entry;
1207
1208 entry = pfn_pte(__pa(p) >> PAGE_SHIFT,
1209 PAGE_KERNEL_LARGE);
1210 set_pmd(pmd, __pmd(pte_val(entry)));
1211
1212 /* check to see if we have contiguous blocks */
1213 if (p_end != p || node_start != node) {
1214 if (p_start)
1215 pr_debug(" [%lx-%lx] PMD -> [%p-%p] on node %d\n",
1216 addr_start, addr_end-1, p_start, p_end-1, node_start);
1217 addr_start = addr;
1218 node_start = node;
1219 p_start = p;
1220 }
1221
1222 addr_end = addr + PMD_SIZE;
1223 p_end = p + PMD_SIZE;
1224 continue;
1225 } else if (altmap)
1226 return -ENOMEM; /* no fallback */
1227 } else if (pmd_large(*pmd)) {
1228 vmemmap_verify((pte_t *)pmd, node, addr, next);
1229 continue;
1230 }
1231 pr_warn_once("vmemmap: falling back to regular page backing\n");
1232 if (vmemmap_populate_basepages(addr, next, node))
1233 return -ENOMEM;
1234 }
1235 return 0;
1236 }
1237
vmemmap_populate(unsigned long start,unsigned long end,int node)1238 int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
1239 {
1240 struct vmem_altmap *altmap = to_vmem_altmap(start);
1241 int err;
1242
1243 if (boot_cpu_has(X86_FEATURE_PSE))
1244 err = vmemmap_populate_hugepages(start, end, node, altmap);
1245 else if (altmap) {
1246 pr_err_once("%s: no cpu support for altmap allocations\n",
1247 __func__);
1248 err = -ENOMEM;
1249 } else
1250 err = vmemmap_populate_basepages(start, end, node);
1251 if (!err)
1252 sync_global_pgds(start, end - 1, 0);
1253 return err;
1254 }
1255
1256 #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_HAVE_BOOTMEM_INFO_NODE)
register_page_bootmem_memmap(unsigned long section_nr,struct page * start_page,unsigned long size)1257 void register_page_bootmem_memmap(unsigned long section_nr,
1258 struct page *start_page, unsigned long size)
1259 {
1260 unsigned long addr = (unsigned long)start_page;
1261 unsigned long end = (unsigned long)(start_page + size);
1262 unsigned long next;
1263 pgd_t *pgd;
1264 pud_t *pud;
1265 pmd_t *pmd;
1266 unsigned int nr_pages;
1267 struct page *page;
1268
1269 for (; addr < end; addr = next) {
1270 pte_t *pte = NULL;
1271
1272 pgd = pgd_offset_k(addr);
1273 if (pgd_none(*pgd)) {
1274 next = (addr + PAGE_SIZE) & PAGE_MASK;
1275 continue;
1276 }
1277 get_page_bootmem(section_nr, pgd_page(*pgd), MIX_SECTION_INFO);
1278
1279 pud = pud_offset(pgd, addr);
1280 if (pud_none(*pud)) {
1281 next = (addr + PAGE_SIZE) & PAGE_MASK;
1282 continue;
1283 }
1284 get_page_bootmem(section_nr, pud_page(*pud), MIX_SECTION_INFO);
1285
1286 if (!boot_cpu_has(X86_FEATURE_PSE)) {
1287 next = (addr + PAGE_SIZE) & PAGE_MASK;
1288 pmd = pmd_offset(pud, addr);
1289 if (pmd_none(*pmd))
1290 continue;
1291 get_page_bootmem(section_nr, pmd_page(*pmd),
1292 MIX_SECTION_INFO);
1293
1294 pte = pte_offset_kernel(pmd, addr);
1295 if (pte_none(*pte))
1296 continue;
1297 get_page_bootmem(section_nr, pte_page(*pte),
1298 SECTION_INFO);
1299 } else {
1300 next = pmd_addr_end(addr, end);
1301
1302 pmd = pmd_offset(pud, addr);
1303 if (pmd_none(*pmd))
1304 continue;
1305
1306 nr_pages = 1 << (get_order(PMD_SIZE));
1307 page = pmd_page(*pmd);
1308 while (nr_pages--)
1309 get_page_bootmem(section_nr, page++,
1310 SECTION_INFO);
1311 }
1312 }
1313 }
1314 #endif
1315
vmemmap_populate_print_last(void)1316 void __meminit vmemmap_populate_print_last(void)
1317 {
1318 if (p_start) {
1319 pr_debug(" [%lx-%lx] PMD -> [%p-%p] on node %d\n",
1320 addr_start, addr_end-1, p_start, p_end-1, node_start);
1321 p_start = NULL;
1322 p_end = NULL;
1323 node_start = 0;
1324 }
1325 }
1326 #endif
1327