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/pagemap.h>
  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
  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) {
 208                                 /* Newer consoles (especially on larger
 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  */
 240 void __init paging_init(void)
 241 {
 242         unsigned long zones_size[MAX_NR_ZONES] = {0, };
 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));
 328                 init_page_count(virt_to_page(__start));
 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