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