Rename project folder.

DiscImageChef/PartPlugins/AppleMap.cs

@@ -0,0 +1,276 @@
+/***************************************************************************
+The Disc Image Chef
+----------------------------------------------------------------------------
+ 
+Filename       : AppleMap.cs
+Version        : 1.0
+Author(s)      : Natalia Portillo
+ 
+Component      : Partitioning scheme plugins
+
+Revision       : $Revision$
+Last change by : $Author$
+Date           : $Date$
+ 
+--[ Description ] ----------------------------------------------------------
+ 
+Manages Apple Partition Map.
+ 
+--[ License ] --------------------------------------------------------------
+ 
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+----------------------------------------------------------------------------
+Copyright (C) 2011-2014 Claunia.com
+****************************************************************************/
+//$Id$
+
+using System;
+using System.Text;
+using System.Collections.Generic;
+using DiscImageChef;
+
+// Information about structures learnt from Inside Macintosh
+// Constants from image testing
+namespace DiscImageChef.PartPlugins
+{
+    class AppleMap : PartPlugin
+    {
+        // "ER"
+        const UInt16 APM_MAGIC = 0x4552;
+        // "PM"
+        const UInt16 APM_ENTRY = 0x504D;
+        // "TS", old entry magic
+        const UInt16 APM_OLDENT = 0x5453;
+
+        public AppleMap(PluginBase Core)
+        {
+            Name = "Apple Partition Map";
+            PluginUUID = new Guid("36405F8D-4F1A-07F5-209C-223D735D6D22");
+        }
+
+        public override bool GetInformation(ImagePlugins.ImagePlugin imagePlugin, out List<Partition> partitions)
+        {
+            byte[] cString;
+			
+            ulong apm_entries;
+            uint sector_size;
+
+            if (imagePlugin.GetSectorSize() == 2352 || imagePlugin.GetSectorSize() == 2448)
+                sector_size = 2048;
+            else
+                sector_size = imagePlugin.GetSectorSize();
+			
+            partitions = new List<Partition>();
+			
+            AppleMapBootEntry APMB = new AppleMapBootEntry();
+            AppleMapPartitionEntry APMEntry = new AppleMapPartitionEntry();
+
+            byte[] APMB_sector = imagePlugin.ReadSector(0);
+
+            APMB.signature = BigEndianBitConverter.ToUInt16(APMB_sector, 0x00);
+            APMB.sector_size = BigEndianBitConverter.ToUInt16(APMB_sector, 0x02);
+            APMB.sectors = BigEndianBitConverter.ToUInt32(APMB_sector, 0x04);
+            APMB.reserved1 = BigEndianBitConverter.ToUInt16(APMB_sector, 0x08);
+            APMB.reserved2 = BigEndianBitConverter.ToUInt16(APMB_sector, 0x0A);
+            APMB.reserved3 = BigEndianBitConverter.ToUInt32(APMB_sector, 0x0C);
+            APMB.driver_entries = BigEndianBitConverter.ToUInt16(APMB_sector, 0x10);
+            APMB.first_driver_blk = BigEndianBitConverter.ToUInt32(APMB_sector, 0x12);
+            APMB.driver_size = BigEndianBitConverter.ToUInt16(APMB_sector, 0x16);
+            APMB.operating_system = BigEndianBitConverter.ToUInt16(APMB_sector, 0x18);
+
+            ulong first_sector = 0;
+
+            if (APMB.signature == APM_MAGIC) // APM boot block found, APM starts in next sector
+                first_sector = 1;
+
+            // Read first entry
+            byte[] APMEntry_sector = imagePlugin.ReadSector(first_sector);
+            APMEntry.signature = BigEndianBitConverter.ToUInt16(APMEntry_sector, 0x00);
+            APMEntry.reserved1 = BigEndianBitConverter.ToUInt16(APMEntry_sector, 0x02);
+            APMEntry.entries = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x04);
+            APMEntry.start = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x08);
+            APMEntry.sectors = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x0C);
+            cString = new byte[32];
+            Array.Copy(APMEntry_sector, 0x10, cString, 0, 32);
+            APMEntry.name = StringHandlers.CToString(cString);
+            cString = new byte[32];
+            Array.Copy(APMEntry_sector, 0x30, cString, 0, 32);
+            APMEntry.type = StringHandlers.CToString(cString);
+            APMEntry.first_data_block = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x50);
+            APMEntry.data_sectors = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x54);
+            APMEntry.status = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x58);
+            APMEntry.first_boot_block = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x5C);
+            APMEntry.boot_size = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x60);
+            APMEntry.load_address = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x64);
+            APMEntry.reserved2 = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x68);
+            APMEntry.entry_point = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x6C);
+            APMEntry.reserved3 = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x70);
+            APMEntry.checksum = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x74);
+            cString = new byte[16];
+            Array.Copy(APMEntry_sector, 0x78, cString, 0, 16);
+            APMEntry.processor = StringHandlers.CToString(cString);
+
+            if (APMEntry.signature != APM_ENTRY && APMEntry.signature != APM_OLDENT)
+                return false;
+
+            if (APMEntry.entries <= 1)
+                return false;
+
+            apm_entries = APMEntry.entries;
+			
+            for (ulong i = 0; i < apm_entries; i++) // For each partition
+            {
+                APMEntry = new AppleMapPartitionEntry();
+                APMEntry_sector = imagePlugin.ReadSector(first_sector + i);
+                APMEntry.signature = BigEndianBitConverter.ToUInt16(APMEntry_sector, 0x00);
+                APMEntry.reserved1 = BigEndianBitConverter.ToUInt16(APMEntry_sector, 0x02);
+                APMEntry.entries = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x04);
+                APMEntry.start = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x08);
+                APMEntry.sectors = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x0C);
+                cString = new byte[32];
+                Array.Copy(APMEntry_sector, 0x10, cString, 0, 32);
+                APMEntry.name = StringHandlers.CToString(cString);
+                cString = new byte[32];
+                Array.Copy(APMEntry_sector, 0x30, cString, 0, 32);
+                APMEntry.type = StringHandlers.CToString(cString);
+                APMEntry.first_data_block = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x50);
+                APMEntry.data_sectors = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x54);
+                APMEntry.status = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x58);
+                APMEntry.first_boot_block = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x5C);
+                APMEntry.boot_size = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x60);
+                APMEntry.load_address = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x64);
+                APMEntry.reserved2 = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x68);
+                APMEntry.entry_point = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x6C);
+                APMEntry.reserved3 = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x70);
+                APMEntry.checksum = BigEndianBitConverter.ToUInt32(APMEntry_sector, 0x74);
+                cString = new byte[16];
+                Array.Copy(APMEntry_sector, 0x78, cString, 0, 16);
+                APMEntry.processor = StringHandlers.CToString(cString);
+
+                if (APMEntry.signature == APM_ENTRY || APMEntry.signature == APM_OLDENT) // It should have partition entry signature
+                {
+                    Partition _partition = new Partition();
+                    StringBuilder sb = new StringBuilder();
+					
+                    _partition.PartitionSequence = i;
+                    _partition.PartitionType = APMEntry.type;
+                    _partition.PartitionName = APMEntry.name;
+                    _partition.PartitionStart = APMEntry.start * sector_size;
+                    _partition.PartitionLength = APMEntry.sectors * sector_size;
+                    _partition.PartitionStartSector = APMEntry.start;
+                    _partition.PartitionSectors = APMEntry.sectors;
+					
+                    sb.AppendLine("Partition flags:");
+                    if ((APMEntry.status & 0x01) == 0x01)
+                        sb.AppendLine("Partition is valid.");
+                    if ((APMEntry.status & 0x02) == 0x02)
+                        sb.AppendLine("Partition entry is not available.");
+                    if ((APMEntry.status & 0x04) == 0x04)
+                        sb.AppendLine("Partition is mounted.");
+                    if ((APMEntry.status & 0x08) == 0x08)
+                        sb.AppendLine("Partition is bootable.");
+                    if ((APMEntry.status & 0x10) == 0x10)
+                        sb.AppendLine("Partition is readable.");
+                    if ((APMEntry.status & 0x20) == 0x20)
+                        sb.AppendLine("Partition is writable.");
+                    if ((APMEntry.status & 0x40) == 0x40)
+                        sb.AppendLine("Partition's boot code is position independent.");
+					
+                    if ((APMEntry.status & 0x08) == 0x08)
+                    {
+                        sb.AppendFormat("First boot sector: {0}", APMEntry.first_boot_block).AppendLine();
+                        sb.AppendFormat("Boot is {0} bytes.", APMEntry.boot_size).AppendLine();
+                        sb.AppendFormat("Boot load address: 0x{0:X8}", APMEntry.load_address).AppendLine();
+                        sb.AppendFormat("Boot entry point: 0x{0:X8}", APMEntry.entry_point).AppendLine();
+                        sb.AppendFormat("Boot code checksum: 0x{0:X8}", APMEntry.checksum).AppendLine();
+                        sb.AppendFormat("Processor: {0}", APMEntry.processor).AppendLine();
+                    }
+					
+                    _partition.PartitionDescription = sb.ToString();
+					
+                    if ((APMEntry.status & 0x01) == 0x01)
+                    if (APMEntry.type != "Apple_partition_map")
+                        partitions.Add(_partition);
+                }
+            }
+			
+            return true;
+        }
+
+        public struct AppleMapBootEntry
+        {
+            // Signature ("ER")
+            public UInt16 signature;
+            // Byter per sector
+            public UInt16 sector_size;
+            // Sectors of the disk
+            public UInt32 sectors;
+            // Reserved
+            public UInt16 reserved1;
+            // Reserved
+            public UInt16 reserved2;
+            // Reserved
+            public UInt32 reserved3;
+            // Number of entries of the driver descriptor
+            public UInt16 driver_entries;
+            // First sector of the driver
+            public UInt32 first_driver_blk;
+            // Size in 512bytes sectors of the driver
+            public UInt16 driver_size;
+            // Operating system (MacOS = 1)
+            public UInt16 operating_system;
+        }
+
+        public struct AppleMapPartitionEntry
+        {
+            // Signature ("PM" or "TS")
+            public UInt16 signature;
+            // Reserved
+            public UInt16 reserved1;
+            // Number of entries on the partition map, each one sector
+            public UInt32 entries;
+            // First sector of the partition
+            public UInt32 start;
+            // Number of sectos of the partition
+            public UInt32 sectors;
+            // Partition name, 32 bytes, null-padded
+            public string name;
+            // Partition type. 32 bytes, null-padded
+            public string type;
+            // First sector of the data area
+            public UInt32 first_data_block;
+            // Number of sectors of the data area
+            public UInt32 data_sectors;
+            // Partition status
+            public UInt32 status;
+            // First sector of the boot code
+            public UInt32 first_boot_block;
+            // Size in bytes of the boot code
+            public UInt32 boot_size;
+            // Load address of the boot code
+            public UInt32 load_address;
+            // Reserved
+            public UInt32 reserved2;
+            // Entry point of the boot code
+            public UInt32 entry_point;
+            // Reserved
+            public UInt32 reserved3;
+            // Boot code checksum
+            public UInt32 checksum;
+            // Processor type, 16 bytes, null-padded
+            public string processor;
+        }
+    }
+}

