usbstor.h File Reference

#include <wdm.h>
#include <ntstrsafe.h>
#include <usbdi.h>
#include <usbbusif.h>
#include <usbdlib.h>
#include <classpnp.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for usbstor.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	CBW
struct	CSW
struct	IRP_CONTEXT
struct	__COMMON_DEVICE_EXTENSION__
struct	FDO_DEVICE_EXTENSION
struct	PDO_DEVICE_EXTENSION
struct	_ERRORHANDLER_WORKITEM_DATA
struct	_STORAGE_ADAPTER_DESCRIPTOR_WIN8

Macros
#define	USB_STOR_TAG   'sbsu'
#define	BooleanFlagOn(Flags, SingleFlag)   ((BOOLEAN)((((Flags) & (SingleFlag)) != 0)))
#define	SrbGetCdb(srb)   ((PCDB)(srb->Cdb))
#define	USB_SUBCLASS_RBC   0x01
#define	USB_SUBCLASS_8020   0x02
#define	USB_SUBCLASS_QIC   0x03
#define	USB_SUBCLASS_UFI   0x04
#define	USB_SUBCLASS_8070   0x05
#define	USB_SUBCLASS_SCSI   0x06
#define	USB_SUBCLASS_LOCKABLE   0x07
#define	USB_SUBCLASS_ISD200   0xF0
#define	USB_SUBCLASS_CYP_ATACB   0xF1
#define	USB_SUBCLASS_VENDOR   0xFF
#define	USB_PROTOCOL_CBI   0x00
#define	USB_PROTOCOL_CB   0x01
#define	USB_PROTOCOL_BULK   0x50
#define	USB_PROTOCOL_UAS   0x62
#define	USB_PROTOCOL_USBAT   0x80
#define	USB_PROTOCOL_EUSB_SDDR09   0x81
#define	USB_PROTOCOL_SDDR55   0x82
#define	USB_PROTOCOL_DPCM_USB   0xF0
#define	USB_PROTOCOL_FREECOM   0xF1
#define	USB_PROTOCOL_DATAFAB   0xF2
#define	USB_PROTOCOL_JUMPSHOT   0xF3
#define	USB_PROTOCOL_ALAUDA   0xF4
#define	USB_PROTOCOL_KARMA   0xF5
#define	USB_PROTOCOL_VENDOR   0xFF
#define	USB_BULK_GET_MAX_LUN   0xFE
#define	USB_BULK_RESET_DEVICE   0xFF
#define	USB_RECOVERABLE_ERRORS
#define	USB_MAXCHILDREN   16
#define	MAX_LUN   0xF
#define	USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH   0x10000
#define	CBW_SIGNATURE   0x43425355
#define	CSW_SIGNATURE   0x53425355
#define	CSW_STATUS_COMMAND_PASSED   0x00
#define	CSW_STATUS_COMMAND_FAILED   0x01
#define	CSW_STATUS_PHASE_ERROR   0x02
#define	USBSTOR_FDO_FLAGS_DEVICE_RESETTING   0x00000001
#define	USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE   0x00000002

Typedefs
typedef struct CBW *	PCBW
typedef struct CSW *	PCSW
typedef struct IRP_CONTEXT *	PIRP_CONTEXT
typedef struct __COMMON_DEVICE_EXTENSION__	USBSTOR_COMMON_DEVICE_EXTENSION
typedef struct __COMMON_DEVICE_EXTENSION__ *	PUSBSTOR_COMMON_DEVICE_EXTENSION
typedef struct FDO_DEVICE_EXTENSION *	PFDO_DEVICE_EXTENSION
typedef struct PDO_DEVICE_EXTENSION *	PPDO_DEVICE_EXTENSION
typedef struct _ERRORHANDLER_WORKITEM_DATA	ERRORHANDLER_WORKITEM_DATA
typedef struct _ERRORHANDLER_WORKITEM_DATA *	PERRORHANDLER_WORKITEM_DATA
typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8	STORAGE_ADAPTER_DESCRIPTOR_WIN8
typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 *	PSTORAGE_ADAPTER_DESCRIPTOR_WIN8

Functions
	C_ASSERT (sizeof(CBW)==31)
