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

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
   3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice,
  14  *   this list of conditions and the following disclaimer in the
  15  *   documentation
  16  *   and/or other materials provided with the distribution.
  17  * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
  18  *   nor the names of their contributors may be used to endorse or promote
  19  *   products derived from this software without specific prior written
  20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 //
  36 // File: AFSCleanup.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // Function: AFSCleanup
  43 //
  44 // Description:
  45 //
  46 //      This function is the IRP_MJ_CLEANUP dispatch handler
  47 //
  48 // Return:
  49 //
  50 //       A status is returned for the handling of this request
  51 //
  52
  53 NTSTATUS
  54 AFSCleanup( IN PDEVICE_OBJECT LibDeviceObject,
  55             IN PIRP Irp)
  56 {
  57
  58     NTSTATUS ntStatus = STATUS_SUCCESS;
  59     AFSDeviceExt *pDeviceExt = NULL;
  60     IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
  61     AFSFcb *pFcb = NULL;
  62     AFSCcb *pCcb = NULL;
  63     PFILE_OBJECT pFileObject = NULL;
  64     AFSFcb *pRootFcb = NULL;
  65     AFSDeviceExt *pControlDeviceExt = NULL;
  66     IO_STATUS_BLOCK stIoSB;
  67     AFSObjectInfoCB *pObjectInfo = NULL;
  68     AFSFileCleanupCB stFileCleanup;
  69     AFSFileCleanupResultCB *pResultCB = NULL;
  70     ULONG ulResultLen = 0;
  71     ULONG   ulNotificationFlags = 0;
  72     LONG    lCount;
  73
  74     __try
  75     {
  76
  77         if( AFSRDRDeviceObject == NULL)
  78         {
  79
  80             //
  81             // Let this through, it's a cleanup on the library control device
  82             //
  83
  84             try_return( ntStatus);
  85         }
  86
  87         pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
  88         pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
  89
  90         //
  91         // Set some initial variables to make processing easier
  92         //
  93
  94         pFileObject = pIrpSp->FileObject;
  95
  96         pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
  97
  98         pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
  99
 100         if( pFcb == NULL)
 101         {
 102             try_return( ntStatus);
 103         }
 104
 105         pObjectInfo = pFcb->ObjectInformation;
 106
 107         pRootFcb = pObjectInfo->VolumeCB->RootFcb;
 108
 109         RtlZeroMemory( &stFileCleanup,
 110                        sizeof( AFSFileCleanupCB));
 111
 112         stFileCleanup.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
 113
 114         stFileCleanup.Identifier = (ULONGLONG)pFileObject;
 115
 116         //
 117         // Allocate our return buffer
 118         //
 119
 120         pResultCB = (AFSFileCleanupResultCB *)AFSExAllocatePoolWithTag( PagedPool,
 121                                                                         PAGE_SIZE,
 122                                                                         AFS_GENERIC_MEMORY_32_TAG);
 123
 124         if( pResultCB == NULL)
 125         {
 126
 127             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
 128         }
 129
 130         RtlZeroMemory( pResultCB,
 131                        PAGE_SIZE);
 132
 133         ulResultLen = PAGE_SIZE;
 134
 135
 136         //
 137         // Perform the cleanup functionality depending on the type of node it is
 138         //
 139
 140         switch( pFcb->Header.NodeTypeCode)
 141         {
 142
 143             case AFS_ROOT_ALL:
 144             {
 145
 146                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 147                               AFS_TRACE_LEVEL_VERBOSE,
 148                               "AFSCleanup Acquiring GlobalRoot lock %08lX EXCL %08lX\n",
 149                               &pFcb->NPFcb->Resource,
 150                               PsGetCurrentThread());
 151
 152                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 153                                   TRUE);
 154
 155                 ASSERT( pFcb->OpenHandleCount != 0);
 156
 157                 AFSReleaseResource( &pFcb->NPFcb->Resource);
 158
 159                 lCount = InterlockedDecrement( &pFcb->OpenHandleCount);
 160
 161                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 162                               AFS_TRACE_LEVEL_VERBOSE,
 163                               "AFSCleanup (RootAll) Decrement handle count on Fcb %08lX Cnt %d\n",
 164                               pFcb,
 165                               lCount);
 166
 167                 FsRtlNotifyCleanup( pControlDeviceExt->Specific.Control.NotifySync,
 168                                     &pControlDeviceExt->Specific.Control.DirNotifyList,
 169                                     pCcb);
 170
 171                 break;
 172             }
 173
 174             case AFS_IOCTL_FCB:
 175             {
 176
 177                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 178                               AFS_TRACE_LEVEL_VERBOSE,
 179                               "AFSCleanup Acquiring PIOCtl lock %08lX EXCL %08lX\n",
 180                               &pFcb->NPFcb->Resource,
 181                               PsGetCurrentThread());
 182
 183                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 184                                   TRUE);
 185
 186                 ASSERT( pFcb->OpenHandleCount != 0);
 187
 188                 //
 189                 // Decrement the open child handle count
 190                 //
 191
 192                 if( pObjectInfo->ParentObjectInformation != NULL &&
 193                     pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
 194                 {
 195
 196                     lCount = InterlockedDecrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
 197
 198                     AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 199                                   AFS_TRACE_LEVEL_VERBOSE,
 200                                   "AFSCleanup (IOCtl) Decrement child open handle count on Parent object %08lX Cnt %d\n",
 201                                   pObjectInfo->ParentObjectInformation,
 202                                   lCount);
 203                 }
 204
 205                 AFSReleaseResource( &pFcb->NPFcb->Resource);
 206
 207                 lCount = InterlockedDecrement( &pFcb->OpenHandleCount);
 208
 209                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 210                               AFS_TRACE_LEVEL_VERBOSE,
 211                               "AFSCleanup (IOCtl) Decrement handle count on Fcb %08lX Cnt %d\n",
 212                               pFcb,
 213                               lCount);
 214
 215                 break;
 216             }
 217
 218             //
 219             // This Fcb represents a file
 220             //
 221
 222             case AFS_FILE_FCB:
 223             {
 224
 225                 //
 226                 // We may be performing some cleanup on the Fcb so grab it exclusive to ensure no collisions
 227                 //
 228
 229                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 230                               AFS_TRACE_LEVEL_VERBOSE,
 231                               "AFSCleanup Acquiring Fcb lock %08lX EXCL %08lX\n",
 232                               &pFcb->NPFcb->Resource,
 233                               PsGetCurrentThread());
 234
 235                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 236                                 TRUE);
 237
 238                 //
 239                 // If the handle has write permission ...
 240                 //
 241
 242                 if( (pCcb->GrantedAccess & FILE_WRITE_DATA) &&
 243                     CcIsFileCached( pIrpSp->FileObject))
 244                 {
 245
 246                     __try
 247                     {
 248
 249                         CcFlushCache( &pFcb->NPFcb->SectionObjectPointers,
 250                                       NULL,
 251                                       0,
 252                                       &stIoSB);
 253
 254                         if( !NT_SUCCESS( stIoSB.Status))
 255                         {
 256
 257                             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 258                                           AFS_TRACE_LEVEL_ERROR,
 259                                           "AFSCleanup CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
 260                                           &pCcb->FullFileName,
 261                                           pObjectInfo->FileId.Cell,
 262                                           pObjectInfo->FileId.Volume,
 263                                           pObjectInfo->FileId.Vnode,
 264                                           pObjectInfo->FileId.Unique,
 265                                           stIoSB.Status,
 266                                           stIoSB.Information);
 267
 268                             ntStatus = stIoSB.Status;
 269                         }
 270                     }
 271                     __except( EXCEPTION_EXECUTE_HANDLER)
 272                     {
 273
 274                         ntStatus = GetExceptionCode();
 275                     }
 276                 }
 277
 278                 //
 279                 // Uninitialize the cache map. This call is unconditional.
 280                 //
 281
 282                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 283                               AFS_TRACE_LEVEL_VERBOSE,
 284                               "AFSCleanup Tearing down cache map for Fcb %08lX FileObject %08lX\n",
 285                               pFcb,
 286                               pFileObject);
 287
 288                 CcUninitializeCacheMap( pFileObject,
 289                                         NULL,
 290                                         NULL);
 291
 292                 //
 293                 // Unlock all outstanding locks on the file, again, unconditionally
 294                 //
 295
 296                 (VOID) FsRtlFastUnlockAll( &pFcb->Specific.File.FileLock,
 297                                            pFileObject,
 298                                            IoGetRequestorProcess( Irp),
 299                                            NULL);
 300
 301                 //
 302                 // Tell the service to unlock all on the file
 303                 //
 304
 305                 ulNotificationFlags |= AFS_REQUEST_FLAG_BYTE_RANGE_UNLOCK_ALL;
 306
 307                 //
 308                 // Perform some final common processing
 309                 //
 310
 311                 ASSERT( pFcb->OpenHandleCount != 0);
 312
 313                 if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
 314                 {
 315
 316                     stFileCleanup.ParentId = pFcb->ObjectInformation->ParentObjectInformation->FileId;
 317                 }
 318
 319                 stFileCleanup.LastAccessTime = pObjectInfo->LastAccessTime;
 320
 321                 if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED))
 322                 {
 323
 324                     stFileCleanup.AllocationSize = pObjectInfo->EndOfFile;
 325
 326                     stFileCleanup.FileAttributes = pObjectInfo->FileAttributes;
 327
 328                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CREATE_TIME))
 329                     {
 330
 331                         stFileCleanup.CreateTime = pObjectInfo->CreationTime;
 332
 333                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CREATE_TIME);
 334                     }
 335
 336                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CHANGE_TIME))
 337                     {
 338
 339                         stFileCleanup.ChangeTime = pObjectInfo->ChangeTime;
 340
 341                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
 342                     }
 343
 344                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_ACCESS_TIME))
 345                     {
 346
 347                         stFileCleanup.LastAccessTime = pObjectInfo->LastAccessTime;
 348
 349                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
 350                     }
 351
 352                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME))
 353                     {
 354
 355                         stFileCleanup.LastWriteTime = pObjectInfo->LastWriteTime;
 356
 357                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME | AFS_FCB_FLAG_UPDATE_WRITE_TIME);
 358                     }
 359                 }
 360
 361                 if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_WRITE_TIME))
 362                 {
 363
 364                     stFileCleanup.LastWriteTime = pObjectInfo->LastWriteTime;
 365                 }
 366
 367                 //
 368                 // If the count has dropped to one and there is a pending delete
 369                 // then delete the node.  The final count will be decremented just
 370                 // before the Fcb->NPFcb->Resource is released.
 371                 //
 372
 373                 if( pFcb->OpenHandleCount == 1 &&
 374                     BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
 375                 {
 376
 377                     //
 378                     // Stop anything possibly in process
 379                     //
 380
 381                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 382                                   AFS_TRACE_LEVEL_VERBOSE,
 383                                   "AFSCleanup Acquiring Fcb extents lock %08lX EXCL %08lX\n",
 384                                   &pFcb->NPFcb->Specific.File.ExtentsResource,
 385                                   PsGetCurrentThread());
 386
 387                     AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
 388                                     TRUE);
 389
 390                     pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_FILE_DELETED;
 391
 392                     KeSetEvent( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestComplete,
 393                                 0,
 394                                 FALSE);
 395
 396                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 397                                   AFS_TRACE_LEVEL_VERBOSE,
 398                                   "AFSCleanup Releasing Fcb extents lock %08lX EXCL %08lX\n",
 399                                   &pFcb->NPFcb->Specific.File.ExtentsResource,
 400                                   PsGetCurrentThread());
 401
 402                     AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource);
 403
 404                     //
 405                     // Before telling the server about the deleted file, tear down all extents for
 406                     // the file
 407                     //
 408
 409                     AFSTearDownFcbExtents( pFcb,
 410                                            &pCcb->AuthGroup);
 411
 412                     ntStatus = STATUS_SUCCESS;
 413
 414                     ulNotificationFlags |= AFS_REQUEST_FLAG_FILE_DELETED;
 415
 416                     //
 417                     // Indicate the file access mode that is being released
 418                     //
 419
 420                     stFileCleanup.FileAccess = pCcb->FileAccess;
 421
 422                     //
 423                     // Push the request to the service
 424                     //
 425
 426                     ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
 427                                                   ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
 428                                                   &pCcb->AuthGroup,
 429                                                   &pCcb->DirectoryCB->NameInformation.FileName,
 430                                                   &pObjectInfo->FileId,
 431                                                   &stFileCleanup,
 432                                                   sizeof( AFSFileCleanupCB),
 433                                                   pResultCB,
 434                                                   &ulResultLen);
 435
 436                     if( !NT_SUCCESS( ntStatus) &&
 437                         ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
 438                     {
 439
 440                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 441                                       AFS_TRACE_LEVEL_ERROR,
 442                                       "AFSCleanup Failed to notify service of deleted file %wZ Status %08lX\n",
 443                                       &pCcb->FullFileName,
 444                                       ntStatus);
 445
 446                         ntStatus = STATUS_SUCCESS;
 447
 448                         ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
 449                     }
 450                     else
 451                     {
 452
 453                         ntStatus = STATUS_SUCCESS;
 454
 455                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 456                                       AFS_TRACE_LEVEL_VERBOSE,
 457                                       "AFSCleanup Setting DELETE flag in file %wZ Dir Entry %p\n",
 458                                       &pCcb->FullFileName,
 459                                       pCcb->DirectoryCB);
 460
 461                         SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_DELETED);
 462
 463                         ASSERT( pObjectInfo->ParentObjectInformation != NULL);
 464
 465                         AFSAcquireExcl( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
 466                                         TRUE);
 467
 468                         if ( pObjectInfo->ParentObjectInformation->DataVersion.QuadPart != pResultCB->ParentDataVersion.QuadPart - 1)
 469                         {
 470
 471                             SetFlag( pObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
 472
 473                             pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
 474                         }
 475                         else
 476                         {
 477
 478                             pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = pResultCB->ParentDataVersion.QuadPart;
 479                         }
 480
 481                         //
 482                         // Now that the service has the entry has deleted we need to remove it from the parent
 483                         // tree so another lookup on the node will fail
 484                         //
 485
 486                         if( !BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
 487                         {
 488
 489                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 490                                           AFS_TRACE_LEVEL_VERBOSE,
 491                                           "AFSCleanup DE %p for %wZ removing entry\n",
 492                                           pCcb->DirectoryCB,
 493                                           &pCcb->DirectoryCB->NameInformation.FileName);
 494
 495                             AFSRemoveNameEntry( pObjectInfo->ParentObjectInformation,
 496                                                 pCcb->DirectoryCB);
 497                         }
 498                         else
 499                         {
 500
 501                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 502                                           AFS_TRACE_LEVEL_VERBOSE,
 503                                           "AFSCleanup DE %p for %wZ NOT removing entry due to flag set\n",
 504                                           pCcb->DirectoryCB,
 505                                           &pCcb->DirectoryCB->NameInformation.FileName);
 506                         }
 507
 508                         AFSReleaseResource( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
 509
 510                         AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
 511                                                         pCcb,
 512                                                         (ULONG)FILE_NOTIFY_CHANGE_FILE_NAME,
 513                                                         (ULONG)FILE_ACTION_REMOVED);
 514
 515                     }
 516                 }
 517                 else
 518                 {
 519
 520                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED))
 521                     {
 522
 523                         ULONG ulNotifyFilter = 0;
 524
 525                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
 526
 527                         ulNotifyFilter |= (FILE_NOTIFY_CHANGE_ATTRIBUTES);
 528
 529                         AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
 530                                                         pCcb,
 531                                                         (ULONG)ulNotifyFilter,
 532                                                         (ULONG)FILE_ACTION_MODIFIED);
 533                     }
 534
 535                     //
 536                     // Attempt to flush any dirty extents to the server. This may be a little
 537                     // aggressive, to flush whenever the handle is closed, but it ensures
 538                     // coherency.
 539                     //
 540
 541                     if( (pCcb->GrantedAccess & FILE_WRITE_DATA) &&
 542                         pFcb->Specific.File.ExtentsDirtyCount != 0)
 543                     {
 544
 545                         AFSFlushExtents( pFcb,
 546                                          &pCcb->AuthGroup);
 547                     }
 548
 549                     if( pFcb->OpenHandleCount == 1)
 550                     {
 551
 552                         //
 553                         // Wait for any outstanding queued flushes to complete
 554                         //
 555
 556                         AFSWaitOnQueuedFlushes( pFcb);
 557
 558                         ulNotificationFlags |= AFS_REQUEST_FLAG_FLUSH_FILE;
 559                     }
 560
 561                     //
 562                     // Indicate the file access mode that is being released
 563                     //
 564
 565                     stFileCleanup.FileAccess = pCcb->FileAccess;
 566
 567                     //
 568                     // Push the request to the service
 569                     //
 570
 571                     ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
 572                                                   ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
 573                                                   &pCcb->AuthGroup,
 574                                                   &pCcb->DirectoryCB->NameInformation.FileName,
 575                                                   &pObjectInfo->FileId,
 576                                                   &stFileCleanup,
 577                                                   sizeof( AFSFileCleanupCB),
 578                                                   pResultCB,
 579                                                   &ulResultLen);
 580
 581                     if ( NT_SUCCESS( ntStatus))
 582                     {
 583
 584                         if ( pObjectInfo->ParentObjectInformation != NULL)
 585                         {
 586
 587                             AFSAcquireExcl( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
 588                                             TRUE);
 589
 590                             if ( pObjectInfo->ParentObjectInformation->DataVersion.QuadPart != pResultCB->ParentDataVersion.QuadPart)
 591                             {
 592
 593                                 SetFlag( pObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
 594
 595                                 pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
 596                             }
 597
 598                             AFSReleaseResource( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
 599                         }
 600                     }
 601
 602                     ntStatus = STATUS_SUCCESS;
 603                 }
 604
 605                 //
 606                 // Remove the share access at this time since we may not get the close for sometime on this FO.
 607                 //
 608
 609                 IoRemoveShareAccess( pFileObject,
 610                                      &pFcb->ShareAccess);
 611
 612                 //
 613                 // We don't need the name array after the user closes the handle on the file
 614                 //
 615
 616                 if( pCcb->NameArray != NULL)
 617                 {
 618
 619                     AFSFreeNameArray( pCcb->NameArray);
 620
 621                     pCcb->NameArray = NULL;
 622                 }
 623
 624                 //
 625                 // Decrement the open child handle count
 626                 //
 627
 628                 if( pObjectInfo->ParentObjectInformation != NULL)
 629                 {
 630
 631                     ASSERT( pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount > 0);
 632
 633                     lCount = InterlockedDecrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
 634
 635                     AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 636                                   AFS_TRACE_LEVEL_VERBOSE,
 637                                   "AFSCleanup (File) Decrement child open handle count on Parent object %08lX Cnt %d\n",
 638                                   pObjectInfo->ParentObjectInformation,
 639                                   lCount);
 640                 }
 641
 642                 AFSReleaseResource( &pFcb->NPFcb->Resource);
 643
 644                 if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE))
 645                 {
 646                     InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
 647
 648                     ClearFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
 649
 650                     AFSPerformObjectInvalidate( pObjectInfo,
 651                                                 AFS_INVALIDATE_DATA_VERSION);
 652                 }
 653
 654                 lCount = InterlockedDecrement( &pFcb->OpenHandleCount);
 655
 656                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 657                               AFS_TRACE_LEVEL_VERBOSE,
 658                               "AFSCleanup (File) Decrement handle count on Fcb %08lX Cnt %d\n",
 659                               pFcb,
 660                               lCount);
 661
 662                 break;
 663             }
 664
 665             //
 666             // Root or directory node
 667             //
 668
 669             case AFS_ROOT_FCB:
 670             {
 671
 672                 //
 673                 // Set the root Fcb to this node
 674                 //
 675
 676                 pRootFcb = pFcb;
 677
 678                 //
 679                 // Fall through to below
 680                 //
 681             }
 682
 683             case AFS_DIRECTORY_FCB:
 684             {
 685
 686                 //
 687                 // We may be performing some cleanup on the Fcb so grab it exclusive to ensure no collisions
 688                 //
 689
 690                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 691                               AFS_TRACE_LEVEL_VERBOSE,
 692                               "AFSCleanup Acquiring Dcb lock %08lX EXCL %08lX\n",
 693                               &pFcb->NPFcb->Resource,
 694                               PsGetCurrentThread());
 695
 696                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 697                                   TRUE);
 698
 699                 //
 700                 // Perform some final common processing
 701                 //
 702
 703                 ASSERT( pFcb->OpenHandleCount != 0);
 704
 705                 if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
 706                 {
 707
 708                     stFileCleanup.ParentId = pFcb->ObjectInformation->ParentObjectInformation->FileId;
 709                 }
 710
 711                 stFileCleanup.LastAccessTime = pObjectInfo->LastAccessTime;
 712
 713                 if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED))
 714                 {
 715
 716                     stFileCleanup.FileAttributes = pObjectInfo->FileAttributes;
 717
 718                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CREATE_TIME))
 719                     {
 720
 721                         stFileCleanup.CreateTime = pObjectInfo->CreationTime;
 722
 723                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CREATE_TIME);
 724                     }
 725
 726                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CHANGE_TIME))
 727                     {
 728
 729                         stFileCleanup.ChangeTime = pObjectInfo->ChangeTime;
 730
 731                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
 732                     }
 733
 734                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_ACCESS_TIME))
 735                     {
 736
 737                         stFileCleanup.LastAccessTime = pObjectInfo->LastAccessTime;
 738
 739                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
 740                     }
 741                 }
 742
 743                 //
 744                 // If the count has dropped to one and there is a pending delete
 745                 // then delete the node.  The final count will be decremented just
 746                 // before the Fcb->NPFcb->Resource is released.
 747                 //
 748
 749                 if( pFcb->OpenHandleCount == 1 &&
 750                     BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
 751                 {
 752
 753                     //
 754                     // Try to notify the service about the delete
 755                     //
 756
 757                     ulNotificationFlags |= AFS_REQUEST_FLAG_FILE_DELETED;
 758
 759                     //
 760                     // Indicate the file access mode that is being released
 761                     //
 762
 763                     stFileCleanup.FileAccess = pCcb->FileAccess;
 764
 765                     //
 766                     // Push the request to the service
 767                     //
 768
 769                     ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
 770                                                   ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
 771                                                   &pCcb->AuthGroup,
 772                                                   &pCcb->DirectoryCB->NameInformation.FileName,
 773                                                   &pObjectInfo->FileId,
 774                                                   &stFileCleanup,
 775                                                   sizeof( AFSFileCleanupCB),
 776                                                   pResultCB,
 777                                                   &ulResultLen);
 778
 779                     if( !NT_SUCCESS( ntStatus) &&
 780                         ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
 781                     {
 782
 783                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 784                                       AFS_TRACE_LEVEL_ERROR,
 785                                       "AFSCleanup Failed to notify service of deleted directory %wZ Status %08lX\n",
 786                                       &pCcb->FullFileName,
 787                                       ntStatus);
 788
 789                         ntStatus = STATUS_SUCCESS;
 790
 791                         ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
 792                     }
 793                     else
 794                     {
 795
 796                         ntStatus = STATUS_SUCCESS;
 797
 798                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 799                                       AFS_TRACE_LEVEL_VERBOSE,
 800                                       "AFSCleanup Setting DELETE flag in directory %wZ Dir Entry %p\n",
 801                                       &pCcb->FullFileName,
 802                                       pCcb->DirectoryCB);
 803
 804                         SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_DELETED);
 805
 806                         ASSERT( pObjectInfo->ParentObjectInformation != NULL);
 807
 808                         AFSAcquireExcl( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
 809                                         TRUE);
 810
 811                         if ( pObjectInfo->ParentObjectInformation->DataVersion.QuadPart != pResultCB->ParentDataVersion.QuadPart - 1)
 812                         {
 813
 814                             SetFlag( pObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
 815
 816                             pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
 817                         }
 818                         else
 819                         {
 820
 821                             pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = pResultCB->ParentDataVersion.QuadPart;
 822                         }
 823
 824                         //
 825                         // Now that the service has the entry has deleted we need to remove it from the parent
 826                         // tree so another lookup on the node will fail
 827                         //
 828
 829                         if( !BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
 830                         {
 831
 832                             AFSRemoveNameEntry( pObjectInfo->ParentObjectInformation,
 833                                                 pCcb->DirectoryCB);
 834                         }
 835                         else
 836                         {
 837
 838                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 839                                           AFS_TRACE_LEVEL_VERBOSE,
 840                                           "AFSCleanup DE %p for %wZ NOT removing entry due to flag set\n",
 841                                           pCcb->DirectoryCB,
 842                                           &pCcb->DirectoryCB->NameInformation.FileName);
 843                         }
 844
 845                         AFSReleaseResource( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
 846
 847                         AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
 848                                                         pCcb,
 849                                                         (ULONG)FILE_NOTIFY_CHANGE_FILE_NAME,
 850                                                         (ULONG)FILE_ACTION_REMOVED);
 851
 852                     }
 853                 }
 854
 855                 //
 856                 // If there have been any updates to the node then push it to
 857                 // the service
 858                 //
 859
 860                 else
 861                 {
 862
 863                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED))
 864                     {
 865
 866                         ULONG ulNotifyFilter = 0;
 867
 868                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
 869
 870                         if(  pObjectInfo->ParentObjectInformation != NULL)
 871                         {
 872
 873                             ulNotifyFilter |= (FILE_NOTIFY_CHANGE_ATTRIBUTES);
 874
 875                             AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
 876                                                             pCcb,
 877                                                             (ULONG)ulNotifyFilter,
 878                                                             (ULONG)FILE_ACTION_MODIFIED);
 879                         }
 880                     }
 881
 882                     //
 883                     // Indicate the file access mode that is being released
 884                     //
 885
 886                     stFileCleanup.FileAccess = pCcb->FileAccess;
 887
 888                     ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
 889                                                   ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
 890                                                   &pCcb->AuthGroup,
 891                                                   &pCcb->DirectoryCB->NameInformation.FileName,
 892                                                   &pObjectInfo->FileId,
 893                                                   &stFileCleanup,
 894                                                   sizeof( AFSFileCleanupCB),
 895                                                   pResultCB,
 896                                                   &ulResultLen);
 897
 898                     if ( NT_SUCCESS( ntStatus))
 899                     {
 900
 901                         if ( pObjectInfo->ParentObjectInformation != NULL)
 902                         {
 903
 904                             AFSAcquireExcl( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
 905                                               TRUE);
 906
 907                             if ( pObjectInfo->ParentObjectInformation->DataVersion.QuadPart != pResultCB->ParentDataVersion.QuadPart)
 908                             {
 909
 910                                 SetFlag( pObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
 911
 912                                 pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
 913                             }
 914
 915                             AFSReleaseResource( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
 916                         }
 917                     }
 918
 919                     ntStatus = STATUS_SUCCESS;
 920                 }
 921
 922                 //
 923                 // Release the notification for this directory if there is one
 924                 //
 925
 926                 FsRtlNotifyCleanup( pControlDeviceExt->Specific.Control.NotifySync,
 927                                     &pControlDeviceExt->Specific.Control.DirNotifyList,
 928                                     pCcb);
 929
 930                 //
 931                 // Remove the share access at this time since we may not get the close for sometime on this FO.
 932                 //
 933
 934                 IoRemoveShareAccess( pFileObject,
 935                                      &pFcb->ShareAccess);
 936
 937                 //
 938                 // We don't need the name array after the user closes the handle on the file
 939                 //
 940
 941                 if( pCcb->NameArray != NULL)
 942                 {
 943
 944                     AFSFreeNameArray( pCcb->NameArray);
 945
 946                     pCcb->NameArray = NULL;
 947                 }
 948
 949                 //
 950                 // Decrement the open child handle count
 951                 //
 952
 953                 if( pObjectInfo->ParentObjectInformation != NULL)
 954                 {
 955
 956                     ASSERT( pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount > 0);
 957
 958                     lCount = InterlockedDecrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
 959
 960                     AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 961                                   AFS_TRACE_LEVEL_VERBOSE,
 962                                   "AFSCleanup (Dir) Decrement child open handle count on Parent object %08lX Cnt %d\n",
 963                                   pObjectInfo->ParentObjectInformation,
 964                                   lCount);
 965                 }
 966
 967                 AFSReleaseResource( &pFcb->NPFcb->Resource);
 968
 969                 lCount = InterlockedDecrement( &pFcb->OpenHandleCount);
 970
 971                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 972                               AFS_TRACE_LEVEL_VERBOSE,
 973                               "AFSCleanup (Dir) Decrement handle count on Fcb %08lX Cnt %d\n",
 974                               pFcb,
 975                               lCount);
 976
 977                 break;
 978             }
 979
 980             case AFS_SYMBOLIC_LINK_FCB:
 981             case AFS_MOUNT_POINT_FCB:
 982             case AFS_DFS_LINK_FCB:
 983             case AFS_INVALID_FCB:
 984             {
 985
 986                 //
 987                 // We may be performing some cleanup on the Fcb so grab it exclusive to ensure no collisions
 988                 //
 989
 990                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 991                               AFS_TRACE_LEVEL_VERBOSE,
 992                               "AFSCleanup (MP/SL) Acquiring Dcb lock %08lX EXCL %08lX\n",
 993                               &pFcb->NPFcb->Resource,
 994                               PsGetCurrentThread());
 995
 996                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 997                                   TRUE);
 998
 999                 //
