Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[linux-2.6] / arch / sparc64 / kernel / signal32.c
1 /*  $Id: signal32.c,v 1.74 2002/02/09 19:49:30 davem Exp $
2  *  arch/sparc64/kernel/signal32.c
3  *
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)
9  */
10
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>
18 #include <linux/mm.h>
19 #include <linux/tty.h>
20 #include <linux/binfmts.h>
21 #include <linux/compat.h>
22 #include <linux/bitops.h>
23
24 #include <asm/uaccess.h>
25 #include <asm/ptrace.h>
26 #include <asm/pgtable.h>
27 #include <asm/psrcompat.h>
28 #include <asm/fpumacro.h>
29 #include <asm/visasm.h>
30 #include <asm/compat_signal.h>
31
32 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
33
34 /* Signal frames: the original one (compatible with SunOS):
35  *
36  * Set up a signal frame... Make the stack look the way SunOS
37  * expects it to look which is basically:
38  *
39  * ---------------------------------- <-- %sp at signal time
40  * Struct sigcontext
41  * Signal address
42  * Ptr to sigcontext area above
43  * Signal code
44  * The signal number itself
45  * One register window
46  * ---------------------------------- <-- New %sp
47  */
48 struct signal_sframe32 {
49         struct reg_window32 sig_window;
50         int sig_num;
51         int sig_code;
52         /* struct sigcontext32 * */ u32 sig_scptr;
53         int sig_address;
54         struct sigcontext32 sig_context;
55         unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
56 };
57
58 /* This magic should be in g_upper[0] for all upper parts
59  * to be valid.
60  */
61 #define SIGINFO_EXTRA_V8PLUS_MAGIC      0x130e269
62 typedef struct {
63         unsigned int g_upper[8];
64         unsigned int o_upper[8];
65         unsigned int asi;
66 } siginfo_extra_v8plus_t;
67
68 /* 
69  * And the new one, intended to be used for Linux applications only
70  * (we have enough in there to work with clone).
71  * All the interesting bits are in the info field.
72  */
73 struct new_signal_frame32 {
74         struct sparc_stackf32   ss;
75         __siginfo32_t           info;
76         /* __siginfo_fpu32_t * */ u32 fpu_save;
77         unsigned int            insns[2];
78         unsigned int            extramask[_COMPAT_NSIG_WORDS - 1];
79         unsigned int            extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
80         /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
81         siginfo_extra_v8plus_t  v8plus;
82         __siginfo_fpu_t         fpu_state;
83 };
84
85 typedef struct compat_siginfo{
86         int si_signo;
87         int si_errno;
88         int si_code;
89
90         union {
91                 int _pad[SI_PAD_SIZE32];
92
93                 /* kill() */
94                 struct {
95                         compat_pid_t _pid;              /* sender's pid */
96                         unsigned int _uid;              /* sender's uid */
97                 } _kill;
98
99                 /* POSIX.1b timers */
100                 struct {
101                         compat_timer_t _tid;                    /* timer id */
102                         int _overrun;                   /* overrun count */
103                         compat_sigval_t _sigval;                /* same as below */
104                         int _sys_private;               /* not to be passed to user */
105                 } _timer;
106
107                 /* POSIX.1b signals */
108                 struct {
109                         compat_pid_t _pid;              /* sender's pid */
110                         unsigned int _uid;              /* sender's uid */
111                         compat_sigval_t _sigval;
112                 } _rt;
113
114                 /* SIGCHLD */
115                 struct {
116                         compat_pid_t _pid;              /* which child */
117                         unsigned int _uid;              /* sender's uid */
118                         int _status;                    /* exit code */
119                         compat_clock_t _utime;
120                         compat_clock_t _stime;
121                 } _sigchld;
122
123                 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
124                 struct {
125                         u32 _addr; /* faulting insn/memory ref. */
126                         int _trapno;
127                 } _sigfault;
128
129                 /* SIGPOLL */
130                 struct {
131                         int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
132                         int _fd;
133                 } _sigpoll;
134         } _sifields;
135 }compat_siginfo_t;
136
137 struct rt_signal_frame32 {
138         struct sparc_stackf32   ss;
139         compat_siginfo_t        info;
140         struct pt_regs32        regs;
141         compat_sigset_t         mask;
142         /* __siginfo_fpu32_t * */ u32 fpu_save;
143         unsigned int            insns[2];
144         stack_t32               stack;
145         unsigned int            extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
146         /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
147         siginfo_extra_v8plus_t  v8plus;
148         __siginfo_fpu_t         fpu_state;
149 };
150
151 /* Align macros */
152 #define SF_ALIGNEDSZ  (((sizeof(struct signal_sframe32) + 7) & (~7)))
153 #define NF_ALIGNEDSZ  (((sizeof(struct new_signal_frame32) + 7) & (~7)))
154 #define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
155
156 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
157 {
158         int err;
159
160         if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
161                 return -EFAULT;
162
163         /* If you change siginfo_t structure, please be sure
164            this code is fixed accordingly.
165            It should never copy any pad contained in the structure
166            to avoid security leaks, but must copy the generic
167            3 ints plus the relevant union member.
168            This routine must convert siginfo from 64bit to 32bit as well
169            at the same time.  */
170         err = __put_user(from->si_signo, &to->si_signo);
171         err |= __put_user(from->si_errno, &to->si_errno);
172         err |= __put_user((short)from->si_code, &to->si_code);
173         if (from->si_code < 0)
174                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
175         else {
176                 switch (from->si_code >> 16) {
177                 case __SI_TIMER >> 16:
178                         err |= __put_user(from->si_tid, &to->si_tid);
179                         err |= __put_user(from->si_overrun, &to->si_overrun);
180                         err |= __put_user(from->si_int, &to->si_int);
181                         break;
182                 case __SI_CHLD >> 16:
183                         err |= __put_user(from->si_utime, &to->si_utime);
184                         err |= __put_user(from->si_stime, &to->si_stime);
185                         err |= __put_user(from->si_status, &to->si_status);
186                 default:
187                         err |= __put_user(from->si_pid, &to->si_pid);
188                         err |= __put_user(from->si_uid, &to->si_uid);
189                         break;
190                 case __SI_FAULT >> 16:
191                         err |= __put_user(from->si_trapno, &to->si_trapno);
192                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
193                         break;
194                 case __SI_POLL >> 16:
195                         err |= __put_user(from->si_band, &to->si_band);
196                         err |= __put_user(from->si_fd, &to->si_fd);
197                         break;
198                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
199                 case __SI_MESGQ >> 16:
200                         err |= __put_user(from->si_pid, &to->si_pid);
201                         err |= __put_user(from->si_uid, &to->si_uid);
202                         err |= __put_user(from->si_int, &to->si_int);
203                         break;
204                 }
205         }
206         return err;
207 }
208
209 /* CAUTION: This is just a very minimalist implementation for the
210  *          sake of compat_sys_rt_sigqueueinfo()
211  */
212 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
213 {
214         if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
215                 return -EFAULT;
216
217         if (copy_from_user(to, from, 3*sizeof(int)) ||
218             copy_from_user(to->_sifields._pad, from->_sifields._pad,
219                            SI_PAD_SIZE))
220                 return -EFAULT;
221
222         return 0;
223 }
224
225 static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
226 {
227         unsigned long *fpregs = current_thread_info()->fpregs;
228         unsigned long fprs;
229         int err;
230         
231         err = __get_user(fprs, &fpu->si_fprs);
232         fprs_write(0);
233         regs->tstate &= ~TSTATE_PEF;
234         if (fprs & FPRS_DL)
235                 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
236         if (fprs & FPRS_DU)
237                 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
238         err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
239         err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
240         current_thread_info()->fpsaved[0] |= fprs;
241         return err;
242 }
243
244 void do_new_sigreturn32(struct pt_regs *regs)
245 {
246         struct new_signal_frame32 __user *sf;
247         unsigned int psr;
248         unsigned pc, npc, fpu_save;
249         sigset_t set;
250         unsigned seta[_COMPAT_NSIG_WORDS];
251         int err, i;
252         
253         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
254         sf = (struct new_signal_frame32 __user *) regs->u_regs[UREG_FP];
255
256         /* 1. Make sure we are not getting garbage from the user */
257         if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
258             (((unsigned long) sf) & 3))
259                 goto segv;
260
261         get_user(pc, &sf->info.si_regs.pc);
262         __get_user(npc, &sf->info.si_regs.npc);
263
264         if ((pc | npc) & 3)
265                 goto segv;
266
267         if (test_thread_flag(TIF_32BIT)) {
268                 pc &= 0xffffffff;
269                 npc &= 0xffffffff;
270         }
271         regs->tpc = pc;
272         regs->tnpc = npc;
273
274         /* 2. Restore the state */
275         err = __get_user(regs->y, &sf->info.si_regs.y);
276         err |= __get_user(psr, &sf->info.si_regs.psr);
277
278         for (i = UREG_G1; i <= UREG_I7; i++)
279                 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
280         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
281                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
282                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
283                         unsigned long asi;
284
285                         for (i = UREG_G1; i <= UREG_I7; i++)
286                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
287                         err |= __get_user(asi, &sf->v8plus.asi);
288                         regs->tstate &= ~TSTATE_ASI;
289                         regs->tstate |= ((asi & 0xffUL) << 24UL);
290                 }
291         }
292
293         /* User can only change condition codes in %tstate. */
294         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
295         regs->tstate |= psr_to_tstate_icc(psr);
296
297         err |= __get_user(fpu_save, &sf->fpu_save);
298         if (fpu_save)
299                 err |= restore_fpu_state32(regs, &sf->fpu_state);
300         err |= __get_user(seta[0], &sf->info.si_mask);
301         err |= copy_from_user(seta+1, &sf->extramask,
302                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
303         if (err)
304                 goto segv;
305         switch (_NSIG_WORDS) {
306                 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
307                 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
308                 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
309                 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
310         }
311         sigdelsetmask(&set, ~_BLOCKABLE);
312         spin_lock_irq(&current->sighand->siglock);
313         current->blocked = set;
314         recalc_sigpending();
315         spin_unlock_irq(&current->sighand->siglock);
316         return;
317
318 segv:
319         force_sig(SIGSEGV, current);
320 }
321
322 asmlinkage void do_sigreturn32(struct pt_regs *regs)
323 {
324         struct sigcontext32 __user *scptr;
325         unsigned int pc, npc, psr;
326         sigset_t set;
327         unsigned int seta[_COMPAT_NSIG_WORDS];
328         int err;
329
330         /* Always make any pending restarted system calls return -EINTR */
331         current_thread_info()->restart_block.fn = do_no_restart_syscall;
332
333         synchronize_user_stack();
334         if (test_thread_flag(TIF_NEWSIGNALS)) {
335                 do_new_sigreturn32(regs);
336                 return;
337         }
338
339         scptr = (struct sigcontext32 __user *)
340                 (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
341         /* Check sanity of the user arg. */
342         if (!access_ok(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
343             (((unsigned long) scptr) & 3))
344                 goto segv;
345
346         err = __get_user(pc, &scptr->sigc_pc);
347         err |= __get_user(npc, &scptr->sigc_npc);
348
349         if ((pc | npc) & 3)
350                 goto segv; /* Nice try. */
351
352         err |= __get_user(seta[0], &scptr->sigc_mask);
353         /* Note that scptr + 1 points to extramask */
354         err |= copy_from_user(seta+1, scptr + 1,
355                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
356         if (err)
357                 goto segv;
358         switch (_NSIG_WORDS) {
359                 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
360                 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
361                 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
362                 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
363         }
364         sigdelsetmask(&set, ~_BLOCKABLE);
365         spin_lock_irq(&current->sighand->siglock);
366         current->blocked = set;
367         recalc_sigpending();
368         spin_unlock_irq(&current->sighand->siglock);
369         
370         if (test_thread_flag(TIF_32BIT)) {
371                 pc &= 0xffffffff;
372                 npc &= 0xffffffff;
373         }
374         regs->tpc = pc;
375         regs->tnpc = npc;
376         err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
377         err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
378         err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
379
380         /* User can only change condition codes in %tstate. */
381         err |= __get_user(psr, &scptr->sigc_psr);
382         if (err)
383                 goto segv;
384         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
385         regs->tstate |= psr_to_tstate_icc(psr);
386         return;
387
388 segv:
389         force_sig(SIGSEGV, current);
390 }
391
392 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
393 {
394         struct rt_signal_frame32 __user *sf;
395         unsigned int psr, pc, npc, fpu_save, u_ss_sp;
396         mm_segment_t old_fs;
397         sigset_t set;
398         compat_sigset_t seta;
399         stack_t st;
400         int err, i;
401         
402         /* Always make any pending restarted system calls return -EINTR */
403         current_thread_info()->restart_block.fn = do_no_restart_syscall;
404
405         synchronize_user_stack();
406         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
407         sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
408
409         /* 1. Make sure we are not getting garbage from the user */
410         if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
411             (((unsigned long) sf) & 3))
412                 goto segv;
413
414         get_user(pc, &sf->regs.pc);
415         __get_user(npc, &sf->regs.npc);
416
417         if ((pc | npc) & 3)
418                 goto segv;
419
420         if (test_thread_flag(TIF_32BIT)) {
421                 pc &= 0xffffffff;
422                 npc &= 0xffffffff;
423         }
424         regs->tpc = pc;
425         regs->tnpc = npc;
426
427         /* 2. Restore the state */
428         err = __get_user(regs->y, &sf->regs.y);
429         err |= __get_user(psr, &sf->regs.psr);
430         
431         for (i = UREG_G1; i <= UREG_I7; i++)
432                 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
433         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
434                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
435                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
436                         unsigned long asi;
437
438                         for (i = UREG_G1; i <= UREG_I7; i++)
439                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
440                         err |= __get_user(asi, &sf->v8plus.asi);
441                         regs->tstate &= ~TSTATE_ASI;
442                         regs->tstate |= ((asi & 0xffUL) << 24UL);
443                 }
444         }
445
446         /* User can only change condition codes in %tstate. */
447         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
448         regs->tstate |= psr_to_tstate_icc(psr);
449
450         err |= __get_user(fpu_save, &sf->fpu_save);
451         if (fpu_save)
452                 err |= restore_fpu_state32(regs, &sf->fpu_state);
453         err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
454         err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
455         st.ss_sp = compat_ptr(u_ss_sp);
456         err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
457         err |= __get_user(st.ss_size, &sf->stack.ss_size);
458         if (err)
459                 goto segv;
460                 
461         /* It is more difficult to avoid calling this function than to
462            call it and ignore errors.  */
463         old_fs = get_fs();
464         set_fs(KERNEL_DS);
465         do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
466         set_fs(old_fs);
467         
468         switch (_NSIG_WORDS) {
469                 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
470                 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
471                 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
472                 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
473         }
474         sigdelsetmask(&set, ~_BLOCKABLE);
475         spin_lock_irq(&current->sighand->siglock);
476         current->blocked = set;
477         recalc_sigpending();
478         spin_unlock_irq(&current->sighand->siglock);
479         return;
480 segv:
481         force_sig(SIGSEGV, current);
482 }
483
484 /* Checks if the fp is valid */
485 static int invalid_frame_pointer(void __user *fp, int fplen)
486 {
487         if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
488                 return 1;
489         return 0;
490 }
491
492 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
493 {
494         unsigned long sp;
495         
496         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
497         sp = regs->u_regs[UREG_FP];
498         
499         /* This is the X/Open sanctioned signal stack switching.  */
500         if (sa->sa_flags & SA_ONSTACK) {
501                 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
502                         sp = current->sas_ss_sp + current->sas_ss_size;
503         }
504         return (void __user *)(sp - framesize);
505 }
506
507 static void
508 setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
509 {
510         struct signal_sframe32 __user *sframep;
511         struct sigcontext32 __user *sc;
512         unsigned int seta[_COMPAT_NSIG_WORDS];
513         int err = 0;
514         void __user *sig_address;
515         int sig_code;
516         unsigned long pc = regs->tpc;
517         unsigned long npc = regs->tnpc;
518         unsigned int psr;
519
520         if (test_thread_flag(TIF_32BIT)) {
521                 pc &= 0xffffffff;
522                 npc &= 0xffffffff;
523         }
524
525         synchronize_user_stack();
526         save_and_clear_fpu();
527
528         sframep = (struct signal_sframe32 __user *)
529                 get_sigframe(sa, regs, SF_ALIGNEDSZ);
530         if (invalid_frame_pointer(sframep, sizeof(*sframep))){
531                 /* Don't change signal code and address, so that
532                  * post mortem debuggers can have a look.
533                  */
534                 do_exit(SIGILL);
535         }
536
537         sc = &sframep->sig_context;
538
539         /* We've already made sure frame pointer isn't in kernel space... */
540         err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
541                          &sc->sigc_onstack);
542         
543         switch (_NSIG_WORDS) {
544         case 4: seta[7] = (oldset->sig[3] >> 32);
545                 seta[6] = oldset->sig[3];
546         case 3: seta[5] = (oldset->sig[2] >> 32);
547                 seta[4] = oldset->sig[2];
548         case 2: seta[3] = (oldset->sig[1] >> 32);
549                 seta[2] = oldset->sig[1];
550         case 1: seta[1] = (oldset->sig[0] >> 32);
551                 seta[0] = oldset->sig[0];
552         }
553         err |= __put_user(seta[0], &sc->sigc_mask);
554         err |= __copy_to_user(sframep->extramask, seta + 1,
555                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
556         err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
557         err |= __put_user(pc, &sc->sigc_pc);
558         err |= __put_user(npc, &sc->sigc_npc);
559         psr = tstate_to_psr(regs->tstate);
560         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
561                 psr |= PSR_EF;
562         err |= __put_user(psr, &sc->sigc_psr);
563         err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
564         err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
565         err |= __put_user(get_thread_wsaved(), &sc->sigc_oswins);
566
567         err |= copy_in_user((u32 __user *)sframep,
568                             (u32 __user *)(regs->u_regs[UREG_FP]),
569                             sizeof(struct reg_window32));
570                        
571         set_thread_wsaved(0); /* So process is allowed to execute. */
572         err |= __put_user(signr, &sframep->sig_num);
573         sig_address = NULL;
574         sig_code = 0;
575         if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
576                 sig_address = info->si_addr;
577                 switch (signr) {
578                 case SIGSEGV:
579                         switch (info->si_code) {
580                         case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
581                         default: sig_code = SUBSIG_PROTECTION; break;
582                         }
583                         break;
584                 case SIGILL:
585                         switch (info->si_code) {
586                         case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
587                         case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
588                         case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
589                         default: sig_code = SUBSIG_STACK; break;
590                         }
591                         break;
592                 case SIGFPE:
593                         switch (info->si_code) {
594                         case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
595                         case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
596                         case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
597                         case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
598                         case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
599                         case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
600                         case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
601                         default: sig_code = SUBSIG_FPERROR; break;
602                         }
603                         break;
604                 case SIGBUS:
605                         switch (info->si_code) {
606                         case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
607                         case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
608                         default: sig_code = SUBSIG_BUSTIMEOUT; break;
609                         }
610                         break;
611                 case SIGEMT:
612                         switch (info->si_code) {
613                         case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
614                         }
615                         break;
616                 case SIGSYS:
617                         if (info->si_code == (__SI_FAULT|0x100)) {
618                                 /* See sys_sunos32.c */
619                                 sig_code = info->si_trapno;
620                                 break;
621                         }
622                 default:
623                         sig_address = NULL;
624                 }
625         }
626         err |= __put_user(ptr_to_compat(sig_address), &sframep->sig_address);
627         err |= __put_user(sig_code, &sframep->sig_code);
628         err |= __put_user(ptr_to_compat(sc), &sframep->sig_scptr);
629         if (err)
630                 goto sigsegv;
631
632         regs->u_regs[UREG_FP] = (unsigned long) sframep;
633         regs->tpc = (unsigned long) sa->sa_handler;
634         regs->tnpc = (regs->tpc + 4);
635         if (test_thread_flag(TIF_32BIT)) {
636                 regs->tpc &= 0xffffffff;
637                 regs->tnpc &= 0xffffffff;
638         }
639         return;
640
641 sigsegv:
642         force_sigsegv(signr, current);
643 }
644
645
646 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
647 {
648         unsigned long *fpregs = current_thread_info()->fpregs;
649         unsigned long fprs;
650         int err = 0;
651         
652         fprs = current_thread_info()->fpsaved[0];
653         if (fprs & FPRS_DL)
654                 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
655                                     (sizeof(unsigned int) * 32));
656         if (fprs & FPRS_DU)
657                 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
658                                     (sizeof(unsigned int) * 32));
659         err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
660         err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
661         err |= __put_user(fprs, &fpu->si_fprs);
662
663         return err;
664 }
665
666 static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
667                               int signo, sigset_t *oldset)
668 {
669         struct new_signal_frame32 __user *sf;
670         int sigframe_size;
671         u32 psr;
672         int i, err;
673         unsigned int seta[_COMPAT_NSIG_WORDS];
674
675         /* 1. Make sure everything is clean */
676         synchronize_user_stack();
677         save_and_clear_fpu();
678         
679         sigframe_size = NF_ALIGNEDSZ;
680         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
681                 sigframe_size -= sizeof(__siginfo_fpu_t);
682
683         sf = (struct new_signal_frame32 __user *)
684                 get_sigframe(&ka->sa, regs, sigframe_size);
685         
686         if (invalid_frame_pointer(sf, sigframe_size))
687                 goto sigill;
688
689         if (get_thread_wsaved() != 0)
690                 goto sigill;
691
692         /* 2. Save the current process state */
693         if (test_thread_flag(TIF_32BIT)) {
694                 regs->tpc &= 0xffffffff;
695                 regs->tnpc &= 0xffffffff;
696         }
697         err  = put_user(regs->tpc, &sf->info.si_regs.pc);
698         err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
699         err |= __put_user(regs->y, &sf->info.si_regs.y);
700         psr = tstate_to_psr(regs->tstate);
701         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
702                 psr |= PSR_EF;
703         err |= __put_user(psr, &sf->info.si_regs.psr);
704         for (i = 0; i < 16; i++)
705                 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
706         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
707         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
708         for (i = 1; i < 16; i++)
709                 err |= __put_user(((u32 *)regs->u_regs)[2*i],
710                                   &sf->v8plus.g_upper[i]);
711         err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
712                           &sf->v8plus.asi);
713
714         if (psr & PSR_EF) {
715                 err |= save_fpu_state32(regs, &sf->fpu_state);
716                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
717         } else {
718                 err |= __put_user(0, &sf->fpu_save);
719         }
720
721         switch (_NSIG_WORDS) {
722         case 4: seta[7] = (oldset->sig[3] >> 32);
723                 seta[6] = oldset->sig[3];
724         case 3: seta[5] = (oldset->sig[2] >> 32);
725                 seta[4] = oldset->sig[2];
726         case 2: seta[3] = (oldset->sig[1] >> 32);
727                 seta[2] = oldset->sig[1];
728         case 1: seta[1] = (oldset->sig[0] >> 32);
729                 seta[0] = oldset->sig[0];
730         }
731         err |= __put_user(seta[0], &sf->info.si_mask);
732         err |= __copy_to_user(sf->extramask, seta + 1,
733                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
734
735         err |= copy_in_user((u32 __user *)sf,
736                             (u32 __user *)(regs->u_regs[UREG_FP]),
737                             sizeof(struct reg_window32));
738         
739         if (err)
740                 goto sigsegv;
741
742         /* 3. signal handler back-trampoline and parameters */
743         regs->u_regs[UREG_FP] = (unsigned long) sf;
744         regs->u_regs[UREG_I0] = signo;
745         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
746         regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
747
748         /* 4. signal handler */
749         regs->tpc = (unsigned long) ka->sa.sa_handler;
750         regs->tnpc = (regs->tpc + 4);
751         if (test_thread_flag(TIF_32BIT)) {
752                 regs->tpc &= 0xffffffff;
753                 regs->tnpc &= 0xffffffff;
754         }
755
756         /* 5. return to kernel instructions */
757         if (ka->ka_restorer) {
758                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
759         } else {
760                 /* Flush instruction space. */
761                 unsigned long address = ((unsigned long)&(sf->insns[0]));
762                 pgd_t *pgdp = pgd_offset(current->mm, address);
763                 pud_t *pudp = pud_offset(pgdp, address);
764                 pmd_t *pmdp = pmd_offset(pudp, address);
765                 pte_t *ptep;
766                 pte_t pte;
767
768                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
769         
770                 err  = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
771                 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
772                 if (err)
773                         goto sigsegv;
774
775                 preempt_disable();
776                 ptep = pte_offset_map(pmdp, address);
777                 pte = *ptep;
778                 if (pte_present(pte)) {
779                         unsigned long page = (unsigned long)
780                                 page_address(pte_page(pte));
781
782                         wmb();
783                         __asm__ __volatile__("flush     %0 + %1"
784                                              : /* no outputs */
785                                              : "r" (page),
786                                                "r" (address & (PAGE_SIZE - 1))
787                                              : "memory");
788                 }
789                 pte_unmap(ptep);
790                 preempt_enable();
791         }
792         return;
793
794 sigill:
795         do_exit(SIGILL);
796 sigsegv:
797         force_sigsegv(signo, current);
798 }
799
800 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
801                              unsigned long signr, sigset_t *oldset,
802                              siginfo_t *info)
803 {
804         struct rt_signal_frame32 __user *sf;
805         int sigframe_size;
806         u32 psr;
807         int i, err;
808         compat_sigset_t seta;
809
810         /* 1. Make sure everything is clean */
811         synchronize_user_stack();
812         save_and_clear_fpu();
813         
814         sigframe_size = RT_ALIGNEDSZ;
815         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
816                 sigframe_size -= sizeof(__siginfo_fpu_t);
817
818         sf = (struct rt_signal_frame32 __user *)
819                 get_sigframe(&ka->sa, regs, sigframe_size);
820         
821         if (invalid_frame_pointer(sf, sigframe_size))
822                 goto sigill;
823
824         if (get_thread_wsaved() != 0)
825                 goto sigill;
826
827         /* 2. Save the current process state */
828         if (test_thread_flag(TIF_32BIT)) {
829                 regs->tpc &= 0xffffffff;
830                 regs->tnpc &= 0xffffffff;
831         }
832         err  = put_user(regs->tpc, &sf->regs.pc);
833         err |= __put_user(regs->tnpc, &sf->regs.npc);
834         err |= __put_user(regs->y, &sf->regs.y);
835         psr = tstate_to_psr(regs->tstate);
836         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
837                 psr |= PSR_EF;
838         err |= __put_user(psr, &sf->regs.psr);
839         for (i = 0; i < 16; i++)
840                 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
841         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
842         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
843         for (i = 1; i < 16; i++)
844                 err |= __put_user(((u32 *)regs->u_regs)[2*i],
845                                   &sf->v8plus.g_upper[i]);
846         err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
847                           &sf->v8plus.asi);
848
849         if (psr & PSR_EF) {
850                 err |= save_fpu_state32(regs, &sf->fpu_state);
851                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
852         } else {
853                 err |= __put_user(0, &sf->fpu_save);
854         }
855
856         /* Update the siginfo structure.  */
857         err |= copy_siginfo_to_user32(&sf->info, info);
858         
859         /* Setup sigaltstack */
860         err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
861         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
862         err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
863
864         switch (_NSIG_WORDS) {
865         case 4: seta.sig[7] = (oldset->sig[3] >> 32);
866                 seta.sig[6] = oldset->sig[3];
867         case 3: seta.sig[5] = (oldset->sig[2] >> 32);
868                 seta.sig[4] = oldset->sig[2];
869         case 2: seta.sig[3] = (oldset->sig[1] >> 32);
870                 seta.sig[2] = oldset->sig[1];
871         case 1: seta.sig[1] = (oldset->sig[0] >> 32);
872                 seta.sig[0] = oldset->sig[0];
873         }
874         err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
875
876         err |= copy_in_user((u32 __user *)sf,
877                             (u32 __user *)(regs->u_regs[UREG_FP]),
878                             sizeof(struct reg_window32));
879         if (err)
880                 goto sigsegv;
881         
882         /* 3. signal handler back-trampoline and parameters */
883         regs->u_regs[UREG_FP] = (unsigned long) sf;
884         regs->u_regs[UREG_I0] = signr;
885         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
886         regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
887
888         /* 4. signal handler */
889         regs->tpc = (unsigned long) ka->sa.sa_handler;
890         regs->tnpc = (regs->tpc + 4);
891         if (test_thread_flag(TIF_32BIT)) {
892                 regs->tpc &= 0xffffffff;
893                 regs->tnpc &= 0xffffffff;
894         }
895
896         /* 5. return to kernel instructions */
897         if (ka->ka_restorer)
898                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
899         else {
900                 /* Flush instruction space. */
901                 unsigned long address = ((unsigned long)&(sf->insns[0]));
902                 pgd_t *pgdp = pgd_offset(current->mm, address);
903                 pud_t *pudp = pud_offset(pgdp, address);
904                 pmd_t *pmdp = pmd_offset(pudp, address);
905                 pte_t *ptep;
906
907                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
908         
909                 /* mov __NR_rt_sigreturn, %g1 */
910                 err |= __put_user(0x82102065, &sf->insns[0]);
911
912                 /* t 0x10 */
913                 err |= __put_user(0x91d02010, &sf->insns[1]);
914                 if (err)
915                         goto sigsegv;
916
917                 preempt_disable();
918                 ptep = pte_offset_map(pmdp, address);
919                 if (pte_present(*ptep)) {
920                         unsigned long page = (unsigned long)
921                                 page_address(pte_page(*ptep));
922
923                         wmb();
924                         __asm__ __volatile__("flush     %0 + %1"
925                                              : /* no outputs */
926                                              : "r" (page),
927                                                "r" (address & (PAGE_SIZE - 1))
928                                              : "memory");
929                 }
930                 pte_unmap(ptep);
931                 preempt_enable();
932         }
933         return;
934
935 sigill:
936         do_exit(SIGILL);
937 sigsegv:
938         force_sigsegv(signr, current);
939 }
940
941 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
942                                    siginfo_t *info,
943                                    sigset_t *oldset, struct pt_regs *regs)
944 {
945         if (ka->sa.sa_flags & SA_SIGINFO)
946                 setup_rt_frame32(ka, regs, signr, oldset, info);
947         else if (test_thread_flag(TIF_NEWSIGNALS))
948                 new_setup_frame32(ka, regs, signr, oldset);
949         else
950                 setup_frame32(&ka->sa, regs, signr, oldset, info);
951         spin_lock_irq(&current->sighand->siglock);
952         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
953         if (!(ka->sa.sa_flags & SA_NOMASK))
954                 sigaddset(&current->blocked,signr);
955         recalc_sigpending();
956         spin_unlock_irq(&current->sighand->siglock);
957 }
958
959 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
960                                      struct sigaction *sa)
961 {
962         switch (regs->u_regs[UREG_I0]) {
963         case ERESTART_RESTARTBLOCK:
964         case ERESTARTNOHAND:
965         no_system_call_restart:
966                 regs->u_regs[UREG_I0] = EINTR;
967                 regs->tstate |= TSTATE_ICARRY;
968                 break;
969         case ERESTARTSYS:
970                 if (!(sa->sa_flags & SA_RESTART))
971                         goto no_system_call_restart;
972                 /* fallthrough */
973         case ERESTARTNOINTR:
974                 regs->u_regs[UREG_I0] = orig_i0;
975                 regs->tpc -= 4;
976                 regs->tnpc -= 4;
977         }
978 }
979
980 /* Note that 'init' is a special process: it doesn't get signals it doesn't
981  * want to handle. Thus you cannot kill init even with a SIGKILL even by
982  * mistake.
983  */
984 void do_signal32(sigset_t *oldset, struct pt_regs * regs,
985                  struct signal_deliver_cookie *cookie)
986 {
987         struct k_sigaction ka;
988         siginfo_t info;
989         int signr;
990         
991         signr = get_signal_to_deliver(&info, &ka, regs, cookie);
992         if (signr > 0) {
993                 if (cookie->restart_syscall)
994                         syscall_restart32(cookie->orig_i0, regs, &ka.sa);
995                 handle_signal32(signr, &ka, &info, oldset, regs);
996
997                 /* a signal was successfully delivered; the saved
998                  * sigmask will have been stored in the signal frame,
999                  * and will be restored by sigreturn, so we can simply
1000                  * clear the TIF_RESTORE_SIGMASK flag.
1001                  */
1002                 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1003                         clear_thread_flag(TIF_RESTORE_SIGMASK);
1004                 return;
1005         }
1006         if (cookie->restart_syscall &&
1007             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1008              regs->u_regs[UREG_I0] == ERESTARTSYS ||
1009              regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1010                 /* replay the system call when we are done */
1011                 regs->u_regs[UREG_I0] = cookie->orig_i0;
1012                 regs->tpc -= 4;
1013                 regs->tnpc -= 4;
1014         }
1015         if (cookie->restart_syscall &&
1016             regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
1017                 regs->u_regs[UREG_G1] = __NR_restart_syscall;
1018                 regs->tpc -= 4;
1019                 regs->tnpc -= 4;
1020         }
1021
1022         /* if there's no signal to deliver, we just put the saved sigmask
1023          * back
1024          */
1025         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1026                 clear_thread_flag(TIF_RESTORE_SIGMASK);
1027                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
1028         }
1029 }
1030
1031 struct sigstack32 {
1032         u32 the_stack;
1033         int cur_status;
1034 };
1035
1036 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
1037 {
1038         struct sigstack32 __user *ssptr =
1039                 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
1040         struct sigstack32 __user *ossptr =
1041                 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
1042         int ret = -EFAULT;
1043
1044         /* First see if old state is wanted. */
1045         if (ossptr) {
1046                 if (put_user(current->sas_ss_sp + current->sas_ss_size,
1047                              &ossptr->the_stack) ||
1048                     __put_user(on_sig_stack(sp), &ossptr->cur_status))
1049                         goto out;
1050         }
1051         
1052         /* Now see if we want to update the new state. */
1053         if (ssptr) {
1054                 u32 ss_sp;
1055
1056                 if (get_user(ss_sp, &ssptr->the_stack))
1057                         goto out;
1058
1059                 /* If the current stack was set with sigaltstack, don't
1060                  * swap stacks while we are on it.
1061                  */
1062                 ret = -EPERM;
1063                 if (current->sas_ss_sp && on_sig_stack(sp))
1064                         goto out;
1065                         
1066                 /* Since we don't know the extent of the stack, and we don't
1067                  * track onstack-ness, but rather calculate it, we must
1068                  * presume a size.  Ho hum this interface is lossy.
1069                  */
1070                 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1071                 current->sas_ss_size = SIGSTKSZ;
1072         }
1073         
1074         ret = 0;
1075 out:
1076         return ret;
1077 }
1078
1079 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
1080 {
1081         stack_t uss, uoss;
1082         u32 u_ss_sp = 0;
1083         int ret;
1084         mm_segment_t old_fs;
1085         stack_t32 __user *uss32 = compat_ptr(ussa);
1086         stack_t32 __user *uoss32 = compat_ptr(uossa);
1087         
1088         if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
1089                     __get_user(uss.ss_flags, &uss32->ss_flags) ||
1090                     __get_user(uss.ss_size, &uss32->ss_size)))
1091                 return -EFAULT;
1092         uss.ss_sp = compat_ptr(u_ss_sp);
1093         old_fs = get_fs();
1094         set_fs(KERNEL_DS);
1095         ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
1096                              uossa ? (stack_t __user *) &uoss : NULL, sp);
1097         set_fs(old_fs);
1098         if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
1099                     __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
1100                     __put_user(uoss.ss_size, &uoss32->ss_size)))
1101                 return -EFAULT;
1102         return ret;
1103 }