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