Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
4 *
5 * PowerPC version
6 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
7 * Copyright (C) 2001 IBM
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
9 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
10 *
11 * Derived from "arch/i386/kernel/signal.c"
12 * Copyright (C) 1991, 1992 Linus Torvalds
13 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
14 */
15
16#include <linux/sched.h>
17#include <linux/mm.h>
18#include <linux/smp.h>
19#include <linux/kernel.h>
20#include <linux/signal.h>
21#include <linux/errno.h>
22#include <linux/elf.h>
23#include <linux/ptrace.h>
24#include <linux/pagemap.h>
25#include <linux/ratelimit.h>
26#include <linux/syscalls.h>
27#ifdef CONFIG_PPC64
28#include <linux/compat.h>
29#else
30#include <linux/wait.h>
31#include <linux/unistd.h>
32#include <linux/stddef.h>
33#include <linux/tty.h>
34#include <linux/binfmts.h>
35#endif
36
37#include <linux/uaccess.h>
38#include <asm/cacheflush.h>
39#include <asm/syscalls.h>
40#include <asm/sigcontext.h>
41#include <asm/vdso.h>
42#include <asm/switch_to.h>
43#include <asm/tm.h>
44#include <asm/asm-prototypes.h>
45#ifdef CONFIG_PPC64
46#include "ppc32.h"
47#include <asm/unistd.h>
48#else
49#include <asm/ucontext.h>
50#endif
51
52#include "signal.h"
53
54
55#ifdef CONFIG_PPC64
56#define old_sigaction old_sigaction32
57#define sigcontext sigcontext32
58#define mcontext mcontext32
59#define ucontext ucontext32
60
61#define __save_altstack __compat_save_altstack
62
63/*
64 * Userspace code may pass a ucontext which doesn't include VSX added
65 * at the end. We need to check for this case.
66 */
67#define UCONTEXTSIZEWITHOUTVSX \
68 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
69
70/*
71 * Returning 0 means we return to userspace via
72 * ret_from_except and thus restore all user
73 * registers from *regs. This is what we need
74 * to do when a signal has been delivered.
75 */
76
77#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
78#undef __SIGNAL_FRAMESIZE
79#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
80#undef ELF_NVRREG
81#define ELF_NVRREG ELF_NVRREG32
82
83/*
84 * Functions for flipping sigsets (thanks to brain dead generic
85 * implementation that makes things simple for little endian only)
86 */
87static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
88{
89 return put_compat_sigset(uset, set, sizeof(*uset));
90}
91
92static inline int get_sigset_t(sigset_t *set,
93 const compat_sigset_t __user *uset)
94{
95 return get_compat_sigset(set, uset);
96}
97
98#define to_user_ptr(p) ptr_to_compat(p)
99#define from_user_ptr(p) compat_ptr(p)
100
101static inline int save_general_regs(struct pt_regs *regs,
102 struct mcontext __user *frame)
103{
104 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
105 int val, i;
106
107 WARN_ON(!FULL_REGS(regs));
108
109 for (i = 0; i <= PT_RESULT; i ++) {
110 /* Force usr to alway see softe as 1 (interrupts enabled) */
111 if (i == PT_SOFTE)
112 val = 1;
113 else
114 val = gregs[i];
115
116 if (__put_user(val, &frame->mc_gregs[i]))
117 return -EFAULT;
118 }
119 return 0;
120}
121
122static inline int restore_general_regs(struct pt_regs *regs,
123 struct mcontext __user *sr)
124{
125 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
126 int i;
127
128 for (i = 0; i <= PT_RESULT; i++) {
129 if ((i == PT_MSR) || (i == PT_SOFTE))
130 continue;
131 if (__get_user(gregs[i], &sr->mc_gregs[i]))
132 return -EFAULT;
133 }
134 return 0;
135}
136
137#else /* CONFIG_PPC64 */
138
139#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
140
141static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
142{
143 return copy_to_user(uset, set, sizeof(*uset));
144}
145
146static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
147{
148 return copy_from_user(set, uset, sizeof(*uset));
149}
150
151#define to_user_ptr(p) ((unsigned long)(p))
152#define from_user_ptr(p) ((void __user *)(p))
153
154static inline int save_general_regs(struct pt_regs *regs,
155 struct mcontext __user *frame)
156{
157 WARN_ON(!FULL_REGS(regs));
158 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
159}
160
161static inline int restore_general_regs(struct pt_regs *regs,
162 struct mcontext __user *sr)
163{
164 /* copy up to but not including MSR */
165 if (__copy_from_user(regs, &sr->mc_gregs,
166 PT_MSR * sizeof(elf_greg_t)))
167 return -EFAULT;
168 /* copy from orig_r3 (the word after the MSR) up to the end */
169 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
170 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
171 return -EFAULT;
172 return 0;
173}
174#endif
175
176/*
177 * When we have signals to deliver, we set up on the
178 * user stack, going down from the original stack pointer:
179 * an ABI gap of 56 words
180 * an mcontext struct
181 * a sigcontext struct
182 * a gap of __SIGNAL_FRAMESIZE bytes
183 *
184 * Each of these things must be a multiple of 16 bytes in size. The following
185 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
186 *
187 */
188struct sigframe {
189 struct sigcontext sctx; /* the sigcontext */
190 struct mcontext mctx; /* all the register values */
191#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
192 struct sigcontext sctx_transact;
193 struct mcontext mctx_transact;
194#endif
195 /*
196 * Programs using the rs6000/xcoff abi can save up to 19 gp
197 * regs and 18 fp regs below sp before decrementing it.
198 */
199 int abigap[56];
200};
201
202/* We use the mc_pad field for the signal return trampoline. */
203#define tramp mc_pad
204
205/*
206 * When we have rt signals to deliver, we set up on the
207 * user stack, going down from the original stack pointer:
208 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
209 * a gap of __SIGNAL_FRAMESIZE+16 bytes
210 * (the +16 is to get the siginfo and ucontext in the same
211 * positions as in older kernels).
212 *
213 * Each of these things must be a multiple of 16 bytes in size.
214 *
215 */
216struct rt_sigframe {
217#ifdef CONFIG_PPC64
218 compat_siginfo_t info;
219#else
220 struct siginfo info;
221#endif
222 struct ucontext uc;
223#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
224 struct ucontext uc_transact;
225#endif
226 /*
227 * Programs using the rs6000/xcoff abi can save up to 19 gp
228 * regs and 18 fp regs below sp before decrementing it.
229 */
230 int abigap[56];
231};
232
233/*
234 * Save the current user registers on the user stack.
235 * We only save the altivec/spe registers if the process has used
236 * altivec/spe instructions at some point.
237 */
238static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
239 struct mcontext __user *tm_frame, int sigret,
240 int ctx_has_vsx_region)
241{
242 unsigned long msr = regs->msr;
243
244 /* Make sure floating point registers are stored in regs */
245 flush_fp_to_thread(current);
246
247 /* save general registers */
248 if (save_general_regs(regs, frame))
249 return 1;
250
251#ifdef CONFIG_ALTIVEC
252 /* save altivec registers */
253 if (current->thread.used_vr) {
254 flush_altivec_to_thread(current);
255 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
256 ELF_NVRREG * sizeof(vector128)))
257 return 1;
258 /* set MSR_VEC in the saved MSR value to indicate that
259 frame->mc_vregs contains valid data */
260 msr |= MSR_VEC;
261 }
262 /* else assert((regs->msr & MSR_VEC) == 0) */
263
264 /* We always copy to/from vrsave, it's 0 if we don't have or don't
265 * use altivec. Since VSCR only contains 32 bits saved in the least
266 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
267 * most significant bits of that same vector. --BenH
268 * Note that the current VRSAVE value is in the SPR at this point.
269 */
270 if (cpu_has_feature(CPU_FTR_ALTIVEC))
271 current->thread.vrsave = mfspr(SPRN_VRSAVE);
272 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
273 return 1;
274#endif /* CONFIG_ALTIVEC */
275 if (copy_fpr_to_user(&frame->mc_fregs, current))
276 return 1;
277
278 /*
279 * Clear the MSR VSX bit to indicate there is no valid state attached
280 * to this context, except in the specific case below where we set it.
281 */
282 msr &= ~MSR_VSX;
283#ifdef CONFIG_VSX
284 /*
285 * Copy VSR 0-31 upper half from thread_struct to local
286 * buffer, then write that to userspace. Also set MSR_VSX in
287 * the saved MSR value to indicate that frame->mc_vregs
288 * contains valid data
289 */
290 if (current->thread.used_vsr && ctx_has_vsx_region) {
291 flush_vsx_to_thread(current);
292 if (copy_vsx_to_user(&frame->mc_vsregs, current))
293 return 1;
294 msr |= MSR_VSX;
295 }
296#endif /* CONFIG_VSX */
297#ifdef CONFIG_SPE
298 /* save spe registers */
299 if (current->thread.used_spe) {
300 flush_spe_to_thread(current);
301 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
302 ELF_NEVRREG * sizeof(u32)))
303 return 1;
304 /* set MSR_SPE in the saved MSR value to indicate that
305 frame->mc_vregs contains valid data */
306 msr |= MSR_SPE;
307 }
308 /* else assert((regs->msr & MSR_SPE) == 0) */
309
310 /* We always copy to/from spefscr */
311 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
312 return 1;
313#endif /* CONFIG_SPE */
314
315 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
316 return 1;
317 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
318 * can check it on the restore to see if TM is active
319 */
320 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
321 return 1;
322
323 if (sigret) {
324 /* Set up the sigreturn trampoline: li 0,sigret; sc */
325 if (__put_user(PPC_INST_ADDI + sigret, &frame->tramp[0])
326 || __put_user(PPC_INST_SC, &frame->tramp[1]))
327 return 1;
328 flush_icache_range((unsigned long) &frame->tramp[0],
329 (unsigned long) &frame->tramp[2]);
330 }
331
332 return 0;
333}
334
335#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
336/*
337 * Save the current user registers on the user stack.
338 * We only save the altivec/spe registers if the process has used
339 * altivec/spe instructions at some point.
340 * We also save the transactional registers to a second ucontext in the
341 * frame.
342 *
343 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
344 */
345static int save_tm_user_regs(struct pt_regs *regs,
346 struct mcontext __user *frame,
347 struct mcontext __user *tm_frame, int sigret,
348 unsigned long msr)
349{
350 WARN_ON(tm_suspend_disabled);
351
352 /* Save both sets of general registers */
353 if (save_general_regs(¤t->thread.ckpt_regs, frame)
354 || save_general_regs(regs, tm_frame))
355 return 1;
356
357 /* Stash the top half of the 64bit MSR into the 32bit MSR word
358 * of the transactional mcontext. This way we have a backward-compatible
359 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
360 * also look at what type of transaction (T or S) was active at the
361 * time of the signal.
362 */
363 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
364 return 1;
365
366#ifdef CONFIG_ALTIVEC
367 /* save altivec registers */
368 if (current->thread.used_vr) {
369 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state,
370 ELF_NVRREG * sizeof(vector128)))
371 return 1;
372 if (msr & MSR_VEC) {
373 if (__copy_to_user(&tm_frame->mc_vregs,
374 ¤t->thread.vr_state,
375 ELF_NVRREG * sizeof(vector128)))
376 return 1;
377 } else {
378 if (__copy_to_user(&tm_frame->mc_vregs,
379 ¤t->thread.ckvr_state,
380 ELF_NVRREG * sizeof(vector128)))
381 return 1;
382 }
383
384 /* set MSR_VEC in the saved MSR value to indicate that
385 * frame->mc_vregs contains valid data
386 */
387 msr |= MSR_VEC;
388 }
389
390 /* We always copy to/from vrsave, it's 0 if we don't have or don't
391 * use altivec. Since VSCR only contains 32 bits saved in the least
392 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
393 * most significant bits of that same vector. --BenH
394 */
395 if (cpu_has_feature(CPU_FTR_ALTIVEC))
396 current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
397 if (__put_user(current->thread.ckvrsave,
398 (u32 __user *)&frame->mc_vregs[32]))
399 return 1;
400 if (msr & MSR_VEC) {
401 if (__put_user(current->thread.vrsave,
402 (u32 __user *)&tm_frame->mc_vregs[32]))
403 return 1;
404 } else {
405 if (__put_user(current->thread.ckvrsave,
406 (u32 __user *)&tm_frame->mc_vregs[32]))
407 return 1;
408 }
409#endif /* CONFIG_ALTIVEC */
410
411 if (copy_ckfpr_to_user(&frame->mc_fregs, current))
412 return 1;
413 if (msr & MSR_FP) {
414 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
415 return 1;
416 } else {
417 if (copy_ckfpr_to_user(&tm_frame->mc_fregs, current))
418 return 1;
419 }
420
421#ifdef CONFIG_VSX
422 /*
423 * Copy VSR 0-31 upper half from thread_struct to local
424 * buffer, then write that to userspace. Also set MSR_VSX in
425 * the saved MSR value to indicate that frame->mc_vregs
426 * contains valid data
427 */
428 if (current->thread.used_vsr) {
429 if (copy_ckvsx_to_user(&frame->mc_vsregs, current))
430 return 1;
431 if (msr & MSR_VSX) {
432 if (copy_vsx_to_user(&tm_frame->mc_vsregs,
433 current))
434 return 1;
435 } else {
436 if (copy_ckvsx_to_user(&tm_frame->mc_vsregs, current))
437 return 1;
438 }
439
440 msr |= MSR_VSX;
441 }
442#endif /* CONFIG_VSX */
443#ifdef CONFIG_SPE
444 /* SPE regs are not checkpointed with TM, so this section is
445 * simply the same as in save_user_regs().
446 */
447 if (current->thread.used_spe) {
448 flush_spe_to_thread(current);
449 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
450 ELF_NEVRREG * sizeof(u32)))
451 return 1;
452 /* set MSR_SPE in the saved MSR value to indicate that
453 * frame->mc_vregs contains valid data */
454 msr |= MSR_SPE;
455 }
456
457 /* We always copy to/from spefscr */
458 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
459 return 1;
460#endif /* CONFIG_SPE */
461
462 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
463 return 1;
464 if (sigret) {
465 /* Set up the sigreturn trampoline: li 0,sigret; sc */
466 if (__put_user(PPC_INST_ADDI + sigret, &frame->tramp[0])
467 || __put_user(PPC_INST_SC, &frame->tramp[1]))
468 return 1;
469 flush_icache_range((unsigned long) &frame->tramp[0],
470 (unsigned long) &frame->tramp[2]);
471 }
472
473 return 0;
474}
475#endif
476
477/*
478 * Restore the current user register values from the user stack,
479 * (except for MSR).
480 */
481static long restore_user_regs(struct pt_regs *regs,
482 struct mcontext __user *sr, int sig)
483{
484 long err;
485 unsigned int save_r2 = 0;
486 unsigned long msr;
487#ifdef CONFIG_VSX
488 int i;
489#endif
490
491 /*
492 * restore general registers but not including MSR or SOFTE. Also
493 * take care of keeping r2 (TLS) intact if not a signal
494 */
495 if (!sig)
496 save_r2 = (unsigned int)regs->gpr[2];
497 err = restore_general_regs(regs, sr);
498 set_trap_norestart(regs);
499 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
500 if (!sig)
501 regs->gpr[2] = (unsigned long) save_r2;
502 if (err)
503 return 1;
504
505 /* if doing signal return, restore the previous little-endian mode */
506 if (sig)
507 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
508
509#ifdef CONFIG_ALTIVEC
510 /*
511 * Force the process to reload the altivec registers from
512 * current->thread when it next does altivec instructions
513 */
514 regs->msr &= ~MSR_VEC;
515 if (msr & MSR_VEC) {
516 /* restore altivec registers from the stack */
517 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
518 sizeof(sr->mc_vregs)))
519 return 1;
520 current->thread.used_vr = true;
521 } else if (current->thread.used_vr)
522 memset(¤t->thread.vr_state, 0,
523 ELF_NVRREG * sizeof(vector128));
524
525 /* Always get VRSAVE back */
526 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
527 return 1;
528 if (cpu_has_feature(CPU_FTR_ALTIVEC))
529 mtspr(SPRN_VRSAVE, current->thread.vrsave);
530#endif /* CONFIG_ALTIVEC */
531 if (copy_fpr_from_user(current, &sr->mc_fregs))
532 return 1;
533
534#ifdef CONFIG_VSX
535 /*
536 * Force the process to reload the VSX registers from
537 * current->thread when it next does VSX instruction.
538 */
539 regs->msr &= ~MSR_VSX;
540 if (msr & MSR_VSX) {
541 /*
542 * Restore altivec registers from the stack to a local
543 * buffer, then write this out to the thread_struct
544 */
545 if (copy_vsx_from_user(current, &sr->mc_vsregs))
546 return 1;
547 current->thread.used_vsr = true;
548 } else if (current->thread.used_vsr)
549 for (i = 0; i < 32 ; i++)
550 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
551#endif /* CONFIG_VSX */
552 /*
553 * force the process to reload the FP registers from
554 * current->thread when it next does FP instructions
555 */
556 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
557
558#ifdef CONFIG_SPE
559 /* force the process to reload the spe registers from
560 current->thread when it next does spe instructions */
561 regs->msr &= ~MSR_SPE;
562 if (msr & MSR_SPE) {
563 /* restore spe registers from the stack */
564 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
565 ELF_NEVRREG * sizeof(u32)))
566 return 1;
567 current->thread.used_spe = true;
568 } else if (current->thread.used_spe)
569 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
570
571 /* Always get SPEFSCR back */
572 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
573 return 1;
574#endif /* CONFIG_SPE */
575
576 return 0;
577}
578
579#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
580/*
581 * Restore the current user register values from the user stack, except for
582 * MSR, and recheckpoint the original checkpointed register state for processes
583 * in transactions.
584 */
585static long restore_tm_user_regs(struct pt_regs *regs,
586 struct mcontext __user *sr,
587 struct mcontext __user *tm_sr)
588{
589 long err;
590 unsigned long msr, msr_hi;
591#ifdef CONFIG_VSX
592 int i;
593#endif
594
595 if (tm_suspend_disabled)
596 return 1;
597 /*
598 * restore general registers but not including MSR or SOFTE. Also
599 * take care of keeping r2 (TLS) intact if not a signal.
600 * See comment in signal_64.c:restore_tm_sigcontexts();
601 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
602 * were set by the signal delivery.
603 */
604 err = restore_general_regs(regs, tm_sr);
605 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
606
607 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
608
609 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
610 if (err)
611 return 1;
612
613 /* Restore the previous little-endian mode */
614 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
615
616#ifdef CONFIG_ALTIVEC
617 regs->msr &= ~MSR_VEC;
618 if (msr & MSR_VEC) {
619 /* restore altivec registers from the stack */
620 if (__copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs,
621 sizeof(sr->mc_vregs)) ||
622 __copy_from_user(¤t->thread.vr_state,
623 &tm_sr->mc_vregs,
624 sizeof(sr->mc_vregs)))
625 return 1;
626 current->thread.used_vr = true;
627 } else if (current->thread.used_vr) {
628 memset(¤t->thread.vr_state, 0,
629 ELF_NVRREG * sizeof(vector128));
630 memset(¤t->thread.ckvr_state, 0,
631 ELF_NVRREG * sizeof(vector128));
632 }
633
634 /* Always get VRSAVE back */
635 if (__get_user(current->thread.ckvrsave,
636 (u32 __user *)&sr->mc_vregs[32]) ||
637 __get_user(current->thread.vrsave,
638 (u32 __user *)&tm_sr->mc_vregs[32]))
639 return 1;
640 if (cpu_has_feature(CPU_FTR_ALTIVEC))
641 mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
642#endif /* CONFIG_ALTIVEC */
643
644 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
645
646 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
647 copy_ckfpr_from_user(current, &tm_sr->mc_fregs))
648 return 1;
649
650#ifdef CONFIG_VSX
651 regs->msr &= ~MSR_VSX;
652 if (msr & MSR_VSX) {
653 /*
654 * Restore altivec registers from the stack to a local
655 * buffer, then write this out to the thread_struct
656 */
657 if (copy_vsx_from_user(current, &tm_sr->mc_vsregs) ||
658 copy_ckvsx_from_user(current, &sr->mc_vsregs))
659 return 1;
660 current->thread.used_vsr = true;
661 } else if (current->thread.used_vsr)
662 for (i = 0; i < 32 ; i++) {
663 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
664 current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
665 }
666#endif /* CONFIG_VSX */
667
668#ifdef CONFIG_SPE
669 /* SPE regs are not checkpointed with TM, so this section is
670 * simply the same as in restore_user_regs().
671 */
672 regs->msr &= ~MSR_SPE;
673 if (msr & MSR_SPE) {
674 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
675 ELF_NEVRREG * sizeof(u32)))
676 return 1;
677 current->thread.used_spe = true;
678 } else if (current->thread.used_spe)
679 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
680
681 /* Always get SPEFSCR back */
682 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
683 + ELF_NEVRREG))
684 return 1;
685#endif /* CONFIG_SPE */
686
687 /* Get the top half of the MSR from the user context */
688 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
689 return 1;
690 msr_hi <<= 32;
691 /* If TM bits are set to the reserved value, it's an invalid context */
692 if (MSR_TM_RESV(msr_hi))
693 return 1;
694
695 /*
696 * Disabling preemption, since it is unsafe to be preempted
697 * with MSR[TS] set without recheckpointing.
698 */
699 preempt_disable();
700
701 /*
702 * CAUTION:
703 * After regs->MSR[TS] being updated, make sure that get_user(),
704 * put_user() or similar functions are *not* called. These
705 * functions can generate page faults which will cause the process
706 * to be de-scheduled with MSR[TS] set but without calling
707 * tm_recheckpoint(). This can cause a bug.
708 *
709 * Pull in the MSR TM bits from the user context
710 */
711 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
712 /* Now, recheckpoint. This loads up all of the checkpointed (older)
713 * registers, including FP and V[S]Rs. After recheckpointing, the
714 * transactional versions should be loaded.
715 */
716 tm_enable();
717 /* Make sure the transaction is marked as failed */
718 current->thread.tm_texasr |= TEXASR_FS;
719 /* This loads the checkpointed FP/VEC state, if used */
720 tm_recheckpoint(¤t->thread);
721
722 /* This loads the speculative FP/VEC state, if used */
723 msr_check_and_set(msr & (MSR_FP | MSR_VEC));
724 if (msr & MSR_FP) {
725 load_fp_state(¤t->thread.fp_state);
726 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
727 }
728#ifdef CONFIG_ALTIVEC
729 if (msr & MSR_VEC) {
730 load_vr_state(¤t->thread.vr_state);
731 regs->msr |= MSR_VEC;
732 }
733#endif
734
735 preempt_enable();
736
737 return 0;
738}
739#endif
740
741#ifdef CONFIG_PPC64
742
743#define copy_siginfo_to_user copy_siginfo_to_user32
744
745#endif /* CONFIG_PPC64 */
746
747/*
748 * Set up a signal frame for a "real-time" signal handler
749 * (one which gets siginfo).
750 */
751int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
752 struct task_struct *tsk)
753{
754 struct rt_sigframe __user *rt_sf;
755 struct mcontext __user *frame;
756 struct mcontext __user *tm_frame = NULL;
757 void __user *addr;
758 unsigned long newsp = 0;
759 int sigret;
760 unsigned long tramp;
761 struct pt_regs *regs = tsk->thread.regs;
762#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
763 /* Save the thread's msr before get_tm_stackpointer() changes it */
764 unsigned long msr = regs->msr;
765#endif
766
767 BUG_ON(tsk != current);
768
769 /* Set up Signal Frame */
770 /* Put a Real Time Context onto stack */
771 rt_sf = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*rt_sf), 1);
772 addr = rt_sf;
773 if (unlikely(rt_sf == NULL))
774 goto badframe;
775
776 /* Put the siginfo & fill in most of the ucontext */
777 if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
778 || __put_user(0, &rt_sf->uc.uc_flags)
779 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
780 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
781 &rt_sf->uc.uc_regs)
782 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
783 goto badframe;
784
785 /* Save user registers on the stack */
786 frame = &rt_sf->uc.uc_mcontext;
787 addr = frame;
788 if (vdso32_rt_sigtramp && tsk->mm->context.vdso_base) {
789 sigret = 0;
790 tramp = tsk->mm->context.vdso_base + vdso32_rt_sigtramp;
791 } else {
792 sigret = __NR_rt_sigreturn;
793 tramp = (unsigned long) frame->tramp;
794 }
795
796#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
797 tm_frame = &rt_sf->uc_transact.uc_mcontext;
798 if (MSR_TM_ACTIVE(msr)) {
799 if (__put_user((unsigned long)&rt_sf->uc_transact,
800 &rt_sf->uc.uc_link) ||
801 __put_user((unsigned long)tm_frame,
802 &rt_sf->uc_transact.uc_regs))
803 goto badframe;
804 if (save_tm_user_regs(regs, frame, tm_frame, sigret, msr))
805 goto badframe;
806 }
807 else
808#endif
809 {
810 if (__put_user(0, &rt_sf->uc.uc_link))
811 goto badframe;
812 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
813 goto badframe;
814 }
815 regs->link = tramp;
816
817 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
818
819 /* create a stack frame for the caller of the handler */
820 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
821 addr = (void __user *)regs->gpr[1];
822 if (put_user(regs->gpr[1], (u32 __user *)newsp))
823 goto badframe;
824
825 /* Fill registers for signal handler */
826 regs->gpr[1] = newsp;
827 regs->gpr[3] = ksig->sig;
828 regs->gpr[4] = (unsigned long) &rt_sf->info;
829 regs->gpr[5] = (unsigned long) &rt_sf->uc;
830 regs->gpr[6] = (unsigned long) rt_sf;
831 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
832 /* enter the signal handler in native-endian mode */
833 regs->msr &= ~MSR_LE;
834 regs->msr |= (MSR_KERNEL & MSR_LE);
835 return 0;
836
837badframe:
838 if (show_unhandled_signals)
839 printk_ratelimited(KERN_INFO
840 "%s[%d]: bad frame in handle_rt_signal32: "
841 "%p nip %08lx lr %08lx\n",
842 tsk->comm, tsk->pid,
843 addr, regs->nip, regs->link);
844
845 return 1;
846}
847
848static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
849{
850 sigset_t set;
851 struct mcontext __user *mcp;
852
853 if (get_sigset_t(&set, &ucp->uc_sigmask))
854 return -EFAULT;
855#ifdef CONFIG_PPC64
856 {
857 u32 cmcp;
858
859 if (__get_user(cmcp, &ucp->uc_regs))
860 return -EFAULT;
861 mcp = (struct mcontext __user *)(u64)cmcp;
862 /* no need to check access_ok(mcp), since mcp < 4GB */
863 }
864#else
865 if (__get_user(mcp, &ucp->uc_regs))
866 return -EFAULT;
867 if (!access_ok(mcp, sizeof(*mcp)))
868 return -EFAULT;
869#endif
870 set_current_blocked(&set);
871 if (restore_user_regs(regs, mcp, sig))
872 return -EFAULT;
873
874 return 0;
875}
876
877#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
878static int do_setcontext_tm(struct ucontext __user *ucp,
879 struct ucontext __user *tm_ucp,
880 struct pt_regs *regs)
881{
882 sigset_t set;
883 struct mcontext __user *mcp;
884 struct mcontext __user *tm_mcp;
885 u32 cmcp;
886 u32 tm_cmcp;
887
888 if (get_sigset_t(&set, &ucp->uc_sigmask))
889 return -EFAULT;
890
891 if (__get_user(cmcp, &ucp->uc_regs) ||
892 __get_user(tm_cmcp, &tm_ucp->uc_regs))
893 return -EFAULT;
894 mcp = (struct mcontext __user *)(u64)cmcp;
895 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
896 /* no need to check access_ok(mcp), since mcp < 4GB */
897
898 set_current_blocked(&set);
899 if (restore_tm_user_regs(regs, mcp, tm_mcp))
900 return -EFAULT;
901
902 return 0;
903}
904#endif
905
906#ifdef CONFIG_PPC64
907COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
908 struct ucontext __user *, new_ctx, int, ctx_size)
909#else
910SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
911 struct ucontext __user *, new_ctx, long, ctx_size)
912#endif
913{
914 struct pt_regs *regs = current_pt_regs();
915 int ctx_has_vsx_region = 0;
916
917#ifdef CONFIG_PPC64
918 unsigned long new_msr = 0;
919
920 if (new_ctx) {
921 struct mcontext __user *mcp;
922 u32 cmcp;
923
924 /*
925 * Get pointer to the real mcontext. No need for
926 * access_ok since we are dealing with compat
927 * pointers.
928 */
929 if (__get_user(cmcp, &new_ctx->uc_regs))
930 return -EFAULT;
931 mcp = (struct mcontext __user *)(u64)cmcp;
932 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
933 return -EFAULT;
934 }
935 /*
936 * Check that the context is not smaller than the original
937 * size (with VMX but without VSX)
938 */
939 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
940 return -EINVAL;
941 /*
942 * If the new context state sets the MSR VSX bits but
943 * it doesn't provide VSX state.
944 */
945 if ((ctx_size < sizeof(struct ucontext)) &&
946 (new_msr & MSR_VSX))
947 return -EINVAL;
948 /* Does the context have enough room to store VSX data? */
949 if (ctx_size >= sizeof(struct ucontext))
950 ctx_has_vsx_region = 1;
951#else
952 /* Context size is for future use. Right now, we only make sure
953 * we are passed something we understand
954 */
955 if (ctx_size < sizeof(struct ucontext))
956 return -EINVAL;
957#endif
958 if (old_ctx != NULL) {
959 struct mcontext __user *mctx;
960
961 /*
962 * old_ctx might not be 16-byte aligned, in which
963 * case old_ctx->uc_mcontext won't be either.
964 * Because we have the old_ctx->uc_pad2 field
965 * before old_ctx->uc_mcontext, we need to round down
966 * from &old_ctx->uc_mcontext to a 16-byte boundary.
967 */
968 mctx = (struct mcontext __user *)
969 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
970 if (!access_ok(old_ctx, ctx_size)
971 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
972 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
973 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
974 return -EFAULT;
975 }
976 if (new_ctx == NULL)
977 return 0;
978 if (!access_ok(new_ctx, ctx_size) ||
979 fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
980 return -EFAULT;
981
982 /*
983 * If we get a fault copying the context into the kernel's
984 * image of the user's registers, we can't just return -EFAULT
985 * because the user's registers will be corrupted. For instance
986 * the NIP value may have been updated but not some of the
987 * other registers. Given that we have done the access_ok
988 * and successfully read the first and last bytes of the region
989 * above, this should only happen in an out-of-memory situation
990 * or if another thread unmaps the region containing the context.
991 * We kill the task with a SIGSEGV in this situation.
992 */
993 if (do_setcontext(new_ctx, regs, 0))
994 do_exit(SIGSEGV);
995
996 set_thread_flag(TIF_RESTOREALL);
997 return 0;
998}
999
1000#ifdef CONFIG_PPC64
1001COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
1002#else
1003SYSCALL_DEFINE0(rt_sigreturn)
1004#endif
1005{
1006 struct rt_sigframe __user *rt_sf;
1007 struct pt_regs *regs = current_pt_regs();
1008 int tm_restore = 0;
1009#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1010 struct ucontext __user *uc_transact;
1011 unsigned long msr_hi;
1012 unsigned long tmp;
1013#endif
1014 /* Always make any pending restarted system calls return -EINTR */
1015 current->restart_block.fn = do_no_restart_syscall;
1016
1017 rt_sf = (struct rt_sigframe __user *)
1018 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1019 if (!access_ok(rt_sf, sizeof(*rt_sf)))
1020 goto bad;
1021
1022#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1023 /*
1024 * If there is a transactional state then throw it away.
1025 * The purpose of a sigreturn is to destroy all traces of the
1026 * signal frame, this includes any transactional state created
1027 * within in. We only check for suspended as we can never be
1028 * active in the kernel, we are active, there is nothing better to
1029 * do than go ahead and Bad Thing later.
1030 * The cause is not important as there will never be a
1031 * recheckpoint so it's not user visible.
1032 */
1033 if (MSR_TM_SUSPENDED(mfmsr()))
1034 tm_reclaim_current(0);
1035
1036 if (__get_user(tmp, &rt_sf->uc.uc_link))
1037 goto bad;
1038 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1039 if (uc_transact) {
1040 u32 cmcp;
1041 struct mcontext __user *mcp;
1042
1043 if (__get_user(cmcp, &uc_transact->uc_regs))
1044 return -EFAULT;
1045 mcp = (struct mcontext __user *)(u64)cmcp;
1046 /* The top 32 bits of the MSR are stashed in the transactional
1047 * ucontext. */
1048 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1049 goto bad;
1050
1051 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1052 /* Trying to start TM on non TM system */
1053 if (!cpu_has_feature(CPU_FTR_TM))
1054 goto bad;
1055 /* We only recheckpoint on return if we're
1056 * transaction.
1057 */
1058 tm_restore = 1;
1059 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1060 goto bad;
1061 }
1062 }
1063 if (!tm_restore) {
1064 /*
1065 * Unset regs->msr because ucontext MSR TS is not
1066 * set, and recheckpoint was not called. This avoid
1067 * hitting a TM Bad thing at RFID
1068 */
1069 regs->msr &= ~MSR_TS_MASK;
1070 }
1071 /* Fall through, for non-TM restore */
1072#endif
1073 if (!tm_restore)
1074 if (do_setcontext(&rt_sf->uc, regs, 1))
1075 goto bad;
1076
1077 /*
1078 * It's not clear whether or why it is desirable to save the
1079 * sigaltstack setting on signal delivery and restore it on
1080 * signal return. But other architectures do this and we have
1081 * always done it up until now so it is probably better not to
1082 * change it. -- paulus
1083 */
1084#ifdef CONFIG_PPC64
1085 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1086 goto bad;
1087#else
1088 if (restore_altstack(&rt_sf->uc.uc_stack))
1089 goto bad;
1090#endif
1091 set_thread_flag(TIF_RESTOREALL);
1092 return 0;
1093
1094 bad:
1095 if (show_unhandled_signals)
1096 printk_ratelimited(KERN_INFO
1097 "%s[%d]: bad frame in sys_rt_sigreturn: "
1098 "%p nip %08lx lr %08lx\n",
1099 current->comm, current->pid,
1100 rt_sf, regs->nip, regs->link);
1101
1102 force_sig(SIGSEGV);
1103 return 0;
1104}
1105
1106#ifdef CONFIG_PPC32
1107SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
1108 int, ndbg, struct sig_dbg_op __user *, dbg)
1109{
1110 struct pt_regs *regs = current_pt_regs();
1111 struct sig_dbg_op op;
1112 int i;
1113 unsigned long new_msr = regs->msr;
1114#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1115 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1116#endif
1117
1118 for (i=0; i<ndbg; i++) {
1119 if (copy_from_user(&op, dbg + i, sizeof(op)))
1120 return -EFAULT;
1121 switch (op.dbg_type) {
1122 case SIG_DBG_SINGLE_STEPPING:
1123#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1124 if (op.dbg_value) {
1125 new_msr |= MSR_DE;
1126 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1127 } else {
1128 new_dbcr0 &= ~DBCR0_IC;
1129 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1130 current->thread.debug.dbcr1)) {
1131 new_msr &= ~MSR_DE;
1132 new_dbcr0 &= ~DBCR0_IDM;
1133 }
1134 }
1135#else
1136 if (op.dbg_value)
1137 new_msr |= MSR_SE;
1138 else
1139 new_msr &= ~MSR_SE;
1140#endif
1141 break;
1142 case SIG_DBG_BRANCH_TRACING:
1143#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1144 return -EINVAL;
1145#else
1146 if (op.dbg_value)
1147 new_msr |= MSR_BE;
1148 else
1149 new_msr &= ~MSR_BE;
1150#endif
1151 break;
1152
1153 default:
1154 return -EINVAL;
1155 }
1156 }
1157
1158 /* We wait until here to actually install the values in the
1159 registers so if we fail in the above loop, it will not
1160 affect the contents of these registers. After this point,
1161 failure is a problem, anyway, and it's very unlikely unless
1162 the user is really doing something wrong. */
1163 regs->msr = new_msr;
1164#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1165 current->thread.debug.dbcr0 = new_dbcr0;
1166#endif
1167
1168 if (!access_ok(ctx, sizeof(*ctx)) ||
1169 fault_in_pages_readable((u8 __user *)ctx, sizeof(*ctx)))
1170 return -EFAULT;
1171
1172 /*
1173 * If we get a fault copying the context into the kernel's
1174 * image of the user's registers, we can't just return -EFAULT
1175 * because the user's registers will be corrupted. For instance
1176 * the NIP value may have been updated but not some of the
1177 * other registers. Given that we have done the access_ok
1178 * and successfully read the first and last bytes of the region
1179 * above, this should only happen in an out-of-memory situation
1180 * or if another thread unmaps the region containing the context.
1181 * We kill the task with a SIGSEGV in this situation.
1182 */
1183 if (do_setcontext(ctx, regs, 1)) {
1184 if (show_unhandled_signals)
1185 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1186 "sys_debug_setcontext: %p nip %08lx "
1187 "lr %08lx\n",
1188 current->comm, current->pid,
1189 ctx, regs->nip, regs->link);
1190
1191 force_sig(SIGSEGV);
1192 goto out;
1193 }
1194
1195 /*
1196 * It's not clear whether or why it is desirable to save the
1197 * sigaltstack setting on signal delivery and restore it on
1198 * signal return. But other architectures do this and we have
1199 * always done it up until now so it is probably better not to
1200 * change it. -- paulus
1201 */
1202 restore_altstack(&ctx->uc_stack);
1203
1204 set_thread_flag(TIF_RESTOREALL);
1205 out:
1206 return 0;
1207}
1208#endif
1209
1210/*
1211 * OK, we're invoking a handler
1212 */
1213int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
1214 struct task_struct *tsk)
1215{
1216 struct sigcontext __user *sc;
1217 struct sigframe __user *frame;
1218 struct mcontext __user *tm_mctx = NULL;
1219 unsigned long newsp = 0;
1220 int sigret;
1221 unsigned long tramp;
1222 struct pt_regs *regs = tsk->thread.regs;
1223#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1224 /* Save the thread's msr before get_tm_stackpointer() changes it */
1225 unsigned long msr = regs->msr;
1226#endif
1227
1228 BUG_ON(tsk != current);
1229
1230 /* Set up Signal Frame */
1231 frame = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*frame), 1);
1232 if (unlikely(frame == NULL))
1233 goto badframe;
1234 sc = (struct sigcontext __user *) &frame->sctx;
1235
1236#if _NSIG != 64
1237#error "Please adjust handle_signal()"
1238#endif
1239 if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1240 || __put_user(oldset->sig[0], &sc->oldmask)
1241#ifdef CONFIG_PPC64
1242 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1243#else
1244 || __put_user(oldset->sig[1], &sc->_unused[3])
1245#endif
1246 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1247 || __put_user(ksig->sig, &sc->signal))
1248 goto badframe;
1249
1250 if (vdso32_sigtramp && tsk->mm->context.vdso_base) {
1251 sigret = 0;
1252 tramp = tsk->mm->context.vdso_base + vdso32_sigtramp;
1253 } else {
1254 sigret = __NR_sigreturn;
1255 tramp = (unsigned long) frame->mctx.tramp;
1256 }
1257
1258#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1259 tm_mctx = &frame->mctx_transact;
1260 if (MSR_TM_ACTIVE(msr)) {
1261 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1262 sigret, msr))
1263 goto badframe;
1264 }
1265 else
1266#endif
1267 {
1268 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1269 goto badframe;
1270 }
1271
1272 regs->link = tramp;
1273
1274 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1275
1276 /* create a stack frame for the caller of the handler */
1277 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1278 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1279 goto badframe;
1280
1281 regs->gpr[1] = newsp;
1282 regs->gpr[3] = ksig->sig;
1283 regs->gpr[4] = (unsigned long) sc;
1284 regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1285 /* enter the signal handler in big-endian mode */
1286 regs->msr &= ~MSR_LE;
1287 return 0;
1288
1289badframe:
1290 if (show_unhandled_signals)
1291 printk_ratelimited(KERN_INFO
1292 "%s[%d]: bad frame in handle_signal32: "
1293 "%p nip %08lx lr %08lx\n",
1294 tsk->comm, tsk->pid,
1295 frame, regs->nip, regs->link);
1296
1297 return 1;
1298}
1299
1300/*
1301 * Do a signal return; undo the signal stack.
1302 */
1303#ifdef CONFIG_PPC64
1304COMPAT_SYSCALL_DEFINE0(sigreturn)
1305#else
1306SYSCALL_DEFINE0(sigreturn)
1307#endif
1308{
1309 struct pt_regs *regs = current_pt_regs();
1310 struct sigframe __user *sf;
1311 struct sigcontext __user *sc;
1312 struct sigcontext sigctx;
1313 struct mcontext __user *sr;
1314 void __user *addr;
1315 sigset_t set;
1316#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1317 struct mcontext __user *mcp, *tm_mcp;
1318 unsigned long msr_hi;
1319#endif
1320
1321 /* Always make any pending restarted system calls return -EINTR */
1322 current->restart_block.fn = do_no_restart_syscall;
1323
1324 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1325 sc = &sf->sctx;
1326 addr = sc;
1327 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1328 goto badframe;
1329
1330#ifdef CONFIG_PPC64
1331 /*
1332 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1333 * unused part of the signal stackframe
1334 */
1335 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1336#else
1337 set.sig[0] = sigctx.oldmask;
1338 set.sig[1] = sigctx._unused[3];
1339#endif
1340 set_current_blocked(&set);
1341
1342#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1343 mcp = (struct mcontext __user *)&sf->mctx;
1344 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1345 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1346 goto badframe;
1347 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1348 if (!cpu_has_feature(CPU_FTR_TM))
1349 goto badframe;
1350 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1351 goto badframe;
1352 } else
1353#endif
1354 {
1355 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1356 addr = sr;
1357 if (!access_ok(sr, sizeof(*sr))
1358 || restore_user_regs(regs, sr, 1))
1359 goto badframe;
1360 }
1361
1362 set_thread_flag(TIF_RESTOREALL);
1363 return 0;
1364
1365badframe:
1366 if (show_unhandled_signals)
1367 printk_ratelimited(KERN_INFO
1368 "%s[%d]: bad frame in sys_sigreturn: "
1369 "%p nip %08lx lr %08lx\n",
1370 current->comm, current->pid,
1371 addr, regs->nip, regs->link);
1372
1373 force_sig(SIGSEGV);
1374 return 0;
1375}
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/kernel.h>
24#include <linux/signal.h>
25#include <linux/errno.h>
26#include <linux/elf.h>
27#include <linux/ptrace.h>
28#include <linux/ratelimit.h>
29#ifdef CONFIG_PPC64
30#include <linux/syscalls.h>
31#include <linux/compat.h>
32#else
33#include <linux/wait.h>
34#include <linux/unistd.h>
35#include <linux/stddef.h>
36#include <linux/tty.h>
37#include <linux/binfmts.h>
38#endif
39
40#include <asm/uaccess.h>
41#include <asm/cacheflush.h>
42#include <asm/syscalls.h>
43#include <asm/sigcontext.h>
44#include <asm/vdso.h>
45#include <asm/switch_to.h>
46#include <asm/tm.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#include "signal.h"
56
57
58#ifdef CONFIG_PPC64
59#define sys_rt_sigreturn compat_sys_rt_sigreturn
60#define sys_swapcontext compat_sys_swapcontext
61#define sys_sigreturn compat_sys_sigreturn
62
63#define old_sigaction old_sigaction32
64#define sigcontext sigcontext32
65#define mcontext mcontext32
66#define ucontext ucontext32
67
68#define __save_altstack __compat_save_altstack
69
70/*
71 * 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/*
78 * 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 */
83
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[6] = 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
111static inline int get_sigset_t(sigset_t *set,
112 const compat_sigset_t __user *uset)
113{
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
132#define to_user_ptr(p) ptr_to_compat(p)
133#define from_user_ptr(p) compat_ptr(p)
134
135static inline int save_general_regs(struct pt_regs *regs,
136 struct mcontext __user *frame)
137{
138 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
139 int i;
140
141 WARN_ON(!FULL_REGS(regs));
142
143 for (i = 0; i <= PT_RESULT; i ++) {
144 if (i == 14 && !FULL_REGS(regs))
145 i = 32;
146 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
147 return -EFAULT;
148 }
149 return 0;
150}
151
152static inline int restore_general_regs(struct pt_regs *regs,
153 struct mcontext __user *sr)
154{
155 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
156 int i;
157
158 for (i = 0; i <= PT_RESULT; i++) {
159 if ((i == PT_MSR) || (i == PT_SOFTE))
160 continue;
161 if (__get_user(gregs[i], &sr->mc_gregs[i]))
162 return -EFAULT;
163 }
164 return 0;
165}
166
167#else /* CONFIG_PPC64 */
168
169#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
170
171static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
172{
173 return copy_to_user(uset, set, sizeof(*uset));
174}
175
176static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
177{
178 return copy_from_user(set, uset, sizeof(*uset));
179}
180
181#define to_user_ptr(p) ((unsigned long)(p))
182#define from_user_ptr(p) ((void __user *)(p))
183
184static inline int save_general_regs(struct pt_regs *regs,
185 struct mcontext __user *frame)
186{
187 WARN_ON(!FULL_REGS(regs));
188 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
189}
190
191static inline int restore_general_regs(struct pt_regs *regs,
192 struct mcontext __user *sr)
193{
194 /* copy up to but not including MSR */
195 if (__copy_from_user(regs, &sr->mc_gregs,
196 PT_MSR * sizeof(elf_greg_t)))
197 return -EFAULT;
198 /* copy from orig_r3 (the word after the MSR) up to the end */
199 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
200 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
201 return -EFAULT;
202 return 0;
203}
204#endif
205
206/*
207 * When we have signals to deliver, we set up on the
208 * user stack, going down from the original stack pointer:
209 * an ABI gap of 56 words
210 * an mcontext struct
211 * a sigcontext struct
212 * a gap of __SIGNAL_FRAMESIZE bytes
213 *
214 * Each of these things must be a multiple of 16 bytes in size. The following
215 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
216 *
217 */
218struct sigframe {
219 struct sigcontext sctx; /* the sigcontext */
220 struct mcontext mctx; /* all the register values */
221#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
222 struct sigcontext sctx_transact;
223 struct mcontext mctx_transact;
224#endif
225 /*
226 * Programs using the rs6000/xcoff abi can save up to 19 gp
227 * regs and 18 fp regs below sp before decrementing it.
228 */
229 int abigap[56];
230};
231
232/* We use the mc_pad field for the signal return trampoline. */
233#define tramp mc_pad
234
235/*
236 * When we have rt signals to deliver, we set up on the
237 * user stack, going down from the original stack pointer:
238 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
239 * a gap of __SIGNAL_FRAMESIZE+16 bytes
240 * (the +16 is to get the siginfo and ucontext in the same
241 * positions as in older kernels).
242 *
243 * Each of these things must be a multiple of 16 bytes in size.
244 *
245 */
246struct rt_sigframe {
247#ifdef CONFIG_PPC64
248 compat_siginfo_t info;
249#else
250 struct siginfo info;
251#endif
252 struct ucontext uc;
253#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
254 struct ucontext uc_transact;
255#endif
256 /*
257 * Programs using the rs6000/xcoff abi can save up to 19 gp
258 * regs and 18 fp regs below sp before decrementing it.
259 */
260 int abigap[56];
261};
262
263#ifdef CONFIG_VSX
264unsigned long copy_fpr_to_user(void __user *to,
265 struct task_struct *task)
266{
267 u64 buf[ELF_NFPREG];
268 int i;
269
270 /* save FPR copy to local buffer then write to the thread_struct */
271 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
272 buf[i] = task->thread.TS_FPR(i);
273 buf[i] = task->thread.fp_state.fpscr;
274 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
275}
276
277unsigned long copy_fpr_from_user(struct task_struct *task,
278 void __user *from)
279{
280 u64 buf[ELF_NFPREG];
281 int i;
282
283 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
284 return 1;
285 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
286 task->thread.TS_FPR(i) = buf[i];
287 task->thread.fp_state.fpscr = buf[i];
288
289 return 0;
290}
291
292unsigned long copy_vsx_to_user(void __user *to,
293 struct task_struct *task)
294{
295 u64 buf[ELF_NVSRHALFREG];
296 int i;
297
298 /* save FPR copy to local buffer then write to the thread_struct */
299 for (i = 0; i < ELF_NVSRHALFREG; i++)
300 buf[i] = task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET];
301 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
302}
303
304unsigned long copy_vsx_from_user(struct task_struct *task,
305 void __user *from)
306{
307 u64 buf[ELF_NVSRHALFREG];
308 int i;
309
310 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
311 return 1;
312 for (i = 0; i < ELF_NVSRHALFREG ; i++)
313 task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
314 return 0;
315}
316
317#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
318unsigned long copy_transact_fpr_to_user(void __user *to,
319 struct task_struct *task)
320{
321 u64 buf[ELF_NFPREG];
322 int i;
323
324 /* save FPR copy to local buffer then write to the thread_struct */
325 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
326 buf[i] = task->thread.TS_TRANS_FPR(i);
327 buf[i] = task->thread.transact_fp.fpscr;
328 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
329}
330
331unsigned long copy_transact_fpr_from_user(struct task_struct *task,
332 void __user *from)
333{
334 u64 buf[ELF_NFPREG];
335 int i;
336
337 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
338 return 1;
339 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
340 task->thread.TS_TRANS_FPR(i) = buf[i];
341 task->thread.transact_fp.fpscr = buf[i];
342
343 return 0;
344}
345
346unsigned long copy_transact_vsx_to_user(void __user *to,
347 struct task_struct *task)
348{
349 u64 buf[ELF_NVSRHALFREG];
350 int i;
351
352 /* save FPR copy to local buffer then write to the thread_struct */
353 for (i = 0; i < ELF_NVSRHALFREG; i++)
354 buf[i] = task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET];
355 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
356}
357
358unsigned long copy_transact_vsx_from_user(struct task_struct *task,
359 void __user *from)
360{
361 u64 buf[ELF_NVSRHALFREG];
362 int i;
363
364 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
365 return 1;
366 for (i = 0; i < ELF_NVSRHALFREG ; i++)
367 task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = buf[i];
368 return 0;
369}
370#endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
371#else
372inline unsigned long copy_fpr_to_user(void __user *to,
373 struct task_struct *task)
374{
375 return __copy_to_user(to, task->thread.fp_state.fpr,
376 ELF_NFPREG * sizeof(double));
377}
378
379inline unsigned long copy_fpr_from_user(struct task_struct *task,
380 void __user *from)
381{
382 return __copy_from_user(task->thread.fp_state.fpr, from,
383 ELF_NFPREG * sizeof(double));
384}
385
386#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
387inline unsigned long copy_transact_fpr_to_user(void __user *to,
388 struct task_struct *task)
389{
390 return __copy_to_user(to, task->thread.transact_fp.fpr,
391 ELF_NFPREG * sizeof(double));
392}
393
394inline unsigned long copy_transact_fpr_from_user(struct task_struct *task,
395 void __user *from)
396{
397 return __copy_from_user(task->thread.transact_fp.fpr, from,
398 ELF_NFPREG * sizeof(double));
399}
400#endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
401#endif
402
403/*
404 * Save the current user registers on the user stack.
405 * We only save the altivec/spe registers if the process has used
406 * altivec/spe instructions at some point.
407 */
408static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
409 struct mcontext __user *tm_frame, int sigret,
410 int ctx_has_vsx_region)
411{
412 unsigned long msr = regs->msr;
413
414 /* Make sure floating point registers are stored in regs */
415 flush_fp_to_thread(current);
416
417 /* save general registers */
418 if (save_general_regs(regs, frame))
419 return 1;
420
421#ifdef CONFIG_ALTIVEC
422 /* save altivec registers */
423 if (current->thread.used_vr) {
424 flush_altivec_to_thread(current);
425 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
426 ELF_NVRREG * sizeof(vector128)))
427 return 1;
428 /* set MSR_VEC in the saved MSR value to indicate that
429 frame->mc_vregs contains valid data */
430 msr |= MSR_VEC;
431 }
432 /* else assert((regs->msr & MSR_VEC) == 0) */
433
434 /* We always copy to/from vrsave, it's 0 if we don't have or don't
435 * use altivec. Since VSCR only contains 32 bits saved in the least
436 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
437 * most significant bits of that same vector. --BenH
438 * Note that the current VRSAVE value is in the SPR at this point.
439 */
440 if (cpu_has_feature(CPU_FTR_ALTIVEC))
441 current->thread.vrsave = mfspr(SPRN_VRSAVE);
442 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
443 return 1;
444#endif /* CONFIG_ALTIVEC */
445 if (copy_fpr_to_user(&frame->mc_fregs, current))
446 return 1;
447
448 /*
449 * Clear the MSR VSX bit to indicate there is no valid state attached
450 * to this context, except in the specific case below where we set it.
451 */
452 msr &= ~MSR_VSX;
453#ifdef CONFIG_VSX
454 /*
455 * Copy VSR 0-31 upper half from thread_struct to local
456 * buffer, then write that to userspace. Also set MSR_VSX in
457 * the saved MSR value to indicate that frame->mc_vregs
458 * contains valid data
459 */
460 if (current->thread.used_vsr && ctx_has_vsx_region) {
461 flush_vsx_to_thread(current);
462 if (copy_vsx_to_user(&frame->mc_vsregs, current))
463 return 1;
464 msr |= MSR_VSX;
465 }
466#endif /* CONFIG_VSX */
467#ifdef CONFIG_SPE
468 /* save spe registers */
469 if (current->thread.used_spe) {
470 flush_spe_to_thread(current);
471 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
472 ELF_NEVRREG * sizeof(u32)))
473 return 1;
474 /* set MSR_SPE in the saved MSR value to indicate that
475 frame->mc_vregs contains valid data */
476 msr |= MSR_SPE;
477 }
478 /* else assert((regs->msr & MSR_SPE) == 0) */
479
480 /* We always copy to/from spefscr */
481 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
482 return 1;
483#endif /* CONFIG_SPE */
484
485 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
486 return 1;
487 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
488 * can check it on the restore to see if TM is active
489 */
490 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
491 return 1;
492
493 if (sigret) {
494 /* Set up the sigreturn trampoline: li r0,sigret; sc */
495 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
496 || __put_user(0x44000002UL, &frame->tramp[1]))
497 return 1;
498 flush_icache_range((unsigned long) &frame->tramp[0],
499 (unsigned long) &frame->tramp[2]);
500 }
501
502 return 0;
503}
504
505#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
506/*
507 * Save the current user registers on the user stack.
508 * We only save the altivec/spe registers if the process has used
509 * altivec/spe instructions at some point.
510 * We also save the transactional registers to a second ucontext in the
511 * frame.
512 *
513 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
514 */
515static int save_tm_user_regs(struct pt_regs *regs,
516 struct mcontext __user *frame,
517 struct mcontext __user *tm_frame, int sigret)
518{
519 unsigned long msr = regs->msr;
520
521 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
522 * just indicates to userland that we were doing a transaction, but we
523 * don't want to return in transactional state. This also ensures
524 * that flush_fp_to_thread won't set TIF_RESTORE_TM again.
525 */
526 regs->msr &= ~MSR_TS_MASK;
527
528 /* Make sure floating point registers are stored in regs */
529 flush_fp_to_thread(current);
530
531 /* Save both sets of general registers */
532 if (save_general_regs(¤t->thread.ckpt_regs, frame)
533 || save_general_regs(regs, tm_frame))
534 return 1;
535
536 /* Stash the top half of the 64bit MSR into the 32bit MSR word
537 * of the transactional mcontext. This way we have a backward-compatible
538 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
539 * also look at what type of transaction (T or S) was active at the
540 * time of the signal.
541 */
542 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
543 return 1;
544
545#ifdef CONFIG_ALTIVEC
546 /* save altivec registers */
547 if (current->thread.used_vr) {
548 flush_altivec_to_thread(current);
549 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
550 ELF_NVRREG * sizeof(vector128)))
551 return 1;
552 if (msr & MSR_VEC) {
553 if (__copy_to_user(&tm_frame->mc_vregs,
554 ¤t->thread.transact_vr,
555 ELF_NVRREG * sizeof(vector128)))
556 return 1;
557 } else {
558 if (__copy_to_user(&tm_frame->mc_vregs,
559 ¤t->thread.vr_state,
560 ELF_NVRREG * sizeof(vector128)))
561 return 1;
562 }
563
564 /* set MSR_VEC in the saved MSR value to indicate that
565 * frame->mc_vregs contains valid data
566 */
567 msr |= MSR_VEC;
568 }
569
570 /* We always copy to/from vrsave, it's 0 if we don't have or don't
571 * use altivec. Since VSCR only contains 32 bits saved in the least
572 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
573 * most significant bits of that same vector. --BenH
574 */
575 if (cpu_has_feature(CPU_FTR_ALTIVEC))
576 current->thread.vrsave = mfspr(SPRN_VRSAVE);
577 if (__put_user(current->thread.vrsave,
578 (u32 __user *)&frame->mc_vregs[32]))
579 return 1;
580 if (msr & MSR_VEC) {
581 if (__put_user(current->thread.transact_vrsave,
582 (u32 __user *)&tm_frame->mc_vregs[32]))
583 return 1;
584 } else {
585 if (__put_user(current->thread.vrsave,
586 (u32 __user *)&tm_frame->mc_vregs[32]))
587 return 1;
588 }
589#endif /* CONFIG_ALTIVEC */
590
591 if (copy_fpr_to_user(&frame->mc_fregs, current))
592 return 1;
593 if (msr & MSR_FP) {
594 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current))
595 return 1;
596 } else {
597 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
598 return 1;
599 }
600
601#ifdef CONFIG_VSX
602 /*
603 * Copy VSR 0-31 upper half from thread_struct to local
604 * buffer, then write that to userspace. Also set MSR_VSX in
605 * the saved MSR value to indicate that frame->mc_vregs
606 * contains valid data
607 */
608 if (current->thread.used_vsr) {
609 flush_vsx_to_thread(current);
610 if (copy_vsx_to_user(&frame->mc_vsregs, current))
611 return 1;
612 if (msr & MSR_VSX) {
613 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs,
614 current))
615 return 1;
616 } else {
617 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current))
618 return 1;
619 }
620
621 msr |= MSR_VSX;
622 }
623#endif /* CONFIG_VSX */
624#ifdef CONFIG_SPE
625 /* SPE regs are not checkpointed with TM, so this section is
626 * simply the same as in save_user_regs().
627 */
628 if (current->thread.used_spe) {
629 flush_spe_to_thread(current);
630 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
631 ELF_NEVRREG * sizeof(u32)))
632 return 1;
633 /* set MSR_SPE in the saved MSR value to indicate that
634 * frame->mc_vregs contains valid data */
635 msr |= MSR_SPE;
636 }
637
638 /* We always copy to/from spefscr */
639 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
640 return 1;
641#endif /* CONFIG_SPE */
642
643 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
644 return 1;
645 if (sigret) {
646 /* Set up the sigreturn trampoline: li r0,sigret; sc */
647 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
648 || __put_user(0x44000002UL, &frame->tramp[1]))
649 return 1;
650 flush_icache_range((unsigned long) &frame->tramp[0],
651 (unsigned long) &frame->tramp[2]);
652 }
653
654 return 0;
655}
656#endif
657
658/*
659 * Restore the current user register values from the user stack,
660 * (except for MSR).
661 */
662static long restore_user_regs(struct pt_regs *regs,
663 struct mcontext __user *sr, int sig)
664{
665 long err;
666 unsigned int save_r2 = 0;
667 unsigned long msr;
668#ifdef CONFIG_VSX
669 int i;
670#endif
671
672 /*
673 * restore general registers but not including MSR or SOFTE. Also
674 * take care of keeping r2 (TLS) intact if not a signal
675 */
676 if (!sig)
677 save_r2 = (unsigned int)regs->gpr[2];
678 err = restore_general_regs(regs, sr);
679 regs->trap = 0;
680 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
681 if (!sig)
682 regs->gpr[2] = (unsigned long) save_r2;
683 if (err)
684 return 1;
685
686 /* if doing signal return, restore the previous little-endian mode */
687 if (sig)
688 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
689
690#ifdef CONFIG_ALTIVEC
691 /*
692 * Force the process to reload the altivec registers from
693 * current->thread when it next does altivec instructions
694 */
695 regs->msr &= ~MSR_VEC;
696 if (msr & MSR_VEC) {
697 /* restore altivec registers from the stack */
698 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
699 sizeof(sr->mc_vregs)))
700 return 1;
701 } else if (current->thread.used_vr)
702 memset(¤t->thread.vr_state, 0,
703 ELF_NVRREG * sizeof(vector128));
704
705 /* Always get VRSAVE back */
706 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
707 return 1;
708 if (cpu_has_feature(CPU_FTR_ALTIVEC))
709 mtspr(SPRN_VRSAVE, current->thread.vrsave);
710#endif /* CONFIG_ALTIVEC */
711 if (copy_fpr_from_user(current, &sr->mc_fregs))
712 return 1;
713
714#ifdef CONFIG_VSX
715 /*
716 * Force the process to reload the VSX registers from
717 * current->thread when it next does VSX instruction.
718 */
719 regs->msr &= ~MSR_VSX;
720 if (msr & MSR_VSX) {
721 /*
722 * Restore altivec registers from the stack to a local
723 * buffer, then write this out to the thread_struct
724 */
725 if (copy_vsx_from_user(current, &sr->mc_vsregs))
726 return 1;
727 } else if (current->thread.used_vsr)
728 for (i = 0; i < 32 ; i++)
729 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
730#endif /* CONFIG_VSX */
731 /*
732 * force the process to reload the FP registers from
733 * current->thread when it next does FP instructions
734 */
735 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
736
737#ifdef CONFIG_SPE
738 /* force the process to reload the spe registers from
739 current->thread when it next does spe instructions */
740 regs->msr &= ~MSR_SPE;
741 if (msr & MSR_SPE) {
742 /* restore spe registers from the stack */
743 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
744 ELF_NEVRREG * sizeof(u32)))
745 return 1;
746 } else if (current->thread.used_spe)
747 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
748
749 /* Always get SPEFSCR back */
750 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
751 return 1;
752#endif /* CONFIG_SPE */
753
754 return 0;
755}
756
757#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
758/*
759 * Restore the current user register values from the user stack, except for
760 * MSR, and recheckpoint the original checkpointed register state for processes
761 * in transactions.
762 */
763static long restore_tm_user_regs(struct pt_regs *regs,
764 struct mcontext __user *sr,
765 struct mcontext __user *tm_sr)
766{
767 long err;
768 unsigned long msr, msr_hi;
769#ifdef CONFIG_VSX
770 int i;
771#endif
772
773 /*
774 * restore general registers but not including MSR or SOFTE. Also
775 * take care of keeping r2 (TLS) intact if not a signal.
776 * See comment in signal_64.c:restore_tm_sigcontexts();
777 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
778 * were set by the signal delivery.
779 */
780 err = restore_general_regs(regs, tm_sr);
781 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
782
783 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
784
785 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
786 if (err)
787 return 1;
788
789 /* Restore the previous little-endian mode */
790 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
791
792#ifdef CONFIG_ALTIVEC
793 regs->msr &= ~MSR_VEC;
794 if (msr & MSR_VEC) {
795 /* restore altivec registers from the stack */
796 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
797 sizeof(sr->mc_vregs)) ||
798 __copy_from_user(¤t->thread.transact_vr,
799 &tm_sr->mc_vregs,
800 sizeof(sr->mc_vregs)))
801 return 1;
802 } else if (current->thread.used_vr) {
803 memset(¤t->thread.vr_state, 0,
804 ELF_NVRREG * sizeof(vector128));
805 memset(¤t->thread.transact_vr, 0,
806 ELF_NVRREG * sizeof(vector128));
807 }
808
809 /* Always get VRSAVE back */
810 if (__get_user(current->thread.vrsave,
811 (u32 __user *)&sr->mc_vregs[32]) ||
812 __get_user(current->thread.transact_vrsave,
813 (u32 __user *)&tm_sr->mc_vregs[32]))
814 return 1;
815 if (cpu_has_feature(CPU_FTR_ALTIVEC))
816 mtspr(SPRN_VRSAVE, current->thread.vrsave);
817#endif /* CONFIG_ALTIVEC */
818
819 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
820
821 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
822 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs))
823 return 1;
824
825#ifdef CONFIG_VSX
826 regs->msr &= ~MSR_VSX;
827 if (msr & MSR_VSX) {
828 /*
829 * Restore altivec registers from the stack to a local
830 * buffer, then write this out to the thread_struct
831 */
832 if (copy_vsx_from_user(current, &sr->mc_vsregs) ||
833 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs))
834 return 1;
835 } else if (current->thread.used_vsr)
836 for (i = 0; i < 32 ; i++) {
837 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
838 current->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = 0;
839 }
840#endif /* CONFIG_VSX */
841
842#ifdef CONFIG_SPE
843 /* SPE regs are not checkpointed with TM, so this section is
844 * simply the same as in restore_user_regs().
845 */
846 regs->msr &= ~MSR_SPE;
847 if (msr & MSR_SPE) {
848 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
849 ELF_NEVRREG * sizeof(u32)))
850 return 1;
851 } else if (current->thread.used_spe)
852 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
853
854 /* Always get SPEFSCR back */
855 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
856 + ELF_NEVRREG))
857 return 1;
858#endif /* CONFIG_SPE */
859
860 /* Get the top half of the MSR from the user context */
861 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
862 return 1;
863 msr_hi <<= 32;
864 /* If TM bits are set to the reserved value, it's an invalid context */
865 if (MSR_TM_RESV(msr_hi))
866 return 1;
867 /* Pull in the MSR TM bits from the user context */
868 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
869 /* Now, recheckpoint. This loads up all of the checkpointed (older)
870 * registers, including FP and V[S]Rs. After recheckpointing, the
871 * transactional versions should be loaded.
872 */
873 tm_enable();
874 /* Make sure the transaction is marked as failed */
875 current->thread.tm_texasr |= TEXASR_FS;
876 /* This loads the checkpointed FP/VEC state, if used */
877 tm_recheckpoint(¤t->thread, msr);
878
879 /* This loads the speculative FP/VEC state, if used */
880 if (msr & MSR_FP) {
881 do_load_up_transact_fpu(¤t->thread);
882 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
883 }
884#ifdef CONFIG_ALTIVEC
885 if (msr & MSR_VEC) {
886 do_load_up_transact_altivec(¤t->thread);
887 regs->msr |= MSR_VEC;
888 }
889#endif
890
891 return 0;
892}
893#endif
894
895#ifdef CONFIG_PPC64
896int copy_siginfo_to_user32(struct compat_siginfo __user *d, const siginfo_t *s)
897{
898 int err;
899
900 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
901 return -EFAULT;
902
903 /* If you change siginfo_t structure, please be sure
904 * this code is fixed accordingly.
905 * It should never copy any pad contained in the structure
906 * to avoid security leaks, but must copy the generic
907 * 3 ints plus the relevant union member.
908 * This routine must convert siginfo from 64bit to 32bit as well
909 * at the same time.
910 */
911 err = __put_user(s->si_signo, &d->si_signo);
912 err |= __put_user(s->si_errno, &d->si_errno);
913 err |= __put_user((short)s->si_code, &d->si_code);
914 if (s->si_code < 0)
915 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
916 SI_PAD_SIZE32);
917 else switch(s->si_code >> 16) {
918 case __SI_CHLD >> 16:
919 err |= __put_user(s->si_pid, &d->si_pid);
920 err |= __put_user(s->si_uid, &d->si_uid);
921 err |= __put_user(s->si_utime, &d->si_utime);
922 err |= __put_user(s->si_stime, &d->si_stime);
923 err |= __put_user(s->si_status, &d->si_status);
924 break;
925 case __SI_FAULT >> 16:
926 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
927 &d->si_addr);
928 break;
929 case __SI_POLL >> 16:
930 err |= __put_user(s->si_band, &d->si_band);
931 err |= __put_user(s->si_fd, &d->si_fd);
932 break;
933 case __SI_TIMER >> 16:
934 err |= __put_user(s->si_tid, &d->si_tid);
935 err |= __put_user(s->si_overrun, &d->si_overrun);
936 err |= __put_user(s->si_int, &d->si_int);
937 break;
938 case __SI_SYS >> 16:
939 err |= __put_user(ptr_to_compat(s->si_call_addr), &d->si_call_addr);
940 err |= __put_user(s->si_syscall, &d->si_syscall);
941 err |= __put_user(s->si_arch, &d->si_arch);
942 break;
943 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
944 case __SI_MESGQ >> 16:
945 err |= __put_user(s->si_int, &d->si_int);
946 /* fallthrough */
947 case __SI_KILL >> 16:
948 default:
949 err |= __put_user(s->si_pid, &d->si_pid);
950 err |= __put_user(s->si_uid, &d->si_uid);
951 break;
952 }
953 return err;
954}
955
956#define copy_siginfo_to_user copy_siginfo_to_user32
957
958int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
959{
960 if (copy_from_user(to, from, 3*sizeof(int)) ||
961 copy_from_user(to->_sifields._pad,
962 from->_sifields._pad, SI_PAD_SIZE32))
963 return -EFAULT;
964
965 return 0;
966}
967#endif /* CONFIG_PPC64 */
968
969/*
970 * Set up a signal frame for a "real-time" signal handler
971 * (one which gets siginfo).
972 */
973int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
974 struct pt_regs *regs)
975{
976 struct rt_sigframe __user *rt_sf;
977 struct mcontext __user *frame;
978 struct mcontext __user *tm_frame = NULL;
979 void __user *addr;
980 unsigned long newsp = 0;
981 int sigret;
982 unsigned long tramp;
983
984 /* Set up Signal Frame */
985 /* Put a Real Time Context onto stack */
986 rt_sf = get_sigframe(ksig, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
987 addr = rt_sf;
988 if (unlikely(rt_sf == NULL))
989 goto badframe;
990
991 /* Put the siginfo & fill in most of the ucontext */
992 if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
993 || __put_user(0, &rt_sf->uc.uc_flags)
994 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
995 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
996 &rt_sf->uc.uc_regs)
997 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
998 goto badframe;
999
1000 /* Save user registers on the stack */
1001 frame = &rt_sf->uc.uc_mcontext;
1002 addr = frame;
1003 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
1004 sigret = 0;
1005 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp;
1006 } else {
1007 sigret = __NR_rt_sigreturn;
1008 tramp = (unsigned long) frame->tramp;
1009 }
1010
1011#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1012 tm_frame = &rt_sf->uc_transact.uc_mcontext;
1013 if (MSR_TM_ACTIVE(regs->msr)) {
1014 if (__put_user((unsigned long)&rt_sf->uc_transact,
1015 &rt_sf->uc.uc_link) ||
1016 __put_user((unsigned long)tm_frame,
1017 &rt_sf->uc_transact.uc_regs))
1018 goto badframe;
1019 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1020 goto badframe;
1021 }
1022 else
1023#endif
1024 {
1025 if (__put_user(0, &rt_sf->uc.uc_link))
1026 goto badframe;
1027 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1028 goto badframe;
1029 }
1030 regs->link = tramp;
1031
1032 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1033
1034 /* create a stack frame for the caller of the handler */
1035 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1036 addr = (void __user *)regs->gpr[1];
1037 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1038 goto badframe;
1039
1040 /* Fill registers for signal handler */
1041 regs->gpr[1] = newsp;
1042 regs->gpr[3] = ksig->sig;
1043 regs->gpr[4] = (unsigned long) &rt_sf->info;
1044 regs->gpr[5] = (unsigned long) &rt_sf->uc;
1045 regs->gpr[6] = (unsigned long) rt_sf;
1046 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
1047 /* enter the signal handler in native-endian mode */
1048 regs->msr &= ~MSR_LE;
1049 regs->msr |= (MSR_KERNEL & MSR_LE);
1050 return 0;
1051
1052badframe:
1053 if (show_unhandled_signals)
1054 printk_ratelimited(KERN_INFO
1055 "%s[%d]: bad frame in handle_rt_signal32: "
1056 "%p nip %08lx lr %08lx\n",
1057 current->comm, current->pid,
1058 addr, regs->nip, regs->link);
1059
1060 return 1;
1061}
1062
1063static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1064{
1065 sigset_t set;
1066 struct mcontext __user *mcp;
1067
1068 if (get_sigset_t(&set, &ucp->uc_sigmask))
1069 return -EFAULT;
1070#ifdef CONFIG_PPC64
1071 {
1072 u32 cmcp;
1073
1074 if (__get_user(cmcp, &ucp->uc_regs))
1075 return -EFAULT;
1076 mcp = (struct mcontext __user *)(u64)cmcp;
1077 /* no need to check access_ok(mcp), since mcp < 4GB */
1078 }
1079#else
1080 if (__get_user(mcp, &ucp->uc_regs))
1081 return -EFAULT;
1082 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1083 return -EFAULT;
1084#endif
1085 set_current_blocked(&set);
1086 if (restore_user_regs(regs, mcp, sig))
1087 return -EFAULT;
1088
1089 return 0;
1090}
1091
1092#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1093static int do_setcontext_tm(struct ucontext __user *ucp,
1094 struct ucontext __user *tm_ucp,
1095 struct pt_regs *regs)
1096{
1097 sigset_t set;
1098 struct mcontext __user *mcp;
1099 struct mcontext __user *tm_mcp;
1100 u32 cmcp;
1101 u32 tm_cmcp;
1102
1103 if (get_sigset_t(&set, &ucp->uc_sigmask))
1104 return -EFAULT;
1105
1106 if (__get_user(cmcp, &ucp->uc_regs) ||
1107 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1108 return -EFAULT;
1109 mcp = (struct mcontext __user *)(u64)cmcp;
1110 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1111 /* no need to check access_ok(mcp), since mcp < 4GB */
1112
1113 set_current_blocked(&set);
1114 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1115 return -EFAULT;
1116
1117 return 0;
1118}
1119#endif
1120
1121long sys_swapcontext(struct ucontext __user *old_ctx,
1122 struct ucontext __user *new_ctx,
1123 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1124{
1125 unsigned char tmp;
1126 int ctx_has_vsx_region = 0;
1127
1128#ifdef CONFIG_PPC64
1129 unsigned long new_msr = 0;
1130
1131 if (new_ctx) {
1132 struct mcontext __user *mcp;
1133 u32 cmcp;
1134
1135 /*
1136 * Get pointer to the real mcontext. No need for
1137 * access_ok since we are dealing with compat
1138 * pointers.
1139 */
1140 if (__get_user(cmcp, &new_ctx->uc_regs))
1141 return -EFAULT;
1142 mcp = (struct mcontext __user *)(u64)cmcp;
1143 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1144 return -EFAULT;
1145 }
1146 /*
1147 * Check that the context is not smaller than the original
1148 * size (with VMX but without VSX)
1149 */
1150 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1151 return -EINVAL;
1152 /*
1153 * If the new context state sets the MSR VSX bits but
1154 * it doesn't provide VSX state.
1155 */
1156 if ((ctx_size < sizeof(struct ucontext)) &&
1157 (new_msr & MSR_VSX))
1158 return -EINVAL;
1159 /* Does the context have enough room to store VSX data? */
1160 if (ctx_size >= sizeof(struct ucontext))
1161 ctx_has_vsx_region = 1;
1162#else
1163 /* Context size is for future use. Right now, we only make sure
1164 * we are passed something we understand
1165 */
1166 if (ctx_size < sizeof(struct ucontext))
1167 return -EINVAL;
1168#endif
1169 if (old_ctx != NULL) {
1170 struct mcontext __user *mctx;
1171
1172 /*
1173 * old_ctx might not be 16-byte aligned, in which
1174 * case old_ctx->uc_mcontext won't be either.
1175 * Because we have the old_ctx->uc_pad2 field
1176 * before old_ctx->uc_mcontext, we need to round down
1177 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1178 */
1179 mctx = (struct mcontext __user *)
1180 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1181 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1182 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1183 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1184 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1185 return -EFAULT;
1186 }
1187 if (new_ctx == NULL)
1188 return 0;
1189 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1190 || __get_user(tmp, (u8 __user *) new_ctx)
1191 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1192 return -EFAULT;
1193
1194 /*
1195 * If we get a fault copying the context into the kernel's
1196 * image of the user's registers, we can't just return -EFAULT
1197 * because the user's registers will be corrupted. For instance
1198 * the NIP value may have been updated but not some of the
1199 * other registers. Given that we have done the access_ok
1200 * and successfully read the first and last bytes of the region
1201 * above, this should only happen in an out-of-memory situation
1202 * or if another thread unmaps the region containing the context.
1203 * We kill the task with a SIGSEGV in this situation.
1204 */
1205 if (do_setcontext(new_ctx, regs, 0))
1206 do_exit(SIGSEGV);
1207
1208 set_thread_flag(TIF_RESTOREALL);
1209 return 0;
1210}
1211
1212long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1213 struct pt_regs *regs)
1214{
1215 struct rt_sigframe __user *rt_sf;
1216#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1217 struct ucontext __user *uc_transact;
1218 unsigned long msr_hi;
1219 unsigned long tmp;
1220 int tm_restore = 0;
1221#endif
1222 /* Always make any pending restarted system calls return -EINTR */
1223 current->restart_block.fn = do_no_restart_syscall;
1224
1225 rt_sf = (struct rt_sigframe __user *)
1226 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1227 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1228 goto bad;
1229#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1230 if (__get_user(tmp, &rt_sf->uc.uc_link))
1231 goto bad;
1232 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1233 if (uc_transact) {
1234 u32 cmcp;
1235 struct mcontext __user *mcp;
1236
1237 if (__get_user(cmcp, &uc_transact->uc_regs))
1238 return -EFAULT;
1239 mcp = (struct mcontext __user *)(u64)cmcp;
1240 /* The top 32 bits of the MSR are stashed in the transactional
1241 * ucontext. */
1242 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1243 goto bad;
1244
1245 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1246 /* We only recheckpoint on return if we're
1247 * transaction.
1248 */
1249 tm_restore = 1;
1250 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1251 goto bad;
1252 }
1253 }
1254 if (!tm_restore)
1255 /* Fall through, for non-TM restore */
1256#endif
1257 if (do_setcontext(&rt_sf->uc, regs, 1))
1258 goto bad;
1259
1260 /*
1261 * It's not clear whether or why it is desirable to save the
1262 * sigaltstack setting on signal delivery and restore it on
1263 * signal return. But other architectures do this and we have
1264 * always done it up until now so it is probably better not to
1265 * change it. -- paulus
1266 */
1267#ifdef CONFIG_PPC64
1268 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1269 goto bad;
1270#else
1271 if (restore_altstack(&rt_sf->uc.uc_stack))
1272 goto bad;
1273#endif
1274 set_thread_flag(TIF_RESTOREALL);
1275 return 0;
1276
1277 bad:
1278 if (show_unhandled_signals)
1279 printk_ratelimited(KERN_INFO
1280 "%s[%d]: bad frame in sys_rt_sigreturn: "
1281 "%p nip %08lx lr %08lx\n",
1282 current->comm, current->pid,
1283 rt_sf, regs->nip, regs->link);
1284
1285 force_sig(SIGSEGV, current);
1286 return 0;
1287}
1288
1289#ifdef CONFIG_PPC32
1290int sys_debug_setcontext(struct ucontext __user *ctx,
1291 int ndbg, struct sig_dbg_op __user *dbg,
1292 int r6, int r7, int r8,
1293 struct pt_regs *regs)
1294{
1295 struct sig_dbg_op op;
1296 int i;
1297 unsigned char tmp;
1298 unsigned long new_msr = regs->msr;
1299#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1300 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1301#endif
1302
1303 for (i=0; i<ndbg; i++) {
1304 if (copy_from_user(&op, dbg + i, sizeof(op)))
1305 return -EFAULT;
1306 switch (op.dbg_type) {
1307 case SIG_DBG_SINGLE_STEPPING:
1308#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1309 if (op.dbg_value) {
1310 new_msr |= MSR_DE;
1311 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1312 } else {
1313 new_dbcr0 &= ~DBCR0_IC;
1314 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1315 current->thread.debug.dbcr1)) {
1316 new_msr &= ~MSR_DE;
1317 new_dbcr0 &= ~DBCR0_IDM;
1318 }
1319 }
1320#else
1321 if (op.dbg_value)
1322 new_msr |= MSR_SE;
1323 else
1324 new_msr &= ~MSR_SE;
1325#endif
1326 break;
1327 case SIG_DBG_BRANCH_TRACING:
1328#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1329 return -EINVAL;
1330#else
1331 if (op.dbg_value)
1332 new_msr |= MSR_BE;
1333 else
1334 new_msr &= ~MSR_BE;
1335#endif
1336 break;
1337
1338 default:
1339 return -EINVAL;
1340 }
1341 }
1342
1343 /* We wait until here to actually install the values in the
1344 registers so if we fail in the above loop, it will not
1345 affect the contents of these registers. After this point,
1346 failure is a problem, anyway, and it's very unlikely unless
1347 the user is really doing something wrong. */
1348 regs->msr = new_msr;
1349#ifdef CONFIG_PPC_ADV_DEBUG_REGS
1350 current->thread.debug.dbcr0 = new_dbcr0;
1351#endif
1352
1353 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1354 || __get_user(tmp, (u8 __user *) ctx)
1355 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1356 return -EFAULT;
1357
1358 /*
1359 * If we get a fault copying the context into the kernel's
1360 * image of the user's registers, we can't just return -EFAULT
1361 * because the user's registers will be corrupted. For instance
1362 * the NIP value may have been updated but not some of the
1363 * other registers. Given that we have done the access_ok
1364 * and successfully read the first and last bytes of the region
1365 * above, this should only happen in an out-of-memory situation
1366 * or if another thread unmaps the region containing the context.
1367 * We kill the task with a SIGSEGV in this situation.
1368 */
1369 if (do_setcontext(ctx, regs, 1)) {
1370 if (show_unhandled_signals)
1371 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1372 "sys_debug_setcontext: %p nip %08lx "
1373 "lr %08lx\n",
1374 current->comm, current->pid,
1375 ctx, regs->nip, regs->link);
1376
1377 force_sig(SIGSEGV, current);
1378 goto out;
1379 }
1380
1381 /*
1382 * It's not clear whether or why it is desirable to save the
1383 * sigaltstack setting on signal delivery and restore it on
1384 * signal return. But other architectures do this and we have
1385 * always done it up until now so it is probably better not to
1386 * change it. -- paulus
1387 */
1388 restore_altstack(&ctx->uc_stack);
1389
1390 set_thread_flag(TIF_RESTOREALL);
1391 out:
1392 return 0;
1393}
1394#endif
1395
1396/*
1397 * OK, we're invoking a handler
1398 */
1399int handle_signal32(struct ksignal *ksig, sigset_t *oldset, struct pt_regs *regs)
1400{
1401 struct sigcontext __user *sc;
1402 struct sigframe __user *frame;
1403 struct mcontext __user *tm_mctx = NULL;
1404 unsigned long newsp = 0;
1405 int sigret;
1406 unsigned long tramp;
1407
1408 /* Set up Signal Frame */
1409 frame = get_sigframe(ksig, get_tm_stackpointer(regs), sizeof(*frame), 1);
1410 if (unlikely(frame == NULL))
1411 goto badframe;
1412 sc = (struct sigcontext __user *) &frame->sctx;
1413
1414#if _NSIG != 64
1415#error "Please adjust handle_signal()"
1416#endif
1417 if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1418 || __put_user(oldset->sig[0], &sc->oldmask)
1419#ifdef CONFIG_PPC64
1420 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1421#else
1422 || __put_user(oldset->sig[1], &sc->_unused[3])
1423#endif
1424 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1425 || __put_user(ksig->sig, &sc->signal))
1426 goto badframe;
1427
1428 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1429 sigret = 0;
1430 tramp = current->mm->context.vdso_base + vdso32_sigtramp;
1431 } else {
1432 sigret = __NR_sigreturn;
1433 tramp = (unsigned long) frame->mctx.tramp;
1434 }
1435
1436#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1437 tm_mctx = &frame->mctx_transact;
1438 if (MSR_TM_ACTIVE(regs->msr)) {
1439 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1440 sigret))
1441 goto badframe;
1442 }
1443 else
1444#endif
1445 {
1446 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1447 goto badframe;
1448 }
1449
1450 regs->link = tramp;
1451
1452 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1453
1454 /* create a stack frame for the caller of the handler */
1455 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1456 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1457 goto badframe;
1458
1459 regs->gpr[1] = newsp;
1460 regs->gpr[3] = ksig->sig;
1461 regs->gpr[4] = (unsigned long) sc;
1462 regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1463 /* enter the signal handler in big-endian mode */
1464 regs->msr &= ~MSR_LE;
1465 return 0;
1466
1467badframe:
1468 if (show_unhandled_signals)
1469 printk_ratelimited(KERN_INFO
1470 "%s[%d]: bad frame in handle_signal32: "
1471 "%p nip %08lx lr %08lx\n",
1472 current->comm, current->pid,
1473 frame, regs->nip, regs->link);
1474
1475 return 1;
1476}
1477
1478/*
1479 * Do a signal return; undo the signal stack.
1480 */
1481long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1482 struct pt_regs *regs)
1483{
1484 struct sigframe __user *sf;
1485 struct sigcontext __user *sc;
1486 struct sigcontext sigctx;
1487 struct mcontext __user *sr;
1488 void __user *addr;
1489 sigset_t set;
1490#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1491 struct mcontext __user *mcp, *tm_mcp;
1492 unsigned long msr_hi;
1493#endif
1494
1495 /* Always make any pending restarted system calls return -EINTR */
1496 current->restart_block.fn = do_no_restart_syscall;
1497
1498 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1499 sc = &sf->sctx;
1500 addr = sc;
1501 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1502 goto badframe;
1503
1504#ifdef CONFIG_PPC64
1505 /*
1506 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1507 * unused part of the signal stackframe
1508 */
1509 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1510#else
1511 set.sig[0] = sigctx.oldmask;
1512 set.sig[1] = sigctx._unused[3];
1513#endif
1514 set_current_blocked(&set);
1515
1516#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1517 mcp = (struct mcontext __user *)&sf->mctx;
1518 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1519 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1520 goto badframe;
1521 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1522 if (!cpu_has_feature(CPU_FTR_TM))
1523 goto badframe;
1524 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1525 goto badframe;
1526 } else
1527#endif
1528 {
1529 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1530 addr = sr;
1531 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1532 || restore_user_regs(regs, sr, 1))
1533 goto badframe;
1534 }
1535
1536 set_thread_flag(TIF_RESTOREALL);
1537 return 0;
1538
1539badframe:
1540 if (show_unhandled_signals)
1541 printk_ratelimited(KERN_INFO
1542 "%s[%d]: bad frame in sys_sigreturn: "
1543 "%p nip %08lx lr %08lx\n",
1544 current->comm, current->pid,
1545 addr, regs->nip, regs->link);
1546
1547 force_sig(SIGSEGV, current);
1548 return 0;
1549}