878 lines
23 KiB
C
878 lines
23 KiB
C
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "primpl.h"
|
|
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <sys/wait.h>
|
|
#include <string.h>
|
|
#if defined(AIX)
|
|
#include <dlfcn.h> /* For dlopen, dlsym, dlclose */
|
|
#endif
|
|
|
|
#if defined(DARWIN)
|
|
#if defined(HAVE_CRT_EXTERNS_H)
|
|
#include <crt_externs.h>
|
|
#endif
|
|
#else
|
|
PR_IMPORT_DATA(char **) environ;
|
|
#endif
|
|
|
|
/*
|
|
* HP-UX 9 doesn't have the SA_RESTART flag.
|
|
*/
|
|
#ifndef SA_RESTART
|
|
#define SA_RESTART 0
|
|
#endif
|
|
|
|
/*
|
|
**********************************************************************
|
|
*
|
|
* The Unix process routines
|
|
*
|
|
**********************************************************************
|
|
*/
|
|
|
|
#define _PR_SIGNALED_EXITSTATUS 256
|
|
|
|
typedef enum pr_PidState {
|
|
_PR_PID_DETACHED,
|
|
_PR_PID_REAPED,
|
|
_PR_PID_WAITING
|
|
} pr_PidState;
|
|
|
|
typedef struct pr_PidRecord {
|
|
pid_t pid;
|
|
int exitStatus;
|
|
pr_PidState state;
|
|
PRCondVar *reapedCV;
|
|
struct pr_PidRecord *next;
|
|
} pr_PidRecord;
|
|
|
|
/*
|
|
* LinuxThreads are actually a kind of processes
|
|
* that can share the virtual address space and file descriptors.
|
|
*/
|
|
#if ((defined(LINUX) || defined(__GNU__) || defined(__GLIBC__)) \
|
|
&& defined(_PR_PTHREADS))
|
|
#define _PR_SHARE_CLONES
|
|
#endif
|
|
|
|
/*
|
|
* The macro _PR_NATIVE_THREADS indicates that we are
|
|
* using native threads only, so waitpid() blocks just the
|
|
* calling thread, not the process. In this case, the waitpid
|
|
* daemon thread can safely block in waitpid(). So we don't
|
|
* need to catch SIGCHLD, and the pipe to unblock PR_Poll() is
|
|
* also not necessary.
|
|
*/
|
|
|
|
#if defined(_PR_GLOBAL_THREADS_ONLY) \
|
|
|| (defined(_PR_PTHREADS) \
|
|
&& !defined(LINUX) && !defined(__GNU__) && !defined(__GLIBC__))
|
|
#define _PR_NATIVE_THREADS
|
|
#endif
|
|
|
|
/*
|
|
* All the static variables used by the Unix process routines are
|
|
* collected in this structure.
|
|
*/
|
|
|
|
static struct {
|
|
PRCallOnceType once;
|
|
PRThread *thread;
|
|
PRLock *ml;
|
|
#if defined(_PR_NATIVE_THREADS)
|
|
PRInt32 numProcs;
|
|
PRCondVar *cv;
|
|
#else
|
|
int pipefd[2];
|
|
#endif
|
|
pr_PidRecord **pidTable;
|
|
|
|
#ifdef _PR_SHARE_CLONES
|
|
struct pr_CreateProcOp *opHead, *opTail;
|
|
#endif
|
|
|
|
#ifdef AIX
|
|
pid_t (*forkptr)(void); /* Newer versions of AIX (starting in 4.3.2)
|
|
* have f_fork, which is faster than the
|
|
* regular fork in a multithreaded process
|
|
* because it skips calling the fork handlers.
|
|
* So we look up the f_fork symbol to see if
|
|
* it's available and fall back on fork.
|
|
*/
|
|
#endif /* AIX */
|
|
} pr_wp;
|
|
|
|
#ifdef _PR_SHARE_CLONES
|
|
static int pr_waitpid_daemon_exit;
|
|
|
|
void
|
|
_MD_unix_terminate_waitpid_daemon(void)
|
|
{
|
|
if (pr_wp.thread) {
|
|
pr_waitpid_daemon_exit = 1;
|
|
write(pr_wp.pipefd[1], "", 1);
|
|
PR_JoinThread(pr_wp.thread);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static PRStatus _MD_InitProcesses(void);
|
|
#if !defined(_PR_NATIVE_THREADS)
|
|
static void pr_InstallSigchldHandler(void);
|
|
#endif
|
|
|
|
static PRProcess *
|
|
ForkAndExec(
|
|
const char *path,
|
|
char *const *argv,
|
|
char *const *envp,
|
|
const PRProcessAttr *attr)
|
|
{
|
|
PRProcess *process;
|
|
int nEnv, idx;
|
|
char *const *childEnvp;
|
|
char **newEnvp = NULL;
|
|
int flags;
|
|
|
|
process = PR_NEW(PRProcess);
|
|
if (!process) {
|
|
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
|
|
return NULL;
|
|
}
|
|
|
|
childEnvp = envp;
|
|
if (attr && attr->fdInheritBuffer) {
|
|
PRBool found = PR_FALSE;
|
|
|
|
if (NULL == childEnvp) {
|
|
#ifdef DARWIN
|
|
#ifdef HAVE_CRT_EXTERNS_H
|
|
childEnvp = *(_NSGetEnviron());
|
|
#else
|
|
/* _NSGetEnviron() is not available on iOS. */
|
|
PR_DELETE(process);
|
|
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
|
|
return NULL;
|
|
#endif
|
|
#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];
|
|
if (!found && !strncmp(newEnvp[idx], "NSPR_INHERIT_FDS=", 17)) {
|
|
newEnvp[idx] = attr->fdInheritBuffer;
|
|
found = PR_TRUE;
|
|
}
|
|
}
|
|
if (!found) {
|
|
newEnvp[idx++] = attr->fdInheritBuffer;
|
|
}
|
|
newEnvp[idx] = NULL;
|
|
childEnvp = newEnvp;
|
|
}
|
|
|
|
#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;
|
|
}
|
|
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)
|
|
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 */
|
|
}
|
|
}
|
|
}
|
|
|
|
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. */
|
|
_exit(1);
|
|
#endif /* !NTO */
|
|
}
|
|
|
|
if (newEnvp) {
|
|
PR_DELETE(newEnvp);
|
|
}
|
|
|
|
#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;
|
|
}
|
|
|
|
#ifdef _PR_SHARE_CLONES
|
|
|
|
struct pr_CreateProcOp {
|
|
const char *path;
|
|
char *const *argv;
|
|
char *const *envp;
|
|
const PRProcessAttr *attr;
|
|
PRProcess *process;
|
|
PRErrorCode prerror;
|
|
PRInt32 oserror;
|
|
PRBool done;
|
|
PRCondVar *doneCV;
|
|
struct pr_CreateProcOp *next;
|
|
};
|
|
|
|
PRProcess *
|
|
_MD_CreateUnixProcess(
|
|
const char *path,
|
|
char *const *argv,
|
|
char *const *envp,
|
|
const PRProcessAttr *attr)
|
|
{
|
|
struct pr_CreateProcOp *op;
|
|
PRProcess *proc;
|
|
int rv;
|
|
|
|
if (PR_CallOnce(&pr_wp.once, _MD_InitProcesses) == PR_FAILURE) {
|
|
return NULL;
|
|
}
|
|
|
|
op = PR_NEW(struct pr_CreateProcOp);
|
|
if (NULL == op) {
|
|
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
|
|
return NULL;
|
|
}
|
|
op->path = path;
|
|
op->argv = argv;
|
|
op->envp = envp;
|
|
op->attr = attr;
|
|
op->done = PR_FALSE;
|
|
op->doneCV = PR_NewCondVar(pr_wp.ml);
|
|
if (NULL == op->doneCV) {
|
|
PR_DELETE(op);
|
|
return NULL;
|
|
}
|
|
PR_Lock(pr_wp.ml);
|
|
|
|
/* add to the tail of op queue */
|
|
op->next = NULL;
|
|
if (pr_wp.opTail) {
|
|
pr_wp.opTail->next = op;
|
|
pr_wp.opTail = op;
|
|
} else {
|
|
PR_ASSERT(NULL == pr_wp.opHead);
|
|
pr_wp.opHead = pr_wp.opTail = op;
|
|
}
|
|
|
|
/* wake up the daemon thread */
|
|
do {
|
|
rv = write(pr_wp.pipefd[1], "", 1);
|
|
} while (-1 == rv && EINTR == errno);
|
|
|
|
while (op->done == PR_FALSE) {
|
|
PR_WaitCondVar(op->doneCV, PR_INTERVAL_NO_TIMEOUT);
|
|
}
|
|
PR_Unlock(pr_wp.ml);
|
|
PR_DestroyCondVar(op->doneCV);
|
|
proc = op->process;
|
|
if (!proc) {
|
|
PR_SetError(op->prerror, op->oserror);
|
|
}
|
|
PR_DELETE(op);
|
|
return proc;
|
|
}
|
|
|
|
#else /* ! _PR_SHARE_CLONES */
|
|
|
|
PRProcess *
|
|
_MD_CreateUnixProcess(
|
|
const char *path,
|
|
char *const *argv,
|
|
char *const *envp,
|
|
const PRProcessAttr *attr)
|
|
{
|
|
if (PR_CallOnce(&pr_wp.once, _MD_InitProcesses) == PR_FAILURE) {
|
|
return NULL;
|
|
}
|
|
return ForkAndExec(path, argv, envp, attr);
|
|
} /* _MD_CreateUnixProcess */
|
|
|
|
#endif /* _PR_SHARE_CLONES */
|
|
|
|
/*
|
|
* The pid table is a hashtable.
|
|
*
|
|
* The number of buckets in the hashtable (NBUCKETS) must be a power of 2.
|
|
*/
|
|
#define NBUCKETS_LOG2 6
|
|
#define NBUCKETS (1 << NBUCKETS_LOG2)
|
|
#define PID_HASH_MASK ((pid_t) (NBUCKETS - 1))
|
|
|
|
static pr_PidRecord *
|
|
FindPidTable(pid_t pid)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void
|
|
InsertPidTable(pr_PidRecord *pRec)
|
|
{
|
|
int keyHash = (int) (pRec->pid & PID_HASH_MASK);
|
|
|
|
pRec->next = pr_wp.pidTable[keyHash];
|
|
pr_wp.pidTable[keyHash] = pRec;
|
|
}
|
|
|
|
static void
|
|
DeletePidTable(pr_PidRecord *pRec)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
static int
|
|
ExtractExitStatus(int rawExitStatus)
|
|
{
|
|
/*
|
|
* 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);
|
|
}
|
|
PR_ASSERT(WIFSIGNALED(rawExitStatus));
|
|
return _PR_SIGNALED_EXITSTATUS;
|
|
}
|
|
|
|
static void
|
|
ProcessReapedChildInternal(pid_t pid, int status)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(_PR_NATIVE_THREADS)
|
|
|
|
/*
|
|
* If all the threads are native threads, the daemon thread is
|
|
* simpler. We don't need to catch the SIGCHLD signal. We can
|
|
* just have the daemon thread block in waitpid().
|
|
*/
|
|
|
|
static void WaitPidDaemonThread(void *unused)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
|
|
while (1) {
|
|
PR_Lock(pr_wp.ml);
|
|
while (0 == pr_wp.numProcs) {
|
|
PR_WaitCondVar(pr_wp.cv, PR_INTERVAL_NO_TIMEOUT);
|
|
}
|
|
PR_Unlock(pr_wp.ml);
|
|
|
|
while (1) {
|
|
do {
|
|
pid = waitpid((pid_t) -1, &status, 0);
|
|
} while ((pid_t) -1 == pid && EINTR == errno);
|
|
|
|
/*
|
|
* waitpid() cannot return 0 because we did not invoke it
|
|
* with the WNOHANG option.
|
|
*/
|
|
PR_ASSERT(0 != pid);
|
|
|
|
/*
|
|
* The only possible error code is ECHILD. But if we do
|
|
* our accounting correctly, we should only call waitpid()
|
|
* when there is a child process to wait for.
|
|
*/
|
|
PR_ASSERT((pid_t) -1 != pid);
|
|
if ((pid_t) -1 == pid) {
|
|
break;
|
|
}
|
|
|
|
PR_Lock(pr_wp.ml);
|
|
ProcessReapedChildInternal(pid, status);
|
|
pr_wp.numProcs--;
|
|
while (0 == pr_wp.numProcs) {
|
|
PR_WaitCondVar(pr_wp.cv, PR_INTERVAL_NO_TIMEOUT);
|
|
}
|
|
PR_Unlock(pr_wp.ml);
|
|
}
|
|
}
|
|
}
|
|
|
|
#else /* _PR_NATIVE_THREADS */
|
|
|
|
static void WaitPidDaemonThread(void *unused)
|
|
{
|
|
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
|
|
while ((op = pr_wp.opHead) != NULL) {
|
|
PR_Unlock(pr_wp.ml);
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void pr_SigchldHandler(int sig)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void pr_InstallSigchldHandler()
|
|
{
|
|
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
|
|
}
|
|
|
|
#endif /* !defined(_PR_NATIVE_THREADS) */
|
|
|
|
static PRStatus _MD_InitProcesses(void)
|
|
{
|
|
#if !defined(_PR_NATIVE_THREADS)
|
|
int rv;
|
|
int flags;
|
|
#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(_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 | O_NONBLOCK);
|
|
flags = fcntl(pr_wp.pipefd[1], F_GETFL, 0);
|
|
fcntl(pr_wp.pipefd[1], F_SETFL, flags | O_NONBLOCK);
|
|
|
|
#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;
|
|
}
|
|
|
|
PRStatus _MD_DetachUnixProcess(PRProcess *process)
|
|
{
|
|
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;
|
|
}
|
|
|
|
PRStatus _MD_WaitUnixProcess(
|
|
PRProcess *process,
|
|
PRInt32 *exitCode)
|
|
{
|
|
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 */
|
|
|
|
PRStatus _MD_KillUnixProcess(PRProcess *process)
|
|
{
|
|
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 */
|