blob: 7cb532fc8aa4e3a9dc1e9d63d4cb887a08b1fad1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/arch/arm/kernel/signal.c
3 *
Russell Kingab72b002009-10-25 15:39:37 +00004 * Copyright (C) 1995-2009 Russell King
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/errno.h>
11#include <linux/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/personality.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080013#include <linux/freezer.h>
Russell King33fa9b12008-09-06 11:35:55 +010014#include <linux/uaccess.h>
David Howells733e5e42009-09-09 08:30:21 +010015#include <linux/tracehook.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
Russell Kingee90dab2006-11-09 14:20:47 +000017#include <asm/elf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <asm/cacheflush.h>
19#include <asm/ucontext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <asm/unistd.h>
Imre Deak82c6f5a2010-04-11 15:58:27 +010021#include <asm/vfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
Russell Kinge00d3492005-06-22 20:26:05 +010023#include "signal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
26
27/*
28 * For ARM syscalls, we encode the syscall number into the instruction.
29 */
janboeee4cd582008-03-19 03:34:23 +010030#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))
Russell Kingab72b002009-10-25 15:39:37 +000032#define SWI_SYS_RESTART (0xef000000|__NR_restart_syscall|__NR_OABI_SYSCALL_BASE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34/*
Nicolas Pitrefcca5382006-01-18 22:38:47 +000035 * 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/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * 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
Nicolas Pitrefcca5382006-01-18 22:38:47 +000047const 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,
Linus Torvalds1da177e2005-04-16 15:20:36 -070050};
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052/*
Russell Kingab72b002009-10-25 15:39:37 +000053 * 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 */
59const unsigned long syscall_restart_code[2] = {
60 SWI_SYS_RESTART, /* swi __NR_restart_syscall */
61 0xe49df004, /* ldr pc, [sp], #4 */
62};
63
64/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 * atomically swap in the new signal mask, and wait for a signal.
66 */
Mikael Pettersson36984262009-08-15 12:58:11 +010067asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068{
Matt Fleming101d9b02012-03-05 15:05:34 -080069 sigset_t blocked;
70
Mikael Pettersson36984262009-08-15 12:58:11 +010071 current->saved_sigmask = current->blocked;
Matt Fleming101d9b02012-03-05 15:05:34 -080072
73 mask &= _BLOCKABLE;
74 siginitset(&blocked, mask);
75 set_current_blocked(&blocked);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Mikael Pettersson36984262009-08-15 12:58:11 +010077 current->state = TASK_INTERRUPTIBLE;
78 schedule();
79 set_restore_sigmask();
80 return -ERESTARTNOHAND;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081}
82
83asmlinkage int
84sys_sigaction(int sig, const struct old_sigaction __user *act,
85 struct old_sigaction __user *oact)
86{
87 struct k_sigaction new_ka, old_ka;
88 int ret;
89
90 if (act) {
91 old_sigset_t mask;
92 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
93 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
94 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
95 return -EFAULT;
96 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
97 __get_user(mask, &act->sa_mask);
98 siginitset(&new_ka.sa.sa_mask, mask);
99 }
100
101 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
102
103 if (!ret && oact) {
104 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
105 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
106 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
107 return -EFAULT;
108 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
109 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
110 }
111
112 return ret;
113}
114
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100115#ifdef CONFIG_CRUNCH
Hartley Sweeten65a50532009-08-04 23:20:45 +0100116static int preserve_crunch_context(struct crunch_sigframe __user *frame)
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100117{
118 char kbuf[sizeof(*frame) + 8];
119 struct crunch_sigframe *kframe;
120
121 /* the crunch context must be 64 bit aligned */
122 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
123 kframe->magic = CRUNCH_MAGIC;
124 kframe->size = CRUNCH_STORAGE_SIZE;
125 crunch_task_copy(current_thread_info(), &kframe->storage);
126 return __copy_to_user(frame, kframe, sizeof(*frame));
127}
128
Hartley Sweeten65a50532009-08-04 23:20:45 +0100129static int restore_crunch_context(struct crunch_sigframe __user *frame)
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100130{
131 char kbuf[sizeof(*frame) + 8];
132 struct crunch_sigframe *kframe;
133
134 /* the crunch context must be 64 bit aligned */
135 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
136 if (__copy_from_user(kframe, frame, sizeof(*frame)))
137 return -1;
138 if (kframe->magic != CRUNCH_MAGIC ||
139 kframe->size != CRUNCH_STORAGE_SIZE)
140 return -1;
141 crunch_task_restore(current_thread_info(), &kframe->storage);
142 return 0;
143}
144#endif
145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146#ifdef CONFIG_IWMMXT
147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
149{
Hugh Dickins69b04752005-10-29 18:16:36 -0700150 char kbuf[sizeof(*frame) + 8];
151 struct iwmmxt_sigframe *kframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 /* the iWMMXt context must be 64 bit aligned */
Hugh Dickins69b04752005-10-29 18:16:36 -0700154 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100155 kframe->magic = IWMMXT_MAGIC;
156 kframe->size = IWMMXT_STORAGE_SIZE;
Hugh Dickins69b04752005-10-29 18:16:36 -0700157 iwmmxt_task_copy(current_thread_info(), &kframe->storage);
158 return __copy_to_user(frame, kframe, sizeof(*frame));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159}
160
161static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
162{
Hugh Dickins69b04752005-10-29 18:16:36 -0700163 char kbuf[sizeof(*frame) + 8];
164 struct iwmmxt_sigframe *kframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Hugh Dickins69b04752005-10-29 18:16:36 -0700166 /* the iWMMXt context must be 64 bit aligned */
167 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
168 if (__copy_from_user(kframe, frame, sizeof(*frame)))
169 return -1;
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100170 if (kframe->magic != IWMMXT_MAGIC ||
171 kframe->size != IWMMXT_STORAGE_SIZE)
Hugh Dickins69b04752005-10-29 18:16:36 -0700172 return -1;
173 iwmmxt_task_restore(current_thread_info(), &kframe->storage);
174 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175}
176
177#endif
178
Imre Deak82c6f5a2010-04-11 15:58:27 +0100179#ifdef CONFIG_VFP
180
181static int preserve_vfp_context(struct vfp_sigframe __user *frame)
182{
183 struct thread_info *thread = current_thread_info();
184 struct vfp_hard_struct *h = &thread->vfpstate.hard;
185 const unsigned long magic = VFP_MAGIC;
186 const unsigned long size = VFP_STORAGE_SIZE;
187 int err = 0;
188
189 vfp_sync_hwstate(thread);
190 __put_user_error(magic, &frame->magic, err);
191 __put_user_error(size, &frame->size, err);
192
193 /*
194 * Copy the floating point registers. There can be unused
195 * registers see asm/hwcap.h for details.
196 */
197 err |= __copy_to_user(&frame->ufp.fpregs, &h->fpregs,
198 sizeof(h->fpregs));
199 /*
200 * Copy the status and control register.
201 */
202 __put_user_error(h->fpscr, &frame->ufp.fpscr, err);
203
204 /*
205 * Copy the exception registers.
206 */
207 __put_user_error(h->fpexc, &frame->ufp_exc.fpexc, err);
208 __put_user_error(h->fpinst, &frame->ufp_exc.fpinst, err);
209 __put_user_error(h->fpinst2, &frame->ufp_exc.fpinst2, err);
210
211 return err ? -EFAULT : 0;
212}
213
214static int restore_vfp_context(struct vfp_sigframe __user *frame)
215{
216 struct thread_info *thread = current_thread_info();
217 struct vfp_hard_struct *h = &thread->vfpstate.hard;
218 unsigned long magic;
219 unsigned long size;
220 unsigned long fpexc;
221 int err = 0;
222
223 __get_user_error(magic, &frame->magic, err);
224 __get_user_error(size, &frame->size, err);
225
226 if (err)
227 return -EFAULT;
228 if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
229 return -EINVAL;
230
Will Deacon2af276d2012-01-30 20:21:42 +0100231 vfp_flush_hwstate(thread);
232
Imre Deak82c6f5a2010-04-11 15:58:27 +0100233 /*
234 * Copy the floating point registers. There can be unused
235 * registers see asm/hwcap.h for details.
236 */
237 err |= __copy_from_user(&h->fpregs, &frame->ufp.fpregs,
238 sizeof(h->fpregs));
239 /*
240 * Copy the status and control register.
241 */
242 __get_user_error(h->fpscr, &frame->ufp.fpscr, err);
243
244 /*
245 * Sanitise and restore the exception registers.
246 */
247 __get_user_error(fpexc, &frame->ufp_exc.fpexc, err);
248 /* Ensure the VFP is enabled. */
249 fpexc |= FPEXC_EN;
250 /* Ensure FPINST2 is invalid and the exception flag is cleared. */
251 fpexc &= ~(FPEXC_EX | FPEXC_FP2V);
252 h->fpexc = fpexc;
253
254 __get_user_error(h->fpinst, &frame->ufp_exc.fpinst, err);
255 __get_user_error(h->fpinst2, &frame->ufp_exc.fpinst2, err);
256
Imre Deak82c6f5a2010-04-11 15:58:27 +0100257 return err ? -EFAULT : 0;
258}
259
260#endif
261
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 * Do a signal return; undo the signal stack. These are aligned to 64-bit.
264 */
265struct sigframe {
Russell King7d4fdc12006-06-15 20:13:25 +0100266 struct ucontext uc;
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000267 unsigned long retcode[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268};
269
270struct rt_sigframe {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 struct siginfo info;
Russell Kingcb3504e2006-06-15 20:18:25 +0100272 struct sigframe sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273};
274
Russell King68071482006-06-15 20:23:02 +0100275static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100277 struct aux_sigframe __user *aux;
Russell King68071482006-06-15 20:23:02 +0100278 sigset_t set;
279 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Russell King68071482006-06-15 20:23:02 +0100281 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
282 if (err == 0) {
283 sigdelsetmask(&set, ~_BLOCKABLE);
Matt Fleming101d9b02012-03-05 15:05:34 -0800284 set_current_blocked(&set);
Russell King68071482006-06-15 20:23:02 +0100285 }
286
287 __get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
288 __get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
289 __get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
290 __get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
291 __get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
292 __get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
293 __get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
294 __get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
295 __get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
296 __get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
297 __get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
298 __get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
299 __get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
300 __get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
301 __get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
302 __get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
303 __get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 err |= !valid_user_regs(regs);
306
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100307 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100308#ifdef CONFIG_CRUNCH
309 if (err == 0)
310 err |= restore_crunch_context(&aux->crunch);
311#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312#ifdef CONFIG_IWMMXT
313 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
314 err |= restore_iwmmxt_context(&aux->iwmmxt);
315#endif
316#ifdef CONFIG_VFP
Imre Deak82c6f5a2010-04-11 15:58:27 +0100317 if (err == 0)
318 err |= restore_vfp_context(&aux->vfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319#endif
320
321 return err;
322}
323
324asmlinkage int sys_sigreturn(struct pt_regs *regs)
325{
326 struct sigframe __user *frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 /* Always make any pending restarted system calls return -EINTR */
329 current_thread_info()->restart_block.fn = do_no_restart_syscall;
330
331 /*
332 * Since we stacked the signal on a 64-bit boundary,
333 * then 'sp' should be word aligned here. If it's
334 * not, then the user is trying to mess with us.
335 */
336 if (regs->ARM_sp & 7)
337 goto badframe;
338
339 frame = (struct sigframe __user *)regs->ARM_sp;
340
341 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
342 goto badframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Russell King68071482006-06-15 20:23:02 +0100344 if (restore_sigframe(regs, frame))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 goto badframe;
346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 return regs->ARM_r0;
348
349badframe:
350 force_sig(SIGSEGV, current);
351 return 0;
352}
353
354asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
355{
356 struct rt_sigframe __user *frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
358 /* Always make any pending restarted system calls return -EINTR */
359 current_thread_info()->restart_block.fn = do_no_restart_syscall;
360
361 /*
362 * Since we stacked the signal on a 64-bit boundary,
363 * then 'sp' should be word aligned here. If it's
364 * not, then the user is trying to mess with us.
365 */
366 if (regs->ARM_sp & 7)
367 goto badframe;
368
369 frame = (struct rt_sigframe __user *)regs->ARM_sp;
370
371 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
372 goto badframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Russell King68071482006-06-15 20:23:02 +0100374 if (restore_sigframe(regs, &frame->sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 goto badframe;
376
Russell Kingcb3504e2006-06-15 20:18:25 +0100377 if (do_sigaltstack(&frame->sig.uc.uc_stack, NULL, regs->ARM_sp) == -EFAULT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 goto badframe;
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return regs->ARM_r0;
381
382badframe:
383 force_sig(SIGSEGV, current);
384 return 0;
385}
386
387static int
Russell Kingaca6ca12006-06-15 20:28:03 +0100388setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100390 struct aux_sigframe __user *aux;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 int err = 0;
392
Russell Kingaca6ca12006-06-15 20:28:03 +0100393 __put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
394 __put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
395 __put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
396 __put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
397 __put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
398 __put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
399 __put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
400 __put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
401 __put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
402 __put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
403 __put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
404 __put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
405 __put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
406 __put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
407 __put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
408 __put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
409 __put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Russell Kingaca6ca12006-06-15 20:28:03 +0100411 __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
412 __put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
413 __put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
414 __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Russell Kingaca6ca12006-06-15 20:28:03 +0100416 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100418 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100419#ifdef CONFIG_CRUNCH
420 if (err == 0)
421 err |= preserve_crunch_context(&aux->crunch);
422#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423#ifdef CONFIG_IWMMXT
424 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
425 err |= preserve_iwmmxt_context(&aux->iwmmxt);
426#endif
427#ifdef CONFIG_VFP
Imre Deak82c6f5a2010-04-11 15:58:27 +0100428 if (err == 0)
429 err |= preserve_vfp_context(&aux->vfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430#endif
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100431 __put_user_error(0, &aux->end_magic, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
433 return err;
434}
435
436static inline void __user *
437get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, int framesize)
438{
439 unsigned long sp = regs->ARM_sp;
440 void __user *frame;
441
442 /*
443 * This is the X/Open sanctioned signal stack switching.
444 */
445 if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
446 sp = current->sas_ss_sp + current->sas_ss_size;
447
448 /*
449 * ATPCS B01 mandates 8-byte alignment
450 */
451 frame = (void __user *)((sp - framesize) & ~7);
452
453 /*
454 * Check that we can actually write to the signal frame.
455 */
456 if (!access_ok(VERIFY_WRITE, frame, framesize))
457 frame = NULL;
458
459 return frame;
460}
461
462static int
463setup_return(struct pt_regs *regs, struct k_sigaction *ka,
464 unsigned long __user *rc, void __user *frame, int usig)
465{
466 unsigned long handler = (unsigned long)ka->sa.sa_handler;
467 unsigned long retcode;
468 int thumb = 0;
Russell King53399052011-02-20 12:22:52 +0000469 unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);
470
471 cpsr |= PSR_ENDSTATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
473 /*
474 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
475 */
476 if (ka->sa.sa_flags & SA_THIRTYTWO)
477 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
478
479#ifdef CONFIG_ARM_THUMB
480 if (elf_hwcap & HWCAP_THUMB) {
481 /*
482 * The LSB of the handler determines if we're going to
483 * be using THUMB or ARM mode for this signal handler.
484 */
485 thumb = handler & 1;
486
Catalin Marinasd71e1352009-05-30 14:00:15 +0100487 if (thumb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 cpsr |= PSR_T_BIT;
Catalin Marinasd71e1352009-05-30 14:00:15 +0100489#if __LINUX_ARM_ARCH__ >= 7
490 /* clear the If-Then Thumb-2 execution state */
491 cpsr &= ~PSR_IT_MASK;
492#endif
493 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 cpsr &= ~PSR_T_BIT;
495 }
496#endif
497
498 if (ka->sa.sa_flags & SA_RESTORER) {
499 retcode = (unsigned long)ka->sa.sa_restorer;
500 } else {
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000501 unsigned int idx = thumb << 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503 if (ka->sa.sa_flags & SA_SIGINFO)
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000504 idx += 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000506 if (__put_user(sigreturn_codes[idx], rc) ||
507 __put_user(sigreturn_codes[idx+1], rc+1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 return 1;
509
Russell Kinge00d3492005-06-22 20:26:05 +0100510 if (cpsr & MODE32_BIT) {
511 /*
512 * 32-bit code can use the new high-page
513 * signal return code support.
514 */
515 retcode = KERN_SIGRETURN_CODE + (idx << 2) + thumb;
516 } else {
517 /*
518 * Ensure that the instruction cache sees
519 * the return code written onto the stack.
520 */
521 flush_icache_range((unsigned long)rc,
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000522 (unsigned long)(rc + 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Russell Kinge00d3492005-06-22 20:26:05 +0100524 retcode = ((unsigned long)rc) + thumb;
525 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 }
527
528 regs->ARM_r0 = usig;
529 regs->ARM_sp = (unsigned long)frame;
530 regs->ARM_lr = retcode;
531 regs->ARM_pc = handler;
532 regs->ARM_cpsr = cpsr;
533
534 return 0;
535}
536
537static int
538setup_frame(int usig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *regs)
539{
540 struct sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
541 int err = 0;
542
543 if (!frame)
544 return 1;
545
Russell Kingca195cf2006-06-24 22:41:09 +0100546 /*
547 * Set uc.uc_flags to a value which sc.trap_no would never have.
548 */
549 __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
Russell Kingaca6ca12006-06-15 20:28:03 +0100551 err |= setup_sigframe(frame, regs, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 if (err == 0)
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000553 err = setup_return(regs, ka, frame->retcode, frame, usig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 return err;
556}
557
558static int
559setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
560 sigset_t *set, struct pt_regs *regs)
561{
562 struct rt_sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
563 stack_t stack;
564 int err = 0;
565
566 if (!frame)
567 return 1;
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 err |= copy_siginfo_to_user(&frame->info, info);
570
Russell Kingcb3504e2006-06-15 20:18:25 +0100571 __put_user_error(0, &frame->sig.uc.uc_flags, err);
572 __put_user_error(NULL, &frame->sig.uc.uc_link, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
574 memset(&stack, 0, sizeof(stack));
575 stack.ss_sp = (void __user *)current->sas_ss_sp;
576 stack.ss_flags = sas_ss_flags(regs->ARM_sp);
577 stack.ss_size = current->sas_ss_size;
Russell Kingcb3504e2006-06-15 20:18:25 +0100578 err |= __copy_to_user(&frame->sig.uc.uc_stack, &stack, sizeof(stack));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
Russell Kingaca6ca12006-06-15 20:28:03 +0100580 err |= setup_sigframe(&frame->sig, regs, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 if (err == 0)
Russell Kingcb3504e2006-06-15 20:18:25 +0100582 err = setup_return(regs, ka, frame->sig.retcode, frame, usig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
584 if (err == 0) {
585 /*
586 * For realtime signals we must also set the second and third
587 * arguments for the signal handler.
588 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
589 */
590 regs->ARM_r1 = (unsigned long)&frame->info;
Russell Kingcb3504e2006-06-15 20:18:25 +0100591 regs->ARM_r2 = (unsigned long)&frame->sig.uc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 }
593
594 return err;
595}
596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597/*
598 * OK, we're invoking a handler
599 */
Mikael Pettersson36984262009-08-15 12:58:11 +0100600static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601handle_signal(unsigned long sig, struct k_sigaction *ka,
602 siginfo_t *info, sigset_t *oldset,
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100603 struct pt_regs * regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
605 struct thread_info *thread = current_thread_info();
606 struct task_struct *tsk = current;
607 int usig = sig;
608 int ret;
609
610 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 * translate the signal
612 */
613 if (usig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
614 usig = thread->exec_domain->signal_invmap[usig];
615
616 /*
617 * Set up the stack frame
618 */
619 if (ka->sa.sa_flags & SA_SIGINFO)
620 ret = setup_rt_frame(usig, ka, info, oldset, regs);
621 else
622 ret = setup_frame(usig, ka, oldset, regs);
623
624 /*
625 * Check that the resulting registers are actually sane.
626 */
627 ret |= !valid_user_regs(regs);
628
Steven Rostedt69be8f12005-08-29 11:44:09 -0400629 if (ret != 0) {
Daniel Jacobowitza6c61e92005-11-19 10:01:07 +0000630 force_sigsegv(sig, tsk);
Mikael Pettersson36984262009-08-15 12:58:11 +0100631 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 }
633
Daniel Jacobowitza6c61e92005-11-19 10:01:07 +0000634 /*
635 * Block the signal if we were successful.
636 */
Matt Fleming101d9b02012-03-05 15:05:34 -0800637 block_sigmask(ka, sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
Mikael Pettersson36984262009-08-15 12:58:11 +0100639 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640}
641
642/*
643 * Note that 'init' is a special process: it doesn't get signals it doesn't
644 * want to handle. Thus you cannot kill init even with a SIGKILL even by
645 * mistake.
646 *
647 * Note that we go through the signals twice: once to check the signals that
648 * the kernel can handle, and then we build all the user-level signal handling
649 * stack-frames in one go after that.
650 */
Mikael Pettersson36984262009-08-15 12:58:11 +0100651static void do_signal(struct pt_regs *regs, int syscall)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652{
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100653 unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 struct k_sigaction ka;
655 siginfo_t info;
656 int signr;
657
658 /*
659 * We want the common case to go fast, which
660 * is why we may in certain cases get here from
661 * kernel mode. Just return without doing anything
662 * if so.
663 */
664 if (!user_mode(regs))
Mikael Pettersson36984262009-08-15 12:58:11 +0100665 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100667 /*
668 * If we were from a system call, check for system call restarting...
669 */
670 if (syscall) {
671 continue_addr = regs->ARM_pc;
672 restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
673 retval = regs->ARM_r0;
674
675 /*
676 * Prepare for system call restart. We do this here so that a
677 * debugger will see the already changed PSW.
678 */
679 switch (retval) {
680 case -ERESTARTNOHAND:
681 case -ERESTARTSYS:
682 case -ERESTARTNOINTR:
683 regs->ARM_r0 = regs->ARM_ORIG_r0;
684 regs->ARM_pc = restart_addr;
685 break;
686 case -ERESTART_RESTARTBLOCK:
687 regs->ARM_r0 = -EINTR;
688 break;
689 }
690 }
691
Andrew Mortonbdb94f32005-06-26 03:27:21 -0700692 if (try_to_freeze())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 goto no_signal;
694
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100695 /*
696 * Get the signal to deliver. When running under ptrace, at this
697 * point the debugger may change all our registers ...
698 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
700 if (signr > 0) {
Mikael Pettersson36984262009-08-15 12:58:11 +0100701 sigset_t *oldset;
702
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100703 /*
704 * Depending on the signal settings we may need to revert the
705 * decision to restart the system call. But skip this if a
706 * debugger has chosen to restart at a different PC.
707 */
708 if (regs->ARM_pc == restart_addr) {
709 if (retval == -ERESTARTNOHAND
710 || (retval == -ERESTARTSYS
711 && !(ka.sa.sa_flags & SA_RESTART))) {
712 regs->ARM_r0 = -EINTR;
713 regs->ARM_pc = continue_addr;
714 }
715 }
716
Mikael Pettersson36984262009-08-15 12:58:11 +0100717 if (test_thread_flag(TIF_RESTORE_SIGMASK))
718 oldset = &current->saved_sigmask;
719 else
720 oldset = &current->blocked;
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100721 if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
Mikael Pettersson36984262009-08-15 12:58:11 +0100722 /*
723 * A signal was successfully delivered; the saved
724 * sigmask will have been stored in the signal frame,
725 * and will be restored by sigreturn, so we can simply
726 * clear the TIF_RESTORE_SIGMASK flag.
727 */
728 if (test_thread_flag(TIF_RESTORE_SIGMASK))
729 clear_thread_flag(TIF_RESTORE_SIGMASK);
730 }
Mikael Pettersson36984262009-08-15 12:58:11 +0100731 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 }
733
734 no_signal:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 if (syscall) {
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100736 /*
737 * Handle restarting a different system call. As above,
738 * if a debugger has chosen to restart at a different PC,
739 * ignore the restart.
740 */
741 if (retval == -ERESTART_RESTARTBLOCK
742 && regs->ARM_pc == continue_addr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 if (thumb_mode(regs)) {
Nicolas Pitref606a6f2006-06-22 22:18:45 +0100744 regs->ARM_r7 = __NR_restart_syscall - __NR_SYSCALL_BASE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 regs->ARM_pc -= 2;
746 } else {
Nicolas Pitref606a6f2006-06-22 22:18:45 +0100747#if defined(CONFIG_AEABI) && !defined(CONFIG_OABI_COMPAT)
748 regs->ARM_r7 = __NR_restart_syscall;
749 regs->ARM_pc -= 4;
750#else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 u32 __user *usp;
752
Russell Kingab72b002009-10-25 15:39:37 +0000753 regs->ARM_sp -= 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 usp = (u32 __user *)regs->ARM_sp;
755
Jean PIHET3336f4f2009-11-23 17:03:32 +0100756 if (put_user(regs->ARM_pc, usp) == 0) {
757 regs->ARM_pc = KERN_RESTART_CODE;
758 } else {
759 regs->ARM_sp += 4;
760 force_sigsegv(0, current);
761 }
Nicolas Pitref606a6f2006-06-22 22:18:45 +0100762#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 }
764 }
Mikael Pettersson36984262009-08-15 12:58:11 +0100765
766 /* If there's no signal to deliver, we just put the saved sigmask
767 * back.
768 */
769 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
770 clear_thread_flag(TIF_RESTORE_SIGMASK);
771 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
772 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774}
775
776asmlinkage void
777do_notify_resume(struct pt_regs *regs, unsigned int thread_flags, int syscall)
778{
779 if (thread_flags & _TIF_SIGPENDING)
Mikael Pettersson36984262009-08-15 12:58:11 +0100780 do_signal(regs, syscall);
David Howellsd0420c82009-09-02 09:14:16 +0100781
782 if (thread_flags & _TIF_NOTIFY_RESUME) {
783 clear_thread_flag(TIF_NOTIFY_RESUME);
784 tracehook_notify_resume(regs);
David Howellsee18d642009-09-02 09:14:21 +0100785 if (current->replacement_session_keyring)
786 key_replace_session_keyring();
David Howellsd0420c82009-09-02 09:14:16 +0100787 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788}