Updated DiskAccessLibrary to v1.4.0

DiskAccessLibrary/DiskAccessLibrary.csproj

@@ -32,9 +32,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="BaseClasses\Disk.cs" />
+    <Compile Include="BaseClasses\DiskExtent.cs" />
     <Compile Include="BaseClasses\IDiskGeometry.cs" />
     <Compile Include="BaseClasses\Volume.cs" />
-    <Compile Include="BaseClasses\DiskExtent.cs" />
     <Compile Include="DiskExtent\DynamicDiskExtent.cs" />
     <Compile Include="Disks\DiskImage.cs" />
     <Compile Include="Disks\GuidPartitionTable\GuidPartitionEntry.cs" />
@@ -49,6 +49,8 @@
     <Compile Include="Disks\VHD\BlockAllocationTable.cs" />
     <Compile Include="Disks\VHD\DynamicDiskHeader.cs" />
     <Compile Include="Disks\VHD\ParentLocatorEntry.cs" />
+    <Compile Include="Disks\VHD\VHDFooter.cs" />
+    <Compile Include="Disks\VHD\VirtualHardDisk.cs" />
     <Compile Include="Disks\VHD\VirtualHardDiskType.cs" />
     <Compile Include="Disks\VMDK\ExtentType.cs" />
     <Compile Include="Disks\VMDK\SparseExtent.cs" />
@@ -59,37 +61,48 @@
     <Compile Include="Disks\VMDK\VirtualMachineDiskType.cs" />
     <Compile Include="Exceptions\CyclicRedundancyCheckException.cs" />
     <Compile Include="Exceptions\DeviceNotReadyException.cs" />
+    <Compile Include="Exceptions\SharingViolationException.cs" />
     <Compile Include="FileSystems\FileSystemHelper.cs" />
     <Compile Include="FileSystems\IExtendableFileSystem.cs" />
+    <Compile Include="FileSystems\NTFS\Adapters\NTFSFileStream.cs" />
+    <Compile Include="FileSystems\NTFS\Adapters\NTFSFileSystem.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\AttributeListEntry.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\AttributeListRecord.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\AttributeRecord.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\DataRecord.cs" />
     <Compile Include="FileSystems\NTFS\AttributeRecord\FileNameAttributeRecord.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\IndexAllocationRecord.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\IndexRootRecord.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\NonResidentAttributeRecord.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\ResidentAttributeRecord.cs" />
     <Compile Include="FileSystems\NTFS\AttributeRecord\StandardInformationRecord.cs" />
+    <Compile Include="FileSystems\NTFS\AttributeRecord\VolumeInformationRecord.cs" />
+    <Compile Include="FileSystems\NTFS\ClusterUsageBitmap.cs" />
+    <Compile Include="FileSystems\NTFS\DataRun.cs" />
+    <Compile Include="FileSystems\NTFS\DataRunSequence.cs" />
+    <Compile Include="FileSystems\NTFS\Enums\AttributeCollationRule.cs" />
+    <Compile Include="FileSystems\NTFS\Enums\AttributeType.cs" />
     <Compile Include="FileSystems\NTFS\Enums\FilenameNamespace.cs" />
-    <Compile Include="FileSystems\NTFS\Adapters\NTFSFileStream.cs" />
-    <Compile Include="FileSystems\NTFS\Adapters\NTFSFileSystem.cs" />
-    <Compile Include="Helpers\MoveHelper.cs" />
-    <Compile Include="LogicalDiskManagerHelpers\RetainHelper.cs" />
-    <Compile Include="LogicalDiskManager\Exceptions\DatabaseNotFoundException.cs" />
-    <Compile Include="LogicalDiskManager\Exceptions\MissingDatabaseRecordException.cs" />
-    <Compile Include="Volumes\RemovableVolume.cs" />
-    <Compile Include="Disks\VHD\VHDFooter.cs" />
-    <Compile Include="Disks\VHD\VirtualHardDisk.cs" />
-    <Compile Include="Exceptions\SharingViolationException.cs" />
+    <Compile Include="FileSystems\NTFS\FileRecord\FileRecord.cs" />
+    <Compile Include="FileSystems\NTFS\FileRecord\FileRecordSegment.cs" />
+    <Compile Include="FileSystems\NTFS\FileRecord\MultiSectorHelper.cs" />
+    <Compile Include="FileSystems\NTFS\Index\FileNameIndexEntry.cs" />
+    <Compile Include="FileSystems\NTFS\Index\FileNameIndexLeafNode.cs" />
+    <Compile Include="FileSystems\NTFS\Index\IndexNode.cs" />
+    <Compile Include="FileSystems\NTFS\Index\IndexNodeEntry.cs" />
+    <Compile Include="FileSystems\NTFS\Index\IndexRecord.cs" />
+    <Compile Include="FileSystems\NTFS\MasterFileTable.cs" />
+    <Compile Include="FileSystems\NTFS\NTFSBootRecord.cs" />
+    <Compile Include="FileSystems\NTFS\NTFSFile.cs" />
+    <Compile Include="FileSystems\NTFS\NTFSVolume.Extend.cs" />
+    <Compile Include="FileSystems\NTFS\NTFSVolume.cs" />
+    <Compile Include="FileSystems\NTFS\Structures\FileNameRecord.cs" />
+    <Compile Include="FileSystems\NTFS\Structures\MftSegmentReference.cs" />
     <Compile Include="Helpers\BasicDiskHelper.cs" />
     <Compile Include="Helpers\DiskExtentHelper.cs" />
-    <Compile Include="Helpers\DynamicDiskExtentHelper.cs" />
-    <Compile Include="Helpers\DynamicDiskHelper.cs" />
-    <Compile Include="Helpers\Settings.cs" />
-    <Compile Include="LogicalDiskManagerHelpers\AddDiskToArrayHelper.cs" />
-    <Compile Include="Helpers\DynamicVolumeHelper.cs" />
     <Compile Include="Helpers\ExtendHelper.Volume.cs" />
-    <Compile Include="LogicalDiskManagerHelpers\VolumeManagerDatabaseHelper.cs" />
-    <Compile Include="LogicalDiskManagerHelpers\MoveExtentHelper.cs" />
-    <Compile Include="LogicalDiskManagerHelpers\RAID5ManagerBootRecord\AddDiskOperationBootRecord.cs" />
-    <Compile Include="LogicalDiskManagerHelpers\RAID5ManagerBootRecord\MoveExtentOperationBootRecord.cs" />
-    <Compile Include="LogicalDiskManagerHelpers\RAID5ManagerBootRecord\RAID5ManagerBootRecord.cs" />
+    <Compile Include="Helpers\Settings.cs" />
     <Compile Include="Helpers\VolumeHelper.cs" />
-    <Compile Include="LogicalDiskManager\VolumeManagerDatabase.cs" />
-    <Compile Include="LogicalDiskManager\VolumeManagerDatabaseHeader.cs" />
     <Compile Include="LogicalDiskManager\DatabaseRecords\ComponentRecord.cs" />
     <Compile Include="LogicalDiskManager\DatabaseRecords\DatabaseRecord.cs" />
     <Compile Include="LogicalDiskManager\DatabaseRecords\DatabaseRecordFragment.cs" />
@@ -100,85 +113,68 @@
     <Compile Include="LogicalDiskManager\DiskGroupDatabase.cs" />
     <Compile Include="LogicalDiskManager\DynamicDisk.cs" />
     <Compile Include="LogicalDiskManager\Enums\DatabaseHeaderUpdateStatus.cs" />
+    <Compile Include="LogicalDiskManager\Enums\DatabaseRecordUpdateStatus.cs" />
     <Compile Include="LogicalDiskManager\Enums\ExtentLayoutName.cs" />
     <Compile Include="LogicalDiskManager\Enums\KernelUpdateLogEntryStatus.cs" />
+    <Compile Include="LogicalDiskManager\Enums\ReadPolicyName.cs" />
     <Compile Include="LogicalDiskManager\Enums\RecordType.cs" />
     <Compile Include="LogicalDiskManager\Enums\VolumeFlags.cs" />
