x86, signals: remove duplicated register setup code in ia32 signal delivery
[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         tmp = save_i387_xstate_ia32(fpstate);
371         if (tmp < 0)
372                 err = -EFAULT;
373         else
374                 err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL),
375                                         &sc->fpstate);
376
377         /* non-iBCS2 extensions.. */
378         err |= __put_user(mask, &sc->oldmask);
379         err |= __put_user(current->thread.cr2, &sc->cr2);
380
381         return err;
382 }
383
384 /*
385  * Determine which stack to use..
386  */
387 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
388                                  size_t frame_size,
389                                  void **fpstate)
390 {
391         unsigned long sp;
392
393         /* Default to using normal stack */
394         sp = regs->sp;
395
396         /* This is the X/Open sanctioned signal stack switching.  */
397         if (ka->sa.sa_flags & SA_ONSTACK) {
398                 if (sas_ss_flags(sp) == 0)
399                         sp = current->sas_ss_sp + current->sas_ss_size;
400         }
401
402         /* This is the legacy signal stack switching. */
403         else if ((regs->ss & 0xffff) != __USER_DS &&
404                 !(ka->sa.sa_flags & SA_RESTORER) &&
405                  ka->sa.sa_restorer)
406                 sp = (unsigned long) ka->sa.sa_restorer;
407
408         if (used_math()) {
409                 sp = sp - sig_xstate_ia32_size;
410                 *fpstate = (struct _fpstate_ia32 *) sp;
411         }
412
413         sp -= frame_size;
414         /* Align the stack pointer according to the i386 ABI,
415          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
416         sp = ((sp + 4) & -16ul) - 4;
417         return (void __user *) sp;
418 }
419
420 int ia32_setup_frame(int sig, struct k_sigaction *ka,
421                      compat_sigset_t *set, struct pt_regs *regs)
422 {
423         struct sigframe __user *frame;
424         void __user *restorer;
425         int err = 0;
426         void __user *fpstate = NULL;
427
428         /* copy_to_user optimizes that into a single 8 byte store */
429         static const struct {
430                 u16 poplmovl;
431                 u32 val;
432                 u16 int80;
433                 u16 pad;
434         } __attribute__((packed)) code = {
435                 0xb858,          /* popl %eax ; movl $...,%eax */
436                 __NR_ia32_sigreturn,
437                 0x80cd,         /* int $0x80 */
438                 0,
439         };
440
441         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
442
443         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
444                 return -EFAULT;
445
446         if (__put_user(sig, &frame->sig))
447                 return -EFAULT;
448
449         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
450                 return -EFAULT;
451
452         if (_COMPAT_NSIG_WORDS > 1) {
453                 if (__copy_to_user(frame->extramask, &set->sig[1],
454                                    sizeof(frame->extramask)))
455                         return -EFAULT;
456         }
457
458         if (ka->sa.sa_flags & SA_RESTORER) {
459                 restorer = ka->sa.sa_restorer;
460         } else {
461                 /* Return stub is in 32bit vsyscall page */
462                 if (current->mm->context.vdso)
463                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
464                                                  sigreturn);
465                 else
466                         restorer = &frame->retcode;
467         }
468         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
469
470         /*
471          * These are actually not used anymore, but left because some
472          * gdb versions depend on them as a marker.
473          */
474         err |= __copy_to_user(frame->retcode, &code, 8);
475         if (err)
476                 return -EFAULT;
477
478         /* Set up registers for signal handler */
479         regs->sp = (unsigned long) frame;
480         regs->ip = (unsigned long) ka->sa.sa_handler;
481
482         /* Make -mregparm=3 work */
483         regs->ax = sig;
484         regs->dx = 0;
485         regs->cx = 0;
486
487         loadsegment(ds, __USER32_DS);
488         loadsegment(es, __USER32_DS);
489
490         regs->cs = __USER32_CS;
491         regs->ss = __USER32_DS;
492
493 #if DEBUG_SIG
494         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
495                current->comm, current->pid, frame, regs->ip, frame->pretcode);
496 #endif
497
498         return 0;
499 }
500
501 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
502                         compat_sigset_t *set, struct pt_regs *regs)
503 {
504         struct rt_sigframe __user *frame;
505         void __user *restorer;
506         int err = 0;
507         void __user *fpstate = NULL;
508
509         /* __copy_to_user optimizes that into a single 8 byte store */
510         static const struct {
511                 u8 movl;
512                 u32 val;
513                 u16 int80;
514                 u16 pad;
515                 u8  pad2;
516         } __attribute__((packed)) code = {
517                 0xb8,
518                 __NR_ia32_rt_sigreturn,
519                 0x80cd,
520                 0,
521         };
522
523         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
524
525         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
526                 return -EFAULT;
527
528         err |= __put_user(sig, &frame->sig);
529         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
530         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
531         err |= copy_siginfo_to_user32(&frame->info, info);
532         if (err)
533                 return -EFAULT;
534
535         /* Create the ucontext.  */
536         if (cpu_has_xsave)
537                 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
538         else
539                 err |= __put_user(0, &frame->uc.uc_flags);
540         err |= __put_user(0, &frame->uc.uc_link);
541         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
542         err |= __put_user(sas_ss_flags(regs->sp),
543                           &frame->uc.uc_stack.ss_flags);
544         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
545         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
546                                      regs, set->sig[0]);
547         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
548         if (err)
549                 return -EFAULT;
550
551         if (ka->sa.sa_flags & SA_RESTORER)
552                 restorer = ka->sa.sa_restorer;
553         else
554                 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
555                                          rt_sigreturn);
556         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
557
558         /*
559          * Not actually used anymore, but left because some gdb
560          * versions need it.
561          */
562         err |= __copy_to_user(frame->retcode, &code, 8);
563         if (err)
564                 return -EFAULT;
565
566         /* Set up registers for signal handler */
567         regs->sp = (unsigned long) frame;
568         regs->ip = (unsigned long) ka->sa.sa_handler;
569
570         /* Make -mregparm=3 work */
571         regs->ax = sig;
572         regs->dx = (unsigned long) &frame->info;
573         regs->cx = (unsigned long) &frame->uc;
574
575         loadsegment(ds, __USER32_DS);
576         loadsegment(es, __USER32_DS);
577
578         regs->cs = __USER32_CS;
579         regs->ss = __USER32_DS;
580
581 #if DEBUG_SIG
582         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
583                current->comm, current->pid, frame, regs->ip, frame->pretcode);
584 #endif
585
586         return 0;
587 }