/// <summary>Create instance of disc IO control commands class</summary>
/// <param name="device">Device</param>
internal Disc(DeviceIoControl device)
{
this._device = device;
}
/// <summary>
/// Gets the serial number of the specified physical driver.
/// </summary>
/// <param name="DriveName">Name of the disk drive.</param>
public static unsafe string Example_QueryDiskSerial(string DriveName = "PhysicalDrive0")
{
var SerialNumber = (string)null;
//
// Open the symbolic link created by the disk driver.
//
var DiskDevice = new DeviceIoControl("\\\\.\\" + DriveName);
DiskDevice.Connect();
//
// Prepare a request to send to the disk driver.
//
var Desc = new STORAGE_DESCRIPTOR_HEADER();
var Query = new STORAGE_PROPERTY_QUERY
{
PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProperty,
QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery
};
//
// Call the disk driver's IRP handler.
//
if (DiskDevice.TryIoControl(IOCTL_STORAGE_QUERY_PROPERTY, &Query, Marshal.SizeOf(Query), &Desc, Marshal.SizeOf(Desc)))
{
var Allocation = Marshal.AllocHGlobal(Desc.Size);
if (DiskDevice.TryIoControl(IOCTL_STORAGE_QUERY_PROPERTY, &Query, Marshal.SizeOf(Query), Allocation.ToPointer(), Desc.Size))
{
var DeviceDesc = Marshal.PtrToStructure <STORAGE_DEVICE_DESCRIPTOR>(Allocation);
if (DeviceDesc.SerialNumberOffset != 0)
{
SerialNumber = Marshal.PtrToStringAnsi(IntPtr.Add(Allocation, DeviceDesc.SerialNumberOffset), Desc.Size - DeviceDesc.SerialNumberOffset);
SerialNumber = SerialNumber.Trim('\0');
}
}
else
{
Console.WriteLine("[*] Failed to query for the storage descriptor.");
}
Marshal.FreeHGlobal(Allocation);
}
else
{
Console.WriteLine("[*] Failed to query for the storage descriptor size.");
}
DiskDevice.Close();
Console.WriteLine($"[*] Disk Serial: {SerialNumber}");
return(SerialNumber);
}
/// <summary>
/// Function will query device for unique device number and set it on <see cref="SystemDevice"/> object
/// </summary>
/// <param name="device">The device.</param>
/// <param name="token">The token.</param>
protected void SetDeviceNumber(SystemDevice device, CancellationToken token)
{
STORAGE_DEVICE_NUMBER devNumber;
if (DeviceIoControl <int> .IsAccessible(device) == false)
{
// Device is not ready
return;
}
token.ThrowIfCancellationRequested();
devNumber = base.GetDeviceNumber(device);
token.ThrowIfCancellationRequested();
device.DeviceNumber = devNumber.DeviceNumber;
}
/// <summary>
/// Sets the size of disk the device.
/// </summary>
/// <param name="device">The device to query</param>
/// <param name="token">The cancellation token.</param>
protected void SetDeviceSize(SystemDevice device, CancellationToken token)
{
DISK_GEOMETRY_EX diskGeometry;
if (DeviceIoControl <int> .IsAccessible(device) == false)
{
// Device is not ready
return;
}
token.ThrowIfCancellationRequested();
diskGeometry = base.GetDriveGeometry(device);
token.ThrowIfCancellationRequested();
device.DiskSize = diskGeometry.DiskSize;
device.BytesPerSector = diskGeometry.Geometry.BytesPerSector;
device.SectorsCount = diskGeometry.Geometry.SectorsCount;
}
/// <summary>Create instance of deviceperfomance counters</summary>
/// <param name="device">device</param>
internal Performance(DeviceIoControl device)
{
this._device = device;
}
/// <summary>Create instance of Volume IO control commands</summary>
/// <param name="device">Device</param>
internal Volume(DeviceIoControl device)
{
this._device = device;
}
static void Main(String[] args)
{
try
{
using(DeviceIoControl device = new DeviceIoControl("c:\\"))
{
var info = device.FileSystem.GetStatistics();
Boolean isWritable = device.Disc.IsWritable;
Boolean checkVerify = device.Storage.CheckVerify;
Boolean checkVerify2 = device.Storage.CheckVerify2;
Boolean isOn = device.IsDeviceOn;
Console.WriteLine(String.Format("Device is {0}", isOn ? "on" : "off"));
if(device.Disc.Version.HasValue)
{
String capabilities = "Capabilities: ";
if(device.Disc.Version.Value.CommandAta)
capabilities += "ATA,";
if(device.Disc.Version.Value.CommandAtapi)
capabilities += "ATAPI,";
if(device.Disc.Version.Value.CommandSmart)
capabilities += "SCSI";
Console.WriteLine(capabilities);
}
Console.WriteLine("===PROPERTIES===");
if(device.Storage.Properties.Device.HasValue)
Console.WriteLine(String.Format("Device: {0}", device.Storage.Properties.Device.Value.Size));
if(device.Storage.Properties.Adapter.HasValue)
Console.WriteLine(String.Format("Adapter: {0}", device.Storage.Properties.Adapter.Value.Size));
if(device.Storage.Properties.ID.HasValue)
Console.WriteLine(String.Format("ID: {0:n0}", device.Storage.Properties.ID.Value.Size));
if(device.Storage.Properties.WriteCache.HasValue)
Console.WriteLine(String.Format("WriteCache: {0}", device.Storage.Properties.WriteCache.Value.Size));
if(device.Storage.Properties.Miniport.HasValue)
Console.WriteLine(String.Format("Miniport: {0}", device.Storage.Properties.Miniport.Value.Size));
if(device.Storage.Properties.AccessAlignment.HasValue)
Console.WriteLine(String.Format("AccessAlignment: {0}", device.Storage.Properties.AccessAlignment.Value.Size));
if(device.Storage.Properties.SeekPenalty.HasValue)
Console.WriteLine(String.Format("SeekPenalty: {0}", device.Storage.Properties.SeekPenalty.Value.Size));
if(device.Storage.Properties.Trim.HasValue)
Console.WriteLine(String.Format("Trim: {0}", device.Storage.Properties.Trim.Value.Size));
if(device.Storage.Properties.WriteAggregation.HasValue)
Console.WriteLine(String.Format("WriteAggregation: {0}", device.Storage.Properties.WriteAggregation.Value.Size));
if(device.Storage.Properties.Power.HasValue)
Console.WriteLine(String.Format("Power: {0}", device.Storage.Properties.Power.Value.Size));
if(device.Storage.Properties.CopyOffload.HasValue)
Console.WriteLine(String.Format("CopyOffload: {0}", device.Storage.Properties.CopyOffload.Value.Size));
if(device.Storage.Properties.Resilency.HasValue)
Console.WriteLine(String.Format("Resilency: {0}", device.Storage.Properties.Resilency.Value.Size));
UInt64 totalSize = 0;
foreach(var bitmap in device.FileSystem.GetVolumeBitmap())
totalSize += bitmap.BitmapSize;
if(device.Disc.Smart != null)
{
Console.WriteLine("===INFO===");
//Info
String deviceInfo = String.Format(@"Type: {0}
Serial number: {1}\
Firmware version: {2}
Model number: {3}
Capabilities: 0x{4:X}
User addressable space {5:n0} sectors (LBA mode only)",
device.Disc.Smart.SystemParams.Type,
device.Disc.Smart.SystemParams.SerialNumber,
device.Disc.Smart.SystemParams.FirmwareRev,
device.Disc.Smart.SystemParams.ModelNumber,
device.Disc.Smart.SystemParams.wCapabilities,
device.Disc.Smart.SystemParams.ulTotalAddressableSectors);
Console.WriteLine(deviceInfo);
//Info
//Params
String deviceParams = String.Format(@"Number of cylinders: {0:n0}
Number of heads: {1:n0}
Current number of cylinders: {2:n0}
Current number of heads: {3:n0}
Current Sectors per track: {4:n0}
Current Sector capacity: {5:n0}",
device.Disc.Smart.SystemParams.wNumCyls,
device.Disc.Smart.SystemParams.wNumHeads,
device.Disc.Smart.SystemParams.wNumCurrentCyls,
device.Disc.Smart.SystemParams.wNumCurrentHeads,
device.Disc.Smart.SystemParams.wNumCurrentSectorsPerTrack,
device.Disc.Smart.SystemParams.ulCurrentSectorCapacity);
Console.WriteLine(deviceParams);
//Params
//SMART
StringBuilder smartAttributes = new StringBuilder();
foreach(var attr in device.Disc.Smart)
smartAttributes.AppendFormat(@"{0:X} {1} Value: {2} Worst: {3} Threshold: {4} RawValue: {5:n0}
",
attr.Attribute.bAttrID,
attr.Attribute.AttrName,
attr.Attribute.bAttrValue,
attr.Attribute.bWorstValue,
attr.Threshold.bWarrantyThreshold,
attr.Attribute.RawValue);
Console.WriteLine(smartAttributes);
//SMART
}
/*using(DiscPerformance perf = device.GetDiscPerfomance())
{
WinNT.DISK_PERFORMANCE perf1 = perf.QueryPerfomanceInfo();
System.Threading.Thread.Sleep(1000);
WinNT.DISK_PERFORMANCE perf2 = perf.QueryPerfomanceInfo();
}*/
}
} catch(Win32Exception exc)
{
Console.WriteLine("{0} ({1:X})", exc.Message, exc.NativeErrorCode);
Console.WriteLine("===================================");
Console.WriteLine(exc.StackTrace);
Console.ReadKey();
}
}
/// <summary>
/// Function will calculate/read 'Disk geometry' for provided <see cref="SystemVolume"/>
/// </summary>
/// <param name="device"><see cref="SystemVolume"/> to query</param>
/// <returns>Disk geometry information</returns>
internal virtual DISK_GEOMETRY_EX GetDriveGeometry(DeviceHandle device)
{
DeviceIoControl<DISK_GEOMETRY_EX> deviceControl = new DeviceIoControl<DISK_GEOMETRY_EX>();
return deviceControl.GetDiskGeometryEx(device);
}
/// <summary>
/// Function will all physical disk that 'volume' is extended/spanned on it
/// </summary>
/// <remarks>MSDN: http://msdn.microsoft.com/en-us/library/aa365194(v=vs.85).aspx </remarks>
/// <param name="device"><see cref="SystemVolume"/> to query</param>
/// <returns><see cref="VOLUME_DISK_EXTENTS"/> structure that volume extends on</returns>
internal virtual Nullable<VOLUME_DISK_EXTENTS> GetDiskExtendsForVolume(SystemVolume device)
{
DeviceIoControl<VOLUME_DISK_EXTENTS> deviceControl = new DeviceIoControl<VOLUME_DISK_EXTENTS>();
return deviceControl.GetDataForDevice(device, IoControlCode.IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS);
}
/// <summary>
/// Retrieves the device type, device number, and, for a partitionable device, the partition number of a device.
/// </summary>
/// <param name="device"><see cref="SystemVolume"/> to query</param>
/// <returns><see cref="STORAGE_DEVICE_NUMBER"/> structure</returns>
internal virtual STORAGE_DEVICE_NUMBER GetDeviceNumber(DeviceHandle device)
{
DeviceIoControl<STORAGE_DEVICE_NUMBER> deviceControl = new DeviceIoControl<STORAGE_DEVICE_NUMBER>();
return deviceControl.GetDataForDevice(device, IoControlCode.IOCTL_STORAGE_GET_DEVICE_NUMBER);
}
/// <summary>
/// Function will calculate/read 'Layout information' for provided <see cref="SystemVolume"/>
/// </summary>
/// <param name="device"><see cref="SystemVolume"/> to query</param>
/// <returns>Tuple of <see cref="DRIVE_LAYOUT_INFORMATION_EX"/> and array of <see cref="PARTITION_INFORMATION_EX"/></returns>
/// <remarks>MSDN: http://msdn.microsoft.com/en-us/library/aa365174(v=vs.85).aspx </remarks>
internal virtual Tuple<DRIVE_LAYOUT_INFORMATION_EX, PARTITION_INFORMATION_EX[]> GetDriveLayout(SystemVolume device)
{
DeviceIoControl<DRIVE_LAYOUT_INFORMATION_EX> deviceControl = new DeviceIoControl<DRIVE_LAYOUT_INFORMATION_EX>();
return deviceControl.GetDriveLayout(device);
}
static void Main(String[] args)
{
try
{
using (DeviceIoControl device = new DeviceIoControl("c:\\"))
{
var info = device.FileSystem.GetStatistics();
Boolean isWritable = device.Disc.IsWritable;
Boolean checkVerify = device.Storage.CheckVerify;
Boolean checkVerify2 = device.Storage.CheckVerify2;
Boolean isOn = device.IsDeviceOn;
Console.WriteLine(String.Format("Device is {0}", isOn ? "on" : "off"));
if (device.Disc.Version.HasValue)
{
String capabilities = "Capabilities: ";
if (device.Disc.Version.Value.CommandAta)
{
capabilities += "ATA,";
}
if (device.Disc.Version.Value.CommandAtapi)
{
capabilities += "ATAPI,";
}
if (device.Disc.Version.Value.CommandSmart)
{
capabilities += "SCSI";
}
Console.WriteLine(capabilities);
}
Console.WriteLine("===PROPERTIES===");
if (device.Storage.Properties.Device.HasValue)
{
Console.WriteLine(String.Format("Device: {0}", device.Storage.Properties.Device.Value.Size));
}
if (device.Storage.Properties.Adapter.HasValue)
{
Console.WriteLine(String.Format("Adapter: {0}", device.Storage.Properties.Adapter.Value.Size));
}
if (device.Storage.Properties.ID.HasValue)
{
Console.WriteLine(String.Format("ID: {0:n0}", device.Storage.Properties.ID.Value.Size));
}
if (device.Storage.Properties.WriteCache.HasValue)
{
Console.WriteLine(String.Format("WriteCache: {0}", device.Storage.Properties.WriteCache.Value.Size));
}
if (device.Storage.Properties.Miniport.HasValue)
{
Console.WriteLine(String.Format("Miniport: {0}", device.Storage.Properties.Miniport.Value.Size));
}
if (device.Storage.Properties.AccessAlignment.HasValue)
{
Console.WriteLine(String.Format("AccessAlignment: {0}", device.Storage.Properties.AccessAlignment.Value.Size));
}
if (device.Storage.Properties.SeekPenalty.HasValue)
{
Console.WriteLine(String.Format("SeekPenalty: {0}", device.Storage.Properties.SeekPenalty.Value.Size));
}
if (device.Storage.Properties.Trim.HasValue)
{
Console.WriteLine(String.Format("Trim: {0}", device.Storage.Properties.Trim.Value.Size));
}
if (device.Storage.Properties.WriteAggregation.HasValue)
{
Console.WriteLine(String.Format("WriteAggregation: {0}", device.Storage.Properties.WriteAggregation.Value.Size));
}
if (device.Storage.Properties.Power.HasValue)
{
Console.WriteLine(String.Format("Power: {0}", device.Storage.Properties.Power.Value.Size));
}
if (device.Storage.Properties.CopyOffload.HasValue)
{
Console.WriteLine(String.Format("CopyOffload: {0}", device.Storage.Properties.CopyOffload.Value.Size));
}
if (device.Storage.Properties.Resilency.HasValue)
{
Console.WriteLine(String.Format("Resilency: {0}", device.Storage.Properties.Resilency.Value.Size));
}
UInt64 totalSize = 0;
foreach (var bitmap in device.FileSystem.GetVolumeBitmap())
{
totalSize += bitmap.BitmapSize;
}
if (device.Disc.Smart != null)
{
Console.WriteLine("===INFO===");
//Info
String deviceInfo = String.Format(@"Type: {0}
Serial number: {1}\
Firmware version: {2}
Model number: {3}
Capabilities: 0x{4:X}
User addressable space {5:n0} sectors (LBA mode only)",
device.Disc.Smart.SystemParams.Type,
device.Disc.Smart.SystemParams.SerialNumber,
device.Disc.Smart.SystemParams.FirmwareRev,
device.Disc.Smart.SystemParams.ModelNumber,
device.Disc.Smart.SystemParams.wCapabilities,
device.Disc.Smart.SystemParams.ulTotalAddressableSectors);
Console.WriteLine(deviceInfo);
//Info
//Params
String deviceParams = String.Format(@"Number of cylinders: {0:n0}
Number of heads: {1:n0}
Current number of cylinders: {2:n0}
Current number of heads: {3:n0}
Current Sectors per track: {4:n0}
Current Sector capacity: {5:n0}",
device.Disc.Smart.SystemParams.wNumCyls,
device.Disc.Smart.SystemParams.wNumHeads,
device.Disc.Smart.SystemParams.wNumCurrentCyls,
device.Disc.Smart.SystemParams.wNumCurrentHeads,
device.Disc.Smart.SystemParams.wNumCurrentSectorsPerTrack,
device.Disc.Smart.SystemParams.ulCurrentSectorCapacity);
Console.WriteLine(deviceParams);
//Params
//SMART
StringBuilder smartAttributes = new StringBuilder();
foreach (var attr in device.Disc.Smart)
{
smartAttributes.AppendFormat(@"{0:X} {1} Value: {2} Worst: {3} Threshold: {4} RawValue: {5:n0}
",
attr.Attribute.bAttrID,
attr.Attribute.AttrName,
attr.Attribute.bAttrValue,
attr.Attribute.bWorstValue,
attr.Threshold.bWarrantyThreshold,
attr.Attribute.RawValue);
}
Console.WriteLine(smartAttributes);
//SMART
}
/*using(DiscPerformance perf = device.GetDiscPerfomance())
* {
* WinNT.DISK_PERFORMANCE perf1 = perf.QueryPerfomanceInfo();
* System.Threading.Thread.Sleep(1000);
* WinNT.DISK_PERFORMANCE perf2 = perf.QueryPerfomanceInfo();
* }*/
}
} catch (Win32Exception exc)
{
Console.WriteLine("{0} ({1:X})", exc.Message, exc.NativeErrorCode);
Console.WriteLine("===================================");
Console.WriteLine(exc.StackTrace);
Console.ReadKey();
}
}
/// <summary>Create instance of file system IO commands class</summary>
/// <param name="device">Device</param>
public FileSystem(DeviceIoControl device)
{
this._device = device;
}
/// <summary>Create instance of storage IO commands class</summary>
/// <param name="device">Device</param>
internal Storage(DeviceIoControl device)
{
this._device = device;
}
