1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 1991, 1992 Linus Torvalds
4 * Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
6 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
7 * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes
8 * 2000-2002 x86-64 support by Andi Kleen
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 #include <linux/sched.h>
14 #include <linux/sched/task_stack.h>
16 #include <linux/smp.h>
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/tracehook.h>
21 #include <linux/unistd.h>
22 #include <linux/stddef.h>
23 #include <linux/personality.h>
24 #include <linux/uaccess.h>
25 #include <linux/user-return-notifier.h>
26 #include <linux/uprobes.h>
27 #include <linux/context_tracking.h>
28 #include <linux/syscalls.h>
30 #include <asm/processor.h>
31 #include <asm/ucontext.h>
32 #include <asm/fpu/internal.h>
33 #include <asm/fpu/signal.h>
36 #include <asm/sighandling.h>
40 #include <asm/proto.h>
41 #include <asm/ia32_unistd.h>
42 #endif /* CONFIG_X86_64 */
44 #include <asm/syscall.h>
45 #include <asm/syscalls.h>
47 #include <asm/sigframe.h>
48 #include <asm/signal.h>
52 * If regs->ss will cause an IRET fault, change it. Otherwise leave it
53 * alone. Using this generally makes no sense unless
54 * user_64bit_mode(regs) would return true.
56 static void force_valid_ss(struct pt_regs
*regs
)
59 asm volatile ("lar %[old_ss], %[ar]\n\t"
60 "jz 1f\n\t" /* If invalid: */
61 "xorl %[ar], %[ar]\n\t" /* set ar = 0 */
64 : [old_ss
] "rm" ((u16
)regs
->ss
));
67 * For a valid 64-bit user context, we need DPL 3, type
68 * read-write data or read-write exp-down data, and S and P
69 * set. We can't use VERW because VERW doesn't check the
72 ar
&= AR_DPL_MASK
| AR_S
| AR_P
| AR_TYPE_MASK
;
73 if (ar
!= (AR_DPL3
| AR_S
| AR_P
| AR_TYPE_RWDATA
) &&
74 ar
!= (AR_DPL3
| AR_S
| AR_P
| AR_TYPE_RWDATA_EXPDOWN
))
77 # define CONTEXT_COPY_SIZE offsetof(struct sigcontext, reserved1)
79 # define CONTEXT_COPY_SIZE sizeof(struct sigcontext)
82 static int restore_sigcontext(struct pt_regs
*regs
,
83 struct sigcontext __user
*usc
,
84 unsigned long uc_flags
)
88 /* Always make any pending restarted system calls return -EINTR */
89 current
->restart_block
.fn
= do_no_restart_syscall
;
91 if (copy_from_user(&sc
, usc
, CONTEXT_COPY_SIZE
))
95 set_user_gs(regs
, sc
.gs
);
99 #endif /* CONFIG_X86_32 */
120 #endif /* CONFIG_X86_64 */
122 /* Get CS/SS and force CPL3 */
123 regs
->cs
= sc
.cs
| 0x03;
124 regs
->ss
= sc
.ss
| 0x03;
126 regs
->flags
= (regs
->flags
& ~FIX_EFLAGS
) | (sc
.flags
& FIX_EFLAGS
);
127 /* disable syscall checks */
132 * Fix up SS if needed for the benefit of old DOSEMU and
135 if (unlikely(!(uc_flags
& UC_STRICT_RESTORE_SS
) && user_64bit_mode(regs
)))
136 force_valid_ss(regs
);
139 return fpu__restore_sig((void __user
*)sc
.fpstate
,
140 IS_ENABLED(CONFIG_X86_32
));
143 int setup_sigcontext(struct sigcontext __user
*sc
, void __user
*fpstate
,
144 struct pt_regs
*regs
, unsigned long mask
)
151 put_user_ex(get_user_gs(regs
), (unsigned int __user
*)&sc
->gs
);
152 put_user_ex(regs
->fs
, (unsigned int __user
*)&sc
->fs
);
153 put_user_ex(regs
->es
, (unsigned int __user
*)&sc
->es
);
154 put_user_ex(regs
->ds
, (unsigned int __user
*)&sc
->ds
);
155 #endif /* CONFIG_X86_32 */
157 put_user_ex(regs
->di
, &sc
->di
);
158 put_user_ex(regs
->si
, &sc
->si
);
159 put_user_ex(regs
->bp
, &sc
->bp
);
160 put_user_ex(regs
->sp
, &sc
->sp
);
161 put_user_ex(regs
->bx
, &sc
->bx
);
162 put_user_ex(regs
->dx
, &sc
->dx
);
163 put_user_ex(regs
->cx
, &sc
->cx
);
164 put_user_ex(regs
->ax
, &sc
->ax
);
166 put_user_ex(regs
->r8
, &sc
->r8
);
167 put_user_ex(regs
->r9
, &sc
->r9
);
168 put_user_ex(regs
->r10
, &sc
->r10
);
169 put_user_ex(regs
->r11
, &sc
->r11
);
170 put_user_ex(regs
->r12
, &sc
->r12
);
171 put_user_ex(regs
->r13
, &sc
->r13
);
172 put_user_ex(regs
->r14
, &sc
->r14
);
173 put_user_ex(regs
->r15
, &sc
->r15
);
174 #endif /* CONFIG_X86_64 */
176 put_user_ex(current
->thread
.trap_nr
, &sc
->trapno
);
177 put_user_ex(current
->thread
.error_code
, &sc
->err
);
178 put_user_ex(regs
->ip
, &sc
->ip
);
180 put_user_ex(regs
->cs
, (unsigned int __user
*)&sc
->cs
);
181 put_user_ex(regs
->flags
, &sc
->flags
);
182 put_user_ex(regs
->sp
, &sc
->sp_at_signal
);
183 put_user_ex(regs
->ss
, (unsigned int __user
*)&sc
->ss
);
184 #else /* !CONFIG_X86_32 */
185 put_user_ex(regs
->flags
, &sc
->flags
);
186 put_user_ex(regs
->cs
, &sc
->cs
);
187 put_user_ex(0, &sc
->gs
);
188 put_user_ex(0, &sc
->fs
);
189 put_user_ex(regs
->ss
, &sc
->ss
);
190 #endif /* CONFIG_X86_32 */
192 put_user_ex(fpstate
, (unsigned long __user
*)&sc
->fpstate
);
194 /* non-iBCS2 extensions.. */
195 put_user_ex(mask
, &sc
->oldmask
);
196 put_user_ex(current
->thread
.cr2
, &sc
->cr2
);
197 } put_user_catch(err
);
203 * Set up a signal frame.
207 * Determine which stack to use..
209 static unsigned long align_sigframe(unsigned long sp
)
213 * Align the stack pointer according to the i386 ABI,
214 * i.e. so that on function entry ((sp + 4) & 15) == 0.
216 sp
= ((sp
+ 4) & -16ul) - 4;
217 #else /* !CONFIG_X86_32 */
218 sp
= round_down(sp
, 16) - 8;
224 get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
, size_t frame_size
,
225 void __user
**fpstate
)
227 /* Default to using normal stack */
228 unsigned long math_size
= 0;
229 unsigned long sp
= regs
->sp
;
230 unsigned long buf_fx
= 0;
231 int onsigstack
= on_sig_stack(sp
);
235 if (IS_ENABLED(CONFIG_X86_64
))
238 /* This is the X/Open sanctioned signal stack switching. */
239 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
240 if (sas_ss_flags(sp
) == 0)
241 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
242 } else if (IS_ENABLED(CONFIG_X86_32
) &&
244 regs
->ss
!= __USER_DS
&&
245 !(ka
->sa
.sa_flags
& SA_RESTORER
) &&
246 ka
->sa
.sa_restorer
) {
247 /* This is the legacy signal stack switching. */
248 sp
= (unsigned long) ka
->sa
.sa_restorer
;
251 sp
= fpu__alloc_mathframe(sp
, IS_ENABLED(CONFIG_X86_32
),
252 &buf_fx
, &math_size
);
253 *fpstate
= (void __user
*)sp
;
255 sp
= align_sigframe(sp
- frame_size
);
258 * If we are on the alternate signal stack and would overflow it, don't.
259 * Return an always-bogus address instead so we will die with SIGSEGV.
261 if (onsigstack
&& !likely(on_sig_stack(sp
)))
262 return (void __user
*)-1L;
264 /* save i387 and extended state */
265 ret
= copy_fpstate_to_sigframe(*fpstate
, (void __user
*)buf_fx
, math_size
);
267 return (void __user
*)-1L;
269 return (void __user
*)sp
;
273 static const struct {
277 } __attribute__((packed
)) retcode
= {
278 0xb858, /* popl %eax; movl $..., %eax */
280 0x80cd, /* int $0x80 */
283 static const struct {
288 } __attribute__((packed
)) rt_retcode
= {
289 0xb8, /* movl $..., %eax */
291 0x80cd, /* int $0x80 */
296 __setup_frame(int sig
, struct ksignal
*ksig
, sigset_t
*set
,
297 struct pt_regs
*regs
)
299 struct sigframe __user
*frame
;
300 void __user
*restorer
;
302 void __user
*fpstate
= NULL
;
304 frame
= get_sigframe(&ksig
->ka
, regs
, sizeof(*frame
), &fpstate
);
306 if (!access_ok(frame
, sizeof(*frame
)))
309 if (__put_user(sig
, &frame
->sig
))
312 if (setup_sigcontext(&frame
->sc
, fpstate
, regs
, set
->sig
[0]))
315 if (__put_user(set
->sig
[1], &frame
->extramask
[0]))
318 if (current
->mm
->context
.vdso
)
319 restorer
= current
->mm
->context
.vdso
+
320 vdso_image_32
.sym___kernel_sigreturn
;
322 restorer
= &frame
->retcode
;
323 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
)
324 restorer
= ksig
->ka
.sa
.sa_restorer
;
326 /* Set up to return from userspace. */
327 err
|= __put_user(restorer
, &frame
->pretcode
);
330 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80
332 * WE DO NOT USE IT ANY MORE! It's only left here for historical
333 * reasons and because gdb uses it as a signature to notice
334 * signal handler stack frames.
336 err
|= __put_user(*((u64
*)&retcode
), (u64
*)frame
->retcode
);
341 /* Set up registers for signal handler */
342 regs
->sp
= (unsigned long)frame
;
343 regs
->ip
= (unsigned long)ksig
->ka
.sa
.sa_handler
;
344 regs
->ax
= (unsigned long)sig
;
348 regs
->ds
= __USER_DS
;
349 regs
->es
= __USER_DS
;
350 regs
->ss
= __USER_DS
;
351 regs
->cs
= __USER_CS
;
356 static int __setup_rt_frame(int sig
, struct ksignal
*ksig
,
357 sigset_t
*set
, struct pt_regs
*regs
)
359 struct rt_sigframe __user
*frame
;
360 void __user
*restorer
;
362 void __user
*fpstate
= NULL
;
364 frame
= get_sigframe(&ksig
->ka
, regs
, sizeof(*frame
), &fpstate
);
366 if (!access_ok(frame
, sizeof(*frame
)))
370 put_user_ex(sig
, &frame
->sig
);
371 put_user_ex(&frame
->info
, &frame
->pinfo
);
372 put_user_ex(&frame
->uc
, &frame
->puc
);
374 /* Create the ucontext. */
375 if (static_cpu_has(X86_FEATURE_XSAVE
))
376 put_user_ex(UC_FP_XSTATE
, &frame
->uc
.uc_flags
);
378 put_user_ex(0, &frame
->uc
.uc_flags
);
379 put_user_ex(0, &frame
->uc
.uc_link
);
380 save_altstack_ex(&frame
->uc
.uc_stack
, regs
->sp
);
382 /* Set up to return from userspace. */
383 restorer
= current
->mm
->context
.vdso
+
384 vdso_image_32
.sym___kernel_rt_sigreturn
;
385 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
)
386 restorer
= ksig
->ka
.sa
.sa_restorer
;
387 put_user_ex(restorer
, &frame
->pretcode
);
390 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80
392 * WE DO NOT USE IT ANY MORE! It's only left here for historical
393 * reasons and because gdb uses it as a signature to notice
394 * signal handler stack frames.
396 put_user_ex(*((u64
*)&rt_retcode
), (u64
*)frame
->retcode
);
397 } put_user_catch(err
);
399 err
|= copy_siginfo_to_user(&frame
->info
, &ksig
->info
);
400 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fpstate
,
402 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
407 /* Set up registers for signal handler */
408 regs
->sp
= (unsigned long)frame
;
409 regs
->ip
= (unsigned long)ksig
->ka
.sa
.sa_handler
;
410 regs
->ax
= (unsigned long)sig
;
411 regs
->dx
= (unsigned long)&frame
->info
;
412 regs
->cx
= (unsigned long)&frame
->uc
;
414 regs
->ds
= __USER_DS
;
415 regs
->es
= __USER_DS
;
416 regs
->ss
= __USER_DS
;
417 regs
->cs
= __USER_CS
;
421 #else /* !CONFIG_X86_32 */
422 static unsigned long frame_uc_flags(struct pt_regs
*regs
)
426 if (boot_cpu_has(X86_FEATURE_XSAVE
))
427 flags
= UC_FP_XSTATE
| UC_SIGCONTEXT_SS
;
429 flags
= UC_SIGCONTEXT_SS
;
431 if (likely(user_64bit_mode(regs
)))
432 flags
|= UC_STRICT_RESTORE_SS
;
437 static int __setup_rt_frame(int sig
, struct ksignal
*ksig
,
438 sigset_t
*set
, struct pt_regs
*regs
)
440 struct rt_sigframe __user
*frame
;
441 void __user
*fp
= NULL
;
442 unsigned long uc_flags
;
445 frame
= get_sigframe(&ksig
->ka
, regs
, sizeof(struct rt_sigframe
), &fp
);
447 if (!access_ok(frame
, sizeof(*frame
)))
450 if (ksig
->ka
.sa
.sa_flags
& SA_SIGINFO
) {
451 if (copy_siginfo_to_user(&frame
->info
, &ksig
->info
))
455 uc_flags
= frame_uc_flags(regs
);
458 /* Create the ucontext. */
459 put_user_ex(uc_flags
, &frame
->uc
.uc_flags
);
460 put_user_ex(0, &frame
->uc
.uc_link
);
461 save_altstack_ex(&frame
->uc
.uc_stack
, regs
->sp
);
463 /* Set up to return from userspace. If provided, use a stub
464 already in userspace. */
465 /* x86-64 should always use SA_RESTORER. */
466 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
) {
467 put_user_ex(ksig
->ka
.sa
.sa_restorer
, &frame
->pretcode
);
469 /* could use a vstub here */
472 } put_user_catch(err
);
474 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fp
, regs
, set
->sig
[0]);
475 err
|= __put_user(set
->sig
[0], &frame
->uc
.uc_sigmask
.sig
[0]);
480 /* Set up registers for signal handler */
482 /* In case the signal handler was declared without prototypes */
485 /* This also works for non SA_SIGINFO handlers because they expect the
486 next argument after the signal number on the stack. */
487 regs
->si
= (unsigned long)&frame
->info
;
488 regs
->dx
= (unsigned long)&frame
->uc
;
489 regs
->ip
= (unsigned long) ksig
->ka
.sa
.sa_handler
;
491 regs
->sp
= (unsigned long)frame
;
494 * Set up the CS and SS registers to run signal handlers in
495 * 64-bit mode, even if the handler happens to be interrupting
496 * 32-bit or 16-bit code.
498 * SS is subtle. In 64-bit mode, we don't need any particular
499 * SS descriptor, but we do need SS to be valid. It's possible
500 * that the old SS is entirely bogus -- this can happen if the
501 * signal we're trying to deliver is #GP or #SS caused by a bad
502 * SS value. We also have a compatbility issue here: DOSEMU
503 * relies on the contents of the SS register indicating the
504 * SS value at the time of the signal, even though that code in
505 * DOSEMU predates sigreturn's ability to restore SS. (DOSEMU
506 * avoids relying on sigreturn to restore SS; instead it uses
507 * a trampoline.) So we do our best: if the old SS was valid,
508 * we keep it. Otherwise we replace it.
510 regs
->cs
= __USER_CS
;
512 if (unlikely(regs
->ss
!= __USER_DS
))
513 force_valid_ss(regs
);
517 #endif /* CONFIG_X86_32 */
519 static int x32_setup_rt_frame(struct ksignal
*ksig
,
520 compat_sigset_t
*set
,
521 struct pt_regs
*regs
)
523 #ifdef CONFIG_X86_X32_ABI
524 struct rt_sigframe_x32 __user
*frame
;
525 unsigned long uc_flags
;
526 void __user
*restorer
;
528 void __user
*fpstate
= NULL
;
530 frame
= get_sigframe(&ksig
->ka
, regs
, sizeof(*frame
), &fpstate
);
532 if (!access_ok(frame
, sizeof(*frame
)))
535 if (ksig
->ka
.sa
.sa_flags
& SA_SIGINFO
) {
536 if (__copy_siginfo_to_user32(&frame
->info
, &ksig
->info
, true))
540 uc_flags
= frame_uc_flags(regs
);
543 /* Create the ucontext. */
544 put_user_ex(uc_flags
, &frame
->uc
.uc_flags
);
545 put_user_ex(0, &frame
->uc
.uc_link
);
546 compat_save_altstack_ex(&frame
->uc
.uc_stack
, regs
->sp
);
547 put_user_ex(0, &frame
->uc
.uc__pad0
);
549 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
) {
550 restorer
= ksig
->ka
.sa
.sa_restorer
;
552 /* could use a vstub here */
556 put_user_ex(restorer
, (unsigned long __user
*)&frame
->pretcode
);
557 } put_user_catch(err
);
559 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fpstate
,
561 err
|= __put_user(*(__u64
*)set
, (__u64 __user
*)&frame
->uc
.uc_sigmask
);
566 /* Set up registers for signal handler */
567 regs
->sp
= (unsigned long) frame
;
568 regs
->ip
= (unsigned long) ksig
->ka
.sa
.sa_handler
;
570 /* We use the x32 calling convention here... */
571 regs
->di
= ksig
->sig
;
572 regs
->si
= (unsigned long) &frame
->info
;
573 regs
->dx
= (unsigned long) &frame
->uc
;
575 loadsegment(ds
, __USER_DS
);
576 loadsegment(es
, __USER_DS
);
578 regs
->cs
= __USER_CS
;
579 regs
->ss
= __USER_DS
;
580 #endif /* CONFIG_X86_X32_ABI */
586 * Do a signal return; undo the signal stack.
589 SYSCALL_DEFINE0(sigreturn
)
591 struct pt_regs
*regs
= current_pt_regs();
592 struct sigframe __user
*frame
;
595 frame
= (struct sigframe __user
*)(regs
->sp
- 8);
597 if (!access_ok(frame
, sizeof(*frame
)))
599 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
) ||
600 __get_user(set
.sig
[1], &frame
->extramask
[0]))
603 set_current_blocked(&set
);
606 * x86_32 has no uc_flags bits relevant to restore_sigcontext.
607 * Save a few cycles by skipping the __get_user.
609 if (restore_sigcontext(regs
, &frame
->sc
, 0))
614 signal_fault(regs
, frame
, "sigreturn");
618 #endif /* CONFIG_X86_32 */
620 SYSCALL_DEFINE0(rt_sigreturn
)
622 struct pt_regs
*regs
= current_pt_regs();
623 struct rt_sigframe __user
*frame
;
625 unsigned long uc_flags
;
627 frame
= (struct rt_sigframe __user
*)(regs
->sp
- sizeof(long));
628 if (!access_ok(frame
, sizeof(*frame
)))
630 if (__get_user(*(__u64
*)&set
, (__u64 __user
*)&frame
->uc
.uc_sigmask
))
632 if (__get_user(uc_flags
, &frame
->uc
.uc_flags
))
635 set_current_blocked(&set
);
637 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, uc_flags
))
640 if (restore_altstack(&frame
->uc
.uc_stack
))
646 signal_fault(regs
, frame
, "rt_sigreturn");
650 static inline int is_ia32_compat_frame(struct ksignal
*ksig
)
652 return IS_ENABLED(CONFIG_IA32_EMULATION
) &&
653 ksig
->ka
.sa
.sa_flags
& SA_IA32_ABI
;
656 static inline int is_ia32_frame(struct ksignal
*ksig
)
658 return IS_ENABLED(CONFIG_X86_32
) || is_ia32_compat_frame(ksig
);
661 static inline int is_x32_frame(struct ksignal
*ksig
)
663 return IS_ENABLED(CONFIG_X86_X32_ABI
) &&
664 ksig
->ka
.sa
.sa_flags
& SA_X32_ABI
;
668 setup_rt_frame(struct ksignal
*ksig
, struct pt_regs
*regs
)
670 int usig
= ksig
->sig
;
671 sigset_t
*set
= sigmask_to_save();
672 compat_sigset_t
*cset
= (compat_sigset_t
*) set
;
674 /* Perform fixup for the pre-signal frame. */
675 rseq_signal_deliver(ksig
, regs
);
677 /* Set up the stack frame */
678 if (is_ia32_frame(ksig
)) {
679 if (ksig
->ka
.sa
.sa_flags
& SA_SIGINFO
)
680 return ia32_setup_rt_frame(usig
, ksig
, cset
, regs
);
682 return ia32_setup_frame(usig
, ksig
, cset
, regs
);
683 } else if (is_x32_frame(ksig
)) {
684 return x32_setup_rt_frame(ksig
, cset
, regs
);
686 return __setup_rt_frame(ksig
->sig
, ksig
, set
, regs
);
691 handle_signal(struct ksignal
*ksig
, struct pt_regs
*regs
)
693 bool stepping
, failed
;
694 struct fpu
*fpu
= ¤t
->thread
.fpu
;
696 if (v8086_mode(regs
))
697 save_v86_state((struct kernel_vm86_regs
*) regs
, VM86_SIGNAL
);
699 /* Are we from a system call? */
700 if (syscall_get_nr(current
, regs
) >= 0) {
701 /* If so, check system call restarting.. */
702 switch (syscall_get_error(current
, regs
)) {
703 case -ERESTART_RESTARTBLOCK
:
704 case -ERESTARTNOHAND
:
709 if (!(ksig
->ka
.sa
.sa_flags
& SA_RESTART
)) {
714 case -ERESTARTNOINTR
:
715 regs
->ax
= regs
->orig_ax
;
722 * If TF is set due to a debugger (TIF_FORCED_TF), clear TF now
723 * so that register information in the sigcontext is correct and
724 * then notify the tracer before entering the signal handler.
726 stepping
= test_thread_flag(TIF_SINGLESTEP
);
728 user_disable_single_step(current
);
730 failed
= (setup_rt_frame(ksig
, regs
) < 0);
733 * Clear the direction flag as per the ABI for function entry.
735 * Clear RF when entering the signal handler, because
736 * it might disable possible debug exception from the
739 * Clear TF for the case when it wasn't set by debugger to
740 * avoid the recursive send_sigtrap() in SIGTRAP handler.
742 regs
->flags
&= ~(X86_EFLAGS_DF
|X86_EFLAGS_RF
|X86_EFLAGS_TF
);
744 * Ensure the signal handler starts with the new fpu state.
748 signal_setup_done(failed
, ksig
, stepping
);
751 static inline unsigned long get_nr_restart_syscall(const struct pt_regs
*regs
)
754 * This function is fundamentally broken as currently
757 * The idea is that we want to trigger a call to the
758 * restart_block() syscall and that we want in_ia32_syscall(),
759 * in_x32_syscall(), etc. to match whatever they were in the
760 * syscall being restarted. We assume that the syscall
761 * instruction at (regs->ip - 2) matches whatever syscall
762 * instruction we used to enter in the first place.
764 * The problem is that we can get here when ptrace pokes
765 * syscall-like values into regs even if we're not in a syscall
768 * For now, we maintain historical behavior and guess based on
769 * stored state. We could do better by saving the actual
770 * syscall arch in restart_block or (with caveats on x32) by
771 * checking if regs->ip points to 'int $0x80'. The current
772 * behavior is incorrect if a tracer has a different bitness
775 #ifdef CONFIG_IA32_EMULATION
776 if (current_thread_info()->status
& (TS_COMPAT
|TS_I386_REGS_POKED
))
777 return __NR_ia32_restart_syscall
;
779 #ifdef CONFIG_X86_X32_ABI
780 return __NR_restart_syscall
| (regs
->orig_ax
& __X32_SYSCALL_BIT
);
782 return __NR_restart_syscall
;
787 * Note that 'init' is a special process: it doesn't get signals it doesn't
788 * want to handle. Thus you cannot kill init even with a SIGKILL even by
791 void do_signal(struct pt_regs
*regs
)
795 if (get_signal(&ksig
)) {
796 /* Whee! Actually deliver the signal. */
797 handle_signal(&ksig
, regs
);
801 /* Did we come from a system call? */
802 if (syscall_get_nr(current
, regs
) >= 0) {
803 /* Restart the system call - no handlers present */
804 switch (syscall_get_error(current
, regs
)) {
805 case -ERESTARTNOHAND
:
807 case -ERESTARTNOINTR
:
808 regs
->ax
= regs
->orig_ax
;
812 case -ERESTART_RESTARTBLOCK
:
813 regs
->ax
= get_nr_restart_syscall(regs
);
820 * If there's no signal to deliver, we just put the saved sigmask
823 restore_saved_sigmask();
826 void signal_fault(struct pt_regs
*regs
, void __user
*frame
, char *where
)
828 struct task_struct
*me
= current
;
830 if (show_unhandled_signals
&& printk_ratelimit()) {
832 "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
833 task_pid_nr(current
) > 1 ? KERN_INFO
: KERN_EMERG
,
834 me
->comm
, me
->pid
, where
, frame
,
835 regs
->ip
, regs
->sp
, regs
->orig_ax
);
836 print_vma_addr(KERN_CONT
" in ", regs
->ip
);
843 #ifdef CONFIG_X86_X32_ABI
844 asmlinkage
long sys32_x32_rt_sigreturn(void)
846 struct pt_regs
*regs
= current_pt_regs();
847 struct rt_sigframe_x32 __user
*frame
;
849 unsigned long uc_flags
;
851 frame
= (struct rt_sigframe_x32 __user
*)(regs
->sp
- 8);
853 if (!access_ok(frame
, sizeof(*frame
)))
855 if (__get_user(set
.sig
[0], (__u64 __user
*)&frame
->uc
.uc_sigmask
))
857 if (__get_user(uc_flags
, &frame
->uc
.uc_flags
))
860 set_current_blocked(&set
);
862 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, uc_flags
))
865 if (compat_restore_altstack(&frame
->uc
.uc_stack
))
871 signal_fault(regs
, frame
, "x32 rt_sigreturn");