Zu Mountpoints Festplatte/Parition bzw. Laufwerksbuchstabe auslesen

[Captnemo]

Hi,

Ich will aus ein oder mehreren Festplatte die partitionen auslesen, und nicht nur die, die auch einen Laufwerksbuchstaben haben.

Meine Mountpoint kriege ich jetzt wunderbar.

Code:

\\?\Volume{30e008b5-f5d1-11e2-be6b-806e6f6e6963}\
\\?\Volume{2b9cf42e-43ae-11e3-be9a-60a44ccd60fd}\
\\?\Volume{d1c41ef1-1c62-11e4-bed6-60a44ccd60fd}\
\\?\Volume{30e008b4-f5d1-11e2-be6b-806e6f6e6963}\
\\?\Volume{ab813b75-2ac8-11e4-bedb-806e6f6e6963}\
\\?\Volume{238e20f9-4c25-11e5-bf27-806e6f6e6963}\

Das pass auch gut zu meinen Partitionen bzw. vorhandenen Medien (siehe JPG im Anhang).

Aber wie kann ich jetzt daraus auf

1. Welche HDD?
2. Welche Partion auf der HDD?
3. Wenn Laufwerksbuchstabe, dann welcher?
4. Welcher Medientyp?

kommen?

Ich habe zwar schon ein bisschen was gefunden über PARTITION_INFORMATION_EX bzw. IOCTL_DISK_GET_PARTITION_INFO_EX, aber ich beiß mir da schon an der Deklaration die Zähne aus.
Vielleicht ist das aber auch der falsche Weg? Ich finde aber auch im Inet sehr wenig, was mir auf die Sprünge hilft. Wäre über ein bisschen Hilfe dankbar.

[Luckie]

Guck mal, ob mein Programm SysInfo (http://michael-puff.de/Programmierung/Delphi/Programme/) das anzeigt, was du willst. Ist mit Quellcode.

[Sir Rufo]

Oder man wirft einen Blick in die Doku https://msdn.microsoft.com/en-us/lib...25(VS.85).aspx und schaut sich das Beispiel an. Schon weiß man, wohin der Gaul laufen muss.

[HolgerX]

Stichworte:

GetVolumePathNamesForVolumeName
-> C:\

QueryDosDevice
-> \Device\HarddiskVolume1

Beide nehmen dein Volume '\\?\Volume{c4ee0265-bada-11dd-9cd5-806e6f6e6963}\', jedoch muss bei QueryDosDevice auf 'Volume{c4ee0265-bada-11dd-9cd5-806e6f6e6963}' abgeschnitten werden....

[Captnemo]

Zitat:

Zitat von Luckie (Beitrag 1317826)

Guck mal, ob mein Programm SysInfo (http://michael-puff.de/Programmierung/Delphi/Programme/) das anzeigt, was du willst. Ist mit Quellcode.

Danke. Im Grund entspricht das, was du THDInfo ausliest, schon ganz dem, was ich benötige. Nur holtst du die das die Parition über die Laufwerksbuchstben. Ich möchte aber auch die Partitionen erfassen, die keinen Laufwerksbuchstbaben haben, wie z.B. die System-reserved von Win7+, oder andere, denen man ggf. aus eigenen Gründen keinen LW-Buchstaben zugeordnet hat.

Zitat:

Zitat von Sir Rufo (Beitrag 1317828)

Oder man wirft einen Blick in die Doku https://msdn.microsoft.com/en-us/lib...25(VS.85).aspx und schaut sich das Beispiel an. Schon weiß man, wohin der Gaul laufen muss.

Mit der Funktion FindFirstVolume und etc. hole ich mir ja bereit die VolumeNames. Mir geht es ja darum, daraus jetzt
a) die HDD's zu Nummerieren (Quasi entsprechend ihrem Anschluss am SATA. SATA1=HDD1, SATA2=HDD2 usw).
b) Festzustellen, welche der Partitionsnamen zu welcher HDD gehörte und in der richtigen Reihenfolge
c) Dazu möglich noch den LW-Buchstaben zu erfahren
d) Den Mediatyp auszulesen (Wobei das bei vorhandenem LW-Buchstabe sicherlich nicht das Problem wäre. Aber auch bei Partitionen ohne LW-Buchstaben von Interesse)

Dazu habe ich im MSDN ja was über PARTITION_INFORMATION_EX bzw. IOCTL_DISK_GET_PARTITION_INFO_EX gelesen, komme aber mit der Umsetzung der deklaration nach Delphi nicht wirklich klar. Liegt sicherlich an mir, weil ich mich dabei immer etwas schwer tue.

