Wie listet man physische Laufwerke auf?

Wie listet man physische Festplatten in Windows auf? Um eine Liste zu erhalten "\\\\.\PhysicalDrive0" verfügbar.

#WMIC
Wmic ist ein sehr komplettes Werkzeug

wmic diskdrive list

zum Beispiel eine (zu) detaillierte Liste liefern

für weniger Infos

wmic diskdrive list brief 

#C Sebastian Godelet erwähnt in den Kommentaren:

In C:

system("wmic diskdrive list");

Wie kommentiert, können Sie auch die WinAPI aufrufen, aber … wie in “Wie erhalte ich Daten von WMI mit einer C-Anwendung?” gezeigt, ist dies ziemlich komplex (und wird im Allgemeinen mit C++ und nicht mit C ausgeführt).

#PowerShell Oder mit PowerShell:

Get-WmiObject Win32_DiskDrive

Update Feb. 2022, Microsoft kündigt in „Windows 10-Features, die wir nicht mehr entwickeln“

Das WMIC-Tool ist in Windows 10, Version 21H1 und der Version 21H1 General Availability Channel von Windows Server veraltet.

Dieses Tool wird ersetzt durch Windows PowerShell für WMI.

Hinweis: Diese Einstellung gilt nur für die Befehlszeilenverwaltungstool. WMI selbst ist nicht betroffen.

Eine Möglichkeit, dies zu tun:

1. Logische Laufwerke aufzählen mit GetLogicalDrives

2. Öffnen Sie für jedes logische Laufwerk eine Datei mit dem Namen "\\.\X:" (ohne die Anführungszeichen), wobei X der logische Laufwerksbuchstabe ist.

3. Anruf DeviceIoControl Übergeben des Handles an die im vorherigen Schritt geöffnete Datei und die dwIoControlCode Parametersatz auf IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS:

   HANDLE hHandle;
   VOLUME_DISK_EXTENTS diskExtents;
   DWORD dwSize;
   [...]
   
   iRes = DeviceIoControl(
       hHandle,
       IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
       NULL,
       0,
       (LPVOID) &diskExtents,
       (DWORD) sizeof(diskExtents),
       (LPDWORD) &dwSize,
       NULL);
   

Dies gibt Informationen über den physischen Standort eines logischen Datenträgers als a VOLUME_DISK_EXTENTS Struktur.

In dem einfachen Fall, in dem sich das Volume auf einem einzelnen physischen Laufwerk befindet, ist die Nummer des physischen Laufwerks in verfügbar diskExtents.Extents[0].DiskNumber

Das könnte 5 Jahre zu spät sein :). Aber da ich noch keine Antwort darauf sehe, füge ich dies hinzu.

Wir können benutzen APIs einrichten um die Liste der Festplatten zu erhalten, dh Geräte in der Systemimplementierung GUID_DEVINTERFACE_DISK.

Sobald wir ihre Gerätepfade haben, können wir sie ausgeben IOCTL_STORAGE_GET_DEVICE_NUMBER konstruieren "\\.\PHYSICALDRIVE%d" mit STORAGE_DEVICE_NUMBER.DeviceNumber

Siehe auch SetupDiGetClassDevs Funktion

#include <Windows.h>
#include <Setupapi.h>
#include <Ntddstor.h>

#pragma comment( lib, "setupapi.lib" )

#include <iostream>
#include <string>
using namespace std;

#define START_ERROR_CHK()           \
    DWORD error = ERROR_SUCCESS;    \
    DWORD failedLine;               \
    string failedApi;

#define CHK( expr, api )            \
    if ( !( expr ) ) {              \
        error = GetLastError( );    \
        failedLine = __LINE__;      \
        failedApi = ( api );        \
        goto Error_Exit;            \
    }

#define END_ERROR_CHK()             \
    error = ERROR_SUCCESS;          \
    Error_Exit:                     \
    if ( ERROR_SUCCESS != error ) { \
        cout << failedApi << " failed at " << failedLine << " : Error Code - " << error << endl;    \
    }