NTSTATUS	USBSTOR_FdoHandlePnp (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	USBSTOR_PdoHandlePnp (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	USBSTOR_CreatePDO (IN PDEVICE_OBJECT DeviceObject, IN UCHAR LUN)
NTSTATUS NTAPI	USBSTOR_GetBusInterface (IN PDEVICE_OBJECT DeviceObject, OUT PUSB_BUS_INTERFACE_USBDI_V2 BusInterface)
PVOID	AllocateItem (IN POOL_TYPE PoolType, IN ULONG ItemSize)
VOID	FreeItem (IN PVOID Item)
NTSTATUS	USBSTOR_SyncUrbRequest (IN PDEVICE_OBJECT DeviceObject, OUT PURB UrbRequest)
NTSTATUS	USBSTOR_GetMaxLUN (IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	USBSTOR_ResetDevice (IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	USBSTOR_GetDescriptors (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	USBSTOR_SelectConfigurationAndInterface (IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	USBSTOR_GetPipeHandles (IN PFDO_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	USBSTOR_HandleExecuteSCSI (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	USBSTOR_SendCSWRequest (PFDO_DEVICE_EXTENSION FDODeviceExtension, PIRP Irp)
NTSTATUS	USBSTOR_HandleInternalDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	USBSTOR_HandleDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	USBSTOR_StartIo (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	USBSTOR_QueueWaitForPendingRequests (IN PDEVICE_OBJECT DeviceObject)
VOID	USBSTOR_QueueRelease (IN PDEVICE_OBJECT DeviceObject)
BOOLEAN	USBSTOR_QueueAddIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	USBSTOR_CancelIo (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID	USBSTOR_QueueInitialize (PFDO_DEVICE_EXTENSION FDODeviceExtension)
VOID	USBSTOR_QueueNextRequest (IN PDEVICE_OBJECT DeviceObject)
VOID	USBSTOR_QueueTerminateRequest (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	USBSTOR_GetEndpointStatus (IN PDEVICE_OBJECT DeviceObject, IN UCHAR bEndpointAddress, OUT PUSHORT Value)
NTSTATUS	USBSTOR_ResetPipeWithHandle (IN PDEVICE_OBJECT DeviceObject, IN USBD_PIPE_HANDLE PipeHandle)
VOID NTAPI	USBSTOR_TimerRoutine (PDEVICE_OBJECT DeviceObject, PVOID Context)
VOID NTAPI	USBSTOR_QueueResetPipe (IN PFDO_DEVICE_EXTENSION FDODeviceExtension)
VOID NTAPI	USBSTOR_QueueResetDevice (IN PFDO_DEVICE_EXTENSION FDODeviceExtension)

Macro Definition Documentation

BooleanFlagOn

#define BooleanFlagOn	(		Flags,
			SingleFlag
	)		((BOOLEAN)((((Flags) & (SingleFlag)) != 0)))

Definition at line 14 of file usbstor.h.

CBW_SIGNATURE

#define CBW_SIGNATURE   0x43425355

Definition at line 65 of file usbstor.h.

CSW_SIGNATURE

#define CSW_SIGNATURE   0x53425355

Definition at line 66 of file usbstor.h.

CSW_STATUS_COMMAND_FAILED

#define CSW_STATUS_COMMAND_FAILED   0x01

Definition at line 84 of file usbstor.h.

CSW_STATUS_COMMAND_PASSED

#define CSW_STATUS_COMMAND_PASSED   0x00

Definition at line 83 of file usbstor.h.

CSW_STATUS_PHASE_ERROR

#define CSW_STATUS_PHASE_ERROR   0x02

Definition at line 85 of file usbstor.h.

MAX_LUN

#define MAX_LUN   0xF

Definition at line 62 of file usbstor.h.

SrbGetCdb

#define SrbGetCdb

(

srb

)

((PCDB)(srb->Cdb))

Definition at line 18 of file usbstor.h.

USB_BULK_GET_MAX_LUN

#define USB_BULK_GET_MAX_LUN   0xFE

Definition at line 55 of file usbstor.h.

USB_BULK_RESET_DEVICE

#define USB_BULK_RESET_DEVICE   0xFF

Definition at line 56 of file usbstor.h.

USB_MAXCHILDREN

#define USB_MAXCHILDREN   16

Definition at line 61 of file usbstor.h.

USB_PROTOCOL_ALAUDA

#define USB_PROTOCOL_ALAUDA   0xF4

Definition at line 49 of file usbstor.h.

USB_PROTOCOL_BULK

#define USB_PROTOCOL_BULK   0x50

Definition at line 39 of file usbstor.h.

USB_PROTOCOL_CB

#define USB_PROTOCOL_CB   0x01

Definition at line 38 of file usbstor.h.

USB_PROTOCOL_CBI

#define USB_PROTOCOL_CBI   0x00

Definition at line 37 of file usbstor.h.

USB_PROTOCOL_DATAFAB

#define USB_PROTOCOL_DATAFAB   0xF2

Definition at line 47 of file usbstor.h.

USB_PROTOCOL_DPCM_USB

#define USB_PROTOCOL_DPCM_USB   0xF0

Definition at line 45 of file usbstor.h.

USB_PROTOCOL_EUSB_SDDR09

#define USB_PROTOCOL_EUSB_SDDR09   0x81

Definition at line 42 of file usbstor.h.

USB_PROTOCOL_FREECOM

#define USB_PROTOCOL_FREECOM   0xF1

Definition at line 46 of file usbstor.h.

USB_PROTOCOL_JUMPSHOT

#define USB_PROTOCOL_JUMPSHOT   0xF3

Definition at line 48 of file usbstor.h.

USB_PROTOCOL_KARMA

#define USB_PROTOCOL_KARMA   0xF5

Definition at line 50 of file usbstor.h.

USB_PROTOCOL_SDDR55

#define USB_PROTOCOL_SDDR55   0x82

Definition at line 43 of file usbstor.h.

USB_PROTOCOL_UAS

#define USB_PROTOCOL_UAS   0x62

Definition at line 40 of file usbstor.h.

USB_PROTOCOL_USBAT

#define USB_PROTOCOL_USBAT   0x80

Definition at line 41 of file usbstor.h.

USB_PROTOCOL_VENDOR

#define USB_PROTOCOL_VENDOR   0xFF

Definition at line 51 of file usbstor.h.

USB_RECOVERABLE_ERRORS

#define USB_RECOVERABLE_ERRORS

Value:

    (USBD_STATUS_STALL_PID | USBD_STATUS_DEV_NOT_RESPONDING \
    | USBD_STATUS_ENDPOINT_HALTED | USBD_STATUS_NO_BANDWIDTH)

Definition at line 58 of file usbstor.h.

USB_STOR_TAG

#define USB_STOR_TAG   'sbsu'

Definition at line 11 of file usbstor.h.

USB_SUBCLASS_8020

#define USB_SUBCLASS_8020   0x02

Definition at line 24 of file usbstor.h.

USB_SUBCLASS_8070

#define USB_SUBCLASS_8070   0x05

Definition at line 27 of file usbstor.h.

USB_SUBCLASS_CYP_ATACB

#define USB_SUBCLASS_CYP_ATACB   0xF1

Definition at line 32 of file usbstor.h.

USB_SUBCLASS_ISD200

#define USB_SUBCLASS_ISD200   0xF0

Definition at line 31 of file usbstor.h.

USB_SUBCLASS_LOCKABLE

#define USB_SUBCLASS_LOCKABLE   0x07

Definition at line 29 of file usbstor.h.

USB_SUBCLASS_QIC

#define USB_SUBCLASS_QIC   0x03

Definition at line 25 of file usbstor.h.

USB_SUBCLASS_RBC

#define USB_SUBCLASS_RBC   0x01

Definition at line 23 of file usbstor.h.

USB_SUBCLASS_SCSI

#define USB_SUBCLASS_SCSI   0x06

Definition at line 28 of file usbstor.h.

USB_SUBCLASS_UFI

#define USB_SUBCLASS_UFI   0x04

Definition at line 26 of file usbstor.h.

USB_SUBCLASS_VENDOR

#define USB_SUBCLASS_VENDOR   0xFF

Definition at line 33 of file usbstor.h.

USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH

#define USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH   0x10000

Definition at line 63 of file usbstor.h.

USBSTOR_FDO_FLAGS_DEVICE_RESETTING

#define USBSTOR_FDO_FLAGS_DEVICE_RESETTING   0x00000001

Definition at line 117 of file usbstor.h.

USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE

#define USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE   0x00000002

Definition at line 118 of file usbstor.h.

Typedef Documentation

ERRORHANDLER_WORKITEM_DATA

typedef struct _ERRORHANDLER_WORKITEM_DATA ERRORHANDLER_WORKITEM_DATA

PCBW

typedef struct CBW * PCBW

PCSW

typedef struct CSW * PCSW

PERRORHANDLER_WORKITEM_DATA

typedef struct _ERRORHANDLER_WORKITEM_DATA * PERRORHANDLER_WORKITEM_DATA

PFDO_DEVICE_EXTENSION

typedef struct FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION

PIRP_CONTEXT

typedef struct IRP_CONTEXT * PIRP_CONTEXT

PPDO_DEVICE_EXTENSION

typedef struct PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION

PSTORAGE_ADAPTER_DESCRIPTOR_WIN8

typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 * PSTORAGE_ADAPTER_DESCRIPTOR_WIN8

PUSBSTOR_COMMON_DEVICE_EXTENSION

typedef struct __COMMON_DEVICE_EXTENSION__ * PUSBSTOR_COMMON_DEVICE_EXTENSION

STORAGE_ADAPTER_DESCRIPTOR_WIN8

typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 STORAGE_ADAPTER_DESCRIPTOR_WIN8

USBSTOR_COMMON_DEVICE_EXTENSION

typedef struct __COMMON_DEVICE_EXTENSION__ USBSTOR_COMMON_DEVICE_EXTENSION

Function Documentation

AllocateItem()

PVOID AllocateItem	(	IN POOL_TYPE	PoolType,
		IN ULONG	ItemSize
	)

Definition at line 29 of file misc.c.

{
    return ExAllocatePoolZero(PoolType, NumberOfBytes, TAG_KS);
}

C_ASSERT()

C_ASSERT

(

sizeof(CBW)

= =31

)

FreeItem()

VOID FreeItem

(

IN PVOID

Item

)

Definition at line 37 of file misc.c.

{
    ExFreePoolWithTag(Item, TAG_KS);
}

USBSTOR_CancelIo()

VOID NTAPI USBSTOR_CancelIo	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 28 of file queue.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    // this IRP isn't in our list here
    // now release the cancel lock
    IoReleaseCancelSpinLock(Irp->CancelIrql);
    Irp->IoStatus.Status = STATUS_CANCELLED;
 
    USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    USBSTOR_QueueNextRequest(DeviceObject);
}

USBSTOR_CreatePDO()

NTSTATUS USBSTOR_CreatePDO	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	LUN
	)

Definition at line 864 of file pdo.c.

{
    PDEVICE_OBJECT PDO;
    NTSTATUS Status;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PINQUIRYDATA InquiryData;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    // create child device object
    Status = IoCreateDevice(DeviceObject->DriverObject, sizeof(PDO_DEVICE_EXTENSION), NULL, FILE_DEVICE_MASS_STORAGE, FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN, FALSE, &PDO);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create PDO, status %x\n", Status);
        return Status;
    }
 
    // patch the stack size
    PDO->StackSize = DeviceObject->StackSize;
 
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)PDO->DeviceExtension;
    InquiryData = (PINQUIRYDATA)&PDODeviceExtension->InquiryData;
 
    // initialize device extension
    RtlZeroMemory(PDODeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
    PDODeviceExtension->Common.IsFDO = FALSE;
    PDODeviceExtension->LowerDeviceObject = DeviceObject;
    PDODeviceExtension->PDODeviceObject = &FDODeviceExtension->ChildPDO[LUN];
    PDODeviceExtension->Self = PDO;
    PDODeviceExtension->LUN = LUN;
 
    PDO->Flags |= DO_DIRECT_IO;
 
    // device is initialized
    PDO->Flags &= ~DO_DEVICE_INITIALIZING;
 
    // output device object
    FDODeviceExtension->ChildPDO[LUN] = PDO;
 
    // send inquiry command by irp
    Status = USBSTOR_FillInquiryData(PDO);
 
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    if (InquiryData->DeviceType != DIRECT_ACCESS_DEVICE &&
        InquiryData->DeviceType != READ_ONLY_DIRECT_ACCESS_DEVICE)
    {
        return STATUS_NOT_SUPPORTED;
    }
 
    return Status;
}

USBSTOR_FdoHandlePnp()

NTSTATUS USBSTOR_FdoHandlePnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 282 of file fdo.c.

{
    PIO_STACK_LOCATION IoStack;
    PFDO_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->Common.IsFDO);
 
    switch(IoStack->MinorFunction)
    {
        case IRP_MN_SURPRISE_REMOVAL:
        {
            DPRINT("IRP_MN_SURPRISE_REMOVAL %p\n", DeviceObject);
            Irp->IoStatus.Status = STATUS_SUCCESS;
 
            // forward irp to next device object
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS %p Type: %u\n", DeviceObject, IoStack->Parameters.QueryDeviceRelations.Type);
            return USBSTOR_FdoHandleDeviceRelations(DeviceExtension, Irp);
        }
        case IRP_MN_STOP_DEVICE:
        {
            DPRINT1("USBSTOR_FdoHandlePnp: IRP_MN_STOP_DEVICE unimplemented\n");
            IoStopTimer(DeviceObject);
            Irp->IoStatus.Status = STATUS_SUCCESS;
 
            // forward irp to next device object
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
        }
        case IRP_MN_REMOVE_DEVICE:
        {
            DPRINT("IRP_MN_REMOVE_DEVICE\n");
 
            return USBSTOR_FdoHandleRemoveDevice(DeviceObject, DeviceExtension, Irp);
        }
        case IRP_MN_QUERY_CAPABILITIES:
        {
            // FIXME: set custom capabilities
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
        }
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        {
            if (DeviceExtension->IrpPendingCount != 0 || DeviceExtension->ActiveSrb != NULL)
            {
                /* We have pending requests */
                DPRINT1("Failing removal/stop request due to pending requests present\n");
                Status = STATUS_UNSUCCESSFUL;
            }
            else
            {
                /* We're all clear */
                Irp->IoStatus.Status = STATUS_SUCCESS;
 
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
            }
            break;
        }
        case IRP_MN_START_DEVICE:
        {
            Status = USBSTOR_FdoHandleStartDevice(DeviceObject, DeviceExtension, Irp);
            break;
        }
        default:
        {
            // forward irp to next device object
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
        }
    }
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return Status;
}

USBSTOR_GetBusInterface()

NTSTATUS NTAPI USBSTOR_GetBusInterface	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PUSB_BUS_INTERFACE_USBDI_V2	BusInterface
	)

Definition at line 33 of file misc.c.

{
    KEVENT Event;
    NTSTATUS Status;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    PIO_STACK_LOCATION Stack;
 
    ASSERT(DeviceObject);
    ASSERT(BusInterface);
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
                                       DeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatus);
    if (Irp == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // initialize request
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = IRP_MJ_PNP;
    Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
    Stack->Parameters.QueryInterface.Size = sizeof(BUS_INTERFACE_STANDARD);
    Stack->Parameters.QueryInterface.InterfaceType = (LPGUID)&USB_BUS_INTERFACE_USBDI_GUID;
    Stack->Parameters.QueryInterface.Version = 2;
    Stack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterface;
    Stack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatus.Status;
    }
 
    return Status;
}

USBSTOR_GetDescriptors()

NTSTATUS USBSTOR_GetDescriptors

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 75 of file descriptor.c.

{
    NTSTATUS Status;
    PFDO_DEVICE_EXTENSION DeviceExtension;
    USHORT DescriptorLength;
 
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
     // first get device descriptor
     Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_DEVICE_DESCRIPTOR_TYPE, sizeof(USB_DEVICE_DESCRIPTOR), 0, 0, (PVOID*)&DeviceExtension->DeviceDescriptor);
     if (!NT_SUCCESS(Status))
     {
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
 
     // now get basic configuration descriptor
     Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_CONFIGURATION_DESCRIPTOR_TYPE, sizeof(USB_CONFIGURATION_DESCRIPTOR), 0, 0, (PVOID*)&DeviceExtension->ConfigurationDescriptor);
     if (!NT_SUCCESS(Status))
     {
         FreeItem(DeviceExtension->DeviceDescriptor);
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
 
     // backup length
     DescriptorLength = DeviceExtension->ConfigurationDescriptor->wTotalLength;
 
     // release basic descriptor
     FreeItem(DeviceExtension->ConfigurationDescriptor);
     DeviceExtension->ConfigurationDescriptor = NULL;
 
     // allocate full descriptor
     Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_CONFIGURATION_DESCRIPTOR_TYPE, DescriptorLength, 0, 0, (PVOID*)&DeviceExtension->ConfigurationDescriptor);
     if (!NT_SUCCESS(Status))
     {
         FreeItem(DeviceExtension->DeviceDescriptor);
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
 
     // check if there is a serial number provided
     if (DeviceExtension->DeviceDescriptor->iSerialNumber)
     {
         // get serial number
         Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_STRING_DESCRIPTOR_TYPE, MAXIMUM_USB_STRING_LENGTH, DeviceExtension->DeviceDescriptor->iSerialNumber, 0x0409, (PVOID*)&DeviceExtension->SerialNumber);
         if (!NT_SUCCESS(Status))
         {
             FreeItem(DeviceExtension->DeviceDescriptor);
             DeviceExtension->DeviceDescriptor = NULL;
 
             FreeItem(DeviceExtension->ConfigurationDescriptor);
             DeviceExtension->ConfigurationDescriptor = NULL;
 
             DeviceExtension->SerialNumber = NULL;
             return Status;
          }
     }
 
     return Status;
}

USBSTOR_GetEndpointStatus()

NTSTATUS USBSTOR_GetEndpointStatus	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	bEndpointAddress,
		OUT PUSHORT	Value
	)

Definition at line 18 of file error.c.

{
    PURB Urb;
    NTSTATUS Status;
 
    DPRINT("Allocating URB\n");
    Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));
    if (!Urb)
    {
        DPRINT1("OutofMemory!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // build status
    UsbBuildGetStatusRequest(Urb, URB_FUNCTION_GET_STATUS_FROM_ENDPOINT, bEndpointAddress & 0x0F, Value, NULL, NULL);
 
    // send the request
    DPRINT1("Sending Request DeviceObject %p, Urb %p\n", DeviceObject, Urb);
    Status = USBSTOR_SyncUrbRequest(DeviceObject, Urb);
 
    FreeItem(Urb);
    return Status;
}

USBSTOR_GetMaxLUN()

NTSTATUS USBSTOR_GetMaxLUN	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PFDO_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 173 of file misc.c.

{
    PUCHAR Buffer;
    NTSTATUS Status;
 
    Buffer = (PUCHAR)ExAllocatePoolWithTag(NonPagedPool, sizeof(UCHAR), USB_STOR_TAG);
    if (!Buffer)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_GET_MAX_LUN, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_IN, sizeof(UCHAR), Buffer);
 
    DPRINT("MaxLUN: %x\n", *Buffer);
 
    if (NT_SUCCESS(Status))
    {
        if (*Buffer > MAX_LUN)
        {
            // invalid response documented in usb mass storage specification
            Status = STATUS_DEVICE_DATA_ERROR;
        }
        else
        {
            // store maxlun
            DeviceExtension->MaxLUN = *Buffer;
        }
    }
    else
    {
        // "USB Mass Storage Class. Bulk-Only Transport. Revision 1.0"
        // 3.2  Get Max LUN (class-specific request) :
        // Devices that do not support multiple LUNs may STALL this command.
        USBSTOR_ResetDevice(DeviceExtension->LowerDeviceObject, DeviceExtension);
 
        DeviceExtension->MaxLUN = 0;
        Status = STATUS_SUCCESS;
    }
 
    ExFreePoolWithTag(Buffer, USB_STOR_TAG);
    return Status;
}

USBSTOR_GetPipeHandles()

NTSTATUS USBSTOR_GetPipeHandles

(

IN PFDO_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 319 of file descriptor.c.

{
    ULONG Index;
    BOOLEAN BulkInFound = FALSE, BulkOutFound = FALSE;
 
    // enumerate all pipes and extract bulk-in / bulk-out pipe handle
    for (Index = 0; Index < DeviceExtension->InterfaceInformation->NumberOfPipes; Index++)
    {
        if (DeviceExtension->InterfaceInformation->Pipes[Index].PipeType == UsbdPipeTypeBulk)
        {
            if (USB_ENDPOINT_DIRECTION_IN(DeviceExtension->InterfaceInformation->Pipes[Index].EndpointAddress))
            {
                DeviceExtension->BulkInPipeIndex = Index;
 
                // there should not be another bulk in pipe
                ASSERT(BulkInFound == FALSE);
                BulkInFound = TRUE;
            }
            else
            {
                DeviceExtension->BulkOutPipeIndex = Index;
 
                // there should not be another bulk out pipe
                ASSERT(BulkOutFound == FALSE);
                BulkOutFound = TRUE;
            }
        }
    }
 
    if (!BulkInFound || !BulkOutFound)
    {
        // WTF? usb port driver does not give us bulk pipe access
        DPRINT1("USBSTOR_GetPipeHandles> BulkInFound %c BulkOutFound %c missing!!!\n", BulkInFound, BulkOutFound);
        return STATUS_DEVICE_CONFIGURATION_ERROR;
    }
 
    return STATUS_SUCCESS;
}

USBSTOR_HandleDeviceControl()

NTSTATUS USBSTOR_HandleDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 413 of file disk.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    PSCSI_ADAPTER_BUS_INFO BusInfo;
    PSCSI_INQUIRY_DATA ScsiInquiryData;
    PINQUIRYDATA InquiryData;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IoStack->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_STORAGE_QUERY_PROPERTY:
            Status = USBSTOR_HandleQueryProperty(DeviceObject, Irp);
            break;
        case IOCTL_SCSI_PASS_THROUGH:
            DPRINT1("USBSTOR_HandleDeviceControl IOCTL_SCSI_PASS_THROUGH NOT implemented\n");
            Status = STATUS_NOT_SUPPORTED;
            break;
        case IOCTL_SCSI_PASS_THROUGH_DIRECT:
            DPRINT1("USBSTOR_HandleDeviceControl IOCTL_SCSI_PASS_THROUGH_DIRECT NOT implemented\n");
            Status = STATUS_NOT_SUPPORTED;
            break;
        case IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER:
            DPRINT1("USBSTOR_HandleDeviceControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER NOT implemented\n");
            Status = STATUS_NOT_SUPPORTED;
            break;
        case IOCTL_SCSI_GET_CAPABILITIES:
        {
            PIO_SCSI_CAPABILITIES Capabilities;
 
            // Legacy port capability query
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(PVOID))
            {
                Capabilities = *((PVOID *)Irp->AssociatedIrp.SystemBuffer) = ExAllocatePoolWithTag(NonPagedPool,
                                                                                                   sizeof(IO_SCSI_CAPABILITIES),
                                                                                                   USB_STOR_TAG);
                Irp->IoStatus.Information = sizeof(PVOID);
            }
            else
            {
                Capabilities = Irp->AssociatedIrp.SystemBuffer;
                Irp->IoStatus.Information = sizeof(IO_SCSI_CAPABILITIES);
            }
 
            if (Capabilities)
            {
                Capabilities->MaximumTransferLength = USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH;
                Capabilities->MaximumPhysicalPages = USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH / PAGE_SIZE + 1; // See CORE-10515 and CORE-10755
                Capabilities->SupportedAsynchronousEvents = 0;
                Capabilities->AlignmentMask = 0;
                Capabilities->TaggedQueuing = FALSE;
                Capabilities->AdapterScansDown = FALSE;
                Capabilities->AdapterUsesPio = FALSE;
                Status = STATUS_SUCCESS;
            }
            else
            {
                Status = STATUS_INSUFFICIENT_RESOURCES;
            }
 
            break;
        }
        case IOCTL_SCSI_GET_INQUIRY_DATA:
        {
            PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
            ASSERT(PDODeviceExtension);
            ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
            // get parameters
            BusInfo = Irp->AssociatedIrp.SystemBuffer;
            ScsiInquiryData = (PSCSI_INQUIRY_DATA)(BusInfo + 1);
            InquiryData = (PINQUIRYDATA)ScsiInquiryData->InquiryData;
 
 
            BusInfo->NumberOfBuses = 1;
            BusInfo->BusData[0].NumberOfLogicalUnits = 1; //FIXME
            BusInfo->BusData[0].InitiatorBusId = 0;
            BusInfo->BusData[0].InquiryDataOffset = sizeof(SCSI_ADAPTER_BUS_INFO);
 
            ScsiInquiryData->PathId = 0;
            ScsiInquiryData->TargetId = 0;
            ScsiInquiryData->Lun = PDODeviceExtension->LUN & MAX_LUN;
            ScsiInquiryData->DeviceClaimed = PDODeviceExtension->Claimed;
            ScsiInquiryData->InquiryDataLength = sizeof(INQUIRYDATA);
            ScsiInquiryData->NextInquiryDataOffset = 0;
 
            // Note: INQUIRYDATA structure is larger than INQUIRYDATABUFFERSIZE
            RtlZeroMemory(InquiryData, sizeof(INQUIRYDATA));
            RtlCopyMemory(InquiryData, &PDODeviceExtension->InquiryData, sizeof(PDODeviceExtension->InquiryData));
 
            InquiryData->Versions = 0x04;
            InquiryData->ResponseDataFormat = 0x02; // some devices set this to 1
 
            Irp->IoStatus.Information = sizeof(SCSI_ADAPTER_BUS_INFO) + sizeof(SCSI_INQUIRY_DATA) + sizeof(INQUIRYDATA) - 1;
            Status = STATUS_SUCCESS;
 
            break;
        }
        case IOCTL_SCSI_GET_ADDRESS:
        {
            PSCSI_ADDRESS Address = Irp->AssociatedIrp.SystemBuffer;
 
            Address->Length = sizeof(SCSI_ADDRESS);
            Address->PortNumber = 0;
            Address->PathId = 0;
            Address->TargetId = 0;
            Address->Lun = (((PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LUN & MAX_LUN);
            Irp->IoStatus.Information = sizeof(SCSI_ADDRESS);
 
            Status = STATUS_SUCCESS;
 
            break;
        }
        default:
            DPRINT("USBSTOR_HandleDeviceControl IoControl %x not supported\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
            Status = STATUS_NOT_SUPPORTED;
            break;
    }
 
    return Status;
}

USBSTOR_HandleExecuteSCSI()

NTSTATUS USBSTOR_HandleExecuteSCSI	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 540 of file scsi.c.

{
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PPDO_DEVICE_EXTENSION PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = IoStack->Parameters.Scsi.Srb;
 
    DPRINT("USBSTOR_HandleExecuteSCSI Operation Code %x, Length %lu\n", SrbGetCdb(Request)->CDB10.OperationCode, Request->DataTransferLength);
 
    // check that we're sending to the right LUN
    ASSERT(SrbGetCdb(Request)->CDB10.LogicalUnitNumber == PDODeviceExtension->LUN);
 
    return USBSTOR_SendCBWRequest(PDODeviceExtension->LowerDeviceObject->DeviceExtension, Irp);
}

Referenced by USBSTOR_HandleTransferError(), and USBSTOR_StartIo().

USBSTOR_HandleInternalDeviceControl()

NTSTATUS USBSTOR_HandleInternalDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 81 of file disk.c.

{
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    NTSTATUS Status;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
    ASSERT(Request);
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
    switch(Request->Function)
    {
        case SRB_FUNCTION_EXECUTE_SCSI:
        {
            DPRINT("SRB_FUNCTION_EXECUTE_SCSI\n");
 
            if (!IsRequestValid(Irp))
            {
                Status = STATUS_INVALID_PARAMETER;
                break;
            }
 
            if (Request->Cdb[0] == SCSIOP_MODE_SENSE)
            {
                DPRINT("USBSTOR_Scsi: SRB_FUNCTION_EXECUTE_SCSI - FIXME SCSIOP_MODE_SENSE\n");
                // FIXME Get from registry WriteProtect for StorageDevicePolicies;
                // L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\StorageDevicePolicies"
                // QueryTable[0].Name = L"WriteProtect"
            }
 
            IoMarkIrpPending(Irp);
            Request->SrbStatus = SRB_STATUS_PENDING;
 
            // add the request
            if (!USBSTOR_QueueAddIrp(PDODeviceExtension->LowerDeviceObject, Irp))
            {
                IoStartPacket(PDODeviceExtension->LowerDeviceObject, Irp, &Request->QueueSortKey, USBSTOR_CancelIo);
            }
 
            return STATUS_PENDING;
        }
        case SRB_FUNCTION_RELEASE_DEVICE:
        {
            DPRINT1("SRB_FUNCTION_RELEASE_DEVICE\n");
            ASSERT(PDODeviceExtension->Claimed == TRUE);
 
            // release claim
            PDODeviceExtension->Claimed = FALSE;
            Status = STATUS_SUCCESS;
            break;
        }
        case SRB_FUNCTION_CLAIM_DEVICE:
        {
            DPRINT1("SRB_FUNCTION_CLAIM_DEVICE\n");
 
            // check if the device has been claimed
            if (PDODeviceExtension->Claimed)
            {
                // device has already been claimed
                Status = STATUS_DEVICE_BUSY;
                Request->SrbStatus = SRB_STATUS_BUSY;
                break;
            }
 
            // claim device
            PDODeviceExtension->Claimed = TRUE;
 
            // output device object
            Request->DataBuffer = DeviceObject;
 
            Status = STATUS_SUCCESS;
            break;
        }
        case SRB_FUNCTION_RELEASE_QUEUE:
        {
            DPRINT1("SRB_FUNCTION_RELEASE_QUEUE\n");
 
            USBSTOR_QueueRelease(PDODeviceExtension->LowerDeviceObject);
 
            Request->SrbStatus = SRB_STATUS_SUCCESS;
            Status = STATUS_SUCCESS;
            break;
        }
 
        case SRB_FUNCTION_SHUTDOWN:
        case SRB_FUNCTION_FLUSH:
        case SRB_FUNCTION_FLUSH_QUEUE:
        {
            DPRINT1("SRB_FUNCTION_FLUSH / SRB_FUNCTION_FLUSH_QUEUE / SRB_FUNCTION_SHUTDOWN\n");
 
            // wait for pending requests to finish
            USBSTOR_QueueWaitForPendingRequests(PDODeviceExtension->LowerDeviceObject);
 
            Request->SrbStatus = SRB_STATUS_SUCCESS;
            Status = STATUS_SUCCESS;
            break;
        }
        default:
        {
            //
            // not supported
            //
            Status = STATUS_NOT_SUPPORTED;
            Request->SrbStatus = SRB_STATUS_ERROR;
        }
    }
 
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

USBSTOR_PdoHandlePnp()

NTSTATUS USBSTOR_PdoHandlePnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 534 of file pdo.c.

{
    PIO_STACK_LOCATION IoStack;
    PPDO_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
    PDEVICE_CAPABILITIES Caps;
    ULONG bDelete;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->Common.IsFDO == FALSE);
 
    switch(IoStack->MinorFunction)
    {
       case IRP_MN_QUERY_DEVICE_RELATIONS:
       {
           Status = USBSTOR_PdoHandleDeviceRelations(DeviceObject, Irp);
           break;
       }
       case IRP_MN_QUERY_DEVICE_TEXT:
       {
           Status = USBSTOR_PdoHandleQueryDeviceText(DeviceObject, Irp);
           break;
       }
       case IRP_MN_QUERY_ID:
       {
           if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID)
           {
               Status = USBSTOR_PdoHandleQueryDeviceId(DeviceObject, Irp);
               break;
           }
           else if (IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
           {
               Status = USBSTOR_PdoHandleQueryHardwareId(DeviceObject, Irp);
               break;
           }
           else if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
           {
               Status = USBSTOR_PdoHandleQueryInstanceId(DeviceObject, Irp);
               break;
           }
           else if (IoStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
           {
               Status = USBSTOR_PdoHandleQueryCompatibleId(DeviceObject, Irp);
               break;
           }
 
           DPRINT1("USBSTOR_PdoHandlePnp: IRP_MN_QUERY_ID IdType %x unimplemented\n", IoStack->Parameters.QueryId.IdType);
           Status = STATUS_NOT_SUPPORTED;
           Irp->IoStatus.Information = 0;
           break;
       }
       case IRP_MN_REMOVE_DEVICE:
       {
           DPRINT("IRP_MN_REMOVE_DEVICE\n");
 
           if(*DeviceExtension->PDODeviceObject != NULL)
           {
               *DeviceExtension->PDODeviceObject = NULL;
               bDelete = TRUE;
           }
           else
           {
               // device object already marked for deletion
               bDelete = FALSE;
           }
 
           Irp->IoStatus.Status = STATUS_SUCCESS;
           IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
           if (bDelete)
           {
               IoDeleteDevice(DeviceObject);
           }
           return STATUS_SUCCESS;
       }
       case IRP_MN_QUERY_CAPABILITIES:
       {
           // just forward irp to lower device
            Status = STATUS_UNSUCCESSFUL;
 
            if (IoForwardIrpSynchronously(DeviceExtension->LowerDeviceObject, Irp))
            {
                Status = Irp->IoStatus.Status;
                ASSERT(Status == STATUS_SUCCESS);
                
                if (NT_SUCCESS(Status))
                {
                    // check if no unique id
                    Caps = (PDEVICE_CAPABILITIES)IoStack->Parameters.DeviceCapabilities.Capabilities;
                    Caps->UniqueID = FALSE; // no unique id is supported
                    Caps->Removable = TRUE; //FIXME
                }
            }
           break;
       }
       case IRP_MN_QUERY_REMOVE_DEVICE:
       case IRP_MN_QUERY_STOP_DEVICE:
       {
           if (DeviceExtension->Claimed)
           {
               Status = STATUS_UNSUCCESSFUL;
               DPRINT1("[USBSTOR] Request %x fails because device is still claimed\n", IoStack->MinorFunction);
           }
           else
               Status = STATUS_SUCCESS;
           break;
       }
       case IRP_MN_START_DEVICE:
       {
           // no-op for PDO
           Status = STATUS_SUCCESS;
           break;
       }
       case IRP_MN_SURPRISE_REMOVAL:
       {
           Status = STATUS_SUCCESS;
           break;
       }
       default:
        {
            // do nothing
            Status = Irp->IoStatus.Status;
        }
    }
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return Status;
}

USBSTOR_QueueAddIrp()

BOOLEAN USBSTOR_QueueAddIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 75 of file queue.c.

{
    PDRIVER_CANCEL OldDriverCancel;
    KIRQL OldLevel;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    BOOLEAN IrpListFreeze;
    BOOLEAN SrbProcessing;
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
    PSCSI_REQUEST_BLOCK Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    IoMarkIrpPending(Irp);
 
    KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
 
    SrbProcessing = FDODeviceExtension->IrpPendingCount != 0;
 
    if (SrbProcessing)
    {
        // add irp to queue
        InsertTailList(&FDODeviceExtension->IrpListHead, &Irp->Tail.Overlay.ListEntry);
    }
 
    FDODeviceExtension->IrpPendingCount++;
    KeClearEvent(&FDODeviceExtension->NoPendingRequests);
 
    // check if queue is freezed
    IrpListFreeze = BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE);
 
    KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
 
    // synchronize with cancellations by holding the cancel lock
    IoAcquireCancelSpinLock(&Irp->CancelIrql);
 
    if (SrbProcessing)
    {
        ASSERT(FDODeviceExtension->ActiveSrb != NULL);
 
        OldDriverCancel = IoSetCancelRoutine(Irp, USBSTOR_Cancel);
    }
    else
    {
        ASSERT(FDODeviceExtension->ActiveSrb == NULL);
 
        FDODeviceExtension->ActiveSrb = Request;
        OldDriverCancel = IoSetCancelRoutine(Irp, USBSTOR_CancelIo);
    }
 
    // check if the irp has already been cancelled
    if (Irp->Cancel && OldDriverCancel == NULL)
    {
        // cancel irp
        Irp->CancelRoutine(DeviceObject, Irp);
        return FALSE;
    }
 
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    // if list is freezed, dont start this packet
    DPRINT("IrpListFreeze: %lu IrpPendingCount %lu\n", IrpListFreeze, FDODeviceExtension->IrpPendingCount);
 
    return (IrpListFreeze || SrbProcessing);
}

USBSTOR_QueueInitialize()

VOID USBSTOR_QueueInitialize

(

PFDO_DEVICE_EXTENSION

FDODeviceExtension

)

Definition at line 17 of file queue.c.

{
    ASSERT(FDODeviceExtension->Common.IsFDO);
    KeInitializeSpinLock(&FDODeviceExtension->IrpListLock);
    InitializeListHead(&FDODeviceExtension->IrpListHead);
    KeInitializeEvent(&FDODeviceExtension->NoPendingRequests, NotificationEvent, TRUE);
}

USBSTOR_QueueNextRequest()

VOID USBSTOR_QueueNextRequest

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 220 of file queue.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PIRP Irp;
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    // check first if there's already a request pending or the queue is frozen
    if (FDODeviceExtension->ActiveSrb != NULL ||
        BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE))
    {
        // no work to do yet
        return;
    }
 
    // remove first irp from list
    Irp = USBSTOR_RemoveIrp(DeviceObject);
 
    // is there an irp pending
    if (!Irp)
    {
        // no work to do
        IoStartNextPacket(DeviceObject, TRUE);
        return;
    }
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
    ASSERT(Request);
 
    FDODeviceExtension->ActiveSrb = Request;
 
    // start next packet
    IoStartPacket(DeviceObject, Irp, &Request->QueueSortKey, USBSTOR_CancelIo);
    IoStartNextPacket(DeviceObject, TRUE);
}

