x86: ia32_signal: do save_i387_xstate_ia32 at get_sigframe()
[linux-2.6.git] / arch / x86 / ia32 / ia32_signal.c
1 /*
2  *  linux/arch/x86_64/ia32/ia32_signal.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *
6  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
7  *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
8  *  2000-12-*   x86-64 compatibility mode signal handling by Andi Kleen
9  */
10
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/kernel.h>
15 #include <linux/signal.h>
16 #include <linux/errno.h>
17 #include <linux/wait.h>
18 #include <linux/ptrace.h>
19 #include <linux/unistd.h>
20 #include <linux/stddef.h>
21 #include <linux/personality.h>
22 #include <linux/compat.h>
23 #include <linux/binfmts.h>
24 #include <asm/ucontext.h>
25 #include <asm/uaccess.h>
26 #include <asm/i387.h>
27 #include <asm/ia32.h>
28 #include <asm/ptrace.h>
29 #include <asm/ia32_unistd.h>
30 #include <asm/user32.h>
31 #include <asm/sigcontext32.h>
32 #include <asm/proto.h>
33 #include <asm/vdso.h>
34
35 #define DEBUG_SIG 0
36
37 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
38
39 #define FIX_EFLAGS      (X86_EFLAGS_AC | X86_EFLAGS_OF | \
40                          X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \
41                          X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \
42                          X86_EFLAGS_CF)
43
44 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
45 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
46
47 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
48 {
49         int err;
50
51         if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
52                 return -EFAULT;
53
54         /* If you change siginfo_t structure, please make sure that
55            this code is fixed accordingly.
56            It should never copy any pad contained in the structure
57            to avoid security leaks, but must copy the generic
58            3 ints plus the relevant union member.  */
59         err = __put_user(from->si_signo, &to->si_signo);
60         err |= __put_user(from->si_errno, &to->si_errno);
61         err |= __put_user((short)from->si_code, &to->si_code);
62
63         if (from->si_code < 0) {
64                 err |= __put_user(from->si_pid, &to->si_pid);
65                 err |= __put_user(from->si_uid, &to->si_uid);
66                 err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
67         } else {
68                 /*
69                  * First 32bits of unions are always present:
70                  * si_pid === si_band === si_tid === si_addr(LS half)
71                  */
72                 err |= __put_user(from->_sifields._pad[0],
73                                   &to->_sifields._pad[0]);
74                 switch (from->si_code >> 16) {
75                 case __SI_FAULT >> 16:
76                         break;
77                 case __SI_CHLD >> 16:
78                         err |= __put_user(from->si_utime, &to->si_utime);
79                         err |= __put_user(from->si_stime, &to->si_stime);
80                         err |= __put_user(from->si_status, &to->si_status);
81                         /* FALL THROUGH */
82                 default:
83                 case __SI_KILL >> 16:
84                         err |= __put_user(from->si_uid, &to->si_uid);
85                         break;
86                 case __SI_POLL >> 16:
87                         err |= __put_user(from->si_fd, &to->si_fd);
88                         break;
89                 case __SI_TIMER >> 16:
90                         err |= __put_user(from->si_overrun, &to->si_overrun);
91                         err |= __put_user(ptr_to_compat(from->si_ptr),
92                                           &to->si_ptr);
93                         break;
94                          /* This is not generated by the kernel as of now.  */
95                 case __SI_RT >> 16:
96                 case __SI_MESGQ >> 16:
97                         err |= __put_user(from->si_uid, &to->si_uid);
98                         err |= __put_user(from->si_int, &to->si_int);
99                         break;
100                 }
101         }
102         return err;
103 }
104
105 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
106 {
107         int err;
108         u32 ptr32;
109
110         if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
111                 return -EFAULT;
112
113         err = __get_user(to->si_signo, &from->si_signo);
114         err |= __get_user(to->si_errno, &from->si_errno);
115         err |= __get_user(to->si_code, &from->si_code);
116
117         err |= __get_user(to->si_pid, &from->si_pid);
118         err |= __get_user(to->si_uid, &from->si_uid);
119         err |= __get_user(ptr32, &from->si_ptr);
120         to->si_ptr = compat_ptr(ptr32);
121
122         return err;
123 }
124
125 asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
126 {
127         mask &= _BLOCKABLE;
128         spin_lock_irq(&current->sighand->siglock);
129         current->saved_sigmask = current->blocked;
130         siginitset(&current->blocked, mask);
131         recalc_sigpending();
132         spin_unlock_irq(&current->sighand->siglock);
133
134         current->state = TASK_INTERRUPTIBLE;
135         schedule();
136         set_restore_sigmask();
137         return -ERESTARTNOHAND;
138 }
139
140 asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
141                                   stack_ia32_t __user *uoss_ptr,
142                                   struct pt_regs *regs)
143 {
144         stack_t uss, uoss;
145         int ret;
146         mm_segment_t seg;
147
148         if (uss_ptr) {
149                 u32 ptr;
150
151                 memset(&uss, 0, sizeof(stack_t));
152                 if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)) ||
153                             __get_user(ptr, &uss_ptr->ss_sp) ||
154                             __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
155                             __get_user(uss.ss_size, &uss_ptr->ss_size))
156                         return -EFAULT;
157                 uss.ss_sp = compat_ptr(ptr);
158         }
159         seg = get_fs();
160         set_fs(KERNEL_DS);
161         ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);
162         set_fs(seg);
163         if (ret >= 0 && uoss_ptr)  {
164                 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)) ||
165                     __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
166                     __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
167                     __put_user(uoss.ss_size, &uoss_ptr->ss_size))
168                         ret = -EFAULT;
169         }
170         return ret;
171 }
172
173 /*
174  * Do a signal return; undo the signal stack.
175  */
176
177 struct sigframe
178 {
179         u32 pretcode;
180         int sig;
181         struct sigcontext_ia32 sc;
182         struct _fpstate_ia32 fpstate_unused; /* look at kernel/sigframe.h */
183         unsigned int extramask[_COMPAT_NSIG_WORDS-1];
184         char retcode[8];
185         /* fp state follows here */
186 };
187
188 struct rt_sigframe
189 {
190         u32 pretcode;
191         int sig;
192         u32 pinfo;
193         u32 puc;
194         compat_siginfo_t info;
195         struct ucontext_ia32 uc;
196         char retcode[8];
197         /* fp state follows here */
198 };
199
200 #define COPY(x)         {               \
201         unsigned int reg;               \
202         err |= __get_user(reg, &sc->x); \
203         regs->x = reg;                  \
204 }
205
206 #define RELOAD_SEG(seg,mask)                                            \
207         { unsigned int cur;                                             \
208           unsigned short pre;                                           \
209           err |= __get_user(pre, &sc->seg);                             \
210           savesegment(seg, cur);                                        \
211           pre |= mask;                                                  \
212           if (pre != cur) loadsegment(seg, pre); }
213
214 static int ia32_restore_sigcontext(struct pt_regs *regs,
215                                    struct sigcontext_ia32 __user *sc,
216                                    unsigned int *peax)
217 {
218         unsigned int tmpflags, gs, oldgs, err = 0;
219         void __user *buf;
220         u32 tmp;
221
222         /* Always make any pending restarted system calls return -EINTR */
223         current_thread_info()->restart_block.fn = do_no_restart_syscall;
224
225 #if DEBUG_SIG
226         printk(KERN_DEBUG "SIG restore_sigcontext: "
227                "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
228                sc, sc->err, sc->ip, sc->cs, sc->flags);
229 #endif
230
231         /*
232          * Reload fs and gs if they have changed in the signal
233          * handler.  This does not handle long fs/gs base changes in
234          * the handler, but does not clobber them at least in the
235          * normal case.
236          */
237         err |= __get_user(gs, &sc->gs);
238         gs |= 3;
239         savesegment(gs, oldgs);
240         if (gs != oldgs)
241                 load_gs_index(gs);
242
243         RELOAD_SEG(fs, 3);
244         RELOAD_SEG(ds, 3);
245         RELOAD_SEG(es, 3);
246
247         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
248         COPY(dx); COPY(cx); COPY(ip);
249         /* Don't touch extended registers */
250
251         err |= __get_user(regs->cs, &sc->cs);
252         regs->cs |= 3;
253         err |= __get_user(regs->ss, &sc->ss);
254         regs->ss |= 3;
255
256         err |= __get_user(tmpflags, &sc->flags);
257         regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
258         /* disable syscall checks */
259         regs->orig_ax = -1;
260
261         err |= __get_user(tmp, &sc->fpstate);
262         buf = compat_ptr(tmp);
263         err |= restore_i387_xstate_ia32(buf);
264
265         err |= __get_user(tmp, &sc->ax);
266         *peax = tmp;
267
268         return err;
269 }
270
271 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
272 {
273         struct sigframe __user *frame = (struct sigframe __user *)(regs->sp-8);
274         sigset_t set;
275         unsigned int ax;
276
277         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
278                 goto badframe;
279         if (__get_user(set.sig[0], &frame->sc.oldmask)
280             || (_COMPAT_NSIG_WORDS > 1
281                 && __copy_from_user((((char *) &set.sig) + 4),
282                                     &frame->extramask,
283                                     sizeof(frame->extramask))))
284                 goto badframe;
285
286         sigdelsetmask(&set, ~_BLOCKABLE);
287         spin_lock_irq(&current->sighand->siglock);
288         current->blocked = set;
289         recalc_sigpending();
290         spin_unlock_irq(&current->sighand->siglock);
291
292         if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
293                 goto badframe;
294         return ax;
295
296 badframe:
297         signal_fault(regs, frame, "32bit sigreturn");
298         return 0;
299 }
300
301 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
302 {
303         struct rt_sigframe __user *frame;
304         sigset_t set;
305         unsigned int ax;
306         struct pt_regs tregs;
307
308         frame = (struct rt_sigframe __user *)(regs->sp - 4);
309
310         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
311                 goto badframe;
312         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
313                 goto badframe;
314
315         sigdelsetmask(&set, ~_BLOCKABLE);
316         spin_lock_irq(&current->sighand->siglock);
317         current->blocked = set;
318         recalc_sigpending();
319         spin_unlock_irq(&current->sighand->siglock);
320
321         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
322                 goto badframe;
323
324         tregs = *regs;
325         if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
326                 goto badframe;
327
328         return ax;
329
330 badframe:
331         signal_fault(regs, frame, "32bit rt sigreturn");
332         return 0;
333 }
334
335 /*
336  * Set up a signal frame.
337  */
338
339 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
340                                  void __user *fpstate,
341                                  struct pt_regs *regs, unsigned int mask)
342 {
343         int tmp, err = 0;
344
345         savesegment(gs, tmp);
346         err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
347         savesegment(fs, tmp);
348         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
349         savesegment(ds, tmp);
350         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
351         savesegment(es, tmp);
352         err |= __put_user(tmp, (unsigned int __user *)&sc->es);
353
354         err |= __put_user(regs->di, &sc->di);
355         err |= __put_user(regs->si, &sc->si);
356         err |= __put_user(regs->bp, &sc->bp);
357         err |= __put_user(regs->sp, &sc->sp);
358         err |= __put_user(regs->bx, &sc->bx);
359         err |= __put_user(regs->dx, &sc->dx);
360         err |= __put_user(regs->cx, &sc->cx);
361         err |= __put_user(regs->ax, &sc->ax);
362         err |= __put_user(regs->cs, &sc->cs);
363         err |= __put_user(regs->ss, &sc->ss);
364         err |= __put_user(current->thread.trap_no, &sc->trapno);
365         err |= __put_user(current->thread.error_code, &sc->err);
366         err |= __put_user(regs->ip, &sc->ip);
367         err |= __put_user(regs->flags, &sc->flags);
368         err |= __put_user(regs->sp, &sc->sp_at_signal);
369
370         err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
371
372         /* non-iBCS2 extensions.. */
373         err |= __put_user(mask, &sc->oldmask);
374         err |= __put_user(current->thread.cr2, &sc->cr2);
375
376         return err;
377 }
378
379 /*
380  * Determine which stack to use..
381  */
382 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
383                                  size_t frame_size,
384                                  void **fpstate)
385 {
386         unsigned long sp;
387
388         /* Default to using normal stack */
389         sp = regs->sp;
390
391         /* This is the X/Open sanctioned signal stack switching.  */
392         if (ka->sa.sa_flags & SA_ONSTACK) {
393                 if (sas_ss_flags(sp) == 0)
394                         sp = current->sas_ss_sp + current->sas_ss_size;
395         }
396
397         /* This is the legacy signal stack switching. */
398         else if ((regs->ss & 0xffff) != __USER_DS &&
399                 !(ka->sa.sa_flags & SA_RESTORER) &&
400                  ka->sa.sa_restorer)
401                 sp = (unsigned long) ka->sa.sa_restorer;
402
403         if (used_math()) {
404                 sp = sp - sig_xstate_ia32_size;
405                 *fpstate = (struct _fpstate_ia32 *) sp;
406                 if (save_i387_xstate_ia32(*fpstate) < 0)
407                         return (void __user *) -1L;
408         }
409
410         sp -= frame_size;
411         /* Align the stack pointer according to the i386 ABI,
412          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
413         sp = ((sp + 4) & -16ul) - 4;
414         return (void __user *) sp;
415 }
416
417 int ia32_setup_frame(int sig, struct k_sigaction *ka,
418                      compat_sigset_t *set, struct pt_regs *regs)
419 {
420         struct sigframe __user *frame;
421         void __user *restorer;
422         int err = 0;
423         void __user *fpstate = NULL;
424
425         /* copy_to_user optimizes that into a single 8 byte store */
426         static const struct {
427                 u16 poplmovl;
428                 u32 val;
429                 u16 int80;
430                 u16 pad;
431         } __attribute__((packed)) code = {
432                 0xb858,          /* popl %eax ; movl $...,%eax */
433                 __NR_ia32_sigreturn,
434                 0x80cd,         /* int $0x80 */
435                 0,
436         };
437
438         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
439
440         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
441                 return -EFAULT;
442
443         if (__put_user(sig, &frame->sig))
444                 return -EFAULT;
445
446         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
447                 return -EFAULT;
448
449         if (_COMPAT_NSIG_WORDS > 1) {
450                 if (__copy_to_user(frame->extramask, &set->sig[1],
451                                    sizeof(frame->extramask)))
452                         return -EFAULT;
453         }
454
455         if (ka->sa.sa_flags & SA_RESTORER) {
456                 restorer = ka->sa.sa_restorer;
457         } else {
458                 /* Return stub is in 32bit vsyscall page */
459                 if (current->mm->context.vdso)
460                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
461                                                  sigreturn);
462                 else
463                         restorer = &frame->retcode;
464         }
465         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
466
467         /*
468          * These are actually not used anymore, but left because some
469          * gdb versions depend on them as a marker.
470          */
471         err |= __copy_to_user(frame->retcode, &code, 8);
472         if (err)
473                 return -EFAULT;
474
475         /* Set up registers for signal handler */
476         regs->sp = (unsigned long) frame;
477         regs->ip = (unsigned long) ka->sa.sa_handler;
478
479         /* Make -mregparm=3 work */
480         regs->ax = sig;
481         regs->dx = 0;
482         regs->cx = 0;
483
484         loadsegment(ds, __USER32_DS);
485         loadsegment(es, __USER32_DS);
486
487         regs->cs = __USER32_CS;
488         regs->ss = __USER32_DS;
489
490 #if DEBUG_SIG
491         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
492                current->comm, current->pid, frame, regs->ip, frame->pretcode);
493 #endif
494
495         return 0;
496 }
497
498 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
499                         compat_sigset_t *set, struct pt_regs *regs)
500 {
501         struct rt_sigframe __user *frame;
502         void __user *restorer;
503         int err = 0;
504         void __user *fpstate = NULL;
505
506         /* __copy_to_user optimizes that into a single 8 byte store */
507         static const struct {
508                 u8 movl;
509                 u32 val;
510                 u16 int80;
511                 u16 pad;
512                 u8  pad2;
513         } __attribute__((packed)) code = {
514                 0xb8,
515                 __NR_ia32_rt_sigreturn,
516                 0x80cd,
517                 0,
518         };
519
520         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
521
522         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
523                 return -EFAULT;
524
525         err |= __put_user(sig, &frame->sig);
526         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
527         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
528         err |= copy_siginfo_to_user32(&frame->info, info);
529         if (err)
530                 return -EFAULT;
531
532         /* Create the ucontext.  */
533         if (cpu_has_xsave)
534                 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
535         else
536                 err |= __put_user(0, &frame->uc.uc_flags);
537         err |= __put_user(0, &frame->uc.uc_link);
538         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
539         err |= __put_user(sas_ss_flags(regs->sp),
540                           &frame->uc.uc_stack.ss_flags);
541         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
542         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
543                                      regs, set->sig[0]);
544         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
545         if (err)
546                 return -EFAULT;
547
548         if (ka->sa.sa_flags & SA_RESTORER)
549                 restorer = ka->sa.sa_restorer;
550         else
551                 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
552                                          rt_sigreturn);
553         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
554
555         /*
556          * Not actually used anymore, but left because some gdb
557          * versions need it.
558          */
559         err |= __copy_to_user(frame->retcode, &code, 8);
560         if (err)
561                 return -EFAULT;
562
563         /* Set up registers for signal handler */
564         regs->sp = (unsigned long) frame;
565         regs->ip = (unsigned long) ka->sa.sa_handler;
566
567         /* Make -mregparm=3 work */
568         regs->ax = sig;
569         regs->dx = (unsigned long) &frame->info;
570         regs->cx = (unsigned long) &frame->uc;
571
572         /* Make -mregparm=3 work */
573         regs->ax = sig;
574         regs->dx = (unsigned long) &frame->info;
575         regs->cx = (unsigned long) &frame->uc;
576
577         loadsegment(ds, __USER32_DS);
578         loadsegment(es, __USER32_DS);
579
580         regs->cs = __USER32_CS;
581         regs->ss = __USER32_DS;
582
583 #if DEBUG_SIG
584         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
585                current->comm, current->pid, frame, regs->ip, frame->pretcode);
586 #endif
587
588         return 0;
589 }