With Hyper-V R2, Microsoft include a new Processor Compatibility feature. Processor compatibility allows you to move a virtual machine up and down multiple processor generations from the same vendor.

Here’s how it works:

When a Virtual Machine (VM) is started on a host, the hypervisor exposes the set of supported processor features available on the underlying hardware to the VM. This set of processor features are called guest visible processor features and are available to the VM until the VM is restarted.

When a VM is started with processor compatibility mode enabled, Hyper-V normalizes the processor feature set and only exposes guest visible processor features that are available on all Hyper-V enabled processors of the same processor architecture, i.e. AMD or Intel.  This allows the VM to be migrated to any hardware platform of the same processor architecture. Processor features are "hidden" by the hypervisor by intercepting a VM’s CPUID instruction and clearing the returned bits corresponding to the hidden features.

Just so we’re clear: this still means AMD<->AMD and Intel<->Intel. It does not mean you can Live Migrate between different processor vendors AMD<->Intel or vice versa.

In addition, you may be aware that both AMD and Intel have provided similar capabilities in hardware, Extended Migration and Flex Migration respectively. Extended and Flex Migration are cool technologies available on relatively recent processors, but this is a case where providing the solution in software allows us to be more flexible and provide this capability to older systems too. Processor Compatibility also makes it easier to upgrade to the newest server hardware. In addition, Hyper-V Processor Compatibility can be done on a per VM basis (it’s a checkbox) and doesn’t require any BIOS changes.

Time To Get Uber-Geeky

Now that I’ve explained what processor compatibility mode does and the flexibility provides, I’m guessing there are a few propeller heads who want to go further and know exactly what a "normalized processor" means from a processor feature standpoint. Happy to oblige. When a VM in processor compatibility mode is started, the following processor features are hidden from the VM:

FAQ

Q: What happens if a vendor has written an application that uses one of these features that isn’t visible with processor compatibility enabled?

A: Since the feature isn’t exposed to the virtual machine, the application won’t "see it" and it’s up to the application to determine how to proceed; however, there are two likely paths.

Path 1: The application will check to see if a specific processor feature is available and use it if it’s available. If the processor features isn’t available, it will use a different code path. Remember that applications that make use of these advanced processor features are generally written in a flexible fashion to accommodate the servers in market today and there are still thousands of older Xeons and Opterons on the market that don’t have some of the latest processor features.

Path 2: The application requires a specific processor feature and refuses to launch. At this point in time, we haven’t found any application that fall into this category. It’s possible they exist, but we haven’t hit one yet. Since we can’t test every application out there, processor compatibility is defaulted off. (We’re conservative by nature.).

BTW, if there were issues with Hyper-V Processor Compatibility, you’d also see it with other virtualization products which rely on underlying hardware capabilities to mitigate this problem as well.

Q: Does processor compatibility have a hardware requirement? Does it require Intel Flex Migration or AMD Extended Migration?

A: Hyper-V processor compatibility mode has no dependencies on these technologies.

Q: Does Hyper-V processor compatibility allow you to migrate a VM from an AMD host to an Intel host and vice versa?

A: No. Processor compatibility allows you to move a virtual machine up and down multiple processor generations from the same vendor. It does not allow migrating a VM (with or without processor compatibility mode) from AMD based hosts to Intel based hosts, and vice versa.

Again :

AMD<->AMD and Intel<->Intel.

Source : Windows Virtualization Team Blog.
http://blogs.technet.com/virtualization/archive/2009/05/12/tech-ed-windows-server-2008-r2-hyper-v-news.aspx

Quick Storage Migration (QSM) In Brief

As you may have seen, we recently released the Release Candidate for System Center Virtual Machine Manager 2008 R2. One of the most anticipated features of SCVMM 2008 R2 is Quick Storage Migration (QSM) which enables the migration of the storage of VM from one location to another. For example, suppose you have virtual machines on a leased SAN (SAN 1). The lease runs out and you decide to upgrade to a new SAN (SAN 2) with more capacity, better performance and additional capabilities. Quick Storage Migration allows you to move the virtual machine which resides on SAN 1 to SAN 2. I have had a number of request for more details on how this works so we’ve written this brief guide to QSM. (In addition, we wanted to make this technology broadly available, not just the biggest enterprises. More on that below.)

QSM relies on Windows Server 2008 R2 Hyper-V and Background Intelligent Transfer Service (BITS). QSM can move the virtual disks of a running virtual machine independent of storage protocols (iSCSI, FC) or storage type (local, DAS, SAN), with minimal downtime.

QSM Is One of Many Migration Technologies Supported in Virtual Machine Manager’s Portfolio

Note on Processor Compatibility Mode:

To increase the mobility of a running virtual machine across hosts with different processor versions (with in the same processor family), Windows Server 2008 R2 Hyper-V offers Processor Compatibility Mode. This feature masks processor feature differences between the source and destination hosts. With this enabled, you can migrate a virtual machine from a host with Pentium 4 VT processors to a host with Nehalem processors. Processor Compatibility Mode does not require advanced processor features like Intel VT Flex Migration or AMD-V Extended Migration. For more on Processor Compatibility Mode, check out Jeff’s Blog a few weeks ago where he goes into detail here.

