src/WINNT/afsrdr/kernel/lib/AFSWrite.cpp

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
   3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice,
  14  *   this list of conditions and the following disclaimer in the
  15  *   documentation
  16  *   and/or other materials provided with the distribution.
  17  * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
  18  *   nor the names of their contributors may be used to endorse or promote
  19  *   products derived from this software without specific prior written
  20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 //
  36 // File: AFSWrite.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 static
  42 NTSTATUS
  43 AFSCachedWrite( IN PDEVICE_OBJECT DeviceObject,
  44                 IN PIRP Irp,
  45                 IN LARGE_INTEGER StartingByte,
  46                 IN ULONG ByteCount,
  47                 IN BOOLEAN ForceFlush);
  48 static
  49 NTSTATUS
  50 AFSNonCachedWrite( IN PDEVICE_OBJECT DeviceObject,
  51                    IN PIRP Irp,
  52                    IN LARGE_INTEGER StartingByte,
  53                    IN ULONG ByteCount);
  54
  55 static
  56 NTSTATUS
  57 AFSExtendingWrite( IN AFSFcb *Fcb,
  58                    IN PFILE_OBJECT FileObject,
  59                    IN LONGLONG NewLength);
  60
  61 //
  62 // Function: AFSWrite
  63 //
  64 // Description:
  65 //
  66 //      This is the dispatch handler for the IRP_MJ_WRITE request
  67 //
  68 // Return:
  69 //
  70 //      A status is returned for the function
  71 //
  72 NTSTATUS
  73 AFSWrite( IN PDEVICE_OBJECT LibDeviceObject,
  74           IN PIRP Irp)
  75 {
  76
  77     NTSTATUS ntStatus = STATUS_SUCCESS;
  78
  79     __try
  80     {
  81
  82         ntStatus = AFSCommonWrite( AFSRDRDeviceObject, Irp, NULL);
  83     }
  84     __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
  85     {
  86
  87         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  88     }
  89
  90     return ntStatus;
  91 }
  92
  93 NTSTATUS
  94 AFSCommonWrite( IN PDEVICE_OBJECT DeviceObject,
  95                 IN PIRP Irp,
  96                 IN HANDLE OnBehalfOf)
  97 {
  98
  99     NTSTATUS           ntStatus = STATUS_SUCCESS;
 100     AFSDeviceExt      *pDeviceExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
 101     IO_STACK_LOCATION *pIrpSp;
 102     AFSFcb            *pFcb = NULL;
 103     AFSCcb            *pCcb = NULL;
 104     AFSNonPagedFcb    *pNPFcb = NULL;
 105     ULONG              ulByteCount = 0;
 106     LARGE_INTEGER      liStartingByte;
 107     PFILE_OBJECT       pFileObject;
 108     BOOLEAN            bPagingIo = FALSE;
 109     BOOLEAN            bNonCachedIo = FALSE;
 110     BOOLEAN            bReleaseMain = FALSE;
 111     BOOLEAN            bReleasePaging = FALSE;
 112     BOOLEAN            bExtendingWrite = FALSE;
 113     BOOLEAN            bCompleteIrp = TRUE;
 114     BOOLEAN            bForceFlush = FALSE;
 115     BOOLEAN            bLockOK;
 116     BOOLEAN            bMapped = TRUE;
 117     HANDLE             hCallingUser = OnBehalfOf;
 118     ULONG              ulExtensionLength = 0;
 119     BOOLEAN            bRetry = FALSE;
 120     ULONGLONG          ullProcessId = (ULONGLONG)PsGetCurrentProcessId();
 121
 122     pIrpSp = IoGetCurrentIrpStackLocation( Irp);
 123
 124     __Enter
 125     {
 126
 127         pFileObject = pIrpSp->FileObject;
 128
 129         //
 130         // Extract the fileobject references
 131         //
 132
 133         pFcb = (AFSFcb *)pFileObject->FsContext;
 134         pCcb = (AFSCcb *)pFileObject->FsContext2;
 135
 136         ObReferenceObject( pFileObject);
 137
 138         if( pFcb == NULL)
 139         {
 140
 141             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 142                           AFS_TRACE_LEVEL_ERROR,
 143                           "AFSCommonWrite Attempted write (%08lX) when pFcb == NULL\n",
 144                           Irp);
 145
 146             try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
 147         }
 148
 149         pNPFcb = pFcb->NPFcb;
 150
 151         //
 152         // If we are in shutdown mode then fail the request
 153         //
 154
 155         if( BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
 156         {
 157
 158             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 159                           AFS_TRACE_LEVEL_WARNING,
 160                           "AFSCommonWrite (%08lX) Open request after shutdown\n",
 161                           Irp);
 162
 163             try_return( ntStatus = STATUS_TOO_LATE);
 164         }
 165
 166         liStartingByte = pIrpSp->Parameters.Write.ByteOffset;
 167         bPagingIo      = BooleanFlagOn( Irp->Flags, IRP_PAGING_IO);
 168         bNonCachedIo   = BooleanFlagOn( Irp->Flags, IRP_NOCACHE);
 169         ulByteCount    = pIrpSp->Parameters.Write.Length;
 170
 171         if( pFcb->Header.NodeTypeCode != AFS_IOCTL_FCB &&
 172             pFcb->Header.NodeTypeCode != AFS_FILE_FCB  &&
 173             pFcb->Header.NodeTypeCode != AFS_SPECIAL_SHARE_FCB)
 174         {
 175
 176             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 177                           AFS_TRACE_LEVEL_ERROR,
 178                           "AFSCommonWrite Attempted write (%08lX) on an invalid node type %08lX\n",
 179                           Irp,
 180                           pFcb->Header.NodeTypeCode);
 181
 182             try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
 183         }
 184
 185         //
 186         // If this is a write against an IOCtl node then handle it
 187         // in a different pathway
 188         //
 189
 190         if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
 191         {
 192
 193             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 194                           AFS_TRACE_LEVEL_VERBOSE,
 195                           "AFSCommonWrite (%08lX) Processing file (PIOCTL) Offset %I64X Length %08lX Irp Flags %08lX\n",
 196                           Irp,
 197                           liStartingByte.QuadPart,
 198                           ulByteCount,
 199                           Irp->Flags);
 200
 201             ntStatus = AFSIOCtlWrite( DeviceObject,
 202                                       Irp);
 203
 204             try_return( ntStatus);
 205         }
 206         else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
 207         {
 208
 209             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 210                           AFS_TRACE_LEVEL_VERBOSE,
 211                           "AFSCommonWrite (%08lX) Processing file (SHARE) Offset %I64X Length %08lX Irp Flags %08lX\n",
 212                           Irp,
 213                           liStartingByte.QuadPart,
 214                           ulByteCount,
 215                           Irp->Flags);
 216
 217             ntStatus = AFSShareWrite( DeviceObject,
 218                                       Irp);
 219
 220             try_return( ntStatus);
 221         }
 222
 223         //
 224         // Is the Cache not there yet?  Exit.
 225         //
 226         if( !BooleanFlagOn( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE) &&
 227             NULL == pDeviceExt->Specific.RDR.CacheFileObject)
 228         {
 229
 230             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 231                           AFS_TRACE_LEVEL_ERROR,
 232                           "AFSCommonWrite (%08lX) Request failed due to AFS cache closed\n",
 233                           Irp);
 234
 235             try_return( ntStatus = STATUS_TOO_LATE );
 236         }
 237
 238         if( pFcb->ObjectInformation->VolumeCB != NULL &&
 239             BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
 240         {
 241
 242             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 243                           AFS_TRACE_LEVEL_ERROR,
 244                           "AFSCommonWrite (%08lX) Request failed due to read only volume\n",
 245                           Irp);
 246
 247             try_return( ntStatus = STATUS_ACCESS_DENIED);
 248         }
 249
 250         //
 251         // We need to know on whose behalf we have been called (which
 252         // we will eventually tell to the server - for non paging
 253         // writes).  If we were posted then we were told.  If this is
 254         // the first time we saw the irp then we grab it now.
 255         //
 256         if( NULL == OnBehalfOf )
 257         {
 258
 259             hCallingUser = PsGetCurrentProcessId();
 260         }
 261         else
 262         {
 263
 264             hCallingUser = OnBehalfOf;
 265         }
 266
 267         //
 268         // Check for zero length write
 269         //
 270
 271         if( ulByteCount == 0)
 272         {
 273
 274             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 275                           AFS_TRACE_LEVEL_VERBOSE,
 276                           "AFSCommonWrite (%08lX) Request completed due to zero length\n",
 277                           Irp);
 278
 279             try_return( ntStatus);
 280         }
 281
 282         //
 283         // Is this Fcb valid???
 284         //
 285
 286         if( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID))
 287         {
 288
 289             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 290                           AFS_TRACE_LEVEL_ERROR,
 291                           "AFSCommonWrite (%08lX) Failing request due to INVALID fcb\n",
 292                           Irp);
 293
 294             Irp->IoStatus.Information = 0;
 295
 296             try_return( ntStatus = STATUS_FILE_DELETED);
 297         }
 298
 299         if( BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_DELETED) ||
 300             BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
 301         {
 302
 303             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 304                           AFS_TRACE_LEVEL_ERROR,
 305                           "AFSCommonWrite (%08lX) Request failed due to file deleted\n",
 306                           Irp);
 307
 308             try_return( ntStatus = STATUS_FILE_DELETED);
 309         }
 310
 311         if( FlagOn( pIrpSp->MinorFunction, IRP_MN_COMPLETE))
 312         {
 313
 314             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 315                           AFS_TRACE_LEVEL_VERBOSE,
 316                           "AFSCommonWrite (%08lX) IRP_MN_COMPLETE being processed\n",
 317                           Irp);
 318
 319             CcMdlWriteComplete(pFileObject, &pIrpSp->Parameters.Write.ByteOffset, Irp->MdlAddress);
 320
 321             //
 322             // Mdl is now Deallocated
 323             //
 324
 325             Irp->MdlAddress = NULL;
 326
 327             try_return( ntStatus = STATUS_SUCCESS );
 328         }
 329
 330         //
 331         // If we get a non cached IO for a cached file we should do a purge.
 332         // For now we will just promote to cached
 333         //
 334         if( NULL != pFileObject->SectionObjectPointer->DataSectionObject && !bPagingIo && bNonCachedIo)
 335         {
 336             bNonCachedIo = FALSE;
 337             bForceFlush = TRUE;
 338         }
 339
 340         if( (!bPagingIo && !bNonCachedIo))
 341         {
 342
 343             if( pFileObject->PrivateCacheMap == NULL)
 344             {
 345
 346                 __try
 347                 {
 348
 349                     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 350                                   AFS_TRACE_LEVEL_VERBOSE,
 351                                   "AFSCommonWrite Initialize caching on Fcb %08lX FileObject %08lX\n",
 352                                   pFcb,
 353                                   pFileObject);
 354
 355                     CcInitializeCacheMap( pFileObject,
 356                                           (PCC_FILE_SIZES)&pFcb->Header.AllocationSize,
 357                                           FALSE,
 358                                           AFSLibCacheManagerCallbacks,
 359                                           pFcb);
 360
 361                     CcSetReadAheadGranularity( pFileObject,
 362                                                pDeviceExt->Specific.RDR.MaximumRPCLength);
 363
 364                     CcSetDirtyPageThreshold( pFileObject,
 365                                              AFS_DIRTY_CHUNK_THRESHOLD * pDeviceExt->Specific.RDR.MaximumRPCLength);
 366                 }
 367                 __except( EXCEPTION_EXECUTE_HANDLER)
 368                 {
 369
 370                     ntStatus = GetExceptionCode();
 371
 372                     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 373                                   AFS_TRACE_LEVEL_ERROR,
 374                                   "AFSCommonWrite (%08lX) Exception thrown while initializing cache map Status %08lX\n",
 375                                   Irp,
 376                                   ntStatus);
 377                 }
 378
 379                 if( !NT_SUCCESS( ntStatus))
 380                 {
 381
 382                     try_return( ntStatus);
 383                 }
 384             }
 385         }
 386
 387         while (!bNonCachedIo && !CcCanIWrite( pFileObject,
 388                                               ulByteCount,
 389                                               FALSE,
 390                                               bRetry))
 391         {
 392             static const LONGLONG llWriteDelay = (LONGLONG)-100000;
 393             bRetry = TRUE;
 394             KeDelayExecutionThread(KernelMode, FALSE, (PLARGE_INTEGER)&llWriteDelay);
 395         }
 396
 397         //
 398         // Save off the PID if this is not a paging IO
 399         //
 400
 401         if( !bPagingIo &&
 402             ( pFcb->Specific.File.ExtentRequestProcessId == 0 ||
 403               ( ullProcessId != (ULONGLONG)AFSSysProcess &&
 404                 pFcb->Specific.File.ExtentRequestProcessId != ullProcessId)))
 405         {
 406
 407             pFcb->Specific.File.ExtentRequestProcessId = ullProcessId;
 408
 409             if( ullProcessId == (ULONGLONG)AFSSysProcess)
 410             {
 411                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
 412                               AFS_TRACE_LEVEL_WARNING,
 413                               "%s Setting LastWriterExtentProcessId to system process for Fcb %p\n",
 414                               __FUNCTION__,
 415                               pFcb);
 416             }
 417         }
 418
 419         //
 420         // We should be ready to go.  So first of all ask for the extents
 421         // Provoke a get of the extents - if we need to.
 422         //
 423
 424         /*
 425         if( !bPagingIo && !bNonCachedIo)
 426         {
 427
 428             ntStatus = AFSRequestExtentsAsync( pFcb, pCcb, &liStartingByte, ulByteCount);
 429
 430             if (!NT_SUCCESS(ntStatus))
 431             {
 432
 433                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 434                               AFS_TRACE_LEVEL_ERROR,
 435                               "AFSCommonWrite (%08lX) Failed to request extents Status %08lX\n",
 436                               Irp,
 437                               ntStatus);
 438
 439                 try_return( ntStatus );
 440             }
 441         }
 442         */
 443
 444         //
 445         // If they are not mapped and we are the Lazy Writer then just
 446         // say "not now"
 447         //
 448         if (!bMapped && pFcb->Specific.File.LazyWriterThread == PsGetCurrentThread())
 449         {
 450
 451             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 452                           AFS_TRACE_LEVEL_VERBOSE,
 453                           "AFSCommonWrite (%08lX) Failing lazy writer for unmapped request\n",
 454                           Irp);
 455
 456             try_return ( ntStatus = STATUS_FILE_LOCK_CONFLICT);
 457         }
 458
 459         //
 460         // Take locks
 461         //
 462         //   - if Paging then we need to nothing (the precalls will
 463         //     have acquired the paging resource), for clarity we will collect
 464         //     the paging resource
 465         //   - If extending Write then take the fileresource EX (EOF will change, Allocation will only move out)
 466         //   - Otherwise we collect the file shared, check against extending and
 467         //
 468
 469         bLockOK = FALSE;
 470
 471         do
 472         {
 473
 474             if( !bPagingIo)
 475             {
 476
 477                 bExtendingWrite = (((liStartingByte.QuadPart + ulByteCount) >=
 478                                     pFcb->Header.FileSize.QuadPart) ||
 479                                    (liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
 480                                     liStartingByte.HighPart == -1)) ;
 481             }
 482
 483             if( bPagingIo)
 484             {
 485
 486                 //ASSERT( NULL != OnBehalfOf || ExIsResourceAcquiredLite( &pNPFcb->Resource ));
 487
 488                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 489                               AFS_TRACE_LEVEL_VERBOSE,
 490                               "AFSCommonWrite Acquiring Fcb PagingIo lock %08lX SHARED %08lX\n",
 491                               &pNPFcb->PagingResource,
 492                               PsGetCurrentThread());
 493
 494                 AFSAcquireShared( &pNPFcb->PagingResource,
 495                                   TRUE);
 496
 497                 bReleasePaging = TRUE;
 498
 499                 //
 500                 // We have the correct lock - we cannot have the wrong one
 501                 //
 502                 bLockOK = TRUE;
 503             }
 504             else if( bExtendingWrite)
 505             {
 506                 //
 507                 // Check for lock inversion
 508                 //
 509
 510                 ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->PagingResource ));
 511
 512                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 513                               AFS_TRACE_LEVEL_VERBOSE,
 514                               "AFSCommonWrite Acquiring Fcb lock %08lX EXCL %08lX\n",
 515                               &pNPFcb->Resource,
 516                               PsGetCurrentThread());
 517
 518                 AFSAcquireExcl( &pNPFcb->Resource,
 519                                 TRUE);
 520
 521                 if (liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
 522                     liStartingByte.HighPart == -1)
 523                 {
 524                     if (pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
 525                     {
 526                         liStartingByte = pFcb->Header.ValidDataLength;
 527                     }
 528                     else
 529                     {
 530                         liStartingByte = pFcb->Header.FileSize;
 531                     }
 532                 }
 533                 bReleaseMain = TRUE;
 534
 535                 //
 536                 // We have the correct lock - even if we don't end up truncating
 537                 //
 538                 bLockOK = TRUE;
 539             }
 540             else
 541             {
 542                 ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->PagingResource ));
 543
 544                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 545                               AFS_TRACE_LEVEL_VERBOSE,
 546                               "AFSCommonWrite Acquiring Fcb lock %08lX SHARED %08lX\n",
 547                               &pNPFcb->Resource,
 548                               PsGetCurrentThread());
 549
 550                 AFSAcquireShared( &pNPFcb->Resource,
 551                                   TRUE);
 552
 553                 bReleaseMain = TRUE;
 554
 555                 //
 556                 // Have things moved?  Are we extending? If so, the the lock isn't OK
 557                 //
 558                 bLockOK = (liStartingByte.QuadPart + ulByteCount) < pFcb->Header.FileSize.QuadPart;
 559
 560                 if (!bLockOK)
 561                 {
 562                     AFSReleaseResource( &pNPFcb->Resource);
 563                     bReleaseMain = FALSE;
 564                 }
 565             }
 566         }
 567         while (!bLockOK);
 568
 569         //
 570         // Check the BR locks on the file.
 571         //
 572
 573         if( !bPagingIo &&
 574             !FsRtlCheckLockForWriteAccess( &pFcb->Specific.File.FileLock,
 575                                            Irp))
 576         {
 577
 578             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 579                           AFS_TRACE_LEVEL_ERROR,
 580                           "AFSCommonWrite (%08lX) Request failed due to lock conflict\n",
 581                           Irp);
 582
 583             try_return( ntStatus = STATUS_FILE_LOCK_CONFLICT);
 584         }
 585
 586         if( bExtendingWrite)
 587         {
 588
 589             ntStatus = AFSExtendingWrite( pFcb, pFileObject, (liStartingByte.QuadPart + ulByteCount));
 590
 591             if( !NT_SUCCESS(ntStatus))
 592             {
 593
 594                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 595                               AFS_TRACE_LEVEL_ERROR,
 596                               "AFSCommonWrite (%08lX) Failed extending write request Status %08lX\n",
 597                               Irp,
 598                               ntStatus);
 599
 600                 try_return( ntStatus );
 601             }
 602         }
 603
 604         //
 605         // Fire off the request as appropriate
 606         //
 607         bCompleteIrp = FALSE;
 608
 609         if( !bPagingIo &&
 610             !bNonCachedIo)
 611         {
 612
 613             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 614                           AFS_TRACE_LEVEL_VERBOSE,
 615                           "AFSCommonWrite (%08lX) Processing CACHED request Offset %I64X Len %08lX\n",
 616                           Irp,
 617                           liStartingByte.QuadPart,
 618                           ulByteCount);
 619
 620             ntStatus = AFSCachedWrite( DeviceObject, Irp, liStartingByte, ulByteCount, bForceFlush);
 621
 622         }
 623         else
 624         {
 625
 626             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 627                           AFS_TRACE_LEVEL_VERBOSE,
 628                           "AFSCommonWrite (%08lX) Processing NON-CACHED request Offset %I64X Len %08lX\n",
 629                           Irp,
 630                           liStartingByte.QuadPart,
 631                           ulByteCount);
 632
 633             ntStatus = AFSNonCachedWrite( DeviceObject, Irp,  liStartingByte, ulByteCount);
 634         }
 635
 636 try_exit:
 637
 638         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 639                       AFS_TRACE_LEVEL_VERBOSE,
 640                       "AFSCommonWrite (%08lX) Process complete Status %08lX\n",
 641                       Irp,
 642                       ntStatus);
 643
 644         ObDereferenceObject(pFileObject);
 645
 646         if( bReleaseMain)
 647         {
 648
 649             AFSReleaseResource( &pNPFcb->Resource);
 650         }
 651
 652         if( bReleasePaging)
 653         {
 654
 655             AFSReleaseResource( &pNPFcb->PagingResource);
 656         }
 657
 658         if( bCompleteIrp)
 659         {
 660
 661             AFSCompleteRequest( Irp,
 662                                 ntStatus);
 663         }
 664     }
 665
 666     return ntStatus;
 667 }
 668
 669 NTSTATUS
 670 AFSIOCtlWrite( IN PDEVICE_OBJECT DeviceObject,
 671                IN PIRP Irp)
 672 {
 673
 674     NTSTATUS ntStatus = STATUS_SUCCESS;
 675     AFSPIOCtlIORequestCB stIORequestCB;
 676     PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
 677     AFSFcb *pFcb = NULL;
 678     AFSCcb *pCcb = NULL;
 679     AFSPIOCtlIOResultCB stIOResultCB;
 680     ULONG ulBytesReturned = 0;
 681     AFSFileID stParentFID;
 682
 683     __Enter
 684     {
 685
 686         RtlZeroMemory( &stIORequestCB,
 687                        sizeof( AFSPIOCtlIORequestCB));
 688
 689         if( pIrpSp->Parameters.Write.Length == 0)
 690         {
 691
 692             //
 693             // Nothing to do in this case
 694             //
 695
 696             try_return( ntStatus);
 697         }
 698
 699         pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
 700
 701         pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
 702
 703         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 704                       AFS_TRACE_LEVEL_VERBOSE,
 705                       "AFSIOCtlWrite Acquiring Fcb lock %08lX SHARED %08lX\n",
 706                       &pFcb->NPFcb->Resource,
 707                       PsGetCurrentThread());
 708
 709         AFSAcquireShared( &pFcb->NPFcb->Resource,
 710                           TRUE);
 711
 712         //
 713         // Get the parent fid to pass to the cm
 714         //
 715
 716         RtlZeroMemory( &stParentFID,
 717                        sizeof( AFSFileID));
 718
 719         if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
 720         {
 721
 722             //
 723             // The parent directory FID of the node
 724             //
 725
 726             stParentFID = pFcb->ObjectInformation->ParentObjectInformation->FileId;
 727         }
 728
 729         //
 730         // Set the control block up
 731         //
 732
 733         stIORequestCB.RequestId = pCcb->RequestID;
 734
 735         if( pFcb->ObjectInformation->VolumeCB != NULL)
 736         {
 737             stIORequestCB.RootId = pFcb->ObjectInformation->VolumeCB->ObjectInformation.FileId;
 738         }
 739
 740         //
 741         // Lock down the buffer
 742         //
 743
 744         stIORequestCB.MappedBuffer = AFSMapToService( Irp,
 745                                                       pIrpSp->Parameters.Write.Length);
 746
 747         if( stIORequestCB.MappedBuffer == NULL)
 748         {
 749
 750             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 751         }
 752
 753         stIORequestCB.BufferLength = pIrpSp->Parameters.Write.Length;
 754
 755         stIOResultCB.BytesProcessed = 0;
 756
 757         ulBytesReturned = sizeof( AFSPIOCtlIOResultCB);
 758
 759         //
 760         // Issue the request to the service
 761         //
 762
 763         ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_WRITE,
 764                                       AFS_REQUEST_FLAG_SYNCHRONOUS,
 765                                       &pCcb->AuthGroup,
 766                                       NULL,
 767                                       &stParentFID,
 768                                       (void *)&stIORequestCB,
 769                                       sizeof( AFSPIOCtlIORequestCB),
 770                                       &stIOResultCB,
 771                                       &ulBytesReturned);
 772
 773         if( !NT_SUCCESS( ntStatus))
 774         {
 775
 776             try_return( ntStatus);
 777         }
 778
 779         //
 780         // Update the length written
 781         //
 782
 783         Irp->IoStatus.Information = stIOResultCB.BytesProcessed;
 784
 785 try_exit:
 786
 787         if( stIORequestCB.MappedBuffer != NULL)
 788         {
 789
 790             AFSUnmapServiceMappedBuffer( stIORequestCB.MappedBuffer,
 791                                          Irp->MdlAddress);
 792         }
 793
 794         if( pFcb != NULL)
 795         {
 796
 797             AFSReleaseResource( &pFcb->NPFcb->Resource);
 798         }
 799     }
 800
 801     return ntStatus;
 802 }
 803
 804 //
 805 // This function is called when we know we have to read from the AFS Cache.
 806 //
 807 // It ensures that we have exents for the entirety of the write and
 808 // then pins the extents into memory (meaning that although we may
 809 // add we will not remove).  Then it creates a scatter gather write
 810 // and fires off the IRPs
 811 //
 812 static
 813 NTSTATUS
 814 AFSNonCachedWrite( IN PDEVICE_OBJECT DeviceObject,
 815                    IN PIRP Irp,
 816                    IN LARGE_INTEGER StartingByte,
 817                    IN ULONG ByteCount)
 818 {
 819     NTSTATUS           ntStatus = STATUS_UNSUCCESSFUL;
 820     VOID              *pSystemBuffer = NULL;
 821     BOOLEAN            bPagingIo = BooleanFlagOn( Irp->Flags, IRP_PAGING_IO);
 822     BOOLEAN            bLocked = FALSE;
 823     BOOLEAN            bCompleteIrp = TRUE;
 824     BOOLEAN            bExtentsMapped = FALSE;
 825     AFSGatherIo       *pGatherIo = NULL;
 826     AFSIoRun          *pIoRuns = NULL;
 827     AFSIoRun           stIoRuns[AFS_MAX_STACK_IO_RUNS];
 828     ULONG              extentsCount = 0, runCount = 0;
 829     AFSExtent         *pStartExtent = NULL;
 830     AFSExtent         *pIgnoreExtent = NULL;
 831     IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
 832     PFILE_OBJECT       pFileObject = pIrpSp->FileObject;
 833     AFSFcb            *pFcb = (AFSFcb *)pFileObject->FsContext;
 834     AFSCcb            *pCcb = (AFSCcb *)pFileObject->FsContext2;
 835     BOOLEAN            bSynchronousFo = BooleanFlagOn( pFileObject->Flags, FO_SYNCHRONOUS_IO);
 836     AFSDeviceExt      *pDevExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
 837     ULONG              ulRequestCount = 0;
 838     LARGE_INTEGER      liCurrentTime, liLastRequestTime;
 839     AFSDeviceExt      *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
 840     PFILE_OBJECT       pCacheFileObject = NULL;
 841     BOOLEAN            bDerefExtents = FALSE;
 842
 843     __Enter
 844     {
 845         Irp->IoStatus.Information = 0;
 846
 847         if (ByteCount > pDevExt->Specific.RDR.MaxIo.QuadPart)
 848         {
 849
 850             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 851                           AFS_TRACE_LEVEL_ERROR,
 852                           "AFSNonCachedWrite (%08lX) Request %08lX Actual %08lX larger than MaxIO %I64X\n",
 853                           Irp,
 854                           ByteCount,
 855                           pIrpSp->Parameters.Write.Length,
 856                           pDevExt->Specific.RDR.MaxIo.QuadPart);
 857
 858             try_return( ntStatus = STATUS_UNSUCCESSFUL);
 859         }
 860
 861         //
 862         // Get the mapping for the buffer
 863         //
 864         pSystemBuffer = AFSLockSystemBuffer( Irp,
 865                                              ByteCount);
 866
 867         if( pSystemBuffer == NULL)
 868         {
 869
 870             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 871                           AFS_TRACE_LEVEL_ERROR,
 872                           "AFSNonCachedWrite (%08lX) Failed to map system buffer\n",
 873                           Irp);
 874
 875             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 876         }
 877
 878
 879         //
 880         // Provoke a get of the extents - if we need to.
 881         //
 882
 883         AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
 884                       AFS_TRACE_LEVEL_VERBOSE,
 885                       "AFSNonCachedWrite Requesting extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
 886                       pFcb->ObjectInformation->FileId.Cell,
 887                       pFcb->ObjectInformation->FileId.Volume,
 888                       pFcb->ObjectInformation->FileId.Vnode,
 889                       pFcb->ObjectInformation->FileId.Unique,
 890                       StartingByte.QuadPart,
 891                       ByteCount);
 892
 893         ntStatus = AFSRequestExtentsAsync( pFcb,
 894                                            pCcb,
 895                                            &StartingByte,
 896                                            ByteCount);
 897
 898         if (!NT_SUCCESS(ntStatus))
 899         {
 900
 901             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 902                           AFS_TRACE_LEVEL_ERROR,
 903                           "AFSNonCachedWrite (%08lX) Failed to request extents Status %08lX\n",
 904                           Irp,
 905                           ntStatus);
 906
 907             try_return( ntStatus);
 908         }
 909
 910         KeQueryTickCount( &liLastRequestTime);
 911
 912         while (TRUE)
 913         {
 914
 915             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 916                           AFS_TRACE_LEVEL_VERBOSE,
 917                           "AFSNonCachedWrite Acquiring Fcb extents lock %08lX SHARED %08lX\n",
 918                           &pFcb->NPFcb->Specific.File.ExtentsResource,
 919                           PsGetCurrentThread());
 920
 921             ASSERT( !ExIsResourceAcquiredLite( &pFcb->NPFcb->Specific.File.ExtentsResource ));
 922
 923             AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource, TRUE );
 924             bLocked = TRUE;
 925
 926             pStartExtent = NULL;
 927             pIgnoreExtent = NULL;
 928
 929             if ( AFSDoExtentsMapRegion( pFcb, &StartingByte, ByteCount, &pStartExtent, &pIgnoreExtent ))
 930             {
 931                 break;
 932             }
 933
 934             KeClearEvent( &pFcb->NPFcb->Specific.File.ExtentsRequestComplete );
 935
 936             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 937                           AFS_TRACE_LEVEL_VERBOSE,
 938                           "AFSNonCachedWrite Releasing(1) Fcb extents lock %08lX SHARED %08lX\n",
 939                           &pFcb->NPFcb->Specific.File.ExtentsResource,
 940                           PsGetCurrentThread());
 941
 942             AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
 943             bLocked= FALSE;
 944
 945             //
 946             // We will re-request the extents after waiting for them
 947             //
 948
 949             KeQueryTickCount( &liCurrentTime);
 950
 951             if( liCurrentTime.QuadPart - liLastRequestTime.QuadPart >= pControlDevExt->Specific.Control.ExtentRequestTimeCount.QuadPart)
 952             {
 953
 954                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
 955                               AFS_TRACE_LEVEL_VERBOSE,
 956                               "AFSNonCachedWrite Requesting extents, again, for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
 957                               pFcb->ObjectInformation->FileId.Cell,
 958                               pFcb->ObjectInformation->FileId.Volume,
 959                               pFcb->ObjectInformation->FileId.Vnode,
 960                               pFcb->ObjectInformation->FileId.Unique,
 961                               StartingByte.QuadPart,
 962                               ByteCount);
 963
 964                 ntStatus = AFSRequestExtentsAsync( pFcb,
 965                                                    pCcb,
 966                                                    &StartingByte,
 967                                                    ByteCount);
 968
 969                 if (!NT_SUCCESS(ntStatus))
 970                 {
 971
 972                     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 973                                   AFS_TRACE_LEVEL_ERROR,
 974                                   "AFSNonCachedWrite (%08lX) Failed to request extents Status %08lX\n",
 975                                   Irp,
 976                                   ntStatus);
 977
 978                     try_return( ntStatus);
 979                 }
 980
 981                 KeQueryTickCount( &liLastRequestTime);
 982             }
 983
 984
 985             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
 986                           AFS_TRACE_LEVEL_VERBOSE,
 987                           "AFSNonCachedWrite Waiting for extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
 988                           pFcb->ObjectInformation->FileId.Cell,
 989                           pFcb->ObjectInformation->FileId.Volume,
 990                           pFcb->ObjectInformation->FileId.Vnode,
 991                           pFcb->ObjectInformation->FileId.Unique,
 992                           StartingByte.QuadPart,
 993                           ByteCount);
 994
 995             //
 996             // Wait for it
 997             //
 998
 999             ntStatus =  AFSWaitForExtentMapping ( pFcb, pCcb);
