* DiscImageChef.Filesystems/Acorn.cs:

* DiscImageChef.Filesystems/DiscImageChef.Filesystems.csproj: Added support for Acorn ADFS. * DiscImageChef.Partitions/Sun.cs: * DiscImageChef.Partitions/DiscImageChef.Partitions.csproj: Added support for Sun disklabel. * DiscImageChef.Filesystems/FFS.cs: Correct FFS information. * DiscImageChef/Commands/DumpMedia.cs: Correct physical/logical block size in sidecar. * TODO: * README.md: Added support for Sun disklabel. Added support for Acorn ADFS.
2025-12-16 19:24:25 +00:00 · 2016-02-05 05:39:15 +00:00
parent ab24c63d4b
commit a090c8f46c
11 changed files with 662 additions and 5 deletions
--- a/DiscImageChef.Filesystems/Acorn.cs
+++ b/DiscImageChef.Filesystems/Acorn.cs
@@ -0,0 +1,219 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : Acorn.cs
+// Version        : 1.0
+// Author(s)      : Natalia Portillo
+//
+// Component      : Component
+//
+// Revision       : $Revision$
+// Last change by : $Author$
+// Date           : $Date$
+//
+// --[ Description ] ----------------------------------------------------------
+//
+// Description
+//
+// --[ 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-2015 Claunia.com
+// ****************************************************************************/
+// //$Id$
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using DiscImageChef.Console;
+
+namespace DiscImageChef.Plugins
+{
+    class AcornADFS : Plugin
+    {
+        const ulong ADFS_SB_POS = 0xC00;
+
+        public AcornADFS()
+        {
+            Name = "Acorn Advanced Disc Filing System";
+            PluginUUID = new Guid("BAFC1E50-9C64-4CD3-8400-80628CC27AFA");
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        struct DiscRecord
+        {
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x1C0)]
+            public byte[] spare;
+            public byte log2secsize;
+            public byte spt;
+            public byte heads;
+            public byte density;
+            public byte idlen;
+            public byte log2bpmb;
+            public byte skew;
+            public byte bootoption;
+            public byte lowsector;
+            public byte nzones;
+            public short zone_spare;
+            public int root;
+            public uint disc_size;
+            public short disc_id;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
+            public byte[] disc_name;
+            public int disc_type;
+            public uint disc_size_high;
+            public byte flags;
+            public byte nzones_high;
+            public int format_version;
+            public int root_size;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
+            public byte[] reserved;
+        }
+
+        public override bool Identify(ImagePlugins.ImagePlugin imagePlugin, ulong partitionStart, ulong partitionEnd)
+        {
+            if (partitionStart >= imagePlugin.GetSectors())
+                return false;
+
+            ulong sbSector;
+
+            if (imagePlugin.GetSectorSize() > ADFS_SB_POS)
+                sbSector = 0;
+            else
+                sbSector = ADFS_SB_POS / imagePlugin.GetSectorSize();
+
+            byte[] sector = imagePlugin.ReadSector(sbSector + partitionStart);
+
+            GCHandle handle = GCHandle.Alloc(sector, GCHandleType.Pinned);
+            DiscRecord drSb = (DiscRecord)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(DiscRecord));
+            handle.Free();
+
+            if (drSb.log2secsize < 8 || drSb.log2secsize > 10)
+                return false;
+
+            if (drSb.idlen < (drSb.log2secsize + 3) || drSb.idlen > 19)
+                return false;
+
+            if ((drSb.disc_size_high >> drSb.log2secsize) != 0)
+                return false;
+
+            if (!ArrayHelpers.ArrayIsNullOrEmpty(drSb.reserved))
+                return false;
+
+            ulong bytes = drSb.disc_size_high;
+            bytes *= 0x100000000;
+            bytes += drSb.disc_size;
+
+            if (bytes > (imagePlugin.GetSectors() * (ulong)imagePlugin.GetSectorSize()))
+               return false;
+
+            return true;
+        }
+        public override void GetInformation(ImagePlugins.ImagePlugin imagePlugin, ulong partitionStart, ulong partitionEnd, out string information)
+        {
+            StringBuilder sbInformation = new StringBuilder();
+            xmlFSType = new Schemas.FileSystemType();
+            information = "";
+
+            ulong sbSector;
+
+            if (imagePlugin.GetSectorSize() > ADFS_SB_POS)
+                sbSector = 0;
+            else
+                sbSector = ADFS_SB_POS / imagePlugin.GetSectorSize();
+
+            byte[] sector = imagePlugin.ReadSector(sbSector + partitionStart);
+
+            GCHandle handle = GCHandle.Alloc(sector, GCHandleType.Pinned);
+            DiscRecord drSb = (DiscRecord)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(DiscRecord));
+            handle.Free();
+
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.log2secsize = {0}", drSb.log2secsize);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.spt = {0}", drSb.spt);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.heads = {0}", drSb.heads);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.density = {0}", drSb.density);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.idlen = {0}", drSb.idlen);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.log2bpmb = {0}", drSb.log2bpmb);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.skew = {0}", drSb.skew);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.bootoption = {0}", drSb.bootoption);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.lowsector = {0}", drSb.lowsector);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.nzones = {0}", drSb.nzones);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.zone_spare = {0}", drSb.zone_spare);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.root = {0}", drSb.root);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size = {0}", drSb.disc_size);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_id = {0}", drSb.disc_id);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_name = {0}", StringHandlers.CToString(drSb.disc_name));
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_type = {0}", drSb.disc_type);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size_high = {0}", drSb.disc_size_high);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.flags = {0}", drSb.flags);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.nzones_high = {0}", drSb.nzones_high);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.format_version = {0}", drSb.format_version);
+            DicConsole.DebugWriteLine("ADFS Plugin", "drSb.root_size = {0}", drSb.root_size);
+
+            if (drSb.log2secsize < 8 || drSb.log2secsize > 10)
+                return;
+
+            if (drSb.idlen < (drSb.log2secsize + 3) || drSb.idlen > 19)
+                return;
+
+            if ((drSb.disc_size_high >> drSb.log2secsize) != 0)
+                return;
+
+            if (!ArrayHelpers.ArrayIsNullOrEmpty(drSb.reserved))
+                return;
+
+            ulong bytes = drSb.disc_size_high;
+            bytes *= 0x100000000;
+            bytes += drSb.disc_size;
+
+            ulong zones = drSb.nzones_high;
+            zones *= 0x100000000;
+            zones += drSb.nzones;
+
+            if (bytes > (imagePlugin.GetSectors() * (ulong)imagePlugin.GetSectorSize()))
+                return;
+
+            string discname = StringHandlers.CToString(drSb.disc_name);
+
+            sbInformation.AppendLine("Acorn Advanced Disc Filing System");
+            sbInformation.AppendLine();
+            sbInformation.AppendFormat("Version {0}", drSb.format_version).AppendLine();
+            sbInformation.AppendFormat("{0} bytes per sector", 1 << drSb.log2secsize).AppendLine();
+            sbInformation.AppendFormat("{0} sectors per track", drSb.spt).AppendLine();
+            sbInformation.AppendFormat("{0} heads", drSb.heads).AppendLine();
+            sbInformation.AppendFormat("Density code: {0}", drSb.density).AppendLine();
+            sbInformation.AppendFormat("Skew: {0}", drSb.skew).AppendLine();
+            sbInformation.AppendFormat("Boot option: {0}", drSb.bootoption).AppendLine();
+            sbInformation.AppendFormat("Root starts at byte {0}", drSb.root).AppendLine();
+            sbInformation.AppendFormat("Root is {0} bytes long", drSb.root_size).AppendLine();
+            sbInformation.AppendFormat("Volume has {0} bytes in {1} zones", bytes, zones).AppendLine();
+            sbInformation.AppendFormat("Volume flags: 0x{0:X4}", drSb.flags).AppendLine();
+            sbInformation.AppendFormat("Volume ID: {0}", drSb.disc_id).AppendLine();
+            sbInformation.AppendFormat("Volume name: {0}", discname).AppendLine();
+
+            information = sbInformation.ToString();
+
+            xmlFSType = new Schemas.FileSystemType();
+            xmlFSType.Bootable |= drSb.bootoption != 0; // Or not?
+            xmlFSType.Clusters = (long)(bytes / (ulong)(1 << drSb.log2secsize));
+            xmlFSType.ClusterSize = (1 << drSb.log2secsize);
+            xmlFSType.Type = "Acorn Advanced Disc Filing System";
+            xmlFSType.VolumeName = discname;
+            xmlFSType.VolumeSerial = string.Format("{0}", drSb.disc_id);
+        }
+    }
+}
+
--- a/DiscImageChef.Filesystems/ChangeLog
+++ b/DiscImageChef.Filesystems/ChangeLog
@@ -1,3 +1,12 @@
+2016-02-05  Natalia Portillo  <claunia@claunia.com>
+
+	* Acorn.cs:
+	* DiscImageChef.Filesystems.csproj:
+	  Added support for Acorn ADFS.
+
+	* FFS.cs:
+	  Correct FFS information.
+
 2016-02-05  Natalia Portillo  <claunia@claunia.com>

 	* FAT.cs:
