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