Initial commit - WPinternals 2.6

DiscUtils/Geometry.cs

@@ -0,0 +1,497 @@
+//
+// Copyright (c) 2008-2011, Kenneth Bell
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+namespace DiscUtils
+{
+    using System;
+    using System.Globalization;
+
+    /// <summary>
+    /// Class whose instances represent disk geometries.
+    /// </summary>
+    /// <remarks>Instances of this class are immutable.</remarks>
+    public sealed class Geometry
+    {
+        private int _cylinders;
+        private int _headsPerCylinder;
+        private int _sectorsPerTrack;
+        private int _bytesPerSector;
+
+        /// <summary>
+        /// Initializes a new instance of the Geometry class.  The default 512 bytes per sector is assumed.
+        /// </summary>
+        /// <param name="cylinders">The number of cylinders of the disk.</param>
+        /// <param name="headsPerCylinder">The number of heads (aka platters) of the disk.</param>
+        /// <param name="sectorsPerTrack">The number of sectors per track/cylinder of the disk.</param>
+        public Geometry(int cylinders, int headsPerCylinder, int sectorsPerTrack)
+        {
+            _cylinders = cylinders;
+            _headsPerCylinder = headsPerCylinder;
+            _sectorsPerTrack = sectorsPerTrack;
+            _bytesPerSector = 512;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Geometry class.
+        /// </summary>
+        /// <param name="cylinders">The number of cylinders of the disk.</param>
+        /// <param name="headsPerCylinder">The number of heads (aka platters) of the disk.</param>
+        /// <param name="sectorsPerTrack">The number of sectors per track/cylinder of the disk.</param>
+        /// <param name="bytesPerSector">The number of bytes per sector of the disk.</param>
+        public Geometry(int cylinders, int headsPerCylinder, int sectorsPerTrack, int bytesPerSector)
+        {
+            _cylinders = cylinders;
+            _headsPerCylinder = headsPerCylinder;
+            _sectorsPerTrack = sectorsPerTrack;
+            _bytesPerSector = bytesPerSector;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Geometry class.
+        /// </summary>
+        /// <param name="capacity">The total capacity of the disk.</param>
+        /// <param name="headsPerCylinder">The number of heads (aka platters) of the disk.</param>
+        /// <param name="sectorsPerTrack">The number of sectors per track/cylinder of the disk.</param>
+        /// <param name="bytesPerSector">The number of bytes per sector of the disk.</param>
+        public Geometry(long capacity, int headsPerCylinder, int sectorsPerTrack, int bytesPerSector)
+        {
+            _cylinders = (int)(capacity / (headsPerCylinder * (long)sectorsPerTrack * bytesPerSector));
+            _headsPerCylinder = headsPerCylinder;
+            _sectorsPerTrack = sectorsPerTrack;
+            _bytesPerSector = bytesPerSector;
+        }
+
+        /// <summary>
+        /// Gets a null geometry, which has 512-byte sectors but zero sectors, tracks or cylinders.
+        /// </summary>
+        public static Geometry Null
+        {
+            get { return new Geometry(0, 0, 0, 512); }
+        }
+
+        /// <summary>
+        /// Gets the number of cylinders.
+        /// </summary>
+        public int Cylinders
+        {
+            get { return _cylinders; }
+        }
+
+        /// <summary>
+        /// Gets the number of heads (aka platters).
+        /// </summary>
+        public int HeadsPerCylinder
+        {
+            get { return _headsPerCylinder; }
+        }
+
+        /// <summary>
+        /// Gets the number of sectors per track.
+        /// </summary>
+        public int SectorsPerTrack
+        {
+            get { return _sectorsPerTrack; }
+        }
+
+        /// <summary>
+        /// Gets the number of bytes in each sector.
+        /// </summary>
+        public int BytesPerSector
+        {
+            get { return _bytesPerSector; }
+        }
+
+        /// <summary>
+        /// Gets the total size of the disk (in sectors).
+        /// </summary>
+        [Obsolete("Use TotalSectorsLong instead, to support very large disks.")]
+        public int TotalSectors
+        {
+            get { return Cylinders * HeadsPerCylinder * SectorsPerTrack; }
+        }
+
+        /// <summary>
+        /// Gets the total size of the disk (in sectors).
+        /// </summary>
+        public long TotalSectorsLong
+        {
+            get { return (long)Cylinders * (long)HeadsPerCylinder * (long)SectorsPerTrack; }
+        }
+
+        /// <summary>
+        /// Gets the total capacity of the disk (in bytes).
+        /// </summary>
+        public long Capacity
+        {
+            get { return TotalSectorsLong * (long)BytesPerSector; }
+        }
+
+        /// <summary>
+        /// Gets the address of the last sector on the disk.
+        /// </summary>
+        public ChsAddress LastSector
+        {
+            get { return new ChsAddress(_cylinders - 1, _headsPerCylinder - 1, _sectorsPerTrack); }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the Geometry is consistent with the values a BIOS can support.
+        /// </summary>
+        public bool IsBiosSafe
+        {
+            get { return _cylinders <= 1024 && _headsPerCylinder <= 255 && _sectorsPerTrack <= 63; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the Geometry is consistent with the values IDE can represent.
+        /// </summary>
+        public bool IsIdeSafe
+        {
+            get { return _cylinders <= 65536 && _headsPerCylinder <= 16 && _sectorsPerTrack <= 255; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the Geometry is representable both by the BIOS and by IDE.
+        /// </summary>
+        public bool IsBiosAndIdeSafe
+        {
+            get { return _cylinders <= 1024 && _headsPerCylinder <= 16 && _sectorsPerTrack <= 63; }
+        }
+
+        /// <summary>
+        /// Gets the 'Large' BIOS geometry for a disk, given it's physical geometry.
+        /// </summary>
+        /// <param name="ideGeometry">The physical (aka IDE) geometry of the disk.</param>
+        /// <returns>The geometry a BIOS using the 'Large' method for calculating disk geometry will indicate for the disk.</returns>
+        public static Geometry LargeBiosGeometry(Geometry ideGeometry)
+        {
+            int cylinders = ideGeometry.Cylinders;
+            int heads = ideGeometry.HeadsPerCylinder;
+            int sectors = ideGeometry.SectorsPerTrack;
+
+            while (cylinders > 1024 && heads <= 127)
+            {
+                cylinders >>= 1;
+                heads <<= 1;
+            }
+
+            return new Geometry(cylinders, heads, sectors);
+        }
+
+        /// <summary>
+        /// Gets the 'LBA Assisted' BIOS geometry for a disk, given it's capacity.
+        /// </summary>
+        /// <param name="capacity">The capacity of the disk.</param>
+        /// <returns>The geometry a BIOS using the 'LBA Assisted' method for calculating disk geometry will indicate for the disk.</returns>
+        public static Geometry LbaAssistedBiosGeometry(long capacity)
+        {
+            int heads;
+            if (capacity <= 504 * Sizes.OneMiB)
+            {
+                heads = 16;
+            }
+            else if (capacity <= 1008 * Sizes.OneMiB)
+            {
+                heads = 32;
+            }
+            else if (capacity <= 2016 * Sizes.OneMiB)
+            {
+                heads = 64;
+            }
+            else if (capacity <= 4032 * Sizes.OneMiB)
+            {
+                heads = 128;
+            }
+            else
+            {
+                heads = 255;
+            }
+
+            int sectors = 63;
+            int cylinders = (int)Math.Min(1024, capacity / (sectors * (long)heads * Sizes.Sector));
+            return new Geometry(cylinders, heads, sectors, Sizes.Sector);
+        }
+
+        /// <summary>
+        /// Converts a geometry into one that is BIOS-safe, if not already.
+        /// </summary>
+        /// <param name="geometry">The geometry to make BIOS-safe.</param>
+        /// <param name="capacity">The capacity of the disk.</param>
+        /// <returns>The new geometry.</returns>
+        /// <remarks>This method returns the LBA-Assisted geometry if the given geometry isn't BIOS-safe.</remarks>
+        public static Geometry MakeBiosSafe(Geometry geometry, long capacity)
+        {
+            if (geometry == null)
+            {
+                return LbaAssistedBiosGeometry(capacity);
+            }
+            else if (geometry.IsBiosSafe)
+            {
+                return geometry;
+            }
+            else
+            {
+                return LbaAssistedBiosGeometry(capacity);
+            }
+        }
+
+        /// <summary>
+        /// Calculates a sensible disk geometry for a disk capacity using the VHD algorithm (errs under).
+        /// </summary>
+        /// <param name="capacity">The desired capacity of the disk.</param>
+        /// <returns>The appropriate disk geometry.</returns>
+        /// <remarks>The geometry returned tends to produce a disk with less capacity
+        /// than requested (an exact capacity is not always possible).  The geometry returned is the IDE
+        /// (aka Physical) geometry of the disk, not necessarily the geometry used by the BIOS.</remarks>
+        public static Geometry FromCapacity(long capacity)
+        {
+            return FromCapacity(capacity, Utilities.SectorSize);
+        }
+
+        /// <summary>
+        /// Calculates a sensible disk geometry for a disk capacity using the VHD algorithm (errs under).
+        /// </summary>
+        /// <param name="capacity">The desired capacity of the disk.</param>
+        /// <param name="sectorSize">The logical sector size of the disk.</param>
+        /// <returns>The appropriate disk geometry.</returns>
+        /// <remarks>The geometry returned tends to produce a disk with less capacity
+        /// than requested (an exact capacity is not always possible).  The geometry returned is the IDE
+        /// (aka Physical) geometry of the disk, not necessarily the geometry used by the BIOS.</remarks>
+        public static Geometry FromCapacity(long capacity, int sectorSize)
+        {
+            int totalSectors;
+            int cylinders;
+            int headsPerCylinder;
+            int sectorsPerTrack;
+
+            // If more than ~128GB truncate at ~128GB
+            if (capacity > 65535 * (long)16 * 255 * sectorSize)
+            {
+                totalSectors = 65535 * 16 * 255;
+            }
+            else
+            {
+                totalSectors = (int)(capacity / sectorSize);
+            }
+
+            // If more than ~32GB, break partition table compatibility.
+            // Partition table has max 63 sectors per track.  Otherwise
+            // we're looking for a geometry that's valid for both BIOS
+            // and ATA.
+            if (totalSectors > 65535 * 16 * 63)
+            {
+                sectorsPerTrack = 255;
+                headsPerCylinder = 16;
+            }
+            else
+            {
+                sectorsPerTrack = 17;
+                int cylindersTimesHeads = totalSectors / sectorsPerTrack;
+                headsPerCylinder = (cylindersTimesHeads + 1023) / 1024;
+
+                if (headsPerCylinder < 4)
+                {
+                    headsPerCylinder = 4;
+                }
+
+                // If we need more than 1023 cylinders, or 16 heads, try more sectors per track
+                if (cylindersTimesHeads >= (headsPerCylinder * 1024U) || headsPerCylinder > 16)
+                {
+                    sectorsPerTrack = 31;
+                    headsPerCylinder = 16;
+                    cylindersTimesHeads = totalSectors / sectorsPerTrack;
+                }
+
+                // We need 63 sectors per track to keep the cylinder count down
+                if (cylindersTimesHeads >= (headsPerCylinder * 1024U))
+                {
+                    sectorsPerTrack = 63;
+                    headsPerCylinder = 16;
+                }
+            }
+
+            cylinders = (totalSectors / sectorsPerTrack) / headsPerCylinder;
+
+            return new Geometry(cylinders, headsPerCylinder, sectorsPerTrack, sectorSize);
+        }
+
+        /// <summary>
+        /// Converts a CHS (Cylinder,Head,Sector) address to a LBA (Logical Block Address).
+        /// </summary>
+        /// <param name="chsAddress">The CHS address to convert.</param>
+        /// <returns>The Logical Block Address (in sectors).</returns>
+        public long ToLogicalBlockAddress(ChsAddress chsAddress)
+        {
+            return ToLogicalBlockAddress(chsAddress.Cylinder, chsAddress.Head, chsAddress.Sector);
+        }
+
+        /// <summary>
+        /// Converts a CHS (Cylinder,Head,Sector) address to a LBA (Logical Block Address).
+        /// </summary>
+        /// <param name="cylinder">The cylinder of the address.</param>
+        /// <param name="head">The head of the address.</param>
+        /// <param name="sector">The sector of the address.</param>
+        /// <returns>The Logical Block Address (in sectors).</returns>
+        public long ToLogicalBlockAddress(int cylinder, int head, int sector)
+        {
+            if (cylinder < 0)
+            {
+                throw new ArgumentOutOfRangeException("cylinder", cylinder, "cylinder number is negative");
+            }
+
+            if (head >= _headsPerCylinder)
+            {
+                throw new ArgumentOutOfRangeException("head", head, "head number is larger than disk geometry");
+            }
+
+            if (head < 0)
+            {
+                throw new ArgumentOutOfRangeException("head", head, "head number is negative");
+            }
+
+            if (sector > _sectorsPerTrack)
+            {
+                throw new ArgumentOutOfRangeException("sector", sector, "sector number is larger than disk geometry");
+            }
+
+            if (sector < 1)
+            {
+                throw new ArgumentOutOfRangeException("sector", sector, "sector number is less than one (sectors are 1-based)");
+            }
+
+            return (((cylinder * (long)_headsPerCylinder) + head) * _sectorsPerTrack) + sector - 1;
+        }
+
+        /// <summary>
+        /// Converts a LBA (Logical Block Address) to a CHS (Cylinder, Head, Sector) address.
+        /// </summary>
+        /// <param name="logicalBlockAddress">The logical block address (in sectors).</param>
+        /// <returns>The address in CHS form.</returns>
+        public ChsAddress ToChsAddress(long logicalBlockAddress)
+        {
+            if (logicalBlockAddress < 0)
+            {
+                throw new ArgumentOutOfRangeException("logicalBlockAddress", logicalBlockAddress, "Logical Block Address is negative");
+            }
+
+            int cylinder = (int)(logicalBlockAddress / (_headsPerCylinder * _sectorsPerTrack));
+            int temp = (int)(logicalBlockAddress % (_headsPerCylinder * _sectorsPerTrack));
+            int head = temp / _sectorsPerTrack;
+            int sector = (temp % _sectorsPerTrack) + 1;
+
+            return new ChsAddress(cylinder, head, sector);
+        }
+
+        /// <summary>
+        /// Translates an IDE (aka Physical) geometry to a BIOS (aka Logical) geometry.
+        /// </summary>
+        /// <param name="translation">The translation to perform.</param>
+        /// <returns>The translated disk geometry.</returns>
+        public Geometry TranslateToBios(GeometryTranslation translation)
+        {
+            return TranslateToBios(0, translation);
+        }
+
+        /// <summary>
+        /// Translates an IDE (aka Physical) geometry to a BIOS (aka Logical) geometry.
+        /// </summary>
+        /// <param name="capacity">The capacity of the disk, required if the geometry is an approximation on the actual disk size.</param>
+        /// <param name="translation">The translation to perform.</param>
+        /// <returns>The translated disk geometry.</returns>
+        public Geometry TranslateToBios(long capacity, GeometryTranslation translation)
+        {
+            if (capacity <= 0)
+            {
+                capacity = TotalSectorsLong * 512L;
+            }
+
+            switch (translation)
+            {
+                case GeometryTranslation.None:
+                    return this;
+
+                case GeometryTranslation.Auto:
+                    if (IsBiosSafe)
+                    {
+                        return this;
+                    }
+                    else
+                    {
+                        return Geometry.LbaAssistedBiosGeometry(capacity);
+                    }
+
+                case GeometryTranslation.Lba:
+                    return Geometry.LbaAssistedBiosGeometry(capacity);
+
+                case GeometryTranslation.Large:
+                    return Geometry.LargeBiosGeometry(this);
+
+                default:
+                    throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Translation mode '{0}' not yet implemented", translation), "translation");
+            }
+        }
+
+        /// <summary>
+        /// Determines if this object is equivalent to another.
+        /// </summary>
+        /// <param name="obj">The object to test against.</param>
+        /// <returns><c>true</c> if the <paramref name="obj"/> is equivalent, else <c>false</c>.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj == null || obj.GetType() != GetType())
+            {
+                return false;
+            }
+
+            Geometry other = (Geometry)obj;
+
+            return _cylinders == other._cylinders && _headsPerCylinder == other._headsPerCylinder
+                && _sectorsPerTrack == other._sectorsPerTrack && _bytesPerSector == other._bytesPerSector;
+        }
+
+        /// <summary>
+        /// Calculates the hash code for this object.
+        /// </summary>
+        /// <returns>The hash code.</returns>
+        public override int GetHashCode()
+        {
+            return _cylinders.GetHashCode() ^ _headsPerCylinder.GetHashCode()
+                ^ _sectorsPerTrack.GetHashCode() ^ _bytesPerSector.GetHashCode();
+        }
+
+        /// <summary>
+        /// Gets a string representation of this object, in the form (C/H/S).
+        /// </summary>
+        /// <returns>The string representation.</returns>
+        public override string ToString()
+        {
+            if (_bytesPerSector == 512)
+            {
+                return "(" + _cylinders + "/" + _headsPerCylinder + "/" + _sectorsPerTrack + ")";
+            }
+            else
+            {
+                return "(" + _cylinders + "/" + _headsPerCylinder + "/" + _sectorsPerTrack + ":" + _bytesPerSector + ")";
+            }
+        }
+    }
+}