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