Updated DiskAccessLibrary to v1.4.3

DiskAccessLibrary/DiskAccessLibrary.csproj

@@ -113,7 +113,6 @@
     <Compile Include="LogicalDiskManager\Enums\ReadPolicyName.cs" />
     <Compile Include="LogicalDiskManager\Enums\RecordType.cs" />
     <Compile Include="LogicalDiskManager\Enums\VolumeFlags.cs" />
-    <Compile Include="LogicalDiskManager\Exceptions\DatabaseNotFoundException.cs" />
     <Compile Include="LogicalDiskManager\Exceptions\MissingDatabaseRecordException.cs" />
     <Compile Include="LogicalDiskManager\Helpers\DynamicDiskExtentHelper.cs" />
     <Compile Include="LogicalDiskManager\Helpers\DynamicDiskExtentsHelper.cs" />
@@ -130,6 +129,7 @@
     <Compile Include="LogicalDiskManager\TOCBlock\TOCBlock.cs" />
     <Compile Include="LogicalDiskManager\TOCBlock\TOCRegion.cs" />
     <Compile Include="LogicalDiskManager\VolumeManagerDatabase.cs" />
+    <Compile Include="LogicalDiskManager\VolumeManagerDatabaseCopy.cs" />
     <Compile Include="LogicalDiskManager\VolumeManagerDatabaseHeader.cs" />
     <Compile Include="LogicalDiskManager\Volumes\DynamicColumn.cs" />
     <Compile Include="LogicalDiskManager\Volumes\DynamicVolume.cs" />

DiskAccessLibrary/FileSystems/NTFS/Adapters/NTFSFileSystem.cs

@@ -167,6 +167,11 @@ namespace DiskAccessLibrary.FileSystems.NTFS
             m_volume.Extend(numberOfAdditionalSectors);
         }
 
