windows-inlinebulkstat-20060627
authorJeffrey Altman <jaltman@secure-endpoints.com>
Wed, 28 Jun 2006 04:22:40 +0000 (04:22 +0000)
committerJeffrey Altman <jaltman@secure-endpoints.com>
Wed, 28 Jun 2006 04:22:40 +0000 (04:22 +0000)
Activate previously implemented TryBulkStat code.  Due to incorrect
comparisons the code was never executed.  Add support for InlineBulkStat
with fallback to BulkStat and increase the size of CM_BULKMAX to 150.
(3 * AFSCBMAX)

Add CM_SERVERFLAG_NOINLINEBULK to track support for InlineBulkStat.
Clear flag during InitCallbackState.

src/WINNT/afsd/cm_callback.c
src/WINNT/afsd/cm_scache.c
src/WINNT/afsd/cm_server.c
src/WINNT/afsd/cm_server.h
src/WINNT/afsd/cm_vnodeops.c
src/WINNT/afsd/cm_vnodeops.h
src/WINNT/afsd/smb.c
src/WINNT/afsd/smb3.c

index ab4cf35..5e52b53 100644 (file)
@@ -476,8 +476,9 @@ SRXAFSCB_InitCallBackState(struct rx_call *callp)
        lock_ReleaseWrite(&cm_scacheLock);
        
        if (tsp) {
-           /* reset the No 64-bit flag on the server */
+           /* reset the No flags on the server */
            cm_SetServerNo64Bit(tsp, 0);
+           cm_SetServerNoInlineBulk(tsp, 0);
 
            /* we're done with the server structure */
             cm_PutServer(tsp);
@@ -1692,7 +1693,7 @@ long cm_GetCallback(cm_scache_t *scp, struct cm_user *userp,
                
         /* now make the RPC */
         osi_Log4(afsd_logp, "CALL FetchStatus scp 0x%p vol %u vn %u uniq %u", 
-                 scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
+                 scp, sfid.volume, sfid.vnode, sfid.unique);
         do {
             code = cm_Conn(&sfid, userp, reqp, &connp);
             if (code) 
index 409e3b3..fd34ccd 100644 (file)
@@ -1245,7 +1245,7 @@ void cm_MergeStatus(cm_scache_t *scp, AFSFetchStatus *statusp, AFSVolSync *volp,
             scp->fileType = CM_SCACHETYPE_SYMLINK;
     }       
     else {
-        osi_Log1(afsd_logp, "Merge, Invalid File Type, scp %x", scp);
+        osi_Log2(afsd_logp, "Merge, Invalid File Type (%d), scp %x", statusp->FileType, scp);
         scp->fileType = CM_SCACHETYPE_INVALID; /* invalid */
     }
     /* and other stuff */
index 84a69af..f04aec9 100644 (file)
@@ -236,6 +236,16 @@ void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
     lock_ReleaseMutex(&serverp->mx);
 }
 
+void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
+{
+    lock_ObtainMutex(&serverp->mx);
+    if (no)
+        serverp->flags |= CM_SERVERFLAG_NOINLINEBULK;
+    else
+        serverp->flags &= ~CM_SERVERFLAG_NOINLINEBULK;
+    lock_ReleaseMutex(&serverp->mx);
+}
+
 void cm_SetServerPrefs(cm_server_t * serverp)
 {
     unsigned long      serverAddr;     /* in host byte order */
index ba672ba..611082c 100644 (file)
@@ -48,11 +48,12 @@ typedef struct cm_serverRef {
 #define CM_SERVER_FILE         2       /* a file server */
 
 /* flags */
-#define CM_SERVERFLAG_DOWN     1       /* server is down */
-#define CM_SERVERFLAG_PREF_SET 2       /* server preference set by user */
-#define CM_SERVERFLAG_PINGING  4       /* a ping against this server in progress */
-#define CM_SERVERFLAG_NO64BIT   8       /* server has no support for
+#define CM_SERVERFLAG_DOWN     0x1     /* server is down */
+#define CM_SERVERFLAG_PREF_SET 0x2     /* server preference set by user */
+#define CM_SERVERFLAG_PINGING  0x4     /* a ping against this server in progress */
+#define CM_SERVERFLAG_NO64BIT   0x8     /* server has no support for
                                            64-bit operations. */
+#define CM_SERVERFLAG_NOINLINEBULK 0x10        /* server has no support for inline bulk */
 
 /* flags for procedures */
 #define CM_FLAG_CHECKUPSERVERS         1       /* check working servers */
@@ -109,4 +110,6 @@ extern void cm_ForceNewConnectionsAllServers(void);
 
 extern void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit);
 
+extern void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no);
+
 #endif /*  __CM_SERVER_H_ENV__ */
index 2d6da55..6ede512 100644 (file)
@@ -673,7 +673,7 @@ long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp,
                  && (scp->bulkStatProgress.QuadPart <= thyper.QuadPart))
             {
                 scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
-                cm_TryBulkStat(scp, &thyper, userp, reqp);
+                code = cm_TryBulkStat(scp, &thyper, userp, reqp);
                 scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
                 scp->bulkStatProgress = thyper;
             }
@@ -1780,7 +1780,7 @@ long cm_EvaluateSymLink(cm_scache_t *dscp, cm_scache_t *linkScp,
  * check anyway, but we want to minimize the chance that we have to leave stuff
  * unstat'd.
  */
-#define CM_BULKMAX             128
+#define CM_BULKMAX             (3 * AFSCBMAX)
 
 /* rock for bulk stat calls */
 typedef struct cm_bulkStat {
@@ -1878,11 +1878,12 @@ long cm_TryBulkProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
 /* called with a locked scp and a pointer to a buffer.  Make bulk stat
  * calls on all undeleted files in the page of the directory specified.
  */
-void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
-                     cm_req_t *reqp)
+afs_int32
+cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
+              cm_req_t *reqp)
 {
     long code;
-    cm_bulkStat_t bb;  /* this is *BIG*, probably 12K or so;
+    cm_bulkStat_t bb;  /* this is *BIG*, probably 16K or so;
                          * watch for stack problems */
     AFSCBFids fidStruct;
     AFSBulkStats statStruct;
@@ -1897,13 +1898,14 @@ void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
     cm_scache_t *scp;
     cm_fid_t tfid;
     struct rx_connection * callp;
+    int inlinebulk = 0;                /* Did we use InlineBulkStatus RPC or not? */
 
     osi_Log1(afsd_logp, "cm_TryBulkStat dir 0x%p", dscp);
 
     /* should be on a buffer boundary */
     osi_assert((offsetp->LowPart & (cm_data.buf_blockSize - 1)) == 0);
 
-    bb.counter = 0;
+    memset(&bb, 0, sizeof(bb));
     bb.bufOffset = *offsetp;
 
     lock_ReleaseMutex(&dscp->mx);
@@ -1913,7 +1915,7 @@ void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
     /* if we failed, bail out early */
     if (code && code != CM_ERROR_STOPNOW) {
         lock_ObtainMutex(&dscp->mx);
-        return;
+        return code;
     }
 
     /* otherwise, we may have one or more bulk stat's worth of stuff in bb;
@@ -1940,18 +1942,29 @@ void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
                 continue;
 
             callp = cm_GetRxConn(connp);
-            code = RXAFS_BulkStatus(callp, &fidStruct,
+           if (!(connp->serverp->flags & CM_SERVERFLAG_NOINLINEBULK)) {
+               code = RXAFS_InlineBulkStatus(callp, &fidStruct,
                                      &statStruct, &callbackStruct, &volSync);
+               if (code == RXGEN_OPCODE) {
+                   cm_SetServerNoInlineBulk(connp->serverp, 0);
+               } else {
+                   inlinebulk = 1;
+               }
+           }
+           if (!inlinebulk) {
+               code = RXAFS_BulkStatus(callp, &fidStruct,
+                                       &statStruct, &callbackStruct, &volSync);
+           }
             rx_PutConnection(callp);
 
         } while (cm_Analyze(connp, userp, reqp, &dscp->fid,
                              &volSync, NULL, &cbReq, code));
         code = cm_MapRPCError(code, reqp);
-
         if (code)
-            osi_Log1(afsd_logp, "CALL BulkStatus FAILURE code 0x%x", code);
+            osi_Log2(afsd_logp, "CALL %sBulkStatus FAILURE code 0x%x", 
+                     inlinebulk ? "Inline" : "", code);
         else
-            osi_Log0(afsd_logp, "CALL BulkStatus SUCCESS");
+            osi_Log1(afsd_logp, "CALL %sBulkStatus SUCCESS", inlinebulk ? "Inline" : "");
 
         /* may as well quit on an error, since we're not going to do
          * much better on the next immediate call, either.
@@ -1994,8 +2007,7 @@ void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
                 cm_EndCallbackGrantingCall(scp, &cbReq,
                                             &bb.callbacks[j],
                                             CM_CALLBACK_MAINTAINCOUNT);
-                cm_MergeStatus(scp, &bb.stats[j], &volSync,
-                                userp, 0);
+                cm_MergeStatus(scp, &bb.stats[j], &volSync, userp, 0);
             }       
             lock_ReleaseMutex(&scp->mx);
             cm_ReleaseSCache(scp);
@@ -2007,7 +2019,20 @@ void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
         filex += filesThisCall;
     }  /* while there are still more files to process */
     lock_ObtainMutex(&dscp->mx);
-    osi_Log0(afsd_logp, "END cm_TryBulkStat");
+
+    /* If we did the InlineBulk RPC pull out the return code */
+    if (inlinebulk) {
+       if ((&bb.stats[0])->errorCode) {
+           cm_Analyze(NULL /*connp was released by the previous cm_Analyze */, 
+                       userp, reqp, &dscp->fid, &volSync, NULL, NULL, (&bb.stats[0])->errorCode);
+           code = cm_MapRPCError((&bb.stats[0])->errorCode, reqp);
+       }
+    } else { 
+       code = 0;
+    }
+
+    osi_Log1(afsd_logp, "END cm_TryBulkStat code = 0x%x", code);
+    return code;
 }       
 
 void cm_StatusFromAttr(AFSStoreStatus *statusp, cm_scache_t *scp, cm_attr_t *attrp)
index 2d9de36..ababc1b 100644 (file)
@@ -76,7 +76,7 @@ extern long cm_LookupInternal(cm_scache_t *dscp, char *namep, long flags,
                               cm_user_t *userp, cm_req_t *reqp, 
                               cm_scache_t **outpScpp);
 
-extern void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp,
+extern afs_int32 cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp,
        cm_user_t *userp, cm_req_t *reqp);
 
 extern long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp,