--- a/DiscImageChef.Filesystems/DiscImageChef.Filesystems.csproj
+++ b/DiscImageChef.Filesystems/DiscImageChef.Filesystems.csproj
@@ -57,6 +57,7 @@
    <Compile Include="Symbian.cs" />
    <Compile Include="SysV.cs" />
    <Compile Include="UNIXBFS.cs" />
+    <Compile Include="Acorn.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <ItemGroup>
--- a/DiscImageChef.Filesystems/FFS.cs
+++ b/DiscImageChef.Filesystems/FFS.cs
@@ -602,10 +602,10 @@ namespace DiscImageChef.Plugins
            sbInformation.AppendFormat("First data block LBA: {0}", ufs_sb.fs_dblkno).AppendLine();
            sbInformation.AppendFormat("Cylinder group offset in cylinder: {0}", ufs_sb.fs_cgoffset).AppendLine();
            sbInformation.AppendFormat("Volume last written on {0}", DateHandlers.UNIXUnsignedToDateTime(ufs_sb.fs_time_t)).AppendLine();
-            sbInformation.AppendFormat("{0} blocks in volume ({1} bytes)", ufs_sb.fs_size, ufs_sb.fs_size * ufs_sb.fs_bsize).AppendLine();
+            sbInformation.AppendFormat("{0} blocks in volume ({1} bytes)", ufs_sb.fs_size, (ulong)ufs_sb.fs_size * (ulong)1024).AppendLine();
            xmlFSType.Clusters = ufs_sb.fs_size;
            xmlFSType.ClusterSize = (int)ufs_sb.fs_bsize;
