Merge branch 'for-2.6.24' of master.kernel.org:/pub/scm/linux/kernel/git/galak/powerp...
[linux-2.6] / arch / s390 / kernel / compat_signal.c
1 /*
2  *  arch/s390/kernel/compat_signal.c
3  *
4  *    Copyright (C) IBM Corp. 2000,2006
5  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6  *               Gerhard Tonn (ton@de.ibm.com)                  
7  *
8  *  Copyright (C) 1991, 1992  Linus Torvalds
9  *
10  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
11  */
12
13 #include <linux/compat.h>
14 #include <linux/sched.h>
15 #include <linux/mm.h>
16 #include <linux/smp.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/tty.h>
25 #include <linux/personality.h>
26 #include <linux/binfmts.h>
27 #include <asm/ucontext.h>
28 #include <asm/uaccess.h>
29 #include <asm/lowcore.h>
30 #include "compat_linux.h"
31 #include "compat_ptrace.h"
32
33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
34
35 typedef struct 
36 {
37         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
38         struct sigcontext32 sc;
39         _sigregs32 sregs;
40         int signo;
41         __u8 retcode[S390_SYSCALL_SIZE];
42 } sigframe32;
43
44 typedef struct 
45 {
46         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
47         __u8 retcode[S390_SYSCALL_SIZE];
48         compat_siginfo_t info;
49         struct ucontext32 uc;
50 } rt_sigframe32;
51
52 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
53 {
54         int err;
55
56         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
57                 return -EFAULT;
58
59         /* If you change siginfo_t structure, please be sure
60            this code is fixed accordingly.
61            It should never copy any pad contained in the structure
62            to avoid security leaks, but must copy the generic
63            3 ints plus the relevant union member.  
64            This routine must convert siginfo from 64bit to 32bit as well
65            at the same time.  */
66         err = __put_user(from->si_signo, &to->si_signo);
67         err |= __put_user(from->si_errno, &to->si_errno);
68         err |= __put_user((short)from->si_code, &to->si_code);
69         if (from->si_code < 0)
70                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
71         else {
72                 switch (from->si_code >> 16) {
73                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
74                 case __SI_MESGQ >> 16:
75                         err |= __put_user(from->si_int, &to->si_int);
76                         /* fallthrough */
77                 case __SI_KILL >> 16:
78                         err |= __put_user(from->si_pid, &to->si_pid);
79                         err |= __put_user(from->si_uid, &to->si_uid);
80                         break;
81                 case __SI_CHLD >> 16:
82                         err |= __put_user(from->si_pid, &to->si_pid);
83                         err |= __put_user(from->si_uid, &to->si_uid);
84                         err |= __put_user(from->si_utime, &to->si_utime);
85                         err |= __put_user(from->si_stime, &to->si_stime);
86                         err |= __put_user(from->si_status, &to->si_status);
87                         break;
88                 case __SI_FAULT >> 16:
89                         err |= __put_user((unsigned long) from->si_addr,
90                                           &to->si_addr);
91                         break;
92                 case __SI_POLL >> 16:
93                         err |= __put_user(from->si_band, &to->si_band);
94                         err |= __put_user(from->si_fd, &to->si_fd);
95                         break;
96                 case __SI_TIMER >> 16:
97                         err |= __put_user(from->si_tid, &to->si_tid);
98                         err |= __put_user(from->si_overrun, &to->si_overrun);
99                         err |= __put_user(from->si_int, &to->si_int);
100                         break;
101                 default:
102                         break;
103                 }
104         }
105         return err;
106 }
107
108 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
109 {
110         int err;
111         u32 tmp;
112
113         if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
114                 return -EFAULT;
115
116         err = __get_user(to->si_signo, &from->si_signo);
117         err |= __get_user(to->si_errno, &from->si_errno);
118         err |= __get_user(to->si_code, &from->si_code);
119
120         if (to->si_code < 0)
121                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
122         else {
123                 switch (to->si_code >> 16) {
124                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
125                 case __SI_MESGQ >> 16:
126                         err |= __get_user(to->si_int, &from->si_int);
127                         /* fallthrough */
128                 case __SI_KILL >> 16:
129                         err |= __get_user(to->si_pid, &from->si_pid);
130                         err |= __get_user(to->si_uid, &from->si_uid);
131                         break;
132                 case __SI_CHLD >> 16:
133                         err |= __get_user(to->si_pid, &from->si_pid);
134                         err |= __get_user(to->si_uid, &from->si_uid);
135                         err |= __get_user(to->si_utime, &from->si_utime);
136                         err |= __get_user(to->si_stime, &from->si_stime);
137                         err |= __get_user(to->si_status, &from->si_status);
138                         break;
139                 case __SI_FAULT >> 16:
140                         err |= __get_user(tmp, &from->si_addr);
141                         to->si_addr = (void __user *)(u64) (tmp & PSW32_ADDR_INSN);
142                         break;
143                 case __SI_POLL >> 16:
144                         err |= __get_user(to->si_band, &from->si_band);
145                         err |= __get_user(to->si_fd, &from->si_fd);
146                         break;
147                 case __SI_TIMER >> 16:
148                         err |= __get_user(to->si_tid, &from->si_tid);
149                         err |= __get_user(to->si_overrun, &from->si_overrun);
150                         err |= __get_user(to->si_int, &from->si_int);
151                         break;
152                 default:
153                         break;
154                 }
155         }
156         return err;
157 }
158
159 asmlinkage long
160 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
161                  struct old_sigaction32 __user *oact)
162 {
163         struct k_sigaction new_ka, old_ka;
164         unsigned long sa_handler, sa_restorer;
165         int ret;
166
167         if (act) {
168                 compat_old_sigset_t mask;
169                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
170                     __get_user(sa_handler, &act->sa_handler) ||
171                     __get_user(sa_restorer, &act->sa_restorer) ||
172                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
173                     __get_user(mask, &act->sa_mask))
174                         return -EFAULT;
175                 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
176                 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
177                 siginitset(&new_ka.sa.sa_mask, mask);
178         }
179
180         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
181
182         if (!ret && oact) {
183                 sa_handler = (unsigned long) old_ka.sa.sa_handler;
184                 sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
185                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
186                     __put_user(sa_handler, &oact->sa_handler) ||
187                     __put_user(sa_restorer, &oact->sa_restorer) ||
188                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
189                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
190                         return -EFAULT;
191         }
192
193         return ret;
194 }
195
196 asmlinkage long
197 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
198            struct sigaction32 __user *oact,  size_t sigsetsize)
199 {
200         struct k_sigaction new_ka, old_ka;
201         unsigned long sa_handler;
202         int ret;
203         compat_sigset_t set32;
204
205         /* XXX: Don't preclude handling different sized sigset_t's.  */
206         if (sigsetsize != sizeof(compat_sigset_t))
207                 return -EINVAL;
208
209         if (act) {
210                 ret = get_user(sa_handler, &act->sa_handler);
211                 ret |= __copy_from_user(&set32, &act->sa_mask,
212                                         sizeof(compat_sigset_t));
213                 switch (_NSIG_WORDS) {
214                 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
215                                 | (((long)set32.sig[7]) << 32);
216                 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
217                                 | (((long)set32.sig[5]) << 32);
218                 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
219                                 | (((long)set32.sig[3]) << 32);
220                 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
221                                 | (((long)set32.sig[1]) << 32);
222                 }
223                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
224                 
225                 if (ret)
226                         return -EFAULT;
227                 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
228         }
229
230         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
231
232         if (!ret && oact) {
233                 switch (_NSIG_WORDS) {
234                 case 4:
235                         set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
236                         set32.sig[6] = old_ka.sa.sa_mask.sig[3];
237                 case 3:
238                         set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
239                         set32.sig[4] = old_ka.sa.sa_mask.sig[2];
240                 case 2:
241                         set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
242                         set32.sig[2] = old_ka.sa.sa_mask.sig[1];
243                 case 1:
244                         set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
245                         set32.sig[0] = old_ka.sa.sa_mask.sig[0];
246                 }
247                 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
248                 ret |= __copy_to_user(&oact->sa_mask, &set32,
249                                       sizeof(compat_sigset_t));
250                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
251         }
252
253         return ret;
254 }
255
256 asmlinkage long
257 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss)
258 {
259         struct pt_regs *regs = task_pt_regs(current);
260         stack_t kss, koss;
261         unsigned long ss_sp;
262         int ret, err = 0;
263         mm_segment_t old_fs = get_fs();
264
265         if (uss) {
266                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
267                         return -EFAULT;
268                 err |= __get_user(ss_sp, &uss->ss_sp);
269                 err |= __get_user(kss.ss_size, &uss->ss_size);
270                 err |= __get_user(kss.ss_flags, &uss->ss_flags);
271                 if (err)
272                         return -EFAULT;
273                 kss.ss_sp = (void __user *) ss_sp;
274         }
275
276         set_fs (KERNEL_DS);
277         ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
278                              (stack_t __force __user *) (uoss ? &koss : NULL),
279                              regs->gprs[15]);
280         set_fs (old_fs);
281
282         if (!ret && uoss) {
283                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
284                         return -EFAULT;
285                 ss_sp = (unsigned long) koss.ss_sp;
286                 err |= __put_user(ss_sp, &uoss->ss_sp);
287                 err |= __put_user(koss.ss_size, &uoss->ss_size);
288                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
289                 if (err)
290                         return -EFAULT;
291         }
292         return ret;
293 }
294
295 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
296 {
297         _s390_regs_common32 regs32;
298         int err, i;
299
300         regs32.psw.mask = PSW32_MASK_MERGE(psw32_user_bits,
301                                            (__u32)(regs->psw.mask >> 32));
302         regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
303         for (i = 0; i < NUM_GPRS; i++)
304                 regs32.gprs[i] = (__u32) regs->gprs[i];
305         save_access_regs(current->thread.acrs);
306         memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
307         err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
308         if (err)
309                 return err;
310         save_fp_regs(&current->thread.fp_regs);
311         /* s390_fp_regs and _s390_fp_regs32 are the same ! */
312         return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
313                               sizeof(_s390_fp_regs32));
314 }
315
316 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
317 {
318         _s390_regs_common32 regs32;
319         int err, i;
320
321         /* Alwys make any pending restarted system call return -EINTR */
322         current_thread_info()->restart_block.fn = do_no_restart_syscall;
323
324         err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
325         if (err)
326                 return err;
327         regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
328                                         (__u64)regs32.psw.mask << 32);
329         regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
330         for (i = 0; i < NUM_GPRS; i++)
331                 regs->gprs[i] = (__u64) regs32.gprs[i];
332         memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
333         restore_access_regs(current->thread.acrs);
334
335         err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
336                                sizeof(_s390_fp_regs32));
337         current->thread.fp_regs.fpc &= FPC_VALID_MASK;
338         if (err)
339                 return err;
340
341         restore_fp_regs(&current->thread.fp_regs);
342         regs->trap = -1;        /* disable syscall checks */
343         return 0;
344 }
345
346 asmlinkage long sys32_sigreturn(void)
347 {
348         struct pt_regs *regs = task_pt_regs(current);
349         sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
350         sigset_t set;
351
352         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
353                 goto badframe;
354         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
355                 goto badframe;
356
357         sigdelsetmask(&set, ~_BLOCKABLE);
358         spin_lock_irq(&current->sighand->siglock);
359         current->blocked = set;
360         recalc_sigpending();
361         spin_unlock_irq(&current->sighand->siglock);
362
363         if (restore_sigregs32(regs, &frame->sregs))
364                 goto badframe;
365
366         return regs->gprs[2];
367
368 badframe:
369         force_sig(SIGSEGV, current);
370         return 0;
371 }
372
373 asmlinkage long sys32_rt_sigreturn(void)
374 {
375         struct pt_regs *regs = task_pt_regs(current);
376         rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
377         sigset_t set;
378         stack_t st;
379         __u32 ss_sp;
380         int err;
381         mm_segment_t old_fs = get_fs();
382
383         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
384                 goto badframe;
385         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
386                 goto badframe;
387
388         sigdelsetmask(&set, ~_BLOCKABLE);
389         spin_lock_irq(&current->sighand->siglock);
390         current->blocked = set;
391         recalc_sigpending();
392         spin_unlock_irq(&current->sighand->siglock);
393
394         if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
395                 goto badframe;
396
397         err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
398         st.ss_sp = compat_ptr(ss_sp);
399         err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
400         err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
401         if (err)
402                 goto badframe; 
403
404         set_fs (KERNEL_DS);
405         do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
406         set_fs (old_fs);
407
408         return regs->gprs[2];
409
410 badframe:
411         force_sig(SIGSEGV, current);
412         return 0;
413 }       
414
415 /*
416  * Set up a signal frame.
417  */
418
419
420 /*
421  * Determine which stack to use..
422  */
423 static inline void __user *
424 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
425 {
426         unsigned long sp;
427
428         /* Default to using normal stack */
429         sp = (unsigned long) A(regs->gprs[15]);
430
431         /* This is the X/Open sanctioned signal stack switching.  */
432         if (ka->sa.sa_flags & SA_ONSTACK) {
433                 if (! sas_ss_flags(sp))
434                         sp = current->sas_ss_sp + current->sas_ss_size;
435         }
436
437         /* This is the legacy signal stack switching. */
438         else if (!user_mode(regs) &&
439                  !(ka->sa.sa_flags & SA_RESTORER) &&
440                  ka->sa.sa_restorer) {
441                 sp = (unsigned long) ka->sa.sa_restorer;
442         }
443
444         return (void __user *)((sp - frame_size) & -8ul);
445 }
446
447 static inline int map_signal(int sig)
448 {
449         if (current_thread_info()->exec_domain
450             && current_thread_info()->exec_domain->signal_invmap
451             && sig < 32)
452                 return current_thread_info()->exec_domain->signal_invmap[sig];
453         else
454                 return sig;
455 }
456
457 static int setup_frame32(int sig, struct k_sigaction *ka,
458                         sigset_t *set, struct pt_regs * regs)
459 {
460         sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
461         if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
462                 goto give_sigsegv;
463
464         if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
465                 goto give_sigsegv;
466
467         if (save_sigregs32(regs, &frame->sregs))
468                 goto give_sigsegv;
469         if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
470                 goto give_sigsegv;
471
472         /* Set up to return from userspace.  If provided, use a stub
473            already in userspace.  */
474         if (ka->sa.sa_flags & SA_RESTORER) {
475                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
476         } else {
477                 regs->gprs[14] = (__u64) frame->retcode;
478                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
479                                (u16 __user *)(frame->retcode)))
480                         goto give_sigsegv;
481         }
482
483         /* Set up backchain. */
484         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
485                 goto give_sigsegv;
486
487         /* Set up registers for signal handler */
488         regs->gprs[15] = (__u64) frame;
489         regs->psw.addr = (__u64) ka->sa.sa_handler;
490
491         regs->gprs[2] = map_signal(sig);
492         regs->gprs[3] = (__u64) &frame->sc;
493
494         /* We forgot to include these in the sigcontext.
495            To avoid breaking binary compatibility, they are passed as args. */
496         regs->gprs[4] = current->thread.trap_no;
497         regs->gprs[5] = current->thread.prot_addr;
498
499         /* Place signal number on stack to allow backtrace from handler.  */
500         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
501                 goto give_sigsegv;
502         return 0;
503
504 give_sigsegv:
505         force_sigsegv(sig, current);
506         return -EFAULT;
507 }
508
509 static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
510                            sigset_t *set, struct pt_regs * regs)
511 {
512         int err = 0;
513         rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
514         if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
515                 goto give_sigsegv;
516
517         if (copy_siginfo_to_user32(&frame->info, info))
518                 goto give_sigsegv;
519
520         /* Create the ucontext.  */
521         err |= __put_user(0, &frame->uc.uc_flags);
522         err |= __put_user(0, &frame->uc.uc_link);
523         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
524         err |= __put_user(sas_ss_flags(regs->gprs[15]),
525                           &frame->uc.uc_stack.ss_flags);
526         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
527         err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
528         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
529         if (err)
530                 goto give_sigsegv;
531
532         /* Set up to return from userspace.  If provided, use a stub
533            already in userspace.  */
534         if (ka->sa.sa_flags & SA_RESTORER) {
535                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
536         } else {
537                 regs->gprs[14] = (__u64) frame->retcode;
538                 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
539                                   (u16 __user *)(frame->retcode));
540         }
541
542         /* Set up backchain. */
543         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
544                 goto give_sigsegv;
545
546         /* Set up registers for signal handler */
547         regs->gprs[15] = (__u64) frame;
548         regs->psw.addr = (__u64) ka->sa.sa_handler;
549
550         regs->gprs[2] = map_signal(sig);
551         regs->gprs[3] = (__u64) &frame->info;
552         regs->gprs[4] = (__u64) &frame->uc;
553         return 0;
554
555 give_sigsegv:
556         force_sigsegv(sig, current);
557         return -EFAULT;
558 }
559
560 /*
561  * OK, we're invoking a handler
562  */     
563
564 int
565 handle_signal32(unsigned long sig, struct k_sigaction *ka,
566                 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
567 {
568         int ret;
569
570         /* Set up the stack frame */
571         if (ka->sa.sa_flags & SA_SIGINFO)
572                 ret = setup_rt_frame32(sig, ka, info, oldset, regs);
573         else
574                 ret = setup_frame32(sig, ka, oldset, regs);
575
576         if (ret == 0) {
577                 spin_lock_irq(&current->sighand->siglock);
578                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
579                 if (!(ka->sa.sa_flags & SA_NODEFER))
580                         sigaddset(&current->blocked,sig);
581                 recalc_sigpending();
582                 spin_unlock_irq(&current->sighand->siglock);
583         }
584         return ret;
585 }
586