blob: 450fb255f8776fa95bfb04c3a3b7f02319cd129b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 1991, 1992 Linus Torvalds
Hiroshi Shimamotoe5fa2d02008-11-24 18:24:11 -08003 * Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
6 * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes
Hiroshi Shimamotoe5fa2d02008-11-24 18:24:11 -08007 * 2000-2002 x86-64 support by Andi Kleen
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
Ingo Molnar7e907f42008-03-06 10:33:08 +01009#include <linux/sched.h>
Ingo Molnar7e907f42008-03-06 10:33:08 +010010#include <linux/mm.h>
Hiroshi Shimamoto5c9b3a02008-11-21 17:36:41 -080011#include <linux/smp.h>
12#include <linux/kernel.h>
Hiroshi Shimamoto5c9b3a02008-11-21 17:36:41 -080013#include <linux/errno.h>
14#include <linux/wait.h>
Hiroshi Shimamoto5c9b3a02008-11-21 17:36:41 -080015#include <linux/tracehook.h>
16#include <linux/unistd.h>
17#include <linux/stddef.h>
18#include <linux/personality.h>
19#include <linux/uaccess.h>
Avi Kivity7c68af62009-09-19 09:40:22 +030020#include <linux/user-return-notifier.h>
Ingo Molnar7e907f42008-03-06 10:33:08 +010021
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <asm/processor.h>
23#include <asm/ucontext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/i387.h>
Roland McGrath6c3652e2008-01-30 13:30:42 +010025#include <asm/vdso.h>
Andi Kleen4efc0672009-04-28 19:07:31 +020026#include <asm/mce.h>
H. Peter Anvinf28f0c22012-02-19 07:38:43 -080027#include <asm/sighandling.h>
Hiroshi Shimamoto5c9b3a02008-11-21 17:36:41 -080028
29#ifdef CONFIG_X86_64
30#include <asm/proto.h>
31#include <asm/ia32_unistd.h>
Hiroshi Shimamoto5c9b3a02008-11-21 17:36:41 -080032#endif /* CONFIG_X86_64 */
33
Hiroshi Shimamotobb579252008-09-05 16:26:55 -070034#include <asm/syscall.h>
Jaswinder Singhbbc1f692008-07-21 21:34:13 +053035#include <asm/syscalls.h>
Ingo Molnar7e907f42008-03-06 10:33:08 +010036
Hiroshi Shimamoto41af86f2008-12-17 18:50:32 -080037#include <asm/sigframe.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Harvey Harrison1a176802008-02-08 12:09:59 -080039#ifdef CONFIG_X86_32
40# define FIX_EFLAGS (__FIX_EFLAGS | X86_EFLAGS_RF)
41#else
42# define FIX_EFLAGS __FIX_EFLAGS
43#endif
44
Tejun Heod9a89a22009-02-09 22:17:40 +090045#define COPY(x) do { \
46 get_user_ex(regs->x, &sc->x); \
47} while (0)
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080048
Tejun Heod9a89a22009-02-09 22:17:40 +090049#define GET_SEG(seg) ({ \
50 unsigned short tmp; \
51 get_user_ex(tmp, &sc->seg); \
52 tmp; \
53})
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080054
Tejun Heod9a89a22009-02-09 22:17:40 +090055#define COPY_SEG(seg) do { \
56 regs->seg = GET_SEG(seg); \
57} while (0)
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080058
Tejun Heod9a89a22009-02-09 22:17:40 +090059#define COPY_SEG_CPL3(seg) do { \
60 regs->seg = GET_SEG(seg) | 3; \
61} while (0)
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080062
H. Peter Anvin85139422012-02-19 07:43:09 -080063int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
64 unsigned long *pax)
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080065{
66 void __user *buf;
67 unsigned int tmpflags;
68 unsigned int err = 0;
69
70 /* Always make any pending restarted system calls return -EINTR */
71 current_thread_info()->restart_block.fn = do_no_restart_syscall;
72
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -080073 get_user_try {
74
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080075#ifdef CONFIG_X86_32
Tejun Heod9a89a22009-02-09 22:17:40 +090076 set_user_gs(regs, GET_SEG(gs));
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -080077 COPY_SEG(fs);
78 COPY_SEG(es);
79 COPY_SEG(ds);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080080#endif /* CONFIG_X86_32 */
81
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -080082 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
83 COPY(dx); COPY(cx); COPY(ip);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080084
85#ifdef CONFIG_X86_64
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -080086 COPY(r8);
87 COPY(r9);
88 COPY(r10);
89 COPY(r11);
90 COPY(r12);
91 COPY(r13);
92 COPY(r14);
93 COPY(r15);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080094#endif /* CONFIG_X86_64 */
95
96#ifdef CONFIG_X86_32
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -080097 COPY_SEG_CPL3(cs);
98 COPY_SEG_CPL3(ss);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -080099#else /* !CONFIG_X86_32 */
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800100 /* Kernel saves and restores only the CS segment register on signals,
101 * which is the bare minimum needed to allow mixed 32/64-bit code.
102 * App's signal handler can save/restore other segments if needed. */
103 COPY_SEG_CPL3(cs);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800104#endif /* CONFIG_X86_32 */
105
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800106 get_user_ex(tmpflags, &sc->flags);
107 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
108 regs->orig_ax = -1; /* disable syscall checks */
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800109
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800110 get_user_ex(buf, &sc->fpstate);
111 err |= restore_i387_xstate(buf);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800112
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800113 get_user_ex(*pax, &sc->ax);
114 } get_user_catch(err);
115
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800116 return err;
117}
118
H. Peter Anvin85139422012-02-19 07:43:09 -0800119int setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate,
120 struct pt_regs *regs, unsigned long mask)
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800121{
122 int err = 0;
123
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800124 put_user_try {
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800125
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800126#ifdef CONFIG_X86_32
Tejun Heod9a89a22009-02-09 22:17:40 +0900127 put_user_ex(get_user_gs(regs), (unsigned int __user *)&sc->gs);
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800128 put_user_ex(regs->fs, (unsigned int __user *)&sc->fs);
129 put_user_ex(regs->es, (unsigned int __user *)&sc->es);
130 put_user_ex(regs->ds, (unsigned int __user *)&sc->ds);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800131#endif /* CONFIG_X86_32 */
132
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800133 put_user_ex(regs->di, &sc->di);
134 put_user_ex(regs->si, &sc->si);
135 put_user_ex(regs->bp, &sc->bp);
136 put_user_ex(regs->sp, &sc->sp);
137 put_user_ex(regs->bx, &sc->bx);
138 put_user_ex(regs->dx, &sc->dx);
139 put_user_ex(regs->cx, &sc->cx);
140 put_user_ex(regs->ax, &sc->ax);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800141#ifdef CONFIG_X86_64
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800142 put_user_ex(regs->r8, &sc->r8);
143 put_user_ex(regs->r9, &sc->r9);
144 put_user_ex(regs->r10, &sc->r10);
145 put_user_ex(regs->r11, &sc->r11);
146 put_user_ex(regs->r12, &sc->r12);
147 put_user_ex(regs->r13, &sc->r13);
148 put_user_ex(regs->r14, &sc->r14);
149 put_user_ex(regs->r15, &sc->r15);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800150#endif /* CONFIG_X86_64 */
151
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800152 put_user_ex(current->thread.trap_no, &sc->trapno);
153 put_user_ex(current->thread.error_code, &sc->err);
154 put_user_ex(regs->ip, &sc->ip);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800155#ifdef CONFIG_X86_32
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800156 put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
157 put_user_ex(regs->flags, &sc->flags);
158 put_user_ex(regs->sp, &sc->sp_at_signal);
159 put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800160#else /* !CONFIG_X86_32 */
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800161 put_user_ex(regs->flags, &sc->flags);
162 put_user_ex(regs->cs, &sc->cs);
163 put_user_ex(0, &sc->gs);
164 put_user_ex(0, &sc->fs);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800165#endif /* CONFIG_X86_32 */
166
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800167 put_user_ex(fpstate, &sc->fpstate);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800168
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800169 /* non-iBCS2 extensions.. */
170 put_user_ex(mask, &sc->oldmask);
171 put_user_ex(current->thread.cr2, &sc->cr2);
172 } put_user_catch(err);
Hiroshi Shimamoto26016572008-11-24 18:21:37 -0800173
174 return err;
175}
176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 * Set up a signal frame.
179 */
Hiroshi Shimamoto75779f02009-02-27 10:29:57 -0800180
181/*
182 * Determine which stack to use..
183 */
Hiroshi Shimamoto1fae0272009-02-27 10:30:32 -0800184static unsigned long align_sigframe(unsigned long sp)
185{
186#ifdef CONFIG_X86_32
187 /*
188 * Align the stack pointer according to the i386 ABI,
189 * i.e. so that on function entry ((sp + 4) & 15) == 0.
190 */
191 sp = ((sp + 4) & -16ul) - 4;
192#else /* !CONFIG_X86_32 */
193 sp = round_down(sp, 16) - 8;
194#endif
195 return sp;
196}
197
Hiroshi Shimamoto75779f02009-02-27 10:29:57 -0800198static inline void __user *
199get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size,
200 void __user **fpstate)
201{
202 /* Default to using normal stack */
203 unsigned long sp = regs->sp;
Hiroshi Shimamoto14fc9fb2009-03-19 10:56:29 -0700204 int onsigstack = on_sig_stack(sp);
Hiroshi Shimamoto75779f02009-02-27 10:29:57 -0800205
206#ifdef CONFIG_X86_64
207 /* redzone */
208 sp -= 128;
209#endif /* CONFIG_X86_64 */
210
Hiroshi Shimamoto14fc9fb2009-03-19 10:56:29 -0700211 if (!onsigstack) {
212 /* This is the X/Open sanctioned signal stack switching. */
213 if (ka->sa.sa_flags & SA_ONSTACK) {
Hiroshi Shimamoto0f8f3082009-03-26 10:03:08 -0700214 if (current->sas_ss_size)
Hiroshi Shimamoto14fc9fb2009-03-19 10:56:29 -0700215 sp = current->sas_ss_sp + current->sas_ss_size;
216 } else {
Hiroshi Shimamoto75779f02009-02-27 10:29:57 -0800217#ifdef CONFIG_X86_32
Hiroshi Shimamoto14fc9fb2009-03-19 10:56:29 -0700218 /* This is the legacy signal stack switching. */
219 if ((regs->ss & 0xffff) != __USER_DS &&
220 !(ka->sa.sa_flags & SA_RESTORER) &&
221 ka->sa.sa_restorer)
222 sp = (unsigned long) ka->sa.sa_restorer;
Hiroshi Shimamoto75779f02009-02-27 10:29:57 -0800223#endif /* CONFIG_X86_32 */
Hiroshi Shimamoto14fc9fb2009-03-19 10:56:29 -0700224 }
Hiroshi Shimamoto75779f02009-02-27 10:29:57 -0800225 }
226
227 if (used_math()) {
228 sp -= sig_xstate_size;
Hiroshi Shimamoto25051702009-03-02 17:20:01 -0800229#ifdef CONFIG_X86_64
230 sp = round_down(sp, 64);
231#endif /* CONFIG_X86_64 */
232 *fpstate = (void __user *)sp;
Hiroshi Shimamoto75779f02009-02-27 10:29:57 -0800233 }
234
Hiroshi Shimamoto14fc9fb2009-03-19 10:56:29 -0700235 sp = align_sigframe(sp - frame_size);
236
237 /*
238 * If we are on the alternate signal stack and would overflow it, don't.
239 * Return an always-bogus address instead so we will die with SIGSEGV.
240 */
241 if (onsigstack && !likely(on_sig_stack(sp)))
242 return (void __user *)-1L;
243
244 /* save i387 state */
245 if (used_math() && save_i387_xstate(*fpstate) < 0)
246 return (void __user *)-1L;
247
248 return (void __user *)sp;
Hiroshi Shimamoto75779f02009-02-27 10:29:57 -0800249}
250
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800251#ifdef CONFIG_X86_32
252static const struct {
253 u16 poplmovl;
254 u32 val;
255 u16 int80;
256} __attribute__((packed)) retcode = {
257 0xb858, /* popl %eax; movl $..., %eax */
258 __NR_sigreturn,
259 0x80cd, /* int $0x80 */
260};
261
262static const struct {
263 u8 movl;
264 u32 val;
265 u16 int80;
266 u8 pad;
267} __attribute__((packed)) rt_retcode = {
268 0xb8, /* movl $..., %eax */
269 __NR_rt_sigreturn,
270 0x80cd, /* int $0x80 */
271 0
272};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Ingo Molnar7e907f42008-03-06 10:33:08 +0100274static int
Hiroshi Shimamoto1d130242008-09-05 16:28:06 -0700275__setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
276 struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 struct sigframe __user *frame;
Ingo Molnar7e907f42008-03-06 10:33:08 +0100279 void __user *restorer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 int err = 0;
Suresh Siddhaab513702008-07-29 10:29:22 -0700281 void __user *fpstate = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Suresh Siddha3c1c7f12008-07-29 10:29:21 -0700283 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
Hiroshi Shimamoto3d0aedd2008-09-12 17:01:09 -0700286 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Hiroshi Shimamoto2ba48e12008-09-12 17:02:53 -0700288 if (__put_user(sig, &frame->sig))
Hiroshi Shimamoto3d0aedd2008-09-12 17:01:09 -0700289 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Hiroshi Shimamoto2ba48e12008-09-12 17:02:53 -0700291 if (setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
Hiroshi Shimamoto3d0aedd2008-09-12 17:01:09 -0700292 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 if (_NSIG_WORDS > 1) {
Hiroshi Shimamoto2ba48e12008-09-12 17:02:53 -0700295 if (__copy_to_user(&frame->extramask, &set->sig[1],
296 sizeof(frame->extramask)))
Hiroshi Shimamoto3d0aedd2008-09-12 17:01:09 -0700297 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 }
299
Roland McGrath1a3e4ca2008-04-09 01:29:27 -0700300 if (current->mm->context.vdso)
Roland McGrath6c3652e2008-01-30 13:30:42 +0100301 restorer = VDSO32_SYMBOL(current->mm->context.vdso, sigreturn);
Andi Kleen9fbbd4d2007-02-13 13:26:26 +0100302 else
Jan Engelhardtade1af72008-01-30 13:33:23 +0100303 restorer = &frame->retcode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 if (ka->sa.sa_flags & SA_RESTORER)
305 restorer = ka->sa.sa_restorer;
306
307 /* Set up to return from userspace. */
308 err |= __put_user(restorer, &frame->pretcode);
Ingo Molnar7e907f42008-03-06 10:33:08 +0100309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 /*
Ingo Molnar7e907f42008-03-06 10:33:08 +0100311 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 *
313 * WE DO NOT USE IT ANY MORE! It's only left here for historical
314 * reasons and because gdb uses it as a signature to notice
315 * signal handler stack frames.
316 */
Hiroshi Shimamoto4a612042008-11-11 19:09:29 -0800317 err |= __put_user(*((u64 *)&retcode), (u64 *)frame->retcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
319 if (err)
Hiroshi Shimamoto3d0aedd2008-09-12 17:01:09 -0700320 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322 /* Set up registers for signal handler */
Ingo Molnar7e907f42008-03-06 10:33:08 +0100323 regs->sp = (unsigned long)frame;
324 regs->ip = (unsigned long)ka->sa.sa_handler;
325 regs->ax = (unsigned long)sig;
Harvey Harrison92bc2052008-02-08 12:09:56 -0800326 regs->dx = 0;
327 regs->cx = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100329 regs->ds = __USER_DS;
330 regs->es = __USER_DS;
331 regs->ss = __USER_DS;
332 regs->cs = __USER_CS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
David Howells283828f2006-01-18 17:44:00 -0800334 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335}
336
Hiroshi Shimamoto1d130242008-09-05 16:28:06 -0700337static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
338 sigset_t *set, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 struct rt_sigframe __user *frame;
Ingo Molnar7e907f42008-03-06 10:33:08 +0100341 void __user *restorer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 int err = 0;
Suresh Siddhaab513702008-07-29 10:29:22 -0700343 void __user *fpstate = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Suresh Siddha3c1c7f12008-07-29 10:29:21 -0700345 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
Hiroshi Shimamoto3d0aedd2008-09-12 17:01:09 -0700348 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800350 put_user_try {
351 put_user_ex(sig, &frame->sig);
352 put_user_ex(&frame->info, &frame->pinfo);
353 put_user_ex(&frame->uc, &frame->puc);
354 err |= copy_siginfo_to_user(&frame->info, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800356 /* Create the ucontext. */
357 if (cpu_has_xsave)
358 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
359 else
360 put_user_ex(0, &frame->uc.uc_flags);
361 put_user_ex(0, &frame->uc.uc_link);
362 put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
363 put_user_ex(sas_ss_flags(regs->sp),
364 &frame->uc.uc_stack.ss_flags);
365 put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
366 err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
367 regs, set->sig[0]);
368 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800370 /* Set up to return from userspace. */
371 restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn);
372 if (ka->sa.sa_flags & SA_RESTORER)
373 restorer = ka->sa.sa_restorer;
374 put_user_ex(restorer, &frame->pretcode);
Ingo Molnar7e907f42008-03-06 10:33:08 +0100375
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800376 /*
377 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80
378 *
379 * WE DO NOT USE IT ANY MORE! It's only left here for historical
380 * reasons and because gdb uses it as a signature to notice
381 * signal handler stack frames.
382 */
383 put_user_ex(*((u64 *)&rt_retcode), (u64 *)frame->retcode);
384 } put_user_catch(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
386 if (err)
Hiroshi Shimamoto3d0aedd2008-09-12 17:01:09 -0700387 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389 /* Set up registers for signal handler */
Ingo Molnar7e907f42008-03-06 10:33:08 +0100390 regs->sp = (unsigned long)frame;
391 regs->ip = (unsigned long)ka->sa.sa_handler;
Hiroshi Shimamoto13ad7722008-09-05 16:28:38 -0700392 regs->ax = (unsigned long)sig;
Ingo Molnar7e907f42008-03-06 10:33:08 +0100393 regs->dx = (unsigned long)&frame->info;
394 regs->cx = (unsigned long)&frame->uc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100396 regs->ds = __USER_DS;
397 regs->es = __USER_DS;
398 regs->ss = __USER_DS;
399 regs->cs = __USER_CS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
David Howells283828f2006-01-18 17:44:00 -0800401 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402}
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800403#else /* !CONFIG_X86_32 */
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800404static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
405 sigset_t *set, struct pt_regs *regs)
406{
407 struct rt_sigframe __user *frame;
408 void __user *fp = NULL;
409 int err = 0;
410 struct task_struct *me = current;
411
Hiroshi Shimamoto97286a22009-02-27 10:28:48 -0800412 frame = get_sigframe(ka, regs, sizeof(struct rt_sigframe), &fp);
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800413
414 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
415 return -EFAULT;
416
417 if (ka->sa.sa_flags & SA_SIGINFO) {
418 if (copy_siginfo_to_user(&frame->info, info))
419 return -EFAULT;
420 }
421
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800422 put_user_try {
423 /* Create the ucontext. */
424 if (cpu_has_xsave)
425 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
426 else
427 put_user_ex(0, &frame->uc.uc_flags);
428 put_user_ex(0, &frame->uc.uc_link);
429 put_user_ex(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
430 put_user_ex(sas_ss_flags(regs->sp),
431 &frame->uc.uc_stack.ss_flags);
432 put_user_ex(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
433 err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]);
434 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800435
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800436 /* Set up to return from userspace. If provided, use a stub
437 already in userspace. */
438 /* x86-64 should always use SA_RESTORER. */
439 if (ka->sa.sa_flags & SA_RESTORER) {
440 put_user_ex(ka->sa.sa_restorer, &frame->pretcode);
441 } else {
442 /* could use a vstub here */
443 err |= -EFAULT;
444 }
445 } put_user_catch(err);
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800446
447 if (err)
448 return -EFAULT;
449
450 /* Set up registers for signal handler */
451 regs->di = sig;
452 /* In case the signal handler was declared without prototypes */
453 regs->ax = 0;
454
455 /* This also works for non SA_SIGINFO handlers because they expect the
456 next argument after the signal number on the stack. */
457 regs->si = (unsigned long)&frame->info;
458 regs->dx = (unsigned long)&frame->uc;
459 regs->ip = (unsigned long) ka->sa.sa_handler;
460
461 regs->sp = (unsigned long)frame;
462
463 /* Set up the CS register to run signal handlers in 64-bit mode,
464 even if the handler happens to be interrupting 32-bit code. */
465 regs->cs = __USER_CS;
466
467 return 0;
468}
469#endif /* CONFIG_X86_32 */
470
Hiroshi Shimamotoe5fa2d02008-11-24 18:24:11 -0800471#ifdef CONFIG_X86_32
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800472/*
473 * Atomically swap in the new signal mask, and wait for a signal.
474 */
475asmlinkage int
476sys_sigsuspend(int history0, int history1, old_sigset_t mask)
477{
Oleg Nesterov39822942011-07-10 21:27:27 +0200478 sigset_t blocked;
479
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800480 current->saved_sigmask = current->blocked;
Oleg Nesterov39822942011-07-10 21:27:27 +0200481
482 mask &= _BLOCKABLE;
483 siginitset(&blocked, mask);
484 set_current_blocked(&blocked);
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800485
486 current->state = TASK_INTERRUPTIBLE;
487 schedule();
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800488
Oleg Nesterov39822942011-07-10 21:27:27 +0200489 set_restore_sigmask();
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800490 return -ERESTARTNOHAND;
491}
492
493asmlinkage int
494sys_sigaction(int sig, const struct old_sigaction __user *act,
495 struct old_sigaction __user *oact)
496{
497 struct k_sigaction new_ka, old_ka;
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800498 int ret = 0;
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800499
500 if (act) {
501 old_sigset_t mask;
502
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800503 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800504 return -EFAULT;
505
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800506 get_user_try {
507 get_user_ex(new_ka.sa.sa_handler, &act->sa_handler);
508 get_user_ex(new_ka.sa.sa_flags, &act->sa_flags);
509 get_user_ex(mask, &act->sa_mask);
510 get_user_ex(new_ka.sa.sa_restorer, &act->sa_restorer);
511 } get_user_catch(ret);
512
513 if (ret)
514 return -EFAULT;
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800515 siginitset(&new_ka.sa.sa_mask, mask);
516 }
517
518 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
519
520 if (!ret && oact) {
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800521 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800522 return -EFAULT;
523
Hiroshi Shimamoto98e3d452009-01-23 15:50:10 -0800524 put_user_try {
525 put_user_ex(old_ka.sa.sa_handler, &oact->sa_handler);
526 put_user_ex(old_ka.sa.sa_flags, &oact->sa_flags);
527 put_user_ex(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
528 put_user_ex(old_ka.sa.sa_restorer, &oact->sa_restorer);
529 } put_user_catch(ret);
530
531 if (ret)
532 return -EFAULT;
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800533 }
534
535 return ret;
536}
Hiroshi Shimamotoe5fa2d02008-11-24 18:24:11 -0800537#endif /* CONFIG_X86_32 */
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800538
Brian Gerst052acad2009-12-09 19:01:54 -0500539long
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800540sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
541 struct pt_regs *regs)
542{
543 return do_sigaltstack(uss, uoss, regs->sp);
544}
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800545
546/*
547 * Do a signal return; undo the signal stack.
548 */
Hiroshi Shimamotoe5fa2d02008-11-24 18:24:11 -0800549#ifdef CONFIG_X86_32
Brian Gerstb12bdaf2009-02-11 16:43:58 -0500550unsigned long sys_sigreturn(struct pt_regs *regs)
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800551{
552 struct sigframe __user *frame;
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800553 unsigned long ax;
554 sigset_t set;
555
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800556 frame = (struct sigframe __user *)(regs->sp - 8);
557
558 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
559 goto badframe;
560 if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1
561 && __copy_from_user(&set.sig[1], &frame->extramask,
562 sizeof(frame->extramask))))
563 goto badframe;
564
565 sigdelsetmask(&set, ~_BLOCKABLE);
Oleg Nesterov39822942011-07-10 21:27:27 +0200566 set_current_blocked(&set);
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800567
568 if (restore_sigcontext(regs, &frame->sc, &ax))
569 goto badframe;
570 return ax;
571
572badframe:
Hiroshi Shimamotoae417bb2008-12-16 14:02:16 -0800573 signal_fault(regs, frame, "sigreturn");
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800574
575 return 0;
576}
Hiroshi Shimamotoe5fa2d02008-11-24 18:24:11 -0800577#endif /* CONFIG_X86_32 */
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800578
H. Peter Anvin74452502009-02-11 16:31:40 -0800579long sys_rt_sigreturn(struct pt_regs *regs)
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800580{
581 struct rt_sigframe __user *frame;
582 unsigned long ax;
583 sigset_t set;
584
585 frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));
586 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
587 goto badframe;
588 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
589 goto badframe;
590
591 sigdelsetmask(&set, ~_BLOCKABLE);
Oleg Nesterove9bd3f02011-04-27 21:09:39 +0200592 set_current_blocked(&set);
Hiroshi Shimamotobfeb91a2008-11-24 18:23:12 -0800593
594 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
595 goto badframe;
596
597 if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT)
598 goto badframe;
599
600 return ax;
601
602badframe:
603 signal_fault(regs, frame, "rt_sigreturn");
604 return 0;
605}
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607/*
Ingo Molnar7e907f42008-03-06 10:33:08 +0100608 * OK, we're invoking a handler:
609 */
Hiroshi Shimamoto8d8c13b2008-09-24 19:10:29 -0700610static int signr_convert(int sig)
611{
Hiroshi Shimamoto96bf84b2008-10-29 18:44:08 -0700612#ifdef CONFIG_X86_32
Hiroshi Shimamoto8d8c13b2008-09-24 19:10:29 -0700613 struct thread_info *info = current_thread_info();
614
615 if (info->exec_domain && info->exec_domain->signal_invmap && sig < 32)
616 return info->exec_domain->signal_invmap[sig];
Hiroshi Shimamoto96bf84b2008-10-29 18:44:08 -0700617#endif /* CONFIG_X86_32 */
Hiroshi Shimamoto8d8c13b2008-09-24 19:10:29 -0700618 return sig;
619}
620
Hiroshi Shimamotocabf5032008-10-29 18:46:07 -0700621#ifdef CONFIG_X86_32
622
Hiroshi Shimamoto455edbc2008-09-24 19:13:11 -0700623#define is_ia32 1
Hiroshi Shimamoto4694d232008-09-24 19:13:29 -0700624#define ia32_setup_frame __setup_frame
625#define ia32_setup_rt_frame __setup_rt_frame
Hiroshi Shimamoto455edbc2008-09-24 19:13:11 -0700626
Hiroshi Shimamotocabf5032008-10-29 18:46:07 -0700627#else /* !CONFIG_X86_32 */
628
629#ifdef CONFIG_IA32_EMULATION
630#define is_ia32 test_thread_flag(TIF_IA32)
631#else /* !CONFIG_IA32_EMULATION */
632#define is_ia32 0
633#endif /* CONFIG_IA32_EMULATION */
634
Hiroshi Shimamotof5223762008-12-17 18:47:17 -0800635int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
636 sigset_t *set, struct pt_regs *regs);
637int ia32_setup_frame(int sig, struct k_sigaction *ka,
638 sigset_t *set, struct pt_regs *regs);
639
Hiroshi Shimamotocabf5032008-10-29 18:46:07 -0700640#endif /* CONFIG_X86_32 */
641
Roland McGrath7c1def12005-06-23 00:08:21 -0700642static int
Hiroshi Shimamoto1d130242008-09-05 16:28:06 -0700643setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
Oleg Nesterov9b429622011-07-10 20:22:03 +0200644 struct pt_regs *regs)
Hiroshi Shimamoto1d130242008-09-05 16:28:06 -0700645{
Hiroshi Shimamoto8d8c13b2008-09-24 19:10:29 -0700646 int usig = signr_convert(sig);
Oleg Nesterov9b429622011-07-10 20:22:03 +0200647 sigset_t *set = &current->blocked;
Hiroshi Shimamoto1d130242008-09-05 16:28:06 -0700648 int ret;
649
Oleg Nesterov9b429622011-07-10 20:22:03 +0200650 if (current_thread_info()->status & TS_RESTORE_SIGMASK)
651 set = &current->saved_sigmask;
652
Hiroshi Shimamoto1d130242008-09-05 16:28:06 -0700653 /* Set up the stack frame */
Hiroshi Shimamoto455edbc2008-09-24 19:13:11 -0700654 if (is_ia32) {
655 if (ka->sa.sa_flags & SA_SIGINFO)
Hiroshi Shimamoto4694d232008-09-24 19:13:29 -0700656 ret = ia32_setup_rt_frame(usig, ka, info, set, regs);
Hiroshi Shimamoto455edbc2008-09-24 19:13:11 -0700657 else
Hiroshi Shimamoto4694d232008-09-24 19:13:29 -0700658 ret = ia32_setup_frame(usig, ka, set, regs);
Hiroshi Shimamoto455edbc2008-09-24 19:13:11 -0700659 } else
660 ret = __setup_rt_frame(sig, ka, info, set, regs);
Hiroshi Shimamoto1d130242008-09-05 16:28:06 -0700661
Hiroshi Shimamoto3d0aedd2008-09-12 17:01:09 -0700662 if (ret) {
663 force_sigsegv(sig, current);
664 return -EFAULT;
665 }
666
Oleg Nesterov9b429622011-07-10 20:22:03 +0200667 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
Hiroshi Shimamoto1d130242008-09-05 16:28:06 -0700668 return ret;
669}
670
671static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
Oleg Nesterov9b429622011-07-10 20:22:03 +0200673 struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674{
Roland McGrath7c1def12005-06-23 00:08:21 -0700675 int ret;
676
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 /* Are we from a system call? */
Hiroshi Shimamotobb579252008-09-05 16:26:55 -0700678 if (syscall_get_nr(current, regs) >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 /* If so, check system call restarting.. */
Hiroshi Shimamotobb579252008-09-05 16:26:55 -0700680 switch (syscall_get_error(current, regs)) {
Harvey Harrisonac66f3f2008-02-08 12:09:58 -0800681 case -ERESTART_RESTARTBLOCK:
682 case -ERESTARTNOHAND:
683 regs->ax = -EINTR;
684 break;
685
686 case -ERESTARTSYS:
687 if (!(ka->sa.sa_flags & SA_RESTART)) {
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100688 regs->ax = -EINTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 break;
Harvey Harrisonac66f3f2008-02-08 12:09:58 -0800690 }
691 /* fallthrough */
692 case -ERESTARTNOINTR:
693 regs->ax = regs->orig_ax;
694 regs->ip -= 2;
695 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
697 }
698
699 /*
Roland McGrathe1f28772008-01-30 13:30:50 +0100700 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF
701 * flag so that register information in the sigcontext is correct.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 */
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100703 if (unlikely(regs->flags & X86_EFLAGS_TF) &&
Roland McGrathe1f28772008-01-30 13:30:50 +0100704 likely(test_and_clear_thread_flag(TIF_FORCED_TF)))
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100705 regs->flags &= ~X86_EFLAGS_TF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
Oleg Nesterov9b429622011-07-10 20:22:03 +0200707 ret = setup_rt_frame(sig, ka, info, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Ingo Molnar7e907f42008-03-06 10:33:08 +0100709 if (ret)
710 return ret;
Roland McGrath7c1def12005-06-23 00:08:21 -0700711
Roland McGrath8b9c5ff2008-04-19 14:26:54 -0700712 /*
713 * Clear the direction flag as per the ABI for function entry.
714 */
715 regs->flags &= ~X86_EFLAGS_DF;
716
717 /*
718 * Clear TF when entering the signal handler, but
719 * notify any tracer that was single-stepping it.
720 * The tracer may want to single-step inside the
721 * handler too.
722 */
723 regs->flags &= ~X86_EFLAGS_TF;
Roland McGrath8b9c5ff2008-04-19 14:26:54 -0700724
Matt Fleming5e6292c2012-01-10 15:11:17 -0800725 block_sigmask(ka, sig);
Ingo Molnar7e907f42008-03-06 10:33:08 +0100726
Roland McGrath36a03302008-03-14 17:46:38 -0700727 tracehook_signal_handler(sig, info, ka, regs,
728 test_thread_flag(TIF_SINGLESTEP));
729
Ingo Molnar7e907f42008-03-06 10:33:08 +0100730 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731}
732
Hiroshi Shimamoto57917752008-10-29 18:46:40 -0700733#ifdef CONFIG_X86_32
Hiroshi Shimamoto8fcd8e22008-09-05 16:27:39 -0700734#define NR_restart_syscall __NR_restart_syscall
Hiroshi Shimamoto57917752008-10-29 18:46:40 -0700735#else /* !CONFIG_X86_32 */
736#define NR_restart_syscall \
737 test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall
738#endif /* CONFIG_X86_32 */
739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740/*
741 * Note that 'init' is a special process: it doesn't get signals it doesn't
742 * want to handle. Thus you cannot kill init even with a SIGKILL even by
743 * mistake.
744 */
Harvey Harrison75604d72008-01-30 13:31:17 +0100745static void do_signal(struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
Harvey Harrisonac66f3f2008-02-08 12:09:58 -0800747 struct k_sigaction ka;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 siginfo_t info;
749 int signr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 /*
Harvey Harrisonac66f3f2008-02-08 12:09:58 -0800752 * We want the common case to go fast, which is why we may in certain
753 * cases get here from kernel mode. Just return without doing anything
754 * if so.
755 * X86_32: vm86 regs switched out by assembly code before reaching
756 * here, so testing against kernel CS suffices.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 */
Vincent Hanquez717b5942005-06-23 00:08:45 -0700758 if (!user_mode(regs))
David Howells283828f2006-01-18 17:44:00 -0800759 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
762 if (signr > 0) {
Ingo Molnar7e907f42008-03-06 10:33:08 +0100763 /* Whee! Actually deliver the signal. */
Oleg Nesterov9b429622011-07-10 20:22:03 +0200764 handle_signal(signr, &info, &ka, regs);
David Howells283828f2006-01-18 17:44:00 -0800765 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 }
767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 /* Did we come from a system call? */
Hiroshi Shimamotobb579252008-09-05 16:26:55 -0700769 if (syscall_get_nr(current, regs) >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 /* Restart the system call - no handlers present */
Hiroshi Shimamotobb579252008-09-05 16:26:55 -0700771 switch (syscall_get_error(current, regs)) {
David Howells283828f2006-01-18 17:44:00 -0800772 case -ERESTARTNOHAND:
773 case -ERESTARTSYS:
774 case -ERESTARTNOINTR:
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100775 regs->ax = regs->orig_ax;
776 regs->ip -= 2;
David Howells283828f2006-01-18 17:44:00 -0800777 break;
778
779 case -ERESTART_RESTARTBLOCK:
Hiroshi Shimamoto8fcd8e22008-09-05 16:27:39 -0700780 regs->ax = NR_restart_syscall;
H. Peter Anvin65ea5b02008-01-30 13:30:56 +0100781 regs->ip -= 2;
David Howells283828f2006-01-18 17:44:00 -0800782 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 }
784 }
David Howells283828f2006-01-18 17:44:00 -0800785
Harvey Harrisonac66f3f2008-02-08 12:09:58 -0800786 /*
787 * If there's no signal to deliver, we just put the saved sigmask
788 * back.
789 */
Roland McGrath5a8da0e2008-04-30 00:53:10 -0700790 if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
791 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
Oleg Nesterov9b429622011-07-10 20:22:03 +0200792 set_current_blocked(&current->saved_sigmask);
David Howells283828f2006-01-18 17:44:00 -0800793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794}
795
796/*
797 * notification of userspace execution resumption
David Howells283828f2006-01-18 17:44:00 -0800798 * - triggered by the TIF_WORK_MASK flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 */
Ingo Molnar7e907f42008-03-06 10:33:08 +0100800void
801do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
Andi Kleenc1ebf832009-07-09 00:31:41 +0200803#ifdef CONFIG_X86_MCE
Hiroshi Shimamotoee847c52008-09-23 17:21:45 -0700804 /* notify userspace of pending MCEs */
805 if (thread_info_flags & _TIF_MCE_NOTIFY)
Andi Kleen9b1beaf2009-05-27 21:56:59 +0200806 mce_notify_process();
Hiroshi Shimamotoee847c52008-09-23 17:21:45 -0700807#endif /* CONFIG_X86_64 && CONFIG_X86_MCE */
808
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 /* deal with pending signal delivery */
Roland McGrath5a8da0e2008-04-30 00:53:10 -0700810 if (thread_info_flags & _TIF_SIGPENDING)
David Howells283828f2006-01-18 17:44:00 -0800811 do_signal(regs);
Peter Zijlstra8f4d37e2008-01-25 21:08:29 +0100812
Roland McGrath59e52132008-04-19 19:10:57 -0700813 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
814 clear_thread_flag(TIF_NOTIFY_RESUME);
815 tracehook_notify_resume(regs);
David Howellsee18d642009-09-02 09:14:21 +0100816 if (current->replacement_session_keyring)
817 key_replace_session_keyring();
Roland McGrath59e52132008-04-19 19:10:57 -0700818 }
Avi Kivity7c68af62009-09-19 09:40:22 +0300819 if (thread_info_flags & _TIF_USER_RETURN_NOTIFY)
820 fire_user_return_notifiers();
Roland McGrath59e52132008-04-19 19:10:57 -0700821
Hiroshi Shimamotoee847c52008-09-23 17:21:45 -0700822#ifdef CONFIG_X86_32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 clear_thread_flag(TIF_IRET);
Hiroshi Shimamotoee847c52008-09-23 17:21:45 -0700824#endif /* CONFIG_X86_32 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825}
Hiroshi Shimamoto72fa50f2008-09-05 16:27:11 -0700826
827void signal_fault(struct pt_regs *regs, void __user *frame, char *where)
828{
829 struct task_struct *me = current;
830
831 if (show_unhandled_signals && printk_ratelimit()) {
Hiroshi Shimamotoae417bb2008-12-16 14:02:16 -0800832 printk("%s"
Hiroshi Shimamoto72fa50f2008-09-05 16:27:11 -0700833 "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
Hiroshi Shimamotoae417bb2008-12-16 14:02:16 -0800834 task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG,
Hiroshi Shimamoto72fa50f2008-09-05 16:27:11 -0700835 me->comm, me->pid, where, frame,
836 regs->ip, regs->sp, regs->orig_ax);
837 print_vma_addr(" in ", regs->ip);
838 printk(KERN_CONT "\n");
839 }
840
841 force_sig(SIGSEGV, me);
842}