x86: ia32_signal: introduce COPY_SEG_CPL3
[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         err |= __get_user(regs->x, &sc->x);     \
202 }
203
204 #define COPY_SEG_CPL3(seg)      {                       \
205                 unsigned short tmp;                     \
206                 err |= __get_user(tmp, &sc->seg);       \
207                 regs->seg = tmp | 3;                    \
208 }
209
210 #define RELOAD_SEG(seg,mask)                                            \
211         { unsigned int cur;                                             \
212           unsigned short pre;                                           \
213           err |= __get_user(pre, &sc->seg);                             \
214           savesegment(seg, cur);                                        \
215           pre |= mask;                                                  \
216           if (pre != cur) loadsegment(seg, pre); }
217
218 static int ia32_restore_sigcontext(struct pt_regs *regs,
219                                    struct sigcontext_ia32 __user *sc,
220                                    unsigned int *peax)
221 {
222         unsigned int tmpflags, gs, oldgs, err = 0;
223         void __user *buf;
224         u32 tmp;
225
226         /* Always make any pending restarted system calls return -EINTR */
227         current_thread_info()->restart_block.fn = do_no_restart_syscall;
228
229 #if DEBUG_SIG
230         printk(KERN_DEBUG "SIG restore_sigcontext: "
231                "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
232                sc, sc->err, sc->ip, sc->cs, sc->flags);
233 #endif
234
235         /*
236          * Reload fs and gs if they have changed in the signal
237          * handler.  This does not handle long fs/gs base changes in
238          * the handler, but does not clobber them at least in the
239          * normal case.
240          */
241         err |= __get_user(gs, &sc->gs);
242         gs |= 3;
243         savesegment(gs, oldgs);
244         if (gs != oldgs)
245                 load_gs_index(gs);
246
247         RELOAD_SEG(fs, 3);
248         RELOAD_SEG(ds, 3);
249         RELOAD_SEG(es, 3);
250
251         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
252         COPY(dx); COPY(cx); COPY(ip);
253         /* Don't touch extended registers */
254
255         COPY_SEG_CPL3(cs);
256         COPY_SEG_CPL3(ss);
257
258         err |= __get_user(tmpflags, &sc->flags);
259         regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
260         /* disable syscall checks */
261         regs->orig_ax = -1;
262
263         err |= __get_user(tmp, &sc->fpstate);
264         buf = compat_ptr(tmp);
265         err |= restore_i387_xstate_ia32(buf);
266
267         err |= __get_user(tmp, &sc->ax);
268         *peax = tmp;
269
270         return err;
271 }
272
273 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
274 {
275         struct sigframe __user *frame = (struct sigframe __user *)(regs->sp-8);
276         sigset_t set;
277         unsigned int ax;
278
279         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
280                 goto badframe;
281         if (__get_user(set.sig[0], &frame->sc.oldmask)
282             || (_COMPAT_NSIG_WORDS > 1
283                 && __copy_from_user((((char *) &set.sig) + 4),
284                                     &frame->extramask,
285                                     sizeof(frame->extramask))))
286                 goto badframe;
287
288         sigdelsetmask(&set, ~_BLOCKABLE);
289         spin_lock_irq(&current->sighand->siglock);
290         current->blocked = set;
291         recalc_sigpending();
292         spin_unlock_irq(&current->sighand->siglock);
293
294         if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
295                 goto badframe;
296         return ax;
297
298 badframe:
299         signal_fault(regs, frame, "32bit sigreturn");
300         return 0;
301 }
302
303 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
304 {
305         struct rt_sigframe __user *frame;
306         sigset_t set;
307         unsigned int ax;
308         struct pt_regs tregs;
309
310         frame = (struct rt_sigframe __user *)(regs->sp - 4);
311
312         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
313                 goto badframe;
314         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
315                 goto badframe;
316
317         sigdelsetmask(&set, ~_BLOCKABLE);
318         spin_lock_irq(&current->sighand->siglock);
319         current->blocked = set;
320         recalc_sigpending();
321         spin_unlock_irq(&current->sighand->siglock);
322
323         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
324                 goto badframe;
325
326         tregs = *regs;
327         if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
328                 goto badframe;
329
330         return ax;
331
332 badframe:
333         signal_fault(regs, frame, "32bit rt sigreturn");
334         return 0;
335 }
336
337 /*
338  * Set up a signal frame.
339  */
340
341 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
342                                  void __user *fpstate,
343                                  struct pt_regs *regs, unsigned int mask)
344 {
345         int tmp, err = 0;
346
347         savesegment(gs, tmp);
348         err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
349         savesegment(fs, tmp);
350         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
351         savesegment(ds, tmp);
352         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
353         savesegment(es, tmp);
354         err |= __put_user(tmp, (unsigned int __user *)&sc->es);
355
356         err |= __put_user(regs->di, &sc->di);
357         err |= __put_user(regs->si, &sc->si);
358         err |= __put_user(regs->bp, &sc->bp);
359         err |= __put_user(regs->sp, &sc->sp);
360         err |= __put_user(regs->bx, &sc->bx);
361         err |= __put_user(regs->dx, &sc->dx);
362         err |= __put_user(regs->cx, &sc->cx);
363         err |= __put_user(regs->ax, &sc->ax);
364         err |= __put_user(regs->cs, &sc->cs);
365         err |= __put_user(regs->ss, &sc->ss);
366         err |= __put_user(current->thread.trap_no, &sc->trapno);
367         err |= __put_user(current->thread.error_code, &sc->err);
368         err |= __put_user(regs->ip, &sc->ip);
369         err |= __put_user(regs->flags, &sc->flags);
370         err |= __put_user(regs->sp, &sc->sp_at_signal);
371
372         err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
373
374         /* non-iBCS2 extensions.. */
375         err |= __put_user(mask, &sc->oldmask);
376         err |= __put_user(current->thread.cr2, &sc->cr2);
377
378         return err;
379 }
380
381 /*
382  * Determine which stack to use..
383  */
384 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
385                                  size_t frame_size,
386                                  void **fpstate)
387 {
388         unsigned long sp;
389
390         /* Default to using normal stack */
391         sp = regs->sp;
392
393         /* This is the X/Open sanctioned signal stack switching.  */
394         if (ka->sa.sa_flags & SA_ONSTACK) {
395                 if (sas_ss_flags(sp) == 0)
396                         sp = current->sas_ss_sp + current->sas_ss_size;
397         }
398
399         /* This is the legacy signal stack switching. */
400         else if ((regs->ss & 0xffff) != __USER_DS &&
401                 !(ka->sa.sa_flags & SA_RESTORER) &&
402                  ka->sa.sa_restorer)
403                 sp = (unsigned long) ka->sa.sa_restorer;
404
405         if (used_math()) {
406                 sp = sp - sig_xstate_ia32_size;
407                 *fpstate = (struct _fpstate_ia32 *) sp;
408                 if (save_i387_xstate_ia32(*fpstate) < 0)
409                         return (void __user *) -1L;
410         }
411
412         sp -= frame_size;
413         /* Align the stack pointer according to the i386 ABI,
414          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
415         sp = ((sp + 4) & -16ul) - 4;
416         return (void __user *) sp;
417 }
418
419 int ia32_setup_frame(int sig, struct k_sigaction *ka,
420                      compat_sigset_t *set, struct pt_regs *regs)
421 {
422         struct sigframe __user *frame;
423         void __user *restorer;
424         int err = 0;
425         void __user *fpstate = NULL;
426
427         /* copy_to_user optimizes that into a single 8 byte store */
428         static const struct {
429                 u16 poplmovl;
430                 u32 val;
431                 u16 int80;
432         } __attribute__((packed)) code = {
433                 0xb858,          /* popl %eax ; movl $...,%eax */
434                 __NR_ia32_sigreturn,
435                 0x80cd,         /* int $0x80 */
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                 u8  pad;
512         } __attribute__((packed)) code = {
513                 0xb8,
514                 __NR_ia32_rt_sigreturn,
515                 0x80cd,
516                 0,
517         };
518
519         frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
520
521         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
522                 return -EFAULT;
523
524         err |= __put_user(sig, &frame->sig);
525         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
526         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
527         err |= copy_siginfo_to_user32(&frame->info, info);
528         if (err)
529                 return -EFAULT;
530
531         /* Create the ucontext.  */
532         if (cpu_has_xsave)
533                 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
534         else
535                 err |= __put_user(0, &frame->uc.uc_flags);
536         err |= __put_user(0, &frame->uc.uc_link);
537         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
538         err |= __put_user(sas_ss_flags(regs->sp),
539                           &frame->uc.uc_stack.ss_flags);
540         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
541         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
542                                      regs, set->sig[0]);
543         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
544         if (err)
545                 return -EFAULT;
546
547         if (ka->sa.sa_flags & SA_RESTORER)
548                 restorer = ka->sa.sa_restorer;
549         else
550                 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
551                                          rt_sigreturn);
552         err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
553
554         /*
555          * Not actually used anymore, but left because some gdb
556          * versions need it.
557          */
558         err |= __copy_to_user(frame->retcode, &code, 8);
559         if (err)
560                 return -EFAULT;
561
562         /* Set up registers for signal handler */
563         regs->sp = (unsigned long) frame;
564         regs->ip = (unsigned long) ka->sa.sa_handler;
565
566         /* Make -mregparm=3 work */
567         regs->ax = sig;
568         regs->dx = (unsigned long) &frame->info;
569         regs->cx = (unsigned long) &frame->uc;
570
571         /* Make -mregparm=3 work */
572         regs->ax = sig;
573         regs->dx = (unsigned long) &frame->info;
574         regs->cx = (unsigned long) &frame->uc;
575
576         loadsegment(ds, __USER32_DS);
577         loadsegment(es, __USER32_DS);
578
579         regs->cs = __USER32_CS;
580         regs->ss = __USER32_DS;
581
582 #if DEBUG_SIG
583         printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
584                current->comm, current->pid, frame, regs->ip, frame->pretcode);
585 #endif
586
587         return 0;
588 }