processscsi.cpp

虚拟磁盘源码,完整的虚拟磁盘源码,支持大硬盘数据

		WriteVerify,									// write and verify = 2E
		Verify,											// verify = 2F
		
		InvalidScsiCmd,									// search data high = 30
		InvalidScsiCmd,									// search data equal = 31
		InvalidScsiCmd,									// search data low = 32
		InvalidScsiCmd,									// set limits = 33
		InvalidScsiCmd,									// prefetch = 34
		SynchronizeCache,								// synchronize cache = 35
		InvalidScsiCmd,									// lock unlock cache = 36
		InvalidScsiCmd,									// read defect data = 37
		InvalidScsiCmd,									// medium scan = 38
		InvalidScsiCmd,									// compare = 39
		InvalidScsiCmd,									// copy and verify = 3A
		InvalidScsiCmd,									// write buffer = 3B
		InvalidScsiCmd,									// read buffer = 3C
		InvalidScsiCmd,									// update block = 3D
		InvalidScsiCmd,									// read long = 3E
		InvalidScsiCmd,									// write long = 3F

		InvalidScsiCmd,									// change definition = 40
		InvalidScsiCmd,									// write same = 41
		InvalidScsiCmd,									// read sub channel = 42
		InvalidScsiCmd,									// read toc = 43
		InvalidScsiCmd,									// read header = 44
		InvalidScsiCmd,									// read audio10 = 45
		InvalidScsiCmd,									// 46
		InvalidScsiCmd,									// play audio smf = 47
		InvalidScsiCmd,									// play audio track index = 48
		InvalidScsiCmd,									// play audio relative10 = 49
		InvalidScsiCmd,									// 4A
		InvalidScsiCmd,									// pause resume = 4B
		InvalidScsiCmd,									// log select = 4C
		InvalidScsiCmd,									// log sense = 4D
		InvalidScsiCmd,									// 4E
		InvalidScsiCmd,									// 4F
	
		InvalidScsiCmd,									// 50
		InvalidScsiCmd,									// 51
		InvalidScsiCmd,									// 52
		InvalidScsiCmd,									// 53
		InvalidScsiCmd,									// 54
		InvalidScsiCmd,									// mode select10 = 55
		InvalidScsiCmd,									// 56
		InvalidScsiCmd,									// 57
		InvalidScsiCmd,									// 58
		InvalidScsiCmd,									// 59
		InvalidScsiCmd,									// mode sense10 = 5A
		InvalidScsiCmd,									// 5B
		InvalidScsiCmd,									// 5C
		InvalidScsiCmd,									// 5D
		InvalidScsiCmd,									// 5E
		InvalidScsiCmd,									// 5F
	};

	#define MAX_SCSI_CMD (sizeof(g_pfnScsiCmdHandler)/sizeof(fnScsiCmdHandler))

	UCHAR g_ucSenseCodes[][5] = 
	{
		/*INVALID_REQUEST*/		SRB_STATUS_ERROR+SRB_STATUS_AUTOSENSE_VALID,SCSISTAT_CHECK_CONDITION,SCSI_SENSE_ILLEGAL_REQUEST,SCSI_ADSENSE_ILLEGAL_COMMAND,	0,
		/*DEVICE_NOT_READY*/	SRB_STATUS_ERROR+SRB_STATUS_AUTOSENSE_VALID,SCSISTAT_CHECK_CONDITION,SCSI_SENSE_NOT_READY,		SCSI_ADSENSE_LUN_NOT_READY,		SCSI_SENSEQ_MANUAL_INTERVENTION_REQUIRED,
		/*NO_MEDIA_IN_DEVICE*/	SRB_STATUS_ERROR+SRB_STATUS_AUTOSENSE_VALID,SCSISTAT_CHECK_CONDITION,SCSI_SENSE_NOT_READY,		SCSI_ADSENSE_NO_MEDIA_IN_DEVICE,0,
		/*MEDIA_ERROR*/			SRB_STATUS_ERROR+SRB_STATUS_AUTOSENSE_VALID,SCSISTAT_CHECK_CONDITION,SCSI_SENSE_MEDIUM_ERROR,	0x10,							0,
		/*INVALID_SUB_REQUEST*/	SRB_STATUS_ERROR+SRB_STATUS_AUTOSENSE_VALID,SCSISTAT_CHECK_CONDITION,SCSI_SENSE_ILLEGAL_REQUEST,SCSI_ADSENSE_INVALID_CDB,		0,
		/*OUT_BOUND_ACCESS*/	SRB_STATUS_ERROR+SRB_STATUS_AUTOSENSE_VALID,SCSISTAT_CHECK_CONDITION,SCSI_SENSE_ILLEGAL_REQUEST,SCSI_ADSENSE_ILLEGAL_BLOCK,		0,
	};
}

