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