Skip to content

prov/efa: Remove handshake requirement for DC #12169

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
a-szegel merged 3 commits into from
Apr 27, 2026
Merged

prov/efa: Remove handshake requirement for DC #12169

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
bca7ba5
prov/efa: Remove handshake requirement for DC
sunkuamzn Apr 18, 2026
dd335e0
prov/efa/docs: Update docs to remove handshake for DC
sunkuamzn Apr 22, 2026
b7b21ff
fabtests/efa: Add new runting read functional test
sunkuamzn Apr 24, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
21 changes: 0 additions & 21 deletions prov/efa/src/rdm/efa_rdm_atomic.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -103,27 +103,6 @@ ssize_t efa_rdm_atomic_post_atomic(struct efa_rdm_ep *efa_rdm_ep, struct efa_rdm
};

delivery_complete_requested = txe->fi_flags & FI_DELIVERY_COMPLETE;
if (delivery_complete_requested && !(txe->peer->is_local)) {
/*
* Because delivery complete is defined as an extra
* feature, the receiver might not support it.
* The sender cannot send with FI_DELIVERY_COMPLETE
* if the peer is not able to handle it.
* If the sender does not know whether the peer
* can handle it, it needs to trigger
* a handshake packet from the peer.
* The handshake packet contains
* the information whether the peer
* support it or not.
*/
if (!efa_rdm_ep->homogeneous_peers) {
if (!(txe->peer->flags & EFA_RDM_PEER_HANDSHAKE_RECEIVED))
return efa_rdm_ep_enforce_handshake_for_txe(efa_rdm_ep, txe);

if (!(txe->peer->is_self) && !efa_rdm_peer_support_delivery_complete(txe->peer))
return -FI_EOPNOTSUPP;
}
}

if (delivery_complete_requested && txe->op == ofi_op_atomic) {
return efa_rdm_ope_post_send(txe, EFA_RDM_DC_WRITE_RTA_PKT);
Expand Down
7 changes: 5 additions & 2 deletions prov/efa/src/rdm/efa_rdm_msg.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -146,8 +146,11 @@ ssize_t efa_rdm_msg_post_rtm(struct efa_rdm_ep *ep, struct efa_rdm_ope *txe)
*
* Check handshake packet from peer to verify support status.
*/
if (!ep->homogeneous_peers && !(txe->peer->flags & EFA_RDM_PEER_HANDSHAKE_RECEIVED))
return efa_rdm_ep_enforce_handshake_for_txe(ep, txe);
if (!ep->homogeneous_peers && !(txe->peer->flags & EFA_RDM_PEER_HANDSHAKE_RECEIVED)) {
int ex_feature = EFA_RDM_PKT_TYPE_REQ_INFO_VEC[rtm_type].ex_feature_flag;
if (ex_feature)
return efa_rdm_ep_enforce_handshake_for_txe(ep, txe);
}

if (!ep->homogeneous_peers && !efa_rdm_pkt_type_is_supported_by_peer(rtm_type, txe->peer))
return -FI_EOPNOTSUPP;
Expand Down
13 changes: 0 additions & 13 deletions prov/efa/src/rdm/efa_rdm_peer.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -176,19 +176,6 @@ bool efa_rdm_peer_support_unsolicited_write_recv(struct efa_rdm_peer *peer)
(peer->extra_info[0] & EFA_RDM_EXTRA_FEATURE_UNSOLICITED_WRITE_RECV);
}

static inline
bool efa_rdm_peer_support_delivery_complete(struct efa_rdm_peer *peer)
{
/* FI_DELIVERY_COMPLETE is an extra feature defined
* in version 4 (the base version).
* Because it is an extra feature,
* an EP will assume the peer does not support
* it before a handshake packet was received.
*/
return (peer->flags & EFA_RDM_PEER_HANDSHAKE_RECEIVED) &&
(peer->extra_info[0] & EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE);
}

