|
|
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
ReadSup.c
Abstract:
This module implements the Read support routine. This is a common read function that is called to do read, unbuffered read, peek, and transceive.
Author:
Gary Kimura [GaryKi] 20-Sep-1990
Revision History:
--*/
#include "NpProcs.h"
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_READSUP)
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, NpReadDataQueue)
#endif
IO_STATUS_BLOCKNpReadDataQueue ( IN PDATA_QUEUE ReadQueue, IN BOOLEAN PeekOperation, IN BOOLEAN ReadOverflowOperation, IN PUCHAR ReadBuffer, IN ULONG ReadLength, IN READ_MODE ReadMode, IN PCCB Ccb, IN PLIST_ENTRY DeferredList )
/*++
Routine Description:
This procedure reads data from the read queue and fills up the read buffer. It will also dequeue the queue or leave it alone based on an input parameter.
Arguments:
ReadQueue - Provides the read queue to examine. Its state must already be set to WriteEntries.
PeekOperation - Indicates if the operation is to dequeue information off of the queue as it is being read or leave the queue alone. TRUE means to leave the queue alone.
ReadOverflowOperation - Indicates if this is a read overflow operation. With read overflow we will not alter the named pipe if the data will overflow the read buffer.
ReadBuffer - Supplies a buffer to receive the data
ReadLength - Supplies the length, in bytes, of ReadBuffer.
ReadMode - Indicates if the read operation is message mode or byte stream mode.
NamedPipeEnd - Supplies the end of the named pipe doing the read
Ccb - Supplies the ccb for the pipe
DeferredList - List of IRP's to complete later after we drop locks
Return Value:
IO_STATUS_BLOCK - Indicates the result of the operation.
--*/
{ IO_STATUS_BLOCK Iosb= {0};
PDATA_ENTRY DataEntry;
ULONG ReadRemaining; ULONG AmountRead;
PUCHAR WriteBuffer; ULONG WriteLength; ULONG WriteRemaining; BOOLEAN StartStalled = FALSE;
ULONG AmountToCopy;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpReadDataQueue\n", 0); DebugTrace( 0, Dbg, "ReadQueue = %08lx\n", ReadQueue); DebugTrace( 0, Dbg, "PeekOperation = %08lx\n", PeekOperation); DebugTrace( 0, Dbg, "ReadOverflowOperation = %08lx\n", ReadOverflowOperation); DebugTrace( 0, Dbg, "ReadBuffer = %08lx\n", ReadBuffer); DebugTrace( 0, Dbg, "ReadLength = %08lx\n", ReadLength); DebugTrace( 0, Dbg, "ReadMode = %08lx\n", ReadMode); DebugTrace( 0, Dbg, "Ccb = %08lx\n", Ccb);
//
// If this is an overflow operation then we will force us to do peeks.
// Later when are determine that the opreation succeeded we will complete
// the write irp.
//
if (ReadOverflowOperation) {
PeekOperation = TRUE; }
//
// Now for every real data entry we loop until either we run out
// of data entries or until the read buffer is full
//
ReadRemaining = ReadLength; Iosb.Status = STATUS_SUCCESS; Iosb.Information = 0; AmountRead = 0;
for (DataEntry = (PeekOperation ? NpGetNextDataQueueEntry( ReadQueue, NULL ) : NpGetNextRealDataQueueEntry( ReadQueue, DeferredList ));
(DataEntry != (PDATA_ENTRY) &ReadQueue->Queue) && (ReadRemaining > 0);
DataEntry = (PeekOperation ? NpGetNextDataQueueEntry( ReadQueue, DataEntry ) : NpGetNextRealDataQueueEntry( ReadQueue, DeferredList ))) {
DebugTrace(0, Dbg, "Top of Loop\n", 0); DebugTrace(0, Dbg, "ReadRemaining = %08lx\n", ReadRemaining);
//
// If this is a peek operation then make sure we got a real
// data entry and not a close or flush
//
if (!PeekOperation || (DataEntry->DataEntryType == Buffered) || (DataEntry->DataEntryType == Unbuffered)) {
//
// Calculate how much data is in this entry. The write
// remaining is based on whether this is the first entry
// in the queue or a later data entry
//
if (DataEntry->DataEntryType == Unbuffered) { WriteBuffer = DataEntry->Irp->AssociatedIrp.SystemBuffer; } else { WriteBuffer = DataEntry->DataBuffer; }
WriteLength = DataEntry->DataSize; WriteRemaining = WriteLength;
if (DataEntry == NpGetNextDataQueueEntry( ReadQueue, NULL )) {
WriteRemaining -= ReadQueue->NextByteOffset; }
DebugTrace(0, Dbg, "WriteBuffer = %08lx\n", WriteBuffer); DebugTrace(0, Dbg, "WriteLength = %08lx\n", WriteLength); DebugTrace(0, Dbg, "WriteRemaining = %08lx\n", WriteRemaining);
//
// copy data from the write buffer at write offset to the
// read buffer at read offset by the mininum of write
// remaining or read remaining
//
AmountToCopy = (WriteRemaining < ReadRemaining ? WriteRemaining : ReadRemaining);
try {
RtlCopyMemory( &ReadBuffer[ ReadLength - ReadRemaining ], &WriteBuffer[ WriteLength - WriteRemaining ], AmountToCopy );
} except(EXCEPTION_EXECUTE_HANDLER) {
Iosb.Status = GetExceptionCode (); goto exit_1; }
//
// Update the Read and Write remaining counts, the total
// amount we've read and the next byte offset field in the
// read queue
//
ReadRemaining -= AmountToCopy; WriteRemaining -= AmountToCopy; AmountRead += AmountToCopy;
if (!PeekOperation) { DataEntry->QuotaCharged -= AmountToCopy; ReadQueue->QuotaUsed -= AmountToCopy; ReadQueue->NextByteOffset += AmountToCopy; StartStalled = TRUE; }
//
// Now update the security fields in the ccb
//
NpCopyClientContext( Ccb, DataEntry );
//
// If the remaining write length is greater than zero
// then we've filled up the read buffer so we need to
// figure out if its an overflow error
//
if (WriteRemaining > 0 || (ReadOverflowOperation && (AmountRead == 0))) {
DebugTrace(0, Dbg, "Write remaining is > 0\n", 0);
if (ReadMode == FILE_PIPE_MESSAGE_MODE) {
DebugTrace(0, Dbg, "Overflow message mode read\n", 0);
//
// Set the status field and break out of the for-loop.
//
Iosb.Status = STATUS_BUFFER_OVERFLOW; break; }
} else {
DebugTrace(0, Dbg, "Remaining Write is zero\n", 0);
//
// The write entry is done so remove it from the read
// queue, if this is not a peek operation. This might
// also have an Irp that needs to be completed
//
if (!PeekOperation || ReadOverflowOperation) {
PIRP WriteIrp;
//
// For a read overflow operation we need to get the read data
// queue entry and remove it.
//
if (ReadOverflowOperation) { PDATA_ENTRY TempDataEntry; TempDataEntry = NpGetNextRealDataQueueEntry( ReadQueue, DeferredList ); ASSERT(TempDataEntry == DataEntry); }
if ((WriteIrp = NpRemoveDataQueueEntry( ReadQueue, TRUE, DeferredList)) != NULL) { WriteIrp->IoStatus.Information = WriteLength; NpDeferredCompleteRequest( WriteIrp, STATUS_SUCCESS, DeferredList ); } }
//
// And if we are doing message mode reads then we'll
// work on completing this irp without going back
// to the top of the loop
//
if (ReadMode == FILE_PIPE_MESSAGE_MODE) {
DebugTrace(0, Dbg, "Successful message mode read\n", 0);
//
// Set the status field and break out of the for-loop.
//
Iosb.Status = STATUS_SUCCESS; break; }
ASSERTMSG("Srv cannot use read overflow on a byte stream pipe ", !ReadOverflowOperation); } } }
DebugTrace(0, Dbg, "End of loop, AmountRead = %08lx\n", AmountRead);
Iosb.Information = AmountRead;
exit_1: if (StartStalled) { NpCompleteStalledWrites (ReadQueue, DeferredList); }
DebugTrace(-1, Dbg, "NpReadDataQueue -> Iosb.Status = %08lx\n", Iosb.Status); return Iosb;}
|
