update tracing scripts to use correct probe names as in c++ code

Author: Naviabheeman

cmake/module/FindUSDT.cmake

@@ -74,5 +74,5 @@ if(USDT_FOUND AND NOT TARGET USDT::headers)
   set_target_properties(USDT::headers PROPERTIES
     INTERFACE_INCLUDE_DIRECTORIES "${USDT_INCLUDE_DIR}"
   )
-  set(ENABLE_TRACING TRUE)
+  set(ENABLE_TRACING ON)
 endif()

src/test/checkqueue_tests.cpp

@@ -16,6 +16,7 @@
 #include <vector>
 #include <mutex>
 #include <condition_variable>
+#include <chrono>
 
 #include <unordered_set>
 #include <memory>
@@ -221,18 +222,39 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure)
     auto fail_queue = new Failing_Queue{QUEUE_BATCH_SIZE, SCRIPT_CHECK_THREADS};
 
     for (size_t i = 0; i < 1001; ++i) {
-        CCheckQueueControl<FailingCheck> control(fail_queue);
-        size_t remaining = i;
-        while (remaining) {
-            size_t r = InsecureRandRange(10);
+        std::atomic<bool> test_completed{false};
+        std::atomic<bool> test_success{false};
 
-            std::vector<FailingCheck> vChecks;
-            vChecks.reserve(r);
-            for (size_t k = 0; k < r && remaining; k++, remaining--)
-                vChecks.emplace_back(remaining == 1);
-            control.Add(std::move(vChecks));
+        std::thread test_thread([&]() {
+            CCheckQueueControl<FailingCheck> control(fail_queue);
+            size_t remaining = i;
+            while (remaining) {
+                size_t r = InsecureRandRange(10);
+                std::vector<FailingCheck> vChecks;
+                vChecks.reserve(r);
+                for (size_t k = 0; k < r && remaining; k++, remaining--)
+                    vChecks.emplace_back(remaining == 1);
+                control.Add(std::move(vChecks));
+            }
+            bool success = control.Wait();
+            test_success.store(success);
+            test_completed.store(true);
+        });
+
+        // Wait for test completion with timeout
+        auto start_time = std::chrono::steady_clock::now();
+        while (!test_completed.load() &&
+               std::chrono::steady_clock::now() - start_time < std::chrono::seconds(10)) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+
+        if (test_thread.joinable()) {
+            test_thread.join();
         }
-        bool success = control.Wait();
+
+        BOOST_REQUIRE(test_completed.load());
+
+        bool success = test_success.load();
         if (i > 0) {
             BOOST_REQUIRE(!success);
         } else if (i == 0) {

test/CMakeLists.txt

@@ -19,6 +19,10 @@ if(NOT ENABLE_ZMQ)
 	set(ENABLE_ZMQ_TRUE "#")
 endif()
 
+if(NOT ENABLE_TRACING)
+	set(ENABLE_TRACING_TRUE "#")
+endif()
+
 # Create build ini file in build and source dir
 configure_file(config.ini.in config.ini USE_SOURCE_PERMISSIONS @ONLY)
 configure_file(config.ini.in ${abs_top_srcdir}/test/config.ini USE_SOURCE_PERMISSIONS @ONLY)

test/config.ini.in

@@ -20,4 +20,4 @@ RPCAUTH=@abs_top_srcdir@/share/rpcauth/rpcauth.py
 @BUILD_GENESIS_TRUE@BUILD_GENESIS=true
 @ENABLE_WALLET_TRUE@ENABLE_WALLET=true
 @ENABLE_ZMQ_TRUE@ENABLE_ZMQ=true
-@ENABLE_USDT_TRACEPOINTS_TRUE@ENABLE_USDT_TRACEPOINTS=true
+@ENABLE_TRACING_TRUE@ENABLE_TRACING=true

test/functional/interface_usdt_coinselection.py

@@ -23,27 +23,29 @@
 coinselection_tracepoints_program = """
 #include <uapi/linux/ptrace.h>
 
-#define WALLET_NAME_LENGTH 16
+#define COLOR_ID_LENGTH 64
 #define ALGO_NAME_LENGTH 16
 
 struct event_data
 {
     u8 type;
-    char wallet_name[WALLET_NAME_LENGTH];
+    char color_id[COLOR_ID_LENGTH];
 
-    // selected coins event
-    char algo[ALGO_NAME_LENGTH];
-    s64 target;
-    s64 waste;
+    // selected coins event (type 1)
+    s64 target_value;
     s64 selected_value;
+    s64 num_coins;
+    char algo[ALGO_NAME_LENGTH];
+
+    // coins requested event (type 2)
+    s64 amount;
 
-    // create tx event
-    bool success;
-    s64 fee;
-    s32 change_pos;
+    // change info event (type 3)
+    s64 change_amount;
 
-    // aps create tx event
-    bool use_aps;
+    // fee info event (type 4)
+    s64 fee_ret;
+    s64 fee_needed;
 };
 
 BPF_QUEUE(coin_selection_events, struct event_data, 1024);
@@ -52,45 +54,41 @@
     struct event_data data;
     __builtin_memset(&data, 0, sizeof(data));
     data.type = 1;
-    bpf_usdt_readarg_p(1, ctx, &data.wallet_name, WALLET_NAME_LENGTH);
-    bpf_usdt_readarg_p(2, ctx, &data.algo, ALGO_NAME_LENGTH);
-    bpf_usdt_readarg(3, ctx, &data.target);
-    bpf_usdt_readarg(4, ctx, &data.waste);
-    bpf_usdt_readarg(5, ctx, &data.selected_value);
+    bpf_usdt_readarg_p(1, ctx, &data.color_id, COLOR_ID_LENGTH);
+    bpf_usdt_readarg(2, ctx, &data.target_value);
+    bpf_usdt_readarg(3, ctx, &data.selected_value);
+    bpf_usdt_readarg(4, ctx, &data.num_coins);
+    bpf_usdt_readarg_p(5, ctx, &data.algo, ALGO_NAME_LENGTH);
     coin_selection_events.push(&data, 0);
     return 0;
 }
 
-int trace_normal_create_tx(struct pt_regs *ctx) {
+int trace_coins_requested(struct pt_regs *ctx) {
     struct event_data data;
     __builtin_memset(&data, 0, sizeof(data));
     data.type = 2;
-    bpf_usdt_readarg_p(1, ctx, &data.wallet_name, WALLET_NAME_LENGTH);
-    bpf_usdt_readarg(2, ctx, &data.success);
-    bpf_usdt_readarg(3, ctx, &data.fee);
-    bpf_usdt_readarg(4, ctx, &data.change_pos);
+    bpf_usdt_readarg(1, ctx, &data.amount);
+    bpf_usdt_readarg_p(2, ctx, &data.color_id, COLOR_ID_LENGTH);
     coin_selection_events.push(&data, 0);
     return 0;
 }
 
-int trace_attempt_aps(struct pt_regs *ctx) {
+int trace_change_info(struct pt_regs *ctx) {
     struct event_data data;
     __builtin_memset(&data, 0, sizeof(data));
     data.type = 3;
-    bpf_usdt_readarg_p(1, ctx, &data.wallet_name, WALLET_NAME_LENGTH);
+    bpf_usdt_readarg(1, ctx, &data.change_amount);
+    bpf_usdt_readarg_p(2, ctx, &data.color_id, COLOR_ID_LENGTH);
     coin_selection_events.push(&data, 0);
     return 0;
 }
 
-int trace_aps_create_tx(struct pt_regs *ctx) {
+int trace_fee_info(struct pt_regs *ctx) {
     struct event_data data;
     __builtin_memset(&data, 0, sizeof(data));
     data.type = 4;
-    bpf_usdt_readarg_p(1, ctx, &data.wallet_name, WALLET_NAME_LENGTH);
-    bpf_usdt_readarg(2, ctx, &data.use_aps);
-    bpf_usdt_readarg(3, ctx, &data.success);
-    bpf_usdt_readarg(4, ctx, &data.fee);
-    bpf_usdt_readarg(5, ctx, &data.change_pos);
+    bpf_usdt_readarg(1, ctx, &data.fee_ret);
+    bpf_usdt_readarg(2, ctx, &data.fee_needed);
     coin_selection_events.push(&data, 0);
     return 0;
 }
@@ -99,7 +97,7 @@
 
 class CoinSelectionTracepointTest(BitcoinTestFramework):
     def add_options(self, parser):
-        self.add_wallet_options(parser)
+        pass
 
     def set_test_params(self):
         self.num_nodes = 1
@@ -165,9 +163,9 @@ def run_test(self):
         self.log.info("hook into the coin_selection tracepoints")
         ctx = USDT(pid=self.nodes[0].process.pid)
         ctx.enable_probe(probe="coin_selection:selected_coins", fn_name="trace_selected_coins")
-        ctx.enable_probe(probe="coin_selection:normal_create_tx_internal", fn_name="trace_normal_create_tx")
-        ctx.enable_probe(probe="coin_selection:attempting_aps_create_tx", fn_name="trace_attempt_aps")
-        ctx.enable_probe(probe="coin_selection:aps_create_tx_internal", fn_name="trace_aps_create_tx")
+        ctx.enable_probe(probe="coin_selection:coins_requested", fn_name="trace_coins_requested")
+        ctx.enable_probe(probe="coin_selection:change_info", fn_name="trace_change_info")
+        ctx.enable_probe(probe="coin_selection:fee_info", fn_name="trace_fee_info")
         self.bpf = BPF(text=coinselection_tracepoints_program, usdt_contexts=[ctx], debug=0)
 
         self.log.info("Prepare wallets")

test/functional/interface_usdt_mempool.py

@@ -16,15 +16,10 @@
 from test_framework.util import assert_equal, TAPYRUS_MODES
 from test_framework.timeout_config import TAPYRUSD_SYNC_TIMEOUT
 
-MEMPOOL_TRACEPOINTS_PROGRAM = """
+MEMPOOL_ADDED_PROGRAM = """
 # include <uapi/linux/ptrace.h>
 
-// The longest rejection reason is 118 chars and is generated in case of SCRIPT_ERR_EVAL_FALSE by
-// strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError()))
-#define MAX_REJECT_REASON_LENGTH        118
-// The longest string returned by RemovalReasonToString() is 'sizelimit'
-#define MAX_REMOVAL_REASON_LENGTH       9
-#define HASH_LENGTH                     32
+#define HASH_LENGTH 32
 
 struct added_event
 {
@@ -33,37 +28,7 @@
   s64   fee;
 };
 
-struct removed_event
-{
-  u8    hash[HASH_LENGTH];
-  char  reason[MAX_REMOVAL_REASON_LENGTH];
-  s32   vsize;
-  s64   fee;
-  u64   entry_time;
-};
-
-struct rejected_event
-{
-  u8    hash[HASH_LENGTH];
-  char  reason[MAX_REJECT_REASON_LENGTH];
-};
-
-struct replaced_event
-{
-  u8    replaced_hash[HASH_LENGTH];
-  s32   replaced_vsize;
-  s64   replaced_fee;
-  u64   replaced_entry_time;
-  u8    replacement_hash[HASH_LENGTH];
-  s32   replacement_vsize;
-  s64   replacement_fee;
-};
-
-// BPF perf buffer to push the data to user space.
 BPF_PERF_OUTPUT(added_events);
-BPF_PERF_OUTPUT(removed_events);
-BPF_PERF_OUTPUT(rejected_events);
-BPF_PERF_OUTPUT(replaced_events);
 
 int trace_added(struct pt_regs *ctx) {
   struct added_event added = {};
@@ -75,6 +40,24 @@
   added_events.perf_submit(ctx, &added, sizeof(added));
   return 0;
 }
+"""
+
+MEMPOOL_REMOVED_PROGRAM = """
+# include <uapi/linux/ptrace.h>
+
+#define MAX_REMOVAL_REASON_LENGTH 9
+#define HASH_LENGTH 32
+
+struct removed_event
+{
+  u8    hash[HASH_LENGTH];
+  char  reason[MAX_REMOVAL_REASON_LENGTH];
+  s32   vsize;
+  s64   fee;
+  u64   entry_time;
+};
+
+BPF_PERF_OUTPUT(removed_events);
 
 int trace_removed(struct pt_regs *ctx) {
   struct removed_event removed = {};
@@ -88,6 +71,21 @@
   removed_events.perf_submit(ctx, &removed, sizeof(removed));
   return 0;
 }
+"""
+
+MEMPOOL_REJECTED_PROGRAM = """
+# include <uapi/linux/ptrace.h>
+
+#define MAX_REJECT_REASON_LENGTH 118
+#define HASH_LENGTH 32
+
+struct rejected_event
+{
+  u8    hash[HASH_LENGTH];
+  char  reason[MAX_REJECT_REASON_LENGTH];
+};
+
+BPF_PERF_OUTPUT(rejected_events);
 
 int trace_rejected(struct pt_regs *ctx) {
   struct rejected_event rejected = {};
@@ -98,6 +96,25 @@
   rejected_events.perf_submit(ctx, &rejected, sizeof(rejected));
   return 0;
 }
+"""
+
+MEMPOOL_REPLACED_PROGRAM = """
+# include <uapi/linux/ptrace.h>
+
+#define HASH_LENGTH 32
+
+struct replaced_event
+{
+  u8    replaced_hash[HASH_LENGTH];
+  s32   replaced_vsize;
+  s64   replaced_fee;
+  u64   replaced_entry_time;
+  u8    replacement_hash[HASH_LENGTH];
+  s32   replacement_vsize;
+  s64   replacement_fee;
+};
+
+BPF_PERF_OUTPUT(replaced_events);
 
 int trace_replaced(struct pt_regs *ctx) {
   struct replaced_event replaced = {};
@@ -138,8 +155,8 @@ def added_test(self):
         self.log.info("Hooking into mempool:added tracepoint...")
         node = self.nodes[0]
         ctx = USDT(pid=node.process.pid)
-        ctx.enable_probe(probe="added", fn_name="trace_added")
-        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0)
+        ctx.enable_probe(probe="mempool:added", fn_name="trace_added")
+        bpf = BPF(text=MEMPOOL_ADDED_PROGRAM, usdt_contexts=[ctx], debug=0)
 
         def handle_added_event(_, data, __):
             nonlocal handled_added_events
@@ -179,8 +196,8 @@ def removed_test(self):
         self.log.info("Hooking into mempool:removed tracepoint...")
         node = self.nodes[0]
         ctx = USDT(pid=node.process.pid)
-        ctx.enable_probe(probe="removed", fn_name="trace_removed")
-        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0)
+        ctx.enable_probe(probe="mempool:removed", fn_name="trace_removed")
+        bpf = BPF(text=MEMPOOL_REMOVED_PROGRAM, usdt_contexts=[ctx], debug=0)
 
         def handle_removed_event(_, data, __):
             nonlocal handled_removed_events
@@ -229,8 +246,8 @@ def replaced_test(self):
         self.log.info("Hooking into mempool:replaced tracepoint...")
         node = self.nodes[0]
         ctx = USDT(pid=node.process.pid)
-        ctx.enable_probe(probe="replaced", fn_name="trace_replaced")
-        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0)
+        ctx.enable_probe(probe="mempool:replaced", fn_name="trace_replaced")
+        bpf = BPF(text=MEMPOOL_REPLACED_PROGRAM, usdt_contexts=[ctx], debug=0)
 
         def handle_replaced_event(_, data, __):
             nonlocal handled_replaced_events
@@ -285,8 +302,8 @@ def rejected_test(self):
 
         self.log.info("Hooking into mempool:rejected tracepoint...")
         ctx = USDT(pid=node.process.pid)
-        ctx.enable_probe(probe="rejected", fn_name="trace_rejected")
-        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0)
+        ctx.enable_probe(probe="mempool:rejected", fn_name="trace_rejected")
+        bpf = BPF(text=MEMPOOL_REJECTED_PROGRAM, usdt_contexts=[ctx], debug=0)
 
         def handle_rejected_event(_, data, __):
             nonlocal handled_rejected_events

test/functional/interface_usdt_net.py

@@ -103,9 +103,9 @@ def __repr__(self):
         self.log.info(
             "hook into the net:inbound_message and net:outbound_message tracepoints")
         ctx = USDT(pid=self.nodes[0].process.pid)
-        ctx.enable_probe(probe="inbound_message",
+        ctx.enable_probe(probe="net:inbound_message",
                          fn_name="trace_inbound_message")
-        ctx.enable_probe(probe="outbound_message",
+        ctx.enable_probe(probe="net:outbound_message",
                          fn_name="trace_outbound_message")
         bpf = BPF(text=net_tracepoints_program, usdt_contexts=[ctx], debug=1)