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