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     AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 266                   AFS_TRACE_LEVEL_VERBOSE,
 267                   "AFSFastIoAcquireFile Acquiring Fcb lock %p EXCL %08lX\n",
 268                   &pFcb->NPFcb->Resource,
 269                   PsGetCurrentThread()));
 270
 271     AFSAcquireExcl( &pFcb->NPFcb->Resource,
 272                     TRUE);
 273
 274     AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 275                   AFS_TRACE_LEVEL_VERBOSE,
 276                   "AFSFastIoAcquireFile Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
 277                   &pFcb->NPFcb->SectionObjectResource,
 278                   PsGetCurrentThread()));
 279
 280     AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
 281                     TRUE);
 282
 283     if( NULL == pFcb->Specific.File.SectionCreateFO )
 284     {
 285         //
 286         // If not re-entrant then save and reference
 287         //
 288         pFcb->Specific.File.SectionCreateFO =
 289           CcGetFileObjectFromSectionPtrs( &pFcb->NPFcb->SectionObjectPointers );
 290         if( NULL !=  pFcb->Specific.File.SectionCreateFO )
 291         {
 292             ObReferenceObject( pFcb->Specific.File.SectionCreateFO);
 293         }
 294     }
 295
 296     return;
 297 }
 298
 299 void
 300 AFSFastIoReleaseFile( IN struct _FILE_OBJECT *FileObject)
 301 {
 302
 303     AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
 304
 305     if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->Resource))
 306     {
 307         AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 308                       AFS_TRACE_LEVEL_VERBOSE,
 309                       "AFSFastIoReleaseFile Releasing Fcb Lock %p EXCL %08lX\n",
 310                       &pFcb->NPFcb->Resource,
 311                       PsGetCurrentThread()));
 312
 313         AFSReleaseResource( &pFcb->NPFcb->Resource);
 314     }
 315
 316     if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->SectionObjectResource))
 317     {
 318         PFILE_OBJECT fileObject = pFcb->Specific.File.SectionCreateFO;
 319         pFcb->Specific.File.SectionCreateFO = NULL;
 320
 321         AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 322                       AFS_TRACE_LEVEL_VERBOSE,
 323                       "AFSFastIoReleaseFile Releasing Fcb SectionObject lock %p EXCL %08lX\n",
 324                       &pFcb->NPFcb->SectionObjectResource,
 325                       PsGetCurrentThread()));
 326
 327         AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
 328
 329         //
 330         // Now defer the Cc file object (if there was one) now that we are lock free
 331         //
 332
 333         if( NULL != fileObject )
 334         {
 335             ObDereferenceObject( fileObject );
 336         }
 337     }
 338
 339     return;
 340 }
 341
 342 VOID
 343 AFSFastIoDetachDevice( IN struct _DEVICE_OBJECT *SourceDevice,
 344                        IN struct _DEVICE_OBJECT *TargetDevice)
 345 {
 346     UNREFERENCED_PARAMETER(SourceDevice);
 347     UNREFERENCED_PARAMETER(TargetDevice);
 348
 349     return;
 350 }
 351
 352 BOOLEAN
 353 AFSFastIoQueryNetworkOpenInfo( IN struct _FILE_OBJECT *FileObject,
 354                                IN BOOLEAN Wait,
 355                                OUT struct _FILE_NETWORK_OPEN_INFORMATION *Buffer,
 356                                OUT struct _IO_STATUS_BLOCK *IoStatus,
 357                                IN struct _DEVICE_OBJECT *DeviceObject)
 358 {
 359     UNREFERENCED_PARAMETER(FileObject);
 360     UNREFERENCED_PARAMETER(Wait);
 361     UNREFERENCED_PARAMETER(Buffer);
 362     UNREFERENCED_PARAMETER(IoStatus);
 363     UNREFERENCED_PARAMETER(DeviceObject);
 364
 365     BOOLEAN bStatus = FALSE;
 366
 367     return bStatus;
 368 }
 369
 370 BOOLEAN
 371 AFSFastIoMdlRead( IN struct _FILE_OBJECT *FileObject,
 372                   IN PLARGE_INTEGER FileOffset,
 373                   IN ULONG Length,
 374                   IN ULONG LockKey,
 375                   OUT PMDL *MdlChain,
 376                   OUT PIO_STATUS_BLOCK IoStatus,
 377                   IN struct _DEVICE_OBJECT *DeviceObject)
 378 {
 379     UNREFERENCED_PARAMETER(FileObject);
 380     UNREFERENCED_PARAMETER(FileOffset);
 381     UNREFERENCED_PARAMETER(Length);
 382     UNREFERENCED_PARAMETER(LockKey);
 383     UNREFERENCED_PARAMETER(MdlChain);
 384     UNREFERENCED_PARAMETER(IoStatus);
 385     UNREFERENCED_PARAMETER(DeviceObject);
 386
 387     BOOLEAN bStatus = FALSE;
 388
 389     return bStatus;
 390 }
 391
 392 BOOLEAN
 393 AFSFastIoMdlReadComplete( IN struct _FILE_OBJECT *FileObject,
 394                           IN PMDL MdlChain,
 395                           IN struct _DEVICE_OBJECT *DeviceObject)
 396 {
 397     UNREFERENCED_PARAMETER(FileObject);
 398     UNREFERENCED_PARAMETER(MdlChain);
 399     UNREFERENCED_PARAMETER(DeviceObject);
 400
 401     BOOLEAN bStatus = FALSE;
 402
 403     return bStatus;
 404 }
 405
 406 BOOLEAN
 407 AFSFastIoPrepareMdlWrite( IN struct _FILE_OBJECT *FileObject,
 408                           IN PLARGE_INTEGER FileOffset,
 409                           IN ULONG Length,
 410                           IN ULONG LockKey,
 411                           OUT PMDL *MdlChain,
 412                           OUT PIO_STATUS_BLOCK IoStatus,
 413                           IN struct _DEVICE_OBJECT *DeviceObject)
 414 {
 415     UNREFERENCED_PARAMETER(FileObject);
 416     UNREFERENCED_PARAMETER(FileOffset);
 417     UNREFERENCED_PARAMETER(Length);
 418     UNREFERENCED_PARAMETER(LockKey);
 419     UNREFERENCED_PARAMETER(MdlChain);
 420     UNREFERENCED_PARAMETER(IoStatus);
 421     UNREFERENCED_PARAMETER(DeviceObject);
 422
 423     BOOLEAN bStatus = FALSE;
 424
 425     return bStatus;
 426 }
 427
 428 BOOLEAN
 429 AFSFastIoMdlWriteComplete( IN struct _FILE_OBJECT *FileObject,
 430                            IN PLARGE_INTEGER FileOffset,
 431                            IN PMDL MdlChain,
 432                            IN struct _DEVICE_OBJECT *DeviceObject)
 433 {
 434     UNREFERENCED_PARAMETER(FileObject);
 435     UNREFERENCED_PARAMETER(FileOffset);
 436     UNREFERENCED_PARAMETER(MdlChain);
 437     UNREFERENCED_PARAMETER(DeviceObject);
 438
 439     BOOLEAN bStatus = FALSE;
 440
 441     return bStatus;
 442 }
 443
 444 NTSTATUS
 445 AFSFastIoAcquireForCCFlush( IN struct _FILE_OBJECT *FileObject,
 446                             IN struct _DEVICE_OBJECT *DeviceObject)
 447 {
 448     UNREFERENCED_PARAMETER(DeviceObject);
 449
 450     NTSTATUS ntStatus = STATUS_FILE_LOCK_CONFLICT;
 451     AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
 452
 453     AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 454                   AFS_TRACE_LEVEL_VERBOSE,
 455                   "AFSFastIoAcquireForCCFlush Acquiring Fcb PagingIo lock %p SHARED %08lX\n",
 456                   &pFcb->NPFcb->PagingResource,
 457                   PsGetCurrentThread()));
 458
 459     AFSAcquireShared( &pFcb->NPFcb->PagingResource,
 460                       TRUE);
 461
 462     if( !ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->SectionObjectResource))
 463     {
 464
 465         AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 466                       AFS_TRACE_LEVEL_VERBOSE,
 467                       "AFSFastIoAcquireForCCFlush Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
 468                       &pFcb->NPFcb->SectionObjectResource,
 469                       PsGetCurrentThread()));
 470
 471         AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
 472                         TRUE);
 473     }
 474     else
 475     {
 476
 477         AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 478                       AFS_TRACE_LEVEL_VERBOSE,
 479                       "AFSFastIoAcquireForCCFlush Acquiring Fcb SectionObject lock %p SHARED %08lX\n",
 480                       &pFcb->NPFcb->SectionObjectResource,
 481                       PsGetCurrentThread()));
 482
 483         AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
 484                           TRUE);
 485     }
 486
 487     ntStatus = STATUS_SUCCESS;
 488
 489     //
 490     // Set the TopLevelIrp field for this caller
 491     //
 492
 493     if( IoGetTopLevelIrp() == NULL)
 494     {
 495
 496         IoSetTopLevelIrp( (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 497     }
 498
 499     return ntStatus;
 500 }
 501
 502 NTSTATUS
 503 AFSFastIoReleaseForCCFlush( IN struct _FILE_OBJECT *FileObject,
 504                             IN struct _DEVICE_OBJECT *DeviceObject)
 505 {
 506     UNREFERENCED_PARAMETER(DeviceObject);
 507
 508     NTSTATUS ntStatus = STATUS_SUCCESS;
 509     AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
 510
 511     if( IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP)
 512     {
 513
 514         IoSetTopLevelIrp( NULL);
 515     }
 516
 517     if( ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->PagingResource))
 518     {
 519
 520         AFSReleaseResource( &pFcb->NPFcb->PagingResource);
 521     }
 522     else
 523     {
 524
 525         AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
 526                       AFS_TRACE_LEVEL_ERROR,
 527                       "AFSFastIoReleaseForCCFlush Called for non-acquired paging resource Fcb\n"));
 528     }
 529
 530     if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->SectionObjectResource) ||
 531         ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->SectionObjectResource))
 532     {
 533
 534         AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
 535     }
 536     else
 537     {
 538
 539         AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
 540                       AFS_TRACE_LEVEL_ERROR,
 541                       "AFSFastIoReleaseForCCFlush Called for non-acquired SectionObject resource Fcb\n"));
 542     }
 543
 544     return ntStatus;
 545 }
 546
 547 BOOLEAN
 548 AFSFastIoReadCompressed( IN struct _FILE_OBJECT *FileObject,
 549                          IN PLARGE_INTEGER FileOffset,
 550                          IN ULONG Length,
 551                          IN ULONG LockKey,
 552                          OUT PVOID Buffer,
 553                          OUT PMDL *MdlChain,
 554                          OUT PIO_STATUS_BLOCK IoStatus,
 555                          OUT struct _COMPRESSED_DATA_INFO *CompressedDataInfo,
 556                          IN ULONG CompressedDataInfoLength,
 557                          IN struct _DEVICE_OBJECT *DeviceObject)
 558 {
 559     UNREFERENCED_PARAMETER(FileObject);
 560     UNREFERENCED_PARAMETER(FileOffset);
 561     UNREFERENCED_PARAMETER(Length);
 562     UNREFERENCED_PARAMETER(LockKey);
 563     UNREFERENCED_PARAMETER(Buffer);
 564     UNREFERENCED_PARAMETER(MdlChain);
 565     UNREFERENCED_PARAMETER(IoStatus);
 566     UNREFERENCED_PARAMETER(CompressedDataInfo);
 567     UNREFERENCED_PARAMETER(CompressedDataInfoLength);
 568     UNREFERENCED_PARAMETER(DeviceObject);
 569
 570     BOOLEAN bStatus = FALSE;
 571
 572     return bStatus;
 573 }
 574
 575 BOOLEAN
 576 AFSFastIoWriteCompressed( IN struct _FILE_OBJECT *FileObject,
 577                           IN PLARGE_INTEGER FileOffset,
 578                           IN ULONG Length,
 579                           IN ULONG LockKey,
 580                           IN PVOID Buffer,
 581                           OUT PMDL *MdlChain,
 582                           OUT PIO_STATUS_BLOCK IoStatus,
 583                           IN struct _COMPRESSED_DATA_INFO *CompressedDataInfo,
 584                           IN ULONG CompressedDataInfoLength,
 585                           IN struct _DEVICE_OBJECT *DeviceObject)
 586 {
 587     UNREFERENCED_PARAMETER(FileObject);
 588     UNREFERENCED_PARAMETER(FileOffset);
 589     UNREFERENCED_PARAMETER(Length);
 590     UNREFERENCED_PARAMETER(LockKey);
 591     UNREFERENCED_PARAMETER(Buffer);
 592     UNREFERENCED_PARAMETER(MdlChain);
 593     UNREFERENCED_PARAMETER(IoStatus);
 594     UNREFERENCED_PARAMETER(CompressedDataInfo);
 595     UNREFERENCED_PARAMETER(CompressedDataInfoLength);
 596     UNREFERENCED_PARAMETER(DeviceObject);
 597
 598     BOOLEAN bStatus = FALSE;
 599
 600     return bStatus;
 601 }
 602
 603 BOOLEAN
 604 AFSFastIoMdlReadCompleteCompressed( IN struct _FILE_OBJECT *FileObject,
 605                                     IN PMDL MdlChain,
 606                                     IN struct _DEVICE_OBJECT *DeviceObject)
 607 {
 608     UNREFERENCED_PARAMETER(FileObject);
 609     UNREFERENCED_PARAMETER(MdlChain);
 610     UNREFERENCED_PARAMETER(DeviceObject);
 611
 612     BOOLEAN bStatus = FALSE;
 613
 614     return bStatus;
 615 }
 616
 617 BOOLEAN
 618 AFSFastIoMdlWriteCompleteCompressed( IN struct _FILE_OBJECT *FileObject,
 619                                      IN PLARGE_INTEGER FileOffset,
 620                                      IN PMDL MdlChain,
 621                                      IN struct _DEVICE_OBJECT *DeviceObject)
 622 {
 623     UNREFERENCED_PARAMETER(FileObject);
 624     UNREFERENCED_PARAMETER(FileOffset);
 625     UNREFERENCED_PARAMETER(MdlChain);
 626     UNREFERENCED_PARAMETER(DeviceObject);
 627
 628     BOOLEAN bStatus = FALSE;
 629
 630     return bStatus;
 631 }
 632
 633 BOOLEAN
 634 AFSFastIoQueryOpen( IN struct _IRP *Irp,
 635                     OUT PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
 636                     IN struct _DEVICE_OBJECT *DeviceObject)
 637 {
 638     UNREFERENCED_PARAMETER(Irp);
 639     UNREFERENCED_PARAMETER(NetworkInformation);
 640     UNREFERENCED_PARAMETER(DeviceObject);
 641
 642     BOOLEAN bStatus = FALSE;
 643
 644     return bStatus;
 645 }