scsiport.h File Reference

#include <ntifs.h>
#include <stdio.h>
#include <scsi.h>
#include <ntddscsi.h>
#include <ntdddisk.h>
#include <mountdev.h>

Include dependency graph for scsiport.h:

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

Go to the source code of this file.

Classes
struct	_STORAGE_ADAPTER_DESCRIPTOR_WIN8
struct	_CONFIGURATION_INFO
struct	_SCSI_PORT_DEVICE_BASE
struct	_SCSI_SG_ADDRESS
struct	_SCSI_REQUEST_BLOCK_INFO
struct	_SCSI_PORT_COMMON_EXTENSION
struct	_SCSI_PORT_LUN_EXTENSION
struct	_SCSI_BUS_INFO
struct	_SCSI_PORT_INTERRUPT_DATA
struct	_SCSI_PORT_SAVE_INTERRUPT
struct	_SCSI_PORT_DEVICE_EXTENSION
struct	_RESETBUS_PARAMS
struct	_SCSIPORT_DRIVER_EXTENSION

Macros
#define	TAG_SCSIPORT   'ISCS'
#define	LUS_NUMBER   8
#define	MAX_SG_LIST   17
#define	SCSI_PORT_DEVICE_BUSY   0x00001
#define	SCSI_PORT_LU_ACTIVE   0x00002
#define	SCSI_PORT_NOTIFICATION_NEEDED   0x00004
#define	SCSI_PORT_NEXT_REQUEST_READY   0x00008
#define	SCSI_PORT_FLUSH_ADAPTERS   0x00010
#define	SCSI_PORT_MAP_TRANSFER   0x00020
#define	SCSI_PORT_RESET   0x00080
#define	SCSI_PORT_RESET_REQUEST   0x00100
#define	SCSI_PORT_RESET_REPORTED   0x00200
#define	SCSI_PORT_REQUEST_PENDING   0x00800
#define	SCSI_PORT_DISCONNECT_ALLOWED   0x01000
#define	SCSI_PORT_DISABLE_INT_REQUESET   0x02000
#define	SCSI_PORT_DISABLE_INTERRUPTS   0x04000
#define	SCSI_PORT_ENABLE_INT_REQUEST   0x08000
#define	SCSI_PORT_TIMER_NEEDED   0x10000
#define	LUNEX_FROZEN_QUEUE   0x0001
#define	LUNEX_NEED_REQUEST_SENSE   0x0004
#define	LUNEX_BUSY   0x0008
#define	LUNEX_FULL_QUEUE   0x0010
#define	LUNEX_REQUEST_PENDING   0x0020
#define	SCSI_PORT_SCAN_IN_PROGRESS   0x8000
#define	ALIGNAS_PTR   DECLSPEC_ALIGN(4)

Typedefs
typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8	STORAGE_ADAPTER_DESCRIPTOR_WIN8
typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 *	PSTORAGE_ADAPTER_DESCRIPTOR_WIN8
typedef enum _SCSI_PORT_TIMER_STATES	SCSI_PORT_TIMER_STATES
typedef struct _CONFIGURATION_INFO	CONFIGURATION_INFO
typedef struct _CONFIGURATION_INFO *	PCONFIGURATION_INFO
typedef struct _SCSI_PORT_DEVICE_BASE	SCSI_PORT_DEVICE_BASE
typedef struct _SCSI_PORT_DEVICE_BASE *	PSCSI_PORT_DEVICE_BASE
typedef struct _SCSI_SG_ADDRESS	SCSI_SG_ADDRESS
typedef struct _SCSI_SG_ADDRESS *	PSCSI_SG_ADDRESS
typedef struct _SCSI_REQUEST_BLOCK_INFO	SCSI_REQUEST_BLOCK_INFO
typedef struct _SCSI_REQUEST_BLOCK_INFO *	PSCSI_REQUEST_BLOCK_INFO
typedef struct _SCSI_PORT_COMMON_EXTENSION	SCSI_PORT_COMMON_EXTENSION
typedef struct _SCSI_PORT_COMMON_EXTENSION *	PSCSI_PORT_COMMON_EXTENSION
typedef struct _SCSI_PORT_LUN_EXTENSION	SCSI_PORT_LUN_EXTENSION
typedef struct _SCSI_PORT_LUN_EXTENSION *	PSCSI_PORT_LUN_EXTENSION
typedef struct _SCSI_BUS_INFO	SCSI_BUS_INFO
typedef struct _SCSI_BUS_INFO *	PSCSI_BUS_INFO
typedef struct _SCSI_PORT_INTERRUPT_DATA	SCSI_PORT_INTERRUPT_DATA
typedef struct _SCSI_PORT_INTERRUPT_DATA *	PSCSI_PORT_INTERRUPT_DATA
typedef struct _SCSI_PORT_SAVE_INTERRUPT	SCSI_PORT_SAVE_INTERRUPT
typedef struct _SCSI_PORT_SAVE_INTERRUPT *	PSCSI_PORT_SAVE_INTERRUPT
typedef struct _SCSI_PORT_DEVICE_EXTENSION	SCSI_PORT_DEVICE_EXTENSION
typedef struct _SCSI_PORT_DEVICE_EXTENSION *	PSCSI_PORT_DEVICE_EXTENSION
typedef struct _RESETBUS_PARAMS	RESETBUS_PARAMS
typedef struct _RESETBUS_PARAMS *	PRESETBUS_PARAMS
typedef struct _SCSIPORT_DRIVER_EXTENSION	SCSI_PORT_DRIVER_EXTENSION
typedef struct _SCSIPORT_DRIVER_EXTENSION *	PSCSI_PORT_DRIVER_EXTENSION

Enumerations
enum	_SCSI_PORT_TIMER_STATES { IDETimerIdle , IDETimerCmdWait , IDETimerResetWaitForBusyNegate , IDETimerResetWaitForDrdyAssert }

