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 ¤t->thread.fault_addr, 268 ¤t->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 } 372