Return to fullwait.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ingres / source / gutil

Annotation of 42BSD/ingres/source/gutil/fullwait.c, revision 1.1.1.1

1.1       root        1: # include      <errno.h>
                      2: # include      <sccs.h>
                      3: 
                      4: SCCSID(@(#)fullwait.c  7.1     2/5/81)
                      5: 
                      6: /*
                      7: **  FULLWAIT -- performs a wait(II) primitive for a given child.
                      8: **
                      9: **     The wait primitive is executed as many times as needed to get
                     10: **     termination status for a given child.  The case of an interrupt
                     11: **     during the wait is handled.  No other children may die during
                     12: **     the wait.  Also, the child must die "normally", that is, as the
                     13: **     result of an exit() system call, or from an interrupt.
                     14: **
                     15: **     Parameters:
                     16: **             "child" -- the pid of the child process to wait for,
                     17: **                     returned from the fork() system call.
                     18: **             "name" -- a character string representing the name of
                     19: **                     the calling routine; printed on syserr's.
                     20: **     Returns:
                     21: **             The exit parameter of the child process.
                     22: */
                     23: 
                     24: fullwait(child, name)
                     25: int    child;
                     26: char   *name;
                     27: {
                     28:        auto int        st;
                     29:        register int    i;
                     30:        extern int      errno;
                     31:        register char   *n;
                     32:        register char   *coredump;
                     33: 
                     34:        n = name;
                     35: 
                     36:        /* wait for a child to die */
                     37:        while ((i = wait(&st)) != child)
                     38:        {
                     39:                /* it is not the child we want; chew on it a little more */
                     40:                if (i != -1)
                     41:                        syserr("%s: bad child: pid %d st 0%o", n, i, st);
                     42: 
                     43:                /* check for interrupted system call */
                     44:                if (errno != EINTR)
                     45:                {
                     46:                        /* wait with no child */
                     47:                        syserr("%s: no child", n);
                     48:                }
                     49:                errno = 0;
                     50: 
                     51:                /* dropped out from signal: reexecute the wait */
                     52:        }
                     53: 
                     54:        /* check termination status */
                     55:        i = st & 0377;
                     56:        if (i > 2)
                     57:        {
                     58:                /* child collapsed */
                     59:                if (i & 0200)
                     60:                {
                     61:                        coredump = " -- core dumped";
                     62:                        i &= 0177;
                     63:                }
                     64:                else
                     65:                {
                     66:                        coredump = "";
                     67:                }
                     68:                syserr("%s: stat %d%s", n, i, coredump);
                     69:        }
                     70: 
                     71:        /* return exit status */
                     72:        return (st >> 8);
                     73: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.