Crescent City Networking » Developing on Windows Virtual PC / Virtual Server / Hyper-V

Using CPU Reserve to enforce virtual processor ratio

Thu, 03 Nov 2011 18:45:00 +0000

On Monday I posted a script for configuring virtual machine CPU scheduler settings. This script got me to thinking about another use for the virtual machine CPU reserve.

You see, it can also be used to ensure that you do not unintentionally start too many virtual machines at once.

If you were to set the CPU reserve on each virtual machine at 20% (or at 20,000 using the underlying API) then it is not possible to start extra virtual machines once you hit a ratio of 5 virtual processors for each physical processor. This is actually what System Center Virtual Machine Manager does to enforce limits on the system.

Here is a script that will do just that:

# Function for handling WMI jobs / return values

Function ProcessResult($result, $successString, $failureString)

{

   #Return success if the return value is "0"

   if ($result.ReturnValue -eq 0)

      {write-host $successString} 

   #If the return value is not "0" or "4096" then the operation failed

   ElseIf ($result.ReturnValue -ne 4096)

      {write-host $failureString " Error value:" $result.ReturnValue}

   Else

      {#Get the job object

      $job=[WMI]$result.job

      #Provide updates if the jobstate is "3" (starting) or "4" (running)

      while ($job.JobState -eq 3 -or $job.JobState -eq 4)

         {write-host $job.PercentComplete "% complete"

          start-sleep 1

          #Refresh the job object

          $job=[WMI]$result.job}

       #A jobstate of "7" means success

       if ($job.JobState -eq 7)

          {write-host $successString}

       Else

          {write-host $failureString

          write-host "ErrorCode:" $job.ErrorCode

          write-host "ErrorDescription" $job.ErrorDescription}

       }

}

# Prompt for the Hyper-V Server to use

$HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

# Prompt for the new CPU reservation

$NewReservation = Read-Host "Specify the CPU reservation (from 0-100000)"

# Get the management service

$VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

# Get all VSSDs for non-snapshots

$VSSDs = gwmi "MSVM_VirtualSystemSettingData" -namespace "root\virtualization" -computername $HyperVServer | ? {$_.SettingType -eq 3}  

foreach ($VSSD in $VSSDs)

   {

   # Get the related VM

   $VM = $VSSD.getRelated("MSVM_ComputerSystem") | select -first 1

   # Get the processor setting data

   $ProcSetting = $VSSD.getRelated("Msvm_ProcessorSettingData") | select -first 1

   # Update ProcSetting with the new value

   $ProcSetting.Reservation = $NewReservation

   # Apply the changes to the processor setting data back to the virtual machine

   $result = $VMMS.ModifyVirtualSystemResources($VM, $ProcSetting.GetText(1))

   # Process the result

   $successMessage = "Updated processor scheduling settings on '" + $VM.ElementName + "'"

   $failureMessage = "Failed to update processor scheduling settings on " + $VM.ElementName + "'"

   ProcessResult $result $successMessage $failureMessage

   }

If you run this script and specify “20000” then you will be able to run at a ratio of 5 virtual processors for each physical processor. If you run this script and specify “25000” then you will be able to run at a ratio of 4 virtual processors for each physical processor.

Note that this will not apply to any virtual machine snapshots, or to any newly created virtual machines, so it is a little fragile as a solution.

Cheers,
Ben

Setting VM CPU scheduler settings with PowerShell [Hyper-V]

Tue, 01 Nov 2011 02:51:19 +0000

