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	_EXTENDED_REQUEST
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_LUN_EXTENSION   'ELtS'
#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)
#define	HW_INIT_DATA_SIZE_PHYSICAL   FIELD_OFFSET(HW_INITIALIZATION_DATA, HwFreeAdapterResources)
#define	HW_INIT_DATA_SIZE_VIRTUAL_LEGACY   FIELD_OFFSET(HW_INITIALIZATION_DATA, HwTracingEnabled)

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 _EXTENDED_REQUEST	EXTENDED_REQUEST
typedef struct _EXTENDED_REQUEST *	PEXTENDED_REQUEST
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)
PPDO_DEVICE_EXTENSION NTAPI	FdoFindLunAboveDispatch (_In_ PFDO_DEVICE_EXTENSION FdoExtension, _In_ ULONG Bus, _In_ ULONG Target, _In_ ULONG Lun)
	Finds a unit from an interrupt service routine or any other caller above DISPATCH_LEVEL.
VOID NTAPI	PortFdoLinkPdo (_Inout_ PFDO_DEVICE_EXTENSION FdoExtension, _Inout_ PPDO_DEVICE_EXTENSION PdoExtension)
	Adds a PDO where both the list lock and the interrupt service routines respect it.
VOID NTAPI	PortFdoUnlinkPdo (_Inout_ PFDO_DEVICE_EXTENSION FdoExtension, _Inout_ PPDO_DEVICE_EXTENSION PdoExtension)
VOID NTAPI	PortFdoBusChangeDpc (_In_ PKDPC Dpc, _In_opt_ PVOID DeferredContext, _In_opt_ PVOID SystemArgument1, _In_opt_ PVOID SystemArgument2)
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)
VOID NTAPI	MiniportFreeAdapterResources (_In_ PMINIPORT Miniport)
	Tells the miniport the adapter is going away.
BOOLEAN NTAPI	MiniportHwMSInterrupt (_In_ PMINIPORT Miniport, _In_ ULONG MessageId)
VOID NTAPI	MiniportQueryAdapterControl (_In_ PMINIPORT Miniport)
	Asks the miniport which adapter control requests it handles.
SCSI_ADAPTER_CONTROL_STATUS NTAPI	MiniportAdapterControl (_In_ PMINIPORT Miniport, _In_ SCSI_ADAPTER_CONTROL_TYPE ControlType, _In_opt_ PVOID Parameters)
	Sends one adapter control request, if the miniport claimed it.
VOID NTAPI	MiniportQueryUnitControl (_In_ PMINIPORT Miniport)
	Asks the miniport which unit control requests it handles.
SCSI_UNIT_CONTROL_STATUS NTAPI	MiniportUnitControl (_In_ PMINIPORT Miniport, _In_ SCSI_UNIT_CONTROL_TYPE ControlType, _In_opt_ PVOID Parameters)
	Sends one unit control request, if the miniport claimed it.
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)
VOID NTAPI	StorpBuildUnitAddress (_In_ PPDO_DEVICE_EXTENSION PdoExtension, _Out_ PSTOR_ADDR_BTL8 Address)
	Fills in the bus, target and LUN address of a logical unit.
BOOLEAN NTAPI	StorpIsExtendedSrb (_In_ PVOID Srb)
	Tells whether a request block is in the extended format.
PQUEUED_REQUEST_REFERENCE NTAPI	StorpRequestReference (_In_ PSCSI_REQUEST_BLOCK Srb)
	Finds the request reference behind an SRB in either format.
PVOID NTAPI	StorpSrbDataBuffer (_In_ PSCSI_REQUEST_BLOCK Srb)
	Finds the data buffer of a request in either format.
VOID NTAPI	StorpBuildExtendedSrb (_In_ PSCSI_REQUEST_BLOCK Srb, _Out_ PEXTENDED_REQUEST Request)
	Fills in the extended request a miniport will be given.
VOID NTAPI	StorpCompleteExtendedSrb (_In_ PSCSI_REQUEST_BLOCK Srb, _In_ PEXTENDED_REQUEST Request)
	Carries the miniport's answer back to the original request block.
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 45 of file precomp.h.

HW_INIT_DATA_SIZE_PHYSICAL

#define HW_INIT_DATA_SIZE_PHYSICAL   FIELD_OFFSET(HW_INITIALIZATION_DATA, HwFreeAdapterResources)

