git://git.openafs.org / openafs.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw
Windows: Call CcDeferWrite rather than loop
[openafs.git] / src / WINNT / afsrdr / kernel / lib / AFSWrite.cpp
diff --git a/src/WINNT/afsrdr/kernel/lib/AFSWrite.cpp b/src/WINNT/afsrdr/kernel/lib/AFSWrite.cpp
index 75bbe8e..05bf857 100644 (file)
--- a/src/WINNT/afsrdr/kernel/lib/AFSWrite.cpp
+++ b/src/WINNT/afsrdr/kernel/lib/AFSWrite.cpp
@@ -80,7 +80,7 @@ AFSWrite( IN PDEVICE_OBJECT LibDeviceObject,
     __try
     {
 
-        ntStatus = AFSCommonWrite( AFSRDRDeviceObject, Irp, NULL);
+        ntStatus = AFSCommonWrite( AFSRDRDeviceObject, Irp, NULL, FALSE);
     }
     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
     {
@@ -94,7 +94,8 @@ AFSWrite( IN PDEVICE_OBJECT LibDeviceObject,
 NTSTATUS
 AFSCommonWrite( IN PDEVICE_OBJECT DeviceObject,
                 IN PIRP Irp,
-                IN HANDLE OnBehalfOf)
+                IN HANDLE OnBehalfOf,
+                IN BOOLEAN bRetry)
 {
 
     NTSTATUS           ntStatus = STATUS_SUCCESS;
@@ -115,7 +116,6 @@ AFSCommonWrite( IN PDEVICE_OBJECT DeviceObject,
     BOOLEAN            bCompleteIrp = TRUE;
     BOOLEAN            bLockOK;
     HANDLE             hCallingUser = OnBehalfOf;
-    BOOLEAN            bRetry = FALSE;
     ULONGLONG          ullProcessId = (ULONGLONG)PsGetCurrentProcessId();
 
     pIrpSp = IoGetCurrentIrpStackLocation( Irp);
@@ -335,85 +335,105 @@ AFSCommonWrite( IN PDEVICE_OBJECT DeviceObject,
             bNonCachedIo = FALSE;
         }
 
-        if ( !bNonCachedIo) {
+        if ( !bNonCachedIo && !bPagingIo)
+        {
 
-            if( !bPagingIo)
+            if( pFileObject->PrivateCacheMap == NULL)
             {
 
-                if( pFileObject->PrivateCacheMap == NULL)
+                AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+                              AFS_TRACE_LEVEL_VERBOSE,
+                              "AFSCommonWrite Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+                              &pNPFcb->SectionObjectResource,
+                              PsGetCurrentThread());
+
+                AFSAcquireExcl( &pNPFcb->SectionObjectResource,
+                                TRUE);
+
+                bReleaseSectionObject = TRUE;
+
+                __try
                 {
 
-                    AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+                    AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
                                   AFS_TRACE_LEVEL_VERBOSE,
-                                  "AFSCommonWrite Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
-                                  &pNPFcb->SectionObjectResource,
-                                  PsGetCurrentThread());
+                                  "AFSCommonWrite Initialize caching on Fcb %p FileObject %p\n",
+                                  pFcb,
+                                  pFileObject);
 
-                    AFSAcquireExcl( &pNPFcb->SectionObjectResource,
-                                    TRUE);
+                    CcInitializeCacheMap( pFileObject,
+                                          (PCC_FILE_SIZES)&pFcb->Header.AllocationSize,
+                                          FALSE,
+                                          AFSLibCacheManagerCallbacks,
+                                          pFcb);
 
-                    bReleaseSectionObject = TRUE;
+                    CcSetReadAheadGranularity( pFileObject,
+                                               pDeviceExt->Specific.RDR.MaximumRPCLength);
 
-                    __try
-                    {
+                    CcSetDirtyPageThreshold( pFileObject,
+                                             AFS_DIRTY_CHUNK_THRESHOLD * pDeviceExt->Specific.RDR.MaximumRPCLength / 4096);
+                }
+                __except( EXCEPTION_EXECUTE_HANDLER)
+                {
 
-                        AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
-                                      AFS_TRACE_LEVEL_VERBOSE,
-                                      "AFSCommonWrite Initialize caching on Fcb %p FileObject %p\n",
-                                      pFcb,
-                                      pFileObject);
+                    ntStatus = GetExceptionCode();
 
-                        CcInitializeCacheMap( pFileObject,
-                                              (PCC_FILE_SIZES)&pFcb->Header.AllocationSize,
-                                              FALSE,
-                                              AFSLibCacheManagerCallbacks,
-                                              pFcb);
+                    AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+                                  AFS_TRACE_LEVEL_ERROR,
+                                  "AFSCommonWrite (%p) Exception thrown while initializing cache map Status %08lX\n",
+                                  Irp,
+                                  ntStatus);
+                }
 
-                        CcSetReadAheadGranularity( pFileObject,
-                                                   pDeviceExt->Specific.RDR.MaximumRPCLength);
+                AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+                              AFS_TRACE_LEVEL_VERBOSE,
+                              "AFSCommonWrite Releasing Fcb SectionObject lock %p EXCL %08lX\n",
+                              &pNPFcb->SectionObjectResource,
+                              PsGetCurrentThread());
 
-                        CcSetDirtyPageThreshold( pFileObject,
-                                                 AFS_DIRTY_CHUNK_THRESHOLD * pDeviceExt->Specific.RDR.MaximumRPCLength);
-                    }
-                    __except( EXCEPTION_EXECUTE_HANDLER)
-                    {
+                AFSReleaseResource( &pNPFcb->SectionObjectResource);
 
-                        ntStatus = GetExceptionCode();
+                bReleaseSectionObject = FALSE;
 
-                        AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
-                                      AFS_TRACE_LEVEL_ERROR,
-                                      "AFSCommonWrite (%p) Exception thrown while initializing cache map Status %08lX\n",
-                                      Irp,
-                                      ntStatus);
-                    }
+                if( !NT_SUCCESS( ntStatus))
+                {
 
-                    AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
-                                  AFS_TRACE_LEVEL_VERBOSE,
-                                  "AFSCommonWrite Releasing Fcb SectionObject lock %p EXCL %08lX\n",
-                                  &pNPFcb->SectionObjectResource,
-                                  PsGetCurrentThread());
+                    try_return( ntStatus);
+                }
+            }
 
