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