# 2.11BSD#431 - /usr/src/sys/sys/kern_sig.c

##### Functions

    cansignal         X
    core              X
    gsignal           X
    issignal          X
    kill              X
    killpg            X
    killpg1           X
    postsig           X
    psignal           X
    sigstack          X
    stop              X

##### struct's

    a                 X

       1: /*
       2:  * Copyright (c) 1986 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  *
       6:  *	@(#)kern_sig.c	1.13 (2.11BSD) 2000/2/20
       7:  */
       8:
       9: #include "param.h"
      10: #include "../machine/seg.h"
      11: #include "systm.h"
      12: #include "user.h"
      13: #include "inode.h"
      14: #include "proc.h"
      15: #include "text.h"
      16: #include "namei.h"
      17: #include "acct.h"
      18: #include "signalvar.h"
      19: extern  char    sigprop[];  /* XXX - defined in kern_sig2.c */
      20:
      21: /*
      22:  * Can the current process send the signal `signum' to process `q'?
      23:  * This is complicated by the need to access the `real uid' of `q'.
      24:  * The 'real uid' is in the u area and `q' may be (but usually is not) swapped
      25:  * out.  Use the routine `fill_from_u' which the sysctl() call uses.  See the
      26:  * notes in kern_sysctl.c
      27:  *
      28:  * The previous checks for a process to post a signal to another process
      29:  * checked _only_ the effective userid.  With the implementation of the
      30:  * 'saved id' feature and the ability of a setuid program to assume either
      31:  * uid that check was inadequate.
      32:  *
      33:  * The 'c'urrent process is allowed to send a signal to a 't'arget process if
      34:  * 1) either the real or effective user ids match OR 2) if the signal is
      35:  * SIGCONT and the target process is a descendant of the current process
      36: */
      37: cansignal(q, signum)
      38:     register struct proc *q;
      39:     int signum;
      40:     {
      41:     register struct proc *curp = u.u_procp;
      42:     uid_t   ruid;
      43:
      44:     fill_from_u(q, &ruid, NULL, NULL);  /* XXX */
      45:     if  (curp->p_uid == 0 ||        /* c effective root */
      46:          u.u_ruid == ruid ||        /* c real = t real */
      47:          curp->p_uid == ruid ||     /* c effective = t real */
      48:          u.u_ruid == q->p_uid ||    /* c real = t effective */
      49:          curp->p_uid == q->p_uid || /* c effective = t effective */
      50:          (signum == SIGCONT && inferior(q)))
      51:         return(1);
      52:     return(0);
      53:     }
      54:
      55: /*
      56:  * 4.3 Compatibility
      57: */
      58: sigstack()
      59:     {
      60:     register struct a
      61:         {
      62:         struct  sigstack *nss;
      63:         struct  sigstack *oss;
      64:         } *uap = (struct a *)u.u_ap;
      65:     struct sigstack ss;
      66:     register int error = 0;
      67:
      68:     ss.ss_sp = u.u_sigstk.ss_base;
      69:     ss.ss_onstack = u.u_sigstk.ss_flags & SA_ONSTACK;
      70:     if  (uap->oss && (error = copyout((caddr_t)&ss,
      71:                     (caddr_t)uap->oss, sizeof (ss))))
      72:         goto out;
      73:     if  (uap->nss && (error = copyin((caddr_t)uap->nss, (caddr_t)&ss,
      74:                     sizeof (ss))) == 0)
      75:         {
      76:         u.u_sigstk.ss_base = ss.ss_sp;
      77:         u.u_sigstk.ss_size = 0;
      78:         u.u_sigstk.ss_flags |= (ss.ss_onstack & SA_ONSTACK);
      79:         u.u_psflags |= SAS_ALTSTACK;
      80:         }
      81: out:
      82:     return(u.u_error = error);
      83:     }
      84:
      85: kill()
      86: {
      87:     register struct a {
      88:         int pid;
      89:         int signo;
      90:     } *uap = (struct a *)u.u_ap;
      91:     register struct proc *p;
      92:     register int error = 0;
      93:
      94:     /*
      95: 	 * BSD4.3 botches the comparison against NSIG - it's a good thing for
      96: 	 * them psignal catches the error - however, since psignal is the
      97: 	 * kernel's internel signal mechanism and *should be getting correct
      98: 	 * parameters from the rest of the kernel, psignal shouldn't *have*
      99: 	 * to check it's parameters for validity.  If you feel differently,
     100: 	 * feel free to clutter up the entire inner kernel with parameter
     101: 	 * checks - start with postsig ...
     102: 	 */
     103:     if (uap->signo < 0 || uap->signo >= NSIG) {
     104:         error = EINVAL;
     105:         goto out;
     106:     }
     107:     if (uap->pid > 0) {
     108:         /* kill single process */
     109:         p = pfind(uap->pid);
     110:         if (p == 0) {
     111:             error = ESRCH;
     112:             goto out;
     113:         }
     114:         if (!cansignal(p, uap->signo))
     115:             error = EPERM;
     116:         else if (uap->signo)
     117:             psignal(p, uap->signo);
     118:         goto out;
     119:     }
     120:     switch (uap->pid) {
     121:     case -1:        /* broadcast signal */
     122:         error = killpg1(uap->signo, 0, 1);
     123:         break;
     124:     case 0:         /* signal own process group */
     125:         error = killpg1(uap->signo, 0, 0);
     126:         break;
     127:     default:        /* negative explicit process group */
     128:         error = killpg1(uap->signo, -uap->pid, 0);
     129:         break;
     130:     }
     131: out:
     132:     return(u.u_error = error);
     133: }
     134:
     135: killpg()
     136: {
     137:     register struct a {
     138:         int pgrp;
     139:         int signo;
     140:     } *uap = (struct a *)u.u_ap;
     141:     register int error = 0;
     142:
     143:     if (uap->signo < 0 || uap->signo >= NSIG) {
     144:         error = EINVAL;
     145:         goto out;
     146:     }
     147:     error = killpg1(uap->signo, uap->pgrp, 0);
     148: out:
     149:     return(u.u_error = error);
     150: }
     151:
     152: killpg1(signo, pgrp, all)
     153:     int signo, pgrp, all;
     154: {
     155:     register struct proc *p;
     156:     int f, error = 0;
     157:
     158:     if (!all && pgrp == 0) {
     159:         /*
     160: 		 * Zero process id means send to my process group.
     161: 		 */
     162:         pgrp = u.u_procp->p_pgrp;
     163:         if (pgrp == 0)
     164:             return (ESRCH);
     165:     }
     166:     for (f = 0, p = allproc; p != NULL; p = p->p_nxt) {
     167:         if ((p->p_pgrp != pgrp && !all) || p->p_ppid == 0 ||
     168:             (p->p_flag&SSYS) || (all && p == u.u_procp))
     169:             continue;
     170:         if (!cansignal(p, signo)) {
     171:             if (!all)
     172:                 error = EPERM;
     173:             continue;
     174:         }
     175:         f++;
     176:         if (signo)
     177:             psignal(p, signo);
     178:     }
     179:     return (error ? error : (f == 0 ? ESRCH : 0));
     180: }
     181:
     182: /*
     183:  * Send the specified signal to
     184:  * all processes with 'pgrp' as
     185:  * process group.
     186:  */
     187: gsignal(pgrp, sig)
     188:     register int pgrp;
     189: {
     190:     register struct proc *p;
     191:     mapinfo map;
     192:
     193:     if (pgrp == 0)
     194:         return;
     195:     savemap(map);
     196:
     197:     for (p = allproc; p != NULL; p = p->p_nxt)
     198:         if (p->p_pgrp == pgrp)
     199:             psignal(p, sig);
     200:     restormap(map);
     201: }
     202:
     203: /*
     204:  * Send the specified signal to
     205:  * the specified process.
     206:  */
     207: psignal(p, sig)
     208:     register struct proc *p;
     209:     register int sig;
     210: {
     211:     register int s;
     212:     int (*action)();
     213:     int prop;
     214:     long mask;
     215:
     216:     mask = sigmask(sig);
     217:     prop = sigprop[sig];
     218:
     219:     /*
     220: 	 * If proc is traced, always give parent a chance.
     221: 	 */
     222:     if (p->p_flag & P_TRACED)
     223:         action = SIG_DFL;
     224:     else {
     225:         /*
     226: 		 * If the signal is being ignored,
     227: 		 * then we forget about it immediately.
     228: 		 */
     229:         if (p->p_sigignore & mask)
     230:             return;
     231:         if (p->p_sigmask & mask)
     232:             action = SIG_HOLD;
     233:         else if (p->p_sigcatch & mask)
     234:             action = SIG_CATCH;
     235:         else
     236:             action = SIG_DFL;
     237:     }
     238:
     239:     if (p->p_nice > NZERO && action == SIG_DFL && (prop & SA_KILL) &&
     240:         (p->p_flag & P_TRACED) == 0)
     241:         p->p_nice = NZERO;
     242:
     243:     if (prop & SA_CONT)
     244:         p->p_sig &= ~stopsigmask;
     245:
     246:     if (prop & SA_STOP) {
     247:         /*
     248: 		 * If sending a tty stop signal to a member of an orphaned
     249: 		 * process group (i.e. a child of init), discard the signal
     250: 		 * here if the action is default; don't stop the process
     251: 		 * below if sleeping, and don't clear any pending SIGCONT.
     252: 		 */
     253:         if (prop & SA_TTYSTOP && (p->p_pptr == &proc[1]) &&
     254:             action == SIG_DFL)
     255:             return;
     256:         p->p_sig &= ~contsigmask;
     257:     }
     258:     p->p_sig |= mask;
     259:
     260:     /*
     261: 	 * Defer further processing for signals which are held.
     262: 	 */
     263:     if (action == SIG_HOLD && ((prop & SA_CONT) == 0 || p->p_stat != SSTOP))
     264:         return;
     265:     s = splhigh();
     266:     switch (p->p_stat) {
     267:
     268:     case SSLEEP:
     269:         /*
     270: 		 * If process is sleeping uninterruptibly we can not
     271: 		 * interrupt the sleep... the signal will be noticed
     272: 		 * when the process returns through trap() or syscall().
     273: 		 */
     274:         if  ((p->p_flag & P_SINTR) == 0)
     275:             goto out;
     276:         /*
     277: 		 * Process is sleeping and traced... make it runnable
     278: 		 * so it can discover the signal in issignal() and stop
     279: 		 * for the parent.
     280: 		 */
     281:         if  (p->p_flag& P_TRACED)
     282:             goto run;
     283:
     284:         /*
     285: 		 * If SIGCONT is default (or ignored) and process is
     286: 		 * asleep, we are finished; the process should not
     287: 		 * be awakened.
     288: 		 */
     289:         if ((prop & SA_CONT) && action == SIG_DFL) {
     290:             p->p_sig &= ~mask;
     291:             goto out;
     292:         }
     293:         /*
     294: 		 * When a sleeping process receives a stop
     295: 		 * signal, process immediately if possible.
     296: 		 * All other (caught or default) signals
     297: 		 * cause the process to run.
     298: 		 */
     299:         if (prop & SA_STOP) {
     300:             if (action != SIG_DFL)
     301:                 goto run;
     302:             /*
     303: 			 * If a child holding parent blocked,
     304: 			 * stopping could cause deadlock.
     305: 			 */
     306:             if (p->p_flag & SVFORK)
     307:                 goto out;
     308:             p->p_sig &= ~mask;
     309:             p->p_ptracesig = sig;
     310:             if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0)
     311:                 psignal(p->p_pptr, SIGCHLD);
     312:             stop(p);
     313:             goto out;
     314:         } else
     315:             goto run;
     316:         /*NOTREACHED*/
     317:     case SSTOP:
     318:         /*
     319: 		 * If traced process is already stopped,
     320: 		 * then no further action is necessary.
     321: 		 */
     322:         if (p->p_flag & P_TRACED)
     323:             goto out;
     324:         if (sig == SIGKILL)
     325:             goto run;
     326:         if (prop & SA_CONT) {
     327:             /*
     328: 			 * If SIGCONT is default (or ignored), we continue the
     329: 			 * process but don't leave the signal in p_sig, as
     330: 			 * it has no further action.  If SIGCONT is held, we
     331: 			 * continue the process and leave the signal in
     332: 			 * p_sig.  If the process catches SIGCONT, let it
     333: 			 * handle the signal itself.  If it isn't waiting on
     334: 			 * an event, then it goes back to run state.
     335: 			 * Otherwise, process goes back to sleep state.
     336: 			 */
     337:             if (action == SIG_DFL)
     338:                 p->p_sig &= ~mask;
     339:             if (action == SIG_CATCH || p->p_wchan == 0)
     340:                 goto run;
     341:             p->p_stat = SSLEEP;
     342:             goto out;
     343:         }
     344:
     345:         if (prop & SA_STOP) {
     346:             /*
     347: 			 * Already stopped, don't need to stop again.
     348: 			 * (If we did the shell could get confused.)
     349: 			 */
     350:             p->p_sig &= ~mask;      /* take it away */
     351:             goto out;
     352:         }
     353:
     354:         /*
     355: 		 * If process is sleeping interruptibly, then simulate a
     356: 		 * wakeup so that when it is continued, it will be made
     357: 		 * runnable and can look at the signal.  But don't make
     358: 		 * the process runnable, leave it stopped.
     359: 		 */
     360:         if (p->p_wchan && (p->p_flag & P_SINTR))
     361:             unsleep(p);
     362:         goto out;
     363:         /*NOTREACHED*/
     364:
     365:     default:
     366:         /*
     367: 		 * SRUN, SIDL, SZOMB do nothing with the signal,
     368: 		 * other than kicking ourselves if we are running.
     369: 		 * It will either never be noticed, or noticed very soon.
     370: 		 */
     371:         goto out;
     372:     }
     373:     /*NOTREACHED*/
     374: run:
     375:     /*
     376: 	 * Raise priority to at least PUSER.
     377: 	 */
     378:     if (p->p_pri > PUSER)
     379:         p->p_pri = PUSER;
     380:     setrun(p);
     381: out:
     382:     splx(s);
     383: }
     384:
     385: /*
     386:  * If the current process has received a signal (should be caught
     387:  * or cause termination, should interrupt current syscall) return the
     388:  * signal number.  Stop signals with default action are processed
     389:  * immediately then cleared; they are not returned.  This is checked
     390:  * after each entry into the kernel for a syscall of trap (though this
     391:  * can usually be done without calling issignal by checking the pending
     392:  * signals masks in CURSIG)/  The normal sequence is:
     393:  *
     394:  *	while (signum = CURSIG(u.u_procp))
     395:  *		postsig(signum);
     396:  */
     397: issignal(p)
     398:     register struct proc *p;
     399: {
     400:     register int sig;
     401:     long mask;
     402:     int prop;
     403:
     404:     for (;;) {
     405:         mask = p->p_sig & ~p->p_sigmask;
     406:         if (p->p_flag&SVFORK)
     407:             mask &= ~stopsigmask;
     408:         if (mask == 0)
     409:             return(0);      /* No signals to send */
     410:         sig = ffs(mask);
     411:         mask = sigmask(sig);
     412:         prop = sigprop[sig];
     413:         /*
     414: 		 * We should see pending but ignored signals
     415: 		 * only if P_TRACED was on when they were posted.
     416: 		*/
     417:         if (mask & p->p_sigignore && (p->p_flag& P_TRACED) == 0) {
     418:             p->p_sig &= ~mask;
     419:             continue;
     420:         }
     421:         if (p->p_flag & P_TRACED && (p->p_flag & SVFORK) == 0) {
     422:             /*
     423: 			 * If traced, always stop, and stay
     424: 			 * stopped until released by the parent.
     425: 			 *
     426: 			 * Note that we  must clear the pending signal
     427: 			 * before we call procxmt since that routine
     428: 			 * might cause a fault, calling sleep and
     429: 			 * leading us back here again with the same signal.
     430: 			 * Then we would be deadlocked because the tracer
     431: 			 * would still be blocked on the ipc struct from
     432: 			 * the initial request.
     433: 			 */
     434:             p->p_sig &= ~mask;
     435:             p->p_ptracesig = sig;
     436:             psignal(p->p_pptr, SIGCHLD);
     437:             do {
     438:                 stop(p);
     439:                 swtch();
     440:             } while (!procxmt() && p->p_flag & P_TRACED);
     441:
     442:             /*
     443: 			 * If parent wants us to take the signal,
     444: 			 * then it will leave it in p->p_ptracesig;
     445: 			 * otherwise we just look for signals again.
     446: 			 */
     447:             sig = p->p_ptracesig;
     448:             if (sig == 0)
     449:                 continue;
     450:
     451:             /*
     452: 			 * Put the new signal into p_sig.  If the
     453: 			 * signal is being masked, look for other signals.
     454: 			 */
     455:             mask = sigmask(sig);
     456:             p->p_sig |= mask;
     457:             if (p->p_sigmask & mask)
     458:                 continue;
     459:
     460:             /*
     461: 			 * If the traced bit got turned off, go back up
     462: 			 * to the top to rescan signals.  This ensures
     463: 			 * that p_sig* and u_signal are consistent.
     464: 			 */
     465:             if ((p->p_flag& P_TRACED) == 0)
     466:                 continue;
     467:             prop = sigprop[sig];
     468:         }
     469:
     470:         switch ((int)u.u_signal[sig]) {
     471:
     472:         case SIG_DFL:
     473:             /*
     474: 			 * Don't take default actions on system processes.
     475: 			 */
     476:             if (p->p_pid <= 1) {
     477: #ifdef DIAGNOSTIC
     478:                 /*
     479:  				 * Are you sure you want to ignore SIGSEGV
     480:  				 * in init? XXX
     481: 				 */
     482:                 printf("Process (pid %d) got signal %d\n",
     483:                     p->p_pid, sig);
     484: #endif
     485:                 break;
     486:             }
     487:             /*
     488: 			 * If there is a pending stop signal to process
     489: 			 * with default action, stop here,
     490: 			 * then clear the signal.  However,
     491: 			 * if process is member of an orphaned
     492: 			 * process group, ignore tty stop signals.
     493: 			 */
     494:             if (prop & SA_STOP) {
     495:                 if (p->p_flag & P_TRACED ||
     496:                         (p->p_pptr == &proc[1] &&
     497:                     prop & SA_TTYSTOP))
     498:                     break;  /* == ignore */
     499:                 p->p_ptracesig = sig;
     500:                 if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0)
     501:                     psignal(p->p_pptr, SIGCHLD);
     502:                 stop(p);
     503:                 swtch();
     504:                 break;
     505:             } else if (prop & SA_IGNORE) {
     506:                 /*
     507: 				 * Except for SIGCONT, shouldn't get here.
     508: 				 * Default action is to ignore; drop it.
     509: 				 */
     510:                 break;      /* == ignore */
     511:             } else
     512:                 return(sig);
     513:             /*NOTREACHED*/
     514:
     515:         case SIG_IGN:
     516:             /*
     517: 			 * Masking above should prevent us
     518: 			 * ever trying to take action on a held
     519: 			 * or ignored signal, unless process is traced.
     520: 			 */
     521:             if ((prop & SA_CONT) == 0 &&
     522:                 (p->p_flag & P_TRACED) == 0)
     523:                 printf("issig\n");
     524:             break;          /* == ignore */
     525:
     526:         default:
     527:             /*
     528: 			 * This signal has an action, let postsig process it.
     529: 			 */
     530:             return(sig);
     531:         }
     532:         p->p_sig &= ~mask;      /* take the signal away! */
     533:     }
     534:     /* NOTREACHED */
     535: }
     536:
     537: /*
     538:  * Put the argument process into the stopped
     539:  * state and notify the parent via wakeup.
     540:  * Signals are handled elsewhere.
     541:  */
     542: stop(p)
     543:     register struct proc *p;
     544: {
     545:
     546:     p->p_stat = SSTOP;
     547:     p->p_flag &= ~P_WAITED;
     548:     wakeup((caddr_t)p->p_pptr);
     549: }
     550:
     551: /*
     552:  * Take the action for the specified signal
     553:  * from the current set of pending signals.
     554:  */
     555:
     556: postsig(sig)
     557:     int sig;
     558: {
     559:     register struct proc *p = u.u_procp;
     560:     long mask = sigmask(sig), returnmask;
     561:     register int (*action)();
     562:
     563:     if (u.u_fpsaved == 0) {
     564:         savfp(&u.u_fps);
     565:         u.u_fpsaved = 1;
     566:     }
     567:
     568:     p->p_sig &= ~mask;
     569:     action = u.u_signal[sig];
     570:
     571:     if (action != SIG_DFL) {
     572: #ifdef DIAGNOSTIC
     573:         if (action == SIG_IGN || (p->p_sigmask & mask))
     574:             panic("postsig action");
     575: #endif
     576:         u.u_error = 0;  /* XXX - why? */
     577:         /*
     578: 		 * Set the new mask value and also defer further
     579: 		 * occurences of this signal.
     580: 		 *
     581: 		 * Special case: user has done a sigsuspend.  Here the
     582: 		 * current mask is not of interest, but rather the
     583: 		 * mask from before the sigsuspend is what we want restored
     584: 		 * after the signal processing is completed.
     585: 		 */
     586:         (void) _splhigh();
     587:         if (u.u_psflags & SAS_OLDMASK) {
     588:             returnmask = u.u_oldmask;
     589:             u.u_psflags &= ~SAS_OLDMASK;
     590:         } else
     591:             returnmask = p->p_sigmask;
     592:         p->p_sigmask |= u.u_sigmask[sig] | mask;
     593:         (void) _spl0();
     594:         u.u_ru.ru_nsignals++;
     595:         sendsig(action, sig, returnmask);
     596:         return;
     597:     }
     598:     u.u_acflag |= AXSIG;
     599:     if  (sigprop[sig] & SA_CORE)
     600:         {
     601:         u.u_arg[0] = sig;
     602:         if  (core())
     603:             sig |= 0200;
     604:         }
     605:     exit(sig);
     606: }
     607:
     608: /*
     609:  * Create a core image on the file "core"
     610:  * If you are looking for protection glitches,
     611:  * there are probably a wealth of them here
     612:  * when this occurs to a suid command.
     613:  *
     614:  * It writes UPAGES (USIZE for pdp11) block of the
     615:  * user.h area followed by the entire
     616:  * data+stack segments.
     617:  */
     618: core()
     619: {
     620:     register struct inode *ip;
     621:     struct  nameidata nd;
     622:     register struct nameidata *ndp = &nd;
     623:     register char *np;
     624:     char    *cp, name[MAXCOMLEN + 6];
     625:
     626:     /*
     627: 	 * Don't dump if not root and the process has used set user or
     628: 	 * group privileges.
     629: 	*/
     630:     if  (u.u_acflag & ASUGID && !suser())
     631:         return(0);
     632:     if (ctob(USIZE+u.u_dsize+u.u_ssize) >=
     633:         u.u_rlimit[RLIMIT_CORE].rlim_cur)
     634:         return (0);
     635:     if (u.u_procp->p_textp && access(u.u_procp->p_textp->x_iptr, IREAD))
     636:         return (0);
     637:     cp = u.u_comm;
     638:     np = name;
     639:     while   (*np++ = *cp++)
     640:         ;
     641:     cp = ".core";
     642:     np--;
     643:     while   (*np++ = *cp++)
     644:         ;
     645:     u.u_error = 0;
     646:     NDINIT(ndp, CREATE, FOLLOW, UIO_SYSSPACE, name);
     647:     ip = namei(ndp);
     648:     if (ip == NULL) {
     649:         if (u.u_error)
     650:             return (0);
     651:         ip = maknode(0644, ndp);
     652:         if (ip==NULL)
     653:             return (0);
     654:     }
     655:     if (access(ip, IWRITE) ||
     656:        (ip->i_mode&IFMT) != IFREG ||
     657:        ip->i_nlink != 1) {
     658:         u.u_error = EFAULT;
     659:         goto out;
     660:     }
     661:     itrunc(ip, (u_long)0, 0);
     662:     u.u_acflag |= ACORE;
     663:     u.u_error = rdwri(UIO_WRITE, ip, &u, ctob(USIZE), (off_t)0,
     664:             UIO_SYSSPACE, IO_UNIT, (int *)0);
     665:     if (u.u_error)
     666:         goto out;
     667:
     668:     estabur((u_int)0, u.u_dsize, u.u_ssize, 0, RO);
     669:     u.u_error = rdwri(UIO_WRITE, ip, 0, ctob(u.u_dsize), (off_t)ctob(USIZE),
     670:             UIO_USERSPACE, IO_UNIT, (int *)0);
     671:     if (u.u_error)
     672:         goto out;
     673:
     674:     u.u_error = rdwri(UIO_WRITE, ip, (caddr_t)(-(ctob(u.u_ssize))), ctob(u.u_ssize),
     675:             (off_t)ctob(USIZE) + (off_t)ctob(u.u_dsize),
     676:              UIO_USERSPACE, IO_UNIT, (int *)0);
     677: out:
     678:     iput(ip);
     679:     return (u.u_error == 0);
     680: }