static inline
bool efa_rdm_peer_support_read_nack(struct efa_rdm_peer *peer)
{
Expand Down
29 changes: 19 additions & 10 deletions prov/efa/src/rdm/efa_rdm_pkt_type.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,21 +19,21 @@ struct efa_rdm_pkt_type_req_info EFA_RDM_PKT_TYPE_REQ_INFO_VEC[] = {
[EFA_RDM_LONGCTS_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_longcts_tagrtm_hdr), 0},
[EFA_RDM_LONGREAD_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_longread_msgrtm_hdr), EFA_RDM_EXTRA_FEATURE_RDMA_READ},
[EFA_RDM_LONGREAD_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_longread_tagrtm_hdr), EFA_RDM_EXTRA_FEATURE_RDMA_READ},
[EFA_RDM_DC_EAGER_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_dc_eager_msgrtm_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_EAGER_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_dc_eager_tagrtm_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_MEDIUM_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_dc_medium_msgrtm_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_MEDIUM_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_dc_medium_tagrtm_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_LONGCTS_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_longcts_msgrtm_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_LONGCTS_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_longcts_tagrtm_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_EAGER_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_dc_eager_msgrtm_hdr), 0},
[EFA_RDM_DC_EAGER_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_dc_eager_tagrtm_hdr), 0},
[EFA_RDM_DC_MEDIUM_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_dc_medium_msgrtm_hdr), 0},
[EFA_RDM_DC_MEDIUM_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_dc_medium_tagrtm_hdr), 0},
[EFA_RDM_DC_LONGCTS_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_longcts_msgrtm_hdr), 0},
[EFA_RDM_DC_LONGCTS_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_longcts_tagrtm_hdr), 0},
[EFA_RDM_RUNTCTS_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_runtcts_msgrtm_hdr), EFA_RDM_EXTRA_FEATURE_RUNT},
[EFA_RDM_RUNTCTS_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_runtcts_tagrtm_hdr), EFA_RDM_EXTRA_FEATURE_RUNT},
[EFA_RDM_RUNTREAD_MSGRTM_PKT] = {0, sizeof(struct efa_rdm_runtread_msgrtm_hdr), EFA_RDM_EXTRA_FEATURE_RUNT | EFA_RDM_EXTRA_FEATURE_RDMA_READ},
[EFA_RDM_RUNTREAD_TAGRTM_PKT] = {0, sizeof(struct efa_rdm_runtread_tagrtm_hdr), EFA_RDM_EXTRA_FEATURE_RUNT | EFA_RDM_EXTRA_FEATURE_RDMA_READ},
/* rtw header */
[EFA_RDM_EAGER_RTW_PKT] = {0, sizeof(struct efa_rdm_eager_rtw_hdr), 0},
[EFA_RDM_DC_EAGER_RTW_PKT] = {0, sizeof(struct efa_rdm_dc_eager_rtw_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_EAGER_RTW_PKT] = {0, sizeof(struct efa_rdm_dc_eager_rtw_hdr), 0},
[EFA_RDM_LONGCTS_RTW_PKT] = {0, sizeof(struct efa_rdm_longcts_rtw_hdr), 0},
[EFA_RDM_DC_LONGCTS_RTW_PKT] = {0, sizeof(struct efa_rdm_longcts_rtw_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_LONGCTS_RTW_PKT] = {0, sizeof(struct efa_rdm_longcts_rtw_hdr), 0},
[EFA_RDM_LONGREAD_RTW_PKT] = {0, sizeof(struct efa_rdm_longread_rtw_hdr), EFA_RDM_EXTRA_FEATURE_RDMA_READ},
[EFA_RDM_RUNTCTS_RTW_PKT] = {0, sizeof(struct efa_rdm_runtcts_rtw_hdr), EFA_RDM_EXTRA_FEATURE_RUNT},
[EFA_RDM_RUNTREAD_RTW_PKT] = {0, sizeof(struct efa_rdm_runtread_rtw_hdr), EFA_RDM_EXTRA_FEATURE_RUNT},
Expand All @@ -43,7 +43,7 @@ struct efa_rdm_pkt_type_req_info EFA_RDM_PKT_TYPE_REQ_INFO_VEC[] = {
[EFA_RDM_READ_RTR_PKT] = {0, sizeof(struct efa_rdm_base_hdr), EFA_RDM_EXTRA_FEATURE_RDMA_READ},
/* rta header */
[EFA_RDM_WRITE_RTA_PKT] = {0, sizeof(struct efa_rdm_rta_hdr), 0},
[EFA_RDM_DC_WRITE_RTA_PKT] = {0, sizeof(struct efa_rdm_rta_hdr), EFA_RDM_EXTRA_FEATURE_DELIVERY_COMPLETE},
[EFA_RDM_DC_WRITE_RTA_PKT] = {0, sizeof(struct efa_rdm_rta_hdr), 0},
[EFA_RDM_FETCH_RTA_PKT] = {0, sizeof(struct efa_rdm_rta_hdr), 0},
[EFA_RDM_COMPARE_RTA_PKT] = {0, sizeof(struct efa_rdm_rta_hdr), 0},
};
Expand All @@ -64,11 +64,20 @@ struct efa_rdm_pkt_type_req_info EFA_RDM_PKT_TYPE_REQ_INFO_VEC[] = {
*/
bool efa_rdm_pkt_type_is_supported_by_peer(int req_pkt_type, struct efa_rdm_peer *peer)
{
uint64_t ex_feature_flag;

ex_feature_flag = EFA_RDM_PKT_TYPE_REQ_INFO_VEC[req_pkt_type].ex_feature_flag;

/* No extra feature required means always supported */
if (!ex_feature_flag)
return true;

/* If an extra feature is needed, handshake should have been enforced */
assert(peer->flags & EFA_RDM_PEER_HANDSHAKE_RECEIVED);

int extra_info_id = EFA_RDM_PKT_TYPE_REQ_INFO_VEC[req_pkt_type].extra_info_id;

return peer->extra_info[extra_info_id] & EFA_RDM_PKT_TYPE_REQ_INFO_VEC[req_pkt_type].ex_feature_flag;
return peer->extra_info[extra_info_id] & ex_feature_flag;
}

/**
Expand Down
19 changes: 2 additions & 17 deletions prov/efa/src/rdm/efa_rdm_rma.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -373,25 +373,10 @@ ssize_t efa_rdm_rma_post_write(struct efa_rdm_ep *ep, struct efa_rdm_ope *txe)
}

delivery_complete_requested = txe->fi_flags & FI_DELIVERY_COMPLETE;
if (delivery_complete_requested) {
/*
* Because delivery complete is defined as an extra
* feature, the receiver might not support it.
*
* The sender cannot send with FI_DELIVERY_COMPLETE
* if the peer is not able to handle it.
*
* handshake is already made now since we enforce
* handshake for write earlier.
*/

if (!ep->homogeneous_peers && !(txe->peer->is_self) && !efa_rdm_peer_support_delivery_complete(txe->peer))
return -FI_EOPNOTSUPP;

if (delivery_complete_requested)
max_eager_rtw_data_size = efa_rdm_txe_max_req_data_capacity(ep, txe, EFA_RDM_DC_EAGER_RTW_PKT);
} else {
else
max_eager_rtw_data_size = efa_rdm_txe_max_req_data_capacity(ep, txe, EFA_RDM_EAGER_RTW_PKT);
}

iface = txe->desc[0] ? ((struct efa_mr*) txe->desc[0])->iface : FI_HMEM_SYSTEM;

Expand Down
183 changes: 0 additions & 183 deletions prov/efa/test/efa_unit_test_ep.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -417,189 +417,6 @@ void test_efa_rdm_pke_get_available_copy_methods_align128(struct efa_resource **
*
* @param[in] state struct efa_resource that is managed by the framework
*/
void test_efa_rdm_ep_dc_atomic_queue_before_handshake(struct efa_resource **state)
{
struct efa_rdm_ep *efa_rdm_ep;
struct efa_rdm_peer *peer;
struct fi_ioc ioc = {0};
struct fi_rma_ioc rma_ioc = {0};
struct fi_msg_atomic msg = {0};
struct efa_resource *resource = *state;
struct efa_ep_addr raw_addr = {0};
size_t raw_addr_len = sizeof(struct efa_ep_addr);
fi_addr_t peer_addr;
int buf[1] = {0}, err, numaddr;
struct efa_rdm_ope *txe;

/* disable shm to force using efa device to send */
efa_unit_test_resource_construct_rdm_shm_disabled(resource);

/* create a fake peer */
err = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len);
assert_int_equal(err, 0);
raw_addr.qpn = 1;
raw_addr.qkey = 0x1234;
numaddr = fi_av_insert(resource->av, &raw_addr, 1, &peer_addr, 0, NULL);
assert_int_equal(numaddr, 1);

msg.addr = peer_addr;

ioc.addr = buf;
ioc.count = 1;
msg.msg_iov = &ioc;
msg.iov_count = 1;

msg.rma_iov = &rma_ioc;
msg.rma_iov_count = 1;
msg.datatype = FI_INT32;
msg.op = FI_SUM;

efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid);

/* set peer->flag to EFA_RDM_PEER_REQ_SENT will make efa_rdm_atomic() think
* a REQ packet has been sent to the peer (so no need to send again)
* handshake has not been received, so we do not know whether the peer support DC
*/
peer = efa_rdm_ep_get_peer(efa_rdm_ep, peer_addr);
peer->flags = EFA_RDM_PEER_REQ_SENT;
peer->is_local = false;

assert_false(efa_rdm_ep->homogeneous_peers);
assert_true(dlist_empty(&efa_rdm_ep->txe_list));
err = fi_atomicmsg(resource->ep, &msg, FI_DELIVERY_COMPLETE);
/* DC has been reuquested, but ep do not know whether peer supports it, therefore
* the ope has been queued to domain->ope_queued_list
*/
assert_int_equal(err, 0);
assert_int_equal(efa_unit_test_get_dlist_length(&efa_rdm_ep->txe_list), 1);
assert_int_equal(efa_unit_test_get_dlist_length(&(efa_rdm_ep_domain(efa_rdm_ep)->ope_queued_list)), 1);
txe = container_of(efa_rdm_ep_domain(efa_rdm_ep)->ope_queued_list.next, struct efa_rdm_ope, queued_entry);
assert_true((txe->op == ofi_op_atomic));
assert_true(txe->internal_flags & EFA_RDM_OPE_QUEUED_BEFORE_HANDSHAKE);
}

/**
* @brief when delivery complete send was used and handshake packet has not been received
* verify the txe is queued
*
* @param[in] state struct efa_resource that is managed by the framework
*/
void test_efa_rdm_ep_dc_send_queue_before_handshake(struct efa_resource **state)
{
struct efa_rdm_ep *efa_rdm_ep;
struct efa_rdm_peer *peer;
struct fi_msg msg = {0};
struct iovec iov;
struct efa_resource *resource = *state;
struct efa_ep_addr raw_addr = {0};
size_t raw_addr_len = sizeof(struct efa_ep_addr);
fi_addr_t peer_addr;
int err, numaddr;
struct efa_rdm_ope *txe;

/* disable shm to force using efa device to send */
efa_unit_test_resource_construct_rdm_shm_disabled(resource);

/* create a fake peer */
err = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len);
assert_int_equal(err, 0);
raw_addr.qpn = 1;
raw_addr.qkey = 0x1234;
numaddr = fi_av_insert(resource->av, &raw_addr, 1, &peer_addr, 0, NULL);
assert_int_equal(numaddr, 1);

msg.addr = peer_addr;
msg.iov_count = 1;
iov.iov_base = NULL;
iov.iov_len = 0;
msg.msg_iov = &iov;
msg.desc = NULL;

efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid);

