1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/sched.h>
14#include <linux/mm.h>
15#include <linux/smp.h>
16#include <linux/kernel.h>
17#include <linux/signal.h>
18#include <linux/errno.h>
19#include <linux/wait.h>
20#include <linux/unistd.h>
21#include <linux/stddef.h>
22#include <linux/personality.h>
23#include <linux/tracehook.h>
24#include <asm/cacheflush.h>
25#include <asm/ucontext.h>
26#include <asm/uaccess.h>
27
28#define DEBUG_SIG 0
29
30asmlinkage int
31sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
32 unsigned long r2, unsigned long r3, unsigned long r4,
33 unsigned long r5, unsigned long r6, struct pt_regs *regs)
34{
35 return do_sigaltstack(uss, uoss, regs->spu);
36}
37
38
39
40
41
42
43struct rt_sigframe
44{
45 int sig;
46 struct siginfo __user *pinfo;
47 void __user *puc;
48 struct siginfo info;
49 struct ucontext uc;
50
51};
52
53static int
54restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
55 int *r0_p)
56{
57 unsigned int err = 0;
58
59
60 current_thread_info()->restart_block.fn = do_no_restart_syscall;
61
62#define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
63 COPY(r4);
64 COPY(r5);
65 COPY(r6);
66 COPY(pt_regs);
67
68 COPY(r1);
69 COPY(r2);
70 COPY(r3);
71 COPY(r7);
72 COPY(r8);
73 COPY(r9);
74 COPY(r10);
75 COPY(r11);
76 COPY(r12);
77 COPY(acc0h);
78 COPY(acc0l);
79 COPY(acc1h);
80 COPY(acc1l);
81 COPY(psw);
82 COPY(bpc);
83 COPY(bbpsw);
84 COPY(bbpc);
85 COPY(spu);
86 COPY(fp);
87 COPY(lr);
88 COPY(spi);
89#undef COPY
90
91 regs->syscall_nr = -1;
92 err |= __get_user(*r0_p, &sc->sc_r0);
93
94 return err;
95}
96
97asmlinkage int
98sys_rt_sigreturn(unsigned long r0, unsigned long r1,
99 unsigned long r2, unsigned long r3, unsigned long r4,
100 unsigned long r5, unsigned long r6, struct pt_regs *regs)
101{
102 struct rt_sigframe __user *frame = (struct rt_sigframe __user *)regs->spu;
103 sigset_t set;
104 int result;
105
106 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
107 goto badframe;
108 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
109 goto badframe;
110
111 set_current_blocked(&set);
112
113 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &result))
114 goto badframe;
115
116 if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->spu) == -EFAULT)
117 goto badframe;
118
119 return result;
120
121badframe:
122 force_sig(SIGSEGV, current);
123 return 0;
124}
125
126
127
128
129
130static int
131setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
132 unsigned long mask)
133{
134 int err = 0;
135
136#define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
137 COPY(r4);
138 COPY(r5);
139 COPY(r6);
140 COPY(pt_regs);
141 COPY(r0);
142 COPY(r1);
143 COPY(r2);
144 COPY(r3);
145 COPY(r7);
146 COPY(r8);
147 COPY(r9);
148 COPY(r10);
149 COPY(r11);
150 COPY(r12);
151 COPY(acc0h);
152 COPY(acc0l);
153 COPY(acc1h);
154 COPY(acc1l);
155 COPY(psw);
156 COPY(bpc);
157 COPY(bbpsw);
158 COPY(bbpc);
159 COPY(spu);
160 COPY(fp);
161 COPY(lr);
162 COPY(spi);
163#undef COPY
164
165 err |= __put_user(mask, &sc->oldmask);
166
167 return err;
168}
169
170
171
172
173static inline void __user *
174get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
175{
176
177 if (ka->sa.sa_flags & SA_ONSTACK) {
178 if (sas_ss_flags(sp) == 0)
179 sp = current->sas_ss_sp + current->sas_ss_size;
180 }
181
182 return (void __user *)((sp - frame_size) & -8ul);
183}
184
185static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
186 sigset_t *set, struct pt_regs *regs)
187{
188 struct rt_sigframe __user *frame;
189 int err = 0;
190 int signal;
191
192 frame = get_sigframe(ka, regs->spu, sizeof(*frame));
193
194 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
195 goto give_sigsegv;
196
197 signal = current_thread_info()->exec_domain
198 && current_thread_info()->exec_domain->signal_invmap
199 && sig < 32
200 ? current_thread_info()->exec_domain->signal_invmap[sig]
201 : sig;
202
203 err |= __put_user(signal, &frame->sig);
204 if (err)
205 goto give_sigsegv;
206
207 err |= __put_user(&frame->info, &frame->pinfo);
208 err |= __put_user(&frame->uc, &frame->puc);
209 err |= copy_siginfo_to_user(&frame->info, info);
210 if (err)
211 goto give_sigsegv;
212
213
214 err |= __put_user(0, &frame->uc.uc_flags);
215 err |= __put_user(0, &frame->uc.uc_link);
216 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
217 err |= __put_user(sas_ss_flags(regs->spu),
218 &frame->uc.uc_stack.ss_flags);
219 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
220 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
221 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
222 if (err)
223 goto give_sigsegv;
224
225
226 regs->lr = (unsigned long)ka->sa.sa_restorer;
227
228
229 regs->spu = (unsigned long)frame;
230 regs->r0 = signal;
231 regs->r1 = (unsigned long)&frame->info;
232 regs->r2 = (unsigned long)&frame->uc;
233 regs->bpc = (unsigned long)ka->sa.sa_handler;
234
235 set_fs(USER_DS);
236
237#if DEBUG_SIG
238 printk("SIG deliver (%s:%d): sp=%p pc=%p\n",
239 current->comm, current->pid, frame, regs->pc);
240#endif
241
242 return 0;
243
244give_sigsegv:
245 force_sigsegv(sig, current);
246 return -EFAULT;
247}
248
249static int prev_insn(struct pt_regs *regs)
250{
251 u16 inst;
252 if (get_user(inst, (u16 __user *)(regs->bpc - 2)))
253 return -EFAULT;
254 if ((inst & 0xfff0) == 0x10f0)
255 regs->bpc -= 2;
256 else
257 regs->bpc -= 4;
258 regs->syscall_nr = -1;
259 return 0;
260}
261
262
263
264
265
266static void
267handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
268 struct pt_regs *regs)
269{
270
271 if (regs->syscall_nr >= 0) {
272
273 switch (regs->r0) {
274 case -ERESTART_RESTARTBLOCK:
275 case -ERESTARTNOHAND:
276 regs->r0 = -EINTR;
277 break;
278
279 case -ERESTARTSYS:
280 if (!(ka->sa.sa_flags & SA_RESTART)) {
281 regs->r0 = -EINTR;
282 break;
283 }
284
285 case -ERESTARTNOINTR:
286 regs->r0 = regs->orig_r0;
287 if (prev_insn(regs) < 0)
288 return;
289 }
290 }
291
292
293 if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs))
294 return;
295
296 signal_delivered(sig, info, ka, regs, 0);
297}
298
299
300
301
302
303
304static void do_signal(struct pt_regs *regs)
305{
306 siginfo_t info;
307 int signr;
308 struct k_sigaction ka;
309
310
311
312
313
314
315
316 if (!user_mode(regs))
317 return;
318
319 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
320 if (signr > 0) {
321
322
323
324
325
326
327
328 handle_signal(signr, &ka, &info, regs);
329
330 return;
331 }
332
333
334 if (regs->syscall_nr >= 0) {
335
336 if (regs->r0 == -ERESTARTNOHAND ||
337 regs->r0 == -ERESTARTSYS ||
338 regs->r0 == -ERESTARTNOINTR) {
339 regs->r0 = regs->orig_r0;
340 prev_insn(regs);
341 } else if (regs->r0 == -ERESTART_RESTARTBLOCK){
342 regs->r0 = regs->orig_r0;
343 regs->r7 = __NR_restart_syscall;
344 prev_insn(regs);
345 }
346 }
347 restore_saved_sigmask();
348}
349
350
351
352
353
354void do_notify_resume(struct pt_regs *regs, __u32 thread_info_flags)
355{
356
357 if (thread_info_flags & _TIF_SINGLESTEP)
358 clear_thread_flag(TIF_SINGLESTEP);
359
360
361 if (thread_info_flags & _TIF_SIGPENDING)
362 do_signal(regs);
363
364 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
365 clear_thread_flag(TIF_NOTIFY_RESUME);
366 tracehook_notify_resume(regs);
367 }
368}
369