dp trace enhancement

3 files changed, 230 insertions, 60 deletions

diff --git a/infra/include/dp_trace.h b/infra/include/dp_trace.h
index a6528d4..d00fd27 100644
--- a/infra/include/dp_trace.h
+++ b/infra/include/dp_trace.h
@@ -15,6 +15,8 @@
 #define DP_TRACE_JOB_NUM_MAX 16
 #define DP_TRACE_RING_SIZE_MAX 4096
 
+// #define DP_TRACE_CACHE_SIZE 512
+
 #define DP_TRACE_POOL_NAME "dp_trace_pool"
 #define DP_TRACE_DUMP_POOL_NAME "dp_trace_dump_pool"
 #define DP_TRACE_RING_NAME "dp_trace_ring"
@@ -28,10 +30,11 @@ typedef uint16_t job_bitmap_t;
 
 struct dp_trace_job_desc
 {
-    char app_name[MR_SYMBOL_MAX];
+    bool enable;
     char bpf_expr[MR_BPF_EXPRSSION_MAX];
     unsigned int pkt_cnt_max;
-    unsigned int sample_rate;
+    unsigned int sampling;
+    unsigned int snaplen;
 };
 
 struct dp_trace_job_ctx
@@ -40,7 +43,7 @@ struct dp_trace_job_ctx
     bool used;
     struct bpf_program fp;
     job_bitmap_t job_id;
-    unsigned int pkt_cnt;
+    uint64_t pkt_cnt;
 };
 
 struct dp_trace_stat
@@ -55,6 +58,7 @@ struct dp_trace_stat
     rte_atomic64_t record_buf_alloc_success; // record_buf_alloc_success = ring_enqueue_failed + ring_enqueue_success
 
     rte_atomic64_t record_emit_failed_no_space_in_buf;
+    rte_atomic64_t record_emit_failed_trace_length_too_long;
     rte_atomic64_t record_emit_success;
 
     rte_atomic64_t ring_enqueue_failed;
@@ -72,16 +76,20 @@ struct dp_trace_stat
 
 struct dp_trace_instance
 {
+    bool trace_stop;
+    bool enable;
     struct dp_trace_job_ctx job_ctx[DP_TRACE_JOB_NUM_MAX];
     struct rte_ring * ring;
     struct rte_mempool * pool;
     struct rte_mempool * dump_pool;
+
     pthread_mutex_t trace_file_mutex;
+    unsigned int trace_file_max_size;
     char trace_file_path[PATH_MAX];
+    char trace_file_bak_path[PATH_MAX];
     rte_pcapng_t * pcapng;
-    unsigned int trace_file_max_size;
-    bool trace_stop;
-    bool enable;
+    unsigned int trace_merge_timeout;
+
     struct dp_trace_stat statistics;
 };
 
@@ -108,6 +116,8 @@ struct dp_trace_buffer
 
     struct dp_trace_instance * inst;
 
+    unsigned int snaplen;
+
     /* record buffer*/
     uint16_t buffer_len;
     uint16_t buffer_used;
diff --git a/infra/src/dp_trace.c b/infra/src/dp_trace.c
index dd1a231..c73ba2f 100644
--- a/infra/src/dp_trace.c
+++ b/infra/src/dp_trace.c
@@ -15,7 +15,7 @@
 static void * dp_trace_save_thread(void * arg);
 static struct dp_trace_instance * dp_trace_instance_create();
 static int trace_file_mutex_lock(struct dp_trace_process * trace);
-static int trace_file_mutex_unlock(struct dp_trace_process * trace);
+static int dp_trace_file_mutex_unlock(struct dp_trace_process * trace);
 static inline bool dp_trace_is_stopped(struct dp_trace_process * trace);
 
 /* copy from dpdk-23.11.After upgrading dpdk, you can delete the following content */
@@ -24,6 +24,7 @@ static struct rte_mbuf * dpdk_23_rte_pcapng_copy(uint16_t port_id, uint32_t queu
                                                  enum rte_pcapng_direction direction, const char * comment);
 static int dpdk_23_pcapng_vlan_insert(struct rte_mbuf * m, uint16_t ether_type, uint16_t tci);
 static char * os_info_get(void);
+static void dp_trace_file_merge(struct dp_trace_process * trace);
 
 struct dp_record
 {
@@ -40,6 +41,11 @@ static bool is_directory_exists(const char * path)
 }
 #endif
 
