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