afs: Add xvcache-related afs_FlushVCache comments

[openafs.git] / src / afs / afs_vcache.c

diff --git a/src/afs/afs_vcache.c b/src/afs/afs_vcache.c
index 281b79d..45cde7f 100644 (file)
--- a/src/afs/afs_vcache.c
+++ b/src/afs/afs_vcache.c
@@ -138,12 +138,16 @@ afs_FlushVCache(struct vcache *avc, int *slept)
     afs_int32 i, code;
     struct vcache **uvc, *wvc;
 
+    /* NOTE: We must have nothing drop afs_xvcache until we have removed all
+     * possible references to this vcache. This means all hash tables, queues,
+     * DNLC, etc. */
+
     *slept = 0;
     AFS_STATCNT(afs_FlushVCache);
     afs_Trace2(afs_iclSetp, CM_TRACE_FLUSHV, ICL_TYPE_POINTER, avc,
               ICL_TYPE_INT32, avc->f.states);
 
-    code = osi_VM_FlushVCache(avc, slept);
+    code = osi_VM_FlushVCache(avc);
     if (code)
        goto bad;
 
@@ -214,6 +218,10 @@ afs_FlushVCache(struct vcache *avc, int *slept)
     else
        osi_dnlc_purgevp(avc);
 
+    /* By this point, the vcache has been removed from all global structures
+     * via which someone could try to use the vcache. It is okay to drop
+     * afs_xvcache at this point (if *slept is set). */
+
     if (!afs_shuttingdown)
        afs_QueueVCB(avc, slept);
 
@@ -403,7 +411,7 @@ afs_FlushVCBs(afs_int32 lockit)
     int tcount;
     struct server *tsp;
     int i;
-    struct vrequest treq;
+    struct vrequest *treq = NULL;
     struct afs_conn *tc;
     int safety1, safety2, safety3;
     XSTATS_DECLS;
@@ -411,9 +419,9 @@ afs_FlushVCBs(afs_int32 lockit)
     if (AFS_IS_DISCONNECTED)
        return ENETDOWN;
 
-    if ((code = afs_InitReq(&treq, afs_osi_credp)))
+    if ((code = afs_CreateReq(&treq, afs_osi_credp)))
        return code;
-    treq.flags |= O_NONBLOCK;
+    treq->flags |= O_NONBLOCK;
     tfids = afs_osi_Alloc(sizeof(struct AFSFid) * AFS_MAXCBRSCALL);
     osi_Assert(tfids != NULL);
 
