@samitouri / QOSamiQemu / commits / 7e7480d7c7

migration/rdma: Stick with rdma_ prefix for all tracepoints

There're a bunch of RDMA tracepoints that are prefixed with "rdma_*", most of the rest with "qemu_rdma_*". Align them up. The "qemu_" prefix isn't helping. Reviewed-by: Jinpu Wang <jinpu.wang@cloud.ionos.com> Signed-off-by: Peter Xu <peterx@redhat.com> Signed-off-by: Fabiano Rosas <farosas@suse.de>

Peter Xu committed Aug 20, 2026 at 16:03 UTC 7e7480d7c7bfebb4bcde84a9d8d4153817992e8f

2 files changed +74 -74

migration/rdma.c

+38 -38

@@ -631,7 +631,7 @@ static void qemu_rdma_init_ram_blocks(RDMAContext *rdma)

631 memset(local, 0, sizeof *local);

632 ret = foreach_not_ignored_block(qemu_rdma_init_one_block, rdma);

633 assert(!ret);

634 - trace_qemu_rdma_init_ram_blocks(local->nb_blocks);

634 + trace_rdma_init_ram_blocks(local->nb_blocks);

635 rdma->dest_blocks = g_new0(RDMADestBlock,

636 rdma->local_ram_blocks.nb_blocks);

637 local->init = true;

@@ -734,11 +734,11 @@ static void qemu_rdma_dump_id(const char *who, struct ibv_context *verbs)

734 struct ibv_port_attr port;

735

736 if (ibv_query_port(verbs, 1, &port)) {

737 - trace_qemu_rdma_dump_id_failed(who);

737 + trace_rdma_dump_id_failed(who);

738 return;

739 }

740

741 - trace_qemu_rdma_dump_id(who,

741 + trace_rdma_dump_id(who,

742 verbs->device->name,

743 verbs->device->dev_name,

744 verbs->device->dev_path,

@@ -759,7 +759,7 @@ static void qemu_rdma_dump_gid(const char *who, struct rdma_cm_id *id)

759 char dgid[33];

760 inet_ntop(AF_INET6, &id->route.addr.addr.ibaddr.sgid, sgid, sizeof sgid);

761 inet_ntop(AF_INET6, &id->route.addr.addr.ibaddr.dgid, dgid, sizeof dgid);

762 - trace_qemu_rdma_dump_gid(who, sgid, dgid);

762 + trace_rdma_dump_gid(who, sgid, dgid);

763 }

764

765 /*

@@ -809,7 +809,7 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp)

809

810 inet_ntop(e->ai_family,

811 &((struct sockaddr_in *) e->ai_dst_addr)->sin_addr, ip, sizeof ip);

812 - trace_qemu_rdma_resolve_host_trying(rdma->host, ip);

812 + trace_rdma_resolve_host_trying(rdma->host, ip);

813

814 ret = rdma_resolve_addr(rdma->cm_id, NULL, e->ai_dst_addr,

815 RDMA_RESOLVE_TIMEOUT_MS);

@@ -998,7 +998,7 @@ static void qemu_rdma_advise_prefetch_mr(struct ibv_pd *pd, uint64_t addr,

998 ret = ibv_advise_mr(pd, advice,

999 IBV_ADVISE_MR_FLAG_FLUSH, &sg_list, 1);

1000 /* ignore the error */

1001 - trace_qemu_rdma_advise_mr(name, len, addr, strerror(ret));

1001 + trace_rdma_advise_mr(name, len, addr, strerror(ret));

1002 #endif

1003 }

1004

@@ -1029,7 +1029,7 @@ static int qemu_rdma_reg_whole_ram_blocks(RDMAContext *rdma, Error **errp)

1029 ibv_reg_mr(rdma->pd,

1030 local->block[i].local_host_addr,

1031 local->block[i].length, access);

1032 - trace_qemu_rdma_register_odp_mr(local->block[i].block_name);

