Powershell et wmi, comment à la carte logique de disques/volumes sur un disque dur ou vice-versa?

Essayer cette

Get-WMIObject Win32_LogicalDisk | Foreach-Object {
    Get-WmiObject -Query "Associators of {Win32_LogicalDisk.DeviceID='$($_.DeviceID)'} WHERE ResultRole=Antecedent"
} | Format-Table

Cela vous donne les instances de WIn32_logicalDisk où Win32_LogicalDisk est dépendante de l'entité dans la relation. Ainsi, vous obtenez le Win32_DiskDrive instances.

OriginalL'auteur ravikanth

Autres réponses avec WMI relation est bonne si vous n'avez pas de soins sur le point de montage de volume car il n'est pas possible avec WMI directement à associer le point de montage de volume avec une partition ou un disque.

Mais il y a une clé de registre qui peut vous aider à comprendre quelques informations qui vous permettront d'établir la connexion en tant que windows n' :

function getVolumeInformation{
param($hostName, $credential)
$volumeInformation = getVolumeInformation -computerName $hostName -credential $credential                   
$WMIRegistryMountedDeviceInfo = WMIRegistryMountedDeviceInfo -computerName $hostName -Credential $credential
foreach($volumeSerial in $volumeInformation.keys){                        
if($WMIRegistryMountedDeviceInfo.containsKey($volumeSerial)){                        
$volumeInformation[$volumeSerial]["diskPartitionStartingOffset"]=$WMIRegistryMountedDeviceInfo[$volumeSerial].diskPartitionStartingOffset
$volumeInformation[$volumeSerial]["diskDriveSignature"]=$WMIRegistryMountedDeviceInfo[$volumeSerial].diskDriveSignature
$volumeInformation[$volumeSerial]["wmiValueRegistry"]=$WMIRegistryMountedDeviceInfo[$volumeSerial].wmiValue
}   
}
return $volumeInformation
}
function getWMIVolumeInformation{
param($computerName, $credential)
$diskToVolumeAssociation = @{}
$regexGetVolumeSerial = ".*Volume{(.*)}.*"
$wmiVolumes = $null
$wmiVolumes = Get-WmiObject Win32_Volume -Credential $credential -ComputerName $computerName -filter "DriveType != 5" -ErrorVariable errorWMIVolume -ErrorAction SilentlyContinue
$volumeInfo = @{}
$wmiVolumes |   Foreach-Object {
$wmiVolume = $_
if($wmiVolume.DeviceID -match  $regexGetVolumeSerial){
$wmiVolumeSerial = $Matches[1]
$volumeInfo[$wmiVolumeSerial] = @{}
$volumeInfo[$wmiVolumeSerial]["wmiInfo"] = $wmiVolume
$volumeInfo[$wmiVolumeSerial]["volumeDirectoryName"] = $wmiVolume.Name
$volumeInfo[$wmiVolumeSerial]["label"] = $wmiVolume.label
$volumeInfo[$wmiVolumeSerial]["serial"] = $wmiVolumeSerial
$volumeInfo[$wmiVolumeSerial]["capacity"] = $wmiVolume.Capacity
$volumeInfo[$wmiVolumeSerial]["freeSpace"] = $wmiVolume.FreeSpace
}
}
return $volumeInfo  
}
function WMIRegistryMountedDeviceInfo{
param($computerName, $mycreds)
$MountPointRegistryInformation = @{}
$hklm = 2147483650
$registryKeyMountedDevices = "SYSTEM\MountedDevices"
$regexMountPoint = ".*{(.*)}.*"
$wmi = get-wmiobject -list "StdRegProv" -namespace root\default -computername $computerName -credential $mycreds
$wmiMountedDeviceKey = ($wmi.EnumValues($hklm,$registryKeyMountedDevices))
foreach($mountedDeviceRegistryName in $wmiMountedDeviceKey.sNames){
if($mountedDeviceRegistryName -match $regexMountPoint){
$wmiValue = ($wmi.GetBinaryValue($hklm,$registryKeyMountedDevices,$mountedDeviceRegistryName))
if($wmiValue.uValue.Count -eq 12){
$diskDriveSignature = [bitconverter]::ToUInt32($wmiValue.uValue[0..3],0)
$diskPartitionStartingOffset = [bitconverter]::ToUInt64($wmiValue.uValue[4..11],0)
$MountPointRegistryInformation[$Matches[1]]=@{"serial"=$Matches[1];
"mountedDeviceRegistryName"=$mountedDeviceRegistryName;
"diskDriveSignature"=$diskDriveSignature;
"diskPartitionStartingOffset"=$diskPartitionStartingOffset;
"wmiValue"=$wmiValue.uValue}
}
}      
}
return $MountPointRegistryInformation
}

