Hoe vermeld ik fysieke schijven in Windows?
Om een ​​lijst met "\\\\.\PhysicalDrive0"beschikbaar te krijgen.

Antwoord 1, autoriteit 100%

WMIC

wmicis een zeer complete tool

wmic diskdrive list

geef bijvoorbeeld een (te veel) gedetailleerde lijst

voor minder info

wmic diskdrive list brief 

C

Sebastian Godeletvermeldt in de opmerkingen:

In C:

system("wmic diskdrive list");

Zoals aangegeven, kunt u ook de WinAPI aanroepen, maar… zoals weergegeven in “Hoe gegevens van WMI te verkrijgen met een C Application?“, is dit behoorlijk ingewikkeld (en wordt meestal gedaan met C++, niet met C).

PowerShell

Of met PowerShell:

Get-WmiObject Win32_DiskDrive

Antwoord 2, autoriteit 64%

Een manier om het te doen:

1. Logische stations opsommen met GetLogicalDrives

2. Open voor elke logische schijf een bestand met de naam "\\.\X:"(zonder de aanhalingstekens) waarbij X de letter van de logische schijf is.

3. Bel DeviceIoControlde handle doorgeven aan het bestand dat in de vorige stap is geopend en de parameter dwIoControlCodeis ingesteld op 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);
   

Dit retourneert informatie over de fysieke locatie van een logisch volume, als een VOLUME_DISK_EXTENTSstructuur.

In het eenvoudige geval dat het volume zich op één fysieke schijf bevindt, is het fysieke schijfnummer beschikbaar in diskExtents.Extents[0].DiskNumber

Antwoord 3, autoriteit 44%

Dit is misschien 5 jaar te laat :). Maar omdat ik hier nog geen antwoord op zie, voeg ik dit toe.

We kunnen Setup-API’sgebruiken om krijg de lijst met schijven, dwz apparaten in het systeem die implementeren GUID_DEVINTERFACE_DISK.

Zodra we hun apparaatpaden hebben, kunnen we uitgeven IOCTL_STORAGE_GET_DEVICE_NUMBERom "\\.\PHYSICALDRIVE%d"te construeren met STORAGE_DEVICE_NUMBER.DeviceNumber

Zie ook SetupDiGetClassDevsfunctie

#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;
}

4, Autoriteit 30%

Het antwoord is veel eenvoudiger dan al het bovenstaande antwoorden. De lijst fysieke aandrijving is feitelijk opgeslagen in een register sleutel die geeft ook de inrichting mapping.

HKEY_LOCAL_MACHINE \ SYSTEM \ CurrentControlSet \ Services \ schijf \ Enum

Count het aantal PhysicalDrive # en elke genummerde Registerwaarde is de bijbehorende fysieke schijf.

Als u bijvoorbeeld Registry Value “0” is PhysicalDrive0. De waarde is het betreffende toestel PhysicalDrive0 is toegewezen aan. De waarde die hier kunnen worden geleid in CM_Locate_DevNode binnen parameter pDeviceID gebruik maken van de plug and play-diensten. Dit zal u toelaten om een ​​schat aan informatie te verzamelen over het apparaat. Zoals de eigenschappen van Device Manager als “Friendly Display Name” als u een naam voor de aandrijving, serienummers en behoefte aan meer.

Er is geen noodzaak voor WMI diensten die niet kunnen worden uitgevoerd op het systeem of andere hacks en deze functionaliteit is ten minste sinds 2000 aanwezig in Windows en blijft het geval in Windows 10 zijn.

Antwoord 5, autoriteit 14%

GetLogicalDrives() somt alle aangekoppelde schijfpartities op, nietfysieke schijven.

U kunt de stationsletters opsommen met (of zonder) GetLogicalDrives en vervolgens QueryDosDevice() aanroepen om erachter te komen aan welk fysiek station de letter is toegewezen.

Als alternatief kunt u de informatie in het register decoderen op HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices. De binaire gegevenscoderingen daar zijn echter niet duidelijk. Als je een exemplaar hebt van Russinovich en Solomon’s boek Microsoft Windows Internals, wordt deze registercomponent besproken in hoofdstuk 10.

