blob: da524fb22422eafc8b4d6514609aec749ffc2dc0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/arch/i386/mm/init.c
3 *
4 * Copyright (C) 1995 Linus Torvalds
5 *
6 * Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
7 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/module.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/hugetlb.h>
20#include <linux/swap.h>
21#include <linux/smp.h>
22#include <linux/init.h>
23#include <linux/highmem.h>
24#include <linux/pagemap.h>
Jan Beulich6fb14752007-05-02 19:27:10 +020025#include <linux/pfn.h>
Randy Dunlapc9cf5522006-06-27 02:53:52 -070026#include <linux/poison.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/bootmem.h>
28#include <linux/slab.h>
29#include <linux/proc_fs.h>
Dave Hansen05039b92005-10-29 18:16:57 -070030#include <linux/memory_hotplug.h>
Adrian Bunk27d99f72005-11-13 16:06:51 -080031#include <linux/initrd.h>
Shaohua Li55b23552006-06-23 02:04:49 -070032#include <linux/cpumask.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34#include <asm/processor.h>
35#include <asm/system.h>
36#include <asm/uaccess.h>
37#include <asm/pgtable.h>
38#include <asm/dma.h>
39#include <asm/fixmap.h>
40#include <asm/e820.h>
41#include <asm/apic.h>
Ingo Molnar8550eb92008-01-30 13:34:10 +010042#include <asm/bugs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <asm/tlb.h>
44#include <asm/tlbflush.h>
Jeremy Fitzhardingea5a19c62008-01-30 13:33:39 +010045#include <asm/pgalloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <asm/sections.h>
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +020047#include <asm/paravirt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49unsigned int __VMALLOC_RESERVE = 128 << 20;
50
51DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
52unsigned long highstart_pfn, highend_pfn;
53
Ingo Molnar8550eb92008-01-30 13:34:10 +010054static noinline int do_test_wp_bit(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56/*
57 * Creates a middle page table and puts a pointer to it in the
58 * given global directory entry. This only returns the gd entry
59 * in non-PAE compilation mode, since the middle layer is folded.
60 */
61static pmd_t * __init one_md_table_init(pgd_t *pgd)
62{
63 pud_t *pud;
64 pmd_t *pmd_table;
Ingo Molnar8550eb92008-01-30 13:34:10 +010065
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#ifdef CONFIG_X86_PAE
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +020067 if (!(pgd_val(*pgd) & _PAGE_PRESENT)) {
68 pmd_table = (pmd_t *) alloc_bootmem_low_pages(PAGE_SIZE);
69
Jeremy Fitzhardinge6c435452008-01-30 13:33:39 +010070 paravirt_alloc_pd(&init_mm, __pa(pmd_table) >> PAGE_SHIFT);
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +020071 set_pgd(pgd, __pgd(__pa(pmd_table) | _PAGE_PRESENT));
72 pud = pud_offset(pgd, 0);
Ingo Molnar8550eb92008-01-30 13:34:10 +010073 BUG_ON(pmd_table != pmd_offset(pud, 0));
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +020074 }
75#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 pud = pud_offset(pgd, 0);
77 pmd_table = pmd_offset(pud, 0);
Ingo Molnar8550eb92008-01-30 13:34:10 +010078
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 return pmd_table;
80}
81
82/*
83 * Create a page table and place a pointer to it in a middle page
Ingo Molnar8550eb92008-01-30 13:34:10 +010084 * directory entry:
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 */
86static pte_t * __init one_page_table_init(pmd_t *pmd)
87{
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +020088 if (!(pmd_val(*pmd) & _PAGE_PRESENT)) {
Ingo Molnar509a80c2007-10-17 18:04:34 +020089 pte_t *page_table = NULL;
90
91#ifdef CONFIG_DEBUG_PAGEALLOC
92 page_table = (pte_t *) alloc_bootmem_pages(PAGE_SIZE);
93#endif
Ingo Molnar8550eb92008-01-30 13:34:10 +010094 if (!page_table) {
Ingo Molnar509a80c2007-10-17 18:04:34 +020095 page_table =
96 (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
Ingo Molnar8550eb92008-01-30 13:34:10 +010097 }
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +020098
Jeremy Fitzhardingefdb4c332007-07-17 18:37:03 -070099 paravirt_alloc_pt(&init_mm, __pa(page_table) >> PAGE_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE));
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200101 BUG_ON(page_table != pte_offset_kernel(pmd, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 }
Ingo Molnar509a80c2007-10-17 18:04:34 +0200103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 return pte_offset_kernel(pmd, 0);
105}
106
107/*
Ingo Molnar8550eb92008-01-30 13:34:10 +0100108 * This function initializes a certain range of kernel virtual memory
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 * with new bootmem page tables, everywhere page tables are missing in
110 * the given range.
Ingo Molnar8550eb92008-01-30 13:34:10 +0100111 *
112 * NOTE: The pagetables are allocated contiguous on the physical space
113 * so we can cache the place of the first one and move around without
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 * checking the pgd every time.
115 */
Ingo Molnar8550eb92008-01-30 13:34:10 +0100116static void __init
117page_table_range_init(unsigned long start, unsigned long end, pgd_t *pgd_base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 int pgd_idx, pmd_idx;
120 unsigned long vaddr;
Ingo Molnar8550eb92008-01-30 13:34:10 +0100121 pgd_t *pgd;
122 pmd_t *pmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124 vaddr = start;
125 pgd_idx = pgd_index(vaddr);
126 pmd_idx = pmd_index(vaddr);
127 pgd = pgd_base + pgd_idx;
128
129 for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd++, pgd_idx++) {
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200130 pmd = one_md_table_init(pgd);
131 pmd = pmd + pmd_index(vaddr);
Ingo Molnar8550eb92008-01-30 13:34:10 +0100132 for (; (pmd_idx < PTRS_PER_PMD) && (vaddr != end);
133 pmd++, pmd_idx++) {
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200134 one_page_table_init(pmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
136 vaddr += PMD_SIZE;
137 }
138 pmd_idx = 0;
139 }
140}
141
142static inline int is_kernel_text(unsigned long addr)
143{
144 if (addr >= PAGE_OFFSET && addr <= (unsigned long)__init_end)
145 return 1;
146 return 0;
147}
148
149/*
Ingo Molnar8550eb92008-01-30 13:34:10 +0100150 * This maps the physical memory to kernel virtual address space, a total
151 * of max_low_pfn pages, by creating page tables starting from address
152 * PAGE_OFFSET:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 */
154static void __init kernel_physical_mapping_init(pgd_t *pgd_base)
155{
Ingo Molnar8550eb92008-01-30 13:34:10 +0100156 int pgd_idx, pmd_idx, pte_ofs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 unsigned long pfn;
158 pgd_t *pgd;
159 pmd_t *pmd;
160 pte_t *pte;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 pgd_idx = pgd_index(PAGE_OFFSET);
163 pgd = pgd_base + pgd_idx;
164 pfn = 0;
165
166 for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
167 pmd = one_md_table_init(pgd);
168 if (pfn >= max_low_pfn)
169 continue;
Ingo Molnar8550eb92008-01-30 13:34:10 +0100170
Jeremy Fitzhardingef3f20de2008-01-30 13:31:09 +0100171 for (pmd_idx = 0;
172 pmd_idx < PTRS_PER_PMD && pfn < max_low_pfn;
173 pmd++, pmd_idx++) {
Ingo Molnar8550eb92008-01-30 13:34:10 +0100174 unsigned int addr = pfn * PAGE_SIZE + PAGE_OFFSET;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Ingo Molnar8550eb92008-01-30 13:34:10 +0100176 /*
177 * Map with big pages if possible, otherwise
178 * create normal page tables:
179 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 if (cpu_has_pse) {
Ingo Molnar8550eb92008-01-30 13:34:10 +0100181 unsigned int addr2;
Jeremy Fitzhardingef3f20de2008-01-30 13:31:09 +0100182 pgprot_t prot = PAGE_KERNEL_LARGE;
183
Ingo Molnar8550eb92008-01-30 13:34:10 +0100184 addr2 = (pfn + PTRS_PER_PTE-1) * PAGE_SIZE +
Jeremy Fitzhardingef3f20de2008-01-30 13:31:09 +0100185 PAGE_OFFSET + PAGE_SIZE-1;
186
Ingo Molnar8550eb92008-01-30 13:34:10 +0100187 if (is_kernel_text(addr) ||
188 is_kernel_text(addr2))
Jeremy Fitzhardingef3f20de2008-01-30 13:31:09 +0100189 prot = PAGE_KERNEL_LARGE_EXEC;
190
191 set_pmd(pmd, pfn_pmd(pfn, prot));
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 pfn += PTRS_PER_PTE;
Ingo Molnar8550eb92008-01-30 13:34:10 +0100194 continue;
195 }
196 pte = one_page_table_init(pmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Ingo Molnar8550eb92008-01-30 13:34:10 +0100198 for (pte_ofs = 0;
199 pte_ofs < PTRS_PER_PTE && pfn < max_low_pfn;
200 pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {
201 pgprot_t prot = PAGE_KERNEL;
Jeremy Fitzhardingef3f20de2008-01-30 13:31:09 +0100202
Ingo Molnar8550eb92008-01-30 13:34:10 +0100203 if (is_kernel_text(addr))
204 prot = PAGE_KERNEL_EXEC;
Jeremy Fitzhardingef3f20de2008-01-30 13:31:09 +0100205
Ingo Molnar8550eb92008-01-30 13:34:10 +0100206 set_pte(pte, pfn_pte(pfn, prot));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 }
208 }
209 }
210}
211
212static inline int page_kills_ppro(unsigned long pagenr)
213{
214 if (pagenr >= 0x70000 && pagenr <= 0x7003F)
215 return 1;
216 return 0;
217}
218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219#ifdef CONFIG_HIGHMEM
220pte_t *kmap_pte;
221pgprot_t kmap_prot;
222
Ingo Molnar8550eb92008-01-30 13:34:10 +0100223static inline pte_t *kmap_get_fixmap_pte(unsigned long vaddr)
224{
225 return pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr),
226 vaddr), vaddr), vaddr);
227}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
229static void __init kmap_init(void)
230{
231 unsigned long kmap_vstart;
232
Ingo Molnar8550eb92008-01-30 13:34:10 +0100233 /*
234 * Cache the first kmap pte:
235 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
237 kmap_pte = kmap_get_fixmap_pte(kmap_vstart);
238
239 kmap_prot = PAGE_KERNEL;
240}
241
242static void __init permanent_kmaps_init(pgd_t *pgd_base)
243{
Ingo Molnar8550eb92008-01-30 13:34:10 +0100244 unsigned long vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 pgd_t *pgd;
246 pud_t *pud;
247 pmd_t *pmd;
248 pte_t *pte;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
250 vaddr = PKMAP_BASE;
251 page_table_range_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, pgd_base);
252
253 pgd = swapper_pg_dir + pgd_index(vaddr);
254 pud = pud_offset(pgd, vaddr);
255 pmd = pmd_offset(pud, vaddr);
256 pte = pte_offset_kernel(pmd, vaddr);
Ingo Molnar8550eb92008-01-30 13:34:10 +0100257 pkmap_page_table = pte;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258}
259
Matt Tolentinoc09b4242006-01-17 07:03:44 +0100260static void __meminit free_new_highpage(struct page *page)
Dave Hansen05039b92005-10-29 18:16:57 -0700261{
Nick Piggin7835e982006-03-22 00:08:40 -0800262 init_page_count(page);
Dave Hansen05039b92005-10-29 18:16:57 -0700263 __free_page(page);
264 totalhigh_pages++;
265}
266
267void __init add_one_highpage_init(struct page *page, int pfn, int bad_ppro)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268{
269 if (page_is_ram(pfn) && !(bad_ppro && page_kills_ppro(pfn))) {
270 ClearPageReserved(page);
Dave Hansen05039b92005-10-29 18:16:57 -0700271 free_new_highpage(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 } else
273 SetPageReserved(page);
274}
275
Ingo Molnar8550eb92008-01-30 13:34:10 +0100276static int __meminit
277add_one_highpage_hotplug(struct page *page, unsigned long pfn)
Dave Hansen05039b92005-10-29 18:16:57 -0700278{
279 free_new_highpage(page);
280 totalram_pages++;
281#ifdef CONFIG_FLATMEM
282 max_mapnr = max(pfn, max_mapnr);
283#endif
284 num_physpages++;
Ingo Molnar8550eb92008-01-30 13:34:10 +0100285
Dave Hansen05039b92005-10-29 18:16:57 -0700286 return 0;
287}
288
289/*
290 * Not currently handling the NUMA case.
291 * Assuming single node and all memory that
292 * has been added dynamically that would be
Ingo Molnar8550eb92008-01-30 13:34:10 +0100293 * onlined here is in HIGHMEM.
Dave Hansen05039b92005-10-29 18:16:57 -0700294 */
Vivek Goyal0e0be252007-01-11 01:52:44 +0100295void __meminit online_page(struct page *page)
Dave Hansen05039b92005-10-29 18:16:57 -0700296{
297 ClearPageReserved(page);
298 add_one_highpage_hotplug(page, page_to_pfn(page));
299}
300
Ingo Molnar8550eb92008-01-30 13:34:10 +0100301#ifndef CONFIG_NUMA
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302static void __init set_highmem_pages_init(int bad_ppro)
303{
304 int pfn;
Ingo Molnar8550eb92008-01-30 13:34:10 +0100305
Ingo Molnar23be8c72008-01-15 16:44:37 +0100306 for (pfn = highstart_pfn; pfn < highend_pfn; pfn++) {
307 /*
308 * Holes under sparsemem might not have no mem_map[]:
309 */
310 if (pfn_valid(pfn))
311 add_one_highpage_init(pfn_to_page(pfn), pfn, bad_ppro);
312 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 totalram_pages += totalhigh_pages;
314}
Ingo Molnar8550eb92008-01-30 13:34:10 +0100315#endif /* !CONFIG_NUMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317#else
Ingo Molnar8550eb92008-01-30 13:34:10 +0100318# define kmap_init() do { } while (0)
319# define permanent_kmaps_init(pgd_base) do { } while (0)
320# define set_highmem_pages_init(bad_ppro) do { } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321#endif /* CONFIG_HIGHMEM */
322
Andi Kleenc93c82b2008-01-30 13:33:50 +0100323pteval_t __PAGE_KERNEL = _PAGE_KERNEL;
Alexey Dobriyan129f6942005-06-23 00:08:33 -0700324EXPORT_SYMBOL(__PAGE_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Ingo Molnar8550eb92008-01-30 13:34:10 +0100326pteval_t __PAGE_KERNEL_EXEC = _PAGE_KERNEL_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200328void __init native_pagetable_setup_start(pgd_t *base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330#ifdef CONFIG_X86_PAE
331 int i;
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200332
333 /*
334 * Init entries of the first-level page table to the
335 * zero page, if they haven't already been set up.
336 *
337 * In a normal native boot, we'll be running on a
338 * pagetable rooted in swapper_pg_dir, but not in PAE
339 * mode, so this will end up clobbering the mappings
340 * for the lower 24Mbytes of the address space,
341 * without affecting the kernel address space.
342 */
343 for (i = 0; i < USER_PTRS_PER_PGD; i++)
344 set_pgd(&base[i],
345 __pgd(__pa(empty_zero_page) | _PAGE_PRESENT));
346
347 /* Make sure kernel address space is empty so that a pagetable
348 will be allocated for it. */
349 memset(&base[USER_PTRS_PER_PGD], 0,
350 KERNEL_PGD_PTRS * sizeof(pgd_t));
Zachary Amsdenc119ecc2007-02-13 13:26:21 +0100351#else
Jeremy Fitzhardinge6c435452008-01-30 13:33:39 +0100352 paravirt_alloc_pd(&init_mm, __pa(base) >> PAGE_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353#endif
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200354}
355
356void __init native_pagetable_setup_done(pgd_t *base)
357{
358#ifdef CONFIG_X86_PAE
359 /*
360 * Add low memory identity-mappings - SMP needs it when
361 * starting up on an AP from real-mode. In the non-PAE
362 * case we already have these mappings through head.S.
363 * All user-space mappings are explicitly cleared after
364 * SMP startup.
365 */
366 set_pgd(&base[0], base[USER_PTRS_PER_PGD]);
367#endif
368}
369
370/*
371 * Build a proper pagetable for the kernel mappings. Up until this
372 * point, we've been running on some set of pagetables constructed by
373 * the boot process.
374 *
375 * If we're booting on native hardware, this will be a pagetable
376 * constructed in arch/i386/kernel/head.S, and not running in PAE mode
377 * (even if we'll end up running in PAE). The root of the pagetable
378 * will be swapper_pg_dir.
379 *
380 * If we're booting paravirtualized under a hypervisor, then there are
381 * more options: we may already be running PAE, and the pagetable may
382 * or may not be based in swapper_pg_dir. In any case,
383 * paravirt_pagetable_setup_start() will set up swapper_pg_dir
384 * appropriately for the rest of the initialization to work.
385 *
386 * In general, pagetable_init() assumes that the pagetable may already
387 * be partially populated, and so it avoids stomping on any existing
388 * mappings.
389 */
Ingo Molnar8550eb92008-01-30 13:34:10 +0100390static void __init pagetable_init(void)
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200391{
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200392 pgd_t *pgd_base = swapper_pg_dir;
Ingo Molnar8550eb92008-01-30 13:34:10 +0100393 unsigned long vaddr, end;
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200394
395 paravirt_pagetable_setup_start(pgd_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
397 /* Enable PSE if available */
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200398 if (cpu_has_pse)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 set_in_cr4(X86_CR4_PSE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401 /* Enable PGE if available */
402 if (cpu_has_pge) {
403 set_in_cr4(X86_CR4_PGE);
404 __PAGE_KERNEL |= _PAGE_GLOBAL;
405 __PAGE_KERNEL_EXEC |= _PAGE_GLOBAL;
406 }
407
408 kernel_physical_mapping_init(pgd_base);
409 remap_numa_kva();
410
411 /*
412 * Fixed mappings, only the page table structure has to be
413 * created - mappings will be set by set_fixmap():
414 */
Huang, Yingbeacfaa2008-01-30 13:33:44 +0100415 early_ioremap_clear();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200417 end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;
418 page_table_range_init(vaddr, end, pgd_base);
Huang, Yingbeacfaa2008-01-30 13:33:44 +0100419 early_ioremap_reset();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421 permanent_kmaps_init(pgd_base);
422
Jeremy Fitzhardingeb239fb22007-05-02 19:27:13 +0200423 paravirt_pagetable_setup_done(pgd_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424}
425
Rafael J. Wysockib0cb1a12007-07-29 23:24:36 +0200426#if defined(CONFIG_HIBERNATION) || defined(CONFIG_ACPI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427/*
428 * Swap suspend & friends need this for resume because things like the intel-agp
429 * driver might have split up a kernel 4MB mapping.
430 */
431char __nosavedata swsusp_pg_dir[PAGE_SIZE]
Ingo Molnar8550eb92008-01-30 13:34:10 +0100432 __attribute__ ((aligned(PAGE_SIZE)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434static inline void save_pg_dir(void)
435{
436 memcpy(swsusp_pg_dir, swapper_pg_dir, PAGE_SIZE);
437}
438#else
439static inline void save_pg_dir(void)
440{
441}
442#endif
443
Ingo Molnar8550eb92008-01-30 13:34:10 +0100444void zap_low_mappings(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{
446 int i;
447
448 save_pg_dir();
449
450 /*
451 * Zap initial low-memory mappings.
452 *
453 * Note that "pgd_clear()" doesn't do it for
454 * us, because pgd_clear() is a no-op on i386.
455 */
Ingo Molnar8550eb92008-01-30 13:34:10 +0100456 for (i = 0; i < USER_PTRS_PER_PGD; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457#ifdef CONFIG_X86_PAE
458 set_pgd(swapper_pg_dir+i, __pgd(1 + __pa(empty_zero_page)));
459#else
460 set_pgd(swapper_pg_dir+i, __pgd(0));
461#endif
Ingo Molnar8550eb92008-01-30 13:34:10 +0100462 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 flush_tlb_all();
464}
465
Ingo Molnar8550eb92008-01-30 13:34:10 +0100466int nx_enabled;
Jan Beulichd5321ab2007-07-21 17:10:26 +0200467
Jeremy Fitzhardinge6fdc05d2008-01-30 13:32:57 +0100468pteval_t __supported_pte_mask __read_mostly = ~_PAGE_NX;
469EXPORT_SYMBOL_GPL(__supported_pte_mask);
470
Jan Beulichd5321ab2007-07-21 17:10:26 +0200471#ifdef CONFIG_X86_PAE
472
Ingo Molnar8550eb92008-01-30 13:34:10 +0100473static int disable_nx __initdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
475/*
476 * noexec = on|off
477 *
478 * Control non executable mappings.
479 *
480 * on Enable
481 * off Disable
482 */
Rusty Russell1a3f2392006-09-26 10:52:32 +0200483static int __init noexec_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484{
Rusty Russell1a3f2392006-09-26 10:52:32 +0200485 if (!str || !strcmp(str, "on")) {
486 if (cpu_has_nx) {
487 __supported_pte_mask |= _PAGE_NX;
488 disable_nx = 0;
489 }
Ingo Molnar8550eb92008-01-30 13:34:10 +0100490 } else {
491 if (!strcmp(str, "off")) {
492 disable_nx = 1;
493 __supported_pte_mask &= ~_PAGE_NX;
494 } else {
495 return -EINVAL;
496 }
497 }
Rusty Russell1a3f2392006-09-26 10:52:32 +0200498
499 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
Rusty Russell1a3f2392006-09-26 10:52:32 +0200501early_param("noexec", noexec_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503static void __init set_nx(void)
504{
505 unsigned int v[4], l, h;
506
507 if (cpu_has_pae && (cpuid_eax(0x80000000) > 0x80000001)) {
508 cpuid(0x80000001, &v[0], &v[1], &v[2], &v[3]);
Ingo Molnar8550eb92008-01-30 13:34:10 +0100509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 if ((v[3] & (1 << 20)) && !disable_nx) {
511 rdmsr(MSR_EFER, l, h);
512 l |= EFER_NX;
513 wrmsr(MSR_EFER, l, h);
514 nx_enabled = 1;
515 __supported_pte_mask |= _PAGE_NX;
516 }
517 }
518}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519#endif
520
521/*
522 * paging_init() sets up the page tables - note that the first 8MB are
523 * already mapped by head.S.
524 *
525 * This routines also unmaps the page at virtual kernel address 0, so
526 * that we can trap those pesky NULL-reference errors in the kernel.
527 */
528void __init paging_init(void)
529{
530#ifdef CONFIG_X86_PAE
531 set_nx();
532 if (nx_enabled)
Ingo Molnard7d119d2008-01-30 13:34:10 +0100533 printk(KERN_INFO "NX (Execute Disable) protection: active\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 pagetable_init();
536
537 load_cr3(swapper_pg_dir);
538
539#ifdef CONFIG_X86_PAE
540 /*
541 * We will bail out later - printk doesn't work right now so
542 * the user would just see a hanging kernel.
543 */
544 if (cpu_has_pae)
545 set_in_cr4(X86_CR4_PAE);
546#endif
547 __flush_tlb_all();
548
549 kmap_init();
550}
551
552/*
553 * Test if the WP bit works in supervisor mode. It isn't supported on 386's
554 * and also on some strange 486's (NexGen etc.). All 586+'s are OK. This
555 * used to involve black magic jumps to work around some nasty CPU bugs,
556 * but fortunately the switch to using exceptions got rid of all that.
557 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558static void __init test_wp_bit(void)
559{
Ingo Molnard7d119d2008-01-30 13:34:10 +0100560 printk(KERN_INFO
561 "Checking if this processor honours the WP bit even in supervisor mode...");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
563 /* Any page-aligned address will do, the test is non-destructive */
564 __set_fixmap(FIX_WP_TEST, __pa(&swapper_pg_dir), PAGE_READONLY);
565 boot_cpu_data.wp_works_ok = do_test_wp_bit();
566 clear_fixmap(FIX_WP_TEST);
567
568 if (!boot_cpu_data.wp_works_ok) {
Ingo Molnard7d119d2008-01-30 13:34:10 +0100569 printk(KERN_CONT "No.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570#ifdef CONFIG_X86_WP_WORKS_OK
Ingo Molnard7d119d2008-01-30 13:34:10 +0100571 panic(
572 "This kernel doesn't support CPU's with broken WP. Recompile it for a 386!");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573#endif
574 } else {
Ingo Molnard7d119d2008-01-30 13:34:10 +0100575 printk(KERN_CONT "Ok.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 }
577}
578
Ingo Molnar8550eb92008-01-30 13:34:10 +0100579static struct kcore_list kcore_mem, kcore_vmalloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581void __init mem_init(void)
582{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 int codesize, reservedpages, datasize, initsize;
Ingo Molnar8550eb92008-01-30 13:34:10 +0100584 int tmp, bad_ppro;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Andy Whitcroft05b79bd2005-06-23 00:07:57 -0700586#ifdef CONFIG_FLATMEM
Eric Sesterhenn8d8f3cb2006-10-03 23:34:58 +0200587 BUG_ON(!mem_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 bad_ppro = ppro_with_ram_bug();
590
591#ifdef CONFIG_HIGHMEM
592 /* check that fixmap and pkmap do not overlap */
Ingo Molnard7d119d2008-01-30 13:34:10 +0100593 if (PKMAP_BASE + LAST_PKMAP*PAGE_SIZE >= FIXADDR_START) {
594 printk(KERN_ERR
595 "fixmap and kmap areas overlap - this will crash\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 printk(KERN_ERR "pkstart: %lxh pkend: %lxh fixstart %lxh\n",
Ingo Molnard7d119d2008-01-30 13:34:10 +0100597 PKMAP_BASE, PKMAP_BASE + LAST_PKMAP*PAGE_SIZE,
598 FIXADDR_START);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 BUG();
600 }
601#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 /* this will put all low memory onto the freelists */
603 totalram_pages += free_all_bootmem();
604
605 reservedpages = 0;
606 for (tmp = 0; tmp < max_low_pfn; tmp++)
607 /*
Ingo Molnar8550eb92008-01-30 13:34:10 +0100608 * Only count reserved RAM pages:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 */
610 if (page_is_ram(tmp) && PageReserved(pfn_to_page(tmp)))
611 reservedpages++;
612
613 set_highmem_pages_init(bad_ppro);
614
615 codesize = (unsigned long) &_etext - (unsigned long) &_text;
616 datasize = (unsigned long) &_edata - (unsigned long) &_etext;
617 initsize = (unsigned long) &__init_end - (unsigned long) &__init_begin;
618
Ingo Molnar8550eb92008-01-30 13:34:10 +0100619 kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
620 kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 VMALLOC_END-VMALLOC_START);
622
Ingo Molnar8550eb92008-01-30 13:34:10 +0100623 printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, "
624 "%dk reserved, %dk data, %dk init, %ldk highmem)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
626 num_physpages << (PAGE_SHIFT-10),
627 codesize >> 10,
628 reservedpages << (PAGE_SHIFT-10),
629 datasize >> 10,
630 initsize >> 10,
631 (unsigned long) (totalhigh_pages << (PAGE_SHIFT-10))
632 );
633
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700634#if 1 /* double-sanity-check paranoia */
Ingo Molnard7d119d2008-01-30 13:34:10 +0100635 printk(KERN_INFO "virtual kernel memory layout:\n"
Ingo Molnar8550eb92008-01-30 13:34:10 +0100636 " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700637#ifdef CONFIG_HIGHMEM
Ingo Molnar8550eb92008-01-30 13:34:10 +0100638 " pkmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700639#endif
Ingo Molnar8550eb92008-01-30 13:34:10 +0100640 " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
641 " lowmem : 0x%08lx - 0x%08lx (%4ld MB)\n"
642 " .init : 0x%08lx - 0x%08lx (%4ld kB)\n"
643 " .data : 0x%08lx - 0x%08lx (%4ld kB)\n"
644 " .text : 0x%08lx - 0x%08lx (%4ld kB)\n",
645 FIXADDR_START, FIXADDR_TOP,
646 (FIXADDR_TOP - FIXADDR_START) >> 10,
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700647
648#ifdef CONFIG_HIGHMEM
Ingo Molnar8550eb92008-01-30 13:34:10 +0100649 PKMAP_BASE, PKMAP_BASE+LAST_PKMAP*PAGE_SIZE,
650 (LAST_PKMAP*PAGE_SIZE) >> 10,
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700651#endif
652
Ingo Molnar8550eb92008-01-30 13:34:10 +0100653 VMALLOC_START, VMALLOC_END,
654 (VMALLOC_END - VMALLOC_START) >> 20,
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700655
Ingo Molnar8550eb92008-01-30 13:34:10 +0100656 (unsigned long)__va(0), (unsigned long)high_memory,
657 ((unsigned long)high_memory - (unsigned long)__va(0)) >> 20,
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700658
Ingo Molnar8550eb92008-01-30 13:34:10 +0100659 (unsigned long)&__init_begin, (unsigned long)&__init_end,
660 ((unsigned long)&__init_end -
661 (unsigned long)&__init_begin) >> 10,
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700662
Ingo Molnar8550eb92008-01-30 13:34:10 +0100663 (unsigned long)&_etext, (unsigned long)&_edata,
664 ((unsigned long)&_edata - (unsigned long)&_etext) >> 10,
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700665
Ingo Molnar8550eb92008-01-30 13:34:10 +0100666 (unsigned long)&_text, (unsigned long)&_etext,
667 ((unsigned long)&_etext - (unsigned long)&_text) >> 10);
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700668
669#ifdef CONFIG_HIGHMEM
Ingo Molnar8550eb92008-01-30 13:34:10 +0100670 BUG_ON(PKMAP_BASE + LAST_PKMAP*PAGE_SIZE > FIXADDR_START);
671 BUG_ON(VMALLOC_END > PKMAP_BASE);
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700672#endif
Ingo Molnar8550eb92008-01-30 13:34:10 +0100673 BUG_ON(VMALLOC_START > VMALLOC_END);
674 BUG_ON((unsigned long)high_memory > VMALLOC_START);
Jeremy Fitzhardinge052e7992006-09-25 23:32:25 -0700675#endif /* double-sanity-check paranoia */
676
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677#ifdef CONFIG_X86_PAE
678 if (!cpu_has_pae)
679 panic("cannot execute a PAE-enabled kernel on a PAE-less CPU!");
680#endif
681 if (boot_cpu_data.wp_works_ok < 0)
682 test_wp_bit();
683
684 /*
685 * Subtle. SMP is doing it's boot stuff late (because it has to
686 * fork idle threads) - but it also needs low mappings for the
687 * protected-mode entry to work. We zap these entries only after
688 * the WP-bit has been tested.
689 */
690#ifndef CONFIG_SMP
691 zap_low_mappings();
692#endif
693}
694
KAMEZAWA Hiroyukiad8f5792006-05-20 15:00:03 -0700695#ifdef CONFIG_MEMORY_HOTPLUG
Yasunori Gotobc02af92006-06-27 02:53:30 -0700696int arch_add_memory(int nid, u64 start, u64 size)
Dave Hansen05039b92005-10-29 18:16:57 -0700697{
Yasunori Goto7c7e9422006-12-22 01:11:13 -0800698 struct pglist_data *pgdata = NODE_DATA(nid);
Christoph Lameter776ed982006-09-25 23:31:09 -0700699 struct zone *zone = pgdata->node_zones + ZONE_HIGHMEM;
Dave Hansen05039b92005-10-29 18:16:57 -0700700 unsigned long start_pfn = start >> PAGE_SHIFT;
701 unsigned long nr_pages = size >> PAGE_SHIFT;
702
703 return __add_pages(zone, start_pfn, nr_pages);
704}
Andi Kleen9d99aaa2006-04-07 19:49:15 +0200705#endif
Dave Hansen05039b92005-10-29 18:16:57 -0700706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707/*
708 * This function cannot be __init, since exceptions don't work in that
709 * section. Put this after the callers, so that it cannot be inlined.
710 */
Ingo Molnar8550eb92008-01-30 13:34:10 +0100711static noinline int do_test_wp_bit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712{
713 char tmp_reg;
714 int flag;
715
716 __asm__ __volatile__(
Ingo Molnar8550eb92008-01-30 13:34:10 +0100717 " movb %0, %1 \n"
718 "1: movb %1, %0 \n"
719 " xorl %2, %2 \n"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 "2: \n"
Ingo Molnar8550eb92008-01-30 13:34:10 +0100721 ".section __ex_table, \"a\"\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 " .align 4 \n"
Ingo Molnar8550eb92008-01-30 13:34:10 +0100723 " .long 1b, 2b \n"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 ".previous \n"
725 :"=m" (*(char *)fix_to_virt(FIX_WP_TEST)),
726 "=q" (tmp_reg),
727 "=r" (flag)
728 :"2" (1)
729 :"memory");
Ingo Molnar8550eb92008-01-30 13:34:10 +0100730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 return flag;
732}
733
Arjan van de Ven63aaf302006-01-06 00:12:02 -0800734#ifdef CONFIG_DEBUG_RODATA
Arjan van de Venedeed302008-01-30 13:34:08 +0100735const int rodata_test_data = 0xC3;
736EXPORT_SYMBOL_GPL(rodata_test_data);
Arjan van de Ven63aaf302006-01-06 00:12:02 -0800737
Arjan van de Ven63aaf302006-01-06 00:12:02 -0800738void mark_rodata_ro(void)
739{
Jan Beulich6fb14752007-05-02 19:27:10 +0200740 unsigned long start = PFN_ALIGN(_text);
741 unsigned long size = PFN_ALIGN(_etext) - start;
Arjan van de Ven63aaf302006-01-06 00:12:02 -0800742
Linus Torvalds602033e2007-07-26 12:07:21 -0700743#ifndef CONFIG_KPROBES
744#ifdef CONFIG_HOTPLUG_CPU
745 /* It must still be possible to apply SMP alternatives. */
746 if (num_possible_cpus() <= 1)
747#endif
748 {
Arjan van de Ven6d238cc2008-01-30 13:34:06 +0100749 set_pages_ro(virt_to_page(start), size >> PAGE_SHIFT);
Ingo Molnard7d119d2008-01-30 13:34:10 +0100750 printk(KERN_INFO "Write protecting the kernel text: %luk\n",
751 size >> 10);
Andi Kleen0c42f392008-01-30 13:33:42 +0100752
753#ifdef CONFIG_CPA_DEBUG
Ingo Molnard7d119d2008-01-30 13:34:10 +0100754 printk(KERN_INFO "Testing CPA: Reverting %lx-%lx\n",
755 start, start+size);
Arjan van de Ven6d238cc2008-01-30 13:34:06 +0100756 set_pages_rw(virt_to_page(start), size>>PAGE_SHIFT);
Andi Kleen0c42f392008-01-30 13:33:42 +0100757
Ingo Molnard7d119d2008-01-30 13:34:10 +0100758 printk(KERN_INFO "Testing CPA: write protecting again\n");
Arjan van de Ven6d238cc2008-01-30 13:34:06 +0100759 set_pages_ro(virt_to_page(start), size>>PAGE_SHIFT);
Andi Kleen0c42f392008-01-30 13:33:42 +0100760#endif
Linus Torvalds602033e2007-07-26 12:07:21 -0700761 }
762#endif
Jan Beulich6fb14752007-05-02 19:27:10 +0200763 start += size;
764 size = (unsigned long)__end_rodata - start;
Arjan van de Ven6d238cc2008-01-30 13:34:06 +0100765 set_pages_ro(virt_to_page(start), size >> PAGE_SHIFT);
Ingo Molnard7d119d2008-01-30 13:34:10 +0100766 printk(KERN_INFO "Write protecting the kernel read-only data: %luk\n",
767 size >> 10);
Arjan van de Venedeed302008-01-30 13:34:08 +0100768 rodata_test();
Arjan van de Ven63aaf302006-01-06 00:12:02 -0800769
Andi Kleen0c42f392008-01-30 13:33:42 +0100770#ifdef CONFIG_CPA_DEBUG
Ingo Molnard7d119d2008-01-30 13:34:10 +0100771 printk(KERN_INFO "Testing CPA: undo %lx-%lx\n", start, start + size);
Arjan van de Ven6d238cc2008-01-30 13:34:06 +0100772 set_pages_rw(virt_to_page(start), size >> PAGE_SHIFT);
Andi Kleen0c42f392008-01-30 13:33:42 +0100773
Ingo Molnard7d119d2008-01-30 13:34:10 +0100774 printk(KERN_INFO "Testing CPA: write protecting again\n");
Arjan van de Ven6d238cc2008-01-30 13:34:06 +0100775 set_pages_ro(virt_to_page(start), size >> PAGE_SHIFT);
Andi Kleen0c42f392008-01-30 13:33:42 +0100776#endif
Arjan van de Ven63aaf302006-01-06 00:12:02 -0800777}
778#endif
779
Gerd Hoffmann9a0b5812006-03-23 02:59:32 -0800780void free_init_pages(char *what, unsigned long begin, unsigned long end)
781{
Ingo Molnaree01f112008-01-30 13:34:09 +0100782#ifdef CONFIG_DEBUG_PAGEALLOC
783 /*
784 * If debugging page accesses then do not free this memory but
785 * mark them not present - any buggy init-section access will
786 * create a kernel page fault:
787 */
788 printk(KERN_INFO "debug: unmapping init memory %08lx..%08lx\n",
789 begin, PAGE_ALIGN(end));
790 set_memory_np(begin, (end - begin) >> PAGE_SHIFT);
791#else
Ingo Molnar86f03982008-01-30 13:34:09 +0100792 unsigned long addr;
793
Arjan van de Ven3c1df682008-01-30 13:34:07 +0100794 /*
795 * We just marked the kernel text read only above, now that
796 * we are going to free part of that, we need to make that
797 * writeable first.
798 */
799 set_memory_rw(begin, (end - begin) >> PAGE_SHIFT);
800
Gerd Hoffmann9a0b5812006-03-23 02:59:32 -0800801 for (addr = begin; addr < end; addr += PAGE_SIZE) {
Linus Torvaldse3ebadd2007-05-07 08:44:24 -0700802 ClearPageReserved(virt_to_page(addr));
803 init_page_count(virt_to_page(addr));
804 memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE);
805 free_page(addr);
Gerd Hoffmann9a0b5812006-03-23 02:59:32 -0800806 totalram_pages++;
807 }
Jan Beulich6fb14752007-05-02 19:27:10 +0200808 printk(KERN_INFO "Freeing %s: %luk freed\n", what, (end - begin) >> 10);
Ingo Molnaree01f112008-01-30 13:34:09 +0100809#endif
Gerd Hoffmann9a0b5812006-03-23 02:59:32 -0800810}
811
812void free_initmem(void)
813{
814 free_init_pages("unused kernel memory",
Linus Torvaldse3ebadd2007-05-07 08:44:24 -0700815 (unsigned long)(&__init_begin),
816 (unsigned long)(&__init_end));
Gerd Hoffmann9a0b5812006-03-23 02:59:32 -0800817}
Arjan van de Ven63aaf302006-01-06 00:12:02 -0800818
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819#ifdef CONFIG_BLK_DEV_INITRD
820void free_initrd_mem(unsigned long start, unsigned long end)
821{
Linus Torvaldse3ebadd2007-05-07 08:44:24 -0700822 free_init_pages("initrd memory", start, end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823}
824#endif