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