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
  27 #include <asm/system.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/pgalloc.h>
  30 #include <asm/hardirq.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
  37 void bust_spinlocks(int yes)
  38 {
  39         int loglevel_save = console_loglevel;
  40         if (yes) {
  41                 oops_in_progress = 1;
  42         } else {
  43 #ifdef CONFIG_VT
  44                 unblank_screen();
  45 #endif
  46                 oops_in_progress = 0;
  47                 /*
  48                  * OK, the message is on the console.  Now we call printk()
  49                  * without oops_in_progress set so that printk will give klogd
  50                  * a poke.  Hold onto your hats...
  51                  */
  52                 console_loglevel = 15;          /* NMI oopser may have shut the console up */
  53                 printk(" ");
  54                 console_loglevel = loglevel_save;
  55         }
  56 }
  57
  58 /* Sometimes the CPU reports invalid exceptions on prefetch.
  59    Check that here and ignore.
  60    Opcode checker based on code by Richard Brunner */
  61 static int is_prefetch(struct pt_regs *regs, unsigned long addr)
  62 {
  63         unsigned char *instr = (unsigned char *)(regs->rip);
  64         int scan_more = 1;
  65         int prefetch = 0;
  66         unsigned char *max_instr = instr + 15;
  67
  68         /* Avoid recursive faults for this common case */
  69         if (regs->rip == addr)
  70                 return 0;
  71
  72         /* Code segments in LDT could have a non zero base. Don't check
  73            when that's possible */
  74         if (regs->cs & (1<<2))
  75                 return 0;
  76
  77         if ((regs->cs & 3) != 0 && regs->rip >= 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 = ((regs->cs & 3) == 0) || (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         pml4_t *pml4;
 145         pgd_t *pgd;
 146         pmd_t *pmd;
 147         pte_t *pte;
 148
 149         asm("movq %%cr3,%0" : "=r" (pml4));
 150
 151         pml4 = __va((unsigned long)pml4 & PHYSICAL_PAGE_MASK);
 152         pml4 += pml4_index(address);
 153         printk("PML4 %lx ", pml4_val(*pml4));
 154         if (bad_address(pml4)) goto bad;
 155         if (!pml4_present(*pml4)) goto ret;
 156
 157         pgd = __pgd_offset_k((pgd_t *)pml4_page(*pml4), address);
 158         if (bad_address(pgd)) goto bad;
 159         printk("PGD %lx ", pgd_val(*pgd));
 160         if (!pgd_present(*pgd)) goto ret;
 161
 162         pmd = pmd_offset(pgd, 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         /* Warn for strace, but not for gdb */
 214         if (!test_ti_thread_flag(tsk->thread_info, TIF_SYSCALL_TRACE) &&
 215             (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 int page_fault_trace;
 222 int exception_trace = 1;
 223
 224 /*
 225  * This routine handles page faults.  It determines the address,
 226  * and the problem, and then passes it off to one of the appropriate
 227  * routines.
 228  *
 229  * error_code:
 230  *      bit 0 == 0 means no page found, 1 means protection fault
 231  *      bit 1 == 0 means read, 1 means write
 232  *      bit 2 == 0 means kernel, 1 means user-mode
 233  *      bit 3 == 1 means fault was an instruction fetch
 234  */
 235 asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long error_code)
 236 {
 237         struct task_struct *tsk;
 238         struct mm_struct *mm;
 239         struct vm_area_struct * vma;
 240         unsigned long address;
 241         const struct exception_table_entry *fixup;
 242         int write;
 243         siginfo_t info;
 244
 245 #ifdef CONFIG_CHECKING
 246         {
 247                 unsigned long gs;
 248                 struct x8664_pda *pda = cpu_pda + stack_smp_processor_id();
 249                 rdmsrl(MSR_GS_BASE, gs);
 250                 if (gs != (unsigned long)pda) {
 251                         wrmsrl(MSR_GS_BASE, pda);
 252                         printk("page_fault: wrong gs %lx expected %p\n", gs, pda);
 253                 }
 254         }
 255 #endif
 256
 257         /* get the address */
 258         __asm__("movq %%cr2,%0":"=r" (address));
 259
 260         if (likely(regs->eflags & X86_EFLAGS_IF))
 261                 local_irq_enable();
 262
 263         if (unlikely(page_fault_trace))
 264                 printk("pagefault rip:%lx rsp:%lx cs:%lu ss:%lu address %lx error %lx\n",
 265                        regs->rip,regs->rsp,regs->cs,regs->ss,address,error_code);
 266
 267         tsk = current;
 268         mm = tsk->mm;
 269         info.si_code = SEGV_MAPERR;
 270
 271         /* 5 => page not present and from supervisor mode */
 272         if (unlikely(!(error_code & 5) &&
 273                      ((address >= VMALLOC_START && address <= VMALLOC_END) ||
 274                       (address >= MODULES_VADDR && address <= MODULES_END))))
 275                 goto vmalloc_fault;
 276
 277         /*
 278          * If we're in an interrupt or have no user
 279          * context, we must not take the fault..
 280          */
 281         if (unlikely(in_atomic() || !mm))
 282                 goto bad_area_nosemaphore;
 283
 284  again:
 285         down_read(&mm->mmap_sem);
 286
 287         vma = find_vma(mm, address);
 288         if (!vma)
 289                 goto bad_area;
 290         if (likely(vma->vm_start <= address))
 291                 goto good_area;
 292         if (!(vma->vm_flags & VM_GROWSDOWN))
 293                 goto bad_area;
 294         if (error_code & 4) {
 295                 // XXX: align red zone size with ABI
 296                 if (address + 128 < regs->rsp)
 297                         goto bad_area;
 298         }
 299         if (expand_stack(vma, address))
 300                 goto bad_area;
 301 /*
 302  * Ok, we have a good vm_area for this memory access, so
 303  * we can handle it..
 304  */
 305 good_area:
 306         info.si_code = SEGV_ACCERR;
 307         write = 0;
 308         switch (error_code & 3) {
 309                 default:        /* 3: write, present */
 310                         /* fall through */
 311                 case 2:         /* write, not present */
 312                         if (!(vma->vm_flags & VM_WRITE))
 313                                 goto bad_area;
 314                         write++;
 315                         break;
 316                 case 1:         /* read, present */
 317                         goto bad_area;
 318                 case 0:         /* read, not present */
 319                         if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
 320                                 goto bad_area;
 321         }
 322
 323         /*
 324          * If for any reason at all we couldn't handle the fault,
 325          * make sure we exit gracefully rather than endlessly redo
 326          * the fault.
 327          */
 328         switch (handle_mm_fault(mm, vma, address, write)) {
 329         case 1:
 330                 tsk->min_flt++;
 331                 break;
 332         case 2:
 333                 tsk->maj_flt++;
 334                 break;
 335         case 0:
 336                 goto do_sigbus;
 337         default:
 338                 goto out_of_memory;
 339         }
 340
 341         up_read(&mm->mmap_sem);
 342         return;
 343
 344 /*
 345  * Something tried to access memory that isn't in our memory map..
 346  * Fix it, but check if it's kernel or user first..
 347  */
 348 bad_area:
 349         up_read(&mm->mmap_sem);
 350
 351 bad_area_nosemaphore:
 352
 353 #ifdef CONFIG_IA32_EMULATION
 354                 /* 32bit vsyscall. map on demand. */
 355                 if (test_thread_flag(TIF_IA32) &&
 356             address >= 0xffffe000 && address < 0xffffe000 + PAGE_SIZE) {
 357                         if (map_syscall32(mm, address) < 0)
 358                                 goto out_of_memory2;
 359                         return;
 360                 }
 361 #endif
 362
 363         /* User mode accesses just cause a SIGSEGV */
 364         if (error_code & 4) {
 365                 if (is_prefetch(regs, address))
 366                         return;
 367
 368                 /* Work around K8 erratum #100 K8 in compat mode
 369                    occasionally jumps to illegal addresses >4GB.  We
 370                    catch this here in the page fault handler because
 371                    these addresses are not reachable. Just detect this
 372                    case and return.  Any code segment in LDT is
 373                    compatibility mode. */
 374                 if ((regs->cs == __USER32_CS || (regs->cs & (1<<2))) &&
 375                     (address >> 32))
 376                         return;
 377
 378                 if (exception_trace && unhandled_signal(tsk, SIGSEGV)) {
 379                 printk(KERN_INFO
 380                        "%s[%d]: segfault at %016lx rip %016lx rsp %016lx error %lx\n",
 381                                         tsk->comm, tsk->pid, address, regs->rip,
 382                                         regs->rsp, error_code);
 383                 }
 384
 385                 tsk->thread.cr2 = address;
 386                 /* Kernel addresses are always protection faults */
 387                 tsk->thread.error_code = error_code | (address >= TASK_SIZE);
 388                 tsk->thread.trap_no = 14;
 389                 info.si_signo = SIGSEGV;
 390                 info.si_errno = 0;
 391                 /* info.si_code has been set above */
 392                 info.si_addr = (void *)address;
 393                 force_sig_info(SIGSEGV, &info, tsk);
 394                 return;
 395         }
 396
 397 no_context:
 398
 399         /* Are we prepared to handle this kernel fault?  */
 400         fixup = search_exception_tables(regs->rip);
 401         if (fixup) {
 402                 regs->rip = fixup->fixup;
 403                 return;
 404         }
 405
 406         /*
 407          * Hall of shame of CPU/BIOS bugs.
 408          */
 409
 410         if (is_prefetch(regs, address))
 411                 return;
 412
 413         if (is_errata93(regs, address))
 414                 return;
 415
 416 /*
 417  * Oops. The kernel tried to access some bad page. We'll have to
 418  * terminate things with extreme prejudice.
 419  */
 420
 421         oops_begin();
 422
 423         if (address < PAGE_SIZE)
 424                 printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference");
 425         else
 426                 printk(KERN_ALERT "Unable to handle kernel paging request");
 427         printk(" at %016lx RIP: \n" KERN_ALERT,address);
 428         printk_address(regs->rip);
 429         printk("\n");
 430         dump_pagetable(address);
 431         __die("Oops", regs, error_code);
 432         /* Executive summary in case the body of the oops scrolled away */
 433         printk(KERN_EMERG "CR2: %016lx\n", address);
 434         oops_end();
 435         do_exit(SIGKILL);
 436
 437 /*
 438  * We ran out of memory, or some other thing happened to us that made
 439  * us unable to handle the page fault gracefully.
 440  */
 441 out_of_memory:
 442         up_read(&mm->mmap_sem);
 443 out_of_memory2:
 444         if (current->pid == 1) {
 445                 yield();
 446                 goto again;
 447         }
 448         printk("VM: killing process %s\n", tsk->comm);
 449         if (error_code & 4)
 450                 do_exit(SIGKILL);
 451         goto no_context;
 452
 453 do_sigbus:
 454         up_read(&mm->mmap_sem);
 455
 456         /* Kernel mode? Handle exceptions or die */
 457         if (!(error_code & 4))
 458                 goto no_context;
 459
 460         tsk->thread.cr2 = address;
 461         tsk->thread.error_code = error_code;
 462         tsk->thread.trap_no = 14;
 463         info.si_signo = SIGBUS;
 464         info.si_errno = 0;
 465         info.si_code = BUS_ADRERR;
 466         info.si_addr = (void *)address;
 467         force_sig_info(SIGBUS, &info, tsk);
 468         return;
 469
 470 vmalloc_fault:
 471         {
 472                 pgd_t *pgd;
 473                 pmd_t *pmd;
 474                 pte_t *pte;
 475
 476                 /*
 477                  * x86-64 has the same kernel 3rd level pages for all CPUs.
 478                  * But for vmalloc/modules the TLB synchronization works lazily,
 479                  * so it can happen that we get a page fault for something
 480                  * that is really already in the page table. Just check if it
 481                  * is really there and when yes flush the local TLB.
 482                  */
 483                 pgd = pgd_offset_k(address);
 484                 if (pgd != current_pgd_offset_k(address))
 485                         BUG();
 486                 if (!pgd_present(*pgd))
 487                                 goto bad_area_nosemaphore;
 488                 pmd = pmd_offset(pgd, address);
 489                 if (!pmd_present(*pmd))
 490                         goto bad_area_nosemaphore;
 491                 pte = pte_offset_kernel(pmd, address);
 492                 if (!pte_present(*pte))
 493                         goto bad_area_nosemaphore;
 494
 495                 __flush_tlb_all();
 496                 return;
 497         }
 498 }