1 // SPDX-License-Identifier: GPL-2.0
2 /*  arch/sparc64/kernel/signal32.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
6  *  Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
7  *  Copyright (C) 1997 Eddie C. Dost   (ecd@skynet.be)
8  *  Copyright (C) 1997,1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
9  */
10 
11 #include <linux/sched.h>
12 #include <linux/kernel.h>
13 #include <linux/signal.h>
14 #include <linux/errno.h>
15 #include <linux/wait.h>
16 #include <linux/ptrace.h>
17 #include <linux/unistd.h>
18 #include <linux/mm.h>
19 #include <linux/tty.h>
20 #include <linux/binfmts.h>
21 #include <linux/compat.h>
22 #include <linux/bitops.h>
23 
24 #include <linux/uaccess.h>
25 #include <asm/ptrace.h>
26 #include <asm/psrcompat.h>
27 #include <asm/fpumacro.h>
28 #include <asm/visasm.h>
29 #include <asm/compat_signal.h>
30 #include <asm/switch_to.h>
31 
32 #include "sigutil.h"
33 #include "kernel.h"
34 
35 /* This magic should be in g_upper[0] for all upper parts
36  * to be valid.
37  */
38 #define SIGINFO_EXTRA_V8PLUS_MAGIC	0x130e269
39 typedef struct {
40 	unsigned int g_upper[8];
41 	unsigned int o_upper[8];
42 	unsigned int asi;
43 } siginfo_extra_v8plus_t;
44 
45 struct signal_frame32 {
46 	struct sparc_stackf32	ss;
47 	__siginfo32_t		info;
48 	/* __siginfo_fpu_t * */ u32 fpu_save;
49 	unsigned int		insns[2];
50 	unsigned int		extramask[_COMPAT_NSIG_WORDS - 1];
51 	unsigned int		extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
52 	/* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
53 	siginfo_extra_v8plus_t	v8plus;
54 	/* __siginfo_rwin_t * */u32 rwin_save;
55 } __attribute__((aligned(8)));
56 
57 struct rt_signal_frame32 {
58 	struct sparc_stackf32	ss;
59 	compat_siginfo_t	info;
60 	struct pt_regs32	regs;
61 	compat_sigset_t		mask;
62 	/* __siginfo_fpu_t * */ u32 fpu_save;
63 	unsigned int		insns[2];
64 	compat_stack_t		stack;
65 	unsigned int		extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
66 	/* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
67 	siginfo_extra_v8plus_t	v8plus;
68 	/* __siginfo_rwin_t * */u32 rwin_save;
69 } __attribute__((aligned(8)));
70 
71 /* Checks if the fp is valid.  We always build signal frames which are
72  * 16-byte aligned, therefore we can always enforce that the restore
73  * frame has that property as well.
74  */
invalid_frame_pointer(void __user * fp,int fplen)75 static bool invalid_frame_pointer(void __user *fp, int fplen)
76 {
77 	if ((((unsigned long) fp) & 15) ||
78 	    ((unsigned long)fp) > 0x100000000ULL - fplen)
79 		return true;
80 	return false;
81 }
82 
do_sigreturn32(struct pt_regs * regs)83 void do_sigreturn32(struct pt_regs *regs)
84 {
85 	struct signal_frame32 __user *sf;
86 	compat_uptr_t fpu_save;
87 	compat_uptr_t rwin_save;
88 	unsigned int psr, ufp;
89 	unsigned int pc, npc;
90 	sigset_t set;
91 	compat_sigset_t seta;
92 	int err, i;
93 
94 	/* Always make any pending restarted system calls return -EINTR */
95 	current->restart_block.fn = do_no_restart_syscall;
96 
97 	synchronize_user_stack();
98 
99 	regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
100 	sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
101 
102 	/* 1. Make sure we are not getting garbage from the user */
103 	if (invalid_frame_pointer(sf, sizeof(*sf)))
104 		goto segv;
105 
106 	if (get_user(ufp, &sf->info.si_regs.u_regs[UREG_FP]))
107 		goto segv;
108 
109 	if (ufp & 0x7)
110 		goto segv;
111 
112 	if (__get_user(pc, &sf->info.si_regs.pc) ||
113 	    __get_user(npc, &sf->info.si_regs.npc))
114 		goto segv;
115 
116 	if ((pc | npc) & 3)
117 		goto segv;
118 
119 	if (test_thread_flag(TIF_32BIT)) {
120 		pc &= 0xffffffff;
121 		npc &= 0xffffffff;
122 	}
123 	regs->tpc = pc;
124 	regs->tnpc = npc;
125 
126 	/* 2. Restore the state */
127 	err = __get_user(regs->y, &sf->info.si_regs.y);
128 	err |= __get_user(psr, &sf->info.si_regs.psr);
129 
130 	for (i = UREG_G1; i <= UREG_I7; i++)
131 		err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
132 	if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
133 		err |= __get_user(i, &sf->v8plus.g_upper[0]);
134 		if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
135 			unsigned long asi;
136 
137 			for (i = UREG_G1; i <= UREG_I7; i++)
138 				err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
139 			err |= __get_user(asi, &sf->v8plus.asi);
140 			regs->tstate &= ~TSTATE_ASI;
141 			regs->tstate |= ((asi & 0xffUL) << 24UL);
142 		}
143 	}
144 
145 	/* User can only change condition codes in %tstate. */
146 	regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
147 	regs->tstate |= psr_to_tstate_icc(psr);
148 
149 	/* Prevent syscall restart.  */
150 	pt_regs_clear_syscall(regs);
151 
152 	err |= __get_user(fpu_save, &sf->fpu_save);
153 	if (!err && fpu_save)
154 		err |= restore_fpu_state(regs, compat_ptr(fpu_save));
155 	err |= __get_user(rwin_save, &sf->rwin_save);
156 	if (!err && rwin_save) {
157 		if (restore_rwin_state(compat_ptr(rwin_save)))
158 			goto segv;
159 	}
160 	err |= __get_user(seta.sig[0], &sf->info.si_mask);
161 	err |= copy_from_user(&seta.sig[1], &sf->extramask,
162 			      (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
163 	if (err)
164 	    	goto segv;
165 
166 	set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
167 	set_current_blocked(&set);
168 	return;
169 
170 segv:
171 	force_sig(SIGSEGV);
172 }
173 
do_rt_sigreturn32(struct pt_regs * regs)174 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
175 {
176 	struct rt_signal_frame32 __user *sf;
177 	unsigned int psr, pc, npc, ufp;
178 	compat_uptr_t fpu_save;
179 	compat_uptr_t rwin_save;
180 	sigset_t set;
181 	int err, i;
182 
183 	/* Always make any pending restarted system calls return -EINTR */
184 	current->restart_block.fn = do_no_restart_syscall;
185 
186 	synchronize_user_stack();
187 	regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
188 	sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
189 
190 	/* 1. Make sure we are not getting garbage from the user */
191 	if (invalid_frame_pointer(sf, sizeof(*sf)))
192 		goto segv;
193 
194 	if (get_user(ufp, &sf->regs.u_regs[UREG_FP]))
195 		goto segv;
196 
197 	if (ufp & 0x7)
198 		goto segv;
199 
200 	if (__get_user(pc, &sf->regs.pc) ||
201 	    __get_user(npc, &sf->regs.npc))
202 		goto segv;
203 
204 	if ((pc | npc) & 3)
205 		goto segv;
206 
207 	if (test_thread_flag(TIF_32BIT)) {
208 		pc &= 0xffffffff;
209 		npc &= 0xffffffff;
210 	}
211 	regs->tpc = pc;
212 	regs->tnpc = npc;
213 
214 	/* 2. Restore the state */
215 	err = __get_user(regs->y, &sf->regs.y);
216 	err |= __get_user(psr, &sf->regs.psr);
217 
218 	for (i = UREG_G1; i <= UREG_I7; i++)
219 		err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
220 	if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
221 		err |= __get_user(i, &sf->v8plus.g_upper[0]);
222 		if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
223 			unsigned long asi;
224 
225 			for (i = UREG_G1; i <= UREG_I7; i++)
226 				err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
227 			err |= __get_user(asi, &sf->v8plus.asi);
228 			regs->tstate &= ~TSTATE_ASI;
229 			regs->tstate |= ((asi & 0xffUL) << 24UL);
230 		}
231 	}
232 
233 	/* User can only change condition codes in %tstate. */
234 	regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
235 	regs->tstate |= psr_to_tstate_icc(psr);
236 
237 	/* Prevent syscall restart.  */
238 	pt_regs_clear_syscall(regs);
239 
240 	err |= __get_user(fpu_save, &sf->fpu_save);
241 	if (!err && fpu_save)
242 		err |= restore_fpu_state(regs, compat_ptr(fpu_save));
243 	err |= get_compat_sigset(&set, &sf->mask);
244 	err |= compat_restore_altstack(&sf->stack);
245 	if (err)
246 		goto segv;
247 
248 	err |= __get_user(rwin_save, &sf->rwin_save);
249 	if (!err && rwin_save) {
250 		if (restore_rwin_state(compat_ptr(rwin_save)))
251 			goto segv;
252 	}
253 
254 	set_current_blocked(&set);
255 	return;
256 segv:
257 	force_sig(SIGSEGV);
258 }
259 
get_sigframe(struct ksignal * ksig,struct pt_regs * regs,unsigned long framesize)260 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
261 {
262 	unsigned long sp;
263 
264 	regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
265 	sp = regs->u_regs[UREG_FP];
266 
267 	/*
268 	 * If we are on the alternate signal stack and would overflow it, don't.
269 	 * Return an always-bogus address instead so we will die with SIGSEGV.
270 	 */
271 	if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
272 		return (void __user *) -1L;
273 
274 	/* This is the X/Open sanctioned signal stack switching.  */
275 	sp = sigsp(sp, ksig) - framesize;
276 
277 	/* Always align the stack frame.  This handles two cases.  First,
278 	 * sigaltstack need not be mindful of platform specific stack
279 	 * alignment.  Second, if we took this signal because the stack
280 	 * is not aligned properly, we'd like to take the signal cleanly
281 	 * and report that.
282 	 */
283 	sp &= ~15UL;
284 
285 	return (void __user *) sp;
286 }
287 
288 /* The I-cache flush instruction only works in the primary ASI, which
289  * right now is the nucleus, aka. kernel space.
290  *
291  * Therefore we have to kick the instructions out using the kernel
292  * side linear mapping of the physical address backing the user
293  * instructions.
294  */
flush_signal_insns(unsigned long address)295 static void flush_signal_insns(unsigned long address)
296 {
297 	unsigned long pstate, paddr;
298 	pte_t *ptep, pte;
299 	pgd_t *pgdp;
300 	p4d_t *p4dp;
301 	pud_t *pudp;
302 	pmd_t *pmdp;
303 
304 	/* Commit all stores of the instructions we are about to flush.  */
305 	wmb();
306 
307 	/* Disable cross-call reception.  In this way even a very wide
308 	 * munmap() on another cpu can't tear down the page table
309 	 * hierarchy from underneath us, since that can't complete
310 	 * until the IPI tlb flush returns.
311 	 */
312 
313 	__asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
314 	__asm__ __volatile__("wrpr %0, %1, %%pstate"
315 				: : "r" (pstate), "i" (PSTATE_IE));
316 
317 	pgdp = pgd_offset(current->mm, address);
318 	if (pgd_none(*pgdp))
319 		goto out_irqs_on;
320 	p4dp = p4d_offset(pgdp, address);
321 	if (p4d_none(*p4dp))
322 		goto out_irqs_on;
323 	pudp = pud_offset(p4dp, address);
324 	if (pud_none(*pudp))
325 		goto out_irqs_on;
326 	pmdp = pmd_offset(pudp, address);
327 	if (pmd_none(*pmdp))
328 		goto out_irqs_on;
329 
330 	ptep = pte_offset_map(pmdp, address);
331 	pte = *ptep;
332 	if (!pte_present(pte))
333 		goto out_unmap;
334 
335 	paddr = (unsigned long) page_address(pte_page(pte));
336 
337 	__asm__ __volatile__("flush	%0 + %1"
338 			     : /* no outputs */
339 			     : "r" (paddr),
340 			       "r" (address & (PAGE_SIZE - 1))
341 			     : "memory");
342 
343 out_unmap:
344 	pte_unmap(ptep);
345 out_irqs_on:
346 	__asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
347 
348 }
349 
setup_frame32(struct ksignal * ksig,struct pt_regs * regs,sigset_t * oldset)350 static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs,
351 			 sigset_t *oldset)
352 {
353 	struct signal_frame32 __user *sf;
354 	int i, err, wsaved;
355 	void __user *tail;
356 	int sigframe_size;
357 	u32 psr;
358 	compat_sigset_t seta;
359 
360 	/* 1. Make sure everything is clean */
361 	synchronize_user_stack();
362 	save_and_clear_fpu();
363 
364 	wsaved = get_thread_wsaved();
365 
366 	sigframe_size = sizeof(*sf);
367 	if (current_thread_info()->fpsaved[0] & FPRS_FEF)
368 		sigframe_size += sizeof(__siginfo_fpu_t);
369 	if (wsaved)
370 		sigframe_size += sizeof(__siginfo_rwin_t);
371 
372 	sf = (struct signal_frame32 __user *)
373 		get_sigframe(ksig, regs, sigframe_size);
374 
375 	if (invalid_frame_pointer(sf, sigframe_size)) {
376 		if (show_unhandled_signals)
377 			pr_info("%s[%d] bad frame in setup_frame32: %08lx TPC %08lx O7 %08lx\n",
378 				current->comm, current->pid, (unsigned long)sf,
379 				regs->tpc, regs->u_regs[UREG_I7]);
380 		force_sigsegv(ksig->sig);
381 		return -EINVAL;
382 	}
383 
384 	tail = (sf + 1);
385 
386 	/* 2. Save the current process state */
387 	if (test_thread_flag(TIF_32BIT)) {
388 		regs->tpc &= 0xffffffff;
389 		regs->tnpc &= 0xffffffff;
390 	}
391 	err  = put_user(regs->tpc, &sf->info.si_regs.pc);
392 	err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
393 	err |= __put_user(regs->y, &sf->info.si_regs.y);
394 	psr = tstate_to_psr(regs->tstate);
395 	if (current_thread_info()->fpsaved[0] & FPRS_FEF)
396 		psr |= PSR_EF;
397 	err |= __put_user(psr, &sf->info.si_regs.psr);
398 	for (i = 0; i < 16; i++)
399 		err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
400 	err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
401 	err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
402 	for (i = 1; i < 16; i++)
403 		err |= __put_user(((u32 *)regs->u_regs)[2*i],
404 				  &sf->v8plus.g_upper[i]);
405 	err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
406 			  &sf->v8plus.asi);
407 
408 	if (psr & PSR_EF) {
409 		__siginfo_fpu_t __user *fp = tail;
410 		tail += sizeof(*fp);
411 		err |= save_fpu_state(regs, fp);
412 		err |= __put_user((u64)fp, &sf->fpu_save);
413 	} else {
414 		err |= __put_user(0, &sf->fpu_save);
415 	}
416 	if (wsaved) {
417 		__siginfo_rwin_t __user *rwp = tail;
418 		tail += sizeof(*rwp);
419 		err |= save_rwin_state(wsaved, rwp);
420 		err |= __put_user((u64)rwp, &sf->rwin_save);
421 		set_thread_wsaved(0);
422 	} else {
423 		err |= __put_user(0, &sf->rwin_save);
424 	}
425 
426 	/* If these change we need to know - assignments to seta relies on these sizes */
427 	BUILD_BUG_ON(_NSIG_WORDS != 1);
428 	BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2);
429 	seta.sig[1] = (oldset->sig[0] >> 32);
430 	seta.sig[0] = oldset->sig[0];
431 
432 	err |= __put_user(seta.sig[0], &sf->info.si_mask);
433 	err |= __copy_to_user(sf->extramask, &seta.sig[1],
434 			      (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
435 
436 	if (!wsaved) {
437 		err |= raw_copy_in_user((u32 __user *)sf,
438 					(u32 __user *)(regs->u_regs[UREG_FP]),
439 					sizeof(struct reg_window32));
440 	} else {
441 		struct reg_window *rp;
442 
443 		rp = &current_thread_info()->reg_window[wsaved - 1];
444 		for (i = 0; i < 8; i++)
445 			err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
446 		for (i = 0; i < 6; i++)
447 			err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
448 		err |= __put_user(rp->ins[6], &sf->ss.fp);
449 		err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
450 	}
451 	if (err)
452 		return err;
453 
454 	/* 3. signal handler back-trampoline and parameters */
455 	regs->u_regs[UREG_FP] = (unsigned long) sf;
456 	regs->u_regs[UREG_I0] = ksig->sig;
457 	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
458 	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
459 
460 	/* 4. signal handler */
461 	regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
462 	regs->tnpc = (regs->tpc + 4);
463 	if (test_thread_flag(TIF_32BIT)) {
464 		regs->tpc &= 0xffffffff;
465 		regs->tnpc &= 0xffffffff;
466 	}
467 
468 	/* 5. return to kernel instructions */
469 	if (ksig->ka.ka_restorer) {
470 		regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
471 	} else {
472 		unsigned long address = ((unsigned long)&(sf->insns[0]));
473 
474 		regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
475 
476 		err  = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
477 		err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
478 		if (err)
479 			return err;
480 		flush_signal_insns(address);
481 	}
482 	return 0;
483 }
484 
setup_rt_frame32(struct ksignal * ksig,struct pt_regs * regs,sigset_t * oldset)485 static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
486 			    sigset_t *oldset)
487 {
488 	struct rt_signal_frame32 __user *sf;
489 	int i, err, wsaved;
490 	void __user *tail;
491 	int sigframe_size;
492 	u32 psr;
493 
494 	/* 1. Make sure everything is clean */
495 	synchronize_user_stack();
496 	save_and_clear_fpu();
497 
498 	wsaved = get_thread_wsaved();
499 
500 	sigframe_size = sizeof(*sf);
501 	if (current_thread_info()->fpsaved[0] & FPRS_FEF)
502 		sigframe_size += sizeof(__siginfo_fpu_t);
503 	if (wsaved)
504 		sigframe_size += sizeof(__siginfo_rwin_t);
505 
506 	sf = (struct rt_signal_frame32 __user *)
507 		get_sigframe(ksig, regs, sigframe_size);
508 
509 	if (invalid_frame_pointer(sf, sigframe_size)) {
510 		if (show_unhandled_signals)
511 			pr_info("%s[%d] bad frame in setup_rt_frame32: %08lx TPC %08lx O7 %08lx\n",
512 				current->comm, current->pid, (unsigned long)sf,
513 				regs->tpc, regs->u_regs[UREG_I7]);
514 		force_sigsegv(ksig->sig);
515 		return -EINVAL;
516 	}
517 
518 	tail = (sf + 1);
519 
520 	/* 2. Save the current process state */
521 	if (test_thread_flag(TIF_32BIT)) {
522 		regs->tpc &= 0xffffffff;
523 		regs->tnpc &= 0xffffffff;
524 	}
525 	err  = put_user(regs->tpc, &sf->regs.pc);
526 	err |= __put_user(regs->tnpc, &sf->regs.npc);
527 	err |= __put_user(regs->y, &sf->regs.y);
528 	psr = tstate_to_psr(regs->tstate);
529 	if (current_thread_info()->fpsaved[0] & FPRS_FEF)
530 		psr |= PSR_EF;
531 	err |= __put_user(psr, &sf->regs.psr);
532 	for (i = 0; i < 16; i++)
533 		err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
534 	err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
535 	err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
536 	for (i = 1; i < 16; i++)
537 		err |= __put_user(((u32 *)regs->u_regs)[2*i],
538 				  &sf->v8plus.g_upper[i]);
539 	err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
540 			  &sf->v8plus.asi);
541 
542 	if (psr & PSR_EF) {
543 		__siginfo_fpu_t __user *fp = tail;
544 		tail += sizeof(*fp);
545 		err |= save_fpu_state(regs, fp);
546 		err |= __put_user((u64)fp, &sf->fpu_save);
547 	} else {
548 		err |= __put_user(0, &sf->fpu_save);
549 	}
550 	if (wsaved) {
551 		__siginfo_rwin_t __user *rwp = tail;
552 		tail += sizeof(*rwp);
553 		err |= save_rwin_state(wsaved, rwp);
554 		err |= __put_user((u64)rwp, &sf->rwin_save);
555 		set_thread_wsaved(0);
556 	} else {
557 		err |= __put_user(0, &sf->rwin_save);
558 	}
559 
560 	/* Update the siginfo structure.  */
561 	err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
562 
563 	/* Setup sigaltstack */
564 	err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
565 
566 	err |= put_compat_sigset(&sf->mask, oldset, sizeof(compat_sigset_t));
567 
568 	if (!wsaved) {
569 		err |= raw_copy_in_user((u32 __user *)sf,
570 					(u32 __user *)(regs->u_regs[UREG_FP]),
571 					sizeof(struct reg_window32));
572 	} else {
573 		struct reg_window *rp;
574 
575 		rp = &current_thread_info()->reg_window[wsaved - 1];
576 		for (i = 0; i < 8; i++)
577 			err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
578 		for (i = 0; i < 6; i++)
579 			err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
580 		err |= __put_user(rp->ins[6], &sf->ss.fp);
581 		err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
582 	}
583 	if (err)
584 		return err;
585 
586 	/* 3. signal handler back-trampoline and parameters */
587 	regs->u_regs[UREG_FP] = (unsigned long) sf;
588 	regs->u_regs[UREG_I0] = ksig->sig;
589 	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
590 	regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
591 
592 	/* 4. signal handler */
593 	regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
594 	regs->tnpc = (regs->tpc + 4);
595 	if (test_thread_flag(TIF_32BIT)) {
596 		regs->tpc &= 0xffffffff;
597 		regs->tnpc &= 0xffffffff;
598 	}
599 
600 	/* 5. return to kernel instructions */
601 	if (ksig->ka.ka_restorer)
602 		regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
603 	else {
604 		unsigned long address = ((unsigned long)&(sf->insns[0]));
605 
606 		regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
607 
608 		/* mov __NR_rt_sigreturn, %g1 */
609 		err |= __put_user(0x82102065, &sf->insns[0]);
610 
611 		/* t 0x10 */
612 		err |= __put_user(0x91d02010, &sf->insns[1]);
613 		if (err)
614 			return err;
615 
616 		flush_signal_insns(address);
617 	}
618 	return 0;
619 }
620 
handle_signal32(struct ksignal * ksig,struct pt_regs * regs)621 static inline void handle_signal32(struct ksignal *ksig,
622 				  struct pt_regs *regs)
623 {
624 	sigset_t *oldset = sigmask_to_save();
625 	int err;
626 
627 	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
628 		err = setup_rt_frame32(ksig, regs, oldset);
629 	else
630 		err = setup_frame32(ksig, regs, oldset);
631 
632 	signal_setup_done(err, ksig, 0);
633 }
634 
syscall_restart32(unsigned long orig_i0,struct pt_regs * regs,struct sigaction * sa)635 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
636 				     struct sigaction *sa)
637 {
638 	switch (regs->u_regs[UREG_I0]) {
639 	case ERESTART_RESTARTBLOCK:
640 	case ERESTARTNOHAND:
641 	no_system_call_restart:
642 		regs->u_regs[UREG_I0] = EINTR;
643 		regs->tstate |= TSTATE_ICARRY;
644 		break;
645 	case ERESTARTSYS:
646 		if (!(sa->sa_flags & SA_RESTART))
647 			goto no_system_call_restart;
648 		fallthrough;
649 	case ERESTARTNOINTR:
650 		regs->u_regs[UREG_I0] = orig_i0;
651 		regs->tpc -= 4;
652 		regs->tnpc -= 4;
653 	}
654 }
655 
656 /* Note that 'init' is a special process: it doesn't get signals it doesn't
657  * want to handle. Thus you cannot kill init even with a SIGKILL even by
658  * mistake.
659  */
do_signal32(struct pt_regs * regs)660 void do_signal32(struct pt_regs * regs)
661 {
662 	struct ksignal ksig;
663 	unsigned long orig_i0 = 0;
664 	int restart_syscall = 0;
665 	bool has_handler = get_signal(&ksig);
666 
667 	if (pt_regs_is_syscall(regs) &&
668 	    (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
669 		restart_syscall = 1;
670 		orig_i0 = regs->u_regs[UREG_G6];
671 	}
672 
673 	if (has_handler) {
674 		if (restart_syscall)
675 			syscall_restart32(orig_i0, regs, &ksig.ka.sa);
676 		handle_signal32(&ksig, regs);
677 	} else {
678 		if (restart_syscall) {
679 			switch (regs->u_regs[UREG_I0]) {
680 			case ERESTARTNOHAND:
681 	     		case ERESTARTSYS:
682 			case ERESTARTNOINTR:
683 				/* replay the system call when we are done */
684 				regs->u_regs[UREG_I0] = orig_i0;
685 				regs->tpc -= 4;
686 				regs->tnpc -= 4;
687 				pt_regs_clear_syscall(regs);
688 				fallthrough;
689 			case ERESTART_RESTARTBLOCK:
690 				regs->u_regs[UREG_G1] = __NR_restart_syscall;
691 				regs->tpc -= 4;
692 				regs->tnpc -= 4;
693 				pt_regs_clear_syscall(regs);
694 			}
695 		}
696 		restore_saved_sigmask();
697 	}
698 }
699 
700 struct sigstack32 {
701 	u32 the_stack;
702 	int cur_status;
703 };
704 
do_sys32_sigstack(u32 u_ssptr,u32 u_ossptr,unsigned long sp)705 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
706 {
707 	struct sigstack32 __user *ssptr =
708 		(struct sigstack32 __user *)((unsigned long)(u_ssptr));
709 	struct sigstack32 __user *ossptr =
710 		(struct sigstack32 __user *)((unsigned long)(u_ossptr));
711 	int ret = -EFAULT;
712 
713 	/* First see if old state is wanted. */
714 	if (ossptr) {
715 		if (put_user(current->sas_ss_sp + current->sas_ss_size,
716 			     &ossptr->the_stack) ||
717 		    __put_user(on_sig_stack(sp), &ossptr->cur_status))
718 			goto out;
719 	}
720 
721 	/* Now see if we want to update the new state. */
722 	if (ssptr) {
723 		u32 ss_sp;
724 
725 		if (get_user(ss_sp, &ssptr->the_stack))
726 			goto out;
727 
728 		/* If the current stack was set with sigaltstack, don't
729 		 * swap stacks while we are on it.
730 		 */
731 		ret = -EPERM;
732 		if (current->sas_ss_sp && on_sig_stack(sp))
733 			goto out;
734 
735 		/* Since we don't know the extent of the stack, and we don't
736 		 * track onstack-ness, but rather calculate it, we must
737 		 * presume a size.  Ho hum this interface is lossy.
738 		 */
739 		current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
740 		current->sas_ss_size = SIGSTKSZ;
741 	}
742 
743 	ret = 0;
744 out:
745 	return ret;
746 }
747 
748 /*
749  * Compile-time assertions for siginfo_t offsets. Check NSIG* as well, as
750  * changes likely come with new fields that should be added below.
751  */
752 static_assert(NSIGILL	== 11);
753 static_assert(NSIGFPE	== 15);
754 static_assert(NSIGSEGV	== 9);
755 static_assert(NSIGBUS	== 5);
756 static_assert(NSIGTRAP	== 6);
757 static_assert(NSIGCHLD	== 6);
758 static_assert(NSIGSYS	== 2);
759 static_assert(sizeof(compat_siginfo_t) == 128);
760 static_assert(__alignof__(compat_siginfo_t) == 4);
761 static_assert(offsetof(compat_siginfo_t, si_signo)	== 0x00);
762 static_assert(offsetof(compat_siginfo_t, si_errno)	== 0x04);
763 static_assert(offsetof(compat_siginfo_t, si_code)	== 0x08);
764 static_assert(offsetof(compat_siginfo_t, si_pid)	== 0x0c);
765 static_assert(offsetof(compat_siginfo_t, si_uid)	== 0x10);
766 static_assert(offsetof(compat_siginfo_t, si_tid)	== 0x0c);
767 static_assert(offsetof(compat_siginfo_t, si_overrun)	== 0x10);
768 static_assert(offsetof(compat_siginfo_t, si_status)	== 0x14);
769 static_assert(offsetof(compat_siginfo_t, si_utime)	== 0x18);
770 static_assert(offsetof(compat_siginfo_t, si_stime)	== 0x1c);
771 static_assert(offsetof(compat_siginfo_t, si_value)	== 0x14);
772 static_assert(offsetof(compat_siginfo_t, si_int)	== 0x14);
773 static_assert(offsetof(compat_siginfo_t, si_ptr)	== 0x14);
774 static_assert(offsetof(compat_siginfo_t, si_addr)	== 0x0c);
775 static_assert(offsetof(compat_siginfo_t, si_trapno)	== 0x10);
776 static_assert(offsetof(compat_siginfo_t, si_addr_lsb)	== 0x10);
777 static_assert(offsetof(compat_siginfo_t, si_lower)	== 0x14);
778 static_assert(offsetof(compat_siginfo_t, si_upper)	== 0x18);
779 static_assert(offsetof(compat_siginfo_t, si_pkey)	== 0x14);
780 static_assert(offsetof(compat_siginfo_t, si_perf_data)	== 0x10);
781 static_assert(offsetof(compat_siginfo_t, si_perf_type)	== 0x14);
782 static_assert(offsetof(compat_siginfo_t, si_perf_flags)	== 0x18);
783 static_assert(offsetof(compat_siginfo_t, si_band)	== 0x0c);
784 static_assert(offsetof(compat_siginfo_t, si_fd)		== 0x10);
785