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; }