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