Zitat:

Zitat von HolgerX (Beitrag 1317851)

Stichworte:

GetVolumePathNamesForVolumeName
-> C:\

QueryDosDevice
-> \Device\HarddiskVolume1

Beide nehmen dein Volume '\\?\Volume{c4ee0265-bada-11dd-9cd5-806e6f6e6963}\', jedoch muss bei QueryDosDevice auf 'Volume{c4ee0265-bada-11dd-9cd5-806e6f6e6963}' abgeschnitten werden....

Damit kann ich schon mal was anfangen. GetVolumePathNamesForVolumeName liefert mir schon mal den Laufwerksbuchstaben. Was mir QueryDosDevice liefert werde ich mir gleich mal ansehen. Aber wie bekomme ich die Zuordnung, welche Partition am Ende zu welcher HDD gehört?

[hathor]

Zitat:

Zitat von Luckie (Beitrag 1317826)

Guck mal, ob mein Programm SysInfo (http://michael-puff.de/Programmierung/Delphi/Programme/) das anzeigt, was du willst. Ist mit Quellcode.

SYSINFO 3.2 braucht nach 11 Jahren mal ein Update...

[Sir Rufo]

Zitat:

Zitat von Captnemo (Beitrag 1317860)

Zitat:

Zitat von Sir Rufo (Beitrag 1317828)

Oder man wirft einen Blick in die Doku https://msdn.microsoft.com/en-us/lib...25(VS.85).aspx und schaut sich das Beispiel an. Schon weiß man, wohin der Gaul laufen muss.

Mit der Funktion FindFirstVolume und etc. hole ich mir ja bereit die VolumeNames. Mir geht es ja darum, daraus jetzt
a) die HDD's zu Nummerieren (Quasi entsprechend ihrem Anschluss am SATA. SATA1=HDD1, SATA2=HDD2 usw).
b) Festzustellen, welche der Partitionsnamen zu welcher HDD gehörte und in der richtigen Reihenfolge
c) Dazu möglich noch den LW-Buchstaben zu erfahren
d) Den Mediatyp auszulesen (Wobei das bei vorhandenem LW-Buchstabe sicherlich nicht das Problem wäre. Aber auch bei Partitionen ohne LW-Buchstaben von Interesse)

Dazu habe ich im MSDN ja was über PARTITION_INFORMATION_EX bzw. IOCTL_DISK_GET_PARTITION_INFO_EX gelesen, komme aber mit der Umsetzung der deklaration nach Delphi nicht wirklich klar. Liegt sicherlich an mir, weil ich mich dabei immer etwas schwer tue.

Auf der Seite (vom Link) finden wir

Zitat:

Examples

For an example, see Displaying Volume Paths.

Und wenn wir dem Link folgen finden wir

Code:

#include <windows.h>
#include <stdio.h>

void DisplayVolumePaths(
        __in PWCHAR VolumeName
        )
{
    DWORD  CharCount = MAX_PATH + 1;
    PWCHAR Names     = NULL;
    PWCHAR NameIdx   = NULL;
    BOOL   Success   = FALSE;

    for (;;) 
    {
        //
        //  Allocate a buffer to hold the paths.
        Names = (PWCHAR) new BYTE [CharCount * sizeof(WCHAR)];

        if ( !Names ) 
        {
            //
            //  If memory can't be allocated, return.
            return;
        }

        //
        //  Obtain all of the paths
        //  for this volume.
        Success = GetVolumePathNamesForVolumeNameW(
            VolumeName, Names, CharCount, &CharCount
            );

        if ( Success ) 
        {
            break;
        }

        if ( GetLastError() != ERROR_MORE_DATA ) 
        {
            break;
        }

        //
        //  Try again with the
        //  new suggested size.
        delete [] Names;
        Names = NULL;
    }

    if ( Success )
    {
        //
        //  Display the various paths.
        for ( NameIdx = Names; 
              NameIdx[0] != L'\0'; 
              NameIdx += wcslen(NameIdx) + 1 ) 
        {
            wprintf(L"  %s", NameIdx);
        }
        wprintf(L"\n");
    }

    if ( Names != NULL ) 
    {
        delete [] Names;
        Names = NULL;
    }

    return;
}

