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/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/dma-mapping.h>
  27
  28 #include <asm/processor.h>
  29 #include <asm/system.h>
  30 #include <asm/uaccess.h>
  31 #include <asm/pgtable.h>
  32 #include <asm/pgalloc.h>
  33 #include <asm/dma.h>
  34 #include <asm/fixmap.h>
  35 #include <asm/e820.h>
  36 #include <asm/apic.h>
  37 #include <asm/tlb.h>
  38 #include <asm/mmu_context.h>
  39 #include <asm/proto.h>
  40 #include <asm/smp.h>
  41 #include <asm/sections.h>
  42 #include <asm/dma-mapping.h>
  43 #include <asm/swiotlb.h>
  44
  45 #ifndef Dprintk
  46 #define Dprintk(x...)
  47 #endif
  48
  49 struct dma_mapping_ops* dma_ops;
  50 EXPORT_SYMBOL(dma_ops);
  51
  52 static unsigned long dma_reserve __initdata;
  53
  54 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
  55
  56 /*
  57  * NOTE: pagetable_init alloc all the fixmap pagetables contiguous on the
  58  * physical space so we can cache the place of the first one and move
  59  * around without checking the pgd every time.
  60  */
  61
  62 void show_mem(void)
  63 {
  64         long i, total = 0, reserved = 0;
  65         long shared = 0, cached = 0;
  66         pg_data_t *pgdat;
  67         struct page *page;
  68
  69         printk(KERN_INFO "Mem-info:\n");
  70         show_free_areas();
  71         printk(KERN_INFO "Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
  72
  73         for_each_pgdat(pgdat) {
  74                for (i = 0; i < pgdat->node_spanned_pages; ++i) {
  75                         page = pfn_to_page(pgdat->node_start_pfn + i);
  76                         total++;
  77                         if (PageReserved(page))
  78                                 reserved++;
  79                         else if (PageSwapCache(page))
  80                                 cached++;
  81                         else if (page_count(page))
  82                                 shared += page_count(page) - 1;
  83                }
  84         }
  85         printk(KERN_INFO "%lu pages of RAM\n", total);
  86         printk(KERN_INFO "%lu reserved pages\n",reserved);
  87         printk(KERN_INFO "%lu pages shared\n",shared);
  88         printk(KERN_INFO "%lu pages swap cached\n",cached);
  89 }
  90
  91 /* References to section boundaries */
  92
  93 int after_bootmem;
  94
  95 static void *spp_getpage(void)
  96 {
  97         void *ptr;
  98         if (after_bootmem)
  99                 ptr = (void *) get_zeroed_page(GFP_ATOMIC);
 100         else
 101                 ptr = alloc_bootmem_pages(PAGE_SIZE);
 102         if (!ptr || ((unsigned long)ptr & ~PAGE_MASK))
 103                 panic("set_pte_phys: cannot allocate page data %s\n", after_bootmem?"after bootmem":"");
 104
 105         Dprintk("spp_getpage %p\n", ptr);
 106         return ptr;
 107 }
 108
 109 static void set_pte_phys(unsigned long vaddr,
 110                          unsigned long phys, pgprot_t prot)
 111 {
 112         pgd_t *pgd;
 113         pud_t *pud;
 114         pmd_t *pmd;
 115         pte_t *pte, new_pte;
 116
 117         Dprintk("set_pte_phys %lx to %lx\n", vaddr, phys);
 118
 119         pgd = pgd_offset_k(vaddr);
 120         if (pgd_none(*pgd)) {
 121                 printk("PGD FIXMAP MISSING, it should be setup in head.S!\n");
 122                 return;
 123         }
 124         pud = pud_offset(pgd, vaddr);
 125         if (pud_none(*pud)) {
 126                 pmd = (pmd_t *) spp_getpage();
 127                 set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
 128                 if (pmd != pmd_offset(pud, 0)) {
 129                         printk("PAGETABLE BUG #01! %p <-> %p\n", pmd, pmd_offset(pud,0));
 130                         return;
 131                 }
 132         }
 133         pmd = pmd_offset(pud, vaddr);
 134         if (pmd_none(*pmd)) {
 135                 pte = (pte_t *) spp_getpage();
 136                 set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE | _PAGE_USER));
 137                 if (pte != pte_offset_kernel(pmd, 0)) {
 138                         printk("PAGETABLE BUG #02!\n");
 139                         return;
 140                 }
 141         }
 142         new_pte = pfn_pte(phys >> PAGE_SHIFT, prot);
 143
 144         pte = pte_offset_kernel(pmd, vaddr);
 145         if (!pte_none(*pte) &&
 146             pte_val(*pte) != (pte_val(new_pte) & __supported_pte_mask))
 147                 pte_ERROR(*pte);
 148         set_pte(pte, new_pte);
 149
 150         /*
 151          * It's enough to flush this one mapping.
 152          * (PGE mappings get flushed as well)
 153          */
 154         __flush_tlb_one(vaddr);
 155 }
 156
 157 /* NOTE: this is meant to be run only at boot */
 158 void __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 __init 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 (pfn >= end_pfn)
 191                 panic("alloc_low_page: ran out of memory");
 192         for (i = 0; temp_mappings[i].allocated; i++) {
 193                 if (!temp_mappings[i].pmd)
 194                         panic("alloc_low_page: ran out of temp mappings");
 195         }
 196         ti = &temp_mappings[i];
 197         paddr = (pfn << PAGE_SHIFT) & PMD_MASK;
 198         set_pmd(ti->pmd, __pmd(paddr | _KERNPG_TABLE | _PAGE_PSE));
 199         ti->allocated = 1;
 200         __flush_tlb();
 201         adr = ti->address + ((pfn << PAGE_SHIFT) & ~PMD_MASK);
 202         *index = i;
 203         *phys  = pfn * PAGE_SIZE;
 204         return adr;
 205 }
 206
 207 static __init void unmap_low_page(int i)
 208 {
 209         struct temp_map *ti = &temp_mappings[i];
 210         set_pmd(ti->pmd, __pmd(0));
 211         ti->allocated = 0;
 212 }
 213
 214 static void __init phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
 215 {
 216         long i, j;
 217
 218         i = pud_index(address);
 219         pud = pud + i;
 220         for (; i < PTRS_PER_PUD; pud++, i++) {
 221                 int map;
 222                 unsigned long paddr, pmd_phys;
 223                 pmd_t *pmd;
 224
 225                 paddr = address + i*PUD_SIZE;
 226                 if (paddr >= end) {
 227                         for (; i < PTRS_PER_PUD; i++, pud++)
 228                                 set_pud(pud, __pud(0));
 229                         break;
 230                 }
 231
 232                 if (!e820_mapped(paddr, paddr+PUD_SIZE, 0)) {
 233                         set_pud(pud, __pud(0));
 234                         continue;
 235                 }
 236
 237                 pmd = alloc_low_page(&map, &pmd_phys);
 238                 set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
 239                 for (j = 0; j < PTRS_PER_PMD; pmd++, j++, paddr += PMD_SIZE) {
 240                         unsigned long pe;
 241
 242                         if (paddr >= end) {
 243                                 for (; j < PTRS_PER_PMD; j++, pmd++)
 244                                         set_pmd(pmd,  __pmd(0));
 245                                 break;
 246                 }
 247                         pe = _PAGE_NX|_PAGE_PSE | _KERNPG_TABLE | _PAGE_GLOBAL | paddr;
 248                         pe &= __supported_pte_mask;
 249                         set_pmd(pmd, __pmd(pe));
 250                 }
 251                 unmap_low_page(map);
 252         }
 253         __flush_tlb();
 254 }
 255
 256 static void __init find_early_table_space(unsigned long end)
 257 {
 258         unsigned long puds, pmds, tables;
 259
 260         puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
 261         pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
 262         tables = round_up(puds * sizeof(pud_t), PAGE_SIZE) +
 263                  round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
 264
 265         table_start = find_e820_area(0x8000, __pa_symbol(&_text), tables);
 266         if (table_start == -1UL)
 267                 panic("Cannot find space for the kernel page tables");
 268
 269         table_start >>= PAGE_SHIFT;
 270         table_end = table_start;
 271 }
 272
 273 /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
 274    This runs before bootmem is initialized and gets pages directly from the
 275    physical memory. To access them they are temporarily mapped. */
 276 void __init init_memory_mapping(unsigned long start, unsigned long end)
 277 {
 278         unsigned long next;
 279
 280         Dprintk("init_memory_mapping\n");
 281
 282         /*
 283          * Find space for the kernel direct mapping tables.
 284          * Later we should allocate these tables in the local node of the memory
 285          * mapped.  Unfortunately this is done currently before the nodes are
 286          * discovered.
 287          */
 288         find_early_table_space(end);
 289
 290         start = (unsigned long)__va(start);
 291         end = (unsigned long)__va(end);
 292
 293         for (; start < end; start = next) {
 294                 int map;
 295                 unsigned long pud_phys;
 296                 pud_t *pud = alloc_low_page(&map, &pud_phys);
 297                 next = start + PGDIR_SIZE;
 298                 if (next > end)
 299                         next = end;
 300                 phys_pud_init(pud, __pa(start), __pa(next));
 301                 set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
 302                 unmap_low_page(map);
 303         }
 304
 305         asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
 306         __flush_tlb_all();
 307         early_printk("kernel direct mapping tables upto %lx @ %lx-%lx\n", end,
 308                table_start<<PAGE_SHIFT,
 309                table_end<<PAGE_SHIFT);
 310 }
 311
 312 void __cpuinit zap_low_mappings(int cpu)
 313 {
 314         if (cpu == 0) {
 315                 pgd_t *pgd = pgd_offset_k(0UL);
 316                 pgd_clear(pgd);
 317         } else {
 318                 /*
 319                  * For AP's, zap the low identity mappings by changing the cr3
 320                  * to init_level4_pgt and doing local flush tlb all
 321                  */
 322                 asm volatile("movq %0,%%cr3" :: "r" (__pa_symbol(&init_level4_pgt)));
 323         }
 324         __flush_tlb_all();
 325 }
 326
 327 /* Compute zone sizes for the DMA and DMA32 zones in a node. */
 328 __init void
 329 size_zones(unsigned long *z, unsigned long *h,
 330            unsigned long start_pfn, unsigned long end_pfn)
 331 {
 332         int i;
 333         unsigned long w;
 334
 335         for (i = 0; i < MAX_NR_ZONES; i++)
 336                 z[i] = 0;
 337
 338         if (start_pfn < MAX_DMA_PFN)
 339                 z[ZONE_DMA] = MAX_DMA_PFN - start_pfn;
 340         if (start_pfn < MAX_DMA32_PFN) {
 341                 unsigned long dma32_pfn = MAX_DMA32_PFN;
 342                 if (dma32_pfn > end_pfn)
 343                         dma32_pfn = end_pfn;
 344                 z[ZONE_DMA32] = dma32_pfn - start_pfn;
 345         }
 346         z[ZONE_NORMAL] = end_pfn - start_pfn;
 347
 348         /* Remove lower zones from higher ones. */
 349         w = 0;
 350         for (i = 0; i < MAX_NR_ZONES; i++) {
 351                 if (z[i])
 352                         z[i] -= w;
 353                 w += z[i];
 354         }
 355
 356         /* Compute holes */
 357         w = start_pfn;
 358         for (i = 0; i < MAX_NR_ZONES; i++) {
 359                 unsigned long s = w;
 360                 w += z[i];
 361                 h[i] = e820_hole_size(s, w);
 362         }
 363
 364         /* Add the space pace needed for mem_map to the holes too. */
 365         for (i = 0; i < MAX_NR_ZONES; i++)
 366                 h[i] += (z[i] * sizeof(struct page)) / PAGE_SIZE;
 367
 368         /* The 16MB DMA zone has the kernel and other misc mappings.
 369            Account them too */
 370         if (h[ZONE_DMA]) {
 371                 h[ZONE_DMA] += dma_reserve;
 372                 if (h[ZONE_DMA] >= z[ZONE_DMA]) {
 373                         printk(KERN_WARNING
 374                                 "Kernel too large and filling up ZONE_DMA?\n");
 375                         h[ZONE_DMA] = z[ZONE_DMA];
 376                 }
 377         }
 378 }
 379
 380 #ifndef CONFIG_NUMA
 381 void __init paging_init(void)
 382 {
 383         unsigned long zones[MAX_NR_ZONES], holes[MAX_NR_ZONES];
 384         size_zones(zones, holes, 0, end_pfn);
 385         free_area_init_node(0, NODE_DATA(0), zones,
 386                             __pa(PAGE_OFFSET) >> PAGE_SHIFT, holes);
 387 }
 388 #endif
 389
 390 /* Unmap a kernel mapping if it exists. This is useful to avoid prefetches
 391    from the CPU leading to inconsistent cache lines. address and size
 392    must be aligned to 2MB boundaries.
 393    Does nothing when the mapping doesn't exist. */
 394 void __init clear_kernel_mapping(unsigned long address, unsigned long size)
 395 {
 396         unsigned long end = address + size;
 397
 398         BUG_ON(address & ~LARGE_PAGE_MASK);
 399         BUG_ON(size & ~LARGE_PAGE_MASK);
 400
 401         for (; address < end; address += LARGE_PAGE_SIZE) {
 402                 pgd_t *pgd = pgd_offset_k(address);
 403                 pud_t *pud;
 404                 pmd_t *pmd;
 405                 if (pgd_none(*pgd))
 406                         continue;
 407                 pud = pud_offset(pgd, address);
 408                 if (pud_none(*pud))
 409                         continue;
 410                 pmd = pmd_offset(pud, address);
 411                 if (!pmd || pmd_none(*pmd))
 412                         continue;
 413                 if (0 == (pmd_val(*pmd) & _PAGE_PSE)) {
 414                         /* Could handle this, but it should not happen currently. */
 415                         printk(KERN_ERR
 416                "clear_kernel_mapping: mapping has been split. will leak memory\n");
 417                         pmd_ERROR(*pmd);
 418                 }
 419                 set_pmd(pmd, __pmd(0));
 420         }
 421         __flush_tlb_all();
 422 }
 423
 424 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
 425                          kcore_vsyscall;
 426
 427 void __init mem_init(void)
 428 {
 429         long codesize, reservedpages, datasize, initsize;
 430
 431 #ifdef CONFIG_SWIOTLB
 432         pci_swiotlb_init();
 433 #endif
 434         no_iommu_init();
 435
 436         /* How many end-of-memory variables you have, grandma! */
 437         max_low_pfn = end_pfn;
 438         max_pfn = end_pfn;
 439         num_physpages = end_pfn;
 440         high_memory = (void *) __va(end_pfn * PAGE_SIZE);
 441
 442         /* clear the zero-page */
 443         memset(empty_zero_page, 0, PAGE_SIZE);
 444
 445         reservedpages = 0;
 446
 447         /* this will put all low memory onto the freelists */
 448 #ifdef CONFIG_NUMA
 449         totalram_pages = numa_free_all_bootmem();
 450 #else
 451         totalram_pages = free_all_bootmem();
 452 #endif
 453         reservedpages = end_pfn - totalram_pages - e820_hole_size(0, end_pfn);
 454
 455         after_bootmem = 1;
 456
 457         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
 458         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
 459         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 460
 461         /* Register memory areas for /proc/kcore */
 462         kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
 463         kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
 464                    VMALLOC_END-VMALLOC_START);
 465         kclist_add(&kcore_kernel, &_stext, _end - _stext);
 466         kclist_add(&kcore_modules, (void *)MODULES_VADDR, MODULES_LEN);
 467         kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START,
 468                                  VSYSCALL_END - VSYSCALL_START);
 469
 470         printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n",
 471                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
 472                 end_pfn << (PAGE_SHIFT-10),
 473                 codesize >> 10,
 474                 reservedpages << (PAGE_SHIFT-10),
 475                 datasize >> 10,
 476                 initsize >> 10);
 477
 478 #ifdef CONFIG_SMP
 479         /*
 480          * Sync boot_level4_pgt mappings with the init_level4_pgt
 481          * except for the low identity mappings which are already zapped
 482          * in init_level4_pgt. This sync-up is essential for AP's bringup
 483          */
 484         memcpy(boot_level4_pgt+1, init_level4_pgt+1, (PTRS_PER_PGD-1)*sizeof(pgd_t));
 485 #endif
 486 }
 487
 488 void free_initmem(void)
 489 {
 490         unsigned long addr;
 491
 492         addr = (unsigned long)(&__init_begin);
 493         for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
 494                 ClearPageReserved(virt_to_page(addr));
 495                 set_page_count(virt_to_page(addr), 1);
 496                 memset((void *)(addr & ~(PAGE_SIZE-1)), 0xcc, PAGE_SIZE);
 497                 free_page(addr);
 498                 totalram_pages++;
 499         }
 500         memset(__initdata_begin, 0xba, __initdata_end - __initdata_begin);
 501         printk ("Freeing unused kernel memory: %luk freed\n", (__init_end - __init_begin) >> 10);
 502 }
 503
 504 #ifdef CONFIG_DEBUG_RODATA
 505
 506 extern char __start_rodata, __end_rodata;
 507 void mark_rodata_ro(void)
 508 {
 509         unsigned long addr = (unsigned long)&__start_rodata;
 510
 511         for (; addr < (unsigned long)&__end_rodata; addr += PAGE_SIZE)
 512                 change_page_attr_addr(addr, 1, PAGE_KERNEL_RO);
 513
 514         printk ("Write protecting the kernel read-only data: %luk\n",
 515                         (&__end_rodata - &__start_rodata) >> 10);
 516
 517         /*
 518          * change_page_attr_addr() requires a global_flush_tlb() call after it.
 519          * We do this after the printk so that if something went wrong in the
 520          * change, the printk gets out at least to give a better debug hint
 521          * of who is the culprit.
 522          */
 523         global_flush_tlb();
 524 }
 525 #endif
 526
 527 #ifdef CONFIG_BLK_DEV_INITRD
 528 void free_initrd_mem(unsigned long start, unsigned long end)
 529 {
 530         if (start < (unsigned long)&_end)
 531                 return;
 532         printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
 533         for (; start < end; start += PAGE_SIZE) {
 534                 ClearPageReserved(virt_to_page(start));
 535                 set_page_count(virt_to_page(start), 1);
 536                 free_page(start);
 537                 totalram_pages++;
 538         }
 539 }
 540 #endif
 541
 542 void __init reserve_bootmem_generic(unsigned long phys, unsigned len)
 543 {
 544         /* Should check here against the e820 map to avoid double free */
 545 #ifdef CONFIG_NUMA
 546         int nid = phys_to_nid(phys);
 547         reserve_bootmem_node(NODE_DATA(nid), phys, len);
 548 #else
 549         reserve_bootmem(phys, len);
 550 #endif
 551         if (phys+len <= MAX_DMA_PFN*PAGE_SIZE)
 552                 dma_reserve += len / PAGE_SIZE;
 553 }
 554
 555 int kern_addr_valid(unsigned long addr)
 556 {
 557         unsigned long above = ((long)addr) >> __VIRTUAL_MASK_SHIFT;
 558        pgd_t *pgd;
 559        pud_t *pud;
 560        pmd_t *pmd;
 561        pte_t *pte;
 562
 563         if (above != 0 && above != -1UL)
 564                 return 0;
 565
 566         pgd = pgd_offset_k(addr);
 567         if (pgd_none(*pgd))
 568                 return 0;
 569
 570         pud = pud_offset(pgd, addr);
 571         if (pud_none(*pud))
 572                 return 0;
 573
 574         pmd = pmd_offset(pud, addr);
 575         if (pmd_none(*pmd))
 576                 return 0;
 577         if (pmd_large(*pmd))
 578                 return pfn_valid(pmd_pfn(*pmd));
 579
 580         pte = pte_offset_kernel(pmd, addr);
 581         if (pte_none(*pte))
 582                 return 0;
 583         return pfn_valid(pte_pfn(*pte));
 584 }
 585
 586 #ifdef CONFIG_SYSCTL
 587 #include <linux/sysctl.h>
 588
 589 extern int exception_trace, page_fault_trace;
 590
 591 static ctl_table debug_table2[] = {
 592         { 99, "exception-trace", &exception_trace, sizeof(int), 0644, NULL,
 593           proc_dointvec },
 594         { 0, }
 595 };
 596
 597 static ctl_table debug_root_table2[] = {
 598         { .ctl_name = CTL_DEBUG, .procname = "debug", .mode = 0555,
 599            .child = debug_table2 },
 600         { 0 },
 601 };
 602
 603 static __init int x8664_sysctl_init(void)
 604 {
 605         register_sysctl_table(debug_root_table2, 1);
 606         return 0;
 607 }
 608 __initcall(x8664_sysctl_init);
 609 #endif
 610
 611 /* A pseudo VMAs to allow ptrace access for the vsyscall page.   This only
 612    covers the 64bit vsyscall page now. 32bit has a real VMA now and does
 613    not need special handling anymore. */
 614
 615 static struct vm_area_struct gate_vma = {
 616         .vm_start = VSYSCALL_START,
 617         .vm_end = VSYSCALL_END,
 618         .vm_page_prot = PAGE_READONLY
 619 };
 620
 621 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
 622 {
 623 #ifdef CONFIG_IA32_EMULATION
 624         if (test_tsk_thread_flag(tsk, TIF_IA32))
 625                 return NULL;
 626 #endif
 627         return &gate_vma;
 628 }
 629
 630 int in_gate_area(struct task_struct *task, unsigned long addr)
 631 {
 632         struct vm_area_struct *vma = get_gate_vma(task);
 633         if (!vma)
 634                 return 0;
 635         return (addr >= vma->vm_start) && (addr < vma->vm_end);
 636 }
 637
 638 /* Use this when you have no reliable task/vma, typically from interrupt
 639  * context.  It is less reliable than using the task's vma and may give
 640  * false positives.
 641  */
 642 int in_gate_area_no_task(unsigned long addr)
 643 {
 644         return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);
 645 }