Merge remote-tracking branch 'origin/dev/sumit-linux-3.10.96' into TOT-merge
[linux-3.10.git] / arch / x86 / kernel / signal.c
1 /*
2  *  Copyright (C) 1991, 1992  Linus Torvalds
3  *  Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
4  *
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
8  */
9
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12 #include <linux/sched.h>
13 #include <linux/mm.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>
26
27 #include <asm/processor.h>
28 #include <asm/ucontext.h>
29 #include <asm/i387.h>
30 #include <asm/fpu-internal.h>
31 #include <asm/vdso.h>
32 #include <asm/mce.h>
33 #include <asm/sighandling.h>
34
35 #ifdef CONFIG_X86_64
36 #include <asm/proto.h>
37 #include <asm/ia32_unistd.h>
38 #include <asm/sys_ia32.h>
39 #endif /* CONFIG_X86_64 */
40
41 #include <asm/syscall.h>
42 #include <asm/syscalls.h>
43
44 #include <asm/sigframe.h>
45
46 #ifdef CONFIG_X86_32
47 # define FIX_EFLAGS     (__FIX_EFLAGS | X86_EFLAGS_RF)
48 #else
49 # define FIX_EFLAGS     __FIX_EFLAGS
50 #endif
51
52 #define COPY(x)                 do {                    \
53         get_user_ex(regs->x, &sc->x);                   \
54 } while (0)
55
56 #define GET_SEG(seg)            ({                      \
57         unsigned short tmp;                             \
58         get_user_ex(tmp, &sc->seg);                     \
59         tmp;                                            \
60 })
61
62 #define COPY_SEG(seg)           do {                    \
63         regs->seg = GET_SEG(seg);                       \
64 } while (0)
65
66 #define COPY_SEG_CPL3(seg)      do {                    \
67         regs->seg = GET_SEG(seg) | 3;                   \
68 } while (0)
69
70 int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
71                        unsigned long *pax)
72 {
73         void __user *buf;
74         unsigned int tmpflags;
75         unsigned int err = 0;
76
77         /* Always make any pending restarted system calls return -EINTR */
78         current_thread_info()->restart_block.fn = do_no_restart_syscall;
79
80         get_user_try {
81
82 #ifdef CONFIG_X86_32
83                 set_user_gs(regs, GET_SEG(gs));
84                 COPY_SEG(fs);
85                 COPY_SEG(es);
86                 COPY_SEG(ds);
87 #endif /* CONFIG_X86_32 */
88
89                 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
90                 COPY(dx); COPY(cx); COPY(ip);
91
92 #ifdef CONFIG_X86_64
93                 COPY(r8);
94                 COPY(r9);
95                 COPY(r10);
96                 COPY(r11);
97                 COPY(r12);
98                 COPY(r13);
99                 COPY(r14);
100                 COPY(r15);
101 #endif /* CONFIG_X86_64 */
102
103 #ifdef CONFIG_X86_32
104                 COPY_SEG_CPL3(cs);
105                 COPY_SEG_CPL3(ss);
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. */
110                 COPY_SEG_CPL3(cs);
111 #endif /* CONFIG_X86_32 */
112
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 */
116
117                 get_user_ex(buf, &sc->fpstate);
118
119                 get_user_ex(*pax, &sc->ax);
120         } get_user_catch(err);
121
122         err |= restore_xstate_sig(buf, config_enabled(CONFIG_X86_32));
123
124         return err;
125 }
126
127 int setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate,
128                      struct pt_regs *regs, unsigned long mask)
129 {
130         int err = 0;
131
132         put_user_try {
133
134 #ifdef CONFIG_X86_32
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 */
140
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);
149 #ifdef CONFIG_X86_64
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 */
159
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);
163 #ifdef CONFIG_X86_32
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 */
174
175                 put_user_ex(fpstate, &sc->fpstate);
176
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);
181
182         return err;
183 }
184
185 /*
186  * Set up a signal frame.
187  */
188
189 /*
190  * Determine which stack to use..
191  */
192 static unsigned long align_sigframe(unsigned long sp)
193 {
194 #ifdef CONFIG_X86_32
195         /*
196          * Align the stack pointer according to the i386 ABI,
197          * i.e. so that on function entry ((sp + 4) & 15) == 0.
198          */
199         sp = ((sp + 4) & -16ul) - 4;
200 #else /* !CONFIG_X86_32 */
201         sp = round_down(sp, 16) - 8;
202 #endif
203         return sp;
204 }
205
206 static inline void __user *
207 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size,
208              void __user **fpstate)
209 {
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);
215
216         /* redzone */
217         if (config_enabled(CONFIG_X86_64))
218                 sp -= 128;
219
220         if (!onsigstack) {
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;
231                 }
232         }
233
234         if (used_math()) {
235                 sp = alloc_mathframe(sp, config_enabled(CONFIG_X86_32),
236                                      &buf_fx, &math_size);
237                 *fpstate = (void __user *)sp;
238         }
239
240         sp = align_sigframe(sp - frame_size);
241
242         /*
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.
245          */
246         if (onsigstack && !likely(on_sig_stack(sp)))
247                 return (void __user *)-1L;
248
249         /* save i387 and extended state */
250         if (used_math() &&
251             save_xstate_sig(*fpstate, (void __user *)buf_fx, math_size) < 0)
252                 return (void __user *)-1L;
253
254         return (void __user *)sp;
255 }
256
257 #ifdef CONFIG_X86_32
258 static const struct {
259         u16 poplmovl;
260         u32 val;
261         u16 int80;
262 } __attribute__((packed)) retcode = {
263         0xb858,         /* popl %eax; movl $..., %eax */
264         __NR_sigreturn,
265         0x80cd,         /* int $0x80 */
266 };
267
268 static const struct {
269         u8  movl;
270         u32 val;
271         u16 int80;
272         u8  pad;
273 } __attribute__((packed)) rt_retcode = {
274         0xb8,           /* movl $..., %eax */
275         __NR_rt_sigreturn,
276         0x80cd,         /* int $0x80 */
277         0
278 };
279
280 static int
281 __setup_frame(int sig, struct ksignal *ksig, sigset_t *set,
282               struct pt_regs *regs)
283 {
284         struct sigframe __user *frame;
285         void __user *restorer;
286         int err = 0;
287         void __user *fpstate = NULL;
288
289         frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate);
290
291         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
292                 return -EFAULT;
293
294         if (__put_user(sig, &frame->sig))
295                 return -EFAULT;
296
297         if (setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
298                 return -EFAULT;
299
300         if (_NSIG_WORDS > 1) {
301                 if (__copy_to_user(&frame->extramask, &set->sig[1],
302                                    sizeof(frame->extramask)))
303                         return -EFAULT;
304         }
305
306         if (current->mm->context.vdso)
307                 restorer = VDSO32_SYMBOL(current->mm->context.vdso, sigreturn);
308         else
309                 restorer = &frame->retcode;
310         if (ksig->ka.sa.sa_flags & SA_RESTORER)
311                 restorer = ksig->ka.sa.sa_restorer;
312
313         /* Set up to return from userspace.  */
314         err |= __put_user(restorer, &frame->pretcode);
315
316         /*
317          * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80
318          *
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.
322          */
323         err |= __put_user(*((u64 *)&retcode), (u64 *)frame->retcode);
324
325         if (err)
326                 return -EFAULT;
327
328         /* Set up registers for signal handler */
329         regs->sp = (unsigned long)frame;
330         regs->ip = (unsigned long)ksig->ka.sa.sa_handler;
331         regs->ax = (unsigned long)sig;
332         regs->dx = 0;
333         regs->cx = 0;
334
335         regs->ds = __USER_DS;
336         regs->es = __USER_DS;
337         regs->ss = __USER_DS;
338         regs->cs = __USER_CS;
339
340         return 0;
341 }
342
343 static int __setup_rt_frame(int sig, struct ksignal *ksig,
344                             sigset_t *set, struct pt_regs *regs)
345 {
346         struct rt_sigframe __user *frame;
347         void __user *restorer;
348         int err = 0;
349         void __user *fpstate = NULL;
350
351         frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate);
352
353         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
354                 return -EFAULT;
355
356         put_user_try {
357                 put_user_ex(sig, &frame->sig);
358                 put_user_ex(&frame->info, &frame->pinfo);
359                 put_user_ex(&frame->uc, &frame->puc);
360
361                 /* Create the ucontext.  */
362                 if (cpu_has_xsave)
363                         put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
364                 else
365                         put_user_ex(0, &frame->uc.uc_flags);
366                 put_user_ex(0, &frame->uc.uc_link);
367                 save_altstack_ex(&frame->uc.uc_stack, regs->sp);
368
369                 /* Set up to return from userspace.  */
370                 restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn);
371                 if (ksig->ka.sa.sa_flags & SA_RESTORER)
372                         restorer = ksig->ka.sa.sa_restorer;
373                 put_user_ex(restorer, &frame->pretcode);
374
375                 /*
376                  * This is movl $__NR_rt_sigreturn, %ax ; int $0x80
377                  *
378                  * WE DO NOT USE IT ANY MORE! It's only left here for historical
379                  * reasons and because gdb uses it as a signature to notice
380                  * signal handler stack frames.
381                  */
382                 put_user_ex(*((u64 *)&rt_retcode), (u64 *)frame->retcode);
383         } put_user_catch(err);
384         
385         err |= copy_siginfo_to_user(&frame->info, &ksig->info);
386         err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
387                                 regs, set->sig[0]);
388         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
389
390         if (err)
391                 return -EFAULT;
392
393         /* Set up registers for signal handler */
394         regs->sp = (unsigned long)frame;
395         regs->ip = (unsigned long)ksig->ka.sa.sa_handler;
396         regs->ax = (unsigned long)sig;
397         regs->dx = (unsigned long)&frame->info;
398         regs->cx = (unsigned long)&frame->uc;
399
400         regs->ds = __USER_DS;
401         regs->es = __USER_DS;
402         regs->ss = __USER_DS;
403         regs->cs = __USER_CS;
404
405         return 0;
406 }
407 #else /* !CONFIG_X86_32 */
408 static int __setup_rt_frame(int sig, struct ksignal *ksig,
409                             sigset_t *set, struct pt_regs *regs)
410 {
411         struct rt_sigframe __user *frame;
412         void __user *fp = NULL;
413         int err = 0;
414
415         frame = get_sigframe(&ksig->ka, regs, sizeof(struct rt_sigframe), &fp);
416
417         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
418                 return -EFAULT;
419
420         if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
421                 if (copy_siginfo_to_user(&frame->info, &ksig->info))
422                         return -EFAULT;
423         }
424
425         put_user_try {
426                 /* Create the ucontext.  */
427                 if (cpu_has_xsave)
428                         put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
429                 else
430                         put_user_ex(0, &frame->uc.uc_flags);
431                 put_user_ex(0, &frame->uc.uc_link);
432                 save_altstack_ex(&frame->uc.uc_stack, regs->sp);
433
434                 /* Set up to return from userspace.  If provided, use a stub
435                    already in userspace.  */
436                 /* x86-64 should always use SA_RESTORER. */
437                 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
438                         put_user_ex(ksig->ka.sa.sa_restorer, &frame->pretcode);
439                 } else {
440                         /* could use a vstub here */
441                         err |= -EFAULT;
442                 }
443         } put_user_catch(err);
444
445         err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]);
446         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
447
448         if (err)
449                 return -EFAULT;
450
451         /* Set up registers for signal handler */
452         regs->di = sig;
453         /* In case the signal handler was declared without prototypes */
454         regs->ax = 0;
455
456         /* This also works for non SA_SIGINFO handlers because they expect the
457            next argument after the signal number on the stack. */
458         regs->si = (unsigned long)&frame->info;
459         regs->dx = (unsigned long)&frame->uc;
460         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
461
462         regs->sp = (unsigned long)frame;
463
464         /* Set up the CS register to run signal handlers in 64-bit mode,
465            even if the handler happens to be interrupting 32-bit code. */
466         regs->cs = __USER_CS;
467
468         return 0;
469 }
470 #endif /* CONFIG_X86_32 */
471
472 static int x32_setup_rt_frame(struct ksignal *ksig,
473                               compat_sigset_t *set,
474                               struct pt_regs *regs)
475 {
476 #ifdef CONFIG_X86_X32_ABI
477         struct rt_sigframe_x32 __user *frame;
478         void __user *restorer;
479         int err = 0;
480         void __user *fpstate = NULL;
481
482         frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate);
483
484         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
485                 return -EFAULT;
486
487         if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
488                 if (copy_siginfo_to_user32(&frame->info, &ksig->info))
489                         return -EFAULT;
490         }
491
492         put_user_try {
493                 /* Create the ucontext.  */
494                 if (cpu_has_xsave)
495                         put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
496                 else
497                         put_user_ex(0, &frame->uc.uc_flags);
498                 put_user_ex(0, &frame->uc.uc_link);
499                 compat_save_altstack_ex(&frame->uc.uc_stack, regs->sp);
500                 put_user_ex(0, &frame->uc.uc__pad0);
501
502                 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
503                         restorer = ksig->ka.sa.sa_restorer;
504                 } else {
505                         /* could use a vstub here */
506                         restorer = NULL;
507                         err |= -EFAULT;
508                 }
509                 put_user_ex(restorer, &frame->pretcode);
510         } put_user_catch(err);
511
512         err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
513                                 regs, set->sig[0]);
514         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
515
516         if (err)
517                 return -EFAULT;
518
519         /* Set up registers for signal handler */
520         regs->sp = (unsigned long) frame;
521         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
522
523         /* We use the x32 calling convention here... */
524         regs->di = ksig->sig;
525         regs->si = (unsigned long) &frame->info;
526         regs->dx = (unsigned long) &frame->uc;
527
528         loadsegment(ds, __USER_DS);
529         loadsegment(es, __USER_DS);
530
531         regs->cs = __USER_CS;
532         regs->ss = __USER_DS;
533 #endif  /* CONFIG_X86_X32_ABI */
534
535         return 0;
536 }
537
538 /*
539  * Do a signal return; undo the signal stack.
540  */
541 #ifdef CONFIG_X86_32
542 unsigned long sys_sigreturn(void)
543 {
544         struct pt_regs *regs = current_pt_regs();
545         struct sigframe __user *frame;
546         unsigned long ax;
547         sigset_t set;
548
549         frame = (struct sigframe __user *)(regs->sp - 8);
550
551         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
552                 goto badframe;
553         if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1
554                 && __copy_from_user(&set.sig[1], &frame->extramask,
555                                     sizeof(frame->extramask))))
556                 goto badframe;
557
558         set_current_blocked(&set);
559
560         if (restore_sigcontext(regs, &frame->sc, &ax))
561                 goto badframe;
562         return ax;
563
564 badframe:
565         signal_fault(regs, frame, "sigreturn");
566
567         return 0;
568 }
569 #endif /* CONFIG_X86_32 */
570
571 long sys_rt_sigreturn(void)
572 {
573         struct pt_regs *regs = current_pt_regs();
574         struct rt_sigframe __user *frame;
575         unsigned long ax;
576         sigset_t set;
577
578         frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));
579         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
580                 goto badframe;
581         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
582                 goto badframe;
583
584         set_current_blocked(&set);
585
586         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
587                 goto badframe;
588
589         if (restore_altstack(&frame->uc.uc_stack))
590                 goto badframe;
591
592         return ax;
593
594 badframe:
595         signal_fault(regs, frame, "rt_sigreturn");
596         return 0;
597 }
598
599 static int
600 setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs)
601 {
602         int usig = ksig->sig;
603         sigset_t *set = sigmask_to_save();
604         compat_sigset_t *cset = (compat_sigset_t *) set;
605
606         /* Set up the stack frame */
607         if (is_ia32_frame()) {
608                 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
609                         return ia32_setup_rt_frame(usig, ksig, cset, regs);
610                 else
611                         return ia32_setup_frame(usig, ksig, cset, regs);
612         } else if (is_x32_frame()) {
613                 return x32_setup_rt_frame(ksig, cset, regs);
614         } else {
615                 return __setup_rt_frame(ksig->sig, ksig, set, regs);
616         }
617 }
618
619 static void
620 handle_signal(struct ksignal *ksig, struct pt_regs *regs)
621 {
622         bool failed;
623         /* Are we from a system call? */
624         if (syscall_get_nr(current, regs) >= 0) {
625                 /* If so, check system call restarting.. */
626                 switch (syscall_get_error(current, regs)) {
627                 case -ERESTART_RESTARTBLOCK:
628                 case -ERESTARTNOHAND:
629                         regs->ax = -EINTR;
630                         break;
631
632                 case -ERESTARTSYS:
633                         if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
634                                 regs->ax = -EINTR;
635                                 break;
636                         }
637                 /* fallthrough */
638                 case -ERESTARTNOINTR:
639                         regs->ax = regs->orig_ax;
640                         regs->ip -= 2;
641                         break;
642                 }
643         }
644
645         /*
646          * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF
647          * flag so that register information in the sigcontext is correct.
648          */
649         if (unlikely(regs->flags & X86_EFLAGS_TF) &&
650             likely(test_and_clear_thread_flag(TIF_FORCED_TF)))
651                 regs->flags &= ~X86_EFLAGS_TF;
652
653         failed = (setup_rt_frame(ksig, regs) < 0);
654         if (!failed) {
655                 /*
656                  * Clear the direction flag as per the ABI for function entry.
657                  */
658                 regs->flags &= ~X86_EFLAGS_DF;
659                 /*
660                  * Clear TF when entering the signal handler, but
661                  * notify any tracer that was single-stepping it.
662                  * The tracer may want to single-step inside the
663                  * handler too.
664                  */
665                 regs->flags &= ~X86_EFLAGS_TF;
666                 /*
667                  * Ensure the signal handler starts with the new fpu state.
668                  */
669                 if (used_math())
670                         drop_init_fpu(current);
671         }
672         signal_setup_done(failed, ksig, test_thread_flag(TIF_SINGLESTEP));
673 }
674
675 static inline unsigned long get_nr_restart_syscall(const struct pt_regs *regs)
676 {
677 #if defined(CONFIG_X86_32) || !defined(CONFIG_X86_64)
678         return __NR_restart_syscall;
679 #else /* !CONFIG_X86_32 && CONFIG_X86_64 */
680         return test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall :
681                 __NR_restart_syscall | (regs->orig_ax & __X32_SYSCALL_BIT);
682 #endif /* CONFIG_X86_32 || !CONFIG_X86_64 */
683 }
684
685 /*
686  * Note that 'init' is a special process: it doesn't get signals it doesn't
687  * want to handle. Thus you cannot kill init even with a SIGKILL even by
688  * mistake.
689  */
690 static void do_signal(struct pt_regs *regs)
691 {
692         struct ksignal ksig;
693
694         if (get_signal(&ksig)) {
695                 /* Whee! Actually deliver the signal.  */
696                 handle_signal(&ksig, regs);
697                 return;
698         }
699
700         /* Did we come from a system call? */
701         if (syscall_get_nr(current, regs) >= 0) {
702                 /* Restart the system call - no handlers present */
703                 switch (syscall_get_error(current, regs)) {
704                 case -ERESTARTNOHAND:
705                 case -ERESTARTSYS:
706                 case -ERESTARTNOINTR:
707                         regs->ax = regs->orig_ax;
708                         regs->ip -= 2;
709                         break;
710
711                 case -ERESTART_RESTARTBLOCK:
712                         regs->ax = get_nr_restart_syscall(regs);
713                         regs->ip -= 2;
714                         break;
715                 }
716         }
717
718         /*
719          * If there's no signal to deliver, we just put the saved sigmask
720          * back.
721          */
722         restore_saved_sigmask();
723 }
724
725 /*
726  * notification of userspace execution resumption
727  * - triggered by the TIF_WORK_MASK flags
728  */
729 void
730 do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
731 {
732         user_exit();
733
734 #ifdef CONFIG_X86_MCE
735         /* notify userspace of pending MCEs */
736         if (thread_info_flags & _TIF_MCE_NOTIFY)
737                 mce_notify_process();
738 #endif /* CONFIG_X86_64 && CONFIG_X86_MCE */
739
740         if (thread_info_flags & _TIF_UPROBE)
741                 uprobe_notify_resume(regs);
742
743         /* deal with pending signal delivery */
744         if (thread_info_flags & _TIF_SIGPENDING)
745                 do_signal(regs);
746
747         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
748                 clear_thread_flag(TIF_NOTIFY_RESUME);
749                 tracehook_notify_resume(regs);
750         }
751         if (thread_info_flags & _TIF_USER_RETURN_NOTIFY)
752                 fire_user_return_notifiers();
753
754         user_enter();
755 }
756
757 void signal_fault(struct pt_regs *regs, void __user *frame, char *where)
758 {
759         struct task_struct *me = current;
760
761         if (show_unhandled_signals && printk_ratelimit()) {
762                 printk("%s"
763                        "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
764                        task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG,
765                        me->comm, me->pid, where, frame,
766                        regs->ip, regs->sp, regs->orig_ax);
767                 print_vma_addr(" in ", regs->ip);
768                 pr_cont("\n");
769         }
770
771         force_sig(SIGSEGV, me);
772 }
773
774 #ifdef CONFIG_X86_X32_ABI
775 asmlinkage long sys32_x32_rt_sigreturn(void)
776 {
777         struct pt_regs *regs = current_pt_regs();
778         struct rt_sigframe_x32 __user *frame;
779         sigset_t set;
780         unsigned long ax;
781
782         frame = (struct rt_sigframe_x32 __user *)(regs->sp - 8);
783
784         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
785                 goto badframe;
786         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
787                 goto badframe;
788
789         set_current_blocked(&set);
790
791         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
792                 goto badframe;
793
794         if (compat_restore_altstack(&frame->uc.uc_stack))
795                 goto badframe;
796
797         return ax;
798
799 badframe:
800         signal_fault(regs, frame, "x32 rt_sigreturn");
801         return 0;
802 }
803 #endif