(TSG-21101)dp_trace uses traffic_link_id as a restrictionv4.8.6-20240508

9 files changed, 92 insertions, 17 deletions

diff --git a/app/src/dp_trace.c b/app/src/dp_trace.c
index 9d4a47f..aa9713e 100644
--- a/app/src/dp_trace.c
+++ b/app/src/dp_trace.c
@@ -67,7 +67,7 @@ int marsio_dp_trace_measurements_can_emit(__rte_unused struct mr_instance * inst
     struct mrb_metadata * mrb_meta = rte_mbuf_to_priv((struct rte_mbuf *)mbuf);
     if (unlikely(mrb_meta->measurement_type == DP_TRACE_MEASUREMENT_TYPE_UNKNOW))
     {
-        marsio_dp_trace_filter_exec(instance, (struct rte_mbuf *)mbuf);
+        dp_trace_filter_exec(instance->trace, (struct rte_mbuf *)mbuf, 0, marsio_thread_id_get());
     }
     return dp_trace_record_can_emit((struct rte_mbuf *)mbuf, measurement_type);
 }
@@ -130,6 +130,17 @@ void marsio_rte_mempool_generic_put(struct rte_mempool * mp, void * const * obj_
     struct mr_instance * mr_instance = marsio_current();
     for (unsigned int i = 0; i < n; i++)
     {
+        if (marsio_dp_trace_measurements_can_emit(mr_instance, obj_table[i], DP_TRACE_MEASUREMENT_TYPE_TELEMETRY))
+        {
+            marsio_dp_trace_measurement_emit_str(mr_instance, obj_table[i], DP_TRACE_MEASUREMENT_TYPE_TELEMETRY, NULL,
+                                                 "packet dropped by application");
+        }
+
+        if (marsio_dp_trace_measurements_can_emit(mr_instance, obj_table[i], DP_TRACE_MEASUREMENT_TYPE_TRACE))
+        {
+            marsio_dp_trace_measurement_emit_str(mr_instance, obj_table[i], DP_TRACE_MEASUREMENT_TYPE_TRACE, NULL,
+                                                 "packet dropped by application");
+        }
         marsio_dp_trace_record_write(mr_instance, (struct rte_mbuf *)obj_table[i]);
     }
     rte_mempool_generic_put(mp, obj_table, n, cache);
@@ -372,6 +383,13 @@ void * marsio_pkt_jump_to_innermost_layer(const marsio_buff_t * mbuf, enum compl
     struct mrb_metadata * mrb_meta = rte_mbuf_to_priv((struct rte_mbuf *)mbuf);
     struct pkt_parser_result * pkt_parser_result = &mrb_meta->pkt_parser_result;
 
+    if (pkt_parser_result->nr_layers == 0)
+    {
+        struct pkt_parser handler;
+        pkt_parser_init(&handler, pkt_parser_result, LAYER_TYPE_ALL, MR_PKT_PARSER_LAYERS_MAX);
+        pkt_parser_exec(&handler, mbuf);
+    }
+
     void * ret = NULL;
     for (int i = pkt_parser_result->nr_layers - 1; i >= 0; i--)
     {
diff --git a/app/src/mrb.c b/app/src/mrb.c
index f7eb885..5eddb02 100644
--- a/app/src/mrb.c
+++ b/app/src/mrb.c
@@ -120,13 +120,6 @@ void marsio_buff_free_v2(struct mr_instance * instance, marsio_buff_t * buff[],
         struct rte_mbuf * m = (struct rte_mbuf *)buff[i];
         struct rte_mbuf * m_next = NULL;
 
-        if (marsio_dp_trace_measurements_can_emit(instance, m, DP_TRACE_MEASUREMENT_TYPE_TRACE))
-        {
-            marsio_dp_trace_measurement_emit_str(instance, m, DP_TRACE_MEASUREMENT_TYPE_TRACE, NULL,
-                                                 "packet dropped by application");
-        }
-        dp_trace_record_write(instance->trace, m, marsio_thread_id_get());
-
         __rte_mbuf_sanity_check(m, 1);
         while (m != NULL)
         {
diff --git a/app/src/rawio.c b/app/src/rawio.c
index 4a17e4f..27afe7f 100644
--- a/app/src/rawio.c
+++ b/app/src/rawio.c
@@ -103,6 +103,13 @@ int marsio_recv_burst(struct mr_vdev * vdev, queue_id_t qid, marsio_buff_t * mbu
     {
         mbufs[i] = rx_buffer->mbufs[rx_buffer->curser + i];
 
+        if (unlikely(
+                marsio_dp_trace_measurements_can_emit(vdev->instance, mbufs[i], DP_TRACE_MEASUREMENT_TYPE_TELEMETRY)))
+        {
+            marsio_dp_trace_measurement_emit_fmt(vdev->instance, mbufs[i], DP_TRACE_MEASUREMENT_TYPE_TELEMETRY,
+                                                 "marsio_recv", "packet rx, dev=%s, qid=%u", vdev->devsym, qid);
+        }
+
         if (unlikely(marsio_dp_trace_measurements_can_emit(vdev->instance, mbufs[i], DP_TRACE_MEASUREMENT_TYPE_TRACE)))
         {
             marsio_dp_trace_measurement_emit_fmt(vdev->instance, mbufs[i], DP_TRACE_MEASUREMENT_TYPE_TRACE,
@@ -142,6 +149,13 @@ int marsio_send_buffer_flush(struct mr_vdev * vdev, queue_id_t sid)
     for (int i = 0; i < tx_buffer->length; i++)
     {
         hash[i] = tx_buffer->mbufs[i]->hash.usr;
+        if (marsio_dp_trace_measurements_can_emit(instance, tx_buffer->mbufs[i], DP_TRACE_MEASUREMENT_TYPE_TELEMETRY))
+        {
+            marsio_dp_trace_measurement_emit_fmt(vdev->instance, tx_buffer->mbufs[i],
+                                                 DP_TRACE_MEASUREMENT_TYPE_TELEMETRY, "marsio_send",
+                                                 "packet tx, dev=%s , qid=%u, hash=%u", vdev->devsym, sid, hash[i]);
+        }
+
         if (marsio_dp_trace_measurements_can_emit(instance, tx_buffer->mbufs[i], DP_TRACE_MEASUREMENT_TYPE_TRACE))
         {
             marsio_dp_trace_measurement_emit_fmt(vdev->instance, tx_buffer->mbufs[i], DP_TRACE_MEASUREMENT_TYPE_TRACE,
diff --git a/examples/l2fwd-nf.c b/examples/l2fwd-nf.c
index 6c245e2..c6f10de 100644
--- a/examples/l2fwd-nf.c
+++ b/examples/l2fwd-nf.c
@@ -110,7 +110,6 @@ void * l2fwd_loop(void * arg)
                 marsio_buff_set_metadata(deep_copy_buff, MR_BUFF_ROUTE_CTX, route_ctx, sizeof(route_ctx));
                 marsio_buff_set_sid_list(deep_copy_buff, sids, nr_sids);
 
-                marsio_dp_trace_filter_exec(mr_instance, deep_copy_buff);
                 if (marsio_dp_trace_measurements_can_emit(mr_instance, deep_copy_buff, DP_TRACE_MEASUREMENT_TYPE_TRACE))
                 {
                     marsio_dp_trace_measurement_emit_str(mr_instance, deep_copy_buff, DP_TRACE_MEASUREMENT_TYPE_TRACE,
diff --git a/include/external/marsio.h b/include/external/marsio.h
index 0a54c20..3eb68dd 100644
--- a/include/external/marsio.h
+++ b/include/external/marsio.h
@@ -330,7 +330,9 @@ marsio_dp_trace_record_emit_fmt(struct mr_instance * instance, marsio_buff_t * m
 #define DP_TRACE_MEASUREMENT_TYPE_TRACE (1 << 0)
 #define DP_TRACE_MEASUREMENT_TYPE_TELEMETRY (1 << 1)
 
-void marsio_dp_trace_filter_exec(struct mr_instance * instance, marsio_buff_t * mbuf);
+__attribute__((
+    deprecated("Users do not need to manually call this function.The current function will be removed in 24.06."))) void
+marsio_dp_trace_filter_exec(struct mr_instance * instance, marsio_buff_t * mbuf);
 
 int marsio_dp_trace_measurements_can_emit(struct mr_instance * instance, const marsio_buff_t * mbuf,
                                           uint8_t measurement_type);
@@ -346,6 +348,8 @@ int marsio_dp_trace_measurement_emit_fmt(struct mr_instance * instance, marsio_b
 #define MR_BPF_EXPRESSION_MAX 128
 #endif
 
+#define DP_TRACE_TRAFFIC_LINK_ID_ARRAY_SIZE_MAX 8
+
 #define DP_TRACE_JOB_NUM_MAX 16
 
 #define DP_TRACE_RING_NUM 4
@@ -380,6 +384,8 @@ struct dp_trace_job_desc
     unsigned int pkt_cnt_max;
     unsigned int sampling;
     unsigned int snaplen;
+    uint8_t traffic_link_id_cnt;
+    uint16_t traffic_link_ids[DP_TRACE_TRAFFIC_LINK_ID_ARRAY_SIZE_MAX];
 };
 
 void * marsio_pkt_jump_to_innermost_layer(const marsio_buff_t * mbuf, enum complex_layer_type_id layer_id);
diff --git a/infra/src/dp_trace.c b/infra/src/dp_trace.c
index 7b31559..eac9a07 100644
--- a/infra/src/dp_trace.c
+++ b/infra/src/dp_trace.c
@@ -196,6 +196,12 @@ int dp_trace_job_add(struct dp_trace_process * trace, const struct dp_trace_job_
     ctx->desc.sampling = desc->sampling;
     ctx->desc.snaplen = desc->snaplen;
 
+    ctx->desc.traffic_link_id_cnt = desc->traffic_link_id_cnt;
+    for (unsigned int i = 0; i < desc->traffic_link_id_cnt; i++)
+    {
+        ctx->desc.traffic_link_ids[i] = desc->traffic_link_ids[i];
+    }
+
     ctx->used = true;
     instance->nr_job_ctx++;
     MR_INFO("[add job:%u] bpf_expr: %s type: %u", rule_index, ctx->desc.bpf_expr, ctx->desc.measurement_type);
@@ -239,11 +245,38 @@ uint16_t dp_trace_filter_exec_jobs_get(struct dp_trace_process * trace, struct r
     for (unsigned int i = 0; i < DP_TRACE_JOB_NUM_MAX; i++)
     {
         ctx = &instance->job_ctx[i];
-        if (ctx->used && (pcap_offline_filter(&ctx->fp, &header, pkt) != 0))
+        if (!ctx->used)
+        {
+            continue;
+        }
+
+        // compare traffic_link_id
+        uint8_t traffic_link_id_match = 0;
+        if (ctx->desc.traffic_link_id_cnt == 0)
+        {
+            traffic_link_id_match = 1;
+        }
+        else
+        {
+            for (unsigned j = 0; j < ctx->desc.traffic_link_id_cnt; j++)
+            {
+                if (mrb_meta->traffic_link_id == ctx->desc.traffic_link_ids[j])
+                {
+                    traffic_link_id_match = 1;
+                    break;
+                }
+            }
+        }
+
+        if (traffic_link_id_match == 0)
+        {
+            continue;
+        }
+
+        if ((pcap_offline_filter(&ctx->fp, &header, pkt) != 0))
         {
-            // When the maximum number of data packet records is reached, the tag will no longer be added to the data
-            // packet.
-            // unlimit: ctx->desc.pkt_cnt_max == 0
+            // When the maximum number of data packet records is reached, the tag will no longer be added to the
+            // data packet. unlimit: ctx->desc.pkt_cnt_max == 0
             target_packet = true;
             if (ctx->desc.pkt_cnt_max != 0 && statistics->filter_exec_hit[i] >= ctx->desc.pkt_cnt_max)
             {
diff --git a/service/src/dp_trace.c b/service/src/dp_trace.c
index 35949d0..166a2d1 100644
--- a/service/src/dp_trace.c
+++ b/service/src/dp_trace.c
@@ -194,6 +194,12 @@ void hook_rte_pktmbuf_free(struct rte_mbuf * m)
     if (m == NULL)
         return;
     struct dp_trace_process * trace = sc_main_get()->trace;
+    if (unlikely(dp_trace_record_can_emit(m, DP_TRACE_MEASUREMENT_TYPE_TRACE)))
+    {
+        struct dp_trace_record_meta meta = {
+            .measurement_type = DP_TRACE_MEASUREMENT_TYPE_TRACE, .appsym = MR_TRACE_APPSYM, .module = ""};
+        dp_trace_record_emit_str(sc_main_get()->trace, m, rte_lcore_id(), &meta, "packet free.");
+    }
     dp_trace_record_write(trace, m, rte_lcore_id());
     rte_pktmbuf_free(m);
 }
@@ -205,6 +211,12 @@ void hook_rte_pktmbuf_free_bulk(struct rte_mbuf ** mbufs, unsigned int count)
     {
         if (mbufs[idx] == NULL)
             continue;
+        if (unlikely(dp_trace_record_can_emit(mbufs[idx], DP_TRACE_MEASUREMENT_TYPE_TRACE)))
+        {
+            struct dp_trace_record_meta meta = {
+                .measurement_type = DP_TRACE_MEASUREMENT_TYPE_TRACE, .appsym = MR_TRACE_APPSYM, .module = ""};
+            dp_trace_record_emit_str(sc_main_get()->trace, mbufs[idx], rte_lcore_id(), &meta, "packet free.");
+        }
         dp_trace_record_write(trace, mbufs[idx], rte_lcore_id());
     }
     rte_pktmbuf_free_bulk(mbufs, count);
diff --git a/service/src/node_classifier.c b/service/src/node_classifier.c
index d4e87e3..c1784ce 100644
--- a/service/src/node_classifier.c
+++ b/service/src/node_classifier.c
@@ -428,6 +428,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
         for (uint8_t pkt_idx = 0; pkt_idx < FWDSTEP; pkt_idx++)
         {
             mrb_metadata[pkt_idx] = mrbuf_cz_data(pending_mbufs[pkt_idx], MR_NODE_CTRLZONE_ID);
+            dp_trace_filter_exec(sc_main_get()->trace, pending_mbufs[pkt_idx], 0, lcore_id);
         }
 
         uint16_t domain_field_for_pkts[FWDSTEP];
@@ -532,6 +533,8 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
         mbufs += 1;
         n_left_from -= 1;
 
+        dp_trace_filter_exec(sc_main_get()->trace, mbuf0, 0, lcore_id);
+
         struct match_result_engine result;
         struct mrb_metadata * mrb_metadata = mrbuf_cz_data(mbuf0, MR_NODE_CTRLZONE_ID);
         uint16_t pattern_group_id =
diff --git a/service/src/node_phydev.c b/service/src/node_phydev.c
index 39c16f0..b5a74a9 100644
--- a/service/src/node_phydev.c
+++ b/service/src/node_phydev.c
@@ -527,9 +527,6 @@ static __rte_always_inline uint16_t dpdk_dev_rx_node_process(struct rte_graph *
 
         parser_results[i] = &mrb_meta->pkt_parser_result;
 
-        /* mark packets for trace*/
-        dp_trace_filter_exec(sc_main_get()->trace, mbuf, 0, rte_lcore_id());
-
         /* Check if tracing is enabled for the current Mbuf */
         if (unlikely(dp_trace_record_can_emit(mbuf, DP_TRACE_MEASUREMENT_TYPE_TRACE)))
         {