blob: 0f17e06d51e60e49085beeba598c4ac4e3bba272 [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>
Russell King48be69a2013-07-24 00:29:18 +010011#include <linux/random.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/personality.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>
Russell King48be69a2013-07-24 00:29:18 +010019#include <asm/traps.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <asm/ucontext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <asm/unistd.h>
Imre Deak82c6f5a2010-04-11 15:58:27 +010022#include <asm/vfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
Linus Torvalds1da177e2005-04-16 15:20:36 -070024/*
25 * For ARM syscalls, we encode the syscall number into the instruction.
26 */
janboeee4cd582008-03-19 03:34:23 +010027#define SWI_SYS_SIGRETURN (0xef000000|(__NR_sigreturn)|(__NR_OABI_SYSCALL_BASE))
28#define SWI_SYS_RT_SIGRETURN (0xef000000|(__NR_rt_sigreturn)|(__NR_OABI_SYSCALL_BASE))
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30/*
Nicolas Pitrefcca5382006-01-18 22:38:47 +000031 * With EABI, the syscall number has to be loaded into r7.
32 */
33#define MOV_R7_NR_SIGRETURN (0xe3a07000 | (__NR_sigreturn - __NR_SYSCALL_BASE))
34#define MOV_R7_NR_RT_SIGRETURN (0xe3a07000 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
35
36/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 * For Thumb syscalls, we pass the syscall number via r7. We therefore
38 * need two 16-bit instructions.
39 */
40#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (__NR_sigreturn - __NR_SYSCALL_BASE))
41#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
42
Russell King48be69a2013-07-24 00:29:18 +010043static const unsigned long sigreturn_codes[7] = {
Nicolas Pitrefcca5382006-01-18 22:38:47 +000044 MOV_R7_NR_SIGRETURN, SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
45 MOV_R7_NR_RT_SIGRETURN, SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN,
Linus Torvalds1da177e2005-04-16 15:20:36 -070046};
47
Russell King48be69a2013-07-24 00:29:18 +010048static unsigned long signal_return_offset;
49
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +010050#ifdef CONFIG_CRUNCH
Hartley Sweeten65a50532009-08-04 23:20:45 +010051static int preserve_crunch_context(struct crunch_sigframe __user *frame)
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +010052{
53 char kbuf[sizeof(*frame) + 8];
54 struct crunch_sigframe *kframe;
55
56 /* the crunch context must be 64 bit aligned */
57 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
58 kframe->magic = CRUNCH_MAGIC;
59 kframe->size = CRUNCH_STORAGE_SIZE;
60 crunch_task_copy(current_thread_info(), &kframe->storage);
61 return __copy_to_user(frame, kframe, sizeof(*frame));
62}
63
Hartley Sweeten65a50532009-08-04 23:20:45 +010064static int restore_crunch_context(struct crunch_sigframe __user *frame)
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +010065{
66 char kbuf[sizeof(*frame) + 8];
67 struct crunch_sigframe *kframe;
68
69 /* the crunch context must be 64 bit aligned */
70 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
71 if (__copy_from_user(kframe, frame, sizeof(*frame)))
72 return -1;
73 if (kframe->magic != CRUNCH_MAGIC ||
74 kframe->size != CRUNCH_STORAGE_SIZE)
75 return -1;
76 crunch_task_restore(current_thread_info(), &kframe->storage);
77 return 0;
78}
79#endif
80
Linus Torvalds1da177e2005-04-16 15:20:36 -070081#ifdef CONFIG_IWMMXT
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
84{
Hugh Dickins69b04752005-10-29 18:16:36 -070085 char kbuf[sizeof(*frame) + 8];
86 struct iwmmxt_sigframe *kframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88 /* the iWMMXt context must be 64 bit aligned */
Hugh Dickins69b04752005-10-29 18:16:36 -070089 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +010090 kframe->magic = IWMMXT_MAGIC;
91 kframe->size = IWMMXT_STORAGE_SIZE;
Hugh Dickins69b04752005-10-29 18:16:36 -070092 iwmmxt_task_copy(current_thread_info(), &kframe->storage);
93 return __copy_to_user(frame, kframe, sizeof(*frame));
Linus Torvalds1da177e2005-04-16 15:20:36 -070094}
95
96static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
97{
Hugh Dickins69b04752005-10-29 18:16:36 -070098 char kbuf[sizeof(*frame) + 8];
99 struct iwmmxt_sigframe *kframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Hugh Dickins69b04752005-10-29 18:16:36 -0700101 /* the iWMMXt context must be 64 bit aligned */
102 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
103 if (__copy_from_user(kframe, frame, sizeof(*frame)))
104 return -1;
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100105 if (kframe->magic != IWMMXT_MAGIC ||
106 kframe->size != IWMMXT_STORAGE_SIZE)
Hugh Dickins69b04752005-10-29 18:16:36 -0700107 return -1;
108 iwmmxt_task_restore(current_thread_info(), &kframe->storage);
109 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
112#endif
113
Imre Deak82c6f5a2010-04-11 15:58:27 +0100114#ifdef CONFIG_VFP
115
116static int preserve_vfp_context(struct vfp_sigframe __user *frame)
117{
Imre Deak82c6f5a2010-04-11 15:58:27 +0100118 const unsigned long magic = VFP_MAGIC;
119 const unsigned long size = VFP_STORAGE_SIZE;
120 int err = 0;
121
Imre Deak82c6f5a2010-04-11 15:58:27 +0100122 __put_user_error(magic, &frame->magic, err);
123 __put_user_error(size, &frame->size, err);
124
Will Deacon2498814f2012-04-23 15:38:28 +0100125 if (err)
126 return -EFAULT;
Imre Deak82c6f5a2010-04-11 15:58:27 +0100127
Will Deacon2498814f2012-04-23 15:38:28 +0100128 return vfp_preserve_user_clear_hwstate(&frame->ufp, &frame->ufp_exc);
Imre Deak82c6f5a2010-04-11 15:58:27 +0100129}
130
131static int restore_vfp_context(struct vfp_sigframe __user *frame)
132{
Imre Deak82c6f5a2010-04-11 15:58:27 +0100133 unsigned long magic;
134 unsigned long size;
Imre Deak82c6f5a2010-04-11 15:58:27 +0100135 int err = 0;
136
137 __get_user_error(magic, &frame->magic, err);
138 __get_user_error(size, &frame->size, err);
139
140 if (err)
141 return -EFAULT;
142 if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
143 return -EINVAL;
144
Will Deacon2498814f2012-04-23 15:38:28 +0100145 return vfp_restore_user_hwstate(&frame->ufp, &frame->ufp_exc);
Imre Deak82c6f5a2010-04-11 15:58:27 +0100146}
147
148#endif
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 * Do a signal return; undo the signal stack. These are aligned to 64-bit.
152 */
153struct sigframe {
Russell King7d4fdc12006-06-15 20:13:25 +0100154 struct ucontext uc;
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000155 unsigned long retcode[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156};
157
158struct rt_sigframe {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 struct siginfo info;
Russell Kingcb3504e2006-06-15 20:18:25 +0100160 struct sigframe sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161};
162
Russell King68071482006-06-15 20:23:02 +0100163static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100165 struct aux_sigframe __user *aux;
Russell King68071482006-06-15 20:23:02 +0100166 sigset_t set;
167 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Russell King68071482006-06-15 20:23:02 +0100169 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
Al Viro77097ae2012-04-27 13:58:59 -0400170 if (err == 0)
Matt Fleming101d9b02012-03-05 15:05:34 -0800171 set_current_blocked(&set);
Russell King68071482006-06-15 20:23:02 +0100172
173 __get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
174 __get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
175 __get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
176 __get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
177 __get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
178 __get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
179 __get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
180 __get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
181 __get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
182 __get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
183 __get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
184 __get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
185 __get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
186 __get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
187 __get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
188 __get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
189 __get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191 err |= !valid_user_regs(regs);
192
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100193 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100194#ifdef CONFIG_CRUNCH
195 if (err == 0)
196 err |= restore_crunch_context(&aux->crunch);
197#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198#ifdef CONFIG_IWMMXT
199 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
200 err |= restore_iwmmxt_context(&aux->iwmmxt);
201#endif
202#ifdef CONFIG_VFP
Imre Deak82c6f5a2010-04-11 15:58:27 +0100203 if (err == 0)
204 err |= restore_vfp_context(&aux->vfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205#endif
206
207 return err;
208}
209
210asmlinkage int sys_sigreturn(struct pt_regs *regs)
211{
212 struct sigframe __user *frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 /* Always make any pending restarted system calls return -EINTR */
215 current_thread_info()->restart_block.fn = do_no_restart_syscall;
216
217 /*
218 * Since we stacked the signal on a 64-bit boundary,
219 * then 'sp' should be word aligned here. If it's
220 * not, then the user is trying to mess with us.
221 */
222 if (regs->ARM_sp & 7)
223 goto badframe;
224
225 frame = (struct sigframe __user *)regs->ARM_sp;
226
227 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
228 goto badframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Russell King68071482006-06-15 20:23:02 +0100230 if (restore_sigframe(regs, frame))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 goto badframe;
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 return regs->ARM_r0;
234
235badframe:
236 force_sig(SIGSEGV, current);
237 return 0;
238}
239
240asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
241{
242 struct rt_sigframe __user *frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 /* Always make any pending restarted system calls return -EINTR */
245 current_thread_info()->restart_block.fn = do_no_restart_syscall;
246
247 /*
248 * Since we stacked the signal on a 64-bit boundary,
249 * then 'sp' should be word aligned here. If it's
250 * not, then the user is trying to mess with us.
251 */
252 if (regs->ARM_sp & 7)
253 goto badframe;
254
255 frame = (struct rt_sigframe __user *)regs->ARM_sp;
256
257 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
258 goto badframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Russell King68071482006-06-15 20:23:02 +0100260 if (restore_sigframe(regs, &frame->sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 goto badframe;
262
Al Viroec93ac82012-12-23 01:52:54 -0500263 if (restore_altstack(&frame->sig.uc.uc_stack))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 goto badframe;
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 return regs->ARM_r0;
267
268badframe:
269 force_sig(SIGSEGV, current);
270 return 0;
271}
272
273static int
Russell Kingaca6ca12006-06-15 20:28:03 +0100274setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100276 struct aux_sigframe __user *aux;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 int err = 0;
278
Russell Kingaca6ca12006-06-15 20:28:03 +0100279 __put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
280 __put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
281 __put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
282 __put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
283 __put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
284 __put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
285 __put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
286 __put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
287 __put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
288 __put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
289 __put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
290 __put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
291 __put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
292 __put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
293 __put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
294 __put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
295 __put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Russell Kingaca6ca12006-06-15 20:28:03 +0100297 __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
298 __put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
299 __put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
300 __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Russell Kingaca6ca12006-06-15 20:28:03 +0100302 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100304 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100305#ifdef CONFIG_CRUNCH
306 if (err == 0)
307 err |= preserve_crunch_context(&aux->crunch);
308#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309#ifdef CONFIG_IWMMXT
310 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
311 err |= preserve_iwmmxt_context(&aux->iwmmxt);
312#endif
313#ifdef CONFIG_VFP
Imre Deak82c6f5a2010-04-11 15:58:27 +0100314 if (err == 0)
315 err |= preserve_vfp_context(&aux->vfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316#endif
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100317 __put_user_error(0, &aux->end_magic, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
319 return err;
320}
321
322static inline void __user *
Al Viro7e243642012-11-07 17:53:13 -0500323get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
Al Viro7e243642012-11-07 17:53:13 -0500325 unsigned long sp = sigsp(regs->ARM_sp, ksig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 void __user *frame;
327
328 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 * ATPCS B01 mandates 8-byte alignment
330 */
331 frame = (void __user *)((sp - framesize) & ~7);
332
333 /*
334 * Check that we can actually write to the signal frame.
335 */
336 if (!access_ok(VERIFY_WRITE, frame, framesize))
337 frame = NULL;
338
339 return frame;
340}
341
Al Viro7e243642012-11-07 17:53:13 -0500342/*
343 * translate the signal
344 */
345static inline int map_sig(int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346{
Al Viro7e243642012-11-07 17:53:13 -0500347 struct thread_info *thread = current_thread_info();
348 if (sig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
349 sig = thread->exec_domain->signal_invmap[sig];
350 return sig;
351}
352
353static int
354setup_return(struct pt_regs *regs, struct ksignal *ksig,
355 unsigned long __user *rc, void __user *frame)
356{
357 unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 unsigned long retcode;
359 int thumb = 0;
Russell King53399052011-02-20 12:22:52 +0000360 unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);
361
362 cpsr |= PSR_ENDSTATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364 /*
365 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
366 */
Al Viro7e243642012-11-07 17:53:13 -0500367 if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
369
370#ifdef CONFIG_ARM_THUMB
371 if (elf_hwcap & HWCAP_THUMB) {
372 /*
373 * The LSB of the handler determines if we're going to
374 * be using THUMB or ARM mode for this signal handler.
375 */
376 thumb = handler & 1;
377
Catalin Marinasd71e1352009-05-30 14:00:15 +0100378 if (thumb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 cpsr |= PSR_T_BIT;
Catalin Marinasd71e1352009-05-30 14:00:15 +0100380#if __LINUX_ARM_ARCH__ >= 7
381 /* clear the If-Then Thumb-2 execution state */
382 cpsr &= ~PSR_IT_MASK;
383#endif
384 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 cpsr &= ~PSR_T_BIT;
386 }
387#endif
388
Al Viro7e243642012-11-07 17:53:13 -0500389 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
390 retcode = (unsigned long)ksig->ka.sa.sa_restorer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 } else {
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000392 unsigned int idx = thumb << 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Al Viro7e243642012-11-07 17:53:13 -0500394 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000395 idx += 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Jonathan Austin9dfc28b2013-04-18 18:37:24 +0100397 /*
398 * Put the sigreturn code on the stack no matter which return
399 * mechanism we use in order to remain ABI compliant
400 */
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000401 if (__put_user(sigreturn_codes[idx], rc) ||
402 __put_user(sigreturn_codes[idx+1], rc+1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 return 1;
404
Jonathan Austin9dfc28b2013-04-18 18:37:24 +0100405 if ((cpsr & MODE32_BIT) && !IS_ENABLED(CONFIG_ARM_MPU)) {
Russell King48be69a2013-07-24 00:29:18 +0100406 struct mm_struct *mm = current->mm;
407
Russell Kinge00d3492005-06-22 20:26:05 +0100408 /*
Russell King48be69a2013-07-24 00:29:18 +0100409 * 32-bit code can use the signal return page
410 * except when the MPU has protected the vectors
411 * page from PL0
Russell Kinge00d3492005-06-22 20:26:05 +0100412 */
Russell King48be69a2013-07-24 00:29:18 +0100413 retcode = mm->context.sigpage + signal_return_offset +
414 (idx << 2) + thumb;
Russell Kinge00d3492005-06-22 20:26:05 +0100415 } else {
416 /*
417 * Ensure that the instruction cache sees
418 * the return code written onto the stack.
419 */
420 flush_icache_range((unsigned long)rc,
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000421 (unsigned long)(rc + 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Russell Kinge00d3492005-06-22 20:26:05 +0100423 retcode = ((unsigned long)rc) + thumb;
424 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
426
Al Viro7e243642012-11-07 17:53:13 -0500427 regs->ARM_r0 = map_sig(ksig->sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 regs->ARM_sp = (unsigned long)frame;
429 regs->ARM_lr = retcode;
430 regs->ARM_pc = handler;
431 regs->ARM_cpsr = cpsr;
432
433 return 0;
434}
435
436static int
Al Viro7e243642012-11-07 17:53:13 -0500437setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
Al Viro7e243642012-11-07 17:53:13 -0500439 struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 int err = 0;
441
442 if (!frame)
443 return 1;
444
Russell Kingca195cf2006-06-24 22:41:09 +0100445 /*
446 * Set uc.uc_flags to a value which sc.trap_no would never have.
447 */
448 __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Russell Kingaca6ca12006-06-15 20:28:03 +0100450 err |= setup_sigframe(frame, regs, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 if (err == 0)
Al Viro7e243642012-11-07 17:53:13 -0500452 err = setup_return(regs, ksig, frame->retcode, frame);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 return err;
455}
456
457static int
Al Viro7e243642012-11-07 17:53:13 -0500458setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Al Viro7e243642012-11-07 17:53:13 -0500460 struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 int err = 0;
462
463 if (!frame)
464 return 1;
465
Al Viro7e243642012-11-07 17:53:13 -0500466 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Russell Kingcb3504e2006-06-15 20:18:25 +0100468 __put_user_error(0, &frame->sig.uc.uc_flags, err);
469 __put_user_error(NULL, &frame->sig.uc.uc_link, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
Al Viroec93ac82012-12-23 01:52:54 -0500471 err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
Russell Kingaca6ca12006-06-15 20:28:03 +0100472 err |= setup_sigframe(&frame->sig, regs, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 if (err == 0)
Al Viro7e243642012-11-07 17:53:13 -0500474 err = setup_return(regs, ksig, frame->sig.retcode, frame);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
476 if (err == 0) {
477 /*
478 * For realtime signals we must also set the second and third
479 * arguments for the signal handler.
480 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
481 */
482 regs->ARM_r1 = (unsigned long)&frame->info;
Russell Kingcb3504e2006-06-15 20:18:25 +0100483 regs->ARM_r2 = (unsigned long)&frame->sig.uc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 }
485
486 return err;
487}
488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489/*
490 * OK, we're invoking a handler
491 */
Al Viro7e243642012-11-07 17:53:13 -0500492static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
Al Virob7f9a112012-05-02 09:59:21 -0400494 sigset_t *oldset = sigmask_to_save();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 int ret;
496
497 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 * Set up the stack frame
499 */
Al Viro7e243642012-11-07 17:53:13 -0500500 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
501 ret = setup_rt_frame(ksig, oldset, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 else
Al Viro7e243642012-11-07 17:53:13 -0500503 ret = setup_frame(ksig, oldset, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 /*
506 * Check that the resulting registers are actually sane.
507 */
508 ret |= !valid_user_regs(regs);
509
Al Viro7e243642012-11-07 17:53:13 -0500510 signal_setup_done(ret, ksig, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511}
512
513/*
514 * Note that 'init' is a special process: it doesn't get signals it doesn't
515 * want to handle. Thus you cannot kill init even with a SIGKILL even by
516 * mistake.
517 *
518 * Note that we go through the signals twice: once to check the signals that
519 * the kernel can handle, and then we build all the user-level signal handling
520 * stack-frames in one go after that.
521 */
Al Viro81783782012-07-19 17:48:21 +0100522static int do_signal(struct pt_regs *regs, int syscall)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523{
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100524 unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
Al Viro7e243642012-11-07 17:53:13 -0500525 struct ksignal ksig;
Al Viro81783782012-07-19 17:48:21 +0100526 int restart = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
528 /*
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100529 * If we were from a system call, check for system call restarting...
530 */
531 if (syscall) {
532 continue_addr = regs->ARM_pc;
533 restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
534 retval = regs->ARM_r0;
535
536 /*
537 * Prepare for system call restart. We do this here so that a
538 * debugger will see the already changed PSW.
539 */
540 switch (retval) {
Al Viro81783782012-07-19 17:48:21 +0100541 case -ERESTART_RESTARTBLOCK:
Al Viro66285212012-07-19 17:48:50 +0100542 restart -= 2;
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100543 case -ERESTARTNOHAND:
544 case -ERESTARTSYS:
545 case -ERESTARTNOINTR:
Al Viro81783782012-07-19 17:48:21 +0100546 restart++;
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100547 regs->ARM_r0 = regs->ARM_ORIG_r0;
548 regs->ARM_pc = restart_addr;
549 break;
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100550 }
551 }
552
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100553 /*
554 * Get the signal to deliver. When running under ptrace, at this
555 * point the debugger may change all our registers ...
556 */
Al Viro81783782012-07-19 17:48:21 +0100557 /*
558 * Depending on the signal settings we may need to revert the
559 * decision to restart the system call. But skip this if a
560 * debugger has chosen to restart at a different PC.
561 */
Al Viro7e243642012-11-07 17:53:13 -0500562 if (get_signal(&ksig)) {
563 /* handler */
564 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
Will Deaconad82cc02012-07-19 17:46:44 +0100565 if (retval == -ERESTARTNOHAND ||
566 retval == -ERESTART_RESTARTBLOCK
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100567 || (retval == -ERESTARTSYS
Al Viro7e243642012-11-07 17:53:13 -0500568 && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100569 regs->ARM_r0 = -EINTR;
570 regs->ARM_pc = continue_addr;
571 }
572 }
Al Viro7e243642012-11-07 17:53:13 -0500573 handle_signal(&ksig, regs);
574 } else {
575 /* no handler */
576 restore_saved_sigmask();
577 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
578 regs->ARM_pc = continue_addr;
579 return restart;
580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 }
Al Viro7e243642012-11-07 17:53:13 -0500582 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583}
584
Al Viro81783782012-07-19 17:48:21 +0100585asmlinkage int
Al Viro0a267fa2012-07-19 17:47:55 +0100586do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
Al Viro0a267fa2012-07-19 17:47:55 +0100588 do {
589 if (likely(thread_flags & _TIF_NEED_RESCHED)) {
590 schedule();
591 } else {
592 if (unlikely(!user_mode(regs)))
Al Viro81783782012-07-19 17:48:21 +0100593 return 0;
Al Viro0a267fa2012-07-19 17:47:55 +0100594 local_irq_enable();
595 if (thread_flags & _TIF_SIGPENDING) {
Al Viro66285212012-07-19 17:48:50 +0100596 int restart = do_signal(regs, syscall);
597 if (unlikely(restart)) {
Al Viro81783782012-07-19 17:48:21 +0100598 /*
599 * Restart without handlers.
600 * Deal with it without leaving
601 * the kernel space.
602 */
Al Viro66285212012-07-19 17:48:50 +0100603 return restart;
Al Viro81783782012-07-19 17:48:21 +0100604 }
Al Viro0a267fa2012-07-19 17:47:55 +0100605 syscall = 0;
606 } else {
607 clear_thread_flag(TIF_NOTIFY_RESUME);
608 tracehook_notify_resume(regs);
609 }
610 }
611 local_irq_disable();
612 thread_flags = current_thread_info()->flags;
613 } while (thread_flags & _TIF_WORK_MASK);
Al Viro81783782012-07-19 17:48:21 +0100614 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615}
Russell King48be69a2013-07-24 00:29:18 +0100616
617static struct page *signal_page;
618
619struct page *get_signal_page(void)
620{
621 if (!signal_page) {
622 unsigned long ptr;
623 unsigned offset;
624 void *addr;
625
626 signal_page = alloc_pages(GFP_KERNEL, 0);
627
628 if (!signal_page)
629 return NULL;
630
631 addr = page_address(signal_page);
632
633 /* Give the signal return code some randomness */
634 offset = 0x200 + (get_random_int() & 0x7fc);
635 signal_return_offset = offset;
636
637 /*
638 * Copy signal return handlers into the vector page, and
639 * set sigreturn to be a pointer to these.
640 */
641 memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
642
643 ptr = (unsigned long)addr + offset;
644 flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
645 }
646
647 return signal_page;
648}