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