linux/arch/parisc/kernel/signal32.c
<<
>>
Prefs
   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
  53inline void
  54sigset_32to64(sigset_t *s64, compat_sigset_t *s32)
  55{
  56        s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32);
  57}
  58
  59inline void
  60sigset_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
  66static int
  67put_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
  77static int
  78get_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
  92int 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
 111int 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
 124long
 125sys32_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
 152int 
 153do_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
 187long
 188restore_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 */
 266long
 267setup_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
 402int
 403copy_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
 446int
 447copy_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
 504asmlinkage 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
 522