merge main

Author: zeeshanlakhani

asic/src/softnpu/table.rs

@@ -265,7 +265,7 @@ impl TableOps<Handle> for Table {
                         }
                     }
                 }
-                ("forward", params)
+                ("forward_v6", params)
             }
             (ROUTER4_LOOKUP_RT, "forward_vlan") => {
                 let mut params = Vec::new();
@@ -339,7 +339,7 @@ impl TableOps<Handle> for Table {
                         }
                     }
                 }
-                ("forward_vlan", params)
+                ("forward_vlan_v6", params)
             }
             (ROUTER6_LOOKUP_IDX, "index") => {
                 let mut params = Vec::new();

dpd-api/src/lib.rs

@@ -46,6 +46,7 @@ use transceiver_controller::{
 };
 
 mod v1;
+mod v2;
 
 api_versions!([
     // WHEN CHANGING THE API (part 1 of 2):
@@ -59,6 +60,8 @@ api_versions!([
     // |  example for the next person.
     // v
     // (next_int, IDENT),
+    (6, CONSOLIDATED_V4_ROUTES),
+    (5, UPLINK_PORTS),
     (4, V4_OVER_V6_ROUTES),
     (3, ATTACHED_SUBNETS),
     (2, DUAL_STACK_NAT_WORKFLOW),
@@ -377,6 +380,34 @@ pub trait DpdApi {
     #[endpoint {
         method = POST,
         path = "/route/ipv4",
+        versions = ..VERSION_CONSOLIDATED_V4_ROUTES
+    }]
+    async fn route_ipv4_add_v1(
+        rqctx: RequestContext<Self::Context>,
+        update: TypedBody<v2::Ipv4RouteUpdate>,
+    ) -> Result<HttpResponseUpdatedNoContent, HttpError> {
+        let route = update.into_inner();
+        Self::route_ipv4_add(
+            rqctx,
+            TypedBody::from(Ipv4RouteUpdate {
+                cidr: route.cidr,
+                target: RouteTarget::V4(route.target),
+                replace: route.replace,
+            }),
+        )
+        .await
+    }
+
+    /**
+     * Route an IPv4 subnet to a link and a nexthop gateway (IPv4 or IPv6).
+     *
+     * This call can be used to create a new single-path route or to add new targets
+     * to a multipath route.
+     */
+    #[endpoint {
+        method = POST,
+        path = "/route/ipv4",
+        versions = VERSION_CONSOLIDATED_V4_ROUTES..
     }]
     async fn route_ipv4_add(
         rqctx: RequestContext<Self::Context>,
@@ -392,12 +423,23 @@ pub trait DpdApi {
     #[endpoint {
         method = POST,
         path = "/route/ipv4-over-ipv6",
-        versions = VERSION_V4_OVER_V6_ROUTES..,
+        versions = VERSION_V4_OVER_V6_ROUTES..VERSION_CONSOLIDATED_V4_ROUTES,
     }]
     async fn route_ipv4_over_ipv6_add(
         rqctx: RequestContext<Self::Context>,
         update: TypedBody<Ipv4OverIpv6RouteUpdate>,
-    ) -> Result<HttpResponseUpdatedNoContent, HttpError>;
+    ) -> Result<HttpResponseUpdatedNoContent, HttpError> {
+        let route = update.into_inner();
+        Self::route_ipv4_add(
+            rqctx,
+            TypedBody::from(Ipv4RouteUpdate {
+                cidr: route.cidr,
+                target: RouteTarget::V6(route.target),
+                replace: route.replace,
+            }),
+        )
+        .await
+    }
 
     /**
      * Route an IPv4 subnet to a link and a nexthop gateway.
@@ -408,6 +450,34 @@ pub trait DpdApi {
     #[endpoint {
         method = PUT,
         path = "/route/ipv4",
+        versions = ..VERSION_CONSOLIDATED_V4_ROUTES
+    }]
+    async fn route_ipv4_set_v1(
+        rqctx: RequestContext<Self::Context>,
+        update: TypedBody<v2::Ipv4RouteUpdate>,
+    ) -> Result<HttpResponseUpdatedNoContent, HttpError> {
+        let route = update.into_inner();
+        Self::route_ipv4_set(
+            rqctx,
+            TypedBody::from(Ipv4RouteUpdate {
+                cidr: route.cidr,
+                target: RouteTarget::V4(route.target),
+                replace: route.replace,
+            }),
+        )
+        .await
+    }
+
+    /**
+     * Route an IPv4 subnet to a link and a nexthop gateway (IPv4 or IPv6).
+     *
+     * This call can be used to create a new single-path route or to replace any
+     * existing routes with a new single-path route.
+     */
+    #[endpoint {
+        method = PUT,
+        path = "/route/ipv4",
+        versions = VERSION_CONSOLIDATED_V4_ROUTES..
     }]
     async fn route_ipv4_set(
         rqctx: RequestContext<Self::Context>,
@@ -423,12 +493,23 @@ pub trait DpdApi {
     #[endpoint {
         method = PUT,
         path = "/route/ipv4-over-ipv6",
-        versions = VERSION_V4_OVER_V6_ROUTES..,
+        versions = VERSION_V4_OVER_V6_ROUTES..VERSION_CONSOLIDATED_V4_ROUTES,
     }]
     async fn route_ipv4_over_ipv6_set(
         rqctx: RequestContext<Self::Context>,
         update: TypedBody<Ipv4OverIpv6RouteUpdate>,
-    ) -> Result<HttpResponseUpdatedNoContent, HttpError>;
+    ) -> Result<HttpResponseUpdatedNoContent, HttpError> {
+        let route = update.into_inner();
+        Self::route_ipv4_set(
+            rqctx,
+            TypedBody::from(Ipv4RouteUpdate {
+                cidr: route.cidr,
+                target: RouteTarget::V6(route.target),
+                replace: route.replace,
+            }),
+        )
+        .await
+    }
 
     /**
      * Remove all targets for the given subnet
@@ -448,6 +529,32 @@ pub trait DpdApi {
     #[endpoint {
         method = DELETE,
         path = "/route/ipv4/{cidr}/{port_id}/{link_id}/{tgt_ip}",
+        versions = ..VERSION_CONSOLIDATED_V4_ROUTES
+    }]
+    async fn route_ipv4_delete_target_v1(
+        rqctx: RequestContext<Self::Context>,
+        path: Path<v2::RouteTargetIpv4Path>,
+    ) -> Result<HttpResponseDeleted, HttpError> {
+        let p = path.into_inner();
+        Self::route_ipv4_delete_target(
+            rqctx,
+            Path::from(RouteTargetIpv4Path {
+                cidr: p.cidr,
+                port_id: p.port_id,
+                link_id: p.link_id,
+                tgt_ip: IpAddr::V4(p.tgt_ip),
+            }),
+        )
+        .await
+    }
+
+    /**
+     * Remove a single target for the given IPv4 subnet (IPv4 or IPv6 next hop)
+     */
+    #[endpoint {
+        method = DELETE,
+        path = "/route/ipv4/{cidr}/{port_id}/{link_id}/{tgt_ip}",
+        versions = VERSION_CONSOLIDATED_V4_ROUTES..
     }]
     async fn route_ipv4_delete_target(
         rqctx: RequestContext<Self::Context>,
@@ -988,21 +1095,50 @@ pub trait DpdApi {
     #[endpoint {
         method = GET,
         path = "/ports/{port_id}/links/{link_id}/nat_only",
+	versions = ..VERSION_UPLINK_PORTS
     }]
     async fn link_nat_only_get(
         rqctx: RequestContext<Self::Context>,
         path: Path<LinkPath>,
+    ) -> Result<HttpResponseOk<bool>, HttpError> {
+        Self::link_uplink_get(rqctx, path).await
+    }
+
+    /// Return whether a port is intended to carry uplink traffic
+    #[endpoint {
+        method = GET,
+        path = "/ports/{port_id}/links/{link_id}/uplink",
+	versions = VERSION_UPLINK_PORTS..
+    }]
+    async fn link_uplink_get(
+        rqctx: RequestContext<Self::Context>,
+        path: Path<LinkPath>,
     ) -> Result<HttpResponseOk<bool>, HttpError>;
 
     /// Set whether a port is configured to use drop non-nat traffic
     #[endpoint {
         method = PUT,
         path = "/ports/{port_id}/links/{link_id}/nat_only",
