?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.8-rc7
[cris-mirror.git] / arch / m68k / kernel / signal.c
blob9a396cda3147d4f56508891ce70f9e6646a670bf
1 /*
2 * linux/arch/m68k/kernel/signal.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file COPYING in the main directory of this archive
8 * for more details.
9 */
10
11 /*
12 * Linux/m68k support by Hamish Macdonald
13 *
14 * 68060 fixes by Jesper Skov
15 *
16 * 1997-12-01 Modified for POSIX.1b signals by Andreas Schwab
17 *
18 * mathemu support by Roman Zippel
19 * (Note: fpstate in the signal context is completely ignored for the emulator
20 * and the internal floating point format is put on stack)
21 */
22
23 /*
24 * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
25 * Atari :-) Current limitation: Only one sigstack can be active at one time.
26 * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
27 * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
28 * signal handlers!
29 */
30
31 #include <linux/sched.h>
32 #include <linux/mm.h>
33 #include <linux/kernel.h>
34 #include <linux/signal.h>
35 #include <linux/syscalls.h>
36 #include <linux/errno.h>
37 #include <linux/wait.h>
38 #include <linux/ptrace.h>
39 #include <linux/unistd.h>
40 #include <linux/stddef.h>
41 #include <linux/highuid.h>
42 #include <linux/personality.h>
43 #include <linux/tty.h>
44 #include <linux/binfmts.h>
45 #include <linux/module.h>
46 #include <linux/tracehook.h>
47
48 #include <asm/setup.h>
49 #include <asm/uaccess.h>
50 #include <asm/pgtable.h>
51 #include <asm/traps.h>
52 #include <asm/ucontext.h>
53
54 #ifdef CONFIG_MMU
55
56 /*
57 * Handle the slight differences in classic 68k and ColdFire trap frames.
58 */
59 #ifdef CONFIG_COLDFIRE
60 #define FORMAT 4
61 #define FMT4SIZE 0
62 #else
63 #define FORMAT 0
64 #define FMT4SIZE sizeof(((struct frame *)0)->un.fmt4)
65 #endif
66
67 static const int frame_size_change[16] = {
68 [1] = -1, /* sizeof(((struct frame *)0)->un.fmt1), */
69 [2] = sizeof(((struct frame *)0)->un.fmt2),
70 [3] = sizeof(((struct frame *)0)->un.fmt3),
71 [4] = FMT4SIZE,
72 [5] = -1, /* sizeof(((struct frame *)0)->un.fmt5), */
73 [6] = -1, /* sizeof(((struct frame *)0)->un.fmt6), */
74 [7] = sizeof(((struct frame *)0)->un.fmt7),
75 [8] = -1, /* sizeof(((struct frame *)0)->un.fmt8), */
76 [9] = sizeof(((struct frame *)0)->un.fmt9),
77 [10] = sizeof(((struct frame *)0)->un.fmta),
78 [11] = sizeof(((struct frame *)0)->un.fmtb),
79 [12] = -1, /* sizeof(((struct frame *)0)->un.fmtc), */
80 [13] = -1, /* sizeof(((struct frame *)0)->un.fmtd), */
81 [14] = -1, /* sizeof(((struct frame *)0)->un.fmte), */
82 [15] = -1, /* sizeof(((struct frame *)0)->un.fmtf), */
83 };
84
85 static inline int frame_extra_sizes(int f)
86 {
87 return frame_size_change[f];
88 }
89
90 int handle_kernel_fault(struct pt_regs *regs)
91 {
92 const struct exception_table_entry *fixup;
93 struct pt_regs *tregs;
94
95 /* Are we prepared to handle this kernel fault? */
96 fixup = search_exception_tables(regs->pc);
97 if (!fixup)
98 return 0;
99
100 /* Create a new four word stack frame, discarding the old one. */
101 regs->stkadj = frame_extra_sizes(regs->format);
102 tregs = (struct pt_regs *)((long)regs + regs->stkadj);
103 tregs->vector = regs->vector;
104 tregs->format = FORMAT;
105 tregs->pc = fixup->fixup;
106 tregs->sr = regs->sr;
107
108 return 1;
109 }
110
111 void ptrace_signal_deliver(void)
112 {
113 struct pt_regs *regs = signal_pt_regs();
114 if (regs->orig_d0 < 0)
115 return;
116 switch (regs->d0) {
117 case -ERESTARTNOHAND:
118 case -ERESTARTSYS:
119 case -ERESTARTNOINTR:
120 regs->d0 = regs->orig_d0;
121 regs->orig_d0 = -1;
122 regs->pc -= 2;
123 break;
124 }
125 }
126
127 static inline void push_cache (unsigned long vaddr)
128 {
129 /*
130 * Using the old cache_push_v() was really a big waste.
131 *
132 * What we are trying to do is to flush 8 bytes to ram.
133 * Flushing 2 cache lines of 16 bytes is much cheaper than
134 * flushing 1 or 2 pages, as previously done in
135 * cache_push_v().
136 * Jes
137 */
138 if (CPU_IS_040) {
139 unsigned long temp;
140
141 __asm__ __volatile__ (".chip 68040\n\t"
142 "nop\n\t"
143 "ptestr (%1)\n\t"
144 "movec %%mmusr,%0\n\t"
145 ".chip 68k"
146 : "=r" (temp)
147 : "a" (vaddr));
148
149 temp &= PAGE_MASK;
150 temp |= vaddr & ~PAGE_MASK;
151
152 __asm__ __volatile__ (".chip 68040\n\t"
153 "nop\n\t"
154 "cpushl %%bc,(%0)\n\t"
155 ".chip 68k"
156 : : "a" (temp));
157 }
158 else if (CPU_IS_060) {
159 unsigned long temp;
160 __asm__ __volatile__ (".chip 68060\n\t"
161 "plpar (%0)\n\t"
162 ".chip 68k"
163 : "=a" (temp)
164 : "0" (vaddr));
165 __asm__ __volatile__ (".chip 68060\n\t"
166 "cpushl %%bc,(%0)\n\t"
167 ".chip 68k"
168 : : "a" (temp));
169 } else if (!CPU_IS_COLDFIRE) {
170 /*
171 * 68030/68020 have no writeback cache;
172 * still need to clear icache.
173 * Note that vaddr is guaranteed to be long word aligned.
174 */
175 unsigned long temp;
176 asm volatile ("movec %%cacr,%0" : "=r" (temp));
177 temp += 4;
178 asm volatile ("movec %0,%%caar\n\t"
179 "movec %1,%%cacr"
180 : : "r" (vaddr), "r" (temp));
181 asm volatile ("movec %0,%%caar\n\t"
182 "movec %1,%%cacr"
183 : : "r" (vaddr + 4), "r" (temp));
184 }
185 }
186
187 static inline void adjustformat(struct pt_regs *regs)
188 {
189 }
190
191 static inline void save_a5_state(struct sigcontext *sc, struct pt_regs *regs)
192 {
193 }
194
195 #else /* CONFIG_MMU */
196
197 void ret_from_user_signal(void);
198 void ret_from_user_rt_signal(void);
199
200 static inline int frame_extra_sizes(int f)
201 {
202 /* No frame size adjustments required on non-MMU CPUs */
203 return 0;
204 }
205
206 static inline void adjustformat(struct pt_regs *regs)
207 {
208 ((struct switch_stack *)regs - 1)->a5 = current->mm->start_data;
209 /*
210 * set format byte to make stack appear modulo 4, which it will
211 * be when doing the rte
212 */
213 regs->format = 0x4;
214 }
215
216 static inline void save_a5_state(struct sigcontext *sc, struct pt_regs *regs)
217 {
218 sc->sc_a5 = ((struct switch_stack *)regs - 1)->a5;
219 }
220
221 static inline void push_cache(unsigned long vaddr)
222 {
223 }
224
225 #endif /* CONFIG_MMU */
226
227 /*
228 * Atomically swap in the new signal mask, and wait for a signal.
229 */
230 asmlinkage int
231 sys_sigsuspend(int unused0, int unused1, old_sigset_t mask)
232 {
233 sigset_t blocked;
234 siginitset(&blocked, mask);
235 return sigsuspend(&blocked);
236 }
237
238 asmlinkage int
239 sys_sigaction(int sig, const struct old_sigaction __user *act,
240 struct old_sigaction __user *oact)
241 {
242 struct k_sigaction new_ka, old_ka;
243 int ret;
244
245 if (act) {
246 old_sigset_t mask;
247 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
248 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
249 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
250 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
251 __get_user(mask, &act->sa_mask))
252 return -EFAULT;
253 siginitset(&new_ka.sa.sa_mask, mask);
254 }
255
256 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
257
258 if (!ret && oact) {
259 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
260 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
261 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
262 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
263 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
264 return -EFAULT;
265 }
266
267 return ret;
268 }
269
270 asmlinkage int
271 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
272 {
273 return do_sigaltstack(uss, uoss, rdusp());
274 }
275
276
277 /*
278 * Do a signal return; undo the signal stack.
279 *
280 * Keep the return code on the stack quadword aligned!
281 * That makes the cache flush below easier.
282 */
283
284 struct sigframe
285 {
286 char __user *pretcode;
287 int sig;
288 int code;
289 struct sigcontext __user *psc;
290 char retcode[8];
291 unsigned long extramask[_NSIG_WORDS-1];
292 struct sigcontext sc;
293 };
294
295 struct rt_sigframe
296 {
297 char __user *pretcode;
298 int sig;
299 struct siginfo __user *pinfo;
300 void __user *puc;
301 char retcode[8];
302 struct siginfo info;
303 struct ucontext uc;
304 };
305
306 #define FPCONTEXT_SIZE 216
307 #define uc_fpstate uc_filler[0]
308 #define uc_formatvec uc_filler[FPCONTEXT_SIZE/4]
309 #define uc_extra uc_filler[FPCONTEXT_SIZE/4+1]
310
311 #ifdef CONFIG_FPU
312
313 static unsigned char fpu_version; /* version number of fpu, set by setup_frame */
314
315 static inline int restore_fpu_state(struct sigcontext *sc)
316 {
317 int err = 1;
318
319 if (FPU_IS_EMU) {
320 /* restore registers */
321 memcpy(current->thread.fpcntl, sc->sc_fpcntl, 12);
322 memcpy(current->thread.fp, sc->sc_fpregs, 24);
323 return 0;
324 }
325
326 if (CPU_IS_060 ? sc->sc_fpstate[2] : sc->sc_fpstate[0]) {
327 /* Verify the frame format. */
328 if (!(CPU_IS_060 || CPU_IS_COLDFIRE) &&
329 (sc->sc_fpstate[0] != fpu_version))
330 goto out;
331 if (CPU_IS_020_OR_030) {
332 if (m68k_fputype & FPU_68881 &&
333 !(sc->sc_fpstate[1] == 0x18 || sc->sc_fpstate[1] == 0xb4))
334 goto out;
335 if (m68k_fputype & FPU_68882 &&
336 !(sc->sc_fpstate[1] == 0x38 || sc->sc_fpstate[1] == 0xd4))
337 goto out;
338 } else if (CPU_IS_040) {
339 if (!(sc->sc_fpstate[1] == 0x00 ||
340 sc->sc_fpstate[1] == 0x28 ||
341 sc->sc_fpstate[1] == 0x60))
342 goto out;
343 } else if (CPU_IS_060) {
344 if (!(sc->sc_fpstate[3] == 0x00 ||
345 sc->sc_fpstate[3] == 0x60 ||
346 sc->sc_fpstate[3] == 0xe0))
347 goto out;
348 } else if (CPU_IS_COLDFIRE) {
349 if (!(sc->sc_fpstate[0] == 0x00 ||
350 sc->sc_fpstate[0] == 0x05 ||
351 sc->sc_fpstate[0] == 0xe5))
352 goto out;
353 } else
354 goto out;
355
356 if (CPU_IS_COLDFIRE) {
357 __asm__ volatile ("fmovemd %0,%%fp0-%%fp1\n\t"
358 "fmovel %1,%%fpcr\n\t"
359 "fmovel %2,%%fpsr\n\t"
360 "fmovel %3,%%fpiar"
361 : /* no outputs */
362 : "m" (sc->sc_fpregs[0]),
363 "m" (sc->sc_fpcntl[0]),
364 "m" (sc->sc_fpcntl[1]),
365 "m" (sc->sc_fpcntl[2]));
366 } else {
367 __asm__ volatile (".chip 68k/68881\n\t"
368 "fmovemx %0,%%fp0-%%fp1\n\t"
369 "fmoveml %1,%%fpcr/%%fpsr/%%fpiar\n\t"
370 ".chip 68k"
371 : /* no outputs */
372 : "m" (*sc->sc_fpregs),
373 "m" (*sc->sc_fpcntl));
374 }
375 }
376
377 if (CPU_IS_COLDFIRE) {
378 __asm__ volatile ("frestore %0" : : "m" (*sc->sc_fpstate));
379 } else {
380 __asm__ volatile (".chip 68k/68881\n\t"
381 "frestore %0\n\t"
382 ".chip 68k"
383 : : "m" (*sc->sc_fpstate));
384 }
385 err = 0;
386
387 out:
388 return err;
389 }
390
391 static inline int rt_restore_fpu_state(struct ucontext __user *uc)
392 {
393 unsigned char fpstate[FPCONTEXT_SIZE];
394 int context_size = CPU_IS_060 ? 8 : (CPU_IS_COLDFIRE ? 12 : 0);
395 fpregset_t fpregs;
396 int err = 1;
397
398 if (FPU_IS_EMU) {
399 /* restore fpu control register */
400 if (__copy_from_user(current->thread.fpcntl,
401 uc->uc_mcontext.fpregs.f_fpcntl, 12))
402 goto out;
403 /* restore all other fpu register */
404 if (__copy_from_user(current->thread.fp,
405 uc->uc_mcontext.fpregs.f_fpregs, 96))
406 goto out;
407 return 0;
408 }
409
410 if (__get_user(*(long *)fpstate, (long __user *)&uc->uc_fpstate))
411 goto out;
412 if (CPU_IS_060 ? fpstate[2] : fpstate[0]) {
413 if (!(CPU_IS_060 || CPU_IS_COLDFIRE))
414 context_size = fpstate[1];
415 /* Verify the frame format. */
416 if (!(CPU_IS_060 || CPU_IS_COLDFIRE) &&
417 (fpstate[0] != fpu_version))
418 goto out;
419 if (CPU_IS_020_OR_030) {
420 if (m68k_fputype & FPU_68881 &&
421 !(context_size == 0x18 || context_size == 0xb4))
422 goto out;
423 if (m68k_fputype & FPU_68882 &&
424 !(context_size == 0x38 || context_size == 0xd4))
425 goto out;
426 } else if (CPU_IS_040) {
427 if (!(context_size == 0x00 ||
428 context_size == 0x28 ||
429 context_size == 0x60))
430 goto out;
431 } else if (CPU_IS_060) {
432 if (!(fpstate[3] == 0x00 ||
433 fpstate[3] == 0x60 ||
434 fpstate[3] == 0xe0))
435 goto out;
436 } else if (CPU_IS_COLDFIRE) {
437 if (!(fpstate[3] == 0x00 ||
438 fpstate[3] == 0x05 ||
439 fpstate[3] == 0xe5))
440 goto out;
441 } else
442 goto out;
443 if (__copy_from_user(&fpregs, &uc->uc_mcontext.fpregs,
444 sizeof(fpregs)))
445 goto out;
446
447 if (CPU_IS_COLDFIRE) {
448 __asm__ volatile ("fmovemd %0,%%fp0-%%fp7\n\t"
449 "fmovel %1,%%fpcr\n\t"
450 "fmovel %2,%%fpsr\n\t"
451 "fmovel %3,%%fpiar"
452 : /* no outputs */
453 : "m" (fpregs.f_fpregs[0]),
454 "m" (fpregs.f_fpcntl[0]),
455 "m" (fpregs.f_fpcntl[1]),
456 "m" (fpregs.f_fpcntl[2]));
457 } else {
458 __asm__ volatile (".chip 68k/68881\n\t"
459 "fmovemx %0,%%fp0-%%fp7\n\t"
460 "fmoveml %1,%%fpcr/%%fpsr/%%fpiar\n\t"
461 ".chip 68k"
462 : /* no outputs */
463 : "m" (*fpregs.f_fpregs),
464 "m" (*fpregs.f_fpcntl));
465 }
466 }
467 if (context_size &&
468 __copy_from_user(fpstate + 4, (long __user *)&uc->uc_fpstate + 1,
469 context_size))
470 goto out;
471
472 if (CPU_IS_COLDFIRE) {
473 __asm__ volatile ("frestore %0" : : "m" (*fpstate));
474 } else {
475 __asm__ volatile (".chip 68k/68881\n\t"
476 "frestore %0\n\t"
477 ".chip 68k"
478 : : "m" (*fpstate));
479 }
480 err = 0;
481
482 out:
483 return err;
484 }
485
486 /*
487 * Set up a signal frame.
488 */
489 static inline void save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
490 {
491 if (FPU_IS_EMU) {
492 /* save registers */
493 memcpy(sc->sc_fpcntl, current->thread.fpcntl, 12);
494 memcpy(sc->sc_fpregs, current->thread.fp, 24);
495 return;
496 }
497
498 if (CPU_IS_COLDFIRE) {
499 __asm__ volatile ("fsave %0"
500 : : "m" (*sc->sc_fpstate) : "memory");
501 } else {
502 __asm__ volatile (".chip 68k/68881\n\t"
503 "fsave %0\n\t"
504 ".chip 68k"
505 : : "m" (*sc->sc_fpstate) : "memory");
506 }
507
508 if (CPU_IS_060 ? sc->sc_fpstate[2] : sc->sc_fpstate[0]) {
509 fpu_version = sc->sc_fpstate[0];
510 if (CPU_IS_020_OR_030 &&
511 regs->vector >= (VEC_FPBRUC * 4) &&
512 regs->vector <= (VEC_FPNAN * 4)) {
513 /* Clear pending exception in 68882 idle frame */
514 if (*(unsigned short *) sc->sc_fpstate == 0x1f38)
515 sc->sc_fpstate[0x38] |= 1 << 3;
516 }
517
518 if (CPU_IS_COLDFIRE) {
519 __asm__ volatile ("fmovemd %%fp0-%%fp1,%0\n\t"
520 "fmovel %%fpcr,%1\n\t"
521 "fmovel %%fpsr,%2\n\t"
522 "fmovel %%fpiar,%3"
523 : "=m" (sc->sc_fpregs[0]),
524 "=m" (sc->sc_fpcntl[0]),
525 "=m" (sc->sc_fpcntl[1]),
526 "=m" (sc->sc_fpcntl[2])
527 : /* no inputs */
528 : "memory");
529 } else {
530 __asm__ volatile (".chip 68k/68881\n\t"
531 "fmovemx %%fp0-%%fp1,%0\n\t"
532 "fmoveml %%fpcr/%%fpsr/%%fpiar,%1\n\t"
533 ".chip 68k"
534 : "=m" (*sc->sc_fpregs),
535 "=m" (*sc->sc_fpcntl)
536 : /* no inputs */
537 : "memory");
538 }
539 }
540 }
541
542 static inline int rt_save_fpu_state(struct ucontext __user *uc, struct pt_regs *regs)
543 {
544 unsigned char fpstate[FPCONTEXT_SIZE];
545 int context_size = CPU_IS_060 ? 8 : (CPU_IS_COLDFIRE ? 12 : 0);
546 int err = 0;
547
548 if (FPU_IS_EMU) {
549 /* save fpu control register */
550 err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpcntl,
551 current->thread.fpcntl, 12);
552 /* save all other fpu register */
553 err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpregs,
554 current->thread.fp, 96);
555 return err;
556 }
557
558 if (CPU_IS_COLDFIRE) {
559 __asm__ volatile ("fsave %0" : : "m" (*fpstate) : "memory");
560 } else {
561 __asm__ volatile (".chip 68k/68881\n\t"
562 "fsave %0\n\t"
563 ".chip 68k"
564 : : "m" (*fpstate) : "memory");
565 }
566
567 err |= __put_user(*(long *)fpstate, (long __user *)&uc->uc_fpstate);
568 if (CPU_IS_060 ? fpstate[2] : fpstate[0]) {
569 fpregset_t fpregs;
570 if (!(CPU_IS_060 || CPU_IS_COLDFIRE))
571 context_size = fpstate[1];
572 fpu_version = fpstate[0];
573 if (CPU_IS_020_OR_030 &&
574 regs->vector >= (VEC_FPBRUC * 4) &&
575 regs->vector <= (VEC_FPNAN * 4)) {
576 /* Clear pending exception in 68882 idle frame */
577 if (*(unsigned short *) fpstate == 0x1f38)
578 fpstate[0x38] |= 1 << 3;
579 }
580 if (CPU_IS_COLDFIRE) {
581 __asm__ volatile ("fmovemd %%fp0-%%fp7,%0\n\t"
582 "fmovel %%fpcr,%1\n\t"
583 "fmovel %%fpsr,%2\n\t"
584 "fmovel %%fpiar,%3"
585 : "=m" (fpregs.f_fpregs[0]),
586 "=m" (fpregs.f_fpcntl[0]),
587 "=m" (fpregs.f_fpcntl[1]),
588 "=m" (fpregs.f_fpcntl[2])
589 : /* no inputs */
590 : "memory");
591 } else {
592 __asm__ volatile (".chip 68k/68881\n\t"
593 "fmovemx %%fp0-%%fp7,%0\n\t"
594 "fmoveml %%fpcr/%%fpsr/%%fpiar,%1\n\t"
595 ".chip 68k"
596 : "=m" (*fpregs.f_fpregs),
597 "=m" (*fpregs.f_fpcntl)
598 : /* no inputs */
599 : "memory");
600 }
601 err |= copy_to_user(&uc->uc_mcontext.fpregs, &fpregs,
602 sizeof(fpregs));
603 }
604 if (context_size)
605 err |= copy_to_user((long __user *)&uc->uc_fpstate + 1, fpstate + 4,
606 context_size);
607 return err;
608 }
609
610 #else /* CONFIG_FPU */
611
612 /*
613 * For the case with no FPU configured these all do nothing.
614 */
615 static inline int restore_fpu_state(struct sigcontext *sc)
616 {
617 return 0;
618 }
619
620 static inline int rt_restore_fpu_state(struct ucontext __user *uc)
621 {
622 return 0;
623 }
624
625 static inline void save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
626 {
627 }
628
629 static inline int rt_save_fpu_state(struct ucontext __user *uc, struct pt_regs *regs)
630 {
631 return 0;
632 }
633
634 #endif /* CONFIG_FPU */
635
636 static int mangle_kernel_stack(struct pt_regs *regs, int formatvec,
637 void __user *fp)
638 {
639 int fsize = frame_extra_sizes(formatvec >> 12);
640 if (fsize < 0) {
641 /*
642 * user process trying to return with weird frame format
643 */
644 #ifdef DEBUG
645 printk("user process returning with weird frame format\n");
646 #endif
647 return 1;
648 }
649 if (!fsize) {
650 regs->format = formatvec >> 12;
651 regs->vector = formatvec & 0xfff;
652 } else {
653 struct switch_stack *sw = (struct switch_stack *)regs - 1;
654 unsigned long buf[fsize / 2]; /* yes, twice as much */
655
656 /* that'll make sure that expansion won't crap over data */
657 if (copy_from_user(buf + fsize / 4, fp, fsize))
658 return 1;
659
660 /* point of no return */
661 regs->format = formatvec >> 12;
662 regs->vector = formatvec & 0xfff;
663 #define frame_offset (sizeof(struct pt_regs)+sizeof(struct switch_stack))
664 __asm__ __volatile__ (
665 #ifdef CONFIG_COLDFIRE
666 " movel %0,%/sp\n\t"
667 " bra ret_from_signal\n"
668 #else
669 " movel %0,%/a0\n\t"
670 " subl %1,%/a0\n\t" /* make room on stack */
671 " movel %/a0,%/sp\n\t" /* set stack pointer */
672 /* move switch_stack and pt_regs */
673 "1: movel %0@+,%/a0@+\n\t"
674 " dbra %2,1b\n\t"
675 " lea %/sp@(%c3),%/a0\n\t" /* add offset of fmt */
676 " lsrl #2,%1\n\t"
677 " subql #1,%1\n\t"
678 /* copy to the gap we'd made */
679 "2: movel %4@+,%/a0@+\n\t"
680 " dbra %1,2b\n\t"
681 " bral ret_from_signal\n"
682 #endif
683 : /* no outputs, it doesn't ever return */
684 : "a" (sw), "d" (fsize), "d" (frame_offset/4-1),
685 "n" (frame_offset), "a" (buf + fsize/4)
686 : "a0");
687 #undef frame_offset
688 }
689 return 0;
690 }
691
692 static inline int
693 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *usc, void __user *fp)
694 {
695 int formatvec;
696 struct sigcontext context;
697 int err = 0;
698
699 /* Always make any pending restarted system calls return -EINTR */
700 current_thread_info()->restart_block.fn = do_no_restart_syscall;
701
702 /* get previous context */
703 if (copy_from_user(&context, usc, sizeof(context)))
704 goto badframe;
705
706 /* restore passed registers */
707 regs->d0 = context.sc_d0;
708 regs->d1 = context.sc_d1;
709 regs->a0 = context.sc_a0;
710 regs->a1 = context.sc_a1;
711 regs->sr = (regs->sr & 0xff00) | (context.sc_sr & 0xff);
712 regs->pc = context.sc_pc;
713 regs->orig_d0 = -1; /* disable syscall checks */
714 wrusp(context.sc_usp);
715 formatvec = context.sc_formatvec;
716
717 err = restore_fpu_state(&context);
718
719 if (err || mangle_kernel_stack(regs, formatvec, fp))
720 goto badframe;
721
722 return 0;
723
724 badframe:
725 return 1;
726 }
727
728 static inline int
729 rt_restore_ucontext(struct pt_regs *regs, struct switch_stack *sw,
730 struct ucontext __user *uc)
731 {
732 int temp;
733 greg_t __user *gregs = uc->uc_mcontext.gregs;
734 unsigned long usp;
735 int err;
736
737 /* Always make any pending restarted system calls return -EINTR */
738 current_thread_info()->restart_block.fn = do_no_restart_syscall;
739
740 err = __get_user(temp, &uc->uc_mcontext.version);
741 if (temp != MCONTEXT_VERSION)
742 goto badframe;
743 /* restore passed registers */
744 err |= __get_user(regs->d0, &gregs[0]);
745 err |= __get_user(regs->d1, &gregs[1]);
746 err |= __get_user(regs->d2, &gregs[2]);
747 err |= __get_user(regs->d3, &gregs[3]);
748 err |= __get_user(regs->d4, &gregs[4]);
749 err |= __get_user(regs->d5, &gregs[5]);
750 err |= __get_user(sw->d6, &gregs[6]);
751 err |= __get_user(sw->d7, &gregs[7]);
752 err |= __get_user(regs->a0, &gregs[8]);
753 err |= __get_user(regs->a1, &gregs[9]);
754 err |= __get_user(regs->a2, &gregs[10]);
755 err |= __get_user(sw->a3, &gregs[11]);
756 err |= __get_user(sw->a4, &gregs[12]);
757 err |= __get_user(sw->a5, &gregs[13]);
758 err |= __get_user(sw->a6, &gregs[14]);
759 err |= __get_user(usp, &gregs[15]);
760 wrusp(usp);
761 err |= __get_user(regs->pc, &gregs[16]);
762 err |= __get_user(temp, &gregs[17]);
763 regs->sr = (regs->sr & 0xff00) | (temp & 0xff);
764 regs->orig_d0 = -1; /* disable syscall checks */
765 err |= __get_user(temp, &uc->uc_formatvec);
766
767 err |= rt_restore_fpu_state(uc);
768
769 if (err || do_sigaltstack(&uc->uc_stack, NULL, usp) == -EFAULT)
770 goto badframe;
771
772 if (mangle_kernel_stack(regs, temp, &uc->uc_extra))
773 goto badframe;
774
775 return 0;
776
777 badframe:
778 return 1;
779 }
780
781 asmlinkage int do_sigreturn(unsigned long __unused)
782 {
783 struct switch_stack *sw = (struct switch_stack *) &__unused;
784 struct pt_regs *regs = (struct pt_regs *) (sw + 1);
785 unsigned long usp = rdusp();
786 struct sigframe __user *frame = (struct sigframe __user *)(usp - 4);
787 sigset_t set;
788
789 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
790 goto badframe;
791 if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
792 (_NSIG_WORDS > 1 &&
793 __copy_from_user(&set.sig[1], &frame->extramask,
794 sizeof(frame->extramask))))
795 goto badframe;
796
797 set_current_blocked(&set);
798
799 if (restore_sigcontext(regs, &frame->sc, frame + 1))
800 goto badframe;
801 return regs->d0;
802
803 badframe:
804 force_sig(SIGSEGV, current);
805 return 0;
806 }
807
808 asmlinkage int do_rt_sigreturn(unsigned long __unused)
809 {
810 struct switch_stack *sw = (struct switch_stack *) &__unused;
811 struct pt_regs *regs = (struct pt_regs *) (sw + 1);
812 unsigned long usp = rdusp();
813 struct rt_sigframe __user *frame = (struct rt_sigframe __user *)(usp - 4);
814 sigset_t set;
815
816 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
817 goto badframe;
818 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
819 goto badframe;
820
821 set_current_blocked(&set);
822
823 if (rt_restore_ucontext(regs, sw, &frame->uc))
824 goto badframe;
825 return regs->d0;
826
827 badframe:
828 force_sig(SIGSEGV, current);
829 return 0;
830 }
831
832 static void setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
833 unsigned long mask)
834 {
835 sc->sc_mask = mask;
836 sc->sc_usp = rdusp();
837 sc->sc_d0 = regs->d0;
838 sc->sc_d1 = regs->d1;
839 sc->sc_a0 = regs->a0;
840 sc->sc_a1 = regs->a1;
841 sc->sc_sr = regs->sr;
842 sc->sc_pc = regs->pc;
843 sc->sc_formatvec = regs->format << 12 | regs->vector;
844 save_a5_state(sc, regs);
845 save_fpu_state(sc, regs);
846 }
847
848 static inline int rt_setup_ucontext(struct ucontext __user *uc, struct pt_regs *regs)
849 {
850 struct switch_stack *sw = (struct switch_stack *)regs - 1;
851 greg_t __user *gregs = uc->uc_mcontext.gregs;
852 int err = 0;
853
854 err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
855 err |= __put_user(regs->d0, &gregs[0]);
856 err |= __put_user(regs->d1, &gregs[1]);
857 err |= __put_user(regs->d2, &gregs[2]);
858 err |= __put_user(regs->d3, &gregs[3]);
859 err |= __put_user(regs->d4, &gregs[4]);
860 err |= __put_user(regs->d5, &gregs[5]);
861 err |= __put_user(sw->d6, &gregs[6]);
862 err |= __put_user(sw->d7, &gregs[7]);
863 err |= __put_user(regs->a0, &gregs[8]);
864 err |= __put_user(regs->a1, &gregs[9]);
865 err |= __put_user(regs->a2, &gregs[10]);
866 err |= __put_user(sw->a3, &gregs[11]);
867 err |= __put_user(sw->a4, &gregs[12]);
868 err |= __put_user(sw->a5, &gregs[13]);
869 err |= __put_user(sw->a6, &gregs[14]);
870 err |= __put_user(rdusp(), &gregs[15]);
871 err |= __put_user(regs->pc, &gregs[16]);
872 err |= __put_user(regs->sr, &gregs[17]);
873 err |= __put_user((regs->format << 12) | regs->vector, &uc->uc_formatvec);
874 err |= rt_save_fpu_state(uc, regs);
875 return err;
876 }
877
878 static inline void __user *
879 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
880 {
881 unsigned long usp;
882
883 /* Default to using normal stack. */
884 usp = rdusp();
885
886 /* This is the X/Open sanctioned signal stack switching. */
887 if (ka->sa.sa_flags & SA_ONSTACK) {
888 if (!sas_ss_flags(usp))
889 usp = current->sas_ss_sp + current->sas_ss_size;
890 }
891 return (void __user *)((usp - frame_size) & -8UL);
892 }
893
894 static int setup_frame (int sig, struct k_sigaction *ka,
895 sigset_t *set, struct pt_regs *regs)
896 {
897 struct sigframe __user *frame;
898 int fsize = frame_extra_sizes(regs->format);
899 struct sigcontext context;
900 int err = 0;
901
902 if (fsize < 0) {
903 #ifdef DEBUG
904 printk ("setup_frame: Unknown frame format %#x\n",
905 regs->format);
906 #endif
907 goto give_sigsegv;
908 }
909
910 frame = get_sigframe(ka, regs, sizeof(*frame) + fsize);
911
912 if (fsize)
913 err |= copy_to_user (frame + 1, regs + 1, fsize);
914
915 err |= __put_user((current_thread_info()->exec_domain
916 && current_thread_info()->exec_domain->signal_invmap
917 && sig < 32
918 ? current_thread_info()->exec_domain->signal_invmap[sig]
919 : sig),
920 &frame->sig);
921
922 err |= __put_user(regs->vector, &frame->code);
923 err |= __put_user(&frame->sc, &frame->psc);
924
925 if (_NSIG_WORDS > 1)
926 err |= copy_to_user(frame->extramask, &set->sig[1],
927 sizeof(frame->extramask));
928
929 setup_sigcontext(&context, regs, set->sig[0]);
930 err |= copy_to_user (&frame->sc, &context, sizeof(context));
931
932 /* Set up to return from userspace. */
933 #ifdef CONFIG_MMU
934 err |= __put_user(frame->retcode, &frame->pretcode);
935 /* moveq #,d0; trap #0 */
936 err |= __put_user(0x70004e40 + (__NR_sigreturn << 16),
937 (long __user *)(frame->retcode));
938 #else
939 err |= __put_user((void *) ret_from_user_signal, &frame->pretcode);
940 #endif
941
942 if (err)
943 goto give_sigsegv;
944
945 push_cache ((unsigned long) &frame->retcode);
946
947 /*
948 * Set up registers for signal handler. All the state we are about
949 * to destroy is successfully copied to sigframe.
950 */
951 wrusp ((unsigned long) frame);
952 regs->pc = (unsigned long) ka->sa.sa_handler;
953 adjustformat(regs);
954
955 /*
956 * This is subtle; if we build more than one sigframe, all but the
957 * first one will see frame format 0 and have fsize == 0, so we won't
958 * screw stkadj.
959 */
960 if (fsize)
961 regs->stkadj = fsize;
962
963 /* Prepare to skip over the extra stuff in the exception frame. */
964 if (regs->stkadj) {
965 struct pt_regs *tregs =
966 (struct pt_regs *)((ulong)regs + regs->stkadj);
967 #ifdef DEBUG
968 printk("Performing stackadjust=%04x\n", regs->stkadj);
969 #endif
970 /* This must be copied with decreasing addresses to
971 handle overlaps. */
972 tregs->vector = 0;
973 tregs->format = 0;
974 tregs->pc = regs->pc;
975 tregs->sr = regs->sr;
976 }
977 return 0;
978
979 give_sigsegv:
980 force_sigsegv(sig, current);
981 return err;
982 }
983
984 static int setup_rt_frame (int sig, struct k_sigaction *ka, siginfo_t *info,
985 sigset_t *set, struct pt_regs *regs)
986 {
987 struct rt_sigframe __user *frame;
988 int fsize = frame_extra_sizes(regs->format);
989 int err = 0;
990
991 if (fsize < 0) {
992 #ifdef DEBUG
993 printk ("setup_frame: Unknown frame format %#x\n",
994 regs->format);
995 #endif
996 goto give_sigsegv;
997 }
998
999 frame = get_sigframe(ka, regs, sizeof(*frame));
1000
1001 if (fsize)
1002 err |= copy_to_user (&frame->uc.uc_extra, regs + 1, fsize);
1003
1004 err |= __put_user((current_thread_info()->exec_domain
1005 && current_thread_info()->exec_domain->signal_invmap
1006 && sig < 32
1007 ? current_thread_info()->exec_domain->signal_invmap[sig]
1008 : sig),
1009 &frame->sig);
1010 err |= __put_user(&frame->info, &frame->pinfo);
1011 err |= __put_user(&frame->uc, &frame->puc);
1012 err |= copy_siginfo_to_user(&frame->info, info);
1013
1014 /* Create the ucontext. */
1015 err |= __put_user(0, &frame->uc.uc_flags);
1016 err |= __put_user(NULL, &frame->uc.uc_link);
1017 err |= __put_user((void __user *)current->sas_ss_sp,
1018 &frame->uc.uc_stack.ss_sp);
1019 err |= __put_user(sas_ss_flags(rdusp()),
1020 &frame->uc.uc_stack.ss_flags);
1021 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
1022 err |= rt_setup_ucontext(&frame->uc, regs);
1023 err |= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
1024
1025 /* Set up to return from userspace. */
1026 #ifdef CONFIG_MMU
1027 err |= __put_user(frame->retcode, &frame->pretcode);
1028 #ifdef __mcoldfire__
1029 /* movel #__NR_rt_sigreturn,d0; trap #0 */
1030 err |= __put_user(0x203c0000, (long __user *)(frame->retcode + 0));
1031 err |= __put_user(0x00004e40 + (__NR_rt_sigreturn << 16),
1032 (long __user *)(frame->retcode + 4));
1033 #else
1034 /* moveq #,d0; notb d0; trap #0 */
1035 err |= __put_user(0x70004600 + ((__NR_rt_sigreturn ^ 0xff) << 16),
1036 (long __user *)(frame->retcode + 0));
1037 err |= __put_user(0x4e40, (short __user *)(frame->retcode + 4));
1038 #endif
1039 #else
1040 err |= __put_user((void *) ret_from_user_rt_signal, &frame->pretcode);
1041 #endif /* CONFIG_MMU */
1042
1043 if (err)
1044 goto give_sigsegv;
1045
1046 push_cache ((unsigned long) &frame->retcode);
1047
1048 /*
1049 * Set up registers for signal handler. All the state we are about
1050 * to destroy is successfully copied to sigframe.
1051 */
1052 wrusp ((unsigned long) frame);
1053 regs->pc = (unsigned long) ka->sa.sa_handler;
1054 adjustformat(regs);
1055
1056 /*
1057 * This is subtle; if we build more than one sigframe, all but the
1058 * first one will see frame format 0 and have fsize == 0, so we won't
1059 * screw stkadj.
1060 */
1061 if (fsize)
1062 regs->stkadj = fsize;
1063
1064 /* Prepare to skip over the extra stuff in the exception frame. */
1065 if (regs->stkadj) {
1066 struct pt_regs *tregs =
1067 (struct pt_regs *)((ulong)regs + regs->stkadj);
1068 #ifdef DEBUG
1069 printk("Performing stackadjust=%04x\n", regs->stkadj);
1070 #endif
1071 /* This must be copied with decreasing addresses to
1072 handle overlaps. */
1073 tregs->vector = 0;
1074 tregs->format = 0;
1075 tregs->pc = regs->pc;
1076 tregs->sr = regs->sr;
1077 }
1078 return 0;
1079
1080 give_sigsegv:
1081 force_sigsegv(sig, current);
1082 return err;
1083 }
1084
1085 static inline void
1086 handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
1087 {
1088 switch (regs->d0) {
1089 case -ERESTARTNOHAND:
1090 if (!has_handler)
1091 goto do_restart;
1092 regs->d0 = -EINTR;
1093 break;
1094
1095 case -ERESTART_RESTARTBLOCK:
1096 if (!has_handler) {
1097 regs->d0 = __NR_restart_syscall;
1098 regs->pc -= 2;
1099 break;
1100 }
1101 regs->d0 = -EINTR;
1102 break;
1103
1104 case -ERESTARTSYS:
1105 if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
1106 regs->d0 = -EINTR;
1107 break;
1108 }
1109 /* fallthrough */
1110 case -ERESTARTNOINTR:
1111 do_restart:
1112 regs->d0 = regs->orig_d0;
1113 regs->pc -= 2;
1114 break;
1115 }
1116 }
1117
1118 /*
1119 * OK, we're invoking a handler
1120 */
1121 static void
1122 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
1123 struct pt_regs *regs)
1124 {
1125 sigset_t *oldset = sigmask_to_save();
1126 int err;
1127 /* are we from a system call? */
1128 if (regs->orig_d0 >= 0)
1129 /* If so, check system call restarting.. */
1130 handle_restart(regs, ka, 1);
1131
1132 /* set up the stack frame */
1133 if (ka->sa.sa_flags & SA_SIGINFO)
1134 err = setup_rt_frame(sig, ka, info, oldset, regs);
1135 else
1136 err = setup_frame(sig, ka, oldset, regs);
1137
1138 if (err)
1139 return;
1140
1141 signal_delivered(sig, info, ka, regs, 0);
1142
1143 if (test_thread_flag(TIF_DELAYED_TRACE)) {
1144 regs->sr &= ~0x8000;
1145 send_sig(SIGTRAP, current, 1);
1146 }
1147 }
1148
1149 /*
1150 * Note that 'init' is a special process: it doesn't get signals it doesn't
1151 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1152 * mistake.
1153 */
1154 static void do_signal(struct pt_regs *regs)
1155 {
1156 siginfo_t info;
1157 struct k_sigaction ka;
1158 int signr;
1159
1160 current->thread.esp0 = (unsigned long) regs;
1161
1162 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1163 if (signr > 0) {
1164 /* Whee! Actually deliver the signal. */
1165 handle_signal(signr, &ka, &info, regs);
1166 return;
1167 }
1168
1169 /* Did we come from a system call? */
1170 if (regs->orig_d0 >= 0)
1171 /* Restart the system call - no handlers present */
1172 handle_restart(regs, NULL, 0);
1173
1174 /* If there's no signal to deliver, we just restore the saved mask. */
1175 restore_saved_sigmask();
1176 }
1177
1178 void do_notify_resume(struct pt_regs *regs)
1179 {
1180 if (test_thread_flag(TIF_SIGPENDING))
1181 do_signal(regs);
1182
1183 if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME))
1184 tracehook_notify_resume(regs);
1185 }
CRIS linux kernel tree