USBSTOR_QueueRelease()

VOID USBSTOR_QueueRelease

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 262 of file queue.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PIRP Irp;
    KIRQL OldLevel;
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
 
    // clear freezed status
    FDODeviceExtension->Flags &= ~USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE;
 
    KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
 
    // grab newest irp
    Irp = USBSTOR_RemoveIrp(DeviceObject);
 
    if (!Irp)
    {
        return;
    }
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
 
    IoStartPacket(DeviceObject,
                  Irp,
                  &Request->QueueSortKey,
                  USBSTOR_CancelIo);
}

USBSTOR_QueueResetDevice()

VOID NTAPI USBSTOR_QueueResetDevice

(

IN PFDO_DEVICE_EXTENSION

FDODeviceExtension

)

Definition at line 148 of file error.c.

{
    KIRQL OldIrql;
 
    DPRINT("USBSTOR_QueueResetDevice\n");
 
    KeAcquireSpinLock(&FDODeviceExtension->CommonLock, &OldIrql);
    FDODeviceExtension->Flags |= USBSTOR_FDO_FLAGS_DEVICE_RESETTING;
    KeReleaseSpinLock(&FDODeviceExtension->CommonLock, OldIrql);
 
    IoQueueWorkItem(FDODeviceExtension->ResetDeviceWorkItem,
                    USBSTOR_ResetDeviceWorkItemRoutine,
                    CriticalWorkQueue,
                    NULL);
}

