cabeçalho pcivirt.h

Guia de referência para usar interfaces usadas expondo VFs a uma máquina virtual.

Os dispositivos que estão em conformidade com a especificação PCI Express Single-Root I/O Virtualization (SR-IOV) podem fornecer várias interfaces para o dispositivo. Essas interfaces, conhecidas como Funções Virtuais (VFs), são independentes e são fornecidas por meio da interface inicial do dispositivo, conhecida como Função Física (PF). Por exemplo, uma placa de rede Ethernet que oferece suporte a SR-IOV pode ser projetada para ter um switch com uma porta Ethernet física (conectada ao fio físico) e muitas portas Ethernet virtuais.

O espaço de configuração do PF permite que o driver PF gerencie os recursos PCI do VF, incluindo espaço de E/S mapeado na memória e interrupções sinalizadas por mensagem. Como os VFs são um subconjunto de um dispositivo completo, eles podem ser mais baratos de expor no hardware do que uma função tradicional em um pacote multifuncional. Isso permite que o fabricante do dispositivo crie mais interfaces e gerencie todos os recursos compartilhados centralmente.

Quando o Windows está sendo executado diretamente no hardware do computador, os drivers de dispositivo participam de operações relacionadas a Plug and Play, gerenciamento de energia, gerenciamento de interrupções e outras tarefas. Um driver de barramento Windows confiável e a HAL (Camada de Abstração de Hardware) possuem a configuração de barramento e configuram todo o barramento. O driver é executado dentro do mesmo nível de privilégio e não há limites de confiança no modo kernel.

Quando o Windows está sendo executado em uma VM (máquina virtual), essas suposições não se aplicam. Os VFs podem ser colocados sob o controle de uma VM sem privilégios. No entanto, o hardware deve ser verificado para que a segurança ou o desempenho do sistema não sejam afetados.

Quando um driver em execução no VF solicita uma leitura ou gravação de espaço de configuração, a solicitação é recebida pela pilha de virtualização e enviada para o driver PF do dispositivo SR-IOV. É responsabilidade do motorista da PF responder a essas solicitações e fornecer detalhes para o VF. O driver PF pode ocasionalmente exigir que uma solicitação de leitura ou gravação de configuração seja passada para o hardware.

A pilha usa um MMU de E/S para diferenciar o tráfego proveniente das várias interfaces que o dispositivo expõe, impondo a política sobre quais regiões de memória um dispositivo pode acessar e quais interrupções ele pode gerar.

Requisitos de hardware

O sistema a ser usado para SR-IOV atribuição de dispositivo deve atender aos requisitos de rede SR-IOV e atribuição direta de dispositivo. O sistema deve ter um IOMMU, esse IOMMU deve ser configurado para dar controle de dispositivos ao sistema operacional e o PCIe ACS (Access Control Services) deve ser habilitado e configurado para uso pelo sistema operacional. Por fim, o dispositivo em questão não deve usar interrupções baseadas em linha e não deve exigir ATS (Serviços de Tradução de Endereços).

Mais informações aqui:

• Tudo o que você queria saber sobre SR-IOV no Hyper-V. Parte 1
• Atribuição de dispositivo discreto — Descrição e plano de fundo

Para determinar se um sistema dá suporte à atribuição de dispositivos e se um dispositivo PCI específico funcionará para atribuição de dispositivos:

• Script de atribuição de dispositivo discreto

Consultando dispositivos SR-IOV

GUID_DEVINTERFACE_VIRTUALIZABLE_DEVICE é uma interface de classe de dispositivo fornecida por drivers para dispositivos SR-IOV. Esse GUID fornece uma maneira de consultar todas as pilhas de dispositivos que expõem as várias tabelas de funções usadas para gerenciar os recursos relacionados à virtualização do dispositivo. Depois que o driver registra o GUID, os recursos individuais são descobertos enviando IRP_MN_QUERY_INTERFACE. O motorista deve responder a essa solicitação com GUID_SRIOV_DEVICE_INTERFACE_STANDARD. Os motoristas também devem lidar com IOCTL_SRIOV_NOTIFICATION e IOCTL_SRIOV_EVENT_COMPLETE.

Um driver para um dispositivo SR_IOV, que é executado em uma VM privilegiada, é o sistema operacional host. Ele possui Plug-and-Play e gerenciamento de energia para uma máquina inteira e expõe PCI Express SR-IOV Virtual Functions em VMs sem privilégios, deve fornecer o GUID_SRIOV_DEVICE_INTERFACE_STANDARD (definido no cabeçalho Pcivirt.h). Esse driver pode ser PCI Express SR-IOV driver PF (Função Física) que cria o FDO ou pode ser um filtro inferior nesse nó do dispositivo no caso em que o FDO está sendo gerenciado por um driver de porta.

