2 * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
3 * Licensed under the GPL
6 #include "linux/stddef.h"
7 #include "linux/kernel.h"
9 #include "linux/bootmem.h"
10 #include "linux/swap.h"
11 #include "linux/highmem.h"
12 #include "linux/gfp.h"
14 #include "asm/fixmap.h"
15 #include "asm/pgalloc.h"
16 #include "user_util.h"
17 #include "kern_util.h"
18 #include "as-layout.h"
21 #include "uml_uaccess.h"
23 #include "linux/types.h"
24 #include "linux/string.h"
26 #include "kern_constants.h"
28 /* allocated in paging_init, zeroed in mem_init, and unchanged thereafter */
29 unsigned long *empty_zero_page
= NULL
;
30 /* allocated in paging_init and unchanged thereafter */
31 unsigned long *empty_bad_page
= NULL
;
32 pgd_t swapper_pg_dir
[PTRS_PER_PGD
];
33 unsigned long long highmem
;
36 static unsigned long brk_end
;
38 void unmap_physmem(void)
40 os_unmap_memory((void *) brk_end
, uml_reserved
- brk_end
);
43 static void map_cb(void *unused
)
45 map_memory(brk_end
, __pa(brk_end
), uml_reserved
- brk_end
, 1, 1, 0);
49 static void setup_highmem(unsigned long highmem_start
,
50 unsigned long highmem_len
)
53 unsigned long highmem_pfn
;
56 highmem_pfn
= __pa(highmem_start
) >> PAGE_SHIFT
;
57 for(i
= 0; i
< highmem_len
>> PAGE_SHIFT
; i
++){
58 page
= &mem_map
[highmem_pfn
+ i
];
59 ClearPageReserved(page
);
60 init_page_count(page
);
68 /* clear the zero-page */
69 memset((void *) empty_zero_page
, 0, PAGE_SIZE
);
71 /* Map in the area just after the brk now that kmalloc is about
74 brk_end
= (unsigned long) UML_ROUND_UP(sbrk(0));
76 initial_thread_cb(map_cb
, NULL
);
77 free_bootmem(__pa(brk_end
), uml_reserved
- brk_end
);
78 uml_reserved
= brk_end
;
80 /* this will put all low memory onto the freelists */
81 totalram_pages
= free_all_bootmem();
82 max_low_pfn
= totalram_pages
;
84 totalhigh_pages
= highmem
>> PAGE_SHIFT
;
85 totalram_pages
+= totalhigh_pages
;
87 num_physpages
= totalram_pages
;
88 max_pfn
= totalram_pages
;
89 printk(KERN_INFO
"Memory: %luk available\n",
90 (unsigned long) nr_free_pages() << (PAGE_SHIFT
-10));
94 setup_highmem(end_iomem
, highmem
);
99 * Create a page table and place a pointer to it in a middle page
102 static void __init
one_page_table_init(pmd_t
*pmd
)
104 if (pmd_none(*pmd
)) {
105 pte_t
*pte
= (pte_t
*) alloc_bootmem_low_pages(PAGE_SIZE
);
106 set_pmd(pmd
, __pmd(_KERNPG_TABLE
+
107 (unsigned long) __pa(pte
)));
108 if (pte
!= pte_offset_kernel(pmd
, 0))
113 static void __init
one_md_table_init(pud_t
*pud
)
115 #ifdef CONFIG_3_LEVEL_PGTABLES
116 pmd_t
*pmd_table
= (pmd_t
*) alloc_bootmem_low_pages(PAGE_SIZE
);
117 set_pud(pud
, __pud(_KERNPG_TABLE
+ (unsigned long) __pa(pmd_table
)));
118 if (pmd_table
!= pmd_offset(pud
, 0))
123 static void __init
fixrange_init(unsigned long start
, unsigned long end
,
133 i
= pgd_index(vaddr
);
134 j
= pmd_index(vaddr
);
137 for ( ; (i
< PTRS_PER_PGD
) && (vaddr
< end
); pgd
++, i
++) {
138 pud
= pud_offset(pgd
, vaddr
);
140 one_md_table_init(pud
);
141 pmd
= pmd_offset(pud
, vaddr
);
142 for (; (j
< PTRS_PER_PMD
) && (vaddr
!= end
); pmd
++, j
++) {
143 one_page_table_init(pmd
);
150 #ifdef CONFIG_HIGHMEM
154 #define kmap_get_fixmap_pte(vaddr) \
155 pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
158 static void __init
kmap_init(void)
160 unsigned long kmap_vstart
;
162 /* cache the first kmap pte */
163 kmap_vstart
= __fix_to_virt(FIX_KMAP_BEGIN
);
164 kmap_pte
= kmap_get_fixmap_pte(kmap_vstart
);
166 kmap_prot
= PAGE_KERNEL
;
169 static void init_highmem(void)
181 fixrange_init(vaddr
, vaddr
+ PAGE_SIZE
*LAST_PKMAP
, swapper_pg_dir
);
183 pgd
= swapper_pg_dir
+ pgd_index(vaddr
);
184 pud
= pud_offset(pgd
, vaddr
);
185 pmd
= pmd_offset(pud
, vaddr
);
186 pte
= pte_offset_kernel(pmd
, vaddr
);
187 pkmap_page_table
= pte
;
191 #endif /* CONFIG_HIGHMEM */
193 static void __init
fixaddr_user_init( void)
195 #ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
196 long size
= FIXADDR_USER_END
- FIXADDR_USER_START
;
201 unsigned long paddr
, vaddr
= FIXADDR_USER_START
;
206 fixrange_init( FIXADDR_USER_START
, FIXADDR_USER_END
, swapper_pg_dir
);
207 paddr
= (unsigned long)alloc_bootmem_low_pages( size
);
208 memcpy( (void *)paddr
, (void *)FIXADDR_USER_START
, size
);
210 for ( ; size
> 0; size
-=PAGE_SIZE
, vaddr
+=PAGE_SIZE
, paddr
+=PAGE_SIZE
){
211 pgd
= swapper_pg_dir
+ pgd_index(vaddr
);
212 pud
= pud_offset(pgd
, vaddr
);
213 pmd
= pmd_offset(pud
, vaddr
);
214 pte
= pte_offset_kernel(pmd
, vaddr
);
215 pte_set_val( (*pte
), paddr
, PAGE_READONLY
);
220 void paging_init(void)
222 unsigned long zones_size
[MAX_NR_ZONES
], vaddr
;
225 empty_zero_page
= (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE
);
226 empty_bad_page
= (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE
);
227 for(i
= 0; i
< ARRAY_SIZE(zones_size
); i
++)
230 zones_size
[ZONE_NORMAL
] = (end_iomem
>> PAGE_SHIFT
) -
231 (uml_physmem
>> PAGE_SHIFT
);
232 #ifdef CONFIG_HIGHMEM
233 zones_size
[ZONE_HIGHMEM
] = highmem
>> PAGE_SHIFT
;
235 free_area_init(zones_size
);
238 * Fixed mappings, only the page table structure has to be
239 * created - mappings will be set by set_fixmap():
241 vaddr
= __fix_to_virt(__end_of_fixed_addresses
- 1) & PMD_MASK
;
242 fixrange_init(vaddr
, FIXADDR_TOP
, swapper_pg_dir
);
246 #ifdef CONFIG_HIGHMEM
251 struct page
*arch_validate(struct page
*page
, gfp_t mask
, int order
)
253 unsigned long addr
, zero
= 0;
259 if(PageHighMem(page
))
262 addr
= (unsigned long) page_address(page
);
263 for(i
= 0; i
< (1 << order
); i
++){
264 current
->thread
.fault_addr
= (void *) addr
;
265 if(__do_copy_to_user((void __user
*) addr
, &zero
,
267 ¤t
->thread
.fault_addr
,
268 ¤t
->thread
.fault_catcher
)){
269 if(!(mask
& __GFP_WAIT
))
276 if(i
== (1 << order
))
278 page
= alloc_pages(mask
, order
);
282 /* This can't do anything because nothing in the kernel image can be freed
283 * since it's not in kernel physical memory.
286 void free_initmem(void)
290 #ifdef CONFIG_BLK_DEV_INITRD
291 void free_initrd_mem(unsigned long start
, unsigned long end
)
294 printk ("Freeing initrd memory: %ldk freed\n",
295 (end
- start
) >> 10);
296 for (; start
< end
; start
+= PAGE_SIZE
) {
297 ClearPageReserved(virt_to_page(start
));
298 init_page_count(virt_to_page(start
));
307 int pfn
, total
= 0, reserved
= 0;
308 int shared
= 0, cached
= 0;
312 printk("Mem-info:\n");
314 printk("Free swap: %6ldkB\n", nr_swap_pages
<<(PAGE_SHIFT
-10));
317 page
= pfn_to_page(pfn
);
319 if(PageHighMem(page
))
321 if(PageReserved(page
))
323 else if(PageSwapCache(page
))
325 else if(page_count(page
))
326 shared
+= page_count(page
) - 1;
328 printk("%d pages of RAM\n", total
);
329 printk("%d pages of HIGHMEM\n", highmem
);
330 printk("%d reserved pages\n", reserved
);
331 printk("%d pages shared\n", shared
);
332 printk("%d pages swap cached\n", cached
);
336 * Allocate and free page tables.
339 pgd_t
*pgd_alloc(struct mm_struct
*mm
)
341 pgd_t
*pgd
= (pgd_t
*)__get_free_page(GFP_KERNEL
);
344 memset(pgd
, 0, USER_PTRS_PER_PGD
* sizeof(pgd_t
));
345 memcpy(pgd
+ USER_PTRS_PER_PGD
,
346 swapper_pg_dir
+ USER_PTRS_PER_PGD
,
347 (PTRS_PER_PGD
- USER_PTRS_PER_PGD
) * sizeof(pgd_t
));
352 void pgd_free(pgd_t
*pgd
)
354 free_page((unsigned long) pgd
);
357 pte_t
*pte_alloc_one_kernel(struct mm_struct
*mm
, unsigned long address
)
361 pte
= (pte_t
*)__get_free_page(GFP_KERNEL
|__GFP_REPEAT
|__GFP_ZERO
);
365 struct page
*pte_alloc_one(struct mm_struct
*mm
, unsigned long address
)
369 pte
= alloc_page(GFP_KERNEL
|__GFP_REPEAT
|__GFP_ZERO
);