1 /*
2 * linux/arch/x86_64/ia32/ia32_signal.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
7 * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes
8 * 2000-12-* x86-64 compatibility mode signal handling by Andi Kleen
9 */
10
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/kernel.h>
15 #include <linux/signal.h>
16 #include <linux/errno.h>
17 #include <linux/wait.h>
18 #include <linux/ptrace.h>
19 #include <linux/unistd.h>
20 #include <linux/stddef.h>
21 #include <linux/personality.h>
22 #include <linux/compat.h>
23 #include <linux/binfmts.h>
24 #include <asm/ucontext.h>
25 #include <asm/uaccess.h>
26 #include <asm/i387.h>
27 #include <asm/ptrace.h>
28 #include <asm/ia32_unistd.h>
29 #include <asm/user32.h>
30 #include <asm/sigcontext32.h>
31 #include <asm/proto.h>
32 #include <asm/vdso.h>
33 #include <asm/sigframe.h>
34 #include <asm/sys_ia32.h>
35
36 #define DEBUG_SIG 0
37
38 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
39
40 #define FIX_EFLAGS (X86_EFLAGS_AC | X86_EFLAGS_OF | \
41 X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \
42 X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \
43 X86_EFLAGS_CF)
44
45 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
46
copy_siginfo_to_user32(compat_siginfo_t __user * to,siginfo_t * from)47 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
48 {
49 int err;
50
51 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
52 return -EFAULT;
53
54 /* If you change siginfo_t structure, please make sure that
55 this code is fixed accordingly.
56 It should never copy any pad contained in the structure
57 to avoid security leaks, but must copy the generic
58 3 ints plus the relevant union member. */
59 err = __put_user(from->si_signo, &to->si_signo);
60 err |= __put_user(from->si_errno, &to->si_errno);
61 err |= __put_user((short)from->si_code, &to->si_code);
62
63 if (from->si_code < 0) {
64 err |= __put_user(from->si_pid, &to->si_pid);
65 err |= __put_user(from->si_uid, &to->si_uid);
66 err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
67 } else {
68 /*
69 * First 32bits of unions are always present:
70 * si_pid === si_band === si_tid === si_addr(LS half)
71 */
72 err |= __put_user(from->_sifields._pad[0],
73 &to->_sifields._pad[0]);
74 switch (from->si_code >> 16) {
75 case __SI_FAULT >> 16:
76 break;
77 case __SI_CHLD >> 16:
78 err |= __put_user(from->si_utime, &to->si_utime);
79 err |= __put_user(from->si_stime, &to->si_stime);
80 err |= __put_user(from->si_status, &to->si_status);
81 /* FALL THROUGH */
82 default:
83 case __SI_KILL >> 16:
84 err |= __put_user(from->si_uid, &to->si_uid);
85 break;
86 case __SI_POLL >> 16:
87 err |= __put_user(from->si_fd, &to->si_fd);
88 break;
89 case __SI_TIMER >> 16:
90 err |= __put_user(from->si_overrun, &to->si_overrun);
91 err |= __put_user(ptr_to_compat(from->si_ptr),
92 &to->si_ptr);
93 break;
94 /* This is not generated by the kernel as of now. */
95 case __SI_RT >> 16:
96 case __SI_MESGQ >> 16:
97 err |= __put_user(from->si_uid, &to->si_uid);
98 err |= __put_user(from->si_int, &to->si_int);
99 break;
100 }
101 }
102 return err;
103 }
104
copy_siginfo_from_user32(siginfo_t * to,compat_siginfo_t __user * from)105 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
106 {
107 int err;
108 u32 ptr32;
109
110 if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
111 return -EFAULT;
112
113 err = __get_user(to->si_signo, &from->si_signo);
114 err |= __get_user(to->si_errno, &from->si_errno);
115 err |= __get_user(to->si_code, &from->si_code);
116
117 err |= __get_user(to->si_pid, &from->si_pid);
118 err |= __get_user(to->si_uid, &from->si_uid);
119 err |= __get_user(ptr32, &from->si_ptr);
120 to->si_ptr = compat_ptr(ptr32);
121
122 return err;
123 }
124
sys32_sigsuspend(int history0,int history1,old_sigset_t mask)125 asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
126 {
127 mask &= _BLOCKABLE;
128 spin_lock_irq(¤t->sighand->siglock);
129 current->saved_sigmask = current->blocked;
130 siginitset(¤t->blocked, mask);
131 recalc_sigpending();
132 spin_unlock_irq(¤t->sighand->siglock);
133
134 current->state = TASK_INTERRUPTIBLE;
135 schedule();
136 set_restore_sigmask();
137 return -ERESTARTNOHAND;
138 }
139
sys32_sigaltstack(const stack_ia32_t __user * uss_ptr,stack_ia32_t __user * uoss_ptr,struct pt_regs * regs)140 asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
141 stack_ia32_t __user *uoss_ptr,
142 struct pt_regs *regs)
143 {
144 stack_t uss, uoss;
145 int ret;
146 mm_segment_t seg;
147
148 if (uss_ptr) {
149 u32 ptr;
150
151 memset(&uss, 0, sizeof(stack_t));
152 if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)) ||
153 __get_user(ptr, &uss_ptr->ss_sp) ||
154 __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
155 __get_user(uss.ss_size, &uss_ptr->ss_size))
156 return -EFAULT;
157 uss.ss_sp = compat_ptr(ptr);
158 }
159 seg = get_fs();
160 set_fs(KERNEL_DS);
161 ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);
162 set_fs(seg);
163 if (ret >= 0 && uoss_ptr) {
164 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)) ||
165 __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
166 __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
167 __put_user(uoss.ss_size, &uoss_ptr->ss_size))
168 ret = -EFAULT;
169 }
170 return ret;
171 }
172
173 /*
174 * Do a signal return; undo the signal stack.
175 */
176 #define COPY(x) { \
177 err |= __get_user(regs->x, &sc->x); \
178 }
179
180 #define COPY_SEG_CPL3(seg) { \
181 unsigned short tmp; \
182 err |= __get_user(tmp, &sc->seg); \
183 regs->seg = tmp | 3; \
184 }
185
186 #define RELOAD_SEG(seg) { \
187 unsigned int cur, pre; \
188 err |= __get_user(pre, &sc->seg); \
189 savesegment(seg, cur); \
190 pre |= 3; \
191 if (pre != cur) \
192 loadsegment(seg, pre); \
193 }
194
ia32_restore_sigcontext(struct pt_regs * regs,struct sigcontext_ia32 __user * sc,unsigned int * pax)195 static int ia32_restore_sigcontext(struct pt_regs *regs,
196 struct sigcontext_ia32 __user *sc,
197 unsigned int *pax)
198 {
199 unsigned int tmpflags, gs, oldgs, err = 0;
200 void __user *buf;
201 u32 tmp;
202
203 /* Always make any pending restarted system calls return -EINTR */
204 current_thread_info()->restart_block.fn = do_no_restart_syscall;
205
206 #if DEBUG_SIG
207 printk(KERN_DEBUG "SIG restore_sigcontext: "
208 "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
209 sc, sc->err, sc->ip, sc->cs, sc->flags);
210 #endif
211
212 /*
213 * Reload fs and gs if they have changed in the signal
214 * handler. This does not handle long fs/gs base changes in
215 * the handler, but does not clobber them at least in the
216 * normal case.
217 */
218 err |= __get_user(gs, &sc->gs);
219 gs |= 3;
220 savesegment(gs, oldgs);
221 if (gs != oldgs)
222 load_gs_index(gs);
223
224 RELOAD_SEG(fs);
225 RELOAD_SEG(ds);
226 RELOAD_SEG(es);
227
228 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
229 COPY(dx); COPY(cx); COPY(ip);
230 /* Don't touch extended registers */
231
232 COPY_SEG_CPL3(cs);
233 COPY_SEG_CPL3(ss);
234
235 err |= __get_user(tmpflags, &sc->flags);
236 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
237 /* disable syscall checks */
238 regs->orig_ax = -1;
239
240 err |= __get_user(tmp, &sc->fpstate);
241 buf = compat_ptr(tmp);
242 err |= restore_i387_xstate_ia32(buf);
243
244 err |= __get_user(*pax, &sc->ax);
245 return err;
246 }
247
sys32_sigreturn(struct pt_regs * regs)248 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
249 {
250 struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
251 sigset_t set;
252 unsigned int ax;
253
254 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
255 goto badframe;
256 if (__get_user(set.sig[0], &frame->sc.oldmask)
257 || (_COMPAT_NSIG_WORDS > 1
258 && __copy_from_user((((char *) &set.sig) + 4),
259 &frame->extramask,
260 sizeof(frame->extramask))))
261 goto badframe;
262
263 sigdelsetmask(&set, ~_BLOCKABLE);
264 spin_lock_irq(¤t->sighand->siglock);
265 current->blocked = set;
266 recalc_sigpending();
267 spin_unlock_irq(¤t->sighand->siglock);
268
269 if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
270 goto badframe;
271 return ax;
272
273 badframe:
274 signal_fault(regs, frame, "32bit sigreturn");
275 return 0;
276 }
277
sys32_rt_sigreturn(struct pt_regs * regs)278 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
279 {
280 struct rt_sigframe_ia32 __user *frame;
281 sigset_t set;
282 unsigned int ax;
283 struct pt_regs tregs;
284
285 frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
286
287 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
288 goto badframe;
289 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
290 goto badframe;
291
292 sigdelsetmask(&set, ~_BLOCKABLE);
293 spin_lock_irq(¤t->sighand->siglock);
294 current->blocked = set;
295 recalc_sigpending();
296 spin_unlock_irq(¤t->sighand->siglock);
297
298 if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
299 goto badframe;
300
301 tregs = *regs;
302 if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
303 goto badframe;
304
305 return ax;
306
307 badframe:
308 signal_fault(regs, frame, "32bit rt sigreturn");
309 return 0;
310 }
311
312 /*
313 * Set up a signal frame.
314 */
315
ia32_setup_sigcontext(struct sigcontext_ia32 __user * sc,void __user * fpstate,struct pt_regs * regs,unsigned int mask)316 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
317 void __user *fpstate,
318 struct pt_regs *regs, unsigned int mask)
319 {
320 int tmp, err = 0;
321
322 savesegment(gs, tmp);
323 err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
324 savesegment(fs, tmp);
325 err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
326 savesegment(ds, tmp);
327 err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
328 savesegment(es, tmp);
329 err |= __put_user(tmp, (unsigned int __user *)&sc->es);
330
331 err |= __put_user(regs->di, &sc->di);
332 err |= __put_user(regs->si, &sc->si);
333 err |= __put_user(regs->bp, &sc->bp);
334 err |= __put_user(regs->sp, &sc->sp);
335 err |= __put_user(regs->bx, &sc->bx);
336 err |= __put_user(regs->dx, &sc->dx);
337 err |= __put_user(regs->cx, &sc->cx);
338 err |= __put_user(regs->ax, &sc->ax);
339 err |= __put_user(current->thread.trap_no, &sc->trapno);
340 err |= __put_user(current->thread.error_code, &sc->err);
341 err |= __put_user(regs->ip, &sc->ip);
342 err |= __put_user(regs->cs, (unsigned int __user *)&sc->cs);
343 err |= __put_user(regs->flags, &sc->flags);
344 err |= __put_user(regs->sp, &sc->sp_at_signal);
345 err |= __put_user(regs->ss, (unsigned int __user *)&sc->ss);
346
347 err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
348
349 /* non-iBCS2 extensions.. */
350 err |= __put_user(mask, &sc->oldmask);
351 err |= __put_user(current->thread.cr2, &sc->cr2);
352
353 return err;
354 }
355
356 /*
357 * Determine which stack to use..
358 */
get_sigframe(struct k_sigaction * ka,struct pt_regs * regs,size_t frame_size,void ** fpstate)359 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
360 size_t frame_size,
361 void **fpstate)
362 {
363 unsigned long sp;
364
365 /* Default to using normal stack */
366 sp = regs->sp;
367
368 /* This is the X/Open sanctioned signal stack switching. */
369 if (ka->sa.sa_flags & SA_ONSTACK) {
370 if (sas_ss_flags(sp) == 0)
371 sp = current->sas_ss_sp + current->sas_ss_size;
372 }
373
374 /* This is the legacy signal stack switching. */
375 else if ((regs->ss & 0xffff) != __USER32_DS &&
376 !(ka->sa.sa_flags & SA_RESTORER) &&
377 ka->sa.sa_restorer)
378 sp = (unsigned long) ka->sa.sa_restorer;
379
380 if (used_math()) {
381 sp = sp - sig_xstate_ia32_size;
382 *fpstate = (struct _fpstate_ia32 *) sp;
383 if (save_i387_xstate_ia32(*fpstate) < 0)
384 return (void __user *) -1L;
385 }
386
387 sp -= frame_size;
388 /* Align the stack pointer according to the i386 ABI,
389 * i.e. so that on function entry ((sp + 4) & 15) == 0. */
390 sp = ((sp + 4) & -16ul) - 4;
391 return (void __user *) sp;
392 }
393
ia32_setup_frame(int sig,struct k_sigaction * ka,compat_sigset_t * set,struct pt_regs * regs)394 int ia32_setup_frame(int sig, struct k_sigaction *ka,
395 compat_sigset_t *set, struct pt_regs *regs)
396 {
397 struct sigframe_ia32 __user *frame;
398 void __user *restorer;
399 int err = 0;
400 void __user *fpstate = NULL;
401
402 /* copy_to_user optimizes that into a single 8 byte store */
403 static const struct {
404 u16 poplmovl;
405 u32 val;
406 u16 int80;
407 } __attribute__((packed)) code = {
408 0xb858, /* popl %eax ; movl $...,%eax */
409 __NR_ia32_sigreturn,
410 0x80cd, /* int $0x80 */
411 };
412
413 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
414
415 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
416 return -EFAULT;
417
418 if (__put_user(sig, &frame->sig))
419 return -EFAULT;
420
421 if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
422 return -EFAULT;
423
424 if (_COMPAT_NSIG_WORDS > 1) {
425 if (__copy_to_user(frame->extramask, &set->sig[1],
426 sizeof(frame->extramask)))
427 return -EFAULT;
428 }
429
430 if (ka->sa.sa_flags & SA_RESTORER) {
431 restorer = ka->sa.sa_restorer;
432 } else {
433 /* Return stub is in 32bit vsyscall page */
434 if (current->mm->context.vdso)
435 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
436 sigreturn);
437 else
438 restorer = &frame->retcode;
439 }
440 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
441
442 /*
443 * These are actually not used anymore, but left because some
444 * gdb versions depend on them as a marker.
445 */
446 err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);
447 if (err)
448 return -EFAULT;
449
450 /* Set up registers for signal handler */
451 regs->sp = (unsigned long) frame;
452 regs->ip = (unsigned long) ka->sa.sa_handler;
453
454 /* Make -mregparm=3 work */
455 regs->ax = sig;
456 regs->dx = 0;
457 regs->cx = 0;
458
459 loadsegment(ds, __USER32_DS);
460 loadsegment(es, __USER32_DS);
461
462 regs->cs = __USER32_CS;
463 regs->ss = __USER32_DS;
464
465 #if DEBUG_SIG
466 printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
467 current->comm, current->pid, frame, regs->ip, frame->pretcode);
468 #endif
469
470 return 0;
471 }
472
ia32_setup_rt_frame(int sig,struct k_sigaction * ka,siginfo_t * info,compat_sigset_t * set,struct pt_regs * regs)473 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
474 compat_sigset_t *set, struct pt_regs *regs)
475 {
476 struct rt_sigframe_ia32 __user *frame;
477 void __user *restorer;
478 int err = 0;
479 void __user *fpstate = NULL;
480
481 /* __copy_to_user optimizes that into a single 8 byte store */
482 static const struct {
483 u8 movl;
484 u32 val;
485 u16 int80;
486 u8 pad;
487 } __attribute__((packed)) code = {
488 0xb8,
489 __NR_ia32_rt_sigreturn,
490 0x80cd,
491 0,
492 };
493
494 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
495
496 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
497 return -EFAULT;
498
499 err |= __put_user(sig, &frame->sig);
500 err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
501 err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
502 err |= copy_siginfo_to_user32(&frame->info, info);
503 if (err)
504 return -EFAULT;
505
506 /* Create the ucontext. */
507 if (cpu_has_xsave)
508 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
509 else
510 err |= __put_user(0, &frame->uc.uc_flags);
511 err |= __put_user(0, &frame->uc.uc_link);
512 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
513 err |= __put_user(sas_ss_flags(regs->sp),
514 &frame->uc.uc_stack.ss_flags);
515 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
516 err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
517 regs, set->sig[0]);
518 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
519 if (err)
520 return -EFAULT;
521
522 if (ka->sa.sa_flags & SA_RESTORER)
523 restorer = ka->sa.sa_restorer;
524 else
525 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
526 rt_sigreturn);
527 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
528
529 /*
530 * Not actually used anymore, but left because some gdb
531 * versions need it.
532 */
533 err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);
534 if (err)
535 return -EFAULT;
536
537 /* Set up registers for signal handler */
538 regs->sp = (unsigned long) frame;
539 regs->ip = (unsigned long) ka->sa.sa_handler;
540
541 /* Make -mregparm=3 work */
542 regs->ax = sig;
543 regs->dx = (unsigned long) &frame->info;
544 regs->cx = (unsigned long) &frame->uc;
545
546 loadsegment(ds, __USER32_DS);
547 loadsegment(es, __USER32_DS);
548
549 regs->cs = __USER32_CS;
550 regs->ss = __USER32_DS;
551
552 #if DEBUG_SIG
553 printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
554 current->comm, current->pid, frame, regs->ip, frame->pretcode);
555 #endif
556
557 return 0;
558 }
559