Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Functions | Variables
uxproces.c File Reference
#include "primpl.h"
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/wait.h>

Go to the source code of this file.

Classes

struct  pr_PidRecord

Defines

#define SA_RESTART   0
#define _PR_SIGNALED_EXITSTATUS   256
#define NBUCKETS_LOG2   6
#define NBUCKETS   (1 << NBUCKETS_LOG2)
#define PID_HASH_MASK   ((pid_t) (NBUCKETS - 1))
#define _PR_NBIO_FLAG   O_NONBLOCK

Typedefs

typedef struct pr_PidRecord pr_PidRecord

Functions

 PR_IMPORT_DATA (char **)
static PRStatus _MD_InitProcesses (void)
static void pr_InstallSigchldHandler (void)
static PRProcessForkAndExec (const char *path, char *const *argv, char *const *envp, const PRProcessAttr *attr)
PRProcess_MD_CreateUnixProcess (const char *path, char *const *argv, char *const *envp, const PRProcessAttr *attr)
static pr_PidRecordFindPidTable (pid_t pid)
static void InsertPidTable (pr_PidRecord *pRec)
static void DeletePidTable (pr_PidRecord *pRec)
static int ExtractExitStatus (int rawExitStatus)
static void ProcessReapedChildInternal (pid_t pid, int status)
static void WaitPidDaemonThread (void *unused)
static void pr_SigchldHandler (int sig)
PRStatus _MD_DetachUnixProcess (PRProcess *process)
PRStatus _MD_WaitUnixProcess (PRProcess *process, PRInt32 *exitCode)
PRStatus _MD_KillUnixProcess (PRProcess *process)

Variables

 pr_PidState
