git.oblomov.eu Git - linux-2.6/blob - arch/x86/mm/init_32.c

   1 /*
   2  *  linux/arch/i386/mm/init.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  *
   6  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
   7  */
   8
   9 #include <linux/module.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/hugetlb.h>
  20 #include <linux/swap.h>
  21 #include <linux/smp.h>
  22 #include <linux/init.h>
  23 #include <linux/highmem.h>
  24 #include <linux/pagemap.h>
  25 #include <linux/pfn.h>
  26 #include <linux/poison.h>
  27 #include <linux/bootmem.h>
  28 #include <linux/slab.h>
  29 #include <linux/proc_fs.h>
  30 #include <linux/memory_hotplug.h>
  31 #include <linux/initrd.h>
  32 #include <linux/cpumask.h>
  33
  34 #include <asm/asm.h>
  35 #include <asm/processor.h>
  36 #include <asm/system.h>
  37 #include <asm/uaccess.h>
  38 #include <asm/pgtable.h>
  39 #include <asm/dma.h>
  40 #include <asm/fixmap.h>
  41 #include <asm/e820.h>
  42 #include <asm/apic.h>
  43 #include <asm/bugs.h>
  44 #include <asm/tlb.h>
  45 #include <asm/tlbflush.h>
  46 #include <asm/pgalloc.h>
  47 #include <asm/sections.h>
  48 #include <asm/paravirt.h>
  49 #include <asm/setup.h>
  50
  51 unsigned int __VMALLOC_RESERVE = 128 << 20;
  52
  53 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
  54 unsigned long highstart_pfn, highend_pfn;
  55
  56 static noinline int do_test_wp_bit(void);
  57
  58 /*
  59  * Creates a middle page table and puts a pointer to it in the
  60  * given global directory entry. This only returns the gd entry
  61  * in non-PAE compilation mode, since the middle layer is folded.
  62  */
  63 static pmd_t * __init one_md_table_init(pgd_t *pgd)
  64 {
  65         pud_t *pud;
  66         pmd_t *pmd_table;
  67
  68 #ifdef CONFIG_X86_PAE
  69         if (!(pgd_val(*pgd) & _PAGE_PRESENT)) {
  70                 pmd_table = (pmd_t *) alloc_bootmem_low_pages(PAGE_SIZE);
  71
  72                 paravirt_alloc_pd(&init_mm, __pa(pmd_table) >> PAGE_SHIFT);
  73                 set_pgd(pgd, __pgd(__pa(pmd_table) | _PAGE_PRESENT));
  74                 pud = pud_offset(pgd, 0);
  75                 BUG_ON(pmd_table != pmd_offset(pud, 0));
  76         }
  77 #endif
  78         pud = pud_offset(pgd, 0);
  79         pmd_table = pmd_offset(pud, 0);
  80
  81         return pmd_table;
  82 }
  83
  84 /*
  85  * Create a page table and place a pointer to it in a middle page
  86  * directory entry:
  87  */
  88 static pte_t * __init one_page_table_init(pmd_t *pmd)
  89 {
  90         if (!(pmd_val(*pmd) & _PAGE_PRESENT)) {
  91                 pte_t *page_table = NULL;
  92
  93 #ifdef CONFIG_DEBUG_PAGEALLOC
  94                 page_table = (pte_t *) alloc_bootmem_pages(PAGE_SIZE);
  95 #endif
  96                 if (!page_table) {
  97                         page_table =
  98                                 (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
  99                 }
 100
 101                 paravirt_alloc_pt(&init_mm, __pa(page_table) >> PAGE_SHIFT);
 102                 set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE));
 103                 BUG_ON(page_table != pte_offset_kernel(pmd, 0));
 104         }
 105
 106         return pte_offset_kernel(pmd, 0);
 107 }
 108
 109 /*
 110  * This function initializes a certain range of kernel virtual memory
 111  * with new bootmem page tables, everywhere page tables are missing in
 112  * the given range.
 113  *
 114  * NOTE: The pagetables are allocated contiguous on the physical space
 115  * so we can cache the place of the first one and move around without
 116  * checking the pgd every time.
 117  */
 118 static void __init
 119 page_table_range_init(unsigned long start, unsigned long end, pgd_t *pgd_base)
 120 {
 121         int pgd_idx, pmd_idx;
 122         unsigned long vaddr;
 123         pgd_t *pgd;
 124         pmd_t *pmd;
 125
 126         vaddr = start;
 127         pgd_idx = pgd_index(vaddr);
 128         pmd_idx = pmd_index(vaddr);
 129         pgd = pgd_base + pgd_idx;
 130
 131         for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd++, pgd_idx++) {
 132                 pmd = one_md_table_init(pgd);
 133                 pmd = pmd + pmd_index(vaddr);
 134                 for (; (pmd_idx < PTRS_PER_PMD) && (vaddr != end);
 135                                                         pmd++, pmd_idx++) {
 136                         one_page_table_init(pmd);
 137
 138                         vaddr += PMD_SIZE;
 139                 }
 140                 pmd_idx = 0;
 141         }
 142 }
 143
 144 static inline int is_kernel_text(unsigned long addr)
 145 {
 146         if (addr >= PAGE_OFFSET && addr <= (unsigned long)__init_end)
 147                 return 1;
 148         return 0;
 149 }
 150
 151 /*
 152  * This maps the physical memory to kernel virtual address space, a total
 153  * of max_low_pfn pages, by creating page tables starting from address
 154  * PAGE_OFFSET:
 155  */
 156 static void __init kernel_physical_mapping_init(pgd_t *pgd_base)
 157 {
 158         int pgd_idx, pmd_idx, pte_ofs;
 159         unsigned long pfn;
 160         pgd_t *pgd;
 161         pmd_t *pmd;
 162         pte_t *pte;
 163
 164         pgd_idx = pgd_index(PAGE_OFFSET);
 165         pgd = pgd_base + pgd_idx;
 166         pfn = 0;
 167
 168         for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
 169                 pmd = one_md_table_init(pgd);
 170                 if (pfn >= max_low_pfn)
 171                         continue;
 172
 173                 for (pmd_idx = 0;
 174                      pmd_idx < PTRS_PER_PMD && pfn < max_low_pfn;
 175                      pmd++, pmd_idx++) {
 176                         unsigned int addr = pfn * PAGE_SIZE + PAGE_OFFSET;
 177
 178                         /*
 179                          * Map with big pages if possible, otherwise
 180                          * create normal page tables:
 181                          */
 182                         if (cpu_has_pse) {
 183                                 unsigned int addr2;
 184                                 pgprot_t prot = PAGE_KERNEL_LARGE;
 185
 186                                 addr2 = (pfn + PTRS_PER_PTE-1) * PAGE_SIZE +
 187                                         PAGE_OFFSET + PAGE_SIZE-1;
 188
 189                                 if (is_kernel_text(addr) ||
 190                                     is_kernel_text(addr2))
 191                                         prot = PAGE_KERNEL_LARGE_EXEC;
 192
 193                                 set_pmd(pmd, pfn_pmd(pfn, prot));
 194
 195                                 pfn += PTRS_PER_PTE;
 196                                 continue;
 197                         }
 198                         pte = one_page_table_init(pmd);
 199
 200                         for (pte_ofs = 0;
 201                              pte_ofs < PTRS_PER_PTE && pfn < max_low_pfn;
 202                              pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {
 203                                 pgprot_t prot = PAGE_KERNEL;
 204
 205                                 if (is_kernel_text(addr))
 206                                         prot = PAGE_KERNEL_EXEC;
 207
 208                                 set_pte(pte, pfn_pte(pfn, prot));
 209                         }
 210                 }
 211         }
 212 }
 213
 214 static inline int page_kills_ppro(unsigned long pagenr)
 215 {
 216         if (pagenr >= 0x70000 && pagenr <= 0x7003F)
 217                 return 1;
 218         return 0;
 219 }
 220
 221 #ifdef CONFIG_HIGHMEM
 222 pte_t *kmap_pte;
 223 pgprot_t kmap_prot;
 224
 225 static inline pte_t *kmap_get_fixmap_pte(unsigned long vaddr)
 226 {
 227         return pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr),
 228                         vaddr), vaddr), vaddr);
 229 }
 230
 231 static void __init kmap_init(void)
 232 {
 233         unsigned long kmap_vstart;
 234
 235         /*
 236          * Cache the first kmap pte:
 237          */
 238         kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
 239         kmap_pte = kmap_get_fixmap_pte(kmap_vstart);
 240
 241         kmap_prot = PAGE_KERNEL;
 242 }
 243
 244 static void __init permanent_kmaps_init(pgd_t *pgd_base)
 245 {
 246         unsigned long vaddr;
 247         pgd_t *pgd;
 248         pud_t *pud;
 249         pmd_t *pmd;
 250         pte_t *pte;
 251
 252         vaddr = PKMAP_BASE;
 253         page_table_range_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, pgd_base);
 254
 255         pgd = swapper_pg_dir + pgd_index(vaddr);
 256         pud = pud_offset(pgd, vaddr);
 257         pmd = pmd_offset(pud, vaddr);
 258         pte = pte_offset_kernel(pmd, vaddr);
 259         pkmap_page_table = pte;
 260 }
 261
 262 static void __meminit free_new_highpage(struct page *page)
 263 {
 264         init_page_count(page);
 265         __free_page(page);
 266         totalhigh_pages++;
 267 }
 268
 269 void __init add_one_highpage_init(struct page *page, int pfn, int bad_ppro)
 270 {
 271         if (page_is_ram(pfn) && !(bad_ppro && page_kills_ppro(pfn))) {
 272                 ClearPageReserved(page);
 273                 free_new_highpage(page);
 274         } else
 275                 SetPageReserved(page);
 276 }
 277
 278 static int __meminit
 279 add_one_highpage_hotplug(struct page *page, unsigned long pfn)
 280 {
 281         free_new_highpage(page);
 282         totalram_pages++;
 283 #ifdef CONFIG_FLATMEM
 284         max_mapnr = max(pfn, max_mapnr);
 285 #endif
 286         num_physpages++;
 287
 288         return 0;
 289 }
 290
 291 /*
 292  * Not currently handling the NUMA case.
 293  * Assuming single node and all memory that
 294  * has been added dynamically that would be
 295  * onlined here is in HIGHMEM.
 296  */
 297 void __meminit online_page(struct page *page)
 298 {
 299         ClearPageReserved(page);
 300         add_one_highpage_hotplug(page, page_to_pfn(page));
 301 }
 302
 303 #ifndef CONFIG_NUMA
 304 static void __init set_highmem_pages_init(int bad_ppro)
 305 {
 306         int pfn;
 307
 308         for (pfn = highstart_pfn; pfn < highend_pfn; pfn++) {
 309                 /*
 310                  * Holes under sparsemem might not have no mem_map[]:
 311                  */
 312                 if (pfn_valid(pfn))
 313                         add_one_highpage_init(pfn_to_page(pfn), pfn, bad_ppro);
 314         }
 315         totalram_pages += totalhigh_pages;
 316 }
 317 #endif /* !CONFIG_NUMA */
 318
 319 #else
 320 # define kmap_init()                            do { } while (0)
 321 # define permanent_kmaps_init(pgd_base)         do { } while (0)
 322 # define set_highmem_pages_init(bad_ppro)       do { } while (0)
 323 #endif /* CONFIG_HIGHMEM */
 324
 325 pteval_t __PAGE_KERNEL = _PAGE_KERNEL;
 326 EXPORT_SYMBOL(__PAGE_KERNEL);
 327
 328 pteval_t __PAGE_KERNEL_EXEC = _PAGE_KERNEL_EXEC;
 329
 330 void __init native_pagetable_setup_start(pgd_t *base)
 331 {
 332         unsigned long pfn, va;
 333         pgd_t *pgd;
 334         pud_t *pud;
 335         pmd_t *pmd;
 336         pte_t *pte;
 337
 338         /*
 339          * Remove any mappings which extend past the end of physical
 340          * memory from the boot time page table:
 341          */
 342         for (pfn = max_low_pfn + 1; pfn < 1<<(32-PAGE_SHIFT); pfn++) {
 343                 va = PAGE_OFFSET + (pfn<<PAGE_SHIFT);
 344                 pgd = base + pgd_index(va);
 345                 if (!pgd_present(*pgd))
 346                         break;
 347
 348                 pud = pud_offset(pgd, va);
 349                 pmd = pmd_offset(pud, va);
 350                 if (!pmd_present(*pmd))
 351                         break;
 352
 353                 pte = pte_offset_kernel(pmd, va);
 354                 if (!pte_present(*pte))
 355                         break;
 356
 357                 pte_clear(NULL, va, pte);
 358         }
 359         paravirt_alloc_pd(&init_mm, __pa(base) >> PAGE_SHIFT);
 360 }
 361
 362 void __init native_pagetable_setup_done(pgd_t *base)
 363 {
 364 }
 365
 366 /*
 367  * Build a proper pagetable for the kernel mappings.  Up until this
 368  * point, we've been running on some set of pagetables constructed by
 369  * the boot process.
 370  *
 371  * If we're booting on native hardware, this will be a pagetable
 372  * constructed in arch/x86/kernel/head_32.S.  The root of the
 373  * pagetable will be swapper_pg_dir.
 374  *
 375  * If we're booting paravirtualized under a hypervisor, then there are
 376  * more options: we may already be running PAE, and the pagetable may
 377  * or may not be based in swapper_pg_dir.  In any case,
 378  * paravirt_pagetable_setup_start() will set up swapper_pg_dir
 379  * appropriately for the rest of the initialization to work.
 380  *
 381  * In general, pagetable_init() assumes that the pagetable may already
 382  * be partially populated, and so it avoids stomping on any existing
 383  * mappings.
 384  */
 385 static void __init pagetable_init(void)
 386 {
 387         pgd_t *pgd_base = swapper_pg_dir;
 388         unsigned long vaddr, end;
 389
 390         paravirt_pagetable_setup_start(pgd_base);
 391
 392         /* Enable PSE if available */
 393         if (cpu_has_pse)
 394                 set_in_cr4(X86_CR4_PSE);
 395
 396         /* Enable PGE if available */
 397         if (cpu_has_pge) {
 398                 set_in_cr4(X86_CR4_PGE);
 399                 __PAGE_KERNEL |= _PAGE_GLOBAL;
 400                 __PAGE_KERNEL_EXEC |= _PAGE_GLOBAL;
 401         }
 402
 403         kernel_physical_mapping_init(pgd_base);
 404         remap_numa_kva();
 405
 406         /*
 407          * Fixed mappings, only the page table structure has to be
 408          * created - mappings will be set by set_fixmap():
 409          */
 410         early_ioremap_clear();
 411         vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
 412         end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;
 413         page_table_range_init(vaddr, end, pgd_base);
 414         early_ioremap_reset();
 415
 416         permanent_kmaps_init(pgd_base);
 417
 418         paravirt_pagetable_setup_done(pgd_base);
 419 }
 420
 421 #ifdef CONFIG_ACPI_SLEEP
 422 /*
 423  * ACPI suspend needs this for resume, because things like the intel-agp
 424  * driver might have split up a kernel 4MB mapping.
 425  */
 426 char swsusp_pg_dir[PAGE_SIZE]
 427         __attribute__ ((aligned(PAGE_SIZE)));
 428
 429 static inline void save_pg_dir(void)
 430 {
 431         memcpy(swsusp_pg_dir, swapper_pg_dir, PAGE_SIZE);
 432 }
 433 #else /* !CONFIG_ACPI_SLEEP */
 434 static inline void save_pg_dir(void)
 435 {
 436 }
 437 #endif /* !CONFIG_ACPI_SLEEP */
 438
 439 void zap_low_mappings(void)
 440 {
 441         int i;
 442
 443         save_pg_dir();
 444
 445         /*
 446          * Zap initial low-memory mappings.
 447          *
 448          * Note that "pgd_clear()" doesn't do it for
 449          * us, because pgd_clear() is a no-op on i386.
 450          */
 451         for (i = 0; i < USER_PTRS_PER_PGD; i++) {
 452 #ifdef CONFIG_X86_PAE
 453                 set_pgd(swapper_pg_dir+i, __pgd(1 + __pa(empty_zero_page)));
 454 #else
 455                 set_pgd(swapper_pg_dir+i, __pgd(0));
 456 #endif
 457         }
 458         flush_tlb_all();
 459 }
 460
 461 int nx_enabled;
 462
 463 pteval_t __supported_pte_mask __read_mostly = ~_PAGE_NX;
 464 EXPORT_SYMBOL_GPL(__supported_pte_mask);
 465
 466 #ifdef CONFIG_X86_PAE
 467
 468 static int disable_nx __initdata;
 469
 470 /*
 471  * noexec = on|off
 472  *
 473  * Control non executable mappings.
 474  *
 475  * on      Enable
 476  * off     Disable
 477  */
 478 static int __init noexec_setup(char *str)
 479 {
 480         if (!str || !strcmp(str, "on")) {
 481                 if (cpu_has_nx) {
 482                         __supported_pte_mask |= _PAGE_NX;
 483                         disable_nx = 0;
 484                 }
 485         } else {
 486                 if (!strcmp(str, "off")) {
 487                         disable_nx = 1;
 488                         __supported_pte_mask &= ~_PAGE_NX;
 489                 } else {
 490                         return -EINVAL;
 491                 }
 492         }
 493
 494         return 0;
 495 }
 496 early_param("noexec", noexec_setup);
 497
 498 static void __init set_nx(void)
 499 {
 500         unsigned int v[4], l, h;
 501
 502         if (cpu_has_pae && (cpuid_eax(0x80000000) > 0x80000001)) {
 503                 cpuid(0x80000001, &v[0], &v[1], &v[2], &v[3]);
 504
 505                 if ((v[3] & (1 << 20)) && !disable_nx) {
 506                         rdmsr(MSR_EFER, l, h);
 507                         l |= EFER_NX;
 508                         wrmsr(MSR_EFER, l, h);
 509                         nx_enabled = 1;
 510                         __supported_pte_mask |= _PAGE_NX;
 511                 }
 512         }
 513 }
 514 #endif
 515
 516 /*
 517  * paging_init() sets up the page tables - note that the first 8MB are
 518  * already mapped by head.S.
 519  *
 520  * This routines also unmaps the page at virtual kernel address 0, so
 521  * that we can trap those pesky NULL-reference errors in the kernel.
 522  */
 523 void __init paging_init(void)
 524 {
 525 #ifdef CONFIG_X86_PAE
 526         set_nx();
 527         if (nx_enabled)
 528                 printk(KERN_INFO "NX (Execute Disable) protection: active\n");
 529 #endif
 530         pagetable_init();
 531
 532         load_cr3(swapper_pg_dir);
 533
 534         __flush_tlb_all();
 535
 536         kmap_init();
 537 }
 538
 539 /*
 540  * Test if the WP bit works in supervisor mode. It isn't supported on 386's
 541  * and also on some strange 486's (NexGen etc.). All 586+'s are OK. This
 542  * used to involve black magic jumps to work around some nasty CPU bugs,
 543  * but fortunately the switch to using exceptions got rid of all that.
 544  */
 545 static void __init test_wp_bit(void)
 546 {
 547         printk(KERN_INFO
 548   "Checking if this processor honours the WP bit even in supervisor mode...");
 549
 550         /* Any page-aligned address will do, the test is non-destructive */
 551         __set_fixmap(FIX_WP_TEST, __pa(&swapper_pg_dir), PAGE_READONLY);
 552         boot_cpu_data.wp_works_ok = do_test_wp_bit();
 553         clear_fixmap(FIX_WP_TEST);
 554
 555         if (!boot_cpu_data.wp_works_ok) {
 556                 printk(KERN_CONT "No.\n");
 557 #ifdef CONFIG_X86_WP_WORKS_OK
 558                 panic(
 559   "This kernel doesn't support CPU's with broken WP. Recompile it for a 386!");
 560 #endif
 561         } else {
 562                 printk(KERN_CONT "Ok.\n");
 563         }
 564 }
 565
 566 static struct kcore_list kcore_mem, kcore_vmalloc;
 567
 568 void __init mem_init(void)
 569 {
 570         int codesize, reservedpages, datasize, initsize;
 571         int tmp, bad_ppro;
 572
 573 #ifdef CONFIG_FLATMEM
 574         BUG_ON(!mem_map);
 575 #endif
 576         bad_ppro = ppro_with_ram_bug();
 577
 578 #ifdef CONFIG_HIGHMEM
 579         /* check that fixmap and pkmap do not overlap */
 580         if (PKMAP_BASE + LAST_PKMAP*PAGE_SIZE >= FIXADDR_START) {
 581                 printk(KERN_ERR
 582                         "fixmap and kmap areas overlap - this will crash\n");
 583                 printk(KERN_ERR "pkstart: %lxh pkend: %lxh fixstart %lxh\n",
 584                                 PKMAP_BASE, PKMAP_BASE + LAST_PKMAP*PAGE_SIZE,
 585                                 FIXADDR_START);
 586                 BUG();
 587         }
 588 #endif
 589         /* this will put all low memory onto the freelists */
 590         totalram_pages += free_all_bootmem();
 591
 592         reservedpages = 0;
 593         for (tmp = 0; tmp < max_low_pfn; tmp++)
 594                 /*
 595                  * Only count reserved RAM pages:
 596                  */
 597                 if (page_is_ram(tmp) && PageReserved(pfn_to_page(tmp)))
 598                         reservedpages++;
 599
 600         set_highmem_pages_init(bad_ppro);
 601
 602         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 603         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 604         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 605
 606         kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 607         kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 608                    VMALLOC_END-VMALLOC_START);
 609
 610         printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, "
 611                         "%dk reserved, %dk data, %dk init, %ldk highmem)\n",
 612                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 613                 num_physpages << (PAGE_SHIFT-10),
 614                 codesize >> 10,
 615                 reservedpages << (PAGE_SHIFT-10),
 616                 datasize >> 10,
 617                 initsize >> 10,
 618                 (unsigned long) (totalhigh_pages << (PAGE_SHIFT-10))
 619                );
 620
 621 #if 1 /* double-sanity-check paranoia */
 622         printk(KERN_INFO "virtual kernel memory layout:\n"
 623                 "    fixmap  : 0x%08lx - 0x%08lx   (%4ld kB)\n"
 624 #ifdef CONFIG_HIGHMEM
 625                 "    pkmap   : 0x%08lx - 0x%08lx   (%4ld kB)\n"
 626 #endif
 627                 "    vmalloc : 0x%08lx - 0x%08lx   (%4ld MB)\n"
 628                 "    lowmem  : 0x%08lx - 0x%08lx   (%4ld MB)\n"
 629                 "      .init : 0x%08lx - 0x%08lx   (%4ld kB)\n"
 630                 "      .data : 0x%08lx - 0x%08lx   (%4ld kB)\n"
 631                 "      .text : 0x%08lx - 0x%08lx   (%4ld kB)\n",
 632                 FIXADDR_START, FIXADDR_TOP,
 633                 (FIXADDR_TOP - FIXADDR_START) >> 10,
 634
 635 #ifdef CONFIG_HIGHMEM
 636                 PKMAP_BASE, PKMAP_BASE+LAST_PKMAP*PAGE_SIZE,
 637                 (LAST_PKMAP*PAGE_SIZE) >> 10,
 638 #endif
 639
 640                 VMALLOC_START, VMALLOC_END,
 641                 (VMALLOC_END - VMALLOC_START) >> 20,
 642
 643                 (unsigned long)__va(0), (unsigned long)high_memory,
 644                 ((unsigned long)high_memory - (unsigned long)__va(0)) >> 20,
 645
 646                 (unsigned long)&__init_begin, (unsigned long)&__init_end,
 647                 ((unsigned long)&__init_end -
 648                  (unsigned long)&__init_begin) >> 10,
 649
 650                 (unsigned long)&_etext, (unsigned long)&_edata,
 651                 ((unsigned long)&_edata - (unsigned long)&_etext) >> 10,
 652
 653                 (unsigned long)&_text, (unsigned long)&_etext,
 654                 ((unsigned long)&_etext - (unsigned long)&_text) >> 10);
 655
 656 #ifdef CONFIG_HIGHMEM
 657         BUG_ON(PKMAP_BASE + LAST_PKMAP*PAGE_SIZE        > FIXADDR_START);
 658         BUG_ON(VMALLOC_END                              > PKMAP_BASE);
 659 #endif
 660         BUG_ON(VMALLOC_START                            > VMALLOC_END);
 661         BUG_ON((unsigned long)high_memory               > VMALLOC_START);
 662 #endif /* double-sanity-check paranoia */
 663
 664         if (boot_cpu_data.wp_works_ok < 0)
 665                 test_wp_bit();
 666
 667         cpa_init();
 668
 669         /*
 670          * Subtle. SMP is doing it's boot stuff late (because it has to
 671          * fork idle threads) - but it also needs low mappings for the
 672          * protected-mode entry to work. We zap these entries only after
 673          * the WP-bit has been tested.
 674          */
 675 #ifndef CONFIG_SMP
 676         zap_low_mappings();
 677 #endif
 678 }
 679
 680 #ifdef CONFIG_MEMORY_HOTPLUG
 681 int arch_add_memory(int nid, u64 start, u64 size)
 682 {
 683         struct pglist_data *pgdata = NODE_DATA(nid);
 684         struct zone *zone = pgdata->node_zones + ZONE_HIGHMEM;
 685         unsigned long start_pfn = start >> PAGE_SHIFT;
 686         unsigned long nr_pages = size >> PAGE_SHIFT;
 687
 688         return __add_pages(zone, start_pfn, nr_pages);
 689 }
 690 #endif
 691
 692 /*
 693  * This function cannot be __init, since exceptions don't work in that
 694  * section.  Put this after the callers, so that it cannot be inlined.
 695  */
 696 static noinline int do_test_wp_bit(void)
 697 {
 698         char tmp_reg;
 699         int flag;
 700
 701         __asm__ __volatile__(
 702                 "       movb %0, %1     \n"
 703                 "1:     movb %1, %0     \n"
 704                 "       xorl %2, %2     \n"
 705                 "2:                     \n"
 706                 _ASM_EXTABLE(1b,2b)
 707                 :"=m" (*(char *)fix_to_virt(FIX_WP_TEST)),
 708                  "=q" (tmp_reg),
 709                  "=r" (flag)
 710                 :"2" (1)
 711                 :"memory");
 712
 713         return flag;
 714 }
 715
 716 #ifdef CONFIG_DEBUG_RODATA
 717 const int rodata_test_data = 0xC3;
 718 EXPORT_SYMBOL_GPL(rodata_test_data);
 719
 720 void mark_rodata_ro(void)
 721 {
 722         unsigned long start = PFN_ALIGN(_text);
 723         unsigned long size = PFN_ALIGN(_etext) - start;
 724
 725 #ifndef CONFIG_KPROBES
 726 #ifdef CONFIG_HOTPLUG_CPU
 727         /* It must still be possible to apply SMP alternatives. */
 728         if (num_possible_cpus() <= 1)
 729 #endif
 730         {
 731                 set_pages_ro(virt_to_page(start), size >> PAGE_SHIFT);
 732                 printk(KERN_INFO "Write protecting the kernel text: %luk\n",
 733                         size >> 10);
 734
 735 #ifdef CONFIG_CPA_DEBUG
 736                 printk(KERN_INFO "Testing CPA: Reverting %lx-%lx\n",
 737                         start, start+size);
 738                 set_pages_rw(virt_to_page(start), size>>PAGE_SHIFT);
 739
 740                 printk(KERN_INFO "Testing CPA: write protecting again\n");
 741                 set_pages_ro(virt_to_page(start), size>>PAGE_SHIFT);
 742 #endif
 743         }
 744 #endif
 745         start += size;
 746         size = (unsigned long)__end_rodata - start;
 747         set_pages_ro(virt_to_page(start), size >> PAGE_SHIFT);
 748         printk(KERN_INFO "Write protecting the kernel read-only data: %luk\n",
 749                 size >> 10);
 750         rodata_test();
 751
 752 #ifdef CONFIG_CPA_DEBUG
 753         printk(KERN_INFO "Testing CPA: undo %lx-%lx\n", start, start + size);
 754         set_pages_rw(virt_to_page(start), size >> PAGE_SHIFT);
 755
 756         printk(KERN_INFO "Testing CPA: write protecting again\n");
 757         set_pages_ro(virt_to_page(start), size >> PAGE_SHIFT);
 758 #endif
 759 }
 760 #endif
 761
 762 void free_init_pages(char *what, unsigned long begin, unsigned long end)
 763 {
 764 #ifdef CONFIG_DEBUG_PAGEALLOC
 765         /*
 766          * If debugging page accesses then do not free this memory but
 767          * mark them not present - any buggy init-section access will
 768          * create a kernel page fault:
 769          */
 770         printk(KERN_INFO "debug: unmapping init memory %08lx..%08lx\n",
 771                 begin, PAGE_ALIGN(end));
 772         set_memory_np(begin, (end - begin) >> PAGE_SHIFT);
 773 #else
 774         unsigned long addr;
 775
 776         /*
 777          * We just marked the kernel text read only above, now that
 778          * we are going to free part of that, we need to make that
 779          * writeable first.
 780          */
 781         set_memory_rw(begin, (end - begin) >> PAGE_SHIFT);
 782
 783         for (addr = begin; addr < end; addr += PAGE_SIZE) {
 784                 ClearPageReserved(virt_to_page(addr));
 785                 init_page_count(virt_to_page(addr));
 786                 memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE);
 787                 free_page(addr);
 788                 totalram_pages++;
 789         }
 790         printk(KERN_INFO "Freeing %s: %luk freed\n", what, (end - begin) >> 10);
 791 #endif
 792 }
 793
 794 void free_initmem(void)
 795 {
 796         free_init_pages("unused kernel memory",
 797                         (unsigned long)(&__init_begin),
 798                         (unsigned long)(&__init_end));
 799 }
 800
 801 #ifdef CONFIG_BLK_DEV_INITRD
 802 void free_initrd_mem(unsigned long start, unsigned long end)
 803 {
 804         free_init_pages("initrd memory", start, end);
 805 }
 806 #endif