-            sbInformation.AppendFormat("{0} data blocks in volume ({1} bytes)", ufs_sb.fs_dsize, ufs_sb.fs_dsize * ufs_sb.fs_bsize).AppendLine();
+            sbInformation.AppendFormat("{0} data blocks in volume ({1} bytes)", ufs_sb.fs_dsize, (ulong)ufs_sb.fs_dsize * (ulong)1024).AppendLine();
            sbInformation.AppendFormat("{0} cylinder groups in volume", ufs_sb.fs_ncg).AppendLine();
            sbInformation.AppendFormat("{0} bytes in a basic block", ufs_sb.fs_bsize).AppendLine();
            sbInformation.AppendFormat("{0} bytes in a frag block", ufs_sb.fs_fsize).AppendLine();
--- a/DiscImageChef.Partitions/ChangeLog
+++ b/DiscImageChef.Partitions/ChangeLog
@@ -1,3 +1,9 @@
+2016-02-05  Natalia Portillo  <claunia@claunia.com>
+
+	* Sun.cs:
+	* DiscImageChef.Partitions.csproj:
+	  Added support for Sun disklabel.
+
 2016-02-03  Natalia Portillo  <claunia@claunia.com>

 	* AppleMap.cs:
--- a/DiscImageChef.Partitions/DiscImageChef.Partitions.csproj
+++ b/DiscImageChef.Partitions/DiscImageChef.Partitions.csproj
@@ -40,6 +40,7 @@
    <Compile Include="NeXT.cs" />
    <Compile Include="PartPlugin.cs" />
    <Compile Include="RDB.cs" />
