Windows: warnings on kernel builds
[openafs.git] / src / WINNT / afsrdr / kernel / lib / AFSIoSupport.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: AFSIoSupport.cpp
37 //
38
39 #include "AFSCommon.h"
40
41 //
42 // Called in the paging or non cached read and write paths to get the
43 // first and last extent in a span.  We also the count of how many
44 // discontiguous extents the are in the cache file.
45 //
46
47 NTSTATUS
48 AFSGetExtents( IN AFSFcb *Fcb,
49                IN PLARGE_INTEGER Offset,
50                IN ULONG Length,
51                OUT AFSExtent *From,
52                OUT ULONG *ExtentCount,
53                OUT ULONG *RunCount)
54 {
55     UNREFERENCED_PARAMETER(Fcb);
56     NTSTATUS           ntStatus = STATUS_SUCCESS;
57     ULONG              extentsCount = 0, runCount = 0;
58     AFSExtent         *pEndExtent = NULL;
59     LARGE_INTEGER      liLastCacheOffset;
60
61     *ExtentCount = 0;
62
63     __Enter
64     {
65         ASSERT(AFSExtentContains(From, Offset));
66
67         pEndExtent = From;
68         extentsCount = 1;
69         runCount = 1;
70         liLastCacheOffset.QuadPart = pEndExtent->CacheOffset.QuadPart + pEndExtent->Size;
71
72         while ((Offset->QuadPart + Length) >
73                pEndExtent->FileOffset.QuadPart + pEndExtent->Size) {
74
75             pEndExtent = NextExtent(pEndExtent, AFS_EXTENTS_LIST);
76
77             if (liLastCacheOffset.QuadPart != pEndExtent->CacheOffset.QuadPart) {
78                 //
79                 // Discontiguous (in the cache)
80                 //
81                 runCount += 1;
82
83             }
84
85             extentsCount+= 1;
86
87             liLastCacheOffset.QuadPart = pEndExtent->CacheOffset.QuadPart + pEndExtent->Size;
88         }
89
90         *ExtentCount = extentsCount;
91         *RunCount = runCount;
92         ntStatus = STATUS_SUCCESS;
93     }
94     return ntStatus;
95 }
96
97
98 NTSTATUS
99 AFSSetupIoRun( IN PDEVICE_OBJECT CacheDevice,
100                IN PIRP           MasterIrp,
101                IN PVOID          SystemBuffer,
102                IN OUT AFSIoRun  *IoRuns,
103                IN PLARGE_INTEGER Start,
104                IN ULONG          Length,
105                IN AFSExtent     *From,
106                IN OUT ULONG     *RunCount)
107 {
108     UNREFERENCED_PARAMETER(MasterIrp);
109     //
110     // Do all the work which we can prior to firing off the IRP
111     // (allocate them, calculate offsets and so on)
112     //
113     LARGE_INTEGER  liCacheOffset;
114     LARGE_INTEGER  liFileOffset = *Start;
115     ULONG          ulCurrLength;
116     ULONG          ulReadOffset;
117     ULONG          ulCurrRun = 0;
118     AFSExtent     *pExtent = From;
119     AFSExtent     *pNextExtent = NULL;
120     BOOLEAN        done = FALSE;
121     NTSTATUS       ntStatus = STATUS_SUCCESS;
122
123     __Enter
124     {
125
126         while( !done)
127         {
128             ASSERT( liFileOffset.QuadPart >= pExtent->FileOffset.QuadPart );
129
130             liCacheOffset = pExtent->CacheOffset;
131             liCacheOffset.QuadPart += (liFileOffset.QuadPart -
132                                        pExtent->FileOffset.QuadPart);
133
134             ulCurrLength = 0;
135
136             //
137             // While there is still data to process, loop
138             //
139             while ( (pExtent->FileOffset.QuadPart + pExtent->Size) <
140                     (Start->QuadPart + Length) )
141             {
142                 //
143                 // Collapse the read if we can
144                 //
145                 pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
146
147                 if (pNextExtent->CacheOffset.QuadPart !=
148                     (pExtent->CacheOffset.QuadPart + pExtent->Size))
149                 {
150                     //
151                     // This extent and the next extent are not contiguous
152                     //
153                     break;
154                 }
155                 pExtent = pNextExtent;
156             }
157
158             //
159             // So, this run goes from liCacheOffset to the end of pExtent
160             //
161
162             if ((pExtent->FileOffset.QuadPart + pExtent->Size) >= (Start->QuadPart + Length))
163             {
164                 //
165                 // The last extent overruns the area we care
166                 // about, so trim it back.
167                 //
168                 ulCurrLength = (ULONG) (Start->QuadPart + Length -
169                                         liFileOffset.QuadPart);
170                 //
171                 // But we are done
172                 //
173                 done = TRUE;
174             }
175             else
176             {
177                 //
178                 // Length is from the LiFileOffset to the end of this
179                 // extent.
180                 //
181                 ulCurrLength = (ULONG) (pExtent->FileOffset.QuadPart + pExtent->Size -
182                                         liFileOffset.QuadPart);
183                 done = FALSE;
184             }
185
186             //
187             // Calculate the offset into the buffer
188             //
189             ulReadOffset = (ULONG) (liFileOffset.QuadPart - Start->QuadPart);
190
191             IoRuns[ulCurrRun].CacheOffset = liCacheOffset;
192             IoRuns[ulCurrRun].ByteCount = ulCurrLength;
193
194             IoRuns[ulCurrRun].ChildIrp = IoAllocateIrp( CacheDevice->StackSize + 1,
195                                                         FALSE);
196
197             if (NULL == IoRuns[ulCurrRun].ChildIrp)
198             {
199                 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
200             }
201
202             IoRuns[ulCurrRun].ChildIrp->UserBuffer = ((PCHAR) SystemBuffer) + ulReadOffset;
203             IoRuns[ulCurrRun].ChildIrp->Tail.Overlay.Thread = PsGetCurrentThread();
204             IoRuns[ulCurrRun].ChildIrp->RequestorMode = KernelMode;
205             IoRuns[ulCurrRun].ChildIrp->MdlAddress = NULL;
206
207             ulCurrRun ++;
208             if (!done)
209             {
210                 ASSERT(pNextExtent != NULL && pNextExtent != pExtent);
211                 //
212                 // Move cursors forward
213                 //
214                 pExtent = pNextExtent;
215                 liFileOffset = pExtent->FileOffset;
216             }
217         }
218         ASSERT(ulCurrRun <= *RunCount);
219 try_exit:
220         if (!NT_SUCCESS(ntStatus))
221         {
222             for (ulCurrRun = 0 ; ulCurrRun < *RunCount; ulCurrRun++)
223             {
224                 if (IoRuns[ulCurrRun].ChildIrp) {
225                     IoFreeIrp( IoRuns[ulCurrRun].ChildIrp );
226                     IoRuns[ulCurrRun].ChildIrp = NULL;
227                 }
228             }
229         }
230         else
231         {
232             *RunCount = ulCurrRun;
233         }
234     }
235     return ntStatus;
236 }
237
238 //
239 // We manage our own scatter / gather.  This completion
240 // function calls into our generic function.
241 //
242
243 static
244 NTSTATUS
245 CompletionFunction(IN PDEVICE_OBJECT DeviceObject,
246                    PIRP Irp,
247                    PVOID Context)
248 {
249     UNREFERENCED_PARAMETER(DeviceObject);
250     AFSGatherIo *pGather = (AFSGatherIo *) Context;
251
252     AFSCompleteIo( pGather, Irp->IoStatus.Status);
253
254     if (Irp->MdlAddress) {
255         if (Irp->MdlAddress->MdlFlags & MDL_PAGES_LOCKED) {
256             MmUnlockPages(Irp->MdlAddress);
257         }
258         IoFreeMdl(Irp->MdlAddress);
259         Irp->MdlAddress = NULL;
260     }
261     IoFreeIrp(Irp);
262
263     //
264     // Tell io manager that we own the Irp
265     //
266     return STATUS_MORE_PROCESSING_REQUIRED;
267 }
268
269 NTSTATUS
270 AFSStartIos( IN PFILE_OBJECT     CacheFileObject,
271              IN UCHAR            FunctionCode,
272              IN ULONG            IrpFlags,
273              IN AFSIoRun        *IoRun,
274              IN ULONG            Count,
275              IN OUT AFSGatherIo *Gather)
276 {
277
278     PIO_STACK_LOCATION  pIoStackLocation = NULL;
279     PIRP                pIrp;
280     NTSTATUS            ntStatus = STATUS_SUCCESS;
281     PDEVICE_OBJECT      pDeviceObject = NULL;
282     LONG                lCount;
283
284     __Enter
285     {
286
287         pDeviceObject = IoGetRelatedDeviceObject( CacheFileObject);
288
289         for (ULONG i = 0; i < Count; i++)
290         {
291
292             pIrp = IoRun[i].ChildIrp;
293
294             pIoStackLocation = IoGetNextIrpStackLocation( pIrp);
295
296             pIrp->Flags = IrpFlags;
297             pIoStackLocation->MajorFunction = FunctionCode;
298             pIoStackLocation->DeviceObject = pDeviceObject;
299             pIoStackLocation->FileObject = CacheFileObject;
300             pIoStackLocation->Parameters.Write.Length = IoRun[i].ByteCount;
301             pIoStackLocation->Parameters.Write.ByteOffset = IoRun[i].CacheOffset;
302
303             //
304             // Bump the count *before* we start the IO, that way if it
305             // completes real fast it will still not set the event
306             //
307             lCount = InterlockedIncrement(&Gather->Count);
308
309             //
310             // Set the completion routine.
311             //
312
313             IoSetCompletionRoutine( pIrp,
314                                     CompletionFunction,
315                                     Gather,
316                                     TRUE,
317                                     TRUE,
318                                     TRUE);
319
320             //
321             // Send it to the Cache
322             //
323
324             ntStatus = IoCallDriver( pDeviceObject,
325                                      pIrp);
326
327             if( !NT_SUCCESS( ntStatus))
328             {
329                 break;
330             }
331         }
332     }
333
334     return ntStatus;
335 }
336
337 VOID
338 AFSCompleteIo( IN AFSGatherIo *Gather,
339                IN NTSTATUS Status)
340 {
341     LONG lCount;
342
343     if (!NT_SUCCESS(Status)) {
344
345         Gather->Status = Status;
346     }
347
348     lCount = InterlockedDecrement( &Gather->Count );
349
350     if (0 == lCount) {
351         //
352         // Last outstanding IO.  Complete the parent and
353         // do whatever it takes to clean up
354         //
355         if (!NT_SUCCESS(Gather->Status))
356         {
357             Gather->MasterIrp->IoStatus.Status = Gather->Status;
358             Gather->MasterIrp->IoStatus.Information = 0;
359         }
360
361         if( Gather->CompleteMasterIrp)
362         {
363
364             AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
365                           AFS_TRACE_LEVEL_VERBOSE,
366                           "AFSCompleteIo Completing Irp %08lX Status %08lX\n",
367                           Gather->MasterIrp,
368                           Gather->Status);
369
370             AFSCompleteRequest(Gather->MasterIrp, Gather->Status);
371         }
372
373         if (Gather->Synchronous)
374         {
375             //
376             // Someone was waiting for us tell them.  They also own
377             // the data structure so we don't free it
378             //
379             KeSetEvent( &Gather->Event,
380                         0,
381                         FALSE);
382         }
383         else
384         {
385
386             AFSExFreePoolWithTag( Gather, AFS_GATHER_TAG);
387         }
388     }
389 }
390
391 NTSTATUS
392 AFSProcessExtentRun( IN PVOID          SystemBuffer,
393                      IN PLARGE_INTEGER Start,
394                      IN ULONG          Length,
395                      IN AFSExtent     *From,
396                      IN BOOLEAN        WriteRequest)
397 {
398
399     LARGE_INTEGER  liCacheOffset;
400     LARGE_INTEGER  liFileOffset = *Start;
401     ULONG          ulCurrLength;
402     ULONG          ulOffset = 0;
403     ULONG          ulCurrRun = 0;
404     AFSExtent     *pExtent = From;
405     AFSExtent     *pNextExtent = NULL;
406     BOOLEAN        done = FALSE;
407     NTSTATUS       ntStatus = STATUS_SUCCESS;
408
409     __Enter
410     {
411
412         while( !done)
413         {
414             ASSERT( liFileOffset.QuadPart >= pExtent->FileOffset.QuadPart );
415
416             liCacheOffset = pExtent->CacheOffset;
417             liCacheOffset.QuadPart += (liFileOffset.QuadPart -
418                                        pExtent->FileOffset.QuadPart);
419
420             ulCurrLength = 0;
421
422             //
423             // While there is still data to process, loop
424             //
425             while ( (pExtent->FileOffset.QuadPart + pExtent->Size) <
426                     (Start->QuadPart + Length) )
427             {
428                 //
429                 // Collapse the read if we can
430                 //
431                 pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
432
433                 if (pNextExtent->CacheOffset.QuadPart !=
434                     (pExtent->CacheOffset.QuadPart + pExtent->Size))
435                 {
436                     //
437                     // This extent and the next extent are not contiguous
438                     //
439                     break;
440                 }
441                 pExtent = pNextExtent;
442             }
443
444             //
445             // So, this run goes from liCacheOffset to the end of pExtent
446             //
447
448             if ((pExtent->FileOffset.QuadPart + pExtent->Size) >= (Start->QuadPart + Length))
449             {
450                 //
451                 // The last extent overruns the area we care
452                 // about, so trim it back.
453                 //
454                 ulCurrLength = (ULONG) (Start->QuadPart + Length -
455                                         liFileOffset.QuadPart);
456                 //
457                 // But we are done
458                 //
459                 done = TRUE;
460             }
461             else
462             {
463                 //
464                 // Length is from the LiFileOffset to the end of this
465                 // extent.
466                 //
467                 ulCurrLength = (ULONG) (pExtent->FileOffset.QuadPart + pExtent->Size -
468                                         liFileOffset.QuadPart);
469                 done = FALSE;
470             }
471
472             //
473             // Calculate the offset into the buffer
474             //
475             ulOffset = (ULONG) (liFileOffset.QuadPart - Start->QuadPart);
476
477             if( WriteRequest)
478             {
479
480 #ifdef AMD64
481                 RtlCopyMemory( ((char *)AFSLibCacheBaseAddress + liCacheOffset.QuadPart),
482                                ((char *)SystemBuffer + ulOffset),
483                                ulCurrLength);
484 #else
485                 ASSERT( liCacheOffset.HighPart == 0);
486                 RtlCopyMemory( ((char *)AFSLibCacheBaseAddress + liCacheOffset.LowPart),
487                                ((char *)SystemBuffer + ulOffset),
488                                ulCurrLength);
489 #endif
490             }
491             else
492             {
493
494 #ifdef AMD64
495                 RtlCopyMemory( ((char *)SystemBuffer + ulOffset),
496                                ((char *)AFSLibCacheBaseAddress + liCacheOffset.QuadPart),
497                                ulCurrLength);
498 #else
499                 ASSERT( liCacheOffset.HighPart == 0);
500                 RtlCopyMemory( ((char *)SystemBuffer + ulOffset),
501                                ((char *)AFSLibCacheBaseAddress + liCacheOffset.LowPart),
502                                ulCurrLength);
503 #endif
504             }
505
506             ulCurrRun ++;
507             if (!done)
508             {
509                 ASSERT(pNextExtent != NULL && pNextExtent != pExtent);
510                 //
511                 // Move cursors forward
512                 //
513                 pExtent = pNextExtent;
514                 liFileOffset = pExtent->FileOffset;
515             }
516         }
517     }
518
519     return ntStatus;
520 }