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