Branch data Line data Source code
1 : : /*
2 : : * Copyright (C) 1991, 1992 Linus Torvalds
3 : : * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
4 : : *
5 : : * Pentium III FXSR, SSE support
6 : : * Gareth Hughes <gareth@valinux.com>, May 2000
7 : : */
8 : :
9 : : /*
10 : : * Handle hardware traps and faults.
11 : : */
12 : :
13 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 : :
15 : : #include <linux/context_tracking.h>
16 : : #include <linux/interrupt.h>
17 : : #include <linux/kallsyms.h>
18 : : #include <linux/spinlock.h>
19 : : #include <linux/kprobes.h>
20 : : #include <linux/uaccess.h>
21 : : #include <linux/kdebug.h>
22 : : #include <linux/kgdb.h>
23 : : #include <linux/kernel.h>
24 : : #include <linux/export.h>
25 : : #include <linux/ptrace.h>
26 : : #include <linux/uprobes.h>
27 : : #include <linux/string.h>
28 : : #include <linux/delay.h>
29 : : #include <linux/errno.h>
30 : : #include <linux/kexec.h>
31 : : #include <linux/sched.h>
32 : : #include <linux/sched/task_stack.h>
33 : : #include <linux/timer.h>
34 : : #include <linux/init.h>
35 : : #include <linux/bug.h>
36 : : #include <linux/nmi.h>
37 : : #include <linux/mm.h>
38 : : #include <linux/smp.h>
39 : : #include <linux/io.h>
40 : : #include <asm/stacktrace.h>
41 : : #include <asm/processor.h>
42 : : #include <asm/debugreg.h>
43 : : #include <linux/atomic.h>
44 : : #include <asm/text-patching.h>
45 : : #include <asm/ftrace.h>
46 : : #include <asm/traps.h>
47 : : #include <asm/desc.h>
48 : : #include <asm/fpu/internal.h>
49 : : #include <asm/cpu_entry_area.h>
50 : : #include <asm/mce.h>
51 : : #include <asm/fixmap.h>
52 : : #include <asm/mach_traps.h>
53 : : #include <asm/alternative.h>
54 : : #include <asm/fpu/xstate.h>
55 : : #include <asm/vm86.h>
56 : : #include <asm/umip.h>
57 : : #include <asm/insn.h>
58 : : #include <asm/insn-eval.h>
59 : :
60 : : #ifdef CONFIG_X86_64
61 : : #include <asm/x86_init.h>
62 : : #include <asm/pgalloc.h>
63 : : #include <asm/proto.h>
64 : : #else
65 : : #include <asm/processor-flags.h>
66 : : #include <asm/setup.h>
67 : : #include <asm/proto.h>
68 : : #endif
69 : :
70 : : DECLARE_BITMAP(system_vectors, NR_VECTORS);
71 : :
72 : 0 : static inline void cond_local_irq_enable(struct pt_regs *regs)
73 : : {
74 : 0 : if (regs->flags & X86_EFLAGS_IF)
75 : 0 : local_irq_enable();
76 : : }
77 : :
78 : 0 : static inline void cond_local_irq_disable(struct pt_regs *regs)
79 : : {
80 : 0 : if (regs->flags & X86_EFLAGS_IF)
81 : 0 : local_irq_disable();
82 : : }
83 : :
84 : : /*
85 : : * In IST context, we explicitly disable preemption. This serves two
86 : : * purposes: it makes it much less likely that we would accidentally
87 : : * schedule in IST context and it will force a warning if we somehow
88 : : * manage to schedule by accident.
89 : : */
90 : 13 : void ist_enter(struct pt_regs *regs)
91 : : {
92 [ # # ]: 0 : if (user_mode(regs)) {
93 : : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
94 : : } else {
95 : : /*
96 : : * We might have interrupted pretty much anything. In
97 : : * fact, if we're a machine check, we can even interrupt
98 : : * NMI processing. We don't want in_nmi() to return true,
99 : : * but we need to notify RCU.
100 : : */
101 : 13 : rcu_nmi_enter();
102 : : }
103 : :
104 : 13 : preempt_disable();
105 : :
106 : : /* This code is a bit fragile. Test it. */
107 : 13 : RCU_LOCKDEP_WARN(!rcu_is_watching(), "ist_enter didn't work");
108 : 0 : }
109 : : NOKPROBE_SYMBOL(ist_enter);
110 : :
111 : 13 : void ist_exit(struct pt_regs *regs)
112 : : {
113 : 0 : preempt_enable_no_resched();
114 : :
115 [ - - + - : 13 : if (!user_mode(regs))
- - ]
116 : 13 : rcu_nmi_exit();
117 : 0 : }
118 : :
119 : : /**
120 : : * ist_begin_non_atomic() - begin a non-atomic section in an IST exception
121 : : * @regs: regs passed to the IST exception handler
122 : : *
123 : : * IST exception handlers normally cannot schedule. As a special
124 : : * exception, if the exception interrupted userspace code (i.e.
125 : : * user_mode(regs) would return true) and the exception was not
126 : : * a double fault, it can be safe to schedule. ist_begin_non_atomic()
127 : : * begins a non-atomic section within an ist_enter()/ist_exit() region.
128 : : * Callers are responsible for enabling interrupts themselves inside
129 : : * the non-atomic section, and callers must call ist_end_non_atomic()
130 : : * before ist_exit().
131 : : */
132 : 0 : void ist_begin_non_atomic(struct pt_regs *regs)
133 : : {
134 [ # # ]: 0 : BUG_ON(!user_mode(regs));
135 : :
136 : : /*
137 : : * Sanity check: we need to be on the normal thread stack. This
138 : : * will catch asm bugs and any attempt to use ist_preempt_enable
139 : : * from double_fault.
140 : : */
141 [ # # ]: 0 : BUG_ON(!on_thread_stack());
142 : :
143 : 0 : preempt_enable_no_resched();
144 : 0 : }
145 : :
146 : : /**
147 : : * ist_end_non_atomic() - begin a non-atomic section in an IST exception
148 : : *
149 : : * Ends a non-atomic section started with ist_begin_non_atomic().
150 : : */
151 : 0 : void ist_end_non_atomic(void)
152 : : {
153 : 0 : preempt_disable();
154 : 0 : }
155 : :
156 : 0 : int is_valid_bugaddr(unsigned long addr)
157 : : {
158 : 0 : unsigned short ud;
159 : :
160 [ # # # # : 0 : if (addr < TASK_SIZE_MAX)
# ]
161 : : return 0;
162 : :
163 [ # # ]: 0 : if (probe_kernel_address((unsigned short *)addr, ud))
164 : : return 0;
165 : :
166 : 0 : return ud == INSN_UD0 || ud == INSN_UD2;
167 : : }
168 : :
169 : 0 : int fixup_bug(struct pt_regs *regs, int trapnr)
170 : : {
171 [ # # ]: 0 : if (trapnr != X86_TRAP_UD)
172 : : return 0;
173 : :
174 [ # # # # ]: 0 : switch (report_bug(regs->ip, regs)) {
175 : : case BUG_TRAP_TYPE_NONE:
176 : : case BUG_TRAP_TYPE_BUG:
177 : : break;
178 : :
179 : 0 : case BUG_TRAP_TYPE_WARN:
180 : 0 : regs->ip += LEN_UD2;
181 : 0 : return 1;
182 : : }
183 : :
184 : : return 0;
185 : : }
186 : :
187 : : static nokprobe_inline int
188 : 0 : do_trap_no_signal(struct task_struct *tsk, int trapnr, const char *str,
189 : : struct pt_regs *regs, long error_code)
190 : : {
191 : 0 : if (v8086_mode(regs)) {
192 : : /*
193 : : * Traps 0, 1, 3, 4, and 5 should be forwarded to vm86.
194 : : * On nmi (interrupt 2), do_trap should not be called.
195 : : */
196 : : if (trapnr < X86_TRAP_UD) {
197 : : if (!handle_vm86_trap((struct kernel_vm86_regs *) regs,
198 : : error_code, trapnr))
199 : : return 0;
200 : : }
201 [ # # ]: 0 : } else if (!user_mode(regs)) {
202 [ # # ]: 0 : if (fixup_exception(regs, trapnr, error_code, 0))
203 : : return 0;
204 : :
205 : 0 : tsk->thread.error_code = error_code;
206 : 0 : tsk->thread.trap_nr = trapnr;
207 : 0 : die(str, regs, error_code);
208 : : }
209 : :
210 : : /*
211 : : * We want error_code and trap_nr set for userspace faults and
212 : : * kernelspace faults which result in die(), but not
213 : : * kernelspace faults which are fixed up. die() gives the
214 : : * process no chance to handle the signal and notice the
215 : : * kernel fault information, so that won't result in polluting
216 : : * the information about previously queued, but not yet
217 : : * delivered, faults. See also do_general_protection below.
218 : : */
219 : 0 : tsk->thread.error_code = error_code;
220 : 0 : tsk->thread.trap_nr = trapnr;
221 : :
222 : 0 : return -1;
223 : : }
224 : :
225 : : static void show_signal(struct task_struct *tsk, int signr,
226 : : const char *type, const char *desc,
227 : : struct pt_regs *regs, long error_code)
228 : : {
229 : : if (show_unhandled_signals && unhandled_signal(tsk, signr) &&
230 : : printk_ratelimit()) {
231 : : pr_info("%s[%d] %s%s ip:%lx sp:%lx error:%lx",
232 : : tsk->comm, task_pid_nr(tsk), type, desc,
233 : : regs->ip, regs->sp, error_code);
234 : : print_vma_addr(KERN_CONT " in ", regs->ip);
235 : : pr_cont("\n");
236 : : }
237 : : }
238 : :
239 : : static void
240 : 0 : do_trap(int trapnr, int signr, char *str, struct pt_regs *regs,
241 : : long error_code, int sicode, void __user *addr)
242 : : {
243 [ # # ]: 0 : struct task_struct *tsk = current;
244 : :
245 : :
246 [ # # ]: 0 : if (!do_trap_no_signal(tsk, trapnr, str, regs, error_code))
247 : : return;
248 : :
249 : 0 : show_signal(tsk, signr, "trap ", str, regs, error_code);
250 : :
251 [ # # ]: 0 : if (!sicode)
252 : 0 : force_sig(signr);
253 : : else
254 : 0 : force_sig_fault(signr, sicode, addr);
255 : : }
256 : : NOKPROBE_SYMBOL(do_trap);
257 : :
258 : 0 : static void do_error_trap(struct pt_regs *regs, long error_code, char *str,
259 : : unsigned long trapnr, int signr, int sicode, void __user *addr)
260 : : {
261 : 0 : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
262 : :
263 : : /*
264 : : * WARN*()s end up here; fix them up before we call the
265 : : * notifier chain.
266 : : */
267 [ # # # # ]: 0 : if (!user_mode(regs) && fixup_bug(regs, trapnr))
268 : 0 : return;
269 : :
270 [ # # ]: 0 : if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) !=
271 : : NOTIFY_STOP) {
272 [ # # ]: 0 : cond_local_irq_enable(regs);
273 : 0 : do_trap(trapnr, signr, str, regs, error_code, sicode, addr);
274 : : }
275 : : }
276 : :
277 : : #define IP ((void __user *)uprobe_get_trap_addr(regs))
278 : : #define DO_ERROR(trapnr, signr, sicode, addr, str, name) \
279 : : dotraplinkage void do_##name(struct pt_regs *regs, long error_code) \
280 : : { \
281 : : do_error_trap(regs, error_code, str, trapnr, signr, sicode, addr); \
282 : : }
283 : :
284 : 0 : DO_ERROR(X86_TRAP_DE, SIGFPE, FPE_INTDIV, IP, "divide error", divide_error)
285 : 0 : DO_ERROR(X86_TRAP_OF, SIGSEGV, 0, NULL, "overflow", overflow)
286 : 0 : DO_ERROR(X86_TRAP_UD, SIGILL, ILL_ILLOPN, IP, "invalid opcode", invalid_op)
287 : 0 : DO_ERROR(X86_TRAP_OLD_MF, SIGFPE, 0, NULL, "coprocessor segment overrun", coprocessor_segment_overrun)
288 : 0 : DO_ERROR(X86_TRAP_TS, SIGSEGV, 0, NULL, "invalid TSS", invalid_TSS)
289 : 0 : DO_ERROR(X86_TRAP_NP, SIGBUS, 0, NULL, "segment not present", segment_not_present)
290 : 0 : DO_ERROR(X86_TRAP_SS, SIGBUS, 0, NULL, "stack segment", stack_segment)
291 : 0 : DO_ERROR(X86_TRAP_AC, SIGBUS, BUS_ADRALN, NULL, "alignment check", alignment_check)
292 : : #undef IP
293 : :
294 : : #ifdef CONFIG_VMAP_STACK
295 : : __visible void __noreturn handle_stack_overflow(const char *message,
296 : : struct pt_regs *regs,
297 : : unsigned long fault_address)
298 : : {
299 : : printk(KERN_EMERG "BUG: stack guard page was hit at %p (stack is %p..%p)\n",
300 : : (void *)fault_address, current->stack,
301 : : (char *)current->stack + THREAD_SIZE - 1);
302 : : die(message, regs, 0);
303 : :
304 : : /* Be absolutely certain we don't return. */
305 : : panic("%s", message);
306 : : }
307 : : #endif
308 : :
309 : : #if defined(CONFIG_X86_64) || defined(CONFIG_DOUBLEFAULT)
310 : : /*
311 : : * Runs on an IST stack for x86_64 and on a special task stack for x86_32.
312 : : *
313 : : * On x86_64, this is more or less a normal kernel entry. Notwithstanding the
314 : : * SDM's warnings about double faults being unrecoverable, returning works as
315 : : * expected. Presumably what the SDM actually means is that the CPU may get
316 : : * the register state wrong on entry, so returning could be a bad idea.
317 : : *
318 : : * Various CPU engineers have promised that double faults due to an IRET fault
319 : : * while the stack is read-only are, in fact, recoverable.
320 : : *
321 : : * On x86_32, this is entered through a task gate, and regs are synthesized
322 : : * from the TSS. Returning is, in principle, okay, but changes to regs will
323 : : * be lost. If, for some reason, we need to return to a context with modified
324 : : * regs, the shim code could be adjusted to synchronize the registers.
325 : : */
326 : 0 : dotraplinkage void do_double_fault(struct pt_regs *regs, long error_code, unsigned long cr2)
327 : : {
328 : 0 : static const char str[] = "double fault";
329 [ # # ]: 0 : struct task_struct *tsk = current;
330 : :
331 : : #ifdef CONFIG_X86_ESPFIX64
332 : 0 : extern unsigned char native_irq_return_iret[];
333 : :
334 : : /*
335 : : * If IRET takes a non-IST fault on the espfix64 stack, then we
336 : : * end up promoting it to a doublefault. In that case, take
337 : : * advantage of the fact that we're not using the normal (TSS.sp0)
338 : : * stack right now. We can write a fake #GP(0) frame at TSS.sp0
339 : : * and then modify our own IRET frame so that, when we return,
340 : : * we land directly at the #GP(0) vector with the stack already
341 : : * set up according to its expectations.
342 : : *
343 : : * The net result is that our #GP handler will think that we
344 : : * entered from usermode with the bad user context.
345 : : *
346 : : * No need for ist_enter here because we don't use RCU.
347 : : */
348 [ # # ]: 0 : if (((long)regs->sp >> P4D_SHIFT) == ESPFIX_PGD_ENTRY &&
349 [ # # ]: 0 : regs->cs == __KERNEL_CS &&
350 [ # # ]: 0 : regs->ip == (unsigned long)native_irq_return_iret)
351 : : {
352 : 0 : struct pt_regs *gpregs = (struct pt_regs *)this_cpu_read(cpu_tss_rw.x86_tss.sp0) - 1;
353 : :
354 : : /*
355 : : * regs->sp points to the failing IRET frame on the
356 : : * ESPFIX64 stack. Copy it to the entry stack. This fills
357 : : * in gpregs->ss through gpregs->ip.
358 : : *
359 : : */
360 : 0 : memmove(&gpregs->ip, (void *)regs->sp, 5*8);
361 : 0 : gpregs->orig_ax = 0; /* Missing (lost) #GP error code */
362 : :
363 : : /*
364 : : * Adjust our frame so that we return straight to the #GP
365 : : * vector with the expected RSP value. This is safe because
366 : : * we won't enable interupts or schedule before we invoke
367 : : * general_protection, so nothing will clobber the stack
368 : : * frame we just set up.
369 : : *
370 : : * We will enter general_protection with kernel GSBASE,
371 : : * which is what the stub expects, given that the faulting
372 : : * RIP will be the IRET instruction.
373 : : */
374 : 0 : regs->ip = (unsigned long)general_protection;
375 : 0 : regs->sp = (unsigned long)&gpregs->orig_ax;
376 : :
377 : 0 : return;
378 : : }
379 : : #endif
380 : :
381 [ # # ]: 0 : ist_enter(regs);
382 : 0 : notify_die(DIE_TRAP, str, regs, error_code, X86_TRAP_DF, SIGSEGV);
383 : :
384 : 0 : tsk->thread.error_code = error_code;
385 : 0 : tsk->thread.trap_nr = X86_TRAP_DF;
386 : :
387 : : #ifdef CONFIG_VMAP_STACK
388 : : /*
389 : : * If we overflow the stack into a guard page, the CPU will fail
390 : : * to deliver #PF and will send #DF instead. Similarly, if we
391 : : * take any non-IST exception while too close to the bottom of
392 : : * the stack, the processor will get a page fault while
393 : : * delivering the exception and will generate a double fault.
394 : : *
395 : : * According to the SDM (footnote in 6.15 under "Interrupt 14 -
396 : : * Page-Fault Exception (#PF):
397 : : *
398 : : * Processors update CR2 whenever a page fault is detected. If a
399 : : * second page fault occurs while an earlier page fault is being
400 : : * delivered, the faulting linear address of the second fault will
401 : : * overwrite the contents of CR2 (replacing the previous
402 : : * address). These updates to CR2 occur even if the page fault
403 : : * results in a double fault or occurs during the delivery of a
404 : : * double fault.
405 : : *
406 : : * The logic below has a small possibility of incorrectly diagnosing
407 : : * some errors as stack overflows. For example, if the IDT or GDT
408 : : * gets corrupted such that #GP delivery fails due to a bad descriptor
409 : : * causing #GP and we hit this condition while CR2 coincidentally
410 : : * points to the stack guard page, we'll think we overflowed the
411 : : * stack. Given that we're going to panic one way or another
412 : : * if this happens, this isn't necessarily worth fixing.
413 : : *
414 : : * If necessary, we could improve the test by only diagnosing
415 : : * a stack overflow if the saved RSP points within 47 bytes of
416 : : * the bottom of the stack: if RSP == tsk_stack + 48 and we
417 : : * take an exception, the stack is already aligned and there
418 : : * will be enough room SS, RSP, RFLAGS, CS, RIP, and a
419 : : * possible error code, so a stack overflow would *not* double
420 : : * fault. With any less space left, exception delivery could
421 : : * fail, and, as a practical matter, we've overflowed the
422 : : * stack even if the actual trigger for the double fault was
423 : : * something else.
424 : : */
425 : : if ((unsigned long)task_stack_page(tsk) - 1 - cr2 < PAGE_SIZE)
426 : : handle_stack_overflow("kernel stack overflow (double-fault)", regs, cr2);
427 : : #endif
428 : :
429 : 0 : pr_emerg("PANIC: double fault, error_code: 0x%lx\n", error_code);
430 : 0 : die("double fault", regs, error_code);
431 : 0 : panic("Machine halted.");
432 : : }
433 : : #endif
434 : :
435 : 0 : dotraplinkage void do_bounds(struct pt_regs *regs, long error_code)
436 : : {
437 : 0 : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
438 [ # # ]: 0 : if (notify_die(DIE_TRAP, "bounds", regs, error_code,
439 : : X86_TRAP_BR, SIGSEGV) == NOTIFY_STOP)
440 : : return;
441 [ # # ]: 0 : cond_local_irq_enable(regs);
442 : :
443 [ # # ]: 0 : if (!user_mode(regs))
444 : 0 : die("bounds", regs, error_code);
445 : :
446 : 0 : do_trap(X86_TRAP_BR, SIGSEGV, "bounds", regs, error_code, 0, NULL);
447 : : }
448 : :
449 : : enum kernel_gp_hint {
450 : : GP_NO_HINT,
451 : : GP_NON_CANONICAL,
452 : : GP_CANONICAL
453 : : };
454 : :
455 : : /*
456 : : * When an uncaught #GP occurs, try to determine the memory address accessed by
457 : : * the instruction and return that address to the caller. Also, try to figure
458 : : * out whether any part of the access to that address was non-canonical.
459 : : */
460 : 0 : static enum kernel_gp_hint get_kernel_gp_address(struct pt_regs *regs,
461 : : unsigned long *addr)
462 : : {
463 : 0 : u8 insn_buf[MAX_INSN_SIZE];
464 : 0 : struct insn insn;
465 : :
466 [ # # ]: 0 : if (probe_kernel_read(insn_buf, (void *)regs->ip, MAX_INSN_SIZE))
467 : : return GP_NO_HINT;
468 : :
469 : 0 : kernel_insn_init(&insn, insn_buf, MAX_INSN_SIZE);
470 : 0 : insn_get_modrm(&insn);
471 : 0 : insn_get_sib(&insn);
472 : :
473 : 0 : *addr = (unsigned long)insn_get_addr_ref(&insn, regs);
474 [ # # ]: 0 : if (*addr == -1UL)
475 : : return GP_NO_HINT;
476 : :
477 : : #ifdef CONFIG_X86_64
478 : : /*
479 : : * Check that:
480 : : * - the operand is not in the kernel half
481 : : * - the last byte of the operand is not in the user canonical half
482 : : */
483 [ # # # # : 0 : if (*addr < ~__VIRTUAL_MASK &&
# # # ]
484 [ # # # ]: 0 : *addr + insn.opnd_bytes - 1 > __VIRTUAL_MASK)
485 : 0 : return GP_NON_CANONICAL;
486 : : #endif
487 : :
488 : : return GP_CANONICAL;
489 : : }
490 : :
491 : : #define GPFSTR "general protection fault"
492 : :
493 : 0 : dotraplinkage void do_general_protection(struct pt_regs *regs, long error_code)
494 : : {
495 : 0 : char desc[sizeof(GPFSTR) + 50 + 2*sizeof(unsigned long) + 1] = GPFSTR;
496 : 0 : enum kernel_gp_hint hint = GP_NO_HINT;
497 : 0 : struct task_struct *tsk;
498 : 0 : unsigned long gp_addr;
499 : 0 : int ret;
500 : :
501 : 0 : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
502 [ # # ]: 0 : cond_local_irq_enable(regs);
503 : :
504 [ # # # ]: 0 : if (static_cpu_has(X86_FEATURE_UMIP)) {
505 [ # # # # ]: 0 : if (user_mode(regs) && fixup_umip_exception(regs))
506 : 0 : return;
507 : : }
508 : :
509 [ # # ]: 0 : if (v8086_mode(regs)) {
510 : : local_irq_enable();
511 : : handle_vm86_fault((struct kernel_vm86_regs *) regs, error_code);
512 : : return;
513 : : }
514 : :
515 [ # # ]: 0 : tsk = current;
516 : :
517 [ # # ]: 0 : if (user_mode(regs)) {
518 : 0 : tsk->thread.error_code = error_code;
519 : 0 : tsk->thread.trap_nr = X86_TRAP_GP;
520 : :
521 : 0 : show_signal(tsk, SIGSEGV, "", desc, regs, error_code);
522 : 0 : force_sig(SIGSEGV);
523 : :
524 : 0 : return;
525 : : }
526 : :
527 [ # # ]: 0 : if (fixup_exception(regs, X86_TRAP_GP, error_code, 0))
528 : : return;
529 : :
530 : 0 : tsk->thread.error_code = error_code;
531 : 0 : tsk->thread.trap_nr = X86_TRAP_GP;
532 : :
533 : : /*
534 : : * To be potentially processing a kprobe fault and to trust the result
535 : : * from kprobe_running(), we have to be non-preemptible.
536 : : */
537 [ # # ]: 0 : if (!preemptible() &&
538 [ # # ]: 0 : kprobe_running() &&
539 : 0 : kprobe_fault_handler(regs, X86_TRAP_GP))
540 : : return;
541 : :
542 : 0 : ret = notify_die(DIE_GPF, desc, regs, error_code, X86_TRAP_GP, SIGSEGV);
543 [ # # ]: 0 : if (ret == NOTIFY_STOP)
544 : : return;
545 : :
546 [ # # ]: 0 : if (error_code)
547 : 0 : snprintf(desc, sizeof(desc), "segment-related " GPFSTR);
548 : : else
549 : 0 : hint = get_kernel_gp_address(regs, &gp_addr);
550 : :
551 [ # # ]: 0 : if (hint != GP_NO_HINT)
552 [ # # ]: 0 : snprintf(desc, sizeof(desc), GPFSTR ", %s 0x%lx",
553 : : (hint == GP_NON_CANONICAL) ? "probably for non-canonical address"
554 : : : "maybe for address",
555 : : gp_addr);
556 : :
557 : : /*
558 : : * KASAN is interested only in the non-canonical case, clear it
559 : : * otherwise.
560 : : */
561 [ # # ]: 0 : if (hint != GP_NON_CANONICAL)
562 : 0 : gp_addr = 0;
563 : :
564 : 0 : die_addr(desc, regs, error_code, gp_addr);
565 : :
566 : : }
567 : : NOKPROBE_SYMBOL(do_general_protection);
568 : :
569 : 13 : dotraplinkage void notrace do_int3(struct pt_regs *regs, long error_code)
570 : : {
571 [ + - ]: 13 : if (poke_int3_handler(regs))
572 : : return;
573 : :
574 : : /*
575 : : * Use ist_enter despite the fact that we don't use an IST stack.
576 : : * We can be called from a kprobe in non-CONTEXT_KERNEL kernel
577 : : * mode or even during context tracking state changes.
578 : : *
579 : : * This means that we can't schedule. That's okay.
580 : : */
581 [ + - ]: 13 : ist_enter(regs);
582 : 13 : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
583 : : #ifdef CONFIG_KGDB_LOW_LEVEL_TRAP
584 : : if (kgdb_ll_trap(DIE_INT3, "int3", regs, error_code, X86_TRAP_BP,
585 : : SIGTRAP) == NOTIFY_STOP)
586 : : goto exit;
587 : : #endif /* CONFIG_KGDB_LOW_LEVEL_TRAP */
588 : :
589 : : #ifdef CONFIG_KPROBES
590 [ - + ]: 13 : if (kprobe_int3_handler(regs))
591 : 0 : goto exit;
592 : : #endif
593 : :
594 [ + - ]: 13 : if (notify_die(DIE_INT3, "int3", regs, error_code, X86_TRAP_BP,
595 : : SIGTRAP) == NOTIFY_STOP)
596 : 13 : goto exit;
597 : :
598 [ # # ]: 0 : cond_local_irq_enable(regs);
599 : 0 : do_trap(X86_TRAP_BP, SIGTRAP, "int3", regs, error_code, 0, NULL);
600 [ # # ]: 0 : cond_local_irq_disable(regs);
601 : :
602 : 13 : exit:
603 : 13 : ist_exit(regs);
604 : : }
605 : : NOKPROBE_SYMBOL(do_int3);
606 : :
607 : : #ifdef CONFIG_X86_64
608 : : /*
609 : : * Help handler running on a per-cpu (IST or entry trampoline) stack
610 : : * to switch to the normal thread stack if the interrupted code was in
611 : : * user mode. The actual stack switch is done in entry_64.S
612 : : */
613 : 5846591 : asmlinkage __visible notrace struct pt_regs *sync_regs(struct pt_regs *eregs)
614 : : {
615 : 5846591 : struct pt_regs *regs = (struct pt_regs *)this_cpu_read(cpu_current_top_of_stack) - 1;
616 [ + - ]: 5846591 : if (regs != eregs)
617 : 5846591 : *regs = *eregs;
618 : 5846591 : return regs;
619 : : }
620 : : NOKPROBE_SYMBOL(sync_regs);
621 : :
622 : : struct bad_iret_stack {
623 : : void *error_entry_ret;
624 : : struct pt_regs regs;
625 : : };
626 : :
627 : : asmlinkage __visible notrace
628 : 0 : struct bad_iret_stack *fixup_bad_iret(struct bad_iret_stack *s)
629 : : {
630 : : /*
631 : : * This is called from entry_64.S early in handling a fault
632 : : * caused by a bad iret to user mode. To handle the fault
633 : : * correctly, we want to move our stack frame to where it would
634 : : * be had we entered directly on the entry stack (rather than
635 : : * just below the IRET frame) and we want to pretend that the
636 : : * exception came from the IRET target.
637 : : */
638 : 0 : struct bad_iret_stack *new_stack =
639 : 0 : (struct bad_iret_stack *)this_cpu_read(cpu_tss_rw.x86_tss.sp0) - 1;
640 : :
641 : : /* Copy the IRET target to the new stack. */
642 : 0 : memmove(&new_stack->regs.ip, (void *)s->regs.sp, 5*8);
643 : :
644 : : /* Copy the remainder of the stack from the current stack. */
645 : 0 : memmove(new_stack, s, offsetof(struct bad_iret_stack, regs.ip));
646 : :
647 [ # # ]: 0 : BUG_ON(!user_mode(&new_stack->regs));
648 : 0 : return new_stack;
649 : : }
650 : : NOKPROBE_SYMBOL(fixup_bad_iret);
651 : : #endif
652 : :
653 : 0 : static bool is_sysenter_singlestep(struct pt_regs *regs)
654 : : {
655 : : /*
656 : : * We don't try for precision here. If we're anywhere in the region of
657 : : * code that can be single-stepped in the SYSENTER entry path, then
658 : : * assume that this is a useless single-step trap due to SYSENTER
659 : : * being invoked with TF set. (We don't know in advance exactly
660 : : * which instructions will be hit because BTF could plausibly
661 : : * be set.)
662 : : */
663 : : #ifdef CONFIG_X86_32
664 : : return (regs->ip - (unsigned long)__begin_SYSENTER_singlestep_region) <
665 : : (unsigned long)__end_SYSENTER_singlestep_region -
666 : : (unsigned long)__begin_SYSENTER_singlestep_region;
667 : : #elif defined(CONFIG_IA32_EMULATION)
668 : 0 : return (regs->ip - (unsigned long)entry_SYSENTER_compat) <
669 : 0 : (unsigned long)__end_entry_SYSENTER_compat -
670 : : (unsigned long)entry_SYSENTER_compat;
671 : : #else
672 : : return false;
673 : : #endif
674 : : }
675 : :
676 : : /*
677 : : * Our handling of the processor debug registers is non-trivial.
678 : : * We do not clear them on entry and exit from the kernel. Therefore
679 : : * it is possible to get a watchpoint trap here from inside the kernel.
680 : : * However, the code in ./ptrace.c has ensured that the user can
681 : : * only set watchpoints on userspace addresses. Therefore the in-kernel
682 : : * watchpoint trap can only occur in code which is reading/writing
683 : : * from user space. Such code must not hold kernel locks (since it
684 : : * can equally take a page fault), therefore it is safe to call
685 : : * force_sig_info even though that claims and releases locks.
686 : : *
687 : : * Code in ./signal.c ensures that the debug control register
688 : : * is restored before we deliver any signal, and therefore that
689 : : * user code runs with the correct debug control register even though
690 : : * we clear it here.
691 : : *
692 : : * Being careful here means that we don't have to be as careful in a
693 : : * lot of more complicated places (task switching can be a bit lazy
694 : : * about restoring all the debug state, and ptrace doesn't have to
695 : : * find every occurrence of the TF bit that could be saved away even
696 : : * by user code)
697 : : *
698 : : * May run on IST stack.
699 : : */
700 : 0 : dotraplinkage void do_debug(struct pt_regs *regs, long error_code)
701 : : {
702 [ # # ]: 0 : struct task_struct *tsk = current;
703 : 0 : int user_icebp = 0;
704 : 0 : unsigned long dr6;
705 : 0 : int si_code;
706 : :
707 [ # # ]: 0 : ist_enter(regs);
708 : :
709 : 0 : get_debugreg(dr6, 6);
710 : : /*
711 : : * The Intel SDM says:
712 : : *
713 : : * Certain debug exceptions may clear bits 0-3. The remaining
714 : : * contents of the DR6 register are never cleared by the
715 : : * processor. To avoid confusion in identifying debug
716 : : * exceptions, debug handlers should clear the register before
717 : : * returning to the interrupted task.
718 : : *
719 : : * Keep it simple: clear DR6 immediately.
720 : : */
721 : 0 : set_debugreg(0, 6);
722 : :
723 : : /* Filter out all the reserved bits which are preset to 1 */
724 : 0 : dr6 &= ~DR6_RESERVED;
725 : :
726 : : /*
727 : : * The SDM says "The processor clears the BTF flag when it
728 : : * generates a debug exception." Clear TIF_BLOCKSTEP to keep
729 : : * TIF_BLOCKSTEP in sync with the hardware BTF flag.
730 : : */
731 : 0 : clear_tsk_thread_flag(tsk, TIF_BLOCKSTEP);
732 : :
733 [ # # # # : 0 : if (unlikely(!user_mode(regs) && (dr6 & DR_STEP) &&
# # ]
734 : : is_sysenter_singlestep(regs))) {
735 : 0 : dr6 &= ~DR_STEP;
736 [ # # ]: 0 : if (!dr6)
737 : 0 : goto exit;
738 : : /*
739 : : * else we might have gotten a single-step trap and hit a
740 : : * watchpoint at the same time, in which case we should fall
741 : : * through and handle the watchpoint.
742 : : */
743 : : }
744 : :
745 : : /*
746 : : * If dr6 has no reason to give us about the origin of this trap,
747 : : * then it's very likely the result of an icebp/int01 trap.
748 : : * User wants a sigtrap for that.
749 : : */
750 [ # # # # ]: 0 : if (!dr6 && user_mode(regs))
751 : 0 : user_icebp = 1;
752 : :
753 : : /* Store the virtualized DR6 value */
754 : 0 : tsk->thread.debugreg6 = dr6;
755 : :
756 : : #ifdef CONFIG_KPROBES
757 [ # # ]: 0 : if (kprobe_debug_handler(regs))
758 : 0 : goto exit;
759 : : #endif
760 : :
761 [ # # ]: 0 : if (notify_die(DIE_DEBUG, "debug", regs, (long)&dr6, error_code,
762 : : SIGTRAP) == NOTIFY_STOP)
763 : 0 : goto exit;
764 : :
765 : : /*
766 : : * Let others (NMI) know that the debug stack is in use
767 : : * as we may switch to the interrupt stack.
768 : : */
769 [ # # ]: 0 : debug_stack_usage_inc();
770 : :
771 : : /* It's safe to allow irq's after DR6 has been saved */
772 [ # # ]: 0 : cond_local_irq_enable(regs);
773 : :
774 [ # # ]: 0 : if (v8086_mode(regs)) {
775 : : handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code,
776 : : X86_TRAP_DB);
777 : : cond_local_irq_disable(regs);
778 : : debug_stack_usage_dec();
779 : : goto exit;
780 : : }
781 : :
782 [ # # # # : 0 : if (WARN_ON_ONCE((dr6 & DR_STEP) && !user_mode(regs))) {
# # # # ]
783 : : /*
784 : : * Historical junk that used to handle SYSENTER single-stepping.
785 : : * This should be unreachable now. If we survive for a while
786 : : * without anyone hitting this warning, we'll turn this into
787 : : * an oops.
788 : : */
789 : 0 : tsk->thread.debugreg6 &= ~DR_STEP;
790 : 0 : set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
791 : 0 : regs->flags &= ~X86_EFLAGS_TF;
792 : : }
793 [ # # ]: 0 : si_code = get_si_code(tsk->thread.debugreg6);
794 [ # # # # ]: 0 : if (tsk->thread.debugreg6 & (DR_STEP | DR_TRAP_BITS) || user_icebp)
795 : 0 : send_sigtrap(regs, error_code, si_code);
796 [ # # ]: 0 : cond_local_irq_disable(regs);
797 : 0 : debug_stack_usage_dec();
798 : :
799 : 0 : exit:
800 : 0 : ist_exit(regs);
801 : 0 : }
802 : : NOKPROBE_SYMBOL(do_debug);
803 : :
804 : : /*
805 : : * Note that we play around with the 'TS' bit in an attempt to get
806 : : * the correct behaviour even in the presence of the asynchronous
807 : : * IRQ13 behaviour
808 : : */
809 : 0 : static void math_error(struct pt_regs *regs, int error_code, int trapnr)
810 : : {
811 [ # # ]: 0 : struct task_struct *task = current;
812 : 0 : struct fpu *fpu = &task->thread.fpu;
813 : 0 : int si_code;
814 [ # # ]: 0 : char *str = (trapnr == X86_TRAP_MF) ? "fpu exception" :
815 : : "simd exception";
816 : :
817 [ # # ]: 0 : cond_local_irq_enable(regs);
818 : :
819 [ # # ]: 0 : if (!user_mode(regs)) {
820 [ # # ]: 0 : if (fixup_exception(regs, trapnr, error_code, 0))
821 : : return;
822 : :
823 : 0 : task->thread.error_code = error_code;
824 : 0 : task->thread.trap_nr = trapnr;
825 : :
826 [ # # ]: 0 : if (notify_die(DIE_TRAP, str, regs, error_code,
827 : : trapnr, SIGFPE) != NOTIFY_STOP)
828 : 0 : die(str, regs, error_code);
829 : 0 : return;
830 : : }
831 : :
832 : : /*
833 : : * Save the info for the exception handler and clear the error.
834 : : */
835 : 0 : fpu__save(fpu);
836 : :
837 : 0 : task->thread.trap_nr = trapnr;
838 : 0 : task->thread.error_code = error_code;
839 : :
840 : 0 : si_code = fpu__exception_code(fpu, trapnr);
841 : : /* Retry when we get spurious exceptions: */
842 [ # # ]: 0 : if (!si_code)
843 : : return;
844 : :
845 : 0 : force_sig_fault(SIGFPE, si_code,
846 : 0 : (void __user *)uprobe_get_trap_addr(regs));
847 : : }
848 : :
849 : 0 : dotraplinkage void do_coprocessor_error(struct pt_regs *regs, long error_code)
850 : : {
851 : 0 : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
852 : 0 : math_error(regs, error_code, X86_TRAP_MF);
853 : 0 : }
854 : :
855 : : dotraplinkage void
856 : 0 : do_simd_coprocessor_error(struct pt_regs *regs, long error_code)
857 : : {
858 : 0 : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
859 : 0 : math_error(regs, error_code, X86_TRAP_XF);
860 : 0 : }
861 : :
862 : : dotraplinkage void
863 : 0 : do_spurious_interrupt_bug(struct pt_regs *regs, long error_code)
864 : : {
865 [ # # ]: 0 : cond_local_irq_enable(regs);
866 : 0 : }
867 : :
868 : : dotraplinkage void
869 : 0 : do_device_not_available(struct pt_regs *regs, long error_code)
870 : : {
871 : 0 : unsigned long cr0 = read_cr0();
872 : :
873 : 0 : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
874 : :
875 : : #ifdef CONFIG_MATH_EMULATION
876 : : if (!boot_cpu_has(X86_FEATURE_FPU) && (cr0 & X86_CR0_EM)) {
877 : : struct math_emu_info info = { };
878 : :
879 : : cond_local_irq_enable(regs);
880 : :
881 : : info.regs = regs;
882 : : math_emulate(&info);
883 : : return;
884 : : }
885 : : #endif
886 : :
887 : : /* This should not happen. */
888 [ # # # # ]: 0 : if (WARN(cr0 & X86_CR0_TS, "CR0.TS was set")) {
889 : : /* Try to fix it up and carry on. */
890 : 0 : write_cr0(cr0 & ~X86_CR0_TS);
891 : : } else {
892 : : /*
893 : : * Something terrible happened, and we're better off trying
894 : : * to kill the task than getting stuck in a never-ending
895 : : * loop of #NM faults.
896 : : */
897 : 0 : die("unexpected #NM exception", regs, error_code);
898 : : }
899 : 0 : }
900 : : NOKPROBE_SYMBOL(do_device_not_available);
901 : :
902 : : #ifdef CONFIG_X86_32
903 : : dotraplinkage void do_iret_error(struct pt_regs *regs, long error_code)
904 : : {
905 : : RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
906 : : local_irq_enable();
907 : :
908 : : if (notify_die(DIE_TRAP, "iret exception", regs, error_code,
909 : : X86_TRAP_IRET, SIGILL) != NOTIFY_STOP) {
910 : : do_trap(X86_TRAP_IRET, SIGILL, "iret exception", regs, error_code,
911 : : ILL_BADSTK, (void __user *)NULL);
912 : : }
913 : : }
914 : : #endif
915 : :
916 : 13 : void __init trap_init(void)
917 : : {
918 : : /* Init cpu_entry_area before IST entries are set up */
919 : 13 : setup_cpu_entry_areas();
920 : :
921 : 13 : idt_setup_traps();
922 : :
923 : : /*
924 : : * Set the IDT descriptor to a fixed read-only location, so that the
925 : : * "sidt" instruction will not leak the location of the kernel, and
926 : : * to defend the IDT against arbitrary memory write vulnerabilities.
927 : : * It will be reloaded in cpu_init() */
928 : 13 : cea_set_pte(CPU_ENTRY_AREA_RO_IDT_VADDR, __pa_symbol(idt_table),
929 : 13 : PAGE_KERNEL_RO);
930 : 13 : idt_descr.address = CPU_ENTRY_AREA_RO_IDT;
931 : :
932 : : /*
933 : : * Should be a barrier for any external CPU state:
934 : : */
935 : 13 : cpu_init();
936 : :
937 : 13 : idt_setup_ist_traps();
938 : :
939 : 13 : x86_init.irqs.trap_init();
940 : :
941 : 13 : idt_setup_debugidt_traps();
942 : 13 : }
|
