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