static void lookup_invalid_test(void)
{
int ret;
struct gnix_ep_name addr;
size_t addrlen = sizeof(struct gnix_ep_name);
/* test null addrlen */
ret = fi_av_lookup(av, 0xdeadbeef, (void *) 0xdeadbeef, NULL);
cr_assert_eq(ret, -FI_EINVAL);
/* test null addr */
ret = fi_av_lookup(av, 0xdeadbeef, NULL, &addrlen);
cr_assert_eq(ret, -FI_EINVAL);
/* test invalid lookup */
if (gnix_av->type == FI_AV_TABLE) {
ret = fi_av_lookup(av, 2000, &addr, &addrlen);
cr_assert_eq(ret, -FI_EINVAL);
/* test within range, but not inserted case */
ret = fi_av_lookup(av, 1, &addr, &addrlen);
cr_assert_eq(ret, -FI_EINVAL);
} else {
ret = fi_av_lookup(av, 0xdeadbeef, &addr, &addrlen);
cr_assert_eq(ret, -FI_ENOENT);
}
}
static inline int rdm_str_addr_sr_check_err_cqe(struct fid_cq *cq)
{
int ret = FI_SUCCESS, cnt;
struct fi_cq_err_entry ee;
size_t name_size;
char *buffer;
fi_addr_t fi_addr;
/*application provided error_data buffer and length*/
ee.err_data_size = addrlen;
ee.err_data = malloc(addrlen);
cr_assert((ee.err_data != NULL), "malloc failed");
buffer = malloc(addrlen);
cr_assert((buffer != NULL), "malloc failed");
cnt = fi_cq_readerr(cq, &ee, 0);
cr_assert((cnt == 1), "fi_cq_readerr didn't return entry");
if ((hints->caps & FI_SOURCE_ERR) && ee.err == FI_EADDRNOTAVAIL) {
ret = fi_av_insert(av[1], ee.err_data, 1, &fi_addr,
0, NULL);
cr_assert(ret == 1, "fi_av_insert failed");
name_size = addrlen;
ret = fi_av_lookup(av[1], fi_addr,
buffer, &name_size);
cr_assert(ret == FI_SUCCESS, "fi_av_lookup failed");
cr_assert(name_size == addrlen);
cr_assert(strncmp((char *)buffer,
(char *)ee.err_data,
addrlen) == 0);
}
return ret;
}
static void lookup_test(void)
{
int ret;
int i;
fi_addr_t addresses[SIMPLE_ADDR_COUNT];
fi_addr_t *compare;
struct gnix_ep_name found;
size_t addrlen = sizeof(struct gnix_ep_name);
/* insert addresses */
ret = fi_av_insert(av, (void *) simple_ep_names, SIMPLE_ADDR_COUNT,
addresses, 0, NULL);
cr_assert_eq(ret, SIMPLE_ADDR_COUNT);
/* check address contents */
for (i = 0; i < SIMPLE_ADDR_COUNT; i++) {
if (gnix_av->type == FI_AV_MAP) {
compare = (fi_addr_t *) &simple_ep_names[i].gnix_addr;
cr_assert_eq(*compare, addresses[i]);
} else {
cr_assert_eq(i, addresses[i]);
}
}
for (i = 0; i < SIMPLE_ADDR_COUNT; i++) {
ret = fi_av_lookup(av, addresses[i], &found, &addrlen);
cr_assert_eq(ret, FI_SUCCESS);
}
}
int rxd_av_dg_reverse_lookup(struct rxd_av *av, uint64_t start_idx,
const void *addr, size_t addrlen, uint64_t *idx)
{
int ret;
size_t i, len;
void *curr_addr;
len = addrlen;
curr_addr = calloc(1, av->addrlen);
if (!curr_addr)
return -FI_ENOMEM;
for (i = 0; i < av->dg_av_used; i++) {
ret = fi_av_lookup(av->dg_av, (i + start_idx) % av->dg_av_used,
curr_addr, &len);
if (ret)
continue;
if (len == addrlen && memcmp(curr_addr, addr, len) == 0) {
*idx = (i + start_idx) % av->dg_av_used;
goto out;
}
}
ret = -FI_ENODATA;
out:
free(curr_addr);
return ret;
}
int rxd_av_lookup(struct fid_av *av, fi_addr_t fi_addr, void *addr, size_t *addrlen)
{
struct rxd_av *rxd_av;
fi_addr_t dg_addr;
rxd_av = container_of(av, struct rxd_av, util_av.av_fid);
dg_addr = rxd_av_get_dg_addr(rxd_av, fi_addr);
return fi_av_lookup(rxd_av->dg_av, dg_addr, addr, addrlen);
}
static void invalid_addrlen_pointer_test(void)
{
int ret;
fi_addr_t address = 0xdeadbeef;
void *addr = (void *) 0xb00fbabe;
/* while the pointers to address and addr aren't valid, they are
* acceptable as stated by the manpage. This will only test for a
* proper return code from fi_av_lookup()
*/
ret = fi_av_lookup(av, address, addr, NULL);
cr_assert_eq(ret, -FI_EINVAL);
}
static int rxd_av_lookup(struct fid_av *av, fi_addr_t fi_addr, void *addr,
size_t *addrlen)
{
struct rxd_av *rxd_av;
fi_addr_t dg_fiaddr;
rxd_av = container_of(av, struct rxd_av, util_av.av_fid);
dg_fiaddr = rxd_av_dg_addr(rxd_av, fi_addr);
if (dg_fiaddr == FI_ADDR_UNSPEC)
return -FI_ENODATA;
return fi_av_lookup(rxd_av->dg_av, dg_fiaddr, addr, addrlen);
}
static int rxd_tree_compare(struct ofi_rbmap *map, void *key, void *data)
{
struct rxd_av *av;
uint8_t addr[RXD_NAME_LENGTH];
size_t len = RXD_NAME_LENGTH;
int ret;
memset(addr, 0, len);
av = container_of(map, struct rxd_av, rbmap);
ret = fi_av_lookup(av->dg_av, av->rxd_addr_table[(fi_addr_t) data].dg_addr,
addr, &len);
if (ret)
return -1;
return memcmp(key, addr, len);
}
static int rxd_av_remove(struct fid_av *av_fid, fi_addr_t *fi_addr, size_t count,
uint64_t flags)
{
int ret = 0;
size_t i, addrlen;
fi_addr_t rxd_addr;
struct rxd_av *av;
uint8_t addr[RXD_NAME_LENGTH];
struct ofi_rbnode *node;
av = container_of(av_fid, struct rxd_av, util_av.av_fid);
fastlock_acquire(&av->util_av.lock);
for (i = 0; i < count; i++) {
rxd_addr = av->fi_addr_table[fi_addr[i]];
addrlen = RXD_NAME_LENGTH;
ret = fi_av_lookup(av->dg_av, av->rxd_addr_table[rxd_addr].dg_addr,
addr, &addrlen);
if (ret)
goto err;
node = ofi_rbmap_find(&av->rbmap, (void *) addr);
if (!node)
goto err;
ofi_rbmap_delete(&av->rbmap, node);
ret = fi_av_remove(av->dg_av, &av->rxd_addr_table[rxd_addr].dg_addr,
1, flags);
if (ret)
goto err;
av->fi_addr_table[fi_addr[i]] = FI_ADDR_UNSPEC;
av->rxd_addr_table[rxd_addr].fi_addr = FI_ADDR_UNSPEC;
av->rxd_addr_table[rxd_addr].dg_addr = FI_ADDR_UNSPEC;
av->dg_av_used--;
}
err:
if (ret)
FI_WARN(&rxd_prov, FI_LOG_AV, "Unable to remove address from AV\n");
fastlock_release(&av->util_av.lock);
return ret;
}
/*
* The RXD code is agnostic wrt the datagram address format, but we need
* to know the size of the address in order to iterate over them. Because
* the datagram AV may be configured for asynchronous operation, open a
* temporary one to insert/lookup the address to get the size. I agree it's
* goofy.
*/
static int rxd_av_set_addrlen(struct rxd_av *av, const void *addr)
{
struct rxd_domain *domain;
struct fid_av *tmp_av;
struct fi_av_attr attr;
uint8_t tmp_addr[RXD_NAME_LENGTH];
fi_addr_t fiaddr;
size_t len;
int ret;
FI_INFO(&rxd_prov, FI_LOG_AV, "determine dgram address len\n");
memset(&attr, 0, sizeof attr);
attr.count = 1;
domain = container_of(av->util_av.domain, struct rxd_domain, util_domain);
ret = fi_av_open(domain->dg_domain, &attr, &tmp_av, NULL);
if (ret) {
FI_WARN(&rxd_prov, FI_LOG_AV, "failed to open av: %d (%s)\n",
-ret, fi_strerror(-ret));
return ret;
}
ret = fi_av_insert(tmp_av, addr, 1, &fiaddr, 0, NULL);
if (ret != 1) {
FI_WARN(&rxd_prov, FI_LOG_AV, "addr insert failed: %d (%s)\n",
-ret, fi_strerror(-ret));
ret = -FI_EINVAL;
goto close;
}
len = sizeof tmp_addr;
ret = fi_av_lookup(tmp_av, fiaddr, tmp_addr, &len);
if (ret) {
FI_WARN(&rxd_prov, FI_LOG_AV, "addr lookup failed: %d (%s)\n",
-ret, fi_strerror(-ret));
goto close;
}
FI_INFO(&rxd_prov, FI_LOG_AV, "set dgram address len: %zu\n", len);
av->dg_addrlen = len;
close:
fi_close(&tmp_av->fid);
return ret;
}
int rxd_av_dg_reverse_lookup(struct rxd_av *av, uint64_t start_idx,
const void *addr, fi_addr_t *dg_fiaddr)
{
uint8_t curr_addr[RXD_MAX_DGRAM_ADDR];
size_t i, len;
int ret;
for (i = 0; i < (size_t) av->dg_av_used; i++) {
len = sizeof curr_addr;
ret = fi_av_lookup(av->dg_av, (i + start_idx) % av->dg_av_used,
curr_addr, &len);
if (!ret) {
*dg_fiaddr = (i + start_idx) % av->dg_av_used;
FI_DBG(&rxd_prov, FI_LOG_AV, "found: %" PRIu64 "\n",
*dg_fiaddr);
return 0;
}
}
FI_DBG(&rxd_prov, FI_LOG_AV, "addr not found\n");
return -FI_ENODATA;
}
static void *lookup_random(void *data)
{
int n, ret;
fi_addr_t *addresses = ((fi_addr_t **) data)[0];
atomic_t *done = ((atomic_t **) data)[1];
struct gnix_ep_name found;
size_t addrlen = sizeof(struct gnix_ep_name);
srand(0);
ret = pthread_barrier_wait(&mtbar);
if ((ret != PTHREAD_BARRIER_SERIAL_THREAD) && (ret != 0)) {
pthread_exit((void *) 1UL);
}
while (!atomic_get(done)) {
n = rand()%MT_ADDR_COUNT;
(void) fi_av_lookup(av, addresses[n], &found, &addrlen);
}
pthread_exit(NULL);
}
static void *lookup_single(void *data)
{
int ret;
struct gnix_ep_name found;
size_t addrlen = sizeof(struct gnix_ep_name);
fi_addr_t *addr = (fi_addr_t *) data;
ret = pthread_barrier_wait(&mtbar);
if ((ret != PTHREAD_BARRIER_SERIAL_THREAD) && (ret != 0)) {
pthread_exit((void *) 1UL);
}
av_lock();
ret = fi_av_lookup(av, *addr, &found, &addrlen);
av_unlock();
if (ret != FI_SUCCESS) {
pthread_exit((void *) 2UL);
}
pthread_exit((void *) 0UL);
}
