?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: ia32_signal: cleanup macro RELOAD_SEG
[linux-2.6/verdex.git] / arch / x86 / ia32 / ia32_signal.c
blob2c56e6857d1a13f1f0d75d108fdd22c2bdeac8db
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/proto.h>
33 #include <asm/vdso.h>
34
35 #define DEBUG_SIG 0
36
37 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
38
39 #define FIX_EFLAGS (X86_EFLAGS_AC | X86_EFLAGS_OF | \
40 X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \
41 X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \
42 X86_EFLAGS_CF)
43
44 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
45 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
46
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
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
125 asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
126 {
127 mask &= _BLOCKABLE;
128 spin_lock_irq(&current->sighand->siglock);
129 current->saved_sigmask = current->blocked;
130 siginitset(&current->blocked, mask);
131 recalc_sigpending();
132 spin_unlock_irq(&current->sighand->siglock);
133
134 current->state = TASK_INTERRUPTIBLE;
135 schedule();
136 set_restore_sigmask();
137 return -ERESTARTNOHAND;
138 }
139
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
177 struct sigframe
178 {
179 u32 pretcode;
180 int sig;
181 struct sigcontext_ia32 sc;
182 struct _fpstate_ia32 fpstate_unused; /* look at kernel/sigframe.h */
183 unsigned int extramask[_COMPAT_NSIG_WORDS-1];
184 char retcode[8];
185 /* fp state follows here */
186 };
187
188 struct rt_sigframe
189 {
190 u32 pretcode;
191 int sig;
192 u32 pinfo;
193 u32 puc;
194 compat_siginfo_t info;
195 struct ucontext_ia32 uc;
196 char retcode[8];
197 /* fp state follows here */
198 };
199
200 #define COPY(x) { \
201 err |= __get_user(regs->x, &sc->x); \
202 }
203
204 #define COPY_SEG_CPL3(seg) { \
205 unsigned short tmp; \
206 err |= __get_user(tmp, &sc->seg); \
207 regs->seg = tmp | 3; \
208 }
209
210 #define RELOAD_SEG(seg) { \
211 unsigned int cur, pre; \
212 err |= __get_user(pre, &sc->seg); \
213 savesegment(seg, cur); \
214 pre |= 3; \
215 if (pre != cur) \
216 loadsegment(seg, pre); \
217 }
218
219 static int ia32_restore_sigcontext(struct pt_regs *regs,
220 struct sigcontext_ia32 __user *sc,
221 unsigned int *peax)
222 {
223 unsigned int tmpflags, gs, oldgs, err = 0;
224 void __user *buf;
225 u32 tmp;
226
227 /* Always make any pending restarted system calls return -EINTR */
228 current_thread_info()->restart_block.fn = do_no_restart_syscall;
229
230 #if DEBUG_SIG
231 printk(KERN_DEBUG "SIG restore_sigcontext: "
232 "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
233 sc, sc->err, sc->ip, sc->cs, sc->flags);
234 #endif
235
236 /*
237 * Reload fs and gs if they have changed in the signal
238 * handler. This does not handle long fs/gs base changes in
239 * the handler, but does not clobber them at least in the
240 * normal case.
241 */
242 err |= __get_user(gs, &sc->gs);
243 gs |= 3;
244 savesegment(gs, oldgs);
245 if (gs != oldgs)
246 load_gs_index(gs);
247
248 RELOAD_SEG(fs);
249 RELOAD_SEG(ds);
250 RELOAD_SEG(es);
251
252 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
253 COPY(dx); COPY(cx); COPY(ip);
254 /* Don't touch extended registers */
255
256 COPY_SEG_CPL3(cs);
257 COPY_SEG_CPL3(ss);
258
259 err |= __get_user(tmpflags, &sc->flags);
260 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
261 /* disable syscall checks */
262 regs->orig_ax = -1;
263
264 err |= __get_user(tmp, &sc->fpstate);
265 buf = compat_ptr(tmp);
266 err |= restore_i387_xstate_ia32(buf);
267
268 err |= __get_user(tmp, &sc->ax);
269 *peax = tmp;
270
271 return err;
272 }
273
274 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
275 {
276 struct sigframe __user *frame = (struct sigframe __user *)(regs->sp-8);
277 sigset_t set;
278 unsigned int ax;
279
280 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
281 goto badframe;
282 if (__get_user(set.sig[0], &frame->sc.oldmask)
283 || (_COMPAT_NSIG_WORDS > 1
284 && __copy_from_user((((char *) &set.sig) + 4),
285 &frame->extramask,
286 sizeof(frame->extramask))))
287 goto badframe;
288
289 sigdelsetmask(&set, ~_BLOCKABLE);
290 spin_lock_irq(&current->sighand->siglock);
291 current->blocked = set;
292 recalc_sigpending();
293 spin_unlock_irq(&current->sighand->siglock);
294
295 if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
296 goto badframe;
297 return ax;
298
299 badframe:
300 signal_fault(regs, frame, "32bit sigreturn");
301 return 0;
302 }
303
304 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
305 {
306 struct rt_sigframe __user *frame;
307 sigset_t set;
308 unsigned int ax;
309 struct pt_regs tregs;
310
311 frame = (struct rt_sigframe __user *)(regs->sp - 4);
312
313 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
314 goto badframe;
315 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
316 goto badframe;
317
318 sigdelsetmask(&set, ~_BLOCKABLE);
319 spin_lock_irq(&current->sighand->siglock);
320 current->blocked = set;
321 recalc_sigpending();
322 spin_unlock_irq(&current->sighand->siglock);
323
324 if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
325 goto badframe;
326
327 tregs = *regs;
328 if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
329 goto badframe;
330
331 return ax;
332
333 badframe:
334 signal_fault(regs, frame, "32bit rt sigreturn");
335 return 0;
336 }
337
338 /*
339 * Set up a signal frame.
340 */
341
342 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
343 void __user *fpstate,
344 struct pt_regs *regs, unsigned int mask)
345 {
346 int tmp, err = 0;
347
348 savesegment(gs, tmp);
349 err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
350 savesegment(fs, tmp);
351 err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
352 savesegment(ds, tmp);
353 err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
354 savesegment(es, tmp);
355 err |= __put_user(tmp, (unsigned int __user *)&sc->es);
356
357 err |= __put_user(regs->di, &sc->di);
358 err |= __put_user(regs->si, &sc->si);
359 err |= __put_user(regs->bp, &sc->bp);
360 err |= __put_user(regs->sp, &sc->sp);
361 err |= __put_user(regs->bx, &sc->bx);
362 err |= __put_user(regs->dx, &sc->dx);
363 err |= __put_user(regs->cx, &sc->cx);
364 err |= __put_user(regs->ax, &sc->ax);
365 err |= __put_user(regs->cs, &sc->cs);
366 err |= __put_user(regs->ss, &sc->ss);
367 err |= __put_user(current->thread.trap_no, &sc->trapno);
368 err |= __put_user(current->thread.error_code, &sc->err);
369 err |= __put_user(regs->ip, &sc->ip);
370 err |= __put_user(regs->flags, &sc->flags);
371 err |= __put_user(regs->sp, &sc->sp_at_signal);
372
373 err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);
374
375 /* non-iBCS2 extensions.. */
376 err |= __put_user(mask, &sc->oldmask);
377 err |= __put_user(current->thread.cr2, &sc->cr2);
378
379 return err;
380 }
381
382 /*
383 * Determine which stack to use..
384 */
385 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
386 size_t frame_size,
387 void **fpstate)
388 {
389 unsigned long sp;
390
391 /* Default to using normal stack */
392 sp = regs->sp;
393
394 /* This is the X/Open sanctioned signal stack switching. */
395 if (ka->sa.sa_flags & SA_ONSTACK) {
396 if (sas_ss_flags(sp) == 0)
397 sp = current->sas_ss_sp + current->sas_ss_size;
398 }
399
400 /* This is the legacy signal stack switching. */
401 else if ((regs->ss & 0xffff) != __USER_DS &&
402 !(ka->sa.sa_flags & SA_RESTORER) &&
403 ka->sa.sa_restorer)
404 sp = (unsigned long) ka->sa.sa_restorer;
405
406 if (used_math()) {
407 sp = sp - sig_xstate_ia32_size;
408 *fpstate = (struct _fpstate_ia32 *) sp;
409 if (save_i387_xstate_ia32(*fpstate) < 0)
410 return (void __user *) -1L;
411 }
412
413 sp -= frame_size;
414 /* Align the stack pointer according to the i386 ABI,
415 * i.e. so that on function entry ((sp + 4) & 15) == 0. */
416 sp = ((sp + 4) & -16ul) - 4;
417 return (void __user *) sp;
418 }
419
420 int ia32_setup_frame(int sig, struct k_sigaction *ka,
421 compat_sigset_t *set, struct pt_regs *regs)
422 {
423 struct sigframe __user *frame;
424 void __user *restorer;
425 int err = 0;
426 void __user *fpstate = NULL;
427
428 /* copy_to_user optimizes that into a single 8 byte store */
429 static const struct {
430 u16 poplmovl;
431 u32 val;
432 u16 int80;
433 } __attribute__((packed)) code = {
434 0xb858, /* popl %eax ; movl $...,%eax */
435 __NR_ia32_sigreturn,
436 0x80cd, /* int $0x80 */
437 };
438
439 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
440
441 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
442 return -EFAULT;
443
444 if (__put_user(sig, &frame->sig))
445 return -EFAULT;
446
447 if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
448 return -EFAULT;
449
450 if (_COMPAT_NSIG_WORDS > 1) {
451 if (__copy_to_user(frame->extramask, &set->sig[1],
452 sizeof(frame->extramask)))
453 return -EFAULT;
454 }
455
456 if (ka->sa.sa_flags & SA_RESTORER) {
457 restorer = ka->sa.sa_restorer;
458 } else {
459 /* Return stub is in 32bit vsyscall page */
460 if (current->mm->context.vdso)
461 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
462 sigreturn);
463 else
464 restorer = &frame->retcode;
465 }
466 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
467
468 /*
469 * These are actually not used anymore, but left because some
470 * gdb versions depend on them as a marker.
471 */
472 err |= __copy_to_user(frame->retcode, &code, 8);
473 if (err)
474 return -EFAULT;
475
476 /* Set up registers for signal handler */
477 regs->sp = (unsigned long) frame;
478 regs->ip = (unsigned long) ka->sa.sa_handler;
479
480 /* Make -mregparm=3 work */
481 regs->ax = sig;
482 regs->dx = 0;
483 regs->cx = 0;
484
485 loadsegment(ds, __USER32_DS);
486 loadsegment(es, __USER32_DS);
487
488 regs->cs = __USER32_CS;
489 regs->ss = __USER32_DS;
490
491 #if DEBUG_SIG
492 printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
493 current->comm, current->pid, frame, regs->ip, frame->pretcode);
494 #endif
495
496 return 0;
497 }
498
499 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
500 compat_sigset_t *set, struct pt_regs *regs)
501 {
502 struct rt_sigframe __user *frame;
503 void __user *restorer;
504 int err = 0;
505 void __user *fpstate = NULL;
506
507 /* __copy_to_user optimizes that into a single 8 byte store */
508 static const struct {
509 u8 movl;
510 u32 val;
511 u16 int80;
512 u8 pad;
513 } __attribute__((packed)) code = {
514 0xb8,
515 __NR_ia32_rt_sigreturn,
516 0x80cd,
517 0,
518 };
519
520 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
521
522 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
523 return -EFAULT;
524
525 err |= __put_user(sig, &frame->sig);
526 err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
527 err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
528 err |= copy_siginfo_to_user32(&frame->info, info);
529 if (err)
530 return -EFAULT;
531
532 /* Create the ucontext. */
533 if (cpu_has_xsave)
534 err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);
535 else
536 err |= __put_user(0, &frame->uc.uc_flags);
537 err |= __put_user(0, &frame->uc.uc_link);
538 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
539 err |= __put_user(sas_ss_flags(regs->sp),
540 &frame->uc.uc_stack.ss_flags);
541 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
542 err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
543 regs, set->sig[0]);
544 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
545 if (err)
546 return -EFAULT;
547
548 if (ka->sa.sa_flags & SA_RESTORER)
549 restorer = ka->sa.sa_restorer;
550 else
551 restorer = VDSO32_SYMBOL(current->mm->context.vdso,
552 rt_sigreturn);
553 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
554
555 /*
556 * Not actually used anymore, but left because some gdb
557 * versions need it.
558 */
559 err |= __copy_to_user(frame->retcode, &code, 8);
560 if (err)
561 return -EFAULT;
562
563 /* Set up registers for signal handler */
564 regs->sp = (unsigned long) frame;
565 regs->ip = (unsigned long) ka->sa.sa_handler;
566
567 /* Make -mregparm=3 work */
568 regs->ax = sig;
569 regs->dx = (unsigned long) &frame->info;
570 regs->cx = (unsigned long) &frame->uc;
571
572 /* Make -mregparm=3 work */
573 regs->ax = sig;
574 regs->dx = (unsigned long) &frame->info;
575 regs->cx = (unsigned long) &frame->uc;
576
577 loadsegment(ds, __USER32_DS);
578 loadsegment(es, __USER32_DS);
579
580 regs->cs = __USER32_CS;
581 regs->ss = __USER32_DS;
582
583 #if DEBUG_SIG
584 printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
585 current->comm, current->pid, frame, regs->ip, frame->pretcode);
586 #endif
587
588 return 0;
589 }
Verdex Pro support