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