DiscImageChef/PartPlugins/NeXT.cs

@@ -0,0 +1,202 @@
+/***************************************************************************
+The Disc Image Chef
+----------------------------------------------------------------------------
+ 
+Filename       : NeXT.cs
+Version        : 1.0
+Author(s)      : Natalia Portillo
+ 
+Component      : Partitioning scheme plugins
+
+Revision       : $Revision$
+Last change by : $Author$
+Date           : $Date$
+ 
+--[ Description ] ----------------------------------------------------------
+ 
+Manages NeXTStep and OpenStep partitions.
+ 
+--[ License ] --------------------------------------------------------------
+ 
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+----------------------------------------------------------------------------
+Copyright (C) 2011-2014 Claunia.com
+****************************************************************************/
+//$Id$
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using DiscImageChef;
+
+// Information learnt from XNU source and testing against real disks
+namespace DiscImageChef.PartPlugins
+{
+    class NeXTDisklabel : PartPlugin
+    {
+        const UInt32 NEXT_MAGIC1 = 0x4E655854;
+        // "NeXT"
+        const UInt32 NEXT_MAGIC2 = 0x646C5632;
+        // "dlV2"
+        const UInt32 NEXT_MAGIC3 = 0x646C5633;
+        // "dlV3"
+        const UInt16 disktabStart = 0xB4;
+        // 180
+        const UInt16 disktabEntrySize = 0x2C;
+        // 44
+        public NeXTDisklabel(PluginBase Core)
+        {
+            Name = "NeXT Disklabel";
+            PluginUUID = new Guid("246A6D93-4F1A-1F8A-344D-50187A5513A9");
+        }
+
+        public override bool GetInformation(ImagePlugins.ImagePlugin imagePlugin, out List<Partition> partitions)
+        {
+            byte[] cString;
+            bool magic_found;
+            byte[] entry_sector;
+			
+            UInt32 magic;
+            UInt32 sector_size;
+            UInt16 front_porch;
+
+            if (imagePlugin.GetSectorSize() == 2352 || imagePlugin.GetSectorSize() == 2448)
+                sector_size = 2048;
+            else
+                sector_size = imagePlugin.GetSectorSize();
+			
+            partitions = new List<Partition>();
+
+            entry_sector = imagePlugin.ReadSector(0); // Starts on sector 0 on NeXT machines, CDs and floppies
+            magic = BigEndianBitConverter.ToUInt32(entry_sector, 0x00);
+
+            if (magic == NEXT_MAGIC1 || magic == NEXT_MAGIC2 || magic == NEXT_MAGIC3)
+                magic_found = true;
+            else
+            {
+                entry_sector = imagePlugin.ReadSector(15); // Starts on sector 15 on MBR machines
+                magic = BigEndianBitConverter.ToUInt32(entry_sector, 0x00);
+
+                if (magic == NEXT_MAGIC1 || magic == NEXT_MAGIC2 || magic == NEXT_MAGIC3)
+                    magic_found = true;
+                else
+                {
+                    if (sector_size == 2048)
+                        entry_sector = imagePlugin.ReadSector(4); // Starts on sector 4 on RISC CDs
+                    else
+                        entry_sector = imagePlugin.ReadSector(16); // Starts on sector 16 on RISC disks
+                    magic = BigEndianBitConverter.ToUInt32(entry_sector, 0x00);
+					
+                    if (magic == NEXT_MAGIC1 || magic == NEXT_MAGIC2 || magic == NEXT_MAGIC3)
+                        magic_found = true;
+                    else
+                        return false;
+                }
+            }
+			
+            front_porch = BigEndianBitConverter.ToUInt16(entry_sector, 0x6A);
+
+            if (magic_found)
+            {
+                for (int i = 0; i < 8; i++)
+                {
+                    NeXTEntry entry = new NeXTEntry();
+
+                    entry.start = BigEndianBitConverter.ToUInt32(entry_sector, disktabStart + disktabEntrySize * i + 0x00);
+                    entry.sectors = BigEndianBitConverter.ToUInt32(entry_sector, disktabStart + disktabEntrySize * i + 0x04);
+                    entry.block_size = BigEndianBitConverter.ToUInt16(entry_sector, disktabStart + disktabEntrySize * i + 0x08);
+                    entry.frag_size = BigEndianBitConverter.ToUInt16(entry_sector, disktabStart + disktabEntrySize * i + 0x0A);
+                    entry.optimization = entry_sector[disktabStart + disktabEntrySize * i + 0x0C];
+                    entry.cpg = BigEndianBitConverter.ToUInt16(entry_sector, disktabStart + disktabEntrySize * i + 0x0D);
+                    entry.bpi = BigEndianBitConverter.ToUInt16(entry_sector, disktabStart + disktabEntrySize * i + 0x0F);
+                    entry.freemin = entry_sector[disktabStart + disktabEntrySize * i + 0x11];
+                    entry.newfs = entry_sector[disktabStart + disktabEntrySize * i + 0x12];
+                    cString = new byte[16];
+                    Array.Copy(entry_sector, disktabStart + disktabEntrySize * i + 0x13, cString, 0, 16);
+                    entry.mount_point = StringHandlers.CToString(cString);
+                    entry.automount = entry_sector[disktabStart + disktabEntrySize * i + 0x23];
+                    cString = new byte[8];
+                    Array.Copy(entry_sector, disktabStart + disktabEntrySize * i + 0x24, cString, 0, 8);
+                    entry.type = StringHandlers.CToString(cString);
+
+                    if (entry.sectors > 0 && entry.sectors < 0xFFFFFFFF && entry.start < 0xFFFFFFFF)
+                    {
+                        Partition part = new Partition();
+                        StringBuilder sb = new StringBuilder();
+						
+                        part.PartitionLength = (ulong)entry.sectors * sector_size;
+                        part.PartitionStart = ((ulong)entry.start + front_porch) * sector_size;
+                        part.PartitionType = entry.type;
+                        part.PartitionSequence = (ulong)i;
+                        part.PartitionName = entry.mount_point;
+                        part.PartitionSectors = (ulong)entry.sectors;
+                        part.PartitionStartSector = ((ulong)entry.start + front_porch);
+						
+                        sb.AppendFormat("{0} bytes per block", entry.block_size).AppendLine();
+                        sb.AppendFormat("{0} bytes per fragment", entry.frag_size).AppendLine();
+                        if (entry.optimization == 's')
+                            sb.AppendLine("Space optimized");
+                        else if (entry.optimization == 't')
+                            sb.AppendLine("Time optimized");
+                        else
+                            sb.AppendFormat("Unknown optimization {0:X2}", entry.optimization).AppendLine();
+                        sb.AppendFormat("{0} cylinders per group", entry.cpg).AppendLine();
+                        sb.AppendFormat("{0} bytes per inode", entry.bpi).AppendLine();
+                        sb.AppendFormat("{0}% of space must be free at minimum", entry.freemin).AppendLine();
+                        if (entry.newfs != 1) // Seems to indicate newfs has been already run
+							sb.AppendLine("Filesystem should be formatted at start");
+                        if (entry.automount == 1)
+                            sb.AppendLine("Filesystem should be automatically mounted");
+						
+                        part.PartitionDescription = sb.ToString();
+						
+                        partitions.Add(part);
+                    }
+                }
+				
+                return true;
+            }
+            return false;
+        }
+
+        struct NeXTEntry
+        {
+            public UInt32 start;
+            // Sector of start, counting from front porch
+            public UInt32 sectors;
+            // Length in sectors
+            public UInt16 block_size;
+            // Filesystem's block size
+            public UInt16 frag_size;
+            // Filesystem's fragment size
+            public byte optimization;
+            // 's'pace or 't'ime
+            public UInt16 cpg;
+            // Cylinders per group
+            public UInt16 bpi;
+            // Bytes per inode
+            public byte freemin;
+            // % of minimum free space
+            public byte newfs;
+            // Should newfs be run on first start?
+            public string mount_point;
+            // Mount point or empty if mount where you want
+            public byte automount;
+            // Should automount
+            public string type;
+            // Filesystem type, always "4.3BSD"?
+        }
+    }
+}

