public static string GetVolumeInformation(Volume volume)
{
StringBuilder builder = new StringBuilder();
builder.AppendFormat("Volume size: {0} bytes\n", volume.Size.ToString("###,###,###,###,##0"));
builder.AppendFormat("Volume type: {0}\n", VolumeHelper.GetVolumeTypeString(volume));
if (volume is GPTPartition)
{
builder.AppendFormat("Partition name: {0}\n", ((GPTPartition)volume).PartitionName);
}
else if (volume is DynamicVolume)
{
builder.AppendFormat("Volume name: {0}\n", ((DynamicVolume)volume).Name);
builder.AppendFormat("Volume status: {0}\n", VolumeHelper.GetVolumeStatusString(volume));
}
Guid?windowsVolumeGuid = WindowsVolumeHelper.GetWindowsVolumeGuid(volume);
if (windowsVolumeGuid.HasValue)
{
List <string> mountPoints = WindowsVolumeManager.GetMountPoints(windowsVolumeGuid.Value);
foreach (string volumePath in mountPoints)
{
builder.AppendFormat("Volume path: {0}\n", volumePath);
}
bool isMounted = WindowsVolumeManager.IsMounted(windowsVolumeGuid.Value);
builder.AppendFormat("Mounted: {0}\n", isMounted);
}
builder.AppendLine();
if (volume is MirroredVolume)
{
builder.AppendLine("Extents:");
List <DynamicVolume> components = ((MirroredVolume)volume).Components;
for (int componentIndex = 0; componentIndex < components.Count; componentIndex++)
{
if (componentIndex != 0)
{
builder.AppendLine();
}
DynamicVolume component = components[componentIndex];
builder.AppendFormat("Component {0}:\n", componentIndex);
builder.Append(GetExtentsInformation(component));
}
}
else if (volume is DynamicVolume)
{
builder.AppendLine("Extents:");
builder.Append(GetExtentsInformation((DynamicVolume)volume));
}
else if (volume is Partition)
{
Partition partition = (Partition)volume;
long partitionOffset = partition.FirstSector * partition.BytesPerSector;
string partitionOffsetString = FormattingHelper.GetStandardSizeString(partitionOffset);
builder.AppendFormat("Partiton Offset: {0}, Start Sector: {1}\n", partitionOffsetString, partition.FirstSector);
}
return(builder.ToString());
}
public static string GetExtentLabel(Volume volume, DiskExtent extent, int width)
{
StringBuilder builder = new StringBuilder();
if (volume != null)
{
Guid?volumeGuid = WindowsVolumeHelper.GetWindowsVolumeGuid(volume);
if (volumeGuid.HasValue)
{
List <string> mountPoints = WindowsVolumeManager.GetMountPoints(volumeGuid.Value);
if (mountPoints.Count > 0)
{
builder.AppendLine(mountPoints[0]);
}
}
}
long size = extent.Size;
if (width <= 60)
{
builder.AppendLine(FormattingHelper.GetCompactSizeString(extent.Size));
}
else
{
builder.AppendLine(FormattingHelper.GetStandardSizeString(extent.Size));
}
if (volume != null)
{
string statusString = VolumeHelper.GetVolumeStatusString(volume);
builder.AppendLine(statusString);
}
return(builder.ToString());
}
private void SelectPhysicalDiskForm_Load(object sender, EventArgs e)
{
List <Volume> volumes = WindowsVolumeHelper.GetVolumes();
for (int index = 0; index < volumes.Count; index++)
{
Volume volume = volumes[index];
string title = String.Format("Volume {0}", index);
string type = VolumeHelper.GetVolumeTypeString(volume);
string status = VolumeHelper.GetVolumeStatusString(volume);
ulong volumeID = 0;
string name = String.Empty;
if (volume is DynamicVolume)
{
volumeID = ((DynamicVolume)volume).VolumeID;
name = ((DynamicVolume)volume).Name;
}
else if (volume is GPTPartition)
{
name = ((GPTPartition)volume).PartitionName;
}
ListViewItem item = new ListViewItem(title);
item.SubItems.Add(name);
item.SubItems.Add(type);
item.SubItems.Add(status);
item.SubItems.Add(FormattingHelper.GetStandardSizeString(volume.Size));
item.Tag = volume;
listVolumes.Items.Add(item);
}
}
private void btnOK_Click(object sender, EventArgs e)
{
if (listVolumes.SelectedItems.Count > 0)
{
Volume selectedVolume = (Volume)listVolumes.SelectedItems[0].Tag;
if (selectedVolume is DynamicVolume && !((DynamicVolume)selectedVolume).IsOperational)
{
MessageBox.Show("The selected volume is not operational", "Error");
return;
}
if (!chkReadOnly.Checked)
{
bool skipLock = (Environment.OSVersion.Version.Major >= 6 && VolumeInfo.IsOffline(selectedVolume));
if (!skipLock)
{
Guid?volumeGuid = WindowsVolumeHelper.GetWindowsVolumeGuid(selectedVolume);
if (Environment.OSVersion.Version.Major >= 6)
{
// Windows Vista / 7 enforce various limitations on direct write operations to volumes and disks.
// We either have to take the disk(s) offline or use the OS volume handle for write operations.
if (!volumeGuid.HasValue)
{
MessageBox.Show("The selected volume is not recognized by your operating system");
return;
}
selectedVolume = new OperatingSystemVolume(volumeGuid.Value, selectedVolume.BytesPerSector, selectedVolume.Size, chkReadOnly.Checked);
}
bool isLocked = false;
if (volumeGuid.HasValue)
{
isLocked = WindowsVolumeManager.ExclusiveLock(volumeGuid.Value);
}
if (!isLocked)
{
MessageBox.Show("Unable to lock the volume", "Error");
return;
}
}
}
m_selectedVolume = selectedVolume;
m_isReadOnly = chkReadOnly.Checked;
this.DialogResult = DialogResult.OK;
this.Close();
}
else
{
MessageBox.Show("No volume was selected", "Error");
return;
}
}
/// <param name="diskGroup">Can be set to null when volume is partition</param>
public static ExtendFileSystemResult ExtendFileSystem(List <DynamicDisk> diskGroup, Volume volume, long numberOfAdditionalSectors)
{
Guid?windowsVolumeGuid = WindowsVolumeHelper.GetWindowsVolumeGuid(volume);
bool isMounted = windowsVolumeGuid.HasValue && WindowsVolumeManager.IsMounted(windowsVolumeGuid.Value);
if (isMounted)
{
return(ExtendMountedFileSystem(volume, windowsVolumeGuid.Value, numberOfAdditionalSectors));
}
else
{
if (volume is Partition)
{
return(ExtendUnmountedFileSystem((Partition)volume, numberOfAdditionalSectors));
}
else
{
return(ExtendUnmountedFileSystem(diskGroup, (DynamicVolume)volume, numberOfAdditionalSectors));
}
}
}
public static void ReleaseDisk(Disk disk)
{
if (disk is DiskImage)
{
((DiskImage)disk).ReleaseLock();
}
else if (disk is RAMDisk)
{
((RAMDisk)disk).Free();
}
#if Win32
else if (disk is PhysicalDisk)
{
if (!DiskAccessLibrary.LogicalDiskManager.DynamicDisk.IsDynamicDisk(disk))
{
LockHelper.UnlockBasicDiskAndVolumes((PhysicalDisk)disk);
try
{
((PhysicalDisk)disk).UpdateProperties();
}
catch (System.IO.IOException)
{
}
}
}
else if (disk is VolumeDisk)
{
bool skippedLock = (Environment.OSVersion.Version.Major >= 6 && VolumeInfo.IsOffline(((VolumeDisk)disk).Volume));
if (!skippedLock)
{
Guid?windowsVolumeGuid = WindowsVolumeHelper.GetWindowsVolumeGuid(((VolumeDisk)disk).Volume);
if (windowsVolumeGuid.HasValue)
{
WindowsVolumeManager.ReleaseLock(windowsVolumeGuid.Value);
}
}
}
#endif
}
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;
}
}
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 ListVolumes()
{
List <Volume> volumes = WindowsVolumeHelper.GetVolumes();
Console.WriteLine("Volume ## ID Name Type Size Status ");
Console.WriteLine("--------- ---- ------------ --------- ------- ---------");
for (int index = 0; index < volumes.Count; index++)
{
Volume volume = volumes[index];
string type = String.Empty;
string status = String.Empty;
ulong volumeID = 0;
string name = String.Empty;
if (volume is DynamicVolume)
{
volumeID = ((DynamicVolume)volume).VolumeID;
name = ((DynamicVolume)volume).Name;
if (((DynamicVolume)volume).IsHealthy)
{
status = "Healthy";
}
else
{
status = "Failed";
}
}
if (volume is SimpleVolume)
{
type = "Simple";
}
else if (volume is SpannedVolume)
{
type = "Spanned";
}
else if (volume is StripedVolume)
{
type = "Striped";
}
else if (volume is MirroredVolume)
{
type = "Mirrored";
if (!((MirroredVolume)volume).IsHealthy && ((MirroredVolume)volume).IsOperational)
{
status = "Failed Rd";
}
}
else if (volume is Raid5Volume)
{
type = "RAID-5";
if (!((Raid5Volume)volume).IsHealthy && ((Raid5Volume)volume).IsOperational)
{
status = "Failed Rd";
}
}
else if (volume is Partition)
{
type = "Partition";
status = "Healthy";
}
string volumeNumber = index.ToString().PadLeft(2);
type = type.ToString().PadRight(9);
name = name.ToString().PadRight(12);
status = status.ToString().PadRight(9);
string volumeIDString = String.Empty;
if (volumeID != 0)
{
volumeIDString = volumeID.ToString();
}
volumeIDString = volumeIDString.PadRight(4);
Console.WriteLine("Volume {0} {1} {2} {3} {4} {5}", volumeNumber, volumeIDString, name, type, GetStandardSizeString(volume.Size), status);
}
}