Ce code devrait donner en retour vous chaque signature d'une table de hachage avec le lecteur de disque de la signature du disque qui sont associées avec le mountedDevice. Il renvoie également DiskPartitionStartingOffset que sera la même que la partition.StartingOffset associés à la mountedDevice.

Si vous voulez écrire le code vous-même, les 4 premiers octets de ce registre SYSTEM\MountedDevices valeur sont le lecteur de disque signature mais attention les little-endian. Les 8 octets sont les PartitionStartingOffset.

Avec cette information, vous pouvez utiliser WMI pour obtenir de lecteur de disque de l'information et de brancher le tout pour vraiment obtenir tout le volume relatif à tous les lecteurs physiques, vous avez indépendamment de la façon dont ils sont montés.

Cela ne marche pas pour un volume fractionné.

Être très prudent lors de la lecture dans ce genre de registre.

OriginalL'auteur Alex

ici est une autre alternative en utilisant le noyau. Microsoft conseille contre il, mais il a montré pour être très efficace dans le piégeage volume fractionné, le point de montage et autres type de volume de l'information pour aider à associer le disque et le volume.

 $scriptBlockInvokeCommandKernel32 = {
param([array]$arrayOfVolumeSerial)
$cSharpCodeKernel32GetDisk = @"
using System;
using Microsoft.Win32.SafeHandles;
using System.IO;
using System.Runtime.InteropServices;
public class GetDisk
{
private const uint IoctlVolumeGetVolumeDiskExtents = 0x560000;
private const uint HASMOREDATA = 234;
//4 rounded to 8 + 8 + 8= 24
[StructLayout(LayoutKind.Sequential)]
public struct DiskExtent
{
public int DiskNumber;
public Int64 StartingOffset;
public Int64 ExtentLength;
}
//size 4 rounded to 8 + number of extends * 24
[StructLayout(LayoutKind.Sequential)]
public struct DiskExtents
{
public int numberOfExtents;
public DiskExtent extents;
}
//4
[StructLayout(LayoutKind.Sequential)]
public struct DiskExtentsBeforeArray
{
public int numberOfExtents;
}
[DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
private static extern SafeFileHandle CreateFile(
string lpFileName,
[MarshalAs(UnmanagedType.U4)] FileAccess dwDesiredAccess,
[MarshalAs(UnmanagedType.U4)] FileShare dwShareMode,
IntPtr lpSecurityAttributes,
[MarshalAs(UnmanagedType.U4)] FileMode dwCreationDisposition,
[MarshalAs(UnmanagedType.U4)] FileAttributes dwFlagsAndAttributes,
IntPtr hTemplateFile
);
[DllImport("Kernel32.dll", SetLastError = false, CharSet = CharSet.Auto)]
private static extern bool DeviceIoControl(
SafeFileHandle hDevice,
uint IoControlCode,
[MarshalAs(UnmanagedType.AsAny)] [In] object InBuffer,
uint nInBufferSize,
ref DiskExtents OutBuffer,
int nOutBufferSize,
ref uint pBytesReturned,
IntPtr Overlapped
);
[DllImport("Kernel32.dll", SetLastError = false, CharSet = CharSet.Auto)]
private static extern bool DeviceIoControl(
SafeFileHandle hDevice,
uint IoControlCode,
[MarshalAs(UnmanagedType.AsAny)] [In] object InBuffer,
uint nInBufferSize,
IntPtr outBuffer,
int nOutBufferSize,
ref uint pBytesReturned,
IntPtr Overlapped
);
[DllImport("Kernel32.dll", SetLastError = false, CharSet = CharSet.Auto)]
private static extern int GetLastError();
public static DiskExtent[] GetPhysicalDriveString(string path)
{
DiskExtent[] diskExtent = null;
path = path.TrimEnd('\\');
if (!path.StartsWith(@"\\.\"))
path = @"\\.\" + path;
SafeFileHandle safeFileHandle = CreateFile(path, FileAccess.Read, FileShare.Read | FileShare.Write, IntPtr.Zero, FileMode.Open, 0,
IntPtr.Zero);
if (safeFileHandle.IsInvalid)
{
Exception e = Marshal.GetExceptionForHR(Marshal.GetLastWin32Error());
}
uint bytesReturned = new uint();
DiskExtents VOLUME_DISK_EXTENTS = new DiskExtents();
bool result = DeviceIoControl(
safeFileHandle,
IoctlVolumeGetVolumeDiskExtents,
IntPtr.Zero,
0,
ref VOLUME_DISK_EXTENTS,
Marshal.SizeOf(VOLUME_DISK_EXTENTS),
ref bytesReturned,
IntPtr.Zero);
if (result)
{
diskExtent = new DiskExtent[1];
diskExtent[0] = VOLUME_DISK_EXTENTS.extents; 
}
else
{
int numberOfExtents = VOLUME_DISK_EXTENTS.numberOfExtents;
int lastError = GetLastError();
if (lastError == HASMOREDATA)
{
int size = 8 + 24 * numberOfExtents;
uint bytesReturned2 = new uint();
IntPtr blob = default(IntPtr);
blob = Marshal.AllocHGlobal(size);
bool resultMutipleDiskExtent = DeviceIoControl(
safeFileHandle,
IoctlVolumeGetVolumeDiskExtents,
IntPtr.Zero,
0,
blob,
(int)size,
ref bytesReturned2,
IntPtr.Zero
);
if (resultMutipleDiskExtent)
{
DiskExtentsBeforeArray lie = default(DiskExtentsBeforeArray);
lie = (DiskExtentsBeforeArray)Marshal.PtrToStructure(blob, typeof(DiskExtentsBeforeArray));
diskExtent = new DiskExtent[lie.numberOfExtents];
for (int i = 0; i <= lie.numberOfExtents - 1; i++)
{
IntPtr offset = new IntPtr(blob.ToInt64() + 8 + 24 * i);
diskExtent[i] = (DiskExtent)Marshal.PtrToStructure(offset, typeof(DiskExtent));
}
}
}
else{
throw new System.ComponentModel.Win32Exception();
}   
}
safeFileHandle.Close();
return diskExtent;
}
} 
"@
$resultOfOperation =@{}
$volumeKernelInfo =@{} 
$type = Add-Type -TypeDefinition $cSharpCodeKernel32GetDisk -ErrorAction Continue -ErrorVariable errorAddType -PassThru
if($errorAddType){
$resultOfOperation["error"]= ("error at CsharpBuild" + $errorAddType)
}
foreach($volumeSerial in $arrayOfVolumeSerial){
$volumeString = "Volume{" + $volumeSerial + "}"
$volumeKernelInfo[$volumeSerial] = [GetDisk]::GetPhysicalDriveString($volumeString)
}
$resultOfOperation["volumeKernelInfo"]=$volumeKernelInfo
return $resultOfOperation
}

vous pouvez l'appeler avec :

$resultVolumeMappingFromKernel = Invoke-Command -ScriptBlock $scriptBlockInvokeCommandKernel32 -ComputerName $hostName -Credential $credential -ArgumentList (,$arrayOfVolumeSerial)

Il doit être exécuté sur la machine distante, vous voulez de l'information avec un compte administrateur.

OriginalL'auteur Alex