precomp.h File Reference

#include <wdm.h>
#include <ntddk.h>
#include <ntintsafe.h>
#include <ntstrsafe.h>
#include <stdio.h>
#include <memory.h>
#include <storport.h>
#include <ntddscsi.h>
#include <ntdddisk.h>
#include <mountdev.h>
#include <wdmguid.h>

Include dependency graph for precomp.h:

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

Go to the source code of this file.

Classes
struct	_DRIVER_INIT_DATA
struct	_DRIVER_OBJECT_EXTENSION
struct	_MINIPORT_DEVICE_EXTENSION
struct	_MINIPORT
struct	_UNIT_DATA
struct	_TIMER_ENTRY
struct	_PDO_IO_FLOW_CONTROL
struct	_FDO_IO_FLOW_CONTROL
struct	_STARVED_REQUEST_QUEUE
struct	_FDO_DEVICE_EXTENSION
struct	_PDO_DEVICE_EXTENSION
struct	_QUEUED_REQUEST_REFERENCE
struct	_LUN_DESCRIPTOR
struct	_REPORT_LUNS_DATA

Macros
#define	_STORPORT_
#define	TAG_GLOBAL_DATA   'DGtS'
#define	TAG_INIT_DATA   'DItS'
#define	TAG_DEVICE_RELATION   'RDtS'
#define	TAG_DEVICE_ID   'DItS'
#define	TAG_DEVICE_TEXT   'XTtS'
#define	TAG_MINIPORT_DATA   'DMtS'
#define	TAG_ACCRESS_RANGE   'RAtS'
#define	TAG_RESOURCE_LIST   'LRtS'
#define	TAG_ADDRESS_MAPPING   'MAtS'
#define	TAG_INQUIRY_DATA   'QItS'
#define	TAG_REPORT_LUN_DATA   'LRtS'
#define	TAG_SENSE_DATA   'NStS'
#define	TAG_QUEUED_REQUEST   'RQtS'
#define	TAG_SRB_EXTENSION   'XStS'
#define	SET_FLAG(Flags, Bit)   ((Flags) |= (Bit))
#define	CLEAR_FLAG(Flags, Bit)   ((Flags) &= ~(Bit))
#define	TEST_FLAG(Flags, Bit)   (((Flags) & (Bit)) != 0)

Typedefs
typedef struct _DRIVER_INIT_DATA	DRIVER_INIT_DATA
typedef struct _DRIVER_INIT_DATA *	PDRIVER_INIT_DATA
typedef struct _DRIVER_OBJECT_EXTENSION	DRIVER_OBJECT_EXTENSION
typedef struct _DRIVER_OBJECT_EXTENSION *	PDRIVER_OBJECT_EXTENSION
typedef struct _MINIPORT_DEVICE_EXTENSION	MINIPORT_DEVICE_EXTENSION
typedef struct _MINIPORT_DEVICE_EXTENSION *	PMINIPORT_DEVICE_EXTENSION
typedef struct _MINIPORT	MINIPORT
typedef struct _MINIPORT *	PMINIPORT
typedef struct _UNIT_DATA	UNIT_DATA
typedef struct _UNIT_DATA *	PUNIT_DATA
typedef struct _TIMER_ENTRY	TIMER_ENTRY
typedef struct _TIMER_ENTRY *	PTIMER_ENTRY
typedef struct _PDO_IO_FLOW_CONTROL	PDO_IO_FLOW_CONTROL
typedef struct _PDO_IO_FLOW_CONTROL *	PPDO_IO_FLOW_CONTROL
typedef struct _FDO_IO_FLOW_CONTROL	FDO_IO_FLOW_CONTROL
typedef struct _FDO_IO_FLOW_CONTROL *	PFDO_IO_FLOW_CONTROL
typedef struct _STARVED_REQUEST_QUEUE	STARVED_REQUEST_QUEUE
typedef struct _STARVED_REQUEST_QUEUE *	PSTARVED_REQUEST_QUEUE
typedef struct _FDO_DEVICE_EXTENSION	FDO_DEVICE_EXTENSION
typedef struct _FDO_DEVICE_EXTENSION *	PFDO_DEVICE_EXTENSION
typedef struct _PDO_DEVICE_EXTENSION	PDO_DEVICE_EXTENSION
typedef struct _PDO_DEVICE_EXTENSION *	PPDO_DEVICE_EXTENSION
typedef struct _QUEUED_REQUEST_REFERENCE	QUEUED_REQUEST_REFERENCE
typedef struct _QUEUED_REQUEST_REFERENCE *	PQUEUED_REQUEST_REFERENCE
typedef struct _LUN_DESCRIPTOR	LUN_DESCRIPTOR
typedef struct _LUN_DESCRIPTOR *	PLUN_DESCRIPTOR
typedef struct _REPORT_LUNS_DATA	REPORT_LUNS_DATA
typedef struct _REPORT_LUNS_DATA *	PREPORT_LUNS_DATA

Enumerations
enum	DEVICE_STATE {   dsStopped , dsStarted , dsPaused , dsRemoved ,   dsSurpriseRemoved , NotStarted = 0 , Started , StopPending ,   Stopped , RemovePending , SurpriseRemovePending , Deleted ,   dsStopped , dsStarted , dsPaused , dsRemoved ,   dsSurpriseRemoved , dsStopped , dsStarted , dsPaused ,   dsRemoved , dsSurpriseRemoved }
enum	EXTENSION_TYPE { InvalidExtension = 0 , DriverExtension , FdoExtension , PdoExtension }

Functions
NTSTATUS	PortInitializeStarvedRequestQueue (_In_ PSTARVED_REQUEST_QUEUE Queue)
VOID	PortQueueStarvedRequest (_In_ PFDO_DEVICE_EXTENSION FdoExtension, _In_ PIRP Irp)
	Queues a request that could not allocate its private contexts.
VOID	PortRetryStarvedRequest (_In_ PFDO_DEVICE_EXTENSION FdoExtension)
	Retries one queued request, so each completion lets exactly one through.
VOID	PortFlushStarvedRequests (_In_ PFDO_DEVICE_EXTENSION FdoExtension)
	Fails every queued request, for when the adapter goes away.
VOID	PortAllocateRequestReserve (_In_ PFDO_DEVICE_EXTENSION FdoExtension)
	Reserves the memory a single request needs, so IO can still be issued out of pool.
VOID	PortFreeRequestReserve (_In_ PFDO_DEVICE_EXTENSION FdoExtension)
	Releases the reserve. No request may be using it anymore.