1000                 // Perform some final common processing
1001                 //
1002
1003                 ASSERT( pFcb->OpenHandleCount != 0);
1004
1005                 if( pFcb->ObjectInformation->ParentObjectInformation != NULL)
1006                 {
1007
1008                     stFileCleanup.ParentId = pFcb->ObjectInformation->ParentObjectInformation->FileId;
1009                 }
1010
1011                 stFileCleanup.LastAccessTime = pObjectInfo->LastAccessTime;
1012
1013                 if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED))
1014                 {
1015
1016                     stFileCleanup.FileAttributes = pObjectInfo->FileAttributes;
1017
1018                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CREATE_TIME))
1019                     {
1020
1021                         stFileCleanup.CreateTime = pObjectInfo->CreationTime;
1022
1023                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CREATE_TIME);
1024                     }
1025
1026                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CHANGE_TIME))
1027                     {
1028
1029                         stFileCleanup.ChangeTime = pObjectInfo->ChangeTime;
1030
1031                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_CHANGE_TIME);
1032                     }
1033
1034                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_ACCESS_TIME))
1035                     {
1036
1037                         stFileCleanup.LastAccessTime = pObjectInfo->LastAccessTime;
1038
1039                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_ACCESS_TIME);
1040                     }
1041                 }
1042
1043                 //
1044                 // If the count has dropped to one and there is a pending delete
1045                 // then delete the node.  The final count will be decremented just
1046                 // before the Fcb->NPFcb->Resource is released.
1047                 //
1048
1049                 if( pFcb->OpenHandleCount == 1 &&
1050                     BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
1051                 {
1052
1053                     //
1054                     // Try to notify the service about the delete
1055                     //
1056
1057                     ulNotificationFlags |= AFS_REQUEST_FLAG_FILE_DELETED;
1058
1059                     //
1060                     // Indicate the file access mode that is being released
1061                     //
1062
1063                     stFileCleanup.FileAccess = pCcb->FileAccess;
1064
1065                     //
1066                     // Push the request to the service
1067                     //
1068
1069                     ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
1070                                                   ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
1071                                                   &pCcb->AuthGroup,
1072                                                   &pCcb->DirectoryCB->NameInformation.FileName,
1073                                                   &pObjectInfo->FileId,
1074                                                   &stFileCleanup,
1075                                                   sizeof( AFSFileCleanupCB),
1076                                                   pResultCB,
1077                                                   &ulResultLen);
1078
1079                     if( !NT_SUCCESS( ntStatus) &&
1080                         ntStatus != STATUS_OBJECT_NAME_NOT_FOUND)
1081                     {
1082
1083                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1084                                       AFS_TRACE_LEVEL_ERROR,
1085                                       "AFSCleanup Failed to notify service of deleted MP/SL %wZ Status %08lX\n",
1086                                       &pCcb->FullFileName,
1087                                       ntStatus);
1088
1089                         ntStatus = STATUS_SUCCESS;
1090
1091                         ClearFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_PENDING_DELETE);
1092                     }
1093                     else
1094                     {
1095
1096                         ntStatus = STATUS_SUCCESS;
1097
1098                         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1099                                       AFS_TRACE_LEVEL_VERBOSE,
1100                                       "AFSCleanup Setting DELETE flag in MP/SL %wZ Dir Entry %p\n",
1101                                       &pCcb->FullFileName,
1102                                       pCcb->DirectoryCB);
1103
1104                         SetFlag( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_DELETED);
1105
1106                         ASSERT( pObjectInfo->ParentObjectInformation != NULL);
1107
1108                         AFSAcquireExcl( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1109                                         TRUE);
1110
1111                         if ( pObjectInfo->ParentObjectInformation->DataVersion.QuadPart != pResultCB->ParentDataVersion.QuadPart - 1)
1112                         {
1113
1114                             SetFlag( pObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
1115
1116                             pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
1117                         }
1118                         else
1119                         {
1120                             pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = pResultCB->ParentDataVersion.QuadPart;
1121                         }
1122
1123                         //
1124                         // Now that the service has the entry has deleted we need to remove it from the parent
1125                         // tree so another lookup on the node will fail
1126                         //
1127
1128                         if( !BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
1129                         {
1130
1131                             AFSRemoveNameEntry( pObjectInfo->ParentObjectInformation,
1132                                                 pCcb->DirectoryCB);
1133                         }
1134                         else
1135                         {
1136
1137                             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1138                                           AFS_TRACE_LEVEL_VERBOSE,
1139                                           "AFSCleanup DE %p for %wZ NOT removing entry due to flag set\n",
1140                                           pCcb->DirectoryCB,
1141                                           &pCcb->DirectoryCB->NameInformation.FileName);
1142                         }
1143
1144                         AFSReleaseResource( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1145
1146                         AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
1147                                                         pCcb,
1148                                                         (ULONG)FILE_NOTIFY_CHANGE_FILE_NAME,
1149                                                         (ULONG)FILE_ACTION_REMOVED);
1150
1151                     }
1152                 }
1153
1154                 //
1155                 // If there have been any updates to the node then push it to
1156                 // the service
1157                 //
1158
1159                 else
1160                 {
1161
1162                     if( BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED))
1163                     {
1164
1165                         ULONG ulNotifyFilter = 0;
1166
1167                         ClearFlag( pFcb->Flags, AFS_FCB_FLAG_FILE_MODIFIED);
1168
1169                         if(  pObjectInfo->ParentObjectInformation != NULL)
1170                         {
1171
1172                             ulNotifyFilter |= (FILE_NOTIFY_CHANGE_ATTRIBUTES);
1173
1174                             AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
1175                                                             pCcb,
1176                                                             (ULONG)ulNotifyFilter,
1177                                                             (ULONG)FILE_ACTION_MODIFIED);
1178                         }
1179                     }
1180
1181                     //
1182                     // Indicate the file access mode that is being released
1183                     //
1184
1185                     stFileCleanup.FileAccess = pCcb->FileAccess;
1186
1187                     ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
1188                                                   ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
1189                                                   &pCcb->AuthGroup,
1190                                                   &pCcb->DirectoryCB->NameInformation.FileName,
1191                                                   &pObjectInfo->FileId,
1192                                                   &stFileCleanup,
1193                                                   sizeof( AFSFileCleanupCB),
1194                                                   pResultCB,
1195                                                   &ulResultLen);
1196
1197                     if ( NT_SUCCESS( ntStatus))
1198                     {
1199
1200                         if ( pObjectInfo->ParentObjectInformation != NULL)
1201                         {
1202
1203                             AFSAcquireExcl( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
1204                                               TRUE);
1205
1206                             if ( pObjectInfo->ParentObjectInformation->DataVersion.QuadPart != pResultCB->ParentDataVersion.QuadPart)
1207                             {
1208
1209                                 SetFlag( pObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
1210
1211                                 pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
1212                             }
1213
1214                             AFSReleaseResource( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
1215                         }
1216                     }
1217
1218                     ntStatus = STATUS_SUCCESS;
1219                 }
1220
1221                 //
1222                 // Remove the share access at this time since we may not get the close for sometime on this FO.
1223                 //
1224
1225                 IoRemoveShareAccess( pFileObject,
1226                                      &pFcb->ShareAccess);
1227
1228                 //
1229                 // We don't need the name array after the user closes the handle on the file
1230                 //
1231
1232                 if( pCcb->NameArray != NULL)
1233                 {
1234
1235                     AFSFreeNameArray( pCcb->NameArray);
1236
1237                     pCcb->NameArray = NULL;
1238                 }
1239
1240                 //
1241                 // Decrement the open child handle count
1242                 //
1243
1244                 if( pObjectInfo->ParentObjectInformation != NULL)
1245                 {
1246
1247                     ASSERT( pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount > 0);
1248
1249                     lCount = InterlockedDecrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
1250
1251                     AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1252                                   AFS_TRACE_LEVEL_VERBOSE,
1253                                   "AFSCleanup (MP/SL) Decrement child open handle count on Parent object %08lX Cnt %d\n",
1254                                   pObjectInfo->ParentObjectInformation,
1255                                   lCount);
1256                 }
1257
1258                 AFSReleaseResource( &pFcb->NPFcb->Resource);
1259
1260                 lCount = InterlockedDecrement( &pFcb->OpenHandleCount);
1261
1262                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1263                               AFS_TRACE_LEVEL_VERBOSE,
1264                               "AFSCleanup (MP/SL) Decrement handle count on Fcb %08lX Cnt %d\n",
1265                               pFcb,
1266                               lCount);
1267
1268                 break;
1269             }
1270
1271             case AFS_SPECIAL_SHARE_FCB:
1272             {
1273
1274                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1275                               AFS_TRACE_LEVEL_VERBOSE,
1276                               "AFSCleanup Acquiring SPECIAL SHARE lock %08lX EXCL %08lX\n",
1277                               &pFcb->NPFcb->Resource,
1278                               PsGetCurrentThread());
1279
1280                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
1281                                 TRUE);
1282
1283                 ASSERT( pFcb->OpenHandleCount != 0);
1284
1285                 //
1286                 // Decrement the open child handle count
1287                 //
1288
1289                 if( pObjectInfo->ParentObjectInformation != NULL &&
1290                     pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount > 0)
1291                 {
1292
1293                     lCount = InterlockedDecrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenHandleCount);
1294
1295                     AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1296                                   AFS_TRACE_LEVEL_VERBOSE,
1297                                   "AFSCleanup (Share) Decrement child open handle count on Parent object %08lX Cnt %d\n",
1298                                   pObjectInfo->ParentObjectInformation,
1299                                   lCount);
1300                 }
1301
1302                 AFSReleaseResource( &pFcb->NPFcb->Resource);
1303
1304                 lCount = InterlockedDecrement( &pFcb->OpenHandleCount);
1305
1306                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
1307                               AFS_TRACE_LEVEL_VERBOSE,
1308                               "AFSCleanup (Share) Decrement handle count on Fcb %08lX Cnt %d\n",
1309                               pFcb,
1310                               lCount);
1311
1312                 break;
1313             }
1314
1315             default:
1316
1317                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1318                               AFS_TRACE_LEVEL_WARNING,
1319                               "AFSCleanup Processing unknown node type %d\n",
1320                               pFcb->Header.NodeTypeCode);
1321
1322                 break;
1323         }
1324
1325
1326 try_exit:
1327
1328         if( pResultCB != NULL)
1329         {
1330
1331             AFSExFreePool( pResultCB);
1332         }
1333
1334         if( pFileObject != NULL)
1335         {
1336
1337             //
1338             // Setup the fileobject flags to indicate cleanup is complete.
1339             //
1340
1341             SetFlag( pFileObject->Flags, FO_CLEANUP_COMPLETE);
1342         }
1343
1344         //
1345         // Complete the request
1346         //
1347
1348         AFSCompleteRequest( Irp, ntStatus);
1349     }
1350     __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
1351     {
1352
1353         AFSDbgLogMsg( 0,
1354                       0,
1355                       "EXCEPTION - AFSCleanup\n");
1356     }
1357
1358     return ntStatus;
1359 }