1 /*
2 * Copyright (C) 2013-2014 Altera Corporation
3 * Copyright (C) 2011-2012 Tobias Klauser <tklauser@distanz.ch>
4 * Copyright (C) 2004 Microtronix Datacom Ltd
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 *
7 * This file is subject to the terms and conditions of the GNU General Public
8 * License. See the file COPYING in the main directory of this archive
9 * for more details.
10 */
11
12 #include <linux/signal.h>
13 #include <linux/errno.h>
14 #include <linux/ptrace.h>
15 #include <linux/uaccess.h>
16 #include <linux/unistd.h>
17 #include <linux/personality.h>
18 #include <linux/resume_user_mode.h>
19
20 #include <asm/ucontext.h>
21 #include <asm/cacheflush.h>
22
23 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
24
25 /*
26 * Do a signal return; undo the signal stack.
27 *
28 * Keep the return code on the stack quadword aligned!
29 * That makes the cache flush below easier.
30 */
31
32 struct rt_sigframe {
33 struct siginfo info;
34 struct ucontext uc;
35 };
36
rt_restore_ucontext(struct pt_regs * regs,struct switch_stack * sw,struct ucontext __user * uc,int * pr2)37 static inline int rt_restore_ucontext(struct pt_regs *regs,
38 struct switch_stack *sw,
39 struct ucontext __user *uc, int *pr2)
40 {
41 int temp;
42 unsigned long __user *gregs = uc->uc_mcontext.gregs;
43 int err;
44
45 /* Always make any pending restarted system calls return -EINTR */
46 current->restart_block.fn = do_no_restart_syscall;
47
48 err = __get_user(temp, &uc->uc_mcontext.version);
49 if (temp != MCONTEXT_VERSION)
50 goto badframe;
51 /* restore passed registers */
52 err |= __get_user(regs->r1, &gregs[0]);
53 err |= __get_user(regs->r2, &gregs[1]);
54 err |= __get_user(regs->r3, &gregs[2]);
55 err |= __get_user(regs->r4, &gregs[3]);
56 err |= __get_user(regs->r5, &gregs[4]);
57 err |= __get_user(regs->r6, &gregs[5]);
58 err |= __get_user(regs->r7, &gregs[6]);
59 err |= __get_user(regs->r8, &gregs[7]);
60 err |= __get_user(regs->r9, &gregs[8]);
61 err |= __get_user(regs->r10, &gregs[9]);
62 err |= __get_user(regs->r11, &gregs[10]);
63 err |= __get_user(regs->r12, &gregs[11]);
64 err |= __get_user(regs->r13, &gregs[12]);
65 err |= __get_user(regs->r14, &gregs[13]);
66 err |= __get_user(regs->r15, &gregs[14]);
67 err |= __get_user(sw->r16, &gregs[15]);
68 err |= __get_user(sw->r17, &gregs[16]);
69 err |= __get_user(sw->r18, &gregs[17]);
70 err |= __get_user(sw->r19, &gregs[18]);
71 err |= __get_user(sw->r20, &gregs[19]);
72 err |= __get_user(sw->r21, &gregs[20]);
73 err |= __get_user(sw->r22, &gregs[21]);
74 err |= __get_user(sw->r23, &gregs[22]);
75 /* gregs[23] is handled below */
76 err |= __get_user(sw->fp, &gregs[24]); /* Verify, should this be
77 settable */
78 err |= __get_user(sw->gp, &gregs[25]); /* Verify, should this be
79 settable */
80
81 err |= __get_user(temp, &gregs[26]); /* Not really necessary no user
82 settable bits */
83 err |= __get_user(regs->ea, &gregs[27]);
84
85 err |= __get_user(regs->ra, &gregs[23]);
86 err |= __get_user(regs->sp, &gregs[28]);
87
88 regs->orig_r2 = -1; /* disable syscall checks */
89
90 err |= restore_altstack(&uc->uc_stack);
91 if (err)
92 goto badframe;
93
94 *pr2 = regs->r2;
95 return err;
96
97 badframe:
98 return 1;
99 }
100
do_rt_sigreturn(struct switch_stack * sw)101 asmlinkage int do_rt_sigreturn(struct switch_stack *sw)
102 {
103 struct pt_regs *regs = (struct pt_regs *)(sw + 1);
104 /* Verify, can we follow the stack back */
105 struct rt_sigframe __user *frame;
106 sigset_t set;
107 int rval;
108
109 frame = (struct rt_sigframe __user *) regs->sp;
110 if (!access_ok(frame, sizeof(*frame)))
111 goto badframe;
112
113 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
114 goto badframe;
115
116 set_current_blocked(&set);
117
118 if (rt_restore_ucontext(regs, sw, &frame->uc, &rval))
119 goto badframe;
120
121 return rval;
122
123 badframe:
124 force_sig(SIGSEGV);
125 return 0;
126 }
127
rt_setup_ucontext(struct ucontext __user * uc,struct pt_regs * regs)128 static inline int rt_setup_ucontext(struct ucontext __user *uc, struct pt_regs *regs)
129 {
130 struct switch_stack *sw = (struct switch_stack *)regs - 1;
131 unsigned long __user *gregs = uc->uc_mcontext.gregs;
132 int err = 0;
133
134 err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
135 err |= __put_user(regs->r1, &gregs[0]);
136 err |= __put_user(regs->r2, &gregs[1]);
137 err |= __put_user(regs->r3, &gregs[2]);
138 err |= __put_user(regs->r4, &gregs[3]);
139 err |= __put_user(regs->r5, &gregs[4]);
140 err |= __put_user(regs->r6, &gregs[5]);
141 err |= __put_user(regs->r7, &gregs[6]);
142 err |= __put_user(regs->r8, &gregs[7]);
143 err |= __put_user(regs->r9, &gregs[8]);
144 err |= __put_user(regs->r10, &gregs[9]);
145 err |= __put_user(regs->r11, &gregs[10]);
146 err |= __put_user(regs->r12, &gregs[11]);
147 err |= __put_user(regs->r13, &gregs[12]);
148 err |= __put_user(regs->r14, &gregs[13]);
149 err |= __put_user(regs->r15, &gregs[14]);
150 err |= __put_user(sw->r16, &gregs[15]);
151 err |= __put_user(sw->r17, &gregs[16]);
152 err |= __put_user(sw->r18, &gregs[17]);
153 err |= __put_user(sw->r19, &gregs[18]);
154 err |= __put_user(sw->r20, &gregs[19]);
155 err |= __put_user(sw->r21, &gregs[20]);
156 err |= __put_user(sw->r22, &gregs[21]);
157 err |= __put_user(sw->r23, &gregs[22]);
158 err |= __put_user(regs->ra, &gregs[23]);
159 err |= __put_user(sw->fp, &gregs[24]);
160 err |= __put_user(sw->gp, &gregs[25]);
161 err |= __put_user(regs->ea, &gregs[27]);
162 err |= __put_user(regs->sp, &gregs[28]);
163 return err;
164 }
165
get_sigframe(struct ksignal * ksig,struct pt_regs * regs,size_t frame_size)166 static inline void __user *get_sigframe(struct ksignal *ksig,
167 struct pt_regs *regs,
168 size_t frame_size)
169 {
170 unsigned long usp;
171
172 /* Default to using normal stack. */
173 usp = regs->sp;
174
175 /* This is the X/Open sanctioned signal stack switching. */
176 usp = sigsp(usp, ksig);
177
178 /* Verify, is it 32 or 64 bit aligned */
179 return (void __user *)((usp - frame_size) & -8UL);
180 }
181
setup_rt_frame(struct ksignal * ksig,sigset_t * set,struct pt_regs * regs)182 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
183 struct pt_regs *regs)
184 {
185 struct rt_sigframe __user *frame;
186 int err = 0;
187
188 frame = get_sigframe(ksig, regs, sizeof(*frame));
189
190 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
191 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
192
193 /* Create the ucontext. */
194 err |= __put_user(0, &frame->uc.uc_flags);
195 err |= __put_user(0, &frame->uc.uc_link);
196 err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
197 err |= rt_setup_ucontext(&frame->uc, regs);
198 err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
199
200 if (err)
201 goto give_sigsegv;
202
203 /* Set up to return from userspace; jump to fixed address sigreturn
204 trampoline on kuser page. */
205 regs->ra = (unsigned long) (0x1044);
206
207 /* Set up registers for signal handler */
208 regs->sp = (unsigned long) frame;
209 regs->r4 = (unsigned long) ksig->sig;
210 regs->r5 = (unsigned long) &frame->info;
211 regs->r6 = (unsigned long) &frame->uc;
212 regs->ea = (unsigned long) ksig->ka.sa.sa_handler;
213 return 0;
214
215 give_sigsegv:
216 force_sigsegv(ksig->sig);
217 return -EFAULT;
218 }
219
220 /*
221 * OK, we're invoking a handler
222 */
handle_signal(struct ksignal * ksig,struct pt_regs * regs)223 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
224 {
225 int ret;
226 sigset_t *oldset = sigmask_to_save();
227
228 /* set up the stack frame */
229 ret = setup_rt_frame(ksig, oldset, regs);
230
231 signal_setup_done(ret, ksig, 0);
232 }
233
do_signal(struct pt_regs * regs)234 static int do_signal(struct pt_regs *regs)
235 {
236 unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
237 int restart = 0;
238 struct ksignal ksig;
239
240 current->thread.kregs = regs;
241
242 /*
243 * If we were from a system call, check for system call restarting...
244 */
245 if (regs->orig_r2 >= 0 && regs->r1) {
246 continue_addr = regs->ea;
247 restart_addr = continue_addr - 4;
248 retval = regs->r2;
249
250 /*
251 * Prepare for system call restart. We do this here so that a
252 * debugger will see the already changed PC.
253 */
254 switch (retval) {
255 case ERESTART_RESTARTBLOCK:
256 restart = -2;
257 fallthrough;
258 case ERESTARTNOHAND:
259 case ERESTARTSYS:
260 case ERESTARTNOINTR:
261 restart++;
262 regs->r2 = regs->orig_r2;
263 regs->r7 = regs->orig_r7;
264 regs->ea = restart_addr;
265 break;
266 }
267 regs->orig_r2 = -1;
268 }
269
270 if (get_signal(&ksig)) {
271 /* handler */
272 if (unlikely(restart && regs->ea == restart_addr)) {
273 if (retval == ERESTARTNOHAND ||
274 retval == ERESTART_RESTARTBLOCK ||
275 (retval == ERESTARTSYS
276 && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
277 regs->r2 = EINTR;
278 regs->r7 = 1;
279 regs->ea = continue_addr;
280 }
281 }
282 handle_signal(&ksig, regs);
283 return 0;
284 }
285
286 /*
287 * No handler present
288 */
289 if (unlikely(restart) && regs->ea == restart_addr) {
290 regs->ea = continue_addr;
291 regs->r2 = __NR_restart_syscall;
292 }
293
294 /*
295 * If there's no signal to deliver, we just put the saved sigmask back.
296 */
297 restore_saved_sigmask();
298
299 return restart;
300 }
301
do_notify_resume(struct pt_regs * regs)302 asmlinkage int do_notify_resume(struct pt_regs *regs)
303 {
304 /*
305 * We want the common case to go fast, which is why we may in certain
306 * cases get here from kernel mode. Just return without doing anything
307 * if so.
308 */
309 if (!user_mode(regs))
310 return 0;
311
312 if (test_thread_flag(TIF_SIGPENDING) ||
313 test_thread_flag(TIF_NOTIFY_SIGNAL)) {
314 int restart = do_signal(regs);
315
316 if (unlikely(restart)) {
317 /*
318 * Restart without handlers.
319 * Deal with it without leaving
320 * the kernel space.
321 */
322 return restart;
323 }
324 } else if (test_thread_flag(TIF_NOTIFY_RESUME))
325 resume_user_mode_work(regs);
326
327 return 0;
328 }
329