/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session,
struct xio_msg *rsp,
int more_in_batch,
void *cb_user_context)
{
struct session_data *session_data = cb_user_context;
int i = rsp->request->sn % QUEUE_DEPTH;
session_data->nrecv++;
/* process the incoming message */
process_response(session_data, rsp);
/* acknowledge xio that response is no longer needed */
xio_release_response(rsp);
#if TEST_DISCONNECT
if (session_data->nrecv == DISCONNECT_NR) {
xio_disconnect(session_data->conn);
return 0;
}
if (session_data->nsent == DISCONNECT_NR)
return 0;
#endif
session_data->req[i].in.header.iov_base = NULL;
session_data->req[i].in.header.iov_len = 0;
vmsg_sglist_set_nents(&session_data->req[i].in, 0);
/* resend the message */
xio_send_request(session_data->conn, &session_data->req[i]);
session_data->nsent++;
return 0;
}
/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session,
struct xio_msg *rsp,
int last_in_rxq,
void *cb_user_context)
{
struct session_data *session_data = (struct session_data *)
cb_user_context;
int i = rsp->request->sn % QUEUE_DEPTH;
session_data->nrecv++;
/* process the incoming message */
process_response(session_data, rsp);
/* acknowledge xio that response is no longer needed */
xio_release_response(rsp);
if (reconnect_flag || reload_flag)
return 0;
/* resend the message */
xio_send_request(session_data->conn, &session_data->req[i]);
session_data->nsent++;
return 0;
}
static int on_msg_error(struct xio_session *session,
enum xio_status error,
enum xio_msg_direction direction,
struct xio_msg *msg,
void *cb_user_context)
{
/* struct server_data *sdata = (struct server_data *)cb_user_context; */
if (direction == XIO_MSG_DIRECTION_OUT) {
sd_debug("**** [%p] message %lu failed. reason: %s",
session, msg->sn, xio_strerror(error));
} else {
xio_release_response(msg);
sd_debug("**** [%p] message %lu failed. reason: %s",
session, msg->request->sn, xio_strerror(error));
}
switch (error) {
case XIO_E_MSG_FLUSHED:
break;
default:
/* xio_disconnect(sdata->connection); */
break;
};
return 0;
}
/*---------------------------------------------------------------------------*/
static int on_msg_error(struct xio_session *session,
enum xio_status error,
enum xio_msg_direction direction,
struct xio_msg *msg,
void *cb_user_context)
{
struct test_params *test_params = (struct test_params *)cb_user_context;
if (direction == XIO_MSG_DIRECTION_OUT) {
printf("**** [%p] message %lu failed. reason: %s\n",
session, msg->sn, xio_strerror(error));
} else {
xio_release_response(msg);
printf("**** [%p] message %lu failed. reason: %s\n",
session, msg->request->sn, xio_strerror(error));
}
msg_pool_put(test_params->pool, msg);
switch (error) {
case XIO_E_MSG_FLUSHED:
break;
default:
xio_disconnect(test_params->connection);
break;
};
return 0;
}
/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session,
struct xio_msg *msg,
int last_in_rxq,
void *cb_user_context)
{
/* struct scatterlist *sgl; */
process_response(msg);
/* message is no longer needed */
xio_release_response(msg);
nrecv++;
msg_pool_put(pool, msg);
if (test_config.finite_run) {
if (nrecv == disconnect_nr) {
xio_disconnect(g_connection);
return 0;
}
if (nrecv > disconnect_nr)
return 0;
}
/* reset message */
msg->in.header.iov_base = NULL;
msg->in.header.iov_len = 0;
msg->in.data_tbl.nents = 0;
/*
sgl = msg->in.data_tbl.sgl;
xio_tbl_set_nents(&msg->in.data_tbl, test_config.in_iov_len);
sg_set_buf(sgl, NULL, ONE_MB);
*/
msg->sn = 0;
/* recycle the message and fill new request */
msg_build_out_sgl(&msg_params, msg,
test_config.hdr_len,
1, test_config.data_len);
/* try to send it */
if (xio_send_request(g_connection, msg) == -1) {
if (xio_errno() != EAGAIN)
pr_err("**** [%p] Error - xio_send_msg " \
"failed %s\n",
session,
xio_strerror(xio_errno()));
msg_pool_put(pool, msg);
/* xio_assert(0); */
}
return 0;
}
/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session, struct xio_msg *rsp,
int more_in_batch, void *cb_user_context)
{
struct xio_iovec_ex *sglist;
process_response(rsp);
/* message is no longer needed */
xio_release_response(rsp);
nrecv++;
if (test_config.finite_run) {
if (nrecv == disconnect_nr) {
xio_disconnect(conn);
return 0;
}
if (nrecv > disconnect_nr || nsent == disconnect_nr)
return 0;
}
/* reset message */
rsp->in.header.iov_base = NULL;
rsp->in.header.iov_len = 0;
sglist = vmsg_sglist(&rsp->in);
vmsg_sglist_set_nents(&rsp->in, 1);
sglist[0].iov_base = NULL;
sglist[0].iov_len = ONE_MB;
sglist[0].mr = NULL;
rsp->sn = 0;
rsp->more_in_batch = 0;
do {
/* recycle the message and fill new request */
msg_write(&msg_params, rsp,
test_config.hdr_len,
1, test_config.data_len);
/* try to send it */
if (xio_send_request(conn, rsp) == -1) {
if (xio_errno() != EAGAIN)
printf("**** [%p] Error - xio_send_msg " \
"failed %s\n",
session,
xio_strerror(xio_errno()));
msg_pool_put(pool, rsp);
xio_assert(0);
}
nsent++;
} while (0);
return 0;
}
/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session,
struct xio_msg *msg,
int last_in_rxq,
void *cb_user_context)
{
struct thread_data *tdata = (struct thread_data *)cb_user_context;
cycles_t rtt = (get_cycles()-(cycles_t)msg->user_context);
if (tdata->do_stat) {
if (rtt > tdata->stat.max_rtt)
tdata->stat.max_rtt = rtt;
if (rtt < tdata->stat.min_rtt)
tdata->stat.min_rtt = rtt;
tdata->stat.tot_rtt += rtt;
tdata->stat.ccnt++;
}
tdata->rx_nr++;
/* message is no longer needed */
xio_release_response(msg);
if (tdata->disconnect) {
if (tdata->rx_nr == tdata->tx_nr)
xio_disconnect(tdata->conn);
else
msg_pool_put(tdata->pool, msg);
return 0;
}
/* reset message */
msg->in.header.iov_len = 0;
vmsg_sglist_set_nents(&msg->in, 0);
msg->user_context = (void *)get_cycles();
if (xio_send_request(tdata->conn, msg) == -1) {
if (xio_errno() != EAGAIN)
printf("**** [%p] Error - xio_send_request " \
"failed %s\n",
session,
xio_strerror(xio_errno()));
msg_pool_put(tdata->pool, msg);
return 0;
}
if (tdata->do_stat)
tdata->stat.scnt++;
tdata->tx_nr++;
return 0;
}
/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session,
struct xio_msg *msg,
int more_in_batch,
void *cb_user_context)
{
process_response(msg);
if (msg->status)
printf("**** message completed with error. [%s]\n",
xio_strerror(msg->status));
/* message is no longer needed */
xio_release_response(msg);
/* reset message */
msg->in.header.iov_base = NULL;
msg->in.header.iov_len = 0;
msg->in.data_iovlen = 1;
msg->in.data_iov[0].iov_base = NULL;
msg->in.data_iov[0].iov_len = ONE_MB;
msg->in.data_iov[0].mr = NULL;
msg->sn = 0;
msg->more_in_batch = 0;
do {
/* recycle the message and fill new request */
msg_write(msg,
"hello world request header",
test_config.hdr_len,
"hello world request data",
test_config.data_len);
/* try to send it */
if (xio_send_request(conn, msg) == -1) {
if (xio_errno() != EAGAIN)
printf("**** [%p] Error - xio_send_msg " \
"failed %s\n",
session,
xio_strerror(xio_errno()));
msg_pool_put(pool, msg);
return 0;
}
} while (0);
return 0;
}
/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session,
struct xio_msg *rsp,
int more_in_batch,
void *cb_user_context)
{
struct hw_session_data *session_data = cb_user_context;
int i = rsp->request->sn % QUEUE_DEPTH;
/* process the incoming message */
process_response(rsp);
/* acknowledge xio that response is no longer needed */
xio_release_response(rsp);
/* resend the message */
xio_send_request(session_data->conn, &session_data->req[i]);
return 0;
}
/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session,
struct xio_msg *rsp,
int last_in_rxq,
void *cb_user_context)
{
struct session_data *session_data = cb_user_context;
struct xio_msg *req = rsp;
/* process the incoming message */
process_response(rsp);
/* acknowledge xio that response is no longer needed */
xio_release_response(rsp);
/* resend the message */
xio_send_request(session_data->connection, req);
return 0;
}
/*---------------------------------------------------------------------------*/
int on_msg_error(struct xio_session *session,
enum xio_status error, struct xio_msg *msg,
void *cb_private_data)
{
switch (msg->type) {
case XIO_MSG_TYPE_REQ:
printf("**** [%p] message [%lu] failed. reason: %s\n",
session, msg->sn, xio_strerror(error));
msg_pool_put(pool, msg);
switch (error) {
case XIO_E_MSG_FLUSHED:
case XIO_E_MSG_DISCARDED:
break;
default:
xio_assert(0);
break;
};
break;
case XIO_MSG_TYPE_RSP:
printf("**** [%p] message [%lu] failed. reason: %s\n",
session, msg->request->sn, xio_strerror(error));
/* message is no longer needed */
switch (error) {
case XIO_E_MSG_FLUSHED:
xio_release_response(msg);
msg_pool_put(pool, msg);
break;
default:
msg_pool_put(pool, msg);
xio_assert(0);
break;
};
break;
default:
printf("unknown message type : %d\n", msg->type);
msg_pool_put(pool, msg);
xio_assert(0);
break;
}
return 0;
}
static void msg_finalize(struct sd_req *hdr, void *data, struct xio_msg *xrsp)
{
struct xio_vmsg *pimsg = &xrsp->in;
struct xio_iovec_ex *isglist = vmsg_sglist(pimsg);
int nents = vmsg_sglist_nents(pimsg);
sd_assert(xrsp->in.header.iov_len == sizeof(struct sd_rsp));
memcpy(hdr, xrsp->in.header.iov_base, sizeof(*hdr));
if (data) {
int total = 0;
for (int i = 0; i < nents; i++) {
memcpy((char *)data + total, isglist[i].iov_base,
isglist[i].iov_len);
total += isglist[i].iov_len;
}
}
xio_release_response(xrsp);
}
/*---------------------------------------------------------------------------*/
static int on_response(struct xio_session *session,
struct xio_msg *msg,
int last_in_rxq,
void *cb_user_context)
{
struct test_params *test_params = (struct test_params *)cb_user_context;
struct xio_iovec_ex *sglist;
static int chain_messages = CHAIN_MESSAGES;
size_t j;
test_params->nrecv++;
process_response(test_params, msg);
/* message is no longer needed */
xio_release_response(msg);
msg_pool_put(test_params->pool, msg);
if (test_params->finite_run) {
if (test_params->nrecv == test_params->disconnect_nr) {
xio_disconnect(test_params->connection);
return 0;
}
if (test_params->nsent == test_params->disconnect_nr)
return 0;
}
/* peek message from the pool */
msg = msg_pool_get(test_params->pool);
if (msg == NULL) {
printf("pool is empty\n");
return 0;
}
msg->in.header.iov_base = NULL;
msg->in.header.iov_len = 0;
sglist = vmsg_sglist(&msg->in);
vmsg_sglist_set_nents(&msg->in, test_config.in_iov_len);
/* tell accelio to use 1MB buffer from its internal pool */
for (j = 0; j < test_config.in_iov_len; j++) {
sglist[j].iov_base = NULL;
sglist[j].iov_len = ONE_MB;
sglist[j].mr = NULL;
}
msg->sn = 0;
/* assign buffers to the message */
msg_build_out_sgl(&test_params->msg_params, msg,
test_config.hdr_len,
test_config.out_iov_len, test_config.data_len);
if (chain_messages) {
msg->next = NULL;
if (test_params->chain.head == NULL) {
test_params->chain.head = msg;
test_params->chain.tail = test_params->chain.head;
} else {
test_params->chain.tail->next = msg;
test_params->chain.tail = test_params->chain.tail->next;
}
if (++test_params->chain.sz == MAX_OUTSTANDING_REQS) {
if (xio_send_request(test_params->connection,
test_params->chain.head) == -1) {
if (xio_errno() != EAGAIN)
printf("**** [%p] Error - xio_send_request " \
"failed %s\n",
session,
xio_strerror(xio_errno()));
msg_pool_put(test_params->pool, msg);
xio_assert(xio_errno() == EAGAIN);
}
test_params->nsent += test_params->chain.sz;
test_params->chain.head = NULL;
test_params->chain.sz = 0;
}
} else {
/* try to send it */
/*msg->flags = XIO_MSG_FLAG_REQUEST_READ_RECEIPT; */
/*msg->flags = XIO_MSG_FLAG_PEER_READ_REQ;*/
if (xio_send_request(test_params->connection, msg) == -1) {
if (xio_errno() != EAGAIN)
printf("**** [%p] Error - xio_send_request " \
"failed %s\n",
session,
xio_strerror(xio_errno()));
msg_pool_put(test_params->pool, msg);
xio_assert(xio_errno() == EAGAIN);
}
test_params->nsent++;
}
return 0;
}