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