int efa_getinfo(uint32_t version, const char *node, const char *service,
uint64_t flags, const struct fi_info *hints, struct fi_info **info)
{
int ret;
if (!(flags & FI_SOURCE) && hints && hints->src_addr &&
hints->src_addrlen != EFA_EP_ADDR_LEN)
return -FI_ENODATA;
if (((!node && !service) || (flags & FI_SOURCE)) &&
hints && hints->dest_addr &&
hints->dest_addrlen != EFA_EP_ADDR_LEN)
return -FI_ENODATA;
ret = efa_get_matching_info(version, node, flags, hints, info);
if (ret)
goto out;
ret = efa_set_fi_address(node, service, flags, hints, *info);
if (ret)
goto out;
ofi_alter_info(*info, hints, version);
out:
if (!ret || ret == -FI_ENOMEM || ret == -FI_ENODEV) {
return ret;
} else {
fi_freeinfo(*info);
*info = NULL;
return -FI_ENODATA;
}
}
int ofix_getinfo(uint32_t version, const char *node, const char *service,
uint64_t flags, const struct util_prov *util_prov,
const struct fi_info *hints, ofi_alter_info_t info_to_core,
ofi_alter_info_t info_to_util, struct fi_info **info)
{
struct fi_info *core_info, *util_info, *cur, *tail;
int ret;
ret = ofi_get_core_info(version, node, service, flags, util_prov,
hints, info_to_core, &core_info);
if (ret)
return ret;
*info = tail = NULL;
for (cur = core_info; cur; cur = cur->next) {
ret = ofi_info_to_util(version, util_prov->prov, cur,
info_to_util, &util_info);
if (ret) {
fi_freeinfo(*info);
break;
}
ofi_alter_info(util_info, hints, version);
if (!*info)
*info = util_info;
else
tail->next = util_info;
tail = util_info;
}
fi_freeinfo(core_info);
return ret;
}
int fi_ibv_getinfo(uint32_t version, const char *node, const char *service,
uint64_t flags, struct fi_info *hints, struct fi_info **info)
{
struct rdma_cm_id *id = NULL;
struct rdma_addrinfo *rai;
int ret;
ret = fi_ibv_init_info();
if (ret)
goto out;
ret = fi_ibv_create_ep(node, service, flags, hints, &rai, &id);
if (ret)
goto out;
if (id->verbs) {
ret = fi_ibv_get_matching_info(ibv_get_device_name(id->verbs->device),
hints, rai, info);
} else {
ret = fi_ibv_get_matching_info(NULL, hints, rai, info);
}
ofi_alter_info(*info, hints);
fi_ibv_destroy_ep(rai, &id);
out:
if (!ret || ret == -FI_ENOMEM || ret == -FI_ENODEV)
return ret;
else
return -FI_ENODATA;
}
static struct fi_info *
fi_ibv_eq_cm_getinfo(struct fi_ibv_fabric *fab, struct rdma_cm_event *event,
struct fi_info *pep_info)
{
struct fi_info *info, *fi;
struct fi_ibv_connreq *connreq;
const char *devname = ibv_get_device_name(event->id->verbs->device);
if (strcmp(devname, fab->info->domain_attr->name)) {
fi = fi_ibv_get_verbs_info(fab->all_infos, devname);
if (!fi)
return NULL;
} else {
fi = fab->info;
}
info = fi_dupinfo(fi);
if (!info)
return NULL;
info->fabric_attr->fabric = &fab->util_fabric.fabric_fid;
if (!(info->fabric_attr->prov_name = strdup(VERBS_PROV_NAME)))
goto err;
ofi_alter_info(info, pep_info, fab->util_fabric.fabric_fid.api_version);
info->src_addrlen = fi_ibv_sockaddr_len(rdma_get_local_addr(event->id));
if (!(info->src_addr = malloc(info->src_addrlen)))
goto err;
memcpy(info->src_addr, rdma_get_local_addr(event->id), info->src_addrlen);
info->dest_addrlen = fi_ibv_sockaddr_len(rdma_get_peer_addr(event->id));
if (!(info->dest_addr = malloc(info->dest_addrlen)))
goto err;
memcpy(info->dest_addr, rdma_get_peer_addr(event->id), info->dest_addrlen);
VERBS_INFO(FI_LOG_CORE, "src_addr: %s:%d\n",
inet_ntoa(((struct sockaddr_in *)info->src_addr)->sin_addr),
ntohs(((struct sockaddr_in *)info->src_addr)->sin_port));
VERBS_INFO(FI_LOG_CORE, "dst_addr: %s:%d\n",
inet_ntoa(((struct sockaddr_in *)info->dest_addr)->sin_addr),
ntohs(((struct sockaddr_in *)info->dest_addr)->sin_port));
connreq = calloc(1, sizeof *connreq);
if (!connreq)
goto err;
connreq->handle.fclass = FI_CLASS_CONNREQ;
connreq->id = event->id;
info->handle = &connreq->handle;
return info;
err:
fi_freeinfo(info);
return NULL;
}
int ofix_getinfo(uint32_t version, const char *node, const char *service,
uint64_t flags, const struct util_prov *util_prov,
struct fi_info *hints,
ofi_alter_info_t alter_layer_info,
ofi_alter_info_t alter_base_info,
int get_base_info, struct fi_info **info)
{
struct fi_info *base_hints = NULL, *base_info;
struct fi_info *temp = NULL, *fi, *tail = NULL;
int ret;
ret = ofi_check_info(util_prov, hints, FI_MATCH_PREFIX);
if (ret)
goto err1;
ret = ofix_alter_layer_info(util_prov->prov, util_prov->info, hints,
alter_layer_info, &base_hints);
if (ret)
goto err1;
ret = fi_getinfo(version, node, service, flags, base_hints, &base_info);
if (ret)
goto err2;
if (get_base_info) {
*info = base_info;
} else {
for (fi = base_info; fi; fi = fi->next) {
ret = ofix_alter_base_info(util_prov->prov, util_prov->info,
fi, alter_base_info, &temp);
if (ret)
goto err3;
ofi_alter_info(temp, hints);
if (!tail)
*info = temp;
else
tail->next = temp;
tail = temp;
}
fi_freeinfo(base_info);
}
fi_freeinfo(base_hints);
return 0;
err3:
fi_freeinfo(*info);
err2:
fi_freeinfo(base_hints);
err1:
return -FI_ENODATA;
}
int fi_ibv_getinfo(uint32_t version, const char *node, const char *service,
uint64_t flags, struct fi_info *hints, struct fi_info **info)
{
struct rdma_cm_id *id = NULL;
struct rdma_addrinfo *rai;
int ret;
ret = fi_ibv_init_info();
if (ret)
goto out;
ret = fi_ibv_create_ep(node, service, flags, hints, &rai, &id);
if (ret)
goto out;
if (id->verbs) {
ret = fi_ibv_get_matching_info(ibv_get_device_name(id->verbs->device),
hints, rai, info);
} else {
ret = fi_ibv_get_matching_info(NULL, hints, rai, info);
if (!ret && !(flags & FI_SOURCE) && !node
&& (!hints || (!hints->src_addr && !hints->dest_addr))) {
ret = fi_ibv_getifaddrs(service, flags, *info);
if (ret) {
fi_freeinfo(*info);
fi_ibv_destroy_ep(rai, &id);
goto out;
}
}
}
if (!ret) {
ret = fi_ibv_rdm_remove_nonaddr_info(info);
}
ofi_alter_info(*info, hints);
fi_ibv_destroy_ep(rai, &id);
out:
if (!ret || ret == -FI_ENOMEM || ret == -FI_ENODEV)
return ret;
else
return -FI_ENODATA;
}
int fi_ibv_getinfo(uint32_t version, const char *node, const char *service,
uint64_t flags, struct fi_info *hints, struct fi_info **info)
{
struct rdma_cm_id *id = NULL;
struct rdma_addrinfo *rai;
struct fi_ibv_rdm_cm rdm_cm;
int ret;
ret = fi_ibv_init_info();
if (ret)
goto out;
if (FI_IBV_EP_TYPE_IS_RDM(hints)) {
memset(&rdm_cm, 0, sizeof(struct fi_ibv_rdm_cm));
ret = fi_ibv_create_ep(node, service, flags, hints, &rai,
&(rdm_cm.listener));
id = rdm_cm.listener;
} else {
ret = fi_ibv_create_ep(node, service, flags, hints, &rai, &id);
}
if (ret)
goto out;
if (id->verbs) {
ret = fi_ibv_get_matching_info(ibv_get_device_name(id->verbs->device),
hints, rai, info);
} else {
ret = fi_ibv_get_matching_info(NULL, hints, rai, info);
}
ofi_alter_info(*info, hints);
if (hints && hints->ep_attr)
fi_ibv_destroy_ep(hints->ep_attr->type, rai,
FI_IBV_EP_TYPE_IS_RDM(hints) ? &(rdm_cm.listener) : &id);
out:
if (!ret || ret == -FI_ENOMEM || ret == -FI_ENODEV)
return ret;
else
return -FI_ENODATA;
}
int util_getinfo(const struct fi_provider *prov, uint32_t version,
const char *node, const char *service, uint64_t flags,
const struct fi_info *prov_info, struct fi_info *hints,
struct fi_info **info)
{
struct util_fabric *fabric;
struct util_domain *domain;
struct dlist_entry *item;
int ret, copy_dest;
FI_DBG(prov, FI_LOG_CORE, "checking info\n");
if ((flags & FI_SOURCE) && !node && !service) {
FI_INFO(prov, FI_LOG_CORE,
"FI_SOURCE set, but no node or service\n");
return -FI_EINVAL;
}
ret = fi_check_info(prov, prov_info, hints, FI_MATCH_EXACT);
if (ret)
return ret;
*info = fi_dupinfo(prov_info);
if (!*info) {
FI_INFO(prov, FI_LOG_CORE, "cannot copy info\n");
return -FI_ENOMEM;
}
ofi_alter_info(*info, hints);
fabric = fi_fabric_find((*info)->fabric_attr->name);
if (fabric) {
FI_DBG(prov, FI_LOG_CORE, "Found opened fabric\n");
(*info)->fabric_attr->fabric = &fabric->fabric_fid;
fastlock_acquire(&fabric->lock);
item = dlist_find_first_match(&fabric->domain_list,
util_find_domain, *info);
if (item) {
FI_DBG(prov, FI_LOG_CORE, "Found open domain\n");
domain = container_of(item, struct util_domain,
list_entry);
(*info)->domain_attr->domain = &domain->domain_fid;
}
fastlock_release(&fabric->lock);
}
if (flags & FI_SOURCE) {
ret = ofi_get_addr((*info)->addr_format, flags,
node, service, &(*info)->src_addr,
&(*info)->src_addrlen);
if (ret) {
FI_INFO(prov, FI_LOG_CORE,
"source address not available\n");
goto err;
}
copy_dest = (hints && hints->dest_addr);
} else {
if (node || service) {
copy_dest = 0;
ret = ofi_get_addr((*info)->addr_format, flags,
node, service, &(*info)->dest_addr,
&(*info)->dest_addrlen);
if (ret) {
FI_INFO(prov, FI_LOG_CORE,
"cannot resolve dest address\n");
goto err;
}
} else {
copy_dest = (hints && hints->dest_addr);
}
if (hints && hints->src_addr) {
(*info)->src_addr = mem_dup(hints->src_addr,
hints->src_addrlen);
if (!(*info)->src_addr) {
ret = -FI_ENOMEM;
goto err;
}
(*info)->src_addrlen = hints->src_addrlen;
}
}
if (copy_dest) {
(*info)->dest_addr = mem_dup(hints->dest_addr,
hints->dest_addrlen);
if (!(*info)->dest_addr) {
ret = -FI_ENOMEM;
goto err;
}
(*info)->dest_addrlen = hints->dest_addrlen;
}
if ((*info)->dest_addr && !(*info)->src_addr) {
ret = ofi_get_src_addr((*info)->addr_format, (*info)->dest_addr,
(*info)->dest_addrlen, &(*info)->src_addr,
&(*info)->src_addrlen);
if (ret) {
FI_INFO(prov, FI_LOG_CORE,
"cannot resolve source address\n");
}
}
return 0;
err:
fi_freeinfo(*info);
return ret;
}
