Loading...
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
32#include "sigutil.h"
33
34#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
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
58typedef struct compat_siginfo{
59 int si_signo;
60 int si_errno;
61 int si_code;
62
63 union {
64 int _pad[SI_PAD_SIZE32];
65
66 /* kill() */
67 struct {
68 compat_pid_t _pid; /* sender's pid */
69 unsigned int _uid; /* sender's uid */
70 } _kill;
71
72 /* POSIX.1b timers */
73 struct {
74 compat_timer_t _tid; /* timer id */
75 int _overrun; /* overrun count */
76 compat_sigval_t _sigval; /* same as below */
77 int _sys_private; /* not to be passed to user */
78 } _timer;
79
80 /* POSIX.1b signals */
81 struct {
82 compat_pid_t _pid; /* sender's pid */
83 unsigned int _uid; /* sender's uid */
84 compat_sigval_t _sigval;
85 } _rt;
86
87 /* SIGCHLD */
88 struct {
89 compat_pid_t _pid; /* which child */
90 unsigned int _uid; /* sender's uid */
91 int _status; /* exit code */
92 compat_clock_t _utime;
93 compat_clock_t _stime;
94 } _sigchld;
95
96 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
97 struct {
98 u32 _addr; /* faulting insn/memory ref. */
99 int _trapno;
100 } _sigfault;
101
102 /* SIGPOLL */
103 struct {
104 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
105 int _fd;
106 } _sigpoll;
107 } _sifields;
108}compat_siginfo_t;
109
110struct rt_signal_frame32 {
111 struct sparc_stackf32 ss;
112 compat_siginfo_t info;
113 struct pt_regs32 regs;
114 compat_sigset_t mask;
115 /* __siginfo_fpu_t * */ u32 fpu_save;
116 unsigned int insns[2];
117 stack_t32 stack;
118 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
119 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
120 siginfo_extra_v8plus_t v8plus;
121 /* __siginfo_rwin_t * */u32 rwin_save;
122} __attribute__((aligned(8)));
123
124int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
125{
126 int err;
127
128 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
129 return -EFAULT;
130
131 /* If you change siginfo_t structure, please be sure
132 this code is fixed accordingly.
133 It should never copy any pad contained in the structure
134 to avoid security leaks, but must copy the generic
135 3 ints plus the relevant union member.
136 This routine must convert siginfo from 64bit to 32bit as well
137 at the same time. */
138 err = __put_user(from->si_signo, &to->si_signo);
139 err |= __put_user(from->si_errno, &to->si_errno);
140 err |= __put_user((short)from->si_code, &to->si_code);
141 if (from->si_code < 0)
142 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
143 else {
144 switch (from->si_code >> 16) {
145 case __SI_TIMER >> 16:
146 err |= __put_user(from->si_tid, &to->si_tid);
147 err |= __put_user(from->si_overrun, &to->si_overrun);
148 err |= __put_user(from->si_int, &to->si_int);
149 break;
150 case __SI_CHLD >> 16:
151 err |= __put_user(from->si_utime, &to->si_utime);
152 err |= __put_user(from->si_stime, &to->si_stime);
153 err |= __put_user(from->si_status, &to->si_status);
154 default:
155 err |= __put_user(from->si_pid, &to->si_pid);
156 err |= __put_user(from->si_uid, &to->si_uid);
157 break;
158 case __SI_FAULT >> 16:
159 err |= __put_user(from->si_trapno, &to->si_trapno);
160 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
161 break;
162 case __SI_POLL >> 16:
163 err |= __put_user(from->si_band, &to->si_band);
164 err |= __put_user(from->si_fd, &to->si_fd);
165 break;
166 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
167 case __SI_MESGQ >> 16:
168 err |= __put_user(from->si_pid, &to->si_pid);
169 err |= __put_user(from->si_uid, &to->si_uid);
170 err |= __put_user(from->si_int, &to->si_int);
171 break;
172 }
173 }
174 return err;
175}
176
177/* CAUTION: This is just a very minimalist implementation for the
178 * sake of compat_sys_rt_sigqueueinfo()
179 */
180int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
181{
182 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
183 return -EFAULT;
184
185 if (copy_from_user(to, from, 3*sizeof(int)) ||
186 copy_from_user(to->_sifields._pad, from->_sifields._pad,
187 SI_PAD_SIZE))
188 return -EFAULT;
189
190 return 0;
191}
192
193void do_sigreturn32(struct pt_regs *regs)
194{
195 struct signal_frame32 __user *sf;
196 compat_uptr_t fpu_save;
197 compat_uptr_t rwin_save;
198 unsigned int psr;
199 unsigned pc, npc;
200 sigset_t set;
201 unsigned seta[_COMPAT_NSIG_WORDS];
202 int err, i;
203
204 /* Always make any pending restarted system calls return -EINTR */
205 current_thread_info()->restart_block.fn = do_no_restart_syscall;
206
207 synchronize_user_stack();
208
209 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
210 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
211
212 /* 1. Make sure we are not getting garbage from the user */
213 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
214 (((unsigned long) sf) & 3))
215 goto segv;
216
217 get_user(pc, &sf->info.si_regs.pc);
218 __get_user(npc, &sf->info.si_regs.npc);
219
220 if ((pc | npc) & 3)
221 goto segv;
222
223 if (test_thread_flag(TIF_32BIT)) {
224 pc &= 0xffffffff;
225 npc &= 0xffffffff;
226 }
227 regs->tpc = pc;
228 regs->tnpc = npc;
229
230 /* 2. Restore the state */
231 err = __get_user(regs->y, &sf->info.si_regs.y);
232 err |= __get_user(psr, &sf->info.si_regs.psr);
233
234 for (i = UREG_G1; i <= UREG_I7; i++)
235 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
236 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
237 err |= __get_user(i, &sf->v8plus.g_upper[0]);
238 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
239 unsigned long asi;
240
241 for (i = UREG_G1; i <= UREG_I7; i++)
242 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
243 err |= __get_user(asi, &sf->v8plus.asi);
244 regs->tstate &= ~TSTATE_ASI;
245 regs->tstate |= ((asi & 0xffUL) << 24UL);
246 }
247 }
248
249 /* User can only change condition codes in %tstate. */
250 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
251 regs->tstate |= psr_to_tstate_icc(psr);
252
253 /* Prevent syscall restart. */
254 pt_regs_clear_syscall(regs);
255
256 err |= __get_user(fpu_save, &sf->fpu_save);
257 if (!err && fpu_save)
258 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
259 err |= __get_user(rwin_save, &sf->rwin_save);
260 if (!err && rwin_save) {
261 if (restore_rwin_state(compat_ptr(rwin_save)))
262 goto segv;
263 }
264 err |= __get_user(seta[0], &sf->info.si_mask);
265 err |= copy_from_user(seta+1, &sf->extramask,
266 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
267 if (err)
268 goto segv;
269 switch (_NSIG_WORDS) {
270 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
271 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
272 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
273 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
274 }
275 sigdelsetmask(&set, ~_BLOCKABLE);
276 set_current_blocked(&set);
277 return;
278
279segv:
280 force_sig(SIGSEGV, current);
281}
282
283asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
284{
285 struct rt_signal_frame32 __user *sf;
286 unsigned int psr, pc, npc, u_ss_sp;
287 compat_uptr_t fpu_save;
288 compat_uptr_t rwin_save;
289 mm_segment_t old_fs;
290 sigset_t set;
291 compat_sigset_t seta;
292 stack_t st;
293 int err, i;
294
295 /* Always make any pending restarted system calls return -EINTR */
296 current_thread_info()->restart_block.fn = do_no_restart_syscall;
297
298 synchronize_user_stack();
299 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
300 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
301
302 /* 1. Make sure we are not getting garbage from the user */
303 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
304 (((unsigned long) sf) & 3))
305 goto segv;
306
307 get_user(pc, &sf->regs.pc);
308 __get_user(npc, &sf->regs.npc);
309
310 if ((pc | npc) & 3)
311 goto segv;
312
313 if (test_thread_flag(TIF_32BIT)) {
314 pc &= 0xffffffff;
315 npc &= 0xffffffff;
316 }
317 regs->tpc = pc;
318 regs->tnpc = npc;
319
320 /* 2. Restore the state */
321 err = __get_user(regs->y, &sf->regs.y);
322 err |= __get_user(psr, &sf->regs.psr);
323
324 for (i = UREG_G1; i <= UREG_I7; i++)
325 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
326 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
327 err |= __get_user(i, &sf->v8plus.g_upper[0]);
328 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
329 unsigned long asi;
330
331 for (i = UREG_G1; i <= UREG_I7; i++)
332 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
333 err |= __get_user(asi, &sf->v8plus.asi);
334 regs->tstate &= ~TSTATE_ASI;
335 regs->tstate |= ((asi & 0xffUL) << 24UL);
336 }
337 }
338
339 /* User can only change condition codes in %tstate. */
340 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
341 regs->tstate |= psr_to_tstate_icc(psr);
342
343 /* Prevent syscall restart. */
344 pt_regs_clear_syscall(regs);
345
346 err |= __get_user(fpu_save, &sf->fpu_save);
347 if (!err && fpu_save)
348 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
349 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
350 err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
351 st.ss_sp = compat_ptr(u_ss_sp);
352 err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
353 err |= __get_user(st.ss_size, &sf->stack.ss_size);
354 if (err)
355 goto segv;
356
357 /* It is more difficult to avoid calling this function than to
358 call it and ignore errors. */
359 old_fs = get_fs();
360 set_fs(KERNEL_DS);
361 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
362 set_fs(old_fs);
363
364 err |= __get_user(rwin_save, &sf->rwin_save);
365 if (!err && rwin_save) {
366 if (restore_rwin_state(compat_ptr(rwin_save)))
367 goto segv;
368 }
369
370 switch (_NSIG_WORDS) {
371 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
372 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
373 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
374 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
375 }
376 sigdelsetmask(&set, ~_BLOCKABLE);
377 set_current_blocked(&set);
378 return;
379segv:
380 force_sig(SIGSEGV, current);
381}
382
383/* Checks if the fp is valid */
384static int invalid_frame_pointer(void __user *fp, int fplen)
385{
386 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
387 return 1;
388 return 0;
389}
390
391static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
392{
393 unsigned long sp;
394
395 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
396 sp = regs->u_regs[UREG_FP];
397
398 /*
399 * If we are on the alternate signal stack and would overflow it, don't.
400 * Return an always-bogus address instead so we will die with SIGSEGV.
401 */
402 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
403 return (void __user *) -1L;
404
405 /* This is the X/Open sanctioned signal stack switching. */
406 if (sa->sa_flags & SA_ONSTACK) {
407 if (sas_ss_flags(sp) == 0)
408 sp = current->sas_ss_sp + current->sas_ss_size;
409 }
410
411 sp -= framesize;
412
413 /* Always align the stack frame. This handles two cases. First,
414 * sigaltstack need not be mindful of platform specific stack
415 * alignment. Second, if we took this signal because the stack
416 * is not aligned properly, we'd like to take the signal cleanly
417 * and report that.
418 */
419 sp &= ~15UL;
420
421 return (void __user *) sp;
422}
423
424/* The I-cache flush instruction only works in the primary ASI, which
425 * right now is the nucleus, aka. kernel space.
426 *
427 * Therefore we have to kick the instructions out using the kernel
428 * side linear mapping of the physical address backing the user
429 * instructions.
430 */
431static void flush_signal_insns(unsigned long address)
432{
433 unsigned long pstate, paddr;
434 pte_t *ptep, pte;
435 pgd_t *pgdp;
436 pud_t *pudp;
437 pmd_t *pmdp;
438
439 /* Commit all stores of the instructions we are about to flush. */
440 wmb();
441
442 /* Disable cross-call reception. In this way even a very wide
443 * munmap() on another cpu can't tear down the page table
444 * hierarchy from underneath us, since that can't complete
445 * until the IPI tlb flush returns.
446 */
447
448 __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
449 __asm__ __volatile__("wrpr %0, %1, %%pstate"
450 : : "r" (pstate), "i" (PSTATE_IE));
451
452 pgdp = pgd_offset(current->mm, address);
453 if (pgd_none(*pgdp))
454 goto out_irqs_on;
455 pudp = pud_offset(pgdp, address);
456 if (pud_none(*pudp))
457 goto out_irqs_on;
458 pmdp = pmd_offset(pudp, address);
459 if (pmd_none(*pmdp))
460 goto out_irqs_on;
461
462 ptep = pte_offset_map(pmdp, address);
463 pte = *ptep;
464 if (!pte_present(pte))
465 goto out_unmap;
466
467 paddr = (unsigned long) page_address(pte_page(pte));
468
469 __asm__ __volatile__("flush %0 + %1"
470 : /* no outputs */
471 : "r" (paddr),
472 "r" (address & (PAGE_SIZE - 1))
473 : "memory");
474
475out_unmap:
476 pte_unmap(ptep);
477out_irqs_on:
478 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
479
480}
481
482static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
483 int signo, sigset_t *oldset)
484{
485 struct signal_frame32 __user *sf;
486 int i, err, wsaved;
487 void __user *tail;
488 int sigframe_size;
489 u32 psr;
490 unsigned int seta[_COMPAT_NSIG_WORDS];
491
492 /* 1. Make sure everything is clean */
493 synchronize_user_stack();
494 save_and_clear_fpu();
495
496 wsaved = get_thread_wsaved();
497
498 sigframe_size = sizeof(*sf);
499 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
500 sigframe_size += sizeof(__siginfo_fpu_t);
501 if (wsaved)
502 sigframe_size += sizeof(__siginfo_rwin_t);
503
504 sf = (struct signal_frame32 __user *)
505 get_sigframe(&ka->sa, regs, sigframe_size);
506
507 if (invalid_frame_pointer(sf, sigframe_size))
508 goto sigill;
509
510 tail = (sf + 1);
511
512 /* 2. Save the current process state */
513 if (test_thread_flag(TIF_32BIT)) {
514 regs->tpc &= 0xffffffff;
515 regs->tnpc &= 0xffffffff;
516 }
517 err = put_user(regs->tpc, &sf->info.si_regs.pc);
518 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
519 err |= __put_user(regs->y, &sf->info.si_regs.y);
520 psr = tstate_to_psr(regs->tstate);
521 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
522 psr |= PSR_EF;
523 err |= __put_user(psr, &sf->info.si_regs.psr);
524 for (i = 0; i < 16; i++)
525 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
526 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
527 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
528 for (i = 1; i < 16; i++)
529 err |= __put_user(((u32 *)regs->u_regs)[2*i],
530 &sf->v8plus.g_upper[i]);
531 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
532 &sf->v8plus.asi);
533
534 if (psr & PSR_EF) {
535 __siginfo_fpu_t __user *fp = tail;
536 tail += sizeof(*fp);
537 err |= save_fpu_state(regs, fp);
538 err |= __put_user((u64)fp, &sf->fpu_save);
539 } else {
540 err |= __put_user(0, &sf->fpu_save);
541 }
542 if (wsaved) {
543 __siginfo_rwin_t __user *rwp = tail;
544 tail += sizeof(*rwp);
545 err |= save_rwin_state(wsaved, rwp);
546 err |= __put_user((u64)rwp, &sf->rwin_save);
547 set_thread_wsaved(0);
548 } else {
549 err |= __put_user(0, &sf->rwin_save);
550 }
551
552 switch (_NSIG_WORDS) {
553 case 4: seta[7] = (oldset->sig[3] >> 32);
554 seta[6] = oldset->sig[3];
555 case 3: seta[5] = (oldset->sig[2] >> 32);
556 seta[4] = oldset->sig[2];
557 case 2: seta[3] = (oldset->sig[1] >> 32);
558 seta[2] = oldset->sig[1];
559 case 1: seta[1] = (oldset->sig[0] >> 32);
560 seta[0] = oldset->sig[0];
561 }
562 err |= __put_user(seta[0], &sf->info.si_mask);
563 err |= __copy_to_user(sf->extramask, seta + 1,
564 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
565
566 if (!wsaved) {
567 err |= copy_in_user((u32 __user *)sf,
568 (u32 __user *)(regs->u_regs[UREG_FP]),
569 sizeof(struct reg_window32));
570 } else {
571 struct reg_window *rp;
572
573 rp = ¤t_thread_info()->reg_window[wsaved - 1];
574 for (i = 0; i < 8; i++)
575 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
576 for (i = 0; i < 6; i++)
577 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
578 err |= __put_user(rp->ins[6], &sf->ss.fp);
579 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
580 }
581 if (err)
582 goto sigsegv;
583
584 /* 3. signal handler back-trampoline and parameters */
585 regs->u_regs[UREG_FP] = (unsigned long) sf;
586 regs->u_regs[UREG_I0] = signo;
587 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
588 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
589
590 /* 4. signal handler */
591 regs->tpc = (unsigned long) ka->sa.sa_handler;
592 regs->tnpc = (regs->tpc + 4);
593 if (test_thread_flag(TIF_32BIT)) {
594 regs->tpc &= 0xffffffff;
595 regs->tnpc &= 0xffffffff;
596 }
597
598 /* 5. return to kernel instructions */
599 if (ka->ka_restorer) {
600 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
601 } else {
602 unsigned long address = ((unsigned long)&(sf->insns[0]));
603
604 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
605
606 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
607 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
608 if (err)
609 goto sigsegv;
610 flush_signal_insns(address);
611 }
612 return 0;
613
614sigill:
615 do_exit(SIGILL);
616 return -EINVAL;
617
618sigsegv:
619 force_sigsegv(signo, current);
620 return -EFAULT;
621}
622
623static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
624 unsigned long signr, sigset_t *oldset,
625 siginfo_t *info)
626{
627 struct rt_signal_frame32 __user *sf;
628 int i, err, wsaved;
629 void __user *tail;
630 int sigframe_size;
631 u32 psr;
632 compat_sigset_t seta;
633
634 /* 1. Make sure everything is clean */
635 synchronize_user_stack();
636 save_and_clear_fpu();
637
638 wsaved = get_thread_wsaved();
639
640 sigframe_size = sizeof(*sf);
641 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
642 sigframe_size += sizeof(__siginfo_fpu_t);
643 if (wsaved)
644 sigframe_size += sizeof(__siginfo_rwin_t);
645
646 sf = (struct rt_signal_frame32 __user *)
647 get_sigframe(&ka->sa, regs, sigframe_size);
648
649 if (invalid_frame_pointer(sf, sigframe_size))
650 goto sigill;
651
652 tail = (sf + 1);
653
654 /* 2. Save the current process state */
655 if (test_thread_flag(TIF_32BIT)) {
656 regs->tpc &= 0xffffffff;
657 regs->tnpc &= 0xffffffff;
658 }
659 err = put_user(regs->tpc, &sf->regs.pc);
660 err |= __put_user(regs->tnpc, &sf->regs.npc);
661 err |= __put_user(regs->y, &sf->regs.y);
662 psr = tstate_to_psr(regs->tstate);
663 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
664 psr |= PSR_EF;
665 err |= __put_user(psr, &sf->regs.psr);
666 for (i = 0; i < 16; i++)
667 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
668 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
669 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
670 for (i = 1; i < 16; i++)
671 err |= __put_user(((u32 *)regs->u_regs)[2*i],
672 &sf->v8plus.g_upper[i]);
673 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
674 &sf->v8plus.asi);
675
676 if (psr & PSR_EF) {
677 __siginfo_fpu_t __user *fp = tail;
678 tail += sizeof(*fp);
679 err |= save_fpu_state(regs, fp);
680 err |= __put_user((u64)fp, &sf->fpu_save);
681 } else {
682 err |= __put_user(0, &sf->fpu_save);
683 }
684 if (wsaved) {
685 __siginfo_rwin_t __user *rwp = tail;
686 tail += sizeof(*rwp);
687 err |= save_rwin_state(wsaved, rwp);
688 err |= __put_user((u64)rwp, &sf->rwin_save);
689 set_thread_wsaved(0);
690 } else {
691 err |= __put_user(0, &sf->rwin_save);
692 }
693
694 /* Update the siginfo structure. */
695 err |= copy_siginfo_to_user32(&sf->info, info);
696
697 /* Setup sigaltstack */
698 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
699 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
700 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
701
702 switch (_NSIG_WORDS) {
703 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
704 seta.sig[6] = oldset->sig[3];
705 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
706 seta.sig[4] = oldset->sig[2];
707 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
708 seta.sig[2] = oldset->sig[1];
709 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
710 seta.sig[0] = oldset->sig[0];
711 }
712 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
713
714 if (!wsaved) {
715 err |= copy_in_user((u32 __user *)sf,
716 (u32 __user *)(regs->u_regs[UREG_FP]),
717 sizeof(struct reg_window32));
718 } else {
719 struct reg_window *rp;
720
721 rp = ¤t_thread_info()->reg_window[wsaved - 1];
722 for (i = 0; i < 8; i++)
723 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
724 for (i = 0; i < 6; i++)
725 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
726 err |= __put_user(rp->ins[6], &sf->ss.fp);
727 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
728 }
729 if (err)
730 goto sigsegv;
731
732 /* 3. signal handler back-trampoline and parameters */
733 regs->u_regs[UREG_FP] = (unsigned long) sf;
734 regs->u_regs[UREG_I0] = signr;
735 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
736 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
737
738 /* 4. signal handler */
739 regs->tpc = (unsigned long) ka->sa.sa_handler;
740 regs->tnpc = (regs->tpc + 4);
741 if (test_thread_flag(TIF_32BIT)) {
742 regs->tpc &= 0xffffffff;
743 regs->tnpc &= 0xffffffff;
744 }
745
746 /* 5. return to kernel instructions */
747 if (ka->ka_restorer)
748 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
749 else {
750 unsigned long address = ((unsigned long)&(sf->insns[0]));
751
752 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
753
754 /* mov __NR_rt_sigreturn, %g1 */
755 err |= __put_user(0x82102065, &sf->insns[0]);
756
757 /* t 0x10 */
758 err |= __put_user(0x91d02010, &sf->insns[1]);
759 if (err)
760 goto sigsegv;
761
762 flush_signal_insns(address);
763 }
764 return 0;
765
766sigill:
767 do_exit(SIGILL);
768 return -EINVAL;
769
770sigsegv:
771 force_sigsegv(signr, current);
772 return -EFAULT;
773}
774
775static inline int handle_signal32(unsigned long signr, struct k_sigaction *ka,
776 siginfo_t *info,
777 sigset_t *oldset, struct pt_regs *regs)
778{
779 sigset_t blocked;
780 int err;
781
782 if (ka->sa.sa_flags & SA_SIGINFO)
783 err = setup_rt_frame32(ka, regs, signr, oldset, info);
784 else
785 err = setup_frame32(ka, regs, signr, oldset);
786
787 if (err)
788 return err;
789
790 sigorsets(&blocked, ¤t->blocked, &ka->sa.sa_mask);
791 if (!(ka->sa.sa_flags & SA_NOMASK))
792 sigaddset(&blocked, signr);
793 set_current_blocked(&blocked);
794
795 tracehook_signal_handler(signr, info, ka, regs, 0);
796
797 return 0;
798}
799
800static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
801 struct sigaction *sa)
802{
803 switch (regs->u_regs[UREG_I0]) {
804 case ERESTART_RESTARTBLOCK:
805 case ERESTARTNOHAND:
806 no_system_call_restart:
807 regs->u_regs[UREG_I0] = EINTR;
808 regs->tstate |= TSTATE_ICARRY;
809 break;
810 case ERESTARTSYS:
811 if (!(sa->sa_flags & SA_RESTART))
812 goto no_system_call_restart;
813 /* fallthrough */
814 case ERESTARTNOINTR:
815 regs->u_regs[UREG_I0] = orig_i0;
816 regs->tpc -= 4;
817 regs->tnpc -= 4;
818 }
819}
820
821/* Note that 'init' is a special process: it doesn't get signals it doesn't
822 * want to handle. Thus you cannot kill init even with a SIGKILL even by
823 * mistake.
824 */
825void do_signal32(sigset_t *oldset, struct pt_regs * regs,
826 int restart_syscall, unsigned long orig_i0)
827{
828 struct k_sigaction ka;
829 siginfo_t info;
830 int signr;
831
832 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
833
834 /* If the debugger messes with the program counter, it clears
835 * the "in syscall" bit, directing us to not perform a syscall
836 * restart.
837 */
838 if (restart_syscall && !pt_regs_is_syscall(regs))
839 restart_syscall = 0;
840
841 if (signr > 0) {
842 if (restart_syscall)
843 syscall_restart32(orig_i0, regs, &ka.sa);
844 if (handle_signal32(signr, &ka, &info, oldset, regs) == 0) {
845 /* A signal was successfully delivered; the saved
846 * sigmask will have been stored in the signal frame,
847 * and will be restored by sigreturn, so we can simply
848 * clear the TS_RESTORE_SIGMASK flag.
849 */
850 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
851 }
852 return;
853 }
854 if (restart_syscall &&
855 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
856 regs->u_regs[UREG_I0] == ERESTARTSYS ||
857 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
858 /* replay the system call when we are done */
859 regs->u_regs[UREG_I0] = orig_i0;
860 regs->tpc -= 4;
861 regs->tnpc -= 4;
862 pt_regs_clear_syscall(regs);
863 }
864 if (restart_syscall &&
865 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
866 regs->u_regs[UREG_G1] = __NR_restart_syscall;
867 regs->tpc -= 4;
868 regs->tnpc -= 4;
869 pt_regs_clear_syscall(regs);
870 }
871
872 /* If there's no signal to deliver, we just put the saved sigmask
873 * back
874 */
875 if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
876 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
877 set_current_blocked(¤t->saved_sigmask);
878 }
879}
880
881struct sigstack32 {
882 u32 the_stack;
883 int cur_status;
884};
885
886asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
887{
888 struct sigstack32 __user *ssptr =
889 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
890 struct sigstack32 __user *ossptr =
891 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
892 int ret = -EFAULT;
893
894 /* First see if old state is wanted. */
895 if (ossptr) {
896 if (put_user(current->sas_ss_sp + current->sas_ss_size,
897 &ossptr->the_stack) ||
898 __put_user(on_sig_stack(sp), &ossptr->cur_status))
899 goto out;
900 }
901
902 /* Now see if we want to update the new state. */
903 if (ssptr) {
904 u32 ss_sp;
905
906 if (get_user(ss_sp, &ssptr->the_stack))
907 goto out;
908
909 /* If the current stack was set with sigaltstack, don't
910 * swap stacks while we are on it.
911 */
912 ret = -EPERM;
913 if (current->sas_ss_sp && on_sig_stack(sp))
914 goto out;
915
916 /* Since we don't know the extent of the stack, and we don't
917 * track onstack-ness, but rather calculate it, we must
918 * presume a size. Ho hum this interface is lossy.
919 */
920 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
921 current->sas_ss_size = SIGSTKSZ;
922 }
923
924 ret = 0;
925out:
926 return ret;
927}
928
929asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
930{
931 stack_t uss, uoss;
932 u32 u_ss_sp = 0;
933 int ret;
934 mm_segment_t old_fs;
935 stack_t32 __user *uss32 = compat_ptr(ussa);
936 stack_t32 __user *uoss32 = compat_ptr(uossa);
937
938 if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
939 __get_user(uss.ss_flags, &uss32->ss_flags) ||
940 __get_user(uss.ss_size, &uss32->ss_size)))
941 return -EFAULT;
942 uss.ss_sp = compat_ptr(u_ss_sp);
943 old_fs = get_fs();
944 set_fs(KERNEL_DS);
945 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
946 uossa ? (stack_t __user *) &uoss : NULL, sp);
947 set_fs(old_fs);
948 if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
949 __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
950 __put_user(uoss.ss_size, &uoss32->ss_size)))
951 return -EFAULT;
952 return ret;
953}
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
39typedef struct {
40 unsigned int g_upper[8];
41 unsigned int o_upper[8];
42 unsigned int asi;
43} siginfo_extra_v8plus_t;
44
45struct 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
57struct 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 */
75static 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
83void 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
170segv:
171 force_sig(SIGSEGV);
172}
173
174asmlinkage 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;
256segv:
257 force_sig(SIGSEGV);
258}
259
260static 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 */
295static 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 if (!ptep)
332 goto out_irqs_on;
333 pte = *ptep;
334 if (!pte_present(pte))
335 goto out_unmap;
336
337 paddr = (unsigned long) page_address(pte_page(pte));
338
339 __asm__ __volatile__("flush %0 + %1"
340 : /* no outputs */
341 : "r" (paddr),
342 "r" (address & (PAGE_SIZE - 1))
343 : "memory");
344
345out_unmap:
346 pte_unmap(ptep);
347out_irqs_on:
348 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
349
350}
351
352static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs,
353 sigset_t *oldset)
354{
355 struct signal_frame32 __user *sf;
356 int i, err, wsaved;
357 void __user *tail;
358 int sigframe_size;
359 u32 psr;
360 compat_sigset_t seta;
361
362 /* 1. Make sure everything is clean */
363 synchronize_user_stack();
364 save_and_clear_fpu();
365
366 wsaved = get_thread_wsaved();
367
368 sigframe_size = sizeof(*sf);
369 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
370 sigframe_size += sizeof(__siginfo_fpu_t);
371 if (wsaved)
372 sigframe_size += sizeof(__siginfo_rwin_t);
373
374 sf = (struct signal_frame32 __user *)
375 get_sigframe(ksig, regs, sigframe_size);
376
377 if (invalid_frame_pointer(sf, sigframe_size)) {
378 if (show_unhandled_signals)
379 pr_info("%s[%d] bad frame in setup_frame32: %08lx TPC %08lx O7 %08lx\n",
380 current->comm, current->pid, (unsigned long)sf,
381 regs->tpc, regs->u_regs[UREG_I7]);
382 force_sigsegv(ksig->sig);
383 return -EINVAL;
384 }
385
386 tail = (sf + 1);
387
388 /* 2. Save the current process state */
389 if (test_thread_flag(TIF_32BIT)) {
390 regs->tpc &= 0xffffffff;
391 regs->tnpc &= 0xffffffff;
392 }
393 err = put_user(regs->tpc, &sf->info.si_regs.pc);
394 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
395 err |= __put_user(regs->y, &sf->info.si_regs.y);
396 psr = tstate_to_psr(regs->tstate);
397 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
398 psr |= PSR_EF;
399 err |= __put_user(psr, &sf->info.si_regs.psr);
400 for (i = 0; i < 16; i++)
401 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
402 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
403 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
404 for (i = 1; i < 16; i++)
405 err |= __put_user(((u32 *)regs->u_regs)[2*i],
406 &sf->v8plus.g_upper[i]);
407 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
408 &sf->v8plus.asi);
409
410 if (psr & PSR_EF) {
411 __siginfo_fpu_t __user *fp = tail;
412 tail += sizeof(*fp);
413 err |= save_fpu_state(regs, fp);
414 err |= __put_user((u64)fp, &sf->fpu_save);
415 } else {
416 err |= __put_user(0, &sf->fpu_save);
417 }
418 if (wsaved) {
419 __siginfo_rwin_t __user *rwp = tail;
420 tail += sizeof(*rwp);
421 err |= save_rwin_state(wsaved, rwp);
422 err |= __put_user((u64)rwp, &sf->rwin_save);
423 set_thread_wsaved(0);
424 } else {
425 err |= __put_user(0, &sf->rwin_save);
426 }
427
428 /* If these change we need to know - assignments to seta relies on these sizes */
429 BUILD_BUG_ON(_NSIG_WORDS != 1);
430 BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2);
431 seta.sig[1] = (oldset->sig[0] >> 32);
432 seta.sig[0] = oldset->sig[0];
433
434 err |= __put_user(seta.sig[0], &sf->info.si_mask);
435 err |= __copy_to_user(sf->extramask, &seta.sig[1],
436 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
437
438 if (!wsaved) {
439 err |= raw_copy_in_user((u32 __user *)sf,
440 (u32 __user *)(regs->u_regs[UREG_FP]),
441 sizeof(struct reg_window32));
442 } else {
443 struct reg_window *rp;
444
445 rp = ¤t_thread_info()->reg_window[wsaved - 1];
446 for (i = 0; i < 8; i++)
447 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
448 for (i = 0; i < 6; i++)
449 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
450 err |= __put_user(rp->ins[6], &sf->ss.fp);
451 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
452 }
453 if (err)
454 return err;
455
456 /* 3. signal handler back-trampoline and parameters */
457 regs->u_regs[UREG_FP] = (unsigned long) sf;
458 regs->u_regs[UREG_I0] = ksig->sig;
459 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
460 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
461
462 /* 4. signal handler */
463 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
464 regs->tnpc = (regs->tpc + 4);
465 if (test_thread_flag(TIF_32BIT)) {
466 regs->tpc &= 0xffffffff;
467 regs->tnpc &= 0xffffffff;
468 }
469
470 /* 5. return to kernel instructions */
471 if (ksig->ka.ka_restorer) {
472 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
473 } else {
474 unsigned long address = ((unsigned long)&(sf->insns[0]));
475
476 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
477
478 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
479 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
480 if (err)
481 return err;
482 flush_signal_insns(address);
483 }
484 return 0;
485}
486
487static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
488 sigset_t *oldset)
489{
490 struct rt_signal_frame32 __user *sf;
491 int i, err, wsaved;
492 void __user *tail;
493 int sigframe_size;
494 u32 psr;
495
496 /* 1. Make sure everything is clean */
497 synchronize_user_stack();
498 save_and_clear_fpu();
499
500 wsaved = get_thread_wsaved();
501
502 sigframe_size = sizeof(*sf);
503 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
504 sigframe_size += sizeof(__siginfo_fpu_t);
505 if (wsaved)
506 sigframe_size += sizeof(__siginfo_rwin_t);
507
508 sf = (struct rt_signal_frame32 __user *)
509 get_sigframe(ksig, regs, sigframe_size);
510
511 if (invalid_frame_pointer(sf, sigframe_size)) {
512 if (show_unhandled_signals)
513 pr_info("%s[%d] bad frame in setup_rt_frame32: %08lx TPC %08lx O7 %08lx\n",
514 current->comm, current->pid, (unsigned long)sf,
515 regs->tpc, regs->u_regs[UREG_I7]);
516 force_sigsegv(ksig->sig);
517 return -EINVAL;
518 }
519
520 tail = (sf + 1);
521
522 /* 2. Save the current process state */
523 if (test_thread_flag(TIF_32BIT)) {
524 regs->tpc &= 0xffffffff;
525 regs->tnpc &= 0xffffffff;
526 }
527 err = put_user(regs->tpc, &sf->regs.pc);
528 err |= __put_user(regs->tnpc, &sf->regs.npc);
529 err |= __put_user(regs->y, &sf->regs.y);
530 psr = tstate_to_psr(regs->tstate);
531 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
532 psr |= PSR_EF;
533 err |= __put_user(psr, &sf->regs.psr);
534 for (i = 0; i < 16; i++)
535 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
536 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
537 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
538 for (i = 1; i < 16; i++)
539 err |= __put_user(((u32 *)regs->u_regs)[2*i],
540 &sf->v8plus.g_upper[i]);
541 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
542 &sf->v8plus.asi);
543
544 if (psr & PSR_EF) {
545 __siginfo_fpu_t __user *fp = tail;
546 tail += sizeof(*fp);
547 err |= save_fpu_state(regs, fp);
548 err |= __put_user((u64)fp, &sf->fpu_save);
549 } else {
550 err |= __put_user(0, &sf->fpu_save);
551 }
552 if (wsaved) {
553 __siginfo_rwin_t __user *rwp = tail;
554 tail += sizeof(*rwp);
555 err |= save_rwin_state(wsaved, rwp);
556 err |= __put_user((u64)rwp, &sf->rwin_save);
557 set_thread_wsaved(0);
558 } else {
559 err |= __put_user(0, &sf->rwin_save);
560 }
561
562 /* Update the siginfo structure. */
563 err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
564
565 /* Setup sigaltstack */
566 err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
567
568 err |= put_compat_sigset(&sf->mask, oldset, sizeof(compat_sigset_t));
569
570 if (!wsaved) {
571 err |= raw_copy_in_user((u32 __user *)sf,
572 (u32 __user *)(regs->u_regs[UREG_FP]),
573 sizeof(struct reg_window32));
574 } else {
575 struct reg_window *rp;
576
577 rp = ¤t_thread_info()->reg_window[wsaved - 1];
578 for (i = 0; i < 8; i++)
579 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
580 for (i = 0; i < 6; i++)
581 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
582 err |= __put_user(rp->ins[6], &sf->ss.fp);
583 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
584 }
585 if (err)
586 return err;
587
588 /* 3. signal handler back-trampoline and parameters */
589 regs->u_regs[UREG_FP] = (unsigned long) sf;
590 regs->u_regs[UREG_I0] = ksig->sig;
591 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
592 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
593
594 /* 4. signal handler */
595 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
596 regs->tnpc = (regs->tpc + 4);
597 if (test_thread_flag(TIF_32BIT)) {
598 regs->tpc &= 0xffffffff;
599 regs->tnpc &= 0xffffffff;
600 }
601
602 /* 5. return to kernel instructions */
603 if (ksig->ka.ka_restorer)
604 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
605 else {
606 unsigned long address = ((unsigned long)&(sf->insns[0]));
607
608 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
609
610 /* mov __NR_rt_sigreturn, %g1 */
611 err |= __put_user(0x82102065, &sf->insns[0]);
612
613 /* t 0x10 */
614 err |= __put_user(0x91d02010, &sf->insns[1]);
615 if (err)
616 return err;
617
618 flush_signal_insns(address);
619 }
620 return 0;
621}
622
623static inline void handle_signal32(struct ksignal *ksig,
624 struct pt_regs *regs)
625{
626 sigset_t *oldset = sigmask_to_save();
627 int err;
628
629 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
630 err = setup_rt_frame32(ksig, regs, oldset);
631 else
632 err = setup_frame32(ksig, regs, oldset);
633
634 signal_setup_done(err, ksig, 0);
635}
636
637static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
638 struct sigaction *sa)
639{
640 switch (regs->u_regs[UREG_I0]) {
641 case ERESTART_RESTARTBLOCK:
642 case ERESTARTNOHAND:
643 no_system_call_restart:
644 regs->u_regs[UREG_I0] = EINTR;
645 regs->tstate |= TSTATE_ICARRY;
646 break;
647 case ERESTARTSYS:
648 if (!(sa->sa_flags & SA_RESTART))
649 goto no_system_call_restart;
650 fallthrough;
651 case ERESTARTNOINTR:
652 regs->u_regs[UREG_I0] = orig_i0;
653 regs->tpc -= 4;
654 regs->tnpc -= 4;
655 }
656}
657
658/* Note that 'init' is a special process: it doesn't get signals it doesn't
659 * want to handle. Thus you cannot kill init even with a SIGKILL even by
660 * mistake.
661 */
662void do_signal32(struct pt_regs * regs)
663{
664 struct ksignal ksig;
665 unsigned long orig_i0 = 0;
666 int restart_syscall = 0;
667 bool has_handler = get_signal(&ksig);
668
669 if (pt_regs_is_syscall(regs) &&
670 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
671 restart_syscall = 1;
672 orig_i0 = regs->u_regs[UREG_G6];
673 }
674
675 if (has_handler) {
676 if (restart_syscall)
677 syscall_restart32(orig_i0, regs, &ksig.ka.sa);
678 handle_signal32(&ksig, regs);
679 } else {
680 if (restart_syscall) {
681 switch (regs->u_regs[UREG_I0]) {
682 case ERESTARTNOHAND:
683 case ERESTARTSYS:
684 case ERESTARTNOINTR:
685 /* replay the system call when we are done */
686 regs->u_regs[UREG_I0] = orig_i0;
687 regs->tpc -= 4;
688 regs->tnpc -= 4;
689 pt_regs_clear_syscall(regs);
690 fallthrough;
691 case ERESTART_RESTARTBLOCK:
692 regs->u_regs[UREG_G1] = __NR_restart_syscall;
693 regs->tpc -= 4;
694 regs->tnpc -= 4;
695 pt_regs_clear_syscall(regs);
696 }
697 }
698 restore_saved_sigmask();
699 }
700}
701
702struct sigstack32 {
703 u32 the_stack;
704 int cur_status;
705};
706
707asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
708{
709 struct sigstack32 __user *ssptr =
710 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
711 struct sigstack32 __user *ossptr =
712 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
713 int ret = -EFAULT;
714
715 /* First see if old state is wanted. */
716 if (ossptr) {
717 if (put_user(current->sas_ss_sp + current->sas_ss_size,
718 &ossptr->the_stack) ||
719 __put_user(on_sig_stack(sp), &ossptr->cur_status))
720 goto out;
721 }
722
723 /* Now see if we want to update the new state. */
724 if (ssptr) {
725 u32 ss_sp;
726
727 if (get_user(ss_sp, &ssptr->the_stack))
728 goto out;
729
730 /* If the current stack was set with sigaltstack, don't
731 * swap stacks while we are on it.
732 */
733 ret = -EPERM;
734 if (current->sas_ss_sp && on_sig_stack(sp))
735 goto out;
736
737 /* Since we don't know the extent of the stack, and we don't
738 * track onstack-ness, but rather calculate it, we must
739 * presume a size. Ho hum this interface is lossy.
740 */
741 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
742 current->sas_ss_size = SIGSTKSZ;
743 }
744
745 ret = 0;
746out:
747 return ret;
748}
749
750/*
751 * Compile-time assertions for siginfo_t offsets. Check NSIG* as well, as
752 * changes likely come with new fields that should be added below.
753 */
754static_assert(NSIGILL == 11);
755static_assert(NSIGFPE == 15);
756static_assert(NSIGSEGV == 10);
757static_assert(NSIGBUS == 5);
758static_assert(NSIGTRAP == 6);
759static_assert(NSIGCHLD == 6);
760static_assert(NSIGSYS == 2);
761static_assert(sizeof(compat_siginfo_t) == 128);
762static_assert(__alignof__(compat_siginfo_t) == 4);
763static_assert(offsetof(compat_siginfo_t, si_signo) == 0x00);
764static_assert(offsetof(compat_siginfo_t, si_errno) == 0x04);
765static_assert(offsetof(compat_siginfo_t, si_code) == 0x08);
766static_assert(offsetof(compat_siginfo_t, si_pid) == 0x0c);
767static_assert(offsetof(compat_siginfo_t, si_uid) == 0x10);
768static_assert(offsetof(compat_siginfo_t, si_tid) == 0x0c);
769static_assert(offsetof(compat_siginfo_t, si_overrun) == 0x10);
770static_assert(offsetof(compat_siginfo_t, si_status) == 0x14);
771static_assert(offsetof(compat_siginfo_t, si_utime) == 0x18);
772static_assert(offsetof(compat_siginfo_t, si_stime) == 0x1c);
773static_assert(offsetof(compat_siginfo_t, si_value) == 0x14);
774static_assert(offsetof(compat_siginfo_t, si_int) == 0x14);
775static_assert(offsetof(compat_siginfo_t, si_ptr) == 0x14);
776static_assert(offsetof(compat_siginfo_t, si_addr) == 0x0c);
777static_assert(offsetof(compat_siginfo_t, si_trapno) == 0x10);
778static_assert(offsetof(compat_siginfo_t, si_addr_lsb) == 0x10);
779static_assert(offsetof(compat_siginfo_t, si_lower) == 0x14);
780static_assert(offsetof(compat_siginfo_t, si_upper) == 0x18);
781static_assert(offsetof(compat_siginfo_t, si_pkey) == 0x14);
782static_assert(offsetof(compat_siginfo_t, si_perf_data) == 0x10);
783static_assert(offsetof(compat_siginfo_t, si_perf_type) == 0x14);
784static_assert(offsetof(compat_siginfo_t, si_perf_flags) == 0x18);
785static_assert(offsetof(compat_siginfo_t, si_band) == 0x0c);
786static_assert(offsetof(compat_siginfo_t, si_fd) == 0x10);