6e191ef0aa624fe4333dd03db0b00f97c90b4380
[linux-3.10.git] / arch / sh / kernel / signal_64.c
1 /*
2  * arch/sh/kernel/signal_64.c
3  *
4  * Copyright (C) 2000, 2001  Paolo Alberelli
5  * Copyright (C) 2003 - 2008  Paul Mundt
6  * Copyright (C) 2004  Richard Curnow
7  *
8  * This file is subject to the terms and conditions of the GNU General Public
9  * License.  See the file "COPYING" in the main directory of this archive
10  * for more details.
11  */
12 #include <linux/rwsem.h>
13 #include <linux/sched.h>
14 #include <linux/mm.h>
15 #include <linux/smp.h>
16 #include <linux/kernel.h>
17 #include <linux/signal.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/personality.h>
21 #include <linux/freezer.h>
22 #include <linux/ptrace.h>
23 #include <linux/unistd.h>
24 #include <linux/stddef.h>
25 #include <linux/tracehook.h>
26 #include <asm/ucontext.h>
27 #include <asm/uaccess.h>
28 #include <asm/pgtable.h>
29 #include <asm/cacheflush.h>
30 #include <asm/fpu.h>
31
32 #define REG_RET 9
33 #define REG_ARG1 2
34 #define REG_ARG2 3
35 #define REG_ARG3 4
36 #define REG_SP 15
37 #define REG_PR 18
38 #define REF_REG_RET regs->regs[REG_RET]
39 #define REF_REG_SP regs->regs[REG_SP]
40 #define DEREF_REG_PR regs->regs[REG_PR]
41
42 #define DEBUG_SIG 0
43
44 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
45
46 static int
47 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
48                 sigset_t *oldset, struct pt_regs * regs);
49
50 static inline void
51 handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
52 {
53         /* If we're not from a syscall, bail out */
54         if (regs->syscall_nr < 0)
55                 return;
56
57         /* check for system call restart.. */
58         switch (regs->regs[REG_RET]) {
59                 case -ERESTART_RESTARTBLOCK:
60                 case -ERESTARTNOHAND:
61                 no_system_call_restart:
62                         regs->regs[REG_RET] = -EINTR;
63                         break;
64
65                 case -ERESTARTSYS:
66                         if (!(sa->sa_flags & SA_RESTART))
67                                 goto no_system_call_restart;
68                 /* fallthrough */
69                 case -ERESTARTNOINTR:
70                         /* Decode syscall # */
71                         regs->regs[REG_RET] = regs->syscall_nr;
72                         regs->pc -= 4;
73                         break;
74         }
75 }
76
77 /*
78  * Note that 'init' is a special process: it doesn't get signals it doesn't
79  * want to handle. Thus you cannot kill init even with a SIGKILL even by
80  * mistake.
81  *
82  * Note that we go through the signals twice: once to check the signals that
83  * the kernel can handle, and then we build all the user-level signal handling
84  * stack-frames in one go after that.
85  */
86 static void do_signal(struct pt_regs *regs)
87 {
88         siginfo_t info;
89         int signr;
90         struct k_sigaction ka;
91         sigset_t *oldset;
92
93         /*
94          * We want the common case to go fast, which
95          * is why we may in certain cases get here from
96          * kernel mode. Just return without doing anything
97          * if so.
98          */
99         if (!user_mode(regs))
100                 return;
101
102         if (current_thread_info()->status & TS_RESTORE_SIGMASK)
103                 oldset = &current->saved_sigmask;
104         else
105                 oldset = &current->blocked;
106
107         signr = get_signal_to_deliver(&info, &ka, regs, 0);
108         if (signr > 0) {
109                 handle_syscall_restart(regs, &ka.sa);
110
111                 /* Whee!  Actually deliver the signal.  */
112                 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
113                         /*
114                          * If a signal was successfully delivered, the
115                          * saved sigmask is in its frame, and we can
116                          * clear the TS_RESTORE_SIGMASK flag.
117                          */
118                         current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
119
120                         tracehook_signal_handler(signr, &info, &ka, regs,
121                                         test_thread_flag(TIF_SINGLESTEP));
122                         return;
123                 }
124         }
125
126         /* Did we come from a system call? */
127         if (regs->syscall_nr >= 0) {
128                 /* Restart the system call - no handlers present */
129                 switch (regs->regs[REG_RET]) {
130                 case -ERESTARTNOHAND:
131                 case -ERESTARTSYS:
132                 case -ERESTARTNOINTR:
133                         /* Decode Syscall # */
134                         regs->regs[REG_RET] = regs->syscall_nr;
135                         regs->pc -= 4;
136                         break;
137
138                 case -ERESTART_RESTARTBLOCK:
139                         regs->regs[REG_RET] = __NR_restart_syscall;
140                         regs->pc -= 4;
141                         break;
142                 }
143         }
144
145         /* No signal to deliver -- put the saved sigmask back */
146         restore_saved_sigmask();
147 }
148
149 /*
150  * Atomically swap in the new signal mask, and wait for a signal.
151  */
152 asmlinkage int
153 sys_sigsuspend(old_sigset_t mask)
154 {
155         sigset_t blocked;
156         siginitset(&blocked, mask);
157         return sigsuspend(&blocked);
158 }
159
160 asmlinkage int
161 sys_sigaction(int sig, const struct old_sigaction __user *act,
162               struct old_sigaction __user *oact)
163 {
164         struct k_sigaction new_ka, old_ka;
165         int ret;
166
167         if (act) {
168                 old_sigset_t mask;
169                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
170                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
171                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
172                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
173                     __get_user(mask, &act->sa_mask))
174                         return -EFAULT;
175                 siginitset(&new_ka.sa.sa_mask, mask);
176         }
177
178         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
179
180         if (!ret && oact) {
181                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
182                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
183                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
184                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
185                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
186                         return -EFAULT;
187         }
188
189         return ret;
190 }
191
192 asmlinkage int
193 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
194                 unsigned long r4, unsigned long r5, unsigned long r6,
195                 unsigned long r7,
196                 struct pt_regs * regs)
197 {
198         return do_sigaltstack(uss, uoss, REF_REG_SP);
199 }
200
201 /*
202  * Do a signal return; undo the signal stack.
203  */
204 struct sigframe {
205         struct sigcontext sc;
206         unsigned long extramask[_NSIG_WORDS-1];
207         long long retcode[2];
208 };
209
210 struct rt_sigframe {
211         struct siginfo __user *pinfo;
212         void *puc;
213         struct siginfo info;
214         struct ucontext uc;
215         long long retcode[2];
216 };
217
218 #ifdef CONFIG_SH_FPU
219 static inline int
220 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
221 {
222         int err = 0;
223         int fpvalid;
224
225         err |= __get_user (fpvalid, &sc->sc_fpvalid);
226         conditional_used_math(fpvalid);
227         if (! fpvalid)
228                 return err;
229
230         if (current == last_task_used_math) {
231                 last_task_used_math = NULL;
232                 regs->sr |= SR_FD;
233         }
234
235         err |= __copy_from_user(&current->thread.xstate->hardfpu, &sc->sc_fpregs[0],
236                                 (sizeof(long long) * 32) + (sizeof(int) * 1));
237
238         return err;
239 }
240
241 static inline int
242 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
243 {
244         int err = 0;
245         int fpvalid;
246
247         fpvalid = !!used_math();
248         err |= __put_user(fpvalid, &sc->sc_fpvalid);
249         if (! fpvalid)
250                 return err;
251
252         if (current == last_task_used_math) {
253                 enable_fpu();
254                 save_fpu(current);
255                 disable_fpu();
256                 last_task_used_math = NULL;
257                 regs->sr |= SR_FD;
258         }
259
260         err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.xstate->hardfpu,
261                               (sizeof(long long) * 32) + (sizeof(int) * 1));
262         clear_used_math();
263
264         return err;
265 }
266 #else
267 static inline int
268 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
269 {
270         return 0;
271 }
272 static inline int
273 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
274 {
275         return 0;
276 }
277 #endif
278
279 static int
280 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
281 {
282         unsigned int err = 0;
283         unsigned long long current_sr, new_sr;
284 #define SR_MASK 0xffff8cfd
285
286 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
287
288         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
289         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
290         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
291         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
292         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
293         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
294         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
295         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
296         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
297         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
298         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
299         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
300         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
301         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
302         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
303         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
304         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
305         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
306
307         /* Prevent the signal handler manipulating SR in a way that can
308            crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
309            modified */
310         current_sr = regs->sr;
311         err |= __get_user(new_sr, &sc->sc_sr);
312         regs->sr &= SR_MASK;
313         regs->sr |= (new_sr & ~SR_MASK);
314
315         COPY(pc);
316
317 #undef COPY
318
319         /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
320          * has been restored above.) */
321         err |= restore_sigcontext_fpu(regs, sc);
322
323         regs->syscall_nr = -1;          /* disable syscall checks */
324         err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
325         return err;
326 }
327
328 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
329                                    unsigned long r4, unsigned long r5,
330                                    unsigned long r6, unsigned long r7,
331                                    struct pt_regs * regs)
332 {
333         struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
334         sigset_t set;
335         long long ret;
336
337         /* Always make any pending restarted system calls return -EINTR */
338         current_thread_info()->restart_block.fn = do_no_restart_syscall;
339
340         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
341                 goto badframe;
342
343         if (__get_user(set.sig[0], &frame->sc.oldmask)
344             || (_NSIG_WORDS > 1
345                 && __copy_from_user(&set.sig[1], &frame->extramask,
346                                     sizeof(frame->extramask))))
347                 goto badframe;
348
349         sigdelsetmask(&set, ~_BLOCKABLE);
350         set_current_blocked(&set);
351
352         if (restore_sigcontext(regs, &frame->sc, &ret))
353                 goto badframe;
354         regs->pc -= 4;
355
356         return (int) ret;
357
358 badframe:
359         force_sig(SIGSEGV, current);
360         return 0;
361 }
362
363 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
364                                 unsigned long r4, unsigned long r5,
365                                 unsigned long r6, unsigned long r7,
366                                 struct pt_regs * regs)
367 {
368         struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
369         sigset_t set;
370         stack_t __user st;
371         long long ret;
372
373         /* Always make any pending restarted system calls return -EINTR */
374         current_thread_info()->restart_block.fn = do_no_restart_syscall;
375
376         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
377                 goto badframe;
378
379         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
380                 goto badframe;
381
382         sigdelsetmask(&set, ~_BLOCKABLE);
383         set_current_blocked(&set);
384
385         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
386                 goto badframe;
387         regs->pc -= 4;
388
389         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
390                 goto badframe;
391         /* It is more difficult to avoid calling this function than to
392            call it and ignore errors.  */
393         do_sigaltstack(&st, NULL, REF_REG_SP);
394
395         return (int) ret;
396
397 badframe:
398         force_sig(SIGSEGV, current);
399         return 0;
400 }
401
402 /*
403  * Set up a signal frame.
404  */
405 static int
406 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
407                  unsigned long mask)
408 {
409         int err = 0;
410
411         /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
412         err |= setup_sigcontext_fpu(regs, sc);
413
414 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
415
416         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
417         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
418         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
419         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
420         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
421         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
422         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
423         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
424         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
425         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
426         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
427         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
428         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
429         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
430         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
431         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
432         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
433         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
434         COPY(sr);       COPY(pc);
435
436 #undef COPY
437
438         err |= __put_user(mask, &sc->oldmask);
439
440         return err;
441 }
442
443 /*
444  * Determine which stack to use..
445  */
446 static inline void __user *
447 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
448 {
449         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
450                 sp = current->sas_ss_sp + current->sas_ss_size;
451
452         return (void __user *)((sp - frame_size) & -8ul);
453 }
454
455 void sa_default_restorer(void);         /* See comments below */
456 void sa_default_rt_restorer(void);      /* See comments below */
457
458 static int setup_frame(int sig, struct k_sigaction *ka,
459                        sigset_t *set, struct pt_regs *regs)
460 {
461         struct sigframe __user *frame;
462         int err = 0;
463         int signal;
464
465         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
466
467         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
468                 goto give_sigsegv;
469
470         signal = current_thread_info()->exec_domain
471                 && current_thread_info()->exec_domain->signal_invmap
472                 && sig < 32
473                 ? current_thread_info()->exec_domain->signal_invmap[sig]
474                 : sig;
475
476         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
477
478         /* Give up earlier as i386, in case */
479         if (err)
480                 goto give_sigsegv;
481
482         if (_NSIG_WORDS > 1) {
483                 err |= __copy_to_user(frame->extramask, &set->sig[1],
484                                       sizeof(frame->extramask)); }
485
486         /* Give up earlier as i386, in case */
487         if (err)
488                 goto give_sigsegv;
489
490         /* Set up to return from userspace.  If provided, use a stub
491            already in userspace.  */
492         if (ka->sa.sa_flags & SA_RESTORER) {
493                 /*
494                  * On SH5 all edited pointers are subject to NEFF
495                  */
496                 DEREF_REG_PR = neff_sign_extend((unsigned long)
497                         ka->sa.sa_restorer | 0x1);
498         } else {
499                 /*
500                  * Different approach on SH5.
501                  * . Endianness independent asm code gets placed in entry.S .
502                  *   This is limited to four ASM instructions corresponding
503                  *   to two long longs in size.
504                  * . err checking is done on the else branch only
505                  * . flush_icache_range() is called upon __put_user() only
506                  * . all edited pointers are subject to NEFF
507                  * . being code, linker turns ShMedia bit on, always
508                  *   dereference index -1.
509                  */
510                 DEREF_REG_PR = neff_sign_extend((unsigned long)
511                         frame->retcode | 0x01);
512
513                 if (__copy_to_user(frame->retcode,
514                         (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
515                         goto give_sigsegv;
516
517                 /* Cohere the trampoline with the I-cache. */
518                 flush_cache_sigtramp(DEREF_REG_PR-1);
519         }
520
521         /*
522          * Set up registers for signal handler.
523          * All edited pointers are subject to NEFF.
524          */
525         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
526         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
527
528         /* FIXME:
529            The glibc profiling support for SH-5 needs to be passed a sigcontext
530            so it can retrieve the PC.  At some point during 2003 the glibc
531            support was changed to receive the sigcontext through the 2nd
532            argument, but there are still versions of libc.so in use that use
533            the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
534            through both 2nd and 3rd arguments.
535         */
536
537         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
538         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
539
540         regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
541
542         set_fs(USER_DS);
543
544         /* Broken %016Lx */
545         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
546                  signal, current->comm, current->pid, frame,
547                  regs->pc >> 32, regs->pc & 0xffffffff,
548                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
549
550         return 0;
551
552 give_sigsegv:
553         force_sigsegv(sig, current);
554         return -EFAULT;
555 }
556
557 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
558                           sigset_t *set, struct pt_regs *regs)
559 {
560         struct rt_sigframe __user *frame;
561         int err = 0;
562         int signal;
563
564         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
565
566         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
567                 goto give_sigsegv;
568
569         signal = current_thread_info()->exec_domain
570                 && current_thread_info()->exec_domain->signal_invmap
571                 && sig < 32
572                 ? current_thread_info()->exec_domain->signal_invmap[sig]
573                 : sig;
574
575         err |= __put_user(&frame->info, &frame->pinfo);
576         err |= __put_user(&frame->uc, &frame->puc);
577         err |= copy_siginfo_to_user(&frame->info, info);
578
579         /* Give up earlier as i386, in case */
580         if (err)
581                 goto give_sigsegv;
582
583         /* Create the ucontext.  */
584         err |= __put_user(0, &frame->uc.uc_flags);
585         err |= __put_user(0, &frame->uc.uc_link);
586         err |= __put_user((void *)current->sas_ss_sp,
587                           &frame->uc.uc_stack.ss_sp);
588         err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
589                           &frame->uc.uc_stack.ss_flags);
590         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
591         err |= setup_sigcontext(&frame->uc.uc_mcontext,
592                                 regs, set->sig[0]);
593         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
594
595         /* Give up earlier as i386, in case */
596         if (err)
597                 goto give_sigsegv;
598
599         /* Set up to return from userspace.  If provided, use a stub
600            already in userspace.  */
601         if (ka->sa.sa_flags & SA_RESTORER) {
602                 /*
603                  * On SH5 all edited pointers are subject to NEFF
604                  */
605                 DEREF_REG_PR = neff_sign_extend((unsigned long)
606                         ka->sa.sa_restorer | 0x1);
607         } else {
608                 /*
609                  * Different approach on SH5.
610                  * . Endianness independent asm code gets placed in entry.S .
611                  *   This is limited to four ASM instructions corresponding
612                  *   to two long longs in size.
613                  * . err checking is done on the else branch only
614                  * . flush_icache_range() is called upon __put_user() only
615                  * . all edited pointers are subject to NEFF
616                  * . being code, linker turns ShMedia bit on, always
617                  *   dereference index -1.
618                  */
619                 DEREF_REG_PR = neff_sign_extend((unsigned long)
620                         frame->retcode | 0x01);
621
622                 if (__copy_to_user(frame->retcode,
623                         (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
624                         goto give_sigsegv;
625
626                 /* Cohere the trampoline with the I-cache. */
627                 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
628         }
629
630         /*
631          * Set up registers for signal handler.
632          * All edited pointers are subject to NEFF.
633          */
634         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
635         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
636         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
637         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
638         regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
639
640         set_fs(USER_DS);
641
642         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
643                  signal, current->comm, current->pid, frame,
644                  regs->pc >> 32, regs->pc & 0xffffffff,
645                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
646
647         return 0;
648
649 give_sigsegv:
650         force_sigsegv(sig, current);
651         return -EFAULT;
652 }
653
654 /*
655  * OK, we're invoking a handler
656  */
657 static int
658 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
659                 sigset_t *oldset, struct pt_regs * regs)
660 {
661         int ret;
662
663         /* Set up the stack frame */
664         if (ka->sa.sa_flags & SA_SIGINFO)
665                 ret = setup_rt_frame(sig, ka, info, oldset, regs);
666         else
667                 ret = setup_frame(sig, ka, oldset, regs);
668
669         if (ret == 0)
670                 block_sigmask(ka, sig);
671
672         return ret;
673 }
674
675 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
676 {
677         if (thread_info_flags & _TIF_SIGPENDING)
678                 do_signal(regs);
679
680         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
681                 clear_thread_flag(TIF_NOTIFY_RESUME);
682                 tracehook_notify_resume(regs);
683         }
684 }