1032 + trace_rdma_register_odp_mr(local->block[i].block_name);

1033

1034 if (local->block[i].mr) {

1035 qemu_rdma_advise_prefetch_mr(rdma->pd,

@@ -1125,7 +1125,7 @@ static int qemu_rdma_register_and_get_keys(RDMAContext *rdma,

1125 int access = rkey ? IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE :

1126 0;

1127

1128 - trace_qemu_rdma_register_and_get_keys(len, chunk_start);

1128 + trace_rdma_register_and_get_keys(len, chunk_start);

1129

1130 block->pmr[chunk] = ibv_reg_mr(rdma->pd, chunk_start, len, access);

1131 /*

@@ -1139,7 +1139,7 @@ static int qemu_rdma_register_and_get_keys(RDMAContext *rdma,

1139 access |= IBV_ACCESS_ON_DEMAND;

1140 /* register ODP mr */

1141 block->pmr[chunk] = ibv_reg_mr(rdma->pd, chunk_start, len, access);

1142 - trace_qemu_rdma_register_odp_mr(block->block_name);

1142 + trace_rdma_register_odp_mr(block->block_name);

1143

1144 if (block->pmr[chunk]) {

1145 qemu_rdma_advise_prefetch_mr(rdma->pd, (uintptr_t)chunk_start,

@@ -1221,7 +1221,7 @@ static int qemu_rdma_poll(RDMAContext *rdma, struct ibv_cq *cq,

1221

1222 if (rdma->control_ready_expected &&

1223 (wr_id >= RDMA_WRID_RECV_CONTROL)) {

1224 - trace_qemu_rdma_poll_recv(wr_id - RDMA_WRID_RECV_CONTROL, wr_id,

1224 + trace_rdma_poll_recv(wr_id - RDMA_WRID_RECV_CONTROL, wr_id,

1225 rdma->nb_sent);

1226 rdma->control_ready_expected = 0;

1227 }

@@ -1233,7 +1233,7 @@ static int qemu_rdma_poll(RDMAContext *rdma, struct ibv_cq *cq,

1233 (wc.wr_id & RDMA_WRID_BLOCK_MASK) >> RDMA_WRID_BLOCK_SHIFT;

1234 RDMALocalBlock *block = &(rdma->local_ram_blocks.block[index]);

1235

1236 - trace_qemu_rdma_poll_write(wr_id, rdma->nb_sent,

1236 + trace_rdma_poll_write(wr_id, rdma->nb_sent,

1237 index, chunk, block->local_host_addr,

1238 (void *)(uintptr_t)block->remote_host_addr);

1239

@@ -1243,7 +1243,7 @@ static int qemu_rdma_poll(RDMAContext *rdma, struct ibv_cq *cq,

1243 rdma->nb_sent--;

1244 }

1245 } else {

1246 - trace_qemu_rdma_poll_other(wr_id, rdma->nb_sent);

1246 + trace_rdma_poll_other(wr_id, rdma->nb_sent);

1247 }

1248

1249 *wr_id_out = wc.wr_id;

@@ -1378,7 +1378,7 @@ static int qemu_rdma_block_for_wrid(RDMAContext *rdma,

1378 break;

1379 }

1380 if (wr_id != wrid_requested) {

1381 - trace_qemu_rdma_block_for_wrid_miss(wrid_requested, wr_id);

1381 + trace_rdma_block_for_wrid_miss(wrid_requested, wr_id);

1382 }

1383 }

1384

@@ -1415,7 +1415,7 @@ static int qemu_rdma_block_for_wrid(RDMAContext *rdma,

1415 break;

1416 }

1417 if (wr_id != wrid_requested) {

1418 - trace_qemu_rdma_block_for_wrid_miss(wrid_requested, wr_id);

1418 + trace_rdma_block_for_wrid_miss(wrid_requested, wr_id);

1419 }

1420 }

1421

@@ -1463,7 +1463,7 @@ static int qemu_rdma_post_send_control(RDMAContext *rdma, uint8_t *buf,

1463 .num_sge = 1,

1464 };

1465

1466 - trace_qemu_rdma_post_send_control(control_desc(head->type));

1466 + trace_rdma_post_send_control(control_desc(head->type));

1467

1468 /*

1469 * We don't actually need to do a memcpy() in here if we used

@@ -1546,10 +1546,10 @@ static int qemu_rdma_exchange_get_response(RDMAContext *rdma,

1546 network_to_control((void *) rdma->wr_data[idx].control);

1547 memcpy(head, rdma->wr_data[idx].control, sizeof(RDMAControlHeader));

1548

1549 - trace_qemu_rdma_exchange_get_response_start(control_desc(expecting));

1549 + trace_rdma_exchange_get_response_start(control_desc(expecting));

1550

1551 if (expecting == RDMA_CONTROL_NONE) {

1552 - trace_qemu_rdma_exchange_get_response_none(control_desc(head->type),

1552 + trace_rdma_exchange_get_response_none(control_desc(head->type),

1553 head->type);

1554 } else if (head->type != expecting || head->type == RDMA_CONTROL_ERROR) {

1555 error_setg(errp, "Was expecting a %s (%d) control message"

@@ -1659,14 +1659,14 @@ static int qemu_rdma_exchange_send(RDMAContext *rdma, RDMAControlHeader *head,

1659 */

1660 if (resp) {

1661 if (callback) {

1662 - trace_qemu_rdma_exchange_send_issue_callback();

1662 + trace_rdma_exchange_send_issue_callback();

1663 ret = callback(rdma, errp);

1664 if (ret < 0) {

1665 return -1;

1666 }

1667 }

1668

1669 - trace_qemu_rdma_exchange_send_waiting(control_desc(resp->type));

1669 + trace_rdma_exchange_send_waiting(control_desc(resp->type));

1670 ret = qemu_rdma_exchange_get_response(rdma, resp,

1671 resp->type, RDMA_WRID_DATA,

1672 errp);

@@ -1679,7 +1679,7 @@ static int qemu_rdma_exchange_send(RDMAContext *rdma, RDMAControlHeader *head,

1679 if (resp_idx) {

1680 *resp_idx = RDMA_WRID_DATA;

1681 }

1682 - trace_qemu_rdma_exchange_send_received(control_desc(resp->type));

1682 + trace_rdma_exchange_send_received(control_desc(resp->type));

1683 }

1684

1685 rdma->control_ready_expected = 1;

@@ -1782,7 +1782,7 @@ retry:

1782 }

1783 }

1784

1785 - trace_qemu_rdma_write_one_top(chunks + 1,

1785 + trace_rdma_write_one_top(chunks + 1,

1786 (chunks + 1) * chunk_size / 1024 / 1024);

1787

1788 chunk_end = ram_chunk_end(block, chunk + chunks);

@@ -1790,7 +1790,7 @@ retry:

1790

1791 while (test_bit(chunk, block->transit_bitmap)) {

1792 (void)count;

1793 - trace_qemu_rdma_write_one_block(count++, current_index, chunk,

1793 + trace_rdma_write_one_block(count++, current_index, chunk,

1794 sge.addr, length, rdma->nb_sent, block->nb_chunks);

1795

1796 ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE, NULL);

@@ -1823,7 +1823,7 @@ retry:

1823 head.len = sizeof(comp);

1824 head.type = RDMA_CONTROL_COMPRESS;

1825

1826 - trace_qemu_rdma_write_one_zero(chunk, sge.length,

1826 + trace_rdma_write_one_zero(chunk, sge.length,

1827 current_index, current_addr);

1828

1829 compress_to_network(rdma, &comp);

@@ -1860,7 +1860,7 @@ retry:

1860 }

1861 reg.chunks = chunks;

1862

1863 - trace_qemu_rdma_write_one_sendreg(chunk, sge.length, current_index,

1863 + trace_rdma_write_one_sendreg(chunk, sge.length, current_index,

1864 current_addr);

1865

1866 register_to_network(rdma, &reg);

@@ -1883,7 +1883,7 @@ retry:

1883

1884 network_to_result(reg_result);

1885

1886 - trace_qemu_rdma_write_one_recvregres(block->remote_keys[chunk],

1886 + trace_rdma_write_one_recvregres(block->remote_keys[chunk],

1887 reg_result->rkey, chunk);

1888

1889 block->remote_keys[chunk] = reg_result->rkey;

@@ -1926,7 +1926,7 @@ retry:

1926 send_wr.wr.rdma.remote_addr = block->remote_host_addr +

1927 (current_addr - block->offset);

1928

1929 - trace_qemu_rdma_write_one_post(chunk, sge.addr, send_wr.wr.rdma.remote_addr,

1929 + trace_rdma_write_one_post(chunk, sge.addr, send_wr.wr.rdma.remote_addr,

1930 sge.length);

1931

1932 /*

@@ -1936,7 +1936,7 @@ retry:

1936 ret = ibv_post_send(rdma->qp, &send_wr, &bad_wr);

1937

1938 if (ret == ENOMEM) {

1939 - trace_qemu_rdma_write_one_queue_full();

1939 + trace_rdma_write_one_queue_full();

1940 ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE, NULL);

1941 if (ret < 0) {

1942 error_setg(errp, "rdma migration: failed to make "

@@ -1993,7 +1993,7 @@ static int qemu_rdma_write_flush(RDMAContext *rdma, Error **errp)

1993

1994 if (ret == 0) {

1995 rdma->nb_sent++;

1996 - trace_qemu_rdma_write_flush(rdma->nb_sent);

1996 + trace_rdma_write_flush(rdma->nb_sent);

1997 }

1998

1999 rdma->current_length = 0;

@@ -2109,7 +2109,7 @@ static void qemu_rdma_cleanup(RDMAContext *rdma)

2109 }

2110

2111 rdma_disconnect(rdma->cm_id);

2112 - trace_qemu_rdma_cleanup_disconnect();

2112 + trace_rdma_cleanup_disconnect();

2113 rdma->connected = false;

2114 }

2115

@@ -2292,7 +2292,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, bool return_path,

2292 * on the source first requested the capability.

2293 */

2294 if (rdma->pin_all) {

2295 - trace_qemu_rdma_connect_pin_all_requested();

2295 + trace_rdma_connect_pin_all_requested();

2296 cap.flags |= RDMA_CAPABILITY_PIN_ALL;

2297 }

2298

@@ -2343,7 +2343,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, bool return_path,

2343 rdma->pin_all = false;

2344 }

2345

2346 - trace_qemu_rdma_connect_pin_all_outcome(rdma->pin_all);

2346 + trace_rdma_connect_pin_all_outcome(rdma->pin_all);

2347

2348 rdma_ack_cm_event(cm_event);

2349

@@ -2412,7 +2412,7 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp)

2412

2413 inet_ntop(e->ai_family,

2414 &((struct sockaddr_in *) e->ai_dst_addr)->sin_addr, ip, sizeof ip);

2415 - trace_qemu_rdma_dest_init_trying(rdma->host, ip);

2415 + trace_rdma_dest_init_trying(rdma->host, ip);

2416 ret = rdma_bind_addr(listen_id, e->ai_dst_addr);

2417 if (ret < 0) {

2418 continue;

@@ -2547,7 +2547,7 @@ static size_t qemu_rdma_fill(RDMAContext *rdma, uint8_t *buf,

2547 size_t len = 0;

2548

2549 if (rdma->wr_data[idx].control_len) {

2550 - trace_qemu_rdma_fill(rdma->wr_data[idx].control_len, size);

2550 + trace_rdma_fill(rdma->wr_data[idx].control_len, size);

2551

2552 len = MIN(size, rdma->wr_data[idx].control_len);

2553 memcpy(buf, rdma->wr_data[idx].control_curr, len);

@@ -2859,7 +2859,7 @@ static int qio_channel_rdma_close(QIOChannel *ioc,

2859 RDMAContext *rdmain, *rdmaout;

2860 struct rdma_close_rcu *rcu = g_new(struct rdma_close_rcu, 1);

2861

2862 - trace_qemu_rdma_close();

2862 + trace_rdma_close();

2863

2864 rdmain = rioc->rdmain;

2865 if (rdmain) {

@@ -3132,11 +3132,11 @@ static int qemu_rdma_accept(RDMAContext *rdma)

3132

3133 rdma_ack_cm_event(cm_event);

3134

3135 - trace_qemu_rdma_accept_pin_state(rdma->pin_all);

3135 + trace_rdma_accept_pin_state(rdma->pin_all);

3136

3137 caps_to_network(&cap);

3138

3139 - trace_qemu_rdma_accept_pin_verbsc(verbs);

3139 + trace_rdma_accept_pin_verbsc(verbs);

3140

3141 if (!rdma->verbs) {

3142 rdma->verbs = verbs;

@@ -3727,13 +3727,13 @@ static void rdma_accept_incoming_migration(void *opaque)

3727 RDMAContext *rdma = opaque;

3728 QIOChannel *ioc;

3729

3730 - trace_qemu_rdma_accept_incoming_migration();

3730 + trace_rdma_accept_incoming_migration();

3731 if (qemu_rdma_accept(rdma) < 0) {

3732 error_report("RDMA ERROR: Migration initialization failed");

3733 return;

3734 }

3735

3736 - trace_qemu_rdma_accept_incoming_migration_accepted();

3736 + trace_rdma_accept_incoming_migration_accepted();

3737

3738 if (rdma->is_return_path) {

3739 return;

migration/trace-events

+36 -36

@@ -214,42 +214,42 @@ migrate_global_state_post_load(const char *state) "loaded state: %s"

214 migrate_global_state_pre_save(const char *state) "saved state: %s"

215

216 # rdma.c

217 -qemu_rdma_accept_incoming_migration(void) ""

218 -qemu_rdma_accept_incoming_migration_accepted(void) ""

219 -qemu_rdma_accept_pin_state(bool pin) "%d"

220 -qemu_rdma_accept_pin_verbsc(void *verbs) "Verbs context after listen: %p"

221 -qemu_rdma_block_for_wrid_miss(uint64_t wcomp, uint64_t req) "A Wanted wrid %" PRIu64 " but got %" PRIu64

222 -qemu_rdma_cleanup_disconnect(void) ""

223 -qemu_rdma_close(void) ""

224 -qemu_rdma_connect_pin_all_requested(void) ""

225 -qemu_rdma_connect_pin_all_outcome(bool pin) "%d"

226 -qemu_rdma_dest_init_trying(const char *host, const char *ip) "%s => %s"

227 -qemu_rdma_dump_id_failed(const char *who) "%s RDMA Device opened, but can't query port information"

228 -qemu_rdma_dump_id(const char *who, const char *name, const char *dev_name, const char *dev_path, const char *ibdev_path, int transport, const char *transport_name) "%s RDMA Device opened: kernel name %s uverbs device name %s, infiniband_verbs class device path %s, infiniband class device path %s, transport: (%d) %s"

229 -qemu_rdma_dump_gid(const char *who, const char *src, const char *dst) "%s Source GID: %s, Dest GID: %s"

230 -qemu_rdma_exchange_get_response_start(const char *desc) "CONTROL: %s receiving..."

231 -qemu_rdma_exchange_get_response_none(const char *desc, int type) "Surprise: got %s (%d)"

232 -qemu_rdma_exchange_send_issue_callback(void) ""

233 -qemu_rdma_exchange_send_waiting(const char *desc) "Waiting for response %s"

234 -qemu_rdma_exchange_send_received(const char *desc) "Response %s received."

235 -qemu_rdma_fill(size_t control_len, size_t size) "RDMA %zd of %zd bytes already in buffer"

236 -qemu_rdma_init_ram_blocks(int blocks) "Allocated %d local ram block structures"

237 -qemu_rdma_poll_recv(uint64_t comp, int64_t id, int sent) "completion %" PRIu64 " received (%" PRId64 ") left %d"

238 -qemu_rdma_poll_write(uint64_t comp, int left, uint64_t block, uint64_t chunk, void *local, void *remote) "completions %" PRIu64 " left %d, block %" PRIu64 ", chunk: %" PRIu64 " %p %p"

239 -qemu_rdma_poll_other(uint64_t comp, int left) "other completion %" PRIu64 " received left %d"

240 -qemu_rdma_post_send_control(const char *desc) "CONTROL: sending %s.."

241 -qemu_rdma_register_and_get_keys(uint64_t len, void *start) "Registering %" PRIu64 " bytes @ %p"

242 -qemu_rdma_register_odp_mr(const char *name) "Try to register On-Demand Paging memory region: %s"

243 -qemu_rdma_advise_mr(const char *name, uint32_t len, uint64_t addr, const char *res) "Try to advise block %s prefetch at %" PRIu32 "@0x%" PRIx64 ": %s"

244 -qemu_rdma_resolve_host_trying(const char *host, const char *ip) "Trying %s => %s"

245 -qemu_rdma_write_flush(int sent) "sent total: %d"

246 -qemu_rdma_write_one_block(int count, int block, uint64_t chunk, uint64_t current, uint64_t len, int nb_sent, int nb_chunks) "(%d) Not clobbering: block: %d chunk %" PRIu64 " current %" PRIu64 " len %" PRIu64 " %d %d"

247 -qemu_rdma_write_one_post(uint64_t chunk, long addr, long remote, uint32_t len) "Posting chunk: %" PRIu64 ", addr: 0x%lx remote: 0x%lx, bytes %" PRIu32

248 -qemu_rdma_write_one_queue_full(void) ""

249 -qemu_rdma_write_one_recvregres(int mykey, int theirkey, uint64_t chunk) "Received registration result: my key: 0x%x their key 0x%x, chunk %" PRIu64

250 -qemu_rdma_write_one_sendreg(uint64_t chunk, int len, int index, int64_t offset) "Sending registration request chunk %" PRIu64 " for %d bytes, index: %d, offset: %" PRId64

251 -qemu_rdma_write_one_top(uint64_t chunks, uint64_t size) "Writing %" PRIu64 " chunks, (%" PRIu64 " MB)"

252 -qemu_rdma_write_one_zero(uint64_t chunk, int len, int index, int64_t offset) "Entire chunk is zero, sending compress: %" PRIu64 " for %d bytes, index: %d, offset: %" PRId64

217 +rdma_accept_incoming_migration(void) ""

218 +rdma_accept_incoming_migration_accepted(void) ""

219 +rdma_accept_pin_state(bool pin) "%d"

220 +rdma_accept_pin_verbsc(void *verbs) "Verbs context after listen: %p"

221 +rdma_block_for_wrid_miss(uint64_t wcomp, uint64_t req) "A Wanted wrid %" PRIu64 " but got %" PRIu64

222 +rdma_cleanup_disconnect(void) ""

223 +rdma_close(void) ""

224 +rdma_connect_pin_all_requested(void) ""

225 +rdma_connect_pin_all_outcome(bool pin) "%d"

226 +rdma_dest_init_trying(const char *host, const char *ip) "%s => %s"

227 +rdma_dump_id_failed(const char *who) "%s RDMA Device opened, but can't query port information"

228 +rdma_dump_id(const char *who, const char *name, const char *dev_name, const char *dev_path, const char *ibdev_path, int transport, const char *transport_name) "%s RDMA Device opened: kernel name %s uverbs device name %s, infiniband_verbs class device path %s, infiniband class device path %s, transport: (%d) %s"

229 +rdma_dump_gid(const char *who, const char *src, const char *dst) "%s Source GID: %s, Dest GID: %s"

230 +rdma_exchange_get_response_start(const char *desc) "CONTROL: %s receiving..."

231 +rdma_exchange_get_response_none(const char *desc, int type) "Surprise: got %s (%d)"

232 +rdma_exchange_send_issue_callback(void) ""

233 +rdma_exchange_send_waiting(const char *desc) "Waiting for response %s"

234 +rdma_exchange_send_received(const char *desc) "Response %s received."

235 +rdma_fill(size_t control_len, size_t size) "RDMA %zd of %zd bytes already in buffer"

236 +rdma_init_ram_blocks(int blocks) "Allocated %d local ram block structures"

237 +rdma_poll_recv(uint64_t comp, int64_t id, int sent) "completion %" PRIu64 " received (%" PRId64 ") left %d"

238 +rdma_poll_write(uint64_t comp, int left, uint64_t block, uint64_t chunk, void *local, void *remote) "completions %" PRIu64 " left %d, block %" PRIu64 ", chunk: %" PRIu64 " %p %p"

239 +rdma_poll_other(uint64_t comp, int left) "other completion %" PRIu64 " received left %d"

240 +rdma_post_send_control(const char *desc) "CONTROL: sending %s.."

241 +rdma_register_and_get_keys(uint64_t len, void *start) "Registering %" PRIu64 " bytes @ %p"

242 +rdma_register_odp_mr(const char *name) "Try to register On-Demand Paging memory region: %s"

243 +rdma_advise_mr(const char *name, uint32_t len, uint64_t addr, const char *res) "Try to advise block %s prefetch at %" PRIu32 "@0x%" PRIx64 ": %s"

244 +rdma_resolve_host_trying(const char *host, const char *ip) "Trying %s => %s"

245 +rdma_write_flush(int sent) "sent total: %d"

246 +rdma_write_one_block(int count, int block, uint64_t chunk, uint64_t current, uint64_t len, int nb_sent, int nb_chunks) "(%d) Not clobbering: block: %d chunk %" PRIu64 " current %" PRIu64 " len %" PRIu64 " %d %d"

247 +rdma_write_one_post(uint64_t chunk, long addr, long remote, uint32_t len) "Posting chunk: %" PRIu64 ", addr: 0x%lx remote: 0x%lx, bytes %" PRIu32

248 +rdma_write_one_queue_full(void) ""

249 +rdma_write_one_recvregres(int mykey, int theirkey, uint64_t chunk) "Received registration result: my key: 0x%x their key 0x%x, chunk %" PRIu64

250 +rdma_write_one_sendreg(uint64_t chunk, int len, int index, int64_t offset) "Sending registration request chunk %" PRIu64 " for %d bytes, index: %d, offset: %" PRId64

251 +rdma_write_one_top(uint64_t chunks, uint64_t size) "Writing %" PRIu64 " chunks, (%" PRIu64 " MB)"

252 +rdma_write_one_zero(uint64_t chunk, int len, int index, int64_t offset) "Entire chunk is zero, sending compress: %" PRIu64 " for %d bytes, index: %d, offset: %" PRId64

253 rdma_add_block(const char *block_name, int block, uint64_t addr, uint64_t offset, uint64_t len, uint64_t end, uint64_t bits, int chunks) "Added Block: '%s':%d, addr: %" PRIu64 ", offset: %" PRIu64 " length: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d"

254 rdma_block_notification_handle(const char *name, int index) "%s at %d"

255 rdma_delete_block(void *block, uint64_t addr, uint64_t offset, uint64_t len, uint64_t end, uint64_t bits, int chunks) "Deleted Block: %p, addr: %" PRIu64 ", offset: %" PRIu64 " length: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d"