Definition at line 72 of file precomp.h.

HW_INIT_DATA_SIZE_VIRTUAL_LEGACY

#define HW_INIT_DATA_SIZE_VIRTUAL_LEGACY   FIELD_OFFSET(HW_INITIALIZATION_DATA, HwTracingEnabled)

Definition at line 75 of file precomp.h.

SET_FLAG

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

Definition at line 44 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_LUN_EXTENSION

#define TAG_LUN_EXTENSION   'ELtS'

Definition at line 38 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 41 of file precomp.h.

TAG_REPORT_LUN_DATA

#define TAG_REPORT_LUN_DATA   'LRtS'

Definition at line 39 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 40 of file precomp.h.

TAG_SRB_EXTENSION

#define TAG_SRB_EXTENSION   'XStS'

Definition at line 42 of file precomp.h.

TEST_FLAG

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

Definition at line 46 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

EXTENDED_REQUEST

typedef struct _EXTENDED_REQUEST EXTENDED_REQUEST

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

PEXTENDED_REQUEST

typedef struct _EXTENDED_REQUEST * PEXTENDED_REQUEST

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 48 of file precomp.h.

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

EXTENSION_TYPE

enum EXTENSION_TYPE

Enumerator
InvalidExtension
DriverExtension
FdoExtension
PdoExtension

Definition at line 57 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 1306 of file fdo.c.

{
    PPDO_DEVICE_EXTENSION PdoExtension;
    KLOCK_QUEUE_HANDLE LockHandle;
 
    KeAcquireInStackQueuedSpinLock(&FdoExtension->PdoListLock, &LockHandle);
    PdoExtension = FdoScanPdoList(FdoExtension, Bus, Target, Lun);
    KeReleaseInStackQueuedSpinLock(&LockHandle);
 
    return PdoExtension;
}

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

FdoFindLunAboveDispatch()

PPDO_DEVICE_EXTENSION NTAPI FdoFindLunAboveDispatch	(	_In_ PFDO_DEVICE_EXTENSION	FdoExtension,
		_In_ ULONG	Bus,
		_In_ ULONG	Target,
		_In_ ULONG	Lun
	)

Finds a unit from an interrupt service routine or any other caller above DISPATCH_LEVEL.

Definition at line 1405 of file fdo.c.

{
    PPDO_DEVICE_EXTENSION PdoExtension;
    KIRQL OldIrql;
 
    /* At device IRQL the caller is an ISR or synchronized routine and already holds a lock */
    if (KeGetCurrentIrql() >= FdoExtension->InterruptIrql)
        return FdoScanPdoList(FdoExtension, Bus, Target, Lun);
 
    OldIrql = PortFdoAcquireInterruptLocks(FdoExtension);
    PdoExtension = FdoScanPdoList(FdoExtension, Bus, Target, Lun);
    PortFdoReleaseInterruptLocks(FdoExtension, OldIrql);
 
    return PdoExtension;
}

Referenced by StorPortGetLogicalUnit().

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().

MiniportAdapterControl()

SCSI_ADAPTER_CONTROL_STATUS NTAPI MiniportAdapterControl	(	_In_ PMINIPORT	Miniport,
		_In_ SCSI_ADAPTER_CONTROL_TYPE	ControlType,
		_In_opt_ PVOID	Parameters
	)

Sends one adapter control request, if the miniport claimed it.

Definition at line 504 of file miniport.c.

{
    DPRINT("MiniportAdapterControl(%p %u %p)\n",
            Miniport, ControlType, Parameters);
 
    ASSERT(ControlType < ScsiAdapterControlMax);
    if (!(Miniport->AdapterControlSupportedBitmap & (1 << ControlType)))
    {
        return ScsiAdapterControlUnsuccessful;
    }
 
    return Miniport->InitData->HwAdapterControl(&Miniport->MiniportExtension->HwDeviceExtension,
                                                ControlType,
                                                Parameters);
}

Referenced by PortFdoStopAdapter().

MiniportFindAdapter()

NTSTATUS MiniportFindAdapter

(

_In_ PMINIPORT

Miniport

)