int main( int argc, char **argv ) {

    HDEVINFO diskClassDevices;
    GUID diskClassDeviceInterfaceGuid = GUID_DEVINTERFACE_DISK;
    SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
    PSP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailData;
    DWORD requiredSize;
    DWORD deviceIndex;

    HANDLE disk = INVALID_HANDLE_VALUE;
    STORAGE_DEVICE_NUMBER diskNumber;
    DWORD bytesReturned;

    START_ERROR_CHK();

    //
    // Get the handle to the device information set for installed
    // disk class devices. Returns only devices that are currently
    // present in the system and have an enabled disk device
    // interface.
    //
    diskClassDevices = SetupDiGetClassDevs( &diskClassDeviceInterfaceGuid,
                                            NULL,
                                            NULL,
                                            DIGCF_PRESENT |
                                            DIGCF_DEVICEINTERFACE );
    CHK( INVALID_HANDLE_VALUE != diskClassDevices,
         "SetupDiGetClassDevs" );

    ZeroMemory( &deviceInterfaceData, sizeof( SP_DEVICE_INTERFACE_DATA ) );
    deviceInterfaceData.cbSize = sizeof( SP_DEVICE_INTERFACE_DATA );
    deviceIndex = 0;

    while ( SetupDiEnumDeviceInterfaces( diskClassDevices,
                                         NULL,
                                         &diskClassDeviceInterfaceGuid,
                                         deviceIndex,
                                         &deviceInterfaceData ) ) {

        ++deviceIndex;

        SetupDiGetDeviceInterfaceDetail( diskClassDevices,
                                         &deviceInterfaceData,
                                         NULL,
                                         0,
                                         &requiredSize,
                                         NULL );
        CHK( ERROR_INSUFFICIENT_BUFFER == GetLastError( ),
             "SetupDiGetDeviceInterfaceDetail - 1" );

        deviceInterfaceDetailData = ( PSP_DEVICE_INTERFACE_DETAIL_DATA ) malloc( requiredSize );
        CHK( NULL != deviceInterfaceDetailData,
             "malloc" );

        ZeroMemory( deviceInterfaceDetailData, requiredSize );
        deviceInterfaceDetailData->cbSize = sizeof( SP_DEVICE_INTERFACE_DETAIL_DATA );

        CHK( SetupDiGetDeviceInterfaceDetail( diskClassDevices,
                                              &deviceInterfaceData,
                                              deviceInterfaceDetailData,
                                              requiredSize,
                                              NULL,
                                              NULL ),
             "SetupDiGetDeviceInterfaceDetail - 2" );

        disk = CreateFile( deviceInterfaceDetailData->DevicePath,
                           GENERIC_READ,
                           FILE_SHARE_READ | FILE_SHARE_WRITE,
                           NULL,
                           OPEN_EXISTING,
                           FILE_ATTRIBUTE_NORMAL,
                           NULL );
        CHK( INVALID_HANDLE_VALUE != disk,
             "CreateFile" );

        CHK( DeviceIoControl( disk,
                              IOCTL_STORAGE_GET_DEVICE_NUMBER,
                              NULL,
                              0,
                              &diskNumber,
                              sizeof( STORAGE_DEVICE_NUMBER ),
                              &bytesReturned,
                              NULL ),
             "IOCTL_STORAGE_GET_DEVICE_NUMBER" );

        CloseHandle( disk );
        disk = INVALID_HANDLE_VALUE;

        cout << deviceInterfaceDetailData->DevicePath << endl;
        cout << "\\\\?\\PhysicalDrive" << diskNumber.DeviceNumber << endl;
        cout << endl;
    }
    CHK( ERROR_NO_MORE_ITEMS == GetLastError( ),
         "SetupDiEnumDeviceInterfaces" );

    END_ERROR_CHK();

Exit:

    if ( INVALID_HANDLE_VALUE != diskClassDevices ) {
        SetupDiDestroyDeviceInfoList( diskClassDevices );
    }

    if ( INVALID_HANDLE_VALUE != disk ) {
        CloseHandle( disk );
    }

    return error;
}

Die Antwort ist viel einfacher als alle oben genannten Antworten. Die Liste der physischen Laufwerke wird tatsächlich in einem Registrierungsschlüssel gespeichert, der auch die Gerätezuordnung bereitstellt.

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\disk\Enum

Zählen ist die Nummer von PhysicalDrive# und jeder nummerierte Registrierungswert ist das entsprechende physische Laufwerk.

Beispielsweise ist der Registrierungswert “0” PhysicalDrive0. Der Wert ist das tatsächliche Gerät, dem PhysicalDrive0 zugeordnet ist. Der hier enthaltene Wert kann übergeben werden CM_Locate_DevNode innerhalb des Parameters pDeviceID um die Plug-and-Play-Dienste zu nutzen. Auf diese Weise können Sie eine Fülle von Informationen über das Gerät sammeln. Beispielsweise die Eigenschaften des Geräte-Managers wie “Friendly Display Name”, wenn Sie einen Namen für das Laufwerk benötigen, Seriennummern und mehr.