struct {
PRCallOnceType once
PRThreadthread
PRLockml
int pipefd [2]
pr_PidRecord ** pidTable
pr_wp

Class Documentation

struct pr_PidRecord

Definition at line 82 of file uxproces.c.

Collaboration diagram for pr_PidRecord:
Class Members
int exitStatus
struct pr_PidRecord * next
pid_t pid
PRCondVar * reapedCV
pr_PidState state

Define Documentation

Definition at line 536 of file uxproces.c.

Definition at line 535 of file uxproces.c.

Definition at line 537 of file uxproces.c.

#define SA_RESTART   0

Typedef Documentation

typedef struct pr_PidRecord pr_PidRecord

Function Documentation

PRProcess* _MD_CreateUnixProcess ( const char *  path,
char *const argv,
char *const envp,
const PRProcessAttr attr 
)

Definition at line 516 of file uxproces.c.

{
    if (PR_CallOnce(&pr_wp.once, _MD_InitProcesses) == PR_FAILURE) {
       return NULL;
    }
    return ForkAndExec(path, argv, envp, attr);
}  /* _MD_CreateUnixProcess */

Here is the call graph for this function:

Definition at line 871 of file uxproces.c.

{
    PRStatus retVal = PR_SUCCESS;
    pr_PidRecord *pRec;

    PR_Lock(pr_wp.ml);
    pRec = FindPidTable(process->md.pid);
    if (NULL == pRec) {
       pRec = PR_NEW(pr_PidRecord);
       if (NULL == pRec) {
           PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
           retVal = PR_FAILURE;
           goto done;
       }
       pRec->pid = process->md.pid;
       pRec->state = _PR_PID_DETACHED;
       pRec->reapedCV = NULL;
       InsertPidTable(pRec);
    } else {
       PR_ASSERT(_PR_PID_REAPED == pRec->state);
       if (_PR_PID_REAPED != pRec->state) {
           PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
           retVal = PR_FAILURE;
       } else {
           DeletePidTable(pRec);
           PR_ASSERT(NULL == pRec->reapedCV);
           PR_DELETE(pRec);
       }
    }
    PR_DELETE(process);

done:
    PR_Unlock(pr_wp.ml);
    return retVal;
}

Here is the call graph for this function:

static PRStatus _MD_InitProcesses ( void  ) [static]

Definition at line 808 of file uxproces.c.

{
#if !defined(_PR_NATIVE_THREADS)
    int rv;
    int flags;
#endif
#ifdef SUNOS4
#define _PR_NBIO_FLAG FNDELAY
#else
#define _PR_NBIO_FLAG O_NONBLOCK
#endif

#ifdef AIX
    {
        void *handle = dlopen(NULL, RTLD_NOW | RTLD_GLOBAL);
        pr_wp.forkptr = (pid_t (*)(void)) dlsym(handle, "f_fork");
        if (!pr_wp.forkptr) {
            pr_wp.forkptr = fork;
        }
        dlclose(handle);
    }
#endif /* AIX */

    pr_wp.ml = PR_NewLock();
    PR_ASSERT(NULL != pr_wp.ml);

#if defined(VMS)
    _pr_vms_fork_lock = PR_NewLock();
    PR_ASSERT(NULL != _pr_vms_fork_lock);
#endif

#if defined(_PR_NATIVE_THREADS)
    pr_wp.numProcs = 0;
    pr_wp.cv = PR_NewCondVar(pr_wp.ml);
    PR_ASSERT(NULL != pr_wp.cv);
#else
    rv = pipe(pr_wp.pipefd);
    PR_ASSERT(0 == rv);
    flags = fcntl(pr_wp.pipefd[0], F_GETFL, 0);
    fcntl(pr_wp.pipefd[0], F_SETFL, flags | _PR_NBIO_FLAG);
    flags = fcntl(pr_wp.pipefd[1], F_GETFL, 0);
    fcntl(pr_wp.pipefd[1], F_SETFL, flags | _PR_NBIO_FLAG);

#ifndef _PR_SHARE_CLONES
    pr_InstallSigchldHandler();
#endif
#endif  /* !_PR_NATIVE_THREADS */

    pr_wp.thread = PR_CreateThread(PR_SYSTEM_THREAD,
           WaitPidDaemonThread, NULL, PR_PRIORITY_NORMAL,
#ifdef _PR_SHARE_CLONES
            PR_GLOBAL_THREAD,
#else
           PR_LOCAL_THREAD,
#endif
           PR_JOINABLE_THREAD, 0);
    PR_ASSERT(NULL != pr_wp.thread);

    pr_wp.pidTable = (pr_PidRecord**)PR_CALLOC(NBUCKETS * sizeof(pr_PidRecord *));
    PR_ASSERT(NULL != pr_wp.pidTable);
    return PR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 967 of file uxproces.c.

{
    PRErrorCode prerror;
    PRInt32 oserror;

    if (kill(process->md.pid, SIGKILL) == 0) {
       return PR_SUCCESS;
    }
    oserror = errno;
    switch (oserror) {
        case EPERM:
           prerror = PR_NO_ACCESS_RIGHTS_ERROR;
           break;
        case ESRCH:
           prerror = PR_INVALID_ARGUMENT_ERROR;
           break;
        default:
           prerror = PR_UNKNOWN_ERROR;
           break;
    }
    PR_SetError(prerror, oserror);
    return PR_FAILURE;
}  /* _MD_KillUnixProcess */
PRStatus _MD_WaitUnixProcess ( PRProcess process,
PRInt32 exitCode 
)

Definition at line 907 of file uxproces.c.

{
    pr_PidRecord *pRec;
    PRStatus retVal = PR_SUCCESS;
    PRBool interrupted = PR_FALSE;

    PR_Lock(pr_wp.ml);
    pRec = FindPidTable(process->md.pid);
    if (NULL == pRec) {
       pRec = PR_NEW(pr_PidRecord);
       if (NULL == pRec) {
           PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
           retVal = PR_FAILURE;
           goto done;
       }
       pRec->pid = process->md.pid;
       pRec->state = _PR_PID_WAITING;
       pRec->reapedCV = PR_NewCondVar(pr_wp.ml);
       if (NULL == pRec->reapedCV) {
           PR_DELETE(pRec);
           retVal = PR_FAILURE;
           goto done;
       }
       InsertPidTable(pRec);
       while (!interrupted && _PR_PID_REAPED != pRec->state) {
           if (PR_WaitCondVar(pRec->reapedCV,
                  PR_INTERVAL_NO_TIMEOUT) == PR_FAILURE
                  && PR_GetError() == PR_PENDING_INTERRUPT_ERROR) {
              interrupted = PR_TRUE;
            }
       }
       if (_PR_PID_REAPED == pRec->state) {
            if (exitCode) {
                *exitCode = pRec->exitStatus;
            }
       } else {
           PR_ASSERT(interrupted);
           retVal = PR_FAILURE;
       }
       DeletePidTable(pRec);
       PR_DestroyCondVar(pRec->reapedCV);
       PR_DELETE(pRec);
    } else {
       PR_ASSERT(_PR_PID_REAPED == pRec->state);
       PR_ASSERT(NULL == pRec->reapedCV);
       DeletePidTable(pRec);
        if (exitCode) {
            *exitCode = pRec->exitStatus;
        }
       PR_DELETE(pRec);
    }
    PR_DELETE(process);

done:
    PR_Unlock(pr_wp.ml);
    return retVal;
}  /* _MD_WaitUnixProcess */

Here is the call graph for this function:

static void DeletePidTable ( pr_PidRecord pRec) [static]

Definition at line 565 of file uxproces.c.

{
    int keyHash = (int) (pRec->pid & PID_HASH_MASK);

    if (pr_wp.pidTable[keyHash] == pRec) {
       pr_wp.pidTable[keyHash] = pRec->next;
    } else {
       pr_PidRecord *pred, *cur;  /* predecessor and current */

       pred = pr_wp.pidTable[keyHash];
       cur = pred->next;
       while (cur) {
           if (cur == pRec) {
              pred->next = cur->next;
              break;
            }
           pred = cur;
           cur = cur->next;
        }
       PR_ASSERT(cur != NULL);
    }
}

Here is the caller graph for this function:

static int ExtractExitStatus ( int  rawExitStatus) [static]

Definition at line 589 of file uxproces.c.

{
    /*
     * We did not specify the WCONTINUED and WUNTRACED options
     * for waitpid, so these two events should not be reported.
     */
    PR_ASSERT(!WIFSTOPPED(rawExitStatus));
#ifdef WIFCONTINUED
    PR_ASSERT(!WIFCONTINUED(rawExitStatus));
#endif
    if (WIFEXITED(rawExitStatus)) {
       return WEXITSTATUS(rawExitStatus);
    } else {
       PR_ASSERT(WIFSIGNALED(rawExitStatus));
       return _PR_SIGNALED_EXITSTATUS;
    }
}

Here is the caller graph for this function:

static pr_PidRecord* FindPidTable ( pid_t  pid) [static]

Definition at line 540 of file uxproces.c.

{
    pr_PidRecord *pRec;
    int keyHash = (int) (pid & PID_HASH_MASK);

    pRec =  pr_wp.pidTable[keyHash];
    while (pRec) {
       if (pRec->pid == pid) {
           break;
       }
       pRec = pRec->next;
    }
    return pRec;
}

Here is the caller graph for this function:

static PRProcess* ForkAndExec ( const char *  path,
char *const argv,
char *const envp,
const PRProcessAttr attr 
) [static]

Definition at line 165 of file uxproces.c.

{
    PRProcess *process;
    int nEnv, idx;
    char *const *childEnvp;
    char **newEnvp = NULL;
    int flags;
#ifdef VMS
    char VMScurdir[FILENAME_MAX+1] = { '\0' } ;
#endif 

    process = PR_NEW(PRProcess);
    if (!process) {
        PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
        return NULL;
    }

    childEnvp = envp;
    if (attr && attr->fdInheritBuffer) {
        if (NULL == childEnvp) {
#ifdef DARWIN
            childEnvp = *(_NSGetEnviron());
#else
            childEnvp = environ;
#endif
        }
        for (nEnv = 0; childEnvp[nEnv]; nEnv++) {
        }
        newEnvp = (char **) PR_MALLOC((nEnv + 2) * sizeof(char *));
        if (NULL == newEnvp) {
            PR_DELETE(process);
            PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
            return NULL;
        }
        for (idx = 0; idx < nEnv; idx++) {
            newEnvp[idx] = childEnvp[idx];
        }
        newEnvp[idx++] = attr->fdInheritBuffer;
        newEnvp[idx] = NULL;
        childEnvp = newEnvp;
    }

#ifdef VMS
/*
** Since vfork/exec is implemented VERY differently on OpenVMS, we have to
** handle the setting up of the standard streams very differently. And since
** none of this code can ever execute in the context of the child, we have
** to perform the chdir in the parent so the child is born into the correct
** directory (and then switch the parent back again).
*/
{
    int decc$set_child_standard_streams(int,int,int);
    int n, fd_stdin=0, fd_stdout=1, fd_stderr=2;

    /* Set up any standard streams we are given, assuming defaults */
    if (attr) {
       if (attr->stdinFd)
           fd_stdin = attr->stdinFd->secret->md.osfd;
       if (attr->stdoutFd)
           fd_stdout = attr->stdoutFd->secret->md.osfd;
       if (attr->stderrFd)
           fd_stderr = attr->stderrFd->secret->md.osfd;
    }

    /*
    ** Put a lock around anything that isn't going to be thread-safe.
    */
    PR_Lock(_pr_vms_fork_lock);

    /*
    ** Prepare the child's streams. We always do this in case a previous fork
    ** has left the stream assignments in some non-standard way.
    */
    n = decc$set_child_standard_streams(fd_stdin,fd_stdout,fd_stderr);
    if (n == -1) {
       PR_SetError(PR_BAD_DESCRIPTOR_ERROR, errno);
       PR_DELETE(process);
       if (newEnvp) {
           PR_DELETE(newEnvp);
       }
       PR_Unlock(_pr_vms_fork_lock);
       return NULL;
    }

    /* Switch directory if we have to */
    if (attr) {
       if (attr->currentDirectory) {
           if ( (getcwd(VMScurdir,sizeof(VMScurdir)) == NULL) ||
                (chdir(attr->currentDirectory) < 0) ) {
               PR_SetError(PR_DIRECTORY_OPEN_ERROR, errno);
               PR_DELETE(process);
               if (newEnvp) {
                   PR_DELETE(newEnvp);
               }
               PR_Unlock(_pr_vms_fork_lock);
               return NULL;
           }
       }
    }
}
#endif /* VMS */

#ifdef AIX
    process->md.pid = (*pr_wp.forkptr)();
#elif defined(NTO)
    /*
     * fork() & exec() does not work in a multithreaded process.
     * Use spawn() instead.
     */
    {
        int fd_map[3] = { 0, 1, 2 };

        if (attr) {
            if (attr->stdinFd && attr->stdinFd->secret->md.osfd != 0) {
                fd_map[0] = dup(attr->stdinFd->secret->md.osfd);
                flags = fcntl(fd_map[0], F_GETFL, 0);
                if (flags & O_NONBLOCK)
                    fcntl(fd_map[0], F_SETFL, flags & ~O_NONBLOCK);
            }
            if (attr->stdoutFd && attr->stdoutFd->secret->md.osfd != 1) {
                fd_map[1] = dup(attr->stdoutFd->secret->md.osfd);
                flags = fcntl(fd_map[1], F_GETFL, 0);
                if (flags & O_NONBLOCK)
                    fcntl(fd_map[1], F_SETFL, flags & ~O_NONBLOCK);
            }
            if (attr->stderrFd && attr->stderrFd->secret->md.osfd != 2) {
                fd_map[2] = dup(attr->stderrFd->secret->md.osfd);
                flags = fcntl(fd_map[2], F_GETFL, 0);
                if (flags & O_NONBLOCK)
                    fcntl(fd_map[2], F_SETFL, flags & ~O_NONBLOCK);
            }

            PR_ASSERT(attr->currentDirectory == NULL);  /* not implemented */
        }

        process->md.pid = spawn(path, 3, fd_map, NULL, argv, childEnvp);

        if (fd_map[0] != 0)
            close(fd_map[0]);
        if (fd_map[1] != 1)
            close(fd_map[1]);
        if (fd_map[2] != 2)
            close(fd_map[2]);
    }
#else
    process->md.pid = fork();
#endif
    if ((pid_t) -1 == process->md.pid) {
        PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, errno);
        PR_DELETE(process);
        if (newEnvp) {
            PR_DELETE(newEnvp);
        }
        return NULL;
    } else if (0 == process->md.pid) {  /* the child process */
        /*
         * If the child process needs to exit, it must call _exit().
         * Do not call exit(), because exit() will flush and close
         * the standard I/O file descriptors, and hence corrupt
         * the parent process's standard I/O data structures.
         */

#if !defined(NTO)
#ifdef VMS
       /* OpenVMS has already handled all this above */
#else
        if (attr) {
            /* the osfd's to redirect stdin, stdout, and stderr to */
            int in_osfd = -1, out_osfd = -1, err_osfd = -1;

            if (attr->stdinFd
                    && attr->stdinFd->secret->md.osfd != 0) {
                in_osfd = attr->stdinFd->secret->md.osfd;
                if (dup2(in_osfd, 0) != 0) {
                    _exit(1);  /* failed */
                }
                flags = fcntl(0, F_GETFL, 0);
                if (flags & O_NONBLOCK) {
                    fcntl(0, F_SETFL, flags & ~O_NONBLOCK);
                }
            }
            if (attr->stdoutFd
                    && attr->stdoutFd->secret->md.osfd != 1) {
                out_osfd = attr->stdoutFd->secret->md.osfd;
                if (dup2(out_osfd, 1) != 1) {
                    _exit(1);  /* failed */
                }
                flags = fcntl(1, F_GETFL, 0);
                if (flags & O_NONBLOCK) {
                    fcntl(1, F_SETFL, flags & ~O_NONBLOCK);
                }
            }
            if (attr->stderrFd
                    && attr->stderrFd->secret->md.osfd != 2) {
                err_osfd = attr->stderrFd->secret->md.osfd;
                if (dup2(err_osfd, 2) != 2) {
                    _exit(1);  /* failed */
                }
                flags = fcntl(2, F_GETFL, 0);
                if (flags & O_NONBLOCK) {
                    fcntl(2, F_SETFL, flags & ~O_NONBLOCK);
                }
            }
            if (in_osfd != -1) {
                close(in_osfd);
            }
            if (out_osfd != -1 && out_osfd != in_osfd) {
                close(out_osfd);
            }
            if (err_osfd != -1 && err_osfd != in_osfd
                    && err_osfd != out_osfd) {
                close(err_osfd);
            }
            if (attr->currentDirectory) {
                if (chdir(attr->currentDirectory) < 0) {
                    _exit(1);  /* failed */
                }
            }
        }
#endif /* !VMS */

        if (childEnvp) {
            (void)execve(path, argv, childEnvp);
        } else {
            /* Inherit the environment of the parent. */
            (void)execv(path, argv);
        }
        /* Whoops! It returned. That's a bad sign. */
#ifdef VMS
       /*
       ** On OpenVMS we are still in the context of the parent, and so we
       ** can (and should!) perform normal error handling.
       */
       PR_SetError(PR_UNKNOWN_ERROR, errno);
       PR_DELETE(process);
       if (newEnvp) {
           PR_DELETE(newEnvp);
       }
       if (VMScurdir[0] != '\0')
           chdir(VMScurdir);
       PR_Unlock(_pr_vms_fork_lock);
       return NULL;
#else
        _exit(1);
#endif /* VMS */
#endif /* !NTO */
    }

    if (newEnvp) {
        PR_DELETE(newEnvp);
    }
#ifdef VMS
    /* If we switched directories, then remember to switch back */
    if (VMScurdir[0] != '\0') {
       chdir(VMScurdir); /* can't do much if it fails */
    }
    PR_Unlock(_pr_vms_fork_lock);
#endif /* VMS */

#if defined(_PR_NATIVE_THREADS)
    PR_Lock(pr_wp.ml);
    if (0 == pr_wp.numProcs++) {
        PR_NotifyCondVar(pr_wp.cv);
    }
    PR_Unlock(pr_wp.ml);
#endif
    return process;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void InsertPidTable ( pr_PidRecord pRec) [static]

Definition at line 556 of file uxproces.c.

{
    int keyHash = (int) (pRec->pid & PID_HASH_MASK);

    pRec->next = pr_wp.pidTable[keyHash];
    pr_wp.pidTable[keyHash] = pRec;
}

Here is the caller graph for this function:

PR_IMPORT_DATA ( char **  )

Definition at line 52 of file uxproces.c.

                         {
    _PR_PID_DETACHED,
    _PR_PID_REAPED,
    _PR_PID_WAITING
} pr_PidState;

Here is the caller graph for this function:

static void pr_InstallSigchldHandler ( void  ) [static]

Definition at line 786 of file uxproces.c.

{
#if defined(HPUX) && defined(_PR_DCETHREADS)
#error "HP-UX DCE threads have their own SIGCHLD handler"
#endif

    struct sigaction act, oact;
    int rv;

    act.sa_handler = pr_SigchldHandler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_NOCLDSTOP | SA_RESTART;
    rv = sigaction(SIGCHLD, &act, &oact);
    PR_ASSERT(0 == rv);
    /* Make sure we are not overriding someone else's SIGCHLD handler */
#ifndef _PR_SHARE_CLONES
    PR_ASSERT(oact.sa_handler == SIG_DFL);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pr_SigchldHandler ( int  sig) [static]

Definition at line 764 of file uxproces.c.

{
    int errnoCopy;
    int rv;

    errnoCopy = errno;

    do {
        rv = write(pr_wp.pipefd[1], "", 1);
    } while (-1 == rv && EINTR == errno);

#ifdef DEBUG
    if (-1 == rv && EAGAIN != errno && EWOULDBLOCK != errno) {
        char *msg = "cannot write to pipe\n";
        write(2, msg, strlen(msg) + 1);
        _exit(1);
    }
#endif

    errno = errnoCopy;
}

Here is the caller graph for this function:

static void ProcessReapedChildInternal ( pid_t  pid,
int  status 
) [static]

Definition at line 608 of file uxproces.c.

{
    pr_PidRecord *pRec;

    pRec = FindPidTable(pid);
    if (NULL == pRec) {
        pRec = PR_NEW(pr_PidRecord);
        pRec->pid = pid;
        pRec->state = _PR_PID_REAPED;
        pRec->exitStatus = ExtractExitStatus(status);
        pRec->reapedCV = NULL;
        InsertPidTable(pRec);
    } else {
        PR_ASSERT(pRec->state != _PR_PID_REAPED);
        if (_PR_PID_DETACHED == pRec->state) {
            PR_ASSERT(NULL == pRec->reapedCV);
            DeletePidTable(pRec);
            PR_DELETE(pRec);
        } else {
            PR_ASSERT(_PR_PID_WAITING == pRec->state);
            PR_ASSERT(NULL != pRec->reapedCV);
            pRec->exitStatus = ExtractExitStatus(status);
            pRec->state = _PR_PID_REAPED;
            PR_NotifyCondVar(pRec->reapedCV);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void WaitPidDaemonThread ( void unused) [static]

Definition at line 690 of file uxproces.c.

{
    PRPollDesc pd;
    PRFileDesc *fd;
    int rv;
    char buf[128];
    pid_t pid;
    int status;
#ifdef _PR_SHARE_CLONES
    struct pr_CreateProcOp *op;
#endif

#ifdef _PR_SHARE_CLONES
    pr_InstallSigchldHandler();
#endif

    fd = PR_ImportFile(pr_wp.pipefd[0]);
    PR_ASSERT(NULL != fd);
    pd.fd = fd;
    pd.in_flags = PR_POLL_READ;

    while (1) {
        rv = PR_Poll(&pd, 1, PR_INTERVAL_NO_TIMEOUT);
        PR_ASSERT(1 == rv);

#ifdef _PR_SHARE_CLONES
        if (pr_waitpid_daemon_exit) {
            return;
        }
       PR_Lock(pr_wp.ml);
#endif
           
        do {
            rv = read(pr_wp.pipefd[0], buf, sizeof(buf));
        } while (sizeof(buf) == rv || (-1 == rv && EINTR == errno));

#ifdef _PR_SHARE_CLONES
       PR_Unlock(pr_wp.ml);
       while ((op = pr_wp.opHead) != NULL) {
           op->process = ForkAndExec(op->path, op->argv,
                  op->envp, op->attr);
           if (NULL == op->process) {
              op->prerror = PR_GetError();
              op->oserror = PR_GetOSError();
           }
           PR_Lock(pr_wp.ml);
           pr_wp.opHead = op->next;
           if (NULL == pr_wp.opHead) {
              pr_wp.opTail = NULL;
           }
           op->done = PR_TRUE;
           PR_NotifyCondVar(op->doneCV);
           PR_Unlock(pr_wp.ml);
       }
#endif

       while (1) {
           do {
               pid = waitpid((pid_t) -1, &status, WNOHANG);
           } while ((pid_t) -1 == pid && EINTR == errno);
           if (0 == pid) break;
           if ((pid_t) -1 == pid) {
              /* must be because we have no child processes */
              PR_ASSERT(ECHILD == errno);
              break;
            }

           PR_Lock(pr_wp.ml);
            ProcessReapedChildInternal(pid, status);
           PR_Unlock(pr_wp.ml);
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 80 of file uxproces.c.

struct { ... } pr_wp [static]