git.oblomov.eu Git - linux-2.6/blob - arch/parisc/kernel/signal32.c

   1 /*    Signal support for 32-bit kernel builds
   2  *
   3  *    Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org>
   4  *    Copyright (C) 2006 Kyle McMartin <kyle at parisc-linux.org>
   5  *
   6  *    Code was mostly borrowed from kernel/signal.c.
   7  *    See kernel/signal.c for additional Copyrights.
   8  *
   9  *
  10  *    This program is free software; you can redistribute it and/or modify
  11  *    it under the terms of the GNU General Public License as published by
  12  *    the Free Software Foundation; either version 2 of the License, or
  13  *    (at your option) any later version.
  14  *
  15  *    This program is distributed in the hope that it will be useful,
  16  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *    GNU General Public License for more details.
  19  *
  20  *    You should have received a copy of the GNU General Public License
  21  *    along with this program; if not, write to the Free Software
  22  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include <linux/compat.h>
  26 #include <linux/slab.h>
  27 #include <linux/module.h>
  28 #include <linux/unistd.h>
  29 #include <linux/init.h>
  30 #include <linux/sched.h>
  31 #include <linux/syscalls.h>
  32 #include <linux/types.h>
  33 #include <linux/errno.h>
  34
  35 #include <asm/uaccess.h>
  36
  37 #include "signal32.h"
  38 #include "sys32.h"
  39
  40 #define DEBUG_COMPAT_SIG 0
  41 #define DEBUG_COMPAT_SIG_LEVEL 2
  42
  43 #if DEBUG_COMPAT_SIG
  44 #define DBG(LEVEL, ...) \
  45         ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \
  46         ? printk(__VA_ARGS__) : (void) 0)
  47 #else
  48 #define DBG(LEVEL, ...)
  49 #endif
  50
  51 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  52
  53 inline void
  54 sigset_32to64(sigset_t *s64, compat_sigset_t *s32)
  55 {
  56         s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32);
  57 }
  58
  59 inline void
  60 sigset_64to32(compat_sigset_t *s32, sigset_t *s64)
  61 {
  62         s32->sig[0] = s64->sig[0] & 0xffffffffUL;
  63         s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL;
  64 }
  65
  66 static int
  67 put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
  68 {
  69         compat_sigset_t s;
  70
  71         if (sz != sizeof *set) panic("put_sigset32()");
  72         sigset_64to32(&s, set);
  73
  74         return copy_to_user(up, &s, sizeof s);
  75 }
  76
  77 static int
  78 get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
  79 {
  80         compat_sigset_t s;
  81         int r;
  82
  83         if (sz != sizeof *set) panic("put_sigset32()");
  84
  85         if ((r = copy_from_user(&s, up, sz)) == 0) {
  86                 sigset_32to64(set, &s);
  87         }
  88
  89         return r;
  90 }
  91
  92 int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset,
  93                                     unsigned int sigsetsize)
  94 {
  95         sigset_t old_set, new_set;
  96         int ret;
  97
  98         if (set && get_sigset32(set, &new_set, sigsetsize))
  99                 return -EFAULT;
 100
 101         KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL,
 102                                  oset ? (sigset_t __user *)&old_set : NULL, sigsetsize);
 103
 104         if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize))
 105                 return -EFAULT;
 106
 107         return ret;
 108 }
 109
 110
 111 int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize)
 112 {
 113         int ret;
 114         sigset_t set;
 115
 116         KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize);
 117
 118         if (!ret && put_sigset32(uset, &set, sigsetsize))
 119                 return -EFAULT;
 120
 121         return ret;
 122 }
 123
 124 long
 125 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, struct sigaction32 __user *oact,
 126                  size_t sigsetsize)
 127 {
 128         struct k_sigaction32 new_sa32, old_sa32;
 129         struct k_sigaction new_sa, old_sa;
 130         int ret = -EINVAL;
 131
 132         if (act) {
 133                 if (copy_from_user(&new_sa32.sa, act, sizeof new_sa32.sa))
 134                         return -EFAULT;
 135                 new_sa.sa.sa_handler = (__sighandler_t)(unsigned long)new_sa32.sa.sa_handler;
 136                 new_sa.sa.sa_flags = new_sa32.sa.sa_flags;
 137                 sigset_32to64(&new_sa.sa.sa_mask, &new_sa32.sa.sa_mask);
 138         }
 139
 140         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
 141
 142         if (!ret && oact) {
 143                 sigset_64to32(&old_sa32.sa.sa_mask, &old_sa.sa.sa_mask);
 144                 old_sa32.sa.sa_flags = old_sa.sa.sa_flags;
 145                 old_sa32.sa.sa_handler = (__sighandler_t32)(unsigned long)old_sa.sa.sa_handler;
 146                 if (copy_to_user(oact, &old_sa32.sa, sizeof old_sa32.sa))
 147                         return -EFAULT;
 148         }
 149         return ret;
 150 }
 151
 152 int
 153 do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp)
 154 {
 155         compat_stack_t ss32, oss32;
 156         stack_t ss, oss;
 157         stack_t *ssp = NULL, *ossp = NULL;
 158         int ret;
 159
 160         if (uss32) {
 161                 if (copy_from_user(&ss32, uss32, sizeof ss32))
 162                         return -EFAULT;
 163
 164                 ss.ss_sp = (void __user *)(unsigned long)ss32.ss_sp;
 165                 ss.ss_flags = ss32.ss_flags;
 166                 ss.ss_size = ss32.ss_size;
 167
 168                 ssp = &ss;
 169         }
 170
 171         if (uoss32)
 172                 ossp = &oss;
 173
 174         KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp);
 175
 176         if (!ret && uoss32) {
 177                 oss32.ss_sp = (unsigned int)(unsigned long)oss.ss_sp;
 178                 oss32.ss_flags = oss.ss_flags;
 179                 oss32.ss_size = oss.ss_size;
 180                 if (copy_to_user(uoss32, &oss32, sizeof *uoss32))
 181                         return -EFAULT;
 182         }
 183
 184         return ret;
 185 }
 186
 187 long
 188 restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
 189                 struct pt_regs *regs)
 190 {
 191         long err = 0;
 192         compat_uint_t compat_reg;
 193         compat_uint_t compat_regt;
 194         int regn;
 195
 196         /* When loading 32-bit values into 64-bit registers make
 197            sure to clear the upper 32-bits */
 198         DBG(2,"restore_sigcontext32: PER_LINUX32 process\n");
 199         DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs);
 200         DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc));
 201         for(regn=0; regn < 32; regn++){
 202                 err |= __get_user(compat_reg,&sc->sc_gr[regn]);
 203                 regs->gr[regn] = compat_reg;
 204                 /* Load upper half */
 205                 err |= __get_user(compat_regt,&rf->rf_gr[regn]);
 206                 regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg;
 207                 DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n",
 208                                 regn, regs->gr[regn], compat_regt, compat_reg);
 209         }
 210         DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr));
 211         /* XXX: BE WARNED FR's are 64-BIT! */
 212         err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
 213
 214         /* Better safe than sorry, pass __get_user two things of
 215            the same size and let gcc do the upward conversion to
 216            64-bits */
 217         err |= __get_user(compat_reg, &sc->sc_iaoq[0]);
 218         /* Load upper half */
 219         err |= __get_user(compat_regt, &rf->rf_iaoq[0]);
 220         regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
 221         DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt);
 222         DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n",
 223                         &sc->sc_iaoq[0], compat_reg);
 224
 225         err |= __get_user(compat_reg, &sc->sc_iaoq[1]);
 226         /* Load upper half */
 227         err |= __get_user(compat_regt, &rf->rf_iaoq[1]);
 228         regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
 229         DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt);
 230         DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n",
 231                         &sc->sc_iaoq[1],compat_reg);
 232         DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n",
 233                         regs->iaoq[0],regs->iaoq[1]);
 234
 235         err |= __get_user(compat_reg, &sc->sc_iasq[0]);
 236         /* Load the upper half for iasq */
 237         err |= __get_user(compat_regt, &rf->rf_iasq[0]);
 238         regs->iasq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
 239         DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt);
 240
 241         err |= __get_user(compat_reg, &sc->sc_iasq[1]);
 242         /* Load the upper half for iasq */
 243         err |= __get_user(compat_regt, &rf->rf_iasq[1]);
 244         regs->iasq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
 245         DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt);
 246         DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n",
 247                 regs->iasq[0],regs->iasq[1]);
 248
 249         err |= __get_user(compat_reg, &sc->sc_sar);
 250         /* Load the upper half for sar */
 251         err |= __get_user(compat_regt, &rf->rf_sar);
 252         regs->sar = ((u64)compat_regt << 32) | (u64)compat_reg;
 253         DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt);
 254         DBG(2,"restore_sigcontext32: sar is %#lx\n", regs->sar);
 255         DBG(2,"restore_sigcontext32: r28 is %ld\n", regs->gr[28]);
 256
 257         return err;
 258 }
 259
 260 /*
 261  * Set up the sigcontext structure for this process.
 262  * This is not an easy task if the kernel is 64-bit, it will require
 263  * that we examine the process personality to determine if we need to
 264  * truncate for a 32-bit userspace.
 265  */
 266 long
 267 setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
 268                 struct pt_regs *regs, int in_syscall)
 269 {
 270         compat_int_t flags = 0;
 271         long err = 0;
 272         compat_uint_t compat_reg;
 273         compat_uint_t compat_regb;
 274         int regn;
 275
 276         if (on_sig_stack((unsigned long) sc))
 277                 flags |= PARISC_SC_FLAG_ONSTACK;
 278
 279         if (in_syscall) {
 280
 281                 DBG(1,"setup_sigcontext32: in_syscall\n");
 282
 283                 flags |= PARISC_SC_FLAG_IN_SYSCALL;
 284                 /* Truncate gr31 */
 285                 compat_reg = (compat_uint_t)(regs->gr[31]);
 286                 /* regs->iaoq is undefined in the syscall return path */
 287                 err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
 288                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
 289                                 &sc->sc_iaoq[0], compat_reg);
 290
 291                 /* Store upper half */
 292                 compat_reg = (compat_uint_t)(regs->gr[31] >> 32);
 293                 err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
 294                 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
 295
 296
 297                 compat_reg = (compat_uint_t)(regs->gr[31]+4);
 298                 err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
 299                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
 300                                 &sc->sc_iaoq[1], compat_reg);
 301                 /* Store upper half */
 302                 compat_reg = (compat_uint_t)((regs->gr[31]+4) >> 32);
 303                 err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
 304                 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
 305
 306                 /* Truncate sr3 */
 307                 compat_reg = (compat_uint_t)(regs->sr[3]);
 308                 err |= __put_user(compat_reg, &sc->sc_iasq[0]);
 309                 err |= __put_user(compat_reg, &sc->sc_iasq[1]);
 310
 311                 /* Store upper half */
 312                 compat_reg = (compat_uint_t)(regs->sr[3] >> 32);
 313                 err |= __put_user(compat_reg, &rf->rf_iasq[0]);
 314                 err |= __put_user(compat_reg, &rf->rf_iasq[1]);
 315
 316                 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
 317                 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
 318                 DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n",
 319                         regs->gr[31], regs->gr[31]+4);
 320
 321         } else {
 322
 323                 compat_reg = (compat_uint_t)(regs->iaoq[0]);
 324                 err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
 325                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
 326                                 &sc->sc_iaoq[0], compat_reg);
 327                 /* Store upper half */
 328                 compat_reg = (compat_uint_t)(regs->iaoq[0] >> 32);
 329                 err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
 330                 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
 331
 332                 compat_reg = (compat_uint_t)(regs->iaoq[1]);
 333                 err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
 334                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
 335                                 &sc->sc_iaoq[1], compat_reg);
 336                 /* Store upper half */
 337                 compat_reg = (compat_uint_t)(regs->iaoq[1] >> 32);
 338                 err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
 339                 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
 340
 341
 342                 compat_reg = (compat_uint_t)(regs->iasq[0]);
 343                 err |= __put_user(compat_reg, &sc->sc_iasq[0]);
 344                 DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n",
 345                                 &sc->sc_iasq[0], compat_reg);
 346                 /* Store upper half */
 347                 compat_reg = (compat_uint_t)(regs->iasq[0] >> 32);
 348                 err |= __put_user(compat_reg, &rf->rf_iasq[0]);
 349                 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
 350
 351
 352                 compat_reg = (compat_uint_t)(regs->iasq[1]);
 353                 err |= __put_user(compat_reg, &sc->sc_iasq[1]);
 354                 DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n",
 355                                 &sc->sc_iasq[1], compat_reg);
 356                 /* Store upper half */
 357                 compat_reg = (compat_uint_t)(regs->iasq[1] >> 32);
 358                 err |= __put_user(compat_reg, &rf->rf_iasq[1]);
 359                 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
 360
 361                 /* Print out the IAOQ for debugging */
 362                 DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n",
 363                         regs->iaoq[0], regs->iaoq[1]);
 364         }
 365
 366         err |= __put_user(flags, &sc->sc_flags);
 367
 368         DBG(1,"setup_sigcontext32: Truncating general registers.\n");
 369
 370         for(regn=0; regn < 32; regn++){
 371                 /* Truncate a general register */
 372                 compat_reg = (compat_uint_t)(regs->gr[regn]);
 373                 err |= __put_user(compat_reg, &sc->sc_gr[regn]);
 374                 /* Store upper half */
 375                 compat_regb = (compat_uint_t)(regs->gr[regn] >> 32);
 376                 err |= __put_user(compat_regb, &rf->rf_gr[regn]);
 377
 378                 /* DEBUG: Write out the "upper / lower" register data */
 379                 DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn,
 380                                 compat_regb, compat_reg);
 381         }
 382
 383         /* Copy the floating point registers (same size)
 384            XXX: BE WARNED FR's are 64-BIT! */
 385         DBG(1,"setup_sigcontext32: Copying from regs to sc, "
 386               "sc->sc_fr size = %#lx, regs->fr size = %#lx\n",
 387                 sizeof(regs->fr), sizeof(sc->sc_fr));
 388         err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
 389
 390         compat_reg = (compat_uint_t)(regs->sar);
 391         err |= __put_user(compat_reg, &sc->sc_sar);
 392         DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg);
 393         /* Store upper half */
 394         compat_reg = (compat_uint_t)(regs->sar >> 32);
 395         err |= __put_user(compat_reg, &rf->rf_sar);
 396         DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg);
 397         DBG(1,"setup_sigcontext32: r28 is %ld\n", regs->gr[28]);
 398
 399         return err;
 400 }
 401
 402 int
 403 copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from)
 404 {
 405         compat_uptr_t addr;
 406         int err;
 407
 408         if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
 409                 return -EFAULT;
 410
 411         err = __get_user(to->si_signo, &from->si_signo);
 412         err |= __get_user(to->si_errno, &from->si_errno);
 413         err |= __get_user(to->si_code, &from->si_code);
 414
 415         if (to->si_code < 0)
 416                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 417         else {
 418                 switch (to->si_code >> 16) {
 419                       case __SI_CHLD >> 16:
 420                         err |= __get_user(to->si_utime, &from->si_utime);
 421                         err |= __get_user(to->si_stime, &from->si_stime);
 422                         err |= __get_user(to->si_status, &from->si_status);
 423                       default:
 424                         err |= __get_user(to->si_pid, &from->si_pid);
 425                         err |= __get_user(to->si_uid, &from->si_uid);
 426                         break;
 427                       case __SI_FAULT >> 16:
 428                         err |= __get_user(addr, &from->si_addr);
 429                         to->si_addr = compat_ptr(addr);
 430                         break;
 431                       case __SI_POLL >> 16:
 432                         err |= __get_user(to->si_band, &from->si_band);
 433                         err |= __get_user(to->si_fd, &from->si_fd);
 434                         break;
 435                       case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 436                       case __SI_MESGQ >> 16:
 437                         err |= __get_user(to->si_pid, &from->si_pid);
 438                         err |= __get_user(to->si_uid, &from->si_uid);
 439                         err |= __get_user(to->si_int, &from->si_int);
 440                         break;
 441                 }
 442         }
 443         return err;
 444 }
 445
 446 int
 447 copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from)
 448 {
 449         compat_uptr_t addr;
 450         compat_int_t val;
 451         int err;
 452
 453         if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 454                 return -EFAULT;
 455
 456         /* If you change siginfo_t structure, please be sure
 457            this code is fixed accordingly.
 458            It should never copy any pad contained in the structure
 459            to avoid security leaks, but must copy the generic
 460            3 ints plus the relevant union member.
 461            This routine must convert siginfo from 64bit to 32bit as well
 462            at the same time.  */
 463         err = __put_user(from->si_signo, &to->si_signo);
 464         err |= __put_user(from->si_errno, &to->si_errno);
 465         err |= __put_user((short)from->si_code, &to->si_code);
 466         if (from->si_code < 0)
 467                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 468         else {
 469                 switch (from->si_code >> 16) {
 470                 case __SI_CHLD >> 16:
 471                         err |= __put_user(from->si_utime, &to->si_utime);
 472                         err |= __put_user(from->si_stime, &to->si_stime);
 473                         err |= __put_user(from->si_status, &to->si_status);
 474                 default:
 475                         err |= __put_user(from->si_pid, &to->si_pid);
 476                         err |= __put_user(from->si_uid, &to->si_uid);
 477                         break;
 478                 case __SI_FAULT >> 16:
 479                         addr = ptr_to_compat(from->si_addr);
 480                         err |= __put_user(addr, &to->si_addr);
 481                         break;
 482                 case __SI_POLL >> 16:
 483                         err |= __put_user(from->si_band, &to->si_band);
 484                         err |= __put_user(from->si_fd, &to->si_fd);
 485                         break;
 486                 case __SI_TIMER >> 16:
 487                         err |= __put_user(from->si_tid, &to->si_tid);
 488                         err |= __put_user(from->si_overrun, &to->si_overrun);
 489                         val = (compat_int_t)from->si_int;
 490                         err |= __put_user(val, &to->si_int);
 491                         break;
 492                 case __SI_RT >> 16:     /* Not generated by the kernel as of now.  */
 493                 case __SI_MESGQ >> 16:
 494                         err |= __put_user(from->si_uid, &to->si_uid);
 495                         err |= __put_user(from->si_pid, &to->si_pid);
 496                         val = (compat_int_t)from->si_int;
 497                         err |= __put_user(val, &to->si_int);
 498                         break;
 499                 }
 500         }
 501         return err;
 502 }
 503
 504 asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig,
 505         struct compat_siginfo __user *uinfo)
 506 {
 507         siginfo_t info;
 508
 509         if (copy_siginfo_from_user32(&info, uinfo))
 510                 return -EFAULT;
 511
 512         /* Not even root can pretend to send signals from the kernel.
 513            Nor can they impersonate a kill(), which adds source info.  */
 514         if (info.si_code >= 0)
 515                 return -EPERM;
 516         info.si_signo = sig;
 517
 518         /* POSIX.1b doesn't mention process groups.  */
 519         return kill_proc_info(sig, &info, pid);
 520 }
 521