Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "primpl.h"
#include <ctype.h>
#include <string.h>
PRLogModuleInfo* _pr_clock_lm;
PRLogModuleInfo* _pr_cmon_lm;
PRLogModuleInfo* _pr_io_lm;
PRLogModuleInfo* _pr_cvar_lm;
PRLogModuleInfo* _pr_mon_lm;
PRLogModuleInfo* _pr_linker_lm;
PRLogModuleInfo* _pr_sched_lm;
PRLogModuleInfo* _pr_thread_lm;
PRLogModuleInfo* _pr_gc_lm;
PRLogModuleInfo* _pr_shm_lm;
PRLogModuleInfo* _pr_shma_lm;
PRFileDesc* _pr_stdin;
PRFileDesc* _pr_stdout;
PRFileDesc* _pr_stderr;
#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)
PRCList _pr_active_local_threadQ =
PR_INIT_STATIC_CLIST(&_pr_active_local_threadQ);
PRCList _pr_active_global_threadQ =
PR_INIT_STATIC_CLIST(&_pr_active_global_threadQ);
_MDLock _pr_cpuLock; /* lock for the CPU Q */
PRCList _pr_cpuQ = PR_INIT_STATIC_CLIST(&_pr_cpuQ);
PRUint32 _pr_utid;
PRInt32 _pr_userActive;
PRInt32 _pr_systemActive;
PRUintn _pr_maxPTDs;
# ifdef _PR_LOCAL_THREADS_ONLY
struct _PRCPU* _pr_currentCPU;
PRThread* _pr_currentThread;
PRThread* _pr_lastThread;
PRInt32 _pr_intsOff;
# endif /* _PR_LOCAL_THREADS_ONLY */
/* Lock protecting all "termination" condition variables of all threads */
PRLock* _pr_terminationCVLock;
#endif /* !defined(_PR_PTHREADS) */
PRLock* _pr_sleeplock; /* used in PR_Sleep(), classic and pthreads */
static void _PR_InitCallOnce(void);
PRBool _pr_initialized = PR_FALSE;
PR_IMPLEMENT(PRBool) PR_VersionCheck(const char* importedVersion) {
/*
** This is the secret handshake algorithm.
**
** This release has a simple version compatibility
** check algorithm. This release is not backward
** compatible with previous major releases. It is
** not compatible with future major, minor, or
** patch releases.
*/
int vmajor = 0, vminor = 0, vpatch = 0;
const char* ptr = importedVersion;
while (isdigit(*ptr)) {
vmajor = 10 * vmajor + *ptr - '0';
ptr++;
}
if (*ptr == '.') {
ptr++;
while (isdigit(*ptr)) {
vminor = 10 * vminor + *ptr - '0';
ptr++;
}
if (*ptr == '.') {
ptr++;
while (isdigit(*ptr)) {
vpatch = 10 * vpatch + *ptr - '0';
ptr++;
}
}
}
if (vmajor != PR_VMAJOR) {
return PR_FALSE;
}
if (vmajor == PR_VMAJOR && vminor > PR_VMINOR) {
return PR_FALSE;
}
if (vmajor == PR_VMAJOR && vminor == PR_VMINOR && vpatch > PR_VPATCH) {
return PR_FALSE;
}
return PR_TRUE;
} /* PR_VersionCheck */
PR_IMPLEMENT(const char*) PR_GetVersion(void) { return PR_VERSION; }
PR_IMPLEMENT(PRBool) PR_Initialized(void) { return _pr_initialized; }
PRInt32 _native_threads_only = 0;
#ifdef WINNT
static void _pr_SetNativeThreadsOnlyMode(void) {
HMODULE mainExe;
PRBool* globalp;
char* envp;
mainExe = GetModuleHandle(NULL);
PR_ASSERT(NULL != mainExe);
globalp = (PRBool*)GetProcAddress(mainExe, "nspr_native_threads_only");
if (globalp) {
_native_threads_only = (*globalp != PR_FALSE);
} else if (envp = getenv("NSPR_NATIVE_THREADS_ONLY")) {
_native_threads_only = (atoi(envp) == 1);
}
}
#endif
static void _PR_InitStuff(void) {
if (_pr_initialized) {
return;
}
_pr_initialized = PR_TRUE;
#ifdef _PR_ZONE_ALLOCATOR
_PR_InitZones();
#endif
#ifdef WINNT
_pr_SetNativeThreadsOnlyMode();
#endif
(void)PR_GetPageSize();
_pr_clock_lm = PR_NewLogModule("clock");
_pr_cmon_lm = PR_NewLogModule("cmon");
_pr_io_lm = PR_NewLogModule("io");
_pr_mon_lm = PR_NewLogModule("mon");
_pr_linker_lm = PR_NewLogModule("linker");
_pr_cvar_lm = PR_NewLogModule("cvar");
_pr_sched_lm = PR_NewLogModule("sched");
_pr_thread_lm = PR_NewLogModule("thread");
_pr_gc_lm = PR_NewLogModule("gc");
_pr_shm_lm = PR_NewLogModule("shm");
_pr_shma_lm = PR_NewLogModule("shma");
/* NOTE: These init's cannot depend on _PR_MD_CURRENT_THREAD() */
_PR_MD_EARLY_INIT();
_PR_InitLocks();
_PR_InitAtomic();
_PR_InitSegs();
_PR_InitStacks();
_PR_InitTPD();
_PR_InitEnv();
_PR_InitLayerCache();
_PR_InitClock();
_pr_sleeplock = PR_NewLock();
PR_ASSERT(NULL != _pr_sleeplock);
_PR_InitThreads(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
#ifndef _PR_GLOBAL_THREADS_ONLY
_PR_InitCPUs();
#endif
/*
* XXX: call _PR_InitMem only on those platforms for which nspr implements
* malloc, for now.
*/
#ifdef _PR_OVERRIDE_MALLOC
_PR_InitMem();
#endif
_PR_InitCMon();
_PR_InitIO();
_PR_InitNet();
_PR_InitTime();
_PR_InitLog();
_PR_InitLinker();
_PR_InitCallOnce();
_PR_InitDtoa();
_PR_InitMW();
_PR_InitRWLocks();
nspr_InitializePRErrorTable();
_PR_MD_FINAL_INIT();
}
void _PR_ImplicitInitialization(void) {
_PR_InitStuff();
/* Enable interrupts */
#if !defined(_PR_PTHREADS) && !defined(_PR_GLOBAL_THREADS_ONLY)
_PR_MD_START_INTERRUPTS();
#endif
}
PR_IMPLEMENT(void) PR_DisableClockInterrupts(void) {
#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)
if (!_pr_initialized) {
_PR_InitStuff();
} else {
_PR_MD_DISABLE_CLOCK_INTERRUPTS();
}
#endif
}
PR_IMPLEMENT(void) PR_EnableClockInterrupts(void) {
#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)
if (!_pr_initialized) {
_PR_InitStuff();
}
_PR_MD_ENABLE_CLOCK_INTERRUPTS();
#endif
}
PR_IMPLEMENT(void) PR_BlockClockInterrupts(void) {
#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)
_PR_MD_BLOCK_CLOCK_INTERRUPTS();
#endif
}
PR_IMPLEMENT(void) PR_UnblockClockInterrupts(void) {
#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)
_PR_MD_UNBLOCK_CLOCK_INTERRUPTS();
#endif
}
PR_IMPLEMENT(void)
PR_Init(PRThreadType type, PRThreadPriority priority, PRUintn maxPTDs) {
_PR_ImplicitInitialization();
}
PR_IMPLEMENT(PRIntn)
PR_Initialize(PRPrimordialFn prmain, PRIntn argc, char** argv,
PRUintn maxPTDs) {
PRIntn rv;
_PR_ImplicitInitialization();
rv = prmain(argc, argv);
PR_Cleanup();
return rv;
} /* PR_Initialize */
/*
*-----------------------------------------------------------------------
*
* _PR_CleanupBeforeExit --
*
* Perform the cleanup work before exiting the process.
* We first do the cleanup generic to all platforms. Then
* we call _PR_MD_CLEANUP_BEFORE_EXIT(), where platform-dependent
* cleanup is done. This function is used by PR_Cleanup().
*
* See also: PR_Cleanup().
*
*-----------------------------------------------------------------------
*/
#if defined(_PR_PTHREADS) || defined(_PR_BTHREADS)
/* see ptthread.c */
#else
static void _PR_CleanupBeforeExit(void) {
/*
Do not make any calls here other than to destroy resources. For example,
do not make any calls that eventually may end up in PR_Lock. Because the
thread is destroyed, can not access current thread any more.
*/
_PR_CleanupTPD();
if (_pr_terminationCVLock)
/*
* In light of the comment above, this looks real suspicious.
* I'd go so far as to say it's just a problem waiting to happen.
*/
{
PR_DestroyLock(_pr_terminationCVLock);
}
_PR_MD_CLEANUP_BEFORE_EXIT();
}
#endif /* defined(_PR_PTHREADS) */
/*
*----------------------------------------------------------------------
*
* PR_Cleanup --
*
* Perform a graceful shutdown of the NSPR runtime. PR_Cleanup() may
* only be called from the primordial thread, typically at the
* end of the main() function. It returns when it has completed
* its platform-dependent duty and the process must not make any other
* NSPR library calls prior to exiting from main().
*
* PR_Cleanup() first blocks the primordial thread until all the
* other user (non-system) threads, if any, have terminated.
* Then it performs cleanup in preparation for exiting the process.
* PR_Cleanup() does not exit the primordial thread (which would
* in turn exit the process).
*
* PR_Cleanup() only responds when it is called by the primordial
* thread. Calls by any other thread are silently ignored.
*
* See also: PR_ExitProcess()
*
*----------------------------------------------------------------------
*/
#if defined(_PR_PTHREADS) || defined(_PR_BTHREADS)
/* see ptthread.c */
#else
PR_IMPLEMENT(PRStatus) PR_Cleanup() {
PRThread* me = PR_GetCurrentThread();
PR_ASSERT((NULL != me) && (me->flags & _PR_PRIMORDIAL));
if ((NULL != me) && (me->flags & _PR_PRIMORDIAL)) {
PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("PR_Cleanup: shutting down NSPR"));
/*
* No more recycling of threads
*/
_pr_recycleThreads = 0;
/*
* Wait for all other user (non-system/daemon) threads
* to terminate.
*/
PR_Lock(_pr_activeLock);
while (_pr_userActive > _pr_primordialExitCount) {
PR_WaitCondVar(_pr_primordialExitCVar, PR_INTERVAL_NO_TIMEOUT);
}
if (me->flags & _PR_SYSTEM) {
_pr_systemActive--;
} else {
_pr_userActive--;
}
PR_Unlock(_pr_activeLock);
_PR_MD_EARLY_CLEANUP();
_PR_CleanupMW();
_PR_CleanupTime();
_PR_CleanupDtoa();
_PR_CleanupCallOnce();
_PR_ShutdownLinker();
_PR_CleanupNet();
_PR_CleanupIO();
/* Release the primordial thread's private data, etc. */
_PR_CleanupThread(me);
_PR_MD_STOP_INTERRUPTS();
PR_LOG(_pr_thread_lm, PR_LOG_MIN,
("PR_Cleanup: clean up before destroying thread"));
_PR_LogCleanup();
/*
* This part should look like the end of _PR_NativeRunThread
* and _PR_UserRunThread.
*/
if (_PR_IS_NATIVE_THREAD(me)) {
_PR_MD_EXIT_THREAD(me);
_PR_NativeDestroyThread(me);
} else {
_PR_UserDestroyThread(me);
PR_DELETE(me->stack);
PR_DELETE(me);
}
/*
* XXX: We are freeing the heap memory here so that Purify won't
* complain, but we should also free other kinds of resources
* that are allocated by the _PR_InitXXX() functions.
* Ideally, for each _PR_InitXXX(), there should be a corresponding
* _PR_XXXCleanup() that we can call here.
*/
# ifdef WINNT
_PR_CleanupCPUs();
# endif
_PR_CleanupThreads();
_PR_CleanupCMon();
PR_DestroyLock(_pr_sleeplock);
_pr_sleeplock = NULL;
_PR_CleanupLayerCache();
_PR_CleanupEnv();
_PR_CleanupStacks();
_PR_CleanupBeforeExit();
_pr_initialized = PR_FALSE;
return PR_SUCCESS;
}
return PR_FAILURE;
}
#endif /* defined(_PR_PTHREADS) */
/*
*------------------------------------------------------------------------
* PR_ProcessExit --
*
* Cause an immediate, nongraceful, forced termination of the process.
* It takes a PRIntn argument, which is the exit status code of the
* process.
*
* See also: PR_Cleanup()
*
*------------------------------------------------------------------------
*/
#if defined(_PR_PTHREADS) || defined(_PR_BTHREADS)
/* see ptthread.c */
#else
PR_IMPLEMENT(void) PR_ProcessExit(PRIntn status) { _PR_MD_EXIT(status); }
#endif /* defined(_PR_PTHREADS) */
PR_IMPLEMENT(PRProcessAttr*)
PR_NewProcessAttr(void) {
PRProcessAttr* attr;
attr = PR_NEWZAP(PRProcessAttr);
if (!attr) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
}
return attr;
}
PR_IMPLEMENT(void)
PR_ResetProcessAttr(PRProcessAttr* attr) {
PR_FREEIF(attr->currentDirectory);
PR_FREEIF(attr->fdInheritBuffer);
memset(attr, 0, sizeof(*attr));
}
PR_IMPLEMENT(void)
PR_DestroyProcessAttr(PRProcessAttr* attr) {
PR_FREEIF(attr->currentDirectory);
PR_FREEIF(attr->fdInheritBuffer);
PR_DELETE(attr);
}
PR_IMPLEMENT(void)
PR_ProcessAttrSetStdioRedirect(PRProcessAttr* attr, PRSpecialFD stdioFd,
PRFileDesc* redirectFd) {
switch (stdioFd) {
case PR_StandardInput:
attr->stdinFd = redirectFd;
break;
case PR_StandardOutput:
attr->stdoutFd = redirectFd;
break;
case PR_StandardError:
attr->stderrFd = redirectFd;
break;
default:
PR_ASSERT(0);
}
}
/*
* OBSOLETE
*/
PR_IMPLEMENT(void)
PR_SetStdioRedirect(PRProcessAttr* attr, PRSpecialFD stdioFd,
PRFileDesc* redirectFd) {
#if defined(DEBUG)
static PRBool warn = PR_TRUE;
if (warn) {
warn = _PR_Obsolete("PR_SetStdioRedirect()",
"PR_ProcessAttrSetStdioRedirect()");
}
#endif
PR_ProcessAttrSetStdioRedirect(attr, stdioFd, redirectFd);
}
PR_IMPLEMENT(PRStatus)
PR_ProcessAttrSetCurrentDirectory(PRProcessAttr* attr, const char* dir) {
PR_FREEIF(attr->currentDirectory);
attr->currentDirectory = (char*)PR_MALLOC(strlen(dir) + 1);
if (!attr->currentDirectory) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return PR_FAILURE;
}
strcpy(attr->currentDirectory, dir);
return PR_SUCCESS;
}
PR_IMPLEMENT(PRStatus)
PR_ProcessAttrSetInheritableFD(PRProcessAttr* attr, PRFileDesc* fd,
const char* name) {
/* We malloc the fd inherit buffer in multiples of this number. */
#define FD_INHERIT_BUFFER_INCR 128
/* The length of "NSPR_INHERIT_FDS=" */
#define NSPR_INHERIT_FDS_STRLEN 17
/* The length of osfd (PROsfd) printed in hexadecimal with 0x prefix */
#ifdef _WIN64
# define OSFD_STRLEN 18
#else
# define OSFD_STRLEN 10
#endif
/* The length of fd type (PRDescType) printed in decimal */
#define FD_TYPE_STRLEN 1
PRSize newSize;
int remainder;
char* newBuffer;
int nwritten;
char* cur;
int freeSize;
if (fd->identity != PR_NSPR_IO_LAYER) {
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
return PR_FAILURE;
}
if (fd->secret->inheritable == _PR_TRI_UNKNOWN) {
_PR_MD_QUERY_FD_INHERITABLE(fd);
}
if (fd->secret->inheritable != _PR_TRI_TRUE) {
PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, 0);
return PR_FAILURE;
}
/*
* We also need to account for the : separators and the
* terminating null byte.
*/
if (NULL == attr->fdInheritBuffer) {
/* The first time, we print "NSPR_INHERIT_FDS=<name>:<type>:<val>" */
newSize = NSPR_INHERIT_FDS_STRLEN + strlen(name) + FD_TYPE_STRLEN +
OSFD_STRLEN + 2 + 1;
} else {
/* At other times, we print ":<name>:<type>:<val>" */
newSize = attr->fdInheritBufferUsed + strlen(name) + FD_TYPE_STRLEN +
OSFD_STRLEN + 3 + 1;
}
if (newSize > attr->fdInheritBufferSize) {
/* Make newSize a multiple of FD_INHERIT_BUFFER_INCR */
remainder = newSize % FD_INHERIT_BUFFER_INCR;
if (remainder != 0) {
newSize += (FD_INHERIT_BUFFER_INCR - remainder);
}
if (NULL == attr->fdInheritBuffer) {
newBuffer = (char*)PR_MALLOC(newSize);
} else {
newBuffer = (char*)PR_REALLOC(attr->fdInheritBuffer, newSize);
}
if (NULL == newBuffer) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return PR_FAILURE;
}
attr->fdInheritBuffer = newBuffer;
attr->fdInheritBufferSize = newSize;
}
cur = attr->fdInheritBuffer + attr->fdInheritBufferUsed;
freeSize = attr->fdInheritBufferSize - attr->fdInheritBufferUsed;
if (0 == attr->fdInheritBufferUsed) {
nwritten =
PR_snprintf(cur, freeSize, "NSPR_INHERIT_FDS=%s:%d:0x%" PR_PRIxOSFD,
name, (PRIntn)fd->methods->file_type, fd->secret->md.osfd);
} else {
nwritten = PR_snprintf(cur, freeSize, ":%s:%d:0x%" PR_PRIxOSFD, name,
(PRIntn)fd->methods->file_type, fd->secret->md.osfd);
}
attr->fdInheritBufferUsed += nwritten;
return PR_SUCCESS;
}
PR_IMPLEMENT(PRFileDesc*) PR_GetInheritedFD(const char* name) {
PRFileDesc* fd;
const char* envVar;
const char* ptr;
int len = strlen(name);
PROsfd osfd;
int nColons;
PRIntn fileType;
envVar = PR_GetEnv("NSPR_INHERIT_FDS");
if (NULL == envVar || '\0' == envVar[0]) {
PR_SetError(PR_UNKNOWN_ERROR, 0);
return NULL;
}
ptr = envVar;
while (1) {
if ((ptr[len] == ':') && (strncmp(ptr, name, len) == 0)) {
ptr += len + 1;
if (PR_sscanf(ptr, "%d:0x%" PR_SCNxOSFD, &fileType, &osfd) != 2) {
PR_SetError(PR_UNKNOWN_ERROR, 0);
return NULL;
}
switch ((PRDescType)fileType) {
case PR_DESC_FILE:
fd = PR_ImportFile(osfd);
break;
case PR_DESC_PIPE:
fd = PR_ImportPipe(osfd);
break;
case PR_DESC_SOCKET_TCP:
fd = PR_ImportTCPSocket(osfd);
break;
case PR_DESC_SOCKET_UDP:
fd = PR_ImportUDPSocket(osfd);
break;
default:
PR_ASSERT(0);
PR_SetError(PR_UNKNOWN_ERROR, 0);
fd = NULL;
break;
}
if (fd) {
/*
* An inherited FD is inheritable by default.
* The child process needs to call PR_SetFDInheritable
* to make it non-inheritable if so desired.
*/
fd->secret->inheritable = _PR_TRI_TRUE;
}
return fd;
}
/* Skip three colons */
nColons = 0;
while (*ptr) {
if (*ptr == ':') {
if (++nColons == 3) {
break;
}
}
ptr++;
}
if (*ptr == '\0') {
PR_SetError(PR_UNKNOWN_ERROR, 0);
return NULL;
}
ptr++;
}
}
PR_IMPLEMENT(PRProcess*)
PR_CreateProcess(const char* path, char* const* argv, char* const* envp,
const PRProcessAttr* attr) {
return _PR_MD_CREATE_PROCESS(path, argv, envp, attr);
} /* PR_CreateProcess */
PR_IMPLEMENT(PRStatus)
PR_CreateProcessDetached(const char* path, char* const* argv, char* const* envp,
const PRProcessAttr* attr) {
PRProcess* process;
PRStatus rv;
process = PR_CreateProcess(path, argv, envp, attr);
if (NULL == process) {
return PR_FAILURE;
}
rv = PR_DetachProcess(process);
PR_ASSERT(PR_SUCCESS == rv);
if (rv == PR_FAILURE) {
PR_DELETE(process);
return PR_FAILURE;
}
return PR_SUCCESS;
}
PR_IMPLEMENT(PRStatus) PR_DetachProcess(PRProcess* process) {
return _PR_MD_DETACH_PROCESS(process);
}
PR_IMPLEMENT(PRStatus) PR_WaitProcess(PRProcess* process, PRInt32* exitCode) {
return _PR_MD_WAIT_PROCESS(process, exitCode);
} /* PR_WaitProcess */
PR_IMPLEMENT(PRStatus) PR_KillProcess(PRProcess* process) {
return _PR_MD_KILL_PROCESS(process);
}
/*
********************************************************************
*
* Module initialization
*
********************************************************************
*/
static struct {
PRLock* ml;
PRCondVar* cv;
} mod_init;
static void _PR_InitCallOnce(void) {
mod_init.ml = PR_NewLock();
PR_ASSERT(NULL != mod_init.ml);
mod_init.cv = PR_NewCondVar(mod_init.ml);
PR_ASSERT(NULL != mod_init.cv);
}
void _PR_CleanupCallOnce() {
PR_DestroyLock(mod_init.ml);
mod_init.ml = NULL;
PR_DestroyCondVar(mod_init.cv);
mod_init.cv = NULL;
}
PR_IMPLEMENT(PRStatus) PR_CallOnce(PRCallOnceType* once, PRCallOnceFN func) {
if (!_pr_initialized) {
_PR_ImplicitInitialization();
}
PR_Lock(mod_init.ml);
PRIntn initialized = once->initialized;
PRStatus status = once->status;
PR_Unlock(mod_init.ml);
if (!initialized) {
if (PR_ATOMIC_SET(&once->inProgress, 1) == 0) {
status = (*func)();
PR_Lock(mod_init.ml);
once->status = status;
once->initialized = 1;
PR_NotifyAllCondVar(mod_init.cv);
PR_Unlock(mod_init.ml);
} else {
PR_Lock(mod_init.ml);
while (!once->initialized) {
PR_WaitCondVar(mod_init.cv, PR_INTERVAL_NO_TIMEOUT);
}
status = once->status;
PR_Unlock(mod_init.ml);
if (PR_SUCCESS != status) {
PR_SetError(PR_CALL_ONCE_ERROR, 0);
}
}
return status;
}
if (PR_SUCCESS != status) {
PR_SetError(PR_CALL_ONCE_ERROR, 0);
}
return status;
}
PR_IMPLEMENT(PRStatus)
PR_CallOnceWithArg(PRCallOnceType* once, PRCallOnceWithArgFN func, void* arg) {
if (!_pr_initialized) {
_PR_ImplicitInitialization();
}
PR_Lock(mod_init.ml);
PRIntn initialized = once->initialized;
PRStatus status = once->status;
PR_Unlock(mod_init.ml);
if (!initialized) {
if (PR_ATOMIC_SET(&once->inProgress, 1) == 0) {
status = (*func)(arg);
PR_Lock(mod_init.ml);
once->status = status;
once->initialized = 1;
PR_NotifyAllCondVar(mod_init.cv);
PR_Unlock(mod_init.ml);
} else {
PR_Lock(mod_init.ml);
while (!once->initialized) {
PR_WaitCondVar(mod_init.cv, PR_INTERVAL_NO_TIMEOUT);
}
status = once->status;
PR_Unlock(mod_init.ml);
if (PR_SUCCESS != status) {
PR_SetError(PR_CALL_ONCE_ERROR, 0);
}
}
return status;
}
if (PR_SUCCESS != status) {
PR_SetError(PR_CALL_ONCE_ERROR, 0);
}
return status;
}
PRBool _PR_Obsolete(const char* obsolete, const char* preferred) {
#if defined(DEBUG)
PR_fprintf(PR_STDERR, "'%s' is obsolete. Use '%s' instead.\n", obsolete,
(NULL == preferred) ? "something else" : preferred);
#endif
return PR_FALSE;
} /* _PR_Obsolete */
/* prinit.c */