2 *------------------------------------------------------------------
3 * Copyright (c) 2017 Cisco and/or its affiliates.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *------------------------------------------------------------------
17 #include <sys/types.h>
21 #include <main_test.h>
23 #include <memif_private.h>
25 #define SOCKET_FILENAME "/run/vpp/memif.sock"
28 #define read_call (1 << 0)
29 #define write_call (1 << 1)
30 #define error_call (1 << 2)
33 read_fn (memif_connection_t * c)
35 ready_called |= read_call;
40 write_fn (memif_connection_t * c)
42 ready_called |= write_call;
47 error_fn (memif_connection_t * c)
49 ready_called |= error_call;
54 register_fd_ready_fn (memif_connection_t * c,
55 memif_fn * read_fn, memif_fn * write_fn,
59 c->write_fn = write_fn;
60 c->error_fn = error_fn;
63 START_TEST (test_init)
68 memif_init (control_fd_update, TEST_APP_NAME, NULL,
69 NULL, NULL)) != MEMIF_ERR_SUCCESS)
70 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
72 libmemif_main_t *lm = &libmemif_main;
74 ck_assert_ptr_ne (lm, NULL);
75 ck_assert_ptr_ne (lm->control_fd_update, NULL);
76 ck_assert_int_gt (lm->timerfd, 2);
84 START_TEST (test_init_epoll)
89 memif_init (NULL, TEST_APP_NAME, NULL, NULL, NULL)) != MEMIF_ERR_SUCCESS)
90 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
92 libmemif_main_t *lm = &libmemif_main;
94 ck_assert_ptr_ne (lm, NULL);
95 ck_assert_ptr_ne (lm->control_fd_update, NULL);
96 ck_assert_int_gt (lm->timerfd, 2);
97 ck_assert_int_gt (memif_epfd, -1);
105 START_TEST (test_create)
108 memif_conn_handle_t conn = NULL;
109 memif_conn_args_t args;
110 memset (&args, 0, sizeof (args));
112 libmemif_main_t *lm = &libmemif_main;
115 memif_init (control_fd_update, TEST_APP_NAME, NULL,
116 NULL, NULL)) != MEMIF_ERR_SUCCESS)
117 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
119 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
121 if ((err = memif_create (&conn, &args, on_connect,
122 on_disconnect, on_interrupt,
123 NULL)) != MEMIF_ERR_SUCCESS)
124 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
126 memif_connection_t *c = (memif_connection_t *) conn;
128 ck_assert_ptr_ne (c, NULL);
130 ck_assert_uint_eq (c->args.interface_id, args.interface_id);
131 ck_assert_uint_eq (c->args.is_master, args.is_master);
132 ck_assert_uint_eq (c->args.mode, args.mode);
134 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
135 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
136 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
137 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
139 ck_assert_ptr_eq (c->msg_queue, NULL);
140 ck_assert_ptr_eq (c->regions, NULL);
141 ck_assert_ptr_eq (c->tx_queues, NULL);
142 ck_assert_ptr_eq (c->rx_queues, NULL);
144 ck_assert_int_eq (c->fd, -1);
146 ck_assert_ptr_ne (c->on_connect, NULL);
147 ck_assert_ptr_ne (c->on_disconnect, NULL);
148 ck_assert_ptr_ne (c->on_interrupt, NULL);
150 ck_assert_str_eq ((char *)c->args.interface_name, (char *)args.interface_name);
152 struct itimerspec timer;
153 timerfd_gettime (lm->timerfd, &timer);
155 ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
156 "timerfd not armed!");
162 memif_delete (&conn);
163 ck_assert_ptr_eq (conn, NULL);
167 START_TEST (test_create_master)
170 memif_conn_handle_t conn = NULL;
171 memif_conn_args_t args;
172 memset (&args, 0, sizeof (args));
176 memif_init (control_fd_update, TEST_APP_NAME, NULL,
177 NULL, NULL)) != MEMIF_ERR_SUCCESS)
178 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
180 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
182 if ((err = memif_create (&conn, &args, on_connect,
183 on_disconnect, on_interrupt,
184 NULL)) != MEMIF_ERR_SUCCESS)
185 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
187 memif_connection_t *c = (memif_connection_t *) conn;
189 ck_assert_ptr_ne (c, NULL);
191 ck_assert_uint_eq (c->args.interface_id, args.interface_id);
192 ck_assert_uint_eq (c->args.is_master, args.is_master);
193 ck_assert_uint_eq (c->args.mode, args.mode);
195 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
196 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
197 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
198 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
200 ck_assert_ptr_eq (c->msg_queue, NULL);
201 ck_assert_ptr_eq (c->regions, NULL);
202 ck_assert_ptr_eq (c->tx_queues, NULL);
203 ck_assert_ptr_eq (c->rx_queues, NULL);
205 ck_assert_int_eq (c->fd, -1);
207 ck_assert_ptr_ne (c->on_connect, NULL);
208 ck_assert_ptr_ne (c->on_disconnect, NULL);
209 ck_assert_ptr_ne (c->on_interrupt, NULL);
211 ck_assert_str_eq ((char *)c->args.interface_name, (char *)args.interface_name);
213 struct stat file_stat;
215 rv = stat (SOCKET_FILENAME, &file_stat);
216 ck_assert_int_eq (rv, 0);
218 ck_assert (S_ISSOCK (file_stat.st_mode));
220 memif_delete (&conn);
221 ck_assert_ptr_eq (conn, NULL);
225 START_TEST (test_create_mult)
228 memif_conn_handle_t conn = NULL;
229 memif_conn_handle_t conn1 = NULL;
230 memif_conn_args_t args;
231 memset (&args, 0, sizeof (args));
233 libmemif_main_t *lm = &libmemif_main;
236 memif_init (control_fd_update, TEST_APP_NAME, NULL,
237 NULL, NULL)) != MEMIF_ERR_SUCCESS)
238 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
240 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
242 if ((err = memif_create (&conn, &args, on_connect,
243 on_disconnect, on_interrupt,
244 NULL)) != MEMIF_ERR_SUCCESS)
245 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
247 args.interface_id = 1;
249 if ((err = memif_create (&conn1, &args, on_connect,
250 on_disconnect, on_interrupt,
251 NULL)) != MEMIF_ERR_SUCCESS)
252 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
254 memif_connection_t *c = (memif_connection_t *) conn;
255 memif_connection_t *c1 = (memif_connection_t *) conn1;
257 ck_assert_ptr_ne (c, NULL);
258 ck_assert_ptr_ne (c1, NULL);
260 ck_assert_uint_eq (c->args.interface_id, 0);
261 ck_assert_uint_eq (c->args.is_master, args.is_master);
262 ck_assert_uint_eq (c->args.mode, args.mode);
263 ck_assert_uint_eq (c1->args.interface_id, 1);
264 ck_assert_uint_eq (c1->args.is_master, args.is_master);
265 ck_assert_uint_eq (c1->args.mode, args.mode);
267 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
268 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
269 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
270 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
271 ck_assert_uint_eq (c1->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
272 ck_assert_uint_eq (c1->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
273 ck_assert_uint_eq (c1->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
274 ck_assert_uint_eq (c1->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
276 ck_assert_ptr_eq (c->msg_queue, NULL);
277 ck_assert_ptr_eq (c->regions, NULL);
278 ck_assert_ptr_eq (c->tx_queues, NULL);
279 ck_assert_ptr_eq (c->rx_queues, NULL);
280 ck_assert_ptr_eq (c1->msg_queue, NULL);
281 ck_assert_ptr_eq (c1->regions, NULL);
282 ck_assert_ptr_eq (c1->tx_queues, NULL);
283 ck_assert_ptr_eq (c1->rx_queues, NULL);
285 ck_assert_int_eq (c->fd, -1);
286 ck_assert_int_eq (c1->fd, -1);
288 ck_assert_ptr_ne (c->on_connect, NULL);
289 ck_assert_ptr_ne (c->on_disconnect, NULL);
290 ck_assert_ptr_ne (c->on_interrupt, NULL);
291 ck_assert_ptr_ne (c1->on_connect, NULL);
292 ck_assert_ptr_ne (c1->on_disconnect, NULL);
293 ck_assert_ptr_ne (c1->on_interrupt, NULL);
295 ck_assert_str_eq ((char *)c->args.interface_name, (char *)args.interface_name);
296 ck_assert_str_eq ((char *)c1->args.interface_name, (char *)args.interface_name);
298 struct itimerspec timer;
299 timerfd_gettime (lm->timerfd, &timer);
301 ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
302 "timerfd not armed!");
308 memif_delete (&conn);
309 ck_assert_ptr_eq (conn, NULL);
313 START_TEST (test_control_fd_handler)
317 memif_conn_handle_t conn = NULL;
318 memif_conn_args_t args;
319 memset (&args, 0, sizeof (args));
320 args.num_s2m_rings = 2;
321 args.num_m2s_rings = 2;
323 libmemif_main_t *lm = &libmemif_main;
326 memif_init (control_fd_update, TEST_APP_NAME, NULL,
327 NULL, NULL)) != MEMIF_ERR_SUCCESS)
328 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
330 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
332 if ((err = memif_create (&conn, &args, on_connect,
333 on_disconnect, on_interrupt,
334 NULL)) != MEMIF_ERR_SUCCESS)
335 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
337 memif_connection_t *c = (memif_connection_t *) conn;
340 memif_control_fd_handler (lm->timerfd,
341 MEMIF_FD_EVENT_READ)) != MEMIF_ERR_SUCCESS)
342 ck_assert_msg (err == MEMIF_ERR_NO_FILE, "err code: %u, err msg: %s", err,
343 memif_strerror (err));
345 register_fd_ready_fn (c, read_fn, write_fn, error_fn);
347 lm->control_list[0].key = c->fd;
348 lm->control_list[0].data_struct = c;
351 memif_control_fd_handler (c->fd,
352 MEMIF_FD_EVENT_READ)) != MEMIF_ERR_SUCCESS)
353 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
355 ck_assert (ready_called & read_call);
358 memif_control_fd_handler (c->fd,
359 MEMIF_FD_EVENT_WRITE)) != MEMIF_ERR_SUCCESS)
360 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
362 ck_assert (ready_called & write_call);
365 memif_control_fd_handler (c->fd,
366 MEMIF_FD_EVENT_ERROR)) != MEMIF_ERR_SUCCESS)
367 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
369 ck_assert (ready_called & error_call);
375 memif_delete (&conn);
376 ck_assert_ptr_eq (conn, NULL);
380 START_TEST (test_buffer_alloc)
385 memif_buffer_t *bufs;
386 uint16_t max_buf = 10;
388 memif_conn_handle_t conn = NULL;
389 memif_conn_args_t args;
390 memset (&args, 0, sizeof (args));
391 args.num_s2m_rings = 2;
392 args.num_m2s_rings = 2;
394 libmemif_main_t *lm = &libmemif_main;
397 memif_init (control_fd_update, TEST_APP_NAME, NULL,
398 NULL, NULL)) != MEMIF_ERR_SUCCESS)
399 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
401 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
403 if ((err = memif_create (&conn, &args, on_connect,
404 on_disconnect, on_interrupt,
405 NULL)) != MEMIF_ERR_SUCCESS)
406 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
408 memif_connection_t *c = (memif_connection_t *) conn;
410 c->run_args.num_s2m_rings = 2;
411 c->run_args.num_m2s_rings = 2;
412 c->run_args.log2_ring_size = 10;
413 c->run_args.buffer_size = 2048;
415 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
416 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
420 /* test buffer allocation qid 0 (positive) */
422 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
426 memif_buffer_alloc (conn, qid, bufs, max_buf,
428 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
429 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
431 ck_assert_uint_eq (buf, max_buf);
432 for (i = 0; i < max_buf; i++)
433 ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
435 /* test buffer allocation qid 1 (positive) */
437 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
441 memif_buffer_alloc (conn, qid, bufs, max_buf,
443 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
444 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
446 ck_assert_uint_eq (buf, max_buf);
447 for (i = 0; i < max_buf; i++)
448 ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
450 /* test buffer allocation qid 2 (negative) */
453 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
457 memif_buffer_alloc (conn, qid, bufs, max_buf,
459 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
460 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
461 memif_strerror (err));
470 memif_delete (&conn);
471 ck_assert_ptr_eq (conn, NULL);
475 START_TEST (test_tx_burst)
478 uint16_t max_buf = 10, buf, tx;
480 memif_buffer_t *bufs;
482 memif_conn_handle_t conn = NULL;
483 memif_conn_args_t args;
484 memset (&args, 0, sizeof (args));
485 args.num_s2m_rings = 2;
486 args.num_m2s_rings = 2;
488 libmemif_main_t *lm = &libmemif_main;
491 memif_init (control_fd_update, TEST_APP_NAME, NULL,
492 NULL, NULL)) != MEMIF_ERR_SUCCESS)
493 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
495 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
497 if ((err = memif_create (&conn, &args, on_connect,
498 on_disconnect, on_interrupt,
499 NULL)) != MEMIF_ERR_SUCCESS)
500 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
502 memif_connection_t *c = (memif_connection_t *) conn;
504 c->run_args.num_s2m_rings = 2;
505 c->run_args.num_m2s_rings = 2;
506 c->run_args.log2_ring_size = 10;
507 c->run_args.buffer_size = 2048;
509 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
510 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
514 /* test transmit qid 0 (positive) */
516 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
519 memif_buffer_alloc (conn, qid, bufs, max_buf,
521 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
522 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
524 ck_assert_uint_eq (buf, max_buf);
525 for (i = 0; i < max_buf; i++)
526 ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
529 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
530 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
532 ck_assert_uint_eq (tx, max_buf);
533 for (i = 0; i < max_buf; i++)
534 ck_assert_ptr_eq (bufs[i].data, NULL);
536 /* test transmit qid 1 (positive) */
538 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
541 memif_buffer_alloc (conn, qid, bufs, max_buf,
543 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
544 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
546 ck_assert_uint_eq (buf, max_buf);
547 for (i = 0; i < max_buf; i++)
548 ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
551 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
552 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
554 ck_assert_uint_eq (tx, max_buf);
555 for (i = 0; i < max_buf; i++)
556 ck_assert_ptr_eq (bufs[i].data, NULL);
558 /* test transmit qid 2 (negative) */
560 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
563 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
564 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
565 memif_strerror (err));
573 memif_delete (&conn);
574 ck_assert_ptr_eq (conn, NULL);
578 START_TEST (test_rx_burst)
581 uint16_t max_buf = 10, rx;
583 memif_buffer_t *bufs;
587 memif_conn_handle_t conn = NULL;
588 memif_conn_args_t args;
589 memset (&args, 0, sizeof (args));
590 args.num_s2m_rings = 2;
591 args.num_m2s_rings = 2;
593 libmemif_main_t *lm = &libmemif_main;
596 memif_init (control_fd_update, TEST_APP_NAME, NULL,
597 NULL, NULL)) != MEMIF_ERR_SUCCESS)
598 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
600 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
602 if ((err = memif_create (&conn, &args, on_connect,
603 on_disconnect, on_interrupt,
604 NULL)) != MEMIF_ERR_SUCCESS)
605 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
607 memif_connection_t *c = (memif_connection_t *) conn;
609 c->run_args.num_s2m_rings = 2;
610 c->run_args.num_m2s_rings = 2;
611 c->run_args.log2_ring_size = 10;
612 c->run_args.buffer_size = 2048;
614 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
615 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
619 /* test receive qid 0 (positive) */
621 mq = &c->rx_queues[qid];
623 ring->tail += max_buf;
625 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
628 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
629 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
631 ck_assert_uint_eq (rx, max_buf);
632 for (i = 0; i < max_buf; i++)
633 ck_assert_ptr_ne (bufs[i].data, NULL);
635 /* test receive qid 1 (positive) */
637 mq = &c->rx_queues[qid];
639 ring->tail += max_buf;
642 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
645 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
646 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
648 ck_assert_uint_eq (rx, max_buf);
649 for (i = 0; i < max_buf; i++)
650 ck_assert_ptr_ne (bufs[i].data, NULL);
652 /* test receive qid 2 (negative) */
654 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
657 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
658 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
659 memif_strerror (err));
667 memif_delete (&conn);
668 ck_assert_ptr_eq (conn, NULL);
672 START_TEST (test_get_details)
676 memif_conn_handle_t conn = NULL;
677 memif_conn_args_t args;
678 memset (&args, 0, sizeof (args));
679 args.num_s2m_rings = 2;
680 args.num_m2s_rings = 2;
682 libmemif_main_t *lm = &libmemif_main;
685 memif_init (control_fd_update, TEST_APP_NAME, NULL,
686 NULL, NULL)) != MEMIF_ERR_SUCCESS)
687 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
689 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
691 if ((err = memif_create (&conn, &args, on_connect,
692 on_disconnect, on_interrupt,
693 NULL)) != MEMIF_ERR_SUCCESS)
694 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
696 memif_connection_t *c = (memif_connection_t *) conn;
698 c->run_args.num_s2m_rings = 2;
699 c->run_args.num_m2s_rings = 2;
700 c->run_args.log2_ring_size = 10;
701 c->run_args.buffer_size = 2048;
703 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
704 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
707 memset (&md, 0, sizeof (md));
708 ssize_t buflen = 2048;
709 char *buf = malloc (buflen);
710 memset (buf, 0, buflen);
712 if ((err = memif_get_details (conn, &md, buf, buflen)) != MEMIF_ERR_SUCCESS)
713 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
715 ck_assert_str_eq ((char *)md.if_name, (char *)c->args.interface_name);
716 ck_assert_str_eq ((char *)md.remote_if_name, (char *)c->remote_if_name);
717 ck_assert_str_eq ((char *)md.remote_inst_name, (char *)c->remote_name);
718 ck_assert_str_eq ((char *)md.secret, (char *)c->args.secret);
720 ck_assert_uint_eq (md.id, c->args.interface_id);
721 ck_assert_uint_ne (md.role, c->args.is_master);
722 ck_assert_uint_eq (md.mode, c->args.mode);
723 for (i = 0; i < md.rx_queues_num; i++)
725 ck_assert_uint_eq (md.rx_queues[i].qid, i);
726 ck_assert_uint_eq (md.rx_queues[i].ring_size,
727 (1 << c->args.log2_ring_size));
728 ck_assert_uint_eq (md.rx_queues[i].buffer_size, c->args.buffer_size);
730 for (i = 0; i < md.tx_queues_num; i++)
732 ck_assert_uint_eq (md.tx_queues[i].qid, i);
733 ck_assert_uint_eq (md.tx_queues[i].ring_size,
734 (1 << c->args.log2_ring_size));
735 ck_assert_uint_eq (md.tx_queues[i].buffer_size, c->args.buffer_size);
737 ck_assert_uint_eq (md.link_up_down, 0);
743 memif_delete (&conn);
744 ck_assert_ptr_eq (conn, NULL);
748 START_TEST (test_init_regions_and_queues)
752 memif_conn_handle_t conn = NULL;
753 memif_conn_args_t args;
754 memset (&args, 0, sizeof (args));
755 args.num_s2m_rings = 2;
756 args.num_m2s_rings = 2;
758 libmemif_main_t *lm = &libmemif_main;
761 memif_init (control_fd_update, TEST_APP_NAME, NULL,
762 NULL, NULL)) != MEMIF_ERR_SUCCESS)
763 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
765 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
767 if ((err = memif_create (&conn, &args, on_connect,
768 on_disconnect, on_interrupt,
769 NULL)) != MEMIF_ERR_SUCCESS)
770 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
772 memif_connection_t *c = (memif_connection_t *) conn;
774 c->run_args.num_s2m_rings = 2;
775 c->run_args.num_m2s_rings = 2;
776 c->run_args.log2_ring_size = 10;
777 c->run_args.buffer_size = 2048;
779 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
780 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
782 ck_assert_ptr_ne (c->regions, NULL);
783 ck_assert_ptr_ne (c->tx_queues, NULL);
784 ck_assert_ptr_ne (c->rx_queues, NULL);
786 ck_assert_ptr_ne (c->regions->addr, NULL);
787 ck_assert_ptr_ne (c->tx_queues->ring, NULL);
788 ck_assert_ptr_ne (c->rx_queues->ring, NULL);
790 ck_assert_int_ne (c->regions->fd, -1);
791 ck_assert_uint_eq (c->tx_queues->ring->cookie, MEMIF_COOKIE);
792 ck_assert_uint_eq (c->rx_queues->ring->cookie, MEMIF_COOKIE);
798 memif_delete (&conn);
799 ck_assert_ptr_eq (conn, NULL);
803 START_TEST (test_connect1)
807 memif_conn_handle_t conn = NULL;
808 memif_conn_args_t args;
809 memset (&args, 0, sizeof (args));
810 args.num_s2m_rings = 2;
811 args.num_m2s_rings = 2;
813 libmemif_main_t *lm = &libmemif_main;
816 memif_init (control_fd_update, TEST_APP_NAME, NULL,
817 NULL, NULL)) != MEMIF_ERR_SUCCESS)
818 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
820 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
822 if ((err = memif_create (&conn, &args, on_connect,
823 on_disconnect, on_interrupt,
824 NULL)) != MEMIF_ERR_SUCCESS)
825 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
827 memif_connection_t *c = (memif_connection_t *) conn;
829 c->run_args.num_s2m_rings = 2;
830 c->run_args.num_m2s_rings = 2;
831 c->run_args.log2_ring_size = 10;
832 c->run_args.buffer_size = 2048;
834 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
835 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
837 if ((err = memif_connect1 (c)) != MEMIF_ERR_SUCCESS)
838 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
844 memif_delete (&conn);
845 ck_assert_ptr_eq (conn, NULL);
849 START_TEST (test_disconnect_internal)
853 memif_conn_handle_t conn = NULL;
854 memif_conn_args_t args;
855 memset (&args, 0, sizeof (args));
856 args.num_s2m_rings = 2;
857 args.num_m2s_rings = 2;
859 libmemif_main_t *lm = &libmemif_main;
862 memif_init (control_fd_update, TEST_APP_NAME, NULL,
863 NULL, NULL)) != MEMIF_ERR_SUCCESS)
864 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
866 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
868 if ((err = memif_create (&conn, &args, on_connect,
869 on_disconnect, on_interrupt,
870 NULL)) != MEMIF_ERR_SUCCESS)
871 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
873 memif_connection_t *c = (memif_connection_t *) conn;
875 c->run_args.num_s2m_rings = 2;
876 c->run_args.num_m2s_rings = 2;
877 c->run_args.log2_ring_size = 10;
878 c->run_args.buffer_size = 2048;
880 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
881 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
883 if ((err = memif_disconnect_internal (c)) != MEMIF_ERR_SUCCESS)
884 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
886 ck_assert_int_eq (c->fd, -1);
888 ck_assert_ptr_eq (c->tx_queues, NULL);
889 ck_assert_ptr_eq (c->rx_queues, NULL);
890 ck_assert_ptr_eq (c->regions, NULL);
891 ck_assert_ptr_eq (c->msg_queue, NULL);
893 struct itimerspec timer;
894 timerfd_gettime (lm->timerfd, &timer);
896 ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
897 "timerfd not armed!");
903 memif_delete (&conn);
904 ck_assert_ptr_eq (conn, NULL);
915 /* create main test suite */
916 s = suite_create ("Libmemif main");
918 /* create api test case */
919 tc_api = tcase_create ("Api calls");
920 /* add tests to test case */
921 tcase_add_test (tc_api, test_init);
922 tcase_add_test (tc_api, test_init_epoll);
923 tcase_add_test (tc_api, test_create);
924 tcase_add_test (tc_api, test_create_master);
925 tcase_add_test (tc_api, test_create_mult);
926 tcase_add_test (tc_api, test_control_fd_handler);
927 tcase_add_test (tc_api, test_buffer_alloc);
928 tcase_add_test (tc_api, test_tx_burst);
929 tcase_add_test (tc_api, test_rx_burst);
930 tcase_add_test (tc_api, test_get_details);
932 /* create internal test case */
933 tc_internal = tcase_create ("Internal");
934 /* add tests to test case */
935 tcase_add_test (tc_internal, test_init_regions_and_queues);
936 tcase_add_test (tc_internal, test_connect1);
937 tcase_add_test (tc_internal, test_disconnect_internal);
939 /* add test cases to test suite */
940 suite_add_tcase (s, tc_api);
941 suite_add_tcase (s, tc_internal);
943 /* return main test suite to test runner */