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