2 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
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)
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
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.
20 #include <linux/sched.h>
22 #include <linux/smp.h>
23 #include <linux/kernel.h>
24 #include <linux/signal.h>
25 #include <linux/errno.h>
26 #include <linux/elf.h>
28 #include <linux/syscalls.h>
29 #include <linux/compat.h>
30 #include <linux/ptrace.h>
32 #include <linux/wait.h>
33 #include <linux/ptrace.h>
34 #include <linux/unistd.h>
35 #include <linux/stddef.h>
36 #include <linux/tty.h>
37 #include <linux/binfmts.h>
38 #include <linux/freezer.h>
41 #include <asm/uaccess.h>
42 #include <asm/cacheflush.h>
43 #include <asm/syscalls.h>
44 #include <asm/sigcontext.h>
48 #include <asm/unistd.h>
50 #include <asm/ucontext.h>
51 #include <asm/pgtable.h>
58 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
61 #define do_signal do_signal32
62 #define sys_sigsuspend compat_sys_sigsuspend
63 #define sys_rt_sigsuspend compat_sys_rt_sigsuspend
64 #define sys_rt_sigreturn compat_sys_rt_sigreturn
65 #define sys_sigaction compat_sys_sigaction
66 #define sys_swapcontext compat_sys_swapcontext
67 #define sys_sigreturn compat_sys_sigreturn
69 #define old_sigaction old_sigaction32
70 #define sigcontext sigcontext32
71 #define mcontext mcontext32
72 #define ucontext ucontext32
75 * Returning 0 means we return to userspace via
76 * ret_from_except and thus restore all user
77 * registers from *regs. This is what we need
78 * to do when a signal has been delivered.
81 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
82 #undef __SIGNAL_FRAMESIZE
83 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
85 #define ELF_NVRREG ELF_NVRREG32
88 * Functions for flipping sigsets (thanks to brain dead generic
89 * implementation that makes things simple for little endian only)
91 static inline int put_sigset_t(compat_sigset_t __user
*uset
, sigset_t
*set
)
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;
105 return copy_to_user(uset
, &cset
, sizeof(*uset
));
108 static inline int get_sigset_t(sigset_t
*set
,
109 const compat_sigset_t __user
*uset
)
113 if (copy_from_user(&s32
, uset
, sizeof(*uset
)))
117 * Swap the 2 words of the 64-bit sigset_t (they are stored
118 * in the "wrong" endian in 32-bit user storage).
120 switch (_NSIG_WORDS
) {
121 case 4: set
->sig
[3] = s32
.sig
[6] | (((long)s32
.sig
[7]) << 32);
122 case 3: set
->sig
[2] = s32
.sig
[4] | (((long)s32
.sig
[5]) << 32);
123 case 2: set
->sig
[1] = s32
.sig
[2] | (((long)s32
.sig
[3]) << 32);
124 case 1: set
->sig
[0] = s32
.sig
[0] | (((long)s32
.sig
[1]) << 32);
129 static inline int get_old_sigaction(struct k_sigaction
*new_ka
,
130 struct old_sigaction __user
*act
)
132 compat_old_sigset_t mask
;
133 compat_uptr_t handler
, restorer
;
135 if (get_user(handler
, &act
->sa_handler
) ||
136 __get_user(restorer
, &act
->sa_restorer
) ||
137 __get_user(new_ka
->sa
.sa_flags
, &act
->sa_flags
) ||
138 __get_user(mask
, &act
->sa_mask
))
140 new_ka
->sa
.sa_handler
= compat_ptr(handler
);
141 new_ka
->sa
.sa_restorer
= compat_ptr(restorer
);
142 siginitset(&new_ka
->sa
.sa_mask
, mask
);
146 #define to_user_ptr(p) ptr_to_compat(p)
147 #define from_user_ptr(p) compat_ptr(p)
149 static inline int save_general_regs(struct pt_regs
*regs
,
150 struct mcontext __user
*frame
)
152 elf_greg_t64
*gregs
= (elf_greg_t64
*)regs
;
155 WARN_ON(!FULL_REGS(regs
));
157 for (i
= 0; i
<= PT_RESULT
; i
++) {
158 if (i
== 14 && !FULL_REGS(regs
))
160 if (__put_user((unsigned int)gregs
[i
], &frame
->mc_gregs
[i
]))
166 static inline int restore_general_regs(struct pt_regs
*regs
,
167 struct mcontext __user
*sr
)
169 elf_greg_t64
*gregs
= (elf_greg_t64
*)regs
;
172 for (i
= 0; i
<= PT_RESULT
; i
++) {
173 if ((i
== PT_MSR
) || (i
== PT_SOFTE
))
175 if (__get_user(gregs
[i
], &sr
->mc_gregs
[i
]))
181 #else /* CONFIG_PPC64 */
183 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
185 static inline int put_sigset_t(sigset_t __user
*uset
, sigset_t
*set
)
187 return copy_to_user(uset
, set
, sizeof(*uset
));
190 static inline int get_sigset_t(sigset_t
*set
, const sigset_t __user
*uset
)
192 return copy_from_user(set
, uset
, sizeof(*uset
));
195 static inline int get_old_sigaction(struct k_sigaction
*new_ka
,
196 struct old_sigaction __user
*act
)
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
))
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
);
210 #define to_user_ptr(p) ((unsigned long)(p))
211 #define from_user_ptr(p) ((void __user *)(p))
213 static inline int save_general_regs(struct pt_regs
*regs
,
214 struct mcontext __user
*frame
)
216 WARN_ON(!FULL_REGS(regs
));
217 return __copy_to_user(&frame
->mc_gregs
, regs
, GP_REGS_SIZE
);
220 static inline int restore_general_regs(struct pt_regs
*regs
,
221 struct mcontext __user
*sr
)
223 /* copy up to but not including MSR */
224 if (__copy_from_user(regs
, &sr
->mc_gregs
,
225 PT_MSR
* sizeof(elf_greg_t
)))
227 /* copy from orig_r3 (the word after the MSR) up to the end */
228 if (__copy_from_user(®s
->orig_gpr3
, &sr
->mc_gregs
[PT_ORIG_R3
],
229 GP_REGS_SIZE
- PT_ORIG_R3
* sizeof(elf_greg_t
)))
234 #endif /* CONFIG_PPC64 */
236 int do_signal(sigset_t
*oldset
, struct pt_regs
*regs
);
239 * Atomically swap in the new signal mask, and wait for a signal.
241 long sys_sigsuspend(old_sigset_t mask
)
244 spin_lock_irq(¤t
->sighand
->siglock
);
245 current
->saved_sigmask
= current
->blocked
;
246 siginitset(¤t
->blocked
, mask
);
248 spin_unlock_irq(¤t
->sighand
->siglock
);
250 current
->state
= TASK_INTERRUPTIBLE
;
252 set_thread_flag(TIF_RESTORE_SIGMASK
);
253 return -ERESTARTNOHAND
;
256 long sys_sigaction(int sig
, struct old_sigaction __user
*act
,
257 struct old_sigaction __user
*oact
)
259 struct k_sigaction new_ka
, old_ka
;
268 if (get_old_sigaction(&new_ka
, act
))
272 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
274 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
275 __put_user(to_user_ptr(old_ka
.sa
.sa_handler
),
276 &oact
->sa_handler
) ||
277 __put_user(to_user_ptr(old_ka
.sa
.sa_restorer
),
278 &oact
->sa_restorer
) ||
279 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
280 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
))
288 * When we have signals to deliver, we set up on the
289 * user stack, going down from the original stack pointer:
291 * a sigcontext struct
292 * a gap of __SIGNAL_FRAMESIZE bytes
294 * Each of these things must be a multiple of 16 bytes in size.
298 struct mcontext mctx
; /* all the register values */
300 * Programs using the rs6000/xcoff abi can save up to 19 gp
301 * regs and 18 fp regs below sp before decrementing it.
306 /* We use the mc_pad field for the signal return trampoline. */
310 * When we have rt signals to deliver, we set up on the
311 * user stack, going down from the original stack pointer:
312 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
313 * a gap of __SIGNAL_FRAMESIZE+16 bytes
314 * (the +16 is to get the siginfo and ucontext in the same
315 * positions as in older kernels).
317 * Each of these things must be a multiple of 16 bytes in size.
322 compat_siginfo_t info
;
328 * Programs using the rs6000/xcoff abi can save up to 19 gp
329 * regs and 18 fp regs below sp before decrementing it.
335 * Save the current user registers on the user stack.
336 * We only save the altivec/spe registers if the process has used
337 * altivec/spe instructions at some point.
339 static int save_user_regs(struct pt_regs
*regs
, struct mcontext __user
*frame
,
342 /* Make sure floating point registers are stored in regs */
343 flush_fp_to_thread(current
);
345 /* save general and floating-point registers */
346 if (save_general_regs(regs
, frame
) ||
347 __copy_to_user(&frame
->mc_fregs
, current
->thread
.fpr
,
348 ELF_NFPREG
* sizeof(double)))
351 #ifdef CONFIG_ALTIVEC
352 /* save altivec registers */
353 if (current
->thread
.used_vr
) {
354 flush_altivec_to_thread(current
);
355 if (__copy_to_user(&frame
->mc_vregs
, current
->thread
.vr
,
356 ELF_NVRREG
* sizeof(vector128
)))
358 /* set MSR_VEC in the saved MSR value to indicate that
359 frame->mc_vregs contains valid data */
360 if (__put_user(regs
->msr
| MSR_VEC
, &frame
->mc_gregs
[PT_MSR
]))
363 /* else assert((regs->msr & MSR_VEC) == 0) */
365 /* We always copy to/from vrsave, it's 0 if we don't have or don't
366 * use altivec. Since VSCR only contains 32 bits saved in the least
367 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
368 * most significant bits of that same vector. --BenH
370 if (__put_user(current
->thread
.vrsave
, (u32 __user
*)&frame
->mc_vregs
[32]))
372 #endif /* CONFIG_ALTIVEC */
375 /* save spe registers */
376 if (current
->thread
.used_spe
) {
377 flush_spe_to_thread(current
);
378 if (__copy_to_user(&frame
->mc_vregs
, current
->thread
.evr
,
379 ELF_NEVRREG
* sizeof(u32
)))
381 /* set MSR_SPE in the saved MSR value to indicate that
382 frame->mc_vregs contains valid data */
383 if (__put_user(regs
->msr
| MSR_SPE
, &frame
->mc_gregs
[PT_MSR
]))
386 /* else assert((regs->msr & MSR_SPE) == 0) */
388 /* We always copy to/from spefscr */
389 if (__put_user(current
->thread
.spefscr
, (u32 __user
*)&frame
->mc_vregs
+ ELF_NEVRREG
))
391 #endif /* CONFIG_SPE */
394 /* Set up the sigreturn trampoline: li r0,sigret; sc */
395 if (__put_user(0x38000000UL
+ sigret
, &frame
->tramp
[0])
396 || __put_user(0x44000002UL
, &frame
->tramp
[1]))
398 flush_icache_range((unsigned long) &frame
->tramp
[0],
399 (unsigned long) &frame
->tramp
[2]);
406 * Restore the current user register values from the user stack,
409 static long restore_user_regs(struct pt_regs
*regs
,
410 struct mcontext __user
*sr
, int sig
)
413 unsigned int save_r2
= 0;
417 * restore general registers but not including MSR or SOFTE. Also
418 * take care of keeping r2 (TLS) intact if not a signal
421 save_r2
= (unsigned int)regs
->gpr
[2];
422 err
= restore_general_regs(regs
, sr
);
423 err
|= __get_user(msr
, &sr
->mc_gregs
[PT_MSR
]);
425 regs
->gpr
[2] = (unsigned long) save_r2
;
429 /* if doing signal return, restore the previous little-endian mode */
431 regs
->msr
= (regs
->msr
& ~MSR_LE
) | (msr
& MSR_LE
);
434 * Do this before updating the thread state in
435 * current->thread.fpr/vr/evr. That way, if we get preempted
436 * and another task grabs the FPU/Altivec/SPE, it won't be
437 * tempted to save the current CPU state into the thread_struct
438 * and corrupt what we are writing there.
440 discard_lazy_cpu_state();
442 /* force the process to reload the FP registers from
443 current->thread when it next does FP instructions */
444 regs
->msr
&= ~(MSR_FP
| MSR_FE0
| MSR_FE1
);
445 if (__copy_from_user(current
->thread
.fpr
, &sr
->mc_fregs
,
446 sizeof(sr
->mc_fregs
)))
449 #ifdef CONFIG_ALTIVEC
450 /* force the process to reload the altivec registers from
451 current->thread when it next does altivec instructions */
452 regs
->msr
&= ~MSR_VEC
;
454 /* restore altivec registers from the stack */
455 if (__copy_from_user(current
->thread
.vr
, &sr
->mc_vregs
,
456 sizeof(sr
->mc_vregs
)))
458 } else if (current
->thread
.used_vr
)
459 memset(current
->thread
.vr
, 0, ELF_NVRREG
* sizeof(vector128
));
461 /* Always get VRSAVE back */
462 if (__get_user(current
->thread
.vrsave
, (u32 __user
*)&sr
->mc_vregs
[32]))
464 #endif /* CONFIG_ALTIVEC */
467 /* force the process to reload the spe registers from
468 current->thread when it next does spe instructions */
469 regs
->msr
&= ~MSR_SPE
;
471 /* restore spe registers from the stack */
472 if (__copy_from_user(current
->thread
.evr
, &sr
->mc_vregs
,
473 ELF_NEVRREG
* sizeof(u32
)))
475 } else if (current
->thread
.used_spe
)
476 memset(current
->thread
.evr
, 0, ELF_NEVRREG
* sizeof(u32
));
478 /* Always get SPEFSCR back */
479 if (__get_user(current
->thread
.spefscr
, (u32 __user
*)&sr
->mc_vregs
+ ELF_NEVRREG
))
481 #endif /* CONFIG_SPE */
487 long compat_sys_rt_sigaction(int sig
, const struct sigaction32 __user
*act
,
488 struct sigaction32 __user
*oact
, size_t sigsetsize
)
490 struct k_sigaction new_ka
, old_ka
;
493 /* XXX: Don't preclude handling different sized sigset_t's. */
494 if (sigsetsize
!= sizeof(compat_sigset_t
))
498 compat_uptr_t handler
;
500 ret
= get_user(handler
, &act
->sa_handler
);
501 new_ka
.sa
.sa_handler
= compat_ptr(handler
);
502 ret
|= get_sigset_t(&new_ka
.sa
.sa_mask
, &act
->sa_mask
);
503 ret
|= __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
508 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
510 ret
= put_user(to_user_ptr(old_ka
.sa
.sa_handler
), &oact
->sa_handler
);
511 ret
|= put_sigset_t(&oact
->sa_mask
, &old_ka
.sa
.sa_mask
);
512 ret
|= __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
518 * Note: it is necessary to treat how as an unsigned int, with the
519 * corresponding cast to a signed int to insure that the proper
520 * conversion (sign extension) between the register representation
521 * of a signed int (msr in 32-bit mode) and the register representation
522 * of a signed int (msr in 64-bit mode) is performed.
524 long compat_sys_rt_sigprocmask(u32 how
, compat_sigset_t __user
*set
,
525 compat_sigset_t __user
*oset
, size_t sigsetsize
)
530 mm_segment_t old_fs
= get_fs();
533 if (get_sigset_t(&s
, set
))
538 /* This is valid because of the set_fs() */
539 up
= (sigset_t __user
*) &s
;
540 ret
= sys_rt_sigprocmask((int)how
, set
? up
: NULL
, oset
? up
: NULL
,
546 if (put_sigset_t(oset
, &s
))
552 long compat_sys_rt_sigpending(compat_sigset_t __user
*set
, compat_size_t sigsetsize
)
556 mm_segment_t old_fs
= get_fs();
559 /* The __user pointer cast is valid because of the set_fs() */
560 ret
= sys_rt_sigpending((sigset_t __user
*) &s
, sigsetsize
);
563 if (put_sigset_t(set
, &s
))
570 int copy_siginfo_to_user32(struct compat_siginfo __user
*d
, siginfo_t
*s
)
574 if (!access_ok (VERIFY_WRITE
, d
, sizeof(*d
)))
577 /* If you change siginfo_t structure, please be sure
578 * this code is fixed accordingly.
579 * It should never copy any pad contained in the structure
580 * to avoid security leaks, but must copy the generic
581 * 3 ints plus the relevant union member.
582 * This routine must convert siginfo from 64bit to 32bit as well
585 err
= __put_user(s
->si_signo
, &d
->si_signo
);
586 err
|= __put_user(s
->si_errno
, &d
->si_errno
);
587 err
|= __put_user((short)s
->si_code
, &d
->si_code
);
589 err
|= __copy_to_user(&d
->_sifields
._pad
, &s
->_sifields
._pad
,
591 else switch(s
->si_code
>> 16) {
592 case __SI_CHLD
>> 16:
593 err
|= __put_user(s
->si_pid
, &d
->si_pid
);
594 err
|= __put_user(s
->si_uid
, &d
->si_uid
);
595 err
|= __put_user(s
->si_utime
, &d
->si_utime
);
596 err
|= __put_user(s
->si_stime
, &d
->si_stime
);
597 err
|= __put_user(s
->si_status
, &d
->si_status
);
599 case __SI_FAULT
>> 16:
600 err
|= __put_user((unsigned int)(unsigned long)s
->si_addr
,
603 case __SI_POLL
>> 16:
604 err
|= __put_user(s
->si_band
, &d
->si_band
);
605 err
|= __put_user(s
->si_fd
, &d
->si_fd
);
607 case __SI_TIMER
>> 16:
608 err
|= __put_user(s
->si_tid
, &d
->si_tid
);
609 err
|= __put_user(s
->si_overrun
, &d
->si_overrun
);
610 err
|= __put_user(s
->si_int
, &d
->si_int
);
612 case __SI_RT
>> 16: /* This is not generated by the kernel as of now. */
613 case __SI_MESGQ
>> 16:
614 err
|= __put_user(s
->si_int
, &d
->si_int
);
616 case __SI_KILL
>> 16:
618 err
|= __put_user(s
->si_pid
, &d
->si_pid
);
619 err
|= __put_user(s
->si_uid
, &d
->si_uid
);
625 #define copy_siginfo_to_user copy_siginfo_to_user32
628 * Note: it is necessary to treat pid and sig as unsigned ints, with the
629 * corresponding cast to a signed int to insure that the proper conversion
630 * (sign extension) between the register representation of a signed int
631 * (msr in 32-bit mode) and the register representation of a signed int
632 * (msr in 64-bit mode) is performed.
634 long compat_sys_rt_sigqueueinfo(u32 pid
, u32 sig
, compat_siginfo_t __user
*uinfo
)
638 mm_segment_t old_fs
= get_fs();
640 if (copy_from_user (&info
, uinfo
, 3*sizeof(int)) ||
641 copy_from_user (info
._sifields
._pad
, uinfo
->_sifields
._pad
, SI_PAD_SIZE32
))
644 /* The __user pointer cast is valid becasuse of the set_fs() */
645 ret
= sys_rt_sigqueueinfo((int)pid
, (int)sig
, (siginfo_t __user
*) &info
);
650 * Start Alternate signal stack support
653 * sigaltatck compat_sys_sigaltstack
656 int compat_sys_sigaltstack(u32 __new
, u32 __old
, int r5
,
657 int r6
, int r7
, int r8
, struct pt_regs
*regs
)
659 stack_32_t __user
* newstack
= compat_ptr(__new
);
660 stack_32_t __user
* oldstack
= compat_ptr(__old
);
668 * set sp to the user stack on entry to the system call
669 * the system call router sets R9 to the saved registers
673 /* Put new stack info in local 64 bit stack struct */
675 if (get_user(ss_sp
, &newstack
->ss_sp
) ||
676 __get_user(uss
.ss_flags
, &newstack
->ss_flags
) ||
677 __get_user(uss
.ss_size
, &newstack
->ss_size
))
679 uss
.ss_sp
= compat_ptr(ss_sp
);
684 /* The __user pointer casts are valid because of the set_fs() */
685 ret
= do_sigaltstack(
686 newstack
? (stack_t __user
*) &uss
: NULL
,
687 oldstack
? (stack_t __user
*) &uoss
: NULL
,
690 /* Copy the stack information to the user output buffer */
691 if (!ret
&& oldstack
&&
692 (put_user(ptr_to_compat(uoss
.ss_sp
), &oldstack
->ss_sp
) ||
693 __put_user(uoss
.ss_flags
, &oldstack
->ss_flags
) ||
694 __put_user(uoss
.ss_size
, &oldstack
->ss_size
)))
698 #endif /* CONFIG_PPC64 */
702 * Restore the user process's signal mask
705 extern void restore_sigmask(sigset_t
*set
);
706 #else /* CONFIG_PPC64 */
707 static void restore_sigmask(sigset_t
*set
)
709 sigdelsetmask(set
, ~_BLOCKABLE
);
710 spin_lock_irq(¤t
->sighand
->siglock
);
711 current
->blocked
= *set
;
713 spin_unlock_irq(¤t
->sighand
->siglock
);
718 * Set up a signal frame for a "real-time" signal handler
719 * (one which gets siginfo).
721 static int handle_rt_signal(unsigned long sig
, struct k_sigaction
*ka
,
722 siginfo_t
*info
, sigset_t
*oldset
,
723 struct pt_regs
*regs
, unsigned long newsp
)
725 struct rt_sigframe __user
*rt_sf
;
726 struct mcontext __user
*frame
;
727 unsigned long origsp
= newsp
;
729 /* Set up Signal Frame */
730 /* Put a Real Time Context onto stack */
731 newsp
-= sizeof(*rt_sf
);
732 rt_sf
= (struct rt_sigframe __user
*)newsp
;
734 /* create a stack frame for the caller of the handler */
735 newsp
-= __SIGNAL_FRAMESIZE
+ 16;
737 if (!access_ok(VERIFY_WRITE
, (void __user
*)newsp
, origsp
- newsp
))
740 /* Put the siginfo & fill in most of the ucontext */
741 if (copy_siginfo_to_user(&rt_sf
->info
, info
)
742 || __put_user(0, &rt_sf
->uc
.uc_flags
)
743 || __put_user(0, &rt_sf
->uc
.uc_link
)
744 || __put_user(current
->sas_ss_sp
, &rt_sf
->uc
.uc_stack
.ss_sp
)
745 || __put_user(sas_ss_flags(regs
->gpr
[1]),
746 &rt_sf
->uc
.uc_stack
.ss_flags
)
747 || __put_user(current
->sas_ss_size
, &rt_sf
->uc
.uc_stack
.ss_size
)
748 || __put_user(to_user_ptr(&rt_sf
->uc
.uc_mcontext
),
750 || put_sigset_t(&rt_sf
->uc
.uc_sigmask
, oldset
))
753 /* Save user registers on the stack */
754 frame
= &rt_sf
->uc
.uc_mcontext
;
755 if (vdso32_rt_sigtramp
&& current
->mm
->context
.vdso_base
) {
756 if (save_user_regs(regs
, frame
, 0))
758 regs
->link
= current
->mm
->context
.vdso_base
+ vdso32_rt_sigtramp
;
760 if (save_user_regs(regs
, frame
, __NR_rt_sigreturn
))
762 regs
->link
= (unsigned long) frame
->tramp
;
765 current
->thread
.fpscr
.val
= 0; /* turn off all fp exceptions */
767 if (put_user(regs
->gpr
[1], (u32 __user
*)newsp
))
769 regs
->gpr
[1] = newsp
;
771 regs
->gpr
[4] = (unsigned long) &rt_sf
->info
;
772 regs
->gpr
[5] = (unsigned long) &rt_sf
->uc
;
773 regs
->gpr
[6] = (unsigned long) rt_sf
;
774 regs
->nip
= (unsigned long) ka
->sa
.sa_handler
;
775 /* enter the signal handler in big-endian mode */
776 regs
->msr
&= ~MSR_LE
;
782 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
785 force_sigsegv(sig
, current
);
789 static int do_setcontext(struct ucontext __user
*ucp
, struct pt_regs
*regs
, int sig
)
792 struct mcontext __user
*mcp
;
794 if (get_sigset_t(&set
, &ucp
->uc_sigmask
))
800 if (__get_user(cmcp
, &ucp
->uc_regs
))
802 mcp
= (struct mcontext __user
*)(u64
)cmcp
;
803 /* no need to check access_ok(mcp), since mcp < 4GB */
806 if (__get_user(mcp
, &ucp
->uc_regs
))
808 if (!access_ok(VERIFY_READ
, mcp
, sizeof(*mcp
)))
811 restore_sigmask(&set
);
812 if (restore_user_regs(regs
, mcp
, sig
))
818 long sys_swapcontext(struct ucontext __user
*old_ctx
,
819 struct ucontext __user
*new_ctx
,
820 int ctx_size
, int r6
, int r7
, int r8
, struct pt_regs
*regs
)
824 /* Context size is for future use. Right now, we only make sure
825 * we are passed something we understand
827 if (ctx_size
< sizeof(struct ucontext
))
830 if (old_ctx
!= NULL
) {
831 struct mcontext __user
*mctx
;
834 * old_ctx might not be 16-byte aligned, in which
835 * case old_ctx->uc_mcontext won't be either.
836 * Because we have the old_ctx->uc_pad2 field
837 * before old_ctx->uc_mcontext, we need to round down
838 * from &old_ctx->uc_mcontext to a 16-byte boundary.
840 mctx
= (struct mcontext __user
*)
841 ((unsigned long) &old_ctx
->uc_mcontext
& ~0xfUL
);
842 if (!access_ok(VERIFY_WRITE
, old_ctx
, sizeof(*old_ctx
))
843 || save_user_regs(regs
, mctx
, 0)
844 || put_sigset_t(&old_ctx
->uc_sigmask
, ¤t
->blocked
)
845 || __put_user(to_user_ptr(mctx
), &old_ctx
->uc_regs
))
850 if (!access_ok(VERIFY_READ
, new_ctx
, sizeof(*new_ctx
))
851 || __get_user(tmp
, (u8 __user
*) new_ctx
)
852 || __get_user(tmp
, (u8 __user
*) (new_ctx
+ 1) - 1))
856 * If we get a fault copying the context into the kernel's
857 * image of the user's registers, we can't just return -EFAULT
858 * because the user's registers will be corrupted. For instance
859 * the NIP value may have been updated but not some of the
860 * other registers. Given that we have done the access_ok
861 * and successfully read the first and last bytes of the region
862 * above, this should only happen in an out-of-memory situation
863 * or if another thread unmaps the region containing the context.
864 * We kill the task with a SIGSEGV in this situation.
866 if (do_setcontext(new_ctx
, regs
, 0))
869 set_thread_flag(TIF_RESTOREALL
);
873 long sys_rt_sigreturn(int r3
, int r4
, int r5
, int r6
, int r7
, int r8
,
874 struct pt_regs
*regs
)
876 struct rt_sigframe __user
*rt_sf
;
878 /* Always make any pending restarted system calls return -EINTR */
879 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
881 rt_sf
= (struct rt_sigframe __user
*)
882 (regs
->gpr
[1] + __SIGNAL_FRAMESIZE
+ 16);
883 if (!access_ok(VERIFY_READ
, rt_sf
, sizeof(*rt_sf
)))
885 if (do_setcontext(&rt_sf
->uc
, regs
, 1))
889 * It's not clear whether or why it is desirable to save the
890 * sigaltstack setting on signal delivery and restore it on
891 * signal return. But other architectures do this and we have
892 * always done it up until now so it is probably better not to
893 * change it. -- paulus
897 * We use the compat_sys_ version that does the 32/64 bits conversion
898 * and takes userland pointer directly. What about error checking ?
901 compat_sys_sigaltstack((u32
)(u64
)&rt_sf
->uc
.uc_stack
, 0, 0, 0, 0, 0, regs
);
903 do_sigaltstack(&rt_sf
->uc
.uc_stack
, NULL
, regs
->gpr
[1]);
905 set_thread_flag(TIF_RESTOREALL
);
909 force_sig(SIGSEGV
, current
);
914 int sys_debug_setcontext(struct ucontext __user
*ctx
,
915 int ndbg
, struct sig_dbg_op __user
*dbg
,
916 int r6
, int r7
, int r8
,
917 struct pt_regs
*regs
)
919 struct sig_dbg_op op
;
922 unsigned long new_msr
= regs
->msr
;
923 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
924 unsigned long new_dbcr0
= current
->thread
.dbcr0
;
927 for (i
=0; i
<ndbg
; i
++) {
928 if (copy_from_user(&op
, dbg
+ i
, sizeof(op
)))
930 switch (op
.dbg_type
) {
931 case SIG_DBG_SINGLE_STEPPING
:
932 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
935 new_dbcr0
|= (DBCR0_IDM
| DBCR0_IC
);
938 new_dbcr0
&= ~(DBCR0_IDM
| DBCR0_IC
);
947 case SIG_DBG_BRANCH_TRACING
:
948 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
963 /* We wait until here to actually install the values in the
964 registers so if we fail in the above loop, it will not
965 affect the contents of these registers. After this point,
966 failure is a problem, anyway, and it's very unlikely unless
967 the user is really doing something wrong. */
969 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
970 current
->thread
.dbcr0
= new_dbcr0
;
973 if (!access_ok(VERIFY_READ
, ctx
, sizeof(*ctx
))
974 || __get_user(tmp
, (u8 __user
*) ctx
)
975 || __get_user(tmp
, (u8 __user
*) (ctx
+ 1) - 1))
979 * If we get a fault copying the context into the kernel's
980 * image of the user's registers, we can't just return -EFAULT
981 * because the user's registers will be corrupted. For instance
982 * the NIP value may have been updated but not some of the
983 * other registers. Given that we have done the access_ok
984 * and successfully read the first and last bytes of the region
985 * above, this should only happen in an out-of-memory situation
986 * or if another thread unmaps the region containing the context.
987 * We kill the task with a SIGSEGV in this situation.
989 if (do_setcontext(ctx
, regs
, 1)) {
990 force_sig(SIGSEGV
, current
);
995 * It's not clear whether or why it is desirable to save the
996 * sigaltstack setting on signal delivery and restore it on
997 * signal return. But other architectures do this and we have
998 * always done it up until now so it is probably better not to
999 * change it. -- paulus
1001 do_sigaltstack(&ctx
->uc_stack
, NULL
, regs
->gpr
[1]);
1003 set_thread_flag(TIF_RESTOREALL
);
1010 * OK, we're invoking a handler
1012 static int handle_signal(unsigned long sig
, struct k_sigaction
*ka
,
1013 siginfo_t
*info
, sigset_t
*oldset
, struct pt_regs
*regs
,
1014 unsigned long newsp
)
1016 struct sigcontext __user
*sc
;
1017 struct sigregs __user
*frame
;
1018 unsigned long origsp
= newsp
;
1020 /* Set up Signal Frame */
1021 newsp
-= sizeof(struct sigregs
);
1022 frame
= (struct sigregs __user
*) newsp
;
1024 /* Put a sigcontext on the stack */
1025 newsp
-= sizeof(*sc
);
1026 sc
= (struct sigcontext __user
*) newsp
;
1028 /* create a stack frame for the caller of the handler */
1029 newsp
-= __SIGNAL_FRAMESIZE
;
1031 if (!access_ok(VERIFY_WRITE
, (void __user
*) newsp
, origsp
- newsp
))
1035 #error "Please adjust handle_signal()"
1037 if (__put_user(to_user_ptr(ka
->sa
.sa_handler
), &sc
->handler
)
1038 || __put_user(oldset
->sig
[0], &sc
->oldmask
)
1040 || __put_user((oldset
->sig
[0] >> 32), &sc
->_unused
[3])
1042 || __put_user(oldset
->sig
[1], &sc
->_unused
[3])
1044 || __put_user(to_user_ptr(frame
), &sc
->regs
)
1045 || __put_user(sig
, &sc
->signal
))
1048 if (vdso32_sigtramp
&& current
->mm
->context
.vdso_base
) {
1049 if (save_user_regs(regs
, &frame
->mctx
, 0))
1051 regs
->link
= current
->mm
->context
.vdso_base
+ vdso32_sigtramp
;
1053 if (save_user_regs(regs
, &frame
->mctx
, __NR_sigreturn
))
1055 regs
->link
= (unsigned long) frame
->mctx
.tramp
;
1058 current
->thread
.fpscr
.val
= 0; /* turn off all fp exceptions */
1060 if (put_user(regs
->gpr
[1], (u32 __user
*)newsp
))
1062 regs
->gpr
[1] = newsp
;
1064 regs
->gpr
[4] = (unsigned long) sc
;
1065 regs
->nip
= (unsigned long) ka
->sa
.sa_handler
;
1066 /* enter the signal handler in big-endian mode */
1067 regs
->msr
&= ~MSR_LE
;
1074 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1075 regs
, frame
, newsp
);
1077 force_sigsegv(sig
, current
);
1082 * Do a signal return; undo the signal stack.
1084 long sys_sigreturn(int r3
, int r4
, int r5
, int r6
, int r7
, int r8
,
1085 struct pt_regs
*regs
)
1087 struct sigcontext __user
*sc
;
1088 struct sigcontext sigctx
;
1089 struct mcontext __user
*sr
;
1092 /* Always make any pending restarted system calls return -EINTR */
1093 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
1095 sc
= (struct sigcontext __user
*)(regs
->gpr
[1] + __SIGNAL_FRAMESIZE
);
1096 if (copy_from_user(&sigctx
, sc
, sizeof(sigctx
)))
1101 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1102 * unused part of the signal stackframe
1104 set
.sig
[0] = sigctx
.oldmask
+ ((long)(sigctx
._unused
[3]) << 32);
1106 set
.sig
[0] = sigctx
.oldmask
;
1107 set
.sig
[1] = sigctx
._unused
[3];
1109 restore_sigmask(&set
);
1111 sr
= (struct mcontext __user
*)from_user_ptr(sigctx
.regs
);
1112 if (!access_ok(VERIFY_READ
, sr
, sizeof(*sr
))
1113 || restore_user_regs(regs
, sr
, 1))
1116 set_thread_flag(TIF_RESTOREALL
);
1120 force_sig(SIGSEGV
, current
);
1125 * Note that 'init' is a special process: it doesn't get signals it doesn't
1126 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1129 int do_signal(sigset_t
*oldset
, struct pt_regs
*regs
)
1132 struct k_sigaction ka
;
1137 if (try_to_freeze()) {
1139 if (!signal_pending(current
))
1144 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
1145 oldset
= ¤t
->saved_sigmask
;
1147 oldset
= ¤t
->blocked
;
1149 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
1153 /* Is there any syscall restart business here ? */
1154 check_syscall_restart(regs
, &ka
, signr
> 0);
1157 /* No signal to deliver -- put the saved sigmask back */
1158 if (test_thread_flag(TIF_RESTORE_SIGMASK
)) {
1159 clear_thread_flag(TIF_RESTORE_SIGMASK
);
1160 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
1162 return 0; /* no signals delivered */
1165 if ((ka
.sa
.sa_flags
& SA_ONSTACK
) && current
->sas_ss_size
1166 && !on_sig_stack(regs
->gpr
[1]))
1167 newsp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
1169 newsp
= regs
->gpr
[1];
1174 * Reenable the DABR before delivering the signal to
1175 * user space. The DABR will have been cleared if it
1176 * triggered inside the kernel.
1178 if (current
->thread
.dabr
)
1179 set_dabr(current
->thread
.dabr
);
1182 /* Whee! Actually deliver the signal. */
1183 if (ka
.sa
.sa_flags
& SA_SIGINFO
)
1184 ret
= handle_rt_signal(signr
, &ka
, &info
, oldset
, regs
, newsp
);
1186 ret
= handle_signal(signr
, &ka
, &info
, oldset
, regs
, newsp
);
1189 spin_lock_irq(¤t
->sighand
->siglock
);
1190 sigorsets(¤t
->blocked
, ¤t
->blocked
,
1192 if (!(ka
.sa
.sa_flags
& SA_NODEFER
))
1193 sigaddset(¤t
->blocked
, signr
);
1194 recalc_sigpending();
1195 spin_unlock_irq(¤t
->sighand
->siglock
);
1196 /* A signal was successfully delivered; the saved sigmask is in
1197 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
1198 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
1199 clear_thread_flag(TIF_RESTORE_SIGMASK
);
This page took 0.084865 seconds and 5 git commands to generate.