/* set peer->flag to EFA_RDM_PEER_REQ_SENT will make efa_rdm_atomic() think
* a REQ packet has been sent to the peer (so no need to send again)
* handshake has not been received, so we do not know whether the peer support DC
*/
peer = efa_rdm_ep_get_peer(efa_rdm_ep, peer_addr);
peer->flags = EFA_RDM_PEER_REQ_SENT;
peer->is_local = false;

assert_false(efa_rdm_ep->homogeneous_peers);
assert_true(dlist_empty(&efa_rdm_ep->txe_list));
err = fi_sendmsg(resource->ep, &msg, FI_DELIVERY_COMPLETE);
/* DC has been reuquested, but ep do not know whether peer supports it, therefore
* the ope has been queued to domain->ope_queued_list
*/
assert_int_equal(err, 0);
assert_int_equal(efa_unit_test_get_dlist_length(&efa_rdm_ep->txe_list), 1);
assert_int_equal(efa_unit_test_get_dlist_length(&(efa_rdm_ep_domain(efa_rdm_ep)->ope_queued_list)), 1);
txe = container_of(efa_rdm_ep_domain(efa_rdm_ep)->ope_queued_list.next, struct efa_rdm_ope, queued_entry);
assert_true((txe->op == ofi_op_msg));
assert_true(txe->internal_flags & EFA_RDM_OPE_QUEUED_BEFORE_HANDSHAKE);
}

