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