xref: /linux/arch/powerpc/kernel/signal_64.c (revision 96d7a4e06fab9fbc4f67c563af65b073902f3e61)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  PowerPC version
4  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
5  *
6  *  Derived from "arch/i386/kernel/signal.c"
7  *    Copyright (C) 1991, 1992 Linus Torvalds
8  *    1997-11-28  Modified for POSIX.1b signals by Richard Henderson
9  */
10 
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/kernel.h>
15 #include <linux/signal.h>
16 #include <linux/errno.h>
17 #include <linux/wait.h>
18 #include <linux/unistd.h>
19 #include <linux/stddef.h>
20 #include <linux/elf.h>
21 #include <linux/ptrace.h>
22 #include <linux/ratelimit.h>
23 #include <linux/syscalls.h>
24 #include <linux/pagemap.h>
25 
26 #include <asm/sigcontext.h>
27 #include <asm/ucontext.h>
28 #include <linux/uaccess.h>
29 #include <asm/unistd.h>
30 #include <asm/cacheflush.h>
31 #include <asm/syscalls.h>
32 #include <asm/vdso.h>
33 #include <asm/switch_to.h>
34 #include <asm/tm.h>
35 #include <asm/asm-prototypes.h>
36 
37 #include "signal.h"
38 
39 
40 #define GP_REGS_SIZE	min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
41 #define FP_REGS_SIZE	sizeof(elf_fpregset_t)
42 
43 #define TRAMP_TRACEBACK	4
44 #define TRAMP_SIZE	7
45 
46 /*
47  * When we have signals to deliver, we set up on the user stack,
48  * going down from the original stack pointer:
49  *	1) a rt_sigframe struct which contains the ucontext
50  *	2) a gap of __SIGNAL_FRAMESIZE bytes which acts as a dummy caller
51  *	   frame for the signal handler.
52  */
53 
54 struct rt_sigframe {
55 	/* sys_rt_sigreturn requires the ucontext be the first field */
56 	struct ucontext uc;
57 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
58 	struct ucontext uc_transact;
59 #endif
60 	unsigned long _unused[2];
61 	unsigned int tramp[TRAMP_SIZE];
62 	struct siginfo __user *pinfo;
63 	void __user *puc;
64 	struct siginfo info;
65 	/* New 64 bit little-endian ABI allows redzone of 512 bytes below sp */
66 	char abigap[USER_REDZONE_SIZE];
67 } __attribute__ ((aligned (16)));
68 
69 /*
70  * This computes a quad word aligned pointer inside the vmx_reserve array
71  * element. For historical reasons sigcontext might not be quad word aligned,
72  * but the location we write the VMX regs to must be. See the comment in
73  * sigcontext for more detail.
74  */
75 #ifdef CONFIG_ALTIVEC
76 static elf_vrreg_t __user *sigcontext_vmx_regs(struct sigcontext __user *sc)
77 {
78 	return (elf_vrreg_t __user *) (((unsigned long)sc->vmx_reserve + 15) & ~0xful);
79 }
80 #endif
81 
82 static void prepare_setup_sigcontext(struct task_struct *tsk)
83 {
84 #ifdef CONFIG_ALTIVEC
85 	/* save altivec registers */
86 	if (tsk->thread.used_vr)
87 		flush_altivec_to_thread(tsk);
88 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
89 		tsk->thread.vrsave = mfspr(SPRN_VRSAVE);
90 #endif /* CONFIG_ALTIVEC */
91 
92 	flush_fp_to_thread(tsk);
93 
94 #ifdef CONFIG_VSX
95 	if (tsk->thread.used_vsr)
96 		flush_vsx_to_thread(tsk);
97 #endif /* CONFIG_VSX */
98 }
99 
100 /*
101  * Set up the sigcontext for the signal frame.
102  */
103 
104 #define unsafe_setup_sigcontext(sc, tsk, signr, set, handler, ctx_has_vsx_region, label)\
105 do {											\
106 	if (__unsafe_setup_sigcontext(sc, tsk, signr, set, handler, ctx_has_vsx_region))\
107 		goto label;								\
108 } while (0)
109 static long notrace __unsafe_setup_sigcontext(struct sigcontext __user *sc,
110 					struct task_struct *tsk, int signr, sigset_t *set,
111 					unsigned long handler, int ctx_has_vsx_region)
112 {
113 	/* When CONFIG_ALTIVEC is set, we _always_ setup v_regs even if the
114 	 * process never used altivec yet (MSR_VEC is zero in pt_regs of
115 	 * the context). This is very important because we must ensure we
116 	 * don't lose the VRSAVE content that may have been set prior to
117 	 * the process doing its first vector operation
118 	 * Userland shall check AT_HWCAP to know whether it can rely on the
119 	 * v_regs pointer or not
120 	 */
121 #ifdef CONFIG_ALTIVEC
122 	elf_vrreg_t __user *v_regs = sigcontext_vmx_regs(sc);
123 #endif
124 	struct pt_regs *regs = tsk->thread.regs;
125 	unsigned long msr = regs->msr;
126 	/* Force usr to alway see softe as 1 (interrupts enabled) */
127 	unsigned long softe = 0x1;
128 
129 	BUG_ON(tsk != current);
130 
131 #ifdef CONFIG_ALTIVEC
132 	unsafe_put_user(v_regs, &sc->v_regs, efault_out);
133 
134 	/* save altivec registers */
135 	if (tsk->thread.used_vr) {
136 		/* Copy 33 vec registers (vr0..31 and vscr) to the stack */
137 		unsafe_copy_to_user(v_regs, &tsk->thread.vr_state,
138 				    33 * sizeof(vector128), efault_out);
139 		/* set MSR_VEC in the MSR value in the frame to indicate that sc->v_reg)
140 		 * contains valid data.
141 		 */
142 		msr |= MSR_VEC;
143 	}
144 	/* We always copy to/from vrsave, it's 0 if we don't have or don't
145 	 * use altivec.
146 	 */
147 	unsafe_put_user(tsk->thread.vrsave, (u32 __user *)&v_regs[33], efault_out);
148 #else /* CONFIG_ALTIVEC */
149 	unsafe_put_user(0, &sc->v_regs, efault_out);
150 #endif /* CONFIG_ALTIVEC */
151 	/* copy fpr regs and fpscr */
152 	unsafe_copy_fpr_to_user(&sc->fp_regs, tsk, efault_out);
153 
154 	/*
155 	 * Clear the MSR VSX bit to indicate there is no valid state attached
156 	 * to this context, except in the specific case below where we set it.
157 	 */
158 	msr &= ~MSR_VSX;
159 #ifdef CONFIG_VSX
160 	/*
161 	 * Copy VSX low doubleword to local buffer for formatting,
162 	 * then out to userspace.  Update v_regs to point after the
163 	 * VMX data.
164 	 */
165 	if (tsk->thread.used_vsr && ctx_has_vsx_region) {
166 		v_regs += ELF_NVRREG;
167 		unsafe_copy_vsx_to_user(v_regs, tsk, efault_out);
168 		/* set MSR_VSX in the MSR value in the frame to
169 		 * indicate that sc->vs_reg) contains valid data.
170 		 */
171 		msr |= MSR_VSX;
172 	}
173 #endif /* CONFIG_VSX */
174 	unsafe_put_user(&sc->gp_regs, &sc->regs, efault_out);
175 	WARN_ON(!FULL_REGS(regs));
176 	unsafe_copy_to_user(&sc->gp_regs, regs, GP_REGS_SIZE, efault_out);
177 	unsafe_put_user(msr, &sc->gp_regs[PT_MSR], efault_out);
178 	unsafe_put_user(softe, &sc->gp_regs[PT_SOFTE], efault_out);
179 	unsafe_put_user(signr, &sc->signal, efault_out);
180 	unsafe_put_user(handler, &sc->handler, efault_out);
181 	if (set != NULL)
182 		unsafe_put_user(set->sig[0], &sc->oldmask, efault_out);
183 
184 	return 0;
185 
186 efault_out:
187 	return -EFAULT;
188 }
189 
190 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
191 /*
192  * As above, but Transactional Memory is in use, so deliver sigcontexts
193  * containing checkpointed and transactional register states.
194  *
195  * To do this, we treclaim (done before entering here) to gather both sets of
196  * registers and set up the 'normal' sigcontext registers with rolled-back
197  * register values such that a simple signal handler sees a correct
198  * checkpointed register state.  If interested, a TM-aware sighandler can
199  * examine the transactional registers in the 2nd sigcontext to determine the
200  * real origin of the signal.
201  */
202 static long setup_tm_sigcontexts(struct sigcontext __user *sc,
203 				 struct sigcontext __user *tm_sc,
204 				 struct task_struct *tsk,
205 				 int signr, sigset_t *set, unsigned long handler,
206 				 unsigned long msr)
207 {
208 	/* When CONFIG_ALTIVEC is set, we _always_ setup v_regs even if the
209 	 * process never used altivec yet (MSR_VEC is zero in pt_regs of
210 	 * the context). This is very important because we must ensure we
211 	 * don't lose the VRSAVE content that may have been set prior to
212 	 * the process doing its first vector operation
213 	 * Userland shall check AT_HWCAP to know wether it can rely on the
214 	 * v_regs pointer or not.
215 	 */
216 #ifdef CONFIG_ALTIVEC
217 	elf_vrreg_t __user *v_regs = sigcontext_vmx_regs(sc);
218 	elf_vrreg_t __user *tm_v_regs = sigcontext_vmx_regs(tm_sc);
219 #endif
220 	struct pt_regs *regs = tsk->thread.regs;
221 	long err = 0;
222 
223 	BUG_ON(tsk != current);
224 
225 	BUG_ON(!MSR_TM_ACTIVE(msr));
226 
227 	WARN_ON(tm_suspend_disabled);
228 
229 	/* Restore checkpointed FP, VEC, and VSX bits from ckpt_regs as
230 	 * it contains the correct FP, VEC, VSX state after we treclaimed
231 	 * the transaction and giveup_all() was called on reclaiming.
232 	 */
233 	msr |= tsk->thread.ckpt_regs.msr & (MSR_FP | MSR_VEC | MSR_VSX);
234 
235 #ifdef CONFIG_ALTIVEC
236 	err |= __put_user(v_regs, &sc->v_regs);
237 	err |= __put_user(tm_v_regs, &tm_sc->v_regs);
238 
239 	/* save altivec registers */
240 	if (tsk->thread.used_vr) {
241 		/* Copy 33 vec registers (vr0..31 and vscr) to the stack */
242 		err |= __copy_to_user(v_regs, &tsk->thread.ckvr_state,
243 				      33 * sizeof(vector128));
244 		/* If VEC was enabled there are transactional VRs valid too,
245 		 * else they're a copy of the checkpointed VRs.
246 		 */
247 		if (msr & MSR_VEC)
248 			err |= __copy_to_user(tm_v_regs,
249 					      &tsk->thread.vr_state,
250 					      33 * sizeof(vector128));
251 		else
252 			err |= __copy_to_user(tm_v_regs,
253 					      &tsk->thread.ckvr_state,
254 					      33 * sizeof(vector128));
255 
256 		/* set MSR_VEC in the MSR value in the frame to indicate
257 		 * that sc->v_reg contains valid data.
258 		 */
259 		msr |= MSR_VEC;
260 	}
261 	/* We always copy to/from vrsave, it's 0 if we don't have or don't
262 	 * use altivec.
263 	 */
264 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
265 		tsk->thread.ckvrsave = mfspr(SPRN_VRSAVE);
266 	err |= __put_user(tsk->thread.ckvrsave, (u32 __user *)&v_regs[33]);
267 	if (msr & MSR_VEC)
268 		err |= __put_user(tsk->thread.vrsave,
269 				  (u32 __user *)&tm_v_regs[33]);
270 	else
271 		err |= __put_user(tsk->thread.ckvrsave,
272 				  (u32 __user *)&tm_v_regs[33]);
273 
274 #else /* CONFIG_ALTIVEC */
275 	err |= __put_user(0, &sc->v_regs);
276 	err |= __put_user(0, &tm_sc->v_regs);
277 #endif /* CONFIG_ALTIVEC */
278 
279 	/* copy fpr regs and fpscr */
280 	err |= copy_ckfpr_to_user(&sc->fp_regs, tsk);
281 	if (msr & MSR_FP)
282 		err |= copy_fpr_to_user(&tm_sc->fp_regs, tsk);
283 	else
284 		err |= copy_ckfpr_to_user(&tm_sc->fp_regs, tsk);
285 
286 #ifdef CONFIG_VSX
287 	/*
288 	 * Copy VSX low doubleword to local buffer for formatting,
289 	 * then out to userspace.  Update v_regs to point after the
290 	 * VMX data.
291 	 */
292 	if (tsk->thread.used_vsr) {
293 		v_regs += ELF_NVRREG;
294 		tm_v_regs += ELF_NVRREG;
295 
296 		err |= copy_ckvsx_to_user(v_regs, tsk);
297 
298 		if (msr & MSR_VSX)
299 			err |= copy_vsx_to_user(tm_v_regs, tsk);
300 		else
301 			err |= copy_ckvsx_to_user(tm_v_regs, tsk);
302 
303 		/* set MSR_VSX in the MSR value in the frame to
304 		 * indicate that sc->vs_reg) contains valid data.
305 		 */
306 		msr |= MSR_VSX;
307 	}
308 #endif /* CONFIG_VSX */
309 
310 	err |= __put_user(&sc->gp_regs, &sc->regs);
311 	err |= __put_user(&tm_sc->gp_regs, &tm_sc->regs);
312 	WARN_ON(!FULL_REGS(regs));
313 	err |= __copy_to_user(&tm_sc->gp_regs, regs, GP_REGS_SIZE);
314 	err |= __copy_to_user(&sc->gp_regs,
315 			      &tsk->thread.ckpt_regs, GP_REGS_SIZE);
316 	err |= __put_user(msr, &tm_sc->gp_regs[PT_MSR]);
317 	err |= __put_user(msr, &sc->gp_regs[PT_MSR]);
318 	err |= __put_user(signr, &sc->signal);
319 	err |= __put_user(handler, &sc->handler);
320 	if (set != NULL)
321 		err |=  __put_user(set->sig[0], &sc->oldmask);
322 
323 	return err;
324 }
325 #endif
326 
327 /*
328  * Restore the sigcontext from the signal frame.
329  */
330 #define unsafe_restore_sigcontext(tsk, set, sig, sc, label) do {	\
331 	if (__unsafe_restore_sigcontext(tsk, set, sig, sc))		\
332 		goto label;						\
333 } while (0)
334 static long notrace __unsafe_restore_sigcontext(struct task_struct *tsk, sigset_t *set,
335 						int sig, struct sigcontext __user *sc)
336 {
337 #ifdef CONFIG_ALTIVEC
338 	elf_vrreg_t __user *v_regs;
339 #endif
340 	unsigned long save_r13 = 0;
341 	unsigned long msr;
342 	struct pt_regs *regs = tsk->thread.regs;
343 #ifdef CONFIG_VSX
344 	int i;
345 #endif
346 
347 	BUG_ON(tsk != current);
348 
349 	/* If this is not a signal return, we preserve the TLS in r13 */
350 	if (!sig)
351 		save_r13 = regs->gpr[13];
352 
353 	/* copy the GPRs */
354 	unsafe_copy_from_user(regs->gpr, sc->gp_regs, sizeof(regs->gpr), efault_out);
355 	unsafe_get_user(regs->nip, &sc->gp_regs[PT_NIP], efault_out);
356 	/* get MSR separately, transfer the LE bit if doing signal return */
357 	unsafe_get_user(msr, &sc->gp_regs[PT_MSR], efault_out);
358 	if (sig)
359 		regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
360 	unsafe_get_user(regs->orig_gpr3, &sc->gp_regs[PT_ORIG_R3], efault_out);
361 	unsafe_get_user(regs->ctr, &sc->gp_regs[PT_CTR], efault_out);
362 	unsafe_get_user(regs->link, &sc->gp_regs[PT_LNK], efault_out);
363 	unsafe_get_user(regs->xer, &sc->gp_regs[PT_XER], efault_out);
364 	unsafe_get_user(regs->ccr, &sc->gp_regs[PT_CCR], efault_out);
365 	/* Don't allow userspace to set SOFTE */
366 	set_trap_norestart(regs);
367 	unsafe_get_user(regs->dar, &sc->gp_regs[PT_DAR], efault_out);
368 	unsafe_get_user(regs->dsisr, &sc->gp_regs[PT_DSISR], efault_out);
369 	unsafe_get_user(regs->result, &sc->gp_regs[PT_RESULT], efault_out);
370 
371 	if (!sig)
372 		regs->gpr[13] = save_r13;
373 	if (set != NULL)
374 		unsafe_get_user(set->sig[0], &sc->oldmask, efault_out);
375 
376 	/*
377 	 * Force reload of FP/VEC.
378 	 * This has to be done before copying stuff into tsk->thread.fpr/vr
379 	 * for the reasons explained in the previous comment.
380 	 */
381 	regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC | MSR_VSX);
382 
383 #ifdef CONFIG_ALTIVEC
384 	unsafe_get_user(v_regs, &sc->v_regs, efault_out);
385 	if (v_regs && !access_ok(v_regs, 34 * sizeof(vector128)))
386 		return -EFAULT;
387 	/* Copy 33 vec registers (vr0..31 and vscr) from the stack */
388 	if (v_regs != NULL && (msr & MSR_VEC) != 0) {
389 		unsafe_copy_from_user(&tsk->thread.vr_state, v_regs,
390 				      33 * sizeof(vector128), efault_out);
391 		tsk->thread.used_vr = true;
392 	} else if (tsk->thread.used_vr) {
393 		memset(&tsk->thread.vr_state, 0, 33 * sizeof(vector128));
394 	}
395 	/* Always get VRSAVE back */
396 	if (v_regs != NULL)
397 		unsafe_get_user(tsk->thread.vrsave, (u32 __user *)&v_regs[33], efault_out);
398 	else
399 		tsk->thread.vrsave = 0;
400 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
401 		mtspr(SPRN_VRSAVE, tsk->thread.vrsave);
402 #endif /* CONFIG_ALTIVEC */
403 	/* restore floating point */
404 	unsafe_copy_fpr_from_user(tsk, &sc->fp_regs, efault_out);
405 #ifdef CONFIG_VSX
406 	/*
407 	 * Get additional VSX data. Update v_regs to point after the
408 	 * VMX data.  Copy VSX low doubleword from userspace to local
409 	 * buffer for formatting, then into the taskstruct.
410 	 */
411 	v_regs += ELF_NVRREG;
412 	if ((msr & MSR_VSX) != 0) {
413 		unsafe_copy_vsx_from_user(tsk, v_regs, efault_out);
414 		tsk->thread.used_vsr = true;
415 	} else {
416 		for (i = 0; i < 32 ; i++)
417 			tsk->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
418 	}
419 #endif
420 	return 0;
421 
422 efault_out:
423 	return -EFAULT;
424 }
425 
426 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
427 /*
428  * Restore the two sigcontexts from the frame of a transactional processes.
429  */
430 
431 static long restore_tm_sigcontexts(struct task_struct *tsk,
432 				   struct sigcontext __user *sc,
433 				   struct sigcontext __user *tm_sc)
434 {
435 #ifdef CONFIG_ALTIVEC
436 	elf_vrreg_t __user *v_regs, *tm_v_regs;
437 #endif
438 	unsigned long err = 0;
439 	unsigned long msr;
440 	struct pt_regs *regs = tsk->thread.regs;
441 #ifdef CONFIG_VSX
442 	int i;
443 #endif
444 
445 	BUG_ON(tsk != current);
446 
447 	if (tm_suspend_disabled)
448 		return -EINVAL;
449 
450 	/* copy the GPRs */
451 	err |= __copy_from_user(regs->gpr, tm_sc->gp_regs, sizeof(regs->gpr));
452 	err |= __copy_from_user(&tsk->thread.ckpt_regs, sc->gp_regs,
453 				sizeof(regs->gpr));
454 
455 	/*
456 	 * TFHAR is restored from the checkpointed 'wound-back' ucontext's NIP.
457 	 * TEXASR was set by the signal delivery reclaim, as was TFIAR.
458 	 * Users doing anything abhorrent like thread-switching w/ signals for
459 	 * TM-Suspended code will have to back TEXASR/TFIAR up themselves.
460 	 * For the case of getting a signal and simply returning from it,
461 	 * we don't need to re-copy them here.
462 	 */
463 	err |= __get_user(regs->nip, &tm_sc->gp_regs[PT_NIP]);
464 	err |= __get_user(tsk->thread.tm_tfhar, &sc->gp_regs[PT_NIP]);
465 
466 	/* get MSR separately, transfer the LE bit if doing signal return */
467 	err |= __get_user(msr, &sc->gp_regs[PT_MSR]);
468 	/* Don't allow reserved mode. */
469 	if (MSR_TM_RESV(msr))
470 		return -EINVAL;
471 
472 	/* pull in MSR LE from user context */
473 	regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
474 
475 	/* The following non-GPR non-FPR non-VR state is also checkpointed: */
476 	err |= __get_user(regs->ctr, &tm_sc->gp_regs[PT_CTR]);
477 	err |= __get_user(regs->link, &tm_sc->gp_regs[PT_LNK]);
478 	err |= __get_user(regs->xer, &tm_sc->gp_regs[PT_XER]);
479 	err |= __get_user(regs->ccr, &tm_sc->gp_regs[PT_CCR]);
480 	err |= __get_user(tsk->thread.ckpt_regs.ctr,
481 			  &sc->gp_regs[PT_CTR]);
482 	err |= __get_user(tsk->thread.ckpt_regs.link,
483 			  &sc->gp_regs[PT_LNK]);
484 	err |= __get_user(tsk->thread.ckpt_regs.xer,
485 			  &sc->gp_regs[PT_XER]);
486 	err |= __get_user(tsk->thread.ckpt_regs.ccr,
487 			  &sc->gp_regs[PT_CCR]);
488 	/* Don't allow userspace to set SOFTE */
489 	set_trap_norestart(regs);
490 	/* These regs are not checkpointed; they can go in 'regs'. */
491 	err |= __get_user(regs->dar, &sc->gp_regs[PT_DAR]);
492 	err |= __get_user(regs->dsisr, &sc->gp_regs[PT_DSISR]);
493 	err |= __get_user(regs->result, &sc->gp_regs[PT_RESULT]);
494 
495 	/*
496 	 * Force reload of FP/VEC.
497 	 * This has to be done before copying stuff into tsk->thread.fpr/vr
498 	 * for the reasons explained in the previous comment.
499 	 */
500 	regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC | MSR_VSX);
501 
502 #ifdef CONFIG_ALTIVEC
503 	err |= __get_user(v_regs, &sc->v_regs);
504 	err |= __get_user(tm_v_regs, &tm_sc->v_regs);
505 	if (err)
506 		return err;
507 	if (v_regs && !access_ok(v_regs, 34 * sizeof(vector128)))
508 		return -EFAULT;
509 	if (tm_v_regs && !access_ok(tm_v_regs, 34 * sizeof(vector128)))
510 		return -EFAULT;
511 	/* Copy 33 vec registers (vr0..31 and vscr) from the stack */
512 	if (v_regs != NULL && tm_v_regs != NULL && (msr & MSR_VEC) != 0) {
513 		err |= __copy_from_user(&tsk->thread.ckvr_state, v_regs,
514 					33 * sizeof(vector128));
515 		err |= __copy_from_user(&tsk->thread.vr_state, tm_v_regs,
516 					33 * sizeof(vector128));
517 		current->thread.used_vr = true;
518 	}
519 	else if (tsk->thread.used_vr) {
520 		memset(&tsk->thread.vr_state, 0, 33 * sizeof(vector128));
521 		memset(&tsk->thread.ckvr_state, 0, 33 * sizeof(vector128));
522 	}
523 	/* Always get VRSAVE back */
524 	if (v_regs != NULL && tm_v_regs != NULL) {
525 		err |= __get_user(tsk->thread.ckvrsave,
526 				  (u32 __user *)&v_regs[33]);
527 		err |= __get_user(tsk->thread.vrsave,
528 				  (u32 __user *)&tm_v_regs[33]);
529 	}
530 	else {
531 		tsk->thread.vrsave = 0;
532 		tsk->thread.ckvrsave = 0;
533 	}
534 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
535 		mtspr(SPRN_VRSAVE, tsk->thread.vrsave);
536 #endif /* CONFIG_ALTIVEC */
537 	/* restore floating point */
538 	err |= copy_fpr_from_user(tsk, &tm_sc->fp_regs);
539 	err |= copy_ckfpr_from_user(tsk, &sc->fp_regs);
540 #ifdef CONFIG_VSX
541 	/*
542 	 * Get additional VSX data. Update v_regs to point after the
543 	 * VMX data.  Copy VSX low doubleword from userspace to local
544 	 * buffer for formatting, then into the taskstruct.
545 	 */
546 	if (v_regs && ((msr & MSR_VSX) != 0)) {
547 		v_regs += ELF_NVRREG;
548 		tm_v_regs += ELF_NVRREG;
549 		err |= copy_vsx_from_user(tsk, tm_v_regs);
550 		err |= copy_ckvsx_from_user(tsk, v_regs);
551 		tsk->thread.used_vsr = true;
552 	} else {
553 		for (i = 0; i < 32 ; i++) {
554 			tsk->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
555 			tsk->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
556 		}
557 	}
558 #endif
559 	tm_enable();
560 	/* Make sure the transaction is marked as failed */
561 	tsk->thread.tm_texasr |= TEXASR_FS;
562 
563 	/*
564 	 * Disabling preemption, since it is unsafe to be preempted
565 	 * with MSR[TS] set without recheckpointing.
566 	 */
567 	preempt_disable();
568 
569 	/* pull in MSR TS bits from user context */
570 	regs->msr |= msr & MSR_TS_MASK;
571 
572 	/*
573 	 * Ensure that TM is enabled in regs->msr before we leave the signal
574 	 * handler. It could be the case that (a) user disabled the TM bit
575 	 * through the manipulation of the MSR bits in uc_mcontext or (b) the
576 	 * TM bit was disabled because a sufficient number of context switches
577 	 * happened whilst in the signal handler and load_tm overflowed,
578 	 * disabling the TM bit. In either case we can end up with an illegal
579 	 * TM state leading to a TM Bad Thing when we return to userspace.
580 	 *
581 	 * CAUTION:
582 	 * After regs->MSR[TS] being updated, make sure that get_user(),
583 	 * put_user() or similar functions are *not* called. These
584 	 * functions can generate page faults which will cause the process
585 	 * to be de-scheduled with MSR[TS] set but without calling
586 	 * tm_recheckpoint(). This can cause a bug.
587 	 */
588 	regs->msr |= MSR_TM;
589 
590 	/* This loads the checkpointed FP/VEC state, if used */
591 	tm_recheckpoint(&tsk->thread);
592 
593 	msr_check_and_set(msr & (MSR_FP | MSR_VEC));
594 	if (msr & MSR_FP) {
595 		load_fp_state(&tsk->thread.fp_state);
596 		regs->msr |= (MSR_FP | tsk->thread.fpexc_mode);
597 	}
598 	if (msr & MSR_VEC) {
599 		load_vr_state(&tsk->thread.vr_state);
600 		regs->msr |= MSR_VEC;
601 	}
602 
603 	preempt_enable();
604 
605 	return err;
606 }
607 #else /* !CONFIG_PPC_TRANSACTIONAL_MEM */
608 static long restore_tm_sigcontexts(struct task_struct *tsk, struct sigcontext __user *sc,
609 				   struct sigcontext __user *tm_sc)
610 {
611 	return -EINVAL;
612 }
613 #endif
614 
615 /*
616  * Setup the trampoline code on the stack
617  */
618 static long setup_trampoline(unsigned int syscall, unsigned int __user *tramp)
619 {
620 	int i;
621 	long err = 0;
622 
623 	/* bctrl # call the handler */
624 	err |= __put_user(PPC_INST_BCTRL, &tramp[0]);
625 	/* addi r1, r1, __SIGNAL_FRAMESIZE  # Pop the dummy stackframe */
626 	err |= __put_user(PPC_INST_ADDI | __PPC_RT(R1) | __PPC_RA(R1) |
627 			  (__SIGNAL_FRAMESIZE & 0xffff), &tramp[1]);
628 	/* li r0, __NR_[rt_]sigreturn| */
629 	err |= __put_user(PPC_INST_ADDI | (syscall & 0xffff), &tramp[2]);
630 	/* sc */
631 	err |= __put_user(PPC_INST_SC, &tramp[3]);
632 
633 	/* Minimal traceback info */
634 	for (i=TRAMP_TRACEBACK; i < TRAMP_SIZE ;i++)
635 		err |= __put_user(0, &tramp[i]);
636 
637 	if (!err)
638 		flush_icache_range((unsigned long) &tramp[0],
639 			   (unsigned long) &tramp[TRAMP_SIZE]);
640 
641 	return err;
642 }
643 
644 /*
645  * Userspace code may pass a ucontext which doesn't include VSX added
646  * at the end.  We need to check for this case.
647  */
648 #define UCONTEXTSIZEWITHOUTVSX \
649 		(sizeof(struct ucontext) - 32*sizeof(long))
650 
651 /*
652  * Handle {get,set,swap}_context operations
653  */
654 SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
655 		struct ucontext __user *, new_ctx, long, ctx_size)
656 {
657 	sigset_t set;
658 	unsigned long new_msr = 0;
659 	int ctx_has_vsx_region = 0;
660 
661 	if (new_ctx &&
662 	    get_user(new_msr, &new_ctx->uc_mcontext.gp_regs[PT_MSR]))
663 		return -EFAULT;
664 	/*
665 	 * Check that the context is not smaller than the original
666 	 * size (with VMX but without VSX)
667 	 */
668 	if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
669 		return -EINVAL;
670 	/*
671 	 * If the new context state sets the MSR VSX bits but
672 	 * it doesn't provide VSX state.
673 	 */
674 	if ((ctx_size < sizeof(struct ucontext)) &&
675 	    (new_msr & MSR_VSX))
676 		return -EINVAL;
677 	/* Does the context have enough room to store VSX data? */
678 	if (ctx_size >= sizeof(struct ucontext))
679 		ctx_has_vsx_region = 1;
680 
681 	if (old_ctx != NULL) {
682 		prepare_setup_sigcontext(current);
683 		if (!user_write_access_begin(old_ctx, ctx_size))
684 			return -EFAULT;
685 
686 		unsafe_setup_sigcontext(&old_ctx->uc_mcontext, current, 0, NULL,
687 					0, ctx_has_vsx_region, efault_out);
688 		unsafe_copy_to_user(&old_ctx->uc_sigmask, &current->blocked,
689 				    sizeof(sigset_t), efault_out);
690 
691 		user_write_access_end();
692 	}
693 	if (new_ctx == NULL)
694 		return 0;
695 	if (!access_ok(new_ctx, ctx_size) ||
696 	    fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
697 		return -EFAULT;
698 
699 	/*
700 	 * If we get a fault copying the context into the kernel's
701 	 * image of the user's registers, we can't just return -EFAULT
702 	 * because the user's registers will be corrupted.  For instance
703 	 * the NIP value may have been updated but not some of the
704 	 * other registers.  Given that we have done the access_ok
705 	 * and successfully read the first and last bytes of the region
706 	 * above, this should only happen in an out-of-memory situation
707 	 * or if another thread unmaps the region containing the context.
708 	 * We kill the task with a SIGSEGV in this situation.
709 	 */
710 
711 	if (__copy_from_user(&set, &new_ctx->uc_sigmask, sizeof(set)))
712 		do_exit(SIGSEGV);
713 	set_current_blocked(&set);
714 
715 	if (!user_read_access_begin(new_ctx, ctx_size))
716 		return -EFAULT;
717 	if (__unsafe_restore_sigcontext(current, NULL, 0, &new_ctx->uc_mcontext)) {
718 		user_read_access_end();
719 		do_exit(SIGSEGV);
720 	}
721 	user_read_access_end();
722 
723 	/* This returns like rt_sigreturn */
724 	set_thread_flag(TIF_RESTOREALL);
725 	return 0;
726 
727 efault_out:
728 	user_write_access_end();
729 	return -EFAULT;
730 }
731 
732 
733 /*
734  * Do a signal return; undo the signal stack.
735  */
736 
737 SYSCALL_DEFINE0(rt_sigreturn)
738 {
739 	struct pt_regs *regs = current_pt_regs();
740 	struct ucontext __user *uc = (struct ucontext __user *)regs->gpr[1];
741 	sigset_t set;
742 	unsigned long msr;
743 
744 	/* Always make any pending restarted system calls return -EINTR */
745 	current->restart_block.fn = do_no_restart_syscall;
746 
747 	if (!access_ok(uc, sizeof(*uc)))
748 		goto badframe;
749 
750 	if (__copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
751 		goto badframe;
752 	set_current_blocked(&set);
753 
754 	if (IS_ENABLED(CONFIG_PPC_TRANSACTIONAL_MEM)) {
755 		/*
756 		 * If there is a transactional state then throw it away.
757 		 * The purpose of a sigreturn is to destroy all traces of the
758 		 * signal frame, this includes any transactional state created
759 		 * within in. We only check for suspended as we can never be
760 		 * active in the kernel, we are active, there is nothing better to
761 		 * do than go ahead and Bad Thing later.
762 		 * The cause is not important as there will never be a
763 		 * recheckpoint so it's not user visible.
764 		 */
765 		if (MSR_TM_SUSPENDED(mfmsr()))
766 			tm_reclaim_current(0);
767 
768 		/*
769 		 * Disable MSR[TS] bit also, so, if there is an exception in the
770 		 * code below (as a page fault in copy_ckvsx_to_user()), it does
771 		 * not recheckpoint this task if there was a context switch inside
772 		 * the exception.
773 		 *
774 		 * A major page fault can indirectly call schedule(). A reschedule
775 		 * process in the middle of an exception can have a side effect
776 		 * (Changing the CPU MSR[TS] state), since schedule() is called
777 		 * with the CPU MSR[TS] disable and returns with MSR[TS]=Suspended
778 		 * (switch_to() calls tm_recheckpoint() for the 'new' process). In
779 		 * this case, the process continues to be the same in the CPU, but
780 		 * the CPU state just changed.
781 		 *
782 		 * This can cause a TM Bad Thing, since the MSR in the stack will
783 		 * have the MSR[TS]=0, and this is what will be used to RFID.
784 		 *
785 		 * Clearing MSR[TS] state here will avoid a recheckpoint if there
786 		 * is any process reschedule in kernel space. The MSR[TS] state
787 		 * does not need to be saved also, since it will be replaced with
788 		 * the MSR[TS] that came from user context later, at
789 		 * restore_tm_sigcontexts.
790 		 */
791 		regs->msr &= ~MSR_TS_MASK;
792 
793 		if (__get_user(msr, &uc->uc_mcontext.gp_regs[PT_MSR]))
794 			goto badframe;
795 	}
796 
797 	if (IS_ENABLED(CONFIG_PPC_TRANSACTIONAL_MEM) && MSR_TM_ACTIVE(msr)) {
798 		/* We recheckpoint on return. */
799 		struct ucontext __user *uc_transact;
800 
801 		/* Trying to start TM on non TM system */
802 		if (!cpu_has_feature(CPU_FTR_TM))
803 			goto badframe;
804 
805 		if (__get_user(uc_transact, &uc->uc_link))
806 			goto badframe;
807 		if (restore_tm_sigcontexts(current, &uc->uc_mcontext,
808 					   &uc_transact->uc_mcontext))
809 			goto badframe;
810 	} else {
811 		/*
812 		 * Fall through, for non-TM restore
813 		 *
814 		 * Unset MSR[TS] on the thread regs since MSR from user
815 		 * context does not have MSR active, and recheckpoint was
816 		 * not called since restore_tm_sigcontexts() was not called
817 		 * also.
818 		 *
819 		 * If not unsetting it, the code can RFID to userspace with
820 		 * MSR[TS] set, but without CPU in the proper state,
821 		 * causing a TM bad thing.
822 		 */
823 		current->thread.regs->msr &= ~MSR_TS_MASK;
824 		if (!user_read_access_begin(&uc->uc_mcontext, sizeof(uc->uc_mcontext)))
825 			return -EFAULT;
826 		if (__unsafe_restore_sigcontext(current, NULL, 1, &uc->uc_mcontext)) {
827 			user_read_access_end();
828 			goto badframe;
829 		}
830 		user_read_access_end();
831 	}
832 
833 	if (restore_altstack(&uc->uc_stack))
834 		goto badframe;
835 
836 	set_thread_flag(TIF_RESTOREALL);
837 	return 0;
838 
839 badframe:
840 	signal_fault(current, regs, "rt_sigreturn", uc);
841 
842 	force_sig(SIGSEGV);
843 	return 0;
844 }
845 
846 int handle_rt_signal64(struct ksignal *ksig, sigset_t *set,
847 		struct task_struct *tsk)
848 {
849 	struct rt_sigframe __user *frame;
850 	unsigned long newsp = 0;
851 	long err = 0;
852 	struct pt_regs *regs = tsk->thread.regs;
853 	/* Save the thread's msr before get_tm_stackpointer() changes it */
854 	unsigned long msr = regs->msr;
855 
856 	frame = get_sigframe(ksig, tsk, sizeof(*frame), 0);
857 
858 	/*
859 	 * This only applies when calling unsafe_setup_sigcontext() and must be
860 	 * called before opening the uaccess window.
861 	 */
862 	if (!MSR_TM_ACTIVE(msr))
863 		prepare_setup_sigcontext(tsk);
864 
865 	if (!user_write_access_begin(frame, sizeof(*frame)))
866 		goto badframe;
867 
868 	unsafe_put_user(&frame->info, &frame->pinfo, badframe_block);
869 	unsafe_put_user(&frame->uc, &frame->puc, badframe_block);
870 
871 	/* Create the ucontext.  */
872 	unsafe_put_user(0, &frame->uc.uc_flags, badframe_block);
873 	unsafe_save_altstack(&frame->uc.uc_stack, regs->gpr[1], badframe_block);
874 
875 	if (MSR_TM_ACTIVE(msr)) {
876 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
877 		/* The ucontext_t passed to userland points to the second
878 		 * ucontext_t (for transactional state) with its uc_link ptr.
879 		 */
880 		unsafe_put_user(&frame->uc_transact, &frame->uc.uc_link, badframe_block);
881 
882 		user_write_access_end();
883 
884 		err |= setup_tm_sigcontexts(&frame->uc.uc_mcontext,
885 					    &frame->uc_transact.uc_mcontext,
886 					    tsk, ksig->sig, NULL,
887 					    (unsigned long)ksig->ka.sa.sa_handler,
888 					    msr);
889 
890 		if (!user_write_access_begin(&frame->uc.uc_sigmask,
891 					     sizeof(frame->uc.uc_sigmask)))
892 			goto badframe;
893 
894 #endif
895 	} else {
896 		unsafe_put_user(0, &frame->uc.uc_link, badframe_block);
897 		unsafe_setup_sigcontext(&frame->uc.uc_mcontext, tsk, ksig->sig,
898 					NULL, (unsigned long)ksig->ka.sa.sa_handler,
899 					1, badframe_block);
900 	}
901 
902 	unsafe_copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set), badframe_block);
903 	user_write_access_end();
904 
905 	/* Make sure signal handler doesn't get spurious FP exceptions */
906 	tsk->thread.fp_state.fpscr = 0;
907 
908 	/* Set up to return from userspace. */
909 	if (tsk->mm->context.vdso) {
910 		regs->nip = VDSO64_SYMBOL(tsk->mm->context.vdso, sigtramp_rt64);
911 	} else {
912 		err |= setup_trampoline(__NR_rt_sigreturn, &frame->tramp[0]);
913 		if (err)
914 			goto badframe;
915 		regs->nip = (unsigned long) &frame->tramp[0];
916 	}
917 
918 
919 	/* Save the siginfo outside of the unsafe block. */
920 	if (copy_siginfo_to_user(&frame->info, &ksig->info))
921 		goto badframe;
922 
923 	/* Allocate a dummy caller frame for the signal handler. */
924 	newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
925 	err |= put_user(regs->gpr[1], (unsigned long __user *)newsp);
926 
927 	/* Set up "regs" so we "return" to the signal handler. */
928 	if (is_elf2_task()) {
929 		regs->ctr = (unsigned long) ksig->ka.sa.sa_handler;
930 		regs->gpr[12] = regs->ctr;
931 	} else {
932 		/* Handler is *really* a pointer to the function descriptor for
933 		 * the signal routine.  The first entry in the function
934 		 * descriptor is the entry address of signal and the second
935 		 * entry is the TOC value we need to use.
936 		 */
937 		func_descr_t __user *funct_desc_ptr =
938 			(func_descr_t __user *) ksig->ka.sa.sa_handler;
939 
940 		err |= get_user(regs->ctr, &funct_desc_ptr->entry);
941 		err |= get_user(regs->gpr[2], &funct_desc_ptr->toc);
942 	}
943 
944 	/* enter the signal handler in native-endian mode */
945 	regs->msr &= ~MSR_LE;
946 	regs->msr |= (MSR_KERNEL & MSR_LE);
947 	regs->gpr[1] = newsp;
948 	regs->gpr[3] = ksig->sig;
949 	regs->result = 0;
950 	if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
951 		err |= get_user(regs->gpr[4], (unsigned long __user *)&frame->pinfo);
952 		err |= get_user(regs->gpr[5], (unsigned long __user *)&frame->puc);
953 		regs->gpr[6] = (unsigned long) frame;
954 	} else {
955 		regs->gpr[4] = (unsigned long)&frame->uc.uc_mcontext;
956 	}
957 	if (err)
958 		goto badframe;
959 
960 	return 0;
961 
962 badframe_block:
963 	user_write_access_end();
964 badframe:
965 	signal_fault(current, regs, "handle_rt_signal64", frame);
966 
967 	return 1;
968 }
969