/**
* @brief when delivery complete send was used and handshake packet has not been received
* verify the txes are queued before the number of requests reach EFA_RDM_MAX_QUEUED_OPE_BEFORE_HANDSHAKE.
* After reaching the limit, fi_send should return -FI_EAGAIN
*
* @param[in] state struct efa_resource that is managed by the framework
*/
void test_efa_rdm_ep_dc_send_queue_limit_before_handshake(struct efa_resource **state)
Comment thread
a-szegel marked this conversation as resolved.
{
struct efa_rdm_ep *efa_rdm_ep;
struct efa_rdm_peer *peer;
struct fi_msg msg = {0};
struct iovec iov;
struct efa_resource *resource = *state;
struct efa_ep_addr raw_addr = {0};
size_t raw_addr_len = sizeof(struct efa_ep_addr);
fi_addr_t peer_addr;
int err, numaddr;
int i;

/* disable shm to force using efa device to send */
efa_unit_test_resource_construct_rdm_shm_disabled(resource);

/* create a fake peer */
err = fi_getname(&resource->ep->fid, &raw_addr, &raw_addr_len);
assert_int_equal(err, 0);
raw_addr.qpn = 1;
raw_addr.qkey = 0x1234;
numaddr = fi_av_insert(resource->av, &raw_addr, 1, &peer_addr, 0, NULL);
assert_int_equal(numaddr, 1);

msg.addr = peer_addr;
msg.iov_count = 1;
iov.iov_base = NULL;
iov.iov_len = 0;
msg.msg_iov = &iov;
msg.desc = NULL;

efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid);