+    <Compile Include="Sun.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <ItemGroup>
--- a/DiscImageChef.Partitions/Sun.cs
+++ b/DiscImageChef.Partitions/Sun.cs
@@ -0,0 +1,407 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : Sun.cs
+// Version        : 1.0
+// Author(s)      : Natalia Portillo
+//
+// Component      : Component
+//
+// Revision       : $Revision$
+// Last change by : $Author$
+// Date           : $Date$
+//
+// --[ Description ] ----------------------------------------------------------
+//
+// Description
+//
+// --[ 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-2015 Claunia.com
+// ****************************************************************************/
+// //$Id$
+using System;
+using System.Collections.Generic;
+using DiscImageChef.Console;
+
+namespace DiscImageChef.PartPlugins
+{
+    class SunDisklabel : PartPlugin
+    {
+        const UInt16 SUN_MAGIC = 0xDABE;
+        const UInt32 VTOC_MAGIC = 0x600DDEEE;
+
+        public enum SunTypes : ushort
+        {
+            SunEmpty = 0x0000,
+            SunBoot = 0x0001,
+            SunRoot = 0x0002,
+            SunSwap = 0x0003,
+            SunUsr = 0x0004,
+            SunWholeDisk = 0x0005,
+            SunStand = 0x0006,
+            SunVar = 0x0007,
+            SunHome = 0x0008,
+            LinuxSwap = 0x0082,
+            Linux = 0x0083,
+            LVM = 0x008E,
+            LinuxRaid = 0x00FD
+        }
+
+        [Flags]
+        public enum SunFlags : ushort
+        {
+            NoMount = 0x0001,
+            ReadOnly = 0x0010,
+        }
+
+        public SunDisklabel()
+        {
+            Name = "Sun Disklabel";
+            PluginUUID = new Guid("50F35CC4-8375-4445-8DCB-1BA550C931A3");
+        }
+
+        public override bool GetInformation(ImagePlugins.ImagePlugin imagePlugin, out List<CommonTypes.Partition> partitions)
+        {
+            partitions = new List<CommonTypes.Partition>();
+
+            byte[] sunSector = imagePlugin.ReadSector(0);
+            byte[] tmpString;
+            SunDiskLabel sdl = new SunDiskLabel();
+            sdl.vtoc = new SunVTOC();
+            sdl.spare = new byte[148];
+            sdl.vtoc.infos = new SunInfo[8];
+            sdl.vtoc.bootinfo = new uint[3];
+            sdl.vtoc.reserved = new byte[40];
+            sdl.vtoc.timestamp = new uint[8];
+            sdl.partitions = new SunPartition[8];
+
+            BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
+
+            tmpString = new byte[128];
+            Array.Copy(sunSector, 0, tmpString, 0, 128);
+            sdl.info = StringHandlers.CToString(tmpString);
+            sdl.vtoc.version = BigEndianBitConverter.ToUInt32(sunSector, 0x80 + 0x00);
+
+            tmpString = new byte[8];
+            Array.Copy(sunSector, 0x80 + 0x04, tmpString, 0, 8);
+            sdl.vtoc.volname = StringHandlers.CToString(tmpString);
+            sdl.vtoc.nparts = BigEndianBitConverter.ToUInt16(sunSector, 0x80 + 0x0C);
+            for (int i = 0; i < 8; i++)
+            {
+                sdl.vtoc.infos[i] = new SunInfo();
+                sdl.vtoc.infos[i].id = BigEndianBitConverter.ToUInt16(sunSector, 0x80 + 0x0E + i * 4 + 0x00);
+                sdl.vtoc.infos[i].flags = BigEndianBitConverter.ToUInt16(sunSector, 0x80 + 0x0E + i * 4 + 0x02);
+            }
+            sdl.vtoc.padding = BigEndianBitConverter.ToUInt16(sunSector, 0x80 + 0x2E);
+            for (int i = 0; i < 3; i++)
+                sdl.vtoc.bootinfo[i] = BigEndianBitConverter.ToUInt32(sunSector, 0x80 + 0x30 + i * 4);
+            sdl.vtoc.sanity = BigEndianBitConverter.ToUInt32(sunSector, 0x80 + 0x3C);
+            Array.Copy(sunSector, 0x80 + 0x40, sdl.vtoc.reserved, 0, 40);
+            for (int i = 0; i < 8; i++)
+                sdl.vtoc.timestamp[i] = BigEndianBitConverter.ToUInt32(sunSector, 0x80 + 0x68 + i * 4);
+
+            sdl.write_reinstruct = BigEndianBitConverter.ToUInt32(sunSector, 0x108);
+            sdl.read_reinstruct = BigEndianBitConverter.ToUInt32(sunSector, 0x10C);
+            Array.Copy(sunSector, 0x110, sdl.spare, 0, 148);
+            sdl.rspeed = BigEndianBitConverter.ToUInt16(sunSector, 0x1A4);
+            sdl.pcylcount = BigEndianBitConverter.ToUInt16(sunSector, 0x1A6);
+            sdl.sparecyl = BigEndianBitConverter.ToUInt16(sunSector, 0x1A8);
+            sdl.gap1 = BigEndianBitConverter.ToUInt16(sunSector, 0x1AA);
+            sdl.gap2 = BigEndianBitConverter.ToUInt16(sunSector, 0x1AC);
+            sdl.ilfact = BigEndianBitConverter.ToUInt16(sunSector, 0x1AE);
+            sdl.ncyl = BigEndianBitConverter.ToUInt16(sunSector, 0x1B0);
+            sdl.nacyl = BigEndianBitConverter.ToUInt16(sunSector, 0x1B2);
+            sdl.ntrks = BigEndianBitConverter.ToUInt16(sunSector, 0x1B4);
+            sdl.nsect = BigEndianBitConverter.ToUInt16(sunSector, 0x1B6);
+            sdl.bhead = BigEndianBitConverter.ToUInt16(sunSector, 0x1B8);
+            sdl.ppart = BigEndianBitConverter.ToUInt16(sunSector, 0x1BA);
+
+            for (int i = 0; i < 8; i++)
+            {
+                sdl.partitions[i] = new SunPartition();
+                sdl.partitions[i].start_cylinder = BigEndianBitConverter.ToUInt32(sunSector, 0x1BC + i * 8 + 0x00);
+                sdl.partitions[i].num_sectors = BigEndianBitConverter.ToUInt32(sunSector, 0x1BC + i * 8 + 0x04);
+            }
+
+            sdl.magic = BigEndianBitConverter.ToUInt16(sunSector, 0x1FC);
+            sdl.csum = BigEndianBitConverter.ToUInt16(sunSector, 0x1FE);
+
+            ushort csum = 0;
+            for (int i = 0; i < 510; i += 2)
+                csum ^= BigEndianBitConverter.ToUInt16(sunSector, i);
+
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.info = {0}", sdl.info);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.version = {0}", sdl.vtoc.version);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.volname = {0}", sdl.vtoc.volname);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.nparts = {0}", sdl.vtoc.nparts);
+            for (int i = 0; i < 8; i++)
+            {
+                DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.infos[{1}].id = 0x{0:X4}", sdl.vtoc.infos[i].id, i);
+                DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.infos[{1}].flags = 0x{0:X4}", sdl.vtoc.infos[i].flags, i);
+            }
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.padding = 0x{0:X4}", sdl.vtoc.padding);
+            for (int i = 0; i < 3; i++)
+                DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.bootinfo[{1}].id = 0x{0:X8}", sdl.vtoc.bootinfo[i], i);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.sanity = 0x{0:X8}", sdl.vtoc.sanity);
+            for (int i = 0; i < 8; i++)
+                DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.vtoc.timestamp[{1}] = 0x{0:X8}", sdl.vtoc.timestamp[i], i);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.rspeed = {0}", sdl.rspeed);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.pcylcount = {0}", sdl.pcylcount);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.sparecyl = {0}", sdl.sparecyl);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.gap1 = {0}", sdl.gap1);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.gap2 = {0}", sdl.gap2);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.ilfact = {0}", sdl.ilfact);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.ncyl = {0}", sdl.ncyl);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.nacyl = {0}", sdl.nacyl);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.ntrks = {0}", sdl.ntrks);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.nsect = {0}", sdl.nsect);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.bhead = {0}", sdl.bhead);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.ppart = {0}", sdl.ppart);
+            for (int i = 0; i < 8; i++)
+            {
+                DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.partitions[{1}].start_cylinder = {0}", sdl.partitions[i].start_cylinder, i);
+                DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.partitions[{1}].num_sectors = {0}", sdl.partitions[i].num_sectors, i);
+            }
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.magic = 0x{0:X4}", sdl.magic);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "sdl.csum = 0x{0:X4}", sdl.csum);
+            DicConsole.DebugWriteLine("Sun Disklabel plugin", "csum = 0x{0:X4}", csum);
+
+            ulong sectorsPerCylinder = (ulong)(sdl.nsect * sdl.ntrks);
+
+            if (sectorsPerCylinder == 0 || sectorsPerCylinder * sdl.pcylcount > imagePlugin.GetSectors() || sdl.magic != SUN_MAGIC)
+                return false;
+
+            for (int i = 0; i < 8; i++)
+            {
+                if ((SunTypes)sdl.vtoc.infos[i].id != SunTypes.SunWholeDisk && sdl.partitions[i].num_sectors > 0)
+                {
+                    CommonTypes.Partition part = new CommonTypes.Partition();
+                    part.PartitionDescription = SunFlagsToString((SunFlags)sdl.vtoc.infos[i].flags);
+                    part.PartitionLength = (ulong)sdl.partitions[i].num_sectors * (ulong)imagePlugin.GetSectorSize();
+                    part.PartitionName = "";
+                    part.PartitionSectors = sdl.partitions[i].num_sectors;
+                    part.PartitionSequence = (ulong)i;
+                    part.PartitionStart = (ulong)sdl.partitions[i].start_cylinder * (ulong)sectorsPerCylinder * (ulong)imagePlugin.GetSectorSize();
+                    part.PartitionStartSector = sdl.partitions[i].start_cylinder * sectorsPerCylinder;
+                    part.PartitionType = SunIdToString((SunTypes)sdl.vtoc.infos[i].id);
+
+                    if (part.PartitionStartSector > imagePlugin.GetSectors() || (part.PartitionStartSector + part.PartitionSectors) > imagePlugin.GetSectors())
+                        return false;
+
+                    partitions.Add(part);
+                }
+            }
+
+            return true;
+        }
+
+        public static string SunFlagsToString(SunFlags flags)
+        {
+            System.Text.StringBuilder sb = new System.Text.StringBuilder();
+            if (flags.HasFlag(SunFlags.NoMount))
+                sb.AppendLine("Unmountable");
+            if (flags.HasFlag(SunFlags.ReadOnly))
+                sb.AppendLine("Read-only");
+            return sb.ToString();
+        }
+
+        public static string SunIdToString(SunTypes id)
+        {
+            switch (id)
+            {
+                case SunTypes.Linux:
+                    return "Linux";
+                case SunTypes.LinuxRaid:
+                return "Linux RAID";
+                case SunTypes.LinuxSwap:
+                    return "Linux swap";
+                case SunTypes.LVM:
+                    return "LVM";
+                case SunTypes.SunBoot:
+                    return "Sun boot";
+                case SunTypes.SunEmpty:
+                    return "Empty";
+                case SunTypes.SunHome:
+                    return "Sun /home";
+                case SunTypes.SunRoot:
+                    return "Sun /";
+                case SunTypes.SunStand:
+                    return "Sun /stand";
+                case SunTypes.SunSwap:
+                    return "Sun swap";
+                case SunTypes.SunUsr:
+                    return "Sun /usr";
+                case SunTypes.SunVar:
+                    return "Sun /var";
+                case SunTypes.SunWholeDisk:
+                    return "Whole disk";
+                default:
+                    return "Unknown";
+            }
+        }
+
+        public struct SunDiskLabel
+        {
+            /// <summary>
+            /// Offset 0x000: Informative string, 128 bytes
+            /// </summary>
+            public string info;
+            /// <summary>
+            /// Offset 0x080: Volume Table Of Contents
+            /// </summary>
+            public SunVTOC vtoc;
+            /// <summary>
+            /// Offset 0x108: Sectors to skip on writes
+            /// </summary>
+            public uint write_reinstruct;
+            /// <summary>
+            /// Offset 0x10C: Sectors to skip in reads
+            /// </summary>
+            public uint read_reinstruct;
+            /// <summary>
+            /// Offset 0x110: Unused, 148 bytes
+            /// </summary>
+            public byte[] spare;
+            /// <summary>
+            /// Offset 0x1A4: Rotational speed
+            /// </summary>
+            public ushort rspeed;
+            /// <summary>
+            /// Offset 0x1A6: Physical cylinder count
+            /// </summary>
+            public ushort pcylcount;
+            /// <summary>
+            /// Offset 0x1A8: Extra sectors per cylinder
+            /// </summary>
+            public ushort sparecyl;
+            /// <summary>
+            /// Offset 0x1AA: Obsolete, gap
+            /// </summary>
+            public ushort gap1;
+            /// <summary>
+            /// Offset 0x1AC: Obsolete, gap
+            /// </summary>
+            public ushort gap2;
+            /// <summary>
+            /// Offset 0x1AE: Interleave factor
+            /// </summary>
+            public ushort ilfact;
+            /// <summary>
+            /// Offset 0x1B0: Cylinders
+            /// </summary>
+            public ushort ncyl;
+            /// <summary>
+            /// Offset 0x1B2: Alternate cylinders
+            /// </summary>
+            public ushort nacyl;
+            /// <summary>
+            /// Offset 0x1B4: Tracks per cylinder
+            /// </summary>
+            public ushort ntrks;
+            /// <summary>
+            /// Offset 0x1B6: Sectors per track
+            /// </summary>
+            public ushort nsect;
+            /// <summary>
+            /// Offset 0x1B8: Label head offset
+            /// </summary>
+            public ushort bhead;
+            /// <summary>
+            /// Offset 0x1BA: Physical partition 
+            /// </summary>
+            public ushort ppart;
+            /// <summary>
+            /// Offset 0x1BC: Partitions
+            /// </summary>
+            public SunPartition[] partitions;
+            /// <summary>
+            /// Offset 0x1FC: 
+            /// </summary>
+            public ushort magic;
+            /// <summary>
+            /// Offset 0x1FE: XOR of label
+            /// </summary>
+            public ushort csum;
+        }
+
+        public struct SunVTOC
+        {
+            /// <summary>
+            /// Offset 0x00: VTOC version
+            /// </summary>
+            public uint version;
+            /// <summary>
+            /// Offset 0x04: Volume name, 8 bytes
+            /// </summary>
+            public string volname;
+            /// <summary>
+            /// Offset 0x0C: Number of partitions
+            /// </summary>
+            public ushort nparts;
+            /// <summary>
+            /// Offset 0x0E: Partition information, 8 entries
+            /// </summary>
+            public SunInfo[] infos;
+            /// <summary>
+            /// Offset 0x2E: Padding
+            /// </summary>
+            public ushort padding;
+            /// <summary>
+            /// Offset 0x30: Information needed by mboot, 3 entries
+            /// </summary>
+            public uint[] bootinfo;
+            /// <summary>
+            /// Offset 0x3C: VTOC magic
+            /// </summary>
+            public uint sanity;
+            /// <summary>
+            /// Offset 0x40: Reserved, 40 bytes
+            /// </summary>
+            public byte[] reserved;
+            /// <summary>
+            /// Offset 0x68: Partition timestamps, 8 entries
+            /// </summary>
+            public uint[] timestamp;
+        }
+
+        public struct SunInfo
+        {
+            /// <summary>
+            /// Offset 0x00: Partition ID
+            /// </summary>
+            public ushort id;
+            /// <summary>
+            /// Offset 0x02: Partition flags
+            /// </summary>
+            public ushort flags;
+        }
+
+        public struct SunPartition
+        {
+            /// <summary>
+            /// Offset 0x00: Starting cylinder
+            /// </summary>
+            public uint start_cylinder;
+            /// <summary>
+            /// Offset 0x02: Sectors
+            /// </summary>
+            public uint num_sectors;
+        }
+    }
+}
--- a/DiscImageChef/ChangeLog
+++ b/DiscImageChef/ChangeLog
@@ -1,3 +1,8 @@
+2016-02-05  Natalia Portillo  <claunia@claunia.com>
+
+	* Commands/DumpMedia.cs:
+	  Correct physical/logical block size in sidecar.
+
 2016-02-05  Natalia Portillo  <claunia@claunia.com>

 	* Commands/Analyze.cs:
