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