2 * Copyright (c) 2005-2006 Intel Corporation. All rights reserved.
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
39 #include <sys/types.h>
40 #include <netinet/in.h>
41 #include <sys/socket.h>
46 #include <rdma/rdma_cma.h>
48 #if __BYTE_ORDER == __BIG_ENDIAN
49 static inline uint64_t cpu_to_be64(uint64_t x) { return x; }
50 static inline uint32_t cpu_to_be32(uint32_t x) { return x; }
52 static inline uint64_t cpu_to_be64(uint64_t x) { return bswap_64(x); }
53 static inline uint32_t cpu_to_be32(uint32_t x) { return bswap_32(x); }
58 struct rdma_cm_id *cma_id;
72 struct rdma_event_channel *channel;
73 struct cmatest_node *nodes;
78 struct rdma_addr addr;
81 static struct cmatest test;
82 static int connections = 1;
83 static int message_size = 100;
84 static int message_count = 10;
85 static uint16_t port = 7471;
86 static uint8_t set_tos = 0;
88 static uint8_t migrate = 0;
89 static char *dst_addr;
90 static char *src_addr;
92 static int create_message(struct cmatest_node *node)
100 node->mem = malloc(message_size);
102 printf("failed message allocation\n");
105 node->mr = ibv_reg_mr(node->pd, node->mem, message_size,
106 IBV_ACCESS_LOCAL_WRITE);
108 printf("failed to reg MR\n");
117 static int init_node(struct cmatest_node *node)
119 struct ibv_qp_init_attr init_qp_attr;
122 node->pd = ibv_alloc_pd(node->cma_id->verbs);
125 printf("cmatose: unable to allocate PD\n");
129 cqe = message_count ? message_count : 1;
130 node->cq[SEND_CQ_INDEX] = ibv_create_cq(node->cma_id->verbs, cqe, node, 0, 0);
131 node->cq[RECV_CQ_INDEX] = ibv_create_cq(node->cma_id->verbs, cqe, node, 0, 0);
132 if (!node->cq[SEND_CQ_INDEX] || !node->cq[RECV_CQ_INDEX]) {
134 printf("cmatose: unable to create CQ\n");
138 memset(&init_qp_attr, 0, sizeof init_qp_attr);
139 init_qp_attr.cap.max_send_wr = cqe;
140 init_qp_attr.cap.max_recv_wr = cqe;
141 init_qp_attr.cap.max_send_sge = 1;
142 init_qp_attr.cap.max_recv_sge = 1;
143 init_qp_attr.qp_context = node;
144 init_qp_attr.sq_sig_all = 1;
145 init_qp_attr.qp_type = IBV_QPT_RC;
146 init_qp_attr.send_cq = node->cq[SEND_CQ_INDEX];
147 init_qp_attr.recv_cq = node->cq[RECV_CQ_INDEX];
148 ret = rdma_create_qp(node->cma_id, node->pd, &init_qp_attr);
150 perror("cmatose: unable to create QP");
154 ret = create_message(node);
156 printf("cmatose: failed to create messages: %d\n", ret);
163 static int post_recvs(struct cmatest_node *node)
165 struct ibv_recv_wr recv_wr, *recv_failure;
173 recv_wr.sg_list = &sge;
175 recv_wr.wr_id = (uintptr_t) node;
177 sge.length = message_size;
178 sge.lkey = node->mr->lkey;
179 sge.addr = (uintptr_t) node->mem;
181 for (i = 0; i < message_count && !ret; i++ ) {
182 ret = ibv_post_recv(node->cma_id->qp, &recv_wr, &recv_failure);
184 printf("failed to post receives: %d\n", ret);
191 static int post_sends(struct cmatest_node *node)
193 struct ibv_send_wr send_wr, *bad_send_wr;
197 if (!node->connected || !message_count)
201 send_wr.sg_list = &sge;
203 send_wr.opcode = IBV_WR_SEND;
204 send_wr.send_flags = 0;
205 send_wr.wr_id = (unsigned long)node;
207 sge.length = message_size;
208 sge.lkey = node->mr->lkey;
209 sge.addr = (uintptr_t) node->mem;
211 for (i = 0; i < message_count && !ret; i++) {
212 ret = ibv_post_send(node->cma_id->qp, &send_wr, &bad_send_wr);
214 printf("failed to post sends: %d\n", ret);
219 static void connect_error(void)
221 test.disconnects_left--;
222 test.connects_left--;
225 static int addr_handler(struct cmatest_node *node)
230 ret = rdma_set_option(node->cma_id, RDMA_OPTION_ID,
231 RDMA_OPTION_ID_TOS, &tos, sizeof tos);
233 perror("cmatose: set TOS option failed");
236 ret = rdma_resolve_route(node->cma_id, 2000);
238 perror("cmatose: resolve route failed");
244 static int route_handler(struct cmatest_node *node)
246 struct rdma_conn_param conn_param;
249 ret = init_node(node);
253 ret = post_recvs(node);
257 memset(&conn_param, 0, sizeof conn_param);
258 conn_param.responder_resources = 1;
259 conn_param.initiator_depth = 1;
260 conn_param.retry_count = 5;
261 ret = rdma_connect(node->cma_id, &conn_param);
263 perror("cmatose: failure connecting");
272 static int connect_handler(struct rdma_cm_id *cma_id)
274 struct cmatest_node *node;
275 struct rdma_conn_param conn_param;
278 if (test.conn_index == connections) {
282 node = &test.nodes[test.conn_index++];
284 node->cma_id = cma_id;
285 cma_id->context = node;
287 ret = init_node(node);
291 ret = post_recvs(node);
295 memset(&conn_param, 0, sizeof conn_param);
296 conn_param.responder_resources = 1;
297 conn_param.initiator_depth = 1;
298 ret = rdma_accept(node->cma_id, &conn_param);
300 perror("cmatose: failure accepting");
309 printf("cmatose: failing connection request\n");
310 rdma_reject(cma_id, NULL, 0);
314 static int cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
318 switch (event->event) {
319 case RDMA_CM_EVENT_ADDR_RESOLVED:
320 ret = addr_handler(cma_id->context);
322 case RDMA_CM_EVENT_ROUTE_RESOLVED:
323 ret = route_handler(cma_id->context);
325 case RDMA_CM_EVENT_CONNECT_REQUEST:
326 ret = connect_handler(cma_id);
328 case RDMA_CM_EVENT_ESTABLISHED:
329 ((struct cmatest_node *) cma_id->context)->connected = 1;
330 test.connects_left--;
332 case RDMA_CM_EVENT_ADDR_ERROR:
333 case RDMA_CM_EVENT_ROUTE_ERROR:
334 case RDMA_CM_EVENT_CONNECT_ERROR:
335 case RDMA_CM_EVENT_UNREACHABLE:
336 case RDMA_CM_EVENT_REJECTED:
337 printf("cmatose: event: %s, error: %d\n",
338 rdma_event_str(event->event), event->status);
341 case RDMA_CM_EVENT_DISCONNECTED:
342 rdma_disconnect(cma_id);
343 test.disconnects_left--;
345 case RDMA_CM_EVENT_DEVICE_REMOVAL:
346 /* Cleanup will occur after test completes. */
354 static void destroy_node(struct cmatest_node *node)
359 if (node->cma_id->qp)
360 rdma_destroy_qp(node->cma_id);
362 if (node->cq[SEND_CQ_INDEX])
363 ibv_destroy_cq(node->cq[SEND_CQ_INDEX]);
365 if (node->cq[RECV_CQ_INDEX])
366 ibv_destroy_cq(node->cq[RECV_CQ_INDEX]);
369 ibv_dereg_mr(node->mr);
374 ibv_dealloc_pd(node->pd);
376 /* Destroy the RDMA ID after all device resources */
377 rdma_destroy_id(node->cma_id);
380 static int alloc_nodes(void)
384 test.nodes = malloc(sizeof *test.nodes * connections);
386 printf("cmatose: unable to allocate memory for test nodes\n");
389 memset(test.nodes, 0, sizeof *test.nodes * connections);
391 for (i = 0; i < connections; i++) {
392 test.nodes[i].id = i;
394 ret = rdma_create_id(test.channel,
395 &test.nodes[i].cma_id,
396 &test.nodes[i], RDMA_PS_TCP);
404 rdma_destroy_id(test.nodes[i].cma_id);
409 static void destroy_nodes(void)
413 for (i = 0; i < connections; i++)
414 destroy_node(&test.nodes[i]);
418 static int poll_cqs(enum CQ_INDEX index)
423 for (i = 0; i < connections; i++) {
424 if (!test.nodes[i].connected)
427 for (done = 0; done < message_count; done += ret) {
428 ret = ibv_poll_cq(test.nodes[i].cq[index], 8, wc);
430 printf("cmatose: failed polling CQ: %d\n", ret);
438 static int connect_events(void)
440 struct rdma_cm_event *event;
441 int err = 0, ret = 0;
443 while (test.connects_left && !err) {
444 err = rdma_get_cm_event(test.channel, &event);
446 cma_handler(event->id, event);
447 rdma_ack_cm_event(event);
449 perror("cmatose: failure in rdma_get_cm_event in connect events");
457 static int disconnect_events(void)
459 struct rdma_cm_event *event;
460 int err = 0, ret = 0;
462 while (test.disconnects_left && !err) {
463 err = rdma_get_cm_event(test.channel, &event);
465 cma_handler(event->id, event);
466 rdma_ack_cm_event(event);
468 perror("cmatose: failure in rdma_get_cm_event in disconnect events");
476 static int migrate_channel(struct rdma_cm_id *listen_id)
478 struct rdma_event_channel *channel;
481 printf("migrating to new event channel\n");
483 channel = rdma_create_event_channel();
485 perror("cmatose: failed to create event channel");
491 ret = rdma_migrate_id(listen_id, channel);
493 for (i = 0; i < connections && !ret; i++)
494 ret = rdma_migrate_id(test.nodes[i].cma_id, channel);
497 rdma_destroy_event_channel(test.channel);
498 test.channel = channel;
500 perror("cmatose: failure migrating to channel");
505 static int get_addr(char *dst, struct sockaddr *addr)
507 struct addrinfo *res;
510 ret = getaddrinfo(dst, NULL, NULL, &res);
512 printf("getaddrinfo failed - invalid hostname or IP address\n");
516 if (res->ai_family == PF_INET)
517 memcpy(addr, res->ai_addr, sizeof(struct sockaddr_in));
518 else if (res->ai_family == PF_INET6)
519 memcpy(addr, res->ai_addr, sizeof(struct sockaddr_in6));
527 static int run_server(void)
529 struct rdma_cm_id *listen_id;
532 printf("cmatose: starting server\n");
533 ret = rdma_create_id(test.channel, &listen_id, &test, RDMA_PS_TCP);
535 perror("cmatose: listen request failed");
540 ret = get_addr(src_addr, &test.addr.src_addr);
543 if (test.addr.src_addr.sa_family == AF_INET)
544 ((struct sockaddr_in *) &test.addr.src_addr)->sin_port = port;
546 ((struct sockaddr_in6 *) &test.addr.src_addr)->sin6_port = port;
549 test.addr.src_addr.sa_family = PF_INET;
550 ((struct sockaddr_in *) &test.addr.src_addr)->sin_port = port;
553 ret = rdma_bind_addr(listen_id, &test.addr.src_addr);
556 perror("cmatose: bind address failed");
560 ret = rdma_listen(listen_id, 0);
562 perror("cmatose: failure trying to listen");
566 ret = connect_events();
571 printf("initiating data transfers\n");
572 for (i = 0; i < connections; i++) {
573 ret = post_sends(&test.nodes[i]);
578 printf("completing sends\n");
579 ret = poll_cqs(SEND_CQ_INDEX);
583 printf("receiving data transfers\n");
584 ret = poll_cqs(RECV_CQ_INDEX);
587 printf("data transfers complete\n");
592 ret = migrate_channel(listen_id);
597 printf("cmatose: disconnecting\n");
598 for (i = 0; i < connections; i++) {
599 if (!test.nodes[i].connected)
602 test.nodes[i].connected = 0;
603 rdma_disconnect(test.nodes[i].cma_id);
606 ret = disconnect_events();
608 printf("disconnected\n");
611 rdma_destroy_id(listen_id);
615 static int run_client(void)
619 printf("cmatose: starting client\n");
621 ret = get_addr(src_addr, &test.addr.src_addr);
626 ret = get_addr(dst_addr, &test.addr.dst_addr);
630 if (test.addr.dst_addr.sa_family == AF_INET)
631 ((struct sockaddr_in *) &test.addr.dst_addr)->sin_port = port;
633 ((struct sockaddr_in6 *) &test.addr.dst_addr)->sin6_port = port;
635 printf("cmatose: connecting\n");
636 for (i = 0; i < connections; i++) {
637 ret = rdma_resolve_addr(test.nodes[i].cma_id,
638 src_addr ? &test.addr.src_addr : NULL,
639 &test.addr.dst_addr, 2000);
641 perror("cmatose: failure getting addr");
647 ret = connect_events();
652 printf("receiving data transfers\n");
653 ret = poll_cqs(RECV_CQ_INDEX);
657 printf("sending replies\n");
658 for (i = 0; i < connections; i++) {
659 ret = post_sends(&test.nodes[i]);
664 printf("data transfers complete\n");
670 ret = migrate_channel(NULL);
675 ret2 = disconnect_events();
682 int main(int argc, char **argv)
686 while ((op = getopt(argc, argv, "s:b:c:C:S:t:p:m")) != -1) {
695 connections = atoi(optarg);
698 message_count = atoi(optarg);
701 message_size = atoi(optarg);
705 tos = (uint8_t) atoi(optarg);
714 printf("usage: %s\n", argv[0]);
715 printf("\t[-s server_address]\n");
716 printf("\t[-b bind_address]\n");
717 printf("\t[-c connections]\n");
718 printf("\t[-C message_count]\n");
719 printf("\t[-S message_size]\n");
720 printf("\t[-t type_of_service]\n");
721 printf("\t[-p port_number]\n");
722 printf("\t[-m(igrate)]\n");
727 test.connects_left = connections;
728 test.disconnects_left = connections;
730 test.channel = rdma_create_event_channel();
732 printf("failed to create event channel\n");
744 printf("test complete\n");
746 rdma_destroy_event_channel(test.channel);
748 printf("return status %d\n", ret);