PageRenderTime 90ms CodeModel.GetById 20ms app.highlight 63ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/powerpc/kernel/signal_64.c

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