public static void MoveExtentDataRight(Volume volume, DiskExtent sourceExtent, DiskExtent relocatedExtent, MoveExtentOperationResumeRecord resumeRecord, ref long bytesCopied)
        {
            // we make sure no data will be overwritten too soon:
            long distanceLBA  = (long)(resumeRecord.NewStartSector - resumeRecord.OldStartSector);
            bool bufferedMode = false;

            if (distanceLBA < BufferedModeThresholdLBA)
            {
                bufferedMode = true;
            }

            int transferSizeLBA;

            if (bufferedMode)
            {
                transferSizeLBA = (int)resumeRecord.BackupBufferSizeLBA;
            }
            else
            {
                transferSizeLBA = (int)Math.Min(Settings.MaximumTransferSizeLBA, distanceLBA);
            }

            // move the data
            for (long readCount = (long)resumeRecord.NumberOfCommittedSectors; readCount < relocatedExtent.TotalSectors; readCount += transferSizeLBA)
            {
                // we read (and write) from the end of the extent and progress to the left
                long sectorsLeft   = relocatedExtent.TotalSectors - readCount;
                int  sectorsToRead = (int)Math.Min(transferSizeLBA, sectorsLeft);

                long sectorIndex = relocatedExtent.TotalSectors - readCount - sectorsToRead;

                byte[] data = sourceExtent.ReadSectors(sectorIndex, sectorsToRead);

                if (bufferedMode)
                {
                    // we write the data to the buffer for recovery purposes
                    relocatedExtent.Disk.WriteSectors((long)resumeRecord.BackupBufferStartSector, data);
                    resumeRecord.RestoreFromBuffer = true;
                    // Note: if the extent we move is the first in the volume, we will write the resume record to
                    // the source extent, which is the one that the database is still referring to
                    volume.WriteSectors(0, resumeRecord.GetBytes(volume.BytesPerSector));
                }
                relocatedExtent.WriteSectors(sectorIndex, data);

                // update the resume record
                resumeRecord.RestoreFromBuffer         = false;
                resumeRecord.NumberOfCommittedSectors += (ulong)sectorsToRead;
                volume.WriteSectors(0, resumeRecord.GetBytes(volume.BytesPerSector));
                bytesCopied = (long)resumeRecord.NumberOfCommittedSectors * sourceExtent.BytesPerSector;
            }
        }
        public static void MoveExtentDataLeft(Volume volume, DiskExtent sourceExtent, DiskExtent relocatedExtent, MoveExtentOperationResumeRecord resumeRecord, ref long bytesCopied)
        {
            // we make sure no data will be overwritten too soon:
            long distanceLBA  = (long)(resumeRecord.OldStartSector - resumeRecord.NewStartSector);
            bool bufferedMode = false;

            if (distanceLBA < BufferedModeThresholdLBA)
            {
                bufferedMode = true;
            }

            int transferSizeLBA;

            if (bufferedMode)
            {
                transferSizeLBA = (int)resumeRecord.BackupBufferSizeLBA;;
            }
            else
            {
                transferSizeLBA = (int)Math.Min(Settings.MaximumTransferSizeLBA, distanceLBA);
            }

            // move the data
            for (long sectorIndex = (long)resumeRecord.NumberOfCommittedSectors; sectorIndex < relocatedExtent.TotalSectors; sectorIndex += transferSizeLBA)
            {
                long sectorsLeft   = relocatedExtent.TotalSectors - sectorIndex;
                int  sectorsToRead = (int)Math.Min(transferSizeLBA, sectorsLeft);

                byte[] data = sourceExtent.ReadSectors(sectorIndex, sectorsToRead);
                if (bufferedMode)
                {
                    // we write the data to the buffer for recovery purposes
                    relocatedExtent.Disk.WriteSectors((long)resumeRecord.BackupBufferStartSector, data);
                    resumeRecord.RestoreFromBuffer = true;
                    relocatedExtent.WriteSectors(0, resumeRecord.GetBytes(relocatedExtent.BytesPerSector));
                }
                relocatedExtent.WriteSectors(sectorIndex, data);

                // update the resume record
                resumeRecord.RestoreFromBuffer         = false;
                resumeRecord.NumberOfCommittedSectors += (ulong)sectorsToRead;
                volume.WriteSectors(0, resumeRecord.GetBytes(volume.BytesPerSector));
                bytesCopied = (long)resumeRecord.NumberOfCommittedSectors * sourceExtent.BytesPerSector;
            }
        }
        /// <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);
            }
        }