/* set peer->flag to EFA_RDM_PEER_REQ_SENT will make efa_rdm_atomic() think
* a REQ packet has been sent to the peer (so no need to send again)
* handshake has not been received, so we do not know whether the peer support DC
*/
peer = efa_rdm_ep_get_peer(efa_rdm_ep, peer_addr);
peer->flags = EFA_RDM_PEER_REQ_SENT;
peer->is_local = false;

assert_false(efa_rdm_ep->homogeneous_peers);
assert_true(dlist_empty(&efa_rdm_ep->txe_list));

for (i = 0; i < EFA_RDM_MAX_QUEUED_OPE_BEFORE_HANDSHAKE; i++) {
err = fi_sendmsg(resource->ep, &msg, FI_DELIVERY_COMPLETE);
assert_int_equal(err, 0);
}

assert_true(efa_rdm_ep->ope_queued_before_handshake_cnt == EFA_RDM_MAX_QUEUED_OPE_BEFORE_HANDSHAKE);
err = fi_sendmsg(resource->ep, &msg, FI_DELIVERY_COMPLETE);
assert_int_equal(err, -FI_EAGAIN);
}

/**
* @brief verify tx entry is queued for rma (read or write) request before handshake is made.
*
Expand Down
25 changes: 10 additions & 15 deletions prov/efa/test/efa_unit_test_ope.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1113,7 +1113,6 @@ void test_efa_rdm_atomic_compare_desc_persistence(struct efa_resource **state)
ret = fi_av_insert(resource->av, &raw_addr, 1, &addr, 0, NULL);
assert_int_equal(ret, 1);

/* Set peer flags to simulate handshake state */
efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid);
peer = efa_rdm_ep_get_peer(efa_rdm_ep, addr);
peer->flags = EFA_RDM_PEER_REQ_SENT;
Expand All @@ -1134,7 +1133,6 @@ void test_efa_rdm_atomic_compare_desc_persistence(struct efa_resource **state)
compare_desc_array[0] = fi_mr_desc(compare_buff.mr);
void *original_desc_value = compare_desc_array[0];