index 3af0993..0f76c56 100644 (file)
@@ -1965,7 +1965,7 @@ void smb_DeleteDirSearch(smb_dirSearch_t *dsp)
         if (dsp->flags & SMB_DIRSEARCH_BULKST) {
             dsp->flags &= ~SMB_DIRSEARCH_BULKST;
             dsp->scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
-            dsp->scp->bulkStatProgress = hones;
+            dsp->scp->bulkStatProgress = hzero;
         }      
         lock_ReleaseMutex(&dsp->scp->mx);
     }  
@@ -4122,6 +4122,7 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou
                  && LargeIntegerGreaterOrEqualToZero(scp->bulkStatProgress)) {
                 scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
                 dsp->flags |= SMB_DIRSEARCH_BULKST;
+               dsp->scp->bulkStatProgress = hzero;
             }
             lock_ReleaseMutex(&scp->mx);
         }
@@ -4229,12 +4230,13 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou
                                                       scp->bulkStatProgress)) {
                     /* Don't bulk stat if risking timeout */
                     int now = GetTickCount();
-                    if (now - req.startTime > 5000) {
+                    if (now - req.startTime < 5000) {
                         scp->bulkStatProgress = thyper;
                         scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
                         dsp->flags &= ~SMB_DIRSEARCH_BULKST;
+                       dsp->scp->bulkStatProgress = hzero;
                     } else
-                        cm_TryBulkStat(scp, &thyper, userp, &req);
+                        code = cm_TryBulkStat(scp, &thyper, userp, &req);
                 }
             } else {
                 lock_ObtainMutex(&scp->mx);
index e1d2d3d..d6ab708 100644 (file)
@@ -4146,12 +4146,12 @@ long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t
                     LargeIntegerGreaterThanOrEqualTo(thyper, scp->bulkStatProgress)) {
                     /* Don't bulk stat if risking timeout */
                     int now = GetTickCount();
-                    if (now - req.startTime > 5000) {
+                    if (now - req.startTime < 5000) {
                         scp->bulkStatProgress = thyper;
                         scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
                         dsp->flags &= ~SMB_DIRSEARCH_BULKST;
                     } else
-                        cm_TryBulkStat(scp, &thyper, userp, &req);
+                        code = cm_TryBulkStat(scp, &thyper, userp, &req);
                 }
             } else {
                 lock_ObtainMutex(&scp->mx);