Normal traffic finishes router ingress before tunneling to a remote
transit port and does not execute its egress pipeline locally.  Omit
ordinary remote-inport and remote egress flows, while retaining disabled-
inport rejection before pruning and shared tunneled-reply learning.

Keep address-global router handling, DHCP responses, peer-datapath
neighbor resolution, routes and policies selecting remote outputs, and
ECMP stateful egress commits.  Those conntrack commits and remote-output
MTU checks execute in ingress before physical tunneling.  Remote network
ID assignments are reachable but redundant: their only consumer is
logical egress SNAT and the ID is not preserved across the tunnel.

Require a remote binding type as well as a remote chassis when
classifying transit ports.  Northd can retain the old remote SB chassis
on a patch binding after requested-chassis changes; that must not
suppress restored ordinary port flows.

Reported-at: https://redhat.atlassian.net/browse/FDP-4694
Assisted-by: GPT-6.1 Sol, OpenCode
Signed-off-by: Ales Musil <[email protected]>
---
 Documentation/ref/ovn-logical-flows.7.rst |   8 +
 northd/northd.c                           | 189 +++++++++++++---------
 tests/ovn-northd.at                       | 168 +++++++++++++++++++
 3 files changed, 293 insertions(+), 72 deletions(-)

diff --git a/Documentation/ref/ovn-logical-flows.7.rst 
b/Documentation/ref/ovn-logical-flows.7.rst
index c3cc08fc9..471c2b7f4 100644
--- a/Documentation/ref/ovn-logical-flows.7.rst
+++ b/Documentation/ref/ovn-logical-flows.7.rst
@@ -2060,6 +2060,14 @@ Logical Router Datapaths
 Logical router datapaths will only exist for ``Logical_Router`` rows in the OVN
 Northbound database that do not have ``enabled`` set to ``false``
 
+Remote transit router ports do not receive ordinary ingress traffic or execute
+local egress delivery.  Their per-port admission, neighbor request handling,
+router advertisements, and ingress error responses are therefore omitted.
+Tunneled neighbor replies use shared admission and learning flows instead.
+Routes selecting remote ports, neighbor resolution, and output MTU checks still
+run locally before tunneling and remain installed, as do router-wide flows
+matching the remote ports' IP addresses.
+
 .. _lr-in-0:
 
 Ingress Table 0: L2 Admission Control
diff --git a/northd/northd.c b/northd/northd.c
index 50b0b7d5f..40c56fb8a 100644
--- a/northd/northd.c
+++ b/northd/northd.c
@@ -1044,13 +1044,14 @@ is_cr_port(const struct ovn_port *op)
     return op->primary_port;
 }
 
-/* This function returns true if 'op' is a router port that has as
- * requested chassis a remote chassis, i.e., if 'op' is a transit router
- * port. */
+/* Returns true for remote transit router bindings.  A patch binding may
+ * retain its old remote chassis after requested-chassis changes, so the
+ * binding type must also be checked. */
 static bool
-is_transit_router_port(struct ovn_port *op)
+is_transit_router_port(const struct ovn_port *op)
 {
     return op->nbrp &&
+           !strcmp(op->sb->type, "remote") &&
            op->sb->chassis &&
            smap_get_bool(&op->sb->chassis->other_config, "is-remote", false);
 }
@@ -12530,25 +12531,24 @@ get_route_table_id(struct simap *route_tables, const 
char *route_table_name)
 }
 
 static void
