12/1 – Resolution and Response To Comments

We have fixed KB3000853 both on Windows update and on download center, the KB article has also been updated to reflect the issue and resolution:

Known issues in this update

Symptom
Volume Shadow Copy Service (VSS) backups might fail after you install update 3000853. This issue occurs because an incorrect version of hotfix 2996928 was included in KB3000853.
Resolution
The KB3000853 update was re-released on November 25, 2014 to include the correct version of hotfix 2996928. If you have downloaded and installed a version of update 3000853 that is earlier than the November 25, 2014 version, you can obtain and install the revised update through Windows Update or by downloading the update from the Microsoft Download Center. Alternatively, you can install hotfix 2996928 separately.

Just to reiterate this issues only effected Windows Server 2012 systems.

-taylorb

11/24 – Update and Response To Comments

• To our knowledge this issue only effects Windows Server 2012
• While KB3000853 does include KB2996928, it has the wrong version of the update.  Hence installing the downloaded copy of KB2996928 (which includes the correct version of the binary) addresses the issue.
• We are working to fix KB3000853 to include the correct content, re-test the update and then replace the broken version on Windows Update and DLC.

-taylorb

11/19 – Original Post

We are getting reports that some customers are seeing backup jobs fail after installing the latest Windows Updates including the November rollup (https://support.microsoft.com/kb/3000853). 

We believe there is an issue with the KB3000853 update and are working to fix it as quickly as possible, in the interim downloading and applying https://support.microsoft.com/kb/2996928/ should address the problem.

I do personally want to apologize for the inconvenience or stress this may have caused – as soon as I have more details I will update this post.

-taylorb

$vmName = "Demo"

#Get an instance of the management service, the Msvm Computer System and setting data
$Msvm_VirtualSystemManagementService = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_VirtualSystemManagementService
$Msvm_ComputerSystem = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_ComputerSystem -Filter "ElementName='$vmName'"
$Msvm_VirtualSystemSettingData = $Msvm_ComputerSystem.GetRelated(
    "Msvm_VirtualSystemSettingData",
    "Msvm_SettingsDefineState",
    $null,
    $null,
    "SettingData",
    "ManagedElement",
    $false,
    $null)

#Get an instance of the port setting data object and the related guest network configuration object
$Msvm_SyntheticEthernetPortSettingData = $Msvm_VirtualSystemSettingData.GetRelated("Msvm_SyntheticEthernetPortSettingData")
$Msvm_GuestNetworkAdapterConfigurations = $Msvm_SyntheticEthernetPortSettingData.GetRelated(
    "Msvm_GuestNetworkAdapterConfiguration",
    "Msvm_SettingDataComponent",
    $null,
    $null,
    "PartComponent",
    "GroupComponent",
    $false,
    $null)
$Msvm_GuestNetworkAdapterConfiguration = ($Msvm_GuestNetworkAdapterConfigurations | % {$_})

#Set the IP address and related information
$Msvm_GuestNetworkAdapterConfiguration.DHCPEnabled = $false
$Msvm_GuestNetworkAdapterConfiguration.IPAddresses = @("192.168.0.10")
$Msvm_GuestNetworkAdapterConfiguration.Subnets = @("255.255.255.0")
$Msvm_GuestNetworkAdapterConfiguration.DefaultGateways = @("192.168.0.1")
$Msvm_GuestNetworkAdapterConfiguration.DNSServers = @("192.168.0.2", "192.168.0.3")

#Set the IP address
$Msvm_VirtualSystemManagementService.SetGuestNetworkAdapterConfiguration(
    $Msvm_ComputerSystem.Path,
    $Msvm_GuestNetworkAdapterConfiguration[0].GetText(1))

Set-GuestNetworkIP.ps1

We just had a fantastic session at TechEd Europe showcasing the next evolution in Hyper-V backup and restore coming with Windows vNext (currently available as a Technical Preview).  Once the session recording is live I will post a link but for those folks in the room here is the PowerShell module I wrote for the demo's.  As I mentioned in the session please try give our new backup and restore scenarios a try and submit feedback so that we can make sure the next release of Hyper-V backup has the most reliable, scalable and preformat backup and restore solution possible.  Thanks!

The module is also attached to this post at the bottom.

-taylorb

# ProcessWMIJob is a generic function that waits for WMI job's to
#  complete and returns appropriate success/failure cases.
#  This function was originally written and documented on
#  Taylor Brown's blog at:
#  https://blogs.msdn.com/b/taylorb/archive/2008/06/18/hyper-v-wmi-rich-error-messages-for-non-zero-returnvalue-no-more-32773-32768-32700.aspx
filter ProcessWMIJob
{
    param
    (
        [WMI]$WmiClass = $null,
        [string]$MethodName = $null
    )
 $errorCode = 0
    $returnObject = $_

    if ($_.ReturnValue -eq 4096)
    {
        $Job = [WMI]$_.Job
        $returnObject = $Job

        while ($Job.JobState -eq 4)
        {
            Write-Progress -Activity $Job.Caption -Status ($Job.JobStatus + " - " + $Job.PercentComplete + "%") -PercentComplete $Job.PercentComplete
            Start-Sleep -seconds 1
            $Job.PSBase.Get()
        }
        if ($Job.JobState -ne 7)
        {
   if ($Job.ErrorDescription -ne "")
   {
             Write-Error $Job.ErrorDescription
             Throw $Job.ErrorDescription
   }
   else
   {
    $errorCode = $Job.ErrorCode
   }
        }
        Write-Progress -Activity $Job.Caption -Status $Job.JobStatus -PercentComplete 100 -Completed:$true
       
    }
 elseif($_.ReturnValue -ne 0)
 {
  $errorCode = $_.ReturnValue
 }
 
 if ($errorCode -ne 0)
    {
        Write-Error "Hyper-V WMI Job Failed!"
        if ($WmiClass -and $MethodName)
        {
            $psWmiClass = [WmiClass]("\\" + $WmiClass.__SERVER + "\" + $WmiClass.__NAMESPACE + ":" + $WmiClass.__CLASS)
            $psWmiClass.PSBase.Options.UseAmendedQualifiers = $TRUE
            $MethodQualifierValues = ($psWmiClass.PSBase.Methods[$MethodName].Qualifiers)["Values"]
            $indexOfError = [System.Array]::IndexOf(($psWmiClass.PSBase.Methods[$MethodName].Qualifiers)["ValueMap"].Value, [string]$errorCode)
            if (($indexOfError -ne "-1") -and $MethodQualifierValues)
            {
                Throw "ReturnCode: ", $errorCode, " ErrorMessage: '", $MethodQualifierValues.Value[$indexOfError], "' - when calling $MethodName"
            }
            else
            {
                Throw "ReturnCode: ", $errorCode, " ErrorMessage: 'MessageNotFound' - when calling $MethodName"
            }
        }
        else
        {
            Throw "ReturnCode: ", $errorCode, "When calling $MethodName - for rich error messages provide classpath and method name."
        }
    }
 return $returnObject
}

function Convert-VmBackupCheckpoint
{
    Param(
      [Parameter(Mandatory=$True)]
      [System.Management.ManagementObject]$BackupCheckpoint = $null
    )

    # Retrieve an instance of the snapshot management service
    $Msvm_VirtualSystemSnapshotService = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_VirtualSystemSnapshotService

    # Convert the snapshot to a reference point, this function returns a job object.
    $job = $Msvm_VirtualSystemSnapshotService.ConvertToReferencePoint($BackupSnapshot)

    # Wait for the job to complete.
    ($job | ProcessWMIJob -WmiClass $Msvm_VirtualSystemSnapshotService -MethodName "ConvertToReferencePoint") | Out-Null

    # The new reference point object is related to the job, GetReleated
    #   always returns an array in this case there is only one member
    $refPoint = (([WMI]$job.Job).GetRelated("Msvm_VirtualSystemReferencePoint") | % {$_})

    # Return the reference point object
    return $refPoint
}

function Export-VMBackupCheckpoint
{
    Param(
      [Parameter(Mandatory=$True)]
      [string]$VmName = [String]::Empty,

      [Parameter(Mandatory=$True)]
      [string]$DestinationPath = [String]::Empty,

      [Parameter(Mandatory=$True)]
      [System.Management.ManagementObject]$BackupCheckpoint = $null,

      [System.Management.ManagementObject]$ReferencePoint = $null,

      [bool]$noWait = $false
    )

    # Retrieve an instance of the virtual machine management service
    $Msvm_VirtualSystemManagementService = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_VirtualSystemManagementService

    # Retrieve an instance of the virtual machine computer system that will be snapshoted
    $Msvm_ComputerSystem = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_ComputerSystem -Filter "ElementName='$vmName'"

    # Retrieve an instance of the Export Setting Data Class (this is used to inform the export operation)
    #  GetReleated always returns an array in this case there is only one member
    $Msvm_VirtualSystemExportSettingData = ($Msvm_ComputerSystem.GetRelated("Msvm_VirtualSystemExportSettingData","Msvm_SystemExportSettingData",$null,$null, $null, $null, $false, $null) | % {$_})

    # Specify the export options
        #   CopySnapshotConfiguration
        #      0: ExportAllSnapshots - All snapshots will be exported with the VM.
        #      1: ExportNoSnapshots - No snapshots will be exported with the VM.
        #      2: ExportOneSnapshot - The snapshot identified by the SnapshotVirtualSystem property will be exported with the VM.
        #      3: ExportOneSnapshotUseVmId  - The snapshot identified by the SnapshotVirtualSystem property will be exported with the VM. Using the VMs ID.
        $Msvm_VirtualSystemExportSettingData.CopySnapshotConfiguration = 3

        #   CopyVmRuntimeInformation
        #      Indicates whether the VM runtime information will be copied when the VM is exported. (i.e. saved state)
        $Msvm_VirtualSystemExportSettingData.CopyVmRuntimeInformation = $false

        #   CopyVmStorage
        #      Indicates whether the VM storage will be copied when the VM is exported.  (i.e. VHDs/VHDx files)
        $Msvm_VirtualSystemExportSettingData.CopyVmStorage = $true

        #   CreateVmExportSubdirectory
        #      Indicates whether a subdirectory with the name of the VM will be created when the VM is exported.
        $Msvm_VirtualSystemExportSettingData.CreateVmExportSubdirectory = $false

        #   SnapshotVirtualSystem
        #      Path to a Msvm_VirtualSystemSettingData instance that represents the snapshot to be exported with the VM.
        $Msvm_VirtualSystemExportSettingData.SnapshotVirtualSystem = $BackupSnapshot

        #   DifferentialBase
        #      Base for differential export. This is either path to a Msvm_VirtualSystemReferencePoint instance that
        #         represents the reference point or path to a Msvm_VirtualSystemSettingData instance that
        #         represents the snapshot to be used as a base for differential export. If the CopySnapshotConfiguration
        #         property is not set to 3(ExportOneSnapshotUseVmId), this property is ignored."
        $Msvm_VirtualSystemExportSettingData.DifferentialBase = $ReferenceSnapshot

        #   StorageConfiguration
        #      Indicates what should be the VHD path in the exported configuration.
        #        0: StorageConfigurationCurrent - The exported configuration would point to the current VHD.
        #        1: StorageConfigurationBaseVhd - The exported configuration would point to the base VHD.
        $Msvm_VirtualSystemExportSettingData.StorageConfiguration = 1

    #Export the virtual machine snapshot, this method returns a job object.
    $job = $Msvm_VirtualSystemManagementService.ExportSystemDefinition($Msvm_ComputerSystem, $DestinationPath, $Msvm_VirtualSystemExportSettingData.GetText(1))

    if (!$noWait)
    {
        ($job | ProcessWMIJob -WmiClass $Msvm_VirtualSystemManagementService -MethodName "ExportSystemDefinition") | Out-Null
    }
}

function Get-VmBackupCheckpoints
{
    Param(
      [Parameter(Mandatory=$True)]
      [string]$VmName = [String]::Empty
    )

    # Retrieve an instance of the virtual machine computer system that contains recovery checkpoints
    $Msvm_ComputerSystem = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_ComputerSystem -Filter "ElementName='$VmName'"

    # Retrieve all snapshot associations for the virtual machine
    $allSnapshotAssociations = $Msvm_ComputerSystem.GetRelationships("Msvm_SnapshotOfVirtualSystem")

    # Enumerate across all of the instances and add all recovery snapshots to an array
    $virtualSystemSnapshots = @()
    $enum = $allSnapshotAssociations.GetEnumerator()
    $enum.Reset()
    while($enum.MoveNext())
    {
        if (([WMI] $enum.Current.Dependent).VirtualSystemType -eq "Microsoft:Hyper-V:Snapshot:Recovery")
        {
            $virtualSystemSnapshots += ([WMI] $enum.Current.Dependent)
        }
    }

    # Return the array of recovery snapshots
    $virtualSystemSnapshots
}

function Get-VmReferencePoints
{
    Param(
      [Parameter(Mandatory=$True)]
      [string]$VmName = [String]::Empty
    )

    # Retrieve an instance of the virtual machine computer system that contains reference points
    $Msvm_ComputerSystem = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_ComputerSystem -Filter "ElementName='$VmName'"

    # Retrieve all refrence associations of the virtual machine
    $allrefPoints = $Msvm_ComputerSystem.GetRelationships("Msvm_ReferencePointOfVirtualSystem")

    # Enumerate across all of the instances and add all recovery points to an array
    $virtualSystemRefPoint = @()
    $enum = $allrefPoints.GetEnumerator()
    $enum.Reset()
    while($enum.MoveNext())
    {
        $virtualSystemRefPoint += ([WMI] $enum.Current.Dependent)
    }

    # Return the array of recovery points
    $virtualSystemRefPoint
}

function New-VmBackupCheckpoint
{
    Param(
      [Parameter(Mandatory=$True)]
      [string]$VmName = [String]::Empty,
      [ValidateSet('ApplicationConsistent','CrashConsistent')]
      [string]$ConsistencyLevel = "Application Consistent"
    )

    # Retrieve an instance of the virtual machine management service
    $Msvm_VirtualSystemManagementService = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_VirtualSystemManagementService

    # Retrieve an instance of the virtual machine snapshot service
    $Msvm_VirtualSystemSnapshotService = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_VirtualSystemSnapshotService

    # Retrieve an instance of the virtual machine computer system that will be snapshotted
    $Msvm_ComputerSystem = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_ComputerSystem -Filter "ElementName='$vmName'"

    # Create an instance of the Msvm_VirtualSystemSnapshotSettingData, this class provides options on how the checkpoint will be created.
    $Msvm_VirtualSystemSnapshotSettingData = ([WMIClass]"\\.\root\virtualization\v2:Msvm_VirtualSystemSnapshotSettingData").CreateInstance()

    # Identify the consistency level for the snapshot.
    #  1:  Application Consistent
    #  2:  Crash Consistent
    switch ($ConsistencyLevel)
    {
        "ApplicationConsistent" {
        $Msvm_VirtualSystemSnapshotSettingData.ConsistencyLevel = 1
        }

        "CrashConsistent" {
        $Msvm_VirtualSystemSnapshotSettingData.ConsistencyLevel = 2
        }

        default {
        throw "Unexpected Consistancy Level Specified"
        }
    }

    # Specify the behavior for disks that cannot be snapshotted (i.e. pass-through, virtual fibre channel)
    $Msvm_VirtualSystemSnapshotSettingData.IgnoreNonSnapshottableDisks = $true

    # Create the virtual machine snapshot, this method returns a job object.
    $job = $Msvm_VirtualSystemSnapshotService.CreateSnapshot(
        $Msvm_ComputerSystem,
        $Msvm_VirtualSystemSnapshotSettingData.GetText(2),
        32768)

    # Waits for the job to complete and processes any errors.
    ($job | ProcessWMIJob -WmiClass $Msvm_VirtualSystemSnapshotService -MethodName "CreateSnapshot") | Out-Null

    # Retrieves the snapshot object resulting from the snapshot.
    $snapshot = (([WMI]$job.Job).GetRelated("Msvm_VirtualSystemSettingData") | % {$_})

    # Returns the snapshot instance
    return $snapshot
}

function Remove-VmReferencePoint
{
    Param(
      [Parameter(Mandatory=$True)]
      [System.Management.ManagementObject]$ReferencePoint = $null
    )

    # Retrieve an instance of the virtual machine refrence point service
    $Msvm_VirtualSystemReferencePointService = Get-WmiObject -Namespace root\virtualization\v2 -Class Msvm_VirtualSystemReferencePointService

    # Removes the virtual machine reference, this method returns a job object.
    $job = $Msvm_VirtualSystemReferencePointService.DestroyReferencePoint($ReferenceSnapshot)

    # Waits for the job to complete and processes any errors.
    ($job | ProcessWMIJob -WmiClass $Msvm_VirtualSystemReferencePointService -MethodName "DestroyReferencePoint") | Out-Null
}

HyperVBackup.psm1

Windows Server 2012 Security Guide For Hyper-V

https://technet.microsoft.com/en-us/library/dn741280.aspx

This release of the Hyper-V Security Guide consists of this Overview and chapters that discuss methods and best practices that will help you secure your Hyper-V environment. Brief descriptions follow for each chapter.

Chapter 1: Overview

This chapter provides necessary prerequisite information on Hyper-V to set the groundwork for subsequent material. In addition to the architecture of Hyper-V it also covers the administrator taxonomy in Hyper-V.

Chapter 2: Hardening the Hyper-V host

This chapter focuses on hardening servers that run the Hyper-V role of Windows Server 2012, in both Full and Server Core installations. It contains security best practice recommendations to help protect against unauthorized access and resource tampering.

Chapter 3: Roles & Delegation

This chapter covers details on delegation of access to resources. Additionally, it includes guidance on effective delegation of administrative roles to ensure security.

Chapter 4: Protecting Virtual Machines

This chapter provides prescriptive guidance for securing virtual machine resources. It discusses best practices and includes detailed steps for protecting virtual machines by using a combination of file system permissions, encryption, and auditing. Also included are resources for hardening and updating the operating system instances running within your virtual machines.

Chapter 5: Best Practices Checklist

The chapter covers recommended best practices that help enhance the security of a Hyper-V deployment.

QFE Released for Hyper-V Backup Failures When Utilizing the CSV Writer on Windows Server 2012 R2

Title:               Backing up virtual machines fails when using the CSV writer after installation of update 2919355 in Windows
KB Number:  2966407
URL:               https://support.microsoft.com/kb/2966407

This QFE only effects folks with backup solutions that leverage the cluster shared volume writer on Windows Server 2012 R2 after installing the April update (KB2919355).

-taylorb

-taylorb

Starting Page for All Sessions

https://channel9.msdn.com/Events/TechEd/NorthAmerica/2014

Sessions I Presented

Converged Networking for Windows Server 2012 R2 Hyper-V

Building a Backup Strategy for Your Private Cloud

Other Sessions I Recommend

File Server Networking for a Private Cloud Storage Infrastructure in Windows Server 2012 R2

Migrating to Hyper-V Using the Microsoft Virtual Machine Converter Tool

Secure Design and Best Practices for Your Private Cloud

Extend Datacenter Networking with Partner Solutions

-taylorb

I have two samples below, the first one simply imports a VM and the second renames the VM as part of the import.  You can get more information about the ImportSystemDefinition API at https://msdn.microsoft.com/en-us/library/hh850082(v=vs.85).aspx.  We also have some additional samples utilizing planned virtual machines in our common sample code at https://msdn.microsoft.com/en-us/library/hh850032(v=vs.85).aspx.

Importing a VM

#Retrieve the management service
$VmMgmtSvc = Get-WmiObject -Namespace root\virtualization\v2 `
      -Class Msvm_VirtualSystemManagementService

#Import the VM, referencing the VM configuration, snapshot folder
$ImportedSystem_ret = $VmMgmtSvc.ImportSystemDefinition(
    "D:\Demo\Virtual Machines\1B3CDA1D-6FB6-4AAE-8E8D-8BE6BB587BD3.XML",
    "D:\Demo\Snapshots",
    $false) #Retaining the VM id

#Retrieve the object referencing the planned VM
$PlannedVM = [WMI]$ImportedSystem_ret.ImportedSystem

#Realize the planned VM
$VmMgmtSvc.RealizePlannedSystem($PlannedVM)

Modifying a VM as part of import

#Retrieve the management service
$VmMgmtSvc = Get-WmiObject -Namespace root\virtualization\v2 `
      -Class Msvm_VirtualSystemManagementService

#Import the VM, referencing the VM configuration, snapshot folder
$ImportedSystem_ret = $VmMgmtSvc.ImportSystemDefinition(
    "D:\Demo\Virtual Machines\1B3CDA1D-6FB6-4AAE-8E8D-8BE6BB587BD3.XML",
    "D:\Demo\Snapshots",
    $false) #Retaining the VM id

#Retrieve the object referencing the planned VM
$PlannedVM = [WMi]$ImportedSystem_ret.ImportedSystem

#Retrieve the setting data for the planned VM
$VmSetData = ($PlannedVM.GetRelated("Msvm_VirtualSystemSettingData", `
      "Msvm_SettingsDefineState", `
      $null, `
      $null, `
      "SettingData", `
      "ManagedElement", `
      $false, $null) | % {$_})

#Modify the name of the VM
$VmSetData.ElementName = "NewVMName"
$VmMgmtSvc.ModifySystemSettings($VmSetData.GetText(2))

#Realize the planned VM
$VmMgmtSvc.RealizePlannedSystem($PlannedVM)

-Taylorb

$vmName = "Template"

 #Retrieve the Hyper-V Management Service, ComputerSystem class for the VM and the VM’s SettingData class. 
$Msvm_VirtualSystemManagementService = Get-WmiObject -Namespace root\virtualization\v2 `
      -Class Msvm_VirtualSystemManagementService 

$Msvm_ComputerSystem = Get-WmiObject -Namespace root\virtualization\v2 `
      -Class Msvm_ComputerSystem -Filter "ElementName='$vmName'" 

$Msvm_VirtualSystemSettingData = ($Msvm_ComputerSystem.GetRelated("Msvm_VirtualSystemSettingData", `
     "Msvm_SettingsDefineState", `
      $null, `
      $null, ` 
     "SettingData", `
     "ManagedElement", `
      $false, $null) | % {$_}) 

#Retrieve the Msvm_MemorySettingData Associated to the VM. 
$Msvm_MemorySettingData = ($Msvm_VirtualSystemSettingData.GetRelated( "Msvm_MemorySettingData") | % {$_})

#Enable Dynamic Memory
$Msvm_MemorySettingData.DynamicMemoryEnabled = $true

#Dynamic Memory and Virtual NUMA can not be enabled at the same time
if ($Msvm_MemorySettingData.DynamicMemoryEnabled)
{
    $Msvm_VirtualSystemSettingData.VirtualNumaEnabled = $false

    #Reservation is equavilant to minimum memory
    $Msvm_MemorySettingData.Reservation = 1024

    #VirtualQuantity is equavilant to startup memory
    $Msvm_MemorySettingData.VirtualQuantity = 2048

    #Limit is equivalnt to Maximum Memory
    $Msvm_MemorySettingData.Limit = 8096
}
else
{
    $Msvm_VirtualSystemSettingData.VirtualNumaEnabled = $true
    
    #VirtualQuantity is the static allocation amount
    $Msvm_MemorySettingData.VirtualQuantity = 4096
}

#First apply the Virtual NUMA changes then Apply The Memory Changes
$Msvm_VirtualSystemManagementService.ModifySystemSettings($Msvm_VirtualSystemSettingData.GetText(2))
$Msvm_VirtualSystemManagementService.ModifyResourceSettings($Msvm_MemorySettingData.GetText(2))

-Taylor Brown
-Program Manager, Hyper-V

Best Practices for Virtualizing & Managing Exchange 2013

-taylorb

Removing a virtual hard disk

$vmName = "Test" 
$vhdPath = "d:\vms\Test.vhdx"

#Retrieve the Hyper-V Management Service, ComputerSystem class for the VM and the VM’s SettingData class. 
$Msvm_VirtualSystemManagementService = Get-WmiObject -Namespace root\virtualization\v2 `
      -Class Msvm_VirtualSystemManagementService 

$Msvm_ComputerSystem = Get-WmiObject -Namespace root\virtualization\v2 `
      -Class Msvm_ComputerSystem -Filter "ElementName='$vmName'" 

$Msvm_VirtualSystemSettingData = ($Msvm_ComputerSystem.GetRelated("Msvm_VirtualSystemSettingData", `
     "Msvm_SettingsDefineState", `
      $null, `
      $null, ` 
     "SettingData", `
     "ManagedElement", `
      $false, $null) | % {$_}) 

#Find the VirtualDisk with the path specified
$virtualHardDisk = $Msvm_VirtualSystemSettingData.GetRelated("Msvm_StorageAllocationSettingData") | Where-Object {
    ($_.HostResource -contains $vhdPath)} 

#Save the associated Disk Drive
$SyntheticDiskDrive = [WMI]$virtualHardDisk.Parent

#Call the RemoveResourceSettings function with the path to virtual hard disk
$Msvm_VirtualSystemManagementService.RemoveResourceSettings($virtualHardDisk)

#Call the RemoveResourceSettings function with the path to disk drive
$Msvm_VirtualSystemManagementService.RemoveResourceSettings($SyntheticDiskDrive)

-Taylor Brown
-Program Manager, Hyper-V