a5c2984009f987e61fef3c540d5851eecac20c28
[openafs.git] / src / WINNT / afsrdr / kernel / lib / AFSExtentsSupport.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: AFSCommSupport.cpp
37 //
38 #include "AFSCommon.h"
39
40 #define AFS_MAX_FCBS_TO_DROP 10
41
42 static ULONG ExtentsMasks[AFS_NUM_EXTENT_LISTS] = AFS_EXTENTS_MASKS;
43 static VOID VerifyExtentsLists(AFSFcb *Fcb);
44 static AFSExtent *DirtyExtentFor(PLIST_ENTRY le);
45
46 LIST_ENTRY *
47 AFSEntryForOffset( IN AFSFcb *Fcb,
48                    IN PLARGE_INTEGER Offset);
49
50
51 //
52 // Returns with Extents lock EX and no one using them.
53 //
54
55 VOID
56 AFSLockForExtentsTrim( IN AFSFcb *Fcb)
57 {
58
59     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
60                   AFS_TRACE_LEVEL_VERBOSE,
61                   "AFSLockForExtentsTrim Acquiring Fcb extents lock %08lX EXCL %08lX\n",
62                   &Fcb->NPFcb->Specific.File.ExtentsResource,
63                   PsGetCurrentThread());
64
65     AFSAcquireExcl( &Fcb->NPFcb->Specific.File.ExtentsResource, TRUE );
66
67     return;
68 }
69
70 //
71 // return FALSE *or* with Extents lock EX and noone using them
72 //
73 BOOLEAN
74 AFSLockForExtentsTrimNoWait( IN AFSFcb *Fcb)
75 {
76
77     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
78                   AFS_TRACE_LEVEL_VERBOSE,
79                   "AFSLockForExtentsTrimNoWait Attempting to acquire Fcb extent lock %08lX EXCL %08lX\n",
80                   &Fcb->NPFcb->Specific.File.ExtentsResource,
81                   PsGetCurrentThread());
82
83     if (!AFSAcquireExcl( &Fcb->NPFcb->Specific.File.ExtentsResource, FALSE ))
84     {
85         //
86         // Couldn't lock immediately
87         //
88
89         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
90                       AFS_TRACE_LEVEL_VERBOSE,
91                       "AFSLockForExtentsTrimNoWait Refused to wait for Fcb extent lock %08lX EXCL %08lX\n",
92                       &Fcb->NPFcb->Specific.File.ExtentsResource,
93                       PsGetCurrentThread());
94
95         return FALSE;
96     }
97
98     return TRUE;
99 }
100
101 static VOID
102 AFSFreeExtent( IN AFSFcb *Fcb,
103                IN AFSExtent *pExtent)
104 {
105     AFSDeviceExt        *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
106     LONG                 lCount;
107
108     for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i ++)
109     {
110         if (NULL != pExtent->Lists[i].Flink && !IsListEmpty(&pExtent->Lists[i]))
111         {
112             RemoveEntryList( &pExtent->Lists[i] );
113         }
114     }
115
116     InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, -((LONG)(pExtent->Size/1024)));
117
118     InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, -((LONG)(pExtent->Size/1024)));
119
120     lCount = InterlockedDecrement( &Fcb->Specific.File.ExtentCount);
121
122     lCount = InterlockedDecrement( &pControlDevExt->Specific.Control.ExtentCount);
123
124     if( lCount == 0)
125     {
126
127         KeSetEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
128                     0,
129                     FALSE);
130     }
131
132     AFSExFreePoolWithTag( pExtent, AFS_EXTENT_TAG);
133 }
134
135 //
136 // AFSTearDownFcbExtents was originally written to
137 // remove all of the extents from an FCB.  For that to happen
138 // it must be an invariant that the extent list cannot change
139 // from the moment the caller decides to execute AFSTearDownFcbExtents
140 // until it returns.  This invariant does not hold because the
141 // the decision to call AFSTearDownFcbExtents is made without
142 // holding the ExtentsResource and it is possible that extents
143 // are in active use. Therefore, AFSTearDownFcbExtents now releases
144 // as many non-active extents as it can.
145 //
146 VOID
147 AFSTearDownFcbExtents( IN AFSFcb *Fcb,
148                        IN GUID *AuthGroup)
149 {
150     AFSNonPagedFcb      *pNPFcb = Fcb->NPFcb;
151     LIST_ENTRY          *le, *leNext;
152     AFSExtent           *pEntry;
153     LONG                 lExtentCount = 0, lProcessCount = 0;
154     ULONG                ulReleaseCount = 0;
155     size_t               sz;
156     AFSReleaseExtentsCB *pRelease = NULL;
157     BOOLEAN              locked = FALSE;
158     NTSTATUS             ntStatus;
159     AFSDeviceExt        *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
160     GUID                *pAuthGroup = AuthGroup;
161     GUID                 stAuthGroup;
162     LONG                 lCount;
163
164     __Enter
165     {
166
167         if( pAuthGroup == NULL ||
168             RtlCompareMemory( pAuthGroup,
169                               &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
170                               sizeof( GUID)) == sizeof( GUID))
171         {
172
173             RtlZeroMemory( &stAuthGroup,
174                            sizeof( GUID));
175
176             ntStatus = AFSRetrieveValidAuthGroup( Fcb,
177                                                   NULL,
178                                                   TRUE,
179                                                   &stAuthGroup);
180
181             if( !NT_SUCCESS( ntStatus))
182             {
183                 try_return( ntStatus);
184             }
185
186             pAuthGroup = &stAuthGroup;
187         }
188
189         //
190         // Ensure that no one is working with the extents and grab the
191         // lock
192         //
193
194         AFSLockForExtentsTrim( Fcb );
195
196         locked = TRUE;
197
198         if (0 == Fcb->Specific.File.ExtentCount)
199         {
200             try_return ( ntStatus = STATUS_SUCCESS);
201         }
202
203         sz = sizeof( AFSReleaseExtentsCB ) + (AFS_MAXIMUM_EXTENT_RELEASE_COUNT * sizeof ( AFSFileExtentCB ));
204
205         pRelease = (AFSReleaseExtentsCB*) AFSExAllocatePoolWithTag( NonPagedPool,
206                                                                     sz,
207                                                                     AFS_EXTENT_RELEASE_TAG);
208         if (NULL == pRelease)
209         {
210
211             try_return ( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
212         }
213
214         AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
215                         TRUE);
216
217         for( le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink,
218              lExtentCount = 0;
219              lExtentCount < Fcb->Specific.File.ExtentCount;
220              lExtentCount += lProcessCount)
221         {
222
223             RtlZeroMemory( pRelease,
224                            sizeof( AFSReleaseExtentsCB ) +
225                            (AFS_MAXIMUM_EXTENT_RELEASE_COUNT * sizeof ( AFSFileExtentCB )));
226
227             for( lProcessCount = 0, ulReleaseCount = 0;
228                  !IsListEmpty( le) &&
229                  ulReleaseCount < AFS_MAXIMUM_EXTENT_RELEASE_COUNT &&
230                  lExtentCount + lProcessCount < Fcb->Specific.File.ExtentCount;
231                  lProcessCount++, le = leNext)
232             {
233
234                 leNext = le->Flink;
235
236                 pEntry = ExtentFor( le, AFS_EXTENTS_LIST );
237
238                 if( pEntry->ActiveCount == 0)
239                 {
240
241                     pRelease->FileExtents[ulReleaseCount].Flags = AFS_EXTENT_FLAG_RELEASE;
242
243 #if GEN_MD5
244                     RtlCopyMemory( pRelease->FileExtents[ulReleaseCount].MD5,
245                                    pEntry->MD5,
246                                    sizeof(pEntry->MD5));
247
248                     pRelease->FileExtents[ulReleaseCount].Flags |= AFS_EXTENT_FLAG_MD5_SET;
249 #endif
250
251                     if( BooleanFlagOn( pEntry->Flags, AFS_EXTENT_DIRTY))
252                     {
253
254                         LONG dirtyCount;
255
256                         AFSRemoveEntryDirtyList( Fcb,
257                                                  pEntry);
258
259                         pRelease->FileExtents[ulReleaseCount].Flags |= AFS_EXTENT_FLAG_DIRTY;
260
261                         dirtyCount = InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
262
263                         ASSERT( dirtyCount >= 0);
264                     }
265
266                     AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
267                                   AFS_TRACE_LEVEL_VERBOSE,
268                                   "AFSTearDownFcbExtents Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %08lX-%08lX Len %08lX\n",
269                                   pEntry,
270                                   Fcb->ObjectInformation->FileId.Cell,
271                                   Fcb->ObjectInformation->FileId.Volume,
272                                   Fcb->ObjectInformation->FileId.Vnode,
273                                   Fcb->ObjectInformation->FileId.Unique,
274                                   pEntry->FileOffset.HighPart,
275                                   pEntry->FileOffset.LowPart,
276                                   pEntry->Size);
277
278                     pRelease->FileExtents[ulReleaseCount].Length = pEntry->Size;
279                     pRelease->FileExtents[ulReleaseCount].DirtyLength = pEntry->Size;
280                     pRelease->FileExtents[ulReleaseCount].DirtyOffset = 0;
281                     pRelease->FileExtents[ulReleaseCount].CacheOffset = pEntry->CacheOffset;
282                     pRelease->FileExtents[ulReleaseCount].FileOffset = pEntry->FileOffset;
283
284                     ulReleaseCount++;
285
286                     AFSFreeExtent( Fcb,
287                                    pEntry);
288                 }
289             }
290
291             if ( ulReleaseCount > 0)
292             {
293
294                 pRelease->ExtentCount = ulReleaseCount;
295
296                 pRelease->Flags = AFS_EXTENT_FLAG_RELEASE;
297
298                 //
299                 // Update the metadata for this call
300                 //
301
302                 pRelease->AllocationSize = Fcb->ObjectInformation->EndOfFile;
303                 pRelease->CreateTime = Fcb->ObjectInformation->CreationTime;
304                 pRelease->ChangeTime = Fcb->ObjectInformation->ChangeTime;
305                 pRelease->LastAccessTime = Fcb->ObjectInformation->LastAccessTime;
306                 pRelease->LastWriteTime = Fcb->ObjectInformation->LastWriteTime;
307
308                 //
309                 // Send the request down.  We cannot send this down
310                 // asynchronously - if we did that we could request them
311                 // back before the service got this request and then this
312                 // request would be a corruption.
313                 //
314
315                 sz = sizeof( AFSReleaseExtentsCB ) + (lProcessCount * sizeof ( AFSFileExtentCB ));
316
317                 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
318                                               AFS_REQUEST_FLAG_SYNCHRONOUS,
319                                               pAuthGroup,
320                                               NULL,
321                                               &Fcb->ObjectInformation->FileId,
322                                               pRelease,
323                                               sz,
324                                               NULL,
325                                               NULL);
326
327                 if( !NT_SUCCESS(ntStatus))
328                 {
329
330                     //
331                     // Regardless of whether or not the AFSProcessRequest() succeeded, the extents
332                     // were released (if AFS_EXTENT_FLAG_RELEASE was set).  Log the error so it is known.
333                     //
334
335                     AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
336                                   AFS_TRACE_LEVEL_ERROR,
337                                   "AFSTearDownFcbExtents AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
338                                   Fcb->ObjectInformation->FileId.Cell,
339                                   Fcb->ObjectInformation->FileId.Volume,
340                                   Fcb->ObjectInformation->FileId.Vnode,
341                                   Fcb->ObjectInformation->FileId.Unique,
342                                   ntStatus);
343
344                 }
345             }
346         }
347
348         AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
349
350         //
351         // if all extents have been released, reinitialize the skip lists
352         //
353
354         if( Fcb->Specific.File.ExtentCount == 0)
355         {
356
357             for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i++)
358             {
359                 InitializeListHead(&Fcb->Specific.File.ExtentsLists[i]);
360             }
361
362             //
363             // Reinitialize the dirty list as well
364             //
365
366             AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
367                             TRUE);
368
369             ASSERT( Fcb->Specific.File.ExtentsDirtyCount == 0);
370
371             Fcb->NPFcb->Specific.File.DirtyListHead = NULL;
372             Fcb->NPFcb->Specific.File.DirtyListTail = NULL;
373
374             AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
375         }
376
377         Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
378
379 try_exit:
380
381         if (locked)
382         {
383
384             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
385                           AFS_TRACE_LEVEL_VERBOSE,
386                           "AFSTearDownFcbExtents Releasing Fcb extent lock %08lX thread %08lX\n",
387                           &Fcb->NPFcb->Specific.File.ExtentsResource,
388                           PsGetCurrentThread());
389
390             AFSReleaseResource( &Fcb->NPFcb->Specific.File.ExtentsResource );
391         }
392
393         if (pRelease)
394         {
395
396             AFSExFreePoolWithTag( pRelease, AFS_EXTENT_RELEASE_TAG);
397         }
398     }
399 }
400
401 static PAFSExtent
402 ExtentForOffsetInList( IN AFSFcb *Fcb,
403                        IN LIST_ENTRY *List,
404                        IN ULONG ListNumber,
405                        IN PLARGE_INTEGER Offset)
406 {
407     //
408     // Return the extent that maps the offset, that
409     //   - Contains the offset
410     //   - or is immediately ahead of the offset (in this list)
411     //   - otherwise return NULL.
412     //
413
414     PLIST_ENTRY  pLe = List;
415     AFSExtent   *pPrevious = NULL;
416
417     ASSERT( ExIsResourceAcquiredLite( &Fcb->NPFcb->Specific.File.ExtentsResource ));
418
419     while (pLe != &Fcb->Specific.File.ExtentsLists[ListNumber])
420     {
421         AFSExtent *entry;
422
423         entry = ExtentFor( pLe, ListNumber );
424
425         if( entry == NULL)
426         {
427             return entry;
428         }
429
430         if (Offset->QuadPart < entry->FileOffset.QuadPart)
431         {
432             //
433             // Offset is ahead of entry.  Return previous
434             //
435             return pPrevious;
436         }
437
438         if (Offset->QuadPart >= (entry->FileOffset.QuadPart + entry->Size))
439         {
440             //
441             // We start after this extent - carry on round
442             //
443             pPrevious = entry;
444             pLe = pLe->Flink;
445             continue;
446         }
447
448         //
449         // Otherwise its a match
450         //
451
452         return entry;
453     }
454
455     //
456     // Got to the end.  Return Previous
457     //
458     return pPrevious;
459 }
460
461 BOOLEAN
462 AFSExtentContains( IN AFSExtent *Extent, IN PLARGE_INTEGER Offset)
463 {
464     if (NULL == Extent)
465     {
466         return FALSE;
467     }
468     return (Extent->FileOffset.QuadPart <= Offset->QuadPart &&
469             (Extent->FileOffset.QuadPart + Extent->Size) > Offset->QuadPart);
470 }
471
472
473 //
474 // Return the extent that contains the offset
475 //
476 PAFSExtent
477 AFSExtentForOffsetHint( IN AFSFcb *Fcb,
478                         IN PLARGE_INTEGER Offset,
479                         IN BOOLEAN ReturnPrevious,
480                         IN AFSExtent *Hint)
481 {
482     AFSExtent *pPrevious = Hint;
483     LIST_ENTRY *pLe;
484     LONG i;
485
486     ASSERT( ExIsResourceAcquiredLite( &Fcb->NPFcb->Specific.File.ExtentsResource ));
487
488 #if AFS_VALIDATE_EXTENTS
489     VerifyExtentsLists(Fcb);
490 #endif
491
492     //
493     // So we will go across the skip lists until we find an
494     // appropriate entry (previous or direct match).  If it's a match
495     // we are done, other wise we start on the next layer down
496     //
497     for (i = AFS_NUM_EXTENT_LISTS-1; i >= AFS_EXTENTS_LIST; i--)
498     {
499         if (NULL == pPrevious)
500         {
501             //
502             // We haven't found anything in the previous layers
503             //
504             pLe = Fcb->Specific.File.ExtentsLists[i].Flink;
505         }
506         else if (NULL == pPrevious->Lists[i].Flink)
507         {
508             ASSERT(AFS_EXTENTS_LIST != i);
509             //
510             // The hint doesn't exist at this level, next one down
511             //
512             continue;
513         }
514         else
515         {
516             //
517             // take the previous into the next
518             //
519             pLe = &pPrevious->Lists[i];
520         }
521
522         pPrevious = ExtentForOffsetInList( Fcb, pLe, i, Offset);
523
524         if (NULL != pPrevious && AFSExtentContains(pPrevious, Offset))
525         {
526             //
527             // Found it immediately.  Stop here
528             //
529             return pPrevious;
530         }
531     }
532
533     if (NULL == pPrevious || ReturnPrevious )
534     {
535         return pPrevious;
536     }
537
538     ASSERT( !AFSExtentContains(pPrevious, Offset) );
539
540     return NULL;
541 }
542
543 LIST_ENTRY *
544 AFSEntryForOffset( IN AFSFcb *Fcb,
545                    IN PLARGE_INTEGER Offset)
546 {
547     AFSExtent *pPrevious = NULL;
548     LIST_ENTRY *pLe;
549     LONG i;
550
551     ASSERT( ExIsResourceAcquiredLite( &Fcb->NPFcb->Specific.File.ExtentsResource ));
552
553 #if AFS_VALIDATE_EXTENTS
554     VerifyExtentsLists(Fcb);
555 #endif
556
557     //
558     // So we will go across the skip lists until we find an
559     // appropriate entry (previous or direct match).  If it's a match
560     // we are done, other wise we start on the next layer down
561     //
562     for (i = AFS_NUM_EXTENT_LISTS-1; i >= AFS_EXTENTS_LIST; i--)
563     {
564         if (NULL == pPrevious)
565         {
566             //
567             // We haven't found anything in the previous layers
568             //
569             pLe = Fcb->Specific.File.ExtentsLists[i].Flink;
570         }
571         else if (NULL == pPrevious->Lists[i].Flink)
572         {
573             ASSERT(AFS_EXTENTS_LIST != i);
574             //
575             // The hint doesn't exist at this level, next one down
576             //
577             continue;
578         }
579         else
580         {
581             //
582             // take the previous into the next
583             //
584             pLe = &pPrevious->Lists[i];
585         }
586
587         pPrevious = ExtentForOffsetInList( Fcb, pLe, i, Offset);
588
589         if (NULL != pPrevious && AFSExtentContains(pPrevious, Offset))
590         {
591             //
592             // Found it immediately.  Stop here
593             //
594             return pLe;
595         }
596     }
597
598     return NULL;
599 }
600
601 PAFSExtent
602 AFSExtentForOffset( IN AFSFcb *Fcb,
603                     IN PLARGE_INTEGER Offset,
604                     IN BOOLEAN ReturnPrevious)
605 {
606     return AFSExtentForOffsetHint(Fcb, Offset, ReturnPrevious, NULL);
607 }
608
609
610 BOOLEAN AFSDoExtentsMapRegion(IN AFSFcb *Fcb,
611                               IN PLARGE_INTEGER Offset,
612                               IN ULONG Size,
613                               IN OUT AFSExtent **FirstExtent,
614                               OUT AFSExtent **LastExtent)
615 {
616     //
617     // Return TRUE region is completely mapped.  FALSE
618     // otherwise.  If the region isn't mapped then the last
619     // extent to map part of the region is returned.
620     //
621     // *LastExtent as input is where to start looking.
622     // *LastExtent as output is either the extent which
623     //  contains the Offset, or the last one which doesn't
624     //
625     AFSExtent *entry;
626     AFSExtent *newEntry;
627     BOOLEAN retVal = FALSE;
628
629     __Enter
630     {
631
632         ASSERT( ExIsResourceAcquiredLite( &Fcb->NPFcb->Specific.File.ExtentsResource ));
633
634         __try
635         {
636             entry = AFSExtentForOffsetHint(Fcb, Offset, TRUE, *FirstExtent);
637             *FirstExtent = entry;
638
639             if (NULL == entry || !AFSExtentContains(entry, Offset))
640             {
641                 try_return (retVal = FALSE);
642             }
643
644             ASSERT(Offset->QuadPart >= entry->FileOffset.QuadPart);
645
646             while (TRUE)
647             {
648                 if ((entry->FileOffset.QuadPart + entry->Size) >=
649                      (Offset->QuadPart + Size))
650                 {
651                     //
652                     // The end is inside the extent
653                     //
654                     try_return (retVal = TRUE);
655                 }
656
657                 if (entry->Lists[AFS_EXTENTS_LIST].Flink == &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
658                 {
659                     //
660                     // Run out of extents
661                     //
662                     try_return (retVal = FALSE);
663                 }
664
665                 newEntry = NextExtent( entry, AFS_EXTENTS_LIST );
666
667                 if (newEntry->FileOffset.QuadPart !=
668                      (entry->FileOffset.QuadPart + entry->Size))
669                 {
670                     //
671                     // Gap
672                     //
673                     try_return (retVal = FALSE);
674                 }
675
676                 entry = newEntry;
677             }
678         }
679         __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
680         {
681
682             AFSDbgLogMsg( 0,
683                           0,
684                           "EXCEPTION - AFSDoExtentsMapRegion\n");
685
686             AFSDumpTraceFilesFnc();
687         }
688
689 try_exit:
690
691         *LastExtent = entry;
692     }
693
694     return retVal;
695 }
696
697 NTSTATUS
698 AFSRequestExtentsAsync( IN AFSFcb *Fcb,
699                         IN AFSCcb *Ccb,
700                         IN PLARGE_INTEGER Offset,
701                         IN ULONG Size)
702 {
703
704     AFSDeviceExt        *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
705     NTSTATUS             ntStatus = STATUS_SUCCESS;
706     AFSExtent           *pExtent = NULL;
707     AFSRequestExtentsCB  request;
708     AFSNonPagedFcb      *pNPFcb = Fcb->NPFcb;
709     AFSExtent           *pFirstExtent = NULL;
710     LARGE_INTEGER        liAlignedOffset;
711     ULONG                ulAlignedLength = 0;
712     BOOLEAN              bRegionMapped = FALSE;
713     ULONGLONG            ullProcessId = (ULONGLONG)PsGetCurrentProcessId();
714
715     __Enter
716     {
717
718         ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->Specific.File.ExtentsResource ));
719
720         //
721         // If the service set a failure on the file since the last
722         // CreateFile was issued, return it now.
723         //
724
725         if (!NT_SUCCESS( pNPFcb->Specific.File.ExtentsRequestStatus))
726         {
727
728             //
729             // If this isn't the same authgroup which caused the failure
730             // then try to request them again
731             //
732
733             if( RtlCompareMemory( &pNPFcb->Specific.File.ExtentsRequestAuthGroup,
734                                   &Ccb->AuthGroup,
735                                   sizeof( GUID)) == sizeof( GUID))
736             {
737
738                 ntStatus = pNPFcb->Specific.File.ExtentsRequestStatus;
739
740                 pNPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
741
742                 RtlZeroMemory( &pNPFcb->Specific.File.ExtentsRequestAuthGroup,
743                                sizeof( GUID));
744
745                 try_return( ntStatus);
746             }
747         }
748
749         //
750         // Check if we are already mapped
751         //
752
753         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
754                       AFS_TRACE_LEVEL_VERBOSE,
755                       "AFSRequestExtentsAsync Acquiring Fcb extents lock %08lX SHARED %08lX\n",
756                       &pNPFcb->Specific.File.ExtentsResource,
757                       PsGetCurrentThread());
758
759         AFSAcquireShared( &pNPFcb->Specific.File.ExtentsResource, TRUE );
760
761         bRegionMapped = AFSDoExtentsMapRegion( Fcb, Offset, Size, &pFirstExtent, &pExtent);
762
763         if( bRegionMapped)
764         {
765
766             KeClearEvent( &pNPFcb->Specific.File.ExtentsRequestComplete );
767         }
768
769         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
770                       AFS_TRACE_LEVEL_VERBOSE,
771                       "AFSRequestExtentsAsync Releasing Fcb extents lock %08lX SHARED %08lX\n",
772                       &pNPFcb->Specific.File.ExtentsResource,
773                       PsGetCurrentThread());
774
775         AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
776
777         if ( bRegionMapped)
778         {
779
780             try_return( ntStatus = STATUS_SUCCESS);
781         }
782
783         //
784         // Align our request on extent size boundary
785         //
786
787         ulAlignedLength = Size;
788
789         liAlignedOffset = *Offset;
790
791         if( liAlignedOffset.QuadPart % pDevExt->Specific.RDR.CacheBlockSize != 0)
792         {
793
794             liAlignedOffset.QuadPart = (ULONGLONG)( (ULONGLONG)(liAlignedOffset.QuadPart / pDevExt->Specific.RDR.CacheBlockSize) * (ULONGLONG)pDevExt->Specific.RDR.CacheBlockSize);
795
796             ulAlignedLength += (ULONG)(Offset->QuadPart - liAlignedOffset.QuadPart);
797         }
798
799         if( ulAlignedLength % pDevExt->Specific.RDR.CacheBlockSize != 0)
800         {
801
802             ulAlignedLength = (ULONG)(((ulAlignedLength / pDevExt->Specific.RDR.CacheBlockSize) + 1) * pDevExt->Specific.RDR.CacheBlockSize);
803         }
804
805         RtlZeroMemory( &request,
806                        sizeof( AFSRequestExtentsCB));
807
808         request.ByteOffset = liAlignedOffset;
809         request.Length = ulAlignedLength;
810
811         if( !AFSIsExtentRequestQueued( &Fcb->ObjectInformation->FileId,
812                                        &request.ByteOffset,
813                                        request.Length))
814         {
815
816             KeClearEvent( &pNPFcb->Specific.File.ExtentsRequestComplete );
817
818             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
819                           AFS_TRACE_LEVEL_VERBOSE,
820                           "AFSRequestExtentsAsync Request extents for fid %08lX-%08lX-%08lX-%08lX Offset %08lX Len %08lX Thread %08lX\n",
821                           Fcb->ObjectInformation->FileId.Cell,
822                           Fcb->ObjectInformation->FileId.Volume,
823                           Fcb->ObjectInformation->FileId.Vnode,
824                           Fcb->ObjectInformation->FileId.Unique,
825                           request.ByteOffset.LowPart,
826                           request.Length,
827                           PsGetCurrentThread());
828
829             ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS,
830                                           0,
831                                           &Ccb->AuthGroup,
832                                           NULL,
833                                           &Fcb->ObjectInformation->FileId,
834                                           &request,
835                                           sizeof( AFSRequestExtentsCB ),
836                                           NULL,
837                                           NULL);
838
839             if (  ntStatus == STATUS_ACCESS_DENIED)
840             {
841                 GUID                 stAuthGroup;
842                 DWORD                ntStatus2;
843
844                 ntStatus2 = AFSRetrieveValidAuthGroup( Fcb,
845                                                       NULL,
846                                                       TRUE,
847                                                       &stAuthGroup);
848
849                 if ( NT_SUCCESS( ntStatus2) &&
850                      RtlCompareMemory( &stAuthGroup,
851                                        &Ccb->AuthGroup,
852                                        sizeof( GUID)) != sizeof( GUID))
853                 {
854
855                     ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS,
856                                                   0,
857                                                   &stAuthGroup,
858                                                   NULL,
859                                                   &Fcb->ObjectInformation->FileId,
860                                                   &request,
861                                                   sizeof( AFSRequestExtentsCB ),
862                                                   NULL,
863                                                   NULL);
864                 }
865             }
866
867             if( !NT_SUCCESS( ntStatus))
868             {
869
870                 KeSetEvent( &pNPFcb->Specific.File.ExtentsRequestComplete,
871                             0,
872                             FALSE);
873             }
874         }
875
876 try_exit:
877
878         NOTHING;
879     }
880
881     return ntStatus;
882 }
883
884 NTSTATUS
885 AFSProcessExtentsResult( IN AFSFcb *Fcb,
886                          IN ULONG   Count,
887                          IN AFSFileExtentCB *Result)
888 {
889     NTSTATUS          ntStatus = STATUS_SUCCESS;
890     AFSFileExtentCB  *pFileExtents = Result;
891     AFSExtent        *pExtent;
892     LIST_ENTRY       *le;
893     AFSNonPagedFcb   *pNPFcb = Fcb->NPFcb;
894     ULONG             fileExtentsUsed = 0;
895     BOOLEAN           bFoundExtent = FALSE;
896     LIST_ENTRY       *pSkipEntries[AFS_NUM_EXTENT_LISTS] = { 0 };
897     AFSDeviceExt     *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
898     LONG              lCount;
899
900     //
901     // Grab the extents exclusive for the duration
902     //
903
904     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
905                   AFS_TRACE_LEVEL_VERBOSE,
906                   "AFSProcessExtentsResult Acquiring Fcb extent lock %08lX EXCL %08lX\n",
907                   &pNPFcb->Specific.File.ExtentsResource,
908                   PsGetCurrentThread());
909
910     AFSAcquireExcl( &pNPFcb->Specific.File.ExtentsResource, TRUE );
911
912     __Enter
913     {
914
915         //
916         // Find where to put the extents
917         //
918         for (ULONG i = AFS_EXTENTS_LIST; i < AFS_NUM_EXTENT_LISTS; i++)
919         {
920
921             pSkipEntries[i] = Fcb->Specific.File.ExtentsLists[i].Flink;
922         }
923
924         le = pSkipEntries[AFS_EXTENTS_LIST];
925
926         if (le == &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
927         {
928             //
929             // No extents.  Insert at head of list (which is where the skip lists point!)
930             //
931             pExtent = NULL;
932         }
933         else if (0 != pFileExtents->FileOffset.QuadPart)
934         {
935             //
936             // We want to find the best extents immediately *behind* this offset
937             //
938             LARGE_INTEGER offset = pFileExtents->FileOffset;
939
940             //
941             // Ask in the top skip list first, then work down
942             //
943             for (LONG i = AFS_NUM_EXTENT_LISTS-1; i >= AFS_EXTENTS_LIST; i--)
944             {
945                 pExtent = ExtentForOffsetInList( Fcb,
946                                                  pSkipEntries[i],
947                                                  i,
948                                                  &offset);
949
950                 if (NULL == pExtent)
951                 {
952                     //
953                     // No dice.  Header has to become the head of the list
954                     //
955                     pSkipEntries[i] = &Fcb->Specific.File.ExtentsLists[i];
956                     //
957                     // And as  a loop invariant we should never have found an extent
958                     //
959                     ASSERT(!bFoundExtent);
960                 }
961                 else
962                 {
963                     //
964                     // pExtent is where to start to insert at this level
965                     //
966                     pSkipEntries[i] = &pExtent->Lists[i];
967
968                     //
969                     // And also where to start to look at the next level
970                     //
971
972                     if (i > AFS_EXTENTS_LIST)
973                     {
974                         pSkipEntries[i-1] = &pExtent->Lists[i-1];
975                     }
976                     bFoundExtent = TRUE;
977                 }
978             }
979
980             if (NULL == pExtent)
981             {
982                 pExtent = ExtentFor( le, AFS_EXTENTS_LIST);
983                 le = le->Blink;
984             }
985             else
986             {
987                 le = pExtent->Lists[AFS_EXTENTS_LIST].Blink;
988             }
989         }
990         else
991         {
992             //
993             // Looking at offset 0, so we must start at the beginning
994             //
995
996             pExtent = ExtentFor(le, AFS_EXTENTS_LIST);
997             le = le->Blink;
998
999             //
1000             // And set up the skip lists
1001             //
1002
1003             for (ULONG i = AFS_EXTENTS_LIST; i < AFS_NUM_EXTENT_LISTS; i++)
1004             {
1005                 pSkipEntries[i] = &Fcb->Specific.File.ExtentsLists[i];
1006             }
1007         }
1008
1009         while (fileExtentsUsed < Count)
1010         {
1011
1012             //
1013             // Loop invariant - le points to where to insert after and
1014             // pExtent points to le->fLink
1015             //
1016
1017             ASSERT (NULL == pExtent ||
1018                     le->Flink == &pExtent->Lists[AFS_EXTENTS_LIST]);
1019
1020             if (NULL == pExtent ||
1021                 pExtent->FileOffset.QuadPart > pFileExtents->FileOffset.QuadPart)
1022             {
1023                 //
1024                 // We need to insert a new extent at le.  Start with
1025                 // some sanity check on spanning
1026                 //
1027                 if (NULL != pExtent &&
1028                     ((pFileExtents->FileOffset.QuadPart + pFileExtents->Length) >
1029                      pExtent->FileOffset.QuadPart))
1030                 {
1031                     //
1032                     // File Extents overlaps pExtent
1033                     //
1034                     ASSERT( (pFileExtents->FileOffset.QuadPart + pFileExtents->Length) <=
1035                             pExtent->FileOffset.QuadPart);
1036
1037                     try_return (ntStatus = STATUS_INVALID_PARAMETER);
1038                 }
1039
1040                 //
1041                 // File offset is entirely in front of this extent.  Create
1042                 // a new one (remember le is the previous list entry)
1043                 //
1044                 pExtent = (AFSExtent *) AFSExAllocatePoolWithTag( NonPagedPool,
1045                                                                   sizeof( AFSExtent),
1046                                                                   AFS_EXTENT_TAG );
1047                 if (NULL  == pExtent)
1048                 {
1049
1050                     try_return (ntStatus = STATUS_INSUFFICIENT_RESOURCES );
1051                 }
1052
1053                 RtlZeroMemory( pExtent, sizeof( AFSExtent ));
1054
1055                 pExtent->FileOffset = pFileExtents->FileOffset;
1056                 pExtent->CacheOffset = pFileExtents->CacheOffset;
1057                 pExtent->Size = pFileExtents->Length;
1058
1059                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1060                               AFS_TRACE_LEVEL_VERBOSE,
1061                               "AFSProcessExtentsResult Received extent for fid %08lX-%08lX-%08lX-%08lX File Offset %I64X Cache Offset %I64X Len %08lX\n",
1062                               Fcb->ObjectInformation->FileId.Cell,
1063                               Fcb->ObjectInformation->FileId.Volume,
1064                               Fcb->ObjectInformation->FileId.Vnode,
1065                               Fcb->ObjectInformation->FileId.Unique,
1066                               pFileExtents->FileOffset.QuadPart,
1067                               pFileExtents->CacheOffset.QuadPart,
1068                               pFileExtents->Length);
1069
1070                 InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, (LONG)(pExtent->Size/1024));
1071
1072                 InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, (LONG)(pExtent->Size/1024));
1073
1074                 lCount = InterlockedIncrement( &Fcb->Specific.File.ExtentCount);
1075
1076                 lCount = InterlockedIncrement( &pControlDevExt->Specific.Control.ExtentCount);
1077
1078                 if( lCount == 1)
1079                 {
1080
1081                     KeClearEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent);
1082                 }
1083
1084                 //
1085                 // Insert into list
1086                 //
1087                 InsertHeadList(le, &pExtent->Lists[AFS_EXTENTS_LIST]);
1088                 ASSERT(le->Flink == &pExtent->Lists[AFS_EXTENTS_LIST]);
1089                 ASSERT(0 == (pExtent->FileOffset.LowPart & ExtentsMasks[AFS_EXTENTS_LIST]));
1090
1091                 //
1092                 // Do not move the cursor - we will do it next time
1093                 //
1094
1095                 //
1096                 // And into the (upper) skip lists - Again, do not move the cursor
1097                 //
1098                 for (ULONG i = AFS_NUM_EXTENT_LISTS-1; i > AFS_EXTENTS_LIST; i--)
1099                 {
1100                     if (0 == (pExtent->FileOffset.LowPart & ExtentsMasks[i]))
1101                     {
1102                         InsertHeadList(pSkipEntries[i], &pExtent->Lists[i]);
1103 #if AFS_VALIDATE_EXTENTS
1104                         VerifyExtentsLists(Fcb);
1105 #endif
1106                     }
1107                 }
1108             }
1109             else if (pExtent->FileOffset.QuadPart == pFileExtents->FileOffset.QuadPart)
1110             {
1111
1112                 if (pExtent->Size != pFileExtents->Length)
1113                 {
1114
1115                     ASSERT (pExtent->Size == pFileExtents->Length);
1116
1117                     try_return (ntStatus = STATUS_INVALID_PARAMETER);
1118                 }
1119
1120                 //
1121                 // Move both cursors forward.
1122                 //
1123                 // First the extent pointer
1124                 //
1125                 fileExtentsUsed++;
1126                 le = &pExtent->Lists[AFS_EXTENTS_LIST];
1127
1128                 //
1129                 // Then the skip lists cursors forward if needed
1130                 //
1131                 for (ULONG i = AFS_NUM_EXTENT_LISTS-1; i > AFS_EXTENTS_LIST; i--)
1132                 {
1133                     if (0 == (pExtent->FileOffset.LowPart & ExtentsMasks[i]))
1134                     {
1135                         //
1136                         // Check sanity before
1137                         //
1138 #if AFS_VALIDATE_EXTENTS
1139                         VerifyExtentsLists(Fcb);
1140 #endif
1141
1142                         //
1143                         // Skip list should point to us
1144                         //
1145                         //ASSERT(pSkipEntries[i] == &pExtent->Lists[i]);
1146                         //
1147                         // Move forward cursor
1148                         //
1149                         pSkipEntries[i] = pSkipEntries[i]->Flink;
1150                         //
1151                         // Check sanity before
1152                         //
1153 #if AFS_VALIDATE_EXTENTS
1154                         VerifyExtentsLists(Fcb);
1155 #endif
1156                     }
1157                 }
1158
1159                 //
1160                 // And then the cursor in the supplied array
1161                 //
1162
1163                 pFileExtents++;
1164
1165                 //
1166                 // setup pExtent if there is one
1167                 //
1168                 if (le->Flink != &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
1169                 {
1170                     pExtent = NextExtent( pExtent, AFS_EXTENTS_LIST ) ;
1171                 }
1172                 else
1173                 {
1174                     pExtent = NULL;
1175                 }
1176             }
1177             else
1178             {
1179
1180                 ASSERT( pExtent->FileOffset.QuadPart < pFileExtents->FileOffset.QuadPart );
1181
1182                 //
1183                 // Sanity check on spanning
1184                 //
1185                 if ((pExtent->FileOffset.QuadPart + pExtent->Size) >
1186                     pFileExtents->FileOffset.QuadPart)
1187                 {
1188
1189                     ASSERT( (pExtent->FileOffset.QuadPart + pExtent->Size) <=
1190                             pFileExtents->FileOffset.QuadPart);
1191
1192                     try_return (ntStatus = STATUS_INVALID_PARAMETER);
1193                 }
1194
1195                 //
1196                 // Move le and pExtent forward
1197                 //
1198                 le = &pExtent->Lists[AFS_EXTENTS_LIST];
1199
1200                 /*
1201                 //
1202                 // Then the check the skip lists cursors
1203                 //
1204                 for (ULONG i = AFS_NUM_EXTENT_LISTS-1; i > AFS_EXTENTS_LIST; i--)
1205                 {
1206                     if (0 == (pFileExtents->FileOffset.LowPart & ExtentsMasks[i]))
1207                     {
1208                         //
1209                         // Three options:
1210                         //    - empty list (pSkipEntries[i]->Flink == pSkipEntries[i]->Flink == fcb->lists[i]
1211                         //    - We are the last on the list (pSkipEntries[i]->Flink == fcb->lists[i])
1212                         //    - We are not the last on the list.  In that case we have to be strictly less than
1213                         //      that extent.
1214                         if (pSkipEntries[i]->Flink != &Fcb->Specific.File.ExtentsLists[i]) {
1215
1216                             AFSExtent *otherExtent = ExtentFor(pSkipEntries[i]->Flink, i);
1217                             ASSERT(pFileExtents->FileOffset.QuadPart < otherExtent->FileOffset.QuadPart);
1218                         }
1219                     }
1220                 }
1221                 */
1222
1223                 //
1224                 // setup pExtent if there is one
1225                 //
1226
1227                 if (le->Flink != &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
1228                 {
1229                     pExtent = NextExtent( pExtent, AFS_EXTENTS_LIST ) ;
1230                 }
1231                 else
1232                 {
1233                     pExtent = NULL;
1234                 }
1235             }
1236         }
1237
1238         //
1239         // All done, signal that we are done drop the lock, exit
1240         //
1241
1242 try_exit:
1243
1244         if( !NT_SUCCESS( ntStatus))
1245         {
1246
1247             //
1248             // If we failed the service is going to drop all extents so trim away the
1249             // set given to us
1250             //
1251
1252             AFSTrimSpecifiedExtents( Fcb,
1253                                      Count,
1254                                      Result);
1255         }
1256
1257 #if AFS_VALIDATE_EXTENTS
1258         VerifyExtentsLists(Fcb);
1259 #endif
1260
1261         KeSetEvent( &pNPFcb->Specific.File.ExtentsRequestComplete,
1262                     0,
1263                     FALSE);
1264
1265         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1266                       AFS_TRACE_LEVEL_VERBOSE,
1267                       "AFSProcessExtentsResult Releasing Fcb extent lock %08lX EXCL %08lX\n",
1268                       &pNPFcb->Specific.File.ExtentsResource,
1269                       PsGetCurrentThread());
1270
1271         AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
1272     }
1273
1274     return ntStatus;
1275 }
1276
1277 NTSTATUS
1278 AFSProcessSetFileExtents( IN AFSSetFileExtentsCB *SetExtents )
1279 {
1280     AFSFcb       *pFcb = NULL;
1281     AFSVolumeCB  *pVolumeCB = NULL;
1282     NTSTATUS      ntStatus = STATUS_SUCCESS;
1283     AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1284     ULONGLONG     ullIndex = 0;
1285     AFSObjectInfoCB *pObjectInfo = NULL;
1286     LONG          lCount;
1287
1288     __Enter
1289     {
1290
1291         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1292                       AFS_TRACE_LEVEL_VERBOSE,
1293                       "AFSProcessSetFileExtents Acquiring RDR VolumeTreeLock lock %08lX SHARED %08lX\n",
1294                       &pDevExt->Specific.RDR.VolumeTreeLock,
1295                       PsGetCurrentThread());
1296
1297         AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
1298
1299         AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1300                       AFS_TRACE_LEVEL_VERBOSE,
1301                       "AFSProcessSetFileExtents Set extents for fid %08lX-%08lX-%08lX-%08lX\n",
1302                       SetExtents->FileId.Cell,
1303                       SetExtents->FileId.Volume,
1304                       SetExtents->FileId.Vnode,
1305                       SetExtents->FileId.Unique);
1306
1307         //
1308         // Locate the volume node
1309         //
1310
1311         ullIndex = AFSCreateHighIndex( &SetExtents->FileId);
1312
1313         ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
1314                                        ullIndex,
1315                                        (AFSBTreeEntry **)&pVolumeCB);
1316
1317         if( pVolumeCB != NULL)
1318         {
1319
1320             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1321                           AFS_TRACE_LEVEL_VERBOSE,
1322                           "AFSProcessSetFileExtents Acquiring VolumeRoot FileIDTree.TreeLock lock %08lX SHARED %08lX\n",
1323                           pVolumeCB->ObjectInfoTree.TreeLock,
1324                           PsGetCurrentThread());
1325
1326             lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
1327         }
1328
1329         AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
1330
1331         if( !NT_SUCCESS( ntStatus) ||
1332             pVolumeCB == NULL)
1333         {
1334
1335             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1336                           AFS_TRACE_LEVEL_ERROR,
1337                           "AFSProcessSetFileExtents Set extents for fid %08lX-%08lX-%08lX-%08lX Failed to locate volume Status %08lX\n",
1338                           SetExtents->FileId.Cell,
1339                           SetExtents->FileId.Volume,
1340                           SetExtents->FileId.Vnode,
1341                           SetExtents->FileId.Unique,
1342                           ntStatus);
1343
1344             try_return( ntStatus = STATUS_UNSUCCESSFUL);
1345         }
1346
1347         AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
1348                           TRUE);
1349
1350         lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1351
1352         //
1353         // Now locate the Object in this volume
1354         //
1355
1356         ullIndex = AFSCreateLowIndex( &SetExtents->FileId);
1357
1358         ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
1359                                        ullIndex,
1360                                        (AFSBTreeEntry **)&pObjectInfo);
1361
1362         if( pObjectInfo != NULL)
1363         {
1364
1365             //
1366             // Reference the node so it won't be torn down
1367             //
1368
1369             lCount = AFSObjectInfoIncrement( pObjectInfo);
1370
1371             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
1372                           AFS_TRACE_LEVEL_VERBOSE,
1373                           "AFSProcessSetFileExtents Increment count on object %08lX Cnt %d\n",
1374                           pObjectInfo,
1375                           lCount);
1376         }
1377
1378         AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
1379
1380         if( !NT_SUCCESS( ntStatus) ||
1381             pObjectInfo == NULL)
1382         {
1383
1384             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1385                           AFS_TRACE_LEVEL_ERROR,
1386                           "AFSProcessSetFileExtents Set extents for hash %I64X fid %08lX-%08lX-%08lX-%08lX Failed to locate file in volume %08lX\n",
1387                           ullIndex,
1388                           SetExtents->FileId.Cell,
1389                           SetExtents->FileId.Volume,
1390                           SetExtents->FileId.Vnode,
1391                           SetExtents->FileId.Unique,
1392                           pVolumeCB);
1393
1394             try_return( ntStatus = STATUS_UNSUCCESSFUL);
1395         }
1396
1397         pFcb = pObjectInfo->Fcb;
1398
1399         //
1400         // If we have a result failure then don't bother trying to set the extents
1401         //
1402
1403         if( SetExtents->ResultStatus != STATUS_SUCCESS)
1404         {
1405
1406             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1407                           AFS_TRACE_LEVEL_ERROR,
1408                           "AFSProcessSetFileExtents Set extents failure fid %08lX-%08lX-%08lX-%08lX ResultStatus %08lX\n",
1409                           SetExtents->FileId.Cell,
1410                           SetExtents->FileId.Volume,
1411                           SetExtents->FileId.Vnode,
1412                           SetExtents->FileId.Unique,
1413                           SetExtents->ResultStatus);
1414
1415             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1416                           AFS_TRACE_LEVEL_VERBOSE,
1417                           "AFSProcessSetFileExtents Acquiring Fcb extents lock %08lX EXCL %08lX\n",
1418                           &pFcb->NPFcb->Specific.File.ExtentsResource,
1419                           PsGetCurrentThread());
1420
1421             AFSAcquireExcl( &pFcb->NPFcb->Specific.File.ExtentsResource,
1422                             TRUE);
1423
1424             pFcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_CANCELLED;
1425
1426             KeSetEvent( &pFcb->NPFcb->Specific.File.ExtentsRequestComplete,
1427                         0,
1428                         FALSE);
1429
1430             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1431                           AFS_TRACE_LEVEL_VERBOSE,
1432                           "AFSProcessSetFileExtents Releasing Fcb extent lock %08lX EXCL %08lX\n",
1433                           &pFcb->NPFcb->Specific.File.ExtentsResource,
1434                           PsGetCurrentThread());
1435
1436             AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource);
1437
1438             try_return( ntStatus);
1439         }
1440
1441         ntStatus = AFSProcessExtentsResult ( pFcb,
1442                                              SetExtents->ExtentCount,
1443                                              SetExtents->FileExtents );
1444
1445 try_exit:
1446
1447         if( pObjectInfo != NULL)
1448         {
1449
1450             lCount = AFSObjectInfoDecrement( pObjectInfo);
1451
1452             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
1453                           AFS_TRACE_LEVEL_VERBOSE,
1454                           "AFSProcessSetFileExtents Decrement count on object %08lX Cnt %d\n",
1455                           pObjectInfo,
1456                           lCount);
1457         }
1458     }
1459
1460     return ntStatus;
1461 }
1462
1463 //
1464 // Helper fuctions for Usermode initiation of release of extents
1465 //
1466 NTSTATUS
1467 AFSReleaseSpecifiedExtents( IN  AFSReleaseFileExtentsCB *Extents,
1468                             IN  AFSFcb *Fcb,
1469                             OUT AFSFileExtentCB *FileExtents,
1470                             IN  ULONG BufferSize,
1471                             OUT ULONG *ExtentCount,
1472                             OUT BOOLEAN *DirtyExtents)
1473 {
1474     AFSExtent           *pExtent;
1475     LIST_ENTRY          *le;
1476     LIST_ENTRY          *leNext;
1477     ULONG                ulExtentCount = 0;
1478     NTSTATUS             ntStatus = STATUS_SUCCESS;
1479     BOOLEAN              bReleaseAll = FALSE;
1480     AFSDeviceExt        *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
1481     LONG                 lCount;
1482
1483     __Enter
1484     {
1485         ASSERT( ExIsResourceAcquiredExclusiveLite( &Fcb->NPFcb->Specific.File.ExtentsResource));
1486
1487         if (BufferSize < (Extents->ExtentCount * sizeof( AFSFileExtentCB)))
1488         {
1489
1490             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1491                           AFS_TRACE_LEVEL_VERBOSE,
1492                           "AFSReleaseSpecifiedExtents Buffer too small\n");
1493
1494             try_return( ntStatus = STATUS_BUFFER_TOO_SMALL);
1495         }
1496
1497         RtlZeroMemory( FileExtents, BufferSize);
1498         *ExtentCount = 0;
1499
1500         *DirtyExtents = FALSE;
1501
1502         //
1503         // iterate until we have dealt with all we were asked for or
1504         // are at the end of the list.  Note that this deals (albeit
1505         // badly) with out of order extents
1506         //
1507
1508         pExtent = AFSExtentForOffset( Fcb,
1509                                       &Extents->FileExtents[0].FileOffset,
1510                                       FALSE);
1511
1512         if (NULL == pExtent)
1513         {
1514             le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
1515         }
1516         else
1517         {
1518             le = &pExtent->Lists[AFS_EXTENTS_LIST];
1519         }
1520         ulExtentCount = 0;
1521
1522         if( BooleanFlagOn( Extents->Flags, AFS_RELEASE_EXTENTS_FLAGS_RELEASE_ALL) ||
1523             ( Extents->FileId.Cell   == 0 &&
1524               Extents->FileId.Volume == 0 &&
1525               Extents->FileId.Vnode  == 0 &&
1526               Extents->FileId.Unique == 0))
1527         {
1528
1529             bReleaseAll = TRUE;
1530         }
1531
1532         while( le != &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST] &&
1533                ulExtentCount < Extents->ExtentCount)
1534
1535         {
1536
1537             pExtent = ExtentFor( le, AFS_EXTENTS_LIST);
1538
1539             if( !bReleaseAll)
1540             {
1541
1542                 if( pExtent->FileOffset.QuadPart < Extents->FileExtents[ulExtentCount].FileOffset.QuadPart)
1543                 {
1544                     //
1545                     // Skip forward through the extent list until we get
1546                     // to the one we want
1547                     //
1548                     le = le->Flink;
1549
1550                     continue;
1551                 }
1552                 else if (pExtent->FileOffset.QuadPart > Extents->FileExtents[ulExtentCount].FileOffset.QuadPart)
1553                 {
1554                     //
1555                     // We don't have the extent asked for so return UNKNOWN
1556                     //
1557
1558                     AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1559                                   AFS_TRACE_LEVEL_VERBOSE,
1560                                   "AFSReleaseSpecifiedExtents Located UNKNOWN extent Offset %I64X Len %08lX\n",
1561                                   Extents->FileExtents[ulExtentCount].FileOffset.QuadPart,
1562                                   Extents->FileExtents[ulExtentCount].Length);
1563
1564                     FileExtents[*ExtentCount].Flags = AFS_EXTENT_FLAG_UNKNOWN;
1565
1566                     FileExtents[*ExtentCount].Length = 0;
1567                     FileExtents[*ExtentCount].CacheOffset.QuadPart = 0;
1568                     FileExtents[*ExtentCount].FileOffset = Extents->FileExtents[ulExtentCount].FileOffset;
1569
1570                     *ExtentCount = (*ExtentCount) + 1;
1571
1572                     ulExtentCount++;
1573
1574                     //
1575                     // Reset where we are looking
1576                     //
1577
1578                     le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
1579
1580                     continue;
1581                 }
1582                 else if( pExtent->ActiveCount > 0)
1583                 {
1584
1585                     AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1586                                   AFS_TRACE_LEVEL_VERBOSE,
1587                                   "AFSReleaseSpecifiedExtents Located IN_USE extent Offset %I64X Len %08lX\n",
1588                                   Extents->FileExtents[ulExtentCount].FileOffset.QuadPart,
1589                                   Extents->FileExtents[ulExtentCount].Length);
1590
1591                     FileExtents[*ExtentCount].Flags = AFS_EXTENT_FLAG_IN_USE;
1592
1593                     FileExtents[*ExtentCount].Length = 0;
1594                     FileExtents[*ExtentCount].CacheOffset.QuadPart = 0;
1595                     FileExtents[*ExtentCount].FileOffset = Extents->FileExtents[ulExtentCount].FileOffset;
1596
1597                     *ExtentCount = (*ExtentCount) + 1;
1598
1599                     ulExtentCount++;
1600
1601                     //
1602                     // Reset where we are looking
1603                     //
1604
1605                     le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
1606
1607                     continue;
1608                 }
1609             }
1610             else
1611             {
1612
1613                 //
1614                 // If the extent is currently active then skip it
1615                 //
1616
1617                 if( pExtent->ActiveCount > 0)
1618                 {
1619
1620                     le = le->Flink;
1621
1622                     continue;
1623                 }
1624             }
1625
1626             FileExtents[*ExtentCount].Flags = AFS_EXTENT_FLAG_RELEASE;
1627
1628             FileExtents[*ExtentCount].Length = pExtent->Size;
1629             FileExtents[*ExtentCount].DirtyLength = pExtent->Size;
1630             FileExtents[*ExtentCount].DirtyOffset = 0;
1631             FileExtents[*ExtentCount].CacheOffset = pExtent->CacheOffset;
1632             FileExtents[*ExtentCount].FileOffset = pExtent->FileOffset;
1633
1634             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
1635                           AFS_TRACE_LEVEL_VERBOSE,
1636                           "AFSReleaseSpecifiedExtents Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %I64X Len %08lX\n",
1637                           pExtent,
1638                           Fcb->ObjectInformation->FileId.Cell,
1639                           Fcb->ObjectInformation->FileId.Volume,
1640                           Fcb->ObjectInformation->FileId.Vnode,
1641                           Fcb->ObjectInformation->FileId.Unique,
1642                           FileExtents[*ExtentCount].FileOffset.QuadPart,
1643                           FileExtents[*ExtentCount].Length);
1644
1645             if( BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
1646             {
1647
1648                 AFSAcquireExcl( &Fcb->NPFcb->Specific.File.DirtyExtentsListLock,
1649                                 TRUE);
1650
1651                 if( BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
1652                 {
1653
1654                     AFSRemoveEntryDirtyList( Fcb,
1655                                              pExtent);
1656
1657                     FileExtents[*ExtentCount].Flags |= AFS_EXTENT_FLAG_DIRTY;
1658
1659                     lCount = InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
1660
1661                     *DirtyExtents = TRUE;
1662                 }
1663
1664                 AFSReleaseResource( &Fcb->NPFcb->Specific.File.DirtyExtentsListLock);
1665             }
1666
1667             //
1668             // move forward all three cursors
1669             //
1670             le = le->Flink;
1671             ulExtentCount ++;
1672             *ExtentCount = (*ExtentCount) + 1;
1673
1674             AFSFreeExtent( Fcb,
1675                            pExtent);
1676         }
1677
1678 try_exit:
1679
1680         NOTHING;
1681     }
1682
1683     return ntStatus;
1684 }
1685
1686 AFSFcb*
1687 AFSFindFcbToClean(ULONG IgnoreTime, AFSFcb *LastFcb, BOOLEAN Block)
1688 {
1689
1690     AFSFcb *pFcb = NULL;
1691     AFSVolumeCB *pVolumeCB = NULL;
1692     AFSDeviceExt *pRDRDeviceExt = NULL;
1693     AFSDeviceExt *pControlDeviceExt = NULL;
1694     BOOLEAN bLocatedEntry = FALSE;
1695     AFSObjectInfoCB *pCurrentObject = NULL;
1696     BOOLEAN bReleaseVolumeListLock = FALSE;
1697     LONG lCount;
1698
1699     pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1700     pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
1701
1702     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1703                   AFS_TRACE_LEVEL_VERBOSE,
1704                   "AFSFindFcbToClean Acquiring RDR VolumeListLock lock %08lX SHARED %08lX\n",
1705                   &pRDRDeviceExt->Specific.RDR.VolumeListLock,
1706                   PsGetCurrentThread());
1707
1708     AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
1709                       TRUE);
1710
1711     bReleaseVolumeListLock = TRUE;
1712
1713     pVolumeCB = pRDRDeviceExt->Specific.RDR.VolumeListHead;
1714
1715     while( pVolumeCB != NULL)
1716     {
1717
1718         //
1719         // The Volume list may move under our feet.  Lock it.
1720         //
1721
1722         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1723                       AFS_TRACE_LEVEL_VERBOSE,
1724                       "AFSFindFcbToClean Acquiring VolumeRoot ObjectInfoTree lock %08lX SHARED %08lX\n",
1725                       pVolumeCB->ObjectInfoTree.TreeLock,
1726                       PsGetCurrentThread());
1727
1728         lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
1729
1730         AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
1731
1732         bReleaseVolumeListLock = FALSE;
1733
1734         AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
1735                           TRUE);
1736
1737         lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1738
1739         if( NULL == LastFcb)
1740         {
1741
1742             pCurrentObject = pVolumeCB->ObjectInfoListHead;
1743         }
1744         else
1745         {
1746
1747             pCurrentObject = (AFSObjectInfoCB *)LastFcb->ObjectInformation->ListEntry.fLink;
1748         }
1749
1750         pFcb = NULL;
1751
1752         while( pCurrentObject != NULL)
1753         {
1754
1755             pFcb = (AFSFcb *)pCurrentObject->Fcb;
1756
1757             //
1758             // If the FCB is a candidate we try to lock it (but without waiting - which
1759             // means we are deadlock free
1760             //
1761
1762             if( pFcb != NULL &&
1763                 pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
1764             {
1765
1766                 if( Block)
1767                 {
1768
1769                     AFSLockForExtentsTrim( pFcb);
1770                 }
1771                 else
1772                 {
1773
1774                     if( !AFSLockForExtentsTrimNoWait( pFcb))
1775                     {
1776
1777                         pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
1778
1779                         pFcb = NULL;
1780
1781                         continue;
1782                     }
1783                 }
1784
1785                 //
1786                 // Need to be sure there are no current flushes in the queue
1787                 //
1788
1789                 if( pFcb->Specific.File.ExtentCount == 0)
1790                 {
1791
1792                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1793                                   AFS_TRACE_LEVEL_VERBOSE,
1794                                   "AFSFindFcbToClean Releasing Fcb extent lock %08lX thread %08lX\n",
1795                                   &pFcb->NPFcb->Specific.File.ExtentsResource,
1796                                   PsGetCurrentThread());
1797
1798                     AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource);
1799
1800                     pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
1801
1802                     pFcb = NULL;
1803
1804                     continue;
1805                 }
1806
1807                 if( pFcb->Specific.File.QueuedFlushCount > 0)
1808                 {
1809
1810                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1811                                   AFS_TRACE_LEVEL_VERBOSE,
1812                                   "AFSFindFcbToClean Releasing Fcb extent lock %08lX thread %08lX\n",
1813                                   &pFcb->NPFcb->Specific.File.ExtentsResource,
1814                                   PsGetCurrentThread());
1815
1816                     AFSReleaseResource(&pFcb->NPFcb->Specific.File.ExtentsResource);
1817
1818                     if( Block)
1819                     {
1820                         AFSWaitOnQueuedFlushes( pFcb);
1821                     }
1822                     else
1823                     {
1824
1825                         pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
1826                     }
1827
1828                     pFcb = NULL;
1829
1830                     continue;
1831                 }
1832
1833                 if( pFcb->OpenHandleCount > 0)
1834                 {
1835
1836                     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1837                                   AFS_TRACE_LEVEL_VERBOSE,
1838                                   "AFSFindFcbToClean Releasing Fcb extent lock %08lX thread %08lX\n",
1839                                   &pFcb->NPFcb->Specific.File.ExtentsResource,
1840                                   PsGetCurrentThread());
1841
1842                     AFSReleaseResource(&pFcb->NPFcb->Specific.File.ExtentsResource);
1843
1844                     pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
1845
1846                     pFcb = NULL;
1847
1848                     continue;
1849                 }
1850
1851                 //
1852                 // A hit a very palpable hit.  Pin it
1853                 //
1854
1855                 lCount = AFSObjectInfoIncrement( pCurrentObject);
1856
1857                 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
1858                               AFS_TRACE_LEVEL_VERBOSE,
1859                               "AFSFindFcbToClean Increment count on Fcb %08lX Cnt %d\n",
1860                               pCurrentObject,
1861                               lCount);
1862
1863                 bLocatedEntry = TRUE;
1864
1865                 break;
1866             }
1867
1868             pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
1869
1870             pFcb = NULL;
1871         }
1872
1873         AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
1874
1875         if( bLocatedEntry)
1876         {
1877             break;
1878         }
1879
1880         AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
1881                           TRUE);
1882
1883         bReleaseVolumeListLock = TRUE;
1884
1885         pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
1886     }
1887
1888     if( bReleaseVolumeListLock)
1889     {
1890
1891         AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
1892     }
1893
1894     return pFcb;
1895 }
1896
1897 NTSTATUS
1898 AFSProcessExtentFailure( PIRP Irp)
1899 {
1900     AFSExtentFailureCB                *pFailureCB = NULL;
1901     NTSTATUS                           ntStatus = STATUS_SUCCESS;
1902     AFSDeviceExt                      *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
1903     PIO_STACK_LOCATION                 pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1904     AFSVolumeCB                       *pVolumeCB = NULL;
1905     ULONGLONG                          ullIndex = 0;
1906     AFSObjectInfoCB                   *pObjectInfo = NULL;
1907     LONG                               lCount;
1908
1909     __Enter
1910     {
1911         if( pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSExtentFailureCB))
1912         {
1913
1914             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1915                           AFS_TRACE_LEVEL_ERROR,
1916                           "AFSProcessExtentFailure Input buffer too small\n");
1917
1918             try_return( ntStatus = STATUS_INVALID_PARAMETER);
1919         }
1920
1921         pFailureCB = (AFSExtentFailureCB *)Irp->AssociatedIrp.SystemBuffer;
1922
1923         AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1924                       AFS_TRACE_LEVEL_ERROR,
1925                       "AFSProcessExtentFailure Service Reports Failure fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
1926                       pFailureCB->FileId.Cell,
1927                       pFailureCB->FileId.Volume,
1928                       pFailureCB->FileId.Vnode,
1929                       pFailureCB->FileId.Unique,
1930                       pFailureCB->FailureStatus);
1931
1932         AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
1933
1934         //
1935         // Locate the volume node
1936         //
1937
1938         ullIndex = AFSCreateHighIndex( &pFailureCB->FileId);
1939
1940         ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
1941                                        ullIndex,
1942                                        (AFSBTreeEntry **)&pVolumeCB);
1943
1944         if( pVolumeCB != NULL)
1945         {
1946
1947             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1948                           AFS_TRACE_LEVEL_VERBOSE,
1949                           "AFSProcessExtentFailure Acquiring VolumeRoot FileIDTree.TreeLock lock %08lX SHARED %08lX\n",
1950                           pVolumeCB->ObjectInfoTree.TreeLock,
1951                           PsGetCurrentThread());
1952
1953             lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
1954         }
1955
1956         AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
1957
1958         if( !NT_SUCCESS( ntStatus) ||
1959             pVolumeCB == NULL)
1960         {
1961
1962             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1963                           AFS_TRACE_LEVEL_ERROR,
1964                           "AFSProcessExtentFailure Invalid volume index %I64X status %08X\n",
1965                           ullIndex, ntStatus);
1966
1967             try_return( ntStatus = STATUS_UNSUCCESSFUL);
1968         }
1969
1970         AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
1971                           TRUE);
1972
1973         lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
1974
1975         //
1976         // Now locate the Object in this volume
1977         //
1978
1979         ullIndex = AFSCreateLowIndex( &pFailureCB->FileId);
1980
1981         ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
1982                                        ullIndex,
1983                                        (AFSBTreeEntry **)&pObjectInfo);
1984
1985         if( pObjectInfo != NULL &&
1986             pObjectInfo->Fcb != NULL)
1987         {
1988
1989             //
1990             // Reference the node so it won't be torn down
1991             //
1992
1993             lCount = AFSObjectInfoIncrement( pObjectInfo);
1994
1995             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
1996                           AFS_TRACE_LEVEL_VERBOSE,
1997                           "AFSProcessExtentFailure Increment count on object %08lX Cnt %d\n",
1998                           pObjectInfo,
1999                           lCount);
2000         }
2001
2002         AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
2003
2004         if( !NT_SUCCESS( ntStatus) ||
2005             pObjectInfo == NULL ||
2006             pObjectInfo->Fcb == NULL)
2007         {
2008
2009             if( pObjectInfo == NULL)
2010             {
2011                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2012                               AFS_TRACE_LEVEL_ERROR,
2013                               "AFSProcessExtentFailure Invalid file index %I64X\n",
2014                               ullIndex);
2015             }
2016             else
2017             {
2018                 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2019                               AFS_TRACE_LEVEL_ERROR,
2020                               "AFSProcessExtentFailure Fcb dealocated for %I64X\n",
2021                               ullIndex);
2022             }
2023
2024             try_return( ntStatus = STATUS_UNSUCCESSFUL);
2025         }
2026
2027         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2028                       AFS_TRACE_LEVEL_VERBOSE,
2029                       "AFSProcessExtentFailure Acquiring Fcb extent lock %08lX EXCL %08lX\n",
2030                       &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
2031                       PsGetCurrentThread());
2032
2033         AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
2034                         TRUE);
2035
2036         pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestStatus = pFailureCB->FailureStatus;
2037
2038         RtlCopyMemory( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
2039                        &pFailureCB->AuthGroup,
2040                        sizeof( GUID));
2041
2042         KeSetEvent( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestComplete,
2043                     0,
2044                     FALSE);
2045
2046         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2047                       AFS_TRACE_LEVEL_VERBOSE,
2048                       "AFSProcessExtentFailure Releasing Fcb extent lock %08lX EXCL %08lX\n",
2049                       &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
2050                       PsGetCurrentThread());
2051
2052         AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource);
2053
2054         lCount = AFSObjectInfoDecrement( pObjectInfo);
2055
2056         AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2057                       AFS_TRACE_LEVEL_VERBOSE,
2058                       "AFSProcessExtentFailure Decrement count on object %08lX Cnt %d\n",
2059                       pObjectInfo,
2060                       lCount);
2061
2062 try_exit:
2063
2064         NOTHING;
2065     }
2066
2067     return ntStatus;
2068 }
2069
2070 NTSTATUS
2071 AFSProcessReleaseFileExtents( IN PIRP Irp)
2072 {
2073     NTSTATUS                           ntStatus = STATUS_SUCCESS;
2074     PIO_STACK_LOCATION                 pIrpSp = IoGetCurrentIrpStackLocation( Irp);
2075     PFILE_OBJECT                       pFileObject = pIrpSp->FileObject;
2076     AFSFcb                            *pFcb = NULL;
2077     AFSVolumeCB                       *pVolumeCB = NULL;
2078     AFSDeviceExt                      *pDevExt;
2079     AFSReleaseFileExtentsCB           *pExtents;
2080     AFSReleaseFileExtentsResultCB     *pResult = NULL;
2081     AFSReleaseFileExtentsResultFileCB *pFile = NULL;
2082     ULONG                              ulSz = 0;
2083     ULONGLONG                          ullIndex = 0;
2084     AFSObjectInfoCB                   *pObjectInfo = NULL;
2085     BOOLEAN                            bLocked = FALSE;
2086     BOOLEAN                            bDirtyExtents = FALSE;
2087     GUID                               stAuthGroup;
2088     LONG                               lCount;
2089
2090     __Enter
2091     {
2092
2093         pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
2094
2095         pExtents = (AFSReleaseFileExtentsCB*) Irp->AssociatedIrp.SystemBuffer;
2096
2097         if( pIrpSp->Parameters.DeviceIoControl.InputBufferLength <
2098                                             sizeof( AFSReleaseFileExtentsCB))
2099         {
2100
2101             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2102                           AFS_TRACE_LEVEL_ERROR,
2103                           "AFSProcessReleaseFileExtents INPUT Buffer too small\n");
2104
2105             try_return( ntStatus = STATUS_INVALID_PARAMETER );
2106         }
2107
2108         if ( pIrpSp->Parameters.DeviceIoControl.OutputBufferLength <
2109                                         sizeof(AFSReleaseFileExtentsResultCB))
2110         {
2111
2112             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2113                           AFS_TRACE_LEVEL_ERROR,
2114                           "AFSProcessReleaseFileExtents OUTPUT Buffer too small [1]\n");
2115
2116             //
2117             // Must have space for one extent in one file
2118             //
2119
2120             try_return( ntStatus = STATUS_BUFFER_TOO_SMALL);
2121         }
2122
2123         if (pExtents->ExtentCount == 0)
2124         {
2125
2126             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2127                           AFS_TRACE_LEVEL_ERROR,
2128                           "AFSProcessReleaseFileExtents Extent count zero\n");
2129
2130             try_return( ntStatus = STATUS_INVALID_PARAMETER);
2131         }
2132
2133         if (pExtents->FileId.Cell   != 0 ||
2134             pExtents->FileId.Volume != 0 ||
2135             pExtents->FileId.Vnode  != 0 ||
2136             pExtents->FileId.Unique != 0)
2137         {
2138
2139             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2140                           AFS_TRACE_LEVEL_VERBOSE,
2141                           "AFSProcessReleaseFileExtents Processing FID %08lX:%08lX:%08lX:%08lX\n",
2142                           pExtents->FileId.Cell,
2143                           pExtents->FileId.Volume,
2144                           pExtents->FileId.Vnode,
2145                           pExtents->FileId.Unique);
2146
2147             if( pIrpSp->Parameters.DeviceIoControl.InputBufferLength <
2148                             ( FIELD_OFFSET( AFSReleaseFileExtentsCB, ExtentCount) + sizeof(ULONG)) ||
2149                 pIrpSp->Parameters.DeviceIoControl.InputBufferLength <
2150                             ( FIELD_OFFSET( AFSReleaseFileExtentsCB, ExtentCount) + sizeof(ULONG) +
2151                                                             sizeof (AFSFileExtentCB) * pExtents->ExtentCount))
2152             {
2153
2154                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2155                               AFS_TRACE_LEVEL_ERROR,
2156                               "AFSProcessReleaseFileExtents Buffer too small for FID %08lX:%08lx:%08lX:%08lX\n",
2157                               pExtents->FileId.Cell,
2158                               pExtents->FileId.Volume,
2159                               pExtents->FileId.Vnode,
2160                               pExtents->FileId.Unique);
2161
2162                 try_return( ntStatus = STATUS_INVALID_PARAMETER );
2163             }
2164
2165             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2166                           AFS_TRACE_LEVEL_VERBOSE,
2167                           "AFSProcessReleaseFileExtents Acquiring RDR VolumeTreeLock lock %08lX SHARED %08lX\n",
2168                           &pDevExt->Specific.RDR.VolumeTreeLock,
2169                           PsGetCurrentThread());
2170
2171             AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
2172
2173             //
2174             // Locate the volume node
2175             //
2176
2177             ullIndex = AFSCreateHighIndex( &pExtents->FileId);
2178
2179             ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
2180                                            ullIndex,
2181                                            (AFSBTreeEntry **)&pVolumeCB);
2182
2183             if( pVolumeCB != NULL)
2184             {
2185
2186                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2187                               AFS_TRACE_LEVEL_VERBOSE,
2188                               "AFSProcessReleaseFileExtents Acquiring VolumeRoot FileIDTree.TreeLock lock %08lX SHARED %08lX\n",
2189                               pVolumeCB->ObjectInfoTree.TreeLock,
2190                               PsGetCurrentThread());
2191
2192                 lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
2193             }
2194
2195             AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
2196
2197             if( !NT_SUCCESS( ntStatus) ||
2198                 pVolumeCB == NULL)
2199             {
2200
2201                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2202                               AFS_TRACE_LEVEL_ERROR,
2203                               "AFSProcessReleaseFileExtents Invalid volume index %I64X status %08X\n",
2204                               ullIndex, ntStatus);
2205
2206                 try_return( ntStatus = STATUS_UNSUCCESSFUL);
2207             }
2208
2209             AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
2210                               TRUE);
2211
2212             lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
2213
2214             //
2215             // Now locate the Object in this volume
2216             //
2217
2218             ullIndex = AFSCreateLowIndex( &pExtents->FileId);
2219
2220             ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
2221                                            ullIndex,
2222                                            (AFSBTreeEntry **)&pObjectInfo);
2223
2224             if( pObjectInfo != NULL)
2225             {
2226
2227                 //
2228                 // Reference the node so it won't be torn down
2229                 //
2230
2231                 lCount = AFSObjectInfoIncrement( pObjectInfo);
2232
2233                 AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2234                               AFS_TRACE_LEVEL_VERBOSE,
2235                               "AFSProcessReleaseFileExtents Increment count on object %08lX Cnt %d\n",
2236                               pObjectInfo,
2237                               lCount);
2238             }
2239
2240             AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
2241
2242             if( !NT_SUCCESS( ntStatus) ||
2243                 pObjectInfo == NULL)
2244             {
2245
2246                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2247                               AFS_TRACE_LEVEL_ERROR,
2248                               "AFSProcessReleaseFileExtents Invalid file index %I64X\n",
2249                               ullIndex);
2250
2251                 try_return( ntStatus = STATUS_UNSUCCESSFUL);
2252             }
2253
2254             pFcb = pObjectInfo->Fcb;
2255
2256             if( pFcb == NULL)
2257             {
2258
2259                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2260                               AFS_TRACE_LEVEL_ERROR,
2261                               "AFSProcessReleaseFileExtents Fcb not initialied (NO EXTENTS) for FID %08lX:%08lx:%08lX:%08lX\n",
2262                               pExtents->FileId.Cell,
2263                               pExtents->FileId.Volume,
2264                               pExtents->FileId.Vnode,
2265                               pExtents->FileId.Unique);
2266
2267                 try_return( ntStatus = STATUS_UNSUCCESSFUL);
2268             }
2269
2270             AFSLockForExtentsTrim( pFcb );
2271
2272             bLocked = TRUE;
2273         }
2274         else
2275         {
2276
2277             //
2278             // Locate an Fcb to trim down
2279             //
2280
2281             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2282                           AFS_TRACE_LEVEL_VERBOSE,
2283                           "AFSProcessReleaseFileExtents Searching for a Fcb to Trim Down\n");
2284
2285             pFcb = AFSFindFcbToClean( 0, NULL, FALSE);
2286
2287             if( pFcb == NULL)
2288             {
2289
2290                 pFcb = AFSFindFcbToClean( 0, NULL, TRUE);
2291             }
2292
2293             if( pFcb == NULL)
2294             {
2295
2296                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2297                               AFS_TRACE_LEVEL_ERROR,
2298                               "AFSProcessReleaseFileExtents Failed to locate Fcb for release ...\n");
2299
2300                 try_return( ntStatus = STATUS_UNSUCCESSFUL);
2301             }
2302
2303             pObjectInfo = pFcb->ObjectInformation;
2304
2305             bLocked = TRUE;
2306         }
2307
2308         //
2309         // Allocate a scratch buffer to move in the extent information
2310         //
2311
2312         ulSz = (pExtents->ExtentCount-1) * sizeof(AFSFileExtentCB);
2313         ulSz += sizeof(AFSReleaseFileExtentsResultCB);
2314
2315         if (ulSz > pIrpSp->Parameters.DeviceIoControl.OutputBufferLength)
2316         {
2317             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2318                           AFS_TRACE_LEVEL_ERROR,
2319                           "AFSProcessReleaseFileExtents OUTPUT Buffer too small [2]\n");
2320
2321             try_return( ntStatus = STATUS_BUFFER_TOO_SMALL );
2322         }
2323
2324         pResult = (AFSReleaseFileExtentsResultCB*) AFSExAllocatePoolWithTag( PagedPool,
2325                                                                              ulSz,
2326                                                                              AFS_EXTENTS_RESULT_TAG);
2327         if (NULL == pResult)
2328         {
2329
2330             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
2331                           AFS_TRACE_LEVEL_ERROR,
2332                           "AFSProcessReleaseFileExtents Failed to allocate result block\n");
2333
2334             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
2335         }
2336
2337         //
2338         // Set up the header (for an array of one)
2339         //
2340         pResult->FileCount = 1;
2341         pResult->Flags = AFS_EXTENT_FLAG_RELEASE;
2342         ulSz -= FIELD_OFFSET(AFSReleaseFileExtentsResultCB, Files);
2343
2344         //
2345         // Setup the first (and only) file
2346         //
2347         pFile = pResult->Files;
2348         pFile->FileId = pObjectInfo->FileId;
2349         pFile->Flags = AFS_EXTENT_FLAG_RELEASE;
2350
2351         //
2352         // Stash away the auth group
2353         //
2354
2355         RtlZeroMemory( &stAuthGroup,
2356                        sizeof( GUID));
2357
2358         ntStatus = AFSRetrieveValidAuthGroup( pFcb,
2359                                               NULL,
2360                                               TRUE,
2361                                               &stAuthGroup);
2362
2363         if( !NT_SUCCESS( ntStatus))
2364         {
2365             try_return( ntStatus);
2366         }
2367
2368         RtlCopyMemory( &pFile->AuthGroup,
2369                        &stAuthGroup,
2370                        sizeof( GUID));
2371
2372         //
2373         // Update the metadata for this call
2374         //
2375
2376         pFile->AllocationSize = pFcb->ObjectInformation->EndOfFile;
2377         pFile->CreateTime = pFcb->ObjectInformation->CreationTime;
2378         pFile->ChangeTime = pFcb->ObjectInformation->ChangeTime;
2379         pFile->LastAccessTime = pFcb->ObjectInformation->LastAccessTime;
2380         pFile->LastWriteTime = pFcb->ObjectInformation->LastWriteTime;
2381
2382         ulSz -= FIELD_OFFSET(AFSReleaseFileExtentsResultFileCB, FileExtents);
2383
2384         ntStatus = AFSReleaseSpecifiedExtents( pExtents,
2385                                                pFcb,
2386                                                pFile->FileExtents,
2387                                                ulSz,
2388                                                &pFile->ExtentCount,
2389                                                &bDirtyExtents);
2390
2391         if (!NT_SUCCESS(ntStatus))
2392         {
2393
2394             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2395                           AFS_TRACE_LEVEL_ERROR,
2396                           "AFSProcessReleaseFileExtents Failed to release extents Status %08lX\n",
2397                           ntStatus);
2398
2399             try_return( ntStatus );
2400         }
2401
2402         if( pExtents->ExtentCount == 0)
2403         {
2404
2405             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2406                           AFS_TRACE_LEVEL_WARNING,
2407                           "AFSProcessReleaseFileExtents Failed to release ANY extents\n");
2408         }
2409
2410         ulSz = sizeof(AFSReleaseFileExtentsResultCB);
2411
2412         if( pExtents->ExtentCount > 0)
2413         {
2414             ulSz += ((pExtents->ExtentCount-1) * sizeof(AFSFileExtentCB));
2415         }
2416
2417         RtlCopyMemory( Irp->AssociatedIrp.SystemBuffer,
2418                        pResult,
2419                        ulSz);
2420
2421 try_exit:
2422
2423         if( bLocked)
2424         {
2425
2426             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2427                           AFS_TRACE_LEVEL_VERBOSE,
2428                           "AFSProcessReleaseFileExtents Releasing Fcb extent lock %08lX thread %08lX\n",
2429                           &pFcb->NPFcb->Specific.File.ExtentsResource,
2430                           PsGetCurrentThread());
2431
2432             AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
2433         }
2434
2435         if( NULL != pResult &&
2436             Irp->AssociatedIrp.SystemBuffer != pResult)
2437         {
2438
2439             AFSExFreePoolWithTag(pResult, AFS_EXTENTS_RESULT_TAG);
2440         }
2441
2442         if (NT_SUCCESS(ntStatus))
2443         {
2444             Irp->IoStatus.Information = ulSz;
2445         }
2446         else
2447         {
2448             Irp->IoStatus.Information = 0;
2449         }
2450
2451         Irp->IoStatus.Status = ntStatus;
2452
2453         if( pObjectInfo != NULL)
2454         {
2455
2456             lCount = AFSObjectInfoDecrement( pObjectInfo);
2457
2458             AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
2459                           AFS_TRACE_LEVEL_VERBOSE,
2460                           "AFSProcessReleaseFileExtents Decrement count on object %08lX Cnt %d\n",
2461                           pObjectInfo,
2462                           lCount);
2463         }
2464     }
2465
2466     return ntStatus;
2467 }
2468
2469 NTSTATUS
2470 AFSWaitForExtentMapping( AFSFcb *Fcb,
2471                          AFSCcb *Ccb)
2472 {
2473     NTSTATUS ntStatus = STATUS_SUCCESS;
2474     LARGE_INTEGER liTimeOut;
2475     ULONGLONG            ullProcessId = (ULONGLONG)PsGetCurrentProcessId();
2476
2477     __Enter
2478     {
2479
2480         ASSERT( !ExIsResourceAcquiredLite( &Fcb->NPFcb->Specific.File.ExtentsResource ));
2481
2482         if (!NT_SUCCESS( Fcb->NPFcb->Specific.File.ExtentsRequestStatus))
2483         {
2484
2485             //
2486             // If this isn't the same authgroup which caused the failure
2487             // then try to request them again
2488             //
2489
2490             if( RtlCompareMemory( &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
2491                                   &Ccb->AuthGroup,
2492                                   sizeof( GUID)) == sizeof( GUID))
2493             {
2494
2495                 ntStatus = Fcb->NPFcb->Specific.File.ExtentsRequestStatus;
2496
2497                 Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
2498
2499                 RtlZeroMemory( &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
2500                                sizeof( GUID));
2501
2502                 try_return( ntStatus);
2503             }
2504         }
2505
2506         liTimeOut.QuadPart = -(1 * AFS_ONE_SECOND);
2507
2508         ntStatus = KeWaitForSingleObject( &Fcb->NPFcb->Specific.File.ExtentsRequestComplete,
2509                                           Executive,
2510                                           KernelMode,
2511                                           FALSE,
2512                                           &liTimeOut);
2513
2514         if (!NT_SUCCESS( Fcb->NPFcb->Specific.File.ExtentsRequestStatus))
2515         {
2516
2517             //
2518             // If this isn't the same authgroup which caused the failure
2519             // or the System Process,
2520             // then try to request the extents again
2521             //
2522
2523             if( RtlCompareMemory( &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
2524                                   &Ccb->AuthGroup,
2525                                   sizeof( GUID)) == sizeof( GUID) ||
2526                 ullProcessId == (ULONGLONG)AFSSysProcess)
2527             {
2528
2529                 ntStatus = Fcb->NPFcb->Specific.File.ExtentsRequestStatus;
2530
2531                 Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
2532
2533                 RtlZeroMemory( &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
2534                                sizeof( GUID));
2535
2536                 try_return( ntStatus);
2537             }
2538         }
2539
2540         if( ntStatus == STATUS_TIMEOUT)
2541         {
2542
2543             ntStatus = STATUS_SUCCESS;
2544         }
2545
2546 try_exit:
2547
2548         NOTHING;
2549     }
2550
2551     return ntStatus;
2552 }
2553
2554 NTSTATUS
2555 AFSFlushExtents( IN AFSFcb *Fcb,
2556                  IN GUID *AuthGroup)
2557 {
2558     AFSNonPagedFcb      *pNPFcb = Fcb->NPFcb;
2559     AFSExtent           *pExtent, *pNextExtent;
2560     LIST_ENTRY          *le;
2561     AFSReleaseExtentsCB *pRelease = NULL;
2562     ULONG                count = 0;
2563     ULONG                initialDirtyCount = 0;
2564     BOOLEAN              bExtentsLocked = FALSE;
2565     ULONG                total = 0;
2566     ULONG                sz = 0;
2567     NTSTATUS             ntStatus = STATUS_SUCCESS;
2568     LARGE_INTEGER        liLastFlush;
2569     AFSExtent           *pDirtyListHead = NULL, *pDirtyListTail = NULL;
2570     AFSDeviceExt        *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
2571     GUID                *pAuthGroup = AuthGroup;
2572     GUID                 stAuthGroup;
2573     LONG                 lCount;
2574
2575     ASSERT( Fcb->Header.NodeTypeCode == AFS_FILE_FCB);
2576
2577     //
2578     // Save, then reset the flush time
2579     //
2580
2581     liLastFlush = Fcb->Specific.File.LastServerFlush;
2582
2583     KeQueryTickCount( &Fcb->Specific.File.LastServerFlush);
2584
2585     __Enter
2586     {
2587
2588         lCount = InterlockedIncrement( &Fcb->Specific.File.QueuedFlushCount);
2589
2590         if( pAuthGroup == NULL ||
2591             RtlCompareMemory( pAuthGroup,
2592                               &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
2593                               sizeof( GUID)) == sizeof( GUID))
2594         {
2595
2596             RtlZeroMemory( &stAuthGroup,
2597                            sizeof( GUID));
2598
2599             ntStatus = AFSRetrieveValidAuthGroup( Fcb,
2600                                                   NULL,
2601                                                   TRUE,
2602                                                   &stAuthGroup);
2603
2604             if( !NT_SUCCESS( ntStatus))
2605             {
2606                 try_return( ntStatus);
2607             }
2608
2609             pAuthGroup = &stAuthGroup;
2610         }
2611
2612         //
2613         // Lock extents while we count and set up the array to send to
2614         // the service
2615         //
2616
2617         AFSLockForExtentsTrim( Fcb);
2618
2619         bExtentsLocked = TRUE;
2620
2621         //
2622         // Clear our queued flush event
2623         //
2624
2625         KeClearEvent( &Fcb->NPFcb->Specific.File.QueuedFlushEvent);
2626
2627         //
2628         // Look for a start in the list to flush entries
2629         //
2630
2631         total = count;
2632
2633         sz = sizeof( AFSReleaseExtentsCB ) + (AFS_MAXIMUM_EXTENT_RELEASE_COUNT * sizeof ( AFSFileExtentCB ));
2634
2635         pRelease = (AFSReleaseExtentsCB*) AFSExAllocatePoolWithTag( NonPagedPool,
2636                                                                     sz,
2637                                                                     AFS_EXTENT_RELEASE_TAG);
2638         if( NULL == pRelease)
2639         {
2640
2641             try_return ( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
2642         }
2643
2644         initialDirtyCount = Fcb->Specific.File.ExtentsDirtyCount;
2645
2646         while( Fcb->Specific.File.ExtentsDirtyCount > 0)
2647         {
2648
2649             pRelease->Flags = AFS_EXTENT_FLAG_DIRTY;
2650
2651             if( BooleanFlagOn( Fcb->Flags, AFS_FCB_FILE_CLOSED))
2652             {
2653
2654                 pRelease->Flags |= AFS_EXTENT_FLAG_FLUSH;
2655             }
2656
2657             //
2658             // Update the metadata for this call
2659             //
2660
2661             pRelease->AllocationSize = Fcb->ObjectInformation->EndOfFile;
2662             pRelease->CreateTime = Fcb->ObjectInformation->CreationTime;
2663             pRelease->ChangeTime = Fcb->ObjectInformation->ChangeTime;
2664             pRelease->LastAccessTime = Fcb->ObjectInformation->LastAccessTime;
2665             pRelease->LastWriteTime = Fcb->ObjectInformation->LastWriteTime;
2666
2667             count = 0;
2668
2669             AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
2670                             TRUE);
2671
2672             pExtent = (AFSExtent *)pNPFcb->Specific.File.DirtyListHead;
2673
2674             while( count < AFS_MAXIMUM_EXTENT_RELEASE_COUNT)
2675             {
2676
2677                 if ( pExtent == NULL)
2678                 {
2679
2680                     break;
2681                 }
2682
2683                 pNextExtent = (AFSExtent *)pExtent->DirtyList.fLink;
2684
2685                 if ( pExtent->ActiveCount > 0)
2686                 {
2687                     pExtent = pNextExtent;
2688                     continue;
2689                 }
2690
2691                 AFSRemoveEntryDirtyList( Fcb, pExtent);
2692
2693                 pExtent->DirtyList.fLink = NULL;
2694                 pExtent->DirtyList.bLink = NULL;
2695
2696                 lCount = InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
2697
2698                 //
2699                 // Clear the flag in advance of the write. If we do
2700                 // things this was we know that the clear is
2701                 // pessimistic (any write which happens from now on
2702                 // will set the flag dirty again).
2703                 //
2704
2705                 pExtent->Flags &= ~AFS_EXTENT_DIRTY;
2706
2707                 pRelease->FileExtents[count].Flags = AFS_EXTENT_FLAG_DIRTY;
2708
2709                 pRelease->FileExtents[count].Length = pExtent->Size;
2710                 pRelease->FileExtents[count].DirtyLength = pExtent->Size;
2711                 pRelease->FileExtents[count].DirtyOffset = 0;
2712                 pRelease->FileExtents[count].CacheOffset = pExtent->CacheOffset;
2713                 pRelease->FileExtents[count].FileOffset = pExtent->FileOffset;
2714
2715 #if GEN_MD5
2716                 RtlCopyMemory( pRelease->FileExtents[count].MD5,
2717                                pExtent->MD5,
2718                                sizeof(pExtent->MD5));
2719
2720                 pRelease->FileExtents[count].Flags |= AFS_EXTENT_FLAG_MD5_SET;
2721 #endif
2722
2723                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2724                               AFS_TRACE_LEVEL_VERBOSE,
2725                               "AFSFlushExtents Releasing DIRTY extent %p fid %08lX-%08lX-%08lX-%08lX Offset %I64X Len %08lX\n",
2726                               pExtent,
2727                               Fcb->ObjectInformation->FileId.Cell,
2728                               Fcb->ObjectInformation->FileId.Volume,
2729                               Fcb->ObjectInformation->FileId.Vnode,
2730                               Fcb->ObjectInformation->FileId.Unique,
2731                               pExtent->FileOffset.QuadPart,
2732                               pExtent->Size);
2733
2734                 pRelease->FileExtents[count].Flags |= AFS_EXTENT_FLAG_RELEASE;
2735
2736                 AFSFreeExtent( Fcb,
2737                                pExtent);
2738
2739                 count ++;
2740
2741                 pExtent = pNextExtent;
2742             }
2743
2744             AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
2745
2746             //
2747             // If we are done then get out
2748             //
2749
2750             if( count == 0)
2751             {
2752
2753                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2754                               AFS_TRACE_LEVEL_VERBOSE,
2755                               "AFSFlushExtents No more dirty extents found\n");
2756
2757                 break;
2758             }
2759
2760             //
2761             // Fire off the request synchronously
2762             //
2763
2764             sz = sizeof( AFSReleaseExtentsCB ) + (count * sizeof ( AFSFileExtentCB ));
2765
2766             pRelease->ExtentCount = count;
2767
2768             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2769                           AFS_TRACE_LEVEL_VERBOSE,
2770                           "AFSFlushExtents Releasing(1) Fcb extents lock %08lX SHARED %08lX\n",
2771                           &pNPFcb->Specific.File.ExtentsResource,
2772                           PsGetCurrentThread());
2773
2774             AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource);
2775             bExtentsLocked = FALSE;
2776
2777             KeSetEvent( &pNPFcb->Specific.File.FlushEvent,
2778                         0,
2779                         FALSE);
2780
2781             ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
2782                                           AFS_REQUEST_FLAG_SYNCHRONOUS,
2783                                           pAuthGroup,
2784                                           NULL,
2785                                           &Fcb->ObjectInformation->FileId,
2786                                           pRelease,
2787                                           sz,
2788                                           NULL,
2789                                           NULL);
2790
2791             if( !NT_SUCCESS(ntStatus))
2792             {
2793
2794                 //
2795                 // Regardless of whether or not the AFSProcessRequest() succeeded, the extents
2796                 // were released (if AFS_EXTENT_FLAG_RELEASE was set).  Log the error so it is known.
2797                 //
2798
2799                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2800                               AFS_TRACE_LEVEL_ERROR,
2801                               "AFSFlushExtents AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
2802                               Fcb->ObjectInformation->FileId.Cell,
2803                               Fcb->ObjectInformation->FileId.Volume,
2804                               Fcb->ObjectInformation->FileId.Vnode,
2805                               Fcb->ObjectInformation->FileId.Unique,
2806                               ntStatus);
2807
2808             }
2809             AFSLockForExtentsTrim( Fcb);
2810
2811             bExtentsLocked = TRUE;
2812         }
2813
2814 try_exit:
2815
2816         lCount = InterlockedDecrement( &Fcb->Specific.File.QueuedFlushCount);
2817
2818         ASSERT( lCount >= 0);
2819
2820         if( lCount == 0)
2821         {
2822
2823             KeSetEvent( &pNPFcb->Specific.File.QueuedFlushEvent,
2824                         0,
2825                         FALSE);
2826         }
2827
2828         KeSetEvent( &pNPFcb->Specific.File.FlushEvent,
2829                     0,
2830                     FALSE);
2831
2832         if (bExtentsLocked)
2833         {
2834
2835             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
2836                           AFS_TRACE_LEVEL_VERBOSE,
2837                           "AFSFlushExtents Releasing(2) Fcb extents lock %08lX SHARED %08lX\n",
2838                           &pNPFcb->Specific.File.ExtentsResource,
2839                           PsGetCurrentThread());
2840
2841             AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
2842         }
2843
2844         if (pRelease)
2845         {
2846             AFSExFreePoolWithTag( pRelease, AFS_EXTENT_RELEASE_TAG);
2847         }
2848     }
2849
2850     return ntStatus;
2851 }
2852
2853 NTSTATUS
2854 AFSReleaseExtentsWithFlush( IN AFSFcb *Fcb,
2855                             IN GUID *AuthGroup,
2856                             IN BOOLEAN bReleaseAll)
2857 {
2858     AFSNonPagedFcb      *pNPFcb = Fcb->NPFcb;
2859     AFSExtent           *pExtent;
2860     LIST_ENTRY          *le;
2861     AFSReleaseExtentsCB *pRelease = NULL;
2862     ULONG                count = 0;
2863     ULONG                initialDirtyCount = 0;
2864     BOOLEAN              bExtentsLocked = FALSE;
2865     ULONG                total = 0;
2866     ULONG                sz = 0;
2867     NTSTATUS             ntStatus = STATUS_SUCCESS;
2868     LARGE_INTEGER        liLastFlush;
2869     ULONG                ulRemainingExtentLength = 0;
2870     AFSDeviceExt        *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
2871     GUID                *pAuthGroup = AuthGroup;
2872     GUID                 stAuthGroup;
2873     LONG                 lCount;
2874
2875     ASSERT( Fcb->Header.NodeTypeCode == AFS_FILE_FCB);
2876
2877     //
2878     // Save, then reset the flush time
2879     //
2880
2881     liLastFlush = Fcb->Specific.File.LastServerFlush;
2882
2883     KeQueryTickCount( &Fcb->Specific.File.LastServerFlush);
2884
2885     __Enter
2886     {
2887
2888         if( pAuthGroup == NULL ||
2889             RtlCompareMemory( pAuthGroup,
2890                               &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
2891                               sizeof( GUID)) == sizeof( GUID))
2892         {
2893
2894             RtlZeroMemory( &stAuthGroup,
2895                            sizeof( GUID));
2896
2897             ntStatus = AFSRetrieveValidAuthGroup( Fcb,
2898                                                   NULL,
2899                                                   TRUE,
2900                                                   &stAuthGroup);
2901
2902             if( !NT_SUCCESS( ntStatus))
2903             {
2904                 try_return( ntStatus);
2905             }
2906
2907             pAuthGroup = &stAuthGroup;
2908         }
2909
2910         //
2911         // Look for a start in the list to flush entries
2912         //
2913
2914         total = count;
2915
2916         sz = sizeof( AFSReleaseExtentsCB ) + (AFS_MAXIMUM_EXTENT_RELEASE_COUNT * sizeof ( AFSFileExtentCB ));
2917
2918         pRelease = (AFSReleaseExtentsCB*) AFSExAllocatePoolWithTag( NonPagedPool,
2919                                                                     sz,
2920                                                                     AFS_EXTENT_RELEASE_TAG);
2921         if( NULL == pRelease)
2922         {
2923
2924             try_return ( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
2925         }
2926
2927         if( Fcb->OpenHandleCount > 0 &&
2928             !bReleaseAll)
2929         {
2930
2931             //
2932             // Don't release everything ...
2933             //
2934
2935             ulRemainingExtentLength = 1024;
2936         }
2937
2938         while( Fcb->Specific.File.ExtentLength > (LONG)ulRemainingExtentLength)
2939         {
2940
2941             AFSLockForExtentsTrim( Fcb);
2942
2943             bExtentsLocked = TRUE;
2944
2945             pRelease->Flags = AFS_EXTENT_FLAG_RELEASE;
2946
2947             //
2948             // Update the metadata for this call
2949             //
2950
2951             pRelease->AllocationSize = Fcb->ObjectInformation->EndOfFile;
2952             pRelease->CreateTime = Fcb->ObjectInformation->CreationTime;
2953             pRelease->ChangeTime = Fcb->ObjectInformation->ChangeTime;
2954             pRelease->LastAccessTime = Fcb->ObjectInformation->LastAccessTime;
2955             pRelease->LastWriteTime = Fcb->ObjectInformation->LastWriteTime;
2956
2957             count = 0;
2958
2959             le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
2960
2961             while( count < AFS_MAXIMUM_EXTENT_RELEASE_COUNT &&
2962                    le != &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
2963             {
2964
2965                 pExtent = ExtentFor( le, AFS_EXTENTS_LIST);
2966
2967                 le = le->Flink;
2968
2969                 if( pExtent->ActiveCount > 0)
2970                 {
2971
2972                     continue;
2973                 }
2974
2975                 pRelease->FileExtents[count].Flags = AFS_EXTENT_FLAG_RELEASE;
2976
2977                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
2978                               AFS_TRACE_LEVEL_VERBOSE,
2979                               "AFSReleaseExtentsWithFlush Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %I64X Len %08lX\n",
2980                               pExtent,
2981                               Fcb->ObjectInformation->FileId.Cell,
2982                               Fcb->ObjectInformation->FileId.Volume,
2983                               Fcb->ObjectInformation->FileId.Vnode,
2984                               Fcb->ObjectInformation->FileId.Unique,
2985                               pExtent->FileOffset.QuadPart,
2986                               pExtent->Size);
2987
2988                 pRelease->FileExtents[count].Length = pExtent->Size;
2989                 pRelease->FileExtents[count].DirtyLength = pExtent->Size;
2990                 pRelease->FileExtents[count].DirtyOffset = 0;
2991                 pRelease->FileExtents[count].CacheOffset = pExtent->CacheOffset;
2992                 pRelease->FileExtents[count].FileOffset = pExtent->FileOffset;
2993
2994 #if GEN_MD5
2995                 RtlCopyMemory( pRelease->FileExtents[count].MD5,
2996                                pExtent->MD5,
2997                                sizeof(pExtent->MD5));
2998
2999                 pRelease->FileExtents[count].Flags |= AFS_EXTENT_FLAG_MD5_SET;
3000 #endif
3001
3002                 if( BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
3003                 {
3004
3005                     AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
3006                                     TRUE);
3007
3008                     if( BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
3009                     {
3010
3011                         AFSRemoveEntryDirtyList( Fcb,
3012                                                  pExtent);
3013
3014                         pRelease->FileExtents[count].Flags |= AFS_EXTENT_FLAG_DIRTY;
3015
3016                         lCount = InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
3017                     }
3018
3019                     AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
3020                 }
3021
3022                 AFSFreeExtent( Fcb,
3023                                pExtent);
3024
3025                 count ++;
3026             }
3027
3028             //
3029             // If we are done then get out
3030             //
3031
3032             if( count == 0)
3033             {
3034
3035                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
3036                               AFS_TRACE_LEVEL_VERBOSE,
3037                               "AFSReleaseExtentsWithFlush No more dirty extents found\n");
3038
3039                 break;
3040             }
3041
3042             //
3043             // Fire off the request synchronously
3044             //
3045
3046             sz = sizeof( AFSReleaseExtentsCB ) + (count * sizeof ( AFSFileExtentCB ));
3047
3048             pRelease->ExtentCount = count;
3049
3050             //
3051             // Drop the extents lock for the duration of the call to
3052             // the network.  We have pinned the extents so, even
3053             // though we might get extents added during this period,
3054             // but none will be removed.  Hence we can carry on from
3055             // le.
3056             //
3057
3058             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3059                           AFS_TRACE_LEVEL_VERBOSE,
3060                           "AFSReleaseExtentsWithFlush Releasing Fcb extents lock %08lX thread %08lX\n",
3061                           &pNPFcb->Specific.File.ExtentsResource,
3062                           PsGetCurrentThread());
3063
3064             AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource);
3065             bExtentsLocked = FALSE;
3066
3067             ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
3068                                           AFS_REQUEST_FLAG_SYNCHRONOUS,
3069                                           pAuthGroup,
3070                                           NULL,
3071                                           &Fcb->ObjectInformation->FileId,
3072                                           pRelease,
3073                                           sz,
3074                                           NULL,
3075                                           NULL);
3076
3077             if( !NT_SUCCESS(ntStatus))
3078             {
3079
3080                 //
3081                 // Regardless of whether or not the AFSProcessRequest() succeeded, the extents
3082                 // were released (if AFS_EXTENT_FLAG_RELEASE was set).  Log the error so it is known.
3083                 //
3084
3085                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
3086                               AFS_TRACE_LEVEL_ERROR,
3087                               "AFSReleaseExtentsWithFlush AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
3088                               Fcb->ObjectInformation->FileId.Cell,
3089                               Fcb->ObjectInformation->FileId.Volume,
3090                               Fcb->ObjectInformation->FileId.Vnode,
3091                               Fcb->ObjectInformation->FileId.Unique,
3092                               ntStatus);
3093             }
3094         }
3095
3096 try_exit:
3097
3098         if (bExtentsLocked)
3099         {
3100
3101             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3102                           AFS_TRACE_LEVEL_VERBOSE,
3103                           "AFSReleaseExtentsWithFlush Releasing Fcb extents lock %08lX thread %08lX\n",
3104                           &pNPFcb->Specific.File.ExtentsResource,
3105                           PsGetCurrentThread());
3106
3107             AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
3108         }
3109
3110         if (pRelease)
3111         {
3112             AFSExFreePoolWithTag( pRelease, AFS_EXTENT_RELEASE_TAG);
3113         }
3114     }
3115
3116     return ntStatus;
3117 }
3118
3119 NTSTATUS
3120 AFSReleaseCleanExtents( IN AFSFcb *Fcb,
3121                         IN GUID *AuthGroup)
3122 {
3123     AFSNonPagedFcb      *pNPFcb = Fcb->NPFcb;
3124     AFSExtent           *pExtent;
3125     LIST_ENTRY          *le;
3126     AFSReleaseExtentsCB *pRelease = NULL;
3127     ULONG                count = 0;
3128     ULONG                initialDirtyCount = 0;
3129     BOOLEAN              bExtentsLocked = FALSE;
3130     ULONG                total = 0;
3131     ULONG                sz = 0;
3132     NTSTATUS             ntStatus = STATUS_SUCCESS;
3133     LARGE_INTEGER        liLastFlush;
3134     ULONG                ulRemainingExtentLength = 0;
3135     AFSDeviceExt        *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
3136     GUID                *pAuthGroup = AuthGroup;
3137     GUID                 stAuthGroup;
3138
3139     ASSERT( Fcb->Header.NodeTypeCode == AFS_FILE_FCB);
3140
3141     //
3142     // Save, then reset the flush time
3143     //
3144
3145     liLastFlush = Fcb->Specific.File.LastServerFlush;
3146
3147     KeQueryTickCount( &Fcb->Specific.File.LastServerFlush);
3148
3149     __Enter
3150     {
3151
3152         if( pAuthGroup == NULL ||
3153             RtlCompareMemory( pAuthGroup,
3154                               &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
3155                               sizeof( GUID)) == sizeof( GUID))
3156         {
3157
3158             RtlZeroMemory( &stAuthGroup,
3159                            sizeof( GUID));
3160
3161             ntStatus = AFSRetrieveValidAuthGroup( Fcb,
3162                                                   NULL,
3163                                                   TRUE,
3164                                                   &stAuthGroup);
3165
3166             if( !NT_SUCCESS( ntStatus))
3167             {
3168                 try_return( ntStatus);
3169             }
3170
3171             pAuthGroup = &stAuthGroup;
3172         }
3173
3174         //
3175         // Look for a start in the list to flush entries
3176         //
3177
3178         total = count;
3179
3180         sz = sizeof( AFSReleaseExtentsCB ) + (AFS_MAXIMUM_EXTENT_RELEASE_COUNT * sizeof ( AFSFileExtentCB ));
3181
3182         pRelease = (AFSReleaseExtentsCB*) AFSExAllocatePoolWithTag( NonPagedPool,
3183                                                                     sz,
3184                                                                     AFS_EXTENT_RELEASE_TAG);
3185         if( NULL == pRelease)
3186         {
3187
3188             try_return ( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
3189         }
3190
3191         while( Fcb->Specific.File.ExtentLength > (LONG)ulRemainingExtentLength)
3192         {
3193
3194             AFSLockForExtentsTrim( Fcb);
3195
3196             bExtentsLocked = TRUE;
3197
3198             pRelease->Flags = AFS_EXTENT_FLAG_RELEASE;
3199
3200             //
3201             // Update the metadata for this call
3202             //
3203
3204             pRelease->AllocationSize = Fcb->ObjectInformation->EndOfFile;
3205             pRelease->CreateTime = Fcb->ObjectInformation->CreationTime;
3206             pRelease->ChangeTime = Fcb->ObjectInformation->ChangeTime;
3207             pRelease->LastAccessTime = Fcb->ObjectInformation->LastAccessTime;
3208             pRelease->LastWriteTime = Fcb->ObjectInformation->LastWriteTime;
3209
3210             count = 0;
3211
3212             le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
3213
3214             while( count < AFS_MAXIMUM_EXTENT_RELEASE_COUNT &&
3215                    le != &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
3216             {
3217
3218                 pExtent = ExtentFor( le, AFS_EXTENTS_LIST);
3219
3220                 le = le->Flink;
3221
3222                 if( pExtent->ActiveCount > 0 ||
3223                     BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
3224                 {
3225                     continue;
3226                 }
3227
3228                 pRelease->FileExtents[count].Flags = AFS_EXTENT_FLAG_RELEASE;
3229
3230                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
3231                               AFS_TRACE_LEVEL_VERBOSE,
3232                               "AFSReleaseCleanExtents Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %I64X Len %08lX\n",
3233                               pExtent,
3234                               Fcb->ObjectInformation->FileId.Cell,
3235                               Fcb->ObjectInformation->FileId.Volume,
3236                               Fcb->ObjectInformation->FileId.Vnode,
3237                               Fcb->ObjectInformation->FileId.Unique,
3238                               pExtent->FileOffset.QuadPart,
3239                               pExtent->Size);
3240
3241                 pRelease->FileExtents[count].Length = pExtent->Size;
3242                 pRelease->FileExtents[count].DirtyLength = pExtent->Size;
3243                 pRelease->FileExtents[count].DirtyOffset = 0;
3244                 pRelease->FileExtents[count].CacheOffset = pExtent->CacheOffset;
3245                 pRelease->FileExtents[count].FileOffset = pExtent->FileOffset;
3246
3247 #if GEN_MD5
3248                 RtlCopyMemory( pRelease->FileExtents[count].MD5,
3249                                pExtent->MD5,
3250                                sizeof(pExtent->MD5));
3251
3252                 pRelease->FileExtents[count].Flags |= AFS_EXTENT_FLAG_MD5_SET;
3253 #endif
3254
3255                 AFSFreeExtent( Fcb,
3256                                pExtent);
3257
3258                 count ++;
3259             }
3260
3261             //
3262             // If we are done then get out
3263             //
3264
3265             if( count == 0)
3266             {
3267
3268                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
3269                               AFS_TRACE_LEVEL_VERBOSE,
3270                               "AFSReleaseCleanExtents No more dirty extents found\n");
3271
3272                 break;
3273             }
3274
3275             //
3276             // Fire off the request synchronously
3277             //
3278
3279             sz = sizeof( AFSReleaseExtentsCB ) + (count * sizeof ( AFSFileExtentCB ));
3280
3281             pRelease->ExtentCount = count;
3282
3283             //
3284             // Drop the extents lock for the duration of the call to
3285             // the network.  We have pinned the extents so, even
3286             // though we might get extents added during this period,
3287             // but none will be removed.  Hence we can carry on from
3288             // le.
3289             //
3290
3291             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3292                           AFS_TRACE_LEVEL_VERBOSE,
3293                           "AFSReleaseCleanExtents Releasing Fcb extents lock %08lX thread %08lX\n",
3294                           &pNPFcb->Specific.File.ExtentsResource,
3295                           PsGetCurrentThread());
3296
3297             AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource);
3298             bExtentsLocked = FALSE;
3299
3300             ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
3301                                           AFS_REQUEST_FLAG_SYNCHRONOUS,
3302                                           pAuthGroup,
3303                                           NULL,
3304                                           &Fcb->ObjectInformation->FileId,
3305                                           pRelease,
3306                                           sz,
3307                                           NULL,
3308                                           NULL);
3309
3310             if( !NT_SUCCESS(ntStatus))
3311             {
3312
3313                 //
3314                 // Regardless of whether or not the AFSProcessRequest() succeeded, the extents
3315                 // were released (if AFS_EXTENT_FLAG_RELEASE was set).  Log the error so it is known.
3316                 //
3317
3318                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
3319                               AFS_TRACE_LEVEL_ERROR,
3320                               "AFSReleaseCleanExtents AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
3321                               Fcb->ObjectInformation->FileId.Cell,
3322                               Fcb->ObjectInformation->FileId.Volume,
3323                               Fcb->ObjectInformation->FileId.Vnode,
3324                               Fcb->ObjectInformation->FileId.Unique,
3325                               ntStatus);
3326             }
3327         }
3328
3329 try_exit:
3330
3331         if (bExtentsLocked)
3332         {
3333
3334             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3335                           AFS_TRACE_LEVEL_VERBOSE,
3336                           "AFSReleaseCleanExtents Releasing Fcb extents lock %08lX thread %08lX\n",
3337                           &pNPFcb->Specific.File.ExtentsResource,
3338                           PsGetCurrentThread());
3339
3340             AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
3341         }
3342
3343         if (pRelease)
3344         {
3345             AFSExFreePoolWithTag( pRelease, AFS_EXTENT_RELEASE_TAG);
3346         }
3347     }
3348
3349     return ntStatus;
3350 }
3351
3352 VOID
3353 AFSMarkDirty( IN AFSFcb *Fcb,
3354               IN AFSExtent *StartExtent,
3355               IN ULONG ExtentsCount,
3356               IN LARGE_INTEGER *StartingByte,
3357               IN BOOLEAN DerefExtents)
3358 {
3359
3360     AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
3361     AFSExtent     *pExtent = StartExtent;
3362     AFSExtent     *pNextExtent, *pCurrentExtent = NULL;
3363     ULONG ulCount = 0;
3364     BOOLEAN bInsertTail = FALSE, bInsertHead = FALSE;
3365     LONG lCount;
3366     BOOLEAN bLocked = FALSE;
3367
3368     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3369                   AFS_TRACE_LEVEL_VERBOSE,
3370                   "AFSMarkDirty Acquiring Fcb extents lock %08lX SHARED %08lX\n",
3371                   &Fcb->NPFcb->Specific.File.ExtentsResource,
3372                   PsGetCurrentThread());
3373
3374     if( !ExIsResourceAcquiredLite( &Fcb->NPFcb->Specific.File.ExtentsResource))
3375     {
3376         AFSAcquireShared( &Fcb->NPFcb->Specific.File.ExtentsResource, TRUE);
3377         bLocked = TRUE;
3378     }
3379
3380     AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
3381                     TRUE);
3382
3383     __try
3384     {
3385         //
3386         // Find the insertion point
3387         //
3388
3389         if( pNPFcb->Specific.File.DirtyListHead == NULL)
3390         {
3391
3392             bInsertTail = TRUE;
3393         }
3394         else if( StartingByte->QuadPart == 0)
3395         {
3396
3397             bInsertHead = TRUE;
3398         }
3399         else
3400         {
3401
3402             pCurrentExtent = pNPFcb->Specific.File.DirtyListHead;
3403
3404             while( pCurrentExtent != NULL)
3405             {
3406
3407                 if( pCurrentExtent->FileOffset.QuadPart + pCurrentExtent->Size >= StartingByte->QuadPart ||
3408                     pCurrentExtent->DirtyList.fLink == NULL)
3409                 {
3410
3411                     break;
3412                 }
3413
3414                 pCurrentExtent = (AFSExtent *)pCurrentExtent->DirtyList.fLink;
3415             }
3416         }
3417
3418         while( ulCount < ExtentsCount)
3419         {
3420
3421             pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
3422
3423             if( !BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
3424             {
3425
3426                 AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
3427                               AFS_TRACE_LEVEL_VERBOSE,
3428                               "AFSMarkDirty Marking extent offset %I64X Length %08lX DIRTY\n",
3429                               pExtent->FileOffset.QuadPart,
3430                               pExtent->Size);
3431
3432                 pExtent->DirtyList.fLink = NULL;
3433                 pExtent->DirtyList.bLink = NULL;
3434
3435                 if( bInsertHead)
3436                 {
3437
3438                     pExtent->DirtyList.fLink = (void *)pNPFcb->Specific.File.DirtyListHead;
3439
3440                     pExtent->DirtyList.bLink = NULL;
3441
3442                     pNPFcb->Specific.File.DirtyListHead->DirtyList.bLink = (void *)pExtent;
3443
3444                     pNPFcb->Specific.File.DirtyListHead = pExtent;
3445
3446                     pCurrentExtent = pExtent;
3447
3448                     bInsertHead = FALSE;
3449                 }
3450                 else if( bInsertTail)
3451                 {
3452
3453                     if( pNPFcb->Specific.File.DirtyListHead == NULL)
3454                     {
3455
3456                         pNPFcb->Specific.File.DirtyListHead = pExtent;
3457                     }
3458                     else
3459                     {
3460
3461                         pNPFcb->Specific.File.DirtyListTail->DirtyList.fLink = (void *)pExtent;
3462
3463                         pExtent->DirtyList.bLink = (void *)pNPFcb->Specific.File.DirtyListTail;
3464                     }
3465
3466                     pNPFcb->Specific.File.DirtyListTail = pExtent;
3467                 }
3468                 else
3469                 {
3470
3471                     pExtent->DirtyList.fLink = pCurrentExtent->DirtyList.fLink;
3472
3473                     pExtent->DirtyList.bLink = (void *)pCurrentExtent;
3474
3475                     if( pExtent->DirtyList.fLink == NULL)
3476                     {
3477
3478                         pNPFcb->Specific.File.DirtyListTail = pExtent;
3479                     }
3480                     else
3481                     {
3482
3483                         ((AFSExtent *)pExtent->DirtyList.fLink)->DirtyList.bLink = (void *)pExtent;
3484                     }
3485
3486                     pCurrentExtent->DirtyList.fLink = (void *)pExtent;
3487
3488                     pCurrentExtent = pExtent;
3489                 }
3490
3491                 pExtent->Flags |= AFS_EXTENT_DIRTY;
3492
3493                 //
3494                 // Up the dirty count
3495                 //
3496
3497                 lCount = InterlockedIncrement( &Fcb->Specific.File.ExtentsDirtyCount);
3498             }
3499             else
3500             {
3501
3502                 pCurrentExtent = pExtent;
3503             }
3504
3505             AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_ACTIVE_COUNTING,
3506                           AFS_TRACE_LEVEL_VERBOSE,
3507                           "AFSMarkDirty Decrement count on extent %08lX Cnt %d\n",
3508                           pExtent,
3509                           pExtent->ActiveCount);
3510
3511             if( DerefExtents)
3512             {
3513                 ASSERT( pExtent->ActiveCount > 0);
3514                 lCount = InterlockedDecrement( &pExtent->ActiveCount);
3515             }
3516
3517             pExtent = pNextExtent;
3518
3519             ulCount++;
3520         }
3521     }
3522     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
3523     {
3524
3525         AFSDbgLogMsg( 0,
3526                       0,
3527                       "EXCEPTION - AFSMarkDirty\n");
3528
3529         AFSDumpTraceFilesFnc();
3530     }
3531
3532     AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
3533
3534     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
3535                   AFS_TRACE_LEVEL_VERBOSE,
3536                   "AFSMarkDirty Releasing Fcb extents lock %08lX SHARED %08lX\n",
3537                   &Fcb->NPFcb->Specific.File.ExtentsResource,
3538                   PsGetCurrentThread());
3539
3540     if( bLocked)
3541     {
3542         AFSReleaseResource( &Fcb->NPFcb->Specific.File.ExtentsResource );
3543     }
3544
3545     return;
3546 }
3547
3548 //
3549 // Helper functions
3550 //
3551
3552 AFSExtent *
3553 ExtentFor(PLIST_ENTRY le, ULONG SkipList)
3554 {
3555
3556     return CONTAINING_RECORD( le, AFSExtent, Lists[SkipList] );
3557 }
3558
3559 AFSExtent *
3560 NextExtent(AFSExtent *Extent, ULONG SkipList)
3561 {
3562
3563     return ExtentFor(Extent->Lists[SkipList].Flink, SkipList);
3564 }
3565
3566 static AFSExtent *DirtyExtentFor(PLIST_ENTRY le)
3567 {
3568
3569     return CONTAINING_RECORD( le, AFSExtent, DirtyList );
3570 }
3571
3572 static VOID VerifyExtentsLists(AFSFcb *Fcb)
3573 {
3574 #if DBG >&nb