void __cdecl wmain(void)
{
    DWORD  CharCount            = 0;
    WCHAR  DeviceName[MAX_PATH] = L"";
    DWORD  Error                = ERROR_SUCCESS;
    HANDLE FindHandle           = INVALID_HANDLE_VALUE;
    BOOL   Found                = FALSE;
    size_t Index                = 0;
    BOOL   Success              = FALSE;
    WCHAR  VolumeName[MAX_PATH] = L"";

    //
    //  Enumerate all volumes in the system.
    FindHandle = FindFirstVolumeW(VolumeName, ARRAYSIZE(VolumeName));

    if (FindHandle == INVALID_HANDLE_VALUE)
    {
        Error = GetLastError();
        wprintf(L"FindFirstVolumeW failed with error code %d\n", Error);
        return;
    }

    for (;;)
    {
        //
        //  Skip the \\?\ prefix and remove the trailing backslash.
        Index = wcslen(VolumeName) - 1;

        if (VolumeName[0]     != L'\\' ||
            VolumeName[1]     != L'\\' ||
            VolumeName[2]     != L'?'  ||
            VolumeName[3]     != L'\\' ||
            VolumeName[Index] != L'\\') 
        {
            Error = ERROR_BAD_PATHNAME;
            wprintf(L"FindFirstVolumeW/FindNextVolumeW returned a bad path: %s\n", VolumeName);
            break;
        }

        //
        //  QueryDosDeviceW does not allow a trailing backslash,
        //  so temporarily remove it.
        VolumeName[Index] = L'\0';

        CharCount = QueryDosDeviceW(&VolumeName[4], DeviceName, ARRAYSIZE(DeviceName)); 

        VolumeName[Index] = L'\\';

        if ( CharCount == 0 ) 
        {
            Error = GetLastError();
            wprintf(L"QueryDosDeviceW failed with error code %d\n", Error);
            break;
        }

        wprintf(L"\nFound a device:\n %s", DeviceName);
        wprintf(L"\nVolume name: %s", VolumeName);
        wprintf(L"\nPaths:");
        DisplayVolumePaths(VolumeName);

        //
        //  Move on to the next volume.
        Success = FindNextVolumeW(FindHandle, VolumeName, ARRAYSIZE(VolumeName));

        if ( !Success ) 
        {
            Error = GetLastError();

            if (Error != ERROR_NO_MORE_FILES) 
            {
                wprintf(L"FindNextVolumeW failed with error code %d\n", Error);
                break;
            }

            //
            //  Finished iterating
            //  through all the volumes.
            Error = ERROR_SUCCESS;
            break;
        }
    }

    FindVolumeClose(FindHandle);
    FindHandle = INVALID_HANDLE_VALUE;

    return;
}

der folgende Ausgabe produziert

Code:

Found a device:
 \Device\HarddiskVolume2
Volume name: \\?\Volume{4c1b02c1-d990-11dc-99ae-806e6f6e6963}\
Paths:  C:\

Found a device:
 \Device\CdRom0
Volume name: \\?\Volume{4c1b02c4-d990-11dc-99ae-806e6f6e6963}\
Paths:  D:\

Das hast du doch gesucht ... oder etwa nicht ...

Ja, das ist kein Delphi, aber man erkennt die Richtung, wohin man laufen muss ...

[Captnemo]

