windows-remove-give-up-callbacks-scache-recycling-20070627
authorJeffrey Altman <jaltman@secure-endpoints.com>
Thu, 28 Jun 2007 05:10:10 +0000 (05:10 +0000)
committerJeffrey Altman <jaltman@secure-endpoints.com>
Thu, 28 Jun 2007 05:10:10 +0000 (05:10 +0000)
remove the conditionalized code used to give up callbacks in response
to stat cache recycling due to performance impacts described in the
commit for DELTA windows-give-up-callbacks-20070627

src/WINNT/afsd/cm_callback.c
src/WINNT/afsd/cm_callback.h
src/WINNT/afsd/cm_scache.c
src/WINNT/afsd/cm_server.c
src/WINNT/afsd/cm_server.h

index 80bf705..9863ad1 100644 (file)
@@ -204,12 +204,6 @@ void cm_RevokeCallback(struct rx_call *callp, cm_cell_t * cellp, AFSFid *fidp)
             osi_Log4(afsd_logp, "RevokeCallback Discarding SCache scp 0x%p vol %u vn %u uniq %u", 
                      scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
 
-#ifdef GIVE_UP_CALLBACKS
-            lock_ObtainMutex(&scp->cbServerp->mx);
-            cm_RemoveFidFromGiveUpCallBackList(scp->cbServerp, &scp->fid);
-            lock_ReleaseMutex(&scp->cbServerp->mx);
-#endif /* GIVE_UP_CALLBACKS */
-
             lock_ObtainMutex(&scp->mx);
             cm_DiscardSCache(scp);
             lock_ReleaseMutex(&scp->mx);
@@ -258,12 +252,6 @@ void cm_RevokeVolumeCallback(struct rx_call *callp, cm_cell_t *cellp, AFSFid *fi
                 cm_HoldSCacheNoLock(scp);
                 lock_ReleaseWrite(&cm_scacheLock);
 
-#ifdef GIVE_UP_CALLBACKS
-                lock_ObtainMutex(&scp->cbServerp->mx);
-                cm_RemoveFidFromGiveUpCallBackList(scp->cbServerp, &scp->fid);
-                lock_ReleaseMutex(&scp->cbServerp->mx);
-#endif /* GIVE_UP_CALLBACKS */
-
                 lock_ObtainMutex(&scp->mx);
                 osi_Log4(afsd_logp, "RevokeVolumeCallback Discarding SCache scp 0x%p vol %u vn %u uniq %u", 
                           scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
@@ -500,24 +488,9 @@ SRXAFSCB_InitCallBackState(struct rx_call *callp)
            cm_SetServerNo64Bit(tsp, 0);
            cm_SetServerNoInlineBulk(tsp, 0);
 
-#ifdef GIVE_UP_CALLBACKS
-            /* Clear the callbacks list */
-            lock_ObtainMutex(&tsp->mx);
-            cm_FreeGiveUpCallBackList(tsp);
-            lock_ReleaseMutex(&tsp->mx);
-#endif /* GIVE_UP_CALLBACKS */
-
            /* we're done with the server structure */
             cm_PutServer(tsp);
        } 
-#ifdef GIVE_UP_CALLBACKS        
-        else {
-            /* if we didn't recognize the server, we cleared all callbacks 
-             * on all stat scache objects.  So we must clear all of the 
-             * Give Up CallBack lists */
-            cm_FreeAllGiveUpCallBackLists();
-        }
-#endif /* GIVE_UP_CALLBACKS */
     }
     MUTEX_EXIT(&callp->lock);
     return 0;
@@ -1559,9 +1532,6 @@ void cm_EndCallbackGrantingCall(cm_scache_t *scp, cm_callbackRequest_t *cbrp,
     int freeFlag;
     cm_server_t * serverp = NULL;
     int discardScp = 0;
-#ifdef GIVE_UP_CALLBACKS
-    int addFidToGUCB = 0;
-#endif /* GIVE_UP_CALLBACKS */
 
     lock_ObtainWrite(&cm_callbackLock);
     if (flags & CM_CALLBACK_MAINTAINCOUNT) {
@@ -1580,9 +1550,6 @@ void cm_EndCallbackGrantingCall(cm_scache_t *scp, cm_callbackRequest_t *cbrp,
        if (scp) {
             if (scp->cbServerp != cbrp->serverp) {
                 serverp = scp->cbServerp;
-#ifdef GIVE_UP_CALLBACKS
-                addFidToGUCB = 1;
-#endif /* GIVE_UP_CALLBACKS */
                 if (!freeFlag)
                     cm_GetServer(cbrp->serverp);
                 scp->cbServerp = cbrp->serverp;
@@ -1645,22 +1612,8 @@ void cm_EndCallbackGrantingCall(cm_scache_t *scp, cm_callbackRequest_t *cbrp,
         cm_CallbackNotifyChange(scp);
         lock_ObtainMutex(&scp->mx);
     } 
-#ifdef GIVE_UP_CALLBACKS    
-    else if (scp) {
-        lock_ObtainMutex(&scp->cbServerp->mx);
-        cm_RemoveFidFromGiveUpCallBackList(scp->cbServerp, &scp->fid);
-        lock_ReleaseMutex(&scp->cbServerp->mx);
-    }
-#endif /* GIVE_UP_CALLBACKS */
 
     if ( serverp ) {
-#ifdef GIVE_UP_CALLBACKS
-        if (addFidToGUCB) {
-            lock_ObtainMutex(&serverp->mx);
-            cm_AddFidToGiveUpCallBackList(serverp, &scp->fid);
-            lock_ReleaseMutex(&serverp->mx);
-        }
-#endif /* GIVE_UP_CALLBACKS */
         lock_ObtainWrite(&cm_serverLock);
         cm_FreeServer(serverp);
         lock_ReleaseWrite(&cm_serverLock);
@@ -1832,96 +1785,6 @@ void cm_CheckCBExpiration(void)
 }
 
 
-#ifdef GIVE_UP_CALLBACKS
-/* server mutex must be held */
-/* do not hold cm_scacheLock */
-void cm_GiveUpCallBacksToServer(cm_server_t * serverp)
-{
-    struct AFSFid *tfids = NULL;
-    struct AFSCallBack callBacks[1];
-    struct AFSCBFids fidArray;
-    struct AFSCBs cbArray;
-    afs_int32 code = 0;
-    cm_server_gucb_t *gucbp, *nextp;
-    cm_conn_t *connp;
-    struct rx_connection * callp;
-    cm_req_t req;
-    int i, j;
-
-    for ( gucbp = serverp->gucbs, serverp->gucbs = NULL, lock_ReleaseMutex(&serverp->mx); 
-          gucbp; 
-          gucbp = nextp ) 
-    {
-        nextp = gucbp->nextp;
-
-        if (!tfids) {   /* only need to do these once */
-            tfids = (struct AFSFid *)malloc(AFS_MAXCBRSCALL * sizeof(*tfids));
-            osi_Assert(tfids);
-
-            fidArray.AFSCBFids_val = (struct AFSFid *)tfids;
-
-            cbArray.AFSCBs_len = 1;
-            cbArray.AFSCBs_val = callBacks;
-            memset(&callBacks[0], 0, sizeof(callBacks[0]));
-            callBacks[0].CallBackType = CB_EXCLUSIVE;
-        }
-        memset(tfids, 0, AFS_MAXCBRSCALL * sizeof(*tfids));
-
-        for ( i=0, j=0; i<gucbp->count; i++ ) {
-            if (gucbp->fids[i].cell != 0) {
-                cm_AFSFidFromFid(&tfids[j++], &gucbp->fids[i]);
-            }
-        }
-        fidArray.AFSCBFids_len = j;
-
-        cm_InitReq(&req);
-        req.flags |= CM_REQ_NORETRY;
-
-        osi_Log1(afsd_logp, "CALL GiveUpCallbacks serverp %xp", serverp);
-        do {
-            code = cm_ConnByServer(serverp, cm_rootUserp, &connp);
-            if (code) 
-                continue;
-
-            callp = cm_GetRxConn(connp);
-            code = RXAFS_GiveUpCallBacks(callp, &fidArray, &cbArray);
-            rx_PutConnection(callp);
-        } while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
-        code = cm_MapRPCError(code, &req);
-
-        if (code)
-            osi_Log1(afsd_logp, "CALL GiveUpCallback FAILURE, code 0x%x", code);
-        else
-            osi_Log0(afsd_logp, "CALL GiveUpCallback SUCCESS");
-
-        free(gucbp);
-    }
-    lock_ObtainMutex(&serverp->mx);
-}
-
-
-void
-cm_GiveUpCallback(cm_scache_t * scp)
-{
-    time_t now;
-
-    cm_HoldSCacheNoLock(scp);
-    now = osi_Time();
-
-    if (scp->cbExpires > 0 && (scp->cbServerp == NULL || now < scp->cbExpires)) {
-        lock_ObtainMutex(&scp->cbServerp->mx);
-        cm_AddFidToGiveUpCallBackList(scp->cbServerp, &scp->fid);
-        lock_ReleaseMutex(&scp->cbServerp->mx);
-
-        /* assume the callbacks were given up even if we fail */
-        cm_PutServer(scp->cbServerp);
-        scp->cbServerp = NULL;
-        scp->cbExpires = 0;
-    }
-    cm_ReleaseSCacheNoLock(scp);
-}
-#endif /* GIVE_UP_CALLBACKS */
-
 void 
 cm_GiveUpAllCallbacks(cm_server_t *tsp)
 {
@@ -1935,12 +1798,6 @@ cm_GiveUpAllCallbacks(cm_server_t *tsp)
             rxconnp = cm_GetRxConn(connp);
            code = RXAFS_GiveUpAllCallBacks(rxconnp);
            rx_PutConnection(rxconnp);
-
-            lock_ObtainMutex(&tsp->mx);
-#ifdef GIVE_UP_CALLBACKS
-            cm_FreeGiveUpCallBackList(tsp);
-#endif /* GIVE_UP_CALLBACKS */
-            lock_ReleaseMutex(&tsp->mx);
         }
     }
 }
index bb9c735..5df58c7 100644 (file)
@@ -68,14 +68,6 @@ extern osi_rwlock_t cm_callbackLock;
 
 extern void cm_CallbackNotifyChange(cm_scache_t *scp);
 
-#ifdef GIVE_UP_CALLBACKS
-extern void cm_GiveUpCallback(struct cm_scache *);
-
-extern void cm_GiveUpCallBacksToServer(cm_server_t * serverp);
-
-#define AFS_MAXCBRSCALL   16      /* max to return in a given call */
-#endif /* GIVE_UP_CALLBACKS */
-
 extern void cm_GiveUpAllCallbacks(cm_server_t *tsp);
 
 extern void cm_GiveUpAllCallbacksAllServers(void);
index 70b1e22..c116369 100644 (file)
@@ -160,18 +160,11 @@ long cm_RecycleSCache(cm_scache_t *scp, afs_int32 flags)
     scp->bulkStatProgress = hzero;
     scp->waitCount = 0;
 
-#ifdef GIVE_UP_CALLBACKS
-    /* discard callback */
-    if (scp->cbServerp) {
-        cm_GiveUpCallback(scp);
-    }
-#else /* GIVE_UP_CALLBACKS */
     if (scp->cbServerp) {
         cm_PutServer(scp->cbServerp);
         scp->cbServerp = NULL;
     }
     scp->cbExpires = 0;
-#endif /* GIVE_UP_CALLBACKS */
 
     scp->fid.vnode = 0;
     scp->fid.volume = 0;
index ac93fd4..766306c 100644 (file)
@@ -232,17 +232,6 @@ void cm_CheckServers(long flags, cm_cell_t *cellp)
         if (doPing) 
            cm_PingServer(tsp);
 
-#ifdef GIVE_UP_CALLBACKS
-        /* if this is a file server and it is not currently down
-         * give up any callbacks we have queued 
-         */
-        if (isFS && !(tsp->flags & CM_SERVERFLAG_DOWN)) {
-            lock_ObtainMutex(&tsp->mx);
-            cm_GiveUpCallBacksToServer(tsp);
-            lock_ReleaseMutex(&tsp->mx);
-        }
-#endif /* GIVE_UP_CALLBACKS */
-
         /* also, run the GC function for connections on all of the
          * server's connections.
          */
@@ -737,78 +726,3 @@ void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
   
     lock_ReleaseWrite(&cm_serverLock);
 }
-
-#ifdef GIVE_UP_CALLBACKS
-cm_server_gucb_t *cm_NewServerGUCBs(void) {
-    cm_server_gucb_t *gucbp;
-
-    gucbp = malloc(sizeof(*gucbp));
-    if (gucbp)
-        memset(gucbp, 0, sizeof(*gucbp));
-
-    return gucbp;
-}
-
-
-/* server mutex must be held */
-void cm_AddFidToGiveUpCallBackList(cm_server_t * serverp, cm_fid_t *fidp) {
-    cm_server_gucb_t ** gucbpp;
-
-    for ( gucbpp = &serverp->gucbs; *gucbpp; gucbpp = &(*gucbpp)->nextp ) {
-        if ((*gucbpp)->count < AFS_MAXCBRSCALL) {
-            (*gucbpp)->fids[(*gucbpp)->count] = *fidp;
-            (*gucbpp)->count++;
-            return;
-        }
-    }
-
-    /* if we get here all of the allocated pages are full */
-    (*gucbpp) = cm_NewServerGUCBs();
-    if (*gucbpp) {
-        (*gucbpp)->fids[0] = *fidp;
-        (*gucbpp)->count = 1;
-    }
-}
-
-/* server mutex must be held */
-void cm_RemoveFidFromGiveUpCallBackList(cm_server_t *serverp, cm_fid_t *fidp) {
-    cm_server_gucb_t *gucbp;
-    int i;
-
-    for ( gucbp = serverp->gucbs; gucbp; gucbp = gucbp->nextp ) {
-        for ( i=0; i < gucbp->count; i++ ) {
-            if (cm_FidCmp(&gucbp->fids[i], fidp) == 0) {
-                /* invalidate this entry.  we will skip over it later */
-                gucbp->fids[i].cell = 0;
-                break;
-            }
-        }
-    }
-}
-
-/* server mutex must be held */
-void cm_FreeGiveUpCallBackList(cm_server_t * serverp)
-{
-    cm_server_gucb_t *gucbp, *nextp;
-
-    for ( gucbp = serverp->gucbs, serverp->gucbs = NULL; gucbp; gucbp = nextp ) {
-        nextp = gucbp->nextp;
-        free(gucbp);
-    }
-}
-
-void cm_FreeAllGiveUpCallBackLists(void)
-{
-    cm_server_t *tsp;
-
-    lock_ObtainRead(&cm_serverLock);
-    for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
-        if (tsp->type == CM_SERVER_FILE && tsp->gucbs != NULL) {
-            lock_ObtainMutex(&tsp->mx);
-            cm_FreeGiveUpCallBackList(tsp);
-            lock_ReleaseMutex(&tsp->mx);
-        }
-    }
-    lock_ReleaseRead(&cm_serverLock);
-}
-#endif /* GIVE_UP_CALLBACKS */
index 5e8ad39..53d0442 100644 (file)
@@ -20,15 +20,6 @@ typedef struct cm_server_vols {
     struct cm_server_vols *nextp;
 } cm_server_vols_t;
 
-#ifdef GIVE_UP_CALLBACKS
-#define AFS_MAXCBRSCALL 16
-typedef struct cm_server_gucb {
-    afs_uint32          count;
-    cm_fid_t            fids[AFS_MAXCBRSCALL];
-    struct cm_server_gucb * nextp;
-} cm_server_gucb_t;
-#endif /* GIVE_UP_CALLBACKS */
-
 /* pointed to by volumes and cells without holds; cm_serverLock is obtained
  * at the appropriate times to change the pointers to these servers.
  */
@@ -45,9 +36,6 @@ typedef struct cm_server {
     osi_mutex_t mx;
     unsigned short ipRank;             /* server priority */
     cm_server_vols_t *  vols;           /* by mx */
-#ifdef GIVE_UP_CALLBACKS
-    cm_server_gucb_t *  gucbs;          /* by mx */
-#endif /* GIVE_UP_CALLBACKS */
 } cm_server_t;
 
 enum repstate {srv_not_busy, srv_busy, srv_offline, srv_deleted};
@@ -135,15 +123,4 @@ extern void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no);
 
 extern cm_server_t * cm_FindServerByIP(afs_uint32 addr, int type);
 
-#ifdef GIVE_UP_CALLBACKS
-extern cm_server_gucb_t *cm_NewServerGUCBs(void);
-
-extern void cm_AddFidToGiveUpCallBackList(cm_server_t * serverp, cm_fid_t *fidp);
-
-extern void cm_RemoveFidFromGiveUpCallBackList(cm_server_t *serverp, cm_fid_t *fidp);
-
-extern void cm_FreeGiveUpCallBackList(cm_server_t * serverp);
-
-extern void cm_FreeAllGiveUpCallBackLists(void);
-#endif /* GIVE_UP_CALLBACKS */
 #endif /*  __CM_SERVER_H_ENV__ */