extras/libmemif/test/main_test.c

   1 /*
   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:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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  *------------------------------------------------------------------
  16  */
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <unistd.h>
  20
  21 #include <main_test.h>
  22
  23 #include <memif_private.h>
  24
  25 #define SOCKET_FILENAME "/run/vpp/memif.sock"
  26
  27 uint8_t ready_called;
  28 #define read_call  (1 << 0)
  29 #define write_call (1 << 1)
  30 #define error_call (1 << 2)
  31
  32 int
  33 read_fn (memif_connection_t * c)
  34 {
  35   ready_called |= read_call;
  36   return 0;
  37 }
  38
  39 int
  40 write_fn (memif_connection_t * c)
  41 {
  42   ready_called |= write_call;
  43   return 0;
  44 }
  45
  46 int
  47 error_fn (memif_connection_t * c)
  48 {
  49   ready_called |= error_call;
  50   return 0;
  51 }
  52
  53 static void
  54 register_fd_ready_fn (memif_connection_t * c,
  55                       memif_fn * read_fn, memif_fn * write_fn,
  56                       memif_fn * error_fn)
  57 {
  58   c->read_fn = read_fn;
  59   c->write_fn = write_fn;
  60   c->error_fn = error_fn;
  61 }
  62
  63 START_TEST (test_init)
  64 {
  65   int err;
  66
  67   if ((err =
  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));
  71
  72   libmemif_main_t *lm = &libmemif_main;
  73
  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);
  77
  78   if (lm->timerfd > 0)
  79     close (lm->timerfd);
  80   lm->timerfd = -1;
  81 }
  82
  83 END_TEST
  84 START_TEST (test_init_epoll)
  85 {
  86   int err;
  87
  88   if ((err =
  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));
  91
  92   libmemif_main_t *lm = &libmemif_main;
  93
  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);
  98
  99   if (lm->timerfd > 0)
 100     close (lm->timerfd);
 101   lm->timerfd = -1;
 102 }
 103
 104 END_TEST
 105 START_TEST (test_create)
 106 {
 107   int err;
 108   memif_conn_handle_t conn = NULL;
 109   memif_conn_args_t args;
 110   memset (&args, 0, sizeof (args));
 111
 112   libmemif_main_t *lm = &libmemif_main;
 113
 114   if ((err =
 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));
 118
 119   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 120
 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));
 125
 126   memif_connection_t *c = (memif_connection_t *) conn;
 127
 128   ck_assert_ptr_ne (c, NULL);
 129
 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);
 133
 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);
 138
 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);
 143
 144   ck_assert_int_eq (c->fd, -1);
 145
 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);
 149
 150   ck_assert_str_eq ((char *)c->args.interface_name, (char *)args.interface_name);
 151   ck_assert_str_eq ((char *)c->args.socket_filename, SOCKET_FILENAME);
 152
 153   struct itimerspec timer;
 154   timerfd_gettime (lm->timerfd, &timer);
 155
 156   ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
 157                  "timerfd not armed!");
 158
 159   if (lm->timerfd > 0)
 160     close (lm->timerfd);
 161   lm->timerfd = -1;
 162
 163   memif_delete (&conn);
 164   ck_assert_ptr_eq (conn, NULL);
 165 }
 166
 167 END_TEST
 168 START_TEST (test_create_master)
 169 {
 170   int err, rv;
 171   memif_conn_handle_t conn = NULL;
 172   memif_conn_args_t args;
 173   memset (&args, 0, sizeof (args));
 174   args.is_master = 1;
 175
 176   if ((err =
 177        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 178                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 179     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 180
 181   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 182
 183   if ((err = memif_create (&conn, &args, on_connect,
 184                            on_disconnect, on_interrupt,
 185                            NULL)) != MEMIF_ERR_SUCCESS)
 186     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 187
 188   memif_connection_t *c = (memif_connection_t *) conn;
 189
 190   ck_assert_ptr_ne (c, NULL);
 191
 192   ck_assert_uint_eq (c->args.interface_id, args.interface_id);
 193   ck_assert_uint_eq (c->args.is_master, args.is_master);
 194   ck_assert_uint_eq (c->args.mode, args.mode);
 195
 196   ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
 197   ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
 198   ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
 199   ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
 200
 201   ck_assert_ptr_eq (c->msg_queue, NULL);
 202   ck_assert_ptr_eq (c->regions, NULL);
 203   ck_assert_ptr_eq (c->tx_queues, NULL);
 204   ck_assert_ptr_eq (c->rx_queues, NULL);
 205
 206   ck_assert_int_eq (c->fd, -1);
 207
 208   ck_assert_ptr_ne (c->on_connect, NULL);
 209   ck_assert_ptr_ne (c->on_disconnect, NULL);
 210   ck_assert_ptr_ne (c->on_interrupt, NULL);
 211
 212   ck_assert_str_eq ((char *)c->args.interface_name, (char *)args.interface_name);
 213   ck_assert_str_eq ((char *)c->args.socket_filename, SOCKET_FILENAME);
 214
 215   struct stat file_stat;
 216
 217   rv = stat (SOCKET_FILENAME, &file_stat);
 218   ck_assert_int_eq (rv, 0);
 219
 220   ck_assert (S_ISSOCK (file_stat.st_mode));
 221
 222   memif_delete (&conn);
 223   ck_assert_ptr_eq (conn, NULL);
 224 }
 225
 226 END_TEST
 227 START_TEST (test_create_mult)
 228 {
 229   int err;
 230   memif_conn_handle_t conn = NULL;
 231   memif_conn_handle_t conn1 = NULL;
 232   memif_conn_args_t args;
 233   memset (&args, 0, sizeof (args));
 234
 235   libmemif_main_t *lm = &libmemif_main;
 236
 237   if ((err =
 238        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 239                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 240     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 241
 242   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 243
 244   if ((err = memif_create (&conn, &args, on_connect,
 245                            on_disconnect, on_interrupt,
 246                            NULL)) != MEMIF_ERR_SUCCESS)
 247     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 248
 249   args.interface_id = 1;
 250
 251   if ((err = memif_create (&conn1, &args, on_connect,
 252                            on_disconnect, on_interrupt,
 253                            NULL)) != MEMIF_ERR_SUCCESS)
 254     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 255
 256   memif_connection_t *c = (memif_connection_t *) conn;
 257   memif_connection_t *c1 = (memif_connection_t *) conn1;
 258
 259   ck_assert_ptr_ne (c, NULL);
 260   ck_assert_ptr_ne (c1, NULL);
 261
 262   ck_assert_uint_eq (c->args.interface_id, 0);
 263   ck_assert_uint_eq (c->args.is_master, args.is_master);
 264   ck_assert_uint_eq (c->args.mode, args.mode);
 265   ck_assert_uint_eq (c1->args.interface_id, 1);
 266   ck_assert_uint_eq (c1->args.is_master, args.is_master);
 267   ck_assert_uint_eq (c1->args.mode, args.mode);
 268
 269   ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
 270   ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
 271   ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
 272   ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
 273   ck_assert_uint_eq (c1->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
 274   ck_assert_uint_eq (c1->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
 275   ck_assert_uint_eq (c1->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
 276   ck_assert_uint_eq (c1->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
 277
 278   ck_assert_ptr_eq (c->msg_queue, NULL);
 279   ck_assert_ptr_eq (c->regions, NULL);
 280   ck_assert_ptr_eq (c->tx_queues, NULL);
 281   ck_assert_ptr_eq (c->rx_queues, NULL);
 282   ck_assert_ptr_eq (c1->msg_queue, NULL);
 283   ck_assert_ptr_eq (c1->regions, NULL);
 284   ck_assert_ptr_eq (c1->tx_queues, NULL);
 285   ck_assert_ptr_eq (c1->rx_queues, NULL);
 286
 287   ck_assert_int_eq (c->fd, -1);
 288   ck_assert_int_eq (c1->fd, -1);
 289
 290   ck_assert_ptr_ne (c->on_connect, NULL);
 291   ck_assert_ptr_ne (c->on_disconnect, NULL);
 292   ck_assert_ptr_ne (c->on_interrupt, NULL);
 293   ck_assert_ptr_ne (c1->on_connect, NULL);
 294   ck_assert_ptr_ne (c1->on_disconnect, NULL);
 295   ck_assert_ptr_ne (c1->on_interrupt, NULL);
 296
 297   ck_assert_str_eq ((char *)c->args.interface_name, (char *)args.interface_name);
 298   ck_assert_str_eq ((char *)c->args.socket_filename, SOCKET_FILENAME);
 299   ck_assert_str_eq ((char *)c1->args.interface_name, (char *)args.interface_name);
 300   ck_assert_str_eq ((char *)c1->args.socket_filename, SOCKET_FILENAME);
 301
 302   struct itimerspec timer;
 303   timerfd_gettime (lm->timerfd, &timer);
 304
 305   ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
 306                  "timerfd not armed!");
 307
 308   if (lm->timerfd > 0)
 309     close (lm->timerfd);
 310   lm->timerfd = -1;
 311
 312   memif_delete (&conn);
 313   ck_assert_ptr_eq (conn, NULL);
 314 }
 315
 316 END_TEST
 317 START_TEST (test_control_fd_handler)
 318 {
 319   int err;
 320   ready_called = 0;
 321   memif_conn_handle_t conn = NULL;
 322   memif_conn_args_t args;
 323   memset (&args, 0, sizeof (args));
 324   args.num_s2m_rings = 2;
 325   args.num_m2s_rings = 2;
 326
 327   libmemif_main_t *lm = &libmemif_main;
 328
 329   if ((err =
 330        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 331                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 332     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 333
 334   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 335
 336   if ((err = memif_create (&conn, &args, on_connect,
 337                            on_disconnect, on_interrupt,
 338                            NULL)) != MEMIF_ERR_SUCCESS)
 339     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 340
 341   memif_connection_t *c = (memif_connection_t *) conn;
 342
 343   if ((err =
 344        memif_control_fd_handler (lm->timerfd,
 345                                  MEMIF_FD_EVENT_READ)) != MEMIF_ERR_SUCCESS)
 346     ck_assert_msg (err == MEMIF_ERR_NO_FILE, "err code: %u, err msg: %s", err,
 347                    memif_strerror (err));
 348
 349   register_fd_ready_fn (c, read_fn, write_fn, error_fn);
 350   c->fd = 69;
 351   lm->control_list[0].key = c->fd;
 352   lm->control_list[0].data_struct = c;
 353
 354   if ((err =
 355        memif_control_fd_handler (c->fd,
 356                                  MEMIF_FD_EVENT_READ)) != MEMIF_ERR_SUCCESS)
 357     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 358
 359   ck_assert (ready_called & read_call);
 360
 361   if ((err =
 362        memif_control_fd_handler (c->fd,
 363                                  MEMIF_FD_EVENT_WRITE)) != MEMIF_ERR_SUCCESS)
 364     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 365
 366   ck_assert (ready_called & write_call);
 367
 368   if ((err =
 369        memif_control_fd_handler (c->fd,
 370                                  MEMIF_FD_EVENT_ERROR)) != MEMIF_ERR_SUCCESS)
 371     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 372
 373   ck_assert (ready_called & error_call);
 374
 375   if (lm->timerfd > 0)
 376     close (lm->timerfd);
 377   lm->timerfd = -1;
 378
 379   memif_delete (&conn);
 380   ck_assert_ptr_eq (conn, NULL);
 381 }
 382
 383 END_TEST
 384 START_TEST (test_buffer_alloc)
 385 {
 386   int err, i;
 387   uint8_t qid;
 388   uint16_t buf;
 389   memif_buffer_t *bufs;
 390   uint16_t max_buf = 10;
 391   ready_called = 0;
 392   memif_conn_handle_t conn = NULL;
 393   memif_conn_args_t args;
 394   memset (&args, 0, sizeof (args));
 395   args.num_s2m_rings = 2;
 396   args.num_m2s_rings = 2;
 397
 398   libmemif_main_t *lm = &libmemif_main;
 399
 400   if ((err =
 401        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 402                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 403     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 404
 405   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 406
 407   if ((err = memif_create (&conn, &args, on_connect,
 408                            on_disconnect, on_interrupt,
 409                            NULL)) != MEMIF_ERR_SUCCESS)
 410     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 411
 412   memif_connection_t *c = (memif_connection_t *) conn;
 413
 414   c->run_args.num_s2m_rings = 2;
 415   c->run_args.num_m2s_rings = 2;
 416   c->run_args.log2_ring_size = 10;
 417   c->run_args.buffer_size = 2048;
 418
 419   if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
 420     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 421
 422   c->fd = 69;
 423
 424   /* test buffer allocation qid 0 (positive) */
 425
 426   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 427
 428   qid = 0;
 429   if ((err =
 430        memif_buffer_alloc (conn, qid, bufs, max_buf,
 431                            &buf,
 432                            MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
 433     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 434
 435   ck_assert_uint_eq (buf, max_buf);
 436   for (i = 0; i < max_buf; i++)
 437     ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
 438
 439   /* test buffer allocation qid 1 (positive) */
 440   free (bufs);
 441   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 442
 443   qid = 1;
 444   if ((err =
 445        memif_buffer_alloc (conn, qid, bufs, max_buf,
 446                            &buf,
 447                            MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
 448     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 449
 450   ck_assert_uint_eq (buf, max_buf);
 451   for (i = 0; i < max_buf; i++)
 452     ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
 453
 454   /* test buffer allocation qid 2 (negative) */
 455
 456   free (bufs);
 457   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 458
 459   qid = 2;
 460   if ((err =
 461        memif_buffer_alloc (conn, qid, bufs, max_buf,
 462                            &buf,
 463                            MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
 464     ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
 465                    memif_strerror (err));
 466
 467   if (lm->timerfd > 0)
 468     close (lm->timerfd);
 469   lm->timerfd = -1;
 470
 471   free (bufs);
 472   bufs = NULL;
 473
 474   memif_delete (&conn);
 475   ck_assert_ptr_eq (conn, NULL);
 476 }
 477
 478 END_TEST
 479 START_TEST (test_tx_burst)
 480 {
 481   int err, i;
 482   uint16_t max_buf = 10, buf, tx;
 483   uint8_t qid;
 484   memif_buffer_t *bufs;
 485   ready_called = 0;
 486   memif_conn_handle_t conn = NULL;
 487   memif_conn_args_t args;
 488   memset (&args, 0, sizeof (args));
 489   args.num_s2m_rings = 2;
 490   args.num_m2s_rings = 2;
 491
 492   libmemif_main_t *lm = &libmemif_main;
 493
 494   if ((err =
 495        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 496                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 497     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 498
 499   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 500
 501   if ((err = memif_create (&conn, &args, on_connect,
 502                            on_disconnect, on_interrupt,
 503                            NULL)) != MEMIF_ERR_SUCCESS)
 504     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 505
 506   memif_connection_t *c = (memif_connection_t *) conn;
 507
 508   c->run_args.num_s2m_rings = 2;
 509   c->run_args.num_m2s_rings = 2;
 510   c->run_args.log2_ring_size = 10;
 511   c->run_args.buffer_size = 2048;
 512
 513   if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
 514     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 515
 516   c->fd = 69;
 517
 518   /* test transmit qid 0 (positive) */
 519
 520   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 521   qid = 0;
 522   if ((err =
 523        memif_buffer_alloc (conn, qid, bufs, max_buf,
 524                            &buf,
 525                            MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
 526     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 527
 528   ck_assert_uint_eq (buf, max_buf);
 529   for (i = 0; i < max_buf; i++)
 530     ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
 531
 532   if ((err =
 533        memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
 534     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 535
 536   ck_assert_uint_eq (tx, max_buf);
 537   for (i = 0; i < max_buf; i++)
 538     ck_assert_ptr_eq (bufs[i].data, NULL);
 539
 540   /* test transmit qid 1 (positive) */
 541   free (bufs);
 542   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 543   qid = 1;
 544   if ((err =
 545        memif_buffer_alloc (conn, qid, bufs, max_buf,
 546                            &buf,
 547                            MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
 548     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 549
 550   ck_assert_uint_eq (buf, max_buf);
 551   for (i = 0; i < max_buf; i++)
 552     ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
 553
 554   if ((err =
 555        memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
 556     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 557
 558   ck_assert_uint_eq (tx, max_buf);
 559   for (i = 0; i < max_buf; i++)
 560     ck_assert_ptr_eq (bufs[i].data, NULL);
 561
 562   /* test transmit qid 2 (negative) */
 563   free (bufs);
 564   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 565   qid = 2;
 566   if ((err =
 567        memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
 568     ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
 569                    memif_strerror (err));
 570
 571   if (lm->timerfd > 0)
 572     close (lm->timerfd);
 573   lm->timerfd = -1;
 574   free (bufs);
 575   bufs = NULL;
 576
 577   memif_delete (&conn);
 578   ck_assert_ptr_eq (conn, NULL);
 579 }
 580
 581 END_TEST
 582 START_TEST (test_rx_burst)
 583 {
 584   int err, i;
 585   uint16_t max_buf = 10, rx;
 586   uint8_t qid;
 587   memif_buffer_t *bufs;
 588   memif_queue_t *mq;
 589   memif_ring_t *ring;
 590   ready_called = 0;
 591   memif_conn_handle_t conn = NULL;
 592   memif_conn_args_t args;
 593   memset (&args, 0, sizeof (args));
 594   args.num_s2m_rings = 2;
 595   args.num_m2s_rings = 2;
 596
 597   libmemif_main_t *lm = &libmemif_main;
 598
 599   if ((err =
 600        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 601                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 602     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 603
 604   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 605
 606   if ((err = memif_create (&conn, &args, on_connect,
 607                            on_disconnect, on_interrupt,
 608                            NULL)) != MEMIF_ERR_SUCCESS)
 609     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 610
 611   memif_connection_t *c = (memif_connection_t *) conn;
 612
 613   c->run_args.num_s2m_rings = 2;
 614   c->run_args.num_m2s_rings = 2;
 615   c->run_args.log2_ring_size = 10;
 616   c->run_args.buffer_size = 2048;
 617
 618   if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
 619     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 620
 621   c->fd = 69;
 622
 623   /* test receive qid 0 (positive) */
 624   qid = 0;
 625   mq = &c->rx_queues[qid];
 626   ring = mq->ring;
 627   ring->tail += max_buf;
 628
 629   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 630
 631   if ((err =
 632        memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
 633     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 634
 635   ck_assert_uint_eq (rx, max_buf);
 636   for (i = 0; i < max_buf; i++)
 637     ck_assert_ptr_ne (bufs[i].data, NULL);
 638
 639   /* test receive qid 1 (positive) */
 640   qid = 1;
 641   mq = &c->rx_queues[qid];
 642   ring = mq->ring;
 643   ring->tail += max_buf;
 644
 645   free (bufs);
 646   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 647
 648   if ((err =
 649        memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
 650     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 651
 652   ck_assert_uint_eq (rx, max_buf);
 653   for (i = 0; i < max_buf; i++)
 654     ck_assert_ptr_ne (bufs[i].data, NULL);
 655
 656   /* test receive qid 2 (negative) */
 657   free (bufs);
 658   bufs = malloc (sizeof (memif_buffer_t) * max_buf);
 659
 660   if ((err =
 661        memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
 662     ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
 663                    memif_strerror (err));
 664
 665   if (lm->timerfd > 0)
 666     close (lm->timerfd);
 667   lm->timerfd = -1;
 668   free (bufs);
 669   bufs = NULL;
 670
 671   memif_delete (&conn);
 672   ck_assert_ptr_eq (conn, NULL);
 673 }
 674
 675 END_TEST
 676 START_TEST (test_get_details)
 677 {
 678   int err, i;
 679   ready_called = 0;
 680   memif_conn_handle_t conn = NULL;
 681   memif_conn_args_t args;
 682   memset (&args, 0, sizeof (args));
 683   args.num_s2m_rings = 2;
 684   args.num_m2s_rings = 2;
 685
 686   libmemif_main_t *lm = &libmemif_main;
 687
 688   if ((err =
 689        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 690                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 691     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 692
 693   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 694
 695   if ((err = memif_create (&conn, &args, on_connect,
 696                            on_disconnect, on_interrupt,
 697                            NULL)) != MEMIF_ERR_SUCCESS)
 698     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 699
 700   memif_connection_t *c = (memif_connection_t *) conn;
 701
 702   c->run_args.num_s2m_rings = 2;
 703   c->run_args.num_m2s_rings = 2;
 704   c->run_args.log2_ring_size = 10;
 705   c->run_args.buffer_size = 2048;
 706
 707   if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
 708     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 709
 710   memif_details_t md;
 711   memset (&md, 0, sizeof (md));
 712   ssize_t buflen = 2048;
 713   char *buf = malloc (buflen);
 714   memset (buf, 0, buflen);
 715
 716   if ((err = memif_get_details (conn, &md, buf, buflen)) != MEMIF_ERR_SUCCESS)
 717     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 718
 719   ck_assert_str_eq ((char *)md.if_name, (char *)c->args.interface_name);
 720   ck_assert_str_eq ((char *)md.remote_if_name, (char *)c->remote_if_name);
 721   ck_assert_str_eq ((char *)md.remote_inst_name, (char *)c->remote_name);
 722   ck_assert_str_eq ((char *)md.secret, (char *)c->args.secret);
 723   ck_assert_str_eq ((char *)md.socket_filename, (char *)c->args.socket_filename);
 724
 725   ck_assert_uint_eq (md.id, c->args.interface_id);
 726   ck_assert_uint_ne (md.role, c->args.is_master);
 727   ck_assert_uint_eq (md.mode, c->args.mode);
 728   for (i = 0; i < md.rx_queues_num; i++)
 729     {
 730       ck_assert_uint_eq (md.rx_queues[i].qid, i);
 731       ck_assert_uint_eq (md.rx_queues[i].ring_size,
 732                          (1 << c->args.log2_ring_size));
 733       ck_assert_uint_eq (md.rx_queues[i].buffer_size, c->args.buffer_size);
 734     }
 735   for (i = 0; i < md.tx_queues_num; i++)
 736     {
 737       ck_assert_uint_eq (md.tx_queues[i].qid, i);
 738       ck_assert_uint_eq (md.tx_queues[i].ring_size,
 739                          (1 << c->args.log2_ring_size));
 740       ck_assert_uint_eq (md.tx_queues[i].buffer_size, c->args.buffer_size);
 741     }
 742   ck_assert_uint_eq (md.link_up_down, 0);
 743
 744   if (lm->timerfd > 0)
 745     close (lm->timerfd);
 746   lm->timerfd = -1;
 747
 748   memif_delete (&conn);
 749   ck_assert_ptr_eq (conn, NULL);
 750 }
 751
 752 END_TEST
 753 START_TEST (test_init_regions_and_queues)
 754 {
 755   int err;
 756   ready_called = 0;
 757   memif_conn_handle_t conn = NULL;
 758   memif_conn_args_t args;
 759   memset (&args, 0, sizeof (args));
 760   args.num_s2m_rings = 2;
 761   args.num_m2s_rings = 2;
 762
 763   libmemif_main_t *lm = &libmemif_main;
 764
 765   if ((err =
 766        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 767                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 768     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 769
 770   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 771
 772   if ((err = memif_create (&conn, &args, on_connect,
 773                            on_disconnect, on_interrupt,
 774                            NULL)) != MEMIF_ERR_SUCCESS)
 775     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 776
 777   memif_connection_t *c = (memif_connection_t *) conn;
 778
 779   c->run_args.num_s2m_rings = 2;
 780   c->run_args.num_m2s_rings = 2;
 781   c->run_args.log2_ring_size = 10;
 782   c->run_args.buffer_size = 2048;
 783
 784   if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
 785     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 786
 787   ck_assert_ptr_ne (c->regions, NULL);
 788   ck_assert_ptr_ne (c->tx_queues, NULL);
 789   ck_assert_ptr_ne (c->rx_queues, NULL);
 790
 791   ck_assert_ptr_ne (c->regions->addr, NULL);
 792   ck_assert_ptr_ne (c->tx_queues->ring, NULL);
 793   ck_assert_ptr_ne (c->rx_queues->ring, NULL);
 794
 795   ck_assert_int_ne (c->regions->fd, -1);
 796   ck_assert_uint_eq (c->tx_queues->ring->cookie, MEMIF_COOKIE);
 797   ck_assert_uint_eq (c->rx_queues->ring->cookie, MEMIF_COOKIE);
 798
 799   if (lm->timerfd > 0)
 800     close (lm->timerfd);
 801   lm->timerfd = -1;
 802
 803   memif_delete (&conn);
 804   ck_assert_ptr_eq (conn, NULL);
 805 }
 806
 807 END_TEST
 808 START_TEST (test_connect1)
 809 {
 810   int err;
 811   ready_called = 0;
 812   memif_conn_handle_t conn = NULL;
 813   memif_conn_args_t args;
 814   memset (&args, 0, sizeof (args));
 815   args.num_s2m_rings = 2;
 816   args.num_m2s_rings = 2;
 817
 818   libmemif_main_t *lm = &libmemif_main;
 819
 820   if ((err =
 821        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 822                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 823     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 824
 825   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 826
 827   if ((err = memif_create (&conn, &args, on_connect,
 828                            on_disconnect, on_interrupt,
 829                            NULL)) != MEMIF_ERR_SUCCESS)
 830     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 831
 832   memif_connection_t *c = (memif_connection_t *) conn;
 833
 834   c->run_args.num_s2m_rings = 2;
 835   c->run_args.num_m2s_rings = 2;
 836   c->run_args.log2_ring_size = 10;
 837   c->run_args.buffer_size = 2048;
 838
 839   if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
 840     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 841
 842   if ((err = memif_connect1 (c)) != MEMIF_ERR_SUCCESS)
 843     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 844
 845   if (lm->timerfd > 0)
 846     close (lm->timerfd);
 847   lm->timerfd = -1;
 848
 849   memif_delete (&conn);
 850   ck_assert_ptr_eq (conn, NULL);
 851 }
 852
 853 END_TEST
 854 START_TEST (test_disconnect_internal)
 855 {
 856   int err;
 857   ready_called = 0;
 858   memif_conn_handle_t conn = NULL;
 859   memif_conn_args_t args;
 860   memset (&args, 0, sizeof (args));
 861   args.num_s2m_rings = 2;
 862   args.num_m2s_rings = 2;
 863
 864   libmemif_main_t *lm = &libmemif_main;
 865
 866   if ((err =
 867        memif_init (control_fd_update, TEST_APP_NAME, NULL,
 868                    NULL, NULL)) != MEMIF_ERR_SUCCESS)
 869     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 870
 871   strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
 872
 873   if ((err = memif_create (&conn, &args, on_connect,
 874                            on_disconnect, on_interrupt,
 875                            NULL)) != MEMIF_ERR_SUCCESS)
 876     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 877
 878   memif_connection_t *c = (memif_connection_t *) conn;
 879
 880   c->run_args.num_s2m_rings = 2;
 881   c->run_args.num_m2s_rings = 2;
 882   c->run_args.log2_ring_size = 10;
 883   c->run_args.buffer_size = 2048;
 884
 885   if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
 886     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 887
 888   if ((err = memif_disconnect_internal (c)) != MEMIF_ERR_SUCCESS)
 889     ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
 890
 891   ck_assert_int_eq (c->fd, -1);
 892
 893   ck_assert_ptr_eq (c->tx_queues, NULL);
 894   ck_assert_ptr_eq (c->rx_queues, NULL);
 895   ck_assert_ptr_eq (c->regions, NULL);
 896   ck_assert_ptr_eq (c->msg_queue, NULL);
 897
 898   struct itimerspec timer;
 899   timerfd_gettime (lm->timerfd, &timer);
 900
 901   ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
 902                  "timerfd not armed!");
 903
 904   if (lm->timerfd > 0)
 905     close (lm->timerfd);
 906   lm->timerfd = -1;
 907
 908   memif_delete (&conn);
 909   ck_assert_ptr_eq (conn, NULL);
 910 }
 911
 912 END_TEST Suite *
 913 main_suite ()
 914 {
 915   Suite *s;
 916
 917   TCase *tc_api;
 918   TCase *tc_internal;
 919
 920   /* create main test suite */
 921   s = suite_create ("Libmemif main");
 922
 923   /* create api test case */
 924   tc_api = tcase_create ("Api calls");
 925   /* add tests to test case */
 926   tcase_add_test (tc_api, test_init);
 927   tcase_add_test (tc_api, test_init_epoll);
 928   tcase_add_test (tc_api, test_create);
 929   tcase_add_test (tc_api, test_create_master);
 930   tcase_add_test (tc_api, test_create_mult);
 931   tcase_add_test (tc_api, test_control_fd_handler);
 932   tcase_add_test (tc_api, test_buffer_alloc);
 933   tcase_add_test (tc_api, test_tx_burst);
 934   tcase_add_test (tc_api, test_rx_burst);
 935   tcase_add_test (tc_api, test_get_details);
 936
 937   /* create internal test case */
 938   tc_internal = tcase_create ("Internal");
 939   /* add tests to test case */
 940   tcase_add_test (tc_internal, test_init_regions_and_queues);
 941   tcase_add_test (tc_internal, test_connect1);
 942   tcase_add_test (tc_internal, test_disconnect_internal);
 943
 944   /* add test cases to test suite */
 945   suite_add_tcase (s, tc_api);
 946   suite_add_tcase (s, tc_internal);
 947
 948   /* return main test suite to test runner */
 949   return s;
 950 }