Functions
FORCEINLINE BOOLEAN	VerifyIrpOutBufferSize (_In_ PIRP Irp, _In_ SIZE_T Size)
FORCEINLINE BOOLEAN	VerifyIrpInBufferSize (_In_ PIRP Irp, _In_ SIZE_T Size)
NTSTATUS NTAPI	ScsiPortDeviceControl (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
VOID	FdoScanAdapter (_In_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	FdoCallHWInitialize (_In_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension)
	Calls HwInitialize routine of the miniport and sets up interrupts Should be called inside ScsiPortInitialize (for legacy drivers) or inside IRP_MN_START_DEVICE for pnp drivers.
NTSTATUS	FdoRemoveAdapter (_In_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	FdoStartAdapter (_In_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	FdoDispatchPnp (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
PDEVICE_OBJECT	PdoCreateLunDevice (_In_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension)
PSCSI_PORT_LUN_EXTENSION	GetLunByPath (_In_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension, _In_ UCHAR PathId, _In_ UCHAR TargetId, _In_ UCHAR Lun)
PSCSI_REQUEST_BLOCK_INFO	SpiGetSrbData (_In_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_PORT_LUN_EXTENSION LunExtension, _In_ UCHAR QueueTag)
NTSTATUS	PdoDispatchPnp (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
VOID	SpiInitOpenKeys (_Inout_ PCONFIGURATION_INFO ConfigInfo, _In_ PSCSI_PORT_DRIVER_EXTENSION DriverExtension)
NTSTATUS	RegistryInitAdapterKey (_Inout_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	RegistryInitLunKey (_Inout_ PSCSI_PORT_LUN_EXTENSION LunExtension)
VOID	SpiGetNextRequestFromLun (_In_ PSCSI_PORT_DEVICE_EXTENSION DeviceExtension, _Inout_ PSCSI_PORT_LUN_EXTENSION LunExtension, _Inout_opt_ PKIRQL OldIrql)
IO_ALLOCATION_ACTION NTAPI	SpiAdapterControl (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PVOID MapRegisterBase, _In_ PVOID Context)
IO_ALLOCATION_ACTION NTAPI	ScsiPortAllocateAdapterChannel (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PVOID MapRegisterBase, _In_ PVOID Context)

Variables
DRIVER_DISPATCH	ScsiPortDispatchPower
IO_DPC_ROUTINE	ScsiPortDpcForIsr
DRIVER_DISPATCH	ScsiPortDispatchScsi
KSYNCHRONIZE_ROUTINE	ScsiPortStartPacket
DRIVER_STARTIO	ScsiPortStartIo
KSERVICE_ROUTINE	ScsiPortIsr

Macro Definition Documentation

ALIGNAS_PTR

#define ALIGNAS_PTR   DECLSPEC_ALIGN(4)

Definition at line 223 of file scsiport.h.

LUNEX_BUSY

#define LUNEX_BUSY   0x0008

Definition at line 48 of file scsiport.h.

LUNEX_FROZEN_QUEUE

#define LUNEX_FROZEN_QUEUE   0x0001

Definition at line 46 of file scsiport.h.

LUNEX_FULL_QUEUE

#define LUNEX_FULL_QUEUE   0x0010

Definition at line 49 of file scsiport.h.

LUNEX_NEED_REQUEST_SENSE

#define LUNEX_NEED_REQUEST_SENSE   0x0004

Definition at line 47 of file scsiport.h.

LUNEX_REQUEST_PENDING

#define LUNEX_REQUEST_PENDING   0x0020

Definition at line 50 of file scsiport.h.

LUS_NUMBER

#define LUS_NUMBER   8

Definition at line 24 of file scsiport.h.

MAX_SG_LIST

#define MAX_SG_LIST   17

Definition at line 26 of file scsiport.h.

SCSI_PORT_DEVICE_BUSY

#define SCSI_PORT_DEVICE_BUSY   0x00001

Definition at line 29 of file scsiport.h.

SCSI_PORT_DISABLE_INT_REQUESET

#define SCSI_PORT_DISABLE_INT_REQUESET   0x02000

Definition at line 40 of file scsiport.h.

SCSI_PORT_DISABLE_INTERRUPTS

#define SCSI_PORT_DISABLE_INTERRUPTS   0x04000

Definition at line 41 of file scsiport.h.

SCSI_PORT_DISCONNECT_ALLOWED

#define SCSI_PORT_DISCONNECT_ALLOWED   0x01000

Definition at line 39 of file scsiport.h.

SCSI_PORT_ENABLE_INT_REQUEST

#define SCSI_PORT_ENABLE_INT_REQUEST   0x08000

Definition at line 42 of file scsiport.h.

SCSI_PORT_FLUSH_ADAPTERS

#define SCSI_PORT_FLUSH_ADAPTERS   0x00010

Definition at line 33 of file scsiport.h.

SCSI_PORT_LU_ACTIVE

#define SCSI_PORT_LU_ACTIVE   0x00002

Definition at line 30 of file scsiport.h.

SCSI_PORT_MAP_TRANSFER

#define SCSI_PORT_MAP_TRANSFER   0x00020

Definition at line 34 of file scsiport.h.

SCSI_PORT_NEXT_REQUEST_READY

#define SCSI_PORT_NEXT_REQUEST_READY   0x00008

Definition at line 32 of file scsiport.h.

SCSI_PORT_NOTIFICATION_NEEDED

#define SCSI_PORT_NOTIFICATION_NEEDED   0x00004

Definition at line 31 of file scsiport.h.

SCSI_PORT_REQUEST_PENDING

#define SCSI_PORT_REQUEST_PENDING   0x00800

Definition at line 38 of file scsiport.h.

SCSI_PORT_RESET

#define SCSI_PORT_RESET   0x00080

Definition at line 35 of file scsiport.h.

SCSI_PORT_RESET_REPORTED

#define SCSI_PORT_RESET_REPORTED   0x00200

Definition at line 37 of file scsiport.h.

SCSI_PORT_RESET_REQUEST

#define SCSI_PORT_RESET_REQUEST   0x00100

Definition at line 36 of file scsiport.h.

SCSI_PORT_SCAN_IN_PROGRESS

#define SCSI_PORT_SCAN_IN_PROGRESS   0x8000

Definition at line 51 of file scsiport.h.

SCSI_PORT_TIMER_NEEDED

#define SCSI_PORT_TIMER_NEEDED   0x10000

Definition at line 43 of file scsiport.h.

TAG_SCSIPORT

#define TAG_SCSIPORT   'ISCS'

Definition at line 21 of file scsiport.h.

Typedef Documentation

CONFIGURATION_INFO

typedef struct _CONFIGURATION_INFO CONFIGURATION_INFO

PCONFIGURATION_INFO

typedef struct _CONFIGURATION_INFO * PCONFIGURATION_INFO

PRESETBUS_PARAMS

typedef struct _RESETBUS_PARAMS * PRESETBUS_PARAMS

PSCSI_BUS_INFO

typedef struct _SCSI_BUS_INFO * PSCSI_BUS_INFO

PSCSI_PORT_COMMON_EXTENSION

typedef struct _SCSI_PORT_COMMON_EXTENSION * PSCSI_PORT_COMMON_EXTENSION

PSCSI_PORT_DEVICE_BASE

typedef struct _SCSI_PORT_DEVICE_BASE * PSCSI_PORT_DEVICE_BASE

PSCSI_PORT_DEVICE_EXTENSION

typedef struct _SCSI_PORT_DEVICE_EXTENSION * PSCSI_PORT_DEVICE_EXTENSION

PSCSI_PORT_DRIVER_EXTENSION

typedef struct _SCSIPORT_DRIVER_EXTENSION * PSCSI_PORT_DRIVER_EXTENSION

PSCSI_PORT_INTERRUPT_DATA

typedef struct _SCSI_PORT_INTERRUPT_DATA * PSCSI_PORT_INTERRUPT_DATA

PSCSI_PORT_LUN_EXTENSION

typedef struct _SCSI_PORT_LUN_EXTENSION * PSCSI_PORT_LUN_EXTENSION

PSCSI_PORT_SAVE_INTERRUPT

typedef struct _SCSI_PORT_SAVE_INTERRUPT * PSCSI_PORT_SAVE_INTERRUPT

PSCSI_REQUEST_BLOCK_INFO

typedef struct _SCSI_REQUEST_BLOCK_INFO * PSCSI_REQUEST_BLOCK_INFO

PSCSI_SG_ADDRESS

typedef struct _SCSI_SG_ADDRESS * PSCSI_SG_ADDRESS

PSTORAGE_ADAPTER_DESCRIPTOR_WIN8

typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 * PSTORAGE_ADAPTER_DESCRIPTOR_WIN8

RESETBUS_PARAMS

typedef struct _RESETBUS_PARAMS RESETBUS_PARAMS

SCSI_BUS_INFO

typedef struct _SCSI_BUS_INFO SCSI_BUS_INFO

SCSI_PORT_COMMON_EXTENSION

typedef struct _SCSI_PORT_COMMON_EXTENSION SCSI_PORT_COMMON_EXTENSION

SCSI_PORT_DEVICE_BASE

typedef struct _SCSI_PORT_DEVICE_BASE SCSI_PORT_DEVICE_BASE

SCSI_PORT_DEVICE_EXTENSION

typedef struct _SCSI_PORT_DEVICE_EXTENSION SCSI_PORT_DEVICE_EXTENSION

SCSI_PORT_DRIVER_EXTENSION

typedef struct _SCSIPORT_DRIVER_EXTENSION SCSI_PORT_DRIVER_EXTENSION

SCSI_PORT_INTERRUPT_DATA

typedef struct _SCSI_PORT_INTERRUPT_DATA SCSI_PORT_INTERRUPT_DATA

SCSI_PORT_LUN_EXTENSION

typedef struct _SCSI_PORT_LUN_EXTENSION SCSI_PORT_LUN_EXTENSION

SCSI_PORT_SAVE_INTERRUPT

typedef struct _SCSI_PORT_SAVE_INTERRUPT SCSI_PORT_SAVE_INTERRUPT

SCSI_PORT_TIMER_STATES

typedef enum _SCSI_PORT_TIMER_STATES SCSI_PORT_TIMER_STATES

SCSI_REQUEST_BLOCK_INFO

typedef struct _SCSI_REQUEST_BLOCK_INFO SCSI_REQUEST_BLOCK_INFO

SCSI_SG_ADDRESS

typedef struct _SCSI_SG_ADDRESS SCSI_SG_ADDRESS

STORAGE_ADAPTER_DESCRIPTOR_WIN8

typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 STORAGE_ADAPTER_DESCRIPTOR_WIN8

Enumeration Type Documentation

_SCSI_PORT_TIMER_STATES

enum _SCSI_PORT_TIMER_STATES

Enumerator
IDETimerIdle
IDETimerCmdWait
IDETimerResetWaitForBusyNegate
IDETimerResetWaitForDrdyAssert

Definition at line 71 of file scsiport.h.

{
    IDETimerIdle,
    IDETimerCmdWait,
    IDETimerResetWaitForBusyNegate,
    IDETimerResetWaitForDrdyAssert
} SCSI_PORT_TIMER_STATES;

Function Documentation

FdoCallHWInitialize()

NTSTATUS FdoCallHWInitialize

(

_In_ PSCSI_PORT_DEVICE_EXTENSION

DeviceExtension

)

Calls HwInitialize routine of the miniport and sets up interrupts Should be called inside ScsiPortInitialize (for legacy drivers) or inside IRP_MN_START_DEVICE for pnp drivers.

Parameters

[in]

DeviceExtension

The device extension

Returns

NTSTATUS of the operation

Definition at line 366 of file fdo.c.

{
    PPORT_CONFIGURATION_INFORMATION PortConfig = DeviceExtension->PortConfig;
    NTSTATUS Status;
    KIRQL OldIrql;
 
    /* Deal with interrupts */
    if (DeviceExtension->HwInterrupt == NULL ||
        (PortConfig->BusInterruptLevel == 0 && PortConfig->BusInterruptVector == 0))
    {
        /* No interrupts */
        DeviceExtension->InterruptCount = 0;
 
        DPRINT1("Interrupt Count: 0\n");
 
        UNIMPLEMENTED;
 
        /* This code path will ALWAYS crash so stop it now */
        __debugbreak();
    }
    else
    {
        BOOLEAN InterruptShareable;
        KINTERRUPT_MODE InterruptMode[2];
        ULONG InterruptVector[2], i, MappedIrq[2];
        KIRQL Dirql[2], MaxDirql;
        KAFFINITY Affinity[2];
 
        DeviceExtension->InterruptLevel[0] = PortConfig->BusInterruptLevel;
        DeviceExtension->InterruptLevel[1] = PortConfig->BusInterruptLevel2;
 
        InterruptVector[0] = PortConfig->BusInterruptVector;
        InterruptVector[1] = PortConfig->BusInterruptVector2;
 
        InterruptMode[0] = PortConfig->InterruptMode;
        InterruptMode[1] = PortConfig->InterruptMode2;
 
        DeviceExtension->InterruptCount =
            (PortConfig->BusInterruptLevel2 != 0 ||
             PortConfig->BusInterruptVector2 != 0) ? 2 : 1;
 
        for (i = 0; i < DeviceExtension->InterruptCount; i++)
        {
            /* Register an interrupt handler for this device */
            MappedIrq[i] = HalGetInterruptVector(
                PortConfig->AdapterInterfaceType, PortConfig->SystemIoBusNumber,
                DeviceExtension->InterruptLevel[i], InterruptVector[i], &Dirql[i],
                &Affinity[i]);
        }
 
        if (DeviceExtension->InterruptCount == 1 || Dirql[0] > Dirql[1])
        {
            MaxDirql = Dirql[0];
        }
        else
        {
            MaxDirql = Dirql[1];
        }
 
        for (i = 0; i < DeviceExtension->InterruptCount; i++)
        {
            /* Determine IRQ sharability as usual */
            if (PortConfig->AdapterInterfaceType == MicroChannel ||
                InterruptMode[i] == LevelSensitive)
            {
                InterruptShareable = TRUE;
            }
            else
            {
                InterruptShareable = FALSE;
            }
 
            Status = IoConnectInterrupt(&DeviceExtension->Interrupt[i],
                                        ScsiPortIsr,
                                        DeviceExtension,
                                        &DeviceExtension->IrqLock,
                                        MappedIrq[i], Dirql[i],
                                        MaxDirql,
                                        InterruptMode[i],
                                        InterruptShareable,
                                        Affinity[i],
                                        FALSE);
 
            if (!(NT_SUCCESS(Status)))
            {
                DPRINT1("Could not connect interrupt %d\n", InterruptVector[i]);
                DeviceExtension->Interrupt[i] = NULL;
                return Status;
            }
        }
    }
 
    /* Save IoAddress (from access ranges) */
    if (PortConfig->NumberOfAccessRanges != 0)
    {
        DeviceExtension->IoAddress = ((*(PortConfig->AccessRanges))[0]).RangeStart.LowPart;
 
        DPRINT("Io Address %x\n", DeviceExtension->IoAddress);
    }
 
    /* Set flag that it's allowed to disconnect during this command */
    DeviceExtension->Flags |= SCSI_PORT_DISCONNECT_ALLOWED;
 
    /* Initialize counter of active requests (-1 means there are none) */
    DeviceExtension->ActiveRequestCounter = -1;
 
    /* Analyze what we have about DMA */
    if (DeviceExtension->AdapterObject != NULL && PortConfig->Master &&
        PortConfig->NeedPhysicalAddresses)
    {
        DeviceExtension->MapRegisters = TRUE;
    }
    else
    {
        DeviceExtension->MapRegisters = FALSE;
    }
 
    /* Call HwInitialize at DISPATCH_LEVEL */
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 
    if (!KeSynchronizeExecution(
            DeviceExtension->Interrupt[0], DeviceExtension->HwInitialize,
            DeviceExtension->MiniPortDeviceExtension))
    {
        DPRINT1("HwInitialize() failed!\n");
        KeLowerIrql(OldIrql);
        return STATUS_ADAPTER_HARDWARE_ERROR;
    }
 
    /* Check if a notification is needed */
    if (DeviceExtension->InterruptData.Flags & SCSI_PORT_NOTIFICATION_NEEDED)
    {
        /* Call DPC right away, because we're already at DISPATCH_LEVEL */
        ScsiPortDpcForIsr(NULL, DeviceExtension->Common.DeviceObject, NULL, NULL);
    }
 
    /* Lower irql back to what it was */
    KeLowerIrql(OldIrql);
 
    return STATUS_SUCCESS;
}

Referenced by ScsiPortInitialize().

FdoDispatchPnp()

NTSTATUS FdoDispatchPnp	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 758 of file fdo.c.

{
    PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp);
    PSCSI_PORT_DEVICE_EXTENSION portExt = DeviceObject->DeviceExtension;
    NTSTATUS status;
 
    ASSERT(portExt->Common.IsFDO);
 
    DPRINT("FDO PnP request %s\n", GetIRPMinorFunctionString(ioStack->MinorFunction));
 
    switch (ioStack->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
        {
            // as we don't support PnP yet, this is a no-op for us
            // (FdoStartAdapter is being called during initialization for legacy miniports)
            status = STATUS_SUCCESS;
            // status = FdoStartAdapter(DeviceExtension);
            break;
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            return FdoHandleDeviceRelations(portExt, Irp);
        }
        case IRP_MN_QUERY_ID:
        {
            if (ioStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
            {
                Irp->IoStatus.Information = 0;
                IoForwardIrpSynchronously(portExt->Common.LowerDevice, Irp);
                status = FdoHandleQueryCompatibleId((PZZWSTR*)&Irp->IoStatus.Information);
                break;
            }
            // otherwise fall through the default case
        }
        default:
        {
            // forward irp to next device object
            IoCopyCurrentIrpStackLocationToNext(Irp);
            return IoCallDriver(portExt->Common.LowerDevice, Irp);
        }
    }
 
    if (status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return status;
}

Referenced by ScsiPortDispatchPnp().

FdoRemoveAdapter()

NTSTATUS FdoRemoveAdapter

(

_In_ PSCSI_PORT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 510 of file fdo.c.

{
    IoStopTimer(DeviceExtension->Common.DeviceObject);
 
    // release device interface
    if (DeviceExtension->InterfaceName.Buffer)
    {
        IoSetDeviceInterfaceState(&DeviceExtension->InterfaceName, FALSE);
 
        RtlFreeUnicodeString(&DeviceExtension->InterfaceName);
        RtlInitUnicodeString(&DeviceExtension->InterfaceName, NULL);
    }
 
    // remove the dos device link
    WCHAR dosNameBuffer[12];
    UNICODE_STRING dosDeviceName;
 
    swprintf(dosNameBuffer, L"\\??\\Scsi%lu:", DeviceExtension->PortNumber);
    RtlInitUnicodeString(&dosDeviceName, dosNameBuffer);
 
    IoDeleteSymbolicLink(&dosDeviceName); // don't check the result
 
    // decrease the port count
    if (DeviceExtension->DeviceStarted)
    {
        PCONFIGURATION_INFORMATION sysConfig = IoGetConfigurationInformation();
        sysConfig->ScsiPortCount--;
    }
 
    // disconnect the interrupts
    while (DeviceExtension->InterruptCount)
    {
        if (DeviceExtension->Interrupt[--DeviceExtension->InterruptCount])
            IoDisconnectInterrupt(DeviceExtension->Interrupt[DeviceExtension->InterruptCount]);
    }
 
    // FIXME: delete LUNs
    if (DeviceExtension->Buses)
    {
        for (UINT8 pathId = 0; pathId < DeviceExtension->NumberOfBuses; pathId++)
        {
            PSCSI_BUS_INFO bus = &DeviceExtension->Buses[pathId];
            if (bus->RegistryMapKey)
            {
                ZwDeleteKey(bus->RegistryMapKey);
                ZwClose(bus->RegistryMapKey);
                bus->RegistryMapKey = NULL;
            }
        }
 
        ExFreePoolWithTag(DeviceExtension->Buses, TAG_SCSIPORT);
    }
 
    /* Free PortConfig */
    if (DeviceExtension->PortConfig)
    {
        ExFreePoolWithTag(DeviceExtension->PortConfig, TAG_SCSIPORT);
    }
 
    /* Free common buffer (if it exists) */
    if (DeviceExtension->SrbExtensionBuffer != NULL && DeviceExtension->CommonBufferLength != 0)
    {
        if (!DeviceExtension->AdapterObject)
        {
            ExFreePoolWithTag(DeviceExtension->SrbExtensionBuffer, TAG_SCSIPORT);
        }
        else
        {
            HalFreeCommonBuffer(DeviceExtension->AdapterObject,
                                DeviceExtension->CommonBufferLength,
                                DeviceExtension->PhysicalAddress,
                                DeviceExtension->SrbExtensionBuffer,
                                FALSE);
        }
    }
 
    /* Free SRB info */
    if (DeviceExtension->SrbInfo != NULL)
        ExFreePoolWithTag(DeviceExtension->SrbInfo, TAG_SCSIPORT);
 
    /* Unmap mapped addresses */
    while (DeviceExtension->MappedAddressList != NULL)
    {
        MmUnmapIoSpace(DeviceExtension->MappedAddressList->MappedAddress,
                       DeviceExtension->MappedAddressList->NumberOfBytes);
 
        PVOID ptr = DeviceExtension->MappedAddressList;
        DeviceExtension->MappedAddressList = DeviceExtension->MappedAddressList->NextMappedAddress;
 
        ExFreePoolWithTag(ptr, TAG_SCSIPORT);
    }
 
    IoDeleteDevice(DeviceExtension->Common.DeviceObject);
 
    return STATUS_SUCCESS;
}

Referenced by ScsiPortInitialize().

FdoScanAdapter()

VOID FdoScanAdapter

(

_In_ PSCSI_PORT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 222 of file fdo.c.

{
    NTSTATUS status;
    UINT32 totalLUNs = PortExtension->TotalLUCount;
 
    DPRINT("FdoScanAdapter() called\n");
 
    /* Scan all buses */
    for (UINT8 pathId = 0; pathId < PortExtension->NumberOfBuses; pathId++)
    {
        DPRINT("    Scanning bus/pathID %u\n", pathId);
 
        /* Get pointer to the scan information */
        PSCSI_BUS_INFO currentBus = &PortExtension->Buses[pathId];
 
        /* And send INQUIRY to every target */
        for (UINT8 targetId = 0;
             targetId < PortExtension->PortConfig->MaximumNumberOfTargets;
             targetId++)
        {
            BOOLEAN targetFound = FALSE;
 
            /* TODO: Support scan bottom-up */
 
            /* Skip if it's the same address */
            if (targetId == currentBus->BusIdentifier)
                continue;
 
            /* Scan all logical units */
            for (UINT8 lun = 0; lun < PortExtension->MaxLunCount; lun++)
            {
                PSCSI_PORT_LUN_EXTENSION lunExt;
 
                /* Skip invalid lun values */
                if (lun >= PortExtension->PortConfig->MaximumNumberOfLogicalUnits)
                    continue;
 
                // try to find an existing device
                lunExt = GetLunByPath(PortExtension,
                                      pathId,
                                      targetId,
                                      lun);
 
                if (lunExt)
                {
                    // check if the device still exists
                    status = FdoSendInquiry(lunExt->Common.DeviceObject);
                    if (!NT_SUCCESS(status))
                    {
                        // remove the device
                        UNIMPLEMENTED;
                        __debugbreak();
                    }
 
                    if (lunExt->InquiryData.DeviceTypeQualifier == DEVICE_QUALIFIER_NOT_SUPPORTED)
                    {
                        // remove the device
                        UNIMPLEMENTED;
                        __debugbreak();
                    }
 
                    /* Decide whether we are continuing or not */
                    if (status == STATUS_INVALID_DEVICE_REQUEST)
                        continue;
                    else
                        break;
                }
 
                // create a new LUN device
                PDEVICE_OBJECT lunPDO = PdoCreateLunDevice(PortExtension);
                if (!lunPDO)
                {
                    continue;
                }
 
                lunExt = lunPDO->DeviceExtension;
 
                lunExt->PathId = pathId;
                lunExt->TargetId = targetId;
                lunExt->Lun = lun;
 
                DPRINT("Add PDO to list: PDO: %p, FDOExt: %p, PDOExt: %p\n", lunPDO, PortExtension, lunExt);
 
                /* Set flag to prevent race conditions */
                lunExt->Flags |= SCSI_PORT_SCAN_IN_PROGRESS;
 
                /* Finally send the inquiry command */
                status = FdoSendInquiry(lunPDO);
 
                if (NT_SUCCESS(status))
                {
                    /* Let's see if we really found a device */
                    PINQUIRYDATA InquiryData = &lunExt->InquiryData;
 
                    /* Check if this device is unsupported */
                    if (InquiryData->DeviceTypeQualifier == DEVICE_QUALIFIER_NOT_SUPPORTED)
                    {
                        IoDeleteDevice(lunPDO);
                        continue;
                    }
 
                    /* Clear the "in scan" flag */
                    lunExt->Flags &= ~SCSI_PORT_SCAN_IN_PROGRESS;
 
                    DPRINT1("Found device of type %d at controller %d bus %d tid %d lun %d, PDO: %p\n",
                        InquiryData->DeviceType, PortExtension->PortNumber, pathId, targetId, lun, lunPDO);
 
                    InsertTailList(&currentBus->LunsListHead, &lunExt->LunEntry);
 
                    totalLUNs++;
                    currentBus->LogicalUnitsCount++;
                    targetFound = TRUE;
                }
                else
                {
                    /* Decide whether we are continuing or not */
                    if (status == STATUS_INVALID_DEVICE_REQUEST)
                        continue;
                    else
                        break;
                }
            }
 
            if (targetFound)
            {
                currentBus->TargetsCount++;
            }
        }
    }
 
    PortExtension->TotalLUCount = totalLUNs;
}

Referenced by FdoHandleDeviceRelations(), and ScsiPortInitialize().

FdoStartAdapter()

NTSTATUS FdoStartAdapter

(

_In_ PSCSI_PORT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 609 of file fdo.c.

{
    WCHAR dosNameBuffer[12];
    UNICODE_STRING dosDeviceName;
    NTSTATUS status;
 
    // Start our timer
    IoStartTimer(PortExtension->Common.DeviceObject);
 
    // Create the dos device link
    swprintf(dosNameBuffer, L"\\??\\Scsi%u:", PortExtension->PortNumber);
    RtlInitUnicodeString(&dosDeviceName, dosNameBuffer);
    status = IoCreateSymbolicLink(&dosDeviceName, &PortExtension->DeviceName);
    if (!NT_SUCCESS(status))
    {
        return status;
    }
 
    // start building a device map
    RegistryInitAdapterKey(PortExtension);
 
    // increase the port count
    PCONFIGURATION_INFORMATION sysConfig = IoGetConfigurationInformation();
    sysConfig->ScsiPortCount++;
 
    // Register and enable the device interface
    status = IoRegisterDeviceInterface(PortExtension->Common.DeviceObject,
                                       &StoragePortClassGuid,
                                       NULL,
                                       &PortExtension->InterfaceName);
    DPRINT("IoRegisterDeviceInterface status: %x, InterfaceName: %wZ\n",
        status, &PortExtension->InterfaceName);
 
    if (NT_SUCCESS(status))
    {
        IoSetDeviceInterfaceState(&PortExtension->InterfaceName, TRUE);
    }
 
    PortExtension->DeviceStarted = TRUE;
 
    return STATUS_SUCCESS;
}

Referenced by ScsiPortInitialize().

GetLunByPath()

PSCSI_PORT_LUN_EXTENSION GetLunByPath	(	_In_ PSCSI_PORT_DEVICE_EXTENSION	DeviceExtension,
		_In_ UCHAR	PathId,
		_In_ UCHAR	TargetId,
		_In_ UCHAR	Lun
	)

Definition at line 68 of file pdo.c.

{
    if (PathId >= DeviceExtension->NumberOfBuses)
    {
        DPRINT1("Invalid PathId: %u\n", PathId);
        return NULL;
    }
 
    PSCSI_BUS_INFO bus = &DeviceExtension->Buses[PathId];
 
    for (PLIST_ENTRY lunEntry = bus->LunsListHead.Flink;
         lunEntry != &bus->LunsListHead;
         lunEntry = lunEntry->Flink)
    {
        PSCSI_PORT_LUN_EXTENSION lunExt =
            CONTAINING_RECORD(lunEntry, SCSI_PORT_LUN_EXTENSION, LunEntry);
 
        if (lunExt->PathId == PathId &&
            lunExt->TargetId == TargetId &&
            lunExt->Lun == Lun)
        {
            return lunExt;
        }
    }
 
    DPRINT("SCSI LUN (%u, %u, %u) was not found\n", PathId, TargetId, Lun);
    return NULL;
}

Referenced by FdoScanAdapter(), ScsiPortGetLogicalUnit(), and ScsiPortNotification().

PdoCreateLunDevice()

PDEVICE_OBJECT PdoCreateLunDevice

(

_In_ PSCSI_PORT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 18 of file pdo.c.

{
    PSCSI_PORT_LUN_EXTENSION LunExtension;
    PDEVICE_OBJECT LunPDO;
 
    ULONG LunExtensionSize = DeviceExtension->LunExtensionSize + sizeof(SCSI_PORT_LUN_EXTENSION);
 
    NTSTATUS Status = IoCreateDevice(DeviceExtension->Common.DeviceObject->DriverObject,
                                     LunExtensionSize,
                                     NULL,
                                     FILE_DEVICE_DISK,
                                     FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN,
                                     FALSE,
                                     &LunPDO);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create a Lun PDO, status: %x\n", Status);
        return NULL;
    }
 
    LunExtension = LunPDO->DeviceExtension;
 
    /* Zero everything */
    RtlZeroMemory(LunExtension, LunExtensionSize);
 
    LunExtension->Common.IsFDO = FALSE;
    LunExtension->Common.DeviceObject = LunPDO;
    LunExtension->Common.LowerDevice = DeviceExtension->Common.DeviceObject;
 
    /* Initialize a list of requests */
    InitializeListHead(&LunExtension->SrbInfo.Requests);
 
    /* Initialize timeout counter */
    LunExtension->RequestTimeout = -1;
 
    /* Set maximum queue size */
    LunExtension->MaxQueueCount = 256;
 
    /* Initialize request queue */
    KeInitializeDeviceQueue(&LunExtension->DeviceQueue);
 
    LunPDO->Flags |= DO_DIRECT_IO;
    LunPDO->Flags &= ~DO_DEVICE_INITIALIZING;
 
    return LunPDO;
}

Referenced by FdoScanAdapter().

PdoDispatchPnp()

NTSTATUS PdoDispatchPnp	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 554 of file pdo.c.

{
    PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp);
    PSCSI_PORT_LUN_EXTENSION lunExt = DeviceObject->DeviceExtension;
    NTSTATUS status;
 
    DPRINT("PDO PnP request %s\n", GetIRPMinorFunctionString(ioStack->MinorFunction));
 
    ASSERT(!lunExt->Common.IsFDO);
 
    switch (ioStack->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
        {
            RegistryInitLunKey(lunExt);
            status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_REMOVE_DEVICE:
        case IRP_MN_QUERY_CAPABILITIES:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_SURPRISE_REMOVAL:
        {
            status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            status = PdoHandleDeviceRelations(DeviceObject, Irp);
            break;
        }
        case IRP_MN_QUERY_DEVICE_TEXT:
        {
            status = PdoHandleQueryDeviceText(DeviceObject, Irp);
            break;
        }
        case IRP_MN_QUERY_ID:
        {
            DPRINT("IRP_MN_QUERY_ID IdType %s\n",
                DbgGetDeviceIDString(ioStack->Parameters.QueryId.IdType));
 
           if (ioStack->Parameters.QueryId.IdType == BusQueryDeviceID)
           {
               status = PdoHandleQueryDeviceId(DeviceObject, Irp);
               break;
           }
           else if (ioStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
           {
               status = PdoHandleQueryHardwareId(DeviceObject, Irp);
               break;
           }
           else if (ioStack->Parameters.QueryId.IdType == BusQueryInstanceID)
           {
               status = PdoHandleQueryInstanceId(DeviceObject, Irp);
               break;
           }
           else if (ioStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
           {
               status = PdoHandleQueryCompatibleId(DeviceObject, Irp);
               break;
           }
 
           // fallthrough
        }
        default:
        {
            // do nothing
            status = Irp->IoStatus.Status;
        }
    }
 
    if (status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return status;
}

Referenced by ScsiPortDispatchPnp().

RegistryInitAdapterKey()

NTSTATUS RegistryInitAdapterKey

(

_Inout_ PSCSI_PORT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 127 of file registry.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    UNICODE_STRING ValueName;
    WCHAR NameBuffer[64];
    HANDLE ScsiKey;
    HANDLE ScsiPortKey = NULL;
    HANDLE ScsiBusKey = NULL;
    HANDLE ScsiInitiatorKey = NULL;
    ULONG BusNumber;
    ULONG UlongData;
    NTSTATUS Status;
 
    DPRINT("SpiBuildDeviceMap() called\n");
 
    if (DeviceExtension == NULL)
    {
        DPRINT1("Invalid parameter\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Open or create the 'Scsi' subkey */
    RtlInitUnicodeString(&KeyName,
                         L"\\Registry\\Machine\\Hardware\\DeviceMap\\Scsi");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_OPENIF | OBJ_KERNEL_HANDLE,
                               0,
                               NULL);
    Status = ZwCreateKey(&ScsiKey,
                         KEY_ALL_ACCESS,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
        return Status;
    }
 
    /* Create new 'Scsi Port X' subkey */
    DPRINT("Scsi Port %lu\n", DeviceExtension->PortNumber);
 
    swprintf(NameBuffer,
             L"Scsi Port %lu",
             DeviceExtension->PortNumber);
    RtlInitUnicodeString(&KeyName, NameBuffer);
    InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_KERNEL_HANDLE, ScsiKey, NULL);
    Status = ZwCreateKey(&ScsiPortKey,
                         KEY_ALL_ACCESS,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    ZwClose(ScsiKey);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
        return Status;
    }
 
    /*
     * Create port-specific values
     */
 
    /* Set 'DMA Enabled' (REG_DWORD) value */
    UlongData = (ULONG)!DeviceExtension->PortCapabilities.AdapterUsesPio;
    DPRINT("  DMA Enabled = %s\n", UlongData ? "TRUE" : "FALSE");
    RtlInitUnicodeString(&ValueName, L"DMA Enabled");
    Status = ZwSetValueKey(ScsiPortKey,
                           &ValueName,
                           0,
                           REG_DWORD,
                           &UlongData,
                           sizeof(UlongData));
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwSetValueKey('DMA Enabled') failed (Status %lx)\n", Status);
        ZwClose(ScsiPortKey);
        return Status;
    }
 
    /* Set 'Driver' (REG_SZ) value */
    PUNICODE_STRING driverNameU = &DeviceExtension->Common.DeviceObject->DriverObject
                                  ->DriverExtension->ServiceKeyName;
 
    PWCHAR driverName = ExAllocatePoolWithTag(PagedPool,
                                              driverNameU->Length + sizeof(UNICODE_NULL),
                                              TAG_SCSIPORT);
    if (!driverName)
    {
        DPRINT("Failed to allocate driverName!\n");
        ZwClose(ScsiPortKey);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory(driverName, driverNameU->Buffer, driverNameU->Length);
    driverName[driverNameU->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    RtlInitUnicodeString(&ValueName, L"Driver");
    Status = ZwSetValueKey(ScsiPortKey,
                           &ValueName,
                           0,
                           REG_SZ,
                           driverName,
                           driverNameU->Length + sizeof(UNICODE_NULL));
 
    ExFreePoolWithTag(driverName, TAG_SCSIPORT);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwSetValueKey('Driver') failed (Status %lx)\n", Status);
        ZwClose(ScsiPortKey);
        return Status;
    }
 
    /* Set 'Interrupt' (REG_DWORD) value (NT4 only) */
    UlongData = (ULONG)DeviceExtension->PortConfig->BusInterruptLevel;
    DPRINT("  Interrupt = %lu\n", UlongData);
    RtlInitUnicodeString(&ValueName, L"Interrupt");
    Status = ZwSetValueKey(ScsiPortKey,
                           &ValueName,
                           0,
                           REG_DWORD,
                           &UlongData,
                           sizeof(UlongData));
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwSetValueKey('Interrupt') failed (Status %lx)\n", Status);
        ZwClose(ScsiPortKey);
        return Status;
    }
 
    /* Set 'IOAddress' (REG_DWORD) value (NT4 only) */
    UlongData = ScsiPortConvertPhysicalAddressToUlong((*DeviceExtension->PortConfig->AccessRanges)[0].RangeStart);
    DPRINT("  IOAddress = %lx\n", UlongData);
    RtlInitUnicodeString(&ValueName, L"IOAddress");
    Status = ZwSetValueKey(ScsiPortKey,
                           &ValueName,
                           0,
                           REG_DWORD,
                           &UlongData,
                           sizeof(UlongData));
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwSetValueKey('IOAddress') failed (Status %lx)\n", Status);
        ZwClose(ScsiPortKey);
        return Status;
    }
 
    /* Enumerate buses */
    for (BusNumber = 0; BusNumber < DeviceExtension->NumberOfBuses; BusNumber++)
    {
        /* Create 'Scsi Bus X' key */
        DPRINT("    Scsi Bus %lu\n", BusNumber);
        swprintf(NameBuffer,
                 L"Scsi Bus %lu",
                 BusNumber);
        RtlInitUnicodeString(&KeyName, NameBuffer);
        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_KERNEL_HANDLE,
                                   ScsiPortKey,
                                   NULL);
        Status = ZwCreateKey(&ScsiBusKey,
                             KEY_ALL_ACCESS,
                             &ObjectAttributes,
                             0,
                             NULL,
                             REG_OPTION_VOLATILE,
                             NULL);
        if (!NT_SUCCESS(Status))
        {
            DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
            goto ByeBye;
        }
 
        /* Create 'Initiator Id X' key */
        DPRINT("      Initiator Id %lu\n",
               DeviceExtension->PortConfig->InitiatorBusId[BusNumber]);
        swprintf(NameBuffer,
                 L"Initiator Id %lu",
                 (ULONG)(UCHAR)DeviceExtension->PortConfig->InitiatorBusId[BusNumber]);
        RtlInitUnicodeString(&KeyName, NameBuffer);
        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_KERNEL_HANDLE,
                                   ScsiBusKey,
                                   NULL);
        Status = ZwCreateKey(&ScsiInitiatorKey,
                             KEY_ALL_ACCESS,
                             &ObjectAttributes,
                             0,
                             NULL,
                             REG_OPTION_VOLATILE,
                             NULL);
        if (!NT_SUCCESS(Status))
        {
            DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
            goto ByeBye;
        }
 
        /* FIXME: Are there any initiator values (??) */
 
        ZwClose(ScsiInitiatorKey);
        ScsiInitiatorKey = NULL;
 
        DeviceExtension->Buses[BusNumber].RegistryMapKey = ScsiBusKey;
        ScsiBusKey = NULL;
    }
 
ByeBye:
    if (ScsiInitiatorKey != NULL)
        ZwClose(ScsiInitiatorKey);
 
    if (ScsiBusKey != NULL)
        ZwClose(ScsiBusKey);
 
    if (ScsiPortKey != NULL)
        ZwClose(ScsiPortKey);
 
    DPRINT("SpiBuildDeviceMap() done\n");
 
    return Status;
}

Referenced by FdoStartAdapter().

RegistryInitLunKey()

NTSTATUS RegistryInitLunKey

(

_Inout_ PSCSI_PORT_LUN_EXTENSION

LunExtension

)

Definition at line 359 of file registry.c.

{
    WCHAR nameBuffer[64];
    UNICODE_STRING keyName;
    UNICODE_STRING valueName;
    OBJECT_ATTRIBUTES objectAttributes;
    HANDLE targetKey;
    NTSTATUS status;
 
    // get the LUN's bus key
    PSCSI_PORT_DEVICE_EXTENSION portExt = LunExtension->Common.LowerDevice->DeviceExtension;
    HANDLE busKey = portExt->Buses[LunExtension->PathId].RegistryMapKey;
 
    // create/open 'Target Id X' key
    swprintf(nameBuffer, L"Target Id %lu", LunExtension->TargetId);
    RtlInitUnicodeString(&keyName, nameBuffer);
    InitializeObjectAttributes(&objectAttributes, &keyName, OBJ_KERNEL_HANDLE, busKey, NULL);
    status = ZwCreateKey(&targetKey,
                         KEY_ALL_ACCESS,
                         &objectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    if (!NT_SUCCESS(status))
    {
        DPRINT("ZwCreateKey() failed (Status %lx)\n", status);
        return status;
    }
 
    // Create 'Logical Unit Id X' key
    swprintf(nameBuffer, L"Logical Unit Id %lu", LunExtension->Lun);
    RtlInitUnicodeString(&keyName, nameBuffer);
    InitializeObjectAttributes(&objectAttributes, &keyName, OBJ_KERNEL_HANDLE, targetKey, NULL);
    status = ZwCreateKey(&LunExtension->RegistryMapKey,
                         KEY_ALL_ACCESS,
                         &objectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    if (!NT_SUCCESS(status))
    {
        DPRINT("ZwCreateKey() failed (Status %lx)\n", status);
        goto ByeBye;
    }
 
    // Set 'Identifier' (REG_SZ) value
    swprintf(nameBuffer,
             L"%.8S%.16S%.4S",
             LunExtension->InquiryData.VendorId,
             LunExtension->InquiryData.ProductId,
             LunExtension->InquiryData.ProductRevisionLevel);
    RtlInitUnicodeString(&valueName, L"Identifier");
    status = ZwSetValueKey(LunExtension->RegistryMapKey,
                           &valueName,
                           0,
                           REG_SZ,
                           nameBuffer,
                           (wcslen(nameBuffer) + 1) * sizeof(WCHAR));
    if (!NT_SUCCESS(status))
    {
        DPRINT("ZwSetValueKey('Identifier') failed (Status %lx)\n", status);
        goto ByeBye;
    }
 
    // Set 'Type' (REG_SZ) value
    PWCHAR typeName = (PWCHAR)GetPeripheralTypeW(&LunExtension->InquiryData);
    DPRINT("          Type = '%S'\n", typeName);
    RtlInitUnicodeString(&valueName, L"Type");
    status = ZwSetValueKey(LunExtension->RegistryMapKey,
                           &valueName,
                           0,
                           REG_SZ,
                           typeName,
                           (wcslen(typeName) + 1) * sizeof(WCHAR));
    if (!NT_SUCCESS(status))
    {
        DPRINT("ZwSetValueKey('Type') failed (Status %lx)\n", status);
        goto ByeBye;
    }
 
    // Set 'InquiryData' (REG_BINARY) value
    RtlInitUnicodeString(&valueName, L"InquiryData");
    status = ZwSetValueKey(LunExtension->RegistryMapKey,
                           &valueName,
                           0,
                           REG_BINARY,
                           &LunExtension->InquiryData,
                           INQUIRYDATABUFFERSIZE);
    if (!NT_SUCCESS(status))
    {
        DPRINT("ZwSetValueKey('InquiryData') failed (Status %lx)\n", status);
        goto ByeBye;
    }
 
ByeBye:
    ZwClose(targetKey);
    // TODO: maybe we will need it in future
    ZwClose(LunExtension->RegistryMapKey);
 
    return status;
}

Referenced by PdoDispatchPnp().

ScsiPortAllocateAdapterChannel()

IO_ALLOCATION_ACTION NTAPI ScsiPortAllocateAdapterChannel	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_ PVOID	MapRegisterBase,
		_In_ PVOID	Context
	)

ScsiPortDeviceControl()

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

Definition at line 404 of file ioctl.c.

{
    PIO_STACK_LOCATION Stack;
    PSCSI_PORT_COMMON_EXTENSION comExt = DeviceObject->DeviceExtension;
    PSCSI_PORT_DEVICE_EXTENSION portExt;
    PSCSI_PORT_LUN_EXTENSION lunExt;
    NTSTATUS status;
 
    DPRINT("ScsiPortDeviceControl()\n");
 
    Irp->IoStatus.Information = 0;
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (Stack->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_STORAGE_QUERY_PROPERTY:
        {
            DPRINT("  IOCTL_STORAGE_QUERY_PROPERTY\n");
 
            if (!VerifyIrpInBufferSize(Irp, sizeof(STORAGE_PROPERTY_QUERY)))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            if (comExt->IsFDO)
                return FdoHandleQueryProperty(DeviceObject, Irp);
            else
                return PdoHandleQueryProperty(DeviceObject, Irp);
        }
        case IOCTL_SCSI_GET_ADDRESS:
        {
            DPRINT("  IOCTL_SCSI_GET_ADDRESS\n");
 
            if (comExt->IsFDO)
            {
                status = STATUS_INVALID_DEVICE_REQUEST;
                break;
            }
 
            PSCSI_ADDRESS address = Irp->AssociatedIrp.SystemBuffer;
            if (!VerifyIrpOutBufferSize(Irp, sizeof(*address)))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            lunExt = DeviceObject->DeviceExtension;
            portExt = comExt->LowerDevice->DeviceExtension;
 
            address->Length = sizeof(SCSI_ADDRESS);
            address->PortNumber = portExt->PortNumber;
            address->PathId = lunExt->PathId;
            address->TargetId = lunExt->TargetId;
            address->Lun = lunExt->Lun;
 
            Irp->IoStatus.Information = sizeof(SCSI_ADDRESS);
            status = STATUS_SUCCESS;
            break;
        }
        case IOCTL_SCSI_GET_DUMP_POINTERS:
        {
            DPRINT("  IOCTL_SCSI_GET_DUMP_POINTERS\n");
 
            if (!comExt->IsFDO)
            {
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(comExt->LowerDevice, Irp);
            }
 
            PDUMP_POINTERS dumpPointers = Irp->AssociatedIrp.SystemBuffer;
            if (!VerifyIrpOutBufferSize(Irp, sizeof(*dumpPointers)))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            dumpPointers->DeviceObject = DeviceObject;
            /* More data.. ? */
 
            status = STATUS_SUCCESS;
            Irp->IoStatus.Information = sizeof(DUMP_POINTERS);
            break;
        }
        case IOCTL_SCSI_GET_CAPABILITIES:
        {
            DPRINT("  IOCTL_SCSI_GET_CAPABILITIES\n");
 
            if (!comExt->IsFDO)
            {
                status = STATUS_INVALID_DEVICE_REQUEST;
                break;
            }
 
            if (!VerifyIrpOutBufferSize(Irp, sizeof(IO_SCSI_CAPABILITIES)))
            {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            portExt = DeviceObject->DeviceExtension;
 
            RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
                          &portExt->PortCapabilities,
                          sizeof(IO_SCSI_CAPABILITIES));
 
            status = STATUS_SUCCESS;
            Irp->IoStatus.Information = sizeof(IO_SCSI_CAPABILITIES);
            break;
        }
        case IOCTL_SCSI_GET_INQUIRY_DATA:
        {
            DPRINT("  IOCTL_SCSI_GET_INQUIRY_DATA\n");
 
            if (!comExt->IsFDO)
            {
                status = STATUS_INVALID_DEVICE_REQUEST;
                break;
            }
 
            /* Copy inquiry data to the port device extension */
            status = SpiGetInquiryData(DeviceObject->DeviceExtension, Irp);
            break;
        }
        case IOCTL_SCSI_MINIPORT:
            DPRINT1("IOCTL_SCSI_MINIPORT unimplemented!\n");
            status = STATUS_NOT_IMPLEMENTED;
            break;
 
        case IOCTL_SCSI_PASS_THROUGH:
            DPRINT1("IOCTL_SCSI_PASS_THROUGH unimplemented!\n");
            status = STATUS_NOT_IMPLEMENTED;
            break;
 
        default:
            DPRINT1("unknown ioctl code: 0x%lX\n", Stack->Parameters.DeviceIoControl.IoControlCode);
            status = STATUS_NOT_SUPPORTED;
            break;
    }
 
    /* Complete the request with the given status */
    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ScsiPortInitialize().

SpiAdapterControl()

IO_ALLOCATION_ACTION NTAPI SpiAdapterControl	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_ PVOID	MapRegisterBase,
		_In_ PVOID	Context
	)

SpiGetNextRequestFromLun()

VOID SpiGetNextRequestFromLun	(	_In_ PSCSI_PORT_DEVICE_EXTENSION	DeviceExtension,
		_Inout_ PSCSI_PORT_LUN_EXTENSION	LunExtension,
		_Inout_opt_ PKIRQL	OldIrql
	)

Definition at line 342 of file scsi.c.

{
    PIO_STACK_LOCATION IrpStack;
    PIRP NextIrp;
    PKDEVICE_QUEUE_ENTRY Entry;
    PSCSI_REQUEST_BLOCK Srb;
 
 
    /* If LUN is not active or queue is more than maximum allowed  */
    if (LunExtension->QueueCount >= LunExtension->MaxQueueCount ||
        !(LunExtension->Flags & SCSI_PORT_LU_ACTIVE))
    {
        /* Release the spinlock and exit */
        if (OldIrql != NULL)
            KeReleaseSpinLock(&DeviceExtension->SpinLock, *OldIrql);
        else
            KeReleaseSpinLockFromDpcLevel(&DeviceExtension->SpinLock);
        return;
    }
 
    /* Check if we can get a next request */
    if (LunExtension->Flags &
        (LUNEX_NEED_REQUEST_SENSE | LUNEX_BUSY |
         LUNEX_FULL_QUEUE | LUNEX_FROZEN_QUEUE | LUNEX_REQUEST_PENDING))
    {
        /* Pending requests can only be started if the queue is empty */
        if (IsListEmpty(&LunExtension->SrbInfo.Requests) &&
            !(LunExtension->Flags &
              (LUNEX_BUSY | LUNEX_FROZEN_QUEUE | LUNEX_FULL_QUEUE | LUNEX_NEED_REQUEST_SENSE)))
        {
            /* Make sure we have SRB */
            ASSERT(LunExtension->SrbInfo.Srb == NULL);
 
            /* Clear active and pending flags */
            LunExtension->Flags &= ~(LUNEX_REQUEST_PENDING | SCSI_PORT_LU_ACTIVE);
 
            /* Get next Irp, and clear pending requests list */
            NextIrp = LunExtension->PendingRequest;
            LunExtension->PendingRequest = NULL;
 
            /* Set attempt counter to zero */
            LunExtension->AttemptCount = 0;
 
            /* Release the spinlock */
            if (OldIrql != NULL)
                KeReleaseSpinLock(&DeviceExtension->SpinLock, *OldIrql);
            else
                KeReleaseSpinLockFromDpcLevel(&DeviceExtension->SpinLock);
 
            /* Start the next pending request */
            IoStartPacket(DeviceExtension->Common.DeviceObject, NextIrp, (PULONG)NULL, NULL);
 
            return;
        }
        else
        {
            /* Release the spinlock, without clearing any flags and exit */
            if (OldIrql != NULL)
                KeReleaseSpinLock(&DeviceExtension->SpinLock, *OldIrql);
            else
                KeReleaseSpinLockFromDpcLevel(&DeviceExtension->SpinLock);
 
            return;
        }
    }
 
    /* Reset active flag */
    LunExtension->Flags &= ~SCSI_PORT_LU_ACTIVE;
 
    /* Set attempt counter to zero */
    LunExtension->AttemptCount = 0;
 
    /* Remove packet from the device queue */
    Entry = KeRemoveByKeyDeviceQueue(&LunExtension->DeviceQueue, LunExtension->SortKey);
 
    if (Entry != NULL)
    {
        /* Get pointer to the next irp */
        NextIrp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.DeviceQueueEntry);
 
        /* Get point to the SRB */
        IrpStack = IoGetCurrentIrpStackLocation(NextIrp);
        Srb = (PSCSI_REQUEST_BLOCK)IrpStack->Parameters.Others.Argument1;
 
        /* Set new key*/
        LunExtension->SortKey = Srb->QueueSortKey;
        LunExtension->SortKey++;
 
        /* Release the spinlock */
        if (OldIrql != NULL)
            KeReleaseSpinLock(&DeviceExtension->SpinLock, *OldIrql);
        else
            KeReleaseSpinLockFromDpcLevel(&DeviceExtension->SpinLock);
 
        /* Start the next pending request */
        IoStartPacket(DeviceExtension->Common.DeviceObject, NextIrp, (PULONG)NULL, NULL);
    }
    else
    {
        /* Release the spinlock */
        if (OldIrql != NULL)
            KeReleaseSpinLock(&DeviceExtension->SpinLock, *OldIrql);
        else
            KeReleaseSpinLockFromDpcLevel(&DeviceExtension->SpinLock);
    }
}

Referenced by FdoSendInquiry(), ScsiPortDispatchScsi(), ScsiPortDpcForIsr(), SpiProcessCompletedRequest(), and SpiSenseCompletionRoutine().

SpiGetSrbData()

PSCSI_REQUEST_BLOCK_INFO SpiGetSrbData	(	_In_ PSCSI_PORT_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_PORT_LUN_EXTENSION	LunExtension,
		_In_ UCHAR	QueueTag
	)

Definition at line 102 of file pdo.c.

{
    if (QueueTag == SP_UNTAGGED)
    {
        /* Return the pointer to SrbInfo */
        return &LunExtension->SrbInfo;
    }
    else
    {
        /* Make sure the tag is valid, if it is - return the data */
        if (QueueTag > DeviceExtension->SrbDataCount || QueueTag < 1)
            return NULL;
        else
            return &DeviceExtension->SrbInfo[QueueTag -1];
    }
}

Referenced by ScsiPortGetPhysicalAddress(), ScsiPortNotification(), ScsiPortStartPacket(), and SpiAllocateSrbStructures().

SpiInitOpenKeys()

VOID SpiInitOpenKeys	(	_Inout_ PCONFIGURATION_INFO	ConfigInfo,
		_In_ PSCSI_PORT_DRIVER_EXTENSION	DriverExtension
	)

Definition at line 18 of file registry.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    NTSTATUS Status;
    HANDLE parametersKey;
 
    DriverExtension->IsLegacyDriver = TRUE;
 
    /* Open the service key */
    InitializeObjectAttributes(&ObjectAttributes,
                               &DriverExtension->RegistryPath,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    Status = ZwOpenKey(&ConfigInfo->ServiceKey, KEY_READ, &ObjectAttributes);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Unable to open driver's registry key %wZ, status 0x%08x\n",
               DriverExtension->RegistryPath, Status);
        ConfigInfo->ServiceKey = NULL;
    }
 
    /* If we could open driver's service key, then proceed to the Parameters key */
    if (ConfigInfo->ServiceKey != NULL)
    {
        RtlInitUnicodeString(&KeyName, L"Parameters");
        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   ConfigInfo->ServiceKey,
                                   NULL);
 
        /* Try to open it */
        Status = ZwOpenKey(&ConfigInfo->DeviceKey, KEY_READ, &ObjectAttributes);
 
        if (NT_SUCCESS(Status))
        {
            /* Yes, Parameters key exist, and it must be used instead of
               the Service key */
            ZwClose(ConfigInfo->ServiceKey);
            ConfigInfo->ServiceKey = ConfigInfo->DeviceKey;
            ConfigInfo->DeviceKey = NULL;
        }
    }
 
    if (ConfigInfo->ServiceKey != NULL)
    {
        /* Open the Device key */
        RtlInitUnicodeString(&KeyName, L"Device");
        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   ConfigInfo->ServiceKey,
                                   NULL);
 
        /* We don't check for failure here - not needed */
        ZwOpenKey(&ConfigInfo->DeviceKey, KEY_READ, &ObjectAttributes);
 
        // Detect the driver PnP capabilities via its Parameters\PnpInterface key
        // for example: HKLM\SYSTEM\CurrentControlSet\Services\UNIATA\Parameters\PnpInterface
 
        RtlInitUnicodeString(&KeyName, L"PnpInterface");
        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   ConfigInfo->ServiceKey,
                                   NULL);
 
        Status = ZwOpenKey(&parametersKey, KEY_READ, &ObjectAttributes);
 
        if (NT_SUCCESS(Status))
        {
            // if the key exists, it's enough for us for now
            // (the proper check should iterate over INTERFACE_TYPE values)
            DriverExtension->IsLegacyDriver = FALSE;
            ZwClose(parametersKey);
        }
    }
}

Referenced by ScsiPortInitialize().

VerifyIrpInBufferSize()

FORCEINLINE BOOLEAN VerifyIrpInBufferSize	(	_In_ PIRP	Irp,
		_In_ SIZE_T	Size
	)

Definition at line 356 of file scsiport.h.

{
    PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp);
    if (ioStack->Parameters.DeviceIoControl.InputBufferLength < Size)
    {
        Irp->IoStatus.Information = Size;
        return FALSE;
    }
    return TRUE;
}

VerifyIrpOutBufferSize()

FORCEINLINE BOOLEAN VerifyIrpOutBufferSize	(	_In_ PIRP	Irp,
		_In_ SIZE_T	Size
	)

Definition at line 341 of file scsiport.h.

{
    PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp);
    if (ioStack->Parameters.DeviceIoControl.OutputBufferLength < Size)
    {
        Irp->IoStatus.Information = Size;
        return FALSE;
    }
    return TRUE;
}

Variable Documentation

ScsiPortDispatchPower

DRIVER_DISPATCH ScsiPortDispatchPower

Definition at line 426 of file scsiport.h.

Referenced by ScsiPortInitialize().

ScsiPortDispatchScsi

DRIVER_DISPATCH ScsiPortDispatchScsi

Definition at line 452 of file scsiport.h.

Referenced by ScsiPortInitialize().

ScsiPortDpcForIsr

IO_DPC_ROUTINE ScsiPortDpcForIsr

Definition at line 451 of file scsiport.h.

Referenced by FdoCallHWInitialize(), ScsiPortInitialize(), and SpiMiniportTimerDpc().

ScsiPortIsr

KSERVICE_ROUTINE ScsiPortIsr

Definition at line 459 of file scsiport.h.

Referenced by FdoCallHWInitialize().

ScsiPortStartIo

DRIVER_STARTIO ScsiPortStartIo

Definition at line 454 of file scsiport.h.

Referenced by ScsiPortDpcForIsr(), and ScsiPortInitialize().

ScsiPortStartPacket

KSYNCHRONIZE_ROUTINE ScsiPortStartPacket

Definition at line 453 of file scsiport.h.

Referenced by ScsiPortAllocateAdapterChannel(), ScsiPortStartIo(), SpiAdapterControl(), and SpiProcessTimeout().