?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SPARC64]: Use trap type stored in pt_regs to handle syscall restart.
[linux-2.6/openmoko-kernel/knife-kernel.git] / arch / sparc64 / kernel / signal32.c
blob43cdec64d9c9014c9b53380cc69632702e0639ca
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 }
Community contributions to the Openmoko Kernel