arch/x86_64/mm/init.c

   1 /*
   2  *  linux/arch/x86_64/mm/init.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  *  Copyright (C) 2000  Pavel Machek <pavel@suse.cz>
   6  *  Copyright (C) 2002,2003 Andi Kleen <ak@suse.de>
   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/swap.h>
  20 #include <linux/smp.h>
  21 #include <linux/init.h>
  22 #include <linux/pagemap.h>
  23 #include <linux/bootmem.h>
  24 #include <linux/proc_fs.h>
  25 #include <linux/pci.h>
  26 #include <linux/poison.h>
  27 #include <linux/dma-mapping.h>
  28 #include <linux/module.h>
  29 #include <linux/memory_hotplug.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/fixmap.h>
  38 #include <asm/e820.h>
  39 #include <asm/apic.h>
  40 #include <asm/tlb.h>
  41 #include <asm/mmu_context.h>
  42 #include <asm/proto.h>
  43 #include <asm/smp.h>
  44 #include <asm/sections.h>
  45
  46 #ifndef Dprintk
  47 #define Dprintk(x...)
  48 #endif
  49
  50 struct dma_mapping_ops* dma_ops;
  51 EXPORT_SYMBOL(dma_ops);
  52
  53 static unsigned long dma_reserve __initdata;
  54
  55 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
  56
  57 /*
  58  * NOTE: pagetable_init alloc all the fixmap pagetables contiguous on the
  59  * physical space so we can cache the place of the first one and move
  60  * around without checking the pgd every time.
  61  */
  62
  63 void show_mem(void)
  64 {
  65         long i, total = 0, reserved = 0;
  66         long shared = 0, cached = 0;
  67         pg_data_t *pgdat;
  68         struct page *page;
  69
  70         printk(KERN_INFO "Mem-info:\n");
  71         show_free_areas();
  72         printk(KERN_INFO "Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
  73
  74         for_each_online_pgdat(pgdat) {
  75                for (i = 0; i < pgdat->node_spanned_pages; ++i) {
  76                         page = pfn_to_page(pgdat->node_start_pfn + i);
  77                         total++;
  78                         if (PageReserved(page))
  79                                 reserved++;
  80                         else if (PageSwapCache(page))
  81                                 cached++;
  82                         else if (page_count(page))
  83                                 shared += page_count(page) - 1;
  84                }
  85         }
  86         printk(KERN_INFO "%lu pages of RAM\n", total);
  87         printk(KERN_INFO "%lu reserved pages\n",reserved);
  88         printk(KERN_INFO "%lu pages shared\n",shared);
  89         printk(KERN_INFO "%lu pages swap cached\n",cached);
  90 }
  91
  92 int after_bootmem;
  93
  94 static __init void *spp_getpage(void)
  95 {
  96         void *ptr;
  97         if (after_bootmem)
  98                 ptr = (void *) get_zeroed_page(GFP_ATOMIC);
  99         else
 100                 ptr = alloc_bootmem_pages(PAGE_SIZE);
 101         if (!ptr || ((unsigned long)ptr & ~PAGE_MASK))
 102                 panic("set_pte_phys: cannot allocate page data %s\n", after_bootmem?"after bootmem":"");
 103
 104         Dprintk("spp_getpage %p\n", ptr);
 105         return ptr;
 106 }
 107
 108 static __init void set_pte_phys(unsigned long vaddr,
 109                          unsigned long phys, pgprot_t prot)
 110 {
 111         pgd_t *pgd;
 112         pud_t *pud;
 113         pmd_t *pmd;
 114         pte_t *pte, new_pte;
 115
 116         Dprintk("set_pte_phys %lx to %lx\n", vaddr, phys);
 117
 118         pgd = pgd_offset_k(vaddr);
 119         if (pgd_none(*pgd)) {
 120                 printk("PGD FIXMAP MISSING, it should be setup in head.S!\n");
 121                 return;
 122         }
 123         pud = pud_offset(pgd, vaddr);
 124         if (pud_none(*pud)) {
 125                 pmd = (pmd_t *) spp_getpage();
 126                 set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
 127                 if (pmd != pmd_offset(pud, 0)) {
 128                         printk("PAGETABLE BUG #01! %p <-> %p\n", pmd, pmd_offset(pud,0));
 129                         return;
 130                 }
 131         }
 132         pmd = pmd_offset(pud, vaddr);
 133         if (pmd_none(*pmd)) {
 134                 pte = (pte_t *) spp_getpage();
 135                 set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE | _PAGE_USER));
 136                 if (pte != pte_offset_kernel(pmd, 0)) {
 137                         printk("PAGETABLE BUG #02!\n");
 138                         return;
 139                 }
 140         }
 141         new_pte = pfn_pte(phys >> PAGE_SHIFT, prot);
 142
 143         pte = pte_offset_kernel(pmd, vaddr);
 144         if (!pte_none(*pte) &&
 145             pte_val(*pte) != (pte_val(new_pte) & __supported_pte_mask))
 146                 pte_ERROR(*pte);
 147         set_pte(pte, new_pte);
 148
 149         /*
 150          * It's enough to flush this one mapping.
 151          * (PGE mappings get flushed as well)
 152          */
 153         __flush_tlb_one(vaddr);
 154 }
 155
 156 /* NOTE: this is meant to be run only at boot */
 157 void __init
 158 __set_fixmap (enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
 159 {
 160         unsigned long address = __fix_to_virt(idx);
 161
 162         if (idx >= __end_of_fixed_addresses) {
 163                 printk("Invalid __set_fixmap\n");
 164                 return;
 165         }
 166         set_pte_phys(address, phys, prot);
 167 }
 168
 169 unsigned long __initdata table_start, table_end;
 170
 171 extern pmd_t temp_boot_pmds[];
 172
 173 static  struct temp_map {
 174         pmd_t *pmd;
 175         void  *address;
 176         int    allocated;
 177 } temp_mappings[] __initdata = {
 178         { &temp_boot_pmds[0], (void *)(40UL * 1024 * 1024) },
 179         { &temp_boot_pmds[1], (void *)(42UL * 1024 * 1024) },
 180         {}
 181 };
 182
 183 static __meminit void *alloc_low_page(int *index, unsigned long *phys)
 184 {
 185         struct temp_map *ti;
 186         int i;
 187         unsigned long pfn = table_end++, paddr;
 188         void *adr;
 189
 190         if (after_bootmem) {
 191                 adr = (void *)get_zeroed_page(GFP_ATOMIC);
 192                 *phys = __pa(adr);
 193                 return adr;
 194         }
 195
 196         if (pfn >= end_pfn)
 197                 panic("alloc_low_page: ran out of memory");
 198         for (i = 0; temp_mappings[i].allocated; i++) {
 199                 if (!temp_mappings[i].pmd)
 200                         panic("alloc_low_page: ran out of temp mappings");
 201         }
 202         ti = &temp_mappings[i];
 203         paddr = (pfn << PAGE_SHIFT) & PMD_MASK;
 204         set_pmd(ti->pmd, __pmd(paddr | _KERNPG_TABLE | _PAGE_PSE));
 205         ti->allocated = 1;
 206         __flush_tlb();
 207         adr = ti->address + ((pfn << PAGE_SHIFT) & ~PMD_MASK);
 208         memset(adr, 0, PAGE_SIZE);
 209         *index = i;
 210         *phys  = pfn * PAGE_SIZE;
 211         return adr;
 212 }
 213
 214 static __meminit void unmap_low_page(int i)
 215 {
 216         struct temp_map *ti;
 217
 218         if (after_bootmem)
 219                 return;
 220
 221         ti = &temp_mappings[i];
 222         set_pmd(ti->pmd, __pmd(0));
 223         ti->allocated = 0;
 224 }
 225
 226 /* Must run before zap_low_mappings */
 227 __init void *early_ioremap(unsigned long addr, unsigned long size)
 228 {
 229         unsigned long map = round_down(addr, LARGE_PAGE_SIZE);
 230
 231         /* actually usually some more */
 232         if (size >= LARGE_PAGE_SIZE) {
 233                 return NULL;
 234         }
 235         set_pmd(temp_mappings[0].pmd,  __pmd(map | _KERNPG_TABLE | _PAGE_PSE));
 236         map += LARGE_PAGE_SIZE;
 237         set_pmd(temp_mappings[1].pmd,  __pmd(map | _KERNPG_TABLE | _PAGE_PSE));
 238         __flush_tlb();
 239         return temp_mappings[0].address + (addr & (LARGE_PAGE_SIZE-1));
 240 }
 241
 242 /* To avoid virtual aliases later */
 243 __init void early_iounmap(void *addr, unsigned long size)
 244 {
 245         if ((void *)round_down((unsigned long)addr, LARGE_PAGE_SIZE) != temp_mappings[0].address)
 246                 printk("early_iounmap: bad address %p\n", addr);
 247         set_pmd(temp_mappings[0].pmd, __pmd(0));
 248         set_pmd(temp_mappings[1].pmd, __pmd(0));
 249         __flush_tlb();
 250 }
 251
 252 static void __meminit
 253 phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end)
 254 {
 255         int i = pmd_index(address);
 256
 257         for (; i < PTRS_PER_PMD; i++, address += PMD_SIZE) {
 258                 unsigned long entry;
 259                 pmd_t *pmd = pmd_page + pmd_index(address);
 260
 261                 if (address >= end) {
 262                         if (!after_bootmem)
 263                                 for (; i < PTRS_PER_PMD; i++, pmd++)
 264                                         set_pmd(pmd, __pmd(0));
 265                         break;
 266                 }
 267
 268                 if (pmd_val(*pmd))
 269                         continue;
 270
 271                 entry = _PAGE_NX|_PAGE_PSE|_KERNPG_TABLE|_PAGE_GLOBAL|address;
 272                 entry &= __supported_pte_mask;
 273                 set_pmd(pmd, __pmd(entry));
 274         }
 275 }
 276
 277 static void __meminit
 278 phys_pmd_update(pud_t *pud, unsigned long address, unsigned long end)
 279 {
 280         pmd_t *pmd = pmd_offset(pud,0);
 281         spin_lock(&init_mm.page_table_lock);
 282         phys_pmd_init(pmd, address, end);
 283         spin_unlock(&init_mm.page_table_lock);
 284         __flush_tlb_all();
 285 }
 286
 287 static void __meminit phys_pud_init(pud_t *pud_page, unsigned long addr, unsigned long end)
 288 {
 289         int i = pud_index(addr);
 290
 291
 292         for (; i < PTRS_PER_PUD; i++, addr = (addr & PUD_MASK) + PUD_SIZE ) {
 293                 int map;
 294                 unsigned long pmd_phys;
 295                 pud_t *pud = pud_page + pud_index(addr);
 296                 pmd_t *pmd;
 297
 298                 if (addr >= end)
 299                         break;
 300
 301                 if (!after_bootmem && !e820_any_mapped(addr,addr+PUD_SIZE,0)) {
 302                         set_pud(pud, __pud(0));
 303                         continue;
 304                 }
 305
 306                 if (pud_val(*pud)) {
 307                         phys_pmd_update(pud, addr, end);
 308                         continue;
 309                 }
 310
 311                 pmd = alloc_low_page(&map, &pmd_phys);
 312                 spin_lock(&init_mm.page_table_lock);
 313                 set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
 314                 phys_pmd_init(pmd, addr, end);
 315                 spin_unlock(&init_mm.page_table_lock);
 316                 unmap_low_page(map);
 317         }
 318         __flush_tlb();
 319 }
 320
 321 static void __init find_early_table_space(unsigned long end)
 322 {
 323         unsigned long puds, pmds, tables, start;
 324
 325         puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
 326         pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
 327         tables = round_up(puds * sizeof(pud_t), PAGE_SIZE) +
 328                  round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
 329
 330         /* RED-PEN putting page tables only on node 0 could
 331            cause a hotspot and fill up ZONE_DMA. The page tables
 332            need roughly 0.5KB per GB. */
 333         start = 0x8000;
 334         table_start = find_e820_area(start, end, tables);
 335         if (table_start == -1UL)
 336                 panic("Cannot find space for the kernel page tables");
 337
 338         table_start >>= PAGE_SHIFT;
 339         table_end = table_start;
 340 }
 341
 342 /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
 343    This runs before bootmem is initialized and gets pages directly from the
 344    physical memory. To access them they are temporarily mapped. */
 345 void __meminit init_memory_mapping(unsigned long start, unsigned long end)
 346 {
 347         unsigned long next;
 348
 349         Dprintk("init_memory_mapping\n");
 350
 351         /*
 352          * Find space for the kernel direct mapping tables.
 353          * Later we should allocate these tables in the local node of the memory
 354          * mapped.  Unfortunately this is done currently before the nodes are
 355          * discovered.
 356          */
 357         if (!after_bootmem)
 358                 find_early_table_space(end);
 359
 360         start = (unsigned long)__va(start);
 361         end = (unsigned long)__va(end);
 362
 363         for (; start < end; start = next) {
 364                 int map;
 365                 unsigned long pud_phys;
 366                 pgd_t *pgd = pgd_offset_k(start);
 367                 pud_t *pud;
 368
 369                 if (after_bootmem)
 370                         pud = pud_offset(pgd, start & PGDIR_MASK);
 371                 else
 372                         pud = alloc_low_page(&map, &pud_phys);
 373
 374                 next = start + PGDIR_SIZE;
 375                 if (next > end)
 376                         next = end;
 377                 phys_pud_init(pud, __pa(start), __pa(next));
 378                 if (!after_bootmem)
 379                         set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
 380                 unmap_low_page(map);
 381         }
 382
 383         if (!after_bootmem)
 384                 asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
 385         __flush_tlb_all();
 386 }
 387
 388 void __cpuinit zap_low_mappings(int cpu)
 389 {
 390         if (cpu == 0) {
 391                 pgd_t *pgd = pgd_offset_k(0UL);
 392                 pgd_clear(pgd);
 393         } else {
 394                 /*
 395                  * For AP's, zap the low identity mappings by changing the cr3
 396                  * to init_level4_pgt and doing local flush tlb all
 397                  */
 398                 asm volatile("movq %0,%%cr3" :: "r" (__pa_symbol(&init_level4_pgt)));
 399         }
 400         __flush_tlb_all();
 401 }
 402
 403 #ifndef CONFIG_NUMA
 404 void __init paging_init(void)
 405 {
 406         unsigned long max_zone_pfns[MAX_NR_ZONES];
 407         memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
 408         max_zone_pfns[ZONE_DMA] = MAX_DMA_PFN;
 409         max_zone_pfns[ZONE_DMA32] = MAX_DMA32_PFN;
 410         max_zone_pfns[ZONE_NORMAL] = end_pfn;
 411
 412         memory_present(0, 0, end_pfn);
 413         sparse_init();
 414         free_area_init_nodes(max_zone_pfns);
 415 }
 416 #endif
 417
 418 /* Unmap a kernel mapping if it exists. This is useful to avoid prefetches
 419    from the CPU leading to inconsistent cache lines. address and size
 420    must be aligned to 2MB boundaries.
 421    Does nothing when the mapping doesn't exist. */
 422 void __init clear_kernel_mapping(unsigned long address, unsigned long size)
 423 {
 424         unsigned long end = address + size;
 425
 426         BUG_ON(address & ~LARGE_PAGE_MASK);
 427         BUG_ON(size & ~LARGE_PAGE_MASK);
 428
 429         for (; address < end; address += LARGE_PAGE_SIZE) {
 430                 pgd_t *pgd = pgd_offset_k(address);
 431                 pud_t *pud;
 432                 pmd_t *pmd;
 433                 if (pgd_none(*pgd))
 434                         continue;
 435                 pud = pud_offset(pgd, address);
 436                 if (pud_none(*pud))
 437                         continue;
 438                 pmd = pmd_offset(pud, address);
 439                 if (!pmd || pmd_none(*pmd))
 440                         continue;
 441                 if (0 == (pmd_val(*pmd) & _PAGE_PSE)) {
 442                         /* Could handle this, but it should not happen currently. */
 443                         printk(KERN_ERR
 444                "clear_kernel_mapping: mapping has been split. will leak memory\n");
 445                         pmd_ERROR(*pmd);
 446                 }
 447                 set_pmd(pmd, __pmd(0));
 448         }
 449         __flush_tlb_all();
 450 }
 451
 452 static inline int page_is_ram (unsigned long pagenr)
 453 {
 454         int i;
 455
 456         for (i = 0; i < e820.nr_map; i++) {
 457                 unsigned long addr, end;
 458
 459                 if (e820.map[i].type != E820_RAM)       /* not usable memory */
 460                         continue;
 461                 /*
 462                  * !!!FIXME!!! Some BIOSen report areas as RAM that
 463                  * are not. Notably the 640->1Mb area. We need a sanity
 464                  * check here.
 465                  */
 466                 addr = (e820.map[i].addr+PAGE_SIZE-1) >> PAGE_SHIFT;
 467                 end = (e820.map[i].addr+e820.map[i].size) >> PAGE_SHIFT;
 468                 if  ((pagenr >= addr) && (pagenr < end))
 469                         return 1;
 470         }
 471         return 0;
 472 }
 473
 474 /*
 475  * Memory hotplug specific functions
 476  */
 477 void online_page(struct page *page)
 478 {
 479         ClearPageReserved(page);
 480         init_page_count(page);
 481         __free_page(page);
 482         totalram_pages++;
 483         num_physpages++;
 484 }
 485
 486 #ifdef CONFIG_MEMORY_HOTPLUG
 487 /*
 488  * Memory is added always to NORMAL zone. This means you will never get
 489  * additional DMA/DMA32 memory.
 490  */
 491 int arch_add_memory(int nid, u64 start, u64 size)
 492 {
 493         struct pglist_data *pgdat = NODE_DATA(nid);
 494         struct zone *zone = pgdat->node_zones + ZONE_NORMAL;
 495         unsigned long start_pfn = start >> PAGE_SHIFT;
 496         unsigned long nr_pages = size >> PAGE_SHIFT;
 497         int ret;
 498
 499         init_memory_mapping(start, (start + size -1));
 500
 501         ret = __add_pages(zone, start_pfn, nr_pages);
 502         if (ret)
 503                 goto error;
 504
 505         return ret;
 506 error:
 507         printk("%s: Problem encountered in __add_pages!\n", __func__);
 508         return ret;
 509 }
 510 EXPORT_SYMBOL_GPL(arch_add_memory);
 511
 512 int remove_memory(u64 start, u64 size)
 513 {
 514         return -EINVAL;
 515 }
 516 EXPORT_SYMBOL_GPL(remove_memory);
 517
 518 #if !defined(CONFIG_ACPI_NUMA) && defined(CONFIG_NUMA)
 519 int memory_add_physaddr_to_nid(u64 start)
 520 {
 521         return 0;
 522 }
 523 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
 524 #endif
 525
 526 #endif /* CONFIG_MEMORY_HOTPLUG */
 527
 528 #ifdef CONFIG_MEMORY_HOTPLUG_RESERVE
 529 /*
 530  * Memory Hotadd without sparsemem. The mem_maps have been allocated in advance,
 531  * just online the pages.
 532  */
 533 int __add_pages(struct zone *z, unsigned long start_pfn, unsigned long nr_pages)
 534 {
 535         int err = -EIO;
 536         unsigned long pfn;
 537         unsigned long total = 0, mem = 0;
 538         for (pfn = start_pfn; pfn < start_pfn + nr_pages; pfn++) {
 539                 if (pfn_valid(pfn)) {
 540                         online_page(pfn_to_page(pfn));
 541                         err = 0;
 542                         mem++;
 543                 }
 544                 total++;
 545         }
 546         if (!err) {
 547                 z->spanned_pages += total;
 548                 z->present_pages += mem;
 549                 z->zone_pgdat->node_spanned_pages += total;
 550                 z->zone_pgdat->node_present_pages += mem;
 551         }
 552         return err;
 553 }
 554 #endif
 555
 556 /*
 557  * devmem_is_allowed() checks to see if /dev/mem access to a certain address is
 558  * valid. The argument is a physical page number.
 559  *
 560  *
 561  * On x86-64, access has to be given to the first megabyte of ram because that area
 562  * contains bios code and data regions used by X and dosemu and similar apps.
 563  * Access has to be given to non-kernel-ram areas as well, these contain the PCI
 564  * mmio resources as well as potential bios/acpi data regions.
 565  */
 566 int devmem_is_allowed(unsigned long pagenr)
 567 {
 568         if (pagenr <= 256)
 569                 return 1;
 570         if (!page_is_ram(pagenr))
 571                 return 1;
 572         return 0;
 573 }
 574
 575
 576 EXPORT_SYMBOL_GPL(page_is_ram);
 577
 578 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
 579                          kcore_vsyscall;
 580
 581 void __init mem_init(void)
 582 {
 583         long codesize, reservedpages, datasize, initsize;
 584
 585         pci_iommu_alloc();
 586
 587         /* clear the zero-page */
 588         memset(empty_zero_page, 0, PAGE_SIZE);
 589
 590         reservedpages = 0;
 591
 592         /* this will put all low memory onto the freelists */
 593 #ifdef CONFIG_NUMA
 594         totalram_pages = numa_free_all_bootmem();
 595 #else
 596         totalram_pages = free_all_bootmem();
 597 #endif
 598         reservedpages = end_pfn - totalram_pages -
 599                                         absent_pages_in_range(0, end_pfn);
 600
 601         after_bootmem = 1;
 602
 603         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 604         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 605         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 606
 607         /* Register memory areas for /proc/kcore */
 608         kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 609         kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 610                    VMALLOC_END-VMALLOC_START);
 611         kclist_add(&kcore_kernel, &_stext, _end - _stext);
 612         kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
 613         kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START,
 614                                  VSYSCALL_END - VSYSCALL_START);
 615
 616         printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n",
 617                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 618                 end_pfn << (PAGE_SHIFT-10),
 619                 codesize >> 10,
 620                 reservedpages << (PAGE_SHIFT-10),
 621                 datasize >> 10,
 622                 initsize >> 10);
 623
 624 #ifdef CONFIG_SMP
 625         /*
 626          * Sync boot_level4_pgt mappings with the init_level4_pgt
 627          * except for the low identity mappings which are already zapped
 628          * in init_level4_pgt. This sync-up is essential for AP's bringup
 629          */
 630         memcpy(boot_level4_pgt+1, init_level4_pgt+1, (PTRS_PER_PGD-1)*sizeof(pgd_t));
 631 #endif
 632 }
 633
 634 void free_init_pages(char *what, unsigned long begin, unsigned long end)
 635 {
 636         unsigned long addr;
 637
 638         if (begin >= end)
 639                 return;
 640
 641         printk(KERN_INFO "Freeing %s: %ldk freed\n", what, (end - begin) >> 10);
 642         for (addr = begin; addr < end; addr += PAGE_SIZE) {
 643                 ClearPageReserved(virt_to_page(addr));
 644                 init_page_count(virt_to_page(addr));
 645                 memset((void *)(addr & ~(PAGE_SIZE-1)),
 646                         POISON_FREE_INITMEM, PAGE_SIZE);
 647                 free_page(addr);
 648                 totalram_pages++;
 649         }
 650 }
 651
 652 void free_initmem(void)
 653 {
 654         memset(__initdata_begin, POISON_FREE_INITDATA,
 655                 __initdata_end - __initdata_begin);
 656         free_init_pages("unused kernel memory",
 657                         (unsigned long)(&__init_begin),
 658                         (unsigned long)(&__init_end));
 659 }
 660
 661 #ifdef CONFIG_DEBUG_RODATA
 662
 663 void mark_rodata_ro(void)
 664 {
 665         unsigned long addr = (unsigned long)__start_rodata;
 666
 667         for (; addr < (unsigned long)__end_rodata; addr += PAGE_SIZE)
 668                 change_page_attr_addr(addr, 1, PAGE_KERNEL_RO);
 669
 670         printk ("Write protecting the kernel read-only data: %luk\n",
 671                         (__end_rodata - __start_rodata) >> 10);
 672
 673         /*
 674          * change_page_attr_addr() requires a global_flush_tlb() call after it.
 675          * We do this after the printk so that if something went wrong in the
 676          * change, the printk gets out at least to give a better debug hint
 677          * of who is the culprit.
 678          */
 679         global_flush_tlb();
 680 }
 681 #endif
 682
 683 #ifdef CONFIG_BLK_DEV_INITRD
 684 void free_initrd_mem(unsigned long start, unsigned long end)
 685 {
 686         free_init_pages("initrd memory", start, end);
 687 }
 688 #endif
 689
 690 void __init reserve_bootmem_generic(unsigned long phys, unsigned len)
 691 {
 692 #ifdef CONFIG_NUMA
 693         int nid = phys_to_nid(phys);
 694 #endif
 695         unsigned long pfn = phys >> PAGE_SHIFT;
 696         if (pfn >= end_pfn) {
 697                 /* This can happen with kdump kernels when accessing firmware
 698                    tables. */
 699                 if (pfn < end_pfn_map)
 700                         return;
 701                 printk(KERN_ERR "reserve_bootmem: illegal reserve %lx %u\n",
 702                                 phys, len);
 703                 return;
 704         }
 705
 706         /* Should check here against the e820 map to avoid double free */
 707 #ifdef CONFIG_NUMA
 708         reserve_bootmem_node(NODE_DATA(nid), phys, len);
 709 #else
 710         reserve_bootmem(phys, len);
 711 #endif
 712         if (phys+len <= MAX_DMA_PFN*PAGE_SIZE) {
 713                 dma_reserve += len / PAGE_SIZE;
 714                 set_dma_reserve(dma_reserve);
 715         }
 716 }
 717
 718 int kern_addr_valid(unsigned long addr)
 719 {
 720         unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
 721        pgd_t *pgd;
 722        pud_t *pud;
 723        pmd_t *pmd;
 724        pte_t *pte;
 725
 726         if (above != 0 && above != -1UL)
 727                 return 0;
 728
 729         pgd = pgd_offset_k(addr);
 730         if (pgd_none(*pgd))
 731                 return 0;
 732
 733         pud = pud_offset(pgd, addr);
 734         if (pud_none(*pud))
 735                 return 0;
 736
 737         pmd = pmd_offset(pud, addr);
 738         if (pmd_none(*pmd))
 739                 return 0;
 740         if (pmd_large(*pmd))
 741                 return pfn_valid(pmd_pfn(*pmd));
 742
 743         pte = pte_offset_kernel(pmd, addr);
 744         if (pte_none(*pte))
 745                 return 0;
 746         return pfn_valid(pte_pfn(*pte));
 747 }
 748
 749 #ifdef CONFIG_SYSCTL
 750 #include <linux/sysctl.h>
 751
 752 extern int exception_trace, page_fault_trace;
 753
 754 static ctl_table debug_table2[] = {
 755         { 99, "exception-trace", &exception_trace, sizeof(int), 0644, NULL,
 756           proc_dointvec },
 757         { 0, }
 758 };
 759
 760 static ctl_table debug_root_table2[] = {
 761         { .ctl_name = CTL_DEBUG, .procname = "debug", .mode = 0555,
 762            .child = debug_table2 },
 763         { 0 },
 764 };
 765
 766 static __init int x8664_sysctl_init(void)
 767 {
 768         register_sysctl_table(debug_root_table2, 1);
 769         return 0;
 770 }
 771 __initcall(x8664_sysctl_init);
 772 #endif
 773
 774 /* A pseudo VMA to allow ptrace access for the vsyscall page.  This only
 775    covers the 64bit vsyscall page now. 32bit has a real VMA now and does
 776    not need special handling anymore. */
 777
 778 static struct vm_area_struct gate_vma = {
 779         .vm_start = VSYSCALL_START,
 780         .vm_end = VSYSCALL_START + (VSYSCALL_MAPPED_PAGES << PAGE_SHIFT),
 781         .vm_page_prot = PAGE_READONLY_EXEC,
 782         .vm_flags = VM_READ | VM_EXEC
 783 };
 784
 785 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
 786 {
 787 #ifdef CONFIG_IA32_EMULATION
 788         if (test_tsk_thread_flag(tsk, TIF_IA32))
 789                 return NULL;
 790 #endif
 791         return &gate_vma;
 792 }
 793
 794 int in_gate_area(struct task_struct *task, unsigned long addr)
 795 {
 796         struct vm_area_struct *vma = get_gate_vma(task);
 797         if (!vma)
 798                 return 0;
 799         return (addr >= vma->vm_start) && (addr < vma->vm_end);
 800 }
 801
 802 /* Use this when you have no reliable task/vma, typically from interrupt
 803  * context.  It is less reliable than using the task's vma and may give
 804  * false positives.
 805  */
 806 int in_gate_area_no_task(unsigned long addr)
 807 {
 808         return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);
 809 }