-    <Compile Include="LogicalDiskManager\Enums\ReadPolicyName.cs" />
+    <Compile Include="LogicalDiskManager\Exceptions\DatabaseNotFoundException.cs" />
+    <Compile Include="LogicalDiskManager\Exceptions\MissingDatabaseRecordException.cs" />
+    <Compile Include="LogicalDiskManager\Helpers\DynamicDiskExtentHelper.cs" />
+    <Compile Include="LogicalDiskManager\Helpers\DynamicDiskHelper.cs" />
+    <Compile Include="LogicalDiskManager\Helpers\DynamicVolumeHelper.cs" />
+    <Compile Include="LogicalDiskManager\Helpers\RetainHelper.cs" />
+    <Compile Include="LogicalDiskManager\Helpers\VolumeManagerDatabaseHelper.cs" />
     <Compile Include="LogicalDiskManager\KernelUpdateLog\KernalUpdateLog.cs" />
     <Compile Include="LogicalDiskManager\KernelUpdateLog\KernelUpdateLogPage.cs" />
-    <Compile Include="LogicalDiskManager\Enums\DatabaseRecordUpdateStatus.cs" />
     <Compile Include="LogicalDiskManager\PrivateHeader.cs" />
     <Compile Include="LogicalDiskManager\TOCBlock\TOCBlock.cs" />
     <Compile Include="LogicalDiskManager\TOCBlock\TOCRegion.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\AttributeListRecord.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\AttributeListEntry.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\AttributeRecord.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\DataRecord.cs" />
-    <Compile Include="FileSystems\NTFS\Structures\FileNameRecord.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\IndexAllocationRecord.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\IndexRootRecord.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\NonResidentAttributeRecord.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\ResidentAttributeRecord.cs" />
-    <Compile Include="FileSystems\NTFS\AttributeRecord\VolumeInformationRecord.cs" />
-    <Compile Include="FileSystems\NTFS\ClusterUsageBitmap.cs" />
-    <Compile Include="FileSystems\NTFS\DataRun.cs" />
-    <Compile Include="FileSystems\NTFS\DataRunSequence.cs" />
-    <Compile Include="FileSystems\NTFS\Enums\AttributeCollationRule.cs" />
-    <Compile Include="FileSystems\NTFS\Enums\AttributeType.cs" />
-    <Compile Include="FileSystems\NTFS\FileRecord\FileRecord.cs" />
-    <Compile Include="FileSystems\NTFS\FileRecord\FileRecordSegment.cs" />
-    <Compile Include="FileSystems\NTFS\Index\FileNameIndexEntry.cs" />
-    <Compile Include="FileSystems\NTFS\Index\FileNameIndexLeafNode.cs" />
-    <Compile Include="FileSystems\NTFS\Index\IndexNode.cs" />
-    <Compile Include="FileSystems\NTFS\Index\IndexRecord.cs" />
-    <Compile Include="FileSystems\NTFS\Index\IndexNodeEntry.cs" />
-    <Compile Include="FileSystems\NTFS\MasterFileTable.cs" />
-    <Compile Include="FileSystems\NTFS\Structures\MftSegmentReference.cs" />
-    <Compile Include="FileSystems\NTFS\FileRecord\MultiSectorHelper.cs" />
-    <Compile Include="FileSystems\NTFS\NTFSBootRecord.cs" />
-    <Compile Include="FileSystems\NTFS\NTFSFile.cs" />
-    <Compile Include="FileSystems\NTFS\NTFSVolume.cs" />
-    <Compile Include="FileSystems\NTFS\NTFSVolume.Extend.cs" />
+    <Compile Include="LogicalDiskManager\VolumeManagerDatabase.cs" />
+    <Compile Include="LogicalDiskManager\VolumeManagerDatabaseHeader.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Volumes\DynamicColumn.cs" />
     <Compile Include="Volumes\DynamicVolume.cs" />
     <Compile Include="Volumes\GPTPartition.cs" />
+    <Compile Include="Volumes\MBRPartition.cs" />
     <Compile Include="Volumes\MirroredVolume.cs" />
     <Compile Include="Volumes\Partition.cs" />
-    <Compile Include="Volumes\MBRPartition.cs" />
     <Compile Include="Volumes\Raid5Volume.cs" />
+    <Compile Include="Volumes\RemovableVolume.cs" />
     <Compile Include="Volumes\SimpleVolume.cs" />
     <Compile Include="Volumes\SpannedVolume.cs" />
     <Compile Include="Volumes\StripedVolume.cs" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Win32\Disks\DiskImage.Win32.cs" />
+    <Compile Include="Win32\Disks\PhysicalDisk.cs" />
+    <Compile Include="Win32\Disks\PhysicalDiskHandlePool.cs" />
+    <Compile Include="Win32\Disks\RawDiskImage\RawDiskImage.Win32.cs" />
+    <Compile Include="Win32\Disks\VHD\VirtualHardDisk.Win32.cs" />
     <Compile Include="Win32\Disks\VMDK\SparseExtent.Win32.cs" />
     <Compile Include="Win32\Disks\VMDK\VirtualMachineDisk.Win32.cs" />
     <Compile Include="Win32\Enums\Win32Error.cs" />
     <Compile Include="Win32\Helpers\DiskOfflineHelper.cs" />
+    <Compile Include="Win32\Helpers\LockHelper.cs" />
+    <Compile Include="Win32\Helpers\PhysicalDiskHelper.cs" />
+    <Compile Include="Win32\Helpers\WindowsVolumeHelper.cs" />
+    <Compile Include="Win32\Helpers\WindowsVolumeManager.cs" />
+    <Compile Include="Win32\LogicalDiskManager\DiskGroupDatabase.Win32.cs" />
+    <Compile Include="Win32\LogicalDiskManager\LockHelper.cs" />
+    <Compile Include="Win32\LogicalDiskManager\LockManager.cs" />
+    <Compile Include="Win32\LogicalDiskManager\DiskLockHelper.cs" />
+    <Compile Include="Win32\LogicalDiskManager\WindowsDynamicDiskHelper.cs" />
+    <Compile Include="Win32\LogicalDiskManager\WindowsDynamicVolumeHelper.cs" />
     <Compile Include="Win32\Utilities\DeviceInterfaceUtils.cs" />
-    <Compile Include="Win32\Helpers\DiskLockHelper.cs" />
-    <Compile Include="Win32\Disks\RawDiskImage\RawDiskImage.Win32.cs" />
-    <Compile Include="Win32\Disks\PhysicalDisk.cs" />
-    <Compile Include="Win32\Disks\PhysicalDiskHandlePool.cs" />
-    <Compile Include="Win32\Disks\VHD\VirtualHardDisk.Win32.cs" />
     <Compile Include="Win32\Utilities\FileStreamEx.cs" />
     <Compile Include="Win32\Utilities\FileStreamUtils.cs" />
     <Compile Include="Win32\Utilities\HandleUtils.cs" />
-    <Compile Include="Win32\Helpers\LockHelper.cs" />
-    <Compile Include="Win32\LogicalDiskManager\DiskGroupDatabase.Win32.cs" />
-    <Compile Include="Win32\Helpers\PhysicalDiskHelper.cs" />
     <Compile Include="Win32\Utilities\PhysicalDiskUtils.cs" />
     <Compile Include="Win32\Utilities\SecurityUtils.cs" />
+    <Compile Include="Win32\Utilities\VolumeUtils.cs" />
     <Compile Include="Win32\Volumes\OperatingSystemVolume.cs" />
     <Compile Include="Win32\Volumes\VolumeHandlePool.cs" />
-    <Compile Include="Win32\Utilities\VolumeUtils.cs" />
-    <Compile Include="Win32\Helpers\WindowsDynamicDiskHelper.cs" />
-    <Compile Include="Win32\Helpers\WindowsDynamicVolumeHelper.cs" />
-    <Compile Include="Win32\Helpers\WindowsVolumeHelper.cs" />
-    <Compile Include="Win32\Helpers\WindowsVolumeManager.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="RevisionHistory.txt" />

DiskAccessLibrary/Disks/VHD/VirtualHardDisk.cs

@@ -239,7 +239,7 @@ namespace DiskAccessLibrary
         /// <param name="length">In bytes</param>
         /// <exception cref="System.IO.IOException"></exception>
         /// <exception cref="System.UnauthorizedAccessException"></exception>
