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                 printk("SMBIOS area too long %lu\n", size);
 234                 return NULL;
 235         }
 236         set_pmd(temp_mappings[0].pmd,  __pmd(map | _KERNPG_TABLE | _PAGE_PSE));
 237         map += LARGE_PAGE_SIZE;
 238         set_pmd(temp_mappings[1].pmd,  __pmd(map | _KERNPG_TABLE | _PAGE_PSE));
 239         __flush_tlb();
 240         return temp_mappings[0].address + (addr & (LARGE_PAGE_SIZE-1));
 241 }
 242
 243 /* To avoid virtual aliases later */
 244 __init void early_iounmap(void *addr, unsigned long size)
 245 {
 246         if ((void *)round_down((unsigned long)addr, LARGE_PAGE_SIZE) != temp_mappings[0].address)
 247                 printk("early_iounmap: bad address %p\n", addr);
 248         set_pmd(temp_mappings[0].pmd, __pmd(0));
 249         set_pmd(temp_mappings[1].pmd, __pmd(0));
 250         __flush_tlb();
 251 }
 252
 253 static void __meminit
 254 phys_pmd_init(pmd_t *pmd, unsigned long address, unsigned long end)
 255 {
 256         int i;
 257
 258         for (i = 0; i < PTRS_PER_PMD; pmd++, i++, address += PMD_SIZE) {
 259                 unsigned long entry;
 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                 entry = _PAGE_NX|_PAGE_PSE|_KERNPG_TABLE|_PAGE_GLOBAL|address;
 268                 entry &= __supported_pte_mask;
 269                 set_pmd(pmd, __pmd(entry));
 270         }
 271 }
 272
 273 static void __meminit
 274 phys_pmd_update(pud_t *pud, unsigned long address, unsigned long end)
 275 {
 276         pmd_t *pmd = pmd_offset(pud, (unsigned long)__va(address));
 277
 278         if (pmd_none(*pmd)) {
 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
 286 static void __meminit phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
 287 {
 288         long i = pud_index(address);
 289
 290         pud = pud + i;
 291
 292         if (after_bootmem && pud_val(*pud)) {
 293                 phys_pmd_update(pud, address, end);
 294                 return;
 295         }
 296
 297         for (; i < PTRS_PER_PUD; pud++, i++) {
 298                 int map;
 299                 unsigned long paddr, pmd_phys;
 300                 pmd_t *pmd;
 301
 302                 paddr = (address & PGDIR_MASK) + i*PUD_SIZE;
 303                 if (paddr >= end)
 304                         break;
 305
 306                 if (!after_bootmem && !e820_any_mapped(paddr, paddr+PUD_SIZE, 0)) {
 307                         set_pud(pud, __pud(0));
 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, paddr, 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 /* Compute zone sizes for the DMA and DMA32 zones in a node. */
 404 __init void
 405 size_zones(unsigned long *z, unsigned long *h,
 406            unsigned long start_pfn, unsigned long end_pfn)
 407 {
 408         int i;
 409         unsigned long w;
 410
 411         for (i = 0; i < MAX_NR_ZONES; i++)
 412                 z[i] = 0;
 413
 414         if (start_pfn < MAX_DMA_PFN)
 415                 z[ZONE_DMA] = MAX_DMA_PFN - start_pfn;
 416         if (start_pfn < MAX_DMA32_PFN) {
 417                 unsigned long dma32_pfn = MAX_DMA32_PFN;
 418                 if (dma32_pfn > end_pfn)
 419                         dma32_pfn = end_pfn;
 420                 z[ZONE_DMA32] = dma32_pfn - start_pfn;
 421         }
 422         z[ZONE_NORMAL] = end_pfn - start_pfn;
 423
 424         /* Remove lower zones from higher ones. */
 425         w = 0;
 426         for (i = 0; i < MAX_NR_ZONES; i++) {
 427                 if (z[i])
 428                         z[i] -= w;
 429                 w += z[i];
 430         }
 431
 432         /* Compute holes */
 433         w = start_pfn;
 434         for (i = 0; i < MAX_NR_ZONES; i++) {
 435                 unsigned long s = w;
 436                 w += z[i];
 437                 h[i] = e820_hole_size(s, w);
 438         }
 439
 440         /* Add the space pace needed for mem_map to the holes too. */
 441         for (i = 0; i < MAX_NR_ZONES; i++)
 442                 h[i] += (z[i] * sizeof(struct page)) / PAGE_SIZE;
 443
 444         /* The 16MB DMA zone has the kernel and other misc mappings.
 445            Account them too */
 446         if (h[ZONE_DMA]) {
 447                 h[ZONE_DMA] += dma_reserve;
 448                 if (h[ZONE_DMA] >= z[ZONE_DMA]) {
 449                         printk(KERN_WARNING
 450                                 "Kernel too large and filling up ZONE_DMA?\n");
 451                         h[ZONE_DMA] = z[ZONE_DMA];
 452                 }
 453         }
 454 }
 455
 456 #ifndef CONFIG_NUMA
 457 void __init paging_init(void)
 458 {
 459         unsigned long zones[MAX_NR_ZONES], holes[MAX_NR_ZONES];
 460
 461         memory_present(0, 0, end_pfn);
 462         sparse_init();
 463         size_zones(zones, holes, 0, end_pfn);
 464         free_area_init_node(0, NODE_DATA(0), zones,
 465                             __pa(PAGE_OFFSET) >> PAGE_SHIFT, holes);
 466 }
 467 #endif
 468
 469 /* Unmap a kernel mapping if it exists. This is useful to avoid prefetches
 470    from the CPU leading to inconsistent cache lines. address and size
 471    must be aligned to 2MB boundaries.
 472    Does nothing when the mapping doesn't exist. */
 473 void __init clear_kernel_mapping(unsigned long address, unsigned long size)
 474 {
 475         unsigned long end = address + size;
 476
 477         BUG_ON(address & ~LARGE_PAGE_MASK);
 478         BUG_ON(size & ~LARGE_PAGE_MASK);
 479
 480         for (; address < end; address += LARGE_PAGE_SIZE) {
 481                 pgd_t *pgd = pgd_offset_k(address);
 482                 pud_t *pud;
 483                 pmd_t *pmd;
 484                 if (pgd_none(*pgd))
 485                         continue;
 486                 pud = pud_offset(pgd, address);
 487                 if (pud_none(*pud))
 488                         continue;
 489                 pmd = pmd_offset(pud, address);
 490                 if (!pmd || pmd_none(*pmd))
 491                         continue;
 492                 if (0 == (pmd_val(*pmd) & _PAGE_PSE)) {
 493                         /* Could handle this, but it should not happen currently. */
 494                         printk(KERN_ERR
 495                "clear_kernel_mapping: mapping has been split. will leak memory\n");
 496                         pmd_ERROR(*pmd);
 497                 }
 498                 set_pmd(pmd, __pmd(0));
 499         }
 500         __flush_tlb_all();
 501 }
 502
 503 static inline int page_is_ram (unsigned long pagenr)
 504 {
 505         int i;
 506
 507         for (i = 0; i < e820.nr_map; i++) {
 508                 unsigned long addr, end;
 509
 510                 if (e820.map[i].type != E820_RAM)       /* not usable memory */
 511                         continue;
 512                 /*
 513                  * !!!FIXME!!! Some BIOSen report areas as RAM that
 514                  * are not. Notably the 640->1Mb area. We need a sanity
 515                  * check here.
 516                  */
 517                 addr = (e820.map[i].addr+PAGE_SIZE-1) >> PAGE_SHIFT;
 518                 end = (e820.map[i].addr+e820.map[i].size) >> PAGE_SHIFT;
 519                 if  ((pagenr >= addr) && (pagenr < end))
 520                         return 1;
 521         }
 522         return 0;
 523 }
 524
 525 /*
 526  * Memory hotplug specific functions
 527  */
 528 void online_page(struct page *page)
 529 {
 530         ClearPageReserved(page);
 531         init_page_count(page);
 532         __free_page(page);
 533         totalram_pages++;
 534         num_physpages++;
 535 }
 536
 537 #ifdef CONFIG_MEMORY_HOTPLUG
 538 /*
 539  * XXX: memory_add_physaddr_to_nid() is to find node id from physical address
 540  *      via probe interface of sysfs. If acpi notifies hot-add event, then it
 541  *      can tell node id by searching dsdt. But, probe interface doesn't have
 542  *      node id. So, return 0 as node id at this time.
 543  */
 544 #ifdef CONFIG_NUMA
 545 int memory_add_physaddr_to_nid(u64 start)
 546 {
 547         return 0;
 548 }
 549 #endif
 550
 551 /*
 552  * Memory is added always to NORMAL zone. This means you will never get
 553  * additional DMA/DMA32 memory.
 554  */
 555 int arch_add_memory(int nid, u64 start, u64 size)
 556 {
 557         struct pglist_data *pgdat = NODE_DATA(nid);
 558         struct zone *zone = pgdat->node_zones + MAX_NR_ZONES-2;
 559         unsigned long start_pfn = start >> PAGE_SHIFT;
 560         unsigned long nr_pages = size >> PAGE_SHIFT;
 561         int ret;
 562
 563         ret = __add_pages(zone, start_pfn, nr_pages);
 564         if (ret)
 565                 goto error;
 566
 567         init_memory_mapping(start, (start + size -1));
 568
 569         return ret;
 570 error:
 571         printk("%s: Problem encountered in __add_pages!\n", __func__);
 572         return ret;
 573 }
 574 EXPORT_SYMBOL_GPL(arch_add_memory);
 575
 576 int remove_memory(u64 start, u64 size)
 577 {
 578         return -EINVAL;
 579 }
 580 EXPORT_SYMBOL_GPL(remove_memory);
 581
 582 #else /* CONFIG_MEMORY_HOTPLUG */
 583 /*
 584  * Memory Hotadd without sparsemem. The mem_maps have been allocated in advance,
 585  * just online the pages.
 586  */
 587 int __add_pages(struct zone *z, unsigned long start_pfn, unsigned long nr_pages)
 588 {
 589         int err = -EIO;
 590         unsigned long pfn;
 591         unsigned long total = 0, mem = 0;
 592         for (pfn = start_pfn; pfn < start_pfn + nr_pages; pfn++) {
 593                 if (pfn_valid(pfn)) {
 594                         online_page(pfn_to_page(pfn));
 595                         err = 0;
 596                         mem++;
 597                 }
 598                 total++;
 599         }
 600         if (!err) {
 601                 z->spanned_pages += total;
 602                 z->present_pages += mem;
 603                 z->zone_pgdat->node_spanned_pages += total;
 604                 z->zone_pgdat->node_present_pages += mem;
 605         }
 606         return err;
 607 }
 608 #endif /* CONFIG_MEMORY_HOTPLUG */
 609
 610 /*
 611  * devmem_is_allowed() checks to see if /dev/mem access to a certain address is
 612  * valid. The argument is a physical page number.
 613  *
 614  *
 615  * On x86-64, access has to be given to the first megabyte of ram because that area
 616  * contains bios code and data regions used by X and dosemu and similar apps.
 617  * Access has to be given to non-kernel-ram areas as well, these contain the PCI
 618  * mmio resources as well as potential bios/acpi data regions.
 619  */
 620 int devmem_is_allowed(unsigned long pagenr)
 621 {
 622         if (pagenr <= 256)
 623                 return 1;
 624         if (!page_is_ram(pagenr))
 625                 return 1;
 626         return 0;
 627 }
 628
 629
 630 EXPORT_SYMBOL_GPL(page_is_ram);
 631
 632 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
 633                          kcore_vsyscall;
 634
 635 void __init mem_init(void)
 636 {
 637         long codesize, reservedpages, datasize, initsize;
 638
 639         pci_iommu_alloc();
 640
 641         /* How many end-of-memory variables you have, grandma! */
 642         max_low_pfn = end_pfn;
 643         max_pfn = end_pfn;
 644         num_physpages = end_pfn;
 645         high_memory = (void *) __va(end_pfn * PAGE_SIZE);
 646
 647         /* clear the zero-page */
 648         memset(empty_zero_page, 0, PAGE_SIZE);
 649
 650         reservedpages = 0;
 651
 652         /* this will put all low memory onto the freelists */
 653 #ifdef CONFIG_NUMA
 654         totalram_pages = numa_free_all_bootmem();
 655 #else
 656         totalram_pages = free_all_bootmem();
 657 #endif
 658         reservedpages = end_pfn - totalram_pages - e820_hole_size(0, end_pfn);
 659
 660         after_bootmem = 1;
 661
 662         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 663         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 664         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 665
 666         /* Register memory areas for /proc/kcore */
 667         kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 668         kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 669                    VMALLOC_END-VMALLOC_START);
 670         kclist_add(&kcore_kernel, &_stext, _end - _stext);
 671         kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
 672         kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START,
 673                                  VSYSCALL_END - VSYSCALL_START);
 674
 675         printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n",
 676                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 677                 end_pfn << (PAGE_SHIFT-10),
 678                 codesize >> 10,
 679                 reservedpages << (PAGE_SHIFT-10),
 680                 datasize >> 10,
 681                 initsize >> 10);
 682
 683 #ifdef CONFIG_SMP
 684         /*
 685          * Sync boot_level4_pgt mappings with the init_level4_pgt
 686          * except for the low identity mappings which are already zapped
 687          * in init_level4_pgt. This sync-up is essential for AP's bringup
 688          */
 689         memcpy(boot_level4_pgt+1, init_level4_pgt+1, (PTRS_PER_PGD-1)*sizeof(pgd_t));
 690 #endif
 691 }
 692
 693 void free_init_pages(char *what, unsigned long begin, unsigned long end)
 694 {
 695         unsigned long addr;
 696
 697         if (begin >= end)
 698                 return;
 699
 700         printk(KERN_INFO "Freeing %s: %ldk freed\n", what, (end - begin) >> 10);
 701         for (addr = begin; addr < end; addr += PAGE_SIZE) {
 702                 ClearPageReserved(virt_to_page(addr));
 703                 init_page_count(virt_to_page(addr));
 704                 memset((void *)(addr & ~(PAGE_SIZE-1)),
 705                         POISON_FREE_INITMEM, PAGE_SIZE);
 706                 free_page(addr);
 707                 totalram_pages++;
 708         }
 709 }
 710
 711 void free_initmem(void)
 712 {
 713         memset(__initdata_begin, POISON_FREE_INITDATA,
 714                 __initdata_end - __initdata_begin);
 715         free_init_pages("unused kernel memory",
 716                         (unsigned long)(&__init_begin),
 717                         (unsigned long)(&__init_end));
 718 }
 719
 720 #ifdef CONFIG_DEBUG_RODATA
 721
 722 void mark_rodata_ro(void)
 723 {
 724         unsigned long addr = (unsigned long)__start_rodata;
 725
 726         for (; addr < (unsigned long)__end_rodata; addr += PAGE_SIZE)
 727                 change_page_attr_addr(addr, 1, PAGE_KERNEL_RO);
 728
 729         printk ("Write protecting the kernel read-only data: %luk\n",
 730                         (__end_rodata - __start_rodata) >> 10);
 731
 732         /*
 733          * change_page_attr_addr() requires a global_flush_tlb() call after it.
 734          * We do this after the printk so that if something went wrong in the
 735          * change, the printk gets out at least to give a better debug hint
 736          * of who is the culprit.
 737          */
 738         global_flush_tlb();
 739 }
 740 #endif
 741
 742 #ifdef CONFIG_BLK_DEV_INITRD
 743 void free_initrd_mem(unsigned long start, unsigned long end)
 744 {
 745         free_init_pages("initrd memory", start, end);
 746 }
 747 #endif
 748
 749 void __init reserve_bootmem_generic(unsigned long phys, unsigned len)
 750 {
 751         /* Should check here against the e820 map to avoid double free */
 752 #ifdef CONFIG_NUMA
 753         int nid = phys_to_nid(phys);
 754         reserve_bootmem_node(NODE_DATA(nid), phys, len);
 755 #else
 756         reserve_bootmem(phys, len);
 757 #endif
 758         if (phys+len <= MAX_DMA_PFN*PAGE_SIZE)
 759                 dma_reserve += len / PAGE_SIZE;
 760 }
 761
 762 int kern_addr_valid(unsigned long addr)
 763 {
 764         unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
 765        pgd_t *pgd;
 766        pud_t *pud;
 767        pmd_t *pmd;
 768        pte_t *pte;
 769
 770         if (above != 0 && above != -1UL)
 771                 return 0;
 772
 773         pgd = pgd_offset_k(addr);
 774         if (pgd_none(*pgd))
 775                 return 0;
 776
 777         pud = pud_offset(pgd, addr);
 778         if (pud_none(*pud))
 779                 return 0;
 780
 781         pmd = pmd_offset(pud, addr);
 782         if (pmd_none(*pmd))
 783                 return 0;
 784         if (pmd_large(*pmd))
 785                 return pfn_valid(pmd_pfn(*pmd));
 786
 787         pte = pte_offset_kernel(pmd, addr);
 788         if (pte_none(*pte))
 789                 return 0;
 790         return pfn_valid(pte_pfn(*pte));
 791 }
 792
 793 #ifdef CONFIG_SYSCTL
 794 #include <linux/sysctl.h>
 795
 796 extern int exception_trace, page_fault_trace;
 797
 798 static ctl_table debug_table2[] = {
 799         { 99, "exception-trace", &exception_trace, sizeof(int), 0644, NULL,
 800           proc_dointvec },
 801         { 0, }
 802 };
 803
 804 static ctl_table debug_root_table2[] = {
 805         { .ctl_name = CTL_DEBUG, .procname = "debug", .mode = 0555,
 806            .child = debug_table2 },
 807         { 0 },
 808 };
 809
 810 static __init int x8664_sysctl_init(void)
 811 {
 812         register_sysctl_table(debug_root_table2, 1);
 813         return 0;
 814 }
 815 __initcall(x8664_sysctl_init);
 816 #endif
 817
 818 /* A pseudo VMAs to allow ptrace access for the vsyscall page.   This only
 819    covers the 64bit vsyscall page now. 32bit has a real VMA now and does
 820    not need special handling anymore. */
 821
 822 static struct vm_area_struct gate_vma = {
 823         .vm_start = VSYSCALL_START,
 824         .vm_end = VSYSCALL_END,
 825         .vm_page_prot = PAGE_READONLY
 826 };
 827
 828 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
 829 {
 830 #ifdef CONFIG_IA32_EMULATION
 831         if (test_tsk_thread_flag(tsk, TIF_IA32))
 832                 return NULL;
 833 #endif
 834         return &gate_vma;
 835 }
 836
 837 int in_gate_area(struct task_struct *task, unsigned long addr)
 838 {
 839         struct vm_area_struct *vma = get_gate_vma(task);
 840         if (!vma)
 841                 return 0;
 842         return (addr >= vma->vm_start) && (addr < vma->vm_end);
 843 }
 844
 845 /* Use this when you have no reliable task/vma, typically from interrupt
 846  * context.  It is less reliable than using the task's vma and may give
 847  * false positives.
 848  */
 849 int in_gate_area_no_task(unsigned long addr)
 850 {
 851         return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);
 852 }