windows-nt/Source/XPSP1/NT/drivers/storage/mpath/control/thread.c

307 lines
8.7 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
#include "mpio.h"
NTSTATUS
MPIOInitiateFailOver(
IN PDEVICE_OBJECT DeviceObject,
IN PVOID FailingPath,
IN ULONG ErrorMask
)
{
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
PMPDISK_EXTENSION diskExtension = deviceExtension->TypeExtension;
PDSM_ENTRY dsm = &diskExtension->DsmInfo;
PREAL_DEV_INFO targetInfo;
PVOID newPath = NULL;
NTSTATUS status;
WCHAR buffer[64];
MPDebugPrint((0,
"InitiateFailOver: Invalidating %x\n",
FailingPath));
//
// Initiate the fail-over.
//
status = dsm->InvalidatePath(dsm->DsmContext,
ErrorMask,
FailingPath,
&newPath);
MPDebugPrint((0,
"InitiateFailOver: New Path (%x)\n",
newPath));
//
// TODO - Put in real Path identiifiers.
//
swprintf(buffer,L"Path (%x) Failed Over to (%x)", FailingPath, newPath);
MPIOFireEvent(DeviceObject,
L"MPIO WrkerThrd",
buffer,
MPIO_WARNING);
//
// If successful, go into DEGRADED
//
if ((status == STATUS_SUCCESS) && newPath) {
//
// Ensure that newPath actually is found in one of the TargetInfo
// structures that make up this mpdisk.
//
targetInfo = MPIOGetTargetInfo(diskExtension,
newPath,
NULL);
if (targetInfo == NULL) {
MPDebugPrint((0,
"MPIOInitiateFailOver: No match for path (%x)\n",
newPath));
DbgBreakPoint();
return STATUS_NO_SUCH_DEVICE;
}
ASSERT(newPath == targetInfo->PathId);
//
// Verify that this path/device combo. is ready.
//
status = dsm->PathVerify(dsm->DsmContext,
targetInfo->DsmID,
targetInfo->PathId);
if (!NT_SUCCESS(status)) {
MPDebugPrint((0,
"MPIOInitiateFailOver: PathVerify failed (%x)\n",
status));
//
// Log.
//
return status;
}
//
// Ensure the new path is active.
// Invalidate path should have done everything to assure that
// the new device(s) are ready.
//
targetInfo->PathActive = dsm->IsPathActive(dsm->DsmContext,
newPath);
ASSERT(targetInfo->PathActive);
//
// Set CurrentPath to this new one.
//
diskExtension->CurrentPath = newPath;
//
// Update all that are using this path, that it has changed.
//
MPIOSetNewPath(diskExtension->ControlObject,
newPath);
} else {
if (newPath == NULL) {
MPDebugPrint((0,
"MPIOInitiateFailOver: DSM returned NULL path\n"));
}
if (status != STATUS_SUCCESS) {
//
// LOG
//
MPDebugPrint((0,
"MPIOInitiateFailOver: DSM returned (%x)\n",
status));
}
//
// Set the path to NULL. The callback will key off this and the bad status.
//
diskExtension->CurrentPath = NULL;
DbgBreakPoint();
}
return status;
}
VOID
MPIORecoveryThread(
IN PVOID Context
)
/*++
Routine Description:
This routine is the thread proc that is started upon creation of an mpdisk.
When signaled, it will initiate the fail-over, insure that the new path is
ready, then call-back the mpdisk to indicate success or failure of the operation.
Arguments:
Context - Info needed to handle the fail-over.
Return Value:
None.
--*/
{
PMPIO_THREAD_CONTEXT context = Context;
PDEVICE_OBJECT deviceObject = context->DeviceObject;
PDEVICE_EXTENSION deviceExtension = deviceObject->DeviceExtension;
PMPDISK_EXTENSION diskExtension = deviceExtension->TypeExtension;
PKEVENT event = context->Event;
PVOID failingPath;
MPIO_CALLBACK RequestComplete;
PMPIO_REQUEST_INFO requestInfo;
PLIST_ENTRY entry;
NTSTATUS status;
ULONG i;
KeSetPriorityThread(KeGetCurrentThread(), LOW_REALTIME_PRIORITY);
while (TRUE) {
//
// Wait on the event.
//
KeWaitForSingleObject(event,
Executive,
KernelMode,
FALSE,
NULL);
KeClearEvent(event);
//
// Yank the packet.
//
entry = ExInterlockedRemoveHeadList(&diskExtension->WorkList,
&diskExtension->WorkListLock);
ASSERT(entry);
//
// Get the actual work item.
//
requestInfo = CONTAINING_RECORD(entry, MPIO_REQUEST_INFO, ListEntry);
//
// Get the call-back proc.
//
RequestComplete = requestInfo->RequestComplete;
//
// Determine the operation.
//
if (requestInfo->Operation == INITIATE_FAILOVER) {
//
// Get the device that indicated the failure.
//
failingPath = requestInfo->OperationSpecificInfo;
//
// Asking for a fail-over. Call the handler.
//
status = MPIOInitiateFailOver(deviceObject,
failingPath,
requestInfo->ErrorMask);
} else if (requestInfo->Operation == SHUTDOWN) {
//
// Being signaled to die.
//
ExFreePool(requestInfo);
goto terminateThread;
} else if (requestInfo->Operation == FORCE_RESCAN) {
PFLTR_ENTRY fltrEntry;
fltrEntry = (PFLTR_ENTRY)(requestInfo->OperationSpecificInfo);
MPIOForceRescan(fltrEntry->FilterObject);
//
// Indicate that the rescan is complete.
//
fltrEntry->Flags &= ~FLTR_FLAGS_RESCANNING;
} else if (requestInfo->Operation == PATH_REMOVAL) {
PDSM_ENTRY dsm = &diskExtension->DsmInfo;
MPDebugPrint((0,
"RecoveryThread: Removing Path (%x)\n",
requestInfo->OperationSpecificInfo));
//
// Call the dsm to clean up. All of the devices have been
// removed, and any pending actions have been completed, so
// it's safe to do this now.
//
dsm->RemovePath(dsm->DsmContext,
requestInfo->OperationSpecificInfo);
} else if (requestInfo->Operation == DEVICE_REMOVAL) {
PMPIO_DEVICE_REMOVAL deviceRemoval = requestInfo->OperationSpecificInfo;
MPDebugPrint((0,
"RecoveryThread: Removing Device (%x) DsmID (%x)\n",
deviceRemoval->TargetInfo,
deviceRemoval->TargetInfo->DsmID));
//
// Invoke the remove routine.
//
status = MPIORemoveDeviceAsync(deviceRemoval->DeviceObject,
deviceRemoval->TargetInfo);
//
// Free this allocation.
//
ExFreePool(deviceRemoval);
} else {
MPDebugPrint((0,
"MPIORecoveryThread: Invalid operation (%x) in (%x)\n",
requestInfo->Operation,
requestInfo));
ASSERT(FALSE);
}
if (RequestComplete) {
//
// Invoke the call-back routine to indicate
// completion.
//
RequestComplete(deviceObject,
requestInfo->Operation,
status);
if (requestInfo->Operation == INITIATE_FAILOVER) {
//
// Force a rescan on the disks adapters.
//
for (i = 0; i < diskExtension->TargetInfoCount; i++ ) {
MPIOForceRescan(diskExtension->TargetInfo[i].DevFilter);
}
}
}
//
// Dispose of the work item.
//
ExFreePool(requestInfo);
}
terminateThread:
PsTerminateSystemThread(STATUS_SUCCESS);
}