blob: 023ac905e4c38c9858e5c644a374c343a0be334b [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>
David A. Longc7edc9e2014-03-07 11:23:04 -050016#include <linux/uprobes.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
Russell Kingee90dab2006-11-09 14:20:47 +000018#include <asm/elf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <asm/cacheflush.h>
Russell King48be69a2013-07-24 00:29:18 +010020#include <asm/traps.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <asm/ucontext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <asm/unistd.h>
Imre Deak82c6f5a2010-04-11 15:58:27 +010023#include <asm/vfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Victor Kamensky574e2b52013-08-27 22:41:57 -070025extern const unsigned long sigreturn_codes[7];
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Russell King48be69a2013-07-24 00:29:18 +010027static unsigned long signal_return_offset;
28
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +010029#ifdef CONFIG_CRUNCH
Hartley Sweeten65a50532009-08-04 23:20:45 +010030static int preserve_crunch_context(struct crunch_sigframe __user *frame)
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +010031{
32 char kbuf[sizeof(*frame) + 8];
33 struct crunch_sigframe *kframe;
34
35 /* the crunch context must be 64 bit aligned */
36 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
37 kframe->magic = CRUNCH_MAGIC;
38 kframe->size = CRUNCH_STORAGE_SIZE;
39 crunch_task_copy(current_thread_info(), &kframe->storage);
40 return __copy_to_user(frame, kframe, sizeof(*frame));
41}
42
Hartley Sweeten65a50532009-08-04 23:20:45 +010043static int restore_crunch_context(struct crunch_sigframe __user *frame)
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +010044{
45 char kbuf[sizeof(*frame) + 8];
46 struct crunch_sigframe *kframe;
47
48 /* the crunch context must be 64 bit aligned */
49 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
50 if (__copy_from_user(kframe, frame, sizeof(*frame)))
51 return -1;
52 if (kframe->magic != CRUNCH_MAGIC ||
53 kframe->size != CRUNCH_STORAGE_SIZE)
54 return -1;
55 crunch_task_restore(current_thread_info(), &kframe->storage);
56 return 0;
57}
58#endif
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#ifdef CONFIG_IWMMXT
61
Linus Torvalds1da177e2005-04-16 15:20:36 -070062static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
63{
Hugh Dickins69b04752005-10-29 18:16:36 -070064 char kbuf[sizeof(*frame) + 8];
65 struct iwmmxt_sigframe *kframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67 /* the iWMMXt context must be 64 bit aligned */
Hugh Dickins69b04752005-10-29 18:16:36 -070068 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +010069 kframe->magic = IWMMXT_MAGIC;
70 kframe->size = IWMMXT_STORAGE_SIZE;
Hugh Dickins69b04752005-10-29 18:16:36 -070071 iwmmxt_task_copy(current_thread_info(), &kframe->storage);
72 return __copy_to_user(frame, kframe, sizeof(*frame));
Linus Torvalds1da177e2005-04-16 15:20:36 -070073}
74
75static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
76{
Hugh Dickins69b04752005-10-29 18:16:36 -070077 char kbuf[sizeof(*frame) + 8];
78 struct iwmmxt_sigframe *kframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Hugh Dickins69b04752005-10-29 18:16:36 -070080 /* the iWMMXt context must be 64 bit aligned */
81 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
82 if (__copy_from_user(kframe, frame, sizeof(*frame)))
83 return -1;
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +010084 if (kframe->magic != IWMMXT_MAGIC ||
85 kframe->size != IWMMXT_STORAGE_SIZE)
Hugh Dickins69b04752005-10-29 18:16:36 -070086 return -1;
87 iwmmxt_task_restore(current_thread_info(), &kframe->storage);
88 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089}
90
91#endif
92
Imre Deak82c6f5a2010-04-11 15:58:27 +010093#ifdef CONFIG_VFP
94
95static int preserve_vfp_context(struct vfp_sigframe __user *frame)
96{
Imre Deak82c6f5a2010-04-11 15:58:27 +010097 const unsigned long magic = VFP_MAGIC;
98 const unsigned long size = VFP_STORAGE_SIZE;
99 int err = 0;
100
Imre Deak82c6f5a2010-04-11 15:58:27 +0100101 __put_user_error(magic, &frame->magic, err);
102 __put_user_error(size, &frame->size, err);
103
Will Deacon2498814f2012-04-23 15:38:28 +0100104 if (err)
105 return -EFAULT;
Imre Deak82c6f5a2010-04-11 15:58:27 +0100106
Will Deacon2498814f2012-04-23 15:38:28 +0100107 return vfp_preserve_user_clear_hwstate(&frame->ufp, &frame->ufp_exc);
Imre Deak82c6f5a2010-04-11 15:58:27 +0100108}
109
110static int restore_vfp_context(struct vfp_sigframe __user *frame)
111{
Imre Deak82c6f5a2010-04-11 15:58:27 +0100112 unsigned long magic;
113 unsigned long size;
Imre Deak82c6f5a2010-04-11 15:58:27 +0100114 int err = 0;
115
116 __get_user_error(magic, &frame->magic, err);
117 __get_user_error(size, &frame->size, err);
118
119 if (err)
120 return -EFAULT;
121 if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
122 return -EINVAL;
123
Will Deacon2498814f2012-04-23 15:38:28 +0100124 return vfp_restore_user_hwstate(&frame->ufp, &frame->ufp_exc);
Imre Deak82c6f5a2010-04-11 15:58:27 +0100125}
126
127#endif
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 * Do a signal return; undo the signal stack. These are aligned to 64-bit.
131 */
132struct sigframe {
Russell King7d4fdc12006-06-15 20:13:25 +0100133 struct ucontext uc;
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000134 unsigned long retcode[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135};
136
137struct rt_sigframe {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 struct siginfo info;
Russell Kingcb3504e2006-06-15 20:18:25 +0100139 struct sigframe sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140};
141
Russell King68071482006-06-15 20:23:02 +0100142static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143{
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100144 struct aux_sigframe __user *aux;
Russell King68071482006-06-15 20:23:02 +0100145 sigset_t set;
146 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Russell King68071482006-06-15 20:23:02 +0100148 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
Al Viro77097ae2012-04-27 13:58:59 -0400149 if (err == 0)
Matt Fleming101d9b02012-03-05 15:05:34 -0800150 set_current_blocked(&set);
Russell King68071482006-06-15 20:23:02 +0100151
152 __get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
153 __get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
154 __get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
155 __get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
156 __get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
157 __get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
158 __get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
159 __get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
160 __get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
161 __get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
162 __get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
163 __get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
164 __get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
165 __get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
166 __get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
167 __get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
168 __get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 err |= !valid_user_regs(regs);
171
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100172 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100173#ifdef CONFIG_CRUNCH
174 if (err == 0)
175 err |= restore_crunch_context(&aux->crunch);
176#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177#ifdef CONFIG_IWMMXT
178 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
179 err |= restore_iwmmxt_context(&aux->iwmmxt);
180#endif
181#ifdef CONFIG_VFP
Imre Deak82c6f5a2010-04-11 15:58:27 +0100182 if (err == 0)
183 err |= restore_vfp_context(&aux->vfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184#endif
185
186 return err;
187}
188
189asmlinkage int sys_sigreturn(struct pt_regs *regs)
190{
191 struct sigframe __user *frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
193 /* Always make any pending restarted system calls return -EINTR */
Andy Lutomirskif56141e2015-02-12 15:01:14 -0800194 current->restart_block.fn = do_no_restart_syscall;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
196 /*
197 * Since we stacked the signal on a 64-bit boundary,
198 * then 'sp' should be word aligned here. If it's
199 * not, then the user is trying to mess with us.
200 */
201 if (regs->ARM_sp & 7)
202 goto badframe;
203
204 frame = (struct sigframe __user *)regs->ARM_sp;
205
206 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
207 goto badframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Russell King68071482006-06-15 20:23:02 +0100209 if (restore_sigframe(regs, frame))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 goto badframe;
211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 return regs->ARM_r0;
213
214badframe:
215 force_sig(SIGSEGV, current);
216 return 0;
217}
218
219asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
220{
221 struct rt_sigframe __user *frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 /* Always make any pending restarted system calls return -EINTR */
Andy Lutomirskif56141e2015-02-12 15:01:14 -0800224 current->restart_block.fn = do_no_restart_syscall;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 /*
227 * Since we stacked the signal on a 64-bit boundary,
228 * then 'sp' should be word aligned here. If it's
229 * not, then the user is trying to mess with us.
230 */
231 if (regs->ARM_sp & 7)
232 goto badframe;
233
234 frame = (struct rt_sigframe __user *)regs->ARM_sp;
235
236 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
237 goto badframe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Russell King68071482006-06-15 20:23:02 +0100239 if (restore_sigframe(regs, &frame->sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 goto badframe;
241
Al Viroec93ac82012-12-23 01:52:54 -0500242 if (restore_altstack(&frame->sig.uc.uc_stack))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 goto badframe;
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 return regs->ARM_r0;
246
247badframe:
248 force_sig(SIGSEGV, current);
249 return 0;
250}
251
252static int
Russell Kingaca6ca12006-06-15 20:28:03 +0100253setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100255 struct aux_sigframe __user *aux;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 int err = 0;
257
Russell Kingaca6ca12006-06-15 20:28:03 +0100258 __put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
259 __put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
260 __put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
261 __put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
262 __put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
263 __put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
264 __put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
265 __put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
266 __put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
267 __put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
268 __put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
269 __put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
270 __put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
271 __put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
272 __put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
273 __put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
274 __put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Russell Kingaca6ca12006-06-15 20:28:03 +0100276 __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
277 __put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
278 __put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
279 __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Russell Kingaca6ca12006-06-15 20:28:03 +0100281 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100283 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
Lennert Buytenhek3bec6ded2006-06-27 22:56:18 +0100284#ifdef CONFIG_CRUNCH
285 if (err == 0)
286 err |= preserve_crunch_context(&aux->crunch);
287#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288#ifdef CONFIG_IWMMXT
289 if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
290 err |= preserve_iwmmxt_context(&aux->iwmmxt);
291#endif
292#ifdef CONFIG_VFP
Imre Deak82c6f5a2010-04-11 15:58:27 +0100293 if (err == 0)
294 err |= preserve_vfp_context(&aux->vfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295#endif
Daniel Jacobowitz85fe0682006-06-24 23:46:21 +0100296 __put_user_error(0, &aux->end_magic, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
298 return err;
299}
300
301static inline void __user *
Al Viro7e243642012-11-07 17:53:13 -0500302get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303{
Al Viro7e243642012-11-07 17:53:13 -0500304 unsigned long sp = sigsp(regs->ARM_sp, ksig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 void __user *frame;
306
307 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 * ATPCS B01 mandates 8-byte alignment
309 */
310 frame = (void __user *)((sp - framesize) & ~7);
311
312 /*
313 * Check that we can actually write to the signal frame.
314 */
315 if (!access_ok(VERIFY_WRITE, frame, framesize))
316 frame = NULL;
317
318 return frame;
319}
320
Al Viro7e243642012-11-07 17:53:13 -0500321/*
322 * translate the signal
323 */
324static inline int map_sig(int sig)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325{
Al Viro7e243642012-11-07 17:53:13 -0500326 struct thread_info *thread = current_thread_info();
327 if (sig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
328 sig = thread->exec_domain->signal_invmap[sig];
329 return sig;
330}
331
332static int
333setup_return(struct pt_regs *regs, struct ksignal *ksig,
334 unsigned long __user *rc, void __user *frame)
335{
336 unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 unsigned long retcode;
338 int thumb = 0;
Russell King53399052011-02-20 12:22:52 +0000339 unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);
340
341 cpsr |= PSR_ENDSTATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
343 /*
344 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
345 */
Al Viro7e243642012-11-07 17:53:13 -0500346 if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
348
349#ifdef CONFIG_ARM_THUMB
350 if (elf_hwcap & HWCAP_THUMB) {
351 /*
352 * The LSB of the handler determines if we're going to
353 * be using THUMB or ARM mode for this signal handler.
354 */
355 thumb = handler & 1;
356
T.J. Purtell6ecf8302013-11-06 18:38:05 +0100357#if __LINUX_ARM_ARCH__ >= 7
358 /*
359 * Clear the If-Then Thumb-2 execution state
360 * ARM spec requires this to be all 000s in ARM mode
361 * Snapdragon S4/Krait misbehaves on a Thumb=>ARM
362 * signal transition without this.
363 */
364 cpsr &= ~PSR_IT_MASK;
365#endif
366
Catalin Marinasd71e1352009-05-30 14:00:15 +0100367 if (thumb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 cpsr |= PSR_T_BIT;
Catalin Marinasd71e1352009-05-30 14:00:15 +0100369 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 cpsr &= ~PSR_T_BIT;
371 }
372#endif
373
Al Viro7e243642012-11-07 17:53:13 -0500374 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
375 retcode = (unsigned long)ksig->ka.sa.sa_restorer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 } else {
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000377 unsigned int idx = thumb << 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Al Viro7e243642012-11-07 17:53:13 -0500379 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000380 idx += 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Jonathan Austin9dfc28b2013-04-18 18:37:24 +0100382 /*
383 * Put the sigreturn code on the stack no matter which return
384 * mechanism we use in order to remain ABI compliant
385 */
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000386 if (__put_user(sigreturn_codes[idx], rc) ||
387 __put_user(sigreturn_codes[idx+1], rc+1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return 1;
389
Russell King8c0cc8a2013-08-03 10:39:51 +0100390#ifdef CONFIG_MMU
391 if (cpsr & MODE32_BIT) {
Russell King48be69a2013-07-24 00:29:18 +0100392 struct mm_struct *mm = current->mm;
393
Russell Kinge00d3492005-06-22 20:26:05 +0100394 /*
Russell King48be69a2013-07-24 00:29:18 +0100395 * 32-bit code can use the signal return page
396 * except when the MPU has protected the vectors
397 * page from PL0
Russell Kinge00d3492005-06-22 20:26:05 +0100398 */
Russell King48be69a2013-07-24 00:29:18 +0100399 retcode = mm->context.sigpage + signal_return_offset +
400 (idx << 2) + thumb;
Russell King8c0cc8a2013-08-03 10:39:51 +0100401 } else
402#endif
403 {
Russell Kinge00d3492005-06-22 20:26:05 +0100404 /*
405 * Ensure that the instruction cache sees
406 * the return code written onto the stack.
407 */
408 flush_icache_range((unsigned long)rc,
Nicolas Pitrefcca5382006-01-18 22:38:47 +0000409 (unsigned long)(rc + 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Russell Kinge00d3492005-06-22 20:26:05 +0100411 retcode = ((unsigned long)rc) + thumb;
412 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 }
414
Al Viro7e243642012-11-07 17:53:13 -0500415 regs->ARM_r0 = map_sig(ksig->sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 regs->ARM_sp = (unsigned long)frame;
417 regs->ARM_lr = retcode;
418 regs->ARM_pc = handler;
419 regs->ARM_cpsr = cpsr;
420
421 return 0;
422}
423
424static int
Al Viro7e243642012-11-07 17:53:13 -0500425setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
Al Viro7e243642012-11-07 17:53:13 -0500427 struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 int err = 0;
429
430 if (!frame)
431 return 1;
432
Russell Kingca195cf2006-06-24 22:41:09 +0100433 /*
434 * Set uc.uc_flags to a value which sc.trap_no would never have.
435 */
436 __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Russell Kingaca6ca12006-06-15 20:28:03 +0100438 err |= setup_sigframe(frame, regs, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 if (err == 0)
Al Viro7e243642012-11-07 17:53:13 -0500440 err = setup_return(regs, ksig, frame->retcode, frame);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 return err;
443}
444
445static int
Al Viro7e243642012-11-07 17:53:13 -0500446setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447{
Al Viro7e243642012-11-07 17:53:13 -0500448 struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 int err = 0;
450
451 if (!frame)
452 return 1;
453
Al Viro7e243642012-11-07 17:53:13 -0500454 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Russell Kingcb3504e2006-06-15 20:18:25 +0100456 __put_user_error(0, &frame->sig.uc.uc_flags, err);
457 __put_user_error(NULL, &frame->sig.uc.uc_link, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Al Viroec93ac82012-12-23 01:52:54 -0500459 err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
Russell Kingaca6ca12006-06-15 20:28:03 +0100460 err |= setup_sigframe(&frame->sig, regs, set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 if (err == 0)
Al Viro7e243642012-11-07 17:53:13 -0500462 err = setup_return(regs, ksig, frame->sig.retcode, frame);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
464 if (err == 0) {
465 /*
466 * For realtime signals we must also set the second and third
467 * arguments for the signal handler.
468 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
469 */
470 regs->ARM_r1 = (unsigned long)&frame->info;
Russell Kingcb3504e2006-06-15 20:18:25 +0100471 regs->ARM_r2 = (unsigned long)&frame->sig.uc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 }
473
474 return err;
475}
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477/*
478 * OK, we're invoking a handler
479 */
Al Viro7e243642012-11-07 17:53:13 -0500480static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481{
Al Virob7f9a112012-05-02 09:59:21 -0400482 sigset_t *oldset = sigmask_to_save();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 int ret;
484
485 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 * Set up the stack frame
487 */
Al Viro7e243642012-11-07 17:53:13 -0500488 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
489 ret = setup_rt_frame(ksig, oldset, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 else
Al Viro7e243642012-11-07 17:53:13 -0500491 ret = setup_frame(ksig, oldset, regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493 /*
494 * Check that the resulting registers are actually sane.
495 */
496 ret |= !valid_user_regs(regs);
497
Al Viro7e243642012-11-07 17:53:13 -0500498 signal_setup_done(ret, ksig, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
500
501/*
502 * Note that 'init' is a special process: it doesn't get signals it doesn't
503 * want to handle. Thus you cannot kill init even with a SIGKILL even by
504 * mistake.
505 *
506 * Note that we go through the signals twice: once to check the signals that
507 * the kernel can handle, and then we build all the user-level signal handling
508 * stack-frames in one go after that.
509 */
Al Viro81783782012-07-19 17:48:21 +0100510static int do_signal(struct pt_regs *regs, int syscall)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100512 unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
Al Viro7e243642012-11-07 17:53:13 -0500513 struct ksignal ksig;
Al Viro81783782012-07-19 17:48:21 +0100514 int restart = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
516 /*
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100517 * If we were from a system call, check for system call restarting...
518 */
519 if (syscall) {
520 continue_addr = regs->ARM_pc;
521 restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
522 retval = regs->ARM_r0;
523
524 /*
525 * Prepare for system call restart. We do this here so that a
526 * debugger will see the already changed PSW.
527 */
528 switch (retval) {
Al Viro81783782012-07-19 17:48:21 +0100529 case -ERESTART_RESTARTBLOCK:
Al Viro66285212012-07-19 17:48:50 +0100530 restart -= 2;
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100531 case -ERESTARTNOHAND:
532 case -ERESTARTSYS:
533 case -ERESTARTNOINTR:
Al Viro81783782012-07-19 17:48:21 +0100534 restart++;
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100535 regs->ARM_r0 = regs->ARM_ORIG_r0;
536 regs->ARM_pc = restart_addr;
537 break;
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100538 }
539 }
540
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100541 /*
542 * Get the signal to deliver. When running under ptrace, at this
543 * point the debugger may change all our registers ...
544 */
Al Viro81783782012-07-19 17:48:21 +0100545 /*
546 * Depending on the signal settings we may need to revert the
547 * decision to restart the system call. But skip this if a
548 * debugger has chosen to restart at a different PC.
549 */
Al Viro7e243642012-11-07 17:53:13 -0500550 if (get_signal(&ksig)) {
551 /* handler */
552 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
Will Deaconad82cc02012-07-19 17:46:44 +0100553 if (retval == -ERESTARTNOHAND ||
554 retval == -ERESTART_RESTARTBLOCK
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100555 || (retval == -ERESTARTSYS
Al Viro7e243642012-11-07 17:53:13 -0500556 && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
Arnd Bergmann2af68df2011-05-03 18:32:55 +0100557 regs->ARM_r0 = -EINTR;
558 regs->ARM_pc = continue_addr;
559 }
560 }
Al Viro7e243642012-11-07 17:53:13 -0500561 handle_signal(&ksig, regs);
562 } else {
563 /* no handler */
564 restore_saved_sigmask();
565 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
566 regs->ARM_pc = continue_addr;
567 return restart;
568 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 }
Al Viro7e243642012-11-07 17:53:13 -0500570 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571}
572
Al Viro81783782012-07-19 17:48:21 +0100573asmlinkage int
Al Viro0a267fa2012-07-19 17:47:55 +0100574do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575{
Al Viro0a267fa2012-07-19 17:47:55 +0100576 do {
577 if (likely(thread_flags & _TIF_NEED_RESCHED)) {
578 schedule();
579 } else {
580 if (unlikely(!user_mode(regs)))
Al Viro81783782012-07-19 17:48:21 +0100581 return 0;
Al Viro0a267fa2012-07-19 17:47:55 +0100582 local_irq_enable();
583 if (thread_flags & _TIF_SIGPENDING) {
Al Viro66285212012-07-19 17:48:50 +0100584 int restart = do_signal(regs, syscall);
585 if (unlikely(restart)) {
Al Viro81783782012-07-19 17:48:21 +0100586 /*
587 * Restart without handlers.
588 * Deal with it without leaving
589 * the kernel space.
590 */
Al Viro66285212012-07-19 17:48:50 +0100591 return restart;
Al Viro81783782012-07-19 17:48:21 +0100592 }
Al Viro0a267fa2012-07-19 17:47:55 +0100593 syscall = 0;
David A. Longc7edc9e2014-03-07 11:23:04 -0500594 } else if (thread_flags & _TIF_UPROBE) {
David A. Longc7edc9e2014-03-07 11:23:04 -0500595 uprobe_notify_resume(regs);
Al Viro0a267fa2012-07-19 17:47:55 +0100596 } else {
597 clear_thread_flag(TIF_NOTIFY_RESUME);
598 tracehook_notify_resume(regs);
599 }
600 }
601 local_irq_disable();
602 thread_flags = current_thread_info()->flags;
603 } while (thread_flags & _TIF_WORK_MASK);
Al Viro81783782012-07-19 17:48:21 +0100604 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605}
Russell King48be69a2013-07-24 00:29:18 +0100606
Russell King48be69a2013-07-24 00:29:18 +0100607struct page *get_signal_page(void)
608{
Russell Kinge0d40752013-08-03 10:30:05 +0100609 unsigned long ptr;
610 unsigned offset;
611 struct page *page;
612 void *addr;
Russell King48be69a2013-07-24 00:29:18 +0100613
Russell Kinge0d40752013-08-03 10:30:05 +0100614 page = alloc_pages(GFP_KERNEL, 0);
Russell King48be69a2013-07-24 00:29:18 +0100615
Russell Kinge0d40752013-08-03 10:30:05 +0100616 if (!page)
617 return NULL;
Russell King48be69a2013-07-24 00:29:18 +0100618
Russell Kinge0d40752013-08-03 10:30:05 +0100619 addr = page_address(page);
Russell King48be69a2013-07-24 00:29:18 +0100620
Russell Kinge0d40752013-08-03 10:30:05 +0100621 /* Give the signal return code some randomness */
622 offset = 0x200 + (get_random_int() & 0x7fc);
623 signal_return_offset = offset;
Russell King48be69a2013-07-24 00:29:18 +0100624
Russell Kinge0d40752013-08-03 10:30:05 +0100625 /*
626 * Copy signal return handlers into the vector page, and
627 * set sigreturn to be a pointer to these.
628 */
629 memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
Russell King48be69a2013-07-24 00:29:18 +0100630
Russell Kinge0d40752013-08-03 10:30:05 +0100631 ptr = (unsigned long)addr + offset;
632 flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
Russell King48be69a2013-07-24 00:29:18 +0100633
Russell Kinge0d40752013-08-03 10:30:05 +0100634 return page;
Russell King48be69a2013-07-24 00:29:18 +0100635}