+        public override string ToString()
+        {
+            return m_volume.ToString();
+        }
+
         public override string Name
         {
             get

DiskAccessLibrary/FileSystems/NTFS/FileRecord/FileRecordSegment.cs

@@ -287,7 +287,7 @@ namespace DiskAccessLibrary.FileSystems.NTFS
         public static byte[] GetEndMarker()
         {
             byte[] buffer = new byte[4];
-            Array.Copy(LittleEndianConverter.GetBytes(0xFFFFFFFF), buffer, 4);
+            LittleEndianWriter.WriteUInt32(buffer, 0, 0xFFFFFFFF);
             return buffer;
         }
 

DiskAccessLibrary/FileSystems/NTFS/FileRecord/MultiSectorHelper.cs

@@ -54,7 +54,7 @@ namespace DiskAccessLibrary.FileSystems.NTFS
             // Overwrite the bytes that are replaced with the USN
             for (int i = 0; i < updateSequenceReplacementData.Count; i++)
             {
-                Array.Copy(LittleEndianConverter.GetBytes(updateSequenceNumber), 0, buffer, offset + (BytesPerStride * (i + 1)) - 2, 2);
+                LittleEndianWriter.WriteUInt16(buffer, offset + (BytesPerStride * (i + 1)) - 2, updateSequenceNumber);
             }
 
             return updateSequenceReplacementData;

DiskAccessLibrary/FileSystems/NTFS/NTFSBootRecord.cs

@@ -78,24 +78,24 @@ namespace DiskAccessLibrary.FileSystems.NTFS
         {
             byte[] buffer = new byte[BytesPerSector];
             Array.Copy(Jump, 0, buffer, 0x00, 3);
-            Array.Copy(ASCIIEncoding.ASCII.GetBytes(OEMID), 0, buffer, 0x03, Math.Min(8, OEMID.Length));
+            ByteWriter.WriteAnsiString(buffer, 0x03, OEMID, 8);
 
-            Array.Copy(LittleEndianConverter.GetBytes(BytesPerSector), 0, buffer, 0x0B, 2);
+            LittleEndianWriter.WriteUInt16(buffer, 0x0B, BytesPerSector);
             buffer[0x0D] = SectorsPerCluster;
             buffer[0x15] = MediaDescriptor;
-            Array.Copy(LittleEndianConverter.GetBytes(SectorsPerTrack), 0, buffer, 0x18, 2);
-            Array.Copy(LittleEndianConverter.GetBytes(NumberOfHeads), 0, buffer, 0x1A, 2);
-            Array.Copy(LittleEndianConverter.GetBytes(NumberOfHiddenSectors), 0, buffer, 0x1C, 4);
+            LittleEndianWriter.WriteUInt16(buffer, 0x18, SectorsPerTrack);
+            LittleEndianWriter.WriteUInt16(buffer, 0x1A, NumberOfHeads);
+            LittleEndianWriter.WriteUInt32(buffer, 0x1C, NumberOfHiddenSectors);
 
             buffer[0x24] = PhysicalDriveNumber;
             buffer[0x26] = ExtendedBootSignature;
-            Array.Copy(LittleEndianConverter.GetBytes(TotalSectors), 0, buffer, 0x28, 8);
-            Array.Copy(LittleEndianConverter.GetBytes(MftStartLCN), 0, buffer, 0x30, 8);
-            Array.Copy(LittleEndianConverter.GetBytes(MftMirrorStartLCN), 0, buffer, 0x38, 8);
+            LittleEndianWriter.WriteUInt64(buffer, 0x28, TotalSectors);
+            LittleEndianWriter.WriteUInt64(buffer, 0x30, MftStartLCN);
+            LittleEndianWriter.WriteUInt64(buffer, 0x38, MftMirrorStartLCN);
             buffer[0x40] = (byte)RawClustersPerFileRecordSegment;
             buffer[0x44] = (byte)RawClustersPerIndexBlock;
-            Array.Copy(LittleEndianConverter.GetBytes(VolumeSerialNumber), 0, buffer, 0x48, 8);
-            Array.Copy(LittleEndianConverter.GetBytes(Checksum), 0, buffer, 0x50, 4);
+            LittleEndianWriter.WriteUInt64(buffer, 0x48, VolumeSerialNumber);
+            LittleEndianWriter.WriteUInt32(buffer, 0x50, Checksum);
 
             Array.Copy(Code, 0, buffer, 0x54, Code.Length);
             return buffer;

DiskAccessLibrary/LogicalDiskManager/DiskGroupDatabase.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,
@@ -14,38 +14,15 @@ namespace DiskAccessLibrary.LogicalDiskManager
 {
     public partial class DiskGroupDatabase : VolumeManagerDatabase
     {
-        List<DynamicDisk> m_disks = new List<DynamicDisk>(); // when updating the database, all dynamic disks in the system should be added
+        List<DynamicDisk> m_disks = new List<DynamicDisk>(); // when updating the database, all dynamic disks in the group should be added
 
         public DiskGroupDatabase(List<DynamicDisk> disks, VolumeManagerDatabaseHeader databaseHeader, List<DatabaseRecord> databaseRecords, KernelUpdateLog kernelUpdateLog)
-            : base(disks[0], databaseHeader, databaseRecords, kernelUpdateLog)
+            : base(databaseHeader, databaseRecords, kernelUpdateLog)
         {
             m_disks = disks;
         }
 
-        public override void VerifyDatabaseConsistency()
-        {
-            base.VerifyDatabaseConsistency();
-            
-            // Make sure database is identical across disks
-            for (int index = 1; index < m_disks.Count; index++)
-            {
-                VolumeManagerDatabase seconary = VolumeManagerDatabase.ReadFromDisk(m_disks[index]);
-                seconary.VerifyDatabaseConsistency();
-
-                if (this.DatabaseHeader.DiskGroupGuidString != seconary.DatabaseHeader.DiskGroupGuidString ||
-                    this.DatabaseHeader.DiskGroupName != seconary.DatabaseHeader.DiskGroupName)
-                {
-                    throw new NotImplementedException("More than one disk group detected");
-                }
-
-                if (this.DatabaseHeader.CommitTransactionID != seconary.DatabaseHeader.CommitTransactionID)
-                {
-                    throw new NotImplementedException("Inconsistent disk group state");
-                }
-            }
-        }
-
-        protected override void WriteDatabaseHeader()
+        public override void WriteDatabaseHeader()
         {
             foreach (DynamicDisk disk in m_disks)
             {
@@ -53,7 +30,7 @@ namespace DiskAccessLibrary.LogicalDiskManager
             }
         }
 
-        protected override void WriteDatabaseRecordFragment(DatabaseRecordFragment fragment)
+        public override void WriteDatabaseRecordFragment(DatabaseRecordFragment fragment)
         {
             foreach (DynamicDisk disk in m_disks)
             {
@@ -61,7 +38,7 @@ namespace DiskAccessLibrary.LogicalDiskManager
             }
         }
 
-        protected override void SetKernelUpdateLogLastEntry(ulong committedTransactionID, ulong pendingTransactionID)
+        public override void SetKernelUpdateLogLastEntry(ulong committedTransactionID, ulong pendingTransactionID)
         {
             foreach (DynamicDisk disk in m_disks)
             {
@@ -104,16 +81,72 @@ namespace DiskAccessLibrary.LogicalDiskManager
             foreach (List<DynamicDisk> groupDisks in groups.Values)
             {
                 VolumeManagerDatabase database = VolumeManagerDatabase.ReadFromDisk(groupDisks[0]);
-                if (database != null) // if there is issue with one disk (such as unsupported version) we skip the group entirely
+                if (database != null && !database.IsDirty)
                 {
                     DiskGroupDatabase groupDatabase = new DiskGroupDatabase(groupDisks, database.DatabaseHeader, database.DatabaseRecords, database.KernelUpdateLog);
-                    result.Add(groupDatabase);
+                    // if there is issue with one disk we skip the group entirely
+                    if (!groupDatabase.IsDirty)
+                    {
+                        result.Add(groupDatabase);
+                    }
                 }
             }
 
             return result;
         }
 
+        public override bool IsDirty
+        {
+            get
+            {
+                return !this.IsIdenticalAcrossAllDisks || base.IsDirty;
+            }
+        }
+
+        public bool IsIdenticalAcrossAllDisks
+        {
+            get
+            {
+                // Make sure database is identical across disks
+                for (int index = 1; index < m_disks.Count; index++)
+                {
+                    VolumeManagerDatabase seconary = VolumeManagerDatabase.ReadFromDisk(m_disks[index]);
+                    if (seconary.IsDirty)
+                    {
+                        return false;
+                    }
+
+                    if (this.DatabaseHeader.DiskGroupGuidString != seconary.DatabaseHeader.DiskGroupGuidString ||
+                        this.DatabaseHeader.DiskGroupName != seconary.DatabaseHeader.DiskGroupName)
+                    {
+                        return false;
+                    }
+
+                    if (this.DatabaseHeader.CommitTransactionID != seconary.DatabaseHeader.CommitTransactionID)
+                    {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
+
+        public bool AreDisksMissing
+        {
+            get
+            {
+                List<DiskRecord> diskRecords = this.DiskRecords;
+                foreach (DiskRecord diskRecord in diskRecords)
+                {
+                    if (DynamicDiskHelper.FindDisk(m_disks, diskRecord.DiskGuid) == null)
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+
         public List<DynamicDisk> Disks
         {
             get

DiskAccessLibrary/LogicalDiskManager/DynamicDisk.cs

@@ -57,6 +57,14 @@ namespace DiskAccessLibrary.LogicalDiskManager
             }
         }
 
+        public Guid DiskGroupGuid
+        {
+            get
+            {
+                return PrivateHeader.DiskGroupGuid;
+            }
+        }
+
         public int BytesPerSector
         {
             get

DiskAccessLibrary/LogicalDiskManager/Exceptions/DatabaseNotFoundException.cs

@@ -1,21 +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.IO;
-
-namespace System
-{
-    public class DatabaseNotFoundException : SystemException
-    {
-        public DatabaseNotFoundException() : base()
-        {
-        }
-
-        public DatabaseNotFoundException(string message) : base(message)
-        {
-        }
-    }
-}

DiskAccessLibrary/LogicalDiskManager/Exceptions/MissingDatabaseRecordException.cs

@@ -1,14 +1,15 @@
-/* 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,
  * either version 3 of the License, or (at your option) any later version.
  */
+using System;
 using System.IO;
 
-namespace System
+namespace DiskAccessLibrary.LogicalDiskManager
 {
-    public class MissingDatabaseRecordException : SystemException
+    public class MissingDatabaseRecordException : Exception
     {
         public MissingDatabaseRecordException() : base()
         {

DiskAccessLibrary/LogicalDiskManager/Helpers/DynamicDiskHelper.Extents.cs

@@ -143,35 +143,41 @@ namespace DiskAccessLibrary.LogicalDiskManager
         }
 
         /// <param name="targetOffset">in bytes</param>
-        public static bool IsMoveLocationValid(DynamicDisk disk, DynamicDiskExtent sourceExtent, long targetOffset)
+        public static bool IsMoveLocationValid(DynamicDiskExtent sourceExtent, DynamicDisk targetDisk, long targetOffset)
         {
-            List<DynamicDiskExtent> extents = GetDiskExtents(disk);
+            bool isSameDisk = (sourceExtent.Disk == targetDisk.Disk);
+            List<DynamicDiskExtent> extents = GetDiskExtents(targetDisk);
             // extents are sorted by first sector
             if (extents == null)
             {
                 return false;
             }
 
-            PrivateHeader privateHeader = disk.PrivateHeader;
+            PrivateHeader privateHeader = targetDisk.PrivateHeader;
+            if (sourceExtent.BytesPerSector != targetDisk.BytesPerSector)
+            {
+                // We must not move an extent to another disk that has different sector size
+                return false;
+            }
             if (targetOffset % privateHeader.BytesPerSector > 0)
             {
                 return false;
             }
-            long targetSector = targetOffset / disk.BytesPerSector;
-            DiskExtent targetExtent = new DiskExtent(disk.Disk, targetSector, sourceExtent.Size);
+            long targetSector = targetOffset / targetDisk.BytesPerSector;
+            DiskExtent targetExtent = new DiskExtent(targetDisk.Disk, targetSector, sourceExtent.Size);
 
             List<DiskExtent> usedExtents = new List<DiskExtent>();
-            foreach (DynamicDiskExtent usedExtent in usedExtents)
+            foreach (DynamicDiskExtent extent in extents)
             {
-                if (usedExtent.FirstSector != sourceExtent.FirstSector)
+                if (!isSameDisk || extent.FirstSector != sourceExtent.FirstSector)
                 {
-                    usedExtents.Add(usedExtent);
+                    usedExtents.Add(extent);
                 }
             }
 
             long publicRegionStartSector = (long)privateHeader.PublicRegionStartLBA;
-            long publicRegionSize = (long)privateHeader.PublicRegionSizeLBA * disk.BytesPerSector;
-            List<DiskExtent> unallocatedExtents = DiskExtentsHelper.GetUnallocatedExtents(disk.Disk, publicRegionStartSector, publicRegionSize, usedExtents);
+            long publicRegionSize = (long)privateHeader.PublicRegionSizeLBA * targetDisk.BytesPerSector;
+            List<DiskExtent> unallocatedExtents = DiskExtentsHelper.GetUnallocatedExtents(targetDisk.Disk, publicRegionStartSector, publicRegionSize, usedExtents);
             foreach (DiskExtent extent in unallocatedExtents)
             {
                 if (extent.FirstSector <= targetExtent.FirstSector && targetExtent.LastSector <= extent.LastSector)

DiskAccessLibrary/LogicalDiskManager/Helpers/DynamicDiskHelper.cs

@@ -18,15 +18,25 @@ namespace DiskAccessLibrary.LogicalDiskManager
         {
             foreach (DynamicDisk dynamicDisk in disks)
             {
-                if (dynamicDisk != null)
+                if (dynamicDisk.DiskGuid == diskGuid)
                 {
-                    if (dynamicDisk.DiskGuid == diskGuid)
-                    {
-                        return dynamicDisk;
-                    }
+                    return dynamicDisk;
                 }
             }
             return null;
         }
+
+        public static List<DynamicDisk> FindDiskGroup(List<DynamicDisk> disks, Guid diskGroupGuid)
+        {
+            List<DynamicDisk> result = new List<DynamicDisk>();
+            foreach (DynamicDisk dynamicDisk in disks)
+            {
+                if (dynamicDisk.DiskGroupGuid == diskGroupGuid)
+                {
+                    result.Add(dynamicDisk);
+                }
+            }
+            return result;
+        }
     }
 }

DiskAccessLibrary/LogicalDiskManager/VolumeManagerDatabase.cs

@@ -6,25 +6,20 @@
  */
 using System;
 using System.Collections.Generic;
-using System.Text;
-using Utilities;
 
 namespace DiskAccessLibrary.LogicalDiskManager
 {
-    public class VolumeManagerDatabase
+    public abstract class VolumeManagerDatabase
     {
         public const uint FirstSequenceNumber = 4; // SequenceNumber starts from 4 (0-3 are taken by the VMDB)
 
-        private DynamicDisk m_disk;
         private VolumeManagerDatabaseHeader m_databaseHeader;
         private List<DatabaseRecord> m_databaseRecords;
         private KernelUpdateLog m_kernelUpdateLog;
-        
         private ulong m_nextRecordID;
 
-        public VolumeManagerDatabase(DynamicDisk disk, VolumeManagerDatabaseHeader databaseHeader, List<DatabaseRecord> databaseRecords, KernelUpdateLog kernelUpdateLog)
+        public VolumeManagerDatabase(VolumeManagerDatabaseHeader databaseHeader, List<DatabaseRecord> databaseRecords, KernelUpdateLog kernelUpdateLog)
         {
-            m_disk = disk;
             m_databaseHeader = databaseHeader;
             m_databaseRecords = databaseRecords;
             m_kernelUpdateLog = kernelUpdateLog;
@@ -38,6 +33,10 @@ namespace DiskAccessLibrary.LogicalDiskManager
             return m_nextRecordID - 1;
         }
 
+        public abstract void WriteDatabaseHeader();
+        public abstract void WriteDatabaseRecordFragment(DatabaseRecordFragment fragment);
+        public abstract void SetKernelUpdateLogLastEntry(ulong committedTransactionID, ulong pendingTransactionID);
+
         // Steps to update the database (as performed by Windows):
         // -------------------------------------------------------
         // 1. We create all the new records as 'pending activation', and mark old records as 'pending deletion'.
@@ -46,17 +45,17 @@ namespace DiskAccessLibrary.LogicalDiskManager
         // 4. We mark the database header update status as 'Commit'.
         // 5. We delete all the 'pending deletion' records, and activate all the 'pending activation' records
         // 6. We mark the database header as 'Clean', and update CommitTransactionID (set it to PendingTransactionID) and the number of committed VBlks.
-        
+
         // Notes:
         // ------
         // 1. The volume manager database and kernel update log ('config' and 'log' regions) are identical across all disks (not including the PRIVHEAD
         //    and TOCBLOCKs of course), and should be kept identical (each step should be performed across all disks before proceeding to the next step).
-        // 2.  I've always encountered steps 1 and 2 within the same write operation, so the order may be the other way around.
+        // 2. I've always encountered steps 1 and 2 within the same write operation, so the order may be the other way around.
         // 3. If an update operation has been terminated (power failure) before step 4 has been reach, Windows will roll back the changes made,
         //    Once step 4 has been performed, Windows will commit the changes made.
         // 4. When a disk is being modified (volume is being added / deleted etc.), Windows / Veritas Storage Foundation updates the disk record,
         //    and a new CommitTransactionID is applied.
-        
+
         /// <param name="records">New or modified records (.e.g. new volume, volume with modified size etc.)</param>
         public void UpdateDatabase(List<DatabaseRecord> records)
         {
@@ -71,7 +70,10 @@ namespace DiskAccessLibrary.LogicalDiskManager
                     }
                 }
             }
-            VerifyDatabaseConsistency();
+            if (this.IsDirty)
+            {
+                throw new Exception("Database is in inconsistent state");
+            }
 
             // step 1:
             MarkOldRecordsAsPendingDeletion(records);
@@ -97,11 +99,11 @@ namespace DiskAccessLibrary.LogicalDiskManager
 
             // step 3:
             SetKernelUpdateLogLastEntry(m_databaseHeader.CommitTransactionID, pendingTransactionID);
-            
+
             // step 4:
             m_databaseHeader.UpdateStatus = DatabaseHeaderUpdateStatus.Commit;
             WriteDatabaseHeader();
-            
+
             // step 5:
             DeletePendingDeletionRecords();
             ActivatePendingActivationRecords();
@@ -118,27 +120,13 @@ namespace DiskAccessLibrary.LogicalDiskManager
             m_nextRecordID = m_databaseHeader.CommitTransactionID + 1;
         }
 
-        virtual public void VerifyDatabaseConsistency()
-        {
-            if (m_databaseHeader.PendingTransactionID != m_databaseHeader.CommitTransactionID ||
-                m_databaseHeader.UpdateStatus != DatabaseHeaderUpdateStatus.Clean)
-            {
-                throw new Exception("Database is in inconsistent state");
-            }
-
-            if (m_databaseHeader.MajorVersion != 4 || m_databaseHeader.MinorVersion != 10)
-            {
-                throw new NotImplementedException("Database version is not supported");
-            }
-        }
-
         /// <summary>
         /// mark old records as pending deletion and return them
         /// </summary>
         private void MarkOldRecordsAsPendingDeletion(List<DatabaseRecord> newRecords)
         {
             foreach (DatabaseRecord newRecord in newRecords)
-            { 
+            {
                 int index = m_databaseRecords.IndexOf(newRecord);
                 if (index >= 0) // same record ID exist
                 {
@@ -262,72 +250,30 @@ namespace DiskAccessLibrary.LogicalDiskManager
             }
         }
 
-        virtual protected void WriteDatabaseHeader()
-        {
-            VolumeManagerDatabaseHeader.WriteToDisk(m_disk, m_databaseHeader);
-        }
-
-        virtual protected void WriteDatabaseRecordFragment(DatabaseRecordFragment fragment)
+        /// <param name="startFromSequenceNumber">We use startSequenceNumber to avoid using the same SequenceNumber twice</param>
+        private uint GetAvailableFragmentSequenceNumber(uint startFromSequenceNumber)
         {
-            WriteDatabaseRecordFragment(m_disk, fragment, (int)m_databaseHeader.BlockSize);
-        }
-
-        virtual protected void SetKernelUpdateLogLastEntry(ulong committedTransactionID, ulong pendingTransactionID)
-        {
-            m_kernelUpdateLog.SetLastEntry(m_disk, committedTransactionID, pendingTransactionID);
-        }
-        
-        /// <param name="searchFrom">We use startSequenceNumber to avoid using the same SequenceNumber twice</param>
-        public uint GetAvailableFragmentSequenceNumber(uint startFromSequenceNumber)
-        {
-            List<uint> sequenceNumbers = new List<uint>();
-            foreach (DatabaseRecord record in m_databaseRecords)
+            uint? sequenceNumber = GetAvailableFragmentSequenceNumber(m_databaseRecords, startFromSequenceNumber, m_databaseHeader.NumberOfVBlks);
+            if (!sequenceNumber.HasValue)
             {
-                foreach (DatabaseRecordFragment fragment in record.Fragments)
-                { 
-                    sequenceNumbers.Add(fragment.SequenceNumber);
-                }
+                throw new Exception("VMDB is full");
             }
-            sequenceNumbers.Sort();
-
-            for (uint sequenceNumber = startFromSequenceNumber; sequenceNumber < m_databaseHeader.NumberOfVBlks; sequenceNumber++)
-            {
-                if (!sequenceNumbers.Contains(sequenceNumber))
-                {
-                    return sequenceNumber;
-                }
-            }
-
-            throw new Exception("VMDB is full");
+            return sequenceNumber.Value;
         }
 
-        /// <param name="searchFrom">We use startFromGroupNumber to avoid using the same GroupNumber twice</param>
-        public uint GetAvailableFragmentGroupNumber(uint startFromGroupNumber)
+        /// <param name="startFromGroupNumber">We use startFromGroupNumber to avoid using the same GroupNumber twice</param>
+        private uint GetAvailableFragmentGroupNumber(uint startFromGroupNumber)
         {
-            List<uint> groupNumbers = new List<uint>();
-            foreach (DatabaseRecord record in m_databaseRecords)
+            uint? groupNumber = GetAvailableFragmentGroupNumber(m_databaseRecords, startFromGroupNumber, m_databaseHeader.NumberOfVBlks);
+            if (!groupNumber.HasValue)
             {
-                foreach (DatabaseRecordFragment fragment in record.Fragments)
-                {
-                    groupNumbers.Add(fragment.GroupNumber);
-                }
-            }
-            groupNumbers.Sort();
-
-            // number of groups can't be bigger than the number of fragments
-            for (uint groupNumber = startFromGroupNumber; groupNumber < m_databaseHeader.NumberOfVBlks; groupNumber++)
-            {
-                if (!groupNumbers.Contains(groupNumber))
-                {
-                    return groupNumber;
-                }
+                throw new Exception("VMDB is full");
             }
-
-            throw new Exception("VMDB is full, can't find available GroupNumber");
+            return groupNumber.Value;
         }
 
-        public List<T> GetRecords<T>() where T:DatabaseRecord
-        { 
+        private List<T> GetRecords<T>() where T : DatabaseRecord
+        {
             List<T> result = new List<T>();
             foreach (DatabaseRecord record in m_databaseRecords)
             {
@@ -339,7 +285,7 @@ namespace DiskAccessLibrary.LogicalDiskManager
             return result;
         }
 
-        public List<T> GetActiveRecords<T>() where T : DatabaseRecord
+        private List<T> GetActiveRecords<T>() where T : DatabaseRecord
         {
             List<T> result = new List<T>();
             foreach (DatabaseRecord record in m_databaseRecords)
@@ -352,7 +298,7 @@ namespace DiskAccessLibrary.LogicalDiskManager
             return result;
         }
 
-        public uint GetPendingTotalNumberOfRecords<T>() where T : DatabaseRecord
+        private uint GetPendingTotalNumberOfRecords<T>() where T : DatabaseRecord
         {
             uint result = 0;
             foreach (DatabaseRecord record in m_databaseRecords)
@@ -418,12 +364,12 @@ namespace DiskAccessLibrary.LogicalDiskManager
                     result.Add(record);
                 }
             }
-            
+
             result.Sort(CompareByOffsetInColumn);
             //result.Sort(CompareByColumnIndex);
             return result;
         }
-        
+
         public List<ExtentRecord> FindExtentsByDiskID(ulong diskID)
         {
             List<ExtentRecord> result = new List<ExtentRecord>();
@@ -496,7 +442,7 @@ namespace DiskAccessLibrary.LogicalDiskManager
                 return m_kernelUpdateLog;
             }
         }
-        
+
         public List<DiskRecord> DiskRecords
         {
             get
@@ -537,6 +483,15 @@ namespace DiskAccessLibrary.LogicalDiskManager
             }
         }
 
+        public virtual bool IsDirty
+        {
+            get
+            {
+                return (m_databaseHeader.PendingTransactionID != m_databaseHeader.CommitTransactionID ||
+                        m_databaseHeader.UpdateStatus != DatabaseHeaderUpdateStatus.Clean);
+            }
+        }
+
         public Guid DiskGroupGuid
         {
             get
@@ -553,58 +508,78 @@ namespace DiskAccessLibrary.LogicalDiskManager
             }
         }
 
-        public static VolumeManagerDatabase ReadFromDisk(DynamicDisk disk)
+        private static int CompareByColumnIndex(ExtentRecord x, ExtentRecord y)
         {
-            return ReadFromDisk(disk.Disk, disk.PrivateHeader, disk.TOCBlock);
+            return x.ColumnIndex.CompareTo(y.ColumnIndex);
         }
 
-        public static VolumeManagerDatabase ReadFromDisk(Disk disk)
+        private static int CompareByOffsetInColumn(ExtentRecord x, ExtentRecord y)
         {
-            if (DynamicDisk.IsDynamicDisk(disk))
+            return x.OffsetInColumnLBA.CompareTo(y.OffsetInColumnLBA);
+        }
+        
+        /// <param name="startFromSequenceNumber">We use startSequenceNumber to avoid using the same SequenceNumber twice</param>
+        private static uint? GetAvailableFragmentSequenceNumber(List<DatabaseRecord> databaseRecords, uint startFromSequenceNumber, uint maxNumberOfFragments)
+        {
+            List<uint> sequenceNumbers = new List<uint>();
+            foreach (DatabaseRecord record in databaseRecords)
             {
-                PrivateHeader privateHeader = PrivateHeader.ReadFromDisk(disk);
-                if (privateHeader != null)
+                foreach (DatabaseRecordFragment fragment in record.Fragments)
                 {
-                    return ReadFromDisk(disk, privateHeader);
+                    sequenceNumbers.Add(fragment.SequenceNumber);
                 }
             }
-            return null;
-        }
+            sequenceNumbers.Sort();
 
-        public static VolumeManagerDatabase ReadFromDisk(Disk disk, PrivateHeader privateHeader)
-        {
-            TOCBlock tocBlock = TOCBlock.ReadFromDisk(disk, privateHeader);
-            if (tocBlock != null)
+            for (uint sequenceNumber = startFromSequenceNumber; sequenceNumber < maxNumberOfFragments; sequenceNumber++)
             {
-                return ReadFromDisk(disk, privateHeader, tocBlock);
+                if (!sequenceNumbers.Contains(sequenceNumber))
+                {
+                    return sequenceNumber;
+                }
             }
+
             return null;
         }
 
-        public static VolumeManagerDatabase ReadFromDisk(Disk disk, PrivateHeader privateHeader, TOCBlock tocBlock)
+        /// <param name="startFromGroupNumber">We use startFromGroupNumber to avoid using the same GroupNumber twice</param>
+        private static uint? GetAvailableFragmentGroupNumber(List<DatabaseRecord> databaseRecords, uint startFromGroupNumber, uint maxNumberOfFragments)
         {
-            VolumeManagerDatabaseHeader databaseHeader = VolumeManagerDatabaseHeader.ReadFromDisk(disk, privateHeader, tocBlock);
-            if (databaseHeader == null)
+            List<uint> groupNumbers = new List<uint>();
+            foreach (DatabaseRecord record in databaseRecords)
             {
-                return null;
+                foreach (DatabaseRecordFragment fragment in record.Fragments)
+                {
+                    groupNumbers.Add(fragment.GroupNumber);
+                }
             }
-            List<DatabaseRecord> databaseRecords = new List<DatabaseRecord>();
+            groupNumbers.Sort();
 
-            // The first VBLK entry is the subsequent entry to the VMDB header.
-            // Note: On a disk with 4KB sectors, VBLKs will reside in the same sector as the VMDB header.
-            ulong firstSector = privateHeader.PrivateRegionStartLBA + tocBlock.ConfigStart;  // we skip the VMDB
-            int databaseLength = (int)(databaseHeader.HeaderSize + databaseHeader.NumberOfVBlks * databaseHeader.BlockSize);
-            int sectorCount = (int)Math.Ceiling(databaseLength / (double)disk.BytesPerSector);
-            byte[] databaseBytes = disk.ReadSectors((long)firstSector, sectorCount);
+            // number of groups can't be bigger than the number of fragments
+            for (uint groupNumber = startFromGroupNumber; groupNumber < maxNumberOfFragments; groupNumber++)
+            {
+                if (!groupNumbers.Contains(groupNumber))
+                {
+                    return groupNumber;
+                }
+            }
+
+            return null;
+        }
 
-            // read all VBLK blocks:
+        /// <summary>
+        /// Will read all VBLK blocks and assemble the database records
+        /// </summary>
+        /// <param name="numberOfFragments">number of fragments excluding the database header</param>
+        private static List<DatabaseRecord> ReadDatabaseRecords(byte[] databaseBytes, int headerSize, int fragmentSize, int numberOfFragments)
+        {
             // Note: fragments are not necessarily contiguous!
             Dictionary<uint, List<DatabaseRecordFragment>> fragments = new Dictionary<uint, List<DatabaseRecordFragment>>();
-            for (uint index = 0; index < databaseHeader.NumberOfVBlks - 4; index++)
+            for (uint index = 0; index < numberOfFragments; index++)
             {
-                byte[] fragmentBytes = new byte[databaseHeader.BlockSize];
-                int fragmentOffset = (int)(databaseHeader.HeaderSize + index * databaseHeader.BlockSize);
-                Array.Copy(databaseBytes, fragmentOffset, fragmentBytes, 0, databaseHeader.BlockSize);
+                byte[] fragmentBytes = new byte[fragmentSize];
+                int fragmentOffset = (int)(headerSize + index * fragmentSize);
+                Array.Copy(databaseBytes, fragmentOffset, fragmentBytes, 0, fragmentSize);
                 DatabaseRecordFragment fragment = DatabaseRecordFragment.GetDatabaseRecordFragment(fragmentBytes);
 
                 if (fragment != null) // null fragment means VBLK is empty
@@ -625,21 +600,69 @@ namespace DiskAccessLibrary.LogicalDiskManager
             // We have all the fragments and we can now assemble the records:
             // We assume that fragments with lower FragmentNumber appear in the database before fragments
             // of the same group with higher FragmentNumber.
+            List<DatabaseRecord> databaseRecords = new List<DatabaseRecord>();
             foreach (List<DatabaseRecordFragment> recordFragments in fragments.Values)
             {
                 DatabaseRecord databaseRecord = DatabaseRecord.GetDatabaseRecord(recordFragments);
                 databaseRecords.Add(databaseRecord);
             }
+            return databaseRecords;
+        }
+
+        public static VolumeManagerDatabase ReadFromDisk(DynamicDisk disk)
+        {
+            return ReadFromDisk(disk.Disk, disk.PrivateHeader, disk.TOCBlock);
+        }
+
+        public static VolumeManagerDatabase ReadFromDisk(Disk disk)
+        {
+            if (DynamicDisk.IsDynamicDisk(disk))
+            {
+                PrivateHeader privateHeader = PrivateHeader.ReadFromDisk(disk);
+                if (privateHeader != null)
+                {
+                    return ReadFromDisk(disk, privateHeader);
+                }
+            }
+            return null;
+        }
+
+        public static VolumeManagerDatabase ReadFromDisk(Disk disk, PrivateHeader privateHeader)
+        {
+            TOCBlock tocBlock = TOCBlock.ReadFromDisk(disk, privateHeader);
+            if (tocBlock != null)
+            {
+                return ReadFromDisk(disk, privateHeader, tocBlock);
+            }
+            return null;
+        }
+
+        public static VolumeManagerDatabase ReadFromDisk(Disk disk, PrivateHeader privateHeader, TOCBlock tocBlock)
+        {
+            VolumeManagerDatabaseHeader databaseHeader = VolumeManagerDatabaseHeader.ReadFromDisk(disk, privateHeader, tocBlock);
+            if (databaseHeader == null || !databaseHeader.IsVersionSupported)
+            {
+                return null;
+            }
+
+            // The first VBLK entry is the subsequent entry to the VMDB header.
+            // Note: On a disk with 4KB sectors, VBLKs will reside in the same sector as the VMDB header.
+            ulong firstSector = privateHeader.PrivateRegionStartLBA + tocBlock.ConfigStart;  // we skip the VMDB
+            int databaseLength = (int)(databaseHeader.HeaderSize + databaseHeader.NumberOfVBlks * databaseHeader.BlockSize);
+            int sectorCount = (int)Math.Ceiling(databaseLength / (double)disk.BytesPerSector);
+            byte[] databaseBytes = disk.ReadSectors((long)firstSector, sectorCount);
+            int numberOfFragments = (int)(databaseHeader.NumberOfVBlks - FirstSequenceNumber);
+            List<DatabaseRecord> databaseRecords = ReadDatabaseRecords(databaseBytes, (int)databaseHeader.HeaderSize, (int)databaseHeader.BlockSize, numberOfFragments);
 
             // read all KLog blocks
             KernelUpdateLog kernelUpdateLog = KernelUpdateLog.ReadFromDisk(disk, privateHeader, tocBlock);
             DynamicDisk dynamicDisk = new DynamicDisk(disk, privateHeader, tocBlock);
-            return new VolumeManagerDatabase(dynamicDisk, databaseHeader, databaseRecords, kernelUpdateLog);
+            return new VolumeManagerDatabaseCopy(dynamicDisk, databaseHeader, databaseRecords, kernelUpdateLog);
         }
 
         public static void WriteDatabaseRecordFragment(DynamicDisk disk, DatabaseRecordFragment fragment, int blockSize)
         {
-            if (fragment.SequenceNumber < 4)
+            if (fragment.SequenceNumber < FirstSequenceNumber)
             {
                 throw new ArgumentException("VBLK SequenceNumber must start from 4");
             }
@@ -655,15 +678,5 @@ namespace DiskAccessLibrary.LogicalDiskManager
             Array.Copy(fragmentBytes, 0, sectorBytes, indexInSector * blockSize, blockSize);
             disk.Disk.WriteSectors((long)sectorIndex, sectorBytes);
         }
-
-        private static int CompareByColumnIndex(ExtentRecord x, ExtentRecord y)
-        {
-            return x.ColumnIndex.CompareTo(y.ColumnIndex);
-        }
-
-        private static int CompareByOffsetInColumn(ExtentRecord x, ExtentRecord y)
-        {
-            return x.OffsetInColumnLBA.CompareTo(y.OffsetInColumnLBA);
-        }
     }
 }

DiskAccessLibrary/LogicalDiskManager/VolumeManagerDatabaseCopy.cs

@@ -0,0 +1,48 @@
+/* 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 Utilities;
+
+namespace DiskAccessLibrary.LogicalDiskManager
+{
+    /// <summary>
+    /// A Volume Manager Database copy stored on a specific disk
+    /// </summary>
+    public class VolumeManagerDatabaseCopy : VolumeManagerDatabase
+    {
+        private DynamicDisk m_disk;
+        private VolumeManagerDatabaseHeader m_databaseHeader;
+        private List<DatabaseRecord> m_databaseRecords;
+        private KernelUpdateLog m_kernelUpdateLog;
+
+        public VolumeManagerDatabaseCopy(DynamicDisk disk, VolumeManagerDatabaseHeader databaseHeader, List<DatabaseRecord> databaseRecords, KernelUpdateLog kernelUpdateLog) :
+            base(databaseHeader, databaseRecords, kernelUpdateLog)
+        {
+            m_disk = disk;
+            m_databaseHeader = databaseHeader;
+            m_databaseRecords = databaseRecords;
+            m_kernelUpdateLog = kernelUpdateLog;
+        }
+
+        public override void WriteDatabaseHeader()
+        {
+            VolumeManagerDatabaseHeader.WriteToDisk(m_disk, m_databaseHeader);
+        }
+
+        public override void WriteDatabaseRecordFragment(DatabaseRecordFragment fragment)
+        {
+            WriteDatabaseRecordFragment(m_disk, fragment, (int)m_databaseHeader.BlockSize);
+        }
+
+        public override void SetKernelUpdateLogLastEntry(ulong committedTransactionID, ulong pendingTransactionID)
+        {
+            m_kernelUpdateLog.SetLastEntry(m_disk, committedTransactionID, pendingTransactionID);
+        }
+    }
+}

DiskAccessLibrary/LogicalDiskManager/VolumeManagerDatabaseHeader.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,
@@ -18,12 +18,12 @@ namespace DiskAccessLibrary.LogicalDiskManager
 
         public string Signature = VolumeManagerDatabaseSignature;
         public uint NumberOfVBlks;              // Number of VBLK blocks in the database (This number includes the VMDB, which counts as 4 blocks)
-        public uint BlockSize;             // VBLK block size
+        public uint BlockSize;                  // VBLK block size
         public uint HeaderSize;
         public DatabaseHeaderUpdateStatus UpdateStatus;
         // Versions: 4.10 for Windows XP \ Server 2003 \ Windows 7 \ Server 2008
-        //           4.10 for Veritas Storage Foundation 4.0 (Windows Disk Management compatible group checked)
-        //           4.12 for Veritas Storage Foundation 4.0 (Windows Disk Management compatible group unchecked)
+        //           4.10 for Veritas Storage Foundation 4.0 ('Windows Disk Management compatible group' checked)
+        //           4.12 for Veritas Storage Foundation 4.0 ('Windows Disk Management compatible group' unchecked)
         public ushort MajorVersion;
         public ushort MinorVersion;
         public string DiskGroupName = String.Empty;
@@ -122,6 +122,14 @@ namespace DiskAccessLibrary.LogicalDiskManager
             }
         }
 
+        public bool IsVersionSupported
+        {
+            get
+            {
+                return (MajorVersion == 4 && (MinorVersion == 10 || MinorVersion == 12));
+            }
+        }
+
         public static VolumeManagerDatabaseHeader ReadFromDisk(Disk disk, PrivateHeader privateHeader, TOCBlock tocBlock)
         {
             ulong sectorIndex = privateHeader.PrivateRegionStartLBA + tocBlock.ConfigStart;

DiskAccessLibrary/LogicalDiskManager/Volumes/MirroredVolume.cs

@@ -49,6 +49,21 @@ namespace DiskAccessLibrary.LogicalDiskManager
             }
         }
 
+        public override int BytesPerSector
+        {
+            get
+            {
+                foreach (DynamicVolume volume in m_volumes)
+                {
+                    if (volume.IsOperational)
+                    {
+                        return volume.BytesPerSector;
+                    }
+                }
+                return DynamicColumn.DefaultBytesPerSector;
+            }
+        }
+
         public override long Size
         {
             get 

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.4.2.0")]
-[assembly: AssemblyFileVersion("1.4.2.0")]
+[assembly: AssemblyVersion("1.4.3.0")]
+[assembly: AssemblyFileVersion("1.4.3.0")]

DiskAccessLibrary/RevisionHistory.txt

@@ -84,3 +84,7 @@ Revision History:
         API: Added RAM-Disk implementation.
         API: Added RawDiskImage.Create method.
         API: Added BasicDiskHelper.GetUnallocatedExtents method.
+
+1.4.3 - Bugfix: MirroredVolume.BytesPerSector reported wrong number of bytes per sector when the first volume was not operational.
+        Bugfix: DynamicDiskHelper.IsMoveLocationValid ignored allocated extents.
+        API: Added DiskGroupGuid property to DynamicDisk.

DiskAccessLibrary/Win32/Helpers/DiskOfflineHelper.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,
@@ -12,9 +12,9 @@ namespace DiskAccessLibrary.LogicalDiskManager
 {
     public class DiskOfflineHelper
     {
-        public static bool AreDynamicDisksOnlineAndWriteable()
+        public static bool IsDiskGroupOnlineAndWritable(Guid diskGroupGuid)
         {
-            List<DynamicDisk> disksToLock = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks();
+            List<DynamicDisk> disksToLock = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks(diskGroupGuid);
             List<PhysicalDisk> physicalDisks = new List<PhysicalDisk>();
             foreach (DynamicDisk dynamicDisk in disksToLock)
             {
@@ -39,15 +39,15 @@ namespace DiskAccessLibrary.LogicalDiskManager
         /// <summary>
         /// Will not persist across reboots
         /// </summary>
-        public static bool OfflineAllDynamicDisks()
+        public static bool OfflineDiskGroup(Guid diskGroupGuid)
         {
-            List<DynamicDisk> disksToLock = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks();
-            return OfflineAllOrNone(disksToLock);
+            List<DynamicDisk> disksToOffline = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks(diskGroupGuid);
+            return OfflineAllOrNone(disksToOffline);
         }
 
-        public static void OnlineAllDynamicDisks()
+        public static void OnlineDiskGroup(Guid diskGroupGuid)
         {
-            List<DynamicDisk> disksToOnline = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks();
+            List<DynamicDisk> disksToOnline = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks(diskGroupGuid);
             foreach (DynamicDisk disk in disksToOnline)
             {
                 ((PhysicalDisk)disk.Disk).SetOnlineStatus(true);

DiskAccessLibrary/Win32/LogicalDiskManager/DiskGroupDatabase.Win32.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,
@@ -15,7 +15,7 @@ namespace DiskAccessLibrary.LogicalDiskManager
     {
         public static DiskGroupDatabase ReadFromPhysicalDisks(Guid diskGroupGuid)
         {
-            List<DynamicDisk> dynamicDisks = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks();
+            List<DynamicDisk> dynamicDisks = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks(diskGroupGuid);
             return ReadFromDisks(dynamicDisks, diskGroupGuid);
         }
 

DiskAccessLibrary/Win32/LogicalDiskManager/LockManager.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,
@@ -17,9 +17,9 @@ namespace DiskAccessLibrary.LogicalDiskManager
         private static List<DynamicDisk> m_lockedDisks = new List<DynamicDisk>();
         private static List<DynamicVolume> m_lockedVolumes = new List<DynamicVolume>();
 
-        public static LockStatus LockAllDynamicDisks(bool lockAllDynamicVolumes)
+        public static LockStatus LockDynamicDiskGroup(Guid diskGroupGuid, bool lockAllDynamicVolumes)
         {
-            List<DynamicDisk> disksToLock = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks();
+            List<DynamicDisk> disksToLock = WindowsDynamicDiskHelper.GetPhysicalDynamicDisks(diskGroupGuid);
             List<DynamicVolume> volumesToLock = new List<DynamicVolume>();
 
             if (lockAllDynamicVolumes)

DiskAccessLibrary/Win32/LogicalDiskManager/WindowsDynamicDiskHelper.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,
@@ -29,6 +29,12 @@ namespace DiskAccessLibrary.LogicalDiskManager
             return result;
         }
 
+        public static List<DynamicDisk> GetPhysicalDynamicDisks(Guid diskGroupGuid)
+        {
+            List<DynamicDisk> dynamicDisks = GetPhysicalDynamicDisks();
+            return DynamicDiskHelper.FindDiskGroup(dynamicDisks, diskGroupGuid);
+        }
+
         public static PrivateHeader FindDiskPrivateHeader(Guid diskGuid)
         {
             DynamicDisk disk = FindDisk(diskGuid);