|
<# |
|
.SYNOPSIS |
|
Create a GPU-P Guest driver package. |
|
.DESCRIPTION |
|
Gathers the necessary files for a GPU-P enabled Windows guest to run. |
|
.EXAMPLE |
|
New-GPUPDriverPackage -DestinationPath '.' |
|
.EXAMPLE |
|
New-GPUPDriverPackage -Filter 'nvidia' -DestinationPath '.' |
|
.INPUTS |
|
None. |
|
.OUTPUTS |
|
A driver package .zip |
|
.NOTES |
|
This has some mildly dodgy use of CIM cmdlets... |
|
.COMPONENT |
|
PSHyperTools |
|
.ROLE |
|
GPUP |
|
.FUNCTIONALITY |
|
Creates a guest driver package. |
|
#> |
|
|
|
[CmdletBinding( |
|
SupportsShouldProcess = $true, |
|
PositionalBinding = $true, |
|
DefaultParameterSetName = 'NoPathProvided', |
|
HelpUri = 'http://www.microsoft.com/', |
|
ConfirmImpact = 'Low')] |
|
[Alias()] |
|
[OutputType([String])] |
|
Param ( |
|
# Path to output directory. |
|
# If no file name is specified the filename will be GPUPDriverPackage-YYYYMMMDD.zip |
|
[Parameter( |
|
Mandatory = $false, |
|
ParameterSetName = 'PathProvided', |
|
HelpMessage = "Path to one or more locations.")] |
|
[Alias("PSPath", "Path")] |
|
[ValidateNotNullOrEmpty()] |
|
[string] |
|
$DestinationPath, |
|
|
|
# Device friendly name filter. |
|
# Only devices whose friendly names contain the supplied string will be processed |
|
[Parameter( |
|
Mandatory = $false, |
|
HelpMessage = "Only add drivers for devices whose friendly names contain the supplied string.")] |
|
[ValidateNotNullOrEmpty] |
|
[String] |
|
$Filter |
|
) |
|
|
|
process { |
|
try { |
|
# make me a temporary folder, and assemble the structure |
|
$fTempFolder = Join-Path -Path $Env:TEMP -ChildPath "GPUPDriverPackage" |
|
(New-Item -ItemType Directory -Path "$fTempFolder/System32/HostDriverStore/FileRepository" -Force -ErrorAction SilentlyContinue | Out-Null) |
|
(New-Item -ItemType Directory -Path "$fTempFolder/SysWOW64" -Force -ErrorAction SilentlyContinue | Out-Null) |
|
|
|
# Set default archive name |
|
$ArchiveName = ('GPUPDriverPackage-{0}.zip' -f $(Get-Date -UFormat '+%Y%b%d')) |
|
|
|
# Check if DestinationPath has been provided |
|
if ($PSCmdlet.ParameterSetName -eq "PathProvided") { |
|
switch ($DestinationPath) { |
|
{ (Split-Path -Path $_ -Leaf) -match '(\.zip)' } { |
|
# Path we've been provided is a full file path, so we'll just use it |
|
$ArchiveFolder = Split-Path -Path $DestinationPath -Parent |
|
$ArchiveName = Split-Path -Path $DestinationPath -Leaf |
|
break |
|
} |
|
{ Test-Path -Path $_ -PathType Container } { |
|
# Path exists and is a directory, so we place our file in it with the default name. |
|
$ArchiveFolder = $DestinationPath |
|
break |
|
} |
|
Default { |
|
# Path doesn't end in .zip and doesn't exist, so we're going to assume it's a directory and place the file in it with the default name. |
|
$ArchiveFolder = $DestinationPath |
|
(New-Item -ItemType Directory -Path $ArchiveFolder -Force -ErrorAction SilentlyContinue | Out-Null) |
|
break |
|
} |
|
} |
|
} else { |
|
# if DestinationPath not supplied, use current directory and default name |
|
$ArchiveFolder = (Get-Location).Path |
|
} |
|
|
|
# just double check that one |
|
if (-not $ArchiveFolder) { $ArchiveFolder = (Get-Location).Path } |
|
|
|
Write-Output -InputObject ('Creating GPU-P driver package for host {0}' -f $Env:COMPUTERNAME) |
|
Write-Output -InputObject ('Destination path: {0}' -f (Join-Path -Path $ArchiveFolder -ChildPath $ArchiveName)) |
|
|
|
<# |
|
Determine which cmdlet we should use to gather the list of GPU-P capable GPUs. |
|
On Windows builds before Server 2022/21H2, the cmdlet is 'Get-VMPartitionableGpu' |
|
On later builds, it's 'Get-VMHostPartitionableGpu', and the old cmdlet just prints an error. |
|
So, we check if Get-VMHostPartitionableGpu is a valid cmdlet to determine whether we should use it. |
|
#> |
|
Write-Output -InputObject "Getting all GPU-P capable GPUs in the current system..." |
|
if (Get-Command -Name 'Get-VMHostPartitionableGpu' -ErrorAction SilentlyContinue) { |
|
Write-Verbose -Message 'Using new Get-VMHostPartitionableGpu cmdlet' |
|
$PVCapableGPUs = Get-VMHostPartitionableGpu |
|
} else { |
|
Write-Verbose -Message 'Using old Get-VMPartitionableGpu cmdlet' |
|
$PVCapableGPUs = Get-VMPartitionableGpu |
|
} |
|
|
|
# if we found no GPU-P capable GPUs, throw an exception |
|
if ($PVCapableGPUs.Count -lt 1) { |
|
throw [System.Management.Automation.ItemNotFoundException]::new('Did not find any GPU-P capable GPUs in this system.') |
|
} elseif ($PvGPUs.Count -gt 1) { |
|
Write-Warning -Message ( |
|
("You have {0} GPU-P capable GPUs in this system. `n" -f $PvGPUs.Count) + |
|
" At present, there is no way to control which one is assigned to a given VM.`n" + |
|
" Unless one of the available GPUs is an intel IGP, it is highly recommended`n" + |
|
" that you disable the GPU(s) you do not wish to use.`n") |
|
$choices = '&Yes', '&No' |
|
$question = 'Do you wish to proceed without disabling the extra GPU(s)?' |
|
if ($Host.UI.PromptForChoice('', $question, $choices, 1) -eq 1) { |
|
throw [System.Management.Automation.ActionPreferenceStopException]::new('User requested to cancel.') |
|
} |
|
} |
|
|
|
# Map each PVCapableGPU to the corresponding PnPDevice. Regex (mostly) extracts the InstanceId from the VMPartitionableGpu 'name' property. |
|
Write-Output -InputObject ('Mapping GPU-P capable GPUs to their corresponding PnPDevice objects...') |
|
$InstanceExpr = [regex]::New('^\\\\\?\\(.+)#.*$') |
|
$TargetGPUs = $PVCapableGPUs.Name | ForEach-Object -Process { |
|
# I'm not proud of this dirty regex trick, but it works. |
|
Get-PnpDevice -InstanceId $InstanceExpr.Replace($_, '$1').Replace('#', '\') |
|
} |
|
|
|
# OK, now that we have some actual device names, we can filter them if we've been asked to |
|
if ($null -ne $Filter) { |
|
Write-Output -InputObject ('Applying filter "{0}" to device list...' -f $Filter) |
|
$TargetGPUs = $TargetGPUs | Where-Object { $_.FriendlyName -like ('*{0}*' -f $Filter) } |
|
} |
|
Write-Output -InputObject ('Will create driver package for {0} GPUs:' -f $TargetGPUs.Count) |
|
$TargetGPUs.FriendlyName | ForEach-Object { Write-Output -InputObject (' - {0}' -f $_) } |
|
} catch { throw $PSItem } |
|
|
|
# Last chance to turn back, traveler. Are you sure? |
|
if ($pscmdlet.ShouldProcess("Driver Package", "Create")) { |
|
try { |
|
Write-Output -InputObject ('The next few steps may take some time, depending on how many devices & driver packages are installed.') |
|
Write-Output -InputObject ('If the script appears hung, please give it a few minutes to complete before terminating.') |
|
# Get display class devices |
|
Write-Output -InputObject ('Gathering display device CIM objects...') |
|
$PnPEntities = Get-CimInstance -ClassName 'Win32_PnPEntity' | Where-Object { $_.Class -like 'Display' } |
|
Write-Verbose -Message ('Found {0} display devices' -f $PnPEntities.Count) |
|
($PnPEntities | Format-Table -AutoSize | Out-String).Trim().Split("`n") | ForEach-Object -Process { Write-Verbose -Message (' {0}' -f $_) } |
|
|
|
# Get display class drivers |
|
Write-Output -InputObject ('Gathering display device driver CIM objects...') |
|
$PnPSignedDrivers = Get-CimInstance -ClassName 'Win32_PnPSignedDriver' -Filter "DeviceClass = 'DISPLAY'" |
|
Write-Verbose -Message ('Found {0} display device drivers' -f $PnPSignedDrivers.Count) |
|
$PnPSignedInfo = ($PnPSignedDrivers | Select-Object -Property DeviceName,DriverProviderName,InfName,DriverVersion,Description | Format-Table -AutoSize | Out-String).Trim().Split("`n") |
|
$PnPSignedInfo | ForEach-Object -Process { Write-Verbose -Message (' {0}' -f $_) } |
|
|
|
# next we have to get every PnPSignedDriverCIMDataFile, because Get-CimAssociatedInstance doesn't wanna play ball |
|
Write-Output -InputObject ('Gathering all driver file objects... (this is the slow one. Blame Microsoft.)') # or me not understanding CIM i guess? |
|
$SignedDriverFiles = Get-CimInstance -ClassName 'Win32_PNPSignedDriverCIMDataFile' |
|
Write-Output -InputObject ('Found {0} files across all system drivers.' -f $SignedDriverFiles.Count) |
|
|
|
foreach ($GPU in $TargetGPUs) { |
|
Write-Output -InputObject ('Getting driver package for {0}' -f $GPU.FriendlyName) |
|
$PnPEntity = $PnPEntities | Where-Object { $_.InstanceId -eq $GPU.InstanceId }[0] |
|
Write-Verbose -Message ('Device PnP Entity:') |
|
($PnPEntity | Format-Table -AutoSize | Out-String).Trim().Split("`n") | ForEach-Object -Process { Write-Verbose -Message (' {0}' -f $_) } |
|
|
|
$PnPSignedDriver = $PnPSignedDrivers | Where-Object { $_.DeviceId -eq $GPU.InstanceId } |
|
Write-Verbose -Message ('Device PnPSignedDriver:') |
|
($PnPSignedDriver | Format-Table -AutoSize | Out-String).Trim().Split("`n") | ForEach-Object -Process { Write-Verbose -Message (' {0}' -f $_) } |
|
|
|
$SystemDriver = Get-CimAssociatedInstance -InputObject $PnPEntity -Association Win32_SystemDriverPNPEntity |
|
Write-Verbose -Message ('Device SystemDriver:') |
|
($SystemDriver | Format-Table -AutoSize | Out-String).Trim().Split("`n") | ForEach-Object -Process { Write-Verbose -Message (' {0}' -f $_) } |
|
|
|
Write-Verbose -Message ('SystemDriver main/anchor file: {0}' -f $SystemDriver.PathName) |
|
$DriverStoreFolder = Get-Item -Path (Split-Path -Path $SystemDriver.PathName -Parent) |
|
while ((Get-Item (Split-Path $DriverStoreFolder)).Name -notlike 'FileRepository') { |
|
$DriverStoreFolder = Get-Item -Path (Split-Path -Path $DriverStoreFolder -Parent) |
|
} |
|
Write-Verbose -Message ('Device DriverStoreFolder: {0}' -f $DriverStoreFolder.FullName) |
|
|
|
Write-Output -InputObject ('Found package {0}, copying DriverStore folder {1} to temporary directory' -f $PnPSignedDriver.InfName, (Split-Path $DriverStoreFolder -Leaf)) |
|
$TempDriverStore = ('{0}/System32/HostDriverStore/FileRepository/{1}' -f $fTempFolder, $DriverStoreFolder.Name) |
|
$DriverStoreFolder | Copy-Item -Destination $TempDriverStore -Recurse -Force |
|
Write-Output -InputObject ('Copied {0} of {1} files to temporary directory' -f (Get-ChildItem -Path $TempDriverStore -Recurse).Count, (Get-ChildItem -Path $DriverStoreFolder -Recurse).Count) |
|
|
|
# Get driver files from system32 etc and copy |
|
Write-Output -InputObject ('Gathering files from System32 and SysWOW64') |
|
$DriverFiles = ($SignedDriverFiles | Where-Object { $_.Antecedent.DeviceID -like $GPU.DeviceID }).Dependent.Name | Sort-Object |
|
$NonDriverStoreFiles = $DriverFiles.Where{$_ -notlike '*DriverStore*'} |
|
|
|
Write-Output -InputObject ('Found {0} files, copying to temporary directory...' -f $NonDriverStoreFiles.Count) |
|
$NonDriverStoreFiles | ForEach-Object -Process { |
|
$TargetPath = Join-Path -Path $fTempFolder -ChildPath $_.ToLower().Replace(('{0}\' -f $Env:SYSTEMROOT.ToLower()),'') |
|
# make sure the parent folder exists |
|
(New-Item -ItemType directory -Path (Split-Path -Path $TargetPath -Parent) -Force -ErrorAction SilentlyContinue | Out-Null) |
|
Write-Output -InputObject (' - {0} -> {1}' -f $_, $TargetPath) |
|
Copy-Item -Path $_ -Destination $TargetPath -Force -Recurse |
|
} |
|
Write-Output -InputObject ('Finished gathering files for {0}' -f $GPU.FriendlyName) |
|
} |
|
Write-Output -InputObject ('All driver files have been collected, creating archive file') |
|
$Location = (Get-Location).Path |
|
Set-Location -Path (Split-Path -Path $fTempFolder -Parent) |
|
Compress-Archive -Path $fTempFolder -DestinationPath (Join-Path -Path $ArchiveFolder -ChildPath $ArchiveName) -CompressionLevel Fastest -Confirm:$false |
|
Set-Location -Path $Location |
|
Write-Output -InputObject ('GPU driver package has been created at path {0}\{1}' -f $ArchiveFolder, $ArchiveName) |
|
} catch { |
|
throw $PSItem |
|
} finally { |
|
Write-Output -InputObject ('Cleaning up temporary directory {0}' -f $fTempFolder) |
|
Remove-Item -Recurse -Force -Path $fTempFolder |
|
} |
|
} |
|
Write-Output -InputObject ('Driver package generation complete.') |
|
Write-Output -InputObject ('Please copy it to your guest and extract the archive into C:\Windows\') |
|
} |
If hyper-v can install mac os. This would be fun.