// process io control
BOOLEAN DoIoControl(PMiniportExt pExt,PSCSI_REQUEST_BLOCK pSrb)
{
	PSRB_IO_CONTROL pIoCtl = static_cast<PSRB_IO_CONTROL>(pSrb->DataBuffer);

	//ULONG ulCode = pIoCtl->ControlCode;

	//pSrb->SrbStatus = SRB_STATUS_INVALID_REQUEST;

	//if(RtlCompareMemory(pIoCtl->Signature,MINIPORTSIGN,sizeof(pIoCtl->Signature)) == sizeof(pIoCtl->Signature))
	//{
	//	switch(ulCode)
	//	{
	//		// check present
	//	case IOCTL_MINIPORT_GET_VERSION:
	//		if(pSrb->DataTransferLength >= sizeof(SRB_IO_CONTROL) + sizeof(USHORT))
	//		{
	//			*reinterpret_cast<PUSHORT>(pIoCtl + 1) = 0x1010;
	//			pSrb->SrbStatus = SRB_STATUS_SUCCESS;
	//		}
	//		else
	//		{
	//			pSrb->SrbStatus = SRB_STATUS_DATA_OVERRUN;
	//		}
	//		break;

	//	case IOCTL_MINIPORT_MOUNT_IMAGE:
	//		{
	//			if(pExt->m_hFileHandle)
	//				pSrb->SrbStatus = SRB_STATUS_BUSY;
	//			else
	//			{
	//				if(MountImage(pExt,L"\\DosDevices\\c:\\pal.iso"))
	//					pSrb->SrbStatus = SRB_STATUS_SUCCESS;
	//				else
	//					pSrb->SrbStatus = SRB_STATUS_ERROR;
	//			}
	//		}
	//		break;

	//	case IOCTL_MINIPORT_UNMOUNT_IMAGE:
	//		{
	//			if(!pExt->m_hFileHandle)
	//				pSrb->SrbStatus = SRB_STATUS_ABORTED;
	//			else
	//			{
	//				pExt->m_bEjectIrpForUnmount = TRUE;

	//				// remove entry
	//				PLIST_ENTRY pltEntry = ExInterlockedRemoveHeadList(&pExt->m_ltRequestHead,&pExt->m_ltRequestLock);

	//				while(pltEntry)
	//				{
	//					// get srb pointer
	//					PSCSI_REQUEST_BLOCK pSrb = (CONTAINING_RECORD(pltEntry,SrbExt,m_ltEntry))->m_pSrb;

	//					// process it
	//					ProcessSrb(pExt,pSrb);

	//					// next entry
	//					pltEntry = ExInterlockedRemoveHeadList(&pExt->m_ltRequestHead,&pExt->m_ltRequestLock);
	//				}

	//				ZwClose(pExt->m_hFileHandle);
	//				pExt->m_hFileHandle = NULL;

	//				pExt->m_bEjectIrpForUnmount = FALSE;
	//			}
	//		}
	//		break;

	//	case IOCTL_MINIPORT_IS_MOUNTED:
	//		if(pSrb->DataTransferLength >= sizeof(SRB_IO_CONTROL) + sizeof(ULONG))
	//		{
	//			*reinterpret_cast<PULONG>(pIoCtl + 1) = pExt->m_hFileHandle != NULL;
	//			pSrb->SrbStatus = SRB_STATUS_SUCCESS;
	//		}
	//		else
	//		{
	//			pSrb->SrbStatus = SRB_STATUS_DATA_OVERRUN;
	//		}
	//		break;
	//	}
	//}

	devDebugPrint(DRIVER_NAME"*******DeviceIoControl,code 0x%x\n",pIoCtl->ControlCode);

	return TRUE;
}

