1 /* arch/sparc64/kernel/signal32.c
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)
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>
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>
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>
35 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
37 /* This magic should be in g_upper[0] for all upper parts
40 #define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
42 unsigned int g_upper[8];
43 unsigned int o_upper[8];
45 } siginfo_extra_v8plus_t;
47 struct signal_frame32 {
48 struct sparc_stackf32 ss;
50 /* __siginfo_fpu_t * */ u32 fpu_save;
51 unsigned int insns[2];
52 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
53 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
54 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
55 siginfo_extra_v8plus_t v8plus;
56 /* __siginfo_rwin_t * */u32 rwin_save;
57 } __attribute__((aligned(8)));
59 typedef struct compat_siginfo{
65 int _pad[SI_PAD_SIZE32];
69 compat_pid_t _pid; /* sender's pid */
70 unsigned int _uid; /* sender's uid */
75 compat_timer_t _tid; /* timer id */
76 int _overrun; /* overrun count */
77 compat_sigval_t _sigval; /* same as below */
78 int _sys_private; /* not to be passed to user */
81 /* POSIX.1b signals */
83 compat_pid_t _pid; /* sender's pid */
84 unsigned int _uid; /* sender's uid */
85 compat_sigval_t _sigval;
90 compat_pid_t _pid; /* which child */
91 unsigned int _uid; /* sender's uid */
92 int _status; /* exit code */
93 compat_clock_t _utime;
94 compat_clock_t _stime;
97 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
99 u32 _addr; /* faulting insn/memory ref. */
105 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
111 struct rt_signal_frame32 {
112 struct sparc_stackf32 ss;
113 compat_siginfo_t info;
114 struct pt_regs32 regs;
115 compat_sigset_t mask;
116 /* __siginfo_fpu_t * */ u32 fpu_save;
117 unsigned int insns[2];
119 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
120 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
121 siginfo_extra_v8plus_t v8plus;
122 /* __siginfo_rwin_t * */u32 rwin_save;
123 } __attribute__((aligned(8)));
125 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
129 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
132 /* If you change siginfo_t structure, please be sure
133 this code is fixed accordingly.
134 It should never copy any pad contained in the structure
135 to avoid security leaks, but must copy the generic
136 3 ints plus the relevant union member.
137 This routine must convert siginfo from 64bit to 32bit as well
139 err = __put_user(from->si_signo, &to->si_signo);
140 err |= __put_user(from->si_errno, &to->si_errno);
141 err |= __put_user((short)from->si_code, &to->si_code);
142 if (from->si_code < 0)
143 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
145 switch (from->si_code >> 16) {
146 case __SI_TIMER >> 16:
147 err |= __put_user(from->si_tid, &to->si_tid);
148 err |= __put_user(from->si_overrun, &to->si_overrun);
149 err |= __put_user(from->si_int, &to->si_int);
151 case __SI_CHLD >> 16:
152 err |= __put_user(from->si_utime, &to->si_utime);
153 err |= __put_user(from->si_stime, &to->si_stime);
154 err |= __put_user(from->si_status, &to->si_status);
156 err |= __put_user(from->si_pid, &to->si_pid);
157 err |= __put_user(from->si_uid, &to->si_uid);
159 case __SI_FAULT >> 16:
160 err |= __put_user(from->si_trapno, &to->si_trapno);
161 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
163 case __SI_POLL >> 16:
164 err |= __put_user(from->si_band, &to->si_band);
165 err |= __put_user(from->si_fd, &to->si_fd);
167 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
168 case __SI_MESGQ >> 16:
169 err |= __put_user(from->si_pid, &to->si_pid);
170 err |= __put_user(from->si_uid, &to->si_uid);
171 err |= __put_user(from->si_int, &to->si_int);
178 /* CAUTION: This is just a very minimalist implementation for the
179 * sake of compat_sys_rt_sigqueueinfo()
181 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
183 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
186 if (copy_from_user(to, from, 3*sizeof(int)) ||
187 copy_from_user(to->_sifields._pad, from->_sifields._pad,
194 void do_sigreturn32(struct pt_regs *regs)
196 struct signal_frame32 __user *sf;
197 compat_uptr_t fpu_save;
198 compat_uptr_t rwin_save;
202 unsigned seta[_COMPAT_NSIG_WORDS];
205 /* Always make any pending restarted system calls return -EINTR */
206 current_thread_info()->restart_block.fn = do_no_restart_syscall;
208 synchronize_user_stack();
210 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
211 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
213 /* 1. Make sure we are not getting garbage from the user */
214 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
215 (((unsigned long) sf) & 3))
218 if (get_user(pc, &sf->info.si_regs.pc) ||
219 __get_user(npc, &sf->info.si_regs.npc))
225 if (test_thread_flag(TIF_32BIT)) {
232 /* 2. Restore the state */
233 err = __get_user(regs->y, &sf->info.si_regs.y);
234 err |= __get_user(psr, &sf->info.si_regs.psr);
236 for (i = UREG_G1; i <= UREG_I7; i++)
237 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
238 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
239 err |= __get_user(i, &sf->v8plus.g_upper[0]);
240 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
243 for (i = UREG_G1; i <= UREG_I7; i++)
244 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
245 err |= __get_user(asi, &sf->v8plus.asi);
246 regs->tstate &= ~TSTATE_ASI;
247 regs->tstate |= ((asi & 0xffUL) << 24UL);
251 /* User can only change condition codes in %tstate. */
252 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
253 regs->tstate |= psr_to_tstate_icc(psr);
255 /* Prevent syscall restart. */
256 pt_regs_clear_syscall(regs);
258 err |= __get_user(fpu_save, &sf->fpu_save);
259 if (!err && fpu_save)
260 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
261 err |= __get_user(rwin_save, &sf->rwin_save);
262 if (!err && rwin_save) {
263 if (restore_rwin_state(compat_ptr(rwin_save)))
266 err |= __get_user(seta[0], &sf->info.si_mask);
267 err |= copy_from_user(seta+1, &sf->extramask,
268 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
271 switch (_NSIG_WORDS) {
272 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
273 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
274 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
275 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
277 sigdelsetmask(&set, ~_BLOCKABLE);
278 set_current_blocked(&set);
282 force_sig(SIGSEGV, current);
285 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
287 struct rt_signal_frame32 __user *sf;
288 unsigned int psr, pc, npc, u_ss_sp;
289 compat_uptr_t fpu_save;
290 compat_uptr_t rwin_save;
293 compat_sigset_t seta;
297 /* Always make any pending restarted system calls return -EINTR */
298 current_thread_info()->restart_block.fn = do_no_restart_syscall;
300 synchronize_user_stack();
301 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
302 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
304 /* 1. Make sure we are not getting garbage from the user */
305 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
306 (((unsigned long) sf) & 3))
309 if (get_user(pc, &sf->regs.pc) ||
310 __get_user(npc, &sf->regs.npc))
316 if (test_thread_flag(TIF_32BIT)) {
323 /* 2. Restore the state */
324 err = __get_user(regs->y, &sf->regs.y);
325 err |= __get_user(psr, &sf->regs.psr);
327 for (i = UREG_G1; i <= UREG_I7; i++)
328 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
329 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
330 err |= __get_user(i, &sf->v8plus.g_upper[0]);
331 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
334 for (i = UREG_G1; i <= UREG_I7; i++)
335 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
336 err |= __get_user(asi, &sf->v8plus.asi);
337 regs->tstate &= ~TSTATE_ASI;
338 regs->tstate |= ((asi & 0xffUL) << 24UL);
342 /* User can only change condition codes in %tstate. */
343 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
344 regs->tstate |= psr_to_tstate_icc(psr);
346 /* Prevent syscall restart. */
347 pt_regs_clear_syscall(regs);
349 err |= __get_user(fpu_save, &sf->fpu_save);
350 if (!err && fpu_save)
351 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
352 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
353 err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
354 st.ss_sp = compat_ptr(u_ss_sp);
355 err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
356 err |= __get_user(st.ss_size, &sf->stack.ss_size);
360 /* It is more difficult to avoid calling this function than to
361 call it and ignore errors. */
364 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
367 err |= __get_user(rwin_save, &sf->rwin_save);
368 if (!err && rwin_save) {
369 if (restore_rwin_state(compat_ptr(rwin_save)))
373 switch (_NSIG_WORDS) {
374 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
375 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
376 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
377 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
379 sigdelsetmask(&set, ~_BLOCKABLE);
380 set_current_blocked(&set);
383 force_sig(SIGSEGV, current);
386 /* Checks if the fp is valid */
387 static int invalid_frame_pointer(void __user *fp, int fplen)
389 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
394 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
398 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
399 sp = regs->u_regs[UREG_FP];
402 * If we are on the alternate signal stack and would overflow it, don't.
403 * Return an always-bogus address instead so we will die with SIGSEGV.
405 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
406 return (void __user *) -1L;
408 /* This is the X/Open sanctioned signal stack switching. */
409 if (sa->sa_flags & SA_ONSTACK) {
410 if (sas_ss_flags(sp) == 0)
411 sp = current->sas_ss_sp + current->sas_ss_size;
416 /* Always align the stack frame. This handles two cases. First,
417 * sigaltstack need not be mindful of platform specific stack
418 * alignment. Second, if we took this signal because the stack
419 * is not aligned properly, we'd like to take the signal cleanly
424 return (void __user *) sp;
427 /* The I-cache flush instruction only works in the primary ASI, which
428 * right now is the nucleus, aka. kernel space.
430 * Therefore we have to kick the instructions out using the kernel
431 * side linear mapping of the physical address backing the user
434 static void flush_signal_insns(unsigned long address)
436 unsigned long pstate, paddr;
442 /* Commit all stores of the instructions we are about to flush. */
445 /* Disable cross-call reception. In this way even a very wide
446 * munmap() on another cpu can't tear down the page table
447 * hierarchy from underneath us, since that can't complete
448 * until the IPI tlb flush returns.
451 __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
452 __asm__ __volatile__("wrpr %0, %1, %%pstate"
453 : : "r" (pstate), "i" (PSTATE_IE));
455 pgdp = pgd_offset(current->mm, address);
458 pudp = pud_offset(pgdp, address);
461 pmdp = pmd_offset(pudp, address);
465 ptep = pte_offset_map(pmdp, address);
467 if (!pte_present(pte))
470 paddr = (unsigned long) page_address(pte_page(pte));
472 __asm__ __volatile__("flush %0 + %1"
475 "r" (address & (PAGE_SIZE - 1))
481 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
485 static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
486 int signo, sigset_t *oldset)
488 struct signal_frame32 __user *sf;
493 unsigned int seta[_COMPAT_NSIG_WORDS];
495 /* 1. Make sure everything is clean */
496 synchronize_user_stack();
497 save_and_clear_fpu();
499 wsaved = get_thread_wsaved();
501 sigframe_size = sizeof(*sf);
502 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
503 sigframe_size += sizeof(__siginfo_fpu_t);
505 sigframe_size += sizeof(__siginfo_rwin_t);
507 sf = (struct signal_frame32 __user *)
508 get_sigframe(&ka->sa, regs, sigframe_size);
510 if (invalid_frame_pointer(sf, sigframe_size))
515 /* 2. Save the current process state */
516 if (test_thread_flag(TIF_32BIT)) {
517 regs->tpc &= 0xffffffff;
518 regs->tnpc &= 0xffffffff;
520 err = put_user(regs->tpc, &sf->info.si_regs.pc);
521 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
522 err |= __put_user(regs->y, &sf->info.si_regs.y);
523 psr = tstate_to_psr(regs->tstate);
524 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
526 err |= __put_user(psr, &sf->info.si_regs.psr);
527 for (i = 0; i < 16; i++)
528 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
529 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
530 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
531 for (i = 1; i < 16; i++)
532 err |= __put_user(((u32 *)regs->u_regs)[2*i],
533 &sf->v8plus.g_upper[i]);
534 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
538 __siginfo_fpu_t __user *fp = tail;
540 err |= save_fpu_state(regs, fp);
541 err |= __put_user((u64)fp, &sf->fpu_save);
543 err |= __put_user(0, &sf->fpu_save);
546 __siginfo_rwin_t __user *rwp = tail;
547 tail += sizeof(*rwp);
548 err |= save_rwin_state(wsaved, rwp);
549 err |= __put_user((u64)rwp, &sf->rwin_save);
550 set_thread_wsaved(0);
552 err |= __put_user(0, &sf->rwin_save);
555 switch (_NSIG_WORDS) {
556 case 4: seta[7] = (oldset->sig[3] >> 32);
557 seta[6] = oldset->sig[3];
558 case 3: seta[5] = (oldset->sig[2] >> 32);
559 seta[4] = oldset->sig[2];
560 case 2: seta[3] = (oldset->sig[1] >> 32);
561 seta[2] = oldset->sig[1];
562 case 1: seta[1] = (oldset->sig[0] >> 32);
563 seta[0] = oldset->sig[0];
565 err |= __put_user(seta[0], &sf->info.si_mask);
566 err |= __copy_to_user(sf->extramask, seta + 1,
567 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
570 err |= copy_in_user((u32 __user *)sf,
571 (u32 __user *)(regs->u_regs[UREG_FP]),
572 sizeof(struct reg_window32));
574 struct reg_window *rp;
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);
587 /* 3. signal handler back-trampoline and parameters */
588 regs->u_regs[UREG_FP] = (unsigned long) sf;
589 regs->u_regs[UREG_I0] = signo;
590 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
591 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
593 /* 4. signal handler */
594 regs->tpc = (unsigned long) 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;
601 /* 5. return to kernel instructions */
602 if (ka->ka_restorer) {
603 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
605 unsigned long address = ((unsigned long)&(sf->insns[0]));
607 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
609 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
610 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
613 flush_signal_insns(address);
622 force_sigsegv(signo, current);
626 static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
627 unsigned long signr, sigset_t *oldset,
630 struct rt_signal_frame32 __user *sf;
635 compat_sigset_t seta;
637 /* 1. Make sure everything is clean */
638 synchronize_user_stack();
639 save_and_clear_fpu();
641 wsaved = get_thread_wsaved();
643 sigframe_size = sizeof(*sf);
644 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
645 sigframe_size += sizeof(__siginfo_fpu_t);
647 sigframe_size += sizeof(__siginfo_rwin_t);
649 sf = (struct rt_signal_frame32 __user *)
650 get_sigframe(&ka->sa, regs, sigframe_size);
652 if (invalid_frame_pointer(sf, sigframe_size))
657 /* 2. Save the current process state */
658 if (test_thread_flag(TIF_32BIT)) {
659 regs->tpc &= 0xffffffff;
660 regs->tnpc &= 0xffffffff;
662 err = put_user(regs->tpc, &sf->regs.pc);
663 err |= __put_user(regs->tnpc, &sf->regs.npc);
664 err |= __put_user(regs->y, &sf->regs.y);
665 psr = tstate_to_psr(regs->tstate);
666 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
668 err |= __put_user(psr, &sf->regs.psr);
669 for (i = 0; i < 16; i++)
670 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
671 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
672 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
673 for (i = 1; i < 16; i++)
674 err |= __put_user(((u32 *)regs->u_regs)[2*i],
675 &sf->v8plus.g_upper[i]);
676 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
680 __siginfo_fpu_t __user *fp = tail;
682 err |= save_fpu_state(regs, fp);
683 err |= __put_user((u64)fp, &sf->fpu_save);
685 err |= __put_user(0, &sf->fpu_save);
688 __siginfo_rwin_t __user *rwp = tail;
689 tail += sizeof(*rwp);
690 err |= save_rwin_state(wsaved, rwp);
691 err |= __put_user((u64)rwp, &sf->rwin_save);
692 set_thread_wsaved(0);
694 err |= __put_user(0, &sf->rwin_save);
697 /* Update the siginfo structure. */
698 err |= copy_siginfo_to_user32(&sf->info, info);
700 /* Setup sigaltstack */
701 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
702 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
703 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
705 switch (_NSIG_WORDS) {
706 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
707 seta.sig[6] = oldset->sig[3];
708 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
709 seta.sig[4] = oldset->sig[2];
710 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
711 seta.sig[2] = oldset->sig[1];
712 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
713 seta.sig[0] = oldset->sig[0];
715 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
718 err |= copy_in_user((u32 __user *)sf,
719 (u32 __user *)(regs->u_regs[UREG_FP]),
720 sizeof(struct reg_window32));
722 struct reg_window *rp;
724 rp = ¤t_thread_info()->reg_window[wsaved - 1];
725 for (i = 0; i < 8; i++)
726 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
727 for (i = 0; i < 6; i++)
728 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
729 err |= __put_user(rp->ins[6], &sf->ss.fp);
730 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
735 /* 3. signal handler back-trampoline and parameters */
736 regs->u_regs[UREG_FP] = (unsigned long) sf;
737 regs->u_regs[UREG_I0] = signr;
738 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
739 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
741 /* 4. signal handler */
742 regs->tpc = (unsigned long) ka->sa.sa_handler;
743 regs->tnpc = (regs->tpc + 4);
744 if (test_thread_flag(TIF_32BIT)) {
745 regs->tpc &= 0xffffffff;
746 regs->tnpc &= 0xffffffff;
749 /* 5. return to kernel instructions */
751 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
753 unsigned long address = ((unsigned long)&(sf->insns[0]));
755 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
757 /* mov __NR_rt_sigreturn, %g1 */
758 err |= __put_user(0x82102065, &sf->insns[0]);
761 err |= __put_user(0x91d02010, &sf->insns[1]);
765 flush_signal_insns(address);
774 force_sigsegv(signr, current);
778 static inline int handle_signal32(unsigned long signr, struct k_sigaction *ka,
780 sigset_t *oldset, struct pt_regs *regs)
784 if (ka->sa.sa_flags & SA_SIGINFO)
785 err = setup_rt_frame32(ka, regs, signr, oldset, info);
787 err = setup_frame32(ka, regs, signr, oldset);
792 block_sigmask(ka, signr);
793 tracehook_signal_handler(signr, info, ka, regs, 0);
798 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
799 struct sigaction *sa)
801 switch (regs->u_regs[UREG_I0]) {
802 case ERESTART_RESTARTBLOCK:
804 no_system_call_restart:
805 regs->u_regs[UREG_I0] = EINTR;
806 regs->tstate |= TSTATE_ICARRY;
809 if (!(sa->sa_flags & SA_RESTART))
810 goto no_system_call_restart;
813 regs->u_regs[UREG_I0] = orig_i0;
819 /* Note that 'init' is a special process: it doesn't get signals it doesn't
820 * want to handle. Thus you cannot kill init even with a SIGKILL even by
823 void do_signal32(sigset_t *oldset, struct pt_regs * regs)
825 struct k_sigaction ka;
826 unsigned long orig_i0;
831 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
835 if (pt_regs_is_syscall(regs) &&
836 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
838 orig_i0 = regs->u_regs[UREG_G6];
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.
850 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
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;
862 pt_regs_clear_syscall(regs);
864 if (restart_syscall &&
865 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
866 regs->u_regs[UREG_G1] = __NR_restart_syscall;
869 pt_regs_clear_syscall(regs);
872 /* If there's no signal to deliver, we just put the saved sigmask
875 if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
876 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
877 set_current_blocked(¤t->saved_sigmask);
886 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
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));
894 /* First see if old state is wanted. */
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))
902 /* Now see if we want to update the new state. */
906 if (get_user(ss_sp, &ssptr->the_stack))
909 /* If the current stack was set with sigaltstack, don't
910 * swap stacks while we are on it.
913 if (current->sas_ss_sp && on_sig_stack(sp))
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.
920 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
921 current->sas_ss_size = SIGSTKSZ;
929 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
935 stack_t32 __user *uss32 = compat_ptr(ussa);
936 stack_t32 __user *uoss32 = compat_ptr(uossa);
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)))
942 uss.ss_sp = compat_ptr(u_ss_sp);
945 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
946 uossa ? (stack_t __user *) &uoss : NULL, sp);
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)))