Okay, mühsam ernährt sich das Eichhörnchen ;) (Dank an SirRufo....ich hab's tatsächlich nicht gesehen ;) )

Jetzt bin schon mal einen Schritt weiter:

Code:

\\?\Volume{30e008b5-f5d1-11e2-be6b-806e6f6e6963}\ | 25 | \Device\HarddiskVolume2 | 0 | C:\
\\?\Volume{2b9cf42e-43ae-11e3-be9a-60a44ccd60fd}\ | 25 | \Device\HarddiskVolume3 | 0 | D:\
\\?\Volume{d1c41ef1-1c62-11e4-bed6-60a44ccd60fd}\ | 25 | \Device\HarddiskVolume5 | 0 | I:\
\\?\Volume{30e008b4-f5d1-11e2-be6b-806e6f6e6963}\ | 25 | \Device\HarddiskVolume1 | 0 |
\\?\Volume{ab813b75-2ac8-11e4-bedb-806e6f6e6963}\ | 25 | \Device\HarddiskVolume4 | 0 | L:\
\\?\Volume{238e20f9-4c25-11e5-bf27-806e6f6e6963}\ | 16 | \Device\CdRom0 | 0 | E:\

Nicht an der komischen Formatierung stören, das mach ich nur zum Testen.
Ich habe also nun mein VolumeName, mein DeviceName und auch meinen dazugehörigen Laufwerksbuchstaben.
HarddiskVolume1 ist meine System-reserved-Partition, HarddiskVolume4 ist mein CardReader und CdRom0 eben mein DVD-Laufwerk.

Wenn ich mir zu den Laufwerken noch die VolumeInfos auslesen, dann könnte ich ja auch feststellen, ob ein Volume überhaupt einen Inhalt hat.

Aber was mir wirklich noch zu meinem Glück fehlt, ist das zuordnet der DeviceNames zu den Physikalischen HDD's. Hat dazu noch jemand eine Idee?

Und da die Nummer hinter HarddiskVolume anzunehmenderweise in chronologischer Reihenfolge des Erstellens der Partition vergeben wird, gibt diese mir auch keinen Aufschluss darüber, in welcher Reihenfolge diese auf der Platte angeordnet sind. Dazu könnte ich ggf. aber Start- und Endsektor auslesen, dann könnte ich mir das schon irgendwie zusammenreimen.

[hathor]

WMI_GetWin32DiskDriveInfo

Delphi-Quellcode:

program GetDiskDriveInfo;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  Winapi.ActiveX,
  System.Win.ComObj,
  System.Variants;

function VarToInt(const AVariant: Variant): integer;
begin Result := StrToIntDef(Trim(VarToStr(AVariant)), 0); end;

function WmiDateToTDatetime(vDate : OleVariant) : TDateTime;
var FWbemDateObj  : OleVariant;
begin;
  FWbemDateObj  := CreateOleObject('WbemScripting.SWbemDateTime');
  FWbemDateObj.Value:=vDate;
  Result:=FWbemDateObj.GetVarDate;
end;

procedure  GetCIM_PhysicalMediaInfo;
const
  WbemUser            ='';
  WbemPassword        ='';
  WbemComputer        ='localhost';
  wbemFlagForwardOnly = $00000020;
var
  FSWbemLocator : OLEVariant;
  FWMIService   : OLEVariant;
  FWbemObjectSet: OLEVariant;
  FWbemObject   : OLEVariant;
  oEnum         : IEnumvariant;
  iValue        : LongWord;
begin;
  FSWbemLocator := CreateOleObject('WbemScripting.SWbemLocator');
  FWMIService   := FSWbemLocator.ConnectServer(WbemComputer, 'root\CIMV2', WbemUser, WbemPassword);
  FWbemObjectSet:= FWMIService.ExecQuery('SELECT * FROM CIM_PhysicalMedia','WQL',wbemFlagForwardOnly);
  oEnum         := IUnknown(FWbemObjectSet._NewEnum) as IEnumVariant;
  while oEnum.Next(1, FWbemObject, iValue) = 0 do
  begin
    Writeln(Format('Capacity                %d',[VarToInt(FWbemObject.Capacity)]));// Uint64
    Writeln(Format('Caption                 %s',[VarToStr(FWbemObject.Caption)]));// String
    Writeln(Format('CleanerMedia            %s',[VarToStr(FWbemObject.CleanerMedia)]));// Boolean
    Writeln(Format('CreationClassName       %s',[VarToStr(FWbemObject.CreationClassName)]));// String
    Writeln(Format('Description             %s',[VarToStr(FWbemObject.Description)]));// String
    Writeln(Format('HotSwappable            %s',[VarToStr(FWbemObject.HotSwappable)]));// Boolean
    Writeln(Format('InstallDate             %s',[VarToStr(FWbemObject.InstallDate)]));// Datetime
    Writeln(Format('Manufacturer            %s',[VarToStr(FWbemObject.Manufacturer)]));// String
    Writeln(Format('MediaDescription        %s',[VarToStr(FWbemObject.MediaDescription)]));// String
    Writeln(Format('MediaType               %d',[VarToInt(FWbemObject.MediaType)]));// Uint16
    Writeln(Format('Model                   %s',[VarToStr(FWbemObject.Model)]));// String
    Writeln(Format('Name                    %s',[VarToStr(FWbemObject.Name)]));// String
    Writeln(Format('OtherIdentifyingInfo    %s',[VarToStr(FWbemObject.OtherIdentifyingInfo)]));// String
    Writeln(Format('PartNumber              %s',[VarToStr(FWbemObject.PartNumber)]));// String
    Writeln(Format('PoweredOn               %s',[VarToStr(FWbemObject.PoweredOn)]));// Boolean
    Writeln(Format('Removable               %s',[VarToStr(FWbemObject.Removable)]));// Boolean
    Writeln(Format('Replaceable             %s',[VarToStr(FWbemObject.Replaceable)]));// Boolean
    Writeln(Format('SerialNumber            %s',[TRIM(VarToStr(FWbemObject.SerialNumber))]));// String
    Writeln(Format('SKU                     %s',[VarToStr(FWbemObject.SKU)]));// String
    Writeln(Format('Status                  %s',[VarToStr(FWbemObject.Status)]));// String
    Writeln(Format('Tag                     %s',[VarToStr(FWbemObject.Tag)]));// String
    Writeln(Format('Version                 %s',[VarToStr(FWbemObject.Version)]));// String
    Writeln(Format('WriteProtectOn          %s',[VarToStr(FWbemObject.WriteProtectOn)]));// Boolean

    Writeln('----------------------------------------------------------------------');
    FWbemObject:=Unassigned;
  end;
end;
//------------------------------------------------------------------------------
procedure GetWin32_DiskDriveInfo;
const
  WbemUser ='';
  WbemPassword ='';
  WbemComputer ='localhost';
  wbemFlagForwardOnly = $00000020;
var
  FSWbemLocator : OLEVariant;
  FWMIService : OLEVariant;
  FWbemObjectSet: OLEVariant;
  FWbemObject : OLEVariant;
  oEnum : IEnumvariant;
  iValue : LongWord;
  FWbemDateObj  : OleVariant;
  Dt : TDateTime;
  I  : Integer;
  Data : array of WORD;//Byte;
  params: OleVariant; //TVarArray;
//  EventDate     : TDateTime;
begin;
  FSWbemLocator := CreateOleObject('WbemScripting.SWbemLocator');
  FWMIService := FSWbemLocator.ConnectServer(WbemComputer, 'root\CIMV2', WbemUser, WbemPassword);
  FWbemObjectSet:= FWMIService.ExecQuery('SELECT * FROM Win32_DiskDrive','WQL',wbemFlagForwardOnly);
  oEnum := IUnknown(FWbemObjectSet._NewEnum) as IEnumVariant;
  while oEnum.Next(1, FWbemObject, iValue) = 0 do
  begin
    Writeln(Format('Availability %d',[VarToInt(FWbemObject.Availability)]));// Uint16
    Writeln(Format('BytesPerSector %d',[VarToInt(FWbemObject.BytesPerSector)]));// Uint32

// Writeln(Format('Capabilities %d',[VarToInt(FWbemObject.Capabilities)]));// Array of Uint16
      if not VarIsNull(FWbemObject.Capabilities) then
      begin
        Data := FWbemObject.Capabilities;
        for I:= VarArrayLowBound(data,1) to VarArrayHighBound(data,1) do
          Writeln('Capabilities: '+IntToStr(Data[I]));// Array of WORD /Uint16
      end;

// Writeln(Format('CapabilityDescriptions %s',[VarToStr(FWbemObject.CapabilityDescriptions)]));// Array of VarToStr
      if not VarIsNull(FWbemObject.CapabilityDescriptions) then
      begin
        Params := FWbemObject.CapabilityDescriptions;
        for I:= VarArrayLowBound(Params,1) to VarArrayHighBound(Params,1) do
          Writeln('CapabilityDescriptions: '+  VarToStr(Params[I]));// Array of VarToStr
      end;

    Writeln(Format('Caption %s',[VarToStr(FWbemObject.Caption)]));// VarToStr
    Writeln(Format('CompressionMethod %s',[VarToStr(FWbemObject.CompressionMethod)]));// String
    Writeln(Format('ConfigManagerErrorCode %d',[VarToInt(FWbemObject.ConfigManagerErrorCode)]));// Uint32
    Writeln(Format('ConfigManagerUserConfig %s',[VarToStr(FWbemObject.ConfigManagerUserConfig)]));// Boolean
    Writeln(Format('CreationClassName %s',[VarToStr(FWbemObject.CreationClassName)]));// String
    Writeln(Format('DefaultBlockSize %d',[VarToInt(FWbemObject.DefaultBlockSize)]));// Uint64
    Writeln(Format('Description %s',[VarToStr(FWbemObject.Description)]));// String
    Writeln(Format('DeviceID %s',[VarToStr(FWbemObject.DeviceID)]));// String
    Writeln(Format('ErrorCleared %s',[VarToStr(FWbemObject.ErrorCleared)]));// Boolean
    Writeln(Format('ErrorDescription %s',[VarToStr(FWbemObject.ErrorDescription)]));// String
    Writeln(Format('ErrorMethodology %s',[VarToStr(FWbemObject.ErrorMethodology)]));// String
    Writeln(Format('FirmwareRevision %s',[VarToStr(FWbemObject.FirmwareRevision)]));// String
    Writeln(Format('Index %d',[VarToInt(FWbemObject.Index)]));// Uint32
//    Writeln(Format('InstallDate %s',[VarToStr(FWbemObject.InstallDate)]));// Datetime
//    Writeln(Format('InstallDate %s',[WmiDateToTDatetime(FWbemObject.InstallDate)]));
//    dt:= WmiDateToTDatetime(FWbemObject.InstallDate);

    Writeln(Format('InterfaceType %s',[VarToStr(FWbemObject.InterfaceType)]));// String
    Writeln(Format('LastErrorCode %d',[VarToInt(FWbemObject.LastErrorCode)]));// Uint32
    Writeln(Format('Manufacturer %s',[VarToStr(FWbemObject.Manufacturer)]));// String
    Writeln(Format('MaxBlockSize %d',[VarToInt(FWbemObject.MaxBlockSize)]));// Uint64
    Writeln(Format('MaxMediaSize %d',[VarToInt(FWbemObject.MaxMediaSize)]));// Uint64
    Writeln(Format('MediaLoaded %s',[VarToStr(FWbemObject.MediaLoaded)]));// Boolean
    Writeln(Format('MediaType %s',[VarToStr(FWbemObject.MediaType)]));// String
    Writeln(Format('MinBlockSize %d',[VarToInt(FWbemObject.MinBlockSize)]));// Uint64
    Writeln(Format('Model %s',[VarToStr(FWbemObject.Model)]));// String
    Writeln(Format('Name %s',[VarToStr(FWbemObject.Name)]));// String
    Writeln(Format('NeedsCleaning %s',[VarToStr(FWbemObject.NeedsCleaning)]));// Boolean
    Writeln(Format('NumberOfMediaSupported %d',[VarToInt(FWbemObject.NumberOfMediaSupported)]));// Uint32
    Writeln(Format('Partitions %d',[VarToInt(FWbemObject.Partitions)]));// Uint32
    Writeln(Format('PNPDeviceID %s',[VarToStr(FWbemObject.PNPDeviceID)]));// String
    Writeln(Format('PowerManagementCapabilities %d',[VarToInt(FWbemObject.PowerManagementCapabilities)]));// Array of Uint16
    Writeln(Format('PowerManagementSupported %s',[VarToStr(FWbemObject.PowerManagementSupported)]));// Boolean
    Writeln(Format('SCSIBus %d',[VarToInt(FWbemObject.SCSIBus)]));// Uint32
    Writeln(Format('SCSILogicalUnit %d',[VarToInt(FWbemObject.SCSILogicalUnit)]));// Uint16
    Writeln(Format('SCSIPort %d',[VarToInt(FWbemObject.SCSIPort)]));// Uint16
    Writeln(Format('SCSITargetId %d',[VarToInt(FWbemObject.SCSITargetId)]));// Uint16
    Writeln(Format('SectorsPerTrack %d',[VarToInt(FWbemObject.SectorsPerTrack)]));// Uint32
    Writeln(Format('SerialNumber %s',[TRIM(VarToStr(FWbemObject.SerialNumber))]));// String
    Writeln(Format('Signature %d',[VarToInt(FWbemObject.Signature)]));// Uint32
    Writeln(Format('Size %d',[VarToInt(FWbemObject.Size)]));// Uint64
    Writeln(Format('Status %s',[VarToStr(FWbemObject.Status)]));// String
    Writeln(Format('StatusInfo %d',[VarToInt(FWbemObject.StatusInfo)]));// Uint16
    Writeln(Format('SystemCreationClassName %s',[VarToStr(FWbemObject.SystemCreationClassName)]));// String
    Writeln(Format('SystemName %s',[VarToStr(FWbemObject.SystemName)]));// String
    Writeln(Format('TotalCylinders %d',[VarToInt(FWbemObject.TotalCylinders)]));// Uint64
    Writeln(Format('TotalHeads %d',[VarToInt(FWbemObject.TotalHeads)]));// Uint32
    Writeln(Format('TotalSectors %d',[VarToInt(FWbemObject.TotalSectors)]));// Uint64
    Writeln(Format('TotalTracks %d',[VarToInt(FWbemObject.TotalTracks)]));// Uint64
    Writeln(Format('TracksPerCylinder %d',[VarToInt(FWbemObject.TracksPerCylinder)]));// Uint32

    Writeln('----------------------------------------------------------------------');
    FWbemObject:=Unassigned;
  end;
end;

begin
 try
    CoInitialize(nil);
    try
      GetCIM_PhysicalMediaInfo;
      WriteLn('----------------------------------------------------------------------');
      GetWin32_DiskDriveInfo;
    finally
      CoUninitialize;
    end;
 except
    on E:EOleException do
        Writeln(Format('EOleException %s %x', [E.Message,E.ErrorCode]));
    on E:Exception do
        Writeln(E.Classname, ':', E.Message);
 end;

 Writeln('Press Enter to exit');
 Readln;
end.

[Dalai]

Vor vielen Jahren hab ich mal etwas ähnliches gesucht und daraus diese Funktion(en) gebastelt:

Delphi-Quellcode:

function GetLD(Drive: Char): Cardinal;
var
  Buffer : String;
begin
  Buffer := Format('\\.\%s:',[Drive]);
  Result := CreateFile(PChar(Buffer),
                       GENERIC_READ OR GENERIC_WRITE,
                       FILE_SHARE_READ OR FILE_SHARE_WRITE,
                       nil,
                       OPEN_EXISTING,
                       0,
                       0);
  If Result = INVALID_HANDLE_VALUE Then
    begin
    Result := CreateFile(PChar(Buffer),
                         GENERIC_READ,
                         FILE_SHARE_READ OR FILE_SHARE_WRITE,
                         nil,
                         OPEN_EXISTING,
                         0,
                         0);
  end;
end;

function GetPhysicalDiskNumber(Drive: Char): shortint;
var
  LD : DWORD;
  DiskExtents : PVolumeDiskExtents;
  DiskExtent : TDiskExtent;
  BytesReturned : Cardinal;
begin
  Result := -1;
  LD := GetLD(Drive);
  If LD = INVALID_HANDLE_VALUE Then Exit;
  Try
    DiskExtents := AllocMem(Max_Path);
    DeviceIOControl(LD,
                    IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
                    nil,
                    0,
                    DiskExtents,
                    MAX_PATH,
                    BytesReturned,
                    nil);
    If DiskExtents^.NumberOfDiskExtents > 0 Then
      begin
      DiskExtent := DiskExtents^.Extents[0];
      Result := DiskExtent.DiskNumber;
    end;
  Finally
    CloseHandle(LD);
  end;
end;

Ich sehe gerade, dass da wahrscheinlich ein schickes Speicherleck drin ist, und auch sonst ist der Code eher suboptimal - naja, ist eben alter Code (und wahrscheinlich weniger schlimm als der Code von jemand anders, den ich seit vorgestern in den Fingern habe).

MfG Dalai

[Captnemo]

@Hathor: Okay über WMI geht's natürlich, und wenn ich am Ende das anders nicht hinbekomme, werde ich es wohl auch so machen müssen. Aber unabhängig davon hat mich jetzt ein bisschen der Ergeiz gepackt, das mal so zum Laufen zu kriegen.

@Dalai: Das Funktioniert sicher auch. Aber damit kann ich ja nur die Paritionen ansprechen, die auch über ein LW-Buchstaben verfügen.

Ich habe mir mittlerweise das hier zusammengebastelt. (Man muss hier von Basteln sprechen, denn diese C-Übersetzung aus dem MSDN fällt mir echt schwer).

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
  TForm1 = class(TForm)
    mmo1: TMemo;
    btn1: TButton;
    procedure btn1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

  const
    PARTITION_BASIC_DATA_GUID     = 'ebd0a0a2-b9e5-4433-87c0-68b6b72699c7';
    PARTITION_ENTRY_UNUSED_GUID   = '00000000-0000-0000-0000-000000000000';
    PARTITION_SYSTEM_GUID         = 'c12a7328-f81f-11d2-ba4b-00a0c93ec93b';
    PARTITION_MSFT_RESERVED_GUID  = 'e3c9e316-0b5c-4db8-817d-f92df00215ae';
    PARTITION_LDM_METADATA_GUID   = '5808c8aa-7e8f-42e0-85d2-e1e90434cfb3';
    PARTITION_LDM_DATA_GUID       = 'af9b60a0-1431-4f62-bc68-3311714a69ad';
    PARTITION_MSFT_RECOVERY_GUID  = 'de94bba4-06d1-4d40-a16a-bfd50179d6ac';

    GTP_ATTRIBUTE_PLATFORM_REQUIRED          = $0000000000000001;
    GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER = $8000000000000000;
    GPT_BASIC_DATA_ATTRIBUTE_HIDDEN          = $4000000000000000;
    GTP_BASIC_data_ATTRIBUTE_SHADOW_COPY     = $2000000000000000;
    GTP_BASIC_DATA_ATTRIBUTE_READ_ONLY       = $1000000000000000;



  Type
    PARTITION_STYLE = type Integer;

    PARTITION_INFORMATION_MBR = record
      PartitionType: Byte;
      BootIndicator: BOOL;
      RecognizedPartition: BOOL;
      HiddenSecorts: DWORD;
    end;

    PARTITION_INFORMATION_GPT = record
      PartitonType: TGUID;
      PartitionId: TGUID;
      Attributes: DWORD64;
      Name: WCHAR;
    end;

    _PARTITION_INFORMATION_EX = record
      PartitionStyle: PARTITION_STYLE;
      StartingOffset: LARGE_INTEGER;
      PartitionLength: LARGE_INTEGER;
      PartitionNumber: ULONG;
      RewritePartition: Boolean;
    case Integer of
     0: (Mbr: PARTITION_INFORMATION_MBR);
     1: (Gpt: PARTITION_INFORMATION_GPT);
    end;
  const
    PARTITION_STYLE_MBR = PARTITION_STYLE(0);
    PARTITION_STYLE_GPT = PARTITION_STYLE(1);
    PARTITION_STYLE_RAW = PARTITION_STYLE(2);

//  function FindFirstVolume(lpszVolumeName: LPTSTR; cchBufferLength: DWord): THandle; stdcall; external 'kernel32.dll' name 'FindFirstVolumeW';
//  function FindNextVolume(hFindVolume: THandle; lpszVolumeName: LPTSTR; cchBufferLength: DWORD): BOOL; stdcall; external 'kernel32.dll' name 'FindNextVolumeW';
//  function FindVolumeClose(hFindVolume: THandle): BOOL; stdcall; external 'kernel32.dll' name 'FindVolumeClose';
//  function GetVolumePathNames(lpszVolumeName: LPCTSTR; lpszVolumePathName: LPTSTR; cchBufferLength: DWORD; lpcchReturnLength: PDWORD): BOOL; stdcall; external 'kernel32.dll' name 'GetVolumePathNamesForVolumeNameW';


var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.btn1Click(Sender: TObject);
var
  h, p: Integer;
  Device: string;
  hDevice: Cardinal;
  PARTITION_INFORMATION_EX: _PARTITION_INFORMATION_EX;
  Len: Cardinal;
  StartOffset, PartLength: Int64;
begin
  for h := 1 to 9 do
  begin
    Device:='\\.\Harddisk1'+IntToStr(h);
    hdevice:=CreateFile(PChar(Device), 0, FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, 0, 0);
    if hDevice <> INVALID_HANDLE_VALUE then
    begin
      DeviceIoControl(hDevice, IOCTL_DISK_GET_PARTITION_INFO_EX, nil, 0, @PARTITION_INFORMATION_EX, SizeOf(PARTITION_INFORMATION_EX), Len, nil);
      StartOffset:=PARTITION_INFORMATION_EX.StartingOffset.QuadPart;
      PartLength:=PARTITION_INFORMATION_EX.PartitionLength.QuadPart;
      mmo1.Lines.Add(Device+' = '+IntToStr(StartOffset)+' - '+IntToStr(PartLength));
      CloseHandle(hDevice);
      ZeroMemory(@PARTITION_INFORMATION_EX, 0);
    end;
    //end;
  end;
end;

end.

(Man denke sich jetzt zu obigen Code noch eine Form mit Memo und Button)

Ist jetzt nur ein Testprogramm um mir die Funktion etwas besser zu verdeutlichen.

Sind sicherlich viele Fehler drin. Aber so grundsätzlich kommt da schon mal was raus. Ob das dann natürlich korrekt ist, steht noch mal auf einem anderen Blatt.

Und leider bekomme ich für jede Harddisk exakt die gleichen Werte.

Und weiterhin ist das ja auch noch nicht so wirklich was ich will. Denn eigenlich möchte ich sowas wie '//./Harddisk1/Partition1' ansprechen, aber da bekomme ich von CreateFile immer ein ungültiges Handle. Aber soweit ich das gelesen habe muss man doch auch Partitionen ansprechen können.