+static bool is_file_exists(const char * path)
+{
+    return access(path, F_OK) == 0;
+}
+
 static struct dp_trace_instance * dp_trace_instance_create()
 {
     static_assert(DP_TRACE_JOB_NUM_MAX <= 16, "DP_TRACE_JOB_NUM_MAX must be no greater than 16");
@@ -81,6 +87,7 @@ static struct dp_trace_instance * dp_trace_instance_create()
 
     rte_atomic64_init(&instance->statistics.record_buf_alloc_failed_no_mem);
     rte_atomic64_init(&instance->statistics.record_buf_alloc_success);
+    rte_atomic64_init(&instance->statistics.record_emit_failed_trace_length_too_long);
     rte_atomic64_init(&instance->statistics.record_emit_failed_no_space_in_buf);
     rte_atomic64_init(&instance->statistics.record_emit_success);
 
@@ -233,10 +240,11 @@ int dp_trace_job_add(struct dp_trace_process * trace, const struct dp_trace_job_
     pcap_freecode(&fp);
     pcap_close(pcap_handle);
 
-    snprintf(ctx->desc.app_name, sizeof(ctx->desc.app_name), "%s", desc->app_name);
+    ctx->desc.enable = desc->enable;
     snprintf(ctx->desc.bpf_expr, sizeof(ctx->desc.bpf_expr), "%s", desc->bpf_expr);
     ctx->desc.pkt_cnt_max = desc->pkt_cnt_max;
-    ctx->desc.sample_rate = desc->sample_rate;
+    ctx->desc.sampling = desc->sampling;
+    ctx->desc.snaplen = desc->snaplen;
 
     ctx->used = true;
 
@@ -250,7 +258,39 @@ err:
     return -1;
 }
 
-uint16_t dp_trace_filter_exec_jobs_get(struct dp_trace_process * trace, struct rte_mbuf * mbuf, unsigned int offset)
+#if 0
+unsigned int dp_trace_snaplen_get(struct dp_trace_process * trace, struct rte_mbuf * mbuf)
+{
+    // When a packet hits multiple rules, the longest snaplen is used.
+
+    struct mrb_metadata * mrb_meta = (struct mrb_metadata *)mrbuf_cz_data(mbuf, 1);
+    struct dp_trace_buffer * dp_trace_buffer = mrb_meta->dp_trace_buffer;
+
+    if (dp_trace_buffer == NULL)
+    {
+        return UINT32_MAX;
+    }
+
+    unsigned int snaplen = 0;
+    job_bitmap_t jobs = dp_trace_buffer->jobs;
+    struct dp_trace_job_ctx * job_ctx = (struct dp_trace_job_ctx *)&trace->inst->job_ctx;
+
+    for (unsigned int i = 0; i < DP_TRACE_JOB_NUM_MAX; i++)
+    {
+        struct dp_trace_job_ctx * job_i_ctx = &job_ctx[i];
+        struct dp_trace_job_desc * job_desc = &job_i_ctx->desc;
+        if ((jobs & job_i_ctx->job_id) != 0)
+        {
+            snaplen = (job_desc->snaplen > snaplen) ? job_desc->snaplen : snaplen;
+        }
+    }
+
+    return snaplen;
+}
+#endif
+
+uint16_t dp_trace_filter_exec_jobs_get(struct dp_trace_process * trace, struct rte_mbuf * mbuf, unsigned int offset,
+                                       unsigned int * snaplen)
 {
     struct dp_trace_instance * instance = trace->inst;
 
@@ -279,13 +319,22 @@ uint16_t dp_trace_filter_exec_jobs_get(struct dp_trace_process * trace, struct r
             // packet.
             // unlimit: ctx->desc.pkt_cnt_max == 0
             target_packet = true;
-            if (ctx->desc.pkt_cnt_max != 0 && ctx->pkt_cnt == ctx->desc.pkt_cnt_max)
+            if (ctx->desc.pkt_cnt_max != 0 && ctx->pkt_cnt >= ctx->desc.pkt_cnt_max)
             {
                 rte_atomic64_inc(&trace->inst->statistics.reach_pkt_cnt_limit);
                 continue;
             }
-            match_jobs = match_jobs | ctx->job_id;
             ctx->pkt_cnt++;
+            if (ctx->pkt_cnt % ctx->desc.sampling == 0)
+            {
+                // match every sampling packet
+                match_jobs = match_jobs | ctx->job_id;
+
+                if (ctx->desc.snaplen > *snaplen)
+                {
+                    *snaplen = ctx->desc.snaplen;
+                }
+            }
         }
     }
 
@@ -339,12 +388,13 @@ void dp_trace_filter_exec(struct dp_trace_process * trace, struct rte_mbuf * mbu
         pkt_parser_exec(&pkt_parser, mbuf);
     }
 
+    unsigned int snaplen = 0;
     for (unsigned int i = 0; i < pkt_parser_result->nr_layers; i++)
     {
         if (pkt_parser_result->layers[i].type_id == LAYER_TYPE_ID_ETHER &&
             pkt_parser_result->layers[i].offset >= offset)
         {
-            match_jobs |= dp_trace_filter_exec_jobs_get(trace, mbuf, pkt_parser_result->layers[i].offset);
+            match_jobs |= dp_trace_filter_exec_jobs_get(trace, mbuf, pkt_parser_result->layers[i].offset, &snaplen);
         }
     }
 
@@ -362,7 +412,7 @@ void dp_trace_filter_exec(struct dp_trace_process * trace, struct rte_mbuf * mbu
             dp_trace_buffer->buffer_len = DP_TRACE_RECORD_SIZE - header_size;
             dp_trace_buffer->inst = trace->inst;
             dp_trace_buffer->jobs = match_jobs;
-            // dp_trace_buffer->buffer_used = 0;
+            dp_trace_buffer->snaplen = snaplen;
             rte_atomic64_inc(&trace->inst->statistics.record_buf_alloc_success);
             mrb_meta->dp_trace_can_emit = 1;
         }
@@ -420,7 +470,7 @@ int dp_trace_record_emit_fmt(struct dp_trace_process * trace, struct rte_mbuf *
 
     if (unlikely(ret < 0 || ret >= 512))
     {
-        rte_atomic64_inc(&trace->inst->statistics.record_emit_failed_no_space_in_buf);
+        rte_atomic64_inc(&trace->inst->statistics.record_emit_failed_trace_length_too_long);
         return -1;
     }
 
@@ -505,11 +555,11 @@ static bool dp_trace_file_open(struct dp_trace_process * trace)
             goto end;
         }
     }
