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