Report that kernel is tainted if there was an OOPS
[linux-2.6.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/compat.h>
22 #include <linux/suspend.h>
23 #include <linux/compiler.h>
24 #include <linux/uaccess.h>
25
26 #include <asm/abi.h>
27 #include <asm/asm.h>
28 #include <asm/compat-signal.h>
29 #include <linux/bitops.h>
30 #include <asm/cacheflush.h>
31 #include <asm/sim.h>
32 #include <asm/ucontext.h>
33 #include <asm/system.h>
34 #include <asm/fpu.h>
35 #include <asm/war.h>
36
37 #include "signal-common.h"
38
39 /*
40  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
41  */
42 #define __NR_O32_sigreturn              4119
43 #define __NR_O32_rt_sigreturn           4193
44 #define __NR_O32_restart_syscall        4253
45
46 /* 32-bit compatibility types */
47
48 typedef unsigned int __sighandler32_t;
49 typedef void (*vfptr_t)(void);
50
51 struct sigaction32 {
52         unsigned int            sa_flags;
53         __sighandler32_t        sa_handler;
54         compat_sigset_t         sa_mask;
55 };
56
57 /* IRIX compatible stack_t  */
58 typedef struct sigaltstack32 {
59         s32 ss_sp;
60         compat_size_t ss_size;
61         int ss_flags;
62 } stack32_t;
63
64 struct ucontext32 {
65         u32                 uc_flags;
66         s32                 uc_link;
67         stack32_t           uc_stack;
68         struct sigcontext32 uc_mcontext;
69         compat_sigset_t     uc_sigmask;   /* mask last for extensibility */
70 };
71
72 /*
73  * Horribly complicated - with the bloody RM9000 workarounds enabled
74  * the signal trampolines is moving to the end of the structure so we can
75  * increase the alignment without breaking software compatibility.
76  */
77 #if ICACHE_REFILLS_WORKAROUND_WAR == 0
78
79 struct sigframe32 {
80         u32 sf_ass[4];          /* argument save space for o32 */
81         u32 sf_code[2];         /* signal trampoline */
82         struct sigcontext32 sf_sc;
83         compat_sigset_t sf_mask;
84 };
85
86 struct rt_sigframe32 {
87         u32 rs_ass[4];                  /* argument save space for o32 */
88         u32 rs_code[2];                 /* signal trampoline */
89         compat_siginfo_t rs_info;
90         struct ucontext32 rs_uc;
91 };
92
93 #else  /* ICACHE_REFILLS_WORKAROUND_WAR */
94
95 struct sigframe32 {
96         u32 sf_ass[4];                  /* argument save space for o32 */
97         u32 sf_pad[2];
98         struct sigcontext32 sf_sc;      /* hw context */
99         compat_sigset_t sf_mask;
100         u32 sf_code[8] ____cacheline_aligned;   /* signal trampoline */
101 };
102
103 struct rt_sigframe32 {
104         u32 rs_ass[4];                  /* argument save space for o32 */
105         u32 rs_pad[2];
106         compat_siginfo_t rs_info;
107         struct ucontext32 rs_uc;
108         u32 rs_code[8] __attribute__((aligned(32)));    /* signal trampoline */
109 };
110
111 #endif  /* !ICACHE_REFILLS_WORKAROUND_WAR */
112
113 /*
114  * sigcontext handlers
115  */
116 static int protected_save_fp_context32(struct sigcontext32 __user *sc)
117 {
118         int err;
119         while (1) {
120                 lock_fpu_owner();
121                 own_fpu_inatomic(1);
122                 err = save_fp_context32(sc); /* this might fail */
123                 unlock_fpu_owner();
124                 if (likely(!err))
125                         break;
126                 /* touch the sigcontext and try again */
127                 err = __put_user(0, &sc->sc_fpregs[0]) |
128                         __put_user(0, &sc->sc_fpregs[31]) |
129                         __put_user(0, &sc->sc_fpc_csr);
130                 if (err)
131                         break;  /* really bad sigcontext */
132         }
133         return err;
134 }
135
136 static int protected_restore_fp_context32(struct sigcontext32 __user *sc)
137 {
138         int err, tmp;
139         while (1) {
140                 lock_fpu_owner();
141                 own_fpu_inatomic(0);
142                 err = restore_fp_context32(sc); /* this might fail */
143                 unlock_fpu_owner();
144                 if (likely(!err))
145                         break;
146                 /* touch the sigcontext and try again */
147                 err = __get_user(tmp, &sc->sc_fpregs[0]) |
148                         __get_user(tmp, &sc->sc_fpregs[31]) |
149                         __get_user(tmp, &sc->sc_fpc_csr);
150                 if (err)
151                         break;  /* really bad sigcontext */
152         }
153         return err;
154 }
155
156 static int setup_sigcontext32(struct pt_regs *regs,
157                               struct sigcontext32 __user *sc)
158 {
159         int err = 0;
160         int i;
161         u32 used_math;
162
163         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
164
165         err |= __put_user(0, &sc->sc_regs[0]);
166         for (i = 1; i < 32; i++)
167                 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
168
169         err |= __put_user(regs->hi, &sc->sc_mdhi);
170         err |= __put_user(regs->lo, &sc->sc_mdlo);
171         if (cpu_has_dsp) {
172                 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
173                 err |= __put_user(mfhi1(), &sc->sc_hi1);
174                 err |= __put_user(mflo1(), &sc->sc_lo1);
175                 err |= __put_user(mfhi2(), &sc->sc_hi2);
176                 err |= __put_user(mflo2(), &sc->sc_lo2);
177                 err |= __put_user(mfhi3(), &sc->sc_hi3);
178                 err |= __put_user(mflo3(), &sc->sc_lo3);
179         }
180
181         used_math = !!used_math();
182         err |= __put_user(used_math, &sc->sc_used_math);
183
184         if (used_math) {
185                 /*
186                  * Save FPU state to signal context.  Signal handler
187                  * will "inherit" current FPU state.
188                  */
189                 err |= protected_save_fp_context32(sc);
190         }
191         return err;
192 }
193
194 static int
195 check_and_restore_fp_context32(struct sigcontext32 __user *sc)
196 {
197         int err, sig;
198
199         err = sig = fpcsr_pending(&sc->sc_fpc_csr);
200         if (err > 0)
201                 err = 0;
202         err |= protected_restore_fp_context32(sc);
203         return err ?: sig;
204 }
205
206 static int restore_sigcontext32(struct pt_regs *regs,
207                                 struct sigcontext32 __user *sc)
208 {
209         u32 used_math;
210         int err = 0;
211         s32 treg;
212         int i;
213
214         /* Always make any pending restarted system calls return -EINTR */
215         current_thread_info()->restart_block.fn = do_no_restart_syscall;
216
217         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
218         err |= __get_user(regs->hi, &sc->sc_mdhi);
219         err |= __get_user(regs->lo, &sc->sc_mdlo);
220         if (cpu_has_dsp) {
221                 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
222                 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
223                 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
224                 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
225                 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
226                 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
227                 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
228         }
229
230         for (i = 1; i < 32; i++)
231                 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
232
233         err |= __get_user(used_math, &sc->sc_used_math);
234         conditional_used_math(used_math);
235
236         if (used_math) {
237                 /* restore fpu context if we have used it before */
238                 if (!err)
239                         err = check_and_restore_fp_context32(sc);
240         } else {
241                 /* signal handler may have used FPU.  Give it up. */
242                 lose_fpu(0);
243         }
244
245         return err;
246 }
247
248 /*
249  *
250  */
251 extern void __put_sigset_unknown_nsig(void);
252 extern void __get_sigset_unknown_nsig(void);
253
254 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
255 {
256         int err = 0;
257
258         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
259                 return -EFAULT;
260
261         switch (_NSIG_WORDS) {
262         default:
263                 __put_sigset_unknown_nsig();
264         case 2:
265                 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]);
266                 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
267         case 1:
268                 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]);
269                 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
270         }
271
272         return err;
273 }
274
275 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
276 {
277         int err = 0;
278         unsigned long sig[4];
279
280         if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
281                 return -EFAULT;
282
283         switch (_NSIG_WORDS) {
284         default:
285                 __get_sigset_unknown_nsig();
286         case 2:
287                 err |= __get_user (sig[3], &ubuf->sig[3]);
288                 err |= __get_user (sig[2], &ubuf->sig[2]);
289                 kbuf->sig[1] = sig[2] | (sig[3] << 32);
290         case 1:
291                 err |= __get_user (sig[1], &ubuf->sig[1]);
292                 err |= __get_user (sig[0], &ubuf->sig[0]);
293                 kbuf->sig[0] = sig[0] | (sig[1] << 32);
294         }
295
296         return err;
297 }
298
299 /*
300  * Atomically swap in the new signal mask, and wait for a signal.
301  */
302
303 asmlinkage int sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
304 {
305         compat_sigset_t __user *uset;
306         sigset_t newset;
307
308         uset = (compat_sigset_t __user *) regs.regs[4];
309         if (get_sigset(&newset, uset))
310                 return -EFAULT;
311         sigdelsetmask(&newset, ~_BLOCKABLE);
312
313         spin_lock_irq(&current->sighand->siglock);
314         current->saved_sigmask = current->blocked;
315         current->blocked = newset;
316         recalc_sigpending();
317         spin_unlock_irq(&current->sighand->siglock);
318
319         current->state = TASK_INTERRUPTIBLE;
320         schedule();
321         set_thread_flag(TIF_RESTORE_SIGMASK);
322         return -ERESTARTNOHAND;
323 }
324
325 asmlinkage int sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
326 {
327         compat_sigset_t __user *uset;
328         sigset_t newset;
329         size_t sigsetsize;
330
331         /* XXX Don't preclude handling different sized sigset_t's.  */
332         sigsetsize = regs.regs[5];
333         if (sigsetsize != sizeof(compat_sigset_t))
334                 return -EINVAL;
335
336         uset = (compat_sigset_t __user *) regs.regs[4];
337         if (get_sigset(&newset, uset))
338                 return -EFAULT;
339         sigdelsetmask(&newset, ~_BLOCKABLE);
340
341         spin_lock_irq(&current->sighand->siglock);
342         current->saved_sigmask = current->blocked;
343         current->blocked = newset;
344         recalc_sigpending();
345         spin_unlock_irq(&current->sighand->siglock);
346
347         current->state = TASK_INTERRUPTIBLE;
348         schedule();
349         set_thread_flag(TIF_RESTORE_SIGMASK);
350         return -ERESTARTNOHAND;
351 }
352
353 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 __user *act,
354                                struct sigaction32 __user *oact)
355 {
356         struct k_sigaction new_ka, old_ka;
357         int ret;
358         int err = 0;
359
360         if (act) {
361                 old_sigset_t mask;
362                 s32 handler;
363
364                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
365                         return -EFAULT;
366                 err |= __get_user(handler, &act->sa_handler);
367                 new_ka.sa.sa_handler = (void __user *)(s64)handler;
368                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
369                 err |= __get_user(mask, &act->sa_mask.sig[0]);
370                 if (err)
371                         return -EFAULT;
372
373                 siginitset(&new_ka.sa.sa_mask, mask);
374         }
375
376         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
377
378         if (!ret && oact) {
379                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
380                         return -EFAULT;
381                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
382                 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
383                                   &oact->sa_handler);
384                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
385                 err |= __put_user(0, &oact->sa_mask.sig[1]);
386                 err |= __put_user(0, &oact->sa_mask.sig[2]);
387                 err |= __put_user(0, &oact->sa_mask.sig[3]);
388                 if (err)
389                         return -EFAULT;
390         }
391
392         return ret;
393 }
394
395 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
396 {
397         const stack32_t __user *uss = (const stack32_t __user *) regs.regs[4];
398         stack32_t __user *uoss = (stack32_t __user *) regs.regs[5];
399         unsigned long usp = regs.regs[29];
400         stack_t kss, koss;
401         int ret, err = 0;
402         mm_segment_t old_fs = get_fs();
403         s32 sp;
404
405         if (uss) {
406                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
407                         return -EFAULT;
408                 err |= __get_user(sp, &uss->ss_sp);
409                 kss.ss_sp = (void __user *) (long) sp;
410                 err |= __get_user(kss.ss_size, &uss->ss_size);
411                 err |= __get_user(kss.ss_flags, &uss->ss_flags);
412                 if (err)
413                         return -EFAULT;
414         }
415
416         set_fs (KERNEL_DS);
417         ret = do_sigaltstack(uss ? (stack_t __user *)&kss : NULL,
418                              uoss ? (stack_t __user *)&koss : NULL, usp);
419         set_fs (old_fs);
420
421         if (!ret && uoss) {
422                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
423                         return -EFAULT;
424                 sp = (int) (unsigned long) koss.ss_sp;
425                 err |= __put_user(sp, &uoss->ss_sp);
426                 err |= __put_user(koss.ss_size, &uoss->ss_size);
427                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
428                 if (err)
429                         return -EFAULT;
430         }
431         return ret;
432 }
433
434 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
435 {
436         int err;
437
438         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
439                 return -EFAULT;
440
441         /* If you change siginfo_t structure, please be sure
442            this code is fixed accordingly.
443            It should never copy any pad contained in the structure
444            to avoid security leaks, but must copy the generic
445            3 ints plus the relevant union member.
446            This routine must convert siginfo from 64bit to 32bit as well
447            at the same time.  */
448         err = __put_user(from->si_signo, &to->si_signo);
449         err |= __put_user(from->si_errno, &to->si_errno);
450         err |= __put_user((short)from->si_code, &to->si_code);
451         if (from->si_code < 0)
452                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
453         else {
454                 switch (from->si_code >> 16) {
455                 case __SI_TIMER >> 16:
456                         err |= __put_user(from->si_tid, &to->si_tid);
457                         err |= __put_user(from->si_overrun, &to->si_overrun);
458                         err |= __put_user(from->si_int, &to->si_int);
459                         break;
460                 case __SI_CHLD >> 16:
461                         err |= __put_user(from->si_utime, &to->si_utime);
462                         err |= __put_user(from->si_stime, &to->si_stime);
463                         err |= __put_user(from->si_status, &to->si_status);
464                 default:
465                         err |= __put_user(from->si_pid, &to->si_pid);
466                         err |= __put_user(from->si_uid, &to->si_uid);
467                         break;
468                 case __SI_FAULT >> 16:
469                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
470                         break;
471                 case __SI_POLL >> 16:
472                         err |= __put_user(from->si_band, &to->si_band);
473                         err |= __put_user(from->si_fd, &to->si_fd);
474                         break;
475                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
476                 case __SI_MESGQ >> 16:
477                         err |= __put_user(from->si_pid, &to->si_pid);
478                         err |= __put_user(from->si_uid, &to->si_uid);
479                         err |= __put_user(from->si_int, &to->si_int);
480                         break;
481                 }
482         }
483         return err;
484 }
485
486 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
487 {
488         struct sigframe32 __user *frame;
489         sigset_t blocked;
490         int sig;
491
492         frame = (struct sigframe32 __user *) regs.regs[29];
493         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
494                 goto badframe;
495         if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
496                 goto badframe;
497
498         sigdelsetmask(&blocked, ~_BLOCKABLE);
499         spin_lock_irq(&current->sighand->siglock);
500         current->blocked = blocked;
501         recalc_sigpending();
502         spin_unlock_irq(&current->sighand->siglock);
503
504         sig = restore_sigcontext32(&regs, &frame->sf_sc);
505         if (sig < 0)
506                 goto badframe;
507         else if (sig)
508                 force_sig(sig, current);
509
510         /*
511          * Don't let your children do this ...
512          */
513         __asm__ __volatile__(
514                 "move\t$29, %0\n\t"
515                 "j\tsyscall_exit"
516                 :/* no outputs */
517                 :"r" (&regs));
518         /* Unreached */
519
520 badframe:
521         force_sig(SIGSEGV, current);
522 }
523
524 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
525 {
526         struct rt_sigframe32 __user *frame;
527         mm_segment_t old_fs;
528         sigset_t set;
529         stack_t st;
530         s32 sp;
531         int sig;
532
533         frame = (struct rt_sigframe32 __user *) regs.regs[29];
534         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
535                 goto badframe;
536         if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
537                 goto badframe;
538
539         sigdelsetmask(&set, ~_BLOCKABLE);
540         spin_lock_irq(&current->sighand->siglock);
541         current->blocked = set;
542         recalc_sigpending();
543         spin_unlock_irq(&current->sighand->siglock);
544
545         sig = restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext);
546         if (sig < 0)
547                 goto badframe;
548         else if (sig)
549                 force_sig(sig, current);
550
551         /* The ucontext contains a stack32_t, so we must convert!  */
552         if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
553                 goto badframe;
554         st.ss_sp = (void __user *)(long) sp;
555         if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
556                 goto badframe;
557         if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
558                 goto badframe;
559
560         /* It is more difficult to avoid calling this function than to
561            call it and ignore errors.  */
562         old_fs = get_fs();
563         set_fs (KERNEL_DS);
564         do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
565         set_fs (old_fs);
566
567         /*
568          * Don't let your children do this ...
569          */
570         __asm__ __volatile__(
571                 "move\t$29, %0\n\t"
572                 "j\tsyscall_exit"
573                 :/* no outputs */
574                 :"r" (&regs));
575         /* Unreached */
576
577 badframe:
578         force_sig(SIGSEGV, current);
579 }
580
581 static int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
582         int signr, sigset_t *set)
583 {
584         struct sigframe32 __user *frame;
585         int err = 0;
586
587         frame = get_sigframe(ka, regs, sizeof(*frame));
588         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
589                 goto give_sigsegv;
590
591         err |= install_sigtramp(frame->sf_code, __NR_O32_sigreturn);
592
593         err |= setup_sigcontext32(regs, &frame->sf_sc);
594         err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
595
596         if (err)
597                 goto give_sigsegv;
598
599         /*
600          * Arguments to signal handler:
601          *
602          *   a0 = signal number
603          *   a1 = 0 (should be cause)
604          *   a2 = pointer to struct sigcontext
605          *
606          * $25 and c0_epc point to the signal handler, $29 points to the
607          * struct sigframe.
608          */
609         regs->regs[ 4] = signr;
610         regs->regs[ 5] = 0;
611         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
612         regs->regs[29] = (unsigned long) frame;
613         regs->regs[31] = (unsigned long) frame->sf_code;
614         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
615
616         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
617                current->comm, current->pid,
618                frame, regs->cp0_epc, regs->regs[31]);
619
620         return 0;
621
622 give_sigsegv:
623         force_sigsegv(signr, current);
624         return -EFAULT;
625 }
626
627 static int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
628         int signr, sigset_t *set, siginfo_t *info)
629 {
630         struct rt_sigframe32 __user *frame;
631         int err = 0;
632         s32 sp;
633
634         frame = get_sigframe(ka, regs, sizeof(*frame));
635         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
636                 goto give_sigsegv;
637
638         err |= install_sigtramp(frame->rs_code, __NR_O32_rt_sigreturn);
639
640         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
641         err |= copy_siginfo_to_user32(&frame->rs_info, info);
642
643         /* Create the ucontext.  */
644         err |= __put_user(0, &frame->rs_uc.uc_flags);
645         err |= __put_user(0, &frame->rs_uc.uc_link);
646         sp = (int) (long) current->sas_ss_sp;
647         err |= __put_user(sp,
648                           &frame->rs_uc.uc_stack.ss_sp);
649         err |= __put_user(sas_ss_flags(regs->regs[29]),
650                           &frame->rs_uc.uc_stack.ss_flags);
651         err |= __put_user(current->sas_ss_size,
652                           &frame->rs_uc.uc_stack.ss_size);
653         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
654         err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
655
656         if (err)
657                 goto give_sigsegv;
658
659         /*
660          * Arguments to signal handler:
661          *
662          *   a0 = signal number
663          *   a1 = 0 (should be cause)
664          *   a2 = pointer to ucontext
665          *
666          * $25 and c0_epc point to the signal handler, $29 points to
667          * the struct rt_sigframe32.
668          */
669         regs->regs[ 4] = signr;
670         regs->regs[ 5] = (unsigned long) &frame->rs_info;
671         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
672         regs->regs[29] = (unsigned long) frame;
673         regs->regs[31] = (unsigned long) frame->rs_code;
674         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
675
676         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
677                current->comm, current->pid,
678                frame, regs->cp0_epc, regs->regs[31]);
679
680         return 0;
681
682 give_sigsegv:
683         force_sigsegv(signr, current);
684         return -EFAULT;
685 }
686
687 /*
688  * o32 compatibility on 64-bit kernels, without DSP ASE
689  */
690 struct mips_abi mips_abi_32 = {
691         .setup_frame    = setup_frame_32,
692         .setup_rt_frame = setup_rt_frame_32,
693         .restart        = __NR_O32_restart_syscall
694 };
695
696 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
697                                   struct sigaction32 __user *oact,
698                                   unsigned int sigsetsize)
699 {
700         struct k_sigaction new_sa, old_sa;
701         int ret = -EINVAL;
702
703         /* XXX: Don't preclude handling different sized sigset_t's.  */
704         if (sigsetsize != sizeof(sigset_t))
705                 goto out;
706
707         if (act) {
708                 s32 handler;
709                 int err = 0;
710
711                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
712                         return -EFAULT;
713                 err |= __get_user(handler, &act->sa_handler);
714                 new_sa.sa.sa_handler = (void __user *)(s64)handler;
715                 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
716                 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
717                 if (err)
718                         return -EFAULT;
719         }
720
721         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
722
723         if (!ret && oact) {
724                 int err = 0;
725
726                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
727                         return -EFAULT;
728
729                 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
730                                    &oact->sa_handler);
731                 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
732                 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
733                 if (err)
734                         return -EFAULT;
735         }
736 out:
737         return ret;
738 }
739
740 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
741         compat_sigset_t __user *oset, unsigned int sigsetsize)
742 {
743         sigset_t old_set, new_set;
744         int ret;
745         mm_segment_t old_fs = get_fs();
746
747         if (set && get_sigset(&new_set, set))
748                 return -EFAULT;
749
750         set_fs (KERNEL_DS);
751         ret = sys_rt_sigprocmask(how, set ? (sigset_t __user *)&new_set : NULL,
752                                  oset ? (sigset_t __user *)&old_set : NULL,
753                                  sigsetsize);
754         set_fs (old_fs);
755
756         if (!ret && oset && put_sigset(&old_set, oset))
757                 return -EFAULT;
758
759         return ret;
760 }
761
762 asmlinkage int sys32_rt_sigpending(compat_sigset_t __user *uset,
763         unsigned int sigsetsize)
764 {
765         int ret;
766         sigset_t set;
767         mm_segment_t old_fs = get_fs();
768
769         set_fs (KERNEL_DS);
770         ret = sys_rt_sigpending((sigset_t __user *)&set, sigsetsize);
771         set_fs (old_fs);
772
773         if (!ret && put_sigset(&set, uset))
774                 return -EFAULT;
775
776         return ret;
777 }
778
779 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo)
780 {
781         siginfo_t info;
782         int ret;
783         mm_segment_t old_fs = get_fs();
784
785         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
786             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
787                 return -EFAULT;
788         set_fs (KERNEL_DS);
789         ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
790         set_fs (old_fs);
791         return ret;
792 }
793
794 asmlinkage long
795 sys32_waitid(int which, compat_pid_t pid,
796              compat_siginfo_t __user *uinfo, int options,
797              struct compat_rusage __user *uru)
798 {
799         siginfo_t info;
800         struct rusage ru;
801         long ret;
802         mm_segment_t old_fs = get_fs();
803
804         info.si_signo = 0;
805         set_fs (KERNEL_DS);
806         ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
807                          uru ? (struct rusage __user *) &ru : NULL);
808         set_fs (old_fs);
809
810         if (ret < 0 || info.si_signo == 0)
811                 return ret;
812
813         if (uru && (ret = put_compat_rusage(&ru, uru)))
814                 return ret;
815
816         BUG_ON(info.si_code & __SI_MASK);
817         info.si_code |= __SI_CHLD;
818         return copy_siginfo_to_user32(uinfo, &info);
819 }