2 * linux/arch/x86_64/mm/init.c
4 * Copyright (C) 1995 Linus Torvalds
5 * Copyright (C) 2000 Pavel Machek <pavel@suse.cz>
6 * Copyright (C) 2002,2003 Andi Kleen <ak@suse.de>
9 #include <linux/config.h>
10 #include <linux/signal.h>
11 #include <linux/sched.h>
12 #include <linux/kernel.h>
13 #include <linux/errno.h>
14 #include <linux/string.h>
15 #include <linux/types.h>
16 #include <linux/ptrace.h>
17 #include <linux/mman.h>
19 #include <linux/swap.h>
20 #include <linux/smp.h>
21 #include <linux/init.h>
22 #include <linux/pagemap.h>
23 #include <linux/bootmem.h>
24 #include <linux/proc_fs.h>
26 #include <asm/processor.h>
27 #include <asm/system.h>
28 #include <asm/uaccess.h>
29 #include <asm/pgtable.h>
30 #include <asm/pgalloc.h>
32 #include <asm/fixmap.h>
36 #include <asm/mmu_context.h>
37 #include <asm/proto.h>
44 #ifdef CONFIG_GART_IOMMU
50 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
53 * NOTE: pagetable_init alloc all the fixmap pagetables contiguous on the
54 * physical space so we can cache the place of the first one and move
55 * around without checking the pgd every time.
60 int i, total = 0, reserved = 0;
61 int shared = 0, cached = 0;
65 printk("Mem-info:\n");
67 printk("Free swap: %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
69 for_each_pgdat(pgdat) {
70 for (i = 0; i < pgdat->node_spanned_pages; ++i) {
71 page = pfn_to_page(pgdat->node_start_pfn + i);
73 if (PageReserved(page))
75 else if (PageSwapCache(page))
77 else if (page_count(page))
78 shared += page_count(page) - 1;
81 printk("%d pages of RAM\n", total);
82 printk("%d reserved pages\n",reserved);
83 printk("%d pages shared\n",shared);
84 printk("%d pages swap cached\n",cached);
87 /* References to section boundaries */
89 extern char _text, _etext, _edata, __bss_start, _end[];
90 extern char __init_begin, __init_end;
94 static void *spp_getpage(void)
98 ptr = (void *) get_zeroed_page(GFP_ATOMIC);
100 ptr = alloc_bootmem_pages(PAGE_SIZE);
101 if (!ptr || ((unsigned long)ptr & ~PAGE_MASK))
102 panic("set_pte_phys: cannot allocate page data %s\n", after_bootmem?"after bootmem":"");
104 Dprintk("spp_getpage %p\n", ptr);
108 static void set_pte_phys(unsigned long vaddr,
109 unsigned long phys, pgprot_t prot)
116 Dprintk("set_pte_phys %lx to %lx\n", vaddr, phys);
118 pgd = pgd_offset_k(vaddr);
119 if (pgd_none(*pgd)) {
120 printk("PGD FIXMAP MISSING, it should be setup in head.S!\n");
123 pud = pud_offset(pgd, vaddr);
124 if (pud_none(*pud)) {
125 pmd = (pmd_t *) spp_getpage();
126 set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
127 if (pmd != pmd_offset(pud, 0)) {
128 printk("PAGETABLE BUG #01! %p <-> %p\n", pmd, pmd_offset(pud,0));
132 pmd = pmd_offset(pud, vaddr);
133 if (pmd_none(*pmd)) {
134 pte = (pte_t *) spp_getpage();
135 set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE | _PAGE_USER));
136 if (pte != pte_offset_kernel(pmd, 0)) {
137 printk("PAGETABLE BUG #02!\n");
141 new_pte = pfn_pte(phys >> PAGE_SHIFT, prot);
143 pte = pte_offset_kernel(pmd, vaddr);
144 if (!pte_none(*pte) &&
145 pte_val(*pte) != (pte_val(new_pte) & __supported_pte_mask))
147 set_pte(pte, new_pte);
150 * It's enough to flush this one mapping.
151 * (PGE mappings get flushed as well)
153 __flush_tlb_one(vaddr);
156 /* NOTE: this is meant to be run only at boot */
157 void __set_fixmap (enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
159 unsigned long address = __fix_to_virt(idx);
161 if (idx >= __end_of_fixed_addresses) {
162 printk("Invalid __set_fixmap\n");
165 set_pte_phys(address, phys, prot);
168 unsigned long __initdata table_start, table_end;
170 extern pmd_t temp_boot_pmds[];
172 static struct temp_map {
176 } temp_mappings[] __initdata = {
177 { &temp_boot_pmds[0], (void *)(40UL * 1024 * 1024) },
178 { &temp_boot_pmds[1], (void *)(42UL * 1024 * 1024) },
182 static __init void *alloc_low_page(int *index, unsigned long *phys)
186 unsigned long pfn = table_end++, paddr;
190 panic("alloc_low_page: ran out of memory");
191 for (i = 0; temp_mappings[i].allocated; i++) {
192 if (!temp_mappings[i].pmd)
193 panic("alloc_low_page: ran out of temp mappings");
195 ti = &temp_mappings[i];
196 paddr = (pfn << PAGE_SHIFT) & PMD_MASK;
197 set_pmd(ti->pmd, __pmd(paddr | _KERNPG_TABLE | _PAGE_PSE));
200 adr = ti->address + ((pfn << PAGE_SHIFT) & ~PMD_MASK);
202 *phys = pfn * PAGE_SIZE;
206 static __init void unmap_low_page(int i)
208 struct temp_map *ti = &temp_mappings[i];
209 set_pmd(ti->pmd, __pmd(0));
213 static void __init phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
217 i = pud_index(address);
219 for (; i < PTRS_PER_PUD; pud++, i++) {
221 unsigned long paddr, pmd_phys;
224 paddr = address + i*PUD_SIZE;
226 for (; i < PTRS_PER_PUD; i++, pud++)
227 set_pud(pud, __pud(0));
231 if (!e820_mapped(paddr, paddr+PUD_SIZE, 0)) {
232 set_pud(pud, __pud(0));
236 pmd = alloc_low_page(&map, &pmd_phys);
237 set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
238 for (j = 0; j < PTRS_PER_PMD; pmd++, j++, paddr += PMD_SIZE) {
242 for (; j < PTRS_PER_PMD; j++, pmd++)
243 set_pmd(pmd, __pmd(0));
246 pe = _PAGE_NX|_PAGE_PSE | _KERNPG_TABLE | _PAGE_GLOBAL | paddr;
247 pe &= __supported_pte_mask;
248 set_pmd(pmd, __pmd(pe));
255 static void __init find_early_table_space(unsigned long end)
257 unsigned long puds, pmds, tables;
259 puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
260 pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
261 tables = round_up(puds * sizeof(pud_t), PAGE_SIZE) +
262 round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
264 table_start = find_e820_area(0x8000, __pa_symbol(&_text), tables);
265 if (table_start == -1UL)
266 panic("Cannot find space for the kernel page tables");
268 table_start >>= PAGE_SHIFT;
269 table_end = table_start;
272 /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
273 This runs before bootmem is initialized and gets pages directly from the
274 physical memory. To access them they are temporarily mapped. */
275 void __init init_memory_mapping(unsigned long start, unsigned long end)
279 Dprintk("init_memory_mapping\n");
282 * Find space for the kernel direct mapping tables.
283 * Later we should allocate these tables in the local node of the memory
284 * mapped. Unfortunately this is done currently before the nodes are
287 find_early_table_space(end);
289 start = (unsigned long)__va(start);
290 end = (unsigned long)__va(end);
292 for (; start < end; start = next) {
294 unsigned long pud_phys;
295 pud_t *pud = alloc_low_page(&map, &pud_phys);
296 next = start + PGDIR_SIZE;
299 phys_pud_init(pud, __pa(start), __pa(next));
300 set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
304 asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
306 early_printk("kernel direct mapping tables upto %lx @ %lx-%lx\n", end,
307 table_start<<PAGE_SHIFT,
308 table_end<<PAGE_SHIFT);
311 extern struct x8664_pda cpu_pda[NR_CPUS];
313 /* Assumes all CPUs still execute in init_mm */
314 void zap_low_mappings(void)
316 pgd_t *pgd = pgd_offset_k(0UL);
322 void __init paging_init(void)
325 unsigned long zones_size[MAX_NR_ZONES];
326 unsigned long holes[MAX_NR_ZONES];
327 unsigned int max_dma;
329 memset(zones_size, 0, sizeof(zones_size));
330 memset(holes, 0, sizeof(holes));
332 max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
334 if (end_pfn < max_dma) {
335 zones_size[ZONE_DMA] = end_pfn;
336 holes[ZONE_DMA] = e820_hole_size(0, end_pfn);
338 zones_size[ZONE_DMA] = max_dma;
339 holes[ZONE_DMA] = e820_hole_size(0, max_dma);
340 zones_size[ZONE_NORMAL] = end_pfn - max_dma;
341 holes[ZONE_NORMAL] = e820_hole_size(max_dma, end_pfn);
343 free_area_init_node(0, NODE_DATA(0), zones_size,
344 __pa(PAGE_OFFSET) >> PAGE_SHIFT, holes);
350 /* Unmap a kernel mapping if it exists. This is useful to avoid prefetches
351 from the CPU leading to inconsistent cache lines. address and size
352 must be aligned to 2MB boundaries.
353 Does nothing when the mapping doesn't exist. */
354 void __init clear_kernel_mapping(unsigned long address, unsigned long size)
356 unsigned long end = address + size;
358 BUG_ON(address & ~LARGE_PAGE_MASK);
359 BUG_ON(size & ~LARGE_PAGE_MASK);
361 for (; address < end; address += LARGE_PAGE_SIZE) {
362 pgd_t *pgd = pgd_offset_k(address);
367 pud = pud_offset(pgd, address);
370 pmd = pmd_offset(pud, address);
371 if (!pmd || pmd_none(*pmd))
373 if (0 == (pmd_val(*pmd) & _PAGE_PSE)) {
374 /* Could handle this, but it should not happen currently. */
376 "clear_kernel_mapping: mapping has been split. will leak memory\n");
379 set_pmd(pmd, __pmd(0));
384 static inline int page_is_ram (unsigned long pagenr)
388 for (i = 0; i < e820.nr_map; i++) {
389 unsigned long addr, end;
391 if (e820.map[i].type != E820_RAM) /* not usable memory */
394 * !!!FIXME!!! Some BIOSen report areas as RAM that
395 * are not. Notably the 640->1Mb area. We need a sanity
398 addr = (e820.map[i].addr+PAGE_SIZE-1) >> PAGE_SHIFT;
399 end = (e820.map[i].addr+e820.map[i].size) >> PAGE_SHIFT;
400 if ((pagenr >= addr) && (pagenr < end))
406 extern int swiotlb_force;
408 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
411 void __init mem_init(void)
413 int codesize, reservedpages, datasize, initsize;
416 #ifdef CONFIG_SWIOTLB
419 if (!iommu_aperture &&
420 (end_pfn >= 0xffffffff>>PAGE_SHIFT || force_iommu))
426 /* How many end-of-memory variables you have, grandma! */
427 max_low_pfn = end_pfn;
429 num_physpages = end_pfn;
430 high_memory = (void *) __va(end_pfn * PAGE_SIZE);
432 /* clear the zero-page */
433 memset(empty_zero_page, 0, PAGE_SIZE);
437 /* this will put all low memory onto the freelists */
439 totalram_pages += numa_free_all_bootmem();
441 /* should count reserved pages here for all nodes */
444 #ifdef CONFIG_FLATMEM
449 totalram_pages += free_all_bootmem();
451 for (tmp = 0; tmp < end_pfn; tmp++)
453 * Only count reserved RAM pages
455 if (page_is_ram(tmp) && PageReserved(pfn_to_page(tmp)))
461 codesize = (unsigned long) &_etext - (unsigned long) &_text;
462 datasize = (unsigned long) &_edata - (unsigned long) &_etext;
463 initsize = (unsigned long) &__init_end - (unsigned long) &__init_begin;
465 /* Register memory areas for /proc/kcore */
466 kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
467 kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
468 VMALLOC_END-VMALLOC_START);
469 kclist_add(&kcore_kernel, &_stext, _end - _stext);
470 kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
471 kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START,
472 VSYSCALL_END - VSYSCALL_START);
474 printk("Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data, %dk init)\n",
475 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
476 end_pfn << (PAGE_SHIFT-10),
478 reservedpages << (PAGE_SHIFT-10),
483 * Subtle. SMP is doing its boot stuff late (because it has to
484 * fork idle threads) - but it also needs low mappings for the
485 * protected-mode entry to work. We zap these entries only after
486 * the WP-bit has been tested.
493 extern char __initdata_begin[], __initdata_end[];
495 void free_initmem(void)
499 addr = (unsigned long)(&__init_begin);
500 for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
501 ClearPageReserved(virt_to_page(addr));
502 set_page_count(virt_to_page(addr), 1);
503 memset((void *)(addr & ~(PAGE_SIZE-1)), 0xcc, PAGE_SIZE);
507 memset(__initdata_begin, 0xba, __initdata_end - __initdata_begin);
508 printk ("Freeing unused kernel memory: %luk freed\n", (&__init_end - &__init_begin) >> 10);
511 #ifdef CONFIG_BLK_DEV_INITRD
512 void free_initrd_mem(unsigned long start, unsigned long end)
514 if (start < (unsigned long)&_end)
516 printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
517 for (; start < end; start += PAGE_SIZE) {
518 ClearPageReserved(virt_to_page(start));
519 set_page_count(virt_to_page(start), 1);
526 void __init reserve_bootmem_generic(unsigned long phys, unsigned len)
528 /* Should check here against the e820 map to avoid double free */
530 int nid = phys_to_nid(phys);
531 reserve_bootmem_node(NODE_DATA(nid), phys, len);
533 reserve_bootmem(phys, len);
537 int kern_addr_valid(unsigned long addr)
539 unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
545 if (above != 0 && above != -1UL)
548 pgd = pgd_offset_k(addr);
552 pud = pud_offset(pgd, addr);
556 pmd = pmd_offset(pud, addr);
560 return pfn_valid(pmd_pfn(*pmd));
562 pte = pte_offset_kernel(pmd, addr);
565 return pfn_valid(pte_pfn(*pte));
569 #include <linux/sysctl.h>
571 extern int exception_trace, page_fault_trace;
573 static ctl_table debug_table2[] = {
574 { 99, "exception-trace", &exception_trace, sizeof(int), 0644, NULL,
576 #ifdef CONFIG_CHECKING
577 { 100, "page-fault-trace", &page_fault_trace, sizeof(int), 0644, NULL,
583 static ctl_table debug_root_table2[] = {
584 { .ctl_name = CTL_DEBUG, .procname = "debug", .mode = 0555,
585 .child = debug_table2 },
589 static __init int x8664_sysctl_init(void)
591 register_sysctl_table(debug_root_table2, 1);
594 __initcall(x8664_sysctl_init);
597 /* A pseudo VMAs to allow ptrace access for the vsyscall page. This only
598 covers the 64bit vsyscall page now. 32bit has a real VMA now and does
599 not need special handling anymore. */
601 static struct vm_area_struct gate_vma = {
602 .vm_start = VSYSCALL_START,
603 .vm_end = VSYSCALL_END,
604 .vm_page_prot = PAGE_READONLY
607 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
609 #ifdef CONFIG_IA32_EMULATION
610 if (test_tsk_thread_flag(tsk, TIF_IA32))
616 int in_gate_area(struct task_struct *task, unsigned long addr)
618 struct vm_area_struct *vma = get_gate_vma(task);
621 return (addr >= vma->vm_start) && (addr < vma->vm_end);
624 /* Use this when you have no reliable task/vma, typically from interrupt
625 * context. It is less reliable than using the task's vma and may give
628 int in_gate_area_no_task(unsigned long addr)
630 return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);