blob: b96a3a010c26859ab93f8cca5ec74cd4905dd16b [file] [log] [blame]
Stephen Rothwell81e70092005-10-18 11:17:58 +10001/*
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
Stephen Rothwell81e70092005-10-18 11:17:58 +100020#include <linux/sched.h>
21#include <linux/mm.h>
22#include <linux/smp.h>
Stephen Rothwell81e70092005-10-18 11:17:58 +100023#include <linux/kernel.h>
24#include <linux/signal.h>
25#include <linux/errno.h>
26#include <linux/elf.h>
Lucas Woods05ead012007-12-13 15:56:06 -080027#include <linux/ptrace.h>
Stephen Rothwell81e70092005-10-18 11:17:58 +100028#ifdef CONFIG_PPC64
29#include <linux/syscalls.h>
30#include <linux/compat.h>
Stephen Rothwell81e70092005-10-18 11:17:58 +100031#else
32#include <linux/wait.h>
Stephen Rothwell81e70092005-10-18 11:17:58 +100033#include <linux/unistd.h>
34#include <linux/stddef.h>
35#include <linux/tty.h>
36#include <linux/binfmts.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080037#include <linux/freezer.h>
Stephen Rothwell81e70092005-10-18 11:17:58 +100038#endif
39
40#include <asm/uaccess.h>
41#include <asm/cacheflush.h>
Arnd Bergmanna7f31842006-03-23 00:00:08 +010042#include <asm/syscalls.h>
David Gibsonc5ff7002005-11-09 11:21:07 +110043#include <asm/sigcontext.h>
Benjamin Herrenschmidta7f290d2005-11-11 21:15:21 +110044#include <asm/vdso.h>
Stephen Rothwell81e70092005-10-18 11:17:58 +100045#ifdef CONFIG_PPC64
Stephen Rothwell879168e2005-11-03 15:32:07 +110046#include "ppc32.h"
Stephen Rothwell81e70092005-10-18 11:17:58 +100047#include <asm/unistd.h>
Stephen Rothwell81e70092005-10-18 11:17:58 +100048#else
49#include <asm/ucontext.h>
50#include <asm/pgtable.h>
51#endif
52
Benjamin Herrenschmidt22e38f22007-06-04 15:15:49 +100053#include "signal.h"
54
Stephen Rothwell81e70092005-10-18 11:17:58 +100055#undef DEBUG_SIG
56
Stephen Rothwell81e70092005-10-18 11:17:58 +100057#ifdef CONFIG_PPC64
Stephen Rothwellb09a4912005-10-18 14:51:57 +100058#define sys_sigsuspend compat_sys_sigsuspend
59#define sys_rt_sigsuspend compat_sys_rt_sigsuspend
60#define sys_rt_sigreturn compat_sys_rt_sigreturn
61#define sys_sigaction compat_sys_sigaction
62#define sys_swapcontext compat_sys_swapcontext
63#define sys_sigreturn compat_sys_sigreturn
Stephen Rothwell81e70092005-10-18 11:17:58 +100064
65#define old_sigaction old_sigaction32
66#define sigcontext sigcontext32
67#define mcontext mcontext32
68#define ucontext ucontext32
69
70/*
Michael Neulingc1cb2992008-07-08 18:43:41 +100071 * Userspace code may pass a ucontext which doesn't include VSX added
72 * at the end. We need to check for this case.
73 */
74#define UCONTEXTSIZEWITHOUTVSX \
75 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
76
77/*
Stephen Rothwell81e70092005-10-18 11:17:58 +100078 * Returning 0 means we return to userspace via
79 * ret_from_except and thus restore all user
80 * registers from *regs. This is what we need
81 * to do when a signal has been delivered.
82 */
Stephen Rothwell81e70092005-10-18 11:17:58 +100083
84#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
85#undef __SIGNAL_FRAMESIZE
86#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
87#undef ELF_NVRREG
88#define ELF_NVRREG ELF_NVRREG32
89
90/*
91 * Functions for flipping sigsets (thanks to brain dead generic
92 * implementation that makes things simple for little endian only)
93 */
94static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
95{
96 compat_sigset_t cset;
97
98 switch (_NSIG_WORDS) {
99 case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
100 cset.sig[7] = set->sig[3] >> 32;
101 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
102 cset.sig[5] = set->sig[2] >> 32;
103 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
104 cset.sig[3] = set->sig[1] >> 32;
105 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
106 cset.sig[1] = set->sig[0] >> 32;
107 }
108 return copy_to_user(uset, &cset, sizeof(*uset));
109}
110
Paul Mackerras9b7cf8b2005-10-19 23:13:04 +1000111static inline int get_sigset_t(sigset_t *set,
112 const compat_sigset_t __user *uset)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000113{
114 compat_sigset_t s32;
115
116 if (copy_from_user(&s32, uset, sizeof(*uset)))
117 return -EFAULT;
118
119 /*
120 * Swap the 2 words of the 64-bit sigset_t (they are stored
121 * in the "wrong" endian in 32-bit user storage).
122 */
123 switch (_NSIG_WORDS) {
124 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
125 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
126 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
127 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
128 }
129 return 0;
130}
131
132static inline int get_old_sigaction(struct k_sigaction *new_ka,
133 struct old_sigaction __user *act)
134{
135 compat_old_sigset_t mask;
136 compat_uptr_t handler, restorer;
137
138 if (get_user(handler, &act->sa_handler) ||
139 __get_user(restorer, &act->sa_restorer) ||
140 __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
141 __get_user(mask, &act->sa_mask))
142 return -EFAULT;
143 new_ka->sa.sa_handler = compat_ptr(handler);
144 new_ka->sa.sa_restorer = compat_ptr(restorer);
145 siginitset(&new_ka->sa.sa_mask, mask);
146 return 0;
147}
148
Al Viro29e646df2006-02-01 05:28:09 -0500149#define to_user_ptr(p) ptr_to_compat(p)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000150#define from_user_ptr(p) compat_ptr(p)
151
152static 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
Paul Mackerras1bd79332006-03-08 13:24:22 +1100158 WARN_ON(!FULL_REGS(regs));
David Woodhouse401d1f02005-11-15 18:52:18 +0000159
160 for (i = 0; i <= PT_RESULT; i ++) {
161 if (i == 14 && !FULL_REGS(regs))
162 i = 32;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000163 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
164 return -EFAULT;
David Woodhouse401d1f02005-11-15 18:52:18 +0000165 }
Stephen Rothwell81e70092005-10-18 11:17:58 +1000166 return 0;
167}
168
169static inline int restore_general_regs(struct pt_regs *regs,
170 struct mcontext __user *sr)
171{
172 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
173 int i;
174
175 for (i = 0; i <= PT_RESULT; i++) {
176 if ((i == PT_MSR) || (i == PT_SOFTE))
177 continue;
178 if (__get_user(gregs[i], &sr->mc_gregs[i]))
179 return -EFAULT;
180 }
181 return 0;
182}
183
184#else /* CONFIG_PPC64 */
185
Stephen Rothwell81e70092005-10-18 11:17:58 +1000186#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
187
188static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
189{
190 return copy_to_user(uset, set, sizeof(*uset));
191}
192
Paul Mackerras9b7cf8b2005-10-19 23:13:04 +1000193static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000194{
195 return copy_from_user(set, uset, sizeof(*uset));
196}
197
198static inline int get_old_sigaction(struct k_sigaction *new_ka,
199 struct old_sigaction __user *act)
200{
201 old_sigset_t mask;
202
203 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
204 __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
205 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
206 return -EFAULT;
207 __get_user(new_ka->sa.sa_flags, &act->sa_flags);
208 __get_user(mask, &act->sa_mask);
209 siginitset(&new_ka->sa.sa_mask, mask);
210 return 0;
211}
212
Al Viro29e646df2006-02-01 05:28:09 -0500213#define to_user_ptr(p) ((unsigned long)(p))
214#define from_user_ptr(p) ((void __user *)(p))
Stephen Rothwell81e70092005-10-18 11:17:58 +1000215
216static inline int save_general_regs(struct pt_regs *regs,
217 struct mcontext __user *frame)
218{
Paul Mackerras1bd79332006-03-08 13:24:22 +1100219 WARN_ON(!FULL_REGS(regs));
Stephen Rothwell81e70092005-10-18 11:17:58 +1000220 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
221}
222
223static inline int restore_general_regs(struct pt_regs *regs,
224 struct mcontext __user *sr)
225{
226 /* copy up to but not including MSR */
227 if (__copy_from_user(regs, &sr->mc_gregs,
228 PT_MSR * sizeof(elf_greg_t)))
229 return -EFAULT;
230 /* copy from orig_r3 (the word after the MSR) up to the end */
231 if (__copy_from_user(&regs->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
232 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
233 return -EFAULT;
234 return 0;
235}
236
237#endif /* CONFIG_PPC64 */
238
Stephen Rothwell81e70092005-10-18 11:17:58 +1000239/*
240 * Atomically swap in the new signal mask, and wait for a signal.
241 */
David Woodhouse150256d2006-01-18 17:43:57 -0800242long sys_sigsuspend(old_sigset_t mask)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000243{
Stephen Rothwell81e70092005-10-18 11:17:58 +1000244 mask &= _BLOCKABLE;
245 spin_lock_irq(&current->sighand->siglock);
Heiko Carstens4a41cdf2006-02-01 03:05:58 -0800246 current->saved_sigmask = current->blocked;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000247 siginitset(&current->blocked, mask);
248 recalc_sigpending();
249 spin_unlock_irq(&current->sighand->siglock);
250
David Woodhouse150256d2006-01-18 17:43:57 -0800251 current->state = TASK_INTERRUPTIBLE;
252 schedule();
Roland McGrath7a101742008-04-28 17:30:37 +1000253 set_restore_sigmask();
David Woodhouse150256d2006-01-18 17:43:57 -0800254 return -ERESTARTNOHAND;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000255}
256
Stephen Rothwell81e70092005-10-18 11:17:58 +1000257long sys_sigaction(int sig, struct old_sigaction __user *act,
258 struct old_sigaction __user *oact)
259{
260 struct k_sigaction new_ka, old_ka;
261 int ret;
262
263#ifdef CONFIG_PPC64
264 if (sig < 0)
265 sig = -sig;
266#endif
267
268 if (act) {
269 if (get_old_sigaction(&new_ka, act))
270 return -EFAULT;
271 }
272
273 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
274 if (!ret && oact) {
275 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
276 __put_user(to_user_ptr(old_ka.sa.sa_handler),
277 &oact->sa_handler) ||
278 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
279 &oact->sa_restorer) ||
280 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
281 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
282 return -EFAULT;
283 }
284
285 return ret;
286}
287
288/*
289 * When we have signals to deliver, we set up on the
290 * user stack, going down from the original stack pointer:
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +1000291 * an ABI gap of 56 words
292 * an mcontext struct
Stephen Rothwell81e70092005-10-18 11:17:58 +1000293 * a sigcontext struct
294 * a gap of __SIGNAL_FRAMESIZE bytes
295 *
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +1000296 * Each of these things must be a multiple of 16 bytes in size. The following
297 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
Stephen Rothwell81e70092005-10-18 11:17:58 +1000298 *
299 */
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +1000300struct sigframe {
301 struct sigcontext sctx; /* the sigcontext */
Stephen Rothwell81e70092005-10-18 11:17:58 +1000302 struct mcontext mctx; /* all the register values */
303 /*
304 * Programs using the rs6000/xcoff abi can save up to 19 gp
305 * regs and 18 fp regs below sp before decrementing it.
306 */
307 int abigap[56];
308};
309
310/* We use the mc_pad field for the signal return trampoline. */
311#define tramp mc_pad
312
313/*
314 * When we have rt signals to deliver, we set up on the
315 * user stack, going down from the original stack pointer:
316 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
317 * a gap of __SIGNAL_FRAMESIZE+16 bytes
318 * (the +16 is to get the siginfo and ucontext in the same
319 * positions as in older kernels).
320 *
321 * Each of these things must be a multiple of 16 bytes in size.
322 *
323 */
324struct rt_sigframe {
325#ifdef CONFIG_PPC64
326 compat_siginfo_t info;
327#else
328 struct siginfo info;
329#endif
330 struct ucontext uc;
331 /*
332 * Programs using the rs6000/xcoff abi can save up to 19 gp
333 * regs and 18 fp regs below sp before decrementing it.
334 */
335 int abigap[56];
336};
337
Michael Neuling6a274c082008-07-02 14:06:37 +1000338#ifdef CONFIG_VSX
339unsigned long copy_fpr_to_user(void __user *to,
340 struct task_struct *task)
341{
342 double buf[ELF_NFPREG];
343 int i;
344
345 /* save FPR copy to local buffer then write to the thread_struct */
346 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
347 buf[i] = task->thread.TS_FPR(i);
348 memcpy(&buf[i], &task->thread.fpscr, sizeof(double));
349 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
350}
351
352unsigned long copy_fpr_from_user(struct task_struct *task,
353 void __user *from)
354{
355 double buf[ELF_NFPREG];
356 int i;
357
358 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
359 return 1;
360 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
361 task->thread.TS_FPR(i) = buf[i];
362 memcpy(&task->thread.fpscr, &buf[i], sizeof(double));
363
364 return 0;
365}
366
367unsigned long copy_vsx_to_user(void __user *to,
368 struct task_struct *task)
369{
370 double buf[ELF_NVSRHALFREG];
371 int i;
372
373 /* save FPR copy to local buffer then write to the thread_struct */
374 for (i = 0; i < ELF_NVSRHALFREG; i++)
375 buf[i] = task->thread.fpr[i][TS_VSRLOWOFFSET];
376 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
377}
378
379unsigned long copy_vsx_from_user(struct task_struct *task,
380 void __user *from)
381{
382 double buf[ELF_NVSRHALFREG];
383 int i;
384
385 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
386 return 1;
387 for (i = 0; i < ELF_NVSRHALFREG ; i++)
388 task->thread.fpr[i][TS_VSRLOWOFFSET] = buf[i];
389 return 0;
390}
391#else
392inline unsigned long copy_fpr_to_user(void __user *to,
393 struct task_struct *task)
394{
395 return __copy_to_user(to, task->thread.fpr,
396 ELF_NFPREG * sizeof(double));
397}
398
399inline unsigned long copy_fpr_from_user(struct task_struct *task,
400 void __user *from)
401{
402 return __copy_from_user(task->thread.fpr, from,
403 ELF_NFPREG * sizeof(double));
404}
405#endif
406
Stephen Rothwell81e70092005-10-18 11:17:58 +1000407/*
408 * Save the current user registers on the user stack.
409 * We only save the altivec/spe registers if the process has used
410 * altivec/spe instructions at some point.
411 */
412static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
Michael Neuling16c29d12008-10-23 00:42:36 +0000413 int sigret, int ctx_has_vsx_region)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000414{
Michael Neuling9e751182008-06-25 14:07:17 +1000415 unsigned long msr = regs->msr;
416
Stephen Rothwell81e70092005-10-18 11:17:58 +1000417 /* Make sure floating point registers are stored in regs */
418 flush_fp_to_thread(current);
419
Michael Neulingc6e67712008-06-25 14:07:18 +1000420 /* save general registers */
421 if (save_general_regs(regs, frame))
Stephen Rothwell81e70092005-10-18 11:17:58 +1000422 return 1;
423
Stephen Rothwell81e70092005-10-18 11:17:58 +1000424#ifdef CONFIG_ALTIVEC
425 /* save altivec registers */
426 if (current->thread.used_vr) {
427 flush_altivec_to_thread(current);
428 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
429 ELF_NVRREG * sizeof(vector128)))
430 return 1;
431 /* set MSR_VEC in the saved MSR value to indicate that
432 frame->mc_vregs contains valid data */
Michael Neuling9e751182008-06-25 14:07:17 +1000433 msr |= MSR_VEC;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000434 }
435 /* else assert((regs->msr & MSR_VEC) == 0) */
436
437 /* We always copy to/from vrsave, it's 0 if we don't have or don't
438 * use altivec. Since VSCR only contains 32 bits saved in the least
439 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
440 * most significant bits of that same vector. --BenH
441 */
442 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
443 return 1;
444#endif /* CONFIG_ALTIVEC */
Michael Neuling6a274c082008-07-02 14:06:37 +1000445 if (copy_fpr_to_user(&frame->mc_fregs, current))
Michael Neulingc6e67712008-06-25 14:07:18 +1000446 return 1;
Michael Neuling6a274c082008-07-02 14:06:37 +1000447#ifdef CONFIG_VSX
Michael Neulingce48b212008-06-25 14:07:18 +1000448 /*
449 * Copy VSR 0-31 upper half from thread_struct to local
450 * buffer, then write that to userspace. Also set MSR_VSX in
451 * the saved MSR value to indicate that frame->mc_vregs
452 * contains valid data
453 */
Michael Neuling16c29d12008-10-23 00:42:36 +0000454 if (current->thread.used_vsr && ctx_has_vsx_region) {
Michael Neuling7c292172008-07-11 16:29:12 +1000455 __giveup_vsx(current);
Michael Neuling6a274c082008-07-02 14:06:37 +1000456 if (copy_vsx_to_user(&frame->mc_vsregs, current))
Michael Neulingce48b212008-06-25 14:07:18 +1000457 return 1;
458 msr |= MSR_VSX;
459 }
Michael Neulingc6e67712008-06-25 14:07:18 +1000460#endif /* CONFIG_VSX */
Stephen Rothwell81e70092005-10-18 11:17:58 +1000461#ifdef CONFIG_SPE
462 /* save spe registers */
463 if (current->thread.used_spe) {
464 flush_spe_to_thread(current);
465 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
466 ELF_NEVRREG * sizeof(u32)))
467 return 1;
468 /* set MSR_SPE in the saved MSR value to indicate that
469 frame->mc_vregs contains valid data */
Michael Neuling9e751182008-06-25 14:07:17 +1000470 msr |= MSR_SPE;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000471 }
472 /* else assert((regs->msr & MSR_SPE) == 0) */
473
474 /* We always copy to/from spefscr */
475 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
476 return 1;
477#endif /* CONFIG_SPE */
478
Michael Neuling9e751182008-06-25 14:07:17 +1000479 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
480 return 1;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000481 if (sigret) {
482 /* Set up the sigreturn trampoline: li r0,sigret; sc */
483 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
484 || __put_user(0x44000002UL, &frame->tramp[1]))
485 return 1;
486 flush_icache_range((unsigned long) &frame->tramp[0],
487 (unsigned long) &frame->tramp[2]);
488 }
489
490 return 0;
491}
492
493/*
494 * Restore the current user register values from the user stack,
495 * (except for MSR).
496 */
497static long restore_user_regs(struct pt_regs *regs,
498 struct mcontext __user *sr, int sig)
499{
500 long err;
501 unsigned int save_r2 = 0;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000502 unsigned long msr;
Michael Neulingc6e67712008-06-25 14:07:18 +1000503#ifdef CONFIG_VSX
Michael Neulingc6e67712008-06-25 14:07:18 +1000504 int i;
505#endif
Stephen Rothwell81e70092005-10-18 11:17:58 +1000506
507 /*
508 * restore general registers but not including MSR or SOFTE. Also
509 * take care of keeping r2 (TLS) intact if not a signal
510 */
511 if (!sig)
512 save_r2 = (unsigned int)regs->gpr[2];
513 err = restore_general_regs(regs, sr);
Al Viro9a81c162010-09-20 21:48:57 +0100514 regs->trap = 0;
Paul Mackerrasfab5db92006-06-07 16:14:40 +1000515 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
Stephen Rothwell81e70092005-10-18 11:17:58 +1000516 if (!sig)
517 regs->gpr[2] = (unsigned long) save_r2;
518 if (err)
519 return 1;
520
Paul Mackerrasfab5db92006-06-07 16:14:40 +1000521 /* if doing signal return, restore the previous little-endian mode */
522 if (sig)
523 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
524
Paul Mackerras5388fb12006-01-11 22:11:39 +1100525 /*
526 * Do this before updating the thread state in
527 * current->thread.fpr/vr/evr. That way, if we get preempted
528 * and another task grabs the FPU/Altivec/SPE, it won't be
529 * tempted to save the current CPU state into the thread_struct
530 * and corrupt what we are writing there.
531 */
532 discard_lazy_cpu_state();
533
Stephen Rothwell81e70092005-10-18 11:17:58 +1000534#ifdef CONFIG_ALTIVEC
Michael Neulingc6e67712008-06-25 14:07:18 +1000535 /*
536 * Force the process to reload the altivec registers from
537 * current->thread when it next does altivec instructions
538 */
Stephen Rothwell81e70092005-10-18 11:17:58 +1000539 regs->msr &= ~MSR_VEC;
Paul Mackerrasfab5db92006-06-07 16:14:40 +1000540 if (msr & MSR_VEC) {
Stephen Rothwell81e70092005-10-18 11:17:58 +1000541 /* restore altivec registers from the stack */
542 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
543 sizeof(sr->mc_vregs)))
544 return 1;
545 } else if (current->thread.used_vr)
546 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
547
548 /* Always get VRSAVE back */
549 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
550 return 1;
551#endif /* CONFIG_ALTIVEC */
Michael Neuling6a274c082008-07-02 14:06:37 +1000552 if (copy_fpr_from_user(current, &sr->mc_fregs))
553 return 1;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000554
Michael Neulingc6e67712008-06-25 14:07:18 +1000555#ifdef CONFIG_VSX
Michael Neulingce48b212008-06-25 14:07:18 +1000556 /*
557 * Force the process to reload the VSX registers from
558 * current->thread when it next does VSX instruction.
559 */
560 regs->msr &= ~MSR_VSX;
561 if (msr & MSR_VSX) {
562 /*
563 * Restore altivec registers from the stack to a local
564 * buffer, then write this out to the thread_struct
565 */
Michael Neuling6a274c082008-07-02 14:06:37 +1000566 if (copy_vsx_from_user(current, &sr->mc_vsregs))
Michael Neulingce48b212008-06-25 14:07:18 +1000567 return 1;
Michael Neulingce48b212008-06-25 14:07:18 +1000568 } else if (current->thread.used_vsr)
569 for (i = 0; i < 32 ; i++)
570 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
Michael Neulingc6e67712008-06-25 14:07:18 +1000571#endif /* CONFIG_VSX */
572 /*
573 * force the process to reload the FP registers from
574 * current->thread when it next does FP instructions
575 */
576 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
577
Stephen Rothwell81e70092005-10-18 11:17:58 +1000578#ifdef CONFIG_SPE
579 /* force the process to reload the spe registers from
580 current->thread when it next does spe instructions */
581 regs->msr &= ~MSR_SPE;
Paul Mackerrasfab5db92006-06-07 16:14:40 +1000582 if (msr & MSR_SPE) {
Stephen Rothwell81e70092005-10-18 11:17:58 +1000583 /* restore spe registers from the stack */
584 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
585 ELF_NEVRREG * sizeof(u32)))
586 return 1;
587 } else if (current->thread.used_spe)
588 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
589
590 /* Always get SPEFSCR back */
591 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
592 return 1;
593#endif /* CONFIG_SPE */
594
Stephen Rothwell81e70092005-10-18 11:17:58 +1000595 return 0;
596}
597
598#ifdef CONFIG_PPC64
Stephen Rothwellb09a4912005-10-18 14:51:57 +1000599long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
Stephen Rothwell81e70092005-10-18 11:17:58 +1000600 struct sigaction32 __user *oact, size_t sigsetsize)
601{
602 struct k_sigaction new_ka, old_ka;
603 int ret;
604
605 /* XXX: Don't preclude handling different sized sigset_t's. */
606 if (sigsetsize != sizeof(compat_sigset_t))
607 return -EINVAL;
608
609 if (act) {
610 compat_uptr_t handler;
611
612 ret = get_user(handler, &act->sa_handler);
613 new_ka.sa.sa_handler = compat_ptr(handler);
614 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
615 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
616 if (ret)
617 return -EFAULT;
618 }
619
620 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
621 if (!ret && oact) {
Al Viro29e646df2006-02-01 05:28:09 -0500622 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
Stephen Rothwell81e70092005-10-18 11:17:58 +1000623 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
624 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
625 }
626 return ret;
627}
628
629/*
630 * Note: it is necessary to treat how as an unsigned int, with the
631 * corresponding cast to a signed int to insure that the proper
632 * conversion (sign extension) between the register representation
633 * of a signed int (msr in 32-bit mode) and the register representation
634 * of a signed int (msr in 64-bit mode) is performed.
635 */
Stephen Rothwellb09a4912005-10-18 14:51:57 +1000636long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
Stephen Rothwell81e70092005-10-18 11:17:58 +1000637 compat_sigset_t __user *oset, size_t sigsetsize)
638{
639 sigset_t s;
640 sigset_t __user *up;
641 int ret;
642 mm_segment_t old_fs = get_fs();
643
644 if (set) {
645 if (get_sigset_t(&s, set))
646 return -EFAULT;
647 }
648
649 set_fs(KERNEL_DS);
650 /* This is valid because of the set_fs() */
651 up = (sigset_t __user *) &s;
652 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
653 sigsetsize);
654 set_fs(old_fs);
655 if (ret)
656 return ret;
657 if (oset) {
658 if (put_sigset_t(oset, &s))
659 return -EFAULT;
660 }
661 return 0;
662}
663
Stephen Rothwellb09a4912005-10-18 14:51:57 +1000664long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000665{
666 sigset_t s;
667 int ret;
668 mm_segment_t old_fs = get_fs();
669
670 set_fs(KERNEL_DS);
671 /* The __user pointer cast is valid because of the set_fs() */
672 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
673 set_fs(old_fs);
674 if (!ret) {
675 if (put_sigset_t(set, &s))
676 return -EFAULT;
677 }
678 return ret;
679}
680
681
682int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
683{
684 int err;
685
686 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
687 return -EFAULT;
688
689 /* If you change siginfo_t structure, please be sure
690 * this code is fixed accordingly.
691 * It should never copy any pad contained in the structure
692 * to avoid security leaks, but must copy the generic
693 * 3 ints plus the relevant union member.
694 * This routine must convert siginfo from 64bit to 32bit as well
695 * at the same time.
696 */
697 err = __put_user(s->si_signo, &d->si_signo);
698 err |= __put_user(s->si_errno, &d->si_errno);
699 err |= __put_user((short)s->si_code, &d->si_code);
700 if (s->si_code < 0)
701 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
702 SI_PAD_SIZE32);
703 else switch(s->si_code >> 16) {
704 case __SI_CHLD >> 16:
705 err |= __put_user(s->si_pid, &d->si_pid);
706 err |= __put_user(s->si_uid, &d->si_uid);
707 err |= __put_user(s->si_utime, &d->si_utime);
708 err |= __put_user(s->si_stime, &d->si_stime);
709 err |= __put_user(s->si_status, &d->si_status);
710 break;
711 case __SI_FAULT >> 16:
712 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
713 &d->si_addr);
714 break;
715 case __SI_POLL >> 16:
716 err |= __put_user(s->si_band, &d->si_band);
717 err |= __put_user(s->si_fd, &d->si_fd);
718 break;
719 case __SI_TIMER >> 16:
720 err |= __put_user(s->si_tid, &d->si_tid);
721 err |= __put_user(s->si_overrun, &d->si_overrun);
722 err |= __put_user(s->si_int, &d->si_int);
723 break;
724 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
725 case __SI_MESGQ >> 16:
726 err |= __put_user(s->si_int, &d->si_int);
727 /* fallthrough */
728 case __SI_KILL >> 16:
729 default:
730 err |= __put_user(s->si_pid, &d->si_pid);
731 err |= __put_user(s->si_uid, &d->si_uid);
732 break;
733 }
734 return err;
735}
736
737#define copy_siginfo_to_user copy_siginfo_to_user32
738
Roland McGrath9c0c44d2008-04-20 08:19:24 +1000739int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
740{
741 memset(to, 0, sizeof *to);
742
743 if (copy_from_user(to, from, 3*sizeof(int)) ||
744 copy_from_user(to->_sifields._pad,
745 from->_sifields._pad, SI_PAD_SIZE32))
746 return -EFAULT;
747
748 return 0;
749}
750
Stephen Rothwell81e70092005-10-18 11:17:58 +1000751/*
752 * Note: it is necessary to treat pid and sig as unsigned ints, with the
753 * corresponding cast to a signed int to insure that the proper conversion
754 * (sign extension) between the register representation of a signed int
755 * (msr in 32-bit mode) and the register representation of a signed int
756 * (msr in 64-bit mode) is performed.
757 */
Stephen Rothwellb09a4912005-10-18 14:51:57 +1000758long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000759{
760 siginfo_t info;
761 int ret;
762 mm_segment_t old_fs = get_fs();
763
Roland McGrath9c0c44d2008-04-20 08:19:24 +1000764 ret = copy_siginfo_from_user32(&info, uinfo);
765 if (unlikely(ret))
766 return ret;
767
Stephen Rothwell81e70092005-10-18 11:17:58 +1000768 set_fs (KERNEL_DS);
769 /* The __user pointer cast is valid becasuse of the set_fs() */
770 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
771 set_fs (old_fs);
772 return ret;
773}
774/*
775 * Start Alternate signal stack support
776 *
777 * System Calls
Stephen Rothwellb09a4912005-10-18 14:51:57 +1000778 * sigaltatck compat_sys_sigaltstack
Stephen Rothwell81e70092005-10-18 11:17:58 +1000779 */
780
Stephen Rothwellb09a4912005-10-18 14:51:57 +1000781int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
Stephen Rothwell81e70092005-10-18 11:17:58 +1000782 int r6, int r7, int r8, struct pt_regs *regs)
783{
Al Viro29e646df2006-02-01 05:28:09 -0500784 stack_32_t __user * newstack = compat_ptr(__new);
785 stack_32_t __user * oldstack = compat_ptr(__old);
Stephen Rothwell81e70092005-10-18 11:17:58 +1000786 stack_t uss, uoss;
787 int ret;
788 mm_segment_t old_fs;
789 unsigned long sp;
790 compat_uptr_t ss_sp;
791
792 /*
793 * set sp to the user stack on entry to the system call
794 * the system call router sets R9 to the saved registers
795 */
796 sp = regs->gpr[1];
797
798 /* Put new stack info in local 64 bit stack struct */
799 if (newstack) {
800 if (get_user(ss_sp, &newstack->ss_sp) ||
801 __get_user(uss.ss_flags, &newstack->ss_flags) ||
802 __get_user(uss.ss_size, &newstack->ss_size))
803 return -EFAULT;
804 uss.ss_sp = compat_ptr(ss_sp);
805 }
806
807 old_fs = get_fs();
808 set_fs(KERNEL_DS);
809 /* The __user pointer casts are valid because of the set_fs() */
810 ret = do_sigaltstack(
811 newstack ? (stack_t __user *) &uss : NULL,
812 oldstack ? (stack_t __user *) &uoss : NULL,
813 sp);
814 set_fs(old_fs);
815 /* Copy the stack information to the user output buffer */
816 if (!ret && oldstack &&
Al Viro29e646df2006-02-01 05:28:09 -0500817 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
Stephen Rothwell81e70092005-10-18 11:17:58 +1000818 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
819 __put_user(uoss.ss_size, &oldstack->ss_size)))
820 return -EFAULT;
821 return ret;
822}
823#endif /* CONFIG_PPC64 */
824
Stephen Rothwell81e70092005-10-18 11:17:58 +1000825/*
826 * Set up a signal frame for a "real-time" signal handler
827 * (one which gets siginfo).
828 */
Christoph Hellwigf478f542007-06-04 15:15:52 +1000829int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
Stephen Rothwell81e70092005-10-18 11:17:58 +1000830 siginfo_t *info, sigset_t *oldset,
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +1000831 struct pt_regs *regs)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000832{
833 struct rt_sigframe __user *rt_sf;
834 struct mcontext __user *frame;
Olof Johanssond0c3d532007-10-12 10:20:07 +1000835 void __user *addr;
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +1000836 unsigned long newsp = 0;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000837
838 /* Set up Signal Frame */
839 /* Put a Real Time Context onto stack */
Josh Boyerefbda862009-03-25 06:23:59 +0000840 rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf), 1);
Olof Johanssond0c3d532007-10-12 10:20:07 +1000841 addr = rt_sf;
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +1000842 if (unlikely(rt_sf == NULL))
Stephen Rothwell81e70092005-10-18 11:17:58 +1000843 goto badframe;
844
845 /* Put the siginfo & fill in most of the ucontext */
846 if (copy_siginfo_to_user(&rt_sf->info, info)
847 || __put_user(0, &rt_sf->uc.uc_flags)
848 || __put_user(0, &rt_sf->uc.uc_link)
849 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
850 || __put_user(sas_ss_flags(regs->gpr[1]),
851 &rt_sf->uc.uc_stack.ss_flags)
852 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
853 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
854 &rt_sf->uc.uc_regs)
855 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
856 goto badframe;
857
858 /* Save user registers on the stack */
859 frame = &rt_sf->uc.uc_mcontext;
Olof Johanssond0c3d532007-10-12 10:20:07 +1000860 addr = frame;
Benjamin Herrenschmidta5bba932006-05-30 13:51:37 +1000861 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
Michael Neuling16c29d12008-10-23 00:42:36 +0000862 if (save_user_regs(regs, frame, 0, 1))
Stephen Rothwell81e70092005-10-18 11:17:58 +1000863 goto badframe;
Benjamin Herrenschmidta5bba932006-05-30 13:51:37 +1000864 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
Benjamin Herrenschmidta7f290d2005-11-11 21:15:21 +1100865 } else {
Michael Neuling16c29d12008-10-23 00:42:36 +0000866 if (save_user_regs(regs, frame, __NR_rt_sigreturn, 1))
Stephen Rothwell81e70092005-10-18 11:17:58 +1000867 goto badframe;
868 regs->link = (unsigned long) frame->tramp;
869 }
Paul Mackerrascc657f52005-11-14 21:55:15 +1100870
871 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
872
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +1000873 /* create a stack frame for the caller of the handler */
874 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
Olof Johanssond0c3d532007-10-12 10:20:07 +1000875 addr = (void __user *)regs->gpr[1];
Paul Mackerrase2b55302005-10-22 14:46:33 +1000876 if (put_user(regs->gpr[1], (u32 __user *)newsp))
Stephen Rothwell81e70092005-10-18 11:17:58 +1000877 goto badframe;
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +1000878
879 /* Fill registers for signal handler */
Stephen Rothwell81e70092005-10-18 11:17:58 +1000880 regs->gpr[1] = newsp;
881 regs->gpr[3] = sig;
882 regs->gpr[4] = (unsigned long) &rt_sf->info;
883 regs->gpr[5] = (unsigned long) &rt_sf->uc;
884 regs->gpr[6] = (unsigned long) rt_sf;
885 regs->nip = (unsigned long) ka->sa.sa_handler;
Paul Mackerrasfab5db92006-06-07 16:14:40 +1000886 /* enter the signal handler in big-endian mode */
887 regs->msr &= ~MSR_LE;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000888 return 1;
889
890badframe:
891#ifdef DEBUG_SIG
892 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
893 regs, frame, newsp);
894#endif
Olof Johanssond0c3d532007-10-12 10:20:07 +1000895 if (show_unhandled_signals && printk_ratelimit())
896 printk(KERN_INFO "%s[%d]: bad frame in handle_rt_signal32: "
897 "%p nip %08lx lr %08lx\n",
898 current->comm, current->pid,
899 addr, regs->nip, regs->link);
900
Stephen Rothwell81e70092005-10-18 11:17:58 +1000901 force_sigsegv(sig, current);
902 return 0;
903}
904
905static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
906{
907 sigset_t set;
908 struct mcontext __user *mcp;
909
910 if (get_sigset_t(&set, &ucp->uc_sigmask))
911 return -EFAULT;
912#ifdef CONFIG_PPC64
913 {
914 u32 cmcp;
915
916 if (__get_user(cmcp, &ucp->uc_regs))
917 return -EFAULT;
918 mcp = (struct mcontext __user *)(u64)cmcp;
Paul Mackerras7c85d1f2006-06-09 13:02:59 +1000919 /* no need to check access_ok(mcp), since mcp < 4GB */
Stephen Rothwell81e70092005-10-18 11:17:58 +1000920 }
921#else
922 if (__get_user(mcp, &ucp->uc_regs))
923 return -EFAULT;
Paul Mackerras7c85d1f2006-06-09 13:02:59 +1000924 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
925 return -EFAULT;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000926#endif
927 restore_sigmask(&set);
928 if (restore_user_regs(regs, mcp, sig))
929 return -EFAULT;
930
931 return 0;
932}
933
934long sys_swapcontext(struct ucontext __user *old_ctx,
Paul Mackerras1bd79332006-03-08 13:24:22 +1100935 struct ucontext __user *new_ctx,
936 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000937{
938 unsigned char tmp;
Michael Neuling16c29d12008-10-23 00:42:36 +0000939 int ctx_has_vsx_region = 0;
Stephen Rothwell81e70092005-10-18 11:17:58 +1000940
Michael Neulingc1cb2992008-07-08 18:43:41 +1000941#ifdef CONFIG_PPC64
942 unsigned long new_msr = 0;
943
Andreas Schwab77eb50a2008-11-06 00:49:00 +0000944 if (new_ctx) {
945 struct mcontext __user *mcp;
946 u32 cmcp;
947
948 /*
949 * Get pointer to the real mcontext. No need for
950 * access_ok since we are dealing with compat
951 * pointers.
952 */
953 if (__get_user(cmcp, &new_ctx->uc_regs))
954 return -EFAULT;
955 mcp = (struct mcontext __user *)(u64)cmcp;
956 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
957 return -EFAULT;
958 }
Michael Neulingc1cb2992008-07-08 18:43:41 +1000959 /*
960 * Check that the context is not smaller than the original
961 * size (with VMX but without VSX)
962 */
963 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
964 return -EINVAL;
965 /*
966 * If the new context state sets the MSR VSX bits but
967 * it doesn't provide VSX state.
968 */
969 if ((ctx_size < sizeof(struct ucontext)) &&
970 (new_msr & MSR_VSX))
971 return -EINVAL;
Michael Neuling16c29d12008-10-23 00:42:36 +0000972 /* Does the context have enough room to store VSX data? */
973 if (ctx_size >= sizeof(struct ucontext))
974 ctx_has_vsx_region = 1;
Michael Neulingc1cb2992008-07-08 18:43:41 +1000975#else
Stephen Rothwell81e70092005-10-18 11:17:58 +1000976 /* Context size is for future use. Right now, we only make sure
977 * we are passed something we understand
978 */
979 if (ctx_size < sizeof(struct ucontext))
980 return -EINVAL;
Michael Neulingc1cb2992008-07-08 18:43:41 +1000981#endif
Stephen Rothwell81e70092005-10-18 11:17:58 +1000982 if (old_ctx != NULL) {
Paul Mackerras1c9bb1a2006-12-20 13:57:06 +1100983 struct mcontext __user *mctx;
984
985 /*
986 * old_ctx might not be 16-byte aligned, in which
987 * case old_ctx->uc_mcontext won't be either.
988 * Because we have the old_ctx->uc_pad2 field
989 * before old_ctx->uc_mcontext, we need to round down
990 * from &old_ctx->uc_mcontext to a 16-byte boundary.
991 */
992 mctx = (struct mcontext __user *)
993 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
Michael Neuling16c29d12008-10-23 00:42:36 +0000994 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
995 || save_user_regs(regs, mctx, 0, ctx_has_vsx_region)
Stephen Rothwell81e70092005-10-18 11:17:58 +1000996 || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
Paul Mackerras1c9bb1a2006-12-20 13:57:06 +1100997 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
Stephen Rothwell81e70092005-10-18 11:17:58 +1000998 return -EFAULT;
999 }
1000 if (new_ctx == NULL)
1001 return 0;
Michael Neuling16c29d12008-10-23 00:42:36 +00001002 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
Stephen Rothwell81e70092005-10-18 11:17:58 +10001003 || __get_user(tmp, (u8 __user *) new_ctx)
Michael Neuling16c29d12008-10-23 00:42:36 +00001004 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
Stephen Rothwell81e70092005-10-18 11:17:58 +10001005 return -EFAULT;
1006
1007 /*
1008 * If we get a fault copying the context into the kernel's
1009 * image of the user's registers, we can't just return -EFAULT
1010 * because the user's registers will be corrupted. For instance
1011 * the NIP value may have been updated but not some of the
1012 * other registers. Given that we have done the access_ok
1013 * and successfully read the first and last bytes of the region
1014 * above, this should only happen in an out-of-memory situation
1015 * or if another thread unmaps the region containing the context.
1016 * We kill the task with a SIGSEGV in this situation.
1017 */
1018 if (do_setcontext(new_ctx, regs, 0))
1019 do_exit(SIGSEGV);
David Woodhouse401d1f02005-11-15 18:52:18 +00001020
1021 set_thread_flag(TIF_RESTOREALL);
Stephen Rothwell81e70092005-10-18 11:17:58 +10001022 return 0;
1023}
1024
1025long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1026 struct pt_regs *regs)
1027{
1028 struct rt_sigframe __user *rt_sf;
1029
1030 /* Always make any pending restarted system calls return -EINTR */
1031 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1032
1033 rt_sf = (struct rt_sigframe __user *)
1034 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1035 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1036 goto bad;
1037 if (do_setcontext(&rt_sf->uc, regs, 1))
1038 goto bad;
1039
1040 /*
1041 * It's not clear whether or why it is desirable to save the
1042 * sigaltstack setting on signal delivery and restore it on
1043 * signal return. But other architectures do this and we have
1044 * always done it up until now so it is probably better not to
1045 * change it. -- paulus
1046 */
1047#ifdef CONFIG_PPC64
1048 /*
Stephen Rothwellb09a4912005-10-18 14:51:57 +10001049 * We use the compat_sys_ version that does the 32/64 bits conversion
Stephen Rothwell81e70092005-10-18 11:17:58 +10001050 * and takes userland pointer directly. What about error checking ?
1051 * nobody does any...
1052 */
Stephen Rothwellb09a4912005-10-18 14:51:57 +10001053 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
Stephen Rothwell81e70092005-10-18 11:17:58 +10001054#else
1055 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
Stephen Rothwell81e70092005-10-18 11:17:58 +10001056#endif
David Woodhouse401d1f02005-11-15 18:52:18 +00001057 set_thread_flag(TIF_RESTOREALL);
1058 return 0;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001059
1060 bad:
Olof Johanssond0c3d532007-10-12 10:20:07 +10001061 if (show_unhandled_signals && printk_ratelimit())
1062 printk(KERN_INFO "%s[%d]: bad frame in sys_rt_sigreturn: "
1063 "%p nip %08lx lr %08lx\n",
1064 current->comm, current->pid,
1065 rt_sf, regs->nip, regs->link);
1066
Stephen Rothwell81e70092005-10-18 11:17:58 +10001067 force_sig(SIGSEGV, current);
1068 return 0;
1069}
1070
1071#ifdef CONFIG_PPC32
1072int sys_debug_setcontext(struct ucontext __user *ctx,
1073 int ndbg, struct sig_dbg_op __user *dbg,
1074 int r6, int r7, int r8,
1075 struct pt_regs *regs)
1076{
1077 struct sig_dbg_op op;
1078 int i;
Paul Mackerras7c85d1f2006-06-09 13:02:59 +10001079 unsigned char tmp;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001080 unsigned long new_msr = regs->msr;
Dave Kleikamp172ae2e2010-02-08 11:50:57 +00001081#ifdef CONFIG_PPC_ADV_DEBUG_REGS
Stephen Rothwell81e70092005-10-18 11:17:58 +10001082 unsigned long new_dbcr0 = current->thread.dbcr0;
1083#endif
1084
1085 for (i=0; i<ndbg; i++) {
Paul Mackerras7c85d1f2006-06-09 13:02:59 +10001086 if (copy_from_user(&op, dbg + i, sizeof(op)))
Stephen Rothwell81e70092005-10-18 11:17:58 +10001087 return -EFAULT;
1088 switch (op.dbg_type) {
1089 case SIG_DBG_SINGLE_STEPPING:
Dave Kleikamp172ae2e2010-02-08 11:50:57 +00001090#ifdef CONFIG_PPC_ADV_DEBUG_REGS
Stephen Rothwell81e70092005-10-18 11:17:58 +10001091 if (op.dbg_value) {
1092 new_msr |= MSR_DE;
1093 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1094 } else {
Dave Kleikamp3bffb652010-02-08 11:51:18 +00001095 new_dbcr0 &= ~DBCR0_IC;
1096 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1097 current->thread.dbcr1)) {
1098 new_msr &= ~MSR_DE;
1099 new_dbcr0 &= ~DBCR0_IDM;
1100 }
Stephen Rothwell81e70092005-10-18 11:17:58 +10001101 }
1102#else
1103 if (op.dbg_value)
1104 new_msr |= MSR_SE;
1105 else
1106 new_msr &= ~MSR_SE;
1107#endif
1108 break;
1109 case SIG_DBG_BRANCH_TRACING:
Dave Kleikamp172ae2e2010-02-08 11:50:57 +00001110#ifdef CONFIG_PPC_ADV_DEBUG_REGS
Stephen Rothwell81e70092005-10-18 11:17:58 +10001111 return -EINVAL;
1112#else
1113 if (op.dbg_value)
1114 new_msr |= MSR_BE;
1115 else
1116 new_msr &= ~MSR_BE;
1117#endif
1118 break;
1119
1120 default:
1121 return -EINVAL;
1122 }
1123 }
1124
1125 /* We wait until here to actually install the values in the
1126 registers so if we fail in the above loop, it will not
1127 affect the contents of these registers. After this point,
1128 failure is a problem, anyway, and it's very unlikely unless
1129 the user is really doing something wrong. */
1130 regs->msr = new_msr;
Dave Kleikamp172ae2e2010-02-08 11:50:57 +00001131#ifdef CONFIG_PPC_ADV_DEBUG_REGS
Stephen Rothwell81e70092005-10-18 11:17:58 +10001132 current->thread.dbcr0 = new_dbcr0;
1133#endif
1134
Paul Mackerras7c85d1f2006-06-09 13:02:59 +10001135 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1136 || __get_user(tmp, (u8 __user *) ctx)
1137 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1138 return -EFAULT;
1139
Stephen Rothwell81e70092005-10-18 11:17:58 +10001140 /*
1141 * If we get a fault copying the context into the kernel's
1142 * image of the user's registers, we can't just return -EFAULT
1143 * because the user's registers will be corrupted. For instance
1144 * the NIP value may have been updated but not some of the
1145 * other registers. Given that we have done the access_ok
1146 * and successfully read the first and last bytes of the region
1147 * above, this should only happen in an out-of-memory situation
1148 * or if another thread unmaps the region containing the context.
1149 * We kill the task with a SIGSEGV in this situation.
1150 */
1151 if (do_setcontext(ctx, regs, 1)) {
Olof Johanssond0c3d532007-10-12 10:20:07 +10001152 if (show_unhandled_signals && printk_ratelimit())
1153 printk(KERN_INFO "%s[%d]: bad frame in "
1154 "sys_debug_setcontext: %p nip %08lx "
1155 "lr %08lx\n",
1156 current->comm, current->pid,
1157 ctx, regs->nip, regs->link);
1158
Stephen Rothwell81e70092005-10-18 11:17:58 +10001159 force_sig(SIGSEGV, current);
1160 goto out;
1161 }
1162
1163 /*
1164 * It's not clear whether or why it is desirable to save the
1165 * sigaltstack setting on signal delivery and restore it on
1166 * signal return. But other architectures do this and we have
1167 * always done it up until now so it is probably better not to
1168 * change it. -- paulus
1169 */
1170 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1171
David Woodhouse401d1f02005-11-15 18:52:18 +00001172 set_thread_flag(TIF_RESTOREALL);
Stephen Rothwell81e70092005-10-18 11:17:58 +10001173 out:
1174 return 0;
1175}
1176#endif
1177
1178/*
1179 * OK, we're invoking a handler
1180 */
Christoph Hellwigf478f542007-06-04 15:15:52 +10001181int handle_signal32(unsigned long sig, struct k_sigaction *ka,
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +10001182 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
Stephen Rothwell81e70092005-10-18 11:17:58 +10001183{
1184 struct sigcontext __user *sc;
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +10001185 struct sigframe __user *frame;
1186 unsigned long newsp = 0;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001187
1188 /* Set up Signal Frame */
Josh Boyerefbda862009-03-25 06:23:59 +00001189 frame = get_sigframe(ka, regs, sizeof(*frame), 1);
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +10001190 if (unlikely(frame == NULL))
Stephen Rothwell81e70092005-10-18 11:17:58 +10001191 goto badframe;
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +10001192 sc = (struct sigcontext __user *) &frame->sctx;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001193
1194#if _NSIG != 64
1195#error "Please adjust handle_signal()"
1196#endif
1197 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1198 || __put_user(oldset->sig[0], &sc->oldmask)
1199#ifdef CONFIG_PPC64
1200 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1201#else
1202 || __put_user(oldset->sig[1], &sc->_unused[3])
1203#endif
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +10001204 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
Stephen Rothwell81e70092005-10-18 11:17:58 +10001205 || __put_user(sig, &sc->signal))
1206 goto badframe;
1207
Benjamin Herrenschmidta5bba932006-05-30 13:51:37 +10001208 if (vdso32_sigtramp && current->mm->context.vdso_base) {
Michael Neuling16c29d12008-10-23 00:42:36 +00001209 if (save_user_regs(regs, &frame->mctx, 0, 1))
Stephen Rothwell81e70092005-10-18 11:17:58 +10001210 goto badframe;
Benjamin Herrenschmidta5bba932006-05-30 13:51:37 +10001211 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
Benjamin Herrenschmidta7f290d2005-11-11 21:15:21 +11001212 } else {
Michael Neuling16c29d12008-10-23 00:42:36 +00001213 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn, 1))
Stephen Rothwell81e70092005-10-18 11:17:58 +10001214 goto badframe;
1215 regs->link = (unsigned long) frame->mctx.tramp;
1216 }
1217
Paul Mackerrascc657f52005-11-14 21:55:15 +11001218 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1219
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +10001220 /* create a stack frame for the caller of the handler */
1221 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001222 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1223 goto badframe;
Benjamin Herrenschmidta3f61dc2007-06-04 17:22:48 +10001224
Stephen Rothwell81e70092005-10-18 11:17:58 +10001225 regs->gpr[1] = newsp;
1226 regs->gpr[3] = sig;
1227 regs->gpr[4] = (unsigned long) sc;
1228 regs->nip = (unsigned long) ka->sa.sa_handler;
Paul Mackerrasfab5db92006-06-07 16:14:40 +10001229 /* enter the signal handler in big-endian mode */
1230 regs->msr &= ~MSR_LE;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001231
1232 return 1;
1233
1234badframe:
1235#ifdef DEBUG_SIG
1236 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1237 regs, frame, newsp);
1238#endif
Olof Johanssond0c3d532007-10-12 10:20:07 +10001239 if (show_unhandled_signals && printk_ratelimit())
1240 printk(KERN_INFO "%s[%d]: bad frame in handle_signal32: "
1241 "%p nip %08lx lr %08lx\n",
1242 current->comm, current->pid,
1243 frame, regs->nip, regs->link);
1244
Stephen Rothwell81e70092005-10-18 11:17:58 +10001245 force_sigsegv(sig, current);
1246 return 0;
1247}
1248
1249/*
1250 * Do a signal return; undo the signal stack.
1251 */
1252long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1253 struct pt_regs *regs)
1254{
1255 struct sigcontext __user *sc;
1256 struct sigcontext sigctx;
1257 struct mcontext __user *sr;
Olof Johanssond0c3d532007-10-12 10:20:07 +10001258 void __user *addr;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001259 sigset_t set;
1260
1261 /* Always make any pending restarted system calls return -EINTR */
1262 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1263
1264 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
Olof Johanssond0c3d532007-10-12 10:20:07 +10001265 addr = sc;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001266 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1267 goto badframe;
1268
1269#ifdef CONFIG_PPC64
1270 /*
1271 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1272 * unused part of the signal stackframe
1273 */
1274 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1275#else
1276 set.sig[0] = sigctx.oldmask;
1277 set.sig[1] = sigctx._unused[3];
1278#endif
1279 restore_sigmask(&set);
1280
1281 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
Olof Johanssond0c3d532007-10-12 10:20:07 +10001282 addr = sr;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001283 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1284 || restore_user_regs(regs, sr, 1))
1285 goto badframe;
1286
David Woodhouse401d1f02005-11-15 18:52:18 +00001287 set_thread_flag(TIF_RESTOREALL);
Stephen Rothwell81e70092005-10-18 11:17:58 +10001288 return 0;
Stephen Rothwell81e70092005-10-18 11:17:58 +10001289
1290badframe:
Olof Johanssond0c3d532007-10-12 10:20:07 +10001291 if (show_unhandled_signals && printk_ratelimit())
1292 printk(KERN_INFO "%s[%d]: bad frame in sys_sigreturn: "
1293 "%p nip %08lx lr %08lx\n",
1294 current->comm, current->pid,
1295 addr, regs->nip, regs->link);
1296
Stephen Rothwell81e70092005-10-18 11:17:58 +10001297 force_sig(SIGSEGV, current);
1298 return 0;
1299}