aaru-dps/Aaru.Server
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Server.git synced 2025-12-16 19:24:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add writing support to QEMU Copy-On-Write disk image.

Browse Source
This commit is contained in:
Natalia Portillo
2018-01-17 15:35:17 +00:00
parent eb92cd0602
commit f723c1c440
1 changed files with 354 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

434
DiscImageChef.DiscImages/QCOW.cs
View File

@@ -33,6 +33,7 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using DiscImageChef.CommonTypes;
using DiscImageChef.Console;
@@ -42,65 +43,66 @@ using SharpCompress.Compressors.Deflate;
namespace DiscImageChef.DiscImages
{
public class Qcow : IMediaImage
public class Qcow : IWritableImage
{
/// <summary>
/// Magic number: 'Q', 'F', 'I', 0xFB
/// </summary>
const uint QCOW_MAGIC = 0x514649FB;
const uint QCOW_VERSION = 1;
const uint QCOW_ENCRYPTION_NONE = 0;
const uint QCOW_ENCRYPTION_AES = 1;
const ulong QCOW_COMPRESSED = 0x8000000000000000;
const uint QCOW_MAGIC = 0x514649FB;
const uint QCOW_VERSION = 1;
const uint QCOW_ENCRYPTION_NONE = 0;
const uint QCOW_ENCRYPTION_AES = 1;
const ulong QCOW_COMPRESSED = 0x8000000000000000;
const int MAX_CACHE_SIZE = 16777216;
const int MAX_CACHED_SECTORS = MAX_CACHE_SIZE / 512;
const int MAX_CACHED_SECTORS = MAX_CACHE_SIZE / 512;
Dictionary<ulong, byte[]> clusterCache;
int clusterSectors;
int clusterSize;
ImageInfo imageInfo;
int clusterSectors;
int clusterSize;
ImageInfo imageInfo;
Stream imageStream;
ulong l1Mask;
int l1Shift;
uint l1Size;
ulong[] l1Table;
ulong l2Mask;
int l2Size;
ulong l1Mask;
int l1Shift;
uint l1Size;
ulong[] l1Table;
ulong l2Mask;
int l2Size;
Dictionary<ulong, ulong[]> l2TableCache;
int maxClusterCache;
int maxL2TableCache;
int maxClusterCache;
int maxL2TableCache;
QCowHeader qHdr;
Dictionary<ulong, byte[]> sectorCache;
ulong sectorMask;
ulong sectorMask;
FileStream writingStream;
public Qcow()
{
imageInfo = new ImageInfo
{
ReadableSectorTags = new List<SectorTagType>(),
ReadableMediaTags = new List<MediaTagType>(),
HasPartitions = false,
HasSessions = false,
Version = "1",
Application = "QEMU",
ApplicationVersion = null,
Creator = null,
Comments = null,
MediaManufacturer = null,
MediaModel = null,
MediaSerialNumber = null,
MediaBarcode = null,
MediaPartNumber = null,
MediaSequence = 0,
LastMediaSequence = 0,
DriveManufacturer = null,
DriveModel = null,
DriveSerialNumber = null,
ReadableSectorTags = new List<SectorTagType>(),
ReadableMediaTags = new List<MediaTagType>(),
HasPartitions = false,
HasSessions = false,
Version = "1",
Application = "QEMU",
ApplicationVersion = null,
Creator = null,
Comments = null,
MediaManufacturer = null,
MediaModel = null,
MediaSerialNumber = null,
MediaBarcode = null,
MediaPartNumber = null,
MediaSequence = 0,
LastMediaSequence = 0,
DriveManufacturer = null,
DriveModel = null,
DriveSerialNumber = null,
DriveFirmwareRevision = null
};
}
@@ -108,7 +110,7 @@ namespace DiscImageChef.DiscImages
public ImageInfo Info => imageInfo;
public string Name => "QEMU Copy-On-Write disk image";
public Guid Id => new Guid("A5C35765-9FE2-469D-BBBF-ACDEBDB7B954");
public Guid Id => new Guid("A5C35765-9FE2-469D-BBBF-ACDEBDB7B954");
public string Format => "QEMU Copy-On-Write";
@@ -146,17 +148,17 @@ namespace DiscImageChef.DiscImages
stream.Read(qHdrB, 0, 48);
qHdr = BigEndianMarshal.ByteArrayToStructureBigEndian<QCowHeader>(qHdrB);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.magic = 0x{0:X8}", qHdr.magic);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.version = {0}", qHdr.version);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.magic = 0x{0:X8}", qHdr.magic);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.version = {0}", qHdr.version);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.backing_file_offset = {0}", qHdr.backing_file_offset);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.backing_file_size = {0}", qHdr.backing_file_size);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.mtime = {0}", qHdr.mtime);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.size = {0}", qHdr.size);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.cluster_bits = {0}", qHdr.cluster_bits);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l2_bits = {0}", qHdr.l2_bits);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.padding = {0}", qHdr.padding);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.crypt_method = {0}", qHdr.crypt_method);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l1_table_offset = {0}", qHdr.l1_table_offset);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.backing_file_size = {0}", qHdr.backing_file_size);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.mtime = {0}", qHdr.mtime);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.size = {0}", qHdr.size);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.cluster_bits = {0}", qHdr.cluster_bits);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l2_bits = {0}", qHdr.l2_bits);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.padding = {0}", qHdr.padding);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.crypt_method = {0}", qHdr.crypt_method);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l1_table_offset = {0}", qHdr.l1_table_offset);
if(qHdr.size <= 1) throw new ArgumentOutOfRangeException(nameof(qHdr.size), "Image size is too small");
@@ -182,16 +184,16 @@ namespace DiscImageChef.DiscImages
if(qHdr.size > ulong.MaxValue - (ulong)(1 << shift))
throw new ArgumentOutOfRangeException(nameof(qHdr.size), "Image is too large");
clusterSize = 1 << qHdr.cluster_bits;
clusterSize = 1 << qHdr.cluster_bits;
clusterSectors = 1 << (qHdr.cluster_bits - 9);
l1Size = (uint)((qHdr.size + (ulong)(1 << shift) - 1) >> shift);
l2Size = 1 << qHdr.l2_bits;
l1Size = (uint)((qHdr.size + (ulong)(1 << shift) - 1) >> shift);
l2Size = 1 << qHdr.l2_bits;
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.clusterSize = {0}", clusterSize);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.clusterSize = {0}", clusterSize);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.clusterSectors = {0}", clusterSectors);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l1Size = {0}", l1Size);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l2Size = {0}", l2Size);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.sectors = {0}", imageInfo.Sectors);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l1Size = {0}", l1Size);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l2Size = {0}", l2Size);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.sectors = {0}", imageInfo.Sectors);
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
@@ -203,8 +205,8 @@ namespace DiscImageChef.DiscImages
for(long i = 0; i < l1Table.LongLength; i++)
l1Table[i] = BigEndianBitConverter.ToUInt64(l1TableB, (int)(i * 8));
l1Mask = 0;
int c = 0;
l1Mask = 0;
int c = 0;
l1Shift = qHdr.l2_bits + qHdr.cluster_bits;
for(int i = 0; i < 64; i++)
@@ -217,17 +219,17 @@ namespace DiscImageChef.DiscImages
c++;
}
l2Mask = 0;
l2Mask = 0;
for(int i = 0; i < qHdr.l2_bits; i++) l2Mask = (l2Mask << 1) + 1;
l2Mask <<= qHdr.cluster_bits;
sectorMask = 0;
sectorMask = 0;
for(int i = 0; i < qHdr.cluster_bits; i++) sectorMask = (sectorMask << 1) + 1;
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l1Mask = {0:X}", l1Mask);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l1Shift = {0}", l1Shift);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l2Mask = {0:X}", l2Mask);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l1Mask = {0:X}", l1Mask);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l1Shift = {0}", l1Shift);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.l2Mask = {0:X}", l2Mask);
DicConsole.DebugWriteLine("QCOW plugin", "qHdr.sectorMask = {0:X}", sectorMask);
maxL2TableCache = MAX_CACHE_SIZE / (l2Size * 8);
@@ -235,23 +237,23 @@ namespace DiscImageChef.DiscImages
imageStream = stream;
sectorCache = new Dictionary<ulong, byte[]>();
sectorCache = new Dictionary<ulong, byte[]>();
l2TableCache = new Dictionary<ulong, ulong[]>();
clusterCache = new Dictionary<ulong, byte[]>();
imageInfo.CreationTime = imageFilter.GetCreationTime();
imageInfo.CreationTime = imageFilter.GetCreationTime();
imageInfo.LastModificationTime = qHdr.mtime > 0
? DateHandlers.UnixUnsignedToDateTime(qHdr.mtime)
: imageFilter.GetLastWriteTime();
imageInfo.MediaTitle = Path.GetFileNameWithoutExtension(imageFilter.GetFilename());
imageInfo.Sectors = qHdr.size / 512;
imageInfo.SectorSize = 512;
imageInfo.MediaTitle = Path.GetFileNameWithoutExtension(imageFilter.GetFilename());
imageInfo.Sectors = qHdr.size / 512;
imageInfo.SectorSize = 512;
imageInfo.XmlMediaType = XmlMediaType.BlockMedia;
imageInfo.MediaType = MediaType.GENERIC_HDD;
imageInfo.ImageSize = qHdr.size;
imageInfo.MediaType = MediaType.GENERIC_HDD;
imageInfo.ImageSize = qHdr.size;
imageInfo.Cylinders = (uint)(imageInfo.Sectors / 16 / 63);
imageInfo.Heads = 16;
imageInfo.Cylinders = (uint)(imageInfo.Sectors / 16 / 63);
imageInfo.Heads = 16;
imageInfo.SectorsPerTrack = 63;
return true;
@@ -281,7 +283,7 @@ namespace DiscImageChef.DiscImages
{
l2Table = new ulong[l2Size];
imageStream.Seek((long)l1Table[l1Off], SeekOrigin.Begin);
byte[] l2TableB = new byte[l2Size * 8];
byte[] l2TableB = new byte[l2Size * 8];
imageStream.Read(l2TableB, 0, l2Size * 8);
DicConsole.DebugWriteLine("QCOW plugin", "Reading L2 table #{0}", l1Off);
for(long i = 0; i < l2Table.LongLength; i++)
@@ -307,11 +309,11 @@ namespace DiscImageChef.DiscImages
ulong compSizeMask;
ulong offMask;
compSizeMask = (ulong)(1 << qHdr.cluster_bits) - 1;
compSizeMask <<= 63 - qHdr.cluster_bits;
offMask = ~compSizeMask ^ QCOW_COMPRESSED;
compSizeMask = (ulong)(1 << qHdr.cluster_bits) - 1;
compSizeMask <<= 63 - qHdr.cluster_bits;
offMask = ~compSizeMask ^ QCOW_COMPRESSED;
ulong realOff = offset & offMask;
ulong realOff = offset & offMask;
ulong compSize = (offset & compSizeMask) >> (63 - qHdr.cluster_bits);
byte[] zCluster = new byte[compSize];
@@ -320,7 +322,7 @@ namespace DiscImageChef.DiscImages
DeflateStream zStream =
new DeflateStream(new MemoryStream(zCluster), CompressionMode.Decompress);
cluster = new byte[clusterSize];
cluster = new byte[clusterSize];
int read = zStream.Read(cluster, 0, clusterSize);
if(read != clusterSize)
@@ -445,7 +447,7 @@ namespace DiscImageChef.DiscImages
}
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
@@ -455,7 +457,7 @@ namespace DiscImageChef.DiscImages
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
out List<ulong> unknownLbas)
{
throw new FeatureUnsupportedImageException("Feature not supported by image format");
}
@@ -465,6 +467,278 @@ namespace DiscImageChef.DiscImages
return null;
}
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };
public IEnumerable<SectorTagType> SupportedSectorTags => new SectorTagType[] { };
public IEnumerable<MediaType> SupportedMediaTypes =>
new[] {MediaType.Unknown, MediaType.GENERIC_HDD};
public IEnumerable<(string name, Type type, string description)> SupportedOptions =>
new (string name, Type type, string description)[] { };
public IEnumerable<string> KnownExtensions => new[] {".qcow", ".qc"};
public bool IsWriting { get; private set; }
public string ErrorMessage { get; private set; }
public bool Create(string path, MediaType mediaType, Dictionary<string, string> options, ulong sectors,
uint sectorSize)
{
if(sectorSize != 512)
{
ErrorMessage = "Unsupported sector size";
return false;
}
if(!SupportedMediaTypes.Contains(mediaType))
{
ErrorMessage = $"Unsupport media format {mediaType}";
return false;
}
// TODO: Correct this calculation
if(sectors * sectorSize / 65536 > uint.MaxValue)
{
ErrorMessage = "Too many sectors for selected cluster size";
return false;
}
imageInfo = new ImageInfo {MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors};
try { writingStream = new FileStream(path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None); }
catch(IOException e)
{
ErrorMessage = $"Could not create new image file, exception {e.Message}";
return false;
}
qHdr = new QCowHeader
{
magic = QCOW_MAGIC,
version = QCOW_VERSION,
size = sectors * sectorSize,
cluster_bits = 12,
l2_bits = 9,
l1_table_offset = (ulong)Marshal.SizeOf(typeof(QCowHeader))
};
int shift = qHdr.cluster_bits + qHdr.l2_bits;
clusterSize = 1 << qHdr.cluster_bits;
clusterSectors = 1 << (qHdr.cluster_bits - 9);
l1Size = (uint)((qHdr.size + (ulong)(1 << shift) - 1) >> shift);
l2Size = 1 << qHdr.l2_bits;
l1Table = new ulong[l1Size];
l1Mask = 0;
int c = 0;
l1Shift = qHdr.l2_bits + qHdr.cluster_bits;
for(int i = 0; i < 64; i++)
{
l1Mask <<= 1;
if(c >= 64 - l1Shift) continue;
l1Mask += 1;
c++;
}
l2Mask = 0;
for(int i = 0; i < qHdr.l2_bits; i++) l2Mask = (l2Mask << 1) + 1;
l2Mask <<= qHdr.cluster_bits;
sectorMask = 0;
for(int i = 0; i < qHdr.cluster_bits; i++) sectorMask = (sectorMask << 1) + 1;
byte[] empty = new byte[qHdr.l1_table_offset + l1Size * 8];
writingStream.Write(empty, 0, empty.Length);
IsWriting = true;
ErrorMessage = null;
return true;
}
public bool WriteMediaTag(byte[] data, MediaTagType tag)
{
ErrorMessage = "Writing media tags is not supported.";
return false;
}
public bool WriteSector(byte[] data, ulong sectorAddress)
{
if(!IsWriting)
{
ErrorMessage = "Tried to write on a non-writable image";
return false;
}
if(data.Length != imageInfo.SectorSize)
{
ErrorMessage = "Incorrect data size";
return false;
}
if(sectorAddress >= imageInfo.Sectors)
{
ErrorMessage = "Tried to write past image size";
return false;
}
// Ignore empty sectors
if(ArrayHelpers.ArrayIsNullOrEmpty(data)) return true;
ulong byteAddress = sectorAddress * 512;
ulong l1Off = (byteAddress & l1Mask) >> l1Shift;
if((long)l1Off >= l1Table.LongLength)
throw new ArgumentOutOfRangeException(nameof(l1Off),
$"Trying to write past L1 table, position {l1Off} of a max {l1Table.LongLength}");
if(l1Table[l1Off] == 0)
{
writingStream.Seek(0, SeekOrigin.End);
l1Table[l1Off] = (ulong)writingStream.Position;
byte[] l2TableB = new byte[l2Size * 8];
writingStream.Seek(0, SeekOrigin.End);
writingStream.Write(l2TableB, 0, l2TableB.Length);
}
writingStream.Position = (long)l1Table[l1Off];
ulong l2Off = (byteAddress & l2Mask) >> qHdr.cluster_bits;
writingStream.Seek((long)(l1Table[l1Off] + l2Off * 8), SeekOrigin.Begin);
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
byte[] entry = new byte[8];
writingStream.Read(entry, 0, 8);
ulong offset = BigEndianBitConverter.ToUInt64(entry, 0);
if(offset == 0)
{
offset = (ulong)writingStream.Length;
byte[] cluster = new byte[clusterSize];
entry = BigEndianBitConverter.GetBytes(offset);
writingStream.Seek((long)(l1Table[l1Off] + l2Off * 8), SeekOrigin.Begin);
writingStream.Write(entry, 0, 8);
writingStream.Seek(0, SeekOrigin.End);
writingStream.Write(cluster, 0, cluster.Length);
}
writingStream.Seek((long)(offset + (byteAddress & sectorMask)), SeekOrigin.Begin);
writingStream.Write(data, 0, data.Length);
ErrorMessage = "";
return true;
}
// TODO: This can be optimized
public bool WriteSectors(byte[] data, ulong sectorAddress, uint length)
{
if(!IsWriting)
{
ErrorMessage = "Tried to write on a non-writable image";
return false;
}
if(data.Length % imageInfo.SectorSize != 0)
{
ErrorMessage = "Incorrect data size";
return false;
}
if(sectorAddress + length > imageInfo.Sectors)
{
ErrorMessage = "Tried to write past image size";
return false;
}
// Ignore empty sectors
if(ArrayHelpers.ArrayIsNullOrEmpty(data)) return true;
for(uint i = 0; i < length; i++)
{
byte[] tmp = new byte[imageInfo.SectorSize];
Array.Copy(data, i * imageInfo.SectorSize, tmp, 0, imageInfo.SectorSize);
if(!WriteSector(tmp, sectorAddress + i)) return false;
}
ErrorMessage = "";
return true;
}
public bool WriteSectorLong(byte[] data, ulong sectorAddress)
{
ErrorMessage = "Writing sectors with tags is not supported.";
return false;
}
public bool WriteSectorsLong(byte[] data, ulong sectorAddress, uint length)
{
ErrorMessage = "Writing sectors with tags is not supported.";
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)
{
ErrorMessage = "Image is not opened for writing";
return false;
}
qHdr.mtime = (uint)(DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds;
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
writingStream.Seek(0, SeekOrigin.Begin);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.magic), 0, 4);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.version), 0, 4);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.backing_file_offset), 0, 8);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.backing_file_size), 0, 4);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.mtime), 0, 4);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.size), 0, 8);
writingStream.WriteByte(qHdr.cluster_bits);
writingStream.WriteByte(qHdr.l2_bits);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.padding), 0, 2);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.crypt_method), 0, 4);
writingStream.Write(BigEndianBitConverter.GetBytes(qHdr.l1_table_offset), 0, 8);
writingStream.Seek((long)qHdr.l1_table_offset, SeekOrigin.Begin);
for(long i = 0; i < l1Table.LongLength; i++)
writingStream.Write(BigEndianBitConverter.GetBytes(l1Table[i]), 0, 8);
return true;
}
public bool SetMetadata(ImageInfo metadata)
{
return true;
}
public bool SetGeometry(uint cylinders, uint heads, uint sectorsPerTrack)
{
// Not stored in image
return true;
}
public bool WriteSectorTag(byte[] data, ulong sectorAddress, SectorTagType tag)
{
ErrorMessage = "Writing sectors with tags is not supported.";
return false;
}
public bool WriteSectorsTag(byte[] data, ulong sectorAddress, uint length, SectorTagType tag)
{
ErrorMessage = "Writing sectors with tags is not supported.";
return false;
}
/// <summary>
/// QCOW header, big-endian
/// </summary>