1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/sched.h>
19#include <linux/mm.h>
20#include <linux/smp.h>
21#include <linux/kernel.h>
22#include <linux/signal.h>
23#include <linux/errno.h>
24#include <linux/wait.h>
25#include <linux/ptrace.h>
26#include <linux/unistd.h>
27#include <linux/stddef.h>
28#include <linux/tracehook.h>
29
30#include <asm/processor.h>
31#include <asm/ucontext.h>
32#include <asm/uaccess.h>
33
34#define DEBUG_SIG 0
35
36#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
37
38asmlinkage long
39_sys_sigaltstack(const stack_t *uss, stack_t *uoss, struct pt_regs *regs)
40{
41 return do_sigaltstack(uss, uoss, regs->sp);
42}
43
44struct rt_sigframe {
45 struct siginfo *pinfo;
46 void *puc;
47 struct siginfo info;
48 struct ucontext uc;
49 unsigned char retcode[16];
50};
51
52static int restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
53{
54 unsigned int err = 0;
55
56
57 current_thread_info()->restart_block.fn = do_no_restart_syscall;
58
59
60
61
62
63
64 if (__copy_from_user(regs, sc->regs.gpr, 32 * sizeof(unsigned long)))
65 goto badframe;
66 if (__copy_from_user(®s->pc, &sc->regs.pc, sizeof(unsigned long)))
67 goto badframe;
68 if (__copy_from_user(®s->sr, &sc->regs.sr, sizeof(unsigned long)))
69 goto badframe;
70
71
72 regs->sr &= ~SPR_SR_SM;
73
74
75
76
77
78
79 return err;
80
81badframe:
82 return 1;
83}
84
85asmlinkage long _sys_rt_sigreturn(struct pt_regs *regs)
86{
87 struct rt_sigframe *frame = (struct rt_sigframe __user *)regs->sp;
88 sigset_t set;
89 stack_t st;
90
91
92
93
94
95
96 if (((long)frame) & 3)
97 goto badframe;
98
99 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
100 goto badframe;
101 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
102 goto badframe;
103
104 sigdelsetmask(&set, ~_BLOCKABLE);
105 spin_lock_irq(¤t->sighand->siglock);
106 current->blocked = set;
107 recalc_sigpending();
108 spin_unlock_irq(¤t->sighand->siglock);
109
110 if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
111 goto badframe;
112
113 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
114 goto badframe;
115
116
117 do_sigaltstack(&st, NULL, regs->sp);
118
119 return regs->gpr[11];
120
121badframe:
122 force_sig(SIGSEGV, current);
123 return 0;
124}
125
126
127
128
129
130static int setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
131 unsigned long mask)
132{
133 int err = 0;
134
135
136
137 err |= __copy_to_user(sc->regs.gpr, regs, 32 * sizeof(unsigned long));
138 err |= __copy_to_user(&sc->regs.pc, ®s->pc, sizeof(unsigned long));
139 err |= __copy_to_user(&sc->regs.sr, ®s->sr, sizeof(unsigned long));
140
141
142
143 err |= __put_user(mask, &sc->oldmask);
144
145 return err;
146}
147
148static inline unsigned long align_sigframe(unsigned long sp)
149{
150 return sp & ~3UL;
151}
152
153
154
155
156
157
158static inline void __user *get_sigframe(struct k_sigaction *ka,
159 struct pt_regs *regs, size_t frame_size)
160{
161 unsigned long sp = regs->sp;
162 int onsigstack = on_sig_stack(sp);
163
164
165 sp -= STACK_FRAME_OVERHEAD;
166
167
168 if ((ka->sa.sa_flags & SA_ONSTACK) && !onsigstack) {
169 if (current->sas_ss_size)
170 sp = current->sas_ss_sp + current->sas_ss_size;
171 }
172
173 sp = align_sigframe(sp - frame_size);
174
175
176
177
178
179 if (onsigstack && !likely(on_sig_stack(sp)))
180 return (void __user *)-1L;
181
182 return (void __user *)sp;
183}
184
185
186
187
188
189
190
191
192static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
193 sigset_t *set, struct pt_regs *regs)
194{
195 struct rt_sigframe *frame;
196 unsigned long return_ip;
197 int err = 0;
198
199 frame = get_sigframe(ka, regs, sizeof(*frame));
200
201 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
202 goto give_sigsegv;
203
204 err |= __put_user(&frame->info, &frame->pinfo);
205 err |= __put_user(&frame->uc, &frame->puc);
206
207 if (ka->sa.sa_flags & SA_SIGINFO)
208 err |= copy_siginfo_to_user(&frame->info, info);
209 if (err)
210 goto give_sigsegv;
211
212
213 err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
214 err |= __put_user(0, &frame->uc.uc_flags);
215 err |= __put_user(NULL, &frame->uc.uc_link);
216 err |= __put_user((void *)current->sas_ss_sp,
217 &frame->uc.uc_stack.ss_sp);
218 err |= __put_user(sas_ss_flags(regs->sp), &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
222 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
223
224 if (err)
225 goto give_sigsegv;
226
227
228 return_ip = (unsigned long)&frame->retcode;
229
230 err |= __put_user(0xa960, (short *)(frame->retcode + 0));
231 err |= __put_user(__NR_rt_sigreturn, (short *)(frame->retcode + 2));
232 err |= __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
233 err |= __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));
234
235 if (err)
236 goto give_sigsegv;
237
238
239
240
241 regs->pc = (unsigned long)ka->sa.sa_handler;
242 regs->gpr[9] = (unsigned long)return_ip;
243 regs->gpr[3] = (unsigned long)sig;
244 regs->gpr[4] = (unsigned long)&frame->info;
245 regs->gpr[5] = (unsigned long)&frame->uc;
246
247
248 regs->sp = (unsigned long)frame;
249
250 return;
251
252give_sigsegv:
253 if (sig == SIGSEGV)
254 ka->sa.sa_handler = SIG_DFL;
255 force_sig(SIGSEGV, current);
256}
257
258static inline void
259handle_signal(unsigned long sig,
260 siginfo_t *info, struct k_sigaction *ka,
261 sigset_t *oldset, struct pt_regs *regs)
262{
263 setup_rt_frame(sig, ka, info, oldset, regs);
264
265 if (ka->sa.sa_flags & SA_ONESHOT)
266 ka->sa.sa_handler = SIG_DFL;
267
268 spin_lock_irq(¤t->sighand->siglock);
269 sigorsets(¤t->blocked, ¤t->blocked, &ka->sa.sa_mask);
270 if (!(ka->sa.sa_flags & SA_NODEFER))
271 sigaddset(¤t->blocked, sig);
272 recalc_sigpending();
273
274 spin_unlock_irq(¤t->sighand->siglock);
275}
276
277
278
279
280
281
282
283
284
285
286
287
288
289void do_signal(struct pt_regs *regs)
290{
291 siginfo_t info;
292 int signr;
293 struct k_sigaction ka;
294
295
296
297
298
299
300
301 if (!user_mode(regs))
302 return;
303
304 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
305
306
307
308
309
310
311
312
313
314
315 if (regs->syscallno) {
316 int restart = 0;
317
318 switch (regs->gpr[11]) {
319 case -ERESTART_RESTARTBLOCK:
320 case -ERESTARTNOHAND:
321
322 restart = (signr <= 0);
323 break;
324 case -ERESTARTSYS:
325
326
327 restart = (signr <= 0 || (ka.sa.sa_flags & SA_RESTART));
328 break;
329 case -ERESTARTNOINTR:
330
331 restart = 1;
332 break;
333 }
334
335 if (restart) {
336 if (regs->gpr[11] == -ERESTART_RESTARTBLOCK)
337 regs->gpr[11] = __NR_restart_syscall;
338 else
339 regs->gpr[11] = regs->orig_gpr11;
340 regs->pc -= 4;
341 } else {
342 regs->gpr[11] = -EINTR;
343 }
344 }
345
346 if (signr <= 0) {
347
348
349 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
350 clear_thread_flag(TIF_RESTORE_SIGMASK);
351 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
352 }
353
354 } else {
355 sigset_t *oldset;
356
357 if (current_thread_info()->flags & _TIF_RESTORE_SIGMASK)
358 oldset = ¤t->saved_sigmask;
359 else
360 oldset = ¤t->blocked;
361
362
363 handle_signal(signr, &info, &ka, oldset, regs);
364
365
366
367
368 if (test_thread_flag(TIF_RESTORE_SIGMASK))
369 clear_thread_flag(TIF_RESTORE_SIGMASK);
370
371 tracehook_signal_handler(signr, &info, &ka, regs,
372 test_thread_flag(TIF_SINGLESTEP));
373 }
374
375 return;
376}
377
378asmlinkage void do_notify_resume(struct pt_regs *regs)
379{
380 if (current_thread_info()->flags & _TIF_SIGPENDING)
381 do_signal(regs);
382
383 if (current_thread_info()->flags & _TIF_NOTIFY_RESUME) {
384 clear_thread_flag(TIF_NOTIFY_RESUME);
385 tracehook_notify_resume(regs);
386 if (current->replacement_session_keyring)
387 key_replace_session_keyring();
388 }
389}
390