Commit | Line | Data |
---|---|---|
03a34755 AJ |
1 | /* |
2 | * Port on Texas Instruments TMS320C6x architecture | |
3 | * | |
4 | * Copyright (C) 2004, 2006, 2009, 2010, 2011 Texas Instruments Incorporated | |
5 | * Author: Aurelien Jacquiot (aurelien.jacquiot@jaluna.com) | |
6 | * | |
7 | * Updated for 2.6.34: Mark Salter <msalter@redhat.com> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License version 2 as | |
11 | * published by the Free Software Foundation. | |
12 | */ | |
13 | ||
14 | #include <linux/kernel.h> | |
15 | #include <linux/uaccess.h> | |
16 | #include <linux/syscalls.h> | |
17 | #include <linux/tracehook.h> | |
18 | ||
19 | #include <asm/ucontext.h> | |
20 | #include <asm/cacheflush.h> | |
21 | ||
22 | ||
23 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) | |
24 | ||
25 | /* | |
26 | * Do a signal return, undo the signal stack. | |
27 | */ | |
28 | ||
29 | #define RETCODE_SIZE (9 << 2) /* 9 instructions = 36 bytes */ | |
30 | ||
31 | struct rt_sigframe { | |
32 | struct siginfo __user *pinfo; | |
33 | void __user *puc; | |
34 | struct siginfo info; | |
35 | struct ucontext uc; | |
36 | unsigned long retcode[RETCODE_SIZE >> 2]; | |
37 | }; | |
38 | ||
39 | static int restore_sigcontext(struct pt_regs *regs, | |
40 | struct sigcontext __user *sc) | |
41 | { | |
42 | int err = 0; | |
43 | ||
44 | /* The access_ok check was done by caller, so use __get_user here */ | |
45 | #define COPY(x) (err |= __get_user(regs->x, &sc->sc_##x)) | |
46 | ||
47 | COPY(sp); COPY(a4); COPY(b4); COPY(a6); COPY(b6); COPY(a8); COPY(b8); | |
48 | COPY(a0); COPY(a1); COPY(a2); COPY(a3); COPY(a5); COPY(a7); COPY(a9); | |
49 | COPY(b0); COPY(b1); COPY(b2); COPY(b3); COPY(b5); COPY(b7); COPY(b9); | |
50 | ||
51 | COPY(a16); COPY(a17); COPY(a18); COPY(a19); | |
52 | COPY(a20); COPY(a21); COPY(a22); COPY(a23); | |
53 | COPY(a24); COPY(a25); COPY(a26); COPY(a27); | |
54 | COPY(a28); COPY(a29); COPY(a30); COPY(a31); | |
55 | COPY(b16); COPY(b17); COPY(b18); COPY(b19); | |
56 | COPY(b20); COPY(b21); COPY(b22); COPY(b23); | |
57 | COPY(b24); COPY(b25); COPY(b26); COPY(b27); | |
58 | COPY(b28); COPY(b29); COPY(b30); COPY(b31); | |
59 | ||
60 | COPY(csr); COPY(pc); | |
61 | ||
62 | #undef COPY | |
63 | ||
64 | return err; | |
65 | } | |
66 | ||
67 | asmlinkage int do_rt_sigreturn(struct pt_regs *regs) | |
68 | { | |
69 | struct rt_sigframe __user *frame; | |
70 | sigset_t set; | |
71 | ||
2a3fdc11 AV |
72 | /* Always make any pending restarted system calls return -EINTR */ |
73 | current_thread_info()->restart_block.fn = do_no_restart_syscall; | |
74 | ||
03a34755 AJ |
75 | /* |
76 | * Since we stacked the signal on a dword boundary, | |
77 | * 'sp' should be dword aligned here. If it's | |
78 | * not, then the user is trying to mess with us. | |
79 | */ | |
80 | if (regs->sp & 7) | |
81 | goto badframe; | |
82 | ||
83 | frame = (struct rt_sigframe __user *) ((unsigned long) regs->sp + 8); | |
84 | ||
85 | if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) | |
86 | goto badframe; | |
87 | if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) | |
88 | goto badframe; | |
89 | ||
90 | sigdelsetmask(&set, ~_BLOCKABLE); | |
6e61ee3b | 91 | set_current_blocked(&set); |
03a34755 AJ |
92 | |
93 | if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) | |
94 | goto badframe; | |
95 | ||
96 | return regs->a4; | |
97 | ||
98 | badframe: | |
99 | force_sig(SIGSEGV, current); | |
100 | return 0; | |
101 | } | |
102 | ||
103 | static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, | |
104 | unsigned long mask) | |
105 | { | |
106 | int err = 0; | |
107 | ||
108 | err |= __put_user(mask, &sc->sc_mask); | |
109 | ||
110 | /* The access_ok check was done by caller, so use __put_user here */ | |
111 | #define COPY(x) (err |= __put_user(regs->x, &sc->sc_##x)) | |
112 | ||
113 | COPY(sp); COPY(a4); COPY(b4); COPY(a6); COPY(b6); COPY(a8); COPY(b8); | |
114 | COPY(a0); COPY(a1); COPY(a2); COPY(a3); COPY(a5); COPY(a7); COPY(a9); | |
115 | COPY(b0); COPY(b1); COPY(b2); COPY(b3); COPY(b5); COPY(b7); COPY(b9); | |
116 | ||
117 | COPY(a16); COPY(a17); COPY(a18); COPY(a19); | |
118 | COPY(a20); COPY(a21); COPY(a22); COPY(a23); | |
119 | COPY(a24); COPY(a25); COPY(a26); COPY(a27); | |
120 | COPY(a28); COPY(a29); COPY(a30); COPY(a31); | |
121 | COPY(b16); COPY(b17); COPY(b18); COPY(b19); | |
122 | COPY(b20); COPY(b21); COPY(b22); COPY(b23); | |
123 | COPY(b24); COPY(b25); COPY(b26); COPY(b27); | |
124 | COPY(b28); COPY(b29); COPY(b30); COPY(b31); | |
125 | ||
126 | COPY(csr); COPY(pc); | |
127 | ||
128 | #undef COPY | |
129 | ||
130 | return err; | |
131 | } | |
132 | ||
133 | static inline void __user *get_sigframe(struct k_sigaction *ka, | |
134 | struct pt_regs *regs, | |
135 | unsigned long framesize) | |
136 | { | |
137 | unsigned long sp = regs->sp; | |
138 | ||
139 | /* | |
140 | * This is the X/Open sanctioned signal stack switching. | |
141 | */ | |
142 | if ((ka->sa.sa_flags & SA_ONSTACK) && sas_ss_flags(sp) == 0) | |
143 | sp = current->sas_ss_sp + current->sas_ss_size; | |
144 | ||
145 | /* | |
146 | * No matter what happens, 'sp' must be dword | |
147 | * aligned. Otherwise, nasty things will happen | |
148 | */ | |
149 | return (void __user *)((sp - framesize) & ~7); | |
150 | } | |
151 | ||
152 | static int setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info, | |
153 | sigset_t *set, struct pt_regs *regs) | |
154 | { | |
155 | struct rt_sigframe __user *frame; | |
156 | unsigned long __user *retcode; | |
157 | int err = 0; | |
158 | ||
159 | frame = get_sigframe(ka, regs, sizeof(*frame)); | |
160 | ||
161 | if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) | |
162 | goto segv_and_exit; | |
163 | ||
164 | err |= __put_user(&frame->info, &frame->pinfo); | |
165 | err |= __put_user(&frame->uc, &frame->puc); | |
166 | err |= copy_siginfo_to_user(&frame->info, info); | |
167 | ||
168 | /* Clear all the bits of the ucontext we don't use. */ | |
169 | err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext)); | |
170 | ||
171 | err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]); | |
172 | err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); | |
173 | ||
174 | /* Set up to return from userspace */ | |
175 | retcode = (unsigned long __user *) &frame->retcode; | |
176 | ||
177 | /* The access_ok check was done above, so use __put_user here */ | |
178 | #define COPY(x) (err |= __put_user(x, retcode++)) | |
179 | ||
180 | COPY(0x0000002AUL | (__NR_rt_sigreturn << 7)); | |
181 | /* MVK __NR_rt_sigreturn,B0 */ | |
182 | COPY(0x10000000UL); /* SWE */ | |
183 | COPY(0x00006000UL); /* NOP 4 */ | |
184 | COPY(0x00006000UL); /* NOP 4 */ | |
185 | COPY(0x00006000UL); /* NOP 4 */ | |
186 | COPY(0x00006000UL); /* NOP 4 */ | |
187 | COPY(0x00006000UL); /* NOP 4 */ | |
188 | COPY(0x00006000UL); /* NOP 4 */ | |
189 | COPY(0x00006000UL); /* NOP 4 */ | |
190 | ||
191 | #undef COPY | |
192 | ||
193 | if (err) | |
194 | goto segv_and_exit; | |
195 | ||
196 | flush_icache_range((unsigned long) &frame->retcode, | |
197 | (unsigned long) &frame->retcode + RETCODE_SIZE); | |
198 | ||
199 | retcode = (unsigned long __user *) &frame->retcode; | |
200 | ||
201 | /* Change user context to branch to signal handler */ | |
202 | regs->sp = (unsigned long) frame - 8; | |
203 | regs->b3 = (unsigned long) retcode; | |
204 | regs->pc = (unsigned long) ka->sa.sa_handler; | |
205 | ||
206 | /* Give the signal number to the handler */ | |
207 | regs->a4 = signr; | |
208 | ||
209 | /* | |
210 | * For realtime signals we must also set the second and third | |
211 | * arguments for the signal handler. | |
212 | * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06 | |
213 | */ | |
214 | regs->b4 = (unsigned long)&frame->info; | |
215 | regs->a6 = (unsigned long)&frame->uc; | |
216 | ||
217 | return 0; | |
218 | ||
219 | segv_and_exit: | |
220 | force_sigsegv(signr, current); | |
221 | return -EFAULT; | |
222 | } | |
223 | ||
224 | static inline void | |
225 | handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler) | |
226 | { | |
227 | switch (regs->a4) { | |
228 | case -ERESTARTNOHAND: | |
229 | if (!has_handler) | |
230 | goto do_restart; | |
231 | regs->a4 = -EINTR; | |
232 | break; | |
233 | ||
234 | case -ERESTARTSYS: | |
235 | if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) { | |
236 | regs->a4 = -EINTR; | |
237 | break; | |
238 | } | |
239 | /* fallthrough */ | |
240 | case -ERESTARTNOINTR: | |
241 | do_restart: | |
242 | regs->a4 = regs->orig_a4; | |
243 | regs->pc -= 4; | |
244 | break; | |
245 | } | |
246 | } | |
247 | ||
248 | /* | |
249 | * handle the actual delivery of a signal to userspace | |
250 | */ | |
a610d6e6 | 251 | static void handle_signal(int sig, |
03a34755 | 252 | siginfo_t *info, struct k_sigaction *ka, |
b7f9a11a | 253 | struct pt_regs *regs, int syscall) |
03a34755 AJ |
254 | { |
255 | int ret; | |
256 | ||
257 | /* Are we from a system call? */ | |
258 | if (syscall) { | |
259 | /* If so, check system call restarting.. */ | |
260 | switch (regs->a4) { | |
261 | case -ERESTART_RESTARTBLOCK: | |
262 | case -ERESTARTNOHAND: | |
263 | regs->a4 = -EINTR; | |
264 | break; | |
265 | ||
266 | case -ERESTARTSYS: | |
267 | if (!(ka->sa.sa_flags & SA_RESTART)) { | |
268 | regs->a4 = -EINTR; | |
269 | break; | |
270 | } | |
271 | ||
272 | /* fallthrough */ | |
273 | case -ERESTARTNOINTR: | |
274 | regs->a4 = regs->orig_a4; | |
275 | regs->pc -= 4; | |
276 | } | |
277 | } | |
278 | ||
279 | /* Set up the stack frame */ | |
a610d6e6 AV |
280 | if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs) < 0) |
281 | return; | |
282 | block_sigmask(ka, sig); | |
283 | tracehook_signal_handler(sig, info, ka, regs, 0); | |
03a34755 AJ |
284 | } |
285 | ||
286 | /* | |
287 | * handle a potential signal | |
288 | */ | |
289 | static void do_signal(struct pt_regs *regs, int syscall) | |
290 | { | |
291 | struct k_sigaction ka; | |
292 | siginfo_t info; | |
03a34755 AJ |
293 | int signr; |
294 | ||
295 | /* we want the common case to go fast, which is why we may in certain | |
296 | * cases get here from kernel mode */ | |
297 | if (!user_mode(regs)) | |
298 | return; | |
299 | ||
03a34755 AJ |
300 | signr = get_signal_to_deliver(&info, &ka, regs, NULL); |
301 | if (signr > 0) { | |
a610d6e6 | 302 | handle_signal(signr, &info, &ka, regs, syscall); |
03a34755 AJ |
303 | return; |
304 | } | |
305 | ||
306 | /* did we come from a system call? */ | |
307 | if (syscall) { | |
308 | /* restart the system call - no handlers present */ | |
309 | switch (regs->a4) { | |
310 | case -ERESTARTNOHAND: | |
311 | case -ERESTARTSYS: | |
312 | case -ERESTARTNOINTR: | |
313 | regs->a4 = regs->orig_a4; | |
314 | regs->pc -= 4; | |
315 | break; | |
316 | ||
317 | case -ERESTART_RESTARTBLOCK: | |
318 | regs->a4 = regs->orig_a4; | |
319 | regs->b0 = __NR_restart_syscall; | |
320 | regs->pc -= 4; | |
321 | break; | |
322 | } | |
323 | } | |
324 | ||
325 | /* if there's no signal to deliver, we just put the saved sigmask | |
326 | * back */ | |
51a7b448 | 327 | restore_saved_sigmask(); |
03a34755 AJ |
328 | } |
329 | ||
330 | /* | |
331 | * notification of userspace execution resumption | |
332 | * - triggered by current->work.notify_resume | |
333 | */ | |
334 | asmlinkage void do_notify_resume(struct pt_regs *regs, u32 thread_info_flags, | |
335 | int syscall) | |
336 | { | |
337 | /* deal with pending signal delivery */ | |
338 | if (thread_info_flags & ((1 << TIF_SIGPENDING) | | |
339 | (1 << TIF_RESTORE_SIGMASK))) | |
340 | do_signal(regs, syscall); | |
341 | ||
342 | if (thread_info_flags & (1 << TIF_NOTIFY_RESUME)) { | |
343 | clear_thread_flag(TIF_NOTIFY_RESUME); | |
344 | tracehook_notify_resume(regs); | |
03a34755 AJ |
345 | } |
346 | } |