PPDO_DEVICE_EXTENSION	FdoFindLun (_In_ PFDO_DEVICE_EXTENSION FdoExtension, _In_ ULONG Bus, _In_ ULONG Target, _In_ ULONG Lun)
NTSTATUS NTAPI	PortFdoScsi (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS NTAPI	PortFdoPnp (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS NTAPI	PortFdoDeviceControl (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS NTAPI	PortPdoDeviceControl (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS	MiniportInitialize (_In_ PMINIPORT Miniport, _In_ PFDO_DEVICE_EXTENSION DeviceExtension, _In_ PHW_INITIALIZATION_DATA HwInitializationData)
NTSTATUS	MiniportFindAdapter (_In_ PMINIPORT Miniport)
NTSTATUS	MiniportHwInitialize (_In_ PMINIPORT Miniport)
BOOLEAN	MiniportHwInterrupt (_In_ PMINIPORT Miniport)
BOOLEAN	MiniportStartIo (_In_ PMINIPORT Miniport, _In_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS NTAPI	ForwardIrpAndForget (_In_ PDEVICE_OBJECT LowerDevice, _In_ PIRP Irp)
INTERFACE_TYPE	GetBusInterface (PDEVICE_OBJECT DeviceObject)
PCM_RESOURCE_LIST	CopyResourceList (POOL_TYPE PoolType, PCM_RESOURCE_LIST Source)
NTSTATUS	QueryBusInterface (PDEVICE_OBJECT DeviceObject, PGUID Guid, USHORT Size, USHORT Version, PBUS_INTERFACE_STANDARD Interface, PVOID InterfaceSpecificData)
BOOLEAN	TranslateResourceListAddress (PFDO_DEVICE_EXTENSION DeviceExtension, INTERFACE_TYPE BusType, ULONG SystemIoBusNumber, STOR_PHYSICAL_ADDRESS IoAddress, ULONG NumberOfBytes, BOOLEAN InIoSpace, PPHYSICAL_ADDRESS TranslatedAddress)
NTSTATUS	GetResourceListInterrupt (PFDO_DEVICE_EXTENSION DeviceExtension, PULONG Vector, PKIRQL Irql, KINTERRUPT_MODE *InterruptMode, PBOOLEAN ShareVector, PKAFFINITY Affinity)
NTSTATUS	AllocateAddressMapping (PMAPPED_ADDRESS *MappedAddressList, STOR_PHYSICAL_ADDRESS IoAddress, PVOID MappedAddress, ULONG NumberOfBytes, ULONG BusNumber)
VOID NTAPI	SimpleTimerCallbackDpcRoutine (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
VOID NTAPI	TimerCallbackDpcRoutine (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
PCSTR	GetDeviceType (_In_ PINQUIRYDATA InquiryData)
PCSTR	GetGenericType (_In_ PINQUIRYDATA InquiryData)
NTSTATUS	PortCreatePdo (_In_ PFDO_DEVICE_EXTENSION FdoExtension, _In_ ULONG Bus, _In_ ULONG Target, _In_ ULONG Lun, _Out_ PPDO_DEVICE_EXTENSION *PdoExtension)
NTSTATUS	PortDeletePdo (_In_ PPDO_DEVICE_EXTENSION PdoExtension)
NTSTATUS NTAPI	PortPdoPnp (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
VOID	StorpSrbFreeRequestReference (_In_ PSCSI_REQUEST_BLOCK Srb)
	Frees an SRB's Request Reference and restore Srb->OriginalRequest field to IRP. This function does not check if Srb->OriginalRequest is actually an request reference, and you must determine it by other means.
NTSTATUS	PortPdoIssueRequest (_In_ PPDO_DEVICE_EXTENSION PdoExtension, _In_ PQUEUED_REQUEST_REFERENCE RequestReference)
BOOLEAN	PortPdoScheduleRequestFlowControlled (_In_ PPDO_DEVICE_EXTENSION PdoExtension, _In_ PFDO_DEVICE_EXTENSION FdoExtension, _In_ PQUEUED_REQUEST_REFERENCE RequestReference)
	Schedules an outstanding request and return a boolean value to indicate if the request can be immediately issued.
NTSTATUS NTAPI	PortPdoScsi (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
VOID NTAPI	PortCompletionDpc (_In_ PKDPC Dpc, _In_ PVOID Context, _In_ PVOID SystemArgument1, _In_ PVOID SystemArgument2)
PHW_INITIALIZATION_DATA	PortGetDriverInitData (PDRIVER_OBJECT_EXTENSION DriverExtension, INTERFACE_TYPE InterfaceType)
NTSTATUS NTAPI	DriverEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)

Macro Definition Documentation

_STORPORT_

#define _STORPORT_

Definition at line 19 of file precomp.h.

CLEAR_FLAG

#define CLEAR_FLAG	(		Flags,
			Bit
	)		((Flags) &= ~(Bit))

Definition at line 44 of file precomp.h.

SET_FLAG

#define SET_FLAG	(		Flags,
			Bit
	)		((Flags) |= (Bit))

Definition at line 43 of file precomp.h.

TAG_ACCRESS_RANGE

#define TAG_ACCRESS_RANGE   'RAtS'

Definition at line 34 of file precomp.h.

TAG_ADDRESS_MAPPING

#define TAG_ADDRESS_MAPPING   'MAtS'

Definition at line 36 of file precomp.h.

TAG_DEVICE_ID

#define TAG_DEVICE_ID   'DItS'

Definition at line 31 of file precomp.h.

TAG_DEVICE_RELATION

#define TAG_DEVICE_RELATION   'RDtS'

Definition at line 30 of file precomp.h.

TAG_DEVICE_TEXT

#define TAG_DEVICE_TEXT   'XTtS'

Definition at line 32 of file precomp.h.

TAG_GLOBAL_DATA

#define TAG_GLOBAL_DATA   'DGtS'

Definition at line 28 of file precomp.h.

TAG_INIT_DATA

#define TAG_INIT_DATA   'DItS'

Definition at line 29 of file precomp.h.

TAG_INQUIRY_DATA

#define TAG_INQUIRY_DATA   'QItS'

Definition at line 37 of file precomp.h.

TAG_MINIPORT_DATA

#define TAG_MINIPORT_DATA   'DMtS'

Definition at line 33 of file precomp.h.

TAG_QUEUED_REQUEST

#define TAG_QUEUED_REQUEST   'RQtS'

Definition at line 40 of file precomp.h.

TAG_REPORT_LUN_DATA

#define TAG_REPORT_LUN_DATA   'LRtS'

Definition at line 38 of file precomp.h.

TAG_RESOURCE_LIST

#define TAG_RESOURCE_LIST   'LRtS'

Definition at line 35 of file precomp.h.

TAG_SENSE_DATA

#define TAG_SENSE_DATA   'NStS'

Definition at line 39 of file precomp.h.

TAG_SRB_EXTENSION

#define TAG_SRB_EXTENSION   'XStS'

Definition at line 41 of file precomp.h.

TEST_FLAG

#define TEST_FLAG	(		Flags,
			Bit
	)		(((Flags) & (Bit)) != 0)

Definition at line 45 of file precomp.h.

Typedef Documentation

DRIVER_INIT_DATA

typedef struct _DRIVER_INIT_DATA DRIVER_INIT_DATA

DRIVER_OBJECT_EXTENSION

typedef struct _DRIVER_OBJECT_EXTENSION DRIVER_OBJECT_EXTENSION

FDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION FDO_DEVICE_EXTENSION

FDO_IO_FLOW_CONTROL

typedef struct _FDO_IO_FLOW_CONTROL FDO_IO_FLOW_CONTROL

LUN_DESCRIPTOR

typedef struct _LUN_DESCRIPTOR LUN_DESCRIPTOR

MINIPORT

typedef struct _MINIPORT MINIPORT

MINIPORT_DEVICE_EXTENSION

typedef struct _MINIPORT_DEVICE_EXTENSION MINIPORT_DEVICE_EXTENSION

PDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION PDO_DEVICE_EXTENSION

PDO_IO_FLOW_CONTROL

typedef struct _PDO_IO_FLOW_CONTROL PDO_IO_FLOW_CONTROL

PDRIVER_INIT_DATA

typedef struct _DRIVER_INIT_DATA * PDRIVER_INIT_DATA

PDRIVER_OBJECT_EXTENSION

typedef struct _DRIVER_OBJECT_EXTENSION * PDRIVER_OBJECT_EXTENSION

PFDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION

PFDO_IO_FLOW_CONTROL

typedef struct _FDO_IO_FLOW_CONTROL * PFDO_IO_FLOW_CONTROL

PLUN_DESCRIPTOR

typedef struct _LUN_DESCRIPTOR * PLUN_DESCRIPTOR

PMINIPORT

typedef struct _MINIPORT * PMINIPORT

PMINIPORT_DEVICE_EXTENSION

typedef struct _MINIPORT_DEVICE_EXTENSION * PMINIPORT_DEVICE_EXTENSION

PPDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION

PPDO_IO_FLOW_CONTROL

typedef struct _PDO_IO_FLOW_CONTROL * PPDO_IO_FLOW_CONTROL

PQUEUED_REQUEST_REFERENCE

typedef struct _QUEUED_REQUEST_REFERENCE * PQUEUED_REQUEST_REFERENCE

PREPORT_LUNS_DATA

typedef struct _REPORT_LUNS_DATA * PREPORT_LUNS_DATA

PSTARVED_REQUEST_QUEUE

typedef struct _STARVED_REQUEST_QUEUE * PSTARVED_REQUEST_QUEUE

PTIMER_ENTRY

typedef struct _TIMER_ENTRY * PTIMER_ENTRY

PUNIT_DATA

typedef struct _UNIT_DATA * PUNIT_DATA

QUEUED_REQUEST_REFERENCE

typedef struct _QUEUED_REQUEST_REFERENCE QUEUED_REQUEST_REFERENCE

REPORT_LUNS_DATA

typedef struct _REPORT_LUNS_DATA REPORT_LUNS_DATA

STARVED_REQUEST_QUEUE

typedef struct _STARVED_REQUEST_QUEUE STARVED_REQUEST_QUEUE

TIMER_ENTRY

typedef struct _TIMER_ENTRY TIMER_ENTRY

UNIT_DATA

typedef struct _UNIT_DATA UNIT_DATA

Enumeration Type Documentation

DEVICE_STATE

enum DEVICE_STATE

Enumerator
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved
NotStarted
Started
StopPending
Stopped
RemovePending
SurpriseRemovePending
Deleted
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved

Definition at line 47 of file precomp.h.

{
    dsStopped,
    dsStarted,
    dsPaused,
    dsRemoved,
    dsSurpriseRemoved
} DEVICE_STATE;

EXTENSION_TYPE

enum EXTENSION_TYPE

Enumerator
InvalidExtension
DriverExtension
FdoExtension
PdoExtension

Definition at line 56 of file precomp.h.

{
    InvalidExtension = 0,
    DriverExtension,
    FdoExtension,
    PdoExtension
} EXTENSION_TYPE;

Function Documentation

AllocateAddressMapping()

NTSTATUS AllocateAddressMapping	(	PMAPPED_ADDRESS *	MappedAddressList,
		STOR_PHYSICAL_ADDRESS	IoAddress,
		PVOID	MappedAddress,
		ULONG	NumberOfBytes,
		ULONG	BusNumber
	)

Definition at line 291 of file misc.c.

{
    PMAPPED_ADDRESS Mapping;
 
    DPRINT1("AllocateAddressMapping()\n");
 
    Mapping = ExAllocatePoolWithTag(NonPagedPool,
                                    sizeof(MAPPED_ADDRESS),
                                    TAG_ADDRESS_MAPPING);
    if (Mapping == NULL)
    {
        DPRINT1("No memory!\n");
        return STATUS_NO_MEMORY;
    }
 
    RtlZeroMemory(Mapping, sizeof(MAPPED_ADDRESS));
 
    Mapping->NextMappedAddress = *MappedAddressList;
    *MappedAddressList = Mapping;
 
    Mapping->IoAddress = IoAddress;
    Mapping->MappedAddress = MappedAddress;
    Mapping->NumberOfBytes = NumberOfBytes;
    Mapping->BusNumber = BusNumber;
 
    return STATUS_SUCCESS;
}

Referenced by StorPortGetDeviceBase().

CopyResourceList()

PCM_RESOURCE_LIST CopyResourceList	(	POOL_TYPE	PoolType,
		PCM_RESOURCE_LIST	Source
	)

Definition at line 92 of file misc.c.

{
    PCM_RESOURCE_LIST Destination;
    ULONG Size;
 
    DPRINT1("CopyResourceList(%lu %p)\n",
            PoolType, Source);
 
    /* Get the size of the resource list */
    Size = GetResourceListSize(Source);
 
    /* Allocate a new buffer */
    Destination = ExAllocatePoolWithTag(PoolType,
                                        Size,
                                        TAG_RESOURCE_LIST);
    if (Destination == NULL)
        return NULL;
 
    /* Copy the resource list */
    RtlCopyMemory(Destination,
                  Source,
                  Size);
 
    return Destination;
}

Referenced by PortFdoStartDevice().

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ PUNICODE_STRING	RegistryPath
	)

Definition at line 1771 of file compbatt.c.

{
    /* Register add device routine */
    DriverObject->DriverExtension->AddDevice = CompBattAddDevice;
 
    /* Register other handlers */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = CompBattOpenClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = CompBattOpenClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = CompBattIoctl;
    DriverObject->MajorFunction[IRP_MJ_POWER] = CompBattPowerDispatch;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = CompBattSystemControl;
    DriverObject->MajorFunction[IRP_MJ_PNP] = CompBattPnpDispatch;
    return STATUS_SUCCESS;
}

FdoFindLun()

PPDO_DEVICE_EXTENSION FdoFindLun	(	_In_ PFDO_DEVICE_EXTENSION	FdoExtension,
		_In_ ULONG	Bus,
		_In_ ULONG	Target,
		_In_ ULONG	Lun
	)

Definition at line 1078 of file fdo.c.

{
    PPDO_DEVICE_EXTENSION PdoExtension;
    KLOCK_QUEUE_HANDLE LockHandle;
    PLIST_ENTRY PdoEntry;
 
    KeAcquireInStackQueuedSpinLock(&FdoExtension->PdoListLock, &LockHandle);
 
    for (PdoEntry = FdoExtension->PdoListHead.Flink;
         PdoEntry != &FdoExtension->PdoListHead;
         PdoEntry = PdoEntry->Flink)
    {
        PdoExtension = CONTAINING_RECORD(PdoEntry, PDO_DEVICE_EXTENSION, PdoListEntry);
 
        if (PdoExtension->Bus == Bus && PdoExtension->Target == Target &&
            PdoExtension->Lun == Lun)
        {
            KeReleaseInStackQueuedSpinLock(&LockHandle);
            return PdoExtension;
        }
    }
 
    KeReleaseInStackQueuedSpinLock(&LockHandle);
    return NULL;
}

Referenced by StorPortDeviceBusy(), StorPortDeviceReady(), and StorPortSetDeviceQueueDepth().

ForwardIrpAndForget()

NTSTATUS NTAPI ForwardIrpAndForget	(	_In_ PDEVICE_OBJECT	LowerDevice,
		_In_ PIRP	Irp
	)

Definition at line 5 of file utils.c.

{
    // this part of a structure is identical in both FDO and PDO
    PDEVICE_OBJECT LowerDevice = ((PFDO_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice;
 
    ASSERT(LowerDevice);
 
    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(LowerDevice, Irp);
}

GetBusInterface()

INTERFACE_TYPE GetBusInterface

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 33 of file misc.c.

{
    GUID Guid;
    ULONG Length;
    NTSTATUS Status;
 
    Status = IoGetDeviceProperty(DeviceObject,
                                 DevicePropertyBusTypeGuid,
                                 sizeof(Guid),
                                 &Guid,
                                 &Length);
    if (!NT_SUCCESS(Status))
        return InterfaceTypeUndefined;
 
    if (RtlCompareMemory(&Guid, &GUID_BUS_TYPE_PCMCIA, sizeof(GUID)) == sizeof(GUID))
        return PCMCIABus;
    else if (RtlCompareMemory(&Guid, &GUID_BUS_TYPE_PCI, sizeof(GUID)) == sizeof(GUID))
        return PCIBus;
    else if (RtlCompareMemory(&Guid, &GUID_BUS_TYPE_ISAPNP, sizeof(GUID)) == sizeof(GUID))
        return PNPISABus;
 
    return InterfaceTypeUndefined;
}

Referenced by PortFdoStartMiniport().

GetDeviceType()

PCSTR GetDeviceType

(

_In_ PINQUIRYDATA

InquiryData

)

Definition at line 7 of file scsitypes.h.

{
    switch (InquiryData->DeviceType)
    {
        case DIRECT_ACCESS_DEVICE:
            return "Disk";
        case SEQUENTIAL_ACCESS_DEVICE:
            return "Sequential";
        case PRINTER_DEVICE:
            return "Printer";
        case PROCESSOR_DEVICE:
            return "Processor";
        case WRITE_ONCE_READ_MULTIPLE_DEVICE:
            return "Worm";
        case READ_ONLY_DIRECT_ACCESS_DEVICE:
            return "CdRom";
        case SCANNER_DEVICE:
            return "Scanner";
        case OPTICAL_DEVICE:
            return "Optical";
        case MEDIUM_CHANGER:
            return "Changer";
        case COMMUNICATION_DEVICE:
            return "Net";
        case ARRAY_CONTROLLER_DEVICE:
            return "Array";
        case SCSI_ENCLOSURE_DEVICE:
            return "Enclosure";
        case REDUCED_BLOCK_DEVICE:
            return "RBC";
        case OPTICAL_CARD_READER_WRITER_DEVICE:
            return "CardReader";
        case BRIDGE_CONTROLLER_DEVICE:
            return "Bridge";
        default:
            return "Other";
    }
}

GetGenericType()

PCSTR GetGenericType

(

_In_ PINQUIRYDATA

InquiryData

)

Definition at line 49 of file scsitypes.h.

{
    switch (InquiryData->DeviceType)
    {
        case DIRECT_ACCESS_DEVICE:
            return "GenDisk";
        case PRINTER_DEVICE:
            return "GenPrinter";
        case WRITE_ONCE_READ_MULTIPLE_DEVICE:
            return "GenWorm";
        case READ_ONLY_DIRECT_ACCESS_DEVICE:
            return "GenCdRom";
        case SCANNER_DEVICE:
            return "GenScanner";
        case OPTICAL_DEVICE:
            return "GenOptical";
        case MEDIUM_CHANGER:
            return "ScsiChanger";
        case COMMUNICATION_DEVICE:
            return "ScsiNet";
        case ARRAY_CONTROLLER_DEVICE:
            return "ScsiArray";
        case SCSI_ENCLOSURE_DEVICE:
            return "ScsiEnclosure";
        case REDUCED_BLOCK_DEVICE:
            return "ScsiRBC";
        case OPTICAL_CARD_READER_WRITER_DEVICE:
            return "ScsiCardReader";
        case BRIDGE_CONTROLLER_DEVICE:
            return "ScsiBridge";
        default:
            return "ScsiOther";
    }
}

GetResourceListInterrupt()

NTSTATUS GetResourceListInterrupt	(	PFDO_DEVICE_EXTENSION	DeviceExtension,
		PULONG	Vector,
		PKIRQL	Irql,
		KINTERRUPT_MODE *	InterruptMode,
		PBOOLEAN	ShareVector,
		PKAFFINITY	Affinity
	)

Definition at line 242 of file misc.c.

{
    PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
    INT i, j;
 
    DPRINT1("GetResourceListInterrupt(%p)\n",
            DeviceExtension);
 
    FullDescriptor = DeviceExtension->TranslatedResources->List;
    for (i = 0; i < DeviceExtension->TranslatedResources->Count; i++)
    {
        for (j = 0; j < FullDescriptor->PartialResourceList.Count; j++)
        {
            PartialDescriptor = FullDescriptor->PartialResourceList.PartialDescriptors + j;
 
            switch (PartialDescriptor->Type)
            {
                case CmResourceTypeInterrupt:
                    DPRINT1("Interrupt: Level %lu  Vector %lu\n",
                            PartialDescriptor->u.Interrupt.Level,
                            PartialDescriptor->u.Interrupt.Vector);
 
                    *Vector = PartialDescriptor->u.Interrupt.Vector;
                    *Irql = (KIRQL)PartialDescriptor->u.Interrupt.Level;
                    *InterruptMode = (PartialDescriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED) ? Latched : LevelSensitive;
                    *ShareVector = (PartialDescriptor->ShareDisposition == CmResourceShareShared) ? TRUE : FALSE;
                    *Affinity = PartialDescriptor->u.Interrupt.Affinity;
 
                    return STATUS_SUCCESS;
            }
        }
 
        /* Advance to next CM_FULL_RESOURCE_DESCRIPTOR block in memory. */
        FullDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)(FullDescriptor->PartialResourceList.PartialDescriptors +
                                                        FullDescriptor->PartialResourceList.Count);
    }
 
    return STATUS_NOT_FOUND;
}

Referenced by PortFdoConnectInterrupt().

MiniportFindAdapter()

NTSTATUS MiniportFindAdapter

(

_In_ PMINIPORT

Miniport

)

Definition at line 294 of file miniport.c.

{
    BOOLEAN Reserved = FALSE;
    ULONG Result;
    NTSTATUS Status;
 
    DPRINT1("MiniportFindAdapter(%p)\n", Miniport);
 
    /* Call the miniport HwFindAdapter routine */
    Result = Miniport->InitData->HwFindAdapter(&Miniport->MiniportExtension->HwDeviceExtension,
                                               NULL,
                                               NULL,
                                               NULL,
                                               &Miniport->PortConfig,
                                               &Reserved);
    DPRINT1("HwFindAdapter() returned %lu\n", Result);
 
    /* Convert the result to a status code */
    switch (Result)
    {
        case SP_RETURN_NOT_FOUND:
            DPRINT1("SP_RETURN_NOT_FOUND\n");
            Status = STATUS_NOT_FOUND;
            break;
 
        case SP_RETURN_FOUND:
            DPRINT1("SP_RETURN_FOUND\n");
            Status = STATUS_SUCCESS;
            break;
 
        case SP_RETURN_ERROR:
            DPRINT1("SP_RETURN_ERROR\n");
            Status = STATUS_ADAPTER_HARDWARE_ERROR;
            break;
 
        case SP_RETURN_BAD_CONFIG:
            DPRINT1("SP_RETURN_BAD_CONFIG\n");
            Status = STATUS_DEVICE_CONFIGURATION_ERROR;
            break;
 
        default:
            DPRINT1("Unknown result: %lu\n", Result);
            Status = STATUS_INTERNAL_ERROR;
            break;
    }
 
    return Status;
}

Referenced by PortFdoStartMiniport().

MiniportHwInitialize()

NTSTATUS MiniportHwInitialize

(

_In_ PMINIPORT

Miniport

)

Definition at line 346 of file miniport.c.

{
    BOOLEAN Result;
 
    DPRINT("MiniportHwInitialize(%p)\n", Miniport);
 
    /* Call the miniport HwInitialize routine */
    Result = Miniport->InitData->HwInitialize(&Miniport->MiniportExtension->HwDeviceExtension);
    DPRINT("HwInitialize() returned %u\n", Result);
 
    return Result ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
}

Referenced by PortFdoStartMiniport().

MiniportHwInterrupt()

BOOLEAN MiniportHwInterrupt

(

_In_ PMINIPORT

Miniport

)

Definition at line 362 of file miniport.c.

{
    BOOLEAN Result;
 
    DPRINT("MiniportHwInterrupt(%p)\n",
            Miniport);
 
    Result = Miniport->InitData->HwInterrupt(&Miniport->MiniportExtension->HwDeviceExtension);
    DPRINT("HwInterrupt() returned %u\n", Result);
 
    return Result;
}

Referenced by PortFdoInterruptRoutine().

MiniportInitialize()

NTSTATUS MiniportInitialize	(	_In_ PMINIPORT	Miniport,
		_In_ PFDO_DEVICE_EXTENSION	DeviceExtension,
		_In_ PHW_INITIALIZATION_DATA	HwInitializationData
	)

Definition at line 239 of file miniport.c.

{
    PMINIPORT_DEVICE_EXTENSION MiniportExtension;
    ULONG Size;
    NTSTATUS Status;
 
    DPRINT1("MiniportInitialize(%p %p %p)\n",
            Miniport, DeviceExtension, InitData);
 
    Miniport->DeviceExtension = DeviceExtension;
    Miniport->InitData = InitData;
 
    /* Calculate the miniport device extension size */
    Status = RtlULongAdd(sizeof(*MiniportExtension),
                         Miniport->InitData->DeviceExtensionSize,
                         &Size);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Invalid miniport extension size %lx\n", Miniport->InitData->DeviceExtensionSize);
        return Status;
    }
 
    /* Allocate and initialize the miniport device extension */
    MiniportExtension = ExAllocatePoolWithTag(NonPagedPool,
                                              Size,
                                              TAG_MINIPORT_DATA);
    if (MiniportExtension == NULL)
        return STATUS_NO_MEMORY;
 
    RtlZeroMemory(MiniportExtension, Size);
 
    MiniportExtension->Miniport = Miniport;
    Miniport->MiniportExtension = MiniportExtension;
 
    /* Initialize the port configuration */
    Status = InitializeConfiguration(&Miniport->PortConfig,
                                     InitData,
                                     DeviceExtension->BusNumber,
                                     DeviceExtension->SlotNumber);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Assign the resources to the port configuration */
    AssignResourcesToConfiguration(&Miniport->PortConfig,
                                   DeviceExtension->AllocatedResources,
                                   InitData->NumberOfAccessRanges);
 
    return STATUS_SUCCESS;
}

MiniportStartIo()

BOOLEAN MiniportStartIo	(	_In_ PMINIPORT	Miniport,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 378 of file miniport.c.

{
    BOOLEAN Result;
 
    DPRINT("MiniportHwStartIo(%p %p)\n",
            Miniport, Srb);
 
    Result = Miniport->InitData->HwStartIo(&Miniport->MiniportExtension->HwDeviceExtension, Srb);
    DPRINT("HwStartIo() returned %u\n", Result);
 
    return Result;
}

PortAllocateRequestReserve()

VOID PortAllocateRequestReserve

(

_In_ PFDO_DEVICE_EXTENSION

FdoExtension

)

Reserves the memory a single request needs, so IO can still be issued out of pool.

Definition at line 168 of file fdo.c.

{
    ULONG SrbExtensionSize = FdoExtension->HwInitData->SrbExtensionSize;
 
    FdoExtension->ReservedRequestReference =
        ExAllocatePoolWithTag(NonPagedPool,
                              sizeof(*FdoExtension->ReservedRequestReference),
                              TAG_QUEUED_REQUEST);
    if (FdoExtension->ReservedRequestReference == NULL)
    {
        DPRINT1("Failed to reserve a request packet\n");
        return;
    }
 
    if (SrbExtensionSize == 0)
    {
        return;
    }
 
    FdoExtension->ReservedSrbExtension = ExAllocatePoolWithTag(NonPagedPool,
                                                               SrbExtensionSize,
                                                               TAG_SRB_EXTENSION);
    if (FdoExtension->ReservedSrbExtension == NULL)
    {
        DPRINT1("Failed to reserve an SRB extension\n");
 
        /* A packet alone is useless if the miniport wants an SRB extension */
        ExFreePoolWithTag(FdoExtension->ReservedRequestReference, TAG_QUEUED_REQUEST);
        FdoExtension->ReservedRequestReference = NULL;
    }
}

Referenced by PortFdoStartDevice().

PortCompletionDpc()

VOID NTAPI PortCompletionDpc	(	_In_ PKDPC	Dpc,
		_In_ PVOID	Context,
		_In_ PVOID	SystemArgument1,
		_In_ PVOID	SystemArgument2
	)

Definition at line 894 of file srb.c.

{
    PQUEUED_REQUEST_REFERENCE RequestReference;
    PFDO_DEVICE_EXTENSION FdoExtension;
    PSLIST_ENTRY Entry;
    PSLIST_ENTRY Next;
    ULONG Count = 0;
 
    DPRINT("PortCompletionDpc(%p %p %p %p)\n", Dpc, Context, SystemArgument1, SystemArgument2);
 
    /* Take context pointer as FDO extension */
    FdoExtension = (PFDO_DEVICE_EXTENSION)Context;
 
    /* Flush all entries in the list and complete all requests */
    Entry = InterlockedFlushSList(&FdoExtension->CompletionList);
    while (Entry)
    {
        /* Prepare Next pointer first (Completion routine will free the memory that contains it) */
        Next = Entry->Next;
 
        /* Get original request */
        RequestReference = CONTAINING_RECORD(Entry, QUEUED_REQUEST_REFERENCE, CompletionEntry);
 
        /* Call real completion routine */
        PortCompleteRequest(RequestReference);
 
        /* Move on to next one */
        Entry = Next;
        ++Count;
    }
 
    DPRINT("Completed %d requests\n", Count);
}

Referenced by PortAddDevice().

PortCreatePdo()

NTSTATUS PortCreatePdo	(	_In_ PFDO_DEVICE_EXTENSION	FdoExtension,
		_In_ ULONG	Bus,
		_In_ ULONG	Target,
		_In_ ULONG	Lun,
		_Out_ PPDO_DEVICE_EXTENSION *	PdoExtension
	)

Definition at line 21 of file pdo.c.

{
    PPDO_DEVICE_EXTENSION DeviceExtension = NULL;
    PDEVICE_OBJECT Pdo = NULL;
    NTSTATUS Status;
 
    DPRINT("PortCreatePdo(%p %p)\n",
           FdoDeviceExtension, PdoDeviceExtension);
 
    /* Create the port device */
    Status = IoCreateDevice(FdoDeviceExtension->Device->DriverObject,
                            sizeof(PDO_DEVICE_EXTENSION),
                            NULL,
                            FILE_DEVICE_MASS_STORAGE,
                            FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
                            FALSE,
                            &Pdo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateDevice() failed (Status 0x%lX)\n", Status);
        return Status;
    }
 
    /* Initialize the device */
    Pdo->Flags |= DO_DIRECT_IO;
    Pdo->Flags |= DO_POWER_PAGABLE;
 
    DeviceExtension = (PPDO_DEVICE_EXTENSION)Pdo->DeviceExtension;
    RtlZeroMemory(DeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
 
    DeviceExtension->ExtensionType = PdoExtension;
 
    DeviceExtension->Device = Pdo;
    DeviceExtension->FdoExtension = FdoDeviceExtension;
    DeviceExtension->PnpState = dsStopped;
 
    /* Add the PDO to the PDO list*/
    StorpInterlockedInsertHeadListCounted(&FdoDeviceExtension->PdoListLock,
                                          &FdoDeviceExtension->PdoListHead,
                                          &DeviceExtension->PdoListEntry,
                                          &FdoDeviceExtension->PdoCount);
 
    DeviceExtension->Bus = Bus;
    DeviceExtension->Target = Target;
    DeviceExtension->Lun = Lun;
 
    /* Initialize IO flow control structure */
    // KeInitializeSpinLock(&DeviceExtension->FlowControl.Lock);
    DeviceExtension->FlowControl.IsBusy = FALSE;
    DeviceExtension->FlowControl.IsPaused = FALSE;
    DeviceExtension->FlowControl.IsWaitingQueueClear = FALSE;
    DeviceExtension->FlowControl.StrongOrderedCount = 0;
    DeviceExtension->FlowControl.RemainingBusyRequests = 0;
    DeviceExtension->FlowControl.RemainingPauseTime = 0;
 
    /* Beginning from Windows 8, when you specified SRB_TYPE_STORAGE_REQUEST_BLOCK, you can increase
       maximum number of outstanding requests to (254, MaxNumberOfIO) range. We do not support
       STORAGE_REQUEST_BLOCKs so we're not implementing it.
    */
    InitializeListHead(&DeviceExtension->FlowControl.AwaitingRequestsListHead);
    // InitializeListHead(&DeviceExtension->FlowControl.ApprovedRequestsListHead);
    InitializeListHead(&DeviceExtension->FlowControl.ActiveRequestsListHead);
    DeviceExtension->FlowControl.OutstandingRequestCount = 0;
    DeviceExtension->OutstandingRequestMax = 254;
    DeviceExtension->TagCounter = -1;
 
    DeviceExtension->IsClaimed = 0;
 
    // FIXME: More initialization
 
    DeviceExtension->SpecialRequestCounter = 0; /* FIXME: DELETE AFTER DEBUG */
 
    /* The device has been initialized */
    Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
    *PdoDeviceExtension = DeviceExtension;
 
    return STATUS_SUCCESS;
}

Referenced by PortFdoScanBus().

PortDeletePdo()

NTSTATUS PortDeletePdo

(

_In_ PPDO_DEVICE_EXTENSION

PdoExtension

)

Definition at line 108 of file pdo.c.

{
    DPRINT("PortDeletePdo(%p)\n", PdoExtension);
 
    /* Remove the PDO from the PDO list*/
    StorpInterlockedRemoveEntryListCounted(&PdoExtension->FdoExtension->PdoListLock,
                                           &PdoExtension->PdoListEntry,
                                           &PdoExtension->FdoExtension->PdoCount);
 
    if (PdoExtension->InquiryBuffer)
    {
        ExFreePoolWithTag(PdoExtension->InquiryBuffer, TAG_INQUIRY_DATA);
        PdoExtension->InquiryBuffer = NULL;
    }
 
 
    // FIXME: More uninitialization
 
 
    /* Delete the PDO */
    IoDeleteDevice(PdoExtension->Device);
 
    return STATUS_SUCCESS;
}

Referenced by PortFdoScanBus().

PortFdoDeviceControl()

NTSTATUS NTAPI PortFdoDeviceControl	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 146 of file ioctl.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IoStack->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_STORAGE_QUERY_PROPERTY:
            return FdoDeviceControlQueryProperty(DeviceObject->DeviceExtension, Irp);
 
        default:
            // __debugbreak();
            Status = Irp->IoStatus.Status;
            break;
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by PortDispatchDeviceControl().

PortFdoPnp()

NTSTATUS NTAPI PortFdoPnp	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 1139 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;
    PIO_STACK_LOCATION Stack;
    ULONG_PTR Information = 0;
    NTSTATUS Status = STATUS_NOT_SUPPORTED;
 
    DPRINT1("PortFdoPnp(%p %p)\n",
            DeviceObject, Irp);
 
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension);
    ASSERT(DeviceExtension->ExtensionType == FdoExtension);
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (Stack->MinorFunction)
    {
        case IRP_MN_START_DEVICE: /* 0x00 */
            DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
            Status = PortFdoStartDevice(DeviceExtension, Irp);
            break;
 
        case IRP_MN_QUERY_REMOVE_DEVICE: /* 0x01 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_REMOVE_DEVICE\n");
            break;
 
        case IRP_MN_REMOVE_DEVICE: /* 0x02 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_REMOVE_DEVICE\n");
            PortFlushStarvedRequests(DeviceExtension);
            PortFreeRequestReserve(DeviceExtension);
            ExDeleteNPagedLookasideList(&DeviceExtension->RequestReferenceLookaside);
            break;
 
        case IRP_MN_CANCEL_REMOVE_DEVICE: /* 0x03 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_CANCEL_REMOVE_DEVICE\n");
            break;
 
        case IRP_MN_STOP_DEVICE: /* 0x04 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_STOP_DEVICE\n");
            break;
 
        case IRP_MN_QUERY_STOP_DEVICE: /* 0x05 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_STOP_DEVICE\n");
            break;
 
        case IRP_MN_CANCEL_STOP_DEVICE: /* 0x06 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_CANCEL_STOP_DEVICE\n");
            break;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS: /* 0x07 */
            switch (Stack->Parameters.QueryDeviceRelations.Type)
            {
                case BusRelations:
                    DPRINT("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
                    Status = PortFdoQueryBusRelations(DeviceExtension, &Information);
                    break;
 
                case RemovalRelations:
                    DPRINT1("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
                    return ForwardIrpAndForget(DeviceExtension->LowerDevice, Irp);
 
                default:
                    DPRINT1("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
                            Stack->Parameters.QueryDeviceRelations.Type);
                    return ForwardIrpAndForget(DeviceExtension->LowerDevice, Irp);
            }
            break;
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* 0x0d */
            DPRINT("IRP_MJ_PNP / IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
            PortFdoFilterRequirements(DeviceExtension, Irp);
            return ForwardIrpAndForget(DeviceExtension->LowerDevice, Irp);
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE: /* 0x14 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_PNP_DEVICE_STATE\n");
            break;
 
        case IRP_MN_DEVICE_USAGE_NOTIFICATION: /* 0x16 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
            break;
 
        case IRP_MN_SURPRISE_REMOVAL: /* 0x17 */
            DPRINT1("IRP_MJ_PNP / IRP_MN_SURPRISE_REMOVAL\n");
            break;
 
        default:
            DPRINT1("IRP_MJ_PNP / Unknown IOCTL 0x%lx\n", Stack->MinorFunction);
            return ForwardIrpAndForget(DeviceExtension->LowerDevice, Irp);
    }
 
    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by PortDispatchPnp().

PortFdoScsi()

NTSTATUS NTAPI PortFdoScsi	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 1111 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;
//    PIO_STACK_LOCATION Stack;
    ULONG_PTR Information = 0;
    NTSTATUS Status = STATUS_NOT_SUPPORTED;
 
    DPRINT("PortFdoScsi(%p %p)\n", DeviceObject, Irp);
 
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension);
    ASSERT(DeviceExtension->ExtensionType == FdoExtension);
 
//    Stack = IoGetCurrentIrpStackLocation(Irp);
 
 
    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by PortDispatchScsi().

PortFlushStarvedRequests()

VOID PortFlushStarvedRequests

(

_In_ PFDO_DEVICE_EXTENSION

FdoExtension

)

Fails every queued request, for when the adapter goes away.

Definition at line 153 of file fdo.c.

{
    PIRP Irp;
 
    while ((Irp = IoCsqRemoveNextIrp(&FdoExtension->StarvedRequests.Csq, NULL)) != NULL)
    {
        StorpCompleteRequest(Irp, SRB_STATUS_NO_DEVICE, STATUS_NO_SUCH_DEVICE);
    }
}

Referenced by PortFdoPnp().

PortFreeRequestReserve()

VOID PortFreeRequestReserve

(

_In_ PFDO_DEVICE_EXTENSION

FdoExtension

)

Releases the reserve. No request may be using it anymore.

Definition at line 205 of file fdo.c.

{
    if (FdoExtension->ReservedSrbExtension != NULL)
    {
        ExFreePoolWithTag(FdoExtension->ReservedSrbExtension, TAG_SRB_EXTENSION);
        FdoExtension->ReservedSrbExtension = NULL;
    }
 
    if (FdoExtension->ReservedRequestReference != NULL)
    {
        ExFreePoolWithTag(FdoExtension->ReservedRequestReference, TAG_QUEUED_REQUEST);
        FdoExtension->ReservedRequestReference = NULL;
    }
}

Referenced by PortFdoPnp().

PortGetDriverInitData()

PHW_INITIALIZATION_DATA PortGetDriverInitData	(	PDRIVER_OBJECT_EXTENSION	DriverExtension,
		INTERFACE_TYPE	InterfaceType
	)

Definition at line 81 of file storport.c.

{
    PDRIVER_INIT_DATA InitData;
    PLIST_ENTRY ListEntry;
 
    DPRINT1("PortGetDriverInitData()\n");
 
    ListEntry = DriverExtension->InitDataListHead.Flink;
    while (ListEntry != &DriverExtension->InitDataListHead)
    {
        InitData = CONTAINING_RECORD(ListEntry,
                                     DRIVER_INIT_DATA,
                                     Entry);
        if (InitData->HwInitData.AdapterInterfaceType == InterfaceType)
            return &InitData->HwInitData;
 
        ListEntry = ListEntry->Flink;
    }
 
    return NULL;
}

Referenced by PortFdoStartMiniport(), and StorPortGetUncachedExtension().

PortInitializeStarvedRequestQueue()

NTSTATUS PortInitializeStarvedRequestQueue

(

_In_ PSTARVED_REQUEST_QUEUE

Queue

)

Definition at line 105 of file fdo.c.

{
    KeInitializeSpinLock(&Queue->Lock);
    InitializeListHead(&Queue->ListHead);
 
    return IoCsqInitialize(&Queue->Csq,
                           PortStarvedCsqInsertIrp,
                           PortStarvedCsqRemoveIrp,
                           PortStarvedCsqPeekNextIrp,
                           PortStarvedCsqAcquireLock,
                           PortStarvedCsqReleaseLock,
                           PortStarvedCsqCompleteCanceledIrp);
}

Referenced by PortAddDevice().

PortPdoDeviceControl()

NTSTATUS NTAPI PortPdoDeviceControl	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 378 of file ioctl.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION IoStack;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IoStack->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_STORAGE_QUERY_PROPERTY:
            return PdoDeviceControlQueryProperty(DeviceObject->DeviceExtension, Irp);
 
        case IOCTL_SCSI_GET_ADDRESS:
            return PdoDeviceControlScsiGetAddress(DeviceObject->DeviceExtension, Irp);
 
        default:
            // DbgBreakPoint();
            Status = STATUS_NOT_IMPLEMENTED;
            break;
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by PortDispatchDeviceControl().

PortPdoIssueRequest()

NTSTATUS PortPdoIssueRequest	(	_In_ PPDO_DEVICE_EXTENSION	PdoExtension,
		_In_ PQUEUED_REQUEST_REFERENCE	RequestReference
	)

Definition at line 290 of file srb.c.

{
    PIRP Irp;
    NTSTATUS Status;
    PFDO_DEVICE_EXTENSION FdoExtension;
    PHW_INITIALIZATION_DATA HwInitData;
    KIRQL OldIrql;
 
    Irp = RequestReference->Irp;
    FdoExtension = PdoExtension->FdoExtension;
    HwInitData = FdoExtension->Miniport.InitData;
 
    NT_ASSERT(HwInitData);
 
    /* Fill in SCSI address data */
    /* FIXME: Not sure if this is the best place for it. */
    RequestReference->Srb->PathId = PdoExtension->Bus;
    RequestReference->Srb->TargetId = PdoExtension->Target;
    RequestReference->Srb->Lun = PdoExtension->Lun;
 
    /* FIXME: Delete after debug */
    // PSCSI_REQUEST_BLOCK Srb = RequestReference->Srb;
    // if (Srb->Function == SRB_FUNCTION_EXECUTE_SCSI &&
    //     (Srb->Cdb[0] == SCSIOP_GET_EVENT_STATUS || Srb->Cdb[0] == SCSIOP_TEST_UNIT_READY))
    // {
    //     RequestReference->DumpSpecialRequest = TRUE;
    //     StorpDumpRequest(RequestReference);
    // }
 
    /* Start an DMA if IO subsystem allocated an MDL for us */
    /* FIXME: Does this strategy work? */
    if (RequestReference->Irp->MdlAddress)
    {
        /*
         * Lock the buffer so that it stays in physical memory.
         * In the two cases avoided here the memory has already been locked
         */
        if (!TEST_FLAG(Irp->MdlAddress->MdlFlags, MDL_SOURCE_IS_NONPAGED_POOL) &&
            !TEST_FLAG(Irp->MdlAddress->MdlFlags, MDL_MAPPED_TO_SYSTEM_VA) &&
            !TEST_FLAG(Irp->MdlAddress->MdlFlags, MDL_PAGES_LOCKED) &&
            !TEST_FLAG(Irp->MdlAddress->MdlFlags, MDL_PARTIAL))
        {
            RequestReference->MappedSystemVa = (PVOID)1; /* FIXME: CHANGE ITS NAME */
            MmProbeAndLockPages(Irp->MdlAddress, KernelMode, IoModifyAccess);
        }
 
        /* Following call requires DISPATCH_LEVEL. */
        OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
 
        /* Make up the scatter gather list */
        /* FIXME: I don't know if we actually hit it */
        NT_ASSERT((RequestReference->Srb->SrbFlags & SRB_FLAGS_UNSPECIFIED_DIRECTION) !=
                  SRB_FLAGS_UNSPECIFIED_DIRECTION);
        RequestReference->WriteToDevice =
            TEST_FLAG(RequestReference->Srb->SrbFlags, SRB_FLAGS_DATA_OUT);
 
        FdoExtension->DmaAdapter->DmaOperations->
            GetScatterGatherList(FdoExtension->DmaAdapter,
                                 FdoExtension->Device,
                                 RequestReference->Irp->MdlAddress,
                                 MmGetMdlVirtualAddress(RequestReference->Irp->MdlAddress),
                                 RequestReference->Srb->DataTransferLength,
                                 PortPdoAfterBuildingScatterGatherList,
                                 (PVOID)RequestReference,
                                 RequestReference->WriteToDevice);
 
        /* Restore IRQL */
        KeLowerIrql(OldIrql);
    } else {
        /* Otherwise just start the IO with a NULL scatter gather list */
        PortPdoAfterBuildingScatterGatherList(FdoExtension->Device,
                                              RequestReference->Irp,
                                              NULL,
                                              RequestReference);
    }
 
    /* FIXME: Is this correct? */
    Status = STATUS_PENDING;
 
    return Status;
}

Referenced by PortPdoScsi(), and PortScheduleComingRequestsOnCompletion().

PortPdoPnp()

NTSTATUS NTAPI PortPdoPnp	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 681 of file pdo.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
    PPDO_DEVICE_EXTENSION DeviceExtension;
 
    DPRINT1("PortPdoPnp(%p %p)\n", DeviceObject, Irp);
 
    DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->ExtensionType == PdoExtension);
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (Stack->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
        {
            // RegistryInitLunKey(lunExt);
            DeviceExtension->PnpState = dsStarted;
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_REMOVE_DEVICE:
        case IRP_MN_SURPRISE_REMOVAL:
        {
            DeviceExtension->PnpState = (Stack->MinorFunction == IRP_MN_REMOVE_DEVICE)
                                        ? dsRemoved : dsSurpriseRemoved;
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_QUERY_CAPABILITIES:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_QUERY_STOP_DEVICE:
        {
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            Status = PdoHandleDeviceRelations(DeviceExtension, Irp);
            break;
        }
        case IRP_MN_QUERY_DEVICE_TEXT:
        {
            Status = PdoHandleQueryDeviceText(DeviceExtension, Irp);
            break;
        }
        case IRP_MN_QUERY_ID:
        {
            DPRINT("IRP_MN_QUERY_ID IdType %s\n",
                DbgGetDeviceIDString(Stack->Parameters.QueryId.IdType));
 
           if (Stack->Parameters.QueryId.IdType == BusQueryDeviceID)
           {
               Status = PdoHandleQueryDeviceId(DeviceExtension, Irp);
               break;
           }
           else if (Stack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
           {
               Status = PdoHandleQueryHardwareId(DeviceExtension, Irp);
               break;
           }
           else if (Stack->Parameters.QueryId.IdType == BusQueryInstanceID)
           {
               Status = PdoHandleQueryInstanceId(DeviceExtension, Irp);
               break;
           }
           else if (Stack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
           {
               Status = PdoHandleQueryCompatibleId(DeviceExtension, Irp);
               break;
           }
 
           __fallthrough;
        }
        default:
        {
            // do nothing
            Status = Irp->IoStatus.Status;
            break;
        }
    }
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return Status;
}

Referenced by PortDispatchPnp().

PortPdoScheduleRequestFlowControlled()

BOOLEAN PortPdoScheduleRequestFlowControlled	(	_In_ PPDO_DEVICE_EXTENSION	PdoExtension,
		_In_ PFDO_DEVICE_EXTENSION	FdoExtension,
		_In_ PQUEUED_REQUEST_REFERENCE	RequestReference
	)

Schedules an outstanding request and return a boolean value to indicate if the request can be immediately issued.

Parameters

PdoExtension	PDO device extension.
FdoExtension	FDO device extension.
RequestReference	RequestReference must be allocated beforehand.

Returns

BOOLEAN When TRUE, you can call PortPdoIssueRequest to issue request right away; When FALSE, the request is already queued in flow control structures and you can safely go on without further processing, it will be issued upon completions.

Definition at line 397 of file srb.c.

{
    PPDO_IO_FLOW_CONTROL FlowControl = &PdoExtension->FlowControl;
    KLOCK_QUEUE_HANDLE LockHandle;
    PSCSI_REQUEST_BLOCK Srb = RequestReference->Srb;
    BOOLEAN StrongOrderedRequest = FALSE;
    BOOLEAN IssueRequest = TRUE;
 
    /* Set outstanding flag */
    RequestReference->IsOutstanding = TRUE;
 
    /* Check if we can issue this request. */
    /* Acquire the HBA global flow control lock first */
    KeAcquireInStackQueuedSpinLock(&FdoExtension->FlowControl.Lock, &LockHandle);
    StorpCheckFlowControl(FdoExtension);
 
    do
    {
        /* Check PDO flow control conditions */
 
        /* Sanity check */
        NT_ASSERT(FlowControl->OutstandingRequestCount <= PdoExtension->OutstandingRequestMax);
 
        /* If PDO is not suitable to receive a request, make it wait */
        if (FlowControl->IsBusy || FlowControl->IsPaused ||
            (FlowControl->IsFrozen && !TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_BYPASS_FROZEN_QUEUE)) ||
            (FlowControl->IsLocked && !TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_BYPASS_LOCKED_QUEUE)) ||
            FlowControl->StrongOrderedCount ||
            FlowControl->OutstandingRequestCount == PdoExtension->OutstandingRequestMax ||
            (!IsListEmpty(&FlowControl->AwaitingRequestsListHead)))
        {
            InsertHeadList(&FlowControl->AwaitingRequestsListHead,
                           &RequestReference->PdoEntry);
            IssueRequest = FALSE;
            break;
        }
 
        /* Check if this request is strong-ordered */
        if (!TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE) ||
            (Srb->QueueAction == SRB_ORDERED_QUEUE_TAG_REQUEST))
        {
            RequestReference->StrongOrdered = TRUE;
            StrongOrderedRequest = TRUE;
            ++FlowControl->StrongOrderedCount;
        }
 
        /*
        * If this request is strong ordered and the LUN's active/approved list is not
        * drained, the request must wait.
        */
        if (StrongOrderedRequest && !IsListEmpty(&FlowControl->ActiveRequestsListHead))
        {
            InsertHeadList(&FlowControl->AwaitingRequestsListHead,
                           &RequestReference->PdoEntry);
            IssueRequest = FALSE;
            break;
        }
 
        /*
        * If any break's triggered before this point, the request is in PDO waiting queue.
        * Going past this point meant PDO approves this request. Put it into active list.
        */
        if (Srb->QueueAction == SRB_HEAD_OF_QUEUE_TAG_REQUEST)
        {
            InsertTailList(&FlowControl->ActiveRequestsListHead,
                           &RequestReference->PdoEntry);
        } else {
            InsertHeadList(&FlowControl->ActiveRequestsListHead,
                           &RequestReference->PdoEntry);
        }
 
        /* A new outstanding request is added to this LUN */
        ++FlowControl->OutstandingRequestCount;
 
        /* Check FDO flow control status. */
 
        /* If the FDO can't handle more requests, then the request should be queued. */
        if (FlowControl->IsBusy || FlowControl->IsPaused ||
            FlowControl->OutstandingRequestCount == FdoExtension->OutstandingRequestMax)
        {
            /* Put into FDO queue */
            InsertHeadList(&FdoExtension->FlowControl.FdoBlockedRequestsListHead,
                           &RequestReference->FdoEntry);
 
            /*
            * Now the request is in PDO active list, in FDO awaiting queue, not issued.
            * Let it wait until another completion event schedules it.
            */
            break;
        }
 
        /* Seems good, increment FDO request count */
        ++FdoExtension->FlowControl.OutstandingRequestCount;
 
        /*
        * Now the request is counted in FDO & PDO, and is put into PDO active list,
        * next step we're going to issue it.
        */
    } while (0);
 
    // FIXME: The port driver indicates that an LU-specific queue has been frozen by
    // returning a request with SRB_STATUS_QUEUE_FROZEN in the SrbStatus member. New
    // requests from the class driver can be inserted into the queue, but only autosense
    // requests are sent to the logical unit as long as its queue is frozen.
    // https://learn.microsoft.com/en-us/windows-hardware/drivers/storage/storage-class-driver-s-releasequeue-routine
 
    /* We've determined where the request goes. Release the flow control lock */
    StorpCheckFlowControl(FdoExtension);
    KeReleaseInStackQueuedSpinLock(&LockHandle);
 
    return IssueRequest;
}

Referenced by PortPdoScsi().

PortPdoScsi()

NTSTATUS NTAPI PortPdoScsi	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 516 of file srb.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
    PSCSI_REQUEST_BLOCK Srb;
    PPDO_DEVICE_EXTENSION PdoExtension;
    PFDO_DEVICE_EXTENSION FdoExtension;
    PMINIPORT Miniport;
    PHW_INITIALIZATION_DATA HwInitData;
 
    DPRINT("PortPdoScsi(%p %p)\n", DeviceObject, Irp);
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
    Srb = Stack->Parameters.Scsi.Srb;
 
    if (Srb == NULL) {
        DPRINT1("Srb is NULL!");
        DbgBreakPoint();
        Status = STATUS_UNSUCCESSFUL;
 
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = Status;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
 
    PdoExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    NT_ASSERT(PdoExtension);
    FdoExtension = PdoExtension->FdoExtension;
    NT_ASSERT(FdoExtension);
    Miniport = &FdoExtension->Miniport;
    HwInitData = Miniport->InitData;
 
    switch (Srb->Function) {
        /* Both of these should be sent to device and let themselves process this */
        case SRB_FUNCTION_IO_CONTROL:
        case SRB_FUNCTION_EXECUTE_SCSI:
        {
            PQUEUED_REQUEST_REFERENCE RequestReference;
            BOOLEAN IssueRequest;
 
            /* Mark IRP as pending */
            IoMarkIrpPending(Irp);
 
            /* Allocate private contexts */
            Status = PortPdoSrbAllocatePrivateContexts(Srb, PdoExtension, FdoExtension);
            if (Status != STATUS_SUCCESS)
            {
                break;
            }
            RequestReference = (PQUEUED_REQUEST_REFERENCE)Srb->OriginalRequest;
 
            /* Assign a tag to the SRB if it supports tagging */
            StorpAssignTagToSrb(PdoExtension, Srb);
 
            DPRINT("New request (%d:%d:%d) ReqRef %p Srb %p Irp %p Tag %x SrbExt %p(%d)\n",
                    Srb->PathId, Srb->TargetId, Srb->Lun,
                    RequestReference, Srb, Irp, Srb->QueueTag,
                    Srb->SrbExtension, HwInitData->SrbExtensionSize);
 
            /*
             * Do the scheduling. If returns TRUE, we should issue this request to the hardware.
             * Otherwise it will keep waiting until next completion schedules it, or be cancelled on
             * an error, etc.
             */
            IssueRequest = PortPdoScheduleRequestFlowControlled(PdoExtension,
                                                                FdoExtension,
                                                                RequestReference);
 
            /* This request is viable to be issued. */
            if (IssueRequest)
            {
                Status = PortPdoIssueRequest(PdoExtension, RequestReference);
            } else {
                Status = STATUS_PENDING;
            }
 
            break;
        }
 
        /*
         * These requests are actually sent to adapters and are not outstanding requests for devices
         * so we simply pass them down to miniport
         */
        case SRB_FUNCTION_FLUSH:
        case SRB_FUNCTION_SHUTDOWN:
        {
            PQUEUED_REQUEST_REFERENCE RequestReference;
 
            /* Mark IRP as pending */
            IoMarkIrpPending(Irp);
 
            /* Allocate private contexts */
            Status = PortPdoSrbAllocatePrivateContexts(Srb, PdoExtension, FdoExtension);
            if (Status != STATUS_SUCCESS)
            {
                break;
            }
            RequestReference = (PQUEUED_REQUEST_REFERENCE)Srb->OriginalRequest;
 
            /*
             * Call the non-flow-controlled scheduling function (it does nothing but the model is
             * preserved for consistency)
             */
            PortPdoScheduleRequestNoFlowControl(FdoExtension, RequestReference);
 
            /* Fire up the request immediately */
            PortPdoIssueRequest(PdoExtension, RequestReference);
 
            break;
        }
 
        case SRB_FUNCTION_CLAIM_DEVICE:
        {
            if (InterlockedCompareExchange(&PdoExtension->IsClaimed, 1, 0))
            {
                Status = STATUS_DEVICE_BUSY;
                StorpCompleteRequest(Irp, SRB_STATUS_BUSY, Status);
                break;
            }
 
            /* The claimed device object is handed back to the class driver here */
            Srb->DataBuffer = PdoExtension->Device;
            Status = STATUS_SUCCESS;
            StorpCompleteRequest(Irp, SRB_STATUS_SUCCESS, Status);
            break;
        }
 
        case SRB_FUNCTION_RELEASE_DEVICE:
        {
            InterlockedExchange(&PdoExtension->IsClaimed, 0);
 
            Status = STATUS_SUCCESS;
            StorpCompleteRequest(Irp, SRB_STATUS_SUCCESS, Status);
            break;
        }
 
        default:
            DPRINT1("Unsupported Srb Function %02X!", Srb->Function);
            // DbgBreakPoint();
            Status = STATUS_NOT_IMPLEMENTED;
            StorpCompleteRequest(Irp, SRB_STATUS_INVALID_REQUEST, Status);
            break;
    }
 
    return Status;
}

Referenced by PortDispatchScsi(), and PortRetryStarvedRequest().

PortQueueStarvedRequest()

VOID PortQueueStarvedRequest	(	_In_ PFDO_DEVICE_EXTENSION	FdoExtension,
		_In_ PIRP	Irp
	)

Queues a request that could not allocate its private contexts.

Definition at line 124 of file fdo.c.

{
    IoCsqInsertIrp(&FdoExtension->StarvedRequests.Csq, Irp, NULL);
}

Referenced by PortPdoStarveRequest().

PortRetryStarvedRequest()

VOID PortRetryStarvedRequest

(

_In_ PFDO_DEVICE_EXTENSION

FdoExtension

)

Retries one queued request, so each completion lets exactly one through.

Definition at line 135 of file fdo.c.

{
    PIRP Irp;
 
    Irp = IoCsqRemoveNextIrp(&FdoExtension->StarvedRequests.Csq, NULL);
    if (Irp == NULL)
    {
        return;
    }
 
    PortPdoScsi(IoGetCurrentIrpStackLocation(Irp)->DeviceObject, Irp);
}

Referenced by PortCompleteRequest().

QueryBusInterface()

NTSTATUS QueryBusInterface	(	PDEVICE_OBJECT	DeviceObject,
		PGUID	Guid,
		USHORT	Size,
		USHORT	Version,
		PBUS_INTERFACE_STANDARD	Interface,
		PVOID	InterfaceSpecificData
	)

Definition at line 122 of file misc.c.

{
    KEVENT Event;
    NTSTATUS Status;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    PIO_STACK_LOCATION Stack;
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
                                       DeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatus);
    if (Irp == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Stack = IoGetNextIrpStackLocation(Irp);
 
    Stack->MajorFunction = IRP_MJ_PNP;
    Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
    Stack->Parameters.QueryInterface.InterfaceType = Guid;
    Stack->Parameters.QueryInterface.Size = Size;
    Stack->Parameters.QueryInterface.Version = Version;
    Stack->Parameters.QueryInterface.Interface = (PINTERFACE)Interface;
    Stack->Parameters.QueryInterface.InterfaceSpecificData = InterfaceSpecificData;
 
    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;
}

Referenced by PortFdoStartDevice().

SimpleTimerCallbackDpcRoutine()

VOID NTAPI SimpleTimerCallbackDpcRoutine	(	PKDPC	Dpc,
		PVOID	DeferredContext,
		PVOID	SystemArgument1,
		PVOID	SystemArgument2
	)

Definition at line 327 of file misc.c.

{
    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);
 
    PFDO_DEVICE_EXTENSION FdoExtension = (PFDO_DEVICE_EXTENSION)DeferredContext;
 
    NT_ASSERT(FdoExtension);
    NT_ASSERT(FdoExtension->Miniport.MiniportExtension);
 
    FdoExtension->TimerCallback(&FdoExtension->Miniport.MiniportExtension->HwDeviceExtension);
}

Referenced by PortAddDevice().

StorpSrbFreeRequestReference()

VOID StorpSrbFreeRequestReference

(

_In_ PSCSI_REQUEST_BLOCK

Srb

)

Frees an SRB's Request Reference and restore Srb->OriginalRequest field to IRP. This function does not check if Srb->OriginalRequest is actually an request reference, and you must determine it by other means.

Parameters

Srb

Definition at line 106 of file srb.c.

{
    PQUEUED_REQUEST_REFERENCE RequestReference;
    PFDO_DEVICE_EXTENSION FdoExtension;
 
    RequestReference = (PQUEUED_REQUEST_REFERENCE)Srb->OriginalRequest;
    Srb->OriginalRequest = RequestReference->Irp;
    FdoExtension = RequestReference->PdoExtension->FdoExtension;
 
    if (RequestReference->FromReserve)
    {
        InterlockedExchange(&FdoExtension->ReserveInUse, 0);
    }
    else
    {
        ExFreeToNPagedLookasideList(&FdoExtension->RequestReferenceLookaside, RequestReference);
    }
}

Referenced by PortCompleteRequest(), and PortPdoSrbAllocatePrivateContexts().

TimerCallbackDpcRoutine()

VOID NTAPI TimerCallbackDpcRoutine	(	PKDPC	Dpc,
		PVOID	DeferredContext,
		PVOID	SystemArgument1,
		PVOID	SystemArgument2
	)

Definition at line 348 of file misc.c.

{
    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);
 
    PTIMER_ENTRY TimerEntry = (PTIMER_ENTRY)DeferredContext;
 
    /*
     * Miniport can schedule a new timer event inside of callback, we should clear timer activated
     * status here to ensure timer can be correctly scheduled
     */
    TimerEntry->TimerAlreadySet = 0;
 
    TimerEntry->TimerCallback(TimerEntry->HwDeviceExtension,
                              TimerEntry->Context);
}

Referenced by StorPortExtendedFunction().

TranslateResourceListAddress()

BOOLEAN TranslateResourceListAddress	(	PFDO_DEVICE_EXTENSION	DeviceExtension,
		INTERFACE_TYPE	BusType,
		ULONG	SystemIoBusNumber,
		STOR_PHYSICAL_ADDRESS	IoAddress,
		ULONG	NumberOfBytes,
		BOOLEAN	InIoSpace,
		PPHYSICAL_ADDRESS	TranslatedAddress
	)

Definition at line 173 of file misc.c.

{
    PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptorA, FullDescriptorT;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptorA, PartialDescriptorT;
    INT i, j;
 
    DPRINT1("TranslateResourceListAddress(%p)\n", DeviceExtension);
 
    FullDescriptorA = DeviceExtension->AllocatedResources->List;
    FullDescriptorT = DeviceExtension->TranslatedResources->List;
    for (i = 0; i < DeviceExtension->AllocatedResources->Count; i++)
    {
        for (j = 0; j < FullDescriptorA->PartialResourceList.Count; j++)
        {
            PartialDescriptorA = FullDescriptorA->PartialResourceList.PartialDescriptors + j;
            PartialDescriptorT = FullDescriptorT->PartialResourceList.PartialDescriptors + j;
 
            switch (PartialDescriptorA->Type)
            {
                case CmResourceTypePort:
                    DPRINT1("Port: 0x%I64x (0x%lx)\n",
                            PartialDescriptorA->u.Port.Start.QuadPart,
                            PartialDescriptorA->u.Port.Length);
                    if (InIoSpace &&
                        IoAddress.QuadPart >= PartialDescriptorA->u.Port.Start.QuadPart &&
                        IoAddress.QuadPart + NumberOfBytes <= PartialDescriptorA->u.Port.Start.QuadPart + PartialDescriptorA->u.Port.Length)
                    {
                        TranslatedAddress->QuadPart = PartialDescriptorT->u.Port.Start.QuadPart +
                                                      (IoAddress.QuadPart - PartialDescriptorA->u.Port.Start.QuadPart);
                        return TRUE;
                    }
                    break;
 
                case CmResourceTypeMemory:
                    DPRINT1("Memory: 0x%I64x (0x%lx)\n",
                            PartialDescriptorA->u.Memory.Start.QuadPart,
                            PartialDescriptorA->u.Memory.Length);
                    if (!InIoSpace &&
                        IoAddress.QuadPart >= PartialDescriptorA->u.Memory.Start.QuadPart &&
                        IoAddress.QuadPart + NumberOfBytes <= PartialDescriptorA->u.Memory.Start.QuadPart + PartialDescriptorA->u.Memory.Length)
                    {
                        TranslatedAddress->QuadPart = PartialDescriptorT->u.Memory.Start.QuadPart +
                                                      (IoAddress.QuadPart - PartialDescriptorA->u.Memory.Start.QuadPart);
                        return TRUE;
                    }
                    break;
            }
        }
 
        /* Advance to next CM_FULL_RESOURCE_DESCRIPTOR block in memory. */
        FullDescriptorA = (PCM_FULL_RESOURCE_DESCRIPTOR)(FullDescriptorA->PartialResourceList.PartialDescriptors +
                                                         FullDescriptorA->PartialResourceList.Count);
 
        FullDescriptorT = (PCM_FULL_RESOURCE_DESCRIPTOR)(FullDescriptorT->PartialResourceList.PartialDescriptors +
                                                         FullDescriptorT->PartialResourceList.Count);
    }
 
    return FALSE;
}

Referenced by StorPortGetDeviceBase().