Compartir a través de

Compatibilidad con KDNET del depurador 2PF

  • Artículo

En este tema se describe cómo habilitar el controlador NDIS de miniport para la compatibilidad con el depurador 2PF para permitir un mayor rendimiento para adaptadores de alta velocidad, que a menudo se usan en centros de datos. Esta característica está disponible en Windows 11 y versiones posteriores.

Al habilitar la depuración de kernel en una NIC, la compatibilidad con la depuración del kernel toma el dispositivo físico para proporcionar tanto una depuración de kernel como una conexión de red en el cuadro. Esto funciona bien en las NIC de ancho de banda bajo de consumidor (1 a 10 Gbps), pero en dispositivos de alto rendimiento que admiten más de 10-40 Gbps, los módulos de extensibilidad de depuración del kernel que se comunican con el hardware generalmente no pueden mantenerse al día con la cantidad de tráfico que proviene de la pila de redes de Windows, por lo que esto degrada el rendimiento general del sistema.

El uso de la característica pci multiple Physical Function (PF) para KDNET permite habilitar la depuración sin casi ningún impacto en el rendimiento.

La función física (PF) es una función PCI Express (PCIe) de un adaptador de red que admite la interfaz de virtualización de E/S raíz única (SR-IOV). El PF incluye la funcionalidad extendida SR-IOV en el espacio de configuración PCIe. La funcionalidad se usa para configurar y administrar la funcionalidad SR-IOV del adaptador de red, como habilitar la virtualización y exponer funciones virtuales (FF) pcIe.

El PF admite la estructura de funcionalidad extendida SR-IOV en su espacio de configuración PCIe. Esta estructura se define en la especificación virtualización de E/S de raíz única PCI-SIG y sharing 1.1.

El transporte del depurador aprovechará varios controladores de miniporte habilitados para 2PF o múltiplos. Para permitir la depuración de sistemas de servidores de alta velocidad, se recomienda que los proveedores de NIC habiliten 2PF en todas las NIC que admiten varias PF en el firmware de la tarjeta de red.

Para obtener información sobre cómo configurar la compatibilidad con 2PF para probar una conexión, consulte Configuración de la depuración en modo kernel de 2PF mediante KDNET.

Introducción a la arquitectura de KDNET de varios PF

  • La funcionalidad Multiple PF (2PF) es agregar o asignar una nueva PF al puerto de red PCI original (por ejemplo, Bus.dev.fun0.0).

  • KDNET usa el nuevo PF agregado (por ejemplo, bus.dev.fun0.1) para enrutar paquetes del depurador hacia o desde el destino.

  • El controlador NIC de la bandeja de entrada de Windows usará el pf original para enrutar los paquetes de red de Windows (TCP/IP).

  • Con este enfoque, ambos controladores pueden funcionar en paralelo y interferir entre sí.

  • Ambos controladores se ejecutarán en el espacio de configuración pci con particiones.

    • El controlador Bandeja de entrada de Windows se quedará sin el puerto de red original en bus.dev.fun0.0

    • KDNET-KDNET-Ext. el módulo se quedará sin el PF agregado en bus.dev.fun0.1, De este modo, garantiza que el controlador NIC de la bandeja de entrada de Windows no se vea afectado al compartir la NIC con KDNET.

  • La herramienta kdnet.exe modo de usuario configura la característica 2PF mediante el controlador de bandeja de entrada de Windows agregando códigos IOCTL específicos para agregar o quitar KDNET PF.

Diagrama que muestra dos pilas de red, una compatible con 2PF mediante una configuración de tarjeta PCI combinada.

