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