/* op_flags=0, FI_SELECTIVE_COMPLETION not set, FI_AV_TABLE */
static ssize_t
psmx2_tagged_recv_no_flag_av_table(struct fid_ep *ep, void *buf, size_t len,
void *desc, fi_addr_t src_addr,
uint64_t tag, uint64_t ignore,
void *context)
{
struct psmx2_fid_ep *ep_priv;
struct psmx2_fid_av *av;
psm2_epaddr_t psm2_epaddr;
uint8_t vlane;
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
uint32_t tag32, tagsel32;
struct fi_context *fi_context;
size_t idx;
int err;
ep_priv = container_of(ep, struct psmx2_fid_ep, ep);
fi_context = context;
PSMX2_CTXT_TYPE(fi_context) = PSMX2_TRECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_SIZE(fi_context) = len;
if ((ep_priv->caps & FI_DIRECTED_RECV) && src_addr != FI_ADDR_UNSPEC) {
av = ep_priv->av;
if (av && PSMX2_SEP_ADDR_TEST(src_addr)) {
psm2_epaddr = psmx2_av_translate_sep(av, ep_priv->trx_ctxt, src_addr);
vlane = 0;
} else {
idx = (size_t)src_addr;
if (idx >= av->last)
return -FI_EINVAL;
psm2_epaddr = av->epaddrs[idx];
vlane = av->vlanes[idx];
}
tag32 = PSMX2_TAG32(0, vlane, ep_priv->vlane);
tagsel32 = ~PSMX2_IOV_BIT;
} else {
psm2_epaddr = 0;
tag32 = PSMX2_TAG32(0, 0, ep_priv->vlane);
tagsel32 = ~(PSMX2_IOV_BIT | PSMX2_SRC_BITS);
}
PSMX2_SET_TAG(psm2_tag, tag, tag32);
PSMX2_SET_TAG(psm2_tagsel, ~ignore, tagsel32);
err = psm2_mq_irecv2(ep_priv->trx_ctxt->psm2_mq, psm2_epaddr,
&psm2_tag, &psm2_tagsel, 0, buf, len,
(void *)fi_context, &psm2_req);
if (err != PSM2_OK)
return psmx2_errno(err);
PSMX2_CTXT_REQ(fi_context) = psm2_req;
return 0;
}
/* op_flags=0, FI_SELECTIVE_COMPLETION set, FI_AV_MAP */
static ssize_t
psmx2_tagged_recv_no_event_av_map(struct fid_ep *ep, void *buf, size_t len,
void *desc, fi_addr_t src_addr,
uint64_t tag, uint64_t ignore,
void *context)
{
struct psmx2_fid_ep *ep_priv;
struct psmx2_fid_av *av;
psm2_epaddr_t psm2_epaddr;
uint8_t vlane;
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
uint32_t tag32, tagsel32;
struct fi_context *fi_context;
int err;
ep_priv = container_of(ep, struct psmx2_fid_ep, ep);
fi_context = psmx2_ep_get_op_context(ep_priv);
PSMX2_CTXT_TYPE(fi_context) = PSMX2_NOCOMP_RECV_CONTEXT_ALLOC;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_SIZE(fi_context) = len;
if ((ep_priv->caps & FI_DIRECTED_RECV) && src_addr != FI_ADDR_UNSPEC) {
av = ep_priv->av;
if (av && PSMX2_SEP_ADDR_TEST(src_addr)) {
psm2_epaddr = psmx2_av_translate_sep(av, ep_priv->trx_ctxt, src_addr);
vlane = 0;
} else {
psm2_epaddr = PSMX2_ADDR_TO_EP(src_addr);
vlane = PSMX2_ADDR_TO_VL(src_addr);
}
tag32 = PSMX2_TAG32(0, vlane, ep_priv->vlane);
tagsel32 = ~PSMX2_IOV_BIT;
} else {
psm2_epaddr = 0;
tag32 = PSMX2_TAG32(0, 0, ep_priv->vlane);
tagsel32 = ~(PSMX2_IOV_BIT | PSMX2_SRC_BITS);
}
PSMX2_SET_TAG(psm2_tag, tag, tag32);
PSMX2_SET_TAG(psm2_tagsel, ~ignore, tagsel32);
err = psm2_mq_irecv2(ep_priv->trx_ctxt->psm2_mq, psm2_epaddr,
&psm2_tag, &psm2_tagsel, 0, buf, len,
(void *)fi_context, &psm2_req);
return psmx2_errno(err);
}
/* op_flags=0, FI_SELECTIVE_COMPLETION set, FI_AV_TABLE */
static ssize_t
psmx2_tagged_recv_no_event_av_table(struct fid_ep *ep, void *buf, size_t len,
void *desc, fi_addr_t src_addr,
uint64_t tag, uint64_t ignore,
void *context)
{
struct psmx2_fid_ep *ep_priv;
struct psmx2_fid_av *av;
psm2_epaddr_t psm2_epaddr;
uint8_t vlane;
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
uint32_t tag32, tagsel32;
struct fi_context *fi_context;
size_t idx;
int err;
ep_priv = container_of(ep, struct psmx2_fid_ep, ep);
fi_context = psmx2_ep_get_op_context(ep_priv);
PSMX2_CTXT_TYPE(fi_context) = PSMX2_NOCOMP_RECV_CONTEXT_ALLOC;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_SIZE(fi_context) = len;
if ((ep_priv->caps & FI_DIRECTED_RECV) && src_addr != FI_ADDR_UNSPEC) {
av = ep_priv->av;
idx = (size_t)src_addr;
if (idx >= av->last)
return -FI_EINVAL;
psm2_epaddr = av->epaddrs[idx];
vlane = av->vlanes[idx];
tag32 = PSMX2_TAG32(0, vlane, ep_priv->vlane);
tagsel32 = ~PSMX2_IOV_BIT;
} else {
psm2_epaddr = 0;
tag32 = PSMX2_TAG32(0, 0, ep_priv->vlane);
tagsel32 = ~(PSMX2_IOV_BIT | PSMX2_SRC_BITS);
}
PSMX2_SET_TAG(psm2_tag, tag, tag32);
PSMX2_SET_TAG(psm2_tagsel, ~ignore, tagsel32);
err = psm2_mq_irecv2(ep_priv->domain->psm2_mq, psm2_epaddr,
&psm2_tag, &psm2_tagsel, 0, buf, len,
(void *)fi_context, &psm2_req);
return psmx2_errno(err);
}
/* op_flags=0, FI_SELECTIVE_COMPLETION not set, FI_AV_MAP */
static ssize_t
psmx2_tagged_recv_no_flag_av_map(struct fid_ep *ep, void *buf, size_t len,
void *desc, fi_addr_t src_addr,
uint64_t tag, uint64_t ignore,
void *context)
{
struct psmx2_fid_ep *ep_priv;
psm2_epaddr_t psm2_epaddr;
uint8_t vlane;
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
uint32_t tag32, tagsel32;
struct fi_context *fi_context;
int err;
ep_priv = container_of(ep, struct psmx2_fid_ep, ep);
fi_context = context;
PSMX2_CTXT_TYPE(fi_context) = PSMX2_TRECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_SIZE(fi_context) = len;
if ((ep_priv->caps & FI_DIRECTED_RECV) && src_addr != FI_ADDR_UNSPEC) {
psm2_epaddr = PSMX2_ADDR_TO_EP(src_addr);
vlane = PSMX2_ADDR_TO_VL(src_addr);
tag32 = PSMX2_TAG32(0, vlane, ep_priv->vlane);
tagsel32 = ~PSMX2_IOV_BIT;
} else {
psm2_epaddr = 0;
tag32 = PSMX2_TAG32(0, 0, ep_priv->vlane);
tagsel32 = ~(PSMX2_IOV_BIT | PSMX2_SRC_BITS);
}
PSMX2_SET_TAG(psm2_tag, tag, tag32);
PSMX2_SET_TAG(psm2_tagsel, ~ignore, tagsel32);
err = psm2_mq_irecv2(ep_priv->domain->psm2_mq, psm2_epaddr,
&psm2_tag, &psm2_tagsel, 0, buf, len,
(void *)fi_context, &psm2_req);
if (err != PSM2_OK)
return psmx2_errno(err);
PSMX2_CTXT_REQ(fi_context) = psm2_req;
return 0;
}
int psmx2_handle_sendv_req(struct psmx2_fid_ep *ep,
psm2_mq_status2_t *psm2_status,
int multi_recv)
{
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
struct psmx2_sendv_reply *rep;
struct psmx2_multi_recv *recv_req;
struct fi_context *fi_context;
struct fi_context *recv_context;
int i, err;
uint8_t *recv_buf;
size_t recv_len, len;
if (psm2_status->error_code != PSM2_OK)
return psmx2_errno(psm2_status->error_code);
rep = malloc(sizeof(*rep));
if (!rep) {
psm2_status->error_code = PSM2_NO_MEMORY;
return -FI_ENOMEM;
}
recv_context = psm2_status->context;
if (multi_recv) {
recv_req = PSMX2_CTXT_USER(recv_context);
recv_buf = recv_req->buf + recv_req->offset;
recv_len = recv_req->len - recv_req->offset;
rep->multi_recv = 1;
} else {
recv_buf = PSMX2_CTXT_USER(recv_context);
recv_len = PSMX2_CTXT_SIZE(recv_context);
rep->multi_recv = 0;
}
/* assert(psm2_status->nbytes <= PSMX2_IOV_BUF_SIZE */
memcpy(&rep->iov_info, recv_buf, psm2_status->nbytes);
rep->user_context = psm2_status->context;
rep->buf = recv_buf;
rep->no_completion = 0;
rep->iov_done = 0;
rep->bytes_received = 0;
rep->msg_length = 0;
rep->error_code = PSM2_OK;
fi_context = &rep->fi_context;
PSMX2_CTXT_TYPE(fi_context) = PSMX2_IOV_RECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = rep;
PSMX2_CTXT_EP(fi_context) = ep;
/* use the same tag, with IOV bit cleared, and seq_num added */
psm2_tag = psm2_status->msg_tag;
psm2_tag.tag2 &= ~PSMX2_IOV_BIT;
PSMX2_TAG32_SET_SEQ(psm2_tag.tag2, rep->iov_info.seq_num);
rep->comp_flag = (psm2_tag.tag2 & PSMX2_MSG_BIT) ? FI_MSG : FI_TAGGED;
if (psm2_tag.tag2 & PSMX2_IMM_BIT)
rep->comp_flag |= FI_REMOTE_CQ_DATA;
/* match every bit of the tag */
PSMX2_SET_TAG(psm2_tagsel, -1UL, -1);
for (i=0; i<rep->iov_info.count; i++) {
if (recv_len) {
len = MIN(recv_len, rep->iov_info.len[i]);
err = psm2_mq_irecv2(ep->domain->psm2_mq,
psm2_status->msg_peer,
&psm2_tag, &psm2_tagsel,
0/*flag*/, recv_buf, len,
(void *)fi_context, &psm2_req);
if (err) {
psm2_status->error_code = err;
return psmx2_errno(psm2_status->error_code);
}
recv_buf += len;
recv_len -= len;
} else {
/* recv buffer full, pust empty recvs */
err = psm2_mq_irecv2(ep->domain->psm2_mq,
psm2_status->msg_peer,
&psm2_tag, &psm2_tagsel,
0/*flag*/, NULL, 0,
(void *)fi_context, &psm2_req);
if (err) {
psm2_status->error_code = err;
return psmx2_errno(psm2_status->error_code);
}
}
}
return 0;
}
ssize_t psmx2_recv_generic(struct fid_ep *ep, void *buf, size_t len,
void *desc, fi_addr_t src_addr, void *context,
uint64_t flags)
{
struct psmx2_fid_ep *ep_priv;
struct psmx2_fid_av *av;
psm2_epaddr_t psm2_epaddr;
uint8_t vlane;
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
uint32_t tag32, tagsel32;
struct fi_context *fi_context;
int recv_flag = 0;
size_t idx;
int err;
ep_priv = container_of(ep, struct psmx2_fid_ep, ep);
if (flags & FI_TRIGGER) {
struct psmx2_trigger *trigger;
struct fi_triggered_context *ctxt = context;
trigger = calloc(1, sizeof(*trigger));
if (!trigger)
return -FI_ENOMEM;
trigger->op = PSMX2_TRIGGERED_RECV;
trigger->cntr = container_of(ctxt->trigger.threshold.cntr,
struct psmx2_fid_cntr, cntr);
trigger->threshold = ctxt->trigger.threshold.threshold;
trigger->recv.ep = ep;
trigger->recv.buf = buf;
trigger->recv.len = len;
trigger->recv.desc = desc;
trigger->recv.src_addr = src_addr;
trigger->recv.context = context;
trigger->recv.flags = flags & ~FI_TRIGGER;
psmx2_cntr_add_trigger(trigger->cntr, trigger);
return 0;
}
if ((ep_priv->caps & FI_DIRECTED_RECV) && src_addr != FI_ADDR_UNSPEC) {
av = ep_priv->av;
if (av && av->type == FI_AV_TABLE) {
idx = (size_t)src_addr;
if (idx >= av->last)
return -FI_EINVAL;
psm2_epaddr = av->epaddrs[idx];
vlane = av->vlanes[idx];
} else {
psm2_epaddr = PSMX2_ADDR_TO_EP(src_addr);
vlane = PSMX2_ADDR_TO_VL(src_addr);
}
tag32 = PSMX2_TAG32(PSMX2_MSG_BIT, vlane, ep_priv->vlane);
tagsel32 = ~(PSMX2_IOV_BIT | PSMX2_IMM_BIT);
} else {
psm2_epaddr = 0;
tag32 = PSMX2_TAG32(PSMX2_MSG_BIT, 0, ep_priv->vlane);
tagsel32 = ~(PSMX2_IOV_BIT | PSMX2_IMM_BIT | PSMX2_SRC_BITS);
}
PSMX2_SET_TAG(psm2_tag, 0ULL, tag32);
PSMX2_SET_TAG(psm2_tagsel, 0ULL, tagsel32);
if (ep_priv->recv_selective_completion && !(flags & FI_COMPLETION)) {
fi_context = psmx2_ep_get_op_context(ep_priv);
PSMX2_CTXT_TYPE(fi_context) = PSMX2_NOCOMP_RECV_CONTEXT_ALLOC;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_SIZE(fi_context) = len;
} else {
if (!context)
return -FI_EINVAL;
fi_context = context;
if (flags & FI_MULTI_RECV) {
struct psmx2_multi_recv *req;
req = calloc(1, sizeof(*req));
if (!req)
return -FI_ENOMEM;
req->src_addr = psm2_epaddr;
req->tag = psm2_tag;
req->tagsel = psm2_tagsel;
req->flag = recv_flag;
req->buf = buf;
req->len = len;
req->offset = 0;
req->min_buf_size = ep_priv->min_multi_recv;
req->context = fi_context;
PSMX2_CTXT_TYPE(fi_context) = PSMX2_MULTI_RECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = req;
if (len > PSMX2_MAX_MSG_SIZE)
len = PSMX2_MAX_MSG_SIZE;
} else {
PSMX2_CTXT_TYPE(fi_context) = PSMX2_RECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = buf;
}
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_SIZE(fi_context) = len;
}
err = psm2_mq_irecv2(ep_priv->domain->psm2_mq, psm2_epaddr,
&psm2_tag, &psm2_tagsel, recv_flag, buf, len,
(void *)fi_context, &psm2_req);
if (err != PSM2_OK)
return psmx2_errno(err);
if (fi_context == context)
PSMX2_CTXT_REQ(fi_context) = psm2_req;
return 0;
}
ssize_t psmx2_tagged_recv_generic(struct fid_ep *ep, void *buf,
size_t len, void *desc,
fi_addr_t src_addr,
uint64_t tag, uint64_t ignore,
void *context, uint64_t flags)
{
struct psmx2_fid_ep *ep_priv;
struct psmx2_fid_av *av;
psm2_epaddr_t psm2_epaddr;
uint8_t vlane;
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
uint32_t tag32, tagsel32;
struct fi_context *fi_context;
size_t idx;
int err;
ep_priv = container_of(ep, struct psmx2_fid_ep, ep);
if (flags & FI_PEEK)
return psmx2_tagged_peek_generic(ep, buf, len, desc,
src_addr, tag, ignore,
context, flags);
if (flags & FI_TRIGGER) {
struct psmx2_trigger *trigger;
struct fi_triggered_context *ctxt = context;
trigger = calloc(1, sizeof(*trigger));
if (!trigger)
return -FI_ENOMEM;
trigger->op = PSMX2_TRIGGERED_TRECV;
trigger->cntr = container_of(ctxt->trigger.threshold.cntr,
struct psmx2_fid_cntr, cntr);
trigger->threshold = ctxt->trigger.threshold.threshold;
trigger->trecv.ep = ep;
trigger->trecv.buf = buf;
trigger->trecv.len = len;
trigger->trecv.desc = desc;
trigger->trecv.src_addr = src_addr;
trigger->trecv.tag = tag;
trigger->trecv.ignore = ignore;
trigger->trecv.context = context;
trigger->trecv.flags = flags & ~FI_TRIGGER;
psmx2_cntr_add_trigger(trigger->cntr, trigger);
return 0;
}
if (flags & FI_CLAIM) {
if (!context)
return -FI_EINVAL;
if (flags & FI_DISCARD) {
psm2_mq_status2_t psm2_status;
struct psmx2_cq_event *event;
fi_context = context;
psm2_req = PSMX2_CTXT_REQ(fi_context);
err = psm2_mq_imrecv(ep_priv->trx_ctxt->psm2_mq, 0,
NULL, 0, context, &psm2_req);
if (err != PSM2_OK)
return psmx2_errno(err);
psm2_mq_wait2(&psm2_req, &psm2_status);
if (ep_priv->recv_cq &&
(!ep_priv->recv_selective_completion || (flags & FI_COMPLETION))) {
tag = PSMX2_GET_TAG64(psm2_status.msg_tag);
event = psmx2_cq_create_event(
ep_priv->recv_cq,
context, /* op_context */
NULL, /* buf */
flags|FI_RECV|FI_TAGGED,/* flags */
0, /* len */
0, /* data */
tag, /* tag */
0, /* olen */
0); /* err */
if (!event)
return -FI_ENOMEM;
vlane = PSMX2_TAG32_GET_SRC(psm2_status.msg_tag.tag2);
event->source_is_valid = 1;
event->source = PSMX2_EP_TO_ADDR(psm2_status.msg_peer, vlane);
event->source_av = ep_priv->av;
psmx2_cq_enqueue_event(ep_priv->recv_cq, event);
}
if (ep_priv->recv_cntr)
psmx2_cntr_inc(ep_priv->recv_cntr);
return 0;
}
fi_context = context;
psm2_req = PSMX2_CTXT_REQ(fi_context);
PSMX2_CTXT_TYPE(fi_context) = PSMX2_TRECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_EP(fi_context) = ep_priv;
err = psm2_mq_imrecv(ep_priv->trx_ctxt->psm2_mq, 0,
buf, len, context, &psm2_req);
if (err != PSM2_OK)
return psmx2_errno(err);
PSMX2_CTXT_REQ(fi_context) = psm2_req;
return 0;
}
if (ep_priv->recv_selective_completion && !(flags & FI_COMPLETION)) {
fi_context = psmx2_ep_get_op_context(ep_priv);
PSMX2_CTXT_TYPE(fi_context) = PSMX2_NOCOMP_RECV_CONTEXT_ALLOC;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_SIZE(fi_context) = len;
} else {
if (!context)
return -FI_EINVAL;
fi_context = context;
PSMX2_CTXT_TYPE(fi_context) = PSMX2_TRECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_SIZE(fi_context) = len;
}
if ((ep_priv->caps & FI_DIRECTED_RECV) && src_addr != FI_ADDR_UNSPEC) {
av = ep_priv->av;
if (av && PSMX2_SEP_ADDR_TEST(src_addr)) {
psm2_epaddr = psmx2_av_translate_sep(av, ep_priv->trx_ctxt, src_addr);
vlane = 0;
} else if (av && av->type == FI_AV_TABLE) {
idx = (size_t)src_addr;
if (idx >= av->last)
return -FI_EINVAL;
psm2_epaddr = av->epaddrs[idx];
vlane = av->vlanes[idx];
} else {
psm2_epaddr = PSMX2_ADDR_TO_EP(src_addr);
vlane = PSMX2_ADDR_TO_VL(src_addr);
}
tag32 = PSMX2_TAG32(0, vlane, ep_priv->vlane);
tagsel32 = ~PSMX2_IOV_BIT;
} else {
psm2_epaddr = 0;
tag32 = PSMX2_TAG32(0, 0, ep_priv->vlane);
tagsel32 = ~(PSMX2_IOV_BIT | PSMX2_SRC_BITS);
}
PSMX2_SET_TAG(psm2_tag, tag, tag32);
PSMX2_SET_TAG(psm2_tagsel, ~ignore, tagsel32);
err = psm2_mq_irecv2(ep_priv->trx_ctxt->psm2_mq, psm2_epaddr,
&psm2_tag, &psm2_tagsel, 0, buf, len,
(void *)fi_context, &psm2_req);
if (err != PSM2_OK)
return psmx2_errno(err);
if (fi_context == context)
PSMX2_CTXT_REQ(fi_context) = psm2_req;
return 0;
}
ssize_t psmx2_tagged_recv_generic(struct fid_ep *ep, void *buf,
size_t len, void *desc,
fi_addr_t src_addr,
uint64_t tag, uint64_t ignore,
void *context, uint64_t flags)
{
struct psmx2_fid_ep *ep_priv;
struct psmx2_fid_av *av;
psm2_epaddr_t psm2_epaddr;
uint8_t vlane;
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
uint32_t tag32, tagsel32;
struct fi_context *fi_context;
size_t idx;
int err;
ep_priv = container_of(ep, struct psmx2_fid_ep, ep);
if (flags & FI_PEEK)
return psmx2_tagged_peek_generic(ep, buf, len, desc,
src_addr, tag, ignore,
context, flags);
if (flags & FI_TRIGGER) {
struct psmx2_trigger *trigger;
struct fi_triggered_context *ctxt = context;
trigger = calloc(1, sizeof(*trigger));
if (!trigger)
return -FI_ENOMEM;
trigger->op = PSMX2_TRIGGERED_TRECV;
trigger->cntr = container_of(ctxt->trigger.threshold.cntr,
struct psmx2_fid_cntr, cntr);
trigger->threshold = ctxt->trigger.threshold.threshold;
trigger->trecv.ep = ep;
trigger->trecv.buf = buf;
trigger->trecv.len = len;
trigger->trecv.desc = desc;
trigger->trecv.src_addr = src_addr;
trigger->trecv.tag = tag;
trigger->trecv.ignore = ignore;
trigger->trecv.context = context;
trigger->trecv.flags = flags & ~FI_TRIGGER;
psmx2_cntr_add_trigger(trigger->cntr, trigger);
return 0;
}
if (flags & FI_CLAIM) {
if (!context)
return -FI_EINVAL;
/* TODO: handle FI_DISCARD */
fi_context = context;
psm2_req = PSMX2_CTXT_REQ(fi_context);
PSMX2_CTXT_TYPE(fi_context) = PSMX2_TRECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_EP(fi_context) = ep_priv;
err = psm2_mq_imrecv(ep_priv->domain->psm2_mq, 0,
buf, len, context, &psm2_req);
if (err != PSM2_OK)
return psmx2_errno(err);
PSMX2_CTXT_REQ(fi_context) = psm2_req;
return 0;
}
if (ep_priv->recv_selective_completion && !(flags & FI_COMPLETION)) {
fi_context = psmx2_ep_get_op_context(ep_priv);
PSMX2_CTXT_TYPE(fi_context) = PSMX2_NOCOMP_RECV_CONTEXT_ALLOC;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_SIZE(fi_context) = len;
} else {
if (!context)
return -FI_EINVAL;
fi_context = context;
PSMX2_CTXT_TYPE(fi_context) = PSMX2_TRECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_SIZE(fi_context) = len;
}
if ((ep_priv->caps & FI_DIRECTED_RECV) && src_addr != FI_ADDR_UNSPEC) {
av = ep_priv->av;
if (av && av->type == FI_AV_TABLE) {
idx = (size_t)src_addr;
if (idx >= av->last)
return -FI_EINVAL;
psm2_epaddr = av->epaddrs[idx];
vlane = av->vlanes[idx];
} else {
psm2_epaddr = PSMX2_ADDR_TO_EP(src_addr);
vlane = PSMX2_ADDR_TO_VL(src_addr);
}
tag32 = PSMX2_TAG32(0, vlane, ep_priv->vlane);
tagsel32 = ~PSMX2_IOV_BIT;
} else {
psm2_epaddr = 0;
tag32 = PSMX2_TAG32(0, 0, ep_priv->vlane);
tagsel32 = ~(PSMX2_IOV_BIT | PSMX2_SRC_BITS);
}
PSMX2_SET_TAG(psm2_tag, tag, tag32);
PSMX2_SET_TAG(psm2_tagsel, ~ignore, tagsel32);
err = psm2_mq_irecv2(ep_priv->domain->psm2_mq, psm2_epaddr,
&psm2_tag, &psm2_tagsel, 0, buf, len,
(void *)fi_context, &psm2_req);
if (err != PSM2_OK)
return psmx2_errno(err);
if (fi_context == context)
PSMX2_CTXT_REQ(fi_context) = psm2_req;
return 0;
}
int psmx2_handle_sendv_req(struct psmx2_fid_ep *ep,
PSMX2_STATUS_TYPE *status,
int multi_recv)
{
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
struct psmx2_sendv_reply *rep;
struct psmx2_multi_recv *recv_req;
struct fi_context *fi_context;
struct fi_context *recv_context;
int i, err;
uint8_t *recv_buf;
size_t recv_len, len;
if (PSMX2_STATUS_ERROR(status) != PSM2_OK)
return psmx2_errno(PSMX2_STATUS_ERROR(status));
rep = malloc(sizeof(*rep));
if (!rep) {
PSMX2_STATUS_ERROR(status) = PSM2_NO_MEMORY;
return -FI_ENOMEM;
}
recv_context = PSMX2_STATUS_CONTEXT(status);
if (multi_recv) {
recv_req = PSMX2_CTXT_USER(recv_context);
recv_buf = recv_req->buf + recv_req->offset;
recv_len = recv_req->len - recv_req->offset;
rep->multi_recv = 1;
} else {
recv_buf = PSMX2_CTXT_USER(recv_context);
recv_len = PSMX2_CTXT_SIZE(recv_context);
rep->multi_recv = 0;
}
/* assert(PSMX2_STATUS_RCVLEN(status) <= PSMX2_IOV_BUF_SIZE); */
memcpy(&rep->iov_info, recv_buf, PSMX2_STATUS_RCVLEN(status));
rep->user_context = PSMX2_STATUS_CONTEXT(status);
rep->tag = PSMX2_STATUS_TAG(status);
rep->buf = recv_buf;
rep->no_completion = 0;
rep->iov_done = 0;
rep->bytes_received = 0;
rep->msg_length = 0;
rep->error_code = PSM2_OK;
fi_context = &rep->fi_context;
PSMX2_CTXT_TYPE(fi_context) = PSMX2_IOV_RECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = rep;
PSMX2_CTXT_EP(fi_context) = ep;
rep->comp_flag = PSMX2_IS_MSG(PSMX2_GET_FLAGS(rep->tag)) ? FI_MSG : FI_TAGGED;
if (PSMX2_HAS_IMM(PSMX2_GET_FLAGS(rep->tag)))
rep->comp_flag |= FI_REMOTE_CQ_DATA;
/* IOV payload uses a sequence number in place of a tag. */
PSMX2_SET_TAG(psm2_tag, rep->iov_info.seq_num, 0, PSMX2_TYPE_IOV_PAYLOAD);
PSMX2_SET_MASK(psm2_tagsel, PSMX2_MATCH_ALL, PSMX2_TYPE_MASK);
for (i=0; i<rep->iov_info.count; i++) {
if (recv_len) {
len = MIN(recv_len, rep->iov_info.len[i]);
err = psm2_mq_irecv2(ep->rx->psm2_mq,
PSMX2_STATUS_PEER(status),
&psm2_tag, &psm2_tagsel,
0/*flag*/, recv_buf, len,
(void *)fi_context, &psm2_req);
if (err) {
PSMX2_STATUS_ERROR(status) = err;
return psmx2_errno(err);
}
recv_buf += len;
recv_len -= len;
} else {
/* recv buffer full, post empty recvs */
err = psm2_mq_irecv2(ep->rx->psm2_mq,
PSMX2_STATUS_PEER(status),
&psm2_tag, &psm2_tagsel,
0/*flag*/, NULL, 0,
(void *)fi_context, &psm2_req);
if (err) {
PSMX2_STATUS_ERROR(status) = err;
return psmx2_errno(err);
}
}
}
if (multi_recv && recv_len < recv_req->min_buf_size)
rep->comp_flag |= FI_MULTI_RECV;
return 0;
}
ssize_t psmx2_recv_generic(struct fid_ep *ep, void *buf, size_t len,
void *desc, fi_addr_t src_addr, void *context,
uint64_t flags)
{
struct psmx2_fid_ep *ep_priv;
struct psmx2_fid_av *av;
psm2_epaddr_t psm2_epaddr;
psm2_mq_req_t psm2_req;
psm2_mq_tag_t psm2_tag, psm2_tagsel;
struct fi_context *fi_context;
int recv_flag = 0;
int err;
int enable_completion;
ep_priv = container_of(ep, struct psmx2_fid_ep, ep);
if (flags & FI_TRIGGER)
return psmx2_trigger_queue_recv(ep, buf, len, desc, src_addr,
context, flags);
if ((ep_priv->caps & FI_DIRECTED_RECV) && src_addr != FI_ADDR_UNSPEC) {
av = ep_priv->av;
assert(av);
psm2_epaddr = psmx2_av_translate_addr(av, ep_priv->rx, src_addr, av->type);
} else {
psm2_epaddr = 0;
}
PSMX2_SET_TAG(psm2_tag, 0ULL, 0, PSMX2_TYPE_MSG);
PSMX2_SET_MASK(psm2_tagsel, PSMX2_MATCH_NONE, PSMX2_TYPE_MASK);
enable_completion = !ep_priv->recv_selective_completion ||
(flags & FI_COMPLETION);
if (enable_completion) {
assert(context);
fi_context = context;
if (flags & FI_MULTI_RECV) {
struct psmx2_multi_recv *req;
req = calloc(1, sizeof(*req));
if (!req)
return -FI_ENOMEM;
req->src_addr = psm2_epaddr;
req->tag = psm2_tag;
req->tagsel = psm2_tagsel;
req->flag = recv_flag;
req->buf = buf;
req->len = len;
req->offset = 0;
req->min_buf_size = ep_priv->min_multi_recv;
req->context = fi_context;
PSMX2_CTXT_TYPE(fi_context) = PSMX2_MULTI_RECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = req;
if (len > PSMX2_MAX_MSG_SIZE)
len = PSMX2_MAX_MSG_SIZE;
} else {
PSMX2_CTXT_TYPE(fi_context) = PSMX2_RECV_CONTEXT;
PSMX2_CTXT_USER(fi_context) = buf;
}
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_SIZE(fi_context) = len;
} else {
PSMX2_EP_GET_OP_CONTEXT(ep_priv, fi_context);
#if !PSMX2_USE_REQ_CONTEXT
PSMX2_CTXT_TYPE(fi_context) = PSMX2_NOCOMP_RECV_CONTEXT;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_SIZE(fi_context) = len;
#endif
}
err = psm2_mq_irecv2(ep_priv->rx->psm2_mq, psm2_epaddr,
&psm2_tag, &psm2_tagsel, recv_flag, buf, len,
(void *)fi_context, &psm2_req);
if (OFI_UNLIKELY(err != PSM2_OK))
return psmx2_errno(err);
if (enable_completion) {
PSMX2_CTXT_REQ(fi_context) = psm2_req;
} else {
#if PSMX2_USE_REQ_CONTEXT
PSMX2_REQ_GET_OP_CONTEXT(psm2_req, fi_context);
PSMX2_CTXT_TYPE(fi_context) = PSMX2_NOCOMP_RECV_CONTEXT;
PSMX2_CTXT_EP(fi_context) = ep_priv;
PSMX2_CTXT_USER(fi_context) = buf;
PSMX2_CTXT_SIZE(fi_context) = len;
#endif
}
return 0;
}
