PTRANSFER_PACKET NewTransferPacket(PDEVICE_OBJECT Fdo)
{
PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
PTRANSFER_PACKET newPkt;
newPkt = ExAllocatePoolWithTag(NonPagedPool, sizeof(TRANSFER_PACKET), 'pnPC');
if (newPkt){
RtlZeroMemory(newPkt, sizeof(TRANSFER_PACKET)); // just to be sure
/*
* Allocate resources for the packet.
*/
newPkt->Irp = IoAllocateIrp(Fdo->StackSize, FALSE);
if (newPkt->Irp){
KIRQL oldIrql;
newPkt->Fdo = Fdo;
/*
* Enqueue the packet in our static AllTransferPacketsList
* (just so we can find it during debugging if its stuck somewhere).
*/
KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
InsertTailList(&fdoData->AllTransferPacketsList, &newPkt->AllPktsListEntry);
KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
}
else {
ExFreePool(newPkt);
newPkt = NULL;
}
}
return newPkt;
}
NTSTATUS
disconnectfromserver(PWSK_SOCKET sock)
{
NTSTATUS status;
KEVENT event;
PIRP irp;
irp = IoAllocateIrp(1, FALSE);
if(!irp){
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent(&event, NotificationEvent, FALSE);
IoSetCompletionRoutine(irp, disconnectcomplete, &event, TRUE, TRUE,
TRUE);
status = ((PWSK_PROVIDER_CONNECTION_DISPATCH)(sock->Dispatch))->
WskCloseSocket(sock, irp);
if(status == STATUS_PENDING){
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = irp->IoStatus.Status;
}
IoFreeIrp(irp);
return status;
}
VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDeviceSpeed(PDEVICE_OBJECT pDevObj, BOOLEAN *pbIsHigh)
{
Assert(pbIsHigh);
*pbIsHigh = FALSE;
PIRP pIrp = IoAllocateIrp(pDevObj->StackSize, FALSE);
Assert(pIrp);
if (!pIrp)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
USB_BUS_INTERFACE_USBDI_V1 BusIf;
PIO_STACK_LOCATION pSl = IoGetNextIrpStackLocation(pIrp);
pSl->MajorFunction = IRP_MJ_PNP;
pSl->MinorFunction = IRP_MN_QUERY_INTERFACE;
pSl->Parameters.QueryInterface.InterfaceType = &USB_BUS_INTERFACE_USBDI_GUID;
pSl->Parameters.QueryInterface.Size = sizeof (BusIf);
pSl->Parameters.QueryInterface.Version = USB_BUSIF_USBDI_VERSION_1;
pSl->Parameters.QueryInterface.Interface = (PINTERFACE)&BusIf;
pSl->Parameters.QueryInterface.InterfaceSpecificData = NULL;
pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
NTSTATUS Status = VBoxDrvToolIoPostSync(pDevObj, pIrp);
Assert(NT_SUCCESS(Status) || Status == STATUS_NOT_SUPPORTED);
if (NT_SUCCESS(Status))
{
*pbIsHigh = BusIf.IsDeviceHighSpeed(BusIf.BusContext);
BusIf.InterfaceDereference(BusIf.BusContext);
}
IoFreeIrp(pIrp);
return Status;
}
NTSTATUS
WaitForUsbDeviceArrivalNotification(PDEVICE_OBJECT DeviceObject)
{
PURB Urb;
PIRP Irp;
NTSTATUS Status;
PIO_STACK_LOCATION Stack = NULL;
PHUB_DEVICE_EXTENSION DeviceExtension;
DeviceExtension = (PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
Urb = &DeviceExtension->Urb;
RtlZeroMemory(Urb, sizeof(URB));
/* Send URB to the miniports Status Change Endpoint SCE */
UsbBuildInterruptOrBulkTransferRequest(Urb,
sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER),
DeviceExtension->PipeHandle,
&DeviceExtension->PortStatus,
NULL,
sizeof(ULONG) * 2,
USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK,
NULL);
Urb->UrbHeader.UsbdDeviceHandle = DeviceExtension->RootHubUsbDevice;
Irp = IoAllocateIrp(DeviceExtension->RootHubPdo->StackSize, FALSE);
if (Irp == NULL)
{
DPRINT("Usbhub: IoBuildDeviceIoControlRequest() failed\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
Irp->IoStatus.Information = 0;
Irp->Flags = 0;
Irp->UserBuffer = NULL;
Stack = IoGetCurrentIrpStackLocation(Irp);
Stack->DeviceObject = DeviceExtension->RootHubPdo;
Stack = IoGetNextIrpStackLocation(Irp);
Stack->DeviceObject = DeviceExtension->RootHubPdo;
Stack->Parameters.Others.Argument1 = Urb;
Stack->Parameters.Others.Argument2 = NULL;
Stack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
Stack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
//IoSetCompletionRoutineEx(DeviceExtension->RootHubPdo, Irp, (PIO_COMPLETION_ROUTINE)DeviceArrivalCompletion, DeviceObject, TRUE, TRUE, TRUE);
IoSetCompletionRoutine(Irp, (PIO_COMPLETION_ROUTINE)DeviceArrivalCompletion, DeviceObject, TRUE, TRUE, TRUE);
Status = IoCallDriver(DeviceExtension->RootHubPdo, Irp);
DPRINT1("SCE request status %x\n", Status);
return STATUS_PENDING;
}
NTSTATUS
AsyncReadWriteSec(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP ParentIrp,
IN ULONG ulStartSec,
IN ULONG ulSectors,
IN PVOID pBuffer,
IN UCHAR MajorFunction
)
{
PMDL MDL;
KEVENT event;
PIRP Irp;
ULONG ulBytes;
LARGE_INTEGER Start;
IO_STATUS_BLOCK ioStatus;
NTSTATUS status = STATUS_SUCCESS;
PIO_STACK_LOCATION NextIrpStack;
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
ulBytes = ulSectors * SECTOR_SIZE;
Start.QuadPart = ((LONGLONG)ulStartSec)*SECTOR_SIZE;
Irp = IoAllocateIrp(LOBYTE(LOWORD(deviceExtension->TargetDeviceObject->StackSize+1)),FALSE);
//Irp = IoBuildSynchronousFsdRequest( MajorFunction,
// deviceExtension->TargetDeviceObject,
// pBuffer,ulBytes,
// &Start,&event,
// &ioStatus );
ASSERT(Irp);
if (!Irp)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
MDL = IoAllocateMdl(pBuffer,ulBytes,FALSE,FALSE,Irp);
if (!MDL)
return STATUS_INSUFFICIENT_RESOURCES;
MmBuildMdlForNonPagedPool(MDL);
IoSetNextIrpStackLocation(Irp);
NextIrpStack = IoGetNextIrpStackLocation(Irp);
NextIrpStack->DeviceObject = deviceExtension->TargetDeviceObject;
NextIrpStack->MajorFunction = MajorFunction;
NextIrpStack->MinorFunction = 0;
NextIrpStack->Parameters.Read.Length = ulBytes;
NextIrpStack->Parameters.Read.Key = 0;
NextIrpStack->Parameters.Read.ByteOffset.QuadPart = Start.QuadPart;
RtlCopyMemory(&(NextIrpStack->Parameters.Write),&(NextIrpStack->Parameters.Read),sizeof(NextIrpStack->Parameters.Read));
IoSetCompletionRoutine(Irp,AsyncCompletion,ParentIrp,TRUE,TRUE,TRUE);
status = IoCallDriver(deviceExtension->TargetDeviceObject,Irp);
return status;
} // end SyncReadWriteSec()
static NTSTATUS EvhdInitialize(HANDLE hFileHandle, PFILE_OBJECT pFileObject, ParserInstance *parser)
{
NTSTATUS status = STATUS_SUCCESS;
parser->pVhdmpFileObject = pFileObject;
parser->FileHandle = hFileHandle;
/* Initialize Direct IO */
parser->pDirectIoIrp = IoAllocateIrp(IoGetRelatedDeviceObject(parser->pVhdmpFileObject)->StackSize, FALSE);
if (!parser->pDirectIoIrp)
{
LOG_PARSER(LL_FATAL, "IoAllocateIrp failed\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
/* Initialize QoS */
parser->pQoSStatusIrp = IoAllocateIrp(IoGetRelatedDeviceObject(parser->pVhdmpFileObject)->StackSize, FALSE);
if (!parser->pQoSStatusIrp)
{
LOG_PARSER(LL_FATAL, "IoAllocateIrp failed\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
parser->pQoSStatusBuffer = ExAllocatePoolWithTag(NonPagedPoolNx, QoSBufferSize, EvhdQoSPoolTag);
if (!parser->pQoSStatusBuffer)
{
LOG_PARSER(LL_FATAL, "ExAllocatePoolWithTag failed\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
/* Initialize CTL */
ExInitializeRundownProtection(&parser->RecoveryRundownProtection);
parser->pRecoveryStatusIrp = IoAllocateIrp(IoGetRelatedDeviceObject(parser->pVhdmpFileObject)->StackSize, FALSE);
if (!parser->pRecoveryStatusIrp)
{
LOG_PARSER(LL_FATAL, "IoAllocateIrp failed\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
parser->FileHandle = hFileHandle;
parser->pVhdmpFileObject = pFileObject;
return status;
}
_Must_inspect_result_
FORCEINLINE
MdIrp
FxIrp::AllocateIrp(
_In_ CCHAR StackSize,
_In_opt_ FxDevice* Device
)
{
UNREFERENCED_PARAMETER(Device);
return IoAllocateIrp(StackSize, FALSE);
}
static NTSTATUS
XenM2BPdoDeviceUsageNotification(PXENM2B_PDO_EXTENSION pPdoExt,
PIRP pIrp)
{
PDEVICE_OBJECT pDeviceObject;
PIO_STACK_LOCATION pIrpStack;
PIRP pSubIrp;
PIO_STACK_LOCATION pSubIrpStack;
NTSTATUS Status;
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
// Find the top of the FDO stack and hold a reference
pDeviceObject = IoGetAttachedDeviceReference(pPdoExt->pFdo);
// Get a new IRP for the FDO stack and reserve an extra stack location
// for our use here.
pSubIrp = IoAllocateIrp(pDeviceObject->StackSize + 1, FALSE);
if (pSubIrp == NULL)
return STATUS_INSUFFICIENT_RESOURCES;
// Fill in the first stack location with our context information
// which we'll need to complete the original IRP.
pSubIrpStack = IoGetNextIrpStackLocation(pSubIrp);
pSubIrpStack->DeviceObject = pDeviceObject;
pSubIrpStack->Parameters.Others.Argument1 = (PVOID)pIrp;
// Advance the stack location, copy in the information from the
// original IRP and set up our completion routine.
IoSetNextIrpStackLocation(pSubIrp);
pSubIrpStack = IoGetNextIrpStackLocation(pSubIrp);
RtlCopyMemory(pSubIrpStack,
pIrpStack,
FIELD_OFFSET(IO_STACK_LOCATION, CompletionRoutine));
pSubIrpStack->Control = 0;
IoSetCompletionRoutine(pSubIrp,
XenM2BPdoDeviceUsageCompletion,
NULL,
TRUE,
TRUE,
TRUE);
// Default completion status
pSubIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
IoMarkIrpPending(pIrp);
IoCallDriver(pDeviceObject, pSubIrp);
return STATUS_PENDING;
}
PIRP mm_allocate_irp_success(CCHAR StackSize)
{
PIRP irp;
int timeout;
for (timeout = DC_MEM_RETRY_TIMEOUT; timeout > 0; timeout -= DC_MEM_RETRY_TIME)
{
if (irp = IoAllocateIrp(StackSize, FALSE)) break;
if (KeGetCurrentIrql() >= DISPATCH_LEVEL) break;
dc_delay(DC_MEM_RETRY_TIME);
}
return irp;
}
static
FORCEINLINE
PIRP
xTdiBuildInternalIrp(
__in PDEVICE_OBJECT ConnectionDeviceObject,
__in PFILE_OBJECT ConnectionFileObject,
__in PKEVENT Event,
__in PIO_STATUS_BLOCK IoStatus)
{
PIRP irp = IoAllocateIrp(ConnectionDeviceObject->StackSize + 1, FALSE);
irp->UserEvent = Event;
irp->UserIosb = IoStatus;
return irp;
}
NTSTATUS
IrpQueryFile(
IN PFILE_OBJECT FileObject,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass
)
{
NTSTATUS status;
KEVENT event;
PIRP irp;
IO_STATUS_BLOCK ioStatus;
PIO_STACK_LOCATION irpSp;
PDEVICE_OBJECT deviceObject;
if (FileObject->Vpb == 0 || FileObject->Vpb->RealDevice == NULL)
return STATUS_UNSUCCESSFUL;
deviceObject = FileObject->Vpb->DeviceObject;
KeInitializeEvent(&event, SynchronizationEvent, FALSE);
irp = IoAllocateIrp(deviceObject->StackSize, FALSE);
if (irp == NULL)
return STATUS_INSUFFICIENT_RESOURCES;
irp->Flags = IRP_BUFFERED_IO;
irp->AssociatedIrp.SystemBuffer = FileInformation;
irp->RequestorMode = KernelMode;
irp->Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)NULL;
irp->UserEvent = &event;
irp->UserIosb = &ioStatus;
irp->Tail.Overlay.Thread = (PETHREAD)KeGetCurrentThread();
irp->Tail.Overlay.OriginalFileObject = FileObject;
irpSp = IoGetNextIrpStackLocation(irp);
irpSp->MajorFunction = IRP_MJ_QUERY_INFORMATION;
irpSp->DeviceObject = deviceObject;
irpSp->FileObject = FileObject;
irpSp->Parameters.QueryFile.Length = Length;
irpSp->Parameters.QueryFile.FileInformationClass = FileInformationClass;
IoSetCompletionRoutine(irp, IoCompletionRoutine, NULL, TRUE, TRUE, TRUE);
status = IoCallDriver(deviceObject, irp);
if (status == STATUS_PENDING)
KeWaitForSingleObject(&event, Executive, KernelMode, TRUE, NULL);
return ioStatus.Status;
}
NTSTATUS FspIopPostWorkRequestFunnel(PDEVICE_OBJECT DeviceObject,
FSP_FSCTL_TRANSACT_REQ *Request, BOOLEAN BestEffort)
{
PAGED_CODE();
ASSERT(0 == Request->Hint);
NTSTATUS Result;
PIRP Irp;
if (BestEffort)
Irp = FspAllocateIrpMustSucceed(DeviceObject->StackSize);
else
{
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
if (0 == Irp)
{
Result = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
}
PIO_STACK_LOCATION IrpSp = IoGetNextIrpStackLocation(Irp);
Irp->RequestorMode = KernelMode;
IrpSp->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;
IrpSp->MinorFunction = IRP_MN_USER_FS_REQUEST;
IrpSp->Parameters.FileSystemControl.FsControlCode = BestEffort ?
FSP_FSCTL_WORK_BEST_EFFORT : FSP_FSCTL_WORK;
IrpSp->Parameters.FileSystemControl.InputBufferLength = Request->Size;
IrpSp->Parameters.FileSystemControl.Type3InputBuffer = Request;
ASSERT(METHOD_NEITHER == (IrpSp->Parameters.DeviceIoControl.IoControlCode & 3));
IoSetCompletionRoutine(Irp, FspIopPostWorkRequestCompletion, 0, TRUE, TRUE, TRUE);
Result = IoCallDriver(DeviceObject, Irp);
if (STATUS_PENDING == Result)
return STATUS_SUCCESS;
/*
* If we did not receive STATUS_PENDING, we still own the Request and must delete it!
*/
exit:
FspIopDeleteRequest(Request);
return Result;
}
NTSTATUS
IrpQueryDirectoryFile(
IN PFILE_OBJECT FileObject,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass,
IN PUNICODE_STRING FileName OPTIONAL)
{
NTSTATUS ntStatus;
PIRP Irp;
KEVENT kEvent;
PIO_STACK_LOCATION IrpSp;
if (FileObject->Vpb == 0 || FileObject->Vpb->DeviceObject == NULL)
return STATUS_UNSUCCESSFUL;
Irp = IoAllocateIrp(FileObject->Vpb->DeviceObject->StackSize, FALSE);
if(Irp == NULL) return STATUS_INSUFFICIENT_RESOURCES;
KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
RtlZeroMemory(FileInformation, Length);
Irp->UserEvent = &kEvent;
Irp->UserIosb = IoStatusBlock;
Irp->UserBuffer = FileInformation;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
Irp->Tail.Overlay.OriginalFileObject = FileObject;
Irp->Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)NULL;
IrpSp = IoGetNextIrpStackLocation(Irp);
IrpSp->MajorFunction = IRP_MJ_DIRECTORY_CONTROL;
IrpSp->MinorFunction = IRP_MN_QUERY_DIRECTORY;
IrpSp->FileObject = FileObject;
IrpSp->Flags = SL_RESTART_SCAN;
IrpSp->Parameters.QueryDirectory.Length = Length;
IrpSp->Parameters.QueryDirectory.FileName = FileName;
IrpSp->Parameters.QueryDirectory.FileInformationClass = FileInformationClass;
IoSetCompletionRoutine(Irp, IoCompletionRoutine, 0, TRUE, TRUE, TRUE);
ntStatus = IoCallDriver(FileObject->Vpb->DeviceObject, Irp);
if (ntStatus == STATUS_PENDING)
KeWaitForSingleObject(&kEvent, Executive, KernelMode, TRUE, 0);
return IoStatusBlock->Status;
}
NTSTATUS CIrp::Create(PDEVICE_OBJECT TargetDevice)
{
ASSERT(m_TargetDevice == nullptr);
ASSERT(m_Irp == nullptr);
m_Irp = IoAllocateIrp(TargetDevice->StackSize, FALSE);
if (m_Irp == nullptr)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
m_Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
ObReferenceObject(TargetDevice);
m_TargetDevice = TargetDevice;
return STATUS_SUCCESS;
}
PVOID FspAllocateIrpMustSucceed(CCHAR StackSize)
{
// !PAGED_CODE();
PIRP Result;
LARGE_INTEGER Delay;
for (ULONG i = 0, n = sizeof(Delays) / sizeof(Delays[0]);; i++)
{
Result = DEBUGTEST(99) ? IoAllocateIrp(StackSize, FALSE) : 0;
if (0 != Result)
return Result;
Delay.QuadPart = n > i ? Delays[i] : Delays[n - 1];
KeDelayExecutionThread(KernelMode, FALSE, &Delay);
}
}
NTSTATUS
IrpSetInformationFile(
IN PFILE_OBJECT FileObject,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass,
IN BOOLEAN ReplaceIfExists)
{
NTSTATUS ntStatus;
PIRP Irp;
KEVENT kEvent;
PIO_STACK_LOCATION IrpSp;
if (FileObject->Vpb == 0 || FileObject->Vpb->DeviceObject == NULL)
return STATUS_UNSUCCESSFUL;
Irp = IoAllocateIrp(FileObject->Vpb->DeviceObject->StackSize, FALSE);
if(Irp == NULL) return STATUS_INSUFFICIENT_RESOURCES;
KeInitializeEvent(&kEvent, SynchronizationEvent, FALSE);
Irp->AssociatedIrp.SystemBuffer = FileInformation;
Irp->UserEvent = &kEvent;
Irp->UserIosb = IoStatusBlock;
Irp->RequestorMode = KernelMode;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
Irp->Tail.Overlay.OriginalFileObject = FileObject;
IrpSp = IoGetNextIrpStackLocation(Irp);
IrpSp->MajorFunction = IRP_MJ_SET_INFORMATION;
IrpSp->DeviceObject = FileObject->Vpb->DeviceObject;
IrpSp->FileObject = FileObject;
IrpSp->Parameters.SetFile.ReplaceIfExists = ReplaceIfExists;
IrpSp->Parameters.SetFile.FileObject = FileObject;
IrpSp->Parameters.SetFile.AdvanceOnly = FALSE;
IrpSp->Parameters.SetFile.Length = Length;
IrpSp->Parameters.SetFile.FileInformationClass = FileInformationClass;
IoSetCompletionRoutine(Irp, IoCompletionRoutine, 0, TRUE, TRUE, TRUE);
ntStatus = IoCallDriver(FileObject->Vpb->DeviceObject, Irp);
if (ntStatus == STATUS_PENDING)
KeWaitForSingleObject(&kEvent, Executive, KernelMode, TRUE, 0);
return IoStatusBlock->Status;
}
NTSTATUS say_hello(PDEVICE_OBJECT deviceObject) {
NTSTATUS status = STATUS_SUCCESS;
DbgPrint("Say Hello to 0x%08X\n", deviceObject);
PIRP myIrp = IoAllocateIrp(deviceObject->StackSize, FALSE);
if (!myIrp) {
DbgPrint("Cannot allocate Irp\n");
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
PIO_STACK_LOCATION pMyIoStackLocation = IoGetNextIrpStackLocation(myIrp);
if (!pMyIoStackLocation) {
DbgPrint("No stack location\n");
status = STATUS_UNSUCCESSFUL;
goto cleanup;
}
pMyIoStackLocation->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
pMyIoStackLocation->Parameters.DeviceIoControl.IoControlCode = MY_INTERNAL_IOCTL_HELLO;
char buffer[BUFFER_SIZE] = "Hello you!";
pMyIoStackLocation->Parameters.DeviceIoControl.InputBufferLength = BUFFER_SIZE;
pMyIoStackLocation->Parameters.DeviceIoControl.OutputBufferLength = BUFFER_SIZE;
myIrp->AssociatedIrp.SystemBuffer = buffer;
myIrp->MdlAddress = NULL;
IoSetCompletionRoutine(myIrp, my_completion_routine, NULL, TRUE, TRUE, TRUE);
status = IoCallDriver(deviceObject, myIrp);
if (status != STATUS_SUCCESS) {
DbgPrint("Error while calling the other driver\n");
goto cleanup;
}
DbgPrint("The other one says: %s\n", myIrp->AssociatedIrp.SystemBuffer);
cleanup:
if (myIrp) {
IoFreeIrp(myIrp);
}
return status;
}
NTSTATUS EVhdPrepareMetaOperation(ParserInstance *parser, MetaOperationBuffer *pBuffer, MetaOperationCompletionRoutine pfnCompletionCb, void *pInterface, MetaOperation **ppOperation)
{
MetaOperation *pOperation = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(MetaOperation), EvhdPoolTag);
if (!pOperation)
return STATUS_INSUFFICIENT_RESOURCES;
pOperation->pfnCompletionRoutine = pfnCompletionCb;
pOperation->pParser = parser;
pOperation->pInterface = pInterface;
pOperation->pIrp = IoAllocateIrp(IoGetRelatedDeviceObject(parser->pVhdmpFileObject)->StackSize, FALSE);
pOperation->pBuffer = pBuffer;
if (!pOperation->pIrp)
{
EVhdCleanupMetaOperation(pOperation);
return STATUS_INSUFFICIENT_RESOURCES;
}
*ppOperation = pOperation;
return STATUS_SUCCESS;
}
NTSTATUS
LspDataInitialize(
__in PDEVICE_OBJECT DeviceObject,
__in PDEVICE_OBJECT ConnectionDeviceObject,
__inout PLSP_TRANSFER_DATA LspTransferData)
{
RtlZeroMemory(LspTransferData, sizeof(LSP_TRANSFER_DATA));
LspTransferData->Irp = IoAllocateIrp(
ConnectionDeviceObject->StackSize + 1,
FALSE);
if (NULL == LspTransferData->Irp)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
LspTransferData->Overlapped.CompletionRoutine = LspTransferCompletion;
LspTransferData->Overlapped.UserContext = DeviceObject;
return STATUS_SUCCESS;
}
NTSTATUS
InitWskData(
__out PIRP* pIrp,
__out PKEVENT CompletionEvent
)
{
ASSERT(pIrp);
ASSERT(CompletionEvent);
*pIrp = IoAllocateIrp(1, FALSE);
if (!*pIrp)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent(CompletionEvent, SynchronizationEvent, FALSE);
IoSetCompletionRoutine(*pIrp, CompletionRoutine, CompletionEvent, TRUE, TRUE, TRUE);
return STATUS_SUCCESS;
}
VBOXUSBTOOL_DECL(PIRP) VBoxUsbToolIoBuildAsyncInternalCtl(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2)
{
PIRP pIrp = IoAllocateIrp(pDevObj->StackSize, FALSE);
Assert(pIrp);
if (!pIrp)
{
return NULL;
}
pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = NULL;
PIO_STACK_LOCATION pSl = IoGetNextIrpStackLocation(pIrp);
pSl->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
pSl->MinorFunction = 0;
pSl->Parameters.DeviceIoControl.IoControlCode = uCtl;
pSl->Parameters.Others.Argument1 = pvArg1;
pSl->Parameters.Others.Argument2 = pvArg2;
return pIrp;
}
NTSTATUS FspSendQueryEaIrp(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
PFILE_GET_EA_INFORMATION GetEa, ULONG GetEaLength,
PFILE_FULL_EA_INFORMATION Ea, PULONG PEaLength)
{
PAGED_CODE();
NTSTATUS Result;
PIRP Irp;
PIO_STACK_LOCATION IrpSp;
FSP_SEND_IRP_CONTEXT Context;
ULONG EaLength = *PEaLength;
*PEaLength = 0;
if (0 == DeviceObject)
DeviceObject = IoGetRelatedDeviceObject(FileObject);
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
if (0 == Irp)
return STATUS_INSUFFICIENT_RESOURCES;
IrpSp = IoGetNextIrpStackLocation(Irp);
Irp->RequestorMode = KernelMode;
Irp->AssociatedIrp.SystemBuffer = Ea;
Irp->UserBuffer = Ea;
IrpSp->MajorFunction = IRP_MJ_QUERY_EA;
IrpSp->FileObject = FileObject;
IrpSp->Parameters.QueryEa.Length = EaLength;
IrpSp->Parameters.QueryEa.EaList = GetEa;
IrpSp->Parameters.QueryEa.EaListLength = GetEaLength;
IoSetCompletionRoutine(Irp, FspSendIrpCompletion, &Context, TRUE, TRUE, TRUE);
KeInitializeEvent(&Context.Event, NotificationEvent, FALSE);
Result = IoCallDriver(DeviceObject, Irp);
if (STATUS_PENDING == Result)
KeWaitForSingleObject(&Context.Event, Executive, KernelMode, FALSE, 0);
*PEaLength = (ULONG)Context.IoStatus.Information;
return Context.IoStatus.Status;
}
NTSTATUS FspSendSetInformationIrp(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
FILE_INFORMATION_CLASS FileInformationClass, PVOID FileInformation, ULONG Length)
{
PAGED_CODE();
ASSERT(
FileAllocationInformation == FileInformationClass ||
FileEndOfFileInformation == FileInformationClass);
NTSTATUS Result;
PIRP Irp;
PIO_STACK_LOCATION IrpSp;
FSP_SEND_IRP_CONTEXT Context;
if (0 == DeviceObject)
DeviceObject = IoGetRelatedDeviceObject(FileObject);
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
if (0 == Irp)
return STATUS_INSUFFICIENT_RESOURCES;
IrpSp = IoGetNextIrpStackLocation(Irp);
Irp->RequestorMode = KernelMode;
Irp->AssociatedIrp.SystemBuffer = FileInformation;
IrpSp->MajorFunction = IRP_MJ_SET_INFORMATION;
IrpSp->FileObject = FileObject;
IrpSp->Parameters.SetFile.FileInformationClass = FileInformationClass;
IrpSp->Parameters.SetFile.Length = Length;
IoSetCompletionRoutine(Irp, FspSendIrpCompletion, &Context, TRUE, TRUE, TRUE);
KeInitializeEvent(&Context.Event, NotificationEvent, FALSE);
Result = IoCallDriver(DeviceObject, Irp);
if (STATUS_PENDING == Result)
KeWaitForSingleObject(&Context.Event, Executive, KernelMode, FALSE, 0);
return Context.IoStatus.Status;
}
NTSTATUS
senddata(PWSK_SOCKET sock, PVOID data, ULONG datal)
{
WSK_BUF wskbuf;
NTSTATUS status;
KEVENT event;
PIRP irp;
irp = IoAllocateIrp(1, FALSE);
if(!irp){
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent(&event, NotificationEvent, FALSE);
IoSetCompletionRoutine(irp, senddatacomplete, &event, TRUE, TRUE, TRUE);
wskbuf.Mdl = IoAllocateMdl(data, datal, FALSE, FALSE, NULL);
if(!wskbuf.Mdl){
DbgPrint("Failed to allocate MDL!\n");
return STATUS_MORE_PROCESSING_REQUIRED;
}
MmBuildMdlForNonPagedPool(wskbuf.Mdl);
wskbuf.Offset = 0;
wskbuf.Length = datal;
status = ((PWSK_PROVIDER_CONNECTION_DISPATCH)(sock->Dispatch))->WskSend(sock, &wskbuf, 0, irp);
if(status == STATUS_PENDING){
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = irp->IoStatus.Status;
}
IoFreeIrp(irp);
return status;
}
static
NTSTATUS
InitWskData(
OUT PIRP* pIrp,
OUT PKEVENT CompletionEvent
)
{
ASSERT(pIrp);
ASSERT(CompletionEvent);
TRACE_ENTER();
*pIrp = IoAllocateIrp(1, FALSE);
if (!*pIrp)
{
TRACE_MESSAGE1(PACKET_DEBUG_LOUD, "InitWskData()::IoAllocateIrp() failed with status 0x%08X\n", STATUS_INSUFFICIENT_RESOURCES);
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent(CompletionEvent, SynchronizationEvent, FALSE);
IoSetCompletionRoutine(*pIrp, CompletionRoutine, CompletionEvent, TRUE, TRUE, TRUE);
TRACE_EXIT();
return STATUS_SUCCESS;
}
static NTSTATUS callparport(struct eppflexfile *fs, unsigned long ioctlcode,
void *buffer, unsigned int inlen, unsigned int outlen,
LARGE_INTEGER *timeout)
{
NTSTATUS status;
PIRP irp;
PIO_STACK_LOCATION irpsp;
KEVENT event;
irp = IoAllocateIrp((CCHAR)(fs->pdo->StackSize+1), FALSE);
if (!irp)
return STATUS_INSUFFICIENT_RESOURCES;
irpsp = IoGetNextIrpStackLocation(irp);
irpsp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
irpsp->Parameters.DeviceIoControl.OutputBufferLength = outlen;
irpsp->Parameters.DeviceIoControl.InputBufferLength = inlen;
irpsp->Parameters.DeviceIoControl.IoControlCode = ioctlcode;
irp->AssociatedIrp.SystemBuffer = buffer;
KeInitializeEvent(&event, NotificationEvent, FALSE);
IoSetCompletionRoutine(irp, parcompletion, &event, TRUE, TRUE, TRUE);
status = IoCallDriver(fs->pdo, irp);
if (!NT_SUCCESS(status)) {
IoFreeIrp(irp);
return status;
}
status = KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, timeout);
if (status == STATUS_TIMEOUT) {
IoCancelIrp(irp);
status = KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
}
status = irp->IoStatus.Status;
IoFreeIrp(irp);
return status;
}
NTSTATUS
VfatWriteDiskPartial(
IN PVFAT_IRP_CONTEXT IrpContext,
IN PLARGE_INTEGER WriteOffset,
IN ULONG WriteLength,
IN ULONG BufferOffset,
IN BOOLEAN Wait)
{
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
NTSTATUS Status;
PVOID Buffer;
DPRINT("VfatWriteDiskPartial(IrpContext %p, WriteOffset %I64x, WriteLength %u, BufferOffset %x, Wait %u)\n",
IrpContext, WriteOffset->QuadPart, WriteLength, BufferOffset, Wait);
Buffer = (PCHAR)MmGetMdlVirtualAddress(IrpContext->Irp->MdlAddress) + BufferOffset;
again:
DPRINT("Building asynchronous FSD Request...\n");
Irp = IoAllocateIrp(IrpContext->DeviceExt->StorageDevice->StackSize, TRUE);
if (Irp == NULL)
{
DPRINT("IoAllocateIrp failed\n");
return STATUS_UNSUCCESSFUL;
}
Irp->UserIosb = NULL;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->MajorFunction = IRP_MJ_WRITE;
StackPtr->MinorFunction = 0;
StackPtr->Flags = 0;
StackPtr->Control = 0;
StackPtr->DeviceObject = IrpContext->DeviceExt->StorageDevice;
StackPtr->FileObject = NULL;
StackPtr->CompletionRoutine = NULL;
StackPtr->Parameters.Read.Length = WriteLength;
StackPtr->Parameters.Read.ByteOffset = *WriteOffset;
if (!IoAllocateMdl(Buffer, WriteLength, FALSE, FALSE, Irp))
{
DPRINT("IoAllocateMdl failed\n");
IoFreeIrp(Irp);
return STATUS_UNSUCCESSFUL;
}
IoBuildPartialMdl(IrpContext->Irp->MdlAddress, Irp->MdlAddress, Buffer, WriteLength);
IoSetCompletionRoutine(Irp,
VfatReadWritePartialCompletion,
IrpContext,
TRUE,
TRUE,
TRUE);
if (Wait)
{
KeInitializeEvent(&IrpContext->Event, NotificationEvent, FALSE);
IrpContext->RefCount = 1;
}
else
{
InterlockedIncrement((PLONG)&IrpContext->RefCount);
}
DPRINT("Calling IO Driver...\n");
Status = IoCallDriver(IrpContext->DeviceExt->StorageDevice, Irp);
if (Wait && Status == STATUS_PENDING)
{
KeWaitForSingleObject(&IrpContext->Event, Executive, KernelMode, FALSE, NULL);
Status = IrpContext->Irp->IoStatus.Status;
}
if (Status == STATUS_VERIFY_REQUIRED)
{
PDEVICE_OBJECT DeviceToVerify;
DPRINT1("Media change detected!\n");
/* Find the device to verify and reset the thread field to empty value again. */
DeviceToVerify = IoGetDeviceToVerify(PsGetCurrentThread());
IoSetDeviceToVerify(PsGetCurrentThread(), NULL);
Status = IoVerifyVolume(DeviceToVerify,
FALSE);
if (NT_SUCCESS(Status))
{
DPRINT1("Volume verification successful; Reissuing write request\n");
goto again;
}
}
return Status;
}
int body() {
__rho_1_ = nondet();
if (__rho_1_>0) {
// haven't stopped yet, lets do so
ntStatus = t1394Diag_PnpStopDevice(DeviceObject, Irp);
}
ntStatus = IoSetDeviceInterfaceState();
// lets free up any crom data structs we've allocated...
keA = 1; keA = 0; KeAcquireSpinLock(lock3, Irql);
__rho_2_ = nondet();
k1 = __rho_2_;
while (1) {
if (!(k1>0)) break;
__rho_3_ = nondet();
CromData = __rho_3_;
// get struct off list
k1--;
// need to free up everything associated with this allocate...
if (CromData>0)
{
__rho_4_ = nondet();
if (__rho_4_>0)
ExFreePool0();
__rho_5_ = nondet();
if (__rho_5_>0)
IoFreeMdl();
// we already checked CromData
ExFreePool1(CromData);
}
}
keR = 1; keR = 0; KeReleaseSpinLock(lock3, Irql);
keA = 1; keA = 0; KeAcquireSpinLock(lock1, Irql);
__rho_6_ = nondet();
k2 = __rho_6_;
while (1) {
if (!(k2>0)) break;
AsyncAddressData = nondet();
// get struct off list
AsyncAddressData = nondet();
k2--;
// need to free up everything associated with this allocate...
__rho_7_ = nondet();
if (__rho_7_>0)
IoFreeMdl();
__rho_8_ = nondet();
if (__rho_8_>0)
ExFreePool0();
__rho_9_ = nondet();
if (__rho_9_>0)
ExFreePool0();
if (AsyncAddressData>0)
ExFreePool0();
}
keR = 1; keR = 0; KeReleaseSpinLock(lock1, Irql);
// free up any attached isoch buffers
while (TRUE) {
keA = 1; keA = 0; KeAcquireSpinLock(lock4, Irql);
__rho_10_ = nondet();
k3 = __rho_10_;
if (k3>0) {
IsochDetachData = nondet();
i = nondet();
IsochDetachData = nondet();
k3--;
KeCancelTimer();
keR = 1; keR = 0; KeReleaseSpinLock(lock4, Irql);
t1394_IsochCleanup(IsochDetachData);
}
else {
keR = 1; keR = 0; KeReleaseSpinLock(lock4, Irql);
break;
}
}
// remove any isoch resource data
__rho_11_ = nondet();
k4 = __rho_11_;
while (TRUE) {
keA = 1; keA = 0; KeAcquireSpinLock(lock5, Irql);
if (k4>0) {
__rho_12_ = nondet();
IsochResourceData = __rho_12_;
k4--;
keR = 1; keR = 0; KeReleaseSpinLock(lock5, Irql);
if (IsochResourceData>0) {
pIrb = nondet();
ResourceIrp = nondet();
StackSize = nondet();
ResourceIrp = IoAllocateIrp(StackSize, FALSE);
if (ResourceIrp == 0) {
}
else {
pIrb = ExAllocatePool(NonPagedPool, 0);
if (pIrb<=0) {
IoFreeIrp(ResourceIrp);
}
else {
RtlZeroMemory (pIrb, 0);
ntStatus = t1394_SubmitIrpSynch(ResourceIrp, pIrb);
ExFreePool1(pIrb);
IoFreeIrp(ResourceIrp);
}
}
}
}
else {
keR = 1; keR = 0; KeReleaseSpinLock(lock5, Irql);
break;
}
}
// get rid of any pending bus reset notify requests
keA = 1; keA = 0; KeAcquireSpinLock(lock6, Irql);
__rho_13_ = nondet();
k5 = __rho_13_;
while (1) {
if (!(k5>0)) break;
prevCancel = NULL;
// get the irp off of the list
BusResetIrp = nondet();
k5--;
// make this irp non-cancelable...
prevCancel = IoSetCancelRoutine(NULL);
// and complete it...
IoCompleteRequest(IO_NO_INCREMENT);
ExFreePool1(BusResetIrp);
}
keR = 1; keR = 0; KeReleaseSpinLock(lock6, Irql);
// free up the symbolic link
while(1) { dummy=dummy; } L_return: return 0;
} // t1394Diag_PnpRemoveDevice
NTSTATUS
connecttoserver(PWSK_PROVIDER_NPI pronpi, PSOCKADDR remaddr, PWSK_SOCKET *sock)
{
NTSTATUS status;
PIRP irp;
KEVENT event;
ULONG SocketOptionState;
SOCKADDR locaddr = {0} ;
irp = IoAllocateIrp(1, FALSE);
if(!irp){
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent(&event, NotificationEvent, FALSE);
IoSetCompletionRoutine(irp, createcomplete, &event, TRUE, TRUE, TRUE);
locaddr.sa_family = remaddr->sa_family;
status = pronpi->Dispatch->WskSocketConnect(
pronpi->Client, /* Client */
SOCK_STREAM, /* SocketType */
IPPROTO_TCP, /* Protocol */
&locaddr, /* LocalAddress */
remaddr, /* RemoteAddress */
0, /* Flags */
NULL, /* SocketContext */
NULL, /* Dispatch */
NULL, /* OwningProcess */
NULL, /* OwningThread */
NULL, /* SecurityDescriptor */
irp); /* Irp */
if(!NT_SUCCESS(status)){
IoFreeIrp(irp);
return status;
}
if(status == STATUS_PENDING){
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = irp->IoStatus.Status;
if(!NT_SUCCESS(status)){
IoFreeIrp(irp);
return status;
}
}
*sock = (PWSK_SOCKET)irp->IoStatus.Information;
// SocketOptionState =1;
// status = WskControlSocket(
// sock,
// WskSetOption,
// TCP_NODELAY,
// SOL_SOCKET,
// sizeof(ULONG),
// &SocketOptionState,
// NULL,
// NULL,
// irp);
IoFreeIrp(irp);
return STATUS_SUCCESS;
}
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;
}
