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