[PATCH] x86_64: Account mem_map in VM holes accounting
[linux-2.6.git] / arch / x86_64 / mm / init.c
1 /*
2  *  linux/arch/x86_64/mm/init.c
3  *
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>
7  */
8
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>
18 #include <linux/mm.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>
25
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>
31 #include <asm/dma.h>
32 #include <asm/fixmap.h>
33 #include <asm/e820.h>
34 #include <asm/apic.h>
35 #include <asm/tlb.h>
36 #include <asm/mmu_context.h>
37 #include <asm/proto.h>
38 #include <asm/smp.h>
39
40 #ifndef Dprintk
41 #define Dprintk(x...)
42 #endif
43
44 #ifdef CONFIG_GART_IOMMU
45 extern int swiotlb;
46 #endif
47
48 extern char _stext[];
49
50 static unsigned long dma_reserve __initdata;
51
52 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
53
54 /*
55  * NOTE: pagetable_init alloc all the fixmap pagetables contiguous on the
56  * physical space so we can cache the place of the first one and move
57  * around without checking the pgd every time.
58  */
59
60 void show_mem(void)
61 {
62         long i, total = 0, reserved = 0;
63         long shared = 0, cached = 0;
64         pg_data_t *pgdat;
65         struct page *page;
66
67         printk(KERN_INFO "Mem-info:\n");
68         show_free_areas();
69         printk(KERN_INFO "Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
70
71         for_each_pgdat(pgdat) {
72                for (i = 0; i < pgdat->node_spanned_pages; ++i) {
73                         page = pfn_to_page(pgdat->node_start_pfn + i);
74                         total++;
75                         if (PageReserved(page))
76                                 reserved++;
77                         else if (PageSwapCache(page))
78                                 cached++;
79                         else if (page_count(page))
80                                 shared += page_count(page) - 1;
81                }
82         }
83         printk(KERN_INFO "%lu pages of RAM\n", total);
84         printk(KERN_INFO "%lu reserved pages\n",reserved);
85         printk(KERN_INFO "%lu pages shared\n",shared);
86         printk(KERN_INFO "%lu pages swap cached\n",cached);
87 }
88
89 /* References to section boundaries */
90
91 extern char _text, _etext, _edata, __bss_start, _end[];
92 extern char __init_begin, __init_end;
93
94 int after_bootmem;
95
96 static void *spp_getpage(void)
97
98         void *ptr;
99         if (after_bootmem)
100                 ptr = (void *) get_zeroed_page(GFP_ATOMIC); 
101         else
102                 ptr = alloc_bootmem_pages(PAGE_SIZE);
103         if (!ptr || ((unsigned long)ptr & ~PAGE_MASK))
104                 panic("set_pte_phys: cannot allocate page data %s\n", after_bootmem?"after bootmem":"");
105
106         Dprintk("spp_getpage %p\n", ptr);
107         return ptr;
108
109
110 static void set_pte_phys(unsigned long vaddr,
111                          unsigned long phys, pgprot_t prot)
112 {
113         pgd_t *pgd;
114         pud_t *pud;
115         pmd_t *pmd;
116         pte_t *pte, new_pte;
117
118         Dprintk("set_pte_phys %lx to %lx\n", vaddr, phys);
119
120         pgd = pgd_offset_k(vaddr);
121         if (pgd_none(*pgd)) {
122                 printk("PGD FIXMAP MISSING, it should be setup in head.S!\n");
123                 return;
124         }
125         pud = pud_offset(pgd, vaddr);
126         if (pud_none(*pud)) {
127                 pmd = (pmd_t *) spp_getpage(); 
128                 set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
129                 if (pmd != pmd_offset(pud, 0)) {
130                         printk("PAGETABLE BUG #01! %p <-> %p\n", pmd, pmd_offset(pud,0));
131                         return;
132                 }
133         }
134         pmd = pmd_offset(pud, vaddr);
135         if (pmd_none(*pmd)) {
136                 pte = (pte_t *) spp_getpage();
137                 set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE | _PAGE_USER));
138                 if (pte != pte_offset_kernel(pmd, 0)) {
139                         printk("PAGETABLE BUG #02!\n");
140                         return;
141                 }
142         }
143         new_pte = pfn_pte(phys >> PAGE_SHIFT, prot);
144
145         pte = pte_offset_kernel(pmd, vaddr);
146         if (!pte_none(*pte) &&
147             pte_val(*pte) != (pte_val(new_pte) & __supported_pte_mask))
148                 pte_ERROR(*pte);
149         set_pte(pte, new_pte);
150
151         /*
152          * It's enough to flush this one mapping.
153          * (PGE mappings get flushed as well)
154          */
155         __flush_tlb_one(vaddr);
156 }
157
158 /* NOTE: this is meant to be run only at boot */
159 void __set_fixmap (enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
160 {
161         unsigned long address = __fix_to_virt(idx);
162
163         if (idx >= __end_of_fixed_addresses) {
164                 printk("Invalid __set_fixmap\n");
165                 return;
166         }
167         set_pte_phys(address, phys, prot);
168 }
169
170 unsigned long __initdata table_start, table_end; 
171
172 extern pmd_t temp_boot_pmds[]; 
173
174 static  struct temp_map { 
175         pmd_t *pmd;
176         void  *address; 
177         int    allocated; 
178 } temp_mappings[] __initdata = { 
179         { &temp_boot_pmds[0], (void *)(40UL * 1024 * 1024) },
180         { &temp_boot_pmds[1], (void *)(42UL * 1024 * 1024) }, 
181         {}
182 }; 
183
184 static __init void *alloc_low_page(int *index, unsigned long *phys) 
185
186         struct temp_map *ti;
187         int i; 
188         unsigned long pfn = table_end++, paddr; 
189         void *adr;
190
191         if (pfn >= end_pfn) 
192                 panic("alloc_low_page: ran out of memory"); 
193         for (i = 0; temp_mappings[i].allocated; i++) {
194                 if (!temp_mappings[i].pmd) 
195                         panic("alloc_low_page: ran out of temp mappings"); 
196         } 
197         ti = &temp_mappings[i];
198         paddr = (pfn << PAGE_SHIFT) & PMD_MASK; 
199         set_pmd(ti->pmd, __pmd(paddr | _KERNPG_TABLE | _PAGE_PSE)); 
200         ti->allocated = 1; 
201         __flush_tlb();         
202         adr = ti->address + ((pfn << PAGE_SHIFT) & ~PMD_MASK); 
203         *index = i; 
204         *phys  = pfn * PAGE_SIZE;  
205         return adr; 
206
207
208 static __init void unmap_low_page(int i)
209
210         struct temp_map *ti = &temp_mappings[i];
211         set_pmd(ti->pmd, __pmd(0));
212         ti->allocated = 0; 
213
214
215 static void __init phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
216
217         long i, j; 
218
219         i = pud_index(address);
220         pud = pud + i;
221         for (; i < PTRS_PER_PUD; pud++, i++) {
222                 int map; 
223                 unsigned long paddr, pmd_phys;
224                 pmd_t *pmd;
225
226                 paddr = address + i*PUD_SIZE;
227                 if (paddr >= end) { 
228                         for (; i < PTRS_PER_PUD; i++, pud++) 
229                                 set_pud(pud, __pud(0)); 
230                         break;
231                 } 
232
233                 if (!e820_mapped(paddr, paddr+PUD_SIZE, 0)) { 
234                         set_pud(pud, __pud(0)); 
235                         continue;
236                 } 
237
238                 pmd = alloc_low_page(&map, &pmd_phys);
239                 set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
240                 for (j = 0; j < PTRS_PER_PMD; pmd++, j++, paddr += PMD_SIZE) {
241                         unsigned long pe;
242
243                         if (paddr >= end) { 
244                                 for (; j < PTRS_PER_PMD; j++, pmd++)
245                                         set_pmd(pmd,  __pmd(0)); 
246                                 break;
247                 }
248                         pe = _PAGE_NX|_PAGE_PSE | _KERNPG_TABLE | _PAGE_GLOBAL | paddr;
249                         pe &= __supported_pte_mask;
250                         set_pmd(pmd, __pmd(pe));
251                 }
252                 unmap_low_page(map);
253         }
254         __flush_tlb();
255
256
257 static void __init find_early_table_space(unsigned long end)
258 {
259         unsigned long puds, pmds, tables;
260
261         puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
262         pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
263         tables = round_up(puds * sizeof(pud_t), PAGE_SIZE) +
264                  round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
265
266         table_start = find_e820_area(0x8000, __pa_symbol(&_text), tables);
267         if (table_start == -1UL)
268                 panic("Cannot find space for the kernel page tables");
269
270         table_start >>= PAGE_SHIFT;
271         table_end = table_start;
272 }
273
274 /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
275    This runs before bootmem is initialized and gets pages directly from the 
276    physical memory. To access them they are temporarily mapped. */
277 void __init init_memory_mapping(unsigned long start, unsigned long end)
278
279         unsigned long next; 
280
281         Dprintk("init_memory_mapping\n");
282
283         /* 
284          * Find space for the kernel direct mapping tables.
285          * Later we should allocate these tables in the local node of the memory
286          * mapped.  Unfortunately this is done currently before the nodes are 
287          * discovered.
288          */
289         find_early_table_space(end);
290
291         start = (unsigned long)__va(start);
292         end = (unsigned long)__va(end);
293
294         for (; start < end; start = next) {
295                 int map;
296                 unsigned long pud_phys; 
297                 pud_t *pud = alloc_low_page(&map, &pud_phys);
298                 next = start + PGDIR_SIZE;
299                 if (next > end) 
300                         next = end; 
301                 phys_pud_init(pud, __pa(start), __pa(next));
302                 set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
303                 unmap_low_page(map);   
304         } 
305
306         asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
307         __flush_tlb_all();
308         early_printk("kernel direct mapping tables upto %lx @ %lx-%lx\n", end, 
309                table_start<<PAGE_SHIFT, 
310                table_end<<PAGE_SHIFT);
311 }
312
313 extern struct x8664_pda cpu_pda[NR_CPUS];
314
315 /* Assumes all CPUs still execute in init_mm */
316 void zap_low_mappings(void)
317 {
318         pgd_t *pgd = pgd_offset_k(0UL);
319         pgd_clear(pgd);
320         flush_tlb_all();
321 }
322
323 /* Compute zone sizes for the DMA and DMA32 zones in a node. */
324 __init void
325 size_zones(unsigned long *z, unsigned long *h,
326            unsigned long start_pfn, unsigned long end_pfn)
327 {
328         int i;
329         unsigned long w;
330
331         for (i = 0; i < MAX_NR_ZONES; i++)
332                 z[i] = 0;
333
334         if (start_pfn < MAX_DMA_PFN)
335                 z[ZONE_DMA] = MAX_DMA_PFN - start_pfn;
336         if (start_pfn < MAX_DMA32_PFN) {
337                 unsigned long dma32_pfn = MAX_DMA32_PFN;
338                 if (dma32_pfn > end_pfn)
339                         dma32_pfn = end_pfn;
340                 z[ZONE_DMA32] = dma32_pfn - start_pfn;
341         }
342         z[ZONE_NORMAL] = end_pfn - start_pfn;
343
344         /* Remove lower zones from higher ones. */
345         w = 0;
346         for (i = 0; i < MAX_NR_ZONES; i++) {
347                 if (z[i])
348                         z[i] -= w;
349                 w += z[i];
350         }
351
352         /* Compute holes */
353         w = 0;
354         for (i = 0; i < MAX_NR_ZONES; i++) {
355                 unsigned long s = w;
356                 w += z[i];
357                 h[i] = e820_hole_size(s, w);
358         }
359
360         /* Add the space pace needed for mem_map to the holes too. */
361         for (i = 0; i < MAX_NR_ZONES; i++)
362                 h[i] += (z[i] * sizeof(struct page)) / PAGE_SIZE;
363
364         /* The 16MB DMA zone has the kernel and other misc mappings.
365            Account them too */
366         if (h[ZONE_DMA]) {
367                 h[ZONE_DMA] += dma_reserve;
368                 if (h[ZONE_DMA] >= z[ZONE_DMA]) {
369                         printk(KERN_WARNING
370                                 "Kernel too large and filling up ZONE_DMA?\n");
371                         h[ZONE_DMA] = z[ZONE_DMA];
372                 }
373         }
374 }
375
376 #ifndef CONFIG_NUMA
377 void __init paging_init(void)
378 {
379         unsigned long zones[MAX_NR_ZONES], holes[MAX_NR_ZONES];
380         size_zones(zones, holes, 0, end_pfn);
381         free_area_init_node(0, NODE_DATA(0), zones,
382                             __pa(PAGE_OFFSET) >> PAGE_SHIFT, holes);
383 }
384 #endif
385
386 /* Unmap a kernel mapping if it exists. This is useful to avoid prefetches
387    from the CPU leading to inconsistent cache lines. address and size
388    must be aligned to 2MB boundaries. 
389    Does nothing when the mapping doesn't exist. */
390 void __init clear_kernel_mapping(unsigned long address, unsigned long size) 
391 {
392         unsigned long end = address + size;
393
394         BUG_ON(address & ~LARGE_PAGE_MASK);
395         BUG_ON(size & ~LARGE_PAGE_MASK); 
396         
397         for (; address < end; address += LARGE_PAGE_SIZE) { 
398                 pgd_t *pgd = pgd_offset_k(address);
399                 pud_t *pud;
400                 pmd_t *pmd;
401                 if (pgd_none(*pgd))
402                         continue;
403                 pud = pud_offset(pgd, address);
404                 if (pud_none(*pud))
405                         continue; 
406                 pmd = pmd_offset(pud, address);
407                 if (!pmd || pmd_none(*pmd))
408                         continue; 
409                 if (0 == (pmd_val(*pmd) & _PAGE_PSE)) { 
410                         /* Could handle this, but it should not happen currently. */
411                         printk(KERN_ERR 
412                "clear_kernel_mapping: mapping has been split. will leak memory\n"); 
413                         pmd_ERROR(*pmd); 
414                 }
415                 set_pmd(pmd, __pmd(0));                 
416         }
417         __flush_tlb_all();
418
419
420 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
421                          kcore_vsyscall;
422
423 void __init mem_init(void)
424 {
425         long codesize, reservedpages, datasize, initsize;
426
427 #ifdef CONFIG_SWIOTLB
428         if (!iommu_aperture &&
429             (end_pfn >= 0xffffffff>>PAGE_SHIFT || force_iommu))
430                swiotlb = 1;
431         if (swiotlb)
432                 swiotlb_init(); 
433 #endif
434
435         /* How many end-of-memory variables you have, grandma! */
436         max_low_pfn = end_pfn;
437         max_pfn = end_pfn;
438         num_physpages = end_pfn;
439         high_memory = (void *) __va(end_pfn * PAGE_SIZE);
440
441         /* clear the zero-page */
442         memset(empty_zero_page, 0, PAGE_SIZE);
443
444         reservedpages = 0;
445
446         /* this will put all low memory onto the freelists */
447 #ifdef CONFIG_NUMA
448         totalram_pages = numa_free_all_bootmem();
449 #else
450         totalram_pages = free_all_bootmem();
451 #endif
452         reservedpages = end_pfn - totalram_pages - e820_hole_size(0, end_pfn);
453
454         after_bootmem = 1;
455
456         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
457         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
458         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
459
460         /* Register memory areas for /proc/kcore */
461         kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT); 
462         kclist_add(&kcore_vmalloc, (void *)VMALLOC_START, 
463                    VMALLOC_END-VMALLOC_START);
464         kclist_add(&kcore_kernel, &_stext, _end - _stext);
465         kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
466         kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START, 
467                                  VSYSCALL_END - VSYSCALL_START);
468
469         printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n",
470                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
471                 end_pfn << (PAGE_SHIFT-10),
472                 codesize >> 10,
473                 reservedpages << (PAGE_SHIFT-10),
474                 datasize >> 10,
475                 initsize >> 10);
476
477         /*
478          * Subtle. SMP is doing its boot stuff late (because it has to
479          * fork idle threads) - but it also needs low mappings for the
480          * protected-mode entry to work. We zap these entries only after
481          * the WP-bit has been tested.
482          */
483 #ifndef CONFIG_SMP
484         zap_low_mappings();
485 #endif
486 }
487
488 extern char __initdata_begin[], __initdata_end[];
489
490 void free_initmem(void)
491 {
492         unsigned long addr;
493
494         addr = (unsigned long)(&__init_begin);
495         for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
496                 ClearPageReserved(virt_to_page(addr));
497                 set_page_count(virt_to_page(addr), 1);
498                 memset((void *)(addr & ~(PAGE_SIZE-1)), 0xcc, PAGE_SIZE); 
499                 free_page(addr);
500                 totalram_pages++;
501         }
502         memset(__initdata_begin, 0xba, __initdata_end - __initdata_begin);
503         printk ("Freeing unused kernel memory: %luk freed\n", (&__init_end - &__init_begin) >> 10);
504 }
505
506 #ifdef CONFIG_BLK_DEV_INITRD
507 void free_initrd_mem(unsigned long start, unsigned long end)
508 {
509         if (start < (unsigned long)&_end)
510                 return;
511         printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
512         for (; start < end; start += PAGE_SIZE) {
513                 ClearPageReserved(virt_to_page(start));
514                 set_page_count(virt_to_page(start), 1);
515                 free_page(start);
516                 totalram_pages++;
517         }
518 }
519 #endif
520
521 void __init reserve_bootmem_generic(unsigned long phys, unsigned len) 
522
523         /* Should check here against the e820 map to avoid double free */ 
524 #ifdef CONFIG_NUMA
525         int nid = phys_to_nid(phys);
526         reserve_bootmem_node(NODE_DATA(nid), phys, len);
527 #else                   
528         reserve_bootmem(phys, len);    
529 #endif
530         if (phys+len <= MAX_DMA_PFN*PAGE_SIZE)
531                 dma_reserve += len / PAGE_SIZE;
532 }
533
534 int kern_addr_valid(unsigned long addr) 
535
536         unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
537        pgd_t *pgd;
538        pud_t *pud;
539        pmd_t *pmd;
540        pte_t *pte;
541
542         if (above != 0 && above != -1UL)
543                 return 0; 
544         
545         pgd = pgd_offset_k(addr);
546         if (pgd_none(*pgd))
547                 return 0;
548
549         pud = pud_offset(pgd, addr);
550         if (pud_none(*pud))
551                 return 0; 
552
553         pmd = pmd_offset(pud, addr);
554         if (pmd_none(*pmd))
555                 return 0;
556         if (pmd_large(*pmd))
557                 return pfn_valid(pmd_pfn(*pmd));
558
559         pte = pte_offset_kernel(pmd, addr);
560         if (pte_none(*pte))
561                 return 0;
562         return pfn_valid(pte_pfn(*pte));
563 }
564
565 #ifdef CONFIG_SYSCTL
566 #include <linux/sysctl.h>
567
568 extern int exception_trace, page_fault_trace;
569
570 static ctl_table debug_table2[] = {
571         { 99, "exception-trace", &exception_trace, sizeof(int), 0644, NULL,
572           proc_dointvec },
573 #ifdef CONFIG_CHECKING
574         { 100, "page-fault-trace", &page_fault_trace, sizeof(int), 0644, NULL,
575           proc_dointvec },
576 #endif
577         { 0, }
578 }; 
579
580 static ctl_table debug_root_table2[] = { 
581         { .ctl_name = CTL_DEBUG, .procname = "debug", .mode = 0555, 
582            .child = debug_table2 }, 
583         { 0 }, 
584 }; 
585
586 static __init int x8664_sysctl_init(void)
587
588         register_sysctl_table(debug_root_table2, 1);
589         return 0;
590 }
591 __initcall(x8664_sysctl_init);
592 #endif
593
594 /* A pseudo VMAs to allow ptrace access for the vsyscall page.   This only
595    covers the 64bit vsyscall page now. 32bit has a real VMA now and does
596    not need special handling anymore. */
597
598 static struct vm_area_struct gate_vma = {
599         .vm_start = VSYSCALL_START,
600         .vm_end = VSYSCALL_END,
601         .vm_page_prot = PAGE_READONLY
602 };
603
604 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
605 {
606 #ifdef CONFIG_IA32_EMULATION
607         if (test_tsk_thread_flag(tsk, TIF_IA32))
608                 return NULL;
609 #endif
610         return &gate_vma;
611 }
612
613 int in_gate_area(struct task_struct *task, unsigned long addr)
614 {
615         struct vm_area_struct *vma = get_gate_vma(task);
616         if (!vma)
617                 return 0;
618         return (addr >= vma->vm_start) && (addr < vma->vm_end);
619 }
620
621 /* Use this when you have no reliable task/vma, typically from interrupt
622  * context.  It is less reliable than using the task's vma and may give
623  * false positives.
624  */
625 int in_gate_area_no_task(unsigned long addr)
626 {
627         return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);
628 }