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"
20 #include "uml_uaccess.h"
23 extern char __binary_start
;
25 /* Changed during early boot */
26 unsigned long *empty_zero_page
= NULL
;
27 unsigned long *empty_bad_page
= NULL
;
28 pgd_t swapper_pg_dir
[PTRS_PER_PGD
];
29 unsigned long highmem
;
32 static unsigned long brk_end
;
34 void unmap_physmem(void)
36 os_unmap_memory((void *) brk_end
, uml_reserved
- brk_end
);
39 static void map_cb(void *unused
)
41 map_memory(brk_end
, __pa(brk_end
), uml_reserved
- brk_end
, 1, 1, 0);
45 static void setup_highmem(unsigned long highmem_start
,
46 unsigned long highmem_len
)
49 unsigned long highmem_pfn
;
52 highmem_pfn
= __pa(highmem_start
) >> PAGE_SHIFT
;
53 for(i
= 0; i
< highmem_len
>> PAGE_SHIFT
; i
++){
54 page
= &mem_map
[highmem_pfn
+ i
];
55 ClearPageReserved(page
);
56 set_bit(PG_highmem
, &page
->flags
);
57 set_page_count(page
, 1);
67 max_low_pfn
= (high_physmem
- uml_physmem
) >> PAGE_SHIFT
;
69 /* clear the zero-page */
70 memset((void *) empty_zero_page
, 0, PAGE_SIZE
);
72 /* Map in the area just after the brk now that kmalloc is about
75 brk_end
= (unsigned long) UML_ROUND_UP(sbrk(0));
77 initial_thread_cb(map_cb
, NULL
);
78 free_bootmem(__pa(brk_end
), uml_reserved
- brk_end
);
79 uml_reserved
= brk_end
;
81 /* Fill in any hole at the start of the binary */
82 start
= (unsigned long) &__binary_start
& PAGE_MASK
;
83 if(uml_physmem
!= start
){
84 map_memory(uml_physmem
, __pa(uml_physmem
), start
- uml_physmem
,
88 /* this will put all low memory onto the freelists */
89 totalram_pages
= free_all_bootmem();
90 totalhigh_pages
= highmem
>> PAGE_SHIFT
;
91 totalram_pages
+= totalhigh_pages
;
92 num_physpages
= totalram_pages
;
93 max_pfn
= totalram_pages
;
94 printk(KERN_INFO
"Memory: %luk available\n",
95 (unsigned long) nr_free_pages() << (PAGE_SHIFT
-10));
99 setup_highmem(end_iomem
, highmem
);
104 * Create a page table and place a pointer to it in a middle page
107 static void __init
one_page_table_init(pmd_t
*pmd
)
109 if (pmd_none(*pmd
)) {
110 pte_t
*pte
= (pte_t
*) alloc_bootmem_low_pages(PAGE_SIZE
);
111 set_pmd(pmd
, __pmd(_KERNPG_TABLE
+
112 (unsigned long) __pa(pte
)));
113 if (pte
!= pte_offset_kernel(pmd
, 0))
118 static void __init
one_md_table_init(pud_t
*pud
)
120 #ifdef CONFIG_3_LEVEL_PGTABLES
121 pmd_t
*pmd_table
= (pmd_t
*) alloc_bootmem_low_pages(PAGE_SIZE
);
122 set_pud(pud
, __pud(_KERNPG_TABLE
+ (unsigned long) __pa(pmd_table
)));
123 if (pmd_table
!= pmd_offset(pud
, 0))
128 static void __init
fixrange_init(unsigned long start
, unsigned long end
,
138 i
= pgd_index(vaddr
);
139 j
= pmd_index(vaddr
);
142 for ( ; (i
< PTRS_PER_PGD
) && (vaddr
< end
); pgd
++, i
++) {
143 pud
= pud_offset(pgd
, vaddr
);
145 one_md_table_init(pud
);
146 pmd
= pmd_offset(pud
, vaddr
);
147 for (; (j
< PTRS_PER_PMD
) && (vaddr
!= end
); pmd
++, j
++) {
148 one_page_table_init(pmd
);
155 #ifdef CONFIG_HIGHMEM
159 #define kmap_get_fixmap_pte(vaddr) \
160 pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
163 static void __init
kmap_init(void)
165 unsigned long kmap_vstart
;
167 /* cache the first kmap pte */
168 kmap_vstart
= __fix_to_virt(FIX_KMAP_BEGIN
);
169 kmap_pte
= kmap_get_fixmap_pte(kmap_vstart
);
171 kmap_prot
= PAGE_KERNEL
;
174 static void init_highmem(void)
186 fixrange_init(vaddr
, vaddr
+ PAGE_SIZE
*LAST_PKMAP
, swapper_pg_dir
);
188 pgd
= swapper_pg_dir
+ pgd_index(vaddr
);
189 pud
= pud_offset(pgd
, vaddr
);
190 pmd
= pmd_offset(pud
, vaddr
);
191 pte
= pte_offset_kernel(pmd
, vaddr
);
192 pkmap_page_table
= pte
;
196 #endif /* CONFIG_HIGHMEM */
198 static void __init
fixaddr_user_init( void)
200 #if CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
201 long size
= FIXADDR_USER_END
- FIXADDR_USER_START
;
206 unsigned long paddr
, vaddr
= FIXADDR_USER_START
;
211 fixrange_init( FIXADDR_USER_START
, FIXADDR_USER_END
, swapper_pg_dir
);
212 paddr
= (unsigned long)alloc_bootmem_low_pages( size
);
213 memcpy( (void *)paddr
, (void *)FIXADDR_USER_START
, size
);
215 for ( ; size
> 0; size
-=PAGE_SIZE
, vaddr
+=PAGE_SIZE
, paddr
+=PAGE_SIZE
){
216 pgd
= swapper_pg_dir
+ pgd_index(vaddr
);
217 pud
= pud_offset(pgd
, vaddr
);
218 pmd
= pmd_offset(pud
, vaddr
);
219 pte
= pte_offset_kernel(pmd
, vaddr
);
220 pte_set_val( (*pte
), paddr
, PAGE_READONLY
);
225 void paging_init(void)
227 unsigned long zones_size
[MAX_NR_ZONES
], vaddr
;
230 empty_zero_page
= (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE
);
231 empty_bad_page
= (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE
);
232 for(i
=0;i
<sizeof(zones_size
)/sizeof(zones_size
[0]);i
++)
234 zones_size
[0] = (end_iomem
>> PAGE_SHIFT
) - (uml_physmem
>> PAGE_SHIFT
);
235 zones_size
[2] = highmem
>> PAGE_SHIFT
;
236 free_area_init(zones_size
);
239 * Fixed mappings, only the page table structure has to be
240 * created - mappings will be set by set_fixmap():
242 vaddr
= __fix_to_virt(__end_of_fixed_addresses
- 1) & PMD_MASK
;
243 fixrange_init(vaddr
, FIXADDR_TOP
, swapper_pg_dir
);
247 #ifdef CONFIG_HIGHMEM
252 struct page
*arch_validate(struct page
*page
, int mask
, int order
)
254 unsigned long addr
, zero
= 0;
258 if(page
== NULL
) return(page
);
259 if(PageHighMem(page
)) return(page
);
261 addr
= (unsigned long) page_address(page
);
262 for(i
= 0; i
< (1 << order
); i
++){
263 current
->thread
.fault_addr
= (void *) addr
;
264 if(__do_copy_to_user((void __user
*) addr
, &zero
,
266 ¤t
->thread
.fault_addr
,
267 ¤t
->thread
.fault_catcher
)){
268 if(!(mask
& __GFP_WAIT
)) return(NULL
);
274 if(i
== (1 << order
)) return(page
);
275 page
= alloc_pages(mask
, order
);
279 /* This can't do anything because nothing in the kernel image can be freed
280 * since it's not in kernel physical memory.
283 void free_initmem(void)
287 #ifdef CONFIG_BLK_DEV_INITRD
289 void free_initrd_mem(unsigned long start
, unsigned long end
)
292 printk ("Freeing initrd memory: %ldk freed\n",
293 (end
- start
) >> 10);
294 for (; start
< end
; start
+= PAGE_SIZE
) {
295 ClearPageReserved(virt_to_page(start
));
296 set_page_count(virt_to_page(start
), 1);
306 int pfn
, total
= 0, reserved
= 0;
307 int shared
= 0, cached
= 0;
311 printk("Mem-info:\n");
313 printk("Free swap: %6ldkB\n", nr_swap_pages
<<(PAGE_SHIFT
-10));
316 page
= pfn_to_page(pfn
);
318 if(PageHighMem(page
))
320 if(PageReserved(page
))
322 else if(PageSwapCache(page
))
324 else if(page_count(page
))
325 shared
+= page_count(page
) - 1;
327 printk("%d pages of RAM\n", total
);
328 printk("%d pages of HIGHMEM\n", highmem
);
329 printk("%d reserved pages\n", reserved
);
330 printk("%d pages shared\n", shared
);
331 printk("%d pages swap cached\n", cached
);
335 * Allocate and free page tables.
338 pgd_t
*pgd_alloc(struct mm_struct
*mm
)
340 pgd_t
*pgd
= (pgd_t
*)__get_free_page(GFP_KERNEL
);
343 memset(pgd
, 0, USER_PTRS_PER_PGD
* sizeof(pgd_t
));
344 memcpy(pgd
+ USER_PTRS_PER_PGD
,
345 swapper_pg_dir
+ USER_PTRS_PER_PGD
,
346 (PTRS_PER_PGD
- USER_PTRS_PER_PGD
) * sizeof(pgd_t
));
351 void pgd_free(pgd_t
*pgd
)
353 free_page((unsigned long) pgd
);
356 pte_t
*pte_alloc_one_kernel(struct mm_struct
*mm
, unsigned long address
)
360 pte
= (pte_t
*)__get_free_page(GFP_KERNEL
|__GFP_REPEAT
|__GFP_ZERO
);
364 struct page
*pte_alloc_one(struct mm_struct
*mm
, unsigned long address
)
368 pte
= alloc_page(GFP_KERNEL
|__GFP_REPEAT
|__GFP_ZERO
);
373 * Overrides for Emacs so that we follow Linus's tabbing style.
374 * Emacs will notice this stuff at the end of the file and automatically
375 * adjust the settings for this buffer only. This must remain at the end
377 * ---------------------------------------------------------------------------
379 * c-file-style: "linux"