Merge branch 'i2c-next' of git://aeryn.fluff.org.uk/bjdooks/linux
[linux-2.6] / 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/ptrace.h>
28 #include <asm/ia32_unistd.h>
29 #include <asm/user32.h>
30 #include <asm/sigcontext32.h>
31 #include <asm/proto.h>
32 #include <asm/vdso.h>
33 #include <asm/sigframe.h>
34 #include <asm/sys_ia32.h>
35
36 #define DEBUG_SIG 0
37
38 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
39
40 #define FIX_EFLAGS      (X86_EFLAGS_AC | X86_EFLAGS_OF | \
41                          X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \
42                          X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \
43                          X86_EFLAGS_CF)
44
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 #define COPY(x)                 {               \
177         err |= __get_user(regs->x, &sc->x);     \
178 }
179
180 #define COPY_SEG_CPL3(seg)      {                       \
181                 unsigned short tmp;                     \
182                 err |= __get_user(tmp, &sc->seg);       \
183                 regs->seg = tmp | 3;                    \
184 }
185
186 #define RELOAD_SEG(seg)         {               \
187         unsigned int cur, pre;                  \
188         err |= __get_user(pre, &sc->seg);       \
189         savesegment(seg, cur);                  \
190         pre |= 3;                               \
191         if (pre != cur)                         \
192                 loadsegment(seg, pre);          \
193 }
194
195 static int ia32_restore_sigcontext(struct pt_regs *regs,
196                                    struct sigcontext_ia32 __user *sc,
197                                    unsigned int *pax)
198 {
199         unsigned int tmpflags, gs, oldgs, err = 0;
200         void __user *buf;
201         u32 tmp;
202
203         /* Always make any pending restarted system calls return -EINTR */
204         current_thread_info()->restart_block.fn = do_no_restart_syscall;
205
206 #if DEBUG_SIG
207         printk(KERN_DEBUG "SIG restore_sigcontext: "
208                "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
209                sc, sc->err, sc->ip, sc->cs, sc->flags);
210 #endif
211
212         /*
213          * Reload fs and gs if they have changed in the signal
214          * handler.  This does not handle long fs/gs base changes in
215          * the handler, but does not clobber them at least in the
216          * normal case.
217          */
218         err |= __get_user(gs, &sc->gs);
219         gs |= 3;
220         savesegment(gs, oldgs);
221         if (gs != oldgs)
222                 load_gs_index(gs);
223
224         RELOAD_SEG(fs);
225         RELOAD_SEG(ds);
226         RELOAD_SEG(es);
227
228         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
229         COPY(dx); COPY(cx); COPY(ip);
230         /* Don't touch extended registers */
231
232         COPY_SEG_CPL3(cs);
233         COPY_SEG_CPL3(ss);
234
235         err |= __get_user(tmpflags, &sc->flags);
236         regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
237         /* disable syscall checks */
238         regs->orig_ax = -1;
239
240         err |= __get_user(tmp, &sc->fpstate);
241         buf = compat_ptr(tmp);
242         err |= restore_i387_xstate_ia32(buf);
243
244         err |= __get_user(*pax, &sc->ax);
245         return err;
246 }
247
248 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
249 {
250         struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
251         sigset_t set;
252         unsigned int ax;
253
254         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
255                 goto badframe;
256         if (__get_user(set.sig[0], &frame->sc.oldmask)
257             || (_COMPAT_NSIG_WORDS > 1
258                 && __copy_from_user((((char *) &set.sig) + 4),
259                                     &frame->extramask,
260                                     sizeof(frame->extramask))))
261                 goto badframe;
262
263         sigdelsetmask(&set, ~_BLOCKABLE);
264         spin_lock_irq(&current->sighand->siglock);
265         current->blocked = set;
266         recalc_sigpending();
267         spin_unlock_irq(&current->sighand->siglock);
268
269         if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
270                 goto badframe;
271         return ax;
272
273 badframe:
274         signal_fault(regs, frame, "32bit sigreturn");
275         return 0;
276 }
277
278 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
279 {
280         struct rt_sigframe_ia32 __user *frame;
281         sigset_t set;
282         unsigned int ax;
283         struct pt_regs tregs;
284
285         frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
286
287         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
288                 goto badframe;
289         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
290                 goto badframe;
291
292         sigdelsetmask(&set, ~_BLOCKABLE);
293         spin_lock_irq(&current->sighand->siglock);
294         current->blocked = set;
295         recalc_sigpending();
296         spin_unlock_irq(&current->sighand->siglock);
297
298         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
299                 goto badframe;
300
301         tregs = *regs;
302         if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
303                 goto badframe;
304
305         return ax;
306
307 badframe:
308         signal_fault(regs, frame, "32bit rt sigreturn");
309         return 0;
310 }
311
312 /*
313  * Set up a signal frame.
314  */
315
316 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
317                                  void __user *fpstate,
318                                  struct pt_regs *regs, unsigned int mask)
319 {
320         int tmp, err = 0;
321
322         savesegment(gs, tmp);
323         err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
324         savesegment(fs, tmp);
325         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
326         savesegment(ds, tmp);
327         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
328         savesegment(es, tmp);
329         err |= __put_user(tmp, (unsigned int __user *)&sc->es);
330
331         err |= __put_user(regs->di, &sc->di);
332         err |= __put_user(regs->si, &sc->si);
333         err |= __put_user(regs->bp, &sc->bp);
334         err |= __put_user(regs->sp, &sc->sp);
335         err |= __put_user(regs->bx, &sc->bx);
336         err |= __put_user(regs->dx, &sc->dx);
337         err |= __put_user(regs->cx, &sc->cx);
338         err |= __put_user(regs->ax, &sc->ax);
339         err |= __put_user(current->thread.trap_no, &sc->trapno);
340         err |= __put_user(current->thread.error_code, &sc->err);
341         err |= __put_user(regs->ip, &sc->ip);
342         err |= __put_user(regs->cs, (unsigned int __user *)&sc->cs);
343         err |= __put_user(regs->flags, &sc->flags);
344         err |= __put_user(regs->sp, &sc->sp_at_signal);
345         err |= __put_user(regs->ss, (unsigned int __user *)&sc->ss);
346
347         err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
348
349         /* non-iBCS2 extensions.. */
350         err |= __put_user(mask, &sc->oldmask);
351         err |= __put_user(current->thread.cr2, &sc->cr2);
352
353         return err;
354 }
355
356 /*
357  * Determine which stack to use..
358  */
359 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
360                                  size_t frame_size,
361                                  void **fpstate)
362 {
363         unsigned long sp;
364
365         /* Default to using normal stack */
366         sp = regs->sp;
367
368         /* This is the X/Open sanctioned signal stack switching.  */
369         if (ka->sa.sa_flags & SA_ONSTACK) {
370                 if (sas_ss_flags(sp) == 0)
371                         sp = current->sas_ss_sp + current->sas_ss_size;
372         }
373
374         /* This is the legacy signal stack switching. */
375         else if ((regs->ss & 0xffff) != __USER32_DS &&
376                 !(ka->sa.sa_flags & SA_RESTORER) &&
377                  ka->sa.sa_restorer)
378                 sp = (unsigned long) ka->sa.sa_restorer;
379
380         if (used_math()) {
381                 sp = sp - sig_xstate_ia32_size;
382                 *fpstate = (struct _fpstate_ia32 *) sp;
383                 if (save_i387_xstate_ia32(*fpstate) < 0)
384                         return (void __user *) -1L;
385         }
386
387         sp -= frame_size;
388         /* Align the stack pointer according to the i386 ABI,
389          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
390         sp = ((sp + 4) & -16ul) - 4;
391         return (void __user *) sp;
392 }
393
394 int ia32_setup_frame(int sig, struct k_sigaction *ka,
395                      compat_sigset_t *set, struct pt_regs *regs)
396 {
397         struct sigframe_ia32 __user *frame;
398         void __user *restorer;
399         int err = 0;
400         void __user *fpstate = NULL;
401
402         /* copy_to_user optimizes that into a single 8 byte store */
403         static const struct {
404                 u16 poplmovl;
405                 u32 val;
406                 u16 int80;
407         } __attribute__((packed)) code = {
408                 0xb858,          /* popl %eax ; movl $...,%eax */
409                 __NR_ia32_sigreturn,
410                 0x80cd,         /* int $0x80 */
411         };
412
413         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
414
415         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
416                 return -EFAULT;
417
418         if (__put_user(sig, &frame->sig))
419                 return -EFAULT;
420
421         if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
422                 return -EFAULT;
423
424         if (_COMPAT_NSIG_WORDS > 1) {
425                 if (__copy_to_user(frame->extramask, &set->sig[1],
426                                    sizeof(frame->extramask)))
427                         return -EFAULT;
428         }
429
430         if (ka->sa.sa_flags & SA_RESTORER) {
431                 restorer = ka->sa.sa_restorer;
432         } else {
433                 /* Return stub is in 32bit vsyscall page */
434                 if (current->mm->context.vdso)
435                         restorer = VDSO32_SYMBOL(current->mm->context.vdso,
436                                                  sigreturn);
437                 else
438                         restorer = &frame->retcode;
439         }
440         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
441
442         /*
443          * These are actually not used anymore, but left because some
444          * gdb versions depend on them as a marker.
445          */
446         err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);
447         if (err)
448                 return -EFAULT;
449
450         /* Set up registers for signal handler */
451         regs->sp = (unsigned long) frame;
452         regs->ip = (unsigned long) ka->sa.sa_handler;
453
454         /* Make -mregparm=3 work */
455         regs->ax = sig;
456         regs->dx = 0;
457         regs->cx = 0;
458
459         loadsegment(ds, __USER32_DS);
460         loadsegment(es, __USER32_DS);
461
462         regs->cs = __USER32_CS;
463         regs->ss = __USER32_DS;
464
465 #if DEBUG_SIG
466         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
467                current->comm, current->pid, frame, regs->ip, frame->pretcode);
468 #endif
469
470         return 0;
471 }
472
473 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
474                         compat_sigset_t *set, struct pt_regs *regs)
475 {
476         struct rt_sigframe_ia32 __user *frame;
477         void __user *restorer;
478         int err = 0;
479         void __user *fpstate = NULL;
480
481         /* __copy_to_user optimizes that into a single 8 byte store */
482         static const struct {
483                 u8 movl;
484                 u32 val;
485                 u16 int80;
486                 u8  pad;
487         } __attribute__((packed)) code = {
488                 0xb8,
489                 __NR_ia32_rt_sigreturn,
490                 0x80cd,
491                 0,
492         };
493
494         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
495
496         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
497                 return -EFAULT;
498
499         err |= __put_user(sig, &frame->sig);
500         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
501         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
502         err |= copy_siginfo_to_user32(&frame->info, info);
503         if (err)
504                 return -EFAULT;
505
506         /* Create the ucontext.  */
507         if (cpu_has_xsave)
508                 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
509         else
510                 err |= __put_user(0, &frame->uc.uc_flags);
511         err |= __put_user(0, &frame->uc.uc_link);
512         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
513         err |= __put_user(sas_ss_flags(regs->sp),
514                           &frame->uc.uc_stack.ss_flags);
515         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
516         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
517                                      regs, set->sig[0]);
518         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
519         if (err)
520                 return -EFAULT;
521
522         if (ka->sa.sa_flags & SA_RESTORER)
523                 restorer = ka->sa.sa_restorer;
524         else
525                 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
526                                          rt_sigreturn);
527         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
528
529         /*
530          * Not actually used anymore, but left because some gdb
531          * versions need it.
532          */
533         err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);
534         if (err)
535                 return -EFAULT;
536
537         /* Set up registers for signal handler */
538         regs->sp = (unsigned long) frame;
539         regs->ip = (unsigned long) ka->sa.sa_handler;
540
541         /* Make -mregparm=3 work */
542         regs->ax = sig;
543         regs->dx = (unsigned long) &frame->info;
544         regs->cx = (unsigned long) &frame->uc;
545
546         loadsegment(ds, __USER32_DS);
547         loadsegment(es, __USER32_DS);
548
549         regs->cs = __USER32_CS;
550         regs->ss = __USER32_DS;
551
552 #if DEBUG_SIG
553         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
554                current->comm, current->pid, frame, regs->ip, frame->pretcode);
555 #endif
556
557         return 0;
558 }