able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/storage/newft/redist.cxx

2414 lines
62 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) 1991-5 Microsoft Corporation
Module Name:
redist.cxx
Abstract:
This module contains the code specific to redistributions for the fault
tolerance driver.
Author:
Norbert Kusters 6-Feb-1997
Environment:
kernel mode only
Notes:
Revision History:
--*/
extern "C" {
#include <ntddk.h>
}
#include <ftdisk.h>
class PROPOGATE_CHANGES_WORK_ITEM : public WORK_QUEUE_ITEM {
public:
PREDISTRIBUTION Redistribution;
FT_COMPLETION_ROUTINE CompletionRoutine;
PVOID Context;
};
typedef PROPOGATE_CHANGES_WORK_ITEM *PPROPOGATE_CHANGES_WORK_ITEM;
#ifdef ALLOC_PRAGMA
#pragma code_seg("PAGE")
#endif
NTSTATUS
REDISTRIBUTION::Initialize(
IN OUT PROOT_EXTENSION RootExtension,
IN FT_LOGICAL_DISK_ID LogicalDiskId,
IN OUT PFT_VOLUME* VolumeArray,
IN USHORT ArraySize,
IN PVOID ConfigInfo,
IN PVOID StateInfo
)
/*++
Routine Description:
Initialize routine for FT_VOLUME of type REDISTRIBUTION.
Arguments:
RootExtension - Supplies the root device extension.
LogicalDiskId - Supplies the logical disk id for this volume.
VolumeArray - Supplies the array of volumes for this volume set.
ArraySize - Supplies the number of volumes in the volume array.
ConfigInfo - Supplies the configuration information.
StateInfo - Supplies the state information.
Return Value:
NTSTATUS
--*/
{
BOOLEAN oneGood;
USHORT i;
NTSTATUS status;
PFT_REDISTRIBUTION_CONFIGURATION_INFORMATION configInfo;
LONGLONG firstRowSize;
LONGLONG secondRowSize;
LONGLONG numRows;
LONGLONG tmpNumRows;
if (ArraySize != 2) {
return STATUS_INVALID_PARAMETER;
}
oneGood = FALSE;
for (i = 0; i < ArraySize; i++) {
if (VolumeArray[i]) {
oneGood = TRUE;
}
}
if (!oneGood) {
return STATUS_INVALID_PARAMETER;
}
status = COMPOSITE_FT_VOLUME::Initialize(RootExtension, LogicalDiskId,
VolumeArray, ArraySize,
ConfigInfo, StateInfo);
if (!NT_SUCCESS(status)) {
return status;
}
configInfo = (PFT_REDISTRIBUTION_CONFIGURATION_INFORMATION) ConfigInfo;
_stripeSize = configInfo->StripeSize;
if (_stripeSize < QuerySectorSize()) {
return STATUS_INVALID_PARAMETER;
}
for (i = 0; _stripeSize%2 == 0; i++) {
_stripeSize /= 2;
}
if (_stripeSize != 1) {
return STATUS_INVALID_PARAMETER;
}
_stripeSize = configInfo->StripeSize;
if( !configInfo->FirstMemberWidth || !configInfo->SecondMemberWidth) {
return STATUS_INVALID_PARAMETER;
}
_firstWidth = configInfo->FirstMemberWidth;
_totalWidth = _firstWidth + configInfo->SecondMemberWidth;
if (VolumeArray[0]) {
_firstSize = VolumeArray[0]->QueryVolumeSize();
} else {
_firstSize = 0;
}
if (_firstSize && VolumeArray[1]) {
firstRowSize = _firstWidth*_stripeSize;
numRows = _firstSize/firstRowSize;
secondRowSize = configInfo->SecondMemberWidth*_stripeSize;
tmpNumRows = VolumeArray[1]->QueryVolumeSize()/secondRowSize;
if (tmpNumRows < numRows) {
numRows = tmpNumRows;
}
_totalSize = numRows*_totalWidth*_stripeSize;
if (_totalSize < _firstSize) {
return STATUS_INVALID_PARAMETER;
}
} else {
_totalSize = 0;
}
_syncOk = TRUE;
_stopSyncs = FALSE;
RtlCopyMemory(&_state, StateInfo, sizeof(_state));
if (_state.BytesRedistributed < _firstSize) {
_redistributionComplete = FALSE;
} else {
_redistributionComplete = TRUE;
}
status = _overlappedIoManager.Initialize(0);
return status;
}
FT_LOGICAL_DISK_TYPE
REDISTRIBUTION::QueryLogicalDiskType(
)
/*++
Routine Description:
This routine returns the type of the logical disk.
Arguments:
None.
Return Value:
The type of the logical disk.
--*/
{
return FtRedistribution;
}
NTSTATUS
REDISTRIBUTION::CheckIo(
OUT PBOOLEAN IsIoOk
)
/*++
Routine Description:
This routine returns whether or not IO is possible on the given
logical disk.
Arguments:
IsIoOk - Returns the state of IO.
Return Value:
NTSTATUS
--*/
{
USHORT n, i;
PFT_VOLUME vol;
NTSTATUS status;
n = QueryNumMembers();
for (i = 0; i < n; i++) {
vol = GetMemberUnprotected(i);
if (!vol) {
*IsIoOk = FALSE;
return STATUS_SUCCESS;
}
status = vol->CheckIo(IsIoOk);
if (!NT_SUCCESS(status)) {
return status;
}
if (!(*IsIoOk)) {
return STATUS_SUCCESS;
}
}
return STATUS_SUCCESS;
}
#ifdef ALLOC_PRAGMA
#pragma code_seg("PAGELK")
#endif
REDISTRIBUTION::~REDISTRIBUTION(
)
{
}
VOID
RedistributionTwoPartCompletionRoutine(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This routine is the completion of a two part operation.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP transferPacket = (PREDISTRIBUTION_TP) TransferPacket;
PREDISTRIBUTION_LOCK_TP lockPacket = (PREDISTRIBUTION_LOCK_TP) transferPacket->MasterPacket;
PTRANSFER_PACKET masterPacket = lockPacket->MasterPacket;
NTSTATUS status = transferPacket->IoStatus.Status;
KIRQL irql;
LONG count;
KeAcquireSpinLock(&lockPacket->SpinLock, &irql);
if (NT_SUCCESS(status)) {
if (NT_SUCCESS(lockPacket->IoStatus.Status)) {
lockPacket->IoStatus.Information +=
transferPacket->IoStatus.Information;
}
} else {
if (FtpIsWorseStatus(status, lockPacket->IoStatus.Status)) {
lockPacket->IoStatus.Status = status;
}
}
count = --lockPacket->RefCount;
KeReleaseSpinLock(&lockPacket->SpinLock, irql);
delete transferPacket;
if (!count) {
masterPacket->IoStatus = lockPacket->IoStatus;
delete lockPacket;
masterPacket->CompletionRoutine(masterPacket);
}
}
VOID
RedistributionRegionLockCompletion(
IN OUT PTRANSFER_PACKET LockPacket
)
/*++
Routine Description:
This routine is the completion of a region lock operation.
Arguments:
LockPacket - Supplies the lock packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_LOCK_TP lockPacket = (PREDISTRIBUTION_LOCK_TP) LockPacket;
PREDISTRIBUTION t = lockPacket->Redistribution;
PTRANSFER_PACKET masterPacket = lockPacket->MasterPacket;
KIRQL irql;
LONGLONG bytesRedistributed;
LONGLONG redistOffset, regularOffset;
ULONG redistLength, regularLength;
PREDISTRIBUTION_TP redistPacket, regularPacket;
PCHAR vp;
KeAcquireSpinLock(&t->_spinLock, &irql);
bytesRedistributed = t->_state.BytesRedistributed;
KeReleaseSpinLock(&t->_spinLock, irql);
if (lockPacket->Offset < bytesRedistributed) {
redistOffset = lockPacket->Offset;
redistLength = lockPacket->Length;
if (redistOffset + redistLength > bytesRedistributed) {
redistLength = (ULONG) (bytesRedistributed - redistOffset);
}
} else {
redistLength = 0;
}
if (redistLength < lockPacket->Length) {
regularLength = lockPacket->Length - redistLength;
regularOffset = lockPacket->Offset + redistLength;
} else {
regularLength = 0;
}
KeInitializeSpinLock(&lockPacket->SpinLock);
lockPacket->IoStatus.Status = STATUS_SUCCESS;
lockPacket->IoStatus.Information = 0;
lockPacket->RefCount = 0;
if (lockPacket->Mdl && redistLength && regularLength) {
vp = (PCHAR) MmGetMdlVirtualAddress(lockPacket->Mdl);
}
if (redistLength) {
lockPacket->RefCount++;
redistPacket = new REDISTRIBUTION_TP;
if (!redistPacket) {
delete lockPacket;
masterPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
masterPacket->IoStatus.Information = 0;
masterPacket->CompletionRoutine(masterPacket);
return;
}
if (regularLength) {
if (lockPacket->Mdl) {
if (redistPacket->AllocateMdl(vp, redistLength)) {
IoBuildPartialMdl(lockPacket->Mdl, redistPacket->Mdl,
vp, redistLength);
} else {
delete redistPacket;
delete lockPacket;
masterPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
masterPacket->IoStatus.Information = 0;
masterPacket->CompletionRoutine(masterPacket);
return;
}
} else {
redistPacket->Mdl = lockPacket->Mdl;
}
} else {
redistPacket->Mdl = lockPacket->Mdl;
}
redistPacket->Length = redistLength;
redistPacket->Offset = redistOffset;
redistPacket->CompletionRoutine = RedistributionTwoPartCompletionRoutine;
redistPacket->TargetVolume = t;
redistPacket->Thread = lockPacket->Thread;
redistPacket->IrpFlags = lockPacket->IrpFlags;
redistPacket->ReadPacket = lockPacket->ReadPacket;
redistPacket->MasterPacket = lockPacket;
redistPacket->Redistribution = t;
redistPacket->WhichMember = 0;
}
if (regularLength) {
lockPacket->RefCount++;
regularPacket = new REDISTRIBUTION_TP;
if (!regularPacket) {
if (redistLength) {
delete redistPacket;
}
delete lockPacket;
masterPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
masterPacket->IoStatus.Information = 0;
masterPacket->CompletionRoutine(masterPacket);
return;
}
if (redistLength) {
if (lockPacket->Mdl) {
if (regularPacket->AllocateMdl(vp, regularLength)) {
IoBuildPartialMdl(lockPacket->Mdl, regularPacket->Mdl,
vp, regularLength);
} else {
if (redistLength) {
delete redistPacket;
}
delete regularPacket;
delete lockPacket;
masterPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
masterPacket->IoStatus.Information = 0;
masterPacket->CompletionRoutine(masterPacket);
return;
}
} else {
regularPacket->Mdl = lockPacket->Mdl;
}
} else {
regularPacket->Mdl = lockPacket->Mdl;
}
regularPacket->Length = regularLength;
regularPacket->Offset = regularOffset;
regularPacket->CompletionRoutine = RedistributionTwoPartCompletionRoutine;
regularPacket->TargetVolume = t->GetMemberUnprotected(0);
regularPacket->Thread = lockPacket->Thread;
regularPacket->IrpFlags = lockPacket->IrpFlags;
regularPacket->ReadPacket = lockPacket->ReadPacket;
regularPacket->MasterPacket = lockPacket;
regularPacket->Redistribution = t;
regularPacket->WhichMember = 0;
}
if (redistLength) {
t->RedistributeTransfer(redistPacket);
}
if (regularLength) {
TRANSFER(regularPacket);
}
}
VOID
REDISTRIBUTION::Transfer(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
Transfer routine for REDISTRIBUTION type FT_VOLUME. Figure out
which volumes this request needs to be dispatched to.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_LOCK_TP lockPacket;
if (!_redistributionComplete) {
if (TransferPacket->Offset + TransferPacket->Length > _firstSize) {
TransferPacket->IoStatus.Status = STATUS_INVALID_PARAMETER;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
lockPacket = new REDISTRIBUTION_LOCK_TP;
if (!lockPacket) {
TransferPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
lockPacket->Mdl = TransferPacket->Mdl;
lockPacket->Length = TransferPacket->Length;
lockPacket->Offset = TransferPacket->Offset;
lockPacket->CompletionRoutine = RedistributionRegionLockCompletion;
lockPacket->TargetVolume = TransferPacket->TargetVolume;
lockPacket->Thread = TransferPacket->Thread;
lockPacket->IrpFlags = TransferPacket->IrpFlags;
lockPacket->ReadPacket = TransferPacket->ReadPacket;
lockPacket->MasterPacket = TransferPacket;
lockPacket->Redistribution = this;
_overlappedIoManager.AcquireIoRegion(lockPacket, TRUE);
return;
}
if (TransferPacket->Offset + TransferPacket->Length > _totalSize) {
TransferPacket->IoStatus.Status = STATUS_INVALID_PARAMETER;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
RedistributeTransfer(TransferPacket);
}
VOID
RedistributionReplaceCompletion(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a replace request.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_LOCK_TP transferPacket = (PREDISTRIBUTION_LOCK_TP) TransferPacket;
PTRANSFER_PACKET masterPacket = transferPacket->MasterPacket;
masterPacket->IoStatus = transferPacket->IoStatus;
delete transferPacket;
masterPacket->CompletionRoutine(masterPacket);
}
VOID
RedistributionLockReplaceCompletion(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a lock request.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_LOCK_TP transferPacket = (PREDISTRIBUTION_LOCK_TP) TransferPacket;
PREDISTRIBUTION t = transferPacket->Redistribution;
KIRQL irql;
LONGLONG bytesRedistributed;
KeAcquireSpinLock(&t->_spinLock, &irql);
bytesRedistributed = t->_state.BytesRedistributed;
KeReleaseSpinLock(&t->_spinLock, irql);
transferPacket->CompletionRoutine = RedistributionReplaceCompletion;
if (transferPacket->Offset < bytesRedistributed) {
t->RedistributeReplaceBadSector(transferPacket);
} else {
transferPacket->TargetVolume = t->GetMemberUnprotected(0);
transferPacket->TargetVolume->ReplaceBadSector(transferPacket);
}
}
VOID
REDISTRIBUTION::ReplaceBadSector(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This routine attempts to fix the given bad sector by routing
the request to the appropriate sub-volume.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_LOCK_TP lockPacket;
if (!_redistributionComplete) {
if (TransferPacket->Offset + TransferPacket->Length > _firstSize) {
TransferPacket->IoStatus.Status = STATUS_INVALID_PARAMETER;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
lockPacket = new REDISTRIBUTION_LOCK_TP;
if (!lockPacket) {
TransferPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
lockPacket->Mdl = TransferPacket->Mdl;
lockPacket->Length = TransferPacket->Length;
lockPacket->Offset = TransferPacket->Offset;
lockPacket->CompletionRoutine = RedistributionLockReplaceCompletion;
lockPacket->TargetVolume = TransferPacket->TargetVolume;
lockPacket->Thread = TransferPacket->Thread;
lockPacket->IrpFlags = TransferPacket->IrpFlags;
lockPacket->ReadPacket = TransferPacket->ReadPacket;
lockPacket->MasterPacket = TransferPacket;
lockPacket->Redistribution = this;
_overlappedIoManager.AcquireIoRegion(lockPacket, TRUE);
return;
}
if (TransferPacket->Offset + TransferPacket->Length > _totalSize) {
TransferPacket->IoStatus.Status = STATUS_INVALID_PARAMETER;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
RedistributeReplaceBadSector(TransferPacket);
}
VOID
RedistributionCompositeVolumeCompletionRoutine(
IN PVOID Context,
IN NTSTATUS Status
)
{
PFT_COMPLETION_ROUTINE_CONTEXT context;
KIRQL irql;
LONG count;
context = (PFT_COMPLETION_ROUTINE_CONTEXT) Context;
KeAcquireSpinLock(&context->SpinLock, &irql);
if (!NT_SUCCESS(Status) && FtpIsWorseStatus(Status, context->Status)) {
context->Status = Status;
}
count = --context->RefCount;
KeReleaseSpinLock(&context->SpinLock, irql);
if (!count) {
context->CompletionRoutine(context->Context, STATUS_SUCCESS);
ExFreePool(context);
}
}
VOID
RedistributionSyncPhase6(
IN OUT PVOID SyncPacket,
IN NTSTATUS Status
)
/*++
Routine Description:
This is the completion routine for the update state part of a sync.
Arguments:
SyncPacket - Supplies the transfer packet.
Status - Supplies the status.
Return Value:
None.
--*/
{
PREDISTRIBUTION_SYNC_TP syncPacket = (PREDISTRIBUTION_SYNC_TP) SyncPacket;
PREDISTRIBUTION_TP ioPacket = &syncPacket->IoPacket;
PREDISTRIBUTION t = syncPacket->Redistribution;
KIRQL irql;
BOOLEAN allDone;
if (!NT_SUCCESS(Status)) {
KeAcquireSpinLock(&t->_spinLock, &irql);
t->_state.BytesRedistributed -= ioPacket->Length;
t->_syncOk = TRUE;
KeReleaseSpinLock(&t->_spinLock, irql);
t->_overlappedIoManager.ReleaseIoRegion(syncPacket);
RedistributionCompositeVolumeCompletionRoutine(syncPacket->Context,
STATUS_SUCCESS);
delete syncPacket;
return;
}
if (t->_state.BytesRedistributed == t->_firstSize) {
t->_redistributionComplete = TRUE;
allDone = TRUE;
} else {
allDone = FALSE;
}
t->_overlappedIoManager.ReleaseIoRegion(syncPacket);
if (allDone) {
RedistributionCompositeVolumeCompletionRoutine(syncPacket->Context,
STATUS_SUCCESS);
delete syncPacket;
return;
}
syncPacket->Offset = t->_state.BytesRedistributed;
t->_overlappedIoManager.AcquireIoRegion(syncPacket, TRUE);
}
VOID
RedistributionSyncPhase5(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for the write verify part of a sync.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP ioPacket = (PREDISTRIBUTION_TP) TransferPacket;
PREDISTRIBUTION_SYNC_TP syncPacket = (PREDISTRIBUTION_SYNC_TP) ioPacket->MasterPacket;
PREDISTRIBUTION t = syncPacket->Redistribution;
NTSTATUS status = ioPacket->IoStatus.Status;
KIRQL irql;
if (FsRtlIsTotalDeviceFailure(status)) {
KeAcquireSpinLock(&t->_spinLock, &irql);
t->_syncOk = TRUE;
KeReleaseSpinLock(&t->_spinLock, irql);
RedistributionCompositeVolumeCompletionRoutine(syncPacket->Context,
status);
delete syncPacket;
return;
}
if (!NT_SUCCESS(status)) {
KeAcquireSpinLock(&t->_spinLock, &irql);
t->_syncOk = TRUE;
KeReleaseSpinLock(&t->_spinLock, irql);
RedistributionCompositeVolumeCompletionRoutine(syncPacket->Context, status);
delete syncPacket;
FtpLogError(t->_rootExtension, t->QueryLogicalDiskId(),
FT_REDISTRIBUTION_ERROR, status, 0);
return;
}
KeAcquireSpinLock(&t->_spinLock, &irql);
t->_state.BytesRedistributed += ioPacket->Length;
KeReleaseSpinLock(&t->_spinLock, irql);
t->PropogateStateChanges(RedistributionSyncPhase6, syncPacket);
}
VOID
RedistributionSyncPhase4(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for the verify write part of a sync.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP ioPacket = (PREDISTRIBUTION_TP) TransferPacket;
PREDISTRIBUTION_SYNC_TP syncPacket = (PREDISTRIBUTION_SYNC_TP) ioPacket->MasterPacket;
PREDISTRIBUTION t = syncPacket->Redistribution;
NTSTATUS status = ioPacket->IoStatus.Status;
KIRQL irql;
if (FsRtlIsTotalDeviceFailure(status)) {
KeAcquireSpinLock(&t->_spinLock, &irql);
t->_syncOk = TRUE;
KeReleaseSpinLock(&t->_spinLock, irql);
RedistributionCompositeVolumeCompletionRoutine(syncPacket->Context,
status);
delete syncPacket;
return;
}
if (!NT_SUCCESS(status)) {
ioPacket->CompletionRoutine = RedistributionSyncPhase5;
t->CarefulWrite(ioPacket);
return;
}
KeAcquireSpinLock(&t->_spinLock, &irql);
t->_state.BytesRedistributed += ioPacket->Length;
KeReleaseSpinLock(&t->_spinLock, irql);
t->PropogateStateChanges(RedistributionSyncPhase6, syncPacket);
}
VOID
RedistributionSyncPhase3(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for the initial write part of a sync.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP ioPacket = (PREDISTRIBUTION_TP) TransferPacket;
PREDISTRIBUTION_SYNC_TP syncPacket = (PREDISTRIBUTION_SYNC_TP) ioPacket->MasterPacket;
PREDISTRIBUTION t = syncPacket->Redistribution;
NTSTATUS status = ioPacket->IoStatus.Status;
KIRQL irql;
if (FsRtlIsTotalDeviceFailure(status)) {
KeAcquireSpinLock(&t->_spinLock, &irql);
t->_syncOk = TRUE;
KeReleaseSpinLock(&t->_spinLock, irql);
RedistributionCompositeVolumeCompletionRoutine(syncPacket->Context,
status);
delete syncPacket;
return;
}
if (!NT_SUCCESS(status)) {
ioPacket->CompletionRoutine = RedistributionSyncPhase5;
t->CarefulWrite(ioPacket);
return;
}
ioPacket->CompletionRoutine = RedistributionSyncPhase4;
t->VerifyWrite(ioPacket);
}
VOID
RedistributionSyncPhase2(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for the read part of a sync.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP ioPacket = (PREDISTRIBUTION_TP) TransferPacket;
PREDISTRIBUTION_SYNC_TP syncPacket = (PREDISTRIBUTION_SYNC_TP) ioPacket->MasterPacket;
PREDISTRIBUTION t = syncPacket->Redistribution;
NTSTATUS status = ioPacket->IoStatus.Status;
LONGLONG rowSize, rowNum, rowOffset, firstSize;
KIRQL irql;
KeAcquireSpinLock(&t->_spinLock, &irql);
if (t->_stopSyncs) {
t->_syncOk = TRUE;
KeReleaseSpinLock(&t->_spinLock, irql);
RedistributionCompositeVolumeCompletionRoutine(syncPacket->Context,
STATUS_SUCCESS);
delete syncPacket;
return;
}
KeReleaseSpinLock(&t->_spinLock, irql);
if (FsRtlIsTotalDeviceFailure(status)) {
KeAcquireSpinLock(&t->_spinLock, &irql);
t->_syncOk = TRUE;
KeReleaseSpinLock(&t->_spinLock, irql);
RedistributionCompositeVolumeCompletionRoutine(syncPacket->Context,
status);
delete syncPacket;
return;
}
if (!NT_SUCCESS(status)) {
t->MaxTransfer(ioPacket);
return;
}
rowSize = t->_totalWidth*t->_stripeSize;
rowNum = ioPacket->Offset/rowSize;
rowOffset = ioPacket->Offset%rowSize;
firstSize = t->_firstWidth*t->_stripeSize;
ioPacket->CompletionRoutine = RedistributionSyncPhase3;
ioPacket->ReadPacket = FALSE;
if (rowOffset < firstSize) {
ioPacket->Offset = rowNum*firstSize + rowOffset;
} else {
ioPacket->Offset = rowNum*(rowSize - firstSize) + rowOffset - firstSize;
ioPacket->TargetVolume = t->GetMemberUnprotected(1);
ioPacket->WhichMember = 1;
}
TRANSFER(ioPacket);
}
VOID
RedistributionSyncPhase1(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for the lock part of a sync.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_SYNC_TP syncPacket = (PREDISTRIBUTION_SYNC_TP) TransferPacket;
PREDISTRIBUTION t = syncPacket->Redistribution;
PREDISTRIBUTION_TP packet = &syncPacket->IoPacket;
packet->Offset = t->_state.BytesRedistributed;
if (packet->Offset + packet->Length > t->_firstSize) {
packet->Length = (ULONG) (t->_firstSize - packet->Offset);
}
packet->CompletionRoutine = RedistributionSyncPhase2;
packet->TargetVolume = t->GetMemberUnprotected(0);
packet->Thread = PsGetCurrentThread();
packet->ReadPacket = TRUE;
packet->WhichMember = 0;
TRANSFER(packet);
}
VOID
REDISTRIBUTION::StartSyncOperations(
IN BOOLEAN RegenerateOrphans,
IN FT_COMPLETION_ROUTINE CompletionRoutine,
IN PVOID Context
)
/*++
Routine Description:
This routine starts off the redistribution of the data.
Arguments:
RegenerateOrphans - Supplies whether or not to try and regenerate
orphaned members.
CompletionRoutine - Supplies the completion routine.
Context - Supplies the context for the completion routine.
Return Value:
None.
--*/
{
PFT_COMPLETION_ROUTINE_CONTEXT context;
PREDISTRIBUTION_SYNC_TP syncPacket;
KIRQL irql;
PREDISTRIBUTION_TP packet;
if (_redistributionComplete) {
COMPOSITE_FT_VOLUME::StartSyncOperations(RegenerateOrphans,
CompletionRoutine, Context);
return;
}
context = (PFT_COMPLETION_ROUTINE_CONTEXT)
ExAllocatePool(NonPagedPool,
sizeof(FT_COMPLETION_ROUTINE_CONTEXT));
if (!context) {
CompletionRoutine(Context, STATUS_INSUFFICIENT_RESOURCES);
return;
}
syncPacket = new REDISTRIBUTION_SYNC_TP;
if (!syncPacket) {
ExFreePool(context);
CompletionRoutine(Context, STATUS_INSUFFICIENT_RESOURCES);
return;
}
if (!syncPacket->IoPacket.AllocateMdl(_stripeSize)) {
delete syncPacket;
ExFreePool(context);
CompletionRoutine(Context, STATUS_INSUFFICIENT_RESOURCES);
return;
}
KeInitializeSpinLock(&context->SpinLock);
context->Status = STATUS_SUCCESS;
context->RefCount = 2;
context->CompletionRoutine = CompletionRoutine;
context->Context = Context;
context->ParentVolume = this;
COMPOSITE_FT_VOLUME::StartSyncOperations(
RegenerateOrphans, RedistributionCompositeVolumeCompletionRoutine,
context);
KeAcquireSpinLock(&_spinLock, &irql);
if (_syncOk) {
_syncOk = FALSE;
_stopSyncs = FALSE;
} else {
KeReleaseSpinLock(&_spinLock, irql);
RedistributionCompositeVolumeCompletionRoutine(context, STATUS_SUCCESS);
return;
}
KeReleaseSpinLock(&_spinLock, irql);
syncPacket->Mdl = NULL;
syncPacket->Offset = _state.BytesRedistributed;
syncPacket->Length = _stripeSize;
syncPacket->CompletionRoutine = RedistributionSyncPhase1;
syncPacket->TargetVolume = this;
syncPacket->Thread = PsGetCurrentThread();
syncPacket->IrpFlags = SL_OVERRIDE_VERIFY_VOLUME;
syncPacket->ReadPacket = TRUE;
syncPacket->Context = context;
syncPacket->Redistribution = this;
packet = &syncPacket->IoPacket;
packet->Length = _stripeSize;
packet->IrpFlags = SL_OVERRIDE_VERIFY_VOLUME;
packet->MasterPacket = syncPacket;
packet->Redistribution = this;
_overlappedIoManager.AcquireIoRegion(syncPacket, TRUE);
}
VOID
REDISTRIBUTION::StopSyncOperations(
)
/*++
Routine Description:
This routine stops all sync operations.
Arguments:
None.
Return Value:
None.
--*/
{
KIRQL irql;
COMPOSITE_FT_VOLUME::StopSyncOperations();
KeAcquireSpinLock(&_spinLock, &irql);
_stopSyncs = TRUE;
KeReleaseSpinLock(&_spinLock, irql);
}
LONGLONG
REDISTRIBUTION::QueryVolumeSize(
)
/*++
Routine Description:
Returns the number of bytes on the entire volume.
Arguments:
None.
Return Value:
The volume size in bytes.
--*/
{
return _redistributionComplete ? _totalSize : _firstSize;
}
VOID
REDISTRIBUTION::CompleteNotification(
IN BOOLEAN IoPending
)
/*++
Routine Description:
This routine is called to notify the volume that it is complete and
to therefore prepare for incoming requests.
Arguments:
IoPending - Supplies whether or not there is IO pending.
Return Value:
None.
--*/
{
LONGLONG firstRowSize, numRows, secondRowSize, tmpNumRows;
COMPOSITE_FT_VOLUME::CompleteNotification(IoPending);
_firstSize = GetMember(0)->QueryVolumeSize();
firstRowSize = _firstWidth*_stripeSize;
numRows = _firstSize/firstRowSize;
secondRowSize = (_totalWidth - _firstWidth)*_stripeSize;
tmpNumRows = GetMember(1)->QueryVolumeSize()/secondRowSize;
if (tmpNumRows < numRows) {
numRows = tmpNumRows;
}
_totalSize = numRows*_totalWidth*_stripeSize;
if (_state.BytesRedistributed >= _firstSize) {
_redistributionComplete = TRUE;
}
}
VOID
REDISTRIBUTION::NewStateArrival(
IN PVOID NewStateInstance
)
/*++
Routine Description:
This routine takes the new state instance arrival combined with its
current state to come up with the new current state for the volume.
If the two states cannot be reconciled then this routine returns FALSE
indicating that the volume is invalid and should be broken into its
constituant parts.
Arguments:
NewStateInstance - Supplies the new state instance.
Return Value:
None.
--*/
{
BOOLEAN changed = FALSE;
PFT_REDISTRIBUTION_STATE_INFORMATION state;
state = (PFT_REDISTRIBUTION_STATE_INFORMATION) NewStateInstance;
if (state->BytesRedistributed > _state.BytesRedistributed) {
_state.BytesRedistributed = state->BytesRedistributed;
changed = TRUE;
}
if (changed) {
PropogateStateChanges(NULL, NULL);
}
}
VOID
RedistributionTransferCompletionRoutine(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
Completion routine for REDISTRIBUTION::RedistributionDispatch.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP transferPacket = (PREDISTRIBUTION_TP) TransferPacket;
PTRANSFER_PACKET masterPacket = transferPacket->MasterPacket;
NTSTATUS status = transferPacket->IoStatus.Status;
KIRQL irql;
if (!NT_SUCCESS(status)) {
KeAcquireSpinLock(&masterPacket->SpinLock, &irql);
if (FtpIsWorseStatus(status, masterPacket->IoStatus.Status)) {
masterPacket->IoStatus.Status = status;
}
KeReleaseSpinLock(&masterPacket->SpinLock, irql);
}
delete transferPacket;
if (!InterlockedDecrement(&masterPacket->RefCount)) {
masterPacket->CompletionRoutine(masterPacket);
}
}
VOID
REDISTRIBUTION::RedistributeTransfer(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This routine launches the given transfer packet using the new
redistributed data allocation scheme.
Arguments:
TransferPacket - Supplies the transfer packet to launch.
Return Value:
None.
--*/
{
LONGLONG begin, end;
LONGLONG rowSize, firstSize, rowBegin, rowOffsetBegin, rowEnd, rowOffsetEnd;
ULONG numRequests, i, numRows;
PCHAR vp;
LIST_ENTRY q;
LONGLONG off, off2;
ULONG len, len2;
USHORT whichMember;
BOOLEAN two;
PREDISTRIBUTION_TP p;
PLIST_ENTRY l;
begin = TransferPacket->Offset;
end = TransferPacket->Offset + TransferPacket->Length;
rowSize = _totalWidth*_stripeSize;
rowBegin = begin/rowSize;
rowOffsetBegin = begin%rowSize;
rowEnd = end/rowSize;
rowOffsetEnd = end%rowSize;
firstSize = _firstWidth*_stripeSize;
if (TransferPacket->Mdl) {
vp = (PCHAR) MmGetMdlVirtualAddress(TransferPacket->Mdl);
}
InitializeListHead(&q);
numRows = (ULONG) (rowEnd - rowBegin + 1);
numRequests = 0;
for (i = 0; i < numRows; i++) {
if (i == 0) {
if (numRows == 1) {
if (rowOffsetBegin < firstSize) {
if (rowOffsetEnd > firstSize) {
two = TRUE;
whichMember = 0;
off = rowBegin*firstSize + rowOffsetBegin;
len = (ULONG) (firstSize - rowOffsetBegin);
off2 = rowBegin*(rowSize - firstSize);
len2 = (ULONG) (rowOffsetEnd - firstSize);
} else {
two = FALSE;
whichMember = 0;
off = rowBegin*firstSize + rowOffsetBegin;
len = (ULONG) (rowOffsetEnd - rowOffsetBegin);
}
} else {
two = FALSE;
whichMember = 1;
off = rowBegin*(rowSize - firstSize) + rowOffsetBegin -
firstSize;
len = (ULONG) (rowOffsetEnd - rowOffsetBegin);
}
} else {
if (rowOffsetBegin < firstSize) {
two = TRUE;
whichMember = 0;
off = rowBegin*firstSize + rowOffsetBegin;
len = (ULONG) (firstSize - rowOffsetBegin);
off2 = rowBegin*(rowSize - firstSize);
len2 = (ULONG) (rowSize - firstSize);
} else {
two = FALSE;
whichMember = 1;
off = rowBegin*(rowSize - firstSize) + rowOffsetBegin -
firstSize;
len = (ULONG) (rowSize - rowOffsetBegin);
}
}
} else if (i == numRows - 1) {
if (!rowOffsetEnd) {
continue;
}
if (rowOffsetEnd > firstSize) {
two = TRUE;
whichMember = 0;
off = rowEnd*firstSize;
len = (ULONG) firstSize;
off2 = rowEnd*(rowSize - firstSize);
len2 = (ULONG) (rowOffsetEnd - firstSize);
} else {
two = FALSE;
whichMember = 0;
off = rowEnd*firstSize;
len = (ULONG) rowOffsetEnd;
}
} else {
two = TRUE;
whichMember = 0;
len = (ULONG) firstSize;
len2 = (ULONG) (rowSize - firstSize);
off = (rowBegin + i)*len;
off2 = (rowBegin + i)*len2;
}
p = new REDISTRIBUTION_TP;
if (!p) {
break;
}
if (!two && numRows == 1) {
p->Mdl = TransferPacket->Mdl;
} else {
if (TransferPacket->Mdl) {
if (p->AllocateMdl(vp, len)) {
IoBuildPartialMdl(TransferPacket->Mdl, p->Mdl, vp, len);
} else {
delete p;
break;
}
vp += len;
} else {
p->Mdl = TransferPacket->Mdl;
}
}
p->Length = len;
p->Offset = off;
p->CompletionRoutine = RedistributionTransferCompletionRoutine;
p->TargetVolume = GetMemberUnprotected(whichMember);
p->Thread = TransferPacket->Thread;
p->IrpFlags = TransferPacket->IrpFlags;
p->ReadPacket = TransferPacket->ReadPacket;
p->SpecialRead = TransferPacket->SpecialRead;
p->MasterPacket = TransferPacket;
p->Redistribution = this;
p->WhichMember = whichMember;
InsertTailList(&q, &p->QueueEntry);
numRequests++;
if (!two) {
continue;
}
p = new REDISTRIBUTION_TP;
if (!p) {
break;
}
if (TransferPacket->Mdl) {
if (p->AllocateMdl(vp, len2)) {
IoBuildPartialMdl(TransferPacket->Mdl, p->Mdl, vp, len2);
} else {
delete p;
break;
}
vp += len2;
} else {
p->Mdl = TransferPacket->Mdl;
}
p->Length = len2;
p->Offset = off2;
p->CompletionRoutine = RedistributionTransferCompletionRoutine;
p->TargetVolume = GetMemberUnprotected(1);
p->Thread = TransferPacket->Thread;
p->IrpFlags = TransferPacket->IrpFlags;
p->ReadPacket = TransferPacket->ReadPacket;
p->SpecialRead = TransferPacket->SpecialRead;
p->MasterPacket = TransferPacket;
p->Redistribution = this;
p->WhichMember = 1;
InsertTailList(&q, &p->QueueEntry);
numRequests++;
}
if (i < numRows) {
while (!IsListEmpty(&q)) {
l = RemoveHeadList(&q);
p = CONTAINING_RECORD(l, REDISTRIBUTION_TP, QueueEntry);
delete p;
}
TransferPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
KeInitializeSpinLock(&TransferPacket->SpinLock);
TransferPacket->IoStatus.Status = STATUS_SUCCESS;
TransferPacket->IoStatus.Information = TransferPacket->Length;
TransferPacket->RefCount = numRequests;
while (!IsListEmpty(&q)) {
l = RemoveHeadList(&q);
p = CONTAINING_RECORD(l, REDISTRIBUTION_TP, QueueEntry);
TRANSFER(p);
}
}
VOID
RedistributeReplaceBadSectorCompletion(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
Completion routine for REDISTRIBUTION::RedistributionReplaceBadSector.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP transferPacket = (PREDISTRIBUTION_TP) TransferPacket;
PTRANSFER_PACKET masterPacket = transferPacket->MasterPacket;
masterPacket->IoStatus = transferPacket->IoStatus;
delete transferPacket;
masterPacket->CompletionRoutine(masterPacket);
}
VOID
REDISTRIBUTION::RedistributeReplaceBadSector(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This routine launches the given transfer packet using the new
redistributed data allocation scheme.
Arguments:
TransferPacket - Supplies the transfer packet to launch.
Return Value:
None.
--*/
{
LONGLONG begin, rowSize, rowBegin, rowOffsetBegin, firstSize, offset;
USHORT whichMember;
PREDISTRIBUTION_TP p;
begin = TransferPacket->Offset;
rowSize = _totalWidth*_stripeSize;
rowBegin = begin/rowSize;
rowOffsetBegin = begin%rowSize;
firstSize = _firstWidth*_stripeSize;
if (rowOffsetBegin < firstSize) {
offset = rowBegin*firstSize + rowOffsetBegin;
whichMember = 0;
} else {
offset = rowBegin*(rowSize - firstSize) + rowOffsetBegin - firstSize;
whichMember = 1;
}
p = new REDISTRIBUTION_TP;
if (!p) {
TransferPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
p->Mdl = TransferPacket->Mdl;
p->Length = TransferPacket->Length;
p->Offset = offset;
p->CompletionRoutine = RedistributeReplaceBadSectorCompletion;
p->TargetVolume = GetMemberUnprotected(whichMember);
p->Thread = TransferPacket->Thread;
p->IrpFlags = TransferPacket->IrpFlags;
p->ReadPacket = TransferPacket->ReadPacket;
p->SpecialRead = TransferPacket->SpecialRead;
p->MasterPacket = TransferPacket;
p->Redistribution = this;
p->WhichMember = whichMember;
p->TargetVolume->ReplaceBadSector(p);
}
VOID
RedistributionPropogateStateChangesWorker(
IN PVOID WorkItem
)
/*++
Routine Description:
This routine is a worker thread routine for propogating state changes.
Arguments:
Mirror - Supplies a pointer to the mirror object.
Return Value:
None.
--*/
{
PPROPOGATE_CHANGES_WORK_ITEM workItem = (PPROPOGATE_CHANGES_WORK_ITEM) WorkItem;
PREDISTRIBUTION t = workItem->Redistribution;
NTSTATUS status;
KIRQL irql;
FT_REDISTRIBUTION_STATE_INFORMATION state;
status = FtpAcquireWithTimeout(t->_rootExtension);
if (!NT_SUCCESS(status)) {
if (workItem->CompletionRoutine) {
workItem->CompletionRoutine(workItem->Context, status);
}
return;
}
KeAcquireSpinLock(&t->_spinLock, &irql);
RtlCopyMemory(&state, &t->_state, sizeof(state));
KeReleaseSpinLock(&t->_spinLock, irql);
status = t->_diskInfoSet->WriteStateInformation(t->QueryLogicalDiskId(),
&state, sizeof(state));
FtpRelease(t->_rootExtension);
if (workItem->CompletionRoutine) {
workItem->CompletionRoutine(workItem->Context, status);
}
}
VOID
REDISTRIBUTION::PropogateStateChanges(
IN FT_COMPLETION_ROUTINE CompletionRoutine,
IN PVOID Context
)
/*++
Routine Description:
This routine propogates the changes in the local memory state to
the on disk state.
Arguments:
CompletionRoutine - Supplies the completion routine.
Context - Supplies the context.
Return Value:
None.
--*/
{
PPROPOGATE_CHANGES_WORK_ITEM workItem;
workItem = (PPROPOGATE_CHANGES_WORK_ITEM)
ExAllocatePool(NonPagedPool,
sizeof(PROPOGATE_CHANGES_WORK_ITEM));
if (!workItem) {
return;
}
workItem->Redistribution = this;
workItem->CompletionRoutine = CompletionRoutine;
workItem->Context = Context;
ExInitializeWorkItem(workItem, RedistributionPropogateStateChangesWorker,
workItem);
FtpQueueWorkItem(_rootExtension, workItem);
}
VOID
RedistributionMaxTransferCompletionRoutine(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a sector transfer subordinate
to a MAX transfer operation.
Arguments:
TransferPacket - Supplies the subordinate transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP subPacket = (PREDISTRIBUTION_TP) TransferPacket;
PREDISTRIBUTION_TP masterPacket = (PREDISTRIBUTION_TP) subPacket->MasterPacket;
NTSTATUS status = subPacket->IoStatus.Status;
if (FsRtlIsTotalDeviceFailure(status)) {
masterPacket->IoStatus = subPacket->IoStatus;
delete subPacket;
masterPacket->CompletionRoutine(masterPacket);
return;
}
if (subPacket->Offset + subPacket->Length ==
masterPacket->Offset + masterPacket->Length) {
delete subPacket;
masterPacket->CompletionRoutine(masterPacket);
return;
}
subPacket->Offset += subPacket->Length;
MmPrepareMdlForReuse(subPacket->Mdl);
IoBuildPartialMdl(masterPacket->Mdl, subPacket->Mdl,
(PCHAR) MmGetMdlVirtualAddress(masterPacket->Mdl) +
(ULONG) (subPacket->Offset - masterPacket->Offset),
subPacket->Length);
TRANSFER(subPacket);
}
VOID
REDISTRIBUTION::MaxTransfer(
IN OUT PREDISTRIBUTION_TP TransferPacket
)
/*++
Routine Description:
This routine propogates sector by sector the given transfer packet,
ignoring errors.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP subPacket;
TransferPacket->IoStatus.Status = STATUS_SUCCESS;
TransferPacket->IoStatus.Information = TransferPacket->Length;
subPacket = new REDISTRIBUTION_TP;
if (!subPacket) {
TransferPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
subPacket->Length = QuerySectorSize();
subPacket->Offset = TransferPacket->Offset;
subPacket->CompletionRoutine = RedistributionMaxTransferCompletionRoutine;
subPacket->TargetVolume = TransferPacket->TargetVolume;
subPacket->Thread = TransferPacket->Thread;
subPacket->IrpFlags = TransferPacket->IrpFlags;
subPacket->ReadPacket = TransferPacket->ReadPacket;
subPacket->MasterPacket = TransferPacket;
subPacket->Redistribution = this;
subPacket->WhichMember = TransferPacket->WhichMember;
if (!subPacket->AllocateMdl((PVOID) (PAGE_SIZE - 1), subPacket->Length)) {
delete subPacket;
TransferPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
IoBuildPartialMdl(TransferPacket->Mdl, subPacket->Mdl,
MmGetMdlVirtualAddress(TransferPacket->Mdl),
subPacket->Length);
TRANSFER(subPacket);
}
VOID
RedistributionVerifyWriteCompletion(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a verify write operation.
Arguments:
TransferPacket - Supplies the subordinate transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP verifyPacket = (PREDISTRIBUTION_TP) TransferPacket;
PREDISTRIBUTION_TP masterPacket = (PREDISTRIBUTION_TP) verifyPacket->MasterPacket;
NTSTATUS status = verifyPacket->IoStatus.Status;
PVOID p, q;
ULONG l;
if (!NT_SUCCESS(status)) {
masterPacket->IoStatus = verifyPacket->IoStatus;
delete verifyPacket;
masterPacket->CompletionRoutine(masterPacket);
return;
}
p = MmGetSystemAddressForMdl(verifyPacket->Mdl);
q = MmGetSystemAddressForMdl(masterPacket->Mdl);
l = (ULONG)RtlCompareMemory(p, q, verifyPacket->Length);
if (l != verifyPacket->Length) {
masterPacket->IoStatus.Status = STATUS_DEVICE_DATA_ERROR;
masterPacket->IoStatus.Information = 0;
}
delete verifyPacket;
masterPacket->CompletionRoutine(masterPacket);
}
VOID
REDISTRIBUTION::VerifyWrite(
IN OUT PREDISTRIBUTION_TP TransferPacket
)
/*++
Routine Description:
This routine verifies that the given write was success by reading
and comparing.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_TP verifyPacket;
verifyPacket = new REDISTRIBUTION_TP;
if (!verifyPacket) {
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
if (!verifyPacket->AllocateMdl(TransferPacket->Length)) {
delete verifyPacket;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
verifyPacket->Length = TransferPacket->Length;
verifyPacket->Offset = TransferPacket->Offset;
verifyPacket->CompletionRoutine = RedistributionVerifyWriteCompletion;
verifyPacket->TargetVolume = TransferPacket->TargetVolume;
verifyPacket->Thread = TransferPacket->Thread;
verifyPacket->IrpFlags = TransferPacket->IrpFlags;
verifyPacket->ReadPacket = TRUE;
verifyPacket->MasterPacket = TransferPacket;
verifyPacket->Redistribution = this;
verifyPacket->WhichMember = TransferPacket->WhichMember;
TRANSFER(verifyPacket);
}
VOID
RedistributionCarefulWritePhase1(
IN OUT PTRANSFER_PACKET TransferPacket
);
VOID
RedistributionCarefulWritePhase5(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a sector read subordinate
to a carefule write operation after a replace bad sector.
Arguments:
TransferPacket - Supplies the subordinate transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_CW_TP subPacket = (PREDISTRIBUTION_CW_TP) TransferPacket;
PREDISTRIBUTION_TP masterPacket = (PREDISTRIBUTION_TP) subPacket->MasterPacket;
NTSTATUS status = subPacket->IoStatus.Status;
PVOID p, q;
ULONG l;
if (NT_SUCCESS(status)) {
p = MmGetSystemAddressForMdl(subPacket->PartialMdl);
q = MmGetSystemAddressForMdl(subPacket->VerifyMdl);
l = (ULONG)RtlCompareMemory(p, q, subPacket->Length);
} else {
l = 0;
}
if (l != subPacket->Length) {
masterPacket->IoStatus = subPacket->IoStatus;
delete subPacket;
masterPacket->CompletionRoutine(masterPacket);
return;
}
if (subPacket->Offset + subPacket->Length ==
masterPacket->Offset + masterPacket->Length) {
delete subPacket;
masterPacket->IoStatus.Status = STATUS_SUCCESS;
masterPacket->IoStatus.Information = masterPacket->Length;
masterPacket->CompletionRoutine(masterPacket);
return;
}
subPacket->Offset += subPacket->Length;
subPacket->CompletionRoutine = RedistributionCarefulWritePhase1;
subPacket->ReadPacket = FALSE;
subPacket->Mdl = subPacket->PartialMdl;
MmPrepareMdlForReuse(subPacket->Mdl);
IoBuildPartialMdl(masterPacket->Mdl, subPacket->Mdl,
(PCHAR) MmGetMdlVirtualAddress(masterPacket->Mdl) +
(ULONG) (subPacket->Offset - masterPacket->Offset),
subPacket->Length);
TRANSFER(subPacket);
}
VOID
RedistributionCarefulWritePhase4(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a sector write subordinate
to a carefule write operation after a sector replace operation.
Arguments:
TransferPacket - Supplies the subordinate transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_CW_TP subPacket = (PREDISTRIBUTION_CW_TP) TransferPacket;
PREDISTRIBUTION_TP masterPacket = (PREDISTRIBUTION_TP) subPacket->MasterPacket;
NTSTATUS status = subPacket->IoStatus.Status;
if (!NT_SUCCESS(status)) {
masterPacket->IoStatus = subPacket->IoStatus;
delete subPacket;
masterPacket->CompletionRoutine(masterPacket);
return;
}
subPacket->Mdl = subPacket->VerifyMdl;
subPacket->CompletionRoutine = RedistributionCarefulWritePhase5;
subPacket->ReadPacket = TRUE;
TRANSFER(subPacket);
}
VOID
RedistributionCarefulWritePhase3(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a sector replace subordinate
to a carefule write operation.
Arguments:
TransferPacket - Supplies the subordinate transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_CW_TP subPacket = (PREDISTRIBUTION_CW_TP) TransferPacket;
PREDISTRIBUTION_TP masterPacket = (PREDISTRIBUTION_TP) subPacket->MasterPacket;
subPacket->CompletionRoutine = RedistributionCarefulWritePhase4;
subPacket->ReadPacket = FALSE;
subPacket->Mdl = subPacket->PartialMdl;
MmPrepareMdlForReuse(subPacket->Mdl);
IoBuildPartialMdl(masterPacket->Mdl, subPacket->Mdl,
(PCHAR) MmGetMdlVirtualAddress(masterPacket->Mdl) +
(ULONG) (subPacket->Offset - masterPacket->Offset),
subPacket->Length);
TRANSFER(subPacket);
}
VOID
RedistributionCarefulWritePhase2(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a sector read subordinate
to a carefule write operation.
Arguments:
TransferPacket - Supplies the subordinate transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_CW_TP subPacket = (PREDISTRIBUTION_CW_TP) TransferPacket;
PREDISTRIBUTION_TP masterPacket = (PREDISTRIBUTION_TP) subPacket->MasterPacket;
NTSTATUS status = subPacket->IoStatus.Status;
PVOID p, q;
ULONG l;
if (FsRtlIsTotalDeviceFailure(status)) {
masterPacket->IoStatus = subPacket->IoStatus;
delete subPacket;
masterPacket->CompletionRoutine(masterPacket);
return;
}
if (NT_SUCCESS(status)) {
p = MmGetSystemAddressForMdl(subPacket->PartialMdl);
q = MmGetSystemAddressForMdl(subPacket->VerifyMdl);
l = (ULONG)RtlCompareMemory(p, q, subPacket->Length);
} else {
l = 0;
}
if (l != subPacket->Length) {
subPacket->CompletionRoutine = RedistributionCarefulWritePhase3;
subPacket->TargetVolume->ReplaceBadSector(subPacket);
return;
}
if (subPacket->Offset + subPacket->Length ==
masterPacket->Offset + masterPacket->Length) {
delete subPacket;
masterPacket->IoStatus.Status = STATUS_SUCCESS;
masterPacket->IoStatus.Information = masterPacket->Length;
masterPacket->CompletionRoutine(masterPacket);
return;
}
subPacket->Offset += subPacket->Length;
subPacket->CompletionRoutine = RedistributionCarefulWritePhase1;
subPacket->ReadPacket = FALSE;
subPacket->Mdl = subPacket->PartialMdl;
MmPrepareMdlForReuse(subPacket->Mdl);
IoBuildPartialMdl(masterPacket->Mdl, subPacket->Mdl,
(PCHAR) MmGetMdlVirtualAddress(masterPacket->Mdl) +
(ULONG) (subPacket->Offset - masterPacket->Offset),
subPacket->Length);
TRANSFER(subPacket);
}
VOID
RedistributionCarefulWritePhase1(
IN OUT PTRANSFER_PACKET TransferPacket
)
/*++
Routine Description:
This is the completion routine for a sector write subordinate
to a carefule write operation.
Arguments:
TransferPacket - Supplies the subordinate transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_CW_TP subPacket = (PREDISTRIBUTION_CW_TP) TransferPacket;
PREDISTRIBUTION_TP masterPacket = (PREDISTRIBUTION_TP) subPacket->MasterPacket;
NTSTATUS status = subPacket->IoStatus.Status;
if (FsRtlIsTotalDeviceFailure(status)) {
masterPacket->IoStatus = subPacket->IoStatus;
delete subPacket;
masterPacket->CompletionRoutine(masterPacket);
return;
}
if (!NT_SUCCESS(status)) {
subPacket->CompletionRoutine = RedistributionCarefulWritePhase3;
subPacket->TargetVolume->ReplaceBadSector(subPacket);
return;
}
subPacket->Mdl = subPacket->VerifyMdl;
subPacket->CompletionRoutine = RedistributionCarefulWritePhase2;
subPacket->ReadPacket = TRUE;
TRANSFER(subPacket);
}
VOID
REDISTRIBUTION::CarefulWrite(
IN OUT PREDISTRIBUTION_TP TransferPacket
)
/*++
Routine Description:
This routine writes the given packet, sector by sector, replacing
bad sectors if need be.
Arguments:
TransferPacket - Supplies the transfer packet.
Return Value:
None.
--*/
{
PREDISTRIBUTION_CW_TP subPacket;
ASSERT(!TransferPacket->ReadPacket);
subPacket = new REDISTRIBUTION_CW_TP;
if (!subPacket) {
TransferPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
subPacket->Length = QuerySectorSize();
subPacket->Offset = TransferPacket->Offset;
subPacket->CompletionRoutine = RedistributionCarefulWritePhase1;
subPacket->TargetVolume = TransferPacket->TargetVolume;
subPacket->Thread = TransferPacket->Thread;
subPacket->IrpFlags = TransferPacket->IrpFlags;
subPacket->ReadPacket = FALSE;
subPacket->MasterPacket = TransferPacket;
subPacket->Redistribution = TransferPacket->Redistribution;
subPacket->WhichMember = TransferPacket->WhichMember;
if (!subPacket->AllocateMdls(subPacket->Length)) {
delete subPacket;
TransferPacket->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
TransferPacket->IoStatus.Information = 0;
TransferPacket->CompletionRoutine(TransferPacket);
return;
}
subPacket->Mdl = subPacket->PartialMdl;
IoBuildPartialMdl(TransferPacket->Mdl, subPacket->Mdl,
MmGetMdlVirtualAddress(TransferPacket->Mdl),
subPacket->Length);
TRANSFER(subPacket);
}
NTSTATUS
REDISTRIBUTION::QueryPhysicalOffsets(
IN LONGLONG LogicalOffset,
OUT PVOLUME_PHYSICAL_OFFSET* PhysicalOffsets,
OUT PULONG NumberOfPhysicalOffsets
)
/*++
Routine Description:
This routine returns physical disk and offset for a given volume
logical offset.
Arguments:
LogicalOffset - Supplies the logical offset
PhysicalOffsets - Returns the physical offsets
NumberOfPhysicalOffsets - Returns the number of physical offsets
Return Value:
NTSTATUS
--*/
{
USHORT n, whichMember, whichStripeInSet;
LONGLONG whichStripe, whichSet, whichRow;
LONGLONG bytesRedistributed, logicalOffsetInMember;
PFT_VOLUME vol;
KIRQL irql;
if (LogicalOffset < 0) {
return STATUS_INVALID_PARAMETER;
}
if (_redistributionComplete) {
if (_totalSize <= LogicalOffset) {
return STATUS_INVALID_PARAMETER;
}
} else {
KeAcquireSpinLock(&_spinLock, &irql);
bytesRedistributed = _state.BytesRedistributed;
KeReleaseSpinLock(&_spinLock, irql);
if (bytesRedistributed <= LogicalOffset) {
return STATUS_INVALID_PARAMETER;
}
}
ASSERT(_stripeSize);
ASSERT(_totalWidth);
whichStripe = LogicalOffset/_stripeSize;
whichSet = whichStripe/_totalWidth;
whichStripeInSet = (USHORT) (whichStripe%_totalWidth);
if (whichStripeInSet < _firstWidth) {
whichMember = 0;
whichRow = whichSet*_firstWidth + whichStripeInSet;
} else {
whichMember = 1;
whichRow = whichSet*(_totalWidth-_firstWidth) + whichStripeInSet - _firstWidth;
}
vol = GetMember(whichMember);
if (!vol) {
return STATUS_INVALID_PARAMETER;
}
logicalOffsetInMember = whichRow*_stripeSize + LogicalOffset%_stripeSize;
return vol->QueryPhysicalOffsets(logicalOffsetInMember, PhysicalOffsets, NumberOfPhysicalOffsets);
}
NTSTATUS
REDISTRIBUTION::QueryLogicalOffset(
IN PVOLUME_PHYSICAL_OFFSET PhysicalOffset,
OUT PLONGLONG LogicalOffset
)
/*++
Routine Description:
This routine returns the volume logical offset for a given disk number
and physical offset.
Arguments:
PhysicalOffset - Supplies the physical offset
LogicalOffset - Returns the logical offset
Return Value:
NTSTATUS
--*/
{
USHORT n, i, whichStripeInSet;
LONGLONG whichStripe, whichSet, whichRow, bytesRedistributed;
LONGLONG logicalOffset, logicalOffsetInMember;
NTSTATUS status;
PFT_VOLUME vol;
KIRQL irql;
n = QueryNumMembers();
ASSERT(n == 2);
ASSERT(_stripeSize);
ASSERT(_firstWidth);
ASSERT(_totalWidth > _firstWidth);
for (i = 0; i < n; i++) {
vol = GetMember(i);
if (!vol) {
continue;
}
status = vol->QueryLogicalOffset(PhysicalOffset, &logicalOffsetInMember);
if (NT_SUCCESS(status)) {
whichRow = logicalOffsetInMember/_stripeSize;
if (i == 0) {
whichSet = whichRow/_firstWidth;
whichStripeInSet = (USHORT) (whichRow%_firstWidth);
} else {
ASSERT(i == 1);
whichSet = whichRow/(_totalWidth-_firstWidth);
whichStripeInSet = (USHORT) (whichRow%(_totalWidth-_firstWidth)) + _firstWidth;
}
whichStripe = whichSet*_totalWidth + whichStripeInSet;
logicalOffset = whichStripe*_stripeSize + logicalOffsetInMember%_stripeSize;
if (_redistributionComplete) {
if (_totalSize <= logicalOffset) {
return STATUS_INVALID_PARAMETER;
}
} else {
KeAcquireSpinLock(&_spinLock, &irql);
bytesRedistributed = _state.BytesRedistributed;
KeReleaseSpinLock(&_spinLock, irql);
if (bytesRedistributed <= logicalOffset) {
return STATUS_INVALID_PARAMETER;
}
}
*LogicalOffset = logicalOffset;
return status;
}
}
return STATUS_INVALID_PARAMETER;
}
Reference in a new issue Copy permalink