-    trace_file_mutex_unlock(trace);
+    dp_trace_file_mutex_unlock(trace);
     return true;
 
 end:
-    trace_file_mutex_unlock(trace);
+    dp_trace_file_mutex_unlock(trace);
     return false;
 }
 
@@ -518,19 +568,10 @@ static void dp_trace_file_close(struct dp_trace_process * trace)
     trace_file_mutex_lock(trace);
     if (likely(trace->inst->pcapng != NULL))
     {
-        uint32_t loss_pkt_cnt = rte_atomic64_read(&trace->inst->statistics.reach_pkt_cnt_limit) +
-                                rte_atomic64_read(&trace->inst->statistics.record_buf_alloc_failed_no_mem) +
-                                rte_atomic64_read(&trace->inst->statistics.ring_enqueue_failed) +
-                                rte_atomic64_read(&trace->inst->statistics.save_to_file_failed_at_pcapng_format) +
-                                rte_atomic64_read(&trace->inst->statistics.save_to_file_failed_at_write_to_disk) +
-                                rte_atomic64_read(&trace->inst->statistics.save_to_file_failed_other);
-        uint32_t filter_exec_hit = rte_atomic64_read(&trace->inst->statistics.filter_exec_hit);
-
-        rte_pcapng_write_stats(trace->inst->pcapng, 0, NULL, 0, 0, filter_exec_hit, loss_pkt_cnt);
         rte_pcapng_close(trace->inst->pcapng);
         trace->inst->pcapng = NULL;
     }
-    trace_file_mutex_unlock(trace);
+    dp_trace_file_mutex_unlock(trace);
 }
 
 bool dp_trace_start(struct dp_trace_process * trace)
@@ -544,6 +585,7 @@ bool dp_trace_start(struct dp_trace_process * trace)
         rte_atomic64_clear(&trace->inst->statistics.reach_pkt_cnt_limit);
         rte_atomic64_clear(&trace->inst->statistics.record_buf_alloc_failed_no_mem);
         rte_atomic64_clear(&trace->inst->statistics.record_buf_alloc_success);
