arch/mips/kernel/signal32.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1991, 1992  Linus Torvalds
   7  * Copyright (C) 1994 - 2000, 2006  Ralf Baechle
   8  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
   9  */
  10 #include <linux/cache.h>
  11 #include <linux/compat.h>
  12 #include <linux/sched.h>
  13 #include <linux/mm.h>
  14 #include <linux/smp.h>
  15 #include <linux/kernel.h>
  16 #include <linux/signal.h>
  17 #include <linux/syscalls.h>
  18 #include <linux/errno.h>
  19 #include <linux/wait.h>
  20 #include <linux/ptrace.h>
  21 #include <linux/suspend.h>
  22 #include <linux/compiler.h>
  23 #include <linux/uaccess.h>
  24
  25 #include <asm/abi.h>
  26 #include <asm/asm.h>
  27 #include <asm/compat-signal.h>
  28 #include <linux/bitops.h>
  29 #include <asm/cacheflush.h>
  30 #include <asm/sim.h>
  31 #include <asm/ucontext.h>
  32 #include <asm/fpu.h>
  33 #include <asm/war.h>
  34 #include <asm/vdso.h>
  35 #include <asm/dsp.h>
  36
  37 #include "signal-common.h"
  38
  39 static int (*save_fp_context32)(struct sigcontext32 __user *sc);
  40 static int (*restore_fp_context32)(struct sigcontext32 __user *sc);
  41
  42 extern asmlinkage int _save_fp_context32(struct sigcontext32 __user *sc);
  43 extern asmlinkage int _restore_fp_context32(struct sigcontext32 __user *sc);
  44
  45 extern asmlinkage int fpu_emulator_save_context32(struct sigcontext32 __user *sc);
  46 extern asmlinkage int fpu_emulator_restore_context32(struct sigcontext32 __user *sc);
  47
  48 /*
  49  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
  50  */
  51 #define __NR_O32_restart_syscall        4253
  52
  53 /* 32-bit compatibility types */
  54
  55 typedef unsigned int __sighandler32_t;
  56 typedef void (*vfptr_t)(void);
  57
  58 struct sigaction32 {
  59         unsigned int            sa_flags;
  60         __sighandler32_t        sa_handler;
  61         compat_sigset_t         sa_mask;
  62 };
  63
  64 struct ucontext32 {
  65         u32                 uc_flags;
  66         s32                 uc_link;
  67         compat_stack_t      uc_stack;
  68         struct sigcontext32 uc_mcontext;
  69         compat_sigset_t     uc_sigmask;   /* mask last for extensibility */
  70 };
  71
  72 struct sigframe32 {
  73         u32 sf_ass[4];          /* argument save space for o32 */
  74         u32 sf_pad[2];          /* Was: signal trampoline */
  75         struct sigcontext32 sf_sc;
  76         compat_sigset_t sf_mask;
  77 };
  78
  79 struct rt_sigframe32 {
  80         u32 rs_ass[4];                  /* argument save space for o32 */
  81         u32 rs_pad[2];                  /* Was: signal trampoline */
  82         compat_siginfo_t rs_info;
  83         struct ucontext32 rs_uc;
  84 };
  85
  86 /*
  87  * sigcontext handlers
  88  */
  89 static int protected_save_fp_context32(struct sigcontext32 __user *sc)
  90 {
  91         int err;
  92         while (1) {
  93                 lock_fpu_owner();
  94                 own_fpu_inatomic(1);
  95                 err = save_fp_context32(sc); /* this might fail */
  96                 unlock_fpu_owner();
  97                 if (likely(!err))
  98                         break;
  99                 /* touch the sigcontext and try again */
 100                 err = __put_user(0, &sc->sc_fpregs[0]) |
 101                         __put_user(0, &sc->sc_fpregs[31]) |
 102                         __put_user(0, &sc->sc_fpc_csr);
 103                 if (err)
 104                         break;  /* really bad sigcontext */
 105         }
 106         return err;
 107 }
 108
 109 static int protected_restore_fp_context32(struct sigcontext32 __user *sc)
 110 {
 111         int err, tmp __maybe_unused;
 112         while (1) {
 113                 lock_fpu_owner();
 114                 own_fpu_inatomic(0);
 115                 err = restore_fp_context32(sc); /* this might fail */
 116                 unlock_fpu_owner();
 117                 if (likely(!err))
 118                         break;
 119                 /* touch the sigcontext and try again */
 120                 err = __get_user(tmp, &sc->sc_fpregs[0]) |
 121                         __get_user(tmp, &sc->sc_fpregs[31]) |
 122                         __get_user(tmp, &sc->sc_fpc_csr);
 123                 if (err)
 124                         break;  /* really bad sigcontext */
 125         }
 126         return err;
 127 }
 128
 129 static int setup_sigcontext32(struct pt_regs *regs,
 130                               struct sigcontext32 __user *sc)
 131 {
 132         int err = 0;
 133         int i;
 134         u32 used_math;
 135
 136         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
 137
 138         err |= __put_user(0, &sc->sc_regs[0]);
 139         for (i = 1; i < 32; i++)
 140                 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
 141
 142         err |= __put_user(regs->hi, &sc->sc_mdhi);
 143         err |= __put_user(regs->lo, &sc->sc_mdlo);
 144         if (cpu_has_dsp) {
 145                 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
 146                 err |= __put_user(mfhi1(), &sc->sc_hi1);
 147                 err |= __put_user(mflo1(), &sc->sc_lo1);
 148                 err |= __put_user(mfhi2(), &sc->sc_hi2);
 149                 err |= __put_user(mflo2(), &sc->sc_lo2);
 150                 err |= __put_user(mfhi3(), &sc->sc_hi3);
 151                 err |= __put_user(mflo3(), &sc->sc_lo3);
 152         }
 153
 154         used_math = !!used_math();
 155         err |= __put_user(used_math, &sc->sc_used_math);
 156
 157         if (used_math) {
 158                 /*
 159                  * Save FPU state to signal context.  Signal handler
 160                  * will "inherit" current FPU state.
 161                  */
 162                 err |= protected_save_fp_context32(sc);
 163         }
 164         return err;
 165 }
 166
 167 static int
 168 check_and_restore_fp_context32(struct sigcontext32 __user *sc)
 169 {
 170         int err, sig;
 171
 172         err = sig = fpcsr_pending(&sc->sc_fpc_csr);
 173         if (err > 0)
 174                 err = 0;
 175         err |= protected_restore_fp_context32(sc);
 176         return err ?: sig;
 177 }
 178
 179 static int restore_sigcontext32(struct pt_regs *regs,
 180                                 struct sigcontext32 __user *sc)
 181 {
 182         u32 used_math;
 183         int err = 0;
 184         s32 treg;
 185         int i;
 186
 187         /* Always make any pending restarted system calls return -EINTR */
 188         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 189
 190         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
 191         err |= __get_user(regs->hi, &sc->sc_mdhi);
 192         err |= __get_user(regs->lo, &sc->sc_mdlo);
 193         if (cpu_has_dsp) {
 194                 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
 195                 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
 196                 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
 197                 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
 198                 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
 199                 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
 200                 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
 201         }
 202
 203         for (i = 1; i < 32; i++)
 204                 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
 205
 206         err |= __get_user(used_math, &sc->sc_used_math);
 207         conditional_used_math(used_math);
 208
 209         if (used_math) {
 210                 /* restore fpu context if we have used it before */
 211                 if (!err)
 212                         err = check_and_restore_fp_context32(sc);
 213         } else {
 214                 /* signal handler may have used FPU.  Give it up. */
 215                 lose_fpu(0);
 216         }
 217
 218         return err;
 219 }
 220
 221 /*
 222  *
 223  */
 224 extern void __put_sigset_unknown_nsig(void);
 225 extern void __get_sigset_unknown_nsig(void);
 226
 227 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
 228 {
 229         int err = 0;
 230
 231         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
 232                 return -EFAULT;
 233
 234         switch (_NSIG_WORDS) {
 235         default:
 236                 __put_sigset_unknown_nsig();
 237         case 2:
 238                 err |= __put_user(kbuf->sig[1] >> 32, &ubuf->sig[3]);
 239                 err |= __put_user(kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
 240         case 1:
 241                 err |= __put_user(kbuf->sig[0] >> 32, &ubuf->sig[1]);
 242                 err |= __put_user(kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
 243         }
 244
 245         return err;
 246 }
 247
 248 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
 249 {
 250         int err = 0;
 251         unsigned long sig[4];
 252
 253         if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
 254                 return -EFAULT;
 255
 256         switch (_NSIG_WORDS) {
 257         default:
 258                 __get_sigset_unknown_nsig();
 259         case 2:
 260                 err |= __get_user(sig[3], &ubuf->sig[3]);
 261                 err |= __get_user(sig[2], &ubuf->sig[2]);
 262                 kbuf->sig[1] = sig[2] | (sig[3] << 32);
 263         case 1:
 264                 err |= __get_user(sig[1], &ubuf->sig[1]);
 265                 err |= __get_user(sig[0], &ubuf->sig[0]);
 266                 kbuf->sig[0] = sig[0] | (sig[1] << 32);
 267         }
 268
 269         return err;
 270 }
 271
 272 /*
 273  * Atomically swap in the new signal mask, and wait for a signal.
 274  */
 275
 276 asmlinkage int sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
 277 {
 278         compat_sigset_t __user *uset;
 279         sigset_t newset;
 280
 281         uset = (compat_sigset_t __user *) regs.regs[4];
 282         if (get_sigset(&newset, uset))
 283                 return -EFAULT;
 284         return sigsuspend(&newset);
 285 }
 286
 287 SYSCALL_DEFINE3(32_sigaction, long, sig, const struct sigaction32 __user *, act,
 288         struct sigaction32 __user *, oact)
 289 {
 290         struct k_sigaction new_ka, old_ka;
 291         int ret;
 292         int err = 0;
 293
 294         if (act) {
 295                 old_sigset_t mask;
 296                 s32 handler;
 297
 298                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 299                         return -EFAULT;
 300                 err |= __get_user(handler, &act->sa_handler);
 301                 new_ka.sa.sa_handler = (void __user *)(s64)handler;
 302                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 303                 err |= __get_user(mask, &act->sa_mask.sig[0]);
 304                 if (err)
 305                         return -EFAULT;
 306
 307                 siginitset(&new_ka.sa.sa_mask, mask);
 308         }
 309
 310         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 311
 312         if (!ret && oact) {
 313                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 314                         return -EFAULT;
 315                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 316                 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
 317                                   &oact->sa_handler);
 318                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
 319                 err |= __put_user(0, &oact->sa_mask.sig[1]);
 320                 err |= __put_user(0, &oact->sa_mask.sig[2]);
 321                 err |= __put_user(0, &oact->sa_mask.sig[3]);
 322                 if (err)
 323                         return -EFAULT;
 324         }
 325
 326         return ret;
 327 }
 328
 329 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
 330 {
 331         int err;
 332
 333         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 334                 return -EFAULT;
 335
 336         /* If you change siginfo_t structure, please be sure
 337            this code is fixed accordingly.
 338            It should never copy any pad contained in the structure
 339            to avoid security leaks, but must copy the generic
 340            3 ints plus the relevant union member.
 341            This routine must convert siginfo from 64bit to 32bit as well
 342            at the same time.  */
 343         err = __put_user(from->si_signo, &to->si_signo);
 344         err |= __put_user(from->si_errno, &to->si_errno);
 345         err |= __put_user((short)from->si_code, &to->si_code);
 346         if (from->si_code < 0)
 347                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 348         else {
 349                 switch (from->si_code >> 16) {
 350                 case __SI_TIMER >> 16:
 351                         err |= __put_user(from->si_tid, &to->si_tid);
 352                         err |= __put_user(from->si_overrun, &to->si_overrun);
 353                         err |= __put_user(from->si_int, &to->si_int);
 354                         break;
 355                 case __SI_CHLD >> 16:
 356                         err |= __put_user(from->si_utime, &to->si_utime);
 357                         err |= __put_user(from->si_stime, &to->si_stime);
 358                         err |= __put_user(from->si_status, &to->si_status);
 359                 default:
 360                         err |= __put_user(from->si_pid, &to->si_pid);
 361                         err |= __put_user(from->si_uid, &to->si_uid);
 362                         break;
 363                 case __SI_FAULT >> 16:
 364                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
 365                         break;
 366                 case __SI_POLL >> 16:
 367                         err |= __put_user(from->si_band, &to->si_band);
 368                         err |= __put_user(from->si_fd, &to->si_fd);
 369                         break;
 370                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 371                 case __SI_MESGQ >> 16:
 372                         err |= __put_user(from->si_pid, &to->si_pid);
 373                         err |= __put_user(from->si_uid, &to->si_uid);
 374                         err |= __put_user(from->si_int, &to->si_int);
 375                         break;
 376                 }
 377         }
 378         return err;
 379 }
 380
 381 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 382 {
 383         memset(to, 0, sizeof *to);
 384
 385         if (copy_from_user(to, from, 3*sizeof(int)) ||
 386             copy_from_user(to->_sifields._pad,
 387                            from->_sifields._pad, SI_PAD_SIZE32))
 388                 return -EFAULT;
 389
 390         return 0;
 391 }
 392
 393 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
 394 {
 395         struct sigframe32 __user *frame;
 396         sigset_t blocked;
 397         int sig;
 398
 399         frame = (struct sigframe32 __user *) regs.regs[29];
 400         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 401                 goto badframe;
 402         if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
 403                 goto badframe;
 404
 405         set_current_blocked(&blocked);
 406
 407         sig = restore_sigcontext32(&regs, &frame->sf_sc);
 408         if (sig < 0)
 409                 goto badframe;
 410         else if (sig)
 411                 force_sig(sig, current);
 412
 413         /*
 414          * Don't let your children do this ...
 415          */
 416         __asm__ __volatile__(
 417                 "move\t$29, %0\n\t"
 418                 "j\tsyscall_exit"
 419                 :/* no outputs */
 420                 :"r" (&regs));
 421         /* Unreached */
 422
 423 badframe:
 424         force_sig(SIGSEGV, current);
 425 }
 426
 427 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 428 {
 429         struct rt_sigframe32 __user *frame;
 430         sigset_t set;
 431         int sig;
 432
 433         frame = (struct rt_sigframe32 __user *) regs.regs[29];
 434         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 435                 goto badframe;
 436         if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
 437                 goto badframe;
 438
 439         set_current_blocked(&set);
 440
 441         sig = restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext);
 442         if (sig < 0)
 443                 goto badframe;
 444         else if (sig)
 445                 force_sig(sig, current);
 446
 447         if (compat_restore_altstack(&frame->rs_uc.uc_stack))
 448                 goto badframe;
 449
 450         /*
 451          * Don't let your children do this ...
 452          */
 453         __asm__ __volatile__(
 454                 "move\t$29, %0\n\t"
 455                 "j\tsyscall_exit"
 456                 :/* no outputs */
 457                 :"r" (&regs));
 458         /* Unreached */
 459
 460 badframe:
 461         force_sig(SIGSEGV, current);
 462 }
 463
 464 static int setup_frame_32(void *sig_return, struct k_sigaction *ka,
 465                           struct pt_regs *regs, int signr, sigset_t *set)
 466 {
 467         struct sigframe32 __user *frame;
 468         int err = 0;
 469
 470         frame = get_sigframe(ka, regs, sizeof(*frame));
 471         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 472                 goto give_sigsegv;
 473
 474         err |= setup_sigcontext32(regs, &frame->sf_sc);
 475         err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
 476
 477         if (err)
 478                 goto give_sigsegv;
 479
 480         /*
 481          * Arguments to signal handler:
 482          *
 483          *   a0 = signal number
 484          *   a1 = 0 (should be cause)
 485          *   a2 = pointer to struct sigcontext
 486          *
 487          * $25 and c0_epc point to the signal handler, $29 points to the
 488          * struct sigframe.
 489          */
 490         regs->regs[ 4] = signr;
 491         regs->regs[ 5] = 0;
 492         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
 493         regs->regs[29] = (unsigned long) frame;
 494         regs->regs[31] = (unsigned long) sig_return;
 495         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 496
 497         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 498                current->comm, current->pid,
 499                frame, regs->cp0_epc, regs->regs[31]);
 500
 501         return 0;
 502
 503 give_sigsegv:
 504         force_sigsegv(signr, current);
 505         return -EFAULT;
 506 }
 507
 508 static int setup_rt_frame_32(void *sig_return, struct k_sigaction *ka,
 509                              struct pt_regs *regs, int signr, sigset_t *set,
 510                              siginfo_t *info)
 511 {
 512         struct rt_sigframe32 __user *frame;
 513         int err = 0;
 514
 515         frame = get_sigframe(ka, regs, sizeof(*frame));
 516         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 517                 goto give_sigsegv;
 518
 519         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
 520         err |= copy_siginfo_to_user32(&frame->rs_info, info);
 521
 522         /* Create the ucontext.  */
 523         err |= __put_user(0, &frame->rs_uc.uc_flags);
 524         err |= __put_user(0, &frame->rs_uc.uc_link);
 525         err |= __compat_save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]);
 526         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
 527         err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
 528
 529         if (err)
 530                 goto give_sigsegv;
 531
 532         /*
 533          * Arguments to signal handler:
 534          *
 535          *   a0 = signal number
 536          *   a1 = 0 (should be cause)
 537          *   a2 = pointer to ucontext
 538          *
 539          * $25 and c0_epc point to the signal handler, $29 points to
 540          * the struct rt_sigframe32.
 541          */
 542         regs->regs[ 4] = signr;
 543         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 544         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 545         regs->regs[29] = (unsigned long) frame;
 546         regs->regs[31] = (unsigned long) sig_return;
 547         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 548
 549         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 550                current->comm, current->pid,
 551                frame, regs->cp0_epc, regs->regs[31]);
 552
 553         return 0;
 554
 555 give_sigsegv:
 556         force_sigsegv(signr, current);
 557         return -EFAULT;
 558 }
 559
 560 /*
 561  * o32 compatibility on 64-bit kernels, without DSP ASE
 562  */
 563 struct mips_abi mips_abi_32 = {
 564         .setup_frame    = setup_frame_32,
 565         .signal_return_offset =
 566                 offsetof(struct mips_vdso, o32_signal_trampoline),
 567         .setup_rt_frame = setup_rt_frame_32,
 568         .rt_signal_return_offset =
 569                 offsetof(struct mips_vdso, o32_rt_signal_trampoline),
 570         .restart        = __NR_O32_restart_syscall
 571 };
 572
 573 SYSCALL_DEFINE4(32_rt_sigaction, int, sig,
 574         const struct sigaction32 __user *, act,
 575         struct sigaction32 __user *, oact, unsigned int, sigsetsize)
 576 {
 577         struct k_sigaction new_sa, old_sa;
 578         int ret = -EINVAL;
 579
 580         /* XXX: Don't preclude handling different sized sigset_t's.  */
 581         if (sigsetsize != sizeof(sigset_t))
 582                 goto out;
 583
 584         if (act) {
 585                 s32 handler;
 586                 int err = 0;
 587
 588                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 589                         return -EFAULT;
 590                 err |= __get_user(handler, &act->sa_handler);
 591                 new_sa.sa.sa_handler = (void __user *)(s64)handler;
 592                 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
 593                 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
 594                 if (err)
 595                         return -EFAULT;
 596         }
 597
 598         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
 599
 600         if (!ret && oact) {
 601                 int err = 0;
 602
 603                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 604                         return -EFAULT;
 605
 606                 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
 607                                    &oact->sa_handler);
 608                 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
 609                 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
 610                 if (err)
 611                         return -EFAULT;
 612         }
 613 out:
 614         return ret;
 615 }
 616
 617 SYSCALL_DEFINE3(32_rt_sigqueueinfo, int, pid, int, sig,
 618         compat_siginfo_t __user *, uinfo)
 619 {
 620         siginfo_t info;
 621         int ret;
 622         mm_segment_t old_fs = get_fs();
 623
 624         if (copy_from_user(&info, uinfo, 3*sizeof(int)) ||
 625             copy_from_user(info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
 626                 return -EFAULT;
 627         set_fs(KERNEL_DS);
 628         ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
 629         set_fs(old_fs);
 630         return ret;
 631 }
 632
 633 static int signal32_init(void)
 634 {
 635         if (cpu_has_fpu) {
 636                 save_fp_context32 = _save_fp_context32;
 637                 restore_fp_context32 = _restore_fp_context32;
 638         } else {
 639                 save_fp_context32 = fpu_emulator_save_context32;
 640                 restore_fp_context32 = fpu_emulator_restore_context32;
 641         }
 642
 643         return 0;
 644 }
 645
 646 arch_initcall(signal32_init);