1 // SPDX-License-Identifier: GPL-2.0
2 /* arch/sparc64/kernel/signal32.c
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)
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>
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>
25 #include <linux/uaccess.h>
26 #include <asm/ptrace.h>
27 #include <asm/pgtable.h>
28 #include <asm/psrcompat.h>
29 #include <asm/fpumacro.h>
30 #include <asm/visasm.h>
31 #include <asm/compat_signal.h>
32 #include <asm/switch_to.h>
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 struct rt_signal_frame32 {
60 struct sparc_stackf32 ss;
61 compat_siginfo_t info;
62 struct pt_regs32 regs;
64 /* __siginfo_fpu_t * */ u32 fpu_save;
65 unsigned int insns[2];
67 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
68 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
69 siginfo_extra_v8plus_t v8plus;
70 /* __siginfo_rwin_t * */u32 rwin_save;
71 } __attribute__((aligned(8)));
73 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
77 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
80 /* If you change siginfo_t structure, please be sure
81 this code is fixed accordingly.
82 It should never copy any pad contained in the structure
83 to avoid security leaks, but must copy the generic
84 3 ints plus the relevant union member.
85 This routine must convert siginfo from 64bit to 32bit as well
87 err = __put_user(from->si_signo, &to->si_signo);
88 err |= __put_user(from->si_errno, &to->si_errno);
89 err |= __put_user(from->si_code, &to->si_code);
90 if (from->si_code < 0)
91 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
93 switch (siginfo_layout(from->si_signo, from->si_code)) {
95 err |= __put_user(from->si_tid, &to->si_tid);
96 err |= __put_user(from->si_overrun, &to->si_overrun);
97 err |= __put_user(from->si_int, &to->si_int);
100 err |= __put_user(from->si_utime, &to->si_utime);
101 err |= __put_user(from->si_stime, &to->si_stime);
102 err |= __put_user(from->si_status, &to->si_status);
105 err |= __put_user(from->si_pid, &to->si_pid);
106 err |= __put_user(from->si_uid, &to->si_uid);
109 err |= __put_user(from->si_trapno, &to->si_trapno);
110 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
113 err |= __put_user(from->si_band, &to->si_band);
114 err |= __put_user(from->si_fd, &to->si_fd);
117 err |= __put_user(from->si_pid, &to->si_pid);
118 err |= __put_user(from->si_uid, &to->si_uid);
119 err |= __put_user(from->si_int, &to->si_int);
126 /* CAUTION: This is just a very minimalist implementation for the
127 * sake of compat_sys_rt_sigqueueinfo()
129 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
131 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
134 if (copy_from_user(to, from, 3*sizeof(int)) ||
135 copy_from_user(to->_sifields._pad, from->_sifields._pad,
142 /* Checks if the fp is valid. We always build signal frames which are
143 * 16-byte aligned, therefore we can always enforce that the restore
144 * frame has that property as well.
146 static bool invalid_frame_pointer(void __user *fp, int fplen)
148 if ((((unsigned long) fp) & 15) ||
149 ((unsigned long)fp) > 0x100000000ULL - fplen)
154 void do_sigreturn32(struct pt_regs *regs)
156 struct signal_frame32 __user *sf;
157 compat_uptr_t fpu_save;
158 compat_uptr_t rwin_save;
159 unsigned int psr, ufp;
160 unsigned int pc, npc;
162 compat_sigset_t seta;
165 /* Always make any pending restarted system calls return -EINTR */
166 current->restart_block.fn = do_no_restart_syscall;
168 synchronize_user_stack();
170 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
171 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
173 /* 1. Make sure we are not getting garbage from the user */
174 if (invalid_frame_pointer(sf, sizeof(*sf)))
177 if (get_user(ufp, &sf->info.si_regs.u_regs[UREG_FP]))
183 if (__get_user(pc, &sf->info.si_regs.pc) ||
184 __get_user(npc, &sf->info.si_regs.npc))
190 if (test_thread_flag(TIF_32BIT)) {
197 /* 2. Restore the state */
198 err = __get_user(regs->y, &sf->info.si_regs.y);
199 err |= __get_user(psr, &sf->info.si_regs.psr);
201 for (i = UREG_G1; i <= UREG_I7; i++)
202 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
203 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
204 err |= __get_user(i, &sf->v8plus.g_upper[0]);
205 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
208 for (i = UREG_G1; i <= UREG_I7; i++)
209 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
210 err |= __get_user(asi, &sf->v8plus.asi);
211 regs->tstate &= ~TSTATE_ASI;
212 regs->tstate |= ((asi & 0xffUL) << 24UL);
216 /* User can only change condition codes in %tstate. */
217 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
218 regs->tstate |= psr_to_tstate_icc(psr);
220 /* Prevent syscall restart. */
221 pt_regs_clear_syscall(regs);
223 err |= __get_user(fpu_save, &sf->fpu_save);
224 if (!err && fpu_save)
225 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
226 err |= __get_user(rwin_save, &sf->rwin_save);
227 if (!err && rwin_save) {
228 if (restore_rwin_state(compat_ptr(rwin_save)))
231 err |= __get_user(seta.sig[0], &sf->info.si_mask);
232 err |= copy_from_user(&seta.sig[1], &sf->extramask,
233 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
237 set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
238 set_current_blocked(&set);
242 force_sig(SIGSEGV, current);
245 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
247 struct rt_signal_frame32 __user *sf;
248 unsigned int psr, pc, npc, ufp;
249 compat_uptr_t fpu_save;
250 compat_uptr_t rwin_save;
252 compat_sigset_t seta;
255 /* Always make any pending restarted system calls return -EINTR */
256 current->restart_block.fn = do_no_restart_syscall;
258 synchronize_user_stack();
259 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
260 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
262 /* 1. Make sure we are not getting garbage from the user */
263 if (invalid_frame_pointer(sf, sizeof(*sf)))
266 if (get_user(ufp, &sf->regs.u_regs[UREG_FP]))
272 if (__get_user(pc, &sf->regs.pc) ||
273 __get_user(npc, &sf->regs.npc))
279 if (test_thread_flag(TIF_32BIT)) {
286 /* 2. Restore the state */
287 err = __get_user(regs->y, &sf->regs.y);
288 err |= __get_user(psr, &sf->regs.psr);
290 for (i = UREG_G1; i <= UREG_I7; i++)
291 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
292 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
293 err |= __get_user(i, &sf->v8plus.g_upper[0]);
294 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
297 for (i = UREG_G1; i <= UREG_I7; i++)
298 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
299 err |= __get_user(asi, &sf->v8plus.asi);
300 regs->tstate &= ~TSTATE_ASI;
301 regs->tstate |= ((asi & 0xffUL) << 24UL);
305 /* User can only change condition codes in %tstate. */
306 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
307 regs->tstate |= psr_to_tstate_icc(psr);
309 /* Prevent syscall restart. */
310 pt_regs_clear_syscall(regs);
312 err |= __get_user(fpu_save, &sf->fpu_save);
313 if (!err && fpu_save)
314 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
315 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
316 err |= compat_restore_altstack(&sf->stack);
320 err |= __get_user(rwin_save, &sf->rwin_save);
321 if (!err && rwin_save) {
322 if (restore_rwin_state(compat_ptr(rwin_save)))
326 set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
327 set_current_blocked(&set);
330 force_sig(SIGSEGV, current);
333 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
337 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
338 sp = regs->u_regs[UREG_FP];
341 * If we are on the alternate signal stack and would overflow it, don't.
342 * Return an always-bogus address instead so we will die with SIGSEGV.
344 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
345 return (void __user *) -1L;
347 /* This is the X/Open sanctioned signal stack switching. */
348 sp = sigsp(sp, ksig) - framesize;
350 /* Always align the stack frame. This handles two cases. First,
351 * sigaltstack need not be mindful of platform specific stack
352 * alignment. Second, if we took this signal because the stack
353 * is not aligned properly, we'd like to take the signal cleanly
358 return (void __user *) sp;
361 /* The I-cache flush instruction only works in the primary ASI, which
362 * right now is the nucleus, aka. kernel space.
364 * Therefore we have to kick the instructions out using the kernel
365 * side linear mapping of the physical address backing the user
368 static void flush_signal_insns(unsigned long address)
370 unsigned long pstate, paddr;
376 /* Commit all stores of the instructions we are about to flush. */
379 /* Disable cross-call reception. In this way even a very wide
380 * munmap() on another cpu can't tear down the page table
381 * hierarchy from underneath us, since that can't complete
382 * until the IPI tlb flush returns.
385 __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
386 __asm__ __volatile__("wrpr %0, %1, %%pstate"
387 : : "r" (pstate), "i" (PSTATE_IE));
389 pgdp = pgd_offset(current->mm, address);
392 pudp = pud_offset(pgdp, address);
395 pmdp = pmd_offset(pudp, address);
399 ptep = pte_offset_map(pmdp, address);
401 if (!pte_present(pte))
404 paddr = (unsigned long) page_address(pte_page(pte));
406 __asm__ __volatile__("flush %0 + %1"
409 "r" (address & (PAGE_SIZE - 1))
415 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
419 static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs,
422 struct signal_frame32 __user *sf;
427 compat_sigset_t seta;
429 /* 1. Make sure everything is clean */
430 synchronize_user_stack();
431 save_and_clear_fpu();
433 wsaved = get_thread_wsaved();
435 sigframe_size = sizeof(*sf);
436 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
437 sigframe_size += sizeof(__siginfo_fpu_t);
439 sigframe_size += sizeof(__siginfo_rwin_t);
441 sf = (struct signal_frame32 __user *)
442 get_sigframe(ksig, regs, sigframe_size);
444 if (invalid_frame_pointer(sf, sigframe_size)) {
451 /* 2. Save the current process state */
452 if (test_thread_flag(TIF_32BIT)) {
453 regs->tpc &= 0xffffffff;
454 regs->tnpc &= 0xffffffff;
456 err = put_user(regs->tpc, &sf->info.si_regs.pc);
457 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
458 err |= __put_user(regs->y, &sf->info.si_regs.y);
459 psr = tstate_to_psr(regs->tstate);
460 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
462 err |= __put_user(psr, &sf->info.si_regs.psr);
463 for (i = 0; i < 16; i++)
464 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
465 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
466 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
467 for (i = 1; i < 16; i++)
468 err |= __put_user(((u32 *)regs->u_regs)[2*i],
469 &sf->v8plus.g_upper[i]);
470 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
474 __siginfo_fpu_t __user *fp = tail;
476 err |= save_fpu_state(regs, fp);
477 err |= __put_user((u64)fp, &sf->fpu_save);
479 err |= __put_user(0, &sf->fpu_save);
482 __siginfo_rwin_t __user *rwp = tail;
483 tail += sizeof(*rwp);
484 err |= save_rwin_state(wsaved, rwp);
485 err |= __put_user((u64)rwp, &sf->rwin_save);
486 set_thread_wsaved(0);
488 err |= __put_user(0, &sf->rwin_save);
491 /* If these change we need to know - assignments to seta relies on these sizes */
492 BUILD_BUG_ON(_NSIG_WORDS != 1);
493 BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2);
494 seta.sig[1] = (oldset->sig[0] >> 32);
495 seta.sig[0] = oldset->sig[0];
497 err |= __put_user(seta.sig[0], &sf->info.si_mask);
498 err |= __copy_to_user(sf->extramask, &seta.sig[1],
499 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
502 err |= copy_in_user((u32 __user *)sf,
503 (u32 __user *)(regs->u_regs[UREG_FP]),
504 sizeof(struct reg_window32));
506 struct reg_window *rp;
508 rp = ¤t_thread_info()->reg_window[wsaved - 1];
509 for (i = 0; i < 8; i++)
510 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
511 for (i = 0; i < 6; i++)
512 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
513 err |= __put_user(rp->ins[6], &sf->ss.fp);
514 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
519 /* 3. signal handler back-trampoline and parameters */
520 regs->u_regs[UREG_FP] = (unsigned long) sf;
521 regs->u_regs[UREG_I0] = ksig->sig;
522 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
523 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
525 /* 4. signal handler */
526 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
527 regs->tnpc = (regs->tpc + 4);
528 if (test_thread_flag(TIF_32BIT)) {
529 regs->tpc &= 0xffffffff;
530 regs->tnpc &= 0xffffffff;
533 /* 5. return to kernel instructions */
534 if (ksig->ka.ka_restorer) {
535 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
537 unsigned long address = ((unsigned long)&(sf->insns[0]));
539 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
541 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
542 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
545 flush_signal_insns(address);
550 static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
553 struct rt_signal_frame32 __user *sf;
558 compat_sigset_t seta;
560 /* 1. Make sure everything is clean */
561 synchronize_user_stack();
562 save_and_clear_fpu();
564 wsaved = get_thread_wsaved();
566 sigframe_size = sizeof(*sf);
567 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
568 sigframe_size += sizeof(__siginfo_fpu_t);
570 sigframe_size += sizeof(__siginfo_rwin_t);
572 sf = (struct rt_signal_frame32 __user *)
573 get_sigframe(ksig, regs, sigframe_size);
575 if (invalid_frame_pointer(sf, sigframe_size)) {
582 /* 2. Save the current process state */
583 if (test_thread_flag(TIF_32BIT)) {
584 regs->tpc &= 0xffffffff;
585 regs->tnpc &= 0xffffffff;
587 err = put_user(regs->tpc, &sf->regs.pc);
588 err |= __put_user(regs->tnpc, &sf->regs.npc);
589 err |= __put_user(regs->y, &sf->regs.y);
590 psr = tstate_to_psr(regs->tstate);
591 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
593 err |= __put_user(psr, &sf->regs.psr);
594 for (i = 0; i < 16; i++)
595 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
596 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
597 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
598 for (i = 1; i < 16; i++)
599 err |= __put_user(((u32 *)regs->u_regs)[2*i],
600 &sf->v8plus.g_upper[i]);
601 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
605 __siginfo_fpu_t __user *fp = tail;
607 err |= save_fpu_state(regs, fp);
608 err |= __put_user((u64)fp, &sf->fpu_save);
610 err |= __put_user(0, &sf->fpu_save);
613 __siginfo_rwin_t __user *rwp = tail;
614 tail += sizeof(*rwp);
615 err |= save_rwin_state(wsaved, rwp);
616 err |= __put_user((u64)rwp, &sf->rwin_save);
617 set_thread_wsaved(0);
619 err |= __put_user(0, &sf->rwin_save);
622 /* Update the siginfo structure. */
623 err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
625 /* Setup sigaltstack */
626 err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
628 seta.sig[1] = (oldset->sig[0] >> 32);
629 seta.sig[0] = oldset->sig[0];
630 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
633 err |= copy_in_user((u32 __user *)sf,
634 (u32 __user *)(regs->u_regs[UREG_FP]),
635 sizeof(struct reg_window32));
637 struct reg_window *rp;
639 rp = ¤t_thread_info()->reg_window[wsaved - 1];
640 for (i = 0; i < 8; i++)
641 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
642 for (i = 0; i < 6; i++)
643 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
644 err |= __put_user(rp->ins[6], &sf->ss.fp);
645 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
650 /* 3. signal handler back-trampoline and parameters */
651 regs->u_regs[UREG_FP] = (unsigned long) sf;
652 regs->u_regs[UREG_I0] = ksig->sig;
653 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
654 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
656 /* 4. signal handler */
657 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
658 regs->tnpc = (regs->tpc + 4);
659 if (test_thread_flag(TIF_32BIT)) {
660 regs->tpc &= 0xffffffff;
661 regs->tnpc &= 0xffffffff;
664 /* 5. return to kernel instructions */
665 if (ksig->ka.ka_restorer)
666 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
668 unsigned long address = ((unsigned long)&(sf->insns[0]));
670 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
672 /* mov __NR_rt_sigreturn, %g1 */
673 err |= __put_user(0x82102065, &sf->insns[0]);
676 err |= __put_user(0x91d02010, &sf->insns[1]);
680 flush_signal_insns(address);
685 static inline void handle_signal32(struct ksignal *ksig,
686 struct pt_regs *regs)
688 sigset_t *oldset = sigmask_to_save();
691 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
692 err = setup_rt_frame32(ksig, regs, oldset);
694 err = setup_frame32(ksig, regs, oldset);
696 signal_setup_done(err, ksig, 0);
699 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
700 struct sigaction *sa)
702 switch (regs->u_regs[UREG_I0]) {
703 case ERESTART_RESTARTBLOCK:
705 no_system_call_restart:
706 regs->u_regs[UREG_I0] = EINTR;
707 regs->tstate |= TSTATE_ICARRY;
710 if (!(sa->sa_flags & SA_RESTART))
711 goto no_system_call_restart;
714 regs->u_regs[UREG_I0] = orig_i0;
720 /* Note that 'init' is a special process: it doesn't get signals it doesn't
721 * want to handle. Thus you cannot kill init even with a SIGKILL even by
724 void do_signal32(struct pt_regs * regs)
727 unsigned long orig_i0 = 0;
728 int restart_syscall = 0;
729 bool has_handler = get_signal(&ksig);
731 if (pt_regs_is_syscall(regs) &&
732 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
734 orig_i0 = regs->u_regs[UREG_G6];
739 syscall_restart32(orig_i0, regs, &ksig.ka.sa);
740 handle_signal32(&ksig, regs);
742 if (restart_syscall) {
743 switch (regs->u_regs[UREG_I0]) {
747 /* replay the system call when we are done */
748 regs->u_regs[UREG_I0] = orig_i0;
751 pt_regs_clear_syscall(regs);
752 case ERESTART_RESTARTBLOCK:
753 regs->u_regs[UREG_G1] = __NR_restart_syscall;
756 pt_regs_clear_syscall(regs);
759 restore_saved_sigmask();
768 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
770 struct sigstack32 __user *ssptr =
771 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
772 struct sigstack32 __user *ossptr =
773 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
776 /* First see if old state is wanted. */
778 if (put_user(current->sas_ss_sp + current->sas_ss_size,
779 &ossptr->the_stack) ||
780 __put_user(on_sig_stack(sp), &ossptr->cur_status))
784 /* Now see if we want to update the new state. */
788 if (get_user(ss_sp, &ssptr->the_stack))
791 /* If the current stack was set with sigaltstack, don't
792 * swap stacks while we are on it.
795 if (current->sas_ss_sp && on_sig_stack(sp))
798 /* Since we don't know the extent of the stack, and we don't
799 * track onstack-ness, but rather calculate it, we must
800 * presume a size. Ho hum this interface is lossy.
802 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
803 current->sas_ss_size = SIGSTKSZ;