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