arch/alpha/mm/init.c

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