--- a/DiscImageChef/Commands/DumpMedia.cs
+++ b/DiscImageChef/Commands/DumpMedia.cs
@@ -142,6 +142,8 @@ namespace DiscImageChef.Commands
            byte[] tmpBuf;
            MediaType dskType = MediaType.Unknown;
            bool opticalDisc = false;
+            uint logicalBlockSize = 0;
+            uint physicalBlockSize = 0;

            if (dev.IsRemovable)
            {
@@ -262,6 +264,9 @@ namespace DiscImageChef.Commands
                    DicConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2} bytes)",
                        blocks, blockSize, blocks * (ulong)blockSize);
                }
+
+                logicalBlockSize = blockSize;
+                physicalBlockSize = blockSize;
            }

            if (dev.SCSIType == DiscImageChef.Decoders.SCSI.PeripheralDeviceTypes.SequentialAccess)
@@ -545,6 +550,8 @@ namespace DiscImageChef.Commands
                            }
                        }
                    }
+
+                    physicalBlockSize = 2448;
                }
                #endregion CompactDisc
                else
@@ -1604,6 +1611,7 @@ namespace DiscImageChef.Commands
                        DicConsole.WriteLine("Reading {0} raw bytes ({1} cooked bytes) per sector.",
                            longBlockSize, blockSize);
                        blocksToRead = 1;
