3158 lines
82 KiB
C
3158 lines
82 KiB
C
/*++
|
||
|
||
Copyright (C) Microsoft Corporation, 1990 - 1999
|
||
|
||
Module Name:
|
||
|
||
port.c
|
||
|
||
Abstract:
|
||
|
||
This is the NT SCSI port driver.
|
||
|
||
Authors:
|
||
|
||
Mike Glass
|
||
Jeff Havens
|
||
|
||
Environment:
|
||
|
||
kernel mode only
|
||
|
||
Notes:
|
||
|
||
This module is a dll for the kernel.
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "port.h"
|
||
|
||
#if DBG
|
||
static const char *__file__ = __FILE__;
|
||
#endif
|
||
|
||
#define __FILE_ID__ 'util'
|
||
|
||
typedef struct SP_GUID_INTERFACE_MAPPING {
|
||
GUID Guid;
|
||
INTERFACE_TYPE InterfaceType;
|
||
} SP_GUID_INTERFACE_MAPPING, *PSP_GUID_INTERFACE_MAPPING;
|
||
|
||
PSP_GUID_INTERFACE_MAPPING SpGuidInterfaceMappingList = NULL;
|
||
|
||
VOID
|
||
SpProcessSpecialControllerList(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PINQUIRYDATA InquiryData,
|
||
IN HANDLE ListKey,
|
||
OUT PSP_SPECIAL_CONTROLLER_FLAGS Flags
|
||
);
|
||
|
||
VOID
|
||
SpProcessSpecialControllerFlags(
|
||
IN HANDLE FlagsKey,
|
||
OUT PSP_SPECIAL_CONTROLLER_FLAGS Flags
|
||
);
|
||
|
||
|
||
NTSTATUS
|
||
ScsiPortBuildMultiString(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
PUNICODE_STRING MultiString,
|
||
...
|
||
);
|
||
|
||
NTSTATUS
|
||
SpMultiStringToStringArray(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PUNICODE_STRING MultiString,
|
||
OUT PWSTR *StringArray[],
|
||
BOOLEAN Forward
|
||
);
|
||
|
||
VOID
|
||
FASTCALL
|
||
SpFreeSrbData(
|
||
IN PADAPTER_EXTENSION Adapter,
|
||
IN PSRB_DATA SrbData
|
||
);
|
||
|
||
VOID
|
||
FASTCALL
|
||
SpFreeBypassSrbData(
|
||
IN PADAPTER_EXTENSION Adapter,
|
||
IN PSRB_DATA SrbData
|
||
);
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(PAGE, ScsiPortBuildMultiString)
|
||
#pragma alloc_text(PAGE, ScsiPortStringArrayToMultiString)
|
||
#pragma alloc_text(PAGE, SpMultiStringToStringArray)
|
||
#pragma alloc_text(PAGE, RtlDuplicateCmResourceList)
|
||
#pragma alloc_text(PAGE, RtlSizeOfCmResourceList)
|
||
#pragma alloc_text(PAGE, SpTranslateResources)
|
||
#pragma alloc_text(PAGE, SpCheckSpecialDeviceFlags)
|
||
#pragma alloc_text(PAGE, SpProcessSpecialControllerList)
|
||
#pragma alloc_text(PAGE, SpProcessSpecialControllerFlags)
|
||
#pragma alloc_text(PAGE, SpAllocateTagBitMap)
|
||
#pragma alloc_text(PAGE, SpGetPdoInterfaceType)
|
||
#pragma alloc_text(PAGE, SpReadNumericInstanceValue)
|
||
#pragma alloc_text(PAGE, SpWriteNumericInstanceValue)
|
||
#pragma alloc_text(PAGE, SpReleaseMappedAddresses)
|
||
#pragma alloc_text(PAGE, SpInitializeGuidInterfaceMapping)
|
||
#pragma alloc_text(PAGE, SpSendIrpSynchronous)
|
||
#pragma alloc_text(PAGE, SpGetBusTypeGuid)
|
||
#pragma alloc_text(PAGE, SpDetermine64BitSupport)
|
||
#pragma alloc_text(PAGE, SpReadNumericValue)
|
||
#pragma alloc_text(PAGE, SpAllocateAddressMapping)
|
||
#pragma alloc_text(PAGE, SpPreallocateAddressMapping)
|
||
#pragma alloc_text(PAGE, SpPurgeFreeMappedAddressList)
|
||
#pragma alloc_text(PAGE, SpFreeMappedAddress)
|
||
#endif
|
||
|
||
|
||
NTSTATUS
|
||
SpInitializeGuidInterfaceMapping(
|
||
IN PDRIVER_OBJECT DriverObject
|
||
)
|
||
{
|
||
ULONG size;
|
||
|
||
PAGED_CODE();
|
||
|
||
ASSERT(SpGuidInterfaceMappingList == NULL);
|
||
|
||
size = sizeof(SP_GUID_INTERFACE_MAPPING) * 5;
|
||
|
||
SpGuidInterfaceMappingList = SpAllocatePool(PagedPool,
|
||
size,
|
||
SCSIPORT_TAG_INTERFACE_MAPPING,
|
||
DriverObject);
|
||
|
||
if(SpGuidInterfaceMappingList == NULL) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
RtlZeroMemory(SpGuidInterfaceMappingList, size);
|
||
|
||
SpGuidInterfaceMappingList[0].Guid = GUID_BUS_TYPE_PCMCIA;
|
||
SpGuidInterfaceMappingList[0].InterfaceType = Isa;
|
||
|
||
SpGuidInterfaceMappingList[1].Guid = GUID_BUS_TYPE_PCI;
|
||
SpGuidInterfaceMappingList[1].InterfaceType = PCIBus;
|
||
|
||
SpGuidInterfaceMappingList[2].Guid = GUID_BUS_TYPE_ISAPNP;
|
||
SpGuidInterfaceMappingList[2].InterfaceType = Isa;
|
||
|
||
SpGuidInterfaceMappingList[3].Guid = GUID_BUS_TYPE_EISA;
|
||
SpGuidInterfaceMappingList[3].InterfaceType = Eisa;
|
||
|
||
SpGuidInterfaceMappingList[4].InterfaceType = InterfaceTypeUndefined;
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
ScsiPortBuildMultiString(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PUNICODE_STRING MultiString,
|
||
...
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will take a null terminated list of ascii strings and combine
|
||
them together into a unicode multi-string block.
|
||
|
||
This routine allocates memory for the string buffer - is the caller's
|
||
responsibility to free it.
|
||
|
||
Arguments:
|
||
|
||
MultiString - a UNICODE_STRING structure into which the multi string will
|
||
be built.
|
||
|
||
... - a NULL terminated list of narrow strings which will be combined
|
||
together. This list may not be empty.
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
|
||
{
|
||
PCSTR rawEntry;
|
||
ANSI_STRING ansiEntry;
|
||
|
||
UNICODE_STRING unicodeEntry;
|
||
PWSTR unicodeLocation;
|
||
|
||
ULONG multiLength = 0;
|
||
|
||
NTSTATUS status;
|
||
|
||
va_list ap;
|
||
|
||
va_start(ap, MultiString);
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Make sure we aren't going to leak any memory
|
||
//
|
||
|
||
ASSERT(MultiString->Buffer == NULL);
|
||
|
||
rawEntry = va_arg(ap, PCSTR);
|
||
|
||
while(rawEntry != NULL) {
|
||
|
||
RtlInitAnsiString(&ansiEntry, rawEntry);
|
||
|
||
multiLength += RtlAnsiStringToUnicodeSize(&ansiEntry);
|
||
|
||
rawEntry = va_arg(ap, PCSTR);
|
||
|
||
}
|
||
|
||
ASSERT(multiLength != 0);
|
||
|
||
multiLength += sizeof(WCHAR);
|
||
|
||
MultiString->Buffer = SpAllocatePool(PagedPool,
|
||
multiLength,
|
||
SCSIPORT_TAG_PNP_ID,
|
||
DriverObject);
|
||
|
||
if(MultiString->Buffer == NULL) {
|
||
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
|
||
}
|
||
|
||
unicodeEntry.Buffer = MultiString->Buffer;
|
||
unicodeEntry.MaximumLength = (USHORT) multiLength;
|
||
|
||
va_start(ap, MultiString);
|
||
|
||
rawEntry = va_arg(ap, PCSTR);
|
||
|
||
while(rawEntry != NULL) {
|
||
|
||
|
||
RtlInitAnsiString(&ansiEntry, rawEntry);
|
||
|
||
status = RtlAnsiStringToUnicodeString(
|
||
&unicodeEntry,
|
||
&ansiEntry,
|
||
FALSE);
|
||
|
||
//
|
||
// Since we're not allocating any memory the only failure possible
|
||
// is if this function is bad
|
||
//
|
||
|
||
ASSERT(NT_SUCCESS(status));
|
||
|
||
//
|
||
// Push the buffer location up and reduce the maximum count
|
||
//
|
||
|
||
((PSTR) unicodeEntry.Buffer) += unicodeEntry.Length + sizeof(WCHAR);
|
||
unicodeEntry.MaximumLength -= unicodeEntry.Length + sizeof(WCHAR);
|
||
|
||
rawEntry = va_arg(ap, PCSTR);
|
||
|
||
};
|
||
|
||
ASSERT(unicodeEntry.MaximumLength == sizeof(WCHAR));
|
||
|
||
//
|
||
// Stick the final NUL on the end of the multisz
|
||
//
|
||
|
||
RtlZeroMemory(unicodeEntry.Buffer, unicodeEntry.MaximumLength);
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
}
|
||
|
||
NTSTATUS
|
||
ScsiPortStringArrayToMultiString(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
PUNICODE_STRING MultiString,
|
||
PCSTR StringArray[]
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will take a null terminated array of ascii strings and merge
|
||
them together into a unicode multi-string block.
|
||
|
||
This routine allocates memory for the string buffer - is the caller's
|
||
responsibility to free it.
|
||
|
||
Arguments:
|
||
|
||
MultiString - a UNICODE_STRING structure into which the multi string will
|
||
be built.
|
||
|
||
StringArray - a NULL terminated list of narrow strings which will be combined
|
||
together. This list may not be empty.
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
|
||
{
|
||
ANSI_STRING ansiEntry;
|
||
|
||
UNICODE_STRING unicodeEntry;
|
||
PWSTR unicodeLocation;
|
||
|
||
UCHAR i;
|
||
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Make sure we aren't going to leak any memory
|
||
//
|
||
|
||
ASSERT(MultiString->Buffer == NULL);
|
||
|
||
RtlInitUnicodeString(MultiString, NULL);
|
||
|
||
for(i = 0; StringArray[i] != NULL; i++) {
|
||
|
||
RtlInitAnsiString(&ansiEntry, StringArray[i]);
|
||
|
||
MultiString->Length += (USHORT) RtlAnsiStringToUnicodeSize(&ansiEntry);
|
||
}
|
||
|
||
ASSERT(MultiString->Length != 0);
|
||
|
||
MultiString->MaximumLength = MultiString->Length + sizeof(UNICODE_NULL);
|
||
|
||
MultiString->Buffer = SpAllocatePool(PagedPool,
|
||
MultiString->MaximumLength,
|
||
SCSIPORT_TAG_PNP_ID,
|
||
DriverObject);
|
||
|
||
if(MultiString->Buffer == NULL) {
|
||
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
|
||
}
|
||
|
||
RtlZeroMemory(MultiString->Buffer, MultiString->MaximumLength);
|
||
|
||
unicodeEntry = *MultiString;
|
||
|
||
for(i = 0; StringArray[i] != NULL; i++) {
|
||
|
||
RtlInitAnsiString(&ansiEntry, StringArray[i]);
|
||
|
||
status = RtlAnsiStringToUnicodeString(
|
||
&unicodeEntry,
|
||
&ansiEntry,
|
||
FALSE);
|
||
|
||
//
|
||
// Since we're not allocating any memory the only failure possible
|
||
// is if this function is bad
|
||
//
|
||
|
||
ASSERT(NT_SUCCESS(status));
|
||
|
||
//
|
||
// Push the buffer location up and reduce the maximum count
|
||
//
|
||
|
||
((PSTR) unicodeEntry.Buffer) += unicodeEntry.Length + sizeof(WCHAR);
|
||
unicodeEntry.MaximumLength -= unicodeEntry.Length + sizeof(WCHAR);
|
||
|
||
};
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpMultiStringToStringArray(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PUNICODE_STRING MultiString,
|
||
OUT PWSTR *StringArray[],
|
||
BOOLEAN Forward
|
||
)
|
||
|
||
{
|
||
ULONG stringCount = 0;
|
||
ULONG stringNumber;
|
||
ULONG i;
|
||
PWSTR *stringArray;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Pass one: count the number of string elements.
|
||
//
|
||
|
||
for(i = 0; i < (MultiString->MaximumLength / sizeof(WCHAR)); i++) {
|
||
if(MultiString->Buffer[i] == UNICODE_NULL) {
|
||
stringCount++;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Allocate the memory for a NULL-terminated string array.
|
||
//
|
||
|
||
stringArray = SpAllocatePool(PagedPool,
|
||
(stringCount + 1) * sizeof(PWSTR),
|
||
SCSIPORT_TAG_PNP_ID,
|
||
DriverObject);
|
||
|
||
if(stringArray == NULL) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
RtlZeroMemory(stringArray, (stringCount + 1) * sizeof(PWSTR));
|
||
|
||
//
|
||
// Pass two : Put the string pointers in place.
|
||
//
|
||
|
||
i = 0;
|
||
|
||
for(stringNumber = 0; stringNumber < stringCount; stringNumber++) {
|
||
|
||
ULONG arrayNumber;
|
||
|
||
if(Forward) {
|
||
arrayNumber = stringNumber;
|
||
} else {
|
||
arrayNumber = stringCount - stringNumber - 1;
|
||
}
|
||
|
||
//
|
||
// Put a pointer to the head of the string into the array.
|
||
//
|
||
|
||
stringArray[arrayNumber] = &MultiString->Buffer[i];
|
||
|
||
//
|
||
// Scan for the end of the string.
|
||
//
|
||
|
||
while((i < (MultiString->MaximumLength / sizeof(WCHAR))) &&
|
||
(MultiString->Buffer[i] != UNICODE_NULL)) {
|
||
i++;
|
||
}
|
||
|
||
//
|
||
// Jump past the NULL.
|
||
//
|
||
|
||
i++;
|
||
}
|
||
|
||
*StringArray = stringArray;
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
PCM_RESOURCE_LIST
|
||
RtlDuplicateCmResourceList(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
POOL_TYPE PoolType,
|
||
PCM_RESOURCE_LIST ResourceList,
|
||
ULONG Tag
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will attempt to allocate memory to copy the supplied
|
||
resource list. If sufficient memory cannot be allocated then the routine
|
||
will return NULL.
|
||
|
||
Arguments:
|
||
|
||
PoolType - the type of pool to allocate the duplicate from
|
||
|
||
ResourceList - the resource list to be copied
|
||
|
||
Tag - a value to tag the memory allocation with. If 0 then untagged
|
||
memory will be allocated.
|
||
|
||
Return Value:
|
||
|
||
an allocated copy of the resource list (caller must free) or
|
||
NULL if memory could not be allocated.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG size = sizeof(CM_RESOURCE_LIST);
|
||
PVOID buffer;
|
||
|
||
PAGED_CODE();
|
||
|
||
size = RtlSizeOfCmResourceList(ResourceList);
|
||
|
||
buffer = SpAllocatePool(PoolType,
|
||
size,
|
||
Tag,
|
||
DriverObject);
|
||
|
||
if (buffer != NULL) {
|
||
RtlCopyMemory(buffer,
|
||
ResourceList,
|
||
size);
|
||
}
|
||
|
||
return buffer;
|
||
}
|
||
|
||
ULONG
|
||
RtlSizeOfCmResourceList(
|
||
IN PCM_RESOURCE_LIST ResourceList
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine returns the size of a CM_RESOURCE_LIST.
|
||
|
||
Arguments:
|
||
|
||
ResourceList - the resource list to be copied
|
||
|
||
Return Value:
|
||
|
||
an allocated copy of the resource list (caller must free) or
|
||
NULL if memory could not be allocated.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG size = sizeof(CM_RESOURCE_LIST);
|
||
ULONG i;
|
||
|
||
PAGED_CODE();
|
||
|
||
for(i = 0; i < ResourceList->Count; i++) {
|
||
|
||
PCM_FULL_RESOURCE_DESCRIPTOR fullDescriptor = &(ResourceList->List[i]);
|
||
ULONG j;
|
||
|
||
//
|
||
// First descriptor is included in the size of the resource list.
|
||
//
|
||
|
||
if(i != 0) {
|
||
size += sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
|
||
}
|
||
|
||
for(j = 0; j < fullDescriptor->PartialResourceList.Count; j++) {
|
||
|
||
//
|
||
// First descriptor is included in the size of the partial list.
|
||
//
|
||
|
||
if(j != 0) {
|
||
size += sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
|
||
}
|
||
}
|
||
}
|
||
|
||
return size;
|
||
}
|
||
|
||
#if !defined(NO_LEGACY_DRIVERS)
|
||
|
||
BOOLEAN
|
||
SpTranslateResources(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PCM_RESOURCE_LIST AllocatedResources,
|
||
OUT PCM_RESOURCE_LIST *TranslatedResources
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will call into the Hal to translate any recognizable resources
|
||
in the AllocatedResources list. This routine allocates the space for the
|
||
translated list - the caller is responsible for freeing this buffer.
|
||
|
||
If any errors occur the TranslatedResources will be NULL and the routine
|
||
will return FALSE.
|
||
|
||
Arguments:
|
||
|
||
AllocatedResources - The list of resources to be translated.
|
||
|
||
TranslatedResources - A location to store the translated resources. There
|
||
will be a one to one mapping between translated and
|
||
untranslated. Any non-standard resource types will
|
||
be blindly copied.
|
||
|
||
Return Value:
|
||
|
||
TRUE if all resources were translated properly.
|
||
|
||
FALSE otherwise.
|
||
|
||
--*/
|
||
|
||
{
|
||
PCM_RESOURCE_LIST list;
|
||
|
||
ULONG listNumber;
|
||
|
||
PAGED_CODE();
|
||
|
||
(*TranslatedResources) = NULL;
|
||
|
||
list = RtlDuplicateCmResourceList(DriverObject,
|
||
NonPagedPool,
|
||
AllocatedResources,
|
||
SCSIPORT_TAG_RESOURCE_LIST);
|
||
|
||
if(list == NULL) {
|
||
return FALSE;
|
||
}
|
||
|
||
for(listNumber = 0; listNumber < list->Count; listNumber++) {
|
||
|
||
PCM_FULL_RESOURCE_DESCRIPTOR fullDescriptor;
|
||
ULONG resourceNumber;
|
||
|
||
fullDescriptor = &(list->List[listNumber]);
|
||
|
||
for(resourceNumber = 0;
|
||
resourceNumber < fullDescriptor->PartialResourceList.Count;
|
||
resourceNumber++) {
|
||
|
||
PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptor;
|
||
CM_PARTIAL_RESOURCE_DESCRIPTOR tmp;
|
||
|
||
partialDescriptor =
|
||
&(fullDescriptor->PartialResourceList.PartialDescriptors[resourceNumber]);
|
||
|
||
switch(partialDescriptor->Type) {
|
||
|
||
case CmResourceTypePort:
|
||
case CmResourceTypeMemory: {
|
||
|
||
ULONG addressSpace;
|
||
|
||
if(partialDescriptor->Type == CmResourceTypePort) {
|
||
addressSpace = 1;
|
||
} else {
|
||
addressSpace = 0;
|
||
}
|
||
|
||
tmp = *partialDescriptor;
|
||
|
||
if(HalTranslateBusAddress(
|
||
fullDescriptor->InterfaceType,
|
||
fullDescriptor->BusNumber,
|
||
partialDescriptor->u.Generic.Start,
|
||
&addressSpace,
|
||
&(tmp.u.Generic.Start))) {
|
||
|
||
tmp.Type = (addressSpace == 0) ? CmResourceTypeMemory :
|
||
CmResourceTypePort;
|
||
|
||
} else {
|
||
|
||
ExFreePool(list);
|
||
return FALSE;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case CmResourceTypeInterrupt: {
|
||
|
||
tmp = *partialDescriptor;
|
||
|
||
tmp.u.Interrupt.Vector =
|
||
HalGetInterruptVector(
|
||
fullDescriptor->InterfaceType,
|
||
fullDescriptor->BusNumber,
|
||
partialDescriptor->u.Interrupt.Level,
|
||
partialDescriptor->u.Interrupt.Vector,
|
||
&((UCHAR) tmp.u.Interrupt.Level),
|
||
&(tmp.u.Interrupt.Affinity));
|
||
|
||
if(tmp.u.Interrupt.Affinity == 0) {
|
||
|
||
//
|
||
// Translation failed.
|
||
//
|
||
|
||
ExFreePool(list);
|
||
return FALSE;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
};
|
||
|
||
*partialDescriptor = tmp;
|
||
}
|
||
}
|
||
|
||
*TranslatedResources = list;
|
||
return TRUE;
|
||
}
|
||
#endif // NO_LEGACY_DRIVERS
|
||
|
||
|
||
BOOLEAN
|
||
SpFindAddressTranslation(
|
||
IN PADAPTER_EXTENSION AdapterExtension,
|
||
IN INTERFACE_TYPE BusType,
|
||
IN ULONG BusNumber,
|
||
IN PHYSICAL_ADDRESS RangeStart,
|
||
IN ULONG RangeLength,
|
||
IN BOOLEAN InIoSpace,
|
||
IN OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR Translation
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will search the resource lists in the AdapterExtension to
|
||
translate the given memory or i/o range using the resources provided by
|
||
pnp or the Hal.
|
||
|
||
Arguments:
|
||
|
||
AdapterExtesnion - the device extension for the adapter making the request
|
||
|
||
RangeStart - the starting address of the memory range
|
||
|
||
RangeLength - the number of bytes in the memory range
|
||
|
||
InIoSpace - whether the untranslated range is in io or memory space.
|
||
|
||
Return Value:
|
||
|
||
a pointer to a partial resource descriptor describing the proper range to
|
||
be used or NULL if no matching range of sufficient length can be found.
|
||
|
||
--*/
|
||
|
||
{
|
||
PCM_RESOURCE_LIST list;
|
||
|
||
ULONG listNumber;
|
||
|
||
list = AdapterExtension->AllocatedResources;
|
||
|
||
ASSERT(!AdapterExtension->IsMiniportDetected);
|
||
ASSERT(AdapterExtension->AllocatedResources);
|
||
ASSERT(AdapterExtension->TranslatedResources);
|
||
|
||
for(listNumber = 0; listNumber < list->Count; listNumber++) {
|
||
|
||
PCM_FULL_RESOURCE_DESCRIPTOR fullDescriptor;
|
||
ULONG resourceNumber;
|
||
|
||
fullDescriptor = &(list->List[listNumber]);
|
||
|
||
if((fullDescriptor->InterfaceType != BusType) ||
|
||
(fullDescriptor->BusNumber != BusNumber)) {
|
||
continue;
|
||
}
|
||
|
||
for(resourceNumber = 0;
|
||
resourceNumber < fullDescriptor->PartialResourceList.Count;
|
||
resourceNumber++) {
|
||
|
||
PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptor;
|
||
|
||
UCHAR desiredType =
|
||
InIoSpace ? CmResourceTypePort : CmResourceTypeMemory;
|
||
|
||
partialDescriptor =
|
||
&(fullDescriptor->PartialResourceList.PartialDescriptors[resourceNumber]);
|
||
|
||
if(partialDescriptor->Type == desiredType) {
|
||
|
||
ULONGLONG requestedStart = (ULONGLONG) RangeStart.QuadPart;
|
||
ULONGLONG requestedEnd =
|
||
((ULONGLONG) RangeStart.QuadPart) + RangeLength;
|
||
|
||
ULONGLONG testStart =
|
||
(ULONGLONG) partialDescriptor->u.Generic.Start.QuadPart;
|
||
ULONGLONG testEnd =
|
||
testStart + partialDescriptor->u.Generic.Length;
|
||
|
||
ULONGLONG requestedOffset = requestedStart - testStart;
|
||
|
||
ULONG rangeOffset;
|
||
|
||
//
|
||
// Make sure the base address is within the current range.
|
||
//
|
||
|
||
if((requestedStart < testStart) ||
|
||
(requestedStart >= testEnd)) {
|
||
continue;
|
||
}
|
||
|
||
//
|
||
// Make sure the end of the requested range is within this
|
||
// descriptor.
|
||
//
|
||
|
||
if(requestedEnd > testEnd) {
|
||
continue;
|
||
}
|
||
|
||
//
|
||
// We seem to have found a match. Copy the equivalent resource
|
||
// in the translated resource list.
|
||
//
|
||
|
||
*Translation =
|
||
AdapterExtension->TranslatedResources->List[listNumber].
|
||
PartialResourceList.PartialDescriptors[resourceNumber];
|
||
|
||
//
|
||
// Return an offset into the translated range equivalent to the
|
||
// offset in the untranslated range.
|
||
//
|
||
|
||
requestedStart = Translation->u.Generic.Start.QuadPart;
|
||
requestedStart += requestedOffset;
|
||
|
||
Translation->u.Generic.Start.QuadPart = requestedStart;
|
||
|
||
return TRUE;
|
||
|
||
};
|
||
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpLockUnlockQueue(
|
||
IN PDEVICE_OBJECT LogicalUnit,
|
||
IN BOOLEAN LockQueue,
|
||
IN BOOLEAN BypassLockedQueue
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will lock or unlock the logical unit queue.
|
||
|
||
This routine is synchronous.
|
||
|
||
Arguments:
|
||
|
||
LogicalUnit - the logical unit to be locked or unlocked
|
||
|
||
LockQueue - whether the queue should be locked or unlocked
|
||
|
||
BypassLockedQueue - whether the operation should bypass other locks or
|
||
whether it should sit in the queue. Must be true for
|
||
unlock requests.
|
||
|
||
Return Value:
|
||
|
||
STATUS_SUCCESS if the operation was successful
|
||
|
||
error status otherwise.
|
||
|
||
--*/
|
||
|
||
{
|
||
PLOGICAL_UNIT_EXTENSION luExtension = LogicalUnit->DeviceExtension;
|
||
PIRP irp;
|
||
PIO_STACK_LOCATION irpStack;
|
||
PSCSI_REQUEST_BLOCK srb;
|
||
PKEVENT event = NULL;
|
||
|
||
NTSTATUS status;
|
||
|
||
ASSERTMSG("Must bypass locked queue when unlocking: ",
|
||
(LockQueue || BypassLockedQueue));
|
||
|
||
DebugPrint((1, "SpLockUnlockQueue: %sing queue for logical unit extension "
|
||
"%#p\n",
|
||
LockQueue ? "Lock" : "Unlock",
|
||
luExtension));
|
||
|
||
//
|
||
// Build an IRP to send to the logical unit. We need one stack
|
||
// location for our completion routine and one for the irp to be
|
||
// processed with. This irp should never be dispatched to the
|
||
//
|
||
|
||
irp = SpAllocateIrp((CCHAR) (LogicalUnit->StackSize + 1),
|
||
FALSE,
|
||
LogicalUnit->DriverObject);
|
||
|
||
if(irp == NULL) {
|
||
DebugPrint((1, "SpLockUnlockQueue: Couldn't allocate IRP\n"));
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
try {
|
||
|
||
srb = SpAllocatePool(NonPagedPool,
|
||
sizeof(SCSI_REQUEST_BLOCK),
|
||
SCSIPORT_TAG_ENABLE,
|
||
LogicalUnit->DriverObject);
|
||
|
||
if(srb == NULL) {
|
||
|
||
DebugPrint((1, "SpLockUnlockQueue: Couldn't allocate SRB\n"));
|
||
status = STATUS_INSUFFICIENT_RESOURCES;
|
||
leave;
|
||
}
|
||
|
||
event = SpAllocatePool(NonPagedPool,
|
||
sizeof(KEVENT),
|
||
SCSIPORT_TAG_EVENT,
|
||
LogicalUnit->DriverObject);
|
||
|
||
if(event == NULL) {
|
||
|
||
DebugPrint((1, "SpLockUnlockQueue: Couldn't allocate Context\n"));
|
||
status = STATUS_INSUFFICIENT_RESOURCES;
|
||
leave;
|
||
}
|
||
|
||
RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
|
||
|
||
KeInitializeEvent(event, NotificationEvent, FALSE);
|
||
|
||
srb->Length = sizeof(SCSI_REQUEST_BLOCK);
|
||
|
||
srb->Function = LockQueue ? SRB_FUNCTION_LOCK_QUEUE :
|
||
SRB_FUNCTION_UNLOCK_QUEUE;
|
||
|
||
srb->OriginalRequest = irp;
|
||
srb->DataBuffer = NULL;
|
||
|
||
srb->QueueTag = SP_UNTAGGED;
|
||
|
||
if(BypassLockedQueue) {
|
||
srb->SrbFlags |= SRB_FLAGS_BYPASS_LOCKED_QUEUE;
|
||
}
|
||
|
||
IoSetCompletionRoutine(irp,
|
||
SpSignalCompletion,
|
||
event,
|
||
TRUE,
|
||
TRUE,
|
||
TRUE);
|
||
|
||
irpStack = IoGetNextIrpStackLocation(irp);
|
||
|
||
irpStack->Parameters.Scsi.Srb = srb;
|
||
irpStack->MajorFunction = IRP_MJ_SCSI;
|
||
|
||
status = IoCallDriver(LogicalUnit, irp);
|
||
|
||
if(status == STATUS_PENDING) {
|
||
|
||
KeWaitForSingleObject(event,
|
||
Executive,
|
||
KernelMode,
|
||
FALSE,
|
||
NULL);
|
||
|
||
status = irp->IoStatus.Status;
|
||
}
|
||
|
||
} finally {
|
||
|
||
if(irp != NULL) {
|
||
IoFreeIrp(irp);
|
||
}
|
||
|
||
if(srb != NULL) {
|
||
ExFreePool(srb);
|
||
}
|
||
|
||
if(event != NULL) {
|
||
ExFreePool(event);
|
||
}
|
||
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpCheckSpecialDeviceFlags(
|
||
IN PLOGICAL_UNIT_EXTENSION LogicalUnit,
|
||
IN PINQUIRYDATA InquiryData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will check the registry to determine what sort of special
|
||
handling a target device requires. If there is a device-node then the
|
||
routine will check under the device parameters for this particular logical
|
||
unit.
|
||
|
||
If there is no device node for the logical unit the hardware id will be
|
||
looked up (first) under the devnode for the adapter or (if not found) the
|
||
bad controller list stored under the scsiport Control key.
|
||
|
||
The flags tested for include (this list should be updated as more are
|
||
added):
|
||
|
||
* OneLun - used to keep from enumerating past LUN 0 on a particular
|
||
device.
|
||
* SparseLun - used to indicate the device may have holes in the LUN
|
||
numbers.
|
||
* NonStandardVPD - used to indicate that a target does not support VPD 0x00
|
||
but does support VPD 0x80 and 0x83.
|
||
* BinarySN - used to indicate that the target supplied a binary
|
||
serial number and that we need to convert it to ascii.
|
||
|
||
|
||
|
||
These values are REG_DWORD's. REG_NULL can be used to return a value
|
||
to it's default.
|
||
|
||
Arguments:
|
||
|
||
LogicalUnit - the logical unit
|
||
|
||
InquiryData - the inquiry data retreived for the lun
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
|
||
{
|
||
HANDLE baseKey = NULL;
|
||
HANDLE listKey = NULL;
|
||
HANDLE entryKey = NULL;
|
||
|
||
UNICODE_STRING keyName;
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
|
||
SP_SPECIAL_CONTROLLER_FLAGS flags = {
|
||
0, // SparseLun
|
||
0, // OneLun
|
||
0, // LargeLuns
|
||
0, // SetLunInCdb
|
||
0, // NonStandardVPD
|
||
0 // BinarySN
|
||
};
|
||
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
DebugPrint((1, "SpCheckSpecialDeviceFlags - checking flags for %#p\n",
|
||
LogicalUnit));
|
||
|
||
//
|
||
// Check the bad controller list in the scsiport control key
|
||
//
|
||
|
||
try {
|
||
|
||
DebugPrint((2, "SpCheckSpecialDeviceFlags - trying control list\n"));
|
||
|
||
RtlInitUnicodeString(&keyName,
|
||
SCSIPORT_CONTROL_KEY SCSIPORT_SPECIAL_TARGET_KEY);
|
||
|
||
InitializeObjectAttributes(&objectAttributes,
|
||
&keyName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
NULL,
|
||
NULL);
|
||
|
||
status = ZwOpenKey(&listKey,
|
||
KEY_READ,
|
||
&objectAttributes);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
DebugPrint((2, "SpCheckSpecialDeviceFlags - error %#08lx opening "
|
||
"key %wZ\n",
|
||
status,
|
||
&keyName));
|
||
leave;
|
||
}
|
||
|
||
SpProcessSpecialControllerList(
|
||
LogicalUnit->DeviceObject->DriverObject,
|
||
InquiryData,
|
||
listKey,
|
||
&flags);
|
||
|
||
} finally {
|
||
|
||
if(listKey != NULL) {
|
||
ZwClose(listKey);
|
||
listKey = NULL;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Next check the special list in the adapter's devnode.
|
||
//
|
||
|
||
try {
|
||
|
||
PDEVICE_OBJECT adapterPdo = LogicalUnit->AdapterExtension->LowerPdo;
|
||
|
||
DebugPrint((2, "SpCheckSpecialDeviceFlags - trying adapter list\n"));
|
||
|
||
status = IoOpenDeviceRegistryKey(adapterPdo,
|
||
PLUGPLAY_REGKEY_DEVICE,
|
||
KEY_READ,
|
||
&baseKey);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
|
||
DebugPrint((2, "SpCheckSpecialDeviceFlags - error %#08lx opening "
|
||
"adapter devnode key\n", status));
|
||
leave;
|
||
}
|
||
|
||
RtlInitUnicodeString(&keyName,
|
||
L"ScsiPort\\" SCSIPORT_SPECIAL_TARGET_KEY);
|
||
|
||
InitializeObjectAttributes(&objectAttributes,
|
||
&keyName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
baseKey,
|
||
NULL);
|
||
|
||
status = ZwOpenKey(&listKey,
|
||
KEY_READ,
|
||
&objectAttributes);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
DebugPrint((2, "SpCheckSpecialDeviceFlags - error %#08lx opening "
|
||
"adapter devnode key %wZ\n", status, &keyName));
|
||
leave;
|
||
}
|
||
|
||
SpProcessSpecialControllerList(
|
||
LogicalUnit->DeviceObject->DriverObject,
|
||
InquiryData,
|
||
listKey,
|
||
&flags);
|
||
|
||
} finally {
|
||
|
||
if(baseKey != NULL) {
|
||
ZwClose(baseKey);
|
||
baseKey = NULL;
|
||
|
||
if(listKey != NULL) {
|
||
ZwClose(listKey);
|
||
listKey = NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// Finally check the devnode (if any) for the logical unit. This one is
|
||
// special - the hardware id already matchs so the key just contains the
|
||
// values to be used, not a database of values.
|
||
//
|
||
|
||
try {
|
||
|
||
status = IoOpenDeviceRegistryKey(LogicalUnit->CommonExtension.DeviceObject,
|
||
PLUGPLAY_REGKEY_DEVICE,
|
||
KEY_READ,
|
||
&baseKey);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
DebugPrint((2, "SpCheckSpecialDeviceFlags - error %#08lx opening "
|
||
"device devnode key\n", status));
|
||
leave;
|
||
}
|
||
|
||
RtlInitUnicodeString(&keyName,
|
||
L"ScsiPort\\" SCSIPORT_SPECIAL_TARGET_KEY);
|
||
|
||
InitializeObjectAttributes(&objectAttributes,
|
||
&keyName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
baseKey,
|
||
NULL);
|
||
|
||
status = ZwOpenKey(&listKey,
|
||
KEY_READ,
|
||
&objectAttributes);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
DebugPrint((2, "SpCheckSpecialDeviceFlags - error %#08lx opening "
|
||
"device devnode key %wZ\n", status, &keyName));
|
||
leave;
|
||
}
|
||
|
||
SpProcessSpecialControllerFlags(listKey, &flags);
|
||
|
||
} finally {
|
||
if(baseKey != NULL) {
|
||
ZwClose(baseKey);
|
||
baseKey = NULL;
|
||
|
||
if(listKey != NULL) {
|
||
ZwClose(listKey);
|
||
listKey = NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
LogicalUnit->SpecialFlags = flags;
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
VOID
|
||
SpProcessSpecialControllerList(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PINQUIRYDATA InquiryData,
|
||
IN HANDLE ListKey,
|
||
OUT PSP_SPECIAL_CONTROLLER_FLAGS Flags
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will match the specified logical unit to a set of special
|
||
controller flags stored in the registry key ListKey. These flags will
|
||
be written into the Flags structure, overwriting any flags which already
|
||
exist.
|
||
|
||
If no logical unit is provided then the ListKey handle is assumed to point
|
||
at the appropriate list entry and the values stored there will be copied
|
||
into the Flags structure.
|
||
|
||
Arguments:
|
||
|
||
InquiryData - The inquiry data for the logical unit. This is used to
|
||
match strings in the special target list.
|
||
|
||
ListKey - a handle to the special controller list to locate the logical
|
||
unit in, or a handle to a list of flags if the LogicalUnit value
|
||
is not present.
|
||
|
||
Flags - a location to store the flags.
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
UNICODE_STRING hardwareIds;
|
||
PWSTR *hardwareIdList;
|
||
|
||
ULONG idNumber;
|
||
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
RtlInitUnicodeString(&hardwareIds, NULL);
|
||
|
||
status = ScsiPortGetHardwareIds(DriverObject, InquiryData, &hardwareIds);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
DebugPrint((2, "SpProcessSpecialControllerList: Error %#08lx getting "
|
||
"hardware id's\n", status));
|
||
return;
|
||
}
|
||
|
||
status = SpMultiStringToStringArray(DriverObject,
|
||
&hardwareIds,
|
||
&hardwareIdList,
|
||
FALSE);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
RtlFreeUnicodeString(&hardwareIds);
|
||
return;
|
||
}
|
||
|
||
for(idNumber = 0; hardwareIdList[idNumber] != NULL; idNumber++) {
|
||
|
||
PWSTR hardwareId = hardwareIdList[idNumber];
|
||
ULONG j;
|
||
UNICODE_STRING keyName;
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
HANDLE flagsKey;
|
||
|
||
DebugPrint((2, "SpProcessSpecialControllerList: processing id %ws\n",
|
||
hardwareId));
|
||
|
||
//
|
||
// Remove the leading slash from the name.
|
||
//
|
||
|
||
for(j = 0; hardwareId[j] != UNICODE_NULL; j++) {
|
||
if(hardwareId[j] == L'\\') {
|
||
hardwareId = &(hardwareId[j+1]);
|
||
break;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Process the hardware id that we just found the end of.
|
||
//
|
||
|
||
RtlInitUnicodeString(&keyName, hardwareId);
|
||
|
||
DebugPrint((2, "SpProcessSpecialControllerList: Finding match for "
|
||
"%wZ - id %d\n", &keyName, idNumber));
|
||
|
||
InitializeObjectAttributes(&objectAttributes,
|
||
&keyName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
ListKey,
|
||
NULL);
|
||
|
||
status = ZwOpenKey(&flagsKey,
|
||
KEY_READ,
|
||
&objectAttributes);
|
||
|
||
if(NT_SUCCESS(status)) {
|
||
SpProcessSpecialControllerFlags(flagsKey, Flags);
|
||
ZwClose(flagsKey);
|
||
} else {
|
||
DebugPrint((2, "SpProcessSpecialControllerList: Error %#08lx "
|
||
"opening key\n", status));
|
||
}
|
||
|
||
}
|
||
|
||
ExFreePool(hardwareIdList);
|
||
RtlFreeUnicodeString(&hardwareIds);
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
VOID
|
||
SpProcessSpecialControllerFlags(
|
||
IN HANDLE FlagsKey,
|
||
OUT PSP_SPECIAL_CONTROLLER_FLAGS Flags
|
||
)
|
||
{
|
||
RTL_QUERY_REGISTRY_TABLE queryTable[7];
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
RtlZeroMemory(queryTable, sizeof(queryTable));
|
||
|
||
queryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
|
||
queryTable[0].Name = L"SparseLUN";
|
||
queryTable[0].EntryContext = &(Flags->SparseLun);
|
||
|
||
queryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
|
||
queryTable[1].Name = L"OneLUN";
|
||
queryTable[1].EntryContext = &(Flags->OneLun);
|
||
|
||
queryTable[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
|
||
queryTable[2].Name = L"LargeLuns";
|
||
queryTable[2].EntryContext = &(Flags->LargeLuns);
|
||
|
||
queryTable[3].Flags = RTL_QUERY_REGISTRY_DIRECT;
|
||
queryTable[3].Name = L"SetLunInCdb";
|
||
queryTable[3].EntryContext = &(Flags->SetLunInCdb);
|
||
|
||
queryTable[4].Flags = RTL_QUERY_REGISTRY_DIRECT;
|
||
queryTable[4].Name = L"NonStandardVPD";
|
||
queryTable[4].EntryContext = &(Flags->NonStandardVPD);
|
||
|
||
queryTable[5].Flags = RTL_QUERY_REGISTRY_DIRECT;
|
||
queryTable[5].Name = L"BinarySN";
|
||
queryTable[5].EntryContext = &(Flags->BinarySN);
|
||
|
||
status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
|
||
FlagsKey,
|
||
queryTable,
|
||
NULL,
|
||
NULL);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
DebugPrint((2, "SpProcssSpecialControllerFlags: Error %#08lx reading "
|
||
"values\n", status));
|
||
} else {
|
||
DebugPrint((2, "SpProcessSpecialControllerFlags: %s%s%s%s%s\n",
|
||
((Flags->SparseLun ||
|
||
Flags->OneLun ||
|
||
Flags->LargeLuns ||
|
||
Flags->SetLunInCdb ||
|
||
Flags->NonStandardVPD ||
|
||
Flags->BinarySN) ? "" : "none"),
|
||
(Flags->SparseLun ? "SparseLun " : ""),
|
||
(Flags->OneLun ? "OneLun " : ""),
|
||
(Flags->LargeLuns ? "LargeLuns " : ""),
|
||
(Flags->SetLunInCdb ? "SetLunInCdb" : ""),
|
||
(Flags->NonStandardVPD ? "NonStandardVPD" : ""),
|
||
(Flags->BinarySN ? "BinarySN" : "")));
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
PSRB_DATA
|
||
FASTCALL
|
||
SpAllocateSrbData(
|
||
IN PADAPTER_EXTENSION Adapter,
|
||
IN OPTIONAL PIRP Request,
|
||
IN OPTIONAL PLOGICAL_UNIT_EXTENSION LogicalUnit
|
||
)
|
||
|
||
{
|
||
PSRB_DATA srbData;
|
||
|
||
srbData = ExAllocateFromNPagedLookasideList(
|
||
&Adapter->SrbDataLookasideList);
|
||
|
||
#if TEST_LISTS
|
||
if(srbData != NULL) {
|
||
InterlockedIncrement64(&Adapter->SrbDataAllocationCount);
|
||
}
|
||
#endif
|
||
|
||
if((srbData == NULL) && (Request != NULL)) {
|
||
|
||
KIRQL oldIrql;
|
||
PSRB_DATA emergencySrbData;
|
||
|
||
//
|
||
// Use the emergency srb data if it's not already in use.
|
||
//
|
||
|
||
KeAcquireSpinLock(&Adapter->EmergencySrbDataSpinLock,
|
||
&oldIrql);
|
||
|
||
emergencySrbData =
|
||
(PSRB_DATA) InterlockedExchangePointer(
|
||
(PVOID) &(Adapter->EmergencySrbData),
|
||
NULL);
|
||
|
||
if(emergencySrbData == NULL) {
|
||
|
||
if(LogicalUnit == NULL ) {
|
||
|
||
//
|
||
// It's in use - queue the request until an srb data block
|
||
// goes free.
|
||
//
|
||
|
||
InsertTailList(
|
||
&Adapter->SrbDataBlockedRequests,
|
||
&Request->Tail.Overlay.DeviceQueueEntry.DeviceListEntry);
|
||
|
||
} else {
|
||
|
||
if( LogicalUnit->BlockedLogicalUnit == NULL ){
|
||
LogicalUnit->BlockedLogicalUnit = Adapter->BlockedLogicalUnit;
|
||
Adapter->BlockedLogicalUnit = LogicalUnit;
|
||
}
|
||
|
||
InsertTailList(
|
||
&LogicalUnit->SrbDataBlockedRequests,
|
||
&Request->Tail.Overlay.DeviceQueueEntry.DeviceListEntry);
|
||
}
|
||
|
||
} else {
|
||
|
||
//
|
||
// There is an SRB_DATA block available after all.
|
||
//
|
||
|
||
srbData = emergencySrbData;
|
||
|
||
#if TEST_LISTS
|
||
InterlockedIncrement64(&Adapter->SrbDataEmergencyFreeCount);
|
||
#endif
|
||
|
||
}
|
||
|
||
KeReleaseSpinLock(&Adapter->EmergencySrbDataSpinLock,
|
||
oldIrql);
|
||
}
|
||
|
||
return srbData;
|
||
}
|
||
|
||
|
||
VOID
|
||
FASTCALL
|
||
SpFreeSrbData(
|
||
IN PADAPTER_EXTENSION Adapter,
|
||
IN PSRB_DATA SrbData
|
||
)
|
||
|
||
{
|
||
PSRB_DATA emergencySrbData = NULL;
|
||
BOOLEAN startedRequest = FALSE;
|
||
LONG depth;
|
||
BOOLEAN Inserted ;
|
||
|
||
ASSERT_SRB_DATA(SrbData);
|
||
ASSERT(SrbData->CurrentIrp == NULL);
|
||
ASSERT(SrbData->CurrentSrb == NULL);
|
||
ASSERT(SrbData->CompletedRequests == NULL);
|
||
|
||
//
|
||
// Determine if there are any other instances of this routine running. If
|
||
// there are, don't start a blocked request.
|
||
//
|
||
|
||
depth = InterlockedIncrement(&Adapter->SrbDataFreeRunning);
|
||
|
||
//
|
||
// Clear out some of the flags so we don't get confused when we reuse this
|
||
// request.
|
||
//
|
||
|
||
SrbData->Flags = 0;
|
||
|
||
//
|
||
// See if we need to store away a new emergency SRB_DATA block
|
||
//
|
||
|
||
emergencySrbData = InterlockedCompareExchangePointer(
|
||
&(Adapter->EmergencySrbData),
|
||
SrbData,
|
||
NULL);
|
||
|
||
//
|
||
// If we stored this SRB_DATA block as the new emergency block AND if this
|
||
// routine is not recursively nested, check if there are any blocked
|
||
// requests waiting to be started.
|
||
//
|
||
|
||
if(emergencySrbData == NULL && depth == 1) {
|
||
|
||
KIRQL oldIrql;
|
||
|
||
CheckForBlockedRequest:
|
||
|
||
//
|
||
// We did - now grab the spinlock and see if we can use it to issue
|
||
// a new request.
|
||
//
|
||
|
||
KeAcquireSpinLock(&(Adapter->EmergencySrbDataSpinLock), &oldIrql);
|
||
|
||
//
|
||
// First check to see if we have a request to process.
|
||
//
|
||
|
||
if( IsListEmpty(&(Adapter->SrbDataBlockedRequests)) ) {
|
||
|
||
Inserted = SpTransferBlockedRequestsToAdapter(Adapter);
|
||
if(!Inserted) {
|
||
KeReleaseSpinLock(&(Adapter->EmergencySrbDataSpinLock), oldIrql);
|
||
InterlockedDecrement(&Adapter->SrbDataFreeRunning);
|
||
return;
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// make sure the emergency request is still there (doesn't really
|
||
// matter if it's the one we were called with or another one - just
|
||
// make sure one is available).
|
||
//
|
||
|
||
emergencySrbData = (PSRB_DATA)
|
||
InterlockedExchangePointer(
|
||
(PVOID) &(Adapter->EmergencySrbData),
|
||
NULL);
|
||
|
||
if(emergencySrbData == NULL) {
|
||
|
||
//
|
||
// Our work here is done.
|
||
//
|
||
|
||
KeReleaseSpinLock(&(Adapter->EmergencySrbDataSpinLock), oldIrql);
|
||
InterlockedDecrement(&Adapter->SrbDataFreeRunning);
|
||
return;
|
||
|
||
} else {
|
||
PIRP request;
|
||
PIO_STACK_LOCATION currentIrpStack;
|
||
PSCSI_REQUEST_BLOCK srb;
|
||
PLIST_ENTRY entry;
|
||
|
||
entry = RemoveHeadList(&(Adapter->SrbDataBlockedRequests));
|
||
|
||
ASSERT(entry != NULL);
|
||
|
||
request =
|
||
CONTAINING_RECORD(
|
||
entry,
|
||
IRP,
|
||
Tail.Overlay.DeviceQueueEntry);
|
||
|
||
KeReleaseSpinLock(&(Adapter->EmergencySrbDataSpinLock), oldIrql);
|
||
|
||
currentIrpStack = IoGetCurrentIrpStackLocation(request);
|
||
srb = currentIrpStack->Parameters.Scsi.Srb;
|
||
|
||
ASSERT_PDO(currentIrpStack->DeviceObject);
|
||
|
||
emergencySrbData->CurrentIrp = request;
|
||
emergencySrbData->CurrentSrb = srb;
|
||
emergencySrbData->LogicalUnit =
|
||
currentIrpStack->DeviceObject->DeviceExtension;
|
||
|
||
srb->OriginalRequest = emergencySrbData;
|
||
|
||
startedRequest = TRUE;
|
||
SpDispatchRequest(emergencySrbData->LogicalUnit,
|
||
request);
|
||
|
||
#if TEST_LISTS
|
||
InterlockedIncrement64(&Adapter->SrbDataResurrectionCount);
|
||
#endif
|
||
}
|
||
|
||
//
|
||
// If we started a blocked request, go back and see if another one
|
||
// needs to be started.
|
||
//
|
||
|
||
if (startedRequest == TRUE) {
|
||
startedRequest = FALSE;
|
||
goto CheckForBlockedRequest;
|
||
}
|
||
|
||
} else if (emergencySrbData != NULL) {
|
||
|
||
//
|
||
// We did not store this SRB_DATA block as the emergency block, so
|
||
// we need to free it back to the lookaside list.
|
||
//
|
||
|
||
ExFreeToNPagedLookasideList(
|
||
&Adapter->SrbDataLookasideList,
|
||
SrbData);
|
||
}
|
||
|
||
InterlockedDecrement(&Adapter->SrbDataFreeRunning);
|
||
return;
|
||
}
|
||
|
||
PVOID
|
||
SpAllocateSrbDataBackend(
|
||
IN POOL_TYPE PoolType,
|
||
IN ULONG NumberOfBytes,
|
||
IN ULONG AdapterIndex
|
||
)
|
||
|
||
{
|
||
KIRQL oldIrql;
|
||
PADAPTER_EXTENSION Adapter;
|
||
PSRB_DATA srbData;
|
||
ULONG tag;
|
||
|
||
KeAcquireSpinLock(&ScsiGlobalAdapterListSpinLock, &oldIrql);
|
||
|
||
Adapter = ScsiGlobalAdapterList[AdapterIndex]->DeviceExtension;
|
||
|
||
KeReleaseSpinLock(&ScsiGlobalAdapterListSpinLock, oldIrql);
|
||
|
||
ASSERT_FDO(Adapter->DeviceObject);
|
||
|
||
tag = SpAllocateQueueTag(Adapter);
|
||
|
||
if(tag == -1) {
|
||
return NULL;
|
||
}
|
||
|
||
srbData = SpAllocatePool(PoolType,
|
||
NumberOfBytes,
|
||
SCSIPORT_TAG_SRB_DATA,
|
||
Adapter->DeviceObject->DriverObject);
|
||
|
||
if(srbData == NULL) {
|
||
SpReleaseQueueTag(Adapter, tag);
|
||
return NULL;
|
||
}
|
||
|
||
RtlZeroMemory(srbData, sizeof(SRB_DATA));
|
||
srbData->Adapter = Adapter;
|
||
srbData->QueueTag = tag;
|
||
srbData->Type = SRB_DATA_TYPE;
|
||
srbData->Size = sizeof(SRB_DATA);
|
||
srbData->Flags = 0;
|
||
srbData->FreeRoutine = SpFreeSrbData;
|
||
|
||
return srbData;
|
||
}
|
||
|
||
VOID
|
||
SpFreeSrbDataBackend(
|
||
IN PSRB_DATA SrbData
|
||
)
|
||
{
|
||
ASSERT_SRB_DATA(SrbData);
|
||
ASSERT_FDO(SrbData->Adapter->DeviceObject);
|
||
ASSERT(SrbData->QueueTag != 0);
|
||
|
||
SpReleaseQueueTag(SrbData->Adapter, SrbData->QueueTag);
|
||
SrbData->Type = 0;
|
||
ExFreePool(SrbData);
|
||
return;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpAllocateTagBitMap(
|
||
IN PADAPTER_EXTENSION Adapter
|
||
)
|
||
|
||
{
|
||
ULONG size; // number of bits
|
||
PRTL_BITMAP bitMap;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Initialize the queue tag bitMap.
|
||
//
|
||
|
||
if(Adapter->MaxQueueTag == 0) {
|
||
#if SMALL_QUEUE_TAG_BITMAP
|
||
if(Adapter->NumberOfRequests <= 240) {
|
||
Adapter->MaxQueueTag = (UCHAR) (Adapter->NumberOfRequests) + 10;
|
||
} else {
|
||
Adapter->MaxQueueTag = 254;
|
||
}
|
||
#else
|
||
Adapter->MaxQueueTag = 254;
|
||
#endif
|
||
} else if (Adapter->MaxQueueTag < Adapter->NumberOfRequests) {
|
||
DbgPrint("SpAllocateTagBitmap: MaxQueueTag %d < NumberOfRequests %d\n"
|
||
"This will negate the advantage of having increased the "
|
||
"number of requests.\n",
|
||
Adapter->MaxQueueTag,
|
||
Adapter->NumberOfRequests);
|
||
}
|
||
|
||
DebugPrint((1, "SpAllocateAdapterResources: %d bits in queue tag "
|
||
"bitMap\n",
|
||
Adapter->MaxQueueTag));
|
||
|
||
size = (Adapter->MaxQueueTag + 1);
|
||
size /= 8;
|
||
size += 1;
|
||
size *= sizeof(UCHAR);
|
||
size += sizeof(RTL_BITMAP);
|
||
|
||
bitMap = SpAllocatePool(NonPagedPool,
|
||
size,
|
||
SCSIPORT_TAG_QUEUE_BITMAP,
|
||
Adapter->DeviceObject->DriverObject);
|
||
|
||
if(bitMap == NULL) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
RtlInitializeBitMap(bitMap,
|
||
(PULONG) (bitMap + 1),
|
||
Adapter->MaxQueueTag);
|
||
|
||
RtlClearAllBits(bitMap);
|
||
|
||
//
|
||
// Queue tag 0 is invalid and should never be returned by the allocator.
|
||
//
|
||
|
||
RtlSetBits(bitMap, 0, 1);
|
||
|
||
Adapter->QueueTagBitMap = bitMap;
|
||
Adapter->QueueTagHint = 1;
|
||
|
||
//
|
||
// Create a spinlock to protect our queue tag bitmap. There's no reason
|
||
// for this to contend with the regular port spinlock.
|
||
//
|
||
|
||
KeInitializeSpinLock(&(Adapter->QueueTagSpinLock));
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
ULONG
|
||
SpAllocateQueueTag(
|
||
IN PADAPTER_EXTENSION Adapter
|
||
)
|
||
{
|
||
KIRQL oldIrql;
|
||
ULONG tagValue;
|
||
|
||
ASSERT_FDO(Adapter->DeviceObject);
|
||
|
||
KeAcquireSpinLock(&(Adapter->QueueTagSpinLock), &oldIrql);
|
||
|
||
//
|
||
// Find an available queue tag.
|
||
//
|
||
|
||
tagValue = RtlFindClearBitsAndSet(Adapter->QueueTagBitMap,
|
||
1,
|
||
Adapter->QueueTagHint);
|
||
|
||
KeReleaseSpinLock(&(Adapter->QueueTagSpinLock), oldIrql);
|
||
|
||
ASSERT(Adapter->QueueTagHint < Adapter->MaxQueueTag);
|
||
ASSERT(tagValue != 0);
|
||
|
||
if(tagValue != -1) {
|
||
|
||
ASSERT(tagValue <= Adapter->MaxQueueTag);
|
||
|
||
//
|
||
// This we can do unsynchronized. if we nuke the hint accidentally it
|
||
// will just increase the cost of the next lookup which should
|
||
// hopefully occur rarely.
|
||
//
|
||
|
||
Adapter->QueueTagHint = (tagValue + 1) % Adapter->MaxQueueTag;
|
||
}
|
||
|
||
return tagValue;
|
||
}
|
||
|
||
VOID
|
||
SpReleaseQueueTag(
|
||
IN PADAPTER_EXTENSION Adapter,
|
||
IN ULONG QueueTag
|
||
)
|
||
{
|
||
KIRQL oldIrql;
|
||
|
||
KeAcquireSpinLock(&(Adapter->QueueTagSpinLock), &oldIrql);
|
||
RtlClearBits(Adapter->QueueTagBitMap,
|
||
QueueTag,
|
||
1);
|
||
KeReleaseSpinLock(&(Adapter->QueueTagSpinLock), oldIrql);
|
||
return;
|
||
}
|
||
|
||
|
||
INTERFACE_TYPE
|
||
SpGetPdoInterfaceType(
|
||
IN PDEVICE_OBJECT Pdo
|
||
)
|
||
{
|
||
ULONG value;
|
||
|
||
GUID busTypeGuid;
|
||
INTERFACE_TYPE interfaceType = InterfaceTypeUndefined;
|
||
ULONG result;
|
||
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
status = SpReadNumericInstanceValue(Pdo,
|
||
L"LegacyInterfaceType",
|
||
&value);
|
||
|
||
if(NT_SUCCESS(status)) {
|
||
interfaceType = value;
|
||
return interfaceType;
|
||
}
|
||
|
||
//
|
||
// Attempt to get and interpret the bus type GUID.
|
||
//
|
||
|
||
status = IoGetDeviceProperty(Pdo,
|
||
DevicePropertyBusTypeGuid,
|
||
sizeof(GUID),
|
||
&busTypeGuid,
|
||
&result);
|
||
|
||
if(NT_SUCCESS(status)) {
|
||
|
||
ULONG i;
|
||
|
||
for(i = 0;
|
||
(SpGuidInterfaceMappingList[i].InterfaceType !=
|
||
InterfaceTypeUndefined);
|
||
i++) {
|
||
|
||
if(RtlEqualMemory(&(SpGuidInterfaceMappingList[i].Guid),
|
||
&busTypeGuid,
|
||
sizeof(GUID))) {
|
||
|
||
//
|
||
// We have a legacy interface type for this guid already.
|
||
//
|
||
|
||
interfaceType = SpGuidInterfaceMappingList[i].InterfaceType;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(interfaceType != InterfaceTypeUndefined) {
|
||
return interfaceType;
|
||
}
|
||
|
||
status = IoGetDeviceProperty(Pdo,
|
||
DevicePropertyLegacyBusType,
|
||
sizeof(INTERFACE_TYPE),
|
||
&interfaceType,
|
||
&result);
|
||
|
||
if(NT_SUCCESS(status)) {
|
||
ASSERT(result == sizeof(INTERFACE_TYPE));
|
||
|
||
//
|
||
// Munge the interface type for the case of PCMCIA cards to allow SCSI
|
||
// pccards (i.e. sparrow) to be recognized. Much better would be a way
|
||
// to get the interface type correct before we enter this routine.
|
||
//
|
||
|
||
if (interfaceType == PCMCIABus) {
|
||
interfaceType = Isa;
|
||
}
|
||
|
||
}
|
||
|
||
if(interfaceType != InterfaceTypeUndefined) {
|
||
|
||
return interfaceType;
|
||
|
||
} else {
|
||
|
||
//
|
||
// No idea what the interface type is - guess isa.
|
||
//
|
||
|
||
DebugPrint((1, "SpGetPdoInterfaceType: Status %#08lx getting legacy "
|
||
"bus type - assuming device is ISA\n", status));
|
||
return Isa;
|
||
}
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpReadNumericInstanceValue(
|
||
IN PDEVICE_OBJECT Pdo,
|
||
IN PWSTR ValueName,
|
||
OUT PULONG Value
|
||
)
|
||
{
|
||
ULONG value;
|
||
|
||
HANDLE baseKey = NULL;
|
||
HANDLE scsiportKey = NULL;
|
||
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
ASSERT(Value != NULL);
|
||
ASSERT(ValueName != NULL);
|
||
ASSERT(Pdo != NULL);
|
||
|
||
status = IoOpenDeviceRegistryKey(Pdo,
|
||
PLUGPLAY_REGKEY_DEVICE,
|
||
KEY_READ,
|
||
&baseKey);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
return status;
|
||
}
|
||
|
||
try {
|
||
UNICODE_STRING unicodeKeyName;
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
|
||
RtlInitUnicodeString(&unicodeKeyName, L"Scsiport");
|
||
InitializeObjectAttributes(&objectAttributes,
|
||
&unicodeKeyName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
baseKey,
|
||
NULL);
|
||
|
||
status = ZwOpenKey(&scsiportKey,
|
||
KEY_READ,
|
||
&objectAttributes);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
leave;
|
||
} else {
|
||
UNICODE_STRING unicodeValueName;
|
||
|
||
UCHAR buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)];
|
||
|
||
PKEY_VALUE_PARTIAL_INFORMATION keyValue =
|
||
(PKEY_VALUE_PARTIAL_INFORMATION) buffer;
|
||
|
||
ULONG result;
|
||
|
||
RtlInitUnicodeString(&unicodeValueName, ValueName);
|
||
|
||
status = ZwQueryValueKey(scsiportKey,
|
||
&unicodeValueName,
|
||
KeyValuePartialInformation,
|
||
keyValue,
|
||
sizeof(buffer),
|
||
&result);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
leave;
|
||
}
|
||
|
||
if(keyValue->Type != REG_DWORD) {
|
||
status = STATUS_OBJECT_TYPE_MISMATCH;
|
||
leave;
|
||
}
|
||
|
||
if(result < sizeof(ULONG)) {
|
||
status = STATUS_OBJECT_TYPE_MISMATCH;
|
||
leave;
|
||
}
|
||
|
||
value = ((PULONG) (keyValue->Data))[0];
|
||
}
|
||
|
||
} finally {
|
||
if(baseKey != NULL) {ZwClose(baseKey);}
|
||
if(scsiportKey != NULL) {ZwClose(scsiportKey);}
|
||
}
|
||
|
||
*Value = value;
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpWriteNumericInstanceValue(
|
||
IN PDEVICE_OBJECT Pdo,
|
||
IN PWSTR ValueName,
|
||
IN ULONG Value
|
||
)
|
||
{
|
||
ULONG value;
|
||
|
||
HANDLE baseKey = NULL;
|
||
HANDLE scsiportKey = NULL;
|
||
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
ASSERT(ValueName != NULL);
|
||
ASSERT(Pdo != NULL);
|
||
|
||
status = IoOpenDeviceRegistryKey(Pdo,
|
||
PLUGPLAY_REGKEY_DEVICE,
|
||
KEY_READ | KEY_WRITE,
|
||
&baseKey);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
return status;
|
||
}
|
||
|
||
try {
|
||
UNICODE_STRING unicodeKeyName;
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
|
||
RtlInitUnicodeString(&unicodeKeyName, L"Scsiport");
|
||
InitializeObjectAttributes(&objectAttributes,
|
||
&unicodeKeyName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
baseKey,
|
||
NULL);
|
||
|
||
status = ZwCreateKey(&scsiportKey,
|
||
KEY_READ | KEY_WRITE,
|
||
&objectAttributes,
|
||
0,
|
||
NULL,
|
||
REG_OPTION_NON_VOLATILE,
|
||
NULL
|
||
);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
leave;
|
||
} else {
|
||
UNICODE_STRING unicodeValueName;
|
||
|
||
ULONG result;
|
||
|
||
RtlInitUnicodeString(&unicodeValueName, ValueName);
|
||
|
||
status = ZwSetValueKey(scsiportKey,
|
||
&unicodeValueName,
|
||
0,
|
||
REG_DWORD,
|
||
&Value,
|
||
sizeof(ULONG));
|
||
|
||
}
|
||
|
||
} finally {
|
||
if(baseKey != NULL) {ZwClose(baseKey);}
|
||
if(scsiportKey != NULL) {ZwClose(scsiportKey);}
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
PMAPPED_ADDRESS
|
||
SpAllocateAddressMapping(
|
||
PADAPTER_EXTENSION Adapter
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will attempt to allocate a free address mapping block and
|
||
place it on the adapter's MappedAddressList. If there is an available
|
||
block in the free list then it will be used. Otherwise it will attempt
|
||
to allocate a block from non-paged pool.
|
||
|
||
Arguments:
|
||
|
||
Adapter - the adapter we are allocating the mapping for.
|
||
|
||
Preallocate - indicates that the caller is trying to preallocate buffers.
|
||
|
||
|
||
Return Value:
|
||
|
||
a pointer to the new mapping (which has been inserted into the address
|
||
mapping list) or NULL if none could be allocated.
|
||
|
||
--*/
|
||
{
|
||
PMAPPED_ADDRESS mapping;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// First check the free address mapping list. If there's one there
|
||
// unlink it and return.
|
||
//
|
||
|
||
if(Adapter->FreeMappedAddressList != NULL) {
|
||
mapping = Adapter->FreeMappedAddressList;
|
||
Adapter->FreeMappedAddressList = mapping->NextMappedAddress;
|
||
} else {
|
||
mapping = SpAllocatePool(NonPagedPool,
|
||
sizeof(MAPPED_ADDRESS),
|
||
SCSIPORT_TAG_MAPPING_LIST,
|
||
Adapter->DeviceObject->DriverObject);
|
||
}
|
||
|
||
if(mapping == NULL) {
|
||
DebugPrint((0, "SpAllocateAddressMapping: Unable to allocate "
|
||
"mapping\n"));
|
||
|
||
return NULL;
|
||
}
|
||
|
||
RtlZeroMemory(mapping, sizeof(MAPPED_ADDRESS));
|
||
|
||
mapping->NextMappedAddress = Adapter->MappedAddressList;
|
||
Adapter->MappedAddressList = mapping;
|
||
|
||
return mapping;
|
||
}
|
||
|
||
BOOLEAN
|
||
SpPreallocateAddressMapping(
|
||
PADAPTER_EXTENSION Adapter,
|
||
IN UCHAR NumberOfBlocks
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will allocate a number of address mapping structures and
|
||
place them on the free mapped address list.
|
||
|
||
Arguments:
|
||
|
||
Adapter - the adapter we are allocating the mapping for.
|
||
|
||
NumberOfBlocks - the number of blocks to allocate
|
||
|
||
|
||
Return Value:
|
||
|
||
TRUE if the requested number of blocks was successfully allocated,
|
||
|
||
FALSE if there was not sufficient memory to allocate them all. The caller
|
||
is still responsible for freeing them in this case.
|
||
|
||
--*/
|
||
{
|
||
PMAPPED_ADDRESS mapping;
|
||
ULONG i;
|
||
|
||
PAGED_CODE();
|
||
|
||
for(i = 0; i < NumberOfBlocks; i++) {
|
||
mapping = SpAllocatePool(NonPagedPool,
|
||
sizeof(MAPPED_ADDRESS),
|
||
SCSIPORT_TAG_MAPPING_LIST,
|
||
Adapter->DeviceObject->DriverObject);
|
||
|
||
if(mapping == NULL) {
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
RtlZeroMemory(mapping, sizeof(MAPPED_ADDRESS));
|
||
|
||
mapping->NextMappedAddress = Adapter->FreeMappedAddressList;
|
||
Adapter->FreeMappedAddressList = mapping;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
VOID
|
||
SpPurgeFreeMappedAddressList(
|
||
IN PADAPTER_EXTENSION Adapter
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine frees all of the mapped address blocks on the
|
||
FreeMappedAddressList.
|
||
|
||
Arguments:
|
||
|
||
Adapter - the adapter who's FreeMappedAddressList is to be dumped.
|
||
|
||
Return Value:
|
||
|
||
none
|
||
|
||
--*/
|
||
{
|
||
PMAPPED_ADDRESS mapping;
|
||
|
||
PAGED_CODE();
|
||
|
||
while(Adapter->FreeMappedAddressList != NULL) {
|
||
mapping = Adapter->FreeMappedAddressList;
|
||
Adapter->FreeMappedAddressList = mapping->NextMappedAddress;
|
||
|
||
ExFreePool(mapping);
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
BOOLEAN
|
||
SpFreeMappedAddress(
|
||
IN PADAPTER_EXTENSION Adapter,
|
||
IN PVOID MappedAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will unmap the specified mapping and then return the mapping
|
||
block to the free list. If no mapped address was specified then this
|
||
will simply free the first mapping on the MappedAddressList.
|
||
|
||
Arguments:
|
||
|
||
Adapter - the adapter which has the mapping
|
||
|
||
MappedAddress - the base address of the mapping we're attempting to free.
|
||
ignored if FreeSpecificBlock is false.
|
||
|
||
Return Value:
|
||
|
||
TRUE if a matching list element was found.
|
||
FALSE otherwise.
|
||
|
||
--*/
|
||
{
|
||
PMAPPED_ADDRESS *mapping;
|
||
|
||
PAGED_CODE();
|
||
|
||
for(mapping = &(Adapter->MappedAddressList);
|
||
*mapping != NULL;
|
||
mapping = &((*mapping)->NextMappedAddress)) {
|
||
|
||
if((*mapping)->MappedAddress == MappedAddress) {
|
||
|
||
PMAPPED_ADDRESS tmp = *mapping;
|
||
|
||
//
|
||
// Unmap address.
|
||
//
|
||
|
||
MmUnmapIoSpace(tmp->MappedAddress, tmp->NumberOfBytes);
|
||
|
||
//
|
||
// Unlink this entry from the mapped address list. Stick it on
|
||
// the free mapped address list. Then return.
|
||
//
|
||
|
||
*mapping = tmp->NextMappedAddress;
|
||
|
||
tmp->NextMappedAddress = Adapter->FreeMappedAddressList;
|
||
Adapter->FreeMappedAddressList = tmp;
|
||
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
PMAPPED_ADDRESS
|
||
SpFindMappedAddress(
|
||
IN PADAPTER_EXTENSION Adapter,
|
||
IN LARGE_INTEGER IoAddress,
|
||
IN ULONG NumberOfBytes,
|
||
IN ULONG SystemIoBusNumber
|
||
)
|
||
{
|
||
PMAPPED_ADDRESS mapping;
|
||
|
||
for(mapping = Adapter->MappedAddressList;
|
||
mapping != NULL;
|
||
mapping = mapping->NextMappedAddress) {
|
||
|
||
if((mapping->IoAddress.QuadPart == IoAddress.QuadPart) &&
|
||
(mapping->NumberOfBytes == NumberOfBytes) &&
|
||
(mapping->BusNumber == SystemIoBusNumber)) {
|
||
return mapping;
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
|
||
VOID
|
||
SpReleaseMappedAddresses(
|
||
IN PADAPTER_EXTENSION Adapter
|
||
)
|
||
{
|
||
ULONG i;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Iterate through the mapped address list and punt every entry onto the
|
||
// free list.
|
||
//
|
||
|
||
while(Adapter->MappedAddressList != NULL) {
|
||
SpFreeMappedAddress(Adapter, Adapter->MappedAddressList->MappedAddress);
|
||
}
|
||
|
||
//
|
||
// Now dump the free list.
|
||
//
|
||
|
||
SpPurgeFreeMappedAddressList(Adapter);
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpSignalCompletion(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PKEVENT Event
|
||
)
|
||
{
|
||
KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
|
||
return STATUS_MORE_PROCESSING_REQUIRED;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpSendIrpSynchronous(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
{
|
||
KEVENT event;
|
||
|
||
PAGED_CODE();
|
||
|
||
KeInitializeEvent(&event, SynchronizationEvent, FALSE);
|
||
|
||
IoCopyCurrentIrpStackLocationToNext(Irp);
|
||
IoSetCompletionRoutine(Irp,
|
||
SpSignalCompletion,
|
||
&event,
|
||
TRUE,
|
||
TRUE,
|
||
TRUE);
|
||
|
||
IoCallDriver(DeviceObject, Irp);
|
||
|
||
KeWaitForSingleObject(&event,
|
||
Executive,
|
||
KernelMode,
|
||
FALSE,
|
||
NULL);
|
||
|
||
return Irp->IoStatus.Status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
SpGetBusTypeGuid(
|
||
IN PADAPTER_EXTENSION Adapter
|
||
)
|
||
{
|
||
ULONG result;
|
||
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Grab the bus interface GUID and save it away in the adapter extension.
|
||
//
|
||
|
||
status = IoGetDeviceProperty(Adapter->LowerPdo,
|
||
DevicePropertyBusTypeGuid,
|
||
sizeof(GUID),
|
||
&(Adapter->BusTypeGuid),
|
||
&result);
|
||
|
||
if(!NT_SUCCESS(status)) {
|
||
RtlZeroMemory(&(Adapter->BusTypeGuid), sizeof(GUID));
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
BOOLEAN
|
||
SpDetermine64BitSupport(
|
||
VOID
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine determines if 64-bit physical addressing is supported by
|
||
the system to be saved in the global Sp64BitPhysicalAddressing. Eventually
|
||
this routine can be removed and the scsiport global will just point to the
|
||
one exported by MM. However the global isn't hooked up for PAE36 at the
|
||
moment so we need to do some x86 specific tricks.
|
||
|
||
Arguments:
|
||
|
||
none
|
||
|
||
Return Value:
|
||
|
||
Does the system support 64-bit (or something over 32-bit) addresses?
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE();
|
||
|
||
if((*Mm64BitPhysicalAddress) == TRUE) {
|
||
DbgPrintEx(DPFLTR_SCSIPORT_ID,
|
||
DPFLTR_INFO_LEVEL,
|
||
"SpDetermine64BitSupport: Mm64BitPhysicalAddress is TRUE\n");
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
VOID
|
||
SpAdjustDisabledBit(
|
||
IN PLOGICAL_UNIT_EXTENSION LogicalUnit,
|
||
IN BOOLEAN Enable
|
||
)
|
||
{
|
||
ULONG newCount;
|
||
KIRQL oldIrql;
|
||
|
||
KeAcquireSpinLock(&(LogicalUnit->AdapterExtension->SpinLock), &oldIrql);
|
||
if(Enable) {
|
||
if(LogicalUnit->QueuePauseCount != 0) {
|
||
LogicalUnit->QueuePauseCount -= 1;
|
||
}
|
||
|
||
if(LogicalUnit->QueuePauseCount == 0) {
|
||
CLEAR_FLAG(LogicalUnit->LuFlags, LU_QUEUE_PAUSED);
|
||
}
|
||
} else {
|
||
LogicalUnit->QueuePauseCount += 1;
|
||
SET_FLAG(LogicalUnit->LuFlags, LU_QUEUE_PAUSED);
|
||
}
|
||
KeReleaseSpinLock(&(LogicalUnit->AdapterExtension->SpinLock), oldIrql);
|
||
return;
|
||
}
|
||
|
||
NTSTATUS
|
||
SpReadNumericValue(
|
||
IN OPTIONAL HANDLE Root,
|
||
IN OPTIONAL PUNICODE_STRING KeyName,
|
||
IN PUNICODE_STRING ValueName,
|
||
OUT PULONG Value
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will read a REG_DWORD value from the specified registry
|
||
location. The caller can specify the key by providing a handle to a root
|
||
registry key and the name of a subkey.
|
||
|
||
The caller must supply either Root or KeyName. Both may be supplied.
|
||
|
||
Arguments:
|
||
|
||
Root - the key the value resides in (if KeyName is NULL), a parent
|
||
key of the one the value resides in, or NULL if KeyName specifies
|
||
the entire registry path.
|
||
|
||
KeyName - the name of the subkey (either from the root of the registry or
|
||
from the key specified in Root.
|
||
|
||
ValueName - the name of the value to be read
|
||
|
||
Value - returns the value in the key. this will be zero if an error occurs
|
||
|
||
Return Value:
|
||
|
||
STATUS_SUCCESS if successful.
|
||
STATUS_UNSUCCESSFUL if the specified value is not a REG_DWORD value.
|
||
other status values explaining the cause of the failure.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG value = 0;
|
||
|
||
HANDLE key = Root;
|
||
|
||
NTSTATUS status = STATUS_SUCCESS;
|
||
|
||
PAGED_CODE();
|
||
|
||
ASSERT(Value != NULL);
|
||
ASSERT(ValueName != NULL);
|
||
|
||
ASSERT((KeyName != NULL) || (Root != NULL));
|
||
|
||
if(ARGUMENT_PRESENT(KeyName)) {
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
|
||
InitializeObjectAttributes(&(objectAttributes),
|
||
KeyName,
|
||
OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
|
||
Root,
|
||
NULL);
|
||
|
||
status = ZwOpenKey(&(key), KEY_QUERY_VALUE, &objectAttributes);
|
||
}
|
||
|
||
if(NT_SUCCESS(status)) {
|
||
UCHAR buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)];
|
||
PKEY_VALUE_PARTIAL_INFORMATION data;
|
||
ULONG result;
|
||
|
||
RtlZeroMemory(buffer, sizeof(buffer));
|
||
data = (PKEY_VALUE_PARTIAL_INFORMATION) buffer;
|
||
|
||
status = ZwQueryValueKey(key,
|
||
ValueName,
|
||
KeyValuePartialInformation,
|
||
data,
|
||
sizeof(buffer),
|
||
&result);
|
||
|
||
if(NT_SUCCESS(status)) {
|
||
if (data->Type != REG_DWORD) {
|
||
status = STATUS_UNSUCCESSFUL;
|
||
} else {
|
||
value = ((PULONG) data->Data)[0];
|
||
}
|
||
}
|
||
}
|
||
|
||
*Value = value;
|
||
|
||
if(key != Root) {
|
||
ZwClose(key);
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
PMDL
|
||
SpBuildMdlForMappedTransfer(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PDMA_ADAPTER AdapterObject,
|
||
IN PMDL OriginalMdl,
|
||
IN PVOID StartVa,
|
||
IN ULONG ByteCount,
|
||
IN PSRB_SCATTER_GATHER ScatterGatherList,
|
||
IN ULONG ScatterGatherEntries
|
||
)
|
||
{
|
||
ULONG size;
|
||
PMDL mdl;
|
||
|
||
ULONG pageCount;
|
||
|
||
PPFN_NUMBER pages;
|
||
ULONG sgPage;
|
||
ULONG mdlPage;
|
||
ULONG sgSpan;
|
||
|
||
mdl = SpAllocateMdl(StartVa,
|
||
ByteCount,
|
||
FALSE,
|
||
FALSE,
|
||
NULL,
|
||
DeviceObject->DriverObject);
|
||
|
||
if (mdl == NULL) {
|
||
return NULL;
|
||
}
|
||
|
||
pageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(StartVa, ByteCount);
|
||
|
||
//
|
||
// Indicate that the memory has already been locked down.
|
||
//
|
||
|
||
//
|
||
// Indicate that the memory is "I/O space" so that MM doesn't won't
|
||
// reference the (nonexistent) PFNs for this buffer. We have to do this
|
||
// for the time being because MM isn't aware of the pages the HAL is using
|
||
// for bounce buffers.
|
||
//
|
||
|
||
SET_FLAG(mdl->MdlFlags, MDL_PAGES_LOCKED | MDL_IO_SPACE);
|
||
|
||
//
|
||
// Run through our scatter gather list and build the page list based
|
||
// on that.
|
||
//
|
||
|
||
pages = (PPFN_NUMBER) (mdl + 1);
|
||
|
||
for(sgPage = 0, mdlPage = 0; sgPage < ScatterGatherEntries; sgPage++) {
|
||
|
||
PVOID pa;
|
||
ULONG sgLength;
|
||
|
||
ASSERT(ScatterGatherList[sgPage].Length != 0);
|
||
|
||
pa = (PVOID) ScatterGatherList[sgPage].Address.QuadPart;
|
||
|
||
sgLength =
|
||
ADDRESS_AND_SIZE_TO_SPAN_PAGES(pa,
|
||
ScatterGatherList[sgPage].Length);
|
||
|
||
for(sgSpan = 0; sgSpan < sgLength; sgSpan++, mdlPage++) {
|
||
ULONGLONG pageAddr;
|
||
pageAddr = ScatterGatherList[sgPage].Address.QuadPart;
|
||
pageAddr += sgSpan * PAGE_SIZE;
|
||
pageAddr >>= PAGE_SHIFT;
|
||
pages[mdlPage] = (PFN_NUMBER) (pageAddr);
|
||
}
|
||
}
|
||
pages = (PPFN_NUMBER) (mdl + 1);
|
||
pages = (PPFN_NUMBER) (OriginalMdl + 1);
|
||
|
||
ASSERT(mdlPage == pageCount);
|
||
|
||
return mdl;
|
||
}
|
||
|
||
#if defined(FORWARD_PROGRESS)
|
||
VOID
|
||
SpPrepareMdlForMappedTransfer(
|
||
IN PMDL mdl,
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PDMA_ADAPTER AdapterObject,
|
||
IN PMDL OriginalMdl,
|
||
IN PVOID StartVa,
|
||
IN ULONG ByteCount,
|
||
IN PSRB_SCATTER_GATHER ScatterGatherList,
|
||
IN ULONG ScatterGatherEntries
|
||
)
|
||
{
|
||
ULONG size;
|
||
|
||
ULONG pageCount;
|
||
|
||
PPFN_NUMBER pages;
|
||
ULONG sgPage;
|
||
ULONG mdlPage;
|
||
ULONG sgSpan;
|
||
|
||
pageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(StartVa, ByteCount);
|
||
|
||
//
|
||
// Indicate that the memory has already been locked down.
|
||
//
|
||
|
||
//
|
||
// Indicate that the memory is "I/O space" so that MM doesn't won't
|
||
// reference the (nonexistent) PFNs for this buffer. We have to do this
|
||
// for the time being because MM isn't aware of the pages the HAL is using
|
||
// for bounce buffers.
|
||
//
|
||
|
||
SET_FLAG(mdl->MdlFlags, MDL_PAGES_LOCKED | MDL_IO_SPACE);
|
||
|
||
//
|
||
// Run through our scatter gather list and build the page list based
|
||
// on that.
|
||
//
|
||
|
||
pages = (PPFN_NUMBER) (mdl + 1);
|
||
|
||
for(sgPage = 0, mdlPage = 0; sgPage < ScatterGatherEntries; sgPage++) {
|
||
|
||
PVOID pa;
|
||
ULONG sgLength;
|
||
|
||
ASSERT(ScatterGatherList[sgPage].Length != 0);
|
||
|
||
pa = (PVOID) ScatterGatherList[sgPage].Address.QuadPart;
|
||
|
||
sgLength =
|
||
ADDRESS_AND_SIZE_TO_SPAN_PAGES(pa,
|
||
ScatterGatherList[sgPage].Length);
|
||
|
||
for(sgSpan = 0; sgSpan < sgLength; sgSpan++, mdlPage++) {
|
||
ULONGLONG pageAddr;
|
||
pageAddr = ScatterGatherList[sgPage].Address.QuadPart;
|
||
pageAddr += sgSpan * PAGE_SIZE;
|
||
pageAddr >>= PAGE_SHIFT;
|
||
pages[mdlPage] = (PFN_NUMBER) (pageAddr);
|
||
}
|
||
}
|
||
pages = (PPFN_NUMBER) (mdl + 1);
|
||
pages = (PPFN_NUMBER) (OriginalMdl + 1);
|
||
|
||
ASSERT(mdlPage == pageCount);
|
||
}
|
||
#endif
|
||
|
||
PSRB_DATA
|
||
FASTCALL
|
||
SpAllocateBypassSrbData(
|
||
IN PLOGICAL_UNIT_EXTENSION LogicalUnit
|
||
)
|
||
{
|
||
PSLIST_ENTRY entry;
|
||
PSRB_DATA srbData;
|
||
|
||
entry = ExInterlockedPopEntrySList(&(LogicalUnit->BypassSrbDataList),
|
||
&(LogicalUnit->BypassSrbDataSpinLock));
|
||
|
||
if(entry == NULL) {
|
||
KeBugCheckEx(PORT_DRIVER_INTERNAL,
|
||
5,
|
||
NUMBER_BYPASS_SRB_DATA_BLOCKS,
|
||
(ULONG_PTR) LogicalUnit->BypassSrbDataBlocks,
|
||
0);
|
||
}
|
||
|
||
srbData = CONTAINING_RECORD(entry, SRB_DATA, Reserved);
|
||
|
||
srbData->Adapter = LogicalUnit->AdapterExtension;
|
||
srbData->QueueTag = SP_UNTAGGED;
|
||
srbData->Type = SRB_DATA_TYPE;
|
||
srbData->Size = sizeof(SRB_DATA);
|
||
srbData->Flags = SRB_DATA_BYPASS_REQUEST;
|
||
srbData->FreeRoutine = SpFreeBypassSrbData;
|
||
|
||
return srbData;
|
||
}
|
||
|
||
VOID
|
||
FASTCALL
|
||
SpFreeBypassSrbData(
|
||
IN PADAPTER_EXTENSION Adapter,
|
||
IN PSRB_DATA SrbData
|
||
)
|
||
|
||
{
|
||
PLOGICAL_UNIT_EXTENSION lu = SrbData->LogicalUnit;
|
||
|
||
ASSERT_SRB_DATA(SrbData);
|
||
ASSERT(SrbData->CurrentIrp == NULL);
|
||
ASSERT(SrbData->CurrentSrb == NULL);
|
||
ASSERT(SrbData->CompletedRequests == NULL);
|
||
ASSERT(TEST_FLAG(SrbData->Flags, SRB_DATA_BYPASS_REQUEST));
|
||
|
||
RtlZeroMemory(SrbData, sizeof(SRB_DATA));
|
||
|
||
ExInterlockedPushEntrySList(&(lu->BypassSrbDataList),
|
||
&(SrbData->Reserved),
|
||
&(lu->BypassSrbDataSpinLock));
|
||
return;
|
||
}
|
||
|
||
PVOID
|
||
SpAllocateErrorLogEntry(
|
||
IN PDRIVER_OBJECT DriverObject
|
||
)
|
||
{
|
||
PVOID Packet;
|
||
|
||
ASSERT(DriverObject);
|
||
Packet = IoAllocateErrorLogEntry(
|
||
DriverObject,
|
||
sizeof(IO_ERROR_LOG_PACKET) + sizeof(SCSIPORT_ALLOCFAILURE_DATA));
|
||
|
||
return Packet;
|
||
}
|
||
|
||
VOID
|
||
FASTCALL
|
||
SpLogAllocationFailureFn(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN POOL_TYPE PoolType,
|
||
IN SIZE_T Size,
|
||
IN ULONG Tag,
|
||
IN ULONG FileId,
|
||
IN ULONG LineNumber
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine writes a message to the event log indicating that an
|
||
allocation failure has occurred.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - pointer to the driver object for which the allocation
|
||
failure event is being logged.
|
||
|
||
PoolType - identifies the pool the failed allocation attempt was from.
|
||
|
||
Size - indicates the number of bytes that the failed allocation
|
||
attempt tried to obtain.
|
||
|
||
Tag - identifies the pool tag associated with the failed
|
||
allocation.
|
||
|
||
AllocId - uniquely identifies this allocation w/in scsiport.
|
||
|
||
Return Value:
|
||
|
||
VOID
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
PIO_ERROR_LOG_PACKET Packet;
|
||
PIO_ERROR_LOG_PACKET CurrentValue;
|
||
SCSIPORT_ALLOCFAILURE_DATA *Data;
|
||
// PSCSIPORT_ALLOCFAILURE_ENTRY Entry;
|
||
// PSCSIPORT_ALLOCFAILURE_ENTRY CurrentValue;
|
||
PSCSIPORT_DRIVER_EXTENSION DriverExtension;
|
||
|
||
DebugPrint((2, "SpLogAllocationFailureFn: DriverObject:%p\nId:%08X|%08X\n",
|
||
DriverObject,
|
||
FileId, LineNumber));
|
||
|
||
//
|
||
// Try to allocate a new error log event.
|
||
//
|
||
|
||
Packet = (PIO_ERROR_LOG_PACKET)
|
||
SpAllocateErrorLogEntry(DriverObject);
|
||
|
||
//
|
||
// If we could not allocate a log event, we check the driver extension to
|
||
// see if it has a reserve event we can use. If we cannot get the driver
|
||
// extension or if it does not contain a reserve event, we return
|
||
// without logging the allocation failure.
|
||
//
|
||
|
||
if (Packet == NULL) {
|
||
|
||
//
|
||
// See if there is a driver extension for this driver. It is possible
|
||
// that one has not been created yet, so this may fail, in which case
|
||
// we give up and return.
|
||
//
|
||
|
||
DriverExtension = IoGetDriverObjectExtension(
|
||
DriverObject,
|
||
ScsiPortInitialize
|
||
);
|
||
|
||
if (DriverExtension == NULL) {
|
||
DebugPrint((1, "SpLogAllocationFailureFn: no driver extension\n"));
|
||
return;
|
||
}
|
||
|
||
//
|
||
// Get the reserve event in the driver extension. The reserve event
|
||
// may have already been used, so it's possible that it is NULL. If
|
||
// this is the case, we give up and return.
|
||
//
|
||
|
||
Packet = (PIO_ERROR_LOG_PACKET)
|
||
DriverExtension->ReserveAllocFailureLogEntry;
|
||
|
||
if (Packet == NULL) {
|
||
DebugPrint((1, "SpLogAllocationFailureFn: no reserve packet\n"));
|
||
return;
|
||
}
|
||
|
||
//
|
||
// We have to ensure that we are the only instance to use this
|
||
// event. To do so, we attempt to NULL the event in the driver
|
||
// extension. If somebody else beats us to it, they own the
|
||
// event and we have to give up.
|
||
//
|
||
|
||
CurrentValue = InterlockedCompareExchangePointer(
|
||
DriverExtension->ReserveAllocFailureLogEntry,
|
||
NULL,
|
||
Packet
|
||
);
|
||
|
||
if (Packet != CurrentValue) {
|
||
DebugPrint((1, "SpLogAllocationFailureFn: someone already owns packet\n"));
|
||
return;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Initialize the error log packet.
|
||
//
|
||
|
||
Packet->ErrorCode = IO_WARNING_ALLOCATION_FAILED;
|
||
Packet->SequenceNumber = 0;
|
||
Packet->MajorFunctionCode = 0;
|
||
Packet->RetryCount = 0;
|
||
Packet->UniqueErrorValue = 0x10;
|
||
Packet->FinalStatus = STATUS_INSUFFICIENT_RESOURCES;
|
||
Packet->DumpDataSize = sizeof(ULONG) * 4;
|
||
Packet->NumberOfStrings = 0;
|
||
Packet->DumpData[0] = Tag;
|
||
|
||
Data = (SCSIPORT_ALLOCFAILURE_DATA*) &Packet->DumpData[1];
|
||
|
||
Data->Size = (ULONG) Size;
|
||
Data->FileId = FileId;
|
||
Data->LineNumber = LineNumber;
|
||
|
||
//
|
||
// Queue the error log entry.
|
||
//
|
||
|
||
IoWriteErrorLogEntry(Packet);
|
||
}
|
||
|
||
PVOID
|
||
SpAllocatePoolEx(
|
||
IN POOL_TYPE PoolType,
|
||
IN SIZE_T NumberOfBytes,
|
||
IN ULONG Tag,
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN ULONG FileId,
|
||
IN ULONG LineNumber
|
||
)
|
||
{
|
||
PVOID Block;
|
||
|
||
if (NumberOfBytes == 0) {
|
||
return NULL;
|
||
}
|
||
|
||
Block = ExAllocatePoolWithTag(PoolType,
|
||
NumberOfBytes,
|
||
Tag);
|
||
if (Block == NULL) {
|
||
|
||
SpLogAllocationFailureFn(DriverObject,
|
||
PoolType,
|
||
NumberOfBytes,
|
||
Tag,
|
||
FileId,
|
||
LineNumber);
|
||
}
|
||
|
||
return Block;
|
||
}
|
||
|
||
PMDL
|
||
SpAllocateMdlEx(
|
||
IN PVOID VirtualAddress,
|
||
IN ULONG Length,
|
||
IN BOOLEAN SecondaryBuffer,
|
||
IN BOOLEAN ChargeQuota,
|
||
IN OUT PIRP Irp,
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN ULONG FileId,
|
||
IN ULONG LineNumber
|
||
)
|
||
{
|
||
PMDL mdl = IoAllocateMdl(VirtualAddress,
|
||
Length,
|
||
SecondaryBuffer,
|
||
ChargeQuota,
|
||
Irp);
|
||
if (mdl == NULL) {
|
||
SpLogAllocationFailureFn(DriverObject,
|
||
NonPagedPool,
|
||
0,
|
||
SCSIPORT_TAG_ALLOCMDL,
|
||
FileId,
|
||
LineNumber);
|
||
}
|
||
return mdl;
|
||
}
|
||
|
||
PIRP
|
||
SpAllocateIrpEx(
|
||
IN CCHAR StackSize,
|
||
IN BOOLEAN ChargeQuota,
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN ULONG FileId,
|
||
IN ULONG LineNumber
|
||
)
|
||
{
|
||
PIRP irp = IoAllocateIrp(StackSize, ChargeQuota);
|
||
if (irp == NULL) {
|
||
SpLogAllocationFailureFn(DriverObject,
|
||
NonPagedPool,
|
||
0,
|
||
SCSIPORT_TAG_ALLOCIRP,
|
||
FileId,
|
||
LineNumber);
|
||
}
|
||
return irp;
|
||
}
|
||
|
||
BOOLEAN
|
||
SpTransferBlockedRequestsToAdapter(
|
||
PADAPTER_EXTENSION Adapter
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will transfer the blocked requests from the Lun Queue to the
|
||
Adapter queue. This is necessary, so as to give a fair(fairness on lun
|
||
level as opposed to previous scheme of adapter level) chance for all
|
||
blocked lun requests to be processed.
|
||
|
||
This routine must be called with the EmergencySpinLock held.
|
||
|
||
Arguments:
|
||
|
||
Adapter - The Adapter extension to which the lun blocked requests would be
|
||
transferred.
|
||
|
||
Return Value:
|
||
|
||
TRUE - If any blocked-requests were transfered to the Adapter Blocked Queue.
|
||
FALSE - Otherwise
|
||
|
||
--*/
|
||
{
|
||
PLIST_ENTRY entry;
|
||
PLOGICAL_UNIT_EXTENSION LogicalUnit,PrevLogicalUnit;
|
||
|
||
LogicalUnit = Adapter->BlockedLogicalUnit;
|
||
PrevLogicalUnit = Adapter->BlockedLogicalUnit;
|
||
|
||
while(LogicalUnit != (PLOGICAL_UNIT_EXTENSION)&Adapter->BlockedLogicalUnit){
|
||
|
||
entry = RemoveHeadList(&(LogicalUnit->SrbDataBlockedRequests));
|
||
InsertHeadList(&(Adapter->SrbDataBlockedRequests),entry);
|
||
if(IsListEmpty(&(LogicalUnit->SrbDataBlockedRequests))){
|
||
if(LogicalUnit == Adapter->BlockedLogicalUnit){
|
||
Adapter->BlockedLogicalUnit =
|
||
LogicalUnit->BlockedLogicalUnit;
|
||
LogicalUnit->BlockedLogicalUnit = NULL;
|
||
LogicalUnit=Adapter->BlockedLogicalUnit;
|
||
} else {
|
||
PrevLogicalUnit->BlockedLogicalUnit =
|
||
LogicalUnit->BlockedLogicalUnit;
|
||
LogicalUnit->BlockedLogicalUnit = NULL;
|
||
LogicalUnit=PrevLogicalUnit->BlockedLogicalUnit;
|
||
}
|
||
}else{
|
||
PrevLogicalUnit = LogicalUnit;
|
||
LogicalUnit = LogicalUnit->BlockedLogicalUnit;
|
||
}
|
||
|
||
}
|
||
return (!IsListEmpty(&(Adapter->SrbDataBlockedRequests)));
|
||
|
||
}
|