public static string GetDiskInformation(Disk disk)
{
StringBuilder builder = new StringBuilder();
if (disk is PhysicalDisk)
{
PhysicalDisk physicalDisk = (PhysicalDisk)disk;
builder.AppendLine(physicalDisk.Description);
}
builder.AppendFormat("Size: {0} bytes\n", disk.Size.ToString("###,###,###,###,##0"));
builder.AppendFormat("Bytes per sector (logical): {0}\n", disk.BytesPerSector);
if (disk is PhysicalDisk)
{
PhysicalDisk physicalDisk = (PhysicalDisk)disk;
builder.AppendFormat("Geometry: Cylinders: {0}, Heads: {1}, Sectors Per Track: {2}\n", physicalDisk.Cylinders, physicalDisk.TracksPerCylinder, physicalDisk.SectorsPerTrack);
}
else if (disk is DiskImage)
{
DiskImage diskImage = (DiskImage)disk;
builder.AppendFormat("Disk image path: {0}\n", diskImage.Path);
}
builder.AppendLine();
MasterBootRecord mbr = MasterBootRecord.ReadFromDisk(disk);
if (mbr != null)
{
builder.AppendFormat("Partitioning scheme: {0}\n", (mbr.IsGPTBasedDisk ? "GPT" : "MBR"));
}
DynamicDisk dynamicDisk = DynamicDisk.ReadFromDisk(disk);
builder.AppendFormat("Disk type: {0}\n", ((dynamicDisk != null) ? "Dynamic Disk" : "Basic Disk"));
if (dynamicDisk != null)
{
VolumeManagerDatabase database = VolumeManagerDatabase.ReadFromDisk(dynamicDisk);
if (database != null)
{
DiskRecord diskRecord = database.FindDiskByDiskGuid(dynamicDisk.PrivateHeader.DiskGuid);
if (diskRecord != null)
{
builder.AppendLine("Disk ID: " + diskRecord.DiskId);
}
}
builder.AppendLine("Disk GUID: " + dynamicDisk.PrivateHeader.DiskGuid);
builder.AppendLine("Disk Group GUID: " + dynamicDisk.PrivateHeader.DiskGroupGuidString);
builder.AppendLine();
builder.AppendLine("Public region start sector: " + dynamicDisk.PrivateHeader.PublicRegionStartLBA);
builder.AppendLine("Public region size (sectors): " + dynamicDisk.PrivateHeader.PublicRegionSizeLBA);
builder.AppendLine();
builder.AppendLine("Private region start sector: " + dynamicDisk.PrivateHeader.PrivateRegionStartLBA);
builder.AppendLine("Private region size (sectors): " + dynamicDisk.PrivateHeader.PrivateRegionSizeLBA);
}
return(builder.ToString());
}
protected DrivePort GetDrivePort(PhysicalDisk pd)
{
return(new DrivePort
{
ports =
{
(int)pd.EnclosureNumber,
(int)pd.SlotNumber
}
});
}
static PhysicalDisk GetPhysicalDisk(uint index)
{
PhysicalDisk disk = PhysicalDisk.GetDisks().First(d => d.Index == index);
if (disk == null)
{
throw new InvalidOperationException(String.Format("Can't find physical disk index {0}", index));
}
return(disk);
}
void Disk_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
((CheckBox)sender).Checked = true;
PhysicalDisk selectedDisk = (PhysicalDisk)((CheckBox)sender).Tag;
UncheckUnselectedDisks(selectedDisk);
ApplyExtentSelection(null);
if (DiskRightClick != null)
{
Point checkBoxLocation = ((CheckBox)sender).Location;
Point location = new Point(checkBoxLocation.X + e.X, checkBoxLocation.Y + e.Y);
DiskRightClick(this, new DiskRightClickEventArgs(selectedDisk, location));
}
}
}
public StorApiStatus GetSpacesDrive(string serial, ref SpacesDrive drive)
{
StorApiStatus result = StorApiStatusEnum.STOR_NO_ERROR;
PhysicalDisk physicalDisk = null;
SpacesApiError physicalDisk2 = SpacesApi.SpacesApi.GetPhysicalDisk(serial, ref physicalDisk);
if (physicalDisk2 != SpacesApiError.Success)
{
return(SpacesUtil.ToStorApiStatus(physicalDisk2));
}
if (physicalDisk != null)
{
drive = this.MakeDrive(physicalDisk);
}
return(result);
}
private void OpenDisk(string device)
{
CreateNewDriveView(device);
SafeFileHandle handle = WinApi.CreateFile(device,
FileAccess.Read,
FileShare.None,
IntPtr.Zero,
FileMode.Open,
0,
IntPtr.Zero);
long length = WinApi.GetDiskCapactity(handle);
long sectorLength = WinApi.GetSectorSize(handle);
PhysicalDisk drive = new PhysicalDisk(handle, length, sectorLength);
driveView.AddDrive(device, drive);
EnableDatabaseOptions();
}
public async Task CreateVolume(PhysicalDisk physicalDisk)
{
if (physicalDisk.NoVolumes || (!physicalDisk.Volumes.Any(v => v.IsMounted) && !physicalDisk.Volumes.All(v => v.IsClean)))
{
try
{
logger.LogInformation($"Creating primary volume on {physicalDisk}");
await CreatePrimaryVolume(physicalDisk);
logger.LogInformation($"Succeffully created primary volume on {physicalDisk}");
}
catch (Exception e)
{
logger.LogError($"Failed to create primary volume: {e.Message}");
}
}
else
{
logger.LogInformation($"{physicalDisk} contains mounted volume");
}
}
/// <summary>
/// Set up the performance monitor objects (CPU, Disk I/O, ...).
/// </summary>
private void InitializePerformanceMonitors()
{
try {
_cpu = new Cpu {
Interval = 250,
Limit = _config.MaxCpuUsage,
Probation = 16,
LogPerformanceReadings = _config.MonitoringLogLevel,
Enabled = true
};
_cpu.LoadAboveLimit += OnLoadAboveLimit;
_cpu.LoadBelowLimit += OnLoadBelowLimit;
}
catch (UnauthorizedAccessException ex) {
Log.Error("Not enough permissions to monitor the CPU load.\nMake sure the " +
"service account is a member of the [Performance Monitor Users] " +
"system group.\nError message was: {0}", ex.Message);
throw;
}
catch (Exception ex) {
Log.Error("Unexpected error initializing CPU monitoring: {0}", ex.Message);
throw;
}
try {
_phyDisk = new PhysicalDisk {
Interval = 250,
Limit = (float)_config.MaxDiskQueue / 1000,
Probation = 16,
LogPerformanceReadings = _config.MonitoringLogLevel,
Enabled = true
};
_phyDisk.LoadAboveLimit += OnLoadAboveLimit;
_phyDisk.LoadBelowLimit += OnLoadBelowLimit;
}
catch (Exception ex) {
Log.Error("Unexpected error initializing PhysicalDisk monitoring: {0}", ex.Message);
throw;
}
}
public SpacesDrive MakeDrive(PhysicalDisk pd)
{
SpacesDrive spacesDrive = new SpacesDrive(pd.ObjectId, this);
spacesDrive.Port = this.GetDrivePort(pd);
spacesDrive.Model = pd.Model;
spacesDrive.Serial = pd.SerialNumber;
spacesDrive.Revision = pd.FirmwareVersion;
spacesDrive.SectorSize = pd.LogicalSectorSize;
spacesDrive.SectorCount = 0UL;
if (pd.LogicalSectorSize != 0UL)
{
spacesDrive.SectorCount = pd.Size / pd.LogicalSectorSize;
}
spacesDrive.IsSmartEnabled = false;
spacesDrive.IsSystem = SpacesApi.SpacesApi.IsPhysicalDiskSystem(pd);
spacesDrive.Status = SpacesUtil.ToStorApiDriveStatus(pd);
spacesDrive.Temperature = 0;
spacesDrive.Health = pd.HealthStatus;
spacesDrive.OperationalStatuses = pd.OperationalStatus;
return(spacesDrive);
}
public static PhysicalDisk[] GetPhysicalDisks()
{
using (var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive"))
{
var objects = searcher.Get().Cast <ManagementObject>();
var disks = new List <PhysicalDisk>();
foreach (ManagementObject obj in objects)
{
var disk = new PhysicalDisk();
disk.Index = (uint)obj["Index"];
disk.Name = (string)obj["Name"];
disk.Model = (string)obj["Model"];
disk.Vendor = (string)obj["Caption"];
disk.Size = (ulong)obj["Size"];
disk.IsSSD = false; // The code to figure this is really frickin complex, so punting for now
disks.Add(disk);
}
return(disks.ToArray());
}
}
static SafeFileHandle CreateVHD(string path, PhysicalDisk disk)
{
VirtualStorageType vhd_type = new VirtualStorageType();
vhd_type.DeviceId = StorageDeviceType.Vhdx;
vhd_type.VendorId = VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT;
CreateVirtualDiskParameters ps = new CreateVirtualDiskParameters();
ps.Version = CreateVirtualDiskVersion.Version1;
ps.SectorSizeInBytes = disk.SectorSizeInBytes;
ps.MaximumSize = disk.SizeInBytes + (100 * 1024 * 1024);
ps.SourcePath = disk.Name;
IntPtr hDisk;
int error = CreateVirtualDisk(ref vhd_type, path, VirtualDiskAccessMask.All, null, CreateVirtualDiskFlag.None, 0, ref ps, IntPtr.Zero, out hDisk);
if (error != 0)
{
throw new Win32Exception(error);
}
return(new SafeFileHandle(hDisk, true));
}
private void comboSourceDisk_SelectedIndexChanged(object sender, EventArgs e)
{
int physicalDiskIndex = ((KeyValuePair <int, string>)comboSourceDisk.SelectedItem).Key;
if (physicalDiskIndex == -1) // VHD
{
DialogResult openFileResult = openVirtualDiskFileDialog.ShowDialog();
if (openFileResult != DialogResult.OK)
{
comboSourceDisk.SelectedIndex = 0;
}
else
{
lblSourceDiskSerialNumber.Text = openVirtualDiskFileDialog.FileName;
}
}
else
{
PhysicalDisk disk = null;
try
{
disk = new PhysicalDisk(physicalDiskIndex);
}
catch (DriveNotFoundException)
{
}
if (disk != null)
{
lblSourceDiskSerialNumber.Text = "S/N: " + disk.SerialNumber;
}
else
{
lblSourceDiskSerialNumber.Text = "Error: Disk not found";
}
}
}
public static DynamicDisk FindDisk(Guid diskGuid)
{
List <int> diskIndexList = PhysicalDiskControl.GetPhysicalDiskIndexList();
foreach (int diskIndex in diskIndexList)
{
PhysicalDisk disk;
try
{
disk = new PhysicalDisk(diskIndex); // will throw an exception if disk is not valid
}
catch (DriveNotFoundException)
{
// The disk must have been removed from the system
continue;
}
catch (DeviceNotReadyException)
{
continue;
}
catch (SharingViolationException) // skip this disk, it's probably being used
{
continue;
}
DynamicDisk dynamicDisk = DynamicDisk.ReadFromDisk(disk);
if (dynamicDisk != null)
{
if (dynamicDisk.DiskGuid == diskGuid)
{
return(dynamicDisk);
}
}
}
return(null);
}
private void btnStart_Click(object sender, EventArgs e)
{
if (m_isBusy)
{
btnStart.Enabled = false;
btnStart.Text = "Stopping";
groupOptions.Enabled = false;
Thread thread = new Thread(delegate()
{
m_diskCopier.Abort = true;
while (m_isBusy)
{
Thread.Sleep(100);
}
if (!m_isClosing)
{
this.Invoke((MethodInvoker) delegate
{
EnableUI();
btnStart.Enabled = true;
});
}
});
thread.Start();
}
else
{
if (comboSourceDisk.SelectedItem == null)
{
return;
}
int sourceDiskIndex = ((KeyValuePair <int, string>)comboSourceDisk.SelectedItem).Key;
int targetDiskIndex = ((KeyValuePair <int, string>)comboTargetDisk.SelectedItem).Key;
Disk sourceDisk = null;
Disk targetDisk = null;
if (sourceDiskIndex == -1)
{
string path = openVirtualDiskFileDialog.FileName;
try
{
sourceDisk = new VirtualHardDisk(path, true);
}
catch (IOException ex)
{
MessageBox.Show("Failed to open the virtual disk: " + ex.Message, "Error");
return;
}
}
else
{
try
{
sourceDisk = new PhysicalDisk(sourceDiskIndex);
}
catch (DriveNotFoundException)
{
MessageBox.Show("Source disk not found", "Error");
return;
}
}
if (targetDiskIndex == -1)
{
string path = saveVirtualDiskFileDialog.FileName;;
try
{
if (chkWriteZeros.Checked)
{
targetDisk = VirtualHardDisk.CreateFixedDisk(path, sourceDisk.Size);
}
else
{
targetDisk = VirtualHardDisk.CreateDynamicDisk(path, sourceDisk.Size);
}
}
catch (IOException ex)
{
MessageBox.Show("Failed to create the virtual disk: " + ex.Message, "Error");
return;
}
}
else
{
try
{
targetDisk = new PhysicalDisk(targetDiskIndex);
}
catch (DriveNotFoundException)
{
MessageBox.Show("Target disk not found", "Error");
return;
}
}
DisableUI();
Thread thread = new Thread(delegate()
{
m_isBusy = true;
CopyDisk(sourceDisk, targetDisk);
m_isBusy = false;
if (m_isClosing)
{
this.Invoke((MethodInvoker) delegate
{
this.Close();
});
}
else
{
this.Invoke((MethodInvoker) delegate
{
EnableUI();
});
}
});
thread.Start();
}
}
private void btnOK_Click(object sender, EventArgs e)
{
PhysicalDisk selectedDisk;
if (listPhysicalDisks.SelectedItems.Count > 0)
{
selectedDisk = (PhysicalDisk)listPhysicalDisks.SelectedItems[0].Tag;
}
else
{
MessageBox.Show("No disk was selected", "Error");
return;
}
if (!chkReadOnly.Checked)
{
if (Environment.OSVersion.Version.Major >= 6)
{
bool isDiskReadOnly;
bool isOnline = selectedDisk.GetOnlineStatus(out isDiskReadOnly);
if (isDiskReadOnly)
{
MessageBox.Show("The selected disk is set to readonly", "Error");
return;
}
if (isOnline)
{
DialogResult result = MessageBox.Show("The selected disk will now be taken offline. OK?", String.Empty, MessageBoxButtons.OKCancel);
if (result == DialogResult.OK)
{
bool success = selectedDisk.SetOnlineStatus(false);
if (!success)
{
MessageBox.Show("Was not able to take the disk offline", "Error");
return;
}
}
else
{
return;
}
}
}
else
{
if (DynamicDisk.IsDynamicDisk(selectedDisk))
{
// The user will probably want to stop the Logical Disk Manager services (vds, dmadmin, dmserver)
// and lock all dynamic disks and dynamic volumes before whatever he's doing.
// Modifications the the LDM database should be applied to all dynamic disks.
DialogResult result = MessageBox.Show("The dynamic disk database will likely be corrupted, Continue?", "Warning", MessageBoxButtons.YesNo);
if (result != DialogResult.Yes)
{
return;
}
}
else
{
// Locking a disk does not prevent Windows from accessing mounted volumes on it. (it does prevent creation of new volumes).
// For basic disks we need to lock the Disk and Volumes, and we should also call UpdateDiskProperties() after releasing the lock.
LockStatus status = LockHelper.LockBasicDiskAndVolumesOrNone(selectedDisk);
if (status == LockStatus.CannotLockDisk)
{
MessageBox.Show("Unable to lock the disk", "Error");
return;
}
else if (status == LockStatus.CannotLockVolume)
{
MessageBox.Show("Unable to lock one of the volumes on the disk", "Error");
return;
}
}
}
}
if (chkReadOnly.Checked)
{
selectedDisk = new PhysicalDisk(selectedDisk.PhysicalDiskIndex, true);
}
m_selectedDisk = selectedDisk;
this.DialogResult = DialogResult.OK;
this.Close();
}
static SafeFileHandle CreateVHD(string path, PhysicalDisk disk)
{
VirtualStorageType vhd_type = new VirtualStorageType();
vhd_type.DeviceId = StorageDeviceType.Vhdx;
vhd_type.VendorId = VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT;
CreateVirtualDiskParameters ps = new CreateVirtualDiskParameters();
ps.Version = CreateVirtualDiskVersion.Version1;
ps.SectorSizeInBytes = disk.SectorSizeInBytes;
ps.MaximumSize = disk.SizeInBytes + (100 * 1024 * 1024);
ps.SourcePath = disk.Name;
IntPtr hDisk;
int error = CreateVirtualDisk(ref vhd_type, path, VirtualDiskAccessMask.All, null, CreateVirtualDiskFlag.None, 0, ref ps, IntPtr.Zero, out hDisk);
if (error != 0)
{
throw new Win32Exception(error);
}
return new SafeFileHandle(hDisk, true);
}
public static void DetailCommand(string[] args)
{
if (args.Length == 2)
{
switch (args[1].ToLower())
{
case "disk":
{
Console.WriteLine();
if (m_selectedDisk != null)
{
Console.WriteLine("Size: {0} bytes", m_selectedDisk.Size.ToString("###,###,###,###,##0"));
if (m_selectedDisk is PhysicalDisk)
{
PhysicalDisk disk = (PhysicalDisk)m_selectedDisk;
Console.WriteLine("Geometry: Heads: {0}, Cylinders: {1}, Sectors Per Track: {2}", disk.TracksPerCylinder, disk.Cylinders, disk.SectorsPerTrack);
Console.WriteLine();
}
else if (m_selectedDisk is DiskImage)
{
DiskImage disk = (DiskImage)m_selectedDisk;
Console.WriteLine("Disk image path: {0}", disk.Path);
Console.WriteLine();
}
MasterBootRecord mbr = MasterBootRecord.ReadFromDisk(m_selectedDisk);
if (mbr != null)
{
Console.WriteLine("Partitioning scheme: " + (mbr.IsGPTBasedDisk ? "GPT" : "MBR"));
}
DynamicDisk dynamicDisk = DynamicDisk.ReadFromDisk(m_selectedDisk);
Console.WriteLine("Disk type: " + ((dynamicDisk != null) ? "Dynamic Disk" : "Basic Disk"));
}
else
{
Console.WriteLine("No disk has been selected.");
}
break;
}
case "volume":
case "partition":
{
Console.WriteLine();
if (m_selectedVolume != null)
{
Console.WriteLine("Volume size: {0} bytes", m_selectedVolume.Size.ToString("###,###,###,###,##0"));
if (m_selectedVolume is GPTPartition)
{
Console.WriteLine("Partition name: {0}", ((GPTPartition)m_selectedVolume).PartitionName);
}
Guid?windowsVolumeGuid = WindowsVolumeHelper.GetWindowsVolumeGuid(m_selectedVolume);
if (windowsVolumeGuid.HasValue)
{
List <string> mountPoints = WindowsVolumeManager.GetMountPoints(windowsVolumeGuid.Value);
foreach (string volumePath in mountPoints)
{
Console.WriteLine("Volume path: {0}", volumePath);
}
bool isMounted = WindowsVolumeManager.IsMounted(windowsVolumeGuid.Value);
Console.WriteLine("Mounted: {0}", isMounted);
}
}
else
{
Console.WriteLine("No volume has been selected.");
}
break;
}
default:
Console.WriteLine("Invalid argument.");
HelpDetail();
break;
}
}
else if (args.Length > 2)
{
Console.WriteLine("Too many arguments.");
HelpDetail();
}
else
{
HelpDetail();
}
}
public static void AttachCommand(string[] args)
{
if (m_server != null)
{
Console.WriteLine("Server is already running");
return;
}
if (args.Length >= 2)
{
KeyValuePairList <string, string> parameters = ParseParameters(args, 2);
if (!VerifyParameters(parameters, "vdisk", "disk", "volume", "readonly", "target"))
{
Console.WriteLine();
Console.WriteLine("Invalid parameter");
HelpAttach();
return;
}
switch (args[1].ToLower())
{
case "vdisk":
{
if (m_selectedDisk == null)
{
Console.WriteLine("No disk has been selected");
break;
}
if (!(m_selectedDisk is DiskImage))
{
Console.WriteLine("Selected disk is not a disk image");
break;
}
DiskImage disk = (DiskImage)m_selectedDisk;
string defaultStorageTargetName = Path.GetFileNameWithoutExtension(disk.Path);
string defaultTargetName = DefaultTargetIQN + ":" + defaultStorageTargetName.Replace(" ", ""); // spaces are not allowed
AttachISCSIDisk(disk, defaultTargetName, parameters);
break;
}
case "disk":
{
if (m_selectedDisk == null)
{
Console.WriteLine("Error: No disk has been selected.");
break;
}
if (!(m_selectedDisk is PhysicalDisk))
{
Console.WriteLine("Error: The selected disk is not a physical disk.");
break;
}
bool isAttachmentReadOnly = parameters.ContainsKey("readonly");
PhysicalDisk disk = (PhysicalDisk)m_selectedDisk;
if (!isAttachmentReadOnly)
{
if (Environment.OSVersion.Version.Major >= 6)
{
bool isDiskReadOnly;
bool isOnline = disk.GetOnlineStatus(out isDiskReadOnly);
if (isOnline)
{
Console.WriteLine();
Console.WriteLine("Error: The selected disk must be taken offline.");
break;
}
if (!isAttachmentReadOnly && isDiskReadOnly)
{
Console.WriteLine();
Console.WriteLine("Error: The selected disk is set to readonly!");
break;
}
}
else
{
Console.WriteLine();
// Locking mechanism is not implemented
Console.Write("Warning: if a volume on this disk is mounted locally, data corruption may occur!");
}
}
string defaultStorageTargetName = string.Format("disk{0}", disk.PhysicalDiskIndex);
string defaultTargetName = DefaultTargetIQN + ":" + defaultStorageTargetName;
AttachISCSIDisk(disk, defaultTargetName, parameters);
break;
}
case "volume":
{
if (m_selectedVolume == null)
{
Console.WriteLine("No volume has been selected.");
break;
}
VolumeDisk virtualDisk = new VolumeDisk(m_selectedVolume);
string defaultTargetName = DefaultTargetIQN + ":Volume";
bool isAttachmentReadOnly = parameters.ContainsKey("readonly");
if (!isAttachmentReadOnly)
{
if (Environment.OSVersion.Version.Major >= 6)
{
if (m_selectedVolume is DynamicVolume)
{
foreach (DiskExtent extent in ((DynamicVolume)m_selectedVolume).Extents)
{
if (extent.Disk is PhysicalDisk)
{
bool isDiskReadOnly;
bool isOnline = ((PhysicalDisk)extent.Disk).GetOnlineStatus(out isDiskReadOnly);
if (isOnline)
{
Console.WriteLine("Error: All disks containing the volume must be taken offline.");
return;
}
if (isDiskReadOnly)
{
Console.WriteLine("Error: A disk containing the volume is set to readonly.");
return;
}
}
}
}
else if (m_selectedVolume is Partition)
{
Disk disk = ((Partition)m_selectedVolume).Disk;
if (disk is PhysicalDisk)
{
bool isDiskReadOnly;
bool isOnline = ((PhysicalDisk)disk).GetOnlineStatus(out isDiskReadOnly);
if (isOnline)
{
Console.WriteLine("Error: The disk containing the volume must be taken offline.");
return;
}
if (isDiskReadOnly)
{
Console.WriteLine("Error: The disk containing the volume is set to readonly.");
return;
}
}
}
}
else
{
Console.WriteLine();
// Locking mechanism is not implemented
Console.WriteLine("Warning: if this volume is mounted locally, data corruption may occur!");
}
}
AttachISCSIDisk(virtualDisk, defaultTargetName, parameters);
break;
}
default:
{
Console.WriteLine();
Console.WriteLine("Invalid argument.");
HelpAttach();
break;
}
}
}
else
{
HelpAttach();
}
}
protected override Int32 Execute()
{
try
{
if (1 == _commandLineParser.FileNames.Length)
{
var deviceName = _commandLineParser.FileNames[0];
if (deviceName.EndsWith(":"))
{
PrintLogicalDiskInformation(deviceName);
}
else
{
PrintPhysicalDiskInformation(deviceName);
}
}
else if (_commandLineParser.IsOptionSet("p"))
{
if (_commandLineParser.OptionHasValue("p"))
{
var deviceName = _commandLineParser.GetOptionString("p");
if (deviceName.Equals("all", StringComparison.InvariantCultureIgnoreCase))
{
foreach (var deviceName1 in PhysicalDisk.GetDeviceNames())
{
PrintPhysicalDiskInformation(deviceName1);
}
}
else
{
UInt32 diskNumber;
if (UInt32.TryParse(deviceName, out diskNumber))
{
deviceName = PhysicalDisk.FormatDeviceName(diskNumber);
}
PrintPhysicalDiskInformation(deviceName);
}
}
else
{
PrintArray(PhysicalDisk.GetDeviceNames());
}
}
else if (_commandLineParser.IsOptionSet("l"))
{
if (_commandLineParser.OptionHasValue("l"))
{
var deviceName = _commandLineParser.GetOptionString("l");
if (deviceName.Equals("all", StringComparison.InvariantCultureIgnoreCase))
{
foreach (var deviceName1 in LogicalDisk.GetDeviceNames())
{
PrintLogicalDiskInformation(deviceName1);
}
}
else
{
if (1 == deviceName.Length)
{
var volume = Char.ToUpper(deviceName[0]);
if ((volume >= 'A') && (volume <= 'Z'))
{
deviceName = LogicalDisk.FormatDeviceName(volume);
}
}
PrintLogicalDiskInformation(deviceName);
}
}
else
{
PrintArray(LogicalDisk.GetDeviceNames());
}
}
else
{
Help();
}
return(0);
}
catch (Exception ex)
{
Print("Error reading disk information: {0}", ex.Message);
return(1);
}
}
private void PrintPhysicalDiskInformation(String deviceName)
{
using (var physicalDisk = new PhysicalDisk(deviceName, true))
{
Console.WriteLine("Physical disk {0}", physicalDisk.DeviceName);
physicalDisk.ReadDiskInformation();
Console.WriteLine("\nDISK_GEOMETRY:");
Console.WriteLine("Cylinders:\t\t{0:N0}", physicalDisk.DiskGeometry.Cylinders);
Console.WriteLine("MediaType:\t\t0x{0:X2} ({1})", physicalDisk.DiskGeometry.MediaType, PhysicalDisk.GetMediaTypeString(physicalDisk.DiskGeometry.MediaType));
Console.WriteLine("TracksPerCylinder:\t{0:N0}", physicalDisk.DiskGeometry.TracksPerCylinder);
Console.WriteLine("SectorsPerTrack:\t{0:N0}", physicalDisk.DiskGeometry.SectorsPerTrack);
Console.WriteLine("BytesPerSector:\t\t{0:N0}", physicalDisk.DiskGeometry.BytesPerSector);
var diskSize = physicalDisk.DiskGeometry.Cylinders * physicalDisk.DiskGeometry.TracksPerCylinder * physicalDisk.DiskGeometry.SectorsPerTrack * physicalDisk.DiskGeometry.BytesPerSector;
Console.WriteLine("\nDisk size:\t\t{0:N0} bytes", diskSize);
Console.WriteLine("\nDRIVE_LAYOUT_INFORMATION:");
Console.WriteLine("PartitionCount:\t{0}", physicalDisk.DriveLayoutInformation.PartitionCount);
Console.WriteLine("Signature:\t0x{0:X8}", physicalDisk.DriveLayoutInformation.Signature);
for (var i = 0; i < physicalDisk.PartitionInformation.Length; i++)
{
PrintPartitionInformation(physicalDisk.PartitionInformation[i]);
}
}
}
public static void SelectCommand(string[] args)
{
if (args.Length == 1)
{
HelpSelect();
return;
}
switch (args[1].ToLower())
{
case "disk":
{
if (args.Length == 3)
{
int diskIndex = Conversion.ToInt32(args[2], -1);
if (diskIndex >= 0)
{
PhysicalDisk disk = null;
try
{
disk = new PhysicalDisk(diskIndex);
}
catch
{
Console.WriteLine();
Console.WriteLine("Error: Invalid disk number");
}
if (disk != null)
{
m_selectedDisk = disk;
}
}
}
else
{
Console.WriteLine();
Console.WriteLine("Error: Invalid number of arguments");
}
break;
}
case "vdisk":
{
if (args.Length == 3)
{
KeyValuePairList <string, string> parameters = ParseParameters(args, 2);
if (parameters.ContainsKey("file"))
{
string path = parameters.ValueOf("file");
if (new FileInfo(path).Exists)
{
try
{
m_selectedDisk = DiskImage.GetDiskImage(path);
}
catch (InvalidDataException)
{
Console.WriteLine("Invalid virtual disk format");
}
catch (NotImplementedException)
{
Console.WriteLine("Unsupported virtual disk format");
}
catch (IOException ex)
{
Console.WriteLine("Cannot read file: " + ex.Message);
}
}
else
{
Console.WriteLine("File not found: \"{0}\"", path);
}
}
else
{
Console.WriteLine();
Console.WriteLine("Error: Invalid argument");
}
}
else
{
Console.WriteLine("Error: Invalid number of arguments");
}
break;
}
case "partition":
{
if (m_selectedDisk != null)
{
if (args.Length == 3)
{
int partitionIndex = Conversion.ToInt32(args[2], -1);
List <Partition> partitions = BasicDiskHelper.GetPartitions(m_selectedDisk);
if (partitionIndex >= 0 && partitionIndex < partitions.Count)
{
m_selectedVolume = partitions[partitionIndex];
}
else
{
Console.WriteLine("Error: Invalid partition number");
}
}
else
{
Console.WriteLine();
Console.WriteLine("Error: Partition number was not specified");
}
}
else
{
Console.WriteLine("No disk has been selected");
}
break;
}
case "volume":
{
if (args.Length == 3)
{
List <Volume> volumes;
try
{
volumes = WindowsVolumeHelper.GetVolumes();
}
catch
{
volumes = new List <Volume>();
}
int volumeIndex = Conversion.ToInt32(args[2], -1);
if (volumeIndex >= 0 && volumeIndex < volumes.Count)
{
m_selectedVolume = volumes[volumeIndex];
}
else
{
Console.WriteLine();
Console.WriteLine("Error: Invalid volume number");
}
}
else
{
Console.WriteLine();
Console.WriteLine("Error: Volume number was not specified");
}
break;
}
default:
HelpSelect();
break;
}
}
/// <summary>
/// class constructor
/// </summary>
public PhysicalDisks()
{
try
{
ManagementObjectSearcher _HDDS = new ManagementObjectSearcher("select * from Win32_DiskDrive");
if (_HDDS.Get().Count == -1)
{
throw new Exception("Could not get HDD(s) information.");
}
// Iterate over Physical Disks
foreach (ManagementObject _Hdd in _HDDS.Get())
{
PhysicalDisk Hdd_Info = new PhysicalDisk();
// Iterate over physical disk info
foreach (PropertyData PC in _Hdd.Properties)
{
if (PC.Value != null)
{
if (PC.Name == "InterfaceType")
{
Hdd_Info.Disk_Interface_Type = (string)_Hdd[PC.Name];
}
if (PC.Name == "MediaType")
{
Hdd_Info.Disk_Media_Type = (string)_Hdd[PC.Name];
}
if (PC.Name == "Name")
{
Hdd_Info.Disk_Name = (string)_Hdd[PC.Name];
}
if (PC.Name == "Partitions")
{
Hdd_Info.Disk_Partition_Count = (uint)_Hdd[PC.Name];
}
if (PC.Name == "SerialNumber")
{
Hdd_Info.Disk_Serial_Number = (string)_Hdd[PC.Name];
}
if (PC.Name == "Size")
{
Hdd_Info.Disk_Size = Convert.ToUInt64(_Hdd[PC.Name]);
}
if (PC.Name == "Index")
{
Hdd_Info.Disk_Index = Convert.ToUInt32(_Hdd[PC.Name]);
}
}
}
// get physical disk partition information
ManagementObjectSearcher partition_info;
if (new ManagementObjectSearcher("select * from Win32_DiskPartition where DiskIndex="
+ Hdd_Info.Disk_Index.ToString()).Get().Count != 0)
{
partition_info = new ManagementObjectSearcher("select * from Win32_DiskPartition where DiskIndex=" + Hdd_Info.Disk_Index.ToString());
// Iterate over Physical disk partitions
foreach (ManagementObject ObjPartition in partition_info.Get())
{
PhysicalDisk.Partition hdd_partition_info = new PhysicalDisk.Partition();
// Iterate over Physical disk partition information
foreach (PropertyData PC in ObjPartition.Properties)
{
if (PC.Value != null)
{
if (PC.Name == "Name")
{
hdd_partition_info.Partition_Name = (string)ObjPartition[PC.Name];
}
if (PC.Name == "BootPartition")
{
hdd_partition_info.Is_Boot_Partition = (bool)ObjPartition[PC.Name];
}
if (PC.Name == "PrimaryPartition")
{
hdd_partition_info.Is_Primary_Partition = (bool)ObjPartition[PC.Name];
}
if (PC.Name == "Size")
{
hdd_partition_info.Partition_Size = Convert.ToUInt64(ObjPartition[PC.Name]);
}
if (PC.Name == "Type")
{
hdd_partition_info.Partition_Type = (string)ObjPartition[PC.Name];
}
}
}
// Add Partition information to the list
Hdd_Info.Disk_Partitions.Add(hdd_partition_info);
}
}
// Add Physyical disk to the Physical Disks list
Physical_Disks.Add(Hdd_Info); // add current Disk Drive information to the list
}
}
catch (Exception ex)
{
throw ex;
}
}
private static void Main(string[] args)
{
var loglevel = LogLevel.Debug;
if (args.Length > 0 && args[0] == "trace")
{
loglevel = LogLevel.Trace;
}
var logConfig = new LoggingConfiguration();
var logTargetConsole = new ConsoleTarget {
Name = "console",
Header = "AutoTx Diagnostics",
Layout = @"${time} [${level}] ${message}",
};
logConfig.AddTarget(logTargetConsole);
var logRuleConsole = new LoggingRule("*", loglevel, logTargetConsole);
logConfig.LoggingRules.Add(logRuleConsole);
LogManager.Configuration = logConfig;
// set the default performance monitors:
var perfMonitors = new[] { "CPU", "PhysicalDisk" };
// if requested explicitly as a command line parameter, override them:
if (args.Length > 1)
{
perfMonitors = args[1].Split(',');
}
var commonAssembly = Assembly.GetAssembly(typeof(Cpu));
var commonVersionInfo = FileVersionInfo.GetVersionInfo(commonAssembly.Location);
Log.Info("ATxCommon library version: {0}", commonVersionInfo.ProductVersion);
Log.Debug("Free space on drive [C:]: " + Conv.BytesToString(SystemChecks.GetFreeDriveSpace("C:")));
if (perfMonitors.Contains("CPU"))
{
Log.Info("Watching CPU load using ATxCommon.Monitoring...");
var cpu = new Cpu {
Interval = 250,
Limit = 50,
Probation = 4, // 4 * 250 ms = 1 second
LogPerformanceReadings = LogLevel.Info,
Enabled = true
};
}
if (perfMonitors.Contains("PhysicalDisk"))
{
Log.Info("Watching I/O load using ATxCommon.Monitoring...");
var disk = new PhysicalDisk {
Interval = 250,
Limit = 0.25F,
Probation = 4, // 4 * 250 ms = 1 second
LogPerformanceReadings = LogLevel.Info,
Enabled = true
};
}
while (true)
{
System.Threading.Thread.Sleep(10000);
}
}
private PhysicalDisk method_4(string string_1)
{
PhysicalDisk disk = new PhysicalDisk {
Extents = new VOLUMEDISKEXTENTS(),
Adapter = new STORAGE_ADAPTER_DESCRIPTOR(),
DeviceID = new STORAGE_DEVICE_ID_DESCRIPTOR(),
Device = new STORAGE_DEVICE_DESCRIPTOR(),
Version = new GETVERSIONOUTPARAMS(),
Params = new SENDCMDOUTPARAMS(),
SerialNumber = string.Empty,
Firmware = string.Empty,
Model = string.Empty
};
char[] trimChars = new char[] { '\\' };
SafeFileHandle handle = Class1.CreateFileW(Class3.smethod_10(0) + Path.GetPathRoot(string_1).TrimEnd(trimChars), 0xc0000000, 3, IntPtr.Zero, 3, 0x80, IntPtr.Zero);
try
{
uint num = 0;
int cb = Marshal.SizeOf(disk.Extents);
IntPtr ptr = Marshal.AllocHGlobal(cb);
Struct0 struct2 = new Struct0();
uint num3 = this.method_0(0x56, 0, 0, 0);
if (Class1.DeviceIoControl_1(handle, num3, IntPtr.Zero, 0, ptr, cb, ref num, 0))
{
disk.Extents = (VOLUMEDISKEXTENTS)Marshal.PtrToStructure(ptr, typeof(VOLUMEDISKEXTENTS));
disk.Number = Convert.ToByte(disk.Extents.diskNumber);
}
cb = Marshal.SizeOf(disk.Adapter);
ptr = Marshal.AllocHGlobal(cb);
struct2.uint_0 = 1;
struct2.uint_1 = 0;
if (Class1.DeviceIoControl(handle, 0x2d1400, struct2, Marshal.SizeOf(struct2), ptr, cb, ref num, 0))
{
disk.Adapter = (STORAGE_ADAPTER_DESCRIPTOR)Marshal.PtrToStructure(ptr, typeof(STORAGE_ADAPTER_DESCRIPTOR));
}
cb = Marshal.SizeOf(disk.DeviceID);
ptr = Marshal.AllocHGlobal(cb);
struct2.uint_0 = 2;
struct2.uint_1 = 0;
if (Class1.DeviceIoControl(handle, 0x2d1400, struct2, Marshal.SizeOf(struct2), ptr, cb, ref num, 0))
{
disk.DeviceID = (STORAGE_DEVICE_ID_DESCRIPTOR)Marshal.PtrToStructure(ptr, typeof(STORAGE_DEVICE_ID_DESCRIPTOR));
}
cb = Marshal.SizeOf(disk.Device);
ptr = Marshal.AllocHGlobal(cb);
struct2.uint_0 = 0;
struct2.uint_1 = 0;
if (Class1.DeviceIoControl(handle, 0x2d1400, struct2, Marshal.SizeOf(struct2), ptr, cb, ref num, 0))
{
disk.Device = (STORAGE_DEVICE_DESCRIPTOR)Marshal.PtrToStructure(ptr, typeof(STORAGE_DEVICE_DESCRIPTOR));
string str2 = Encoding.ASCII.GetString(disk.Device.RawDeviceProperties);
int num4 = Marshal.SizeOf(disk.Device) - disk.Device.RawDeviceProperties.Length;
if (disk.Device.ProductIdOffset > 0)
{
char[] chArray2 = new char[2];
chArray2[1] = ' ';
disk.Model = str2.Substring(disk.Device.ProductIdOffset - num4, 20).Trim(chArray2);
}
if (disk.Device.ProductRevisionOffset > 0)
{
char[] chArray3 = new char[2];
chArray3[1] = ' ';
disk.Firmware = str2.Substring(disk.Device.ProductRevisionOffset - num4, 8).Trim(chArray3);
}
if (disk.Device.SerialNumberOffset > 0)
{
char[] chArray4 = new char[2];
chArray4[1] = ' ';
disk.SerialNumber = str2.Substring(disk.Device.SerialNumberOffset - num4, 40).Trim(chArray4);
}
if ((disk.SerialNumber != null) && (disk.SerialNumber.Length == 40))
{
disk.SerialNumber = this.method_3(disk.SerialNumber);
}
disk.RemovableMedia = Convert.ToBoolean(disk.Device.RemovableMedia);
}
cb = Marshal.SizeOf(disk.Version);
ptr = Marshal.AllocHGlobal(cb);
if (Class1.DeviceIoControl_1(handle, 0x74080, IntPtr.Zero, 0, ptr, cb, ref num, 0))
{
disk.Version = (GETVERSIONOUTPARAMS)Marshal.PtrToStructure(ptr, typeof(GETVERSIONOUTPARAMS));
if ((disk.Version.fCapabilities & 4L) > 0L)
{
SENDCMDINPARAMS sendcmdinparams = new SENDCMDINPARAMS();
sendcmdinparams.DriveRegs.Command = 0xec;
sendcmdinparams.DriveNumber = disk.Number;
sendcmdinparams.BufferSize = 0x200;
if (Class1.DeviceIoControl(handle, 0x7c088, sendcmdinparams, Marshal.SizeOf(sendcmdinparams), ptr, cb, ref num, 0))
{
disk.Params = (SENDCMDOUTPARAMS)Marshal.PtrToStructure(ptr, typeof(SENDCMDOUTPARAMS));
disk.Model = this.method_2(disk.Params.IDS.ModelNumber).Trim();
disk.Firmware = this.method_2(disk.Params.IDS.FirmwareRevision).Trim();
disk.SerialNumber = this.method_2(disk.Params.IDS.SerialNumber).Trim();
}
}
}
}
catch (Exception)
{
}
finally
{
if (handle != null)
{
handle.Dispose();
}
}
return(disk);
}
private async Task CreatePrimaryVolume(PhysicalDisk physicalDisk)
{
await processInvoker.InvokeSudoProcess("parted", physicalDisk.DevPath.Path, "--script", "--", "mklabel", "gpt");
await processInvoker.InvokeSudoProcess("parted", physicalDisk.DevPath.Path, "--script", "--", "mkpart", "primary", "0%", "100%");
}
private void PerformTest(int physicalDiskIndex, TestName testName)
{
PhysicalDisk disk = new PhysicalDisk(physicalDiskIndex);
m_startTime = DateTime.Now;
ClearLog();
AddToLog("Hard Disk Validator {0}", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(3));
AddToLog("Starting {0} Test", GetTestTitle(testName));
AddToLog("Disk: {0}, S/N: {1}", disk.Description, disk.SerialNumber);
AddToLog("Disk size: {0} ({1:###,###,###,###,##0} sectors, {2} bytes per sector)", UIHelper.GetSizeString(disk.Size), disk.TotalSectors, disk.BytesPerSector);
if (!(testName == TestName.Read || testName == TestName.Verify))
{
bool success = disk.ExclusiveLock();
if (!success)
{
MessageBox.Show("Failed to lock the disk.");
return;
}
if (Environment.OSVersion.Version.Major >= 6)
{
success = disk.SetOnlineStatus(false, false);
if (!success)
{
disk.ReleaseLock();
MessageBox.Show("Failed to take the disk offline.");
return;
}
}
}
m_diskTester = new DiskTester(testName, disk);
m_diskTester.OnStatusUpdate += delegate(long currentPosition)
{
UpdateStatus(currentPosition);
};
m_diskTester.OnLogUpdate += delegate(string format, object[] args)
{
AddToLog(format, args);
};
// The last segment might be bigger than the others
long uiBlockSize = disk.TotalSectors / (HorizontalBlocks * VerticalBlocks);
m_blocks = new BlockStatus[HorizontalBlocks * VerticalBlocks];
this.Invoke((MethodInvoker) delegate
{
pictureBoxMap.Invalidate();
pictureBoxMap.Update();
});
for (int uiBlockIndex = 0; uiBlockIndex < m_blocks.Length; uiBlockIndex++)
{
long sectorIndex = uiBlockIndex * uiBlockSize;
long sectorCount = uiBlockSize;
if (uiBlockIndex == m_blocks.Length - 1)
{
sectorCount = disk.TotalSectors - ((m_blocks.Length - 1) * uiBlockSize);
}
BlockStatus blockStatus = m_diskTester.PerformTest(sectorIndex, sectorCount);
m_blocks[uiBlockIndex] = blockStatus;
this.Invoke((MethodInvoker) delegate
{
pictureBoxMap.Invalidate();
pictureBoxMap.Update();
});
if (m_diskTester.Abort)
{
break;
}
}
if (testName != TestName.Read)
{
if (Environment.OSVersion.Version.Major >= 6)
{
disk.SetOnlineStatus(true, false);
}
disk.ReleaseLock();
disk.UpdateProperties();
}
if (m_diskTester.Abort)
{
AddToLog("Test Aborted");
}
else
{
AddToLog("Test Completed");
}
m_diskTester = null;
}
public bool ShouldBeProcessed(PhysicalDisk physicalDisk) => configuration.MonitoringEntries.Any(i => i.PhysicalId.IsChildOfOrEqualTo(physicalDisk.PhysicalId));