?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / arch / sparc / kernel / signal.c
blobe85023bb8e50363e3295a7c49ca0c7242e93c9fb
1 /* $Id: signal.c,v 1.110 2002/02/08 03:57:14 davem Exp $
2 * linux/arch/sparc/kernel/signal.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 */
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>
19 #include <linux/smp.h>
20 #include <linux/binfmts.h> /* do_coredum */
21 #include <linux/bitops.h>
22
23 #include <asm/uaccess.h>
24 #include <asm/ptrace.h>
25 #include <asm/svr4.h>
26 #include <asm/pgalloc.h>
27 #include <asm/pgtable.h>
28 #include <asm/cacheflush.h> /* flush_sig_insns */
29
30 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
31
32 extern void fpsave(unsigned long *fpregs, unsigned long *fsr,
33 void *fpqueue, unsigned long *fpqdepth);
34 extern void fpload(unsigned long *fpregs, unsigned long *fsr);
35
36 /* Signal frames: the original one (compatible with SunOS):
37 *
38 * Set up a signal frame... Make the stack look the way SunOS
39 * expects it to look which is basically:
40 *
41 * ---------------------------------- <-- %sp at signal time
42 * Struct sigcontext
43 * Signal address
44 * Ptr to sigcontext area above
45 * Signal code
46 * The signal number itself
47 * One register window
48 * ---------------------------------- <-- New %sp
49 */
50 struct signal_sframe {
51 struct reg_window sig_window;
52 int sig_num;
53 int sig_code;
54 struct sigcontext __user *sig_scptr;
55 int sig_address;
56 struct sigcontext sig_context;
57 unsigned int extramask[_NSIG_WORDS - 1];
58 };
59
60 /*
61 * And the new one, intended to be used for Linux applications only
62 * (we have enough in there to work with clone).
63 * All the interesting bits are in the info field.
64 */
65
66 struct new_signal_frame {
67 struct sparc_stackf ss;
68 __siginfo_t info;
69 __siginfo_fpu_t __user *fpu_save;
70 unsigned long insns[2] __attribute__ ((aligned (8)));
71 unsigned int extramask[_NSIG_WORDS - 1];
72 unsigned int extra_size; /* Should be 0 */
73 __siginfo_fpu_t fpu_state;
74 };
75
76 struct rt_signal_frame {
77 struct sparc_stackf ss;
78 siginfo_t info;
79 struct pt_regs regs;
80 sigset_t mask;
81 __siginfo_fpu_t __user *fpu_save;
82 unsigned int insns[2];
83 stack_t stack;
84 unsigned int extra_size; /* Should be 0 */
85 __siginfo_fpu_t fpu_state;
86 };
87
88 /* Align macros */
89 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe) + 7) & (~7)))
90 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame) + 7) & (~7)))
91 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
92
93 static int _sigpause_common(old_sigset_t set)
94 {
95 set &= _BLOCKABLE;
96 spin_lock_irq(&current->sighand->siglock);
97 current->saved_sigmask = current->blocked;
98 siginitset(&current->blocked, set);
99 recalc_sigpending();
100 spin_unlock_irq(&current->sighand->siglock);
101
102 current->state = TASK_INTERRUPTIBLE;
103 schedule();
104 set_thread_flag(TIF_RESTORE_SIGMASK);
105
106 return -ERESTARTNOHAND;
107 }
108
109 asmlinkage int sys_sigpause(unsigned int set)
110 {
111 return _sigpause_common(set);
112 }
113
114 asmlinkage int sys_sigsuspend(old_sigset_t set)
115 {
116 return _sigpause_common(set);
117 }
118
119 static inline int
120 restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
121 {
122 int err;
123 #ifdef CONFIG_SMP
124 if (test_tsk_thread_flag(current, TIF_USEDFPU))
125 regs->psr &= ~PSR_EF;
126 #else
127 if (current == last_task_used_math) {
128 last_task_used_math = NULL;
129 regs->psr &= ~PSR_EF;
130 }
131 #endif
132 set_used_math();
133 clear_tsk_thread_flag(current, TIF_USEDFPU);
134
135 if (!access_ok(VERIFY_READ, fpu, sizeof(*fpu)))
136 return -EFAULT;
137
138 err = __copy_from_user(&current->thread.float_regs[0], &fpu->si_float_regs[0],
139 (sizeof(unsigned long) * 32));
140 err |= __get_user(current->thread.fsr, &fpu->si_fsr);
141 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
142 if (current->thread.fpqdepth != 0)
143 err |= __copy_from_user(&current->thread.fpqueue[0],
144 &fpu->si_fpqueue[0],
145 ((sizeof(unsigned long) +
146 (sizeof(unsigned long *)))*16));
147 return err;
148 }
149
150 static inline void do_new_sigreturn (struct pt_regs *regs)
151 {
152 struct new_signal_frame __user *sf;
153 unsigned long up_psr, pc, npc;
154 sigset_t set;
155 __siginfo_fpu_t __user *fpu_save;
156 int err;
157
158 sf = (struct new_signal_frame __user *) regs->u_regs[UREG_FP];
159
160 /* 1. Make sure we are not getting garbage from the user */
161 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
162 goto segv_and_exit;
163
164 if (((unsigned long) sf) & 3)
165 goto segv_and_exit;
166
167 err = __get_user(pc, &sf->info.si_regs.pc);
168 err |= __get_user(npc, &sf->info.si_regs.npc);
169
170 if ((pc | npc) & 3)
171 goto segv_and_exit;
172
173 /* 2. Restore the state */
174 up_psr = regs->psr;
175 err |= __copy_from_user(regs, &sf->info.si_regs, sizeof(struct pt_regs));
176
177 /* User can only change condition codes and FPU enabling in %psr. */
178 regs->psr = (up_psr & ~(PSR_ICC | PSR_EF))
179 | (regs->psr & (PSR_ICC | PSR_EF));
180
181 /* Prevent syscall restart. */
182 pt_regs_clear_syscall(regs);
183
184 err |= __get_user(fpu_save, &sf->fpu_save);
185
186 if (fpu_save)
187 err |= restore_fpu_state(regs, fpu_save);
188
189 /* This is pretty much atomic, no amount locking would prevent
190 * the races which exist anyways.
191 */
192 err |= __get_user(set.sig[0], &sf->info.si_mask);
193 err |= __copy_from_user(&set.sig[1], &sf->extramask,
194 (_NSIG_WORDS-1) * sizeof(unsigned int));
195
196 if (err)
197 goto segv_and_exit;
198
199 sigdelsetmask(&set, ~_BLOCKABLE);
200 spin_lock_irq(&current->sighand->siglock);
201 current->blocked = set;
202 recalc_sigpending();
203 spin_unlock_irq(&current->sighand->siglock);
204 return;
205
206 segv_and_exit:
207 force_sig(SIGSEGV, current);
208 }
209
210 asmlinkage void do_sigreturn(struct pt_regs *regs)
211 {
212 struct sigcontext __user *scptr;
213 unsigned long pc, npc, psr;
214 sigset_t set;
215 int err;
216
217 /* Always make any pending restarted system calls return -EINTR */
218 current_thread_info()->restart_block.fn = do_no_restart_syscall;
219
220 synchronize_user_stack();
221
222 if (current->thread.new_signal) {
223 do_new_sigreturn(regs);
224 return;
225 }
226
227 scptr = (struct sigcontext __user *) regs->u_regs[UREG_I0];
228
229 /* Check sanity of the user arg. */
230 if (!access_ok(VERIFY_READ, scptr, sizeof(struct sigcontext)) ||
231 (((unsigned long) scptr) & 3))
232 goto segv_and_exit;
233
234 err = __get_user(pc, &scptr->sigc_pc);
235 err |= __get_user(npc, &scptr->sigc_npc);
236
237 if ((pc | npc) & 3)
238 goto segv_and_exit;
239
240 /* This is pretty much atomic, no amount locking would prevent
241 * the races which exist anyways.
242 */
243 err |= __get_user(set.sig[0], &scptr->sigc_mask);
244 /* Note that scptr + 1 points to extramask */
245 err |= __copy_from_user(&set.sig[1], scptr + 1,
246 (_NSIG_WORDS - 1) * sizeof(unsigned int));
247
248 if (err)
249 goto segv_and_exit;
250
251 sigdelsetmask(&set, ~_BLOCKABLE);
252 spin_lock_irq(&current->sighand->siglock);
253 current->blocked = set;
254 recalc_sigpending();
255 spin_unlock_irq(&current->sighand->siglock);
256
257 regs->pc = pc;
258 regs->npc = npc;
259
260 err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
261 err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
262 err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
263
264 /* User can only change condition codes in %psr. */
265 err |= __get_user(psr, &scptr->sigc_psr);
266 if (err)
267 goto segv_and_exit;
268
269 regs->psr &= ~(PSR_ICC);
270 regs->psr |= (psr & PSR_ICC);
271 return;
272
273 segv_and_exit:
274 force_sig(SIGSEGV, current);
275 }
276
277 asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
278 {
279 struct rt_signal_frame __user *sf;
280 unsigned int psr, pc, npc;
281 __siginfo_fpu_t __user *fpu_save;
282 mm_segment_t old_fs;
283 sigset_t set;
284 stack_t st;
285 int err;
286
287 synchronize_user_stack();
288 sf = (struct rt_signal_frame __user *) regs->u_regs[UREG_FP];
289 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
290 (((unsigned long) sf) & 0x03))
291 goto segv;
292
293 err = __get_user(pc, &sf->regs.pc);
294 err |= __get_user(npc, &sf->regs.npc);
295 err |= ((pc | npc) & 0x03);
296
297 err |= __get_user(regs->y, &sf->regs.y);
298 err |= __get_user(psr, &sf->regs.psr);
299
300 err |= __copy_from_user(&regs->u_regs[UREG_G1],
301 &sf->regs.u_regs[UREG_G1], 15 * sizeof(u32));
302
303 regs->psr = (regs->psr & ~PSR_ICC) | (psr & PSR_ICC);
304
305 /* Prevent syscall restart. */
306 pt_regs_clear_syscall(regs);
307
308 err |= __get_user(fpu_save, &sf->fpu_save);
309
310 if (fpu_save)
311 err |= restore_fpu_state(regs, fpu_save);
312 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
313
314 err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
315
316 if (err)
317 goto segv;
318
319 regs->pc = pc;
320 regs->npc = npc;
321
322 /* It is more difficult to avoid calling this function than to
323 * call it and ignore errors.
324 */
325 old_fs = get_fs();
326 set_fs(KERNEL_DS);
327 do_sigaltstack((const stack_t __user *) &st, NULL, (unsigned long)sf);
328 set_fs(old_fs);
329
330 sigdelsetmask(&set, ~_BLOCKABLE);
331 spin_lock_irq(&current->sighand->siglock);
332 current->blocked = set;
333 recalc_sigpending();
334 spin_unlock_irq(&current->sighand->siglock);
335 return;
336 segv:
337 force_sig(SIGSEGV, current);
338 }
339
340 /* Checks if the fp is valid */
341 static inline int invalid_frame_pointer(void __user *fp, int fplen)
342 {
343 if ((((unsigned long) fp) & 7) ||
344 !__access_ok((unsigned long)fp, fplen) ||
345 ((sparc_cpu_model == sun4 || sparc_cpu_model == sun4c) &&
346 ((unsigned long) fp < 0xe0000000 && (unsigned long) fp >= 0x20000000)))
347 return 1;
348
349 return 0;
350 }
351
352 static inline void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
353 {
354 unsigned long sp = regs->u_regs[UREG_FP];
355
356 /*
357 * If we are on the alternate signal stack and would overflow it, don't.
358 * Return an always-bogus address instead so we will die with SIGSEGV.
359 */
360 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
361 return (void __user *) -1L;
362
363 /* This is the X/Open sanctioned signal stack switching. */
364 if (sa->sa_flags & SA_ONSTACK) {
365 if (sas_ss_flags(sp) == 0)
366 sp = current->sas_ss_sp + current->sas_ss_size;
367 }
368
369 /* Always align the stack frame. This handles two cases. First,
370 * sigaltstack need not be mindful of platform specific stack
371 * alignment. Second, if we took this signal because the stack
372 * is not aligned properly, we'd like to take the signal cleanly
373 * and report that.
374 */
375 sp &= ~7UL;
376
377 return (void __user *)(sp - framesize);
378 }
379
380 static inline void
381 setup_frame(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
382 {
383 struct signal_sframe __user *sframep;
384 struct sigcontext __user *sc;
385 int window = 0, err;
386 unsigned long pc = regs->pc;
387 unsigned long npc = regs->npc;
388 struct thread_info *tp = current_thread_info();
389 void __user *sig_address;
390 int sig_code;
391
392 synchronize_user_stack();
393 sframep = (struct signal_sframe __user *)
394 get_sigframe(sa, regs, SF_ALIGNEDSZ);
395 if (invalid_frame_pointer(sframep, sizeof(*sframep))){
396 /* Don't change signal code and address, so that
397 * post mortem debuggers can have a look.
398 */
399 goto sigill_and_return;
400 }
401
402 sc = &sframep->sig_context;
403
404 /* We've already made sure frame pointer isn't in kernel space... */
405 err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
406 &sc->sigc_onstack);
407 err |= __put_user(oldset->sig[0], &sc->sigc_mask);
408 err |= __copy_to_user(sframep->extramask, &oldset->sig[1],
409 (_NSIG_WORDS - 1) * sizeof(unsigned int));
410 err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
411 err |= __put_user(pc, &sc->sigc_pc);
412 err |= __put_user(npc, &sc->sigc_npc);
413 err |= __put_user(regs->psr, &sc->sigc_psr);
414 err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
415 err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
416 err |= __put_user(tp->w_saved, &sc->sigc_oswins);
417 if (tp->w_saved)
418 for (window = 0; window < tp->w_saved; window++) {
419 put_user((char *)tp->rwbuf_stkptrs[window],
420 &sc->sigc_spbuf[window]);
421 err |= __copy_to_user(&sc->sigc_wbuf[window],
422 &tp->reg_window[window],
423 sizeof(struct reg_window));
424 }
425 else
426 err |= __copy_to_user(sframep, (char *) regs->u_regs[UREG_FP],
427 sizeof(struct reg_window));
428
429 tp->w_saved = 0; /* So process is allowed to execute. */
430
431 err |= __put_user(signr, &sframep->sig_num);
432 sig_address = NULL;
433 sig_code = 0;
434 if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
435 sig_address = info->si_addr;
436 switch (signr) {
437 case SIGSEGV:
438 switch (info->si_code) {
439 case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
440 default: sig_code = SUBSIG_PROTECTION; break;
441 }
442 break;
443 case SIGILL:
444 switch (info->si_code) {
445 case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
446 case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
447 case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
448 default: sig_code = SUBSIG_STACK; break;
449 }
450 break;
451 case SIGFPE:
452 switch (info->si_code) {
453 case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
454 case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
455 case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
456 case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
457 case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
458 case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
459 case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
460 default: sig_code = SUBSIG_FPERROR; break;
461 }
462 break;
463 case SIGBUS:
464 switch (info->si_code) {
465 case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
466 case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
467 default: sig_code = SUBSIG_BUSTIMEOUT; break;
468 }
469 break;
470 case SIGEMT:
471 switch (info->si_code) {
472 case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
473 }
474 break;
475 case SIGSYS:
476 if (info->si_code == (__SI_FAULT|0x100)) {
477 /* See sys_sunos.c */
478 sig_code = info->si_trapno;
479 break;
480 }
481 default:
482 sig_address = NULL;
483 }
484 }
485 err |= __put_user((unsigned long)sig_address, &sframep->sig_address);
486 err |= __put_user(sig_code, &sframep->sig_code);
487 err |= __put_user(sc, &sframep->sig_scptr);
488 if (err)
489 goto sigsegv;
490
491 regs->u_regs[UREG_FP] = (unsigned long) sframep;
492 regs->pc = (unsigned long) sa->sa_handler;
493 regs->npc = (regs->pc + 4);
494 return;
495
496 sigill_and_return:
497 do_exit(SIGILL);
498 sigsegv:
499 force_sigsegv(signr, current);
500 }
501
502
503 static inline int
504 save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
505 {
506 int err = 0;
507 #ifdef CONFIG_SMP
508 if (test_tsk_thread_flag(current, TIF_USEDFPU)) {
509 put_psr(get_psr() | PSR_EF);
510 fpsave(&current->thread.float_regs[0], &current->thread.fsr,
511 &current->thread.fpqueue[0], &current->thread.fpqdepth);
512 regs->psr &= ~(PSR_EF);
513 clear_tsk_thread_flag(current, TIF_USEDFPU);
514 }
515 #else
516 if (current == last_task_used_math) {
517 put_psr(get_psr() | PSR_EF);
518 fpsave(&current->thread.float_regs[0], &current->thread.fsr,
519 &current->thread.fpqueue[0], &current->thread.fpqdepth);
520 last_task_used_math = NULL;
521 regs->psr &= ~(PSR_EF);
522 }
523 #endif
524 err |= __copy_to_user(&fpu->si_float_regs[0],
525 &current->thread.float_regs[0],
526 (sizeof(unsigned long) * 32));
527 err |= __put_user(current->thread.fsr, &fpu->si_fsr);
528 err |= __put_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
529 if (current->thread.fpqdepth != 0)
530 err |= __copy_to_user(&fpu->si_fpqueue[0],
531 &current->thread.fpqueue[0],
532 ((sizeof(unsigned long) +
533 (sizeof(unsigned long *)))*16));
534 clear_used_math();
535 return err;
536 }
537
538 static inline void
539 new_setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
540 int signo, sigset_t *oldset)
541 {
542 struct new_signal_frame __user *sf;
543 int sigframe_size, err;
544
545 /* 1. Make sure everything is clean */
546 synchronize_user_stack();
547
548 sigframe_size = NF_ALIGNEDSZ;
549 if (!used_math())
550 sigframe_size -= sizeof(__siginfo_fpu_t);
551
552 sf = (struct new_signal_frame __user *)
553 get_sigframe(&ka->sa, regs, sigframe_size);
554
555 if (invalid_frame_pointer(sf, sigframe_size))
556 goto sigill_and_return;
557
558 if (current_thread_info()->w_saved != 0)
559 goto sigill_and_return;
560
561 /* 2. Save the current process state */
562 err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs));
563
564 err |= __put_user(0, &sf->extra_size);
565
566 if (used_math()) {
567 err |= save_fpu_state(regs, &sf->fpu_state);
568 err |= __put_user(&sf->fpu_state, &sf->fpu_save);
569 } else {
570 err |= __put_user(0, &sf->fpu_save);
571 }
572
573 err |= __put_user(oldset->sig[0], &sf->info.si_mask);
574 err |= __copy_to_user(sf->extramask, &oldset->sig[1],
575 (_NSIG_WORDS - 1) * sizeof(unsigned int));
576 err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
577 sizeof(struct reg_window));
578 if (err)
579 goto sigsegv;
580
581 /* 3. signal handler back-trampoline and parameters */
582 regs->u_regs[UREG_FP] = (unsigned long) sf;
583 regs->u_regs[UREG_I0] = signo;
584 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
585 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
586
587 /* 4. signal handler */
588 regs->pc = (unsigned long) ka->sa.sa_handler;
589 regs->npc = (regs->pc + 4);
590
591 /* 5. return to kernel instructions */
592 if (ka->ka_restorer)
593 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
594 else {
595 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
596
597 /* mov __NR_sigreturn, %g1 */
598 err |= __put_user(0x821020d8, &sf->insns[0]);
599
600 /* t 0x10 */
601 err |= __put_user(0x91d02010, &sf->insns[1]);
602 if (err)
603 goto sigsegv;
604
605 /* Flush instruction space. */
606 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
607 }
608 return;
609
610 sigill_and_return:
611 do_exit(SIGILL);
612 sigsegv:
613 force_sigsegv(signo, current);
614 }
615
616 static inline void
617 new_setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
618 int signo, sigset_t *oldset, siginfo_t *info)
619 {
620 struct rt_signal_frame __user *sf;
621 int sigframe_size;
622 unsigned int psr;
623 int err;
624
625 synchronize_user_stack();
626 sigframe_size = RT_ALIGNEDSZ;
627 if (!used_math())
628 sigframe_size -= sizeof(__siginfo_fpu_t);
629 sf = (struct rt_signal_frame __user *)
630 get_sigframe(&ka->sa, regs, sigframe_size);
631 if (invalid_frame_pointer(sf, sigframe_size))
632 goto sigill;
633 if (current_thread_info()->w_saved != 0)
634 goto sigill;
635
636 err = __put_user(regs->pc, &sf->regs.pc);
637 err |= __put_user(regs->npc, &sf->regs.npc);
638 err |= __put_user(regs->y, &sf->regs.y);
639 psr = regs->psr;
640 if (used_math())
641 psr |= PSR_EF;
642 err |= __put_user(psr, &sf->regs.psr);
643 err |= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
644 err |= __put_user(0, &sf->extra_size);
645
646 if (psr & PSR_EF) {
647 err |= save_fpu_state(regs, &sf->fpu_state);
648 err |= __put_user(&sf->fpu_state, &sf->fpu_save);
649 } else {
650 err |= __put_user(0, &sf->fpu_save);
651 }
652 err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
653
654 /* Setup sigaltstack */
655 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
656 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
657 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
658
659 err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
660 sizeof(struct reg_window));
661
662 err |= copy_siginfo_to_user(&sf->info, info);
663
664 if (err)
665 goto sigsegv;
666
667 regs->u_regs[UREG_FP] = (unsigned long) sf;
668 regs->u_regs[UREG_I0] = signo;
669 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
670 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
671
672 regs->pc = (unsigned long) ka->sa.sa_handler;
673 regs->npc = (regs->pc + 4);
674
675 if (ka->ka_restorer)
676 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
677 else {
678 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
679
680 /* mov __NR_sigreturn, %g1 */
681 err |= __put_user(0x821020d8, &sf->insns[0]);
682
683 /* t 0x10 */
684 err |= __put_user(0x91d02010, &sf->insns[1]);
685 if (err)
686 goto sigsegv;
687
688 /* Flush instruction space. */
689 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
690 }
691 return;
692
693 sigill:
694 do_exit(SIGILL);
695 sigsegv:
696 force_sigsegv(signo, current);
697 }
698
699 /* Setup a Solaris stack frame */
700 static inline void
701 setup_svr4_frame(struct sigaction *sa, unsigned long pc, unsigned long npc,
702 struct pt_regs *regs, int signr, sigset_t *oldset)
703 {
704 svr4_signal_frame_t __user *sfp;
705 svr4_gregset_t __user *gr;
706 svr4_siginfo_t __user *si;
707 svr4_mcontext_t __user *mc;
708 svr4_gwindows_t __user *gw;
709 svr4_ucontext_t __user *uc;
710 svr4_sigset_t setv;
711 struct thread_info *tp = current_thread_info();
712 int window = 0, err;
713
714 synchronize_user_stack();
715 sfp = (svr4_signal_frame_t __user *)
716 get_sigframe(sa, regs, SVR4_SF_ALIGNED + sizeof(struct reg_window));
717
718 if (invalid_frame_pointer(sfp, sizeof(*sfp)))
719 goto sigill_and_return;
720
721 /* Start with a clean frame pointer and fill it */
722 err = __clear_user(sfp, sizeof(*sfp));
723
724 /* Setup convenience variables */
725 si = &sfp->si;
726 uc = &sfp->uc;
727 gw = &sfp->gw;
728 mc = &uc->mcontext;
729 gr = &mc->greg;
730
731 /* FIXME: where am I supposed to put this?
732 * sc->sigc_onstack = old_status;
733 * anyways, it does not look like it is used for anything at all.
734 */
735 setv.sigbits[0] = oldset->sig[0];
736 setv.sigbits[1] = oldset->sig[1];
737 if (_NSIG_WORDS >= 4) {
738 setv.sigbits[2] = oldset->sig[2];
739 setv.sigbits[3] = oldset->sig[3];
740 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
741 } else
742 err |= __copy_to_user(&uc->sigmask, &setv,
743 2 * sizeof(unsigned int));
744
745 /* Store registers */
746 err |= __put_user(regs->pc, &((*gr)[SVR4_PC]));
747 err |= __put_user(regs->npc, &((*gr)[SVR4_NPC]));
748 err |= __put_user(regs->psr, &((*gr)[SVR4_PSR]));
749 err |= __put_user(regs->y, &((*gr)[SVR4_Y]));
750
751 /* Copy g[1..7] and o[0..7] registers */
752 err |= __copy_to_user(&(*gr)[SVR4_G1], &regs->u_regs[UREG_G1],
753 sizeof(long) * 7);
754 err |= __copy_to_user(&(*gr)[SVR4_O0], &regs->u_regs[UREG_I0],
755 sizeof(long) * 8);
756
757 /* Setup sigaltstack */
758 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
759 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
760 err |= __put_user(current->sas_ss_size, &uc->stack.size);
761
762 /* Save the currently window file: */
763
764 /* 1. Link sfp->uc->gwins to our windows */
765 err |= __put_user(gw, &mc->gwin);
766
767 /* 2. Number of windows to restore at setcontext(): */
768 err |= __put_user(tp->w_saved, &gw->count);
769
770 /* 3. Save each valid window
771 * Currently, it makes a copy of the windows from the kernel copy.
772 * David's code for SunOS, makes the copy but keeps the pointer to
773 * the kernel. My version makes the pointer point to a userland
774 * copy of those. Mhm, I wonder if I shouldn't just ignore those
775 * on setcontext and use those that are on the kernel, the signal
776 * handler should not be modyfing those, mhm.
777 *
778 * These windows are just used in case synchronize_user_stack failed
779 * to flush the user windows.
780 */
781 for (window = 0; window < tp->w_saved; window++) {
782 err |= __put_user((int __user *) &(gw->win[window]), &gw->winptr[window]);
783 err |= __copy_to_user(&gw->win[window],
784 &tp->reg_window[window],
785 sizeof(svr4_rwindow_t));
786 err |= __put_user(0, gw->winptr[window]);
787 }
788
789 /* 4. We just pay attention to the gw->count field on setcontext */
790 tp->w_saved = 0; /* So process is allowed to execute. */
791
792 /* Setup the signal information. Solaris expects a bunch of
793 * information to be passed to the signal handler, we don't provide
794 * that much currently, should use siginfo.
795 */
796 err |= __put_user(signr, &si->siginfo.signo);
797 err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
798 if (err)
799 goto sigsegv;
800
801 regs->u_regs[UREG_FP] = (unsigned long) sfp;
802 regs->pc = (unsigned long) sa->sa_handler;
803 regs->npc = (regs->pc + 4);
804
805 /* Arguments passed to signal handler */
806 if (regs->u_regs[14]){
807 struct reg_window __user *rw = (struct reg_window __user *)
808 regs->u_regs[14];
809
810 err |= __put_user(signr, &rw->ins[0]);
811 err |= __put_user(si, &rw->ins[1]);
812 err |= __put_user(uc, &rw->ins[2]);
813 err |= __put_user(sfp, &rw->ins[6]); /* frame pointer */
814 if (err)
815 goto sigsegv;
816
817 regs->u_regs[UREG_I0] = signr;
818 regs->u_regs[UREG_I1] = (unsigned long) si;
819 regs->u_regs[UREG_I2] = (unsigned long) uc;
820 }
821 return;
822
823 sigill_and_return:
824 do_exit(SIGILL);
825 sigsegv:
826 force_sigsegv(signr, current);
827 }
828
829 asmlinkage int svr4_getcontext(svr4_ucontext_t __user *uc, struct pt_regs *regs)
830 {
831 svr4_gregset_t __user *gr;
832 svr4_mcontext_t __user *mc;
833 svr4_sigset_t setv;
834 int err = 0;
835
836 synchronize_user_stack();
837
838 if (current_thread_info()->w_saved)
839 return -EFAULT;
840
841 err = clear_user(uc, sizeof(*uc));
842 if (err)
843 return -EFAULT;
844
845 /* Setup convenience variables */
846 mc = &uc->mcontext;
847 gr = &mc->greg;
848
849 setv.sigbits[0] = current->blocked.sig[0];
850 setv.sigbits[1] = current->blocked.sig[1];
851 if (_NSIG_WORDS >= 4) {
852 setv.sigbits[2] = current->blocked.sig[2];
853 setv.sigbits[3] = current->blocked.sig[3];
854 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
855 } else
856 err |= __copy_to_user(&uc->sigmask, &setv,
857 2 * sizeof(unsigned int));
858
859 /* Store registers */
860 err |= __put_user(regs->pc, &uc->mcontext.greg[SVR4_PC]);
861 err |= __put_user(regs->npc, &uc->mcontext.greg[SVR4_NPC]);
862 err |= __put_user(regs->psr, &uc->mcontext.greg[SVR4_PSR]);
863 err |= __put_user(regs->y, &uc->mcontext.greg[SVR4_Y]);
864
865 /* Copy g[1..7] and o[0..7] registers */
866 err |= __copy_to_user(&(*gr)[SVR4_G1], &regs->u_regs[UREG_G1],
867 sizeof(uint) * 7);
868 err |= __copy_to_user(&(*gr)[SVR4_O0], &regs->u_regs[UREG_I0],
869 sizeof(uint) * 8);
870
871 /* Setup sigaltstack */
872 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
873 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
874 err |= __put_user(current->sas_ss_size, &uc->stack.size);
875
876 /* The register file is not saved
877 * we have already stuffed all of it with sync_user_stack
878 */
879 return (err ? -EFAULT : 0);
880 }
881
882 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
883 asmlinkage int svr4_setcontext(svr4_ucontext_t __user *c, struct pt_regs *regs)
884 {
885 svr4_gregset_t __user *gr;
886 unsigned long pc, npc, psr;
887 mm_segment_t old_fs;
888 sigset_t set;
889 svr4_sigset_t setv;
890 int err;
891 stack_t st;
892
893 /* Fixme: restore windows, or is this already taken care of in
894 * svr4_setup_frame when sync_user_windows is done?
895 */
896 flush_user_windows();
897
898 if (current_thread_info()->w_saved)
899 goto sigsegv_and_return;
900
901 if (((unsigned long) c) & 3)
902 goto sigsegv_and_return;
903
904 if (!__access_ok((unsigned long)c, sizeof(*c)))
905 goto sigsegv_and_return;
906
907 /* Check for valid PC and nPC */
908 gr = &c->mcontext.greg;
909 err = __get_user(pc, &((*gr)[SVR4_PC]));
910 err |= __get_user(npc, &((*gr)[SVR4_NPC]));
911
912 if ((pc | npc) & 3)
913 goto sigsegv_and_return;
914
915 /* Retrieve information from passed ucontext */
916 /* note that nPC is ored a 1, this is used to inform entry.S */
917 /* that we don't want it to mess with our PC and nPC */
918
919 /* This is pretty much atomic, no amount locking would prevent
920 * the races which exist anyways.
921 */
922 err |= __copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
923
924 err |= __get_user(st.ss_sp, &c->stack.sp);
925 err |= __get_user(st.ss_flags, &c->stack.flags);
926 err |= __get_user(st.ss_size, &c->stack.size);
927
928 if (err)
929 goto sigsegv_and_return;
930
931 /* It is more difficult to avoid calling this function than to
932 call it and ignore errors. */
933 old_fs = get_fs();
934 set_fs(KERNEL_DS);
935 do_sigaltstack((const stack_t __user *) &st, NULL,
936 regs->u_regs[UREG_I6]);
937 set_fs(old_fs);
938
939 set.sig[0] = setv.sigbits[0];
940 set.sig[1] = setv.sigbits[1];
941 if (_NSIG_WORDS >= 4) {
942 set.sig[2] = setv.sigbits[2];
943 set.sig[3] = setv.sigbits[3];
944 }
945 sigdelsetmask(&set, ~_BLOCKABLE);
946 spin_lock_irq(&current->sighand->siglock);
947 current->blocked = set;
948 recalc_sigpending();
949 spin_unlock_irq(&current->sighand->siglock);
950 regs->pc = pc;
951 regs->npc = npc | 1;
952 err |= __get_user(regs->y, &((*gr)[SVR4_Y]));
953 err |= __get_user(psr, &((*gr)[SVR4_PSR]));
954 regs->psr &= ~(PSR_ICC);
955 regs->psr |= (psr & PSR_ICC);
956
957 /* Restore g[1..7] and o[0..7] registers */
958 err |= __copy_from_user(&regs->u_regs[UREG_G1], &(*gr)[SVR4_G1],
959 sizeof(long) * 7);
960 err |= __copy_from_user(&regs->u_regs[UREG_I0], &(*gr)[SVR4_O0],
961 sizeof(long) * 8);
962 return (err ? -EFAULT : 0);
963
964 sigsegv_and_return:
965 force_sig(SIGSEGV, current);
966 return -EFAULT;
967 }
968
969 static inline void
970 handle_signal(unsigned long signr, struct k_sigaction *ka,
971 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
972 int svr4_signal)
973 {
974 if (svr4_signal)
975 setup_svr4_frame(&ka->sa, regs->pc, regs->npc, regs, signr, oldset);
976 else {
977 if (ka->sa.sa_flags & SA_SIGINFO)
978 new_setup_rt_frame(ka, regs, signr, oldset, info);
979 else if (current->thread.new_signal)
980 new_setup_frame(ka, regs, signr, oldset);
981 else
982 setup_frame(&ka->sa, regs, signr, oldset, info);
983 }
984 spin_lock_irq(&current->sighand->siglock);
985 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
986 if (!(ka->sa.sa_flags & SA_NOMASK))
987 sigaddset(&current->blocked, signr);
988 recalc_sigpending();
989 spin_unlock_irq(&current->sighand->siglock);
990 }
991
992 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
993 struct sigaction *sa)
994 {
995 switch(regs->u_regs[UREG_I0]) {
996 case ERESTART_RESTARTBLOCK:
997 case ERESTARTNOHAND:
998 no_system_call_restart:
999 regs->u_regs[UREG_I0] = EINTR;
1000 regs->psr |= PSR_C;
1001 break;
1002 case ERESTARTSYS:
1003 if (!(sa->sa_flags & SA_RESTART))
1004 goto no_system_call_restart;
1005 /* fallthrough */
1006 case ERESTARTNOINTR:
1007 regs->u_regs[UREG_I0] = orig_i0;
1008 regs->pc -= 4;
1009 regs->npc -= 4;
1010 }
1011 }
1012
1013 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1014 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1015 * mistake.
1016 */
1017 asmlinkage void do_signal(struct pt_regs * regs, unsigned long orig_i0)
1018 {
1019 struct k_sigaction ka;
1020 int restart_syscall;
1021 sigset_t *oldset;
1022 siginfo_t info;
1023 int signr;
1024
1025 /*
1026 * XXX Disable svr4 signal handling until solaris emulation works.
1027 * It is buggy - Anton
1028 */
1029 #define SVR4_SIGNAL_BROKEN 1
1030 #ifdef SVR4_SIGNAL_BROKEN
1031 int svr4_signal = 0;
1032 #else
1033 int svr4_signal = current->personality == PER_SVR4;
1034 #endif
1035
1036 if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))
1037 restart_syscall = 1;
1038 else
1039 restart_syscall = 0;
1040
1041 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1042 oldset = &current->saved_sigmask;
1043 else
1044 oldset = &current->blocked;
1045
1046 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1047
1048 /* If the debugger messes with the program counter, it clears
1049 * the software "in syscall" bit, directing us to not perform
1050 * a syscall restart.
1051 */
1052 if (restart_syscall && !pt_regs_is_syscall(regs))
1053 restart_syscall = 0;
1054
1055 if (signr > 0) {
1056 if (restart_syscall)
1057 syscall_restart(orig_i0, regs, &ka.sa);
1058 handle_signal(signr, &ka, &info, oldset,
1059 regs, svr4_signal);
1060 /* a signal was successfully delivered; the saved
1061 * sigmask will have been stored in the signal frame,
1062 * and will be restored by sigreturn, so we can simply
1063 * clear the TIF_RESTORE_SIGMASK flag.
1064 */
1065 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1066 clear_thread_flag(TIF_RESTORE_SIGMASK);
1067 return;
1068 }
1069 if (restart_syscall &&
1070 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1071 regs->u_regs[UREG_I0] == ERESTARTSYS ||
1072 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1073 /* replay the system call when we are done */
1074 regs->u_regs[UREG_I0] = orig_i0;
1075 regs->pc -= 4;
1076 regs->npc -= 4;
1077 }
1078 if (restart_syscall &&
1079 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
1080 regs->u_regs[UREG_G1] = __NR_restart_syscall;
1081 regs->pc -= 4;
1082 regs->npc -= 4;
1083 }
1084
1085 /* if there's no signal to deliver, we just put the saved sigmask
1086 * back
1087 */
1088 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1089 clear_thread_flag(TIF_RESTORE_SIGMASK);
1090 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
1091 }
1092 }
1093
1094 asmlinkage int
1095 do_sys_sigstack(struct sigstack __user *ssptr, struct sigstack __user *ossptr,
1096 unsigned long sp)
1097 {
1098 int ret = -EFAULT;
1099
1100 /* First see if old state is wanted. */
1101 if (ossptr) {
1102 if (put_user(current->sas_ss_sp + current->sas_ss_size,
1103 &ossptr->the_stack) ||
1104 __put_user(on_sig_stack(sp), &ossptr->cur_status))
1105 goto out;
1106 }
1107
1108 /* Now see if we want to update the new state. */
1109 if (ssptr) {
1110 char *ss_sp;
1111
1112 if (get_user(ss_sp, &ssptr->the_stack))
1113 goto out;
1114 /* If the current stack was set with sigaltstack, don't
1115 swap stacks while we are on it. */
1116 ret = -EPERM;
1117 if (current->sas_ss_sp && on_sig_stack(sp))
1118 goto out;
1119
1120 /* Since we don't know the extent of the stack, and we don't
1121 track onstack-ness, but rather calculate it, we must
1122 presume a size. Ho hum this interface is lossy. */
1123 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1124 current->sas_ss_size = SIGSTKSZ;
1125 }
1126 ret = 0;
1127 out:
1128 return ret;
1129 }
mah project overlay