Exemplo n.º 1
0
        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());
        }
Exemplo n.º 2
0
        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
        }
Exemplo n.º 7
0
        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();
            }
        }
Exemplo n.º 9
0
        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);
            }
        }