src/WINNT/afsrdr/kernel/lib/AFSClose.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: AFSClose.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 //
  42 // Function: AFSClose
  43 //
  44 // Description:
  45 //
  46 //      This function is the IRP_MJ_CLOSE dispatch handler
  47 //
  48 // Return:
  49 //
  50 //       A status is returned for the handling of this request
  51 //
  52
  53 NTSTATUS
  54 AFSClose( IN PDEVICE_OBJECT LibDeviceObject,
  55           IN PIRP Irp)
  56 {
  57
  58     NTSTATUS ntStatus = STATUS_SUCCESS;
  59     ULONG ulRequestType = 0;
  60     IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
  61     AFSFcb *pFcb = NULL;
  62     AFSDeviceExt *pDeviceExt = NULL;
  63     AFSCcb *pCcb = NULL;
  64     AFSObjectInfoCB *pObjectInfo = NULL;
  65     AFSDirectoryCB *pDirCB = NULL;
  66     LONG lCount;
  67
  68     __try
  69     {
  70
  71         if( AFSRDRDeviceObject == NULL)
  72         {
  73
  74             //
  75             // Let this through, it's an close on the library control device
  76             //
  77
  78             try_return( ntStatus);
  79         }
  80
  81         pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
  82
  83         pIrpSp = IoGetCurrentIrpStackLocation( Irp);
  84
  85         pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
  86
  87         if( pFcb == NULL)
  88         {
  89             try_return( ntStatus);
  90         }
  91
  92         pObjectInfo = pFcb->ObjectInformation;
  93
  94         //
  95         // Perform the close functionality depending on the type of node it is
  96         //
  97
  98         switch( pFcb->Header.NodeTypeCode)
  99         {
 100
 101             case AFS_IOCTL_FCB:
 102             {
 103
 104                 AFSPIOCtlOpenCloseRequestCB stPIOCtlClose;
 105                 AFSFileID stParentFileId;
 106
 107                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 108                               AFS_TRACE_LEVEL_VERBOSE,
 109                               "AFSClose Acquiring GlobalRoot lock %08lX EXCL %08lX\n",
 110                               &pFcb->NPFcb->Resource,
 111                               PsGetCurrentThread());
 112
 113                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 114                                   TRUE);
 115
 116                 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
 117
 118                 //
 119                 // Send the close to the CM
 120                 //
 121
 122                 RtlZeroMemory( &stPIOCtlClose,
 123                                sizeof( AFSPIOCtlOpenCloseRequestCB));
 124
 125                 stPIOCtlClose.RequestId = pCcb->RequestID;
 126
 127                 stPIOCtlClose.RootId = pObjectInfo->VolumeCB->ObjectInformation.FileId;
 128
 129                 RtlZeroMemory( &stParentFileId,
 130                                sizeof( AFSFileID));
 131
 132                 stParentFileId = pObjectInfo->ParentObjectInformation->FileId;
 133
 134                 //
 135                 // Issue the close request to the service
 136                 //
 137
 138                 AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_CLOSE,
 139                                    AFS_REQUEST_FLAG_SYNCHRONOUS,
 140                                    &pCcb->AuthGroup,
 141                                    NULL,
 142                                    &stParentFileId,
 143                                    (void *)&stPIOCtlClose,
 144                                    sizeof( AFSPIOCtlOpenCloseRequestCB),
 145                                    NULL,
 146                                    NULL);
 147
 148                 pDirCB = pCcb->DirectoryCB;
 149
 150                 //
 151                 // Remove the Ccb and de-allocate it
 152                 //
 153
 154                 ntStatus = AFSRemoveCcb( pFcb,
 155                                          pCcb);
 156
 157                 if( !NT_SUCCESS( ntStatus))
 158                 {
 159
 160                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 161                                   AFS_TRACE_LEVEL_WARNING,
 162                                   "AFSClose Failed to remove Ccb from Fcb Status %08lX\n", ntStatus);
 163
 164                     //
 165                     // We can't actually fail a close operation so reset the status
 166                     //
 167
 168                     ntStatus = STATUS_SUCCESS;
 169                 }
 170
 171                 lCount = InterlockedDecrement( &pDirCB->DirOpenReferenceCount);
 172
 173                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 174                               AFS_TRACE_LEVEL_VERBOSE,
 175                               "AFSClose (IOCtl) Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
 176                               &pDirCB->NameInformation.FileName,
 177                               pDirCB,
 178                               pCcb,
 179                               lCount);
 180
 181                 ASSERT( lCount >= 0);
 182
 183                 //
 184                 // If this is not the root then decrement the open child reference count
 185                 //
 186
 187                 if( pObjectInfo->ParentObjectInformation != NULL &&
 188                     pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
 189                 {
 190
 191                     InterlockedDecrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
 192
 193                     AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 194                                   AFS_TRACE_LEVEL_VERBOSE,
 195                                   "AFSClose (IOCtl) Decrement child open ref count on Parent object %08lX Cnt %d\n",
 196                                   pObjectInfo->ParentObjectInformation,
 197                                   pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
 198                 }
 199
 200                 AFSReleaseResource( &pFcb->NPFcb->Resource);
 201
 202                 lCount = InterlockedDecrement( &pFcb->OpenReferenceCount);
 203
 204                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 205                               AFS_TRACE_LEVEL_VERBOSE,
 206                               "AFSClose (IOCtl) Decrement count on Fcb %08lX Cnt %d\n",
 207                               pFcb,
 208                               lCount);
 209
 210                 ASSERT( lCount >= 0);
 211
 212                 break;
 213             }
 214
 215             case AFS_ROOT_ALL:
 216             {
 217
 218                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 219                               AFS_TRACE_LEVEL_VERBOSE,
 220                               "AFSClose Acquiring Special Root ALL lock %08lX EXCL %08lX\n",
 221                               &pFcb->NPFcb->Resource,
 222                               PsGetCurrentThread());
 223
 224                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 225                                 TRUE);
 226
 227                 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
 228
 229                 pDirCB = pCcb->DirectoryCB;
 230
 231                 //
 232                 // Remove the Ccb and de-allocate it
 233                 //
 234
 235                 ntStatus = AFSRemoveCcb( pFcb,
 236                                          pCcb);
 237
 238                 if( !NT_SUCCESS( ntStatus))
 239                 {
 240
 241                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 242                                   AFS_TRACE_LEVEL_WARNING,
 243                                   "AFSClose Failed to remove Ccb from Fcb Status %08lX\n", ntStatus);
 244
 245                     //
 246                     // We can't actually fail a close operation so reset the status
 247                     //
 248
 249                     ntStatus = STATUS_SUCCESS;
 250                 }
 251
 252                 lCount = InterlockedDecrement( &pDirCB->DirOpenReferenceCount);
 253
 254                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 255                               AFS_TRACE_LEVEL_VERBOSE,
 256                               "AFSClose Decrement (Root ALL) count on %wZ DE %p Ccb %p Cnt %d\n",
 257                               &pDirCB->NameInformation.FileName,
 258                               pDirCB,
 259                               pCcb,
 260                               lCount);
 261
 262                 ASSERT( lCount >= 0);
 263
 264                 AFSReleaseResource( &pFcb->NPFcb->Resource);
 265
 266                 lCount = InterlockedDecrement( &pFcb->OpenReferenceCount);
 267
 268                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 269                               AFS_TRACE_LEVEL_VERBOSE,
 270                               "AFSClose (RootAll) Decrement count on Fcb %08lX Cnt %d\n",
 271                               pFcb,
 272                               lCount);
 273
 274                 ASSERT( lCount >= 0);
 275
 276                 break;
 277             }
 278
 279             //
 280             // Root, file or directory node
 281             //
 282
 283             case AFS_FILE_FCB:
 284             case AFS_ROOT_FCB:
 285             case AFS_DIRECTORY_FCB:
 286             case AFS_SYMBOLIC_LINK_FCB:
 287             case AFS_MOUNT_POINT_FCB:
 288             case AFS_DFS_LINK_FCB:
 289             case AFS_INVALID_FCB:
 290             {
 291
 292                 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
 293
 294                 //
 295                 // We may be performing some cleanup on the Fcb so grab it exclusive to ensure no collisions
 296                 //
 297
 298                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 299                               AFS_TRACE_LEVEL_VERBOSE,
 300                               "AFSClose Acquiring Dcb lock %08lX EXCL %08lX\n",
 301                               &pFcb->NPFcb->Resource,
 302                               PsGetCurrentThread());
 303
 304                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 305                                 TRUE);
 306
 307                 KeQueryTickCount( &pFcb->ObjectInformation->LastAccessCount);
 308
 309                 if( pFcb->OpenReferenceCount == 1 &&
 310                     pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
 311                 {
 312
 313                     SetFlag( pFcb->Flags, AFS_FCB_FILE_CLOSED);
 314
 315                     //
 316                     // Attempt to tear down our extent list for the file
 317                     // If there are remaining dirty extents then attempt to
 318                     // flush them as well
 319                     //
 320
 321                     if( pFcb->Specific.File.ExtentsDirtyCount)
 322                     {
 323
 324                         AFSFlushExtents( pFcb,
 325                                          &pCcb->AuthGroup);
 326                     }
 327
 328                     //
 329                     // Wait for any outstanding queued flushes to complete
 330                     //
 331
 332                     AFSWaitOnQueuedFlushes( pFcb);
 333
 334                     ASSERT( pFcb->Specific.File.ExtentsDirtyCount == 0 &&
 335                             pFcb->Specific.File.QueuedFlushCount == 0);
 336
 337                     AFSReleaseResource( &pFcb->NPFcb->Resource);
 338
 339                     //
 340                     // Tear 'em down, we'll not be needing them again
 341                     //
 342
 343                     AFSTearDownFcbExtents( pFcb,
 344                                            &pCcb->AuthGroup);
 345                 }
 346                 else
 347                 {
 348
 349                     if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB &&
 350                         pFcb->Specific.File.ExtentsDirtyCount &&
 351                         (pCcb->GrantedAccess & FILE_WRITE_DATA))
 352                     {
 353
 354                         AFSFlushExtents( pFcb,
 355                                          &pCcb->AuthGroup);
 356                     }
 357
 358                     AFSReleaseResource( &pFcb->NPFcb->Resource);
 359                 }
 360
 361                 pDirCB = pCcb->DirectoryCB;
 362
 363                 //
 364                 // Remove the Ccb and de-allocate it
 365                 //
 366
 367                 ntStatus = AFSRemoveCcb( pFcb,
 368                                          pCcb);
 369
 370                 if( !NT_SUCCESS( ntStatus))
 371                 {
 372
 373                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 374                                   AFS_TRACE_LEVEL_WARNING,
 375                                   "AFSClose Failed to remove Ccb from Fcb Status %08lX\n",
 376                                   ntStatus);
 377
 378                     //
 379                     // We can't actually fail a close operation so reset the status
 380                     //
 381
 382                     ntStatus = STATUS_SUCCESS;
 383                 }
 384
 385                 //
 386                 // If this entry is deleted then remove the object from the volume tree
 387                 //
 388
 389                 if( BooleanFlagOn( pDirCB->Flags, AFS_DIR_ENTRY_DELETED))
 390                 {
 391
 392                     if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB &&
 393                         pObjectInfo->Links == 0)
 394                     {
 395
 396                         //
 397                         // Stop anything possibly in process
 398                         //
 399
 400                         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 401                                       AFS_TRACE_LEVEL_VERBOSE,
 402                                       "AFSClose Acquiring Fcb extents lock %08lX EXCL %08lX\n",
 403                                       &pFcb->NPFcb->Specific.File.ExtentsResource,
 404                                       PsGetCurrentThread());
 405
 406                         AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
 407                                         TRUE);
 408
 409                         pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_FILE_DELETED;
 410
 411                         KeSetEvent( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestComplete,
 412                                     0,
 413                                     FALSE);
 414
 415                         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 416                                       AFS_TRACE_LEVEL_VERBOSE,
 417                                       "AFSClose Releasing Fcb extents lock %08lX EXCL %08lX\n",
 418                                       &pFcb->NPFcb->Specific.File.ExtentsResource,
 419                                       PsGetCurrentThread());
 420
 421                         AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource);
 422                     }
 423
 424                     AFSAcquireExcl( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
 425                                     TRUE);
 426
 427                     AFSAcquireExcl( pObjectInfo->VolumeCB->ObjectInfoTree.TreeLock,
 428                                     TRUE);
 429
 430                     lCount = InterlockedDecrement( &pDirCB->DirOpenReferenceCount);
 431
 432                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 433                                   AFS_TRACE_LEVEL_VERBOSE,
 434                                   "AFSClose (Other) Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
 435                                   &pDirCB->NameInformation.FileName,
 436                                   pDirCB,
 437                                   pCcb,
 438                                   lCount);
 439
 440                     ASSERT( lCount >= 0);
 441
 442                     if( lCount == 0)
 443                     {
 444
 445                         AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
 446                                       AFS_TRACE_LEVEL_VERBOSE,
 447                                       "AFSClose Deleting dir entry %08lX (%08lX) for %wZ  FID %08lX-%08lX-%08lX-%08lX\n",
 448                                       pDirCB,
 449                                       pObjectInfo,
 450                                       &pDirCB->NameInformation.FileName,
 451                                       pObjectInfo->FileId.Cell,
 452                                       pObjectInfo->FileId.Volume,
 453                                       pObjectInfo->FileId.Vnode,
 454                                       pObjectInfo->FileId.Unique);
 455
 456                         //
 457                         // Remove and delete the directory entry from the parent list
 458                         //
 459
 460                         AFSDeleteDirEntry( pObjectInfo->ParentObjectInformation,
 461                                            pDirCB);
 462
 463                         AFSAcquireShared( &pObjectInfo->NonPagedInfo->ObjectInfoLock,
 464                                           TRUE);
 465
 466                         if( pObjectInfo->ObjectReferenceCount <= 0)
 467                         {
 468
 469                             if( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
 470                             {
 471
 472                                 AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
 473                                               AFS_TRACE_LEVEL_VERBOSE,
 474                                               "AFSClose Removing object %08lX from volume tree\n",
 475                                               pObjectInfo);
 476
 477                                 AFSRemoveHashEntry( &pObjectInfo->VolumeCB->ObjectInfoTree.TreeHead,
 478                                                     &pObjectInfo->TreeEntry);
 479
 480                                 ClearFlag( pObjectInfo->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
 481                             }
 482                         }
 483
 484                         AFSReleaseResource( &pObjectInfo->NonPagedInfo->ObjectInfoLock);
 485                     }
 486
 487                     AFSReleaseResource( pObjectInfo->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
 488
 489                     AFSReleaseResource( pObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
 490                 }
 491                 else
 492                 {
 493
 494                     lCount = InterlockedDecrement( &pDirCB->DirOpenReferenceCount);
 495
 496                     AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 497                                   AFS_TRACE_LEVEL_VERBOSE,
 498                                   "AFSClose (Other2) Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
 499                                   &pDirCB->NameInformation.FileName,
 500                                   pDirCB,
 501                                   pCcb,
 502                                   lCount);
 503
 504                     ASSERT( lCount >= 0);
 505                 }
 506
 507                 //
 508                 // If this is not the root then decrement the open child reference count
 509                 //
 510
 511                 if( pObjectInfo != NULL &&
 512                     pObjectInfo->ParentObjectInformation != NULL &&
 513                     pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
 514                 {
 515
 516                     InterlockedDecrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
 517
 518                     AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 519                                   AFS_TRACE_LEVEL_VERBOSE,
 520                                   "AFSClose Decrement child open ref count on Parent object %08lX Cnt %d\n",
 521                                   pObjectInfo->ParentObjectInformation,
 522                                   pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
 523                 }
 524
 525                 //
 526                 // Decrement the reference count on the Fcb. this is protecting it from teardown.
 527                 //
 528
 529                 lCount = InterlockedDecrement( &pFcb->OpenReferenceCount);
 530
 531                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 532                               AFS_TRACE_LEVEL_VERBOSE,
 533                               "AFSClose Decrement count on Fcb %08lX Cnt %d\n",
 534                               pFcb,
 535                               lCount);
 536
 537                 ASSERT( lCount >= 0);
 538
 539                 break;
 540             }
 541
 542             case AFS_SPECIAL_SHARE_FCB:
 543             {
 544
 545                 AFSPipeOpenCloseRequestCB stPipeClose;
 546
 547                 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
 548
 549                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 550                               AFS_TRACE_LEVEL_VERBOSE,
 551                               "AFSClose Acquiring Special Share lock %08lX EXCL %08lX\n",
 552                               &pFcb->NPFcb->Resource,
 553                               PsGetCurrentThread());
 554
 555                 AFSAcquireExcl( &pFcb->NPFcb->Resource,
 556                                 TRUE);
 557
 558                 RtlZeroMemory( &stPipeClose,
 559                                sizeof( AFSPipeOpenCloseRequestCB));
 560
 561                 stPipeClose.RequestId = pCcb->RequestID;
 562
 563                 stPipeClose.RootId = pObjectInfo->VolumeCB->ObjectInformation.FileId;
 564
 565                 //
 566                 // Issue the open request to the service
 567                 //
 568
 569                 /*
 570                 AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_CLOSE,
 571                                    AFS_REQUEST_FLAG_SYNCHRONOUS,
 572                                    &pFcb->AuthGroup,
 573                                    &pDirCB->NameInformation.FileName,
 574                                    NULL,
 575                                    (void *)&stPipeClose,
 576                                    sizeof( AFSPipeOpenCloseRequestCB),
 577                                    NULL,
 578                                    NULL);
 579                 */
 580
 581                 pDirCB = pCcb->DirectoryCB;
 582
 583                 //
 584                 // Remove the Ccb and de-allocate it
 585                 //
 586
 587                 ntStatus = AFSRemoveCcb( pFcb,
 588                                          pCcb);
 589
 590                 if( !NT_SUCCESS( ntStatus))
 591                 {
 592
 593                     AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 594                                   AFS_TRACE_LEVEL_WARNING,
 595                                   "AFSClose Failed to remove Ccb from Fcb Status %08lX\n", ntStatus);
 596
 597                     //
 598                     // We can't actually fail a close operation so reset the status
 599                     //
 600
 601                     ntStatus = STATUS_SUCCESS;
 602                 }
 603
 604                 lCount = InterlockedDecrement( &pDirCB->DirOpenReferenceCount);
 605
 606                 AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
 607                               AFS_TRACE_LEVEL_VERBOSE,
 608                               "AFSClose (Share) Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
 609                               &pDirCB->NameInformation.FileName,
 610                               pDirCB,
 611                               pCcb,
 612                               lCount);
 613
 614                 ASSERT( lCount >= 0);
 615
 616                 //
 617                 // If this is not the root then decrement the open child reference count
 618                 //
 619
 620                 if( pObjectInfo->ParentObjectInformation != NULL &&
 621                     pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
 622                 {
 623
 624                     lCount = InterlockedDecrement( &pObjectInfo->ParentObjectInformation->Specific.Directory.ChildOpenReferenceCount);
 625
 626                     AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 627                                   AFS_TRACE_LEVEL_VERBOSE,
 628                                   "AFSClose (Share) Decrement child open ref count on Parent object %08lX Cnt %d\n",
 629                                   pObjectInfo->ParentObjectInformation,
 630                                   lCount);
 631                 }
 632
 633                 AFSReleaseResource( &pFcb->NPFcb->Resource);
 634
 635                 lCount = InterlockedDecrement( &pFcb->OpenReferenceCount);
 636
 637                 AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
 638                               AFS_TRACE_LEVEL_VERBOSE,
 639                               "AFSClose (Share) Decrement count on Fcb %08lX Cnt %d\n",
 640                               pFcb,
 641                               lCount);
 642
 643                 ASSERT( lCount >= 0);
 644
 645                 break;
 646             }
 647
 648             default:
 649
 650                 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 651                               AFS_TRACE_LEVEL_ERROR,
 652                               "AFSClose Processing unknown node type %d\n",
 653                               pFcb->Header.NodeTypeCode);
 654
 655                 break;
 656         }
 657
 658 try_exit:
 659
 660         //
 661         // Complete the request
 662         //
 663
 664         AFSCompleteRequest( Irp,
 665                             ntStatus);
 666     }
 667     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
 668     {
 669
 670         AFSDbgLogMsg( 0,
 671                       0,
 672                       "EXCEPTION - AFSClose\n");
 673
 674         AFSDumpTraceFilesFnc();
 675     }
 676
 677     return ntStatus;
 678 }