1/* 2 * arch/s390/mm/init.c 3 * 4 * S390 version 5 * Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation 6 * Author(s): Hartmut Penner (hpenner@de.ibm.com) 7 * 8 * Derived from "arch/i386/mm/init.c" 9 * Copyright (C) 1995 Linus Torvalds 10 */ 11 12#include <linux/config.h> 13#include <linux/signal.h> 14#include <linux/sched.h> 15#include <linux/kernel.h> 16#include <linux/errno.h> 17#include <linux/string.h> 18#include <linux/types.h> 19#include <linux/ptrace.h> 20#include <linux/mman.h> 21#include <linux/mm.h> 22#include <linux/swap.h> 23#include <linux/smp.h> 24#include <linux/init.h> 25#ifdef CONFIG_BLK_DEV_INITRD 26#include <linux/blk.h> 27#endif 28#include <linux/pagemap.h> 29#include <linux/bootmem.h> 30 31#include <asm/processor.h> 32#include <asm/system.h> 33#include <asm/uaccess.h> 34#include <asm/pgtable.h> 35#include <asm/pgalloc.h> 36#include <asm/dma.h> 37#include <asm/lowcore.h> 38#include <asm/tlb.h> 39 40mmu_gather_t mmu_gathers[NR_CPUS]; 41 42static unsigned long totalram_pages; 43 44pgd_t swapper_pg_dir[PTRS_PER_PGD] __attribute__((__aligned__(PAGE_SIZE))); 45char empty_zero_page[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE))); 46 47pmd_t *pgd_populate(struct mm_struct *mm, pgd_t *pgd, pmd_t *pmd) 48{ 49 unsigned long addr = (unsigned long) pgd; 50 unsigned long *pgd_slot = (unsigned long *) (addr & -8); 51 unsigned long offset = addr & 4; 52 pmd_t *new, *pmd2; 53 int i; 54 55 if (offset == 0 && 56 ((*pgd_slot & _PGD_ENTRY_INV) != 0 || 57 (*pgd_slot & _PGD_ENTRY_LEN(2)) == 0)) { 58 /* Set lower pmd, upper pmd is empty. */ 59 *pgd_slot = __pa(pmd) | _PGD_ENTRY_MASK | 60 _PGD_ENTRY_OFF(0) | _PGD_ENTRY_LEN(1); 61 return pmd; 62 } 63 if (offset == 4 && 64 ((*pgd_slot & _PGD_ENTRY_INV) != 0 || 65 (*pgd_slot & _PGD_ENTRY_OFF(2)) != 0)) { 66 /* Lower pmd empty, set upper pmd. */ 67 *pgd_slot = (__pa(pmd) - 0x2000) | _PGD_ENTRY_MASK | 68 _PGD_ENTRY_OFF(2) | _PGD_ENTRY_LEN(3); 69 return pmd; 70 } 71 /* We have to enlarge the pmd to 16K if we arrive here. */ 72 new = (pmd_t *) __get_free_pages(GFP_KERNEL, 2); 73 if (new == NULL) { 74 pmd_free(pmd); 75 return NULL; 76 } 77 /* Set the PG_arch_1 bit on the first and the third pmd page 78 so that pmd_free_fast can recognize pmds that have been 79 allocated with an order 2 allocation. */ 80 set_bit(PG_arch_1, &virt_to_page(new)->flags); 81 set_bit(PG_arch_1, &virt_to_page(new+PTRS_PER_PMD)->flags); 82 /* Now copy the two pmds to the new memory area. */ 83 if (offset == 0) { 84 pmd2 = (pmd_t *)(*pgd_slot & PAGE_MASK) + PTRS_PER_PMD; 85 memcpy(new, pmd, sizeof(pmd_t)*PTRS_PER_PMD); 86 memcpy(new + PTRS_PER_PMD, pmd2, sizeof(pmd_t)*PTRS_PER_PMD); 87 } else { 88 pmd2 = (pmd_t *)(*pgd_slot & PAGE_MASK); 89 memcpy(new, pmd2, sizeof(pmd_t)*PTRS_PER_PMD); 90 memcpy(new + PTRS_PER_PMD, pmd, sizeof(pmd_t)*PTRS_PER_PMD); 91 } 92 *pgd_slot = __pa(new) | _PGD_ENTRY_MASK | 93 _PGD_ENTRY_OFF(0) | _PGD_ENTRY_LEN(3); 94 for (i = 0; i < PTRS_PER_PMD; i++) { 95 pmd_clear(pmd + i); 96 pmd_clear(pmd2 + i); 97 } 98 pmd_free(pmd); 99 pmd_free(pmd2); 100 return new; 101} 102 103void pmd_free_order2(pmd_t *pmd) 104{ 105 pmd_t *pmd2 = (pmd_t *) ((unsigned long) pmd ^ 8192); 106 107 clear_bit(PG_arch_1, &virt_to_page(pmd)->flags); 108 if (test_bit(PG_arch_1, &virt_to_page(pmd2)->flags) == 0) { 109 /* The other pmd of the order 2 allocation has already 110 been freed. Now we can release the order 2 allocation. */ 111 free_pages((unsigned long) pmd & ~8192, 2); 112 } 113} 114 115int do_check_pgt_cache(int low, int high) 116{ 117 int freed = 0; 118 if(pgtable_cache_size > high) { 119 do { 120 if(pgd_quicklist) { 121 free_pgd_slow(get_pgd_fast()); 122 freed += 2; 123 } 124 if(pmd_quicklist) { 125 pmd_free_slow(pmd_alloc_one_fast(NULL, 0)); 126 freed += 2; 127 } 128 if(pte_quicklist) { 129 pte_free_slow(pte_alloc_one_fast(NULL, 0)); 130 freed += 1; 131 } 132 } while(pgtable_cache_size > low); 133 } 134 return freed; 135} 136 137void show_mem(void) 138{ 139 int i, total = 0,reserved = 0; 140 int shared = 0, cached = 0; 141 142 printk("Mem-info:\n"); 143 show_free_areas(); 144 printk("Free swap: %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10)); 145 i = max_mapnr; 146 while (i-- > 0) { 147 total++; 148 if (PageReserved(mem_map+i)) 149 reserved++; 150 else if (PageSwapCache(mem_map+i)) 151 cached++; 152 else if (page_count(mem_map+i)) 153 shared += atomic_read(&mem_map[i].count) - 1; 154 } 155 printk("%d pages of RAM\n",total); 156 printk("%d reserved pages\n",reserved); 157 printk("%d pages shared\n",shared); 158 printk("%d pages swap cached\n",cached); 159 printk("%ld pages in page table cache\n",pgtable_cache_size); 160 show_buffers(); 161} 162 163/* References to section boundaries */ 164 165extern unsigned long _text; 166extern unsigned long _etext; 167extern unsigned long _edata; 168extern unsigned long __bss_start; 169extern unsigned long _end; 170 171extern unsigned long __init_begin; 172extern unsigned long __init_end; 173 174/* 175 * paging_init() sets up the page tables 176 */ 177 178unsigned long last_valid_pfn; 179 180void __init paging_init(void) 181{ 182 unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0}; 183 static const int ssm_mask = 0x04000000L; 184 unsigned long dma_pfn, address, end_mem; 185 pgd_t * pg_dir; 186 int i,j,k; 187 188 dma_pfn = MAX_DMA_ADDRESS >> PAGE_SHIFT; 189 190 if (dma_pfn > max_low_pfn) 191 zones_size[ZONE_DMA] = max_low_pfn; 192 else { 193 zones_size[ZONE_DMA] = dma_pfn; 194 zones_size[ZONE_NORMAL] = max_low_pfn - dma_pfn; 195 } 196 197 /* Initialize mem_map[]. */ 198 free_area_init(zones_size); 199 200 /* 201 * map whole physical memory to virtual memory (identity mapping) 202 */ 203 pg_dir = swapper_pg_dir; 204 address = 0; 205 end_mem = (unsigned long) __va(max_low_pfn*PAGE_SIZE); 206 for (i = 0 ; i < PTRS_PER_PGD/2 ; i++, pg_dir += 2) { 207 pmd_t *pm_dir; 208 209 if (address >= end_mem) { 210 pgd_clear(pg_dir); 211 continue; 212 } 213 214 pm_dir = (pmd_t *) alloc_bootmem_low_pages(PAGE_SIZE*4); 215 *((unsigned long *) pg_dir) = __pa(pm_dir) | _PGD_ENTRY_MASK | 216 _PGD_ENTRY_LEN(3) | _PGD_ENTRY_OFF(0); 217 218 for (j = 0 ; j < PTRS_PER_PMD*2 ; j++, pm_dir++) { 219 pte_t *pt_dir; 220 221 if (address >= end_mem) { 222 pmd_clear(pm_dir); 223 continue; 224 } 225 226 pt_dir = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE); 227 pmd_populate(&init_mm, pm_dir, pt_dir); 228 229 for (k = 0 ; k < PTRS_PER_PTE ; k++,pt_dir++) { 230 pte_t pte = mk_pte_phys(address, PAGE_KERNEL); 231 if (address >= end_mem) { 232 pte_clear(&pte); 233 continue; 234 } 235 set_pte(pt_dir, pte); 236 address += PAGE_SIZE; 237 } 238 } 239 } 240 241 /* enable virtual mapping in kernel mode */ 242 __asm__ __volatile__("lctlg 1,1,%0\n\t" 243 "lctlg 7,7,%0\n\t" 244 "lctlg 13,13,%0\n\t" 245 "ssm %1" 246 : :"m" (__pa(swapper_pg_dir) | _KERN_REGION_TABLE), 247 "m" (ssm_mask)); 248 local_flush_tlb(); 249 250 return; 251} 252 253void __init mem_init(void) 254{ 255 unsigned long codesize, reservedpages, datasize, initsize; 256 257 max_mapnr = num_physpages = max_low_pfn; 258 high_memory = (void *) __va(max_low_pfn * PAGE_SIZE); 259 260 /* clear the zero-page */ 261 memset(empty_zero_page, 0, PAGE_SIZE); 262 263 /* this will put all low memory onto the freelists */ 264 totalram_pages += free_all_bootmem(); 265 266 reservedpages = 0; 267 268 codesize = (unsigned long) &_etext - (unsigned long) &_text; 269 datasize = (unsigned long) &_edata - (unsigned long) &_etext; 270 initsize = (unsigned long) &__init_end - (unsigned long) &__init_begin; 271 printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n", 272 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10), 273 max_mapnr << (PAGE_SHIFT-10), 274 codesize >> 10, 275 reservedpages << (PAGE_SHIFT-10), 276 datasize >>10, 277 initsize >> 10); 278} 279 280void free_initmem(void) 281{ 282 unsigned long addr; 283 284 addr = (unsigned long)(&__init_begin); 285 for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) { 286 ClearPageReserved(virt_to_page(addr)); 287 set_page_count(virt_to_page(addr), 1); 288 free_page(addr); 289 totalram_pages++; 290 } 291 printk (KERN_INFO "Freeing unused kernel memory: %ldk freed\n", 292 (&__init_end - &__init_begin) >> 10); 293} 294 295#ifdef CONFIG_BLK_DEV_INITRD 296void free_initrd_mem(unsigned long start, unsigned long end) 297{ 298 if (start < end) 299 printk (KERN_INFO "Freeing initrd memory: %ldk freed\n", (end - start) >> 10); 300 for (; start < end; start += PAGE_SIZE) { 301 ClearPageReserved(virt_to_page(start)); 302 set_page_count(virt_to_page(start), 1); 303 free_page(start); 304 totalram_pages++; 305 } 306} 307#endif 308 309void si_meminfo(struct sysinfo *val) 310{ 311 val->totalram = totalram_pages; 312 val->sharedram = 0; 313 val->freeram = nr_free_pages(); 314 val->bufferram = atomic_read(&buffermem_pages); 315 val->totalhigh = 0; 316 val->freehigh = 0; 317 val->mem_unit = PAGE_SIZE; 318} 319 320/* 321 * Overrides for Emacs so that we follow Linus's tabbing style. 322 * Emacs will notice this stuff at the end of the file and automatically 323 * adjust the settings for this buffer only. This must remain at the end 324 * of the file. 325 * --------------------------------------------------------------------------- 326 * Local variables: 327 * c-indent-level: 4 328 * c-brace-imaginary-offset: 0 329 * c-brace-offset: -4 330 * c-argdecl-indent: 4 331 * c-label-offset: -4 332 * c-continued-statement-offset: 4 333 * c-continued-brace-offset: 0 334 * indent-tabs-mode: nil 335 * tab-width: 8 336 * End: 337 */ 338