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>
23 #include <linux/bitops.h>
24 #include <linux/tracehook.h>
26 #include <asm/uaccess.h>
27 #include <asm/ptrace.h>
29 #include <asm/pgtable.h>
30 #include <asm/psrcompat.h>
31 #include <asm/fpumacro.h>
32 #include <asm/visasm.h>
33 #include <asm/compat_signal.h>
35 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
37 /* Signal frames: the original one (compatible with SunOS):
39 * Set up a signal frame... Make the stack look the way SunOS
40 * expects it to look which is basically:
42 * ---------------------------------- <-- %sp at signal time
45 * Ptr to sigcontext area above
47 * The signal number itself
49 * ---------------------------------- <-- New %sp
51 struct signal_sframe32 {
52 struct reg_window32 sig_window;
55 /* struct sigcontext32 * */ u32 sig_scptr;
57 struct sigcontext32 sig_context;
58 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
61 /* This magic should be in g_upper[0] for all upper parts
64 #define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
66 unsigned int g_upper[8];
67 unsigned int o_upper[8];
69 } siginfo_extra_v8plus_t;
72 * And the new one, intended to be used for Linux applications only
73 * (we have enough in there to work with clone).
74 * All the interesting bits are in the info field.
76 struct new_signal_frame32 {
77 struct sparc_stackf32 ss;
79 /* __siginfo_fpu32_t * */ u32 fpu_save;
80 unsigned int insns[2];
81 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
82 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
83 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
84 siginfo_extra_v8plus_t v8plus;
85 __siginfo_fpu_t fpu_state;
88 typedef struct compat_siginfo{
94 int _pad[SI_PAD_SIZE32];
98 compat_pid_t _pid; /* sender's pid */
99 unsigned int _uid; /* sender's uid */
102 /* POSIX.1b timers */
104 compat_timer_t _tid; /* timer id */
105 int _overrun; /* overrun count */
106 compat_sigval_t _sigval; /* same as below */
107 int _sys_private; /* not to be passed to user */
110 /* POSIX.1b signals */
112 compat_pid_t _pid; /* sender's pid */
113 unsigned int _uid; /* sender's uid */
114 compat_sigval_t _sigval;
119 compat_pid_t _pid; /* which child */
120 unsigned int _uid; /* sender's uid */
121 int _status; /* exit code */
122 compat_clock_t _utime;
123 compat_clock_t _stime;
126 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
128 u32 _addr; /* faulting insn/memory ref. */
134 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
140 struct rt_signal_frame32 {
141 struct sparc_stackf32 ss;
142 compat_siginfo_t info;
143 struct pt_regs32 regs;
144 compat_sigset_t mask;
145 /* __siginfo_fpu32_t * */ u32 fpu_save;
146 unsigned int insns[2];
148 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
149 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
150 siginfo_extra_v8plus_t v8plus;
151 __siginfo_fpu_t fpu_state;
155 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe32) + 7) & (~7)))
156 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame32) + 7) & (~7)))
157 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
159 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
163 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
166 /* If you change siginfo_t structure, please be sure
167 this code is fixed accordingly.
168 It should never copy any pad contained in the structure
169 to avoid security leaks, but must copy the generic
170 3 ints plus the relevant union member.
171 This routine must convert siginfo from 64bit to 32bit as well
173 err = __put_user(from->si_signo, &to->si_signo);
174 err |= __put_user(from->si_errno, &to->si_errno);
175 err |= __put_user((short)from->si_code, &to->si_code);
176 if (from->si_code < 0)
177 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
179 switch (from->si_code >> 16) {
180 case __SI_TIMER >> 16:
181 err |= __put_user(from->si_tid, &to->si_tid);
182 err |= __put_user(from->si_overrun, &to->si_overrun);
183 err |= __put_user(from->si_int, &to->si_int);
185 case __SI_CHLD >> 16:
186 err |= __put_user(from->si_utime, &to->si_utime);
187 err |= __put_user(from->si_stime, &to->si_stime);
188 err |= __put_user(from->si_status, &to->si_status);
190 err |= __put_user(from->si_pid, &to->si_pid);
191 err |= __put_user(from->si_uid, &to->si_uid);
193 case __SI_FAULT >> 16:
194 err |= __put_user(from->si_trapno, &to->si_trapno);
195 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
197 case __SI_POLL >> 16:
198 err |= __put_user(from->si_band, &to->si_band);
199 err |= __put_user(from->si_fd, &to->si_fd);
201 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
202 case __SI_MESGQ >> 16:
203 err |= __put_user(from->si_pid, &to->si_pid);
204 err |= __put_user(from->si_uid, &to->si_uid);
205 err |= __put_user(from->si_int, &to->si_int);
212 /* CAUTION: This is just a very minimalist implementation for the
213 * sake of compat_sys_rt_sigqueueinfo()
215 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
217 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
220 if (copy_from_user(to, from, 3*sizeof(int)) ||
221 copy_from_user(to->_sifields._pad, from->_sifields._pad,
228 static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
230 unsigned long *fpregs = current_thread_info()->fpregs;
234 err = __get_user(fprs, &fpu->si_fprs);
236 regs->tstate &= ~TSTATE_PEF;
238 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
240 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
241 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
242 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
243 current_thread_info()->fpsaved[0] |= fprs;
247 void do_new_sigreturn32(struct pt_regs *regs)
249 struct new_signal_frame32 __user *sf;
251 unsigned pc, npc, fpu_save;
253 unsigned seta[_COMPAT_NSIG_WORDS];
256 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
257 sf = (struct new_signal_frame32 __user *) regs->u_regs[UREG_FP];
259 /* 1. Make sure we are not getting garbage from the user */
260 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
261 (((unsigned long) sf) & 3))
264 get_user(pc, &sf->info.si_regs.pc);
265 __get_user(npc, &sf->info.si_regs.npc);
270 if (test_thread_flag(TIF_32BIT)) {
277 /* 2. Restore the state */
278 err = __get_user(regs->y, &sf->info.si_regs.y);
279 err |= __get_user(psr, &sf->info.si_regs.psr);
281 for (i = UREG_G1; i <= UREG_I7; i++)
282 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
283 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
284 err |= __get_user(i, &sf->v8plus.g_upper[0]);
285 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
288 for (i = UREG_G1; i <= UREG_I7; i++)
289 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
290 err |= __get_user(asi, &sf->v8plus.asi);
291 regs->tstate &= ~TSTATE_ASI;
292 regs->tstate |= ((asi & 0xffUL) << 24UL);
296 /* User can only change condition codes in %tstate. */
297 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
298 regs->tstate |= psr_to_tstate_icc(psr);
300 err |= __get_user(fpu_save, &sf->fpu_save);
302 err |= restore_fpu_state32(regs, &sf->fpu_state);
303 err |= __get_user(seta[0], &sf->info.si_mask);
304 err |= copy_from_user(seta+1, &sf->extramask,
305 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
308 switch (_NSIG_WORDS) {
309 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
310 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
311 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
312 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
314 sigdelsetmask(&set, ~_BLOCKABLE);
315 spin_lock_irq(¤t->sighand->siglock);
316 current->blocked = set;
318 spin_unlock_irq(¤t->sighand->siglock);
322 force_sig(SIGSEGV, current);
325 asmlinkage void do_sigreturn32(struct pt_regs *regs)
327 struct sigcontext32 __user *scptr;
328 unsigned int pc, npc, psr;
330 unsigned int seta[_COMPAT_NSIG_WORDS];
333 /* Always make any pending restarted system calls return -EINTR */
334 current_thread_info()->restart_block.fn = do_no_restart_syscall;
336 synchronize_user_stack();
337 if (test_thread_flag(TIF_NEWSIGNALS)) {
338 do_new_sigreturn32(regs);
342 scptr = (struct sigcontext32 __user *)
343 (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
344 /* Check sanity of the user arg. */
345 if (!access_ok(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
346 (((unsigned long) scptr) & 3))
349 err = __get_user(pc, &scptr->sigc_pc);
350 err |= __get_user(npc, &scptr->sigc_npc);
353 goto segv; /* Nice try. */
355 err |= __get_user(seta[0], &scptr->sigc_mask);
356 /* Note that scptr + 1 points to extramask */
357 err |= copy_from_user(seta+1, scptr + 1,
358 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
361 switch (_NSIG_WORDS) {
362 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
363 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
364 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
365 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
367 sigdelsetmask(&set, ~_BLOCKABLE);
368 spin_lock_irq(¤t->sighand->siglock);
369 current->blocked = set;
371 spin_unlock_irq(¤t->sighand->siglock);
373 if (test_thread_flag(TIF_32BIT)) {
379 err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
380 err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
381 err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
383 /* User can only change condition codes in %tstate. */
384 err |= __get_user(psr, &scptr->sigc_psr);
387 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
388 regs->tstate |= psr_to_tstate_icc(psr);
392 force_sig(SIGSEGV, current);
395 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
397 struct rt_signal_frame32 __user *sf;
398 unsigned int psr, pc, npc, fpu_save, u_ss_sp;
401 compat_sigset_t seta;
405 /* Always make any pending restarted system calls return -EINTR */
406 current_thread_info()->restart_block.fn = do_no_restart_syscall;
408 synchronize_user_stack();
409 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
410 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
412 /* 1. Make sure we are not getting garbage from the user */
413 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
414 (((unsigned long) sf) & 3))
417 get_user(pc, &sf->regs.pc);
418 __get_user(npc, &sf->regs.npc);
423 if (test_thread_flag(TIF_32BIT)) {
430 /* 2. Restore the state */
431 err = __get_user(regs->y, &sf->regs.y);
432 err |= __get_user(psr, &sf->regs.psr);
434 for (i = UREG_G1; i <= UREG_I7; i++)
435 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
436 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
437 err |= __get_user(i, &sf->v8plus.g_upper[0]);
438 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
441 for (i = UREG_G1; i <= UREG_I7; i++)
442 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
443 err |= __get_user(asi, &sf->v8plus.asi);
444 regs->tstate &= ~TSTATE_ASI;
445 regs->tstate |= ((asi & 0xffUL) << 24UL);
449 /* User can only change condition codes in %tstate. */
450 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
451 regs->tstate |= psr_to_tstate_icc(psr);
453 err |= __get_user(fpu_save, &sf->fpu_save);
455 err |= restore_fpu_state32(regs, &sf->fpu_state);
456 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
457 err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
458 st.ss_sp = compat_ptr(u_ss_sp);
459 err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
460 err |= __get_user(st.ss_size, &sf->stack.ss_size);
464 /* It is more difficult to avoid calling this function than to
465 call it and ignore errors. */
468 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
471 switch (_NSIG_WORDS) {
472 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
473 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
474 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
475 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
477 sigdelsetmask(&set, ~_BLOCKABLE);
478 spin_lock_irq(¤t->sighand->siglock);
479 current->blocked = set;
481 spin_unlock_irq(¤t->sighand->siglock);
484 force_sig(SIGSEGV, current);
487 /* Checks if the fp is valid */
488 static int invalid_frame_pointer(void __user *fp, int fplen)
490 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
495 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
499 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
500 sp = regs->u_regs[UREG_FP];
502 /* This is the X/Open sanctioned signal stack switching. */
503 if (sa->sa_flags & SA_ONSTACK) {
504 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
505 sp = current->sas_ss_sp + current->sas_ss_size;
507 return (void __user *)(sp - framesize);
511 setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
513 struct signal_sframe32 __user *sframep;
514 struct sigcontext32 __user *sc;
515 unsigned int seta[_COMPAT_NSIG_WORDS];
517 void __user *sig_address;
519 unsigned long pc = regs->tpc;
520 unsigned long npc = regs->tnpc;
523 if (test_thread_flag(TIF_32BIT)) {
528 synchronize_user_stack();
529 save_and_clear_fpu();
531 sframep = (struct signal_sframe32 __user *)
532 get_sigframe(sa, regs, SF_ALIGNEDSZ);
533 if (invalid_frame_pointer(sframep, sizeof(*sframep))){
534 /* Don't change signal code and address, so that
535 * post mortem debuggers can have a look.
540 sc = &sframep->sig_context;
542 /* We've already made sure frame pointer isn't in kernel space... */
543 err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
546 switch (_NSIG_WORDS) {
547 case 4: seta[7] = (oldset->sig[3] >> 32);
548 seta[6] = oldset->sig[3];
549 case 3: seta[5] = (oldset->sig[2] >> 32);
550 seta[4] = oldset->sig[2];
551 case 2: seta[3] = (oldset->sig[1] >> 32);
552 seta[2] = oldset->sig[1];
553 case 1: seta[1] = (oldset->sig[0] >> 32);
554 seta[0] = oldset->sig[0];
556 err |= __put_user(seta[0], &sc->sigc_mask);
557 err |= __copy_to_user(sframep->extramask, seta + 1,
558 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
559 err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
560 err |= __put_user(pc, &sc->sigc_pc);
561 err |= __put_user(npc, &sc->sigc_npc);
562 psr = tstate_to_psr(regs->tstate);
563 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
565 err |= __put_user(psr, &sc->sigc_psr);
566 err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
567 err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
568 err |= __put_user(get_thread_wsaved(), &sc->sigc_oswins);
570 err |= copy_in_user((u32 __user *)sframep,
571 (u32 __user *)(regs->u_regs[UREG_FP]),
572 sizeof(struct reg_window32));
574 set_thread_wsaved(0); /* So process is allowed to execute. */
575 err |= __put_user(signr, &sframep->sig_num);
578 if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
579 sig_address = info->si_addr;
582 switch (info->si_code) {
583 case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
584 default: sig_code = SUBSIG_PROTECTION; break;
588 switch (info->si_code) {
589 case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
590 case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
591 case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
592 default: sig_code = SUBSIG_STACK; break;
596 switch (info->si_code) {
597 case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
598 case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
599 case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
600 case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
601 case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
602 case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
603 case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
604 default: sig_code = SUBSIG_FPERROR; break;
608 switch (info->si_code) {
609 case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
610 case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
611 default: sig_code = SUBSIG_BUSTIMEOUT; break;
615 switch (info->si_code) {
616 case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
620 if (info->si_code == (__SI_FAULT|0x100)) {
621 /* See sys_sunos32.c */
622 sig_code = info->si_trapno;
629 err |= __put_user(ptr_to_compat(sig_address), &sframep->sig_address);
630 err |= __put_user(sig_code, &sframep->sig_code);
631 err |= __put_user(ptr_to_compat(sc), &sframep->sig_scptr);
635 regs->u_regs[UREG_FP] = (unsigned long) sframep;
636 regs->tpc = (unsigned long) sa->sa_handler;
637 regs->tnpc = (regs->tpc + 4);
638 if (test_thread_flag(TIF_32BIT)) {
639 regs->tpc &= 0xffffffff;
640 regs->tnpc &= 0xffffffff;
645 force_sigsegv(signr, current);
649 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
651 unsigned long *fpregs = current_thread_info()->fpregs;
655 fprs = current_thread_info()->fpsaved[0];
657 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
658 (sizeof(unsigned int) * 32));
660 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
661 (sizeof(unsigned int) * 32));
662 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
663 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
664 err |= __put_user(fprs, &fpu->si_fprs);
669 static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
670 int signo, sigset_t *oldset)
672 struct new_signal_frame32 __user *sf;
676 unsigned int seta[_COMPAT_NSIG_WORDS];
678 /* 1. Make sure everything is clean */
679 synchronize_user_stack();
680 save_and_clear_fpu();
682 sigframe_size = NF_ALIGNEDSZ;
683 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
684 sigframe_size -= sizeof(__siginfo_fpu_t);
686 sf = (struct new_signal_frame32 __user *)
687 get_sigframe(&ka->sa, regs, sigframe_size);
689 if (invalid_frame_pointer(sf, sigframe_size))
692 if (get_thread_wsaved() != 0)
695 /* 2. Save the current process state */
696 if (test_thread_flag(TIF_32BIT)) {
697 regs->tpc &= 0xffffffff;
698 regs->tnpc &= 0xffffffff;
700 err = put_user(regs->tpc, &sf->info.si_regs.pc);
701 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
702 err |= __put_user(regs->y, &sf->info.si_regs.y);
703 psr = tstate_to_psr(regs->tstate);
704 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
706 err |= __put_user(psr, &sf->info.si_regs.psr);
707 for (i = 0; i < 16; i++)
708 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
709 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
710 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
711 for (i = 1; i < 16; i++)
712 err |= __put_user(((u32 *)regs->u_regs)[2*i],
713 &sf->v8plus.g_upper[i]);
714 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
718 err |= save_fpu_state32(regs, &sf->fpu_state);
719 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
721 err |= __put_user(0, &sf->fpu_save);
724 switch (_NSIG_WORDS) {
725 case 4: seta[7] = (oldset->sig[3] >> 32);
726 seta[6] = oldset->sig[3];
727 case 3: seta[5] = (oldset->sig[2] >> 32);
728 seta[4] = oldset->sig[2];
729 case 2: seta[3] = (oldset->sig[1] >> 32);
730 seta[2] = oldset->sig[1];
731 case 1: seta[1] = (oldset->sig[0] >> 32);
732 seta[0] = oldset->sig[0];
734 err |= __put_user(seta[0], &sf->info.si_mask);
735 err |= __copy_to_user(sf->extramask, seta + 1,
736 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
738 err |= copy_in_user((u32 __user *)sf,
739 (u32 __user *)(regs->u_regs[UREG_FP]),
740 sizeof(struct reg_window32));
745 /* 3. signal handler back-trampoline and parameters */
746 regs->u_regs[UREG_FP] = (unsigned long) sf;
747 regs->u_regs[UREG_I0] = signo;
748 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
749 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
751 /* 4. signal handler */
752 regs->tpc = (unsigned long) ka->sa.sa_handler;
753 regs->tnpc = (regs->tpc + 4);
754 if (test_thread_flag(TIF_32BIT)) {
755 regs->tpc &= 0xffffffff;
756 regs->tnpc &= 0xffffffff;
759 /* 5. return to kernel instructions */
760 if (ka->ka_restorer) {
761 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
763 /* Flush instruction space. */
764 unsigned long address = ((unsigned long)&(sf->insns[0]));
765 pgd_t *pgdp = pgd_offset(current->mm, address);
766 pud_t *pudp = pud_offset(pgdp, address);
767 pmd_t *pmdp = pmd_offset(pudp, address);
771 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
773 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
774 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
779 ptep = pte_offset_map(pmdp, address);
781 if (pte_present(pte)) {
782 unsigned long page = (unsigned long)
783 page_address(pte_page(pte));
786 __asm__ __volatile__("flush %0 + %1"
789 "r" (address & (PAGE_SIZE - 1))
800 force_sigsegv(signo, current);
803 /* Setup a Solaris stack frame */
805 setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc,
806 struct pt_regs *regs, int signr, sigset_t *oldset)
808 svr4_signal_frame_t __user *sfp;
809 svr4_gregset_t __user *gr;
810 svr4_siginfo_t __user *si;
811 svr4_mcontext_t __user *mc;
812 svr4_gwindows_t __user *gw;
813 svr4_ucontext_t __user *uc;
818 synchronize_user_stack();
819 save_and_clear_fpu();
821 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
822 sfp = (svr4_signal_frame_t __user *)
823 get_sigframe(sa, regs,
824 sizeof(struct reg_window32) + SVR4_SF_ALIGNED);
826 if (invalid_frame_pointer(sfp, sizeof(*sfp)))
829 /* Start with a clean frame pointer and fill it */
830 err = clear_user(sfp, sizeof(*sfp));
832 /* Setup convenience variables */
839 /* FIXME: where am I supposed to put this?
840 * sc->sigc_onstack = old_status;
841 * anyways, it does not look like it is used for anything at all.
843 setv.sigbits[0] = oldset->sig[0];
844 setv.sigbits[1] = (oldset->sig[0] >> 32);
845 if (_NSIG_WORDS >= 2) {
846 setv.sigbits[2] = oldset->sig[1];
847 setv.sigbits[3] = (oldset->sig[1] >> 32);
848 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
850 err |= __copy_to_user(&uc->sigmask, &setv,
851 2 * sizeof(unsigned int));
853 /* Store registers */
854 if (test_thread_flag(TIF_32BIT)) {
855 regs->tpc &= 0xffffffff;
856 regs->tnpc &= 0xffffffff;
858 err |= __put_user(regs->tpc, &((*gr)[SVR4_PC]));
859 err |= __put_user(regs->tnpc, &((*gr)[SVR4_NPC]));
860 psr = tstate_to_psr(regs->tstate);
861 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
863 err |= __put_user(psr, &((*gr)[SVR4_PSR]));
864 err |= __put_user(regs->y, &((*gr)[SVR4_Y]));
866 /* Copy g[1..7] and o[0..7] registers */
867 for (i = 0; i < 7; i++)
868 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
869 for (i = 0; i < 8; i++)
870 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
872 /* Setup sigaltstack */
873 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
874 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
875 err |= __put_user(current->sas_ss_size, &uc->stack.size);
877 /* Save the currently window file: */
879 /* 1. Link sfp->uc->gwins to our windows */
880 err |= __put_user(ptr_to_compat(gw), &mc->gwin);
882 /* 2. Number of windows to restore at setcontext (): */
883 err |= __put_user(get_thread_wsaved(), &gw->count);
885 /* 3. We just pay attention to the gw->count field on setcontext */
886 set_thread_wsaved(0); /* So process is allowed to execute. */
888 /* Setup the signal information. Solaris expects a bunch of
889 * information to be passed to the signal handler, we don't provide
890 * that much currently, should use siginfo.
892 err |= __put_user(signr, &si->siginfo.signo);
893 err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
897 regs->u_regs[UREG_FP] = (unsigned long) sfp;
898 regs->tpc = (unsigned long) sa->sa_handler;
899 regs->tnpc = (regs->tpc + 4);
900 if (test_thread_flag(TIF_32BIT)) {
901 regs->tpc &= 0xffffffff;
902 regs->tnpc &= 0xffffffff;
905 /* Arguments passed to signal handler */
906 if (regs->u_regs[14]){
907 struct reg_window32 __user *rw = (struct reg_window32 __user *)
908 (regs->u_regs[14] & 0x00000000ffffffffUL);
910 err |= __put_user(signr, &rw->ins[0]);
911 err |= __put_user((u64)si, &rw->ins[1]);
912 err |= __put_user((u64)uc, &rw->ins[2]);
913 err |= __put_user((u64)sfp, &rw->ins[6]); /* frame pointer */
917 regs->u_regs[UREG_I0] = signr;
918 regs->u_regs[UREG_I1] = (u32)(u64) si;
919 regs->u_regs[UREG_I2] = (u32)(u64) uc;
924 force_sigsegv(signr, current);
928 svr4_getcontext(svr4_ucontext_t __user *uc, struct pt_regs *regs)
930 svr4_gregset_t __user *gr;
931 svr4_mcontext_t __user *mc;
936 synchronize_user_stack();
937 save_and_clear_fpu();
939 if (get_thread_wsaved())
942 err = clear_user(uc, sizeof(*uc));
944 /* Setup convenience variables */
948 setv.sigbits[0] = current->blocked.sig[0];
949 setv.sigbits[1] = (current->blocked.sig[0] >> 32);
950 if (_NSIG_WORDS >= 2) {
951 setv.sigbits[2] = current->blocked.sig[1];
952 setv.sigbits[3] = (current->blocked.sig[1] >> 32);
953 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
955 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
957 /* Store registers */
958 if (test_thread_flag(TIF_32BIT)) {
959 regs->tpc &= 0xffffffff;
960 regs->tnpc &= 0xffffffff;
962 err |= __put_user(regs->tpc, &uc->mcontext.greg[SVR4_PC]);
963 err |= __put_user(regs->tnpc, &uc->mcontext.greg[SVR4_NPC]);
965 psr = tstate_to_psr(regs->tstate) & ~PSR_EF;
966 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
968 err |= __put_user(psr, &uc->mcontext.greg[SVR4_PSR]);
970 err |= __put_user(regs->y, &uc->mcontext.greg[SVR4_Y]);
972 /* Copy g[1..7] and o[0..7] registers */
973 for (i = 0; i < 7; i++)
974 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
975 for (i = 0; i < 8; i++)
976 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
978 /* Setup sigaltstack */
979 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
980 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
981 err |= __put_user(current->sas_ss_size, &uc->stack.size);
983 /* The register file is not saved
984 * we have already stuffed all of it with sync_user_stack
986 return (err ? -EFAULT : 0);
990 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
991 asmlinkage int svr4_setcontext(svr4_ucontext_t __user *c, struct pt_regs *regs)
993 svr4_gregset_t __user *gr;
995 u32 pc, npc, psr, u_ss_sp;
1001 /* Fixme: restore windows, or is this already taken care of in
1002 * svr4_setup_frame when sync_user_windows is done?
1004 flush_user_windows();
1006 if (get_thread_wsaved())
1009 if (((unsigned long) c) & 3){
1010 printk("Unaligned structure passed\n");
1014 if (!__access_ok(c, sizeof(*c))) {
1015 /* Miguel, add nice debugging msg _here_. ;-) */
1019 /* Check for valid PC and nPC */
1020 gr = &c->mcontext.greg;
1021 err = __get_user(pc, &((*gr)[SVR4_PC]));
1022 err |= __get_user(npc, &((*gr)[SVR4_NPC]));
1026 /* Retrieve information from passed ucontext */
1027 /* note that nPC is ored a 1, this is used to inform entry.S */
1028 /* that we don't want it to mess with our PC and nPC */
1030 err |= copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
1031 set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32);
1032 if (_NSIG_WORDS >= 2)
1033 set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32);
1035 err |= __get_user(u_ss_sp, &c->stack.sp);
1036 st.ss_sp = compat_ptr(u_ss_sp);
1037 err |= __get_user(st.ss_flags, &c->stack.flags);
1038 err |= __get_user(st.ss_size, &c->stack.size);
1042 /* It is more difficult to avoid calling this function than to
1043 call it and ignore errors. */
1046 do_sigaltstack((stack_t __user *) &st, NULL, regs->u_regs[UREG_I6]);
1049 sigdelsetmask(&set, ~_BLOCKABLE);
1050 spin_lock_irq(¤t->sighand->siglock);
1051 current->blocked = set;
1052 recalc_sigpending();
1053 spin_unlock_irq(¤t->sighand->siglock);
1055 regs->tnpc = npc | 1;
1056 if (test_thread_flag(TIF_32BIT)) {
1057 regs->tpc &= 0xffffffff;
1058 regs->tnpc &= 0xffffffff;
1060 err |= __get_user(regs->y, &((*gr)[SVR4_Y]));
1061 err |= __get_user(psr, &((*gr)[SVR4_PSR]));
1062 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
1063 regs->tstate |= psr_to_tstate_icc(psr);
1065 /* Restore g[1..7] and o[0..7] registers */
1066 for (i = 0; i < 7; i++)
1067 err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1068 for (i = 0; i < 8; i++)
1069 err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1078 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
1079 unsigned long signr, sigset_t *oldset,
1082 struct rt_signal_frame32 __user *sf;
1086 compat_sigset_t seta;
1088 /* 1. Make sure everything is clean */
1089 synchronize_user_stack();
1090 save_and_clear_fpu();
1092 sigframe_size = RT_ALIGNEDSZ;
1093 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
1094 sigframe_size -= sizeof(__siginfo_fpu_t);
1096 sf = (struct rt_signal_frame32 __user *)
1097 get_sigframe(&ka->sa, regs, sigframe_size);
1099 if (invalid_frame_pointer(sf, sigframe_size))
1102 if (get_thread_wsaved() != 0)
1105 /* 2. Save the current process state */
1106 if (test_thread_flag(TIF_32BIT)) {
1107 regs->tpc &= 0xffffffff;
1108 regs->tnpc &= 0xffffffff;
1110 err = put_user(regs->tpc, &sf->regs.pc);
1111 err |= __put_user(regs->tnpc, &sf->regs.npc);
1112 err |= __put_user(regs->y, &sf->regs.y);
1113 psr = tstate_to_psr(regs->tstate);
1114 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
1116 err |= __put_user(psr, &sf->regs.psr);
1117 for (i = 0; i < 16; i++)
1118 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
1119 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
1120 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
1121 for (i = 1; i < 16; i++)
1122 err |= __put_user(((u32 *)regs->u_regs)[2*i],
1123 &sf->v8plus.g_upper[i]);
1124 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
1128 err |= save_fpu_state32(regs, &sf->fpu_state);
1129 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
1131 err |= __put_user(0, &sf->fpu_save);
1134 /* Update the siginfo structure. */
1135 err |= copy_siginfo_to_user32(&sf->info, info);
1137 /* Setup sigaltstack */
1138 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
1139 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
1140 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
1142 switch (_NSIG_WORDS) {
1143 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
1144 seta.sig[6] = oldset->sig[3];
1145 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
1146 seta.sig[4] = oldset->sig[2];
1147 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
1148 seta.sig[2] = oldset->sig[1];
1149 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
1150 seta.sig[0] = oldset->sig[0];
1152 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
1154 err |= copy_in_user((u32 __user *)sf,
1155 (u32 __user *)(regs->u_regs[UREG_FP]),
1156 sizeof(struct reg_window32));
1160 /* 3. signal handler back-trampoline and parameters */
1161 regs->u_regs[UREG_FP] = (unsigned long) sf;
1162 regs->u_regs[UREG_I0] = signr;
1163 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
1164 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
1166 /* 4. signal handler */
1167 regs->tpc = (unsigned long) ka->sa.sa_handler;
1168 regs->tnpc = (regs->tpc + 4);
1169 if (test_thread_flag(TIF_32BIT)) {
1170 regs->tpc &= 0xffffffff;
1171 regs->tnpc &= 0xffffffff;
1174 /* 5. return to kernel instructions */
1175 if (ka->ka_restorer)
1176 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
1178 /* Flush instruction space. */
1179 unsigned long address = ((unsigned long)&(sf->insns[0]));
1180 pgd_t *pgdp = pgd_offset(current->mm, address);
1181 pud_t *pudp = pud_offset(pgdp, address);
1182 pmd_t *pmdp = pmd_offset(pudp, address);
1185 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
1187 /* mov __NR_rt_sigreturn, %g1 */
1188 err |= __put_user(0x82102065, &sf->insns[0]);
1191 err |= __put_user(0x91d02010, &sf->insns[1]);
1196 ptep = pte_offset_map(pmdp, address);
1197 if (pte_present(*ptep)) {
1198 unsigned long page = (unsigned long)
1199 page_address(pte_page(*ptep));
1202 __asm__ __volatile__("flush %0 + %1"
1205 "r" (address & (PAGE_SIZE - 1))
1216 force_sigsegv(signr, current);
1219 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
1221 sigset_t *oldset, struct pt_regs *regs,
1225 setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc,
1226 regs, signr, oldset);
1228 if (ka->sa.sa_flags & SA_SIGINFO)
1229 setup_rt_frame32(ka, regs, signr, oldset, info);
1230 else if (test_thread_flag(TIF_NEWSIGNALS))
1231 new_setup_frame32(ka, regs, signr, oldset);
1233 setup_frame32(&ka->sa, regs, signr, oldset, info);
1235 spin_lock_irq(¤t->sighand->siglock);
1236 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
1237 if (!(ka->sa.sa_flags & SA_NOMASK))
1238 sigaddset(¤t->blocked,signr);
1239 recalc_sigpending();
1240 spin_unlock_irq(¤t->sighand->siglock);
1241 tracehook_report_handle_signal(signr, ka, oldset, regs);
1244 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
1245 struct sigaction *sa)
1247 switch (regs->u_regs[UREG_I0]) {
1248 case ERESTART_RESTARTBLOCK:
1249 case ERESTARTNOHAND:
1250 no_system_call_restart:
1251 regs->u_regs[UREG_I0] = EINTR;
1252 regs->tstate |= TSTATE_ICARRY;
1255 if (!(sa->sa_flags & SA_RESTART))
1256 goto no_system_call_restart;
1258 case ERESTARTNOINTR:
1259 regs->u_regs[UREG_I0] = orig_i0;
1265 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1266 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1269 void do_signal32(sigset_t *oldset, struct pt_regs * regs,
1270 unsigned long orig_i0, int restart_syscall)
1273 struct signal_deliver_cookie cookie;
1274 struct k_sigaction ka;
1276 int svr4_signal = current->personality == PER_SVR4;
1278 cookie.restart_syscall = restart_syscall;
1279 cookie.orig_i0 = orig_i0;
1281 signr = get_signal_to_deliver(&info, &ka, regs, &cookie);
1283 if (cookie.restart_syscall)
1284 syscall_restart32(orig_i0, regs, &ka.sa);
1285 handle_signal32(signr, &ka, &info, oldset,
1288 /* a signal was successfully delivered; the saved
1289 * sigmask will have been stored in the signal frame,
1290 * and will be restored by sigreturn, so we can simply
1291 * clear the TIF_RESTORE_SIGMASK flag.
1293 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1294 clear_thread_flag(TIF_RESTORE_SIGMASK);
1297 if (cookie.restart_syscall &&
1298 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1299 regs->u_regs[UREG_I0] == ERESTARTSYS ||
1300 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1301 /* replay the system call when we are done */
1302 regs->u_regs[UREG_I0] = cookie.orig_i0;
1306 if (cookie.restart_syscall &&
1307 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
1308 regs->u_regs[UREG_G1] = __NR_restart_syscall;
1313 /* if there's no signal to deliver, we just put the saved sigmask
1316 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1317 clear_thread_flag(TIF_RESTORE_SIGMASK);
1318 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
1327 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
1329 struct sigstack32 __user *ssptr =
1330 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
1331 struct sigstack32 __user *ossptr =
1332 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
1335 /* First see if old state is wanted. */
1337 if (put_user(current->sas_ss_sp + current->sas_ss_size,
1338 &ossptr->the_stack) ||
1339 __put_user(on_sig_stack(sp), &ossptr->cur_status))
1343 /* Now see if we want to update the new state. */
1347 if (get_user(ss_sp, &ssptr->the_stack))
1350 /* If the current stack was set with sigaltstack, don't
1351 * swap stacks while we are on it.
1354 if (current->sas_ss_sp && on_sig_stack(sp))
1357 /* Since we don't know the extent of the stack, and we don't
1358 * track onstack-ness, but rather calculate it, we must
1359 * presume a size. Ho hum this interface is lossy.
1361 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1362 current->sas_ss_size = SIGSTKSZ;
1370 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
1375 mm_segment_t old_fs;
1376 stack_t32 __user *uss32 = compat_ptr(ussa);
1377 stack_t32 __user *uoss32 = compat_ptr(uossa);
1379 if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
1380 __get_user(uss.ss_flags, &uss32->ss_flags) ||
1381 __get_user(uss.ss_size, &uss32->ss_size)))
1383 uss.ss_sp = compat_ptr(u_ss_sp);
1386 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
1387 uossa ? (stack_t __user *) &uoss : NULL, sp);
1389 if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
1390 __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
1391 __put_user(uoss.ss_size, &uoss32->ss_size)))