arch/ia64/ia32/ia32_signal.c

   1 /*
   2  * IA32 Architecture-specific signal handling support.
   3  *
   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>
   9  *
  10  * Derived from i386 and Alpha versions.
  11  */
  12
  13 #include <linux/errno.h>
  14 #include <linux/kernel.h>
  15 #include <linux/mm.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>
  27
  28 #include <asm/intrinsics.h>
  29 #include <asm/uaccess.h>
  30 #include <asm/rse.h>
  31 #include <asm/sigcontext.h>
  32 #include <asm/segment.h>
  33
  34 #include "ia32priv.h"
  35
  36 #include "../kernel/sigframe.h"
  37
  38 #define A(__x)          ((unsigned long)(__x))
  39
  40 #define DEBUG_SIG       0
  41 #define _BLOCKABLE      (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  42
  43 #define __IA32_NR_sigreturn            119
  44 #define __IA32_NR_rt_sigreturn         173
  45
  46 struct sigframe_ia32
  47 {
  48        int pretcode;
  49        int sig;
  50        struct sigcontext_ia32 sc;
  51        struct _fpstate_ia32 fpstate;
  52        unsigned int extramask[_COMPAT_NSIG_WORDS-1];
  53        char retcode[8];
  54 };
  55
  56 struct rt_sigframe_ia32
  57 {
  58        int pretcode;
  59        int sig;
  60        int pinfo;
  61        int puc;
  62        siginfo_t32 info;
  63        struct ucontext_ia32 uc;
  64        struct _fpstate_ia32 fpstate;
  65        char retcode[8];
  66 };
  67
  68 int
  69 copy_siginfo_from_user32 (siginfo_t *to, siginfo_t32 *from)
  70 {
  71         unsigned long tmp;
  72         int err;
  73
  74         if (!access_ok(VERIFY_READ, from, sizeof(siginfo_t32)))
  75                 return -EFAULT;
  76
  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);
  80
  81         if (from->si_code < 0)
  82                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  83         else {
  84                 switch (from->si_code >> 16) {
  85                       case __SI_CHLD >> 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);
  89                       default:
  90                         err |= __get_user(to->si_pid, &from->si_pid);
  91                         err |= __get_user(to->si_uid, &from->si_uid);
  92                         break;
  93                       case __SI_FAULT >> 16:
  94                         err |= __get_user(tmp, &from->si_addr);
  95                         to->si_addr = (void *) tmp;
  96                         break;
  97                       case __SI_POLL >> 16:
  98                         err |= __get_user(to->si_band, &from->si_band);
  99                         err |= __get_user(to->si_fd, &from->si_fd);
 100                         break;
 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);
 106                         break;
 107                 }
 108         }
 109         return err;
 110 }
 111
 112 int
 113 copy_siginfo_to_user32 (siginfo_t32 *to, siginfo_t *from)
 114 {
 115         unsigned int addr;
 116         int err;
 117
 118         if (!access_ok(VERIFY_WRITE, to, sizeof(siginfo_t32)))
 119                 return -EFAULT;
 120
 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
 127            at the same time.  */
 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);
 133         else {
 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);
 139                 default:
 140                         err |= __put_user(from->si_pid, &to->si_pid);
 141                         err |= __put_user(from->si_uid, &to->si_uid);
 142                         break;
 143                 case __SI_FAULT >> 16:
 144                         err |= __put_user((long)from->si_addr, &to->si_addr);
 145                         break;
 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);
 149                         break;
 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);
 155                         break;
 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);
 162                         break;
 163                 }
 164         }
 165         return err;
 166 }
 167
 168
 169 /*
 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.
 173  *
 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
 177  *    sw         ar.fsr(0:15)
 178  *    tag        ar.fsr(16:31)               with odd numbered bits not used
 179  *                                           (read returns 0, writes ignored)
 180  *    ipoff      ar.fir(0:31)
 181  *    cssel      ar.fir(32:47)
 182  *    dataoff    ar.fdr(0:31)
 183  *    datasel    ar.fdr(32:47)
 184  *
 185  *    _st[(0+TOS)%8]   f8
 186  *    _st[(1+TOS)%8]   f9
 187  *    _st[(2+TOS)%8]   f10
 188  *    _st[(3+TOS)%8]   f11                   (f8..f11 from ptregs)
 189  *      : :            :                     (f12..f15 from live reg)
 190  *      : :            :
 191  *    _st[(7+TOS)%8]   f15                   TOS=sw.top(bits11:13)
 192  *
 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)
 198  *                                           with _xmm[0]
 199  *                                             Bit(64:127)=f17(0:63)
 200  *                                             Bit(0:63)=f16(0:63)
 201  *    All other fields unused...
 202  */
 203
 204 static int
 205 save_ia32_fpstate_live (struct _fpstate_ia32 *save)
 206 {
 207         struct task_struct *tsk = current;
 208         struct pt_regs *ptp;
 209         struct _fpreg_ia32 *fpregp;
 210         char buf[32];
 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;
 216
 217         if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
 218                 return -EFAULT;
 219
 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);
 225
 226         /*
 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
 229          * instruction.
 230          */
 231         new_fsr = fsr & ~0x80ff;
 232         ia64_setreg(_IA64_REG_AR_FSR, new_fsr);
 233
 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);
 242
 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
 246
 247         /*
 248          * save f8..f11  from pt_regs
 249          * save f12..f15 from live register set
 250          */
 251         /*
 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
 254          *  to.
 255          */
 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));
 268
 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));
 277
 278         ia64_stf8(&num128[0], 16);
 279         ia64_stf8(&num128[1], 17);
 280         copy_to_user(&save->_xmm[0], num128, sizeof(struct _xmmreg_ia32));
 281
 282         ia64_stf8(&num128[0], 18);
 283         ia64_stf8(&num128[1], 19);
 284         copy_to_user(&save->_xmm[1], num128, sizeof(struct _xmmreg_ia32));
 285
 286         ia64_stf8(&num128[0], 20);
 287         ia64_stf8(&num128[1], 21);
 288         copy_to_user(&save->_xmm[2], num128, sizeof(struct _xmmreg_ia32));
 289
 290         ia64_stf8(&num128[0], 22);
 291         ia64_stf8(&num128[1], 23);
 292         copy_to_user(&save->_xmm[3], num128, sizeof(struct _xmmreg_ia32));
 293
 294         ia64_stf8(&num128[0], 24);
 295         ia64_stf8(&num128[1], 25);
 296         copy_to_user(&save->_xmm[4], num128, sizeof(struct _xmmreg_ia32));
 297
 298         ia64_stf8(&num128[0], 26);
 299         ia64_stf8(&num128[1], 27);
 300         copy_to_user(&save->_xmm[5], num128, sizeof(struct _xmmreg_ia32));
 301
 302         ia64_stf8(&num128[0], 28);
 303         ia64_stf8(&num128[1], 29);
 304         copy_to_user(&save->_xmm[6], num128, sizeof(struct _xmmreg_ia32));
 305
 306         ia64_stf8(&num128[0], 30);
 307         ia64_stf8(&num128[1], 31);
 308         copy_to_user(&save->_xmm[7], num128, sizeof(struct _xmmreg_ia32));
 309         return 0;
 310 }
 311
 312 static int
 313 restore_ia32_fpstate_live (struct _fpstate_ia32 *save)
 314 {
 315         struct task_struct *tsk = current;
 316         struct pt_regs *ptp;
 317         unsigned int lo, hi;
 318         unsigned long num128[2];
 319         unsigned long num64, mxcsr;
 320         struct _fpreg_ia32 *fpregp;
 321         char buf[32];
 322         unsigned long fsr, fcr, fir, fdr;
 323         int fp_tos, fr8_st_map;
 324
 325         if (!access_ok(VERIFY_READ, save, sizeof(*save)))
 326                 return(-EFAULT);
 327
 328         /*
 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.
 336          */
 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);
 341
 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;
 348
 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 */
 352         if ( !(lo & 0x7f) )
 353                 lo &= (~0x8080);
 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;
 359
 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);
 363         num64 = hi & 0xffff;
 364         num64 = (num64 << 32) | lo;
 365         fir = (fir & (~0xffffffffffff)) | num64;
 366
 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);
 370         num64 = hi & 0xffff;
 371         num64 = (num64 << 32) | lo;
 372         fdr = (fdr & (~0xffffffffffff)) | num64;
 373
 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);
 378
 379         /*
 380          * restore f8..f11 onto pt_regs
 381          * restore f12..f15 onto live registers
 382          */
 383         /*
 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
 386          *  to.
 387          */
 388         fp_tos = (fsr>>11)&0x7;
 389         fr8_st_map = (8-fp_tos)&0x7;
 390         fpregp = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
 391
 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);
 401
 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);
 410
 411         copy_from_user(num128, &save->_xmm[0], sizeof(struct _xmmreg_ia32));
 412         ia64_ldf8(16, &num128[0]);
 413         ia64_ldf8(17, &num128[1]);
 414
 415         copy_from_user(num128, &save->_xmm[1], sizeof(struct _xmmreg_ia32));
 416         ia64_ldf8(18, &num128[0]);
 417         ia64_ldf8(19, &num128[1]);
 418
 419         copy_from_user(num128, &save->_xmm[2], sizeof(struct _xmmreg_ia32));
 420         ia64_ldf8(20, &num128[0]);
 421         ia64_ldf8(21, &num128[1]);
 422
 423         copy_from_user(num128, &save->_xmm[3], sizeof(struct _xmmreg_ia32));
 424         ia64_ldf8(22, &num128[0]);
 425         ia64_ldf8(23, &num128[1]);
 426
 427         copy_from_user(num128, &save->_xmm[4], sizeof(struct _xmmreg_ia32));
 428         ia64_ldf8(24, &num128[0]);
 429         ia64_ldf8(25, &num128[1]);
 430
 431         copy_from_user(num128, &save->_xmm[5], sizeof(struct _xmmreg_ia32));
 432         ia64_ldf8(26, &num128[0]);
 433         ia64_ldf8(27, &num128[1]);
 434
 435         copy_from_user(num128, &save->_xmm[6], sizeof(struct _xmmreg_ia32));
 436         ia64_ldf8(28, &num128[0]);
 437         ia64_ldf8(29, &num128[1]);
 438
 439         copy_from_user(num128, &save->_xmm[7], sizeof(struct _xmmreg_ia32));
 440         ia64_ldf8(30, &num128[0]);
 441         ia64_ldf8(31, &num128[1]);
 442         return 0;
 443 }
 444
 445 static inline void
 446 sigact_set_handler (struct k_sigaction *sa, unsigned int handler, unsigned int restorer)
 447 {
 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);
 451         else
 452                 sa->sa.sa_handler = (__sighandler_t) (((unsigned long) restorer << 32) | handler);
 453 }
 454
 455 asmlinkage long
 456 ia32_rt_sigsuspend (compat_sigset_t *uset, unsigned int sigsetsize, struct sigscratch *scr)
 457 {
 458         extern long ia64_do_signal (sigset_t *oldset, struct sigscratch *scr, long in_syscall);
 459         sigset_t oldset, set;
 460
 461         scr->scratch_unat = 0;  /* avoid leaking kernel bits to user level */
 462         memset(&set, 0, sizeof(&set));
 463
 464         if (sigsetsize > sizeof(sigset_t))
 465                 return -EINVAL;
 466
 467         if (copy_from_user(&set.sig, &uset->sig, sigsetsize))
 468                 return -EFAULT;
 469
 470         sigdelsetmask(&set, ~_BLOCKABLE);
 471
 472         spin_lock_irq(&current->sighand->siglock);
 473         {
 474                 oldset = current->blocked;
 475                 current->blocked = set;
 476                 recalc_sigpending();
 477         }
 478         spin_unlock_irq(&current->sighand->siglock);
 479
 480         /*
 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
 483          * by ia64_do_signal.
 484          */
 485         scr->pt.r8 = -EINTR;
 486         while (1) {
 487                 current->state = TASK_INTERRUPTIBLE;
 488                 schedule();
 489                 if (ia64_do_signal(&oldset, scr, 1))
 490                         return -EINTR;
 491         }
 492 }
 493
 494 asmlinkage long
 495 ia32_sigsuspend (unsigned int mask, struct sigscratch *scr)
 496 {
 497         return ia32_rt_sigsuspend((compat_sigset_t *)&mask, sizeof(mask), scr);
 498 }
 499
 500 asmlinkage long
 501 sys32_signal (int sig, unsigned int handler)
 502 {
 503         struct k_sigaction new_sa, old_sa;
 504         int ret;
 505
 506         sigact_set_handler(&new_sa, handler, 0);
 507         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
 508
 509         ret = do_sigaction(sig, &new_sa, &old_sa);
 510
 511         return ret ? ret : IA32_SA_HANDLER(&old_sa);
 512 }
 513
 514 asmlinkage long
 515 sys32_rt_sigaction (int sig, struct sigaction32 *act,
 516                     struct sigaction32 *oact, unsigned int sigsetsize)
 517 {
 518         struct k_sigaction new_ka, old_ka;
 519         unsigned int handler, restorer;
 520         int ret;
 521
 522         /* XXX: Don't preclude handling different sized sigset_t's.  */
 523         if (sigsetsize != sizeof(compat_sigset_t))
 524                 return -EINVAL;
 525
 526         if (act) {
 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));
 531                 if (ret)
 532                         return -EFAULT;
 533
 534                 sigact_set_handler(&new_ka, handler, restorer);
 535         }
 536
 537         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 538
 539         if (!ret && oact) {
 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));
 544         }
 545         return ret;
 546 }
 547
 548
 549 asmlinkage long
 550 sys32_rt_sigprocmask (int how, compat_sigset_t *set, compat_sigset_t *oset, unsigned int sigsetsize)
 551 {
 552         mm_segment_t old_fs = get_fs();
 553         sigset_t s;
 554         long ret;
 555
 556         if (sigsetsize > sizeof(s))
 557                 return -EINVAL;
 558
 559         if (set) {
 560                 memset(&s, 0, sizeof(s));
 561                 if (copy_from_user(&s.sig, set, sigsetsize))
 562                         return -EFAULT;
 563         }
 564         set_fs(KERNEL_DS);
 565         ret = sys_rt_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL, sizeof(s));
 566         set_fs(old_fs);
 567         if (ret)
 568                 return ret;
 569         if (oset) {
 570                 if (copy_to_user(oset, &s.sig, sigsetsize))
 571                         return -EFAULT;
 572         }
 573         return 0;
 574 }
 575
 576 asmlinkage long
 577 sys32_rt_sigtimedwait (compat_sigset_t *uthese, siginfo_t32 *uinfo,
 578                 struct compat_timespec *uts, unsigned int sigsetsize)
 579 {
 580         extern int copy_siginfo_to_user32 (siginfo_t32 *, siginfo_t *);
 581         mm_segment_t old_fs = get_fs();
 582         struct timespec t;
 583         siginfo_t info;
 584         sigset_t s;
 585         int ret;
 586
 587         if (copy_from_user(&s.sig, uthese, sizeof(compat_sigset_t)))
 588                 return -EFAULT;
 589         if (uts && get_compat_timespec(&t, uts))
 590                 return -EFAULT;
 591         set_fs(KERNEL_DS);
 592         ret = sys_rt_sigtimedwait(&s, uinfo ? &info : NULL, uts ? &t : NULL,
 593                         sigsetsize);
 594         set_fs(old_fs);
 595         if (ret >= 0 && uinfo) {
 596                 if (copy_siginfo_to_user32(uinfo, &info))
 597                         return -EFAULT;
 598         }
 599         return ret;
 600 }
 601
 602 asmlinkage long
 603 sys32_rt_sigqueueinfo (int pid, int sig, siginfo_t32 *uinfo)
 604 {
 605         mm_segment_t old_fs = get_fs();
 606         siginfo_t info;
 607         int ret;
 608
 609         if (copy_siginfo_from_user32(&info, uinfo))
 610                 return -EFAULT;
 611         set_fs(KERNEL_DS);
 612         ret = sys_rt_sigqueueinfo(pid, sig, &info);
 613         set_fs(old_fs);
 614         return ret;
 615 }
 616
 617 asmlinkage long
 618 sys32_sigaction (int sig, struct old_sigaction32 *act, struct old_sigaction32 *oact)
 619 {
 620         struct k_sigaction new_ka, old_ka;
 621         unsigned int handler, restorer;
 622         int ret;
 623
 624         if (act) {
 625                 compat_old_sigset_t mask;
 626
 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);
 631                 if (ret)
 632                         return ret;
 633
 634                 sigact_set_handler(&new_ka, handler, restorer);
 635                 siginitset(&new_ka.sa.sa_mask, mask);
 636         }
 637
 638         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 639
 640         if (!ret && oact) {
 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);
 645         }
 646
 647         return ret;
 648 }
 649
 650 static int
 651 setup_sigcontext_ia32 (struct sigcontext_ia32 *sc, struct _fpstate_ia32 *fpstate,
 652                        struct pt_regs *regs, unsigned long mask)
 653 {
 654         int  err = 0;
 655         unsigned long flag;
 656
 657         if (!access_ok(VERIFY_WRITE, sc, sizeof(*sc)))
 658                 return -EFAULT;
 659
 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);
 672 #if 0
 673         err |= __put_user(current->tss.trap_no, &sc->trapno);
 674         err |= __put_user(current->tss.error_code, &sc->err);
 675 #endif
 676         err |= __put_user(regs->cr_iip, &sc->eip);
 677         err |= __put_user(regs->r17 & 0xffff, (unsigned int *)&sc->cs);
 678         /*
 679          *  `eflags' is in an ar register for this context
 680          */
 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);
 685
 686         if ( save_ia32_fpstate_live(fpstate) < 0 )
 687                 err = -EFAULT;
 688         else
 689                 err |= __put_user((u32)(u64)fpstate, &sc->fpstate);
 690
 691 #if 0
 692         tmp = save_i387(fpstate);
 693         if (tmp < 0)
 694                 err = 1;
 695         else
 696                 err |= __put_user(tmp ? fpstate : NULL, &sc->fpstate);
 697
 698         /* non-iBCS2 extensions.. */
 699 #endif
 700         err |= __put_user(mask, &sc->oldmask);
 701 #if 0
 702         err |= __put_user(current->tss.cr2, &sc->cr2);
 703 #endif
 704         return err;
 705 }
 706
 707 static int
 708 restore_sigcontext_ia32 (struct pt_regs *regs, struct sigcontext_ia32 *sc, int *peax)
 709 {
 710         unsigned int err = 0;
 711
 712         /* Always make any pending restarted system calls return -EINTR */
 713         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 714
 715         if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
 716                 return(-EFAULT);
 717
 718 #define COPY(ia64x, ia32x)      err |= __get_user(regs->ia64x, &sc->ia32x)
 719
 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)
 726
 727 #define COPY_SEG(seg)                                   \
 728         {                                               \
 729                 unsigned short tmp;                     \
 730                 err |= __get_user(tmp, &sc->seg);       \
 731                 copyseg_##seg(tmp);                     \
 732         }
 733 #define COPY_SEG_STRICT(seg)                            \
 734         {                                               \
 735                 unsigned short tmp;                     \
 736                 err |= __get_user(tmp, &sc->seg);       \
 737                 copyseg_##seg(tmp|3);                   \
 738         }
 739
 740         /* To make COPY_SEGs easier, we zero r16, r17 */
 741         regs->r16 = 0;
 742         regs->r17 = 0;
 743
 744         COPY_SEG(gs);
 745         COPY_SEG(fs);
 746         COPY_SEG(es);
 747         COPY_SEG(ds);
 748         COPY(r15, edi);
 749         COPY(r14, esi);
 750         COPY(r13, ebp);
 751         COPY(r12, esp);
 752         COPY(r11, ebx);
 753         COPY(r10, edx);
 754         COPY(r9, ecx);
 755         COPY(cr_iip, eip);
 756         COPY_SEG_STRICT(cs);
 757         COPY_SEG_STRICT(ss);
 758         ia32_load_segment_descriptors(current);
 759         {
 760                 unsigned int tmpflags;
 761                 unsigned long flag;
 762
 763                 /*
 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.
 767                  */
 768                 err |= __get_user(tmpflags, &sc->eflags);
 769                 flag = ia64_getreg(_IA64_REG_AR_EFLAG);
 770                 flag &= ~0x40DD5;
 771                 flag |= (tmpflags & 0x40DD5);
 772                 ia64_setreg(_IA64_REG_AR_EFLAG, flag);
 773
 774                 regs->r1 = -1;  /* disable syscall checks, r1 is orig_eax */
 775         }
 776
 777         {
 778                 struct _fpstate_ia32 *buf = NULL;
 779                 u32    fpstate_ptr;
 780                 err |= get_user(fpstate_ptr, &(sc->fpstate));
 781                 buf = (struct _fpstate_ia32 *)(u64)fpstate_ptr;
 782                 if (buf) {
 783                         err |= restore_ia32_fpstate_live(buf);
 784                 }
 785         }
 786
 787 #if 0
 788         {
 789                 struct _fpstate * buf;
 790                 err |= __get_user(buf, &sc->fpstate);
 791                 if (buf) {
 792                         if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
 793                                 goto badframe;
 794                         err |= restore_i387(buf);
 795                 }
 796         }
 797 #endif
 798
 799         err |= __get_user(*peax, &sc->eax);
 800         return err;
 801
 802 #if 0
 803   badframe:
 804         return 1;
 805 #endif
 806 }
 807
 808 /*
 809  * Determine which stack to use..
 810  */
 811 static inline void *
 812 get_sigframe (struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 813 {
 814         unsigned long esp;
 815
 816         /* Default to using normal stack (truncate off sign-extension of bit 31: */
 817         esp = (unsigned int) regs->r12;
 818
 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;
 823         }
 824         /* Legacy stack switching not supported */
 825
 826         return (void *)((esp - frame_size) & -8ul);
 827 }
 828
 829 static int
 830 setup_frame_ia32 (int sig, struct k_sigaction *ka, sigset_t *set, struct pt_regs * regs)
 831 {
 832         struct exec_domain *ed = current_thread_info()->exec_domain;
 833         struct sigframe_ia32 *frame;
 834         int err = 0;
 835
 836         frame = get_sigframe(ka, regs, sizeof(*frame));
 837
 838         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 839                 goto give_sigsegv;
 840
 841         err |= __put_user((ed && ed->signal_invmap && sig < 32
 842                            ? (int)(ed->signal_invmap[sig]) : sig), &frame->sig);
 843
 844         err |= setup_sigcontext_ia32(&frame->sc, &frame->fpstate, regs, set->sig[0]);
 845
 846         if (_COMPAT_NSIG_WORDS > 1)
 847                 err |= __copy_to_user(frame->extramask, (char *) &set->sig + 4,
 848                                       sizeof(frame->extramask));
 849
 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);
 855         } else {
 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));
 862         }
 863
 864         if (err)
 865                 goto give_sigsegv;
 866
 867         /* Set up registers for signal handler */
 868         regs->r12 = (unsigned long) frame;
 869         regs->cr_iip = IA32_SA_HANDLER(ka);
 870
 871         set_fs(USER_DS);
 872
 873 #if 0
 874         regs->eflags &= ~TF_MASK;
 875 #endif
 876
 877 #if 0
 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);
 880 #endif
 881
 882         return 1;
 883
 884   give_sigsegv:
 885         if (sig == SIGSEGV)
 886                 ka->sa.sa_handler = SIG_DFL;
 887         force_sig(SIGSEGV, current);
 888         return 0;
 889 }
 890
 891 static int
 892 setup_rt_frame_ia32 (int sig, struct k_sigaction *ka, siginfo_t *info,
 893                      sigset_t *set, struct pt_regs * regs)
 894 {
 895         struct exec_domain *ed = current_thread_info()->exec_domain;
 896         struct rt_sigframe_ia32 *frame;
 897         int err = 0;
 898
 899         frame = get_sigframe(ka, regs, sizeof(*frame));
 900
 901         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 902                 goto give_sigsegv;
 903
 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);
 909
 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));
 918         if (err)
 919                 goto give_sigsegv;
 920
 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);
 926         } else {
 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));
 932         }
 933
 934         if (err)
 935                 goto give_sigsegv;
 936
 937         /* Set up registers for signal handler */
 938         regs->r12 = (unsigned long) frame;
 939         regs->cr_iip = IA32_SA_HANDLER(ka);
 940
 941         set_fs(USER_DS);
 942
 943 #if 0
 944         regs->eflags &= ~TF_MASK;
 945 #endif
 946
 947 #if 0
 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);
 950 #endif
 951
 952         return 1;
 953
 954 give_sigsegv:
 955         if (sig == SIGSEGV)
 956                 ka->sa.sa_handler = SIG_DFL;
 957         force_sig(SIGSEGV, current);
 958         return 0;
 959 }
 960
 961 int
 962 ia32_setup_frame1 (int sig, struct k_sigaction *ka, siginfo_t *info,
 963                    sigset_t *set, struct pt_regs *regs)
 964 {
 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);
 968        else
 969                return setup_frame_ia32(sig, ka, set, regs);
 970 }
 971
 972 asmlinkage long
 973 sys32_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7,
 974                  unsigned long stack)
 975 {
 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);
 979         sigset_t set;
 980         int eax;
 981
 982         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 983                 goto badframe;
 984
 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))))
 988                 goto badframe;
 989
 990         sigdelsetmask(&set, ~_BLOCKABLE);
 991         spin_lock_irq(&current->sighand->siglock);
 992         current->blocked = (sigset_t) set;
 993         recalc_sigpending();
 994         spin_unlock_irq(&current->sighand->siglock);
 995
 996         if (restore_sigcontext_ia32(regs, &frame->sc, &eax))
 997                 goto badframe;
 998         return eax;
 999
1000   badframe:
1001         force_sig(SIGSEGV, current);
1002         return 0;
1003 }
1004
1005 asmlinkage long
1006 sys32_rt_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7,
1007                     unsigned long stack)
1008 {
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);
1012         sigset_t set;
1013         stack_t st;
1014         int eax;
1015
1016         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
1017                 goto badframe;
1018         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
1019                 goto badframe;
1020
1021         sigdelsetmask(&set, ~_BLOCKABLE);
1022         spin_lock_irq(&current->sighand->siglock);
1023         current->blocked =  set;
1024         recalc_sigpending();
1025         spin_unlock_irq(&current->sighand->siglock);
1026
1027         if (restore_sigcontext_ia32(regs, &frame->uc.uc_mcontext, &eax))
1028                 goto badframe;
1029
1030         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
1031                 goto badframe;
1032         /* It is more difficult to avoid calling this function than to
1033            call it and ignore errors.  */
1034         do_sigaltstack(&st, NULL, esp);
1035
1036         return eax;
1037
1038   badframe:
1039         force_sig(SIGSEGV, current);
1040         return 0;
1041 }