PRIntn main(PRIntn argc, char **argv)
{
PRInt32 rv, test, result = 0;
PRFileDesc *output = PR_GetSpecialFD(PR_StandardOutput);
test = -2;
rv = PR_AtomicIncrement(&test);
result = result | ((rv < 0) ? 0 : 1);
PR_fprintf(
output, "PR_AtomicIncrement(%d) == %d: %s\n",
test, rv, (rv < 0) ? "PASSED" : "FAILED");
rv = PR_AtomicIncrement(&test);
result = result | ((rv == 0) ? 0 : 1);
PR_fprintf(
output, "PR_AtomicIncrement(%d) == %d: %s\n",
test, rv, (rv == 0) ? "PASSED" : "FAILED");
rv = PR_AtomicIncrement(&test);
result = result | ((rv > 0) ? 0 : 1);
PR_fprintf(
output, "PR_AtomicIncrement(%d) == %d: %s\n",
test, rv, (rv > 0) ? "PASSED" : "FAILED");
test = 2;
rv = PR_AtomicDecrement(&test);
result = result | ((rv > 0) ? 0 : 1);
PR_fprintf(
output, "PR_AtomicDecrement(%d) == %d: %s\n",
test, rv, (rv > 0) ? "PASSED" : "FAILED");
rv = PR_AtomicDecrement(&test);
result = result | ((rv == 0) ? 0 : 1);
PR_fprintf(
output, "PR_AtomicDecrement(%d) == %d: %s\n",
test, rv, (rv == 0) ? "PASSED" : "FAILED");
rv = PR_AtomicDecrement(&test);
result = result | ((rv < 0) ? 0 : 1);
PR_fprintf(
output, "PR_AtomicDecrement(%d) == %d: %s\n",
test, rv, (rv < 0) ? "PASSED" : "FAILED");
test = -2;
rv = PR_AtomicSet(&test, 2);
result = result | (((rv == -2) && (test == 2)) ? 0 : 1);
PR_fprintf(
output, "PR_AtomicSet(%d) == %d: %s\n",
test, rv, ((rv == -2) && (test == 2)) ? "PASSED" : "FAILED");
PR_fprintf(
output, "Atomic operations test %s\n",
(result == 0) ? "PASSED" : "FAILED");
return result;
} /* main */
nsPlatformCharset::nsPlatformCharset()
{
PR_AtomicIncrement(&gCnt);
static PRCallOnceType once;
PR_CallOnce(&once, InitLock);
NS_ASSERTION(gLock, "Can't allocate a lock?!");
}
void PyXPCOM_DLLAddRef(void)
{
// Must be thread-safe, although cant have the Python lock!
CEnterLeaveXPCOMFramework _celf;
PRInt32 cnt = PR_AtomicIncrement(&g_cLockCount);
if (cnt==1) { // First call
if (!Py_IsInitialized()) {
Py_Initialize();
// Make sure our Windows framework is all setup.
PyXPCOM_Globals_Ensure();
// Make sure we have _something_ as sys.argv.
if (PySys_GetObject((char*)"argv")==NULL) {
PyObject *path = PyList_New(0);
#if PY_MAJOR_VERSION <= 2
PyObject *str = PyString_FromString("");
#else
PyObject *str = PyUnicode_FromString("");
#endif
PyList_Append(path, str);
PySys_SetObject((char*)"argv", path);
Py_XDECREF(path);
Py_XDECREF(str);
}
// Must force Python to start using thread locks, as
// we are free-threaded (maybe, I think, sometimes :-)
PyEval_InitThreads();
#ifndef PYXPCOM_USE_PYGILSTATE
// Release Python lock, as first thing we do is re-get it.
ptsGlobal = PyEval_SaveThread();
#endif
// NOTE: We never finalize Python!!
}
}
}
nsSystemPrincipal::AddRef()
{
NS_PRECONDITION(PRInt32(mJSPrincipals.refcount) >= 0, "illegal refcnt");
nsrefcnt count = PR_AtomicIncrement((PRInt32 *)&mJSPrincipals.refcount);
NS_LOG_ADDREF(this, count, "nsSystemPrincipal", sizeof(*this));
return count;
}
nsresult nsTimerImpl::InitCommon(PRUint32 aType, PRUint32 aDelay)
{
nsresult rv;
NS_ENSURE_TRUE(gThread, NS_ERROR_NOT_INITIALIZED);
rv = gThread->Init();
NS_ENSURE_SUCCESS(rv, rv);
/**
* In case of re-Init, both with and without a preceding Cancel, clear the
* mCanceled flag and assign a new mGeneration. But first, remove any armed
* timer from the timer thread's list.
*
* If we are racing with the timer thread to remove this timer and we lose,
* the RemoveTimer call made here will fail to find this timer in the timer
* thread's list, and will return false harmlessly. We test mArmed here to
* avoid the small overhead in RemoveTimer of locking the timer thread and
* checking its list for this timer. It's safe to test mArmed even though
* it might be cleared on another thread in the next cycle (or even already
* be cleared by another CPU whose store hasn't reached our CPU's cache),
* because RemoveTimer is idempotent.
*/
if (mArmed)
gThread->RemoveTimer(this);
mCanceled = PR_FALSE;
mGeneration = PR_AtomicIncrement(&gGenerator);
mType = (PRUint8)aType;
SetDelayInternal(aDelay);
return gThread->AddTimer(this);
}
SECStatus
sslMutex_Lock(sslMutex *pMutex)
{
PRInt32 newValue;
if (PR_FALSE == pMutex->isMultiProcess) {
return single_process_sslMutex_Lock(pMutex);
}
if (pMutex->u.pipeStr.mPipes[2] != SSL_MUTEX_MAGIC) {
PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
return SECFailure;
}
newValue = PR_AtomicIncrement(&pMutex->u.pipeStr.nWaiters);
/* Do Memory Barrier here. */
if (newValue > 1) {
int cc;
char c;
do {
cc = read(pMutex->u.pipeStr.mPipes[0], &c, 1);
} while (cc < 0 && errno == EINTR);
if (cc != 1) {
if (cc < 0)
nss_MD_unix_map_default_error(errno);
else
PORT_SetError(PR_UNKNOWN_ERROR);
return SECFailure;
}
}
return SECSuccess;
}
PRFileDesc *
ServerSetup(void)
{
PRFileDesc *listenSocket;
PRNetAddr serverAddr;
PRThread *WorkerThread;
if ( (listenSocket = PR_NewTCPSocket()) == NULL) {
if (debug_mode) printf("\tServer error creating listen socket\n");
else failed_already=1;
return NULL;
}
memset(&serverAddr, 0, sizeof(PRNetAddr));
serverAddr.inet.family = AF_INET;
serverAddr.inet.port = PR_htons(PORT);
serverAddr.inet.ip = PR_htonl(INADDR_ANY);
if ( PR_Bind(listenSocket, &serverAddr) == PR_FAILURE) {
if (debug_mode) printf("\tServer error binding to server address: OS error %d\n",
PR_GetOSError());
else failed_already=1;
PR_Close(listenSocket);
return NULL;
}
if ( PR_Listen(listenSocket, 128) == PR_FAILURE) {
if (debug_mode) printf("\tServer error listening to server socket\n");
else failed_already=1;
PR_Close(listenSocket);
return NULL;
}
/* Create Clients */
workerThreads = 0;
workerThreadsBusy = 0;
workerThreadsLock = PR_NewLock();
WorkerThread = PR_CreateThread(
PR_SYSTEM_THREAD,
WorkerThreadFunc,
listenSocket,
PR_PRIORITY_NORMAL,
ServerScope,
PR_UNJOINABLE_THREAD,
STACKSIZE);
if (!WorkerThread) {
if (debug_mode) printf("error creating working thread\n");
PR_Close(listenSocket);
return NULL;
}
PR_AtomicIncrement(&workerThreads);
if (debug_mode) DPRINTF("\tServer created primordial worker thread\n");
return listenSocket;
}
//
// Request a reservation in the keep-alive system
//
PRBool
PollManager::RequestReservation(void)
{
PR_ASSERT(numKeepAlives_ >= 0);
PRInt32 numKeepAlives = PR_AtomicIncrement(&numKeepAlives_);
if (numKeepAlives > maxKeepAlives_) {
PR_AtomicDecrement(&numKeepAlives_);
if (PR_AtomicIncrement(&numKeepAliveRefusals_) == 1)
ereport(LOG_VERBOSE, "PollManager::RequestReservation() keep-alive subsystem full");
return PR_FALSE;
}
return PR_TRUE;
}
NSS_IMPLEMENT NSSSlot *
nssSlot_AddRef (
NSSSlot *slot
)
{
PR_AtomicIncrement(&slot->base.refCount);
return slot;
}
NS_IMETHODIMP_(nsrefcnt) nsPrintProgress::AddRef(void)
{
NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt");
nsrefcnt count;
count = PR_AtomicIncrement((PRInt32*)&mRefCnt);
//NS_LOG_ADDREF(this, count, "nsPrintProgress", sizeof(*this));
return count;
}
/*
* Function: prldap_new_tpdindex()
* Description: allocate a thread-private data index.
* Returns: the new index.
*/
static PRUintn
prldap_new_tpdindex( void )
{
PRUintn tpdindex;
tpdindex = (PRUintn)PR_AtomicIncrement( &prldap_tpd_maxindex );
return( tpdindex );
}
Py_nsISupports::Py_nsISupports(nsISupports *punk, const nsIID &iid, PyTypeObject *this_type)
{
ob_type = this_type;
m_obj = punk;
m_iid = iid;
// refcnt of object managed by caller.
PR_AtomicIncrement(&cInterfaces);
_Py_NewReference(this);
}
nsExceptionManager::nsExceptionManager(nsExceptionService *svc) :
mNextThread(nsnull),
mService(svc)
{
/* member initializers and constructor code */
#ifdef NS_DEBUG
PR_AtomicIncrement(&totalInstances);
#endif
}
Py_DOMnsISupports(PyObject *pycontext, nsISupports *p, const nsIID &iid) :
Py_nsISupports(p, iid, type),
m_pycontext(pycontext) {
/* The IID _must_ be the IID of the interface we are wrapping! */
//NS_ABORT_IF_FALSE(iid.Equals(NS_GET_IID(InterfaceName)), "Bad IID");
Py_INCREF(pycontext);
PR_AtomicIncrement(&cPyDOMISupportsObjects);
}
NS_IMETHODIMP
PlugletEngine::LockFactory(PRBool aLock)
{
if(aLock) {
PR_AtomicIncrement(&lockCount);
} else {
PR_AtomicDecrement(&lockCount);
}
return NS_OK;
}
nsrefcnt
nsNodeInfoManager::AddRef()
{
NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt");
nsrefcnt count = PR_AtomicIncrement((PRInt32*)&mRefCnt);
NS_LOG_ADDREF(this, count, "nsNodeInfoManager", sizeof(*this));
return count;
}
NSFC_GetFileInfo(const char *filename, NSFCFileInfo *finfo,
NSFCCache cache)
{
NSFCEntry entry = NSFCENTRY_INIT;
NSFCEntryImpl *nep = entry;
NSFCStatus rfc;
NSFCStatusInfo statusInfo;
NSFCFileInfo myfinfo;
NSFCFileInfo *f_info = (finfo) ? finfo : &myfinfo;
PRBool hit = PR_FALSE;
PRStatus rv = PR_SUCCESS;
NSFCSTATUSINFO_INIT(&statusInfo);
rfc = NSFC_AccessFilename(filename, &nep, f_info, cache, &statusInfo);
if (rfc == NSFC_OK) {
PR_ASSERT(nep->flags & NSFCENTRY_HASINFO);
if (finfo)
memcpy(finfo, &nep->finfo, sizeof(*finfo));
if (nep->flags & NSFCENTRY_ERRORINFO) {
rv = PR_FAILURE;
}
if (statusInfo != NSFC_STATUSINFO_CREATE)
hit = PR_TRUE;
NSFC_RecordEntryHit(cache, nep);
NSFC_ReleaseEntry(cache, &nep);
}
else if (rfc == NSFC_STATFAIL) {
rv = PR_FAILURE;
}
else {
rv = NSFC_GetNonCacheFileInfo(filename, f_info);
}
if (hit)
PR_AtomicIncrement((PRInt32 *)&cache->infoHits);
else
PR_AtomicIncrement((PRInt32 *)&cache->infoMiss);
return rv;
}
nsrefcnt
PyG_Base::AddRef(void)
{
nsrefcnt cnt = (nsrefcnt) PR_AtomicIncrement((PRInt32*)&mRefCnt);
#ifdef NS_BUILD_REFCNT_LOGGING
// If we have no pBaseObject, then we need to ignore them
if (m_pBaseObject == NULL)
NS_LOG_ADDREF(this, cnt, refcntLogRepr, sizeof(*this));
#endif
return cnt;
}
/*
* Close all outstanding persistent searches.
* To be used when the server is shutting down.
*/
void
ps_stop_psearch_system()
{
PSearch *ps;
if ( PS_IS_INITIALIZED()) {
PSL_LOCK_WRITE();
for ( ps = psearch_list->pl_head; NULL != ps; ps = ps->ps_next ) {
PR_AtomicIncrement( &ps->ps_complete );
}
PSL_UNLOCK_WRITE();
ps_wakeup_all();
}
}
nsresult
nsPlatformCharset::InitInfo()
{
PR_AtomicIncrement(&gCnt); // count for gInfo
if (gInfo == nsnull) {
nsGREResProperties *info =
new nsGREResProperties(NS_LITERAL_CSTRING("os2charset.properties"));
NS_ASSERTION(info , "cannot open properties file");
NS_ENSURE_TRUE(info, NS_ERROR_FAILURE);
gInfo = info;
}
return NS_OK;
}
static JSBool
Suspend(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
nsJSSh* shell;
if (!GetJSShGlobal(cx, obj, &shell)) return JS_FALSE;
nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
PR_AtomicIncrement(&shell->mSuspendCount);
while (shell->mSuspendCount) {
LOG(("|"));
NS_ProcessNextEvent(thread);
}
return JS_TRUE;
}
/*
* Notifies just get posted to the protecting mutex. The
* actual notification is done when the lock is released so that
* MP systems don't contend for a lock that they can't have.
*/
static void pt_PostNotifyToCvar(PRCondVar *cvar, PRBool broadcast)
{
PRIntn index = 0;
_PT_Notified *notified = &cvar->lock->notified;
PR_ASSERT(PR_TRUE == cvar->lock->locked);
PR_ASSERT(pthread_equal(cvar->lock->owner, pthread_self()));
PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(cvar->lock->mutex));
while (1)
{
for (index = 0; index < notified->length; ++index)
{
if (notified->cv[index].cv == cvar)
{
if (broadcast)
notified->cv[index].times = -1;
else if (-1 != notified->cv[index].times)
notified->cv[index].times += 1;
goto finished; /* we're finished */
}
}
/* if not full, enter new CV in this array */
if (notified->length < PT_CV_NOTIFIED_LENGTH) break;
/* if there's no link, create an empty array and link it */
if (NULL == notified->link)
notified->link = PR_NEWZAP(_PT_Notified);
notified = notified->link;
}
/* A brand new entry in the array */
(void)PR_AtomicIncrement(&cvar->notify_pending);
notified->cv[index].times = (broadcast) ? -1 : 1;
notified->cv[index].cv = cvar;
notified->length += 1;
finished:
PR_ASSERT(PR_TRUE == cvar->lock->locked);
PR_ASSERT(pthread_equal(cvar->lock->owner, pthread_self()));
} /* pt_PostNotifyToCvar */
XPCWrappedNativeProto::XPCWrappedNativeProto(XPCWrappedNativeScope* Scope,
nsIClassInfo* ClassInfo,
PRUint32 ClassInfoFlags,
XPCNativeSet* Set)
: mScope(Scope),
mJSProtoObject(nsnull),
mClassInfo(ClassInfo),
mClassInfoFlags(ClassInfoFlags),
mSet(Set),
mSecurityInfo(nsnull),
mScriptableInfo(nsnull)
{
// This native object lives as long as its associated JSObject - killed
// by finalization of the JSObject (or explicitly if Init fails).
MOZ_COUNT_CTOR(XPCWrappedNativeProto);
#ifdef DEBUG
PR_AtomicIncrement(&gDEBUG_LiveProtoCount);
#endif
}
static PRInt32 _udt_recv(PRFileDesc *fd, void *buf, PRInt32 amount,
PRIntn flags, PRIntervalTime timeout) {
uint32_t dummy_data;
PRUdtSocketDesc* desc = (PRUdtSocketDesc*)(fd->secret);
if (desc->sign_cnt != desc->rd_cnt) {
PR_Recv(desc->sock_pair0, (char*)&dummy_data, sizeof(dummy_data), 0, 0);
PR_AtomicIncrement(&desc->rd_cnt);
}
// peek is not supported in udt
if(PR_MSG_PEEK & flags)
return PR_WOULD_BLOCK_ERROR;
int rc = udt_recv(desc->udtfd, (char*)buf, amount, 0);
if(rc < 0) {
int udterrcode = udt_getErrorCode();
if ((UDT_ERRECONNLOST == udterrcode) ||
(UDT_ERRENOCONN == udterrcode)) {
PR_Close(desc->sock_pair1);
//rc = 0;
}
}
return rc;
}
static PRInt32 _udt_read(PRFileDesc *fd, void *buf, PRInt32 amount) {
UDTSOCKET s = get_socket_from_fd(fd);
uint32_t dummy_data;
int rc = 0;
PRUdtSocketDesc* desc = (PRUdtSocketDesc*)(fd->secret);
if (desc->sign_cnt != desc->rd_cnt) {
PR_Recv(desc->sock_pair0, (char*)&dummy_data, sizeof(dummy_data), 0, 0);
PR_AtomicIncrement(&desc->rd_cnt);
}
rc = udt_recv(s, (char*)buf, amount, 0);
if(rc < 0) {
int udterrcode = udt_getErrorCode();
if (UDT_ERRECONNLOST == udterrcode) {
rc = 0;
PR_Close(desc->sock_pair0);
PR_Close(desc->sock_pair1);
} else if (UDT_ERRENOCONN == udterrcode) {
rc = 0;
PR_Close(desc->sock_pair0);
PR_Close(desc->sock_pair1);
}
}
return rc;
}
nsExceptionService::nsExceptionService()
: mProviders(4, PR_TRUE) /* small, thread-safe hashtable */
{
#ifdef NS_DEBUG
if (PR_AtomicIncrement(&totalInstances)!=1) {
NS_ERROR("The nsExceptionService is a singleton!");
}
#endif
/* member initializers and constructor code */
if (tlsIndex == BAD_TLS_INDEX) {
PRStatus status;
status = PR_NewThreadPrivateIndex( &tlsIndex, ThreadDestruct );
NS_ASSERTION(status==0, "ScriptErrorService could not allocate TLS storage.");
}
lock = PR_NewLock();
NS_ASSERTION(lock, "Error allocating ExceptionService lock");
// observe XPCOM shutdown.
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
NS_ASSERTION(observerService, "Could not get observer service!");
if (observerService)
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_FALSE);
}
STDMETHODIMP_(ULONG) CMapiFactory::AddRef()
{
return (PR_AtomicIncrement(&m_cRef));
}
STDMETHODIMP_(ULONG) CMapiImp::AddRef()
{
return PR_AtomicIncrement(&m_cRef);
}
explicit nsStressRunner(int num) : mNum(num), mWasRun(false) {
PR_AtomicIncrement(&gNum);
}
int
decrement_repl_active_threads()
{
PR_AtomicIncrement(&repl_active_threads);
return repl_active_threads;
}
