[PATCH] Add include/linux/freezer.h and move definitions from sched.h
[linux-2.6.git] / arch / powerpc / kernel / signal_32.c
1 /*
2  * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
3  *
4  *  PowerPC version
5  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
6  * Copyright (C) 2001 IBM
7  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8  * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
9  *
10  *  Derived from "arch/i386/kernel/signal.c"
11  *    Copyright (C) 1991, 1992 Linus Torvalds
12  *    1997-11-28  Modified for POSIX.1b signals by Richard Henderson
13  *
14  *  This program is free software; you can redistribute it and/or
15  *  modify it under the terms of the GNU General Public License
16  *  as published by the Free Software Foundation; either version
17  *  2 of the License, or (at your option) any later version.
18  */
19
20 #include <linux/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                 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
839                     || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
840                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
841                     || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
842                             &old_ctx->uc_regs))
843                         return -EFAULT;
844         }
845         if (new_ctx == NULL)
846                 return 0;
847         if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
848             || __get_user(tmp, (u8 __user *) new_ctx)
849             || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
850                 return -EFAULT;
851
852         /*
853          * If we get a fault copying the context into the kernel's
854          * image of the user's registers, we can't just return -EFAULT
855          * because the user's registers will be corrupted.  For instance
856          * the NIP value may have been updated but not some of the
857          * other registers.  Given that we have done the access_ok
858          * and successfully read the first and last bytes of the region
859          * above, this should only happen in an out-of-memory situation
860          * or if another thread unmaps the region containing the context.
861          * We kill the task with a SIGSEGV in this situation.
862          */
863         if (do_setcontext(new_ctx, regs, 0))
864                 do_exit(SIGSEGV);
865
866         set_thread_flag(TIF_RESTOREALL);
867         return 0;
868 }
869
870 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
871                      struct pt_regs *regs)
872 {
873         struct rt_sigframe __user *rt_sf;
874
875         /* Always make any pending restarted system calls return -EINTR */
876         current_thread_info()->restart_block.fn = do_no_restart_syscall;
877
878         rt_sf = (struct rt_sigframe __user *)
879                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
880         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
881                 goto bad;
882         if (do_setcontext(&rt_sf->uc, regs, 1))
883                 goto bad;
884
885         /*
886          * It's not clear whether or why it is desirable to save the
887          * sigaltstack setting on signal delivery and restore it on
888          * signal return.  But other architectures do this and we have
889          * always done it up until now so it is probably better not to
890          * change it.  -- paulus
891          */
892 #ifdef CONFIG_PPC64
893         /*
894          * We use the compat_sys_ version that does the 32/64 bits conversion
895          * and takes userland pointer directly. What about error checking ?
896          * nobody does any...
897          */
898         compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
899 #else
900         do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
901 #endif
902         set_thread_flag(TIF_RESTOREALL);
903         return 0;
904
905  bad:
906         force_sig(SIGSEGV, current);
907         return 0;
908 }
909
910 #ifdef CONFIG_PPC32
911 int sys_debug_setcontext(struct ucontext __user *ctx,
912                          int ndbg, struct sig_dbg_op __user *dbg,
913                          int r6, int r7, int r8,
914                          struct pt_regs *regs)
915 {
916         struct sig_dbg_op op;
917         int i;
918         unsigned char tmp;
919         unsigned long new_msr = regs->msr;
920 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
921         unsigned long new_dbcr0 = current->thread.dbcr0;
922 #endif
923
924         for (i=0; i<ndbg; i++) {
925                 if (copy_from_user(&op, dbg + i, sizeof(op)))
926                         return -EFAULT;
927                 switch (op.dbg_type) {
928                 case SIG_DBG_SINGLE_STEPPING:
929 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
930                         if (op.dbg_value) {
931                                 new_msr |= MSR_DE;
932                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
933                         } else {
934                                 new_msr &= ~MSR_DE;
935                                 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
936                         }
937 #else
938                         if (op.dbg_value)
939                                 new_msr |= MSR_SE;
940                         else
941                                 new_msr &= ~MSR_SE;
942 #endif
943                         break;
944                 case SIG_DBG_BRANCH_TRACING:
945 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
946                         return -EINVAL;
947 #else
948                         if (op.dbg_value)
949                                 new_msr |= MSR_BE;
950                         else
951                                 new_msr &= ~MSR_BE;
952 #endif
953                         break;
954
955                 default:
956                         return -EINVAL;
957                 }
958         }
959
960         /* We wait until here to actually install the values in the
961            registers so if we fail in the above loop, it will not
962            affect the contents of these registers.  After this point,
963            failure is a problem, anyway, and it's very unlikely unless
964            the user is really doing something wrong. */
965         regs->msr = new_msr;
966 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
967         current->thread.dbcr0 = new_dbcr0;
968 #endif
969
970         if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
971             || __get_user(tmp, (u8 __user *) ctx)
972             || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
973                 return -EFAULT;
974
975         /*
976          * If we get a fault copying the context into the kernel's
977          * image of the user's registers, we can't just return -EFAULT
978          * because the user's registers will be corrupted.  For instance
979          * the NIP value may have been updated but not some of the
980          * other registers.  Given that we have done the access_ok
981          * and successfully read the first and last bytes of the region
982          * above, this should only happen in an out-of-memory situation
983          * or if another thread unmaps the region containing the context.
984          * We kill the task with a SIGSEGV in this situation.
985          */
986         if (do_setcontext(ctx, regs, 1)) {
987                 force_sig(SIGSEGV, current);
988                 goto out;
989         }
990
991         /*
992          * It's not clear whether or why it is desirable to save the
993          * sigaltstack setting on signal delivery and restore it on
994          * signal return.  But other architectures do this and we have
995          * always done it up until now so it is probably better not to
996          * change it.  -- paulus
997          */
998         do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
999
1000         set_thread_flag(TIF_RESTOREALL);
1001  out:
1002         return 0;
1003 }
1004 #endif
1005
1006 /*
1007  * OK, we're invoking a handler
1008  */
1009 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1010                 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1011                 unsigned long newsp)
1012 {
1013         struct sigcontext __user *sc;
1014         struct sigregs __user *frame;
1015         unsigned long origsp = newsp;
1016
1017         /* Set up Signal Frame */
1018         newsp -= sizeof(struct sigregs);
1019         frame = (struct sigregs __user *) newsp;
1020
1021         /* Put a sigcontext on the stack */
1022         newsp -= sizeof(*sc);
1023         sc = (struct sigcontext __user *) newsp;
1024
1025         /* create a stack frame for the caller of the handler */
1026         newsp -= __SIGNAL_FRAMESIZE;
1027
1028         if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1029                 goto badframe;
1030
1031 #if _NSIG != 64
1032 #error "Please adjust handle_signal()"
1033 #endif
1034         if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1035             || __put_user(oldset->sig[0], &sc->oldmask)
1036 #ifdef CONFIG_PPC64
1037             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1038 #else
1039             || __put_user(oldset->sig[1], &sc->_unused[3])
1040 #endif
1041             || __put_user(to_user_ptr(frame), &sc->regs)
1042             || __put_user(sig, &sc->signal))
1043                 goto badframe;
1044
1045         if (vdso32_sigtramp && current->mm->context.vdso_base) {
1046                 if (save_user_regs(regs, &frame->mctx, 0))
1047                         goto badframe;
1048                 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
1049         } else {
1050                 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1051                         goto badframe;
1052                 regs->link = (unsigned long) frame->mctx.tramp;
1053         }
1054
1055         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
1056
1057         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1058                 goto badframe;
1059         regs->gpr[1] = newsp;
1060         regs->gpr[3] = sig;
1061         regs->gpr[4] = (unsigned long) sc;
1062         regs->nip = (unsigned long) ka->sa.sa_handler;
1063         /* enter the signal handler in big-endian mode */
1064         regs->msr &= ~MSR_LE;
1065         regs->trap = 0;
1066
1067         return 1;
1068
1069 badframe:
1070 #ifdef DEBUG_SIG
1071         printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1072                regs, frame, newsp);
1073 #endif
1074         force_sigsegv(sig, current);
1075         return 0;
1076 }
1077
1078 /*
1079  * Do a signal return; undo the signal stack.
1080  */
1081 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1082                        struct pt_regs *regs)
1083 {
1084         struct sigcontext __user *sc;
1085         struct sigcontext sigctx;
1086         struct mcontext __user *sr;
1087         sigset_t set;
1088
1089         /* Always make any pending restarted system calls return -EINTR */
1090         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1091
1092         sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1093         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1094                 goto badframe;
1095
1096 #ifdef CONFIG_PPC64
1097         /*
1098          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1099          * unused part of the signal stackframe
1100          */
1101         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1102 #else
1103         set.sig[0] = sigctx.oldmask;
1104         set.sig[1] = sigctx._unused[3];
1105 #endif
1106         restore_sigmask(&set);
1107
1108         sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1109         if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1110             || restore_user_regs(regs, sr, 1))
1111                 goto badframe;
1112
1113         set_thread_flag(TIF_RESTOREALL);
1114         return 0;
1115
1116 badframe:
1117         force_sig(SIGSEGV, current);
1118         return 0;
1119 }
1120
1121 /*
1122  * Note that 'init' is a special process: it doesn't get signals it doesn't
1123  * want to handle. Thus you cannot kill init even with a SIGKILL even by
1124  * mistake.
1125  */
1126 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1127 {
1128         siginfo_t info;
1129         struct k_sigaction ka;
1130         unsigned int newsp;
1131         int signr, ret;
1132
1133 #ifdef CONFIG_PPC32
1134         if (try_to_freeze()) {
1135                 signr = 0;
1136                 if (!signal_pending(current))
1137                         goto no_signal;
1138         }
1139 #endif
1140
1141         if (test_thread_flag(TIF_RESTORE_SIGMASK))
1142                 oldset = &current->saved_sigmask;
1143         else if (!oldset)
1144                 oldset = &current->blocked;
1145
1146         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1147 #ifdef CONFIG_PPC32
1148 no_signal:
1149 #endif
1150         if (TRAP(regs) == 0x0C00                /* System Call! */
1151             && regs->ccr & 0x10000000           /* error signalled */
1152             && ((ret = regs->gpr[3]) == ERESTARTSYS
1153                 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1154                 || ret == ERESTART_RESTARTBLOCK)) {
1155
1156                 if (signr > 0
1157                     && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1158                         || (ret == ERESTARTSYS
1159                             && !(ka.sa.sa_flags & SA_RESTART)))) {
1160                         /* make the system call return an EINTR error */
1161                         regs->result = -EINTR;
1162                         regs->gpr[3] = EINTR;
1163                         /* note that the cr0.SO bit is already set */
1164                 } else {
1165                         regs->nip -= 4; /* Back up & retry system call */
1166                         regs->result = 0;
1167                         regs->trap = 0;
1168                         if (ret == ERESTART_RESTARTBLOCK)
1169                                 regs->gpr[0] = __NR_restart_syscall;
1170                         else
1171                                 regs->gpr[3] = regs->orig_gpr3;
1172                 }
1173         }
1174
1175         if (signr == 0) {
1176                 /* No signal to deliver -- put the saved sigmask back */
1177                 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1178                         clear_thread_flag(TIF_RESTORE_SIGMASK);
1179                         sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
1180                 }
1181                 return 0;               /* no signals delivered */
1182         }
1183
1184         if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1185             && !on_sig_stack(regs->gpr[1]))
1186                 newsp = current->sas_ss_sp + current->sas_ss_size;
1187         else
1188                 newsp = regs->gpr[1];
1189         newsp &= ~0xfUL;
1190
1191 #ifdef CONFIG_PPC64
1192         /*
1193          * Reenable the DABR before delivering the signal to
1194          * user space. The DABR will have been cleared if it
1195          * triggered inside the kernel.
1196          */
1197         if (current->thread.dabr)
1198                 set_dabr(current->thread.dabr);
1199 #endif
1200
1201         /* Whee!  Actually deliver the signal.  */
1202         if (ka.sa.sa_flags & SA_SIGINFO)
1203                 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1204         else
1205                 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1206
1207         if (ret) {
1208                 spin_lock_irq(&current->sighand->siglock);
1209                 sigorsets(&current->blocked, &current->blocked,
1210                           &ka.sa.sa_mask);
1211                 if (!(ka.sa.sa_flags & SA_NODEFER))
1212                         sigaddset(&current->blocked, signr);
1213                 recalc_sigpending();
1214                 spin_unlock_irq(&current->sighand->siglock);
1215                 /* A signal was successfully delivered; the saved sigmask is in
1216                    its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
1217                 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1218                         clear_thread_flag(TIF_RESTORE_SIGMASK);
1219         }
1220
1221         return ret;
1222 }