/* Setup atomic message with FI_DELIVERY_COMPLETE to force queuing */
ioc.addr = send_buff.buff;
ioc.count = 1;
compare_ioc.addr = compare_buff.buff;
Expand All @@ -1152,26 +1150,23 @@ void test_efa_rdm_atomic_compare_desc_persistence(struct efa_resource **state)
msg.op = FI_CSWAP;

/*
* Call fi_compare_atomicmsg with FI_DELIVERY_COMPLETE.
* This forces the operation to be queued when handshake is not complete.
* The old buggy code would store a pointer to compare_desc_array,
* which becomes dangling when this function returns.
* The fix copies the array contents into txe->atomic_ex.compare_desc[].
* Mock efa_qp_post_send to succeed so the compare atomic completes.
* The test verifies that compare_desc is properly copied into the txe
* (not just a pointer to the caller's stack array).
*/
ret = fi_compare_atomicmsg(resource->ep, &msg, &compare_ioc, compare_desc_array, 1,
&result_ioc, result_desc_array, 1, FI_DELIVERY_COMPLETE);
g_efa_unit_test_mocks.efa_qp_post_send = &efa_mock_efa_qp_post_send_return_mock;
will_return_int(efa_mock_efa_qp_post_send_return_mock, 0);

/* Operation should succeed (queued) */
ret = fi_compare_atomicmsg(resource->ep, &msg, &compare_ioc, compare_desc_array, 1,
&result_ioc, result_desc_array, 1, 0);
assert_int_equal(ret, 0);

/* Destroy stack array to simulate function return */
compare_desc_array[0] = (void *)(uintptr_t)0xDEADBEEF;

/* Retrieve queued txe from ope_queued_list */
efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid);
assert_false(dlist_empty(&efa_rdm_ep_domain(efa_rdm_ep)->ope_queued_list));
txe = container_of(efa_rdm_ep_domain(efa_rdm_ep)->ope_queued_list.next,
struct efa_rdm_ope, queued_entry);
/* Retrieve the txe from the txe_list */
assert_false(dlist_empty(&efa_rdm_ep->txe_list));
txe = container_of(efa_rdm_ep->txe_list.next, struct efa_rdm_ope, ep_entry);

/* Verify compare_desc was copied, not just pointer stored */
assert_ptr_equal(txe->atomic_ex.compare_desc[0], original_desc_value);
Expand Down
Loading