+                        physicalBlockSize = longBlockSize;
                        blockSize = longBlockSize;
                    }
                }
@@ -2235,7 +2243,8 @@ namespace DiscImageChef.Commands
                            sidecar.BlockMedia[0].Interface = "SCSI";
                    }
                    sidecar.BlockMedia[0].LogicalBlocks = (long)blocks;
-                    sidecar.BlockMedia[0].LogicalBlockSize = (int)blockSize;
+                    sidecar.BlockMedia[0].PhysicalBlockSize = (int)physicalBlockSize;
+                    sidecar.BlockMedia[0].LogicalBlockSize = (int)logicalBlockSize;
                    sidecar.BlockMedia[0].Manufacturer = dev.Manufacturer;
                    sidecar.BlockMedia[0].Model = dev.Model;
                    sidecar.BlockMedia[0].Serial = dev.Serial;
--- a/README.md
+++ b/README.md
@@ -54,6 +54,7 @@ Supported partitioning schemes
 * NeXT disklabel
 * Amiga Rigid Disk Block (RDB)
 * Atari AHDI and ICDPro
+* Sun disklabel

 Supported file systems
 ======================
@@ -88,6 +89,7 @@ Supported file systems
 * Amiga Original File System, with international characters, directory cache and multi-user patches
 * Amiga Fast File System, with international characters, directory cache and multi-user patches
 * Amiga Fast File System v2, untested
+* Acorn Advanced Disc Filing System

 Supported checksums
 ===================
--- a/2
+++ b/2
@@ -20,7 +20,6 @@
 Filesystem plugins:
 --- Add support for SFS filesystem
 --- Add support for PFS3 filesystem
--- Add support for Acorn filesystems
 --- Add support for Apple DOS filesystems
 --- Add support for UCSD/Pascal filesystem
 --- Add support for AMSDOS filesystem
@@ -48,7 +47,6 @@ Partitioning scheme plugins:
 --- Add support for AIX partitions
 --- Add support for EFI GPT
 --- Add support for SGI partitions
--- Add support for Sun partitions
 --- Add support for Ultrix partitions

 Other things: