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>
46 #define COPY(x) do { \
47 get_user_ex(regs->x, &sc->x); \
50 #define GET_SEG(seg) ({ \
52 get_user_ex(tmp, &sc->seg); \
56 #define COPY_SEG(seg) do { \
57 regs->seg = GET_SEG(seg); \
60 #define COPY_SEG_CPL3(seg) do { \
61 regs->seg = GET_SEG(seg) | 3; \
64 int restore_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
,
68 unsigned int tmpflags
;
71 /* Always make any pending restarted system calls return -EINTR */
72 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
77 set_user_gs(regs
, GET_SEG(gs
));
81 #endif /* CONFIG_X86_32 */
83 COPY(di
); COPY(si
); COPY(bp
); COPY(sp
); COPY(bx
);
84 COPY(dx
); COPY(cx
); COPY(ip
);
95 #endif /* CONFIG_X86_64 */
100 #else /* !CONFIG_X86_32 */
101 /* Kernel saves and restores only the CS segment register on signals,
102 * which is the bare minimum needed to allow mixed 32/64-bit code.
103 * App's signal handler can save/restore other segments if needed. */
105 #endif /* CONFIG_X86_32 */
107 get_user_ex(tmpflags
, &sc
->flags
);
108 regs
->flags
= (regs
->flags
& ~FIX_EFLAGS
) | (tmpflags
& FIX_EFLAGS
);
109 regs
->orig_ax
= -1; /* disable syscall checks */
111 get_user_ex(buf
, &sc
->fpstate
);
113 get_user_ex(*pax
, &sc
->ax
);
114 } get_user_catch(err
);
116 err
|= restore_xstate_sig(buf
, config_enabled(CONFIG_X86_32
));
121 int setup_sigcontext(struct sigcontext __user
*sc
, void __user
*fpstate
,
122 struct pt_regs
*regs
, unsigned long mask
)
129 put_user_ex(get_user_gs(regs
), (unsigned int __user
*)&sc
->gs
);
130 put_user_ex(regs
->fs
, (unsigned int __user
*)&sc
->fs
);
131 put_user_ex(regs
->es
, (unsigned int __user
*)&sc
->es
);
132 put_user_ex(regs
->ds
, (unsigned int __user
*)&sc
->ds
);
133 #endif /* CONFIG_X86_32 */
135 put_user_ex(regs
->di
, &sc
->di
);
136 put_user_ex(regs
->si
, &sc
->si
);
137 put_user_ex(regs
->bp
, &sc
->bp
);
138 put_user_ex(regs
->sp
, &sc
->sp
);
139 put_user_ex(regs
->bx
, &sc
->bx
);
140 put_user_ex(regs
->dx
, &sc
->dx
);
141 put_user_ex(regs
->cx
, &sc
->cx
);
142 put_user_ex(regs
->ax
, &sc
->ax
);
144 put_user_ex(regs
->r8
, &sc
->r8
);
145 put_user_ex(regs
->r9
, &sc
->r9
);
146 put_user_ex(regs
->r10
, &sc
->r10
);
147 put_user_ex(regs
->r11
, &sc
->r11
);
148 put_user_ex(regs
->r12
, &sc
->r12
);
149 put_user_ex(regs
->r13
, &sc
->r13
);
150 put_user_ex(regs
->r14
, &sc
->r14
);
151 put_user_ex(regs
->r15
, &sc
->r15
);
152 #endif /* CONFIG_X86_64 */
154 put_user_ex(current
->thread
.trap_nr
, &sc
->trapno
);
155 put_user_ex(current
->thread
.error_code
, &sc
->err
);
156 put_user_ex(regs
->ip
, &sc
->ip
);
158 put_user_ex(regs
->cs
, (unsigned int __user
*)&sc
->cs
);
159 put_user_ex(regs
->flags
, &sc
->flags
);
160 put_user_ex(regs
->sp
, &sc
->sp_at_signal
);
161 put_user_ex(regs
->ss
, (unsigned int __user
*)&sc
->ss
);
162 #else /* !CONFIG_X86_32 */
163 put_user_ex(regs
->flags
, &sc
->flags
);
164 put_user_ex(regs
->cs
, &sc
->cs
);
165 put_user_ex(0, &sc
->gs
);
166 put_user_ex(0, &sc
->fs
);
167 #endif /* CONFIG_X86_32 */
169 put_user_ex(fpstate
, &sc
->fpstate
);
171 /* non-iBCS2 extensions.. */
172 put_user_ex(mask
, &sc
->oldmask
);
173 put_user_ex(current
->thread
.cr2
, &sc
->cr2
);
174 } put_user_catch(err
);
180 * Set up a signal frame.
184 * Determine which stack to use..
186 static unsigned long align_sigframe(unsigned long sp
)
190 * Align the stack pointer according to the i386 ABI,
191 * i.e. so that on function entry ((sp + 4) & 15) == 0.
193 sp
= ((sp
+ 4) & -16ul) - 4;
194 #else /* !CONFIG_X86_32 */
195 sp
= round_down(sp
, 16) - 8;
200 static inline void __user
*
201 get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
, size_t frame_size
,
202 void __user
**fpstate
)
204 /* Default to using normal stack */
205 unsigned long math_size
= 0;
206 unsigned long sp
= regs
->sp
;
207 unsigned long buf_fx
= 0;
208 int onsigstack
= on_sig_stack(sp
);
211 if (config_enabled(CONFIG_X86_64
))
215 /* This is the X/Open sanctioned signal stack switching. */
216 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
217 if (current
->sas_ss_size
)
218 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
219 } else if (config_enabled(CONFIG_X86_32
) &&
220 (regs
->ss
& 0xffff) != __USER_DS
&&
221 !(ka
->sa
.sa_flags
& SA_RESTORER
) &&
222 ka
->sa
.sa_restorer
) {
223 /* This is the legacy signal stack switching. */
224 sp
= (unsigned long) ka
->sa
.sa_restorer
;
229 sp
= alloc_mathframe(sp
, config_enabled(CONFIG_X86_32
),
230 &buf_fx
, &math_size
);
231 *fpstate
= (void __user
*)sp
;
234 sp
= align_sigframe(sp
- frame_size
);
237 * If we are on the alternate signal stack and would overflow it, don't.
238 * Return an always-bogus address instead so we will die with SIGSEGV.
240 if (onsigstack
&& !likely(on_sig_stack(sp
)))
241 return (void __user
*)-1L;
243 /* save i387 and extended state */
245 save_xstate_sig(*fpstate
, (void __user
*)buf_fx
, math_size
) < 0)
246 return (void __user
*)-1L;
248 return (void __user
*)sp
;
252 static const struct {
256 } __attribute__((packed
)) retcode
= {
257 0xb858, /* popl %eax; movl $..., %eax */
259 0x80cd, /* int $0x80 */
262 static const struct {
267 } __attribute__((packed
)) rt_retcode
= {
268 0xb8, /* movl $..., %eax */
270 0x80cd, /* int $0x80 */
275 __setup_frame(int sig
, struct ksignal
*ksig
, sigset_t
*set
,
276 struct pt_regs
*regs
)
278 struct sigframe __user
*frame
;
279 void __user
*restorer
;
281 void __user
*fpstate
= NULL
;
283 frame
= get_sigframe(&ksig
->ka
, regs
, sizeof(*frame
), &fpstate
);
285 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
288 if (__put_user(sig
, &frame
->sig
))
291 if (setup_sigcontext(&frame
->sc
, fpstate
, regs
, set
->sig
[0]))
294 if (_NSIG_WORDS
> 1) {
295 if (__copy_to_user(&frame
->extramask
, &set
->sig
[1],
296 sizeof(frame
->extramask
)))
300 if (current
->mm
->context
.vdso
)
301 restorer
= current
->mm
->context
.vdso
+
302 selected_vdso32
->sym___kernel_sigreturn
;
304 restorer
= &frame
->retcode
;
305 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
)
306 restorer
= ksig
->ka
.sa
.sa_restorer
;
308 /* Set up to return from userspace. */
309 err
|= __put_user(restorer
, &frame
->pretcode
);
312 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80
314 * WE DO NOT USE IT ANY MORE! It's only left here for historical
315 * reasons and because gdb uses it as a signature to notice
316 * signal handler stack frames.
318 err
|= __put_user(*((u64
*)&retcode
), (u64
*)frame
->retcode
);
323 /* Set up registers for signal handler */
324 regs
->sp
= (unsigned long)frame
;
325 regs
->ip
= (unsigned long)ksig
->ka
.sa
.sa_handler
;
326 regs
->ax
= (unsigned long)sig
;
330 regs
->ds
= __USER_DS
;
331 regs
->es
= __USER_DS
;
332 regs
->ss
= __USER_DS
;
333 regs
->cs
= __USER_CS
;
338 static int __setup_rt_frame(int sig
, struct ksignal
*ksig
,
339 sigset_t
*set
, struct pt_regs
*regs
)
341 struct rt_sigframe __user
*frame
;
342 void __user
*restorer
;
344 void __user
*fpstate
= NULL
;
346 frame
= get_sigframe(&ksig
->ka
, regs
, sizeof(*frame
), &fpstate
);
348 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
352 put_user_ex(sig
, &frame
->sig
);
353 put_user_ex(&frame
->info
, &frame
->pinfo
);
354 put_user_ex(&frame
->uc
, &frame
->puc
);
356 /* Create the ucontext. */
358 put_user_ex(UC_FP_XSTATE
, &frame
->uc
.uc_flags
);
360 put_user_ex(0, &frame
->uc
.uc_flags
);
361 put_user_ex(0, &frame
->uc
.uc_link
);
362 save_altstack_ex(&frame
->uc
.uc_stack
, regs
->sp
);
364 /* Set up to return from userspace. */
365 restorer
= current
->mm
->context
.vdso
+
366 selected_vdso32
->sym___kernel_rt_sigreturn
;
367 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
)
368 restorer
= ksig
->ka
.sa
.sa_restorer
;
369 put_user_ex(restorer
, &frame
->pretcode
);
372 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80
374 * WE DO NOT USE IT ANY MORE! It's only left here for historical
375 * reasons and because gdb uses it as a signature to notice
376 * signal handler stack frames.
378 put_user_ex(*((u64
*)&rt_retcode
), (u64
*)frame
->retcode
);
379 } put_user_catch(err
);
381 err
|= copy_siginfo_to_user(&frame
->info
, &ksig
->info
);
382 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fpstate
,
384 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
389 /* Set up registers for signal handler */
390 regs
->sp
= (unsigned long)frame
;
391 regs
->ip
= (unsigned long)ksig
->ka
.sa
.sa_handler
;
392 regs
->ax
= (unsigned long)sig
;
393 regs
->dx
= (unsigned long)&frame
->info
;
394 regs
->cx
= (unsigned long)&frame
->uc
;
396 regs
->ds
= __USER_DS
;
397 regs
->es
= __USER_DS
;
398 regs
->ss
= __USER_DS
;
399 regs
->cs
= __USER_CS
;
403 #else /* !CONFIG_X86_32 */
404 static int __setup_rt_frame(int sig
, struct ksignal
*ksig
,
405 sigset_t
*set
, struct pt_regs
*regs
)
407 struct rt_sigframe __user
*frame
;
408 void __user
*fp
= NULL
;
411 frame
= get_sigframe(&ksig
->ka
, regs
, sizeof(struct rt_sigframe
), &fp
);
413 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
416 if (ksig
->ka
.sa
.sa_flags
& SA_SIGINFO
) {
417 if (copy_siginfo_to_user(&frame
->info
, &ksig
->info
))
422 /* Create the ucontext. */
424 put_user_ex(UC_FP_XSTATE
, &frame
->uc
.uc_flags
);
426 put_user_ex(0, &frame
->uc
.uc_flags
);
427 put_user_ex(0, &frame
->uc
.uc_link
);
428 save_altstack_ex(&frame
->uc
.uc_stack
, regs
->sp
);
430 /* Set up to return from userspace. If provided, use a stub
431 already in userspace. */
432 /* x86-64 should always use SA_RESTORER. */
433 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
) {
434 put_user_ex(ksig
->ka
.sa
.sa_restorer
, &frame
->pretcode
);
436 /* could use a vstub here */
439 } put_user_catch(err
);
441 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fp
, regs
, set
->sig
[0]);
442 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
447 /* Set up registers for signal handler */
449 /* In case the signal handler was declared without prototypes */
452 /* This also works for non SA_SIGINFO handlers because they expect the
453 next argument after the signal number on the stack. */
454 regs
->si
= (unsigned long)&frame
->info
;
455 regs
->dx
= (unsigned long)&frame
->uc
;
456 regs
->ip
= (unsigned long) ksig
->ka
.sa
.sa_handler
;
458 regs
->sp
= (unsigned long)frame
;
460 /* Set up the CS register to run signal handlers in 64-bit mode,
461 even if the handler happens to be interrupting 32-bit code. */
462 regs
->cs
= __USER_CS
;
466 #endif /* CONFIG_X86_32 */
468 static int x32_setup_rt_frame(struct ksignal
*ksig
,
469 compat_sigset_t
*set
,
470 struct pt_regs
*regs
)
472 #ifdef CONFIG_X86_X32_ABI
473 struct rt_sigframe_x32 __user
*frame
;
474 void __user
*restorer
;
476 void __user
*fpstate
= NULL
;
478 frame
= get_sigframe(&ksig
->ka
, regs
, sizeof(*frame
), &fpstate
);
480 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
483 if (ksig
->ka
.sa
.sa_flags
& SA_SIGINFO
) {
484 if (copy_siginfo_to_user32(&frame
->info
, &ksig
->info
))
489 /* Create the ucontext. */
491 put_user_ex(UC_FP_XSTATE
, &frame
->uc
.uc_flags
);
493 put_user_ex(0, &frame
->uc
.uc_flags
);
494 put_user_ex(0, &frame
->uc
.uc_link
);
495 compat_save_altstack_ex(&frame
->uc
.uc_stack
, regs
->sp
);
496 put_user_ex(0, &frame
->uc
.uc__pad0
);
498 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
) {
499 restorer
= ksig
->ka
.sa
.sa_restorer
;
501 /* could use a vstub here */
505 put_user_ex(restorer
, &frame
->pretcode
);
506 } put_user_catch(err
);
508 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, fpstate
,
510 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
515 /* Set up registers for signal handler */
516 regs
->sp
= (unsigned long) frame
;
517 regs
->ip
= (unsigned long) ksig
->ka
.sa
.sa_handler
;
519 /* We use the x32 calling convention here... */
520 regs
->di
= ksig
->sig
;
521 regs
->si
= (unsigned long) &frame
->info
;
522 regs
->dx
= (unsigned long) &frame
->uc
;
524 loadsegment(ds
, __USER_DS
);
525 loadsegment(es
, __USER_DS
);
527 regs
->cs
= __USER_CS
;
528 regs
->ss
= __USER_DS
;
529 #endif /* CONFIG_X86_X32_ABI */
535 * Do a signal return; undo the signal stack.
538 asmlinkage
unsigned long sys_sigreturn(void)
540 struct pt_regs
*regs
= current_pt_regs();
541 struct sigframe __user
*frame
;
545 frame
= (struct sigframe __user
*)(regs
->sp
- 8);
547 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
549 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
) || (_NSIG_WORDS
> 1
550 && __copy_from_user(&set
.sig
[1], &frame
->extramask
,
551 sizeof(frame
->extramask
))))
554 set_current_blocked(&set
);
556 if (restore_sigcontext(regs
, &frame
->sc
, &ax
))
561 signal_fault(regs
, frame
, "sigreturn");
565 #endif /* CONFIG_X86_32 */
567 asmlinkage
long sys_rt_sigreturn(void)
569 struct pt_regs
*regs
= current_pt_regs();
570 struct rt_sigframe __user
*frame
;
574 frame
= (struct rt_sigframe __user
*)(regs
->sp
- sizeof(long));
575 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
577 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
580 set_current_blocked(&set
);
582 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, &ax
))
585 if (restore_altstack(&frame
->uc
.uc_stack
))
591 signal_fault(regs
, frame
, "rt_sigreturn");
596 * OK, we're invoking a handler:
598 static int signr_convert(int sig
)
601 struct thread_info
*info
= current_thread_info();
603 if (info
->exec_domain
&& info
->exec_domain
->signal_invmap
&& sig
< 32)
604 return info
->exec_domain
->signal_invmap
[sig
];
605 #endif /* CONFIG_X86_32 */
610 setup_rt_frame(struct ksignal
*ksig
, struct pt_regs
*regs
)
612 int usig
= signr_convert(ksig
->sig
);
613 sigset_t
*set
= sigmask_to_save();
614 compat_sigset_t
*cset
= (compat_sigset_t
*) set
;
616 /* Set up the stack frame */
617 if (is_ia32_frame()) {
618 if (ksig
->ka
.sa
.sa_flags
& SA_SIGINFO
)
619 return ia32_setup_rt_frame(usig
, ksig
, cset
, regs
);
621 return ia32_setup_frame(usig
, ksig
, cset
, regs
);
622 } else if (is_x32_frame()) {
623 return x32_setup_rt_frame(ksig
, cset
, regs
);
625 return __setup_rt_frame(ksig
->sig
, ksig
, set
, regs
);
630 handle_signal(struct ksignal
*ksig
, struct pt_regs
*regs
)
633 /* Are we from a system call? */
634 if (syscall_get_nr(current
, regs
) >= 0) {
635 /* If so, check system call restarting.. */
636 switch (syscall_get_error(current
, regs
)) {
637 case -ERESTART_RESTARTBLOCK
:
638 case -ERESTARTNOHAND
:
643 if (!(ksig
->ka
.sa
.sa_flags
& SA_RESTART
)) {
648 case -ERESTARTNOINTR
:
649 regs
->ax
= regs
->orig_ax
;
656 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF
657 * flag so that register information in the sigcontext is correct.
659 if (unlikely(regs
->flags
& X86_EFLAGS_TF
) &&
660 likely(test_and_clear_thread_flag(TIF_FORCED_TF
)))
661 regs
->flags
&= ~X86_EFLAGS_TF
;
663 failed
= (setup_rt_frame(ksig
, regs
) < 0);
666 * Clear the direction flag as per the ABI for function entry.
668 * Clear RF when entering the signal handler, because
669 * it might disable possible debug exception from the
672 * Clear TF when entering the signal handler, but
673 * notify any tracer that was single-stepping it.
674 * The tracer may want to single-step inside the
677 regs
->flags
&= ~(X86_EFLAGS_DF
|X86_EFLAGS_RF
|X86_EFLAGS_TF
);
679 * Ensure the signal handler starts with the new fpu state.
682 drop_init_fpu(current
);
684 signal_setup_done(failed
, ksig
, test_thread_flag(TIF_SINGLESTEP
));
688 #define NR_restart_syscall __NR_restart_syscall
689 #else /* !CONFIG_X86_32 */
690 #define NR_restart_syscall \
691 test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall
692 #endif /* CONFIG_X86_32 */
695 * Note that 'init' is a special process: it doesn't get signals it doesn't
696 * want to handle. Thus you cannot kill init even with a SIGKILL even by
699 static void do_signal(struct pt_regs
*regs
)
703 if (get_signal(&ksig
)) {
704 /* Whee! Actually deliver the signal. */
705 handle_signal(&ksig
, regs
);
709 /* Did we come from a system call? */
710 if (syscall_get_nr(current
, regs
) >= 0) {
711 /* Restart the system call - no handlers present */
712 switch (syscall_get_error(current
, regs
)) {
713 case -ERESTARTNOHAND
:
715 case -ERESTARTNOINTR
:
716 regs
->ax
= regs
->orig_ax
;
720 case -ERESTART_RESTARTBLOCK
:
721 regs
->ax
= NR_restart_syscall
;
728 * If there's no signal to deliver, we just put the saved sigmask
731 restore_saved_sigmask();
735 * notification of userspace execution resumption
736 * - triggered by the TIF_WORK_MASK flags
739 do_notify_resume(struct pt_regs
*regs
, void *unused
, __u32 thread_info_flags
)
743 #ifdef CONFIG_X86_MCE
744 /* notify userspace of pending MCEs */
745 if (thread_info_flags
& _TIF_MCE_NOTIFY
)
746 mce_notify_process();
747 #endif /* CONFIG_X86_64 && CONFIG_X86_MCE */
749 if (thread_info_flags
& _TIF_UPROBE
)
750 uprobe_notify_resume(regs
);
752 /* deal with pending signal delivery */
753 if (thread_info_flags
& _TIF_SIGPENDING
)
756 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
757 clear_thread_flag(TIF_NOTIFY_RESUME
);
758 tracehook_notify_resume(regs
);
760 if (thread_info_flags
& _TIF_USER_RETURN_NOTIFY
)
761 fire_user_return_notifiers();
766 void signal_fault(struct pt_regs
*regs
, void __user
*frame
, char *where
)
768 struct task_struct
*me
= current
;
770 if (show_unhandled_signals
&& printk_ratelimit()) {
772 "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
773 task_pid_nr(current
) > 1 ? KERN_INFO
: KERN_EMERG
,
774 me
->comm
, me
->pid
, where
, frame
,
775 regs
->ip
, regs
->sp
, regs
->orig_ax
);
776 print_vma_addr(" in ", regs
->ip
);
780 force_sig(SIGSEGV
, me
);
783 #ifdef CONFIG_X86_X32_ABI
784 asmlinkage
long sys32_x32_rt_sigreturn(void)
786 struct pt_regs
*regs
= current_pt_regs();
787 struct rt_sigframe_x32 __user
*frame
;
791 frame
= (struct rt_sigframe_x32 __user
*)(regs
->sp
- 8);
793 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
795 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
798 set_current_blocked(&set
);
800 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, &ax
))
803 if (compat_restore_altstack(&frame
->uc
.uc_stack
))
809 signal_fault(regs
, frame
, "x32 rt_sigreturn");