2421 lines
58 KiB
C
2421 lines
58 KiB
C
|
||
/*++
|
||
|
||
Copyright (C) 2000-2001 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
hpdsm.c
|
||
|
||
Abstract:
|
||
|
||
This driver is the DSM for HP XP-256/512
|
||
|
||
Author:
|
||
|
||
Environment:
|
||
|
||
kernel mode only
|
||
|
||
Notes:
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include <ntddk.h>
|
||
#include <stdio.h>
|
||
#include <stdarg.h>
|
||
#include "dsm.h"
|
||
#include "hpdsm.h"
|
||
|
||
|
||
|
||
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 = HPInquire;
|
||
initData.DsmCompareDevices = HPCompareDevices;
|
||
initData.DsmSetDeviceInfo = HPSetDeviceInfo;
|
||
initData.DsmGetControllerInfo = HPGetControllerInfo;
|
||
initData.DsmIsPathActive = HPIsPathActive;
|
||
initData.DsmPathVerify = HPPathVerify;
|
||
initData.DsmInvalidatePath = HPInvalidatePath;
|
||
initData.DsmRemoveDevice = HPRemoveDevice;
|
||
initData.DsmRemovePath = HPRemovePath;
|
||
initData.DsmReenablePath = HPBringPathOnLine;
|
||
|
||
initData.DsmCategorizeRequest = HPCategorizeRequest;
|
||
initData.DsmBroadcastSrb = HPBroadcastRequest;
|
||
initData.DsmSrbDeviceControl = HPSrbDeviceControl;
|
||
initData.DsmSetCompletion = HPSetCompletion;
|
||
initData.DsmLBGetPath = HPLBGetPath;
|
||
initData.DsmInterpretError = HPInterpretError;
|
||
initData.DsmUnload = HPUnload;
|
||
|
||
//
|
||
// Need to also set-up the WMI info. TODO
|
||
//
|
||
|
||
//
|
||
// Set the DriverObject. Used by MPIO for Unloading.
|
||
//
|
||
initData.DriverObject = DriverObject;
|
||
RtlInitUnicodeString(&initData.DisplayName, L"HP FC-12 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;
|
||
|
||
} else {
|
||
DebugPrint((0,
|
||
"HPDsm: Failed to register (%x)\n",
|
||
status));
|
||
//
|
||
// Stay loaded, perhaps mpctl will come up later.
|
||
// Will need to implement a mechanism to poll for mpio to arrive.
|
||
//
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
HPInquire (
|
||
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
|
||
)
|
||
{
|
||
PDEVICE_INFO deviceInfo;
|
||
PGROUP_ENTRY group;
|
||
NTSTATUS status;
|
||
ULONG deviceState;
|
||
ULONG allocationLength;
|
||
PHP_ENQUIRY enquiry;
|
||
PHP_DAC_STATUS dacStatus;
|
||
UCHAR majorRev;
|
||
UCHAR minorRev;
|
||
ULONG loadBal;
|
||
PUCHAR vendorIndex;
|
||
PUCHAR productIndex;
|
||
BOOLEAN needInquiry = FALSE;
|
||
UCHAR nativeSlot;
|
||
UCHAR portNumber;
|
||
UCHAR logicalPort;
|
||
PUCHAR vendorId = "HP ";
|
||
PUCHAR productId = "FCArray";
|
||
|
||
//
|
||
// 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)) {
|
||
|
||
// TODO : remove after FW update...
|
||
//
|
||
//return STATUS_NOT_SUPPORTED;
|
||
needInquiry = TRUE;
|
||
}
|
||
|
||
vendorIndex = (PUCHAR)Descriptor;
|
||
productIndex = (PUCHAR)Descriptor;
|
||
(ULONG_PTR)vendorIndex += Descriptor->VendorIdOffset;
|
||
(ULONG_PTR)productIndex += Descriptor->ProductIdOffset;
|
||
|
||
//
|
||
// Determine if the device is supported.
|
||
//
|
||
if ((!RtlEqualMemory(vendorId, vendorIndex, 8)) ||
|
||
(!RtlEqualMemory(productId, productIndex, 7))) {
|
||
|
||
|
||
return STATUS_NOT_SUPPORTED;
|
||
}
|
||
|
||
//
|
||
// 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);
|
||
|
||
//
|
||
// Save the PortPdo Object.
|
||
//
|
||
deviceInfo->PortPdo = TargetDevice;
|
||
|
||
|
||
//
|
||
// Send the enquire command to get the FW revs. Based on the revision
|
||
// we can either do fail-over only or active lb.
|
||
//
|
||
enquiry = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(HP_ENQUIRY));
|
||
if (enquiry == NULL) {
|
||
|
||
ExFreePool(deviceInfo);
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
RtlZeroMemory(enquiry, sizeof(HP_ENQUIRY));
|
||
|
||
status = HPSendDirectCommand(TargetDevice,
|
||
(PUCHAR)enquiry,
|
||
sizeof(HP_ENQUIRY),
|
||
DCMD_ENQUIRY);
|
||
|
||
if (NT_SUCCESS(status)) {
|
||
|
||
majorRev = enquiry->FwMajorRev;
|
||
minorRev = enquiry->FwMinorRev;
|
||
|
||
DebugPrint((0,
|
||
"HPDSM: FirmWare Major (%u) Minor (%u)\n",
|
||
majorRev,
|
||
minorRev));
|
||
|
||
//
|
||
// Free the buffer.
|
||
//
|
||
ExFreePool(enquiry);
|
||
|
||
if (majorRev > 5 || (majorRev == 5 && minorRev >= 46)) {
|
||
|
||
//
|
||
// Supports dual active/active.
|
||
//
|
||
loadBal = LB_MIN_QUEUE;
|
||
|
||
} else if (majorRev == 5 && minorRev >= 41) {
|
||
|
||
//
|
||
// Fail-over only.
|
||
//
|
||
loadBal = LB_ACTIVE_PASSIVE;
|
||
|
||
} else {
|
||
|
||
//
|
||
// Not supported. LOG.
|
||
//
|
||
ExFreePool(deviceInfo);
|
||
|
||
return STATUS_NOT_SUPPORTED;
|
||
}
|
||
} else {
|
||
|
||
ExFreePool(enquiry);
|
||
ExFreePool(deviceInfo);
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// Send the Get Controller Status command so that the port
|
||
// on which this device lives can be determined.
|
||
//
|
||
dacStatus = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(HP_DAC_STATUS));
|
||
if (dacStatus == NULL) {
|
||
ExFreePool(deviceInfo);
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
RtlZeroMemory(dacStatus, sizeof(HP_DAC_STATUS));
|
||
status = HPSendDirectCommand(TargetDevice,
|
||
(PUCHAR)dacStatus,
|
||
sizeof(HP_DAC_STATUS),
|
||
DCMD_GET_DAC_STATUS);
|
||
|
||
if (NT_SUCCESS(status)) {
|
||
|
||
//
|
||
// Build a logical port value (1-4) based on the NativeSlot and PortNumber
|
||
// values. NativeSlot 0 or 1, and portNumber 0 or 1 for 4 possibilities.
|
||
// NativeSlot refers to the controller and portNumber to the port.
|
||
//
|
||
nativeSlot = dacStatus->DACInfo[0] >> 4;
|
||
portNumber = (dacStatus->DACInfo[1] >> 5) & 0x01;
|
||
|
||
logicalPort = ((nativeSlot & 1) << 1) + (portNumber + 1);
|
||
|
||
//
|
||
// Set the port number for this device.
|
||
// Used to help create the FOGroups and as the index into
|
||
// the path array.
|
||
//
|
||
deviceInfo->Controller = logicalPort;
|
||
|
||
} else {
|
||
|
||
ExFreePool(deviceInfo);
|
||
return status;
|
||
}
|
||
|
||
|
||
//
|
||
// Build the controller serial number.
|
||
// Bytes 40-47 of the inquiry data have the Node Name of Controller 0.
|
||
// Use this as a 64-bit identifier.
|
||
//
|
||
if (needInquiry) {
|
||
CDB cdb;
|
||
PINQUIRYDATA inquiryBuffer;
|
||
|
||
RtlZeroMemory(&cdb, sizeof(CDB));
|
||
|
||
cdb.START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
|
||
cdb.START_STOP.Start = 1;
|
||
|
||
status = HPSendScsiCommand(TargetDevice,
|
||
NULL,
|
||
0,
|
||
6,
|
||
&cdb,
|
||
1);
|
||
|
||
RtlZeroMemory(&cdb, sizeof(CDB));
|
||
|
||
cdb.CDB6INQUIRY.OperationCode = SCSIOP_INQUIRY;
|
||
cdb.CDB6INQUIRY.AllocationLength = 56;
|
||
|
||
inquiryBuffer = ExAllocatePool(NonPagedPoolCacheAligned, 56);
|
||
|
||
status = HPSendScsiCommand(TargetDevice,
|
||
(PUCHAR)inquiryBuffer,
|
||
56,
|
||
6,
|
||
&cdb,
|
||
1);
|
||
if (NT_SUCCESS(status)) {
|
||
UCHAR controllerSerialNumber[9];
|
||
UCHAR driveNumber[11];
|
||
|
||
RtlZeroMemory(controllerSerialNumber, 9);
|
||
RtlZeroMemory(driveNumber, 11);
|
||
|
||
//
|
||
// Copy the serial number over into the deviceInfo.
|
||
// SerialNumber is built from the Node Name of the Controller +
|
||
// the SystemDrive Number.
|
||
//
|
||
RtlCopyMemory(controllerSerialNumber,
|
||
&inquiryBuffer->VendorSpecific[4],
|
||
8);
|
||
//
|
||
// Get the drive Number.
|
||
//
|
||
driveNumber[0] = inquiryBuffer->VendorSpecific[0];
|
||
driveNumber[1] = inquiryBuffer->VendorSpecific[1];
|
||
|
||
//
|
||
// cat the driveNumber & controller serial number into 10-byte binary value.
|
||
//
|
||
RtlCopyMemory(&driveNumber[2],
|
||
controllerSerialNumber,
|
||
8);
|
||
|
||
//
|
||
// Convert to ascii.
|
||
//
|
||
HPConvertHexToAscii(driveNumber,
|
||
deviceInfo->SerialNumber,
|
||
10);
|
||
|
||
DebugPrint((0,
|
||
"HPInquiry: SerialNumber: %s\n", deviceInfo->SerialNumber));
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// See if there is an existing Muli-path group to which this belongs.
|
||
// (same serial number).
|
||
//
|
||
group = FindDevice(DsmContext,
|
||
deviceInfo);
|
||
|
||
if (group == NULL) {
|
||
|
||
//
|
||
// Build a multi-path group entry.
|
||
//
|
||
group = BuildGroupEntry(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 = AddDeviceEntry(DsmContext,
|
||
group,
|
||
deviceInfo,
|
||
deviceState);
|
||
|
||
*DsmIdentifier = deviceInfo;
|
||
return status;
|
||
}
|
||
|
||
|
||
VOID
|
||
HPConvertHexToAscii(
|
||
IN PUCHAR HexString,
|
||
IN OUT PUCHAR AsciiString,
|
||
IN ULONG Count
|
||
)
|
||
{
|
||
ULONG i;
|
||
ULONG j;
|
||
UCHAR value;
|
||
|
||
DebugPrint((0,
|
||
"ConvertHexToAscii: "));
|
||
for (i = 0, j = 0; i < Count; i++, j++) {
|
||
|
||
value = HexString[i];
|
||
DebugPrint((0,
|
||
"%x ", value));
|
||
if (value <= 9) {
|
||
AsciiString[j] = value + '0';
|
||
} else {
|
||
AsciiString[j] = value - 10 + 'A';
|
||
}
|
||
}
|
||
DebugPrint((0,"\n"));
|
||
}
|
||
|
||
|
||
BOOLEAN
|
||
HPCompareDevices(
|
||
IN PVOID DsmContext,
|
||
IN PVOID DsmId1,
|
||
IN PVOID DsmId2
|
||
)
|
||
{
|
||
PDEVICE_INFO deviceInfo = DsmId1;
|
||
PDEVICE_INFO comparedDevice = DsmId2;
|
||
ULONG length;
|
||
PUCHAR serialNumber;
|
||
PUCHAR comparedSerialNumber;
|
||
|
||
//
|
||
// If this is an RS12, then no serial number in the device descriptor.
|
||
//
|
||
if (deviceInfo->Descriptor.SerialNumberOffset == (ULONG)-1) {
|
||
|
||
//
|
||
// Use the one's built from inquiry Data.
|
||
//
|
||
serialNumber = deviceInfo->SerialNumber;
|
||
comparedSerialNumber = comparedDevice->SerialNumber;
|
||
|
||
} else {
|
||
|
||
//
|
||
// Get the two serial numbers.
|
||
// They reside at SNOffset from the front of the
|
||
// descriptor buffer.
|
||
//
|
||
serialNumber = (PUCHAR)&deviceInfo->Descriptor;
|
||
serialNumber += deviceInfo->Descriptor.SerialNumberOffset;
|
||
|
||
comparedSerialNumber = (PUCHAR)&comparedDevice->Descriptor;
|
||
comparedSerialNumber += comparedDevice->Descriptor.SerialNumberOffset;
|
||
|
||
}
|
||
|
||
//
|
||
// 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;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
HPSetDeviceInfo(
|
||
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 = FindFOGroup(DsmContext,
|
||
*PathId);
|
||
//
|
||
// if not found, create a new f.o. group
|
||
//
|
||
if (failGroup == NULL) {
|
||
failGroup = BuildFOGroup(DsmContext,
|
||
DsmId,
|
||
*PathId);
|
||
|
||
if (failGroup == NULL) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
}
|
||
|
||
//
|
||
// add this deviceInfo to the f.o. group.
|
||
//
|
||
status = UpdateFOGroup(DsmContext,
|
||
failGroup,
|
||
deviceInfo);
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
HPGetControllerInfo(
|
||
IN PVOID DsmContext,
|
||
IN PVOID DsmId,
|
||
IN ULONG Flags,
|
||
IN OUT PCONTROLLER_INFO *ControllerInfo
|
||
)
|
||
{
|
||
PCONTROLLER_INFO controllerInfo;
|
||
|
||
if (Flags & DSM_CNTRL_FLAGS_ALLOCATE) {
|
||
controllerInfo = ExAllocatePool(NonPagedPool, sizeof(CONTROLLER_INFO));
|
||
if (controllerInfo == NULL) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
RtlZeroMemory(controllerInfo, sizeof(CONTROLLER_INFO));
|
||
|
||
//
|
||
// TODO Get the ID etc.
|
||
//
|
||
controllerInfo->State = DSM_CONTROLLER_NO_CNTRL;
|
||
*ControllerInfo = controllerInfo;
|
||
|
||
} else {
|
||
|
||
controllerInfo = *ControllerInfo;
|
||
|
||
//
|
||
// TODO Get the state.
|
||
//
|
||
controllerInfo->State = DSM_CONTROLLER_NO_CNTRL;
|
||
}
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
BOOLEAN
|
||
HPIsPathActive(
|
||
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 = FindFOGroup(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
|
||
HPPathVerify(
|
||
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 = FindFOGroup(DsmContext,
|
||
PathId);
|
||
if (group == NULL) {
|
||
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 {
|
||
|
||
//
|
||
// What really has to happen:
|
||
// Ensure the device is in our structs
|
||
// Send it a TUR.
|
||
// Depending upon prior state - update to the new, appropriate state.
|
||
// return status.
|
||
//
|
||
status = STATUS_UNSUCCESSFUL;
|
||
for (i = 0; i < group->Count; i++) {
|
||
if (group->DeviceList[i] == deviceInfo) {
|
||
status = DsmSendTUR(deviceInfo->TargetObject);
|
||
}
|
||
}
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
|
||
//
|
||
// Either the device is not in the group, or the TUR was not successful.
|
||
// TODO - Something.
|
||
//
|
||
}
|
||
}
|
||
//
|
||
// Update the group State, depending upon the outcome.
|
||
// TODO
|
||
//
|
||
ASSERT(status == STATUS_SUCCESS);
|
||
if (status == STATUS_SUCCESS) {
|
||
|
||
//
|
||
// This lets the LBInit run to properly set-up this device.
|
||
//
|
||
deviceInfo->NeedsVerification = FALSE;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
HPInvalidatePath(
|
||
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) || (ErrorMask & DSM_ADMIN_FO));
|
||
|
||
failGroup = FindFOGroup(DsmContext,
|
||
PathId);
|
||
|
||
//
|
||
// Mark the path as failed.
|
||
//
|
||
failGroup->State = FG_FAILED;
|
||
|
||
//
|
||
// 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;
|
||
|
||
//
|
||
// 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 = SetNewPath(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;
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
HPRemoveDevice(
|
||
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];
|
||
|
||
//
|
||
// 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.
|
||
//
|
||
SetNewPath(DsmContext,
|
||
group,
|
||
deviceInfo,
|
||
NULL);
|
||
}
|
||
|
||
//
|
||
// Remove it's entry from the Fail-Over Group.
|
||
//
|
||
RemoveDeviceFailGroup(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.
|
||
//
|
||
RemoveDeviceEntry(DsmContext,
|
||
group,
|
||
deviceInfo);
|
||
|
||
swprintf(buffer, L"Removing Device");
|
||
DsmWriteEvent(dsmContext->MPIOContext,
|
||
L"HpDsm",
|
||
buffer,
|
||
2);
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
HPRemovePath(
|
||
IN PDSM_CONTEXT DsmContext,
|
||
IN PVOID PathId
|
||
)
|
||
{
|
||
PFAILOVER_GROUP failGroup;
|
||
KIRQL irql;
|
||
|
||
failGroup = FindFOGroup(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);
|
||
//
|
||
// 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
|
||
HPBringPathOnLine(
|
||
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 = FindFOGroup(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
|
||
HPLBGetPath(
|
||
IN PVOID DsmContext,
|
||
IN PSCSI_REQUEST_BLOCK Srb,
|
||
IN PDSM_IDS DsmList,
|
||
IN PVOID CurrentPath,
|
||
OUT NTSTATUS *Status
|
||
)
|
||
{
|
||
PDEVICE_INFO deviceInfo;
|
||
PGROUP_ENTRY group;
|
||
PFAILOVER_GROUP failGroup = NULL;
|
||
ULONG i;
|
||
|
||
//
|
||
// 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];
|
||
|
||
//
|
||
// 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];
|
||
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.
|
||
//
|
||
LBInit(DsmContext,
|
||
group);
|
||
}
|
||
}
|
||
|
||
//
|
||
// Ensure that mpctl and this dsm are in sync.
|
||
//
|
||
ASSERT(DsmList->Count == group->NumberDevices);
|
||
|
||
//
|
||
// Find the active device.
|
||
//
|
||
for (i = 0; i < DsmList->Count; i++) {
|
||
|
||
//
|
||
// Get each of the DsmId's, in reality the deviceInfo.
|
||
//
|
||
deviceInfo = DsmList->IdList[i];
|
||
|
||
//
|
||
// Ensure that the device is in our list.
|
||
//
|
||
ASSERT(FindDevice(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;
|
||
return failGroup->PathId;
|
||
}
|
||
}
|
||
|
||
//
|
||
// 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
|
||
HPCategorizeRequest(
|
||
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 = HPLBGetPath(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
|
||
HPBroadcastRequest(
|
||
IN PVOID DsmContext,
|
||
IN PDSM_IDS DsmIds,
|
||
IN PIRP Irp,
|
||
IN PSCSI_REQUEST_BLOCK Srb,
|
||
IN PKEVENT Event
|
||
)
|
||
{
|
||
//
|
||
// BUGBUG: Need to handle Reset, Reserve, and Release.
|
||
//
|
||
return STATUS_INVALID_DEVICE_REQUEST;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
HPSrbDeviceControl(
|
||
IN PVOID DsmContext,
|
||
IN PDSM_IDS DsmIds,
|
||
IN PIRP Irp,
|
||
IN PSCSI_REQUEST_BLOCK Srb,
|
||
IN PKEVENT Event
|
||
)
|
||
{
|
||
//
|
||
// BUGBUG: Need to handle ??
|
||
//
|
||
return STATUS_INVALID_DEVICE_REQUEST;
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
HPCompletion(
|
||
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
|
||
HPSetCompletion(
|
||
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 = HPCompletion;
|
||
DsmCompletion->DsmContext = completionContext;
|
||
return;
|
||
}
|
||
|
||
|
||
ULONG
|
||
HPInterpretError(
|
||
IN PVOID DsmContext,
|
||
IN PVOID DsmId,
|
||
IN PSCSI_REQUEST_BLOCK Srb,
|
||
IN OUT NTSTATUS *Status,
|
||
OUT PBOOLEAN Retry
|
||
)
|
||
{
|
||
ULONG errorMask = 0;
|
||
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;
|
||
|
||
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
|
||
HPUnload(
|
||
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.
|
||
//
|
||
|
||
NTSTATUS
|
||
HPSendDirectCommand(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PUCHAR Buffer,
|
||
IN ULONG BufferSize,
|
||
IN UCHAR Opcode
|
||
)
|
||
{
|
||
PSCSI_PASS_THROUGH_DIRECT passThrough;
|
||
ULONG length;
|
||
NTSTATUS status;
|
||
PCDB cdb;
|
||
IO_STATUS_BLOCK ioStatus;
|
||
|
||
DsmSendTUR(DeviceObject);
|
||
|
||
//
|
||
// Allocate the pass through plus sense info buffer.
|
||
//
|
||
length = sizeof(SCSI_PASS_THROUGH_DIRECT) + sizeof(SENSE_DATA);
|
||
passThrough = ExAllocatePool(NonPagedPool,
|
||
length);
|
||
if (passThrough == NULL) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
RtlZeroMemory(passThrough, length);
|
||
|
||
//
|
||
// These are always 10-byte CDB, guess on the timeout.
|
||
// Buffer is allocated by the caller and is it's responsibility to be correctly
|
||
// sized and aligned.
|
||
//
|
||
passThrough->Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
|
||
passThrough->CdbLength = 10;
|
||
passThrough->SenseInfoLength = sizeof(SENSE_DATA);
|
||
passThrough->DataIn = 1;
|
||
passThrough->DataTransferLength = BufferSize;
|
||
passThrough->TimeOutValue = 20;
|
||
passThrough->DataBuffer = Buffer;
|
||
passThrough->SenseInfoOffset = sizeof(SCSI_PASS_THROUGH_DIRECT);
|
||
|
||
cdb = (PCDB)passThrough->Cdb;
|
||
|
||
//
|
||
// These are always 0x20.
|
||
//
|
||
cdb->CDB10.OperationCode = 0x20;
|
||
|
||
//
|
||
// The sub-code (DCMD OpCode)
|
||
//
|
||
cdb->CDB10.LogicalBlockByte0 = Opcode;
|
||
|
||
//
|
||
// Allocation length.
|
||
//
|
||
cdb->CDB10.TransferBlocksLsb = (UCHAR)(BufferSize & 0xFF);
|
||
cdb->CDB10.TransferBlocksMsb = (UCHAR)(BufferSize >> 8);
|
||
|
||
//
|
||
// Submit the command.
|
||
//
|
||
DsmSendDeviceIoControlSynchronous(IOCTL_SCSI_PASS_THROUGH_DIRECT,
|
||
DeviceObject,
|
||
passThrough,
|
||
passThrough,
|
||
length,
|
||
length,
|
||
FALSE,
|
||
&ioStatus);
|
||
|
||
status = ioStatus.Status;
|
||
|
||
// status = DsmSendPassThroughDirect(DeviceObject,
|
||
// passThrough,
|
||
// length,
|
||
// BufferSize);
|
||
if (!NT_SUCCESS(status)) {
|
||
|
||
//
|
||
// The call above has already 'interpreted' the senseInfo, but check
|
||
// to see if it is correct.
|
||
//
|
||
if (Opcode == 0x5) {
|
||
|
||
//
|
||
// No error conditions reported with this command, so trust the interpretation.
|
||
//
|
||
//
|
||
}
|
||
}
|
||
|
||
if (passThrough->ScsiStatus) {
|
||
DebugPrint((0,
|
||
"SendDirect: ScsiStatus (%x)\n",
|
||
passThrough->ScsiStatus));
|
||
}
|
||
ExFreePool(passThrough);
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
HPSendScsiCommand(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PUCHAR Buffer,
|
||
IN ULONG BufferSize,
|
||
IN ULONG CdbLength,
|
||
IN PCDB Cdb,
|
||
IN BOOLEAN DataIn
|
||
)
|
||
{
|
||
PSCSI_PASS_THROUGH_DIRECT passThrough;
|
||
ULONG length;
|
||
NTSTATUS status;
|
||
IO_STATUS_BLOCK ioStatus;
|
||
|
||
//
|
||
// Allocate the pass through plus sense info buffer.
|
||
//
|
||
length = sizeof(SCSI_PASS_THROUGH_DIRECT) + sizeof(SENSE_DATA);
|
||
passThrough = ExAllocatePool(NonPagedPool,
|
||
length);
|
||
if (passThrough == NULL) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
RtlZeroMemory(passThrough, length);
|
||
|
||
//
|
||
// These are always 10-byte CDB, guess on the timeout.
|
||
// Buffer is allocated by the caller and is it's responsibility to be correctly
|
||
// sized and aligned.
|
||
//
|
||
passThrough->Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
|
||
passThrough->CdbLength = (UCHAR)CdbLength;
|
||
passThrough->SenseInfoLength = sizeof(SENSE_DATA);
|
||
passThrough->DataIn = DataIn;
|
||
passThrough->DataTransferLength = BufferSize;
|
||
passThrough->TimeOutValue = 20;
|
||
passThrough->DataBuffer = Buffer;
|
||
passThrough->SenseInfoOffset = sizeof(SCSI_PASS_THROUGH_DIRECT);
|
||
|
||
RtlCopyMemory(passThrough->Cdb,
|
||
Cdb,
|
||
CdbLength);
|
||
|
||
//
|
||
// Submit the command.
|
||
//
|
||
DsmSendDeviceIoControlSynchronous(IOCTL_SCSI_PASS_THROUGH_DIRECT,
|
||
DeviceObject,
|
||
passThrough,
|
||
passThrough,
|
||
length,
|
||
length,
|
||
FALSE,
|
||
&ioStatus);
|
||
|
||
status = ioStatus.Status;
|
||
|
||
// status = DsmSendPassThroughDirect(DeviceObject,
|
||
// passThrough,
|
||
// length,
|
||
// BufferSize);
|
||
return status;
|
||
}
|
||
|
||
|
||
PGROUP_ENTRY
|
||
FindDevice(
|
||
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 (HPCompareDevices(DsmContext,
|
||
DeviceInfo,
|
||
deviceInfo)) {
|
||
|
||
|
||
return deviceInfo->Group;
|
||
}
|
||
}
|
||
|
||
DebugPrint((0,
|
||
"DsmFindDevice: DsmContext (%x), DeviceInfo (%x)\n",
|
||
DsmContext,
|
||
DeviceInfo));
|
||
return NULL;
|
||
}
|
||
|
||
|
||
|
||
PGROUP_ENTRY
|
||
BuildGroupEntry(
|
||
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);
|
||
|
||
ASSERT(group->GroupNumber >= 1);
|
||
return group;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
AddDeviceEntry(
|
||
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
|
||
RemoveDeviceEntry(
|
||
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
|
||
FindFOGroup(
|
||
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
|
||
BuildFOGroup(
|
||
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;
|
||
|
||
//
|
||
// Add it to the global list.
|
||
//
|
||
InsertTailList(&DsmContext->FailGroupList,
|
||
&failOverGroup->ListEntry);
|
||
|
||
KeReleaseSpinLock(&DsmContext->SpinLock, irql);
|
||
|
||
return failOverGroup;
|
||
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
UpdateFOGroup(
|
||
IN PDSM_CONTEXT DsmContext,
|
||
IN PFAILOVER_GROUP FailGroup,
|
||
IN PDEVICE_INFO DeviceInfo
|
||
)
|
||
{
|
||
PGROUP_ENTRY group;
|
||
ULONG count;
|
||
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;
|
||
DeviceInfo->NeedsVerification = TRUE;
|
||
|
||
//
|
||
// Set the device's F.O. Group.
|
||
//
|
||
DeviceInfo->FailGroup = FailGroup;
|
||
|
||
KeReleaseSpinLock(&DsmContext->SpinLock, irql);
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
VOID
|
||
RemoveDeviceFailGroup(
|
||
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
|
||
SetNewPath(
|
||
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);
|
||
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;
|
||
|
||
} 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
|
||
LBInit(
|
||
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;
|
||
|
||
DebugPrint((0,
|
||
"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);
|
||
|
||
DebugPrint((0,
|
||
"DsmLBInit: Trying %x. at (%x) of (%x)\n",
|
||
failGroup,
|
||
i,
|
||
assignedPath));
|
||
|
||
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);
|
||
|
||
DebugPrint((0,
|
||
"DsmLBInit: Using FOG (%x)\n",
|
||
failGroup));
|
||
|
||
//
|
||
// 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;
|
||
|
||
DebugPrint((0,
|
||
"DsmLBInit: Marking (%x) as active device\n",
|
||
device));
|
||
|
||
//
|
||
// 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 {
|
||
|
||
DebugPrint((0,
|
||
"DsmLBInit: Marking (%x) as stand-by device\n",
|
||
device));
|
||
device->State = DEV_PASSIVE;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
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 <= HPDSMDebug) {
|
||
|
||
_vsnprintf(DebugBuffer, DEBUG_BUFFER_LENGTH, DebugMessage, ap);
|
||
|
||
DbgPrint(DebugBuffer);
|
||
}
|
||
|
||
va_end(ap);
|
||
|
||
}
|