WMI-Dienste, die möglicherweise nicht auf dem System ausgeführt werden, oder andere Hacker sind nicht erforderlich, und diese Funktionalität ist in Windows seit mindestens 2000 vorhanden und ist in Windows 10 weiterhin der Fall.

Ich habe ein Open-Source-Programm namens “dskwipe” modifiziert, um diese Festplatteninformationen daraus zu ziehen. Dskwipe ist in C geschrieben, und Sie können diese Funktion daraus ziehen. Die Binärdatei und die Quelle sind hier verfügbar: dskwipe 0.3 wurde veröffentlicht

Die zurückgegebenen Informationen sehen in etwa so aus:

Device Name                         Size Type      Partition Type
------------------------------ --------- --------- --------------------
\\.\PhysicalDrive0               40.0 GB Fixed
\\.\PhysicalDrive1               80.0 GB Fixed
\Device\Harddisk0\Partition0     40.0 GB Fixed
\Device\Harddisk0\Partition1     40.0 GB Fixed     NTFS
\Device\Harddisk1\Partition0     80.0 GB Fixed
\Device\Harddisk1\Partition1     80.0 GB Fixed     NTFS
\\.\C:                           80.0 GB Fixed     NTFS
\\.\D:                            2.1 GB Fixed     FAT32
\\.\E:                           40.0 GB Fixed     NTFS

Die einzig richtige Antwort ist die von @Grodriguez, und hier ist ein Code, den zu schreiben er zu faul war:

#include <windows.h>
#include <iostream>
#include <bitset>
#include <vector>
using namespace std;

typedef struct _DISK_EXTENT {
    DWORD         DiskNumber;
    LARGE_INTEGER StartingOffset;
    LARGE_INTEGER ExtentLength;
} DISK_EXTENT, *PDISK_EXTENT;

typedef struct _VOLUME_DISK_EXTENTS {
    DWORD       NumberOfDiskExtents;
    DISK_EXTENT Extents[ANYSIZE_ARRAY];
} VOLUME_DISK_EXTENTS, *PVOLUME_DISK_EXTENTS;

#define CTL_CODE(DeviceType, Function, Method, Access) \
    (((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
#define IOCTL_VOLUME_BASE ((DWORD)'V')
#define METHOD_BUFFERED 0
#define FILE_ANY_ACCESS 0x00000000
#define IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS CTL_CODE(IOCTL_VOLUME_BASE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS)

int main() {
    bitset<32> drives(GetLogicalDrives());
    vector<char> goodDrives;
    for (char c="A"; c <= 'Z'; ++c) {
        if (drives[c - 'A']) {
            if (GetDriveType((c + string(":\\")).c_str()) == DRIVE_FIXED) {
                goodDrives.push_back(c);
            }
        }
    }
    for (auto & drive : goodDrives) {
        string s = string("\\\\.\\") + drive + ":";
        HANDLE h = CreateFileA(
            s.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
            OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_RANDOM_ACCESS, NULL
        );
        if (h == INVALID_HANDLE_VALUE) {
            cerr << "Drive " << drive << ":\\ cannot be opened";
            continue;
        }
        DWORD bytesReturned;
        VOLUME_DISK_EXTENTS vde;
        if (!DeviceIoControl(
            h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
            NULL, 0, &vde, sizeof(vde), &bytesReturned, NULL
        )) {
            cerr << "Drive " << drive << ":\\ cannot be mapped into physical drive";
            continue;
        }
        cout << "Drive " << drive << ":\\ is on the following physical drives: ";
        for (int i = 0; i < vde.NumberOfDiskExtents; ++i) {
            cout << vde.Extents[i].DiskNumber << ' ';
        }
        cout << endl;
    }
}

Ich denke, dass die Installation des Windows Driver Development Kit ein ziemlich langwieriger Prozess ist, daher habe ich die Deklarationen beigefügt, die man verwenden muss DeviceIoControl für diese Aufgabe.

GetLogicalDrives() listet alle gemounteten Festplattenpartitionen auf, nicht physische Laufwerke.

Sie können die Laufwerksbuchstaben mit (oder ohne) GetLogicalDrives aufzählen und dann QueryDosDevice() aufrufen, um herauszufinden, welchem ​​physischen Laufwerk der Buchstabe zugeordnet ist.

Alternativ können Sie die Informationen in der Registrierung unter HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices entschlüsseln. Die dortigen binären Datenkodierungen sind jedoch nicht offensichtlich. Wenn Sie eine Kopie des Buches Microsoft Windows Internals von Russinovich und Solomon haben, wird dieser Registrierungsbaum in Kapitel 10 besprochen.