void do_valid_fi_getinfo_with_fas(void)
{
int i, ret;
char *fas = calloc(GNIX_FI_ADDR_STR_LEN, sizeof(char));
struct gnix_ep_name ep_name;
/*
* This test ensures the gni provider can set addresses properly with
* FI_ADDR_STR and no flags set.
*/
for (i = 0; i < NUMEPS; i++) {
generate_rand_fas(&fas);
ret = fi_getinfo(fi_version(), fas, NULL, 0, hints, &fi[i]);
cr_assert(ret == FI_SUCCESS, "fi_getinfo returned: %s",
fi_strerror(-ret));
dbg_printf(BLUE "fi[%d]->dest_addr = %s\n" COLOR_RESET,
i, (char *) fi[i]->dest_addr);
fas_to_ep_name(fas, &ep_name);
check_ep_name(((struct gnix_ep_name *) fi[i]->dest_addr)[0],
ep_name);
fi_freeinfo(fi[i]);
}
/*
* This test ensures the gni provider can set addresses properly with
* FI_ADDR_STR and the FI_SOURCE set.
*/
for (i = 0; i < NUMEPS; i++) {
generate_rand_fas(&fas);
ret = fi_getinfo(fi_version(), fas, NULL, FI_SOURCE, hints,
&fi[i]);
cr_assert(ret == FI_SUCCESS, "fi_getinfo returned: %s",
fi_strerror(-ret));
fas_to_ep_name(fas, &ep_name);
check_ep_name(((struct gnix_ep_name *) fi[i]->src_addr)[0],
ep_name);
fi_freeinfo(fi[i]);
}
free(fas);
}
int DEFAULT_SYMVER_PRE(fi_getinfo)(uint32_t version, const char *node, const char *service,
uint64_t flags, struct fi_info *hints, struct fi_info **info)
{
struct fi_prov *prov;
struct fi_info *tail, *cur;
int ret;
if (!init)
fi_ini();
if (FI_VERSION_LT(fi_version(), version)) {
FI_WARN(&core_prov, FI_LOG_CORE,
"Requested version is newer than library\n");
return -FI_ENOSYS;
}
if (flags == FI_PROV_ATTR_ONLY) {
return fi_getprovinfo(info);
}
*info = tail = NULL;
for (prov = prov_head; prov; prov = prov->next) {
if (!prov->provider->getinfo)
continue;
if (hints && hints->fabric_attr && hints->fabric_attr->prov_name &&
strcasecmp(prov->provider->name, hints->fabric_attr->prov_name))
continue;
ret = prov->provider->getinfo(version, node, service, flags,
hints, &cur);
if (ret) {
FI_WARN(&core_prov, FI_LOG_CORE,
"fi_getinfo: provider %s returned -%d (%s)\n",
prov->provider->name, -ret, fi_strerror(-ret));
continue;
}
if (!*info)
*info = cur;
else
tail->next = cur;
for (tail = cur; tail->next; tail = tail->next) {
if (tail->fabric_attr->prov_name != NULL)
FI_WARN(&core_prov, FI_LOG_CORE,
"prov_name field is not NULL (%s)\n",
tail->fabric_attr->prov_name);
tail->fabric_attr->prov_name = strdup(prov->provider->name);
tail->fabric_attr->prov_version = prov->provider->version;
}
if (tail->fabric_attr->prov_name != NULL)
FI_WARN(&core_prov, FI_LOG_CORE,
"prov_name field is not NULL (%s)\n",
tail->fabric_attr->prov_name);
tail->fabric_attr->prov_name = strdup(prov->provider->name);
tail->fabric_attr->prov_version = prov->provider->version;
}
return *info ? 0 : -FI_ENODATA;
}
int cm_server_start(void)
{
int ret;
struct sockaddr_in loc_sa;
cm_local_ip(&loc_sa);
srv_hints = fi_allocinfo();
srv_hints->fabric_attr->name = strdup("gni");
srv_hints->ep_attr->type = FI_EP_MSG;
srv_hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
ret = fi_getinfo(fi_version(), inet_ntoa(loc_sa.sin_addr),
DEF_PORT, FI_SOURCE, srv_hints, &srv_fi);
cr_assert(!ret);
ret = fi_fabric(srv_fi->fabric_attr, &srv_fab, NULL);
cr_assert(!ret);
ret = fi_eq_open(srv_fab, &eq_attr, &srv_eq, NULL);
cr_assert(!ret);
ret = fi_passive_ep(srv_fab, srv_fi, &srv_pep, NULL);
cr_assert(!ret);
ret = fi_pep_bind(srv_pep, &srv_eq->fid, 0);
cr_assert(!ret);
ret = fi_listen(srv_pep);
cr_assert(!ret);
dbg_printf("Server start complete.\n");
return 0;
}
int cm_client_start_connect(void)
{
int ret;
struct sockaddr_in loc_sa;
cm_local_ip(&loc_sa);
cli_hints = fi_allocinfo();
cli_hints->fabric_attr->name = strdup("gni");
cli_hints->caps = GNIX_EP_PRIMARY_CAPS;
cli_hints->ep_attr->type = FI_EP_MSG;
cli_hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
ret = fi_getinfo(fi_version(), inet_ntoa(loc_sa.sin_addr),
DEF_PORT, 0, cli_hints, &cli_fi);
cr_assert(!ret);
ret = fi_fabric(cli_fi->fabric_attr, &cli_fab, NULL);
cr_assert(!ret);
ret = fi_eq_open(cli_fab, &eq_attr, &cli_eq, NULL);
cr_assert(!ret);
ret = fi_domain(cli_fab, cli_fi, &cli_dom, NULL);
cr_assert(!ret);
ret = fi_endpoint(cli_dom, cli_fi, &cli_ep, NULL);
cr_assert(!ret, "fi_endpoint");
cq_attr.format = FI_CQ_FORMAT_TAGGED;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
ret = fi_cq_open(cli_dom, &cq_attr, &cli_cq, &cli_cq);
cr_assert(!ret);
ret = fi_ep_bind(cli_ep, &cli_eq->fid, 0);
cr_assert(!ret);
ret = fi_ep_bind(cli_ep, &cli_cq->fid, FI_SEND | FI_RECV);
cr_assert(!ret);
ret = fi_enable(cli_ep);
cr_assert(!ret);
ret = fi_connect(cli_ep, cli_fi->dest_addr, cli_cm_in_data,
GNIX_CM_DATA_MAX_SIZE+1);
cr_assert(ret == -FI_EINVAL);
ret = fi_connect(cli_ep, cli_fi->dest_addr, cli_cm_in_data,
strlen(cli_cm_in_data));
cr_assert(!ret);
dbg_printf("Client connect complete.\n");
return 0;
}
Test(endpoint_info, info)
{
int ret;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_RDM);
cr_assert_eq(fi->next->ep_attr->type, FI_EP_DGRAM);
cr_assert_eq(fi->next->next->ep_attr->type, FI_EP_MSG);
cr_assert_neq(fi->domain_attr->cntr_cnt, 0);
cr_assert_neq(fi->domain_attr->cq_cnt, 0);
cr_assert_eq(fi->domain_attr->ep_cnt, SIZE_MAX);
fi_freeinfo(fi);
hints->ep_attr->type = FI_EP_RDM;
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_RDM);
fi_freeinfo(fi);
hints->ep_attr->type = FI_EP_DGRAM;
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_DGRAM);
fi_freeinfo(fi);
fi_freeinfo(hints);
}
void vc_lookup_setup(int av_type, int av_size)
{
int ret = 0;
struct fi_av_attr attr;
hints = fi_allocinfo();
hints->mode = mode_bits;
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->fabric_attr->prov_name = strdup("gni");
/* Create endpoint */
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
attr.type = av_type;
attr.count = av_size;
ret = fi_av_open(dom, &attr, &av, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom, fi, &ep, NULL);
cr_assert(!ret, "fi_endpoint");
gnix_ep = container_of(ep, struct gnix_fid_ep, ep_fid);
ret = fi_getname(&ep->fid, NULL, &ep_name_len);
ret = fi_getname(&ep->fid, &ep_name, &ep_name_len);
cr_assert(ret == FI_SUCCESS);
ret = fi_ep_bind(ep, &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep);
cr_assert(!ret, "fi_ep_enable");
fi_freeinfo(hints);
}
void rdm_str_addr_sr_setup(void)
{
int ret = 0, i = 0;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->domain_attr->cq_data_size = NUMEPS * 2;
hints->mode = FI_CONTEXT;
hints->caps = FI_SOURCE | FI_MSG | FI_SOURCE | FI_SOURCE_ERR;
hints->fabric_attr->prov_name = strdup("gni");
hints->addr_format = FI_ADDR_STR;
/* Get info about fabric services with the provided hints */
for (; i < NUMEPS; i++) {
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi[i]);
cr_assert(!ret, "fi_getinfo");
}
rdm_str_addr_sr_setup_common();
}
static void setup_dom(enum fi_progress pm)
{
int ret;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->domain_attr->data_progress = pm;
hints->domain_attr->cq_data_size = 4;
hints->mode = mode_bits;
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
}
static void fas_ep_setup(void)
{
int ret, i, j;
size_t addrlen = 0;
fas_setup_common(fi_version());
ctx_cnt = MIN(ctx_cnt, fi[0]->domain_attr->rx_ctx_cnt);
ctx_cnt = MIN(ctx_cnt, fi[0]->domain_attr->tx_ctx_cnt);
for (i = 0; i < NUMEPS; i++) {
fi[i]->ep_attr->tx_ctx_cnt = ctx_cnt;
fi[i]->ep_attr->rx_ctx_cnt = ctx_cnt;
ret = fi_domain(fab, fi[i], dom + i, NULL);
cr_assert(!ret, "fi_domain returned: %s", fi_strerror(-ret));
ret = fi_cntr_open(dom[i], &cntr_attr, send_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open returned: %s", fi_strerror(-ret));
ret = fi_cntr_open(dom[i], &cntr_attr, recv_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open returned: %s", fi_strerror(-ret));
switch (ep_type) {
case EP:
ret = fi_endpoint(dom[i], fi[i], ep + i, NULL);
cr_assert(!ret, "fi_endpoint returned: %s",
fi_strerror(-ret));
break;
case SEP:
ret = fi_scalable_ep(dom[i], fi[i], ep + i,
NULL);
cr_assert(!ret, "fi_endpoint returned: %s",
fi_strerror(-ret));
break;
case PEP:
ret = fi_passive_ep(fab, fi[i], pep + i,
NULL);
cr_assert(!ret, "fi_endpoint returned: %s",
fi_strerror(-ret));
ret = fi_getname(get_fid[ep_type](i), NULL,
&addrlen);
if (use_str_fmt) {
cr_assert(addrlen == GNIX_FI_ADDR_STR_LEN,
"fi_getname returned: %s",
fi_strerror(-ret));
} else {
cr_assert(addrlen ==
sizeof(struct gnix_ep_name),
"fi_getname returned: %s",
fi_strerror(-ret));
}
ep_name_len[i] = addrlen;
continue;
default:
cr_assert_fail("Unknown endpoint type.");
}
ret = fi_av_open(dom[i], &attr, av + i, NULL);
cr_assert(!ret, "fi_av_open returned: %s", fi_strerror(-ret));
switch (ep_type) {
case EP:
case PEP:
ret = fi_cq_open(dom[i], &cq_attr, msg_cq + i,
0);
cr_assert(!ret, "fi_cq_open returned: %s",
fi_strerror(-ret));
ret = fi_ep_bind(ep[i], &msg_cq[i]->fid,
FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind returned: %s",
fi_strerror(-ret));
break;
case SEP:
dbg_printf(BLUE
"ctx_cnt = %d\n"
COLOR_RESET,
ctx_cnt);
for (j = 0; j < ctx_cnt; j++) {
ret = fi_tx_context(ep[i], j, NULL,
&tx_ep[i][j], NULL);
cr_assert(!ret,
"fi_tx_context returned: %s",
fi_strerror(-ret));
ret = fi_cq_open(dom[i], &cq_attr,
&tx_cq[i][j],
NULL);
cr_assert(!ret,
"fi_cq_open returned: %s",
fi_strerror(-ret));
ret = fi_rx_context(ep[i], j, NULL,
&rx_ep[i][j], NULL);
cr_assert(!ret,
"fi_rx_context returned: %s",
fi_strerror(-ret));
ret = fi_cq_open(dom[i], &cq_attr,
&rx_cq[i][j],
NULL);
cr_assert(!ret,
"fi_cq_open returned: %s",
fi_strerror(-ret));
}
break;
default:
cr_assert_fail("Unknown endpoint type.");
}
ret = fi_getname(get_fid[ep_type](i), NULL, &addrlen);
if (use_str_fmt) {
cr_assert(addrlen > sizeof(struct gnix_ep_name),
"fi_getname returned: %s",
fi_strerror(-ret));
} else {
cr_assert(addrlen == sizeof(struct gnix_ep_name),
"fi_getname returned: %s",
fi_strerror(-ret));
}
ep_name[i] = malloc(addrlen);
ep_name_len[i] = addrlen;
dbg_printf(BLUE
"ep_name_len[%d] = %lu\n"
COLOR_RESET, i,
ep_name_len[i]);
cr_assert(ep_name[i] != NULL, "malloc returned: %s",
strerror(errno));
ret = fi_getname(get_fid[ep_type](i), ep_name[i], &addrlen);
cr_assert(ret == FI_SUCCESS, "fi_getname returned: %s",
fi_strerror(-ret));
}
/* Just testing setname / getname for passive endpoints */
if (ep_type == PEP)
return;
for (i = 0; i < NUMEPS; i++) {
/*Insert all gni addresses into each av*/
for (j = 0; j < NUMEPS; j++) {
ret = fi_av_insert(av[i], ep_name[j], 1, &gni_addr[j],
0, NULL);
cr_assert(ret == 1, "fi_av_insert returned: %s",
fi_strerror(-ret));
}
switch (ep_type) {
case EP:
ret = fi_ep_bind(ep[i], &av[i]->fid, 0);
cr_assert(!ret, "fi_ep_bind returned: %s",
fi_strerror(-ret));
ret = fi_ep_bind(ep[i], &send_cntr[i]->fid,
FI_SEND);
cr_assert(!ret, "fi_ep_bind returned: %s",
fi_strerror(-ret));
ret = fi_ep_bind(ep[i], &recv_cntr[i]->fid,
FI_RECV);
cr_assert(!ret, "fi_ep_bind returned: %s",
fi_strerror(-ret));
break;
case SEP:
ret = fi_scalable_ep_bind(ep[i], &av[i]->fid,
0);
cr_assert(!ret,
"fi_scalable_ep_bind returned: %s",
fi_strerror(-ret));
dbg_printf(BLUE
"ctx_cnt = %d\n"
COLOR_RESET,
ctx_cnt);
for (j = 0; j < ctx_cnt; j++) {
ret = fi_ep_bind(tx_ep[i][j],
&tx_cq[i][j]->fid,
FI_TRANSMIT);
cr_assert(!ret,
"fi_ep_bind returned: %s",
fi_strerror(-ret));
ret = fi_ep_bind(tx_ep[i][j],
&send_cntr[i]->fid,
FI_SEND);
cr_assert(!ret,
"fi_ep_bind returned: %s",
fi_strerror(-ret));
ret = fi_enable(tx_ep[i][j]);
cr_assert(!ret,
"fi_enable returned: %s",
fi_strerror(-ret));
ret = fi_ep_bind(rx_ep[i][j],
&rx_cq[i][j]->fid,
FI_RECV);
cr_assert(!ret,
"fi_ep_bind returned: %s",
fi_strerror(-ret));
ret = fi_ep_bind(rx_ep[i][j],
&recv_cntr[i]->fid,
FI_RECV);
cr_assert(!ret,
"fi_ep_bind returned: %s",
fi_strerror(-ret));
ret = fi_enable(rx_ep[i][j]);
cr_assert(!ret,
"fi_enable returned: %s",
fi_strerror(-ret));
}
break;
case PEP:
break;
default:
cr_assert_fail("Unknown endpoint type.");
}
ret = fi_enable(ep[i]);
cr_assert(!ret, "fi_ep_enable returned: %s", fi_strerror(-ret));
if (ep_type != SEP) {
ret = fi_enable(ep[i]);
cr_assert_eq(ret, -FI_EOPBADSTATE,
"fi_enable returned: %s",
fi_strerror(-ret));
}
}
}
void cancel_setup(void)
{
int ret = 0;
struct fi_av_attr attr;
size_t addrlen = 0;
int rem_requested_key, loc_requested_key;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->domain_attr->cq_data_size = 4;
hints->mode = mode_bits;
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
memset(&attr, 0, sizeof(attr));
attr.type = FI_AV_MAP;
attr.count = 16;
ret = fi_av_open(dom, &attr, &av, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom, fi, &ep[0], NULL);
cr_assert(!ret, "fi_endpoint");
cq_attr.format = FI_CQ_FORMAT_CONTEXT;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
ret = fi_cq_open(dom, &cq_attr, &msg_cq[0], 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_cq_open(dom, &cq_attr, &msg_cq[1], 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[0], &msg_cq[0]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_getname(&ep[0]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[0] = malloc(addrlen);
cr_assert(ep_name[0] != NULL);
ret = fi_getname(&ep[0]->fid, ep_name[0], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_endpoint(dom, fi, &ep[1], NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_ep_bind(ep[1], &msg_cq[1]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ep_name[1] = malloc(addrlen);
cr_assert(ep_name[1] != NULL);
ret = fi_getname(&ep[1]->fid, ep_name[1], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_av_insert(av, ep_name[0], 1, &gni_addr[0], 0,
NULL);
cr_assert(ret == 1);
ret = fi_av_insert(av, ep_name[1], 1, &gni_addr[1], 0,
NULL);
cr_assert(ret == 1);
ret = fi_ep_bind(ep[0], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_ep_bind(ep[1], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[0]);
cr_assert(!ret, "fi_ep_enable");
ret = fi_enable(ep[1]);
cr_assert(!ret, "fi_ep_enable");
target_base = malloc(GNIT_ALIGN_LEN(BUF_SZ));
assert(target_base);
target = GNIT_ALIGN_BUFFER(char *, target_base);
source_base = malloc(GNIT_ALIGN_LEN(BUF_SZ));
assert(source_base);
source = GNIT_ALIGN_BUFFER(char *, source_base);
rem_requested_key = USING_SCALABLE(fi) ? 1 : 0;
loc_requested_key = USING_SCALABLE(fi) ? 2 : 0;
ret = fi_mr_reg(dom,
target,
BUF_SZ,
FI_REMOTE_WRITE,
0,
rem_requested_key,
0,
&rem_mr,
&target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom,
source,
BUF_SZ,
FI_REMOTE_WRITE,
0,
loc_requested_key,
0,
&loc_mr,
&source);
cr_assert_eq(ret, 0);
if (USING_SCALABLE(fi)) {
MR_ENABLE(rem_mr, target, BUF_SZ);
MR_ENABLE(loc_mr, source, BUF_SZ);
}
mr_key = fi_mr_key(rem_mr);
}
static void api_cntr_setup_scalable(void)
{
__api_cntr_setup(fi_version(), GNIX_MR_SCALABLE);
}
static void api_cntr_setup_basic(void)
{
__api_cntr_setup(fi_version(), GNIX_MR_BASIC);
}
static void setup(void)
{
_setup(fi_version());
}
int DEFAULT_SYMVER_PRE(fi_getinfo)(uint32_t version, const char *node,
const char *service, uint64_t flags,
const struct fi_info *hints, struct fi_info **info)
{
struct ofi_prov *prov;
struct fi_info *tail, *cur;
char **prov_vec = NULL;
size_t count = 0;
int ret;
if (!ofi_init)
fi_ini();
if (FI_VERSION_LT(fi_version(), version)) {
FI_WARN(&core_prov, FI_LOG_CORE,
"Requested version is newer than library\n");
return -FI_ENOSYS;
}
if (flags == FI_PROV_ATTR_ONLY) {
return ofi_getprovinfo(info);
}
if (hints && hints->fabric_attr && hints->fabric_attr->prov_name) {
prov_vec = ofi_split_and_alloc(hints->fabric_attr->prov_name,
";", &count);
if (!prov_vec)
return -FI_ENOMEM;
FI_DBG(&core_prov, FI_LOG_CORE, "hints prov_name: %s\n",
hints->fabric_attr->prov_name);
}
*info = tail = NULL;
for (prov = prov_head; prov; prov = prov->next) {
if (!prov->provider)
continue;
if (!ofi_layering_ok(prov->provider, prov_vec, count, flags))
continue;
if (FI_VERSION_LT(prov->provider->fi_version, version)) {
FI_WARN(&core_prov, FI_LOG_CORE,
"Provider %s fi_version %d.%d < requested %d.%d\n",
prov->provider->name,
FI_MAJOR(prov->provider->fi_version),
FI_MINOR(prov->provider->fi_version),
FI_MAJOR(version), FI_MINOR(version));
continue;
}
ret = prov->provider->getinfo(version, node, service, flags,
hints, &cur);
if (ret) {
FI_WARN(&core_prov, FI_LOG_CORE,
"fi_getinfo: provider %s returned -%d (%s)\n",
prov->provider->name, -ret, fi_strerror(-ret));
continue;
}
if (!cur) {
FI_WARN(&core_prov, FI_LOG_CORE,
"fi_getinfo: provider %s output empty list\n",
prov->provider->name);
continue;
}
if (!*info)
*info = cur;
else
tail->next = cur;
for (tail = cur; tail->next; tail = tail->next) {
ofi_set_prov_attr(tail->fabric_attr, prov->provider);
tail->fabric_attr->api_version = version;
}
ofi_set_prov_attr(tail->fabric_attr, prov->provider);
tail->fabric_attr->api_version = version;
}
ofi_free_string_array(prov_vec);
return *info ? 0 : -FI_ENODATA;
}