// // Debug implementation of ReentrantMonitor void ReentrantMonitor::Enter() { BlockingResourceBase* chainFront = ResourceChainFront(); // the code below implements monitor reentrancy semantics if (this == chainFront) { // immediately re-entered the monitor: acceptable PR_EnterMonitor(mReentrantMonitor); ++mEntryCount; return; } CallStack callContext = CallStack(); // this is sort of a hack around not recording the thread that // owns this monitor if (chainFront) { for (BlockingResourceBase* br = ResourceChainPrev(chainFront); br; br = ResourceChainPrev(br)) { if (br == this) { NS_WARNING( "Re-entering ReentrantMonitor after acquiring other resources.\n" "At calling context\n"); GetAcquisitionContext().Print(stderr); // show the caller why this is potentially bad CheckAcquire(callContext); PR_EnterMonitor(mReentrantMonitor); ++mEntryCount; return; } } } CheckAcquire(callContext); PR_EnterMonitor(mReentrantMonitor); NS_ASSERTION(mEntryCount == 0, "ReentrantMonitor isn't free!"); Acquire(callContext); // protected by mReentrantMonitor mEntryCount = 1; }
static void WaitMonitorThread(void *arg) { PRIntervalTime timeout = (PRIntervalTime) arg; PRIntervalTime elapsed; #if defined(XP_UNIX) || defined(WIN32) PRInt32 timeout_msecs = PR_IntervalToMilliseconds(timeout); PRInt32 elapsed_msecs; #endif #if defined(XP_UNIX) struct timeval end_time_tv; #endif #if defined(WIN32) && !defined(WINCE) struct _timeb end_time_tb; #endif PRMonitor *mon; mon = PR_NewMonitor(); if (mon == NULL) { fprintf(stderr, "PR_NewMonitor failed\n"); exit(1); } PR_EnterMonitor(mon); PR_Wait(mon, timeout); PR_ExitMonitor(mon); elapsed = (PRIntervalTime)(PR_IntervalNow() - start_time); if (elapsed + tolerance < timeout || elapsed > timeout + tolerance) { fprintf(stderr, "timeout wrong\n"); exit(1); } #if defined(XP_UNIX) gettimeofday(&end_time_tv, NULL); elapsed_msecs = 1000*(end_time_tv.tv_sec - start_time_tv.tv_sec) + (end_time_tv.tv_usec - start_time_tv.tv_usec)/1000; #endif #if defined(WIN32) #if defined(WINCE) elapsed_msecs = GetTickCount() - start_time_tick; #else _ftime(&end_time_tb); elapsed_msecs = 1000*(end_time_tb.time - start_time_tb.time) + (end_time_tb.millitm - start_time_tb.millitm); #endif #endif #if defined(XP_UNIX) || defined(WIN32) if (elapsed_msecs + tolerance_msecs < timeout_msecs || elapsed_msecs > timeout_msecs + tolerance_msecs) { fprintf(stderr, "timeout wrong\n"); exit(1); } #endif PR_DestroyMonitor(mon); if (debug_mode) { fprintf(stderr, "wait monitor thread (scope %d) done\n", PR_GetThreadScope(PR_GetCurrentThread())); } }
NS_IMETHODIMP nsIMAPHostSessionList::GetOnlineDirForHost(const char *serverKey, nsString &result) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) CopyASCIItoUTF16(host->fOnlineDir, result); PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
static void PR_CALLBACK TryEntry(void *arg) { PRMonitor *ml = (PRMonitor*)arg; if (debug_mode) PR_fprintf(std_err, "Reentrant thread created\n"); PR_EnterMonitor(ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); if (debug_mode) PR_fprintf(std_err, "Reentrant thread acquired monitor\n"); PR_ExitMonitor(ml); if (debug_mode) PR_fprintf(std_err, "Reentrant thread released monitor\n"); } /* TryEntry */
NS_IMETHODIMP nsIMAPHostSessionList::ClearShellCacheForHost(const char *serverKey) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host && host->fShellCache) host->fShellCache->Clear(); PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::GetOnlineTrashFolderExistsForHost(const char *serverKey, PRBool &result) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) result = host->fOnlineTrashFolderExists; PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::SetGotNamespacesForHost( const char *serverKey, PRBool gotNamespaces) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) host->fGotNamespaces = gotNamespaces; PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::SetDeleteIsMoveToTrashForHost( const char *serverKey, PRBool isMoveToTrash) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) host->fDeleteIsMoveToTrash = isMoveToTrash; PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::GetPasswordVerifiedOnline(const char *serverKey, PRBool &result) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) result = host->fPasswordVerifiedOnline; PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
void jsd_LockSourceTextSubsystem(JSDContext* jsdc) { #ifndef JSD_SIMULATION if (jsd_text_mon == NULL) jsd_text_mon = PR_NewNamedMonitor("jsd-text-monitor"); PR_EnterMonitor(jsd_text_mon); #endif /* JSD_SIMULATION */ }
NS_IMETHODIMP nsIMAPHostSessionList::FlushUncommittedNamespacesForHost(const char *serverKey, PRBool &result) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) { host->fTempNamespaceList->ClearNamespaces(PR_TRUE, PR_TRUE, PR_TRUE); } PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::GetNamespaceNumberForHost(const char *serverKey, PRInt32 n, nsIMAPNamespace * &result) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) { result = host->fNamespaceList->GetNamespaceNumber(n); } PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::GetDefaultNamespaceOfTypeForHost(const char *serverKey, EIMAPNamespaceType type, nsIMAPNamespace * &result) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) { result = host->fNamespaceList->GetDefaultNamespaceOfType(type); } PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::ClearServerAdvertisedNamespacesForHost(const char *serverKey) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) { host->fNamespaceList->ClearNamespaces(PR_FALSE, PR_TRUE, PR_TRUE); } PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::AddNewNamespaceForHost(const char *serverKey, nsIMAPNamespace *ns) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) { host->fNamespaceList->AddNewNamespace(ns); } PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
static void PR_CALLBACK MonitorContender(void *arg) { MonitorContentious_t *contention = (MonitorContentious_t*)arg; while (contention->loops-- > 0) { PR_EnterMonitor(contention->ml); contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_ExitMonitor(contention->ml); } } /* MonitorContender */
/** * Destroy a monitor that was created by gpsee_createMonitor(). It is the caller's * responsibility to insure that no other threads may want to use the monitor while * this routine is running. * * @param grt The GPSEE runtime which owns the monitor * @param monitor The monitor to destroy */ void gpsee_destroyMonitor(gpsee_runtime_t *grt, gpsee_monitor_t monitor) { #ifdef JS_THREADSAFE if (monitor == nilMonitor) return; PR_EnterMonitor(grt->monitors.monitor); gpsee_ds_remove(grt->monitorList_unlocked, monitor); PR_ExitMonitor(grt->monitors.monitor); PR_DestroyMonitor(monitor); #endif }
static PRIntervalTime NonContentiousMonitor(PRUint32 loops) { PRMonitor *ml = NULL; ml = PR_NewMonitor(); while (loops-- > 0) { PR_EnterMonitor(ml); PR_ExitMonitor(ml); } PR_DestroyMonitor(ml); return 0; } /* NonContentiousMonitor */
// create new event queue, append it to the current thread's chain of event queues. // return it, addrefed. NS_IMETHODIMP nsEventQueueServiceImpl::PushThreadEventQueue(nsIEventQueue **aNewQueue) { nsresult rv = NS_OK; PRThread* currentThread = PR_GetCurrentThread(); PRBool native = PR_TRUE; // native by default as per old comment NS_ASSERTION(aNewQueue, "PushThreadEventQueue called with null param"); /* Enter the lock that protects the EventQ hashtable... */ PR_EnterMonitor(mEventQMonitor); nsIEventQueue* queue = mEventQTable.GetWeak(currentThread); NS_ASSERTION(queue, "pushed event queue on top of nothing"); if (queue) { // find out what kind of queue our relatives are nsCOMPtr<nsIEventQueue> youngQueue; GetYoungestEventQueue(queue, getter_AddRefs(youngQueue)); if (youngQueue) { youngQueue->IsQueueNative(&native); } } nsIEventQueue* newQueue = nsnull; MakeNewQueue(currentThread, native, &newQueue); // create new queue; addrefs if (!queue) { // shouldn't happen. as a fallback, we guess you wanted a native queue mEventQTable.Put(currentThread, newQueue); } // append to the event queue chain nsCOMPtr<nsPIEventQueueChain> ourChain(do_QueryInterface(queue)); // QI the queue in the hash table if (ourChain) ourChain->AppendQueue(newQueue); // append new queue to it *aNewQueue = newQueue; #if defined(PR_LOGGING) && defined(DEBUG_danm) PLEventQueue *equeue; (*aNewQueue)->GetPLEventQueue(&equeue); PR_LOG(gEventQueueLog, PR_LOG_DEBUG, ("EventQueue: Service push queue [queue=%lx]",(long)equeue)); ++gEventQueueLogCount; #endif // Release the EventQ lock... PR_ExitMonitor(mEventQMonitor); return rv; }
// reset any cached connection info - delete the lot of 'em NS_IMETHODIMP nsIMAPHostSessionList::ResetAll() { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *nextHost = NULL; for (nsIMAPHostInfo *host = fHostInfoList; host; host = nextHost) { nextHost = host->fNextHost; delete host; } fHostInfoList = NULL; PR_ExitMonitor(gCachedHostInfoMonitor); return NS_OK; }
void nsDNSSyncRequest::OnLookupComplete(nsHostResolver *resolver, nsHostRecord *hostRecord, nsresult status) { // store results, and wake up nsDNSService::Resolve to process results. PR_EnterMonitor(mMonitor); mDone = PR_TRUE; mStatus = status; mHostRecord = hostRecord; PR_Notify(mMonitor); PR_ExitMonitor(mMonitor); }
PKIX_Error * PKIX_PL_MonitorLock_Enter( PKIX_PL_MonitorLock *monitorLock, void *plContext) { PKIX_ENTER_NO_LOGGER(MONITORLOCK, "PKIX_PL_MonitorLock_Enter"); PKIX_NULLCHECK_ONE(monitorLock); PKIX_MONITORLOCK_DEBUG("\tCalling PR_EnterMonitor)\n"); (void) PR_EnterMonitor(monitorLock->lock); PKIX_RETURN_NO_LOGGER(MONITORLOCK); }
NS_IMETHODIMP nsIMAPHostSessionList::SetNamespaceHierarchyDelimiterFromMailboxForHost(const char *serverKey, const char *boxName, char delimiter) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) { nsIMAPNamespace *ns = host->fNamespaceList->GetNamespaceForMailbox(boxName); if (ns && !ns->GetIsDelimiterFilledIn()) ns->SetDelimiter(delimiter, true); } PR_ExitMonitor(gCachedHostInfoMonitor); return (host) ? NS_OK : NS_ERROR_ILLEGAL_VALUE ; }
static PRIntervalTime NonContentiousMonitor(PRUint32 loops) { PRMonitor *ml = NULL; ml = PR_NewMonitor(); while (loops-- > 0) { PR_EnterMonitor(ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); PR_ExitMonitor(ml); } PR_DestroyMonitor(ml); return 0; } /* NonContentiousMonitor */
NS_IMETHODIMP nsIMAPHostSessionList::GetNumberOfNamespacesForHost(const char *serverKey, PRUint32 &result) { PRInt32 intResult = 0; PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) intResult = host->fNamespaceList->GetNumberOfNamespaces(); PR_ExitMonitor(gCachedHostInfoMonitor); NS_ASSERTION(intResult >= 0, "negative number of namespaces"); result = (PRUint32) intResult; return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::SetOnlineDirForHost(const char *serverKey, const char *onlineDir) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) { if (onlineDir) host->fOnlineDir = onlineDir; } PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
NS_IMETHODIMP nsIMAPHostSessionList::SetPasswordForHost(const char *serverKey, const char *password) { PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host) { PR_FREEIF(host->fCachedPassword); if (password) host->fCachedPassword = NS_strdup(password); } PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
static void Level_0_Thread(PRThreadScope scope1, PRThreadScope scope2) { PRThread *thr; PRThread *me = PR_GetCurrentThread(); int n; PRInt32 words; PRWord *registers; alive = 0; mon = PR_NewMonitor(); alive = count; for (n=0; n<count; n++) { thr = PR_CreateThreadGCAble(PR_USER_THREAD, Level_1_Thread, (void *)scope2, PR_PRIORITY_NORMAL, scope1, PR_UNJOINABLE_THREAD, 0); if (!thr) { printf("Could not create thread!\n"); alive--; } printf("Level_0_Thread[0x%lx] created %15s thread 0x%lx\n", PR_GetCurrentThread(), (scope1 == PR_GLOBAL_THREAD) ? "PR_GLOBAL_THREAD" : "PR_LOCAL_THREAD", thr); PR_Sleep(0); } PR_SuspendAll(); PR_EnumerateThreads(print_thread, NULL); registers = PR_GetGCRegisters(me, 1, (int *)&words); if (registers) printf("My Registers: R0 = 0x%x R1 = 0x%x R2 = 0x%x R3 = 0x%x\n", registers[0],registers[1],registers[2],registers[3]); printf("My Stack Pointer = 0x%lx\n", PR_GetSP(me)); PR_ResumeAll(); /* Wait for all threads to exit */ PR_EnterMonitor(mon); while (alive) { PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT); } PR_ExitMonitor(mon); PR_DestroyMonitor(mon); }
NS_IMETHODIMP nsIMAPHostSessionList::FindShellInCacheForHost(const char *serverKey, const char *mailboxName, const char *UID, IMAP_ContentModifiedType modType, nsIMAPBodyShell **shell) { nsCString uidString(UID); PR_EnterMonitor(gCachedHostInfoMonitor); nsIMAPHostInfo *host = FindHost(serverKey); if (host && host->fShellCache) NS_IF_ADDREF(*shell = host->fShellCache->FindShellForUID(uidString, mailboxName, modType)); PR_ExitMonitor(gCachedHostInfoMonitor); return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK; }
static void PR_CALLBACK MonitorContender(void *arg) { MonitorContentious_t *contention = (MonitorContentious_t*)arg; while (contention->loops-- > 0) { PR_EnterMonitor(contention->ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml); contention->contender+= 1; contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml); PR_ExitMonitor(contention->ml); } } /* MonitorContender */