Definition at line 325 of file miniport.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension = Miniport->DeviceExtension;
    BOOLEAN Reserved = FALSE;
    ULONG Result;
    NTSTATUS Status;
 
    DPRINT1("MiniportFindAdapter(%p)\n", Miniport);
 
    /* HwFindAdapter is typeless since Win8, a virtual miniport puts a PVIRTUAL_HW_FIND_ADAPTER there */
    if (Miniport->IsVirtual)
    {
        PVIRTUAL_HW_FIND_ADAPTER FindAdapter;
 
        FindAdapter = (PVIRTUAL_HW_FIND_ADAPTER)Miniport->InitData->HwFindAdapter;
 
        Result = FindAdapter(&Miniport->MiniportExtension->HwDeviceExtension,
                             DeviceExtension->PhysicalDevice,
                             DeviceExtension->Device,
                             DeviceExtension->LowerDevice,
                             NULL,
                             &Miniport->PortConfig,
                             &Reserved);
    }
    else
    {
        PHW_FIND_ADAPTER FindAdapter;
 
        FindAdapter = (PHW_FIND_ADAPTER)Miniport->InitData->HwFindAdapter;
 
        Result = FindAdapter(&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().

MiniportFreeAdapterResources()

VOID NTAPI MiniportFreeAdapterResources

(

_In_ PMINIPORT

Miniport

)

Tells the miniport the adapter is going away.

Definition at line 419 of file miniport.c.

{
    if (Miniport->MiniportExtension == NULL ||
        Miniport->InitData->HwInitializationDataSize != sizeof(*Miniport->InitData) ||
        Miniport->InitData->HwFreeAdapterResources == NULL)
    {
        return;
    }
 
    DPRINT1("MiniportFreeAdapterResources(%p)\n", Miniport);
 
    Miniport->InitData->HwFreeAdapterResources(&Miniport->MiniportExtension->HwDeviceExtension);
}

Referenced by PortFdoPnp().

MiniportHwInitialize()

NTSTATUS MiniportHwInitialize

(

_In_ PMINIPORT

Miniport

)

Definition at line 399 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 436 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().

MiniportHwMSInterrupt()

BOOLEAN NTAPI MiniportHwMSInterrupt	(	_In_ PMINIPORT	Miniport,
		_In_ ULONG	MessageId
	)

Definition at line 603 of file miniport.c.

{
    BOOLEAN Result;
 
    DPRINT("MiniportHwMSInterrupt(%p %lu)\n",
            Miniport, MessageId);
 
    Result = Miniport->PortConfig.HwMSInterruptRoutine(&Miniport->MiniportExtension->HwDeviceExtension,
                                                       MessageId);
    DPRINT("HwMSInterruptRoutine() returned %u\n", Result);
 
    return Result;
}

Referenced by PortFdoMessageInterruptRoutine().

MiniportInitialize()

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

Definition at line 264 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;
 
    /* Win7 virtual miniports used a shorter structure, Win8 ones set a feature flag */
    Miniport->IsVirtual = (InitData->HwInitializationDataSize == HW_INIT_DATA_SIZE_VIRTUAL_LEGACY) ||
                          ((InitData->HwInitializationDataSize == sizeof(*InitData)) &&
                           (InitData->FeatureSupport & STOR_FEATURE_VIRTUAL_MINIPORT));
    DPRINT1("Miniport is %s\n", Miniport->IsVirtual ? "virtual" : "physical");
 
    /* 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;
}

MiniportQueryAdapterControl()

VOID NTAPI MiniportQueryAdapterControl

(

_In_ PMINIPORT

Miniport

)

Asks the miniport which adapter control requests it handles.

Definition at line 456 of file miniport.c.

{
    PSCSI_SUPPORTED_CONTROL_TYPE_LIST List;
    SCSI_ADAPTER_CONTROL_STATUS Result;
    ULONG Length;
    ULONG Type;
 
    Miniport->AdapterControlSupportedBitmap = 0;
 
    if (Miniport->InitData->HwAdapterControl == NULL)
        return;
 
    Length = sizeof(*List) +
             (ScsiAdapterControlMax * sizeof(List->SupportedTypeList[0]));
 
    List = ExAllocatePoolZero(NonPagedPool, Length, TAG_MINIPORT_DATA);
    if (List == NULL)
        return;
 
    List->MaxControlType = ScsiAdapterControlMax;
 
    Result = Miniport->InitData->HwAdapterControl(&Miniport->MiniportExtension->HwDeviceExtension,
                                                  ScsiQuerySupportedControlTypes,
                                                  List);
    if (Result == ScsiAdapterControlSuccess)
    {
        for (Type = 0; Type < ScsiAdapterControlMax; Type++)
        {
            C_ASSERT(ScsiAdapterControlMax <= RTL_BITS_OF(Miniport->AdapterControlSupportedBitmap));
 
            if (List->SupportedTypeList[Type])
            {
                DPRINT1("Adapter control %lu supported\n", Type);
                Miniport->AdapterControlSupportedBitmap |= 1 << Type;
            }
        }
    }
 
    ExFreePoolWithTag(List, TAG_MINIPORT_DATA);
}

Referenced by PortFdoStartMiniport().

MiniportQueryUnitControl()

VOID NTAPI MiniportQueryUnitControl

(

_In_ PMINIPORT

Miniport

)

Asks the miniport which unit control requests it handles.

Definition at line 529 of file miniport.c.

{
    PSCSI_SUPPORTED_CONTROL_TYPE_LIST List;
    SCSI_UNIT_CONTROL_STATUS Result;
    ULONG Length;
    ULONG Type;
 
    Miniport->UnitControlSupportedBitmap = 0;
 
    if (Miniport->InitData->HwInitializationDataSize <
        RTL_SIZEOF_THROUGH_FIELD(HW_INITIALIZATION_DATA, HwUnitControl) ||
        Miniport->InitData->HwUnitControl == NULL)
    {
        return;
    }
 
    Length = sizeof(*List) +
             (ScsiUnitControlMax * sizeof(List->SupportedTypeList[0]));
 
    List = ExAllocatePoolZero(NonPagedPool, Length, TAG_MINIPORT_DATA);
    if (List == NULL)
        return;
 
    List->MaxControlType = ScsiUnitControlMax;
 
    Result = Miniport->InitData->HwUnitControl(&Miniport->MiniportExtension->HwDeviceExtension,
                                               ScsiQuerySupportedUnitControlTypes,
                                               List);
    if (Result == ScsiUnitControlSuccess)
    {
        for (Type = 0; Type < ScsiUnitControlMax; Type++)
        {
            C_ASSERT(ScsiUnitControlMax <= RTL_BITS_OF(Miniport->UnitControlSupportedBitmap));
 
            if (List->SupportedTypeList[Type])
            {
                DPRINT1("Unit control %lu supported\n", Type);
                Miniport->UnitControlSupportedBitmap |= 1 << Type;
            }
        }
    }
 
    ExFreePoolWithTag(List, TAG_MINIPORT_DATA);
}

Referenced by PortFdoStartMiniport().

MiniportStartIo()

BOOLEAN MiniportStartIo	(	_In_ PMINIPORT	Miniport,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 621 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;
}

MiniportUnitControl()

SCSI_UNIT_CONTROL_STATUS NTAPI MiniportUnitControl	(	_In_ PMINIPORT	Miniport,
		_In_ SCSI_UNIT_CONTROL_TYPE	ControlType,
		_In_opt_ PVOID	Parameters
	)

Sends one unit control request, if the miniport claimed it.

Definition at line 581 of file miniport.c.

{
    DPRINT("MiniportUnitControl(%p %u %p)\n",
            Miniport, ControlType, Parameters);
 
    ASSERT(ControlType < ScsiUnitControlMax);
    if (!(Miniport->UnitControlSupportedBitmap & (1 << ControlType)))
    {
        return ScsiUnitControlNotSupported;
    }
 
    return Miniport->InitData->HwUnitControl(&Miniport->MiniportExtension->HwDeviceExtension,
                                             ControlType,
                                             Parameters);
}

Referenced by PortCreatePdo(), and PortDeletePdo().

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->Miniport.PortConfig.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 920 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;
    STOR_ADDR_BTL8 Address;
    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;
 
    /* Allocate the miniport's per unit extension before the unit is reachable */
    if (FdoDeviceExtension->HwInitData != NULL &&
        FdoDeviceExtension->HwInitData->SpecificLuExtensionSize != 0)
    {
        DeviceExtension->LunExtension =
            ExAllocatePoolZero(NonPagedPool,
                               FdoDeviceExtension->HwInitData->SpecificLuExtensionSize,
                               TAG_LUN_EXTENSION);
        if (DeviceExtension->LunExtension == NULL)
        {
            DPRINT1("No pool for the unit extension\n");
            IoDeleteDevice(Pdo);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    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 */
 
    /* Add the PDO to the PDO list only once a lookup can match its address */
    PortFdoLinkPdo(FdoDeviceExtension, DeviceExtension);
 
    /* Let the miniport know the unit is coming up */
    StorpBuildUnitAddress(DeviceExtension, &Address);
    MiniportUnitControl(&FdoDeviceExtension->Miniport, ScsiUnitStart, &Address);
 
    /* 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 126 of file pdo.c.

{
    STOR_ADDR_BTL8 Address;
 
    DPRINT("PortDeletePdo(%p)\n", PdoExtension);
 
    /* Tell the miniport before the unit goes away under it */
    StorpBuildUnitAddress(PdoExtension, &Address);
    MiniportUnitControl(&PdoExtension->FdoExtension->Miniport, ScsiUnitRemove, &Address);
 
    /* Remove the PDO from the PDO list*/
    PortFdoUnlinkPdo(PdoExtension->FdoExtension, PdoExtension);
 
    if (PdoExtension->InquiryBuffer)
    {
        ExFreePoolWithTag(PdoExtension->InquiryBuffer, TAG_INQUIRY_DATA);
        PdoExtension->InquiryBuffer = NULL;
    }
 
    /* The miniport was just told the unit is going, so what it kept goes too */
    if (PdoExtension->LunExtension)
    {
        ExFreePoolWithTag(PdoExtension->LunExtension, TAG_LUN_EXTENSION);
        PdoExtension->LunExtension = NULL;
    }
 
 
    // FIXME: More uninitialization
 
 
    /* Delete the PDO */
    IoDeleteDevice(PdoExtension->Device);
 
    return STATUS_SUCCESS;
}

Referenced by PortFdoScanBus().

PortFdoBusChangeDpc()

VOID NTAPI PortFdoBusChangeDpc	(	_In_ PKDPC	Dpc,
		_In_opt_ PVOID	DeferredContext,
		_In_opt_ PVOID	SystemArgument1,
		_In_opt_ PVOID	SystemArgument2
	)

Definition at line 1471 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION FdoExtension = (PFDO_DEVICE_EXTENSION)DeferredContext;
 
    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);
 
    DPRINT1("Bus change, invalidating bus relations\n");
 
    IoInvalidateDeviceRelations(FdoExtension->PhysicalDevice, BusRelations);
}

Referenced by PortAddDevice().

PortFdoDeviceControl()

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

Definition at line 147 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().

PortFdoLinkPdo()

VOID NTAPI PortFdoLinkPdo	(	_Inout_ PFDO_DEVICE_EXTENSION	FdoExtension,
		_Inout_ PPDO_DEVICE_EXTENSION	PdoExtension
	)

Adds a PDO where both the list lock and the interrupt service routines respect it.

Definition at line 1431 of file fdo.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
    KIRQL OldIrql;
 
    KeAcquireInStackQueuedSpinLock(&FdoExtension->PdoListLock, &LockHandle);
    OldIrql = PortFdoAcquireInterruptLocks(FdoExtension);
 
    InsertHeadList(&FdoExtension->PdoListHead, &PdoExtension->PdoListEntry);
    FdoExtension->PdoCount++;
 
    PortFdoReleaseInterruptLocks(FdoExtension, OldIrql);
    KeReleaseInStackQueuedSpinLock(&LockHandle);
}

