NTSTATUS NTAPI Ext2PassDownSingleReadWriteIRP(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PtrExt2VCB PtrVCB,
LARGE_INTEGER ByteOffset,
uint32 ReadWriteLength,
BOOLEAN SynchronousIo)
{
NTSTATUS RC = STATUS_SUCCESS;
PEXT2_IO_CONTEXT PtrIoContext = NULL;
PKEVENT PtrSyncEvent = NULL;
PIO_STACK_LOCATION PtrIrpNextSp = NULL;
try
{
if( !PtrIrp->MdlAddress )
{
Ext2LockCallersBuffer( PtrIrp, TRUE, ReadWriteLength );
}
if( SynchronousIo )
{
PtrSyncEvent = Ext2AllocatePool( NonPagedPool, Ext2QuadAlign( sizeof(KEVENT) ) );
if ( !PtrSyncEvent )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
try_return();
}
KeInitializeEvent( PtrSyncEvent, SynchronizationEvent, FALSE );
}
//
// Allocate and initialize a completion context
//
PtrIoContext = Ext2AllocatePool(NonPagedPool, Ext2QuadAlign( sizeof(EXT2_IO_CONTEXT) ) );
if ( !PtrIoContext )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
try_return();
}
RtlZeroMemory( PtrIoContext, sizeof(EXT2_IO_CONTEXT) );
PtrIoContext->Count = 1;
PtrIoContext->NodeIdentifier.NodeType = EXT2_NODE_TYPE_IO_CONTEXT;
PtrIoContext->NodeIdentifier.NodeSize = sizeof( EXT2_IO_CONTEXT );
PtrIoContext->PtrMasterIrp = NULL;
PtrIoContext->PtrSyncEvent = PtrSyncEvent;
PtrIoContext->ReadWriteLength = ReadWriteLength;
IoSetCompletionRoutine( PtrIrp,
SynchronousIo ?
Ext2SingleSyncCompletionRoutine:
Ext2SingleAsyncCompletionRoutine,
PtrIoContext, TRUE, TRUE, TRUE );
//
// Setup the next IRP stack location in the associated Irp for the disk
// driver beneath us.
//
PtrIrpNextSp = IoGetNextIrpStackLocation( PtrIrp );
//
// Setup the Stack location to do a read from the disk driver.
//
PtrIrpNextSp->MajorFunction = PtrIrpContext->MajorFunction;
if( PtrIrpContext->MajorFunction == IRP_MJ_READ )
{
PtrIrpNextSp->Parameters.Read.Length = ReadWriteLength;
PtrIrpNextSp->Parameters.Read.ByteOffset = ByteOffset;
}
else if( PtrIrpContext->MajorFunction == IRP_MJ_WRITE )
{
PtrIrpNextSp->Parameters.Write.Length = ReadWriteLength;
PtrIrpNextSp->Parameters.Write.ByteOffset = ByteOffset;
}
//
// Issue the read / write request
//
RC = IoCallDriver(PtrVCB->TargetDeviceObject, PtrIrp);
if( SynchronousIo )
{
//
// Wait for completion...
//
RC = KeWaitForSingleObject( &PtrIoContext->PtrSyncEvent,
Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );
RC = STATUS_SUCCESS;
}
else
{
RC = STATUS_PENDING;
}
try_exit: NOTHING;
}
finally
{
if( PtrSyncEvent )
{
DebugTrace( DEBUG_TRACE_FREE, "Freeing = %lX [io]", PtrSyncEvent );
ExFreePool( PtrSyncEvent );
}
if( PtrIoContext && !( RC == STATUS_PENDING || RC == STATUS_SUCCESS ) )
{
//
// This means we are getting out of
// this function without doing a read / write
// due to an error, maybe...
//
DebugTrace( DEBUG_TRACE_FREE, "Freeing = %lX [io]", PtrIoContext );
ExFreePool( PtrIoContext );
}
}
return RC;
}
NTSTATUS
NdscAdapterCompletion(
IN PCCB Ccb,
IN PMINIPORT_DEVICE_EXTENSION HwDeviceExtension
)
{
KIRQL oldIrql;
static LONG SrbSeq;
LONG srbSeqIncremented;
PSCSI_REQUEST_BLOCK srb;
PCCB abortCcb;
NTSTATUS return_status;
UINT32 AdapterStatus, AdapterStatusBefore;
UINT32 NeedToUpdatePdoInfoInLSBus;
BOOLEAN busResetOccured;
KDPrint(4,("RequestExecuting = %d\n", HwDeviceExtension->RequestExecuting));
srb = Ccb->Srb;
if(!srb) {
KDPrint(2,("Ccb:%p CcbStatus %d. No srb assigned.\n", Ccb, Ccb->CcbStatus));
ASSERT(srb);
return STATUS_SUCCESS;
}
//
// NDASSCSI completion routine will do post operation to complete CCBs.
//
return_status = STATUS_MORE_PROCESSING_REQUIRED;
//
// Set SRB completion sequence for debugging
//
srbSeqIncremented = InterlockedIncrement(&SrbSeq);
#if 0
if(KeGetCurrentIrql() == PASSIVE_LEVEL) {
if((srbSeqIncremented%100) == 0) {
LARGE_INTEGER interval;
KDPrint(2,("Interval for debugging.\n"));
interval.QuadPart = - 11 * 10000000; // 10 seconds
KeDelayExecutionThread(KernelMode, FALSE, &interval);
}
}
#endif
//
// Update Adapter status flag
//
NeedToUpdatePdoInfoInLSBus = FALSE;
ACQUIRE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, &oldIrql);
// Save the bus-reset flag
if(ADAPTER_ISSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_BUSRESET_PENDING)) {
busResetOccured = TRUE;
} else {
busResetOccured = FALSE;
}
// Save the current flag
AdapterStatusBefore = HwDeviceExtension->AdapterStatus;
// Check reconnecting process.
if (LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_RECONNECTING)) {
ADAPTER_SETSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING);
} else {
ADAPTER_RESETSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING);
}
if (!LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_RAID_FLAG_VALID)) {
NDAS_ASSERT( Ccb->NdasrStatusFlag8 == 0 );
} else {
NDAS_ASSERT( Ccb->NdasrStatusFlag8 == CCBSTATUS_FLAG_RAID_DEGRADED >> 8 ||
Ccb->NdasrStatusFlag8 == CCBSTATUS_FLAG_RAID_RECOVERING >> 8 ||
Ccb->NdasrStatusFlag8 == CCBSTATUS_FLAG_RAID_FAILURE >> 8 ||
Ccb->NdasrStatusFlag8 == CCBSTATUS_FLAG_RAID_NORMAL >> 8 );
}
// Update adapter status only when CCBSTATUS_FLAG_RAID_FLAG_VALID is on.
// In other case, Ccb has no chance to get flag information from RAID.
if (LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_RAID_FLAG_VALID)) {
// Check to see if the associate member is in error.
if (LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_RAID_DEGRADED)) {
if (!ADAPTER_ISSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT)) {
KDPrint(2, ("NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT is Set\n") );
}
ADAPTER_SETSTATUSFLAG( HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT );
} else {
ADAPTER_RESETSTATUSFLAG( HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT );
}
// Check recovering process.
if (LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_RAID_RECOVERING)) {
if (!ADAPTER_ISSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING)) {
KDPrint(2, ("NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING is Set\n") );
}
ADAPTER_SETSTATUSFLAG( HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING );
} else {
ADAPTER_RESETSTATUSFLAG( HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING );
}
// Check RAID failure
if (LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_RAID_FAILURE)) {
if (!ADAPTER_ISSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RAID_FAILURE)) {
KDPrint(2, ("NDASSCSI_ADAPTER_STATUSFLAG_RAID_FAILURE is Set\n") );
}
ADAPTER_SETSTATUSFLAG( HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RAID_FAILURE );
} else {
ADAPTER_RESETSTATUSFLAG( HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RAID_FAILURE );
}
// Set RAID normal status
if (LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_RAID_NORMAL)) {
if (!ADAPTER_ISSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RAID_NORMAL)) {
KDPrint(2, ("NDASSCSI_ADAPTER_STATUSFLAG_RAID_NORMAL is Set\n") );
}
ADAPTER_SETSTATUSFLAG( HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RAID_NORMAL );
} else {
ADAPTER_RESETSTATUSFLAG( HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_RAID_NORMAL );
}
}
// power-recycle occurred.
if(LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_POWERRECYLE_OCCUR)) {
ADAPTER_SETSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_POWERRECYCLED);
} else {
ADAPTER_RESETSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_POWERRECYCLED);
}
if (ADAPTER_ISSTATUSFLAG(HwDeviceExtension, NDASSCSI_ADAPTER_STATUSFLAG_POWERRECYCLED)) {
//NDAS_ASSERT( FALSE );
}
AdapterStatus = HwDeviceExtension->AdapterStatus;
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
if(AdapterStatus != AdapterStatusBefore)
{
if(
!(AdapterStatusBefore & NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT) &&
(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT)
)
{
// NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT on
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_MEMBER_FAULT, EVTLOG_MEMBER_IN_ERROR);
KDPrint(2,("Ccb:%p CcbStatus %d. Set member fault.\n", Ccb, Ccb->CcbStatus));
}
if(
(AdapterStatusBefore & NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT) &&
!(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT)
)
{
// NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT off
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_MEMBER_FAULT_RECOVERED, EVTLOG_MEMBER_RECOVERED);
KDPrint(2,("Ccb:%p CcbStatus %d. Reset member fault.\n", Ccb, Ccb->CcbStatus));
}
if(
!(AdapterStatusBefore & NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING) &&
(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING)
)
{
// NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING on
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_RECONNECT_START, EVTLOG_START_RECONNECTION);
KDPrint(2,("Ccb:%p CcbStatus %d. Start reconnecting\n", Ccb, Ccb->CcbStatus));
}
if(
(AdapterStatusBefore & NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING) &&
!(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING)
)
{
// NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING off
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_RECONNECTED, EVTLOG_END_RECONNECTION);
KDPrint(2,("Ccb:%p CcbStatus %d. Finish reconnecting\n", Ccb, Ccb->CcbStatus));
}
if(
!(AdapterStatusBefore & NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING) &&
(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING)
)
{
// NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING on
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_RECOVERY_START, EVTLOG_START_RECOVERING);
KDPrint(2,("Ccb:%p CcbStatus %d. Started recovering\n", Ccb, Ccb->CcbStatus));
}
if(
(AdapterStatusBefore & NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING) &&
!(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING) &&
!(AdapterStatus & (NDASSCSI_ADAPTER_STATUSFLAG_RAID_FAILURE|NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT)) &&
(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_RAID_NORMAL))
{
// NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING off
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_RECOVERED, EVTLOG_END_RECOVERING);
KDPrint(2,("Ccb:%p CcbStatus %d. Ended recovering\n", Ccb, Ccb->CcbStatus));
}
if (
(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_RAID_FAILURE) &&
!(AdapterStatusBefore & NDASSCSI_ADAPTER_STATUSFLAG_RAID_FAILURE))
{
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_RAID_FAILURE, EVTLOG_RAID_FAILURE);
KDPrint(2,("Ccb:%p CcbStatus %d. RAID failure\n", Ccb, Ccb->CcbStatus));
}
if(
!(AdapterStatusBefore & NDASSCSI_ADAPTER_STATUSFLAG_POWERRECYCLED) &&
(AdapterStatus & NDASSCSI_ADAPTER_STATUSFLAG_POWERRECYCLED)
)
{
// NDASSCSI_ADAPTER_STATUSFLAG_POWERRECYCLED on
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_DISK_POWERRECYCLE, EVTLOG_DISK_POWERRECYCLED);
KDPrint(2,("Ccb:%p CcbStatus %d. Started recovering\n", Ccb, Ccb->CcbStatus));
}
NeedToUpdatePdoInfoInLSBus = TRUE;
}
//
// If CCB_OPCODE_UPDATE is successful, update adapter status in LanscsiBus
//
if(Ccb->OperationCode == CCB_OPCODE_UPDATE) {
if(Ccb->CcbStatus == CCB_STATUS_SUCCESS) {
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_UPGRADE_SUCC, EVTLOG_SUCCEED_UPGRADE);
} else {
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_UPGRADE_FAIL, EVTLOG_FAIL_UPGRADE);
}
NeedToUpdatePdoInfoInLSBus = TRUE;
}
//
// Copy IO control results to the SRB buffer.
//
// If device lock CCB is successful, copy the result to the SRB.
//
if(Ccb->OperationCode == CCB_OPCODE_DEVLOCK) {
if(Ccb->CcbStatus == CCB_STATUS_SUCCESS) {
PSRB_IO_CONTROL srbIoctlHeader;
PUCHAR lockIoctlBuffer;
PNDSCIOCTL_DEVICELOCK ioCtlAcReDeviceLock;
PLURN_DEVLOCK_CONTROL lurnAcReDeviceLock;
//
// Get the Ioctl buffer.
//
srbIoctlHeader = (PSRB_IO_CONTROL)srb->DataBuffer;
srbIoctlHeader->ReturnCode = SRB_STATUS_SUCCESS;
lockIoctlBuffer = (PUCHAR)(srbIoctlHeader + 1);
ioCtlAcReDeviceLock = (PNDSCIOCTL_DEVICELOCK)lockIoctlBuffer;
lurnAcReDeviceLock = (PLURN_DEVLOCK_CONTROL)Ccb->DataBuffer;
// Copy the result
RtlCopyMemory( ioCtlAcReDeviceLock->LockData,
lurnAcReDeviceLock->LockData,
NDSCLOCK_LOCKDATA_LENGTH);
}
} else if(Ccb->OperationCode == CCB_OPCODE_QUERY) {
if(Ccb->CcbStatus == CCB_STATUS_SUCCESS) {
PSRB_IO_CONTROL srbIoctlHeader;
NTSTATUS copyStatus;
srbIoctlHeader = (PSRB_IO_CONTROL)srb->DataBuffer;
copyStatus = NdscCopyQueryOutputToSrb(
HwDeviceExtension,
Ccb->DataBufferLength,
Ccb->DataBuffer,
srbIoctlHeader->Length,
(PUCHAR)(srbIoctlHeader + 1)
);
if(copyStatus == STATUS_BUFFER_TOO_SMALL) {
srbIoctlHeader->ReturnCode = SRB_STATUS_DATA_OVERRUN;
}else if(NT_SUCCESS(copyStatus)) {
srbIoctlHeader->ReturnCode = SRB_STATUS_SUCCESS;
} else {
srbIoctlHeader->ReturnCode = SRB_STATUS_ERROR;
}
}
}
KDPrint(4,("CcbStatus %d\n", Ccb->CcbStatus));
//
// Translate CcbStatus to SrbStatus
//
CcbStatusToSrbStatus(Ccb, srb);
//
// Perform stop process when we get stop status.
//
if(Ccb->CcbStatus == CCB_STATUS_STOP) {
//
// Stop in the timer routine.
//
KDPrint(2, ("Stop status. Stop in the timer routine.\n"));
} else {
//
// Update PDO information on the NDAS bus.
//
if(NeedToUpdatePdoInfoInLSBus)
{
KDPrint(2, ("<<<<<<<<<<<<<<<< %08lx -> %08lx ADAPTER STATUS CHANGED"
" >>>>>>>>>>>>>>>>\n", AdapterStatusBefore, AdapterStatus));
UpdatePdoInfoInLSBus(HwDeviceExtension, HwDeviceExtension->AdapterStatus);
}
}
//
// Process Abort CCB.
//
abortCcb = Ccb->AbortCcb;
if(abortCcb != NULL) {
KDPrint(2,("abortSrb\n"));
ASSERT(FALSE);
srb->SrbStatus = SRB_STATUS_SUCCESS;
LsCcbSetStatusFlag(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE);
InitializeListHead(&Ccb->ListEntry);
ExInterlockedInsertTailList(
&HwDeviceExtension->CcbTimerCompletionList,
&Ccb->ListEntry,
&HwDeviceExtension->CcbTimerCompletionListSpinLock
);
((PSCSI_REQUEST_BLOCK)abortCcb->Srb)->SrbStatus = SRB_STATUS_ABORTED;
LsCcbSetStatusFlag(abortCcb, CCBSTATUS_FLAG_TIMER_COMPLETE);
InitializeListHead(&abortCcb->ListEntry);
ExInterlockedInsertTailList(
&HwDeviceExtension->CcbTimerCompletionList,
&abortCcb->ListEntry,
&HwDeviceExtension->CcbTimerCompletionListSpinLock
);
} else {
BOOLEAN criticalSrb;
//
// We should not use completion IRP method with disable-disconnect flag.
// A SRB with DISABLE_DISCONNECT flag causes the SCSI port queue locked.
//
criticalSrb = (srb->SrbFlags & SRB_FLAGS_DISABLE_DISCONNECT) != 0 ||
(srb->SrbFlags & SRB_FLAGS_BYPASS_FROZEN_QUEUE) != 0 ||
(srb->SrbFlags & SRB_FLAGS_BYPASS_LOCKED_QUEUE) != 0;
#if DBG
if(criticalSrb) {
KDPrint(2, ("Critical Srb:%p\n", srb));
}
#if 0
NdscPrintSrb("Comp:", srb);
#endif
#endif
//
// Make Complete IRP and Send it.
//
//
// In case of HostStatus == CCB_STATUS_SUCCESS_TIMER, CCB will go to the timer to complete.
//
if( (Ccb->CcbStatus == CCB_STATUS_SUCCESS || Ccb->CcbStatus == CCB_STATUS_DATA_OVERRUN) &&
!LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE) &&
!LsCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_BUSCHANGE) &&
!busResetOccured &&
!criticalSrb
)
{
PDEVICE_OBJECT pDeviceObject = HwDeviceExtension->ScsiportFdoObject;
PIRP pCompletionIrp = NULL;
PIO_STACK_LOCATION pIoStack;
NTSTATUS ntStatus;
PSCSI_REQUEST_BLOCK completionSrb = NULL;
PCOMPLETION_DATA completionData = NULL;
completionSrb = ExAllocatePoolWithTag(NonPagedPool, sizeof(SCSI_REQUEST_BLOCK), NDSC_PTAG_SRB);
if(completionSrb == NULL)
goto Out;
RtlZeroMemory(
completionSrb,
sizeof(SCSI_REQUEST_BLOCK)
);
// Build New IRP.
pCompletionIrp = IoAllocateIrp((CCHAR)(pDeviceObject->StackSize + 1), FALSE);
if(pCompletionIrp == NULL) {
ExFreePoolWithTag(completionSrb, NDSC_PTAG_SRB);
goto Out;
}
completionData = ExAllocatePoolWithTag(NonPagedPool, sizeof(COMPLETION_DATA), NDSC_PTAG_CMPDATA);
if(completionData == NULL) {
ExFreePoolWithTag(completionSrb, NDSC_PTAG_SRB);
IoFreeIrp(pCompletionIrp);
pCompletionIrp = NULL;
goto Out;
}
pCompletionIrp->MdlAddress = NULL;
// Set IRP stack location.
pIoStack = IoGetNextIrpStackLocation(pCompletionIrp);
pIoStack->DeviceObject = pDeviceObject;
pIoStack->MajorFunction = IRP_MJ_SCSI;
pIoStack->Parameters.DeviceIoControl.InputBufferLength = 0;
pIoStack->Parameters.DeviceIoControl.OutputBufferLength = 0;
pIoStack->Parameters.Scsi.Srb = completionSrb;
// Set SRB.
completionSrb->Length = sizeof(SCSI_REQUEST_BLOCK);
completionSrb->Function = SRB_FUNCTION_EXECUTE_SCSI;
completionSrb->PathId = srb->PathId;
completionSrb->TargetId = srb->TargetId;
completionSrb->Lun = srb->Lun;
completionSrb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
completionSrb->DataBuffer = Ccb;
completionSrb->SrbFlags |= SRB_FLAGS_BYPASS_FROZEN_QUEUE | SRB_FLAGS_NO_QUEUE_FREEZE;
completionSrb->OriginalRequest = pCompletionIrp;
completionSrb->CdbLength = MAXIMUM_CDB_SIZE;
completionSrb->Cdb[0] = SCSIOP_COMPLETE;
completionSrb->Cdb[1] = (UCHAR)srbSeqIncremented;
completionSrb->TimeOutValue = 20;
completionSrb->SrbStatus = SRB_STATUS_SUCCESS;
//
// Set completion data for the completion IRP.
//
completionData->HwDeviceExtension = HwDeviceExtension;
completionData->CompletionSrb = completionSrb;
completionData->ShippedCcb = Ccb;
completionData->ShippedCcbAllocatedFromPool = LsCcbIsFlagOn(Ccb, CCB_FLAG_ALLOCATED);
Out:
KDPrint(5,("Before Completion\n"));
IoSetCompletionRoutine( pCompletionIrp,
CompletionIrpCompletionRoutine,
completionData,
TRUE, TRUE, TRUE);
ASSERT(HwDeviceExtension->RequestExecuting != 0);
#if 0
{
LARGE_INTEGER interval;
ULONG SrbTimeout;
static DebugCount = 0;
DebugCount ++;
SrbTimeout = ((PSCSI_REQUEST_BLOCK)(Ccb->Srb))->TimeOutValue;
if( SrbTimeout>9 &&
(DebugCount%1000) == 0
) {
KDPrint(2,("Experiment!!!!!!! Delay completion. SrbTimeout:%d\n", SrbTimeout));
interval.QuadPart = - (INT64)SrbTimeout * 11 * 1000000;
KeDelayExecutionThread(KernelMode, FALSE, &interval);
}
}
#endif
//
// call Scsiport FDO.
//
ntStatus = IoCallDriver(pDeviceObject, pCompletionIrp);
ASSERT(NT_SUCCESS(ntStatus));
if(ntStatus!= STATUS_SUCCESS && ntStatus!= STATUS_PENDING) {
KDPrint(2,("ntStatus = 0x%x\n", ntStatus));
SCSI_PORT_LOG_ERROR_MODULE_COMPLETION(NDASSCSI_IO_COMPIRP_FAIL, EVTLOG_FAIL_COMPLIRP);
KDPrint(2,("IoCallDriver() error. CCB(%p) and SRB(%p) is going to the timer."
" CcbStatus:%x CcbFlag:%x\n", Ccb, Ccb->Srb, Ccb->CcbStatus, Ccb->Flags));
InitializeListHead(&Ccb->ListEntry);
LsCcbSetStatusFlag(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE);
ExInterlockedInsertTailList(
&HwDeviceExtension->CcbTimerCompletionList,
&Ccb->ListEntry,
&HwDeviceExtension->CcbTimerCompletionListSpinLock
);
}
} else {
KDPrint(2,("CCB(%p) and SRB(%p) is going to the timer."
" CcbStatus:%x CcbFlag:%x\n", Ccb, Ccb->Srb, Ccb->CcbStatus, Ccb->Flags));
InitializeListHead(&Ccb->ListEntry);
LsCcbSetStatusFlag(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE);
ExInterlockedInsertTailList(
&HwDeviceExtension->CcbTimerCompletionList,
&Ccb->ListEntry,
&HwDeviceExtension->CcbTimerCompletionListSpinLock
);
}
}
return return_status;
}
NTSTATUS
NdasDluSendIoctlSrb(
IN PDEVICE_OBJECT DeviceObject,
IN ULONG IoctlCode,
IN PVOID InputBuffer,
IN LONG InputBufferLength,
OUT PVOID OutputBuffer,
IN LONG OutputBufferLength
) {
PIRP irp;
KEVENT event;
PSRB_IO_CONTROL psrbIoctl;
LONG srbIoctlLength;
PVOID srbIoctlBuffer;
LONG srbIoctlBufferLength;
NTSTATUS status;
PIO_STACK_LOCATION irpStack;
SCSI_REQUEST_BLOCK srb;
LARGE_INTEGER startingOffset;
IO_STATUS_BLOCK ioStatusBlock;
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
psrbIoctl = NULL;
irp = NULL;
//
// build an SRB for the miniport
//
srbIoctlBufferLength = (InputBufferLength>OutputBufferLength)?InputBufferLength:OutputBufferLength;
srbIoctlLength = sizeof(SRB_IO_CONTROL) + srbIoctlBufferLength;
psrbIoctl = (PSRB_IO_CONTROL)ExAllocatePoolWithTag(NonPagedPool , srbIoctlLength, NDAS_DLU_PTAG_SRB_IOCTL);
if(psrbIoctl == NULL) {
KDPrint(1, ("STATUS_INSUFFICIENT_RESOURCES\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
RtlZeroMemory(psrbIoctl, srbIoctlLength);
psrbIoctl->HeaderLength = sizeof(SRB_IO_CONTROL);
RtlCopyMemory(psrbIoctl->Signature, NDASSCSI_IOCTL_SIGNATURE, 8);
psrbIoctl->Timeout = 10;
psrbIoctl->ControlCode = IoctlCode;
psrbIoctl->Length = srbIoctlBufferLength;
srbIoctlBuffer = (PUCHAR)psrbIoctl + sizeof(SRB_IO_CONTROL);
RtlCopyMemory(srbIoctlBuffer, InputBuffer, InputBufferLength);
//
// Initialize the notification event.
//
KeInitializeEvent(&event,
NotificationEvent,
FALSE);
startingOffset.QuadPart = 1;
//
// Build IRP for this request.
// Note we do this synchronously for two reasons. If it was done
// asynchronously then the completion code would have to make a special
// check to deallocate the buffer. Second if a completion routine were
// used then an additional IRP stack location would be needed.
//
irp = IoBuildSynchronousFsdRequest(
IRP_MJ_SCSI,
DeviceObject,
psrbIoctl,
srbIoctlLength,
&startingOffset,
&event,
&ioStatusBlock);
irpStack = IoGetNextIrpStackLocation(irp);
if (irp == NULL) {
KDPrint(1,("STATUS_INSUFFICIENT_RESOURCES\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
//
// Set major and minor codes.
//
irpStack->MajorFunction = IRP_MJ_SCSI;
irpStack->MinorFunction = 1;
//
// Fill in SRB fields.
//
irpStack->Parameters.Others.Argument1 = &srb;
//
// Zero out the srb.
//
RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
srb.PathId = 0;
srb.TargetId = 0;
srb.Lun = 0;
srb.Function = SRB_FUNCTION_IO_CONTROL;
srb.Length = sizeof(SCSI_REQUEST_BLOCK);
srb.SrbFlags = SRB_FLAGS_DATA_IN | SRB_FLAGS_NO_QUEUE_FREEZE;
srb.QueueAction = SRB_SIMPLE_TAG_REQUEST;
srb.QueueTag = SP_UNTAGGED;
srb.OriginalRequest = irp;
//
// Set timeout to requested value.
//
srb.TimeOutValue = psrbIoctl->Timeout;
//
// Set the data buffer.
//
srb.DataBuffer = psrbIoctl;
srb.DataTransferLength = srbIoctlLength;
//
// Flush the data buffer for output. This will insure that the data is
// written back to memory. Since the data-in flag is the the port driver
// will flush the data again for input which will ensure the data is not
// in the cache.
//
/*
KeFlushIoBuffers(irp->MdlAddress, FALSE, TRUE);
*/
status = IoCallDriver( DeviceObject, irp );
//
// Wait for request to complete.
//
if (status == STATUS_PENDING) {
(VOID)KeWaitForSingleObject(
&event,
Executive,
KernelMode,
FALSE,
(PLARGE_INTEGER)NULL
);
status = ioStatusBlock.Status;
}
//
// get the result
//
if(status == STATUS_SUCCESS) {
if(OutputBuffer && OutputBufferLength)
RtlCopyMemory(OutputBuffer, srbIoctlBuffer, OutputBufferLength);
KDPrint(1,("Ioctl(%08lx) succeeded!\n", IoctlCode));
}
cleanup:
if(psrbIoctl)
ExFreePool(psrbIoctl);
return status;
}
BOOLEAN
NTAPI
FsRecReadBlock(IN PDEVICE_OBJECT DeviceObject,
IN PLARGE_INTEGER Offset,
IN ULONG Length,
IN ULONG SectorSize,
IN OUT PVOID *Buffer,
OUT PBOOLEAN DeviceError OPTIONAL)
{
IO_STATUS_BLOCK IoStatusBlock;
KEVENT Event;
PIRP Irp;
NTSTATUS Status;
PAGED_CODE();
/* Assume failure */
if (DeviceError) *DeviceError = FALSE;
/* Check if the caller requested too little */
if (Length < SectorSize)
{
/* Read at least the sector size */
Length = SectorSize;
}
else
{
/* Otherwise, just round up the request to sector size */
Length = ROUND_UP(Length, SectorSize);
}
/* Check if the caller gave us a buffer */
if (!*Buffer)
{
/* He didn't, allocate one */
*Buffer = ExAllocatePoolWithTag(NonPagedPool,
ROUND_TO_PAGES(Length),
FSREC_TAG);
if (!*Buffer) return FALSE;
}
/* Build the IRP */
KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
DeviceObject,
*Buffer,
Length,
Offset,
&Event,
&IoStatusBlock);
if (!Irp) return FALSE;
/* Override verification */
IoGetNextIrpStackLocation(Irp)->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
/* Do the request */
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
/* Wait for completion */
KeWaitForSingleObject(&Event,
Executive,
KernelMode,
FALSE,
NULL);
Status = IoStatusBlock.Status;
}
/* Check if we couldn't get the data */
if (!NT_SUCCESS(Status))
{
/* Check if caller wanted to know about the device and fail */
if (DeviceError) *DeviceError = TRUE;
return FALSE;
}
/* All went well */
return TRUE;
}
/*
* @implemented
*/
VOID
SendLinkDeleted(IN PUNICODE_STRING DeviceName,
IN PUNICODE_STRING SymbolicName)
{
PIRP Irp;
KEVENT Event;
ULONG NameSize;
NTSTATUS Status;
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION Stack;
PMOUNTDEV_NAME Name = NULL;
PDEVICE_OBJECT DeviceObject;
IO_STATUS_BLOCK IoStatusBlock;
/* Get the device associated with the name */
Status = IoGetDeviceObjectPointer(DeviceName,
FILE_READ_ATTRIBUTES,
&FileObject,
&DeviceObject);
if (!NT_SUCCESS(Status))
{
return;
}
/* Get attached device (will notify it) */
DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
/* NameSize is the size of the whole MOUNTDEV_NAME struct */
NameSize = sizeof(USHORT) + SymbolicName->Length;
Name = AllocatePool(NameSize);
if (!Name)
{
goto Cleanup;
}
/* Initialize struct */
Name->NameLength = SymbolicName->Length;
RtlCopyMemory(Name->Name, SymbolicName->Buffer, SymbolicName->Length);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
/* Cf: SendLinkCreated comment */
Irp = IoBuildDeviceIoControlRequest(CTL_CODE(MOUNTDEVCONTROLTYPE, 5, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
DeviceObject,
Name,
NameSize,
NULL,
0,
FALSE,
&Event,
&IoStatusBlock);
/* This one can fail, no one matters */
if (Irp)
{
Stack = IoGetNextIrpStackLocation(Irp);
Stack->FileObject = FileObject;
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
}
}
/* Then, second one */
KeInitializeEvent(&Event, NotificationEvent, FALSE);
Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_LINK_DELETED,
DeviceObject,
Name,
NameSize,
NULL,
0,
FALSE,
&Event,
&IoStatusBlock);
if (!Irp)
{
goto Cleanup;
}
Stack = IoGetNextIrpStackLocation(Irp);
Stack->FileObject = FileObject;
/* Really notify */
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
}
Cleanup:
if (Name)
{
FreePool(Name);
}
ObDereferenceObject(DeviceObject);
ObDereferenceObject(FileObject);
return;
}
NTSTATUS
W2KNtfsPerformVerifyDiskRead (
IN PDEVICE_OBJECT DeviceObject,
IN PVOID Buffer,
IN LONGLONG Offset,
IN ULONG NumberOfBytesToRead
)
/*++
Routine Description:
This routine is used to read in a range of bytes from the disk. It
bypasses all of the caching and regular I/O logic, and builds and issues
the requests itself. It does this operation overriding the verify
volume flag in the device object.
Arguments:
Vcb - Supplies the Vcb denoting the device for this operation
Buffer - Supplies the buffer that will recieve the results of this operation
Offset - Supplies the offset of where to start reading
NumberOfBytesToRead - Supplies the number of bytes to read, this must
be in multiple of bytes units acceptable to the disk driver.
Return Value:
None.
--*/
{
KEVENT Event;
PIRP Irp;
NTSTATUS Status;
PAGED_CODE();
//
// Initialize the event we're going to use
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
//
// Build the irp for the operation and also set the overrride flag
//
// Note that we may be at APC level, so do this asyncrhonously and
// use an event for synchronization normal request completion
// cannot occur at APC level.
//
Irp = IoBuildAsynchronousFsdRequest( IRP_MJ_READ,
DeviceObject,
Buffer,
NumberOfBytesToRead,
(PLARGE_INTEGER)&Offset,
NULL );
if ( Irp == NULL ) {
return STATUS_INSUFFICIENT_RESOURCES;
}
SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
//
// Set up the completion routine
//
IoSetCompletionRoutine( Irp,
W2KNtfsVerifyReadCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
//
// Call the device to do the write and wait for it to finish.
//
try {
(VOID)IoCallDriver( DeviceObject, Irp );
(VOID)KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );
//
// Grab the Status.
//
Status = Irp->IoStatus.Status;
} finally {
//
// If there is an MDL (or MDLs) associated with this I/O
// request, Free it (them) here. This is accomplished by
// walking the MDL list hanging off of the IRP and deallocating
// each MDL encountered.
//
while (Irp->MdlAddress != NULL) {
PMDL NextMdl;
NextMdl = Irp->MdlAddress->Next;
MmUnlockPages( Irp->MdlAddress );
IoFreeMdl( Irp->MdlAddress );
Irp->MdlAddress = NextMdl;
}
IoFreeIrp( Irp );
}
//
// If it doesn't succeed then raise the error
//
return Status;
}
NTSTATUS
HidClassFDO_QueryCapabilities(
IN PDEVICE_OBJECT DeviceObject,
IN OUT PDEVICE_CAPABILITIES Capabilities)
{
PIRP Irp;
KEVENT Event;
NTSTATUS Status;
PIO_STACK_LOCATION IoStack;
PHIDCLASS_FDO_EXTENSION FDODeviceExtension;
//
// get device extension
//
FDODeviceExtension = DeviceObject->DeviceExtension;
ASSERT(FDODeviceExtension->Common.IsFDO);
//
// init event
//
KeInitializeEvent(&Event, NotificationEvent, FALSE);
//
// now allocte the irp
//
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
if (!Irp)
{
//
// no memory
//
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// get next stack location
//
IoStack = IoGetNextIrpStackLocation(Irp);
//
// init stack location
//
IoStack->MajorFunction = IRP_MJ_PNP;
IoStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
IoStack->Parameters.DeviceCapabilities.Capabilities = Capabilities;
//
// set completion routine
//
IoSetCompletionRoutine(Irp, HidClassFDO_QueryCapabilitiesCompletionRoutine, &Event, TRUE, TRUE, TRUE);
//
// init capabilities
//
RtlZeroMemory(Capabilities, sizeof(DEVICE_CAPABILITIES));
Capabilities->Size = sizeof(DEVICE_CAPABILITIES);
Capabilities->Version = 1; // FIXME hardcoded constant
Capabilities->Address = MAXULONG;
Capabilities->UINumber = MAXULONG;
//
// pnp irps have default completion code
//
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
//
// call lower device
//
Status = IoCallDriver(FDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject, Irp);
if (Status == STATUS_PENDING)
{
//
// wait for completion
//
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
}
//
// get status
//
Status = Irp->IoStatus.Status;
//
// complete request
//
IoFreeIrp(Irp);
//
// done
//
return Status;
}
/*
* Dispatch routines call this function to complete their processing.
* They _MUST_ call this function anyway.
*/
NTSTATUS
tdi_dispatch_complete(PDEVICE_OBJECT devobj, PIRP irp, int filter,
PIO_COMPLETION_ROUTINE cr, PVOID context)
{
PIO_STACK_LOCATION irps = IoGetCurrentIrpStackLocation(irp);
NTSTATUS status;
if (filter == FILTER_DENY) {
/*
* DENY: complete request with status "Access violation"
*/
KdPrint(("[tdi_fw] tdi_dispatch_complete: [DROP!]"
" major 0x%x, minor 0x%x for devobj 0x%x; fileobj 0x%x\n",
irps->MajorFunction,
irps->MinorFunction,
devobj,
irps->FileObject));
if (irp->IoStatus.Status == STATUS_SUCCESS) {
// change status
status = irp->IoStatus.Status = STATUS_ACCESS_DENIED;
} else {
// set IRP status unchanged
status = irp->IoStatus.Status;
}
IoCompleteRequest (irp, IO_NO_INCREMENT);
} else if (filter == FILTER_ALLOW) {
/*
* ALLOW: pass IRP to the next driver
*/
#ifndef USE_TDI_HOOKING
PDEVICE_OBJECT old_devobj = get_original_devobj(devobj, NULL);
if (old_devobj == NULL) {
KdPrint(("[tdi_fw] tdi_send_irp_to_old_driver: Unknown DeviceObject 0x%x!\n", devobj));
status = irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
IoCompleteRequest (irp, IO_NO_INCREMENT);
return status;
}
#endif
KdPrint(("[tdi_fw] tdi_dispatch_complete: [ALLOW.]"
" major 0x%x, minor 0x%x for devobj 0x%x; fileobj 0x%x\n",
irps->MajorFunction,
irps->MinorFunction,
devobj,
irps->FileObject));
#ifndef USE_TDI_HOOKING
if (cr == NULL || irp->CurrentLocation <= 1) {
/*
* we use _THIS_ way of sending IRP to old driver
* a) to avoid NO_MORE_STACK_LOCATIONS
* b) and if we haven't our completions - no need to copy stack locations!
*/
// stay on this location after IoCallDriver
IoSkipCurrentIrpStackLocation(irp);
#endif
if (cr != NULL) {
/*
* set completion routine (this way is slow)
*/
// save old completion routine and context
TDI_SKIP_CTX *ctx = (TDI_SKIP_CTX *)malloc_np(sizeof(*ctx));
if (ctx == NULL) {
KdPrint(("[tdi_fw] tdi_send_irp_to_old_driver: malloc_np\n"));
status = irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
IoCompleteRequest(irp, IO_NO_INCREMENT);
return status;
}
ctx->old_cr = irps->CompletionRoutine;
ctx->old_context = irps->Context;
ctx->new_cr = cr;
ctx->new_context = context;
ctx->fileobj = irps->FileObject;
ctx->new_devobj = devobj;
ctx->old_control = irps->Control;
IoSetCompletionRoutine(irp, tdi_skip_complete, ctx, TRUE, TRUE, TRUE);
}
#ifndef USE_TDI_HOOKING
} else {
PIO_STACK_LOCATION irps = IoGetCurrentIrpStackLocation(irp),
next_irps = IoGetNextIrpStackLocation(irp);
memcpy(next_irps, irps, sizeof(*irps));
if (cr != NULL) {
/*
* this way for completion is more quicker than used above
*/
IoSetCompletionRoutine(irp, cr, context, TRUE, TRUE, TRUE);
} else
IoSetCompletionRoutine(irp, tdi_generic_complete, NULL, TRUE, TRUE, TRUE);
}
#endif
/* call original driver */
#ifndef USE_TDI_HOOKING
status = IoCallDriver(old_devobj, irp);
#else
status = g_old_DriverObject.MajorFunction[irps->MajorFunction](devobj, irp);
#endif
} else { /* FILTER_UNKNOWN */
/*
* UNKNOWN: just complete the request
*/
status = irp->IoStatus.Status = STATUS_SUCCESS; // ???
IoCompleteRequest (irp, IO_NO_INCREMENT);
}
return status;
}
NTSTATUS
Ext2Flush (IN PEXT2_IRP_CONTEXT IrpContext)
{
NTSTATUS Status = STATUS_SUCCESS;
PIRP Irp = NULL;
PIO_STACK_LOCATION IrpSp = NULL;
PEXT2_VCB Vcb = NULL;
PEXT2_FCB Fcb = NULL;
PEXT2_FCBVCB FcbOrVcb = NULL;
PEXT2_CCB Ccb = NULL;
PFILE_OBJECT FileObject = NULL;
PDEVICE_OBJECT DeviceObject = NULL;
BOOLEAN MainResourceAcquired = FALSE;
__try {
ASSERT(IrpContext);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
//
// This request is not allowed on the main device object
//
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
ASSERT(Vcb != NULL);
ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)));
ASSERT(IsMounted(Vcb));
if ( IsFlagOn(Vcb->Flags, VCB_READ_ONLY) ||
IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {
Status = STATUS_SUCCESS;
__leave;
}
Irp = IrpContext->Irp;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
FileObject = IrpContext->FileObject;
FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;
ASSERT(FcbOrVcb != NULL);
Ccb = (PEXT2_CCB) FileObject->FsContext2;
if (Ccb == NULL) {
Status = STATUS_SUCCESS;
__leave;
}
MainResourceAcquired =
ExAcquireResourceExclusiveLite(&FcbOrVcb->MainResource,
IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
ASSERT(MainResourceAcquired);
DEBUG(DL_INF, ("Ext2Flush-pre: total mcb records=%u\n",
FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));
if (FcbOrVcb->Identifier.Type == EXT2VCB) {
Ext2VerifyVcb(IrpContext, Vcb);
Status = Ext2FlushFiles(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);
if (NT_SUCCESS(Status)) {
__leave;
}
Status = Ext2FlushVolume(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);
if (NT_SUCCESS(Status) && IsFlagOn(Vcb->Volume->Flags, FO_FILE_MODIFIED)) {
ClearFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);
}
} else if (FcbOrVcb->Identifier.Type == EXT2FCB) {
Fcb = (PEXT2_FCB)(FcbOrVcb);
Status = Ext2FlushFile(IrpContext, Fcb, Ccb);
if (NT_SUCCESS(Status)) {
if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {
Fcb->Mcb->FileAttr |= FILE_ATTRIBUTE_ARCHIVE;
ClearFlag(FileObject->Flags, FO_FILE_MODIFIED);
}
}
}
DEBUG(DL_INF, ("Ext2Flush-post: total mcb records=%u\n",
FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));
} __finally {
if (MainResourceAcquired) {
ExReleaseResourceLite(&FcbOrVcb->MainResource);
}
if (!IrpContext->ExceptionInProgress) {
if (Vcb && Irp && IrpSp && (!IsFlagOn(Vcb->Flags, VCB_READ_ONLY))) {
// Call the disk driver to flush the physial media.
NTSTATUS DriverStatus;
PIO_STACK_LOCATION NextIrpSp;
NextIrpSp = IoGetNextIrpStackLocation(Irp);
*NextIrpSp = *IrpSp;
IoSetCompletionRoutine( Irp,
Ext2FlushCompletionRoutine,
NULL,
TRUE,
TRUE,
TRUE );
DriverStatus = IoCallDriver(Vcb->TargetDeviceObject, Irp);
Status = (DriverStatus == STATUS_INVALID_DEVICE_REQUEST) ?
Status : DriverStatus;
IrpContext->Irp = Irp = NULL;
}
Ext2CompleteIrpContext(IrpContext, Status);
}
}
return Status;
}
BOOLEAN
SKillDeleteFile(
IN HANDLE FileHandle
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PFILE_OBJECT fileObject;
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
KEVENT event;
FILE_DISPOSITION_INFORMATION FileInformation;
IO_STATUS_BLOCK ioStatus;
PIO_STACK_LOCATION irpSp;
PSECTION_OBJECT_POINTERS pSectionObjectPointer; ////////////////////
BOOL bInit = FALSE;
ReLoadNtosCALL(&RObReferenceObjectByHandle,L"ObReferenceObjectByHandle",SystemKernelModuleBase,ImageModuleBase);
ReLoadNtosCALL(&RKeInitializeEvent,L"KeInitializeEvent",SystemKernelModuleBase,ImageModuleBase);
ReLoadNtosCALL(&RIoAllocateIrp,L"IoAllocateIrp",SystemKernelModuleBase,ImageModuleBase);
ReLoadNtosCALL(&RIoCallDriver,L"IoCallDriver",SystemKernelModuleBase,ImageModuleBase);
ReLoadNtosCALL(&RKeWaitForSingleObject,L"KeWaitForSingleObject",SystemKernelModuleBase,ImageModuleBase);
if (RObReferenceObjectByHandle &&
RKeInitializeEvent &&
RIoAllocateIrp &&
RIoCallDriver &&
RKeWaitForSingleObject)
{
bInit = TRUE;
}
if (!bInit)
return NULL;
SKillStripFileAttributes( FileHandle); //去掉只读属性，才能删除只读文件
ntStatus = RObReferenceObjectByHandle(FileHandle,
DELETE,
*IoFileObjectType,
KernelMode,
&fileObject,
NULL);
if (!NT_SUCCESS(ntStatus))
{
return FALSE;
}
DeviceObject = IoGetRelatedDeviceObject(fileObject);
Irp = RIoAllocateIrp(DeviceObject->StackSize, TRUE);
if (Irp == NULL)
{
ObDereferenceObject(fileObject);
return FALSE;
}
RKeInitializeEvent(&event, SynchronizationEvent, FALSE);
FileInformation.DeleteFile = TRUE;
Irp->AssociatedIrp.SystemBuffer = &FileInformation;
Irp->UserEvent = &event;
Irp->UserIosb = &ioStatus;
Irp->Tail.Overlay.OriginalFileObject = fileObject;
Irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();
Irp->RequestorMode = KernelMode;
irpSp = IoGetNextIrpStackLocation(Irp);
irpSp->MajorFunction = IRP_MJ_SET_INFORMATION;
irpSp->DeviceObject = DeviceObject;
irpSp->FileObject = fileObject;
irpSp->Parameters.SetFile.Length = sizeof(FILE_DISPOSITION_INFORMATION);
irpSp->Parameters.SetFile.FileInformationClass = FileDispositionInformation;
irpSp->Parameters.SetFile.FileObject = fileObject;
IoSetCompletionRoutine(
Irp,
SkillSetFileCompletion,
&event,
TRUE,
TRUE,
TRUE);
//再加上下面这三行代码 ，MmFlushImageSection 函数通过这个结构来检查是否可以删除文件。
//这个和Hook
ulImageSectionObject = NULL;
ulDataSectionObject = NULL;
ulSharedCacheMap = NULL;
pSectionObjectPointer = NULL;
pSectionObjectPointer = fileObject->SectionObjectPointer;
if (MmIsAddressValidEx(pSectionObjectPointer))
{
ulImageSectionObject = pSectionObjectPointer->ImageSectionObject; // 备份之~~~
pSectionObjectPointer->ImageSectionObject = 0; //清零，准备删除
ulDataSectionObject = pSectionObjectPointer->DataSectionObject; //备份之
pSectionObjectPointer->DataSectionObject = 0; //清零，准备删除
ulSharedCacheMap = pSectionObjectPointer->SharedCacheMap;
pSectionObjectPointer->SharedCacheMap = 0;
}
//发irp删除
RIoCallDriver(DeviceObject, Irp);
//等待操作完毕
RKeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);
//删除文件之后，从备份那里填充回来
pSectionObjectPointer = NULL;
pSectionObjectPointer = fileObject->SectionObjectPointer;
if (MmIsAddressValidEx(pSectionObjectPointer))
{
if (ulImageSectionObject)
pSectionObjectPointer->ImageSectionObject = ulImageSectionObject; //填充回来，不然蓝屏哦
if (ulDataSectionObject)
pSectionObjectPointer->DataSectionObject = ulDataSectionObject;
if (ulSharedCacheMap)
pSectionObjectPointer->SharedCacheMap = ulSharedCacheMap;
}
ObDereferenceObject(fileObject);
fileObject = NULL;
return TRUE;
}
BOOLEAN
SKillStripFileAttributes(
IN HANDLE FileHandle
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PFILE_OBJECT fileObject;
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
KEVENT event;
FILE_BASIC_INFORMATION FileInformation;
IO_STATUS_BLOCK ioStatus;
PIO_STACK_LOCATION irpSp;
BOOL bInit = FALSE;
ReLoadNtosCALL(&RObReferenceObjectByHandle,L"ObReferenceObjectByHandle",SystemKernelModuleBase,ImageModuleBase);
ReLoadNtosCALL(&RKeInitializeEvent,L"KeInitializeEvent",SystemKernelModuleBase,ImageModuleBase);
ReLoadNtosCALL(&RIoAllocateIrp,L"IoAllocateIrp",SystemKernelModuleBase,ImageModuleBase);
ReLoadNtosCALL(&RIoCallDriver,L"IoCallDriver",SystemKernelModuleBase,ImageModuleBase);
ReLoadNtosCALL(&RKeWaitForSingleObject,L"KeWaitForSingleObject",SystemKernelModuleBase,ImageModuleBase);
if (RObReferenceObjectByHandle &&
RKeInitializeEvent &&
RIoAllocateIrp &&
RIoCallDriver &&
RKeWaitForSingleObject)
{
bInit = TRUE;
}
if (!bInit)
return NULL;
ntStatus = RObReferenceObjectByHandle(FileHandle,
DELETE,
*IoFileObjectType,
KernelMode,
&fileObject,
NULL);
if (!NT_SUCCESS(ntStatus))
{
return FALSE;
}
DeviceObject = IoGetRelatedDeviceObject(fileObject);
Irp = RIoAllocateIrp(DeviceObject->StackSize, TRUE);
if (Irp == NULL)
{
ObDereferenceObject(fileObject);
return FALSE;
}
RKeInitializeEvent(&event, SynchronizationEvent, FALSE);
memset(&FileInformation,0,0x28);
FileInformation.FileAttributes = FILE_ATTRIBUTE_NORMAL;
Irp->AssociatedIrp.SystemBuffer = &FileInformation;
Irp->UserEvent = &event;
Irp->UserIosb = &ioStatus;
Irp->Tail.Overlay.OriginalFileObject = fileObject;
Irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();
Irp->RequestorMode = KernelMode;
irpSp = IoGetNextIrpStackLocation(Irp);
irpSp->MajorFunction = IRP_MJ_SET_INFORMATION;
irpSp->DeviceObject = DeviceObject;
irpSp->FileObject = fileObject;
irpSp->Parameters.SetFile.Length = sizeof(FILE_BASIC_INFORMATION);
irpSp->Parameters.SetFile.FileInformationClass = FileBasicInformation;
irpSp->Parameters.SetFile.FileObject = fileObject;
IoSetCompletionRoutine(
Irp,
SkillSetFileCompletion,
&event,
TRUE,
TRUE,
TRUE);
RIoCallDriver(DeviceObject, Irp);
RKeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);
ObDereferenceObject(fileObject);
return TRUE;
}
NTSTATUS
LanscsiMiniportCompletion(
IN PCCB Ccb,
IN PMINIPORT_DEVICE_EXTENSION HwDeviceExtension
)
{
KIRQL oldIrql;
static LONG SrbSeq;
LONG srbSeqIncremented;
PSCSI_REQUEST_BLOCK srb;
PCCB abortCcb;
NTSTATUS return_status;
KDPrint(3,("RequestExecuting = %d\n", HwDeviceExtension->RequestExecuting));
srb = Ccb->Srb;
if(!srb) {
KDPrint(1,("Ccb:%p CcbStatus %d. No srb assigned.\n", Ccb, Ccb->CcbStatus));
ASSERT(srb);
return STATUS_SUCCESS;
}
//
// LanscsiMiniport completion routine will do post operation to complete CCBs.
//
return_status = STATUS_MORE_PROCESSING_REQUIRED;
srbSeqIncremented = InterlockedIncrement(&SrbSeq);
//
// check to see if this CCB was sent before BusReset occurs.
// TODO: we need to calculate the accurate BUSRESET_EFFECT_TICKCOUNT.
//
ASSERT(Ccb->CreateTime.QuadPart);
KDPrint(3,("!!!!! SRB:%p CCB:%p CCB->CreateTime: %I64u!!!!!!\n", srb, Ccb, Ccb->CreateTime.QuadPart));
ACQUIRE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, &oldIrql);
if( Ccb->CreateTime.QuadPart <= HwDeviceExtension->LastBusResetTime.QuadPart + BUSRESET_EFFECT_TICKCOUNT ||
ADAPTER_ISSTATUSFLAG(HwDeviceExtension, ADAPTER_STATUSFLAG_BUSRESET_PENDING) )
{
ADAPTER_RESETSTATUSFLAG(HwDeviceExtension, ADAPTER_STATUSFLAG_BUSRESET_PENDING);
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
KDPrint(1,("!!!!!! BusReset occured after this CCB has entered."
" Make it completed with Timer. CCB->CreateTime: %I64u!!!!!!\n", Ccb->CreateTime.QuadPart));
LSCcbSetStatusFlag(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE);
} else {
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
}
//
// Check reconnecting process.
// Translate CCB to SRB.
//
if(LSCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_RECONNECTING)) {
ACQUIRE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, &oldIrql);
if(!ADAPTER_ISSTATUSFLAG(HwDeviceExtension, ADAPTER_STATUSFLAG_RECONNECTPENDING)) {
UINT32 AdapterStatus;
AdapterStatus = ADAPTER_SETSTATUSFLAG(HwDeviceExtension, ADAPTER_STATUSFLAG_RECONNECTPENDING);
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
UpdatePdoInfoInLSBus(HwDeviceExtension, AdapterStatus);
KDPrint(1,("Ccb:%p CcbStatus %d. Start reconnecting\n", Ccb, Ccb->CcbStatus));
} else {
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
}
} else {
//
// If CCbStatus != CCB_STATUS_STOP, reconnecting is successful.
//
if(Ccb->CcbStatus != CCB_STATUS_STOP) {
ACQUIRE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, &oldIrql);
if(ADAPTER_ISSTATUSFLAG(HwDeviceExtension, ADAPTER_STATUSFLAG_RECONNECTPENDING)) {
UINT32 AdapterStatus;
AdapterStatus = ADAPTER_RESETSTATUSFLAG(HwDeviceExtension, ADAPTER_STATUSFLAG_RECONNECTPENDING);
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
UpdatePdoInfoInLSBus(HwDeviceExtension, AdapterStatus);
KDPrint(1,("Ccb:%p CcbStatus %d. Finish reconnecting\n", Ccb, Ccb->CcbStatus));
} else {
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
}
}
}
//
// If CCB_OPCODE_UPDATE is successful, update adapter status in LanscsiBus
//
if(Ccb->OperationCode == CCB_OPCODE_UPDATE && Ccb->CcbStatus == CCB_STATUS_SUCCESS) {
UINT32 AdapterStatus;
ACQUIRE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, &oldIrql);
AdapterStatus = HwDeviceExtension->AdapterStatus;
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
UpdatePdoInfoInLSBus(HwDeviceExtension, AdapterStatus);
}
KDPrint(3,("CcbStatus %d\n", Ccb->CcbStatus));
//
// Translate CcbStatus to SrbStatus
//
switch(Ccb->CcbStatus) {
case CCB_STATUS_SUCCESS:
srb->SrbStatus = SRB_STATUS_SUCCESS;
srb->ScsiStatus = SCSISTAT_GOOD;
//
// Check to see if the associate member is in error.
//
if(LSCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_LURN_STOP)) {
ACQUIRE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, &oldIrql);
if(!ADAPTER_ISSTATUSFLAG(HwDeviceExtension, ADAPTER_STATUSFLAG_MEMBER_FAULT)) {
UINT32 AdapterStatus;
AdapterStatus = ADAPTER_SETSTATUSFLAG(HwDeviceExtension, ADAPTER_STATUSFLAG_MEMBER_FAULT);
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
UpdatePdoInfoInLSBus(HwDeviceExtension, AdapterStatus);
KDPrint(1,("Ccb:%p CcbStatus %d. Associate member is in error.\n", Ccb, Ccb->CcbStatus));
//
// Send DisconEvent to the service.
// TODO: alternate to AlarmEvent.
//
KeSetEvent(HwDeviceExtension->DisconEventToService, IO_NO_INCREMENT, FALSE);
} else {
RELEASE_SPIN_LOCK(&HwDeviceExtension->LanscsiAdapterSpinLock, oldIrql);
}
}
break;
case CCB_STATUS_NOT_EXIST:
srb->SrbStatus = SRB_STATUS_NO_DEVICE;
srb->ScsiStatus = SCSISTAT_GOOD;
break;
case CCB_STATUS_INVALID_COMMAND:
srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
srb->ScsiStatus = SCSISTAT_GOOD;
break;
case CCB_STATUS_COMMAND_FAILED:
srb->SrbStatus = SRB_STATUS_ERROR | SRB_STATUS_AUTOSENSE_VALID;
srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
srb->DataTransferLength -= Ccb->ResidualDataLength;
break;
// Added by ILGU HONG 2004_07_05
case CCB_STATUS_COMMMAND_DONE_SENSE:
srb->SrbStatus = SRB_STATUS_ERROR | SRB_STATUS_AUTOSENSE_VALID ;
srb->DataTransferLength = 0;
srb->ScsiStatus = SCSISTAT_GOOD;
break;
// Added by ILGU HONG 2004_07_05 end
case CCB_STATUS_RESET:
srb->SrbStatus = SRB_STATUS_BUS_RESET;
srb->ScsiStatus = SCSISTAT_GOOD;
break;
case CCB_STATUS_COMMUNICATION_ERROR:
{
PSENSE_DATA senseData;
srb->SrbStatus = SRB_STATUS_ERROR | SRB_STATUS_AUTOSENSE_VALID;
srb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
srb->DataTransferLength = 0;
senseData = srb->SenseInfoBuffer;
senseData->ErrorCode = 0x70;
senseData->Valid = 1;
//senseData->SegmentNumber = 0;
senseData->SenseKey = SCSI_SENSE_HARDWARE_ERROR; //SCSI_SENSE_MISCOMPARE;
//senseData->IncorrectLength = 0;
//senseData->EndOfMedia = 0;
//senseData->FileMark = 0;
senseData->AdditionalSenseLength = 0xb;
senseData->AdditionalSenseCode = SCSI_ADSENSE_NO_SENSE;
senseData->AdditionalSenseCodeQualifier = 0;
}
break;
case CCB_STATUS_BUSY:
srb->SrbStatus = SRB_STATUS_BUSY;
srb->ScsiStatus = SCSISTAT_GOOD;
KDPrint(1,("CCB_STATUS_BUSY\n"));
break;
//
// Stop one LUR
//
case CCB_STATUS_STOP: {
KDPrint(1,("CCB_STATUS_STOP. Stopping!\n"));
srb->SrbStatus = SRB_STATUS_NO_DEVICE;
srb->ScsiStatus = SCSISTAT_GOOD;
MiniStopAdapter(HwDeviceExtension, TRUE);
break;
}
default:
// Error in Connection...
// CCB_STATUS_UNKNOWN_STATUS, CCB_STATUS_RESET, and so on.
srb->SrbStatus = SRB_STATUS_ERROR;
srb->ScsiStatus = SCSISTAT_GOOD;
}
//
// Process Abort CCB.
//
abortCcb = Ccb->AbortCcb;
if(abortCcb != NULL) {
KDPrint(1,("abortSrb\n"));
ASSERT(FALSE);
srb->SrbStatus = SRB_STATUS_SUCCESS;
LSCcbSetStatusFlag(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE);
InitializeListHead(&Ccb->ListEntry);
ExInterlockedInsertTailList(
&HwDeviceExtension->CcbCompletionList,
&Ccb->ListEntry,
&HwDeviceExtension->CcbCompletionListSpinLock
);
((PSCSI_REQUEST_BLOCK)abortCcb->Srb)->SrbStatus = SRB_STATUS_ABORTED;
LSCcbSetStatusFlag(abortCcb, CCBSTATUS_FLAG_TIMER_COMPLETE);
InitializeListHead(&abortCcb->ListEntry);
ExInterlockedInsertTailList(
&HwDeviceExtension->CcbCompletionList,
&abortCcb->ListEntry,
&HwDeviceExtension->CcbCompletionListSpinLock
);
} else {
//
// Make Complete IRP and Send it.
//
//
// In case of HostStatus == CCB_STATUS_SUCCESS_TIMER, CCB will go to the timer to complete.
//
if( (Ccb->CcbStatus == CCB_STATUS_SUCCESS || Ccb->CcbStatus == CCB_STATUS_INVALID_COMMAND) &&
!LSCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE) &&
!LSCcbIsStatusFlagOn(Ccb, CCBSTATUS_FLAG_BUSRESET_REQUIRED)
)
{
PDEVICE_OBJECT pDeviceObject = HwDeviceExtension->ScsiportFdoObject;
PIRP pCompletionIrp = NULL;
PIO_STACK_LOCATION pIoStack;
NTSTATUS ntStatus;
PSCSI_REQUEST_BLOCK completionSrb = NULL;
PCOMPLETION_DATA completionData = NULL;
completionSrb = ExAllocatePoolWithTag(NonPagedPool, sizeof(SCSI_REQUEST_BLOCK), LSMP_PTAG_SRB);
if(completionSrb == NULL)
goto Out;
RtlZeroMemory(
completionSrb,
sizeof(SCSI_REQUEST_BLOCK)
);
// Build New IRP.
pCompletionIrp = IoAllocateIrp((CCHAR)(pDeviceObject->StackSize + 1), FALSE);
if(pCompletionIrp == NULL) {
ExFreePoolWithTag(completionSrb, LSMP_PTAG_SRB);
goto Out;
}
completionData = ExAllocatePoolWithTag(NonPagedPool, sizeof(COMPLETION_DATA), LSMP_PTAG_CMPDATA);
if(completionData == NULL) {
ExFreePoolWithTag(completionSrb, LSMP_PTAG_SRB);
IoFreeIrp(pCompletionIrp);
pCompletionIrp = NULL;
goto Out;
}
pCompletionIrp->MdlAddress = NULL;
// Set IRP stack location.
pIoStack = IoGetNextIrpStackLocation(pCompletionIrp);
pIoStack->DeviceObject = pDeviceObject;
pIoStack->MajorFunction = IRP_MJ_SCSI;
pIoStack->Parameters.DeviceIoControl.InputBufferLength = 0;
pIoStack->Parameters.DeviceIoControl.OutputBufferLength = 0;
pIoStack->Parameters.Scsi.Srb = completionSrb;
// Set SRB.
completionSrb->Length = sizeof(SCSI_REQUEST_BLOCK);
completionSrb->Function = SRB_FUNCTION_EXECUTE_SCSI;
completionSrb->PathId = srb->PathId;
completionSrb->TargetId = srb->TargetId;
completionSrb->Lun = srb->Lun;
completionSrb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
completionSrb->DataBuffer = srb;
completionSrb->SrbFlags |= SRB_FLAGS_BYPASS_FROZEN_QUEUE | SRB_FLAGS_NO_QUEUE_FREEZE;
completionSrb->OriginalRequest = pCompletionIrp;
completionSrb->CdbLength = MAXIMUM_CDB_SIZE;
completionSrb->Cdb[0] = SCSIOP_COMPLETE;
completionSrb->Cdb[1] = (UCHAR)srbSeqIncremented;
completionSrb->TimeOutValue = 20;
completionSrb->SrbStatus = SRB_STATUS_SUCCESS;
//
// Set compeltion data for the completion IRP.
//
completionData->HwDeviceExtension = HwDeviceExtension;
completionData->CompletionSrb = completionSrb;
completionData->ShippedCcb = Ccb;
completionData->ShippedCcbAllocatedFromPool = LSCcbIsFlagOn(Ccb, CCB_FLAG_ALLOCATED);
Out:
KDPrint(4,("Before Completion\n"));
if(pCompletionIrp) {
IoSetCompletionRoutine(pCompletionIrp, CompletionIrpCompletionRoutine, completionData, TRUE, TRUE, TRUE);
ASSERT(HwDeviceExtension->RequestExecuting != 0);
//
// call Scsiport FDO.
//
ntStatus = IoCallDriver(pDeviceObject, pCompletionIrp);
ASSERT(NT_SUCCESS(ntStatus));
#if DBG
if(ntStatus!= STATUS_SUCCESS && ntStatus!= STATUS_PENDING) {
KDPrint(1,("ntStatus = 0x%x\n", ntStatus));
}
#endif
}else {
KDPrint(1,("CompletionIRP NULL. CCB(%p) and SRB(%p) is going to the timer. CcbStatus:%x CcbFlag:%x\n", Ccb, Ccb->Srb, Ccb->CcbStatus, Ccb->Flags));
InitializeListHead(&Ccb->ListEntry);
LSCcbSetStatusFlag(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE);
ExInterlockedInsertTailList(
&HwDeviceExtension->CcbCompletionList,
&Ccb->ListEntry,
&HwDeviceExtension->CcbCompletionListSpinLock
);
}
} else {
KDPrint(1,("CCB(%p) and SRB(%p) is going to the timer. CcbStatus:%x CcbFlag:%x\n", Ccb, Ccb->Srb, Ccb->CcbStatus, Ccb->Flags));
InitializeListHead(&Ccb->ListEntry);
LSCcbSetStatusFlag(Ccb, CCBSTATUS_FLAG_TIMER_COMPLETE);
ExInterlockedInsertTailList(
&HwDeviceExtension->CcbCompletionList,
&Ccb->ListEntry,
&HwDeviceExtension->CcbCompletionListSpinLock
);
}
}
return return_status;
}
NTSTATUS
ScsiPortPdoPnp(
IN PDEVICE_OBJECT LogicalUnit,
IN PIRP Irp
)
/*++
Routine Description:
This routine handles pnp-power requests. Currently it will just be
successful
Arguments:
LogicalUnit - pointer to the physical device object
Irp - pointer to the io request packet
Return Value:
status
--*/
{
PLOGICAL_UNIT_EXTENSION logicalUnitExtension = LogicalUnit->DeviceExtension;
PCOMMON_EXTENSION commonExtension = LogicalUnit->DeviceExtension;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
static ULONG i = 0;
NTSTATUS status = STATUS_SUCCESS;
ULONG isRemoved;
PAGED_CODE();
isRemoved = SpAcquireRemoveLock(LogicalUnit, Irp);
#if 0
if(isRemoved != ) {
ASSERT(isRemoved != REMOVE_PENDING);
status = STATUS_DEVICE_DOES_NOT_EXIST;
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
}
#else
ASSERT(isRemoved != REMOVE_COMPLETE);
#endif
switch(irpStack->MinorFunction) {
case IRP_MN_QUERY_PNP_DEVICE_STATE: {
//
// If the device is in the paging path then mark it as
// not-disableable.
//
PPNP_DEVICE_STATE deviceState =
(PPNP_DEVICE_STATE) &(Irp->IoStatus.Information);
DebugPrint((1, "ScsiPortPdoPnp: QUERY_DEVICE_STATE for PDO %#x\n", LogicalUnit));
if(commonExtension->PagingPathCount != 0) {
SET_FLAG((*deviceState), PNP_DEVICE_NOT_DISABLEABLE);
DebugPrint((1, "ScsiPortPdoPnp: QUERY_DEVICE_STATE: %#x - not disableable\n",
LogicalUnit));
}
Irp->IoStatus.Status = STATUS_SUCCESS;
SpReleaseRemoveLock(LogicalUnit, Irp);
SpCompleteRequest(LogicalUnit, Irp, NULL, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
case IRP_MN_START_DEVICE: {
if(commonExtension->CurrentPnpState == IRP_MN_START_DEVICE) {
Irp->IoStatus.Status = STATUS_SUCCESS;
break;
}
if(commonExtension->IsInitialized == FALSE) {
status = ScsiPortInitDevice(LogicalUnit);
}
if(NT_SUCCESS(status)) {
commonExtension->IsInitialized = TRUE;
status = ScsiPortStartDevice(LogicalUnit);
}
if(NT_SUCCESS(status)) {
commonExtension->CurrentPnpState = IRP_MN_START_DEVICE;
commonExtension->PreviousPnpState = 0xff;
}
Irp->IoStatus.Status = status;
break;
}
case IRP_MN_QUERY_ID: {
UCHAR rawIdString[64] = "UNKNOWN ID TYPE";
ANSI_STRING ansiIdString;
UNICODE_STRING unicodeIdString;
BOOLEAN multiStrings;
PINQUIRYDATA inquiryData = &(logicalUnitExtension->InquiryData);
//
// We've been asked for the id of one of the physical device objects
//
DebugPrint((2, "ScsiPortPnp: got IRP_MN_QUERY_ID\n"));
RtlInitUnicodeString(&unicodeIdString, NULL);
RtlInitAnsiString(&ansiIdString, NULL);
switch(irpStack->Parameters.QueryId.IdType) {
case BusQueryDeviceID: {
status = ScsiPortGetDeviceId(LogicalUnit, &unicodeIdString);
multiStrings = FALSE;
break;
}
case BusQueryInstanceID: {
status = ScsiPortGetInstanceId(LogicalUnit, &unicodeIdString);
multiStrings = FALSE;
break;
}
case BusQueryHardwareIDs: {
status = ScsiPortGetHardwareIds(
&(logicalUnitExtension->InquiryData),
&unicodeIdString);
multiStrings = TRUE;
break;
}
case BusQueryCompatibleIDs: {
status = ScsiPortGetCompatibleIds(
&(logicalUnitExtension->InquiryData),
&unicodeIdString);
multiStrings = TRUE;
break;
}
default: {
status = Irp->IoStatus.Status;
Irp->IoStatus.Information = 0;
break;
}
}
Irp->IoStatus.Status = status;
if(NT_SUCCESS(status)) {
PWCHAR idString;
//
// fix up all invalid characters
//
idString = unicodeIdString.Buffer;
while (*idString) {
if ((*idString <= L' ') ||
(*idString > (WCHAR)0x7F) ||
(*idString == L',')) {
*idString = L'_';
}
idString++;
if ((*idString == L'\0') && multiStrings) {
idString++;
}
}
Irp->IoStatus.Information = (ULONG_PTR) unicodeIdString.Buffer;
} else {
Irp->IoStatus.Information = (ULONG_PTR) NULL;
}
SpReleaseRemoveLock(LogicalUnit, Irp);
SpCompleteRequest(LogicalUnit, Irp, NULL, IO_NO_INCREMENT);
return status;
break;
}
case IRP_MN_QUERY_RESOURCES:
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS: {
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = (ULONG_PTR) NULL;
SpReleaseRemoveLock(LogicalUnit, Irp);
SpCompleteRequest(LogicalUnit, Irp, NULL, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
case IRP_MN_SURPRISE_REMOVAL:
case IRP_MN_REMOVE_DEVICE: {
BOOLEAN destroyed;
//
// Release the lock for this IRP before going in.
//
if(commonExtension->IsRemoved == NO_REMOVE) {
commonExtension->IsRemoved = REMOVE_PENDING;
}
SpReleaseRemoveLock(LogicalUnit, Irp);
destroyed = SpRemoveLogicalUnit(LogicalUnit,
irpStack->MinorFunction);
if(destroyed) {
commonExtension->PreviousPnpState =
commonExtension->CurrentPnpState;
commonExtension->CurrentPnpState = irpStack->MinorFunction;
} else {
commonExtension->CurrentPnpState = 0xff;
commonExtension->PreviousPnpState = irpStack->MinorFunction;
}
status = STATUS_SUCCESS;
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
}
case IRP_MN_QUERY_DEVICE_TEXT: {
Irp->IoStatus.Status =
SpQueryDeviceText(
LogicalUnit,
irpStack->Parameters.QueryDeviceText.DeviceTextType,
irpStack->Parameters.QueryDeviceText.LocaleId,
(PWSTR *) &Irp->IoStatus.Information
);
break;
}
case IRP_MN_QUERY_CAPABILITIES: {
PDEVICE_CAPABILITIES capabilities =
irpStack->Parameters.DeviceCapabilities.Capabilities;
PSCSIPORT_DEVICE_TYPE deviceType = NULL;
capabilities->RawDeviceOK = 1;
deviceType = SpGetDeviceTypeInfo(
logicalUnitExtension->InquiryData.DeviceType
);
if((deviceType != NULL) && (deviceType->IsStorage)) {
capabilities->SilentInstall = 1;
}
capabilities->Address = logicalUnitExtension->TargetId;
Irp->IoStatus.Status = STATUS_SUCCESS;
break;
}
case IRP_MN_QUERY_STOP_DEVICE:
case IRP_MN_QUERY_REMOVE_DEVICE: {
if ((commonExtension->PagingPathCount != 0) ||
(logicalUnitExtension->IsLegacyClaim == TRUE)) {
Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
} else {
Irp->IoStatus.Status = STATUS_SUCCESS;
commonExtension->PreviousPnpState =
commonExtension->CurrentPnpState;
commonExtension->CurrentPnpState = irpStack->MinorFunction;
}
break;
}
case IRP_MN_CANCEL_STOP_DEVICE: {
if(commonExtension->CurrentPnpState == IRP_MN_QUERY_STOP_DEVICE) {
commonExtension->CurrentPnpState =
commonExtension->PreviousPnpState;
commonExtension->PreviousPnpState = 0xff;
}
Irp->IoStatus.Status = STATUS_SUCCESS;
break;
}
case IRP_MN_CANCEL_REMOVE_DEVICE: {
if(commonExtension->CurrentPnpState == IRP_MN_QUERY_REMOVE_DEVICE) {
commonExtension->CurrentPnpState =
commonExtension->PreviousPnpState;
commonExtension->PreviousPnpState = 0xff;
}
Irp->IoStatus.Status = STATUS_SUCCESS;
break;
}
case IRP_MN_STOP_DEVICE: {
ASSERT(commonExtension->CurrentPnpState == IRP_MN_QUERY_STOP_DEVICE);
status = ScsiPortStopDevice(LogicalUnit);
ASSERT(NT_SUCCESS(status));
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = (ULONG_PTR) NULL;
if(NT_SUCCESS(status)) {
commonExtension->CurrentPnpState = IRP_MN_STOP_DEVICE;
commonExtension->PreviousPnpState = 0xff;
}
SpReleaseRemoveLock(LogicalUnit, Irp);
SpCompleteRequest(LogicalUnit, Irp, NULL, IO_NO_INCREMENT);
return status;
}
case IRP_MN_QUERY_DEVICE_RELATIONS: {
PDEVICE_RELATIONS deviceRelations;
if(irpStack->Parameters.QueryDeviceRelations.Type !=
TargetDeviceRelation) {
break;
}
//
// DEVICE_RELATIONS definition contains one object pointer.
//
deviceRelations = ExAllocatePoolWithTag(
PagedPool,
sizeof(DEVICE_RELATIONS),
SCSIPORT_TAG_DEVICE_RELATIONS);
if(deviceRelations == NULL) {
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlZeroMemory(deviceRelations, sizeof(DEVICE_RELATIONS));
deviceRelations->Count = 1;
deviceRelations->Objects[0] = LogicalUnit;
ObReferenceObject(deviceRelations->Objects[0]);
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
break;
}
case IRP_MN_DEVICE_USAGE_NOTIFICATION: {
PIRP newIrp;
PIO_STACK_LOCATION nextStack;
DebugPrint((1, "Pdo - IRP_MN_DEVICE_USAGE_NOTIFICATION %#p received for "
"logical unit %#p\n",
Irp,
LogicalUnit));
newIrp = IoAllocateIrp(
commonExtension->LowerDeviceObject->StackSize,
FALSE);
if(newIrp == NULL) {
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
newIrp->AssociatedIrp.MasterIrp = Irp;
newIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
nextStack = IoGetNextIrpStackLocation(newIrp);
*nextStack = *IoGetCurrentIrpStackLocation(Irp);
IoSetCompletionRoutine(newIrp,
SpPagingPathNotificationCompletion,
commonExtension->LowerDeviceObject,
TRUE,
TRUE,
TRUE);
status = IoCallDriver(commonExtension->LowerDeviceObject,
newIrp);
return status;
break;
}
}
SpReleaseRemoveLock(LogicalUnit, Irp);
status = Irp->IoStatus.Status;
SpCompleteRequest(LogicalUnit, Irp, NULL, IO_NO_INCREMENT);
return status;
}
/*************************************************************************
*
* Function: Ext2PassDownMultiReadWriteIRP()
*
* Description:
* pass down multiple read IRPs as Associated IRPs
*
* Expected Interrupt Level (for execution) :
*
* ?
*
* Return Value: STATUS_SUCCESS / STATUS_PENDING / Error
*
*************************************************************************/
NTSTATUS NTAPI Ext2PassDownMultiReadWriteIRP(
PEXT2_IO_RUN PtrIoRuns,
UINT Count,
ULONG TotalReadWriteLength,
PtrExt2IrpContext PtrIrpContext,
PtrExt2FCB PtrFCB,
BOOLEAN SynchronousIo)
{
PIRP PtrMasterIrp;
PIRP PtrAssociatedIrp;
PIO_STACK_LOCATION PtrIrpSp;
PMDL PtrMdl;
PtrExt2VCB PtrVCB;
UINT i;
ULONG BufferOffset;
PEXT2_IO_CONTEXT PtrIoContext = NULL;
PKEVENT PtrSyncEvent = NULL;
ULONG LogicalBlockSize;
ULONG ReadWriteLength;
NTSTATUS RC = STATUS_SUCCESS;
PtrVCB = PtrFCB->PtrVCB;
PtrMasterIrp = PtrIrpContext->Irp;
LogicalBlockSize = EXT2_MIN_BLOCK_SIZE << PtrVCB->LogBlockSize;
try
{
if( !SynchronousIo )
{
IoMarkIrpPending( PtrIrpContext->Irp );
// We will be returning STATUS_PENDING...
}
if( !PtrMasterIrp->MdlAddress )
{
Ext2LockCallersBuffer( PtrMasterIrp, TRUE, TotalReadWriteLength );
}
if( SynchronousIo )
{
PtrSyncEvent = Ext2AllocatePool(NonPagedPool, Ext2QuadAlign( sizeof(KEVENT) ) );
if ( !PtrSyncEvent )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
try_return();
}
KeInitializeEvent( PtrSyncEvent, SynchronizationEvent, FALSE );
}
//
// Allocate and initialize a completion context
//
PtrIoContext = Ext2AllocatePool(NonPagedPool, Ext2QuadAlign( sizeof(EXT2_IO_CONTEXT) ) );
if ( !PtrIoContext )
{
RC = STATUS_INSUFFICIENT_RESOURCES;
try_return();
}
RtlZeroMemory( PtrIoContext, sizeof(EXT2_IO_CONTEXT) );
PtrIoContext->Count = Count;
PtrIoContext->NodeIdentifier.NodeType = EXT2_NODE_TYPE_IO_CONTEXT;
PtrIoContext->NodeIdentifier.NodeSize = sizeof( EXT2_IO_CONTEXT );
PtrIoContext->PtrMasterIrp = PtrMasterIrp;
PtrIoContext->PtrSyncEvent = PtrSyncEvent;
PtrIoContext->ReadWriteLength = TotalReadWriteLength;
for( ReadWriteLength = 0, BufferOffset = 0, i = 0; i < Count; i++, BufferOffset += ReadWriteLength )
{
ReadWriteLength = PtrIoRuns[ i].EndOffset - PtrIoRuns[ i].StartOffset;
//
// Allocating an Associated IRP...
//
PtrAssociatedIrp = IoMakeAssociatedIrp( PtrMasterIrp,
(CCHAR) (PtrVCB->TargetDeviceObject->StackSize + 1 ) );
PtrIoRuns[ i].PtrAssociatedIrp = PtrAssociatedIrp;
ASSERT ( PtrAssociatedIrp );
PtrMasterIrp->AssociatedIrp.IrpCount ++;
//
// Allocating a Memory Descriptor List...
//
PtrMdl = IoAllocateMdl( (PCHAR) PtrMasterIrp->UserBuffer + BufferOffset, // Virtual Address
ReadWriteLength, FALSE, FALSE, PtrAssociatedIrp );
//
// and building a partial MDL...
//
IoBuildPartialMdl( PtrMasterIrp->MdlAddress,
PtrMdl, (PCHAR)PtrMasterIrp->UserBuffer + BufferOffset, ReadWriteLength );
//
// Create an Irp stack location for ourselves...
//
IoSetNextIrpStackLocation( PtrAssociatedIrp );
PtrIrpSp = IoGetCurrentIrpStackLocation( PtrAssociatedIrp );
//
// Setup the Stack location to describe our read.
//
PtrIrpSp->MajorFunction = PtrIrpContext->MajorFunction;
if( PtrIrpContext->MajorFunction == IRP_MJ_READ )
{
PtrIrpSp->Parameters.Read.Length = ReadWriteLength;
PtrIrpSp->Parameters.Read.ByteOffset.QuadPart =
PtrIoRuns[i].LogicalBlock * ( LogicalBlockSize );
}
else if( PtrIrpContext->MajorFunction == IRP_MJ_WRITE )
{
PtrIrpSp->Parameters.Write.Length = ReadWriteLength;
PtrIrpSp->Parameters.Write.ByteOffset.QuadPart =
PtrIoRuns[i].LogicalBlock * ( LogicalBlockSize );
}
// PtrIrpSp->Parameters.Read.Length = ReadWriteLength;
// PtrIrpSp->Parameters.Read.ByteOffset.QuadPart = PtrIoRuns[i].LogicalBlock;
//
// Setup a completion routine...
//
IoSetCompletionRoutine( PtrAssociatedIrp,
SynchronousIo ?
Ext2MultiSyncCompletionRoutine :
Ext2MultiAsyncCompletionRoutine,
PtrIoContext, TRUE, TRUE, TRUE );
//
// Initialise the next stack location for the driver below us to use...
//
PtrIrpSp = IoGetNextIrpStackLocation( PtrAssociatedIrp );
PtrIrpSp->MajorFunction = PtrIrpContext->MajorFunction;
if( PtrIrpContext->MajorFunction == IRP_MJ_READ )
{
PtrIrpSp->Parameters.Read.Length = ReadWriteLength;
PtrIrpSp->Parameters.Read.ByteOffset.QuadPart = PtrIoRuns[i].LogicalBlock * ( LogicalBlockSize );
}
else if( PtrIrpContext->MajorFunction == IRP_MJ_WRITE )
{
PtrIrpSp->Parameters.Write.Length = ReadWriteLength;
PtrIrpSp->Parameters.Write.ByteOffset.QuadPart = PtrIoRuns[i].LogicalBlock * ( LogicalBlockSize );
}
// PtrIrpSp->Parameters.Read.Length = ReadWriteLength;
// PtrIrpSp->Parameters.Read.ByteOffset.QuadPart =
// PtrIoRuns[i].LogicalBlock * ( LogicalBlockSize );
}
for( i = 0; i < Count; i++ ) {
// DbgPrint("PASSING DOWN IRP %d TO TARGET DEVICE\n", i);
IoCallDriver( PtrVCB->TargetDeviceObject, PtrIoRuns[ i].PtrAssociatedIrp );
}
if( SynchronousIo )
{
//
// Synchronous IO
// Wait for the IO to complete...
//
DbgPrint("DEADLY WAIT (%d)\n", KeGetCurrentIrql());
KeWaitForSingleObject( PtrSyncEvent,
Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );
DbgPrint("DEADLY WAIT DONE\n");
try_return();
}
else
{
// Asynchronous IO...
RC = STATUS_PENDING;
try_return();
}
try_exit: NOTHING;
}
finally
{
if( PtrSyncEvent )
{
DebugTrace( DEBUG_TRACE_FREE, "Freeing = %lX [io]", PtrSyncEvent );
ExFreePool( PtrSyncEvent );
}
if( PtrIoContext && ! ( RC == STATUS_PENDING || RC == STATUS_SUCCESS ) )
{
//
// This means we are getting out of
// this function without doing a read
// due to an error, maybe...
//
DebugTrace( DEBUG_TRACE_FREE, "Freeing = %lX [io]", PtrIoContext);
ExFreePool( PtrIoContext );
}
}
return(RC);
}
NTSTATUS IrpCloseFile(__in PFILE_OBJECT FileObject)
{
NTSTATUS nsStatus = STATUS_UNSUCCESSFUL;
IO_STATUS_BLOCK IoStatus = {0x00};
PIRP Irp = NULL;
KEVENT kEvent = {0x00};
PIO_STACK_LOCATION IrpSp = NULL;
PDEVICE_OBJECT pBaseDeviceObject = FileObject->Vpb->DeviceObject;
BDKit_If_DoAction(FileObject->Vpb == NULL || FileObject->Vpb->DeviceObject == NULL, return STATUS_UNSUCCESSFUL);
do
{
Irp = IoAllocateIrp(FileObject->Vpb->DeviceObject->StackSize, FALSE);
BDKit_If_Not_Break(Irp != NULL);
KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
Irp->UserEvent = &kEvent;
Irp->UserIosb = &IoStatus;
Irp->RequestorMode = KernelMode;
Irp->Flags = IRP_CLOSE_OPERATION | IRP_SYNCHRONOUS_API;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
Irp->Tail.Overlay.OriginalFileObject = FileObject;
IrpSp = IoGetNextIrpStackLocation(Irp);
IrpSp->MajorFunction = IRP_MJ_CLEANUP;
IrpSp->FileObject = FileObject;
IoSetCompletionRoutine(Irp, BDKitIoCompletionRoutine, 0, TRUE, TRUE, TRUE);
nsStatus = IoCallDriver(pBaseDeviceObject, Irp);
BDKit_If_DoAction(nsStatus == STATUS_PENDING,
KeWaitForSingleObject(&kEvent, Executive, KernelMode, FALSE, NULL));
Irp = NULL;
nsStatus = IoStatus.Status;
BDKit_If_Not_Break(NT_SUCCESS(nsStatus));
// SEND IRP_MJ_CLOSE
Irp = IoAllocateIrp(FileObject->Vpb->DeviceObject->StackSize, FALSE);
BDKit_If_Not_Break(Irp != NULL);
KeClearEvent(&kEvent);
Irp->UserEvent = &kEvent;
Irp->UserIosb = &IoStatus;
Irp->Tail.Overlay.OriginalFileObject = FileObject;
Irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();
Irp->AssociatedIrp.SystemBuffer = (PVOID)NULL;
Irp->Flags = IRP_CLOSE_OPERATION | IRP_SYNCHRONOUS_API;
IrpSp = IoGetNextIrpStackLocation(Irp);
IrpSp->MajorFunction = IRP_MJ_CLOSE;
IrpSp->FileObject = FileObject;
if ( FileObject->Vpb && !(FileObject->Flags & FO_DIRECT_DEVICE_OPEN) )
{
InterlockedDecrement((LONG volatile*)&FileObject->Vpb->ReferenceCount);
FileObject->Flags |= FO_FILE_OPEN_CANCELLED;
}
IoSetCompletionRoutine(Irp, BDKitIoCompletionRoutine, 0, TRUE, TRUE, TRUE);
nsStatus = IoCallDriver(pBaseDeviceObject, Irp);
BDKit_If_DoAction(nsStatus == STATUS_PENDING,
KeWaitForSingleObject(&kEvent, Executive, KernelMode, FALSE, NULL));
Irp = NULL;
nsStatus = IoStatus.Status;
BDKit_If_Not_Break(NT_SUCCESS(nsStatus));
} while (FALSE);
BDKit_If_DoAction(Irp != NULL, IoFreeIrp (Irp));
return nsStatus;
}
NTSTATUS
NTAPI
MiSimpleRead(PFILE_OBJECT FileObject,
PLARGE_INTEGER FileOffset,
PVOID Buffer,
ULONG Length,
BOOLEAN Paging,
PIO_STATUS_BLOCK ReadStatus)
{
NTSTATUS Status;
PIRP Irp = NULL;
KEVENT ReadWait;
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION IrpSp;
ASSERT(FileObject);
ASSERT(FileOffset);
ASSERT(Buffer);
ASSERT(ReadStatus);
DeviceObject = MmGetDeviceObjectForFile(FileObject);
ReadStatus->Status = STATUS_INTERNAL_ERROR;
ReadStatus->Information = 0;
ASSERT(DeviceObject);
DPRINT("PAGING READ: FileObject %p <%wZ> Offset %08x%08x Length %ul\n",
FileObject,
&FileObject->FileName,
FileOffset->HighPart,
FileOffset->LowPart,
Length);
KeInitializeEvent(&ReadWait, NotificationEvent, FALSE);
Irp = IoBuildAsynchronousFsdRequest(IRP_MJ_READ,
DeviceObject,
Buffer,
Length,
FileOffset,
ReadStatus);
if (!Irp)
{
return STATUS_NO_MEMORY;
}
Irp->Flags |= (Paging ? IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO | IRP_NOCACHE : 0) | IRP_SYNCHRONOUS_API;
Irp->UserEvent = &ReadWait;
Irp->Tail.Overlay.OriginalFileObject = FileObject;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
IrpSp = IoGetNextIrpStackLocation(Irp);
IrpSp->Control |= SL_INVOKE_ON_SUCCESS | SL_INVOKE_ON_ERROR;
IrpSp->FileObject = FileObject;
IrpSp->CompletionRoutine = MiSimpleReadComplete;
/* Non paging case, the FileObject will be dereferenced at completion */
if (!Paging)
ObReferenceObject(FileObject);
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
DPRINT("KeWaitForSingleObject(&ReadWait)\n");
if (!NT_SUCCESS(KeWaitForSingleObject(&ReadWait,
Suspended,
KernelMode,
FALSE,
NULL)))
{
DPRINT1("Warning: Failed to wait for synchronous IRP\n");
ASSERT(FALSE);
return Status;
}
}
DPRINT("Paging IO Done: %08x\n", ReadStatus->Status);
Status = ReadStatus->Status == STATUS_END_OF_FILE ? STATUS_SUCCESS : ReadStatus->Status;
return Status;
}
NTSTATUS
BuildQueryDirectoryIrp(
IN HANDLE FileHandle,
IN HANDLE Event OPTIONAL,
IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
IN PVOID ApcContext OPTIONAL,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass,
IN BOOLEAN ReturnSingleEntry,
IN PUNICODE_STRING FileName OPTIONAL,
IN BOOLEAN RestartScan,
IN UCHAR MinorFunction,
OUT BOOLEAN *SynchronousIo,
OUT PDEVICE_OBJECT *DeviceObject,
OUT PIRP *Irp,
OUT PFILE_OBJECT *FileObject,
OUT KPROCESSOR_MODE *RequestorMode
)
/*++
Routine Description:
This service operates on a directory file or OLE container specified by the
FileHandle parameter. The service returns information about files in the
directory or embeddings and streams in the container specified by the file
handle. The ReturnSingleEntry parameter specifies that only a single entry
should be returned rather than filling the buffer. The actual number of
files whose information is returned, is the smallest of the following:
o One entry, if the ReturnSingleEntry parameter is TRUE.
o The number of entries whose information fits into the specified
buffer.
o The number of entries that exist.
o One entry if the optional FileName parameter is specified.
If the optional FileName parameter is specified, then the only information
that is returned is for that single entries, if it exists. Note that the
file name may not specify any wildcard characters according to the naming
conventions of the target file system. The ReturnSingleEntry parameter is
simply ignored.
The information that is obtained about the entries in the directory or OLE
container is based on the FileInformationClass parameter. Legal values are
hard coded based on the MinorFunction.
Arguments:
FileHandle - Supplies a handle to the directory file or OLE container for
which information should be returned.
Event - Supplies an optional event to be set to the Signaled state when
the query is complete.
ApcRoutine - Supplies an optional APC routine to be executed when the
query is complete.
ApcContext - Supplies a context parameter to be passed to the ApcRoutine,
if an ApcRoutine was specified.
IoStatusBlock - Address of the caller's I/O status block.
FileInformation - Supplies a buffer to receive the requested information
returned about the contents of the directory.
Length - Supplies the length, in bytes, of the FileInformation buffer.
FileInformationClass - Specfies the type of information that is to be
returned about the files in the specified directory or OLE container.
ReturnSingleEntry - Supplies a BOOLEAN value that, if TRUE, indicates that
only a single entry should be returned.
FileName - Optionally supplies a file name within the specified directory
or OLE container.
RestartScan - Supplies a BOOLEAN value that, if TRUE, indicates that the
scan should be restarted from the beginning. This parameter must be
set to TRUE by the caller the first time the service is invoked.
MinorFunction - IRP_MN_QUERY_DIRECTORY or IRP_MN_QUERY_OLE_DIRECTORY
SynchronousIo - pointer to returned BOOLEAN; TRUE if synchronous I/O
DeviceObject - pointer to returned pointer to device object
Irp - pointer to returned pointer to device object
FileObject - pointer to returned pointer to file object
RequestorMode - pointer to returned requestor mode
Return Value:
The status returned is STATUS_SUCCESS if a valid irp was created for the
query operation.
--*/
{
PIRP irp;
NTSTATUS status;
PFILE_OBJECT fileObject;
PDEVICE_OBJECT deviceObject;
PKEVENT eventObject = (PKEVENT) NULL;
KPROCESSOR_MODE requestorMode;
PCHAR auxiliaryBuffer = (PCHAR) NULL;
PIO_STACK_LOCATION irpSp;
PMDL mdl;
PETHREAD CurrentThread;
PAGED_CODE();
//
// Get the previous mode; i.e., the mode of the caller.
//
CurrentThread = PsGetCurrentThread ();
requestorMode = KeGetPreviousModeByThread(&CurrentThread->Tcb);
*RequestorMode = requestorMode;
try {
if (requestorMode != KernelMode) {
ULONG operationlength = 0; // assume invalid
//
// The caller's access mode is not kernel so probe and validate
// each of the arguments as necessary. If any failures occur,
// the condition handler will be invoked to handle them. It
// will simply cleanup and return an access violation status
// code back to the system service dispatcher.
//
//
// The IoStatusBlock parameter must be writeable by the caller.
//
ProbeForWriteIoStatus(IoStatusBlock);
//
// Ensure that the FileInformationClass parameter is legal for
// querying information about files in the directory or object.
//
if (FileInformationClass == FileDirectoryInformation) {
operationlength = sizeof(FILE_DIRECTORY_INFORMATION);
} else if (MinorFunction == IRP_MN_QUERY_DIRECTORY) {
switch (FileInformationClass)
{
case FileFullDirectoryInformation:
operationlength = sizeof(FILE_FULL_DIR_INFORMATION);
break;
case FileIdFullDirectoryInformation:
operationlength = sizeof(FILE_ID_FULL_DIR_INFORMATION);
break;
case FileBothDirectoryInformation:
operationlength = sizeof(FILE_BOTH_DIR_INFORMATION);
break;
case FileIdBothDirectoryInformation:
operationlength = sizeof(FILE_ID_BOTH_DIR_INFORMATION);
break;
case FileNamesInformation:
operationlength = sizeof(FILE_NAMES_INFORMATION);
break;
case FileObjectIdInformation:
operationlength = sizeof(FILE_OBJECTID_INFORMATION);
break;
case FileQuotaInformation:
operationlength = sizeof(FILE_QUOTA_INFORMATION);
break;
case FileReparsePointInformation:
operationlength = sizeof(FILE_REPARSE_POINT_INFORMATION);
break;
}
}
//
// If the FileInformationClass parameter is illegal, fail now.
//
if (operationlength == 0) {
return STATUS_INVALID_INFO_CLASS;
}
//
// Ensure that the caller's supplied buffer is at least large enough
// to contain the fixed part of the structure required for this
// query.
//
if (Length < operationlength) {
return STATUS_INFO_LENGTH_MISMATCH;
}
//
// The FileInformation buffer must be writeable by the caller.
//
#if defined(_X86_)
ProbeForWrite( FileInformation, Length, sizeof( ULONG ) );
#elif defined(_WIN64)
//
// If we are a wow64 process, follow the X86 rules
//
if (PsGetCurrentProcessByThread(CurrentThread)->Wow64Process) {
ProbeForWrite( FileInformation, Length, sizeof( ULONG ) );
} else {
ProbeForWrite( FileInformation,
Length,
IopQuerySetAlignmentRequirement[FileInformationClass] );
}
#else
ProbeForWrite( FileInformation,
Length,
IopQuerySetAlignmentRequirement[FileInformationClass] );
#endif
}
//
// If the optional FileName parameter was specified, then it must be
// readable by the caller. Capture the file name string in a pool
// block. Note that if an error occurs during the copy, the cleanup
// code in the exception handler will deallocate the pool before
// returning an access violation status.
//
if (ARGUMENT_PRESENT( FileName )) {
UNICODE_STRING fileName;
PUNICODE_STRING nameBuffer;
//
// Capture the string descriptor itself to ensure that the
// string is readable by the caller without the caller being
// able to change the memory while its being checked.
//
if (requestorMode != KernelMode) {
ProbeAndReadUnicodeStringEx( &fileName, FileName );
} else {
fileName = *FileName;
}
//
// If the length is not an even number of bytes
// return an error.
//
if (fileName.Length & (sizeof(WCHAR) - 1)) {
return STATUS_INVALID_PARAMETER;
}
if (fileName.Length) {
//
// The length of the string is non-zero, so probe the
// buffer described by the descriptor if the caller was
// not kernel mode. Likewise, if the caller's mode was
// not kernel, then check the length of the name string
// to ensure that it is not too long.
//
if (requestorMode != KernelMode) {
ProbeForRead( fileName.Buffer,
fileName.Length,
sizeof( UCHAR ) );
//
// account for unicode
//
if (fileName.Length > MAXIMUM_FILENAME_LENGTH<<1) {
ExRaiseStatus( STATUS_INVALID_PARAMETER );
}
}
//
// Allocate an auxiliary buffer large enough to contain
// a file name descriptor and to hold the entire file
// name itself. Copy the body of the string into the
// buffer.
//
auxiliaryBuffer = ExAllocatePoolWithQuota( NonPagedPool,
fileName.Length + sizeof( UNICODE_STRING ) );
RtlCopyMemory( auxiliaryBuffer + sizeof( UNICODE_STRING ),
fileName.Buffer,
fileName.Length );
//
// Finally, build the Unicode string descriptor in the
// auxiliary buffer.
//
nameBuffer = (PUNICODE_STRING) auxiliaryBuffer;
nameBuffer->Length = fileName.Length;
nameBuffer->MaximumLength = fileName.Length;
nameBuffer->Buffer = (PWSTR) (auxiliaryBuffer + sizeof( UNICODE_STRING ) );
}
}
} except(EXCEPTION_EXECUTE_HANDLER) {
//
// An exception was incurred while probing the caller's buffers,
// attempting to allocate a pool buffer, or while trying to copy
// the caller's data. Determine what happened, clean everything
// up, and return an appropriate error status code.
//
if (auxiliaryBuffer) {
ExFreePool( auxiliaryBuffer );
}
return GetExceptionCode();
}
//
// There were no blatant errors so far, so reference the file object so
// the target device object can be found. Note that if the handle does
// not refer to a file object, or if the caller does not have the required
// access to the file, then it will fail.
//
status = ObReferenceObjectByHandle( FileHandle,
FILE_LIST_DIRECTORY,
IoFileObjectType,
requestorMode,
(PVOID *) &fileObject,
(POBJECT_HANDLE_INFORMATION) NULL );
if (!NT_SUCCESS( status )) {
if (auxiliaryBuffer) {
ExFreePool( auxiliaryBuffer );
}
return status;
}
*FileObject = fileObject;
//
// If this file has an I/O completion port associated w/it, then ensure
// that the caller did not supply an APC routine, as the two are mutually
// exclusive methods for I/O completion notification.
//
if (fileObject->CompletionContext && IopApcRoutinePresent( ApcRoutine )) {
ObDereferenceObject( fileObject );
if (auxiliaryBuffer) {
ExFreePool( auxiliaryBuffer );
}
return STATUS_INVALID_PARAMETER;
}
//
// Get the address of the event object and set the event to the Not-
// Signaled state, if an event was specified. Note here, too, that if
// the handle does not refer to an event, or if the event cannot be
// written, then the reference will fail.
//
if (ARGUMENT_PRESENT( Event )) {
status = ObReferenceObjectByHandle( Event,
EVENT_MODIFY_STATE,
ExEventObjectType,
requestorMode,
(PVOID *) &eventObject,
(POBJECT_HANDLE_INFORMATION) NULL );
if (!NT_SUCCESS( status )) {
if (auxiliaryBuffer) {
ExFreePool( auxiliaryBuffer );
}
ObDereferenceObject( fileObject );
return status;
} else {
KeClearEvent( eventObject );
}
}
//
// Make a special check here to determine whether this is a synchronous
// I/O operation. If it is, then wait here until the file is owned by
// the current thread.
//
if (fileObject->Flags & FO_SYNCHRONOUS_IO) {
BOOLEAN interrupted;
if (!IopAcquireFastLock( fileObject )) {
status = IopAcquireFileObjectLock( fileObject,
requestorMode,
(BOOLEAN) ((fileObject->Flags & FO_ALERTABLE_IO) != 0),
&interrupted );
if (interrupted) {
if (auxiliaryBuffer != NULL) {
ExFreePool( auxiliaryBuffer );
}
if (eventObject != NULL) {
ObDereferenceObject( eventObject );
}
ObDereferenceObject( fileObject );
return status;
}
}
*SynchronousIo = TRUE;
} else {
*SynchronousIo = FALSE;
#if defined(_WIN64)
if (requestorMode != KernelMode) {
try {
//
// If this is a 32-bit asynchronous IO, then mark the Iosb being sent as so.
// Note: IopMarkApcRoutineIfAsyncronousIo32 must be called after probing
// the IoStatusBlock structure for write.
//
IopMarkApcRoutineIfAsyncronousIo32(IoStatusBlock,ApcRoutine,FALSE);
} except (EXCEPTION_EXECUTE_HANDLER) {
//
// An IRP could not be allocated. Cleanup and return an appropriate
// error status code.
//
IopAllocateIrpCleanup( fileObject, eventObject );
if (auxiliaryBuffer) {
ExFreePool( auxiliaryBuffer );
}
return GetExceptionCode ();
}
}
#endif
}
//
// Set the file object to the Not-Signaled state.
//
KeClearEvent( &fileObject->Event );
//
// Get the address of the target device object.
//
deviceObject = IoGetRelatedDeviceObject( fileObject );
*DeviceObject = deviceObject;
//
// Allocate and initialize the I/O Request Packet (IRP) for this operation.
// The allocation is performed with an exception handler in case the
// caller does not have enough quota to allocate the packet.
irp = IoAllocateIrp( deviceObject->StackSize, !(*SynchronousIo) );
if (!irp) {
//
// An IRP could not be allocated. Cleanup and return an appropriate
// error status code.
//
IopAllocateIrpCleanup( fileObject, eventObject );
if (auxiliaryBuffer) {
ExFreePool( auxiliaryBuffer );
}
return STATUS_INSUFFICIENT_RESOURCES;
}
*Irp = irp;
irp->Tail.Overlay.OriginalFileObject = fileObject;
irp->Tail.Overlay.Thread = CurrentThread;
irp->RequestorMode = requestorMode;
//
// Fill in the service independent parameters in the IRP.
//
irp->UserEvent = eventObject;
irp->UserIosb = IoStatusBlock;
irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
//
// Get a pointer to the stack location for the first driver. This will be
// used to pass the original function codes and parameters.
//
irpSp = IoGetNextIrpStackLocation( irp );
irpSp->MajorFunction = IRP_MJ_DIRECTORY_CONTROL;
irpSp->MinorFunction = MinorFunction;
irpSp->FileObject = fileObject;
// Also, copy the caller's parameters to the service-specific portion of
// the IRP.
//
irp->Tail.Overlay.AuxiliaryBuffer = auxiliaryBuffer;
irp->AssociatedIrp.SystemBuffer = (PVOID) NULL;
irp->MdlAddress = (PMDL) NULL;
//
// Now determine whether this driver expects to have data buffered to it
// or whether it performs direct I/O. This is based on the DO_BUFFERED_IO
// flag in the device object. If the flag is set, then a system buffer is
// allocated and the driver's data will be copied into it. Otherwise, a
// Memory Descriptor List (MDL) is allocated and the caller's buffer is
// locked down using it.
//
if (deviceObject->Flags & DO_BUFFERED_IO) {
//
// The device does not support direct I/O. Allocate a system buffer
// and specify that it should be deallocated on completion. Also
// indicate that this is an input operation so the data will be copied
// into the caller's buffer. This is done using an exception handler
// that will perform cleanup if the operation fails.
//
try {
//
// Allocate the intermediary system buffer from nonpaged pool and
// charge quota for it.
//
irp->AssociatedIrp.SystemBuffer =
ExAllocatePoolWithQuota( NonPagedPool, Length );
} except(EXCEPTION_EXECUTE_HANDLER) {
//
// An exception was incurred while either probing the caller's
// buffer or allocate the system buffer. Determine what actually
// happened, clean everything up, and return an appropriate error
// status code.
//
IopExceptionCleanup( fileObject,
irp,
eventObject,
(PKEVENT) NULL );
if (auxiliaryBuffer != NULL) {
ExFreePool( auxiliaryBuffer );
}
return GetExceptionCode();
}
//
// Remember the address of the caller's buffer so the copy can take
// place during I/O completion. Also, set the flags so that the
// completion code knows to do the copy and to deallocate the buffer.
//
irp->UserBuffer = FileInformation;
irp->Flags = (ULONG) (IRP_BUFFERED_IO |
IRP_DEALLOCATE_BUFFER |
IRP_INPUT_OPERATION);
} else if (deviceObject->Flags & DO_DIRECT_IO) {
NTSTATUS
NTAPI
_MiSimpleWrite(PFILE_OBJECT FileObject,
PLARGE_INTEGER FileOffset,
PVOID Buffer,
ULONG Length,
PIO_STATUS_BLOCK ReadStatus,
const char *File,
int Line)
{
NTSTATUS Status;
PIRP Irp = NULL;
KEVENT ReadWait;
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION IrpSp;
ASSERT(FileObject);
ASSERT(FileOffset);
ASSERT(Buffer);
ASSERT(ReadStatus);
DeviceObject = MmGetDeviceObjectForFile(FileObject);
ASSERT(DeviceObject);
DPRINT("PAGING WRITE: FileObject %p <%wZ> Offset 0x%I64x Length %lu (%s:%d)\n",
FileObject,
&FileObject->FileName,
FileOffset->QuadPart,
Length,
File,
Line);
KeInitializeEvent(&ReadWait, NotificationEvent, FALSE);
Irp = IoBuildAsynchronousFsdRequest(IRP_MJ_WRITE,
DeviceObject,
Buffer,
Length,
FileOffset,
ReadStatus);
if (!Irp)
{
return STATUS_NO_MEMORY;
}
Irp->Flags = IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO | IRP_NOCACHE | IRP_SYNCHRONOUS_API;
Irp->UserEvent = &ReadWait;
Irp->Tail.Overlay.OriginalFileObject = FileObject;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
IrpSp = IoGetNextIrpStackLocation(Irp);
IrpSp->Control |= SL_INVOKE_ON_SUCCESS | SL_INVOKE_ON_ERROR;
IrpSp->FileObject = FileObject;
IrpSp->CompletionRoutine = MiSimpleReadComplete;
DPRINT("Call Driver\n");
Status = IoCallDriver(DeviceObject, Irp);
DPRINT("Status %x\n", Status);
if (Status == STATUS_PENDING)
{
DPRINT("KeWaitForSingleObject(&ReadWait)\n");
if (!NT_SUCCESS(KeWaitForSingleObject(&ReadWait,
Suspended,
KernelMode,
FALSE,
NULL)))
{
DPRINT1("Warning: Failed to wait for synchronous IRP\n");
ASSERT(FALSE);
return Status;
}
}
DPRINT("Paging IO Done: %08x\n", ReadStatus->Status);
return ReadStatus->Status;
}
NTSTATUS
HidClassFDO_GetDescriptors(
IN PDEVICE_OBJECT DeviceObject)
{
PHIDCLASS_FDO_EXTENSION FDODeviceExtension;
PIRP Irp;
PIO_STACK_LOCATION IoStack;
NTSTATUS Status;
//
// get device extension
//
FDODeviceExtension = DeviceObject->DeviceExtension;
ASSERT(FDODeviceExtension->Common.IsFDO);
//
// let's allocate irp
//
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
if (!Irp)
{
//
// no memory
//
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// get stack location
//
IoStack = IoGetNextIrpStackLocation(Irp);
//
// init stack location
//
IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_HID_GET_DEVICE_DESCRIPTOR;
IoStack->Parameters.DeviceIoControl.OutputBufferLength = sizeof(HID_DESCRIPTOR);
IoStack->Parameters.DeviceIoControl.InputBufferLength = 0;
IoStack->Parameters.DeviceIoControl.Type3InputBuffer = NULL;
Irp->UserBuffer = &FDODeviceExtension->HidDescriptor;
//
// send request
//
Status = HidClassFDO_DispatchRequestSynchronous(DeviceObject, Irp);
if (!NT_SUCCESS(Status))
{
//
// failed to get device descriptor
//
DPRINT1("[HIDCLASS] IOCTL_HID_GET_DEVICE_DESCRIPTOR failed with %x\n", Status);
IoFreeIrp(Irp);
return Status;
}
//
// let's get device attributes
//
IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_HID_GET_DEVICE_ATTRIBUTES;
IoStack->Parameters.DeviceIoControl.OutputBufferLength = sizeof(HID_DEVICE_ATTRIBUTES);
Irp->UserBuffer = &FDODeviceExtension->Common.Attributes;
//
// send request
//
Status = HidClassFDO_DispatchRequestSynchronous(DeviceObject, Irp);
if (!NT_SUCCESS(Status))
{
//
// failed to get device descriptor
//
DPRINT1("[HIDCLASS] IOCTL_HID_GET_DEVICE_ATTRIBUTES failed with %x\n", Status);
IoFreeIrp(Irp);
return Status;
}
//
// sanity checks
//
ASSERT(FDODeviceExtension->HidDescriptor.bLength == sizeof(HID_DESCRIPTOR));
ASSERT(FDODeviceExtension->HidDescriptor.bNumDescriptors > 0);
ASSERT(FDODeviceExtension->HidDescriptor.DescriptorList[0].wReportLength > 0);
ASSERT(FDODeviceExtension->HidDescriptor.DescriptorList[0].bReportType == HID_REPORT_DESCRIPTOR_TYPE);
//
// now allocate space for the report descriptor
//
FDODeviceExtension->ReportDescriptor = ExAllocatePoolWithTag(NonPagedPool,
FDODeviceExtension->HidDescriptor.DescriptorList[0].wReportLength,
HIDCLASS_TAG);
if (!FDODeviceExtension->ReportDescriptor)
{
//
// not enough memory
//
IoFreeIrp(Irp);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// init stack location
//
IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_HID_GET_REPORT_DESCRIPTOR;
IoStack->Parameters.DeviceIoControl.OutputBufferLength = FDODeviceExtension->HidDescriptor.DescriptorList[0].wReportLength;
Irp->UserBuffer = FDODeviceExtension->ReportDescriptor;
//
// send request
//
Status = HidClassFDO_DispatchRequestSynchronous(DeviceObject, Irp);
if (!NT_SUCCESS(Status))
{
//
// failed to get device descriptor
//
DPRINT1("[HIDCLASS] IOCTL_HID_GET_REPORT_DESCRIPTOR failed with %x\n", Status);
IoFreeIrp(Irp);
return Status;
}
//
// completed successfully
//
IoFreeIrp(Irp);
return STATUS_SUCCESS;
}
NTSTATUS
ImDiskReadWriteLowerDevice(PIRP Irp, PDEVICE_EXTENSION DeviceExtension)
{
PIO_STACK_LOCATION io_stack = IoGetCurrentIrpStackLocation(Irp);
PIO_STACK_LOCATION lower_io_stack;
PIRP lower_irp;
PLOWER_DEVICE_WORK_ITEM item;
// If image file is a direct I/O device, we simply forward the IRP with
// correct FILE_OBJECT and adjusted offset if needed.
if ((DeviceExtension->dev_object->Flags & DO_DIRECT_IO) == DO_DIRECT_IO)
{
IoCopyCurrentIrpStackLocationToNext(Irp);
lower_io_stack = IoGetNextIrpStackLocation(Irp);
lower_io_stack->Parameters.Read.ByteOffset.QuadPart +=
DeviceExtension->image_offset.QuadPart;
lower_io_stack->FileObject = DeviceExtension->file_object;
if ((io_stack->MajorFunction == IRP_MJ_WRITE) &&
!DeviceExtension->image_modified)
{
DeviceExtension->image_modified = TRUE;
// Fire refresh event
if (RefreshEvent != NULL)
KePulseEvent(RefreshEvent, 0, FALSE);
}
return IoCallDriver(DeviceExtension->dev_object, Irp);
}
// This goes for image files with DO_BUFFERED_IO or DO_NEITHER_IO.
// We allocate NP pool as buffer for a request to send down. A completion
// routine takes care of copying read operation data back to original IRP.
item = (PLOWER_DEVICE_WORK_ITEM)
ExAllocatePoolWithTag(NonPagedPool,
sizeof(*item), POOL_TAG);
if (item == NULL)
{
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(item, sizeof(*item));
item->OriginalIrp = Irp;
item->DeviceExtension = DeviceExtension;
item->OriginalOffset = io_stack->Parameters.Read.ByteOffset.QuadPart;
if ((io_stack->MajorFunction == IRP_MJ_READ) ||
(io_stack->MajorFunction == IRP_MJ_WRITE))
{
item->SystemBuffer = (PUCHAR)
MmGetSystemAddressForMdlSafe(Irp->MdlAddress,
NormalPagePriority);
if (item->SystemBuffer == NULL)
{
ExFreePoolWithTag(item, POOL_TAG);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
}
lower_irp = IoAllocateIrp(DeviceExtension->dev_object->StackSize, FALSE);
if (lower_irp == NULL)
{
ExFreePoolWithTag(item, POOL_TAG);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
lower_io_stack = IoGetNextIrpStackLocation(lower_irp);
lower_io_stack->MajorFunction = io_stack->MajorFunction;
lower_io_stack->Parameters = io_stack->Parameters;
if ((io_stack->MajorFunction == IRP_MJ_READ) ||
(io_stack->MajorFunction == IRP_MJ_WRITE))
{
lower_irp->AssociatedIrp.SystemBuffer =
lower_irp->UserBuffer =
item->AllocatedBuffer = (PUCHAR)
ExAllocatePoolWithTag(NonPagedPool,
io_stack->Parameters.Read.Length, POOL_TAG);
if (item->AllocatedBuffer == NULL)
{
ImDiskFreeIrpWithMdls(lower_irp);
ExFreePoolWithTag(item, POOL_TAG);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
if (io_stack->MajorFunction == IRP_MJ_WRITE)
{
RtlCopyMemory(item->AllocatedBuffer, item->SystemBuffer,
io_stack->Parameters.Write.Length);
}
else if (io_stack->MajorFunction == IRP_MJ_READ)
{
item->CopyBack = TRUE;
}
}
lower_irp->Tail.Overlay.Thread = Irp->Tail.Overlay.Thread;
if (io_stack->MajorFunction == IRP_MJ_READ)
{
lower_irp->Flags |= IRP_READ_OPERATION;
}
else if (io_stack->MajorFunction == IRP_MJ_WRITE)
{
lower_irp->Flags |= IRP_WRITE_OPERATION;
lower_io_stack->Flags |= SL_WRITE_THROUGH;
}
lower_irp->Flags |= IRP_NOCACHE;
lower_io_stack->Parameters.Read = io_stack->Parameters.Read;
lower_io_stack->Parameters.Read.ByteOffset.QuadPart +=
DeviceExtension->image_offset.QuadPart;
lower_io_stack->FileObject = DeviceExtension->file_object;
if ((io_stack->MajorFunction == IRP_MJ_WRITE) &&
(!DeviceExtension->image_modified))
{
DeviceExtension->image_modified = TRUE;
// Fire refresh event
if (RefreshEvent != NULL)
KePulseEvent(RefreshEvent, 0, FALSE);
}
IoSetCompletionRoutine(lower_irp, ImDiskReadWriteLowerDeviceCompletion,
item, TRUE, TRUE, TRUE);
IoMarkIrpPending(Irp);
(void)IoCallDriver(DeviceExtension->dev_object, lower_irp);
return STATUS_PENDING;
}
//
// I/O Control to the LanscsiMiniport.
// Buffers must be allocated from NonPagedPool
//
// NOTE: Do not use LANSCSIMINIPORT_IOCTL_QUERYINFO.
// It uses separate input/output buffer.
// It will be obsolete.
//
NTSTATUS
LSBus_IoctlToLSMPDevice(
PPDO_DEVICE_DATA PdoData,
ULONG IoctlCode,
PVOID InputBuffer,
LONG InputBufferLength,
PVOID OutputBuffer,
LONG OutputBufferLength
) {
PDEVICE_OBJECT AttachedDevice;
PIRP irp;
KEVENT event;
PSRB_IO_CONTROL psrbIoctl;
LONG srbIoctlLength;
PVOID srbIoctlBuffer;
LONG srbIoctlBufferLength;
NTSTATUS status;
PIO_STACK_LOCATION irpStack;
SCSI_REQUEST_BLOCK srb;
LARGE_INTEGER startingOffset;
IO_STATUS_BLOCK ioStatusBlock;
AttachedDevice = NULL;
psrbIoctl = NULL;
irp = NULL;
//
// get a ScsiPort device or attached one.
//
AttachedDevice = IoGetAttachedDeviceReference(PdoData->Self);
if(AttachedDevice == NULL) {
Bus_KdPrint_Def( BUS_DBG_SS_ERROR, ("STATUS_INVALID_DEVICE\n"));
return STATUS_NO_SUCH_DEVICE;
}
//
// build an SRB for the miniport
//
srbIoctlBufferLength = (InputBufferLength>OutputBufferLength)?InputBufferLength:OutputBufferLength;
srbIoctlLength = sizeof(SRB_IO_CONTROL) + srbIoctlBufferLength;
psrbIoctl = (PSRB_IO_CONTROL)ExAllocatePoolWithTag(NonPagedPool , srbIoctlLength, BUSENUM_POOL_TAG);
if(psrbIoctl == NULL) {
Bus_KdPrint_Def( BUS_DBG_SS_ERROR, ("STATUS_INSUFFICIENT_RESOURCES\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
RtlZeroMemory(psrbIoctl, srbIoctlLength);
psrbIoctl->HeaderLength = sizeof(SRB_IO_CONTROL);
RtlCopyMemory(psrbIoctl->Signature, LANSCSIMINIPORT_IOCTL_SIGNATURE, 8);
psrbIoctl->Timeout = 60 * 60;
psrbIoctl->ControlCode = IoctlCode;
psrbIoctl->Length = srbIoctlBufferLength;
srbIoctlBuffer = (PUCHAR)psrbIoctl + sizeof(SRB_IO_CONTROL);
RtlCopyMemory(srbIoctlBuffer, InputBuffer, InputBufferLength);
//
// Initialize the notification event.
//
KeInitializeEvent(&event,
NotificationEvent,
FALSE);
startingOffset.QuadPart = 1;
//
// Build IRP for this request.
// Note we do this synchronously for two reasons. If it was done
// asynchonously then the completion code would have to make a special
// check to deallocate the buffer. Second if a completion routine were
// used then an additional IRP stack location would be needed.
//
irp = IoBuildSynchronousFsdRequest(
IRP_MJ_SCSI,
AttachedDevice,
psrbIoctl,
srbIoctlLength,
&startingOffset,
&event,
&ioStatusBlock);
irpStack = IoGetNextIrpStackLocation(irp);
if (irp == NULL) {
Bus_KdPrint_Def( BUS_DBG_SS_ERROR, ("STATUS_INSUFFICIENT_RESOURCES\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
//
// Set major and minor codes.
//
irpStack->MajorFunction = IRP_MJ_SCSI;
irpStack->MinorFunction = 1;
//
// Fill in SRB fields.
//
irpStack->Parameters.Others.Argument1 = &srb;
//
// Zero out the srb.
//
RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
srb.PathId = 0;
srb.TargetId = 0;
srb.Lun = 0;
srb.Function = SRB_FUNCTION_IO_CONTROL;
srb.Length = sizeof(SCSI_REQUEST_BLOCK);
srb.SrbFlags = /*SRB_FLAGS_DATA_IN |*/ SRB_FLAGS_NO_QUEUE_FREEZE /*| SRB_FLAGS_BYPASS_FROZEN_QUEUE */;
srb.OriginalRequest = irp;
//
// Set timeout to requested value.
//
srb.TimeOutValue = psrbIoctl->Timeout;
//
// Set the data buffer.
//
srb.DataBuffer = psrbIoctl;
srb.DataTransferLength = srbIoctlLength;
//
// Flush the data buffer for output. This will insure that the data is
// written back to memory. Since the data-in flag is the the port driver
// will flush the data again for input which will ensure the data is not
// in the cache.
//
/*
KeFlushIoBuffers(irp->MdlAddress, FALSE, TRUE);
*/
status = IoCallDriver( AttachedDevice, irp );
//
// Wait for request to complete.
//
if (status == STATUS_PENDING) {
(VOID)KeWaitForSingleObject(
&event,
Executive,
KernelMode,
FALSE,
(PLARGE_INTEGER)NULL
);
status = ioStatusBlock.Status;
}
//
// get the result
//
// if(status == STATUS_SUCCESS) {
if(OutputBuffer && OutputBufferLength)
RtlCopyMemory(OutputBuffer, srbIoctlBuffer, OutputBufferLength);
Bus_KdPrint_Def( BUS_DBG_SS_NOISE, ("%d succeeded!\n", IoctlCode));
// }
if(psrbIoctl->ControlCode == STATUS_BUFFER_TOO_SMALL) {
status = STATUS_BUFFER_TOO_SMALL;
}
cleanup:
if(psrbIoctl)
ExFreePool(psrbIoctl);
if(AttachedDevice)
ObDereferenceObject(AttachedDevice);
return status;
}
/*++////////////////////////////////////////////////////////////////////////////
RetryRequest()
Routine Description:
This is a wrapper around the delayed retry DPC routine, RetryRequestDPC.
This reinitializes the necessary fields, queues the request, and sets
a timer to call the DPC if someone hasn't already done so.
Arguments:
DeviceObject - Supplies the device object associated with this request.
Irp - Supplies the request to be retried.
Srb - Supplies a Pointer to the SCSI request block to be retied.
Associated - Indicates this is an associated Irp created by split request.
RetryInterval - How long, in seconds, before retrying the request.
Return Value:
None
--*/
VOID
NTAPI
RetryRequest(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PSCSI_REQUEST_BLOCK Srb,
BOOLEAN Associated,
ULONG RetryInterval
)
{
PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
ULONG transferByteCount;
// This function is obsolete but is still used by some of our class drivers.
// DBGWARN(("RetryRequest is OBSOLETE !"));
//
// Determine the transfer count of the request. If this is a read or a
// write then the transfer count is in the Irp stack. Otherwise assume
// the MDL contains the correct length. If there is no MDL then the
// transfer length must be zero.
//
if (currentIrpStack->MajorFunction == IRP_MJ_READ ||
currentIrpStack->MajorFunction == IRP_MJ_WRITE) {
transferByteCount = currentIrpStack->Parameters.Read.Length;
} else if (Irp->MdlAddress != NULL) {
//
// Note this assumes that only read and write requests are spilt and
// other request do not need to be. If the data buffer address in
// the MDL and the SRB don't match then transfer length is most
// likely incorrect.
//
ASSERT(Srb->DataBuffer == MmGetMdlVirtualAddress(Irp->MdlAddress));
transferByteCount = Irp->MdlAddress->ByteCount;
} else {
transferByteCount = 0;
}
//
// this is a safety net. this should not normally be hit, since we are
// not guaranteed to be an fdoExtension
//
ASSERT(!TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
//
// Reset byte count of transfer in SRB Extension.
//
Srb->DataTransferLength = transferByteCount;
//
// Zero SRB statuses.
//
Srb->SrbStatus = Srb->ScsiStatus = 0;
//
// Set the no disconnect flag, disable synchronous data transfers and
// disable tagged queuing. This fixes some errors.
// NOTE: Cannot clear these flags, just add to them
//
SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DISABLE_DISCONNECT);
SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
CLEAR_FLAG(Srb->SrbFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE);
Srb->QueueTag = SP_UNTAGGED;
//
// Set up major SCSI function.
//
nextIrpStack->MajorFunction = IRP_MJ_SCSI;
//
// Save SRB address in next stack for port driver.
//
nextIrpStack->Parameters.Scsi.Srb = Srb;
IoSetCompletionRoutine(Irp, ClassIoComplete, Srb, TRUE, TRUE, TRUE);
{
LARGE_INTEGER retry100ns;
retry100ns.QuadPart = RetryInterval; // seconds
retry100ns.QuadPart *= (LONGLONG)1000 * 1000 * 10;
ClassRetryRequest(DeviceObject, Irp, retry100ns);
}
return;
} // end RetryRequest()
BOOLEAN
NTAPI
FsRecGetDeviceSectorSize(IN PDEVICE_OBJECT DeviceObject,
OUT PULONG SectorSize)
{
DISK_GEOMETRY DiskGeometry;
IO_STATUS_BLOCK IoStatusBlock;
KEVENT Event;
PIRP Irp;
NTSTATUS Status;
ULONG ControlCode;
PAGED_CODE();
/* Check what device we have */
switch (DeviceObject->DeviceType)
{
case FILE_DEVICE_CD_ROM:
/* Use the CD IOCTL */
ControlCode = IOCTL_CDROM_GET_DRIVE_GEOMETRY;
break;
case FILE_DEVICE_DISK:
/* Use the Disk IOCTL */
ControlCode = IOCTL_DISK_GET_DRIVE_GEOMETRY;
break;
default:
/* Invalid device type */
return FALSE;
}
/* Build the information IRP */
KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
Irp = IoBuildDeviceIoControlRequest(ControlCode,
DeviceObject,
NULL,
0,
&DiskGeometry,
sizeof(DISK_GEOMETRY),
FALSE,
&Event,
&IoStatusBlock);
if (!Irp) return FALSE;
/* Override verification */
IoGetNextIrpStackLocation(Irp)->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
/* Do the request */
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
/* Wait for completion */
KeWaitForSingleObject(&Event,
Executive,
KernelMode,
FALSE,
NULL);
Status = IoStatusBlock.Status;
}
/* Fail if we couldn't get the data */
if (!NT_SUCCESS(Status)) return FALSE;
/* Return the sector size if it's valid */
if (!DiskGeometry.BytesPerSector) return FALSE;
*SectorSize = DiskGeometry.BytesPerSector;
return TRUE;
}
VOID
NTAPI
ClasspBuildRequestEx(
IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
IN PIRP Irp,
IN PSCSI_REQUEST_BLOCK Srb
)
/*++
ClasspBuildRequestEx()
Routine Description:
This routine allocates and builds an Srb for a read or write request.
The block address and length are supplied by the Irp. The retry count
is stored in the current stack for use by ClassIoComplete which
processes these requests when they complete. The Irp is ready to be
passed to the port driver when this routine returns.
Arguments:
FdoExtension - Supplies the device extension associated with this request.
Irp - Supplies the request to be issued.
Srb - Supplies an SRB to be used for the request.
Note:
If the IRP is for a disk transfer, the byteoffset field
will already have been adjusted to make it relative to
the beginning of the disk.
Return Value:
NT Status
--*/
{
PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
LARGE_INTEGER startingOffset = currentIrpStack->Parameters.Read.ByteOffset;
PCDB cdb;
ULONG logicalBlockAddress;
USHORT transferBlocks;
// This function is obsolete, but still called by CDROM.SYS .
// DBGWARN(("ClasspBuildRequestEx is OBSOLETE !"));
//
// Prepare the SRB.
//
RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
//
// Calculate relative sector address.
//
logicalBlockAddress =
(ULONG)(Int64ShrlMod32(startingOffset.QuadPart,
FdoExtension->SectorShift));
//
// Write length to SRB.
//
Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
//
// Set up IRP Address.
//
Srb->OriginalRequest = Irp;
//
// Set up target ID and logical unit number.
//
Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
Srb->DataBuffer = MmGetMdlVirtualAddress(Irp->MdlAddress);
//
// Save byte count of transfer in SRB Extension.
//
Srb->DataTransferLength = currentIrpStack->Parameters.Read.Length;
//
// Initialize the queue actions field.
//
Srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
//
// Queue sort key is Relative Block Address.
//
Srb->QueueSortKey = logicalBlockAddress;
//
// Indicate auto request sense by specifying buffer and size.
//
Srb->SenseInfoBuffer = FdoExtension->SenseData;
Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
//
// Set timeout value of one unit per 64k bytes of data.
//
Srb->TimeOutValue = ((Srb->DataTransferLength + 0xFFFF) >> 16) *
FdoExtension->TimeOutValue;
//
// Zero statuses.
//
Srb->SrbStatus = Srb->ScsiStatus = 0;
Srb->NextSrb = 0;
//
// Indicate that 10-byte CDB's will be used.
//
Srb->CdbLength = 10;
//
// Fill in CDB fields.
//
cdb = (PCDB)Srb->Cdb;
transferBlocks = (USHORT)(currentIrpStack->Parameters.Read.Length >>
FdoExtension->SectorShift);
//
// Move little endian values into CDB in big endian format.
//
cdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte3;
cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte2;
cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte1;
cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte0;
cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&transferBlocks)->Byte1;
cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&transferBlocks)->Byte0;
//
// Set transfer direction flag and Cdb command.
//
if (currentIrpStack->MajorFunction == IRP_MJ_READ) {
DebugPrint((3, "ClassBuildRequest: Read Command\n"));
SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DATA_IN);
cdb->CDB10.OperationCode = SCSIOP_READ;
} else {
DebugPrint((3, "ClassBuildRequest: Write Command\n"));
SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DATA_OUT);
cdb->CDB10.OperationCode = SCSIOP_WRITE;
}
//
// If this is not a write-through request, then allow caching.
//
if (!(currentIrpStack->Flags & SL_WRITE_THROUGH)) {
SET_FLAG(Srb->SrbFlags, SRB_FLAGS_ADAPTER_CACHE_ENABLE);
} else {
//
// If write caching is enable then force media access in the
// cdb.
//
if (FdoExtension->DeviceFlags & DEV_WRITE_CACHE) {
cdb->CDB10.ForceUnitAccess = TRUE;
}
}
if(TEST_FLAG(Irp->Flags, (IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO))) {
SET_FLAG(Srb->SrbFlags, SRB_CLASS_FLAGS_PAGING);
}
//
// OR in the default flags from the device object.
//
SET_FLAG(Srb->SrbFlags, FdoExtension->SrbFlags);
//
// Set up major SCSI function.
//
nextIrpStack->MajorFunction = IRP_MJ_SCSI;
//
// Save SRB address in next stack for port driver.
//
nextIrpStack->Parameters.Scsi.Srb = Srb;
//
// Save retry count in current IRP stack.
//
currentIrpStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;
//
// Set up IoCompletion routine address.
//
IoSetCompletionRoutine(Irp, ClassIoComplete, Srb, TRUE, TRUE, TRUE);
}
/*
* @implemented
*/
NTSTATUS
QuerySuggestedLinkName(IN PUNICODE_STRING SymbolicName,
OUT PUNICODE_STRING SuggestedLinkName,
OUT PBOOLEAN UseOnlyIfThereAreNoOtherLinks)
{
PIRP Irp;
KEVENT Event;
NTSTATUS Status;
USHORT NameLength;
PFILE_OBJECT FileObject;
PDEVICE_OBJECT DeviceObject;
IO_STATUS_BLOCK IoStatusBlock;
PIO_STACK_LOCATION IoStackLocation;
PMOUNTDEV_SUGGESTED_LINK_NAME IoCtlSuggested;
/* First, get device */
Status = IoGetDeviceObjectPointer(SymbolicName,
FILE_READ_ATTRIBUTES,
&FileObject,
&DeviceObject);
if (!NT_SUCCESS(Status))
{
return Status;
}
/* Then, get attached device */
DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
/* Then, prepare buffer to query suggested name */
IoCtlSuggested = AllocatePool(sizeof(MOUNTDEV_SUGGESTED_LINK_NAME));
if (!IoCtlSuggested)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
goto Dereference;
}
/* Prepare request */
KeInitializeEvent(&Event, NotificationEvent, FALSE);
Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME,
DeviceObject,
NULL,
0,
IoCtlSuggested,
sizeof(MOUNTDEV_SUGGESTED_LINK_NAME),
FALSE,
&Event,
&IoStatusBlock);
if (!Irp)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
goto Release;
}
IoStackLocation = IoGetNextIrpStackLocation(Irp);
IoStackLocation->FileObject = FileObject;
/* And ask */
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&Event, Executive, KernelMode,
FALSE, NULL);
Status = IoStatusBlock.Status;
}
/* Overflow? Normal */
if (Status == STATUS_BUFFER_OVERFLOW)
{
/* Reallocate big enough buffer */
NameLength = IoCtlSuggested->NameLength + sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
FreePool(IoCtlSuggested);
IoCtlSuggested = AllocatePool(NameLength);
if (!IoCtlSuggested)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
goto Dereference;
}
/* And reask */
KeInitializeEvent(&Event, NotificationEvent, FALSE);
Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME,
DeviceObject,
NULL,
0,
IoCtlSuggested,
NameLength,
FALSE,
&Event,
&IoStatusBlock);
if (!Irp)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
goto Release;
}
IoStackLocation = IoGetNextIrpStackLocation(Irp);
IoStackLocation->FileObject = FileObject;
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&Event, Executive, KernelMode,
FALSE, NULL);
Status = IoStatusBlock.Status;
}
}
if (!NT_SUCCESS(Status))
{
goto Release;
}
/* Now we have suggested name, copy it */
SuggestedLinkName->Length = IoCtlSuggested->NameLength;
SuggestedLinkName->MaximumLength = IoCtlSuggested->NameLength + sizeof(UNICODE_NULL);
SuggestedLinkName->Buffer = AllocatePool(IoCtlSuggested->NameLength + sizeof(UNICODE_NULL));
if (!SuggestedLinkName->Buffer)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
RtlCopyMemory(SuggestedLinkName->Buffer, IoCtlSuggested->Name, IoCtlSuggested->NameLength);
SuggestedLinkName->Buffer[SuggestedLinkName->Length / sizeof(WCHAR)] = UNICODE_NULL;
}
/* Also return its priority */
*UseOnlyIfThereAreNoOtherLinks = IoCtlSuggested->UseOnlyIfThereAreNoOtherLinks;
Release:
FreePool(IoCtlSuggested);
Dereference:
ObDereferenceObject(DeviceObject);
ObDereferenceObject(FileObject);
return Status;
}
/*++////////////////////////////////////////////////////////////////////////////
ClassIoCompleteAssociated()
Routine Description:
This routine executes when the port driver has completed a request.
It looks at the SRB status in the completing SRB and if not success
it checks for valid request sense buffer information. If valid, the
info is used to update status with more precise message of type of
error. This routine deallocates the SRB. This routine is used for
requests which were build by split request. After it has processed
the request it decrements the Irp count in the master Irp. If the
count goes to zero then the master Irp is completed.
Arguments:
Fdo - Supplies the functional device object which represents the target.
Irp - Supplies the Irp which has completed.
Context - Supplies a pointer to the SRB.
Return Value:
NT status
--*/
NTSTATUS
NTAPI
ClassIoCompleteAssociated(
IN PDEVICE_OBJECT Fdo,
IN PIRP Irp,
IN PVOID Context
)
{
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
PSCSI_REQUEST_BLOCK srb = Context;
PIRP originalIrp = Irp->AssociatedIrp.MasterIrp;
LONG irpCount;
NTSTATUS status;
BOOLEAN retry;
DBGWARN(("ClassIoCompleteAssociated is OBSOLETE !"));
//
// Check SRB status for success of completing request.
//
if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) {
ULONG retryInterval;
DebugPrint((2,"ClassIoCompleteAssociated: IRP %p, SRB %p", Irp, srb));
//
// Release the queue if it is frozen.
//
if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
ClassReleaseQueue(Fdo);
}
retry = ClassInterpretSenseInfo(
Fdo,
srb,
irpStack->MajorFunction,
irpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL ?
irpStack->Parameters.DeviceIoControl.IoControlCode :
0,
MAXIMUM_RETRIES -
((ULONG)(ULONG_PTR)irpStack->Parameters.Others.Argument4),
&status,
&retryInterval);
//
// If the status is verified required and the this request
// should bypass verify required then retry the request.
//
if (irpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME &&
status == STATUS_VERIFY_REQUIRED) {
status = STATUS_IO_DEVICE_ERROR;
retry = TRUE;
}
if (retry && ((*(PCHAR*)&irpStack->Parameters.Others.Argument4)--)) {
//
// Retry request. If the class driver has supplied a StartIo,
// call it directly for retries.
//
DebugPrint((1, "Retry request %p\n", Irp));
if (PORT_ALLOCATED_SENSE(fdoExtension, srb)) {
FREE_PORT_ALLOCATED_SENSE_BUFFER(fdoExtension, srb);
}
RetryRequest(Fdo, Irp, srb, TRUE, retryInterval);
return STATUS_MORE_PROCESSING_REQUIRED;
}
} else {
//
// Set status for successful request.
//
status = STATUS_SUCCESS;
} // end if (SRB_STATUS(srb->SrbStatus) ...
//
// Return SRB to list.
//
if (PORT_ALLOCATED_SENSE(fdoExtension, srb)) {
FREE_PORT_ALLOCATED_SENSE_BUFFER(fdoExtension, srb);
}
ClassFreeOrReuseSrb(fdoExtension, srb);
//
// Set status in completing IRP.
//
Irp->IoStatus.Status = status;
DebugPrint((2, "ClassIoCompleteAssociated: Partial xfer IRP %p\n", Irp));
//
// Get next stack location. This original request is unused
// except to keep track of the completing partial IRPs so the
// stack location is valid.
//
irpStack = IoGetNextIrpStackLocation(originalIrp);
//
// Update status only if error so that if any partial transfer
// completes with error, then the original IRP will return with
// error. If any of the asynchronous partial transfer IRPs fail,
// with an error then the original IRP will return 0 bytes transfered.
// This is an optimization for successful transfers.
//
if (!NT_SUCCESS(status)) {
originalIrp->IoStatus.Status = status;
originalIrp->IoStatus.Information = 0;
//
// Set the hard error if necessary.
//
if (IoIsErrorUserInduced(status)) {
//
// Store DeviceObject for filesystem.
//
IoSetHardErrorOrVerifyDevice(originalIrp, Fdo);
}
}
//
// Decrement and get the count of remaining IRPs.
//
irpCount = InterlockedDecrement(
(PLONG)&irpStack->Parameters.Others.Argument1);
DebugPrint((2, "ClassIoCompleteAssociated: Partial IRPs left %d\n",
irpCount));
//
// Ensure that the irpCount doesn't go negative. This was happening once
// because classpnp would get confused if it ran out of resources when
// splitting the request.
//
ASSERT(irpCount >= 0);
if (irpCount == 0) {
//
// All partial IRPs have completed.
//
DebugPrint((2,
"ClassIoCompleteAssociated: All partial IRPs complete %p\n",
originalIrp));
if (fdoExtension->CommonExtension.DriverExtension->InitData.ClassStartIo) {
//
// Acquire a separate copy of the remove lock so the debugging code
// works okay and we don't have to hold up the completion of this
// irp until after we start the next packet(s).
//
KIRQL oldIrql;
UCHAR uniqueAddress;
ClassAcquireRemoveLock(Fdo, (PIRP)&uniqueAddress);
ClassReleaseRemoveLock(Fdo, originalIrp);
ClassCompleteRequest(Fdo, originalIrp, IO_DISK_INCREMENT);
KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
IoStartNextPacket(Fdo, FALSE);
KeLowerIrql(oldIrql);
ClassReleaseRemoveLock(Fdo, (PIRP)&uniqueAddress);
} else {
//
// just complete this request
//
ClassReleaseRemoveLock(Fdo, originalIrp);
ClassCompleteRequest(Fdo, originalIrp, IO_DISK_INCREMENT);
}
}
//
// Deallocate IRP and indicate the I/O system should not attempt any more
// processing.
//
IoFreeIrp(Irp);
return STATUS_MORE_PROCESSING_REQUIRED;
} // end ClassIoCompleteAssociated()
/*************************************************************************
*
* Function: Ext2MountVolume()
*
* Description:
* This routine is used for performing a verify read...
*
* Expected Interrupt Level (for execution) :
* IRQL_PASSIVE_LEVEL
*
* Arguments:
* TargetDeviceObject - The target of the query
* PartitionInformation - Receives the result of the query
*
* Return Value:
* NTSTATUS - The return status for the operation
*
*************************************************************************/
BOOLEAN Ext2PerformVerifyDiskRead(
IN PDEVICE_OBJECT TargetDeviceObject,
IN PVOID Buffer,
IN LONGLONG Lbo,
IN ULONG NumberOfBytesToRead )
{
KEVENT Event;
PIRP Irp;
LARGE_INTEGER ByteOffset;
NTSTATUS Status;
IO_STATUS_BLOCK Iosb;
//
// Initialize the event we're going to use
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
//
// Build the irp for the operation
//
ByteOffset.QuadPart = Lbo;
Irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ,
TargetDeviceObject,
Buffer,
NumberOfBytesToRead,
&ByteOffset,
&Event,
&Iosb );
if ( Irp == NULL )
{
Status = FALSE;
}
Ext2SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
//
// Call the device to do the read and wait for it to finish.
//
Status = IoCallDriver( TargetDeviceObject, Irp );
if (Status == STATUS_PENDING)
{
(VOID)KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );
Status = Iosb.Status;
}
ASSERT(Status != STATUS_VERIFY_REQUIRED);
//
// Special case this error code because this probably means we used
// the wrong sector size and we want to reject STATUS_WRONG_VOLUME.
//
if (Status == STATUS_INVALID_PARAMETER)
{
DbgPrint("Ext2PerformVerifyDiskRead Invalid Param\n");
return FALSE;
}
if (Status == STATUS_NO_MEDIA_IN_DEVICE)
{
DbgPrint("Ext2PerformVerifyDiskRead NO MEDIA in DEVICE!!! BS!!\n");
return FALSE;
}
//
// If it doesn't succeed then either return or raise the error.
//
if (!NT_SUCCESS(Status))
{
DbgPrint("Ext2PerformVerifyDiskRead Fail Status %x\n",Status);
return FALSE;
}
//
// And return to our caller
//
return TRUE;
}
NTSTATUS
NdFatCommonFlushBuffers (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for flushing a buffer.
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
BOOLEAN VcbAcquired = FALSE;
BOOLEAN FcbAcquired = FALSE;
PDIRENT Dirent;
PBCB DirentBcb = NULL;
PVOLUME_DEVICE_OBJECT volDo = CONTAINING_RECORD( IrpContext->Vcb, VOLUME_DEVICE_OBJECT, Vcb );
BOOLEAN secondarySessionResourceAcquired = FALSE;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
LARGE_INTEGER timeOut;
PAGED_CODE();
IrpSp = IoGetCurrentIrpStackLocation( Irp );
DebugTrace(+1, Dbg, "FatCommonFlushBuffers\n", 0);
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg, "->FileObject = %08lx\n", IrpSp->FileObject);
//
// Extract and decode the file object
//
FileObject = IrpSp->FileObject;
TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
//
// CcFlushCache is always synchronous, so if we can't wait enqueue
// the irp to the Fsp.
//
if ( !FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) ) {
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatCommonFlushBuffers -> %08lx\n", Status );
return Status;
}
Status = STATUS_SUCCESS;
try {
if (!FlagOn(Ccb->NdFatFlags, ND_FAT_CCB_FLAG_UNOPENED)) {
do {
secondarySessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( IrpContext,
&volDo->Secondary->SessionResource,
BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ) {
PrintIrp( Dbg2, "SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED", NULL, IrpContext->OriginatingIrp );
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
secondaryRequest = ALLOC_WINXP_SECONDARY_REQUEST( volDo->Secondary, IRP_MJ_FLUSH_BUFFERS, 0 );
if (secondaryRequest == NULL) {
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
ndfsRequestHeader = &secondaryRequest->NdfsRequestHeader;
INITIALIZE_NDFS_REQUEST_HEADER( ndfsRequestHeader, NDFS_COMMAND_EXECUTE, volDo->Secondary, IRP_MJ_FLUSH_BUFFERS, 0 );
ndfsWinxpRequestHeader = (PNDFS_WINXP_REQUEST_HEADER)(ndfsRequestHeader+1);
ASSERT( ndfsWinxpRequestHeader == (PNDFS_WINXP_REQUEST_HEADER)secondaryRequest->NdfsRequestData );
INITIALIZE_NDFS_WINXP_REQUEST_HEADER( ndfsWinxpRequestHeader,
IrpContext->OriginatingIrp,
IoGetCurrentIrpStackLocation(IrpContext->OriginatingIrp),
Ccb->PrimaryFileHandle );
ASSERT( !ExIsResourceAcquiredSharedLite(&IrpContext->Vcb->Resource) );
secondaryRequest->RequestType = SECONDARY_REQ_SEND_MESSAGE;
QueueingSecondaryRequest( volDo->Secondary, secondaryRequest );
timeOut.QuadPart = -NDFAT_TIME_OUT;
Status = KeWaitForSingleObject( &secondaryRequest->CompleteEvent, Executive, KernelMode, FALSE, &timeOut );
if (Status != STATUS_SUCCESS) {
ASSERT( NDFAT_BUG );
break;
}
KeClearEvent (&secondaryRequest->CompleteEvent);
if (BooleanFlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED)) {
FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
if (secondaryRequest->ExecuteStatus == STATUS_SUCCESS) {
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
ASSERT(ndfsWinxpReplytHeader->Status == STATUS_SUCCESS);
}
if (secondaryRequest) {
DereferenceSecondaryRequest( secondaryRequest );
secondaryRequest = NULL;
}
if ( secondarySessionResourceAcquired == TRUE ) {
SecondaryReleaseResourceLite( IrpContext, &volDo->Secondary->SessionResource );
secondarySessionResourceAcquired = FALSE;
}
break;
} while(0);
}
Status = STATUS_SUCCESS;
//
// Case on the type of open that we are trying to flush
//
switch (TypeOfOpen) {
case VirtualVolumeFile:
case EaFile:
case DirectoryFile:
DebugTrace(0, Dbg, "Flush that does nothing\n", 0);
break;
case UserFileOpen:
DebugTrace(0, Dbg, "Flush User File Open\n", 0);
(VOID)FatAcquireExclusiveFcb( IrpContext, Fcb );
FcbAcquired = TRUE;
FatVerifyFcb( IrpContext, Fcb );
//
// If the file is cached then flush its cache
//
Status = FatFlushFile( IrpContext, Fcb, Flush );
//
// Also update and flush the file's dirent in the parent directory if the
// file flush worked.
//
if (NT_SUCCESS( Status )) {
//
// Insure that we get the filesize to disk correctly. This is
// benign if it was already good.
//
// (why do we need to do this?)
//
SetFlag(FileObject->Flags, FO_FILE_SIZE_CHANGED);
#if 0
FatUpdateDirentFromFcb( IrpContext, FileObject, Fcb, Ccb );
#endif
//
// Flush the volume file to get any allocation information
// updates to disk.
//
if (FlagOn(Fcb->FcbState, FCB_STATE_FLUSH_FAT)) {
Status = FatFlushFat( IrpContext, Vcb );
ClearFlag(Fcb->FcbState, FCB_STATE_FLUSH_FAT);
}
//
// Set the write through bit so that these modifications
// will be completed with the request.
//
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH);
}
break;
case UserDirectoryOpen:
//
// If the user had opened the root directory then we'll
// oblige by flushing the volume.
//
if (NodeType(Fcb) != FAT_NTC_ROOT_DCB) {
DebugTrace(0, Dbg, "Flush a directory does nothing\n", 0);
break;
}
case UserVolumeOpen:
DebugTrace(0, Dbg, "Flush User Volume Open, or root dcb\n", 0);
//
// Acquire exclusive access to the Vcb.
//
{
BOOLEAN Finished;
Finished = FatAcquireExclusiveSecondaryVcb( IrpContext, Vcb );
ASSERT( Finished );
}
VcbAcquired = TRUE;
//
// Mark the volume clean and then flush the volume file,
// and then all directories
//
Status = FatFlushVolume( IrpContext, Vcb, Flush );
//
// If the volume was dirty, do the processing that the delayed
// callback would have done.
//
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY)) {
//
// Cancel any pending clean volumes.
//
(VOID)KeCancelTimer( &Vcb->CleanVolumeTimer );
(VOID)KeRemoveQueueDpc( &Vcb->CleanVolumeDpc );
//
// The volume is now clean, note it.
//
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
FatMarkVolume( IrpContext, Vcb, VolumeClean );
ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY );
}
//
// Unlock the volume if it is removable.
//
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_REMOVABLE_MEDIA) &&
!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_BOOT_OR_PAGING_FILE)) {
FatToggleMediaEjectDisable( IrpContext, Vcb, FALSE );
}
}
break;
default:
FatBugCheck( TypeOfOpen, 0, 0 );
}
FatUnpinBcb( IrpContext, DirentBcb );
FatUnpinRepinnedBcbs( IrpContext );
} finally {
DebugUnwind( FatCommonFlushBuffers );
if (secondaryRequest)
DereferenceSecondaryRequest( secondaryRequest );
if (secondarySessionResourceAcquired) {
SecondaryReleaseResourceLite( IrpContext, &volDo->Secondary->SessionResource );
}
FatUnpinBcb( IrpContext, DirentBcb );
if (VcbAcquired) { FatReleaseSecondaryVcb( IrpContext, Vcb ); }
if (FcbAcquired) { FatReleaseFcb( IrpContext, Fcb ); }
//
// If this is a normal termination then pass the request on
// to the target device object.
//
if (!AbnormalTermination()) {
NTSTATUS DriverStatus;
PIO_STACK_LOCATION NextIrpSp;
//
// Get the next stack location, and copy over the stack location
//
NextIrpSp = IoGetNextIrpStackLocation( Irp );
*NextIrpSp = *IrpSp;
//
// Set up the completion routine
//
IoSetCompletionRoutine( Irp,
FatFlushCompletionRoutine,
ULongToPtr( Status ),
TRUE,
TRUE,
TRUE );
//
// Send the request.
//
DriverStatus = IoCallDriver(Vcb->TargetDeviceObject, Irp);
Status = (DriverStatus == STATUS_INVALID_DEVICE_REQUEST) ?
Status : DriverStatus;
//
// Free the IrpContext and return to the caller.
//
FatCompleteRequest( IrpContext, FatNull, STATUS_SUCCESS );
}
DebugTrace(-1, Dbg, "FatCommonFlushBuffers -> %08lx\n", Status);
}
return Status;
}
NTSTATUS
NdasDluSendIoctlSrbAsynch(
IN PDEVICE_OBJECT DeviceObject,
IN ULONG IoctlCode,
IN PVOID InputBuffer,
IN LONG InputBufferLength,
OUT PVOID OutputBuffer,
IN LONG OutputBufferLength
){
PIRP irp;
PMINISENDSRB_CONTEXT context = NULL;
PSRB_IO_CONTROL psrbIoctl;
PSCSI_REQUEST_BLOCK srb;
LONG srbIoctlLength;
PVOID srbIoctlBuffer;
LONG srbIoctlBufferLength;
NTSTATUS status;
PIO_STACK_LOCATION irpStack;
LARGE_INTEGER startingOffset;
IO_STATUS_BLOCK ioStatusBlock;
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
psrbIoctl = NULL;
irp = NULL;
//
// build an SRB for the miniport
//
srbIoctlBufferLength = (InputBufferLength>OutputBufferLength)?InputBufferLength:OutputBufferLength;
srbIoctlLength = sizeof(SRB_IO_CONTROL) + srbIoctlBufferLength;
context = (PMINISENDSRB_CONTEXT)ExAllocatePoolWithTag(NonPagedPool,
FIELD_OFFSET(MINISENDSRB_CONTEXT, SrbIoctl) + srbIoctlLength,
NDAS_DLU_PTAG_SRB_CMPDATA);
if(context == NULL) {
KDPrint(1, ("STATUS_INSUFFICIENT_RESOURCES\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
context->UserBuffer = OutputBuffer;
context->UserBufferLen = OutputBufferLength;
srb = &context->Srb;
psrbIoctl = &context->SrbIoctl;
RtlZeroMemory(psrbIoctl, srbIoctlLength);
psrbIoctl->HeaderLength = sizeof(SRB_IO_CONTROL);
RtlCopyMemory(psrbIoctl->Signature, NDASSCSI_IOCTL_SIGNATURE, 8);
psrbIoctl->Timeout = 10;
psrbIoctl->ControlCode = IoctlCode;
psrbIoctl->Length = srbIoctlBufferLength;
srbIoctlBuffer = (PUCHAR)psrbIoctl + sizeof(SRB_IO_CONTROL);
RtlCopyMemory(srbIoctlBuffer, InputBuffer, InputBufferLength);
startingOffset.QuadPart = 1;
//
// Build IRP for this request.
// Note we do this synchronously for two reasons. If it was done
// asynchronously then the completion code would have to make a special
// check to deallocate the buffer. Second if a completion routine were
// used then an additional IRP stack location would be needed.
//
irp = IoBuildAsynchronousFsdRequest(
IRP_MJ_SCSI,
DeviceObject,
psrbIoctl,
srbIoctlLength,
&startingOffset,
&ioStatusBlock);
context->Irp = irp;
IoSetCompletionRoutine(irp, NdasDluSendSrbIoCompletion, context, TRUE, TRUE, TRUE);
irpStack = IoGetNextIrpStackLocation(irp);
if (irp == NULL) {
KDPrint(1,("STATUS_INSUFFICIENT_RESOURCES\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
//
// Set major and minor codes.
//
irpStack->MajorFunction = IRP_MJ_SCSI;
irpStack->MinorFunction = 1;
//
// Fill in SRB fields.
//
irpStack->Parameters.Others.Argument1 = srb;
//
// Zero out the srb.
//
RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
srb->PathId = 0;
srb->TargetId = 0;
srb->Lun = 0;
srb->Function = SRB_FUNCTION_IO_CONTROL;
srb->Length = sizeof(SCSI_REQUEST_BLOCK);
srb->SrbFlags = SRB_FLAGS_DATA_OUT | SRB_FLAGS_NO_QUEUE_FREEZE;
srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
srb->QueueTag = SP_UNTAGGED;
srb->OriginalRequest = irp;
//
// Set timeout to requested value.
//
srb->TimeOutValue = psrbIoctl->Timeout;
//
// Set the data buffer.
//
srb->DataBuffer = psrbIoctl;
srb->DataTransferLength = srbIoctlLength;
//
// Flush the data buffer for output. This will insure that the data is
// written back to memory. Since the data-in flag is the the port driver
// will flush the data again for input which will ensure the data is not
// in the cache.
//
/*
KeFlushIoBuffers(irp->MdlAddress, FALSE, TRUE);
*/
status = IoCallDriver( DeviceObject, irp );
return status;
cleanup:
if(context)
ExFreePool(context);
return status;
}
static FORCEINLINE NTSTATUS
__DriverQueryId(
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN BUS_QUERY_ID_TYPE IdType,
OUT PVOID *Information
)
{
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
KEVENT Event;
PIO_STACK_LOCATION StackLocation;
NTSTATUS status;
ASSERT3U(KeGetCurrentIrql(), ==, PASSIVE_LEVEL);
DeviceObject = IoGetAttachedDeviceReference(PhysicalDeviceObject);
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
status = STATUS_INSUFFICIENT_RESOURCES;
if (Irp == NULL)
goto fail1;
StackLocation = IoGetNextIrpStackLocation(Irp);
StackLocation->MajorFunction = IRP_MJ_PNP;
StackLocation->MinorFunction = IRP_MN_QUERY_ID;
StackLocation->Flags = 0;
StackLocation->Parameters.QueryId.IdType = IdType;
StackLocation->DeviceObject = DeviceObject;
StackLocation->FileObject = NULL;
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoSetCompletionRoutine(Irp,
DriverQueryIdCompletion,
&Event,
TRUE,
TRUE,
TRUE);
// Default completion status
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
status = IoCallDriver(DeviceObject, Irp);
if (status == STATUS_PENDING) {
(VOID) KeWaitForSingleObject(&Event,
Executive,
KernelMode,
FALSE,
NULL);
status = Irp->IoStatus.Status;
} else {
ASSERT3U(status, ==, Irp->IoStatus.Status);
}
if (!NT_SUCCESS(status))
goto fail2;
*Information = (PVOID)Irp->IoStatus.Information;
IoFreeIrp(Irp);
ObDereferenceObject(DeviceObject);
return STATUS_SUCCESS;
fail2:
Error("fail2\n");
IoFreeIrp(Irp);
fail1:
Error("fail1 (%08x)\n", status);
ObDereferenceObject(DeviceObject);
return status;
}