src/WINNT/afsrdr/kernel/lib/AFSGeneric.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: AFSGeneric.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // Function: AFSExceptionFilter
  43 //
  44 // Description:
  45 //
  46 //      This function is the exception handler
  47 //
  48 // Return:
  49 //
  50 //      A status is returned for the function
  51 //
  52
  53 ULONG
  54 AFSExceptionFilter( IN ULONG Code,
  55                     IN PEXCEPTION_POINTERS ExceptPtrs)
  56 {
  57
  58     PEXCEPTION_RECORD ExceptRec;
  59     PCONTEXT Context;
  60
  61     __try
  62     {
  63
  64         ExceptRec = ExceptPtrs->ExceptionRecord;
  65
  66         Context = ExceptPtrs->ContextRecord;
  67
  68         AFSDbgLogMsg( 0,
  69                       0,
  70                       "AFSExceptionFilter (Library) - EXR %p CXR %p Code %08lX Address %p Routine %p\n",
  71                       ExceptRec,
  72                       Context,
  73                       ExceptRec->ExceptionCode,
  74                       ExceptRec->ExceptionAddress,
  75                       (void *)AFSExceptionFilter);
  76
  77         DbgPrint("**** Exception Caught in AFS Redirector Library ****\n");
  78
  79         DbgPrint("\n\nPerform the following WnDbg Cmds:\n");
  80         DbgPrint("\n\t.exr %p ;  .cxr %p\n\n", ExceptRec, Context);
  81
  82         DbgPrint("**** Exception Complete from AFS Redirector Library ****\n");
  83
  84         if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_BUGCHECK_EXCEPTION))
  85         {
  86
  87             KeBugCheck( (ULONG)-2);
  88         }
  89         else
  90         {
  91
  92             AFSBreakPoint();
  93         }
  94     }
  95     __except( EXCEPTION_EXECUTE_HANDLER)
  96     {
  97
  98         NOTHING;
  99     }
 100
 101     return EXCEPTION_EXECUTE_HANDLER;
 102 }
 103
 104 //
 105 // Function: AFSLibExAllocatePoolWithTag()
 106 //
 107 // Purpose: Allocate Pool Memory.  If BugCheck Exception flag
 108 //          is configured on, then bugcheck the system if
 109 //          a memory allocation fails.  The routine should be
 110 //          used for all memory allocations that are to be freed
 111 //          when the library is unloaded.  Memory allocations that
 112 //          are to survive library unload and reload should be
 113 //          performed using AFSExAllocatePoolWithTag() which is
 114 //          provided by the AFS Framework.
 115 //
 116 // Parameters:
 117 //                POOL_TYPE PoolType - Paged or NonPaged
 118 //                SIZE_T NumberOfBytes - requested allocation size
 119 //                ULONG  Tag - Pool Allocation Tag to be applied for tracking
 120 //
 121 // Return:
 122 //                void * - the memory allocation
 123 //
 124
 125 void *
 126 AFSLibExAllocatePoolWithTag( IN POOL_TYPE  PoolType,
 127                              IN SIZE_T  NumberOfBytes,
 128                              IN ULONG  Tag)
 129 {
 130
 131     void *pBuffer = NULL;
 132
 133     pBuffer = ExAllocatePoolWithTag( PoolType,
 134                                      NumberOfBytes,
 135                                      Tag);
 136
 137     if( pBuffer == NULL)
 138     {
 139
 140         if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_BUGCHECK_EXCEPTION))
 141         {
 142
 143             KeBugCheck( (ULONG)-2);
 144         }
 145         else
 146         {
 147
 148             AFSDbgLogMsg( 0,
 149                           0,
 150                           "AFSLibExAllocatePoolWithTag failure Type %08lX Size %08lX Tag %08lX %08lX\n",
 151                           PoolType,
 152                           NumberOfBytes,
 153                           Tag,
 154                           PsGetCurrentThread());
 155
 156             AFSBreakPoint();
 157         }
 158     }
 159
 160     return pBuffer;
 161 }
 162
 163 //
 164 // Function: AFSAcquireExcl()
 165 //
 166 // Purpose: Called to acquire a resource exclusive with optional wait
 167 //
 168 // Parameters:
 169 //                PERESOURCE Resource - Resource to acquire
 170 //                BOOLEAN Wait - Whether to block
 171 //
 172 // Return:
 173 //                BOOLEAN - Whether the mask was acquired
 174 //
 175
 176 BOOLEAN
 177 AFSAcquireExcl( IN PERESOURCE Resource,
 178                 IN BOOLEAN wait)
 179 {
 180
 181     BOOLEAN bStatus = FALSE;
 182
 183     //
 184     // Normal kernel APCs must be disabled before calling
 185     // ExAcquireResourceExclusiveLite. Otherwise a bugcheck occurs.
 186     //
 187
 188     KeEnterCriticalRegion();
 189
 190     bStatus = ExAcquireResourceExclusiveLite( Resource,
 191                                               wait);
 192
 193     if( !bStatus)
 194     {
 195
 196         KeLeaveCriticalRegion();
 197     }
 198
 199     return bStatus;
 200 }
 201
 202 BOOLEAN
 203 AFSAcquireSharedStarveExclusive( IN PERESOURCE Resource,
 204                                  IN BOOLEAN Wait)
 205 {
 206
 207     BOOLEAN bStatus = FALSE;
 208
 209     KeEnterCriticalRegion();
 210
 211     bStatus = ExAcquireSharedStarveExclusive( Resource,
 212                                               Wait);
 213
 214     if( !bStatus)
 215     {
 216
 217         KeLeaveCriticalRegion();
 218     }
 219
 220     return bStatus;
 221 }
 222
 223 //
 224 // Function: AFSAcquireShared()
 225 //
 226 // Purpose: Called to acquire a resource shared with optional wait
 227 //
 228 // Parameters:
 229 //                PERESOURCE Resource - Resource to acquire
 230 //                BOOLEAN Wait - Whether to block
 231 //
 232 // Return:
 233 //                BOOLEAN - Whether the mask was acquired
 234 //
 235
 236 BOOLEAN
 237 AFSAcquireShared( IN PERESOURCE Resource,
 238                   IN BOOLEAN wait)
 239 {
 240
 241     BOOLEAN bStatus = FALSE;
 242
 243     KeEnterCriticalRegion();
 244
 245     bStatus = ExAcquireResourceSharedLite( Resource,
 246                                            wait);
 247
 248     if( !bStatus)
 249     {
 250
 251         KeLeaveCriticalRegion();
 252     }
 253
 254     return bStatus;
 255 }
 256
 257 //
 258 // Function: AFSReleaseResource()
 259 //
 260 // Purpose: Called to release a resource
 261 //
 262 // Parameters:
 263 //                PERESOURCE Resource - Resource to release
 264 //
 265 // Return:
 266 //                None
 267 //
 268
 269 void
 270 AFSReleaseResource( IN PERESOURCE Resource)
 271 {
 272
 273     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 274                   AFS_TRACE_LEVEL_VERBOSE,
 275                   "AFSReleaseResource Releasing lock %08lX Thread %08lX\n",
 276                   Resource,
 277                   PsGetCurrentThread());
 278
 279     ExReleaseResourceLite( Resource);
 280
 281     KeLeaveCriticalRegion();
 282
 283     return;
 284 }
 285
 286 void
 287 AFSConvertToShared( IN PERESOURCE Resource)
 288 {
 289
 290     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 291                   AFS_TRACE_LEVEL_VERBOSE,
 292                   "AFSConvertToShared Converting lock %08lX Thread %08lX\n",
 293                   Resource,
 294                   PsGetCurrentThread());
 295
 296     ExConvertExclusiveToSharedLite( Resource);
 297
 298     return;
 299 }
 300
 301 //
 302 // Function: AFSCompleteRequest
 303 //
 304 // Description:
 305 //
 306 //      This function completes irps
 307 //
 308 // Return:
 309 //
 310 //      A status is returned for the function
 311 //
 312
 313 void
 314 AFSCompleteRequest( IN PIRP Irp,
 315                     IN ULONG Status)
 316 {
 317
 318     Irp->IoStatus.Status = Status;
 319
 320     IoCompleteRequest( Irp,
 321                        IO_NO_INCREMENT);
 322
 323     return;
 324 }
 325
 326 //
 327 // Function: AFSGenerateCRC
 328 //
 329 // Description:
 330 //
 331 //      Given a device and filename this function generates a CRC
 332 //
 333 // Return:
 334 //
 335 //      A status is returned for the function
 336 //
 337
 338 ULONG
 339 AFSGenerateCRC( IN PUNICODE_STRING FileName,
 340                 IN BOOLEAN UpperCaseName)
 341 {
 342
 343     ULONG ulCRC = 0;
 344     NTSTATUS ntStatus = STATUS_SUCCESS;
 345
 346     ntStatus = RtlHashUnicodeString( FileName,
 347                                      UpperCaseName,
 348                                      HASH_STRING_ALGORITHM_DEFAULT,
 349                                      &ulCRC);
 350
 351     if( !NT_SUCCESS( ntStatus))
 352     {
 353         ulCRC = 0;
 354     }
 355
 356     return ulCRC;
 357 }
 358
 359 void *
 360 AFSLockSystemBuffer( IN PIRP Irp,
 361                      IN ULONG Length)
 362 {
 363
 364     NTSTATUS Status = STATUS_SUCCESS;
 365     void *pAddress = NULL;
 366
 367     if( Irp->MdlAddress != NULL)
 368     {
 369
 370         pAddress = MmGetSystemAddressForMdlSafe( Irp->MdlAddress,
 371                                                  NormalPagePriority);
 372     }
 373     else if( Irp->AssociatedIrp.SystemBuffer != NULL)
 374     {
 375
 376         pAddress = Irp->AssociatedIrp.SystemBuffer;
 377     }
 378     else if( Irp->UserBuffer != NULL)
 379     {
 380
 381         Irp->MdlAddress = IoAllocateMdl( Irp->UserBuffer,
 382                                          Length,
 383                                          FALSE,
 384                                          FALSE,
 385                                          Irp);
 386
 387         if( Irp->MdlAddress != NULL)
 388         {
 389
 390             //
 391             //  Lock the new Mdl in memory.
 392             //
 393
 394             __try
 395             {
 396                 PIO_STACK_LOCATION pIoStack;
 397                 pIoStack = IoGetCurrentIrpStackLocation( Irp);
 398
 399
 400                 MmProbeAndLockPages( Irp->MdlAddress, KernelMode,
 401                                      (pIoStack->MajorFunction == IRP_MJ_READ) ? IoWriteAccess : IoReadAccess);
 402
 403                 pAddress = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority );
 404
 405             }
 406             __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
 407             {
 408
 409                 IoFreeMdl( Irp->MdlAddress );
 410                 Irp->MdlAddress = NULL;
 411                 pAddress = NULL;
 412             }
 413         }
 414     }
 415
 416     return pAddress;
 417 }
 418
 419 void *
 420 AFSLockUserBuffer( IN void *UserBuffer,
 421                    IN ULONG BufferLength,
 422                                    OUT MDL ** Mdl)
 423 {
 424
 425     NTSTATUS ntStatus = STATUS_SUCCESS;
 426     void *pAddress = NULL;
 427     MDL *pMdl = NULL;
 428
 429     __Enter
 430     {
 431
 432         pMdl = IoAllocateMdl( UserBuffer,
 433                               BufferLength,
 434                               FALSE,
 435                               FALSE,
 436                               NULL);
 437
 438             if( pMdl == NULL)
 439             {
 440
 441                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 442             }
 443
 444         //
 445         //  Lock the new Mdl in memory.
 446         //
 447
 448         __try
 449         {
 450
 451             MmProbeAndLockPages( pMdl,
 452                                  KernelMode,
 453                                  IoWriteAccess);
 454
 455             pAddress = MmGetSystemAddressForMdlSafe( pMdl,
 456                                                      NormalPagePriority);
 457         }
 458         __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
 459         {
 460
 461             IoFreeMdl( pMdl);
 462             pMdl = NULL;
 463             pAddress = NULL;
 464         }
 465
 466         if( pMdl != NULL)
 467         {
 468
 469             *Mdl = pMdl;
 470         }
 471
 472 try_exit:
 473
 474         NOTHING;
 475     }
 476
 477     return pAddress;
 478 }
 479
 480 void *
 481 AFSMapToService( IN PIRP Irp,
 482                  IN ULONG ByteCount)
 483 {
 484
 485     NTSTATUS ntStatus = STATUS_SUCCESS;
 486     void *pMappedBuffer = NULL;
 487     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
 488     KAPC stApcState;
 489
 490     __Enter
 491     {
 492
 493         if( pDevExt->Specific.Control.ServiceProcess == NULL)
 494         {
 495
 496             try_return( ntStatus = STATUS_DEVICE_NOT_READY);
 497         }
 498
 499         if( Irp->MdlAddress == NULL)
 500         {
 501
 502             if( AFSLockSystemBuffer( Irp,
 503                                      ByteCount) == NULL)
 504             {
 505
 506                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 507             }
 508         }
 509
 510         //
 511         // Attach to the service process for mapping
 512         //
 513
 514         KeStackAttachProcess( pDevExt->Specific.Control.ServiceProcess,
 515                               (PRKAPC_STATE)&stApcState);
 516
 517         pMappedBuffer = MmMapLockedPagesSpecifyCache( Irp->MdlAddress,
 518                                                       UserMode,
 519                                                       MmCached,
 520                                                       NULL,
 521                                                       FALSE,
 522                                                       NormalPagePriority);
 523
 524         KeUnstackDetachProcess( (PRKAPC_STATE)&stApcState);
 525
 526 try_exit:
 527
 528         NOTHING;
 529     }
 530
 531     return pMappedBuffer;
 532 }
 533
 534 NTSTATUS
 535 AFSUnmapServiceMappedBuffer( IN void *MappedBuffer,
 536                              IN PMDL Mdl)
 537 {
 538
 539     NTSTATUS ntStatus = STATUS_SUCCESS;
 540     void *pMappedBuffer = NULL;
 541     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
 542     KAPC stApcState;
 543
 544     __Enter
 545     {
 546
 547         if( pDevExt->Specific.Control.ServiceProcess == NULL)
 548         {
 549
 550             try_return( ntStatus = STATUS_DEVICE_NOT_READY);
 551         }
 552
 553         if( Mdl != NULL)
 554         {
 555
 556             //
 557             // Attach to the service process for mapping
 558             //
 559
 560             KeStackAttachProcess( pDevExt->Specific.Control.ServiceProcess,
 561                                   (PRKAPC_STATE)&stApcState);
 562
 563             MmUnmapLockedPages( MappedBuffer,
 564                                 Mdl);
 565
 566             KeUnstackDetachProcess( (PRKAPC_STATE)&stApcState);
 567         }
 568
 569 try_exit:
 570
 571         NOTHING;
 572     }
 573
 574     return ntStatus;
 575 }
 576
 577 NTSTATUS
 578 AFSInitializeLibraryDevice()
 579 {
 580
 581     NTSTATUS ntStatus = STATUS_SUCCESS;
 582     AFSDeviceExt *pDeviceExt = NULL;
 583
 584     __Enter
 585     {
 586
 587         pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
 588
 589         //
 590         // The PIOCtl file name
 591         //
 592
 593         RtlInitUnicodeString( &AFSPIOCtlName,
 594                               AFS_PIOCTL_FILE_INTERFACE_NAME);
 595
 596         //
 597         // And the global root share name
 598         //
 599
 600         RtlInitUnicodeString( &AFSGlobalRootName,
 601                               AFS_GLOBAL_ROOT_SHARE_NAME);
 602
 603     }
 604
 605     return ntStatus;
 606 }
 607
 608 NTSTATUS
 609 AFSRemoveLibraryDevice()
 610 {
 611
 612     NTSTATUS ntStatus = STATUS_SUCCESS;
 613
 614     __Enter
 615     {
 616
 617     }
 618
 619     return ntStatus;
 620 }
 621
 622 NTSTATUS
 623 AFSDefaultDispatch( IN PDEVICE_OBJECT DeviceObject,
 624                     IN PIRP Irp)
 625 {
 626
 627     NTSTATUS            ntStatus = STATUS_INVALID_DEVICE_REQUEST;
 628     PIO_STACK_LOCATION  pIrpSp = IoGetCurrentIrpStackLocation( Irp);
 629
 630     AFSCompleteRequest( Irp,
 631                         ntStatus);
 632
 633     return ntStatus;
 634 }
 635
 636 NTSTATUS
 637 AFSInitializeGlobalDirectoryEntries()
 638 {
 639
 640     NTSTATUS ntStatus = STATUS_SUCCESS;
 641     AFSDirectoryCB *pDirNode = NULL;
 642     ULONG ulEntryLength = 0;
 643     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 644     AFSObjectInfoCB *pObjectInfoCB = NULL;
 645     AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
 646     LONG lCount;
 647
 648     __Enter
 649     {
 650
 651         //
 652         // Initialize the global . entry
 653         //
 654
 655         pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
 656                                                0);
 657
 658         if( pObjectInfoCB == NULL)
 659         {
 660
 661             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 662                           AFS_TRACE_LEVEL_ERROR,
 663                           "AFSInitializeGlobalDirectory AFSAllocateObjectInfo failure %08lX\n",
 664                           ntStatus);
 665
 666             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 667         }
 668
 669         lCount = InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
 670
 671         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
 672                       AFS_TRACE_LEVEL_VERBOSE,
 673                       "AFSInitializeGlobalDirectoryEntries Increment count on object %08lX Cnt %d\n",
 674                       pObjectInfoCB,
 675                       lCount);
 676
 677         ntStatus = STATUS_SUCCESS;
 678
 679         ulEntryLength = sizeof( AFSDirectoryCB) +
 680                                      sizeof( WCHAR);
 681
 682         pDirNode = (AFSDirectoryCB *)AFSLibExAllocatePoolWithTag( PagedPool,
 683                                                                   ulEntryLength,
 684                                                                   AFS_DIR_ENTRY_TAG);
 685
 686         if( pDirNode == NULL)
 687         {
 688
 689             AFSDeleteObjectInfo( pObjectInfoCB);
 690
 691             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 692                           AFS_TRACE_LEVEL_ERROR,
 693                           "AFSInitializeGlobalDirectory AFS_DIR_ENTRY_TAG allocation failure\n");
 694
 695             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 696         }
 697
 698         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
 699                                                                                    sizeof( AFSNonPagedDirectoryCB),
 700                                                                                    AFS_DIR_ENTRY_NP_TAG);
 701
 702         if( pNonPagedDirEntry == NULL)
 703         {
 704
 705             ExFreePool( pDirNode);
 706
 707             AFSDeleteObjectInfo( pObjectInfoCB);
 708
 709             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 710                           AFS_TRACE_LEVEL_ERROR,
 711                           "AFSInitializeGlobalDirectory AFS_DIR_ENTRY_NP_TAG allocation failure\n");
 712
 713             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 714         }
 715
 716         RtlZeroMemory( pDirNode,
 717                        ulEntryLength);
 718
 719         RtlZeroMemory( pNonPagedDirEntry,
 720                        sizeof( AFSNonPagedDirectoryCB));
 721
 722         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
 723
 724         pDirNode->NonPaged = pNonPagedDirEntry;
 725
 726         pDirNode->ObjectInformation = pObjectInfoCB;
 727
 728         //
 729         // Set valid entry
 730         //
 731
 732         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE | AFS_DIR_ENTRY_FAKE | AFS_DIR_ENTRY_VALID);
 733
 734         pDirNode->FileIndex = (ULONG)AFS_DIR_ENTRY_DOT_INDEX;
 735
 736         //
 737         // Setup the names in the entry
 738         //
 739
 740         pDirNode->NameInformation.FileName.Length = sizeof( WCHAR);
 741
 742         pDirNode->NameInformation.FileName.MaximumLength = sizeof( WCHAR);
 743
 744         pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
 745
 746         pDirNode->NameInformation.FileName.Buffer[ 0] = L'.';
 747
 748         //
 749         // Populate the rest of the data
 750         //
 751
 752         pObjectInfoCB->FileType = AFS_FILE_TYPE_DIRECTORY;
 753
 754         pObjectInfoCB->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 755
 756         AFSGlobalDotDirEntry = pDirNode;
 757
 758         //
 759         // Now the .. entry
 760         //
 761
 762         pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
 763                                                0);
 764
 765         if( pObjectInfoCB == NULL)
 766         {
 767
 768             AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
 769                           AFS_TRACE_LEVEL_ERROR,
 770                           "AFSInitializeGlobalDirectory AFSAllocateObjectInfo (2) failure %08lX\n",
 771                           ntStatus);
 772
 773             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 774         }
 775
 776         lCount = InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
 777
 778         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
 779                       AFS_TRACE_LEVEL_VERBOSE,
 780                       "AFSInitializeGlobalDirectoryEntries Increment count on object %08lX Cnt %d\n",
 781                       pObjectInfoCB,
 782                       lCount);
 783
 784         ntStatus = STATUS_SUCCESS;
 785
 786         ulEntryLength = sizeof( AFSDirectoryCB) +
 787                                      ( 2 * sizeof( WCHAR));
 788
 789         pDirNode = (AFSDirectoryCB *)AFSLibExAllocatePoolWithTag( PagedPool,
 790                                                                   ulEntryLength,
 791                                                                   AFS_DIR_ENTRY_TAG);
 792
 793         if( pDirNode == NULL)
 794         {
 795
 796             AFSDeleteObjectInfo( pObjectInfoCB);
 797
 798             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 799         }
 800
 801         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
 802                                                                                    sizeof( AFSNonPagedDirectoryCB),
 803                                                                                    AFS_DIR_ENTRY_NP_TAG);
 804
 805         if( pNonPagedDirEntry == NULL)
 806         {
 807
 808             ExFreePool( pDirNode);
 809
 810             AFSDeleteObjectInfo( pObjectInfoCB);
 811
 812             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 813         }
 814
 815         RtlZeroMemory( pDirNode,
 816                        ulEntryLength);
 817
 818         RtlZeroMemory( pNonPagedDirEntry,
 819                        sizeof( AFSNonPagedDirectoryCB));
 820
 821         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
 822
 823         pDirNode->NonPaged = pNonPagedDirEntry;
 824
 825         pDirNode->ObjectInformation = pObjectInfoCB;
 826
 827         //
 828         // Set valid entry
 829         //
 830
 831         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE | AFS_DIR_ENTRY_FAKE | AFS_DIR_ENTRY_VALID);
 832
 833         pDirNode->FileIndex = (ULONG)AFS_DIR_ENTRY_DOT_DOT_INDEX;
 834
 835         //
 836         // Setup the names in the entry
 837         //
 838
 839         pDirNode->NameInformation.FileName.Length = 2 * sizeof( WCHAR);
 840
 841         pDirNode->NameInformation.FileName.MaximumLength = 2 * sizeof( WCHAR);
 842
 843         pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
 844
 845         pDirNode->NameInformation.FileName.Buffer[ 0] = L'.';
 846
 847         pDirNode->NameInformation.FileName.Buffer[ 1] = L'.';
 848
 849         //
 850         // Populate the rest of the data
 851         //
 852
 853         pObjectInfoCB->FileType = AFS_FILE_TYPE_DIRECTORY;
 854
 855         pObjectInfoCB->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 856
 857         AFSGlobalDotDotDirEntry = pDirNode;
 858
 859 try_exit:
 860
 861         if( !NT_SUCCESS( ntStatus))
 862         {
 863
 864             if( AFSGlobalDotDirEntry != NULL)
 865             {
 866
 867                 AFSDeleteObjectInfo( AFSGlobalDotDirEntry->ObjectInformation);
 868
 869                 ExDeleteResourceLite( &AFSGlobalDotDirEntry->NonPaged->Lock);
 870
 871                 ExFreePool( AFSGlobalDotDirEntry->NonPaged);
 872
 873                 ExFreePool( AFSGlobalDotDirEntry);
 874
 875                 AFSGlobalDotDirEntry = NULL;
 876             }
 877
 878             if( AFSGlobalDotDotDirEntry != NULL)
 879             {
 880
 881                 AFSDeleteObjectInfo( AFSGlobalDotDotDirEntry->ObjectInformation);
 882
 883                 ExDeleteResourceLite( &AFSGlobalDotDotDirEntry->NonPaged->Lock);
 884
 885                 ExFreePool( AFSGlobalDotDotDirEntry->NonPaged);
 886
 887                 ExFreePool( AFSGlobalDotDotDirEntry);
 888
 889                 AFSGlobalDotDotDirEntry = NULL;
 890             }
 891         }
 892     }
 893
 894     return ntStatus;
 895 }
 896
 897 AFSDirectoryCB *
 898 AFSInitDirEntry( IN AFSObjectInfoCB *ParentObjectInfo,
 899                  IN PUNICODE_STRING FileName,
 900                  IN PUNICODE_STRING TargetName,
 901                  IN AFSDirEnumEntry *DirEnumEntry,
 902                  IN ULONG FileIndex)
 903 {
 904
 905     AFSDirectoryCB *pDirNode = NULL;
 906     NTSTATUS ntStatus = STATUS_SUCCESS;
 907     ULONG ulEntryLength = 0;
 908     AFSDirEnumEntry *pDirEnumCB = NULL;
 909     AFSFileID stTargetFileID;
 910     AFSFcb *pVcb = NULL;
 911     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
 912     AFSObjectInfoCB *pObjectInfoCB = NULL;
 913     BOOLEAN bAllocatedObjectCB = FALSE;
 914     ULONGLONG ullIndex = 0;
 915     AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
 916     LONG lCount;
 917
 918     __Enter
 919     {
 920
 921         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 922                       AFS_TRACE_LEVEL_VERBOSE,
 923                       "AFSInitDirEntry Initializing entry %wZ parent FID %08lX-%08lX-%08lX-%08lX\n",
 924                       FileName,
 925                       ParentObjectInfo->FileId.Cell,
 926                       ParentObjectInfo->FileId.Volume,
 927                       ParentObjectInfo->FileId.Vnode,
 928                       ParentObjectInfo->FileId.Unique);
 929
 930         //
 931         // First thing is to locate/create our object information block
 932         // for this entry
 933         //
 934
 935         AFSAcquireExcl( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeLock,
 936                         TRUE);
 937
 938         ullIndex = AFSCreateLowIndex( &DirEnumEntry->FileId);
 939
 940         ntStatus = AFSLocateHashEntry( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeHead,
 941                                        ullIndex,
 942                                        (AFSBTreeEntry **)&pObjectInfoCB);
 943
 944         if( !NT_SUCCESS( ntStatus) ||
 945             pObjectInfoCB == NULL)
 946         {
 947
 948             //
 949             // Allocate our object info cb
 950             //
 951
 952             pObjectInfoCB = AFSAllocateObjectInfo( ParentObjectInfo,
 953                                                    ullIndex);
 954
 955             if( pObjectInfoCB == NULL)
 956             {
 957
 958                 AFSReleaseResource( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
 959
 960                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 961             }
 962
 963             bAllocatedObjectCB = TRUE;
 964
 965             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 966                           AFS_TRACE_LEVEL_VERBOSE,
 967                           "AFSInitDirEntry initialized object %08lX Parent Object %08lX for %wZ\n",
 968                           pObjectInfoCB,
 969                           ParentObjectInfo,
 970                           FileName);
 971         }
 972
 973         lCount = InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
 974
 975         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
 976                       AFS_TRACE_LEVEL_VERBOSE,
 977                       "AFSInitDirEntry Increment count on object %08lX Cnt %d\n",
 978                       pObjectInfoCB,
 979                       lCount);
 980
 981         AFSReleaseResource( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
 982
 983         ntStatus = STATUS_SUCCESS;
 984
 985         ulEntryLength = sizeof( AFSDirectoryCB) +
 986                                      FileName->Length;
 987
 988         if( TargetName != NULL)
 989         {
 990
 991             ulEntryLength += TargetName->Length;
 992         }
 993
 994         pDirNode = (AFSDirectoryCB *)AFSExAllocatePoolWithTag( PagedPool,
 995                                                                ulEntryLength,
 996                                                                AFS_DIR_ENTRY_TAG);
 997
 998         if( pDirNode == NULL)
 999         {
1000
1001             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1002         }
1003
1004         pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSExAllocatePoolWithTag( NonPagedPool,
1005                                                                                 sizeof( AFSNonPagedDirectoryCB),
1006                                                                                 AFS_DIR_ENTRY_NP_TAG);
1007
1008         if( pNonPagedDirEntry == NULL)
1009         {
1010
1011             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1012         }
1013
1014         RtlZeroMemory( pDirNode,
1015                        ulEntryLength);
1016
1017         RtlZeroMemory( pNonPagedDirEntry,
1018                        sizeof( AFSNonPagedDirectoryCB));
1019
1020         ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
1021
1022         pDirNode->NonPaged = pNonPagedDirEntry;
1023
1024         pDirNode->ObjectInformation = pObjectInfoCB;
1025
1026         //
1027         // Set valid entry and NOT_IN_PARENT flag
1028         //
1029
1030         SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
1031
1032         pDirNode->FileIndex = FileIndex;
1033
1034         //
1035         // Setup the names in the entry
1036         //
1037
1038         if( FileName->Length > 0)
1039         {
1040
1041             pDirNode->NameInformation.FileName.Length = FileName->Length;
1042
1043             pDirNode->NameInformation.FileName.MaximumLength = FileName->Length;
1044
1045             pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
1046
1047             RtlCopyMemory( pDirNode->NameInformation.FileName.Buffer,
1048                            FileName->Buffer,
1049                            pDirNode->NameInformation.FileName.Length);
1050
1051             //
1052             // Create a CRC for the file
1053             //
1054
1055             pDirNode->CaseSensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
1056                                                                          FALSE);
1057
1058             pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
1059                                                                            TRUE);
1060         }
1061
1062         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1063                       AFS_TRACE_LEVEL_VERBOSE,
1064                       "AFSInitDirEntry Initialized DE %p for %wZ in parent FID %08lX-%08lX-%08lX-%08lX\n",
1065                       pDirNode,
1066                       FileName,
1067                       ParentObjectInfo->FileId.Cell,
1068                       ParentObjectInfo->FileId.Volume,
1069                       ParentObjectInfo->FileId.Vnode,
1070                       ParentObjectInfo->FileId.Unique);
1071
1072         if( TargetName != NULL &&
1073             TargetName->Length > 0)
1074         {
1075
1076             pDirNode->NameInformation.TargetName.Length = TargetName->Length;
1077
1078             pDirNode->NameInformation.TargetName.MaximumLength = pDirNode->NameInformation.TargetName.Length;
1079
1080             pDirNode->NameInformation.TargetName.Buffer = (WCHAR *)((char *)pDirNode +
1081                                                                             sizeof( AFSDirectoryCB) +
1082                                                                             pDirNode->NameInformation.FileName.Length);
1083
1084             RtlCopyMemory( pDirNode->NameInformation.TargetName.Buffer,
1085                            TargetName->Buffer,
1086                            pDirNode->NameInformation.TargetName.Length);
1087         }
1088
1089         //
1090         // If we allocated the object information cb then update the information
1091         //
1092
1093         if( bAllocatedObjectCB)
1094         {
1095
1096             //
1097             // Populate the rest of the data
1098             //
1099
1100             pObjectInfoCB->FileId = DirEnumEntry->FileId;
1101
1102             pObjectInfoCB->TargetFileId = DirEnumEntry->TargetFileId;
1103
1104             pObjectInfoCB->FileType = DirEnumEntry->FileType;
1105
1106             pObjectInfoCB->CreationTime = DirEnumEntry->CreationTime;
1107
1108             pObjectInfoCB->LastAccessTime = DirEnumEntry->LastAccessTime;
1109
1110             pObjectInfoCB->LastWriteTime = DirEnumEntry->LastWriteTime;
1111
1112             pObjectInfoCB->ChangeTime = DirEnumEntry->ChangeTime;
1113
1114             pObjectInfoCB->EndOfFile = DirEnumEntry->EndOfFile;
1115
1116             pObjectInfoCB->AllocationSize = DirEnumEntry->AllocationSize;
1117
1118             pObjectInfoCB->FileAttributes = DirEnumEntry->FileAttributes;
1119
1120             if( pObjectInfoCB->FileType == AFS_FILE_TYPE_MOUNTPOINT)
1121             {
1122
1123                 pObjectInfoCB->FileAttributes = (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
1124             }
1125
1126             if (pObjectInfoCB->FileType == AFS_FILE_TYPE_SYMLINK ||
1127                 pObjectInfoCB->FileType == AFS_FILE_TYPE_DFSLINK)
1128             {
1129
1130                 pObjectInfoCB->FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
1131             }
1132
1133             pObjectInfoCB->EaSize = DirEnumEntry->EaSize;
1134
1135             //
1136             // Object specific information
1137             //
1138
1139             pObjectInfoCB->Links = DirEnumEntry->Links;
1140
1141             pObjectInfoCB->Expiration = DirEnumEntry->Expiration;
1142
1143             pObjectInfoCB->DataVersion = DirEnumEntry->DataVersion;
1144
1145             //
1146             // Check for the case where we have a filetype of SymLink but both the TargetFid and the
1147             // TargetName are empty. In this case set the filetype to zero so we evaluate it later in
1148             // the code
1149             //
1150
1151             if( pObjectInfoCB->FileType == AFS_FILE_TYPE_SYMLINK &&
1152                 pObjectInfoCB->TargetFileId.Vnode == 0 &&
1153                 pObjectInfoCB->TargetFileId.Unique == 0 &&
1154                 pDirNode->NameInformation.TargetName.Length == 0)
1155             {
1156
1157                 //
1158                 // This will ensure we perform a validation on the node
1159                 //
1160
1161                 pObjectInfoCB->FileType = AFS_FILE_TYPE_UNKNOWN;
1162             }
1163
1164             if( pObjectInfoCB->FileType == AFS_FILE_TYPE_UNKNOWN)
1165             {
1166
1167                 SetFlag( pObjectInfoCB->Flags, AFS_OBJECT_FLAGS_NOT_EVALUATED);
1168             }
1169         }
1170
1171 try_exit:
1172
1173         if( !NT_SUCCESS( ntStatus))
1174         {
1175
1176             if( pNonPagedDirEntry != NULL)
1177             {
1178
1179                 ExDeleteResourceLite( &pNonPagedDirEntry->Lock);
1180
1181                 AFSExFreePool( pNonPagedDirEntry);
1182             }
1183
1184             if( pDirNode != NULL)
1185             {
1186
1187                 AFSExFreePool( pDirNode);
1188
1189                 pDirNode = NULL;
1190             }
1191
1192             //
1193             // Dereference our object info block if we have one
1194             //
1195
1196             if( pObjectInfoCB != NULL)
1197             {
1198
1199                 lCount = InterlockedDecrement( &pObjectInfoCB->ObjectReferenceCount);
1200
1201                 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
1202                               AFS_TRACE_LEVEL_VERBOSE,
1203                               "AFSInitDirEntry Decrement count on object %08lX Cnt %d\n",
1204                               pObjectInfoCB,
1205                               lCount);
1206
1207                 if( bAllocatedObjectCB)
1208                 {
1209
1210                     ASSERT( pObjectInfoCB->ObjectReferenceCount == 0);
1211
1212                     AFSDeleteObjectInfo( pObjectInfoCB);
1213                 }
1214             }
1215         }
1216     }
1217
1218     return pDirNode;
1219 }
1220
1221 BOOLEAN
1222 AFSCheckForReadOnlyAccess( IN ACCESS_MASK DesiredAccess,
1223                            IN BOOLEAN DirectoryEntry)
1224 {
1225
1226     BOOLEAN bReturn = TRUE;
1227     ACCESS_MASK stAccessMask = 0;
1228
1229     //
1230     // Get rid of anything we don't know about
1231     //
1232
1233     DesiredAccess = (DesiredAccess   &
1234                           ( DELETE |
1235                             READ_CONTROL |
1236                             WRITE_OWNER |
1237                             WRITE_DAC |
1238                             SYNCHRONIZE |
1239                             ACCESS_SYSTEM_SECURITY |
1240                             FILE_WRITE_DATA |
1241                             FILE_READ_EA |
1242                             FILE_WRITE_EA |
1243                             FILE_READ_ATTRIBUTES |
1244                             FILE_WRITE_ATTRIBUTES |
1245                             FILE_LIST_DIRECTORY |
1246                             FILE_TRAVERSE |
1247                             FILE_DELETE_CHILD |
1248                             FILE_APPEND_DATA));
1249
1250     //
1251     // Our 'read only' access mask. These are the accesses we will
1252     // allow for a read only file
1253     //
1254
1255     stAccessMask = DELETE |
1256                         READ_CONTROL |
1257                         WRITE_OWNER |
1258                         WRITE_DAC |
1259                         SYNCHRONIZE |
1260                         ACCESS_SYSTEM_SECURITY |
1261                         FILE_READ_DATA |
1262                         FILE_READ_EA |
1263                         FILE_WRITE_EA |
1264                         FILE_READ_ATTRIBUTES |
1265                         FILE_WRITE_ATTRIBUTES |
1266                         FILE_EXECUTE |
1267                         FILE_LIST_DIRECTORY |
1268                         FILE_TRAVERSE;
1269
1270     //
1271     // For a directory, add in the directory specific accesses
1272     //
1273
1274     if( DirectoryEntry)
1275     {
1276
1277         stAccessMask |= FILE_ADD_SUBDIRECTORY |
1278                                 FILE_ADD_FILE |
1279                                 FILE_DELETE_CHILD;
1280     }
1281
1282     if( FlagOn( DesiredAccess, ~stAccessMask))
1283     {
1284
1285         //
1286         // A write access is set ...
1287         //
1288
1289         bReturn = FALSE;
1290     }
1291
1292     return bReturn;
1293 }
1294
1295 NTSTATUS
1296 AFSEvaluateNode( IN GUID *AuthGroup,
1297                  IN AFSDirectoryCB *DirEntry)
1298 {
1299
1300     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1301     NTSTATUS ntStatus = STATUS_SUCCESS;
1302     AFSDirEnumEntry *pDirEntry = NULL;
1303     UNICODE_STRING uniTargetName;
1304
1305     __Enter
1306     {
1307
1308         ntStatus = AFSEvaluateTargetByID( DirEntry->ObjectInformation,
1309                                           AuthGroup,
1310                                           FALSE,
1311                                           &pDirEntry);
1312
1313         if( !NT_SUCCESS( ntStatus))
1314         {
1315
1316             try_return( ntStatus);
1317         }
1318
1319         DirEntry->ObjectInformation->TargetFileId = pDirEntry->TargetFileId;
1320
1321         DirEntry->ObjectInformation->Expiration = pDirEntry->Expiration;
1322
1323         DirEntry->ObjectInformation->DataVersion = pDirEntry->DataVersion;
1324
1325         DirEntry->ObjectInformation->FileType = pDirEntry->FileType;
1326
1327         DirEntry->ObjectInformation->CreationTime = pDirEntry->CreationTime;
1328
1329         DirEntry->ObjectInformation->LastAccessTime = pDirEntry->LastAccessTime;
1330
1331         DirEntry->ObjectInformation->LastWriteTime = pDirEntry->LastWriteTime;
1332
1333         DirEntry->ObjectInformation->ChangeTime = pDirEntry->ChangeTime;
1334
1335         DirEntry->ObjectInformation->EndOfFile = pDirEntry->EndOfFile;
1336
1337         DirEntry->ObjectInformation->AllocationSize = pDirEntry->AllocationSize;
1338
1339         DirEntry->ObjectInformation->FileAttributes = pDirEntry->FileAttributes;
1340
1341         if( pDirEntry->FileType == AFS_FILE_TYPE_MOUNTPOINT)
1342         {
1343
1344             DirEntry->ObjectInformation->FileAttributes = (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
1345         }
1346
1347         if( pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK ||
1348             pDirEntry->FileType == AFS_FILE_TYPE_DFSLINK)
1349         {
1350
1351             DirEntry->ObjectInformation->FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
1352         }
1353
1354         DirEntry->ObjectInformation->EaSize = pDirEntry->EaSize;
1355
1356         DirEntry->ObjectInformation->Links = pDirEntry->Links;
1357
1358         //
1359         // If we have a target name then see if it needs updating ...
1360         //
1361
1362         if( pDirEntry->TargetNameLength > 0)
1363         {
1364
1365             //
1366             // Update the target name information if needed
1367             //
1368
1369             uniTargetName.Length = (USHORT)pDirEntry->TargetNameLength;
1370
1371             uniTargetName.MaximumLength = uniTargetName.Length;
1372
1373             uniTargetName.Buffer = (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset);
1374
1375             AFSAcquireExcl( &DirEntry->NonPaged->Lock,
1376                             TRUE);
1377
1378             if( DirEntry->NameInformation.TargetName.Length == 0 ||
1379                 RtlCompareUnicodeString( &uniTargetName,
1380                                          &DirEntry->NameInformation.TargetName,
1381                                          TRUE) != 0)
1382             {
1383
1384                 //
1385                 // Update the target name
1386                 //
1387
1388                 ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
1389                                                 &DirEntry->Flags,
1390                                                 uniTargetName.Buffer,
1391                                                 uniTargetName.Length);
1392
1393                 if( !NT_SUCCESS( ntStatus))
1394                 {
1395
1396                     AFSReleaseResource( &DirEntry->NonPaged->Lock);
1397
1398                     try_return( ntStatus);
1399                 }
1400             }
1401
1402             AFSReleaseResource( &DirEntry->NonPaged->Lock);
1403         }
1404
1405 try_exit:
1406
1407         if( pDirEntry != NULL)
1408         {
1409
1410             AFSExFreePool( pDirEntry);
1411         }
1412     }
1413
1414     return ntStatus;
1415 }
1416
1417 NTSTATUS
1418 AFSValidateSymLink( IN GUID *AuthGroup,
1419                     IN AFSDirectoryCB *DirEntry)
1420 {
1421
1422     AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1423     NTSTATUS ntStatus = STATUS_SUCCESS;
1424     AFSDirEnumEntry *pDirEntry = NULL;
1425     UNICODE_STRING uniTargetName;
1426
1427     __Enter
1428     {
1429
1430         ntStatus = AFSEvaluateTargetByID( DirEntry->ObjectInformation,
1431                                           AuthGroup,
1432                                           FALSE,
1433                                           &pDirEntry);
1434
1435         if( !NT_SUCCESS( ntStatus))
1436         {
1437
1438             try_return( ntStatus);
1439         }
1440
1441         if( pDirEntry->FileType == AFS_FILE_TYPE_UNKNOWN ||
1442             pDirEntry->FileType == AFS_FILE_TYPE_INVALID)
1443         {
1444
1445             try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
1446         }
1447
1448         DirEntry->ObjectInformation->TargetFileId = pDirEntry->TargetFileId;
1449
1450         DirEntry->ObjectInformation->Expiration = pDirEntry->Expiration;
1451
1452         DirEntry->ObjectInformation->DataVersion = pDirEntry->DataVersion;
1453
1454         //
1455         // Update the target name information if needed
1456         //
1457
1458         uniTargetName.Length = (USHORT)pDirEntry->TargetNameLength;
1459
1460         uniTargetName.MaximumLength = uniTargetName.Length;
1461
1462         uniTargetName.Buffer = (WCHAR *)((char *)pDirEntry + pDirEntry->TargetNameOffset);
1463
1464         if( uniTargetName.Length > 0)
1465         {
1466
1467             AFSAcquireExcl( &DirEntry->NonPaged->Lock,
1468                             TRUE);
1469
1470             if( DirEntry->NameInformation.TargetName.Length == 0 ||
1471                 RtlCompareUnicodeString( &uniTargetName,
1472                                          &DirEntry->NameInformation.TargetName,
1473                                          TRUE) != 0)
1474             {
1475
1476                 //
1477                 // Update the target name
1478                 //
1479
1480                 ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
1481                                                 &DirEntry->Flags,
1482                                                 uniTargetName.Buffer,
1483                                                 uniTargetName.Length);
1484
1485                 if( !NT_SUCCESS( ntStatus))
1486                 {
1487
1488                     AFSReleaseResource( &DirEntry->NonPaged->Lock);
1489
1490                     try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1491                 }
1492             }
1493
1494             AFSReleaseResource( &DirEntry->NonPaged->Lock);
1495         }
1496
1497         //
1498         // If the FileType is the same then nothing to do since it IS
1499         // a SymLink
1500         //
1501
1502         if( pDirEntry->FileType == DirEntry->ObjectInformation->FileType)
1503         {
1504
1505             ASSERT( pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK);
1506
1507             try_return( ntStatus = STATUS_SUCCESS);
1508         }
1509
1510         DirEntry->ObjectInformation->FileType = pDirEntry->FileType;
1511
1512         DirEntry->ObjectInformation->CreationTime = pDirEntry->CreationTime;
1513
1514         DirEntry->ObjectInformation->LastAccessTime = pDirEntry->LastAccessTime;
1515
1516         DirEntry->ObjectInformation->LastWriteTime = pDirEntry->LastWriteTime;
1517
1518         DirEntry->ObjectInformation->ChangeTime = pDirEntry->ChangeTime;
1519
1520         DirEntry->ObjectInformation->EndOfFile = pDirEntry->EndOfFile;
1521
1522         DirEntry->ObjectInformation->AllocationSize = pDirEntry->AllocationSize;
1523
1524         DirEntry->ObjectInformation->FileAttributes = pDirEntry->FileAttributes;
1525
1526         if( pDirEntry->FileType == AFS_FILE_TYPE_MOUNTPOINT)
1527         {
1528
1529             DirEntry->ObjectInformation->FileAttributes = (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
1530         }
1531
1532         if( pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK ||
1533             pDirEntry->FileType == AFS_FILE_TYPE_DFSLINK)
1534         {
1535
1536             DirEntry->ObjectInformation->FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
1537         }
1538
1539         DirEntry->ObjectInformation->EaSize = pDirEntry->EaSize;
1540
1541         DirEntry->ObjectInformation->Links = pDirEntry->Links;
1542
1543 try_exit:
1544
1545         if( pDirEntry != NULL)
1546         {
1547
1548             AFSExFreePool( pDirEntry);
1549         }
1550     }
1551
1552     return ntStatus;
1553 }
1554
1555 NTSTATUS
1556 AFSInvalidateObject( IN OUT AFSObjectInfoCB **ppObjectInfo,
1557                      IN     ULONG Reason)
1558 {
1559
1560     NTSTATUS ntStatus = STATUS_SUCCESS;
1561     IO_STATUS_BLOCK stIoStatus;
1562     ULONG ulFilter = 0;
1563
1564     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1565                   AFS_TRACE_LEVEL_VERBOSE,
1566                   "AFSInvalidateObject Invalidation on node type %d for fid %08lX-%08lX-%08lX-%08lX Reason %d\n",
1567                   (*ppObjectInfo)->FileType,
1568                   (*ppObjectInfo)->FileId.Cell,
1569                   (*ppObjectInfo)->FileId.Volume,
1570                   (*ppObjectInfo)->FileId.Vnode,
1571                   (*ppObjectInfo)->FileId.Unique,
1572                   Reason);
1573
1574     if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_SYMLINK ||
1575         (*ppObjectInfo)->FileType == AFS_FILE_TYPE_DFSLINK ||
1576         (*ppObjectInfo)->FileType == AFS_FILE_TYPE_MOUNTPOINT)
1577     {
1578         //
1579         // We only act on the mount point itself, not the target. If the
1580         // node has been deleted then mark it as such otherwise indicate
1581         // it requires verification
1582         //
1583
1584         if( Reason == AFS_INVALIDATE_DELETED)
1585         {
1586             SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
1587         }
1588         else
1589         {
1590
1591             if( Reason == AFS_INVALIDATE_FLUSHED)
1592             {
1593
1594                 (*ppObjectInfo)->DataVersion.QuadPart = (ULONGLONG)-1;
1595
1596                 SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
1597             }
1598
1599             (*ppObjectInfo)->Expiration.QuadPart = 0;
1600
1601             (*ppObjectInfo)->TargetFileId.Vnode = 0;
1602
1603             (*ppObjectInfo)->TargetFileId.Unique = 0;
1604
1605             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1606                           AFS_TRACE_LEVEL_VERBOSE,
1607                           "AFSInvalidateObject Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
1608                           (*ppObjectInfo)->FileId.Cell,
1609                           (*ppObjectInfo)->FileId.Volume,
1610                           (*ppObjectInfo)->FileId.Vnode,
1611                           (*ppObjectInfo)->FileId.Unique);
1612
1613             SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_VERIFY);
1614         }
1615
1616         ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
1617
1618         if( Reason == AFS_INVALIDATE_CREDS)
1619         {
1620             ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
1621         }
1622
1623         if( Reason == AFS_INVALIDATE_DATA_VERSION ||
1624             Reason == AFS_INVALIDATE_FLUSHED)
1625         {
1626             ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
1627         }
1628         else
1629         {
1630             ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1631         }
1632
1633         AFSFsRtlNotifyFullReportChange( (*ppObjectInfo)->ParentObjectInformation,
1634                                         NULL,
1635                                         ulFilter,
1636                                         FILE_ACTION_MODIFIED);
1637
1638         try_return( ntStatus);
1639     }
1640
1641     //
1642     // Depending on the reason for invalidation then perform work on the node
1643     //
1644
1645     switch( Reason)
1646     {
1647
1648     case AFS_INVALIDATE_DELETED:
1649         {
1650
1651             //
1652             // Mark this node as invalid
1653             //
1654
1655             SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_DELETED);
1656
1657             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1658                           AFS_TRACE_LEVEL_VERBOSE,
1659                           "AFSInvalidateObject Set DELETE flag on fid %08lX-%08lX-%08lX-%08lX\n",
1660                           (*ppObjectInfo)->FileId.Cell,
1661                           (*ppObjectInfo)->FileId.Volume,
1662                           (*ppObjectInfo)->FileId.Vnode,
1663                           (*ppObjectInfo)->FileId.Unique);
1664
1665             if( (*ppObjectInfo)->ParentObjectInformation != NULL)
1666             {
1667
1668                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1669                               AFS_TRACE_LEVEL_VERBOSE,
1670                               "AFSInvalidateObject Set VERIFY flag on parent fid %08lX-%08lX-%08lX-%08lX\n",
1671                               (*ppObjectInfo)->ParentObjectInformation->FileId.Cell,
1672                               (*ppObjectInfo)->ParentObjectInformation->FileId.Volume,
1673                               (*ppObjectInfo)->ParentObjectInformation->FileId.Vnode,
1674                               (*ppObjectInfo)->ParentObjectInformation->FileId.Unique);
1675
1676                 SetFlag( (*ppObjectInfo)->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
1677
1678                 (*ppObjectInfo)->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
1679
1680                 (*ppObjectInfo)->ParentObjectInformation->Expiration.QuadPart = 0;
1681             }
1682
1683             if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_DIRECTORY)
1684             {
1685                 ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
1686             }
1687             else
1688             {
1689                 ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
1690             }
1691
1692             AFSFsRtlNotifyFullReportChange( (*ppObjectInfo)->ParentObjectInformation,
1693                                             NULL,
1694                                             ulFilter,
1695                                             FILE_ACTION_REMOVED);
1696
1697             if( NT_SUCCESS( AFSQueueInvalidateObject( (*ppObjectInfo),
1698                                                       Reason)))
1699             {
1700                 (*ppObjectInfo) = NULL; // We'll dec the count in the worker item
1701             }
1702
1703             break;
1704         }
1705
1706     case AFS_INVALIDATE_FLUSHED:
1707         {
1708
1709             if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_FILE &&
1710                 (*ppObjectInfo)->Fcb != NULL)
1711             {
1712
1713                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1714                               AFS_TRACE_LEVEL_VERBOSE,
1715                               "AFSInvalidateObject Flush/purge file fid %08lX-%08lX-%08lX-%08lX\n",
1716                               (*ppObjectInfo)->FileId.Cell,
1717                               (*ppObjectInfo)->FileId.Volume,
1718                               (*ppObjectInfo)->FileId.Vnode,
1719                               (*ppObjectInfo)->FileId.Unique);
1720
1721                 AFSAcquireExcl( &(*ppObjectInfo)->Fcb->NPFcb->Resource,
1722                                 TRUE);
1723
1724                 __try
1725                 {
1726
1727                     CcFlushCache( &(*ppObjectInfo)->Fcb->NPFcb->SectionObjectPointers,
1728                                   NULL,
1729                                   0,
1730                                   &stIoStatus);
1731
1732                     if( !NT_SUCCESS( stIoStatus.Status))
1733                     {
1734
1735                         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1736                                       AFS_TRACE_LEVEL_ERROR,
1737                                       "AFSInvalidateObject CcFlushCache failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
1738                                       (*ppObjectInfo)->FileId.Cell,
1739                                       (*ppObjectInfo)->FileId.Volume,
1740                                       (*ppObjectInfo)->FileId.Vnode,
1741                                       (*ppObjectInfo)->FileId.Unique,
1742                                       stIoStatus.Status,
1743                                       stIoStatus.Information);
1744
1745                         ntStatus = stIoStatus.Status;
1746                     }
1747
1748                     if ( !CcPurgeCacheSection( &(*ppObjectInfo)->Fcb->NPFcb->SectionObjectPointers,
1749                                                NULL,
1750                                                0,
1751                                                FALSE))
1752                     {
1753
1754                         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1755                                       AFS_TRACE_LEVEL_WARNING,
1756                                       "AFSInvalidateObject CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
1757                                       (*ppObjectInfo)->FileId.Cell,
1758                                       (*ppObjectInfo)->FileId.Volume,
1759                                       (*ppObjectInfo)->FileId.Vnode,
1760                                       (*ppObjectInfo)->FileId.Unique);
1761
1762                         SetFlag( (*ppObjectInfo)->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
1763                     }
1764                 }
1765                 __except( EXCEPTION_EXECUTE_HANDLER)
1766                 {
1767
1768                     ntStatus = GetExceptionCode();
1769
1770                     AFSDbgLogMsg( 0,
1771                                   0,
1772                                   "EXCEPTION - AFSInvalidateObject Cc FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
1773                                   (*ppObjectInfo)->FileId.Cell,
1774                                   (*ppObjectInfo)->FileId.Volume,
1775                                   (*ppObjectInfo)->FileId.Vnode,
1776                                   (*ppObjectInfo)->FileId.Unique,
1777                                   ntStatus);
1778
1779                     SetFlag( (*ppObjectInfo)->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
1780                 }
1781
1782                 AFSReleaseResource( &(*ppObjectInfo)->Fcb->NPFcb->Resource);
1783
1784                 //
1785                 // Clear out the extents
1786                 // Get rid of them (note this involves waiting
1787                 // for any writes or reads to the cache to complete)
1788                 //
1789
1790                 (VOID) AFSTearDownFcbExtents( (*ppObjectInfo)->Fcb,
1791                                               NULL);
1792             }
1793
1794             (*ppObjectInfo)->DataVersion.QuadPart = (ULONGLONG)-1;
1795
1796
1797             if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_FILE)
1798             {
1799
1800                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1801                               AFS_TRACE_LEVEL_VERBOSE,
1802                               "AFSInvalidateObject Setting VERIFY_DATA flag on fid %08lX-%08lX-%08lX-%08lX\n",
1803                               (*ppObjectInfo)->FileId.Cell,
1804                               (*ppObjectInfo)->FileId.Volume,
1805                               (*ppObjectInfo)->FileId.Vnode,
1806                               (*ppObjectInfo)->FileId.Unique);
1807
1808                 SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
1809             }
1810
1811             // Fall through to the default processing
1812         }
1813
1814     default:
1815         {
1816
1817             if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_DIRECTORY)
1818             {
1819                 ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
1820             }
1821             else
1822             {
1823                 ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
1824             }
1825
1826             if( Reason == AFS_INVALIDATE_CREDS)
1827             {
1828                 ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
1829             }
1830
1831             if( Reason == AFS_INVALIDATE_DATA_VERSION)
1832             {
1833                 ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
1834             }
1835             else
1836             {
1837                 ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
1838             }
1839
1840             AFSFsRtlNotifyFullReportChange( (*ppObjectInfo)->ParentObjectInformation,
1841                                             NULL,
1842                                             ulFilter,
1843                                             FILE_ACTION_MODIFIED);
1844
1845             //
1846             // Indicate this node requires re-evaluation for the remaining reasons
1847             //
1848
1849             (*ppObjectInfo)->Expiration.QuadPart = 0;
1850
1851             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1852                           AFS_TRACE_LEVEL_VERBOSE,
1853                           "AFSInvalidateObject Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
1854                           (*ppObjectInfo)->FileId.Cell,
1855                           (*ppObjectInfo)->FileId.Volume,
1856                           (*ppObjectInfo)->FileId.Vnode,
1857                           (*ppObjectInfo)->FileId.Unique);
1858
1859             SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_VERIFY);
1860
1861             if( Reason == AFS_INVALIDATE_DATA_VERSION ||
1862                 (*ppObjectInfo)->FileType == AFS_FILE_TYPE_FILE &&
1863                 ( Reason == AFS_INVALIDATE_CALLBACK ||
1864                   Reason == AFS_INVALIDATE_EXPIRED))
1865             {
1866                 if ( NT_SUCCESS( AFSQueueInvalidateObject( (*ppObjectInfo),
1867                                                            AFS_INVALIDATE_DATA_VERSION)))
1868                 {
1869
1870                     (*ppObjectInfo) = NULL; // We'll dec the count in the worker item
1871                 }
1872             }
1873
1874             break;
1875         }
1876     }
1877
1878   try_exit:
1879
1880     return ntStatus;
1881 }
1882
1883 NTSTATUS
1884 AFSInvalidateCache( IN AFSInvalidateCacheCB *InvalidateCB)
1885 {
1886
1887     NTSTATUS ntStatus = STATUS_SUCCESS;
1888     AFSFcb      *pDcb = NULL, *pFcb = NULL, *pNextFcb = NULL;
1889     AFSVolumeCB *pVolumeCB = NULL;
1890     AFSFcb      *pTargetDcb = NULL;
1891     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
1892     AFSDirectoryCB *pCurrentDirEntry = NULL;
1893     BOOLEAN     bIsChild = FALSE;
1894     ULONGLONG   ullIndex = 0;
1895     AFSObjectInfoCB *pObjectInfo = NULL;
1896     LONG lCount;
1897
1898     __Enter
1899     {
1900
1901         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1902                       AFS_TRACE_LEVEL_VERBOSE,
1903                       "AFSInvalidateCache Invalidation FID %08lX-%08lX-%08lX-%08lX Type %d WholeVolume %d Reason %d\n",
1904                       InvalidateCB->FileID.Cell,
1905                       InvalidateCB->FileID.Volume,
1906                       InvalidateCB->FileID.Vnode,
1907                       InvalidateCB->FileID.Unique,
1908                       InvalidateCB->FileType,
1909                       InvalidateCB->WholeVolume,
1910                       InvalidateCB->Reason);
1911
1912         //
1913         // Need to locate the Fcb for the directory to purge
1914         //
1915
1916         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1917                       AFS_TRACE_LEVEL_VERBOSE,
1918                       "AFSInvalidateCache Acquiring RDR VolumeTreeLock lock %08lX SHARED %08lX\n",
1919                       &pDevExt->Specific.RDR.VolumeTreeLock,
1920                       PsGetCurrentThread());
1921
1922         //
1923         // Starve any exclusive waiters on this paticular call
1924         //
1925
1926         AFSAcquireSharedStarveExclusive( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
1927
1928         //
1929         // Locate the volume node
1930         //
1931
1932         ullIndex = AFSCreateHighIndex( &InvalidateCB->FileID);
1933
1934         ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
1935                                        ullIndex,
1936                                        (AFSBTreeEntry **)&pVolumeCB);
1937
1938         if( pVolumeCB != NULL)
1939         {
1940
1941             lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
1942
1943             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
1944                           AFS_TRACE_LEVEL_VERBOSE,
1945                           "AFSInvalidateCache Increment count on volume %08lX Cnt %d\n",
1946                           pVolumeCB,
1947                           lCount);
1948         }
1949
1950         AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
1951
1952         if( !NT_SUCCESS( ntStatus) ||
1953             pVolumeCB == NULL)
1954         {
1955
1956             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1957                           AFS_TRACE_LEVEL_WARNING,
1958                           "AFSInvalidateCache Invalidation FAILURE Unable to locate volume node FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1959                           InvalidateCB->FileID.Cell,
1960                           InvalidateCB->FileID.Volume,
1961                           InvalidateCB->FileID.Vnode,
1962                           InvalidateCB->FileID.Unique,
1963                           ntStatus);
1964
1965             try_return( ntStatus = STATUS_SUCCESS);
1966         }
1967
1968         //
1969         // If this is a whole volume invalidation then go do it now
1970         //
1971
1972         if( InvalidateCB->WholeVolume)
1973         {
1974
1975             ntStatus = AFSInvalidateVolume( pVolumeCB,
1976                                             InvalidateCB->Reason);
1977
1978             lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1979
1980             try_return( ntStatus);
1981         }
1982
1983         AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
1984                           TRUE);
1985
1986         if ( AFSIsVolumeFID( &InvalidateCB->FileID))
1987         {
1988
1989             pObjectInfo = &pVolumeCB->ObjectInformation;
1990         }
1991         else
1992         {
1993
1994             lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1995
1996             AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
1997                           AFS_TRACE_LEVEL_VERBOSE,
1998                           "AFSInvalidateCache Decrement count on volume %08lX Cnt %d\n",
1999                           pVolumeCB,
2000                           pVolumeCB->VolumeReferenceCount);
2001
2002             ullIndex = AFSCreateLowIndex( &InvalidateCB->FileID);
2003
2004             ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
2005                                            ullIndex,
2006                                            (AFSBTreeEntry **)&pObjectInfo);
2007         }
2008
2009         if( pObjectInfo != NULL)
2010         {
2011
2012             //
2013             // Reference the node so it won't be torn down
2014             //
2015
2016             lCount = InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
2017
2018             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2019                           AFS_TRACE_LEVEL_VERBOSE,
2020                           "AFSInvalidateCache Increment count on object %08lX Cnt %d\n",
2021                           pObjectInfo,
2022                           lCount);
2023         }
2024
2025         AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
2026
2027         if( !NT_SUCCESS( ntStatus) ||
2028             pObjectInfo == NULL)
2029         {
2030
2031             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2032                           AFS_TRACE_LEVEL_VERBOSE,
2033                           "AFSInvalidateCache Invalidation FAILURE Unable to locate object FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2034                           InvalidateCB->FileID.Cell,
2035                           InvalidateCB->FileID.Volume,
2036                           InvalidateCB->FileID.Vnode,
2037                           InvalidateCB->FileID.Unique,
2038                           ntStatus);
2039
2040             try_return( ntStatus = STATUS_SUCCESS);
2041         }
2042
2043         AFSInvalidateObject( &pObjectInfo,
2044                              InvalidateCB->Reason);
2045
2046 try_exit:
2047
2048         if( pObjectInfo != NULL)
2049         {
2050
2051             lCount = InterlockedDecrement( &pObjectInfo->ObjectReferenceCount);
2052
2053             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2054                           AFS_TRACE_LEVEL_VERBOSE,
2055                           "AFSInvalidateCache Decrement count on object %08lX Cnt %d\n",
2056                           pObjectInfo,
2057                           lCount);
2058         }
2059     }
2060
2061     return ntStatus;
2062 }
2063
2064 BOOLEAN
2065 AFSIsChildOfParent( IN AFSFcb *Dcb,
2066                     IN AFSFcb *Fcb)
2067 {
2068
2069     BOOLEAN bIsChild = FALSE;
2070     AFSFcb *pCurrentFcb = Fcb;
2071
2072     while( pCurrentFcb != NULL)
2073     {
2074
2075         if( pCurrentFcb->ObjectInformation->ParentObjectInformation == Dcb->ObjectInformation)
2076         {
2077
2078             bIsChild = TRUE;
2079
2080             break;
2081         }
2082
2083         pCurrentFcb = pCurrentFcb->ObjectInformation->ParentObjectInformation->Fcb;
2084     }
2085
2086     return bIsChild;
2087 }
2088
2089 inline
2090 ULONGLONG
2091 AFSCreateHighIndex( IN AFSFileID *FileID)
2092 {
2093
2094     ULONGLONG ullIndex = 0;
2095
2096     ullIndex = (((ULONGLONG)FileID->Cell << 32) | FileID->Volume);
2097
2098     return ullIndex;
2099 }
2100
2101 inline
2102 ULONGLONG
2103 AFSCreateLowIndex( IN AFSFileID *FileID)
2104 {
2105
2106     ULONGLONG ullIndex = 0;
2107
2108     ullIndex = (((ULONGLONG)FileID->Vnode << 32) | FileID->Unique);
2109
2110     return ullIndex;
2111 }
2112
2113 BOOLEAN
2114 AFSCheckAccess( IN ACCESS_MASK DesiredAccess,
2115                 IN ACCESS_MASK GrantedAccess,
2116                 IN BOOLEAN DirectoryEntry)
2117 {
2118
2119     BOOLEAN bAccessGranted = TRUE;
2120
2121     //
2122     // Check if we are asking for read/write and granted only read only
2123     // NOTE: There will be more checks here
2124     //
2125
2126     if( !AFSCheckForReadOnlyAccess( DesiredAccess,
2127                                     DirectoryEntry) &&
2128         AFSCheckForReadOnlyAccess( GrantedAccess,
2129                                    DirectoryEntry))
2130     {
2131
2132         bAccessGranted = FALSE;
2133     }
2134
2135     return bAccessGranted;
2136 }
2137
2138 NTSTATUS
2139 AFSGetDriverStatus( IN AFSDriverStatusRespCB *DriverStatus)
2140 {
2141
2142     NTSTATUS         ntStatus = STATUS_SUCCESS;
2143     AFSDeviceExt    *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
2144
2145     //
2146     // Start with read
2147     //
2148
2149     DriverStatus->Status = AFS_DRIVER_STATUS_READY;
2150
2151     if( AFSGlobalRoot == NULL)
2152     {
2153
2154         //
2155         // We are not ready
2156         //
2157
2158         DriverStatus->Status = AFS_DRIVER_STATUS_NOT_READY;
2159     }
2160
2161     if( pControlDevExt->Specific.Control.CommServiceCB.IrpPoolControlFlag != POOL_ACTIVE)
2162     {
2163
2164         //
2165         // No service yet
2166         //
2167
2168         DriverStatus->Status = AFS_DRIVER_STATUS_NO_SERVICE;
2169     }
2170
2171     return ntStatus;
2172 }
2173
2174 NTSTATUS
2175 AFSSubstituteSysName( IN UNICODE_STRING *ComponentName,
2176                       IN UNICODE_STRING *SubstituteName,
2177                       IN ULONG StringIndex)
2178 {
2179
2180     NTSTATUS ntStatus = STATUS_SUCCESS;
2181     AFSDeviceExt    *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
2182     AFSSysNameCB    *pSysName = NULL;
2183     ERESOURCE       *pSysNameLock = NULL;
2184     ULONG            ulIndex = 1;
2185     USHORT           usIndex = 0;
2186     UNICODE_STRING   uniSysName;
2187
2188     __Enter
2189     {
2190
2191 #if defined(_WIN64)
2192
2193         if( IoIs32bitProcess( NULL))
2194         {
2195
2196             pSysNameLock = &pControlDevExt->Specific.Control.SysName32ListLock;
2197
2198             pSysName = pControlDevExt->Specific.Control.SysName32ListHead;
2199         }
2200         else
2201         {
2202
2203             pSysNameLock = &pControlDevExt->Specific.Control.SysName64ListLock;
2204
2205             pSysName = pControlDevExt->Specific.Control.SysName64ListHead;
2206         }
2207 #else
2208
2209         pSysNameLock = &pControlDevExt->Specific.Control.SysName32ListLock;
2210
2211         pSysName = pControlDevExt->Specific.Control.SysName32ListHead;
2212
2213 #endif
2214
2215         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2216                       AFS_TRACE_LEVEL_VERBOSE,
2217                       "AFSSubstituteSysName Acquiring SysName lock %08lX SHARED %08lX\n",
2218                       pSysNameLock,
2219                       PsGetCurrentThread());
2220
2221         AFSAcquireShared( pSysNameLock,
2222                           TRUE);
2223
2224         //
2225         // Find where we are in the list
2226         //
2227
2228         while( pSysName != NULL &&
2229             ulIndex < StringIndex)
2230         {
2231
2232             pSysName = pSysName->fLink;
2233
2234             ulIndex++;
2235         }
2236
2237         if( pSysName == NULL)
2238         {
2239
2240             try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
2241         }
2242
2243         RtlInitUnicodeString( &uniSysName,
2244                               L"@SYS");
2245         //
2246         // If it is a full component of @SYS then just substitue the
2247         // name in
2248         //
2249
2250         if( RtlCompareUnicodeString( &uniSysName,
2251                                      ComponentName,
2252                                      TRUE) == 0)
2253         {
2254
2255             SubstituteName->Length = pSysName->SysName.Length;
2256             SubstituteName->MaximumLength = SubstituteName->Length;
2257
2258             SubstituteName->Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
2259                                                                         SubstituteName->Length,
2260                                                                         AFS_SUBST_BUFFER_TAG);
2261
2262             if( SubstituteName->Buffer == NULL)
2263             {
2264
2265                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2266             }
2267
2268             RtlCopyMemory( SubstituteName->Buffer,
2269                            pSysName->SysName.Buffer,
2270                            pSysName->SysName.Length);
2271         }
2272         else
2273         {
2274
2275             usIndex = 0;
2276
2277             while( ComponentName->Buffer[ usIndex] != L'@')
2278             {
2279
2280                 usIndex++;
2281             }
2282
2283             SubstituteName->Length = (usIndex * sizeof( WCHAR)) + pSysName->SysName.Length;
2284             SubstituteName->MaximumLength = SubstituteName->Length;
2285
2286             SubstituteName->Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
2287                                                                         SubstituteName->Length,
2288                                                                         AFS_SUBST_BUFFER_TAG);
2289
2290             if( SubstituteName->Buffer == NULL)
2291             {
2292
2293                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2294             }
2295
2296             RtlCopyMemory( SubstituteName->Buffer,
2297                            ComponentName->Buffer,
2298                            usIndex * sizeof( WCHAR));
2299
2300             RtlCopyMemory( &SubstituteName->Buffer[ usIndex],
2301                            pSysName->SysName.Buffer,
2302                            pSysName->SysName.Length);
2303         }
2304
2305 try_exit:
2306
2307         AFSReleaseResource( pSysNameLock);
2308     }
2309
2310     return ntStatus;
2311 }
2312
2313 NTSTATUS
2314 AFSSubstituteNameInPath( IN OUT UNICODE_STRING *FullPathName,
2315                          IN OUT UNICODE_STRING *ComponentName,
2316                          IN UNICODE_STRING *SubstituteName,
2317                          IN OUT UNICODE_STRING *RemainingPath,
2318                          IN BOOLEAN FreePathName)
2319 {
2320
2321     NTSTATUS ntStatus = STATUS_SUCCESS;
2322     UNICODE_STRING uniPathName;
2323     USHORT usPrefixNameLen = 0;
2324     SHORT  sNameLenDelta = 0;
2325
2326     __Enter
2327     {
2328
2329         //
2330         // If the passed in name can handle the additional length
2331         // then just moves things around
2332         //
2333
2334         sNameLenDelta = SubstituteName->Length - ComponentName->Length;
2335
2336         usPrefixNameLen = (USHORT)(ComponentName->Buffer - FullPathName->Buffer);
2337
2338         if( FullPathName->MaximumLength > FullPathName->Length + sNameLenDelta)
2339         {
2340
2341             if( FullPathName->Length > usPrefixNameLen + ComponentName->Length)
2342             {
2343
2344                 RtlMoveMemory( &FullPathName->Buffer[ ((usPrefixNameLen*sizeof( WCHAR) + SubstituteName->Length)/sizeof( WCHAR))],
2345                                &FullPathName->Buffer[ ((usPrefixNameLen*sizeof( WCHAR) + ComponentName->Length)/sizeof( WCHAR))],
2346                                FullPathName->Length - usPrefixNameLen*sizeof( WCHAR) - ComponentName->Length);
2347             }
2348
2349             RtlCopyMemory( &FullPathName->Buffer[ usPrefixNameLen],
2350                            SubstituteName->Buffer,
2351                            SubstituteName->Length);
2352
2353             FullPathName->Length += sNameLenDelta;
2354
2355             ComponentName->Length += sNameLenDelta;
2356
2357             ComponentName->MaximumLength = ComponentName->Length;
2358
2359             if ( RemainingPath->Buffer)
2360             {
2361
2362                 RemainingPath->Buffer += sNameLenDelta/sizeof( WCHAR);
2363             }
2364
2365             try_return( ntStatus);
2366         }
2367
2368         //
2369         // Need to re-allocate the buffer
2370         //
2371
2372         uniPathName.Length = FullPathName->Length -
2373                                          ComponentName->Length +
2374                                          SubstituteName->Length;
2375
2376         uniPathName.MaximumLength = FullPathName->MaximumLength + PAGE_SIZE;
2377
2378         uniPathName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
2379                                                                 uniPathName.MaximumLength,
2380                                                                 AFS_NAME_BUFFER_FOUR_TAG);
2381
2382         if( uniPathName.Buffer == NULL)
2383         {
2384
2385             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
2386         }
2387
2388         usPrefixNameLen = (USHORT)(ComponentName->Buffer - FullPathName->Buffer);
2389
2390         usPrefixNameLen *= sizeof( WCHAR);
2391
2392         RtlZeroMemory( uniPathName.Buffer,
2393                        uniPathName.MaximumLength);
2394
2395         RtlCopyMemory( uniPathName.Buffer,
2396                        FullPathName->Buffer,
2397                        usPrefixNameLen);
2398
2399         RtlCopyMemory( &uniPathName.Buffer[ (usPrefixNameLen/sizeof( WCHAR))],
2400                        SubstituteName->Buffer,
2401                        SubstituteName->Length);
2402
2403         if( FullPathName->Length > usPrefixNameLen + ComponentName->Length)
2404         {
2405
2406             RtlCopyMemory( &uniPathName.Buffer[ (usPrefixNameLen + SubstituteName->Length)/sizeof( WCHAR)],
2407                            &FullPathName->Buffer[ (usPrefixNameLen + ComponentName->Length)/sizeof( WCHAR)],
2408                            FullPathName->Length - usPrefixNameLen - ComponentName->Length);
2409         }
2410
2411         ComponentName->Buffer = uniPathName.Buffer + (ComponentName->Buffer - FullPathName->Buffer);
2412
2413         ComponentName->Length += sNameLenDelta;
2414
2415         ComponentName->MaximumLength = ComponentName->Length;
2416
2417         if ( RemainingPath->Buffer)
2418         {
2419
2420             RemainingPath->Buffer = uniPathName.Buffer
2421                 + (RemainingPath->Buffer - FullPathName->Buffer)
2422                 + sNameLenDelta/sizeof( WCHAR);
2423         }
2424
2425         if( FreePathName)
2426         {
2427             AFSExFreePool( FullPathName->Buffer);
2428         }
2429
2430         *FullPathName = uniPathName;
2431
2432 try_exit:
2433
2434         NOTHING;
2435     }
2436
2437     return ntStatus;
2438 }
2439
2440 NTSTATUS
2441 AFSInvalidateVolume( IN AFSVolumeCB *VolumeCB,
2442                      IN ULONG Reason)
2443 {
2444
2445     NTSTATUS ntStatus = STATUS_SUCCESS;
2446     AFSObjectInfoCB *pCurrentObject = NULL;
2447     AFSObjectInfoCB *pNextObject = NULL;
2448     LONG lCount;
2449     AFSFcb *pFcb = NULL;
2450     ULONG ulFilter = 0;
2451
2452     __Enter
2453     {
2454
2455         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2456                       AFS_TRACE_LEVEL_VERBOSE,
2457                       "AFSInvalidateVolume Invalidate volume fid %08lX-%08lX-%08lX-%08lX Reason %08lX\n",
2458                       VolumeCB->ObjectInformation.FileId.Cell,
2459                       VolumeCB->ObjectInformation.FileId.Volume,
2460                       VolumeCB->ObjectInformation.FileId.Vnode,
2461                       VolumeCB->ObjectInformation.FileId.Unique,
2462                       Reason);
2463
2464         //
2465         // Depending on the reason for invalidation then perform work on the node
2466         //
2467
2468         switch( Reason)
2469         {
2470
2471             case AFS_INVALIDATE_DELETED:
2472             {
2473
2474                 //
2475                 // Mark this volume as invalid
2476                 //
2477
2478                 SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
2479
2480                 SetFlag( VolumeCB->Flags, AFS_VOLUME_FLAGS_OFFLINE);
2481
2482                 break;
2483             }
2484         }
2485
2486         //
2487         // Invalidate the volume root directory
2488         //
2489
2490         pCurrentObject = &VolumeCB->ObjectInformation;
2491
2492         if ( pCurrentObject )
2493         {
2494
2495             lCount = InterlockedIncrement( &pCurrentObject->ObjectReferenceCount);
2496
2497             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2498                           AFS_TRACE_LEVEL_VERBOSE,
2499                           "AFSInvalidateVolumeObjects Increment count on object %08lX Cnt %d\n",
2500                           pCurrentObject,
2501                           lCount);
2502
2503             AFSInvalidateObject( &pCurrentObject,
2504                                  Reason);
2505
2506             if ( pCurrentObject)
2507             {
2508
2509                 lCount = InterlockedDecrement( &pCurrentObject->ObjectReferenceCount);
2510
2511                 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2512                               AFS_TRACE_LEVEL_VERBOSE,
2513                               "AFSInvalidateVolumeObjects Decrement count on object %08lX Cnt %d\n",
2514                               pCurrentObject,
2515                               lCount);
2516             }
2517         }
2518
2519         //
2520         // Apply invalidation to all other volume objects
2521         //
2522
2523         AFSAcquireShared( VolumeCB->ObjectInfoTree.TreeLock,
2524                           TRUE);
2525
2526         pCurrentObject = VolumeCB->ObjectInfoListHead;
2527
2528         if ( pCurrentObject)
2529         {
2530
2531             //
2532             // Reference the node so it won't be torn down
2533             //
2534
2535             lCount = InterlockedIncrement( &pCurrentObject->ObjectReferenceCount);
2536
2537             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2538                           AFS_TRACE_LEVEL_VERBOSE,
2539                           "AFSInvalidateVolumeObjects Increment count on object %08lX Cnt %d\n",
2540                           pCurrentObject,
2541                           lCount);
2542         }
2543
2544         while( pCurrentObject != NULL)
2545         {
2546
2547             pNextObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
2548
2549             if ( pNextObject)
2550             {
2551
2552                 //
2553                 // Reference the node so it won't be torn down
2554                 //
2555
2556                 lCount = InterlockedIncrement( &pNextObject->ObjectReferenceCount);
2557
2558                 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2559                               AFS_TRACE_LEVEL_VERBOSE,
2560                               "AFSInvalidateVolumeObjects Increment count on object %08lX Cnt %d\n",
2561                               pNextObject,
2562                               lCount);
2563             }
2564
2565             AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
2566
2567             AFSInvalidateObject( &pCurrentObject,
2568                                  Reason);
2569
2570             if ( pCurrentObject )
2571             {
2572
2573                 lCount = InterlockedDecrement( &pCurrentObject->ObjectReferenceCount);
2574
2575                 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2576                               AFS_TRACE_LEVEL_VERBOSE,
2577                               "AFSInvalidateVolumeObjects Decrement count on object %08lX Cnt %d\n",
2578                               pCurrentObject,
2579                               lCount);
2580             }
2581
2582             AFSAcquireShared( VolumeCB->ObjectInfoTree.TreeLock,
2583                               TRUE);
2584
2585             pCurrentObject = pNextObject;
2586         }
2587
2588         AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
2589     }
2590
2591     return ntStatus;
2592 }
2593
2594 VOID
2595 AFSInvalidateAllVolumes( VOID)
2596 {
2597     AFSVolumeCB *pVolumeCB = NULL;
2598     AFSVolumeCB *pNextVolumeCB = NULL;
2599     AFSDeviceExt *pRDRDeviceExt = NULL;
2600     LONG lCount;
2601
2602     pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
2603
2604     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2605                   AFS_TRACE_LEVEL_VERBOSE,
2606                   "AFSInvalidateAllVolumes Acquiring RDR VolumeListLock lock %08lX SHARED %08lX\n",
2607                   &pRDRDeviceExt->Specific.RDR.VolumeListLock,
2608                   PsGetCurrentThread());
2609
2610     AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
2611                       TRUE);
2612
2613     pVolumeCB = pRDRDeviceExt->Specific.RDR.VolumeListHead;
2614
2615     if ( pVolumeCB)
2616     {
2617
2618         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2619                       AFS_TRACE_LEVEL_VERBOSE,
2620                       "AFSInvalidateAllVolumes Acquiring VolumeRoot ObjectInfoTree lock %08lX SHARED %08lX\n",
2621                       pVolumeCB->ObjectInfoTree.TreeLock,
2622                       PsGetCurrentThread());
2623
2624         lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
2625     }
2626
2627     while( pVolumeCB != NULL)
2628     {
2629
2630         pNextVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
2631
2632         if ( pNextVolumeCB)
2633         {
2634
2635             lCount = InterlockedIncrement( &pNextVolumeCB->VolumeReferenceCount);
2636         }
2637
2638         AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
2639
2640         // do I need to hold the volume lock here?
2641
2642         AFSInvalidateVolume( pVolumeCB, AFS_INVALIDATE_EXPIRED);
2643
2644         AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
2645                           TRUE);
2646
2647         lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
2648
2649         pVolumeCB = pNextVolumeCB;
2650     }
2651
2652     AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
2653 }
2654
2655 NTSTATUS
2656 AFSVerifyEntry( IN GUID *AuthGroup,
2657                 IN AFSDirectoryCB *DirEntry)
2658 {
2659
2660     NTSTATUS ntStatus = STATUS_SUCCESS;
2661     AFSDirEnumEntry *pDirEnumEntry = NULL;
2662     AFSObjectInfoCB *pObjectInfo = DirEntry->ObjectInformation;
2663     IO_STATUS_BLOCK stIoStatus;
2664
2665     __Enter
2666     {
2667
2668         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2669                       AFS_TRACE_LEVEL_VERBOSE_2,
2670                       "AFSVerifyEntry Verifying entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2671                       &DirEntry->NameInformation.FileName,
2672                       pObjectInfo->FileId.Cell,
2673                       pObjectInfo->FileId.Volume,
2674                       pObjectInfo->FileId.Vnode,
2675                       pObjectInfo->FileId.Unique);
2676
2677         ntStatus = AFSEvaluateTargetByID( pObjectInfo,
2678                                           AuthGroup,
2679                                           FALSE,
2680                                           &pDirEnumEntry);
2681
2682         if( !NT_SUCCESS( ntStatus))
2683         {
2684
2685             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2686                           AFS_TRACE_LEVEL_ERROR,
2687                           "AFSVerifyEntry Evaluate Target failed %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
2688                           &DirEntry->NameInformation.FileName,
2689                           pObjectInfo->FileId.Cell,
2690                           pObjectInfo->FileId.Volume,
2691                           pObjectInfo->FileId.Vnode,
2692                           pObjectInfo->FileId.Unique,
2693                           ntStatus);
2694
2695             try_return( ntStatus);
2696         }
2697
2698         //
2699         // Check the data version of the file
2700         //
2701
2702         if( pObjectInfo->DataVersion.QuadPart == pDirEnumEntry->DataVersion.QuadPart)
2703         {
2704             if ( !BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
2705             {
2706
2707                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2708                               AFS_TRACE_LEVEL_VERBOSE,
2709                               "AFSVerifyEntry No DV change %I64X for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2710                               pObjectInfo->DataVersion.QuadPart,
2711                               &DirEntry->NameInformation.FileName,
2712                               pObjectInfo->FileId.Cell,
2713                               pObjectInfo->FileId.Volume,
2714                               pObjectInfo->FileId.Vnode,
2715                               pObjectInfo->FileId.Unique);
2716
2717                 //
2718                 // We are ok, just get out
2719                 //
2720
2721                 ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2722
2723                 try_return( ntStatus = STATUS_SUCCESS);
2724             }
2725         }
2726
2727         //
2728         // New data version so we will need to process the node based on the type
2729         //
2730
2731         switch( pDirEnumEntry->FileType)
2732         {
2733
2734             case AFS_FILE_TYPE_MOUNTPOINT:
2735             {
2736
2737                 //
2738                 // For a mount point we need to ensure the target is the same
2739                 //
2740
2741                 if( !AFSIsEqualFID( &pObjectInfo->TargetFileId,
2742                                     &pDirEnumEntry->TargetFileId))
2743                 {
2744
2745                 }
2746
2747                 //
2748                 // Update the metadata for the entry
2749                 //
2750
2751                 ntStatus = AFSUpdateMetaData( DirEntry,
2752                                               pDirEnumEntry);
2753
2754                 if( NT_SUCCESS( ntStatus))
2755                 {
2756
2757                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2758                 }
2759
2760                 break;
2761             }
2762
2763             case AFS_FILE_TYPE_SYMLINK:
2764             {
2765
2766                 ASSERT( pDirEnumEntry->TargetNameLength > 0);
2767
2768                 //
2769                 // Update the metadata for the entry
2770                 //
2771
2772                 ntStatus = AFSUpdateMetaData( DirEntry,
2773                                               pDirEnumEntry);
2774
2775                 if( NT_SUCCESS( ntStatus))
2776                 {
2777
2778                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
2779                 }
2780
2781                 break;
2782             }
2783
2784             case AFS_FILE_TYPE_FILE:
2785             {
2786                 FILE_OBJECT * pCCFileObject = NULL;
2787                 BOOLEAN bPurgeExtents = FALSE;
2788
2789                 if ( pObjectInfo->DataVersion.QuadPart != pDirEnumEntry->DataVersion.QuadPart)
2790                 {
2791
2792                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2793                                   AFS_TRACE_LEVEL_VERBOSE,
2794                                   "AFSVerifyEntry DV Change %wZ FID %08lX-%08lX-%08lX-%08lX (%08lX != %08lX)\n",
2795                                   &DirEntry->NameInformation.FileName,
2796                                   pObjectInfo->FileId.Cell,
2797                                   pObjectInfo->FileId.Volume,
2798                                   pObjectInfo->FileId.Vnode,
2799                                   pObjectInfo->FileId.Unique,
2800                                   pObjectInfo->DataVersion.LowPart,
2801                                   pDirEnumEntry->DataVersion.LowPart
2802                                   );
2803
2804                     bPurgeExtents = TRUE;
2805                 }
2806
2807                 if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
2808                 {
2809
2810                     bPurgeExtents = TRUE;
2811
2812                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2813                                   AFS_TRACE_LEVEL_VERBOSE,
2814                                   "AFSVerifyEntry Clearing VERIFY_DATA flag %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2815                                   &DirEntry->NameInformation.FileName,
2816                                   pObjectInfo->FileId.Cell,
2817                                   pObjectInfo->FileId.Volume,
2818                                   pObjectInfo->FileId.Vnode,
2819                                   pObjectInfo->FileId.Unique);
2820
2821                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
2822                 }
2823
2824                 if( pObjectInfo->Fcb != NULL)
2825                 {
2826
2827                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2828                                   AFS_TRACE_LEVEL_VERBOSE,
2829                                   "AFSVerifyEntry Flush/purge entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2830                                   &DirEntry->NameInformation.FileName,
2831                                   pObjectInfo->FileId.Cell,
2832                                   pObjectInfo->FileId.Volume,
2833                                   pObjectInfo->FileId.Vnode,
2834                                   pObjectInfo->FileId.Unique);
2835
2836                     AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
2837                                     TRUE);
2838
2839                     __try
2840                     {
2841
2842                         CcFlushCache( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
2843                                       NULL,
2844                                       0,
2845                                       &stIoStatus);
2846
2847                         if( !NT_SUCCESS( stIoStatus.Status))
2848                         {
2849
2850                             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2851                                           AFS_TRACE_LEVEL_ERROR,
2852                                           "AFSVerifyEntry CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
2853                                           &DirEntry->NameInformation.FileName,
2854                                           pObjectInfo->FileId.Cell,
2855                                           pObjectInfo->FileId.Volume,
2856                                           pObjectInfo->FileId.Vnode,
2857                                           pObjectInfo->FileId.Unique,
2858                                           stIoStatus.Status,
2859                                           stIoStatus.Information);
2860
2861                             ntStatus = stIoStatus.Status;
2862                         }
2863
2864                         if ( bPurgeExtents)
2865                         {
2866
2867                             if ( !CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
2868                                                        NULL,
2869                                                        0,
2870                                                        FALSE))
2871                             {
2872
2873                                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2874                                               AFS_TRACE_LEVEL_WARNING,
2875                                               "AFSVerifyEntry CcPurgeCacheSection failure %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2876                                               &DirEntry->NameInformation.FileName,
2877                                               pObjectInfo->FileId.Cell,
2878                                               pObjectInfo->FileId.Volume,
2879                                               pObjectInfo->FileId.Vnode,
2880                                               pObjectInfo->FileId.Unique);
2881
2882                                 SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
2883                             }
2884                         }
2885                     }
2886                     __except( EXCEPTION_EXECUTE_HANDLER)
2887                     {
2888                         ntStatus = GetExceptionCode();
2889
2890                         AFSDbgLogMsg( 0,
2891                                       0,
2892                                       "EXCEPTION - AFSVerifyEntry CcFlushCache or CcPurgeCacheSection %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
2893                                       &DirEntry->NameInformation.FileName,
2894                                       pObjectInfo->FileId.Cell,
2895                                       pObjectInfo->FileId.Volume,
2896                                       pObjectInfo->FileId.Vnode,
2897                                       pObjectInfo->FileId.Unique,
2898                                       ntStatus);
2899
2900                         SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
2901                     }
2902
2903                     AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
2904
2905                     if ( bPurgeExtents)
2906                     {
2907                         AFSFlushExtents( pObjectInfo->Fcb,
2908                                          AuthGroup);
2909                     }
2910
2911                     //
2912                     // Reacquire the Fcb to purge the cache
2913                     //
2914
2915                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2916                                   AFS_TRACE_LEVEL_VERBOSE,
2917                                   "AFSVerifyEntry Acquiring Fcb lock %08lX EXCL %08lX\n",
2918                                   &pObjectInfo->Fcb->NPFcb->Resource,
2919                                   PsGetCurrentThread());
2920
2921                     AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
2922                                     TRUE);
2923
2924                     //
2925                     // Update the metadata for the entry
2926                     //
2927
2928                     ntStatus = AFSUpdateMetaData( DirEntry,
2929                                                   pDirEnumEntry);
2930
2931                     if( !NT_SUCCESS( ntStatus))
2932                     {
2933
2934                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2935                                       AFS_TRACE_LEVEL_ERROR,
2936                                       "AFSVerifyEntry Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX ntStatus %08lX\n",
2937                                       &DirEntry->NameInformation.FileName,
2938                                       pObjectInfo->FileId.Cell,
2939                                       pObjectInfo->FileId.Volume,
2940                                       pObjectInfo->FileId.Vnode,
2941                                       pObjectInfo->FileId.Unique,
2942                                       ntStatus);
2943
2944                         break;
2945                     }
2946
2947                     //
2948                     // Update file sizes
2949                     //
2950
2951                     pObjectInfo->Fcb->Header.AllocationSize.QuadPart  = pObjectInfo->AllocationSize.QuadPart;
2952                     pObjectInfo->Fcb->Header.FileSize.QuadPart        = pObjectInfo->EndOfFile.QuadPart;
2953                     pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
2954
2955                     pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
2956
2957                     if ( pCCFileObject != NULL)
2958                     {
2959                         CcSetFileSizes( pCCFileObject,
2960                                         (PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
2961                     }
2962
2963                     AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
2964                 }
2965                 else
2966                 {
2967
2968                     //
2969                     // Update the metadata for the entry
2970                     //
2971
2972                     ntStatus = AFSUpdateMetaData( DirEntry,
2973                                                   pDirEnumEntry);
2974
2975                     if( !NT_SUCCESS( ntStatus))
2976                     {
2977
2978                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2979                                       AFS_TRACE_LEVEL_ERROR,
2980                                       "AFSVerifyEntry Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX ntStatus %08lX\n",
2981                                       &DirEntry->NameInformation.FileName,
2982                                       pObjectInfo->FileId.Cell,
2983                                       pObjectInfo->FileId.Volume,
2984                                       pObjectInfo->FileId.Vnode,
2985                                       pObjectInfo->FileId.Unique,
2986                                       ntStatus);
2987
2988                         break;
2989                     }
2990
2991                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
2992                                   AFS_TRACE_LEVEL_WARNING,
2993                                   "AFSVerifyEntry Fcb NULL %wZ FID %08lX-%08lX-%08lX-%08lX\n",
2994                                   &DirEntry->NameInformation.FileName,
2995                                   pObjectInfo->FileId.Cell,
2996                                   pObjectInfo->FileId.Volume,
2997                                   pObjectInfo->FileId.Vnode,
2998                                   pObjectInfo->FileId.Unique);
2999                 }
3000
3001                 ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
3002
3003                 break;
3004             }
3005
3006             case AFS_FILE_TYPE_DIRECTORY:
3007             {
3008
3009                 AFSFcb *pCurrentFcb = NULL;
3010                 AFSDirectoryCB *pCurrentDirEntry = NULL;
3011
3012                 //
3013                 // For a directory or root entry flush the content of
3014                 // the directory enumeration.
3015                 //
3016
3017                 if( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
3018                 {
3019
3020                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3021                                   AFS_TRACE_LEVEL_VERBOSE_2,
3022                                   "AFSVerifyEntry Validating directory content for entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
3023                                   &DirEntry->NameInformation.FileName,
3024                                   pObjectInfo->FileId.Cell,
3025                                   pObjectInfo->FileId.Volume,
3026                                   pObjectInfo->FileId.Vnode,
3027                                   pObjectInfo->FileId.Unique);
3028
3029                     AFSAcquireExcl( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
3030                                     TRUE);
3031
3032                     ntStatus = AFSValidateDirectoryCache( pObjectInfo,
3033                                                           AuthGroup);
3034
3035                     AFSReleaseResource( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
3036
3037                     if ( !NT_SUCCESS( ntStatus))
3038                     {
3039
3040                         try_return( ntStatus);
3041                     }
3042                 }
3043
3044                 //
3045                 // Update the metadata for the entry
3046                 //
3047
3048                 ntStatus = AFSUpdateMetaData( DirEntry,
3049                                               pDirEnumEntry);
3050
3051                 if( NT_SUCCESS( ntStatus))
3052                 {
3053
3054                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
3055                 }
3056
3057                 break;
3058             }
3059
3060             case AFS_FILE_TYPE_DFSLINK:
3061             {
3062
3063                 UNICODE_STRING uniTargetName;
3064
3065                 //
3066                 // For a DFS link need to check the target name has not changed
3067                 //
3068
3069                 uniTargetName.Length = (USHORT)pDirEnumEntry->TargetNameLength;
3070
3071                 uniTargetName.MaximumLength = uniTargetName.Length;
3072
3073                 uniTargetName.Buffer = (WCHAR *)((char *)pDirEnumEntry + pDirEnumEntry->TargetNameOffset);
3074
3075                 AFSAcquireExcl( &DirEntry->NonPaged->Lock,
3076                                 TRUE);
3077
3078                 if( DirEntry->NameInformation.TargetName.Length == 0 ||
3079                     RtlCompareUnicodeString( &uniTargetName,
3080                                              &DirEntry->NameInformation.TargetName,
3081                                              TRUE) != 0)
3082                 {
3083
3084                     //
3085                     // Update the target name
3086                     //
3087
3088                     ntStatus = AFSUpdateTargetName( &DirEntry->NameInformation.TargetName,
3089                                                     &DirEntry->Flags,
3090                                                     uniTargetName.Buffer,
3091                                                     uniTargetName.Length);
3092
3093                     if( !NT_SUCCESS( ntStatus))
3094                     {
3095
3096                         AFSReleaseResource( &DirEntry->NonPaged->Lock);
3097
3098                         break;
3099                     }
3100                 }
3101
3102                 AFSReleaseResource( &DirEntry->NonPaged->Lock);
3103
3104                 //
3105                 // Update the metadata for the entry
3106                 //
3107
3108                 ntStatus = AFSUpdateMetaData( DirEntry,
3109                                               pDirEnumEntry);
3110
3111                 if( NT_SUCCESS( ntStatus))
3112                 {
3113
3114                     ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
3115                 }
3116
3117                 break;
3118             }
3119
3120             default:
3121
3122                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3123                               AFS_TRACE_LEVEL_WARNING,
3124                               "AFSVerifyEntry Attempt to verify node of type %d %wZ FID %08lX-%08lX-%08lX-%08lX\n",
3125                               pObjectInfo->FileType,
3126                               &DirEntry->NameInformation.FileName,
3127                               pObjectInfo->FileId.Cell,
3128                               pObjectInfo->FileId.Volume,
3129                               pObjectInfo->FileId.Vnode,
3130                               pObjectInfo->FileId.Unique);
3131
3132                 break;
3133         }
3134
3135  try_exit:
3136
3137         if( pDirEnumEntry != NULL)
3138         {
3139
3140             AFSExFreePool( pDirEnumEntry);
3141         }
3142     }
3143
3144     return ntStatus;
3145 }
3146
3147 NTSTATUS
3148 AFSSetVolumeState( IN AFSVolumeStatusCB *VolumeStatus)
3149 {
3150
3151     NTSTATUS ntStatus = STATUS_SUCCESS;
3152     AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
3153     ULONGLONG   ullIndex = 0;
3154     AFSVolumeCB *pVolumeCB = NULL;
3155     AFSFcb *pFcb = NULL;
3156     AFSObjectInfoCB *pCurrentObject = NULL;
3157     LONG lCount;
3158
3159     __Enter
3160     {
3161
3162         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
3163                       AFS_TRACE_LEVEL_VERBOSE,
3164                       "AFSSetVolumeState Marking volume state %d Volume Cell %08lX Volume %08lX\n",
3165                       VolumeStatus->Online,
3166                       VolumeStatus->FileID.Cell,
3167                       VolumeStatus->FileID.Volume);
3168
3169         //
3170         // Need to locate the Fcb for the directory to purge
3171         //
3172
3173         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3174                       AFS_TRACE_LEVEL_VERBOSE,
3175                       "AFSSetVolumeState Acquiring RDR VolumeTreeLock lock %08lX SHARED %08lX\n",
3176                       &pDevExt->Specific.RDR.VolumeTreeLock,
3177                       PsGetCurrentThread());
3178
3179         AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
3180
3181         //
3182         // Locate the volume node
3183         //
3184
3185         ullIndex = AFSCreateHighIndex( &VolumeStatus->FileID);
3186
3187         ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
3188                                        ullIndex,
3189                                        (AFSBTreeEntry **)&pVolumeCB);
3190
3191         if( pVolumeCB != NULL)
3192         {
3193
3194             lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
3195
3196             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
3197
3198             //
3199             // Set the volume state accordingly
3200             //
3201
3202             if( VolumeStatus->Online)
3203             {
3204
3205                 InterlockedAnd( (LONG *)&(pVolumeCB->Flags), ~AFS_VOLUME_FLAGS_OFFLINE);
3206             }
3207             else
3208             {
3209
3210                 InterlockedOr( (LONG *)&(pVolumeCB->Flags), AFS_VOLUME_FLAGS_OFFLINE);
3211             }
3212
3213             AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
3214                               TRUE);
3215
3216             pCurrentObject = pVolumeCB->ObjectInfoListHead;;
3217
3218             while( pCurrentObject != NULL)
3219             {
3220
3221                 if( VolumeStatus->Online)
3222                 {
3223
3224                     ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
3225
3226                     SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
3227
3228                     pCurrentObject->DataVersion.QuadPart = (ULONGLONG)-1;
3229                 }
3230                 else
3231                 {
3232
3233                     SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
3234                 }
3235
3236                 pFcb = pCurrentObject->Fcb;
3237
3238                 if( pFcb != NULL &&
3239                     !(VolumeStatus->Online) &&
3240                     pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
3241                 {
3242
3243                     AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
3244                                   AFS_TRACE_LEVEL_ERROR,
3245                                   "AFSSetVolumeState Marking volume offline and canceling extents Volume Cell %08lX Volume %08lX\n",
3246                                   VolumeStatus->FileID.Cell,
3247                                   VolumeStatus->FileID.Volume);
3248
3249                     //
3250                     // Clear out the extents
3251                     //
3252
3253                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3254                                   AFS_TRACE_LEVEL_VERBOSE,
3255                                   "AFSSetVolumeState Acquiring Fcb extents lock %08lX EXCL %08lX\n",
3256                                   &pFcb->NPFcb->Specific.File.ExtentsResource,
3257                                   PsGetCurrentThread());