+        rte_atomic64_clear(&trace->inst->statistics.record_emit_failed_trace_length_too_long);
         rte_atomic64_clear(&trace->inst->statistics.record_emit_failed_no_space_in_buf);
         rte_atomic64_clear(&trace->inst->statistics.record_emit_success);
         rte_atomic64_clear(&trace->inst->statistics.ring_enqueue_failed);
@@ -554,10 +596,15 @@ bool dp_trace_start(struct dp_trace_process * trace)
         rte_atomic64_clear(&trace->inst->statistics.save_to_file_success);
         rte_atomic64_clear(&trace->inst->statistics.uncategorized_failed);
 
+        if (remove(trace->inst->trace_file_bak_path) < 0)
+        {
+            MR_ERROR("remove %s failed. error info: %s", trace->inst->trace_file_bak_path, strerror(errno));
+        }
+
         trace->inst->trace_stop = false;
         ret = true;
     }
-    trace_file_mutex_unlock(trace);
+    dp_trace_file_mutex_unlock(trace);
     return ret;
 }
 
@@ -572,15 +619,128 @@ void dp_trace_stop(struct dp_trace_process * trace)
 
     trace_file_mutex_lock(trace);
     dp_trace_file_close(trace);
-    trace_file_mutex_unlock(trace);
+    dp_trace_file_merge(trace);
+    dp_trace_file_mutex_unlock(trace);
+}
+
+#if 0
+void new_filename_generate(const char * old_filename, char * new_filename, unsigned int buf_len, const char * suffix)
+{
+    assert(strlen(old_filename) <= PATH_MAX);
+
+    char * dot = strrchr(old_filename, '.');
+    if (dot == NULL)
+    {
+        snprintf(new_filename, buf_len, "%s_%s", old_filename, suffix);
+    }
+    else
+    {
+        unsigned int name_len = dot - old_filename;
+        assert(buf_len > name_len);
+
+        strncpy(new_filename, old_filename, name_len);
+        snprintf(new_filename + name_len, buf_len - name_len, "_%s%s", suffix, dot);
+    }
+}
+#endif
+
+static void dp_trace_file_merge(struct dp_trace_process * trace)
+{
+    if (!is_file_exists(trace->inst->trace_file_bak_path))
+    {
+        // Only one file, no need to merge
+        return;
+    }
+
+    trace_file_mutex_lock(trace);
+
+    char tmp_name[PATH_MAX];
+    snprintf(tmp_name, sizeof(tmp_name), "%s.2", trace->inst->trace_file_path);
+
+    dp_trace_file_close(trace);
+
+    // If newpath already exists, it will be atomically replaced
+    if (rename(trace->inst->trace_file_path, tmp_name) < 0)
+    {
+        MR_ERROR("rename %s to %s failed. error info: %s", trace->inst->trace_file_path, tmp_name, strerror(errno));
+    }
+
+    char command[2 * PATH_MAX];
+    snprintf(command, sizeof(command), "timeout -v %us mergecap -w %s %s %s 2>&1", trace->inst->trace_merge_timeout,
+             trace->inst->trace_file_path, tmp_name, trace->inst->trace_file_bak_path);
+    MR_INFO("merge trace file: %s", command);
+
+    FILE * fp;
+    char buffer[1024];
+    fp = popen(command, "r");
+    if (fp == NULL)
+    {
+        MR_ERROR("open pipe failed: %s", strerror(errno));
+        goto err;
+    }
+
+    while (fgets(buffer, sizeof(buffer), fp) != NULL)
+    {
+        MR_ERROR("merge trace file output: %s", buffer);
+    }
+
+    pclose(fp);
+
+    if (remove(tmp_name) < 0)
+    {
+        MR_ERROR("remove %s failed. error info: %s", tmp_name, strerror(errno));
+    }
+
+    if (remove(trace->inst->trace_file_bak_path) < 0)
+    {
+        MR_ERROR("remove %s failed. error info: %s", trace->inst->trace_file_bak_path, strerror(errno));
+    }
+
+    dp_trace_file_mutex_unlock(trace);
+    return;
+
+err:
+    if (rename(tmp_name, trace->inst->trace_file_path) < 0)
+    {
+        MR_ERROR("rename %s to %s failed. error info: %s", tmp_name, trace->inst->trace_file_path, strerror(errno));
+    }
+
+    dp_trace_file_mutex_unlock(trace);
+    return;
+}
+
+static void dp_trace_file_rollbak(struct dp_trace_process * trace)
+{
+    trace_file_mutex_lock(trace);
+
+    const char * cur_filename = trace->inst->trace_file_path;
+    char * bak_filename = trace->inst->trace_file_bak_path;
+    unsigned int bak_filename_len = sizeof(trace->inst->trace_file_bak_path);
+
+    dp_trace_file_close(trace);
+
+    snprintf(bak_filename, bak_filename_len, "%s.1", cur_filename);
+
+    if (rename(cur_filename, bak_filename) < 0)
+    {
+        MR_ERROR("rename %s to %s failed. error info: %s", cur_filename, bak_filename, strerror(errno));
+    }
+
+    dp_trace_file_open(trace);
+
+    dp_trace_file_mutex_unlock(trace);
 }
 
 static bool dp_trace_file_reach_max_size(struct dp_trace_process * trace)
 {
     // max_size == 0 : unlimit write
-    unsigned int max_size = trace->inst->trace_file_max_size;
+    trace_file_mutex_lock(trace);
+
+    unsigned int max_size = trace->inst->trace_file_max_size / 2;
+
     if (max_size == 0)
     {
+        dp_trace_file_mutex_unlock(trace);
         return false;
     }
 
@@ -588,12 +748,18 @@ static bool dp_trace_file_reach_max_size(struct dp_trace_process * trace)
     if (unlikely(stat(trace->inst->trace_file_path, &file_stat) == -1))
     {
         MR_ERROR("Failed to obtain data path trace file status.");
+        dp_trace_file_mutex_unlock(trace);
         return true;
     }
 
     // unit is B -> KB
     if ((file_stat.st_size >> 10) >= max_size)
+    {
+        dp_trace_file_mutex_unlock(trace);
         return true;
+    }
+
+    dp_trace_file_mutex_unlock(trace);
     return false;
 }
 
