Commit | Line | Data |
---|---|---|
b53e906d LFT |
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> | |
03248add | 18 | #include <linux/resume_user_mode.h> |
b53e906d LFT |
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, | |
23fc539e | 39 | struct ucontext __user *uc, int *pr2) |
b53e906d LFT |
40 | { |
41 | int temp; | |
23fc539e | 42 | unsigned long __user *gregs = uc->uc_mcontext.gregs; |
b53e906d LFT |
43 | int err; |
44 | ||
45 | /* Always make any pending restarted system calls return -EINTR */ | |
7587d126 | 46 | current->restart_block.fn = do_no_restart_syscall; |
b53e906d LFT |
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 */ | |
23fc539e | 105 | struct rt_sigframe __user *frame; |
b53e906d LFT |
106 | sigset_t set; |
107 | int rval; | |
108 | ||
23fc539e | 109 | frame = (struct rt_sigframe __user *) regs->sp; |
96d4f267 | 110 | if (!access_ok(frame, sizeof(*frame))) |
b53e906d LFT |
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: | |
3cf5d076 | 124 | force_sig(SIGSEGV); |
b53e906d LFT |
125 | return 0; |
126 | } | |
127 | ||
23fc539e | 128 | static inline int rt_setup_ucontext(struct ucontext __user *uc, struct pt_regs *regs) |
b53e906d LFT |
129 | { |
130 | struct switch_stack *sw = (struct switch_stack *)regs - 1; | |
23fc539e | 131 | unsigned long __user *gregs = uc->uc_mcontext.gregs; |
b53e906d LFT |
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 | ||
23fc539e AB |
166 | static inline void __user *get_sigframe(struct ksignal *ksig, |
167 | struct pt_regs *regs, | |
168 | size_t frame_size) | |
b53e906d LFT |
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 */ | |
23fc539e | 179 | return (void __user *)((usp - frame_size) & -8UL); |
b53e906d LFT |
180 | } |
181 | ||
182 | static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, | |
183 | struct pt_regs *regs) | |
184 | { | |
23fc539e | 185 | struct rt_sigframe __user *frame; |
b53e906d LFT |
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. */ | |
d24c8163 | 205 | regs->ra = (unsigned long) (0x1044); |
b53e906d LFT |
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: | |
cb44c9a0 | 216 | force_sigsegv(ksig->sig); |
b53e906d LFT |
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, oldset, regs); | |
230 | ||
231 | signal_setup_done(ret, ksig, 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 | */ | |
2d631bd5 | 245 | if (regs->orig_r2 >= 0 && regs->r1) { |
b53e906d LFT |
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; | |
6b57fa4d | 257 | fallthrough; |
b53e906d LFT |
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 | } | |
411a76b7 | 267 | regs->orig_r2 = -1; |
b53e906d LFT |
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 | ||
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 | ||
42020064 JA |
312 | if (test_thread_flag(TIF_SIGPENDING) || |
313 | test_thread_flag(TIF_NOTIFY_SIGNAL)) { | |
b53e906d LFT |
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 | } | |
3c532798 | 324 | } else if (test_thread_flag(TIF_NOTIFY_RESUME)) |
03248add | 325 | resume_user_mode_work(regs); |
b53e906d LFT |
326 | |
327 | return 0; | |
328 | } |