int assign_data_in_buf(struct xio_msg *msg, void *cb_user_context)
{
static int first_time = 1;
static char *buf = NULL;
static struct xio_mr *mr = NULL;
msg->in.data_iovlen = 1;
if (first_time) {
msg->in.data_iov[0].iov_base = calloc(XIO_READ_BUF_LEN, 1);
msg->in.data_iov[0].iov_len = XIO_READ_BUF_LEN;
msg->in.data_iov[0].mr =
xio_reg_mr(msg->in.data_iov[0].iov_base,
msg->in.data_iov[0].iov_len);
buf = msg->in.data_iov[0].iov_base;
mr = msg->in.data_iov[0].mr;
first_time = 0;
} else {
msg->in.data_iov[0].iov_base = buf;
msg->in.data_iov[0].iov_len = XIO_READ_BUF_LEN;
msg->in.data_iov[0].mr = mr;
}
return 0;
}
/*---------------------------------------------------------------------------*/
int msg_api_init(struct msg_params *msg_params,
size_t hdrlen, size_t datalen, int is_server)
{
const char *req_hdr = "hello world request header";
const char *req_data = "hello world request data";
const char *rsp_hdr = "hello world response header";
const char *rsp_data = "hello world response data";
const char *ptr;
size_t len;
int pagesize = sysconf(_SC_PAGESIZE);
if (pagesize < 0)
return -1;
msg_params->g_hdr = NULL;
msg_params->g_data = NULL;
if (hdrlen) {
msg_params->g_hdr = (uint8_t *)memalign(pagesize, hdrlen);
if (!msg_params->g_hdr)
goto cleanup;
ptr = (is_server) ? rsp_hdr : req_hdr;
len = strlen(ptr);
if (hdrlen <= len)
len = hdrlen - 1;
if (len)
strncpy((char *)msg_params->g_hdr, ptr, len);
msg_params->g_hdr[len] = 0;
}
if (datalen) {
datalen = ALIGNHUGEPAGE(datalen);
msg_params->g_data = (uint8_t *)alloc_mem_buf(datalen,
&msg_params->g_shmid);
if (!msg_params->g_data)
goto cleanup;
ptr = (is_server) ? rsp_data : req_data;
len = strlen(ptr);
if (datalen <= len)
len = datalen - 1;
if (len)
strncpy((char *)msg_params->g_data, ptr, len);
msg_params->g_data[len] = 0;
msg_params->g_data_mr =
xio_reg_mr(msg_params->g_data, datalen);
if (!msg_params->g_data_mr)
goto cleanup;
}
return 0;
cleanup:
msg_api_free(msg_params);
return -1;
}
/*---------------------------------------------------------------------------*/
struct perf_buf *xio_buf_alloc(size_t size)
{
struct perf_buf * pbuf;
pbuf = calloc(1, sizeof(*pbuf));
pbuf->addr = alloc_mem_buf(ALIGNHUGEPAGE(size) , &pbuf->shmid);
pbuf->length = size;
pbuf->mr = xio_reg_mr(pbuf->addr, pbuf->length);
return pbuf;
}
/*---------------------------------------------------------------------------*/
struct xio_buf *xio_alloc(size_t length)
{
struct xio_buf *buf;
size_t real_size;
int alloced = 0;
buf = (struct xio_buf *)ucalloc(1, sizeof(*buf));
if (!buf) {
xio_set_error(errno);
ERROR_LOG("calloc failed. (errno=%d %m)\n", errno);
return NULL;
}
real_size = ALIGN(length, page_size);
buf->addr = umemalign(page_size, real_size);
if (!buf->addr) {
ERROR_LOG("xio_memalign failed. sz:%zu\n", real_size);
goto cleanup;
}
memset(buf->addr, 0, real_size);
alloced = 1;
buf->mr = xio_reg_mr(&buf->addr, length);
if (!buf->mr) {
ERROR_LOG("xio_reg_mr failed. addr:%p, length:%d\n",
buf->addr, length, access);
goto cleanup1;
}
buf->length = length;
return buf;
cleanup1:
if (alloced)
ufree(buf->addr);
cleanup:
ufree(buf);
return NULL;
}
/*---------------------------------------------------------------------------*/
static int assign_data_in_buf(struct xio_msg *msg, void *cb_user_context)
{
struct ow_test_params *ow_params = cb_user_context;
msg->in.data_iovlen = 1;
if (ow_params->mr == NULL) {
msg->in.data_iov[0].iov_base = calloc(XIO_READ_BUF_LEN, 1);
msg->in.data_iov[0].iov_len = XIO_READ_BUF_LEN;
msg->in.data_iov[0].mr =
xio_reg_mr(msg->in.data_iov[0].iov_base,
msg->in.data_iov[0].iov_len);
ow_params->buf = msg->in.data_iov[0].iov_base;
ow_params->mr = msg->in.data_iov[0].mr;
} else {
msg->in.data_iov[0].iov_base = ow_params->buf;
msg->in.data_iov[0].iov_len = XIO_READ_BUF_LEN;
msg->in.data_iov[0].mr = ow_params->mr;
}
return 0;
}
/*---------------------------------------------------------------------------*/
int assign_data_in_buf(struct xio_msg *msg, void *cb_user_context)
{
struct thread_data *tdata = cb_user_context;
msg->in.data_iovlen = 1;
if (tdata->buf == NULL) {
msg->in.data_iov[0].iov_base = calloc(XIO_READ_BUF_LEN, 1);
msg->in.data_iov[0].iov_len = XIO_READ_BUF_LEN;
msg->in.data_iov[0].mr =
xio_reg_mr(msg->in.data_iov[0].iov_base,
msg->in.data_iov[0].iov_len);
tdata->buf = msg->in.data_iov[0].iov_base;
tdata->mr = msg->in.data_iov[0].mr;
} else {
msg->in.data_iov[0].iov_base = tdata->buf;
msg->in.data_iov[0].iov_len = XIO_READ_BUF_LEN;
msg->in.data_iov[0].mr = tdata->mr;
}
return 0;
}
/*---------------------------------------------------------------------------*/
struct msg_pool *msg_pool_alloc(int max,
size_t out_hdrlen, size_t out_datalen,
size_t in_hdrlen, size_t in_datalen)
{
struct msg_pool *msg_pool;
struct xio_msg *msg;
size_t len;
size_t hdrlen;
size_t datalen;
int i;
uint8_t *buf;
uint8_t *header;
uint8_t *data;
/* allocate the structures */
len = sizeof(struct msg_pool)+
max*(2*sizeof(struct xio_msg *)+sizeof(struct xio_msg));
buf = calloc(len, sizeof(uint8_t));
if (!buf) {
fprintf(stderr, "Couldn't allocate message pool\n");
exit(1);
}
datalen = max*(out_datalen + in_datalen);
hdrlen = max*(out_hdrlen + in_hdrlen);
/* pool */
msg_pool = (struct msg_pool *)buf;
buf = buf + sizeof(struct msg_pool);
/* stack */
msg_pool->stack = (struct xio_msg **)buf;
buf = buf + max * sizeof(struct xio_msg *);
/* array */
msg_pool->array = (struct xio_msg **)buf;
buf = buf + max * sizeof(struct xio_msg *);
/* header */
if (hdrlen) {
msg_pool->header = calloc(hdrlen, sizeof(uint8_t));
if (!buf) {
fprintf(stderr, "Couldn't allocate message pool\n");
exit(1);
}
}
/* data */
if (datalen) {
datalen = ALIGNHUGEPAGE(datalen);
msg_pool->data = alloc_mem_buf(datalen, &msg_pool->shmid);
if (!msg_pool->data) {
fprintf(stderr, "Couldn't allocate data buffers\n");
free(buf);
exit(1);
}
memset(msg_pool->data, 0, datalen);
msg_pool->mr = xio_reg_mr(msg_pool->data, datalen);
}
data = msg_pool->data;
header = msg_pool->header;
for (i = 0; i < max; i++) {
msg_pool->array[i] = (struct xio_msg *)buf;
buf = buf + sizeof(struct xio_msg);
msg = msg_pool->array[i];
msg_pool->stack[i] = msg;
if (out_hdrlen) {
msg->out.header.iov_base = header;
msg->out.header.iov_len = out_hdrlen;
header = header + out_hdrlen;
}
if (out_datalen) {
msg->out.data_iov[0].iov_base = data;
msg->out.data_iov[0].iov_len = out_datalen;
msg->out.data_iov[0].mr = msg_pool->mr;
data = data + out_datalen;
msg->out.data_iovlen = 1;
}
if (in_hdrlen) {
msg->in.header.iov_base = header;
msg->in.header.iov_len = in_hdrlen;
header = header + in_hdrlen;
}
if (in_datalen) {
msg->in.data_iov[0].iov_base = data;
msg->in.data_iov[0].iov_len = in_datalen;
msg->in.data_iov[0].mr = msg_pool->mr;
data = data + in_datalen;
msg->in.data_iovlen = 1;
}
}
msg_pool->stack_ptr = msg_pool->stack;
msg_pool->stack_end = msg_pool->stack_ptr + max;
msg_pool->max = max;
return msg_pool;
}
/*---------------------------------------------------------------------------*/
int msg_api_init(struct msg_params *msg_params, size_t hdrlen, size_t datalen, int is_server)
{
int pagesize = sysconf(_SC_PAGESIZE);
const char *req_hdr = "hello world request header";
const char *req_data = "hello world request data";
const char *rsp_hdr = "hello world response header";
const char *rsp_data = "hello world response data";
const char *ptr;
int len, i;
unsigned char c;
msg_params->g_hdr = NULL;
msg_params->g_data = NULL;
if (hdrlen) {
msg_params->g_hdr = memalign(pagesize, hdrlen);
if (!msg_params->g_hdr)
goto cleanup;
ptr = (is_server) ? rsp_hdr : req_hdr;
len = strlen(ptr);
if (hdrlen < len)
len = hdrlen;
strncpy((char *)msg_params->g_hdr, ptr, len);
msg_params->g_hdr[len] = 0;
len++;
for (i = len, c = 65; i < hdrlen; i++) {
msg_params->g_hdr[i] = c;
c++;
if (c > 122)
c = 65;
}
}
if (datalen) {
datalen = ALIGNHUGEPAGE(datalen);
msg_params->g_data = alloc_mem_buf(datalen, &msg_params->g_shmid);
if (!msg_params->g_data)
goto cleanup;
ptr = (is_server) ? rsp_data : req_data;
len = strlen(ptr);
if (datalen < len)
len = datalen;
strncpy((char *)msg_params->g_data, ptr, len);
msg_params->g_data[len] = 0;
len++;
for (i = len, c = 65; i < datalen; i++) {
msg_params->g_data[i] = c;
c++;
if (c > 122)
c = 65;
}
msg_params->g_data_mr = xio_reg_mr(msg_params->g_data, datalen);
}
return 0;
cleanup:
if (msg_params->g_hdr) {
free(msg_params->g_hdr);
msg_params->g_hdr = NULL;
}
if (msg_params->g_data) {
free_mem_buf(msg_params->g_data, msg_params->g_shmid);
msg_params->g_data = NULL;
}
return -1;
}