@@ -456,7 +464,7 @@ afs_FlushVCBs(afs_int32 lockit)
                    callBacks[0].CallBackType = CB_EXCLUSIVE;
                    for (safety3 = 0; safety3 < AFS_MAXHOSTS * 2; safety3++) {
                        tc = afs_ConnByHost(tsp, tsp->cell->fsport,
-                                           tsp->cell->cellNum, &treq, 0,
+                                           tsp->cell->cellNum, treq, 0,
                                            SHARED_LOCK, 0, &rxconn);
                        if (tc) {
                            XSTATS_START_TIME
@@ -470,7 +478,7 @@ afs_FlushVCBs(afs_int32 lockit)
                        } else
                            code = -1;
                        if (!afs_Analyze
-                           (tc, rxconn, code, 0, &treq,
+                           (tc, rxconn, code, 0, treq,
                             AFS_STATS_FS_RPCIDX_GIVEUPCALLBACKS, SHARED_LOCK,
                             tsp->cell)) {
                            break;
@@ -515,6 +523,7 @@ afs_FlushVCBs(afs_int32 lockit)
     if (lockit)
        ReleaseWriteLock(&afs_xvcb);
     afs_osi_Free(tfids, sizeof(struct AFSFid) * AFS_MAXCBRSCALL);
+    afs_DestroyReq(treq);
     return 0;
 }
 
@@ -994,11 +1003,18 @@ afs_FlushActiveVcaches(afs_int32 doflocks)
     struct afs_conn *tc;
     afs_int32 code;
     afs_ucred_t *cred = NULL;
-    struct vrequest treq, ureq;
+    struct vrequest *treq = NULL;
     struct AFSVolSync tsync;
     int didCore;
     XSTATS_DECLS;
     AFS_STATCNT(afs_FlushActiveVcaches);
+
+    code = afs_CreateReq(&treq, afs_osi_credp);
+    if (code) {
+       afs_warn("unable to alloc treq\n");
+       return;
+    }
+
     ObtainReadLock(&afs_xvcache);
     for (i = 0; i < VCSIZE; i++) {
        for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
@@ -1015,14 +1031,14 @@ afs_FlushActiveVcaches(afs_int32 doflocks)
                ReleaseReadLock(&afs_xvcache);
                ObtainWriteLock(&tvc->lock, 51);
                do {
-                   code = afs_InitReq(&treq, afs_osi_credp);
+                   code = afs_InitReq(treq, afs_osi_credp);
                    if (code) {
                        code = -1;
                        break; /* shutting down: do not try to extend the lock */
                    }
-                   treq.flags |= O_NONBLOCK;
+                   treq->flags |= O_NONBLOCK;
 
-                   tc = afs_Conn(&tvc->f.fid, &treq, SHARED_LOCK, &rxconn);
+                   tc = afs_Conn(&tvc->f.fid, treq, SHARED_LOCK, &rxconn);
                    if (tc) {
                        XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_EXTENDLOCK);
                        RX_AFS_GUNLOCK();
@@ -1035,7 +1051,7 @@ afs_FlushActiveVcaches(afs_int32 doflocks)
                    } else
                        code = -1;
                } while (afs_Analyze
-                        (tc, rxconn, code, &tvc->f.fid, &treq,
+                        (tc, rxconn, code, &tvc->f.fid, treq,
                          AFS_STATS_FS_RPCIDX_EXTENDLOCK, SHARED_LOCK, NULL));
 
                ReleaseWriteLock(&tvc->lock);
@@ -1056,9 +1072,6 @@ afs_FlushActiveVcaches(afs_int32 doflocks)
                 */
                osi_vnhold(tvc, 0);
                ReleaseReadLock(&afs_xvcache);
-#ifdef AFS_BOZONLOCK_ENV
-               afs_BozonLock(&tvc->pvnLock, tvc);
-#endif
 #if defined(AFS_SGI_ENV)
                /*
                 * That's because if we come in via the CUnlinkedDel bit state path we'll be have 0 refcnt
@@ -1072,17 +1085,14 @@ afs_FlushActiveVcaches(afs_int32 doflocks)
                    /* XXXX Find better place-holder for cred XXXX */
                    cred = (afs_ucred_t *)tvc->linkData;
                    tvc->linkData = NULL;       /* XXX */
-                   code = afs_InitReq(&ureq, cred);
+                   code = afs_InitReq(treq, cred);
                    afs_Trace2(afs_iclSetp, CM_TRACE_ACTCCORE,
                               ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
                               tvc->execsOrWriters);
                    if (!code) {  /* avoid store when shutting down */
-                       code = afs_StoreOnLastReference(tvc, &ureq);
+                       code = afs_StoreOnLastReference(tvc, treq);
                    }
                    ReleaseWriteLock(&tvc->lock);
-#ifdef AFS_BOZONLOCK_ENV
-                   afs_BozonUnlock(&tvc->pvnLock, tvc);
-#endif
                    hzero(tvc->flushDV);
                    osi_FlushText(tvc);
                    didCore = 1;
@@ -1095,9 +1105,6 @@ afs_FlushActiveVcaches(afs_int32 doflocks)
                     * Ignore errors
                     */
                    ReleaseWriteLock(&tvc->lock);
-#ifdef AFS_BOZONLOCK_ENV
-                   afs_BozonUnlock(&tvc->pvnLock, tvc);
-#endif
 #if defined(AFS_SGI_ENV)
                    AFS_RWUNLOCK((vnode_t *) tvc, VRWLOCK_WRITE);
 #endif
@@ -1108,9 +1115,6 @@ afs_FlushActiveVcaches(afs_int32 doflocks)
                } else {
                    /* lost (or won, perhaps) the race condition */
                    ReleaseWriteLock(&tvc->lock);
-#ifdef AFS_BOZONLOCK_ENV
-                   afs_BozonUnlock(&tvc->pvnLock, tvc);
-#endif
                }
 #if defined(AFS_SGI_ENV)
                AFS_RWUNLOCK((vnode_t *) tvc, VRWLOCK_WRITE);
@@ -1136,6 +1140,7 @@ afs_FlushActiveVcaches(afs_int32 doflocks)
        }
     }
     ReleaseReadLock(&afs_xvcache);
+    afs_DestroyReq(treq);
 }