Referenced by PortCreatePdo().

PortFdoPnp()

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

Definition at line 1519 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");
            PortFdoStopAdapter(DeviceExtension);
            PortFdoDisconnectInterrupt(DeviceExtension);
 
            /* Nothing may tell PnP about this adapter once it is gone */
            KeRemoveQueueDpc(&DeviceExtension->BusChangeDpc);
            KeFlushQueuedDpcs();
            MiniportFreeAdapterResources(&DeviceExtension->Miniport);
            PortFlushStarvedRequests(DeviceExtension);
            PortFreeRequestReserve(DeviceExtension);
            if (DeviceExtension->RequestReferenceLookasideInitialized)
            {
                ExDeleteNPagedLookasideList(&DeviceExtension->RequestReferenceLookaside);
                DeviceExtension->RequestReferenceLookasideInitialized = FALSE;
            }
            DeviceExtension->PnpState = dsRemoved;
            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");
            PortFdoStopAdapter(DeviceExtension);
            PortFdoDisconnectInterrupt(DeviceExtension);
            MiniportFreeAdapterResources(&DeviceExtension->Miniport);
            DeviceExtension->PnpState = dsStopped;
            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 1491 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().

PortFdoUnlinkPdo()

VOID NTAPI PortFdoUnlinkPdo	(	_Inout_ PFDO_DEVICE_EXTENSION	FdoExtension,
		_Inout_ PPDO_DEVICE_EXTENSION	PdoExtension
	)