A while ago I did a number of posts talking about the different controls that are available to you in regards to how Hyper-V schedules virtual machine processor resources (Hyper-V CPU Scheduling–Part 1, Hyper-V CPU Scheduling–Part 2, Hyper-V CPU Scheduling–Part 3 and Hyper-V CPU Scheduling–Part 4). Today I want to share a PowerShell script that shows you how to configure these settings programmatically:

     # Function for handling WMI jobs / return values

    Function ProcessResult($result, $successString, $failureString)

    {

       #Return success if the return value is "0"

       if ($result.ReturnValue -eq 0)

          {write-host $successString} 

       #If the return value is not "0" or "4096" then the operation failed

       ElseIf ($result.ReturnValue -ne 4096)

          {write-host $failureString "  Error value:" $result.ReturnValue}

       Else

          {#Get the job object

          $job=[WMI]$result.job

          #Provide updates if the jobstate is "3" (starting) or "4" (running)

          while ($job.JobState -eq 3 -or $job.JobState -eq 4)

             {write-host $job.PercentComplete "% complete"

              start-sleep 1

              #Refresh the job object

              $job=[WMI]$result.job}

           #A jobstate of "7" means success

           if ($job.JobState -eq 7)

              {write-host $successString}

           Else

              {write-host $failureString

              write-host "ErrorCode:" $job.ErrorCode

              write-host "ErrorDescription" $job.ErrorDescription}

           }

    }

    # Prompt for the Hyper-V Server to use

    $HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

    # Prompt for the virtual machine to use

    $VMName = Read-Host "Specify the name of the virtual machine"

    # Get the management service

    $VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

    # Get the virtual machine object

    $VM = gwmi MSVM_ComputerSystem -filter "ElementName='$VMName'" -namespace "root\virtualization" -computername $HyperVServer

    # SettingType = 3 ensures that we do not get snapshots

    $SystemSettingData = $VM.getRelated("Msvm_VirtualSystemSettingData") | where {$_.SettingType -eq 3}

    # Get the processor setting data

    $ProcSetting = $SystemSettingData.getRelated("Msvm_ProcessorSettingData") | select -first 1

    # Get new values from the user

    $NewReservation = Read-Host "Specify the CPU reserve (from 0-10000) [Currently:"$ProcSetting.Reservation"]"

    $NewLimit = Read-Host "Specify the CPU limit (from 0-10000) [Currently:"$ProcSetting.Limit"]"

    $NewWeight = Read-Host "Specify the CPU weight (from 0-10000) [Currently:"$ProcSetting.weight"]"

    # Update ProcSetting with the new values

    $ProcSetting.Reservation = $NewReservation

    $ProcSetting.Limit = $NewLimit

    $ProcSetting.weight = $NewWeight

    # Apply the changes to the processor setting data back to the virtual machine

    $result = $VMMS.ModifyVirtualSystemResources($VM, $ProcSetting.GetText(1))

    # Process the result

    ProcessResult $result "Updated processor scheduling settings." "Failed to update processor scheduling settings."

Cheers,
Ben

How many virtual processors does a virtual machine have?

Tue, 25 Oct 2011 15:17:00 +0000

A recent forum poster asked:

How do I write a script that figures out how many virtual processors a virtual machine has, when it is offline (i.e. not running)?

His question showed that he had made a classic mistake when working with the Hyper-V WMI APIs. You see Hyper-V usually has two WMI objects for many parts of the virtual machine – one of them representing the settings and one of them representing the live object itself.

Case in hand: for a virtual processor you have “MSVM_Processor” which represents the live object, and you have “MSVM_ProcessorSettingData” which represents its settings.

Looking at the wrong object at the wrong time can cause problems. Live objects should be used for gathering usage information about running virtual machines – settings object should be used for getting and setting configuration details. 90% of the time – the settings object is what you want (and 90% of the time it is the object that ends with the string “SettingData”).

Here is a simple script that gets a virtual machines processor count using both objects:

# Prompt for the Hyper-V Server to use

$HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

# Prompt for the virtual machine to use

$VMName = Read-Host "Specify the name of the virtual machine"

# Get the management service

$VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

# Get the virtual machine object

$VM = gwmi MSVM_ComputerSystem -filter "ElementName='$VMName'" -namespace "root\virtualization" -computername $HyperVServer

# Set the stage

Write-host "There are two ways to get a virtual machines processor count, the wrong way and the right way..."

write-host

# Let's do the wrong way first

# Get the virtual processor objects

$vProcs = $vm.GetRelated("MSVM_Processor")

write-host

Write-host "Doing it the wrong way (using Msvm_Processor):"

write-host

write-host "The" $VMName "virtual machine is configured with" $vProcs.count "virtual processors."

# Now let's do it the right way

# SettingType = 3 ensures that we do not get snapshots

$SystemSettingData = $VM.getRelated("Msvm_VirtualSystemSettingData") | where {$_.SettingType -eq 3}

