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