Requisitos de diseño de varias características de PFs

  1. La característica KDNET 2PF debe funcionar para todos los escenarios de KD actuales, tanto si es el sistema operativo anterior a NT (por ejemplo, el Administrador de arranque, el cargador del sistema operativo, WinResume, Hyper-V, SK, etc.), el sistema operativo NT o el escritorio de Windows.

  2. El reinicio del sistema será necesario al agregar un nuevo PF para un dispositivo, lo que da como resultado un cambio necesario en la configuración de BCD para la depuración. Esto significa que la configuración de un PF adicional debe ser persistente en los arranques.

  3. El depurador debe usar KDNET 2PF solo para asegurarse de que no haya ningún otro controlador ethernet de Windows/UEFI que acceda o ejecute desde la ubicación PCI 2PF cuando el depurador posee el dispositivo de depuración (la ubicación 2PF se configura mediante dbgsettings::busparams).

  4. Los controladores Ethernet de Windows o UEFI no se pueden ejecutar del KDNET 2PF agregado incluso cuando KDNET no está habilitado en el sistema.

  5. La característica 2PF debe admitir un mecanismo dinámico para agregar, habilitar y quitar o deshabilitar la funcionalidad en la NIC actual.

  6. Los controladores de miniport de Windows implementarán la característica 2PF mediante el mantenimiento de los siguientes NDIS OID.

Nombre del OID Descripción
OID_KDNET_ENUMERATE_PFS Enumera los PFs en el bus.dev.fun actual (BDF), donde se ejecuta el controlador de miniport.
OID_KDNET_ADD_PF Agrega un PF al BDF actual, donde se ejecuta el controlador de miniport.
OID_KDNET_REMOVE_PF Quita el PF agregado del objeto que se pasa en BDF.
OID_KDNET_QUERY_PF_INFORMATION Consulta los datos de información de PF del objeto pasado en BDF.

Los OID y sus estructuras se definen en archivos ntddndis.h y kdnetpf.h que se publican con el WDK público.

Consulte los detalles siguientes sobre los parámetros input/Output para cada OID y la información proporcionada en el archivo de encabezado kdnetpf.h.

  1. KDNET debe configurarse a través de la característica KDNET 2PF en NICS donde está disponible varias características PF y la NIC habilita la funcionalidad 2PF siguiendo todos los requisitos descritos anteriormente.

Interfaz PF múltiple de KDNET para controladores NIC de Windows

Para admitir los controladores KDNET Multiple PF Interface Miniport deberá implementar el control de los cuatro NDIS OID siguientes.

  • OID_KDNET_ENUMERATE_PFS

  • OID_KDNET_ADD_PF

  • OID_KDNET_REMOVE_PF

  • OID_KDNET_QUERY_PF_INFORMATION

Estos OID y estructuras se rellenan en los archivos ntddndis.h y kdnetpf.h en la versión pública de WDK en esta ruta de acceso:

<WDK root directory>\ddk\inc\ndis

Estos archivos también están disponibles en Windows SDK y se pueden encontrar en este directorio.

\Program Files (x86)\Windows Kits\10\Include\<Version for example 10.0.21301.0>\shared

La herramienta cliente (kdnet.exe) usa un IOCTL de NDIS privado para enrutar los OID NDIS de KDNET 2PF a los controladores de miniport.

Los NDIS de características de múltiples PF

La característica Multiple PF está operada mediante estos cuatro OID de NDIS.

