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 | |
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 | |
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(to: &set, from: &frame->uc.uc_sigmask, n: sizeof(set))) |
114 | goto badframe; |
115 | |
116 | set_current_blocked(&set); |
117 | |
118 | if (rt_restore_ucontext(regs, sw, uc: &frame->uc, pr2: &rval)) |
119 | goto badframe; |
120 | |
121 | return rval; |
122 | |
123 | badframe: |
124 | force_sig(SIGSEGV); |
125 | return 0; |
126 | } |
127 | |
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 | |
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(sp: usp, ksig); |
177 | |
178 | /* Verify, is it 32 or 64 bit aligned */ |
179 | return (void __user *)((usp - frame_size) & -8UL); |
180 | } |
181 | |
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, frame_size: sizeof(*frame)); |
189 | |
190 | if (ksig->ka.sa.sa_flags & SA_SIGINFO) |
191 | err |= copy_siginfo_to_user(to: &frame->info, from: &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(uc: &frame->uc, regs); |
198 | err |= copy_to_user(to: &frame->uc.uc_sigmask, from: set, n: 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(sig: ksig->sig); |
217 | return -EFAULT; |
218 | } |
219 | |
220 | /* |
221 | * OK, we're invoking a handler |
222 | */ |
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, set: oldset, regs); |
230 | |
231 | signal_setup_done(failed: ret, ksig, stepping: 0); |
232 | } |
233 | |
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: &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: &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 | |
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 | |