When tc_netdev_flow_put() rejects a flow because the upstream
recirc chain is not yet registered (used_chains count is zero),
the flow is permanently stranded in the kernel.  A new
offload_deferred flag on struct dpif_op propagates the rejection
up to the revalidator, which retries the offload when the offload
state changes.

An offload-specific change_seq counter signals the revalidator
that a condition has changed which may allow successful offload.
The revalidator will try again to offload the flow, which is
limited to OFFLOAD_DEFERRED_MAX_RETRIES (16) attempts per ukey
to avoid infinite loops.

Fixes: 273a4fce951a ("netdev-offload-tc: Only install recirc flows if the 
parent is present.")
Reported-by: Numan Siddique <[email protected]>
Signed-off-by: Eelco Chaudron <[email protected]>
---

v2 changes:
  - Use a flag to pass the deferred state, rather than EAGAIN.
  - Fixed some style issues.
  - Replaced the time based retry mechanism with a triggered
    approach, with max 16 retries.
---
 lib/dpif-offload-provider.h      |  5 +++
 lib/dpif-offload-tc-netdev.c     | 32 +++++++++------
 lib/dpif-offload-tc-private.h    |  2 +
 lib/dpif-offload-tc.c            | 12 +++++-
 lib/dpif-offload.c               | 28 +++++++++++++
 lib/dpif-offload.h               |  1 +
 lib/dpif.c                       |  7 ++++
 lib/dpif.h                       |  3 ++
 ofproto/ofproto-dpif-upcall.c    | 48 +++++++++++++++++++++-
 tests/system-offloads-traffic.at | 68 ++++++++++++++++++++++++++++++++
 10 files changed, 190 insertions(+), 16 deletions(-)

diff --git a/lib/dpif-offload-provider.h b/lib/dpif-offload-provider.h
index 0b098f6c1..c0388528e 100644
--- a/lib/dpif-offload-provider.h
+++ b/lib/dpif-offload-provider.h
@@ -47,6 +47,10 @@ struct dpif_offload_provider_collection {
                              * deletions are allowed; hence no locking of the
                              * list is required. */
 
+    atomic_uint64_t change_seq; /* Incremented by offload providers to signal
+                                 * revalidators that deferred offloads should
+                                 * be retried. */
+
     struct ovs_mutex mutex; /* Mutex to protect all below. */
     struct ovs_refcount ref_cnt;
 };
@@ -381,6 +385,7 @@ struct dpif_offload_port 
*dpif_offload_port_mgr_find_by_odp_port(
 
 /* Global functions, called by the dpif layer or offload providers. */
 void dpif_offload_module_init(void);
+void dpif_offload_inc_change_seq(const struct dpif *);
 void dpif_offload_set_config(struct dpif *, const struct smap *other_cfg);
 void dpif_offload_port_add(struct dpif *, struct netdev *, odp_port_t);
 void dpif_offload_port_del(struct dpif *, odp_port_t);
diff --git a/lib/dpif-offload-tc-netdev.c b/lib/dpif-offload-tc-netdev.c
index a2f4ab8b5..8d08bacde 100644
--- a/lib/dpif-offload-tc-netdev.c
+++ b/lib/dpif-offload-tc-netdev.c
@@ -41,6 +41,7 @@
 #include "unaligned.h"
 #include "util.h"
 #include "dpif-offload.h"
+#include "dpif-offload-provider.h"
 #include "dpif-offload-tc-private.h"
 #include "dpif-provider.h"
 
@@ -2355,17 +2356,6 @@ tc_netdev_flow_put(struct dpif *dpif, struct netdev 
*netdev,
     chain = key->recirc_id;
     mask->recirc_id = 0;
 
-    if (chain) {
-        /* If we match on a recirculation ID, we must ensure the previous
-         * flow is also in the TC datapath; otherwise, the entry is useless,
-         * as the related packets will be handled by upcalls. */
-        if (!ccmap_find(&used_chains, chain)) {
-            VLOG_DBG_RL(&rl, "match for chain %u failed due to non-existing "
-                        "goto chain action", chain);
-            return EOPNOTSUPP;
-        }
-    }
-
     if (flow_tnl_dst_is_set(&key->tunnel) ||
         flow_tnl_src_is_set(&key->tunnel)) {
         VLOG_DBG_RL(&rl,
@@ -2687,6 +2677,18 @@ tc_netdev_flow_put(struct dpif *dpif, struct netdev 
*netdev,
         return EOPNOTSUPP;
     }
 
+    if (chain && !ccmap_find(&used_chains, chain)) {
+        /* If we match on a recirculation ID, we must ensure the previous
+         * flow is also in the TC datapath; otherwise, the entry is useless,
+         * as the related packets will be handled by upcalls.  The chain
+         * may not be registered yet because the upstream flow install is
+         * still in progress; flag it for deferred retry. */
+        VLOG_DBG_RL(&rl, "match for chain %u failed due to non-existing "
+                    "goto chain action", chain);
+        info->offload_deferred = true;
+        return EOPNOTSUPP;
+    }
+
     memset(&adjust_stats, 0, sizeof adjust_stats);
     if (get_ufid_tc_mapping(ufid, &id) == 0) {
         VLOG_DBG_RL(&rl, "updating old handle: %d prio: %d",
@@ -2725,10 +2727,16 @@ tc_netdev_flow_put(struct dpif *dpif, struct netdev 
*netdev,
                  * Since it does not involve recirculation handling,
                  * it should be ignored. */
                 if (action->type == TC_ACT_GOTO && action->chain) {
+                    uint32_t count;
+
                     chain_goto = action->chain;
                     ovs_mutex_lock(&used_chains_mutex);
-                    ccmap_inc(&used_chains, chain_goto);
+                    count = ccmap_inc(&used_chains, chain_goto);
                     ovs_mutex_unlock(&used_chains_mutex);
+                    if (count == 1) {
+                        /* New chain registered; notify revalidators. */
+                        dpif_offload_inc_change_seq(dpif);
+                    }
                     break;
                 }
             }
diff --git a/lib/dpif-offload-tc-private.h b/lib/dpif-offload-tc-private.h
index b876ff1c9..6f2e55bc9 100644
--- a/lib/dpif-offload-tc-private.h
+++ b/lib/dpif-offload-tc-private.h
@@ -37,6 +37,8 @@ struct tc_offload_info {
     bool tc_modify_flow; /* Indicates tc modified the flow. */
     bool tc_modify_flow_deleted; /* Indicate the tc modify flow put success
                                   * to delete the original flow. */
+    bool offload_deferred; /* The recirc chain is not yet registered; the
+                            * revalidator should retry the offload later. */
 };
 
 /* Netdev-specific offload functions.  These should only be used by the
diff --git a/lib/dpif-offload-tc.c b/lib/dpif-offload-tc.c
index 3b84d9f20..6f9303c57 100644
--- a/lib/dpif-offload-tc.c
+++ b/lib/dpif-offload-tc.c
@@ -487,7 +487,8 @@ tc_flow_dump_thread_destroy(struct 
dpif_offload_flow_dump_thread *thread_)
 
 static int
 tc_parse_flow_put(struct tc_offload *offload_tc, struct dpif *dpif,
-                  struct dpif_flow_put *put)
+                  struct dpif_flow_put *put,
+                  bool *offload_deferred)
 {
     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
     struct dpif_offload_port *port;
@@ -498,6 +499,8 @@ tc_parse_flow_put(struct tc_offload *offload_tc, struct 
dpif *dpif,
     size_t left;
     int err;
 
+    *offload_deferred = false;
+    info.offload_deferred = false;
     info.tc_modify_flow_deleted = false;
     info.tc_modify_flow = false;
 
@@ -608,6 +611,7 @@ out:
         }
     }
 
+    *offload_deferred = info.offload_deferred;
     return err;
 }
 
@@ -673,12 +677,16 @@ tc_operate(struct dpif *dpif, const struct dpif_offload 
*offload_,
         switch (op->type) {
         case DPIF_OP_FLOW_PUT: {
             struct dpif_flow_put *put = &op->flow_put;
+            bool deferred = false;
 
             if (!put->ufid) {
                 break;
             }
 
-            error = tc_parse_flow_put(offload, dpif, put);
+            error = tc_parse_flow_put(offload, dpif, put, &deferred);
+            if (deferred) {
+                op->offload_deferred = true;
+            }
             break;
         }
         case DPIF_OP_FLOW_DEL: {
diff --git a/lib/dpif-offload.c b/lib/dpif-offload.c
index 3d9a8a1fc..fce32807d 100644
--- a/lib/dpif-offload.c
+++ b/lib/dpif-offload.c
@@ -274,6 +274,7 @@ dpif_attach_new_offload_provider_collection(struct dpif 
*dpif)
     ovs_mutex_init_recursive(&collection->mutex);
     ovs_refcount_init(&collection->ref_cnt);
     ovs_list_init(&collection->list);
+    atomic_init(&collection->change_seq, 1);
     shash_add(&dpif_offload_providers, collection->dpif_name, collection);
 
     /* Open all the providers supporting this dpif type. */
@@ -400,6 +401,33 @@ dpif_detach_offload_providers(struct dpif *dpif)
     }
 }
 
+void
+dpif_offload_inc_change_seq(const struct dpif *dpif)
+{
+    struct dpif_offload_provider_collection *collection;
+    uint64_t old_change_seq;
+
+    collection = dpif_get_offload_provider_collection(dpif);
+    ovs_assert(collection);
+
+    atomic_add_explicit(&collection->change_seq, 1, &old_change_seq,
+                        memory_order_release);
+}
+
+uint64_t
+dpif_offload_get_change_seq(const struct dpif *dpif)
+{
+    struct dpif_offload_provider_collection *collection;
+    uint64_t change_seq = 0;
+
+    collection = dpif_get_offload_provider_collection(dpif);
+    if (collection) {
+        atomic_read_explicit(&collection->change_seq, &change_seq,
+                             memory_order_acquire);
+    }
+    return change_seq;
+}
+
 void
 dpif_offload_set_config(struct dpif *dpif, const struct smap *other_cfg)
 {
diff --git a/lib/dpif-offload.h b/lib/dpif-offload.h
index b6d3c1f37..c8ba21137 100644
--- a/lib/dpif-offload.h
+++ b/lib/dpif-offload.h
@@ -45,6 +45,7 @@ enum dpif_offload_impl_type {
 void dpif_offload_set_global_cfg(const struct ovsrec_open_vswitch *);
 bool dpif_offload_enabled(void);
 bool dpif_offload_rebalance_policy_enabled(void);
+uint64_t dpif_offload_get_change_seq(const struct dpif *);
 
 
 /* Per dpif specific functions. */
diff --git a/lib/dpif.c b/lib/dpif.c
index a62da6483..46f16e141 100644
--- a/lib/dpif.c
+++ b/lib/dpif.c
@@ -1355,10 +1355,17 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, 
size_t n_ops,
         for (i = 0; i < n_ops; i++) {
             struct dpif_op *op = ops[i];
             op->error = EINVAL;
+            op->offload_deferred = false;
         }
         return;
     }
 
+    /* Initialize offload_deferred for all ops; the offload provider sets
+     * it to true if the flow cannot be offloaded yet. */
+    for (size_t i = 0; i < n_ops; i++) {
+        ops[i]->offload_deferred = false;
+    }
+
     while (n_ops > 0) {
         size_t chunk;
 
diff --git a/lib/dpif.h b/lib/dpif.h
index 3e6a34a25..34e2dfc86 100644
--- a/lib/dpif.h
+++ b/lib/dpif.h
@@ -782,6 +782,9 @@ int dpif_execute(struct dpif *, struct dpif_execute *);
 struct dpif_op {
     enum dpif_op_type type;
     int error;
+    bool offload_deferred; /* True if the offload provider requires a
+                            * prerequisite flow to be programmed first.
+                            * Retried when offload change_seq advances. */
     union {
         struct dpif_flow_put flow_put;
         struct dpif_flow_del flow_del;
diff --git a/ofproto/ofproto-dpif-upcall.c b/ofproto/ofproto-dpif-upcall.c
index c877a0c24..b082a9635 100644
--- a/ofproto/ofproto-dpif-upcall.c
+++ b/ofproto/ofproto-dpif-upcall.c
@@ -51,6 +51,7 @@
 #define UPCALL_MAX_BATCH 64
 #define REVALIDATE_MAX_BATCH 50
 #define UINT64_THREE_QUARTERS (UINT64_MAX / 4 * 3)
+#define OFFLOAD_DEFERRED_MAX_RETRIES 16
 
 VLOG_DEFINE_THIS_MODULE(ofproto_dpif_upcall);
 
@@ -348,6 +349,9 @@ struct udpif_key {
 #define OFFL_REBAL_INTVL_MSEC  3000    /* dynamic offload rebalance freq */
     struct netdev *in_netdev;          /* in_odp_port's netdev */
     bool offloaded;                    /* True if flow is offloaded */
+    bool offload_deferred;             /* Deferred, retry next cycle. */
+    uint64_t offload_deferred_seq;     /* change_seq when deferred. */
+    unsigned int offload_deferred_retries; /* Retry attempts remaining. */
     uint64_t flow_pps_rate;            /* Packets-Per-Second rate */
     long long int flow_time;           /* last pps update time */
     uint64_t flow_packets;             /* #pkts seen in interval */
@@ -1685,6 +1689,7 @@ static void
 handle_upcalls(struct udpif *udpif, struct upcall *upcalls,
                size_t n_upcalls)
 {
+    uint64_t offload_seq = dpif_offload_get_change_seq(udpif->dpif);
     struct dpif_op *opsp[UPCALL_MAX_BATCH * 2];
     struct ukey_op ops[UPCALL_MAX_BATCH * 2];
     size_t n_ops, n_opsp, i;
@@ -1745,8 +1750,16 @@ handle_upcalls(struct udpif *udpif, struct upcall 
*upcalls,
             ovs_mutex_lock(&ukey->mutex);
             if (ops[i].dop.error) {
                 transition_ukey(ukey, UKEY_EVICTED);
-            } else if (ukey->state < UKEY_OPERATIONAL) {
-                transition_ukey(ukey, UKEY_OPERATIONAL);
+            } else {
+                if (ukey->state < UKEY_OPERATIONAL) {
+                    transition_ukey(ukey, UKEY_OPERATIONAL);
+                }
+                if (ops[i].dop.offload_deferred && !ukey->offload_deferred) {
+                    ukey->offload_deferred_seq = offload_seq;
+                    ukey->offload_deferred_retries =
+                        OFFLOAD_DEFERRED_MAX_RETRIES;
+                    ukey->offload_deferred = true;
+                }
             }
             ovs_mutex_unlock(&ukey->mutex);
         }
@@ -1837,6 +1850,9 @@ ukey_create__(const struct nlattr *key, size_t key_len,
     ukey->xcache = NULL;
 
     ukey->offloaded = false;
+    ukey->offload_deferred = false;
+    ukey->offload_deferred_seq = 0;
+    ukey->offload_deferred_retries = 0;
     ukey->in_netdev = NULL;
     ukey->flow_packets = ukey->flow_backlog_packets = 0;
 
@@ -2541,6 +2557,7 @@ put_op_init(struct ukey_op *op, struct udpif_key *ukey,
 static void
 push_dp_ops(struct udpif *udpif, struct ukey_op *ops, size_t n_ops)
 {
+    uint64_t offload_seq = dpif_offload_get_change_seq(udpif->dpif);
     struct dpif_op *opsp[REVALIDATE_MAX_BATCH];
     size_t i;
 
@@ -2553,6 +2570,22 @@ push_dp_ops(struct udpif *udpif, struct ukey_op *ops, 
size_t n_ops)
     for (i = 0; i < n_ops; i++) {
         struct ukey_op *op = &ops[i];
 
+        if (op->ukey && op->dop.type == DPIF_OP_FLOW_PUT) {
+            ovs_mutex_lock(&op->ukey->mutex);
+            if (op->dop.offload_deferred) {
+                if (!op->ukey->offload_deferred) {
+                    op->ukey->offload_deferred_retries =
+                        OFFLOAD_DEFERRED_MAX_RETRIES;
+                }
+                op->ukey->offload_deferred_seq = offload_seq;
+                op->ukey->offload_deferred = true;
+            } else if (op->ukey->offload_deferred) {
+                op->ukey->offload_deferred = false;
+                op->ukey->offload_deferred_retries = 0;
+            }
+            ovs_mutex_unlock(&op->ukey->mutex);
+        }
+
         if (op->dop.error) {
             if (op->ukey) {
                 ovs_mutex_lock(&op->ukey->mutex);
@@ -2827,11 +2860,13 @@ revalidate(struct revalidator *revalidator)
     struct udpif *udpif = revalidator->udpif;
     struct dpif_flow_dump_thread *dump_thread;
     uint64_t dump_seq, reval_seq;
+    uint64_t offload_seq;
     bool kill_warn_print = true;
     unsigned int flow_limit;
 
     dump_seq = seq_read(udpif->dump_seq);
     reval_seq = seq_read(udpif->reval_seq);
+    offload_seq = dpif_offload_get_change_seq(udpif->dpif);
     atomic_read_relaxed(&udpif->flow_limit, &flow_limit);
     dump_thread = dpif_flow_dump_thread_create(udpif->dump);
     for (;;) {
@@ -2985,6 +3020,15 @@ revalidate(struct revalidator *revalidator)
                 /* Takes ownership of 'recircs'. */
                 reval_op_init(&ops[n_ops++], result, udpif, ukey, &recircs,
                               &odp_actions);
+            } else if (ukey->offload_deferred) {
+                if (offload_seq > ukey->offload_deferred_seq) {
+                    if (ukey->offload_deferred_retries > 0) {
+                        ukey->offload_deferred_retries--;
+                        put_op_init(&ops[n_ops++], ukey, DPIF_FP_MODIFY);
+                    } else {
+                        ukey->offload_deferred = false;
+                    }
+                }
             }
             ovs_mutex_unlock(&ukey->mutex);
         }
diff --git a/tests/system-offloads-traffic.at b/tests/system-offloads-traffic.at
index cfcc5bd6c..aad63a8a0 100644
--- a/tests/system-offloads-traffic.at
+++ b/tests/system-offloads-traffic.at
@@ -1197,6 +1197,74 @@ OVS_WAIT_WHILE(
 OVS_TRAFFIC_VSWITCHD_STOP
 AT_CLEANUP
 
+AT_SETUP([offloads - split recirc rules kernel vs offload])
+OVS_TRAFFIC_VSWITCHD_START([], [], [-- set Open_vSwitch . 
other_config:hw-offload=true])
+
+ADD_NAMESPACES(at_ns0, at_ns1)
+
+ADD_VETH(p1, at_ns0, br0, "10.0.0.1/24")
+ADD_VETH(p2, at_ns1, br0, "10.0.0.2/24")
+
+dnl Two source IPs on the same veth guarantee the same in_port and therefore
+dnl the same recirc ID R1 for the second datapath flow.
+NS_CHECK_EXEC([at_ns0], [ip addr add 10.0.0.3/24 dev p1])
+
+AT_CHECK([ovs-vsctl -- set interface ovs-p1 ofport_request=1 \
+                    -- set interface ovs-p2 ofport_request=2])
+
+AT_CHECK([ovs-appctl vlog/set dpif_offload_tc_netdev:dbg])
+
+dnl controller() is not TC-offloadable, so both datapath flows land in dp:ovs.
+AT_DATA([flows.txt], [dnl
+table=0,arp,actions=NORMAL
+table=0,priority=100,in_port=ovs-p1,ip,nw_dst=10.0.0.2,actions=controller(),ct(commit,table=1)
+table=0,priority=100,in_port=ovs-p2,ip,actions=ovs-p1
+table=1,ip,actions=ovs-p2
+])
+AT_CHECK([ovs-ofctl add-flows br0 flows.txt])
+
+NS_CHECK_EXEC([at_ns0], [ping -q -c 3 -i 0.3 -W 2 10.0.0.2 | FORMAT_PING], 
[0], [dnl
+3 packets transmitted, 3 received, 0% packet loss, time 0ms
+])
+AT_CHECK([ovs-appctl revalidator/wait])
+
+AT_CHECK([grep -q "match for chain .* failed due to non-existing goto chain 
action" \
+          ovs-vswitchd.log])
+AT_CHECK([ovs-appctl dpctl/dump-flows --names type=ovs \
+          filter='in_port(ovs-p1),ipv4' | grep -c "in_port(ovs-p1)"], [0], [2
+])
+AT_CHECK([ovs-appctl dpctl/dump-flows --names type=tc \
+          filter='in_port(ovs-p1),ipv4'], [0], [dnl
+])
+
+dnl Replace the rule with plain ct (TC-offloadable).  Traffic from 10.0.0.3
+dnl offloads its first datapath flow to dp:tc, which registers the recirc ID.
+dnl After the fix, the second datapath flow should also be offloaded to dp:tc.
+AT_CHECK([ovs-ofctl del-flows br0 "table=0,in_port=ovs-p1,ip,nw_dst=10.0.0.2"])
+AT_DATA([flows2.txt], [dnl
+table=0,priority=100,in_port=ovs-p1,ip,nw_dst=10.0.0.2,actions=ct(commit,table=1)
+])
+AT_CHECK([ovs-ofctl add-flows br0 flows2.txt])
+
+NS_CHECK_EXEC([at_ns0], [ping -q -c 3 -i 0.3 -W 2 -I 10.0.0.3 10.0.0.2 | 
FORMAT_PING], [0], [dnl
+3 packets transmitted, 3 received, 0% packet loss, time 0ms
+])
+
+AT_CHECK([ovs-appctl revalidator/wait])
+OVS_WAIT_UNTIL([ovs-appctl dpctl/dump-flows --names type=tc \
+    filter='in_port(ovs-p1),ipv4' | grep -q "actions:ovs-p2"])
+
+AT_CHECK([ovs-appctl dpctl/dump-flows --names type=tc \
+          filter='in_port(ovs-p1),ipv4' | grep -c "in_port(ovs-p1)"], [0], [2
+])
+AT_CHECK([ovs-appctl dpctl/dump-flows --names type=ovs \
+          filter='in_port(ovs-p1),ipv4' | grep "actions:ovs-p2"], [1])
+AT_CHECK([ovs-appctl dpctl/dump-flows --names type=tc \
+          filter='in_port(ovs-p1),ipv4' | grep "actions:ovs-p2"], [0], 
[ignore])
+
+OVS_TRAFFIC_VSWITCHD_STOP
+AT_CLEANUP
+
 AT_SETUP([offloads - ovs-appctl dpif/offload/show - offloads enabled])
 AT_KEYWORDS([dpif-offload])
 OVS_TRAFFIC_VSWITCHD_START([], [],
-- 
2.56.0

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

Reply via email to