void do_getpeer_enosys(void)
{
int ret = 0, i;
struct gnix_fid_pep *gnix_pep;
struct fid_ep *ep_fid = NULL;
for (i = 0; i < NUMEPS; i++) {
switch (ep_type) {
case EP:
ep_fid = get_fid_ep(i, NULL, NULL, NULL);
ret = fi_getpeer(ep_fid, NULL, NULL);
break;
case SEP:
ep_fid = get_fid_ep(i, NULL, NULL, NULL);
ret = fi_getpeer(ep_fid, NULL, NULL);
break;
case PEP:
gnix_pep = container_of(get_fid[ep_type](i),
struct gnix_fid_pep,
pep_fid.fid);
ret = gnix_pep->pep_fid.cm->getpeer(NULL, NULL,
NULL);
break;
default:
cr_assert_fail("Unknown endpoint type.");
}
cr_assert_eq(ret, -FI_ENOSYS, "Invalid return value: %s",
fi_strerror(-ret));
}
}
void do_send_recv(void)
{
int len, i, j;
switch (ep_type) {
case EP:
for (len = 2; len <= BUF_SZ; len *= 2) {
do_ep_send_recv_iter(len);
}
break;
case SEP:
for (j = 0; j < ctx_cnt; j++) {
for (len = 2; len <= BUF_SZ; len *= 2) {
do_sep_send_recv_iter(j, len);
}
for (i = 0; i < NUMEPS; i++) {
fi_cntr_set(send_cntr[i], 0);
fi_cntr_set(recv_cntr[i], 0);
}
}
break;
case PEP:
break;
default:
cr_assert_fail("Invalid endpoint type.");
}
}
int client_echo(int sockfd, void *args)
{
int rc;
int size = *((int *) args);
uint8_t *buf = generate_msg(size);
uint8_t *recv_buf = calloc(size, 1);
rc = chitcp_socket_send(sockfd, buf, size);
cr_assert(rc == size,
"Client socket did not send all the bytes (expected %i, got %i)", size, rc);
rc = chitcp_socket_recv(sockfd, recv_buf, size);
cr_assert(rc == size,
"Client socket did not receive all the bytes (expected %i, got %i)", size, rc);
for (int i = 0; i < size; i++)
if(buf[i] != recv_buf[i])
cr_assert_fail("Client received unexpected value: recv_buf[%i] == %i (expected %i)",
i, recv_buf[i], buf[i]);
free(buf);
free(recv_buf);
return 0;
}
struct fid_ep *get_fid_ep(int i, void **info, void **dest_addr,
void **src_addr)
{
struct gnix_fid_ep *ep = NULL;
struct gnix_fid_sep *sep = NULL;
struct gnix_fid_pep *pep = NULL;
switch (ep_type) {
case EP:
ep = container_of(get_fid[ep_type](i),
struct gnix_fid_ep,
ep_fid.fid);
if (info)
*info = (void *) ep->info;
if (dest_addr)
*dest_addr = (void *) &ep->dest_addr;
if (src_addr)
*src_addr = (void *) &ep->src_addr;
return &ep->ep_fid;
case SEP:
sep = container_of(get_fid[ep_type](i),
struct gnix_fid_sep,
ep_fid);
if (info)
*info = (void *) sep->info;
if (dest_addr) {
if (!sep->info->dest_addr) {
sep->info->dest_addr = malloc
(sep->info->dest_addrlen);
cr_assert(sep->info->dest_addr, "malloc "
"failed");
}
*dest_addr = sep->info->dest_addr;
}
if (src_addr)
*src_addr = (void *) &sep->my_name;
return &sep->ep_fid;
case PEP:
pep = container_of(get_fid[ep_type](i),
struct gnix_fid_pep,
pep_fid.fid);
if (info)
*info = (void *) pep->info;
if (dest_addr)
*dest_addr = pep->info->dest_addr;
if (src_addr)
*src_addr = (void *) &pep->src_addr;
break;
default:
cr_assert_fail("Unknown endpoint type.");
}
return NULL;
}
static enum chitcpd_debug_response check_vars(int sockfd, enum chitcpd_debug_event event_flag, debug_socket_state_t *state_info, debug_socket_state_t *saved_state_info, int new_sockfd)
{
if (event_flag == DBG_EVT_PENDING_CONNECTION)
{
return DBG_RESP_ACCEPT_MONITOR;
}
if (event_flag == DBG_EVT_TCP_STATE_CHANGE)
{
tcp_state_t curs = state_info->tcp_state;
cr_assert(IS_VALID_TCP_STATE(curs), "Unknown TCP state.");
if(!saved_state_info)
{
cr_assert(curs == SYN_SENT || curs == SYN_RCVD,
"%s is not a valid initial state", tcp_str(curs));
cr_assert(state_info->SND_UNA + 1 == state_info->SND_NXT,
"In state %s, SND.UNA + 1 != SND.NXT (got SND.UNA=%i, SND.NXT=%i",
tcp_str(curs), state_info->SND_UNA, state_info->SND_NXT);
}
else
{
cr_assert(IS_VALID_TCP_STATE(saved_state_info->tcp_state), "Unknown (previous) TCP state.");
tcp_state_t prevs = saved_state_info->tcp_state;
if ( (prevs == SYN_SENT && curs != ESTABLISHED) ||
(prevs == SYN_RCVD && curs != ESTABLISHED) )
cr_assert_fail("Invalid transition: %s -> %s", tcp_str(prevs), tcp_str(curs));
if (prevs == SYN_SENT || prevs == SYN_RCVD)
cr_assert(state_info->SND_UNA == state_info->SND_NXT,
"In state %s, SND.UNA != SND.NXT (got SND.UNA=%i, SND.NXT=%i",
tcp_str(curs), state_info->SND_UNA, state_info->SND_NXT);
}
chitcpd_debug_save_socket_state(state_info);
if (curs == ESTABLISHED)
return DBG_RESP_STOP;
else
return DBG_RESP_NONE;
}
return DBG_RESP_NONE;
}
int receiver(int sockfd, void *args)
{
int rc;
int size = *((int *) args);
uint8_t buf[size];
rc = chitcp_socket_recv(sockfd, buf, size);
cr_assert(rc == size,
"Socket did not receive all the bytes (expected %i, got %i)", size, rc);
for (int i = 0; i < size; i++)
if(buf[i] != (i % 256))
cr_assert_fail("Unexpected value encountered: buf[%i] == %i (expected %i)",
i, buf[i], (i % 256));
return 0;
}
int server_echo(int sockfd, void *args)
{
int rc;
int size = *((int *) args);
uint8_t buf[size];
rc = chitcp_socket_recv(sockfd, buf, size);
cr_assert(rc == size,
"Server socket did not receive all the bytes (expected %i, got %i)", size, rc);
for (int i = 0; i < size; i++)
if(buf[i] != (i % 256))
cr_assert_fail("Server received unexpected value: buf[%i] == %i (expected %i)",
i, buf[i], (i % 256));
rc = chitcp_socket_send(sockfd, buf, size);
cr_assert(rc == size,
"Client socket did not send all the bytes (expected %i, got %i)", size, rc);
return 0;
}
static void fas_teardown_common(void)
{
int ret = 0, i = 0, j;
for (; i < NUMEPS; i++) {
if (ep_type == SEP || ep_type == EP) {
ret = fi_close(&recv_cntr[i]->fid);
cr_assert(!ret, "failure in closing recv cntr.");
ret = fi_close(&send_cntr[i]->fid);
cr_assert(!ret, "failure in closing send cntr.");
}
switch (ep_type) {
case EP:
ret = fi_close(&msg_cq[i]->fid);
cr_assert(!ret, "failure in closing msg cq.");
break;
case SEP:
for (j = 0; j < ctx_cnt; j++) {
ret = fi_close(&tx_ep[i][j]->fid);
cr_assert(!ret,
"failure closing tx_ep.");
ret = fi_close(&rx_ep[i][j]->fid);
cr_assert(!ret,
"failure closing rx_ep.");
ret = fi_close(&tx_cq[i][j]->fid);
cr_assert(!ret,
"failure closing tx cq.");
ret = fi_close(&rx_cq[i][j]->fid);
cr_assert(!ret,
"failure closing rx cq.");
}
break;
case PEP:
ret = fi_close(get_fid[ep_type](i));
cr_assert(!ret, "failure in closing ep.");
continue;
break;
default:
cr_assert_fail("Unknown endpoint type.");
break;
}
ret = fi_close(get_fid[ep_type](i));
cr_assert(!ret, "failure in closing ep.");
ret = fi_close(&av[i]->fid);
cr_assert(!ret, "failure in closing av.");
ret = fi_close(&dom[i]->fid);
cr_assert(!ret, "failure in closing domain.");
free(ep_name[i]);
free(target[i]);
free(source[i]);
free(tx_cq[i]);
free(tx_ep[i]);
free(rx_cq[i]);
free(rx_ep[i]);
fi_freeinfo(fi[i]);
}
ret = fi_close(&fab->fid);
cr_assert(!ret, "failure in closing fabric.");
fi_freeinfo(hints);
}
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));
}
}
}
