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