]> bbs.cooldavid.org Git - net-next-2.6.git/blame - arch/sparc/kernel/signal32.c
sparc: Don't mask signal when we can't setup signal frame.
[net-next-2.6.git] / arch / sparc / kernel / signal32.c
CommitLineData
5526b7e4 1/* arch/sparc64/kernel/signal32.c
1da177e4
LT
2 *
3 * Copyright (C) 1991, 1992 Linus Torvalds
4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
5 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
6 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8 */
9
10#include <linux/sched.h>
11#include <linux/kernel.h>
12#include <linux/signal.h>
13#include <linux/errno.h>
14#include <linux/wait.h>
15#include <linux/ptrace.h>
16#include <linux/unistd.h>
17#include <linux/mm.h>
18#include <linux/tty.h>
1da177e4
LT
19#include <linux/binfmts.h>
20#include <linux/compat.h>
21#include <linux/bitops.h>
95698466 22#include <linux/tracehook.h>
1da177e4
LT
23
24#include <asm/uaccess.h>
25#include <asm/ptrace.h>
1da177e4
LT
26#include <asm/pgtable.h>
27#include <asm/psrcompat.h>
28#include <asm/fpumacro.h>
29#include <asm/visasm.h>
14cc6aba 30#include <asm/compat_signal.h>
1da177e4
LT
31
32#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
33
1da177e4
LT
34/* This magic should be in g_upper[0] for all upper parts
35 * to be valid.
36 */
37#define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
38typedef struct {
39 unsigned int g_upper[8];
40 unsigned int o_upper[8];
41 unsigned int asi;
42} siginfo_extra_v8plus_t;
43
5526b7e4 44struct signal_frame32 {
1da177e4
LT
45 struct sparc_stackf32 ss;
46 __siginfo32_t info;
47 /* __siginfo_fpu32_t * */ u32 fpu_save;
48 unsigned int insns[2];
49 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
50 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
51 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
52 siginfo_extra_v8plus_t v8plus;
53 __siginfo_fpu_t fpu_state;
54};
55
56typedef struct compat_siginfo{
57 int si_signo;
58 int si_errno;
59 int si_code;
60
61 union {
62 int _pad[SI_PAD_SIZE32];
63
64 /* kill() */
65 struct {
66 compat_pid_t _pid; /* sender's pid */
67 unsigned int _uid; /* sender's uid */
68 } _kill;
69
70 /* POSIX.1b timers */
71 struct {
0d77e5a2 72 compat_timer_t _tid; /* timer id */
1da177e4
LT
73 int _overrun; /* overrun count */
74 compat_sigval_t _sigval; /* same as below */
75 int _sys_private; /* not to be passed to user */
76 } _timer;
77
78 /* POSIX.1b signals */
79 struct {
80 compat_pid_t _pid; /* sender's pid */
81 unsigned int _uid; /* sender's uid */
82 compat_sigval_t _sigval;
83 } _rt;
84
85 /* SIGCHLD */
86 struct {
87 compat_pid_t _pid; /* which child */
88 unsigned int _uid; /* sender's uid */
89 int _status; /* exit code */
90 compat_clock_t _utime;
91 compat_clock_t _stime;
92 } _sigchld;
93
94 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
95 struct {
96 u32 _addr; /* faulting insn/memory ref. */
97 int _trapno;
98 } _sigfault;
99
100 /* SIGPOLL */
101 struct {
102 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
103 int _fd;
104 } _sigpoll;
105 } _sifields;
106}compat_siginfo_t;
107
108struct rt_signal_frame32 {
109 struct sparc_stackf32 ss;
110 compat_siginfo_t info;
111 struct pt_regs32 regs;
112 compat_sigset_t mask;
113 /* __siginfo_fpu32_t * */ u32 fpu_save;
114 unsigned int insns[2];
115 stack_t32 stack;
116 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
117 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
118 siginfo_extra_v8plus_t v8plus;
119 __siginfo_fpu_t fpu_state;
120};
121
122/* Align macros */
f036d9f3
DM
123#define SF_ALIGNEDSZ (((sizeof(struct signal_frame32) + 15) & (~15)))
124#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 15) & (~15)))
1da177e4
LT
125
126int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
127{
128 int err;
129
130 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
131 return -EFAULT;
132
133 /* If you change siginfo_t structure, please be sure
134 this code is fixed accordingly.
135 It should never copy any pad contained in the structure
136 to avoid security leaks, but must copy the generic
137 3 ints plus the relevant union member.
138 This routine must convert siginfo from 64bit to 32bit as well
139 at the same time. */
140 err = __put_user(from->si_signo, &to->si_signo);
141 err |= __put_user(from->si_errno, &to->si_errno);
142 err |= __put_user((short)from->si_code, &to->si_code);
143 if (from->si_code < 0)
144 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
145 else {
146 switch (from->si_code >> 16) {
147 case __SI_TIMER >> 16:
148 err |= __put_user(from->si_tid, &to->si_tid);
149 err |= __put_user(from->si_overrun, &to->si_overrun);
150 err |= __put_user(from->si_int, &to->si_int);
151 break;
152 case __SI_CHLD >> 16:
153 err |= __put_user(from->si_utime, &to->si_utime);
154 err |= __put_user(from->si_stime, &to->si_stime);
155 err |= __put_user(from->si_status, &to->si_status);
156 default:
157 err |= __put_user(from->si_pid, &to->si_pid);
158 err |= __put_user(from->si_uid, &to->si_uid);
159 break;
160 case __SI_FAULT >> 16:
1da177e4
LT
161 err |= __put_user(from->si_trapno, &to->si_trapno);
162 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
163 break;
9c7d3b3a
JS
164 case __SI_POLL >> 16:
165 err |= __put_user(from->si_band, &to->si_band);
166 err |= __put_user(from->si_fd, &to->si_fd);
167 break;
1da177e4
LT
168 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
169 case __SI_MESGQ >> 16:
170 err |= __put_user(from->si_pid, &to->si_pid);
171 err |= __put_user(from->si_uid, &to->si_uid);
172 err |= __put_user(from->si_int, &to->si_int);
173 break;
174 }
175 }
176 return err;
177}
178
179/* CAUTION: This is just a very minimalist implementation for the
180 * sake of compat_sys_rt_sigqueueinfo()
181 */
182int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
183{
184 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
185 return -EFAULT;
186
187 if (copy_from_user(to, from, 3*sizeof(int)) ||
188 copy_from_user(to->_sifields._pad, from->_sifields._pad,
189 SI_PAD_SIZE))
190 return -EFAULT;
191
192 return 0;
193}
194
1da177e4
LT
195static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
196{
197 unsigned long *fpregs = current_thread_info()->fpregs;
198 unsigned long fprs;
199 int err;
200
201 err = __get_user(fprs, &fpu->si_fprs);
202 fprs_write(0);
203 regs->tstate &= ~TSTATE_PEF;
204 if (fprs & FPRS_DL)
205 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
206 if (fprs & FPRS_DU)
207 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
208 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
209 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
210 current_thread_info()->fpsaved[0] |= fprs;
211 return err;
212}
213
5526b7e4 214void do_sigreturn32(struct pt_regs *regs)
1da177e4 215{
5526b7e4 216 struct signal_frame32 __user *sf;
1da177e4
LT
217 unsigned int psr;
218 unsigned pc, npc, fpu_save;
219 sigset_t set;
220 unsigned seta[_COMPAT_NSIG_WORDS];
221 int err, i;
222
5526b7e4
DM
223 /* Always make any pending restarted system calls return -EINTR */
224 current_thread_info()->restart_block.fn = do_no_restart_syscall;
225
226 synchronize_user_stack();
227
1da177e4 228 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
5526b7e4 229 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
1da177e4
LT
230
231 /* 1. Make sure we are not getting garbage from the user */
232 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
233 (((unsigned long) sf) & 3))
234 goto segv;
235
236 get_user(pc, &sf->info.si_regs.pc);
237 __get_user(npc, &sf->info.si_regs.npc);
238
239 if ((pc | npc) & 3)
240 goto segv;
241
242 if (test_thread_flag(TIF_32BIT)) {
243 pc &= 0xffffffff;
244 npc &= 0xffffffff;
245 }
246 regs->tpc = pc;
247 regs->tnpc = npc;
248
249 /* 2. Restore the state */
250 err = __get_user(regs->y, &sf->info.si_regs.y);
251 err |= __get_user(psr, &sf->info.si_regs.psr);
252
253 for (i = UREG_G1; i <= UREG_I7; i++)
254 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
255 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
256 err |= __get_user(i, &sf->v8plus.g_upper[0]);
257 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
258 unsigned long asi;
259
260 for (i = UREG_G1; i <= UREG_I7; i++)
261 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
262 err |= __get_user(asi, &sf->v8plus.asi);
263 regs->tstate &= ~TSTATE_ASI;
264 regs->tstate |= ((asi & 0xffUL) << 24UL);
265 }
266 }
267
268 /* User can only change condition codes in %tstate. */
269 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
270 regs->tstate |= psr_to_tstate_icc(psr);
271
2678fefe 272 /* Prevent syscall restart. */
28e61036 273 pt_regs_clear_syscall(regs);
2678fefe 274
1da177e4
LT
275 err |= __get_user(fpu_save, &sf->fpu_save);
276 if (fpu_save)
277 err |= restore_fpu_state32(regs, &sf->fpu_state);
278 err |= __get_user(seta[0], &sf->info.si_mask);
279 err |= copy_from_user(seta+1, &sf->extramask,
280 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
281 if (err)
282 goto segv;
283 switch (_NSIG_WORDS) {
284 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
285 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
286 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
287 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
288 }
289 sigdelsetmask(&set, ~_BLOCKABLE);
290 spin_lock_irq(&current->sighand->siglock);
291 current->blocked = set;
292 recalc_sigpending();
293 spin_unlock_irq(&current->sighand->siglock);
294 return;
295
296segv:
297 force_sig(SIGSEGV, current);
298}
299
1da177e4
LT
300asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
301{
302 struct rt_signal_frame32 __user *sf;
303 unsigned int psr, pc, npc, fpu_save, u_ss_sp;
304 mm_segment_t old_fs;
305 sigset_t set;
306 compat_sigset_t seta;
307 stack_t st;
308 int err, i;
309
310 /* Always make any pending restarted system calls return -EINTR */
311 current_thread_info()->restart_block.fn = do_no_restart_syscall;
312
313 synchronize_user_stack();
314 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
315 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
316
317 /* 1. Make sure we are not getting garbage from the user */
318 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
319 (((unsigned long) sf) & 3))
320 goto segv;
321
322 get_user(pc, &sf->regs.pc);
323 __get_user(npc, &sf->regs.npc);
324
325 if ((pc | npc) & 3)
326 goto segv;
327
328 if (test_thread_flag(TIF_32BIT)) {
329 pc &= 0xffffffff;
330 npc &= 0xffffffff;
331 }
332 regs->tpc = pc;
333 regs->tnpc = npc;
334
335 /* 2. Restore the state */
336 err = __get_user(regs->y, &sf->regs.y);
337 err |= __get_user(psr, &sf->regs.psr);
338
339 for (i = UREG_G1; i <= UREG_I7; i++)
340 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
341 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
342 err |= __get_user(i, &sf->v8plus.g_upper[0]);
343 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
344 unsigned long asi;
345
346 for (i = UREG_G1; i <= UREG_I7; i++)
347 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
348 err |= __get_user(asi, &sf->v8plus.asi);
349 regs->tstate &= ~TSTATE_ASI;
350 regs->tstate |= ((asi & 0xffUL) << 24UL);
351 }
352 }
353
354 /* User can only change condition codes in %tstate. */
355 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
356 regs->tstate |= psr_to_tstate_icc(psr);
357
2678fefe 358 /* Prevent syscall restart. */
28e61036 359 pt_regs_clear_syscall(regs);
2678fefe 360
1da177e4
LT
361 err |= __get_user(fpu_save, &sf->fpu_save);
362 if (fpu_save)
363 err |= restore_fpu_state32(regs, &sf->fpu_state);
364 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
365 err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
366 st.ss_sp = compat_ptr(u_ss_sp);
367 err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
368 err |= __get_user(st.ss_size, &sf->stack.ss_size);
369 if (err)
370 goto segv;
371
372 /* It is more difficult to avoid calling this function than to
373 call it and ignore errors. */
374 old_fs = get_fs();
375 set_fs(KERNEL_DS);
376 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
377 set_fs(old_fs);
378
379 switch (_NSIG_WORDS) {
380 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
381 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
382 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
383 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
384 }
385 sigdelsetmask(&set, ~_BLOCKABLE);
386 spin_lock_irq(&current->sighand->siglock);
387 current->blocked = set;
388 recalc_sigpending();
389 spin_unlock_irq(&current->sighand->siglock);
390 return;
391segv:
392 force_sig(SIGSEGV, current);
393}
394
395/* Checks if the fp is valid */
396static int invalid_frame_pointer(void __user *fp, int fplen)
397{
398 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
399 return 1;
400 return 0;
401}
402
403static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
404{
405 unsigned long sp;
406
407 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
408 sp = regs->u_regs[UREG_FP];
409
dc5dc7e6
DM
410 /*
411 * If we are on the alternate signal stack and would overflow it, don't.
412 * Return an always-bogus address instead so we will die with SIGSEGV.
413 */
414 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
415 return (void __user *) -1L;
416
1da177e4
LT
417 /* This is the X/Open sanctioned signal stack switching. */
418 if (sa->sa_flags & SA_ONSTACK) {
dc5dc7e6 419 if (sas_ss_flags(sp) == 0)
1da177e4
LT
420 sp = current->sas_ss_sp + current->sas_ss_size;
421 }
dc5dc7e6 422
f036d9f3
DM
423 sp -= framesize;
424
dc5dc7e6
DM
425 /* Always align the stack frame. This handles two cases. First,
426 * sigaltstack need not be mindful of platform specific stack
427 * alignment. Second, if we took this signal because the stack
428 * is not aligned properly, we'd like to take the signal cleanly
429 * and report that.
430 */
f036d9f3 431 sp &= ~15UL;
dc5dc7e6 432
f036d9f3 433 return (void __user *) sp;
1da177e4
LT
434}
435
1da177e4
LT
436static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
437{
438 unsigned long *fpregs = current_thread_info()->fpregs;
439 unsigned long fprs;
440 int err = 0;
441
442 fprs = current_thread_info()->fpsaved[0];
443 if (fprs & FPRS_DL)
444 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
445 (sizeof(unsigned int) * 32));
446 if (fprs & FPRS_DU)
447 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
448 (sizeof(unsigned int) * 32));
449 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
450 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
451 err |= __put_user(fprs, &fpu->si_fprs);
452
453 return err;
454}
455
05c5e769
DM
456/* The I-cache flush instruction only works in the primary ASI, which
457 * right now is the nucleus, aka. kernel space.
458 *
459 * Therefore we have to kick the instructions out using the kernel
460 * side linear mapping of the physical address backing the user
461 * instructions.
462 */
463static void flush_signal_insns(unsigned long address)
464{
465 unsigned long pstate, paddr;
466 pte_t *ptep, pte;
467 pgd_t *pgdp;
468 pud_t *pudp;
469 pmd_t *pmdp;
470
471 /* Commit all stores of the instructions we are about to flush. */
472 wmb();
473
474 /* Disable cross-call reception. In this way even a very wide
475 * munmap() on another cpu can't tear down the page table
476 * hierarchy from underneath us, since that can't complete
477 * until the IPI tlb flush returns.
478 */
479
480 __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
481 __asm__ __volatile__("wrpr %0, %1, %%pstate"
482 : : "r" (pstate), "i" (PSTATE_IE));
483
484 pgdp = pgd_offset(current->mm, address);
485 if (pgd_none(*pgdp))
486 goto out_irqs_on;
487 pudp = pud_offset(pgdp, address);
488 if (pud_none(*pudp))
489 goto out_irqs_on;
490 pmdp = pmd_offset(pudp, address);
491 if (pmd_none(*pmdp))
492 goto out_irqs_on;
493
494 ptep = pte_offset_map(pmdp, address);
495 pte = *ptep;
496 if (!pte_present(pte))
497 goto out_unmap;
498
499 paddr = (unsigned long) page_address(pte_page(pte));
500
501 __asm__ __volatile__("flush %0 + %1"
502 : /* no outputs */
503 : "r" (paddr),
504 "r" (address & (PAGE_SIZE - 1))
505 : "memory");
506
507out_unmap:
508 pte_unmap(ptep);
509out_irqs_on:
510 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
511
512}
513
392c2180
DM
514static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
515 int signo, sigset_t *oldset)
1da177e4 516{
5526b7e4 517 struct signal_frame32 __user *sf;
1da177e4
LT
518 int sigframe_size;
519 u32 psr;
520 int i, err;
521 unsigned int seta[_COMPAT_NSIG_WORDS];
522
523 /* 1. Make sure everything is clean */
524 synchronize_user_stack();
525 save_and_clear_fpu();
526
5526b7e4 527 sigframe_size = SF_ALIGNEDSZ;
1da177e4
LT
528 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
529 sigframe_size -= sizeof(__siginfo_fpu_t);
530
5526b7e4 531 sf = (struct signal_frame32 __user *)
1da177e4
LT
532 get_sigframe(&ka->sa, regs, sigframe_size);
533
534 if (invalid_frame_pointer(sf, sigframe_size))
535 goto sigill;
536
537 if (get_thread_wsaved() != 0)
538 goto sigill;
539
540 /* 2. Save the current process state */
541 if (test_thread_flag(TIF_32BIT)) {
542 regs->tpc &= 0xffffffff;
543 regs->tnpc &= 0xffffffff;
544 }
545 err = put_user(regs->tpc, &sf->info.si_regs.pc);
546 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
547 err |= __put_user(regs->y, &sf->info.si_regs.y);
548 psr = tstate_to_psr(regs->tstate);
549 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
550 psr |= PSR_EF;
551 err |= __put_user(psr, &sf->info.si_regs.psr);
552 for (i = 0; i < 16; i++)
553 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
554 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
555 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
556 for (i = 1; i < 16; i++)
557 err |= __put_user(((u32 *)regs->u_regs)[2*i],
558 &sf->v8plus.g_upper[i]);
559 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
560 &sf->v8plus.asi);
561
562 if (psr & PSR_EF) {
563 err |= save_fpu_state32(regs, &sf->fpu_state);
564 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
565 } else {
566 err |= __put_user(0, &sf->fpu_save);
567 }
568
569 switch (_NSIG_WORDS) {
570 case 4: seta[7] = (oldset->sig[3] >> 32);
571 seta[6] = oldset->sig[3];
572 case 3: seta[5] = (oldset->sig[2] >> 32);
573 seta[4] = oldset->sig[2];
574 case 2: seta[3] = (oldset->sig[1] >> 32);
575 seta[2] = oldset->sig[1];
576 case 1: seta[1] = (oldset->sig[0] >> 32);
577 seta[0] = oldset->sig[0];
578 }
579 err |= __put_user(seta[0], &sf->info.si_mask);
580 err |= __copy_to_user(sf->extramask, seta + 1,
581 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
582
583 err |= copy_in_user((u32 __user *)sf,
584 (u32 __user *)(regs->u_regs[UREG_FP]),
585 sizeof(struct reg_window32));
586
587 if (err)
588 goto sigsegv;
589
590 /* 3. signal handler back-trampoline and parameters */
591 regs->u_regs[UREG_FP] = (unsigned long) sf;
592 regs->u_regs[UREG_I0] = signo;
593 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
594 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
595
596 /* 4. signal handler */
597 regs->tpc = (unsigned long) ka->sa.sa_handler;
598 regs->tnpc = (regs->tpc + 4);
599 if (test_thread_flag(TIF_32BIT)) {
600 regs->tpc &= 0xffffffff;
601 regs->tnpc &= 0xffffffff;
602 }
603
604 /* 5. return to kernel instructions */
605 if (ka->ka_restorer) {
606 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
607 } else {
1da177e4 608 unsigned long address = ((unsigned long)&(sf->insns[0]));
1da177e4
LT
609
610 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
611
612 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
613 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
614 if (err)
615 goto sigsegv;
616
05c5e769 617 flush_signal_insns(address);
1da177e4
LT
618 }
619 return;
620
621sigill:
622 do_exit(SIGILL);
392c2180
DM
623 return -EINVAL;
624
1da177e4
LT
625sigsegv:
626 force_sigsegv(signo, current);
392c2180 627 return -EFAULT;
1da177e4
LT
628}
629
392c2180
DM
630static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
631 unsigned long signr, sigset_t *oldset,
632 siginfo_t *info)
1da177e4
LT
633{
634 struct rt_signal_frame32 __user *sf;
635 int sigframe_size;
636 u32 psr;
637 int i, err;
638 compat_sigset_t seta;
639
640 /* 1. Make sure everything is clean */
641 synchronize_user_stack();
642 save_and_clear_fpu();
643
644 sigframe_size = RT_ALIGNEDSZ;
645 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
646 sigframe_size -= sizeof(__siginfo_fpu_t);
647
648 sf = (struct rt_signal_frame32 __user *)
649 get_sigframe(&ka->sa, regs, sigframe_size);
650
651 if (invalid_frame_pointer(sf, sigframe_size))
652 goto sigill;
653
654 if (get_thread_wsaved() != 0)
655 goto sigill;
656
657 /* 2. Save the current process state */
658 if (test_thread_flag(TIF_32BIT)) {
659 regs->tpc &= 0xffffffff;
660 regs->tnpc &= 0xffffffff;
661 }
662 err = put_user(regs->tpc, &sf->regs.pc);
663 err |= __put_user(regs->tnpc, &sf->regs.npc);
664 err |= __put_user(regs->y, &sf->regs.y);
665 psr = tstate_to_psr(regs->tstate);
666 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
667 psr |= PSR_EF;
668 err |= __put_user(psr, &sf->regs.psr);
669 for (i = 0; i < 16; i++)
670 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
671 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
672 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
673 for (i = 1; i < 16; i++)
674 err |= __put_user(((u32 *)regs->u_regs)[2*i],
675 &sf->v8plus.g_upper[i]);
676 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
677 &sf->v8plus.asi);
678
679 if (psr & PSR_EF) {
680 err |= save_fpu_state32(regs, &sf->fpu_state);
681 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
682 } else {
683 err |= __put_user(0, &sf->fpu_save);
684 }
685
686 /* Update the siginfo structure. */
687 err |= copy_siginfo_to_user32(&sf->info, info);
688
689 /* Setup sigaltstack */
690 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
691 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
692 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
693
694 switch (_NSIG_WORDS) {
695 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
696 seta.sig[6] = oldset->sig[3];
697 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
698 seta.sig[4] = oldset->sig[2];
699 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
700 seta.sig[2] = oldset->sig[1];
701 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
702 seta.sig[0] = oldset->sig[0];
703 }
704 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
705
706 err |= copy_in_user((u32 __user *)sf,
707 (u32 __user *)(regs->u_regs[UREG_FP]),
708 sizeof(struct reg_window32));
709 if (err)
710 goto sigsegv;
711
712 /* 3. signal handler back-trampoline and parameters */
713 regs->u_regs[UREG_FP] = (unsigned long) sf;
714 regs->u_regs[UREG_I0] = signr;
715 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
716 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
717
718 /* 4. signal handler */
719 regs->tpc = (unsigned long) ka->sa.sa_handler;
720 regs->tnpc = (regs->tpc + 4);
721 if (test_thread_flag(TIF_32BIT)) {
722 regs->tpc &= 0xffffffff;
723 regs->tnpc &= 0xffffffff;
724 }
725
726 /* 5. return to kernel instructions */
727 if (ka->ka_restorer)
728 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
729 else {
1da177e4 730 unsigned long address = ((unsigned long)&(sf->insns[0]));
1da177e4
LT
731
732 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
733
734 /* mov __NR_rt_sigreturn, %g1 */
735 err |= __put_user(0x82102065, &sf->insns[0]);
736
737 /* t 0x10 */
738 err |= __put_user(0x91d02010, &sf->insns[1]);
739 if (err)
740 goto sigsegv;
741
05c5e769 742 flush_signal_insns(address);
1da177e4 743 }
392c2180 744 return 0;
1da177e4
LT
745
746sigill:
747 do_exit(SIGILL);
392c2180
DM
748 return -EINVAL;
749
1da177e4
LT
750sigsegv:
751 force_sigsegv(signr, current);
392c2180 752 return -EFAULT;
1da177e4
LT
753}
754
392c2180
DM
755static inline int handle_signal32(unsigned long signr, struct k_sigaction *ka,
756 siginfo_t *info,
757 sigset_t *oldset, struct pt_regs *regs)
1da177e4 758{
392c2180
DM
759 int err;
760
ec98c6b9 761 if (ka->sa.sa_flags & SA_SIGINFO)
392c2180 762 err = setup_rt_frame32(ka, regs, signr, oldset, info);
ec98c6b9 763 else
392c2180
DM
764 err = setup_frame32(ka, regs, signr, oldset);
765
766 if (err)
767 return err;
5526b7e4 768
69be8f18
SR
769 spin_lock_irq(&current->sighand->siglock);
770 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
771 if (!(ka->sa.sa_flags & SA_NOMASK))
1da177e4 772 sigaddset(&current->blocked,signr);
69be8f18
SR
773 recalc_sigpending();
774 spin_unlock_irq(&current->sighand->siglock);
392c2180
DM
775
776 tracehook_signal_handler(signr, info, ka, regs, 0);
777
778 return 0;
1da177e4
LT
779}
780
781static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
782 struct sigaction *sa)
783{
784 switch (regs->u_regs[UREG_I0]) {
785 case ERESTART_RESTARTBLOCK:
786 case ERESTARTNOHAND:
787 no_system_call_restart:
788 regs->u_regs[UREG_I0] = EINTR;
789 regs->tstate |= TSTATE_ICARRY;
790 break;
791 case ERESTARTSYS:
792 if (!(sa->sa_flags & SA_RESTART))
793 goto no_system_call_restart;
794 /* fallthrough */
795 case ERESTARTNOINTR:
796 regs->u_regs[UREG_I0] = orig_i0;
797 regs->tpc -= 4;
798 regs->tnpc -= 4;
799 }
800}
801
802/* Note that 'init' is a special process: it doesn't get signals it doesn't
803 * want to handle. Thus you cannot kill init even with a SIGKILL even by
804 * mistake.
805 */
2d7d5f05 806void do_signal32(sigset_t *oldset, struct pt_regs * regs,
28e61036 807 int restart_syscall, unsigned long orig_i0)
1da177e4 808{
1da177e4 809 struct k_sigaction ka;
238468b2 810 siginfo_t info;
1da177e4 811 int signr;
1da177e4 812
28e61036
DM
813 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
814
815 /* If the debugger messes with the program counter, it clears
816 * the "in syscall" bit, directing us to not perform a syscall
817 * restart.
818 */
819 if (restart_syscall && !pt_regs_is_syscall(regs))
820 restart_syscall = 0;
821
1da177e4 822 if (signr > 0) {
28e61036
DM
823 if (restart_syscall)
824 syscall_restart32(orig_i0, regs, &ka.sa);
392c2180
DM
825 if (handle_signal32(signr, &ka, &info, oldset, regs) == 0) {
826 /* A signal was successfully delivered; the saved
827 * sigmask will have been stored in the signal frame,
828 * and will be restored by sigreturn, so we can simply
829 * clear the TS_RESTORE_SIGMASK flag.
830 */
831 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
832 }
2d7d5f05 833 return;
1da177e4 834 }
28e61036 835 if (restart_syscall &&
1da177e4
LT
836 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
837 regs->u_regs[UREG_I0] == ERESTARTSYS ||
838 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
839 /* replay the system call when we are done */
28e61036 840 regs->u_regs[UREG_I0] = orig_i0;
1da177e4
LT
841 regs->tpc -= 4;
842 regs->tnpc -= 4;
843 }
28e61036 844 if (restart_syscall &&
1da177e4
LT
845 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
846 regs->u_regs[UREG_G1] = __NR_restart_syscall;
847 regs->tpc -= 4;
848 regs->tnpc -= 4;
849 }
2d7d5f05 850
9a28dbf8 851 /* If there's no signal to deliver, we just put the saved sigmask
2d7d5f05
DM
852 * back
853 */
9a28dbf8
DM
854 if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
855 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
2d7d5f05
DM
856 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
857 }
1da177e4
LT
858}
859
860struct sigstack32 {
861 u32 the_stack;
862 int cur_status;
863};
864
865asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
866{
867 struct sigstack32 __user *ssptr =
868 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
869 struct sigstack32 __user *ossptr =
870 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
871 int ret = -EFAULT;
872
873 /* First see if old state is wanted. */
874 if (ossptr) {
875 if (put_user(current->sas_ss_sp + current->sas_ss_size,
876 &ossptr->the_stack) ||
877 __put_user(on_sig_stack(sp), &ossptr->cur_status))
878 goto out;
879 }
880
881 /* Now see if we want to update the new state. */
882 if (ssptr) {
883 u32 ss_sp;
884
885 if (get_user(ss_sp, &ssptr->the_stack))
886 goto out;
887
888 /* If the current stack was set with sigaltstack, don't
889 * swap stacks while we are on it.
890 */
891 ret = -EPERM;
892 if (current->sas_ss_sp && on_sig_stack(sp))
893 goto out;
894
895 /* Since we don't know the extent of the stack, and we don't
896 * track onstack-ness, but rather calculate it, we must
897 * presume a size. Ho hum this interface is lossy.
898 */
899 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
900 current->sas_ss_size = SIGSTKSZ;
901 }
902
903 ret = 0;
904out:
905 return ret;
906}
907
908asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
909{
910 stack_t uss, uoss;
911 u32 u_ss_sp = 0;
912 int ret;
913 mm_segment_t old_fs;
914 stack_t32 __user *uss32 = compat_ptr(ussa);
915 stack_t32 __user *uoss32 = compat_ptr(uossa);
916
917 if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
918 __get_user(uss.ss_flags, &uss32->ss_flags) ||
919 __get_user(uss.ss_size, &uss32->ss_size)))
920 return -EFAULT;
921 uss.ss_sp = compat_ptr(u_ss_sp);
922 old_fs = get_fs();
923 set_fs(KERNEL_DS);
924 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
925 uossa ? (stack_t __user *) &uoss : NULL, sp);
926 set_fs(old_fs);
927 if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
928 __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
929 __put_user(uoss.ss_size, &uoss32->ss_size)))
930 return -EFAULT;
931 return ret;
932}