2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3 * Licensed under the GPL
6 #include <linux/stddef.h>
7 #include <linux/bootmem.h>
9 #include <linux/highmem.h>
11 #include <linux/swap.h>
12 #include <asm/fixmap.h>
14 #include "as-layout.h"
17 #include "kern_util.h"
21 /* allocated in paging_init, zeroed in mem_init, and unchanged thereafter */
22 unsigned long *empty_zero_page
= NULL
;
23 /* allocated in paging_init and unchanged thereafter */
24 unsigned long *empty_bad_page
= NULL
;
25 pgd_t swapper_pg_dir
[PTRS_PER_PGD
];
26 unsigned long long highmem
;
29 static unsigned long brk_end
;
31 void unmap_physmem(void)
33 os_unmap_memory((void *) brk_end
, uml_reserved
- brk_end
);
36 static void map_cb(void *unused
)
38 map_memory(brk_end
, __pa(brk_end
), uml_reserved
- brk_end
, 1, 1, 0);
42 static void setup_highmem(unsigned long highmem_start
,
43 unsigned long highmem_len
)
46 unsigned long highmem_pfn
;
49 highmem_pfn
= __pa(highmem_start
) >> PAGE_SHIFT
;
50 for (i
= 0; i
< highmem_len
>> PAGE_SHIFT
; i
++) {
51 page
= &mem_map
[highmem_pfn
+ i
];
52 ClearPageReserved(page
);
53 init_page_count(page
);
59 void __init
mem_init(void)
61 /* clear the zero-page */
62 memset(empty_zero_page
, 0, PAGE_SIZE
);
64 /* Map in the area just after the brk now that kmalloc is about
67 brk_end
= (unsigned long) UML_ROUND_UP(sbrk(0));
69 initial_thread_cb(map_cb
, NULL
);
70 free_bootmem(__pa(brk_end
), uml_reserved
- brk_end
);
71 uml_reserved
= brk_end
;
73 /* this will put all low memory onto the freelists */
74 totalram_pages
= free_all_bootmem();
75 max_low_pfn
= totalram_pages
;
77 totalhigh_pages
= highmem
>> PAGE_SHIFT
;
78 totalram_pages
+= totalhigh_pages
;
80 num_physpages
= totalram_pages
;
81 max_pfn
= totalram_pages
;
82 printk(KERN_INFO
"Memory: %luk available\n",
83 (unsigned long) nr_free_pages() << (PAGE_SHIFT
-10));
87 setup_highmem(end_iomem
, highmem
);
92 * Create a page table and place a pointer to it in a middle page
95 static void __init
one_page_table_init(pmd_t
*pmd
)
98 pte_t
*pte
= (pte_t
*) alloc_bootmem_low_pages(PAGE_SIZE
);
99 set_pmd(pmd
, __pmd(_KERNPG_TABLE
+
100 (unsigned long) __pa(pte
)));
101 if (pte
!= pte_offset_kernel(pmd
, 0))
106 static void __init
one_md_table_init(pud_t
*pud
)
108 #ifdef CONFIG_3_LEVEL_PGTABLES
109 pmd_t
*pmd_table
= (pmd_t
*) alloc_bootmem_low_pages(PAGE_SIZE
);
110 set_pud(pud
, __pud(_KERNPG_TABLE
+ (unsigned long) __pa(pmd_table
)));
111 if (pmd_table
!= pmd_offset(pud
, 0))
116 static void __init
fixrange_init(unsigned long start
, unsigned long end
,
126 i
= pgd_index(vaddr
);
127 j
= pmd_index(vaddr
);
130 for ( ; (i
< PTRS_PER_PGD
) && (vaddr
< end
); pgd
++, i
++) {
131 pud
= pud_offset(pgd
, vaddr
);
133 one_md_table_init(pud
);
134 pmd
= pmd_offset(pud
, vaddr
);
135 for (; (j
< PTRS_PER_PMD
) && (vaddr
!= end
); pmd
++, j
++) {
136 one_page_table_init(pmd
);
143 #ifdef CONFIG_HIGHMEM
147 #define kmap_get_fixmap_pte(vaddr) \
148 pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
151 static void __init
kmap_init(void)
153 unsigned long kmap_vstart
;
155 /* cache the first kmap pte */
156 kmap_vstart
= __fix_to_virt(FIX_KMAP_BEGIN
);
157 kmap_pte
= kmap_get_fixmap_pte(kmap_vstart
);
159 kmap_prot
= PAGE_KERNEL
;
162 static void __init
init_highmem(void)
174 fixrange_init(vaddr
, vaddr
+ PAGE_SIZE
*LAST_PKMAP
, swapper_pg_dir
);
176 pgd
= swapper_pg_dir
+ pgd_index(vaddr
);
177 pud
= pud_offset(pgd
, vaddr
);
178 pmd
= pmd_offset(pud
, vaddr
);
179 pte
= pte_offset_kernel(pmd
, vaddr
);
180 pkmap_page_table
= pte
;
184 #endif /* CONFIG_HIGHMEM */
186 static void __init
fixaddr_user_init( void)
188 #ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
189 long size
= FIXADDR_USER_END
- FIXADDR_USER_START
;
194 unsigned long paddr
, vaddr
= FIXADDR_USER_START
;
199 fixrange_init( FIXADDR_USER_START
, FIXADDR_USER_END
, swapper_pg_dir
);
200 paddr
= (unsigned long)alloc_bootmem_low_pages( size
);
201 memcpy( (void *)paddr
, (void *)FIXADDR_USER_START
, size
);
203 for ( ; size
> 0; size
-= PAGE_SIZE
, vaddr
+= PAGE_SIZE
,
204 paddr
+= PAGE_SIZE
) {
205 pgd
= swapper_pg_dir
+ pgd_index(vaddr
);
206 pud
= pud_offset(pgd
, vaddr
);
207 pmd
= pmd_offset(pud
, vaddr
);
208 pte
= pte_offset_kernel(pmd
, vaddr
);
209 pte_set_val( (*pte
), paddr
, PAGE_READONLY
);
214 void __init
paging_init(void)
216 unsigned long zones_size
[MAX_NR_ZONES
], vaddr
;
219 empty_zero_page
= (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE
);
220 empty_bad_page
= (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE
);
221 for (i
= 0; i
< ARRAY_SIZE(zones_size
); i
++)
224 zones_size
[ZONE_NORMAL
] = (end_iomem
>> PAGE_SHIFT
) -
225 (uml_physmem
>> PAGE_SHIFT
);
226 #ifdef CONFIG_HIGHMEM
227 zones_size
[ZONE_HIGHMEM
] = highmem
>> PAGE_SHIFT
;
229 free_area_init(zones_size
);
232 * Fixed mappings, only the page table structure has to be
233 * created - mappings will be set by set_fixmap():
235 vaddr
= __fix_to_virt(__end_of_fixed_addresses
- 1) & PMD_MASK
;
236 fixrange_init(vaddr
, FIXADDR_TOP
, swapper_pg_dir
);
240 #ifdef CONFIG_HIGHMEM
245 struct page
*arch_validate(struct page
*page
, gfp_t mask
, int order
)
247 unsigned long addr
, zero
= 0;
253 if (PageHighMem(page
))
256 addr
= (unsigned long) page_address(page
);
257 for (i
= 0; i
< (1 << order
); i
++) {
258 current
->thread
.fault_addr
= (void *) addr
;
259 if (__do_copy_to_user((void __user
*) addr
, &zero
,
261 ¤t
->thread
.fault_addr
,
262 ¤t
->thread
.fault_catcher
)) {
263 if (!(mask
& __GFP_WAIT
))
270 if (i
== (1 << order
))
272 page
= alloc_pages(mask
, order
);
277 * This can't do anything because nothing in the kernel image can be freed
278 * since it's not in kernel physical memory.
281 void free_initmem(void)
285 #ifdef CONFIG_BLK_DEV_INITRD
286 void free_initrd_mem(unsigned long start
, unsigned long end
)
289 printk(KERN_INFO
"Freeing initrd memory: %ldk freed\n",
290 (end
- start
) >> 10);
291 for (; start
< end
; start
+= PAGE_SIZE
) {
292 ClearPageReserved(virt_to_page(start
));
293 init_page_count(virt_to_page(start
));
302 int pfn
, total
= 0, reserved
= 0;
303 int shared
= 0, cached
= 0;
307 printk(KERN_INFO
"Mem-info:\n");
309 printk(KERN_INFO
"Free swap: %6ldkB\n",
310 nr_swap_pages
<<(PAGE_SHIFT
-10));
313 page
= pfn_to_page(pfn
);
315 if (PageHighMem(page
))
317 if (PageReserved(page
))
319 else if (PageSwapCache(page
))
321 else if (page_count(page
))
322 shared
+= page_count(page
) - 1;
324 printk(KERN_INFO
"%d pages of RAM\n", total
);
325 printk(KERN_INFO
"%d pages of HIGHMEM\n", highmem
);
326 printk(KERN_INFO
"%d reserved pages\n", reserved
);
327 printk(KERN_INFO
"%d pages shared\n", shared
);
328 printk(KERN_INFO
"%d pages swap cached\n", cached
);
331 /* Allocate and free page tables. */
333 pgd_t
*pgd_alloc(struct mm_struct
*mm
)
335 pgd_t
*pgd
= (pgd_t
*)__get_free_page(GFP_KERNEL
);
338 memset(pgd
, 0, USER_PTRS_PER_PGD
* sizeof(pgd_t
));
339 memcpy(pgd
+ USER_PTRS_PER_PGD
,
340 swapper_pg_dir
+ USER_PTRS_PER_PGD
,
341 (PTRS_PER_PGD
- USER_PTRS_PER_PGD
) * sizeof(pgd_t
));
346 void pgd_free(struct mm_struct
*mm
, pgd_t
*pgd
)
348 free_page((unsigned long) pgd
);
351 pte_t
*pte_alloc_one_kernel(struct mm_struct
*mm
, unsigned long address
)
355 pte
= (pte_t
*)__get_free_page(GFP_KERNEL
|__GFP_REPEAT
|__GFP_ZERO
);
359 struct page
*pte_alloc_one(struct mm_struct
*mm
, unsigned long address
)
363 pte
= alloc_page(GFP_KERNEL
|__GFP_REPEAT
|__GFP_ZERO
);
367 #ifdef CONFIG_3_LEVEL_PGTABLES
368 pmd_t
*pmd_alloc_one(struct mm_struct
*mm
, unsigned long address
)
370 pmd_t
*pmd
= (pmd_t
*) __get_free_page(GFP_KERNEL
);
373 memset(pmd
, 0, PAGE_SIZE
);