A interface do dispositivo é necessária para que o driver possa acessar o espaço de configuração dos VFs.

Na implementação EVT_WDF_DRIVER_DEVICE_ADD do driver PF, execute estas tarefas:

• Depois de chamar WdfDeviceCreate para criar o FDO (objeto de dispositivo de função), chame WdfDeviceCreateDeviceInterface para registrar GUID_DEVINTERFACE_VIRTUALIZABLE_DEVICE. Isso permite que a pilha de virtualização recupere um identificador de dispositivo para o dispositivo SR-IOV.
• Exponha o GUID_SRIOV_DEVICE_INTERFACE_STANDARD.
  • Inicialize uma estrutura SRIOV_DEVICE_INTERFACE_STANDARD e defina membros para ponteiros de função das funções de retorno de chamada implementadas pelo driver PF.
  • Configure a estrutura chamando WDF_QUERY_INTERFACE_CONFIG_INIT.
  • Registre a interface com o FDO chamando WdfDeviceAddQueryInterface.

// Make the device visible as an assignable device.
//
status = WdfDeviceCreateDeviceInterface(
    fdo,
    &GUID_DEVINTERFACE_VIRTUALIZABLE_DEVICE,
    NULL);
if (!NT_SUCCESS(status))
{
    TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
                "Failed to create interface: %!STATUS!",
                status);
    goto Cleanup;
}

//
// Expose SRIOV_DEVICE_INTERFACE_STANDARD
//
RtlZeroMemory(&sriovInterface, sizeof(sriovInterface));
sriovInterface.Size = sizeof(sriovInterface);
sriovInterface.Version = 1;
sriovInterface.Context = deviceContext;
sriovInterface.InterfaceReference = Virtualization_ReferenceInterface;
sriovInterface.InterfaceDereference = Virtualization_DereferenceInterface;
sriovInterface.ReadVfConfig = Virtualization_ReadConfig;
sriovInterface.WriteVfConfig = Virtualization_WriteConfig;
sriovInterface.ReadVfConfigBlock = Virtualization_ReadBlock;
sriovInterface.WriteVfConfigBlock = Virtualization_WriteBlock;
sriovInterface.ResetVf = Virtualization_ResetFunction;
sriovInterface.SetVfPowerState = Virtualization_SetPowerState;
sriovInterface.GetDeviceLocation = Virtualization_GetDeviceLocation;
sriovInterface.GetVendorAndDevice = Virtualization_GetVendorAndDevice;
sriovInterface.QueryProbedBars = Virtualization_QueryProbedBars;
sriovInterface.QueryLuid = Virtualization_QueryLuid;


WDF_QUERY_INTERFACE_CONFIG_INIT(&qiConfig,
                                (PINTERFACE)&sriovInterface,
                                &GUID_SRIOV_DEVICE_INTERFACE_STANDARD,
                                NULL);

status = WdfDeviceAddQueryInterface(fdo, &qiConfig);

if (!NT_SUCCESS(status))
{
    TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
                "WdfDeviceAddQueryInterface failed: %!STATUS!\n",
                status);
    goto Cleanup;
}

Manipulando eventos Plug and Play

A pilha de virtualização é responsável por enviar as mensagens apropriadas para a VM, aguardar a resposta (com um tempo limite) e no caso de VM não respondente e aplicar a ação apropriada, como vetar o evento PnP ou remover o dispositivo da VM sem privilégios. Os drivers PF que implementam GUID_DEVINTERFACE_VIRTUALIZABLE_DEVICE também devem lidar com essas solicitações de controle de E/S que permitem que a pilha de virtualização reaja a eventos PnP.

• A pilha de virtualização primeiro envia IOCTL_SRIOV_ATTACH para o dispositivo. Isso notifica o dispositivo de que a pilha de virtualização precisa ser notificada sobre determinados eventos PnP.

• Isso está em vigor até que a pilha de virtualização envie IOCTL_SRIOV_DETACH.

• A pilha de virtualização consulta os dispositivos sobre eventos PnP enviando solicitações IOCTL_SRIOV_NOTIFICATION. O driver PF pode informar a pilha de virtualização de um evento PnP concluindo a solicitação IOCTL_SRIOV_NOTIFICATION.

• A pilha de virtualização desbloqueia esses eventos enviando IOCTL_SRIOV_EVENT_COMPLETE.

pcivirt.h contém as seguintes interfaces de programação:

IOCTLs

Funções de retorno de chamada

Estruturas

Enumerações