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