@@ -602,6 +768,8 @@ static void * dp_trace_save_thread(void * arg)
     struct dp_trace_process * trace = (struct dp_trace_process *)arg;
     mr_thread_setname(pthread_self(), "dp_trace_save_thread");
     MR_DEBUG("start data path trace save thread");
+    char * decode_trace_buf = ZMALLOC(DP_TRACE_RECORD_SIZE);
+    MR_VERIFY_MALLOC(decode_trace_buf);
 
     while (rte_atomic16_read(&trace->save_thread_still_run) == 1)
     {
@@ -646,14 +814,6 @@ static void * dp_trace_save_thread(void * arg)
                 struct mrb_metadata * mrb_meta = (struct mrb_metadata *)mrbuf_cz_data(mbuf, 1);
                 struct dp_trace_buffer * dp_trace_buffer = mrb_meta->dp_trace_buffer;
 
-                char * decode_trace_buf = NULL;
-                ret = rte_mempool_get(trace->inst->pool, (void **)&decode_trace_buf);
-                if (unlikely(ret < 0))
-                {
-                    rte_atomic64_inc(&trace->inst->statistics.save_to_file_failed_other);
-                    goto release_buffer;
-                }
-
                 ret = dp_trace_record_decode(mbuf, decode_trace_buf, DP_TRACE_RECORD_SIZE);
                 if (unlikely(ret < 0))
                 {
@@ -662,18 +822,18 @@ static void * dp_trace_save_thread(void * arg)
                 }
 
                 struct rte_mbuf * pkt =
-                    dpdk_23_rte_pcapng_copy(0, 0, mbuf, trace->inst->dump_pool, rte_pktmbuf_pkt_len(mbuf),
+                    dpdk_23_rte_pcapng_copy(0, 0, mbuf, trace->inst->dump_pool, dp_trace_buffer->snaplen,
                                             RTE_PCAPNG_DIRECTION_UNKNOWN, decode_trace_buf);
                 if (pkt == NULL)
+                {
                     rte_atomic64_inc(&trace->inst->statistics.save_to_file_failed_at_pcapng_format);
+                }
                 else
+                {
                     pcapng_records[copy_cnt++] = pkt;
+                }
 
             release_buffer:
-                if (decode_trace_buf != NULL)
-                {
-                    rte_mempool_put(trace->inst->pool, (void *)decode_trace_buf);
-                }
                 rte_mempool_put(trace->inst->pool, (void *)dp_trace_buffer);
             }
             rte_pktmbuf_free_bulk(records, n);
@@ -695,12 +855,12 @@ static void * dp_trace_save_thread(void * arg)
             // OR in the configuration file, stop trace
             if (dp_trace_file_reach_max_size(trace))
             {
-                // Stop trace; flush the contents of the ring to the file
-                trace->inst->trace_stop = true;
+                dp_trace_file_rollbak(trace);
             }
         }
