2 * IA32 Architecture-specific signal handling support.
4 * Copyright (C) 1999, 2001-2002 Hewlett-Packard Co
5 * David Mosberger-Tang <davidm@hpl.hp.com>
6 * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
7 * Copyright (C) 2000 VA Linux Co
8 * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
10 * Derived from i386 and Alpha versions.
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
16 #include <linux/personality.h>
17 #include <linux/ptrace.h>
18 #include <linux/sched.h>
19 #include <linux/signal.h>
20 #include <linux/smp.h>
21 #include <linux/smp_lock.h>
22 #include <linux/stddef.h>
23 #include <linux/syscalls.h>
24 #include <linux/unistd.h>
25 #include <linux/wait.h>
26 #include <linux/compat.h>
28 #include <asm/intrinsics.h>
29 #include <asm/uaccess.h>
31 #include <asm/sigcontext.h>
32 #include <asm/segment.h>
36 #include "../kernel/sigframe.h"
38 #define A(__x) ((unsigned long)(__x))
41 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
43 #define __IA32_NR_sigreturn 119
44 #define __IA32_NR_rt_sigreturn 173
50 struct sigcontext_ia32 sc;
51 struct _fpstate_ia32 fpstate;
52 unsigned int extramask[_COMPAT_NSIG_WORDS-1];
56 struct rt_sigframe_ia32
63 struct ucontext_ia32 uc;
64 struct _fpstate_ia32 fpstate;
69 copy_siginfo_from_user32 (siginfo_t *to, siginfo_t32 *from)
74 if (!access_ok(VERIFY_READ, from, sizeof(siginfo_t32)))
77 err = __get_user(to->si_signo, &from->si_signo);
78 err |= __get_user(to->si_errno, &from->si_errno);
79 err |= __get_user(to->si_code, &from->si_code);
81 if (from->si_code < 0)
82 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
84 switch (from->si_code >> 16) {
86 err |= __get_user(to->si_utime, &from->si_utime);
87 err |= __get_user(to->si_stime, &from->si_stime);
88 err |= __get_user(to->si_status, &from->si_status);
90 err |= __get_user(to->si_pid, &from->si_pid);
91 err |= __get_user(to->si_uid, &from->si_uid);
93 case __SI_FAULT >> 16:
94 err |= __get_user(tmp, &from->si_addr);
95 to->si_addr = (void *) tmp;
98 err |= __get_user(to->si_band, &from->si_band);
99 err |= __get_user(to->si_fd, &from->si_fd);
101 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
102 case __SI_MESGQ >> 16:
103 err |= __get_user(to->si_pid, &from->si_pid);
104 err |= __get_user(to->si_uid, &from->si_uid);
105 err |= __get_user(to->si_int, &from->si_int);
113 copy_siginfo_to_user32 (siginfo_t32 *to, siginfo_t *from)
118 if (!access_ok(VERIFY_WRITE, to, sizeof(siginfo_t32)))
121 /* If you change siginfo_t structure, please be sure
122 this code is fixed accordingly.
123 It should never copy any pad contained in the structure
124 to avoid security leaks, but must copy the generic
125 3 ints plus the relevant union member.
126 This routine must convert siginfo from 64bit to 32bit as well
128 err = __put_user(from->si_signo, &to->si_signo);
129 err |= __put_user(from->si_errno, &to->si_errno);
130 err |= __put_user((short)from->si_code, &to->si_code);
131 if (from->si_code < 0)
132 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
134 switch (from->si_code >> 16) {
135 case __SI_CHLD >> 16:
136 err |= __put_user(from->si_utime, &to->si_utime);
137 err |= __put_user(from->si_stime, &to->si_stime);
138 err |= __put_user(from->si_status, &to->si_status);
140 err |= __put_user(from->si_pid, &to->si_pid);
141 err |= __put_user(from->si_uid, &to->si_uid);
143 case __SI_FAULT >> 16:
144 err |= __put_user((long)from->si_addr, &to->si_addr);
146 case __SI_POLL >> 16:
147 err |= __put_user(from->si_band, &to->si_band);
148 err |= __put_user(from->si_fd, &to->si_fd);
150 case __SI_TIMER >> 16:
151 err |= __put_user(from->si_tid, &to->si_tid);
152 err |= __put_user(from->si_overrun, &to->si_overrun);
153 addr = (unsigned long) from->si_ptr;
154 err |= __put_user(addr, &to->si_ptr);
156 case __SI_RT >> 16: /* Not generated by the kernel as of now. */
157 case __SI_MESGQ >> 16:
158 err |= __put_user(from->si_uid, &to->si_uid);
159 err |= __put_user(from->si_pid, &to->si_pid);
160 addr = (unsigned long) from->si_ptr;
161 err |= __put_user(addr, &to->si_ptr);
170 * SAVE and RESTORE of ia32 fpstate info, from ia64 current state
171 * Used in exception handler to pass the fpstate to the user, and restore
172 * the fpstate while returning from the exception handler.
174 * fpstate info and their mapping to IA64 regs:
175 * fpstate REG(BITS) Attribute Comments
176 * cw ar.fcr(0:12) with bits 7 and 6 not used
178 * tag ar.fsr(16:31) with odd numbered bits not used
179 * (read returns 0, writes ignored)
181 * cssel ar.fir(32:47)
182 * dataoff ar.fdr(0:31)
183 * datasel ar.fdr(32:47)
188 * _st[(3+TOS)%8] f11 (f8..f11 from ptregs)
189 * : : : (f12..f15 from live reg)
191 * _st[(7+TOS)%8] f15 TOS=sw.top(bits11:13)
193 * status Same as sw RO
194 * magic 0 as X86_FXSR_MAGIC in ia32
195 * mxcsr Bits(7:15)=ar.fcr(39:47)
196 * Bits(0:5) =ar.fsr(32:37) with bit 6 reserved
197 * _xmm[0..7] f16..f31 (live registers)
199 * Bit(64:127)=f17(0:63)
200 * Bit(0:63)=f16(0:63)
201 * All other fields unused...
205 save_ia32_fpstate_live (struct _fpstate_ia32 *save)
207 struct task_struct *tsk = current;
209 struct _fpreg_ia32 *fpregp;
211 unsigned long fsr, fcr, fir, fdr;
212 unsigned long new_fsr;
213 unsigned long num128[2];
214 unsigned long mxcsr=0;
215 int fp_tos, fr8_st_map;
217 if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
220 /* Read in fsr, fcr, fir, fdr and copy onto fpstate */
221 fsr = ia64_getreg(_IA64_REG_AR_FSR);
222 fcr = ia64_getreg(_IA64_REG_AR_FCR);
223 fir = ia64_getreg(_IA64_REG_AR_FIR);
224 fdr = ia64_getreg(_IA64_REG_AR_FDR);
227 * We need to clear the exception state before calling the signal handler. Clear
228 * the bits 15, bits 0-7 in fp status word. Similar to the functionality of fnclex
231 new_fsr = fsr & ~0x80ff;
232 ia64_setreg(_IA64_REG_AR_FSR, new_fsr);
234 __put_user(fcr & 0xffff, &save->cw);
235 __put_user(fsr & 0xffff, &save->sw);
236 __put_user((fsr>>16) & 0xffff, &save->tag);
237 __put_user(fir, &save->ipoff);
238 __put_user((fir>>32) & 0xffff, &save->cssel);
239 __put_user(fdr, &save->dataoff);
240 __put_user((fdr>>32) & 0xffff, &save->datasel);
241 __put_user(fsr & 0xffff, &save->status);
243 mxcsr = ((fcr>>32) & 0xff80) | ((fsr>>32) & 0x3f);
244 __put_user(mxcsr & 0xffff, &save->mxcsr);
245 __put_user( 0, &save->magic); //#define X86_FXSR_MAGIC 0x0000
248 * save f8..f11 from pt_regs
249 * save f12..f15 from live register set
252 * Find the location where f8 has to go in fp reg stack. This depends on
253 * TOP(11:13) field of sw. Other f reg continue sequentially from where f8 maps
256 fp_tos = (fsr>>11)&0x7;
257 fr8_st_map = (8-fp_tos)&0x7;
258 ptp = ia64_task_regs(tsk);
259 fpregp = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
260 ia64f2ia32f(fpregp, &ptp->f8);
261 copy_to_user(&save->_st[(0+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
262 ia64f2ia32f(fpregp, &ptp->f9);
263 copy_to_user(&save->_st[(1+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
264 ia64f2ia32f(fpregp, &ptp->f10);
265 copy_to_user(&save->_st[(2+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
266 ia64f2ia32f(fpregp, &ptp->f11);
267 copy_to_user(&save->_st[(3+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
269 ia64_stfe(fpregp, 12);
270 copy_to_user(&save->_st[(4+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
271 ia64_stfe(fpregp, 13);
272 copy_to_user(&save->_st[(5+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
273 ia64_stfe(fpregp, 14);
274 copy_to_user(&save->_st[(6+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
275 ia64_stfe(fpregp, 15);
276 copy_to_user(&save->_st[(7+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
278 ia64_stf8(&num128[0], 16);
279 ia64_stf8(&num128[1], 17);
280 copy_to_user(&save->_xmm[0], num128, sizeof(struct _xmmreg_ia32));
282 ia64_stf8(&num128[0], 18);
283 ia64_stf8(&num128[1], 19);
284 copy_to_user(&save->_xmm[1], num128, sizeof(struct _xmmreg_ia32));
286 ia64_stf8(&num128[0], 20);
287 ia64_stf8(&num128[1], 21);
288 copy_to_user(&save->_xmm[2], num128, sizeof(struct _xmmreg_ia32));
290 ia64_stf8(&num128[0], 22);
291 ia64_stf8(&num128[1], 23);
292 copy_to_user(&save->_xmm[3], num128, sizeof(struct _xmmreg_ia32));
294 ia64_stf8(&num128[0], 24);
295 ia64_stf8(&num128[1], 25);
296 copy_to_user(&save->_xmm[4], num128, sizeof(struct _xmmreg_ia32));
298 ia64_stf8(&num128[0], 26);
299 ia64_stf8(&num128[1], 27);
300 copy_to_user(&save->_xmm[5], num128, sizeof(struct _xmmreg_ia32));
302 ia64_stf8(&num128[0], 28);
303 ia64_stf8(&num128[1], 29);
304 copy_to_user(&save->_xmm[6], num128, sizeof(struct _xmmreg_ia32));
306 ia64_stf8(&num128[0], 30);
307 ia64_stf8(&num128[1], 31);
308 copy_to_user(&save->_xmm[7], num128, sizeof(struct _xmmreg_ia32));
313 restore_ia32_fpstate_live (struct _fpstate_ia32 *save)
315 struct task_struct *tsk = current;
318 unsigned long num128[2];
319 unsigned long num64, mxcsr;
320 struct _fpreg_ia32 *fpregp;
322 unsigned long fsr, fcr, fir, fdr;
323 int fp_tos, fr8_st_map;
325 if (!access_ok(VERIFY_READ, save, sizeof(*save)))
329 * Updating fsr, fcr, fir, fdr.
330 * Just a bit more complicated than save.
331 * - Need to make sure that we don't write any value other than the
332 * specific fpstate info
333 * - Need to make sure that the untouched part of frs, fdr, fir, fcr
334 * should remain same while writing.
335 * So, we do a read, change specific fields and write.
337 fsr = ia64_getreg(_IA64_REG_AR_FSR);
338 fcr = ia64_getreg(_IA64_REG_AR_FCR);
339 fir = ia64_getreg(_IA64_REG_AR_FIR);
340 fdr = ia64_getreg(_IA64_REG_AR_FDR);
342 __get_user(mxcsr, (unsigned int *)&save->mxcsr);
343 /* setting bits 0..5 8..12 with cw and 39..47 from mxcsr */
344 __get_user(lo, (unsigned int *)&save->cw);
345 num64 = mxcsr & 0xff10;
346 num64 = (num64 << 32) | (lo & 0x1f3f);
347 fcr = (fcr & (~0xff1000001f3f)) | num64;
349 /* setting bits 0..31 with sw and tag and 32..37 from mxcsr */
350 __get_user(lo, (unsigned int *)&save->sw);
351 /* set bits 15,7 (fsw.b, fsw.es) to reflect the current error status */
354 __get_user(hi, (unsigned int *)&save->tag);
355 num64 = mxcsr & 0x3f;
356 num64 = (num64 << 16) | (hi & 0xffff);
357 num64 = (num64 << 16) | (lo & 0xffff);
358 fsr = (fsr & (~0x3fffffffff)) | num64;
360 /* setting bits 0..47 with cssel and ipoff */
361 __get_user(lo, (unsigned int *)&save->ipoff);
362 __get_user(hi, (unsigned int *)&save->cssel);
364 num64 = (num64 << 32) | lo;
365 fir = (fir & (~0xffffffffffff)) | num64;
367 /* setting bits 0..47 with datasel and dataoff */
368 __get_user(lo, (unsigned int *)&save->dataoff);
369 __get_user(hi, (unsigned int *)&save->datasel);
371 num64 = (num64 << 32) | lo;
372 fdr = (fdr & (~0xffffffffffff)) | num64;
374 ia64_setreg(_IA64_REG_AR_FSR, fsr);
375 ia64_setreg(_IA64_REG_AR_FCR, fcr);
376 ia64_setreg(_IA64_REG_AR_FIR, fir);
377 ia64_setreg(_IA64_REG_AR_FDR, fdr);
380 * restore f8..f11 onto pt_regs
381 * restore f12..f15 onto live registers
384 * Find the location where f8 has to go in fp reg stack. This depends on
385 * TOP(11:13) field of sw. Other f reg continue sequentially from where f8 maps
388 fp_tos = (fsr>>11)&0x7;
389 fr8_st_map = (8-fp_tos)&0x7;
390 fpregp = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
392 ptp = ia64_task_regs(tsk);
393 copy_from_user(fpregp, &save->_st[(0+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
394 ia32f2ia64f(&ptp->f8, fpregp);
395 copy_from_user(fpregp, &save->_st[(1+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
396 ia32f2ia64f(&ptp->f9, fpregp);
397 copy_from_user(fpregp, &save->_st[(2+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
398 ia32f2ia64f(&ptp->f10, fpregp);
399 copy_from_user(fpregp, &save->_st[(3+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
400 ia32f2ia64f(&ptp->f11, fpregp);
402 copy_from_user(fpregp, &save->_st[(4+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
403 ia64_ldfe(12, fpregp);
404 copy_from_user(fpregp, &save->_st[(5+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
405 ia64_ldfe(13, fpregp);
406 copy_from_user(fpregp, &save->_st[(6+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
407 ia64_ldfe(14, fpregp);
408 copy_from_user(fpregp, &save->_st[(7+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
409 ia64_ldfe(15, fpregp);
411 copy_from_user(num128, &save->_xmm[0], sizeof(struct _xmmreg_ia32));
412 ia64_ldf8(16, &num128[0]);
413 ia64_ldf8(17, &num128[1]);
415 copy_from_user(num128, &save->_xmm[1], sizeof(struct _xmmreg_ia32));
416 ia64_ldf8(18, &num128[0]);
417 ia64_ldf8(19, &num128[1]);
419 copy_from_user(num128, &save->_xmm[2], sizeof(struct _xmmreg_ia32));
420 ia64_ldf8(20, &num128[0]);
421 ia64_ldf8(21, &num128[1]);
423 copy_from_user(num128, &save->_xmm[3], sizeof(struct _xmmreg_ia32));
424 ia64_ldf8(22, &num128[0]);
425 ia64_ldf8(23, &num128[1]);
427 copy_from_user(num128, &save->_xmm[4], sizeof(struct _xmmreg_ia32));
428 ia64_ldf8(24, &num128[0]);
429 ia64_ldf8(25, &num128[1]);
431 copy_from_user(num128, &save->_xmm[5], sizeof(struct _xmmreg_ia32));
432 ia64_ldf8(26, &num128[0]);
433 ia64_ldf8(27, &num128[1]);
435 copy_from_user(num128, &save->_xmm[6], sizeof(struct _xmmreg_ia32));
436 ia64_ldf8(28, &num128[0]);
437 ia64_ldf8(29, &num128[1]);
439 copy_from_user(num128, &save->_xmm[7], sizeof(struct _xmmreg_ia32));
440 ia64_ldf8(30, &num128[0]);
441 ia64_ldf8(31, &num128[1]);
446 sigact_set_handler (struct k_sigaction *sa, unsigned int handler, unsigned int restorer)
448 if (handler + 1 <= 2)
449 /* SIG_DFL, SIG_IGN, or SIG_ERR: must sign-extend to 64-bits */
450 sa->sa.sa_handler = (__sighandler_t) A((int) handler);
452 sa->sa.sa_handler = (__sighandler_t) (((unsigned long) restorer << 32) | handler);
456 ia32_rt_sigsuspend (compat_sigset_t *uset, unsigned int sigsetsize, struct sigscratch *scr)
458 extern long ia64_do_signal (sigset_t *oldset, struct sigscratch *scr, long in_syscall);
459 sigset_t oldset, set;
461 scr->scratch_unat = 0; /* avoid leaking kernel bits to user level */
462 memset(&set, 0, sizeof(&set));
464 if (sigsetsize > sizeof(sigset_t))
467 if (copy_from_user(&set.sig, &uset->sig, sigsetsize))
470 sigdelsetmask(&set, ~_BLOCKABLE);
472 spin_lock_irq(¤t->sighand->siglock);
474 oldset = current->blocked;
475 current->blocked = set;
478 spin_unlock_irq(¤t->sighand->siglock);
481 * The return below usually returns to the signal handler. We need to pre-set the
482 * correct error code here to ensure that the right values get saved in sigcontext
487 current->state = TASK_INTERRUPTIBLE;
489 if (ia64_do_signal(&oldset, scr, 1))
495 ia32_sigsuspend (unsigned int mask, struct sigscratch *scr)
497 return ia32_rt_sigsuspend((compat_sigset_t *)&mask, sizeof(mask), scr);
501 sys32_signal (int sig, unsigned int handler)
503 struct k_sigaction new_sa, old_sa;
506 sigact_set_handler(&new_sa, handler, 0);
507 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
509 ret = do_sigaction(sig, &new_sa, &old_sa);
511 return ret ? ret : IA32_SA_HANDLER(&old_sa);
515 sys32_rt_sigaction (int sig, struct sigaction32 *act,
516 struct sigaction32 *oact, unsigned int sigsetsize)
518 struct k_sigaction new_ka, old_ka;
519 unsigned int handler, restorer;
522 /* XXX: Don't preclude handling different sized sigset_t's. */
523 if (sigsetsize != sizeof(compat_sigset_t))
527 ret = get_user(handler, &act->sa_handler);
528 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
529 ret |= get_user(restorer, &act->sa_restorer);
530 ret |= copy_from_user(&new_ka.sa.sa_mask, &act->sa_mask, sizeof(compat_sigset_t));
534 sigact_set_handler(&new_ka, handler, restorer);
537 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
540 ret = put_user(IA32_SA_HANDLER(&old_ka), &oact->sa_handler);
541 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
542 ret |= put_user(IA32_SA_RESTORER(&old_ka), &oact->sa_restorer);
543 ret |= copy_to_user(&oact->sa_mask, &old_ka.sa.sa_mask, sizeof(compat_sigset_t));
550 sys32_rt_sigprocmask (int how, compat_sigset_t *set, compat_sigset_t *oset, unsigned int sigsetsize)
552 mm_segment_t old_fs = get_fs();
556 if (sigsetsize > sizeof(s))
560 memset(&s, 0, sizeof(s));
561 if (copy_from_user(&s.sig, set, sigsetsize))
565 ret = sys_rt_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL, sizeof(s));
570 if (copy_to_user(oset, &s.sig, sigsetsize))
577 sys32_rt_sigtimedwait (compat_sigset_t *uthese, siginfo_t32 *uinfo,
578 struct compat_timespec *uts, unsigned int sigsetsize)
580 extern int copy_siginfo_to_user32 (siginfo_t32 *, siginfo_t *);
581 mm_segment_t old_fs = get_fs();
587 if (copy_from_user(&s.sig, uthese, sizeof(compat_sigset_t)))
589 if (uts && get_compat_timespec(&t, uts))
592 ret = sys_rt_sigtimedwait(&s, uinfo ? &info : NULL, uts ? &t : NULL,
595 if (ret >= 0 && uinfo) {
596 if (copy_siginfo_to_user32(uinfo, &info))
603 sys32_rt_sigqueueinfo (int pid, int sig, siginfo_t32 *uinfo)
605 mm_segment_t old_fs = get_fs();
609 if (copy_siginfo_from_user32(&info, uinfo))
612 ret = sys_rt_sigqueueinfo(pid, sig, &info);
618 sys32_sigaction (int sig, struct old_sigaction32 *act, struct old_sigaction32 *oact)
620 struct k_sigaction new_ka, old_ka;
621 unsigned int handler, restorer;
625 compat_old_sigset_t mask;
627 ret = get_user(handler, &act->sa_handler);
628 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
629 ret |= get_user(restorer, &act->sa_restorer);
630 ret |= get_user(mask, &act->sa_mask);
634 sigact_set_handler(&new_ka, handler, restorer);
635 siginitset(&new_ka.sa.sa_mask, mask);
638 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
641 ret = put_user(IA32_SA_HANDLER(&old_ka), &oact->sa_handler);
642 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
643 ret |= put_user(IA32_SA_RESTORER(&old_ka), &oact->sa_restorer);
644 ret |= put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
651 setup_sigcontext_ia32 (struct sigcontext_ia32 *sc, struct _fpstate_ia32 *fpstate,
652 struct pt_regs *regs, unsigned long mask)
657 if (!access_ok(VERIFY_WRITE, sc, sizeof(*sc)))
660 err |= __put_user((regs->r16 >> 32) & 0xffff, (unsigned int *)&sc->fs);
661 err |= __put_user((regs->r16 >> 48) & 0xffff, (unsigned int *)&sc->gs);
662 err |= __put_user((regs->r16 >> 16) & 0xffff, (unsigned int *)&sc->es);
663 err |= __put_user(regs->r16 & 0xffff, (unsigned int *)&sc->ds);
664 err |= __put_user(regs->r15, &sc->edi);
665 err |= __put_user(regs->r14, &sc->esi);
666 err |= __put_user(regs->r13, &sc->ebp);
667 err |= __put_user(regs->r12, &sc->esp);
668 err |= __put_user(regs->r11, &sc->ebx);
669 err |= __put_user(regs->r10, &sc->edx);
670 err |= __put_user(regs->r9, &sc->ecx);
671 err |= __put_user(regs->r8, &sc->eax);
673 err |= __put_user(current->tss.trap_no, &sc->trapno);
674 err |= __put_user(current->tss.error_code, &sc->err);
676 err |= __put_user(regs->cr_iip, &sc->eip);
677 err |= __put_user(regs->r17 & 0xffff, (unsigned int *)&sc->cs);
679 * `eflags' is in an ar register for this context
681 flag = ia64_getreg(_IA64_REG_AR_EFLAG);
682 err |= __put_user((unsigned int)flag, &sc->eflags);
683 err |= __put_user(regs->r12, &sc->esp_at_signal);
684 err |= __put_user((regs->r17 >> 16) & 0xffff, (unsigned int *)&sc->ss);
686 if ( save_ia32_fpstate_live(fpstate) < 0 )
689 err |= __put_user((u32)(u64)fpstate, &sc->fpstate);
692 tmp = save_i387(fpstate);
696 err |= __put_user(tmp ? fpstate : NULL, &sc->fpstate);
698 /* non-iBCS2 extensions.. */
700 err |= __put_user(mask, &sc->oldmask);
702 err |= __put_user(current->tss.cr2, &sc->cr2);
708 restore_sigcontext_ia32 (struct pt_regs *regs, struct sigcontext_ia32 *sc, int *peax)
710 unsigned int err = 0;
712 /* Always make any pending restarted system calls return -EINTR */
713 current_thread_info()->restart_block.fn = do_no_restart_syscall;
715 if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
718 #define COPY(ia64x, ia32x) err |= __get_user(regs->ia64x, &sc->ia32x)
720 #define copyseg_gs(tmp) (regs->r16 |= (unsigned long) (tmp) << 48)
721 #define copyseg_fs(tmp) (regs->r16 |= (unsigned long) (tmp) << 32)
722 #define copyseg_cs(tmp) (regs->r17 |= tmp)
723 #define copyseg_ss(tmp) (regs->r17 |= (unsigned long) (tmp) << 16)
724 #define copyseg_es(tmp) (regs->r16 |= (unsigned long) (tmp) << 16)
725 #define copyseg_ds(tmp) (regs->r16 |= tmp)
727 #define COPY_SEG(seg) \
729 unsigned short tmp; \
730 err |= __get_user(tmp, &sc->seg); \
731 copyseg_##seg(tmp); \
733 #define COPY_SEG_STRICT(seg) \
735 unsigned short tmp; \
736 err |= __get_user(tmp, &sc->seg); \
737 copyseg_##seg(tmp|3); \
740 /* To make COPY_SEGs easier, we zero r16, r17 */
758 ia32_load_segment_descriptors(current);
760 unsigned int tmpflags;
764 * IA32 `eflags' is not part of `pt_regs', it's in an ar register which
765 * is part of the thread context. Fortunately, we are executing in the
766 * IA32 process's context.
768 err |= __get_user(tmpflags, &sc->eflags);
769 flag = ia64_getreg(_IA64_REG_AR_EFLAG);
771 flag |= (tmpflags & 0x40DD5);
772 ia64_setreg(_IA64_REG_AR_EFLAG, flag);
774 regs->r1 = -1; /* disable syscall checks, r1 is orig_eax */
778 struct _fpstate_ia32 *buf = NULL;
780 err |= get_user(fpstate_ptr, &(sc->fpstate));
781 buf = (struct _fpstate_ia32 *)(u64)fpstate_ptr;
783 err |= restore_ia32_fpstate_live(buf);
789 struct _fpstate * buf;
790 err |= __get_user(buf, &sc->fpstate);
792 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
794 err |= restore_i387(buf);
799 err |= __get_user(*peax, &sc->eax);
809 * Determine which stack to use..
812 get_sigframe (struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
816 /* Default to using normal stack (truncate off sign-extension of bit 31: */
817 esp = (unsigned int) regs->r12;
819 /* This is the X/Open sanctioned signal stack switching. */
820 if (ka->sa.sa_flags & SA_ONSTACK) {
821 if (!on_sig_stack(esp))
822 esp = current->sas_ss_sp + current->sas_ss_size;
824 /* Legacy stack switching not supported */
826 return (void *)((esp - frame_size) & -8ul);
830 setup_frame_ia32 (int sig, struct k_sigaction *ka, sigset_t *set, struct pt_regs * regs)
832 struct exec_domain *ed = current_thread_info()->exec_domain;
833 struct sigframe_ia32 *frame;
836 frame = get_sigframe(ka, regs, sizeof(*frame));
838 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
841 err |= __put_user((ed && ed->signal_invmap && sig < 32
842 ? (int)(ed->signal_invmap[sig]) : sig), &frame->sig);
844 err |= setup_sigcontext_ia32(&frame->sc, &frame->fpstate, regs, set->sig[0]);
846 if (_COMPAT_NSIG_WORDS > 1)
847 err |= __copy_to_user(frame->extramask, (char *) &set->sig + 4,
848 sizeof(frame->extramask));
850 /* Set up to return from userspace. If provided, use a stub
851 already in userspace. */
852 if (ka->sa.sa_flags & SA_RESTORER) {
853 unsigned int restorer = IA32_SA_RESTORER(ka);
854 err |= __put_user(restorer, &frame->pretcode);
856 err |= __put_user((long)frame->retcode, &frame->pretcode);
857 /* This is popl %eax ; movl $,%eax ; int $0x80 */
858 err |= __put_user(0xb858, (short *)(frame->retcode+0));
859 err |= __put_user(__IA32_NR_sigreturn & 0xffff, (short *)(frame->retcode+2));
860 err |= __put_user(__IA32_NR_sigreturn >> 16, (short *)(frame->retcode+4));
861 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
867 /* Set up registers for signal handler */
868 regs->r12 = (unsigned long) frame;
869 regs->cr_iip = IA32_SA_HANDLER(ka);
874 regs->eflags &= ~TF_MASK;
878 printk("SIG deliver (%s:%d): sig=%d sp=%p pc=%lx ra=%x\n",
879 current->comm, current->pid, sig, (void *) frame, regs->cr_iip, frame->pretcode);
886 ka->sa.sa_handler = SIG_DFL;
887 force_sig(SIGSEGV, current);
892 setup_rt_frame_ia32 (int sig, struct k_sigaction *ka, siginfo_t *info,
893 sigset_t *set, struct pt_regs * regs)
895 struct exec_domain *ed = current_thread_info()->exec_domain;
896 struct rt_sigframe_ia32 *frame;
899 frame = get_sigframe(ka, regs, sizeof(*frame));
901 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
904 err |= __put_user((ed && ed->signal_invmap
905 && sig < 32 ? ed->signal_invmap[sig] : sig), &frame->sig);
906 err |= __put_user((long)&frame->info, &frame->pinfo);
907 err |= __put_user((long)&frame->uc, &frame->puc);
908 err |= copy_siginfo_to_user32(&frame->info, info);
910 /* Create the ucontext. */
911 err |= __put_user(0, &frame->uc.uc_flags);
912 err |= __put_user(0, &frame->uc.uc_link);
913 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
914 err |= __put_user(sas_ss_flags(regs->r12), &frame->uc.uc_stack.ss_flags);
915 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
916 err |= setup_sigcontext_ia32(&frame->uc.uc_mcontext, &frame->fpstate, regs, set->sig[0]);
917 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
921 /* Set up to return from userspace. If provided, use a stub
922 already in userspace. */
923 if (ka->sa.sa_flags & SA_RESTORER) {
924 unsigned int restorer = IA32_SA_RESTORER(ka);
925 err |= __put_user(restorer, &frame->pretcode);
927 err |= __put_user((long)frame->retcode, &frame->pretcode);
928 /* This is movl $,%eax ; int $0x80 */
929 err |= __put_user(0xb8, (char *)(frame->retcode+0));
930 err |= __put_user(__IA32_NR_rt_sigreturn, (int *)(frame->retcode+1));
931 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
937 /* Set up registers for signal handler */
938 regs->r12 = (unsigned long) frame;
939 regs->cr_iip = IA32_SA_HANDLER(ka);
944 regs->eflags &= ~TF_MASK;
948 printk("SIG deliver (%s:%d): sp=%p pc=%lx ra=%x\n",
949 current->comm, current->pid, (void *) frame, regs->cr_iip, frame->pretcode);
956 ka->sa.sa_handler = SIG_DFL;
957 force_sig(SIGSEGV, current);
962 ia32_setup_frame1 (int sig, struct k_sigaction *ka, siginfo_t *info,
963 sigset_t *set, struct pt_regs *regs)
965 /* Set up the stack frame */
966 if (ka->sa.sa_flags & SA_SIGINFO)
967 return setup_rt_frame_ia32(sig, ka, info, set, regs);
969 return setup_frame_ia32(sig, ka, set, regs);
973 sys32_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7,
976 struct pt_regs *regs = (struct pt_regs *) &stack;
977 unsigned long esp = (unsigned int) regs->r12;
978 struct sigframe_ia32 *frame = (struct sigframe_ia32 *)(esp - 8);
982 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
985 if (__get_user(set.sig[0], &frame->sc.oldmask)
986 || (_COMPAT_NSIG_WORDS > 1 && __copy_from_user((char *) &set.sig + 4, &frame->extramask,
987 sizeof(frame->extramask))))
990 sigdelsetmask(&set, ~_BLOCKABLE);
991 spin_lock_irq(¤t->sighand->siglock);
992 current->blocked = (sigset_t) set;
994 spin_unlock_irq(¤t->sighand->siglock);
996 if (restore_sigcontext_ia32(regs, &frame->sc, &eax))
1001 force_sig(SIGSEGV, current);
1006 sys32_rt_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7,
1007 unsigned long stack)
1009 struct pt_regs *regs = (struct pt_regs *) &stack;
1010 unsigned long esp = (unsigned int) regs->r12;
1011 struct rt_sigframe_ia32 *frame = (struct rt_sigframe_ia32 *)(esp - 4);
1016 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
1018 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
1021 sigdelsetmask(&set, ~_BLOCKABLE);
1022 spin_lock_irq(¤t->sighand->siglock);
1023 current->blocked = set;
1024 recalc_sigpending();
1025 spin_unlock_irq(¤t->sighand->siglock);
1027 if (restore_sigcontext_ia32(regs, &frame->uc.uc_mcontext, &eax))
1030 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
1032 /* It is more difficult to avoid calling this function than to
1033 call it and ignore errors. */
1034 do_sigaltstack(&st, NULL, esp);
1039 force_sig(SIGSEGV, current);