NSFC_RecordEntryHit(NSFCCache cache, NSFCEntry entry)
{
PR_ASSERT(entry->refcnt >= 1);
entry->hitcnt++;
/*
* If existing entries can be recycled for new files, indicate that
* this entry is active.
*/
if (cache->cfg.replaceFiles == PR_TRUE) {
/* Update the hit list order if this entry is in the hit list */
PR_Lock(cache->hitLock);
if (PR_LIST_HEAD(&entry->hit_list) != PR_LIST_TAIL(&entry->hit_list)) {
if (cache->cfg.hitOrder == PR_TRUE) {
/*
* If this entry is not at the head of the hit list,
* move it ahead of all entries with the same hitcnt.
*/
PRCList *prev;
NSFCEntryImpl *pnep;
for (prev = PR_PREV_LINK(&entry->hit_list);
prev != &cache->hit_list;
prev = PR_PREV_LINK(prev)) {
pnep = NSFCENTRYIMPL(prev);
if (pnep->hitcnt > entry->hitcnt) {
break; /* Our spot in the list */
}
}
/* Move the element up if necessary */
if (prev != PR_PREV_LINK(&entry->hit_list)) {
PR_REMOVE_LINK(&entry->hit_list);
PR_INSERT_AFTER(&entry->hit_list, prev);
}
}
else {
/* Ignore hitcnt, keep list in strict MRU to LRU order */
if (&entry->hit_list != PR_LIST_HEAD(&cache->hit_list)) {
PR_REMOVE_LINK(&entry->hit_list);
PR_INSERT_LINK(&entry->hit_list, &cache->hit_list);
}
}
}
PR_Unlock(cache->hitLock);
}
}
PRBool
nsSocketTransportService::ServiceEventQ()
{
PRBool keepGoing;
// grab the event queue
PRCList eq;
PR_INIT_CLIST(&eq);
{
nsAutoLock lock(mEventQLock);
MoveCList(mEventQ, eq);
// check to see if we're supposed to shutdown
keepGoing = mInitialized;
}
// service the event queue
PLEvent *event;
while (!PR_CLIST_IS_EMPTY(&eq)) {
event = PLEVENT_FROM_LINK(PR_LIST_HEAD(&eq));
PR_REMOVE_AND_INIT_LINK(&event->link);
PL_HandleEvent(event);
}
return keepGoing;
}
nsresult
nsSocketTransportService::DetachSocket(SocketContext *sock)
{
LOG(("nsSocketTransportService::DetachSocket [handler=%x]\n", sock->mHandler));
// inform the handler that this socket is going away
sock->mHandler->OnSocketDetached(sock->mFD);
// cleanup
sock->mFD = nsnull;
NS_RELEASE(sock->mHandler);
// find out what list this is on.
PRUint32 index = sock - mActiveList;
if (index < NS_SOCKET_MAX_COUNT)
RemoveFromPollList(sock);
else
RemoveFromIdleList(sock);
// NOTE: sock is now an invalid pointer
//
// notify the first element on the pending socket queue...
//
if (!PR_CLIST_IS_EMPTY(&mPendingSocketQ)) {
// move event from pending queue to event queue
PLEvent *event = PLEVENT_FROM_LINK(PR_LIST_HEAD(&mPendingSocketQ));
PR_REMOVE_AND_INIT_LINK(&event->link);
PostEvent(event);
}
return NS_OK;
}
int
jobLoop(PRFileDesc *a, PRFileDesc *b, int c)
{
PRCList *myLink = 0;
JOB *myJob;
PZ_Lock(qLock);
do {
myLink = 0;
while (PR_CLIST_IS_EMPTY(&jobQ) && !stopping) {
PZ_WaitCondVar(jobQNotEmptyCv, PR_INTERVAL_NO_TIMEOUT);
}
if (!PR_CLIST_IS_EMPTY(&jobQ)) {
myLink = PR_LIST_HEAD(&jobQ);
PR_REMOVE_AND_INIT_LINK(myLink);
}
PZ_Unlock(qLock);
myJob = (JOB *)myLink;
/* myJob will be null when stopping is true and jobQ is empty */
if (!myJob)
break;
handle_connection(myJob->tcp_sock, myJob->model_sock,
myJob->requestCert);
PZ_Lock(qLock);
PR_APPEND_LINK(myLink, &freeJobs);
PZ_NotifyCondVar(freeListNotEmptyCv);
} while (PR_TRUE);
return 0;
}
/* cleanup at shutdown */
void RSA_Cleanup(void)
{
blindingParams * bp = NULL;
if (!coBPInit.initialized)
return;
while (!PR_CLIST_IS_EMPTY(&blindingParamsList.head)) {
RSABlindingParams *rsabp =
(RSABlindingParams *)PR_LIST_HEAD(&blindingParamsList.head);
PR_REMOVE_LINK(&rsabp->link);
/* clear parameters cache */
while (rsabp->bp != NULL) {
bp = rsabp->bp;
rsabp->bp = rsabp->bp->next;
mp_clear( &bp->f );
mp_clear( &bp->g );
}
SECITEM_FreeItem(&rsabp->modulus,PR_FALSE);
PORT_Free(rsabp);
}
if (blindingParamsList.cVar) {
PR_DestroyCondVar(blindingParamsList.cVar);
blindingParamsList.cVar = NULL;
}
if (blindingParamsList.lock) {
SKIP_AFTER_FORK(PZ_DestroyLock(blindingParamsList.lock));
blindingParamsList.lock = NULL;
}
coBPInit.initialized = 0;
coBPInit.inProgress = 0;
coBPInit.status = 0;
}
/**
* Called from PL_HashTableEnumerateEntries
* A pointer to a PRCList (circular linked list) is passed in.
* Once enumeration is complete, the PRCList will contain a lexically
* ordered list of a copy of the keys in the hash.
* The caller needs to free the copies
*/
static PRIntn OrderLoop(PLHashEntry *he, PRIntn index, void *arg)
{
PRCList *qp = (PRCList *)arg;
OrderedEntry_t *entry;
if (he != NULL) {
entry = (OrderedEntry_t *) PR_Malloc(sizeof(OrderedEntry_t));
entry->key = PL_strdup((char *) he->key);
if (index ==0) {
PR_APPEND_LINK((PRCList *)entry, qp);
return HT_ENUMERATE_NEXT;
}
PRCList *head = PR_LIST_HEAD(qp);
PRCList *next;
while (head != qp) {
OrderedEntry_t *current = (OrderedEntry_t *) head;
if (strcmp((char *) he->key, (char *) current->key) <=0)
break;
next = PR_NEXT_LINK(head);
head = next;
}
PR_INSERT_BEFORE((PRCList*) entry, head);
return HT_ENUMERATE_NEXT;
} else {
return HT_ENUMERATE_STOP;
}
}
nsresult
nsMemoryCacheDevice::Visit(nsICacheVisitor * visitor)
{
nsMemoryCacheDeviceInfo * deviceInfo = new nsMemoryCacheDeviceInfo(this);
nsCOMPtr<nsICacheDeviceInfo> deviceRef(deviceInfo);
if (!deviceInfo) return NS_ERROR_OUT_OF_MEMORY;
bool keepGoing;
nsresult rv = visitor->VisitDevice(gMemoryDeviceID, deviceInfo, &keepGoing);
if (NS_FAILED(rv)) return rv;
if (!keepGoing)
return NS_OK;
nsCacheEntry * entry;
nsCOMPtr<nsICacheEntryInfo> entryRef;
for (int i = kQueueCount - 1; i >= 0; --i) {
entry = (nsCacheEntry *)PR_LIST_HEAD(&mEvictionList[i]);
while (entry != &mEvictionList[i]) {
nsCacheEntryInfo * entryInfo = new nsCacheEntryInfo(entry);
if (!entryInfo) return NS_ERROR_OUT_OF_MEMORY;
entryRef = entryInfo;
rv = visitor->VisitEntry(gMemoryDeviceID, entryInfo, &keepGoing);
entryInfo->DetachEntry();
if (NS_FAILED(rv)) return rv;
if (!keepGoing) break;
entry = (nsCacheEntry *)PR_NEXT_LINK(entry);
}
}
return NS_OK;
}
nsresult
nsMemoryCacheDevice::DoEvictEntries(bool (*matchFn)(nsCacheEntry* entry, void* args), void* args)
{
nsCacheEntry * entry;
for (int i = kQueueCount - 1; i >= 0; --i) {
PRCList * elem = PR_LIST_HEAD(&mEvictionList[i]);
while (elem != &mEvictionList[i]) {
entry = (nsCacheEntry *)elem;
elem = PR_NEXT_LINK(elem);
if (!matchFn(entry, args))
continue;
if (entry->IsInUse()) {
nsresult rv = nsCacheService::DoomEntry(entry);
if (NS_FAILED(rv)) {
CACHE_LOG_WARNING(("memCache->DoEvictEntries() aborted: rv =%x", rv));
return rv;
}
} else {
EvictEntry(entry, DELETE_ENTRY);
}
}
}
return NS_OK;
}
nsresult
nsMemoryCacheDevice::EvictEntries(const char * clientID)
{
nsCacheEntry * entry;
uint32_t prefixLength = (clientID ? strlen(clientID) : 0);
for (int i = kQueueCount - 1; i >= 0; --i) {
PRCList * elem = PR_LIST_HEAD(&mEvictionList[i]);
while (elem != &mEvictionList[i]) {
entry = (nsCacheEntry *)elem;
elem = PR_NEXT_LINK(elem);
const char * key = entry->Key()->get();
if (clientID && nsCRT::strncmp(clientID, key, prefixLength) != 0)
continue;
if (entry->IsInUse()) {
nsresult rv = nsCacheService::DoomEntry(entry);
if (NS_FAILED(rv)) {
CACHE_LOG_WARNING(("memCache->EvictEntries() aborted: rv =%x", rv));
return rv;
}
} else {
EvictEntry(entry, DELETE_ENTRY);
}
}
}
return NS_OK;
}
void JavaDOMGlobals::TakeOutGarbage()
{
nsAutoLock lock(garbageLock);
PRUint32 count = 0;
nsISupports* domo = NULL;
PRCList* chain = NULL;
PRCList* elem = NULL;
for (chain = PR_LIST_HEAD(&garbage);
chain != &garbage;
chain = PR_NEXT_LINK(chain)) {
delete elem;
elem = chain;
domo = ((jniDOMGarbage*) elem)->domObject;
PR_LOG(log, PR_LOG_DEBUG,
("JavaDOMGlobals::TakeOutGarbage: Releasing %x\n", domo));
domo->Release();
domo = NULL;
count++;
}
delete elem;
PR_INIT_CLIST(&garbage);
if (count)
PR_LOG(log, PR_LOG_DEBUG,
("JavaDOMGlobals::TakeOutGarbage: Released %d objects\n", count));
}
/* cleanup at shutdown */
void RSA_Cleanup(void)
{
if (!coBPInit.initialized)
return;
while (!PR_CLIST_IS_EMPTY(&blindingParamsList.head))
{
struct RSABlindingParamsStr * rsabp = (struct RSABlindingParamsStr *)
PR_LIST_HEAD(&blindingParamsList.head);
PR_REMOVE_LINK(&rsabp->link);
mp_clear(&rsabp->f);
mp_clear(&rsabp->g);
SECITEM_FreeItem(&rsabp->modulus,PR_FALSE);
PORT_Free(rsabp);
}
if (blindingParamsList.lock)
{
PZ_DestroyLock(blindingParamsList.lock);
blindingParamsList.lock = NULL;
}
coBPInit.initialized = 0;
coBPInit.inProgress = 0;
coBPInit.status = 0;
}
/**
* returns a string containing all the parameters in the ConfigStore hash set in the
* format key1=value1&&key2=value2&& ...
* The list will be lexically ordered by parameter key values.
* The string needs to be freed by the caller.
**/
TPS_PUBLIC const char* ConfigStore::GetOrderedList()
{
char *outstr = NULL;
char *new_string = NULL;
PRCList order_list;
PR_INIT_CLIST(&order_list);
PR_Lock(m_lock);
PL_HashTableEnumerateEntries(m_root->getSet(), &OrderLoop, &order_list);
PR_Unlock(m_lock);
PRCList *current = PR_LIST_HEAD(&order_list);
PRCList *next;
outstr = (char*) PR_Malloc(128);
int allocated = 128;
int needed = 0;
PR_snprintf(outstr, 128, "");
while (current != &order_list) {
OrderedEntry_t *entry = (OrderedEntry_t *) current;
const char *value = GetConfigAsString(entry->key, "");
if ((entry != NULL) && (entry->key != NULL)) {
needed = PL_strlen(outstr) + PL_strlen(entry->key) + PL_strlen(value) + 4;
if (allocated <= needed) {
while (allocated <= needed) {
allocated = allocated * 2;
}
new_string = (char *)PR_Malloc(allocated);
PR_snprintf(new_string, allocated, "%s", outstr);
PR_Free(outstr);
outstr = new_string;
}
PL_strcat(outstr, entry->key);
PL_strcat(outstr, "=");
PL_strcat(outstr, value);
// free the memory for the Ordered Entry
PL_strfree(entry->key);
}
next = PR_NEXT_LINK(current);
PR_REMOVE_AND_INIT_LINK(current);
if (current != NULL) {
PR_Free(current);
}
current = next;
if (current != &order_list) PL_strcat(outstr, "&&");
}
return outstr;
}
void
nsScannerBufferList::ReleaseAll()
{
while (!PR_CLIST_IS_EMPTY(&mBuffers))
{
PRCList* node = PR_LIST_HEAD(&mBuffers);
PR_REMOVE_LINK(node);
//printf(">>> freeing buffer @%p\n", node);
free(NS_STATIC_CAST(Buffer*, node));
}
}
/*
* Delete the entire config list contents.
*/
void
pam_passthru_delete_config()
{
PRCList *list;
while (!PR_CLIST_IS_EMPTY(pam_passthru_global_config)) {
list = PR_LIST_HEAD(pam_passthru_global_config);
pam_passthru_delete_configEntry(list);
}
return;
}
PR_IMPLEMENT(PRRecvWait*) PR_CancelWaitGroup(PRWaitGroup *group)
{
PRRecvWait **desc;
PRRecvWait *recv_wait = NULL;
if (PR_FAILURE == MW_Init())
{
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
return NULL;
}
if (NULL == group) group = mw_state->group;
PR_ASSERT(NULL != group);
if (NULL == group)
{
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
return NULL;
}
PR_Lock(group->ml);
if (_prmw_stopped != group->state)
{
if (_prmw_running == group->state)
group->state = _prmw_stopping; /* so nothing new comes in */
if (0 == group->waiting_threads) /* is there anybody else? */
group->state = _prmw_stopped; /* we can stop right now */
while (_prmw_stopped != group->state)
(void)PR_WaitCondVar(group->mw_manage, PR_INTERVAL_NO_TIMEOUT);
/* make all the existing descriptors look done/interrupted */
for (desc = &group->waiter->recv_wait; group->waiter->count > 0; ++desc)
{
if (NULL != *desc)
_MW_DoneInternal(group, desc, PR_MW_INTERRUPT);
}
PR_NotifyAllCondVar(group->new_business);
}
/* take first element of finished list and return it or NULL */
if (PR_CLIST_IS_EMPTY(&group->io_ready))
PR_SetError(PR_GROUP_EMPTY_ERROR, 0);
else
{
PRCList *head = PR_LIST_HEAD(&group->io_ready);
PR_REMOVE_AND_INIT_LINK(head);
recv_wait = (PRRecvWait*)head;
}
PR_Unlock(group->ml);
return recv_wait;
} /* PR_CancelWaitGroup */
void
nsCacheEntry::DetachDescriptors(void)
{
nsCacheEntryDescriptor * descriptor =
(nsCacheEntryDescriptor *)PR_LIST_HEAD(&mDescriptorQ);
while (descriptor != &mDescriptorQ) {
nsCacheEntryDescriptor * nextDescriptor =
(nsCacheEntryDescriptor *)PR_NEXT_LINK(descriptor);
descriptor->ClearCacheEntry();
PR_REMOVE_AND_INIT_LINK(descriptor);
descriptor = nextDescriptor;
}
}
PR_IMPLEMENT(PRStatus) PR_CancelWaitFileDesc(PRWaitGroup *group, PRRecvWait *desc)
{
PRRecvWait **recv_wait;
PRStatus rv = PR_SUCCESS;
if (PR_FAILURE == MW_Init()) return rv;
if (NULL == group) group = mw_state->group;
PR_ASSERT(NULL != group);
if (NULL == group)
{
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
return PR_FAILURE;
}
PR_Lock(group->ml);
if (_prmw_running != group->state)
{
PR_SetError(PR_INVALID_STATE_ERROR, 0);
rv = PR_FAILURE;
goto stopping;
}
if (NULL != (recv_wait = _MW_LookupInternal(group, desc->fd)))
{
/* it was in the wait table */
_MW_DoneInternal(group, recv_wait, PR_MW_INTERRUPT);
goto found;
}
if (!PR_CLIST_IS_EMPTY(&group->io_ready))
{
/* is it already complete? */
PRCList *head = PR_LIST_HEAD(&group->io_ready);
do
{
PRRecvWait *done = (PRRecvWait*)head;
if (done == desc) goto found;
head = PR_NEXT_LINK(head);
} while (head != &group->io_ready);
}
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
rv = PR_FAILURE;
found:
stopping:
PR_Unlock(group->ml);
return rv;
} /* PR_CancelWaitFileDesc */
void
nsMemoryCacheDevice::EvictEntriesIfNecessary(void)
{
nsCacheEntry * entry;
nsCacheEntry * maxEntry;
CACHE_LOG_DEBUG(("EvictEntriesIfNecessary. mTotalSize: %d, mHardLimit: %d,"
"mInactiveSize: %d, mSoftLimit: %d\n",
mTotalSize, mHardLimit, mInactiveSize, mSoftLimit));
if ((mTotalSize < mHardLimit) && (mInactiveSize < mSoftLimit))
return;
uint32_t now = SecondsFromPRTime(PR_Now());
uint64_t entryCost = 0;
uint64_t maxCost = 0;
do {
// LRU-SP eviction selection: Check the head of each segment (each
// eviction list, kept in LRU order) and select the maximal-cost
// entry for eviction. Cost is time-since-accessed * size / nref.
maxEntry = 0;
for (int i = kQueueCount - 1; i >= 0; --i) {
entry = (nsCacheEntry *)PR_LIST_HEAD(&mEvictionList[i]);
// If the head of a list is in use, check the next available entry
while ((entry != &mEvictionList[i]) &&
(entry->IsInUse())) {
entry = (nsCacheEntry *)PR_NEXT_LINK(entry);
}
if (entry != &mEvictionList[i]) {
entryCost = (uint64_t)
(now - entry->LastFetched()) * entry->DataSize() /
std::max(1, entry->FetchCount());
if (!maxEntry || (entryCost > maxCost)) {
maxEntry = entry;
maxCost = entryCost;
}
}
}
if (maxEntry) {
EvictEntry(maxEntry, DELETE_ENTRY);
} else {
break;
}
}
while ((mTotalSize >= mHardLimit) || (mInactiveSize >= mSoftLimit));
}
static void TimerManager(void *arg)
{
PRIntervalTime now;
PRIntervalTime timeout;
PRCList *head;
TimerEvent *timer;
PR_Lock(tm_vars.ml);
while (1)
{
if (PR_CLIST_IS_EMPTY(&tm_vars.timer_queue))
{
PR_WaitCondVar(tm_vars.new_timer, PR_INTERVAL_NO_TIMEOUT);
}
else
{
now = PR_IntervalNow();
head = PR_LIST_HEAD(&tm_vars.timer_queue);
timer = TIMER_EVENT_PTR(head);
if ((PRInt32) (now - timer->absolute) >= 0)
{
PR_REMOVE_LINK(head);
/*
* make its prev and next point to itself so that
* it's obvious that it's not on the timer_queue.
*/
PR_INIT_CLIST(head);
PR_ASSERT(2 == timer->ref_count);
PR_Unlock(tm_vars.ml);
timer->func(timer->arg);
PR_Lock(tm_vars.ml);
timer->ref_count -= 1;
if (0 == timer->ref_count)
{
PR_NotifyAllCondVar(tm_vars.cancel_timer);
}
}
else
{
timeout = (PRIntervalTime)(timer->absolute - now);
PR_WaitCondVar(tm_vars.new_timer, timeout);
}
}
}
PR_Unlock(tm_vars.ml);
}
void
nsMemoryCacheDevice::CheckEntryCount()
{
if (!mInitialized) return;
int32_t evictionListCount = 0;
for (int i=0; i<kQueueCount; ++i) {
PRCList * elem = PR_LIST_HEAD(&mEvictionList[i]);
while (elem != &mEvictionList[i]) {
elem = PR_NEXT_LINK(elem);
++evictionListCount;
}
}
NS_ASSERTION(mEntryCount == evictionListCount, "### mem cache badness");
int32_t entryCount = 0;
mMemCacheEntries.VisitEntries(CountEntry, &entryCount);
NS_ASSERTION(mEntryCount == entryCount, "### mem cache badness");
}
void
nsStringBundleService::flushBundleCache()
{
// release all bundles in the cache
mBundleMap.Reset();
PRCList *current = PR_LIST_HEAD(&mBundleCache);
while (current != &mBundleCache) {
bundleCacheEntry_t *cacheEntry = (bundleCacheEntry_t*)current;
recycleEntry(cacheEntry);
PRCList *oldItem = current;
current = PR_NEXT_LINK(current);
// will be freed in PL_FreeArenaPool
PR_REMOVE_LINK(oldItem);
}
PL_FreeArenaPool(&mCacheEntryPool);
}
ssl3CipherSpec *
ssl_FindCipherSpecByEpoch(sslSocket *ss, CipherSpecDirection direction,
DTLSEpoch epoch)
{
PRCList *cur_p;
for (cur_p = PR_LIST_HEAD(&ss->ssl3.hs.cipherSpecs);
cur_p != &ss->ssl3.hs.cipherSpecs;
cur_p = PR_NEXT_LINK(cur_p)) {
ssl3CipherSpec *spec = (ssl3CipherSpec *)cur_p;
if (spec->epoch != epoch) {
continue;
}
if (direction != spec->direction) {
continue;
}
return spec;
}
return NULL;
}
PR_FindNextTraceQname(
PRTraceHandle handle
)
{
QName *qnp = (QName *)handle;
if ( PR_CLIST_IS_EMPTY( &qNameList ))
qnp = NULL;
else if ( qnp == NULL )
qnp = (QName *)PR_LIST_HEAD( &qNameList );
else if ( PR_NEXT_LINK( &qnp->link ) == &qNameList )
qnp = NULL;
else
qnp = (QName *)PR_NEXT_LINK( &qnp->link );
PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: FindNextQname: Handle: %p, Returns: %p",
handle, qnp ));
return((PRTraceHandle)qnp);
} /* end PR_FindNextTraceQname() */
void
nsPACMan::ProcessPendingQ(nsresult status)
{
// Now, start any pending queries
PRCList *node = PR_LIST_HEAD(&mPendingQ);
while (node != &mPendingQ) {
PendingPACQuery *query = static_cast<PendingPACQuery *>(node);
node = PR_NEXT_LINK(node);
if (NS_SUCCEEDED(status)) {
// keep the query in the list (so we can complete it from Shutdown if
// necessary).
status = query->Start();
}
if (NS_FAILED(status)) {
// remove the query from the list
PR_REMOVE_LINK(query);
query->Complete(status, EmptyCString());
NS_RELEASE(query);
}
}
}
nsresult
nsMemoryCacheDevice::Shutdown()
{
NS_ASSERTION(mInitialized, "### attempting shutdown while not initialized");
NS_ENSURE_TRUE(mInitialized, NS_ERROR_NOT_INITIALIZED);
mMemCacheEntries.Shutdown();
// evict all entries
nsCacheEntry * entry, * next;
for (int i = kQueueCount - 1; i >= 0; --i) {
entry = (nsCacheEntry *)PR_LIST_HEAD(&mEvictionList[i]);
while (entry != &mEvictionList[i]) {
NS_ASSERTION(!entry->IsInUse(), "### shutting down with active entries");
next = (nsCacheEntry *)PR_NEXT_LINK(entry);
PR_REMOVE_AND_INIT_LINK(entry);
// update statistics
int32_t memoryRecovered = (int32_t)entry->DataSize();
mTotalSize -= memoryRecovered;
mInactiveSize -= memoryRecovered;
--mEntryCount;
delete entry;
entry = next;
}
}
/*
* we're not factoring in changes to meta data yet...
* NS_ASSERTION(mTotalSize == 0, "### mem cache leaking entries?");
*/
NS_ASSERTION(mInactiveSize == 0, "### mem cache leaking entries?");
NS_ASSERTION(mEntryCount == 0, "### mem cache leaking entries?");
mInitialized = false;
return NS_OK;
}
PR_FindNextTraceRname(
PRTraceHandle rhandle,
PRTraceHandle qhandle
)
{
RName *rnp = (RName *)rhandle;
QName *qnp = (QName *)qhandle;
if ( PR_CLIST_IS_EMPTY( &qnp->rNameList ))
rnp = NULL;
else if ( rnp == NULL )
rnp = (RName *)PR_LIST_HEAD( &qnp->rNameList );
else if ( PR_NEXT_LINK( &rnp->link ) == &qnp->rNameList )
rnp = NULL;
else
rnp = (RName *)PR_NEXT_LINK( &rnp->link );
PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: FindNextRname: Rhandle: %p, QHandle: %p, Returns: %p",
rhandle, qhandle, rnp ));
return((PRTraceHandle)rnp);
} /* end PR_FindNextTraceRname() */
void
nsCacheEntry::DetachDescriptors(void)
{
nsCacheEntryDescriptor * descriptor =
(nsCacheEntryDescriptor *)PR_LIST_HEAD(&mDescriptorQ);
while (descriptor != &mDescriptorQ) {
nsCacheEntryDescriptor * nextDescriptor =
(nsCacheEntryDescriptor *)PR_NEXT_LINK(descriptor);
// Doom entry if something bad happens while closing. See bug #673543
// Errors are handled different from RemoveDescriptor because this
// method is only called from ClearDoomList (in which case the entry is
// doomed anyway) and ClearActiveEntries (in which case we are shutting
// down and really want to get rid of the entry immediately)
if (NS_FAILED(descriptor->CloseOutput()))
nsCacheService::DoomEntry(this);
descriptor->ClearCacheEntry();
PR_REMOVE_AND_INIT_LINK(descriptor);
descriptor = nextDescriptor;
}
}
static PRAlarmID *pr_getNextAlarm(PRAlarm *alarm, PRAlarmID *id)
{
/*
* Puts 'id' back into the sorted list iff it's not NULL.
* Removes the first element from the list and returns it (or NULL).
* List is "assumed" to be short.
*
* NB: Caller is providing locking
*/
PRCList *timer;
PRAlarmID *result = id;
PRIntervalTime now = PR_IntervalNow();
if (!PR_CLIST_IS_EMPTY(&alarm->timers))
{
if (id != NULL) /* have to put this id back in */
{
PRIntervalTime idDelta = now - id->nextNotify;
timer = alarm->timers.next;
do
{
result = (PRAlarmID*)timer;
if ((PRIntervalTime)(now - result->nextNotify) > idDelta)
{
PR_INSERT_BEFORE(&id->list, &alarm->timers);
break;
}
timer = timer->next;
} while (timer != &alarm->timers);
}
result = (PRAlarmID*)(timer = PR_LIST_HEAD(&alarm->timers));
PR_REMOVE_LINK(timer); /* remove it from the list */
}
return result;
} /* pr_getNextAlarm */
void
nsPACMan::ProcessPendingQ(nsresult status)
{
// Now, start any pending queries
PRCList *node = PR_LIST_HEAD(&mPendingQ);
while (node != &mPendingQ) {
PendingPACQuery *query = static_cast<PendingPACQuery *>(node);
node = PR_NEXT_LINK(node);
if (NS_SUCCEEDED(status)) {
// keep the query in the list (so we can complete it from Shutdown if
// necessary).
status = query->Start(nsIDNSService::RESOLVE_SPECULATE);
}
if (status == NS_ERROR_DNS_LOOKUP_QUEUE_FULL) {
query->OnLookupComplete(NULL, NULL, NS_OK);
status = NS_OK;
} else if (NS_FAILED(status)) {
// remove the query from the list
PR_REMOVE_LINK(query);
query->Complete(status, EmptyCString());
NS_RELEASE(query);
}
}
}
PR_CreateTrace(
const char *qName, /* QName for this trace handle */
const char *rName, /* RName for this trace handle */
const char *description /* description for this trace handle */
)
{
QName *qnp;
RName *rnp;
PRBool matchQname = PR_FALSE;
/* Self initialize, if necessary */
if ( traceLock == NULL )
_PR_InitializeTrace();
/* Validate input arguments */
PR_ASSERT( strlen(qName) <= PRTRACE_NAME_MAX );
PR_ASSERT( strlen(rName) <= PRTRACE_NAME_MAX );
PR_ASSERT( strlen(description) <= PRTRACE_DESC_MAX );
PR_LOG( lm, PR_LOG_DEBUG,
("PRTRACE: CreateTrace: Qname: %s, RName: %s", qName, rName));
/* Lock the Facility */
PR_Lock( traceLock );
/* Do we already have a matching QName? */
if (!PR_CLIST_IS_EMPTY( &qNameList ))
{
qnp = (QName *) PR_LIST_HEAD( &qNameList );
do {
if ( strcmp(qnp->name, qName) == 0)
{
matchQname = PR_TRUE;
break;
}
qnp = (QName *)PR_NEXT_LINK( &qnp->link );
} while( qnp != (QName *)PR_LIST_HEAD( &qNameList ));
}
/*
** If we did not find a matching QName,
** allocate one and initialize it.
** link it onto the qNameList.
**
*/
if ( matchQname != PR_TRUE )
{
qnp = PR_NEWZAP( QName );
PR_ASSERT( qnp != NULL );
PR_INIT_CLIST( &qnp->link );
PR_INIT_CLIST( &qnp->rNameList );
strcpy( qnp->name, qName );
PR_APPEND_LINK( &qnp->link, &qNameList );
}
/* Do we already have a matching RName? */
if (!PR_CLIST_IS_EMPTY( &qnp->rNameList ))
{
rnp = (RName *) PR_LIST_HEAD( &qnp->rNameList );
do {
/*
** No duplicate RNames are allowed within a QName
**
*/
PR_ASSERT( strcmp(rnp->name, rName));
rnp = (RName *)PR_NEXT_LINK( &rnp->link );
} while( rnp != (RName *)PR_LIST_HEAD( &qnp->rNameList ));
}
/* Get a new RName structure; initialize its members */
rnp = PR_NEWZAP( RName );
PR_ASSERT( rnp != NULL );
PR_INIT_CLIST( &rnp->link );
strcpy( rnp->name, rName );
strcpy( rnp->desc, description );
rnp->lock = PR_NewLock();
rnp->state = Running;
if ( rnp->lock == NULL )
{
PR_ASSERT(0);
}
PR_APPEND_LINK( &rnp->link, &qnp->rNameList ); /* add RName to QName's rnList */
rnp->qName = qnp; /* point the RName to the QName */
/* Unlock the Facility */
PR_Unlock( traceLock );
PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: Create: QName: %s %p, RName: %s %p\n\t",
qName, qnp, rName, rnp ));
return((PRTraceHandle)rnp);
} /* end PR_CreateTrace() */
