Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/arch/alpha/mm/init.c |
| 3 | * |
| 4 | * Copyright (C) 1995 Linus Torvalds |
| 5 | */ |
| 6 | |
| 7 | /* 2.3.x zone allocator, 1999 Andrea Arcangeli <andrea@suse.de> */ |
| 8 | |
akpm@osdl.org | df2e71f | 2006-01-09 20:51:37 -0800 | [diff] [blame] | 9 | #include <linux/pagemap.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | #include <linux/signal.h> |
| 11 | #include <linux/sched.h> |
| 12 | #include <linux/kernel.h> |
| 13 | #include <linux/errno.h> |
| 14 | #include <linux/string.h> |
| 15 | #include <linux/types.h> |
| 16 | #include <linux/ptrace.h> |
| 17 | #include <linux/mman.h> |
| 18 | #include <linux/mm.h> |
| 19 | #include <linux/swap.h> |
| 20 | #include <linux/init.h> |
| 21 | #include <linux/bootmem.h> /* max_low_pfn */ |
| 22 | #include <linux/vmalloc.h> |
| 23 | |
| 24 | #include <asm/system.h> |
| 25 | #include <asm/uaccess.h> |
| 26 | #include <asm/pgtable.h> |
| 27 | #include <asm/pgalloc.h> |
| 28 | #include <asm/hwrpb.h> |
| 29 | #include <asm/dma.h> |
| 30 | #include <asm/mmu_context.h> |
| 31 | #include <asm/console.h> |
| 32 | #include <asm/tlb.h> |
| 33 | |
| 34 | DEFINE_PER_CPU(struct mmu_gather, mmu_gathers); |
| 35 | |
| 36 | extern void die_if_kernel(char *,struct pt_regs *,long); |
| 37 | |
| 38 | static struct pcb_struct original_pcb; |
| 39 | |
| 40 | pgd_t * |
| 41 | pgd_alloc(struct mm_struct *mm) |
| 42 | { |
| 43 | pgd_t *ret, *init; |
| 44 | |
| 45 | ret = (pgd_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO); |
| 46 | init = pgd_offset(&init_mm, 0UL); |
| 47 | if (ret) { |
| 48 | #ifdef CONFIG_ALPHA_LARGE_VMALLOC |
| 49 | memcpy (ret + USER_PTRS_PER_PGD, init + USER_PTRS_PER_PGD, |
| 50 | (PTRS_PER_PGD - USER_PTRS_PER_PGD - 1)*sizeof(pgd_t)); |
| 51 | #else |
| 52 | pgd_val(ret[PTRS_PER_PGD-2]) = pgd_val(init[PTRS_PER_PGD-2]); |
| 53 | #endif |
| 54 | |
| 55 | /* The last PGD entry is the VPTB self-map. */ |
| 56 | pgd_val(ret[PTRS_PER_PGD-1]) |
| 57 | = pte_val(mk_pte(virt_to_page(ret), PAGE_KERNEL)); |
| 58 | } |
| 59 | return ret; |
| 60 | } |
| 61 | |
| 62 | pte_t * |
| 63 | pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address) |
| 64 | { |
| 65 | pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO); |
| 66 | return pte; |
| 67 | } |
| 68 | |
| 69 | |
| 70 | /* |
| 71 | * BAD_PAGE is the page that is used for page faults when linux |
| 72 | * is out-of-memory. Older versions of linux just did a |
| 73 | * do_exit(), but using this instead means there is less risk |
| 74 | * for a process dying in kernel mode, possibly leaving an inode |
| 75 | * unused etc.. |
| 76 | * |
| 77 | * BAD_PAGETABLE is the accompanying page-table: it is initialized |
| 78 | * to point to BAD_PAGE entries. |
| 79 | * |
| 80 | * ZERO_PAGE is a special page that is used for zero-initialized |
| 81 | * data and COW. |
| 82 | */ |
| 83 | pmd_t * |
| 84 | __bad_pagetable(void) |
| 85 | { |
| 86 | memset((void *) EMPTY_PGT, 0, PAGE_SIZE); |
| 87 | return (pmd_t *) EMPTY_PGT; |
| 88 | } |
| 89 | |
| 90 | pte_t |
| 91 | __bad_page(void) |
| 92 | { |
| 93 | memset((void *) EMPTY_PGE, 0, PAGE_SIZE); |
| 94 | return pte_mkdirty(mk_pte(virt_to_page(EMPTY_PGE), PAGE_SHARED)); |
| 95 | } |
| 96 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | static inline unsigned long |
| 98 | load_PCB(struct pcb_struct *pcb) |
| 99 | { |
| 100 | register unsigned long sp __asm__("$30"); |
| 101 | pcb->ksp = sp; |
| 102 | return __reload_thread(pcb); |
| 103 | } |
| 104 | |
| 105 | /* Set up initial PCB, VPTB, and other such nicities. */ |
| 106 | |
| 107 | static inline void |
| 108 | switch_to_system_map(void) |
| 109 | { |
| 110 | unsigned long newptbr; |
| 111 | unsigned long original_pcb_ptr; |
| 112 | |
| 113 | /* Initialize the kernel's page tables. Linux puts the vptb in |
| 114 | the last slot of the L1 page table. */ |
| 115 | memset(swapper_pg_dir, 0, PAGE_SIZE); |
| 116 | newptbr = ((unsigned long) swapper_pg_dir - PAGE_OFFSET) >> PAGE_SHIFT; |
| 117 | pgd_val(swapper_pg_dir[1023]) = |
| 118 | (newptbr << 32) | pgprot_val(PAGE_KERNEL); |
| 119 | |
| 120 | /* Set the vptb. This is often done by the bootloader, but |
| 121 | shouldn't be required. */ |
| 122 | if (hwrpb->vptb != 0xfffffffe00000000UL) { |
| 123 | wrvptptr(0xfffffffe00000000UL); |
| 124 | hwrpb->vptb = 0xfffffffe00000000UL; |
| 125 | hwrpb_update_checksum(hwrpb); |
| 126 | } |
| 127 | |
| 128 | /* Also set up the real kernel PCB while we're at it. */ |
| 129 | init_thread_info.pcb.ptbr = newptbr; |
| 130 | init_thread_info.pcb.flags = 1; /* set FEN, clear everything else */ |
| 131 | original_pcb_ptr = load_PCB(&init_thread_info.pcb); |
| 132 | tbia(); |
| 133 | |
| 134 | /* Save off the contents of the original PCB so that we can |
| 135 | restore the original console's page tables for a clean reboot. |
| 136 | |
| 137 | Note that the PCB is supposed to be a physical address, but |
| 138 | since KSEG values also happen to work, folks get confused. |
| 139 | Check this here. */ |
| 140 | |
| 141 | if (original_pcb_ptr < PAGE_OFFSET) { |
| 142 | original_pcb_ptr = (unsigned long) |
| 143 | phys_to_virt(original_pcb_ptr); |
| 144 | } |
| 145 | original_pcb = *(struct pcb_struct *) original_pcb_ptr; |
| 146 | } |
| 147 | |
| 148 | int callback_init_done; |
| 149 | |
| 150 | void * __init |
| 151 | callback_init(void * kernel_end) |
| 152 | { |
| 153 | struct crb_struct * crb; |
| 154 | pgd_t *pgd; |
| 155 | pmd_t *pmd; |
| 156 | void *two_pages; |
| 157 | |
| 158 | /* Starting at the HWRPB, locate the CRB. */ |
| 159 | crb = (struct crb_struct *)((char *)hwrpb + hwrpb->crb_offset); |
| 160 | |
| 161 | if (alpha_using_srm) { |
| 162 | /* Tell the console whither it is to be remapped. */ |
| 163 | if (srm_fixup(VMALLOC_START, (unsigned long)hwrpb)) |
| 164 | __halt(); /* "We're boned." --Bender */ |
| 165 | |
| 166 | /* Edit the procedure descriptors for DISPATCH and FIXUP. */ |
| 167 | crb->dispatch_va = (struct procdesc_struct *) |
| 168 | (VMALLOC_START + (unsigned long)crb->dispatch_va |
| 169 | - crb->map[0].va); |
| 170 | crb->fixup_va = (struct procdesc_struct *) |
| 171 | (VMALLOC_START + (unsigned long)crb->fixup_va |
| 172 | - crb->map[0].va); |
| 173 | } |
| 174 | |
| 175 | switch_to_system_map(); |
| 176 | |
| 177 | /* Allocate one PGD and one PMD. In the case of SRM, we'll need |
| 178 | these to actually remap the console. There is an assumption |
| 179 | here that only one of each is needed, and this allows for 8MB. |
| 180 | On systems with larger consoles, additional pages will be |
| 181 | allocated as needed during the mapping process. |
| 182 | |
| 183 | In the case of not SRM, but not CONFIG_ALPHA_LARGE_VMALLOC, |
| 184 | we need to allocate the PGD we use for vmalloc before we start |
| 185 | forking other tasks. */ |
| 186 | |
| 187 | two_pages = (void *) |
| 188 | (((unsigned long)kernel_end + ~PAGE_MASK) & PAGE_MASK); |
| 189 | kernel_end = two_pages + 2*PAGE_SIZE; |
| 190 | memset(two_pages, 0, 2*PAGE_SIZE); |
| 191 | |
| 192 | pgd = pgd_offset_k(VMALLOC_START); |
| 193 | pgd_set(pgd, (pmd_t *)two_pages); |
| 194 | pmd = pmd_offset(pgd, VMALLOC_START); |
| 195 | pmd_set(pmd, (pte_t *)(two_pages + PAGE_SIZE)); |
| 196 | |
| 197 | if (alpha_using_srm) { |
| 198 | static struct vm_struct console_remap_vm; |
| 199 | unsigned long vaddr = VMALLOC_START; |
| 200 | unsigned long i, j; |
| 201 | |
| 202 | /* Set up the third level PTEs and update the virtual |
| 203 | addresses of the CRB entries. */ |
| 204 | for (i = 0; i < crb->map_entries; ++i) { |
| 205 | unsigned long pfn = crb->map[i].pa >> PAGE_SHIFT; |
| 206 | crb->map[i].va = vaddr; |
| 207 | for (j = 0; j < crb->map[i].count; ++j) { |
Simon Arlott | c3a2dde | 2007-10-20 01:04:37 +0200 | [diff] [blame] | 208 | /* Newer consoles (especially on larger |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 209 | systems) may require more pages of |
| 210 | PTEs. Grab additional pages as needed. */ |
| 211 | if (pmd != pmd_offset(pgd, vaddr)) { |
| 212 | memset(kernel_end, 0, PAGE_SIZE); |
| 213 | pmd = pmd_offset(pgd, vaddr); |
| 214 | pmd_set(pmd, (pte_t *)kernel_end); |
| 215 | kernel_end += PAGE_SIZE; |
| 216 | } |
| 217 | set_pte(pte_offset_kernel(pmd, vaddr), |
| 218 | pfn_pte(pfn, PAGE_KERNEL)); |
| 219 | pfn++; |
| 220 | vaddr += PAGE_SIZE; |
| 221 | } |
| 222 | } |
| 223 | |
| 224 | /* Let vmalloc know that we've allocated some space. */ |
| 225 | console_remap_vm.flags = VM_ALLOC; |
| 226 | console_remap_vm.addr = (void *) VMALLOC_START; |
| 227 | console_remap_vm.size = vaddr - VMALLOC_START; |
| 228 | vmlist = &console_remap_vm; |
| 229 | } |
| 230 | |
| 231 | callback_init_done = 1; |
| 232 | return kernel_end; |
| 233 | } |
| 234 | |
| 235 | |
| 236 | #ifndef CONFIG_DISCONTIGMEM |
| 237 | /* |
| 238 | * paging_init() sets up the memory map. |
| 239 | */ |
Sam Ravnborg | 64d158b | 2007-07-31 00:37:53 -0700 | [diff] [blame] | 240 | void __init paging_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | { |
Christoph Lameter | f06a968 | 2006-09-25 23:31:10 -0700 | [diff] [blame] | 242 | unsigned long zones_size[MAX_NR_ZONES] = {0, }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | unsigned long dma_pfn, high_pfn; |
| 244 | |
| 245 | dma_pfn = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT; |
| 246 | high_pfn = max_pfn = max_low_pfn; |
| 247 | |
| 248 | if (dma_pfn >= high_pfn) |
| 249 | zones_size[ZONE_DMA] = high_pfn; |
| 250 | else { |
| 251 | zones_size[ZONE_DMA] = dma_pfn; |
| 252 | zones_size[ZONE_NORMAL] = high_pfn - dma_pfn; |
| 253 | } |
| 254 | |
| 255 | /* Initialize mem_map[]. */ |
| 256 | free_area_init(zones_size); |
| 257 | |
| 258 | /* Initialize the kernel's ZERO_PGE. */ |
| 259 | memset((void *)ZERO_PGE, 0, PAGE_SIZE); |
| 260 | } |
| 261 | #endif /* CONFIG_DISCONTIGMEM */ |
| 262 | |
| 263 | #if defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_SRM) |
| 264 | void |
| 265 | srm_paging_stop (void) |
| 266 | { |
| 267 | /* Move the vptb back to where the SRM console expects it. */ |
| 268 | swapper_pg_dir[1] = swapper_pg_dir[1023]; |
| 269 | tbia(); |
| 270 | wrvptptr(0x200000000UL); |
| 271 | hwrpb->vptb = 0x200000000UL; |
| 272 | hwrpb_update_checksum(hwrpb); |
| 273 | |
| 274 | /* Reload the page tables that the console had in use. */ |
| 275 | load_PCB(&original_pcb); |
| 276 | tbia(); |
| 277 | } |
| 278 | #endif |
| 279 | |
| 280 | #ifndef CONFIG_DISCONTIGMEM |
| 281 | static void __init |
| 282 | printk_memory_info(void) |
| 283 | { |
| 284 | unsigned long codesize, reservedpages, datasize, initsize, tmp; |
| 285 | extern int page_is_ram(unsigned long) __init; |
| 286 | extern char _text, _etext, _data, _edata; |
| 287 | extern char __init_begin, __init_end; |
| 288 | |
| 289 | /* printk all informations */ |
| 290 | reservedpages = 0; |
| 291 | for (tmp = 0; tmp < max_low_pfn; tmp++) |
| 292 | /* |
| 293 | * Only count reserved RAM pages |
| 294 | */ |
| 295 | if (page_is_ram(tmp) && PageReserved(mem_map+tmp)) |
| 296 | reservedpages++; |
| 297 | |
| 298 | codesize = (unsigned long) &_etext - (unsigned long) &_text; |
| 299 | datasize = (unsigned long) &_edata - (unsigned long) &_data; |
| 300 | initsize = (unsigned long) &__init_end - (unsigned long) &__init_begin; |
| 301 | |
| 302 | printk("Memory: %luk/%luk available (%luk kernel code, %luk reserved, %luk data, %luk init)\n", |
| 303 | (unsigned long) nr_free_pages() << (PAGE_SHIFT-10), |
| 304 | max_mapnr << (PAGE_SHIFT-10), |
| 305 | codesize >> 10, |
| 306 | reservedpages << (PAGE_SHIFT-10), |
| 307 | datasize >> 10, |
| 308 | initsize >> 10); |
| 309 | } |
| 310 | |
| 311 | void __init |
| 312 | mem_init(void) |
| 313 | { |
| 314 | max_mapnr = num_physpages = max_low_pfn; |
| 315 | totalram_pages += free_all_bootmem(); |
| 316 | high_memory = (void *) __va(max_low_pfn * PAGE_SIZE); |
| 317 | |
| 318 | printk_memory_info(); |
| 319 | } |
| 320 | #endif /* CONFIG_DISCONTIGMEM */ |
| 321 | |
| 322 | void |
| 323 | free_reserved_mem(void *start, void *end) |
| 324 | { |
| 325 | void *__start = start; |
| 326 | for (; __start < end; __start += PAGE_SIZE) { |
| 327 | ClearPageReserved(virt_to_page(__start)); |
Nick Piggin | 7835e98 | 2006-03-22 00:08:40 -0800 | [diff] [blame] | 328 | init_page_count(virt_to_page(__start)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | free_page((long)__start); |
| 330 | totalram_pages++; |
| 331 | } |
| 332 | } |
| 333 | |
| 334 | void |
| 335 | free_initmem(void) |
| 336 | { |
| 337 | extern char __init_begin, __init_end; |
| 338 | |
| 339 | free_reserved_mem(&__init_begin, &__init_end); |
| 340 | printk ("Freeing unused kernel memory: %ldk freed\n", |
| 341 | (&__init_end - &__init_begin) >> 10); |
| 342 | } |
| 343 | |
| 344 | #ifdef CONFIG_BLK_DEV_INITRD |
| 345 | void |
| 346 | free_initrd_mem(unsigned long start, unsigned long end) |
| 347 | { |
| 348 | free_reserved_mem((void *)start, (void *)end); |
| 349 | printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10); |
| 350 | } |
| 351 | #endif |