-        trace_file_mutex_unlock(trace);
+        dp_trace_file_mutex_unlock(trace);
     }
+    FREE(decode_trace_buf);
     pthread_exit(NULL);
 }
 
@@ -831,7 +991,7 @@ int trace_file_mutex_lock(struct dp_trace_process * trace)
     return 0;
 }
 
-int trace_file_mutex_unlock(struct dp_trace_process * trace)
+int dp_trace_file_mutex_unlock(struct dp_trace_process * trace)
 {
     return pthread_mutex_unlock(&trace->inst->trace_file_mutex);
 }
diff --git a/infra/test/TestDataPathTrace.cc b/infra/test/TestDataPathTrace.cc
index 9a3b2f4..9afd52f 100644
--- a/infra/test/TestDataPathTrace.cc
+++ b/infra/test/TestDataPathTrace.cc
@@ -214,7 +214,7 @@ TEST_F(DataPathTraceTest, InstanceCreate)
 TEST_F(DataPathTraceTest, JobInit)
 {
     int n;
-    struct dp_trace_job_desc desc = {"test", "ether host 64:f6:9d:5f:b9:76"};
+    struct dp_trace_job_desc desc = {true, "ether host 64:f6:9d:5f:b9:76", 10, 1};
     n = dp_trace_job_add(trace, &desc, 0);
     EXPECT_GE(n, 0);
     EXPECT_EQ(trace->inst->job_ctx[0].used, true);
@@ -222,10 +222,10 @@ TEST_F(DataPathTraceTest, JobInit)
 
 TEST_F(DataPathTraceTest, JobDestroy)
 {
-    struct dp_trace_job_desc desc = {"test", "ether host 64:f6:9d:5f:b9:76"};
+    struct dp_trace_job_desc desc = {true, "ether host 64:f6:9d:5f:b9:76", 10, 1};
     dp_trace_job_add(trace, &desc, 0);
 
-    struct dp_trace_job_desc desc_2 = {"test", "vlan && ip src 125.33.49.137"};
+    struct dp_trace_job_desc desc_2 = {true, "vlan && ip src 125.33.49.137", 10, 1};
     dp_trace_job_add(trace, &desc_2, 1);
 
     dp_trace_jobs_destroy(trace, 1 | 1 << 1);
@@ -242,10 +242,10 @@ TEST_F(DataPathTraceTest, BPFMatch)
     struct mrb_metadata * mrb_meta = (struct mrb_metadata *)mrbuf_cz_data(pkt73_mbuf, 1);
     unsigned int offset = mrb_meta->pkt_parser_result.layers[4].offset;
 
-    struct dp_trace_job_desc desc = {"test", "ether host 64:f6:9d:5f:b9:76"};
+    struct dp_trace_job_desc desc = {true, "ether host 64:f6:9d:5f:b9:76", 10, 1};
     dp_trace_job_add(trace, &desc, 0);
 
-    struct dp_trace_job_desc desc_2 = {"test", "vlan && ip src 125.33.49.137"};
+    struct dp_trace_job_desc desc_2 = {true, "vlan && ip src 125.33.49.137", 10, 1};
     dp_trace_job_add(trace, &desc_2, 1);
 
     ;
@@ -263,7 +263,7 @@ TEST_F(DataPathTraceTest, BPFMatchNet)
 {
     struct rte_mbuf * pkt1_buf = mbuf_construct(pkt1, sizeof(pkt1));
 
-    struct dp_trace_job_desc desc = {"test", "net 0.0.0.0/0"};
+    struct dp_trace_job_desc desc = {true, "net 0.0.0.0/0", 10, 1};
     dp_trace_job_add(trace, &desc, 0);
 
     dp_trace_filter_exec(trace, pkt1_buf, 0);
@@ -282,10 +282,10 @@ TEST_F(DataPathTraceTest, BPFMatchExternalAndInternal)
     struct rte_mbuf * pkt73_mbuf = mbuf_construct(pkt73, sizeof(pkt73));
     struct mrb_metadata * mrb_meta = (struct mrb_metadata *)mrbuf_cz_data(pkt73_mbuf, 1);
 
-    struct dp_trace_job_desc desc = {"test", "ip src 1.1.15.100"};
+    struct dp_trace_job_desc desc = {true, "ip src 1.1.15.100", 10, 1};
     dp_trace_job_add(trace, &desc, 0);
 
-    struct dp_trace_job_desc desc_2 = {"test", "vlan && ip src 125.33.49.137"};
+    struct dp_trace_job_desc desc_2 = {true, "vlan && ip src 125.33.49.137", 10, 1};
     dp_trace_job_add(trace, &desc_2, 1);
 
     dp_trace_filter_exec(trace, pkt73_mbuf, 0);
@@ -304,7 +304,7 @@ TEST_F(DataPathTraceTest, BPFUnmatch)
     struct mrb_metadata * mrb_meta = (struct mrb_metadata *)mrbuf_cz_data(pkt73_mbuf, 1);
     unsigned int offset = mrb_meta->pkt_parser_result.layers[4].offset;
 
-    struct dp_trace_job_desc desc = {"test", "vlan && ip src 127.0.0.1"};
+    struct dp_trace_job_desc desc = {true, "vlan && ip src 127.0.0.1", 10, 1};
     dp_trace_job_add(trace, &desc, 0);
 
     dp_trace_filter_exec(trace, pkt73_mbuf, offset);
@@ -321,7 +321,7 @@ TEST_F(DataPathTraceTest, EmitTrace)
     struct rte_mbuf * pkt73_mbuf = mbuf_construct(pkt73, sizeof(pkt73));
     struct mrb_metadata * mrb_meta = (struct mrb_metadata *)mrbuf_cz_data(pkt73_mbuf, 1);
 
-    struct dp_trace_job_desc desc = {"test", "ether host 64:f6:9d:5f:b9:76"};
+    struct dp_trace_job_desc desc = {true, "ether host 64:f6:9d:5f:b9:76", 10, 1};
     dp_trace_job_add(trace, &desc, 1);
 
     mrb_meta->packet_create_from_nf = 1;
@@ -355,7 +355,7 @@ TEST_F(DataPathTraceTest, StripToRing)
     struct mrb_metadata * mrb_meta = (struct mrb_metadata *)mrbuf_cz_data(pkt73_mbuf, 1);
     unsigned int offset = mrb_meta->pkt_parser_result.layers[4].offset;
 
-    struct dp_trace_job_desc desc = {"test", "ether host 64:f6:9d:5f:b9:76"};
+    struct dp_trace_job_desc desc = {true, "ether host 64:f6:9d:5f:b9:76", 10, 1};
     dp_trace_job_add(trace, &desc, 0);
 
     dp_trace_filter_exec(trace, pkt73_mbuf, offset);
@@ -376,7 +376,7 @@ TEST_F(DataPathTraceTest, SaveTraceToFile)
     struct mrb_metadata * mrb_meta = (struct mrb_metadata *)mrbuf_cz_data(pkt73_mbuf, 1);
     unsigned int offset = mrb_meta->pkt_parser_result.layers[4].offset;
 
-    struct dp_trace_job_desc desc = {"test", "ether host 64:f6:9d:5f:b9:76"};
+    struct dp_trace_job_desc desc = {true, "ether host 64:f6:9d:5f:b9:76", 10, 1};
     dp_trace_job_add(trace, &desc, 0);
 
     dp_trace_filter_exec(trace, pkt73_mbuf, offset);
@@ -397,7 +397,7 @@ TEST_F(DataPathTraceTest, SaveTraceToFile)
 
 TEST_F(DataPathTraceTest, MaxRecordCount)
 {
-    struct dp_trace_job_desc desc = {"test", "ether host 64:f6:9d:5f:b9:76", 2};
+    struct dp_trace_job_desc desc = {true, "ether host 64:f6:9d:5f:b9:76", 2, 1};
     dp_trace_job_add(trace, &desc, 0);
 
     EXPECT_TRUE(trace->inst->job_ctx[0].pkt_cnt == 0);