static struct xio_connection *sd_xio_create_connection(struct xio_context *ctx, const struct node_id *nid, void *user_ctx) { struct xio_connection *conn; struct xio_session *session; char url[256]; struct xio_session_params params; struct xio_connection_params cparams; if (nid->io_transport_type == IO_TRANSPORT_TYPE_RDMA) snprintf(url, 256, "rdma://%s", addr_to_str(nid->io_addr, nid->io_port)); else snprintf(url, 256, "tcp://%s", addr_to_str(nid->io_addr, nid->io_port)); memset(¶ms, 0, sizeof(params)); params.type = XIO_SESSION_CLIENT; params.ses_ops = &client_ses_ops; params.uri = url; params.user_context = user_ctx; session = xio_session_create(¶ms); memset(&cparams, 0, sizeof(cparams)); cparams.session = session; cparams.ctx = ctx; cparams.conn_user_context = user_ctx; conn = xio_connect(&cparams); return conn; }
struct xio_connection *sd_xio_gw_create_connection(struct xio_context *ctx, struct xio_session *session, void *user_ctx) { struct xio_connection *conn; struct xio_connection_params cparams; memset(&cparams, 0, sizeof(cparams)); cparams.session = session; cparams.ctx = ctx; cparams.conn_user_context = user_ctx; conn = xio_connect(&cparams); return conn; }
/*---------------------------------------------------------------------------*/ int main(int argc, char *argv[]) { struct xio_session *session; char url[256]; struct session_data session_data; int i = 0; struct xio_session_params params; if (argc < 3) { printf("Usage: %s <host> <port> <transport:optional>\n", argv[0]); exit(1); } memset(&session_data, 0, sizeof(session_data)); memset(¶ms, 0, sizeof(params)); /* initialize library */ xio_init(); /* create thread context for the client */ session_data.ctx = xio_context_create(NULL, 0, -1); /* create url to connect to */ if (argc > 3) sprintf(url, "%s://%s:%s", argv[3], argv[1], argv[2]); else sprintf(url, "rdma://%s:%s", argv[1], argv[2]); params.type = XIO_SESSION_CLIENT; params.ses_ops = &ses_ops; params.user_context = &session_data; params.uri = url; session = xio_session_create(¶ms); /* connect the session */ session_data.conn = xio_connect(session, session_data.ctx, 0, NULL, &session_data); /* create "hello world" message */ for (i = 0; i < QUEUE_DEPTH; i++) { memset(&session_data.req[i], 0, sizeof(session_data.req[i])); /* header */ session_data.req[i].out.header.iov_base = strdup("hello world header request"); session_data.req[i].out.header.iov_len = strlen(session_data.req[i].out.header.iov_base) + 1; /* iovec[0]*/ session_data.req[i].in.sgl_type = XIO_SGL_TYPE_IOV; session_data.req[i].in.data_iov.max_nents = XIO_IOVLEN; session_data.req[i].out.sgl_type = XIO_SGL_TYPE_IOV; session_data.req[i].out.data_iov.max_nents = XIO_IOVLEN; session_data.req[i].out.data_iov.sglist[0].iov_base = strdup("hello world data request"); session_data.req[i].out.data_iov.sglist[0].iov_len = strlen(session_data.req[i].out.data_iov.sglist[0].iov_base) + 1; session_data.req[i].out.data_iov.nents = 1; } /* send first message */ for (i = 0; i < QUEUE_DEPTH; i++) { xio_send_request(session_data.conn, &session_data.req[i]); session_data.nsent++; } /* event dispatcher is now running */ xio_context_run_loop(session_data.ctx, XIO_INFINITE); /* normal exit phase */ fprintf(stdout, "exit signaled\n"); /* free the message */ for (i = 0; i < QUEUE_DEPTH; i++) { free(session_data.req[i].out.header.iov_base); free(session_data.req[i].out.data_iov.sglist[0].iov_base); } /* free the context */ xio_context_destroy(session_data.ctx); xio_shutdown(); printf("good bye\n"); return 0; }
/*---------------------------------------------------------------------------*/ static int xio_client_main(void *data) { char **argv = (char **) data; struct xio_session *session; char url[256]; struct xio_context *ctx; struct hw_session_data *session_data; int i = 0; /* client session attributes */ struct xio_session_attr attr = { &ses_ops, /* callbacks structure */ NULL, /* no need to pass the server private data */ 0 }; session_data = kzalloc(sizeof(*session_data), GFP_KERNEL); if (!session_data) { printk("session_data alloc failed\n"); return 0; } /* create thread context for the client */ ctx = xio_ctx_open(XIO_LOOP_GIVEN_THREAD, NULL, current, 0, -1); if (!ctx) { kfree(session_data); printk("context open filed\n"); return 0; } session_data->ctx = ctx; /* create url to connect to */ sprintf(url, "rdma://%s:%s", argv[1], argv[2]); session = xio_session_open(XIO_SESSION_REQ, &attr, url, 0, 0, session_data); /* connect the session */ session_data->conn = xio_connect(session, ctx, 0, NULL, session_data); /* create "hello world" message */ for (i = 0; i < QUEUE_DEPTH; i++) { memset(&session_data->req[i], 0, sizeof(session_data->req[i])); session_data->req[i].out.header.iov_base = kstrdup("hello world header request", GFP_KERNEL); session_data->req[i].out.header.iov_len = strlen(session_data->req[i].out.header.iov_base); } /* send first message */ for (i = 0; i < QUEUE_DEPTH; i++) xio_send_request(session_data->conn, &session_data->req[i]); /* the default xio supplied main loop */ xio_ev_loop_run(ctx); /* normal exit phase */ printk("exit signaled\n"); /* free the message */ for (i = 0; i < QUEUE_DEPTH; i++) kfree(session_data->req[i].out.header.iov_base); /* free the context */ xio_ctx_close(ctx); kfree(session_data); printk("good bye\n"); return 0; }
/*---------------------------------------------------------------------------*/ int main(int argc, char *const argv[]) { struct xio_session *session; char url[256]; int i; struct sigaction sa; int c; char *addr = NULL; char *port = NULL; char *trans = NULL; struct xio_session_params params; struct xio_connection_params cparams; while (1) { c = getopt_long(argc, argv, "a:p:r:hdnV", longopts, NULL); if (c == -1) break; switch (c) { case 'a': addr = optarg; break; case 'p': port = optarg; break; case 'r': trans = optarg; break; case 'h': usage(argv[0], 0); case 'd': debug_flag++; nofork_flag++; break; case 'n': nofork_flag++; break; case 'V': printf("%s\n", PACKAGE_STRING); exit(0); break; default: usage(argv[0], 1); break; } } memset(&sa, 0, sizeof(sa)); sa.sa_handler = signal_handler; sigaction(SIGINT, &sa, NULL); sigaction(SIGTERM, &sa, NULL); sigaction(SIGQUIT, &sa, NULL); sigaction(SIGHUP, &sa, NULL); sa.sa_handler = SIG_IGN; sa.sa_flags = SA_RESTART; sigaction(SIGPIPE, &sa, NULL); if (!nofork_flag && daemon(0, 0)) { logerr("daemon() failed"); exit(1); } if (!debug_flag) { openlog("xioclntd", LOG_PID, LOG_DAEMON); use_syslog = 1; } /* Create the process PID file */ if (create_pidfile(pid_file) != 0) exit(EXIT_FAILURE); memset(&session_data, 0, sizeof(session_data)); memset(¶ms, 0, sizeof(params)); memset(&cparams, 0, sizeof(cparams)); /* initialize library */ xio_init(); /* create "hello world" message */ for (i = 0; i < QUEUE_DEPTH; i++) { memset(&session_data.req[i], 0, sizeof(session_data.req[i])); /* header */ session_data.req[i].out.header.iov_base = strdup("hello world header request"); session_data.req[i].out.header.iov_len = strlen((const char *) session_data.req[i].out.header.iov_base) + 1; /* iovec[0]*/ session_data.req[i].out.sgl_type = XIO_SGL_TYPE_IOV; session_data.req[i].out.data_iov.max_nents = XIO_IOVLEN; session_data.req[i].out.data_iov.sglist[0].iov_base = strdup("hello world iovec request"); session_data.req[i].out.data_iov.sglist[0].iov_len = strlen((const char *) session_data.req[i].out.data_iov.sglist[0].iov_base) + 1; session_data.req[i].out.data_iov.nents = 1; } /* create thread context for the client */ session_data.ctx = xio_context_create(NULL, 0, -1); /* create url to connect to */ if (trans) sprintf(url, "%s://%s:%s", trans, addr, port); else sprintf(url, "rdma://%s:%s", addr, port); params.type = XIO_SESSION_CLIENT; params.ses_ops = &ses_ops; params.user_context = &session_data; params.uri = url; reconnect: session = xio_session_create(¶ms); cparams.session = session; cparams.ctx = session_data.ctx; cparams.conn_user_context = &session_data; /* connect the session */ session_data.conn = xio_connect(&cparams); /* event dispatcher is now running */ xio_context_run_loop(session_data.ctx, XIO_INFINITE); if (reconnect_flag || reload_flag) { session_data.cnt = 0; if (reconnect_flag) sleep(1); reload_flag = 0; reconnect_flag = 0; goto reconnect; } /* normal exit phase */ logit(LOG_INFO, "exit signaled\n"); /* free the message */ for (i = 0; i < QUEUE_DEPTH; i++) { free(session_data.req[i].out.header.iov_base); free(session_data.req[i].out.data_iov.sglist[0].iov_base); } /* free the context */ xio_context_destroy(session_data.ctx); xio_shutdown(); remove_pidfile(); if (use_syslog) closelog(); return 0; }
/*---------------------------------------------------------------------------*/ static void *worker_thread(void *data) { struct thread_data *tdata = data; cpu_set_t cpuset; struct xio_msg *msg; int i; /* set affinity to thread */ CPU_ZERO(&cpuset); CPU_SET(tdata->affinity, &cpuset); pthread_setaffinity_np(tdata->thread_id, sizeof(cpu_set_t), &cpuset); /* prepare data for the cuurent thread */ tdata->pool = msg_pool_alloc(tdata->user_param->queue_depth); /* create thread context for the client */ tdata->ctx = xio_context_create(NULL, tdata->user_param->poll_timeout, tdata->affinity); /* connect the session */ tdata->conn = xio_connect(tdata->session, tdata->ctx, tdata->cid, NULL, tdata); if (tdata->data_len) tdata->xbuf = xio_alloc(tdata->data_len); for (i = 0; i < tdata->user_param->queue_depth; i++) { /* create transaction */ msg = msg_pool_get(tdata->pool); if (msg == NULL) break; /* get pointers to internal buffers */ msg->in.header.iov_len = 0; msg->in.data_iovlen = 0; msg->out.header.iov_len = 0; if (tdata->data_len) { msg->out.data_iovlen = 1; msg->out.data_iov[0].iov_base = tdata->xbuf->addr; msg->out.data_iov[0].iov_len = tdata->xbuf->length; msg->out.data_iov[0].mr = tdata->xbuf->mr; } else { msg->out.data_iovlen = 0; } msg->user_context = (void *)get_cycles(); /* send first message */ if (xio_send_request(tdata->conn, msg) == -1) { if (xio_errno() != EAGAIN) printf("**** [%p] Error - xio_send_request " \ "failed. %s\n", tdata->session, xio_strerror(xio_errno())); msg_pool_put(tdata->pool, msg); return 0; } if (tdata->do_stat) tdata->stat.scnt++; tdata->tx_nr++; } /* the default xio supplied main loop */ xio_context_run_loop(tdata->ctx, XIO_INFINITE); /* normal exit phase */ if (tdata->pool) msg_pool_free(tdata->pool); if (tdata->xbuf) xio_free(&tdata->xbuf); /* free the context */ xio_context_destroy(tdata->ctx); return NULL; }
/*---------------------------------------------------------------------------*/ int main(int argc, char *argv[]) { struct xio_session *session; char url[256]; struct session_data session_data; int i = 0; /* client session attributes */ struct xio_session_attr attr = { &ses_ops, /* callbacks structure */ NULL, /* no need to pass the server private data */ 0 }; memset(&session_data, 0, sizeof(session_data)); /* initialize library */ xio_init(); /* create thread context for the client */ session_data.ctx = xio_context_create(NULL, 0); /* create url to connect to */ sprintf(url, "rdma://%s:%s", argv[1], argv[2]); session = xio_session_create(XIO_SESSION_CLIENT, &attr, url, 0, 0, &session_data); /* connect the session */ session_data.conn = xio_connect(session, session_data.ctx, 0, NULL, &session_data); /* create "hello world" message */ for (i = 0; i < QUEUE_DEPTH; i++) { memset(&session_data.req[i], 0, sizeof(session_data.req[i])); session_data.req[i].out.header.iov_base = strdup("hello world header request"); session_data.req[i].out.header.iov_len = strlen(session_data.req[i].out.header.iov_base) + 1; } /* send first message */ for (i = 0; i < QUEUE_DEPTH; i++) { xio_send_request(session_data.conn, &session_data.req[i]); session_data.nsent++; } /* event dispatcher is now running */ xio_context_run_loop(session_data.ctx, XIO_INFINITE); /* normal exit phase */ fprintf(stdout, "exit signaled\n"); /* free the message */ for (i = 0; i < QUEUE_DEPTH; i++) free(session_data.req[i].out.header.iov_base); /* free the context */ xio_context_destroy(session_data.ctx); xio_shutdown(); printf("good bye\n"); return 0; }
/*---------------------------------------------------------------------------*/ int main(int argc, char *argv[]) { struct xio_session *session; char url[256]; struct session_data session_data; int i = 0; struct event timeout; struct event xio_event; struct timeval tv; struct xio_poll_params poll_params; struct xio_session_params params; if (argc < 3) { printf("Usage: %s <host> <port> <transport:optional>\n", argv[0]); exit(1); } memset(&session_data, 0, sizeof(session_data)); memset(¶ms, 0, sizeof(params)); /* initialize library */ xio_init(); /* create thread context for the client */ session_data.ctx = xio_context_create(NULL, 0, -1); /* get poll parameters for libevent */ xio_context_get_poll_params(session_data.ctx, &poll_params); /* create url to connect to */ if (argc > 3) sprintf(url, "%s://%s:%s", argv[3], argv[1], argv[2]); else sprintf(url, "rdma://%s:%s", argv[1], argv[2]); params.type = XIO_SESSION_CLIENT; params.ses_ops = &ses_ops; params.user_context = &session_data; params.uri = url; session = xio_session_create(¶ms); /* connect the session */ session_data.conn = xio_connect(session, session_data.ctx, 0, NULL, &session_data); /* create "hello world" message */ for (i = 0; i < QUEUE_DEPTH; i++) { memset(&session_data.req[i], 0, sizeof(session_data.req[i])); /* header */ session_data.req[i].out.header.iov_base = strdup("hello world header request"); session_data.req[i].out.header.iov_len = strlen(session_data.req[i].out.header.iov_base) + 1; /* iovec[0]*/ session_data.req[i].out.sgl_type = XIO_SGL_TYPE_IOV; session_data.req[i].out.data_iov.max_nents = XIO_IOVLEN; session_data.req[i].out.data_iov.sglist[0].iov_base = strdup("hello world iovec request"); session_data.req[i].out.data_iov.sglist[0].iov_len = strlen(session_data.req[i].out.data_iov.sglist[0].iov_base) + 1; session_data.req[i].out.data_iov.nents = 1; } /* send first message */ for (i = 0; i < QUEUE_DEPTH; i++) { xio_send_request(session_data.conn, &session_data.req[i]); session_data.nsent++; } /* Initialize the event library */ session_data.evbase = event_base_new(); /* Initialize one timer event */ event_assign(&timeout, session_data.evbase, -1, EV_PERSIST, timeout_cb, (void *)&timeout); evutil_timerclear(&tv); tv.tv_sec = 2; event_add(&timeout, &tv); event_assign(&xio_event, session_data.evbase, poll_params.fd, EV_READ|EV_PERSIST, xio_event_handler, (void *)&poll_params); /* Add it to the active events, without a timeout */ event_add(&xio_event, NULL); event_base_dispatch(session_data.evbase); fprintf(stdout, "exit signaled\n"); event_base_free(session_data.evbase); /* free the message */ for (i = 0; i < QUEUE_DEPTH; i++) { free(session_data.req[i].out.header.iov_base); free(session_data.req[i].out.data_iov.sglist[0].iov_base); } /* free the context */ xio_context_destroy(session_data.ctx); xio_shutdown(); printf("good bye\n"); return 0; }
/*---------------------------------------------------------------------------*/ static int xio_client_main(void *data) { char url[256]; struct xio_session_params params; struct xio_context_params ctx_params; struct xio_connection_params cparams; int error; int retval = 0; atomic_add(2, &module_state); print_counter = PRINT_COUNTER; print_test_config(&test_config); memset(¶ms, 0, sizeof(params)); memset(&cparams, 0, sizeof(cparams)); /* prepare buffers for this test */ if (msg_api_init(&msg_params, test_config.hdr_len, test_config.data_len, 0) != 0) { pr_err("msg_api_init failed\n"); return -1; } pool = msg_pool_alloc(MAX_POOL_SIZE, 1, 1); if (!pool) { pr_err("msg_pool_alloc failed\n"); goto cleanup; } /* create thread context for the server */ memset(&ctx_params, 0, sizeof(ctx_params)); ctx_params.flags = XIO_LOOP_GIVEN_THREAD; ctx_params.worker = current; ctx = xio_context_create(&ctx_params, POLLING_TIMEOUT, cpu); if (!ctx) { pr_err("context open failed\n"); goto cleanup; } sprintf(url, "%s://%s:%d", test_config.transport, test_config.server_addr, test_config.server_port); params.type = XIO_SESSION_CLIENT; params.ses_ops = &ses_ops; params.uri = url; g_session = xio_session_create(¶ms); if (!g_session) pr_err("session creation failed\n"); cparams.session = g_session; cparams.ctx = ctx; cparams.conn_idx = test_config.conn_idx; /* connect the session */ g_connection = xio_connect(&cparams); /* the default xio supplied main loop */ if (atomic_add_unless(&module_state, 4, 0x83)) retval = xio_context_run_loop(ctx); atomic_sub(4, &module_state); if (retval != 0) { error = xio_errno(); pr_err("running event loop failed. reason %d - (%s)\n", error, xio_strerror(error)); xio_assert(retval == 0); } /* normal exit phase */ pr_info("exit signaled\n"); xio_context_destroy(ctx); msg_pool_free(pool); cleanup: msg_api_free(&msg_params); pr_info("exit complete\n"); complete_and_exit(&cleanup_complete, 0); return 0; }
/*---------------------------------------------------------------------------*/ static int xio_client_main(void *data) { char **argv = (char **)data; struct xio_session *session; struct xio_session_params params; struct xio_context_params ctx_params; struct xio_connection_params cparams; char url[256]; struct xio_context *ctx; struct session_data *session_data; int i = 0; atomic_add(2, &module_state); session_data = vzalloc(sizeof(*session_data)); if (!session_data) { /*pr_err("session_data alloc failed\n");*/ return 0; } /* create thread context for the client */ memset(&ctx_params, 0, sizeof(ctx_params)); ctx_params.flags = XIO_LOOP_GIVEN_THREAD; ctx_params.worker = current; ctx = xio_context_create(&ctx_params, 0, -1); if (!ctx) { vfree(session_data); pr_err("context open filed\n"); return 0; } session_data->ctx = ctx; /* create url to connect to */ sprintf(url, "rdma://%s:%s", argv[1], argv[2]); memset(¶ms, 0, sizeof(params)); params.type = XIO_SESSION_CLIENT; params.ses_ops = &ses_ops; params.user_context = session_data; params.uri = url; session = xio_session_create(¶ms); memset(&cparams, 0, sizeof(cparams)); cparams.session = session; cparams.ctx = ctx; cparams.conn_user_context = session_data; /* connect the session */ session_data->session = session; session_data->connection = xio_connect(&cparams); /* create "hello world" message */ for (i = 0; i < QUEUE_DEPTH; i++) { struct xio_vmsg *omsg; void *buf; omsg = &session_data->req[i].out; memset(&session_data->req[i], 0, sizeof(session_data->req[i])); /* header */ buf = kstrdup("hello world header request", GFP_KERNEL); session_data->req[i].out.header.iov_base = buf; session_data->req[i].out.header.iov_len = strlen(buf) + 1; /* iovec[0]*/ omsg->sgl_type = XIO_SGL_TYPE_SCATTERLIST; sg_alloc_table(&omsg->data_tbl, SG_TBL_LEN, GFP_KERNEL); /* currently only one entry */ buf = kstrdup("hello world iovec request", GFP_KERNEL); sg_init_one(omsg->data_tbl.sgl, buf, strlen(buf) + 1); /* orig_nents is XIO_IOVLEN */ omsg->data_tbl.nents = 1; } /* send first message */ for (i = 0; i < QUEUE_DEPTH; i++) xio_send_request(session_data->connection, &session_data->req[i]); g_session_data = session_data; /* the default xio supplied main loop */ if (atomic_add_unless(&module_state, 4, 0x83)) xio_context_run_loop(ctx); atomic_sub(4, &module_state); /* normal exit phase */ pr_info("exit signaled\n"); /* free the message */ for (i = 0; i < QUEUE_DEPTH; i++) { kfree(session_data->req[i].out.header.iov_base); /* Currently need to release only one entry */ kfree(sg_virt(session_data->req[i].out.data_tbl.sgl)); sg_free_table(&session_data->req[i].out.data_tbl); } /* free the context */ xio_context_destroy(ctx); vfree(session_data); pr_info("good bye\n"); complete_and_exit(&cleanup_complete, 0); return 0; }
static void *worker_thread(void *data) { struct thread_data *tdata = data; cpu_set_t cpuset; struct xio_session **sessions = NULL; struct xio_context *ctx; struct session_data *session_data = NULL; int j = 0, n = 0; struct timespec start, end; void *loop = NULL; double *sec = NULL; /* set affinity to thread */ CPU_ZERO(&cpuset); CPU_SET(tdata->affinity, &cpuset); pthread_setaffinity_np(tdata->thread_id, sizeof(cpu_set_t), &cpuset); /* open default event loop */ loop = xio_ev_loop_init(); if (loop == NULL) { fprintf(stderr, "Failed to allocate event loop\n"); return (void*)(-1); } /* create thread context for the client */ ctx= xio_ctx_open(NULL, loop, 0); if(ctx == NULL) { fprintf(stderr, "Failed to allocate thread context\n"); xio_ev_loop_destroy(&loop); return (void*)-1; } session_data = malloc(tdata->num_sessions*sizeof(struct session_data)); sessions = malloc(tdata->num_sessions*sizeof(struct sessions *)); if( session_data == NULL || sessions == NULL ) { fprintf(stderr, "Allocation failed\n"); xio_ctx_close(ctx); xio_ev_loop_destroy(&loop); if(session_data) { free(session_data); } if(sessions) { free(sessions); } return (void*)-1; } for(n = 0; n < tdata->num_sessions; n++) { tdata->loop = loop; session_data[n].tdata = tdata; } /* client session attributes */ struct xio_session_attr attr = { &ses_ops, /* callbacks structure */ NULL, /* no need to pass the server private data */ 0 }; if(clock_gettime(CLOCK_MONOTONIC, &start)) { fprintf(stderr, "clock_gettime() failed, errno = %d\n", errno); } for (j = 0; j< NUM_ITER; j++) { for(n = 0; n < tdata->num_sessions; n++) { sessions[n] = xio_session_open(XIO_SESSION_REQ, &attr, tdata->url, 0, 0, &session_data[n]); /* connect the session */ //fprintf(stderr, "Connect Session\n"); session_data[n].conn = xio_connect(sessions[n], ctx, 0, &session_data[n]); } /* the default xio supplied main loop */ xio_ev_loop_run(loop); } if(clock_gettime(CLOCK_MONOTONIC, &end)) { fprintf(stderr, "clock_gettime() failed, errno = %d\n", errno); } /* normal exit phase */ fprintf(stdout, "exit signaled\n"); /* free the context */ xio_ctx_close(ctx); /* destroy the default loop */ xio_ev_loop_destroy(&loop); sec = malloc(sizeof(double)); *sec = (double)(((end.tv_sec * 1000000000 + end.tv_nsec) - (start.tv_sec * 1000000000 - start.tv_nsec))/NUM_ITER)/1000000000; fprintf(stdout, "THREAD [ %lu ] It took %lf sec for %d sessions\n", tdata->thread_id, *sec, tdata->num_sessions); free(session_data); free(sessions); return ((void *)sec); }