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];
63 * And the new one, intended to be used for Linux applications only
64 * (we have enough in there to work with clone).
65 * All the interesting bits are in the info field.
67 struct new_signal_frame32 {
68 struct sparc_stackf32 ss;
70 /* __siginfo_fpu32_t * */ u32 fpu_save;
71 unsigned int insns[2];
72 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
73 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
74 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
75 siginfo_extra_v8plus_t v8plus;
76 __siginfo_fpu_t fpu_state;
79 struct rt_signal_frame32 {
80 struct sparc_stackf32 ss;
82 struct pt_regs32 regs;
84 /* __siginfo_fpu32_t * */ u32 fpu_save;
85 unsigned int insns[2];
87 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
88 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
89 siginfo_extra_v8plus_t v8plus;
90 __siginfo_fpu_t fpu_state;
94 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe32) + 7) & (~7)))
95 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame32) + 7) & (~7)))
96 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
98 int copy_siginfo_to_user32(siginfo_t32 __user *to, siginfo_t *from)
102 if (!access_ok(VERIFY_WRITE, to, sizeof(siginfo_t32)))
105 /* If you change siginfo_t structure, please be sure
106 this code is fixed accordingly.
107 It should never copy any pad contained in the structure
108 to avoid security leaks, but must copy the generic
109 3 ints plus the relevant union member.
110 This routine must convert siginfo from 64bit to 32bit as well
112 err = __put_user(from->si_signo, &to->si_signo);
113 err |= __put_user(from->si_errno, &to->si_errno);
114 err |= __put_user((short)from->si_code, &to->si_code);
115 if (from->si_code < 0)
116 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
118 switch (from->si_code >> 16) {
119 case __SI_TIMER >> 16:
120 err |= __put_user(from->si_tid, &to->si_tid);
121 err |= __put_user(from->si_overrun, &to->si_overrun);
122 err |= __put_user((u32)(u64)from->si_ptr, &to->si_ptr);
124 case __SI_CHLD >> 16:
125 err |= __put_user(from->si_utime, &to->si_utime);
126 err |= __put_user(from->si_stime, &to->si_stime);
127 err |= __put_user(from->si_status, &to->si_status);
129 err |= __put_user(from->si_pid, &to->si_pid);
130 err |= __put_user(from->si_uid, &to->si_uid);
132 case __SI_FAULT >> 16:
133 case __SI_POLL >> 16:
134 err |= __put_user(from->si_trapno, &to->si_trapno);
135 err |= __put_user((long)from->si_addr, &to->si_addr);
137 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
138 case __SI_MESGQ >> 16:
139 err |= __put_user(from->si_pid, &to->si_pid);
140 err |= __put_user(from->si_uid, &to->si_uid);
141 err |= __put_user(from->si_int, &to->si_int);
149 * atomically swap in the new signal mask, and wait for a signal.
150 * This is really tricky on the Sparc, watch out...
152 asmlinkage void _sigpause32_common(compat_old_sigset_t set, struct pt_regs *regs)
157 spin_lock_irq(¤t->sighand->siglock);
158 saveset = current->blocked;
159 siginitset(¤t->blocked, set);
161 spin_unlock_irq(¤t->sighand->siglock);
163 regs->tpc = regs->tnpc;
165 if (test_thread_flag(TIF_32BIT)) {
166 regs->tpc &= 0xffffffff;
167 regs->tnpc &= 0xffffffff;
170 /* Condition codes and return value where set here for sigpause,
171 * and so got used by setup_frame, which again causes sigreturn()
175 current->state = TASK_INTERRUPTIBLE;
178 * Return -EINTR and set condition code here,
179 * so the interrupted system call actually returns
182 regs->tstate |= TSTATE_ICARRY;
183 regs->u_regs[UREG_I0] = EINTR;
184 if (do_signal32(&saveset, regs, 0, 0))
189 asmlinkage void do_rt_sigsuspend32(u32 uset, size_t sigsetsize, struct pt_regs *regs)
191 sigset_t oldset, set;
192 compat_sigset_t set32;
194 /* XXX: Don't preclude handling different sized sigset_t's. */
195 if (((compat_size_t)sigsetsize) != sizeof(sigset_t)) {
196 regs->tstate |= TSTATE_ICARRY;
197 regs->u_regs[UREG_I0] = EINVAL;
200 if (copy_from_user(&set32, (void __user *)(long)uset, sizeof(set32))) {
201 regs->tstate |= TSTATE_ICARRY;
202 regs->u_regs[UREG_I0] = EFAULT;
205 switch (_NSIG_WORDS) {
206 case 4: set.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
207 case 3: set.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
208 case 2: set.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
209 case 1: set.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
211 sigdelsetmask(&set, ~_BLOCKABLE);
212 spin_lock_irq(¤t->sighand->siglock);
213 oldset = current->blocked;
214 current->blocked = set;
216 spin_unlock_irq(¤t->sighand->siglock);
218 regs->tpc = regs->tnpc;
220 if (test_thread_flag(TIF_32BIT)) {
221 regs->tpc &= 0xffffffff;
222 regs->tnpc &= 0xffffffff;
225 /* Condition codes and return value where set here for sigpause,
226 * and so got used by setup_frame, which again causes sigreturn()
230 current->state = TASK_INTERRUPTIBLE;
233 * Return -EINTR and set condition code here,
234 * so the interrupted system call actually returns
237 regs->tstate |= TSTATE_ICARRY;
238 regs->u_regs[UREG_I0] = EINTR;
239 if (do_signal32(&oldset, regs, 0, 0))
244 static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
246 unsigned long *fpregs = current_thread_info()->fpregs;
250 err = __get_user(fprs, &fpu->si_fprs);
252 regs->tstate &= ~TSTATE_PEF;
254 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
256 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
257 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
258 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
259 current_thread_info()->fpsaved[0] |= fprs;
263 void do_new_sigreturn32(struct pt_regs *regs)
265 struct new_signal_frame32 __user *sf;
267 unsigned pc, npc, fpu_save;
269 unsigned seta[_COMPAT_NSIG_WORDS];
272 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
273 sf = (struct new_signal_frame32 __user *) regs->u_regs[UREG_FP];
275 /* 1. Make sure we are not getting garbage from the user */
276 if (verify_area(VERIFY_READ, sf, sizeof(*sf)) ||
277 (((unsigned long) sf) & 3))
280 get_user(pc, &sf->info.si_regs.pc);
281 __get_user(npc, &sf->info.si_regs.npc);
286 if (test_thread_flag(TIF_32BIT)) {
293 /* 2. Restore the state */
294 err = __get_user(regs->y, &sf->info.si_regs.y);
295 err |= __get_user(psr, &sf->info.si_regs.psr);
297 for (i = UREG_G1; i <= UREG_I7; i++)
298 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
299 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
300 err |= __get_user(i, &sf->v8plus.g_upper[0]);
301 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
302 for (i = UREG_G1; i <= UREG_I7; i++)
303 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
307 /* User can only change condition codes in %tstate. */
308 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
309 regs->tstate |= psr_to_tstate_icc(psr);
311 err |= __get_user(fpu_save, &sf->fpu_save);
313 err |= restore_fpu_state32(regs, &sf->fpu_state);
314 err |= __get_user(seta[0], &sf->info.si_mask);
315 err |= copy_from_user(seta+1, &sf->extramask,
316 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
319 switch (_NSIG_WORDS) {
320 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
321 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
322 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
323 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
325 sigdelsetmask(&set, ~_BLOCKABLE);
326 spin_lock_irq(¤t->sighand->siglock);
327 current->blocked = set;
329 spin_unlock_irq(¤t->sighand->siglock);
336 asmlinkage void do_sigreturn32(struct pt_regs *regs)
338 struct sigcontext32 __user *scptr;
339 unsigned int pc, npc, psr;
341 unsigned int seta[_COMPAT_NSIG_WORDS];
344 /* Always make any pending restarted system calls return -EINTR */
345 current_thread_info()->restart_block.fn = do_no_restart_syscall;
347 synchronize_user_stack();
348 if (test_thread_flag(TIF_NEWSIGNALS)) {
349 do_new_sigreturn32(regs);
353 scptr = (struct sigcontext32 __user *)
354 (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
355 /* Check sanity of the user arg. */
356 if (verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
357 (((unsigned long) scptr) & 3))
360 err = __get_user(pc, &scptr->sigc_pc);
361 err |= __get_user(npc, &scptr->sigc_npc);
364 goto segv; /* Nice try. */
366 err |= __get_user(seta[0], &scptr->sigc_mask);
367 /* Note that scptr + 1 points to extramask */
368 err |= copy_from_user(seta+1, scptr + 1,
369 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
372 switch (_NSIG_WORDS) {
373 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
374 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
375 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
376 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
378 sigdelsetmask(&set, ~_BLOCKABLE);
379 spin_lock_irq(¤t->sighand->siglock);
380 current->blocked = set;
382 spin_unlock_irq(¤t->sighand->siglock);
384 if (test_thread_flag(TIF_32BIT)) {
390 err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
391 err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
392 err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
394 /* User can only change condition codes in %tstate. */
395 err |= __get_user(psr, &scptr->sigc_psr);
398 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
399 regs->tstate |= psr_to_tstate_icc(psr);
406 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
408 struct rt_signal_frame32 __user *sf;
409 unsigned int psr, pc, npc, fpu_save, u_ss_sp;
412 compat_sigset_t seta;
416 /* Always make any pending restarted system calls return -EINTR */
417 current_thread_info()->restart_block.fn = do_no_restart_syscall;
419 synchronize_user_stack();
420 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
421 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
423 /* 1. Make sure we are not getting garbage from the user */
424 if (verify_area(VERIFY_READ, sf, sizeof(*sf)) ||
425 (((unsigned long) sf) & 3))
428 get_user(pc, &sf->regs.pc);
429 __get_user(npc, &sf->regs.npc);
434 if (test_thread_flag(TIF_32BIT)) {
441 /* 2. Restore the state */
442 err = __get_user(regs->y, &sf->regs.y);
443 err |= __get_user(psr, &sf->regs.psr);
445 for (i = UREG_G1; i <= UREG_I7; i++)
446 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
447 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
448 err |= __get_user(i, &sf->v8plus.g_upper[0]);
449 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
450 for (i = UREG_G1; i <= UREG_I7; i++)
451 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
455 /* User can only change condition codes in %tstate. */
456 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
457 regs->tstate |= psr_to_tstate_icc(psr);
459 err |= __get_user(fpu_save, &sf->fpu_save);
461 err |= restore_fpu_state32(regs, &sf->fpu_state);
462 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
463 err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
464 st.ss_sp = compat_ptr(u_ss_sp);
465 err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
466 err |= __get_user(st.ss_size, &sf->stack.ss_size);
470 /* It is more difficult to avoid calling this function than to
471 call it and ignore errors. */
474 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
477 switch (_NSIG_WORDS) {
478 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
479 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
480 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
481 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
483 sigdelsetmask(&set, ~_BLOCKABLE);
484 spin_lock_irq(¤t->sighand->siglock);
485 current->blocked = set;
487 spin_unlock_irq(¤t->sighand->siglock);
493 /* Checks if the fp is valid */
494 static int invalid_frame_pointer(void __user *fp, int fplen)
496 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
501 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
505 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
506 sp = regs->u_regs[UREG_FP];
508 /* This is the X/Open sanctioned signal stack switching. */
509 if (sa->sa_flags & SA_ONSTACK) {
510 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
511 sp = current->sas_ss_sp + current->sas_ss_size;
513 return (void __user *)(sp - framesize);
517 setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
519 struct signal_sframe32 __user *sframep;
520 struct sigcontext32 __user *sc;
521 unsigned int seta[_COMPAT_NSIG_WORDS];
523 void __user *sig_address;
525 unsigned long pc = regs->tpc;
526 unsigned long npc = regs->tnpc;
529 if (test_thread_flag(TIF_32BIT)) {
534 synchronize_user_stack();
535 save_and_clear_fpu();
537 sframep = (struct signal_sframe32 __user *)
538 get_sigframe(sa, regs, SF_ALIGNEDSZ);
539 if (invalid_frame_pointer(sframep, sizeof(*sframep))){
540 /* Don't change signal code and address, so that
541 * post mortem debuggers can have a look.
546 sc = &sframep->sig_context;
548 /* We've already made sure frame pointer isn't in kernel space... */
549 err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
552 switch (_NSIG_WORDS) {
553 case 4: seta[7] = (oldset->sig[3] >> 32);
554 seta[6] = oldset->sig[3];
555 case 3: seta[5] = (oldset->sig[2] >> 32);
556 seta[4] = oldset->sig[2];
557 case 2: seta[3] = (oldset->sig[1] >> 32);
558 seta[2] = oldset->sig[1];
559 case 1: seta[1] = (oldset->sig[0] >> 32);
560 seta[0] = oldset->sig[0];
562 err |= __put_user(seta[0], &sc->sigc_mask);
563 err |= __copy_to_user(sframep->extramask, seta + 1,
564 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
565 err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
566 err |= __put_user(pc, &sc->sigc_pc);
567 err |= __put_user(npc, &sc->sigc_npc);
568 psr = tstate_to_psr(regs->tstate);
569 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
571 err |= __put_user(psr, &sc->sigc_psr);
572 err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
573 err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
574 err |= __put_user(get_thread_wsaved(), &sc->sigc_oswins);
576 err |= copy_in_user((u32 __user *)sframep,
577 (u32 __user *)(regs->u_regs[UREG_FP]),
578 sizeof(struct reg_window32));
580 set_thread_wsaved(0); /* So process is allowed to execute. */
581 err |= __put_user(signr, &sframep->sig_num);
584 if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
585 sig_address = info->si_addr;
588 switch (info->si_code) {
589 case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
590 default: sig_code = SUBSIG_PROTECTION; break;
594 switch (info->si_code) {
595 case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
596 case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
597 case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
598 default: sig_code = SUBSIG_STACK; break;
602 switch (info->si_code) {
603 case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
604 case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
605 case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
606 case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
607 case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
608 case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
609 case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
610 default: sig_code = SUBSIG_FPERROR; break;
614 switch (info->si_code) {
615 case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
616 case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
617 default: sig_code = SUBSIG_BUSTIMEOUT; break;
621 switch (info->si_code) {
622 case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
626 if (info->si_code == (__SI_FAULT|0x100)) {
627 /* See sys_sunos32.c */
628 sig_code = info->si_trapno;
635 err |= __put_user((long)sig_address, &sframep->sig_address);
636 err |= __put_user(sig_code, &sframep->sig_code);
637 err |= __put_user((u64)sc, &sframep->sig_scptr);
641 regs->u_regs[UREG_FP] = (unsigned long) sframep;
642 regs->tpc = (unsigned long) sa->sa_handler;
643 regs->tnpc = (regs->tpc + 4);
644 if (test_thread_flag(TIF_32BIT)) {
645 regs->tpc &= 0xffffffff;
646 regs->tnpc &= 0xffffffff;
655 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
657 unsigned long *fpregs = current_thread_info()->fpregs;
661 fprs = current_thread_info()->fpsaved[0];
663 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
664 (sizeof(unsigned int) * 32));
666 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
667 (sizeof(unsigned int) * 32));
668 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
669 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
670 err |= __put_user(fprs, &fpu->si_fprs);
675 static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
676 int signo, sigset_t *oldset)
678 struct new_signal_frame32 __user *sf;
682 unsigned int seta[_COMPAT_NSIG_WORDS];
684 /* 1. Make sure everything is clean */
685 synchronize_user_stack();
686 save_and_clear_fpu();
688 sigframe_size = NF_ALIGNEDSZ;
689 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
690 sigframe_size -= sizeof(__siginfo_fpu_t);
692 sf = (struct new_signal_frame32 __user *)
693 get_sigframe(&ka->sa, regs, sigframe_size);
695 if (invalid_frame_pointer(sf, sigframe_size))
698 if (get_thread_wsaved() != 0)
701 /* 2. Save the current process state */
702 if (test_thread_flag(TIF_32BIT)) {
703 regs->tpc &= 0xffffffff;
704 regs->tnpc &= 0xffffffff;
706 err = put_user(regs->tpc, &sf->info.si_regs.pc);
707 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
708 err |= __put_user(regs->y, &sf->info.si_regs.y);
709 psr = tstate_to_psr(regs->tstate);
710 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
712 err |= __put_user(psr, &sf->info.si_regs.psr);
713 for (i = 0; i < 16; i++)
714 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
715 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
716 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
717 for (i = 1; i < 16; i++)
718 err |= __put_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
721 err |= save_fpu_state32(regs, &sf->fpu_state);
722 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
724 err |= __put_user(0, &sf->fpu_save);
727 switch (_NSIG_WORDS) {
728 case 4: seta[7] = (oldset->sig[3] >> 32);
729 seta[6] = oldset->sig[3];
730 case 3: seta[5] = (oldset->sig[2] >> 32);
731 seta[4] = oldset->sig[2];
732 case 2: seta[3] = (oldset->sig[1] >> 32);
733 seta[2] = oldset->sig[1];
734 case 1: seta[1] = (oldset->sig[0] >> 32);
735 seta[0] = oldset->sig[0];
737 err |= __put_user(seta[0], &sf->info.si_mask);
738 err |= __copy_to_user(sf->extramask, seta + 1,
739 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
741 err |= copy_in_user((u32 __user *)sf,
742 (u32 __user *)(regs->u_regs[UREG_FP]),
743 sizeof(struct reg_window32));
748 /* 3. signal handler back-trampoline and parameters */
749 regs->u_regs[UREG_FP] = (unsigned long) sf;
750 regs->u_regs[UREG_I0] = signo;
751 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
753 /* 4. signal handler */
754 regs->tpc = (unsigned long) ka->sa.sa_handler;
755 regs->tnpc = (regs->tpc + 4);
756 if (test_thread_flag(TIF_32BIT)) {
757 regs->tpc &= 0xffffffff;
758 regs->tnpc &= 0xffffffff;
761 /* 5. return to kernel instructions */
762 if (ka->ka_restorer) {
763 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
765 /* Flush instruction space. */
766 unsigned long address = ((unsigned long)&(sf->insns[0]));
767 pgd_t *pgdp = pgd_offset(current->mm, address);
768 pmd_t *pmdp = pmd_offset(pgdp, 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);
780 if (pte_present(*ptep)) {
781 unsigned long page = (unsigned long)
782 page_address(pte_page(*ptep));
784 __asm__ __volatile__(
785 " membar #StoreStore\n"
787 : : "r" (page), "r" (address & (PAGE_SIZE - 1))
801 /* Setup a Solaris stack frame */
803 setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc,
804 struct pt_regs *regs, int signr, sigset_t *oldset)
806 svr4_signal_frame_t __user *sfp;
807 svr4_gregset_t __user *gr;
808 svr4_siginfo_t __user *si;
809 svr4_mcontext_t __user *mc;
810 svr4_gwindows_t __user *gw;
811 svr4_ucontext_t __user *uc;
816 synchronize_user_stack();
817 save_and_clear_fpu();
819 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
820 sfp = (svr4_signal_frame_t __user *)
821 get_sigframe(sa, regs,
822 sizeof(struct reg_window32) + SVR4_SF_ALIGNED);
824 if (invalid_frame_pointer(sfp, sizeof(*sfp)))
827 /* Start with a clean frame pointer and fill it */
828 err = clear_user(sfp, sizeof(*sfp));
830 /* Setup convenience variables */
837 /* FIXME: where am I supposed to put this?
838 * sc->sigc_onstack = old_status;
839 * anyways, it does not look like it is used for anything at all.
841 setv.sigbits[0] = oldset->sig[0];
842 setv.sigbits[1] = (oldset->sig[0] >> 32);
843 if (_NSIG_WORDS >= 2) {
844 setv.sigbits[2] = oldset->sig[1];
845 setv.sigbits[3] = (oldset->sig[1] >> 32);
846 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
848 err |= __copy_to_user(&uc->sigmask, &setv,
849 2 * sizeof(unsigned int));
851 /* Store registers */
852 if (test_thread_flag(TIF_32BIT)) {
853 regs->tpc &= 0xffffffff;
854 regs->tnpc &= 0xffffffff;
856 err |= __put_user(regs->tpc, &((*gr)[SVR4_PC]));
857 err |= __put_user(regs->tnpc, &((*gr)[SVR4_NPC]));
858 psr = tstate_to_psr(regs->tstate);
859 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
861 err |= __put_user(psr, &((*gr)[SVR4_PSR]));
862 err |= __put_user(regs->y, &((*gr)[SVR4_Y]));
864 /* Copy g[1..7] and o[0..7] registers */
865 for (i = 0; i < 7; i++)
866 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
867 for (i = 0; i < 8; i++)
868 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
870 /* Setup sigaltstack */
871 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
872 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
873 err |= __put_user(current->sas_ss_size, &uc->stack.size);
875 /* Save the currently window file: */
877 /* 1. Link sfp->uc->gwins to our windows */
878 err |= __put_user((u32)(long)gw, &mc->gwin);
880 /* 2. Number of windows to restore at setcontext (): */
881 err |= __put_user(get_thread_wsaved(), &gw->count);
883 /* 3. We just pay attention to the gw->count field on setcontext */
884 set_thread_wsaved(0); /* So process is allowed to execute. */
886 /* Setup the signal information. Solaris expects a bunch of
887 * information to be passed to the signal handler, we don't provide
888 * that much currently, should use siginfo.
890 err |= __put_user(signr, &si->siginfo.signo);
891 err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
895 regs->u_regs[UREG_FP] = (unsigned long) sfp;
896 regs->tpc = (unsigned long) sa->sa_handler;
897 regs->tnpc = (regs->tpc + 4);
898 if (test_thread_flag(TIF_32BIT)) {
899 regs->tpc &= 0xffffffff;
900 regs->tnpc &= 0xffffffff;
903 /* Arguments passed to signal handler */
904 if (regs->u_regs[14]){
905 struct reg_window32 __user *rw = (struct reg_window32 __user *)
906 (regs->u_regs[14] & 0x00000000ffffffffUL);
908 err |= __put_user(signr, &rw->ins[0]);
909 err |= __put_user((u64)si, &rw->ins[1]);
910 err |= __put_user((u64)uc, &rw->ins[2]);
911 err |= __put_user((u64)sfp, &rw->ins[6]); /* frame pointer */
915 regs->u_regs[UREG_I0] = signr;
916 regs->u_regs[UREG_I1] = (u32)(u64) si;
917 regs->u_regs[UREG_I2] = (u32)(u64) uc;
926 svr4_getcontext(svr4_ucontext_t __user *uc, struct pt_regs *regs)
928 svr4_gregset_t __user *gr;
929 svr4_mcontext_t __user *mc;
934 synchronize_user_stack();
935 save_and_clear_fpu();
937 if (get_thread_wsaved())
940 err = clear_user(uc, sizeof(*uc));
942 /* Setup convenience variables */
946 setv.sigbits[0] = current->blocked.sig[0];
947 setv.sigbits[1] = (current->blocked.sig[0] >> 32);
948 if (_NSIG_WORDS >= 2) {
949 setv.sigbits[2] = current->blocked.sig[1];
950 setv.sigbits[3] = (current->blocked.sig[1] >> 32);
951 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
953 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
955 /* Store registers */
956 if (test_thread_flag(TIF_32BIT)) {
957 regs->tpc &= 0xffffffff;
958 regs->tnpc &= 0xffffffff;
960 err |= __put_user(regs->tpc, &uc->mcontext.greg[SVR4_PC]);
961 err |= __put_user(regs->tnpc, &uc->mcontext.greg[SVR4_NPC]);
963 psr = tstate_to_psr(regs->tstate) & ~PSR_EF;
964 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
966 err |= __put_user(psr, &uc->mcontext.greg[SVR4_PSR]);
968 err |= __put_user(regs->y, &uc->mcontext.greg[SVR4_Y]);
970 /* Copy g[1..7] and o[0..7] registers */
971 for (i = 0; i < 7; i++)
972 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
973 for (i = 0; i < 8; i++)
974 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
976 /* Setup sigaltstack */
977 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
978 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
979 err |= __put_user(current->sas_ss_size, &uc->stack.size);
981 /* The register file is not saved
982 * we have already stuffed all of it with sync_user_stack
984 return (err ? -EFAULT : 0);
988 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
989 asmlinkage int svr4_setcontext(svr4_ucontext_t __user *c, struct pt_regs *regs)
991 svr4_gregset_t __user *gr;
993 u32 pc, npc, psr, u_ss_sp;
999 /* Fixme: restore windows, or is this already taken care of in
1000 * svr4_setup_frame when sync_user_windows is done?
1002 flush_user_windows();
1004 if (get_thread_wsaved())
1007 if (((unsigned long) c) & 3){
1008 printk("Unaligned structure passed\n");
1012 if (!__access_ok((unsigned long)c, sizeof(*c))) {
1013 /* Miguel, add nice debugging msg _here_. ;-) */
1017 /* Check for valid PC and nPC */
1018 gr = &c->mcontext.greg;
1019 err = __get_user(pc, &((*gr)[SVR4_PC]));
1020 err |= __get_user(npc, &((*gr)[SVR4_NPC]));
1024 /* Retrieve information from passed ucontext */
1025 /* note that nPC is ored a 1, this is used to inform entry.S */
1026 /* that we don't want it to mess with our PC and nPC */
1028 err |= copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
1029 set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32);
1030 if (_NSIG_WORDS >= 2)
1031 set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32);
1033 err |= __get_user(u_ss_sp, &c->stack.sp);
1034 st.ss_sp = compat_ptr(u_ss_sp);
1035 err |= __get_user(st.ss_flags, &c->stack.flags);
1036 err |= __get_user(st.ss_size, &c->stack.size);
1040 /* It is more difficult to avoid calling this function than to
1041 call it and ignore errors. */
1044 do_sigaltstack((stack_t __user *) &st, NULL, regs->u_regs[UREG_I6]);
1047 sigdelsetmask(&set, ~_BLOCKABLE);
1048 spin_lock_irq(¤t->sighand->siglock);
1049 current->blocked = set;
1050 recalc_sigpending();
1051 spin_unlock_irq(¤t->sighand->siglock);
1053 regs->tnpc = npc | 1;
1054 if (test_thread_flag(TIF_32BIT)) {
1055 regs->tpc &= 0xffffffff;
1056 regs->tnpc &= 0xffffffff;
1058 err |= __get_user(regs->y, &((*gr)[SVR4_Y]));
1059 err |= __get_user(psr, &((*gr)[SVR4_PSR]));
1060 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
1061 regs->tstate |= psr_to_tstate_icc(psr);
1063 /* Restore g[1..7] and o[0..7] registers */
1064 for (i = 0; i < 7; i++)
1065 err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1066 for (i = 0; i < 8; i++)
1067 err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1076 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
1077 unsigned long signr, sigset_t *oldset,
1080 struct rt_signal_frame32 __user *sf;
1084 compat_sigset_t seta;
1086 /* 1. Make sure everything is clean */
1087 synchronize_user_stack();
1088 save_and_clear_fpu();
1090 sigframe_size = RT_ALIGNEDSZ;
1091 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
1092 sigframe_size -= sizeof(__siginfo_fpu_t);
1094 sf = (struct rt_signal_frame32 __user *)
1095 get_sigframe(&ka->sa, regs, sigframe_size);
1097 if (invalid_frame_pointer(sf, sigframe_size))
1100 if (get_thread_wsaved() != 0)
1103 /* 2. Save the current process state */
1104 if (test_thread_flag(TIF_32BIT)) {
1105 regs->tpc &= 0xffffffff;
1106 regs->tnpc &= 0xffffffff;
1108 err = put_user(regs->tpc, &sf->regs.pc);
1109 err |= __put_user(regs->tnpc, &sf->regs.npc);
1110 err |= __put_user(regs->y, &sf->regs.y);
1111 psr = tstate_to_psr(regs->tstate);
1112 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
1114 err |= __put_user(psr, &sf->regs.psr);
1115 for (i = 0; i < 16; i++)
1116 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
1117 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
1118 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
1119 for (i = 1; i < 16; i++)
1120 err |= __put_user(((u32 *)regs->u_regs)[2*i],
1121 &sf->v8plus.g_upper[i]);
1124 err |= save_fpu_state32(regs, &sf->fpu_state);
1125 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
1127 err |= __put_user(0, &sf->fpu_save);
1130 /* Update the siginfo structure. */
1131 err |= copy_siginfo_to_user32(&sf->info, info);
1133 /* Setup sigaltstack */
1134 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
1135 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
1136 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
1138 switch (_NSIG_WORDS) {
1139 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
1140 seta.sig[6] = oldset->sig[3];
1141 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
1142 seta.sig[4] = oldset->sig[2];
1143 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
1144 seta.sig[2] = oldset->sig[1];
1145 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
1146 seta.sig[0] = oldset->sig[0];
1148 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
1150 err |= copy_in_user((u32 __user *)sf,
1151 (u32 __user *)(regs->u_regs[UREG_FP]),
1152 sizeof(struct reg_window32));
1156 /* 3. signal handler back-trampoline and parameters */
1157 regs->u_regs[UREG_FP] = (unsigned long) sf;
1158 regs->u_regs[UREG_I0] = signr;
1159 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
1161 /* 4. signal handler */
1162 regs->tpc = (unsigned long) ka->sa.sa_handler;
1163 regs->tnpc = (regs->tpc + 4);
1164 if (test_thread_flag(TIF_32BIT)) {
1165 regs->tpc &= 0xffffffff;
1166 regs->tnpc &= 0xffffffff;
1169 /* 5. return to kernel instructions */
1170 if (ka->ka_restorer)
1171 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
1173 /* Flush instruction space. */
1174 unsigned long address = ((unsigned long)&(sf->insns[0]));
1175 pgd_t *pgdp = pgd_offset(current->mm, address);
1176 pmd_t *pmdp = pmd_offset(pgdp, address);
1179 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
1181 /* mov __NR_rt_sigreturn, %g1 */
1182 err |= __put_user(0x82102065, &sf->insns[0]);
1185 err |= __put_user(0x91d02010, &sf->insns[1]);
1190 ptep = pte_offset_map(pmdp, address);
1191 if (pte_present(*ptep)) {
1192 unsigned long page = (unsigned long)
1193 page_address(pte_page(*ptep));
1195 __asm__ __volatile__(
1196 " membar #StoreStore\n"
1198 : : "r" (page), "r" (address & (PAGE_SIZE - 1))
1212 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
1214 sigset_t *oldset, struct pt_regs *regs,
1218 setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc,
1219 regs, signr, oldset);
1221 if (ka->sa.sa_flags & SA_SIGINFO)
1222 setup_rt_frame32(ka, regs, signr, oldset, info);
1223 else if (test_thread_flag(TIF_NEWSIGNALS))
1224 new_setup_frame32(ka, regs, signr, oldset);
1226 setup_frame32(&ka->sa, regs, signr, oldset, info);
1228 if (ka->sa.sa_flags & SA_ONESHOT)
1229 ka->sa.sa_handler = SIG_DFL;
1230 if (!(ka->sa.sa_flags & SA_NOMASK)) {
1231 spin_lock_irq(¤t->sighand->siglock);
1232 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
1233 sigaddset(¤t->blocked,signr);
1234 recalc_sigpending();
1235 spin_unlock_irq(¤t->sighand->siglock);
1239 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
1240 struct sigaction *sa)
1242 switch (regs->u_regs[UREG_I0]) {
1243 case ERESTART_RESTARTBLOCK:
1244 case ERESTARTNOHAND:
1245 no_system_call_restart:
1246 regs->u_regs[UREG_I0] = EINTR;
1247 regs->tstate |= TSTATE_ICARRY;
1250 if (!(sa->sa_flags & SA_RESTART))
1251 goto no_system_call_restart;
1253 case ERESTARTNOINTR:
1254 regs->u_regs[UREG_I0] = orig_i0;
1260 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1261 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1264 int do_signal32(sigset_t *oldset, struct pt_regs * regs,
1265 unsigned long orig_i0, int restart_syscall)
1268 struct signal_deliver_cookie cookie;
1270 int svr4_signal = current->personality == PER_SVR4;
1272 cookie.restart_syscall = restart_syscall;
1273 cookie.orig_i0 = orig_i0;
1275 signr = get_signal_to_deliver(&info, regs, &cookie);
1277 struct k_sigaction *ka;
1279 ka = ¤t->sighand->action[signr-1];
1281 if (cookie.restart_syscall)
1282 syscall_restart32(orig_i0, regs, &ka->sa);
1283 handle_signal32(signr, ka, &info, oldset, regs, svr4_signal);
1286 if (cookie.restart_syscall &&
1287 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1288 regs->u_regs[UREG_I0] == ERESTARTSYS ||
1289 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1290 /* replay the system call when we are done */
1291 regs->u_regs[UREG_I0] = cookie.orig_i0;
1295 if (cookie.restart_syscall &&
1296 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
1297 regs->u_regs[UREG_G1] = __NR_restart_syscall;
1309 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
1311 struct sigstack32 __user *ssptr =
1312 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
1313 struct sigstack32 __user *ossptr =
1314 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
1317 /* First see if old state is wanted. */
1319 if (put_user(current->sas_ss_sp + current->sas_ss_size,
1320 &ossptr->the_stack) ||
1321 __put_user(on_sig_stack(sp), &ossptr->cur_status))
1325 /* Now see if we want to update the new state. */
1329 if (get_user(ss_sp, &ssptr->the_stack))
1332 /* If the current stack was set with sigaltstack, don't
1333 * swap stacks while we are on it.
1336 if (current->sas_ss_sp && on_sig_stack(sp))
1339 /* Since we don't know the extent of the stack, and we don't
1340 * track onstack-ness, but rather calculate it, we must
1341 * presume a size. Ho hum this interface is lossy.
1343 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1344 current->sas_ss_size = SIGSTKSZ;
1352 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
1357 mm_segment_t old_fs;
1359 if (ussa && (get_user(u_ss_sp, &((stack_t32 __user *)(long)ussa)->ss_sp) ||
1360 __get_user(uss.ss_flags, &((stack_t32 __user *)(long)ussa)->ss_flags) ||
1361 __get_user(uss.ss_size, &((stack_t32 __user *)(long)ussa)->ss_size)))
1363 uss.ss_sp = compat_ptr(u_ss_sp);
1366 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
1367 uossa ? (stack_t __user *) &uoss : NULL, sp);
1369 if (!ret && uossa && (put_user((long)uoss.ss_sp, &((stack_t32 __user *)(long)uossa)->ss_sp) ||
1370 __put_user(uoss.ss_flags, &((stack_t32 __user *)(long)uossa)->ss_flags) ||
1371 __put_user(uoss.ss_size, &((stack_t32 __user *)(long)uossa)->ss_size)))