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/signal.h>
  10 #include <linux/sched.h>
  11 #include <linux/kernel.h>
  12 #include <linux/errno.h>
  13 #include <linux/string.h>
  14 #include <linux/types.h>
  15 #include <linux/ptrace.h>
  16 #include <linux/mman.h>
  17 #include <linux/mm.h>
  18 #include <linux/swap.h>
  19 #include <linux/smp.h>
  20 #include <linux/init.h>
  21 #include <linux/pagemap.h>
  22 #include <linux/bootmem.h>
  23 #include <linux/proc_fs.h>
  24 #include <linux/pci.h>
  25 #include <linux/pfn.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 const 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 static __meminit void *alloc_low_page(unsigned long *phys)
 172 {
 173         unsigned long pfn = table_end++;
 174         void *adr;
 175
 176         if (after_bootmem) {
 177                 adr = (void *)get_zeroed_page(GFP_ATOMIC);
 178                 *phys = __pa(adr);
 179                 return adr;
 180         }
 181
 182         if (pfn >= end_pfn)
 183                 panic("alloc_low_page: ran out of memory");
 184
 185         adr = early_ioremap(pfn * PAGE_SIZE, PAGE_SIZE);
 186         memset(adr, 0, PAGE_SIZE);
 187         *phys  = pfn * PAGE_SIZE;
 188         return adr;
 189 }
 190
 191 static __meminit void unmap_low_page(void *adr)
 192 {
 193
 194         if (after_bootmem)
 195                 return;
 196
 197         early_iounmap(adr, PAGE_SIZE);
 198 }
 199
 200 /* Must run before zap_low_mappings */
 201 __init void *early_ioremap(unsigned long addr, unsigned long size)
 202 {
 203         unsigned long vaddr;
 204         pmd_t *pmd, *last_pmd;
 205         int i, pmds;
 206
 207         pmds = ((addr & ~PMD_MASK) + size + ~PMD_MASK) / PMD_SIZE;
 208         vaddr = __START_KERNEL_map;
 209         pmd = level2_kernel_pgt;
 210         last_pmd = level2_kernel_pgt + PTRS_PER_PMD - 1;
 211         for (; pmd <= last_pmd; pmd++, vaddr += PMD_SIZE) {
 212                 for (i = 0; i < pmds; i++) {
 213                         if (pmd_present(pmd[i]))
 214                                 goto next;
 215                 }
 216                 vaddr += addr & ~PMD_MASK;
 217                 addr &= PMD_MASK;
 218                 for (i = 0; i < pmds; i++, addr += PMD_SIZE)
 219                         set_pmd(pmd + i,__pmd(addr | _KERNPG_TABLE | _PAGE_PSE));
 220                 __flush_tlb();
 221                 return (void *)vaddr;
 222         next:
 223                 ;
 224         }
 225         printk("early_ioremap(0x%lx, %lu) failed\n", addr, size);
 226         return NULL;
 227 }
 228
 229 /* To avoid virtual aliases later */
 230 __init void early_iounmap(void *addr, unsigned long size)
 231 {
 232         unsigned long vaddr;
 233         pmd_t *pmd;
 234         int i, pmds;
 235
 236         vaddr = (unsigned long)addr;
 237         pmds = ((vaddr & ~PMD_MASK) + size + ~PMD_MASK) / PMD_SIZE;
 238         pmd = level2_kernel_pgt + pmd_index(vaddr);
 239         for (i = 0; i < pmds; i++)
 240                 pmd_clear(pmd + i);
 241         __flush_tlb();
 242 }
 243
 244 static void __meminit
 245 phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end)
 246 {
 247         int i = pmd_index(address);
 248
 249         for (; i < PTRS_PER_PMD; i++, address += PMD_SIZE) {
 250                 unsigned long entry;
 251                 pmd_t *pmd = pmd_page + pmd_index(address);
 252
 253                 if (address >= end) {
 254                         if (!after_bootmem)
 255                                 for (; i < PTRS_PER_PMD; i++, pmd++)
 256                                         set_pmd(pmd, __pmd(0));
 257                         break;
 258                 }
 259
 260                 if (pmd_val(*pmd))
 261                         continue;
 262
 263                 entry = _PAGE_NX|_PAGE_PSE|_KERNPG_TABLE|_PAGE_GLOBAL|address;
 264                 entry &= __supported_pte_mask;
 265                 set_pmd(pmd, __pmd(entry));
 266         }
 267 }
 268
 269 static void __meminit
 270 phys_pmd_update(pud_t *pud, unsigned long address, unsigned long end)
 271 {
 272         pmd_t *pmd = pmd_offset(pud,0);
 273         spin_lock(&init_mm.page_table_lock);
 274         phys_pmd_init(pmd, address, end);
 275         spin_unlock(&init_mm.page_table_lock);
 276         __flush_tlb_all();
 277 }
 278
 279 static void __meminit phys_pud_init(pud_t *pud_page, unsigned long addr, unsigned long end)
 280 {
 281         int i = pud_index(addr);
 282
 283
 284         for (; i < PTRS_PER_PUD; i++, addr = (addr & PUD_MASK) + PUD_SIZE ) {
 285                 unsigned long pmd_phys;
 286                 pud_t *pud = pud_page + pud_index(addr);
 287                 pmd_t *pmd;
 288
 289                 if (addr >= end)
 290                         break;
 291
 292                 if (!after_bootmem && !e820_any_mapped(addr,addr+PUD_SIZE,0)) {
 293                         set_pud(pud, __pud(0));
 294                         continue;
 295                 }
 296
 297                 if (pud_val(*pud)) {
 298                         phys_pmd_update(pud, addr, end);
 299                         continue;
 300                 }
 301
 302                 pmd = alloc_low_page(&pmd_phys);
 303                 spin_lock(&init_mm.page_table_lock);
 304                 set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
 305                 phys_pmd_init(pmd, addr, end);
 306                 spin_unlock(&init_mm.page_table_lock);
 307                 unmap_low_page(pmd);
 308         }
 309         __flush_tlb();
 310 }
 311
 312 static void __init find_early_table_space(unsigned long end)
 313 {
 314         unsigned long puds, pmds, tables, start;
 315
 316         puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
 317         pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
 318         tables = round_up(puds * sizeof(pud_t), PAGE_SIZE) +
 319                  round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
 320
 321         /* RED-PEN putting page tables only on node 0 could
 322            cause a hotspot and fill up ZONE_DMA. The page tables
 323            need roughly 0.5KB per GB. */
 324         start = 0x8000;
 325         table_start = find_e820_area(start, end, tables);
 326         if (table_start == -1UL)
 327                 panic("Cannot find space for the kernel page tables");
 328
 329         table_start >>= PAGE_SHIFT;
 330         table_end = table_start;
 331
 332         early_printk("kernel direct mapping tables up to %lx @ %lx-%lx\n",
 333                 end, table_start << PAGE_SHIFT,
 334                 (table_start << PAGE_SHIFT) + tables);
 335 }
 336
 337 /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
 338    This runs before bootmem is initialized and gets pages directly from the
 339    physical memory. To access them they are temporarily mapped. */
 340 void __meminit init_memory_mapping(unsigned long start, unsigned long end)
 341 {
 342         unsigned long next;
 343
 344         Dprintk("init_memory_mapping\n");
 345
 346         /*
 347          * Find space for the kernel direct mapping tables.
 348          * Later we should allocate these tables in the local node of the memory
 349          * mapped.  Unfortunately this is done currently before the nodes are
 350          * discovered.
 351          */
 352         if (!after_bootmem)
 353                 find_early_table_space(end);
 354
 355         start = (unsigned long)__va(start);
 356         end = (unsigned long)__va(end);
 357
 358         for (; start < end; start = next) {
 359                 unsigned long pud_phys;
 360                 pgd_t *pgd = pgd_offset_k(start);
 361                 pud_t *pud;
 362
 363                 if (after_bootmem)
 364                         pud = pud_offset(pgd, start & PGDIR_MASK);
 365                 else
 366                         pud = alloc_low_page(&pud_phys);
 367
 368                 next = start + PGDIR_SIZE;
 369                 if (next > end)
 370                         next = end;
 371                 phys_pud_init(pud, __pa(start), __pa(next));
 372                 if (!after_bootmem)
 373                         set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
 374                 unmap_low_page(pud);
 375         }
 376
 377         if (!after_bootmem)
 378                 asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
 379         __flush_tlb_all();
 380 }
 381
 382 #ifndef CONFIG_NUMA
 383 void __init paging_init(void)
 384 {
 385         unsigned long max_zone_pfns[MAX_NR_ZONES];
 386         memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
 387         max_zone_pfns[ZONE_DMA] = MAX_DMA_PFN;
 388         max_zone_pfns[ZONE_DMA32] = MAX_DMA32_PFN;
 389         max_zone_pfns[ZONE_NORMAL] = end_pfn;
 390
 391         memory_present(0, 0, end_pfn);
 392         sparse_init();
 393         free_area_init_nodes(max_zone_pfns);
 394 }
 395 #endif
 396
 397 /* Unmap a kernel mapping if it exists. This is useful to avoid prefetches
 398    from the CPU leading to inconsistent cache lines. address and size
 399    must be aligned to 2MB boundaries.
 400    Does nothing when the mapping doesn't exist. */
 401 void __init clear_kernel_mapping(unsigned long address, unsigned long size)
 402 {
 403         unsigned long end = address + size;
 404
 405         BUG_ON(address & ~LARGE_PAGE_MASK);
 406         BUG_ON(size & ~LARGE_PAGE_MASK);
 407
 408         for (; address < end; address += LARGE_PAGE_SIZE) {
 409                 pgd_t *pgd = pgd_offset_k(address);
 410                 pud_t *pud;
 411                 pmd_t *pmd;
 412                 if (pgd_none(*pgd))
 413                         continue;
 414                 pud = pud_offset(pgd, address);
 415                 if (pud_none(*pud))
 416                         continue;
 417                 pmd = pmd_offset(pud, address);
 418                 if (!pmd || pmd_none(*pmd))
 419                         continue;
 420                 if (0 == (pmd_val(*pmd) & _PAGE_PSE)) {
 421                         /* Could handle this, but it should not happen currently. */
 422                         printk(KERN_ERR
 423                "clear_kernel_mapping: mapping has been split. will leak memory\n");
 424                         pmd_ERROR(*pmd);
 425                 }
 426                 set_pmd(pmd, __pmd(0));
 427         }
 428         __flush_tlb_all();
 429 }
 430
 431 /*
 432  * Memory hotplug specific functions
 433  */
 434 void online_page(struct page *page)
 435 {
 436         ClearPageReserved(page);
 437         init_page_count(page);
 438         __free_page(page);
 439         totalram_pages++;
 440         num_physpages++;
 441 }
 442
 443 #ifdef CONFIG_MEMORY_HOTPLUG
 444 /*
 445  * Memory is added always to NORMAL zone. This means you will never get
 446  * additional DMA/DMA32 memory.
 447  */
 448 int arch_add_memory(int nid, u64 start, u64 size)
 449 {
 450         struct pglist_data *pgdat = NODE_DATA(nid);
 451         struct zone *zone = pgdat->node_zones + ZONE_NORMAL;
 452         unsigned long start_pfn = start >> PAGE_SHIFT;
 453         unsigned long nr_pages = size >> PAGE_SHIFT;
 454         int ret;
 455
 456         init_memory_mapping(start, (start + size -1));
 457
 458         ret = __add_pages(zone, start_pfn, nr_pages);
 459         if (ret)
 460                 goto error;
 461
 462         return ret;
 463 error:
 464         printk("%s: Problem encountered in __add_pages!\n", __func__);
 465         return ret;
 466 }
 467 EXPORT_SYMBOL_GPL(arch_add_memory);
 468
 469 int remove_memory(u64 start, u64 size)
 470 {
 471         return -EINVAL;
 472 }
 473 EXPORT_SYMBOL_GPL(remove_memory);
 474
 475 #if !defined(CONFIG_ACPI_NUMA) && defined(CONFIG_NUMA)
 476 int memory_add_physaddr_to_nid(u64 start)
 477 {
 478         return 0;
 479 }
 480 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
 481 #endif
 482
 483 #endif /* CONFIG_MEMORY_HOTPLUG */
 484
 485 #ifdef CONFIG_MEMORY_HOTPLUG_RESERVE
 486 /*
 487  * Memory Hotadd without sparsemem. The mem_maps have been allocated in advance,
 488  * just online the pages.
 489  */
 490 int __add_pages(struct zone *z, unsigned long start_pfn, unsigned long nr_pages)
 491 {
 492         int err = -EIO;
 493         unsigned long pfn;
 494         unsigned long total = 0, mem = 0;
 495         for (pfn = start_pfn; pfn < start_pfn + nr_pages; pfn++) {
 496                 if (pfn_valid(pfn)) {
 497                         online_page(pfn_to_page(pfn));
 498                         err = 0;
 499                         mem++;
 500                 }
 501                 total++;
 502         }
 503         if (!err) {
 504                 z->spanned_pages += total;
 505                 z->present_pages += mem;
 506                 z->zone_pgdat->node_spanned_pages += total;
 507                 z->zone_pgdat->node_present_pages += mem;
 508         }
 509         return err;
 510 }
 511 #endif
 512
 513 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
 514                          kcore_vsyscall;
 515
 516 void __init mem_init(void)
 517 {
 518         long codesize, reservedpages, datasize, initsize;
 519
 520         pci_iommu_alloc();
 521
 522         /* clear the zero-page */
 523         memset(empty_zero_page, 0, PAGE_SIZE);
 524
 525         reservedpages = 0;
 526
 527         /* this will put all low memory onto the freelists */
 528 #ifdef CONFIG_NUMA
 529         totalram_pages = numa_free_all_bootmem();
 530 #else
 531         totalram_pages = free_all_bootmem();
 532 #endif
 533         reservedpages = end_pfn - totalram_pages -
 534                                         absent_pages_in_range(0, end_pfn);
 535
 536         after_bootmem = 1;
 537
 538         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 539         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 540         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 541
 542         /* Register memory areas for /proc/kcore */
 543         kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 544         kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 545                    VMALLOC_END-VMALLOC_START);
 546         kclist_add(&kcore_kernel, &_stext, _end - _stext);
 547         kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
 548         kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START,
 549                                  VSYSCALL_END - VSYSCALL_START);
 550
 551         printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n",
 552                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 553                 end_pfn << (PAGE_SHIFT-10),
 554                 codesize >> 10,
 555                 reservedpages << (PAGE_SHIFT-10),
 556                 datasize >> 10,
 557                 initsize >> 10);
 558 }
 559
 560 void free_init_pages(char *what, unsigned long begin, unsigned long end)
 561 {
 562         unsigned long addr;
 563
 564         if (begin >= end)
 565                 return;
 566
 567         printk(KERN_INFO "Freeing %s: %luk freed\n", what, (end - begin) >> 10);
 568         for (addr = begin; addr < end; addr += PAGE_SIZE) {
 569                 struct page *page = pfn_to_page(addr >> PAGE_SHIFT);
 570                 ClearPageReserved(page);
 571                 init_page_count(page);
 572                 memset(page_address(page), POISON_FREE_INITMEM, PAGE_SIZE);
 573                 if (addr >= __START_KERNEL_map)
 574                         change_page_attr_addr(addr, 1, __pgprot(0));
 575                 __free_page(page);
 576                 totalram_pages++;
 577         }
 578         if (addr > __START_KERNEL_map)
 579                 global_flush_tlb();
 580 }
 581
 582 void free_initmem(void)
 583 {
 584         free_init_pages("unused kernel memory",
 585                         __pa_symbol(&__init_begin),
 586                         __pa_symbol(&__init_end));
 587 }
 588
 589 #ifdef CONFIG_DEBUG_RODATA
 590
 591 void mark_rodata_ro(void)
 592 {
 593         unsigned long start = PFN_ALIGN(__va(__pa_symbol(&_stext))), size;
 594
 595 #ifdef CONFIG_HOTPLUG_CPU
 596         /* It must still be possible to apply SMP alternatives. */
 597         if (num_possible_cpus() > 1)
 598                 start = PFN_ALIGN(__va(__pa_symbol(&_etext)));
 599 #endif
 600         size = (unsigned long)__va(__pa_symbol(&__end_rodata)) - start;
 601         change_page_attr_addr(start, size >> PAGE_SHIFT, PAGE_KERNEL_RO);
 602
 603         printk(KERN_INFO "Write protecting the kernel read-only data: %luk\n",
 604                size >> 10);
 605
 606         /*
 607          * change_page_attr_addr() requires a global_flush_tlb() call after it.
 608          * We do this after the printk so that if something went wrong in the
 609          * change, the printk gets out at least to give a better debug hint
 610          * of who is the culprit.
 611          */
 612         global_flush_tlb();
 613 }
 614 #endif
 615
 616 #ifdef CONFIG_BLK_DEV_INITRD
 617 void free_initrd_mem(unsigned long start, unsigned long end)
 618 {
 619         free_init_pages("initrd memory", __pa(start), __pa(end));
 620 }
 621 #endif
 622
 623 void __init reserve_bootmem_generic(unsigned long phys, unsigned len)
 624 {
 625 #ifdef CONFIG_NUMA
 626         int nid = phys_to_nid(phys);
 627 #endif
 628         unsigned long pfn = phys >> PAGE_SHIFT;
 629         if (pfn >= end_pfn) {
 630                 /* This can happen with kdump kernels when accessing firmware
 631                    tables. */
 632                 if (pfn < end_pfn_map)
 633                         return;
 634                 printk(KERN_ERR "reserve_bootmem: illegal reserve %lx %u\n",
 635                                 phys, len);
 636                 return;
 637         }
 638
 639         /* Should check here against the e820 map to avoid double free */
 640 #ifdef CONFIG_NUMA
 641         reserve_bootmem_node(NODE_DATA(nid), phys, len);
 642 #else
 643         reserve_bootmem(phys, len);
 644 #endif
 645         if (phys+len <= MAX_DMA_PFN*PAGE_SIZE) {
 646                 dma_reserve += len / PAGE_SIZE;
 647                 set_dma_reserve(dma_reserve);
 648         }
 649 }
 650
 651 int kern_addr_valid(unsigned long addr)
 652 {
 653         unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
 654        pgd_t *pgd;
 655        pud_t *pud;
 656        pmd_t *pmd;
 657        pte_t *pte;
 658
 659         if (above != 0 && above != -1UL)
 660                 return 0;
 661
 662         pgd = pgd_offset_k(addr);
 663         if (pgd_none(*pgd))
 664                 return 0;
 665
 666         pud = pud_offset(pgd, addr);
 667         if (pud_none(*pud))
 668                 return 0;
 669
 670         pmd = pmd_offset(pud, addr);
 671         if (pmd_none(*pmd))
 672                 return 0;
 673         if (pmd_large(*pmd))
 674                 return pfn_valid(pmd_pfn(*pmd));
 675
 676         pte = pte_offset_kernel(pmd, addr);
 677         if (pte_none(*pte))
 678                 return 0;
 679         return pfn_valid(pte_pfn(*pte));
 680 }
 681
 682 #ifdef CONFIG_SYSCTL
 683 #include <linux/sysctl.h>
 684
 685 extern int exception_trace, page_fault_trace;
 686
 687 static ctl_table debug_table2[] = {
 688         {
 689                 .ctl_name       = 99,
 690                 .procname       = "exception-trace",
 691                 .data           = &exception_trace,
 692                 .maxlen         = sizeof(int),
 693                 .mode           = 0644,
 694                 .proc_handler   = proc_dointvec
 695         },
 696         {}
 697 };
 698
 699 static ctl_table debug_root_table2[] = {
 700         {
 701                 .ctl_name = CTL_DEBUG,
 702                 .procname = "debug",
 703                 .mode = 0555,
 704                 .child = debug_table2
 705         },
 706         {}
 707 };
 708
 709 static __init int x8664_sysctl_init(void)
 710 {
 711         register_sysctl_table(debug_root_table2);
 712         return 0;
 713 }
 714 __initcall(x8664_sysctl_init);
 715 #endif
 716
 717 /* A pseudo VMA to allow ptrace access for the vsyscall page.  This only
 718    covers the 64bit vsyscall page now. 32bit has a real VMA now and does
 719    not need special handling anymore. */
 720
 721 static struct vm_area_struct gate_vma = {
 722         .vm_start = VSYSCALL_START,
 723         .vm_end = VSYSCALL_START + (VSYSCALL_MAPPED_PAGES << PAGE_SHIFT),
 724         .vm_page_prot = PAGE_READONLY_EXEC,
 725         .vm_flags = VM_READ | VM_EXEC
 726 };
 727
 728 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
 729 {
 730 #ifdef CONFIG_IA32_EMULATION
 731         if (test_tsk_thread_flag(tsk, TIF_IA32))
 732                 return NULL;
 733 #endif
 734         return &gate_vma;
 735 }
 736
 737 int in_gate_area(struct task_struct *task, unsigned long addr)
 738 {
 739         struct vm_area_struct *vma = get_gate_vma(task);
 740         if (!vma)
 741                 return 0;
 742         return (addr >= vma->vm_start) && (addr < vma->vm_end);
 743 }
 744
 745 /* Use this when you have no reliable task/vma, typically from interrupt
 746  * context.  It is less reliable than using the task's vma and may give
 747  * false positives.
 748  */
 749 int in_gate_area_no_task(unsigned long addr)
 750 {
 751         return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);
 752 }