+	versions = ..VERSION_UPLINK_PORTS
     }]
     async fn link_nat_only_set(
         rqctx: RequestContext<Self::Context>,
         path: Path<LinkPath>,
         body: TypedBody<bool>,
+    ) -> Result<HttpResponseUpdatedNoContent, HttpError> {
+        Self::link_uplink_set(rqctx, path, body).await
+    }
+
+    /// Set whether a port is intended to carry uplink traffic
+    #[endpoint {
+        method = PUT,
+        path = "/ports/{port_id}/links/{link_id}/uplink",
+	versions = VERSION_UPLINK_PORTS..
+    }]
+    async fn link_uplink_set(
+        rqctx: RequestContext<Self::Context>,
+        path: Path<LinkPath>,
+        body: TypedBody<bool>,
     ) -> Result<HttpResponseUpdatedNoContent, HttpError>;
 
     /// Get the event history for the given link.
@@ -2083,15 +2219,15 @@ impl TryFrom<RouteTarget> for Ipv6Route {
     }
 }
 
-/// Represents a new or replacement mapping of a subnet to a single IPv4
-/// RouteTarget nexthop target.
+/// Represents a new or replacement mapping of an IPv4 subnet to a single
+/// RouteTarget nexthop target, which may be either IPv4 or IPv6.
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
 pub struct Ipv4RouteUpdate {
     /// Traffic destined for any address within the CIDR block is routed using
     /// this information.
     pub cidr: Ipv4Net,
     /// A single Route associated with this CIDR
-    pub target: Ipv4Route,
+    pub target: RouteTarget,
     /// Should this route replace any existing route?  If a route exists and
     /// this parameter is false, then the call will fail.
     pub replace: bool,
@@ -2198,7 +2334,8 @@ pub struct SubnetPath {
     pub subnet: IpNet,
 }
 
-/// Represents a single subnet->target route entry
+/// Represents a single subnet->target route entry with an IPv4 or IPv6
+/// next hop.
 #[derive(Deserialize, Serialize, JsonSchema)]
 pub struct RouteTargetIpv4Path {
     /// The subnet being routed
@@ -2207,8 +2344,8 @@ pub struct RouteTargetIpv4Path {
     pub port_id: PortId,
     /// The link to which packets should be sent
     pub link_id: LinkId,
-    /// The next hop in the IPv4 route
-    pub tgt_ip: Ipv4Addr,
+    /// The next hop in the route (IPv4 or IPv6)
+    pub tgt_ip: IpAddr,
 }
 
 #[derive(Deserialize, Serialize, JsonSchema)]

dpd-api/src/v2.rs

@@ -0,0 +1,41 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/
+//
+// Copyright 2026 Oxide Computer Company
+
+use std::net::Ipv4Addr;
+
+use common::ports::PortId;
+use dpd_types::link::LinkId;
+use dpd_types::route::Ipv4Route;
+use oxnet::Ipv4Net;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Represents a new or replacement mapping of a subnet to a single IPv4
+/// RouteTarget nexthop target.
+#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
+pub struct Ipv4RouteUpdate {
+    /// Traffic destined for any address within the CIDR block is routed using
+    /// this information.
+    pub cidr: Ipv4Net,
+    /// A single Route associated with this CIDR
+    pub target: Ipv4Route,
+    /// Should this route replace any existing route?  If a route exists and
+    /// this parameter is false, then the call will fail.
+    pub replace: bool,
+}
+
+/// Represents a single subnet->target route entry
+#[derive(Deserialize, Serialize, JsonSchema)]
+pub struct RouteTargetIpv4Path {
+    /// The subnet being routed
+    pub cidr: Ipv4Net,
+    /// The switch port to which packets should be sent
+    pub port_id: PortId,
+    /// The link to which packets should be sent
+    pub link_id: LinkId,
+    /// The next hop in the IPv4 route
+    pub tgt_ip: Ipv4Addr,
+}

dpd-client/tests/integration_tests/attached_subnet.rs

@@ -116,6 +116,7 @@ async fn test_egress(switch: &Switch, test: &ExternalTest) -> TestResult {
         tag: switch.client.inner().tag.clone(),
     };
     switch.client.link_ipv6_create(&port_id, &link_id, &entry).await.unwrap();
+    switch.set_uplink(test.uplink_port, true).await;
 
     // populate the ndp/arp table with the upstream router's mac and IP.
     if test.upstream_router_ip.parse::<Ipv4Addr>().is_ok() {

dpd-client/tests/integration_tests/common.rs

@@ -537,6 +537,15 @@ impl Switch {
         Ok(())
     }
 
+    pub async fn set_uplink(&self, phys_port: PhysPort, uplink: bool) {
+        let (port_id, link_id) = self.link_id(phys_port).unwrap();
+        self.client
+            .link_uplink_set(&port_id, &link_id, uplink)
+            .await
+            .unwrap()
+            .into_inner()
+    }
+
     pub fn tofino_port(&self, phys_port: PhysPort) -> u16 {
         let idx: usize = phys_port.into();
         if phys_port == NO_PORT {
@@ -1178,13 +1187,13 @@ async fn set_route_ipv4_common(
     let (port_id, link_id) = switch.link_id(phys_port).unwrap();
     let route = types::Ipv4RouteUpdate {
         cidr,
-        target: types::Ipv4Route {
+        target: types::RouteTarget::V4(types::Ipv4Route {
             port_id: port_id.clone(),
             link_id: link_id.clone(),
             tgt_ip,
             tag: switch.client.inner().tag.clone(),
             vlan_id,
-        },
+        }),
         replace: false,
     };
     switch
@@ -1231,20 +1240,20 @@ async fn set_route_ipv4_over_ipv6_common(
     let cidr = subnet.parse::<Ipv4Net>()?;
     let tgt_ip: Ipv6Addr = gw.parse()?;
     let (port_id, link_id) = switch.link_id(phys_port).unwrap();
-    let route = types::Ipv4OverIpv6RouteUpdate {
+    let route = types::Ipv4RouteUpdate {
         cidr,
-        target: types::Ipv6Route {
+        target: types::RouteTarget::V6(types::Ipv6Route {
             port_id: port_id.clone(),
             link_id: link_id.clone(),
             tgt_ip,
             tag: switch.client.inner().tag.clone(),
             vlan_id,
-        },
+        }),
         replace: false,
     };
     switch
         .client
-        .route_ipv4_over_ipv6_set(&route)
+        .route_ipv4_set(&route)
         .await
         .expect("Failed to add IPv4 route entry");