Remove QUIC_USE_RAW_DATAPATH macro (#3781)

* Remove QUIC_USE_RAW_DATAPATH (logic only)

* move logic to core side

* remove QUIC_USE_RAW_DATAPATH from test

* fix googletest version and add last line

* replace from flag to function call

* fix build error

* fix build/test issues

* implement CxPlatResolveRoute for normal socket

* add Getter of Datapath feature

* fix build issues

* adopt comments

* adopt comment and fix kernel build error

* fix kernel build error

* more fix for kernel build

* add preview_feature flag back

* refactoring CxPlatIsRouteReady

* fix linux code check

* fix comments

* fix IsRouteReady and clean ifdef for _KERNEL_MODE

* kernel build error

* Set RouteResolved for Rx

* fix more tests

* move global definition in header file

* kernel to avoid calling helper function

* move QuitTestIsFeatureSupported after RegistrationOpen

* supress warning

* remove QuitTestIsFeatureSupported from quic_gtest as it doesn't work as expected by dependency of MsQuicLib.Datapath

* remove raw feature check as much as possible

* ifdef for UseQTIP visibility

* Couple nits and cleanup

---------

Co-authored-by: Nick Banks <[email protected]>

Author: ami-GS

CMakeLists.txt

@@ -333,10 +333,6 @@ if (QUIC_ENABLE_SANITIZERS)
     list(APPEND QUIC_COMMON_DEFINES DISABLE_CXPLAT_POOL=1)
 endif()
 
-if(QUIC_USE_XDP)
-    list(APPEND QUIC_COMMON_DEFINES QUIC_USE_RAW_DATAPATH=1)
-endif()
-
 if(QUIC_OFFICIAL_RELEASE)
     list(APPEND QUIC_COMMON_DEFINES QUIC_OFFICIAL_RELEASE=1)
     message(STATUS "Configured for official release build")

src/core/connection.c

@@ -3287,7 +3287,6 @@ QuicConnQueueUnreachable(
     }
 }
 
-#ifdef QUIC_USE_RAW_DATAPATH
 _IRQL_requires_max_(DISPATCH_LEVEL)
 _Function_class_(CXPLAT_ROUTE_RESOLUTION_CALLBACK)
 void
@@ -3325,7 +3324,6 @@ QuicConnQueueRouteCompletion(
 
     QuicConnRelease(Connection, QUIC_CONN_REF_ROUTE);
 }
-#endif // QUIC_USE_RAW_DATAPATH
 
 //
 // Updates the current destination CID to the received packet's source CID, if
@@ -5594,9 +5592,7 @@ QuicConnRecvDatagrams(
             goto Drop;
         }
 
-#ifdef QUIC_USE_RAW_DATAPATH
         CxPlatUpdateRoute(&DatagramPath->Route, Datagram->Route);
-#endif
 
         if (DatagramPath != CurrentPath) {
             if (BatchCount != 0) {
@@ -5954,7 +5950,6 @@ QuicConnProcessUdpUnreachable(
     }
 }
 
-#ifdef QUIC_USE_RAW_DATAPATH
 _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 QuicConnProcessRouteCompletion(
@@ -6004,7 +5999,6 @@ QuicConnProcessRouteCompletion(
             NULL);
     }
 }
-#endif // QUIC_USE_RAW_DATAPATH
 
 _IRQL_requires_max_(PASSIVE_LEVEL)
 void