-                    AFSReleaseResource( &pNPFcb->SectionObjectResource);
+            if (!CcCanIWrite( pFileObject,
+                              ulByteCount,
+                              FALSE,
+                              bRetry))
+            {
 
-                    bReleaseSectionObject = FALSE;
+                AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+                              AFS_TRACE_LEVEL_WARNING,
+                              "AFSCommonWrite (FO: %p) CcCanIWrite says No room for Offset %0I64X Length %08lX bytes! Deferring%s\n",
+                              pFileObject,
+                              liStartingByte.QuadPart,
+                              ulByteCount,
+                              bRetry ? " RETRY" : "");
 
+                ntStatus = AFSDeferWrite( DeviceObject, pFileObject, hCallingUser, Irp, ulByteCount, bRetry);
 
-                    if( !NT_SUCCESS( ntStatus))
-                    {
+                if ( STATUS_PENDING == ntStatus)
+                {
 
-                        try_return( ntStatus);
-                    }
+                    bCompleteIrp = FALSE;
                 }
-            }
+                else
+                {
 
-            while (!CcCanIWrite( pFileObject,
-                                 ulByteCount,
-                                 FALSE,
-                                 bRetry))
-            {
-                static const LONGLONG llWriteDelay = (LONGLONG)-100000;
-                bRetry = TRUE;
-                KeDelayExecutionThread(KernelMode, FALSE, (PLARGE_INTEGER)&llWriteDelay);
+                    AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+                                  AFS_TRACE_LEVEL_ERROR,
+                                  "AFSCommonWrite (FO: %p) AFSDeferWrite failure Status %08lX\n",
+                                  pFileObject,
+                                  ntStatus);
+                }
+
+                try_return( ntStatus);
             }
         }
 
@@ -626,10 +646,11 @@ AFSCommonWrite( IN PDEVICE_OBJECT DeviceObject,
 
             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
                           AFS_TRACE_LEVEL_VERBOSE,
-                          "AFSCommonWrite (%p) Processing CACHED request Offset %I64X Len %08lX\n",
+                          "AFSCommonWrite (%p) Processing CACHED request Offset %0I64X Len %08lX%s\n",
                           Irp,
                           liStartingByte.QuadPart,
-                          ulByteCount);
+                          ulByteCount,
+                          bRetry ? " RETRY" : "");
 
             ntStatus = AFSCachedWrite( DeviceObject, Irp, liStartingByte, ulByteCount, TRUE);
 
