/*++ 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))); }