Referenced by USBSTOR_CBWCompletionRoutine(), USBSTOR_CSWCompletionRoutine(), and USBSTOR_DataCompletionRoutine().

USBSTOR_QueueResetPipe()

VOID NTAPI USBSTOR_QueueResetPipe

(

IN PFDO_DEVICE_EXTENSION

FDODeviceExtension

)

Definition at line 135 of file error.c.

{
    DPRINT("USBSTOR_QueueResetPipe\n");
 
    IoQueueWorkItem(FDODeviceExtension->ResetDeviceWorkItem,
                    USBSTOR_ResetPipeWorkItemRoutine,
                    CriticalWorkQueue,
                    FDODeviceExtension);
}

Referenced by USBSTOR_CSWCompletionRoutine(), and USBSTOR_DataCompletionRoutine().

USBSTOR_QueueTerminateRequest()

VOID USBSTOR_QueueTerminateRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 186 of file queue.c.

{
    KIRQL OldLevel;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
    PSCSI_REQUEST_BLOCK Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)FDODeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
 
    FDODeviceExtension->IrpPendingCount--;
 
    // check if this was our current active SRB
    if (FDODeviceExtension->ActiveSrb == Request)
    {
        // indicate processing is completed
        FDODeviceExtension->ActiveSrb = NULL;
    }
 
    // Set the event if nothing else is pending
    if (FDODeviceExtension->IrpPendingCount == 0 &&
        FDODeviceExtension->ActiveSrb == NULL)
    {
        KeSetEvent(&FDODeviceExtension->NoPendingRequests, IO_NO_INCREMENT, FALSE);
    }
 
    KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
}

