int rxm_domain_open(struct fid_fabric *fabric, struct fi_info *info,
struct fid_domain **domain, void *context)
{
int ret;
struct rxm_domain *rxm_domain;
struct rxm_fabric *rxm_fabric;
struct fi_info *msg_info;
rxm_domain = calloc(1, sizeof(*rxm_domain));
if (!rxm_domain)
return -FI_ENOMEM;
rxm_fabric = container_of(fabric, struct rxm_fabric, util_fabric.fabric_fid);
ret = ofi_get_core_info(fabric->api_version, NULL, NULL, 0, &rxm_util_prov,
info, rxm_info_to_core, &msg_info);
if (ret)
goto err1;
/* Force core provider to supply MR key */
if (FI_VERSION_LT(fabric->api_version, FI_VERSION(1, 5)))
msg_info->domain_attr->mr_mode = FI_MR_BASIC;
else
msg_info->domain_attr->mr_mode |= FI_MR_PROV_KEY;
ret = fi_domain(rxm_fabric->msg_fabric, msg_info,
&rxm_domain->msg_domain, context);
if (ret)
goto err2;
ret = ofi_domain_init(fabric, info, &rxm_domain->util_domain, context);
if (ret) {
goto err3;
}
*domain = &rxm_domain->util_domain.domain_fid;
(*domain)->fid.ops = &rxm_domain_fi_ops;
/* Replace MR ops set by ofi_domain_init() */
(*domain)->mr = &rxm_domain_mr_ops;
(*domain)->ops = &rxm_domain_ops;
rxm_domain->mr_local = OFI_CHECK_MR_LOCAL(msg_info->domain_attr->mr_mode) &&
!OFI_CHECK_MR_LOCAL(info->domain_attr->mr_mode);
fi_freeinfo(msg_info);
return 0;
err3:
fi_close(&rxm_domain->msg_domain->fid);
err2:
fi_freeinfo(msg_info);
err1:
free(rxm_domain);
return ret;
}
int udpx_domain_open(struct fid_fabric *fabric, struct fi_info *info,
struct fid_domain **domain, void *context)
{
int ret;
struct util_domain *util_domain;
ret = udpx_check_info(info);
if (ret)
return ret;
util_domain = calloc(1, sizeof(*util_domain));
if (!util_domain)
return -FI_ENOMEM;
ret = ofi_domain_init(fabric, info, util_domain, context);
if (ret)
return ret;
*domain = &util_domain->domain_fid;
(*domain)->fid.ops = &udpx_domain_fi_ops;
(*domain)->ops = &udpx_domain_ops;
return 0;
}
int psmx2_domain_open(struct fid_fabric *fabric, struct fi_info *info,
struct fid_domain **domain, void *context)
{
struct psmx2_fid_fabric *fabric_priv;
struct psmx2_fid_domain *domain_priv;
struct psmx2_ep_name *src_addr = info->src_addr;
int mr_mode = (info->domain_attr->mr_mode & FI_MR_BASIC) ? FI_MR_BASIC : 0;
int err;
FI_INFO(&psmx2_prov, FI_LOG_DOMAIN, "\n");
fabric_priv = container_of(fabric, struct psmx2_fid_fabric,
util_fabric.fabric_fid);
if (!info->domain_attr->name ||
strcmp(info->domain_attr->name, PSMX2_DOMAIN_NAME)) {
err = -FI_EINVAL;
goto err_out;
}
domain_priv = (struct psmx2_fid_domain *) calloc(1, sizeof *domain_priv);
if (!domain_priv) {
err = -FI_ENOMEM;
goto err_out;
}
err = ofi_domain_init(fabric, info, &domain_priv->util_domain, context);
if (err)
goto err_out_free_domain;
/* fclass & context are set in ofi_domain_init */
domain_priv->util_domain.domain_fid.fid.ops = &psmx2_fi_ops;
domain_priv->util_domain.domain_fid.ops = &psmx2_domain_ops;
domain_priv->util_domain.domain_fid.mr = &psmx2_mr_ops;
domain_priv->mr_mode = mr_mode;
domain_priv->mode = info->mode;
domain_priv->caps = PSMX2_CAPS | PSMX2_DOM_CAPS;
domain_priv->fabric = fabric_priv;
domain_priv->progress_thread_enabled =
(info->domain_attr->data_progress == FI_PROGRESS_AUTO);
domain_priv->addr_format = info->addr_format;
if (info->addr_format == FI_ADDR_STR)
src_addr = psmx2_string_to_ep_name(info->src_addr);
err = psmx2_domain_init(domain_priv, src_addr);
if (info->addr_format == FI_ADDR_STR)
free(src_addr);
if (err)
goto err_out_close_domain;
psmx2_fabric_acquire(fabric_priv);
psmx2_lock(&fabric_priv->domain_lock, 1);
dlist_insert_before(&domain_priv->entry, &fabric_priv->domain_list);
psmx2_unlock(&fabric_priv->domain_lock, 1);
*domain = &domain_priv->util_domain.domain_fid;
return 0;
err_out_close_domain:
ofi_domain_close(&domain_priv->util_domain);
err_out_free_domain:
free(domain_priv);
err_out:
return err;
}
int psmx2_domain_open(struct fid_fabric *fabric, struct fi_info *info,
struct fid_domain **domain, void *context)
{
struct psmx2_fid_fabric *fabric_priv;
struct psmx2_fid_domain *domain_priv;
int mr_mode = (info->domain_attr->mr_mode & FI_MR_BASIC) ? FI_MR_BASIC : 0;
int err;
FI_INFO(&psmx2_prov, FI_LOG_DOMAIN, "\n");
if (!psmx2_env.sep)
psmx2_domain_ops.scalable_ep = fi_no_scalable_ep;
fabric_priv = container_of(fabric, struct psmx2_fid_fabric,
util_fabric.fabric_fid);
if (fabric_priv->active_domain) {
if (mr_mode != fabric_priv->active_domain->mr_mode) {
FI_INFO(&psmx2_prov, FI_LOG_DOMAIN,
"mr_mode mismatch: expecting %s\n",
mr_mode ? "FI_MR_SCALABLE" : "FI_MR_BASIC");
return -FI_EINVAL;
}
psmx2_domain_acquire(fabric_priv->active_domain);
*domain = &fabric_priv->active_domain->util_domain.domain_fid;
return 0;
}
if (!info->domain_attr->name ||
strcmp(info->domain_attr->name, PSMX2_DOMAIN_NAME)) {
err = -FI_EINVAL;
goto err_out;
}
domain_priv = (struct psmx2_fid_domain *) calloc(1, sizeof *domain_priv);
if (!domain_priv) {
err = -FI_ENOMEM;
goto err_out;
}
err = ofi_domain_init(fabric, info, &domain_priv->util_domain, context);
if (err)
goto err_out_free_domain;
/* fclass & context are set in ofi_domain_init */
domain_priv->util_domain.domain_fid.fid.ops = &psmx2_fi_ops;
domain_priv->util_domain.domain_fid.ops = &psmx2_domain_ops;
domain_priv->util_domain.domain_fid.mr = &psmx2_mr_ops;
domain_priv->mr_mode = mr_mode;
domain_priv->mode = info->mode;
domain_priv->caps = PSMX2_CAPS | PSMX2_DOM_CAPS;
domain_priv->fabric = fabric_priv;
domain_priv->progress_thread_enabled =
(info->domain_attr->data_progress == FI_PROGRESS_AUTO);
err = psmx2_domain_init(domain_priv, info->src_addr);
if (err)
goto err_out_close_domain;
/* take the reference to count for multiple domain open calls */
psmx2_domain_acquire(fabric_priv->active_domain);
*domain = &domain_priv->util_domain.domain_fid;
return 0;
err_out_close_domain:
ofi_domain_close(&domain_priv->util_domain);
err_out_free_domain:
free(domain_priv);
err_out:
return err;
}
int psmx_domain_open(struct fid_fabric *fabric, struct fi_info *info,
struct fid_domain **domain, void *context)
{
struct psmx_fid_fabric *fabric_priv;
struct psmx_fid_domain *domain_priv;
int err;
FI_INFO(&psmx_prov, FI_LOG_DOMAIN, "\n");
fabric_priv = container_of(fabric, struct psmx_fid_fabric,
util_fabric.fabric_fid);
if (fabric_priv->active_domain) {
psmx_domain_acquire(fabric_priv->active_domain);
*domain = &fabric_priv->active_domain->util_domain.domain_fid;
return 0;
}
if (!info->domain_attr->name ||
strcmp(info->domain_attr->name, PSMX_DOMAIN_NAME)) {
err = -FI_EINVAL;
goto err_out;
}
domain_priv = (struct psmx_fid_domain *) calloc(1, sizeof *domain_priv);
if (!domain_priv) {
err = -FI_ENOMEM;
goto err_out;
}
err = ofi_domain_init(fabric, info, &domain_priv->util_domain, context);
if (err)
goto err_out_free_domain;
/* fclass & context are set in ofi_domain_init */
domain_priv->util_domain.domain_fid.fid.ops = &psmx_fi_ops;
domain_priv->util_domain.domain_fid.ops = &psmx_domain_ops;
domain_priv->util_domain.domain_fid.mr = &psmx_mr_ops;
domain_priv->mr_mode = info->domain_attr->mr_mode;
domain_priv->mode = info->mode;
domain_priv->caps = info->caps;
domain_priv->fabric = fabric_priv;
domain_priv->progress_thread_enabled =
(info->domain_attr->data_progress == FI_PROGRESS_AUTO && psmx_env.prog_thread);
err = psmx_domain_init(domain_priv, info->src_addr);
if (err)
goto err_out_close_domain;
/* tale the reference to count for multiple domain open calls */
psmx_domain_acquire(fabric_priv->active_domain);
*domain = &domain_priv->util_domain.domain_fid;
return 0;
err_out_close_domain:
ofi_domain_close(&domain_priv->util_domain);
err_out_free_domain:
free(domain_priv);
err_out:
return err;
}
int efa_domain_open(struct fid_fabric *fabric_fid, struct fi_info *info,
struct fid_domain **domain_fid, void *context)
{
struct efa_domain *domain;
struct efa_fabric *fabric;
const struct fi_info *fi;
int ret;
fi = efa_get_efa_info(info->domain_attr->name);
if (!fi)
return -FI_EINVAL;
fabric = container_of(fabric_fid, struct efa_fabric,
util_fabric.fabric_fid);
ret = ofi_check_domain_attr(&efa_prov, fabric_fid->api_version,
fi->domain_attr, info);
if (ret)
return ret;
domain = calloc(1, sizeof(*domain));
if (!domain)
return -FI_ENOMEM;
ret = ofi_domain_init(fabric_fid, info, &domain->util_domain,
context);
if (ret)
goto err_free_domain;
domain->info = fi_dupinfo(info);
if (!domain->info) {
ret = -FI_ENOMEM;
goto err_close_domain;
}
domain->rdm = EFA_EP_TYPE_IS_RDM(info);
ret = efa_open_device_by_name(domain, info->domain_attr->name);
if (ret)
goto err_free_info;
domain->pd = efa_cmd_alloc_pd(domain->ctx);
if (!domain->pd) {
ret = -errno;
goto err_free_info;
}
EFA_INFO(FI_LOG_DOMAIN, "Allocated pd[%u].\n", domain->pd->pdn);
domain->util_domain.domain_fid.fid.ops = &efa_fid_ops;
domain->util_domain.domain_fid.ops = &efa_domain_ops;
domain->fab = fabric;
*domain_fid = &domain->util_domain.domain_fid;
if (efa_mr_cache_enable) {
domain->notifier = efa_mem_notifier;
if (!domain->notifier) {
EFA_DBG(FI_LOG_MR,
"efa_mem_notifier is not initialized.\n");
ret = -FI_ENOMEM;
goto err_free_pd;
}
domain->monitor.subscribe = efa_monitor_subscribe;
domain->monitor.unsubscribe = efa_monitor_unsubscribe;
ofi_monitor_init(&domain->monitor);
domain->cache.max_cached_cnt = efa_mr_max_cached_count;
domain->cache.max_cached_size = efa_mr_max_cached_size;
domain->cache.merge_regions = efa_mr_cache_merge_regions;
domain->cache.entry_data_size = sizeof(struct efa_mem_desc);
domain->cache.add_region = efa_mr_cache_entry_reg;
domain->cache.delete_region = efa_mr_cache_entry_dereg;
ret = ofi_mr_cache_init(&domain->util_domain, &domain->monitor,
&domain->cache);
if (OFI_UNLIKELY(ret))
goto err_cleanup_monitor;
domain->util_domain.domain_fid.mr = &efa_domain_mr_cache_ops;
} else {
domain->util_domain.domain_fid.mr = &efa_domain_mr_ops;
}
return 0;
err_cleanup_monitor:
ofi_monitor_cleanup(&domain->monitor);
err_free_pd:
ret = efa_cmd_dealloc_pd(domain->pd);
if (ret) {
EFA_INFO_ERRNO(FI_LOG_DOMAIN, "efa_cmd_dealloc_pd", ret);
}
domain->pd = NULL;
err_free_info:
fi_freeinfo(domain->info);
err_close_domain:
ofi_domain_close(&domain->util_domain);
err_free_domain:
free(domain);
return ret;
}