Global Execution Context Renames

docs/Settings.md

@@ -113,7 +113,7 @@ These parameters are accessed by calling [GetParam](./api/GetParam.md) or [SetPa
 | `QUIC_PARAM_GLOBAL_GLOBAL_SETTINGS`<br> 6         | QUIC_GLOBAL_SETTINGS    | Both      | Globally change global only settings.                                                                 |
 | `QUIC_PARAM_GLOBAL_VERSION_SETTINGS`<br> 7        | QUIC_VERSIONS_SETTINGS  | Both      | Globally change version settings for all subsequent connections.                                      |
 | `QUIC_PARAM_GLOBAL_LIBRARY_GIT_HASH`<br> 8        | char[64]                | Get-only  | Git hash used to build MsQuic (null terminated string)                                                |
-| `QUIC_PARAM_GLOBAL_EXECUTION_CONFIG`<br> 9        | QUIC_EXECUTION_CONFIG   | Both      | Globally configure the execution model used for QUIC. Must be set before opening registration.        |
+| `QUIC_PARAM_GLOBAL_EXECUTION_CONFIG`<br> 9 (preview)        | QUIC_GLOBAL_EXECUTION_CONFIG   | Both      | Globally configure the execution model used for QUIC. Must be set before opening registration.        |
 | `QUIC_PARAM_GLOBAL_TLS_PROVIDER`<br> 10           | QUIC_TLS_PROVIDER       | Get-Only  | The TLS provider being used by MsQuic for the TLS handshake.                                          |
 | `QUIC_PARAM_GLOBAL_STATELESS_RESET_KEY`<br> 11    | uint8_t[]               | Set-Only  | Globally change the stateless reset key for all subsequent connections.                               |
 | `QUIC_PARAM_GLOBAL_VERSION_NEGOTIATION_ENABLED`<br> (preview) | uint8_t (BOOLEAN) | Both | Globally enable the version negotiation extension for all client and server connections. |

scripts/generate-dotnet.ps1

@@ -80,7 +80,7 @@ Invoke-Expression "$ToolExe $FullArgs"
     -replace "  QUIC_RECEIVE_FLAG_", "  " `
     -replace "  QUIC_SEND_FLAG_", "  " `
     -replace "  QUIC_DATAGRAM_SEND_", "  " `
-    -replace "  QUIC_EXECUTION_CONFIG_FLAG_", "  " `
+    -replace "  QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_", "  " `
     -replace "QUIC_TLS_PROTOCOL_1_3", "TLS_1_3" `
     -replace "  QUIC_TLS_PROTOCOL_", "  " `
     -replace "  QUIC_CIPHER_ALGORITHM_", "  " `

src/core/library.c

@@ -1013,13 +1013,13 @@ QuicLibrarySetGlobalParam(
             return QUIC_STATUS_SUCCESS;
         }
 
-        if (Buffer == NULL || BufferLength < QUIC_EXECUTION_CONFIG_MIN_SIZE) {
+        if (Buffer == NULL || BufferLength < QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE) {
             return QUIC_STATUS_INVALID_PARAMETER;
         }
 
-        QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)Buffer;
+        QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)Buffer;
 
-        if (BufferLength < QUIC_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t) * Config->ProcessorCount) {
+        if (BufferLength < QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t) * Config->ProcessorCount) {
             return QUIC_STATUS_INVALID_PARAMETER;
         }
 
@@ -1051,7 +1051,7 @@ QuicLibrarySetGlobalParam(
             break;
         }
 