USBSTOR_QueueWaitForPendingRequests()

VOID USBSTOR_QueueWaitForPendingRequests

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 171 of file queue.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    KeWaitForSingleObject(&FDODeviceExtension->NoPendingRequests,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
}

USBSTOR_ResetDevice()

NTSTATUS USBSTOR_ResetDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PFDO_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 219 of file misc.c.

{
    NTSTATUS Status;
 
    Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_RESET_DEVICE, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_OUT, 0, NULL);
    return Status;
}

USBSTOR_ResetPipeWithHandle()

NTSTATUS USBSTOR_ResetPipeWithHandle	(	IN PDEVICE_OBJECT	DeviceObject,
		IN USBD_PIPE_HANDLE	PipeHandle
	)

Definition at line 46 of file error.c.

{
    PURB Urb;
    NTSTATUS Status;
 
    DPRINT("Allocating URB\n");
    Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_PIPE_REQUEST));
    if (!Urb)
    {
        DPRINT1("OutofMemory!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Urb->UrbPipeRequest.Hdr.Length = sizeof(struct _URB_PIPE_REQUEST);
    Urb->UrbPipeRequest.Hdr.Function = URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL;
    Urb->UrbPipeRequest.PipeHandle = PipeHandle;
 
    // send the request
    DPRINT1("Sending Request DeviceObject %p, Urb %p\n", DeviceObject, Urb);
    Status = USBSTOR_SyncUrbRequest(DeviceObject, Urb);
 
    FreeItem(Urb);
    return Status;
}

USBSTOR_SelectConfigurationAndInterface()

NTSTATUS USBSTOR_SelectConfigurationAndInterface	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PFDO_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 234 of file descriptor.c.

{
    PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
    PUSB_ENDPOINT_DESCRIPTOR InEndpointDescriptor, OutEndpointDescriptor;
    NTSTATUS Status;
    PURB Urb;
    PUSBD_INTERFACE_LIST_ENTRY InterfaceList;
 
    Status = USBSTOR_ScanConfigurationDescriptor(DeviceExtension->ConfigurationDescriptor, &InterfaceDescriptor, &InEndpointDescriptor, &OutEndpointDescriptor);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    // now allocate one interface entry and terminating null entry
    InterfaceList = (PUSBD_INTERFACE_LIST_ENTRY)AllocateItem(PagedPool, sizeof(USBD_INTERFACE_LIST_ENTRY) * 2);
    if (!InterfaceList)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // initialize interface list entry
    InterfaceList[0].InterfaceDescriptor = InterfaceDescriptor;
 
    // now allocate the urb
    Urb = USBD_CreateConfigurationRequestEx(DeviceExtension->ConfigurationDescriptor, InterfaceList);
    if (!Urb)
    {
        FreeItem(InterfaceList);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
 
    ASSERT(InterfaceList[0].Interface);
 
    // submit urb
    Status = USBSTOR_SyncUrbRequest(DeviceExtension->LowerDeviceObject, Urb);
    if (!NT_SUCCESS(Status))
    {
        // failed to set configuration
        DPRINT1("USBSTOR_SelectConfiguration failed to set interface %x\n", Status);
        FreeItem(InterfaceList);
        ExFreePoolWithTag(Urb, 0);
        return Status;
    }
 
    // backup interface information
    DeviceExtension->InterfaceInformation = (PUSBD_INTERFACE_INFORMATION)AllocateItem(NonPagedPool, Urb->UrbSelectConfiguration.Interface.Length);
    if (!DeviceExtension->InterfaceInformation)
    {
        FreeItem(InterfaceList);
        ExFreePoolWithTag(Urb, 0);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // copy interface information
    RtlCopyMemory(DeviceExtension->InterfaceInformation, &Urb->UrbSelectConfiguration.Interface, Urb->UrbSelectConfiguration.Interface.Length);
 
    // store pipe handle
    DeviceExtension->ConfigurationHandle = Urb->UrbSelectConfiguration.ConfigurationHandle;
 
    // now prepare interface urb
    UsbBuildSelectInterfaceRequest(Urb, GET_SELECT_INTERFACE_REQUEST_SIZE(InterfaceDescriptor->bNumEndpoints), DeviceExtension->ConfigurationHandle, InterfaceDescriptor->bInterfaceNumber, InterfaceDescriptor->bAlternateSetting);
 
    // copy interface information structure back - as offset for SelectConfiguration / SelectInterface request do differ
    RtlCopyMemory(&Urb->UrbSelectInterface.Interface, DeviceExtension->InterfaceInformation, DeviceExtension->InterfaceInformation->Length);
 
    // now select the interface
    Status = USBSTOR_SyncUrbRequest(DeviceExtension->LowerDeviceObject, Urb);
    if (NT_SUCCESS(Status))
    {
        // update configuration info
        ASSERT(Urb->UrbSelectInterface.Interface.Length == DeviceExtension->InterfaceInformation->Length);
        RtlCopyMemory(DeviceExtension->InterfaceInformation, &Urb->UrbSelectInterface.Interface, Urb->UrbSelectInterface.Interface.Length);
    }
 
    FreeItem(InterfaceList);
    ExFreePoolWithTag(Urb, 0);
 
    return Status;
}

USBSTOR_SendCSWRequest()

NTSTATUS USBSTOR_SendCSWRequest	(	PFDO_DEVICE_EXTENSION	FDODeviceExtension,
		PIRP	Irp
	)

Definition at line 242 of file scsi.c.

{
    return USBSTOR_IssueBulkOrInterruptRequest(FDODeviceExtension,
                                               Irp,
                                               FDODeviceExtension->InterfaceInformation->Pipes[FDODeviceExtension->BulkInPipeIndex].PipeHandle,
                                               USBD_TRANSFER_DIRECTION_IN,
                                               sizeof(CSW),
                                               &FDODeviceExtension->CurrentIrpContext.csw,
                                               NULL,
                                               USBSTOR_CSWCompletionRoutine);
}

Referenced by USBSTOR_CBWCompletionRoutine(), USBSTOR_DataCompletionRoutine(), and USBSTOR_ResetPipeWorkItemRoutine().

USBSTOR_StartIo()

VOID NTAPI USBSTOR_StartIo	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 300 of file queue.c.

{
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    KIRQL OldLevel;
    BOOLEAN ResetInProgress;
 
    DPRINT("USBSTOR_StartIo\n");
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    IoAcquireCancelSpinLock(&OldLevel);
 
    IoSetCancelRoutine(Irp, NULL);
 
    // check if the irp has been cancelled
    if (Irp->Cancel)
    {
        IoReleaseCancelSpinLock(OldLevel);
 
        Irp->IoStatus.Status = STATUS_CANCELLED;
        Irp->IoStatus.Information = 0;
 
        USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        USBSTOR_QueueNextRequest(DeviceObject);
        return;
    }
 
    IoReleaseCancelSpinLock(OldLevel);
 
    KeAcquireSpinLock(&FDODeviceExtension->CommonLock, &OldLevel);
    ResetInProgress = BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_DEVICE_RESETTING);
    KeReleaseSpinLock(&FDODeviceExtension->CommonLock, OldLevel);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)IoStack->DeviceObject->DeviceExtension;
    Request = IoStack->Parameters.Scsi.Srb;
    ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
    if (ResetInProgress)
    {
        // hard reset is in progress
        Request->SrbStatus = SRB_STATUS_NO_DEVICE;
        Request->DataTransferLength = 0;
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
        USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        USBSTOR_QueueNextRequest(DeviceObject);
        return;
    }
 
    USBSTOR_HandleExecuteSCSI(IoStack->DeviceObject, Irp);
 
    // FIXME: handle error
}

USBSTOR_SyncUrbRequest()

NTSTATUS USBSTOR_SyncUrbRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PURB	UrbRequest
	)