# Get the processor setting data

$ProcSetting = $SystemSettingData.getRelated("Msvm_ProcessorSettingData") | select -first 1

write-host

Write-host "Doing it the right way (using Msvm_ProcessorSettingData):"

write-host

write-host "The" $VMName "virtual machine is configured with" $ProcSetting.VirtualQuantity "virtual processors."

If I run this on a running virtual machine – both methods return the same thing:

But if the virtual machine is not running – only the MVSM_ProcessorSettingData actually tells me what I want to know:

Cheers,
Ben

Deleting a snapshot sub-tree–via PowerShell [Hyper-V]

Fri, 21 Oct 2011 17:27:00 +0000

Here is a dangerous script! Given a virtual machine name and a snapshot name, it will delete the specified snapshot *and* any snapshots underneath it in the snapshot tree that Hyper-V manager displays:

# Function for handling WMI jobs / return values

Function ProcessResult($result, $successString, $failureString)

{

   #Return success if the return value is "0"

   if ($result.ReturnValue -eq 0)

      {write-host $successString} 

   #If the return value is not "0" or "4096" then the operation failed

   ElseIf ($result.ReturnValue -ne 4096)

      {write-host $failureString " Error value:" $result.ReturnValue}

   Else

      {#Get the job object

      $job=[WMI]$result.job

      #Provide updates if the jobstate is "3" (starting) or "4" (running)

      while ($job.JobState -eq 3 -or $job.JobState -eq 4)

         {write-host $job.PercentComplete "% complete"

          start-sleep 1

          #Refresh the job object

          $job=[WMI]$result.job}

       #A jobstate of "7" means success

       if ($job.JobState -eq 7)

          {write-host $successString

          return $true}

       Else

          {write-host $failureString

          write-host "ErrorCode:" $job.ErrorCode

          write-host "ErrorDescription" $job.ErrorDescription

          return $false}

       }

}

# Prompt for the Hyper-V Server to use

$HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

# Prompt for the virtual machine to use

$VMName = Read-Host "Specify the name of the virtual machine"

# Prompt for the name of the snapshot to delete the tree from

$SnapshotName = Read-Host "Specify the name of the snapshot to delete the tree from (warning - a lot of snapshots will be deleted)"

# Get the management service

$VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

# Get the virtual machine object

$VM = gwmi MSVM_ComputerSystem -filter "ElementName='$VMName'" -namespace "root\virtualization" -computername $HyperVServer

# Find the snapshot that we want to delete

$Snapshot = gwmi -Namespace root\virtualization -Query "Associators Of {$VM} Where AssocClass=Msvm_ElementSettingData ResultClass=Msvm_VirtualSystemSettingData" | where {$_.ElementName -eq $SnapshotName} | select -first 1

# Delete the snapshot

$result = $VMMS.RemoveVirtualSystemSnapshotTree($Snapshot)

# Check to make sure we succeeded

$deleteSucceeded = ProcessResult $result "Deleted snapshot tree." "Failed to delete snapshot tree."

Note that this script actually uses a different WMI method to delete the snapshot sub-tree (when compared to deleting a single snapshot). There is no way to stop the deletion once it is started, and there is no confirmation prompt in this script – so be careful when you use it!

Cheers,
Ben

Deleting a snapshot–via PowerShell [Hyper-V]

Thu, 20 Oct 2011 17:56:00 +0000

Here is a script that will allow you to delete a single snapshot from a Hyper-V virtual machine:

# Function for handling WMI jobs / return values

Function ProcessResult($result, $successString, $failureString)

{

   #Return success if the return value is "0"

   if ($result.ReturnValue -eq 0)

      {write-host $successString} 

   #If the return value is not "0" or "4096" then the operation failed

   ElseIf ($result.ReturnValue -ne 4096)

      {write-host $failureString " Error value:" $result.ReturnValue}

   Else

      {#Get the job object

      $job=[WMI]$result.job

      #Provide updates if the jobstate is "3" (starting) or "4" (running)

      while ($job.JobState -eq 3 -or $job.JobState -eq 4)

         {write-host $job.PercentComplete "% complete"

          start-sleep 1

          #Refresh the job object

          $job=[WMI]$result.job}

       #A jobstate of "7" means success

       if ($job.JobState -eq 7)

          {write-host $successString

          return $true}

       Else

          {write-host $failureString

          write-host "ErrorCode:" $job.ErrorCode

          write-host "ErrorDescription" $job.ErrorDescription

          return $false}

       }

}