1000
1001             if (!NT_SUCCESS(ntStatus))
1002             {
1003
1004                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1005                               AFS_TRACE_LEVEL_ERROR,
1006                               "AFSNonCachedWrite Failed wait for extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX Status %08lX\n",
1007                               pFcb->ObjectInformation->FileId.Cell,
1008                               pFcb->ObjectInformation->FileId.Volume,
1009                               pFcb->ObjectInformation->FileId.Vnode,
1010                               pFcb->ObjectInformation->FileId.Unique,
1011                               StartingByte.QuadPart,
1012                               ByteCount,
1013                               ntStatus);
1014
1015                 try_return( ntStatus);
1016             }
1017         }
1018
1019         //
1020         // As per the read path -
1021         //
1022
1023         AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1024                       AFS_TRACE_LEVEL_VERBOSE,
1025                       "AFSNonCachedWrite Extents located for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
1026                       pFcb->ObjectInformation->FileId.Cell,
1027                       pFcb->ObjectInformation->FileId.Volume,
1028                       pFcb->ObjectInformation->FileId.Vnode,
1029                       pFcb->ObjectInformation->FileId.Unique,
1030                       StartingByte.QuadPart,
1031                       ByteCount);
1032
1033         ntStatus = AFSGetExtents( pFcb,
1034                                   &StartingByte,
1035                                   ByteCount,
1036                                   pStartExtent,
1037                                   &extentsCount,
1038                                   &runCount);
1039
1040         if (!NT_SUCCESS(ntStatus))
1041         {
1042
1043             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1044                           AFS_TRACE_LEVEL_ERROR,
1045                           "AFSNonCachedWrite (%08lX) Failed to retrieve mapped extents Status %08lX\n",
1046                           Irp,
1047                           ntStatus);
1048
1049             try_return( ntStatus );
1050         }
1051
1052         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1053                       AFS_TRACE_LEVEL_VERBOSE,
1054                       "AFSNonCachedWrite (%08lX) Successfully retrieved map extents count %08lX run count %08lX\n",
1055                       Irp,
1056                       extentsCount,
1057                       runCount);
1058
1059         if( BooleanFlagOn( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE))
1060         {
1061
1062             Irp->IoStatus.Information = ByteCount;
1063
1064 #if GEN_MD5
1065             //
1066             // Setup the MD5 for each extent
1067             //
1068
1069             AFSSetupMD5Hash( pFcb,
1070                              pStartExtent,
1071                              extentsCount,
1072                              pSystemBuffer,
1073                              &StartingByte,
1074                              ByteCount);
1075 #endif
1076
1077             ntStatus = AFSProcessExtentRun( pSystemBuffer,
1078                                             &StartingByte,
1079                                             ByteCount,
1080                                             pStartExtent,
1081                                             TRUE);
1082
1083             if (!NT_SUCCESS(ntStatus))
1084             {
1085
1086                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1087                               AFS_TRACE_LEVEL_ERROR,
1088                               "AFSNonCachedWrite (%08lX) Failed to process extent run for non-persistent cache Status %08lX\n",
1089                               Irp,
1090                               ntStatus);
1091             }
1092
1093             try_return( ntStatus);
1094         }
1095
1096         //
1097         // Retrieve the cache file object
1098         //
1099
1100         pCacheFileObject = AFSReferenceCacheFileObject();
1101
1102         if( pCacheFileObject == NULL)
1103         {
1104
1105             ntStatus = STATUS_DEVICE_NOT_READY;
1106
1107             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1108                           AFS_TRACE_LEVEL_ERROR,
1109                           "AFSNonCachedWrite Failed to retrieve cache fileobject for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX Status %08lX\n",
1110                           pFcb->ObjectInformation->FileId.Cell,
1111                           pFcb->ObjectInformation->FileId.Volume,
1112                           pFcb->ObjectInformation->FileId.Vnode,
1113                           pFcb->ObjectInformation->FileId.Unique,
1114                           StartingByte.QuadPart,
1115                           ByteCount,
1116                           ntStatus);
1117
1118             try_return( ntStatus);
1119         }
1120
1121         if (runCount > AFS_MAX_STACK_IO_RUNS)
1122         {
1123
1124             pIoRuns = (AFSIoRun*) AFSExAllocatePoolWithTag( PagedPool,
1125                                                             runCount * sizeof( AFSIoRun ),
1126                                                             AFS_IO_RUN_TAG );
1127             if (NULL == pIoRuns)
1128             {
1129
1130                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1131                               AFS_TRACE_LEVEL_ERROR,
1132                               "AFSNonCachedWrite (%08lX) Failed to allocate IO run block\n",
1133                               Irp);
1134
1135                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
1136             }
1137         }
1138         else
1139         {
1140
1141             pIoRuns = stIoRuns;
1142         }
1143
1144         RtlZeroMemory( pIoRuns, runCount * sizeof( AFSIoRun ));
1145
1146         ntStatus = AFSSetupIoRun( IoGetRelatedDeviceObject( pCacheFileObject),
1147                                   Irp,
1148                                   pSystemBuffer,
1149                                   pIoRuns,
1150                                   &StartingByte,
1151                                   ByteCount,
1152                                   pStartExtent,
1153                                   &runCount );
1154
1155         if (!NT_SUCCESS(ntStatus))
1156         {
1157
1158             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1159                           AFS_TRACE_LEVEL_ERROR,
1160                           "AFSNonCachedWrite (%08lX) Failed to initialize IO run block Status %08lX\n",
1161                           Irp,
1162                           ntStatus);
1163
1164             try_return( ntStatus );
1165         }
1166
1167         AFSReferenceActiveExtents( pStartExtent,
1168                                    extentsCount);
1169
1170         bDerefExtents = TRUE;
1171
1172         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1173                       AFS_TRACE_LEVEL_VERBOSE,
1174                       "AFSNonCachedWrite Releasing(2) Fcb extents lock %08lX SHARED %08lX\n",
1175                       &pFcb->NPFcb->Specific.File.ExtentsResource,
1176                       PsGetCurrentThread());
1177
1178         AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
1179         bLocked = FALSE;
1180
1181         pGatherIo = (AFSGatherIo*) AFSExAllocatePoolWithTag( NonPagedPool,
1182                                                              sizeof( AFSGatherIo),
1183                                                              AFS_GATHER_TAG);
1184
1185         if (NULL == pGatherIo)
1186         {
1187
1188             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1189                           AFS_TRACE_LEVEL_ERROR,
1190                           "AFSNonCachedWrite (%08lX) Failed to allocate IO gather block\n",
1191                           Irp);
1192
1193             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1194                           AFS_TRACE_LEVEL_VERBOSE,
1195                           "AFSNonCachedWrite Acquiring(1) Fcb extents lock %08lX SHARED %08lX\n",
1196                           &pFcb->NPFcb->Specific.File.ExtentsResource,
1197                           PsGetCurrentThread());
1198
1199             AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
1200                               TRUE);
1201             bLocked = TRUE;
1202
1203             AFSDereferenceActiveExtents( pStartExtent,
1204                                          extentsCount);
1205
1206             try_return (ntStatus = STATUS_INSUFFICIENT_RESOURCES );
1207         }
1208
1209         RtlZeroMemory( pGatherIo, sizeof( AFSGatherIo ));
1210
1211         //
1212         // Initialize count to 1, that was we won't get an early
1213         // completion if the first irp completes before the second is
1214         // queued.
1215         //
1216         pGatherIo->Count = 1;
1217         pGatherIo->Status = STATUS_SUCCESS;
1218         pGatherIo->MasterIrp = Irp;
1219         pGatherIo->Synchronous = TRUE;
1220         pGatherIo->CompleteMasterIrp = FALSE;
1221
1222         bCompleteIrp = TRUE;
1223
1224         if( pGatherIo->Synchronous)
1225         {
1226             KeInitializeEvent( &pGatherIo->Event, NotificationEvent, FALSE );
1227         }
1228
1229 #if GEN_MD5
1230         //
1231         // Setup the MD5 for each extent
1232         //
1233
1234         AFSSetupMD5Hash( pFcb,
1235                          pStartExtent,
1236                          extentsCount,
1237                          pSystemBuffer,
1238                          &StartingByte,
1239                          ByteCount);
1240 #endif
1241
1242         //
1243         // Pre-emptively set up the count
1244         //
1245
1246         Irp->IoStatus.Information = ByteCount;
1247
1248         ntStatus = AFSQueueStartIos( pCacheFileObject,
1249                                      IRP_MJ_WRITE,
1250                                      IRP_WRITE_OPERATION | IRP_SYNCHRONOUS_API,
1251                                      pIoRuns,
1252                                      runCount,
1253                                      pGatherIo);
1254
1255         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1256                       AFS_TRACE_LEVEL_VERBOSE,
1257                       "AFSNonCachedWrite (%08lX) AFSStartIos completed Status %08lX\n",
1258                       Irp,
1259                       ntStatus);
1260
1261         if( !NT_SUCCESS( ntStatus))
1262         {
1263
1264             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1265                           AFS_TRACE_LEVEL_VERBOSE,
1266                           "AFSNonCachedWrite Acquiring(2) Fcb extents lock %08lX SHARED %08lX\n",
1267                           &pFcb->NPFcb->Specific.File.ExtentsResource,
1268                           PsGetCurrentThread());
1269
1270             AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
1271                               TRUE);
1272             bLocked = TRUE;
1273
1274             AFSDereferenceActiveExtents( pStartExtent,
1275                                          extentsCount);
1276
1277             try_return( ntStatus);
1278         }
1279
1280         //
1281         // Wait for completion of All IOs we started.
1282         //
1283
1284         ntStatus = KeWaitForSingleObject( &pGatherIo->Event,
1285                                           Executive,
1286                                           KernelMode,
1287                                           FALSE,
1288                                           NULL);
1289
1290         if( NT_SUCCESS( ntStatus))
1291         {
1292
1293             ntStatus = pGatherIo->Status;
1294         }
1295
1296         if( !NT_SUCCESS( ntStatus))
1297         {
1298
1299             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1300                           AFS_TRACE_LEVEL_VERBOSE,
1301                           "AFSNonCachedWrite Acquiring(3) Fcb extents lock %08lX SHARED %08lX\n",
1302                           &pFcb->NPFcb->Specific.File.ExtentsResource,
1303                           PsGetCurrentThread());
1304
1305             AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
1306                               TRUE);
1307             bLocked = TRUE;
1308
1309             AFSDereferenceActiveExtents( pStartExtent,
1310                                          extentsCount);
1311
1312             try_return( ntStatus);
1313         }
1314
1315 try_exit:
1316
1317         if( NT_SUCCESS( ntStatus) &&
1318             pStartExtent != NULL &&
1319             Irp->IoStatus.Information > 0)
1320         {
1321
1322             //
1323             // Since this is dirty we can mark the extents dirty now.
1324             // AFSMarkDirty will dereference the extents.  Do not call
1325             // AFSDereferenceActiveExtents() in this code path.
1326             //
1327
1328             AFSMarkDirty( pFcb,
1329                           pStartExtent,
1330                           extentsCount,
1331                           &StartingByte,
1332                           bDerefExtents);
1333
1334             if (!bPagingIo)
1335             {
1336                 //
1337                 // This was an uncached user write - tell the server to do
1338                 // the flush when the worker thread next wakes up
1339                 //
1340                 pFcb->Specific.File.LastServerFlush.QuadPart = 0;
1341             }
1342         }
1343
1344         if( pCacheFileObject != NULL)
1345         {
1346             AFSReleaseCacheFileObject( pCacheFileObject);
1347         }
1348
1349         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1350                       AFS_TRACE_LEVEL_VERBOSE,
1351                       "AFSNonCachedWrite (%08lX) Completed request Status %08lX\n",
1352                       Irp,
1353                       ntStatus);
1354
1355         if (NT_SUCCESS(ntStatus) &&
1356             !bPagingIo &&
1357             bSynchronousFo)
1358         {
1359
1360             pFileObject->CurrentByteOffset.QuadPart = StartingByte.QuadPart + ByteCount;
1361         }
1362
1363         if( bLocked)
1364         {
1365
1366             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1367                           AFS_TRACE_LEVEL_VERBOSE,
1368                           "AFSNonCachedWrite Releasing Fcb extents lock %08lX SHARED %08lX\n",
1369                           &pFcb->NPFcb->Specific.File.ExtentsResource,
1370                           PsGetCurrentThread());
1371
1372             AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
1373         }
1374
1375         if( pGatherIo)
1376         {
1377             AFSExFreePool(pGatherIo);
1378         }
1379
1380         if( NULL != pIoRuns &&
1381             stIoRuns != pIoRuns)
1382         {
1383             AFSExFreePool(pIoRuns);
1384         }
1385
1386         if( bCompleteIrp)
1387         {
1388
1389             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1390                           AFS_TRACE_LEVEL_VERBOSE,
1391                           "AFSNonCachedWrite Completing Irp %08lX Status %08lX Info %08lX\n",
1392                           Irp,
1393                           ntStatus,
1394                           Irp->IoStatus.Information);
1395
1396             AFSCompleteRequest( Irp, ntStatus);
1397         }
1398     }
1399
1400     return ntStatus;
1401 }
1402
1403 static
1404 NTSTATUS
1405 AFSCachedWrite( IN PDEVICE_OBJECT DeviceObject,
1406                 IN PIRP Irp,
1407                 IN LARGE_INTEGER StartingByte,
1408                 IN ULONG ByteCount,
1409                 IN BOOLEAN ForceFlush)
1410 {
1411     PVOID              pSystemBuffer = NULL;
1412     NTSTATUS           ntStatus = STATUS_SUCCESS;
1413     IO_STATUS_BLOCK    iosbFlush;
1414     IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1415     PFILE_OBJECT       pFileObject = pIrpSp->FileObject;
1416     AFSFcb            *pFcb = (AFSFcb *)pFileObject->FsContext;
1417     AFSCcb            *pCcb = (AFSCcb *)pFileObject->FsContext2;
1418     BOOLEAN            bSynchronousFo = BooleanFlagOn( pFileObject->Flags, FO_SYNCHRONOUS_IO);
1419     BOOLEAN            bMapped = FALSE;
1420     ULONG              ulCurrentIO = 0, ulTotalLen = ByteCount;
1421     PMDL               pCurrentMdl = Irp->MdlAddress;
1422     LARGE_INTEGER      liCurrentOffset;
1423
1424     __Enter
1425     {
1426
1427         Irp->IoStatus.Information = 0;
1428
1429         if( BooleanFlagOn( pIrpSp->MinorFunction, IRP_MN_MDL))
1430         {
1431
1432             __try
1433             {
1434
1435                 CcPrepareMdlWrite( pFileObject,
1436                                    &StartingByte,
1437                                    ByteCount,
1438                                    &Irp->MdlAddress,
1439                                    &Irp->IoStatus);
1440
1441                 ntStatus = Irp->IoStatus.Status;
1442             }
1443             __except( EXCEPTION_EXECUTE_HANDLER)
1444             {
1445                 ntStatus = GetExceptionCode();
1446
1447                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1448                               AFS_TRACE_LEVEL_ERROR,
1449                               "AFSCachedWrite (%08lX) Exception thrown while preparing mdl write Status %08lX\n",
1450                               Irp,
1451                               ntStatus);
1452             }
1453
1454             if( !NT_SUCCESS( ntStatus))
1455             {
1456
1457                 //
1458                 // Free up any potentially allocated mdl's
1459                 //
1460
1461                 CcMdlWriteComplete( pFileObject,
1462                                     &StartingByte,
1463                                     Irp->MdlAddress);
1464
1465                 Irp->MdlAddress = NULL;
1466
1467                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1468                               AFS_TRACE_LEVEL_ERROR,
1469                               "AFSCachedWrite (%08lX) Failed to process MDL write Status %08lX\n",
1470                               Irp,
1471                               ntStatus);
1472             }
1473
1474             try_return( ntStatus);
1475         }
1476
1477         liCurrentOffset.QuadPart = StartingByte.QuadPart;
1478
1479         while( ulTotalLen > 0)
1480         {
1481
1482             ntStatus = STATUS_SUCCESS;
1483
1484             if( pCurrentMdl != NULL)
1485             {
1486
1487                 pSystemBuffer = MmGetSystemAddressForMdlSafe( pCurrentMdl,
1488                                                               NormalPagePriority);
1489
1490                 ulCurrentIO = MmGetMdlByteCount( pCurrentMdl);
1491
1492                 if( ulCurrentIO > ulTotalLen)
1493                 {
1494                     ulCurrentIO = ulTotalLen;
1495                 }
1496             }
1497             else
1498             {
1499
1500                 pSystemBuffer = AFSLockSystemBuffer( Irp,
1501                                                      ulTotalLen);
1502
1503                 ulCurrentIO = ulTotalLen;
1504             }
1505
1506             if( pSystemBuffer == NULL)
1507             {
1508
1509                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1510                               AFS_TRACE_LEVEL_ERROR,
1511                               "AFSCachedWrite (%08lX) Failed to lock system buffer\n",
1512                               Irp);
1513
1514                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1515             }
1516
1517             __try
1518             {
1519
1520                 if( !CcCopyWrite( pFileObject,
1521                                   &liCurrentOffset,
1522                                   ulCurrentIO,
1523                                   TRUE,
1524                                   pSystemBuffer))
1525                 {
1526                     //
1527                     // Failed to process request.
1528                     //
1529
1530                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1531                                   AFS_TRACE_LEVEL_ERROR,
1532                                   "AFSCachedWrite (%08lX) Failed to issue CcCopyWrite %wZ @ %0I64X Status %08lX\n",
1533                                   Irp,
1534                                   &pFileObject->FileName,
1535                                   liCurrentOffset.QuadPart,
1536                                   Irp->IoStatus.Status);
1537
1538                     try_return( ntStatus = STATUS_UNSUCCESSFUL);
1539                 }
1540             }
1541             __except( EXCEPTION_EXECUTE_HANDLER)
1542             {
1543
1544                 ntStatus = GetExceptionCode();
1545
1546                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1547                               AFS_TRACE_LEVEL_ERROR,
1548                               "AFSCachedWrite (%08lX) CcCopyWrite Threw exception %wZ @ %0I64X Status %08lX\n",
1549                               Irp,
1550                               &pFileObject->FileName,
1551                               liCurrentOffset.QuadPart,
1552                               ntStatus);
1553             }
1554
1555             if( !NT_SUCCESS( ntStatus))
1556             {
1557                 try_return( ntStatus);
1558             }
1559
1560             if( ForceFlush)
1561             {
1562
1563                 //
1564                 // We have detected a file we do a write through with.
1565                 //
1566
1567                 CcFlushCache(&pFcb->NPFcb->SectionObjectPointers,
1568                              &liCurrentOffset,
1569                              ulCurrentIO,
1570                              &iosbFlush);
1571
1572                 if( !NT_SUCCESS( iosbFlush.Status))
1573                 {
1574
1575                     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1576                                   AFS_TRACE_LEVEL_ERROR,
1577                                   "AFSCachedWrite (%08lX) CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
1578                                   Irp,
1579                                   &pFileObject->FileName,
1580                                   pFcb->ObjectInformation->FileId.Cell,
1581                                   pFcb->ObjectInformation->FileId.Volume,
1582                                   pFcb->ObjectInformation->FileId.Vnode,
1583                                   pFcb->ObjectInformation->FileId.Unique,
1584                                   iosbFlush.Status,
1585                                   iosbFlush.Information);
1586
1587                     try_return( ntStatus = iosbFlush.Status);
1588                 }
1589             }
1590
1591             if( ulTotalLen <= ulCurrentIO)
1592             {
1593                 break;
1594             }
1595
1596             liCurrentOffset.QuadPart += ulCurrentIO;
1597
1598             ulTotalLen -= ulCurrentIO;
1599
1600             pCurrentMdl = pCurrentMdl->Next;
1601         }
1602
1603 try_exit:
1604
1605         if( NT_SUCCESS( ntStatus))
1606         {
1607
1608             Irp->IoStatus.Information = ByteCount;
1609
1610             if( bSynchronousFo)
1611             {
1612
1613                 pFileObject->CurrentByteOffset.QuadPart = StartingByte.QuadPart + ByteCount;
1614             }
1615
1616             //
1617             // If this extended the Vdl, then update it accordingly
1618             //
1619
1620             if( StartingByte.QuadPart + ByteCount > pFcb->Header.ValidDataLength.QuadPart)
1621             {
1622
1623                 pFcb->Header.ValidDataLength.QuadPart = StartingByte.QuadPart + ByteCount;
1624             }
1625
1626             if (BooleanFlagOn(pFileObject->Flags, (FO_NO_INTERMEDIATE_BUFFERING + FO_WRITE_THROUGH)))
1627             {
1628                 //
1629                 // Write through asked for... Set things so that we get
1630                 // flush when the worker thread next wakes up
1631                 //
1632                 pFcb->Specific.File.LastServerFlush.QuadPart = 0;
1633             }
1634
1635             if( !BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME))
1636             {
1637
1638                 SetFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_WRITE_TIME);
1639
1640                 KeQuerySystemTime( &pFcb->ObjectInformation->LastWriteTime);
1641             }
1642         }
1643
1644         AFSCompleteRequest( Irp,
1645                             ntStatus);
1646     }
1647
1648     return ntStatus;
1649 }
1650
1651 static
1652 NTSTATUS
1653 AFSExtendingWrite( IN AFSFcb *Fcb,
1654                    IN PFILE_OBJECT FileObject,
1655                    IN LONGLONG NewLength)
1656 {
1657     LARGE_INTEGER liSaveFileSize = Fcb->Header.FileSize;
1658     LARGE_INTEGER liSaveAllocation = Fcb->Header.AllocationSize;
1659     NTSTATUS      ntStatus = STATUS_SUCCESS;
1660     AFSCcb       *pCcb = (AFSCcb *)FileObject->FsContext2;
1661
1662     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1663                   AFS_TRACE_LEVEL_VERBOSE,
1664                   "AFSExtendingWrite Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
1665                   &Fcb->NPFcb->PagingResource,
1666                   PsGetCurrentThread());
1667
1668     AFSAcquireExcl( &Fcb->NPFcb->PagingResource,
1669                     TRUE);
1670
1671     if( NewLength > Fcb->Header.AllocationSize.QuadPart)
1672     {
1673
1674         Fcb->Header.AllocationSize.QuadPart = NewLength;
1675
1676         Fcb->ObjectInformation->AllocationSize = Fcb->Header.AllocationSize;
1677     }
1678
1679     if( NewLength > Fcb->Header.FileSize.QuadPart)
1680     {
1681
1682         Fcb->Header.FileSize.QuadPart = NewLength;
1683
1684         Fcb->ObjectInformation->EndOfFile = Fcb->Header.FileSize;
1685     }
1686
1687     //
1688     // Tell the server
1689     //
1690
1691     ntStatus = AFSUpdateFileInformation( &Fcb->ObjectInformation->ParentObjectInformation->FileId,
1692                                          Fcb->ObjectInformation,
1693                                          &pCcb->AuthGroup);
1694
1695     if (NT_SUCCESS(ntStatus))
1696     {
1697
1698         KeQuerySystemTime( &Fcb->ObjectInformation->ChangeTime);
1699
1700         SetFlag( Fcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED | AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
1701
1702         //
1703         // If the file is currently cached, then let the MM know about the extension
1704         //
1705
1706         if( CcIsFileCached( FileObject))
1707         {
1708             CcSetFileSizes( FileObject,
1709                             (PCC_FILE_SIZES)&Fcb->Header.AllocationSize);
1710         }
1711     }
1712     else
1713     {
1714         Fcb->Header.FileSize = liSaveFileSize;
1715         Fcb->Header.AllocationSize = liSaveAllocation;
1716     }
1717
1718     AFSReleaseResource( &Fcb->NPFcb->PagingResource);
1719
1720     //
1721     // DownConvert file resource to shared
1722     //
1723     ExConvertExclusiveToSharedLite( &Fcb->NPFcb->Resource);
1724
1725     return ntStatus;
1726 }
1727
1728 NTSTATUS
1729 AFSShareWrite( IN PDEVICE_OBJECT DeviceObject,
1730                IN PIRP Irp)
1731 {
1732
1733     NTSTATUS ntStatus = STATUS_SUCCESS;
1734     AFSPIOCtlIORequestCB stIORequestCB;
1735     PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1736     AFSFcb *pFcb = NULL;
1737     AFSCcb *pCcb = NULL;
1738     AFSPipeIORequestCB *pIoRequest = NULL;
1739     void *pBuffer = NULL;
1740     AFSPipeIOResultCB stIoResult;
1741     ULONG ulBytesReturned = 0;
1742
1743     __Enter
1744     {
1745
1746         pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1747
1748         pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1749
1750         AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
1751                       AFS_TRACE_LEVEL_VERBOSE,
1752                       "AFSShareWrite On pipe %wZ Length %08lX\n",
1753                       &pCcb->DirectoryCB->NameInformation.FileName,
1754                       pIrpSp->Parameters.Write.Length);
1755
1756         if( pIrpSp->Parameters.Write.Length == 0)
1757         {
1758
1759             //
1760             // Nothing to do in this case
1761             //
1762
1763             try_return( ntStatus);
1764         }
1765
1766         //
1767         // Retrieve the buffer for the read request
1768         //
1769
1770         pBuffer = AFSLockSystemBuffer( Irp,
1771                                        pIrpSp->Parameters.Write.Length);
1772
1773         if( pBuffer == NULL)
1774         {
1775
1776             AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
1777                           AFS_TRACE_LEVEL_ERROR,
1778                           "AFSShareWrite Failed to map buffer on pipe %wZ\n",
1779                           &pCcb->DirectoryCB->NameInformation.FileName);
1780
1781             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1782         }
1783
1784         AFSAcquireShared( &pFcb->NPFcb->Resource,
1785                           TRUE);
1786
1787         pIoRequest = (AFSPipeIORequestCB *)AFSExAllocatePoolWithTag( PagedPool,
1788                                                                      sizeof( AFSPipeIORequestCB) +
1789                                                                                 pIrpSp->Parameters.Write.Length,
1790                                                                      AFS_GENERIC_MEMORY_14_TAG);
1791
1792         if( pIoRequest == NULL)
1793         {
1794
1795             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1796         }
1797
1798         RtlZeroMemory( pIoRequest,
1799                        sizeof( AFSPipeIORequestCB) + pIrpSp->Parameters.Write.Length);
1800
1801         pIoRequest->RequestId = pCcb->RequestID;
1802
1803         pIoRequest->RootId = pFcb->ObjectInformation->VolumeCB->ObjectInformation.FileId;
1804
1805         pIoRequest->BufferLength = pIrpSp->Parameters.Write.Length;
1806
1807         RtlCopyMemory( (void *)((char *)pIoRequest + sizeof( AFSPipeIORequestCB)),
1808                        pBuffer,
1809                        pIrpSp->Parameters.Write.Length);
1810
1811         stIoResult.BytesProcessed = 0;
1812
1813         ulBytesReturned = sizeof( AFSPipeIOResultCB);
1814
1815         //
1816         // Issue the open request to the service
1817         //
1818
1819         ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_WRITE,
1820                                       AFS_REQUEST_FLAG_SYNCHRONOUS,
1821                                       &pCcb->AuthGroup,
1822                                       &pCcb->DirectoryCB->NameInformation.FileName,
1823                                       NULL,
1824                                       pIoRequest,
1825                                       sizeof( AFSPipeIORequestCB) +
1826                                                 pIrpSp->Parameters.Write.Length,
1827                                       &stIoResult,
1828                                       &ulBytesReturned);
1829
1830         if( !NT_SUCCESS( ntStatus))
1831         {
1832
1833             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1834                           AFS_TRACE_LEVEL_ERROR,
1835                           "AFSShareWrite (%08lX) Failed service write Status %08lX\n",
1836                           Irp,
1837                           ntStatus);
1838
1839             try_return( ntStatus);
1840         }
1841
1842         AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
1843                       AFS_TRACE_LEVEL_VERBOSE,
1844                       "AFSShareWrite Completed on pipe %wZ Length read %08lX\n",
1845                       &pCcb->DirectoryCB->NameInformation.FileName,
1846                       stIoResult.BytesProcessed);
1847
1848         Irp->IoStatus.Information = stIoResult.BytesProcessed;
1849
1850 try_exit:
1851
1852         if( pFcb != NULL)
1853         {
1854
1855             AFSReleaseResource( &pFcb->NPFcb->Resource);
1856         }
1857
1858         if( pIoRequest != NULL)
1859         {
1860
1861             AFSExFreePool( pIoRequest);
1862         }
1863     }
1864
1865     return ntStatus;
1866 }