How QSM Compares To VMware Storage VMotion

You see this error message because the switch protocol is already enabled on that NIC.  It’s enabled either because there is already a virtual network using that adapter or because something or someone enabled it incorrectly.  If you already have a virtual network using that NIC, you can’t use that NIC on two virtual networks.

 If you ever need to completely remove all virtual networks from your system, you could use one of the options below (I recommend extreme caution ):

Delete all your virtual networks.

I wouldn’t recommend running it remotely because it will tear down your network stack but it should restore it once completed.

/*
Copyright (c) Microsoft Corporation
 
Module Name:
 
    nvspscrub.js
 
*/

//
// VirtualSwitchManagementService object.  Logical wrapper class for Switch Management Service
//
function
VirtualSwitchManagementService(
    Server,
    User,
    Password
    )
{
    //
    // Define instance fields.
    //   
    this.m_VirtualizationNamespace  = null;
   
    this.m_VirtualSwitchManagementService = null;
       

    //
    // Instance methods
    //       
   
    VirtualSwitchManagementService.prototype.DeleteSwitch =
    function(
        VirtualSwitch
        )
       
    /*++

    Description:

        Deletes a virtual switch
       
    Arguments:

        VirtualSwitch – Msvm_VirtualSwitch object to delete

    Return Value:

        SWbemMethod.OutParameters object.

    –*/
   
    {
        var methodName = "DeleteSwitch";

        var inParams = this.m_VirtualSwitchManagementService.Methods_(methodName).inParameters.SpawnInstance_();

        inParams.VirtualSwitch = VirtualSwitch.Path_.Path;
       
        return this.m_VirtualSwitchManagementService.ExecMethod_(methodName, inParams);
    }
   
   
    VirtualSwitchManagementService.prototype.DeleteInternalEthernetPort =
    function(
        InternalEthernetPort
        )

    /*++

    Description:

        Deletes an internal ethernet port
       
    Arguments:

        InternalEthernetPort – Msvm_InternalEthernetPort to delete
       
    Return Value:

        SWbemMethod.OutParameters object.

    –*/

    {
        var methodName = "DeleteInternalEthernetPort";

        var inParams = this.m_VirtualSwitchManagementService.Methods_(methodName).inParameters.SpawnInstance_();
       
        inParams.InternalEthernetPort = InternalEthernetPort.Path_.Path;
       
        return this.m_VirtualSwitchManagementService.ExecMethod_(methodName, inParams);
    }
   
    VirtualSwitchManagementService.prototype.UnbindExternalEthernetPort =
    function(
        ExternalEthernetPort
        )

    /*++

    Description:

        Unbinds an external ethernet port from the virtual network subsystem.  Usually this method
         won’t be called directly
       
    Arguments:

        SwitchPort – Msvm_ExternalEthernetPort to unbind.

    Return Value:

        SWbemMethod.OutParameters object.

    –*/

    {
        var methodName = "UnbindExternalEthernetPort";

        var inParams = this.m_VirtualSwitchManagementService.Methods_(methodName).inParameters.SpawnInstance_();

        inParams.ExternalEthernetPort = ExternalEthernetPort.Path_.Path;
       
        return this.m_VirtualSwitchManagementService.ExecMethod_(methodName, inParams);
    }
   
    //
    // Utility functions
    //
   
    VirtualSwitchManagementService.prototype.WaitForNetworkJob =
    function(
        OutParams
        )

    /*++

    Description:

        WMI calls will exit with some type of return result.  Some will require
        a little more processing before they are complete. This handles those
        states after a wmi call.

    Arguments:

        OutParams – the parameters returned by the wmi call.

    Return Value:

        Status code

    –*/

    {
        if (OutParams.ReturnValue == 4096)
        {
            var jobStateStarting        = 3;
            var jobStateRunning         = 4;
            var jobStateCompleted       = 7;
   
            var networkJob;

            do
            {
                WScript.Sleep(1000);
               
                networkJob = this.m_VirtualizationNamespace.Get(OutParams.Job);

            } while ((networkJob.JobState == jobStateStarting) ||
                     (networkJob.JobState == jobStateRunning));

            if (networkJob.JobState != jobStateCompleted)
            {
                throw(new Error(networkJob.ErrorCode,
                                networkJob.Description + " failed: " + networkJob.ErrorDescription));
            }
           
            return networkJob.ErrorCode;
        }

        return OutParams.ReturnValue;
    }
   
    VirtualSwitchManagementService.prototype.GetSingleObject =
    function(
        SWbemObjectSet
        )

    /*++

    Description:

        Takes a SWbemObjectSet which is expected to have one object and returns the object

    Arguments:

        SWbemObjectSet – The set.

    Return Value:

        The lone member of the set.  Exception thrown if Count does not equal 1.

    –*/

    {
        if (SWbemObjectSet.Count != 1)
        {
            throw(new Error(5, "SWbemObjectSet was expected to have one item but actually had " + SWbemObjectSet.Count));
        }
       
        return SWbemObjectSet.ItemIndex(0);
    }

   
    //
    // Aggregate functions
    //
    VirtualSwitchManagementService.prototype.DeleteSwitchAndWait =
    function(
        VirtualSwitch
        )
       
    /*++

    Description:

        Deletes a switch
       
    Arguments:

        VirtualSwitch – Msvm_VirtualSwitch to delete
       
    Return Value:
   
        None.

    –*/
   
    {
        var outParams = this.DeleteSwitch(VirtualSwitch);

        var wmiRetValue = this.WaitForNetworkJob(outParams);

        if (wmiRetValue != 0)
        {
            throw(new Error(wmiRetValue, "DeleteSwitch failed"));
        }
    }
   
    VirtualSwitchManagementService.prototype.DeleteInternalEthernetPortAndWait =
    function(
        InternalEthernetPort
        )
    /*++

    Description:

        Deletes an internal ethernet port
       
    Arguments:

        InternalEthernetPort – Msvm_InternalEthernetPort to delete
       
    Return Value:

        SWbemMethod.OutParameters object.

    –*/
   
    {
        var outParams = this.DeleteInternalEthernetPort(InternalEthernetPort);

        var wmiRetValue = this.WaitForNetworkJob(outParams);

        if (wmiRetValue != 0)
        {
            throw(new Error(wmiRetValue, "DeleteInternalEthernetPortAndWait failed"));
        }
    }
   
   
    VirtualSwitchManagementService.prototype.UnbindExternalEthernetPortAndWait =
    function(
        ExternalEthernetPort
        )
    /*++

    Description:

        unbinds an internal ethernet port
       
    Arguments:

        ExternalEthernetPort – Msvm_ExternalEthernetPort to unbind
       
    Return Value:

        SWbemMethod.OutParameters object.

    –*/
   
    {
        var outParams = this.UnbindExternalEthernetPort(ExternalEthernetPort);

        var wmiRetValue = this.WaitForNetworkJob(outParams);

        if (wmiRetValue != 0)
        {
            throw(new Error(wmiRetValue, "UnbindExternalEthernetPortAndWait failed"));
        }
    }
   
    //
    // Constructor code
    //
   
    if (Server == null)
    {
        Server = WScript.CreateObject("WScript.Network").ComputerName;
    }
   
    //
    // Set Namespace fields
    //
    try
    {
        var locator = new ActiveXObject("WbemScripting.SWbemLocator");

        this.m_VirtualizationNamespace = locator.ConnectServer(Server, "root\virtualization", User, Password);
    }
    catch (e)
    {
        this.m_VirtualizationNamespace = null;
       
        throw(new Error("Unable to get an instance of Virtualization namespace: " + e.description));
    }
   
    //
    // Set Msvm_VirtualSwitchManagementService field
    //
    try
    {
        var physicalComputerSystem =
                this.m_VirtualizationNamespace.Get(
                        "Msvm_ComputerSystem.CreationClassName=’Msvm_ComputerSystem’,Name=’" + Server + "’");
         
        this.m_VirtualSwitchManagementService = this.GetSingleObject(
                                                        physicalComputerSystem.Associators_(
                                                            "Msvm_HostedService",
                                                            "Msvm_VirtualSwitchManagementService",
                                                            "Dependent"));
    }
    catch (e)
    {
        this.m_VirtualSwitchManagementService = null;
       
        throw(new Error("Unable to get an instance of Msvm_VirtualSwitchManagementService: " + e.description));
    }
}