# Prompt for the Hyper-V Server to use

$HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

# Prompt for the virtual machine to use

$VMName = Read-Host "Specify the name of the virtual machine"

# Prompt for the name of the snapshot to delete

$SnapshotName = Read-Host "Specify the name of the snapshot to delete"

# Get the management service

$VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

# Get the virtual machine object

$VM = gwmi MSVM_ComputerSystem -filter "ElementName='$VMName'" -namespace "root\virtualization" -computername $HyperVServer

# Find the snapshot that we want to delete

$Snapshot = gwmi -Namespace root\virtualization -Query "Associators Of {$VM} Where AssocClass=Msvm_ElementSettingData ResultClass=Msvm_VirtualSystemSettingData" | where {$_.ElementName -eq $SnapshotName} | select -first 1

# Delete the snapshot

$result = $VMMS.RemoveVirtualSystemSnapshot($Snapshot)

# Check to make sure we succeeded

$deleteSucceeded = ProcessResult $result "Deleted snapshot." "Failed to delete snapshot."

Cheers,
Ben

Applying a snapshot–via PowerShell [Hyper-V]

Wed, 19 Oct 2011 17:08:00 +0000

Now that we know how to take a snapshot, and how to list snapshots – let’s start applying snapshots:

# Function for handling WMI jobs / return values

Function ProcessResult($result, $successString, $failureString)

{

   #Return success if the return value is "0"

   if ($result.ReturnValue -eq 0)

      {write-host $successString} 

   #If the return value is not "0" or "4096" then the operation failed

   ElseIf ($result.ReturnValue -ne 4096)

      {write-host $failureString " Error value:" $result.ReturnValue}

   Else

      {#Get the job object

      $job=[WMI]$result.job

      #Provide updates if the jobstate is "3" (starting) or "4" (running)

      while ($job.JobState -eq 3 -or $job.JobState -eq 4)

         {write-host $job.PercentComplete "% complete"

          start-sleep 1

          #Refresh the job object

          $job=[WMI]$result.job}

       #A jobstate of "7" means success

       if ($job.JobState -eq 7)

          {write-host $successString

          return $true}

       Else

          {write-host $failureString

          write-host "ErrorCode:" $job.ErrorCode

          write-host "ErrorDescription" $job.ErrorDescription

          return $false}

       }

}

# Prompt for the Hyper-V Server to use

$HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

# Prompt for the virtual machine to use

$VMName = Read-Host "Specify the name of the virtual machine"

# Prompt for the name of the snapshot to apply

$SnapshotName = Read-Host "Specify the name of the snapshot to apply"

# Get the management service

$VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

# Get the virtual machine object

$VM = gwmi MSVM_ComputerSystem -filter "ElementName='$VMName'" -namespace "root\virtualization" -computername $HyperVServer

# Find the snapshot that we want to apply

$Snapshot = gwmi -Namespace root\virtualization -Query "Associators Of {$VM} Where AssocClass=Msvm_ElementSettingData ResultClass=Msvm_VirtualSystemSettingData" | where {$_.ElementName -eq $SnapshotName} | select -first 1

# Apply the snapshot

$result = $VMMS.ApplyVirtualSystemSnapshot($VM, $Snapshot)

# Check to make sure we succeeded

$applySucceeded = ProcessResult $result "Snapshot applied." "Failed to apply snapshot."

This is a fairly standard Hyper-V WMI script. One thing to be aware of is that this operation will fail if the virtual machine is running when you try to apply the snapshot – the virtual machine needs to be turned off or put into a saved state first.

Cheers,
Ben

Listing snapshots–via PowerShell [Hyper-V]

Tue, 18 Oct 2011 16:57:00 +0000

After the relatively trick “taking a snapshot” script – today’s snapshot script is quite easy. Listing the snapshots that a virtual machine has:

# Prompt for the Hyper-V Server to use

$HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

# Prompt for the virtual machine to use

$VMName = Read-Host "Specify the name of the virtual machine"

# Get the management service

$VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

# Get the virtual machine object

$VM = gwmi MSVM_ComputerSystem -filter "ElementName='$VMName'" -namespace "root\virtualization" -computername $HyperVServer

# Get snapshot objects associated with the virtual machine

$Snapshots = gwmi -Namespace root\virtualization -Query "Associators Of {$VM} Where AssocClass=Msvm_ElementSettingData ResultClass=Msvm_VirtualSystemSettingData" 

write-host

write-host $VMName "has the following snapshots:" 

# Display a formatted list of snapshots

$Snapshots | sort CreationTime | Format-Table -Property @{n='Snapshot Name';e={$_.ElementName}}

One thing to point out here is that I am using a WMI query that looks at the association class (MSVM_ElementSettingData) as well as the result class (MSVM_VirtualSystemSettingData). The reason why I do this is that if you grab all MSVM_VirtualSystemSettingData classes that are associated with a virtual machine – you will get two extra entries: one for the active virtual machine, and one for the latest snapshot (which results in one of your snapshots being duplicated). The method that I am using here ensures that you only get snapshots, and you do not get any duplicates.

Cheers,
Ben

Taking a snapshot–via PowerShell [Hyper-V]

Mon, 17 Oct 2011 16:51:00 +0000

This week I am going to be sharing a bunch of scripts that show you how to interact with virtual machine snapshots in Hyper-V. And I am going to start off with the hardest one – taking a snapshot:

# Function for handling WMI jobs / return values

Function ProcessResult($result, $successString, $failureString)

{

   #Return success if the return value is "0"

   if ($result.ReturnValue -eq 0)

      {write-host $successString} 

   #If the return value is not "0" or "4096" then the operation failed

   ElseIf ($result.ReturnValue -ne 4096)

      {write-host $failureString " Error value:" $result.ReturnValue}

   Else

      {#Get the job object

      $job=[WMI]$result.job

      #Provide updates if the jobstate is "3" (starting) or "4" (running)

      while ($job.JobState -eq 3 -or $job.JobState -eq 4)

         {write-host $job.PercentComplete "% complete"

          start-sleep 1

          #Refresh the job object

          $job=[WMI]$result.job}

       #A jobstate of "7" means success

       if ($job.JobState -eq 7)

          {write-host $successString

          return $true}

       Else

          {write-host $failureString

          write-host "ErrorCode:" $job.ErrorCode

          write-host "ErrorDescription" $job.ErrorDescription

          return $false}

       }

}

# Prompt for the Hyper-V Server to use

$HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

# Prompt for the virtual machine to use

$VMName = Read-Host "Specify the name of the virtual machine"

# Prompt for the name of the new snapshot

$SnapshotName = Read-Host "Specify the name of the new snapshot"

# Get the management service

$VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

# Get the virtual machine object

$VM = gwmi MSVM_ComputerSystem -filter "ElementName='$VMName'" -namespace "root\virtualization" -computername $HyperVServer

# Take the snapshot

$result = $VMMS.CreateVirtualSystemSnapshot($VM)

# Process the results

$snapshotSucceeded = ProcessResult $result "The snapshot was taken." "Failed to take snapshot."

# If the snapshot is created - rename it

if ($snapshotSucceeded)

    {

    # Get the job object from the results

    $job2=[WMI]$result.job

    # Get the snapshot that is assocated with the completed job

    $newSnapshot = $job2.GetRelated("Msvm_VirtualSystemSettingData") | select -first 1

    # Change the "ElementName" 

    $newSnapshot.ElementName = $SnapshotName

    # Apply the changes to the snapshot

    $result2 = $VMMS.ModifyVirtualSystem($VM, $newSnapshot.GetText(1))

    # Check to see if renaming the snapshot succeeds

    $renameSucceeded = ProcessResult $result2 "The new snapshot was renamed." "Failed to rename the new snapshot."

    }

The tricky part of this script is not actually taking the snapshot (which is done with CreateVirtualSystemSnapshot) but naming the snapshot after it is taken (Hyper-V always auto-generates a snapshot name for you – and you need to rename it if you want to have a custom snapshot name). Actually, that isn’t hard either – the hard bit is *finding* the snapshot after it is taken in order to name it.

