Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6
[linux-2.6] / 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/sched.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/smp_lock.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
25 #include <asm/abi.h>
26 #include <asm/asm.h>
27 #include <linux/bitops.h>
28 #include <asm/cacheflush.h>
29 #include <asm/sim.h>
30 #include <asm/uaccess.h>
31 #include <asm/ucontext.h>
32 #include <asm/system.h>
33 #include <asm/fpu.h>
34 #include <asm/war.h>
35
36 #include "signal-common.h"
37
38 #define SI_PAD_SIZE32   ((SI_MAX_SIZE/sizeof(int)) - 3)
39
40 typedef struct compat_siginfo {
41         int si_signo;
42         int si_code;
43         int si_errno;
44
45         union {
46                 int _pad[SI_PAD_SIZE32];
47
48                 /* kill() */
49                 struct {
50                         compat_pid_t _pid;      /* sender's pid */
51                         compat_uid_t _uid;      /* sender's uid */
52                 } _kill;
53
54                 /* SIGCHLD */
55                 struct {
56                         compat_pid_t _pid;      /* which child */
57                         compat_uid_t _uid;      /* sender's uid */
58                         int _status;            /* exit code */
59                         compat_clock_t _utime;
60                         compat_clock_t _stime;
61                 } _sigchld;
62
63                 /* IRIX SIGCHLD */
64                 struct {
65                         compat_pid_t _pid;      /* which child */
66                         compat_clock_t _utime;
67                         int _status;            /* exit code */
68                         compat_clock_t _stime;
69                 } _irix_sigchld;
70
71                 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
72                 struct {
73                         s32 _addr; /* faulting insn/memory ref. */
74                 } _sigfault;
75
76                 /* SIGPOLL, SIGXFSZ (To do ...)  */
77                 struct {
78                         int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
79                         int _fd;
80                 } _sigpoll;
81
82                 /* POSIX.1b timers */
83                 struct {
84                         timer_t _tid;           /* timer id */
85                         int _overrun;           /* overrun count */
86                         compat_sigval_t _sigval;/* same as below */
87                         int _sys_private;       /* not to be passed to user */
88                 } _timer;
89
90                 /* POSIX.1b signals */
91                 struct {
92                         compat_pid_t _pid;      /* sender's pid */
93                         compat_uid_t _uid;      /* sender's uid */
94                         compat_sigval_t _sigval;
95                 } _rt;
96
97         } _sifields;
98 } compat_siginfo_t;
99
100 /*
101  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
102  */
103 #define __NR_O32_sigreturn              4119
104 #define __NR_O32_rt_sigreturn           4193
105 #define __NR_O32_restart_syscall        4253
106
107 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
108
109 /* 32-bit compatibility types */
110
111 #define _NSIG_BPW32     32
112 #define _NSIG_WORDS32   (_NSIG / _NSIG_BPW32)
113
114 typedef struct {
115         unsigned int sig[_NSIG_WORDS32];
116 } sigset_t32;
117
118 typedef unsigned int __sighandler32_t;
119 typedef void (*vfptr_t)(void);
120
121 struct sigaction32 {
122         unsigned int            sa_flags;
123         __sighandler32_t        sa_handler;
124         compat_sigset_t         sa_mask;
125 };
126
127 /* IRIX compatible stack_t  */
128 typedef struct sigaltstack32 {
129         s32 ss_sp;
130         compat_size_t ss_size;
131         int ss_flags;
132 } stack32_t;
133
134 struct ucontext32 {
135         u32                 uc_flags;
136         s32                 uc_link;
137         stack32_t           uc_stack;
138         struct sigcontext32 uc_mcontext;
139         sigset_t32          uc_sigmask;   /* mask last for extensibility */
140 };
141
142 #if ICACHE_REFILLS_WORKAROUND_WAR == 0
143
144 struct rt_sigframe32 {
145         u32 rs_ass[4];                  /* argument save space for o32 */
146         u32 rs_code[2];                 /* signal trampoline */
147         compat_siginfo_t rs_info;
148         struct ucontext32 rs_uc;
149 };
150
151 #else  /* ICACHE_REFILLS_WORKAROUND_WAR */
152
153 struct rt_sigframe32 {
154         u32 rs_ass[4];                  /* argument save space for o32 */
155         u32 rs_pad[2];
156         compat_siginfo_t rs_info;
157         struct ucontext32 rs_uc;
158         u32 rs_code[8] __attribute__((aligned(32)));    /* signal trampoline */
159 };
160
161 #endif  /* !ICACHE_REFILLS_WORKAROUND_WAR */
162
163 /*
164  * sigcontext handlers
165  */
166 static int setup_sigcontext32(struct pt_regs *regs,
167                               struct sigcontext32 __user *sc)
168 {
169         int err = 0;
170         int i;
171
172         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
173
174         err |= __put_user(0, &sc->sc_regs[0]);
175         for (i = 1; i < 32; i++)
176                 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
177
178         err |= __put_user(regs->hi, &sc->sc_mdhi);
179         err |= __put_user(regs->lo, &sc->sc_mdlo);
180         if (cpu_has_dsp) {
181                 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
182                 err |= __put_user(mfhi1(), &sc->sc_hi1);
183                 err |= __put_user(mflo1(), &sc->sc_lo1);
184                 err |= __put_user(mfhi2(), &sc->sc_hi2);
185                 err |= __put_user(mflo2(), &sc->sc_lo2);
186                 err |= __put_user(mfhi3(), &sc->sc_hi3);
187                 err |= __put_user(mflo3(), &sc->sc_lo3);
188         }
189
190         err |= __put_user(!!used_math(), &sc->sc_used_math);
191
192         if (used_math()) {
193                 /*
194                  * Save FPU state to signal context.  Signal handler
195                  * will "inherit" current FPU state.
196                  */
197                 preempt_disable();
198
199                 if (!is_fpu_owner()) {
200                         own_fpu();
201                         restore_fp(current);
202                 }
203                 err |= save_fp_context32(sc);
204
205                 preempt_enable();
206         }
207         return err;
208 }
209
210 static int restore_sigcontext32(struct pt_regs *regs,
211                                 struct sigcontext32 __user *sc)
212 {
213         u32 used_math;
214         int err = 0;
215         s32 treg;
216         int i;
217
218         /* Always make any pending restarted system calls return -EINTR */
219         current_thread_info()->restart_block.fn = do_no_restart_syscall;
220
221         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
222         err |= __get_user(regs->hi, &sc->sc_mdhi);
223         err |= __get_user(regs->lo, &sc->sc_mdlo);
224         if (cpu_has_dsp) {
225                 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
226                 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
227                 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
228                 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
229                 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
230                 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
231                 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
232         }
233
234         for (i = 1; i < 32; i++)
235                 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
236
237         err |= __get_user(used_math, &sc->sc_used_math);
238         conditional_used_math(used_math);
239
240         preempt_disable();
241
242         if (used_math()) {
243                 /* restore fpu context if we have used it before */
244                 own_fpu();
245                 err |= restore_fp_context32(sc);
246         } else {
247                 /* signal handler may have used FPU.  Give it up. */
248                 lose_fpu();
249         }
250
251         preempt_enable();
252
253         return err;
254 }
255
256 /*
257  *
258  */
259 extern void __put_sigset_unknown_nsig(void);
260 extern void __get_sigset_unknown_nsig(void);
261
262 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
263 {
264         int err = 0;
265
266         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
267                 return -EFAULT;
268
269         switch (_NSIG_WORDS) {
270         default:
271                 __put_sigset_unknown_nsig();
272         case 2:
273                 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]);
274                 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
275         case 1:
276                 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]);
277                 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
278         }
279
280         return err;
281 }
282
283 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
284 {
285         int err = 0;
286         unsigned long sig[4];
287
288         if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
289                 return -EFAULT;
290
291         switch (_NSIG_WORDS) {
292         default:
293                 __get_sigset_unknown_nsig();
294         case 2:
295                 err |= __get_user (sig[3], &ubuf->sig[3]);
296                 err |= __get_user (sig[2], &ubuf->sig[2]);
297                 kbuf->sig[1] = sig[2] | (sig[3] << 32);
298         case 1:
299                 err |= __get_user (sig[1], &ubuf->sig[1]);
300                 err |= __get_user (sig[0], &ubuf->sig[0]);
301                 kbuf->sig[0] = sig[0] | (sig[1] << 32);
302         }
303
304         return err;
305 }
306
307 /*
308  * Atomically swap in the new signal mask, and wait for a signal.
309  */
310
311 asmlinkage int sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
312 {
313         compat_sigset_t __user *uset;
314         sigset_t newset;
315
316         uset = (compat_sigset_t __user *) regs.regs[4];
317         if (get_sigset(&newset, uset))
318                 return -EFAULT;
319         sigdelsetmask(&newset, ~_BLOCKABLE);
320
321         spin_lock_irq(&current->sighand->siglock);
322         current->saved_sigmask = current->blocked;
323         current->blocked = newset;
324         recalc_sigpending();
325         spin_unlock_irq(&current->sighand->siglock);
326
327         current->state = TASK_INTERRUPTIBLE;
328         schedule();
329         set_thread_flag(TIF_RESTORE_SIGMASK);
330         return -ERESTARTNOHAND;
331 }
332
333 asmlinkage int sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
334 {
335         compat_sigset_t __user *uset;
336         sigset_t newset;
337         size_t sigsetsize;
338
339         /* XXX Don't preclude handling different sized sigset_t's.  */
340         sigsetsize = regs.regs[5];
341         if (sigsetsize != sizeof(compat_sigset_t))
342                 return -EINVAL;
343
344         uset = (compat_sigset_t __user *) regs.regs[4];
345         if (get_sigset(&newset, uset))
346                 return -EFAULT;
347         sigdelsetmask(&newset, ~_BLOCKABLE);
348
349         spin_lock_irq(&current->sighand->siglock);
350         current->saved_sigmask = current->blocked;
351         current->blocked = newset;
352         recalc_sigpending();
353         spin_unlock_irq(&current->sighand->siglock);
354
355         current->state = TASK_INTERRUPTIBLE;
356         schedule();
357         set_thread_flag(TIF_RESTORE_SIGMASK);
358         return -ERESTARTNOHAND;
359 }
360
361 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 __user *act,
362                                struct sigaction32 __user *oact)
363 {
364         struct k_sigaction new_ka, old_ka;
365         int ret;
366         int err = 0;
367
368         if (act) {
369                 old_sigset_t mask;
370                 s32 handler;
371
372                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
373                         return -EFAULT;
374                 err |= __get_user(handler, &act->sa_handler);
375                 new_ka.sa.sa_handler = (void __user *)(s64)handler;
376                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
377                 err |= __get_user(mask, &act->sa_mask.sig[0]);
378                 if (err)
379                         return -EFAULT;
380
381                 siginitset(&new_ka.sa.sa_mask, mask);
382         }
383
384         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
385
386         if (!ret && oact) {
387                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
388                         return -EFAULT;
389                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
390                 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
391                                   &oact->sa_handler);
392                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
393                 err |= __put_user(0, &oact->sa_mask.sig[1]);
394                 err |= __put_user(0, &oact->sa_mask.sig[2]);
395                 err |= __put_user(0, &oact->sa_mask.sig[3]);
396                 if (err)
397                         return -EFAULT;
398         }
399
400         return ret;
401 }
402
403 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
404 {
405         const stack32_t __user *uss = (const stack32_t __user *) regs.regs[4];
406         stack32_t __user *uoss = (stack32_t __user *) regs.regs[5];
407         unsigned long usp = regs.regs[29];
408         stack_t kss, koss;
409         int ret, err = 0;
410         mm_segment_t old_fs = get_fs();
411         s32 sp;
412
413         if (uss) {
414                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
415                         return -EFAULT;
416                 err |= __get_user(sp, &uss->ss_sp);
417                 kss.ss_sp = (void __user *) (long) sp;
418                 err |= __get_user(kss.ss_size, &uss->ss_size);
419                 err |= __get_user(kss.ss_flags, &uss->ss_flags);
420                 if (err)
421                         return -EFAULT;
422         }
423
424         set_fs (KERNEL_DS);
425         ret = do_sigaltstack(uss ? (stack_t __user *)&kss : NULL,
426                              uoss ? (stack_t __user *)&koss : NULL, usp);
427         set_fs (old_fs);
428
429         if (!ret && uoss) {
430                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
431                         return -EFAULT;
432                 sp = (int) (unsigned long) koss.ss_sp;
433                 err |= __put_user(sp, &uoss->ss_sp);
434                 err |= __put_user(koss.ss_size, &uoss->ss_size);
435                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
436                 if (err)
437                         return -EFAULT;
438         }
439         return ret;
440 }
441
442 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
443 {
444         int err;
445
446         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
447                 return -EFAULT;
448
449         /* If you change siginfo_t structure, please be sure
450            this code is fixed accordingly.
451            It should never copy any pad contained in the structure
452            to avoid security leaks, but must copy the generic
453            3 ints plus the relevant union member.
454            This routine must convert siginfo from 64bit to 32bit as well
455            at the same time.  */
456         err = __put_user(from->si_signo, &to->si_signo);
457         err |= __put_user(from->si_errno, &to->si_errno);
458         err |= __put_user((short)from->si_code, &to->si_code);
459         if (from->si_code < 0)
460                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
461         else {
462                 switch (from->si_code >> 16) {
463                 case __SI_TIMER >> 16:
464                         err |= __put_user(from->si_tid, &to->si_tid);
465                         err |= __put_user(from->si_overrun, &to->si_overrun);
466                         err |= __put_user(from->si_int, &to->si_int);
467                         break;
468                 case __SI_CHLD >> 16:
469                         err |= __put_user(from->si_utime, &to->si_utime);
470                         err |= __put_user(from->si_stime, &to->si_stime);
471                         err |= __put_user(from->si_status, &to->si_status);
472                 default:
473                         err |= __put_user(from->si_pid, &to->si_pid);
474                         err |= __put_user(from->si_uid, &to->si_uid);
475                         break;
476                 case __SI_FAULT >> 16:
477                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
478                         break;
479                 case __SI_POLL >> 16:
480                         err |= __put_user(from->si_band, &to->si_band);
481                         err |= __put_user(from->si_fd, &to->si_fd);
482                         break;
483                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
484                 case __SI_MESGQ >> 16:
485                         err |= __put_user(from->si_pid, &to->si_pid);
486                         err |= __put_user(from->si_uid, &to->si_uid);
487                         err |= __put_user(from->si_int, &to->si_int);
488                         break;
489                 }
490         }
491         return err;
492 }
493
494 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
495 {
496         struct sigframe __user *frame;
497         sigset_t blocked;
498
499         frame = (struct sigframe __user *) regs.regs[29];
500         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
501                 goto badframe;
502         if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
503                 goto badframe;
504
505         sigdelsetmask(&blocked, ~_BLOCKABLE);
506         spin_lock_irq(&current->sighand->siglock);
507         current->blocked = blocked;
508         recalc_sigpending();
509         spin_unlock_irq(&current->sighand->siglock);
510
511         if (restore_sigcontext32(&regs, &frame->sf_sc))
512                 goto badframe;
513
514         /*
515          * Don't let your children do this ...
516          */
517         __asm__ __volatile__(
518                 "move\t$29, %0\n\t"
519                 "j\tsyscall_exit"
520                 :/* no outputs */
521                 :"r" (&regs));
522         /* Unreached */
523
524 badframe:
525         force_sig(SIGSEGV, current);
526 }
527
528 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
529 {
530         struct rt_sigframe32 __user *frame;
531         mm_segment_t old_fs;
532         sigset_t set;
533         stack_t st;
534         s32 sp;
535
536         frame = (struct rt_sigframe32 __user *) regs.regs[29];
537         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
538                 goto badframe;
539         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
540                 goto badframe;
541
542         sigdelsetmask(&set, ~_BLOCKABLE);
543         spin_lock_irq(&current->sighand->siglock);
544         current->blocked = set;
545         recalc_sigpending();
546         spin_unlock_irq(&current->sighand->siglock);
547
548         if (restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext))
549                 goto badframe;
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 int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
582         int signr, sigset_t *set)
583 {
584         struct sigframe __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_to_user(&frame->sf_mask, set, sizeof(*set));
595         if (err)
596                 goto give_sigsegv;
597
598         /*
599          * Arguments to signal handler:
600          *
601          *   a0 = signal number
602          *   a1 = 0 (should be cause)
603          *   a2 = pointer to struct sigcontext
604          *
605          * $25 and c0_epc point to the signal handler, $29 points to the
606          * struct sigframe.
607          */
608         regs->regs[ 4] = signr;
609         regs->regs[ 5] = 0;
610         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
611         regs->regs[29] = (unsigned long) frame;
612         regs->regs[31] = (unsigned long) frame->sf_code;
613         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
614
615         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
616                current->comm, current->pid,
617                frame, regs->cp0_epc, regs->regs[31]);
618
619         return 0;
620
621 give_sigsegv:
622         force_sigsegv(signr, current);
623         return -EFAULT;
624 }
625
626 int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
627         int signr, sigset_t *set, siginfo_t *info)
628 {
629         struct rt_sigframe32 __user *frame;
630         int err = 0;
631         s32 sp;
632
633         frame = get_sigframe(ka, regs, sizeof(*frame));
634         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
635                 goto give_sigsegv;
636
637         err |= install_sigtramp(frame->rs_code, __NR_O32_rt_sigreturn);
638
639         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
640         err |= copy_siginfo_to_user32(&frame->rs_info, info);
641
642         /* Create the ucontext.  */
643         err |= __put_user(0, &frame->rs_uc.uc_flags);
644         err |= __put_user(0, &frame->rs_uc.uc_link);
645         sp = (int) (long) current->sas_ss_sp;
646         err |= __put_user(sp,
647                           &frame->rs_uc.uc_stack.ss_sp);
648         err |= __put_user(sas_ss_flags(regs->regs[29]),
649                           &frame->rs_uc.uc_stack.ss_flags);
650         err |= __put_user(current->sas_ss_size,
651                           &frame->rs_uc.uc_stack.ss_size);
652         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
653         err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
654
655         if (err)
656                 goto give_sigsegv;
657
658         /*
659          * Arguments to signal handler:
660          *
661          *   a0 = signal number
662          *   a1 = 0 (should be cause)
663          *   a2 = pointer to ucontext
664          *
665          * $25 and c0_epc point to the signal handler, $29 points to
666          * the struct rt_sigframe32.
667          */
668         regs->regs[ 4] = signr;
669         regs->regs[ 5] = (unsigned long) &frame->rs_info;
670         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
671         regs->regs[29] = (unsigned long) frame;
672         regs->regs[31] = (unsigned long) frame->rs_code;
673         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
674
675         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
676                current->comm, current->pid,
677                frame, regs->cp0_epc, regs->regs[31]);
678
679         return 0;
680
681 give_sigsegv:
682         force_sigsegv(signr, current);
683         return -EFAULT;
684 }
685
686 static inline int handle_signal(unsigned long sig, siginfo_t *info,
687         struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
688 {
689         int ret;
690
691         switch (regs->regs[0]) {
692         case ERESTART_RESTARTBLOCK:
693         case ERESTARTNOHAND:
694                 regs->regs[2] = EINTR;
695                 break;
696         case ERESTARTSYS:
697                 if (!(ka->sa.sa_flags & SA_RESTART)) {
698                         regs->regs[2] = EINTR;
699                         break;
700                 }
701         /* fallthrough */
702         case ERESTARTNOINTR:            /* Userland will reload $v0.  */
703                 regs->regs[7] = regs->regs[26];
704                 regs->cp0_epc -= 8;
705         }
706
707         regs->regs[0] = 0;              /* Don't deal with this again.  */
708
709         if (ka->sa.sa_flags & SA_SIGINFO)
710                 ret = current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info);
711         else
712                 ret = current->thread.abi->setup_frame(ka, regs, sig, oldset);
713
714         spin_lock_irq(&current->sighand->siglock);
715         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
716         if (!(ka->sa.sa_flags & SA_NODEFER))
717                 sigaddset(&current->blocked,sig);
718         recalc_sigpending();
719         spin_unlock_irq(&current->sighand->siglock);
720
721         return ret;
722 }
723
724 void do_signal32(struct pt_regs *regs)
725 {
726         struct k_sigaction ka;
727         sigset_t *oldset;
728         siginfo_t info;
729         int signr;
730
731         /*
732          * We want the common case to go fast, which is why we may in certain
733          * cases get here from kernel mode. Just return without doing anything
734          * if so.
735          */
736         if (!user_mode(regs))
737                 return;
738
739         if (test_thread_flag(TIF_RESTORE_SIGMASK))
740                 oldset = &current->saved_sigmask;
741         else
742                 oldset = &current->blocked;
743
744         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
745         if (signr > 0) {
746                 /* Whee! Actually deliver the signal. */
747                 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
748                         /*
749                         * A signal was successfully delivered; the saved
750                         * sigmask will have been stored in the signal frame,
751                         * and will be restored by sigreturn, so we can simply
752                         * clear the TIF_RESTORE_SIGMASK flag.
753                         */
754                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
755                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
756                 }
757
758                 return;
759         }
760
761         /*
762          * Who's code doesn't conform to the restartable syscall convention
763          * dies here!!!  The li instruction, a single machine instruction,
764          * must directly be followed by the syscall instruction.
765          */
766         if (regs->regs[0]) {
767                 if (regs->regs[2] == ERESTARTNOHAND ||
768                     regs->regs[2] == ERESTARTSYS ||
769                     regs->regs[2] == ERESTARTNOINTR) {
770                         regs->regs[7] = regs->regs[26];
771                         regs->cp0_epc -= 8;
772                 }
773                 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
774                         regs->regs[2] = __NR_O32_restart_syscall;
775                         regs->regs[7] = regs->regs[26];
776                         regs->cp0_epc -= 4;
777                 }
778                 regs->regs[0] = 0;      /* Don't deal with this again.  */
779         }
780
781         /*
782         * If there's no signal to deliver, we just put the saved sigmask
783         * back
784         */
785         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
786                 clear_thread_flag(TIF_RESTORE_SIGMASK);
787                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
788         }
789 }
790
791 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
792                                   struct sigaction32 __user *oact,
793                                   unsigned int sigsetsize)
794 {
795         struct k_sigaction new_sa, old_sa;
796         int ret = -EINVAL;
797
798         /* XXX: Don't preclude handling different sized sigset_t's.  */
799         if (sigsetsize != sizeof(sigset_t))
800                 goto out;
801
802         if (act) {
803                 s32 handler;
804                 int err = 0;
805
806                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
807                         return -EFAULT;
808                 err |= __get_user(handler, &act->sa_handler);
809                 new_sa.sa.sa_handler = (void __user *)(s64)handler;
810                 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
811                 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
812                 if (err)
813                         return -EFAULT;
814         }
815
816         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
817
818         if (!ret && oact) {
819                 int err = 0;
820
821                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
822                         return -EFAULT;
823
824                 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
825                                    &oact->sa_handler);
826                 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
827                 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
828                 if (err)
829                         return -EFAULT;
830         }
831 out:
832         return ret;
833 }
834
835 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
836         compat_sigset_t __user *oset, unsigned int sigsetsize)
837 {
838         sigset_t old_set, new_set;
839         int ret;
840         mm_segment_t old_fs = get_fs();
841
842         if (set && get_sigset(&new_set, set))
843                 return -EFAULT;
844
845         set_fs (KERNEL_DS);
846         ret = sys_rt_sigprocmask(how, set ? (sigset_t __user *)&new_set : NULL,
847                                  oset ? (sigset_t __user *)&old_set : NULL,
848                                  sigsetsize);
849         set_fs (old_fs);
850
851         if (!ret && oset && put_sigset(&old_set, oset))
852                 return -EFAULT;
853
854         return ret;
855 }
856
857 asmlinkage int sys32_rt_sigpending(compat_sigset_t __user *uset,
858         unsigned int sigsetsize)
859 {
860         int ret;
861         sigset_t set;
862         mm_segment_t old_fs = get_fs();
863
864         set_fs (KERNEL_DS);
865         ret = sys_rt_sigpending((sigset_t __user *)&set, sigsetsize);
866         set_fs (old_fs);
867
868         if (!ret && put_sigset(&set, uset))
869                 return -EFAULT;
870
871         return ret;
872 }
873
874 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo)
875 {
876         siginfo_t info;
877         int ret;
878         mm_segment_t old_fs = get_fs();
879
880         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
881             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
882                 return -EFAULT;
883         set_fs (KERNEL_DS);
884         ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
885         set_fs (old_fs);
886         return ret;
887 }
888
889 asmlinkage long
890 sys32_waitid(int which, compat_pid_t pid,
891              compat_siginfo_t __user *uinfo, int options,
892              struct compat_rusage __user *uru)
893 {
894         siginfo_t info;
895         struct rusage ru;
896         long ret;
897         mm_segment_t old_fs = get_fs();
898
899         info.si_signo = 0;
900         set_fs (KERNEL_DS);
901         ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
902                          uru ? (struct rusage __user *) &ru : NULL);
903         set_fs (old_fs);
904
905         if (ret < 0 || info.si_signo == 0)
906                 return ret;
907
908         if (uru && (ret = put_compat_rusage(&ru, uru)))
909                 return ret;
910
911         BUG_ON(info.si_code & __SI_MASK);
912         info.si_code |= __SI_CHLD;
913         return copy_siginfo_to_user32(uinfo, &info);
914 }