[PATCH] powerpc signal __user annotations
[linux-2.6.git] / arch / powerpc / kernel / signal_32.c
1 /*
2  * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
3  *
4  *  PowerPC version
5  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
6  * Copyright (C) 2001 IBM
7  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8  * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
9  *
10  *  Derived from "arch/i386/kernel/signal.c"
11  *    Copyright (C) 1991, 1992 Linus Torvalds
12  *    1997-11-28  Modified for POSIX.1b signals by Richard Henderson
13  *
14  *  This program is free software; you can redistribute it and/or
15  *  modify it under the terms of the GNU General Public License
16  *  as published by the Free Software Foundation; either version
17  *  2 of the License, or (at your option) any later version.
18  */
19
20 #include <linux/config.h>
21 #include <linux/sched.h>
22 #include <linux/mm.h>
23 #include <linux/smp.h>
24 #include <linux/smp_lock.h>
25 #include <linux/kernel.h>
26 #include <linux/signal.h>
27 #include <linux/errno.h>
28 #include <linux/elf.h>
29 #ifdef CONFIG_PPC64
30 #include <linux/syscalls.h>
31 #include <linux/compat.h>
32 #include <linux/ptrace.h>
33 #else
34 #include <linux/wait.h>
35 #include <linux/ptrace.h>
36 #include <linux/unistd.h>
37 #include <linux/stddef.h>
38 #include <linux/tty.h>
39 #include <linux/binfmts.h>
40 #include <linux/suspend.h>
41 #endif
42
43 #include <asm/uaccess.h>
44 #include <asm/cacheflush.h>
45 #include <asm/sigcontext.h>
46 #include <asm/vdso.h>
47 #ifdef CONFIG_PPC64
48 #include "ppc32.h"
49 #include <asm/unistd.h>
50 #else
51 #include <asm/ucontext.h>
52 #include <asm/pgtable.h>
53 #endif
54
55 #undef DEBUG_SIG
56
57 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
58
59 #ifdef CONFIG_PPC64
60 #define do_signal       do_signal32
61 #define sys_sigsuspend  compat_sys_sigsuspend
62 #define sys_rt_sigsuspend       compat_sys_rt_sigsuspend
63 #define sys_rt_sigreturn        compat_sys_rt_sigreturn
64 #define sys_sigaction   compat_sys_sigaction
65 #define sys_swapcontext compat_sys_swapcontext
66 #define sys_sigreturn   compat_sys_sigreturn
67
68 #define old_sigaction   old_sigaction32
69 #define sigcontext      sigcontext32
70 #define mcontext        mcontext32
71 #define ucontext        ucontext32
72
73 /*
74  * Returning 0 means we return to userspace via
75  * ret_from_except and thus restore all user
76  * registers from *regs.  This is what we need
77  * to do when a signal has been delivered.
78  */
79
80 #define GP_REGS_SIZE    min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
81 #undef __SIGNAL_FRAMESIZE
82 #define __SIGNAL_FRAMESIZE      __SIGNAL_FRAMESIZE32
83 #undef ELF_NVRREG
84 #define ELF_NVRREG      ELF_NVRREG32
85
86 /*
87  * Functions for flipping sigsets (thanks to brain dead generic
88  * implementation that makes things simple for little endian only)
89  */
90 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
91 {
92         compat_sigset_t cset;
93
94         switch (_NSIG_WORDS) {
95         case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
96                 cset.sig[7] = set->sig[3] >> 32;
97         case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
98                 cset.sig[5] = set->sig[2] >> 32;
99         case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
100                 cset.sig[3] = set->sig[1] >> 32;
101         case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
102                 cset.sig[1] = set->sig[0] >> 32;
103         }
104         return copy_to_user(uset, &cset, sizeof(*uset));
105 }
106
107 static inline int get_sigset_t(sigset_t *set,
108                                const compat_sigset_t __user *uset)
109 {
110         compat_sigset_t s32;
111
112         if (copy_from_user(&s32, uset, sizeof(*uset)))
113                 return -EFAULT;
114
115         /*
116          * Swap the 2 words of the 64-bit sigset_t (they are stored
117          * in the "wrong" endian in 32-bit user storage).
118          */
119         switch (_NSIG_WORDS) {
120         case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
121         case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
122         case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
123         case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
124         }
125         return 0;
126 }
127
128 static inline int get_old_sigaction(struct k_sigaction *new_ka,
129                 struct old_sigaction __user *act)
130 {
131         compat_old_sigset_t mask;
132         compat_uptr_t handler, restorer;
133
134         if (get_user(handler, &act->sa_handler) ||
135             __get_user(restorer, &act->sa_restorer) ||
136             __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
137             __get_user(mask, &act->sa_mask))
138                 return -EFAULT;
139         new_ka->sa.sa_handler = compat_ptr(handler);
140         new_ka->sa.sa_restorer = compat_ptr(restorer);
141         siginitset(&new_ka->sa.sa_mask, mask);
142         return 0;
143 }
144
145 #define to_user_ptr(p)          ptr_to_compat(p)
146 #define from_user_ptr(p)        compat_ptr(p)
147
148 static inline int save_general_regs(struct pt_regs *regs,
149                 struct mcontext __user *frame)
150 {
151         elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
152         int i;
153
154         if (!FULL_REGS(regs)) {
155                 set_thread_flag(TIF_SAVE_NVGPRS);
156                 current_thread_info()->nvgprs_frame = frame->mc_gregs;
157         }
158
159         for (i = 0; i <= PT_RESULT; i ++) {
160                 if (i == 14 && !FULL_REGS(regs))
161                         i = 32;
162                 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
163                         return -EFAULT;
164         }
165         return 0;
166 }
167
168 static inline int restore_general_regs(struct pt_regs *regs,
169                 struct mcontext __user *sr)
170 {
171         elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
172         int i;
173
174         for (i = 0; i <= PT_RESULT; i++) {
175                 if ((i == PT_MSR) || (i == PT_SOFTE))
176                         continue;
177                 if (__get_user(gregs[i], &sr->mc_gregs[i]))
178                         return -EFAULT;
179         }
180         return 0;
181 }
182
183 #else /* CONFIG_PPC64 */
184
185 #define GP_REGS_SIZE    min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
186
187 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
188 {
189         return copy_to_user(uset, set, sizeof(*uset));
190 }
191
192 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
193 {
194         return copy_from_user(set, uset, sizeof(*uset));
195 }
196
197 static inline int get_old_sigaction(struct k_sigaction *new_ka,
198                 struct old_sigaction __user *act)
199 {
200         old_sigset_t mask;
201
202         if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
203                         __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
204                         __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
205                 return -EFAULT;
206         __get_user(new_ka->sa.sa_flags, &act->sa_flags);
207         __get_user(mask, &act->sa_mask);
208         siginitset(&new_ka->sa.sa_mask, mask);
209         return 0;
210 }
211
212 #define to_user_ptr(p)          ((unsigned long)(p))
213 #define from_user_ptr(p)        ((void __user *)(p))
214
215 static inline int save_general_regs(struct pt_regs *regs,
216                 struct mcontext __user *frame)
217 {
218         if (!FULL_REGS(regs)) {
219                 /* Zero out the unsaved GPRs to avoid information
220                    leak, and set TIF_SAVE_NVGPRS to ensure that the
221                    registers do actually get saved later. */
222                 memset(&regs->gpr[14], 0, 18 * sizeof(unsigned long));
223                 current_thread_info()->nvgprs_frame = &frame->mc_gregs;
224                 set_thread_flag(TIF_SAVE_NVGPRS);
225         }
226
227         return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
228 }
229
230 static inline int restore_general_regs(struct pt_regs *regs,
231                 struct mcontext __user *sr)
232 {
233         /* copy up to but not including MSR */
234         if (__copy_from_user(regs, &sr->mc_gregs,
235                                 PT_MSR * sizeof(elf_greg_t)))
236                 return -EFAULT;
237         /* copy from orig_r3 (the word after the MSR) up to the end */
238         if (__copy_from_user(&regs->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
239                                 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
240                 return -EFAULT;
241         return 0;
242 }
243
244 #endif /* CONFIG_PPC64 */
245
246 int do_signal(sigset_t *oldset, struct pt_regs *regs);
247
248 /*
249  * Atomically swap in the new signal mask, and wait for a signal.
250  */
251 long sys_sigsuspend(old_sigset_t mask)
252 {
253         mask &= _BLOCKABLE;
254         spin_lock_irq(&current->sighand->siglock);
255         current->saved_sigmask = current->blocked;
256         siginitset(&current->blocked, mask);
257         recalc_sigpending();
258         spin_unlock_irq(&current->sighand->siglock);
259
260         current->state = TASK_INTERRUPTIBLE;
261         schedule();
262         set_thread_flag(TIF_RESTORE_SIGMASK);
263         return -ERESTARTNOHAND;
264 }
265
266 #ifdef CONFIG_PPC32
267 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
268                 int r6, int r7, int r8, struct pt_regs *regs)
269 {
270         return do_sigaltstack(uss, uoss, regs->gpr[1]);
271 }
272 #endif
273
274 long sys_sigaction(int sig, struct old_sigaction __user *act,
275                 struct old_sigaction __user *oact)
276 {
277         struct k_sigaction new_ka, old_ka;
278         int ret;
279
280 #ifdef CONFIG_PPC64
281         if (sig < 0)
282                 sig = -sig;
283 #endif
284
285         if (act) {
286                 if (get_old_sigaction(&new_ka, act))
287                         return -EFAULT;
288         }
289
290         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
291         if (!ret && oact) {
292                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
293                     __put_user(to_user_ptr(old_ka.sa.sa_handler),
294                             &oact->sa_handler) ||
295                     __put_user(to_user_ptr(old_ka.sa.sa_restorer),
296                             &oact->sa_restorer) ||
297                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
298                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
299                         return -EFAULT;
300         }
301
302         return ret;
303 }
304
305 /*
306  * When we have signals to deliver, we set up on the
307  * user stack, going down from the original stack pointer:
308  *      a sigregs struct
309  *      a sigcontext struct
310  *      a gap of __SIGNAL_FRAMESIZE bytes
311  *
312  * Each of these things must be a multiple of 16 bytes in size.
313  *
314  */
315 struct sigregs {
316         struct mcontext mctx;           /* all the register values */
317         /*
318          * Programs using the rs6000/xcoff abi can save up to 19 gp
319          * regs and 18 fp regs below sp before decrementing it.
320          */
321         int                     abigap[56];
322 };
323
324 /* We use the mc_pad field for the signal return trampoline. */
325 #define tramp   mc_pad
326
327 /*
328  *  When we have rt signals to deliver, we set up on the
329  *  user stack, going down from the original stack pointer:
330  *      one rt_sigframe struct (siginfo + ucontext + ABI gap)
331  *      a gap of __SIGNAL_FRAMESIZE+16 bytes
332  *  (the +16 is to get the siginfo and ucontext in the same
333  *  positions as in older kernels).
334  *
335  *  Each of these things must be a multiple of 16 bytes in size.
336  *
337  */
338 struct rt_sigframe {
339 #ifdef CONFIG_PPC64
340         compat_siginfo_t info;
341 #else
342         struct siginfo info;
343 #endif
344         struct ucontext uc;
345         /*
346          * Programs using the rs6000/xcoff abi can save up to 19 gp
347          * regs and 18 fp regs below sp before decrementing it.
348          */
349         int                     abigap[56];
350 };
351
352 /*
353  * Save the current user registers on the user stack.
354  * We only save the altivec/spe registers if the process has used
355  * altivec/spe instructions at some point.
356  */
357 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
358                 int sigret)
359 {
360         /* Make sure floating point registers are stored in regs */
361         flush_fp_to_thread(current);
362
363         /* save general and floating-point registers */
364         if (save_general_regs(regs, frame) ||
365             __copy_to_user(&frame->mc_fregs, current->thread.fpr,
366                     ELF_NFPREG * sizeof(double)))
367                 return 1;
368
369 #ifdef CONFIG_ALTIVEC
370         /* save altivec registers */
371         if (current->thread.used_vr) {
372                 flush_altivec_to_thread(current);
373                 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
374                                    ELF_NVRREG * sizeof(vector128)))
375                         return 1;
376                 /* set MSR_VEC in the saved MSR value to indicate that
377                    frame->mc_vregs contains valid data */
378                 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
379                         return 1;
380         }
381         /* else assert((regs->msr & MSR_VEC) == 0) */
382
383         /* We always copy to/from vrsave, it's 0 if we don't have or don't
384          * use altivec. Since VSCR only contains 32 bits saved in the least
385          * significant bits of a vector, we "cheat" and stuff VRSAVE in the
386          * most significant bits of that same vector. --BenH
387          */
388         if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
389                 return 1;
390 #endif /* CONFIG_ALTIVEC */
391
392 #ifdef CONFIG_SPE
393         /* save spe registers */
394         if (current->thread.used_spe) {
395                 flush_spe_to_thread(current);
396                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
397                                    ELF_NEVRREG * sizeof(u32)))
398                         return 1;
399                 /* set MSR_SPE in the saved MSR value to indicate that
400                    frame->mc_vregs contains valid data */
401                 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
402                         return 1;
403         }
404         /* else assert((regs->msr & MSR_SPE) == 0) */
405
406         /* We always copy to/from spefscr */
407         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
408                 return 1;
409 #endif /* CONFIG_SPE */
410
411         if (sigret) {
412                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
413                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
414                     || __put_user(0x44000002UL, &frame->tramp[1]))
415                         return 1;
416                 flush_icache_range((unsigned long) &frame->tramp[0],
417                                    (unsigned long) &frame->tramp[2]);
418         }
419
420         return 0;
421 }
422
423 /*
424  * Restore the current user register values from the user stack,
425  * (except for MSR).
426  */
427 static long restore_user_regs(struct pt_regs *regs,
428                               struct mcontext __user *sr, int sig)
429 {
430         long err;
431         unsigned int save_r2 = 0;
432 #if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
433         unsigned long msr;
434 #endif
435
436         /*
437          * restore general registers but not including MSR or SOFTE. Also
438          * take care of keeping r2 (TLS) intact if not a signal
439          */
440         if (!sig)
441                 save_r2 = (unsigned int)regs->gpr[2];
442         err = restore_general_regs(regs, sr);
443         if (!sig)
444                 regs->gpr[2] = (unsigned long) save_r2;
445         if (err)
446                 return 1;
447
448         /*
449          * Do this before updating the thread state in
450          * current->thread.fpr/vr/evr.  That way, if we get preempted
451          * and another task grabs the FPU/Altivec/SPE, it won't be
452          * tempted to save the current CPU state into the thread_struct
453          * and corrupt what we are writing there.
454          */
455         discard_lazy_cpu_state();
456
457         /* force the process to reload the FP registers from
458            current->thread when it next does FP instructions */
459         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
460         if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
461                              sizeof(sr->mc_fregs)))
462                 return 1;
463
464 #ifdef CONFIG_ALTIVEC
465         /* force the process to reload the altivec registers from
466            current->thread when it next does altivec instructions */
467         regs->msr &= ~MSR_VEC;
468         if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
469                 /* restore altivec registers from the stack */
470                 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
471                                      sizeof(sr->mc_vregs)))
472                         return 1;
473         } else if (current->thread.used_vr)
474                 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
475
476         /* Always get VRSAVE back */
477         if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
478                 return 1;
479 #endif /* CONFIG_ALTIVEC */
480
481 #ifdef CONFIG_SPE
482         /* force the process to reload the spe registers from
483            current->thread when it next does spe instructions */
484         regs->msr &= ~MSR_SPE;
485         if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
486                 /* restore spe registers from the stack */
487                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
488                                      ELF_NEVRREG * sizeof(u32)))
489                         return 1;
490         } else if (current->thread.used_spe)
491                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
492
493         /* Always get SPEFSCR back */
494         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
495                 return 1;
496 #endif /* CONFIG_SPE */
497
498         return 0;
499 }
500
501 #ifdef CONFIG_PPC64
502 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
503                 struct sigaction32 __user *oact, size_t sigsetsize)
504 {
505         struct k_sigaction new_ka, old_ka;
506         int ret;
507
508         /* XXX: Don't preclude handling different sized sigset_t's.  */
509         if (sigsetsize != sizeof(compat_sigset_t))
510                 return -EINVAL;
511
512         if (act) {
513                 compat_uptr_t handler;
514
515                 ret = get_user(handler, &act->sa_handler);
516                 new_ka.sa.sa_handler = compat_ptr(handler);
517                 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
518                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
519                 if (ret)
520                         return -EFAULT;
521         }
522
523         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
524         if (!ret && oact) {
525                 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
526                 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
527                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
528         }
529         return ret;
530 }
531
532 /*
533  * Note: it is necessary to treat how as an unsigned int, with the
534  * corresponding cast to a signed int to insure that the proper
535  * conversion (sign extension) between the register representation
536  * of a signed int (msr in 32-bit mode) and the register representation
537  * of a signed int (msr in 64-bit mode) is performed.
538  */
539 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
540                 compat_sigset_t __user *oset, size_t sigsetsize)
541 {
542         sigset_t s;
543         sigset_t __user *up;
544         int ret;
545         mm_segment_t old_fs = get_fs();
546
547         if (set) {
548                 if (get_sigset_t(&s, set))
549                         return -EFAULT;
550         }
551
552         set_fs(KERNEL_DS);
553         /* This is valid because of the set_fs() */
554         up = (sigset_t __user *) &s;
555         ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
556                                  sigsetsize);
557         set_fs(old_fs);
558         if (ret)
559                 return ret;
560         if (oset) {
561                 if (put_sigset_t(oset, &s))
562                         return -EFAULT;
563         }
564         return 0;
565 }
566
567 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
568 {
569         sigset_t s;
570         int ret;
571         mm_segment_t old_fs = get_fs();
572
573         set_fs(KERNEL_DS);
574         /* The __user pointer cast is valid because of the set_fs() */
575         ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
576         set_fs(old_fs);
577         if (!ret) {
578                 if (put_sigset_t(set, &s))
579                         return -EFAULT;
580         }
581         return ret;
582 }
583
584
585 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
586 {
587         int err;
588
589         if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
590                 return -EFAULT;
591
592         /* If you change siginfo_t structure, please be sure
593          * this code is fixed accordingly.
594          * It should never copy any pad contained in the structure
595          * to avoid security leaks, but must copy the generic
596          * 3 ints plus the relevant union member.
597          * This routine must convert siginfo from 64bit to 32bit as well
598          * at the same time.
599          */
600         err = __put_user(s->si_signo, &d->si_signo);
601         err |= __put_user(s->si_errno, &d->si_errno);
602         err |= __put_user((short)s->si_code, &d->si_code);
603         if (s->si_code < 0)
604                 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
605                                       SI_PAD_SIZE32);
606         else switch(s->si_code >> 16) {
607         case __SI_CHLD >> 16:
608                 err |= __put_user(s->si_pid, &d->si_pid);
609                 err |= __put_user(s->si_uid, &d->si_uid);
610                 err |= __put_user(s->si_utime, &d->si_utime);
611                 err |= __put_user(s->si_stime, &d->si_stime);
612                 err |= __put_user(s->si_status, &d->si_status);
613                 break;
614         case __SI_FAULT >> 16:
615                 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
616                                   &d->si_addr);
617                 break;
618         case __SI_POLL >> 16:
619                 err |= __put_user(s->si_band, &d->si_band);
620                 err |= __put_user(s->si_fd, &d->si_fd);
621                 break;
622         case __SI_TIMER >> 16:
623                 err |= __put_user(s->si_tid, &d->si_tid);
624                 err |= __put_user(s->si_overrun, &d->si_overrun);
625                 err |= __put_user(s->si_int, &d->si_int);
626                 break;
627         case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
628         case __SI_MESGQ >> 16:
629                 err |= __put_user(s->si_int, &d->si_int);
630                 /* fallthrough */
631         case __SI_KILL >> 16:
632         default:
633                 err |= __put_user(s->si_pid, &d->si_pid);
634                 err |= __put_user(s->si_uid, &d->si_uid);
635                 break;
636         }
637         return err;
638 }
639
640 #define copy_siginfo_to_user    copy_siginfo_to_user32
641
642 /*
643  * Note: it is necessary to treat pid and sig as unsigned ints, with the
644  * corresponding cast to a signed int to insure that the proper conversion
645  * (sign extension) between the register representation of a signed int
646  * (msr in 32-bit mode) and the register representation of a signed int
647  * (msr in 64-bit mode) is performed.
648  */
649 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
650 {
651         siginfo_t info;
652         int ret;
653         mm_segment_t old_fs = get_fs();
654
655         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
656             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
657                 return -EFAULT;
658         set_fs (KERNEL_DS);
659         /* The __user pointer cast is valid becasuse of the set_fs() */
660         ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
661         set_fs (old_fs);
662         return ret;
663 }
664 /*
665  *  Start Alternate signal stack support
666  *
667  *  System Calls
668  *       sigaltatck               compat_sys_sigaltstack
669  */
670
671 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
672                       int r6, int r7, int r8, struct pt_regs *regs)
673 {
674         stack_32_t __user * newstack = compat_ptr(__new);
675         stack_32_t __user * oldstack = compat_ptr(__old);
676         stack_t uss, uoss;
677         int ret;
678         mm_segment_t old_fs;
679         unsigned long sp;
680         compat_uptr_t ss_sp;
681
682         /*
683          * set sp to the user stack on entry to the system call
684          * the system call router sets R9 to the saved registers
685          */
686         sp = regs->gpr[1];
687
688         /* Put new stack info in local 64 bit stack struct */
689         if (newstack) {
690                 if (get_user(ss_sp, &newstack->ss_sp) ||
691                     __get_user(uss.ss_flags, &newstack->ss_flags) ||
692                     __get_user(uss.ss_size, &newstack->ss_size))
693                         return -EFAULT;
694                 uss.ss_sp = compat_ptr(ss_sp);
695         }
696
697         old_fs = get_fs();
698         set_fs(KERNEL_DS);
699         /* The __user pointer casts are valid because of the set_fs() */
700         ret = do_sigaltstack(
701                 newstack ? (stack_t __user *) &uss : NULL,
702                 oldstack ? (stack_t __user *) &uoss : NULL,
703                 sp);
704         set_fs(old_fs);
705         /* Copy the stack information to the user output buffer */
706         if (!ret && oldstack  &&
707                 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
708                  __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
709                  __put_user(uoss.ss_size, &oldstack->ss_size)))
710                 return -EFAULT;
711         return ret;
712 }
713 #endif /* CONFIG_PPC64 */
714
715
716 /*
717  * Restore the user process's signal mask
718  */
719 #ifdef CONFIG_PPC64
720 extern void restore_sigmask(sigset_t *set);
721 #else /* CONFIG_PPC64 */
722 static void restore_sigmask(sigset_t *set)
723 {
724         sigdelsetmask(set, ~_BLOCKABLE);
725         spin_lock_irq(&current->sighand->siglock);
726         current->blocked = *set;
727         recalc_sigpending();
728         spin_unlock_irq(&current->sighand->siglock);
729 }
730 #endif
731
732 /*
733  * Set up a signal frame for a "real-time" signal handler
734  * (one which gets siginfo).
735  */
736 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
737                 siginfo_t *info, sigset_t *oldset,
738                 struct pt_regs *regs, unsigned long newsp)
739 {
740         struct rt_sigframe __user *rt_sf;
741         struct mcontext __user *frame;
742         unsigned long origsp = newsp;
743
744         /* Set up Signal Frame */
745         /* Put a Real Time Context onto stack */
746         newsp -= sizeof(*rt_sf);
747         rt_sf = (struct rt_sigframe __user *)newsp;
748
749         /* create a stack frame for the caller of the handler */
750         newsp -= __SIGNAL_FRAMESIZE + 16;
751
752         if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
753                 goto badframe;
754
755         /* Put the siginfo & fill in most of the ucontext */
756         if (copy_siginfo_to_user(&rt_sf->info, info)
757             || __put_user(0, &rt_sf->uc.uc_flags)
758             || __put_user(0, &rt_sf->uc.uc_link)
759             || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
760             || __put_user(sas_ss_flags(regs->gpr[1]),
761                           &rt_sf->uc.uc_stack.ss_flags)
762             || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
763             || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
764                     &rt_sf->uc.uc_regs)
765             || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
766                 goto badframe;
767
768         /* Save user registers on the stack */
769         frame = &rt_sf->uc.uc_mcontext;
770         if (vdso32_rt_sigtramp && current->thread.vdso_base) {
771                 if (save_user_regs(regs, frame, 0))
772                         goto badframe;
773                 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
774         } else {
775                 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
776                         goto badframe;
777                 regs->link = (unsigned long) frame->tramp;
778         }
779
780         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
781
782         if (put_user(regs->gpr[1], (u32 __user *)newsp))
783                 goto badframe;
784         regs->gpr[1] = newsp;
785         regs->gpr[3] = sig;
786         regs->gpr[4] = (unsigned long) &rt_sf->info;
787         regs->gpr[5] = (unsigned long) &rt_sf->uc;
788         regs->gpr[6] = (unsigned long) rt_sf;
789         regs->nip = (unsigned long) ka->sa.sa_handler;
790         regs->trap = 0;
791         return 1;
792
793 badframe:
794 #ifdef DEBUG_SIG
795         printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
796                regs, frame, newsp);
797 #endif
798         force_sigsegv(sig, current);
799         return 0;
800 }
801
802 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
803 {
804         sigset_t set;
805         struct mcontext __user *mcp;
806
807         if (get_sigset_t(&set, &ucp->uc_sigmask))
808                 return -EFAULT;
809 #ifdef CONFIG_PPC64
810         {
811                 u32 cmcp;
812
813                 if (__get_user(cmcp, &ucp->uc_regs))
814                         return -EFAULT;
815                 mcp = (struct mcontext __user *)(u64)cmcp;
816         }
817 #else
818         if (__get_user(mcp, &ucp->uc_regs))
819                 return -EFAULT;
820 #endif
821         restore_sigmask(&set);
822         if (restore_user_regs(regs, mcp, sig))
823                 return -EFAULT;
824
825         return 0;
826 }
827
828 long sys_swapcontext(struct ucontext __user *old_ctx,
829                        struct ucontext __user *new_ctx,
830                        int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
831 {
832         unsigned char tmp;
833
834         /* Context size is for future use. Right now, we only make sure
835          * we are passed something we understand
836          */
837         if (ctx_size < sizeof(struct ucontext))
838                 return -EINVAL;
839
840         if (old_ctx != NULL) {
841                 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
842                     || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
843                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
844                     || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
845                             &old_ctx->uc_regs))
846                         return -EFAULT;
847         }
848         if (new_ctx == NULL)
849                 return 0;
850         if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
851             || __get_user(tmp, (u8 __user *) new_ctx)
852             || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
853                 return -EFAULT;
854
855         /*
856          * If we get a fault copying the context into the kernel's
857          * image of the user's registers, we can't just return -EFAULT
858          * because the user's registers will be corrupted.  For instance
859          * the NIP value may have been updated but not some of the
860          * other registers.  Given that we have done the access_ok
861          * and successfully read the first and last bytes of the region
862          * above, this should only happen in an out-of-memory situation
863          * or if another thread unmaps the region containing the context.
864          * We kill the task with a SIGSEGV in this situation.
865          */
866         if (do_setcontext(new_ctx, regs, 0))
867                 do_exit(SIGSEGV);
868
869         set_thread_flag(TIF_RESTOREALL);
870         return 0;
871 }
872
873 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
874                      struct pt_regs *regs)
875 {
876         struct rt_sigframe __user *rt_sf;
877
878         /* Always make any pending restarted system calls return -EINTR */
879         current_thread_info()->restart_block.fn = do_no_restart_syscall;
880
881         rt_sf = (struct rt_sigframe __user *)
882                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
883         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
884                 goto bad;
885         if (do_setcontext(&rt_sf->uc, regs, 1))
886                 goto bad;
887
888         /*
889          * It's not clear whether or why it is desirable to save the
890          * sigaltstack setting on signal delivery and restore it on
891          * signal return.  But other architectures do this and we have
892          * always done it up until now so it is probably better not to
893          * change it.  -- paulus
894          */
895 #ifdef CONFIG_PPC64
896         /*
897          * We use the compat_sys_ version that does the 32/64 bits conversion
898          * and takes userland pointer directly. What about error checking ?
899          * nobody does any...
900          */
901         compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
902 #else
903         do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
904 #endif
905         set_thread_flag(TIF_RESTOREALL);
906         return 0;
907
908  bad:
909         force_sig(SIGSEGV, current);
910         return 0;
911 }
912
913 #ifdef CONFIG_PPC32
914 int sys_debug_setcontext(struct ucontext __user *ctx,
915                          int ndbg, struct sig_dbg_op __user *dbg,
916                          int r6, int r7, int r8,
917                          struct pt_regs *regs)
918 {
919         struct sig_dbg_op op;
920         int i;
921         unsigned long new_msr = regs->msr;
922 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
923         unsigned long new_dbcr0 = current->thread.dbcr0;
924 #endif
925
926         for (i=0; i<ndbg; i++) {
927                 if (__copy_from_user(&op, dbg, sizeof(op)))
928                         return -EFAULT;
929                 switch (op.dbg_type) {
930                 case SIG_DBG_SINGLE_STEPPING:
931 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
932                         if (op.dbg_value) {
933                                 new_msr |= MSR_DE;
934                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
935                         } else {
936                                 new_msr &= ~MSR_DE;
937                                 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
938                         }
939 #else
940                         if (op.dbg_value)
941                                 new_msr |= MSR_SE;
942                         else
943                                 new_msr &= ~MSR_SE;
944 #endif
945                         break;
946                 case SIG_DBG_BRANCH_TRACING:
947 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
948                         return -EINVAL;
949 #else
950                         if (op.dbg_value)
951                                 new_msr |= MSR_BE;
952                         else
953                                 new_msr &= ~MSR_BE;
954 #endif
955                         break;
956
957                 default:
958                         return -EINVAL;
959                 }
960         }
961
962         /* We wait until here to actually install the values in the
963            registers so if we fail in the above loop, it will not
964            affect the contents of these registers.  After this point,
965            failure is a problem, anyway, and it's very unlikely unless
966            the user is really doing something wrong. */
967         regs->msr = new_msr;
968 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
969         current->thread.dbcr0 = new_dbcr0;
970 #endif
971
972         /*
973          * If we get a fault copying the context into the kernel's
974          * image of the user's registers, we can't just return -EFAULT
975          * because the user's registers will be corrupted.  For instance
976          * the NIP value may have been updated but not some of the
977          * other registers.  Given that we have done the access_ok
978          * and successfully read the first and last bytes of the region
979          * above, this should only happen in an out-of-memory situation
980          * or if another thread unmaps the region containing the context.
981          * We kill the task with a SIGSEGV in this situation.
982          */
983         if (do_setcontext(ctx, regs, 1)) {
984                 force_sig(SIGSEGV, current);
985                 goto out;
986         }
987
988         /*
989          * It's not clear whether or why it is desirable to save the
990          * sigaltstack setting on signal delivery and restore it on
991          * signal return.  But other architectures do this and we have
992          * always done it up until now so it is probably better not to
993          * change it.  -- paulus
994          */
995         do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
996
997         set_thread_flag(TIF_RESTOREALL);
998  out:
999         return 0;
1000 }
1001 #endif
1002
1003 /*
1004  * OK, we're invoking a handler
1005  */
1006 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1007                 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1008                 unsigned long newsp)
1009 {
1010         struct sigcontext __user *sc;
1011         struct sigregs __user *frame;
1012         unsigned long origsp = newsp;
1013
1014         /* Set up Signal Frame */
1015         newsp -= sizeof(struct sigregs);
1016         frame = (struct sigregs __user *) newsp;
1017
1018         /* Put a sigcontext on the stack */
1019         newsp -= sizeof(*sc);
1020         sc = (struct sigcontext __user *) newsp;
1021
1022         /* create a stack frame for the caller of the handler */
1023         newsp -= __SIGNAL_FRAMESIZE;
1024
1025         if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1026                 goto badframe;
1027
1028 #if _NSIG != 64
1029 #error "Please adjust handle_signal()"
1030 #endif
1031         if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1032             || __put_user(oldset->sig[0], &sc->oldmask)
1033 #ifdef CONFIG_PPC64
1034             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1035 #else
1036             || __put_user(oldset->sig[1], &sc->_unused[3])
1037 #endif
1038             || __put_user(to_user_ptr(frame), &sc->regs)
1039             || __put_user(sig, &sc->signal))
1040                 goto badframe;
1041
1042         if (vdso32_sigtramp && current->thread.vdso_base) {
1043                 if (save_user_regs(regs, &frame->mctx, 0))
1044                         goto badframe;
1045                 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1046         } else {
1047                 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1048                         goto badframe;
1049                 regs->link = (unsigned long) frame->mctx.tramp;
1050         }
1051
1052         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
1053
1054         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1055                 goto badframe;
1056         regs->gpr[1] = newsp;
1057         regs->gpr[3] = sig;
1058         regs->gpr[4] = (unsigned long) sc;
1059         regs->nip = (unsigned long) ka->sa.sa_handler;
1060         regs->trap = 0;
1061
1062         return 1;
1063
1064 badframe:
1065 #ifdef DEBUG_SIG
1066         printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1067                regs, frame, newsp);
1068 #endif
1069         force_sigsegv(sig, current);
1070         return 0;
1071 }
1072
1073 /*
1074  * Do a signal return; undo the signal stack.
1075  */
1076 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1077                        struct pt_regs *regs)
1078 {
1079         struct sigcontext __user *sc;
1080         struct sigcontext sigctx;
1081         struct mcontext __user *sr;
1082         sigset_t set;
1083
1084         /* Always make any pending restarted system calls return -EINTR */
1085         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1086
1087         sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1088         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1089                 goto badframe;
1090
1091 #ifdef CONFIG_PPC64
1092         /*
1093          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1094          * unused part of the signal stackframe
1095          */
1096         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1097 #else
1098         set.sig[0] = sigctx.oldmask;
1099         set.sig[1] = sigctx._unused[3];
1100 #endif
1101         restore_sigmask(&set);
1102
1103         sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1104         if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1105             || restore_user_regs(regs, sr, 1))
1106                 goto badframe;
1107
1108         set_thread_flag(TIF_RESTOREALL);
1109         return 0;
1110
1111 badframe:
1112         force_sig(SIGSEGV, current);
1113         return 0;
1114 }
1115
1116 /*
1117  * Note that 'init' is a special process: it doesn't get signals it doesn't
1118  * want to handle. Thus you cannot kill init even with a SIGKILL even by
1119  * mistake.
1120  */
1121 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1122 {
1123         siginfo_t info;
1124         struct k_sigaction ka;
1125         unsigned int newsp;
1126         int signr, ret;
1127
1128 #ifdef CONFIG_PPC32
1129         if (try_to_freeze()) {
1130                 signr = 0;
1131                 if (!signal_pending(current))
1132                         goto no_signal;
1133         }
1134 #endif
1135
1136         if (test_thread_flag(TIF_RESTORE_SIGMASK))
1137                 oldset = &current->saved_sigmask;
1138         else if (!oldset)
1139                 oldset = &current->blocked;
1140
1141         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1142 #ifdef CONFIG_PPC32
1143 no_signal:
1144 #endif
1145         if (TRAP(regs) == 0x0C00                /* System Call! */
1146             && regs->ccr & 0x10000000           /* error signalled */
1147             && ((ret = regs->gpr[3]) == ERESTARTSYS
1148                 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1149                 || ret == ERESTART_RESTARTBLOCK)) {
1150
1151                 if (signr > 0
1152                     && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1153                         || (ret == ERESTARTSYS
1154                             && !(ka.sa.sa_flags & SA_RESTART)))) {
1155                         /* make the system call return an EINTR error */
1156                         regs->result = -EINTR;
1157                         regs->gpr[3] = EINTR;
1158                         /* note that the cr0.SO bit is already set */
1159                 } else {
1160                         regs->nip -= 4; /* Back up & retry system call */
1161                         regs->result = 0;
1162                         regs->trap = 0;
1163                         if (ret == ERESTART_RESTARTBLOCK)
1164                                 regs->gpr[0] = __NR_restart_syscall;
1165                         else
1166                                 regs->gpr[3] = regs->orig_gpr3;
1167                 }
1168         }
1169
1170         if (signr == 0) {
1171                 /* No signal to deliver -- put the saved sigmask back */
1172                 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1173                         clear_thread_flag(TIF_RESTORE_SIGMASK);
1174                         sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
1175                 }
1176                 return 0;               /* no signals delivered */
1177         }
1178
1179         if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1180             && !on_sig_stack(regs->gpr[1]))
1181                 newsp = current->sas_ss_sp + current->sas_ss_size;
1182         else
1183                 newsp = regs->gpr[1];
1184         newsp &= ~0xfUL;
1185
1186 #ifdef CONFIG_PPC64
1187         /*
1188          * Reenable the DABR before delivering the signal to
1189          * user space. The DABR will have been cleared if it
1190          * triggered inside the kernel.
1191          */
1192         if (current->thread.dabr)
1193                 set_dabr(current->thread.dabr);
1194 #endif
1195
1196         /* Whee!  Actually deliver the signal.  */
1197         if (ka.sa.sa_flags & SA_SIGINFO)
1198                 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1199         else
1200                 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1201
1202         if (ret) {
1203                 spin_lock_irq(&current->sighand->siglock);
1204                 sigorsets(&current->blocked, &current->blocked,
1205                           &ka.sa.sa_mask);
1206                 if (!(ka.sa.sa_flags & SA_NODEFER))
1207                         sigaddset(&current->blocked, signr);
1208                 recalc_sigpending();
1209                 spin_unlock_irq(&current->sighand->siglock);
1210                 /* A signal was successfully delivered; the saved sigmask is in
1211                    its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
1212                 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1213                         clear_thread_flag(TIF_RESTORE_SIGMASK);
1214         }
1215
1216         return ret;
1217 }