// process scsi cmd
BOOLEAN DoScsiCmd(PMiniportExt pExt,PSCSI_REQUEST_BLOCK pSrb)
{
	if(pSrb->Cdb[0] > MAX_SCSI_CMD)
	{
		devDebugPrint(DRIVER_NAME"*******ScsiCmd : unknown(0x%x)\n",pSrb->Cdb[0]);
		return InvalidScsiCmd(pExt,pSrb);
	}

#ifdef DBG
	static PCHAR szScsiCmd[] = 
	{
		"test unit ready = 0",
		"rezero unit = 1",
		"vendor specific = 2",
		"request sense = 3",
		"format unit = 4",
		"read block limits = 5",
		"vendor specific = 6",
		"initialize element status = 7",
		NULL,//"read6 = 8",
		"vendor specific = 9",
		NULL,//"write6 = A",
		NULL,//"seek6 = B",
		"vendor specific = C",
		"vendor specific = D",
		"vendor specific = E",
		"vendor specific = F",

		"synchronize buffer = 10",
		"space = 11",
		"inquiry = 12",
		"verify = 13",
		"recover buffered data = 14",
		"mode select6 = 15",
		"reserve = 16",
		"release = 17",
		"copy = 18",
		"erase = 19",
		"mode sense6 = 1A",
		"stop start unit = 1B",
		"receive diagnostic results = 1C",
		"send diagnostic = 1D",
		"prevent allow medium removal = 1E",
		"1F",
		
		"vendor specific = 20",
		"vendor specific = 21",
		"vendor specific = 22",
		"vendor specific = 23",
		"set window = 24",
		"read caps = 25",
		"vendor specific = 26",
		"vendor specific = 27",
		NULL,//"read10 = 28",
		"read generation = 29",
		NULL,//"write10 = 2A",
		NULL,//"seek10 = 2B",
		"erase10 = 2C",
		"read updated block = 2D",
		"write and verify = 2E",
		"verify = 2F",

		"search data high = 30",
		"search data equal = 31",
		"search data low = 32",
		"set limits = 33",
		"prefetch = 34",
		"synchronize cache = 35",
		"lock unlock cache = 36",
		"read defect data = 37",
		"medium scan = 38",
		"compare = 39",
		"copy and verify = 3A",
		"write buffer = 3B",
		"read buffer = 3C",
		"update block = 3D",
		"read long = 3E",
		"write long = 3F",

		"change definition = 40",
		"write same = 41",
		"read sub channel = 42",
		"read toc = 43",
		"read header = 44",
		"read audio10 = 45",
		"46",
		"play audio smf = 47",
		"play audio track index = 48",
		"play audio relative10 = 49",
		"4A",
		"pause resume = 4B",
		"log select = 4C",
		"log sense = 4D",
		"4E",
		"4F",

		"50",
		"51",
		"52",
		"53",
		"54",
		"mode select10 = 55",
		"56",
		"57",
		"58",
		"59",
		"mode sense10 = 5A",
		"5B",
		"5C",
		"5D",
		"5E",
		"5F",
	};

	//if(g_pfnScsiCmdHandler[pSrb->Cdb[0]] == InvalidScsiCmd)
	if(szScsiCmd[pSrb->Cdb[0]])
		devDebugPrint(DRIVER_NAME"*******ScsiCmd : %s\n",szScsiCmd[pSrb->Cdb[0]]);	
#endif

	return g_pfnScsiCmdHandler[pSrb->Cdb[0]](pExt,pSrb);
}

// process srb
BOOLEAN ProcessSrb(PMiniportExt pExt,PSCSI_REQUEST_BLOCK pSrb)
{
	BOOLEAN bRet = TRUE;
	pSrb->SrbStatus = SRB_STATUS_SUCCESS;
	pSrb->ScsiStatus = SCSISTAT_GOOD;
	switch(pSrb->Function)
	{
	case SRB_FUNCTION_SHUTDOWN:
		devDebugPrint(DRIVER_NAME"*******SRB_FUNCTION_SHUTDOWN\n");
		break;

	case SRB_FUNCTION_FLUSH:
		devDebugPrint(DRIVER_NAME"*******SRB_FUNCTION_FLUSH\n");
		break;

	case SRB_FUNCTION_ABORT_COMMAND:
		pSrb->SrbStatus = SRB_STATUS_ABORT_FAILED;
		devDebugPrint(DRIVER_NAME"*******SRB_FUNCTION_ABORT_COMMAND\n");
		break;

	case SRB_FUNCTION_RESET_BUS:
		devDebugPrint(DRIVER_NAME"*******SRB_FUNCTION_RESET_BUS\n");
		break;

	case SRB_FUNCTION_EXECUTE_SCSI:
		bRet = DoScsiCmd(pExt,pSrb);
		break;

	case SRB_FUNCTION_IO_CONTROL:
		bRet = DoIoControl(pExt,pSrb);
		break;
	default:
		pSrb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
		devDebugPrint(DRIVER_NAME"*******SRB_FUNCTION_unknow %d\n",pSrb->Function);
		break;
	}

	PSrbExt pSrbExt = static_cast<PSrbExt>(pSrb->SrbExtension);
	ExInterlockedInsertTailList(&g_ltFinishHead,&pSrbExt->m_ltEntry,&g_ltFinishLock);

	return bRet;
}

// set sense code
VOID SetSrbSenseCode(PSCSI_REQUEST_BLOCK pSrb,ULONG ulErrorCode,...)
{
	PUCHAR pucSense = &g_ucSenseCodes[ulErrorCode][0];
	UCHAR  ucLen;
	va_list list;

	va_start(list, ulErrorCode);

	ucLen = pSrb->SenseInfoBufferLength;

	pSrb->SrbStatus  = pucSense[0];
	pSrb->ScsiStatus = pucSense[1];

	PSENSE_DATA pSenseData = static_cast<PSENSE_DATA>(pSrb->SenseInfoBuffer);

	if(ucLen > 0)
	{
		RtlZeroMemory(pSenseData, ucLen);

		pSenseData->ErrorCode = 0x70;

		if(ucLen >  2)
			pSenseData->SenseKey = pucSense[2];

		if(ucLen >  7)
			pSenseData->AdditionalSenseLength = 6;

		if(ucLen > 12)
			pSenseData->AdditionalSenseCode = pucSense[3];

		if(ucLen > 13)
			pSenseData->AdditionalSenseCodeQualifier = pucSense[4];
	};

	va_end(list);
}