arch/x86_64/mm/fault.c

   1 /*
   2  *  linux/arch/x86-64/mm/fault.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  *  Copyright (C) 2001,2002 Andi Kleen, SuSE Labs.
   6  */
   7
   8 #include <linux/signal.h>
   9 #include <linux/sched.h>
  10 #include <linux/kernel.h>
  11 #include <linux/errno.h>
  12 #include <linux/string.h>
  13 #include <linux/types.h>
  14 #include <linux/tracehook.h>
  15 #include <linux/mman.h>
  16 #include <linux/mm.h>
  17 #include <linux/smp.h>
  18 #include <linux/smp_lock.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/init.h>
  21 #include <linux/tty.h>
  22 #include <linux/vt_kern.h>              /* For unblank_screen() */
  23 #include <linux/compiler.h>
  24 #include <linux/module.h>
  25 #include <linux/kprobes.h>
  26
  27 #include <asm/system.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/pgalloc.h>
  30 #include <asm/smp.h>
  31 #include <asm/tlbflush.h>
  32 #include <asm/proto.h>
  33 #include <asm/kdebug.h>
  34 #include <asm-generic/sections.h>
  35
  36 /* Page fault error code bits */
  37 #define PF_PROT (1<<0)          /* or no page found */
  38 #define PF_WRITE        (1<<1)
  39 #define PF_USER (1<<2)
  40 #define PF_RSVD (1<<3)
  41 #define PF_INSTR        (1<<4)
  42
  43 #ifdef CONFIG_KPROBES
  44 ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
  45
  46 /* Hook to register for page fault notifications */
  47 int register_page_fault_notifier(struct notifier_block *nb)
  48 {
  49         vmalloc_sync_all();
  50         return atomic_notifier_chain_register(&notify_page_fault_chain, nb);
  51 }
  52
  53 int unregister_page_fault_notifier(struct notifier_block *nb)
  54 {
  55         return atomic_notifier_chain_unregister(&notify_page_fault_chain, nb);
  56 }
  57
  58 static inline int notify_page_fault(enum die_val val, const char *str,
  59                         struct pt_regs *regs, long err, int trap, int sig)
  60 {
  61         struct die_args args = {
  62                 .regs = regs,
  63                 .str = str,
  64                 .err = err,
  65                 .trapnr = trap,
  66                 .signr = sig
  67         };
  68         return atomic_notifier_call_chain(&notify_page_fault_chain, val, &args);
  69 }
  70 #else
  71 static inline int notify_page_fault(enum die_val val, const char *str,
  72                         struct pt_regs *regs, long err, int trap, int sig)
  73 {
  74         return NOTIFY_DONE;
  75 }
  76 #endif
  77
  78 void bust_spinlocks(int yes)
  79 {
  80         int loglevel_save = console_loglevel;
  81         if (yes) {
  82                 oops_in_progress = 1;
  83         } else {
  84 #ifdef CONFIG_VT
  85                 unblank_screen();
  86 #endif
  87                 oops_in_progress = 0;
  88                 /*
  89                  * OK, the message is on the console.  Now we call printk()
  90                  * without oops_in_progress set so that printk will give klogd
  91                  * a poke.  Hold onto your hats...
  92                  */
  93                 console_loglevel = 15;          /* NMI oopser may have shut the console up */
  94                 printk(" ");
  95                 console_loglevel = loglevel_save;
  96         }
  97 }
  98
  99 /* Sometimes the CPU reports invalid exceptions on prefetch.
 100    Check that here and ignore.
 101    Opcode checker based on code by Richard Brunner */
 102 static noinline int is_prefetch(struct pt_regs *regs, unsigned long addr,
 103                                 unsigned long error_code)
 104 {
 105         unsigned char *instr;
 106         int scan_more = 1;
 107         int prefetch = 0;
 108         unsigned char *max_instr;
 109
 110         /* If it was a exec fault ignore */
 111         if (error_code & PF_INSTR)
 112                 return 0;
 113
 114         instr = (unsigned char *)convert_rip_to_linear(current, regs);
 115         max_instr = instr + 15;
 116
 117         if (user_mode(regs) && instr >= (unsigned char *)TASK_SIZE64)
 118                 return 0;
 119
 120         while (scan_more && instr < max_instr) {
 121                 unsigned char opcode;
 122                 unsigned char instr_hi;
 123                 unsigned char instr_lo;
 124
 125                 if (__get_user(opcode, instr))
 126                         break;
 127
 128                 instr_hi = opcode & 0xf0;
 129                 instr_lo = opcode & 0x0f;
 130                 instr++;
 131
 132                 switch (instr_hi) {
 133                 case 0x20:
 134                 case 0x30:
 135                         /* Values 0x26,0x2E,0x36,0x3E are valid x86
 136                            prefixes.  In long mode, the CPU will signal
 137                            invalid opcode if some of these prefixes are
 138                            present so we will never get here anyway */
 139                         scan_more = ((instr_lo & 7) == 0x6);
 140                         break;
 141
 142                 case 0x40:
 143                         /* In AMD64 long mode, 0x40 to 0x4F are valid REX prefixes
 144                            Need to figure out under what instruction mode the
 145                            instruction was issued ... */
 146                         /* Could check the LDT for lm, but for now it's good
 147                            enough to assume that long mode only uses well known
 148                            segments or kernel. */
 149                         scan_more = (!user_mode(regs)) || (regs->cs == __USER_CS);
 150                         break;
 151
 152                 case 0x60:
 153                         /* 0x64 thru 0x67 are valid prefixes in all modes. */
 154                         scan_more = (instr_lo & 0xC) == 0x4;
 155                         break;
 156                 case 0xF0:
 157                         /* 0xF0, 0xF2, and 0xF3 are valid prefixes in all modes. */
 158                         scan_more = !instr_lo || (instr_lo>>1) == 1;
 159                         break;
 160                 case 0x00:
 161                         /* Prefetch instruction is 0x0F0D or 0x0F18 */
 162                         scan_more = 0;
 163                         if (__get_user(opcode, instr))
 164                                 break;
 165                         prefetch = (instr_lo == 0xF) &&
 166                                 (opcode == 0x0D || opcode == 0x18);
 167                         break;
 168                 default:
 169                         scan_more = 0;
 170                         break;
 171                 }
 172         }
 173         return prefetch;
 174 }
 175
 176 static int bad_address(void *p)
 177 {
 178         unsigned long dummy;
 179         return __get_user(dummy, (unsigned long *)p);
 180 }
 181
 182 void dump_pagetable(unsigned long address)
 183 {
 184         pgd_t *pgd;
 185         pud_t *pud;
 186         pmd_t *pmd;
 187         pte_t *pte;
 188
 189         asm("movq %%cr3,%0" : "=r" (pgd));
 190
 191         pgd = __va((unsigned long)pgd & PHYSICAL_PAGE_MASK);
 192         pgd += pgd_index(address);
 193         if (bad_address(pgd)) goto bad;
 194         printk("PGD %lx ", pgd_val(*pgd));
 195         if (!pgd_present(*pgd)) goto ret;
 196
 197         pud = pud_offset(pgd, address);
 198         if (bad_address(pud)) goto bad;
 199         printk("PUD %lx ", pud_val(*pud));
 200         if (!pud_present(*pud)) goto ret;
 201
 202         pmd = pmd_offset(pud, address);
 203         if (bad_address(pmd)) goto bad;
 204         printk("PMD %lx ", pmd_val(*pmd));
 205         if (!pmd_present(*pmd)) goto ret;
 206
 207         pte = pte_offset_kernel(pmd, address);
 208         if (bad_address(pte)) goto bad;
 209         printk("PTE %lx", pte_val(*pte));
 210 ret:
 211         printk("\n");
 212         return;
 213 bad:
 214         printk("BAD\n");
 215 }
 216
 217 static const char errata93_warning[] =
 218 KERN_ERR "******* Your BIOS seems to not contain a fix for K8 errata #93\n"
 219 KERN_ERR "******* Working around it, but it may cause SEGVs or burn power.\n"
 220 KERN_ERR "******* Please consider a BIOS update.\n"
 221 KERN_ERR "******* Disabling USB legacy in the BIOS may also help.\n";
 222
 223 /* Workaround for K8 erratum #93 & buggy BIOS.
 224    BIOS SMM functions are required to use a specific workaround
 225    to avoid corruption of the 64bit RIP register on C stepping K8.
 226    A lot of BIOS that didn't get tested properly miss this.
 227    The OS sees this as a page fault with the upper 32bits of RIP cleared.
 228    Try to work around it here.
 229    Note we only handle faults in kernel here. */
 230
 231 static int is_errata93(struct pt_regs *regs, unsigned long address)
 232 {
 233         static int warned;
 234         if (address != regs->rip)
 235                 return 0;
 236         if ((address >> 32) != 0)
 237                 return 0;
 238         address |= 0xffffffffUL << 32;
 239         if ((address >= (u64)_stext && address <= (u64)_etext) ||
 240             (address >= MODULES_VADDR && address <= MODULES_END)) {
 241                 if (!warned) {
 242                         printk(errata93_warning);
 243                         warned = 1;
 244                 }
 245                 regs->rip = address;
 246                 return 1;
 247         }
 248         return 0;
 249 }
 250
 251 int unhandled_signal(struct task_struct *tsk, int sig)
 252 {
 253         if (tsk->pid == 1)
 254                 return 1;
 255         if (tracehook_consider_fatal_signal(tsk, sig))
 256                 return 0;
 257         return (tsk->sighand->action[sig-1].sa.sa_handler == SIG_IGN) ||
 258                 (tsk->sighand->action[sig-1].sa.sa_handler == SIG_DFL);
 259 }
 260
 261 static noinline void pgtable_bad(unsigned long address, struct pt_regs *regs,
 262                                  unsigned long error_code)
 263 {
 264         unsigned long flags = oops_begin();
 265         struct task_struct *tsk;
 266
 267         printk(KERN_ALERT "%s: Corrupted page table at address %lx\n",
 268                current->comm, address);
 269         dump_pagetable(address);
 270         tsk = current;
 271         tsk->thread.cr2 = address;
 272         tsk->thread.trap_no = 14;
 273         tsk->thread.error_code = error_code;
 274         __die("Bad pagetable", regs, error_code);
 275         oops_end(flags);
 276         do_exit(SIGKILL);
 277 }
 278
 279 /*
 280  * Handle a fault on the vmalloc area
 281  *
 282  * This assumes no large pages in there.
 283  */
 284 static int vmalloc_fault(unsigned long address)
 285 {
 286         pgd_t *pgd, *pgd_ref;
 287         pud_t *pud, *pud_ref;
 288         pmd_t *pmd, *pmd_ref;
 289         pte_t *pte, *pte_ref;
 290
 291         /* Copy kernel mappings over when needed. This can also
 292            happen within a race in page table update. In the later
 293            case just flush. */
 294
 295         pgd = pgd_offset(current->mm ?: &init_mm, address);
 296         pgd_ref = pgd_offset_k(address);
 297         if (pgd_none(*pgd_ref))
 298                 return -1;
 299         if (pgd_none(*pgd))
 300                 set_pgd(pgd, *pgd_ref);
 301         else
 302                 BUG_ON(pgd_page(*pgd) != pgd_page(*pgd_ref));
 303
 304         /* Below here mismatches are bugs because these lower tables
 305            are shared */
 306
 307         pud = pud_offset(pgd, address);
 308         pud_ref = pud_offset(pgd_ref, address);
 309         if (pud_none(*pud_ref))
 310                 return -1;
 311         if (pud_none(*pud) || pud_page(*pud) != pud_page(*pud_ref))
 312                 BUG();
 313         pmd = pmd_offset(pud, address);
 314         pmd_ref = pmd_offset(pud_ref, address);
 315         if (pmd_none(*pmd_ref))
 316                 return -1;
 317         if (pmd_none(*pmd) || pmd_page(*pmd) != pmd_page(*pmd_ref))
 318                 BUG();
 319         pte_ref = pte_offset_kernel(pmd_ref, address);
 320         if (!pte_present(*pte_ref))
 321                 return -1;
 322         pte = pte_offset_kernel(pmd, address);
 323         /* Don't use pte_page here, because the mappings can point
 324            outside mem_map, and the NUMA hash lookup cannot handle
 325            that. */
 326         if (!pte_present(*pte) || pte_pfn(*pte) != pte_pfn(*pte_ref))
 327                 BUG();
 328         return 0;
 329 }
 330
 331 int page_fault_trace = 0;
 332 int exception_trace = 1;
 333
 334 /*
 335  * This routine handles page faults.  It determines the address,
 336  * and the problem, and then passes it off to one of the appropriate
 337  * routines.
 338  */
 339 asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,
 340                                         unsigned long error_code)
 341 {
 342         struct task_struct *tsk;
 343         struct mm_struct *mm;
 344         struct vm_area_struct * vma;
 345         unsigned long address;
 346         const struct exception_table_entry *fixup;
 347         int write;
 348         unsigned long flags;
 349         siginfo_t info;
 350
 351         tsk = current;
 352         mm = tsk->mm;
 353         prefetchw(&mm->mmap_sem);
 354
 355         /* get the address */
 356         __asm__("movq %%cr2,%0":"=r" (address));
 357
 358         info.si_code = SEGV_MAPERR;
 359
 360
 361         /*
 362          * We fault-in kernel-space virtual memory on-demand. The
 363          * 'reference' page table is init_mm.pgd.
 364          *
 365          * NOTE! We MUST NOT take any locks for this case. We may
 366          * be in an interrupt or a critical region, and should
 367          * only copy the information from the master page table,
 368          * nothing more.
 369          *
 370          * This verifies that the fault happens in kernel space
 371          * (error_code & 4) == 0, and that the fault was not a
 372          * protection error (error_code & 9) == 0.
 373          */
 374         if (unlikely(address >= TASK_SIZE64)) {
 375                 /*
 376                  * Don't check for the module range here: its PML4
 377                  * is always initialized because it's shared with the main
 378                  * kernel text. Only vmalloc may need PML4 syncups.
 379                  */
 380                 if (!(error_code & (PF_RSVD|PF_USER|PF_PROT)) &&
 381                       ((address >= VMALLOC_START && address < VMALLOC_END))) {
 382                         if (vmalloc_fault(address) >= 0)
 383                                 return;
 384                 }
 385                 if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14,
 386                                                 SIGSEGV) == NOTIFY_STOP)
 387                         return;
 388                 /*
 389                  * Don't take the mm semaphore here. If we fixup a prefetch
 390                  * fault we could otherwise deadlock.
 391                  */
 392                 goto bad_area_nosemaphore;
 393         }
 394
 395         if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14,
 396                                         SIGSEGV) == NOTIFY_STOP)
 397                 return;
 398
 399         if (likely(regs->eflags & X86_EFLAGS_IF))
 400                 local_irq_enable();
 401
 402         if (unlikely(page_fault_trace))
 403                 printk("pagefault rip:%lx rsp:%lx cs:%lu ss:%lu address %lx error %lx\n",
 404                        regs->rip,regs->rsp,regs->cs,regs->ss,address,error_code);
 405
 406         if (unlikely(error_code & PF_RSVD))
 407                 pgtable_bad(address, regs, error_code);
 408
 409         /*
 410          * If we're in an interrupt or have no user
 411          * context, we must not take the fault..
 412          */
 413         if (unlikely(in_atomic() || !mm))
 414                 goto bad_area_nosemaphore;
 415
 416  again:
 417         /* When running in the kernel we expect faults to occur only to
 418          * addresses in user space.  All other faults represent errors in the
 419          * kernel and should generate an OOPS.  Unfortunatly, in the case of an
 420          * erroneous fault occurring in a code path which already holds mmap_sem
 421          * we will deadlock attempting to validate the fault against the
 422          * address space.  Luckily the kernel only validly references user
 423          * space from well defined areas of code, which are listed in the
 424          * exceptions table.
 425          *
 426          * As the vast majority of faults will be valid we will only perform
 427          * the source reference check when there is a possibilty of a deadlock.
 428          * Attempt to lock the address space, if we cannot we then validate the
 429          * source.  If this is invalid we can skip the address space check,
 430          * thus avoiding the deadlock.
 431          */
 432         if (!down_read_trylock(&mm->mmap_sem)) {
 433                 if ((error_code & PF_USER) == 0 &&
 434                     !search_exception_tables(regs->rip))
 435                         goto bad_area_nosemaphore;
 436                 down_read(&mm->mmap_sem);
 437         }
 438
 439         vma = find_vma(mm, address);
 440         if (!vma)
 441                 goto bad_area;
 442         if (likely(vma->vm_start <= address))
 443                 goto good_area;
 444         if (!(vma->vm_flags & VM_GROWSDOWN))
 445                 goto bad_area;
 446         if (error_code & 4) {
 447                 /* Allow userspace just enough access below the stack pointer
 448                  * to let the 'enter' instruction work.
 449                  */
 450                 if (address + 65536 + 32 * sizeof(unsigned long) < regs->rsp)
 451                         goto bad_area;
 452         }
 453         if (expand_stack(vma, address))
 454                 goto bad_area;
 455 /*
 456  * Ok, we have a good vm_area for this memory access, so
 457  * we can handle it..
 458  */
 459 good_area:
 460         info.si_code = SEGV_ACCERR;
 461         write = 0;
 462         switch (error_code & (PF_PROT|PF_WRITE)) {
 463                 default:        /* 3: write, present */
 464                         /* fall through */
 465                 case PF_WRITE:          /* write, not present */
 466                         if (!(vma->vm_flags & VM_WRITE))
 467                                 goto bad_area;
 468                         write++;
 469                         break;
 470                 case PF_PROT:           /* read, present */
 471                         goto bad_area;
 472                 case 0:                 /* read, not present */
 473                         if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
 474                                 goto bad_area;
 475         }
 476
 477         /*
 478          * If for any reason at all we couldn't handle the fault,
 479          * make sure we exit gracefully rather than endlessly redo
 480          * the fault.
 481          */
 482         switch (handle_mm_fault(mm, vma, address, write)) {
 483         case VM_FAULT_MINOR:
 484                 tsk->min_flt++;
 485                 break;
 486         case VM_FAULT_MAJOR:
 487                 tsk->maj_flt++;
 488                 break;
 489         case VM_FAULT_SIGBUS:
 490                 goto do_sigbus;
 491         default:
 492                 goto out_of_memory;
 493         }
 494
 495         up_read(&mm->mmap_sem);
 496         return;
 497
 498 /*
 499  * Something tried to access memory that isn't in our memory map..
 500  * Fix it, but check if it's kernel or user first..
 501  */
 502 bad_area:
 503         up_read(&mm->mmap_sem);
 504
 505 bad_area_nosemaphore:
 506         /* User mode accesses just cause a SIGSEGV */
 507         if (error_code & PF_USER) {
 508                 if (is_prefetch(regs, address, error_code))
 509                         return;
 510
 511                 /* Work around K8 erratum #100 K8 in compat mode
 512                    occasionally jumps to illegal addresses >4GB.  We
 513                    catch this here in the page fault handler because
 514                    these addresses are not reachable. Just detect this
 515                    case and return.  Any code segment in LDT is
 516                    compatibility mode. */
 517                 if ((regs->cs == __USER32_CS || (regs->cs & (1<<2))) &&
 518                     (address >> 32))
 519                         return;
 520
 521                 if (exception_trace && unhandled_signal(tsk, SIGSEGV)) {
 522                         printk(
 523                        "%s%s[%d]: segfault at %016lx rip %016lx rsp %016lx error %lx\n",
 524                                         tsk->pid > 1 ? KERN_INFO : KERN_EMERG,
 525                                         tsk->comm, tsk->pid, address, regs->rip,
 526                                         regs->rsp, error_code);
 527                 }
 528
 529                 tsk->thread.cr2 = address;
 530                 /* Kernel addresses are always protection faults */
 531                 tsk->thread.error_code = error_code | (address >= TASK_SIZE);
 532                 tsk->thread.trap_no = 14;
 533                 info.si_signo = SIGSEGV;
 534                 info.si_errno = 0;
 535                 /* info.si_code has been set above */
 536                 info.si_addr = (void __user *)address;
 537                 force_sig_info(SIGSEGV, &info, tsk);
 538                 return;
 539         }
 540
 541 no_context:
 542
 543         /* Are we prepared to handle this kernel fault?  */
 544         fixup = search_exception_tables(regs->rip);
 545         if (fixup) {
 546                 regs->rip = fixup->fixup;
 547                 return;
 548         }
 549
 550         /*
 551          * Hall of shame of CPU/BIOS bugs.
 552          */
 553
 554         if (is_prefetch(regs, address, error_code))
 555                 return;
 556
 557         if (is_errata93(regs, address))
 558                 return;
 559
 560 /*
 561  * Oops. The kernel tried to access some bad page. We'll have to
 562  * terminate things with extreme prejudice.
 563  */
 564
 565         flags = oops_begin();
 566
 567         if (address < PAGE_SIZE)
 568                 printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference");
 569         else
 570                 printk(KERN_ALERT "Unable to handle kernel paging request");
 571         printk(" at %016lx RIP: \n" KERN_ALERT,address);
 572         printk_address(regs->rip);
 573         dump_pagetable(address);
 574         tsk->thread.cr2 = address;
 575         tsk->thread.trap_no = 14;
 576         tsk->thread.error_code = error_code;
 577         __die("Oops", regs, error_code);
 578         /* Executive summary in case the body of the oops scrolled away */
 579         printk(KERN_EMERG "CR2: %016lx\n", address);
 580         oops_end(flags);
 581         do_exit(SIGKILL);
 582
 583 /*
 584  * We ran out of memory, or some other thing happened to us that made
 585  * us unable to handle the page fault gracefully.
 586  */
 587 out_of_memory:
 588         up_read(&mm->mmap_sem);
 589         if (current->pid == 1) {
 590                 yield();
 591                 goto again;
 592         }
 593         printk("VM: killing process %s\n", tsk->comm);
 594         if (error_code & 4)
 595                 do_exit(SIGKILL);
 596         goto no_context;
 597
 598 do_sigbus:
 599         up_read(&mm->mmap_sem);
 600
 601         /* Kernel mode? Handle exceptions or die */
 602         if (!(error_code & PF_USER))
 603                 goto no_context;
 604
 605         tsk->thread.cr2 = address;
 606         tsk->thread.error_code = error_code;
 607         tsk->thread.trap_no = 14;
 608         info.si_signo = SIGBUS;
 609         info.si_errno = 0;
 610         info.si_code = BUS_ADRERR;
 611         info.si_addr = (void __user *)address;
 612         force_sig_info(SIGBUS, &info, tsk);
 613         return;
 614 }
 615
 616 DEFINE_SPINLOCK(pgd_lock);
 617 struct page *pgd_list;
 618
 619 void vmalloc_sync_all(void)
 620 {
 621         /* Note that races in the updates of insync and start aren't
 622            problematic:
 623            insync can only get set bits added, and updates to start are only
 624            improving performance (without affecting correctness if undone). */
 625         static DECLARE_BITMAP(insync, PTRS_PER_PGD);
 626         static unsigned long start = VMALLOC_START & PGDIR_MASK;
 627         unsigned long address;
 628
 629         for (address = start; address <= VMALLOC_END; address += PGDIR_SIZE) {
 630                 if (!test_bit(pgd_index(address), insync)) {
 631                         const pgd_t *pgd_ref = pgd_offset_k(address);
 632                         struct page *page;
 633
 634                         if (pgd_none(*pgd_ref))
 635                                 continue;
 636                         spin_lock(&pgd_lock);
 637                         for (page = pgd_list; page;
 638                              page = (struct page *)page->index) {
 639                                 pgd_t *pgd;
 640                                 pgd = (pgd_t *)page_address(page) + pgd_index(address);
 641                                 if (pgd_none(*pgd))
 642                                         set_pgd(pgd, *pgd_ref);
 643                                 else
 644                                         BUG_ON(pgd_page(*pgd) != pgd_page(*pgd_ref));
 645                         }
 646                         spin_unlock(&pgd_lock);
 647                         set_bit(pgd_index(address), insync);
 648                 }
 649                 if (address == start)
 650                         start = address + PGDIR_SIZE;
 651         }
 652         /* Check that there is no need to do the same for the modules area. */
 653         BUILD_BUG_ON(!(MODULES_VADDR > __START_KERNEL));
 654         BUILD_BUG_ON(!(((MODULES_END - 1) & PGDIR_MASK) ==
 655                                 (__START_KERNEL & PGDIR_MASK)));
 656 }
 657
 658 static int __init enable_pagefaulttrace(char *str)
 659 {
 660         page_fault_trace = 1;
 661         return 1;
 662 }
 663 __setup("pagefaulttrace", enable_pagefaulttrace);