static int alloc_ep_res(struct fi_info *fi)
{
struct fi_poll_attr poll_attr;
int ret;
ret = ft_alloc_bufs();
if (ret)
return ret;
ret = ft_alloc_active_res(fi);
if (ret)
return ret;
memset(&poll_attr, 0, sizeof poll_attr);
ret = fi_poll_open(domain, &poll_attr, &pollset);
if (ret) {
FT_PRINTERR("fi_poll_open", ret);
return ret;
}
ret = fi_poll_add(pollset, &txcq->fid, 0);
if (ret) {
FT_PRINTERR("fi_poll_add", ret);
return ret;
}
ret = fi_poll_add(pollset, &rxcq->fid, 0);
if (ret) {
FT_PRINTERR("fi_poll_add", ret);
return ret;
}
return 0;
}
int ofi_eq_create(struct fid_fabric *fabric_fid, struct fi_eq_attr *attr,
struct fid_eq **eq_fid, void *context)
{
struct util_fabric *fabric;
struct util_eq *eq;
int ret;
fabric = container_of(fabric_fid, struct util_fabric, fabric_fid);
ret = util_verify_eq_attr(fabric->prov, attr);
if (ret)
return ret;
eq = calloc(1, sizeof(*eq));
if (!eq)
return -FI_ENOMEM;
eq->fabric = fabric;
eq->prov = fabric->prov;
ret = util_eq_init(fabric_fid, eq, attr);
if (ret) {
free(eq);
return ret;
}
eq->eq_fid.fid.fclass = FI_CLASS_EQ;
eq->eq_fid.fid.context = context;
eq->eq_fid.fid.ops = &util_eq_fi_ops;
eq->eq_fid.ops = &util_eq_ops;
ofi_atomic_inc32(&fabric->ref);
/* EQ must be fully operational before adding to wait set */
if (eq->wait) {
ret = fi_poll_add(&eq->wait->pollset->poll_fid,
&eq->eq_fid.fid, 0);
if (ret) {
util_eq_close(&eq->eq_fid.fid);
return ret;
}
}
*eq_fid = &eq->eq_fid;
return 0;
}
int psmx_cntr_open(struct fid_domain *domain, struct fi_cntr_attr *attr,
struct fid_cntr **cntr, void *context)
{
struct psmx_fid_domain *domain_priv;
struct psmx_fid_cntr *cntr_priv;
struct fid_wait *wait = NULL;
struct fi_wait_attr wait_attr;
int wait_is_local = 0;
int events;
uint64_t flags;
int err;
events = FI_CNTR_EVENTS_COMP;
flags = 0;
domain_priv = container_of(domain, struct psmx_fid_domain,
util_domain.domain_fid);
switch (attr->events) {
case FI_CNTR_EVENTS_COMP:
events = attr->events;
break;
default:
FI_INFO(&psmx_prov, FI_LOG_CQ,
"attr->events=%d, supported=%d\n",
attr->events, FI_CNTR_EVENTS_COMP);
return -FI_EINVAL;
}
switch (attr->wait_obj) {
case FI_WAIT_NONE:
case FI_WAIT_UNSPEC:
break;
case FI_WAIT_SET:
if (!attr->wait_set) {
FI_INFO(&psmx_prov, FI_LOG_CQ,
"FI_WAIT_SET is specified but attr->wait_set is NULL\n");
return -FI_EINVAL;
}
wait = attr->wait_set;
break;
case FI_WAIT_FD:
case FI_WAIT_MUTEX_COND:
wait_attr.wait_obj = attr->wait_obj;
wait_attr.flags = 0;
err = fi_wait_open(&domain_priv->fabric->util_fabric.fabric_fid,
&wait_attr, (struct fid_wait **)&wait);
if (err)
return err;
wait_is_local = 1;
break;
default:
FI_INFO(&psmx_prov, FI_LOG_CQ,
"attr->wait_obj=%d, supported=%d...%d\n",
attr->wait_obj, FI_WAIT_NONE, FI_WAIT_MUTEX_COND);
return -FI_EINVAL;
}
cntr_priv = (struct psmx_fid_cntr *) calloc(1, sizeof *cntr_priv);
if (!cntr_priv) {
err = -FI_ENOMEM;
goto fail;
}
cntr_priv->domain = domain_priv;
cntr_priv->events = events;
if (wait)
cntr_priv->wait = container_of(wait, struct util_wait, wait_fid);
cntr_priv->wait_is_local = wait_is_local;
cntr_priv->flags = flags;
cntr_priv->cntr.fid.fclass = FI_CLASS_CNTR;
cntr_priv->cntr.fid.context = context;
cntr_priv->cntr.fid.ops = &psmx_fi_ops;
cntr_priv->cntr.ops = &psmx_cntr_ops;
ofi_atomic_initialize64(&cntr_priv->counter, 0);
ofi_atomic_initialize64(&cntr_priv->error_counter, 0);
pthread_mutex_init(&cntr_priv->trigger_lock, NULL);
if (wait)
fi_poll_add(&cntr_priv->wait->pollset->poll_fid,
&cntr_priv->cntr.fid, 0);
psmx_domain_acquire(domain_priv);
*cntr = &cntr_priv->cntr;
return 0;
fail:
if (wait && wait_is_local)
fi_close(&wait->fid);
return err;
}