Antwoord 6, autoriteit 12%

De enige zekere manier om dit te doen is door CreateFile()aan te roepen op alle \\.\Physicaldiskxwaar x van 0 tot 15 is (16 is het maximum aantal aantal schijven toegestaan). Controleer de geretourneerde handle-waarde. Indien ongeldig, controleer dan GetLastError()voor ERROR_FILE_NOT_FOUND. Als het iets anders retourneert, dan bestaat de schijf maar heb je er om de een of andere reden geen toegang toe.

Antwoord 7, autoriteit 6%

Thic WMIC-commandocombinatie werkt prima:

wmic volume list brief

Antwoord 8, autoriteit 4%

Als u alleen naar de bestaande schijven hoeft te kijken, is deze voldoende:

powershell "get-physicaldisk"

Antwoord 9, autoriteit 2%

Misschien wilt u de oude A: en B: schijven opnemen, want u weet nooit wie ze gebruikt!
Ik werd moe van USB-drives die mijn twee SDHC-drives stoten die alleen voor Readyboost zijn.
Ik had ze toegewezen aan Hoge letters Z:Y: met een hulpprogramma dat stationsletters naar wens toewijst aan apparaten. Ik vroeg me af… Kan ik een Readyboost drive letter A maken: ? JA!
Kan ik mijn tweede SDHC-schijfletter als B: ? JA!

Ik heb vroeger floppydrives gebruikt, nooit gedacht dat A: of B: handig zou zijn voor
Klaarboost.

Mijn punt is, ga er niet vanuit dat A: & B: zal door niemand voor iets worden gebruikt
Misschien vindt u zelfs het oude SUBST-commando dat wordt gebruikt!

Antwoord 10, autoriteit 2%

Hieris een nieuweoplossing om dit te doen met WMI-oproepen.
Dan hoef je alleen maar te bellen:

queryAndPrintResult(L"SELECT * FROM Win32_DiskDrive", L"Name");

Antwoord 11

Ik kwam dit vandaag tegen in mijn RSS-lezer. Ik heb een schonere oplossing voor je. Dit voorbeeld is in Delphi, maar kan heel gemakkelijk worden omgezet naar C/C++ (It’s all Win32).

Bevraag alle waardenamen van de volgende registerlocatie:
HKLM\SYSTEM\MountedDevices

Geef ze een voor een door aan de volgende functie en u krijgt de apparaatnaam terug. Lekker schoon en simpel! Ik heb dit gevonden code op een blog hier.

function VolumeNameToDeviceName(const VolName: String): String;
var
  s: String;
  TargetPath: Array[0..MAX_PATH] of WideChar;
  bSucceeded: Boolean;
begin
  Result := ”;
  // VolumeName has a format like this: \\?\Volume{c4ee0265-bada-11dd-9cd5-806e6f6e6963}\
  // We need to strip this to Volume{c4ee0265-bada-11dd-9cd5-806e6f6e6963}
  s :=  Copy(VolName, 5, Length(VolName) - 5);
  bSucceeded := QueryDosDeviceW(PWideChar(WideString(s)), TargetPath, MAX_PATH) <> 0;
  if bSucceeded then
  begin
    Result := TargetPath;
  end
  else begin
    // raise exception
  end;
end;

Antwoord 12

Als u ‘fysieke’ toegang wilt, ontwikkelen we deze API waarmee u uiteindelijk kunt communiceren met opslagapparaten. Het is open source en je kunt de huidige code zien voor wat informatie. Kom terug voor meer functies:
https://github.com/virtium/vtStor

Antwoord 13

Maak een lijst van alle letters in het Amerikaans-Engelse alfabet, sla een & B. “CDEFGHIJKLMNOPQRSTUVWXYZ”. Open elk van die schijven met CreateFileb.v. CreateFile("\\.\C:"). Als het INVALID_HANDLE_VALUEniet retourneert, heb je een ‘goede’ drive. Neem vervolgens dat handvat en voer het door DeviceIoControlom de schijf #. Zie mijn gerelateerde antwoord voor meer details.