|
|
/*++
Copyright (C) Microsoft Corporation, 2000
Module Name:
protocol.c
Abstract:
This file contains iSCSI protocol related routines.
Environment:
kernel mode only
Revision History:
--*/
#include "port.h"
LONG GlobalSessionID;LONG InitiatorSessionID;
#define ISCSI_TARGET "target:"
#define ISCSI_TARGET_LENGTH 7
#define ISCSI_USE_RTT "UseRtt:no"
#define ISCSI_USE_RTT_LENGTH 9
ULONGiSpGetActiveClientRequestIndex( PISCSI_CONNECTION IScsiConnection, ULONG TaskTag );
ULONGiSpGetReqIndexUsingCmdRN( PISCSI_CONNECTION IScsiConnection, ULONG CmdRN );
NTSTATUSiSpSendLoginCommand( IN PISCSI_PDO_EXTENSION PdoExtension ){ PISCSI_CONNECTION iScsiConnection; PISCSI_LOGIN_COMMAND iscsiLoginCommand; PUCHAR loginParameters; NTSTATUS status; ULONG bytesSent; ULONG tempULong; ULONG packetSize; ULONG targetLength;
iScsiConnection = PdoExtension->ClientNodeInfo;
ASSERT((iScsiConnection != NULL)); ASSERT((iScsiConnection->Type) == ISCSI_CONNECTION_TYPE);
targetLength = strlen(PdoExtension->TargetName); packetSize = (sizeof(ISCSI_LOGIN_COMMAND) + ISCSI_TARGET_LENGTH + targetLength + ISCSI_USE_RTT_LENGTH + 2);
iscsiLoginCommand = iSpAllocatePool( NonPagedPool, packetSize, ISCSI_TAG_LOGIN_CMD); if (iscsiLoginCommand == NULL) { DebugPrint((0, "Failed to allocate logon packet\n")); return STATUS_INSUFFICIENT_RESOURCES; }
RtlZeroMemory(iscsiLoginCommand, packetSize);
iscsiLoginCommand->OpCode = ISCSIOP_LOGIN_COMMAND;
//
// No authentication performed
//
iscsiLoginCommand->LoginType = ISCSI_LOGINTYPE_NONE;
//
// Connection ID for this session
//
tempULong = InterlockedIncrement(&GlobalSessionID); iscsiLoginCommand->ConnectionID[0] = (UCHAR) ((tempULong & 0xFF00) >> 8); iscsiLoginCommand->ConnectionID[1] = (UCHAR) (tempULong & 0xFF);
//
// Command Reference number starting from 1
//
iscsiLoginCommand->InitCmdRN[3] = 1;
tempULong = InterlockedIncrement(&InitiatorSessionID); iscsiLoginCommand->ISID[0] = (UCHAR) ((tempULong & 0xFF00) >> 8); iscsiLoginCommand->ISID[1] = (UCHAR) (tempULong & 0xFF);
//
// Identifier for the target device is passed as parameters
// in the Login packet
//
// "target:<TargetName>" -- Target device name
// "UseRtt:no" -- Do NOT use RTT
//
loginParameters = (PUCHAR) (iscsiLoginCommand + 1);
RtlCopyMemory(loginParameters, ISCSI_TARGET, ISCSI_TARGET_LENGTH); loginParameters += ISCSI_TARGET_LENGTH;
RtlCopyMemory(loginParameters, PdoExtension->TargetName, targetLength); loginParameters += targetLength + 1;
RtlCopyMemory(loginParameters, ISCSI_USE_RTT, ISCSI_USE_RTT_LENGTH);
iscsiLoginCommand->Length[3] = ISCSI_TARGET_LENGTH + (UCHAR) targetLength + ISCSI_USE_RTT_LENGTH + 2;
/*
{ ULONG inx0, inx1, len;
DebugPrint((1, "\n Logon Packet\n"));
len = (ISCSI_TARGET_LENGTH + targetLength + ISCSI_USE_RTT_LENGTH + 2 + 48); inx0 = 0; while(inx0 < len) { inx1 = 0; DebugPrint((1, "\t")); while ((inx1 < 4) && ((inx0+inx1) < len)) { DebugPrint((1, "0x%02x ", ((PUCHAR)iscsiLoginCommand)[inx0+inx1])); inx1++; } DebugPrint((1, "\n"));
inx0 += 4; } DebugPrint((1, "\n")); } */
//
// Save away the connection ID in our device extension
//
PdoExtension->SavedConnectionID[0] = iscsiLoginCommand->ConnectionID[0]; PdoExtension->SavedConnectionID[1] = iscsiLoginCommand->ConnectionID[1];
status = iSpSendData(iScsiConnection->ConnectionDeviceObject, iScsiConnection->ConnectionFileObject, iscsiLoginCommand, packetSize, &bytesSent); if (NT_SUCCESS(status)) {
DebugPrint((3, "Send succeeded for logon. Bytes sent : %d\n", bytesSent)); } else { DebugPrint((0, "Failed to logon packet. Status : %x\n", status));
PdoExtension->SavedConnectionID[0] = 0; PdoExtension->SavedConnectionID[1] = 0; }
return status;}
NTSTATUSiSpSendScsiCommand( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ){ PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension; PISCSI_PDO_EXTENSION pdoExtension = NULL; PISCSI_CONNECTION iScsiConnection = NULL;
PISCSI_SCSI_COMMAND iScsiScsiCommand = NULL;
PACTIVE_REQUESTS currentRequest;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp); PSCSI_REQUEST_BLOCK srb = irpStack->Parameters.Scsi.Srb;
PVOID requestBuffer = NULL; PVOID originalDataBuffer = NULL; ULONG_PTR offset;
PVOID receiveBuffer = NULL; ULONG receiveBufferSize = 0;
ULONG cmdRN; ULONG expectedDataLen;
ULONG packetSize; ULONG inx; ULONG bytesSent;
NTSTATUS status;
KIRQL oldIrql;
BOOLEAN writeToDevice;
ASSERT(commonExtension->IsPdo); pdoExtension = (PISCSI_PDO_EXTENSION)(DeviceObject->DeviceExtension);
iScsiConnection = pdoExtension->ClientNodeInfo;
if ((iScsiConnection->ConnectionState) != ConnectionStateConnected) { DebugPrint((0, "Not connected to target. Connection State : %d\n", (iScsiConnection->ConnectionState)));
Irp->IoStatus.Status = STATUS_DEVICE_NOT_CONNECTED; Irp->IoStatus.Information = 0L; IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_DEVICE_NOT_CONNECTED; }
ASSERT((pdoExtension->CurrentProtocolState) == PSFullFeaturePhase);
//
// Get the lock to synchronize access to iSCSI
// Connection structure
//
KeAcquireSpinLock(&(iScsiConnection->RequestLock), &oldIrql);
if ((iScsiConnection->NumberOfReqsInProgress) >= (iScsiConnection->MaxPendingRequests)) {
//
// Queue it to the request list for this connection
//
IoMarkIrpPending(Irp);
ExInterlockedInsertTailList(&(iScsiConnection->RequestList), &(Irp->Tail.Overlay.ListEntry), &(iScsiConnection->ListSpinLock));
KeReleaseSpinLock(&(iScsiConnection->RequestLock), oldIrql);
return STATUS_PENDING; }
expectedDataLen = 0;
writeToDevice = FALSE;
packetSize = sizeof(ISCSI_SCSI_COMMAND);
if (srb->SrbFlags & SRB_FLAGS_DATA_IN) {
expectedDataLen = srb->DataTransferLength;
} else if (srb->SrbFlags & SRB_FLAGS_DATA_OUT) {
//
// If we are writing to the device, the data
// is sent as immediate data
//
packetSize += srb->DataTransferLength; writeToDevice = TRUE; }
if (Irp->MdlAddress) {
offset = (ULONG_PTR) ((ULONG_PTR) srb->DataBuffer - (ULONG_PTR) MmGetMdlVirtualAddress(Irp->MdlAddress));
DebugPrint((3, "Srb DataBuffer : 0x%x, Offset into the MDL : 0x%x\n", srb->DataBuffer, offset));
requestBuffer = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, ((Irp->RequestorMode == KernelMode) ? HighPagePriority : NormalPagePriority)); if (requestBuffer != NULL) { UCHAR readChar;
//
// Save the original DataBuffer passed in the SRB
//
originalDataBuffer = srb->DataBuffer;
DebugPrint((3, "SendCommand : Original DataBuffer - 0x%08x\n", originalDataBuffer));
srb->DataBuffer = (PVOID) ((ULONG_PTR) requestBuffer + (ULONG_PTR) offset); //
// This is for catching the case where the Srb DataBuffer
// we have generated is not valid
//
readChar = *((PUCHAR)(srb->DataBuffer));
DebugPrint((3, "OpCode : %d, SRB DataBuffer : %x. ReadChar : %d\n", srb->Cdb[0], srb->DataBuffer, readChar));
DebugPrint((3, "System address for requestBuffer : 0x%08x\n", requestBuffer)); } else {
DebugPrint((1, "Failed to get System Address for MDL\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0L; IoCompleteRequest(Irp, IO_NO_INCREMENT);
goto iSpSendScsiCommandExit; } }
iScsiScsiCommand = iSpAllocatePool( NonPagedPool, packetSize, ISCSI_TAG_SCSI_CMD); if (iScsiScsiCommand == NULL) {
DebugPrint((1, "Could not allocate iSCSI Command packet\n"));
//
// Restore the original DataBuffer in the SRB
//
if (originalDataBuffer != NULL) { srb->DataBuffer = originalDataBuffer; }
status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0L; IoCompleteRequest(Irp, IO_NO_INCREMENT);
goto iSpSendScsiCommandExit; }
RtlZeroMemory(iScsiScsiCommand, packetSize);
iScsiScsiCommand->OpCode = ISCSIOP_SCSI_COMMAND;
if (srb->SrbFlags & SRB_FLAGS_DATA_IN) { iScsiScsiCommand->Read = SETBITON; }
if (writeToDevice == TRUE) {
SetUlongInArray((iScsiScsiCommand->Length), (srb->DataTransferLength));
SetUlongInArray((iScsiScsiCommand->ExpDataXferLength), (srb->DataTransferLength));
//
// Issue : nramas : 01/02/2001
// This should be later changed to chained MDLs
//
RtlCopyMemory((iScsiScsiCommand + 1), (srb->DataBuffer), srb->DataTransferLength); }
if (expectedDataLen != 0) { SetUlongInArray((iScsiScsiCommand->ExpDataXferLength), expectedDataLen); }
SetUlongInArray((iScsiScsiCommand->CmdRN), (iScsiConnection->CommandRefNum));
SetUlongInArray((iScsiScsiCommand->ExpStatRN), (iScsiConnection->CurrentStatusRefNum));
//DebugPrint((3, "Exp StatRN : 0x%x\n",
// (iScsiConnection->ExpStatusRefNum)));
SetUlongInArray((iScsiScsiCommand->TaskTag), (iScsiConnection->InitiatorTaskTag));
ASSERT((srb->CdbLength) <= 16);
DebugPrint((3, "CDB : ")); for (inx = 0; inx < (srb->CdbLength); inx++) { DebugPrint((3, "0x%02x ", srb->Cdb[inx])); } DebugPrint((3, "\n"));
RtlCopyMemory((iScsiScsiCommand->Cdb), (srb->Cdb), (srb->CdbLength));
cmdRN = (iScsiConnection->CommandRefNum); inx = cmdRN % (iScsiConnection->MaxPendingRequests); if (inx == 0) { inx = (iScsiConnection->MaxPendingRequests); } DebugPrint((3, "Request will be added to slot %d\n", inx));
currentRequest = &(iScsiConnection->ActiveClientRequests[inx]);
ASSERT((currentRequest->InUse) == FALSE);
currentRequest->CommandRefNum = iScsiConnection->CommandRefNum;
currentRequest->Irp = Irp;
currentRequest->DeviceObject = DeviceObject;
currentRequest->TaskTag = iScsiConnection->InitiatorTaskTag;
if (originalDataBuffer != NULL) { currentRequest->OriginalDataBuffer = originalDataBuffer; }
currentRequest->RequestBuffer = srb->DataBuffer;
currentRequest->RequestBufferOffset = 0;
currentRequest->InUse = TRUE;
currentRequest->Completed = FALSE;
(iScsiConnection->InitiatorTaskTag)++; if ((iScsiConnection->InitiatorTaskTag) == 0) { iScsiConnection->InitiatorTaskTag = 1; }
(iScsiConnection->CommandRefNum)++;
(iScsiConnection->NumberOfReqsInProgress)++;
DebugPrint((3, "Number of requests in progress %d\n", (iScsiConnection->NumberOfReqsInProgress)));
DebugPrint((3, "CmdRN %d. PacketSize %d, Expected Xfer Length %d\n", cmdRN, packetSize, expectedDataLen));
DebugPrint((3, "SCSI packet : %x\n", iScsiScsiCommand)); status = iSpSendData(iScsiConnection->ConnectionDeviceObject, iScsiConnection->ConnectionFileObject, iScsiScsiCommand, packetSize, &bytesSent);
if (NT_SUCCESS(status)) {
//
// Command packet successfully sent. Mark the IRP pending,
// and return STATUS_PENDING
//
IoMarkIrpPending(Irp);
status = STATUS_PENDING;
} else { DebugPrint((0, "Failed to send SCSI Command. Status : 0x%08x\n", status));
if (currentRequest->OriginalDataBuffer) { srb->DataBuffer = currentRequest->OriginalDataBuffer; }
(iScsiConnection->InitiatorTaskTag)--; (iScsiConnection->CommandRefNum)--; (iScsiConnection->NumberOfReqsInProgress)--;
RtlZeroMemory(currentRequest, sizeof(ACTIVE_REQUESTS));
Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0L; IoCompleteRequest(Irp, IO_NO_INCREMENT); } iSpSendScsiCommandExit:
KeReleaseSpinLock(&(iScsiConnection->RequestLock), oldIrql);
return status;}
NTSTATUSiSpProcessScsiResponse( PISCSI_CONNECTION IScsiConnection, PISCSI_SCSI_RESPONSE IScsiScsiResponse ){ PISCSI_PDO_EXTENSION pdoExtension; PCOMMON_EXTENSION commonExtension; PIO_STACK_LOCATION irpStack; PSCSI_REQUEST_BLOCK srb; PIRP irp; PDEVICE_OBJECT deviceObject; PACTIVE_REQUESTS currentRequest; ULONG inx; ULONG taskTag; ULONG cmdStatus; ULONG iScsiStatus; ULONG statusRN; ULONG length; ULONG expCmdRefNum; NTSTATUS status;
ASSERT((IScsiScsiResponse->OpCode) == ISCSIOP_SCSI_RESPONSE);
ASSERT(IScsiConnection->Type == ISCSI_CONNECTION_TYPE);
currentRequest = IScsiConnection->CurrentRequest;
GetUlongFromArray((IScsiScsiResponse->TaskTag), taskTag);
GetUlongFromArray((IScsiScsiResponse->StatusRN), statusRN);
IScsiConnection->CurrentStatusRefNum = statusRN;
DebugPrint((3, "iSpProcessScsiResponse - TaskTag 0x%08x\n", taskTag));
(IScsiConnection->NumberOfReqsInProgress)--;
commonExtension = (currentRequest->DeviceObject)->DeviceExtension; pdoExtension = (PISCSI_PDO_EXTENSION) commonExtension;
irp = currentRequest->Irp; deviceObject = currentRequest->DeviceObject; irpStack = IoGetCurrentIrpStackLocation(irp); srb = irpStack->Parameters.Scsi.Srb;
cmdStatus = IScsiScsiResponse->CmdStatus; iScsiStatus = IScsiScsiResponse->iSCSIStatus;
GetUlongFromArray((IScsiScsiResponse->ExpCmdRN), (expCmdRefNum));
GetUlongFromArray((IScsiScsiResponse->MaxCmdRN), (IScsiConnection->MaxCommandRefNum));
DebugPrint((3, "SCSI Response : Expected CmdRefNum %d, MaxCmdRN %d\n", expCmdRefNum, (IScsiConnection->MaxCommandRefNum)));
//
// Retrieve the size of immediate data
//
GetUlongFromArray((IScsiScsiResponse->Length), length);
if (cmdStatus == SCSISTAT_GOOD) {
ASSERT(iScsiStatus == ISCSISTAT_GOOD);
irp->IoStatus.Status = STATUS_SUCCESS;
if ((srb->SrbFlags) & SRB_FLAGS_DATA_IN) {
//
// Read request. Fill the number of bytes read
//
irp->IoStatus.Information = currentRequest->ReceivedDataLength;
srb->DataTransferLength = currentRequest->ReceivedDataLength;
} else if ((srb->SrbFlags) & SRB_FLAGS_DATA_OUT) {
//
// Write request. Set IoStatus Information to
// number of bytes written (srb->DataTransferLength)
//
irp->IoStatus.Information = srb->DataTransferLength;
} else {
//
// No I/O involved in this request.
//
irp->IoStatus.Information = 0; }
srb->SrbStatus = SRB_STATUS_SUCCESS;
srb->ScsiStatus = SCSISTAT_GOOD;
DebugPrint((3, "Info : 0x%x\n", irp->IoStatus.Information));
} else {
DebugPrint((0, "Command failed\n")); srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
//
// Should map SRB status error using sense data
//
srb->SrbStatus = SRB_STATUS_ERROR;
//
// If the upper driver passed a valid senseinfo buffer,
// and the target sent sense data, copy it to the buffer
//
if ((srb->SenseInfoBufferLength) && (length > 0)) {
ULONG senseInx;
if (length > (srb->SenseInfoBufferLength)) { DebugPrint((0, "Sense info greater than buffer size. Size %d\n", length));
length = srb->SenseInfoBufferLength; }
DebugPrint((0, "Command 0x%02x failed. Sense Data : ", srb->Cdb[0])); for (senseInx = 0; senseInx < length; senseInx++) { DebugPrint((0, "%02x ", currentRequest->SenseData[senseInx])); } DebugPrint((0, "\n"));
RtlCopyMemory(srb->SenseInfoBuffer, currentRequest->SenseData, length);
srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID; srb->SenseInfoBufferLength = (UCHAR) length; }
//
// ISSUE : nramas : 01/15/2001
// Need to determine the correct NTSTATUS here
//
irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR; irp->IoStatus.Information = 0;
}
//
// Restore the original DataBuffer in the SRB
//
if ((currentRequest->OriginalDataBuffer) != NULL) {
DebugPrint((3, "ProcessResponse : Original DataBuffer - 0x%08x\n", currentRequest->OriginalDataBuffer));
srb->DataBuffer = currentRequest->OriginalDataBuffer; }
DebugPrint((3, "Irp done : 0x%x\n", irp));
IoCompleteRequest(irp, IO_NO_INCREMENT);
RtlZeroMemory(currentRequest, sizeof(ACTIVE_REQUESTS));
return STATUS_SUCCESS;}
NTSTATUSiSpProcessReceivedData( IN PISCSI_CONNECTION IScsiConnection, IN ULONG BytesIndicated, OUT ULONG *BytesTaken, IN PVOID DataBuffer ){ PUCHAR requestBuffer = NULL; PISCSI_GENERIC_HEADER iScsiHeader = NULL; PISCSI_SCSI_RESPONSE iScsiResponse = NULL; PISCSI_SCSI_DATA_READ iScsiDataRead = NULL; PACTIVE_REQUESTS currentRequest = NULL; ULONG length; ULONG receivedDataLen; ULONG inx; ULONG taskTag; ULONG statusRefNum; ULONG expCmdRN; LONG byteCount; NTSTATUS status = STATUS_SUCCESS; UCHAR opCode; KIRQL oldIrql; //
// We always take all the data given to us
// in this routine. So set BytesTaken to
// BytesIndicated
*BytesTaken = BytesIndicated;
byteCount = (LONG) BytesIndicated;
DebugPrint((3, "Bytes indicated : %d\n", BytesIndicated));
//
// Get the lock to synchronize access to iSCSI
// Connection structure
//
KeAcquireSpinLock(&(IScsiConnection->RequestLock), &oldIrql);
while (byteCount > 0) { if ((IScsiConnection->ReceiveState) == ReceiveHeader) {
DebugPrint((3, "Receiving header\n"));
if ((IScsiConnection->CompleteHeaderReceived)== FALSE) { LONG bytesToCopy; BOOLEAN headerComplete = FALSE;
bytesToCopy = sizeof(ISCSI_GENERIC_HEADER) - (IScsiConnection->IScsiPacketOffset);
DebugPrint((0, "CHR False. ToCopy : %d, Count : %d\n", bytesToCopy, byteCount));
if (byteCount < bytesToCopy) { bytesToCopy = byteCount; } else { headerComplete = TRUE; } RtlCopyMemory((IScsiConnection->IScsiPacket) + (IScsiConnection->IScsiPacketOffset), DataBuffer, bytesToCopy);
if (headerComplete == FALSE) {
DebugPrint((0, "CHR still FALSE\n"));
IScsiConnection->IScsiPacketOffset += bytesToCopy; KeReleaseSpinLock(&(IScsiConnection->RequestLock), oldIrql);
return STATUS_SUCCESS; } else {
DebugPrint((0, "Header complete\n"));
IScsiConnection->IScsiPacketOffset = 0; IScsiConnection->CompleteHeaderReceived = TRUE;
byteCount -= bytesToCopy; ASSERT(byteCount >= 0); (PUCHAR) DataBuffer += bytesToCopy; }
} else if (byteCount < sizeof(ISCSI_GENERIC_HEADER)) { DebugPrint((0, "Complete header NOT received. Count : %d\n", byteCount));
IScsiConnection->CompleteHeaderReceived = FALSE;
RtlCopyMemory((IScsiConnection->IScsiPacket), DataBuffer, byteCount);
IScsiConnection->IScsiPacketOffset = byteCount;
KeReleaseSpinLock(&(IScsiConnection->RequestLock), oldIrql);
return STATUS_SUCCESS; } else { RtlCopyMemory((IScsiConnection->IScsiPacket), DataBuffer, sizeof(ISCSI_GENERIC_HEADER));
byteCount -= sizeof(ISCSI_GENERIC_HEADER); ASSERT(byteCount >= 0); (PUCHAR) DataBuffer += sizeof(ISCSI_GENERIC_HEADER); }
//
// At this point, we should have the complete header
// available
//
iScsiHeader = (PISCSI_GENERIC_HEADER) (IScsiConnection->IScsiPacket);
opCode = iScsiHeader->OpCode;
//
// Retrieve the length of immediate data
// associated with this iSCSI packet
//
GetUlongFromArray((iScsiHeader->Length), length);
DebugPrint((3, "Opcode : %x, Length : %x\n", opCode, length));
switch (opCode) { case ISCSIOP_SCSI_DATA_READ: { iScsiDataRead = (PISCSI_SCSI_DATA_READ) iScsiHeader;
GetUlongFromArray((iScsiDataRead->InitiatorTransferTag), taskTag);
DebugPrint((3, "XfrTag - 0x%08x\n", taskTag));
if ((IScsiConnection->CurrentRequest) == NULL) {
inx = iSpGetActiveClientRequestIndex( IScsiConnection, taskTag);
DebugPrint((3, "ActiveClientRequest index : %d\n", inx));
ASSERT((inx <= (IScsiConnection->MaxPendingRequests)));
currentRequest = &(IScsiConnection->ActiveClientRequests[inx]);
IScsiConnection->CurrentRequest = currentRequest;
} else { DebugPrint((0, "CurrentRequest not null in data\n")); currentRequest = IScsiConnection->CurrentRequest; }
currentRequest->CommandStatus = iScsiDataRead->CommandStatus;
//
// If the command status is not SCSISTAT_GOOD, use
// SenseData buffer to read the sense info. Else, use
// RequestBuffer to read input data
//
if ((iScsiDataRead->CommandStatus) != SCSISTAT_GOOD) { DebugPrint((0, "Command status is %x\n", iScsiDataRead->CommandStatus)); requestBuffer = currentRequest->SenseData; } else { requestBuffer = currentRequest->RequestBuffer; }
//
// If immediate data is available, copy that
//
if (length != 0) { ULONG receivedDataLen;
IScsiConnection->ReceiveState = ReceiveData;
if ((LONG)length <= byteCount ) { receivedDataLen = length; } else { receivedDataLen = byteCount; }
if ((iScsiDataRead->CommandStatus) != SCSISTAT_GOOD) { ASSERT(receivedDataLen <= sizeof(currentRequest->SenseData)); }
RtlCopyMemory(requestBuffer, DataBuffer, receivedDataLen);
(PUCHAR) DataBuffer += receivedDataLen; byteCount -= receivedDataLen; ASSERT(byteCount >= 0);
if (byteCount != 0) { DebugPrint((1, "More bytes available\n")); }
currentRequest->ExpectedDataLength = length;
currentRequest->RequestBufferOffset = receivedDataLen;
currentRequest->ReceivedDataLength = receivedDataLen;
if ((currentRequest->ExpectedDataLength) == currentRequest->ReceivedDataLength) { IScsiConnection->ReceiveState = ReceiveHeader; } }
break; }
case ISCSIOP_SCSI_RESPONSE: { BOOLEAN responseComplete = FALSE;
iScsiResponse = (PISCSI_SCSI_RESPONSE) iScsiHeader;
IScsiConnection->ReceiveState = ReceiveHeader;
GetUlongFromArray((iScsiResponse->TaskTag), taskTag);
DebugPrint((3, "ResTag - 0x%08x\n", taskTag));
if ((IScsiConnection->CurrentRequest) == NULL) {
inx = iSpGetActiveClientRequestIndex( IScsiConnection, taskTag);
DebugPrint((3, "ActiveClientRequest index : %d\n", inx));
if (inx > (IScsiConnection->MaxPendingRequests)) {
ULONG cmdRN;
DebugPrint((0, "Tag : %x. Will use cmdRN to search\n", taskTag));
GetUlongFromArray((iScsiResponse->ExpCmdRN), cmdRN);
inx = iSpGetReqIndexUsingCmdRN(IScsiConnection, (cmdRN - 1)); DebugPrint((0, "Inx returned : 0x%x\n", inx)); }
ASSERT((inx <= (IScsiConnection->MaxPendingRequests)));
currentRequest = &(IScsiConnection->ActiveClientRequests[inx]);
IScsiConnection->CurrentRequest = currentRequest;
} else { currentRequest = IScsiConnection->CurrentRequest; }
currentRequest->CommandStatus = iScsiResponse->CmdStatus;
if ((iScsiResponse->CmdStatus) != SCSISTAT_GOOD) { DebugPrint((0, "Command status is %x. Length : %d\n", iScsiResponse->CmdStatus, length)); requestBuffer = currentRequest->SenseData; } else { requestBuffer = currentRequest->RequestBuffer; }
if (length != 0) { ULONG receivedDataLen;
DebugPrint((3, "Non-zero length in response : %d\n", length)); IScsiConnection->ReceiveState = ReceiveData;
if ((LONG)length <= byteCount ) { receivedDataLen = length; } else { receivedDataLen = byteCount; }
if ((iScsiResponse->CmdStatus) != SCSISTAT_GOOD) { ASSERT(receivedDataLen <= sizeof(currentRequest->SenseData)); }
RtlCopyMemory(requestBuffer, DataBuffer, receivedDataLen);
(PUCHAR) DataBuffer += receivedDataLen; byteCount -= receivedDataLen; ASSERT(byteCount >= 0);
currentRequest->ExpectedDataLength = length;
currentRequest->RequestBufferOffset = receivedDataLen;
currentRequest->ReceivedDataLength = receivedDataLen;
if ((currentRequest->ExpectedDataLength) == currentRequest->ReceivedDataLength) { IScsiConnection->ReceiveState = ReceiveHeader;
responseComplete = TRUE; DebugPrint((3, "Response complete. Will process it\n")); } } else { responseComplete = TRUE; }
//
// Should use this field to determine
// Data Overrun\Underrun cases
//
if ((iScsiResponse->OverFlow) || (iScsiResponse->UnderFlow)) { ULONG residualCount;
GetUlongFromArray((iScsiResponse->ResidualCount), residualCount); DebugPrint((0, "Residualcount is : %d\n", residualCount)); }
if (responseComplete == TRUE) {
if ((iScsiResponse->CmdStatus) != SCSISTAT_GOOD) {
PUCHAR resBuff = (PUCHAR) (IScsiConnection->IScsiPacket); ULONG inx0, inx1; ULONG sizeRequired = sizeof(ISCSI_SCSI_RESPONSE);
DebugPrint((1, "\n Beginning Of Data\n")); inx0 = 0; while (inx0 < sizeRequired) { inx1 = 0; DebugPrint((1, "\t")); while ((inx1 < 4) && ((inx0+inx1) < sizeRequired)) { DebugPrint((1, "%02x ", resBuff[inx0+inx1])); inx1++; } DebugPrint((1, "\n")); inx0 += 4; } DebugPrint((1, " End Of Data\n"));
}
iSpProcessScsiResponse( IScsiConnection, (PISCSI_SCSI_RESPONSE)(IScsiConnection->IScsiPacket));
IScsiConnection->CurrentRequest = NULL; }
break; }
case ISCSIOP_NOP_IN_MESSAGE: {
PISCSI_NOP_IN iScsiNopIn = (PISCSI_NOP_IN) iScsiHeader;
IScsiConnection->ReceiveState = ReceiveHeader;
if (iScsiNopIn->Poll) {
//
// Need to handle this case. Should send
// response to the target
//
DebugPrint((0, "Target expects NOP OUT message\n")); } else { DebugPrint((1, "No NOP OUT message needed.\n")); }
break; }
default: { ULONG inx0, inx1;
//
// Opcode that we don't currently handle.
// For the timebeing, just dump the iSCSI
// packet.
//
DebugPrint((0, "Unknown opcode : 0x%02x\n", opCode));
inx0 = 0; while(inx0 < 48) { inx1 = 0; DebugPrint((0, "\t")); while ((inx1 < 4) && ((inx0+inx1) < 48)) { DebugPrint((0, "0x%02x ", ((PUCHAR)(iScsiHeader))[inx0+inx1])); inx1++; } DebugPrint((0, "\n"));
inx0 += 4; } DebugPrint((0, "\n"));
break; } } // switch (opCode)
} else { ULONG bytesToCopy; UCHAR opCode;
//
// We are receiving the data portion of the packet
//
ASSERT((IScsiConnection->ReceiveState) == ReceiveData);
ASSERT(IScsiConnection->CurrentRequest);
DebugPrint((3, "Receiving data\n"));
currentRequest = IScsiConnection->CurrentRequest;
if ((currentRequest->CommandStatus) != SCSISTAT_GOOD) { requestBuffer = currentRequest->SenseData; } else { requestBuffer = currentRequest->RequestBuffer; }
requestBuffer += currentRequest->RequestBufferOffset;
bytesToCopy = ((currentRequest->ExpectedDataLength) - (currentRequest->ReceivedDataLength)); if ((LONG)bytesToCopy > byteCount) { bytesToCopy = byteCount; } else { DebugPrint((3, "More bytes in current buffer than expected\n")); }
RtlCopyMemory(requestBuffer, DataBuffer, bytesToCopy); byteCount -= bytesToCopy; (PUCHAR) DataBuffer += bytesToCopy; ASSERT(byteCount >= 0);
currentRequest->RequestBufferOffset += bytesToCopy;
currentRequest->ReceivedDataLength += bytesToCopy;
if ((currentRequest->ExpectedDataLength) == currentRequest->ReceivedDataLength) {
DebugPrint((3, "Got all data. Bytes left %d\n", byteCount));
IScsiConnection->ReceiveState = ReceiveHeader;
opCode = IScsiConnection->IScsiPacket[0]; if (opCode == ISCSIOP_SCSI_RESPONSE) {
DebugPrint((3, "Will process the response\n"));
iSpProcessScsiResponse( IScsiConnection, (PISCSI_SCSI_RESPONSE)(IScsiConnection->IScsiPacket));
IScsiConnection->CurrentRequest = NULL; } } } }
KeReleaseSpinLock(&(IScsiConnection->RequestLock), oldIrql);
return status;}
ULONGiSpGetActiveClientRequestIndex( PISCSI_CONNECTION IScsiConnection, ULONG TaskTag ){ ULONG retIndex = ~0; ULONG inx;
DebugPrint((3, "Given Task Tag : 0x%08x\n", TaskTag));
for (inx = 1; inx <= (IScsiConnection->MaxPendingRequests); inx++) { DebugPrint((3, "Index %d : CmdRN - 0x%08x\n", inx, ((IScsiConnection->ActiveClientRequests[inx]).TaskTag)));
if (((IScsiConnection->ActiveClientRequests[inx]).TaskTag) == TaskTag) {
retIndex = inx;
DebugPrint((1, "inx : 0x%04x\n", retIndex));
break; } }
if (retIndex > (IScsiConnection->MaxPendingRequests)) { DebugPrint((0, "Tag : Did not find the request for this response\n")); }
return retIndex;}
ULONGiSpGetReqIndexUsingCmdRN( PISCSI_CONNECTION IScsiConnection, ULONG CmdRN ){ ULONG retIndex = ~0; ULONG inx;
DebugPrint((3, "Given CmdRN : 0x%08x\n", CmdRN));
for (inx = 1; inx <= (IScsiConnection->MaxPendingRequests); inx++) {
if (((IScsiConnection->ActiveClientRequests[inx]).CommandRefNum) == CmdRN) {
retIndex = inx;
DebugPrint((1, "inx : 0x%04x\n", retIndex));
break; } }
if (retIndex > (IScsiConnection->MaxPendingRequests)) { ASSERTMSG("CmdRN : Did not find the request for this response\n", FALSE); }
return retIndex;}
|