-build_route_table_lflow(struct ovn_datapath *od, struct lflow_table *lflows,
-                        struct nbrec_logical_router_port *lrp,
+build_route_table_lflow(struct ovn_port *op, struct lflow_table *lflows,
                         struct simap *route_tables,
                         struct lflow_ref *lflow_ref)
 {
     struct ds match = DS_EMPTY_INITIALIZER;
     struct ds actions = DS_EMPTY_INITIALIZER;
 
-    const char *route_table_name = smap_get(&lrp->options, "route_table");
+    const char *route_table_name = smap_get(&op->nbrp->options, "route_table");
     uint32_t rtb_id = get_route_table_id(route_tables, route_table_name);
-    if (!rtb_id) {
+    if (!rtb_id || is_transit_router_port(op)) {
         return;
     }
 
-    ds_put_format(&match, "inport == \"%s\"", lrp->name);
+    ds_put_format(&match, "inport == %s", op->json_key);
     ds_put_format(&actions, "%s = %d; next;",
                   REG_ROUTE_TABLE_ID, rtb_id);
 
-    ovn_lflow_add(lflows, od, S_ROUTER_IN_IP_ROUTING_PRE, 100,
+    ovn_lflow_add(lflows, op->od, S_ROUTER_IN_IP_ROUTING_PRE, 100,
                   ds_cstr(&match), ds_cstr(&actions), lflow_ref);
 
     ds_destroy(&match);
@@ -13373,6 +13373,10 @@ add_route(struct lflow_table *lflows, const struct 
ovn_datapath *od,
         }
     }
 
+    if (op_inport && is_transit_router_port(op_inport)) {
+        return;
+    }
+
     if (op_inport) {
         ds_put_format(&match, "inport == %s && ", op_inport->json_key);
     }
@@ -13423,7 +13427,8 @@ add_route(struct lflow_table *lflows, const struct 
ovn_datapath *od,
     ovn_lflow_add(lflows, od, S_ROUTER_IN_IP_ROUTING, priority,
                   ds_cstr(&match), ds_cstr(&actions), lflow_ref,
                   WITH_HINT(stage_hint));
-    if (op && bfd_is_port_running(bfd_ports, op->key)) {
+    if (op && !is_transit_router_port(op) &&
+        bfd_is_port_running(bfd_ports, op->key)) {
         /* BFD packets generated by ovn-controller are injected with their
          * logical router port set as the logical inport.  Scope this helper
          * route to that port so LRPs sharing a connected prefix do not
@@ -14448,6 +14453,10 @@ build_lrouter_arp_flow(const struct ovn_datapath *od, 
struct ovn_port *op,
                        struct lflow_table *lflows,
                        struct lflow_ref *lflow_ref)
 {
+    if (op && is_transit_router_port(op)) {
+        return;
+    }
+
     struct ds match = DS_EMPTY_INITIALIZER;
     struct ds actions = DS_EMPTY_INITIALIZER;
 
@@ -14497,6 +14506,10 @@ build_lrouter_nd_flow(const struct ovn_datapath *od, 
struct ovn_port *op,
                       const struct shash *meter_groups,
                       struct lflow_ref *lflow_ref)
 {
+    if (op && is_transit_router_port(op)) {
+        return;
+    }
+
     struct ds match = DS_EMPTY_INITIALIZER;
     struct ds actions = DS_EMPTY_INITIALIZER;
 
@@ -14858,7 +14871,8 @@ build_lrouter_force_snat_flows_op(struct ovn_port *op,
     size_t network_id;
 
     ovs_assert(op->nbrp);
-    if (!op->peer || !lrnat_rec->lb_force_snat_router_ip) {
+    if (is_transit_router_port(op) || !op->peer ||
+        !lrnat_rec->lb_force_snat_router_ip) {
         return;
     }
 
@@ -15177,6 +15191,11 @@ build_adm_ctrl_flows_for_lrouter_port(
         return;
     }
 
+    if (is_transit_router_port(op)) {
+        /* Tunneled replies use the shared transit-router admission rule. */
+        return;
+    }
+
     if (is_cr_port(op)) {
         /* No ingress packets should be received on a chassisredirect
          * port. */
@@ -15381,6 +15400,10 @@ build_neigh_learning_flows_for_lrouter_port(
 {
     ovs_assert(op->nbrp);
 
+    if (is_transit_router_port(op)) {
+        return;
+    }
+
     bool learn_from_arp_request = smap_get_bool(&op->od->nbr->options,
         "always_learn_from_arp_request", true);
 
@@ -15504,7 +15527,7 @@ build_ND_RA_flows_for_lrouter_port(
         struct lflow_ref *lflow_ref)
 {
     ovs_assert(op->nbrp);
-    if (op->nbrp->peer || !op->peer) {
+    if (is_transit_router_port(op) || op->nbrp->peer || !op->peer) {
         return;
     }
 
@@ -15639,7 +15662,7 @@ build_ip_routing_pre_flows_for_lrouter(struct 
ovn_datapath *od,
 static void
 build_default_route_flows_for_lrouter(
         struct ovn_datapath *od, struct lflow_table *lflows,
-        struct simap *route_tables)
+        struct simap *route_tables, const struct hmap *lr_ports)
 {
     ovn_lflow_add_default_drop(lflows, od, S_ROUTER_IN_IP_ROUTING_ECMP,
                                od->datapath_lflows);
@@ -15650,8 +15673,10 @@ build_default_route_flows_for_lrouter(
                   od->datapath_lflows);
 
     for (int i = 0; i < od->nbr->n_ports; i++) {
-        build_route_table_lflow(od, lflows, od->nbr->ports[i],
-                                route_tables, NULL);
+        struct ovn_port *op = ovn_port_find(lr_ports, od->nbr->ports[i]->name);
+        if (op) {
+            build_route_table_lflow(op, lflows, route_tables, NULL);
+        }
     }
 
 }
@@ -15691,10 +15716,11 @@ static void
 build_route_flows_for_lrouter(
         struct ovn_datapath *od, struct lflow_table *lflows,
         const struct group_ecmp_route_data *route_data,
-        struct simap *route_tables, const struct sset *bfd_ports)
+        struct simap *route_tables, const struct sset *bfd_ports,
+        const struct hmap *lr_ports)
 {
     ovs_assert(od->nbr);
-    build_default_route_flows_for_lrouter(od, lflows, route_tables);
+    build_default_route_flows_for_lrouter(od, lflows, route_tables, lr_ports);
 
     const struct group_ecmp_datapath *datapath_node =
         group_ecmp_datapath_lookup(route_data, od);
@@ -16523,10 +16549,13 @@ build_check_pkt_len_flows_for_lrp(struct ovn_port *op,
                            match, actions, &op->nbrp->header_, lflow_ref,
                            "%s", mtu_flow_action);
 
-    /* ingress traffic */
-    build_icmperr_pkt_big_flows(op, gw_mtu, lflows, meter_groups,
-                                match, actions, S_ROUTER_IN_IP_INPUT,
-                                NULL, NULL, lflow_ref);
+    /* Ingress errors are local, but the remote-outport size check above
+     * still runs before tunneling. */
+    if (!is_transit_router_port(op)) {
+        build_icmperr_pkt_big_flows(op, gw_mtu, lflows, meter_groups,
+                                    match, actions, S_ROUTER_IN_IP_INPUT,
+                                    NULL, NULL, lflow_ref);
+    }
 
     /* Additional match at egress on tracked and reply and dnat-ed traffic. */
     char *ct_match = features->ct_state_save
@@ -16538,7 +16567,7 @@ build_check_pkt_len_flows_for_lrp(struct ovn_port *op,
     for (size_t i = 0; i < op->od->nbr->n_ports; i++) {
         struct ovn_port *rp = ovn_port_find(lr_ports,
                                             op->od->nbr->ports[i]->name);
-        if (!rp || rp == op) {
+        if (!rp || rp == op || is_transit_router_port(rp)) {
             continue;
         }
 
@@ -16788,6 +16817,12 @@ build_lrouter_network_id_flows(
     size_t network_id;
 
     HMAP_FOR_EACH (op, dp_node, &od->ports) {
+        /* The ID is consumed only by egress SNAT and is not carried over
+         * the tunnel.  Assigning it for a remote outport is redundant. */
+        if (is_transit_router_port(op)) {
+            continue;
+        }
+
         for (size_t i = 0; i < op->lrp_networks.n_ipv4_addrs; i++) {
             if (i > OVN_MAX_NETWORK_ID) {
                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
@@ -16879,6 +16914,10 @@ build_egress_delivery_flows_for_lrouter_port(
         struct lflow_ref *lflow_ref)
 {
     ovs_assert(op->nbrp);
+    if (is_transit_router_port(op)) {
+        return;
+    }
+
     if (!lrport_is_enabled(op->nbrp)) {
         /* Drop packets to disabled logical ports (since logical flow
          * tables are default-drop). */
@@ -17139,59 +17178,65 @@ build_dhcp_relay_flows_for_lrouter_port(struct 
ovn_port *op,
         return;
     }
 
-    ds_clear(match);
-    ds_clear(actions);
-
-    ds_put_format(
-        match, "inport == %s && "
-        "ip4.src == {0.0.0.0, %s/%u} && ip4.dst == 255.255.255.255 && "
-        "ip.frag == 0 && udp.src == 68 && udp.dst == 67",
-        op->json_key, lrp_ipv4_addr->network_s, lrp_ipv4_addr->plen);
-    ds_put_format(actions,
-                  REGBIT_DHCP_RELAY_REQ_CHK
-                  " = dhcp_relay_req_chk(%s, %s);"
-                  "next; /* DHCP_RELAY_REQ */",
-                  lrp_ipv4_addr->addr_s, server_ip_str);
+    if (!is_transit_router_port(op)) {
+        ds_clear(match);
+        ds_clear(actions);
 
-    ovn_lflow_add(lflows, op->od, S_ROUTER_IN_IP_INPUT, 110, ds_cstr(match),
-                  ds_cstr(actions), lflow_ref,
-                  WITH_CTRL_METER(copp_meter_get(COPP_DHCPV4_RELAY,
-                                                 op->od->nbr->copp,
-                                                 meter_groups)),
-                  WITH_HINT(&op->nbrp->header_));
+        ds_put_format(
+            match, "inport == %s && "
+            "ip4.src == {0.0.0.0, %s/%u} && ip4.dst == 255.255.255.255 && "
+            "ip.frag == 0 && udp.src == 68 && udp.dst == 67",
+            op->json_key, lrp_ipv4_addr->network_s, lrp_ipv4_addr->plen);
+        ds_put_format(actions,
+                      REGBIT_DHCP_RELAY_REQ_CHK
+                      " = dhcp_relay_req_chk(%s, %s);"
+                      "next; /* DHCP_RELAY_REQ */",
+                      lrp_ipv4_addr->addr_s, server_ip_str);
 
-    ds_clear(match);
-    ds_clear(actions);
+        ovn_lflow_add(lflows, op->od, S_ROUTER_IN_IP_INPUT, 110,
+                      ds_cstr(match), ds_cstr(actions), lflow_ref,
+                      WITH_CTRL_METER(copp_meter_get(COPP_DHCPV4_RELAY,
+                                                     op->od->nbr->copp,
+                                                     meter_groups)),
+                      WITH_HINT(&op->nbrp->header_));
+    }
 
-    ds_put_format(
-        match, "inport == %s && "
-        "ip4.src == {0.0.0.0, %s/%u} && ip4.dst == 255.255.255.255 && "
-        "udp.src == 68 && udp.dst == 67 && "
-        REGBIT_DHCP_RELAY_REQ_CHK,
-        op->json_key, lrp_ipv4_addr->network_s, lrp_ipv4_addr->plen);
-    ds_put_format(actions,
-                  "ip4.src = %s; ip4.dst = %s; udp.src = 67; next; "
-                  "/* DHCP_RELAY_REQ */",
-                  lrp_ipv4_addr->addr_s, server_ip_str);
+    if (!is_transit_router_port(op)) {
+        ds_clear(match);
+        ds_clear(actions);
 
-    ovn_lflow_add(lflows, op->od, S_ROUTER_IN_DHCP_RELAY_REQ, 100,
-                  ds_cstr(match), ds_cstr(actions), lflow_ref,
-                  WITH_HINT(&op->nbrp->header_));
+        ds_put_format(
+            match, "inport == %s && "
+            "ip4.src == {0.0.0.0, %s/%u} && ip4.dst == 255.255.255.255 && "
+            "udp.src == 68 && udp.dst == 67 && "
+            REGBIT_DHCP_RELAY_REQ_CHK,
+            op->json_key, lrp_ipv4_addr->network_s, lrp_ipv4_addr->plen);
+        ds_put_format(actions,
+                      "ip4.src = %s; ip4.dst = %s; udp.src = 67; next; "
+                      "/* DHCP_RELAY_REQ */",
+                      lrp_ipv4_addr->addr_s, server_ip_str);
 
-    ds_clear(match);
-    ds_clear(actions);
+        ovn_lflow_add(lflows, op->od, S_ROUTER_IN_DHCP_RELAY_REQ, 100,
+                      ds_cstr(match), ds_cstr(actions), lflow_ref,
+                      WITH_HINT(&op->nbrp->header_));
+    }
 
-    ds_put_format(
-        match, "inport == %s && "
-        "ip4.src == {0.0.0.0, %s/%u} && ip4.dst == 255.255.255.255 && "
-        "udp.src == 68 && udp.dst == 67 && "
-        REGBIT_DHCP_RELAY_REQ_CHK" == 0",
-        op->json_key, lrp_ipv4_addr->network_s, lrp_ipv4_addr->plen);
-    ds_put_format(actions, "drop; /* DHCP_RELAY_REQ */");
+    if (!is_transit_router_port(op)) {
+        ds_clear(match);
+        ds_clear(actions);
 
-    ovn_lflow_add(lflows, op->od, S_ROUTER_IN_DHCP_RELAY_REQ, 1,
-                  ds_cstr(match), ds_cstr(actions), lflow_ref,
-                  WITH_HINT(&op->nbrp->header_));
+        ds_put_format(
+            match, "inport == %s && "
+            "ip4.src == {0.0.0.0, %s/%u} && ip4.dst == 255.255.255.255 && "
+            "udp.src == 68 && udp.dst == 67 && "
+            REGBIT_DHCP_RELAY_REQ_CHK" == 0",
+            op->json_key, lrp_ipv4_addr->network_s, lrp_ipv4_addr->plen);
+        ds_put_format(actions, "drop; /* DHCP_RELAY_REQ */");
+
+        ovn_lflow_add(lflows, op->od, S_ROUTER_IN_DHCP_RELAY_REQ, 1,
+                      ds_cstr(match), ds_cstr(actions), lflow_ref,
+                      WITH_HINT(&op->nbrp->header_));
+    }
 
     ds_clear(match);
     ds_clear(actions);
@@ -17267,7 +17312,7 @@ build_lrouter_ipv4_default_ttl_expired_flows(
     const struct shash *meter_groups,
     struct lflow_ref *lflow_ref)
 {
-    if (!op->lrp_networks.n_ipv4_addrs) {
+    if (is_transit_router_port(op) || !op->lrp_networks.n_ipv4_addrs) {
         return;
     }
 
@@ -17344,7 +17389,7 @@ build_lrouter_ipv6_default_ttl_expired_flows(
     /* Early return if no IPv6 addresses are configured.
      * Note: op->lrp_networks.ipv6_addrs will always have LLA and that
      * will be last in the list. */
-    if (op->lrp_networks.n_ipv6_addrs < 1) {
+    if (is_transit_router_port(op) || op->lrp_networks.n_ipv6_addrs < 1) {
         return;
     }
 
@@ -20354,7 +20399,7 @@ build_lswitch_and_lrouter_iterate_by_lr(struct 
ovn_datapath *od,
                                            od->datapath_lflows);
     build_route_flows_for_lrouter(od, lsi->lflows,
                                   lsi->route_data, lsi->route_tables,
-                                  lsi->bfd_ports);
+                                  lsi->bfd_ports, lsi->lr_ports);
     build_mcast_lookup_flows_for_lrouter(od, lsi->lflows, &lsi->match,
                                          od->datapath_lflows);
     build_default_ingress_policy_flows_for_lrouter(od, lsi->lflows,
diff --git a/tests/ovn-northd.at b/tests/ovn-northd.at
index 01d3c93f1..701f72500 100644
--- a/tests/ovn-northd.at
+++ b/tests/ovn-northd.at
@@ -17241,6 +17241,174 @@ OVN_CLEANUP_NORTHD
 AT_CLEANUP
 ])
 
+OVN_FOR_EACH_NORTHD_NO_HV([
+AT_SETUP([Transit router - remote port flows])
+ovn_start
+
+check ovn-sbctl chassis-add remote geneve 192.0.2.2 \
+    -- set chassis remote other_config:is-remote=true
+check ovn-sbctl chassis-add local geneve 192.0.2.1
+check ovn-nbctl lr-add tr -- lr-add ordinary \
+    -- lrp-add ordinary ordinary-port 00:00:00:00:03:01 10.0.3.1/24 
fd00:3::1/64
+for p in 1 2; do
+    check ovn-nbctl lrp-add tr rp$p 00:00:00:00:0$p:01 10.0.$p.1/24 
fd00:$p::1/64 \
+        -- set Logical_Router_Port rp$p options:route_table=blue 
options:gateway_mtu=1400 \
+            options:prefix_delegation=true \
+            ipv6_ra_configs:address_mode=slaac \
+        -- ls-add ls$p -- lsp-add-router-port ls$p ls$p-tr rp$p
+    relay=$(ovn-nbctl create DHCP_Relay servers=10.0.3.2)
+    check ovn-nbctl set Logical_Router_Port rp$p dhcp_relay=$relay \
+        -- set Logical_Switch ls$p other_config:dhcp_relay_port=ls$p-tr
+    check ovn-nbctl --bfd lr-route-add tr 10.30.$p.0/24 10.0.$p.2 rp$p
+done
+check ovn-nbctl set Logical_Router tr options:lb_force_snat_ip=router_ip \
+    options:mcast_relay=true \
+    options:always_learn_from_arp_request=false \
+    -- lb-add lb 10.0.2.100:80 10.0.1.2:80 \
+    -- lb-add lb '[[fd00:2::100]]:80' '[[fd00:1::2]]:80' \
+    -- lr-lb-add tr lb
+check ovn-nbctl --ecmp-symmetric-reply lr-route-add tr 10.10.0.0/24 10.0.1.2 \
+    -- --ecmp-symmetric-reply lr-route-add tr 10.10.0.0/24 10.0.2.2 \
+    -- lr-policy-add tr 100 'ip4.dst == 10.20.0.0/24' reroute 10.0.2.2
+check ovn-nbctl --wait=sb set Logical_Router_Port rp2 
options:requested-chassis=remote
+check ovn-nbctl lsp-add ls2 routing-daemon \
+    -- lsp-set-addresses routing-daemon 00:00:00:00:02:10 \
+    -- set Logical_Router_Port rp2 
options:routing-protocol-redirect=routing-daemon \
+        options:routing-protocols=BGP
+
+check_port_flows() {
+    port=$1
+    present=$2
+    check ovn-nbctl --wait=sb sync
+    ovn-sbctl lflow-list tr > lflows
+    AT_CAPTURE_FILE([lflows])
+    dnl Every selected family is present for local/chassisless ports, absent
+    dnl for remote ports.  Do not infer correctness from a total flow count.
+    for stage in lr_in_admission lr_in_lookup_neighbor lr_in_nd_ra_options \
+                 lr_in_nd_ra_response lr_in_ip_routing_pre lr_in_ip_input \
+                 lr_in_dhcp_relay_req; do
+        AT_CHECK([grep "$stage" lflows | grep -q "inport == \"$port\""], 
[$present])
+    done
+    for stage in lr_out_delivery lr_in_network_id; do
+        AT_CHECK([grep "$stage" lflows | grep -q "outport == \"$port\""], 
[$present])
+    done
+    dnl Late ingress still runs locally after choosing a remote outport.
+    AT_CHECK([grep lr_in_chk_pkt_len lflows | grep -q "outport == \"$port\""])
+    AT_CHECK([grep lr_in_ecmp_stateful lflows | grep "outport == \"$port\"" | 
grep -q ct_commit])
+    AT_CHECK([grep lr_in_ip_routing lflows | grep 'ip4.dst == 10.0.' | grep -q 
"outport = \"$port\""])
+    AT_CHECK([grep lr_in_ip_routing lflows | grep 'ip6.dst == fd00:' | grep -q 
"outport = \"$port\""])
+    AT_CHECK([grep lr_in_ip_routing lflows | grep fe80: | grep -q "inport == 
\"$port\""], [$present])
+    AT_CHECK([grep lr_in_ip_routing lflows | grep 'udp.dst == 3784' | grep -q 
"inport == \"$port\""], [$present])
+}
+
+check_port_flows rp1 0
+check_port_flows rp2 1
+dnl Address-global handling and DHCP responses must survive remote pruning.
+AT_CHECK([grep lr_in_ip_input lflows | grep 'ip4.dst == 10.0.2.1' | grep -q 
'icmp4.type == 8'])
+AT_CHECK([grep lr_in_ip_input lflows | grep 'ip6.dst ==' | grep fd00:2::1 | 
grep -q 'icmp6.type == 128'])
+AT_CHECK([grep lr_in_ip_input lflows | grep 'ip4.src ==' | grep -q 10.0.2.1])
+AT_CHECK([grep lr_in_ip_input lflows | grep 'ip4.dst == 10.0.2.1' | grep -q 
tcp_reset])
+AT_CHECK([grep lr_in_dhcp_relay_resp lflows | grep -q 'outport = "rp2"'])
+AT_CHECK([grep lr_in_ip_input lflows | grep 'priority=60 ' | grep -q 'ip4.dst 
== {10.0.2.1}'])
+AT_CHECK([grep lr_in_arp_resolve lflows | grep -q 'get_arp(outport, reg0)'])
+AT_CHECK([grep lr_in_ip_routing_ecmp lflows | grep -q 'outport = "rp2"'])
+AT_CHECK([grep lr_in_policy lflows | grep -q 'outport = "rp2"'])
+AT_CHECK([grep lr_in_lookup_neighbor lflows | grep 'arp.op == 2' | grep -q 
flood_remote])
+AT_CHECK([grep lr_in_learn_neighbor lflows | grep 'nd.tll == 0' | grep -q 
'put_nd(inport, nd.target, eth.src)'])
+AT_CHECK([grep lr_in_ip_input lflows | grep fd00:2::1 | grep -q 
handle_dhcpv6_reply])
+AT_CHECK([grep lr_in_ip_input lflows | grep 10.0.2.1 | grep -q handle_bfd_msg])
+AT_CHECK([grep lr_in_larger_pkts lflows | grep 'outport == "rp2"' | grep -q 
'inport == "rp1"'])
+AT_CHECK([grep lr_in_larger_pkts lflows | grep -q 'inport == "rp2"'], [1])
+AT_CHECK([ovn-sbctl lflow-list ordinary | grep lr_in_admission | grep -q 
'inport == "ordinary-port"'])
+AT_CHECK([ovn-sbctl lflow-list ls2 | grep ls_in_l2_lkup | grep 'tcp.dst == 
179' | grep -q 'outport = "routing-daemon"'])
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+
+dnl Remote LRPs can also supply neighbor resolution flows on a peer router.
+check ovn-nbctl lr-add peer \
+    -- lrp-add tr tr-peer 00:00:00:00:04:01 10.40.0.1/24 fd00:40::1/64 \
+    -- set Logical_Router_Port tr-peer peer=peer-tr 
options:requested-chassis=remote \
+    -- lrp-add peer peer-tr 00:00:00:00:04:02 10.40.0.2/24 fd00:40::2/64 
peer=tr-peer
+check ovn-nbctl --wait=sb sync
+AT_CHECK([ovn-sbctl lflow-list peer | grep lr_in_arp_resolve | grep 'outport 
== "peer-tr"' | grep -q 'eth.dst = 00:00:00:00:04:01'])
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+check ovn-nbctl --wait=sb lrp-del tr-peer -- lr-del peer
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+
+dnl Chassis changes must restore and prune the same flows on recompute.
+check ovn-sbctl remove Chassis remote other_config is-remote
+check_port_flows rp2 0
+AT_CHECK([grep lr_in_admission lflows | grep -q 'priority=40'], [1])
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+check ovn-sbctl set Chassis remote other_config:is-remote=true
+check_port_flows rp2 1
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+
+dnl Requested-chassis changes use the same classification as chassis updates.
+check ovn-nbctl --wait=sb set Logical_Router_Port rp2 
options:requested-chassis=local
+dnl The previous remote chassis may still be recorded on the patch binding.
+dnl It must not suppress ordinary port flows after the NB request changes.
+check_port_flows rp2 0
+AT_CHECK([grep lr_in_admission lflows | grep -q 'priority=40'], [1])
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+check ovn-nbctl --wait=sb set Logical_Router_Port rp2 
options:requested-chassis=remote
+check_port_flows rp2 1
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+check ovn-nbctl lr-route-del tr 10.30.2.0/24
+check ovn-nbctl --wait=sb lrp-del rp2
+AT_CHECK([ovn-sbctl lflow-list tr | grep lr_in_admission | grep -q 
'priority=40'], [1])
+check_port_flows rp1 0
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+
+OVN_CLEANUP_NORTHD
+AT_CLEANUP
+])
+
+OVN_FOR_EACH_NORTHD_NO_HV([
+AT_SETUP([Transit router - force SNAT flows])
+ovn_start
+check ovn-sbctl chassis-add remote geneve 192.0.2.2 \
+    -- set Chassis remote other_config:is-remote=true
+check ovn-sbctl chassis-add local geneve 192.0.2.1
+check ovn-nbctl lr-add tr \
+    -- set Logical_Router tr options:lb_force_snat_ip=router_ip \
+    -- lrp-add tr remote 00:00:00:00:02:01 10.0.2.1/24 fd00:2::1/64 \
+    -- set Logical_Router_Port remote options:requested-chassis=remote \
+    -- ls-add ts -- lsp-add-router-port ts ts-tr remote
+dnl Router-IP force SNAT is supported on chassis-bound gateway routers, not
+dnl distributed transit routers.  Check local preservation in that context.
+check ovn-nbctl lr-add gw \
+    -- set Logical_Router gw options:chassis=local 
options:lb_force_snat_ip=router_ip \
+    -- lrp-add gw gw-ls 00:00:00:00:05:01 10.0.5.1/24 fd00:5::1/64 \
+    -- ls-add gs -- lsp-add-router-port gs gs-gw gw-ls \
+    -- lb-add lb 10.0.2.100:80 10.0.5.2:80 \
+    -- lb-add lb '[[fd00:2::100]]:80' '[[fd00:5::2]]:80' \
+    -- lr-lb-add tr lb -- lr-lb-add gw lb
+
+check_snat_flows() {
+    check ovn-nbctl --wait=sb sync
+    ovn-sbctl lflow-list "$1" > snatflows
+    AT_CAPTURE_FILE([snatflows])
+    for family in 4 6; do
+        AT_CHECK([grep lr_in_unsnat snatflows | grep "inport == \"$2\"" | grep 
-q "ip$family.dst"], [$3])
+        for priority in 105 110; do
+            AT_CHECK([grep lr_out_snat snatflows | grep "priority=$priority " 
| grep "outport == \"$2\"" | grep -q "&& ip$family"], [$3])
+        done
+    done
+}
+check_snat_flows tr remote 1
+check_snat_flows gw gw-ls 0
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+dnl LB-only changes regenerate stateful flows independently of port flows.
+check ovn-nbctl lb-add lb 10.0.2.101:80 10.0.5.3:80 \
+    -- lb-add lb '[[fd00:2::101]]:80' '[[fd00:5::3]]:80'
+check_snat_flows tr remote 1
+check_snat_flows gw gw-ls 0
+CHECK_NO_CHANGE_AFTER_RECOMPUTE
+
+OVN_CLEANUP_NORTHD
+AT_CLEANUP
+])
+
 OVN_FOR_EACH_NORTHD_NO_HV([
 AT_SETUP([ACL persistent ID - Logical Flows])
 ovn_start
-- 
2.56.0

_______________________________________________
dev mailing list
[email protected]
https://mail.openvswitch.org/mailman/listinfo/ovs-dev

Reply via email to