Definition at line 1451 of file fdo.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
    KIRQL OldIrql;
 
    KeAcquireInStackQueuedSpinLock(&FdoExtension->PdoListLock, &LockHandle);
    OldIrql = PortFdoAcquireInterruptLocks(FdoExtension);
 
    RemoveEntryList(&PdoExtension->PdoListEntry);
    FdoExtension->PdoCount--;
 
    PortFdoReleaseInterruptLocks(FdoExtension, OldIrql);
    KeReleaseInStackQueuedSpinLock(&LockHandle);
}

Referenced by PortDeletePdo().

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 87 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 379 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 311 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);
        }
 
        RequestReference->WriteToDevice =
            TEST_FLAG(RequestReference->Srb->SrbFlags, SRB_FLAGS_DATA_OUT);
 
        /* A virtual miniport has no DMA adapter and moves the buffer itself through the MDL */
        if (FdoExtension->Miniport.IsVirtual)
        {
            PortPdoAfterBuildingScatterGatherList(FdoExtension->Device,
                                                  RequestReference->Irp,
                                                  NULL,
                                                  RequestReference);
            return STATUS_PENDING;
        }
 
        /* 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);
 
        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 710 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 429 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 548 of file srb.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
    PSCSI_REQUEST_BLOCK Srb;
    PPDO_DEVICE_EXTENSION PdoExtension;
    PFDO_DEVICE_EXTENSION FdoExtension;
    PMINIPORT Miniport;
 
    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;
 
    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, Miniport->PortConfig.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 */
            Status = 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().

