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