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