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