e5cc803476a1a9e10d9abf800abe86235a478872
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
;
257 long sys_sigaltstack(const stack_t __user
*uss
, stack_t __user
*uoss
, int r5
,
258 int r6
, int r7
, int r8
, struct pt_regs
*regs
)
260 return do_sigaltstack(uss
, uoss
, regs
->gpr
[1]);
264 long sys_sigaction(int sig
, struct old_sigaction __user
*act
,
265 struct old_sigaction __user
*oact
)
267 struct k_sigaction new_ka
, old_ka
;
276 if (get_old_sigaction(&new_ka
, act
))
280 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
282 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
283 __put_user(to_user_ptr(old_ka
.sa
.sa_handler
),
284 &oact
->sa_handler
) ||
285 __put_user(to_user_ptr(old_ka
.sa
.sa_restorer
),
286 &oact
->sa_restorer
) ||
287 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
288 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
))
296 * When we have signals to deliver, we set up on the
297 * user stack, going down from the original stack pointer:
299 * a sigcontext struct
300 * a gap of __SIGNAL_FRAMESIZE bytes
302 * Each of these things must be a multiple of 16 bytes in size.
306 struct mcontext mctx
; /* all the register values */
308 * Programs using the rs6000/xcoff abi can save up to 19 gp
309 * regs and 18 fp regs below sp before decrementing it.
314 /* We use the mc_pad field for the signal return trampoline. */
318 * When we have rt signals to deliver, we set up on the
319 * user stack, going down from the original stack pointer:
320 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
321 * a gap of __SIGNAL_FRAMESIZE+16 bytes
322 * (the +16 is to get the siginfo and ucontext in the same
323 * positions as in older kernels).
325 * Each of these things must be a multiple of 16 bytes in size.
330 compat_siginfo_t info
;
336 * Programs using the rs6000/xcoff abi can save up to 19 gp
337 * regs and 18 fp regs below sp before decrementing it.
343 * Save the current user registers on the user stack.
344 * We only save the altivec/spe registers if the process has used
345 * altivec/spe instructions at some point.
347 static int save_user_regs(struct pt_regs
*regs
, struct mcontext __user
*frame
,
350 /* Make sure floating point registers are stored in regs */
351 flush_fp_to_thread(current
);
353 /* save general and floating-point registers */
354 if (save_general_regs(regs
, frame
) ||
355 __copy_to_user(&frame
->mc_fregs
, current
->thread
.fpr
,
356 ELF_NFPREG
* sizeof(double)))
359 #ifdef CONFIG_ALTIVEC
360 /* save altivec registers */
361 if (current
->thread
.used_vr
) {
362 flush_altivec_to_thread(current
);
363 if (__copy_to_user(&frame
->mc_vregs
, current
->thread
.vr
,
364 ELF_NVRREG
* sizeof(vector128
)))
366 /* set MSR_VEC in the saved MSR value to indicate that
367 frame->mc_vregs contains valid data */
368 if (__put_user(regs
->msr
| MSR_VEC
, &frame
->mc_gregs
[PT_MSR
]))
371 /* else assert((regs->msr & MSR_VEC) == 0) */
373 /* We always copy to/from vrsave, it's 0 if we don't have or don't
374 * use altivec. Since VSCR only contains 32 bits saved in the least
375 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
376 * most significant bits of that same vector. --BenH
378 if (__put_user(current
->thread
.vrsave
, (u32 __user
*)&frame
->mc_vregs
[32]))
380 #endif /* CONFIG_ALTIVEC */
383 /* save spe registers */
384 if (current
->thread
.used_spe
) {
385 flush_spe_to_thread(current
);
386 if (__copy_to_user(&frame
->mc_vregs
, current
->thread
.evr
,
387 ELF_NEVRREG
* sizeof(u32
)))
389 /* set MSR_SPE in the saved MSR value to indicate that
390 frame->mc_vregs contains valid data */
391 if (__put_user(regs
->msr
| MSR_SPE
, &frame
->mc_gregs
[PT_MSR
]))
394 /* else assert((regs->msr & MSR_SPE) == 0) */
396 /* We always copy to/from spefscr */
397 if (__put_user(current
->thread
.spefscr
, (u32 __user
*)&frame
->mc_vregs
+ ELF_NEVRREG
))
399 #endif /* CONFIG_SPE */
402 /* Set up the sigreturn trampoline: li r0,sigret; sc */
403 if (__put_user(0x38000000UL
+ sigret
, &frame
->tramp
[0])
404 || __put_user(0x44000002UL
, &frame
->tramp
[1]))
406 flush_icache_range((unsigned long) &frame
->tramp
[0],
407 (unsigned long) &frame
->tramp
[2]);
414 * Restore the current user register values from the user stack,
417 static long restore_user_regs(struct pt_regs
*regs
,
418 struct mcontext __user
*sr
, int sig
)
421 unsigned int save_r2
= 0;
425 * restore general registers but not including MSR or SOFTE. Also
426 * take care of keeping r2 (TLS) intact if not a signal
429 save_r2
= (unsigned int)regs
->gpr
[2];
430 err
= restore_general_regs(regs
, sr
);
431 err
|= __get_user(msr
, &sr
->mc_gregs
[PT_MSR
]);
433 regs
->gpr
[2] = (unsigned long) save_r2
;
437 /* if doing signal return, restore the previous little-endian mode */
439 regs
->msr
= (regs
->msr
& ~MSR_LE
) | (msr
& MSR_LE
);
442 * Do this before updating the thread state in
443 * current->thread.fpr/vr/evr. That way, if we get preempted
444 * and another task grabs the FPU/Altivec/SPE, it won't be
445 * tempted to save the current CPU state into the thread_struct
446 * and corrupt what we are writing there.
448 discard_lazy_cpu_state();
450 /* force the process to reload the FP registers from
451 current->thread when it next does FP instructions */
452 regs
->msr
&= ~(MSR_FP
| MSR_FE0
| MSR_FE1
);
453 if (__copy_from_user(current
->thread
.fpr
, &sr
->mc_fregs
,
454 sizeof(sr
->mc_fregs
)))
457 #ifdef CONFIG_ALTIVEC
458 /* force the process to reload the altivec registers from
459 current->thread when it next does altivec instructions */
460 regs
->msr
&= ~MSR_VEC
;
462 /* restore altivec registers from the stack */
463 if (__copy_from_user(current
->thread
.vr
, &sr
->mc_vregs
,
464 sizeof(sr
->mc_vregs
)))
466 } else if (current
->thread
.used_vr
)
467 memset(current
->thread
.vr
, 0, ELF_NVRREG
* sizeof(vector128
));
469 /* Always get VRSAVE back */
470 if (__get_user(current
->thread
.vrsave
, (u32 __user
*)&sr
->mc_vregs
[32]))
472 #endif /* CONFIG_ALTIVEC */
475 /* force the process to reload the spe registers from
476 current->thread when it next does spe instructions */
477 regs
->msr
&= ~MSR_SPE
;
479 /* restore spe registers from the stack */
480 if (__copy_from_user(current
->thread
.evr
, &sr
->mc_vregs
,
481 ELF_NEVRREG
* sizeof(u32
)))
483 } else if (current
->thread
.used_spe
)
484 memset(current
->thread
.evr
, 0, ELF_NEVRREG
* sizeof(u32
));
486 /* Always get SPEFSCR back */
487 if (__get_user(current
->thread
.spefscr
, (u32 __user
*)&sr
->mc_vregs
+ ELF_NEVRREG
))
489 #endif /* CONFIG_SPE */
495 long compat_sys_rt_sigaction(int sig
, const struct sigaction32 __user
*act
,
496 struct sigaction32 __user
*oact
, size_t sigsetsize
)
498 struct k_sigaction new_ka
, old_ka
;
501 /* XXX: Don't preclude handling different sized sigset_t's. */
502 if (sigsetsize
!= sizeof(compat_sigset_t
))
506 compat_uptr_t handler
;
508 ret
= get_user(handler
, &act
->sa_handler
);
509 new_ka
.sa
.sa_handler
= compat_ptr(handler
);
510 ret
|= get_sigset_t(&new_ka
.sa
.sa_mask
, &act
->sa_mask
);
511 ret
|= __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
516 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
518 ret
= put_user(to_user_ptr(old_ka
.sa
.sa_handler
), &oact
->sa_handler
);
519 ret
|= put_sigset_t(&oact
->sa_mask
, &old_ka
.sa
.sa_mask
);
520 ret
|= __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
526 * Note: it is necessary to treat how as an unsigned int, with the
527 * corresponding cast to a signed int to insure that the proper
528 * conversion (sign extension) between the register representation
529 * of a signed int (msr in 32-bit mode) and the register representation
530 * of a signed int (msr in 64-bit mode) is performed.
532 long compat_sys_rt_sigprocmask(u32 how
, compat_sigset_t __user
*set
,
533 compat_sigset_t __user
*oset
, size_t sigsetsize
)
538 mm_segment_t old_fs
= get_fs();
541 if (get_sigset_t(&s
, set
))
546 /* This is valid because of the set_fs() */
547 up
= (sigset_t __user
*) &s
;
548 ret
= sys_rt_sigprocmask((int)how
, set
? up
: NULL
, oset
? up
: NULL
,
554 if (put_sigset_t(oset
, &s
))
560 long compat_sys_rt_sigpending(compat_sigset_t __user
*set
, compat_size_t sigsetsize
)
564 mm_segment_t old_fs
= get_fs();
567 /* The __user pointer cast is valid because of the set_fs() */
568 ret
= sys_rt_sigpending((sigset_t __user
*) &s
, sigsetsize
);
571 if (put_sigset_t(set
, &s
))
578 int copy_siginfo_to_user32(struct compat_siginfo __user
*d
, siginfo_t
*s
)
582 if (!access_ok (VERIFY_WRITE
, d
, sizeof(*d
)))
585 /* If you change siginfo_t structure, please be sure
586 * this code is fixed accordingly.
587 * It should never copy any pad contained in the structure
588 * to avoid security leaks, but must copy the generic
589 * 3 ints plus the relevant union member.
590 * This routine must convert siginfo from 64bit to 32bit as well
593 err
= __put_user(s
->si_signo
, &d
->si_signo
);
594 err
|= __put_user(s
->si_errno
, &d
->si_errno
);
595 err
|= __put_user((short)s
->si_code
, &d
->si_code
);
597 err
|= __copy_to_user(&d
->_sifields
._pad
, &s
->_sifields
._pad
,
599 else switch(s
->si_code
>> 16) {
600 case __SI_CHLD
>> 16:
601 err
|= __put_user(s
->si_pid
, &d
->si_pid
);
602 err
|= __put_user(s
->si_uid
, &d
->si_uid
);
603 err
|= __put_user(s
->si_utime
, &d
->si_utime
);
604 err
|= __put_user(s
->si_stime
, &d
->si_stime
);
605 err
|= __put_user(s
->si_status
, &d
->si_status
);
607 case __SI_FAULT
>> 16:
608 err
|= __put_user((unsigned int)(unsigned long)s
->si_addr
,
611 case __SI_POLL
>> 16:
612 err
|= __put_user(s
->si_band
, &d
->si_band
);
613 err
|= __put_user(s
->si_fd
, &d
->si_fd
);
615 case __SI_TIMER
>> 16:
616 err
|= __put_user(s
->si_tid
, &d
->si_tid
);
617 err
|= __put_user(s
->si_overrun
, &d
->si_overrun
);
618 err
|= __put_user(s
->si_int
, &d
->si_int
);
620 case __SI_RT
>> 16: /* This is not generated by the kernel as of now. */
621 case __SI_MESGQ
>> 16:
622 err
|= __put_user(s
->si_int
, &d
->si_int
);
624 case __SI_KILL
>> 16:
626 err
|= __put_user(s
->si_pid
, &d
->si_pid
);
627 err
|= __put_user(s
->si_uid
, &d
->si_uid
);
633 #define copy_siginfo_to_user copy_siginfo_to_user32
636 * Note: it is necessary to treat pid and sig as unsigned ints, with the
637 * corresponding cast to a signed int to insure that the proper conversion
638 * (sign extension) between the register representation of a signed int
639 * (msr in 32-bit mode) and the register representation of a signed int
640 * (msr in 64-bit mode) is performed.
642 long compat_sys_rt_sigqueueinfo(u32 pid
, u32 sig
, compat_siginfo_t __user
*uinfo
)
646 mm_segment_t old_fs
= get_fs();
648 if (copy_from_user (&info
, uinfo
, 3*sizeof(int)) ||
649 copy_from_user (info
._sifields
._pad
, uinfo
->_sifields
._pad
, SI_PAD_SIZE32
))
652 /* The __user pointer cast is valid becasuse of the set_fs() */
653 ret
= sys_rt_sigqueueinfo((int)pid
, (int)sig
, (siginfo_t __user
*) &info
);
658 * Start Alternate signal stack support
661 * sigaltatck compat_sys_sigaltstack
664 int compat_sys_sigaltstack(u32 __new
, u32 __old
, int r5
,
665 int r6
, int r7
, int r8
, struct pt_regs
*regs
)
667 stack_32_t __user
* newstack
= compat_ptr(__new
);
668 stack_32_t __user
* oldstack
= compat_ptr(__old
);
676 * set sp to the user stack on entry to the system call
677 * the system call router sets R9 to the saved registers
681 /* Put new stack info in local 64 bit stack struct */
683 if (get_user(ss_sp
, &newstack
->ss_sp
) ||
684 __get_user(uss
.ss_flags
, &newstack
->ss_flags
) ||
685 __get_user(uss
.ss_size
, &newstack
->ss_size
))
687 uss
.ss_sp
= compat_ptr(ss_sp
);
692 /* The __user pointer casts are valid because of the set_fs() */
693 ret
= do_sigaltstack(
694 newstack
? (stack_t __user
*) &uss
: NULL
,
695 oldstack
? (stack_t __user
*) &uoss
: NULL
,
698 /* Copy the stack information to the user output buffer */
699 if (!ret
&& oldstack
&&
700 (put_user(ptr_to_compat(uoss
.ss_sp
), &oldstack
->ss_sp
) ||
701 __put_user(uoss
.ss_flags
, &oldstack
->ss_flags
) ||
702 __put_user(uoss
.ss_size
, &oldstack
->ss_size
)))
706 #endif /* CONFIG_PPC64 */
710 * Restore the user process's signal mask
713 extern void restore_sigmask(sigset_t
*set
);
714 #else /* CONFIG_PPC64 */
715 static void restore_sigmask(sigset_t
*set
)
717 sigdelsetmask(set
, ~_BLOCKABLE
);
718 spin_lock_irq(¤t
->sighand
->siglock
);
719 current
->blocked
= *set
;
721 spin_unlock_irq(¤t
->sighand
->siglock
);
726 * Set up a signal frame for a "real-time" signal handler
727 * (one which gets siginfo).
729 static int handle_rt_signal(unsigned long sig
, struct k_sigaction
*ka
,
730 siginfo_t
*info
, sigset_t
*oldset
,
731 struct pt_regs
*regs
, unsigned long newsp
)
733 struct rt_sigframe __user
*rt_sf
;
734 struct mcontext __user
*frame
;
735 unsigned long origsp
= newsp
;
737 /* Set up Signal Frame */
738 /* Put a Real Time Context onto stack */
739 newsp
-= sizeof(*rt_sf
);
740 rt_sf
= (struct rt_sigframe __user
*)newsp
;
742 /* create a stack frame for the caller of the handler */
743 newsp
-= __SIGNAL_FRAMESIZE
+ 16;
745 if (!access_ok(VERIFY_WRITE
, (void __user
*)newsp
, origsp
- newsp
))
748 /* Put the siginfo & fill in most of the ucontext */
749 if (copy_siginfo_to_user(&rt_sf
->info
, info
)
750 || __put_user(0, &rt_sf
->uc
.uc_flags
)
751 || __put_user(0, &rt_sf
->uc
.uc_link
)
752 || __put_user(current
->sas_ss_sp
, &rt_sf
->uc
.uc_stack
.ss_sp
)
753 || __put_user(sas_ss_flags(regs
->gpr
[1]),
754 &rt_sf
->uc
.uc_stack
.ss_flags
)
755 || __put_user(current
->sas_ss_size
, &rt_sf
->uc
.uc_stack
.ss_size
)
756 || __put_user(to_user_ptr(&rt_sf
->uc
.uc_mcontext
),
758 || put_sigset_t(&rt_sf
->uc
.uc_sigmask
, oldset
))
761 /* Save user registers on the stack */
762 frame
= &rt_sf
->uc
.uc_mcontext
;
763 if (vdso32_rt_sigtramp
&& current
->mm
->context
.vdso_base
) {
764 if (save_user_regs(regs
, frame
, 0))
766 regs
->link
= current
->mm
->context
.vdso_base
+ vdso32_rt_sigtramp
;
768 if (save_user_regs(regs
, frame
, __NR_rt_sigreturn
))
770 regs
->link
= (unsigned long) frame
->tramp
;
773 current
->thread
.fpscr
.val
= 0; /* turn off all fp exceptions */
775 if (put_user(regs
->gpr
[1], (u32 __user
*)newsp
))
777 regs
->gpr
[1] = newsp
;
779 regs
->gpr
[4] = (unsigned long) &rt_sf
->info
;
780 regs
->gpr
[5] = (unsigned long) &rt_sf
->uc
;
781 regs
->gpr
[6] = (unsigned long) rt_sf
;
782 regs
->nip
= (unsigned long) ka
->sa
.sa_handler
;
783 /* enter the signal handler in big-endian mode */
784 regs
->msr
&= ~MSR_LE
;
790 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
793 force_sigsegv(sig
, current
);
797 static int do_setcontext(struct ucontext __user
*ucp
, struct pt_regs
*regs
, int sig
)
800 struct mcontext __user
*mcp
;
802 if (get_sigset_t(&set
, &ucp
->uc_sigmask
))
808 if (__get_user(cmcp
, &ucp
->uc_regs
))
810 mcp
= (struct mcontext __user
*)(u64
)cmcp
;
811 /* no need to check access_ok(mcp), since mcp < 4GB */
814 if (__get_user(mcp
, &ucp
->uc_regs
))
816 if (!access_ok(VERIFY_READ
, mcp
, sizeof(*mcp
)))
819 restore_sigmask(&set
);
820 if (restore_user_regs(regs
, mcp
, sig
))
826 long sys_swapcontext(struct ucontext __user
*old_ctx
,
827 struct ucontext __user
*new_ctx
,
828 int ctx_size
, int r6
, int r7
, int r8
, struct pt_regs
*regs
)
832 /* Context size is for future use. Right now, we only make sure
833 * we are passed something we understand
835 if (ctx_size
< sizeof(struct ucontext
))
838 if (old_ctx
!= NULL
) {
839 struct mcontext __user
*mctx
;
842 * old_ctx might not be 16-byte aligned, in which
843 * case old_ctx->uc_mcontext won't be either.
844 * Because we have the old_ctx->uc_pad2 field
845 * before old_ctx->uc_mcontext, we need to round down
846 * from &old_ctx->uc_mcontext to a 16-byte boundary.
848 mctx
= (struct mcontext __user
*)
849 ((unsigned long) &old_ctx
->uc_mcontext
& ~0xfUL
);
850 if (!access_ok(VERIFY_WRITE
, old_ctx
, sizeof(*old_ctx
))
851 || save_user_regs(regs
, mctx
, 0)
852 || put_sigset_t(&old_ctx
->uc_sigmask
, ¤t
->blocked
)
853 || __put_user(to_user_ptr(mctx
), &old_ctx
->uc_regs
))
858 if (!access_ok(VERIFY_READ
, new_ctx
, sizeof(*new_ctx
))
859 || __get_user(tmp
, (u8 __user
*) new_ctx
)
860 || __get_user(tmp
, (u8 __user
*) (new_ctx
+ 1) - 1))
864 * If we get a fault copying the context into the kernel's
865 * image of the user's registers, we can't just return -EFAULT
866 * because the user's registers will be corrupted. For instance
867 * the NIP value may have been updated but not some of the
868 * other registers. Given that we have done the access_ok
869 * and successfully read the first and last bytes of the region
870 * above, this should only happen in an out-of-memory situation
871 * or if another thread unmaps the region containing the context.
872 * We kill the task with a SIGSEGV in this situation.
874 if (do_setcontext(new_ctx
, regs
, 0))
877 set_thread_flag(TIF_RESTOREALL
);
881 long sys_rt_sigreturn(int r3
, int r4
, int r5
, int r6
, int r7
, int r8
,
882 struct pt_regs
*regs
)
884 struct rt_sigframe __user
*rt_sf
;
886 /* Always make any pending restarted system calls return -EINTR */
887 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
889 rt_sf
= (struct rt_sigframe __user
*)
890 (regs
->gpr
[1] + __SIGNAL_FRAMESIZE
+ 16);
891 if (!access_ok(VERIFY_READ
, rt_sf
, sizeof(*rt_sf
)))
893 if (do_setcontext(&rt_sf
->uc
, regs
, 1))
897 * It's not clear whether or why it is desirable to save the
898 * sigaltstack setting on signal delivery and restore it on
899 * signal return. But other architectures do this and we have
900 * always done it up until now so it is probably better not to
901 * change it. -- paulus
905 * We use the compat_sys_ version that does the 32/64 bits conversion
906 * and takes userland pointer directly. What about error checking ?
909 compat_sys_sigaltstack((u32
)(u64
)&rt_sf
->uc
.uc_stack
, 0, 0, 0, 0, 0, regs
);
911 do_sigaltstack(&rt_sf
->uc
.uc_stack
, NULL
, regs
->gpr
[1]);
913 set_thread_flag(TIF_RESTOREALL
);
917 force_sig(SIGSEGV
, current
);
922 int sys_debug_setcontext(struct ucontext __user
*ctx
,
923 int ndbg
, struct sig_dbg_op __user
*dbg
,
924 int r6
, int r7
, int r8
,
925 struct pt_regs
*regs
)
927 struct sig_dbg_op op
;
930 unsigned long new_msr
= regs
->msr
;
931 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
932 unsigned long new_dbcr0
= current
->thread
.dbcr0
;
935 for (i
=0; i
<ndbg
; i
++) {
936 if (copy_from_user(&op
, dbg
+ i
, sizeof(op
)))
938 switch (op
.dbg_type
) {
939 case SIG_DBG_SINGLE_STEPPING
:
940 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
943 new_dbcr0
|= (DBCR0_IDM
| DBCR0_IC
);
946 new_dbcr0
&= ~(DBCR0_IDM
| DBCR0_IC
);
955 case SIG_DBG_BRANCH_TRACING
:
956 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
971 /* We wait until here to actually install the values in the
972 registers so if we fail in the above loop, it will not
973 affect the contents of these registers. After this point,
974 failure is a problem, anyway, and it's very unlikely unless
975 the user is really doing something wrong. */
977 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
978 current
->thread
.dbcr0
= new_dbcr0
;
981 if (!access_ok(VERIFY_READ
, ctx
, sizeof(*ctx
))
982 || __get_user(tmp
, (u8 __user
*) ctx
)
983 || __get_user(tmp
, (u8 __user
*) (ctx
+ 1) - 1))
987 * If we get a fault copying the context into the kernel's
988 * image of the user's registers, we can't just return -EFAULT
989 * because the user's registers will be corrupted. For instance
990 * the NIP value may have been updated but not some of the
991 * other registers. Given that we have done the access_ok
992 * and successfully read the first and last bytes of the region
993 * above, this should only happen in an out-of-memory situation
994 * or if another thread unmaps the region containing the context.
995 * We kill the task with a SIGSEGV in this situation.
997 if (do_setcontext(ctx
, regs
, 1)) {
998 force_sig(SIGSEGV
, current
);
1003 * It's not clear whether or why it is desirable to save the
1004 * sigaltstack setting on signal delivery and restore it on
1005 * signal return. But other architectures do this and we have
1006 * always done it up until now so it is probably better not to
1007 * change it. -- paulus
1009 do_sigaltstack(&ctx
->uc_stack
, NULL
, regs
->gpr
[1]);
1011 set_thread_flag(TIF_RESTOREALL
);
1018 * OK, we're invoking a handler
1020 static int handle_signal(unsigned long sig
, struct k_sigaction
*ka
,
1021 siginfo_t
*info
, sigset_t
*oldset
, struct pt_regs
*regs
,
1022 unsigned long newsp
)
1024 struct sigcontext __user
*sc
;
1025 struct sigregs __user
*frame
;
1026 unsigned long origsp
= newsp
;
1028 /* Set up Signal Frame */
1029 newsp
-= sizeof(struct sigregs
);
1030 frame
= (struct sigregs __user
*) newsp
;
1032 /* Put a sigcontext on the stack */
1033 newsp
-= sizeof(*sc
);
1034 sc
= (struct sigcontext __user
*) newsp
;
1036 /* create a stack frame for the caller of the handler */
1037 newsp
-= __SIGNAL_FRAMESIZE
;
1039 if (!access_ok(VERIFY_WRITE
, (void __user
*) newsp
, origsp
- newsp
))
1043 #error "Please adjust handle_signal()"
1045 if (__put_user(to_user_ptr(ka
->sa
.sa_handler
), &sc
->handler
)
1046 || __put_user(oldset
->sig
[0], &sc
->oldmask
)
1048 || __put_user((oldset
->sig
[0] >> 32), &sc
->_unused
[3])
1050 || __put_user(oldset
->sig
[1], &sc
->_unused
[3])
1052 || __put_user(to_user_ptr(frame
), &sc
->regs
)
1053 || __put_user(sig
, &sc
->signal
))
1056 if (vdso32_sigtramp
&& current
->mm
->context
.vdso_base
) {
1057 if (save_user_regs(regs
, &frame
->mctx
, 0))
1059 regs
->link
= current
->mm
->context
.vdso_base
+ vdso32_sigtramp
;
1061 if (save_user_regs(regs
, &frame
->mctx
, __NR_sigreturn
))
1063 regs
->link
= (unsigned long) frame
->mctx
.tramp
;
1066 current
->thread
.fpscr
.val
= 0; /* turn off all fp exceptions */
1068 if (put_user(regs
->gpr
[1], (u32 __user
*)newsp
))
1070 regs
->gpr
[1] = newsp
;
1072 regs
->gpr
[4] = (unsigned long) sc
;
1073 regs
->nip
= (unsigned long) ka
->sa
.sa_handler
;
1074 /* enter the signal handler in big-endian mode */
1075 regs
->msr
&= ~MSR_LE
;
1082 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1083 regs
, frame
, newsp
);
1085 force_sigsegv(sig
, current
);
1090 * Do a signal return; undo the signal stack.
1092 long sys_sigreturn(int r3
, int r4
, int r5
, int r6
, int r7
, int r8
,
1093 struct pt_regs
*regs
)
1095 struct sigcontext __user
*sc
;
1096 struct sigcontext sigctx
;
1097 struct mcontext __user
*sr
;
1100 /* Always make any pending restarted system calls return -EINTR */
1101 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
1103 sc
= (struct sigcontext __user
*)(regs
->gpr
[1] + __SIGNAL_FRAMESIZE
);
1104 if (copy_from_user(&sigctx
, sc
, sizeof(sigctx
)))
1109 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1110 * unused part of the signal stackframe
1112 set
.sig
[0] = sigctx
.oldmask
+ ((long)(sigctx
._unused
[3]) << 32);
1114 set
.sig
[0] = sigctx
.oldmask
;
1115 set
.sig
[1] = sigctx
._unused
[3];
1117 restore_sigmask(&set
);
1119 sr
= (struct mcontext __user
*)from_user_ptr(sigctx
.regs
);
1120 if (!access_ok(VERIFY_READ
, sr
, sizeof(*sr
))
1121 || restore_user_regs(regs
, sr
, 1))
1124 set_thread_flag(TIF_RESTOREALL
);
1128 force_sig(SIGSEGV
, current
);
1133 * Note that 'init' is a special process: it doesn't get signals it doesn't
1134 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1137 int do_signal(sigset_t
*oldset
, struct pt_regs
*regs
)
1140 struct k_sigaction ka
;
1145 if (try_to_freeze()) {
1147 if (!signal_pending(current
))
1152 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
1153 oldset
= ¤t
->saved_sigmask
;
1155 oldset
= ¤t
->blocked
;
1157 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
1161 /* Is there any syscall restart business here ? */
1162 check_syscall_restart(regs
, &ka
, signr
> 0);
1165 /* No signal to deliver -- put the saved sigmask back */
1166 if (test_thread_flag(TIF_RESTORE_SIGMASK
)) {
1167 clear_thread_flag(TIF_RESTORE_SIGMASK
);
1168 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
1170 return 0; /* no signals delivered */
1173 if ((ka
.sa
.sa_flags
& SA_ONSTACK
) && current
->sas_ss_size
1174 && !on_sig_stack(regs
->gpr
[1]))
1175 newsp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
1177 newsp
= regs
->gpr
[1];
1182 * Reenable the DABR before delivering the signal to
1183 * user space. The DABR will have been cleared if it
1184 * triggered inside the kernel.
1186 if (current
->thread
.dabr
)
1187 set_dabr(current
->thread
.dabr
);
1190 /* Whee! Actually deliver the signal. */
1191 if (ka
.sa
.sa_flags
& SA_SIGINFO
)
1192 ret
= handle_rt_signal(signr
, &ka
, &info
, oldset
, regs
, newsp
);
1194 ret
= handle_signal(signr
, &ka
, &info
, oldset
, regs
, newsp
);
1197 spin_lock_irq(¤t
->sighand
->siglock
);
1198 sigorsets(¤t
->blocked
, ¤t
->blocked
,
1200 if (!(ka
.sa
.sa_flags
& SA_NODEFER
))
1201 sigaddset(¤t
->blocked
, signr
);
1202 recalc_sigpending();
1203 spin_unlock_irq(¤t
->sighand
->siglock
);
1204 /* A signal was successfully delivered; the saved sigmask is in
1205 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
1206 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
1207 clear_thread_flag(TIF_RESTORE_SIGMASK
);
This page took 0.091787 seconds and 4 git commands to generate.