1. Enumerar PFs en el puerto principal de BDF de miniporte mediante OID: OID_KDNET_ENUMERATE_PFS, consulte la definición siguiente.

  • OID_KDNET_ENUMERATE_PFS devuelve una lista de todas las BDF asociadas al puerto principal determinado desde donde se ejecuta el controlador de miniport. El puerto se representa mediante el bus.dev.fun (BDF). La operación enumerará o enumerará la lista de PFs que están asociadas solo al bus.dev.fun (puerto BDF) desde donde se ejecuta el controlador de miniporte en el sistema, ya que cada controlador de miniporte puede determinar su ubicación BDF.

  • La lista de PFs se devolverá al cliente a través de una operación de consulta NDIS.

  • El OID_KDNET_ENUMERATE_PFS OID está asociado a la estructura NDIS_KDNET_ENUMERATE_PFS .

  • El controlador de controlador OID_KDNET_ENUMERATE_PFS devolverá un búfer que contiene la lista de PFs con cada elemento PF descrito por el tipo NDIS_KDNET_PF_ENUM_ELEMENT.

    El campo PfNumber contiene el número de función PF (por ejemplo, bus.dev.divertido)

    El campo PfState contiene el estado PF posibles valores: cada tipo de elemento descrito por NDIS_KDNET_PF_STATE enumeración.

    NDIS_KDNET_PF_STATE::NdisKdNetPfStatePrimary : se trata de un PF principal y normalmente solo lo usa el controlador de miniport.

    NDIS_KDNET_PF_STATE::NdisKdnetPfStateEnabled : se trata de un PF secundario agregado, que usa KDNET.

    NDIS_KDNET_PF_STATE::NdisKdnetPfStateConfigured : se trata de un PF agregado, pero solo se agrega o configura y no se usa.

  • Si el tamaño del búfer de salida de la lista PF no es lo suficientemente grande como para asignar la lista de PFs reales, el controlador de OID debe devolver E_NOT_SUFFICIENT_BUFFER el valor devuelto de error, junto con el tamaño de búfer necesario, por lo que la herramienta cliente puede asignar el búfer de tamaño necesario y, a continuación, el cliente puede realizar otra llamada con el tamaño de búfer correcto asignado. Además, el valor de que el campo de estado de la solicitud OID (descrito por NDIS_IOCTL_OID_REQUEST_INFO.status) debe establecerse en igual a NDIS_STATUS_BUFFER_TOO_SHORT.

2. Agregue PCI PF al puerto principal BDF de miniporte (OID: OID_KDNET_ADD_PF, consulte la definición siguiente)

  • Agregue un PF al puerto principal de miniporte. El puerto se representa mediante el BDF.

  • El PF recién agregado se devolverá al cliente a través de una operación de consulta NDIS.

  • El OID_KDNET_ADD_PF OID está asociado a la estructura NDIS_KDNET_ADD_PF .

  • El controlador del controlador OID_KDNET_ADD_PF devolverá un ULONG que contiene el número de función PF agregado .

  • Esta solicitud de OID solo tendrá un parámetro output: AddedFunctionNumber. AddedFunctionNumber indica el valor del número de función agregado en la ubicación PCI de miniport (miniporte BDF). La utilidad kdnet.exe recibirá este valor y configurará dbgsettings::busparams para apuntar al PF agregado.

Nota:

KDNET puede usar el PF agregado exclusivamente, por lo que los controladores de NIC de Windows se rijan para ejecutarse expresamente *NOT* en un PF agregado, por lo que esto también se aplica cuando KDNET está habilitado en el sistema y el PF se ha agregado al puerto.

3. Quite PCI PF (OID: OID_KDNET_REMOVE_PF, vea la definición siguiente )

  • Quite un PF del puerto especificado. El puerto se representa mediante el BDF.

  • El OID_KDNET_REMOVE_PF OID está asociado a la estructura NDIS_KDNET_REMOVE_PF .

  • El OID_KDNET_REMOVE_PF OID tiene un puerto BDF de entrada y devuelve un ULONG que contiene el número de función PF quitado a través de una operación de método NDIS.

  • Esta función solo se realizará correctamente en los PFs que se han agregado mediante el uso del OID de OID_KDNET_ADD_PF .

  • Esta solicitud de OID tendrá el puerto BDF de entrada desde donde debe quitarse el BDF. Esta función tiene un parámetro Output de FunctionNumber. La salida FunctionNumber contendrá el valor del número de función quitado.

4. Consultar información de PCI PF (OID: OID_KDNET_QUERY_PF_INFORMATION, consulte la definición siguiente)

  • Este código OID permite consultar datos PF específicos en un puerto determinado. El puerto se representa mediante el BDF.

  • La información de PF solicitada se devolverá al cliente a través de una operación de método NDIS.

  • El OID_KDNET_QUERY_PF_INFORMATION OID está asociado a la estructura NDIS_KDNET_QUERY_PF_INFORMATION .

  • El OID_KDNET_QUERY_PF_INFORMATION OID tiene un puerto BDF de entrada y devuelve un búfer que contiene los datos siguientes:

    • Dirección MAC: dirección de red del nuevo KDNET PF asignado si hay alguno.

    • Etiqueta de uso: describe la entidad propietaria del puerto PF. Contiene un valor constante descrito por NDIS_KDNET_PF_USAGE_TAG enumeración.

    • Número máximo de PFs: contiene un ULONG con el número máximo de PFs que se pueden agregar al BDF especificado.

    • Id. de dispositivo: contiene el identificador de dispositivo asociado al puerto BDF especificado. Esto es necesario para los casos en los que el NIC FW asigna un nuevo identificador de dispositivo al nuevo puerto PF de KDNET agregado.

  • Este OID solicita la información de cualquier puerto BDF pasado (BDF es un parámetro de entrada para esta operación), por lo que no está necesariamente relacionado con el BDF actual desde donde se ejecuta el controlador.