#### Defined functions

cansignal defined in line 37; used 2 times

- in line 114, 170

core defined in line 618; used 1 times

- in line 602

gsignal defined in line 187; used 15 times

- in /usr/src/sys/pdp/net_mac.h line 37-39(2)
- in /usr/src/sys/sys/subr_log.c line 220
- in /usr/src/sys/sys/sys_inode.c line 715
- in /usr/src/sys/sys/tty.c line 337, 562, 732-733(2), 887, 915, 1162, 1238, 1352, 1693
- in /usr/src/sys/sys/tty_pty.c line 116

issignal defined in line 397; used 1 times

- in /usr/src/sys/h/signalvar.h line 66

kill defined in line 85; used 2 times

- in /usr/src/sys/sys/init_sysent.c line 34, 147

killpg defined in line 135; used 2 times

- in /usr/src/sys/sys/init_sysent.c line 34, 256

killpg1 defined in line 152; used 4 times

- in line 122-128(3), 147

postsig defined in line 556; used 2 times

- in /usr/src/sys/pdp/trap.c line 302, 377

psignal defined in line 207; used 26 times

- in line 117, 177, 199, 311, 436, 501
- in /usr/src/sys/pdp/trap.c line 299, 399
- in /usr/src/sys/pdpuba/dr.c line 178, 303
- in /usr/src/sys/sys/kern_clock.c line 81, 107, 114
- in /usr/src/sys/sys/kern_exec.c line 611
- in /usr/src/sys/sys/kern_exit.c line 140-143(3), 152
- in /usr/src/sys/sys/kern_sig2.c line 184
- in /usr/src/sys/sys/kern_synch.c line 49
- in /usr/src/sys/sys/subr_log.c line 222
- in /usr/src/sys/sys/sys_inode.c line 191
- in /usr/src/sys/sys/sys_kern.c line 39
- in /usr/src/sys/sys/sys_pipe.c line 182
- in /usr/src/sys/sys/vm_swp.c line 86
- in /usr/src/sys/sys/vm_text.c line 186

sigstack defined in line 58; used 2 times

- in /usr/src/sys/sys/init_sysent.c line 32, 222

stop defined in line 542; used 4 times

- in line 312, 438, 502
- in /usr/src/sys/sys/kern_sig2.c line 62

#### Defined struct's

a defined in line 137; used 6 times

- in line 64(2), 90(2), 140(2)

Last modified: 2000-02-21 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1605 |