1
2
3
4
5
6
7
8
9
10#include <linux/sched.h>
11#include <linux/mm.h>
12#include <linux/smp.h>
13#include <linux/kernel.h>
14#include <linux/signal.h>
15#include <linux/errno.h>
16#include <linux/wait.h>
17#include <linux/ptrace.h>
18#include <linux/unistd.h>
19#include <linux/stddef.h>
20#include <linux/personality.h>
21#include <linux/compiler.h>
22#include <asm/ucontext.h>
23#include <asm/uaccess.h>
24#include <asm/i387.h>
25#include <asm/proto.h>
26#include <asm/ia32_unistd.h>
27#include <asm/mce.h>
28
29
30
31#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
32
33int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
34 sigset_t *set, struct pt_regs * regs);
35int ia32_setup_frame(int sig, struct k_sigaction *ka,
36 sigset_t *set, struct pt_regs * regs);
37
38asmlinkage long
39sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
40 struct pt_regs *regs)
41{
42 return do_sigaltstack(uss, uoss, regs->rsp);
43}
44
45
46
47
48
49
50struct rt_sigframe
51{
52 char __user *pretcode;
53 struct ucontext uc;
54 struct siginfo info;
55};
56
57static int
58restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, unsigned long *prax)
59{
60 unsigned int err = 0;
61
62
63 current_thread_info()->restart_block.fn = do_no_restart_syscall;
64
65#define COPY(x) err |= __get_user(regs->x, &sc->x)
66
67 COPY(rdi); COPY(rsi); COPY(rbp); COPY(rsp); COPY(rbx);
68 COPY(rdx); COPY(rcx); COPY(rip);
69 COPY(r8);
70 COPY(r9);
71 COPY(r10);
72 COPY(r11);
73 COPY(r12);
74 COPY(r13);
75 COPY(r14);
76 COPY(r15);
77
78
79
80
81 {
82 unsigned cs;
83 err |= __get_user(cs, &sc->cs);
84 regs->cs = cs | 3;
85 }
86
87 {
88 unsigned int tmpflags;
89 err |= __get_user(tmpflags, &sc->eflags);
90 regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
91 regs->orig_rax = -1;
92 }
93
94 {
95 struct _fpstate __user * buf;
96 err |= __get_user(buf, &sc->fpstate);
97
98 if (buf) {
99 if (!access_ok(VERIFY_READ, buf, sizeof(*buf)))
100 goto badframe;
101 err |= restore_i387(buf);
102 } else {
103 struct task_struct *me = current;
104 if (used_math()) {
105 clear_fpu(me);
106 clear_used_math();
107 }
108 }
109 }
110
111 err |= __get_user(*prax, &sc->rax);
112 return err;
113
114badframe:
115 return 1;
116}
117
118asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
119{
120 struct rt_sigframe __user *frame;
121 sigset_t set;
122 unsigned long eax;
123
124 frame = (struct rt_sigframe __user *)(regs->rsp - 8);
125 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) {
126 goto badframe;
127 }
128 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) {
129 goto badframe;
130 }
131
132 sigdelsetmask(&set, ~_BLOCKABLE);
133 spin_lock_irq(¤t->sighand->siglock);
134 current->blocked = set;
135 recalc_sigpending();
136 spin_unlock_irq(¤t->sighand->siglock);
137
138 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &eax))
139 goto badframe;
140
141#ifdef DEBUG_SIG
142 printk("%d sigreturn rip:%lx rsp:%lx frame:%p rax:%lx\n",current->pid,regs->rip,regs->rsp,frame,eax);
143#endif
144
145 if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->rsp) == -EFAULT)
146 goto badframe;
147
148 return eax;
149
150badframe:
151 signal_fault(regs,frame,"sigreturn");
152 return 0;
153}
154
155
156
157
158
159static inline int
160setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask, struct task_struct *me)
161{
162 int err = 0;
163
164 err |= __put_user(regs->cs, &sc->cs);
165 err |= __put_user(0, &sc->gs);
166 err |= __put_user(0, &sc->fs);
167
168 err |= __put_user(regs->rdi, &sc->rdi);
169 err |= __put_user(regs->rsi, &sc->rsi);
170 err |= __put_user(regs->rbp, &sc->rbp);
171 err |= __put_user(regs->rsp, &sc->rsp);
172 err |= __put_user(regs->rbx, &sc->rbx);
173 err |= __put_user(regs->rdx, &sc->rdx);
174 err |= __put_user(regs->rcx, &sc->rcx);
175 err |= __put_user(regs->rax, &sc->rax);
176 err |= __put_user(regs->r8, &sc->r8);
177 err |= __put_user(regs->r9, &sc->r9);
178 err |= __put_user(regs->r10, &sc->r10);
179 err |= __put_user(regs->r11, &sc->r11);
180 err |= __put_user(regs->r12, &sc->r12);
181 err |= __put_user(regs->r13, &sc->r13);
182 err |= __put_user(regs->r14, &sc->r14);
183 err |= __put_user(regs->r15, &sc->r15);
184 err |= __put_user(me->thread.trap_no, &sc->trapno);
185 err |= __put_user(me->thread.error_code, &sc->err);
186 err |= __put_user(regs->rip, &sc->rip);
187 err |= __put_user(regs->eflags, &sc->eflags);
188 err |= __put_user(mask, &sc->oldmask);
189 err |= __put_user(me->thread.cr2, &sc->cr2);
190
191 return err;
192}
193
194
195
196
197
198static void __user *
199get_stack(struct k_sigaction *ka, struct pt_regs *regs, unsigned long size)
200{
201 unsigned long rsp;
202
203
204 rsp = regs->rsp - 128;
205
206
207 if (ka->sa.sa_flags & SA_ONSTACK) {
208 if (sas_ss_flags(rsp) == 0)
209 rsp = current->sas_ss_sp + current->sas_ss_size;
210 }
211
212 return (void __user *)round_down(rsp - size, 16);
213}
214
215static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
216 sigset_t *set, struct pt_regs * regs)
217{
218 struct rt_sigframe __user *frame;
219 struct _fpstate __user *fp = NULL;
220 int err = 0;
221 struct task_struct *me = current;
222
223 if (used_math()) {
224 fp = get_stack(ka, regs, sizeof(struct _fpstate));
225 frame = (void __user *)round_down(
226 (unsigned long)fp - sizeof(struct rt_sigframe), 16) - 8;
227
228 if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate)))
229 goto give_sigsegv;
230
231 if (save_i387(fp) < 0)
232 err |= -1;
233 } else
234 frame = get_stack(ka, regs, sizeof(struct rt_sigframe)) - 8;
235
236 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
237 goto give_sigsegv;
238
239 if (ka->sa.sa_flags & SA_SIGINFO) {
240 err |= copy_siginfo_to_user(&frame->info, info);
241 if (err)
242 goto give_sigsegv;
243 }
244
245
246 err |= __put_user(0, &frame->uc.uc_flags);
247 err |= __put_user(0, &frame->uc.uc_link);
248 err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
249 err |= __put_user(sas_ss_flags(regs->rsp),
250 &frame->uc.uc_stack.ss_flags);
251 err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
252 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0], me);
253 err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate);
254 if (sizeof(*set) == 16) {
255 __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]);
256 __put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]);
257 } else
258 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
259
260
261
262
263 if (ka->sa.sa_flags & SA_RESTORER) {
264 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
265 } else {
266
267 goto give_sigsegv;
268 }
269
270 if (err)
271 goto give_sigsegv;
272
273#ifdef DEBUG_SIG
274 printk("%d old rip %lx old rsp %lx old rax %lx\n", current->pid,regs->rip,regs->rsp,regs->rax);
275#endif
276
277
278 regs->rdi = sig;
279
280 regs->rax = 0;
281
282
283
284 regs->rsi = (unsigned long)&frame->info;
285 regs->rdx = (unsigned long)&frame->uc;
286 regs->rip = (unsigned long) ka->sa.sa_handler;
287
288 regs->rsp = (unsigned long)frame;
289
290
291
292 regs->cs = __USER_CS;
293
294
295
296 set_fs(USER_DS);
297
298 regs->eflags &= ~TF_MASK;
299 if (test_thread_flag(TIF_SINGLESTEP))
300 ptrace_notify(SIGTRAP);
301#ifdef DEBUG_SIG
302 printk("SIG deliver (%s:%d): sp=%p pc=%lx ra=%p\n",
303 current->comm, current->pid, frame, regs->rip, frame->pretcode);
304#endif
305
306 return 0;
307
308give_sigsegv:
309 force_sigsegv(sig, current);
310 return -EFAULT;
311}
312
313
314
315
316
317static int
318handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
319 sigset_t *oldset, struct pt_regs *regs)
320{
321 int ret;
322
323#ifdef DEBUG_SIG
324 printk("handle_signal pid:%d sig:%lu rip:%lx rsp:%lx regs=%p\n",
325 current->pid, sig,
326 regs->rip, regs->rsp, regs);
327#endif
328
329
330 if ((long)regs->orig_rax >= 0) {
331
332 switch (regs->rax) {
333 case -ERESTART_RESTARTBLOCK:
334 case -ERESTARTNOHAND:
335 regs->rax = -EINTR;
336 break;
337
338 case -ERESTARTSYS:
339 if (!(ka->sa.sa_flags & SA_RESTART)) {
340 regs->rax = -EINTR;
341 break;
342 }
343
344 case -ERESTARTNOINTR:
345 regs->rax = regs->orig_rax;
346 regs->rip -= 2;
347 break;
348 }
349 }
350
351
352
353
354
355
356 if (unlikely(regs->eflags & TF_MASK)) {
357 if (likely(current->ptrace & PT_DTRACE)) {
358 current->ptrace &= ~PT_DTRACE;
359 regs->eflags &= ~TF_MASK;
360 }
361 }
362
363#ifdef CONFIG_IA32_EMULATION
364 if (test_thread_flag(TIF_IA32)) {
365 if (ka->sa.sa_flags & SA_SIGINFO)
366 ret = ia32_setup_rt_frame(sig, ka, info, oldset, regs);
367 else
368 ret = ia32_setup_frame(sig, ka, oldset, regs);
369 } else
370#endif
371 ret = setup_rt_frame(sig, ka, info, oldset, regs);
372
373 if (ret == 0) {
374 spin_lock_irq(¤t->sighand->siglock);
375 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
376 if (!(ka->sa.sa_flags & SA_NODEFER))
377 sigaddset(¤t->blocked,sig);
378 recalc_sigpending();
379 spin_unlock_irq(¤t->sighand->siglock);
380 }
381
382 return ret;
383}
384
385
386
387
388
389
390static void do_signal(struct pt_regs *regs)
391{
392 struct k_sigaction ka;
393 siginfo_t info;
394 int signr;
395 sigset_t *oldset;
396
397
398
399
400
401
402
403 if (!user_mode(regs))
404 return;
405
406 if (test_thread_flag(TIF_RESTORE_SIGMASK))
407 oldset = ¤t->saved_sigmask;
408 else
409 oldset = ¤t->blocked;
410
411 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
412 if (signr > 0) {
413
414
415
416
417
418 if (current->thread.debugreg7)
419 set_debugreg(current->thread.debugreg7, 7);
420
421
422 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
423
424
425
426
427 clear_thread_flag(TIF_RESTORE_SIGMASK);
428 }
429 return;
430 }
431
432
433 if ((long)regs->orig_rax >= 0) {
434
435 long res = regs->rax;
436 switch (res) {
437 case -ERESTARTNOHAND:
438 case -ERESTARTSYS:
439 case -ERESTARTNOINTR:
440 regs->rax = regs->orig_rax;
441 regs->rip -= 2;
442 break;
443 case -ERESTART_RESTARTBLOCK:
444 regs->rax = test_thread_flag(TIF_IA32) ?
445 __NR_ia32_restart_syscall :
446 __NR_restart_syscall;
447 regs->rip -= 2;
448 break;
449 }
450 }
451
452
453
454 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
455 clear_thread_flag(TIF_RESTORE_SIGMASK);
456 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
457 }
458}
459
460void
461do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
462{
463#ifdef DEBUG_SIG
464 printk("do_notify_resume flags:%x rip:%lx rsp:%lx caller:%p pending:%x\n",
465 thread_info_flags, regs->rip, regs->rsp, __builtin_return_address(0),signal_pending(current));
466#endif
467
468
469 if (thread_info_flags & _TIF_SINGLESTEP) {
470 regs->eflags |= TF_MASK;
471 clear_thread_flag(TIF_SINGLESTEP);
472 }
473
474#ifdef CONFIG_X86_MCE
475
476 if (thread_info_flags & _TIF_MCE_NOTIFY)
477 mce_notify_user();
478#endif
479
480
481 if (thread_info_flags & (_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK))
482 do_signal(regs);
483}
484
485void signal_fault(struct pt_regs *regs, void __user *frame, char *where)
486{
487 struct task_struct *me = current;
488 if (show_unhandled_signals && printk_ratelimit())
489 printk("%s[%d] bad frame in %s frame:%p rip:%lx rsp:%lx orax:%lx\n",
490 me->comm,me->pid,where,frame,regs->rip,regs->rsp,regs->orig_rax);
491
492 force_sig(SIGSEGV, me);
493}
494