-        QUIC_EXECUTION_CONFIG* NewConfig =
+        QUIC_GLOBAL_EXECUTION_CONFIG* NewConfig =
             CXPLAT_ALLOC_NONPAGED(BufferLength, QUIC_POOL_EXECUTION_CONFIG);
         if (NewConfig == NULL) {
             QuicTraceEvent(
@@ -1340,7 +1340,7 @@ QuicLibraryGetGlobalParam(
         }
 
         const uint32_t ConfigLength =
-            QUIC_EXECUTION_CONFIG_MIN_SIZE +
+            QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE +
             sizeof(uint16_t) * MsQuicLib.ExecutionConfig->ProcessorCount;
 
         if (*BufferLength < ConfigLength) {

src/core/library.h

@@ -170,7 +170,7 @@ typedef struct QUIC_LIBRARY {
     //
     // Configuration for execution of the library (optionally set by the app).
     //
-    QUIC_EXECUTION_CONFIG* ExecutionConfig;
+    QUIC_GLOBAL_EXECUTION_CONFIG* ExecutionConfig;
 
     //
     // Datapath instance for the library.

src/core/unittest/SettingsTest.cpp

@@ -559,8 +559,8 @@ TEST(SettingsTest, GlobalLoadBalancingServerIDSet)
 #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
 TEST(SettingsTest, GlobalExecutionConfigSetAndGet)
 {
-    uint8_t RawConfig[QUIC_EXECUTION_CONFIG_MIN_SIZE + 2 * sizeof(uint16_t)] = {0};
-    QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)RawConfig;
+    uint8_t RawConfig[QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + 2 * sizeof(uint16_t)] = {0};
+    QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)RawConfig;
     Config->ProcessorCount = 2;
     if (CxPlatProcCount() < 2) {
         Config->ProcessorCount = CxPlatProcCount();
@@ -586,7 +586,7 @@ TEST(SettingsTest, GlobalExecutionConfigSetAndGet)
             nullptr));
     ASSERT_EQ((uint32_t)sizeof(RawConfig), BufferLength);
     uint16_t GetRawConfig[sizeof(RawConfig)] = {0};
-    QUIC_EXECUTION_CONFIG* GetConfig = (QUIC_EXECUTION_CONFIG*)GetRawConfig;
+    QUIC_GLOBAL_EXECUTION_CONFIG* GetConfig = (QUIC_GLOBAL_EXECUTION_CONFIG*)GetRawConfig;
     ASSERT_EQ(
         QUIC_STATUS_SUCCESS,
         QuicLibraryGetGlobalParam(
@@ -629,8 +629,8 @@ TEST(SettingsTest, GlobalExecutionConfigSetAndGet)
 
 TEST(SettingsTest, GlobalRawDataPathProcsSetAfterDataPathInit)
 {
-    uint8_t RawConfig[QUIC_EXECUTION_CONFIG_MIN_SIZE + 2 * sizeof(uint16_t)] = {0};
-    QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)RawConfig;
+    uint8_t RawConfig[QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + 2 * sizeof(uint16_t)] = {0};
+    QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)RawConfig;
     Config->ProcessorCount = 2;
     Config->ProcessorList[0] = 0;
     Config->ProcessorList[1] = 1;

src/core/worker.c

@@ -115,10 +115,10 @@ QuicWorkerInitialize(
         }
 
         if (MsQuicLib.ExecutionConfig) {
-            if (MsQuicLib.ExecutionConfig->Flags & QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY) {
+            if (MsQuicLib.ExecutionConfig->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY) {
                 ThreadFlags |= CXPLAT_THREAD_FLAG_HIGH_PRIORITY;
             }
-            if (MsQuicLib.ExecutionConfig->Flags & QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE) {
+            if (MsQuicLib.ExecutionConfig->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE) {
                 ThreadFlags |= CXPLAT_THREAD_FLAG_SET_AFFINITIZE;
             }
         }

src/cs/lib/msquic_generated.cs

@@ -213,7 +213,7 @@ internal enum QUIC_DATAGRAM_SEND_STATE
     }
 
     [System.Flags]
-    internal enum QUIC_EXECUTION_CONFIG_FLAGS
+    internal enum QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS
     {
         NONE = 0x0000,
         RIO = 0x0002,
@@ -223,9 +223,9 @@ internal enum QUIC_EXECUTION_CONFIG_FLAGS
         AFFINITIZE = 0x0020,
     }
 
-    internal unsafe partial struct QUIC_EXECUTION_CONFIG
+    internal unsafe partial struct QUIC_GLOBAL_EXECUTION_CONFIG
     {
-        internal QUIC_EXECUTION_CONFIG_FLAGS Flags;
+        internal QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS Flags;
 
         [NativeTypeName("uint32_t")]
         internal uint PollingIdleTimeoutUs;
@@ -3419,8 +3419,8 @@ internal static unsafe partial class MsQuic
         [NativeTypeName("#define QUIC_STATELESS_RESET_KEY_LENGTH 32")]
         internal const uint QUIC_STATELESS_RESET_KEY_LENGTH = 32;
 
-        [NativeTypeName("#define QUIC_EXECUTION_CONFIG_MIN_SIZE (uint32_t)FIELD_OFFSET(QUIC_EXECUTION_CONFIG, ProcessorList)")]
-        internal static readonly uint QUIC_EXECUTION_CONFIG_MIN_SIZE = unchecked((uint)((int)(Marshal.OffsetOf<QUIC_EXECUTION_CONFIG>("ProcessorList"))));
+        [NativeTypeName("#define QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE (uint32_t)FIELD_OFFSET(QUIC_GLOBAL_EXECUTION_CONFIG, ProcessorList)")]
+        internal static readonly uint QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE = unchecked((uint)((int)(Marshal.OffsetOf<QUIC_GLOBAL_EXECUTION_CONFIG>("ProcessorList"))));
 
         [NativeTypeName("#define QUIC_MAX_TICKET_KEY_COUNT 16")]
         internal const uint QUIC_MAX_TICKET_KEY_COUNT = 16;

src/inc/msquic.h

@@ -270,34 +270,34 @@ typedef enum QUIC_DATAGRAM_SEND_STATE {
 #define QUIC_DATAGRAM_SEND_STATE_IS_FINAL(State) \
     ((State) >= QUIC_DATAGRAM_SEND_LOST_DISCARDED)
 
-typedef enum QUIC_EXECUTION_CONFIG_FLAGS {
-    QUIC_EXECUTION_CONFIG_FLAG_NONE             = 0x0000,
+typedef enum QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS {
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE             = 0x0000,
 #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
-    QUIC_EXECUTION_CONFIG_FLAG_RIO              = 0x0002,
-    QUIC_EXECUTION_CONFIG_FLAG_XDP              = 0x0004,
-    QUIC_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC    = 0x0008,
-    QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY    = 0x0010,
-    QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE       = 0x0020,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_RIO              = 0x0002,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP              = 0x0004,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC    = 0x0008,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY    = 0x0010,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE       = 0x0020,
 #endif
-} QUIC_EXECUTION_CONFIG_FLAGS;
+} QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(QUIC_EXECUTION_CONFIG_FLAGS)
+DEFINE_ENUM_FLAG_OPERATORS(QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS)
 
 //
 // A custom configuration for thread execution in QUIC.
 //
-typedef struct QUIC_EXECUTION_CONFIG {
+typedef struct QUIC_GLOBAL_EXECUTION_CONFIG {
 
-    QUIC_EXECUTION_CONFIG_FLAGS Flags;
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS Flags;
     uint32_t PollingIdleTimeoutUs;      // Time before a polling thread, with no work to do, sleeps.
     uint32_t ProcessorCount;
     _Field_size_(ProcessorCount)
     uint16_t ProcessorList[1];          // List of processors to use for threads.
 
-} QUIC_EXECUTION_CONFIG;
+} QUIC_GLOBAL_EXECUTION_CONFIG;
 
-#define QUIC_EXECUTION_CONFIG_MIN_SIZE \
-    (uint32_t)FIELD_OFFSET(QUIC_EXECUTION_CONFIG, ProcessorList)
+#define QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE \
+    (uint32_t)FIELD_OFFSET(QUIC_GLOBAL_EXECUTION_CONFIG, ProcessorList)
 
 typedef struct QUIC_REGISTRATION_CONFIG { // All fields may be NULL/zero.
     const char* AppName;
@@ -863,7 +863,7 @@ void
 #endif
 #define QUIC_PARAM_GLOBAL_LIBRARY_GIT_HASH              0x01000008  // char[64]
 #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
-#define QUIC_PARAM_GLOBAL_EXECUTION_CONFIG              0x01000009  // QUIC_EXECUTION_CONFIG
+#define QUIC_PARAM_GLOBAL_EXECUTION_CONFIG              0x01000009  // QUIC_GLOBAL_EXECUTION_CONFIG
 #endif
 #define QUIC_PARAM_GLOBAL_TLS_PROVIDER                  0x0100000A  // QUIC_TLS_PROVIDER
 #define QUIC_PARAM_GLOBAL_STATELESS_RESET_KEY           0x0100000B  // uint8_t[] - Array size is QUIC_STATELESS_RESET_KEY_LENGTH

src/inc/msquic.hpp

@@ -1743,4 +1743,4 @@ struct QuicBufferScope {
 
 static_assert(sizeof(QuicBufferScope) == sizeof(QUIC_BUFFER*), "Scope guards should be the same size as the guarded type");
 
-#endif  //  _WIN32
+#endif  //  _MSQUIC_HPP_

src/inc/quic_datapath.h

@@ -447,7 +447,7 @@ CxPlatDataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH** NewDatapath
     );
 
@@ -467,7 +467,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 #define CXPLAT_DATAPATH_FEATURE_RECV_SIDE_SCALING     0x0001

src/inc/quic_platform.h

@@ -444,7 +444,7 @@ CxPlatGetAllocFailDenominator(
 // loops.
 //
 
-typedef struct QUIC_EXECUTION_CONFIG QUIC_EXECUTION_CONFIG;
+typedef struct QUIC_GLOBAL_EXECUTION_CONFIG QUIC_GLOBAL_EXECUTION_CONFIG;
 
 typedef struct CXPLAT_EXECUTION_CONTEXT CXPLAT_EXECUTION_CONTEXT;
 
@@ -467,7 +467,7 @@ typedef struct CXPLAT_WORKER_POOL CXPLAT_WORKER_POOL;
 
 CXPLAT_WORKER_POOL*
 CxPlatWorkerPoolCreate(
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 void

src/perf/lib/SecNetPerfMain.cpp

@@ -177,23 +177,23 @@ QuicMainStart(
         return Status;
     }
 
-    uint8_t RawConfig[QUIC_EXECUTION_CONFIG_MIN_SIZE + 256 * sizeof(uint16_t)] = {0};
-    QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)RawConfig;
+    uint8_t RawConfig[QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + 256 * sizeof(uint16_t)] = {0};
+    QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)RawConfig;
     Config->PollingIdleTimeoutUs = 0; // Default to no polling.
     bool SetConfig = false;
     const char* IoMode = GetValue(argc, argv, "io");
 
 #ifndef _KERNEL_MODE
 
     if (IoMode && IsValue(IoMode, "rio")) {
-        Config->Flags |= QUIC_EXECUTION_CONFIG_FLAG_RIO;
+        Config->Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_RIO;
         SetConfig = true;
     }
 
 #endif // _KERNEL_MODE
 
     if (IoMode && IsValue(IoMode, "xdp")) {
-        Config->Flags |= QUIC_EXECUTION_CONFIG_FLAG_XDP;
+        Config->Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP;
         SetConfig = true;
     }
 
@@ -215,13 +215,13 @@ QuicMainStart(
 
     TryGetValue(argc, argv, "highpri", &PerfDefaultHighPriority);
     if (PerfDefaultHighPriority) {
-        Config->Flags |= QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY;
+        Config->Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY;
         SetConfig = true;
     }
 
     TryGetValue(argc, argv, "affinitize", &PerfDefaultAffinitizeThreads);
     if (PerfDefaultHighPriority) {
-        Config->Flags |= QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE;
+        Config->Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE;
         SetConfig = true;
     }
 
@@ -235,7 +235,7 @@ QuicMainStart(
         MsQuic->SetParam(
             nullptr,
             QUIC_PARAM_GLOBAL_EXECUTION_CONFIG,
-            (uint32_t)QUIC_EXECUTION_CONFIG_MIN_SIZE + Config->ProcessorCount * sizeof(uint16_t),
+            (uint32_t)QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + Config->ProcessorCount * sizeof(uint16_t),
             Config))) {
         WriteOutput("Failed to set execution config %d\n", Status);
         return Status;

src/platform/datapath_epoll.c

@@ -360,7 +360,7 @@ DataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH** NewDatapath
     )
 {
@@ -485,7 +485,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 DataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);

src/platform/datapath_kqueue.c

@@ -434,7 +434,7 @@ CxPlatDataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH** NewDataPath
     )
 {
@@ -546,7 +546,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);

src/platform/datapath_raw.c

@@ -22,7 +22,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 QUIC_STATUS
 RawDataPathInitialize(
     _In_ uint32_t ClientRecvContextLength,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _In_opt_ const CXPLAT_DATAPATH* ParentDataPath,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
     _Out_ CXPLAT_DATAPATH_RAW** NewDataPath
@@ -133,7 +133,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 RawDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH_RAW* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     CxPlatDpRawUpdateConfig(Datapath, Config);;

src/platform/datapath_raw.h

@@ -113,7 +113,7 @@ CxPlatDpRawInitialize(
     _Inout_ CXPLAT_DATAPATH_RAW* Datapath,
     _In_ uint32_t ClientRecvContextLength,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 //
@@ -141,7 +141,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDpRawUpdateConfig(
     _In_ CXPLAT_DATAPATH_RAW* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 //

src/platform/datapath_raw_dpdk.c

@@ -126,7 +126,7 @@ CxPlatDpdkReadConfig(
 _IRQL_requires_max_(PASSIVE_LEVEL)
 size_t
 CxPlatDpRawGetDatapathSize(
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Config);
@@ -139,7 +139,7 @@ CxPlatDpRawInitialize(
     _Inout_ CXPLAT_DATAPATH* Datapath,
     _In_ uint32_t ClientRecvContextLength,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(WorkerPool);
@@ -214,7 +214,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDpRawUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);