DiscImageChef/PartPlugins/PartPlugin.cs

@@ -0,0 +1,89 @@
+/***************************************************************************
+The Disc Image Chef
+----------------------------------------------------------------------------
+ 
+Filename       : PartPlugin.cs
+Version        : 1.0
+Author(s)      : Natalia Portillo
+ 
+Component      : Partitioning scheme plugins
+
+Revision       : $Revision$
+Last change by : $Author$
+Date           : $Date$
+ 
+--[ Description ] ----------------------------------------------------------
+ 
+Defines functions to be used by partitioning scheme plugins and several constants.
+ 
+--[ License ] --------------------------------------------------------------
+ 
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+----------------------------------------------------------------------------
+Copyright (C) 2011-2014 Claunia.com
+****************************************************************************/
+//$Id$
+
+using System;
+using System.Collections.Generic;
+
+namespace DiscImageChef.PartPlugins
+{
+    /// <summary>
+    /// Abstract class to implement partitioning schemes interpreting plugins.
+    /// </summary>
+    public abstract class PartPlugin
+    {
+        /// <summary>Plugin name.</summary>
+        public string Name;
+        /// <summary>Plugin UUID.</summary>
+        public Guid PluginUUID;
+
+        protected PartPlugin()
+        {
+        }
+
+        /// <summary>
+        /// Interprets a partitioning scheme.
+        /// </summary>
+        /// <returns><c>true</c>, if partitioning scheme is recognized, <c>false</c> otherwise.</returns>
+        /// <param name="imagePlugin">Disk image.</param>
+        /// <param name="partitions">Returns list of partitions.</param>
+        public abstract bool GetInformation(ImagePlugins.ImagePlugin imagePlugin, out List<Partition> partitions);
+    }
+
+    /// <summary>
+    /// Partition structure.
+    /// </summary>
+    public struct Partition
+    {
+        /// <summary>Partition number, 0-started</summary>
+        public ulong PartitionSequence;
+        /// <summary>Partition type</summary>
+        public string PartitionType;
+        /// <summary>Partition name (if the scheme supports it)</summary>
+        public string PartitionName;
+        /// <summary>Start of the partition, in bytes</summary>
+        public ulong PartitionStart;
+        /// <summary>LBA of partition start</summary>
+        public ulong PartitionStartSector;
+        /// <summary>Length in bytes of the partition</summary>
+        public ulong PartitionLength;
+        /// <summary>Length in sectors of the partition</summary>
+        public ulong PartitionSectors;
+        /// <summary>Information that does not find space in this struct</summary>
+        public string PartitionDescription;
+    }
+}