NDIS OID para KDNET en 2PF

El archivo Ntddndis.h define los OID.

#if (NDIS_SUPPORT_NDIS686)

 //

 // Optional OIDs to handle network multiple PF feature.

 //
#define OID_KDNET_ENUMERATE_PFS 0x00020222
#define OID_KDNET_ADD_PF 0x00020223
#define OID_KDNET_REMOVE_PF 0x00020224
#define OID_KDNET_QUERY_PF_INFORMATION 0x00020225
#endif // (NDIS_SUPPORT_NDIS686)

El archivo Kdnetpf.h describe el tipo y las estructuras asociadas a los OID de NDIS.

#if (NDIS_SUPPORT_NDIS686)

 //
 // Used to query/add/remove Physical function on a network port.
 // These structures are used by these OIDs:
 // OID_KDNET_ENUMERATE_PFS
 // OID_KDNET_ADD_PF
 // OID_KDNET_REMOVE_PF
 // OID_KDNET_QUERY_PF_INFORMATION
 // These OIDs handle PFs that are primary intended to be used by  KDNET.
 //
 //
 // PCI location of the port to query
 //
 typedef struct _NDIS_KDNET_BDF
 {
 ULONG SegmentNumber;
 ULONG BusNumber;
 ULONG DeviceNumber;
 ULONG FunctionNumber;
 ULONG Reserved;
 } NDIS_KDNET_BDF, *PNDIS_KDNET_PCI_BDF;

 //
 // PF supported states.
 //
 typedef enum _NDIS_KDNET_PF_STATE
 {
 NdisKdNetPfStatePrimary = 0x0,
 NdisKdnetPfStateEnabled = 0x1,
 NdisKdnetPfStateConfigured = 0x2,
 } NDIS_KDNET_PF_STATE,*PNDIS_KDNET_PF_STATE;

 //
 // PF Usage Tag
 // Used to indicate the entity that owns the PF.
 // Used by the query NdisKdnetQueryUsageTag.
 //
 typedef enum _NDIS_KDNET_PF_USAGE_TAG
 {
 NdisKdnetPfUsageUnknown = 0x0,
 NdisKdnetPfUsageKdModule = 0x1,
 } NDIS_KDNET_PF_USAGE_TAG,*PNDIS_KDNET_PF_USAGE_TAG;

 //
 // PF element array structure
 //
 typedef struct _NDIS_KDNET_PF_ENUM_ELEMENT
 {
 NDIS_OBJECT_HEADER Header;

 //
 // PF value (e.g. if <bus.dev.fun>, then PF value = fun)
 //
 ULONG PfNumber;

 //
 // The PF state value (defined by NDIS_KDNET_PF_STATE)
 //
 NDIS_KDNET_PF_STATE PfState;

 } NDIS_KDNET_PF_ENUM_ELEMENT, *PNDIS_KDNET_PF_ENUM_ELEMENT;
