vscsi.c

虚拟Scsi Disk源程序 版权归原作者

			RtlMoveMemory(pInquiryData->VendorId,"zhu	",8);

			RtlMoveMemory(pInquiryData->ProductId,"zhu Disk	",16);

			RtlMoveMemory(pInquiryData->ProductRevisionLevel,"1010",4);
			VirtualScsiPortDebugPrint(DBG_IO, DBG_TRACE, __FUNCTION__"\tInquiry...(target-lun)=(%d,%d)...succeed\n", 
				srb->TargetId,srb->Lun);
			*/
		}
        else if (cdb->CDB6GENERIC.OperationCode == SCSIOP_READ)
        {
            ULONG   logicalBlockAddress;
            USHORT  transferCount;
            PVOID   buffer;

            REVERSE_BYTES(&logicalBlockAddress, &cdb->CDB10.LogicalBlockByte0);
            REVERSE_BYTES_SHORT(&transferCount, &cdb->CDB10.TransferBlocksMsb);

            if ((logicalBlockAddress + transferCount) <= (VSCSI_BUFFER_SIZE/512))
            {
                buffer = MmGetSystemAddressForMdl(Irp->MdlAddress);

                RtlCopyMemory(buffer, g_Buffer + logicalBlockAddress*512, transferCount*512);
                Irp->IoStatus.Information = transferCount*512;
            }
            else
            {
                status = STATUS_INVALID_PARAMETER;
                srb->SrbStatus = SRB_STATUS_BAD_SRB_BLOCK_LENGTH;
            }
        }
        else if (cdb->CDB6GENERIC.OperationCode == SCSIOP_WRITE)
        {
            ULONG   logicalBlockAddress;
            USHORT  transferCount;
            PVOID   buffer;

            REVERSE_BYTES(&logicalBlockAddress, &cdb->CDB10.LogicalBlockByte0);
            REVERSE_BYTES_SHORT(&transferCount, &cdb->CDB10.TransferBlocksMsb);

            if ((logicalBlockAddress + transferCount) <= (VSCSI_BUFFER_SIZE/512))
            {
                buffer = MmGetSystemAddressForMdl(Irp->MdlAddress);

                RtlCopyMemory(g_Buffer + logicalBlockAddress*512, buffer, transferCount*512);
                Irp->IoStatus.Information = transferCount*512;
            }
            else
            {
                status = STATUS_INVALID_PARAMETER;
                srb->SrbStatus = SRB_STATUS_BAD_SRB_BLOCK_LENGTH;
            }
        }
        else if (cdb->CDB6GENERIC.OperationCode == SCSIOP_MODE_SENSE)
        {
			VScsiDiskDebugPrint(DBG_IO, DBG_TRACE, __FUNCTION__"mode sense...(target-lun)=(%d,%d)..zhu\n", 
					srb->TargetId,srb->Lun);
            RtlZeroMemory(srb->DataBuffer, srb->DataTransferLength);

            if (cdb->MODE_SENSE.Pc != 1)
            {
                PMODE_PARAMETER_HEADER  header;

                header = (PMODE_PARAMETER_HEADER)srb->DataBuffer;

                header->ModeDataLength = sizeof(MODE_PARAMETER_HEADER);
                header->MediumType = 0;
                header->DeviceSpecificParameter = 0;

                if (!cdb->MODE_SENSE.Dbd && (cdb->MODE_SENSE.AllocationLength >= (header->ModeDataLength + sizeof(MODE_PARAMETER_BLOCK))))
                {
                    PMODE_PARAMETER_BLOCK   block;
                    ULONG                   logicalBlockAddress;
                    ULONG                   bytesPerBlock;

                    block = (PMODE_PARAMETER_BLOCK)((PUCHAR)header + header->ModeDataLength);
                    logicalBlockAddress = VSCSI_BUFFER_SIZE/512;
                    bytesPerBlock = 512;

                    header->BlockDescriptorLength = sizeof(MODE_PARAMETER_BLOCK);
                    header->ModeDataLength += sizeof(MODE_PARAMETER_BLOCK);

                    block->DensityCode = 0;

                    block->NumberOfBlocks[0] = (UCHAR)((logicalBlockAddress >> 16) & 0xFF);
                    block->NumberOfBlocks[1] = (UCHAR)((logicalBlockAddress >> 8) & 0xFF);
                    block->NumberOfBlocks[2] = (UCHAR)(logicalBlockAddress & 0xFF);

                    block->BlockLength[0] = (UCHAR)((bytesPerBlock >> 16) & 0xFF);
                    block->BlockLength[1] = (UCHAR)((bytesPerBlock >> 8) & 0xFF);
                    block->BlockLength[2] = (UCHAR)(bytesPerBlock & 0xFF);
                }
                else
                {
                    header->BlockDescriptorLength = 0;
                }

                if ((cdb->MODE_SENSE.AllocationLength >= (header->ModeDataLength + sizeof(MODE_PAGE_FORMAT_DEVICE))) && 
                    ((cdb->MODE_SENSE.PageCode == MODE_SENSE_RETURN_ALL) || 
                     (cdb->MODE_SENSE.PageCode == MODE_PAGE_FORMAT_DEVICE)))
                {
                    PMODE_FORMAT_PAGE format;

                    format = (PMODE_FORMAT_PAGE)((PUCHAR)header + header->ModeDataLength);
                    header->ModeDataLength += sizeof(MODE_FORMAT_PAGE);

                    format->PageCode = MODE_PAGE_FORMAT_DEVICE;
                    format->PageLength = sizeof(MODE_FORMAT_PAGE);
                    format->TracksPerZone[0] = 0;           // we have only one zone
                    format->TracksPerZone[1] = 0;
                    format->AlternateSectorsPerZone[0] = 0;
                    format->AlternateSectorsPerZone[1] = 0;
                    format->AlternateTracksPerZone[0] = 0;
                    format->AlternateTracksPerZone[1] = 0;
                    format->AlternateTracksPerLogicalUnit[0] = 0;
                    format->AlternateTracksPerLogicalUnit[1] = 0;
                    format->SectorsPerTrack[0] = (UCHAR)((VSCSI_BUFFER_SIZE/512 >> 8) & 0xFF);
                    format->SectorsPerTrack[1] = (UCHAR)((VSCSI_BUFFER_SIZE/512 >> 0) & 0xFF);
                    format->BytesPerPhysicalSector[0] = (UCHAR)((512 >> 8) & 0xFF);
                    format->BytesPerPhysicalSector[1] = (UCHAR)((512 >> 0) & 0xFF);
                    format->SoftSectorFormating = 1;
                }

                if ((cdb->MODE_SENSE.AllocationLength >= (header->ModeDataLength + sizeof(MODE_DISCONNECT_PAGE))) && 
                    ((cdb->MODE_SENSE.PageCode == MODE_SENSE_RETURN_ALL) || 
                     (cdb->MODE_SENSE.PageCode == MODE_PAGE_DISCONNECT)))
                {
                    PMODE_DISCONNECT_PAGE disconnectPage;

                    disconnectPage = (PMODE_DISCONNECT_PAGE)((PUCHAR)header + header->ModeDataLength);
                    header->ModeDataLength += sizeof(MODE_DISCONNECT_PAGE);

                    disconnectPage->PageCode = MODE_PAGE_DISCONNECT;
                    disconnectPage->PageLength = sizeof(MODE_DISCONNECT_PAGE);
                    disconnectPage->BufferFullRatio = 0xFF;
                    disconnectPage->BufferEmptyRatio = 0xFF;
                    disconnectPage->BusInactivityLimit[0] = 0;
                    disconnectPage->BusInactivityLimit[1] = 1;
                    disconnectPage->BusDisconnectTime[0] = 0;
                    disconnectPage->BusDisconnectTime[1] = 1;
                    disconnectPage->BusConnectTime[0] = 0;
                    disconnectPage->BusConnectTime[1] = 1;
                    disconnectPage->MaximumBurstSize[0] = 0;
                    disconnectPage->MaximumBurstSize[1] = 1;
                    disconnectPage->DataTransferDisconnect = 1;
                }

                srb->DataTransferLength = header->ModeDataLength;
            }
			
        }
		else if(cdb->CDB12.OperationCode == SCSIOP_REPORT_LUNS)
		{
			VScsiDiskDebugPrint(DBG_IO, DBG_TRACE, __FUNCTION__"report lun...(target-lun)=(%d,%d)..zhu\n", 
					srb->TargetId,srb->Lun);
		}
        break;
    case SRB_FUNCTION_CLAIM_DEVICE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_CLAIM_DEVICE");
        srb->DataBuffer = DeviceObject;
        break;
    case SRB_FUNCTION_IO_CONTROL:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_IO_CONTROL");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_RECEIVE_EVENT:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_RECEIVE_EVENT");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_RELEASE_QUEUE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_RELEASE_QUEUE");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_ATTACH_DEVICE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_ATTACH_DEVICE");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_RELEASE_DEVICE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_RELEASE_DEVICE");
        break;
    case SRB_FUNCTION_SHUTDOWN:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_SHUTDOWN");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_FLUSH:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_FLUSH");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_ABORT_COMMAND:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_ABORT_COMMAND");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_RELEASE_RECOVERY:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_RELEASE_RECOVERY");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_RESET_BUS:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_RESET_BUS");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_RESET_DEVICE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_RESET_DEVICE");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_TERMINATE_IO:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_TERMINATE_IO");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_FLUSH_QUEUE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_FLUSH_QUEUE");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_REMOVE_DEVICE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_REMOVE_DEVICE");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_WMI:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_WMI");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_LOCK_QUEUE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_LOCK_QUEUE");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    case SRB_FUNCTION_UNLOCK_QUEUE:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_UNLOCK_QUEUE");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
#ifndef WIN2K
    case SRB_FUNCTION_RESET_LOGICAL_UNIT:
        VScsiDiskDebugPrint(DBG_IO, DBG_INFO, "SRB_FUNCTION_RESET_LOGICAL_UNIT");
        status = STATUS_INVALID_DEVICE_REQUEST;
        srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
#endif
    default:
//      status = STATUS_INVALID_DEVICE_REQUEST;
//      srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
        break;
    }

    if (NT_SUCCESS(status))
    {
        Irp->IoStatus.Information = srb->DataTransferLength;
    }

    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    VScsiDiskDebugPrint(DBG_IO, DBG_TRACE, __FUNCTION__"--. IRP %p, STATUS %x", Irp, status);

    return status;
}