Invert platform/core worker-statistics dependency; return NOT_SUPPORTED in kernel mode

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: guhetier

src/core/library.c

@@ -1506,6 +1506,67 @@ QuicLibrarySetGlobalParam(
     return Status;
 }
 
+#ifndef _KERNEL_MODE
+//
+// Fills the caller's buffer with the per-worker statistics for the global
+// worker pool, mapping the platform's raw statistics into the public shape.
+//
+_IRQL_requires_max_(PASSIVE_LEVEL)
+QUIC_STATUS
+QuicLibraryGetGlobalWorkerStatistics(
+    _Inout_ uint32_t* BufferLength,
+    _Out_writes_bytes_opt_(*BufferLength)
+        void* Buffer
+    )
+{
+    if (MsQuicLib.WorkerPool == NULL) {
+        return QUIC_STATUS_INVALID_STATE;
+    }
+
+    uint32_t WorkerCount = CxPlatWorkerPoolGetCount(MsQuicLib.WorkerPool);
+    uint32_t RequiredSize =
+        sizeof(QUIC_WORKER_STATISTICS_LIST) +
+        WorkerCount * sizeof(QUIC_WORKER_STATISTICS);
+
+    if (*BufferLength < RequiredSize) {
+        *BufferLength = RequiredSize;
+        return QUIC_STATUS_BUFFER_TOO_SMALL;
+    }
+
+    if (Buffer == NULL) {
+        return QUIC_STATUS_INVALID_PARAMETER;
+    }
+
+    QUIC_WORKER_STATISTICS_LIST* List = (QUIC_WORKER_STATISTICS_LIST*)Buffer;
+    List->WorkerCount = WorkerCount;
+    List->WorkerStatsSize = sizeof(QUIC_WORKER_STATISTICS);
+
+    QUIC_WORKER_STATISTICS* PublicStats =
+        (QUIC_WORKER_STATISTICS*)((uint8_t*)Buffer + sizeof(QUIC_WORKER_STATISTICS_LIST));
+    CxPlatZeroMemory(PublicStats, WorkerCount * sizeof(QUIC_WORKER_STATISTICS));
+
+    if (WorkerCount > 0) {
+        CXPLAT_WORKER_STATISTICS* RawStats =
+            CXPLAT_ALLOC_PAGED(
+                WorkerCount * sizeof(CXPLAT_WORKER_STATISTICS),
+                QUIC_POOL_GENERIC);
+        if (RawStats == NULL) {
+            return QUIC_STATUS_OUT_OF_MEMORY;
+        }
+        CxPlatWorkerPoolGetStatistics(MsQuicLib.WorkerPool, RawStats, WorkerCount);
+        for (uint32_t i = 0; i < WorkerCount; i++) {
+            PublicStats[i].IdealProcessor = RawStats[i].IdealProcessor;
+            PublicStats[i].CumulativeActiveTimeUs = RawStats[i].CumulativeActiveTimeUs;
+            PublicStats[i].CumulativeWallTimeUs = RawStats[i].CumulativeWallTimeUs;
+        }
+        CXPLAT_FREE(RawStats, QUIC_POOL_GENERIC);
+    }
+
+    *BufferLength = RequiredSize;
+    return QUIC_STATUS_SUCCESS;
+}
+#endif // !_KERNEL_MODE
+
 _IRQL_requires_max_(PASSIVE_LEVEL)
 QUIC_STATUS
 QuicLibraryGetGlobalParam(
@@ -1876,43 +1937,18 @@ QuicLibraryGetGlobalParam(
         break;
     }
 
-#ifndef _KERNEL_MODE
     case QUIC_PARAM_GLOBAL_WORKER_STATISTICS: {
-
-        if (MsQuicLib.WorkerPool == NULL) {
-            Status = QUIC_STATUS_INVALID_STATE;
-            break;
-        }
-
-        uint32_t WorkerCount = CxPlatWorkerPoolGetCount(MsQuicLib.WorkerPool);
-        uint32_t RequiredSize =
-            sizeof(QUIC_WORKER_STATISTICS_LIST) +
-            WorkerCount * sizeof(QUIC_WORKER_STATISTICS);
-
-        if (*BufferLength < RequiredSize) {
-            *BufferLength = RequiredSize;
-            Status = QUIC_STATUS_BUFFER_TOO_SMALL;
-            break;
-        }
-
-        if (Buffer == NULL) {
-            Status = QUIC_STATUS_INVALID_PARAMETER;
-            break;
-        }
-
-        QUIC_WORKER_STATISTICS_LIST* List = (QUIC_WORKER_STATISTICS_LIST*)Buffer;
-        List->WorkerCount = WorkerCount;
-        List->WorkerStatsSize = sizeof(QUIC_WORKER_STATISTICS);
-
-        QUIC_WORKER_STATISTICS* Stats =
-            (QUIC_WORKER_STATISTICS*)((uint8_t*)Buffer + sizeof(QUIC_WORKER_STATISTICS_LIST));
-        CxPlatWorkerPoolGetStatistics(MsQuicLib.WorkerPool, Stats, WorkerCount);
-
-        *BufferLength = RequiredSize;
-        Status = QUIC_STATUS_SUCCESS;
+#ifdef _KERNEL_MODE
+        //
+        // Worker statistics are not supported in kernel mode, where the worker
+        // threads are not owned by the platform worker pool.
+        //
+        Status = QUIC_STATUS_NOT_SUPPORTED;
+#else
+        Status = QuicLibraryGetGlobalWorkerStatistics(BufferLength, Buffer);
+#endif
         break;
     }
-#endif
 
     default:
         Status = QUIC_STATUS_INVALID_PARAMETER;

src/inc/quic_platform.h

@@ -557,14 +557,24 @@ CxPlatWorkerPoolWorkerPoll(
     _In_ QUIC_EXECUTION* Execution
     );
 
+//
+// Raw per-worker statistics owned by the platform layer. The core layer maps
+// these into the public QUIC_WORKER_STATISTICS shape, keeping the platform
+// layer free of any dependency on core/public types.
+//
+typedef struct CXPLAT_WORKER_STATISTICS {
+    uint64_t CumulativeActiveTimeUs;    // Time the worker spent active (not idle).
+    uint64_t CumulativeWallTimeUs;      // Wall time since the worker thread started.
+    uint16_t IdealProcessor;            // CPU the worker is affinitized to.
+} CXPLAT_WORKER_STATISTICS;
+
 //
 // Gets the statistics for all workers in the pool.
 //
-typedef struct QUIC_WORKER_STATISTICS QUIC_WORKER_STATISTICS; // Forward declaration
 void
 CxPlatWorkerPoolGetStatistics(
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _Out_writes_(WorkerCount) QUIC_WORKER_STATISTICS* Stats,
+    _Out_writes_(WorkerCount) CXPLAT_WORKER_STATISTICS* Stats,
     _In_ uint32_t WorkerCount
     );
 

src/platform/platform_worker.c

@@ -881,7 +881,7 @@ CXPLAT_THREAD_CALLBACK(CxPlatWorkerThread, Context)
 void
 CxPlatWorkerPoolGetStatistics(
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _Out_writes_(WorkerCount) QUIC_WORKER_STATISTICS* Stats,
+    _Out_writes_(WorkerCount) CXPLAT_WORKER_STATISTICS* Stats,
     _In_ uint32_t WorkerCount
     )
 {
@@ -892,7 +892,7 @@ CxPlatWorkerPoolGetStatistics(
     //
     // Note: The active time that has not been accumulated yet is ignored.
     //
-    CxPlatZeroMemory(Stats, WorkerCount * sizeof(QUIC_WORKER_STATISTICS));
+    CxPlatZeroMemory(Stats, WorkerCount * sizeof(CXPLAT_WORKER_STATISTICS));
     for (uint32_t i = 0; i < WorkerCount; i++) {
         CXPLAT_WORKER* Worker = &WorkerPool->Workers[i];
         Stats[i].IdealProcessor = Worker->IdealProcessor;

src/test/bin/winkernel/control.cpp

@@ -466,7 +466,7 @@ ExecuteTestRequest(
 #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
     RegisterTestFunction(QuicTestValidateEncryptDecryptPerfCounters);
 #endif
-#ifndef _KERNEL_MODE
+#ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
     RegisterTestFunction(QuicTestGetWorkerStatistics);
     RegisterTestFunction(QuicTestValidateWorkerStatistics);
 #endif

src/test/lib/ApiTest.cpp

@@ -6057,6 +6057,19 @@ QuicTestGetWorkerStatistics()
     MsQuicRegistration Registration;
     TEST_QUIC_SUCCEEDED(Registration.GetInitStatus());
 
+#ifdef _KERNEL_MODE
+    //
+    // Worker statistics are not supported in kernel mode.
+    //
+    uint32_t UnsupportedLength = 0;
+    TEST_EQUAL(
+        MsQuic->GetParam(
+            nullptr,
+            QUIC_PARAM_GLOBAL_WORKER_STATISTICS,
+            &UnsupportedLength,
+            nullptr),
+        QUIC_STATUS_NOT_SUPPORTED);
+#else
     //
     // Test getting the required size with zero-length buffer.
     //
@@ -6130,6 +6143,7 @@ QuicTestGetWorkerStatistics()
     }
 
     delete[] Buffer;
+#endif // _KERNEL_MODE
 }
 
 void
@@ -6142,6 +6156,19 @@ QuicTestValidateWorkerStatistics()
     MsQuicRegistration Registration(true);
     TEST_QUIC_SUCCEEDED(Registration.GetInitStatus());
 
+#ifdef _KERNEL_MODE
+    //
+    // Worker statistics are not supported in kernel mode.
+    //
+    uint32_t UnsupportedLength = 0;
+    TEST_EQUAL(
+        MsQuic->GetParam(
+            nullptr,
+            QUIC_PARAM_GLOBAL_WORKER_STATISTICS,
+            &UnsupportedLength,
+            nullptr),
+        QUIC_STATUS_NOT_SUPPORTED);
+#else
     MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", ServerSelfSignedCredConfig);
     TEST_QUIC_SUCCEEDED(ServerConfiguration.GetInitStatus());
 
@@ -6227,6 +6254,7 @@ QuicTestValidateWorkerStatistics()
 
     delete[] BeforeBuffer;
     delete[] AfterBuffer;
+#endif // _KERNEL_MODE
 }
 #endif // QUIC_API_ENABLE_PREVIEW_FEATURES