1/*
  2 * Copyright (C) 2004-2006 Atmel Corporation
  3 *
  4 * Based on linux/arch/sh/kernel/signal.c
  5 *  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
  6 *  Copyright (C) 1991, 1992  Linus Torvalds
  7 *
  8 * This program is free software; you can redistribute it and/or modify
  9 * it under the terms of the GNU General Public License version 2 as
 10 * published by the Free Software Foundation.
 11 */
 12
 13#include <linux/sched.h>
 14#include <linux/mm.h>
 15#include <linux/errno.h>
 16#include <linux/ptrace.h>
 17#include <linux/unistd.h>
 18#include <linux/freezer.h>
 19#include <linux/tracehook.h>
 20
 21#include <asm/uaccess.h>
 22#include <asm/ucontext.h>
 23#include <asm/syscalls.h>
 24
 25asmlinkage int sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
 26			       struct pt_regs *regs)
 27{
 28	return do_sigaltstack(uss, uoss, regs->sp);
 29}
 30
 31struct rt_sigframe
 32{
 33	struct siginfo info;
 34	struct ucontext uc;
 35	unsigned long retcode;
 36};
 37
 38static int
 39restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
 40{
 41	int err = 0;
 42
 43#define COPY(x)		err |= __get_user(regs->x, &sc->x)
 44	COPY(sr);
 45	COPY(pc);
 46	COPY(lr);
 47	COPY(sp);
 48	COPY(r12);
 49	COPY(r11);
 50	COPY(r10);
 51	COPY(r9);
 52	COPY(r8);
 53	COPY(r7);
 54	COPY(r6);
 55	COPY(r5);
 56	COPY(r4);
 57	COPY(r3);
 58	COPY(r2);
 59	COPY(r1);
 60	COPY(r0);
 61#undef	COPY
 62
 63	/*
 64	 * Don't allow anyone to pretend they're running in supervisor
 65	 * mode or something...
 66	 */
 67	err |= !valid_user_regs(regs);
 68
 69	return err;
 70}
 71
 72
 73asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
 74{
 75	struct rt_sigframe __user *frame;
 76	sigset_t set;
 77
 78	/* Always make any pending restarted system calls return -EINTR */
 79	current_thread_info()->restart_block.fn = do_no_restart_syscall;
 80
 81	frame = (struct rt_sigframe __user *)regs->sp;
 82	pr_debug("SIG return: frame = %p\n", frame);
 83
 84	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 85		goto badframe;
 86
 87	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 88		goto badframe;
 89
 90	set_current_blocked(&set);
 91
 92	if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 93		goto badframe;
 94
 95	if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT)
 96		goto badframe;
 97
 98	pr_debug("Context restored: pc = %08lx, lr = %08lx, sp = %08lx\n",
 99		 regs->pc, regs->lr, regs->sp);