StorpBuildExtendedSrb()

VOID NTAPI StorpBuildExtendedSrb	(	_In_ PSCSI_REQUEST_BLOCK	Srb,
		_Out_ PEXTENDED_REQUEST	Request
	)

Fills in the extended request a miniport will be given.

Parameters

Srb	The request as the class layer built it.
Request	Storage for the translated request, already zeroed.

Definition at line 102 of file srbex.c.

{
    PSTORAGE_REQUEST_BLOCK Extended = &Request->Srb;
 
    Extended->Length = sizeof(*Extended);
    Extended->Function = SRB_FUNCTION_STORAGE_REQUEST_BLOCK;
    Extended->SrbStatus = SRB_STATUS_PENDING;
    Extended->Signature = SRB_SIGNATURE;
    Extended->Version = STORAGE_REQUEST_BLOCK_VERSION_1;
    Extended->SrbLength = sizeof(*Request);
    Extended->SrbFunction = Srb->Function;
    Extended->SrbFlags = Srb->SrbFlags;
    Extended->RequestTag = Srb->QueueTag;
    Extended->RequestAttribute = Srb->QueueAction;
    Extended->TimeOutValue = Srb->TimeOutValue;
    Extended->DataTransferLength = Srb->DataTransferLength;
    Extended->DataBuffer = Srb->DataBuffer;
 
    /* The miniport hands this straight back to us on completion */
    Extended->OriginalRequest = Srb->OriginalRequest;
    Extended->MiniportContext = Srb->SrbExtension;
 
    Extended->AddressOffset = FIELD_OFFSET(EXTENDED_REQUEST, Address);
 
    Request->Address.Type = STOR_ADDRESS_TYPE_BTL8;
    Request->Address.AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
    Request->Address.Path = Srb->PathId;
    Request->Address.Target = Srb->TargetId;
    Request->Address.Lun = Srb->Lun;
 
    /* Only SRB_FUNCTION_EXECUTE_SCSI carries a CDB */
    if (Srb->Function != SRB_FUNCTION_EXECUTE_SCSI)
        return;
 
    Extended->NumSrbExData = 1;
    Extended->SrbExDataOffset[0] = FIELD_OFFSET(EXTENDED_REQUEST, Cdb);
 
    Request->Cdb.Type = SrbExDataTypeScsiCdb16;
    Request->Cdb.Length = SRBEX_DATA_SCSI_CDB16_LENGTH;
    Request->Cdb.ScsiStatus = Srb->ScsiStatus;
    Request->Cdb.SenseInfoBufferLength = Srb->SenseInfoBufferLength;
    Request->Cdb.CdbLength = Srb->CdbLength;
    Request->Cdb.SenseInfoBuffer = Srb->SenseInfoBuffer;
 
    RtlCopyMemory(Request->Cdb.Cdb, Srb->Cdb, sizeof(Request->Cdb.Cdb));
}

