2 * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3 * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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
14 * this list of conditions and the following disclaimer in the
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.
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.
39 #include "AFSCommon.h"
43 AFSCachedRead( IN PDEVICE_OBJECT DeviceObject,
45 IN LARGE_INTEGER StartingByte,
48 UNREFERENCED_PARAMETER(DeviceObject);
49 NTSTATUS ntStatus = STATUS_SUCCESS;
50 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
51 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
52 BOOLEAN bSynchronousIo = BooleanFlagOn( pFileObject->Flags, FO_SYNCHRONOUS_IO);
53 VOID *pSystemBuffer = NULL;
54 ULONG ulCurrentIO = 0, ulTotalLen = ByteCount;
55 PMDL pCurrentMdl = Irp->MdlAddress;
56 LARGE_INTEGER liCurrentOffset;
61 Irp->IoStatus.Information = 0;
63 liCurrentOffset.QuadPart = StartingByte.QuadPart;
65 while( ulTotalLen > 0)
68 ntStatus = STATUS_SUCCESS;
70 if( pCurrentMdl != NULL)
73 ASSERT( pCurrentMdl != NULL);
75 pSystemBuffer = MmGetSystemAddressForMdlSafe( pCurrentMdl,
78 ulCurrentIO = MmGetMdlByteCount( pCurrentMdl);
80 if( ulCurrentIO > ulTotalLen)
82 ulCurrentIO = ulTotalLen;
88 pSystemBuffer = AFSLockSystemBuffer( Irp,
91 ulCurrentIO = ulTotalLen;
94 if( pSystemBuffer == NULL)
97 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
98 AFS_TRACE_LEVEL_ERROR,
99 "AFSCachedRead (%p) Failed to lock system buffer\n",
102 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
108 if( !CcCopyRead( pFileObject,
117 // Failed to process request.
120 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
121 AFS_TRACE_LEVEL_ERROR,
122 "AFSCachedRead (%p) Failed CcCopyRead() %wZ @ %0I64X Status %08lX\n",
124 &pFileObject->FileName,
125 liCurrentOffset.QuadPart,
126 Irp->IoStatus.Status));
128 try_return( ntStatus = Irp->IoStatus.Status);
131 __except( EXCEPTION_EXECUTE_HANDLER)
133 ntStatus = GetExceptionCode();
135 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
136 AFS_TRACE_LEVEL_ERROR,
137 "AFSCachedRead (%p) CcCopyRead() Threw exception %wZ @ %0I64X Status %08lX\n",
139 &pFileObject->FileName,
140 liCurrentOffset.QuadPart,
144 if( !NT_SUCCESS( ntStatus))
147 try_return( ntStatus);
150 if( ulTotalLen <= ulCurrentIO)
155 liCurrentOffset.QuadPart += ulCurrentIO;
157 ulTotalLen -= ulCurrentIO;
159 pCurrentMdl = pCurrentMdl->Next;
164 if( NT_SUCCESS( ntStatus))
167 Irp->IoStatus.Information = ByteCount;
170 // Update the CBO if this is a sync read
176 pFileObject->CurrentByteOffset.QuadPart = StartingByte.QuadPart + ByteCount;
180 AFSCompleteRequest( Irp,
189 AFSNonCachedRead( IN PDEVICE_OBJECT DeviceObject,
191 IN LARGE_INTEGER StartingByte)
193 NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
194 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
195 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
196 AFSFcb *pFcb = (AFSFcb *)pFileObject->FsContext;
197 AFSCcb *pCcb = (AFSCcb *)pFileObject->FsContext2;
198 VOID *pSystemBuffer = NULL;
199 BOOLEAN bPagingIo = BooleanFlagOn( Irp->Flags, IRP_PAGING_IO);
200 BOOLEAN bLocked = FALSE;
201 AFSGatherIo *pGatherIo = NULL;
202 AFSIoRun *pIoRuns = NULL;
203 AFSIoRun stIoRuns[AFS_MAX_STACK_IO_RUNS];
204 ULONG extentsCount = 0, runCount = 0;
205 AFSExtent *pStartExtent = NULL;
206 AFSExtent *pIgnoreExtent = NULL;
207 BOOLEAN bCompleteIrp = TRUE;
208 ULONG ulReadByteCount;
210 AFSDeviceExt *pDevExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
211 LARGE_INTEGER liCurrentTime, liLastRequestTime;
212 AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
213 PFILE_OBJECT pCacheFileObject = NULL;
218 ulByteCount = pIrpSp->Parameters.Read.Length;
220 if (ulByteCount > pDevExt->Specific.RDR.MaxIo.QuadPart)
223 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
224 AFS_TRACE_LEVEL_ERROR,
225 "AFSNonCachedRead (%p) Request larger than MaxIO %I64X\n",
227 pDevExt->Specific.RDR.MaxIo.QuadPart));
229 try_return( ntStatus = STATUS_UNSUCCESSFUL);
232 pSystemBuffer = AFSLockSystemBuffer( Irp,
235 if( pSystemBuffer == NULL)
238 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
239 AFS_TRACE_LEVEL_ERROR,
240 "AFSNonCachedRead (%p) Failed to map system buffer\n",
243 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
246 if( StartingByte.QuadPart + ulByteCount > pFcb->Header.FileSize.QuadPart)
248 ULONG zeroCount = (ULONG) (StartingByte.QuadPart + ulByteCount - pFcb->Header.FileSize.QuadPart);
249 ulReadByteCount = (ULONG)(pFcb->Header.FileSize.QuadPart - StartingByte.QuadPart);
255 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
256 AFS_TRACE_LEVEL_VERBOSE,
257 "AFSNonCachedRead (%p) Zeroing to EOF zero byte length %08lX\n",
261 RtlZeroMemory( ((PCHAR)pSystemBuffer) + ulReadByteCount, zeroCount);
265 ulReadByteCount = ulByteCount;
269 // Provoke a get of the extents - if we need to.
274 AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
275 AFS_TRACE_LEVEL_VERBOSE,
276 "AFSNonCachedRead Requesting extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
277 pFcb->ObjectInformation->FileId.Cell,
278 pFcb->ObjectInformation->FileId.Volume,
279 pFcb->ObjectInformation->FileId.Vnode,
280 pFcb->ObjectInformation->FileId.Unique,
281 StartingByte.QuadPart,
284 ntStatus = AFSRequestExtentsAsync( pFcb,
289 if (!NT_SUCCESS(ntStatus))
292 AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
293 AFS_TRACE_LEVEL_ERROR,
294 "AFSNonCachedRead (%p) Failed to request extents Status %08lX\n",
298 try_return( ntStatus);
301 KeQueryTickCount( &liLastRequestTime);
306 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
307 AFS_TRACE_LEVEL_VERBOSE,
308 "AFSNonCachedRead Acquiring Fcb extents lock %p SHARED %08lX\n",
309 &pFcb->NPFcb->Specific.File.ExtentsResource,
310 PsGetCurrentThread()));
312 AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource, TRUE );
316 pIgnoreExtent = NULL;
318 if( AFSDoExtentsMapRegion( pFcb,
327 KeClearEvent( &pFcb->NPFcb->Specific.File.ExtentsRequestComplete);
329 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
330 AFS_TRACE_LEVEL_VERBOSE,
331 "AFSNonCachedRead Releasing Fcb extents lock %p SHARED %08lX\n",
332 &pFcb->NPFcb->Specific.File.ExtentsResource,
333 PsGetCurrentThread()));
335 AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
339 // We will re-request the extents after 10 seconds of waiting for them
342 KeQueryTickCount( &liCurrentTime);
344 if( liCurrentTime.QuadPart - liLastRequestTime.QuadPart >= pControlDevExt->Specific.Control.ExtentRequestTimeCount.QuadPart)
347 AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
348 AFS_TRACE_LEVEL_VERBOSE,
349 "AFSNonCachedRead Requesting extents, again, for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
350 pFcb->ObjectInformation->FileId.Cell,
351 pFcb->ObjectInformation->FileId.Volume,
352 pFcb->ObjectInformation->FileId.Vnode,
353 pFcb->ObjectInformation->FileId.Unique,
354 StartingByte.QuadPart,
357 ntStatus = AFSRequestExtentsAsync( pFcb,
362 if (!NT_SUCCESS(ntStatus))
365 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
366 AFS_TRACE_LEVEL_ERROR,
367 "AFSNonCachedRead (%p) Failed to request extents Status %08lX\n",
371 try_return( ntStatus);
374 KeQueryTickCount( &liLastRequestTime);
377 AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
378 AFS_TRACE_LEVEL_VERBOSE,
379 "AFSNonCachedRead Waiting for extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
380 pFcb->ObjectInformation->FileId.Cell,
381 pFcb->ObjectInformation->FileId.Volume,
382 pFcb->ObjectInformation->FileId.Vnode,
383 pFcb->ObjectInformation->FileId.Unique,
384 StartingByte.QuadPart,
387 ntStatus = AFSWaitForExtentMapping ( pFcb, pCcb);
389 if (!NT_SUCCESS(ntStatus))
392 AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
393 AFS_TRACE_LEVEL_ERROR,
394 "AFSNonCachedRead Failed wait for extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX Status %08lX\n",
395 pFcb->ObjectInformation->FileId.Cell,
396 pFcb->ObjectInformation->FileId.Volume,
397 pFcb->ObjectInformation->FileId.Vnode,
398 pFcb->ObjectInformation->FileId.Unique,
399 StartingByte.QuadPart,
403 try_return( ntStatus);
408 // At this stage we know that the extents are fully mapped and
409 // that, because we took a reference they won't be unmapped.
410 // Thus the list will not move between the start and end.
413 AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
414 AFS_TRACE_LEVEL_VERBOSE,
415 "AFSNonCachedRead Extents mapped for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
416 pFcb->ObjectInformation->FileId.Cell,
417 pFcb->ObjectInformation->FileId.Volume,
418 pFcb->ObjectInformation->FileId.Vnode,
419 pFcb->ObjectInformation->FileId.Unique,
420 StartingByte.QuadPart,
423 ntStatus = AFSGetExtents( pFcb,
430 if (!NT_SUCCESS(ntStatus))
433 AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
434 AFS_TRACE_LEVEL_ERROR,
435 "AFSNonCachedRead (%p) Failed to retrieve mapped extents Status %08lX\n",
439 try_return( ntStatus );
442 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
443 AFS_TRACE_LEVEL_VERBOSE,
444 "AFSNonCachedRead (%p) Successfully retrieved map extents count %d run count %d\n",
449 if( BooleanFlagOn( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE))
452 Irp->IoStatus.Information = ulReadByteCount;
454 ntStatus = AFSProcessExtentRun( pSystemBuffer,
460 if (!NT_SUCCESS(ntStatus))
463 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
464 AFS_TRACE_LEVEL_ERROR,
465 "AFSNonCachedRead (%p) Failed to process extent run for non-persistent cache Status %08lX\n",
470 try_return( ntStatus);
474 // Retrieve the cache file object
477 pCacheFileObject = AFSReferenceCacheFileObject();
479 if( pCacheFileObject == NULL)
482 ntStatus = STATUS_DEVICE_NOT_READY;
484 AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
485 AFS_TRACE_LEVEL_ERROR,
486 "AFSNonCachedRead Failed to retrieve cache fileobject for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX Status %08lX\n",
487 pFcb->ObjectInformation->FileId.Cell,
488 pFcb->ObjectInformation->FileId.Volume,
489 pFcb->ObjectInformation->FileId.Vnode,
490 pFcb->ObjectInformation->FileId.Unique,
491 StartingByte.QuadPart,
495 try_return( ntStatus);
498 if (runCount > AFS_MAX_STACK_IO_RUNS)
501 pIoRuns = (AFSIoRun*) AFSExAllocatePoolWithTag( PagedPool,
502 runCount * sizeof( AFSIoRun ),
507 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
508 AFS_TRACE_LEVEL_ERROR,
509 "AFSNonCachedRead (%p) Failed to allocate IO run block\n",
512 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
521 RtlZeroMemory( pIoRuns, runCount * sizeof( AFSIoRun ));
523 ntStatus = AFSSetupIoRun( IoGetRelatedDeviceObject( pCacheFileObject),
532 if (!NT_SUCCESS(ntStatus))
535 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
536 AFS_TRACE_LEVEL_ERROR,
537 "AFSNonCachedRead (%p) Failed to initialize IO run block Status %08lX\n",
541 try_return( ntStatus );
544 AFSReferenceActiveExtents( pStartExtent,
547 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
548 AFS_TRACE_LEVEL_VERBOSE,
549 "AFSNonCachedRead Releasing Fcb extents lock %p SHARED %08lX\n",
550 &pFcb->NPFcb->Specific.File.ExtentsResource,
551 PsGetCurrentThread()));
553 AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
556 pGatherIo = (AFSGatherIo*) AFSExAllocatePoolWithTag( NonPagedPool,
557 sizeof( AFSGatherIo ),
560 if (NULL == pGatherIo)
563 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
564 AFS_TRACE_LEVEL_ERROR,
565 "AFSNonCachedRead (%p) Failed to allocate IO gather block\n",
568 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
569 AFS_TRACE_LEVEL_VERBOSE,
570 "AFSNonCachedRead Acquiring(2) Fcb extents lock %p SHARED %08lX\n",
571 &pFcb->NPFcb->Specific.File.ExtentsResource,
572 PsGetCurrentThread()));
574 AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
578 AFSDereferenceActiveExtents( pStartExtent,
581 try_return (ntStatus = STATUS_INSUFFICIENT_RESOURCES );
584 RtlZeroMemory( pGatherIo, sizeof( AFSGatherIo ));
587 // Initialize count to 1, that was we won't get an early
588 // completion if the first irp completes before the second is
591 pGatherIo->Count = 1;
592 pGatherIo->Status = STATUS_SUCCESS;
593 pGatherIo->MasterIrp = Irp;
594 pGatherIo->Synchronous = TRUE;
595 pGatherIo->Fcb = pFcb;
596 pGatherIo->CompleteMasterIrp = FALSE;
600 if (pGatherIo->Synchronous)
602 KeInitializeEvent( &pGatherIo->Event, NotificationEvent, FALSE );
606 IoMarkIrpPending( Irp);
610 // Pre-emptively set up the count
613 Irp->IoStatus.Information = ulByteCount;
615 ntStatus = AFSQueueStartIos( pCacheFileObject,
617 IRP_READ_OPERATION | IRP_SYNCHRONOUS_API,
622 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
623 AFS_TRACE_LEVEL_VERBOSE,
624 "AFSNonCachedRead (%p) AFSStartIos completed Status %08lX\n",
628 if( !NT_SUCCESS( ntStatus))
631 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
632 AFS_TRACE_LEVEL_VERBOSE,
633 "AFSNonCachedRead Acquiring(3) Fcb extents lock %p SHARED %08lX\n",
634 &pFcb->NPFcb->Specific.File.ExtentsResource,
635 PsGetCurrentThread()));
637 AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
641 AFSDereferenceActiveExtents( pStartExtent,
644 try_return( ntStatus);
648 // Wait for completion of all IOs we started.
650 (VOID) KeWaitForSingleObject( &pGatherIo->Event,
656 ntStatus = pGatherIo->Status;
658 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
659 AFS_TRACE_LEVEL_VERBOSE,
660 "AFSNonCachedRead (%p) AFSStartIos wait completed Status %08lX\n",
664 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
665 AFS_TRACE_LEVEL_VERBOSE,
666 "AFSNonCachedRead Acquiring(4) Fcb extents lock %p SHARED %08lX\n",
667 &pFcb->NPFcb->Specific.File.ExtentsResource,
668 PsGetCurrentThread()));
670 AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
674 AFSDereferenceActiveExtents( pStartExtent,
677 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
678 AFS_TRACE_LEVEL_VERBOSE,
679 "AFSNonCachedRead Releasing Fcb extents lock %p SHARED %08lX\n",
680 &pFcb->NPFcb->Specific.File.ExtentsResource,
681 PsGetCurrentThread()));
683 AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
687 // The data is there now. Give back the extents now so the service
691 if ( pFcb->Specific.File.ExtentLength > 4096)
694 (VOID) AFSReleaseExtentsWithFlush( pFcb,
701 if( pCacheFileObject != NULL)
703 AFSReleaseCacheFileObject( pCacheFileObject);
706 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
707 AFS_TRACE_LEVEL_VERBOSE,
708 "AFSNonCachedRead (%p) Completed request Status %08lX\n",
712 if (NT_SUCCESS(ntStatus) &&
714 BooleanFlagOn( pFileObject->Flags, FO_SYNCHRONOUS_IO))
717 // Update the CBO if this is a sync, nopaging read
719 pFileObject->CurrentByteOffset.QuadPart = StartingByte.QuadPart + ulByteCount;
725 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
726 AFS_TRACE_LEVEL_VERBOSE,
727 "AFSNonCachedRead Releasing Fcb extents lock %p SHARED %08lX\n",
728 &pFcb->NPFcb->Specific.File.ExtentsResource,
729 PsGetCurrentThread()));
731 AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
736 AFSExFreePoolWithTag(pGatherIo, AFS_GATHER_TAG);
739 if (NULL != pIoRuns && stIoRuns != pIoRuns)
741 AFSExFreePoolWithTag(pIoRuns, AFS_IO_RUN_TAG);
747 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
748 AFS_TRACE_LEVEL_VERBOSE,
749 "AFSNonCachedRead Completing irp %08lX Status %08lX Info %08lX\n",
752 Irp->IoStatus.Information));
754 AFSCompleteRequest( Irp, ntStatus );
762 AFSNonCachedReadDirect( IN PDEVICE_OBJECT DeviceObject,
764 IN LARGE_INTEGER StartingByte)
766 NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
767 IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
768 PFILE_OBJECT pFileObject = pIrpSp->FileObject;
769 AFSFcb *pFcb = (AFSFcb *)pFileObject->FsContext;
770 AFSCcb *pCcb = (AFSCcb *)pFileObject->FsContext2;
771 VOID *pSystemBuffer = NULL;
772 ULONG ulByteCount = 0;
773 ULONG ulReadByteCount = 0;
775 BOOLEAN bNoIntermediateBuffering = BooleanFlagOn( pFileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING);
776 AFSDeviceExt *pDevExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
777 AFSFileIOCB stFileIORequest;
778 AFSFileIOResultCB stFileIOResult;
779 ULONG ulResultLen = 0;
784 Irp->IoStatus.Information = 0;
786 ulByteCount = pIrpSp->Parameters.Read.Length;
788 if (ulByteCount > pDevExt->Specific.RDR.MaxIo.QuadPart)
791 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
792 AFS_TRACE_LEVEL_ERROR,
793 "AFSNonCachedReadDirect (%p) Request larger than MaxIO %I64X\n",
795 pDevExt->Specific.RDR.MaxIo.QuadPart));
797 try_return( ntStatus = STATUS_UNSUCCESSFUL);
800 pSystemBuffer = AFSLockSystemBuffer( Irp,
803 if( pSystemBuffer == NULL)
806 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
807 AFS_TRACE_LEVEL_ERROR,
808 "AFSNonCachedReadDirect (%p) Failed to map system buffer\n",
811 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
814 if( StartingByte.QuadPart + ulByteCount > pFcb->Header.FileSize.QuadPart)
816 ULONG zeroCount = (ULONG) (StartingByte.QuadPart + ulByteCount - pFcb->Header.FileSize.QuadPart);
817 ulReadByteCount = (ULONG)(pFcb->Header.FileSize.QuadPart - StartingByte.QuadPart);
823 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
824 AFS_TRACE_LEVEL_VERBOSE,
825 "AFSNonCachedReadDirect (%p) Zeroing to EOF zero byte length %08lX\n",
829 RtlZeroMemory( ((PCHAR)pSystemBuffer) + ulReadByteCount, zeroCount);
833 ulReadByteCount = ulByteCount;
837 // Issue the request at the service for processing
840 ulResultLen = sizeof( AFSFileIOResultCB);
842 RtlZeroMemory( &stFileIORequest,
843 sizeof( AFSFileIOCB));
845 RtlZeroMemory( &stFileIOResult,
846 sizeof( AFSFileIOResultCB));
848 stFileIORequest.SystemIOBuffer = pSystemBuffer;
850 stFileIORequest.SystemIOBufferMdl = Irp->MdlAddress;
852 stFileIORequest.IOOffset = StartingByte;
854 stFileIORequest.IOLength = ulReadByteCount;
856 ulFlags = AFS_REQUEST_FLAG_SYNCHRONOUS;
858 if ( bNoIntermediateBuffering)
861 ulFlags |= AFS_REQUEST_FLAG_CACHE_BYPASS;
864 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PROCESS_READ_FILE,
867 &pCcb->DirectoryCB->NameInformation.FileName,
868 &pFcb->ObjectInformation->FileId,
869 pFcb->ObjectInformation->VolumeCB->VolumeInformation.Cell,
870 pFcb->ObjectInformation->VolumeCB->VolumeInformation.CellLength,
872 sizeof( AFSFileIOCB),
876 if( NT_SUCCESS( ntStatus))
879 Irp->IoStatus.Information = (ULONG_PTR)stFileIOResult.Length;
884 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
885 AFS_TRACE_LEVEL_ERROR,
886 "AFSNonCachedReadDirect (%p) Failed to send read to service Status %08lX\n",
893 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
894 AFS_TRACE_LEVEL_VERBOSE,
895 "AFSNonCachedReadDirect (%p) Completed request Status %08lX\n",
899 if (NT_SUCCESS(ntStatus) &&
900 !BooleanFlagOn( Irp->Flags, IRP_PAGING_IO) &&
901 BooleanFlagOn( pFileObject->Flags, FO_SYNCHRONOUS_IO))
904 // Update the CBO if this is a sync, nopaging read
906 pFileObject->CurrentByteOffset.QuadPart = StartingByte.QuadPart + ulByteCount;
909 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
910 AFS_TRACE_LEVEL_VERBOSE,
911 "AFSNonCachedReadDirect Completing irp %08lX Status %08lX Info %08lX\n",
914 Irp->IoStatus.Information));
916 AFSCompleteRequest( Irp, ntStatus );
923 // Function: AFSDispatch
927 // A shim around AFSCommonRead (qv)
930 AFSRead( IN PDEVICE_OBJECT LibDeviceObject,
934 UNREFERENCED_PARAMETER(LibDeviceObject);
935 NTSTATUS ntStatus = STATUS_SUCCESS;
940 ntStatus = AFSCommonRead( AFSRDRDeviceObject, Irp, NULL);
942 __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
945 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
947 AFSDumpTraceFilesFnc();
957 // This function is a slightly widened Dispatch handler for the
958 // AFS Read function. The third parameter is NULL if we were called
959 // at our dispatch point and a process handle if we have been posted.
961 // After doing the obvious (completing MDL writes and so forth)
962 // we then post, or not.
966 // A status is returned for the function
970 AFSCommonRead( IN PDEVICE_OBJECT DeviceObject,
972 IN HANDLE OnBehalfOf)
975 UNREFERENCED_PARAMETER(OnBehalfOf);
976 NTSTATUS ntStatus = STATUS_SUCCESS;
977 AFSDeviceExt *pDeviceExt;
978 IO_STACK_LOCATION *pIrpSp;
981 BOOLEAN bReleaseMain = FALSE;
982 BOOLEAN bReleaseSectionObject = FALSE;
983 BOOLEAN bReleasePaging = FALSE;
984 BOOLEAN bPagingIo = FALSE;
985 BOOLEAN bNonCachedIo = FALSE;
986 BOOLEAN bCompleteIrp = TRUE;
987 PFILE_OBJECT pFileObject = NULL;
988 LARGE_INTEGER liStartingByte;
990 AFSDeviceExt *pRDRDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
992 pIrpSp = IoGetCurrentIrpStackLocation( Irp);
993 pDeviceExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
998 // Decode the fileobject
1000 pFileObject = pIrpSp->FileObject;
1003 // There is a risk (albeit infinitely small) that the Irp will
1004 // complete before this function exits, then a cleanup and
1005 // close will happen and the FCB will be torn down before we
1006 // get to the try_exit. Pin the file Object which will pin the FCB
1009 ObReferenceObject( pFileObject);
1012 // If we are in shutdown mode then fail the request
1015 if( BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
1018 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
1019 AFS_TRACE_LEVEL_WARNING,
1020 "AFSCommonRead (%p) Open request after shutdown\n",
1023 try_return( ntStatus = STATUS_TOO_LATE);
1026 pFcb = (AFSFcb *)pFileObject->FsContext;
1028 pCcb = (AFSCcb *)pFileObject->FsContext2;
1033 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1034 AFS_TRACE_LEVEL_ERROR,
1035 "AFSCommonRead Attempted read (%p) when pFcb == NULL\n",
1038 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
1041 bPagingIo = BooleanFlagOn( Irp->Flags, IRP_PAGING_IO);
1042 bNonCachedIo = BooleanFlagOn( Irp->Flags,IRP_NOCACHE);
1044 liStartingByte = pIrpSp->Parameters.Read.ByteOffset;
1045 ulByteCount = pIrpSp->Parameters.Read.Length;
1047 if( pFcb->Header.NodeTypeCode != AFS_IOCTL_FCB &&
1048 pFcb->Header.NodeTypeCode != AFS_FILE_FCB &&
1049 pFcb->Header.NodeTypeCode != AFS_SPECIAL_SHARE_FCB)
1052 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1053 AFS_TRACE_LEVEL_ERROR,
1054 "AFSCommonRead Attempted read (%p) on an invalid node type %08lX\n",
1056 pFcb->Header.NodeTypeCode));
1058 try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
1062 // If this is a read against an IOCtl node then handle it
1063 // in a different pathway
1066 if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
1069 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1070 AFS_TRACE_LEVEL_VERBOSE,
1071 "AFSCommonRead (%p) Processing file (PIOCTL) Offset %I64X Length %08lX Irp Flags %08lX\n",
1073 liStartingByte.QuadPart,
1077 ntStatus = AFSIOCtlRead( DeviceObject,
1080 try_return( ntStatus);
1082 else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
1085 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1086 AFS_TRACE_LEVEL_VERBOSE,
1087 "AFSCommonRead (%p) Processing file (SHARE) Offset %I64X Length %08lX Irp Flags %08lX\n",
1089 liStartingByte.QuadPart,
1093 ntStatus = AFSShareRead( DeviceObject,
1096 try_return( ntStatus);
1100 // No fileobject yet? Bail.
1102 if( !BooleanFlagOn( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE) &&
1103 !BooleanFlagOn( pRDRDevExt->DeviceFlags, AFS_REDIR_INIT_PERFORM_SERVICE_IO) &&
1104 NULL == pDeviceExt->Specific.RDR.CacheFileObject)
1107 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1108 AFS_TRACE_LEVEL_ERROR,
1109 "AFSCommonRead (%p) Request failed due to AFS cache closed\n",
1112 try_return( ntStatus = STATUS_TOO_LATE );
1115 if( pIrpSp->Parameters.Read.Length == 0)
1118 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1119 AFS_TRACE_LEVEL_VERBOSE,
1120 "AFSCommonRead (%p) Request completed due to zero length\n",
1123 try_return( ntStatus);
1126 if ( FlagOn(pIrpSp->MinorFunction, IRP_MN_COMPLETE) )
1129 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
1130 AFS_TRACE_LEVEL_VERBOSE,
1131 "AFSCommonRead Acquiring Fcb SectionObject lock %p SHARED %08lX\n",
1132 &pFcb->NPFcb->SectionObjectResource,
1133 PsGetCurrentThread()));
1135 AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
1138 bReleaseSectionObject = TRUE;
1143 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1144 AFS_TRACE_LEVEL_VERBOSE,
1145 "AFSCommonRead (%p) IRP_MN_COMPLETE being processed\n",
1148 CcMdlReadComplete(pIrpSp->FileObject, Irp->MdlAddress);
1151 // Mdl is now Deallocated
1154 Irp->MdlAddress = NULL;
1156 try_return( ntStatus = STATUS_SUCCESS );
1158 __except( EXCEPTION_EXECUTE_HANDLER)
1161 ntStatus = GetExceptionCode();
1165 "EXCEPTION - AFSCommonRead CcMdlReadComplete failed FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
1166 pFcb->ObjectInformation->FileId.Cell,
1167 pFcb->ObjectInformation->FileId.Volume,
1168 pFcb->ObjectInformation->FileId.Vnode,
1169 pFcb->ObjectInformation->FileId.Unique,
1172 try_return( ntStatus);
1177 // If we get a non cached IO for a cached file we should do a purge.
1178 // For now we will just promote to cached
1180 if (NULL != pFileObject->SectionObjectPointer->DataSectionObject && !bPagingIo)
1183 bNonCachedIo = FALSE;
1187 // We acquire the main/paging resource first to synchronize
1188 // against size checks.
1194 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
1195 AFS_TRACE_LEVEL_VERBOSE,
1196 "AFSCommonRead Acquiring Fcb PagingIo lock %p SHARED %08lX\n",
1197 &pFcb->NPFcb->PagingResource,
1198 PsGetCurrentThread()));
1200 AFSAcquireShared( &pFcb->NPFcb->PagingResource,
1203 bReleasePaging = TRUE;
1205 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
1206 AFS_TRACE_LEVEL_VERBOSE,
1207 "AFSCommonRead Acquiring Fcb SectionObject lock %p SHARED %08lX\n",
1208 &pFcb->NPFcb->SectionObjectResource,
1209 PsGetCurrentThread()));
1211 AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
1214 bReleaseSectionObject = TRUE;
1220 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
1221 AFS_TRACE_LEVEL_VERBOSE,
1222 "AFSCommonRead Acquiring Fcb SectionObject lock %p SHARED %08lX\n",
1223 &pFcb->NPFcb->SectionObjectResource,
1224 PsGetCurrentThread()));
1226 AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
1229 bReleaseSectionObject = TRUE;
1232 // Check the BR locks
1235 if( !FsRtlCheckLockForReadAccess( &pFcb->Specific.File.FileLock,
1239 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1240 AFS_TRACE_LEVEL_ERROR,
1241 "AFSCommonRead (%p) Request failed due to lock conflict\n",
1244 try_return( ntStatus = STATUS_FILE_LOCK_CONFLICT);
1248 if( BooleanFlagOn( pCcb->DirectoryCB->Flags, AFS_DIR_ENTRY_DELETED) ||
1249 BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
1252 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1253 AFS_TRACE_LEVEL_ERROR,
1254 "AFSCommonRead (%p) Request failed due to file deleted\n",
1257 try_return( ntStatus = STATUS_FILE_DELETED);
1261 // If the read starts beyond End of File, return EOF.
1264 if( liStartingByte.QuadPart >= pFcb->Header.FileSize.QuadPart)
1267 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1268 AFS_TRACE_LEVEL_VERBOSE,
1269 "AFSCommonRead (%p) Request beyond EOF %I64X\n",
1271 pFcb->Header.FileSize.QuadPart));
1273 try_return( ntStatus = STATUS_END_OF_FILE);
1279 if( liStartingByte.QuadPart + ulByteCount > pFcb->Header.FileSize.QuadPart)
1282 ulByteCount = (ULONG)(pFcb->Header.FileSize.QuadPart - liStartingByte.QuadPart);
1284 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1285 AFS_TRACE_LEVEL_VERBOSE,
1286 "AFSCommonRead (%p) Truncated read request to %08lX\n",
1292 // Is this Fcb valid???
1295 if( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID))
1298 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1299 AFS_TRACE_LEVEL_ERROR,
1300 "AFSCommonRead (%p) Failing request due to INVALID fcb\n",
1303 Irp->IoStatus.Information = 0;
1305 try_return( ntStatus = STATUS_FILE_DELETED);
1309 // If this is an cached IO
1311 if( (!bPagingIo && !bNonCachedIo))
1314 // This is a top level irp. Init the caching if it has not yet
1315 // been initialzed for this FO
1318 if( pFileObject->PrivateCacheMap == NULL)
1324 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1325 AFS_TRACE_LEVEL_VERBOSE,
1326 "AFSCommonRead Initialize caching on Fcb %p FO %p\n",
1330 CcInitializeCacheMap( pFileObject,
1331 (PCC_FILE_SIZES)&pFcb->Header.AllocationSize,
1333 AFSLibCacheManagerCallbacks,
1336 CcSetReadAheadGranularity( pFileObject,
1337 pDeviceExt->Specific.RDR.MaximumRPCLength);
1339 CcSetDirtyPageThreshold( pFileObject,
1340 AFS_DIRTY_CHUNK_THRESHOLD * pDeviceExt->Specific.RDR.MaximumRPCLength / 4096);
1342 __except( EXCEPTION_EXECUTE_HANDLER)
1345 ntStatus = GetExceptionCode();
1347 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1348 AFS_TRACE_LEVEL_ERROR,
1349 "AFSCommonRead (%p) Exception thrown while initializing cache map Status %08lX\n",
1354 if( !NT_SUCCESS( ntStatus))
1357 try_return( ntStatus);
1362 // And if this is MDL operation, deal with it now (yes we
1363 // could post, but we are almost certainly posted
1364 // already and we don't want to grow and SVA for it..)
1367 if( BooleanFlagOn( pIrpSp->MinorFunction, IRP_MN_MDL))
1372 CcMdlRead( pFileObject,
1377 ntStatus = Irp->IoStatus.Status;
1379 __except( EXCEPTION_EXECUTE_HANDLER)
1381 ntStatus = GetExceptionCode();
1383 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1384 AFS_TRACE_LEVEL_ERROR,
1385 "AFSCommonRead (%p) Exception thrown during mdl read Status %08lX\n",
1390 if( !NT_SUCCESS( ntStatus))
1393 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1394 AFS_TRACE_LEVEL_ERROR,
1395 "AFSCommonRead (%p) Failed to process MDL read Status %08lX\n",
1399 try_return( ntStatus);
1403 // Update the CBO if this is a sync read
1406 if( BooleanFlagOn( pFileObject->Flags, FO_SYNCHRONOUS_IO))
1409 pFileObject->CurrentByteOffset.QuadPart = liStartingByte.QuadPart + ulByteCount;
1412 try_return( ntStatus);
1417 // The called request completes the IRP for us.
1420 bCompleteIrp = FALSE;
1426 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1427 AFS_TRACE_LEVEL_VERBOSE,
1428 "AFSCommonRead (%p) Processing CACHED request Offset %I64X Len %08lX\n",
1430 liStartingByte.QuadPart,
1433 ntStatus = AFSCachedRead( DeviceObject, Irp, liStartingByte, ulByteCount);
1441 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
1443 bReleasePaging = FALSE;
1446 if( bReleaseSectionObject)
1449 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
1450 AFS_TRACE_LEVEL_VERBOSE,
1451 "AFSCommonRead Releasing Fcb SectionObject lock %p SHARED %08lX\n",
1452 &pFcb->NPFcb->SectionObjectResource,
1453 PsGetCurrentThread()));
1455 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
1457 bReleaseSectionObject = FALSE;
1463 AFSReleaseResource( &pFcb->NPFcb->Resource);
1465 bReleaseMain = FALSE;
1468 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1469 AFS_TRACE_LEVEL_VERBOSE,
1470 "AFSCommonRead (%p) Processing NON-CACHED request Offset %I64X Len %08lX\n",
1472 liStartingByte.QuadPart,
1475 if( BooleanFlagOn( pRDRDevExt->DeviceFlags, AFS_DEVICE_FLAG_DIRECT_SERVICE_IO))
1478 ntStatus = AFSNonCachedReadDirect( DeviceObject, Irp, liStartingByte);
1482 ntStatus = AFSNonCachedRead( DeviceObject, Irp, liStartingByte);
1488 AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
1489 AFS_TRACE_LEVEL_VERBOSE,
1490 "AFSCommonRead (%p) Process complete Status %08lX\n",
1497 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
1500 if( bReleaseSectionObject)
1503 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
1504 AFS_TRACE_LEVEL_VERBOSE,
1505 "AFSCommonRead (exit) Releasing Fcb SectionObject lock %p SHARED %08lX\n",
1506 &pFcb->NPFcb->SectionObjectResource,
1507 PsGetCurrentThread()));
1509 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
1515 AFSReleaseResource( &pFcb->NPFcb->Resource);
1521 AFSCompleteRequest( Irp, ntStatus);
1524 ObDereferenceObject( pFileObject);
1531 AFSIOCtlRead( IN PDEVICE_OBJECT DeviceObject,
1535 UNREFERENCED_PARAMETER(DeviceObject);
1536 NTSTATUS ntStatus = STATUS_SUCCESS;
1537 AFSPIOCtlIORequestCB stIORequestCB;
1538 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1539 AFSFcb *pFcb = NULL;
1540 AFSCcb *pCcb = NULL;
1541 AFSPIOCtlIOResultCB stIOResultCB;
1542 ULONG ulBytesReturned = 0;
1543 AFSFileID stParentFID;
1548 RtlZeroMemory( &stIORequestCB,
1549 sizeof( AFSPIOCtlIORequestCB));
1551 if( pIrpSp->Parameters.Read.Length == 0)
1555 // Nothing to do in this case
1558 try_return( ntStatus);
1561 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1563 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1565 AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
1566 AFS_TRACE_LEVEL_VERBOSE,
1567 "AFSIOCtlRead Acquiring Fcb lock %p SHARED %08lX\n",
1568 &pFcb->NPFcb->Resource,
1569 PsGetCurrentThread()));
1571 AFSAcquireShared( &pFcb->NPFcb->Resource,
1575 // Get the parent fid to pass to the cm
1578 RtlZeroMemory( &stParentFID,
1579 sizeof( AFSFileID));
1581 if( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
1585 // The parent directory FID of the node
1588 stParentFID = pFcb->ObjectInformation->ParentFileId;
1592 // Set the control block up
1595 stIORequestCB.RequestId = pCcb->RequestID;
1597 if( pFcb->ObjectInformation->VolumeCB != NULL)
1599 stIORequestCB.RootId = pFcb->ObjectInformation->VolumeCB->ObjectInformation.FileId;
1603 // Lock down the buffer
1606 stIORequestCB.MappedBuffer = AFSMapToService( Irp,
1607 pIrpSp->Parameters.Read.Length);
1609 if( stIORequestCB.MappedBuffer == NULL)
1612 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1615 stIORequestCB.BufferLength = pIrpSp->Parameters.Read.Length;
1617 stIOResultCB.BytesProcessed = 0;
1619 ulBytesReturned = sizeof( AFSPIOCtlIOResultCB);
1622 // Issue the request to the service
1625 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_READ,
1626 AFS_REQUEST_FLAG_SYNCHRONOUS,
1632 (void *)&stIORequestCB,
1633 sizeof( AFSPIOCtlIORequestCB),
1637 if( !NT_SUCCESS( ntStatus))
1640 try_return( ntStatus);
1644 // Update the length read
1647 Irp->IoStatus.Information = stIOResultCB.BytesProcessed;
1651 if( stIORequestCB.MappedBuffer != NULL)
1654 AFSUnmapServiceMappedBuffer( stIORequestCB.MappedBuffer,
1661 AFSReleaseResource( &pFcb->NPFcb->Resource);
1669 AFSShareRead( IN PDEVICE_OBJECT DeviceObject,
1673 UNREFERENCED_PARAMETER(DeviceObject);
1674 NTSTATUS ntStatus = STATUS_SUCCESS;
1675 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1676 AFSFcb *pFcb = NULL;
1677 AFSCcb *pCcb = NULL;
1678 ULONG ulBytesReturned = 0;
1679 void *pBuffer = NULL;
1680 AFSPipeIORequestCB stIoRequest;
1685 pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
1687 pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
1689 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
1690 AFS_TRACE_LEVEL_VERBOSE,
1691 "AFSShareRead On pipe %wZ Length %08lX\n",
1692 &pCcb->DirectoryCB->NameInformation.FileName,
1693 pIrpSp->Parameters.Read.Length));
1695 if( pIrpSp->Parameters.Read.Length == 0)
1699 // Nothing to do in this case
1702 try_return( ntStatus);
1705 AFSAcquireShared( &pFcb->NPFcb->Resource,
1709 // Retrieve the buffer for the read request
1712 pBuffer = AFSLockSystemBuffer( Irp,
1713 pIrpSp->Parameters.Read.Length);
1715 if( pBuffer == NULL)
1718 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
1719 AFS_TRACE_LEVEL_ERROR,
1720 "AFSShareRead Failed to map buffer on pipe %wZ\n",
1721 &pCcb->DirectoryCB->NameInformation.FileName));
1723 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1726 RtlZeroMemory( &stIoRequest,
1727 sizeof( AFSPipeIORequestCB));
1729 stIoRequest.RequestId = pCcb->RequestID;
1731 stIoRequest.RootId = pFcb->ObjectInformation->VolumeCB->ObjectInformation.FileId;
1733 stIoRequest.BufferLength = pIrpSp->Parameters.Read.Length;
1735 ulBytesReturned = pIrpSp->Parameters.Read.Length;
1738 // Issue the open request to the service
1741 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_READ,
1742 AFS_REQUEST_FLAG_SYNCHRONOUS,
1744 &pCcb->DirectoryCB->NameInformation.FileName,
1748 (void *)&stIoRequest,
1749 sizeof( AFSPipeIORequestCB),
1753 if( !NT_SUCCESS( ntStatus) &&
1754 ntStatus != STATUS_BUFFER_OVERFLOW)
1757 AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
1758 AFS_TRACE_LEVEL_ERROR,
1759 "AFSShareRead (%p) Failed service read Status %08lX\n",
1763 try_return( ntStatus);
1766 AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
1767 AFS_TRACE_LEVEL_VERBOSE,
1768 "AFSShareRead Completed on pipe %wZ Length read %08lX Status %08lX\n",
1769 &pCcb->DirectoryCB->NameInformation.FileName,
1773 Irp->IoStatus.Information = ulBytesReturned;
1780 AFSReleaseResource( &pFcb->NPFcb->Resource);