92d2108a62c3de03ce516fa9d23b1a6894d2598c
[linux-2.6.git] / arch / x86 / mm / init.c
1 #include <linux/ioport.h>
2 #include <linux/swap.h>
3
4 #include <asm/cacheflush.h>
5 #include <asm/e820.h>
6 #include <asm/init.h>
7 #include <asm/page.h>
8 #include <asm/page_types.h>
9 #include <asm/sections.h>
10 #include <asm/setup.h>
11 #include <asm/system.h>
12 #include <asm/tlbflush.h>
13 #include <asm/tlb.h>
14
15 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
16
17 unsigned long __initdata e820_table_start;
18 unsigned long __meminitdata e820_table_end;
19 unsigned long __meminitdata e820_table_top;
20
21 int after_bootmem;
22
23 int direct_gbpages
24 #ifdef CONFIG_DIRECT_GBPAGES
25                                 = 1
26 #endif
27 ;
28
29 int nx_enabled;
30
31 #if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
32 static int disable_nx __cpuinitdata;
33
34 /*
35  * noexec = on|off
36  *
37  * Control non-executable mappings for processes.
38  *
39  * on      Enable
40  * off     Disable
41  */
42 static int __init noexec_setup(char *str)
43 {
44         if (!str)
45                 return -EINVAL;
46         if (!strncmp(str, "on", 2)) {
47                 __supported_pte_mask |= _PAGE_NX;
48                 disable_nx = 0;
49         } else if (!strncmp(str, "off", 3)) {
50                 disable_nx = 1;
51                 __supported_pte_mask &= ~_PAGE_NX;
52         }
53         return 0;
54 }
55 early_param("noexec", noexec_setup);
56 #endif
57
58 #ifdef CONFIG_X86_PAE
59 static void __init set_nx(void)
60 {
61         unsigned int v[4], l, h;
62
63         if (cpu_has_pae && (cpuid_eax(0x80000000) > 0x80000001)) {
64                 cpuid(0x80000001, &v[0], &v[1], &v[2], &v[3]);
65
66                 if ((v[3] & (1 << 20)) && !disable_nx) {
67                         rdmsr(MSR_EFER, l, h);
68                         l |= EFER_NX;
69                         wrmsr(MSR_EFER, l, h);
70                         nx_enabled = 1;
71                         __supported_pte_mask |= _PAGE_NX;
72                 }
73         }
74 }
75 #else
76 static inline void set_nx(void)
77 {
78 }
79 #endif
80
81 #ifdef CONFIG_X86_64
82 void __cpuinit check_efer(void)
83 {
84         unsigned long efer;
85
86         rdmsrl(MSR_EFER, efer);
87         if (!(efer & EFER_NX) || disable_nx)
88                 __supported_pte_mask &= ~_PAGE_NX;
89 }
90 #endif
91
92 static void __init find_early_table_space(unsigned long end, int use_pse,
93                                           int use_gbpages)
94 {
95         unsigned long puds, pmds, ptes, tables, start;
96
97         puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
98         tables = roundup(puds * sizeof(pud_t), PAGE_SIZE);
99
100         if (use_gbpages) {
101                 unsigned long extra;
102
103                 extra = end - ((end>>PUD_SHIFT) << PUD_SHIFT);
104                 pmds = (extra + PMD_SIZE - 1) >> PMD_SHIFT;
105         } else
106                 pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
107
108         tables += roundup(pmds * sizeof(pmd_t), PAGE_SIZE);
109
110         if (use_pse) {
111                 unsigned long extra;
112
113                 extra = end - ((end>>PMD_SHIFT) << PMD_SHIFT);
114 #ifdef CONFIG_X86_32
115                 extra += PMD_SIZE;
116 #endif
117                 ptes = (extra + PAGE_SIZE - 1) >> PAGE_SHIFT;
118         } else
119                 ptes = (end + PAGE_SIZE - 1) >> PAGE_SHIFT;
120
121         tables += roundup(ptes * sizeof(pte_t), PAGE_SIZE);
122
123 #ifdef CONFIG_X86_32
124         /* for fixmap */
125         tables += roundup(__end_of_fixed_addresses * sizeof(pte_t), PAGE_SIZE);
126 #endif
127
128         /*
129          * RED-PEN putting page tables only on node 0 could
130          * cause a hotspot and fill up ZONE_DMA. The page tables
131          * need roughly 0.5KB per GB.
132          */
133 #ifdef CONFIG_X86_32
134         start = 0x7000;
135 #else
136         start = 0x8000;
137 #endif
138         e820_table_start = find_e820_area(start, max_pfn_mapped<<PAGE_SHIFT,
139                                         tables, PAGE_SIZE);
140         if (e820_table_start == -1UL)
141                 panic("Cannot find space for the kernel page tables");
142
143         e820_table_start >>= PAGE_SHIFT;
144         e820_table_end = e820_table_start;
145         e820_table_top = e820_table_start + (tables >> PAGE_SHIFT);
146
147         printk(KERN_DEBUG "kernel direct mapping tables up to %lx @ %lx-%lx\n",
148                 end, e820_table_start << PAGE_SHIFT, e820_table_top << PAGE_SHIFT);
149 }
150
151 struct map_range {
152         unsigned long start;
153         unsigned long end;
154         unsigned page_size_mask;
155 };
156
157 #ifdef CONFIG_X86_32
158 #define NR_RANGE_MR 3
159 #else /* CONFIG_X86_64 */
160 #define NR_RANGE_MR 5
161 #endif
162
163 static int __meminit save_mr(struct map_range *mr, int nr_range,
164                              unsigned long start_pfn, unsigned long end_pfn,
165                              unsigned long page_size_mask)
166 {
167         if (start_pfn < end_pfn) {
168                 if (nr_range >= NR_RANGE_MR)
169                         panic("run out of range for init_memory_mapping\n");
170                 mr[nr_range].start = start_pfn<<PAGE_SHIFT;
171                 mr[nr_range].end   = end_pfn<<PAGE_SHIFT;
172                 mr[nr_range].page_size_mask = page_size_mask;
173                 nr_range++;
174         }
175
176         return nr_range;
177 }
178
179 #ifdef CONFIG_X86_64
180 static void __init init_gbpages(void)
181 {
182         if (direct_gbpages && cpu_has_gbpages)
183                 printk(KERN_INFO "Using GB pages for direct mapping\n");
184         else
185                 direct_gbpages = 0;
186 }
187 #else
188 static inline void init_gbpages(void)
189 {
190 }
191 #endif
192
193 /*
194  * Setup the direct mapping of the physical memory at PAGE_OFFSET.
195  * This runs before bootmem is initialized and gets pages directly from
196  * the physical memory. To access them they are temporarily mapped.
197  */
198 unsigned long __init_refok init_memory_mapping(unsigned long start,
199                                                unsigned long end)
200 {
201         unsigned long page_size_mask = 0;
202         unsigned long start_pfn, end_pfn;
203         unsigned long ret = 0;
204         unsigned long pos;
205
206         struct map_range mr[NR_RANGE_MR];
207         int nr_range, i;
208         int use_pse, use_gbpages;
209
210         printk(KERN_INFO "init_memory_mapping: %016lx-%016lx\n", start, end);
211
212         if (!after_bootmem)
213                 init_gbpages();
214
215 #ifdef CONFIG_DEBUG_PAGEALLOC
216         /*
217          * For CONFIG_DEBUG_PAGEALLOC, identity mapping will use small pages.
218          * This will simplify cpa(), which otherwise needs to support splitting
219          * large pages into small in interrupt context, etc.
220          */
221         use_pse = use_gbpages = 0;
222 #else
223         use_pse = cpu_has_pse;
224         use_gbpages = direct_gbpages;
225 #endif
226
227         set_nx();
228         if (nx_enabled)
229                 printk(KERN_INFO "NX (Execute Disable) protection: active\n");
230
231         /* Enable PSE if available */
232         if (cpu_has_pse)
233                 set_in_cr4(X86_CR4_PSE);
234
235         /* Enable PGE if available */
236         if (cpu_has_pge) {
237                 set_in_cr4(X86_CR4_PGE);
238                 __supported_pte_mask |= _PAGE_GLOBAL;
239         }
240
241         if (use_gbpages)
242                 page_size_mask |= 1 << PG_LEVEL_1G;
243         if (use_pse)
244                 page_size_mask |= 1 << PG_LEVEL_2M;
245
246         memset(mr, 0, sizeof(mr));
247         nr_range = 0;
248
249         /* head if not big page alignment ? */
250         start_pfn = start >> PAGE_SHIFT;
251         pos = start_pfn << PAGE_SHIFT;
252 #ifdef CONFIG_X86_32
253         /*
254          * Don't use a large page for the first 2/4MB of memory
255          * because there are often fixed size MTRRs in there
256          * and overlapping MTRRs into large pages can cause
257          * slowdowns.
258          */
259         if (pos == 0)
260                 end_pfn = 1<<(PMD_SHIFT - PAGE_SHIFT);
261         else
262                 end_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT)
263                                  << (PMD_SHIFT - PAGE_SHIFT);
264 #else /* CONFIG_X86_64 */
265         end_pfn = ((pos + (PMD_SIZE - 1)) >> PMD_SHIFT)
266                         << (PMD_SHIFT - PAGE_SHIFT);
267 #endif
268         if (end_pfn > (end >> PAGE_SHIFT))
269                 end_pfn = end >> PAGE_SHIFT;
270         if (start_pfn < end_pfn) {
271                 nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);
272                 pos = end_pfn << PAGE_SHIFT;
273         }
274
275         /* big page (2M) range */
276         start_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT)
277                          << (PMD_SHIFT - PAGE_SHIFT);
278 #ifdef CONFIG_X86_32
279         end_pfn = (end>>PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT);
280 #else /* CONFIG_X86_64 */
281         end_pfn = ((pos + (PUD_SIZE - 1))>>PUD_SHIFT)
282                          << (PUD_SHIFT - PAGE_SHIFT);
283         if (end_pfn > ((end>>PMD_SHIFT)<<(PMD_SHIFT - PAGE_SHIFT)))
284                 end_pfn = ((end>>PMD_SHIFT)<<(PMD_SHIFT - PAGE_SHIFT));
285 #endif
286
287         if (start_pfn < end_pfn) {
288                 nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,
289                                 page_size_mask & (1<<PG_LEVEL_2M));
290                 pos = end_pfn << PAGE_SHIFT;
291         }
292
293 #ifdef CONFIG_X86_64
294         /* big page (1G) range */
295         start_pfn = ((pos + (PUD_SIZE - 1))>>PUD_SHIFT)
296                          << (PUD_SHIFT - PAGE_SHIFT);
297         end_pfn = (end >> PUD_SHIFT) << (PUD_SHIFT - PAGE_SHIFT);
298         if (start_pfn < end_pfn) {
299                 nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,
300                                 page_size_mask &
301                                  ((1<<PG_LEVEL_2M)|(1<<PG_LEVEL_1G)));
302                 pos = end_pfn << PAGE_SHIFT;
303         }
304
305         /* tail is not big page (1G) alignment */
306         start_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT)
307                          << (PMD_SHIFT - PAGE_SHIFT);
308         end_pfn = (end >> PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT);
309         if (start_pfn < end_pfn) {
310                 nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,
311                                 page_size_mask & (1<<PG_LEVEL_2M));
312                 pos = end_pfn << PAGE_SHIFT;
313         }
314 #endif
315
316         /* tail is not big page (2M) alignment */
317         start_pfn = pos>>PAGE_SHIFT;
318         end_pfn = end>>PAGE_SHIFT;
319         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);
320
321         /* try to merge same page size and continuous */
322         for (i = 0; nr_range > 1 && i < nr_range - 1; i++) {
323                 unsigned long old_start;
324                 if (mr[i].end != mr[i+1].start ||
325                     mr[i].page_size_mask != mr[i+1].page_size_mask)
326                         continue;
327                 /* move it */
328                 old_start = mr[i].start;
329                 memmove(&mr[i], &mr[i+1],
330                         (nr_range - 1 - i) * sizeof(struct map_range));
331                 mr[i--].start = old_start;
332                 nr_range--;
333         }
334
335         for (i = 0; i < nr_range; i++)
336                 printk(KERN_DEBUG " %010lx - %010lx page %s\n",
337                                 mr[i].start, mr[i].end,
338                         (mr[i].page_size_mask & (1<<PG_LEVEL_1G))?"1G":(
339                          (mr[i].page_size_mask & (1<<PG_LEVEL_2M))?"2M":"4k"));
340
341         /*
342          * Find space for the kernel direct mapping tables.
343          *
344          * Later we should allocate these tables in the local node of the
345          * memory mapped. Unfortunately this is done currently before the
346          * nodes are discovered.
347          */
348         if (!after_bootmem)
349                 find_early_table_space(end, use_pse, use_gbpages);
350
351 #ifdef CONFIG_X86_32
352         for (i = 0; i < nr_range; i++)
353                 kernel_physical_mapping_init(mr[i].start, mr[i].end,
354                                              mr[i].page_size_mask);
355         ret = end;
356 #else /* CONFIG_X86_64 */
357         for (i = 0; i < nr_range; i++)
358                 ret = kernel_physical_mapping_init(mr[i].start, mr[i].end,
359                                                    mr[i].page_size_mask);
360 #endif
361
362 #ifdef CONFIG_X86_32
363         early_ioremap_page_table_range_init();
364
365         load_cr3(swapper_pg_dir);
366 #endif
367
368 #ifdef CONFIG_X86_64
369         if (!after_bootmem && !start) {
370                 pud_t *pud;
371                 pmd_t *pmd;
372
373                 mmu_cr4_features = read_cr4();
374
375                 /*
376                  * _brk_end cannot change anymore, but it and _end may be
377                  * located on different 2M pages. cleanup_highmap(), however,
378                  * can only consider _end when it runs, so destroy any
379                  * mappings beyond _brk_end here.
380                  */
381                 pud = pud_offset(pgd_offset_k(_brk_end), _brk_end);
382                 pmd = pmd_offset(pud, _brk_end - 1);
383                 while (++pmd <= pmd_offset(pud, (unsigned long)_end - 1))
384                         pmd_clear(pmd);
385         }
386 #endif
387         __flush_tlb_all();
388
389         if (!after_bootmem && e820_table_end > e820_table_start)
390                 reserve_early(e820_table_start << PAGE_SHIFT,
391                                  e820_table_end << PAGE_SHIFT, "PGTABLE");
392
393         if (!after_bootmem)
394                 early_memtest(start, end);
395
396         return ret >> PAGE_SHIFT;
397 }
398
399
400 /*
401  * devmem_is_allowed() checks to see if /dev/mem access to a certain address
402  * is valid. The argument is a physical page number.
403  *
404  *
405  * On x86, access has to be given to the first megabyte of ram because that area
406  * contains bios code and data regions used by X and dosemu and similar apps.
407  * Access has to be given to non-kernel-ram areas as well, these contain the PCI
408  * mmio resources as well as potential bios/acpi data regions.
409  */
410 int devmem_is_allowed(unsigned long pagenr)
411 {
412         if (pagenr <= 256)
413                 return 1;
414         if (iomem_is_exclusive(pagenr << PAGE_SHIFT))
415                 return 0;
416         if (!page_is_ram(pagenr))
417                 return 1;
418         return 0;
419 }
420
421 void free_init_pages(char *what, unsigned long begin, unsigned long end)
422 {
423         unsigned long addr = begin;
424
425         if (addr >= end)
426                 return;
427
428         /*
429          * If debugging page accesses then do not free this memory but
430          * mark them not present - any buggy init-section access will
431          * create a kernel page fault:
432          */
433 #ifdef CONFIG_DEBUG_PAGEALLOC
434         printk(KERN_INFO "debug: unmapping init memory %08lx..%08lx\n",
435                 begin, PAGE_ALIGN(end));
436         set_memory_np(begin, (end - begin) >> PAGE_SHIFT);
437 #else
438         /*
439          * We just marked the kernel text read only above, now that
440          * we are going to free part of that, we need to make that
441          * writeable first.
442          */
443         set_memory_rw(begin, (end - begin) >> PAGE_SHIFT);
444
445         printk(KERN_INFO "Freeing %s: %luk freed\n", what, (end - begin) >> 10);
446
447         for (; addr < end; addr += PAGE_SIZE) {
448                 ClearPageReserved(virt_to_page(addr));
449                 init_page_count(virt_to_page(addr));
450                 memset((void *)(addr & ~(PAGE_SIZE-1)),
451                         POISON_FREE_INITMEM, PAGE_SIZE);
452                 free_page(addr);
453                 totalram_pages++;
454         }
455 #endif
456 }
457
458 void free_initmem(void)
459 {
460         free_init_pages("unused kernel memory",
461                         (unsigned long)(&__init_begin),
462                         (unsigned long)(&__init_end));
463 }
464
465 #ifdef CONFIG_BLK_DEV_INITRD
466 void free_initrd_mem(unsigned long start, unsigned long end)
467 {
468         free_init_pages("initrd memory", start, end);
469 }
470 #endif