62bcb21258b518afa64bafeac97e0fed456a8412
[openafs.git] / 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( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
690     {
691
692         AFSDbgLogMsg( 0,
693                       0,
694                       "EXCEPTION - AFSClose\n");
695
696         AFSDumpTraceFilesFnc();
697     }
698
699     return ntStatus;
700 }