The secret here is that the new snapshot object (in WMI) will actually be associated with the job object once the snapshot is complete. So this script waits for the snapshot job to complete, then it gets the related system setting data from the completed job, and uses that to rename the snapshot. Once you have figured this bit out – the rest is quite straight forward.

Cheers,
Ben

Enabling processor compatibility with a script [Hyper-V]

Virtual PC Guy — Fri, 21 Jan 2011 07:26:00 +0000

When we released Windows Server 2008 R2 we added the ability to make a virtual machines processor more compatible for migration between different hardware platforms (details here). Here is a PowerShell script to do this for you:

# Function for handling WMI jobs / return values

Function ProcessResult($result, $successString, $failureString)

{

   #Return success if the return value is "0"

   if ($result.ReturnValue -eq 0)

      {write-host $successString} 

   #If the return value is not "0" or "4096" then the operation failed

   ElseIf ($result.ReturnValue -ne 4096)

      {write-host $failureString "  Error value:" $result.ReturnValue}

   Else

      {#Get the job object

      $job=[WMI]$result.job

      #Provide updates if the jobstate is "3" (starting) or "4" (running)

      while ($job.JobState -eq 3 -or $job.JobState -eq 4)

         {write-host $job.PercentComplete "% complete"

          start-sleep 1

          #Refresh the job object

          $job=[WMI]$result.job}

       #A jobstate of "7" means success

       if ($job.JobState -eq 7)

          {write-host $successString}

       Else

          {write-host $failureString

          write-host "ErrorCode:" $job.ErrorCode

          write-host "ErrorDescription" $job.ErrorDescription}

       }

}

# Prompt for the Hyper-V Server to use

$HyperVServer = Read-Host "Specify the Hyper-V Server to use (enter '.' for the local computer)"

# Prompt for the virtual machine to use

$VMName = Read-Host "Specify the name of the virtual machine"

# Get the management service

$VMMS = gwmi -namespace root\virtualization Msvm_VirtualSystemManagementService -computername $HyperVServer

# Get the virtual machine object

$VM = gwmi MSVM_ComputerSystem -filter "ElementName='$VMName'" -namespace "root\virtualization" -computername $HyperVServer

# SettingType = 3 ensures that we do not get snapshots

$SystemSettingData = $VM.getRelated("Msvm_VirtualSystemSettingData") | where {$_.SettingType -eq 3}

# Get the processor setting data

$ProcSetting = $SystemSettingData.getRelated("Msvm_ProcessorSettingData") | select -first 1

# Enable processor compatibility

$ProcSetting.LimitProcessorFeatures = $true

# Apply the changes to the processor setting data back to the virtual machine

$result = $VMMS.ModifyVirtualSystemResources($VM, $ProcSetting.GetText(1))

# Process the result

ProcessResult $result "Enabled limited processor features." "Failed to enable limited processor features."

Cheers,
Ben

Script to attach a USB device to a virtual machine [VPC]

Virtual PC Guy — Wed, 19 Jan 2011 07:29:00 +0000

A couple of people have asked me how to automate attaching a USB device to a Windows Virtual PC virtual machine, so here is a PowerShell script to do just that:

# Connect to Virtual PC

$vpc = new-object -com VirtualPC.Application

# Get VM name

$vmName = Read-host "Specify the name of the virtual machine that you want to use"

# List available USB devices

write-host "The following USB devices are available:"

$vpc.USBDeviceCollection | select -ExpandProperty DeviceString

# Get the USB device name

$usb = Read-host "Enter the name of the USB device that you want to connect to the virtual machine"

# Get the VM object

$vm = $vpc.findVirtualMachine($vmName)

# Get the USB object

$usbDevice = $vpc.USBDeviceCollection | ? {$_.DeviceString -eq $usb} | select -first 1

# Attach the device - this will fail if the VM is not running

$vm.AttachUSBDevice($usbDevice)

Note that I am using the “DeviceString” of the USB device – which is not guaranteed to be unique. So what I do is just grab the first one that matches.

Cheers,
Ben