aboutsummaryrefslogtreecommitdiffstats
path: root/arch/powerpc/kernel/signal_32.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/powerpc/kernel/signal_32.c')
-rw-r--r--arch/powerpc/kernel/signal_32.c1269
1 files changed, 1269 insertions, 0 deletions
diff --git a/arch/powerpc/kernel/signal_32.c b/arch/powerpc/kernel/signal_32.c
new file mode 100644
index 000000000000..e53127ec373d
--- /dev/null
+++ b/arch/powerpc/kernel/signal_32.c
@@ -0,0 +1,1269 @@
1/*
2 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
3 *
4 * PowerPC version
5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
6 * Copyright (C) 2001 IBM
7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
9 *
10 * Derived from "arch/i386/kernel/signal.c"
11 * Copyright (C) 1991, 1992 Linus Torvalds
12 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version
17 * 2 of the License, or (at your option) any later version.
18 */
19
20#include <linux/config.h>
21#include <linux/sched.h>
22#include <linux/mm.h>
23#include <linux/smp.h>
24#include <linux/smp_lock.h>
25#include <linux/kernel.h>
26#include <linux/signal.h>
27#include <linux/errno.h>
28#include <linux/elf.h>
29#ifdef CONFIG_PPC64
30#include <linux/syscalls.h>
31#include <linux/compat.h>
32#include <linux/ptrace.h>
33#else
34#include <linux/wait.h>
35#include <linux/ptrace.h>
36#include <linux/unistd.h>
37#include <linux/stddef.h>
38#include <linux/tty.h>
39#include <linux/binfmts.h>
40#include <linux/suspend.h>
41#endif
42
43#include <asm/uaccess.h>
44#include <asm/cacheflush.h>
45#ifdef CONFIG_PPC64
46#include <asm/ppc32.h>
47#include <asm/ppcdebug.h>
48#include <asm/unistd.h>
49#include <asm/vdso.h>
50#else
51#include <asm/ucontext.h>
52#include <asm/pgtable.h>
53#endif
54
55#undef DEBUG_SIG
56
57#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
58
59#ifdef CONFIG_PPC64
60#define do_signal do_signal32
61#define sys_sigsuspend sys32_sigsuspend
62#define sys_rt_sigsuspend sys32_rt_sigsuspend
63#define sys_rt_sigreturn sys32_rt_sigreturn
64#define sys_sigaction sys32_sigaction
65#define sys_swapcontext sys32_swapcontext
66#define sys_sigreturn sys32_sigreturn
67
68#define old_sigaction old_sigaction32
69#define sigcontext sigcontext32
70#define mcontext mcontext32
71#define ucontext ucontext32
72
73/*
74 * Returning 0 means we return to userspace via
75 * ret_from_except and thus restore all user
76 * registers from *regs. This is what we need
77 * to do when a signal has been delivered.
78 */
79#define sigreturn_exit(regs) return 0
80
81#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
82#undef __SIGNAL_FRAMESIZE
83#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
84#undef ELF_NVRREG
85#define ELF_NVRREG ELF_NVRREG32
86
87/*
88 * Functions for flipping sigsets (thanks to brain dead generic
89 * implementation that makes things simple for little endian only)
90 */
91static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
92{
93 compat_sigset_t cset;
94
95 switch (_NSIG_WORDS) {
96 case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
97 cset.sig[7] = set->sig[3] >> 32;
98 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
99 cset.sig[5] = set->sig[2] >> 32;
100 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
101 cset.sig[3] = set->sig[1] >> 32;
102 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
103 cset.sig[1] = set->sig[0] >> 32;
104 }
105 return copy_to_user(uset, &cset, sizeof(*uset));
106}
107
108static inline int get_sigset_t(sigset_t *set, compat_sigset_t __user *uset)
109{
110 compat_sigset_t s32;
111
112 if (copy_from_user(&s32, uset, sizeof(*uset)))
113 return -EFAULT;
114
115 /*
116 * Swap the 2 words of the 64-bit sigset_t (they are stored
117 * in the "wrong" endian in 32-bit user storage).
118 */
119 switch (_NSIG_WORDS) {
120 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
121 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
122 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
123 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
124 }
125 return 0;
126}
127
128static inline int get_old_sigaction(struct k_sigaction *new_ka,
129 struct old_sigaction __user *act)
130{
131 compat_old_sigset_t mask;
132 compat_uptr_t handler, restorer;
133
134 if (get_user(handler, &act->sa_handler) ||
135 __get_user(restorer, &act->sa_restorer) ||
136 __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
137 __get_user(mask, &act->sa_mask))
138 return -EFAULT;
139 new_ka->sa.sa_handler = compat_ptr(handler);
140 new_ka->sa.sa_restorer = compat_ptr(restorer);
141 siginitset(&new_ka->sa.sa_mask, mask);
142 return 0;
143}
144
145static inline compat_uptr_t to_user_ptr(void *kp)
146{
147 return (compat_uptr_t)(u64)kp;
148}
149
150#define from_user_ptr(p) compat_ptr(p)
151
152static inline int save_general_regs(struct pt_regs *regs,
153 struct mcontext __user *frame)
154{
155 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
156 int i;
157
158 for (i = 0; i <= PT_RESULT; i ++)
159 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
160 return -EFAULT;
161 return 0;
162}
163
164static inline int restore_general_regs(struct pt_regs *regs,
165 struct mcontext __user *sr)
166{
167 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
168 int i;
169
170 for (i = 0; i <= PT_RESULT; i++) {
171 if ((i == PT_MSR) || (i == PT_SOFTE))
172 continue;
173 if (__get_user(gregs[i], &sr->mc_gregs[i]))
174 return -EFAULT;
175 }
176 return 0;
177}
178
179#else /* CONFIG_PPC64 */
180
181extern void sigreturn_exit(struct pt_regs *);
182
183#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
184
185static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
186{
187 return copy_to_user(uset, set, sizeof(*uset));
188}
189
190static inline int get_sigset_t(sigset_t *set, sigset_t __user *uset)
191{
192 return copy_from_user(set, uset, sizeof(*uset));
193}
194
195static inline int get_old_sigaction(struct k_sigaction *new_ka,
196 struct old_sigaction __user *act)
197{
198 old_sigset_t mask;
199
200 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
201 __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
202 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
203 return -EFAULT;
204 __get_user(new_ka->sa.sa_flags, &act->sa_flags);
205 __get_user(mask, &act->sa_mask);
206 siginitset(&new_ka->sa.sa_mask, mask);
207 return 0;
208}
209
210#define to_user_ptr(p) (p)
211#define from_user_ptr(p) (p)
212
213static inline int save_general_regs(struct pt_regs *regs,
214 struct mcontext __user *frame)
215{
216 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
217}
218
219static inline int restore_general_regs(struct pt_regs *regs,
220 struct mcontext __user *sr)
221{
222 /* copy up to but not including MSR */
223 if (__copy_from_user(regs, &sr->mc_gregs,
224 PT_MSR * sizeof(elf_greg_t)))
225 return -EFAULT;
226 /* copy from orig_r3 (the word after the MSR) up to the end */
227 if (__copy_from_user(&regs->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
228 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
229 return -EFAULT;
230 return 0;
231}
232
233#endif /* CONFIG_PPC64 */
234
235int do_signal(sigset_t *oldset, struct pt_regs *regs);
236
237/*
238 * Atomically swap in the new signal mask, and wait for a signal.
239 */
240long sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,
241 struct pt_regs *regs)
242{
243 sigset_t saveset;
244
245 mask &= _BLOCKABLE;
246 spin_lock_irq(&current->sighand->siglock);
247 saveset = current->blocked;
248 siginitset(&current->blocked, mask);
249 recalc_sigpending();
250 spin_unlock_irq(&current->sighand->siglock);
251
252 regs->result = -EINTR;
253 regs->gpr[3] = EINTR;
254 regs->ccr |= 0x10000000;
255 while (1) {
256 current->state = TASK_INTERRUPTIBLE;
257 schedule();
258 if (do_signal(&saveset, regs))
259 sigreturn_exit(regs);
260 }
261}
262
263long sys_rt_sigsuspend(
264#ifdef CONFIG_PPC64
265 compat_sigset_t __user *unewset,
266#else
267 sigset_t __user *unewset,
268#endif
269 size_t sigsetsize, int p3, int p4,
270 int p6, int p7, struct pt_regs *regs)
271{
272 sigset_t saveset, newset;
273
274 /* XXX: Don't preclude handling different sized sigset_t's. */
275 if (sigsetsize != sizeof(sigset_t))
276 return -EINVAL;
277
278 if (get_sigset_t(&newset, unewset))
279 return -EFAULT;
280 sigdelsetmask(&newset, ~_BLOCKABLE);
281
282 spin_lock_irq(&current->sighand->siglock);
283 saveset = current->blocked;
284 current->blocked = newset;
285 recalc_sigpending();
286 spin_unlock_irq(&current->sighand->siglock);
287
288 regs->result = -EINTR;
289 regs->gpr[3] = EINTR;
290 regs->ccr |= 0x10000000;
291 while (1) {
292 current->state = TASK_INTERRUPTIBLE;
293 schedule();
294 if (do_signal(&saveset, regs))
295 sigreturn_exit(regs);
296 }
297}
298
299#ifdef CONFIG_PPC32
300long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
301 int r6, int r7, int r8, struct pt_regs *regs)
302{
303 return do_sigaltstack(uss, uoss, regs->gpr[1]);
304}
305#endif
306
307long sys_sigaction(int sig, struct old_sigaction __user *act,
308 struct old_sigaction __user *oact)
309{
310 struct k_sigaction new_ka, old_ka;
311 int ret;
312
313#ifdef CONFIG_PPC64
314 if (sig < 0)
315 sig = -sig;
316#endif
317
318 if (act) {
319 if (get_old_sigaction(&new_ka, act))
320 return -EFAULT;
321 }
322
323 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
324 if (!ret && oact) {
325 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
326 __put_user(to_user_ptr(old_ka.sa.sa_handler),
327 &oact->sa_handler) ||
328 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
329 &oact->sa_restorer) ||
330 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
331 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
332 return -EFAULT;
333 }
334
335 return ret;
336}
337
338/*
339 * When we have signals to deliver, we set up on the
340 * user stack, going down from the original stack pointer:
341 * a sigregs struct
342 * a sigcontext struct
343 * a gap of __SIGNAL_FRAMESIZE bytes
344 *
345 * Each of these things must be a multiple of 16 bytes in size.
346 *
347 */
348struct sigregs {
349 struct mcontext mctx; /* all the register values */
350 /*
351 * Programs using the rs6000/xcoff abi can save up to 19 gp
352 * regs and 18 fp regs below sp before decrementing it.
353 */
354 int abigap[56];
355};
356
357/* We use the mc_pad field for the signal return trampoline. */
358#define tramp mc_pad
359
360/*
361 * When we have rt signals to deliver, we set up on the
362 * user stack, going down from the original stack pointer:
363 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
364 * a gap of __SIGNAL_FRAMESIZE+16 bytes
365 * (the +16 is to get the siginfo and ucontext in the same
366 * positions as in older kernels).
367 *
368 * Each of these things must be a multiple of 16 bytes in size.
369 *
370 */
371struct rt_sigframe {
372#ifdef CONFIG_PPC64
373 compat_siginfo_t info;
374#else
375 struct siginfo info;
376#endif
377 struct ucontext uc;
378 /*
379 * Programs using the rs6000/xcoff abi can save up to 19 gp
380 * regs and 18 fp regs below sp before decrementing it.
381 */
382 int abigap[56];
383};
384
385/*
386 * Save the current user registers on the user stack.
387 * We only save the altivec/spe registers if the process has used
388 * altivec/spe instructions at some point.
389 */
390static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
391 int sigret)
392{
393#ifdef CONFIG_PPC32
394 CHECK_FULL_REGS(regs);
395#endif
396 /* Make sure floating point registers are stored in regs */
397 flush_fp_to_thread(current);
398
399 /* save general and floating-point registers */
400 if (save_general_regs(regs, frame) ||
401 __copy_to_user(&frame->mc_fregs, current->thread.fpr,
402 ELF_NFPREG * sizeof(double)))
403 return 1;
404
405 current->thread.fpscr = 0; /* turn off all fp exceptions */
406
407#ifdef CONFIG_ALTIVEC
408 /* save altivec registers */
409 if (current->thread.used_vr) {
410 flush_altivec_to_thread(current);
411 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
412 ELF_NVRREG * sizeof(vector128)))
413 return 1;
414 /* set MSR_VEC in the saved MSR value to indicate that
415 frame->mc_vregs contains valid data */
416 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
417 return 1;
418 }
419 /* else assert((regs->msr & MSR_VEC) == 0) */
420
421 /* We always copy to/from vrsave, it's 0 if we don't have or don't
422 * use altivec. Since VSCR only contains 32 bits saved in the least
423 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
424 * most significant bits of that same vector. --BenH
425 */
426 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
427 return 1;
428#endif /* CONFIG_ALTIVEC */
429
430#ifdef CONFIG_SPE
431 /* save spe registers */
432 if (current->thread.used_spe) {
433 flush_spe_to_thread(current);
434 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
435 ELF_NEVRREG * sizeof(u32)))
436 return 1;
437 /* set MSR_SPE in the saved MSR value to indicate that
438 frame->mc_vregs contains valid data */
439 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
440 return 1;
441 }
442 /* else assert((regs->msr & MSR_SPE) == 0) */
443
444 /* We always copy to/from spefscr */
445 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
446 return 1;
447#endif /* CONFIG_SPE */
448
449 if (sigret) {
450 /* Set up the sigreturn trampoline: li r0,sigret; sc */
451 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
452 || __put_user(0x44000002UL, &frame->tramp[1]))
453 return 1;
454 flush_icache_range((unsigned long) &frame->tramp[0],
455 (unsigned long) &frame->tramp[2]);
456 }
457
458 return 0;
459}
460
461/*
462 * Restore the current user register values from the user stack,
463 * (except for MSR).
464 */
465static long restore_user_regs(struct pt_regs *regs,
466 struct mcontext __user *sr, int sig)
467{
468 long err;
469 unsigned int save_r2 = 0;
470#if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
471 unsigned long msr;
472#endif
473
474 /*
475 * restore general registers but not including MSR or SOFTE. Also
476 * take care of keeping r2 (TLS) intact if not a signal
477 */
478 if (!sig)
479 save_r2 = (unsigned int)regs->gpr[2];
480 err = restore_general_regs(regs, sr);
481 if (!sig)
482 regs->gpr[2] = (unsigned long) save_r2;
483 if (err)
484 return 1;
485
486 /* force the process to reload the FP registers from
487 current->thread when it next does FP instructions */
488 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
489 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
490 sizeof(sr->mc_fregs)))
491 return 1;
492
493#ifdef CONFIG_ALTIVEC
494 /* force the process to reload the altivec registers from
495 current->thread when it next does altivec instructions */
496 regs->msr &= ~MSR_VEC;
497 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
498 /* restore altivec registers from the stack */
499 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
500 sizeof(sr->mc_vregs)))
501 return 1;
502 } else if (current->thread.used_vr)
503 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
504
505 /* Always get VRSAVE back */
506 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
507 return 1;
508#endif /* CONFIG_ALTIVEC */
509
510#ifdef CONFIG_SPE
511 /* force the process to reload the spe registers from
512 current->thread when it next does spe instructions */
513 regs->msr &= ~MSR_SPE;
514 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
515 /* restore spe registers from the stack */
516 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
517 ELF_NEVRREG * sizeof(u32)))
518 return 1;
519 } else if (current->thread.used_spe)
520 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
521
522 /* Always get SPEFSCR back */
523 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
524 return 1;
525#endif /* CONFIG_SPE */
526
527#ifndef CONFIG_SMP
528 preempt_disable();
529 if (last_task_used_math == current)
530 last_task_used_math = NULL;
531 if (last_task_used_altivec == current)
532 last_task_used_altivec = NULL;
533#ifdef CONFIG_SPE
534 if (last_task_used_spe == current)
535 last_task_used_spe = NULL;
536#endif
537 preempt_enable();
538#endif
539 return 0;
540}
541
542#ifdef CONFIG_PPC64
543long sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
544 struct sigaction32 __user *oact, size_t sigsetsize)
545{
546 struct k_sigaction new_ka, old_ka;
547 int ret;
548
549 /* XXX: Don't preclude handling different sized sigset_t's. */
550 if (sigsetsize != sizeof(compat_sigset_t))
551 return -EINVAL;
552
553 if (act) {
554 compat_uptr_t handler;
555
556 ret = get_user(handler, &act->sa_handler);
557 new_ka.sa.sa_handler = compat_ptr(handler);
558 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
559 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
560 if (ret)
561 return -EFAULT;
562 }
563
564 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
565 if (!ret && oact) {
566 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
567 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
568 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
569 }
570 return ret;
571}
572
573/*
574 * Note: it is necessary to treat how as an unsigned int, with the
575 * corresponding cast to a signed int to insure that the proper
576 * conversion (sign extension) between the register representation
577 * of a signed int (msr in 32-bit mode) and the register representation
578 * of a signed int (msr in 64-bit mode) is performed.
579 */
580long sys32_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
581 compat_sigset_t __user *oset, size_t sigsetsize)
582{
583 sigset_t s;
584 sigset_t __user *up;
585 int ret;
586 mm_segment_t old_fs = get_fs();
587
588 if (set) {
589 if (get_sigset_t(&s, set))
590 return -EFAULT;
591 }
592
593 set_fs(KERNEL_DS);
594 /* This is valid because of the set_fs() */
595 up = (sigset_t __user *) &s;
596 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
597 sigsetsize);
598 set_fs(old_fs);
599 if (ret)
600 return ret;
601 if (oset) {
602 if (put_sigset_t(oset, &s))
603 return -EFAULT;
604 }
605 return 0;
606}
607
608long sys32_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
609{
610 sigset_t s;
611 int ret;
612 mm_segment_t old_fs = get_fs();
613
614 set_fs(KERNEL_DS);
615 /* The __user pointer cast is valid because of the set_fs() */
616 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
617 set_fs(old_fs);
618 if (!ret) {
619 if (put_sigset_t(set, &s))
620 return -EFAULT;
621 }
622 return ret;
623}
624
625
626int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
627{
628 int err;
629
630 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
631 return -EFAULT;
632
633 /* If you change siginfo_t structure, please be sure
634 * this code is fixed accordingly.
635 * It should never copy any pad contained in the structure
636 * to avoid security leaks, but must copy the generic
637 * 3 ints plus the relevant union member.
638 * This routine must convert siginfo from 64bit to 32bit as well
639 * at the same time.
640 */
641 err = __put_user(s->si_signo, &d->si_signo);
642 err |= __put_user(s->si_errno, &d->si_errno);
643 err |= __put_user((short)s->si_code, &d->si_code);
644 if (s->si_code < 0)
645 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
646 SI_PAD_SIZE32);
647 else switch(s->si_code >> 16) {
648 case __SI_CHLD >> 16:
649 err |= __put_user(s->si_pid, &d->si_pid);
650 err |= __put_user(s->si_uid, &d->si_uid);
651 err |= __put_user(s->si_utime, &d->si_utime);
652 err |= __put_user(s->si_stime, &d->si_stime);
653 err |= __put_user(s->si_status, &d->si_status);
654 break;
655 case __SI_FAULT >> 16:
656 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
657 &d->si_addr);
658 break;
659 case __SI_POLL >> 16:
660 err |= __put_user(s->si_band, &d->si_band);
661 err |= __put_user(s->si_fd, &d->si_fd);
662 break;
663 case __SI_TIMER >> 16:
664 err |= __put_user(s->si_tid, &d->si_tid);
665 err |= __put_user(s->si_overrun, &d->si_overrun);
666 err |= __put_user(s->si_int, &d->si_int);
667 break;
668 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
669 case __SI_MESGQ >> 16:
670 err |= __put_user(s->si_int, &d->si_int);
671 /* fallthrough */
672 case __SI_KILL >> 16:
673 default:
674 err |= __put_user(s->si_pid, &d->si_pid);
675 err |= __put_user(s->si_uid, &d->si_uid);
676 break;
677 }
678 return err;
679}
680
681#define copy_siginfo_to_user copy_siginfo_to_user32
682
683/*
684 * Note: it is necessary to treat pid and sig as unsigned ints, with the
685 * corresponding cast to a signed int to insure that the proper conversion
686 * (sign extension) between the register representation of a signed int
687 * (msr in 32-bit mode) and the register representation of a signed int
688 * (msr in 64-bit mode) is performed.
689 */
690long sys32_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
691{
692 siginfo_t info;
693 int ret;
694 mm_segment_t old_fs = get_fs();
695
696 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
697 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
698 return -EFAULT;
699 set_fs (KERNEL_DS);
700 /* The __user pointer cast is valid becasuse of the set_fs() */
701 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
702 set_fs (old_fs);
703 return ret;
704}
705/*
706 * Start Alternate signal stack support
707 *
708 * System Calls
709 * sigaltatck sys32_sigaltstack
710 */
711
712int sys32_sigaltstack(u32 __new, u32 __old, int r5,
713 int r6, int r7, int r8, struct pt_regs *regs)
714{
715 stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
716 stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
717 stack_t uss, uoss;
718 int ret;
719 mm_segment_t old_fs;
720 unsigned long sp;
721 compat_uptr_t ss_sp;
722
723 /*
724 * set sp to the user stack on entry to the system call
725 * the system call router sets R9 to the saved registers
726 */
727 sp = regs->gpr[1];
728
729 /* Put new stack info in local 64 bit stack struct */
730 if (newstack) {
731 if (get_user(ss_sp, &newstack->ss_sp) ||
732 __get_user(uss.ss_flags, &newstack->ss_flags) ||
733 __get_user(uss.ss_size, &newstack->ss_size))
734 return -EFAULT;
735 uss.ss_sp = compat_ptr(ss_sp);
736 }
737
738 old_fs = get_fs();
739 set_fs(KERNEL_DS);
740 /* The __user pointer casts are valid because of the set_fs() */
741 ret = do_sigaltstack(
742 newstack ? (stack_t __user *) &uss : NULL,
743 oldstack ? (stack_t __user *) &uoss : NULL,
744 sp);
745 set_fs(old_fs);
746 /* Copy the stack information to the user output buffer */
747 if (!ret && oldstack &&
748 (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
749 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
750 __put_user(uoss.ss_size, &oldstack->ss_size)))
751 return -EFAULT;
752 return ret;
753}
754#endif /* CONFIG_PPC64 */
755
756
757/*
758 * Restore the user process's signal mask
759 */
760#ifdef CONFIG_PPC64
761extern void restore_sigmask(sigset_t *set);
762#else /* CONFIG_PPC64 */
763static void restore_sigmask(sigset_t *set)
764{
765 sigdelsetmask(set, ~_BLOCKABLE);
766 spin_lock_irq(&current->sighand->siglock);
767 current->blocked = *set;
768 recalc_sigpending();
769 spin_unlock_irq(&current->sighand->siglock);
770}
771#endif
772
773/*
774 * Set up a signal frame for a "real-time" signal handler
775 * (one which gets siginfo).
776 */
777static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
778 siginfo_t *info, sigset_t *oldset,
779 struct pt_regs *regs, unsigned long newsp)
780{
781 struct rt_sigframe __user *rt_sf;
782 struct mcontext __user *frame;
783 unsigned long origsp = newsp;
784
785 /* Set up Signal Frame */
786 /* Put a Real Time Context onto stack */
787 newsp -= sizeof(*rt_sf);
788 rt_sf = (struct rt_sigframe __user *)newsp;
789
790 /* create a stack frame for the caller of the handler */
791 newsp -= __SIGNAL_FRAMESIZE + 16;
792
793 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
794 goto badframe;
795
796 /* Put the siginfo & fill in most of the ucontext */
797 if (copy_siginfo_to_user(&rt_sf->info, info)
798 || __put_user(0, &rt_sf->uc.uc_flags)
799 || __put_user(0, &rt_sf->uc.uc_link)
800 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
801 || __put_user(sas_ss_flags(regs->gpr[1]),
802 &rt_sf->uc.uc_stack.ss_flags)
803 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
804 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
805 &rt_sf->uc.uc_regs)
806 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
807 goto badframe;
808
809 /* Save user registers on the stack */
810 frame = &rt_sf->uc.uc_mcontext;
811#ifdef CONFIG_PPC64
812 if (vdso32_rt_sigtramp && current->thread.vdso_base) {
813 if (save_user_regs(regs, frame, 0))
814 goto badframe;
815 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
816 } else
817#endif
818 {
819 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
820 goto badframe;
821 regs->link = (unsigned long) frame->tramp;
822 }
823 if (put_user(regs->gpr[1], (unsigned long __user *)newsp))
824 goto badframe;
825 regs->gpr[1] = newsp;
826 regs->gpr[3] = sig;
827 regs->gpr[4] = (unsigned long) &rt_sf->info;
828 regs->gpr[5] = (unsigned long) &rt_sf->uc;
829 regs->gpr[6] = (unsigned long) rt_sf;
830 regs->nip = (unsigned long) ka->sa.sa_handler;
831 regs->link = (unsigned long) frame->tramp;
832 regs->trap = 0;
833#ifdef CONFIG_PPC64
834 regs->result = 0;
835
836 if (test_thread_flag(TIF_SINGLESTEP))
837 ptrace_notify(SIGTRAP);
838#endif
839 return 1;
840
841badframe:
842#ifdef DEBUG_SIG
843 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
844 regs, frame, newsp);
845#endif
846 force_sigsegv(sig, current);
847 return 0;
848}
849
850static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
851{
852 sigset_t set;
853 struct mcontext __user *mcp;
854
855 if (get_sigset_t(&set, &ucp->uc_sigmask))
856 return -EFAULT;
857#ifdef CONFIG_PPC64
858 {
859 u32 cmcp;
860
861 if (__get_user(cmcp, &ucp->uc_regs))
862 return -EFAULT;
863 mcp = (struct mcontext __user *)(u64)cmcp;
864 }
865#else
866 if (__get_user(mcp, &ucp->uc_regs))
867 return -EFAULT;
868#endif
869 restore_sigmask(&set);
870 if (restore_user_regs(regs, mcp, sig))
871 return -EFAULT;
872
873 return 0;
874}
875
876long sys_swapcontext(struct ucontext __user *old_ctx,
877 struct ucontext __user *new_ctx,
878 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
879{
880 unsigned char tmp;
881
882 /* Context size is for future use. Right now, we only make sure
883 * we are passed something we understand
884 */
885 if (ctx_size < sizeof(struct ucontext))
886 return -EINVAL;
887
888 if (old_ctx != NULL) {
889 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
890 || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
891 || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
892 || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
893 &old_ctx->uc_regs))
894 return -EFAULT;
895 }
896 if (new_ctx == NULL)
897 return 0;
898 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
899 || __get_user(tmp, (u8 __user *) new_ctx)
900 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
901 return -EFAULT;
902
903 /*
904 * If we get a fault copying the context into the kernel's
905 * image of the user's registers, we can't just return -EFAULT
906 * because the user's registers will be corrupted. For instance
907 * the NIP value may have been updated but not some of the
908 * other registers. Given that we have done the access_ok
909 * and successfully read the first and last bytes of the region
910 * above, this should only happen in an out-of-memory situation
911 * or if another thread unmaps the region containing the context.
912 * We kill the task with a SIGSEGV in this situation.
913 */
914 if (do_setcontext(new_ctx, regs, 0))
915 do_exit(SIGSEGV);
916 sigreturn_exit(regs);
917 /* doesn't actually return back to here */
918 return 0;
919}
920
921long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
922 struct pt_regs *regs)
923{
924 struct rt_sigframe __user *rt_sf;
925
926 /* Always make any pending restarted system calls return -EINTR */
927 current_thread_info()->restart_block.fn = do_no_restart_syscall;
928
929 rt_sf = (struct rt_sigframe __user *)
930 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
931 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
932 goto bad;
933 if (do_setcontext(&rt_sf->uc, regs, 1))
934 goto bad;
935
936 /*
937 * It's not clear whether or why it is desirable to save the
938 * sigaltstack setting on signal delivery and restore it on
939 * signal return. But other architectures do this and we have
940 * always done it up until now so it is probably better not to
941 * change it. -- paulus
942 */
943#ifdef CONFIG_PPC64
944 /*
945 * We use the sys32_ version that does the 32/64 bits conversion
946 * and takes userland pointer directly. What about error checking ?
947 * nobody does any...
948 */
949 sys32_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
950 return (int)regs->result;
951#else
952 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
953 sigreturn_exit(regs); /* doesn't return here */
954 return 0;
955#endif
956
957 bad:
958 force_sig(SIGSEGV, current);
959 return 0;
960}
961
962#ifdef CONFIG_PPC32
963int sys_debug_setcontext(struct ucontext __user *ctx,
964 int ndbg, struct sig_dbg_op __user *dbg,
965 int r6, int r7, int r8,
966 struct pt_regs *regs)
967{
968 struct sig_dbg_op op;
969 int i;
970 unsigned long new_msr = regs->msr;
971#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
972 unsigned long new_dbcr0 = current->thread.dbcr0;
973#endif
974
975 for (i=0; i<ndbg; i++) {
976 if (__copy_from_user(&op, dbg, sizeof(op)))
977 return -EFAULT;
978 switch (op.dbg_type) {
979 case SIG_DBG_SINGLE_STEPPING:
980#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
981 if (op.dbg_value) {
982 new_msr |= MSR_DE;
983 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
984 } else {
985 new_msr &= ~MSR_DE;
986 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
987 }
988#else
989 if (op.dbg_value)
990 new_msr |= MSR_SE;
991 else
992 new_msr &= ~MSR_SE;
993#endif
994 break;
995 case SIG_DBG_BRANCH_TRACING:
996#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
997 return -EINVAL;
998#else
999 if (op.dbg_value)
1000 new_msr |= MSR_BE;
1001 else
1002 new_msr &= ~MSR_BE;
1003#endif
1004 break;
1005
1006 default:
1007 return -EINVAL;
1008 }
1009 }
1010
1011 /* We wait until here to actually install the values in the
1012 registers so if we fail in the above loop, it will not
1013 affect the contents of these registers. After this point,
1014 failure is a problem, anyway, and it's very unlikely unless
1015 the user is really doing something wrong. */
1016 regs->msr = new_msr;
1017#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1018 current->thread.dbcr0 = new_dbcr0;
1019#endif
1020
1021 /*
1022 * If we get a fault copying the context into the kernel's
1023 * image of the user's registers, we can't just return -EFAULT
1024 * because the user's registers will be corrupted. For instance
1025 * the NIP value may have been updated but not some of the
1026 * other registers. Given that we have done the access_ok
1027 * and successfully read the first and last bytes of the region
1028 * above, this should only happen in an out-of-memory situation
1029 * or if another thread unmaps the region containing the context.
1030 * We kill the task with a SIGSEGV in this situation.
1031 */
1032 if (do_setcontext(ctx, regs, 1)) {
1033 force_sig(SIGSEGV, current);
1034 goto out;
1035 }
1036
1037 /*
1038 * It's not clear whether or why it is desirable to save the
1039 * sigaltstack setting on signal delivery and restore it on
1040 * signal return. But other architectures do this and we have
1041 * always done it up until now so it is probably better not to
1042 * change it. -- paulus
1043 */
1044 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1045
1046 sigreturn_exit(regs);
1047 /* doesn't actually return back to here */
1048
1049 out:
1050 return 0;
1051}
1052#endif
1053
1054/*
1055 * OK, we're invoking a handler
1056 */
1057static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1058 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1059 unsigned long newsp)
1060{
1061 struct sigcontext __user *sc;
1062 struct sigregs __user *frame;
1063 unsigned long origsp = newsp;
1064
1065 /* Set up Signal Frame */
1066 newsp -= sizeof(struct sigregs);
1067 frame = (struct sigregs __user *) newsp;
1068
1069 /* Put a sigcontext on the stack */
1070 newsp -= sizeof(*sc);
1071 sc = (struct sigcontext __user *) newsp;
1072
1073 /* create a stack frame for the caller of the handler */
1074 newsp -= __SIGNAL_FRAMESIZE;
1075
1076 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1077 goto badframe;
1078
1079#if _NSIG != 64
1080#error "Please adjust handle_signal()"
1081#endif
1082 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1083 || __put_user(oldset->sig[0], &sc->oldmask)
1084#ifdef CONFIG_PPC64
1085 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1086#else
1087 || __put_user(oldset->sig[1], &sc->_unused[3])
1088#endif
1089 || __put_user(to_user_ptr(frame), &sc->regs)
1090 || __put_user(sig, &sc->signal))
1091 goto badframe;
1092
1093#ifdef CONFIG_PPC64
1094 if (vdso32_sigtramp && current->thread.vdso_base) {
1095 if (save_user_regs(regs, &frame->mctx, 0))
1096 goto badframe;
1097 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1098 } else
1099#endif
1100 {
1101 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1102 goto badframe;
1103 regs->link = (unsigned long) frame->mctx.tramp;
1104 }
1105
1106 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1107 goto badframe;
1108 regs->gpr[1] = newsp;
1109 regs->gpr[3] = sig;
1110 regs->gpr[4] = (unsigned long) sc;
1111 regs->nip = (unsigned long) ka->sa.sa_handler;
1112 regs->trap = 0;
1113#ifdef CONFIG_PPC64
1114 regs->result = 0;
1115
1116 if (test_thread_flag(TIF_SINGLESTEP))
1117 ptrace_notify(SIGTRAP);
1118#endif
1119
1120 return 1;
1121
1122badframe:
1123#ifdef DEBUG_SIG
1124 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1125 regs, frame, newsp);
1126#endif
1127 force_sigsegv(sig, current);
1128 return 0;
1129}
1130
1131/*
1132 * Do a signal return; undo the signal stack.
1133 */
1134long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1135 struct pt_regs *regs)
1136{
1137 struct sigcontext __user *sc;
1138 struct sigcontext sigctx;
1139 struct mcontext __user *sr;
1140 sigset_t set;
1141
1142 /* Always make any pending restarted system calls return -EINTR */
1143 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1144
1145 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1146 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1147 goto badframe;
1148
1149#ifdef CONFIG_PPC64
1150 /*
1151 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1152 * unused part of the signal stackframe
1153 */
1154 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1155#else
1156 set.sig[0] = sigctx.oldmask;
1157 set.sig[1] = sigctx._unused[3];
1158#endif
1159 restore_sigmask(&set);
1160
1161 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1162 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1163 || restore_user_regs(regs, sr, 1))
1164 goto badframe;
1165
1166#ifdef CONFIG_PPC64
1167 return (int)regs->result;
1168#else
1169 sigreturn_exit(regs); /* doesn't return */
1170 return 0;
1171#endif
1172
1173badframe:
1174 force_sig(SIGSEGV, current);
1175 return 0;
1176}
1177
1178/*
1179 * Note that 'init' is a special process: it doesn't get signals it doesn't
1180 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1181 * mistake.
1182 */
1183int do_signal(sigset_t *oldset, struct pt_regs *regs)
1184{
1185 siginfo_t info;
1186 struct k_sigaction ka;
1187 unsigned int frame, newsp;
1188 int signr, ret;
1189
1190#ifdef CONFIG_PPC32
1191 if (try_to_freeze()) {
1192 signr = 0;
1193 if (!signal_pending(current))
1194 goto no_signal;
1195 }
1196#endif
1197
1198 if (!oldset)
1199 oldset = &current->blocked;
1200
1201 newsp = frame = 0;
1202
1203 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1204#ifdef CONFIG_PPC32
1205no_signal:
1206#endif
1207 if (TRAP(regs) == 0x0C00 /* System Call! */
1208 && regs->ccr & 0x10000000 /* error signalled */
1209 && ((ret = regs->gpr[3]) == ERESTARTSYS
1210 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1211 || ret == ERESTART_RESTARTBLOCK)) {
1212
1213 if (signr > 0
1214 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1215 || (ret == ERESTARTSYS
1216 && !(ka.sa.sa_flags & SA_RESTART)))) {
1217 /* make the system call return an EINTR error */
1218 regs->result = -EINTR;
1219 regs->gpr[3] = EINTR;
1220 /* note that the cr0.SO bit is already set */
1221 } else {
1222 regs->nip -= 4; /* Back up & retry system call */
1223 regs->result = 0;
1224 regs->trap = 0;
1225 if (ret == ERESTART_RESTARTBLOCK)
1226 regs->gpr[0] = __NR_restart_syscall;
1227 else
1228 regs->gpr[3] = regs->orig_gpr3;
1229 }
1230 }
1231
1232 if (signr == 0)
1233 return 0; /* no signals delivered */
1234
1235 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1236 && !on_sig_stack(regs->gpr[1]))
1237 newsp = current->sas_ss_sp + current->sas_ss_size;
1238 else
1239 newsp = regs->gpr[1];
1240 newsp &= ~0xfUL;
1241
1242#ifdef CONFIG_PPC64
1243 /*
1244 * Reenable the DABR before delivering the signal to
1245 * user space. The DABR will have been cleared if it
1246 * triggered inside the kernel.
1247 */
1248 if (current->thread.dabr)
1249 set_dabr(current->thread.dabr);
1250#endif
1251
1252 /* Whee! Actually deliver the signal. */
1253 if (ka.sa.sa_flags & SA_SIGINFO)
1254 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1255 else
1256 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1257
1258 if (ret) {
1259 spin_lock_irq(&current->sighand->siglock);
1260 sigorsets(&current->blocked, &current->blocked,
1261 &ka.sa.sa_mask);
1262 if (!(ka.sa.sa_flags & SA_NODEFER))
1263 sigaddset(&current->blocked, signr);
1264 recalc_sigpending();
1265 spin_unlock_irq(&current->sighand->siglock);
1266 }
1267
1268 return ret;
1269}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-24 03:51:08 -0500