Windows: more warnings on kernel builds
[openafs.git] / src / WINNT / afsrdr / kernel / fs / AFSFastIoSupport.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: AFSFastIoSupport.cpp
37 //
38
39 #include "AFSCommon.h"
40
41 BOOLEAN
42 AFSFastIoCheckIfPossible( IN struct _FILE_OBJECT *FileObject,
43                           IN PLARGE_INTEGER FileOffset,
44                           IN ULONG Length,
45                           IN BOOLEAN Wait,
46                           IN ULONG LockKey,
47                           IN BOOLEAN CheckForReadOperation,
48                           OUT PIO_STATUS_BLOCK IoStatus,
49                           IN struct _DEVICE_OBJECT *DeviceObject)
50 {
51     UNREFERENCED_PARAMETER(FileObject);
52     UNREFERENCED_PARAMETER(FileOffset);
53     UNREFERENCED_PARAMETER(Length);
54     UNREFERENCED_PARAMETER(Wait);
55     UNREFERENCED_PARAMETER(LockKey);
56     UNREFERENCED_PARAMETER(CheckForReadOperation);
57     UNREFERENCED_PARAMETER(IoStatus);
58     UNREFERENCED_PARAMETER(DeviceObject);
59
60     BOOLEAN bStatus = FALSE;
61
62     return bStatus;
63 }
64
65 BOOLEAN
66 AFSFastIoRead( IN struct _FILE_OBJECT *FileObject,
67                IN PLARGE_INTEGER FileOffset,
68                IN ULONG Length,
69                IN BOOLEAN Wait,
70                IN ULONG LockKey,
71                OUT PVOID Buffer,
72                OUT PIO_STATUS_BLOCK IoStatus,
73                IN struct _DEVICE_OBJECT *DeviceObject)
74 {
75
76     UNREFERENCED_PARAMETER(FileObject);
77     UNREFERENCED_PARAMETER(FileOffset);
78     UNREFERENCED_PARAMETER(Length);
79     UNREFERENCED_PARAMETER(Wait);
80     UNREFERENCED_PARAMETER(LockKey);
81     UNREFERENCED_PARAMETER(Buffer);
82     UNREFERENCED_PARAMETER(IoStatus);
83     UNREFERENCED_PARAMETER(DeviceObject);
84
85     BOOLEAN bStatus = FALSE;
86
87     return bStatus;
88 }
89
90 BOOLEAN
91 AFSFastIoWrite( IN struct _FILE_OBJECT *FileObject,
92                 IN PLARGE_INTEGER FileOffset,
93                 IN ULONG Length,
94                 IN BOOLEAN Wait,
95                 IN ULONG LockKey,
96                 IN PVOID Buffer,
97                 OUT PIO_STATUS_BLOCK IoStatus,
98                 IN struct _DEVICE_OBJECT *DeviceObject)
99 {
100
101     UNREFERENCED_PARAMETER(FileObject);
102     UNREFERENCED_PARAMETER(FileOffset);
103     UNREFERENCED_PARAMETER(Length);
104     UNREFERENCED_PARAMETER(Wait);
105     UNREFERENCED_PARAMETER(LockKey);
106     UNREFERENCED_PARAMETER(Buffer);
107     UNREFERENCED_PARAMETER(IoStatus);
108     UNREFERENCED_PARAMETER(DeviceObject);
109
110     BOOLEAN bStatus = FALSE;
111
112     return bStatus;
113 }
114
115 BOOLEAN
116 AFSFastIoQueryBasicInfo( IN struct _FILE_OBJECT *FileObject,
117                          IN BOOLEAN Wait,
118                          OUT PFILE_BASIC_INFORMATION Buffer,
119                          OUT PIO_STATUS_BLOCK IoStatus,
120                          IN struct _DEVICE_OBJECT *DeviceObject)
121 {
122     UNREFERENCED_PARAMETER(FileObject);
123     UNREFERENCED_PARAMETER(Wait);
124     UNREFERENCED_PARAMETER(Buffer);
125     UNREFERENCED_PARAMETER(IoStatus);
126     UNREFERENCED_PARAMETER(DeviceObject);
127
128     BOOLEAN bStatus = FALSE;
129
130     return bStatus;
131 }
132
133 BOOLEAN
134 AFSFastIoQueryStandardInfo( IN struct _FILE_OBJECT *FileObject,
135                             IN BOOLEAN Wait,
136                             OUT PFILE_STANDARD_INFORMATION Buffer,
137                             OUT PIO_STATUS_BLOCK IoStatus,
138                             IN struct _DEVICE_OBJECT *DeviceObject)
139 {
140     UNREFERENCED_PARAMETER(FileObject);
141     UNREFERENCED_PARAMETER(Wait);
142     UNREFERENCED_PARAMETER(Buffer);
143     UNREFERENCED_PARAMETER(IoStatus);
144     UNREFERENCED_PARAMETER(DeviceObject);
145
146     BOOLEAN bStatus = FALSE;
147
148     return bStatus;
149 }
150
151 BOOLEAN
152 AFSFastIoLock( IN struct _FILE_OBJECT *FileObject,
153                IN PLARGE_INTEGER FileOffset,
154                IN PLARGE_INTEGER Length,
155                IN PEPROCESS ProcessId,
156                IN ULONG Key,
157                IN BOOLEAN FailImmediately,
158                IN BOOLEAN ExclusiveLock,
159                OUT PIO_STATUS_BLOCK IoStatus,
160                IN struct _DEVICE_OBJECT *DeviceObject)
161 {
162     UNREFERENCED_PARAMETER(FileObject);
163     UNREFERENCED_PARAMETER(FileOffset);
164     UNREFERENCED_PARAMETER(Length);
165     UNREFERENCED_PARAMETER(ProcessId);
166     UNREFERENCED_PARAMETER(Key);
167     UNREFERENCED_PARAMETER(FailImmediately);
168     UNREFERENCED_PARAMETER(ExclusiveLock);
169     UNREFERENCED_PARAMETER(IoStatus);
170     UNREFERENCED_PARAMETER(DeviceObject);
171
172     BOOLEAN bStatus = FALSE;
173
174     return bStatus;
175 }
176
177 BOOLEAN
178 AFSFastIoUnlockSingle( IN struct _FILE_OBJECT *FileObject,
179                        IN PLARGE_INTEGER FileOffset,
180                        IN PLARGE_INTEGER Length,
181                        IN PEPROCESS ProcessId,
182                        IN ULONG Key,
183                        OUT PIO_STATUS_BLOCK IoStatus,
184                        IN struct _DEVICE_OBJECT *DeviceObject)
185 {
186     UNREFERENCED_PARAMETER(FileObject);
187     UNREFERENCED_PARAMETER(FileOffset);
188     UNREFERENCED_PARAMETER(Length);
189     UNREFERENCED_PARAMETER(ProcessId);
190     UNREFERENCED_PARAMETER(Key);
191     UNREFERENCED_PARAMETER(IoStatus);
192     UNREFERENCED_PARAMETER(DeviceObject);
193
194     BOOLEAN bStatus = FALSE;
195
196     return bStatus;
197 }
198
199 BOOLEAN
200 AFSFastIoUnlockAll( IN struct _FILE_OBJECT *FileObject,
201                     IN PEPROCESS ProcessId,
202                     OUT PIO_STATUS_BLOCK IoStatus,
203                     IN struct _DEVICE_OBJECT *DeviceObject)
204 {
205     UNREFERENCED_PARAMETER(FileObject);
206     UNREFERENCED_PARAMETER(ProcessId);
207     UNREFERENCED_PARAMETER(IoStatus);
208     UNREFERENCED_PARAMETER(DeviceObject);
209
210     BOOLEAN bStatus = FALSE;
211
212     return bStatus;
213 }
214
215 BOOLEAN
216 AFSFastIoUnlockAllByKey( IN struct _FILE_OBJECT *FileObject,
217                          IN PVOID ProcessId,
218                          IN ULONG Key,
219                          OUT PIO_STATUS_BLOCK IoStatus,
220                          IN struct _DEVICE_OBJECT *DeviceObject)
221 {
222     UNREFERENCED_PARAMETER(FileObject);
223     UNREFERENCED_PARAMETER(ProcessId);
224     UNREFERENCED_PARAMETER(Key);
225     UNREFERENCED_PARAMETER(IoStatus);
226     UNREFERENCED_PARAMETER(DeviceObject);
227
228     BOOLEAN bStatus = FALSE;
229
230     return bStatus;
231 }
232
233 BOOLEAN
234 AFSFastIoDevCtrl( IN struct _FILE_OBJECT *FileObject,
235                   IN BOOLEAN Wait,
236                   IN PVOID InputBuffer OPTIONAL,
237                   IN ULONG InputBufferLength,
238                   OUT PVOID OutputBuffer OPTIONAL,
239                   IN ULONG OutputBufferLength,
240                   IN ULONG IoControlCode,
241                   OUT PIO_STATUS_BLOCK IoStatus,
242                   IN struct _DEVICE_OBJECT *DeviceObject)
243 {
244     UNREFERENCED_PARAMETER(FileObject);
245     UNREFERENCED_PARAMETER(Wait);
246     UNREFERENCED_PARAMETER(InputBuffer);
247     UNREFERENCED_PARAMETER(InputBufferLength);
248     UNREFERENCED_PARAMETER(OutputBuffer);
249     UNREFERENCED_PARAMETER(OutputBufferLength);
250     UNREFERENCED_PARAMETER(IoControlCode);
251     UNREFERENCED_PARAMETER(IoStatus);
252     UNREFERENCED_PARAMETER(DeviceObject);
253
254     BOOLEAN bStatus = FALSE;
255
256     return bStatus;
257 }
258
259 void
260 AFSFastIoAcquireFile( IN struct _FILE_OBJECT *FileObject)
261 {
262
263     AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
264
265     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
266                   AFS_TRACE_LEVEL_VERBOSE,
267                   "AFSFastIoAcquireFile Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
268                   &pFcb->NPFcb->SectionObjectResource,
269                   PsGetCurrentThread());
270
271     AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
272                     TRUE);
273
274     return;
275 }
276
277 void
278 AFSFastIoReleaseFile( IN struct _FILE_OBJECT *FileObject)
279 {
280
281     AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
282
283     if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->SectionObjectResource))
284     {
285
286         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
287                       AFS_TRACE_LEVEL_VERBOSE,
288                       "AFSFastIoReleaseFile Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
289                       &pFcb->NPFcb->SectionObjectResource,
290                       PsGetCurrentThread());
291
292         AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
293     }
294
295     return;
296 }
297
298 VOID
299 AFSFastIoDetachDevice( IN struct _DEVICE_OBJECT *SourceDevice,
300                        IN struct _DEVICE_OBJECT *TargetDevice)
301 {
302     UNREFERENCED_PARAMETER(SourceDevice);
303     UNREFERENCED_PARAMETER(TargetDevice);
304
305     return;
306 }
307
308 BOOLEAN
309 AFSFastIoQueryNetworkOpenInfo( IN struct _FILE_OBJECT *FileObject,
310                                IN BOOLEAN Wait,
311                                OUT struct _FILE_NETWORK_OPEN_INFORMATION *Buffer,
312                                OUT struct _IO_STATUS_BLOCK *IoStatus,
313                                IN struct _DEVICE_OBJECT *DeviceObject)
314 {
315     UNREFERENCED_PARAMETER(FileObject);
316     UNREFERENCED_PARAMETER(Wait);
317     UNREFERENCED_PARAMETER(Buffer);
318     UNREFERENCED_PARAMETER(IoStatus);
319     UNREFERENCED_PARAMETER(DeviceObject);
320
321     BOOLEAN bStatus = FALSE;
322
323     return bStatus;
324 }
325
326 BOOLEAN
327 AFSFastIoMdlRead( IN struct _FILE_OBJECT *FileObject,
328                   IN PLARGE_INTEGER FileOffset,
329                   IN ULONG Length,
330                   IN ULONG LockKey,
331                   OUT PMDL *MdlChain,
332                   OUT PIO_STATUS_BLOCK IoStatus,
333                   IN struct _DEVICE_OBJECT *DeviceObject)
334 {
335     UNREFERENCED_PARAMETER(FileObject);
336     UNREFERENCED_PARAMETER(FileOffset);
337     UNREFERENCED_PARAMETER(Length);
338     UNREFERENCED_PARAMETER(LockKey);
339     UNREFERENCED_PARAMETER(MdlChain);
340     UNREFERENCED_PARAMETER(IoStatus);
341     UNREFERENCED_PARAMETER(DeviceObject);
342
343     BOOLEAN bStatus = FALSE;
344
345     return bStatus;
346 }
347
348 BOOLEAN
349 AFSFastIoMdlReadComplete( IN struct _FILE_OBJECT *FileObject,
350                           IN PMDL MdlChain,
351                           IN struct _DEVICE_OBJECT *DeviceObject)
352 {
353     UNREFERENCED_PARAMETER(FileObject);
354     UNREFERENCED_PARAMETER(MdlChain);
355     UNREFERENCED_PARAMETER(DeviceObject);
356
357     BOOLEAN bStatus = FALSE;
358
359     return bStatus;
360 }
361
362 BOOLEAN
363 AFSFastIoPrepareMdlWrite( IN struct _FILE_OBJECT *FileObject,
364                           IN PLARGE_INTEGER FileOffset,
365                           IN ULONG Length,
366                           IN ULONG LockKey,
367                           OUT PMDL *MdlChain,
368                           OUT PIO_STATUS_BLOCK IoStatus,
369                           IN struct _DEVICE_OBJECT *DeviceObject)
370 {
371     UNREFERENCED_PARAMETER(FileObject);
372     UNREFERENCED_PARAMETER(FileOffset);
373     UNREFERENCED_PARAMETER(Length);
374     UNREFERENCED_PARAMETER(LockKey);
375     UNREFERENCED_PARAMETER(MdlChain);
376     UNREFERENCED_PARAMETER(IoStatus);
377     UNREFERENCED_PARAMETER(DeviceObject);
378
379     BOOLEAN bStatus = FALSE;
380
381     return bStatus;
382 }
383
384 BOOLEAN
385 AFSFastIoMdlWriteComplete( IN struct _FILE_OBJECT *FileObject,
386                            IN PLARGE_INTEGER FileOffset,
387                            IN PMDL MdlChain,
388                            IN struct _DEVICE_OBJECT *DeviceObject)
389 {
390     UNREFERENCED_PARAMETER(FileObject);
391     UNREFERENCED_PARAMETER(FileOffset);
392     UNREFERENCED_PARAMETER(MdlChain);
393     UNREFERENCED_PARAMETER(DeviceObject);
394
395     BOOLEAN bStatus = FALSE;
396
397     return bStatus;
398 }
399
400 NTSTATUS
401 AFSFastIoAcquireForModWrite( IN struct _FILE_OBJECT *FileObject,
402                              IN PLARGE_INTEGER EndingOffset,
403                              OUT struct _ERESOURCE **ResourceToRelease,
404                              IN struct _DEVICE_OBJECT *DeviceObject)
405 {
406     UNREFERENCED_PARAMETER(DeviceObject);
407     UNREFERENCED_PARAMETER(EndingOffset);
408
409     NTSTATUS ntStatus = STATUS_FILE_LOCK_CONFLICT;
410     AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
411
412     __Enter
413     {
414
415         if( AFSAcquireExcl( &pFcb->NPFcb->Resource,
416                             BooleanFlagOn( FileObject->Flags, FO_SYNCHRONOUS_IO)))
417         {
418
419             AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
420                           AFS_TRACE_LEVEL_VERBOSE,
421                           "AFSFastIoAcquireForModWrite Acquired Fcb SectionObject lock %08lX EXCL %08lX\n",
422                           &pFcb->NPFcb->SectionObjectResource,
423                           PsGetCurrentThread());
424
425             ntStatus = STATUS_SUCCESS;
426
427             *ResourceToRelease = &pFcb->NPFcb->SectionObjectResource;
428         }
429     }
430
431     return ntStatus;
432 }
433
434 NTSTATUS
435 AFSFastIoReleaseForModWrite( IN struct _FILE_OBJECT *FileObject,
436                              IN struct _ERESOURCE *ResourceToRelease,
437                              IN struct _DEVICE_OBJECT *DeviceObject)
438 {
439     UNREFERENCED_PARAMETER(FileObject);
440     UNREFERENCED_PARAMETER(DeviceObject);
441
442     NTSTATUS ntStatus = STATUS_SUCCESS;
443
444     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
445                   AFS_TRACE_LEVEL_VERBOSE,
446                   "AFSFastIoReleaseForModWrite Releasing lock %08lX EXCL %08lX\n",
447                   ResourceToRelease,
448                   PsGetCurrentThread());
449
450     AFSReleaseResource( ResourceToRelease);
451
452     return ntStatus;
453 }
454
455 NTSTATUS
456 AFSFastIoAcquireForCCFlush( IN struct _FILE_OBJECT *FileObject,
457                             IN struct _DEVICE_OBJECT *DeviceObject)
458 {
459     UNREFERENCED_PARAMETER(DeviceObject);
460
461     NTSTATUS ntStatus = STATUS_FILE_LOCK_CONFLICT;
462     AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
463
464     AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
465                   AFS_TRACE_LEVEL_VERBOSE,
466                   "AFSFastIoAcquireForCCFlush Acquiring Fcb PagingIo lock %08lX SHARED %08lX\n",
467                   &pFcb->NPFcb->PagingResource,
468                   PsGetCurrentThread());
469
470     AFSAcquireShared( &pFcb->NPFcb->PagingResource,
471                       TRUE);
472
473     if( !ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->SectionObjectResource))
474     {
475
476         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
477                       AFS_TRACE_LEVEL_VERBOSE,
478                       "AFSFastIoAcquireForCCFlush Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
479                       &pFcb->NPFcb->SectionObjectResource,
480                       PsGetCurrentThread());
481
482         AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
483                         TRUE);
484     }
485     else
486     {
487
488         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
489                       AFS_TRACE_LEVEL_VERBOSE,
490                       "AFSFastIoAcquireForCCFlush Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
491                       &pFcb->NPFcb->SectionObjectResource,
492                       PsGetCurrentThread());
493
494         AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
495                           TRUE);
496     }
497
498     ntStatus = STATUS_SUCCESS;
499
500     //
501     // Set the TopLevelIrp field for this caller
502     //
503
504     if( IoGetTopLevelIrp() == NULL)
505     {
506
507         IoSetTopLevelIrp( (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
508     }
509
510     return ntStatus;
511 }
512
513 NTSTATUS
514 AFSFastIoReleaseForCCFlush( IN struct _FILE_OBJECT *FileObject,
515                             IN struct _DEVICE_OBJECT *DeviceObject)
516 {
517     UNREFERENCED_PARAMETER(DeviceObject);
518
519     NTSTATUS ntStatus = STATUS_SUCCESS;
520     AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
521
522     if( IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP)
523     {
524
525         IoSetTopLevelIrp( NULL);
526     }
527
528     if( ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->PagingResource))
529     {
530
531         AFSReleaseResource( &pFcb->NPFcb->PagingResource);
532     }
533     else
534     {
535
536         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
537                       AFS_TRACE_LEVEL_ERROR,
538                       "AFSFastIoReleaseForCCFlush Called for non-acquired paging resource Fcb\n");
539     }
540
541     if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->SectionObjectResource) ||
542         ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->SectionObjectResource))
543     {
544
545         AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
546     }
547     else
548     {
549
550         AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
551                       AFS_TRACE_LEVEL_ERROR,
552                       "AFSFastIoReleaseForCCFlush Called for non-acquired SectionObject resource Fcb\n");
553     }
554
555     return ntStatus;
556 }
557
558 BOOLEAN
559 AFSFastIoReadCompressed( IN struct _FILE_OBJECT *FileObject,
560                          IN PLARGE_INTEGER FileOffset,
561                          IN ULONG Length,
562                          IN ULONG LockKey,
563                          OUT PVOID Buffer,
564                          OUT PMDL *MdlChain,
565                          OUT PIO_STATUS_BLOCK IoStatus,
566                          OUT struct _COMPRESSED_DATA_INFO *CompressedDataInfo,
567                          IN ULONG CompressedDataInfoLength,
568                          IN struct _DEVICE_OBJECT *DeviceObject)
569 {
570     UNREFERENCED_PARAMETER(FileObject);
571     UNREFERENCED_PARAMETER(FileOffset);
572     UNREFERENCED_PARAMETER(Length);
573     UNREFERENCED_PARAMETER(LockKey);
574     UNREFERENCED_PARAMETER(Buffer);
575     UNREFERENCED_PARAMETER(MdlChain);
576     UNREFERENCED_PARAMETER(IoStatus);
577     UNREFERENCED_PARAMETER(CompressedDataInfo);
578     UNREFERENCED_PARAMETER(CompressedDataInfoLength);
579     UNREFERENCED_PARAMETER(DeviceObject);
580
581     BOOLEAN bStatus = FALSE;
582
583     return bStatus;
584 }
585
586 BOOLEAN
587 AFSFastIoWriteCompressed( IN struct _FILE_OBJECT *FileObject,
588                           IN PLARGE_INTEGER FileOffset,
589                           IN ULONG Length,
590                           IN ULONG LockKey,
591                           IN PVOID Buffer,
592                           OUT PMDL *MdlChain,
593                           OUT PIO_STATUS_BLOCK IoStatus,
594                           IN struct _COMPRESSED_DATA_INFO *CompressedDataInfo,
595                           IN ULONG CompressedDataInfoLength,
596                           IN struct _DEVICE_OBJECT *DeviceObject)
597 {
598     UNREFERENCED_PARAMETER(FileObject);
599     UNREFERENCED_PARAMETER(FileOffset);
600     UNREFERENCED_PARAMETER(Length);
601     UNREFERENCED_PARAMETER(LockKey);
602     UNREFERENCED_PARAMETER(Buffer);
603     UNREFERENCED_PARAMETER(MdlChain);
604     UNREFERENCED_PARAMETER(IoStatus);
605     UNREFERENCED_PARAMETER(CompressedDataInfo);
606     UNREFERENCED_PARAMETER(CompressedDataInfoLength);
607     UNREFERENCED_PARAMETER(DeviceObject);
608
609     BOOLEAN bStatus = FALSE;
610
611     return bStatus;
612 }
613
614 BOOLEAN
615 AFSFastIoMdlReadCompleteCompressed( IN struct _FILE_OBJECT *FileObject,
616                                     IN PMDL MdlChain,
617                                     IN struct _DEVICE_OBJECT *DeviceObject)
618 {
619     UNREFERENCED_PARAMETER(FileObject);
620     UNREFERENCED_PARAMETER(MdlChain);
621     UNREFERENCED_PARAMETER(DeviceObject);
622
623     BOOLEAN bStatus = FALSE;
624
625     return bStatus;
626 }
627
628 BOOLEAN
629 AFSFastIoMdlWriteCompleteCompressed( IN struct _FILE_OBJECT *FileObject,
630                                      IN PLARGE_INTEGER FileOffset,
631                                      IN PMDL MdlChain,
632                                      IN struct _DEVICE_OBJECT *DeviceObject)
633 {
634     UNREFERENCED_PARAMETER(FileObject);
635     UNREFERENCED_PARAMETER(FileOffset);
636     UNREFERENCED_PARAMETER(MdlChain);
637     UNREFERENCED_PARAMETER(DeviceObject);
638
639     BOOLEAN bStatus = FALSE;
640
641     return bStatus;
642 }
643
644 BOOLEAN
645 AFSFastIoQueryOpen( IN struct _IRP *Irp,
646                     OUT PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
647                     IN struct _DEVICE_OBJECT *DeviceObject)
648 {
649     UNREFERENCED_PARAMETER(Irp);
650     UNREFERENCED_PARAMETER(NetworkInformation);
651     UNREFERENCED_PARAMETER(DeviceObject);
652
653     BOOLEAN bStatus = FALSE;
654
655     return bStatus;
656 }