#endif
/* must be called with cm_scacheLock write-locked! */
-void cm_AdjustLRU(cm_scache_t *scp)
+void cm_AdjustScacheLRU(cm_scache_t *scp)
{
if (scp == cm_data.scacheLRULastp)
cm_data.scacheLRULastp = (cm_scache_t *) osi_QPrev(&scp->q);
if (scp->flags & CM_SCACHEFLAG_INHASH) {
/* hash it out first */
i = CM_SCACHE_HASH(&scp->fid);
- for (lscpp = &cm_data.hashTablep[i], tscp = cm_data.hashTablep[i];
+ for (lscpp = &cm_data.scacheHashTablep[i], tscp = cm_data.scacheHashTablep[i];
tscp;
lscpp = &tscp->nextp, tscp = tscp->nextp) {
if (tscp == scp) {
/* invalidate so next merge works fine;
* also initialize some flags */
+ scp->fileType = 0;
scp->flags &= ~(CM_SCACHEFLAG_STATD
| CM_SCACHEFLAG_DELETED
| CM_SCACHEFLAG_RO
scp->bulkStatProgress = hzero;
scp->waitCount = 0;
+ if (scp->cbServerp) {
+ cm_PutServer(scp->cbServerp);
+ scp->cbServerp = NULL;
+ }
+ scp->cbExpires = 0;
+
scp->fid.vnode = 0;
scp->fid.volume = 0;
scp->fid.unique = 0;
scp->fid.cell = 0;
- /* discard callback */
- if (scp->cbServerp) {
- cm_PutServer(scp->cbServerp);
- scp->cbServerp = NULL;
- }
- scp->cbExpires = 0;
-
/* remove from dnlc */
cm_dnlcPurgedp(scp);
cm_dnlcPurgevp(scp);
}
/* discard symlink info */
- scp->mountPointStringp[0] = 0;
+ scp->mountPointStringp[0] = '\0';
memset(&scp->mountRootFid, 0, sizeof(cm_fid_t));
memset(&scp->dotdotFid, 0, sizeof(cm_fid_t));
scp;
scp = (cm_scache_t *) osi_QPrev(&scp->q))
{
- osi_assert(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.hashTablep);
+ osi_assert(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.scacheHashTablep);
if (scp->refCount == 0) {
if (scp->flags & CM_SCACHEFLAG_DELETED) {
/* now remove from the LRU queue and put it back at the
* head of the LRU queue.
*/
- cm_AdjustLRU(scp);
+ cm_AdjustScacheLRU(scp);
/* and we're done */
return scp;
/* now remove from the LRU queue and put it back at the
* head of the LRU queue.
*/
- cm_AdjustLRU(scp);
+ cm_AdjustScacheLRU(scp);
/* and we're done */
return scp;
/* There were no deleted scache objects that we could use. Try to find
* one that simply hasn't been used in a while.
*/
- for ( scp = cm_data.scacheLRULastp;
- scp;
- scp = (cm_scache_t *) osi_QPrev(&scp->q))
- {
- /* It is possible for the refCount to be zero and for there still
- * to be outstanding dirty buffers. If there are dirty buffers,
- * we must not recycle the scp. */
- if (scp->refCount == 0 && scp->bufReadsp == NULL && scp->bufWritesp == NULL) {
- if (!buf_DirtyBuffersExist(&scp->fid)) {
- if (!cm_RecycleSCache(scp, 0)) {
- /* we found an entry, so return it */
- /* now remove from the LRU queue and put it back at the
- * head of the LRU queue.
- */
- cm_AdjustLRU(scp);
-
- /* and we're done */
- return scp;
- }
- } else {
- osi_Log1(afsd_logp,"GetNewSCache dirty buffers exist scp 0x%x", scp);
- }
- }
- }
- osi_Log1(afsd_logp, "GetNewSCache all scache entries in use (retry = %d)", retry);
-
- return NULL;
+ for ( scp = cm_data.scacheLRULastp;
+ scp;
+ scp = (cm_scache_t *) osi_QPrev(&scp->q))
+ {
+ /* It is possible for the refCount to be zero and for there still
+ * to be outstanding dirty buffers. If there are dirty buffers,
+ * we must not recycle the scp. */
+ if (scp->refCount == 0 && scp->bufReadsp == NULL && scp->bufWritesp == NULL) {
+ if (!buf_DirtyBuffersExist(&scp->fid)) {
+ if (!cm_RecycleSCache(scp, 0)) {
+ /* we found an entry, so return it */
+ /* now remove from the LRU queue and put it back at the
+ * head of the LRU queue.
+ */
+ cm_AdjustScacheLRU(scp);
+
+ /* and we're done */
+ return scp;
+ }
+ } else {
+ osi_Log1(afsd_logp,"GetNewSCache dirty buffers exist scp 0x%x", scp);
+ }
+ }
+ }
+ osi_Log1(afsd_logp, "GetNewSCache all scache entries in use (retry = %d)", retry);
+
+ return NULL;
}
/* if we get here, we should allocate a new scache entry. We either are below
* quota or we have a leak and need to allocate a new one to avoid panicing.
*/
scp = cm_data.scacheBaseAddress + cm_data.currentSCaches;
- osi_assert(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.hashTablep);
+ osi_assert(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.scacheHashTablep);
memset(scp, 0, sizeof(cm_scache_t));
scp->magic = CM_SCACHE_MAGIC;
lock_InitializeMutex(&scp->mx, "cm_scache_t mutex");
cm_data.currentSCaches++;
cm_dnlcPurgedp(scp); /* make doubly sure that this is not in dnlc */
cm_dnlcPurgevp(scp);
+ scp->allNextp = cm_data.allSCachesp;
+ cm_data.allSCachesp = scp;
return scp;
}
}
}
- for ( i=0; i < cm_data.hashTableSize; i++ ) {
- for ( scp = cm_data.hashTablep[i]; scp; scp = scp->nextp ) {
+ for ( i=0; i < cm_data.scacheHashTableSize; i++ ) {
+ for ( scp = cm_data.scacheHashTablep[i]; scp; scp = scp->nextp ) {
if (scp->magic != CM_SCACHE_MAGIC) {
afsi_log("cm_ValidateSCache failure: scp->magic != CM_SCACHE_MAGIC");
fprintf(stderr, "cm_ValidateSCache failure: scp->magic != CM_SCACHE_MAGIC\n");
return cm_dnlcValidate();
}
+void
+cm_SuspendSCache(void)
+{
+ cm_scache_t * scp;
+
+ cm_GiveUpAllCallbacksAllServers();
+
+ lock_ObtainWrite(&cm_scacheLock);
+ for ( scp = cm_data.allSCachesp; scp;
+ scp = scp->allNextp ) {
+ if (scp->cbServerp) {
+ cm_PutServer(scp->cbServerp);
+ scp->cbServerp = NULL;
+ }
+ scp->cbExpires = 0;
+ scp->flags &= ~CM_SCACHEFLAG_CALLBACK;
+ }
+ lock_ReleaseWrite(&cm_scacheLock);
+}
+
long
cm_ShutdownSCache(void)
{
cm_scache_t * scp;
- for ( scp = cm_data.scacheLRULastp; scp;
- scp = (cm_scache_t *) osi_QPrev(&scp->q) ) {
+ lock_ObtainWrite(&cm_scacheLock);
+
+ for ( scp = cm_data.allSCachesp; scp;
+ scp = scp->allNextp ) {
if (scp->randomACLp) {
lock_ObtainMutex(&scp->mx);
cm_FreeAllACLEnts(scp);
lock_ReleaseMutex(&scp->mx);
}
+
+ if (scp->cbServerp) {
+ cm_PutServer(scp->cbServerp);
+ scp->cbServerp = NULL;
+ }
+ scp->cbExpires = 0;
+ scp->flags &= ~CM_SCACHEFLAG_CALLBACK;
+
lock_FinalizeMutex(&scp->mx);
lock_FinalizeRWLock(&scp->bufCreateLock);
}
+ lock_ReleaseWrite(&cm_scacheLock);
+
+ cm_GiveUpAllCallbacksAllServers();
return cm_dnlcShutdown();
}
if (osi_Once(&once)) {
lock_InitializeRWLock(&cm_scacheLock, "cm_scacheLock");
if ( newFile ) {
- memset(cm_data.hashTablep, 0, sizeof(cm_scache_t *) * cm_data.hashTableSize);
+ memset(cm_data.scacheHashTablep, 0, sizeof(cm_scache_t *) * cm_data.scacheHashTableSize);
+ cm_data.allSCachesp = NULL;
cm_data.currentSCaches = 0;
cm_data.maxSCaches = maxSCaches;
cm_data.scacheLRUFirstp = cm_data.scacheLRULastp = NULL;
} else {
cm_scache_t * scp;
- for ( scp = cm_data.scacheLRULastp; scp;
- scp = (cm_scache_t *) osi_QPrev(&scp->q) ) {
+ for ( scp = cm_data.allSCachesp; scp;
+ scp = scp->allNextp ) {
lock_InitializeMutex(&scp->mx, "cm_scache_t mutex");
lock_InitializeRWLock(&scp->bufCreateLock, "cm_scache_t bufCreateLock");
}
lock_ObtainWrite(&cm_scacheLock);
- for (scp=cm_data.hashTablep[hash]; scp; scp=scp->nextp) {
+ for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
if (cm_FidCmp(fidp, &scp->fid) == 0) {
cm_HoldSCacheNoLock(scp);
- cm_AdjustLRU(scp);
+ cm_AdjustScacheLRU(scp);
lock_ReleaseWrite(&cm_scacheLock);
return scp;
}
// yj: check if we have the scp, if so, we don't need
// to do anything else
lock_ObtainWrite(&cm_scacheLock);
- for (scp=cm_data.hashTablep[hash]; scp; scp=scp->nextp) {
+ for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
if (cm_FidCmp(fidp, &scp->fid) == 0) {
#ifdef DEBUG_REFCOUNT
afsi_log("%s:%d cm_GetSCache (1) outScpp 0x%p ref %d", file, line, scp, scp->refCount);
#endif
cm_HoldSCacheNoLock(scp);
*outScpp = scp;
- cm_AdjustLRU(scp);
+ cm_AdjustScacheLRU(scp);
lock_ReleaseWrite(&cm_scacheLock);
return 0;
}
}
-
+
// yj: when we get here, it means we don't have an scp
// so we need to either load it or fake it, depending
// on whether the file is "special", see below.
scp->dotdotFid.unique=1;
scp->dotdotFid.vnode=1;
scp->flags |= (CM_SCACHEFLAG_PURERO | CM_SCACHEFLAG_RO);
- scp->nextp=cm_data.hashTablep[hash];
- cm_data.hashTablep[hash]=scp;
+ scp->nextp=cm_data.scacheHashTablep[hash];
+ cm_data.scacheHashTablep[hash]=scp;
scp->flags |= CM_SCACHEFLAG_INHASH;
scp->refCount = 1;
osi_Log1(afsd_logp,"cm_GetSCache (freelance) sets refCount to 1 scp 0x%x", scp);
if (!cellp)
return CM_ERROR_NOSUCHCELL;
- code = cm_GetVolumeByID(cellp, fidp->volume, userp, reqp, &volp);
+ code = cm_GetVolumeByID(cellp, fidp->volume, userp, reqp, CM_GETVOL_FLAG_CREATE, &volp);
if (code)
return code;
lock_ObtainWrite(&cm_scacheLock);
/* otherwise, we have the volume, now reverify that the scp doesn't
* exist, and proceed.
*/
- for (scp=cm_data.hashTablep[hash]; scp; scp=scp->nextp) {
+ for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
if (cm_FidCmp(fidp, &scp->fid) == 0) {
#ifdef DEBUG_REFCOUNT
afsi_log("%s:%d cm_GetSCache (3) outScpp 0x%p ref %d", file, line, scp, scp->refCount);
#endif
cm_HoldSCacheNoLock(scp);
osi_assert(scp->volp == volp);
- cm_AdjustLRU(scp);
+ cm_AdjustScacheLRU(scp);
lock_ReleaseWrite(&cm_scacheLock);
if (volp)
cm_PutVolume(volp);
scp->dotdotFid = volp->dotdotFid;
}
- if (volp->roID == fidp->volume)
+ if (volp->ro.ID == fidp->volume)
scp->flags |= (CM_SCACHEFLAG_PURERO | CM_SCACHEFLAG_RO);
- else if (volp->bkID == fidp->volume)
+ else if (volp->bk.ID == fidp->volume)
scp->flags |= CM_SCACHEFLAG_RO;
}
- scp->nextp = cm_data.hashTablep[hash];
- cm_data.hashTablep[hash] = scp;
+ scp->nextp = cm_data.scacheHashTablep[hash];
+ cm_data.scacheHashTablep[hash] = scp;
scp->flags |= CM_SCACHEFLAG_INHASH;
scp->refCount = 1;
osi_Log1(afsd_logp,"cm_GetSCache sets refCount to 1 scp 0x%x", scp);
if (cm_FidCmp(&scp->fid, &parent_fid)) {
i = CM_SCACHE_HASH(&parent_fid);
- for (pscp = cm_data.hashTablep[i]; pscp; pscp = pscp->nextp) {
+ for (pscp = cm_data.scacheHashTablep[i]; pscp; pscp = pscp->nextp) {
if (!cm_FidCmp(&pscp->fid, &parent_fid)) {
cm_HoldSCacheNoLock(pscp);
break;
scp->flags |= CM_SCACHEFLAG_EACCESS;
osi_Log2(afsd_logp, "Merge, Failure scp %x code 0x%x", scp, statusp->errorCode);
+ scp->fileType = 0; /* unknown */
+
scp->serverModTime = 0;
scp->clientModTime = 0;
scp->length.LowPart = 0;
scp->anyAccess = 0;
scp->dataVersion = 0;
- scp->parentVnode = dscp->fid.vnode;
- scp->parentUnique = dscp->fid.unique;
-
+ if (dscp) {
+ scp->parentVnode = dscp->fid.vnode;
+ scp->parentUnique = dscp->fid.unique;
+ } else {
+ scp->parentVnode = 0;
+ scp->parentUnique = 0;
+ }
return;
} else {
scp->flags &= ~CM_SCACHEFLAG_EACCESS;
struct cm_volume *volp = NULL;
cm_GetVolumeByID(cellp, scp->fid.volume, userp,
- (cm_req_t *) NULL, &volp);
+ (cm_req_t *) NULL, CM_GETVOL_FLAG_CREATE, &volp);
osi_Log2(afsd_logp, "old data from server %x volume %s",
scp->cbServerp->addr.sin_addr.s_addr,
volp ? volp->namep : "(unknown)");
osi_assert(fidp->cell != 0);
lock_ObtainWrite(&cm_scacheLock);
- for (scp=cm_data.hashTablep[hash]; scp; scp=scp->nextp) {
+ for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
if (cm_FidCmp(fidp, &scp->fid) == 0) {
lock_ReleaseWrite(&cm_scacheLock);
return scp->fileType;
sprintf(output, "%s - dumping scache - cm_data.currentSCaches=%d, cm_data.maxSCaches=%d\r\n", cookie, cm_data.currentSCaches, cm_data.maxSCaches);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
- for (scp = cm_data.scacheLRULastp; scp; scp = (cm_scache_t *) osi_QPrev(&scp->q))
+ for (scp = cm_data.allSCachesp; scp; scp = scp->allNextp)
{
- if (scp->refCount != 0)
- {
- sprintf(output, "%s scp=0x%p, fid (cell=%d, volume=%d, vnode=%d, unique=%d) refCount=%u\r\n",
- cookie, scp, scp->fid.cell, scp->fid.volume, scp->fid.vnode, scp->fid.unique,
- scp->refCount);
- WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
- }
+ sprintf(output, "%s scp=0x%p, fid (cell=%d, volume=%d, vnode=%d, unique=%d) volp=0x%p flags=0x%x refCount=%u\r\n",
+ cookie, scp, scp->fid.cell, scp->fid.volume, scp->fid.vnode, scp->fid.unique,
+ scp->volp, scp->flags, scp->refCount);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
- sprintf(output, "%s - dumping cm_data.hashTable - cm_data.hashTableSize=%d\r\n", cookie, cm_data.hashTableSize);
+ sprintf(output, "%s - dumping cm_data.hashTable - cm_data.scacheHashTableSize=%d\r\n", cookie, cm_data.scacheHashTableSize);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
- for (i = 0; i < cm_data.hashTableSize; i++)
+ for (i = 0; i < cm_data.scacheHashTableSize; i++)
{
- for(scp = cm_data.hashTablep[i]; scp; scp=scp->nextp)
+ for(scp = cm_data.scacheHashTablep[i]; scp; scp=scp->nextp)
{
- if (scp->refCount != 0)
- {
- sprintf(output, "%s scp=0x%p, hash=%d, fid (cell=%d, volume=%d, vnode=%d, unique=%d) refCount=%u\r\n",
- cookie, scp, i, scp->fid.cell, scp->fid.volume, scp->fid.vnode,
- scp->fid.unique, scp->refCount);
- WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
- }
+ sprintf(output, "%s scp=0x%p, hash=%d, fid (cell=%d, volume=%d, vnode=%d, unique=%d) volp=0x%p flags=0x%x refCount=%u\r\n",
+ cookie, scp, i, scp->fid.cell, scp->fid.volume, scp->fid.vnode,
+ scp->fid.unique, scp->volp, scp->flags, scp->refCount);
+ WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
}
}