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