Loading...
1/*
2 * Copyright (C) 1995 Linus Torvalds
3 * Copyright (C) 2001, 2002 Andi Kleen, SuSE Labs.
4 * Copyright (C) 2008-2009, Red Hat Inc., Ingo Molnar
5 */
6#include <linux/magic.h> /* STACK_END_MAGIC */
7#include <linux/sched.h> /* test_thread_flag(), ... */
8#include <linux/kdebug.h> /* oops_begin/end, ... */
9#include <linux/module.h> /* search_exception_table */
10#include <linux/bootmem.h> /* max_low_pfn */
11#include <linux/kprobes.h> /* __kprobes, ... */
12#include <linux/mmiotrace.h> /* kmmio_handler, ... */
13#include <linux/perf_event.h> /* perf_sw_event */
14#include <linux/hugetlb.h> /* hstate_index_to_shift */
15#include <linux/prefetch.h> /* prefetchw */
16
17#include <asm/traps.h> /* dotraplinkage, ... */
18#include <asm/pgalloc.h> /* pgd_*(), ... */
19#include <asm/kmemcheck.h> /* kmemcheck_*(), ... */
20#include <asm/fixmap.h> /* VSYSCALL_START */
21
22/*
23 * Page fault error code bits:
24 *
25 * bit 0 == 0: no page found 1: protection fault
26 * bit 1 == 0: read access 1: write access
27 * bit 2 == 0: kernel-mode access 1: user-mode access
28 * bit 3 == 1: use of reserved bit detected
29 * bit 4 == 1: fault was an instruction fetch
30 */
31enum x86_pf_error_code {
32
33 PF_PROT = 1 << 0,
34 PF_WRITE = 1 << 1,
35 PF_USER = 1 << 2,
36 PF_RSVD = 1 << 3,
37 PF_INSTR = 1 << 4,
38};
39
40/*
41 * Returns 0 if mmiotrace is disabled, or if the fault is not
42 * handled by mmiotrace:
43 */
44static inline int __kprobes
45kmmio_fault(struct pt_regs *regs, unsigned long addr)
46{
47 if (unlikely(is_kmmio_active()))
48 if (kmmio_handler(regs, addr) == 1)
49 return -1;
50 return 0;
51}
52
53static inline int __kprobes notify_page_fault(struct pt_regs *regs)
54{
55 int ret = 0;
56
57 /* kprobe_running() needs smp_processor_id() */
58 if (kprobes_built_in() && !user_mode_vm(regs)) {
59 preempt_disable();
60 if (kprobe_running() && kprobe_fault_handler(regs, 14))
61 ret = 1;
62 preempt_enable();
63 }
64
65 return ret;
66}
67
68/*
69 * Prefetch quirks:
70 *
71 * 32-bit mode:
72 *
73 * Sometimes AMD Athlon/Opteron CPUs report invalid exceptions on prefetch.
74 * Check that here and ignore it.
75 *
76 * 64-bit mode:
77 *
78 * Sometimes the CPU reports invalid exceptions on prefetch.
79 * Check that here and ignore it.
80 *
81 * Opcode checker based on code by Richard Brunner.
82 */
83static inline int
84check_prefetch_opcode(struct pt_regs *regs, unsigned char *instr,
85 unsigned char opcode, int *prefetch)
86{
87 unsigned char instr_hi = opcode & 0xf0;
88 unsigned char instr_lo = opcode & 0x0f;
89
90 switch (instr_hi) {
91 case 0x20:
92 case 0x30:
93 /*
94 * Values 0x26,0x2E,0x36,0x3E are valid x86 prefixes.
95 * In X86_64 long mode, the CPU will signal invalid
96 * opcode if some of these prefixes are present so
97 * X86_64 will never get here anyway
98 */
99 return ((instr_lo & 7) == 0x6);
100#ifdef CONFIG_X86_64
101 case 0x40:
102 /*
103 * In AMD64 long mode 0x40..0x4F are valid REX prefixes
104 * Need to figure out under what instruction mode the
105 * instruction was issued. Could check the LDT for lm,
106 * but for now it's good enough to assume that long
107 * mode only uses well known segments or kernel.
108 */
109 return (!user_mode(regs) || user_64bit_mode(regs));
110#endif
111 case 0x60:
112 /* 0x64 thru 0x67 are valid prefixes in all modes. */
113 return (instr_lo & 0xC) == 0x4;
114 case 0xF0:
115 /* 0xF0, 0xF2, 0xF3 are valid prefixes in all modes. */
116 return !instr_lo || (instr_lo>>1) == 1;
117 case 0x00:
118 /* Prefetch instruction is 0x0F0D or 0x0F18 */
119 if (probe_kernel_address(instr, opcode))
120 return 0;
121
122 *prefetch = (instr_lo == 0xF) &&
123 (opcode == 0x0D || opcode == 0x18);
124 return 0;
125 default:
126 return 0;
127 }
128}
129
130static int
131is_prefetch(struct pt_regs *regs, unsigned long error_code, unsigned long addr)
132{
133 unsigned char *max_instr;
134 unsigned char *instr;
135 int prefetch = 0;
136
137 /*
138 * If it was a exec (instruction fetch) fault on NX page, then
139 * do not ignore the fault:
140 */
141 if (error_code & PF_INSTR)
142 return 0;
143
144 instr = (void *)convert_ip_to_linear(current, regs);
145 max_instr = instr + 15;
146
147 if (user_mode(regs) && instr >= (unsigned char *)TASK_SIZE)
148 return 0;
149
150 while (instr < max_instr) {
151 unsigned char opcode;
152
153 if (probe_kernel_address(instr, opcode))
154 break;
155
156 instr++;
157
158 if (!check_prefetch_opcode(regs, instr, opcode, &prefetch))
159 break;
160 }
161 return prefetch;
162}
163
164static void
165force_sig_info_fault(int si_signo, int si_code, unsigned long address,
166 struct task_struct *tsk, int fault)
167{
168 unsigned lsb = 0;
169 siginfo_t info;
170
171 info.si_signo = si_signo;
172 info.si_errno = 0;
173 info.si_code = si_code;
174 info.si_addr = (void __user *)address;
175 if (fault & VM_FAULT_HWPOISON_LARGE)
176 lsb = hstate_index_to_shift(VM_FAULT_GET_HINDEX(fault));
177 if (fault & VM_FAULT_HWPOISON)
178 lsb = PAGE_SHIFT;
179 info.si_addr_lsb = lsb;
180
181 force_sig_info(si_signo, &info, tsk);
182}
183
184DEFINE_SPINLOCK(pgd_lock);
185LIST_HEAD(pgd_list);
186
187#ifdef CONFIG_X86_32
188static inline pmd_t *vmalloc_sync_one(pgd_t *pgd, unsigned long address)
189{
190 unsigned index = pgd_index(address);
191 pgd_t *pgd_k;
192 pud_t *pud, *pud_k;
193 pmd_t *pmd, *pmd_k;
194
195 pgd += index;
196 pgd_k = init_mm.pgd + index;
197
198 if (!pgd_present(*pgd_k))
199 return NULL;
200
201 /*
202 * set_pgd(pgd, *pgd_k); here would be useless on PAE
203 * and redundant with the set_pmd() on non-PAE. As would
204 * set_pud.
205 */
206 pud = pud_offset(pgd, address);
207 pud_k = pud_offset(pgd_k, address);
208 if (!pud_present(*pud_k))
209 return NULL;
210
211 pmd = pmd_offset(pud, address);
212 pmd_k = pmd_offset(pud_k, address);
213 if (!pmd_present(*pmd_k))
214 return NULL;
215
216 if (!pmd_present(*pmd))
217 set_pmd(pmd, *pmd_k);
218 else
219 BUG_ON(pmd_page(*pmd) != pmd_page(*pmd_k));
220
221 return pmd_k;
222}
223
224void vmalloc_sync_all(void)
225{
226 unsigned long address;
227
228 if (SHARED_KERNEL_PMD)
229 return;
230
231 for (address = VMALLOC_START & PMD_MASK;
232 address >= TASK_SIZE && address < FIXADDR_TOP;
233 address += PMD_SIZE) {
234 struct page *page;
235
236 spin_lock(&pgd_lock);
237 list_for_each_entry(page, &pgd_list, lru) {
238 spinlock_t *pgt_lock;
239 pmd_t *ret;
240
241 /* the pgt_lock only for Xen */
242 pgt_lock = &pgd_page_get_mm(page)->page_table_lock;
243
244 spin_lock(pgt_lock);
245 ret = vmalloc_sync_one(page_address(page), address);
246 spin_unlock(pgt_lock);
247
248 if (!ret)
249 break;
250 }
251 spin_unlock(&pgd_lock);
252 }
253}
254
255/*
256 * 32-bit:
257 *
258 * Handle a fault on the vmalloc or module mapping area
259 */
260static noinline __kprobes int vmalloc_fault(unsigned long address)
261{
262 unsigned long pgd_paddr;
263 pmd_t *pmd_k;
264 pte_t *pte_k;
265
266 /* Make sure we are in vmalloc area: */
267 if (!(address >= VMALLOC_START && address < VMALLOC_END))
268 return -1;
269
270 WARN_ON_ONCE(in_nmi());
271
272 /*
273 * Synchronize this task's top level page-table
274 * with the 'reference' page table.
275 *
276 * Do _not_ use "current" here. We might be inside
277 * an interrupt in the middle of a task switch..
278 */
279 pgd_paddr = read_cr3();
280 pmd_k = vmalloc_sync_one(__va(pgd_paddr), address);
281 if (!pmd_k)
282 return -1;
283
284 pte_k = pte_offset_kernel(pmd_k, address);
285 if (!pte_present(*pte_k))
286 return -1;
287
288 return 0;
289}
290
291/*
292 * Did it hit the DOS screen memory VA from vm86 mode?
293 */
294static inline void
295check_v8086_mode(struct pt_regs *regs, unsigned long address,
296 struct task_struct *tsk)
297{
298 unsigned long bit;
299
300 if (!v8086_mode(regs))
301 return;
302
303 bit = (address - 0xA0000) >> PAGE_SHIFT;
304 if (bit < 32)
305 tsk->thread.screen_bitmap |= 1 << bit;
306}
307
308static bool low_pfn(unsigned long pfn)
309{
310 return pfn < max_low_pfn;
311}
312
313static void dump_pagetable(unsigned long address)
314{
315 pgd_t *base = __va(read_cr3());
316 pgd_t *pgd = &base[pgd_index(address)];
317 pmd_t *pmd;
318 pte_t *pte;
319
320#ifdef CONFIG_X86_PAE
321 printk("*pdpt = %016Lx ", pgd_val(*pgd));
322 if (!low_pfn(pgd_val(*pgd) >> PAGE_SHIFT) || !pgd_present(*pgd))
323 goto out;
324#endif
325 pmd = pmd_offset(pud_offset(pgd, address), address);
326 printk(KERN_CONT "*pde = %0*Lx ", sizeof(*pmd) * 2, (u64)pmd_val(*pmd));
327
328 /*
329 * We must not directly access the pte in the highpte
330 * case if the page table is located in highmem.
331 * And let's rather not kmap-atomic the pte, just in case
332 * it's allocated already:
333 */
334 if (!low_pfn(pmd_pfn(*pmd)) || !pmd_present(*pmd) || pmd_large(*pmd))
335 goto out;
336
337 pte = pte_offset_kernel(pmd, address);
338 printk("*pte = %0*Lx ", sizeof(*pte) * 2, (u64)pte_val(*pte));
339out:
340 printk("\n");
341}
342
343#else /* CONFIG_X86_64: */
344
345void vmalloc_sync_all(void)
346{
347 sync_global_pgds(VMALLOC_START & PGDIR_MASK, VMALLOC_END);
348}
349
350/*
351 * 64-bit:
352 *
353 * Handle a fault on the vmalloc area
354 *
355 * This assumes no large pages in there.
356 */
357static noinline __kprobes int vmalloc_fault(unsigned long address)
358{
359 pgd_t *pgd, *pgd_ref;
360 pud_t *pud, *pud_ref;
361 pmd_t *pmd, *pmd_ref;
362 pte_t *pte, *pte_ref;
363
364 /* Make sure we are in vmalloc area: */
365 if (!(address >= VMALLOC_START && address < VMALLOC_END))
366 return -1;
367
368 WARN_ON_ONCE(in_nmi());
369
370 /*
371 * Copy kernel mappings over when needed. This can also
372 * happen within a race in page table update. In the later
373 * case just flush:
374 */
375 pgd = pgd_offset(current->active_mm, address);
376 pgd_ref = pgd_offset_k(address);
377 if (pgd_none(*pgd_ref))
378 return -1;
379
380 if (pgd_none(*pgd))
381 set_pgd(pgd, *pgd_ref);
382 else
383 BUG_ON(pgd_page_vaddr(*pgd) != pgd_page_vaddr(*pgd_ref));
384
385 /*
386 * Below here mismatches are bugs because these lower tables
387 * are shared:
388 */
389
390 pud = pud_offset(pgd, address);
391 pud_ref = pud_offset(pgd_ref, address);
392 if (pud_none(*pud_ref))
393 return -1;
394
395 if (pud_none(*pud) || pud_page_vaddr(*pud) != pud_page_vaddr(*pud_ref))
396 BUG();
397
398 pmd = pmd_offset(pud, address);
399 pmd_ref = pmd_offset(pud_ref, address);
400 if (pmd_none(*pmd_ref))
401 return -1;
402
403 if (pmd_none(*pmd) || pmd_page(*pmd) != pmd_page(*pmd_ref))
404 BUG();
405
406 pte_ref = pte_offset_kernel(pmd_ref, address);
407 if (!pte_present(*pte_ref))
408 return -1;
409
410 pte = pte_offset_kernel(pmd, address);
411
412 /*
413 * Don't use pte_page here, because the mappings can point
414 * outside mem_map, and the NUMA hash lookup cannot handle
415 * that:
416 */
417 if (!pte_present(*pte) || pte_pfn(*pte) != pte_pfn(*pte_ref))
418 BUG();
419
420 return 0;
421}
422
423#ifdef CONFIG_CPU_SUP_AMD
424static const char errata93_warning[] =
425KERN_ERR
426"******* Your BIOS seems to not contain a fix for K8 errata #93\n"
427"******* Working around it, but it may cause SEGVs or burn power.\n"
428"******* Please consider a BIOS update.\n"
429"******* Disabling USB legacy in the BIOS may also help.\n";
430#endif
431
432/*
433 * No vm86 mode in 64-bit mode:
434 */
435static inline void
436check_v8086_mode(struct pt_regs *regs, unsigned long address,
437 struct task_struct *tsk)
438{
439}
440
441static int bad_address(void *p)
442{
443 unsigned long dummy;
444
445 return probe_kernel_address((unsigned long *)p, dummy);
446}
447
448static void dump_pagetable(unsigned long address)
449{
450 pgd_t *base = __va(read_cr3() & PHYSICAL_PAGE_MASK);
451 pgd_t *pgd = base + pgd_index(address);
452 pud_t *pud;
453 pmd_t *pmd;
454 pte_t *pte;
455
456 if (bad_address(pgd))
457 goto bad;
458
459 printk("PGD %lx ", pgd_val(*pgd));
460
461 if (!pgd_present(*pgd))
462 goto out;
463
464 pud = pud_offset(pgd, address);
465 if (bad_address(pud))
466 goto bad;
467
468 printk("PUD %lx ", pud_val(*pud));
469 if (!pud_present(*pud) || pud_large(*pud))
470 goto out;
471
472 pmd = pmd_offset(pud, address);
473 if (bad_address(pmd))
474 goto bad;
475
476 printk("PMD %lx ", pmd_val(*pmd));
477 if (!pmd_present(*pmd) || pmd_large(*pmd))
478 goto out;
479
480 pte = pte_offset_kernel(pmd, address);
481 if (bad_address(pte))
482 goto bad;
483
484 printk("PTE %lx", pte_val(*pte));
485out:
486 printk("\n");
487 return;
488bad:
489 printk("BAD\n");
490}
491
492#endif /* CONFIG_X86_64 */
493
494/*
495 * Workaround for K8 erratum #93 & buggy BIOS.
496 *
497 * BIOS SMM functions are required to use a specific workaround
498 * to avoid corruption of the 64bit RIP register on C stepping K8.
499 *
500 * A lot of BIOS that didn't get tested properly miss this.
501 *
502 * The OS sees this as a page fault with the upper 32bits of RIP cleared.
503 * Try to work around it here.
504 *
505 * Note we only handle faults in kernel here.
506 * Does nothing on 32-bit.
507 */
508static int is_errata93(struct pt_regs *regs, unsigned long address)
509{
510#if defined(CONFIG_X86_64) && defined(CONFIG_CPU_SUP_AMD)
511 if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD
512 || boot_cpu_data.x86 != 0xf)
513 return 0;
514
515 if (address != regs->ip)
516 return 0;
517
518 if ((address >> 32) != 0)
519 return 0;
520
521 address |= 0xffffffffUL << 32;
522 if ((address >= (u64)_stext && address <= (u64)_etext) ||
523 (address >= MODULES_VADDR && address <= MODULES_END)) {
524 printk_once(errata93_warning);
525 regs->ip = address;
526 return 1;
527 }
528#endif
529 return 0;
530}
531
532/*
533 * Work around K8 erratum #100 K8 in compat mode occasionally jumps
534 * to illegal addresses >4GB.
535 *
536 * We catch this in the page fault handler because these addresses
537 * are not reachable. Just detect this case and return. Any code
538 * segment in LDT is compatibility mode.
539 */
540static int is_errata100(struct pt_regs *regs, unsigned long address)
541{
542#ifdef CONFIG_X86_64
543 if ((regs->cs == __USER32_CS || (regs->cs & (1<<2))) && (address >> 32))
544 return 1;
545#endif
546 return 0;
547}
548
549static int is_f00f_bug(struct pt_regs *regs, unsigned long address)
550{
551#ifdef CONFIG_X86_F00F_BUG
552 unsigned long nr;
553
554 /*
555 * Pentium F0 0F C7 C8 bug workaround:
556 */
557 if (boot_cpu_data.f00f_bug) {
558 nr = (address - idt_descr.address) >> 3;
559
560 if (nr == 6) {
561 do_invalid_op(regs, 0);
562 return 1;
563 }
564 }
565#endif
566 return 0;
567}
568
569static const char nx_warning[] = KERN_CRIT
570"kernel tried to execute NX-protected page - exploit attempt? (uid: %d)\n";
571
572static void
573show_fault_oops(struct pt_regs *regs, unsigned long error_code,
574 unsigned long address)
575{
576 if (!oops_may_print())
577 return;
578
579 if (error_code & PF_INSTR) {
580 unsigned int level;
581
582 pte_t *pte = lookup_address(address, &level);
583
584 if (pte && pte_present(*pte) && !pte_exec(*pte))
585 printk(nx_warning, from_kuid(&init_user_ns, current_uid()));
586 }
587
588 printk(KERN_ALERT "BUG: unable to handle kernel ");
589 if (address < PAGE_SIZE)
590 printk(KERN_CONT "NULL pointer dereference");
591 else
592 printk(KERN_CONT "paging request");
593
594 printk(KERN_CONT " at %p\n", (void *) address);
595 printk(KERN_ALERT "IP:");
596 printk_address(regs->ip, 1);
597
598 dump_pagetable(address);
599}
600
601static noinline void
602pgtable_bad(struct pt_regs *regs, unsigned long error_code,
603 unsigned long address)
604{
605 struct task_struct *tsk;
606 unsigned long flags;
607 int sig;
608
609 flags = oops_begin();
610 tsk = current;
611 sig = SIGKILL;
612
613 printk(KERN_ALERT "%s: Corrupted page table at address %lx\n",
614 tsk->comm, address);
615 dump_pagetable(address);
616
617 tsk->thread.cr2 = address;
618 tsk->thread.trap_nr = X86_TRAP_PF;
619 tsk->thread.error_code = error_code;
620
621 if (__die("Bad pagetable", regs, error_code))
622 sig = 0;
623
624 oops_end(flags, regs, sig);
625}
626
627static noinline void
628no_context(struct pt_regs *regs, unsigned long error_code,
629 unsigned long address, int signal, int si_code)
630{
631 struct task_struct *tsk = current;
632 unsigned long *stackend;
633 unsigned long flags;
634 int sig;
635
636 /* Are we prepared to handle this kernel fault? */
637 if (fixup_exception(regs)) {
638 if (current_thread_info()->sig_on_uaccess_error && signal) {
639 tsk->thread.trap_nr = X86_TRAP_PF;
640 tsk->thread.error_code = error_code | PF_USER;
641 tsk->thread.cr2 = address;
642
643 /* XXX: hwpoison faults will set the wrong code. */
644 force_sig_info_fault(signal, si_code, address, tsk, 0);
645 }
646 return;
647 }
648
649 /*
650 * 32-bit:
651 *
652 * Valid to do another page fault here, because if this fault
653 * had been triggered by is_prefetch fixup_exception would have
654 * handled it.
655 *
656 * 64-bit:
657 *
658 * Hall of shame of CPU/BIOS bugs.
659 */
660 if (is_prefetch(regs, error_code, address))
661 return;
662
663 if (is_errata93(regs, address))
664 return;
665
666 /*
667 * Oops. The kernel tried to access some bad page. We'll have to
668 * terminate things with extreme prejudice:
669 */
670 flags = oops_begin();
671
672 show_fault_oops(regs, error_code, address);
673
674 stackend = end_of_stack(tsk);
675 if (tsk != &init_task && *stackend != STACK_END_MAGIC)
676 printk(KERN_EMERG "Thread overran stack, or stack corrupted\n");
677
678 tsk->thread.cr2 = address;
679 tsk->thread.trap_nr = X86_TRAP_PF;
680 tsk->thread.error_code = error_code;
681
682 sig = SIGKILL;
683 if (__die("Oops", regs, error_code))
684 sig = 0;
685
686 /* Executive summary in case the body of the oops scrolled away */
687 printk(KERN_DEFAULT "CR2: %016lx\n", address);
688
689 oops_end(flags, regs, sig);
690}
691
692/*
693 * Print out info about fatal segfaults, if the show_unhandled_signals
694 * sysctl is set:
695 */
696static inline void
697show_signal_msg(struct pt_regs *regs, unsigned long error_code,
698 unsigned long address, struct task_struct *tsk)
699{
700 if (!unhandled_signal(tsk, SIGSEGV))
701 return;
702
703 if (!printk_ratelimit())
704 return;
705
706 printk("%s%s[%d]: segfault at %lx ip %p sp %p error %lx",
707 task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
708 tsk->comm, task_pid_nr(tsk), address,
709 (void *)regs->ip, (void *)regs->sp, error_code);
710
711 print_vma_addr(KERN_CONT " in ", regs->ip);
712
713 printk(KERN_CONT "\n");
714}
715
716static void
717__bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,
718 unsigned long address, int si_code)
719{
720 struct task_struct *tsk = current;
721
722 /* User mode accesses just cause a SIGSEGV */
723 if (error_code & PF_USER) {
724 /*
725 * It's possible to have interrupts off here:
726 */
727 local_irq_enable();
728
729 /*
730 * Valid to do another page fault here because this one came
731 * from user space:
732 */
733 if (is_prefetch(regs, error_code, address))
734 return;
735
736 if (is_errata100(regs, address))
737 return;
738
739#ifdef CONFIG_X86_64
740 /*
741 * Instruction fetch faults in the vsyscall page might need
742 * emulation.
743 */
744 if (unlikely((error_code & PF_INSTR) &&
745 ((address & ~0xfff) == VSYSCALL_START))) {
746 if (emulate_vsyscall(regs, address))
747 return;
748 }
749#endif
750
751 if (unlikely(show_unhandled_signals))
752 show_signal_msg(regs, error_code, address, tsk);
753
754 /* Kernel addresses are always protection faults: */
755 tsk->thread.cr2 = address;
756 tsk->thread.error_code = error_code | (address >= TASK_SIZE);
757 tsk->thread.trap_nr = X86_TRAP_PF;
758
759 force_sig_info_fault(SIGSEGV, si_code, address, tsk, 0);
760
761 return;
762 }
763
764 if (is_f00f_bug(regs, address))
765 return;
766
767 no_context(regs, error_code, address, SIGSEGV, si_code);
768}
769
770static noinline void
771bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,
772 unsigned long address)
773{
774 __bad_area_nosemaphore(regs, error_code, address, SEGV_MAPERR);
775}
776
777static void
778__bad_area(struct pt_regs *regs, unsigned long error_code,
779 unsigned long address, int si_code)
780{
781 struct mm_struct *mm = current->mm;
782
783 /*
784 * Something tried to access memory that isn't in our memory map..
785 * Fix it, but check if it's kernel or user first..
786 */
787 up_read(&mm->mmap_sem);
788
789 __bad_area_nosemaphore(regs, error_code, address, si_code);
790}
791
792static noinline void
793bad_area(struct pt_regs *regs, unsigned long error_code, unsigned long address)
794{
795 __bad_area(regs, error_code, address, SEGV_MAPERR);
796}
797
798static noinline void
799bad_area_access_error(struct pt_regs *regs, unsigned long error_code,
800 unsigned long address)
801{
802 __bad_area(regs, error_code, address, SEGV_ACCERR);
803}
804
805/* TODO: fixup for "mm-invoke-oom-killer-from-page-fault.patch" */
806static void
807out_of_memory(struct pt_regs *regs, unsigned long error_code,
808 unsigned long address)
809{
810 /*
811 * We ran out of memory, call the OOM killer, and return the userspace
812 * (which will retry the fault, or kill us if we got oom-killed):
813 */
814 up_read(¤t->mm->mmap_sem);
815
816 pagefault_out_of_memory();
817}
818
819static void
820do_sigbus(struct pt_regs *regs, unsigned long error_code, unsigned long address,
821 unsigned int fault)
822{
823 struct task_struct *tsk = current;
824 struct mm_struct *mm = tsk->mm;
825 int code = BUS_ADRERR;
826
827 up_read(&mm->mmap_sem);
828
829 /* Kernel mode? Handle exceptions or die: */
830 if (!(error_code & PF_USER)) {
831 no_context(regs, error_code, address, SIGBUS, BUS_ADRERR);
832 return;
833 }
834
835 /* User-space => ok to do another page fault: */
836 if (is_prefetch(regs, error_code, address))
837 return;
838
839 tsk->thread.cr2 = address;
840 tsk->thread.error_code = error_code;
841 tsk->thread.trap_nr = X86_TRAP_PF;
842
843#ifdef CONFIG_MEMORY_FAILURE
844 if (fault & (VM_FAULT_HWPOISON|VM_FAULT_HWPOISON_LARGE)) {
845 printk(KERN_ERR
846 "MCE: Killing %s:%d due to hardware memory corruption fault at %lx\n",
847 tsk->comm, tsk->pid, address);
848 code = BUS_MCEERR_AR;
849 }
850#endif
851 force_sig_info_fault(SIGBUS, code, address, tsk, fault);
852}
853
854static noinline int
855mm_fault_error(struct pt_regs *regs, unsigned long error_code,
856 unsigned long address, unsigned int fault)
857{
858 /*
859 * Pagefault was interrupted by SIGKILL. We have no reason to
860 * continue pagefault.
861 */
862 if (fatal_signal_pending(current)) {
863 if (!(fault & VM_FAULT_RETRY))
864 up_read(¤t->mm->mmap_sem);
865 if (!(error_code & PF_USER))
866 no_context(regs, error_code, address, 0, 0);
867 return 1;
868 }
869 if (!(fault & VM_FAULT_ERROR))
870 return 0;
871
872 if (fault & VM_FAULT_OOM) {
873 /* Kernel mode? Handle exceptions or die: */
874 if (!(error_code & PF_USER)) {
875 up_read(¤t->mm->mmap_sem);
876 no_context(regs, error_code, address,
877 SIGSEGV, SEGV_MAPERR);
878 return 1;
879 }
880
881 out_of_memory(regs, error_code, address);
882 } else {
883 if (fault & (VM_FAULT_SIGBUS|VM_FAULT_HWPOISON|
884 VM_FAULT_HWPOISON_LARGE))
885 do_sigbus(regs, error_code, address, fault);
886 else
887 BUG();
888 }
889 return 1;
890}
891
892static int spurious_fault_check(unsigned long error_code, pte_t *pte)
893{
894 if ((error_code & PF_WRITE) && !pte_write(*pte))
895 return 0;
896
897 if ((error_code & PF_INSTR) && !pte_exec(*pte))
898 return 0;
899
900 return 1;
901}
902
903/*
904 * Handle a spurious fault caused by a stale TLB entry.
905 *
906 * This allows us to lazily refresh the TLB when increasing the
907 * permissions of a kernel page (RO -> RW or NX -> X). Doing it
908 * eagerly is very expensive since that implies doing a full
909 * cross-processor TLB flush, even if no stale TLB entries exist
910 * on other processors.
911 *
912 * There are no security implications to leaving a stale TLB when
913 * increasing the permissions on a page.
914 */
915static noinline __kprobes int
916spurious_fault(unsigned long error_code, unsigned long address)
917{
918 pgd_t *pgd;
919 pud_t *pud;
920 pmd_t *pmd;
921 pte_t *pte;
922 int ret;
923
924 /* Reserved-bit violation or user access to kernel space? */
925 if (error_code & (PF_USER | PF_RSVD))
926 return 0;
927
928 pgd = init_mm.pgd + pgd_index(address);
929 if (!pgd_present(*pgd))
930 return 0;
931
932 pud = pud_offset(pgd, address);
933 if (!pud_present(*pud))
934 return 0;
935
936 if (pud_large(*pud))
937 return spurious_fault_check(error_code, (pte_t *) pud);
938
939 pmd = pmd_offset(pud, address);
940 if (!pmd_present(*pmd))
941 return 0;
942
943 if (pmd_large(*pmd))
944 return spurious_fault_check(error_code, (pte_t *) pmd);
945
946 /*
947 * Note: don't use pte_present() here, since it returns true
948 * if the _PAGE_PROTNONE bit is set. However, this aliases the
949 * _PAGE_GLOBAL bit, which for kernel pages give false positives
950 * when CONFIG_DEBUG_PAGEALLOC is used.
951 */
952 pte = pte_offset_kernel(pmd, address);
953 if (!(pte_flags(*pte) & _PAGE_PRESENT))
954 return 0;
955
956 ret = spurious_fault_check(error_code, pte);
957 if (!ret)
958 return 0;
959
960 /*
961 * Make sure we have permissions in PMD.
962 * If not, then there's a bug in the page tables:
963 */
964 ret = spurious_fault_check(error_code, (pte_t *) pmd);
965 WARN_ONCE(!ret, "PMD has incorrect permission bits\n");
966
967 return ret;
968}
969
970int show_unhandled_signals = 1;
971
972static inline int
973access_error(unsigned long error_code, struct vm_area_struct *vma)
974{
975 if (error_code & PF_WRITE) {
976 /* write, present and write, not present: */
977 if (unlikely(!(vma->vm_flags & VM_WRITE)))
978 return 1;
979 return 0;
980 }
981
982 /* read, present: */
983 if (unlikely(error_code & PF_PROT))
984 return 1;
985
986 /* read, not present: */
987 if (unlikely(!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE))))
988 return 1;
989
990 return 0;
991}
992
993static int fault_in_kernel_space(unsigned long address)
994{
995 return address >= TASK_SIZE_MAX;
996}
997
998/*
999 * This routine handles page faults. It determines the address,
1000 * and the problem, and then passes it off to one of the appropriate
1001 * routines.
1002 */
1003dotraplinkage void __kprobes
1004do_page_fault(struct pt_regs *regs, unsigned long error_code)
1005{
1006 struct vm_area_struct *vma;
1007 struct task_struct *tsk;
1008 unsigned long address;
1009 struct mm_struct *mm;
1010 int fault;
1011 int write = error_code & PF_WRITE;
1012 unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE |
1013 (write ? FAULT_FLAG_WRITE : 0);
1014
1015 tsk = current;
1016 mm = tsk->mm;
1017
1018 /* Get the faulting address: */
1019 address = read_cr2();
1020
1021 /*
1022 * Detect and handle instructions that would cause a page fault for
1023 * both a tracked kernel page and a userspace page.
1024 */
1025 if (kmemcheck_active(regs))
1026 kmemcheck_hide(regs);
1027 prefetchw(&mm->mmap_sem);
1028
1029 if (unlikely(kmmio_fault(regs, address)))
1030 return;
1031
1032 /*
1033 * We fault-in kernel-space virtual memory on-demand. The
1034 * 'reference' page table is init_mm.pgd.
1035 *
1036 * NOTE! We MUST NOT take any locks for this case. We may
1037 * be in an interrupt or a critical region, and should
1038 * only copy the information from the master page table,
1039 * nothing more.
1040 *
1041 * This verifies that the fault happens in kernel space
1042 * (error_code & 4) == 0, and that the fault was not a
1043 * protection error (error_code & 9) == 0.
1044 */
1045 if (unlikely(fault_in_kernel_space(address))) {
1046 if (!(error_code & (PF_RSVD | PF_USER | PF_PROT))) {
1047 if (vmalloc_fault(address) >= 0)
1048 return;
1049
1050 if (kmemcheck_fault(regs, address, error_code))
1051 return;
1052 }
1053
1054 /* Can handle a stale RO->RW TLB: */
1055 if (spurious_fault(error_code, address))
1056 return;
1057
1058 /* kprobes don't want to hook the spurious faults: */
1059 if (notify_page_fault(regs))
1060 return;
1061 /*
1062 * Don't take the mm semaphore here. If we fixup a prefetch
1063 * fault we could otherwise deadlock:
1064 */
1065 bad_area_nosemaphore(regs, error_code, address);
1066
1067 return;
1068 }
1069
1070 /* kprobes don't want to hook the spurious faults: */
1071 if (unlikely(notify_page_fault(regs)))
1072 return;
1073 /*
1074 * It's safe to allow irq's after cr2 has been saved and the
1075 * vmalloc fault has been handled.
1076 *
1077 * User-mode registers count as a user access even for any
1078 * potential system fault or CPU buglet:
1079 */
1080 if (user_mode_vm(regs)) {
1081 local_irq_enable();
1082 error_code |= PF_USER;
1083 } else {
1084 if (regs->flags & X86_EFLAGS_IF)
1085 local_irq_enable();
1086 }
1087
1088 if (unlikely(error_code & PF_RSVD))
1089 pgtable_bad(regs, error_code, address);
1090
1091 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
1092
1093 /*
1094 * If we're in an interrupt, have no user context or are running
1095 * in an atomic region then we must not take the fault:
1096 */
1097 if (unlikely(in_atomic() || !mm)) {
1098 bad_area_nosemaphore(regs, error_code, address);
1099 return;
1100 }
1101
1102 /*
1103 * When running in the kernel we expect faults to occur only to
1104 * addresses in user space. All other faults represent errors in
1105 * the kernel and should generate an OOPS. Unfortunately, in the
1106 * case of an erroneous fault occurring in a code path which already
1107 * holds mmap_sem we will deadlock attempting to validate the fault
1108 * against the address space. Luckily the kernel only validly
1109 * references user space from well defined areas of code, which are
1110 * listed in the exceptions table.
1111 *
1112 * As the vast majority of faults will be valid we will only perform
1113 * the source reference check when there is a possibility of a
1114 * deadlock. Attempt to lock the address space, if we cannot we then
1115 * validate the source. If this is invalid we can skip the address
1116 * space check, thus avoiding the deadlock:
1117 */
1118 if (unlikely(!down_read_trylock(&mm->mmap_sem))) {
1119 if ((error_code & PF_USER) == 0 &&
1120 !search_exception_tables(regs->ip)) {
1121 bad_area_nosemaphore(regs, error_code, address);
1122 return;
1123 }
1124retry:
1125 down_read(&mm->mmap_sem);
1126 } else {
1127 /*
1128 * The above down_read_trylock() might have succeeded in
1129 * which case we'll have missed the might_sleep() from
1130 * down_read():
1131 */
1132 might_sleep();
1133 }
1134
1135 vma = find_vma(mm, address);
1136 if (unlikely(!vma)) {
1137 bad_area(regs, error_code, address);
1138 return;
1139 }
1140 if (likely(vma->vm_start <= address))
1141 goto good_area;
1142 if (unlikely(!(vma->vm_flags & VM_GROWSDOWN))) {
1143 bad_area(regs, error_code, address);
1144 return;
1145 }
1146 if (error_code & PF_USER) {
1147 /*
1148 * Accessing the stack below %sp is always a bug.
1149 * The large cushion allows instructions like enter
1150 * and pusha to work. ("enter $65535, $31" pushes
1151 * 32 pointers and then decrements %sp by 65535.)
1152 */
1153 if (unlikely(address + 65536 + 32 * sizeof(unsigned long) < regs->sp)) {
1154 bad_area(regs, error_code, address);
1155 return;
1156 }
1157 }
1158 if (unlikely(expand_stack(vma, address))) {
1159 bad_area(regs, error_code, address);
1160 return;
1161 }
1162
1163 /*
1164 * Ok, we have a good vm_area for this memory access, so
1165 * we can handle it..
1166 */
1167good_area:
1168 if (unlikely(access_error(error_code, vma))) {
1169 bad_area_access_error(regs, error_code, address);
1170 return;
1171 }
1172
1173 /*
1174 * If for any reason at all we couldn't handle the fault,
1175 * make sure we exit gracefully rather than endlessly redo
1176 * the fault:
1177 */
1178 fault = handle_mm_fault(mm, vma, address, flags);
1179
1180 if (unlikely(fault & (VM_FAULT_RETRY|VM_FAULT_ERROR))) {
1181 if (mm_fault_error(regs, error_code, address, fault))
1182 return;
1183 }
1184
1185 /*
1186 * Major/minor page fault accounting is only done on the
1187 * initial attempt. If we go through a retry, it is extremely
1188 * likely that the page will be found in page cache at that point.
1189 */
1190 if (flags & FAULT_FLAG_ALLOW_RETRY) {
1191 if (fault & VM_FAULT_MAJOR) {
1192 tsk->maj_flt++;
1193 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1,
1194 regs, address);
1195 } else {
1196 tsk->min_flt++;
1197 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1,
1198 regs, address);
1199 }
1200 if (fault & VM_FAULT_RETRY) {
1201 /* Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk
1202 * of starvation. */
1203 flags &= ~FAULT_FLAG_ALLOW_RETRY;
1204 goto retry;
1205 }
1206 }
1207
1208 check_v8086_mode(regs, address, tsk);
1209
1210 up_read(&mm->mmap_sem);
1211}