100
101	return regs->r12;
102
103badframe:
104	force_sig(SIGSEGV, current);
105	return 0;
106}
107
108static int
109setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
110{
111	int err = 0;
112
113#define COPY(x)		err |= __put_user(regs->x, &sc->x)
114	COPY(sr);
115	COPY(pc);
116	COPY(lr);
117	COPY(sp);
118	COPY(r12);
119	COPY(r11);
120	COPY(r10);
121	COPY(r9);
122	COPY(r8);
123	COPY(r7);
124	COPY(r6);
125	COPY(r5);
126	COPY(r4);
127	COPY(r3);
128	COPY(r2);
129	COPY(r1);
130	COPY(r0);
131#undef	COPY
132
133	return err;
134}
135
136static inline void __user *
137get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, int framesize)
138{
139	unsigned long sp = regs->sp;
140
141	if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
142		sp = current->sas_ss_sp + current->sas_ss_size;
143
144	return (void __user *)((sp - framesize) & ~3);
145}
146
147static int
148setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
149	       sigset_t *set, struct pt_regs *regs)
150{
151	struct rt_sigframe __user *frame;
152	int err = 0;
153
154	frame = get_sigframe(ka, regs, sizeof(*frame));
155	err = -EFAULT;
156	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
157		goto out;
158
159	/*
160	 * Set up the return code:
161	 *
162	 *	mov	r8, __NR_rt_sigreturn
163	 *	scall
164	 *
165	 * Note: This will blow up since we're using a non-executable
166	 * stack. Better use SA_RESTORER.
167	 */
168#if __NR_rt_sigreturn > 127
169# error __NR_rt_sigreturn must be < 127 to fit in a short mov
170#endif
171	err = __put_user(0x3008d733 | (__NR_rt_sigreturn << 20),
172			 &frame->retcode);
173
174	err |= copy_siginfo_to_user(&frame->info, info);
175
176	/* Set up the ucontext */
177	err |= __put_user(0, &frame->uc.uc_flags);
178	err |= __put_user(NULL, &frame->uc.uc_link);
179	err |= __put_user((void __user *)current->sas_ss_sp,
180			  &frame->uc.uc_stack.ss_sp);
181	err |= __put_user(sas_ss_flags(regs->sp),
182			  &frame->uc.uc_stack.ss_flags);
183	err |= __put_user(current->sas_ss_size,
184			  &frame->uc.uc_stack.ss_size);
185	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs);
186	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
187
188	if (err)
189		goto out;
190
191	regs->r12 = sig;
192	regs->r11 = (unsigned long) &frame->info;
193	regs->r10 = (unsigned long) &frame->uc;
194	regs->sp = (unsigned long) frame;
195	if (ka->sa.sa_flags & SA_RESTORER)
196		regs->lr = (unsigned long)ka->sa.sa_restorer;
197	else {
198		printk(KERN_NOTICE "[%s:%d] did not set SA_RESTORER\n",
199		       current->comm, current->pid);
200		regs->lr = (unsigned long) &frame->retcode;
201	}
202
203	pr_debug("SIG deliver [%s:%d]: sig=%d sp=0x%lx pc=0x%lx->0x%p lr=0x%lx\n",
204		 current->comm, current->pid, sig, regs->sp,
205		 regs->pc, ka->sa.sa_handler, regs->lr);
206
207	regs->pc = (unsigned long) ka->sa.sa_handler;
208
209out:
210	return err;
211}
212
213static inline void setup_syscall_restart(struct pt_regs *regs)
214{
215	if (regs->r12 == -ERESTART_RESTARTBLOCK)
216		regs->r8 = __NR_restart_syscall;
217	else
218		regs->r12 = regs->r12_orig;
219	regs->pc -= 2;
220}
221
222static inline void
223handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
224	      struct pt_regs *regs, int syscall)
225{
226	int ret;
227
228	/*
229	 * Set up the stack frame
230	 */
231	ret = setup_rt_frame(sig, ka, info, sigmask_to_save(), regs);
232
233	/*
234	 * Check that the resulting registers are sane
235	 */
236	ret |= !valid_user_regs(regs);
237
238	/*
239	 * Block the signal if we were successful.
240	 */
241	if (ret != 0)
242		force_sigsegv(sig, current);
243	else
244		signal_delivered(sig, info, ka, regs, 0);
245}
246
247/*
248 * Note that 'init' is a special process: it doesn't get signals it
249 * doesn't want to handle. Thus you cannot kill init even with a
250 * SIGKILL even by mistake.
251 */
252static void do_signal(struct pt_regs *regs, int syscall)
253{
254	siginfo_t info;
255	int signr;
256	struct k_sigaction ka;
257
258	/*
259	 * We want the common case to go fast, which is why we may in
260	 * certain cases get here from kernel mode. Just return
261	 * without doing anything if so.
262	 */
263	if (!user_mode(regs))
264		return;
265
266	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
267	if (syscall) {
268		switch (regs->r12) {
269		case -ERESTART_RESTARTBLOCK:
270		case -ERESTARTNOHAND:
271			if (signr > 0) {
272				regs->r12 = -EINTR;
273				break;
274			}
275			/* fall through */
276		case -ERESTARTSYS:
277			if (signr > 0 && !(ka.sa.sa_flags & SA_RESTART)) {
278				regs->r12 = -EINTR;
279				break;
280			}
281			/* fall through */
282		case -ERESTARTNOINTR:
283			setup_syscall_restart(regs);
284		}
285	}
286
287	if (signr == 0) {
288		/* No signal to deliver -- put the saved sigmask back */
289		restore_saved_sigmask();
290		return;
291	}
292
293	handle_signal(signr, &ka, &info, regs, syscall);
294}
295
296asmlinkage void do_notify_resume(struct pt_regs *regs, struct thread_info *ti)
297{
298	int syscall = 0;
299
300	if ((sysreg_read(SR) & MODE_MASK) == MODE_SUPERVISOR)
301		syscall = 1;
302
303	if (ti->flags & _TIF_SIGPENDING)
304		do_signal(regs, syscall);
305
306	if (ti->flags & _TIF_NOTIFY_RESUME) {
307		clear_thread_flag(TIF_NOTIFY_RESUME);
308		tracehook_notify_resume(regs);
309	}
310}