Merge branch 'gart/rename' of git://git.kernel.org/pub/scm/linux/kernel/git/joro...
[linux-2.6.git] / arch / arm / kernel / signal.c
1 /*
2  *  linux/arch/arm/kernel/signal.c
3  *
4  *  Copyright (C) 1995-2009 Russell King
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10 #include <linux/errno.h>
11 #include <linux/signal.h>
12 #include <linux/personality.h>
13 #include <linux/freezer.h>
14 #include <linux/uaccess.h>
15 #include <linux/tracehook.h>
16
17 #include <asm/elf.h>
18 #include <asm/cacheflush.h>
19 #include <asm/ucontext.h>
20 #include <asm/unistd.h>
21 #include <asm/vfp.h>
22
23 #include "signal.h"
24
25 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
26
27 /*
28  * For ARM syscalls, we encode the syscall number into the instruction.
29  */
30 #define SWI_SYS_SIGRETURN       (0xef000000|(__NR_sigreturn)|(__NR_OABI_SYSCALL_BASE))
31 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(__NR_rt_sigreturn)|(__NR_OABI_SYSCALL_BASE))
32 #define SWI_SYS_RESTART         (0xef000000|__NR_restart_syscall|__NR_OABI_SYSCALL_BASE)
33
34 /*
35  * With EABI, the syscall number has to be loaded into r7.
36  */
37 #define MOV_R7_NR_SIGRETURN     (0xe3a07000 | (__NR_sigreturn - __NR_SYSCALL_BASE))
38 #define MOV_R7_NR_RT_SIGRETURN  (0xe3a07000 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
39
40 /*
41  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
42  * need two 16-bit instructions.
43  */
44 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (__NR_sigreturn - __NR_SYSCALL_BASE))
45 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
46
47 const unsigned long sigreturn_codes[7] = {
48         MOV_R7_NR_SIGRETURN,    SWI_SYS_SIGRETURN,    SWI_THUMB_SIGRETURN,
49         MOV_R7_NR_RT_SIGRETURN, SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN,
50 };
51
52 /*
53  * Either we support OABI only, or we have EABI with the OABI
54  * compat layer enabled.  In the later case we don't know if
55  * user space is EABI or not, and if not we must not clobber r7.
56  * Always using the OABI syscall solves that issue and works for
57  * all those cases.
58  */
59 const unsigned long syscall_restart_code[2] = {
60         SWI_SYS_RESTART,        /* swi  __NR_restart_syscall */
61         0xe49df004,             /* ldr  pc, [sp], #4 */
62 };
63
64 /*
65  * atomically swap in the new signal mask, and wait for a signal.
66  */
67 asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t mask)
68 {
69         mask &= _BLOCKABLE;
70         spin_lock_irq(&current->sighand->siglock);
71         current->saved_sigmask = current->blocked;
72         siginitset(&current->blocked, mask);
73         recalc_sigpending();
74         spin_unlock_irq(&current->sighand->siglock);
75
76         current->state = TASK_INTERRUPTIBLE;
77         schedule();
78         set_restore_sigmask();
79         return -ERESTARTNOHAND;
80 }
81
82 asmlinkage int 
83 sys_sigaction(int sig, const struct old_sigaction __user *act,
84               struct old_sigaction __user *oact)
85 {
86         struct k_sigaction new_ka, old_ka;
87         int ret;
88
89         if (act) {
90                 old_sigset_t mask;
91                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
92                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
93                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
94                         return -EFAULT;
95                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
96                 __get_user(mask, &act->sa_mask);
97                 siginitset(&new_ka.sa.sa_mask, mask);
98         }
99
100         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
101
102         if (!ret && oact) {
103                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
104                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
105                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
106                         return -EFAULT;
107                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
108                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
109         }
110
111         return ret;
112 }
113
114 #ifdef CONFIG_CRUNCH
115 static int preserve_crunch_context(struct crunch_sigframe __user *frame)
116 {
117         char kbuf[sizeof(*frame) + 8];
118         struct crunch_sigframe *kframe;
119
120         /* the crunch context must be 64 bit aligned */
121         kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
122         kframe->magic = CRUNCH_MAGIC;
123         kframe->size = CRUNCH_STORAGE_SIZE;
124         crunch_task_copy(current_thread_info(), &kframe->storage);
125         return __copy_to_user(frame, kframe, sizeof(*frame));
126 }
127
128 static int restore_crunch_context(struct crunch_sigframe __user *frame)
129 {
130         char kbuf[sizeof(*frame) + 8];
131         struct crunch_sigframe *kframe;
132
133         /* the crunch context must be 64 bit aligned */
134         kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
135         if (__copy_from_user(kframe, frame, sizeof(*frame)))
136                 return -1;
137         if (kframe->magic != CRUNCH_MAGIC ||
138             kframe->size != CRUNCH_STORAGE_SIZE)
139                 return -1;
140         crunch_task_restore(current_thread_info(), &kframe->storage);
141         return 0;
142 }
143 #endif
144
145 #ifdef CONFIG_IWMMXT
146
147 static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
148 {
149         char kbuf[sizeof(*frame) + 8];
150         struct iwmmxt_sigframe *kframe;
151
152         /* the iWMMXt context must be 64 bit aligned */
153         kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
154         kframe->magic = IWMMXT_MAGIC;
155         kframe->size = IWMMXT_STORAGE_SIZE;
156         iwmmxt_task_copy(current_thread_info(), &kframe->storage);
157         return __copy_to_user(frame, kframe, sizeof(*frame));
158 }
159
160 static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
161 {
162         char kbuf[sizeof(*frame) + 8];
163         struct iwmmxt_sigframe *kframe;
164
165         /* the iWMMXt context must be 64 bit aligned */
166         kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
167         if (__copy_from_user(kframe, frame, sizeof(*frame)))
168                 return -1;
169         if (kframe->magic != IWMMXT_MAGIC ||
170             kframe->size != IWMMXT_STORAGE_SIZE)
171                 return -1;
172         iwmmxt_task_restore(current_thread_info(), &kframe->storage);
173         return 0;
174 }
175
176 #endif
177
178 #ifdef CONFIG_VFP
179
180 static int preserve_vfp_context(struct vfp_sigframe __user *frame)
181 {
182         struct thread_info *thread = current_thread_info();
183         struct vfp_hard_struct *h = &thread->vfpstate.hard;
184         const unsigned long magic = VFP_MAGIC;
185         const unsigned long size = VFP_STORAGE_SIZE;
186         int err = 0;
187
188         vfp_sync_hwstate(thread);
189         __put_user_error(magic, &frame->magic, err);
190         __put_user_error(size, &frame->size, err);
191
192         /*
193          * Copy the floating point registers. There can be unused
194          * registers see asm/hwcap.h for details.
195          */
196         err |= __copy_to_user(&frame->ufp.fpregs, &h->fpregs,
197                               sizeof(h->fpregs));
198         /*
199          * Copy the status and control register.
200          */
201         __put_user_error(h->fpscr, &frame->ufp.fpscr, err);
202
203         /*
204          * Copy the exception registers.
205          */
206         __put_user_error(h->fpexc, &frame->ufp_exc.fpexc, err);
207         __put_user_error(h->fpinst, &frame->ufp_exc.fpinst, err);
208         __put_user_error(h->fpinst2, &frame->ufp_exc.fpinst2, err);
209
210         return err ? -EFAULT : 0;
211 }
212
213 static int restore_vfp_context(struct vfp_sigframe __user *frame)
214 {
215         struct thread_info *thread = current_thread_info();
216         struct vfp_hard_struct *h = &thread->vfpstate.hard;
217         unsigned long magic;
218         unsigned long size;
219         unsigned long fpexc;
220         int err = 0;
221
222         __get_user_error(magic, &frame->magic, err);
223         __get_user_error(size, &frame->size, err);
224
225         if (err)
226                 return -EFAULT;
227         if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
228                 return -EINVAL;
229
230         /*
231          * Copy the floating point registers. There can be unused
232          * registers see asm/hwcap.h for details.
233          */
234         err |= __copy_from_user(&h->fpregs, &frame->ufp.fpregs,
235                                 sizeof(h->fpregs));
236         /*
237          * Copy the status and control register.
238          */
239         __get_user_error(h->fpscr, &frame->ufp.fpscr, err);
240
241         /*
242          * Sanitise and restore the exception registers.
243          */
244         __get_user_error(fpexc, &frame->ufp_exc.fpexc, err);
245         /* Ensure the VFP is enabled. */
246         fpexc |= FPEXC_EN;
247         /* Ensure FPINST2 is invalid and the exception flag is cleared. */
248         fpexc &= ~(FPEXC_EX | FPEXC_FP2V);
249         h->fpexc = fpexc;
250
251         __get_user_error(h->fpinst, &frame->ufp_exc.fpinst, err);
252         __get_user_error(h->fpinst2, &frame->ufp_exc.fpinst2, err);
253
254         if (!err)
255                 vfp_flush_hwstate(thread);
256
257         return err ? -EFAULT : 0;
258 }
259
260 #endif
261
262 /*
263  * Do a signal return; undo the signal stack.  These are aligned to 64-bit.
264  */
265 struct sigframe {
266         struct ucontext uc;
267         unsigned long retcode[2];
268 };
269
270 struct rt_sigframe {
271         struct siginfo info;
272         struct sigframe sig;
273 };
274
275 static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
276 {
277         struct aux_sigframe __user *aux;
278         sigset_t set;
279         int err;
280
281         err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
282         if (err == 0) {
283                 sigdelsetmask(&set, ~_BLOCKABLE);
284                 spin_lock_irq(&current->sighand->siglock);
285                 current->blocked = set;
286                 recalc_sigpending();
287                 spin_unlock_irq(&current->sighand->siglock);
288         }
289
290         __get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
291         __get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
292         __get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
293         __get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
294         __get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
295         __get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
296         __get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
297         __get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
298         __get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
299         __get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
300         __get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
301         __get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
302         __get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
303         __get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
304         __get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
305         __get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
306         __get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
307
308         err |= !valid_user_regs(regs);
309
310         aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
311 #ifdef CONFIG_CRUNCH
312         if (err == 0)
313                 err |= restore_crunch_context(&aux->crunch);
314 #endif
315 #ifdef CONFIG_IWMMXT
316         if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
317                 err |= restore_iwmmxt_context(&aux->iwmmxt);
318 #endif
319 #ifdef CONFIG_VFP
320         if (err == 0)
321                 err |= restore_vfp_context(&aux->vfp);
322 #endif
323
324         return err;
325 }
326
327 asmlinkage int sys_sigreturn(struct pt_regs *regs)
328 {
329         struct sigframe __user *frame;
330
331         /* Always make any pending restarted system calls return -EINTR */
332         current_thread_info()->restart_block.fn = do_no_restart_syscall;
333
334         /*
335          * Since we stacked the signal on a 64-bit boundary,
336          * then 'sp' should be word aligned here.  If it's
337          * not, then the user is trying to mess with us.
338          */
339         if (regs->ARM_sp & 7)
340                 goto badframe;
341
342         frame = (struct sigframe __user *)regs->ARM_sp;
343
344         if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
345                 goto badframe;
346
347         if (restore_sigframe(regs, frame))
348                 goto badframe;
349
350         return regs->ARM_r0;
351
352 badframe:
353         force_sig(SIGSEGV, current);
354         return 0;
355 }
356
357 asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
358 {
359         struct rt_sigframe __user *frame;
360
361         /* Always make any pending restarted system calls return -EINTR */
362         current_thread_info()->restart_block.fn = do_no_restart_syscall;
363
364         /*
365          * Since we stacked the signal on a 64-bit boundary,
366          * then 'sp' should be word aligned here.  If it's
367          * not, then the user is trying to mess with us.
368          */
369         if (regs->ARM_sp & 7)
370                 goto badframe;
371
372         frame = (struct rt_sigframe __user *)regs->ARM_sp;
373
374         if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
375                 goto badframe;
376
377         if (restore_sigframe(regs, &frame->sig))
378                 goto badframe;
379
380         if (do_sigaltstack(&frame->sig.uc.uc_stack, NULL, regs->ARM_sp) == -EFAULT)
381                 goto badframe;
382
383         return regs->ARM_r0;
384
385 badframe:
386         force_sig(SIGSEGV, current);
387         return 0;
388 }
389
390 static int
391 setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
392 {
393         struct aux_sigframe __user *aux;
394         int err = 0;
395
396         __put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
397         __put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
398         __put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
399         __put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
400         __put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
401         __put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
402         __put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
403         __put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
404         __put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
405         __put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
406         __put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
407         __put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
408         __put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
409         __put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
410         __put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
411         __put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
412         __put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
413
414         __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
415         __put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
416         __put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
417         __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
418
419         err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
420
421         aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
422 #ifdef CONFIG_CRUNCH
423         if (err == 0)
424                 err |= preserve_crunch_context(&aux->crunch);
425 #endif
426 #ifdef CONFIG_IWMMXT
427         if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
428                 err |= preserve_iwmmxt_context(&aux->iwmmxt);
429 #endif
430 #ifdef CONFIG_VFP
431         if (err == 0)
432                 err |= preserve_vfp_context(&aux->vfp);
433 #endif
434         __put_user_error(0, &aux->end_magic, err);
435
436         return err;
437 }
438
439 static inline void __user *
440 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, int framesize)
441 {
442         unsigned long sp = regs->ARM_sp;
443         void __user *frame;
444
445         /*
446          * This is the X/Open sanctioned signal stack switching.
447          */
448         if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
449                 sp = current->sas_ss_sp + current->sas_ss_size;
450
451         /*
452          * ATPCS B01 mandates 8-byte alignment
453          */
454         frame = (void __user *)((sp - framesize) & ~7);
455
456         /*
457          * Check that we can actually write to the signal frame.
458          */
459         if (!access_ok(VERIFY_WRITE, frame, framesize))
460                 frame = NULL;
461
462         return frame;
463 }
464
465 static int
466 setup_return(struct pt_regs *regs, struct k_sigaction *ka,
467              unsigned long __user *rc, void __user *frame, int usig)
468 {
469         unsigned long handler = (unsigned long)ka->sa.sa_handler;
470         unsigned long retcode;
471         int thumb = 0;
472         unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);
473
474         cpsr |= PSR_ENDSTATE;
475
476         /*
477          * Maybe we need to deliver a 32-bit signal to a 26-bit task.
478          */
479         if (ka->sa.sa_flags & SA_THIRTYTWO)
480                 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
481
482 #ifdef CONFIG_ARM_THUMB
483         if (elf_hwcap & HWCAP_THUMB) {
484                 /*
485                  * The LSB of the handler determines if we're going to
486                  * be using THUMB or ARM mode for this signal handler.
487                  */
488                 thumb = handler & 1;
489
490                 if (thumb) {
491                         cpsr |= PSR_T_BIT;
492 #if __LINUX_ARM_ARCH__ >= 7
493                         /* clear the If-Then Thumb-2 execution state */
494                         cpsr &= ~PSR_IT_MASK;
495 #endif
496                 } else
497                         cpsr &= ~PSR_T_BIT;
498         }
499 #endif
500
501         if (ka->sa.sa_flags & SA_RESTORER) {
502                 retcode = (unsigned long)ka->sa.sa_restorer;
503         } else {
504                 unsigned int idx = thumb << 1;
505
506                 if (ka->sa.sa_flags & SA_SIGINFO)
507                         idx += 3;
508
509                 if (__put_user(sigreturn_codes[idx],   rc) ||
510                     __put_user(sigreturn_codes[idx+1], rc+1))
511                         return 1;
512
513                 if (cpsr & MODE32_BIT) {
514                         /*
515                          * 32-bit code can use the new high-page
516                          * signal return code support.
517                          */
518                         retcode = KERN_SIGRETURN_CODE + (idx << 2) + thumb;
519                 } else {
520                         /*
521                          * Ensure that the instruction cache sees
522                          * the return code written onto the stack.
523                          */
524                         flush_icache_range((unsigned long)rc,
525                                            (unsigned long)(rc + 2));
526
527                         retcode = ((unsigned long)rc) + thumb;
528                 }
529         }
530
531         regs->ARM_r0 = usig;
532         regs->ARM_sp = (unsigned long)frame;
533         regs->ARM_lr = retcode;
534         regs->ARM_pc = handler;
535         regs->ARM_cpsr = cpsr;
536
537         return 0;
538 }
539
540 static int
541 setup_frame(int usig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *regs)
542 {
543         struct sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
544         int err = 0;
545
546         if (!frame)
547                 return 1;
548
549         /*
550          * Set uc.uc_flags to a value which sc.trap_no would never have.
551          */
552         __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
553
554         err |= setup_sigframe(frame, regs, set);
555         if (err == 0)
556                 err = setup_return(regs, ka, frame->retcode, frame, usig);
557
558         return err;
559 }
560
561 static int
562 setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
563                sigset_t *set, struct pt_regs *regs)
564 {
565         struct rt_sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
566         stack_t stack;
567         int err = 0;
568
569         if (!frame)
570                 return 1;
571
572         err |= copy_siginfo_to_user(&frame->info, info);
573
574         __put_user_error(0, &frame->sig.uc.uc_flags, err);
575         __put_user_error(NULL, &frame->sig.uc.uc_link, err);
576
577         memset(&stack, 0, sizeof(stack));
578         stack.ss_sp = (void __user *)current->sas_ss_sp;
579         stack.ss_flags = sas_ss_flags(regs->ARM_sp);
580         stack.ss_size = current->sas_ss_size;
581         err |= __copy_to_user(&frame->sig.uc.uc_stack, &stack, sizeof(stack));
582
583         err |= setup_sigframe(&frame->sig, regs, set);
584         if (err == 0)
585                 err = setup_return(regs, ka, frame->sig.retcode, frame, usig);
586
587         if (err == 0) {
588                 /*
589                  * For realtime signals we must also set the second and third
590                  * arguments for the signal handler.
591                  *   -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
592                  */
593                 regs->ARM_r1 = (unsigned long)&frame->info;
594                 regs->ARM_r2 = (unsigned long)&frame->sig.uc;
595         }
596
597         return err;
598 }
599
600 static inline void setup_syscall_restart(struct pt_regs *regs)
601 {
602         regs->ARM_r0 = regs->ARM_ORIG_r0;
603         regs->ARM_pc -= thumb_mode(regs) ? 2 : 4;
604 }
605
606 /*
607  * OK, we're invoking a handler
608  */     
609 static int
610 handle_signal(unsigned long sig, struct k_sigaction *ka,
611               siginfo_t *info, sigset_t *oldset,
612               struct pt_regs * regs, int syscall)
613 {
614         struct thread_info *thread = current_thread_info();
615         struct task_struct *tsk = current;
616         int usig = sig;
617         int ret;
618
619         /*
620          * If we were from a system call, check for system call restarting...
621          */
622         if (syscall) {
623                 switch (regs->ARM_r0) {
624                 case -ERESTART_RESTARTBLOCK:
625                 case -ERESTARTNOHAND:
626                         regs->ARM_r0 = -EINTR;
627                         break;
628                 case -ERESTARTSYS:
629                         if (!(ka->sa.sa_flags & SA_RESTART)) {
630                                 regs->ARM_r0 = -EINTR;
631                                 break;
632                         }
633                         /* fallthrough */
634                 case -ERESTARTNOINTR:
635                         setup_syscall_restart(regs);
636                 }
637         }
638
639         /*
640          * translate the signal
641          */
642         if (usig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
643                 usig = thread->exec_domain->signal_invmap[usig];
644
645         /*
646          * Set up the stack frame
647          */
648         if (ka->sa.sa_flags & SA_SIGINFO)
649                 ret = setup_rt_frame(usig, ka, info, oldset, regs);
650         else
651                 ret = setup_frame(usig, ka, oldset, regs);
652
653         /*
654          * Check that the resulting registers are actually sane.
655          */
656         ret |= !valid_user_regs(regs);
657
658         if (ret != 0) {
659                 force_sigsegv(sig, tsk);
660                 return ret;
661         }
662
663         /*
664          * Block the signal if we were successful.
665          */
666         spin_lock_irq(&tsk->sighand->siglock);
667         sigorsets(&tsk->blocked, &tsk->blocked,
668                   &ka->sa.sa_mask);
669         if (!(ka->sa.sa_flags & SA_NODEFER))
670                 sigaddset(&tsk->blocked, sig);
671         recalc_sigpending();
672         spin_unlock_irq(&tsk->sighand->siglock);
673
674         return 0;
675 }
676
677 /*
678  * Note that 'init' is a special process: it doesn't get signals it doesn't
679  * want to handle. Thus you cannot kill init even with a SIGKILL even by
680  * mistake.
681  *
682  * Note that we go through the signals twice: once to check the signals that
683  * the kernel can handle, and then we build all the user-level signal handling
684  * stack-frames in one go after that.
685  */
686 static void do_signal(struct pt_regs *regs, int syscall)
687 {
688         struct k_sigaction ka;
689         siginfo_t info;
690         int signr;
691
692         /*
693          * We want the common case to go fast, which
694          * is why we may in certain cases get here from
695          * kernel mode. Just return without doing anything
696          * if so.
697          */
698         if (!user_mode(regs))
699                 return;
700
701         if (try_to_freeze())
702                 goto no_signal;
703
704         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
705         if (signr > 0) {
706                 sigset_t *oldset;
707
708                 if (test_thread_flag(TIF_RESTORE_SIGMASK))
709                         oldset = &current->saved_sigmask;
710                 else
711                         oldset = &current->blocked;
712                 if (handle_signal(signr, &ka, &info, oldset, regs, syscall) == 0) {
713                         /*
714                          * A signal was successfully delivered; the saved
715                          * sigmask will have been stored in the signal frame,
716                          * and will be restored by sigreturn, so we can simply
717                          * clear the TIF_RESTORE_SIGMASK flag.
718                          */
719                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
720                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
721                 }
722                 return;
723         }
724
725  no_signal:
726         /*
727          * No signal to deliver to the process - restart the syscall.
728          */
729         if (syscall) {
730                 if (regs->ARM_r0 == -ERESTART_RESTARTBLOCK) {
731                         if (thumb_mode(regs)) {
732                                 regs->ARM_r7 = __NR_restart_syscall - __NR_SYSCALL_BASE;
733                                 regs->ARM_pc -= 2;
734                         } else {
735 #if defined(CONFIG_AEABI) && !defined(CONFIG_OABI_COMPAT)
736                                 regs->ARM_r7 = __NR_restart_syscall;
737                                 regs->ARM_pc -= 4;
738 #else
739                                 u32 __user *usp;
740
741                                 regs->ARM_sp -= 4;
742                                 usp = (u32 __user *)regs->ARM_sp;
743
744                                 if (put_user(regs->ARM_pc, usp) == 0) {
745                                         regs->ARM_pc = KERN_RESTART_CODE;
746                                 } else {
747                                         regs->ARM_sp += 4;
748                                         force_sigsegv(0, current);
749                                 }
750 #endif
751                         }
752                 }
753                 if (regs->ARM_r0 == -ERESTARTNOHAND ||
754                     regs->ARM_r0 == -ERESTARTSYS ||
755                     regs->ARM_r0 == -ERESTARTNOINTR) {
756                         setup_syscall_restart(regs);
757                 }
758
759                 /* If there's no signal to deliver, we just put the saved sigmask
760                  * back.
761                  */
762                 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
763                         clear_thread_flag(TIF_RESTORE_SIGMASK);
764                         sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
765                 }
766         }
767 }
768
769 asmlinkage void
770 do_notify_resume(struct pt_regs *regs, unsigned int thread_flags, int syscall)
771 {
772         if (thread_flags & _TIF_SIGPENDING)
773                 do_signal(regs, syscall);
774
775         if (thread_flags & _TIF_NOTIFY_RESUME) {
776                 clear_thread_flag(TIF_NOTIFY_RESUME);
777                 tracehook_notify_resume(regs);
778                 if (current->replacement_session_keyring)
779                         key_replace_session_keyring();
780         }
781 }