Inside Bitcoin

1#!/usr/bin/env python3
2# Copyright (c) 2022-present The Bitcoin Core developers
3# Distributed under the MIT software license, see the accompanying
4# file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6"""  Tests the mempool:* tracepoint API interface.
7     See https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#context-mempool
8"""
9
10import ctypes
11from decimal import Decimal
12
13# Test will be skipped if we don't have bcc installed
14try:
15    from bcc import BPF, USDT  # type: ignore[import]
16except ImportError:
17    pass
18
19from test_framework.blocktools import COINBASE_MATURITY
20from test_framework.messages import COIN, DEFAULT_MEMPOOL_EXPIRY_HOURS
21from test_framework.p2p import P2PDataStore
22from test_framework.test_framework import BitcoinTestFramework
23from test_framework.util import (
24    assert_equal,
25    bpf_cflags,
26)
27from test_framework.wallet import MiniWallet
28
29MEMPOOL_TRACEPOINTS_PROGRAM = """
30# include <uapi/linux/ptrace.h>
31
32// The longest rejection reason is 118 chars and is generated in case of SCRIPT_ERR_EVAL_FALSE by
33// strprintf("block-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError()))
34#define MAX_REJECT_REASON_LENGTH        118
35// The longest string returned by RemovalReasonToString() is 'sizelimit'
36#define MAX_REMOVAL_REASON_LENGTH       9
37#define HASH_LENGTH                     32
38
39struct added_event
40{
41  u8    hash[HASH_LENGTH];
42  s32   vsize;
43  s64   fee;
44};
45
46struct removed_event
47{
48  u8    hash[HASH_LENGTH];
49  char  reason[MAX_REMOVAL_REASON_LENGTH];
50  s32   vsize;
51  s64   fee;
52  u64   entry_time;
53};
54
55struct rejected_event
56{
57  u8    hash[HASH_LENGTH];
58  char  reason[MAX_REJECT_REASON_LENGTH];
59};
60
61struct replaced_event
62{
63  u8    replaced_hash[HASH_LENGTH];
64  s32   replaced_vsize;
65  s64   replaced_fee;
66  u64   replaced_entry_time;
67  u8    replacement_hash[HASH_LENGTH];
68  s32   replacement_vsize;
69  s64   replacement_fee;
70  bool  replaced_by_transaction;
71};
72
73// BPF perf buffer to push the data to user space.
74BPF_PERF_OUTPUT(added_events);
75BPF_PERF_OUTPUT(removed_events);
76BPF_PERF_OUTPUT(rejected_events);
77BPF_PERF_OUTPUT(replaced_events);
78
79int trace_added(struct pt_regs *ctx) {
80  struct added_event added = {};
81  void *phash = NULL;
82  bpf_usdt_readarg(1, ctx, &phash);
83  bpf_probe_read_user(&added.hash, sizeof(added.hash), phash);
84  bpf_usdt_readarg(2, ctx, &added.vsize);
85  bpf_usdt_readarg(3, ctx, &added.fee);
86
87  added_events.perf_submit(ctx, &added, sizeof(added));
88  return 0;
89}
90
91int trace_removed(struct pt_regs *ctx) {
92  struct removed_event removed = {};
93  void *phash = NULL, *preason = NULL;
94  bpf_usdt_readarg(1, ctx, &phash);
95  bpf_probe_read_user(&removed.hash, sizeof(removed.hash), phash);
96  bpf_usdt_readarg(2, ctx, &preason);
97  bpf_probe_read_user_str(&removed.reason, sizeof(removed.reason), preason);
98  bpf_usdt_readarg(3, ctx, &removed.vsize);
99  bpf_usdt_readarg(4, ctx, &removed.fee);
100  bpf_usdt_readarg(5, ctx, &removed.entry_time);
101
102  removed_events.perf_submit(ctx, &removed, sizeof(removed));
103  return 0;
104}
105
106int trace_rejected(struct pt_regs *ctx) {
107  struct rejected_event rejected = {};
108  void *phash = NULL, *preason = NULL;
109  bpf_usdt_readarg(1, ctx, &phash);
110  bpf_probe_read_user(&rejected.hash, sizeof(rejected.hash), phash);
111  bpf_usdt_readarg(2, ctx, &preason);
112  bpf_probe_read_user_str(&rejected.reason, sizeof(rejected.reason), preason);
113  rejected_events.perf_submit(ctx, &rejected, sizeof(rejected));
114  return 0;
115}
116
117int trace_replaced(struct pt_regs *ctx) {
118  struct replaced_event replaced = {};
119  void *preplaced_hash = NULL, *preplacement_hash = NULL;
120  bpf_usdt_readarg(1, ctx, &preplaced_hash);
121  bpf_probe_read_user(&replaced.replaced_hash, sizeof(replaced.replaced_hash), preplaced_hash);
122  bpf_usdt_readarg(2, ctx, &replaced.replaced_vsize);
123  bpf_usdt_readarg(3, ctx, &replaced.replaced_fee);
124  bpf_usdt_readarg(4, ctx, &replaced.replaced_entry_time);
125  bpf_usdt_readarg(5, ctx, &preplacement_hash);
126  bpf_probe_read_user(&replaced.replacement_hash, sizeof(replaced.replacement_hash), preplacement_hash);
127  bpf_usdt_readarg(6, ctx, &replaced.replacement_vsize);
128  bpf_usdt_readarg(7, ctx, &replaced.replacement_fee);
129  bpf_usdt_readarg(8, ctx, &replaced.replaced_by_transaction);
130
131  replaced_events.perf_submit(ctx, &replaced, sizeof(replaced));
132  return 0;
133}
134
135"""
136
137
138class MempoolReplaced(ctypes.Structure):
139    _fields_ = [
140        ("replaced_hash", ctypes.c_ubyte * 32),
141        ("replaced_vsize", ctypes.c_int32),
142        ("replaced_fee", ctypes.c_int64),
143        ("replaced_entry_time", ctypes.c_uint64),
144        ("replacement_hash", ctypes.c_ubyte * 32),
145        ("replacement_vsize", ctypes.c_int32),
146        ("replacement_fee", ctypes.c_int64),
147        ("replaced_by_transaction", ctypes.c_bool),
148    ]
149
150
151class MempoolTracepointTest(BitcoinTestFramework):
152    def set_test_params(self):
153        self.num_nodes = 1
154        self.setup_clean_chain = True
155
156    def skip_test_if_missing_module(self):
157        self.skip_if_platform_not_linux()
158        self.skip_if_no_bitcoind_tracepoints()
159        self.skip_if_no_python_bcc()
160        self.skip_if_no_bpf_permissions()
161        self.skip_if_running_under_valgrind()
162
163    def added_test(self):
164        """Add a transaction to the mempool and make sure the tracepoint returns
165        the expected txid, vsize, and fee."""
166
167        events = []
168
169        self.log.info("Hooking into mempool:added tracepoint...")
170        node = self.nodes[0]
171        ctx = USDT(pid=node.process.pid)
172        ctx.enable_probe(probe="mempool:added", fn_name="trace_added")
173        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=bpf_cflags())
174
175        def handle_added_event(_, data, __):
176            events.append(bpf["added_events"].event(data))
177
178        bpf["added_events"].open_perf_buffer(handle_added_event)
179
180        self.log.info("Sending transaction...")
181        fee = Decimal(31200)
182        tx = self.wallet.send_self_transfer(from_node=node, fee=fee / COIN)
183
184        self.log.info("Polling buffer...")
185        bpf.perf_buffer_poll(timeout=200)
186
187        self.log.info("Cleaning up mempool...")
188        self.generate(node, 1)
189
190        self.log.info("Ensuring mempool:added event was handled successfully...")
191        assert_equal(1, len(events))
192        event = events[0]
193        assert_equal(bytes(event.hash)[::-1].hex(), tx["txid"])
194        assert_equal(event.vsize, tx["tx"].get_vsize())
195        assert_equal(event.fee, fee)
196
197        bpf.cleanup()
198        self.generate(self.wallet, 1)
199
200    def removed_test(self):
201        """Expire a transaction from the mempool and make sure the tracepoint returns
202        the expected txid, expiry reason, vsize, and fee."""
203
204        events = []
205
206        self.log.info("Hooking into mempool:removed tracepoint...")
207        node = self.nodes[0]
208        ctx = USDT(pid=node.process.pid)
209        ctx.enable_probe(probe="mempool:removed", fn_name="trace_removed")
210        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=bpf_cflags())
211
212        def handle_removed_event(_, data, __):
213            events.append(bpf["removed_events"].event(data))
214
215        bpf["removed_events"].open_perf_buffer(handle_removed_event)
216
217        self.log.info("Sending transaction...")
218        fee = Decimal(31200)
219        tx = self.wallet.send_self_transfer(from_node=node, fee=fee / COIN)
220        txid = tx["txid"]
221
222        self.log.info("Fast-forwarding time to mempool expiry...")
223        entry_time = node.getmempoolentry(txid)["time"]
224        expiry_time = entry_time + 60 * 60 * DEFAULT_MEMPOOL_EXPIRY_HOURS + 5
225        node.setmocktime(expiry_time)
226
227        self.log.info("Triggering expiry...")
228        self.wallet.get_utxo(txid=txid)
229        self.wallet.send_self_transfer(from_node=node)
230
231        self.log.info("Polling buffer...")
232        bpf.perf_buffer_poll(timeout=200)
233
234        self.log.info("Ensuring mempool:removed event was handled successfully...")
235        assert_equal(1, len(events))
236        event = events[0]
237        assert_equal(bytes(event.hash)[::-1].hex(), txid)
238        assert_equal(event.reason.decode("UTF-8"), "expiry")
239        assert_equal(event.vsize, tx["tx"].get_vsize())
240        assert_equal(event.fee, fee)
241        assert_equal(event.entry_time, entry_time)
242
243        bpf.cleanup()
244        self.generate(self.wallet, 1)
245
246    def replaced_test(self):
247        """Replace one and two transactions in the mempool and make sure the tracepoint
248        returns the expected txids, vsizes, and fees."""
249
250        events = []