#define NDIS_KDNET_PF_ENUM_ELEMENT_REVISION_1 1
#define NDIS_SIZEOF_KDNET_PF_ENUM_ELEMENT_REVISION_1 \
 RTL_SIZEOF_THROUGH_FIELD(NDIS_KDNET_PF_ENUM_ELEMENT, PfState)

 //
 // This structure describes the data required to enumerate the list of PF
 // Used by OID_KDNET_ENUMERATE_PFS.
 //
 typedef struct _NDIS_KDNET_ENUMERATE_PFS
 {
 NDIS_OBJECT_HEADER Header;

 //
 // The size of each element is the sizeof(NDIS_KDNET_PF_ENUM_ELEMENT)
 //
 ULONG ElementSize;

 //
 // The number of elements in the returned array
 //
 ULONG NumberOfElements;

 //
 // Offset value to the first element of the returned array.
 // Each array element is defined by NDIS_KDNET_PF_ENUM_ELEMENT.
 //
 ULONG OffsetToFirstElement;
 } NDIS_KDNET_ENUMERATE_PFS, *PNDIS_KDNET_ENUMERATE_PFS;

#define NDIS_KDNET_ENUMERATE_PFS_REVISION_1 1
#define NDIS_SIZEOF_KDNET_ENUMERATE_PFS_REVISION_1 \
 RTL_SIZEOF_THROUGH_FIELD(NDIS_KDNET_ENUMERATE_PFS,
 OffsetToFirstElement)

 //
 // This structure indicates the data required to add a PF to the BDF port.
 // Used by OID_KDNET_ADD_PF.
 //
 typedef struct _NDIS_KDNET_ADD_PF
 {
 NDIS_OBJECT_HEADER Header;

 //
 // One element containing the added PF port number
 //
 ULONG AddedFunctionNumber;
 } NDIS_KDNET_ADD_PF, *PNDIS_KDNET_ADD_PF;

#define NDIS_KDNET_ADD_PF_REVISION_1 1
#define NDIS_SIZEOF_KDNET_ADD_PF_REVISION_1 \
 RTL_SIZEOF_THROUGH_FIELD(NDIS_KDNET_ADD_PF, AddedFunctionNumber)

 //
 // This structure indicates the data required to remove a PF from the BDF port.
 // Used by OID_KDNET_REMOVE_PF.
 //

 typedef struct _NDIS_KDNET_REMOVE_PF
 {
 NDIS_OBJECT_HEADER Header;

 //
 // PCI location that points to the PF that needs to be removed
 //
 NDIS_KDNET_BDF Bdf;

 //
 // One element containing the removed PF port
 //
 ULONG FunctionNumber;
 } NDIS_KDNET_REMOVE_PF, *PNDIS_KDNET_REMOVE_PF;
#define NDIS_KDNET_REMOVE_PF_REVISION_1 1
#define NDIS_SIZEOF_KDNET_REMOVE_PF_REVISION_1 \
 RTL_SIZEOF_THROUGH_FIELD(NDIS_KDNET_REMOVE_PF, FunctionNumber)

 //
 // This structure describes the data required to query the PF management data
 // Used by OID_KDNET_QUERY_PF_INFORMATION
 //
 typedef struct _NDIS_KDNET_QUERY_PF_INFORMATION
 {
 NDIS_OBJECT_HEADER Header;

 //
 // PF PCI location to query for
 //
 NDIS_KDNET_BDF Bdf;

 //
 // PF assigned MAC address
 //
 UCHAR NetworkAdddress[6];

 //
 // PF Usage tag described by NDIS_KDNET_PF_USAGE_TAG
 //
 ULONG UsageTag;

 //
 // Maximum number of Pfs that can be associated to the Primary BDF.
 //
 ULONG MaximumNumberOfSupportedPfs;

 //
 // KDNET PF device ID (Used if there is a new added PF and
 // the FW assigns a new DeviceID to the added KDNET PF)
 //
 ULONG DeviceId;

 } NDIS_KDNET_QUERY_PF_INFORMATION, *PNDIS_KDNET_QUERY_PF_INFORMATION;
#define NDIS_KDNET_QUERY_PF_INFORMATION_REVISION_1 1
#define NDIS_SIZEOF_KDNET_QUERY_PF_INFORMATION_REVISION_1 \
 RTL_SIZEOF_THROUGH_FIELD(NDIS_KDNET_QUERY_PF_INFORMATION, DeviceId)

#endif // (NDIS_SUPPORT_NDIS686)

Consulte también

Configuración de la depuración en modo kernel 2PF mediante KDNET

OID de red

Encabezado kdnetpf.h