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

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