@@ -7592,12 +7586,10 @@ QuicConnDrainOperations(
             QuicConnTraceRundownOper(Connection);
             break;
 
-#ifdef QUIC_USE_RAW_DATAPATH
         case QUIC_OPER_TYPE_ROUTE_COMPLETION:
             QuicConnProcessRouteCompletion(
                 Connection, Oper->ROUTE.PhysicalAddress, Oper->ROUTE.PathId, Oper->ROUTE.Succeeded);
             break;
-#endif // QUIC_USE_RAW_DATAPATH
 
         default:
             CXPLAT_FRE_ASSERT(FALSE);

src/core/connection.h

@@ -1516,7 +1516,6 @@ QuicConnQueueUnreachable(
     _In_ const QUIC_ADDR* RemoteAddress
     );
 
-#ifdef QUIC_USE_RAW_DATAPATH
 //
 // Queues a route completion event to a connection for processing.
 //
@@ -1531,7 +1530,6 @@ QuicConnQueueRouteCompletion(
     _In_ uint8_t PathId,
     _In_ BOOLEAN Succeeded
     );
-#endif // QUIC_USE_RAW_DATAPATH
 
 //
 // Queues up an update to the packet tolerance we want the peer to use.

src/core/cubic.c

@@ -312,9 +312,9 @@ CubicCongestionControlOnCongestionEvent(
             "[conn][%p] Persistent congestion event",
             Connection);
         Connection->Stats.Send.PersistentCongestionCount++;
-#ifdef QUIC_USE_RAW_DATAPATH
-        Connection->Paths[0].Route.State = RouteSuspected;
-#endif
+
+        Connection->Paths[0].Route.State = RouteSuspected; // used only for RAW datapath
+
         Cubic->IsInPersistentCongestion = TRUE;
         Cubic->WindowPrior =
         Cubic->WindowMax =

src/core/library.c

@@ -1293,6 +1293,29 @@ QuicLibraryGetGlobalParam(
         Status = QUIC_STATUS_SUCCESS;
         break;
 
+    case QUIC_PARAM_GLOBAL_DATAPATH_FEATURES:
+        if (*BufferLength < sizeof(uint32_t)) {
+            *BufferLength = sizeof(uint32_t);
+            Status = QUIC_STATUS_BUFFER_TOO_SMALL;
+            break;
+        }
+
+        if (Buffer == NULL) {
+            Status = QUIC_STATUS_INVALID_PARAMETER;
+            break;
+        }
+
+        if (MsQuicLib.Datapath == NULL) {
+            Status = QUIC_STATUS_INVALID_STATE;
+            break;
+        }
+
+        *BufferLength = sizeof(uint32_t);
+        *(uint32_t*)Buffer = CxPlatDataPathGetSupportedFeatures(MsQuicLib.Datapath);
+
+        Status = QUIC_STATUS_SUCCESS;
+        break;
+
     case QUIC_PARAM_GLOBAL_VERSION_NEGOTIATION_ENABLED:
 
         if (*BufferLength < sizeof(BOOLEAN)) {

src/core/listener.c

@@ -293,7 +293,8 @@ MsQuicListenerStart(
 #ifdef QUIC_OWNING_PROCESS
     UdpConfig.OwningProcess = NULL;     // Owning process not supported for listeners.
 #endif
-#ifdef QUIC_USE_RAW_DATAPATH
+
+    // for RAW datapath
     UdpConfig.CibirIdLength = Listener->CibirId[0];
     UdpConfig.CibirIdOffsetSrc = MsQuicLib.CidServerIdLength + 2;
     UdpConfig.CibirIdOffsetDst = MsQuicLib.CidServerIdLength + 2;
@@ -304,7 +305,6 @@ MsQuicListenerStart(
             &Listener->CibirId[2],
             UdpConfig.CibirIdLength);
     }
-#endif
 
     CXPLAT_TEL_ASSERT(Listener->Binding == NULL);
     Status =

src/core/path.c

@@ -34,12 +34,12 @@ QuicPathInitialize(
     Path->RttVariance = Path->SmoothedRtt / 2;
     Path->EcnValidationState =
         Connection->Settings.EcnEnabled ? ECN_VALIDATION_TESTING : ECN_VALIDATION_FAILED;
-#ifdef QUIC_USE_RAW_DATAPATH
+
     if (MsQuicLib.ExecutionConfig &&
         MsQuicLib.ExecutionConfig->Flags & QUIC_EXECUTION_CONFIG_FLAG_QTIP) {
         CxPlatRandom(sizeof(Path->Route.TcpState.SequenceNumber), &Path->Route.TcpState.SequenceNumber);
     }
-#endif
+
     QuicTraceLogConnInfo(
         PathInitialized,
         Connection,
@@ -183,21 +183,6 @@ QuicConnGetPathByID(
     return NULL;
 }
 
-_IRQL_requires_max_(PASSIVE_LEVEL)
-void
-QuicCopyRouteInfo(
-    _Inout_ CXPLAT_ROUTE* DstRoute,
-    _In_ CXPLAT_ROUTE* SrcRoute
-    )
-{
-#ifdef QUIC_USE_RAW_DATAPATH
-    CxPlatCopyMemory(DstRoute, SrcRoute, (uint8_t*)&SrcRoute->State - (uint8_t*)SrcRoute);
-    CxPlatUpdateRoute(DstRoute, SrcRoute);
-#else
-    *DstRoute = *SrcRoute;
-#endif
-}
-
 _IRQL_requires_max_(PASSIVE_LEVEL)
 _Ret_maybenull_
 QUIC_PATH*

src/core/send.c

@@ -1018,6 +1018,45 @@ QuicSendGetNextStream(
     return NULL;
 }
 
+BOOLEAN
+CxPlatIsRouteReady(
+    _In_ QUIC_CONNECTION *Connection,
+    _In_ QUIC_PATH* Path
+    )
+{
+    //
+    // Make sure the route is resolved before sending packets.
+    //
+    if (Path->Route.State == RouteResolved) {
+        return TRUE;
+    }
+
+    //
+    // We need to set the path challenge flag back on so that when route is resolved,
+    // we know we need to continue to send the challenge.
+    //
+    CXPLAT_DBG_ASSERT(Path->IsActive);
+    if (Path->Route.State == RouteUnresolved || Path->Route.State == RouteSuspected) {
+        QuicConnAddRef(Connection, QUIC_CONN_REF_ROUTE);
+        QUIC_STATUS Status =
+            CxPlatResolveRoute(
+                Path->Binding->Socket, &Path->Route, Path->ID, (void*)Connection, QuicConnQueueRouteCompletion);
+        if (Status == QUIC_STATUS_SUCCESS) {
+            QuicConnRelease(Connection, QUIC_CONN_REF_ROUTE);
+            return TRUE;
+        }
+        //
+        // Route resolution failed or pended. We need to pause sending.
+        //
+        CXPLAT_DBG_ASSERT(Status == QUIC_STATUS_PENDING || QUIC_FAILED(Status));
+    }
+    //
+    // Path->Route.State == RouteResolving
+    // Can't send now. Once route resolution completes, we will resume sending.
+    //
+    return FALSE;
+}
+
 //
 // This function sends a path challenge frame out on all paths that currently
 // need one sent.
@@ -1042,37 +1081,10 @@ QuicSendPathChallenges(
             continue;
         }
 
-#ifdef QUIC_USE_RAW_DATAPATH
-        //
-        // Make sure the route is resolved before sending the path challenge.
-        //
-        // We need to set the path challenge flag back on so that when route is resolved,
-        // we know we need to continue to send the challenge.
-        //
-        CXPLAT_DBG_ASSERT(Path->Route.State != RouteSuspected);
-        if (Path->Route.State == RouteUnresolved) {
-            QuicConnAddRef(Connection, QUIC_CONN_REF_ROUTE);
-            QUIC_STATUS Status =
-                CxPlatResolveRoute(
-                    Path->Binding->Socket, &Path->Route, Path->ID, (void*)Connection, QuicConnQueueRouteCompletion);
-            if (Status == QUIC_STATUS_SUCCESS) {
-                QuicConnRelease(Connection, QUIC_CONN_REF_ROUTE);
-            } else {
-                //
-                // Route resolution failed or pended. We need to pause sending.
-                //
-                CXPLAT_DBG_ASSERT(Status == QUIC_STATUS_PENDING || QUIC_FAILED(Status));
-                Send->SendFlags |= QUIC_CONN_SEND_FLAG_PATH_CHALLENGE;
-                continue;
-            }
-        } else if (Path->Route.State == RouteResolving) {
-            //
-            // Can't send now. Once route resolution completes, we will resume sending.
-            //
+        if (!CxPlatIsRouteReady(Connection, Path)) {
             Send->SendFlags |= QUIC_CONN_SEND_FLAG_PATH_CHALLENGE;
             continue;
         }
-#endif
 
         QUIC_PACKET_BUILDER Builder = { 0 };
         if (!QuicPacketBuilderInitialize(&Builder, Connection, Path)) {
@@ -1159,32 +1171,9 @@ QuicSendFlush(
 
     CXPLAT_DBG_ASSERT(!Connection->State.HandleClosed);
 
-#ifdef QUIC_USE_RAW_DATAPATH
-    //
-    // Make sure the route is resolved before sending packets.
-    //
-    CXPLAT_DBG_ASSERT(Path->IsActive);
-    if (Path->Route.State == RouteUnresolved || Path->Route.State == RouteSuspected) {
-        QuicConnAddRef(Connection, QUIC_CONN_REF_ROUTE);
-        QUIC_STATUS Status =
-            CxPlatResolveRoute(
-                Path->Binding->Socket, &Path->Route, Path->ID, (void*)Connection, QuicConnQueueRouteCompletion);
-        if (Status == QUIC_STATUS_SUCCESS) {
-            QuicConnRelease(Connection, QUIC_CONN_REF_ROUTE);
-        } else {
-            //
-            // Route resolution failed or pended. We need to pause sending.
-            //
-            CXPLAT_DBG_ASSERT(Status == QUIC_STATUS_PENDING || QUIC_FAILED(Status));
-            return TRUE;
-        }
-    } else if (Path->Route.State == RouteResolving) {
-        //
-        // Can't send now. Once route resolution completes, we will resume sending.
-        //
+    if (!CxPlatIsRouteReady(Connection, Path)) {
         return TRUE;
     }
-#endif
 
     QuicConnTimerCancel(Connection, QUIC_CONN_TIMER_PACING);
     QuicConnRemoveOutFlowBlockedReason(

src/inc/msquicp.h

@@ -114,6 +114,7 @@ typedef struct QUIC_PRIVATE_TRANSPORT_PARAMETER {
 #define QUIC_PARAM_GLOBAL_VERSION_NEGOTIATION_ENABLED   0x81000003  // BOOLEAN
 #endif
 #define QUIC_PARAM_GLOBAL_IN_USE                        0x81000004  // BOOLEAN
+#define QUIC_PARAM_GLOBAL_DATAPATH_FEATURES             0x81000005  // uint32_t
 
 //
 // The different private parameters for Configuration.