Referenced by PortPdoAfterBuildingScatterGatherList().

StorpBuildUnitAddress()

VOID NTAPI StorpBuildUnitAddress	(	_In_ PPDO_DEVICE_EXTENSION	PdoExtension,
		_Out_ PSTOR_ADDR_BTL8	Address
	)

Fills in the bus, target and LUN address of a logical unit.

Definition at line 28 of file srbex.c.

{
    RtlZeroMemory(Address, sizeof(*Address));
 
    Address->Type = STOR_ADDRESS_TYPE_BTL8;
    Address->AddressLength = STOR_ADDR_BTL8_ADDRESS_LENGTH;
    Address->Path = (UCHAR)PdoExtension->Bus;
    Address->Target = (UCHAR)PdoExtension->Target;
    Address->Lun = (UCHAR)PdoExtension->Lun;
}

Referenced by PortCreatePdo(), and PortDeletePdo().

StorpCompleteExtendedSrb()

VOID NTAPI StorpCompleteExtendedSrb	(	_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ PEXTENDED_REQUEST	Request
	)

Carries the miniport's answer back to the original request block.

Definition at line 157 of file srbex.c.

{
    PSTORAGE_REQUEST_BLOCK Extended = &Request->Srb;
 
    Srb->SrbStatus = Extended->SrbStatus;
    Srb->DataTransferLength = Extended->DataTransferLength;
 
    if (Extended->NumSrbExData == 0)
        return;
 
    Srb->ScsiStatus = Request->Cdb.ScsiStatus;
    Srb->SenseInfoBufferLength = Request->Cdb.SenseInfoBufferLength;
}

Referenced by StorPortNotification().

StorpIsExtendedSrb()

BOOLEAN NTAPI StorpIsExtendedSrb

(

_In_ PVOID

Srb

)

Tells whether a request block is in the extended format.

Definition at line 47 of file srbex.c.

{
    PSTORAGE_REQUEST_BLOCK_HEADER Header = (PSTORAGE_REQUEST_BLOCK_HEADER)Srb;
 
    return (Header->Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK);
}

Referenced by StorPortNotification(), StorpRequestReference(), and StorpSrbDataBuffer().

StorpRequestReference()

PQUEUED_REQUEST_REFERENCE NTAPI StorpRequestReference

(

_In_ PSCSI_REQUEST_BLOCK

Srb

)

Finds the request reference behind an SRB in either format.

Definition at line 61 of file srbex.c.

{
    if (StorpIsExtendedSrb(Srb))
    {
        PSTORAGE_REQUEST_BLOCK Extended = (PSTORAGE_REQUEST_BLOCK)Srb;
 
        return (PQUEUED_REQUEST_REFERENCE)Extended->OriginalRequest;
    }
 
    return (PQUEUED_REQUEST_REFERENCE)Srb->OriginalRequest;
}

Referenced by StorPortExtendedFunction(), StorPortGetScatterGatherList(), and StorPortNotification().

StorpSrbDataBuffer()

PVOID NTAPI StorpSrbDataBuffer

(

_In_ PSCSI_REQUEST_BLOCK

Srb

)

Finds the data buffer of a request in either format.

Definition at line 80 of file srbex.c.

{
    if (StorpIsExtendedSrb(Srb))
    {
        PSTORAGE_REQUEST_BLOCK Extended = (PSTORAGE_REQUEST_BLOCK)Srb;
 
        return Extended->DataBuffer;
    }
 
    return Srb->DataBuffer;
}

Referenced by StorPortExtendedFunction().

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 112 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().