[PATCH] x86_64: Only use asm/sections.h to declare section symbols
[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 #include <asm/sections.h>
40
41 #ifndef Dprintk
42 #define Dprintk(x...)
43 #endif
44
45 #ifdef CONFIG_GART_IOMMU
46 extern int swiotlb;
47 #endif
48
49 static unsigned long dma_reserve __initdata;
50
51 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
52
53 /*
54  * NOTE: pagetable_init alloc all the fixmap pagetables contiguous on the
55  * physical space so we can cache the place of the first one and move
56  * around without checking the pgd every time.
57  */
58
59 void show_mem(void)
60 {
61         long i, total = 0, reserved = 0;
62         long shared = 0, cached = 0;
63         pg_data_t *pgdat;
64         struct page *page;
65
66         printk(KERN_INFO "Mem-info:\n");
67         show_free_areas();
68         printk(KERN_INFO "Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
69
70         for_each_pgdat(pgdat) {
71                for (i = 0; i < pgdat->node_spanned_pages; ++i) {
72                         page = pfn_to_page(pgdat->node_start_pfn + i);
73                         total++;
74                         if (PageReserved(page))
75                                 reserved++;
76                         else if (PageSwapCache(page))
77                                 cached++;
78                         else if (page_count(page))
79                                 shared += page_count(page) - 1;
80                }
81         }
82         printk(KERN_INFO "%lu pages of RAM\n", total);
83         printk(KERN_INFO "%lu reserved pages\n",reserved);
84         printk(KERN_INFO "%lu pages shared\n",shared);
85         printk(KERN_INFO "%lu pages swap cached\n",cached);
86 }
87
88 /* References to section boundaries */
89
90 int after_bootmem;
91
92 static void *spp_getpage(void)
93
94         void *ptr;
95         if (after_bootmem)
96                 ptr = (void *) get_zeroed_page(GFP_ATOMIC); 
97         else
98                 ptr = alloc_bootmem_pages(PAGE_SIZE);
99         if (!ptr || ((unsigned long)ptr & ~PAGE_MASK))
100                 panic("set_pte_phys: cannot allocate page data %s\n", after_bootmem?"after bootmem":"");
101
102         Dprintk("spp_getpage %p\n", ptr);
103         return ptr;
104
105
106 static void set_pte_phys(unsigned long vaddr,
107                          unsigned long phys, pgprot_t prot)
108 {
109         pgd_t *pgd;
110         pud_t *pud;
111         pmd_t *pmd;
112         pte_t *pte, new_pte;
113
114         Dprintk("set_pte_phys %lx to %lx\n", vaddr, phys);
115
116         pgd = pgd_offset_k(vaddr);
117         if (pgd_none(*pgd)) {
118                 printk("PGD FIXMAP MISSING, it should be setup in head.S!\n");
119                 return;
120         }
121         pud = pud_offset(pgd, vaddr);
122         if (pud_none(*pud)) {
123                 pmd = (pmd_t *) spp_getpage(); 
124                 set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
125                 if (pmd != pmd_offset(pud, 0)) {
126                         printk("PAGETABLE BUG #01! %p <-> %p\n", pmd, pmd_offset(pud,0));
127                         return;
128                 }
129         }
130         pmd = pmd_offset(pud, vaddr);
131         if (pmd_none(*pmd)) {
132                 pte = (pte_t *) spp_getpage();
133                 set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE | _PAGE_USER));
134                 if (pte != pte_offset_kernel(pmd, 0)) {
135                         printk("PAGETABLE BUG #02!\n");
136                         return;
137                 }
138         }
139         new_pte = pfn_pte(phys >> PAGE_SHIFT, prot);
140
141         pte = pte_offset_kernel(pmd, vaddr);
142         if (!pte_none(*pte) &&
143             pte_val(*pte) != (pte_val(new_pte) & __supported_pte_mask))
144                 pte_ERROR(*pte);
145         set_pte(pte, new_pte);
146
147         /*
148          * It's enough to flush this one mapping.
149          * (PGE mappings get flushed as well)
150          */
151         __flush_tlb_one(vaddr);
152 }
153
154 /* NOTE: this is meant to be run only at boot */
155 void __set_fixmap (enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
156 {
157         unsigned long address = __fix_to_virt(idx);
158
159         if (idx >= __end_of_fixed_addresses) {
160                 printk("Invalid __set_fixmap\n");
161                 return;
162         }
163         set_pte_phys(address, phys, prot);
164 }
165
166 unsigned long __initdata table_start, table_end; 
167
168 extern pmd_t temp_boot_pmds[]; 
169
170 static  struct temp_map { 
171         pmd_t *pmd;
172         void  *address; 
173         int    allocated; 
174 } temp_mappings[] __initdata = { 
175         { &temp_boot_pmds[0], (void *)(40UL * 1024 * 1024) },
176         { &temp_boot_pmds[1], (void *)(42UL * 1024 * 1024) }, 
177         {}
178 }; 
179
180 static __init void *alloc_low_page(int *index, unsigned long *phys) 
181
182         struct temp_map *ti;
183         int i; 
184         unsigned long pfn = table_end++, paddr; 
185         void *adr;
186
187         if (pfn >= end_pfn) 
188                 panic("alloc_low_page: ran out of memory"); 
189         for (i = 0; temp_mappings[i].allocated; i++) {
190                 if (!temp_mappings[i].pmd) 
191                         panic("alloc_low_page: ran out of temp mappings"); 
192         } 
193         ti = &temp_mappings[i];
194         paddr = (pfn << PAGE_SHIFT) & PMD_MASK; 
195         set_pmd(ti->pmd, __pmd(paddr | _KERNPG_TABLE | _PAGE_PSE)); 
196         ti->allocated = 1; 
197         __flush_tlb();         
198         adr = ti->address + ((pfn << PAGE_SHIFT) & ~PMD_MASK); 
199         *index = i; 
200         *phys  = pfn * PAGE_SIZE;  
201         return adr; 
202
203
204 static __init void unmap_low_page(int i)
205
206         struct temp_map *ti = &temp_mappings[i];
207         set_pmd(ti->pmd, __pmd(0));
208         ti->allocated = 0; 
209
210
211 static void __init phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
212
213         long i, j; 
214
215         i = pud_index(address);
216         pud = pud + i;
217         for (; i < PTRS_PER_PUD; pud++, i++) {
218                 int map; 
219                 unsigned long paddr, pmd_phys;
220                 pmd_t *pmd;
221
222                 paddr = address + i*PUD_SIZE;
223                 if (paddr >= end) { 
224                         for (; i < PTRS_PER_PUD; i++, pud++) 
225                                 set_pud(pud, __pud(0)); 
226                         break;
227                 } 
228
229                 if (!e820_mapped(paddr, paddr+PUD_SIZE, 0)) { 
230                         set_pud(pud, __pud(0)); 
231                         continue;
232                 } 
233
234                 pmd = alloc_low_page(&map, &pmd_phys);
235                 set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
236                 for (j = 0; j < PTRS_PER_PMD; pmd++, j++, paddr += PMD_SIZE) {
237                         unsigned long pe;
238
239                         if (paddr >= end) { 
240                                 for (; j < PTRS_PER_PMD; j++, pmd++)
241                                         set_pmd(pmd,  __pmd(0)); 
242                                 break;
243                 }
244                         pe = _PAGE_NX|_PAGE_PSE | _KERNPG_TABLE | _PAGE_GLOBAL | paddr;
245                         pe &= __supported_pte_mask;
246                         set_pmd(pmd, __pmd(pe));
247                 }
248                 unmap_low_page(map);
249         }
250         __flush_tlb();
251
252
253 static void __init find_early_table_space(unsigned long end)
254 {
255         unsigned long puds, pmds, tables;
256
257         puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
258         pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
259         tables = round_up(puds * sizeof(pud_t), PAGE_SIZE) +
260                  round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
261
262         table_start = find_e820_area(0x8000, __pa_symbol(&_text), tables);
263         if (table_start == -1UL)
264                 panic("Cannot find space for the kernel page tables");
265
266         table_start >>= PAGE_SHIFT;
267         table_end = table_start;
268 }
269
270 /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
271    This runs before bootmem is initialized and gets pages directly from the 
272    physical memory. To access them they are temporarily mapped. */
273 void __init init_memory_mapping(unsigned long start, unsigned long end)
274
275         unsigned long next; 
276
277         Dprintk("init_memory_mapping\n");
278
279         /* 
280          * Find space for the kernel direct mapping tables.
281          * Later we should allocate these tables in the local node of the memory
282          * mapped.  Unfortunately this is done currently before the nodes are 
283          * discovered.
284          */
285         find_early_table_space(end);
286
287         start = (unsigned long)__va(start);
288         end = (unsigned long)__va(end);
289
290         for (; start < end; start = next) {
291                 int map;
292                 unsigned long pud_phys; 
293                 pud_t *pud = alloc_low_page(&map, &pud_phys);
294                 next = start + PGDIR_SIZE;
295                 if (next > end) 
296                         next = end; 
297                 phys_pud_init(pud, __pa(start), __pa(next));
298                 set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
299                 unmap_low_page(map);   
300         } 
301
302         asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
303         __flush_tlb_all();
304         early_printk("kernel direct mapping tables upto %lx @ %lx-%lx\n", end, 
305                table_start<<PAGE_SHIFT, 
306                table_end<<PAGE_SHIFT);
307 }
308
309 extern struct x8664_pda cpu_pda[NR_CPUS];
310
311 void __cpuinit zap_low_mappings(int cpu)
312 {
313         if (cpu == 0) {
314                 pgd_t *pgd = pgd_offset_k(0UL);
315                 pgd_clear(pgd);
316         } else {
317                 /*
318                  * For AP's, zap the low identity mappings by changing the cr3
319                  * to init_level4_pgt and doing local flush tlb all
320                  */
321                 asm volatile("movq %0,%%cr3" :: "r" (__pa_symbol(&init_level4_pgt)));
322         }
323         __flush_tlb_all();
324 }
325
326 /* Compute zone sizes for the DMA and DMA32 zones in a node. */
327 __init void
328 size_zones(unsigned long *z, unsigned long *h,
329            unsigned long start_pfn, unsigned long end_pfn)
330 {
331         int i;
332         unsigned long w;
333
334         for (i = 0; i < MAX_NR_ZONES; i++)
335                 z[i] = 0;
336
337         if (start_pfn < MAX_DMA_PFN)
338                 z[ZONE_DMA] = MAX_DMA_PFN - start_pfn;
339         if (start_pfn < MAX_DMA32_PFN) {
340                 unsigned long dma32_pfn = MAX_DMA32_PFN;
341                 if (dma32_pfn > end_pfn)
342                         dma32_pfn = end_pfn;
343                 z[ZONE_DMA32] = dma32_pfn - start_pfn;
344         }
345         z[ZONE_NORMAL] = end_pfn - start_pfn;
346
347         /* Remove lower zones from higher ones. */
348         w = 0;
349         for (i = 0; i < MAX_NR_ZONES; i++) {
350                 if (z[i])
351                         z[i] -= w;
352                 w += z[i];
353         }
354
355         /* Compute holes */
356         w = 0;
357         for (i = 0; i < MAX_NR_ZONES; i++) {
358                 unsigned long s = w;
359                 w += z[i];
360                 h[i] = e820_hole_size(s, w);
361         }
362
363         /* Add the space pace needed for mem_map to the holes too. */
364         for (i = 0; i < MAX_NR_ZONES; i++)
365                 h[i] += (z[i] * sizeof(struct page)) / PAGE_SIZE;
366
367         /* The 16MB DMA zone has the kernel and other misc mappings.
368            Account them too */
369         if (h[ZONE_DMA]) {
370                 h[ZONE_DMA] += dma_reserve;
371                 if (h[ZONE_DMA] >= z[ZONE_DMA]) {
372                         printk(KERN_WARNING
373                                 "Kernel too large and filling up ZONE_DMA?\n");
374                         h[ZONE_DMA] = z[ZONE_DMA];
375                 }
376         }
377 }
378
379 #ifndef CONFIG_NUMA
380 void __init paging_init(void)
381 {
382         unsigned long zones[MAX_NR_ZONES], holes[MAX_NR_ZONES];
383         size_zones(zones, holes, 0, end_pfn);
384         free_area_init_node(0, NODE_DATA(0), zones,
385                             __pa(PAGE_OFFSET) >> PAGE_SHIFT, holes);
386 }
387 #endif
388
389 /* Unmap a kernel mapping if it exists. This is useful to avoid prefetches
390    from the CPU leading to inconsistent cache lines. address and size
391    must be aligned to 2MB boundaries. 
392    Does nothing when the mapping doesn't exist. */
393 void __init clear_kernel_mapping(unsigned long address, unsigned long size) 
394 {
395         unsigned long end = address + size;
396
397         BUG_ON(address & ~LARGE_PAGE_MASK);
398         BUG_ON(size & ~LARGE_PAGE_MASK); 
399         
400         for (; address < end; address += LARGE_PAGE_SIZE) { 
401                 pgd_t *pgd = pgd_offset_k(address);
402                 pud_t *pud;
403                 pmd_t *pmd;
404                 if (pgd_none(*pgd))
405                         continue;
406                 pud = pud_offset(pgd, address);
407                 if (pud_none(*pud))
408                         continue; 
409                 pmd = pmd_offset(pud, address);
410                 if (!pmd || pmd_none(*pmd))
411                         continue; 
412                 if (0 == (pmd_val(*pmd) & _PAGE_PSE)) { 
413                         /* Could handle this, but it should not happen currently. */
414                         printk(KERN_ERR 
415                "clear_kernel_mapping: mapping has been split. will leak memory\n"); 
416                         pmd_ERROR(*pmd); 
417                 }
418                 set_pmd(pmd, __pmd(0));                 
419         }
420         __flush_tlb_all();
421
422
423 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
424                          kcore_vsyscall;
425
426 void __init mem_init(void)
427 {
428         long codesize, reservedpages, datasize, initsize;
429
430 #ifdef CONFIG_SWIOTLB
431         if (!iommu_aperture &&
432             (end_pfn >= 0xffffffff>>PAGE_SHIFT || force_iommu))
433                swiotlb = 1;
434         if (swiotlb)
435                 swiotlb_init(); 
436 #endif
437
438         /* How many end-of-memory variables you have, grandma! */
439         max_low_pfn = end_pfn;
440         max_pfn = end_pfn;
441         num_physpages = end_pfn;
442         high_memory = (void *) __va(end_pfn * PAGE_SIZE);
443
444         /* clear the zero-page */
445         memset(empty_zero_page, 0, PAGE_SIZE);
446
447         reservedpages = 0;
448
449         /* this will put all low memory onto the freelists */
450 #ifdef CONFIG_NUMA
451         totalram_pages = numa_free_all_bootmem();
452 #else
453         totalram_pages = free_all_bootmem();
454 #endif
455         reservedpages = end_pfn - totalram_pages - e820_hole_size(0, end_pfn);
456
457         after_bootmem = 1;
458
459         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
460         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
461         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
462
463         /* Register memory areas for /proc/kcore */
464         kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT); 
465         kclist_add(&kcore_vmalloc, (void *)VMALLOC_START, 
466                    VMALLOC_END-VMALLOC_START);
467         kclist_add(&kcore_kernel, &_stext, _end - _stext);
468         kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
469         kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START, 
470                                  VSYSCALL_END - VSYSCALL_START);
471
472         printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n",
473                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
474                 end_pfn << (PAGE_SHIFT-10),
475                 codesize >> 10,
476                 reservedpages << (PAGE_SHIFT-10),
477                 datasize >> 10,
478                 initsize >> 10);
479
480 #ifdef CONFIG_SMP
481         /*
482          * Sync boot_level4_pgt mappings with the init_level4_pgt
483          * except for the low identity mappings which are already zapped
484          * in init_level4_pgt. This sync-up is essential for AP's bringup
485          */
486         memcpy(boot_level4_pgt+1, init_level4_pgt+1, (PTRS_PER_PGD-1)*sizeof(pgd_t));
487 #endif
488 }
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 }