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)) {
445 if (show_unhandled_signals)
446 pr_info("%s[%d] bad frame in setup_frame32: %08lx TPC %08lx O7 %08lx\n",
447 current->comm, current->pid, (unsigned long)sf,
448 regs->tpc, regs->u_regs[UREG_I7]);
449 force_sigsegv(ksig->sig, current);
455 /* 2. Save the current process state */
456 if (test_thread_flag(TIF_32BIT)) {
457 regs->tpc &= 0xffffffff;
458 regs->tnpc &= 0xffffffff;
460 err = put_user(regs->tpc, &sf->info.si_regs.pc);
461 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
462 err |= __put_user(regs->y, &sf->info.si_regs.y);
463 psr = tstate_to_psr(regs->tstate);
464 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
466 err |= __put_user(psr, &sf->info.si_regs.psr);
467 for (i = 0; i < 16; i++)
468 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
469 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
470 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
471 for (i = 1; i < 16; i++)
472 err |= __put_user(((u32 *)regs->u_regs)[2*i],
473 &sf->v8plus.g_upper[i]);
474 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
478 __siginfo_fpu_t __user *fp = tail;
480 err |= save_fpu_state(regs, fp);
481 err |= __put_user((u64)fp, &sf->fpu_save);
483 err |= __put_user(0, &sf->fpu_save);
486 __siginfo_rwin_t __user *rwp = tail;
487 tail += sizeof(*rwp);
488 err |= save_rwin_state(wsaved, rwp);
489 err |= __put_user((u64)rwp, &sf->rwin_save);
490 set_thread_wsaved(0);
492 err |= __put_user(0, &sf->rwin_save);
495 /* If these change we need to know - assignments to seta relies on these sizes */
496 BUILD_BUG_ON(_NSIG_WORDS != 1);
497 BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2);
498 seta.sig[1] = (oldset->sig[0] >> 32);
499 seta.sig[0] = oldset->sig[0];
501 err |= __put_user(seta.sig[0], &sf->info.si_mask);
502 err |= __copy_to_user(sf->extramask, &seta.sig[1],
503 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
506 err |= copy_in_user((u32 __user *)sf,
507 (u32 __user *)(regs->u_regs[UREG_FP]),
508 sizeof(struct reg_window32));
510 struct reg_window *rp;
512 rp = ¤t_thread_info()->reg_window[wsaved - 1];
513 for (i = 0; i < 8; i++)
514 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
515 for (i = 0; i < 6; i++)
516 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
517 err |= __put_user(rp->ins[6], &sf->ss.fp);
518 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
523 /* 3. signal handler back-trampoline and parameters */
524 regs->u_regs[UREG_FP] = (unsigned long) sf;
525 regs->u_regs[UREG_I0] = ksig->sig;
526 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
527 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
529 /* 4. signal handler */
530 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
531 regs->tnpc = (regs->tpc + 4);
532 if (test_thread_flag(TIF_32BIT)) {
533 regs->tpc &= 0xffffffff;
534 regs->tnpc &= 0xffffffff;
537 /* 5. return to kernel instructions */
538 if (ksig->ka.ka_restorer) {
539 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
541 unsigned long address = ((unsigned long)&(sf->insns[0]));
543 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
545 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
546 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
549 flush_signal_insns(address);
554 static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
557 struct rt_signal_frame32 __user *sf;
562 compat_sigset_t seta;
564 /* 1. Make sure everything is clean */
565 synchronize_user_stack();
566 save_and_clear_fpu();
568 wsaved = get_thread_wsaved();
570 sigframe_size = sizeof(*sf);
571 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
572 sigframe_size += sizeof(__siginfo_fpu_t);
574 sigframe_size += sizeof(__siginfo_rwin_t);
576 sf = (struct rt_signal_frame32 __user *)
577 get_sigframe(ksig, regs, sigframe_size);
579 if (invalid_frame_pointer(sf, sigframe_size)) {
580 if (show_unhandled_signals)
581 pr_info("%s[%d] bad frame in setup_rt_frame32: %08lx TPC %08lx O7 %08lx\n",
582 current->comm, current->pid, (unsigned long)sf,
583 regs->tpc, regs->u_regs[UREG_I7]);
584 force_sigsegv(ksig->sig, current);
590 /* 2. Save the current process state */
591 if (test_thread_flag(TIF_32BIT)) {
592 regs->tpc &= 0xffffffff;
593 regs->tnpc &= 0xffffffff;
595 err = put_user(regs->tpc, &sf->regs.pc);
596 err |= __put_user(regs->tnpc, &sf->regs.npc);
597 err |= __put_user(regs->y, &sf->regs.y);
598 psr = tstate_to_psr(regs->tstate);
599 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
601 err |= __put_user(psr, &sf->regs.psr);
602 for (i = 0; i < 16; i++)
603 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
604 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
605 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
606 for (i = 1; i < 16; i++)
607 err |= __put_user(((u32 *)regs->u_regs)[2*i],
608 &sf->v8plus.g_upper[i]);
609 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
613 __siginfo_fpu_t __user *fp = tail;
615 err |= save_fpu_state(regs, fp);
616 err |= __put_user((u64)fp, &sf->fpu_save);
618 err |= __put_user(0, &sf->fpu_save);
621 __siginfo_rwin_t __user *rwp = tail;
622 tail += sizeof(*rwp);
623 err |= save_rwin_state(wsaved, rwp);
624 err |= __put_user((u64)rwp, &sf->rwin_save);
625 set_thread_wsaved(0);
627 err |= __put_user(0, &sf->rwin_save);
630 /* Update the siginfo structure. */
631 err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
633 /* Setup sigaltstack */
634 err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
636 seta.sig[1] = (oldset->sig[0] >> 32);
637 seta.sig[0] = oldset->sig[0];
638 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
641 err |= copy_in_user((u32 __user *)sf,
642 (u32 __user *)(regs->u_regs[UREG_FP]),
643 sizeof(struct reg_window32));
645 struct reg_window *rp;
647 rp = ¤t_thread_info()->reg_window[wsaved - 1];
648 for (i = 0; i < 8; i++)
649 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
650 for (i = 0; i < 6; i++)
651 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
652 err |= __put_user(rp->ins[6], &sf->ss.fp);
653 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
658 /* 3. signal handler back-trampoline and parameters */
659 regs->u_regs[UREG_FP] = (unsigned long) sf;
660 regs->u_regs[UREG_I0] = ksig->sig;
661 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
662 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
664 /* 4. signal handler */
665 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
666 regs->tnpc = (regs->tpc + 4);
667 if (test_thread_flag(TIF_32BIT)) {
668 regs->tpc &= 0xffffffff;
669 regs->tnpc &= 0xffffffff;
672 /* 5. return to kernel instructions */
673 if (ksig->ka.ka_restorer)
674 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
676 unsigned long address = ((unsigned long)&(sf->insns[0]));
678 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
680 /* mov __NR_rt_sigreturn, %g1 */
681 err |= __put_user(0x82102065, &sf->insns[0]);
684 err |= __put_user(0x91d02010, &sf->insns[1]);
688 flush_signal_insns(address);
693 static inline void handle_signal32(struct ksignal *ksig,
694 struct pt_regs *regs)
696 sigset_t *oldset = sigmask_to_save();
699 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
700 err = setup_rt_frame32(ksig, regs, oldset);
702 err = setup_frame32(ksig, regs, oldset);
704 signal_setup_done(err, ksig, 0);
707 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
708 struct sigaction *sa)
710 switch (regs->u_regs[UREG_I0]) {
711 case ERESTART_RESTARTBLOCK:
713 no_system_call_restart:
714 regs->u_regs[UREG_I0] = EINTR;
715 regs->tstate |= TSTATE_ICARRY;
718 if (!(sa->sa_flags & SA_RESTART))
719 goto no_system_call_restart;
722 regs->u_regs[UREG_I0] = orig_i0;
728 /* Note that 'init' is a special process: it doesn't get signals it doesn't
729 * want to handle. Thus you cannot kill init even with a SIGKILL even by
732 void do_signal32(struct pt_regs * regs)
735 unsigned long orig_i0 = 0;
736 int restart_syscall = 0;
737 bool has_handler = get_signal(&ksig);
739 if (pt_regs_is_syscall(regs) &&
740 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
742 orig_i0 = regs->u_regs[UREG_G6];
747 syscall_restart32(orig_i0, regs, &ksig.ka.sa);
748 handle_signal32(&ksig, regs);
750 if (restart_syscall) {
751 switch (regs->u_regs[UREG_I0]) {
755 /* replay the system call when we are done */
756 regs->u_regs[UREG_I0] = orig_i0;
759 pt_regs_clear_syscall(regs);
760 case ERESTART_RESTARTBLOCK:
761 regs->u_regs[UREG_G1] = __NR_restart_syscall;
764 pt_regs_clear_syscall(regs);
767 restore_saved_sigmask();
776 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
778 struct sigstack32 __user *ssptr =
779 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
780 struct sigstack32 __user *ossptr =
781 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
784 /* First see if old state is wanted. */
786 if (put_user(current->sas_ss_sp + current->sas_ss_size,
787 &ossptr->the_stack) ||
788 __put_user(on_sig_stack(sp), &ossptr->cur_status))
792 /* Now see if we want to update the new state. */
796 if (get_user(ss_sp, &ssptr->the_stack))
799 /* If the current stack was set with sigaltstack, don't
800 * swap stacks while we are on it.
803 if (current->sas_ss_sp && on_sig_stack(sp))
806 /* Since we don't know the extent of the stack, and we don't
807 * track onstack-ness, but rather calculate it, we must
808 * presume a size. Ho hum this interface is lossy.
810 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
811 current->sas_ss_size = SIGSTKSZ;