private static void MoveExtentLeft(DiskGroupDatabase database, DynamicVolume volume, MoveExtentOperationResumeRecord resumeRecord, ref long bytesCopied)
{
DynamicDiskExtent relocatedExtent = DynamicDiskExtentHelper.GetByExtentID(volume.DynamicExtents, resumeRecord.ExtentID);
if (resumeRecord.OldStartSector == (ulong)relocatedExtent.FirstSector)
{
// the database update was not completed (this must be a resume operation)
relocatedExtent = new DynamicDiskExtent(relocatedExtent.Disk, (long)resumeRecord.NewStartSector, relocatedExtent.Size, resumeRecord.ExtentID);
VolumeManagerDatabaseHelper.UpdateExtentLocation(database, volume, relocatedExtent);
}
DiskExtent sourceExtent = new DiskExtent(relocatedExtent.Disk, (long)resumeRecord.OldStartSector, relocatedExtent.Size);
MoveHelper.MoveExtentDataLeft(volume, sourceExtent, relocatedExtent, resumeRecord, ref bytesCopied);
// if this is a resume, then volume is StripedVolume, otherwise it is a Raid5Volume
if (resumeRecord.RestoreRAID5)
{
VolumeManagerDatabaseHelper.ConvertStripedVolumeToRaid(database, volume.VolumeGuid);
// get the updated volume (we just reconverted to RAID-5)
volume = DynamicVolumeHelper.GetVolumeByGuid(database.Disks, volume.VolumeGuid);
}
// restore the filesystem boot sector
byte[] filesystemBootRecord = relocatedExtent.Disk.ReadSector((long)resumeRecord.BootRecordBackupSector);
volume.WriteSectors(0, filesystemBootRecord);
ClearBackupData(relocatedExtent.Disk, resumeRecord);
}
private void ResumeMove(MoveExtentOperationResumeRecord resumeRecord)
{
DiskGroupLockResult result = DiskGroupHelper.LockDiskGroup(m_diskGroup);
if (result == DiskGroupLockResult.CannotLockDisk)
{
MessageBox.Show("Unable to lock all disks!", "Error");
}
else if (result == DiskGroupLockResult.CannotLockVolume)
{
MessageBox.Show("Unable to lock all volumes!", "Error");
}
else if (result == DiskGroupLockResult.OneOrMoreDisksAreOfflineOrReadonly)
{
MessageBox.Show("One or more disks are offline or set to readonly.", "Error");
}
else if (result == DiskGroupLockResult.CannotTakeDiskOffline)
{
MessageBox.Show("Failed to take all dynamic disks offline!", "Error");
}
else if (result == DiskGroupLockResult.Success)
{
int extentIndex = DynamicDiskExtentHelper.GetIndexOfExtentID(m_volume.DynamicExtents, (resumeRecord).ExtentID);
DynamicDiskExtent sourceExtent = m_volume.DynamicExtents[extentIndex];
long bytesTotal = sourceExtent.Size;
long bytesCopied = 0;
Thread workerThread = new Thread(delegate()
{
m_isWorking = true;
List <DynamicDisk> diskGroup = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks(m_volume.DiskGroupGuid);
DiskGroupDatabase database = DiskGroupDatabase.ReadFromDisks(diskGroup, m_volume.DiskGroupGuid);
MoveExtentHelper.ResumeMoveExtent(database, m_volume, resumeRecord, ref bytesCopied);
m_isWorking = false;
});
workerThread.Start();
new Thread(delegate()
{
while (workerThread.IsAlive)
{
Thread.Sleep(250);
int progress = (int)(100 * (double)bytesCopied / bytesTotal);
this.Invoke((MethodInvoker) delegate()
{
progressBar.Value = progress;
});
}
this.Invoke((MethodInvoker) delegate()
{
DiskGroupHelper.UnlockDiskGroup(m_diskGroup);
this.DialogResult = DialogResult.OK;
this.Close();
});
}).Start();
}
}
private static DynamicDiskExtent GetVolumeExtent(DynamicVolume volume, ulong extentID)
{
if (volume is MirroredVolume)
{
foreach (DynamicVolume component in ((MirroredVolume)volume).Components)
{
int extentIndex = DynamicDiskExtentHelper.GetIndexOfExtentID(component.DynamicExtents, extentID);
if (extentIndex >= 0)
{
return(volume.DynamicExtents[extentIndex]);
}
}
}
else
{
int extentIndex = DynamicDiskExtentHelper.GetIndexOfExtentID(volume.DynamicExtents, extentID);
if (extentIndex >= 0)
{
return(volume.DynamicExtents[extentIndex]);
}
}
throw new ArgumentException("Volume does not have an extent with given ExtentID");
}
/// <summary>
/// Move extent to a new location on the same disk
/// </summary>
public static void MoveExtentWithinSameDisk(DiskGroupDatabase database, DynamicVolume volume, DynamicDiskExtent sourceExtent, DiskExtent relocatedExtent, ref long bytesCopied)
{
MoveExtentOperationResumeRecord resumeRecord = new MoveExtentOperationResumeRecord();
// If there will be a power failure during the move, a RAID volume will resync during boot,
// To prevent destruction of the data, we temporarily convert the array to striped volume
if (volume is Raid5Volume)
{
VolumeManagerDatabaseHelper.ConvertRaidToStripedVolume(database, volume.VolumeGuid);
resumeRecord.RestoreRAID5 = true;
}
// We want to write our own volume boot sector for recovery purposes, so we must find where to backup the old boot sector.
// We don't want to store the backup in the range of the existing or relocated extent, because then we would have to move
// the backup around during the move operation, other options include:
// 1. Store it between sectors 1-62 (cons: Could be in use, Windows occasionally start a volume from sector 1)
// 2. Find an easily compressible sector (e.g. zero-filled) within the existing extent, overwrite it with the backup, and restore it when the operation is done.
// 3. use the LDM private region to store the sector.
DynamicDisk dynamicDisk = DynamicDisk.ReadFromDisk(relocatedExtent.Disk);
// Note: backupSectorIndex will be from the beginning of the private region while backupBufferStartSector will be from the end
// so there is no need to allocate them
long backupSectorIndex = PrivateRegionHelper.FindUnusedSector(dynamicDisk.PrivateHeader, dynamicDisk.TOCBlock);
resumeRecord.VolumeGuid = volume.VolumeGuid;
resumeRecord.NumberOfCommittedSectors = 0;
resumeRecord.ExtentID = sourceExtent.ExtentID;
resumeRecord.OldStartSector = (ulong)sourceExtent.FirstSector;
resumeRecord.NewStartSector = (ulong)relocatedExtent.FirstSector;
resumeRecord.BootRecordBackupSector = (ulong)backupSectorIndex;
long distanceLBA = (long)Math.Abs((double)resumeRecord.NewStartSector - resumeRecord.OldStartSector);
if (distanceLBA < MoveHelper.BufferedModeThresholdLBA)
{
long backupBufferStartSector = PrivateRegionHelper.FindUnusedRegion(dynamicDisk.PrivateHeader, dynamicDisk.TOCBlock, BackupBufferSizeLBA);
if (backupBufferStartSector == -1)
{
throw new Exception("Private region is full");
}
if (backupBufferStartSector <= backupSectorIndex)
{
throw new Exception("Private region structure is unknown");
}
resumeRecord.BackupBufferStartSector = (ulong)backupBufferStartSector;
resumeRecord.BackupBufferSizeLBA = BackupBufferSizeLBA;
}
// Backup the first sector of the first extent
// (We replace the filesystem boot record with our own sector for recovery purposes)
byte[] filesystemBootRecord = volume.ReadSector(0);
relocatedExtent.Disk.WriteSectors(backupSectorIndex, filesystemBootRecord);
// we write the resume record instead of the boot record
volume.WriteSectors(0, resumeRecord.GetBytes(volume.BytesPerSector));
if (sourceExtent.FirstSector < relocatedExtent.FirstSector)
{
// move right
MoveExtentRight(database, volume, resumeRecord, ref bytesCopied);
}
else
{
// move left
// we write the resume record at the new location as well (to be able to resume if a power failure will occur immediately after updating the database)
relocatedExtent.WriteSectors(0, resumeRecord.GetBytes(relocatedExtent.BytesPerSector));
DynamicDiskExtent dynamicRelocatedExtent = new DynamicDiskExtent(relocatedExtent, sourceExtent.ExtentID);
dynamicRelocatedExtent.Name = sourceExtent.Name;
dynamicRelocatedExtent.DiskGuid = sourceExtent.DiskGuid;
VolumeManagerDatabaseHelper.UpdateExtentLocation(database, volume, dynamicRelocatedExtent);
int extentIndex = DynamicDiskExtentHelper.GetIndexOfExtentID(volume.DynamicExtents, sourceExtent.ExtentID);
// get the updated volume (we just moved an extent)
volume = DynamicVolumeHelper.GetVolumeByGuid(database.Disks, volume.VolumeGuid);
MoveExtentLeft(database, volume, resumeRecord, ref bytesCopied);
}
}
