1 /* $Id: signal32.c,v 1.74 2002/02/09 19:49:30 davem Exp $
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/smp_lock.h>
21 #include <linux/binfmts.h>
22 #include <linux/compat.h>
24 #include <asm/uaccess.h>
25 #include <asm/bitops.h>
26 #include <asm/ptrace.h>
28 #include <asm/pgtable.h>
29 #include <asm/psrcompat.h>
30 #include <asm/fpumacro.h>
31 #include <asm/visasm.h>
33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
35 int do_signal32(sigset_t *oldset, struct pt_regs *regs,
36 unsigned long orig_o0, int ret_from_syscall);
38 /* Signal frames: the original one (compatible with SunOS):
40 * Set up a signal frame... Make the stack look the way SunOS
41 * expects it to look which is basically:
43 * ---------------------------------- <-- %sp at signal time
46 * Ptr to sigcontext area above
48 * The signal number itself
50 * ---------------------------------- <-- New %sp
52 struct signal_sframe32 {
53 struct reg_window32 sig_window;
56 /* struct sigcontext32 * */ u32 sig_scptr;
58 struct sigcontext32 sig_context;
59 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
62 /* This magic should be in g_upper[0] for all upper parts
65 #define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
67 unsigned int g_upper[8];
68 unsigned int o_upper[8];
70 } siginfo_extra_v8plus_t;
73 * And the new one, intended to be used for Linux applications only
74 * (we have enough in there to work with clone).
75 * All the interesting bits are in the info field.
77 struct new_signal_frame32 {
78 struct sparc_stackf32 ss;
80 /* __siginfo_fpu32_t * */ u32 fpu_save;
81 unsigned int insns[2];
82 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
83 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
84 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
85 siginfo_extra_v8plus_t v8plus;
86 __siginfo_fpu_t fpu_state;
95 int _pad[SI_PAD_SIZE32];
99 compat_pid_t _pid; /* sender's pid */
100 unsigned int _uid; /* sender's uid */
103 /* POSIX.1b timers */
105 timer_t _tid; /* timer id */
106 int _overrun; /* overrun count */
107 sigval_t32 _sigval; /* same as below */
108 int _sys_private; /* not to be passed to user */
111 /* POSIX.1b signals */
113 compat_pid_t _pid; /* sender's pid */
114 unsigned int _uid; /* sender's uid */
120 compat_pid_t _pid; /* which child */
121 unsigned int _uid; /* sender's uid */
122 int _status; /* exit code */
123 compat_clock_t _utime;
124 compat_clock_t _stime;
127 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
129 u32 _addr; /* faulting insn/memory ref. */
135 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
141 struct rt_signal_frame32 {
142 struct sparc_stackf32 ss;
143 struct siginfo32 info;
144 struct pt_regs32 regs;
145 compat_sigset_t mask;
146 /* __siginfo_fpu32_t * */ u32 fpu_save;
147 unsigned int insns[2];
149 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
150 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
151 siginfo_extra_v8plus_t v8plus;
152 __siginfo_fpu_t fpu_state;
156 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe32) + 7) & (~7)))
157 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame32) + 7) & (~7)))
158 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
160 int copy_siginfo_to_user32(struct siginfo32 __user *to, siginfo_t *from)
164 if (!access_ok(VERIFY_WRITE, to, sizeof(struct siginfo32)))
167 /* If you change siginfo_t structure, please be sure
168 this code is fixed accordingly.
169 It should never copy any pad contained in the structure
170 to avoid security leaks, but must copy the generic
171 3 ints plus the relevant union member.
172 This routine must convert siginfo from 64bit to 32bit as well
174 err = __put_user(from->si_signo, &to->si_signo);
175 err |= __put_user(from->si_errno, &to->si_errno);
176 err |= __put_user((short)from->si_code, &to->si_code);
177 if (from->si_code < 0)
178 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
180 switch (from->si_code >> 16) {
181 case __SI_TIMER >> 16:
182 err |= __put_user(from->si_tid, &to->si_tid);
183 err |= __put_user(from->si_overrun, &to->si_overrun);
184 err |= __put_user(from->si_int, &to->si_int);
186 case __SI_CHLD >> 16:
187 err |= __put_user(from->si_utime, &to->si_utime);
188 err |= __put_user(from->si_stime, &to->si_stime);
189 err |= __put_user(from->si_status, &to->si_status);
191 err |= __put_user(from->si_pid, &to->si_pid);
192 err |= __put_user(from->si_uid, &to->si_uid);
194 case __SI_FAULT >> 16:
195 case __SI_POLL >> 16:
196 err |= __put_user(from->si_trapno, &to->si_trapno);
197 err |= __put_user((long)from->si_addr, &to->si_addr);
199 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
200 case __SI_MESGQ >> 16:
201 err |= __put_user(from->si_pid, &to->si_pid);
202 err |= __put_user(from->si_uid, &to->si_uid);
203 err |= __put_user(from->si_int, &to->si_int);
210 /* CAUTION: This is just a very minimalist implementation for the
211 * sake of compat_sys_rt_sigqueueinfo()
213 int copy_siginfo_to_kernel32(siginfo_t *to, struct siginfo32 __user *from)
215 if (!access_ok(VERIFY_WRITE, from, sizeof(struct siginfo32)))
218 if (copy_from_user(to, from, 3*sizeof(int)) ||
219 copy_from_user(to->_sifields._pad, from->_sifields._pad,
227 * atomically swap in the new signal mask, and wait for a signal.
228 * This is really tricky on the Sparc, watch out...
230 asmlinkage void _sigpause32_common(compat_old_sigset_t set, struct pt_regs *regs)
235 spin_lock_irq(¤t->sighand->siglock);
236 saveset = current->blocked;
237 siginitset(¤t->blocked, set);
239 spin_unlock_irq(¤t->sighand->siglock);
241 regs->tpc = regs->tnpc;
243 if (test_thread_flag(TIF_32BIT)) {
244 regs->tpc &= 0xffffffff;
245 regs->tnpc &= 0xffffffff;
248 /* Condition codes and return value where set here for sigpause,
249 * and so got used by setup_frame, which again causes sigreturn()
253 current->state = TASK_INTERRUPTIBLE;
256 * Return -EINTR and set condition code here,
257 * so the interrupted system call actually returns
260 regs->tstate |= TSTATE_ICARRY;
261 regs->u_regs[UREG_I0] = EINTR;
262 if (do_signal32(&saveset, regs, 0, 0))
267 asmlinkage void do_rt_sigsuspend32(u32 uset, size_t sigsetsize, struct pt_regs *regs)
269 sigset_t oldset, set;
270 compat_sigset_t set32;
272 /* XXX: Don't preclude handling different sized sigset_t's. */
273 if (((compat_size_t)sigsetsize) != sizeof(sigset_t)) {
274 regs->tstate |= TSTATE_ICARRY;
275 regs->u_regs[UREG_I0] = EINVAL;
278 if (copy_from_user(&set32, (void __user *)(long)uset, sizeof(set32))) {
279 regs->tstate |= TSTATE_ICARRY;
280 regs->u_regs[UREG_I0] = EFAULT;
283 switch (_NSIG_WORDS) {
284 case 4: set.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
285 case 3: set.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
286 case 2: set.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
287 case 1: set.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
289 sigdelsetmask(&set, ~_BLOCKABLE);
290 spin_lock_irq(¤t->sighand->siglock);
291 oldset = current->blocked;
292 current->blocked = set;
294 spin_unlock_irq(¤t->sighand->siglock);
296 regs->tpc = regs->tnpc;
298 if (test_thread_flag(TIF_32BIT)) {
299 regs->tpc &= 0xffffffff;
300 regs->tnpc &= 0xffffffff;
303 /* Condition codes and return value where set here for sigpause,
304 * and so got used by setup_frame, which again causes sigreturn()
308 current->state = TASK_INTERRUPTIBLE;
311 * Return -EINTR and set condition code here,
312 * so the interrupted system call actually returns
315 regs->tstate |= TSTATE_ICARRY;
316 regs->u_regs[UREG_I0] = EINTR;
317 if (do_signal32(&oldset, regs, 0, 0))
322 static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
324 unsigned long *fpregs = current_thread_info()->fpregs;
328 err = __get_user(fprs, &fpu->si_fprs);
330 regs->tstate &= ~TSTATE_PEF;
332 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
334 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
335 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
336 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
337 current_thread_info()->fpsaved[0] |= fprs;
341 void do_new_sigreturn32(struct pt_regs *regs)
343 struct new_signal_frame32 __user *sf;
345 unsigned pc, npc, fpu_save;
347 unsigned seta[_COMPAT_NSIG_WORDS];
350 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
351 sf = (struct new_signal_frame32 __user *) regs->u_regs[UREG_FP];
353 /* 1. Make sure we are not getting garbage from the user */
354 if (verify_area(VERIFY_READ, sf, sizeof(*sf)) ||
355 (((unsigned long) sf) & 3))
358 get_user(pc, &sf->info.si_regs.pc);
359 __get_user(npc, &sf->info.si_regs.npc);
364 if (test_thread_flag(TIF_32BIT)) {
371 /* 2. Restore the state */
372 err = __get_user(regs->y, &sf->info.si_regs.y);
373 err |= __get_user(psr, &sf->info.si_regs.psr);
375 for (i = UREG_G1; i <= UREG_I7; i++)
376 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
377 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
378 err |= __get_user(i, &sf->v8plus.g_upper[0]);
379 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
382 for (i = UREG_G1; i <= UREG_I7; i++)
383 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
384 err |= __get_user(asi, &sf->v8plus.asi);
385 regs->tstate &= ~TSTATE_ASI;
386 regs->tstate |= ((asi & 0xffUL) << 24UL);
390 /* User can only change condition codes in %tstate. */
391 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
392 regs->tstate |= psr_to_tstate_icc(psr);
394 err |= __get_user(fpu_save, &sf->fpu_save);
396 err |= restore_fpu_state32(regs, &sf->fpu_state);
397 err |= __get_user(seta[0], &sf->info.si_mask);
398 err |= copy_from_user(seta+1, &sf->extramask,
399 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
402 switch (_NSIG_WORDS) {
403 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
404 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
405 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
406 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
408 sigdelsetmask(&set, ~_BLOCKABLE);
409 spin_lock_irq(¤t->sighand->siglock);
410 current->blocked = set;
412 spin_unlock_irq(¤t->sighand->siglock);
416 force_sig(SIGSEGV, current);
419 asmlinkage void do_sigreturn32(struct pt_regs *regs)
421 struct sigcontext32 __user *scptr;
422 unsigned int pc, npc, psr;
424 unsigned int seta[_COMPAT_NSIG_WORDS];
427 /* Always make any pending restarted system calls return -EINTR */
428 current_thread_info()->restart_block.fn = do_no_restart_syscall;
430 synchronize_user_stack();
431 if (test_thread_flag(TIF_NEWSIGNALS)) {
432 do_new_sigreturn32(regs);
436 scptr = (struct sigcontext32 __user *)
437 (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
438 /* Check sanity of the user arg. */
439 if (verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
440 (((unsigned long) scptr) & 3))
443 err = __get_user(pc, &scptr->sigc_pc);
444 err |= __get_user(npc, &scptr->sigc_npc);
447 goto segv; /* Nice try. */
449 err |= __get_user(seta[0], &scptr->sigc_mask);
450 /* Note that scptr + 1 points to extramask */
451 err |= copy_from_user(seta+1, scptr + 1,
452 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
455 switch (_NSIG_WORDS) {
456 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
457 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
458 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
459 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
461 sigdelsetmask(&set, ~_BLOCKABLE);
462 spin_lock_irq(¤t->sighand->siglock);
463 current->blocked = set;
465 spin_unlock_irq(¤t->sighand->siglock);
467 if (test_thread_flag(TIF_32BIT)) {
473 err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
474 err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
475 err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
477 /* User can only change condition codes in %tstate. */
478 err |= __get_user(psr, &scptr->sigc_psr);
481 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
482 regs->tstate |= psr_to_tstate_icc(psr);
486 force_sig(SIGSEGV, current);
489 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
491 struct rt_signal_frame32 __user *sf;
492 unsigned int psr, pc, npc, fpu_save, u_ss_sp;
495 compat_sigset_t seta;
499 /* Always make any pending restarted system calls return -EINTR */
500 current_thread_info()->restart_block.fn = do_no_restart_syscall;
502 synchronize_user_stack();
503 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
504 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
506 /* 1. Make sure we are not getting garbage from the user */
507 if (verify_area(VERIFY_READ, sf, sizeof(*sf)) ||
508 (((unsigned long) sf) & 3))
511 get_user(pc, &sf->regs.pc);
512 __get_user(npc, &sf->regs.npc);
517 if (test_thread_flag(TIF_32BIT)) {
524 /* 2. Restore the state */
525 err = __get_user(regs->y, &sf->regs.y);
526 err |= __get_user(psr, &sf->regs.psr);
528 for (i = UREG_G1; i <= UREG_I7; i++)
529 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
530 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
531 err |= __get_user(i, &sf->v8plus.g_upper[0]);
532 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
535 for (i = UREG_G1; i <= UREG_I7; i++)
536 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
537 err |= __get_user(asi, &sf->v8plus.asi);
538 regs->tstate &= ~TSTATE_ASI;
539 regs->tstate |= ((asi & 0xffUL) << 24UL);
543 /* User can only change condition codes in %tstate. */
544 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
545 regs->tstate |= psr_to_tstate_icc(psr);
547 err |= __get_user(fpu_save, &sf->fpu_save);
549 err |= restore_fpu_state32(regs, &sf->fpu_state);
550 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
551 err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
552 st.ss_sp = compat_ptr(u_ss_sp);
553 err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
554 err |= __get_user(st.ss_size, &sf->stack.ss_size);
558 /* It is more difficult to avoid calling this function than to
559 call it and ignore errors. */
562 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
565 switch (_NSIG_WORDS) {
566 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
567 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
568 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
569 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
571 sigdelsetmask(&set, ~_BLOCKABLE);
572 spin_lock_irq(¤t->sighand->siglock);
573 current->blocked = set;
575 spin_unlock_irq(¤t->sighand->siglock);
578 force_sig(SIGSEGV, current);
581 /* Checks if the fp is valid */
582 static int invalid_frame_pointer(void __user *fp, int fplen)
584 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
589 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
593 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
594 sp = regs->u_regs[UREG_FP];
596 /* This is the X/Open sanctioned signal stack switching. */
597 if (sa->sa_flags & SA_ONSTACK) {
598 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
599 sp = current->sas_ss_sp + current->sas_ss_size;
601 return (void __user *)(sp - framesize);
605 setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
607 struct signal_sframe32 __user *sframep;
608 struct sigcontext32 __user *sc;
609 unsigned int seta[_COMPAT_NSIG_WORDS];
611 void __user *sig_address;
613 unsigned long pc = regs->tpc;
614 unsigned long npc = regs->tnpc;
617 if (test_thread_flag(TIF_32BIT)) {
622 synchronize_user_stack();
623 save_and_clear_fpu();
625 sframep = (struct signal_sframe32 __user *)
626 get_sigframe(sa, regs, SF_ALIGNEDSZ);
627 if (invalid_frame_pointer(sframep, sizeof(*sframep))){
628 /* Don't change signal code and address, so that
629 * post mortem debuggers can have a look.
634 sc = &sframep->sig_context;
636 /* We've already made sure frame pointer isn't in kernel space... */
637 err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
640 switch (_NSIG_WORDS) {
641 case 4: seta[7] = (oldset->sig[3] >> 32);
642 seta[6] = oldset->sig[3];
643 case 3: seta[5] = (oldset->sig[2] >> 32);
644 seta[4] = oldset->sig[2];
645 case 2: seta[3] = (oldset->sig[1] >> 32);
646 seta[2] = oldset->sig[1];
647 case 1: seta[1] = (oldset->sig[0] >> 32);
648 seta[0] = oldset->sig[0];
650 err |= __put_user(seta[0], &sc->sigc_mask);
651 err |= __copy_to_user(sframep->extramask, seta + 1,
652 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
653 err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
654 err |= __put_user(pc, &sc->sigc_pc);
655 err |= __put_user(npc, &sc->sigc_npc);
656 psr = tstate_to_psr(regs->tstate);
657 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
659 err |= __put_user(psr, &sc->sigc_psr);
660 err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
661 err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
662 err |= __put_user(get_thread_wsaved(), &sc->sigc_oswins);
664 err |= copy_in_user((u32 __user *)sframep,
665 (u32 __user *)(regs->u_regs[UREG_FP]),
666 sizeof(struct reg_window32));
668 set_thread_wsaved(0); /* So process is allowed to execute. */
669 err |= __put_user(signr, &sframep->sig_num);
672 if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
673 sig_address = info->si_addr;
676 switch (info->si_code) {
677 case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
678 default: sig_code = SUBSIG_PROTECTION; break;
682 switch (info->si_code) {
683 case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
684 case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
685 case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
686 default: sig_code = SUBSIG_STACK; break;
690 switch (info->si_code) {
691 case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
692 case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
693 case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
694 case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
695 case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
696 case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
697 case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
698 default: sig_code = SUBSIG_FPERROR; break;
702 switch (info->si_code) {
703 case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
704 case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
705 default: sig_code = SUBSIG_BUSTIMEOUT; break;
709 switch (info->si_code) {
710 case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
714 if (info->si_code == (__SI_FAULT|0x100)) {
715 /* See sys_sunos32.c */
716 sig_code = info->si_trapno;
723 err |= __put_user((long)sig_address, &sframep->sig_address);
724 err |= __put_user(sig_code, &sframep->sig_code);
725 err |= __put_user((u64)sc, &sframep->sig_scptr);
729 regs->u_regs[UREG_FP] = (unsigned long) sframep;
730 regs->tpc = (unsigned long) sa->sa_handler;
731 regs->tnpc = (regs->tpc + 4);
732 if (test_thread_flag(TIF_32BIT)) {
733 regs->tpc &= 0xffffffff;
734 regs->tnpc &= 0xffffffff;
739 force_sigsegv(signr, current);
743 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
745 unsigned long *fpregs = current_thread_info()->fpregs;
749 fprs = current_thread_info()->fpsaved[0];
751 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
752 (sizeof(unsigned int) * 32));
754 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
755 (sizeof(unsigned int) * 32));
756 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
757 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
758 err |= __put_user(fprs, &fpu->si_fprs);
763 static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
764 int signo, sigset_t *oldset)
766 struct new_signal_frame32 __user *sf;
770 unsigned int seta[_COMPAT_NSIG_WORDS];
772 /* 1. Make sure everything is clean */
773 synchronize_user_stack();
774 save_and_clear_fpu();
776 sigframe_size = NF_ALIGNEDSZ;
777 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
778 sigframe_size -= sizeof(__siginfo_fpu_t);
780 sf = (struct new_signal_frame32 __user *)
781 get_sigframe(&ka->sa, regs, sigframe_size);
783 if (invalid_frame_pointer(sf, sigframe_size))
786 if (get_thread_wsaved() != 0)
789 /* 2. Save the current process state */
790 if (test_thread_flag(TIF_32BIT)) {
791 regs->tpc &= 0xffffffff;
792 regs->tnpc &= 0xffffffff;
794 err = put_user(regs->tpc, &sf->info.si_regs.pc);
795 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
796 err |= __put_user(regs->y, &sf->info.si_regs.y);
797 psr = tstate_to_psr(regs->tstate);
798 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
800 err |= __put_user(psr, &sf->info.si_regs.psr);
801 for (i = 0; i < 16; i++)
802 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
803 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
804 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
805 for (i = 1; i < 16; i++)
806 err |= __put_user(((u32 *)regs->u_regs)[2*i],
807 &sf->v8plus.g_upper[i]);
808 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
812 err |= save_fpu_state32(regs, &sf->fpu_state);
813 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
815 err |= __put_user(0, &sf->fpu_save);
818 switch (_NSIG_WORDS) {
819 case 4: seta[7] = (oldset->sig[3] >> 32);
820 seta[6] = oldset->sig[3];
821 case 3: seta[5] = (oldset->sig[2] >> 32);
822 seta[4] = oldset->sig[2];
823 case 2: seta[3] = (oldset->sig[1] >> 32);
824 seta[2] = oldset->sig[1];
825 case 1: seta[1] = (oldset->sig[0] >> 32);
826 seta[0] = oldset->sig[0];
828 err |= __put_user(seta[0], &sf->info.si_mask);
829 err |= __copy_to_user(sf->extramask, seta + 1,
830 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
832 err |= copy_in_user((u32 __user *)sf,
833 (u32 __user *)(regs->u_regs[UREG_FP]),
834 sizeof(struct reg_window32));
839 /* 3. signal handler back-trampoline and parameters */
840 regs->u_regs[UREG_FP] = (unsigned long) sf;
841 regs->u_regs[UREG_I0] = signo;
842 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
843 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
845 /* 4. signal handler */
846 regs->tpc = (unsigned long) ka->sa.sa_handler;
847 regs->tnpc = (regs->tpc + 4);
848 if (test_thread_flag(TIF_32BIT)) {
849 regs->tpc &= 0xffffffff;
850 regs->tnpc &= 0xffffffff;
853 /* 5. return to kernel instructions */
854 if (ka->ka_restorer) {
855 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
857 /* Flush instruction space. */
858 unsigned long address = ((unsigned long)&(sf->insns[0]));
859 pgd_t *pgdp = pgd_offset(current->mm, address);
860 pmd_t *pmdp = pmd_offset(pgdp, address);
863 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
865 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
866 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
871 ptep = pte_offset_map(pmdp, address);
872 if (pte_present(*ptep)) {
873 unsigned long page = (unsigned long)
874 page_address(pte_page(*ptep));
876 __asm__ __volatile__(
877 " membar #StoreStore\n"
879 : : "r" (page), "r" (address & (PAGE_SIZE - 1))
890 force_sigsegv(signo, current);
893 /* Setup a Solaris stack frame */
895 setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc,
896 struct pt_regs *regs, int signr, sigset_t *oldset)
898 svr4_signal_frame_t __user *sfp;
899 svr4_gregset_t __user *gr;
900 svr4_siginfo_t __user *si;
901 svr4_mcontext_t __user *mc;
902 svr4_gwindows_t __user *gw;
903 svr4_ucontext_t __user *uc;
908 synchronize_user_stack();
909 save_and_clear_fpu();
911 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
912 sfp = (svr4_signal_frame_t __user *)
913 get_sigframe(sa, regs,
914 sizeof(struct reg_window32) + SVR4_SF_ALIGNED);
916 if (invalid_frame_pointer(sfp, sizeof(*sfp)))
919 /* Start with a clean frame pointer and fill it */
920 err = clear_user(sfp, sizeof(*sfp));
922 /* Setup convenience variables */
929 /* FIXME: where am I supposed to put this?
930 * sc->sigc_onstack = old_status;
931 * anyways, it does not look like it is used for anything at all.
933 setv.sigbits[0] = oldset->sig[0];
934 setv.sigbits[1] = (oldset->sig[0] >> 32);
935 if (_NSIG_WORDS >= 2) {
936 setv.sigbits[2] = oldset->sig[1];
937 setv.sigbits[3] = (oldset->sig[1] >> 32);
938 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
940 err |= __copy_to_user(&uc->sigmask, &setv,
941 2 * sizeof(unsigned int));
943 /* Store registers */
944 if (test_thread_flag(TIF_32BIT)) {
945 regs->tpc &= 0xffffffff;
946 regs->tnpc &= 0xffffffff;
948 err |= __put_user(regs->tpc, &((*gr)[SVR4_PC]));
949 err |= __put_user(regs->tnpc, &((*gr)[SVR4_NPC]));
950 psr = tstate_to_psr(regs->tstate);
951 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
953 err |= __put_user(psr, &((*gr)[SVR4_PSR]));
954 err |= __put_user(regs->y, &((*gr)[SVR4_Y]));
956 /* Copy g[1..7] and o[0..7] registers */
957 for (i = 0; i < 7; i++)
958 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
959 for (i = 0; i < 8; i++)
960 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
962 /* Setup sigaltstack */
963 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
964 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
965 err |= __put_user(current->sas_ss_size, &uc->stack.size);
967 /* Save the currently window file: */
969 /* 1. Link sfp->uc->gwins to our windows */
970 err |= __put_user((u32)(long)gw, &mc->gwin);
972 /* 2. Number of windows to restore at setcontext (): */
973 err |= __put_user(get_thread_wsaved(), &gw->count);
975 /* 3. We just pay attention to the gw->count field on setcontext */
976 set_thread_wsaved(0); /* So process is allowed to execute. */
978 /* Setup the signal information. Solaris expects a bunch of
979 * information to be passed to the signal handler, we don't provide
980 * that much currently, should use siginfo.
982 err |= __put_user(signr, &si->siginfo.signo);
983 err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
987 regs->u_regs[UREG_FP] = (unsigned long) sfp;
988 regs->tpc = (unsigned long) sa->sa_handler;
989 regs->tnpc = (regs->tpc + 4);
990 if (test_thread_flag(TIF_32BIT)) {
991 regs->tpc &= 0xffffffff;
992 regs->tnpc &= 0xffffffff;
995 /* Arguments passed to signal handler */
996 if (regs->u_regs[14]){
997 struct reg_window32 __user *rw = (struct reg_window32 __user *)
998 (regs->u_regs[14] & 0x00000000ffffffffUL);
1000 err |= __put_user(signr, &rw->ins[0]);
1001 err |= __put_user((u64)si, &rw->ins[1]);
1002 err |= __put_user((u64)uc, &rw->ins[2]);
1003 err |= __put_user((u64)sfp, &rw->ins[6]); /* frame pointer */
1007 regs->u_regs[UREG_I0] = signr;
1008 regs->u_regs[UREG_I1] = (u32)(u64) si;
1009 regs->u_regs[UREG_I2] = (u32)(u64) uc;
1014 force_sigsegv(signr, current);
1018 svr4_getcontext(svr4_ucontext_t __user *uc, struct pt_regs *regs)
1020 svr4_gregset_t __user *gr;
1021 svr4_mcontext_t __user *mc;
1026 synchronize_user_stack();
1027 save_and_clear_fpu();
1029 if (get_thread_wsaved())
1032 err = clear_user(uc, sizeof(*uc));
1034 /* Setup convenience variables */
1038 setv.sigbits[0] = current->blocked.sig[0];
1039 setv.sigbits[1] = (current->blocked.sig[0] >> 32);
1040 if (_NSIG_WORDS >= 2) {
1041 setv.sigbits[2] = current->blocked.sig[1];
1042 setv.sigbits[3] = (current->blocked.sig[1] >> 32);
1043 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
1045 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
1047 /* Store registers */
1048 if (test_thread_flag(TIF_32BIT)) {
1049 regs->tpc &= 0xffffffff;
1050 regs->tnpc &= 0xffffffff;
1052 err |= __put_user(regs->tpc, &uc->mcontext.greg[SVR4_PC]);
1053 err |= __put_user(regs->tnpc, &uc->mcontext.greg[SVR4_NPC]);
1055 psr = tstate_to_psr(regs->tstate) & ~PSR_EF;
1056 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
1058 err |= __put_user(psr, &uc->mcontext.greg[SVR4_PSR]);
1060 err |= __put_user(regs->y, &uc->mcontext.greg[SVR4_Y]);
1062 /* Copy g[1..7] and o[0..7] registers */
1063 for (i = 0; i < 7; i++)
1064 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1065 for (i = 0; i < 8; i++)
1066 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1068 /* Setup sigaltstack */
1069 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
1070 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
1071 err |= __put_user(current->sas_ss_size, &uc->stack.size);
1073 /* The register file is not saved
1074 * we have already stuffed all of it with sync_user_stack
1076 return (err ? -EFAULT : 0);
1080 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
1081 asmlinkage int svr4_setcontext(svr4_ucontext_t __user *c, struct pt_regs *regs)
1083 svr4_gregset_t __user *gr;
1084 mm_segment_t old_fs;
1085 u32 pc, npc, psr, u_ss_sp;
1091 /* Fixme: restore windows, or is this already taken care of in
1092 * svr4_setup_frame when sync_user_windows is done?
1094 flush_user_windows();
1096 if (get_thread_wsaved())
1099 if (((unsigned long) c) & 3){
1100 printk("Unaligned structure passed\n");
1104 if (!__access_ok((unsigned long)c, sizeof(*c))) {
1105 /* Miguel, add nice debugging msg _here_. ;-) */
1109 /* Check for valid PC and nPC */
1110 gr = &c->mcontext.greg;
1111 err = __get_user(pc, &((*gr)[SVR4_PC]));
1112 err |= __get_user(npc, &((*gr)[SVR4_NPC]));
1116 /* Retrieve information from passed ucontext */
1117 /* note that nPC is ored a 1, this is used to inform entry.S */
1118 /* that we don't want it to mess with our PC and nPC */
1120 err |= copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
1121 set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32);
1122 if (_NSIG_WORDS >= 2)
1123 set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32);
1125 err |= __get_user(u_ss_sp, &c->stack.sp);
1126 st.ss_sp = compat_ptr(u_ss_sp);
1127 err |= __get_user(st.ss_flags, &c->stack.flags);
1128 err |= __get_user(st.ss_size, &c->stack.size);
1132 /* It is more difficult to avoid calling this function than to
1133 call it and ignore errors. */
1136 do_sigaltstack((stack_t __user *) &st, NULL, regs->u_regs[UREG_I6]);
1139 sigdelsetmask(&set, ~_BLOCKABLE);
1140 spin_lock_irq(¤t->sighand->siglock);
1141 current->blocked = set;
1142 recalc_sigpending();
1143 spin_unlock_irq(¤t->sighand->siglock);
1145 regs->tnpc = npc | 1;
1146 if (test_thread_flag(TIF_32BIT)) {
1147 regs->tpc &= 0xffffffff;
1148 regs->tnpc &= 0xffffffff;
1150 err |= __get_user(regs->y, &((*gr)[SVR4_Y]));
1151 err |= __get_user(psr, &((*gr)[SVR4_PSR]));
1152 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
1153 regs->tstate |= psr_to_tstate_icc(psr);
1155 /* Restore g[1..7] and o[0..7] registers */
1156 for (i = 0; i < 7; i++)
1157 err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1158 for (i = 0; i < 8; i++)
1159 err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1168 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
1169 unsigned long signr, sigset_t *oldset,
1172 struct rt_signal_frame32 __user *sf;
1176 compat_sigset_t seta;
1178 /* 1. Make sure everything is clean */
1179 synchronize_user_stack();
1180 save_and_clear_fpu();
1182 sigframe_size = RT_ALIGNEDSZ;
1183 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
1184 sigframe_size -= sizeof(__siginfo_fpu_t);
1186 sf = (struct rt_signal_frame32 __user *)
1187 get_sigframe(&ka->sa, regs, sigframe_size);
1189 if (invalid_frame_pointer(sf, sigframe_size))
1192 if (get_thread_wsaved() != 0)
1195 /* 2. Save the current process state */
1196 if (test_thread_flag(TIF_32BIT)) {
1197 regs->tpc &= 0xffffffff;
1198 regs->tnpc &= 0xffffffff;
1200 err = put_user(regs->tpc, &sf->regs.pc);
1201 err |= __put_user(regs->tnpc, &sf->regs.npc);
1202 err |= __put_user(regs->y, &sf->regs.y);
1203 psr = tstate_to_psr(regs->tstate);
1204 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
1206 err |= __put_user(psr, &sf->regs.psr);
1207 for (i = 0; i < 16; i++)
1208 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
1209 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
1210 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
1211 for (i = 1; i < 16; i++)
1212 err |= __put_user(((u32 *)regs->u_regs)[2*i],
1213 &sf->v8plus.g_upper[i]);
1214 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
1218 err |= save_fpu_state32(regs, &sf->fpu_state);
1219 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
1221 err |= __put_user(0, &sf->fpu_save);
1224 /* Update the siginfo structure. */
1225 err |= copy_siginfo_to_user32(&sf->info, info);
1227 /* Setup sigaltstack */
1228 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
1229 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
1230 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
1232 switch (_NSIG_WORDS) {
1233 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
1234 seta.sig[6] = oldset->sig[3];
1235 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
1236 seta.sig[4] = oldset->sig[2];
1237 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
1238 seta.sig[2] = oldset->sig[1];
1239 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
1240 seta.sig[0] = oldset->sig[0];
1242 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
1244 err |= copy_in_user((u32 __user *)sf,
1245 (u32 __user *)(regs->u_regs[UREG_FP]),
1246 sizeof(struct reg_window32));
1250 /* 3. signal handler back-trampoline and parameters */
1251 regs->u_regs[UREG_FP] = (unsigned long) sf;
1252 regs->u_regs[UREG_I0] = signr;
1253 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
1254 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
1256 /* 4. signal handler */
1257 regs->tpc = (unsigned long) ka->sa.sa_handler;
1258 regs->tnpc = (regs->tpc + 4);
1259 if (test_thread_flag(TIF_32BIT)) {
1260 regs->tpc &= 0xffffffff;
1261 regs->tnpc &= 0xffffffff;
1264 /* 5. return to kernel instructions */
1265 if (ka->ka_restorer)
1266 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
1268 /* Flush instruction space. */
1269 unsigned long address = ((unsigned long)&(sf->insns[0]));
1270 pgd_t *pgdp = pgd_offset(current->mm, address);
1271 pmd_t *pmdp = pmd_offset(pgdp, address);
1274 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
1276 /* mov __NR_rt_sigreturn, %g1 */
1277 err |= __put_user(0x82102065, &sf->insns[0]);
1280 err |= __put_user(0x91d02010, &sf->insns[1]);
1285 ptep = pte_offset_map(pmdp, address);
1286 if (pte_present(*ptep)) {
1287 unsigned long page = (unsigned long)
1288 page_address(pte_page(*ptep));
1290 __asm__ __volatile__(
1291 " membar #StoreStore\n"
1293 : : "r" (page), "r" (address & (PAGE_SIZE - 1))
1304 force_sigsegv(signr, current);
1307 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
1309 sigset_t *oldset, struct pt_regs *regs,
1313 setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc,
1314 regs, signr, oldset);
1316 if (ka->sa.sa_flags & SA_SIGINFO)
1317 setup_rt_frame32(ka, regs, signr, oldset, info);
1318 else if (test_thread_flag(TIF_NEWSIGNALS))
1319 new_setup_frame32(ka, regs, signr, oldset);
1321 setup_frame32(&ka->sa, regs, signr, oldset, info);
1323 if (!(ka->sa.sa_flags & SA_NOMASK)) {
1324 spin_lock_irq(¤t->sighand->siglock);
1325 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
1326 sigaddset(¤t->blocked,signr);
1327 recalc_sigpending();
1328 spin_unlock_irq(¤t->sighand->siglock);
1332 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
1333 struct sigaction *sa)
1335 switch (regs->u_regs[UREG_I0]) {
1336 case ERESTART_RESTARTBLOCK:
1337 case ERESTARTNOHAND:
1338 no_system_call_restart:
1339 regs->u_regs[UREG_I0] = EINTR;
1340 regs->tstate |= TSTATE_ICARRY;
1343 if (!(sa->sa_flags & SA_RESTART))
1344 goto no_system_call_restart;
1346 case ERESTARTNOINTR:
1347 regs->u_regs[UREG_I0] = orig_i0;
1353 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1354 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1357 int do_signal32(sigset_t *oldset, struct pt_regs * regs,
1358 unsigned long orig_i0, int restart_syscall)
1361 struct signal_deliver_cookie cookie;
1362 struct k_sigaction ka;
1364 int svr4_signal = current->personality == PER_SVR4;
1366 cookie.restart_syscall = restart_syscall;
1367 cookie.orig_i0 = orig_i0;
1369 signr = get_signal_to_deliver(&info, &ka, regs, &cookie);
1371 if (cookie.restart_syscall)
1372 syscall_restart32(orig_i0, regs, &ka.sa);
1373 handle_signal32(signr, &ka, &info, oldset,
1377 if (cookie.restart_syscall &&
1378 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1379 regs->u_regs[UREG_I0] == ERESTARTSYS ||
1380 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1381 /* replay the system call when we are done */
1382 regs->u_regs[UREG_I0] = cookie.orig_i0;
1386 if (cookie.restart_syscall &&
1387 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
1388 regs->u_regs[UREG_G1] = __NR_restart_syscall;
1400 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
1402 struct sigstack32 __user *ssptr =
1403 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
1404 struct sigstack32 __user *ossptr =
1405 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
1408 /* First see if old state is wanted. */
1410 if (put_user(current->sas_ss_sp + current->sas_ss_size,
1411 &ossptr->the_stack) ||
1412 __put_user(on_sig_stack(sp), &ossptr->cur_status))
1416 /* Now see if we want to update the new state. */
1420 if (get_user(ss_sp, &ssptr->the_stack))
1423 /* If the current stack was set with sigaltstack, don't
1424 * swap stacks while we are on it.
1427 if (current->sas_ss_sp && on_sig_stack(sp))
1430 /* Since we don't know the extent of the stack, and we don't
1431 * track onstack-ness, but rather calculate it, we must
1432 * presume a size. Ho hum this interface is lossy.
1434 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1435 current->sas_ss_size = SIGSTKSZ;
1443 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
1448 mm_segment_t old_fs;
1450 if (ussa && (get_user(u_ss_sp, &((stack_t32 __user *)(long)ussa)->ss_sp) ||
1451 __get_user(uss.ss_flags, &((stack_t32 __user *)(long)ussa)->ss_flags) ||
1452 __get_user(uss.ss_size, &((stack_t32 __user *)(long)ussa)->ss_size)))
1454 uss.ss_sp = compat_ptr(u_ss_sp);
1457 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
1458 uossa ? (stack_t __user *) &uoss : NULL, sp);
1460 if (!ret && uossa && (put_user((long)uoss.ss_sp, &((stack_t32 __user *)(long)uossa)->ss_sp) ||
1461 __put_user(uoss.ss_flags, &((stack_t32 __user *)(long)uossa)->ss_flags) ||
1462 __put_user(uoss.ss_size, &((stack_t32 __user *)(long)uossa)->ss_size)))