@@ -668,10 +689,11 @@ AFSCommonWrite( IN PDEVICE_OBJECT DeviceObject,
 
             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
                           AFS_TRACE_LEVEL_VERBOSE,
-                          "AFSCommonWrite (%p) Processing NON-CACHED request Offset %I64X Len %08lX\n",
+                          "AFSCommonWrite (%p) Processing NON-CACHED request Offset %0I64X Len %08lX%s\n",
                           Irp,
                           liStartingByte.QuadPart,
-                          ulByteCount);
+                          ulByteCount,
+                          bRetry ? " RETRY" : "");
 
             ntStatus = AFSNonCachedWrite( DeviceObject, Irp,  liStartingByte, ulByteCount);
         }
@@ -766,14 +788,14 @@ AFSIOCtlWrite( IN PDEVICE_OBJECT DeviceObject,
         RtlZeroMemory( &stParentFID,
                        sizeof( AFSFileID));
 
-        if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
+        if( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
         {
 
             //
             // The parent directory FID of the node
             //
 
-            stParentFID = pFcb->ObjectInformation->ParentObjectInformation->FileId;
+            stParentFID = pFcb->ObjectInformation->ParentFileId;
         }
 
         //
@@ -815,6 +837,8 @@ AFSIOCtlWrite( IN PDEVICE_OBJECT DeviceObject,
                                       &pCcb->AuthGroup,
                                       NULL,
                                       &stParentFID,
+                                      NULL,
+                                      0,
                                       (void *)&stIORequestCB,
                                       sizeof( AFSPIOCtlIORequestCB),
                                       &stIOResultCB,
@@ -892,6 +916,14 @@ AFSNonCachedWrite( IN PDEVICE_OBJECT DeviceObject,
     {
         Irp->IoStatus.Information = 0;
 
+        AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+                      AFS_TRACE_LEVEL_VERBOSE,
+                      "AFSNonCachedWrite (FO: %p) StartingByte %08lX:%08lX Length %08lX\n",
+                      pFileObject,
+                      StartingByte.HighPart,
+                      StartingByte.LowPart,
+                      ByteCount);
+
         if (ByteCount > pDevExt->Specific.RDR.MaxIo.QuadPart)
         {
 
@@ -1099,7 +1131,7 @@ AFSNonCachedWrite( IN PDEVICE_OBJECT DeviceObject,
 
         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
                       AFS_TRACE_LEVEL_VERBOSE,
-                      "AFSNonCachedWrite (%p) Successfully retrieved map extents count %08lX run count %08lX\n",
+                      "AFSNonCachedWrite (%p) Successfully retrieved map extents count %d run count %d\n",
                       Irp,
                       extentsCount,
                       runCount);
@@ -1404,8 +1436,11 @@ try_exit:
 
         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
                       AFS_TRACE_LEVEL_VERBOSE,
-                      "AFSNonCachedWrite (%p) Completed request Status %08lX\n",
-                      Irp,
+                      "AFSNonCachedWrite (FO: %p) StartingByte %08lX:%08lX Length %08lX Status %08lX\n",
+                      pFileObject,
+                      StartingByte.HighPart,
+                      StartingByte.LowPart,
+                      ByteCount,
                       ntStatus);
 
         if (NT_SUCCESS(ntStatus) &&
@@ -1736,7 +1771,7 @@ AFSExtendingWrite( IN AFSFcb *Fcb,
     // Tell the server
     //
 
-    ntStatus = AFSUpdateFileInformation( &Fcb->ObjectInformation->ParentObjectInformation->FileId,
+    ntStatus = AFSUpdateFileInformation( &Fcb->ObjectInformation->ParentFileId,
                                          Fcb->ObjectInformation,
                                          &pCcb->AuthGroup);
 
@@ -1867,6 +1902,8 @@ AFSShareWrite( IN PDEVICE_OBJECT DeviceObject,
                                       &pCcb->AuthGroup,
                                       &pCcb->DirectoryCB->NameInformation.FileName,
                                       NULL,
+                                      NULL,
+                                      0,
                                       pIoRequest,
                                       sizeof( AFSPipeIORequestCB) +
                                                 pIrpSp->Parameters.Write.Length,
OpenAFS Master Repository