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