/*++ Copyright (C) 2000 Microsoft Corporation Module Name: dsm.c Abstract: This driver is the generic DSM for FC disks and exports behaviours that mpctl.sys will use to determine how to multipath these devices. Author: Environment: kernel mode only Notes: Revision History: --*/ #include #include #include #include "dsm.h" #include "gendsm.h" #include "wmi.h" #define USE_BINARY_MOF_QUERY // // MOF data can be reported by a device driver via a resource attached to // the device drivers image file or in response to a query on the binary // mof data guid. As the mpio pdo handles these requests partially for the DSM // it is easier to handle via a Query-response. // #ifdef ALLOC_DATA_PRAGMA #pragma data_seg("PAGED") #endif UCHAR DsmBinaryMofData[] = { #include "dsm.x" }; #ifdef ALLOC_DATA_PRAGMA #pragma data_seg() #endif // // Define symbolic names for the guid indexes // #define GENDSM_CONFIGINFOGuidIndex 0 #define BinaryMofGuidIndex 1 // // List of guids supported // GUID GENDSM_CONFIGINFOGUID = GENDSM_CONFIGINFOGuid; GUID DsmBinaryMofGUID = BINARY_MOF_GUID; WMIGUIDREGINFO DsmGuidList[] = { { &GENDSM_CONFIGINFOGUID, 1, 0 }, { &DsmBinaryMofGUID, 1, 0 } }; #define DsmGuidCount (sizeof(DsmGuidList) / sizeof(WMIGUIDREGINFO)) NTSTATUS DsmGetDeviceList( IN PDSM_CONTEXT Context ); NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath ) /*++ Routine Description: This routine is called when the driver loads loads. Arguments: DriverObject - Supplies the driver object. RegistryPath - Supplies the registry path. Return Value: NTSTATUS --*/ { DSM_INIT_DATA initData; WCHAR dosDeviceName[40]; UNICODE_STRING mpUnicodeName; PDEVICE_OBJECT deviceObject; PFILE_OBJECT fileObject; NTSTATUS status; PDSM_CONTEXT dsmContext; PDSM_MPIO_CONTEXT mpctlContext; PVOID buffer; // // Build the init data structure. // dsmContext = ExAllocatePool(NonPagedPool, sizeof(DSM_CONTEXT)); if (dsmContext == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory(dsmContext, sizeof(DSM_CONTEXT)); buffer = &initData; // // Set-up the init data // initData.DsmContext = (PVOID)dsmContext; initData.InitDataSize = sizeof(DSM_INIT_DATA); initData.DsmInquireDriver = DsmInquire; initData.DsmCompareDevices = DsmCompareDevices; initData.DsmSetDeviceInfo = DsmSetDeviceInfo; initData.DsmGetControllerInfo = DsmGetControllerInfo; initData.DsmIsPathActive = DsmIsPathActive; initData.DsmPathVerify = DsmPathVerify; initData.DsmInvalidatePath = DsmInvalidatePath; initData.DsmMoveDevice = DsmMoveDevice; initData.DsmRemovePending = DsmRemovePending; initData.DsmRemoveDevice = DsmRemoveDevice; initData.DsmRemovePath = DsmRemovePath; initData.DsmReenablePath = DsmBringPathOnLine; initData.DsmCategorizeRequest = DsmCategorizeRequest; initData.DsmBroadcastSrb = DsmBroadcastRequest; initData.DsmSrbDeviceControl = DsmSrbDeviceControl; initData.DsmSetCompletion = DsmSetCompletion; initData.DsmLBGetPath = DsmLBGetPath; initData.DsmInterpretError = DsmInterpretError; initData.DsmUnload = DsmUnload; // // Set-up the WMI Info. // DsmWmiInitialize(&initData.DsmWmiInfo); // // Set the DriverObject. Used by MPIO for Unloading. // initData.DriverObject = DriverObject; RtlInitUnicodeString(&initData.DisplayName, L"Generic Device-Specific Module"); // // Initialize the context objects. // KeInitializeSpinLock(&dsmContext->SpinLock); InitializeListHead(&dsmContext->GroupList); InitializeListHead(&dsmContext->DeviceList); InitializeListHead(&dsmContext->FailGroupList); ExInitializeNPagedLookasideList(&dsmContext->ContextList, NULL, NULL, 0, sizeof(COMPLETION_CONTEXT), 'MSDG', 0); // // Build the mpctl name. // swprintf(dosDeviceName, L"\\DosDevices\\MPathControl"); RtlInitUnicodeString(&mpUnicodeName, dosDeviceName); // // Get mpctl's deviceObject. // status = IoGetDeviceObjectPointer(&mpUnicodeName, FILE_READ_ATTRIBUTES, &fileObject, &deviceObject); if (NT_SUCCESS(status)) { KEVENT event; PIRP irp; IO_STATUS_BLOCK ioStatus; // // Send the IOCTL to mpctl.sys to register ourselves. // DsmSendDeviceIoControlSynchronous(IOCTL_MPDSM_REGISTER, deviceObject, &initData, &initData, sizeof(DSM_INIT_DATA), sizeof(DSM_MPIO_CONTEXT), TRUE, &ioStatus); status = ioStatus.Status; ObDereferenceObject(fileObject); } if (status == STATUS_SUCCESS) { // // Grab the context value passed back by mpctl. // mpctlContext = buffer; dsmContext->MPIOContext = mpctlContext->MPIOContext; // // Query the registry to find out what devices are being supported // on this machine. // DsmGetDeviceList(dsmContext); } else { // // Need to LOG this. // } return status; } PUCHAR DsmGetSerialNumber( IN PDEVICE_OBJECT DeviceObject ) { IO_STATUS_BLOCK ioStatus; PSCSI_PASS_THROUGH passThrough; PVPD_SERIAL_NUMBER_PAGE serialPage; ULONG length; PCDB cdb; PUCHAR serialNumber; ULONG serialNumberOffset; // // Build an inquiry command with EVPD and pagecode of 0x80 (serial number). // length = sizeof(SCSI_PASS_THROUGH) + SENSE_BUFFER_SIZE + 0xFF; passThrough = ExAllocatePool(NonPagedPool, length); if (passThrough == NULL) { return NULL; } RtlZeroMemory(passThrough, length); // // build the cdb. // cdb = (PCDB)passThrough->Cdb; cdb->CDB6INQUIRY3.OperationCode = SCSIOP_INQUIRY; cdb->CDB6INQUIRY3.EnableVitalProductData = 1; cdb->CDB6INQUIRY3.PageCode = VPD_SERIAL_NUMBER; cdb->CDB6INQUIRY3.AllocationLength = 255; passThrough->Length = sizeof(SCSI_PASS_THROUGH); passThrough->CdbLength = 6; passThrough->SenseInfoLength = SENSE_BUFFER_SIZE; passThrough->DataIn = 1; passThrough->DataTransferLength = 0xFF; passThrough->TimeOutValue = 20; passThrough->SenseInfoOffset = sizeof(SCSI_PASS_THROUGH); passThrough->DataBufferOffset = sizeof(SCSI_PASS_THROUGH) + 18; DsmSendDeviceIoControlSynchronous(IOCTL_SCSI_PASS_THROUGH, DeviceObject, passThrough, passThrough, length, length, FALSE, &ioStatus); if ((passThrough->ScsiStatus) || (ioStatus.Status != STATUS_SUCCESS)) { DebugPrint((0, "DsmGetSerialNumber: Status (%x) ScsiStatus (%x)\n", ioStatus.Status, passThrough->ScsiStatus)); ExFreePool(passThrough); return NULL; } else { ULONG i; DebugPrint((0, "GetDeviceDescriptor: Got the serial number page\n")); // // Get the returned data. // (ULONG_PTR)serialPage = (ULONG_PTR)passThrough; (ULONG_PTR)serialPage += passThrough->DataBufferOffset; // // Allocate a buffer to hold just the serial number. // serialNumber = ExAllocatePool(NonPagedPool, serialPage->PageLength + 1); RtlZeroMemory(serialNumber, serialPage->PageLength + 1); // // Copy it over. // RtlCopyMemory(serialNumber, serialPage->SerialNumber, serialPage->PageLength); // // Convert 0x00 to spaces. // for (i = 0; i < serialPage->PageLength; i++) { if (serialNumber[i] == '\0') { serialNumber[i] = ' '; } } // // Free the passthrough + data buffer. // ExFreePool(passThrough); // // Return the sn. // return serialNumber; } } NTSTATUS DsmQueryCallBack( IN PWSTR ValueName, IN ULONG Type, IN PVOID Data, IN ULONG Length, IN PVOID Context, IN PVOID EntryContext ) { PVOID *value = EntryContext; if (Type == REG_MULTI_SZ) { *value = ExAllocatePool(PagedPool, Length); if (*value) { RtlMoveMemory(*value, Data, Length); return STATUS_SUCCESS; } } return STATUS_UNSUCCESSFUL; } NTSTATUS DsmGetDeviceList( IN PDSM_CONTEXT Context ) { RTL_QUERY_REGISTRY_TABLE queryTable[2]; WCHAR registryKeyName[56]; UNICODE_STRING inquiryStrings; WCHAR defaultIDs[] = { L"\0" }; NTSTATUS status; RtlZeroMemory(registryKeyName, 56); RtlZeroMemory(&queryTable, sizeof(queryTable)); RtlInitUnicodeString(&inquiryStrings, NULL); swprintf(registryKeyName, L"gendsm\\parameters"); // // The query table has two entries. One for the supporteddeviceList and // the second which is the 'NULL' terminator. // queryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_NOEXPAND; queryTable[0].Name = L"SupportedDeviceList"; queryTable[0].EntryContext = &Context->SupportedDevices; queryTable[0].DefaultType = REG_MULTI_SZ; queryTable[0].DefaultData = defaultIDs; queryTable[0].DefaultLength = sizeof(defaultIDs); status = RtlQueryRegistryValues(RTL_REGISTRY_SERVICES, registryKeyName, queryTable, NULL, NULL); return status; } BOOLEAN DsmFindSupportedDevice( IN PUNICODE_STRING DeviceName, IN PUNICODE_STRING SupportedDevices ) { PWSTR devices = SupportedDevices->Buffer; UNICODE_STRING unicodeString; LONG compare; while (devices[0]) { // // Make the current entry into a unicode string. // RtlInitUnicodeString(&unicodeString, devices); // // Compare this one with the current device. // compare = RtlCompareUnicodeString(&unicodeString, DeviceName, TRUE); if (compare == 0) { return TRUE; } // // Advance to next entry in the MULTI_SZ. // devices += (unicodeString.MaximumLength / sizeof(WCHAR)); } return FALSE; } BOOLEAN DsmDeviceSupported( IN PDSM_CONTEXT Context, IN PUCHAR VendorId, IN PUCHAR ProductId ) { UNICODE_STRING deviceName; UNICODE_STRING productName; ANSI_STRING ansiVendor; ANSI_STRING ansiProduct; NTSTATUS status; BOOLEAN supported = FALSE; if (Context->SupportedDevices.MaximumLength == 0) { return FALSE; } // // Convert the inquiry fields into ansi strings. // RtlInitAnsiString(&ansiVendor, VendorId); RtlInitAnsiString(&ansiProduct, ProductId); // // Allocate the deviceName buffer. Needs to be 8+16 plus NULL. // (productId length + vendorId length + NULL). // deviceName.MaximumLength = 25 * sizeof(WCHAR); deviceName.Buffer = ExAllocatePool(PagedPool, deviceName.MaximumLength); // // Convert the vendorId to unicode. // RtlAnsiStringToUnicodeString(&deviceName, &ansiVendor, FALSE); // // Convert the productId to unicode. // RtlAnsiStringToUnicodeString(&productName, &ansiProduct, TRUE); // // 'cat' them. // status = RtlAppendUnicodeStringToString(&deviceName, &productName); if (status == STATUS_SUCCESS) { // // Run the list of supported devices that was captured from the registry // and see if this one is in the list. // supported = DsmFindSupportedDevice(&deviceName, &Context->SupportedDevices); } return supported; } NTSTATUS DsmInquire ( IN PVOID DsmContext, IN PDEVICE_OBJECT TargetDevice, IN PDEVICE_OBJECT PortObject, IN PSTORAGE_DEVICE_DESCRIPTOR Descriptor, IN PSTORAGE_DEVICE_ID_DESCRIPTOR DeviceIdList, OUT PVOID *DsmIdentifier ) { PDSM_CONTEXT dsmContext = DsmContext; PDEVICE_INFO deviceInfo; PGROUP_ENTRY group; NTSTATUS status; ULONG deviceState; ULONG allocationLength; PDSM_IDS controllerObjects; PUCHAR vendorId = "SEAGATE "; PUCHAR productId = "ST39102FC"; PUCHAR vendorIndex; PUCHAR productIndex; PUCHAR serialNumber; BOOLEAN supported; vendorIndex = (PUCHAR)Descriptor; productIndex = (PUCHAR)Descriptor; (ULONG_PTR)vendorIndex += Descriptor->VendorIdOffset; (ULONG_PTR)productIndex += Descriptor->ProductIdOffset; supported = DsmDeviceSupported((PDSM_CONTEXT)DsmContext, vendorIndex, productIndex); if (supported == FALSE) { return STATUS_NOT_SUPPORTED; } #if 0 // // Determine if the device is supported. // if ((!RtlEqualMemory(vendorId, vendorIndex, 8)) || (!RtlEqualMemory(productId, productIndex, 9))) { return STATUS_NOT_SUPPORTED; } #endif // // Ensure that the device's serial number is present. If not, can't claim // support for this drive. // if ((Descriptor->SerialNumberOffset == (ULONG)-1) || (Descriptor->SerialNumberOffset == 0)) { PUCHAR index; // // The port driver currently doesn't get the VPD page 0x80, if the // device doesn't support GET_SUPPORTED_PAGES. Check to see whether // there actually is a serial number. // serialNumber = DsmGetSerialNumber(TargetDevice); if (serialNumber == NULL) { return STATUS_NOT_SUPPORTED; } DebugPrint((0,"SerialNumber: ")); index = serialNumber; while (*index) { DebugPrint((0,"%02x", *index)); index++; } DebugPrint((0,"\n")); } else { // // Get a pointer to the embedded serial number info. // serialNumber = (PUCHAR)Descriptor; (ULONG_PTR)serialNumber += Descriptor->SerialNumberOffset; } // // Allocate the descriptor. This is also used as DsmId. // allocationLength = sizeof(DEVICE_INFO); allocationLength += Descriptor->Size - sizeof(STORAGE_DEVICE_DESCRIPTOR); deviceInfo = ExAllocatePool(NonPagedPool, allocationLength); if (deviceInfo == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory(deviceInfo, allocationLength); // // Copy over the StorageDescriptor. // RtlCopyMemory(&deviceInfo->Descriptor, Descriptor, Descriptor->Size); // // As an example - if the storage enclosure contains controller-type devices (or others) // they can be found via this routine. // controllerObjects = DsmGetAssociatedDevice(dsmContext->MPIOContext, PortObject, 0x0C); if (controllerObjects) { // // Currently not used by this driver, so just free the memory. // ExFreePool(controllerObjects); } // // Set the serial number. // deviceInfo->SerialNumber = serialNumber; // // Save the PortPdo Object. // deviceInfo->PortPdo = TargetDevice; // // Set the signature. // deviceInfo->DeviceSig = DSM_DEVICE_SIG; // // See if there is an existing Muli-path group to which this belongs. // (same serial number). // group = DsmFindDevice(DsmContext, deviceInfo); if (group == NULL) { // // Build a multi-path group entry. // group = DsmBuildGroupEntry(DsmContext, deviceInfo); if (group == NULL) { ExFreePool(deviceInfo); return STATUS_INSUFFICIENT_RESOURCES; } // // This is the first in the group, so make it the active // device. The actual active/passive devices will be set-up // later when the first call to LBGetPath is made. // deviceState = DEV_ACTIVE; } else { // // Already something active, this will be the fail-over // device until the load-balance groups are set-up. // deviceState = DEV_PASSIVE; } // // Add it to the list. // status = DsmAddDeviceEntry(DsmContext, group, deviceInfo, deviceState); *DsmIdentifier = deviceInfo; return status; } BOOLEAN DsmCompareDevices( IN PVOID DsmContext, IN PVOID DsmId1, IN PVOID DsmId2 ) { PDEVICE_INFO deviceInfo = DsmId1; PDEVICE_INFO comparedDevice = DsmId2; ULONG length; PUCHAR serialNumber; PUCHAR comparedSerialNumber; // // Get the two serial numbers. // They were either embedded in the STORAGE_DEVICE_DESCRIPTOR or built // by directly issuing the VPD request. // serialNumber = deviceInfo->SerialNumber; comparedSerialNumber = comparedDevice->SerialNumber; // // Get the length of the base-device Serial Number. // length = strlen(serialNumber); // // If the lengths match, compare the contents. // if (length == strlen(comparedSerialNumber)) { if (RtlEqualMemory(serialNumber, comparedSerialNumber, length)) { return TRUE; } } return FALSE; } VOID DsmSetupAlternatePath( IN PDSM_CONTEXT DsmContext, IN PGROUP_ENTRY Group ) { PFAILOVER_GROUP currentGroup; PFAILOVER_GROUP failGroup; PDEVICE_INFO deviceInfo; PDEVICE_INFO currentDevInfo; ULONG i; ULONG j; BOOLEAN pathSet = FALSE; // // Check for single-pathed groups. // if (Group->NumberDevices > 2) { return; } for (i = 0; i < Group->NumberDevices; i++) { // // Get the device. // deviceInfo = Group->DeviceList[i]; // // Get it's FOG. // currentGroup = deviceInfo->FailGroup; if (currentGroup == NULL) { // // This deviceInfo isn't fully intitialised yet. // continue; } // // Run through all the devices again. // for (j = 0; j < Group->NumberDevices; j++) { currentDevInfo = Group->DeviceList[j]; if (currentDevInfo == deviceInfo) { // // Find one that's a different path. // continue; } failGroup = currentDevInfo->FailGroup; if (failGroup) { if (failGroup->PathId) { DebugPrint((0, "SetAlternatePath: FOG (%x) using (%x) as Alt\n", currentGroup, failGroup)); currentGroup->AlternatePath = failGroup->PathId; pathSet = TRUE; } } } if (pathSet == FALSE) { DebugPrint((0, "SetAlternatePath: No alternate set for (%x)\n", currentGroup)); } else { pathSet = FALSE; } } } NTSTATUS DsmSetDeviceInfo( IN PVOID DsmContext, IN PDEVICE_OBJECT TargetObject, IN PVOID DsmId, IN OUT PVOID *PathId ) { PDEVICE_INFO deviceInfo = DsmId; PGROUP_ENTRY group = deviceInfo->Group; PFAILOVER_GROUP failGroup; NTSTATUS status; // // TargetObject is the destination for any requests created by this driver. // Save this for future reference. // deviceInfo->TargetObject = TargetObject; // // PathId indicates the path on which this device resides. Meaning // that when a Fail-Over occurs all device's on the same path fail together. // Search for a matching F.O. Group // failGroup = DsmFindFOGroup(DsmContext, *PathId); // // if not found, create a new f.o. group // if (failGroup == NULL) { failGroup = DsmBuildFOGroup(DsmContext, DsmId, *PathId); if (failGroup == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } } // // add this deviceInfo to the f.o. group. // status = DsmUpdateFOGroup(DsmContext, failGroup, deviceInfo); DsmSetupAlternatePath(DsmContext, group); return status; } NTSTATUS DsmGetControllerInfo( IN PVOID DsmContext, IN PVOID DsmId, IN ULONG Flags, IN OUT PCONTROLLER_INFO *ControllerInfo ) { PDSM_CONTEXT dsmContext = DsmContext; PCONTROLLER_INFO controllerInfo; LARGE_INTEGER time; if (!dsmContext->ControllerId) { // // Make one up. // KeQuerySystemTime(&time); // // Use only the bottom 32-bits. // dsmContext->ControllerId = time.LowPart; } if (Flags & DSM_CNTRL_FLAGS_ALLOCATE) { controllerInfo = ExAllocatePool(NonPagedPool, sizeof(CONTROLLER_INFO)); if (controllerInfo == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory(controllerInfo, sizeof(CONTROLLER_INFO)); // // Indicate that there are no specific controllers. // controllerInfo->State = DSM_CONTROLLER_NO_CNTRL; // // Set the identifier to the value generated earlier. // controllerInfo->ControllerIdentifier = (ULONGLONG)dsmContext->ControllerId; *ControllerInfo = controllerInfo; } else { controllerInfo = *ControllerInfo; // // If the enclosures supported by this DSM actually had controllers, there would // be a list of them and a search based on ControllerIdentifier would be made. // controllerInfo->State = DSM_CONTROLLER_NO_CNTRL; } return STATUS_SUCCESS; } BOOLEAN DsmIsPathActive( IN PVOID DsmContext, IN PVOID PathId ) { PFAILOVER_GROUP group; // // NOTE: Internal callers of this assume certain behaviours. If it's changed, // those functions need to be updated appropriately. // // // Get the F.O. Group information. // group = DsmFindFOGroup(DsmContext, PathId); // // If there are any devices on this path, and // it's not in a failed state: it's capable of handling requests // so it's active. // if ((group->Count >= 1) && (group->State == FG_NORMAL)) { return TRUE; } return FALSE; } NTSTATUS DsmPathVerify( IN PVOID DsmContext, IN PVOID DsmId, IN PVOID PathId ) { PDEVICE_INFO deviceInfo = DsmId; PFAILOVER_GROUP group; NTSTATUS status; ULONG i; // // Get the F.O. group // group = DsmFindFOGroup(DsmContext, PathId); if (group == NULL) { DbgBreakPoint(); return STATUS_DEVICE_NOT_CONNECTED; } // // Check the Path state to ensure all is normal. // Should be in FAILBACK state. This indicates that either // an admin utility told us we are O.K. or the AutoRecovery detected // the error was transitory. // BUGBUG: Need to implement both of the above assumptions. // if ((group->Count >= 1) && group->State == FG_FAILBACK) { // // Ensure that the device is still there // for (i = 0; i < group->Count; i++) { if (group->DeviceList[i] == deviceInfo) { // // Send it a TUR. // status = DsmSendTUR(deviceInfo->TargetObject); } } } else { status = STATUS_UNSUCCESSFUL; // // Find the device. // for (i = 0; i < group->Count; i++) { if (group->DeviceList[i] == deviceInfo) { // // Issue a TUR to see if it's OK. // status = DsmSendTUR(deviceInfo->TargetObject); } } #if DBG if (status == STATUS_SUCCESS) { DebugPrint((2, "DsmPathVerify: Successful TUR to (%x)\n", deviceInfo)); } else { // // Either the device is not in the group, or the TUR was not successful. // if (i == group->Count) { DebugPrint((0, "PathVerify: (%x) not in group (%x)\n", deviceInfo, group)); } else { DebugPrint((0, "PathVerify: TUR to (%x) failed. (%x)\n", deviceInfo, status)); } } #endif } // // Update the group State, depending upon the outcome. // TODO // if (status == STATUS_SUCCESS) { // // This lets the LBInit run to properly set-up this device. // deviceInfo->NeedsVerification = FALSE; } return status; } NTSTATUS DsmInvalidatePath( IN PVOID DsmContext, IN ULONG ErrorMask, IN PVOID PathId, IN OUT PVOID *NewPathId ) { PFAILOVER_GROUP failGroup; PFAILOVER_GROUP hintPath; PGROUP_ENTRY group; PDEVICE_INFO deviceInfo; NTSTATUS status; ULONG i; ASSERT(ErrorMask & DSM_FATAL_ERROR); // // Get the fail-over group corresponding to the PathId. // failGroup = DsmFindFOGroup(DsmContext, PathId); // // Mark the path as failed. // failGroup->State = FG_FAILED; DebugPrint((0, "DsmInvalidatePath: Path (%x) FOG (%x) failing\n", PathId, failGroup)); // // First interation, the hint will be NULL. This allows the // GetNewPath routine the opportunity to select the best new path // Subsequent calls will be fed the updated value. // hintPath = NULL; if (failGroup->Count == 0) { // // This indicates that all of the devices have already // been removed. Just return the alternate path. // *NewPathId = failGroup->AlternatePath; return STATUS_SUCCESS; } // // Process each device in the fail-over group // for (i = 0; i < failGroup->Count; i++) { // // Get the deviceInfo. // deviceInfo = failGroup->DeviceList[i]; // // Set the state of the Failing Devicea // deviceInfo->State = DEV_FAILED; // // Get it's Multi-Path Group entry. // group = deviceInfo->Group; // // Get a new path for this failed device. // hintPath = DsmSetNewPath(DsmContext, group, deviceInfo, hintPath); } if (hintPath == NULL) { // // This indicates that no acceptable paths // were found. Return the error to mpctl. // status = STATUS_NO_SUCH_DEVICE; *NewPathId = NULL; } else { // // return the new path. // *NewPathId = hintPath->PathId; DebugPrint((0, "DsmInvalidatePath: Returning (%x) as newPath\n", hintPath->PathId)); status = STATUS_SUCCESS; } return status; } NTSTATUS DsmMoveDevice( IN PVOID DsmContext, IN PDSM_IDS DsmIds, IN PVOID MPIOPath, IN PVOID SuggestedPath, IN ULONG Flags ) { return STATUS_SUCCESS; } NTSTATUS DsmRemovePending( IN PVOID DsmContext, IN PVOID DsmId ) { PDSM_CONTEXT dsmContext = DsmContext; PDEVICE_INFO deviceInfo = DsmId; KIRQL irql; DebugPrint((0, "RemovePending: Marking %x as PENDING_REMOVED\n", deviceInfo)); KeAcquireSpinLock(&dsmContext->SpinLock, &irql); // // Mark the device as being unavailable, as a remove will be // coming shortly. // deviceInfo->State = DEV_PENDING_REMOVE; KeReleaseSpinLock(&dsmContext->SpinLock, irql); return STATUS_SUCCESS; } NTSTATUS DsmRemoveDevice( IN PVOID DsmContext, IN PVOID DsmId, IN PVOID PathId ) { PDSM_CONTEXT dsmContext = DsmContext; PDEVICE_INFO deviceInfo; PFAILOVER_GROUP failGroup; PGROUP_ENTRY group; ULONG state; WCHAR buffer[64]; DebugPrint((0, "DsmRemoveDevice: Removing %x\n", DsmId)); // // DsmId is our deviceInfo structure. // deviceInfo = DsmId; // // Get it's Multi-Path Group entry. // group = deviceInfo->Group; // // Get the Fail-over group. // failGroup = deviceInfo->FailGroup; // // If it's active, need to 'Fail-Over' to another device in // the group. // state = deviceInfo->State; // // Set the state of the Failing Devicea // deviceInfo->State = DEV_FAILED; if (state == DEV_ACTIVE) { // // Find the next available device. // This is basically a fail-over for just // this device. // DsmSetNewPath(DsmContext, group, deviceInfo, NULL); } // // Remove it's entry from the Fail-Over Group. // DsmRemoveDeviceFailGroup(DsmContext, failGroup, deviceInfo); // // Remove it from it's multi-path group. This has the side-effect // of cleaning up the Group if the number of devices goes to zero. // DsmRemoveDeviceEntry(DsmContext, group, deviceInfo); swprintf(buffer, L"Removing Device (%ws)", L"It's Name"); DsmWriteEvent(dsmContext->MPIOContext, L"GenDsm", buffer, 2); return STATUS_SUCCESS; } NTSTATUS DsmRemovePath( IN PDSM_CONTEXT DsmContext, IN PVOID PathId ) { PFAILOVER_GROUP failGroup; KIRQL irql; failGroup = DsmFindFOGroup(DsmContext, PathId); if (failGroup == NULL) { // // It's already been removed. // LOG though. // return STATUS_SUCCESS; } // // The claim is that a path won't be removed, until all // the devices on it are. // ASSERT(failGroup->Count == 0); KeAcquireSpinLock(&DsmContext->SpinLock, &irql); // // Need to find any other FOG's using this as their alternate path and // update them to use something else (if available). // BUGBUG: that it's not done. // // // Yank it from the list. // RemoveEntryList(&failGroup->ListEntry); DsmContext->NumberFOGroups--; // // Zero the entry. // RtlZeroMemory(failGroup, sizeof(FAILOVER_GROUP)); KeReleaseSpinLock(&DsmContext->SpinLock, irql); // // Free the allocation. // ExFreePool(failGroup); return STATUS_SUCCESS; } NTSTATUS DsmBringPathOnLine( IN PVOID DsmContext, IN PVOID PathId, OUT PULONG DSMError ) { PFAILOVER_GROUP failGroup; // // PathVerify has been called already, so if // it came back successfully, then this is O.K. // failGroup = DsmFindFOGroup(DsmContext, PathId); if (failGroup == NULL) { // // LOG // *DSMError = 0; return STATUS_DEVICE_NOT_CONNECTED; } // // Should be in FG_PENDING // ASSERT(failGroup->State == FG_PENDING); // // Indicate that it's ready to go. // failGroup->State = FG_NORMAL; return STATUS_SUCCESS; } PVOID DsmLBGetPath( IN PVOID DsmContext, IN PSCSI_REQUEST_BLOCK Srb, IN PDSM_IDS DsmList, IN PVOID CurrentPath, OUT NTSTATUS *Status ) { PDSM_CONTEXT dsmContext = DsmContext; PDEVICE_INFO deviceInfo; PGROUP_ENTRY group; PFAILOVER_GROUP failGroup = NULL; ULONG i; KIRQL irql; KeAcquireSpinLock(&dsmContext->SpinLock, &irql); // // Up-front checking to minimally validate // the list of DsmId's being passed in. // ASSERT(DsmList->Count); ASSERT(DsmList->IdList[0]); // // Grab the first device from the list. // deviceInfo = DsmList->IdList[0]; ASSERT(deviceInfo->DeviceSig == DSM_DEVICE_SIG); // // Get the multi-path group. // group = deviceInfo->Group; // // See if Load-Balancing has been initialized. // if (group->LoadBalanceInit == FALSE) { PDEVICE_INFO lbDevice; BOOLEAN doInit = TRUE; // // Check to see whether we are really ready to run // the LBInit. If any of the list aren't verified, then // we will hold off. // for (i = 0; i < DsmList->Count; i++) { lbDevice = DsmList->IdList[i]; // // Check to see whether pathVerify has been invoked // on this device. Due to how PnP builds the device stacks // there is a period of time between the PDO showing up, and // when the FDO (mpdev.sys) gets loaded and registers. // if (lbDevice->NeedsVerification) { DebugPrint((0, "LBGetPath: (%x) needs verify\n", lbDevice)); doInit = FALSE; break; } } if (doInit) { // // Set-up the load-balancing. This routine // builds a static assignment of multi-path group to // a particular path. // DsmLBInit(DsmContext, group); } } #if DBG // // Ensure that mpctl and this dsm are in sync. // if (DsmList->Count != group->NumberDevices) { BOOLEAN doAssert = TRUE; for (i = 0; i NumberDevices; i++) { deviceInfo = group->DeviceList[i]; if ((deviceInfo->State == DEV_PENDING_REMOVE) || (deviceInfo->State == DEV_FAILED)) { // // The reason the lists are off is that this one // has been marked for removal. mpio has already // adjusted it's structures to show it not being used. // doAssert = FALSE; } } if (doAssert) { ASSERT(DsmList->Count == group->NumberDevices); } } #endif // // Find the active device. // //for (i = 0; i < group->NumberDevices; i++) { for (i = 0; i < DsmList->Count; i++) { // // Get each of the DsmId's, in reality the deviceInfo. // deviceInfo = DsmList->IdList[i]; ASSERT(deviceInfo->DeviceSig == DSM_DEVICE_SIG); // // Ensure that the device is in our list. // ASSERT(DsmFindDevice(DsmContext, deviceInfo)); // // NOTE: This assumes 'static' Load-Balancing. Once others // are implemented, this section will have to be updated. // // Return the path on which the ACTIVE device resides. // if (deviceInfo->State == DEV_ACTIVE) { // // Get the F.O.Group, as it contains the // correct PathId for this device. // failGroup = deviceInfo->FailGroup; *Status = STATUS_SUCCESS; KeReleaseSpinLock(&dsmContext->SpinLock, irql); return failGroup->PathId; } } KeReleaseSpinLock(&dsmContext->SpinLock, irql); // // Should never have gotten here. // DebugPrint((0, "LBGetPath: Returning STATUS_DEVICE_NOT_CONNECTED\n")); DbgBreakPoint(); ASSERT(failGroup); *Status = STATUS_DEVICE_NOT_CONNECTED; return NULL; } ULONG DsmCategorizeRequest( IN PVOID DsmContext, IN PDSM_IDS DsmIds, IN PIRP Irp, IN PSCSI_REQUEST_BLOCK Srb, IN PVOID CurrentPath, OUT PVOID *PathId, OUT NTSTATUS *Status ) { ULONG dsmStatus; NTSTATUS status; // // Requests to broadcast // Reset // Reserve // Release // // Requests to Handle // None for now. // // // For all other requests, punt it back to the bus-driver. // Need to get a path for the request first, so call the Load-Balance // function. // *PathId = DsmLBGetPath(DsmContext, Srb, DsmIds, CurrentPath, &status); if (NT_SUCCESS(status)) { // // Indicate that the path is updated, and mpctl should handle the request. // dsmStatus = DSM_PATH_SET; } else { // // Indicate the error back to mpctl. // dsmStatus = DSM_ERROR; // // Mark-up the Srb to show that a failure has occurred. // This value is really only for this DSM to know what to do // in the InterpretError routine - Fatal Error. // It could be something more meaningful. // Srb->SrbStatus = SRB_STATUS_NO_DEVICE; } // // Pass back status info to mpctl. // *Status = status; return dsmStatus; } NTSTATUS DsmBroadcastRequest( IN PVOID DsmContext, IN PDSM_IDS DsmIds, IN PIRP Irp, IN PSCSI_REQUEST_BLOCK Srb, IN PKEVENT Event ) { PDSM_CONTEXT dsmContext = DsmContext; KIRQL irql; KeAcquireSpinLock(&dsmContext->SpinLock, &irql); // // BUGBUG: Need to handle Reset, Reserve, and Release. // KeReleaseSpinLock(&dsmContext->SpinLock, irql); return STATUS_INVALID_DEVICE_REQUEST; } NTSTATUS DsmSrbDeviceControl( IN PVOID DsmContext, IN PDSM_IDS DsmIds, IN PIRP Irp, IN PSCSI_REQUEST_BLOCK Srb, IN PKEVENT Event ) { PDSM_CONTEXT dsmContext = DsmContext; KIRQL irql; KeAcquireSpinLock(&dsmContext->SpinLock, &irql); // // BUGBUG: Need to handle ?? // KeReleaseSpinLock(&dsmContext->SpinLock, irql); return STATUS_INVALID_DEVICE_REQUEST; } VOID DsmXCompletion( IN PVOID DsmId, IN PIRP Irp, IN PSCSI_REQUEST_BLOCK Srb, IN PVOID DsmContext ) { PCOMPLETION_CONTEXT completionContext = DsmContext; PDEVICE_INFO deviceInfo; PDSM_CONTEXT dsmContext; UCHAR opCode; // // If it's read or write, save stats. // Categorize set-up the Context to have path, target info. // TODO // ASSERT(DsmContext); dsmContext = completionContext->DsmContext; deviceInfo = completionContext->DeviceInfo; opCode = Srb->Cdb[0]; // // Indicate one less request on this device. // InterlockedDecrement(&deviceInfo->Requests); // // TODO: Use the timestamp. // Path/Device up-time, ave. time/request... // // // If it's a read or a write, update the stats. // if (opCode == SCSIOP_READ) { deviceInfo->Stats.NumberReads++; deviceInfo->Stats.BytesRead.QuadPart += Srb->DataTransferLength; } else if (opCode == SCSIOP_WRITE) { deviceInfo->Stats.NumberWrites++; deviceInfo->Stats.BytesWritten.QuadPart += Srb->DataTransferLength; } // // Release the allocation. // ExFreeToNPagedLookasideList(&dsmContext->ContextList, DsmContext); } VOID DsmSetCompletion( IN PVOID DsmContext, IN PVOID DsmId, IN PIRP Irp, IN PSCSI_REQUEST_BLOCK Srb, IN OUT PDSM_COMPLETION_INFO DsmCompletion ) { PCOMPLETION_CONTEXT completionContext; PDSM_CONTEXT dsmContext = DsmContext; PDEVICE_INFO deviceInfo = DsmId; // // Save the DeviceInfo as being the target for this request. // Get a timestamp // TODO Determine other data. // completionContext = ExAllocateFromNPagedLookasideList(&dsmContext->ContextList); if (completionContext == NULL) { // // LOG // } // // Time stamp this. // KeQueryTickCount(&completionContext->TickCount); // // Indicate the target for this request. // completionContext->DeviceInfo = deviceInfo; completionContext->DsmContext = DsmContext; // // Indicate one more request on this device. // LB may use this. // InterlockedIncrement(&deviceInfo->Requests); DsmCompletion->DsmCompletionRoutine = DsmXCompletion; DsmCompletion->DsmContext = completionContext; return; } ULONG DsmInterpretError( IN PVOID DsmContext, IN PVOID DsmId, IN PSCSI_REQUEST_BLOCK Srb, IN OUT NTSTATUS *Status, OUT PBOOLEAN Retry ) { ULONG errorMask = 0; PSENSE_DATA senseData = Srb->SenseInfoBuffer; BOOLEAN failover = FALSE; BOOLEAN retry = FALSE; BOOLEAN handled = FALSE; // // Check the NT Status first. // Several are clearly failover conditions. // switch (*Status) { case STATUS_DEVICE_NOT_CONNECTED: case STATUS_DEVICE_DOES_NOT_EXIST: case STATUS_NO_SUCH_DEVICE: // // The port pdo has either been removed or is // very broken. A fail-over is necessary. // handled = TRUE; failover = TRUE; break; case STATUS_IO_DEVICE_ERROR: // // See if it's a unit attention. // if (Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID) { if (senseData->SenseKey == SCSI_SENSE_UNIT_ATTENTION) { retry = TRUE; handled = TRUE; } } break; default: break; } if (handled == FALSE) { if (Srb) { // // The ntstatus didn't indicate a fail-over condition, but // check various srb status for failover-class error. // switch (Srb->SrbStatus) { case SRB_STATUS_SELECTION_TIMEOUT: case SRB_STATUS_INVALID_LUN: case SRB_STATUS_INVALID_TARGET_ID: case SRB_STATUS_NO_DEVICE: case SRB_STATUS_NO_HBA: case SRB_STATUS_INVALID_PATH_ID: // // All of these are fatal. // failover = TRUE; break; default: break; } } } if (failover) { DebugPrint((0, "InterpretError: Marking Fatal. Srb (%x). *Status (%x)\n", Srb, *Status)); errorMask = DSM_FATAL_ERROR; } // // TODO: Gather a list of status that indicate a retry is necessary. // Look at InterpretSenseInfo. // *Retry = retry; return errorMask; } NTSTATUS DsmUnload( IN PVOID DsmContext ) { // // It's the responsibility of the mpio bus driver to have already // destroyed all devices and paths. // As those functions free allocations for the objects, the only thing // needed here is to free the DsmContext. // ExFreePool(DsmContext); return STATUS_SUCCESS; } // // Utility functions. // PGROUP_ENTRY DsmFindDevice( IN PDSM_CONTEXT DsmContext, IN PDEVICE_INFO DeviceInfo ) { PDEVICE_INFO deviceInfo; PLIST_ENTRY entry; ULONG i; // // Run through the DeviceInfo List // entry = DsmContext->DeviceList.Flink; for (i = 0; i < DsmContext->NumberDevices; i++, entry = entry->Flink) { // // Extract the deviceInfo structure. // deviceInfo = CONTAINING_RECORD(entry, DEVICE_INFO, ListEntry); ASSERT(deviceInfo); // // Call the Serial Number compare routine. // if (DsmCompareDevices(DsmContext, DeviceInfo, deviceInfo)) { return deviceInfo->Group; } } DebugPrint((0, "DsmFindDevice: DsmContext (%x), DeviceInfo (%x)\n", DsmContext, DeviceInfo)); return NULL; } PGROUP_ENTRY DsmBuildGroupEntry( IN PDSM_CONTEXT DsmContext, IN PDEVICE_INFO DeviceInfo ) { PGROUP_ENTRY group; // // Allocate the memory for the multi-path group. // group = ExAllocatePool(NonPagedPool, sizeof(GROUP_ENTRY)); if (group == NULL) { return NULL; } RtlZeroMemory(group, sizeof(GROUP_ENTRY)); // // Add it to the list of multi-path groups. // ExInterlockedInsertTailList(&DsmContext->GroupList, &group->ListEntry, &DsmContext->SpinLock); group->GroupNumber = InterlockedIncrement(&DsmContext->NumberGroups); group->GroupSig = DSM_GROUP_SIG; ASSERT(group->GroupNumber >= 1); return group; } NTSTATUS DsmAddDeviceEntry( IN PDSM_CONTEXT DsmContext, IN PGROUP_ENTRY Group, IN PDEVICE_INFO DeviceInfo, IN ULONG DeviceState ) { ULONG numberDevices; ULONG i; KIRQL irql; // // Ensure that this is a valid config - namely, it hasn't // exceeded the number of paths supported. // numberDevices = Group->NumberDevices; if (numberDevices >= MAX_PATHS) { return STATUS_UNSUCCESSFUL; } KeAcquireSpinLock(&DsmContext->SpinLock, &irql); #if DBG // // Ensure that this isn't a second copy of the same pdo. // for (i = 0; i < numberDevices; i++) { if (Group->DeviceList[i]->PortPdo == DeviceInfo->PortPdo) { DebugPrint((0, "DsmAddDeviceEntry: Received same PDO twice\n")); DbgBreakPoint(); } } #endif // // Indicate one device is present in // this group. // Group->DeviceList[numberDevices] = DeviceInfo; // // Indicate one more in the list. // Group->NumberDevices++; // // Set-up this device's group id. // DeviceInfo->Group = Group; // // Set-up whether this is an active/passive member of the // group. // DeviceInfo->State = DeviceState; // // One more deviceInfo entry. // DsmContext->NumberDevices++; // // Finally, add it to the global list of devices. // InsertTailList(&DsmContext->DeviceList, &DeviceInfo->ListEntry); KeReleaseSpinLock(&DsmContext->SpinLock, irql); return STATUS_SUCCESS; } VOID DsmRemoveDeviceEntry( IN PDSM_CONTEXT DsmContext, IN PGROUP_ENTRY Group, IN PDEVICE_INFO DeviceInfo ) { KIRQL irql; NTSTATUS status; ULONG i; ULONG j; BOOLEAN freeGroup = FALSE; KeAcquireSpinLock(&DsmContext->SpinLock, &irql); // // Find it's offset in the array of devices. // for (i = 0; i < Group->NumberDevices; i++) { if (Group->DeviceList[i] == DeviceInfo) { // // Zero out it's entry. // Group->DeviceList[i] = NULL; // // Reduce the number in the group. // Group->NumberDevices--; // // Collapse the array. // // BUGBUG: If any requests come in during this time, it's // possible to either bugcheck or get an incorrect deviceInfo // structure. // for (j = i; j < Group->NumberDevices; j++) { // // Shuffle all entries down to fill the hole. // Group->DeviceList[j] = Group->DeviceList[j + 1]; } // // Zero out the last one. // Group->DeviceList[j] = NULL; break; } } // // See if anything is left in the Group. // if (Group->NumberDevices == 0) { // // Yank it from the Group list. // RemoveEntryList(&Group->ListEntry); DsmContext->NumberGroups--; // // Zero it. // RtlZeroMemory(Group, sizeof(GROUP_ENTRY)); freeGroup = TRUE; } // // Yank the device out of the Global list. // RemoveEntryList(&DeviceInfo->ListEntry); DsmContext->NumberDevices--; // // Zero it. // RtlZeroMemory(DeviceInfo, sizeof(DEVICE_INFO)); KeReleaseSpinLock(&DsmContext->SpinLock, irql); // // Free the allocation. // ExFreePool(DeviceInfo); if (freeGroup) { // // Free the allocation. // ExFreePool(Group); } } PFAILOVER_GROUP DsmFindFOGroup( IN PDSM_CONTEXT DsmContext, IN PVOID PathId ) { PFAILOVER_GROUP failOverGroup; PLIST_ENTRY entry; ULONG i; // // Run through the list of Fail-Over Groups // entry = DsmContext->FailGroupList.Flink; for (i = 0; i < DsmContext->NumberFOGroups; i++, entry = entry->Flink) { // // Extract the fail-over group structure. // failOverGroup = CONTAINING_RECORD(entry, FAILOVER_GROUP, ListEntry); ASSERT(failOverGroup); // // Check for a match of the PathId. // if (failOverGroup->PathId == PathId) { return failOverGroup; } } return NULL; } PFAILOVER_GROUP DsmBuildFOGroup( IN PDSM_CONTEXT DsmContext, IN PDEVICE_INFO DeviceInfo, IN PVOID PathId ) { PFAILOVER_GROUP failOverGroup; KIRQL irql; ULONG numberGroups; // // Allocate an entry. // failOverGroup = ExAllocatePool(NonPagedPool, sizeof(FAILOVER_GROUP)); if (failOverGroup == NULL) { return NULL; } RtlZeroMemory(failOverGroup, sizeof(FAILOVER_GROUP)); KeAcquireSpinLock(&DsmContext->SpinLock, &irql); // // Get the current number of groups, and add the one that's // being created. // numberGroups = DsmContext->NumberFOGroups++; // // Set the PathId - All devices on the same PathId will // failover together. // failOverGroup->PathId = PathId; // // Set the initial state to NORMAL. // failOverGroup->State = FG_NORMAL; failOverGroup->FailOverSig = DSM_FOG_SIG; // // Add it to the global list. // InsertTailList(&DsmContext->FailGroupList, &failOverGroup->ListEntry); KeReleaseSpinLock(&DsmContext->SpinLock, irql); return failOverGroup; } NTSTATUS DsmUpdateFOGroup( IN PDSM_CONTEXT DsmContext, IN PFAILOVER_GROUP FailGroup, IN PDEVICE_INFO DeviceInfo ) { PGROUP_ENTRY group; ULONG count; ULONG i; KIRQL irql; KeAcquireSpinLock(&DsmContext->SpinLock, &irql); // // Add the device to the list of devices that are on this path. // count = FailGroup->Count++; FailGroup->DeviceList[count] = DeviceInfo; // // Get the MultiPath group for this device. // group = DeviceInfo->Group; // // Indicate that the L.B. policy needs to be updated. // The next call to LBGetPath will cause the re-shuffle to // take place. // group->LoadBalanceInit = FALSE; // // Indicate the need to wait for PathVerify // This just eliminates the need to handle unit attentions // on this device when LoadBalancing is set-up. // DeviceInfo->NeedsVerification = TRUE; // // Set the device's F.O. Group. // DeviceInfo->FailGroup = FailGroup; KeReleaseSpinLock(&DsmContext->SpinLock, irql); return STATUS_SUCCESS; } VOID DsmRemoveDeviceFailGroup( IN PDSM_CONTEXT DsmContext, IN PFAILOVER_GROUP FailGroup, IN PDEVICE_INFO DeviceInfo ) { ULONG count; KIRQL irql; ULONG i; ULONG j; KeAcquireSpinLock(&DsmContext->SpinLock, &irql); // // Find it's offset in the array of devices. // for (i = 0; i < FailGroup->Count; i++) { if (FailGroup->DeviceList[i] == DeviceInfo) { // // Zero out it's entry. // FailGroup->DeviceList[i] = NULL; // // Reduce the number in the group. // FailGroup->Count--; // // Collapse the array. // for (j = i; j < FailGroup->Count; j++) { // // Shuffle all entries down to fill the hole. // FailGroup->DeviceList[j] = FailGroup->DeviceList[j + 1]; } // // Zero out the last one. // FailGroup->DeviceList[j] = NULL; break; } } KeReleaseSpinLock(&DsmContext->SpinLock, irql); return; } PFAILOVER_GROUP DsmSetNewPath( IN PDSM_CONTEXT DsmContext, IN PGROUP_ENTRY Group, IN PDEVICE_INFO FailingDevice, IN PFAILOVER_GROUP SelectedPath ) { PFAILOVER_GROUP failGroup; PGROUP_ENTRY group; PDEVICE_INFO device; ULONG i; NTSTATUS status; BOOLEAN matched = FALSE; if (SelectedPath) { // // This indicates that a new path has already been selected // for at least one device in the Fail-Over Group. // Run the list of new devices and find the matching // multi-path group. // for (i = 0; i < SelectedPath->Count; i++) { // // Get the device from the newly selected Path. // device = SelectedPath->DeviceList[i]; // // Determine if the device's group matches the failing // device's group. // if (device->Group == Group) { // // The new device should be either ACTIVE or PASSIVE // if ((device->State == DEV_ACTIVE) || (device->State == DEV_PASSIVE)) { // // Set it to ACTIVE. // device->State = DEV_ACTIVE; // // Ensure that it's ready. // status = DsmSendTUR(device->TargetObject); ASSERT(status == STATUS_SUCCESS); matched = TRUE; break; } } } // // When the first call was made and a path selected, all devices // on the path were checked for validity. // ASSERT(matched == TRUE); // // Just return the SelectedPath // failGroup = SelectedPath; } else { // // Go through Group, looking for an available device. // for (i = 0; i < Group->NumberDevices; i++) { // // Look for any that are Passive. They are the best // choice. This would indicate either an ActiveN/PassiveN arrangement. // device = Group->DeviceList[i]; if (device->State == DEV_PASSIVE) { matched = TRUE; break; } } if (matched) { // // Mark the device as active. // device->State = DEV_ACTIVE; // // Ensure that it's ready. // status = DsmSendTUR(device->TargetObject); if (status != STATUS_SUCCESS) { DebugPrint((0, "SetNewPath: SendTUR (%x) (%x)\n", status, device->TargetObject)); } ASSERT(status == STATUS_SUCCESS); // // Get the Fail-Over group from the selected device. // failGroup = device->FailGroup; } else { // // No passive devices. This indicates either an Active/Active arrangement, // or everything is failed. // Look for active devices. // for (i = 0; i < Group->NumberDevices; i++) { device = Group->DeviceList[i]; if (device->State == DEV_ACTIVE) { matched = TRUE; break; } } if (matched) { // // The device is already active, just return the // new path info. // failGroup = device->FailGroup; // // Ensure that it's ready. // status = DsmSendTUR(device->TargetObject); } else { // // Everything has failed. Should try to do something?? TODO // failGroup = NULL; } } if (failGroup) { // // Run through all the devices to ensure that they are // in a reasonable state. // for (i = 0; i < failGroup->Count; i++) { device = failGroup->DeviceList[i]; if ((device->State != DEV_ACTIVE) && (device->State != DEV_PASSIVE)) { // // Really need to find a new fail-over group. // TODO. // This isn't necessarily a valid assert. If static lb is in // effect and this is one of the first to fail-over, others // could be considered bad. // ASSERT(device->State == DEV_ACTIVE); } } } } return failGroup; } VOID DsmLBInit( IN PDSM_CONTEXT DsmContext, IN PGROUP_ENTRY Group ) { PFAILOVER_GROUP failGroup; PDEVICE_INFO device; PLIST_ENTRY entry; ULONG numberPaths; ULONG assignedPath; ULONG i; BOOLEAN found; // // TODO: Once the Wmi support is here, this will be configurable // Need to add code to handle each of the different policies. // // // Doing 'static' LB. Out of each Multi-Path Group, one // device will be active and assigned to a particular path. // The assignment is based on the group ordinal modulus the total // number of paths. // numberPaths = DsmContext->NumberFOGroups; assignedPath = Group->GroupNumber % numberPaths; // assignedPath = 0; DebugPrint((2, "DsmLBInit: NumberFOGs (%x), Group Number (%x), assignedPath (%x)\n", DsmContext->NumberFOGroups, Group->GroupNumber, assignedPath)); // // Get the Fail-Over Group with the correct path. // i = 0; found = FALSE; // // Get the first entry. // entry = DsmContext->FailGroupList.Flink; do { // // Extract the F.O. Group entry. // failGroup = CONTAINING_RECORD(entry, FAILOVER_GROUP, ListEntry); ASSERT(failGroup); if (i == assignedPath) { // // This is the one. // found = TRUE; } else { // // Advance to the next entry. // entry = entry->Flink; i++; } // // BUGBUG: Need to terminate this loop based on #of FG's. // } while (found == FALSE); // // It may occur that though there are multiple paths/groups, not // all devices have been put into the DeviceList. // If there is only 1, special case this. It will get fixed up // when the second device arrives. // if (Group->NumberDevices == 1) { // // LOG. Indicates something "might" be wrong - definitely // not multi-pathing this device, so could lead to disaster // // // Grab device 0 and set it active. // device = Group->DeviceList[0]; device->State = DEV_ACTIVE; // // Go ahead state that this is init'ed. If/when another // device shows up, we will re-do this. // Group->LoadBalanceInit = TRUE; Group->LoadBalanceType = LB_STATIC; DebugPrint((0, "DsmLBInit: Only One Device (%x) currently in group. Setting it Active\n", device)); return; } // // Find the device with the same F.O. Group // in the mulit-path group. // for (i = 0; i < Group->NumberDevices; i++) { // // Get the device info. // device = Group->DeviceList[i]; // // See if there is a match. // if (device->FailGroup == failGroup) { // // Set the device to active. // device->State = DEV_ACTIVE; // // Done setting up this multi-path group. // Indicate that it's so, and that we are using // STATIC Load-Balancing. // Group->LoadBalanceInit = TRUE; Group->LoadBalanceType = LB_STATIC; return; } else { // // This makes the assumption, once again that Static LB is in // effect. As this entire routine would need to be changes for // any other policy, it's OK. // if (device->State == DEV_ACTIVE) { device->State = DEV_PASSIVE; } else { // // Don't muck with the state. It could be REMOVE_PENDING or FAILED // and just waiting for the cleanup. // NOTHING; } } } } NTSTATUS DsmQueryData( IN PVOID DsmContext, IN PIRP Irp, IN ULONG GuidIndex, IN ULONG InstanceIndex, IN ULONG InstanceCount, IN OUT PULONG InstanceLengthArray, IN ULONG BufferAvail, OUT PUCHAR Buffer, OUT PULONG DataLength ) { PDSM_CONTEXT context = DsmContext; NTSTATUS status = STATUS_UNSUCCESSFUL; ULONG dataLength; switch(GuidIndex) { case GENDSM_CONFIGINFOGuidIndex: { PGENDSM_CONFIGINFO configInfo; dataLength = sizeof(GENDSM_CONFIGINFO); if (dataLength > BufferAvail) { // // Buffer is too small. Indicate this back // to the mpio driver. // *DataLength = dataLength; status = STATUS_BUFFER_TOO_SMALL; } else { // // Get the buffer. // configInfo = (PGENDSM_CONFIGINFO)Buffer; // // Set-up the necessary info. // configInfo->NumberFOGroups = context->NumberFOGroups; configInfo->NumberMPGroups = context->NumberGroups; configInfo->LoadBalancePolicy = DSM_LB_STATIC; // // Indicate the size of returned data to // WMI and MPIO. // *DataLength = dataLength; *InstanceLengthArray = dataLength; status = STATUS_SUCCESS; } break; } case BinaryMofGuidIndex: { // // Check that the buffer size can handle the binary // mof data. // dataLength = sizeof(DsmBinaryMofData); if (dataLength > BufferAvail) { // // Buffer is too small. // Indicate such with status. // status = STATUS_BUFFER_TOO_SMALL; // // Update DataLength, so that the mpio pdo knows // the correct size to report back to Wmi. // *DataLength = dataLength; } else { RtlCopyMemory(Buffer, DsmBinaryMofData, dataLength); // // Set both of these on all successful operations. // InstanceLengthArray gives wMI it's info and DataLength // gives the mpio pdo it's info. // *InstanceLengthArray = dataLength; *DataLength = dataLength; status = STATUS_SUCCESS; } break; } default: status = STATUS_WMI_GUID_NOT_FOUND; break; } return status; } VOID DsmWmiInitialize( IN PDSM_WMILIB_CONTEXT WmiInfo ) { RtlZeroMemory(WmiInfo, sizeof(DSM_WMILIB_CONTEXT)); // // This will jam in the entry points and guids for // supported WMI operations. // WmiInfo->GuidCount = DsmGuidCount; WmiInfo->GuidList = DsmGuidList; WmiInfo->QueryWmiDataBlock = DsmQueryData; // // SetDataBlock and Item, Execute, and FunctionControl are currently // not needed, so leave them set to zero. // return; } VOID DsmDebugPrint( ULONG DebugPrintLevel, PCCHAR DebugMessage, ... ) /*++ Routine Description: Debug print for the DSM Arguments: Return Value: None --*/ { va_list ap; va_start(ap, DebugMessage); if (DebugPrintLevel <= GenDSMDebug) { _vsnprintf(DebugBuffer, DEBUG_BUFFER_LENGTH, DebugMessage, ap); DbgPrint(DebugBuffer); } va_end(ap); }