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 SectionObject lock %p 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         AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 287                       AFS_TRACE_LEVEL_VERBOSE,
 288                       "AFSFastIoReleaseFile Releasing Fcb SectionObject lock %p 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             AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 420                           AFS_TRACE_LEVEL_VERBOSE,
 421                           "AFSFastIoAcquireForModWrite Acquired Fcb SectionObject lock %p 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     AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 445                   AFS_TRACE_LEVEL_VERBOSE,
 446                   "AFSFastIoReleaseForModWrite Releasing lock %p 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     AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 465                   AFS_TRACE_LEVEL_VERBOSE,
 466                   "AFSFastIoAcquireForCCFlush Acquiring Fcb PagingIo lock %p 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         AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 477                       AFS_TRACE_LEVEL_VERBOSE,
 478                       "AFSFastIoAcquireForCCFlush Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
 479                       &pFcb->NPFcb->SectionObjectResource,
 480                       PsGetCurrentThread()));
 481
 482         AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
 483                         TRUE);
 484     }
 485     else
 486     {
 487
 488         AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
 489                       AFS_TRACE_LEVEL_VERBOSE,
 490                       "AFSFastIoAcquireForCCFlush Acquiring Fcb SectionObject lock %p 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         AFSDbgTrace(( 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         AFSDbgTrace(( 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 }