//
// main
//

var wshShell = WScript.CreateObject("WScript.Shell");

var g_NvspWmi   = null;

Main();

function Main()
{
 WScript.Echo("Looking for nvspwmi…");
 g_NvspWmi   = new VirtualSwitchManagementService();

 WScript.Echo("");
 WScript.Echo("Looking for internal (host) virtual nics…");
 var list = g_NvspWmi.m_VirtualizationNamespace.ExecQuery("SELECT * FROM Msvm_InternalEthernetPort");
 for (i = 0; i < list.Count; i++)
 {
  var next = list.ItemIndex(i);
  WScript.echo(next.DeviceID);
  g_NvspWmi.DeleteInternalEthernetPortAndWait(next);
 }
 
 WScript.Echo("");
 WScript.Echo("Looking for switches…");
 list = g_NvspWmi.m_VirtualizationNamespace.ExecQuery("SELECT * FROM Msvm_VirtualSwitch");
 for (i = 0; i < list.Count; i++)
 {
  var next = list.ItemIndex(i);
  WScript.echo(next.Name);
  g_NvspWmi.DeleteSwitchAndWait(next);
 }
 
 WScript.Echo("");
 WScript.Echo("Looking for external nics…");
 list = g_NvspWmi.m_VirtualizationNamespace.ExecQuery("SELECT * FROM Msvm_ExternalEthernetPort WHERE IsBound=TRUE");
 for (i = 0; i < list.Count; i++)
 {
  var next = list.ItemIndex(i);
  WScript.echo(next.DeviceID);
  g_NvspWmi.UnbindExternalEthernetPortAndWait(next);
 }
 
 WScript.Echo("");
 WScript.Echo("Finished!");
}