Merge branch 'upstream' of git://git.linux-mips.org/pub/scm/ralf/upstream-linus
[~shefty/rdma-dev.git] / arch / mips / kernel / signal32.c
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Copyright (C) 1991, 1992  Linus Torvalds
7  * Copyright (C) 1994 - 2000, 2006  Ralf Baechle
8  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
9  */
10 #include <linux/cache.h>
11 #include <linux/compat.h>
12 #include <linux/sched.h>
13 #include <linux/mm.h>
14 #include <linux/smp.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/syscalls.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/ptrace.h>
21 #include <linux/suspend.h>
22 #include <linux/compiler.h>
23 #include <linux/uaccess.h>
24
25 #include <asm/abi.h>
26 #include <asm/asm.h>
27 #include <asm/compat-signal.h>
28 #include <linux/bitops.h>
29 #include <asm/cacheflush.h>
30 #include <asm/sim.h>
31 #include <asm/ucontext.h>
32 #include <asm/fpu.h>
33 #include <asm/war.h>
34 #include <asm/vdso.h>
35 #include <asm/dsp.h>
36
37 #include "signal-common.h"
38
39 static int (*save_fp_context32)(struct sigcontext32 __user *sc);
40 static int (*restore_fp_context32)(struct sigcontext32 __user *sc);
41
42 extern asmlinkage int _save_fp_context32(struct sigcontext32 __user *sc);
43 extern asmlinkage int _restore_fp_context32(struct sigcontext32 __user *sc);
44
45 extern asmlinkage int fpu_emulator_save_context32(struct sigcontext32 __user *sc);
46 extern asmlinkage int fpu_emulator_restore_context32(struct sigcontext32 __user *sc);
47
48 /*
49  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
50  */
51 #define __NR_O32_restart_syscall        4253
52
53 /* 32-bit compatibility types */
54
55 typedef unsigned int __sighandler32_t;
56 typedef void (*vfptr_t)(void);
57
58 struct ucontext32 {
59         u32                 uc_flags;
60         s32                 uc_link;
61         compat_stack_t      uc_stack;
62         struct sigcontext32 uc_mcontext;
63         compat_sigset_t     uc_sigmask;   /* mask last for extensibility */
64 };
65
66 struct sigframe32 {
67         u32 sf_ass[4];          /* argument save space for o32 */
68         u32 sf_pad[2];          /* Was: signal trampoline */
69         struct sigcontext32 sf_sc;
70         compat_sigset_t sf_mask;
71 };
72
73 struct rt_sigframe32 {
74         u32 rs_ass[4];                  /* argument save space for o32 */
75         u32 rs_pad[2];                  /* Was: signal trampoline */
76         compat_siginfo_t rs_info;
77         struct ucontext32 rs_uc;
78 };
79
80 /*
81  * sigcontext handlers
82  */
83 static int protected_save_fp_context32(struct sigcontext32 __user *sc)
84 {
85         int err;
86         while (1) {
87                 lock_fpu_owner();
88                 own_fpu_inatomic(1);
89                 err = save_fp_context32(sc); /* this might fail */
90                 unlock_fpu_owner();
91                 if (likely(!err))
92                         break;
93                 /* touch the sigcontext and try again */
94                 err = __put_user(0, &sc->sc_fpregs[0]) |
95                         __put_user(0, &sc->sc_fpregs[31]) |
96                         __put_user(0, &sc->sc_fpc_csr);
97                 if (err)
98                         break;  /* really bad sigcontext */
99         }
100         return err;
101 }
102
103 static int protected_restore_fp_context32(struct sigcontext32 __user *sc)
104 {
105         int err, tmp __maybe_unused;
106         while (1) {
107                 lock_fpu_owner();
108                 own_fpu_inatomic(0);
109                 err = restore_fp_context32(sc); /* this might fail */
110                 unlock_fpu_owner();
111                 if (likely(!err))
112                         break;
113                 /* touch the sigcontext and try again */
114                 err = __get_user(tmp, &sc->sc_fpregs[0]) |
115                         __get_user(tmp, &sc->sc_fpregs[31]) |
116                         __get_user(tmp, &sc->sc_fpc_csr);
117                 if (err)
118                         break;  /* really bad sigcontext */
119         }
120         return err;
121 }
122
123 static int setup_sigcontext32(struct pt_regs *regs,
124                               struct sigcontext32 __user *sc)
125 {
126         int err = 0;
127         int i;
128         u32 used_math;
129
130         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
131
132         err |= __put_user(0, &sc->sc_regs[0]);
133         for (i = 1; i < 32; i++)
134                 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
135
136         err |= __put_user(regs->hi, &sc->sc_mdhi);
137         err |= __put_user(regs->lo, &sc->sc_mdlo);
138         if (cpu_has_dsp) {
139                 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
140                 err |= __put_user(mfhi1(), &sc->sc_hi1);
141                 err |= __put_user(mflo1(), &sc->sc_lo1);
142                 err |= __put_user(mfhi2(), &sc->sc_hi2);
143                 err |= __put_user(mflo2(), &sc->sc_lo2);
144                 err |= __put_user(mfhi3(), &sc->sc_hi3);
145                 err |= __put_user(mflo3(), &sc->sc_lo3);
146         }
147
148         used_math = !!used_math();
149         err |= __put_user(used_math, &sc->sc_used_math);
150
151         if (used_math) {
152                 /*
153                  * Save FPU state to signal context.  Signal handler
154                  * will "inherit" current FPU state.
155                  */
156                 err |= protected_save_fp_context32(sc);
157         }
158         return err;
159 }
160
161 static int
162 check_and_restore_fp_context32(struct sigcontext32 __user *sc)
163 {
164         int err, sig;
165
166         err = sig = fpcsr_pending(&sc->sc_fpc_csr);
167         if (err > 0)
168                 err = 0;
169         err |= protected_restore_fp_context32(sc);
170         return err ?: sig;
171 }
172
173 static int restore_sigcontext32(struct pt_regs *regs,
174                                 struct sigcontext32 __user *sc)
175 {
176         u32 used_math;
177         int err = 0;
178         s32 treg;
179         int i;
180
181         /* Always make any pending restarted system calls return -EINTR */
182         current_thread_info()->restart_block.fn = do_no_restart_syscall;
183
184         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
185         err |= __get_user(regs->hi, &sc->sc_mdhi);
186         err |= __get_user(regs->lo, &sc->sc_mdlo);
187         if (cpu_has_dsp) {
188                 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
189                 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
190                 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
191                 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
192                 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
193                 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
194                 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
195         }
196
197         for (i = 1; i < 32; i++)
198                 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
199
200         err |= __get_user(used_math, &sc->sc_used_math);
201         conditional_used_math(used_math);
202
203         if (used_math) {
204                 /* restore fpu context if we have used it before */
205                 if (!err)
206                         err = check_and_restore_fp_context32(sc);
207         } else {
208                 /* signal handler may have used FPU.  Give it up. */
209                 lose_fpu(0);
210         }
211
212         return err;
213 }
214
215 /*
216  *
217  */
218 extern void __put_sigset_unknown_nsig(void);
219 extern void __get_sigset_unknown_nsig(void);
220
221 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
222 {
223         int err = 0;
224
225         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
226                 return -EFAULT;
227
228         switch (_NSIG_WORDS) {
229         default:
230                 __put_sigset_unknown_nsig();
231         case 2:
232                 err |= __put_user(kbuf->sig[1] >> 32, &ubuf->sig[3]);
233                 err |= __put_user(kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
234         case 1:
235                 err |= __put_user(kbuf->sig[0] >> 32, &ubuf->sig[1]);
236                 err |= __put_user(kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
237         }
238
239         return err;
240 }
241
242 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
243 {
244         int err = 0;
245         unsigned long sig[4];
246
247         if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
248                 return -EFAULT;
249
250         switch (_NSIG_WORDS) {
251         default:
252                 __get_sigset_unknown_nsig();
253         case 2:
254                 err |= __get_user(sig[3], &ubuf->sig[3]);
255                 err |= __get_user(sig[2], &ubuf->sig[2]);
256                 kbuf->sig[1] = sig[2] | (sig[3] << 32);
257         case 1:
258                 err |= __get_user(sig[1], &ubuf->sig[1]);
259                 err |= __get_user(sig[0], &ubuf->sig[0]);
260                 kbuf->sig[0] = sig[0] | (sig[1] << 32);
261         }
262
263         return err;
264 }
265
266 /*
267  * Atomically swap in the new signal mask, and wait for a signal.
268  */
269
270 asmlinkage int sys32_sigsuspend(compat_sigset_t __user *uset)
271 {
272         return compat_sys_rt_sigsuspend(uset, sizeof(compat_sigset_t));
273 }
274
275 SYSCALL_DEFINE3(32_sigaction, long, sig, const struct compat_sigaction __user *, act,
276         struct compat_sigaction __user *, oact)
277 {
278         struct k_sigaction new_ka, old_ka;
279         int ret;
280         int err = 0;
281
282         if (act) {
283                 old_sigset_t mask;
284                 s32 handler;
285
286                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
287                         return -EFAULT;
288                 err |= __get_user(handler, &act->sa_handler);
289                 new_ka.sa.sa_handler = (void __user *)(s64)handler;
290                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
291                 err |= __get_user(mask, &act->sa_mask.sig[0]);
292                 if (err)
293                         return -EFAULT;
294
295                 siginitset(&new_ka.sa.sa_mask, mask);
296         }
297
298         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
299
300         if (!ret && oact) {
301                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
302                         return -EFAULT;
303                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
304                 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
305                                   &oact->sa_handler);
306                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
307                 err |= __put_user(0, &oact->sa_mask.sig[1]);
308                 err |= __put_user(0, &oact->sa_mask.sig[2]);
309                 err |= __put_user(0, &oact->sa_mask.sig[3]);
310                 if (err)
311                         return -EFAULT;
312         }
313
314         return ret;
315 }
316
317 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
318 {
319         int err;
320
321         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
322                 return -EFAULT;
323
324         /* If you change siginfo_t structure, please be sure
325            this code is fixed accordingly.
326            It should never copy any pad contained in the structure
327            to avoid security leaks, but must copy the generic
328            3 ints plus the relevant union member.
329            This routine must convert siginfo from 64bit to 32bit as well
330            at the same time.  */
331         err = __put_user(from->si_signo, &to->si_signo);
332         err |= __put_user(from->si_errno, &to->si_errno);
333         err |= __put_user((short)from->si_code, &to->si_code);
334         if (from->si_code < 0)
335                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
336         else {
337                 switch (from->si_code >> 16) {
338                 case __SI_TIMER >> 16:
339                         err |= __put_user(from->si_tid, &to->si_tid);
340                         err |= __put_user(from->si_overrun, &to->si_overrun);
341                         err |= __put_user(from->si_int, &to->si_int);
342                         break;
343                 case __SI_CHLD >> 16:
344                         err |= __put_user(from->si_utime, &to->si_utime);
345                         err |= __put_user(from->si_stime, &to->si_stime);
346                         err |= __put_user(from->si_status, &to->si_status);
347                 default:
348                         err |= __put_user(from->si_pid, &to->si_pid);
349                         err |= __put_user(from->si_uid, &to->si_uid);
350                         break;
351                 case __SI_FAULT >> 16:
352                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
353                         break;
354                 case __SI_POLL >> 16:
355                         err |= __put_user(from->si_band, &to->si_band);
356                         err |= __put_user(from->si_fd, &to->si_fd);
357                         break;
358                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
359                 case __SI_MESGQ >> 16:
360                         err |= __put_user(from->si_pid, &to->si_pid);
361                         err |= __put_user(from->si_uid, &to->si_uid);
362                         err |= __put_user(from->si_int, &to->si_int);
363                         break;
364                 }
365         }
366         return err;
367 }
368
369 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
370 {
371         memset(to, 0, sizeof *to);
372
373         if (copy_from_user(to, from, 3*sizeof(int)) ||
374             copy_from_user(to->_sifields._pad,
375                            from->_sifields._pad, SI_PAD_SIZE32))
376                 return -EFAULT;
377
378         return 0;
379 }
380
381 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
382 {
383         struct sigframe32 __user *frame;
384         sigset_t blocked;
385         int sig;
386
387         frame = (struct sigframe32 __user *) regs.regs[29];
388         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
389                 goto badframe;
390         if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
391                 goto badframe;
392
393         set_current_blocked(&blocked);
394
395         sig = restore_sigcontext32(&regs, &frame->sf_sc);
396         if (sig < 0)
397                 goto badframe;
398         else if (sig)
399                 force_sig(sig, current);
400
401         /*
402          * Don't let your children do this ...
403          */
404         __asm__ __volatile__(
405                 "move\t$29, %0\n\t"
406                 "j\tsyscall_exit"
407                 :/* no outputs */
408                 :"r" (&regs));
409         /* Unreached */
410
411 badframe:
412         force_sig(SIGSEGV, current);
413 }
414
415 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
416 {
417         struct rt_sigframe32 __user *frame;
418         sigset_t set;
419         int sig;
420
421         frame = (struct rt_sigframe32 __user *) regs.regs[29];
422         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
423                 goto badframe;
424         if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
425                 goto badframe;
426
427         set_current_blocked(&set);
428
429         sig = restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext);
430         if (sig < 0)
431                 goto badframe;
432         else if (sig)
433                 force_sig(sig, current);
434
435         if (compat_restore_altstack(&frame->rs_uc.uc_stack))
436                 goto badframe;
437
438         /*
439          * Don't let your children do this ...
440          */
441         __asm__ __volatile__(
442                 "move\t$29, %0\n\t"
443                 "j\tsyscall_exit"
444                 :/* no outputs */
445                 :"r" (&regs));
446         /* Unreached */
447
448 badframe:
449         force_sig(SIGSEGV, current);
450 }
451
452 static int setup_frame_32(void *sig_return, struct k_sigaction *ka,
453                           struct pt_regs *regs, int signr, sigset_t *set)
454 {
455         struct sigframe32 __user *frame;
456         int err = 0;
457
458         frame = get_sigframe(ka, regs, sizeof(*frame));
459         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
460                 goto give_sigsegv;
461
462         err |= setup_sigcontext32(regs, &frame->sf_sc);
463         err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
464
465         if (err)
466                 goto give_sigsegv;
467
468         /*
469          * Arguments to signal handler:
470          *
471          *   a0 = signal number
472          *   a1 = 0 (should be cause)
473          *   a2 = pointer to struct sigcontext
474          *
475          * $25 and c0_epc point to the signal handler, $29 points to the
476          * struct sigframe.
477          */
478         regs->regs[ 4] = signr;
479         regs->regs[ 5] = 0;
480         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
481         regs->regs[29] = (unsigned long) frame;
482         regs->regs[31] = (unsigned long) sig_return;
483         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
484
485         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
486                current->comm, current->pid,
487                frame, regs->cp0_epc, regs->regs[31]);
488
489         return 0;
490
491 give_sigsegv:
492         force_sigsegv(signr, current);
493         return -EFAULT;
494 }
495
496 static int setup_rt_frame_32(void *sig_return, struct k_sigaction *ka,
497                              struct pt_regs *regs, int signr, sigset_t *set,
498                              siginfo_t *info)
499 {
500         struct rt_sigframe32 __user *frame;
501         int err = 0;
502
503         frame = get_sigframe(ka, regs, sizeof(*frame));
504         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
505                 goto give_sigsegv;
506
507         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
508         err |= copy_siginfo_to_user32(&frame->rs_info, info);
509
510         /* Create the ucontext.  */
511         err |= __put_user(0, &frame->rs_uc.uc_flags);
512         err |= __put_user(0, &frame->rs_uc.uc_link);
513         err |= __compat_save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]);
514         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
515         err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
516
517         if (err)
518                 goto give_sigsegv;
519
520         /*
521          * Arguments to signal handler:
522          *
523          *   a0 = signal number
524          *   a1 = 0 (should be cause)
525          *   a2 = pointer to ucontext
526          *
527          * $25 and c0_epc point to the signal handler, $29 points to
528          * the struct rt_sigframe32.
529          */
530         regs->regs[ 4] = signr;
531         regs->regs[ 5] = (unsigned long) &frame->rs_info;
532         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
533         regs->regs[29] = (unsigned long) frame;
534         regs->regs[31] = (unsigned long) sig_return;
535         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
536
537         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
538                current->comm, current->pid,
539                frame, regs->cp0_epc, regs->regs[31]);
540
541         return 0;
542
543 give_sigsegv:
544         force_sigsegv(signr, current);
545         return -EFAULT;
546 }
547
548 /*
549  * o32 compatibility on 64-bit kernels, without DSP ASE
550  */
551 struct mips_abi mips_abi_32 = {
552         .setup_frame    = setup_frame_32,
553         .signal_return_offset =
554                 offsetof(struct mips_vdso, o32_signal_trampoline),
555         .setup_rt_frame = setup_rt_frame_32,
556         .rt_signal_return_offset =
557                 offsetof(struct mips_vdso, o32_rt_signal_trampoline),
558         .restart        = __NR_O32_restart_syscall
559 };
560
561 static int signal32_init(void)
562 {
563         if (cpu_has_fpu) {
564                 save_fp_context32 = _save_fp_context32;
565                 restore_fp_context32 = _restore_fp_context32;
566         } else {
567                 save_fp_context32 = fpu_emulator_save_context32;
568                 restore_fp_context32 = fpu_emulator_restore_context32;
569         }
570
571         return 0;
572 }
573
574 arch_initcall(signal32_init);