-        public static VirtualHardDisk Create(string path, long length)
+        public static VirtualHardDisk Create(string path, long size)
         {
 #if Win32
             // calling AdjustTokenPrivileges and then immediately calling SetFileValidData will sometimes result in ERROR_PRIVILEGE_NOT_HELD.
@@ -249,7 +249,7 @@ namespace DiskAccessLibrary
             FileStream stream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
             try
             {
-                stream.SetLength(length + 512); // VHD footer is 512 bytes
+                stream.SetLength(size + 512); // VHD footer is 512 bytes
             }
             catch (IOException)
             {
@@ -270,7 +270,7 @@ namespace DiskAccessLibrary
             {
                 try
                 {
-                    FileStreamUtils.SetValidLength(stream, length + 512);
+                    FileStreamUtils.SetValidLength(stream, size + 512);
                 }
                 catch (IOException)
                 {
@@ -279,11 +279,11 @@ namespace DiskAccessLibrary
 #endif
 
             VHDFooter footer = new VHDFooter();
-            footer.OriginalSize = (ulong)length;
-            footer.CurrentSize = (ulong)length;
+            footer.OriginalSize = (ulong)size;
+            footer.CurrentSize = (ulong)size;
             footer.SetCurrentTimeStamp();
-            footer.SetDiskGeometry((ulong)length / DiskImage.BytesPerDiskImageSector);
-            stream.Seek(length, SeekOrigin.Begin);
+            footer.SetDiskGeometry((ulong)size / DiskImage.BytesPerDiskImageSector);
+            stream.Seek(size, SeekOrigin.Begin);
             stream.Write(footer.GetBytes(), 0, VHDFooter.Length);
             stream.Close();
             return new VirtualHardDisk(path);

DiskAccessLibrary/Helpers/DiskExtentHelper.cs

@@ -7,7 +7,6 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using DiskAccessLibrary.LogicalDiskManager;
 using Utilities;
 
 namespace DiskAccessLibrary

DiskAccessLibrary/Helpers/MoveHelper.cs

@@ -1,119 +0,0 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
- * 
- * You can redistribute this program and/or modify it under the terms of
- * the GNU Lesser Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using DiskAccessLibrary.LogicalDiskManager;
-using Utilities;
-
-namespace DiskAccessLibrary
-{
-    public class MoveHelper
-    {
-        /// <summary>
-        /// When a user want to move an extent one sector to the left/right (e.g. for alignment purposes),
-        /// the regular operation method will mandate reading and writing one sector at a time,
-        /// this can be extremely slow, and to avoid this, we use free space on the disk to "buffer" the data read.
-        /// (this will allow us to recover from a power failure)
-        /// </summary>
-        public const int BufferedModeThresholdLBA = 64;
-
-        public static void MoveExtentDataRight(Volume volume, DiskExtent sourceExtent, DiskExtent relocatedExtent, MoveExtentOperationBootRecord 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());
-                }
-                relocatedExtent.WriteSectors(sectorIndex, data);
-
-                // update the resume record
-                resumeRecord.RestoreFromBuffer = false;
-                resumeRecord.NumberOfCommittedSectors += (ulong)sectorsToRead;
-                volume.WriteSectors(0, resumeRecord.GetBytes());
-                bytesCopied = (long)resumeRecord.NumberOfCommittedSectors * sourceExtent.BytesPerSector;
-            }
-        }
-
-        public static void MoveExtentDataLeft(Volume volume, DiskExtent sourceExtent, DiskExtent relocatedExtent, MoveExtentOperationBootRecord 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.WriteSectors(sectorIndex, data);
-
-                // update the resume record
-                resumeRecord.RestoreFromBuffer = false;
-                resumeRecord.NumberOfCommittedSectors += (ulong)sectorsToRead;
-                volume.WriteSectors(0, resumeRecord.GetBytes());
-                bytesCopied = (long)resumeRecord.NumberOfCommittedSectors * sourceExtent.BytesPerSector;
-            }
-        }
-    }
-}

DiskAccessLibrary/Helpers/VolumeHelper.cs

@@ -14,50 +14,6 @@ namespace DiskAccessLibrary
 {
     public partial class VolumeHelper
     {
-        /// <summary>
-        /// Will return or generate a persistent volume unique ID
-        /// </summary>
-        [Obsolete]
-        public static Guid? GetVolumeUniqueID(Volume volume)
-        {
-            if (volume is MBRPartition)
-            {
-                MBRPartition partition = (MBRPartition)volume;
-                MasterBootRecord mbr = MasterBootRecord.ReadFromDisk(partition.Disk);
-                byte[] firstSectorBytes = BigEndianConverter.GetBytes(partition.FirstSector);
-                return new Guid((int)mbr.DiskSignature, 0, 0, firstSectorBytes);
-            }
-            else if (volume is GPTPartition)
-            {
-                return ((GPTPartition)volume).VolumeGuid;
-            }
-            else if (volume is DynamicVolume)
-            {
-                return ((DynamicVolume)volume).VolumeGuid;
-            }
-            else
-            {
-                return null;
-            }
-        }
-
-        [Obsolete]
-        public static Volume GetVolumeByGuid(List<Disk> disks, Guid volumeGuid)
-        {
-            List<Volume> volumes = GetVolumes(disks);
-            foreach (Volume volume in volumes)
-            {
-                Guid? guid = GetVolumeUniqueID(volume);
-                if (guid == volumeGuid)
-                {
-                    {
-                        return volume;
-                    }
-                }
-            }
-            return null;
-        }
-
         public static List<Volume> GetVolumes(List<Disk> disks)
         {
             List<Volume> result = new List<Volume>();
@@ -90,52 +46,74 @@ namespace DiskAccessLibrary
             return result;
         }
 
-        /// <summary>
-        /// Return volumes that are stored (or partially stored) on the given disk
-        /// </summary>
-        [Obsolete]
-        public static List<Volume> GetDiskVolumes(Disk disk)
+        public static string GetVolumeTypeString(Volume volume)
         {
-            List<Volume> result = new List<Volume>();
-
-            DynamicDisk dynamicDisk = DynamicDisk.ReadFromDisk(disk);
-
-            if (dynamicDisk == null)
+            if (volume is SimpleVolume)
             {
-                // basic disk
-                List<Partition> partitions = BasicDiskHelper.GetPartitions(disk);
-                foreach (MBRPartition partition in partitions)
-                {
-                    result.Add(partition);
-                }
+                return "Simple";
+            }
+            else if (volume is SpannedVolume)
+            {
+                return "Spanned";
+            }
+            else if (volume is StripedVolume)
+            {
+                return "Striped";
+            }
+            else if (volume is MirroredVolume)
+            {
+                return "Mirrored";
+            }
+            else if (volume is Raid5Volume)
+            {
+                return "RAID-5";
+            }
+            else if (volume is Partition)
+            {
+                return "Partition";
             }
             else
             {
-                // dynamic disk
-                List<DynamicVolume> dynamicVolumes = DynamicVolumeHelper.GetDynamicDiskVolumes(dynamicDisk);
-                foreach (DynamicVolume volume in dynamicVolumes)
-                {
-                    result.Add(volume);
-                }
+                return "Unknown";
             }
-            return result;
         }
 
-        [Obsolete]
-        public static bool ContainsVolumeGuid(List<Volume> volumes, Guid volumeGuid)
+        public static string GetVolumeStatusString(Volume volume)
         {
-            foreach (Volume volume in volumes)
+            if (volume is DynamicVolume)
             {
-                if (volume is DynamicVolume)
+                if (volume is MirroredVolume)
                 {
-                    DynamicVolume dynamicVolume = (DynamicVolume)volume;
-                    if (dynamicVolume.VolumeGuid == volumeGuid)
+                    if (!((MirroredVolume)volume).IsHealthy && ((MirroredVolume)volume).IsOperational)
                     {
-                        return true;
+                        return "Failed Rd";
                     }
                 }
+                else if (volume is Raid5Volume)
+                {
+                    if (!((Raid5Volume)volume).IsHealthy && ((Raid5Volume)volume).IsOperational)
+                    {
+                        return "Failed Rd";
+                    }
+                }
+
+                if (((DynamicVolume)volume).IsHealthy)
+                {
+                    return "Healthy";
+                }
+                else
+                {
+                    return "Failed";
+                }
+            }
+            else if (volume is Partition)
+            {
+                return "Healthy";
+            }
+            else
+            {
+                return String.Empty;
             }
-            return false;
         }
     }
 }

DiskAccessLibrary/Helpers/DynamicDiskExtentHelper.cs

@@ -7,10 +7,9 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using DiskAccessLibrary.LogicalDiskManager;
 using Utilities;
 
