2 * Copyright (C) 1991, 1992 Linus Torvalds
3 * Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
5 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
6 * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes
7 * 2000-2002 x86-64 support by Andi Kleen
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/sched.h>
14 #include <linux/smp.h>
15 #include <linux/kernel.h>
16 #include <linux/errno.h>
17 #include <linux/wait.h>
18 #include <linux/tracehook.h>
19 #include <linux/unistd.h>
20 #include <linux/stddef.h>
21 #include <linux/personality.h>
22 #include <linux/uaccess.h>
23 #include <linux/user-return-notifier.h>
24 #include <linux/uprobes.h>
25 #include <linux/context_tracking.h>
27 #include <asm/processor.h>
28 #include <asm/ucontext.h>
30 #include <asm/fpu-internal.h>
33 #include <asm/sighandling.h>
36 #include <asm/proto.h>
37 #include <asm/ia32_unistd.h>
38 #include <asm/sys_ia32.h>
39 #endif /* CONFIG_X86_64 */
41 #include <asm/syscall.h>
42 #include <asm/syscalls.h>
44 #include <asm/sigframe.h>
47 # define FIX_EFLAGS (__FIX_EFLAGS | X86_EFLAGS_RF)
49 # define FIX_EFLAGS __FIX_EFLAGS
52 #define COPY(x) do { \
53 get_user_ex(regs->x, &sc->x); \
56 #define GET_SEG(seg) ({ \
58 get_user_ex(tmp, &sc->seg); \
62 #define COPY_SEG(seg) do { \
63 regs->seg = GET_SEG(seg); \
66 #define COPY_SEG_CPL3(seg) do { \
67 regs->seg = GET_SEG(seg) | 3; \
70 int restore_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
,
74 unsigned int tmpflags
;
77 /* Always make any pending restarted system calls return -EINTR */
78 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
83 set_user_gs(regs
, GET_SEG(gs
));
87 #endif /* CONFIG_X86_32 */
89 COPY(di
); COPY(si
); COPY(bp
); COPY(sp
); COPY(bx
);
90 COPY(dx
); COPY(cx
); COPY(ip
);
101 #endif /* CONFIG_X86_64 */
106 #else /* !CONFIG_X86_32 */
107 /* Kernel saves and restores only the CS segment register on signals,
108 * which is the bare minimum needed to allow mixed 32/64-bit code.
109 * App's signal handler can save/restore other segments if needed. */
111 #endif /* CONFIG_X86_32 */
113 get_user_ex(tmpflags
, &sc
->flags
);
114 regs
->flags
= (regs
->flags
& ~FIX_EFLAGS
) | (tmpflags
& FIX_EFLAGS
);
115 regs
->orig_ax
= -1; /* disable syscall checks */
117 get_user_ex(buf
, &sc
->fpstate
);
119 get_user_ex(*pax
, &sc
->ax
);
120 } get_user_catch(err
);
122 err
|= restore_xstate_sig(buf
, config_enabled(CONFIG_X86_32
));
127 int setup_sigcontext(struct sigcontext __user
*sc
, void __user
*fpstate
,
128 struct pt_regs
*regs
, unsigned long mask
)
135 put_user_ex(get_user_gs(regs
), (unsigned int __user
*)&sc
->gs
);
136 put_user_ex(regs
->fs
, (unsigned int __user
*)&sc
->fs
);
137 put_user_ex(regs
->es
, (unsigned int __user
*)&sc
->es
);
138 put_user_ex(regs
->ds
, (unsigned int __user
*)&sc
->ds
);
139 #endif /* CONFIG_X86_32 */
141 put_user_ex(regs
->di
, &sc
->di
);
142 put_user_ex(regs
->si
, &sc
->si
);
143 put_user_ex(regs
->bp
, &sc
->bp
);
144 put_user_ex(regs
->sp
, &sc
->sp
);
145 put_user_ex(regs
->bx
, &sc
->bx
);
146 put_user_ex(regs
->dx
, &sc
->dx
);
147 put_user_ex(regs
->cx
, &sc
->cx
);
148 put_user_ex(regs
->ax
, &sc
->ax
);
150 put_user_ex(regs
->r8
, &sc
->r8
);
151 put_user_ex(regs
->r9
, &sc
->r9
);
152 put_user_ex(regs
->r10
, &sc
->r10
);
153 put_user_ex(regs
->r11
, &sc
->r11
);
154 put_user_ex(regs
->r12
, &sc
->r12
);
155 put_user_ex(regs
->r13
, &sc
->r13
);
156 put_user_ex(regs
->r14
, &sc
->r14
);
157 put_user_ex(regs
->r15
, &sc
->r15
);
158 #endif /* CONFIG_X86_64 */
160 put_user_ex(current
->thread
.trap_nr
, &sc
->trapno
);
161 put_user_ex(current
->thread
.error_code
, &sc
->err
);
162 put_user_ex(regs
->ip
, &sc
->ip
);
164 put_user_ex(regs
->cs
, (unsigned int __user
*)&sc
->cs
);
165 put_user_ex(regs
->flags
, &sc
->flags
);
166 put_user_ex(regs
->sp
, &sc
->sp_at_signal
);
167 put_user_ex(regs
->ss
, (unsigned int __user
*)&sc
->ss
);
168 #else /* !CONFIG_X86_32 */
169 put_user_ex(regs
->flags
, &sc
->flags
);
170 put_user_ex(regs
->cs
, &sc
->cs
);
171 put_user_ex(0, &sc
->gs
);
172 put_user_ex(0, &sc
->fs
);
173 #endif /* CONFIG_X86_32 */
175 put_user_ex(fpstate
, &sc
->fpstate
);
177 /* non-iBCS2 extensions.. */
178 put_user_ex(mask
, &sc
->oldmask
);
179 put_user_ex(current
->thread
.cr2
, &sc
->cr2
);
180 } put_user_catch(err
);
186 * Set up a signal frame.
190 * Determine which stack to use..
192 static unsigned long align_sigframe(unsigned long sp
)
196 * Align the stack pointer according to the i386 ABI,
197 * i.e. so that on function entry ((sp + 4) & 15) == 0.
199 sp
= ((sp
+ 4) & -16ul) - 4;
200 #else /* !CONFIG_X86_32 */
201 sp
= round_down(sp
, 16) - 8;
206 static inline void __user
*
207 get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
, size_t frame_size
,
208 void __user
**fpstate
)
210 /* Default to using normal stack */
211 unsigned long math_size
= 0;
212 unsigned long sp
= regs
->sp
;
213 unsigned long buf_fx
= 0;
214 int onsigstack
= on_sig_stack(sp
);
217 if (config_enabled(CONFIG_X86_64
))
221 /* This is the X/Open sanctioned signal stack switching. */
222 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
223 if (current
->sas_ss_size
)
224 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
225 } else if (config_enabled(CONFIG_X86_32
) &&
226 (regs
->ss
& 0xffff) != __USER_DS
&&
227 !(ka
->sa
.sa_flags
& SA_RESTORER
) &&
228 ka
->sa
.sa_restorer
) {
229 /* This is the legacy signal stack switching. */
230 sp
= (unsigned long) ka
->sa
.sa_restorer
;
235 sp
= alloc_mathframe(sp
, config_enabled(CONFIG_X86_32
),
236 &buf_fx
, &math_size
);
237 *fpstate
= (void __user
*)sp
;
240 sp
= align_sigframe(sp
- frame_size
);
243 * If we are on the alternate signal stack and would overflow it, don't.
244 * Return an always-bogus address instead so we will die with SIGSEGV.
246 if (onsigstack
&& !likely(on_sig_stack(sp
)))
247 return (void __user
*)-1L;
249 /* save i387 and extended state */
251 save_xstate_sig(*fpstate
, (void __user
*)buf_fx
, math_size
) < 0)
252 return (void __user
*)-1L;
254 return (void __user
*)sp
;
258 static const struct {
262 } __attribute__((packed
)) retcode
= {
263 0xb858, /* popl %eax; movl $..., %eax */
265 0x80cd, /* int $0x80 */
268 static const struct {
273 } __attribute__((packed
)) rt_retcode
= {
274 0xb8, /* movl $..., %eax */
276 0x80cd, /* int $0x80 */
281 __setup_frame(int sig
, struct k_sigaction
*ka
, sigset_t
*set
,
282 struct pt_regs
*regs
)
284 struct sigframe __user
*frame
;
285 void __user
*restorer
;
287 void __user
*fpstate
= NULL
;
289 frame
= get_sigframe(ka
, regs
, sizeof(*frame
), &fpstate
);
291 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
294 if (__put_user(sig
, &frame
->sig
))
297 if (setup_sigcontext(&frame
->sc
, fpstate
, regs
, set
->sig
[0]))
300 if (_NSIG_WORDS
> 1) {
301 if (__copy_to_user(&frame
->extramask
, &set
->sig
[1],
302 sizeof(frame
->extramask
)))
306 if (current
->mm
->context
.vdso
)
307 restorer
= VDSO32_SYMBOL(current
->mm
->context
.vdso
, sigreturn
);
309 restorer
= &frame
->retcode
;
310 if (ka
->sa
.sa_flags
& SA_RESTORER
)
311 restorer
= ka
->sa
.sa_restorer
;
313 /* Set up to return from userspace. */
314 err
|= __put_user(restorer
, &frame
->pretcode
);
317 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80
319 * WE DO NOT USE IT ANY MORE! It's only left here for historical
320 * reasons and because gdb uses it as a signature to notice
321 * signal handler stack frames.
323 err
|= __put_user(*((u64
*)&retcode
), (u64
*)frame
->retcode
);
328 /* Set up registers for signal handler */
329 regs
->sp
= (unsigned long)frame
;
330 regs
->ip
= (unsigned long)ka
->sa
.sa_handler
;
331 regs
->ax
= (unsigned long)sig
;
335 regs
->ds
= __USER_DS
;
336 regs
->es
= __USER_DS
;
337 regs
->ss
= __USER_DS
;
338 regs
->cs
= __USER_CS
;
343 static int __setup_rt_frame(int sig
, struct k_sigaction
*ka
, siginfo_t
*info
,
344 sigset_t
*set
, struct pt_regs
*regs
)
346 struct rt_sigframe __user
*frame
;
347 void __user
*restorer
;
349 void __user
*fpstate
= NULL
;
351 frame
= get_sigframe(ka
, regs
, sizeof(*frame
), &fpstate
);
353 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
357 put_user_ex(sig
, &frame
->sig
);
358 put_user_ex(&frame
->info
, &frame
->pinfo
);
359 put_user_ex(&frame
->uc
, &frame
->puc
);
361 /* Create the ucontext. */
363 put_user_ex(UC_FP_XSTATE
, &frame
->uc
.uc_flags
);
365 put_user_ex(0, &frame
->uc
.uc_flags
);
366 put_user_ex(0, &frame
->uc
.uc_link
);
367 put_user_ex(current
->sas_ss_sp
, &frame
->uc
.uc_stack
.ss_sp
);
368 put_user_ex(sas_ss_flags(regs
->sp
),
369 &frame
->uc
.uc_stack
.ss_flags
);
370 put_user_ex(current
->sas_ss_size
, &frame
->uc
.uc_stack
.ss_size
);
372 /* Set up to return from userspace. */
373 restorer
= VDSO32_SYMBOL(current
->mm
->context
.vdso
, rt_sigreturn
);
374 if (ka
->sa
.sa_flags
& SA_RESTORER
)
375 restorer
= ka
->sa
.sa_restorer
;
376 put_user_ex(restorer
, &frame
->pretcode
);
379 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80
381 * WE DO NOT USE IT ANY MORE! It's only left here for historical
382 * reasons and because gdb uses it as a signature to notice
383 * signal handler stack frames.
385 put_user_ex(*((u64
*)&rt_retcode
), (u64
*)frame
->retcode
);
386 } put_user_catch(err
);
388 err
|= copy_siginfo_to_user(&frame
->info
, info
);
389 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fpstate
,
391 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
396 /* Set up registers for signal handler */
397 regs
->sp
= (unsigned long)frame
;
398 regs
->ip
= (unsigned long)ka
->sa
.sa_handler
;
399 regs
->ax
= (unsigned long)sig
;
400 regs
->dx
= (unsigned long)&frame
->info
;
401 regs
->cx
= (unsigned long)&frame
->uc
;
403 regs
->ds
= __USER_DS
;
404 regs
->es
= __USER_DS
;
405 regs
->ss
= __USER_DS
;
406 regs
->cs
= __USER_CS
;
410 #else /* !CONFIG_X86_32 */
411 static int __setup_rt_frame(int sig
, struct k_sigaction
*ka
, siginfo_t
*info
,
412 sigset_t
*set
, struct pt_regs
*regs
)
414 struct rt_sigframe __user
*frame
;
415 void __user
*fp
= NULL
;
417 struct task_struct
*me
= current
;
419 frame
= get_sigframe(ka
, regs
, sizeof(struct rt_sigframe
), &fp
);
421 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
424 if (ka
->sa
.sa_flags
& SA_SIGINFO
) {
425 if (copy_siginfo_to_user(&frame
->info
, info
))
430 /* Create the ucontext. */
432 put_user_ex(UC_FP_XSTATE
, &frame
->uc
.uc_flags
);
434 put_user_ex(0, &frame
->uc
.uc_flags
);
435 put_user_ex(0, &frame
->uc
.uc_link
);
436 put_user_ex(me
->sas_ss_sp
, &frame
->uc
.uc_stack
.ss_sp
);
437 put_user_ex(sas_ss_flags(regs
->sp
),
438 &frame
->uc
.uc_stack
.ss_flags
);
439 put_user_ex(me
->sas_ss_size
, &frame
->uc
.uc_stack
.ss_size
);
441 /* Set up to return from userspace. If provided, use a stub
442 already in userspace. */
443 /* x86-64 should always use SA_RESTORER. */
444 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
445 put_user_ex(ka
->sa
.sa_restorer
, &frame
->pretcode
);
447 /* could use a vstub here */
450 } put_user_catch(err
);
452 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fp
, regs
, set
->sig
[0]);
453 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
458 /* Set up registers for signal handler */
460 /* In case the signal handler was declared without prototypes */
463 /* This also works for non SA_SIGINFO handlers because they expect the
464 next argument after the signal number on the stack. */
465 regs
->si
= (unsigned long)&frame
->info
;
466 regs
->dx
= (unsigned long)&frame
->uc
;
467 regs
->ip
= (unsigned long) ka
->sa
.sa_handler
;
469 regs
->sp
= (unsigned long)frame
;
471 /* Set up the CS register to run signal handlers in 64-bit mode,
472 even if the handler happens to be interrupting 32-bit code. */
473 regs
->cs
= __USER_CS
;
477 #endif /* CONFIG_X86_32 */
479 static int x32_setup_rt_frame(int sig
, struct k_sigaction
*ka
,
480 siginfo_t
*info
, compat_sigset_t
*set
,
481 struct pt_regs
*regs
)
483 #ifdef CONFIG_X86_X32_ABI
484 struct rt_sigframe_x32 __user
*frame
;
485 void __user
*restorer
;
487 void __user
*fpstate
= NULL
;
489 frame
= get_sigframe(ka
, regs
, sizeof(*frame
), &fpstate
);
491 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
494 if (ka
->sa
.sa_flags
& SA_SIGINFO
) {
495 if (copy_siginfo_to_user32(&frame
->info
, info
))
500 /* Create the ucontext. */
502 put_user_ex(UC_FP_XSTATE
, &frame
->uc
.uc_flags
);
504 put_user_ex(0, &frame
->uc
.uc_flags
);
505 put_user_ex(0, &frame
->uc
.uc_link
);
506 put_user_ex(current
->sas_ss_sp
, &frame
->uc
.uc_stack
.ss_sp
);
507 put_user_ex(sas_ss_flags(regs
->sp
),
508 &frame
->uc
.uc_stack
.ss_flags
);
509 put_user_ex(current
->sas_ss_size
, &frame
->uc
.uc_stack
.ss_size
);
510 put_user_ex(0, &frame
->uc
.uc__pad0
);
512 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
513 restorer
= ka
->sa
.sa_restorer
;
515 /* could use a vstub here */
519 put_user_ex(restorer
, &frame
->pretcode
);
520 } put_user_catch(err
);
522 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fpstate
,
524 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
529 /* Set up registers for signal handler */
530 regs
->sp
= (unsigned long) frame
;
531 regs
->ip
= (unsigned long) ka
->sa
.sa_handler
;
533 /* We use the x32 calling convention here... */
535 regs
->si
= (unsigned long) &frame
->info
;
536 regs
->dx
= (unsigned long) &frame
->uc
;
538 loadsegment(ds
, __USER_DS
);
539 loadsegment(es
, __USER_DS
);
541 regs
->cs
= __USER_CS
;
542 regs
->ss
= __USER_DS
;
543 #endif /* CONFIG_X86_X32_ABI */
550 * Atomically swap in the new signal mask, and wait for a signal.
553 sys_sigsuspend(int history0
, int history1
, old_sigset_t mask
)
556 siginitset(&blocked
, mask
);
557 return sigsuspend(&blocked
);
561 sys_sigaction(int sig
, const struct old_sigaction __user
*act
,
562 struct old_sigaction __user
*oact
)
564 struct k_sigaction new_ka
, old_ka
;
570 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)))
574 get_user_ex(new_ka
.sa
.sa_handler
, &act
->sa_handler
);
575 get_user_ex(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
576 get_user_ex(mask
, &act
->sa_mask
);
577 get_user_ex(new_ka
.sa
.sa_restorer
, &act
->sa_restorer
);
578 } get_user_catch(ret
);
582 siginitset(&new_ka
.sa
.sa_mask
, mask
);
585 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
588 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)))
592 put_user_ex(old_ka
.sa
.sa_handler
, &oact
->sa_handler
);
593 put_user_ex(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
594 put_user_ex(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
);
595 put_user_ex(old_ka
.sa
.sa_restorer
, &oact
->sa_restorer
);
596 } put_user_catch(ret
);
604 #endif /* CONFIG_X86_32 */
607 sys_sigaltstack(const stack_t __user
*uss
, stack_t __user
*uoss
,
608 struct pt_regs
*regs
)
610 return do_sigaltstack(uss
, uoss
, regs
->sp
);
614 * Do a signal return; undo the signal stack.
617 unsigned long sys_sigreturn(struct pt_regs
*regs
)
619 struct sigframe __user
*frame
;
623 frame
= (struct sigframe __user
*)(regs
->sp
- 8);
625 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
627 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
) || (_NSIG_WORDS
> 1
628 && __copy_from_user(&set
.sig
[1], &frame
->extramask
,
629 sizeof(frame
->extramask
))))
632 set_current_blocked(&set
);
634 if (restore_sigcontext(regs
, &frame
->sc
, &ax
))
639 signal_fault(regs
, frame
, "sigreturn");
643 #endif /* CONFIG_X86_32 */
645 long sys_rt_sigreturn(struct pt_regs
*regs
)
647 struct rt_sigframe __user
*frame
;
651 frame
= (struct rt_sigframe __user
*)(regs
->sp
- sizeof(long));
652 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
654 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
657 set_current_blocked(&set
);
659 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, &ax
))
662 if (do_sigaltstack(&frame
->uc
.uc_stack
, NULL
, regs
->sp
) == -EFAULT
)
668 signal_fault(regs
, frame
, "rt_sigreturn");
673 * OK, we're invoking a handler:
675 static int signr_convert(int sig
)
678 struct thread_info
*info
= current_thread_info();
680 if (info
->exec_domain
&& info
->exec_domain
->signal_invmap
&& sig
< 32)
681 return info
->exec_domain
->signal_invmap
[sig
];
682 #endif /* CONFIG_X86_32 */
687 setup_rt_frame(int sig
, struct k_sigaction
*ka
, siginfo_t
*info
,
688 struct pt_regs
*regs
)
690 int usig
= signr_convert(sig
);
691 sigset_t
*set
= sigmask_to_save();
692 compat_sigset_t
*cset
= (compat_sigset_t
*) set
;
694 /* Set up the stack frame */
695 if (is_ia32_frame()) {
696 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
697 return ia32_setup_rt_frame(usig
, ka
, info
, cset
, regs
);
699 return ia32_setup_frame(usig
, ka
, cset
, regs
);
700 } else if (is_x32_frame()) {
701 return x32_setup_rt_frame(usig
, ka
, info
, cset
, regs
);
703 return __setup_rt_frame(sig
, ka
, info
, set
, regs
);
708 handle_signal(unsigned long sig
, siginfo_t
*info
, struct k_sigaction
*ka
,
709 struct pt_regs
*regs
)
711 /* Are we from a system call? */
712 if (syscall_get_nr(current
, regs
) >= 0) {
713 /* If so, check system call restarting.. */
714 switch (syscall_get_error(current
, regs
)) {
715 case -ERESTART_RESTARTBLOCK
:
716 case -ERESTARTNOHAND
:
721 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
726 case -ERESTARTNOINTR
:
727 regs
->ax
= regs
->orig_ax
;
734 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF
735 * flag so that register information in the sigcontext is correct.
737 if (unlikely(regs
->flags
& X86_EFLAGS_TF
) &&
738 likely(test_and_clear_thread_flag(TIF_FORCED_TF
)))
739 regs
->flags
&= ~X86_EFLAGS_TF
;
741 if (setup_rt_frame(sig
, ka
, info
, regs
) < 0) {
742 force_sigsegv(sig
, current
);
747 * Clear the direction flag as per the ABI for function entry.
749 regs
->flags
&= ~X86_EFLAGS_DF
;
752 * Clear TF when entering the signal handler, but
753 * notify any tracer that was single-stepping it.
754 * The tracer may want to single-step inside the
757 regs
->flags
&= ~X86_EFLAGS_TF
;
759 signal_delivered(sig
, info
, ka
, regs
,
760 test_thread_flag(TIF_SINGLESTEP
));
764 #define NR_restart_syscall __NR_restart_syscall
765 #else /* !CONFIG_X86_32 */
766 #define NR_restart_syscall \
767 test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall
768 #endif /* CONFIG_X86_32 */
771 * Note that 'init' is a special process: it doesn't get signals it doesn't
772 * want to handle. Thus you cannot kill init even with a SIGKILL even by
775 static void do_signal(struct pt_regs
*regs
)
777 struct k_sigaction ka
;
781 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
783 /* Whee! Actually deliver the signal. */
784 handle_signal(signr
, &info
, &ka
, regs
);
788 /* Did we come from a system call? */
789 if (syscall_get_nr(current
, regs
) >= 0) {
790 /* Restart the system call - no handlers present */
791 switch (syscall_get_error(current
, regs
)) {
792 case -ERESTARTNOHAND
:
794 case -ERESTARTNOINTR
:
795 regs
->ax
= regs
->orig_ax
;
799 case -ERESTART_RESTARTBLOCK
:
800 regs
->ax
= NR_restart_syscall
;
807 * If there's no signal to deliver, we just put the saved sigmask
810 restore_saved_sigmask();
814 * notification of userspace execution resumption
815 * - triggered by the TIF_WORK_MASK flags
818 do_notify_resume(struct pt_regs
*regs
, void *unused
, __u32 thread_info_flags
)
822 #ifdef CONFIG_X86_MCE
823 /* notify userspace of pending MCEs */
824 if (thread_info_flags
& _TIF_MCE_NOTIFY
)
825 mce_notify_process();
826 #endif /* CONFIG_X86_64 && CONFIG_X86_MCE */
828 if (thread_info_flags
& _TIF_UPROBE
)
829 uprobe_notify_resume(regs
);
831 /* deal with pending signal delivery */
832 if (thread_info_flags
& _TIF_SIGPENDING
)
835 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
836 clear_thread_flag(TIF_NOTIFY_RESUME
);
837 tracehook_notify_resume(regs
);
839 if (thread_info_flags
& _TIF_USER_RETURN_NOTIFY
)
840 fire_user_return_notifiers();
845 void signal_fault(struct pt_regs
*regs
, void __user
*frame
, char *where
)
847 struct task_struct
*me
= current
;
849 if (show_unhandled_signals
&& printk_ratelimit()) {
851 "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
852 task_pid_nr(current
) > 1 ? KERN_INFO
: KERN_EMERG
,
853 me
->comm
, me
->pid
, where
, frame
,
854 regs
->ip
, regs
->sp
, regs
->orig_ax
);
855 print_vma_addr(" in ", regs
->ip
);
859 force_sig(SIGSEGV
, me
);
862 #ifdef CONFIG_X86_X32_ABI
863 asmlinkage
long sys32_x32_rt_sigreturn(struct pt_regs
*regs
)
865 struct rt_sigframe_x32 __user
*frame
;
868 struct pt_regs tregs
;
870 frame
= (struct rt_sigframe_x32 __user
*)(regs
->sp
- 8);
872 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
874 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
877 set_current_blocked(&set
);
879 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, &ax
))
883 if (sys32_sigaltstack(&frame
->uc
.uc_stack
, NULL
, &tregs
) == -EFAULT
)
889 signal_fault(regs
, frame
, "x32 rt_sigreturn");
This page took 0.050752 seconds and 6 git commands to generate.