odp-execute: Add auto validation function for actions.

This commit introduced the auto-validation function which
allows users to compare the batch of packets obtained from
different action implementations against the linear
action implementation.

The autovalidator function can be triggered at runtime using the
following command:

$ ovs-appctl odp-execute/action-impl-set autovalidator

Signed-off-by: Emma Finn <emma.finn@intel.com>
Acked-by: Harry van Haaren <harry.van.haaren@intel.com>
Acked-by: Sunil Pai G <sunil.pai.g@intel.com>
Acked-by: Eelco Chaudron <echaudro@redhat.com>
Signed-off-by: Ian Stokes <ian.stokes@intel.com>

NEWS

@@ -55,6 +55,8 @@ Post-v2.17.0
      * 'dpif-netdev/subtable-lookup-prio-get' appctl command renamed to
        'dpif-netdev/subtable-lookup-info-get' to better reflect its purpose.
        The old variant is kept for backward compatibility.
+     * Add actions auto-validator function to compare different actions
+       implementations against default implementation.
    - Linux datapath:
      * Add offloading meter tc police.
      * Add support for offloading the check_pkt_len action.

lib/dp-packet.c

@@ -506,3 +506,27 @@ dp_packet_resize_l2(struct dp_packet *b, int increment)
     dp_packet_adjust_layer_offset(&b->l2_5_ofs, increment);
     return dp_packet_data(b);
 }
+
+bool
+dp_packet_compare_offsets(struct dp_packet *b1, struct dp_packet *b2,
+                          struct ds *err_str)
+{
+    if ((b1->l2_pad_size != b2->l2_pad_size) ||
+        (b1->l2_5_ofs != b2->l2_5_ofs) ||
+        (b1->l3_ofs != b2->l3_ofs) ||
+        (b1->l4_ofs != b2->l4_ofs)) {
+        if (err_str) {
+            ds_put_format(err_str, "Packet offset comparison failed\n");
+            ds_put_format(err_str, "Buffer 1 offsets: l2_pad_size %u,"
+                          " l2_5_ofs : %u l3_ofs %u, l4_ofs %u\n",
+                          b1->l2_pad_size, b1->l2_5_ofs,
+                          b1->l3_ofs, b1->l4_ofs);
+            ds_put_format(err_str, "Buffer 2 offsets: l2_pad_size %u,"
+                          " l2_5_ofs : %u l3_ofs %u, l4_ofs %u\n",
+                          b2->l2_pad_size, b2->l2_5_ofs,
+                          b2->l3_ofs, b2->l4_ofs);
+        }
+        return false;
+    }
+    return true;
+}

lib/dp-packet.h

@@ -236,6 +236,10 @@ void *dp_packet_steal_data(struct dp_packet *);
 static inline bool dp_packet_equal(const struct dp_packet *,
                                    const struct dp_packet *);
 
+bool dp_packet_compare_offsets(struct dp_packet *good,
+                               struct dp_packet *test,
+                               struct ds *err_str);
+
 
 /* Frees memory that 'b' points to, as well as 'b' itself. */
 static inline void

lib/odp-execute-private.c

@@ -30,6 +30,12 @@ VLOG_DEFINE_THIS_MODULE(odp_execute_impl);
 static int active_action_impl_index;
 
 static struct odp_execute_action_impl action_impls[] = {
+    [ACTION_IMPL_AUTOVALIDATOR] = {
+        .available = false,
+        .name = "autovalidator",
+        .init_func = action_autoval_init,
+    },
+
     [ACTION_IMPL_SCALAR] = {
         .available = false,
         .name = "scalar",
@@ -103,3 +109,95 @@ odp_execute_action_init(void)
         }
     }
 }