Definition at line 83 of file misc.c.

{
    PIRP Irp;
    PIO_STACK_LOCATION IoStack;
    KEVENT Event;
    NTSTATUS Status;
 
    Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
    if (!Irp)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    IoStack = IoGetNextIrpStackLocation(Irp);
 
    // initialize stack location
    IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
    IoStack->Parameters.Others.Argument1 = (PVOID)UrbRequest;
    IoStack->Parameters.DeviceIoControl.InputBufferLength = UrbRequest->UrbHeader.Length;
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    IoSetCompletionRoutine(Irp, USBSTOR_SyncForwardIrpCompletionRoutine, &Event, TRUE, TRUE, TRUE);
 
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = Irp->IoStatus.Status;
    }
 
    IoFreeIrp(Irp);
    return Status;
}

USBSTOR_TimerRoutine()

VOID NTAPI USBSTOR_TimerRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PVOID	Context
	)

Definition at line 205 of file error.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    BOOLEAN ResetDevice = FALSE;
    PERRORHANDLER_WORKITEM_DATA WorkItemData;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)Context;
    DPRINT1("[USBSTOR] TimerRoutine entered\n");
    // DPRINT1("[USBSTOR] ActiveSrb %p ResetInProgress %x LastTimerActiveSrb %p\n", FDODeviceExtension->ActiveSrb, FDODeviceExtension->ResetInProgress, FDODeviceExtension->LastTimerActiveSrb);
 
    KeAcquireSpinLockAtDpcLevel(&FDODeviceExtension->IrpListLock);
 
    // is there an active srb and no global reset is in progress
    if (FDODeviceExtension->ActiveSrb && /* FDODeviceExtension->ResetInProgress == FALSE && */ FDODeviceExtension->TimerWorkQueueEnabled)
    {
        if (FDODeviceExtension->LastTimerActiveSrb != NULL && FDODeviceExtension->LastTimerActiveSrb == FDODeviceExtension->ActiveSrb)
        {
            // check if empty
            DPRINT1("[USBSTOR] ActiveSrb %p hang detected\n", FDODeviceExtension->ActiveSrb);
            ResetDevice = TRUE;
        }
        else
        {
            // update pointer
            FDODeviceExtension->LastTimerActiveSrb = FDODeviceExtension->ActiveSrb;
        }
    }
    else
    {
        // reset srb
        FDODeviceExtension->LastTimerActiveSrb = NULL;
    }
 
    KeReleaseSpinLockFromDpcLevel(&FDODeviceExtension->IrpListLock);
 
 
    if (ResetDevice && FDODeviceExtension->TimerWorkQueueEnabled && FDODeviceExtension->SrbErrorHandlingActive == FALSE)
    {
        WorkItemData = ExAllocatePoolWithTag(NonPagedPool,
                                             sizeof(ERRORHANDLER_WORKITEM_DATA),
                                             USB_STOR_TAG);
        if (WorkItemData)
        {
           // Initialize and queue the work item to handle the error
           ExInitializeWorkItem(&WorkItemData->WorkQueueItem,
                                 USBSTOR_TimerWorkerRoutine,
                                 WorkItemData);
 
           WorkItemData->DeviceObject = FDODeviceExtension->FunctionalDeviceObject;
 
           DPRINT1("[USBSTOR] Queing Timer WorkItem\n");
           ExQueueWorkItem(&WorkItemData->WorkQueueItem, DelayedWorkQueue);
        }
     }
}