-namespace DiskAccessLibrary
+namespace DiskAccessLibrary.LogicalDiskManager
 {
     public class DynamicDiskExtentHelper
     {

DiskAccessLibrary/Helpers/DynamicDiskHelper.cs

@@ -8,10 +8,9 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using DiskAccessLibrary.LogicalDiskManager;
 using Utilities;
 
-namespace DiskAccessLibrary
+namespace DiskAccessLibrary.LogicalDiskManager
 {
     public partial class DynamicDiskHelper
     {

DiskAccessLibrary/Helpers/DynamicVolumeHelper.cs

@@ -8,13 +8,22 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using DiskAccessLibrary.LogicalDiskManager;
 using Utilities;
 
-namespace DiskAccessLibrary
+namespace DiskAccessLibrary.LogicalDiskManager
 {
     public partial class DynamicVolumeHelper
     {
+        public static List<Guid> GetVolumeGuids(List<DynamicVolume> volumes)
+        {
+            List<Guid> volumeGuids = new List<Guid>();
+            foreach (DynamicVolume volume in volumes)
+            {
+                volumeGuids.Add(volume.VolumeGuid);
+            }
+            return volumeGuids;
+        }
+
         public static DynamicVolume GetVolumeByGuid(List<DynamicDisk> disks, Guid volumeGuid)
         {
             List<DynamicVolume> volumes = GetDynamicVolumes(disks);
@@ -45,38 +54,6 @@ namespace DiskAccessLibrary
             return result;
         }
 
-        /// <summary>
-        /// Return volumes that are stored (or partially stored) on the given disk
-        /// </summary>
-        [Obsolete]
-        public static List<DynamicVolume> GetDynamicDiskVolumes(DynamicDisk disk)
-        {
-            VolumeManagerDatabase database = VolumeManagerDatabase.ReadFromDisk(disk);
-            List<DynamicDisk> disks = new List<DynamicDisk>();
-            disks.Add(disk);
-
-            List<DynamicVolume> result = new List<DynamicVolume>();
-            if (database != null)
-            {
-                foreach (VolumeRecord volumeRecord in database.VolumeRecords)
-                {
-                    DynamicVolume volume = GetVolume(disks, database, volumeRecord);
-                    if (volume != null)
-                    {
-                        foreach (DynamicDiskExtent extent in volume.Extents)
-                        {
-                            if (extent.DiskGuid == disk.DiskGuid)
-                            {
-                                result.Add(volume);
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            return result;
-        }
-
         public static DynamicVolume GetVolume(List<DynamicDisk> disks, VolumeManagerDatabase database, VolumeRecord volumeRecord)
         {
             List<ComponentRecord> componentRecords = database.FindComponentsByVolumeID(volumeRecord.VolumeId);

DiskAccessLibrary/LogicalDiskManagerHelpers/AddDiskToArrayHelper.cs

@@ -1,191 +0,0 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
- * 
- * You can redistribute this program and/or modify it under the terms of
- * the GNU Lesser Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using DiskAccessLibrary;
-using Utilities;
-
-namespace DiskAccessLibrary.LogicalDiskManager
-{
-    public class AddDiskToArrayHelper
-    {
-        public static void AddDiskToRaid5Volume(List<DynamicDisk> disks, Raid5Volume volume, DiskExtent newExtent, ref long bytesCopied)
-        {
-            DiskGroupDatabase database = DiskGroupDatabase.ReadFromDisks(disks, volume.DiskGroupGuid);
-            if (database == null)
-            {
-                throw new DatabaseNotFoundException();
-            }
-            // If there will be a power failure during the conversion, our RAID volume will resync during boot,
-            // To prevent destruction of the data, we temporarily convert the array to striped volume
-            VolumeManagerDatabaseHelper.ConvertRaidToStripedVolume(database, volume.VolumeGuid);
-            ulong newExtentID = VolumeManagerDatabaseHelper.AddNewExtentToVolume(database, volume, newExtent);
-
-            // Backup the first sector of the first extent to the last sector of the new extent
-            // (We replace the filesystem boot record with our own sector for recovery purposes)
-            byte[] filesystemBootRecord = volume.Extents[0].ReadSector(0);
-            newExtent.WriteSectors(newExtent.TotalSectors - 1, filesystemBootRecord);
-
-            AddDiskOperationBootRecord resumeRecord = new AddDiskOperationBootRecord();
-            resumeRecord.VolumeGuid = volume.VolumeGuid;
-            PrivateHeader privateHeader = PrivateHeader.ReadFromDisk(newExtent.Disk);
-            // privateHeader cannot be null at this point
-            resumeRecord.NumberOfCommittedSectors = 0;
-
-            // we use volume.WriteSectors so that the parity information will be update
-            // this way, we could recover the first sector of each extent if a disk will fail
-            volume.WriteSectors(0, resumeRecord.GetBytes());
-
-            ResumeAddDiskToRaid5Volume(disks, volume, new DynamicDiskExtent(newExtent, newExtentID), resumeRecord, ref bytesCopied);
-        }
-
-        public static void ResumeAddDiskToRaid5Volume(List<DynamicDisk> disks, StripedVolume stripedVolume, AddDiskOperationBootRecord resumeRecord, ref long bytesCopied)
-        {
-            List<DynamicColumn> columns = stripedVolume.Columns;
-            DynamicDiskExtent newExtent = columns[columns.Count - 1].Extents[0];
-            columns.RemoveAt(columns.Count - 1);
-
-            Raid5Volume volume = new Raid5Volume(columns, stripedVolume.SectorsPerStripe, stripedVolume.VolumeGuid, stripedVolume.DiskGroupGuid);
-            volume.VolumeID = stripedVolume.VolumeID;
-            volume.Name = stripedVolume.Name;
-            volume.DiskGroupName = stripedVolume.DiskGroupName;
-            ResumeAddDiskToRaid5Volume(disks, volume, newExtent, resumeRecord, ref bytesCopied);
-        }
-
-        private static void ResumeAddDiskToRaid5Volume(List<DynamicDisk> disks, Raid5Volume volume, DynamicDiskExtent newExtent, AddDiskOperationBootRecord resumeRecord, ref long bytesCopied)
-        {
-            // When reading from the volume, we must use the old volume (without the new disk)
-            // However, when writing the boot sector to the volume, we must use the new volume or otherwise parity information will be invalid
-            List<DynamicColumn> newVolumeColumns = new List<DynamicColumn>();
-            newVolumeColumns.AddRange(volume.Columns);
-            newVolumeColumns.Add(new DynamicColumn(newExtent));
-            Raid5Volume newVolume = new Raid5Volume(newVolumeColumns, volume.SectorsPerStripe, volume.VolumeGuid, volume.DiskGroupGuid);
-
-            int oldColumnCount = volume.Columns.Count;
-            int newColumnCount = oldColumnCount + 1;
-
-            long resumeFromStripe = (long)resumeRecord.NumberOfCommittedSectors / volume.SectorsPerStripe;
-            // it would be prudent to write the new extent before committing to the operation, however, it would take much longer.
-            
-            // The number of sectors in extent / column is always a multiple of SectorsPerStripe.
-
-            // We read enough stripes to write a vertical stripe segment in the new array,
-            // We will read MaximumTransferSizeLBA and make sure maximumStripesToTransfer is multiple of (NumberOfColumns - 1).
-            int maximumStripesToTransfer = (Settings.MaximumTransferSizeLBA / volume.SectorsPerStripe) / (newColumnCount - 1) * (newColumnCount - 1);
-            long totalStripesInVolume = volume.TotalStripes;
-
-            long stripeIndexInVolume = resumeFromStripe;
-            while (stripeIndexInVolume < totalStripesInVolume)
-            {
-                // When we add a column, the distance between the stripes we read (later in the column) to thes one we write (earlier),
-                // Is growing constantly (because we can stack more stripes in each vertical stripe), so we increment the number of stripes we
-                // can safely transfer as we go.
-                // (We assume that the segment we write will be corrupted if there will be a power failure)
-
-                long stripeToReadIndexInColumn = stripeIndexInVolume / (oldColumnCount - 1);
-                long stripeToWriteIndexInColumn = stripeIndexInVolume / (newColumnCount - 1);
-                long numberOfStripesSafeToTransfer = (stripeToReadIndexInColumn - stripeToWriteIndexInColumn) * (newColumnCount - 1);
-                bool verticalStripeAtRisk = (numberOfStripesSafeToTransfer == 0);
-                if (numberOfStripesSafeToTransfer == 0)
-                {
-                    // The first few stripes in each column are 'at rist', meaning that we may overwrite crucial data (that is only stored in memory) 
-                    // when writing the segment that will be lost forever if a power failure will occur during the write operation.
-                    // Note: The number of 'at risk' vertical stripes is equal to the number of columns in the old array - 1
-                    numberOfStripesSafeToTransfer = (newColumnCount - 1);
-                }
-                int numberOfStripesToTransfer = (int)Math.Min(numberOfStripesSafeToTransfer, maximumStripesToTransfer);
-
-                long stripesLeft = totalStripesInVolume - stripeIndexInVolume;
-                numberOfStripesToTransfer = (int)Math.Min(numberOfStripesToTransfer, stripesLeft);
-                byte[] segmentData = volume.ReadStripes(stripeIndexInVolume, numberOfStripesToTransfer);
-
-                if (numberOfStripesToTransfer % (newColumnCount - 1) > 0)
-                {
-                    // this is the last segment and we need to zero-fill it for the write:
-                    int numberOfStripesToWrite = (int)Math.Ceiling((double)numberOfStripesToTransfer / (newColumnCount - 1)) * (newColumnCount - 1);
-                    byte[] temp = new byte[numberOfStripesToWrite * volume.BytesPerStripe];
-                    Array.Copy(segmentData, temp, segmentData.Length);
-                    segmentData = temp;
-                }
-
-                long firstStripeIndexInColumn = stripeIndexInVolume / (newColumnCount - 1);
-                if (verticalStripeAtRisk)
-                {
-                    // we write 'at risk' stripes one at a time to the new volume, this will make sure they will not overwrite crucial data
-                    // (because they will be written in an orderly fashion, and not in bulk from the first column to the last)
-                    newVolume.WriteStripes(stripeIndexInVolume, segmentData);
-                }
-                else
-                {
-                    WriteSegment(volume, newExtent, firstStripeIndexInColumn, segmentData);
-                }
-
-                // update resume record
-                resumeRecord.NumberOfCommittedSectors += (ulong)(numberOfStripesToTransfer * volume.SectorsPerStripe);
-                bytesCopied = (long)resumeRecord.NumberOfCommittedSectors * volume.BytesPerSector;
-                newVolume.WriteSectors(0, resumeRecord.GetBytes());
-
-                stripeIndexInVolume += numberOfStripesToTransfer;
-            }
-
-            // we're done, let's restore the filesystem boot record
-            byte[] filesystemBootRecord = newExtent.ReadSector(newExtent.TotalSectors - 1);
-            newVolume.WriteSectors(0, filesystemBootRecord);
-            DiskGroupDatabase database = DiskGroupDatabase.ReadFromDisks(disks, volume.DiskGroupGuid);
-            VolumeManagerDatabaseHelper.ConvertStripedVolumeToRaid(database, volume.VolumeGuid);
-        }
-
-        /// <summary>
-        /// Segment - sequence of stripes that is a multiple of (NumberOfColumns - 1),
-        /// and every (NumberOfColumns - 1) stripes in the sequence have the same stripeIndexInColumn
-        /// (Such sequence can be written to disk without reading the parity information first)
-        /// </summary>
-        public static void WriteSegment(Raid5Volume volume, DynamicDiskExtent newExtent, long firstStripeIndexInColumn, byte[] data)
-        {
-            List<DynamicColumn> newArray = new List<DynamicColumn>();
-            newArray.AddRange(volume.Columns);
-            newArray.Add(new DynamicColumn(newExtent));
-
-            int bytesPerStripe = volume.BytesPerStripe;
-
-            int stripesToWritePerColumn = (data.Length / bytesPerStripe) / (newArray.Count - 1);
-            
-            int dataLengthPerColumn = stripesToWritePerColumn * bytesPerStripe;
-            byte[][] columnData = new byte[newArray.Count][];
-            for(int index = 0; index < columnData.Length; index++)
-            {
-                columnData[index] = new byte[dataLengthPerColumn];
-            }
-
-            Parallel.For(0, stripesToWritePerColumn, delegate(int stripeOffsetInColumn)
-            {
-                long stripeIndexInColumn = firstStripeIndexInColumn + stripeOffsetInColumn;
-                int parityColumnIndex = (newArray.Count - 1) - (int)(stripeIndexInColumn % newArray.Count);
-
-                byte[] parityData = new byte[bytesPerStripe];
-                for (int stripeVerticalIndex = 0; stripeVerticalIndex < newArray.Count - 1; stripeVerticalIndex++)
-                {
-                    int columnIndex = (parityColumnIndex + 1 + stripeVerticalIndex) % newArray.Count;
-
-                    long stripeOffsetInData = (stripeOffsetInColumn * (newArray.Count - 1) + stripeVerticalIndex) * bytesPerStripe;
-                    Array.Copy(data, stripeOffsetInData, columnData[columnIndex], stripeOffsetInColumn * bytesPerStripe, bytesPerStripe);
-
-                    parityData = ByteUtils.XOR(parityData, 0, columnData[columnIndex], stripeOffsetInColumn * bytesPerStripe, bytesPerStripe);
-                }
-                Array.Copy(parityData, 0, columnData[parityColumnIndex], stripeOffsetInColumn * bytesPerStripe, bytesPerStripe);
-            });
-
-            // write the data
-            long firstSectorIndexInColumn = firstStripeIndexInColumn * volume.SectorsPerStripe;
-            for (int columnIndex = 0; columnIndex < newArray.Count; columnIndex++)
-            {
-                newArray[columnIndex].WriteSectors(firstSectorIndexInColumn, columnData[columnIndex]);
-            }
-        }
-    }
-}

DiskAccessLibrary/LogicalDiskManagerHelpers/MoveExtentHelper.cs

@@ -1,266 +0,0 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
- * 
- * You can redistribute this program and/or modify it under the terms of
- * the GNU Lesser Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- */
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using Utilities;
-using DiskAccessLibrary;
-
-namespace DiskAccessLibrary.LogicalDiskManager
-{
-    public class MoveExtentHelper
-    {
-        public const int BackupBufferSizeLBA = 128; // there are about 180 contiguous free sectors in a private region
-
-        /// <summary>
-        /// Move extent to another disk
-        /// </summary>
-        public static void MoveExtentToAnotherDisk(List<DynamicDisk> disks, DynamicVolume volume, DynamicDiskExtent sourceExtent, DiskExtent relocatedExtent, ref long bytesCopied)
-        {
-            DiskGroupDatabase database = DiskGroupDatabase.ReadFromDisks(disks, volume.DiskGroupGuid);
-            if (database == null)
-            {
-                throw new DatabaseNotFoundException();
-            }
-
-            // copy the data
-            long transferSizeLBA = Settings.MaximumTransferSizeLBA;
-            for (long sectorIndex = 0; sectorIndex < relocatedExtent.TotalSectors; sectorIndex += transferSizeLBA)
-            {
-                long sectorsLeft = relocatedExtent.TotalSectors - sectorIndex;
-                int sectorsToRead = (int)Math.Min(transferSizeLBA, sectorsLeft);
-
-                byte[] data = sourceExtent.ReadSectors(sectorIndex, sectorsToRead);
-                
-                relocatedExtent.WriteSectors(sectorIndex, data);
-
-                bytesCopied += sectorsToRead * sourceExtent.BytesPerSector;
-            }
-
-            // Update the database to point to the relocated extent
-            DynamicDisk targetDisk = DynamicDisk.ReadFromDisk(relocatedExtent.Disk);
-            DynamicDiskExtent dynamicRelocatedExtent = new DynamicDiskExtent(relocatedExtent, sourceExtent.ExtentID);
-            dynamicRelocatedExtent.Name = sourceExtent.Name;
-            dynamicRelocatedExtent.DiskGuid = targetDisk.DiskGuid;
-            VolumeManagerDatabaseHelper.UpdateExtentLocation(database, volume, dynamicRelocatedExtent);
-        }
-
-        /// <summary>
-        /// Move extent to a new location on the same disk
-        /// </summary>
-        public static void MoveExtentWithinSameDisk(List<DynamicDisk> disks, DynamicVolume volume, DynamicDiskExtent sourceExtent, DiskExtent relocatedExtent, ref long bytesCopied)
-        {
-            DiskGroupDatabase database = DiskGroupDatabase.ReadFromDisks(disks, volume.DiskGroupGuid);
-            if (database == null)
-            {
-                throw new DatabaseNotFoundException();
-            }
-
-            MoveExtentOperationBootRecord resumeRecord = new MoveExtentOperationBootRecord();
-            // 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 = DynamicDiskHelper.FindUnusedSectorInPrivateRegion(dynamicDisk);
-
-            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 = DynamicDiskHelper.FindUnusedRegionInPrivateRegion(dynamicDisk, 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());
-
-            if (sourceExtent.FirstSector < relocatedExtent.FirstSector)
-            {
-                // move right
-                MoveExtentRight(disks, 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());
-                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(disks, volume.VolumeGuid);
-                MoveExtentLeft(disks, volume, resumeRecord, ref bytesCopied);
-            }
-        }
-
-        public static void ResumeMoveExtent(List<DynamicDisk> disks, DynamicVolume volume, MoveExtentOperationBootRecord resumeRecord, ref long bytesCopied)
-        {
-            if (resumeRecord.OldStartSector == resumeRecord.NewStartSector)
-            {
-                throw new InvalidDataException("Invalid move record");
-            }
-
-            if (resumeRecord.RestoreFromBuffer)
-            {
-                // we need to use the backup buffer to restore the data that may have been overwritten
-                int extentIndex = DynamicDiskExtentHelper.GetIndexOfExtentID(volume.DynamicExtents, resumeRecord.ExtentID);
-                DynamicDiskExtent sourceExtent = volume.DynamicExtents[extentIndex];
-
-                byte[] backupBuffer = sourceExtent.Disk.ReadSectors((long)resumeRecord.BackupBufferStartSector, BackupBufferSizeLBA);
-                if (resumeRecord.OldStartSector < resumeRecord.NewStartSector)
-                {
-                    // move right
-                    long readCount = (long)resumeRecord.NumberOfCommittedSectors;
-                    int sectorsToRead = BackupBufferSizeLBA;
-                    long sectorIndex = sourceExtent.TotalSectors - readCount - sectorsToRead;
-                    sourceExtent.WriteSectors(sectorIndex, backupBuffer);
-
-                    System.Diagnostics.Debug.WriteLine("Restored to " + sectorIndex);
-                }
-                else
-                {
-                    // move left
-                    long sectorIndex = (long)resumeRecord.NumberOfCommittedSectors;
-                    sourceExtent.WriteSectors(sectorIndex, backupBuffer);
-
-                    System.Diagnostics.Debug.WriteLine("Restored to " + sectorIndex);
-                }
-            }
-
-            if (resumeRecord.OldStartSector < resumeRecord.NewStartSector)
-            {
-                MoveExtentRight(disks, volume, resumeRecord, ref bytesCopied);
-            }
-            else
-            {
-                MoveExtentLeft(disks, volume, resumeRecord, ref bytesCopied);
-            }
-        }
-
-        private static void MoveExtentRight(List<DynamicDisk> disks, DynamicVolume volume, MoveExtentOperationBootRecord resumeRecord, ref long bytesCopied)
-        {
-            DiskGroupDatabase database = DiskGroupDatabase.ReadFromDisks(disks, volume.DiskGroupGuid);
-            if (database == null)
-            {
-                throw new DatabaseNotFoundException();
-            }
-
-            int extentIndex = DynamicDiskExtentHelper.GetIndexOfExtentID(volume.DynamicExtents, resumeRecord.ExtentID);
-            DynamicDiskExtent sourceExtent = volume.DynamicExtents[extentIndex];
-            DiskExtent relocatedExtent = new DiskExtent(sourceExtent.Disk, (long)resumeRecord.NewStartSector, sourceExtent.Size);
-
-            MoveHelper.MoveExtentDataRight(volume, sourceExtent, relocatedExtent, resumeRecord, ref bytesCopied);
-
-            // even if the database update won't complete, the resume record was copied 
-
-            // update the database
-            DynamicDiskExtent dynamicRelocatedExtent = new DynamicDiskExtent(relocatedExtent, sourceExtent.ExtentID);
-            dynamicRelocatedExtent.Name = sourceExtent.Name;
-            dynamicRelocatedExtent.DiskGuid = sourceExtent.DiskGuid;
-            VolumeManagerDatabaseHelper.UpdateExtentLocation(database, volume, dynamicRelocatedExtent);
-
-            // 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 moved an extent and possibly reconverted to RAID-5)
-            volume = DynamicVolumeHelper.GetVolumeByGuid(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 static void MoveExtentLeft(List<DynamicDisk> disks, DynamicVolume volume, MoveExtentOperationBootRecord resumeRecord, ref long bytesCopied)
-        {
-            DiskGroupDatabase database = DiskGroupDatabase.ReadFromDisks(disks, volume.DiskGroupGuid);
-            if (database == null)
-            {
-                throw new DatabaseNotFoundException();
-            }
-
-            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(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 static void ClearBackupData(Disk relocatedExtentDisk, MoveExtentOperationBootRecord resumeRecord)
-        {
-            byte[] emptySector = new byte[relocatedExtentDisk.BytesPerSector];
-            relocatedExtentDisk.WriteSectors((long)resumeRecord.BootRecordBackupSector, emptySector);
-            if (resumeRecord.BackupBufferStartSector > 0)
-            {
-                byte[] emptyRegion = new byte[resumeRecord.BackupBufferSizeLBA * relocatedExtentDisk.BytesPerSector];
-                relocatedExtentDisk.WriteSectors((long)resumeRecord.BackupBufferStartSector, emptyRegion);
-            }
-        }
-    }
-}

DiskAccessLibrary/LogicalDiskManagerHelpers/RAID5ManagerBootRecord/AddDiskOperationBootRecord.cs

@@ -1,40 +0,0 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
- * 
- * You can redistribute this program and/or modify it under the terms of
- * the GNU Lesser Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Utilities;
-
-namespace DiskAccessLibrary
-{
-    public class AddDiskOperationBootRecord : RAID5ManagerBootRecord
-    {
-        public Guid VolumeGuid; // offset 16
-        public ulong NumberOfCommittedSectors; // for an array, this would be the total of all sectors that can be now read from the new array
-
-        public AddDiskOperationBootRecord()
-        {
-            Operation = RAID5ManagerOperation.AddDiskToArray;
-        }
-
-        public AddDiskOperationBootRecord(byte[] buffer) : base(buffer)
-        { 
-        }
-
-        protected override void ReadOperationParameters(byte[] buffer, int offset)
-        {
-            VolumeGuid = BigEndianConverter.ToGuid(buffer, offset + 0);
-            NumberOfCommittedSectors = BigEndianConverter.ToUInt64(buffer, offset + 16);
-        }
-
-        protected override void WriteOperationParameters(byte[] buffer, int offset)
-        {
-            BigEndianWriter.WriteGuidBytes(buffer, offset + 0, VolumeGuid);
-            BigEndianWriter.WriteUInt64(buffer, offset + 16, NumberOfCommittedSectors);
-        }
-    }
-}

DiskAccessLibrary/LogicalDiskManagerHelpers/RAID5ManagerBootRecord/MoveExtentOperationBootRecord.cs

@@ -1,66 +0,0 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
- * 
- * You can redistribute this program and/or modify it under the terms of
- * the GNU Lesser Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Utilities;
-
-namespace DiskAccessLibrary
-{
-    public class MoveExtentOperationBootRecord : RAID5ManagerBootRecord
-    {
-        public Guid VolumeGuid; // offset 16
-        public ulong NumberOfCommittedSectors; // for an array, this would be the total of all sectors that can be now read from the new array
-        public ulong ExtentID;
-        public ulong OldStartSector;
-        public ulong NewStartSector;
-        public ulong BootRecordBackupSector;
-        public ulong BackupBufferStartSector;
-        public uint BackupBufferSizeLBA;
-        public bool RestoreFromBuffer;
-        public bool RestoreRAID5;
-
-        public MoveExtentOperationBootRecord()
-        {
-            Operation = RAID5ManagerOperation.MoveExtent;
-        }
-
-        public MoveExtentOperationBootRecord(byte[] buffer) : base(buffer)
-        { 
-
-        }
-
-        protected override void ReadOperationParameters(byte[] buffer, int offset)
-        {
- 	        VolumeGuid = BigEndianConverter.ToGuid(buffer, offset + 0);
-            NumberOfCommittedSectors = BigEndianConverter.ToUInt64(buffer, offset + 16);
-            ExtentID = BigEndianConverter.ToUInt64(buffer, offset + 24);
-            OldStartSector = BigEndianConverter.ToUInt64(buffer, offset + 32);
-            NewStartSector = BigEndianConverter.ToUInt64(buffer, offset + 40);
-            BootRecordBackupSector = BigEndianConverter.ToUInt64(buffer, offset + 48);
-            BackupBufferStartSector = BigEndianConverter.ToUInt64(buffer, offset + 56);
-            BackupBufferSizeLBA = BigEndianConverter.ToUInt32(buffer, offset + 64);
-            RestoreFromBuffer = ByteReader.ReadByte(buffer, offset + 68) == 1;
-            RestoreRAID5 = ByteReader.ReadByte(buffer, offset + 69) == 1;
-        }
-
-        protected override void WriteOperationParameters(byte[] buffer, int offset)
-        {
-            BigEndianWriter.WriteGuidBytes(buffer, offset + 0, VolumeGuid);
-            BigEndianWriter.WriteUInt64(buffer, offset + 16, NumberOfCommittedSectors);
-
-            BigEndianWriter.WriteUInt64(buffer, offset + 24, ExtentID);
-            BigEndianWriter.WriteUInt64(buffer, offset + 32, OldStartSector);
-            BigEndianWriter.WriteUInt64(buffer, offset + 40, NewStartSector);
-            BigEndianWriter.WriteUInt64(buffer, offset + 48, BootRecordBackupSector);
-            BigEndianWriter.WriteUInt64(buffer, offset + 56, BackupBufferStartSector);
-            BigEndianWriter.WriteUInt64(buffer, offset + 64, BackupBufferSizeLBA);
-            ByteWriter.WriteByte(buffer, offset + 68, Convert.ToByte(RestoreFromBuffer));
-            ByteWriter.WriteByte(buffer, offset + 69, Convert.ToByte(RestoreRAID5));
-        }
-    }
-}

DiskAccessLibrary/LogicalDiskManagerHelpers/RAID5ManagerBootRecord/RAID5ManagerBootRecord.cs

@@ -1,94 +0,0 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
- * 
- * You can redistribute this program and/or modify it under the terms of
- * the GNU Lesser Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Utilities;
-
-namespace DiskAccessLibrary
-{
-    public enum RAID5ManagerOperation : ushort
-    {
-        //MoveExtent = 0x0100, // MoveExtent v0
-        MoveExtent = 0x0101, // MoveExtent v1
-        AddDiskToArray = 0x0200,
-    }
-
-    public abstract class RAID5ManagerBootRecord
-    {
-        public const int Length = 512;
-        public const string ValidSignature = "RAID5MGR";
-
-        public string Signature = ValidSignature;
-        public byte RecordRevision = 1; // Must be 1
-        protected RAID5ManagerOperation Operation; // 2 bytes
-        // reserved 5 bytes
-
-        public RAID5ManagerBootRecord()
-        { 
-
-        }
-
-        public RAID5ManagerBootRecord(byte[] buffer)
-        {
-            Signature = ByteReader.ReadAnsiString(buffer, 0, 8);
-            RecordRevision = ByteReader.ReadByte(buffer, 8);
-            Operation = (RAID5ManagerOperation)BigEndianConverter.ToUInt16(buffer, 9);
-
-            ReadOperationParameters(buffer, 16);
-        }
-
-        protected abstract void ReadOperationParameters(byte[] buffer, int offset);
-
-        public byte[] GetBytes()
-        {
-            byte[] buffer = new byte[Length];
-            ByteWriter.WriteAnsiString(buffer, 0, Signature, 8);
-            ByteWriter.WriteByte(buffer, 8, RecordRevision);
-            BigEndianWriter.WriteUInt16(buffer, 9, (ushort)Operation);
-
-            WriteOperationParameters(buffer, 16);
-
-            return buffer;
-        }
-
-        protected abstract void WriteOperationParameters(byte[] buffer, int offset);
-
-        public bool IsValid
-        {
-            get
-            {
-                return this.Signature == ValidSignature;
-            }
-        }
-
-        public static RAID5ManagerBootRecord FromBytes(byte[] buffer)
-        {
-            string signature = ByteReader.ReadAnsiString(buffer, 0, 8);
-            byte recordRevision = ByteReader.ReadByte(buffer, 8);
-            RAID5ManagerOperation operation = (RAID5ManagerOperation)BigEndianConverter.ToUInt16(buffer, 9);
-            if (signature == ValidSignature && recordRevision == 1)
-            {
-                if (operation == RAID5ManagerOperation.AddDiskToArray)
-                {
-                    return new AddDiskOperationBootRecord(buffer);
-                }
-                else if (operation == RAID5ManagerOperation.MoveExtent)
-                {
-                    return new MoveExtentOperationBootRecord(buffer);
-                }
-            }
-            return null;
-        }
-
-        public static bool HasValidSignature(byte[] buffer)
-        {
-            string signature = ByteReader.ReadAnsiString(buffer, 0, 8);
-            return (signature == ValidSignature);
-        }
-    }
-}

DiskAccessLibrary/Properties/AssemblyInfo.cs

@@ -31,5 +31,5 @@ using System.Runtime.InteropServices;
 //
 // You can specify all the values or you can default the Revision and Build Numbers 
 // by using the '*' as shown below:
-[assembly: AssemblyVersion("1.3.9.0")]
-[assembly: AssemblyFileVersion("1.3.9.0")]
+[assembly: AssemblyVersion("1.4.0.0")]
+[assembly: AssemblyFileVersion("1.4.0.0")]

DiskAccessLibrary/RevisionHistory.txt

@@ -72,3 +72,5 @@ Revision History:
 1.3.8 - Minor improvements.
 
 1.3.9 - Minor improvements.
+
+1.4.0 - API improvements.

DiskAccessLibrary/Win32/Disks/PhysicalDisk.cs

@@ -196,6 +196,7 @@ namespace DiskAccessLibrary
         /// <summary>
         /// Invalidates the cached partition table and re-enumerates the device
         /// </summary>
+        /// <exception cref="System.IO.IOException"></exception>
         public void UpdateProperties()
         {
             bool releaseHandle;
@@ -304,6 +305,7 @@ namespace DiskAccessLibrary
         /// <summary>
         /// Available on Windows Vista and newer
         /// </summary>
+        /// <exception cref="System.IO.IOException"></exception>
         public bool GetOnlineStatus(out bool isReadOnly)
         {
             bool releaseHandle;
@@ -340,6 +342,7 @@ namespace DiskAccessLibrary
         /// <summary>
         /// Available on Windows Vista and newer
         /// </summary>
+        /// <exception cref="System.IO.IOException"></exception>
         public bool SetOnlineStatus(bool online, bool persist)
         {
             bool releaseHandle;

DiskAccessLibrary/Win32/Helpers/LockHelper.cs

@@ -1,4 +1,4 @@
-/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+/* Copyright (C) 2014-2016 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  * 
  * You can redistribute this program and/or modify it under the terms of
  * the GNU Lesser Public License as published by the Free Software Foundation,
@@ -8,69 +8,95 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using DiskAccessLibrary;
-using DiskAccessLibrary.LogicalDiskManager;
 
-namespace DiskAccessLibrary.LogicalDiskManager
+namespace DiskAccessLibrary
 {
     public enum LockStatus
-    { 
+    {
         Success,
         CannotLockDisk,
         CannotLockVolume,
     }
 
-    public class LockHelper
+    public partial class LockHelper
     {
-        private static List<DynamicDisk> m_lockedDisks = new List<DynamicDisk>();
-        private static List<DynamicVolume> m_lockedVolumes = new List<DynamicVolume>();
-
-        public static LockStatus LockAllOrNone(List<DynamicDisk> disksToLock, List<DynamicVolume> volumesToLock)
+        /// <summary>
+        /// Will lock physical basic disk and all volumes on it.
+        /// If the operation is not completed successfully, all locks will be releases.
+        /// </summary>
+        public static LockStatus LockBasicDiskAndVolumesOrNone(PhysicalDisk disk)
         {
-            bool success = DiskLockHelper.LockAllOrNone(disksToLock);
+            bool success = disk.ExclusiveLock();
             if (!success)
             {
                 return LockStatus.CannotLockDisk;
             }
+            List<Partition> partitions = BasicDiskHelper.GetPartitions(disk);
+            List<Guid> volumeGuids = new List<Guid>();
+            foreach (Partition partition in partitions)
+            {
+                Guid? windowsVolumeGuid = WindowsVolumeHelper.GetWindowsVolumeGuid(partition);
+                if (windowsVolumeGuid.HasValue)
+                {
+                    volumeGuids.Add(windowsVolumeGuid.Value);
+                }
+                else
+                {
+                    return LockStatus.CannotLockVolume;
+                }
+            }
 
-            success = WindowsDynamicVolumeHelper.LockAllMountedOrNone(volumesToLock);
+            success = LockAllMountedVolumesOrNone(volumeGuids);
             if (!success)
             {
-                DiskLockHelper.ReleaseLock(disksToLock);
+                disk.ReleaseLock();
                 return LockStatus.CannotLockVolume;
             }
-
             return LockStatus.Success;
         }
 
-        public static LockStatus LockAllDynamicDisks(bool lockAllDynamicVolumes)
+        public static void UnlockBasicDiskAndVolumes(PhysicalDisk disk)
         {
-            List<DynamicDisk> disksToLock = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks();
-            List<DynamicVolume> volumesToLock = new List<DynamicVolume>();
-
-            if (lockAllDynamicVolumes)
+            List<Partition> partitions = BasicDiskHelper.GetPartitions(disk);
+            foreach (Partition partition in partitions)
             {
-                volumesToLock = WindowsDynamicVolumeHelper.GetLockableDynamicVolumes(disksToLock);
+                Guid? windowsVolumeGuid = WindowsVolumeHelper.GetWindowsVolumeGuid(partition);
+                if (windowsVolumeGuid.HasValue)
+                {
+                    if (WindowsVolumeManager.IsMounted(windowsVolumeGuid.Value))
+                    {
+                        WindowsVolumeManager.ReleaseLock(windowsVolumeGuid.Value);
+                    }
+                }
             }
 
-            LockStatus status = LockAllOrNone(disksToLock, volumesToLock);
-            if (status == LockStatus.Success)
-            {
-                m_lockedDisks.AddRange(disksToLock);
-                m_lockedVolumes.AddRange(volumesToLock);
-            }
-            return status;
+            disk.ReleaseLock();
         }
 
-        public static void UnlockAllDisksAndVolumes()
+        public static bool LockAllMountedVolumesOrNone(List<Guid> volumeGuids)
         {
-            DiskLockHelper.ReleaseLock(m_lockedDisks);
+            bool success = true;
+            int lockIndex;
+            for (lockIndex = 0; lockIndex < volumeGuids.Count; lockIndex++)
+            {
+                // NOTE: The fact that a volume does not have mount points, does not mean it is not mounted and cannot be accessed by Windows
+                success = WindowsVolumeManager.ExclusiveLockIfMounted(volumeGuids[lockIndex]);
+                if (!success)
+                {
+                    break;
+                }
+            }
 
-            foreach (DynamicVolume volumeToUnlock in m_lockedVolumes)
+            if (!success)
             {
-                WindowsVolumeManager.ReleaseLock(volumeToUnlock.VolumeGuid);
+                // release the volumes that were locked
+                for (int index = 0; index < lockIndex; index++)
+                {
+                    WindowsVolumeManager.ReleaseLock(volumeGuids[lockIndex]);
+                }
             }
-            m_lockedDisks.Clear();
-            m_lockedVolumes.Clear();
+
+            return success;
         }
     }
-}
+}

DiskAccessLibrary/Win32/Helpers/DiskLockHelper.cs

@@ -9,7 +9,7 @@ using System.Collections.Generic;
 using System.Text;
 using DiskAccessLibrary.LogicalDiskManager;
 
-namespace DiskAccessLibrary
+namespace DiskAccessLibrary.LogicalDiskManager
 {
     public class DiskLockHelper
     {

DiskAccessLibrary/Win32/LogicalDiskManager/LockHelper.cs

@@ -0,0 +1,35 @@
+/* Copyright (C) 2014-2016 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+ * 
+ * You can redistribute this program and/or modify it under the terms of
+ * the GNU Lesser Public License as published by the Free Software Foundation,
+ * either version 3 of the License, or (at your option) any later version.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using DiskAccessLibrary.LogicalDiskManager;
+
+namespace DiskAccessLibrary
+{
+    public partial class LockHelper
+    {
+        public static LockStatus LockAllOrNone(List<DynamicDisk> disksToLock, List<DynamicVolume> volumesToLock)
+        {
+            bool success = DiskLockHelper.LockAllOrNone(disksToLock);
+            if (!success)
+            {
+                return LockStatus.CannotLockDisk;
+            }
+
+            List<Guid> volumeGuids = DynamicVolumeHelper.GetVolumeGuids(volumesToLock);
+            success = LockAllMountedVolumesOrNone(volumeGuids);
+            if (!success)
+            {
+                DiskLockHelper.ReleaseLock(disksToLock);
+                return LockStatus.CannotLockVolume;
+            }
+
+            return LockStatus.Success;
+        }
+    }
+}

DiskAccessLibrary/Win32/LogicalDiskManager/LockManager.cs

@@ -0,0 +1,51 @@
+/* Copyright (C) 2014 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+ * 
+ * You can redistribute this program and/or modify it under the terms of
+ * the GNU Lesser Public License as published by the Free Software Foundation,
+ * either version 3 of the License, or (at your option) any later version.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using DiskAccessLibrary;
+using DiskAccessLibrary.LogicalDiskManager;
+
+namespace DiskAccessLibrary.LogicalDiskManager
+{
+    public class LockManager
+    {
+        private static List<DynamicDisk> m_lockedDisks = new List<DynamicDisk>();
+        private static List<DynamicVolume> m_lockedVolumes = new List<DynamicVolume>();
+
+        public static LockStatus LockAllDynamicDisks(bool lockAllDynamicVolumes)
+        {
+            List<DynamicDisk> disksToLock = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks();
+            List<DynamicVolume> volumesToLock = new List<DynamicVolume>();
+
+            if (lockAllDynamicVolumes)
+            {
+                volumesToLock = WindowsDynamicVolumeHelper.GetLockableDynamicVolumes(disksToLock);
+            }
+
+            LockStatus status = LockHelper.LockAllOrNone(disksToLock, volumesToLock);
+            if (status == LockStatus.Success)
+            {
+                m_lockedDisks.AddRange(disksToLock);
+                m_lockedVolumes.AddRange(volumesToLock);
+            }
+            return status;
+        }
+
+        public static void UnlockAllDisksAndVolumes()
+        {
+            DiskLockHelper.ReleaseLock(m_lockedDisks);
+
+            foreach (DynamicVolume volumeToUnlock in m_lockedVolumes)
+            {
+                WindowsVolumeManager.ReleaseLock(volumeToUnlock.VolumeGuid);
+            }
+            m_lockedDisks.Clear();
+            m_lockedVolumes.Clear();
+        }
+    }
+}

DiskAccessLibrary/Win32/Helpers/WindowsDynamicDiskHelper.cs

@@ -8,10 +8,9 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using DiskAccessLibrary.LogicalDiskManager;
 using Utilities;
 
-namespace DiskAccessLibrary
+namespace DiskAccessLibrary.LogicalDiskManager
 {
     public class WindowsDynamicDiskHelper
     {

DiskAccessLibrary/Win32/Helpers/WindowsDynamicVolumeHelper.cs

@@ -7,10 +7,9 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using DiskAccessLibrary.LogicalDiskManager;
 using Utilities;
 
-namespace DiskAccessLibrary
+namespace DiskAccessLibrary.LogicalDiskManager
 {
     public class WindowsDynamicVolumeHelper
     {
@@ -35,31 +34,5 @@ namespace DiskAccessLibrary
 
             return DynamicVolumeHelper.GetDynamicVolumes(disks);
         }
-
-        public static bool LockAllMountedOrNone(List<DynamicVolume> volumes)
-        {
-            bool success = true;
-            int lockIndex;
-            for (lockIndex = 0; lockIndex < volumes.Count; lockIndex++)
-            {
-                // NOTE: The fact that a volume does not have mount points, does not mean it is not mounted and cannot be accessed by Windows
-                success = WindowsVolumeManager.ExclusiveLockIfMounted(volumes[lockIndex].VolumeGuid);
-                if (!success)
-                {
-                    break;
-                }
-            }
-
-            if (!success)
-            {
-                // release the volumes that were locked
-                for (int index = 0; index < lockIndex; index++)
-                {
-                    WindowsVolumeManager.ReleaseLock(volumes[index].VolumeGuid);
-                }
-            }
-
-            return success;
-        }
     }
 }