+
+/* Init sequence required to be scalar first to pick up the default scalar
+ * implementations, allowing over-riding of the optimized functions later. */
+BUILD_ASSERT_DECL(ACTION_IMPL_SCALAR == 0);
+BUILD_ASSERT_DECL(ACTION_IMPL_AUTOVALIDATOR == 1);
+
+/* Loop over packets, and validate each one for the given action. */
+static void
+action_autoval_generic(struct dp_packet_batch *batch, const struct nlattr *a)
+{
+    struct odp_execute_action_impl *scalar = &action_impls[ACTION_IMPL_SCALAR];
+    enum ovs_action_attr attr_type = nl_attr_type(a);
+    struct dp_packet_batch original_batch;
+    bool failed = false;
+
+    dp_packet_batch_clone(&original_batch, batch);
+
+    scalar->funcs[attr_type](batch, a);
+
+    for (int impl = ACTION_IMPL_BEGIN; impl < ACTION_IMPL_MAX; impl++) {
+        /* Clone original batch and execute implementation under test. */
+        struct dp_packet_batch test_batch;
+
+        dp_packet_batch_clone(&test_batch, &original_batch);
+        action_impls[impl].funcs[attr_type](&test_batch, a);
+
+        /* Loop over implementations, checking each one. */
+        for (int pidx = 0; pidx < original_batch.count; pidx++) {
+            struct dp_packet *good_pkt = batch->packets[pidx];
+            struct dp_packet *test_pkt = test_batch.packets[pidx];
+
+            struct ds log_msg = DS_EMPTY_INITIALIZER;
+
+            /* Compare packet length and payload contents. */
+            bool eq = dp_packet_equal(good_pkt, test_pkt);
+
+            if (!eq) {
+                ds_put_format(&log_msg, "Packet: %d\nAction : ", pidx);
+                format_odp_actions(&log_msg, a, a->nla_len, NULL);
+                ds_put_format(&log_msg, "\nGood hex:\n");
+                ds_put_hex_dump(&log_msg, dp_packet_data(good_pkt),
+                                dp_packet_size(good_pkt), 0, false);
+                ds_put_format(&log_msg, "Test hex:\n");
+                ds_put_hex_dump(&log_msg, dp_packet_data(test_pkt),
+                                dp_packet_size(test_pkt), 0, false);
+
+                failed = true;
+            }
+
+            /* Compare offsets and RSS */
+            if (!dp_packet_compare_offsets(good_pkt, test_pkt, &log_msg)) {
+                failed = true;
+            }
+
+            if (dp_packet_rss_valid(good_pkt)) {
+                uint32_t good_hash = dp_packet_get_rss_hash(good_pkt);
+                uint32_t test_hash = dp_packet_get_rss_hash(test_pkt);
+
+                if (good_hash != test_hash) {
+                    ds_put_format(&log_msg,
+                                  "Autovalidation rss hash failed\n");
+                    ds_put_format(&log_msg, "Good RSS hash : %u\n", good_hash);
+                    ds_put_format(&log_msg, "Test RSS hash : %u\n", test_hash);
+
+                    failed = true;
+                }
+            }
+
+            if (failed) {
+                VLOG_ERR("Autovalidation of %s failed. Details:\n%s",
+                         action_impls[impl].name, ds_cstr(&log_msg));
+                ds_destroy(&log_msg);
+                failed = false;
+            }
+        }
+        dp_packet_delete_batch(&test_batch, true);
+    }
+    dp_packet_delete_batch(&original_batch, true);
+}
+
+int
+action_autoval_init(struct odp_execute_action_impl *self)
+{
+    /* Set function pointers for actions that can be applied directly, these
+     * are identified by OVS_ACTION_ATTR_*. */
+    for (int i = 0; i < __OVS_ACTION_ATTR_MAX; i++) {
+        if (action_impls[ACTION_IMPL_SCALAR].funcs[i]) {
+            self->funcs[i] = action_autoval_generic;
+        }
+    }
+    return 0;
+}

lib/odp-execute-private.h

@@ -51,6 +51,7 @@ struct odp_execute_action_impl {
 /* Order of Actions implementations. */
 enum odp_execute_action_impl_idx {
     ACTION_IMPL_SCALAR,
+    ACTION_IMPL_AUTOVALIDATOR,
     /* See ACTION_IMPL_BEGIN below, for "first to-be-validated" impl.
      * Do not change the autovalidator position in this list without updating
      * the define below. */
@@ -60,6 +61,9 @@ enum odp_execute_action_impl_idx {
 
 /* Index to start verifying implementations from. */
 BUILD_ASSERT_DECL(ACTION_IMPL_SCALAR == 0);
+BUILD_ASSERT_DECL(ACTION_IMPL_AUTOVALIDATOR == 1);
+
+#define ACTION_IMPL_BEGIN (ACTION_IMPL_AUTOVALIDATOR + 1)
 
 /* Odp execute init handles setting up the state of the actions functions at
  * initialization time. It cannot return errors, as it must always succeed in
@@ -72,4 +76,6 @@ int odp_action_scalar_init(struct odp_execute_action_impl *self);
 
 struct odp_execute_action_impl * odp_execute_action_set(const char *name);
 
+int action_autoval_init(struct odp_execute_action_impl *self);
+
 #endif /* ODP_EXTRACT_PRIVATE */