e85d65deea0db9c46f16085c8f168e56e4a475c5
[linux-2.6.git] / arch / um / kernel / mem.c
1 /*
2  * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
3  * Licensed under the GPL
4  */
5
6 #include "linux/stddef.h"
7 #include "linux/kernel.h"
8 #include "linux/mm.h"
9 #include "linux/bootmem.h"
10 #include "linux/swap.h"
11 #include "linux/highmem.h"
12 #include "linux/gfp.h"
13 #include "asm/page.h"
14 #include "asm/fixmap.h"
15 #include "asm/pgalloc.h"
16 #include "user_util.h"
17 #include "kern_util.h"
18 #include "kern.h"
19 #include "mem_user.h"
20 #include "uml_uaccess.h"
21 #include "os.h"
22 #include "linux/types.h"
23 #include "linux/string.h"
24 #include "init.h"
25 #include "kern_constants.h"
26
27 /* allocated in paging_init, zeroed in mem_init, and unchanged thereafter */
28 unsigned long *empty_zero_page = NULL;
29 /* allocated in paging_init and unchanged thereafter */
30 unsigned long *empty_bad_page = NULL;
31 pgd_t swapper_pg_dir[PTRS_PER_PGD];
32 unsigned long long highmem;
33 int kmalloc_ok = 0;
34
35 static unsigned long brk_end;
36
37 void unmap_physmem(void)
38 {
39         os_unmap_memory((void *) brk_end, uml_reserved - brk_end);
40 }
41
42 static void map_cb(void *unused)
43 {
44         map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
45 }
46
47 #ifdef CONFIG_HIGHMEM
48 static void setup_highmem(unsigned long highmem_start,
49                           unsigned long highmem_len)
50 {
51         struct page *page;
52         unsigned long highmem_pfn;
53         int i;
54
55         highmem_pfn = __pa(highmem_start) >> PAGE_SHIFT;
56         for(i = 0; i < highmem_len >> PAGE_SHIFT; i++){
57                 page = &mem_map[highmem_pfn + i];
58                 ClearPageReserved(page);
59                 init_page_count(page);
60                 __free_page(page);
61         }
62 }
63 #endif
64
65 void mem_init(void)
66 {
67         max_low_pfn = (high_physmem - uml_physmem) >> PAGE_SHIFT;
68
69         /* clear the zero-page */
70         memset((void *) empty_zero_page, 0, PAGE_SIZE);
71
72         /* Map in the area just after the brk now that kmalloc is about
73          * to be turned on.
74          */
75         brk_end = (unsigned long) UML_ROUND_UP(sbrk(0));
76         map_cb(NULL);
77         initial_thread_cb(map_cb, NULL);
78         free_bootmem(__pa(brk_end), uml_reserved - brk_end);
79         uml_reserved = brk_end;
80
81         /* this will put all low memory onto the freelists */
82         totalram_pages = free_all_bootmem();
83 #ifdef CONFIG_HIGHMEM
84         totalhigh_pages = highmem >> PAGE_SHIFT;
85         totalram_pages += totalhigh_pages;
86 #endif
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));
91         kmalloc_ok = 1;
92
93 #ifdef CONFIG_HIGHMEM
94         setup_highmem(end_iomem, highmem);
95 #endif
96 }
97
98 /*
99  * Create a page table and place a pointer to it in a middle page
100  * directory entry.
101  */
102 static void __init one_page_table_init(pmd_t *pmd)
103 {
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))
109                         BUG();
110         }
111 }
112
113 static void __init one_md_table_init(pud_t *pud)
114 {
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))
119                 BUG();
120 #endif
121 }
122
123 static void __init fixrange_init(unsigned long start, unsigned long end, 
124                                  pgd_t *pgd_base)
125 {
126         pgd_t *pgd;
127         pud_t *pud;
128         pmd_t *pmd;
129         int i, j;
130         unsigned long vaddr;
131
132         vaddr = start;
133         i = pgd_index(vaddr);
134         j = pmd_index(vaddr);
135         pgd = pgd_base + i;
136
137         for ( ; (i < PTRS_PER_PGD) && (vaddr < end); pgd++, i++) {
138                 pud = pud_offset(pgd, vaddr);
139                 if (pud_none(*pud))
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);
144                         vaddr += PMD_SIZE;
145                 }
146                 j = 0;
147         }
148 }
149
150 #ifdef CONFIG_HIGHMEM
151 pte_t *kmap_pte;
152 pgprot_t kmap_prot;
153
154 #define kmap_get_fixmap_pte(vaddr)                                      \
155         pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
156                           (vaddr)), (vaddr))
157
158 static void __init kmap_init(void)
159 {
160         unsigned long kmap_vstart;
161
162         /* cache the first kmap pte */
163         kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
164         kmap_pte = kmap_get_fixmap_pte(kmap_vstart);
165
166         kmap_prot = PAGE_KERNEL;
167 }
168
169 static void init_highmem(void)
170 {
171         pgd_t *pgd;
172         pud_t *pud;
173         pmd_t *pmd;
174         pte_t *pte;
175         unsigned long vaddr;
176
177         /*
178          * Permanent kmaps:
179          */
180         vaddr = PKMAP_BASE;
181         fixrange_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, swapper_pg_dir);
182
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;
188
189         kmap_init();
190 }
191 #endif /* CONFIG_HIGHMEM */
192
193 static void __init fixaddr_user_init( void)
194 {
195 #ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
196         long size = FIXADDR_USER_END - FIXADDR_USER_START;
197         pgd_t *pgd;
198         pud_t *pud;
199         pmd_t *pmd;
200         pte_t *pte;
201         unsigned long paddr, vaddr = FIXADDR_USER_START;
202
203         if (  ! size )
204                 return;
205
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);
209         paddr = __pa(paddr);
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);
216         }
217 #endif
218 }
219
220 void paging_init(void)
221 {
222         unsigned long zones_size[MAX_NR_ZONES], vaddr;
223         int i;
224
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++)
228                 zones_size[i] = 0;
229
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;
234 #endif
235         free_area_init(zones_size);
236
237         /*
238          * Fixed mappings, only the page table structure has to be
239          * created - mappings will be set by set_fixmap():
240          */
241         vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
242         fixrange_init(vaddr, FIXADDR_TOP, swapper_pg_dir);
243
244         fixaddr_user_init();
245
246 #ifdef CONFIG_HIGHMEM
247         init_highmem();
248 #endif
249 }
250
251 struct page *arch_validate(struct page *page, gfp_t mask, int order)
252 {
253         unsigned long addr, zero = 0;
254         int i;
255
256  again:
257         if(page == NULL)
258                 return page;
259         if(PageHighMem(page))
260                 return page;
261
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,
266                                      sizeof(zero),
267                                      &current->thread.fault_addr,
268                                      &current->thread.fault_catcher)){
269                         if(!(mask & __GFP_WAIT))
270                                 return NULL;
271                         else break;
272                 }
273                 addr += PAGE_SIZE;
274         }
275
276         if(i == (1 << order))
277                 return page;
278         page = alloc_pages(mask, order);
279         goto again;
280 }
281
282 /* This can't do anything because nothing in the kernel image can be freed
283  * since it's not in kernel physical memory.
284  */
285
286 void free_initmem(void)
287 {
288 }
289
290 #ifdef CONFIG_BLK_DEV_INITRD
291 void free_initrd_mem(unsigned long start, unsigned long end)
292 {
293         if (start < 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));
299                 free_page(start);
300                 totalram_pages++;
301         }
302 }
303 #endif
304
305 void show_mem(void)
306 {
307         int pfn, total = 0, reserved = 0;
308         int shared = 0, cached = 0;
309         int highmem = 0;
310         struct page *page;
311
312         printk("Mem-info:\n");
313         show_free_areas();
314         printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
315         pfn = max_mapnr;
316         while(pfn-- > 0) {
317                 page = pfn_to_page(pfn);
318                 total++;
319                 if(PageHighMem(page))
320                         highmem++;
321                 if(PageReserved(page))
322                         reserved++;
323                 else if(PageSwapCache(page))
324                         cached++;
325                 else if(page_count(page))
326                         shared += page_count(page) - 1;
327         }
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);
333 }
334
335 /*
336  * Allocate and free page tables.
337  */
338
339 pgd_t *pgd_alloc(struct mm_struct *mm)
340 {
341         pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL);
342
343         if (pgd) {
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));
348         }
349         return pgd;
350 }
351
352 void pgd_free(pgd_t *pgd)
353 {
354         free_page((unsigned long) pgd);
355 }
356
357 pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
358 {
359         pte_t *pte;
360
361         pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
362         return pte;
363 }
364
365 struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
366 {
367         struct page *pte;
368
369         pte = alloc_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
370         return pte;
371 }