diff --git a/prov/efa/src/rdm/efa_rdm_cq.c b/prov/efa/src/rdm/efa_rdm_cq.c
index 24051cc2e8a..179501f78d5 100644
--- a/prov/efa/src/rdm/efa_rdm_cq.c
+++ b/prov/efa/src/rdm/efa_rdm_cq.c
@@ -359,7 +359,7 @@ static void efa_rdm_cq_handle_recv_completion(struct efa_ibv_cq *ibv_cq, struct
 		return;
 	}
 
-	efa_rdm_pke_proc_received(pkt_entry);
+	efa_rdm_pke_proc_received(pkt_entry, peer);
 }
 
 
@@ -371,6 +371,7 @@ static void efa_rdm_cq_handle_recv_completion(struct efa_ibv_cq *ibv_cq, struct
  * provider error code.
  *
  * @param[in]	ibv_cq_ex	IBV CQ
+ * @param[in]	peer	efa_rdm_peer struct of sender
  * @return	EFA-specific error code
  * @sa		#EFA_PROV_ERRNOS
  *
@@ -382,16 +383,10 @@ static void efa_rdm_cq_handle_recv_completion(struct efa_ibv_cq *ibv_cq, struct
  * RDMA Core error codes (#EFA_IO_COMP_STATUSES) for the sake of more accurate
  * error reporting
  */
-static int efa_rdm_cq_get_prov_errno(struct ibv_cq_ex *ibv_cq_ex) {
+static int efa_rdm_cq_get_prov_errno(struct ibv_cq_ex *ibv_cq_ex, struct efa_rdm_peer *peer) {
 	uint32_t vendor_err = ibv_wc_read_vendor_err(ibv_cq_ex);
-	struct efa_rdm_pke *pkt_entry = (void *) (uintptr_t) ibv_cq_ex->wr_id;
-	struct efa_rdm_peer *peer;
-	struct efa_rdm_ep *ep;
 
-	if (OFI_LIKELY(pkt_entry && pkt_entry->addr)) {
-		ep = pkt_entry->ep;
-		peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
-	} else {
+	if (OFI_UNLIKELY(!peer)) {
 		return vendor_err;
 	}
 
@@ -438,6 +433,7 @@ void efa_rdm_cq_poll_ibv_cq(ssize_t cqe_to_process, struct efa_ibv_cq *ibv_cq)
 	struct efa_cq *efa_cq;
 	struct efa_domain *efa_domain;
 	struct efa_qp *qp;
+	struct efa_rdm_peer *peer = NULL;
 	struct dlist_entry rx_progressed_ep_list, *tmp;
 
 	efa_cq = container_of(ibv_cq, struct efa_cq, ibv_cq);
@@ -462,12 +458,14 @@ void efa_rdm_cq_poll_ibv_cq(ssize_t cqe_to_process, struct efa_ibv_cq *ibv_cq)
 #endif
 		opcode = ibv_wc_read_opcode(ibv_cq->ibv_cq_ex);
 		if (ibv_cq->ibv_cq_ex->status) {
-			prov_errno = efa_rdm_cq_get_prov_errno(ibv_cq->ibv_cq_ex);
+			if (pkt_entry)
+				peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
+			prov_errno = efa_rdm_cq_get_prov_errno(ibv_cq->ibv_cq_ex, peer);
 			switch (opcode) {
 			case IBV_WC_SEND: /* fall through */
 			case IBV_WC_RDMA_WRITE: /* fall through */
 			case IBV_WC_RDMA_READ:
-				efa_rdm_pke_handle_tx_error(pkt_entry, prov_errno);
+				efa_rdm_pke_handle_tx_error(pkt_entry, prov_errno, peer);
 				break;
 			case IBV_WC_RECV: /* fall through */
 			case IBV_WC_RECV_RDMA_WITH_IMM:
@@ -490,9 +488,12 @@ void efa_rdm_cq_poll_ibv_cq(ssize_t cqe_to_process, struct efa_ibv_cq *ibv_cq)
 #if ENABLE_DEBUG
 			ep->send_comps++;
 #endif
-			efa_rdm_pke_handle_send_completion(pkt_entry);
+			peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
+			efa_rdm_pke_handle_send_completion(pkt_entry, peer);
 			break;
 		case IBV_WC_RECV:
+			/* efa_rdm_cq_handle_recv_completion does additional work to determine the source
+			 * address and the peer struct. So do not try to identify the peer here. */
 			efa_rdm_cq_handle_recv_completion(ibv_cq, pkt_entry, ep);
 #if ENABLE_DEBUG
 			ep->recv_comps++;
@@ -500,7 +501,8 @@ void efa_rdm_cq_poll_ibv_cq(ssize_t cqe_to_process, struct efa_ibv_cq *ibv_cq)
 			break;
 		case IBV_WC_RDMA_READ:
 		case IBV_WC_RDMA_WRITE:
-			efa_rdm_pke_handle_rma_completion(pkt_entry);
+			peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
+			efa_rdm_pke_handle_rma_completion(pkt_entry, peer);
 			break;
 		case IBV_WC_RECV_RDMA_WITH_IMM:
 			efa_rdm_cq_proc_ibv_recv_rdma_with_imm_completion(
diff --git a/prov/efa/src/rdm/efa_rdm_ep.h b/prov/efa/src/rdm/efa_rdm_ep.h
index 4b36c225784..4f73524e14c 100644
--- a/prov/efa/src/rdm/efa_rdm_ep.h
+++ b/prov/efa/src/rdm/efa_rdm_ep.h
@@ -207,7 +207,7 @@ struct efa_rdm_ope *efa_rdm_ep_alloc_rxe(struct efa_rdm_ep *ep,
 
 void efa_rdm_ep_record_tx_op_submitted(struct efa_rdm_ep *ep, struct efa_rdm_pke *pkt_entry);
 
-void efa_rdm_ep_record_tx_op_completed(struct efa_rdm_ep *ep, struct efa_rdm_pke *pkt_entry);
+void efa_rdm_ep_record_tx_op_completed(struct efa_rdm_ep *ep, struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 static inline size_t efa_rdm_ep_get_rx_pool_size(struct efa_rdm_ep *ep)
 {
@@ -235,9 +235,9 @@ int efa_rdm_ep_post_user_recv_buf(struct efa_rdm_ep *ep, struct efa_rdm_ope *rxe
 
 struct efa_rdm_peer;
 
-void efa_rdm_ep_queue_rnr_pkt(struct efa_rdm_ep *ep,
-			      struct dlist_entry *list,
-			      struct efa_rdm_pke *pkt_entry);
+void efa_rdm_ep_queue_rnr_pkt(struct efa_rdm_ep *ep, struct dlist_entry *list,
+			      struct efa_rdm_pke *pkt_entry,
+			      struct efa_rdm_peer *peer);
 
 ssize_t efa_rdm_ep_post_queued_pkts(struct efa_rdm_ep *ep,
 				    struct dlist_entry *pkts);
diff --git a/prov/efa/src/rdm/efa_rdm_ep_utils.c b/prov/efa/src/rdm/efa_rdm_ep_utils.c
index abd30fabed3..792f9e4a40e 100644
--- a/prov/efa/src/rdm/efa_rdm_ep_utils.c
+++ b/prov/efa/src/rdm/efa_rdm_ep_utils.c
@@ -335,11 +335,11 @@ void efa_rdm_ep_record_tx_op_submitted(struct efa_rdm_ep *ep, struct efa_rdm_pke
  * @param[in,out]	ep		endpoint
  * @param[in]		pkt_entry	TX pkt_entry, which contains
  * 					the info of the TX op
+ * @param[in]	peer		efa_rdm_peer struct for the receiver
  */
-void efa_rdm_ep_record_tx_op_completed(struct efa_rdm_ep *ep, struct efa_rdm_pke *pkt_entry)
+void efa_rdm_ep_record_tx_op_completed(struct efa_rdm_ep *ep, struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
 	struct efa_rdm_ope *ope = NULL;
-	struct efa_rdm_peer *peer;
 
 	ope = pkt_entry->ope;
 	/*
@@ -351,7 +351,6 @@ void efa_rdm_ep_record_tx_op_completed(struct efa_rdm_ep *ep, struct efa_rdm_pke
 	 *    a new peer has the same GID+QPN was inserted to address, or because
 	 *    application removed the peer from address vector.
 	 */
-	peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
 	if (peer)
 		dlist_remove(&pkt_entry->entry);
 
@@ -408,12 +407,13 @@ void efa_rdm_ep_record_tx_op_completed(struct efa_rdm_ep *ep, struct efa_rdm_pke
  * @param[in]	ep		endpoint
  * @param[in]	list		queued RNR packet list
  * @param[in]	pkt_entry	packet entry that encounter RNR
+ * @param[in]	peer	efa_rdm_peer struct of the receiver
  */
 void efa_rdm_ep_queue_rnr_pkt(struct efa_rdm_ep *ep,
 			  struct dlist_entry *list,
-			  struct efa_rdm_pke *pkt_entry)
+			  struct efa_rdm_pke *pkt_entry,
+			struct efa_rdm_peer *peer)
 {
-	struct efa_rdm_peer *peer;
 	static const int random_min_timeout = 40;
 	static const int random_max_timeout = 120;
 
@@ -422,7 +422,6 @@ void efa_rdm_ep_queue_rnr_pkt(struct efa_rdm_ep *ep,
 #endif
 	dlist_insert_tail(&pkt_entry->entry, list);
 	ep->efa_rnr_queued_pkt_cnt += 1;
-	peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
 	assert(peer);
 	if (!(pkt_entry->flags & EFA_RDM_PKE_RNR_RETRANSMIT)) {
 		/* This is the first time this packet encountered RNR,
diff --git a/prov/efa/src/rdm/efa_rdm_peer.c b/prov/efa/src/rdm/efa_rdm_peer.c
index c9383e97faa..07f73a2c95e 100644
--- a/prov/efa/src/rdm/efa_rdm_peer.c
+++ b/prov/efa/src/rdm/efa_rdm_peer.c
@@ -304,7 +304,7 @@ void efa_rdm_peer_proc_pending_items_in_robuf(struct efa_rdm_peer *peer, struct
 		EFA_DBG(FI_LOG_EP_CTRL,
 		       "Processing msg_id %d from robuf\n", msg_id);
 		/* efa_rdm_pke_proc_rtm_rta will write error cq entry if needed */
-		ret = efa_rdm_pke_proc_rtm_rta(pending_pkt);
+		ret = efa_rdm_pke_proc_rtm_rta(pending_pkt, peer);
 		*ofi_recvwin_get_next_msg((&peer->robuf)) = NULL;
 
 		exp_msg_id = ofi_recvwin_next_exp_id((&peer->robuf));
diff --git a/prov/efa/src/rdm/efa_rdm_pke_cmd.c b/prov/efa/src/rdm/efa_rdm_pke_cmd.c
index b8baf5c2935..2268384af4a 100644
--- a/prov/efa/src/rdm/efa_rdm_pke_cmd.c
+++ b/prov/efa/src/rdm/efa_rdm_pke_cmd.c
@@ -396,10 +396,10 @@ void efa_rdm_pke_handle_data_copied(struct efa_rdm_pke *pkt_entry)
  *
  * @param[in]	pkt_entry	pkt entry
  * @param[in]	prov_errno	provider specific error code
+ * @param[in]	peer	efa_rdm_peer struct for the receiver
  */
-void efa_rdm_pke_handle_tx_error(struct efa_rdm_pke *pkt_entry, int prov_errno)
+void efa_rdm_pke_handle_tx_error(struct efa_rdm_pke *pkt_entry, int prov_errno, struct efa_rdm_peer *peer)
 {
-	struct efa_rdm_peer *peer;
 	struct efa_rdm_ope *txe;
 	struct efa_rdm_ope *rxe;
 	struct efa_rdm_ep *ep;
@@ -412,9 +412,8 @@ void efa_rdm_pke_handle_tx_error(struct efa_rdm_pke *pkt_entry, int prov_errno)
 	        efa_strerror(prov_errno), prov_errno);
 
 	ep = pkt_entry->ep;
-	efa_rdm_ep_record_tx_op_completed(ep, pkt_entry);
+	efa_rdm_ep_record_tx_op_completed(ep, pkt_entry, peer);
 
-	peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
 	if (!peer) {
 		/*
 		 * If peer is NULL, it means the peer has been removed from AV.
@@ -493,7 +492,7 @@ void efa_rdm_pke_handle_tx_error(struct efa_rdm_pke *pkt_entry, int prov_errno)
 				 * packets include all REQ, DATA) thus shoud be queued for RNR
 				 * only if application wants EFA to manager resource.
 				 */
-				efa_rdm_ep_queue_rnr_pkt(ep, &txe->queued_pkts, pkt_entry);
+				efa_rdm_ep_queue_rnr_pkt(ep, &txe->queued_pkts, pkt_entry, peer);
 				if (!(txe->internal_flags & EFA_RDM_OPE_QUEUED_RNR)) {
 					txe->internal_flags |= EFA_RDM_OPE_QUEUED_RNR;
 					dlist_insert_tail(&txe->queued_entry,
@@ -514,7 +513,7 @@ void efa_rdm_pke_handle_tx_error(struct efa_rdm_pke *pkt_entry, int prov_errno)
 			 * is regardless value of ep->handle_resource_management, because
 			 * resource management is only applied to send operation.
 			 */
-			efa_rdm_ep_queue_rnr_pkt(ep, &rxe->queued_pkts, pkt_entry);
+			efa_rdm_ep_queue_rnr_pkt(ep, &rxe->queued_pkts, pkt_entry, peer);
 			if (!(rxe->internal_flags & EFA_RDM_OPE_QUEUED_RNR)) {
 				rxe->internal_flags |= EFA_RDM_OPE_QUEUED_RNR;
 				dlist_insert_tail(&rxe->queued_entry,
@@ -544,8 +543,9 @@ void efa_rdm_pke_handle_tx_error(struct efa_rdm_pke *pkt_entry, int prov_errno)
  * then release the packet entry.
  *
  * @param[in,out]	pkt_entry	packet entry
+ * @param[in,out]	peer	efa_rdm_peer struct of the receiver
  */
-void efa_rdm_pke_handle_send_completion(struct efa_rdm_pke *pkt_entry)
+void efa_rdm_pke_handle_send_completion(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
 	struct efa_rdm_ep *ep;
 
@@ -560,7 +560,7 @@ void efa_rdm_pke_handle_send_completion(struct efa_rdm_pke *pkt_entry)
 	if (pkt_entry->addr == FI_ADDR_NOTAVAIL &&
 	    !(pkt_entry->flags & EFA_RDM_PKE_LOCAL_READ)) {
 		EFA_WARN(FI_LOG_CQ, "ignoring send completion of a packet to a removed peer.\n");
-		efa_rdm_ep_record_tx_op_completed(ep, pkt_entry);
+		efa_rdm_ep_record_tx_op_completed(ep, pkt_entry, peer);
 		efa_rdm_pke_release_tx(pkt_entry);
 		return;
 	}
@@ -568,7 +568,7 @@ void efa_rdm_pke_handle_send_completion(struct efa_rdm_pke *pkt_entry)
 	/* These pkts are eager pkts withour hdrs */
 	if (pkt_entry->flags & EFA_RDM_PKE_SEND_TO_USER_RECV_QP) {
 		efa_rdm_pke_handle_eager_rtm_send_completion(pkt_entry);
-		efa_rdm_ep_record_tx_op_completed(ep, pkt_entry);
+		efa_rdm_ep_record_tx_op_completed(ep, pkt_entry, peer);
 		efa_rdm_pke_release_tx(pkt_entry);
 		return;
 	}
@@ -590,7 +590,7 @@ void efa_rdm_pke_handle_send_completion(struct efa_rdm_pke *pkt_entry)
 		efa_rdm_pke_handle_eor_send_completion(pkt_entry);
 		break;
 	case EFA_RDM_RMA_CONTEXT_PKT:
-		efa_rdm_pke_handle_rma_completion(pkt_entry);
+		efa_rdm_pke_handle_rma_completion(pkt_entry, peer);
 		return;
 	case EFA_RDM_ATOMRSP_PKT:
 		efa_rdm_pke_handle_atomrsp_send_completion(pkt_entry);
@@ -674,7 +674,7 @@ void efa_rdm_pke_handle_send_completion(struct efa_rdm_pke *pkt_entry)
 		return;
 	}
 
-	efa_rdm_ep_record_tx_op_completed(ep, pkt_entry);
+	efa_rdm_ep_record_tx_op_completed(ep, pkt_entry, peer);
 	efa_rdm_pke_release_tx(pkt_entry);
 }
 
@@ -808,8 +808,9 @@ void efa_rdm_pke_proc_received_no_hdr(struct efa_rdm_pke *pkt_entry, bool has_im
  *
  * @param[in]	ep		endpoint
  * @param[in]	pkt_entry	received packet entry
+ * @param[in]	peer		peer struct of the sender
  */
-void efa_rdm_pke_proc_received(struct efa_rdm_pke *pkt_entry)
+void efa_rdm_pke_proc_received(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
 	struct efa_rdm_ep *ep;
 	struct efa_rdm_base_hdr *base_hdr;
@@ -843,7 +844,7 @@ void efa_rdm_pke_proc_received(struct efa_rdm_pke *pkt_entry)
 		efa_rdm_pke_handle_eor_recv(pkt_entry);
 		return;
 	case EFA_RDM_HANDSHAKE_PKT:
-		efa_rdm_pke_handle_handshake_recv(pkt_entry);
+		efa_rdm_pke_handle_handshake_recv(pkt_entry, peer);
 		return;
 	case EFA_RDM_CTS_PKT:
 		efa_rdm_pke_handle_cts_recv(pkt_entry);
@@ -880,7 +881,7 @@ void efa_rdm_pke_proc_received(struct efa_rdm_pke *pkt_entry)
 	case EFA_RDM_DC_WRITE_RTA_PKT:
 	case EFA_RDM_FETCH_RTA_PKT:
 	case EFA_RDM_COMPARE_RTA_PKT:
-		efa_rdm_pke_handle_rtm_rta_recv(pkt_entry);
+		efa_rdm_pke_handle_rtm_rta_recv(pkt_entry, peer);
 		return;
 	case EFA_RDM_EAGER_RTW_PKT:
 		efa_rdm_pke_handle_eager_rtw_recv(pkt_entry);
diff --git a/prov/efa/src/rdm/efa_rdm_pke_cmd.h b/prov/efa/src/rdm/efa_rdm_pke_cmd.h
index 019d4b34c51..d3f9e448ef7 100644
--- a/prov/efa/src/rdm/efa_rdm_pke_cmd.h
+++ b/prov/efa/src/rdm/efa_rdm_pke_cmd.h
@@ -20,15 +20,15 @@ fi_addr_t efa_rdm_pke_determine_addr(struct efa_rdm_pke *pkt_entry);
 
 void efa_rdm_pke_handle_data_copied(struct efa_rdm_pke *pkt_entry);
 
-void efa_rdm_pke_handle_tx_error(struct efa_rdm_pke *pkt_entry, int prov_errno);
+void efa_rdm_pke_handle_tx_error(struct efa_rdm_pke *pkt_entry, int prov_errno, struct efa_rdm_peer *peer);
 
-void efa_rdm_pke_handle_send_completion(struct efa_rdm_pke *pkt_entry);
+void efa_rdm_pke_handle_send_completion(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 void efa_rdm_pke_handle_rx_error(struct efa_rdm_pke *pkt_entry, int prov_errno);
 
 void efa_rdm_pke_handle_recv_completion(struct efa_rdm_pke *pkt_entry);
 
-void efa_rdm_pke_proc_received(struct efa_rdm_pke *pkt_entry);
+void efa_rdm_pke_proc_received(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 void efa_rdm_pke_proc_received_no_hdr(struct efa_rdm_pke *pkt_entry, bool has_imm_data, uint32_t imm_data);
 
diff --git a/prov/efa/src/rdm/efa_rdm_pke_nonreq.c b/prov/efa/src/rdm/efa_rdm_pke_nonreq.c
index b1b7be31460..944e426d6a1 100644
--- a/prov/efa/src/rdm/efa_rdm_pke_nonreq.c
+++ b/prov/efa/src/rdm/efa_rdm_pke_nonreq.c
@@ -90,9 +90,8 @@ ssize_t efa_rdm_pke_init_handshake(struct efa_rdm_pke *pkt_entry,
 	return 0;
 }
 
-void efa_rdm_pke_handle_handshake_recv(struct efa_rdm_pke *pkt_entry)
+void efa_rdm_pke_handle_handshake_recv(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
-	struct efa_rdm_peer *peer;
 	struct efa_rdm_handshake_hdr *handshake_pkt;
 	uint64_t *host_id_ptr;
 
@@ -100,7 +99,6 @@ void efa_rdm_pke_handle_handshake_recv(struct efa_rdm_pke *pkt_entry)
 	EFA_DBG(FI_LOG_CQ,
 		"HANDSHAKE received from %" PRIu64 "\n", pkt_entry->addr);
 
-	peer = efa_rdm_ep_get_peer(pkt_entry->ep, pkt_entry->addr);
 	assert(peer);
 
 	handshake_pkt = (struct efa_rdm_handshake_hdr *)pkt_entry->wiredata;
@@ -570,8 +568,9 @@ void efa_rdm_pke_handle_rma_read_completion(struct efa_rdm_pke *context_pkt_entr
  *
  * @param ep[in,out]			Endpoint
  * @param context_pkt_entry[in,out]	The "Packet" which serves as context
+ * @param peer[in]			struct efa_rdm_peer of peer
  */
-void efa_rdm_pke_handle_rma_completion(struct efa_rdm_pke *context_pkt_entry)
+void efa_rdm_pke_handle_rma_completion(struct efa_rdm_pke *context_pkt_entry, struct efa_rdm_peer *peer)
 {
 	struct efa_rdm_ope *txe = NULL;
 	struct efa_rdm_rma_context_pkt *rma_context_pkt;
@@ -601,7 +600,7 @@ void efa_rdm_pke_handle_rma_completion(struct efa_rdm_pke *context_pkt_entry)
 		assert(0 && "invalid EFA_RDM_RMA_CONTEXT_PKT rma_context_type\n");
 	}
 
-	efa_rdm_ep_record_tx_op_completed(context_pkt_entry->ep, context_pkt_entry);
+	efa_rdm_ep_record_tx_op_completed(context_pkt_entry->ep, context_pkt_entry, peer);
 	efa_rdm_pke_release_tx(context_pkt_entry);
 }
 
diff --git a/prov/efa/src/rdm/efa_rdm_pke_nonreq.h b/prov/efa/src/rdm/efa_rdm_pke_nonreq.h
index 1393d070856..cd9aaa9764e 100644
--- a/prov/efa/src/rdm/efa_rdm_pke_nonreq.h
+++ b/prov/efa/src/rdm/efa_rdm_pke_nonreq.h
@@ -118,7 +118,7 @@ struct efa_rdm_handshake_opt_user_recv_qp_hdr *efa_rdm_pke_get_handshake_opt_use
 ssize_t efa_rdm_pke_init_handshake(struct efa_rdm_pke *pkt_entry,
 				   fi_addr_t addr);
 
-void efa_rdm_pke_handle_handshake_recv(struct efa_rdm_pke *pkt_entry);
+void efa_rdm_pke_handle_handshake_recv(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 /* CTS packet related functions */
 static inline
@@ -210,7 +210,7 @@ void efa_rdm_pke_init_read_context(struct efa_rdm_pke *pkt_entry,
 				   int read_id,
 				   size_t seg_size);
 
-void efa_rdm_pke_handle_rma_completion(struct efa_rdm_pke *pkt_entry);
+void efa_rdm_pke_handle_rma_completion(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 /* EOR packet related functions */
 static inline
diff --git a/prov/efa/src/rdm/efa_rdm_pke_rtm.c b/prov/efa/src/rdm/efa_rdm_pke_rtm.c
index ca45c1a2fab..01c82ea55d7 100644
--- a/prov/efa/src/rdm/efa_rdm_pke_rtm.c
+++ b/prov/efa/src/rdm/efa_rdm_pke_rtm.c
@@ -176,26 +176,25 @@ void efa_rdm_pke_rtm_update_rxe(struct efa_rdm_pke *pkt_entry,
  *
  * @param[in,out]	pkt_entry	RTM packet entry
  * @param[in,out]	rxe		RX entry that matches the RTM
+ * @param[in]	peer		efa_rdm_peer struct of receiver
  *
  * @returns
  * 0 on success
  * negative libfabric error code on failure
  */
-ssize_t efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry)
+ssize_t efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
-	struct efa_rdm_ep *ep;
 	struct efa_rdm_ope *rxe;
 	int pkt_type;
 	ssize_t ret;
 
-	ep = pkt_entry->ep;
 	rxe = pkt_entry->ope;
 	assert(rxe && rxe->state == EFA_RDM_RXE_MATCHED);
 
 	efa_rdm_tracepoint(rx_pke_proc_matched_msg_begin, (size_t) pkt_entry, pkt_entry->payload_size, rxe->msg_id, (size_t) rxe->cq_entry.op_context, rxe->total_len);
 	if (!rxe->peer) {
 		rxe->addr = pkt_entry->addr;
-		rxe->peer = efa_rdm_ep_get_peer(ep, rxe->addr);
+		rxe->peer = peer;
 		assert(rxe->peer);
 		dlist_insert_tail(&rxe->peer_entry, &rxe->peer->rxe_list);
 	}
@@ -235,7 +234,7 @@ ssize_t efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry)
 		return efa_rdm_pke_proc_matched_longread_rtm(pkt_entry);
 
 	if (efa_rdm_pkt_type_is_mulreq(pkt_type))
-		return efa_rdm_pke_proc_matched_mulreq_rtm(pkt_entry);
+		return efa_rdm_pke_proc_matched_mulreq_rtm(pkt_entry, peer);
 
 	if (pkt_type == EFA_RDM_EAGER_MSGRTM_PKT ||
 	    pkt_type == EFA_RDM_EAGER_TAGRTM_PKT ||
@@ -268,18 +267,18 @@ ssize_t efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry)
  * @brief process a received non-tagged RTM packet
  *
  * @param[in,out]	pkt_entry	non-tagged RTM packet entry
+ * @param[in]	peer	efa_rdm_peer struct of sender
  */
-ssize_t efa_rdm_pke_proc_msgrtm(struct efa_rdm_pke *pkt_entry)
+static ssize_t efa_rdm_pke_proc_msgrtm(struct efa_rdm_pke *pkt_entry,
+				       struct efa_rdm_peer *peer)
 {
 	ssize_t err;
 	struct efa_rdm_ep *ep;
 	struct efa_rdm_ope *rxe;
 	struct fid_peer_srx *peer_srx;
 	struct efa_rdm_rtm_base_hdr *rtm_hdr;
-	struct efa_rdm_peer *peer;
 
 	ep = pkt_entry->ep;
-	peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
 
 	rtm_hdr = (struct efa_rdm_rtm_base_hdr *)pkt_entry->wiredata;
 	if (rtm_hdr->flags & EFA_RDM_REQ_READ_NACK) {
@@ -299,7 +298,7 @@ ssize_t efa_rdm_pke_proc_msgrtm(struct efa_rdm_pke *pkt_entry)
 	pkt_entry->ope = rxe;
 
 	if (rxe->state == EFA_RDM_RXE_MATCHED) {
-		err = efa_rdm_pke_proc_matched_rtm(pkt_entry);
+		err = efa_rdm_pke_proc_matched_rtm(pkt_entry, peer);
 		if (OFI_UNLIKELY(err)) {
 			efa_rdm_rxe_handle_error(rxe, -err, FI_EFA_ERR_PKT_PROC_MSGRTM);
 			efa_rdm_pke_release_rx(pkt_entry);
@@ -318,18 +317,18 @@ ssize_t efa_rdm_pke_proc_msgrtm(struct efa_rdm_pke *pkt_entry)
  * @brief process a received tagged RTM packet
  *
  * @param[in,out]	pkt_entry	non-tagged RTM packet entry
+ * @param[in]	peer	efa_rdm_peer struct of sender
  */
-ssize_t efa_rdm_pke_proc_tagrtm(struct efa_rdm_pke *pkt_entry)
+static ssize_t efa_rdm_pke_proc_tagrtm(struct efa_rdm_pke *pkt_entry,
+				       struct efa_rdm_peer *peer)
 {
 	ssize_t err;
 	struct efa_rdm_ep *ep;
 	struct efa_rdm_ope *rxe;
 	struct fid_peer_srx *peer_srx;
 	struct efa_rdm_rtm_base_hdr *rtm_hdr;
-	struct efa_rdm_peer *peer;
 
 	ep = pkt_entry->ep;
-	peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
 
 	rtm_hdr = (struct efa_rdm_rtm_base_hdr *) pkt_entry->wiredata;
 	if (rtm_hdr->flags & EFA_RDM_REQ_READ_NACK) {
@@ -349,7 +348,7 @@ ssize_t efa_rdm_pke_proc_tagrtm(struct efa_rdm_pke *pkt_entry)
 	pkt_entry->ope = rxe;
 
 	if (rxe->state == EFA_RDM_RXE_MATCHED) {
-		err = efa_rdm_pke_proc_matched_rtm(pkt_entry);
+		err = efa_rdm_pke_proc_matched_rtm(pkt_entry, peer);
 		if (OFI_UNLIKELY(err)) {
 			if (err == -FI_ENOMR)
 				return err;
@@ -374,8 +373,9 @@ ssize_t efa_rdm_pke_proc_tagrtm(struct efa_rdm_pke *pkt_entry)
  * by msg_id in the packet header
  *
  * @param[in,out]	pkt_entry	received RTM or RTA packet entry
+ * @param[in]	peer	efa_rdm_peer struct of the sender
  */
-ssize_t efa_rdm_pke_proc_rtm_rta(struct efa_rdm_pke *pkt_entry)
+ssize_t efa_rdm_pke_proc_rtm_rta(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
 	struct efa_rdm_ep *ep;
 	struct efa_rdm_base_hdr *base_hdr;
@@ -393,7 +393,7 @@ ssize_t efa_rdm_pke_proc_rtm_rta(struct efa_rdm_pke *pkt_entry)
 	case EFA_RDM_DC_EAGER_MSGRTM_PKT:
 	case EFA_RDM_DC_MEDIUM_MSGRTM_PKT:
 	case EFA_RDM_DC_LONGCTS_MSGRTM_PKT:
-		return efa_rdm_pke_proc_msgrtm(pkt_entry);
+		return efa_rdm_pke_proc_msgrtm(pkt_entry, peer);
 	case EFA_RDM_EAGER_TAGRTM_PKT:
 	case EFA_RDM_MEDIUM_TAGRTM_PKT:
 	case EFA_RDM_LONGCTS_TAGRTM_PKT:
@@ -402,7 +402,7 @@ ssize_t efa_rdm_pke_proc_rtm_rta(struct efa_rdm_pke *pkt_entry)
 	case EFA_RDM_DC_EAGER_TAGRTM_PKT:
 	case EFA_RDM_DC_MEDIUM_TAGRTM_PKT:
 	case EFA_RDM_DC_LONGCTS_TAGRTM_PKT:
-		return efa_rdm_pke_proc_tagrtm(pkt_entry);
+		return efa_rdm_pke_proc_tagrtm(pkt_entry, peer);
 	case EFA_RDM_WRITE_RTA_PKT:
 		return efa_rdm_pke_proc_write_rta(pkt_entry);
 	case EFA_RDM_DC_WRITE_RTA_PKT:
@@ -430,12 +430,12 @@ ssize_t efa_rdm_pke_proc_rtm_rta(struct efa_rdm_pke *pkt_entry)
  * Otherwise, process it then process packet in the re-order buffer.
  *
  * @param[in,out]	pkt_entry	received RTM or RTA packet entry
+ * @param[in]	peer	efa_rdm_peer struct corresponding to the sender
  */
-void efa_rdm_pke_handle_rtm_rta_recv(struct efa_rdm_pke *pkt_entry)
+void efa_rdm_pke_handle_rtm_rta_recv(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
 	struct efa_rdm_ep *ep;
 	struct efa_rdm_base_hdr *base_hdr;
-	struct efa_rdm_peer *peer;
 	struct efa_rdm_rtm_base_hdr *rtm_hdr;
 	bool slide_recvwin;
 	int ret;
@@ -443,7 +443,6 @@ void efa_rdm_pke_handle_rtm_rta_recv(struct efa_rdm_pke *pkt_entry)
 
 	ep = pkt_entry->ep;
 
-	peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
 	assert(peer);
 
 	base_hdr = efa_rdm_pke_get_base_hdr(pkt_entry);
@@ -457,7 +456,7 @@ void efa_rdm_pke_handle_rtm_rta_recv(struct efa_rdm_pke *pkt_entry)
 		if (rxe) {
 			if (rxe->state == EFA_RDM_RXE_MATCHED) {
 				pkt_entry->ope = rxe;
-				efa_rdm_pke_proc_matched_mulreq_rtm(pkt_entry);
+				efa_rdm_pke_proc_matched_mulreq_rtm(pkt_entry, peer);
 			} else {
 				assert(rxe->unexp_pkt);
 				unexp_pkt_entry = efa_rdm_pke_get_unexp(&pkt_entry);
@@ -511,7 +510,7 @@ void efa_rdm_pke_handle_rtm_rta_recv(struct efa_rdm_pke *pkt_entry)
 	 * efa_rdm_pke_proc_rtm_rta() will write error cq entry if needed,
 	 * thus we do not write error cq entry
 	 */
-	ret = efa_rdm_pke_proc_rtm_rta(pkt_entry);
+	ret = efa_rdm_pke_proc_rtm_rta(pkt_entry, peer);
 	if (OFI_UNLIKELY(ret))
 		return;
 
@@ -855,13 +854,13 @@ void efa_rdm_pke_handle_medium_rtm_send_completion(struct efa_rdm_pke *pkt_entry
  * RTM and 2 types of RUNTREAD RTM.
  *
  * @param[in,out]	pkt_entry	packet entry
+ * @param[in]	peer	efa_rdm_peer struct of the sender
  */
-ssize_t efa_rdm_pke_proc_matched_mulreq_rtm(struct efa_rdm_pke *pkt_entry)
+ssize_t efa_rdm_pke_proc_matched_mulreq_rtm(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
 	struct efa_rdm_ep *ep;
 	struct efa_rdm_ope *rxe;
 	struct efa_rdm_pke *cur, *nxt;
-	struct efa_rdm_peer *peer;
 	int pkt_type;
 	ssize_t ret, err;
 	uint64_t msg_id;
@@ -869,7 +868,6 @@ ssize_t efa_rdm_pke_proc_matched_mulreq_rtm(struct efa_rdm_pke *pkt_entry)
 	ep = pkt_entry->ep;
 	rxe = pkt_entry->ope;
 	pkt_type = efa_rdm_pke_get_base_hdr(pkt_entry)->type;
-	peer = efa_rdm_ep_get_peer(ep, pkt_entry->addr);
 
 	ret = 0;
 	if (efa_rdm_pkt_type_is_runtread(pkt_type)) {
diff --git a/prov/efa/src/rdm/efa_rdm_pke_rtm.h b/prov/efa/src/rdm/efa_rdm_pke_rtm.h
index 4c55aad9ec0..35ba583303b 100644
--- a/prov/efa/src/rdm/efa_rdm_pke_rtm.h
+++ b/prov/efa/src/rdm/efa_rdm_pke_rtm.h
@@ -90,11 +90,11 @@ void efa_rdm_pke_set_rtm_tag(struct efa_rdm_pke *pkt_entry, uint64_t tag)
 void efa_rdm_pke_rtm_update_rxe(struct efa_rdm_pke *pkt_entry,
 				struct efa_rdm_ope *rxe);
 
-ssize_t efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry);
+ssize_t efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
-ssize_t efa_rdm_pke_proc_rtm_rta(struct efa_rdm_pke *pkt_entry);
+ssize_t efa_rdm_pke_proc_rtm_rta(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
-void efa_rdm_pke_handle_rtm_rta_recv(struct efa_rdm_pke *pkt_entry);
+void efa_rdm_pke_handle_rtm_rta_recv(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 static inline
 struct efa_rdm_dc_eager_rtm_base_hdr *efa_rdm_pke_get_dc_eager_rtm_base_hdr(struct efa_rdm_pke *pke)
@@ -196,7 +196,7 @@ void efa_rdm_pke_handle_medium_rtm_sent(struct efa_rdm_pke *pkt_entry);
 
 void efa_rdm_pke_handle_medium_rtm_send_completion(struct efa_rdm_pke *pkt_entry);
 
-ssize_t efa_rdm_pke_proc_matched_mulreq_rtm(struct efa_rdm_pke *pkt_entry);
+ssize_t efa_rdm_pke_proc_matched_mulreq_rtm(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 ssize_t efa_rdm_pke_init_longcts_msgrtm(struct efa_rdm_pke *pkt_entry,
 					struct efa_rdm_ope *txe);
diff --git a/prov/efa/src/rdm/efa_rdm_srx.c b/prov/efa/src/rdm/efa_rdm_srx.c
index 6625a0c30b8..d41be0e9fb7 100644
--- a/prov/efa/src/rdm/efa_rdm_srx.c
+++ b/prov/efa/src/rdm/efa_rdm_srx.c
@@ -52,6 +52,7 @@ static int efa_rdm_srx_start(struct fi_peer_rx_entry *peer_rxe)
 	int ret;
 	struct efa_rdm_pke *pkt_entry;
 	struct efa_rdm_ope *rxe;
+	struct efa_rdm_peer *peer;
 
 	assert(ofi_genlock_held(efa_rdm_srx_get_srx_ctx(peer_rxe)->lock));
 
@@ -68,7 +69,8 @@ static int efa_rdm_srx_start(struct fi_peer_rx_entry *peer_rxe)
 	 */
 	rxe->unexp_pkt = NULL;
 
-	ret = efa_rdm_pke_proc_matched_rtm(pkt_entry);
+	peer = efa_rdm_ep_get_peer(rxe->ep, pkt_entry->addr);
+	ret = efa_rdm_pke_proc_matched_rtm(pkt_entry, peer);
 	if (OFI_UNLIKELY(ret)) {
 		/* If we run out of memory registrations, we fall back to
 		 * emulated protocols */
diff --git a/prov/efa/test/efa_unit_test_cq.c b/prov/efa/test/efa_unit_test_cq.c
index 11d7418387b..9911428d4ec 100644
--- a/prov/efa/test/efa_unit_test_cq.c
+++ b/prov/efa/test/efa_unit_test_cq.c
@@ -74,7 +74,7 @@ void test_ibv_cq_ex_read_empty_cq(struct efa_resource **state)
  */
 static void test_rdm_cq_read_bad_send_status(struct efa_resource *resource,
                                              uint64_t local_host_id, uint64_t peer_host_id,
-                                             int vendor_error)
+                                             int vendor_error, int efa_error)
 {
 	const char *strerror;
 	fi_addr_t addr;
@@ -154,7 +154,7 @@ static void test_rdm_cq_read_bad_send_status(struct efa_resource *resource,
 
 	assert_int_equal(ret, 1);
 	assert_int_not_equal(cq_err_entry.err, FI_SUCCESS);
-	assert_int_equal(cq_err_entry.prov_errno, vendor_error);
+	assert_int_equal(cq_err_entry.prov_errno, efa_error);
 
 	/* Reset value */
 	memset(host_id_str, 0, sizeof(host_id_str));
@@ -196,7 +196,7 @@ void test_rdm_cq_read_bad_send_status_unresponsive_receiver(struct efa_resource
 	struct efa_resource *resource = *state;
 	test_rdm_cq_read_bad_send_status(resource,
 					 0x1234567812345678, 0x8765432187654321,
-					 EFA_IO_COMP_STATUS_LOCAL_ERROR_UNRESP_REMOTE);
+					 EFA_IO_COMP_STATUS_LOCAL_ERROR_UNRESP_REMOTE, FI_EFA_ERR_UNESTABLISHED_RECV_UNRESP);
 }
 
 /**
@@ -213,7 +213,7 @@ void test_rdm_cq_read_bad_send_status_unresponsive_receiver_missing_peer_host_id
 	struct efa_resource *resource = *state;
 	test_rdm_cq_read_bad_send_status(resource,
 					 0x1234567812345678, 0,
-					 EFA_IO_COMP_STATUS_LOCAL_ERROR_UNRESP_REMOTE);
+					 EFA_IO_COMP_STATUS_LOCAL_ERROR_UNRESP_REMOTE, FI_EFA_ERR_UNESTABLISHED_RECV_UNRESP);
 }
 
 /**
@@ -230,7 +230,7 @@ void test_rdm_cq_read_bad_send_status_unreachable_receiver(struct efa_resource *
 	struct efa_resource *resource = *state;
 	test_rdm_cq_read_bad_send_status(resource,
 					 0x1234567812345678, 0x8765432187654321,
-					 EFA_IO_COMP_STATUS_LOCAL_ERROR_UNREACH_REMOTE);
+					 EFA_IO_COMP_STATUS_LOCAL_ERROR_UNREACH_REMOTE, EFA_IO_COMP_STATUS_LOCAL_ERROR_UNREACH_REMOTE);
 }
 
 /**
@@ -248,7 +248,7 @@ void test_rdm_cq_read_bad_send_status_invalid_qpn(struct efa_resource **state)
 
 	test_rdm_cq_read_bad_send_status(resource,
 					 0x1234567812345678, 0x8765432187654321,
-					 EFA_IO_COMP_STATUS_REMOTE_ERROR_BAD_DEST_QPN);
+					 EFA_IO_COMP_STATUS_REMOTE_ERROR_BAD_DEST_QPN, EFA_IO_COMP_STATUS_REMOTE_ERROR_BAD_DEST_QPN);
 }
 
 /**
@@ -265,7 +265,7 @@ void test_rdm_cq_read_bad_send_status_message_too_long(struct efa_resource **sta
 	struct efa_resource *resource = *state;
 	test_rdm_cq_read_bad_send_status(resource,
 					 0x1234567812345678, 0x8765432187654321,
-					 EFA_IO_COMP_STATUS_LOCAL_ERROR_BAD_LENGTH);
+					 EFA_IO_COMP_STATUS_LOCAL_ERROR_BAD_LENGTH, EFA_IO_COMP_STATUS_LOCAL_ERROR_BAD_LENGTH);
 }
 
 /**
@@ -286,6 +286,10 @@ void test_ibv_cq_ex_read_bad_recv_status(struct efa_resource **state)
 	int ret;
 	struct efa_rdm_cq *efa_rdm_cq;
 	struct ibv_cq_ex *ibv_cqx;
+	size_t raw_addr_len = sizeof(struct efa_ep_addr);
+	fi_addr_t peer_addr;
+	struct efa_ep_addr raw_addr = {0};
+	int err, numaddr;
 
 
 	efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
@@ -307,6 +311,13 @@ void test_ibv_cq_ex_read_bad_recv_status(struct efa_resource **state)
 	efa_rdm_cq = container_of(resource->cq, struct efa_rdm_cq, efa_cq.util_cq.cq_fid.fid);
 	ibv_cqx = efa_rdm_cq->efa_cq.ibv_cq.ibv_cq_ex;
 
+	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);
+
 	ibv_cqx->start_poll = &efa_mock_ibv_start_poll_return_mock;
 	ibv_cqx->end_poll = &efa_mock_ibv_end_poll_check_mock;
 	ibv_cqx->read_opcode = &efa_mock_ibv_read_opcode_return_mock;
@@ -341,7 +352,7 @@ void test_ibv_cq_ex_read_bad_recv_status(struct efa_resource **state)
 	ret = fi_eq_readerr(resource->eq, &eq_err_entry, 0);
 	assert_int_equal(ret, sizeof(eq_err_entry));
 	assert_int_not_equal(eq_err_entry.err, FI_SUCCESS);
-	assert_int_equal(eq_err_entry.prov_errno, EFA_IO_COMP_STATUS_LOCAL_ERROR_UNRESP_REMOTE);
+	assert_int_equal(eq_err_entry.prov_errno, FI_EFA_ERR_UNESTABLISHED_RECV_UNRESP);
 }
 
 /**
@@ -364,7 +375,10 @@ void test_ibv_cq_ex_read_bad_recv_rdma_with_imm_status_impl(struct efa_resource
 	int ret;
 	struct efa_rdm_cq *efa_rdm_cq;
 	struct ibv_cq_ex *ibv_cqx;
-
+	size_t raw_addr_len = sizeof(struct efa_ep_addr);
+	fi_addr_t peer_addr;
+	struct efa_ep_addr raw_addr = {0};
+	int err, numaddr;
 
 	efa_unit_test_resource_construct(resource, FI_EP_RDM, EFA_FABRIC_NAME);
 	efa_rdm_ep = container_of(resource->ep, struct efa_rdm_ep, base_ep.util_ep.ep_fid);
@@ -372,6 +386,13 @@ void test_ibv_cq_ex_read_bad_recv_rdma_with_imm_status_impl(struct efa_resource
 	efa_rdm_cq = container_of(resource->cq, struct efa_rdm_cq, efa_cq.util_cq.cq_fid.fid);
 	ibv_cqx = efa_rdm_cq->efa_cq.ibv_cq.ibv_cq_ex;
 
+	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);
+
 	ibv_cqx->start_poll = &efa_mock_ibv_start_poll_return_mock;
 	ibv_cqx->end_poll = &efa_mock_ibv_end_poll_check_mock;
 	ibv_cqx->read_opcode = &efa_mock_ibv_read_opcode_return_mock;
diff --git a/prov/efa/test/efa_unit_test_mocks.c b/prov/efa/test/efa_unit_test_mocks.c
index de257fc91ab..517456bac18 100644
--- a/prov/efa/test/efa_unit_test_mocks.c
+++ b/prov/efa/test/efa_unit_test_mocks.c
@@ -218,7 +218,7 @@ ssize_t efa_mock_efa_rdm_ope_post_send_return_mock(struct efa_rdm_ope *ope, int
 	return mock();
 }
 
-ssize_t efa_mock_efa_rdm_pke_proc_matched_rtm_no_op(struct efa_rdm_pke *pkt_entry)
+ssize_t efa_mock_efa_rdm_pke_proc_matched_rtm_no_op(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
 	return FI_SUCCESS;
 }
@@ -402,9 +402,9 @@ int __wrap_efa_rdm_pke_read(struct efa_rdm_ope *ope)
 	return g_efa_unit_test_mocks.efa_rdm_pke_read(ope);
 }
 
-int __wrap_efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry)
+int __wrap_efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer)
 {
-	return g_efa_unit_test_mocks.efa_rdm_pke_proc_matched_rtm(pkt_entry);
+	return g_efa_unit_test_mocks.efa_rdm_pke_proc_matched_rtm(pkt_entry, peer);
 }
 
 int __wrap_efa_rdm_ope_post_send(struct efa_rdm_ope *ope, int pkt_type)
diff --git a/prov/efa/test/efa_unit_test_mocks.h b/prov/efa/test/efa_unit_test_mocks.h
index c74df8646e9..2004826444c 100644
--- a/prov/efa/test/efa_unit_test_mocks.h
+++ b/prov/efa/test/efa_unit_test_mocks.h
@@ -95,9 +95,9 @@ bool __real_efa_device_support_unsolicited_write_recv();
 
 int efa_mock_efa_rdm_pke_read_return_mock(struct efa_rdm_ope *ope);
 
-ssize_t __real_efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry);
+ssize_t __real_efa_rdm_pke_proc_matched_rtm(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
-ssize_t efa_mock_efa_rdm_pke_proc_matched_rtm_no_op(struct efa_rdm_pke *pkt_entry);
+ssize_t efa_mock_efa_rdm_pke_proc_matched_rtm_no_op(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 ssize_t __real_efa_rdm_ope_post_send(struct efa_rdm_ope *ope, int pkt_type);
 
@@ -146,7 +146,7 @@ struct efa_unit_test_mocks
 
 	int (*efa_rdm_pke_read)(struct efa_rdm_ope *ope);
 
-	ssize_t (*efa_rdm_pke_proc_matched_rtm)(struct efa_rdm_pke *pkt_entry);
+	ssize_t (*efa_rdm_pke_proc_matched_rtm)(struct efa_rdm_pke *pkt_entry, struct efa_rdm_peer *peer);
 
 	ssize_t (*efa_rdm_ope_post_send)(struct efa_rdm_ope *ope, int pkt_type);
 
diff --git a/prov/efa/test/efa_unit_test_rnr.c b/prov/efa/test/efa_unit_test_rnr.c
index bca4dd627b8..737ac70f258 100644
--- a/prov/efa/test/efa_unit_test_rnr.c
+++ b/prov/efa/test/efa_unit_test_rnr.c
@@ -17,6 +17,7 @@ void test_efa_rnr_queue_and_resend(struct efa_resource **state)
 	struct efa_rdm_ep *efa_rdm_ep;
 	struct efa_rdm_ope *txe;
 	struct efa_rdm_pke *pkt_entry;
+	struct efa_rdm_peer *peer;
 	size_t raw_addr_len = sizeof(raw_addr);
 	fi_addr_t peer_addr;
 	int ret;
@@ -48,9 +49,11 @@ void test_efa_rnr_queue_and_resend(struct efa_resource **state)
 
 	txe = container_of(efa_rdm_ep->txe_list.next, struct efa_rdm_ope, ep_entry);
 	pkt_entry = (struct efa_rdm_pke *)g_ibv_submitted_wr_id_vec[0];
+	peer = efa_rdm_ep_get_peer(efa_rdm_ep, pkt_entry->addr);
 
-	efa_rdm_ep_record_tx_op_completed(efa_rdm_ep, pkt_entry);
-	efa_rdm_ep_queue_rnr_pkt(efa_rdm_ep, &txe->queued_pkts, pkt_entry);
+	efa_rdm_ep_record_tx_op_completed(efa_rdm_ep, pkt_entry, peer);
+
+	efa_rdm_ep_queue_rnr_pkt(efa_rdm_ep, &txe->queued_pkts, pkt_entry, peer);
 	assert_int_equal(pkt_entry->flags & EFA_RDM_PKE_RNR_RETRANSMIT, EFA_RDM_PKE_RNR_RETRANSMIT);
 	assert_int_equal(efa_rdm_ep->efa_rnr_queued_pkt_cnt, 1);
 	assert_int_equal(efa_rdm_ep_get_peer(efa_rdm_ep, peer_addr)->rnr_queued_pkt_cnt, 1);
@@ -61,7 +64,7 @@ void test_efa_rnr_queue_and_resend(struct efa_resource **state)
 	assert_int_equal(efa_rdm_ep->efa_rnr_queued_pkt_cnt, 0);
 	assert_int_equal(efa_rdm_ep_get_peer(efa_rdm_ep, peer_addr)->rnr_queued_pkt_cnt, 0);
 
-	efa_rdm_pke_handle_send_completion(pkt_entry);
+	efa_rdm_pke_handle_send_completion(pkt_entry, peer);
 
 	efa_unit_test_buff_destruct(&send_buff);
 }