extras/libmemif/src/main.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
  18 #define _GNU_SOURCE
  19 #include <stdint.h>
  20 #include <net/if.h>
  21 #include <sys/types.h>
  22 #include <fcntl.h>
  23 #include <sys/ioctl.h>
  24 #include <sys/socket.h>
  25 #include <sys/un.h>
  26 #include <sys/uio.h>
  27 #include <sys/mman.h>
  28 #include <sys/prctl.h>
  29 #include <inttypes.h>
  30 #include <string.h>
  31 #include <stdio.h>
  32 #include <netdb.h>
  33 #include <linux/ip.h>
  34 #include <linux/icmp.h>
  35 #include <arpa/inet.h>
  36 #include <stdlib.h>
  37 #include <netinet/if_ether.h>
  38 #include <net/if_arp.h>
  39 #include <asm/byteorder.h>
  40 #include <byteswap.h>
  41 #include <string.h>
  42 #include <errno.h>
  43 #include <sys/stat.h>
  44 #include <sys/eventfd.h>
  45 #include <sys/timerfd.h>
  46 #include <sys/epoll.h>
  47 #include <signal.h>
  48 #include <linux/memfd.h>
  49
  50 /* memif protocol msg, ring and descriptor definitions */
  51 #include <memif.h>
  52 /* memif api */
  53 #include <libmemif.h>
  54 /* socket messaging functions */
  55 #include <socket.h>
  56 /* private structs and functions */
  57 #include <memif_private.h>
  58
  59 #define ERRLIST_LEN 40
  60 #define MAX_ERRBUF_LEN 256
  61
  62 #if __x86_x64__
  63 #define MEMIF_MEMORY_BARRIER() __builtin_ia32_sfence ()
  64 #else
  65 #define MEMIF_MEMORY_BARRIER() __sync_synchronize ()
  66 #endif /* __x86_x64__ */
  67
  68 libmemif_main_t libmemif_main;
  69 int memif_epfd;
  70 int poll_cancel_fd = -1;
  71
  72 static char memif_buf[MAX_ERRBUF_LEN];
  73
  74 const char *memif_errlist[ERRLIST_LEN] = {      /* MEMIF_ERR_SUCCESS */
  75   "Success.",
  76   /* MEMIF_ERR_SYSCALL */
  77   "Unspecified syscall error (build with -DMEMIF_DBG or make debug).",
  78   /* MEMIF_ERR_CONNREFUSED */
  79   "Connection refused",
  80   /* MEMIF_ERR_ACCES */
  81   "Permission to resoure denied.",
  82   /* MEMIF_ERR_NO_FILE */
  83   "Socket file does not exist",
  84   /* MEMIF_ERR_FILE_LIMIT */
  85   "System limit on total numer of open files reached.",
  86   /* MEMIF_ERR_PROC_FILE_LIMIT */
  87   "Per-process limit on total number of open files reached.",
  88   /* MEMIF_ERR_ALREADY */
  89   "Connection already requested.",
  90   /* MEMIF_ERR_AGAIN */
  91   "File descriptor refers to file other than socket, or operation would block.",
  92   /* MEMIF_ERR_BAD_FD */
  93   "Bad file descriptor.",
  94   /* MEMIF_ERR_NOMEM */
  95   "Out of memory.",
  96   /* MEMIF_ERR_INVAL_ARG */
  97   "Invalid argument.",
  98   /* MEMIF_ERR_NOCONN */
  99   "Memif connection handle does not point to existing conenction",
 100   /* MEMIF_ERR_CONN */
 101   "Memif connection handle points to existing connection",
 102   /* MEMIF_ERR_CB_FDUPDATE */
 103   "Callback memif_control_fd_update_t returned error",
 104   /* MEMIF_ERR_FILE_NOT_SOCK */
 105   "File specified by socket filename exists and is not socket.",
 106   /* MEMIF_ERR_NO_SHMFD */
 107   "Missing shared memory file descriptor. (internal error)",
 108   /* MEMIF_ERR_COOKIE */
 109   "Invalid cookie on ring. (internal error)",
 110   /* MEMIF_ERR_NOBUF_RING */
 111   "Ring buffer full.",
 112   /* MEMIF_ERR_NOBUF */
 113   "Not enough memif buffers. There are unreceived data in shared memory.",
 114   /* MEMIF_ERR_NOBUF_DET */
 115   "Not enough space for memif details in suplied buffer. String data might be malformed.",
 116   /* MEMIF_ERR_INT_WRITE */
 117   "Send interrupt error.",
 118   /* MEMIF_ERR_MFMSG */
 119   "Malformed message received on control channel.",
 120   /* MEMIF_ERR_QID */
 121   "Invalid queue id",
 122   /* MEMIF_ERR_PROTO */
 123   "Incompatible memory interface protocol version.",
 124   /* MEMIF_ERR_ID */
 125   "Unmatched interface id.",
 126   /* MEMIF_ERR_ACCSLAVE */
 127   "Slave cannot accept connection reqest.",
 128   /* MEMIF_ERR_ALRCONN */
 129   "Interface is already connected.",
 130   /* MEMIF_ERR_MODE */
 131   "Mode mismatch.",
 132   /* MEMIF_ERR_SECRET */
 133   "Secret mismatch.",
 134   /* MEMIF_ERR_NOSECRET */
 135   "Secret required.",
 136   /* MEMIF_ERR_MAXREG */
 137   "Limit on total number of regions reached.",
 138   /* MEMIF_ERR_MAXRING */
 139   "Limit on total number of ring reached.",
 140   /* MEMIF_ERR_NO_INTFD */
 141   "Missing interrupt file descriptor. (internal error)",
 142   /* MEMIF_ERR_DISCONNECT */
 143   "Interface received disconnect request.",
 144   /* MEMIF_ERR_DISCONNECTED */
 145   "Interface is disconnected.",
 146   /* MEMIF_ERR_UNKNOWN_MSG */
 147   "Unknown message type received on control channel. (internal error)",
 148   /* MEMIF_ERR_POLL_CANCEL */
 149   "Memif event polling was canceled.",
 150   /* MEMIF_ERR_MAX_RING */
 151   "Maximum log2 ring size is 15",
 152   /* MEMIF_ERR_PRIVHDR */
 153   "Private headers not supported."
 154 };
 155
 156 #define MEMIF_ERR_UNDEFINED "undefined error"
 157
 158 char *
 159 memif_strerror (int err_code)
 160 {
 161   if (err_code >= ERRLIST_LEN)
 162     {
 163       strncpy (memif_buf, MEMIF_ERR_UNDEFINED, strlen (MEMIF_ERR_UNDEFINED));
 164       memif_buf[strlen (MEMIF_ERR_UNDEFINED)] = '\0';
 165     }
 166   else
 167     {
 168       strncpy (memif_buf, memif_errlist[err_code],
 169                strlen (memif_errlist[err_code]));
 170       memif_buf[strlen (memif_errlist[err_code])] = '\0';
 171     }
 172   return memif_buf;
 173 }
 174
 175 uint16_t
 176 memif_get_version ()
 177 {
 178   return MEMIF_VERSION;
 179 }
 180
 181 #define DBG_TX_BUF (0)
 182 #define DBG_RX_BUF (1)
 183
 184 #ifdef MEMIF_DBG_SHM
 185 static void
 186 print_bytes (void *data, uint16_t len, uint8_t q)
 187 {
 188   if (q == DBG_TX_BUF)
 189     printf ("\nTX:\n\t");
 190   else
 191     printf ("\nRX:\n\t");
 192   int i;
 193   for (i = 0; i < len; i++)
 194     {
 195       if (i % 8 == 0)
 196         printf ("\n%d:\t", i);
 197       printf ("%02X ", ((uint8_t *) (data))[i]);
 198     }
 199   printf ("\n\n");
 200 }
 201 #endif /* MEMIF_DBG_SHM */
 202
 203 int
 204 memif_syscall_error_handler (int err_code)
 205 {
 206   DBG ("%s", strerror (err_code));
 207
 208   if (err_code == 0)
 209     return MEMIF_ERR_SUCCESS;
 210   if (err_code == EACCES)
 211     return MEMIF_ERR_ACCES;
 212   if (err_code == ENFILE)
 213     return MEMIF_ERR_FILE_LIMIT;
 214   if (err_code == EMFILE)
 215     return MEMIF_ERR_PROC_FILE_LIMIT;
 216   if (err_code == ENOMEM)
 217     return MEMIF_ERR_NOMEM;
 218 /* connection refused if master does not exist
 219     this error would spam the user until master was created */
 220 /*
 221   if (err_code == ECONNREFUSED)
 222     return MEMIF_ERR_SUCCESS;
 223 */
 224   if (err_code == ECONNREFUSED)
 225     return MEMIF_ERR_CONNREFUSED;
 226   if (err_code == EALREADY)
 227     return MEMIF_ERR_ALREADY;
 228   if (err_code == EAGAIN)
 229     return MEMIF_ERR_AGAIN;
 230   if (err_code == EBADF)
 231     return MEMIF_ERR_BAD_FD;
 232   if (err_code == ENOENT)
 233     return MEMIF_ERR_NO_FILE;
 234
 235   /* other syscall errors */
 236   return MEMIF_ERR_SYSCALL;
 237 }
 238
 239 static int
 240 memif_add_epoll_fd (int fd, uint32_t events)
 241 {
 242   if (fd < 0)
 243     {
 244       DBG ("invalid fd %d", fd);
 245       return -1;
 246     }
 247   struct epoll_event evt;
 248   memset (&evt, 0, sizeof (evt));
 249   evt.events = events;
 250   evt.data.fd = fd;
 251   if (epoll_ctl (memif_epfd, EPOLL_CTL_ADD, fd, &evt) < 0)
 252     {
 253       DBG ("epoll_ctl: %s fd %d", strerror (errno), fd);
 254       return -1;
 255     }
 256   DBG ("fd %d added to epoll", fd);
 257   return 0;
 258 }
 259
 260 static int
 261 memif_mod_epoll_fd (int fd, uint32_t events)
 262 {
 263   if (fd < 0)
 264     {
 265       DBG ("invalid fd %d", fd);
 266       return -1;
 267     }
 268   struct epoll_event evt;
 269   memset (&evt, 0, sizeof (evt));
 270   evt.events = events;
 271   evt.data.fd = fd;
 272   if (epoll_ctl (memif_epfd, EPOLL_CTL_MOD, fd, &evt) < 0)
 273     {
 274       DBG ("epoll_ctl: %s fd %d", strerror (errno), fd);
 275       return -1;
 276     }
 277   DBG ("fd %d moddified on epoll", fd);
 278   return 0;
 279 }
 280
 281 static int
 282 memif_del_epoll_fd (int fd)
 283 {
 284   if (fd < 0)
 285     {
 286       DBG ("invalid fd %d", fd);
 287       return -1;
 288     }
 289   struct epoll_event evt;
 290   memset (&evt, 0, sizeof (evt));
 291   if (epoll_ctl (memif_epfd, EPOLL_CTL_DEL, fd, &evt) < 0)
 292     {
 293       DBG ("epoll_ctl: %s fd %d", strerror (errno), fd);
 294       return -1;
 295     }
 296   DBG ("fd %d removed from epoll", fd);
 297   return 0;
 298 }
 299
 300 int
 301 memif_control_fd_update (int fd, uint8_t events)
 302 {
 303   if (events & MEMIF_FD_EVENT_DEL)
 304     return memif_del_epoll_fd (fd);
 305
 306   uint32_t evt = 0;
 307   if (events & MEMIF_FD_EVENT_READ)
 308     evt |= EPOLLIN;
 309   if (events & MEMIF_FD_EVENT_WRITE)
 310     evt |= EPOLLOUT;
 311
 312   if (events & MEMIF_FD_EVENT_MOD)
 313     return memif_mod_epoll_fd (fd, evt);
 314
 315   return memif_add_epoll_fd (fd, evt);
 316 }
 317
 318 int
 319 add_list_elt (memif_list_elt_t * e, memif_list_elt_t ** list, uint16_t * len)
 320 {
 321   libmemif_main_t *lm = &libmemif_main;
 322
 323   int i;
 324   for (i = 0; i < *len; i++)
 325     {
 326       if ((*list)[i].data_struct == NULL)
 327         {
 328           (*list)[i].key = e->key;
 329           (*list)[i].data_struct = e->data_struct;
 330           return i;
 331         }
 332     }
 333   memif_list_elt_t *tmp;
 334   tmp = lm->realloc (*list, sizeof (memif_list_elt_t) * *len * 2);
 335   if (tmp == NULL)
 336     return -1;
 337
 338   for (i = *len; i < *len * 2; i++)
 339     {
 340       tmp[i].key = -1;
 341       tmp[i].data_struct = NULL;
 342     }
 343
 344   tmp[*len].key = e->key;
 345   tmp[*len].data_struct = e->data_struct;
 346   i = *len;
 347   *len = *len * 2;
 348   *list = tmp;
 349
 350   return i;
 351 }
 352
 353 int
 354 get_list_elt (memif_list_elt_t ** e, memif_list_elt_t * list, uint16_t len,
 355               int key)
 356 {
 357   if (key == -1)
 358     {
 359       *e = NULL;
 360       return -1;
 361     }
 362   int i;
 363   for (i = 0; i < len; i++)
 364     {
 365       if (list[i].key == key)
 366         {
 367           *e = &list[i];
 368           return 0;
 369         }
 370     }
 371   *e = NULL;
 372   return -1;
 373 }
 374
 375 /* does not free memory, only marks element as free */
 376 int
 377 free_list_elt (memif_list_elt_t * list, uint16_t len, int key)
 378 {
 379   int i;
 380   for (i = 0; i < len; i++)
 381     {
 382       if (list[i].key == key)
 383         {
 384           list[i].key = -1;
 385           list[i].data_struct = NULL;
 386           return 0;
 387         }
 388     }
 389
 390   return -1;
 391 }
 392
 393 int
 394 free_list_elt_ctx (memif_list_elt_t * list, uint16_t len,
 395                    memif_connection_t * ctx)
 396 {
 397   int i;
 398   for (i = 0; i < len; i++)
 399     {
 400       if (list[i].key == -1)
 401         {
 402           if (list[i].data_struct == ctx)
 403             {
 404               list[i].data_struct = NULL;
 405               return 0;
 406             }
 407         }
 408     }
 409
 410   return -1;
 411 }
 412
 413 static void
 414 memif_control_fd_update_register (memif_control_fd_update_t * cb)
 415 {
 416   libmemif_main_t *lm = &libmemif_main;
 417   lm->control_fd_update = cb;
 418 }
 419
 420 void
 421 memif_register_external_region (memif_add_external_region_t * ar,
 422                                 memif_get_external_region_addr_t * gr,
 423                                 memif_del_external_region_t * dr,
 424                                 memif_get_external_buffer_offset_t * go)
 425 {
 426   libmemif_main_t *lm = &libmemif_main;
 427   lm->add_external_region = ar;
 428   lm->get_external_region_addr = gr;
 429   lm->del_external_region = dr;
 430   lm->get_external_buffer_offset = go;
 431 }
 432
 433 static void
 434 memif_alloc_register (memif_alloc_t * ma)
 435 {
 436   libmemif_main_t *lm = &libmemif_main;
 437   lm->alloc = ma;
 438 }
 439
 440 static void
 441 memif_realloc_register (memif_realloc_t * mr)
 442 {
 443   libmemif_main_t *lm = &libmemif_main;
 444   lm->realloc = mr;
 445 }
 446
 447 static void
 448 memif_free_register (memif_free_t * mf)
 449 {
 450   libmemif_main_t *lm = &libmemif_main;
 451   lm->free = mf;
 452 }
 453
 454 int
 455 memif_init (memif_control_fd_update_t * on_control_fd_update, char *app_name,
 456             memif_alloc_t * memif_alloc, memif_realloc_t * memif_realloc,
 457             memif_free_t * memif_free)
 458 {
 459   int err = MEMIF_ERR_SUCCESS;  /* 0 */
 460   libmemif_main_t *lm = &libmemif_main;
 461   memset (lm, 0, sizeof (libmemif_main_t));
 462
 463   if (memif_alloc != NULL)
 464     {
 465       memif_alloc_register (memif_alloc);
 466     }
 467   else
 468     memif_alloc_register (malloc);
 469
 470   if (memif_realloc != NULL)
 471     {
 472       memif_realloc_register (memif_realloc);
 473     }
 474   else
 475     memif_realloc_register (realloc);
 476
 477   if (memif_free != NULL)
 478     memif_free_register (memif_free);
 479   else
 480     memif_free_register (free);
 481
 482   if (app_name != NULL)
 483     {
 484       uint8_t len = (strlen (app_name) > MEMIF_NAME_LEN)
 485         ? strlen (app_name) : MEMIF_NAME_LEN;
 486       strncpy ((char *) lm->app_name, app_name, len);
 487     }
 488   else
 489     {
 490       strncpy ((char *) lm->app_name, MEMIF_DEFAULT_APP_NAME,
 491                strlen (MEMIF_DEFAULT_APP_NAME));
 492     }
 493
 494   /* register control fd update callback */
 495   if (on_control_fd_update != NULL)
 496     memif_control_fd_update_register (on_control_fd_update);
 497   else
 498     {
 499       memif_epfd = epoll_create (1);
 500       memif_control_fd_update_register (memif_control_fd_update);
 501       if ((poll_cancel_fd = eventfd (0, EFD_NONBLOCK)) < 0)
 502         {
 503           err = errno;
 504           DBG ("eventfd: %s", strerror (err));
 505           return memif_syscall_error_handler (err);
 506         }
 507       lm->control_fd_update (poll_cancel_fd, MEMIF_FD_EVENT_READ);
 508       DBG ("libmemif event polling initialized");
 509     }
 510
 511   lm->control_list_len = 2;
 512   lm->interrupt_list_len = 2;
 513   lm->listener_list_len = 1;
 514   lm->pending_list_len = 1;
 515
 516   lm->control_list =
 517     lm->alloc (sizeof (memif_list_elt_t) * lm->control_list_len);
 518   if (lm->control_list == NULL)
 519     {
 520       err = MEMIF_ERR_NOMEM;
 521       goto error;
 522     }
 523   lm->interrupt_list =
 524     lm->alloc (sizeof (memif_list_elt_t) * lm->interrupt_list_len);
 525   if (lm->interrupt_list == NULL)
 526     {
 527       err = MEMIF_ERR_NOMEM;
 528       goto error;
 529     }
 530   lm->listener_list =
 531     lm->alloc (sizeof (memif_list_elt_t) * lm->listener_list_len);
 532   if (lm->listener_list == NULL)
 533     {
 534       err = MEMIF_ERR_NOMEM;
 535       goto error;
 536     }
 537   lm->pending_list =
 538     lm->alloc (sizeof (memif_list_elt_t) * lm->pending_list_len);
 539   if (lm->pending_list == NULL)
 540     {
 541       err = MEMIF_ERR_NOMEM;
 542       goto error;
 543     }
 544
 545   int i;
 546   for (i = 0; i < lm->control_list_len; i++)
 547     {
 548       lm->control_list[i].key = -1;
 549       lm->control_list[i].data_struct = NULL;
 550     }
 551   for (i = 0; i < lm->interrupt_list_len; i++)
 552     {
 553       lm->interrupt_list[i].key = -1;
 554       lm->interrupt_list[i].data_struct = NULL;
 555     }
 556   for (i = 0; i < lm->listener_list_len; i++)
 557     {
 558       lm->listener_list[i].key = -1;
 559       lm->listener_list[i].data_struct = NULL;
 560     }
 561   for (i = 0; i < lm->pending_list_len; i++)
 562     {
 563       lm->pending_list[i].key = -1;
 564       lm->pending_list[i].data_struct = NULL;
 565     }
 566
 567   lm->disconn_slaves = 0;
 568
 569   lm->timerfd = timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK);
 570   if (lm->timerfd < 0)
 571     {
 572       err = memif_syscall_error_handler (errno);
 573       goto error;
 574     }
 575
 576   lm->arm.it_value.tv_sec = 2;
 577   lm->arm.it_value.tv_nsec = 0;
 578   lm->arm.it_interval.tv_sec = 2;
 579   lm->arm.it_interval.tv_nsec = 0;
 580
 581   if (lm->control_fd_update (lm->timerfd, MEMIF_FD_EVENT_READ) < 0)
 582     {
 583       DBG ("callback type memif_control_fd_update_t error!");
 584       err = MEMIF_ERR_CB_FDUPDATE;
 585       goto error;
 586     }
 587
 588   return err;
 589
 590 error:
 591   memif_cleanup ();
 592   return err;
 593 }
 594
 595 static inline memif_ring_t *
 596 memif_get_ring (memif_connection_t * conn, memif_ring_type_t type,
 597                 uint16_t ring_num)
 598 {
 599   if (&conn->regions[0] == NULL)
 600     return NULL;
 601   void *p = conn->regions[0].addr;
 602   int ring_size =
 603     sizeof (memif_ring_t) +
 604     sizeof (memif_desc_t) * (1 << conn->run_args.log2_ring_size);
 605   p += (ring_num + type * conn->run_args.num_s2m_rings) * ring_size;
 606
 607   return (memif_ring_t *) p;
 608 }
 609
 610 int
 611 memif_set_rx_mode (memif_conn_handle_t c, memif_rx_mode_t rx_mode,
 612                    uint16_t qid)
 613 {
 614   memif_connection_t *conn = (memif_connection_t *) c;
 615   if (conn == NULL)
 616     return MEMIF_ERR_NOCONN;
 617   uint8_t num =
 618     (conn->args.is_master) ? conn->run_args.num_s2m_rings : conn->
 619     run_args.num_m2s_rings;
 620   if (qid >= num)
 621     return MEMIF_ERR_QID;
 622
 623   conn->rx_queues[qid].ring->flags = rx_mode;
 624   DBG ("rx_mode flag: %u", conn->rx_queues[qid].ring->flags);
 625   return MEMIF_ERR_SUCCESS;
 626 }
 627
 628 int
 629 memif_create (memif_conn_handle_t * c, memif_conn_args_t * args,
 630               memif_connection_update_t * on_connect,
 631               memif_connection_update_t * on_disconnect,
 632               memif_interrupt_t * on_interrupt, void *private_ctx)
 633 {
 634   libmemif_main_t *lm = &libmemif_main;
 635   int err, i, index, sockfd = -1;
 636   memif_list_elt_t list_elt;
 637   memif_connection_t *conn = (memif_connection_t *) * c;
 638   if (conn != NULL)
 639     {
 640       DBG ("This handle already points to existing memif.");
 641       return MEMIF_ERR_CONN;
 642     }
 643   conn = (memif_connection_t *) lm->alloc (sizeof (memif_connection_t));
 644   if (conn == NULL)
 645     {
 646       err = MEMIF_ERR_NOMEM;
 647       goto error;
 648     }
 649   memset (conn, 0, sizeof (memif_connection_t));
 650
 651   conn->args.interface_id = args->interface_id;
 652
 653   if (args->log2_ring_size == 0)
 654     args->log2_ring_size = MEMIF_DEFAULT_LOG2_RING_SIZE;
 655   else if (args->log2_ring_size > MEMIF_MAX_LOG2_RING_SIZE)
 656     {
 657       err = MEMIF_ERR_MAX_RING;
 658       goto error;
 659     }
 660   if (args->buffer_size == 0)
 661     args->buffer_size = MEMIF_DEFAULT_BUFFER_SIZE;
 662   if (args->num_s2m_rings == 0)
 663     args->num_s2m_rings = MEMIF_DEFAULT_TX_QUEUES;
 664   if (args->num_m2s_rings == 0)
 665     args->num_m2s_rings = MEMIF_DEFAULT_RX_QUEUES;
 666
 667   conn->args.num_s2m_rings = args->num_s2m_rings;
 668   conn->args.num_m2s_rings = args->num_m2s_rings;
 669   conn->args.buffer_size = args->buffer_size;
 670   conn->args.log2_ring_size = args->log2_ring_size;
 671   conn->args.is_master = args->is_master;
 672   conn->args.mode = args->mode;
 673   conn->msg_queue = NULL;
 674   conn->regions = NULL;
 675   conn->tx_queues = NULL;
 676   conn->rx_queues = NULL;
 677   conn->fd = -1;
 678   conn->on_connect = on_connect;
 679   conn->on_disconnect = on_disconnect;
 680   conn->on_interrupt = on_interrupt;
 681   conn->private_ctx = private_ctx;
 682   memset (&conn->run_args, 0, sizeof (memif_conn_run_args_t));
 683
 684   uint8_t l = strlen ((char *) args->interface_name);
 685   strncpy ((char *) conn->args.interface_name, (char *) args->interface_name,
 686            l);
 687
 688   /* allocate and initialize socket_filename so it can be copyed to sun_path
 689      without memory leaks */
 690   conn->args.socket_filename = lm->alloc (sizeof (char *) * 108);
 691   if (conn->args.socket_filename == NULL)
 692     {
 693       err = MEMIF_ERR_NOMEM;
 694       goto error;
 695     }
 696   memset (conn->args.socket_filename, 0, 108 * sizeof (char *));
 697
 698   if (args->socket_filename)
 699     {
 700       if (conn->args.socket_filename == NULL)
 701         {
 702           err = memif_syscall_error_handler (errno);
 703           goto error;
 704         }
 705       strncpy ((char *) conn->args.socket_filename,
 706                (char *) args->socket_filename,
 707                strlen ((char *) args->socket_filename));
 708     }
 709   else
 710     {
 711       uint16_t sdl = strlen (MEMIF_DEFAULT_SOCKET_DIR);
 712       uint16_t sfl = strlen (MEMIF_DEFAULT_SOCKET_FILENAME);
 713       if (conn->args.socket_filename == NULL)
 714         {
 715           err = memif_syscall_error_handler (errno);
 716           goto error;
 717         }
 718       strncpy ((char *) conn->args.socket_filename,
 719                MEMIF_DEFAULT_SOCKET_DIR, sdl);
 720       conn->args.socket_filename[sdl] = '/';
 721       strncpy ((char *) (conn->args.socket_filename + 1 + sdl),
 722                MEMIF_DEFAULT_SOCKET_FILENAME, sfl);
 723     }
 724
 725   if ((l = strlen ((char *) args->secret)) > 0)
 726     {
 727       strncpy ((char *) conn->args.secret, (char *) args->secret, l);
 728     }
 729
 730   if (conn->args.is_master)
 731     {
 732       conn->run_args.buffer_size = conn->args.buffer_size;
 733       memif_socket_t *ms;
 734       memif_list_elt_t elt;
 735       for (i = 0; i < lm->listener_list_len; i++)
 736         {
 737           if ((ms =
 738                (memif_socket_t *) lm->listener_list[i].data_struct) != NULL)
 739             {
 740               if (strncmp
 741                   ((char *) ms->filename, (char *) conn->args.socket_filename,
 742                    strlen ((char *) ms->filename)) == 0)
 743                 {
 744                   /* add interface to listener socket */
 745                   elt.key = conn->args.interface_id;
 746                   *c = elt.data_struct = conn;
 747                   add_list_elt (&elt, &ms->interface_list,
 748                                 &ms->interface_list_len);
 749                   ms->use_count++;
 750                   conn->listener_fd = ms->fd;
 751                   break;
 752                 }
 753             }
 754           else
 755             {
 756               struct stat file_stat;
 757               if (stat ((char *) conn->args.socket_filename, &file_stat) == 0)
 758                 {
 759                   if (S_ISSOCK (file_stat.st_mode))
 760                     unlink ((char *) conn->args.socket_filename);
 761                   else
 762                     return memif_syscall_error_handler (errno);
 763                 }
 764               DBG ("creating socket file");
 765               ms = lm->alloc (sizeof (memif_socket_t));
 766               if (ms == NULL)
 767                 {
 768                   err = MEMIF_ERR_NOMEM;
 769                   goto error;
 770                 }
 771               ms->filename =
 772                 lm->alloc (strlen ((char *) conn->args.socket_filename) +
 773                            sizeof (char));
 774               if (ms->filename == NULL)
 775                 {
 776                   err = MEMIF_ERR_NOMEM;
 777                   goto error;
 778                 }
 779               memset (ms->filename, 0,
 780                       strlen ((char *) conn->args.socket_filename) +
 781                       sizeof (char));
 782               strncpy ((char *) ms->filename,
 783                        (char *) conn->args.socket_filename,
 784                        strlen ((char *) conn->args.socket_filename));
 785               ms->interface_list_len = 1;
 786               ms->interface_list =
 787                 lm->alloc (sizeof (memif_list_elt_t) *
 788                            ms->interface_list_len);
 789               if (ms->interface_list == NULL)
 790                 {
 791                   err = MEMIF_ERR_NOMEM;
 792                   goto error;
 793                 }
 794               ms->interface_list[0].key = -1;
 795               ms->interface_list[0].data_struct = NULL;
 796               struct sockaddr_un un = { 0 };
 797               int on = 1;
 798
 799               ms->fd = socket (AF_UNIX, SOCK_SEQPACKET, 0);
 800               if (ms->fd < 0)
 801                 {
 802                   err = memif_syscall_error_handler (errno);
 803                   goto error;
 804                 }
 805               DBG ("socket %d created", ms->fd);
 806               un.sun_family = AF_UNIX;
 807               strncpy ((char *) un.sun_path, (char *) ms->filename,
 808                        sizeof (un.sun_path) - 1);
 809               DBG ("sockopt");
 810               if (setsockopt
 811                   (ms->fd, SOL_SOCKET, SO_PASSCRED, &on, sizeof (on)) < 0)
 812                 {
 813                   err = memif_syscall_error_handler (errno);
 814                   goto error;
 815                 }
 816               DBG ("bind");
 817               if (bind (ms->fd, (struct sockaddr *) &un, sizeof (un)) < 0)
 818                 {
 819                   err = memif_syscall_error_handler (errno);
 820                   goto error;
 821                 }
 822               DBG ("listen");
 823               if (listen (ms->fd, 1) < 0)
 824                 {
 825                   err = memif_syscall_error_handler (errno);
 826                   goto error;
 827                 }
 828               DBG ("stat");
 829               if (stat ((char *) ms->filename, &file_stat) < 0)
 830                 {
 831                   err = memif_syscall_error_handler (errno);
 832                   goto error;
 833                 }
 834
 835               /* add interface to listener socket */
 836               elt.key = conn->args.interface_id;
 837               *c = elt.data_struct = conn;
 838               add_list_elt (&elt, &ms->interface_list,
 839                             &ms->interface_list_len);
 840               ms->use_count = 1;
 841               conn->listener_fd = ms->fd;
 842
 843               /* add listener socket to libmemif main */
 844               elt.key = ms->fd;
 845               elt.data_struct = ms;
 846               add_list_elt (&elt, &lm->listener_list, &lm->listener_list_len);
 847               lm->control_fd_update (ms->fd, MEMIF_FD_EVENT_READ);
 848               break;
 849             }
 850         }
 851     }
 852   else
 853     {
 854       if (lm->disconn_slaves == 0)
 855         {
 856           if (timerfd_settime (lm->timerfd, 0, &lm->arm, NULL) < 0)
 857             {
 858               err = memif_syscall_error_handler (errno);
 859               goto error;
 860             }
 861         }
 862
 863       lm->disconn_slaves++;
 864
 865       list_elt.key = -1;
 866       *c = list_elt.data_struct = conn;
 867       if ((index =
 868            add_list_elt (&list_elt, &lm->control_list,
 869                          &lm->control_list_len)) < 0)
 870         {
 871           err = MEMIF_ERR_NOMEM;
 872           goto error;
 873         }
 874     }
 875
 876   conn->index = index;
 877
 878   return 0;
 879
 880 error:
 881   if (sockfd > 0)
 882     close (sockfd);
 883   sockfd = -1;
 884   if (conn->args.socket_filename)
 885     lm->free (conn->args.socket_filename);
 886   if (conn != NULL)
 887     lm->free (conn);
 888   *c = conn = NULL;
 889   return err;
 890 }
 891
 892 int
 893 memif_control_fd_handler (int fd, uint8_t events)
 894 {
 895   int i, rv, sockfd = -1, err = MEMIF_ERR_SUCCESS;      /* 0 */
 896   uint16_t num;
 897   memif_list_elt_t *e = NULL;
 898   memif_connection_t *conn;
 899   libmemif_main_t *lm = &libmemif_main;
 900   if (fd == lm->timerfd)
 901     {
 902       uint64_t b;
 903       ssize_t size;
 904       size = read (fd, &b, sizeof (b));
 905       for (i = 0; i < lm->control_list_len; i++)
 906         {
 907           if ((lm->control_list[i].key < 0)
 908               && (lm->control_list[i].data_struct != NULL))
 909             {
 910               conn = lm->control_list[i].data_struct;
 911               if (conn->args.is_master)
 912                 continue;
 913
 914               struct sockaddr_un sun;
 915               sockfd = socket (AF_UNIX, SOCK_SEQPACKET, 0);
 916               if (sockfd < 0)
 917                 {
 918                   err = memif_syscall_error_handler (errno);
 919                   goto error;
 920                 }
 921
 922               sun.sun_family = AF_UNIX;
 923
 924               strncpy (sun.sun_path, (char *) conn->args.socket_filename,
 925                        sizeof (sun.sun_path) - 1);
 926
 927               if (connect (sockfd, (struct sockaddr *) &sun,
 928                            sizeof (struct sockaddr_un)) == 0)
 929                 {
 930                   conn->fd = sockfd;
 931                   conn->read_fn = memif_conn_fd_read_ready;
 932                   conn->write_fn = memif_conn_fd_write_ready;
 933                   conn->error_fn = memif_conn_fd_error;
 934
 935                   lm->control_list[conn->index].key = conn->fd;
 936
 937                   lm->control_fd_update (sockfd,
 938                                          MEMIF_FD_EVENT_READ |
 939                                          MEMIF_FD_EVENT_WRITE);
 940
 941                   lm->disconn_slaves--;
 942                   if (lm->disconn_slaves == 0)
 943                     {
 944                       if (timerfd_settime (lm->timerfd, 0, &lm->disarm, NULL)
 945                           < 0)
 946                         {
 947                           err = memif_syscall_error_handler (errno);
 948                           goto error;
 949                         }
 950                     }
 951                 }
 952               else
 953                 {
 954                   strcpy ((char *) conn->remote_disconnect_string,
 955                           memif_strerror (memif_syscall_error_handler
 956                                           (errno)));
 957                 }
 958             }
 959         }
 960     }
 961   else
 962     {
 963       get_list_elt (&e, lm->interrupt_list, lm->interrupt_list_len, fd);
 964       if (e != NULL)
 965         {
 966           if (((memif_connection_t *) e->data_struct)->on_interrupt != NULL)
 967             {
 968               num =
 969                 (((memif_connection_t *) e->data_struct)->
 970                  args.is_master) ? ((memif_connection_t *) e->
 971                                     data_struct)->run_args.
 972                 num_s2m_rings : ((memif_connection_t *) e->data_struct)->
 973                 run_args.num_m2s_rings;
 974               for (i = 0; i < num; i++)
 975                 {
 976                   if (((memif_connection_t *) e->data_struct)->
 977                       rx_queues[i].int_fd == fd)
 978                     {
 979                       ((memif_connection_t *) e->data_struct)->
 980                         on_interrupt ((void *) e->data_struct,
 981                                       ((memif_connection_t *) e->
 982                                        data_struct)->private_ctx, i);
 983                       return MEMIF_ERR_SUCCESS;
 984                     }
 985                 }
 986             }
 987           return MEMIF_ERR_SUCCESS;
 988         }
 989       get_list_elt (&e, lm->listener_list, lm->listener_list_len, fd);
 990       if (e != NULL)
 991         {
 992           memif_conn_fd_accept_ready ((memif_socket_t *) e->data_struct);
 993           return MEMIF_ERR_SUCCESS;
 994         }
 995
 996       get_list_elt (&e, lm->pending_list, lm->pending_list_len, fd);
 997       if (e != NULL)
 998         {
 999           memif_read_ready (fd);
1000           return MEMIF_ERR_SUCCESS;
1001         }
1002
1003       get_list_elt (&e, lm->control_list, lm->control_list_len, fd);
1004       if (e != NULL)
1005         {
1006           if (events & MEMIF_FD_EVENT_READ)
1007             {
1008               err =
1009                 ((memif_connection_t *) e->data_struct)->
1010                 read_fn (e->data_struct);
1011               if (err != MEMIF_ERR_SUCCESS)
1012                 return err;
1013             }
1014           if (events & MEMIF_FD_EVENT_WRITE)
1015             {
1016               err =
1017                 ((memif_connection_t *) e->data_struct)->
1018                 write_fn (e->data_struct);
1019               if (err != MEMIF_ERR_SUCCESS)
1020                 return err;
1021             }
1022           if (events & MEMIF_FD_EVENT_ERROR)
1023             {
1024               err =
1025                 ((memif_connection_t *) e->data_struct)->
1026                 error_fn (e->data_struct);
1027               if (err != MEMIF_ERR_SUCCESS)
1028                 return err;
1029             }
1030         }
1031     }
1032
1033   return MEMIF_ERR_SUCCESS;     /* 0 */
1034
1035 error:
1036   if (sockfd > 0)
1037     close (sockfd);
1038   sockfd = -1;
1039   return err;
1040 }
1041
1042 int
1043 memif_poll_event (int timeout)
1044 {
1045   libmemif_main_t *lm = &libmemif_main;
1046   memif_list_elt_t *elt;
1047   struct epoll_event evt, *e;
1048   int en = 0, err = MEMIF_ERR_SUCCESS, i = 0;   /* 0 */
1049   uint16_t num;
1050   uint32_t events = 0;
1051   uint64_t counter = 0;
1052   ssize_t r = 0;
1053   memset (&evt, 0, sizeof (evt));
1054   evt.events = EPOLLIN | EPOLLOUT;
1055   sigset_t sigset;
1056   sigemptyset (&sigset);
1057   en = epoll_pwait (memif_epfd, &evt, 1, timeout, &sigset);
1058   if (en < 0)
1059     {
1060       err = errno;
1061       DBG ("epoll_pwait: %s", strerror (err));
1062       return memif_syscall_error_handler (err);
1063     }
1064   if (en > 0)
1065     {
1066       if (evt.data.fd == poll_cancel_fd)
1067         {
1068           r = read (evt.data.fd, &counter, sizeof (counter));
1069           return MEMIF_ERR_POLL_CANCEL;
1070         }
1071       if (evt.events & EPOLLIN)
1072         events |= MEMIF_FD_EVENT_READ;
1073       if (evt.events & EPOLLOUT)
1074         events |= MEMIF_FD_EVENT_WRITE;
1075       if (evt.events & EPOLLERR)
1076         events |= MEMIF_FD_EVENT_ERROR;
1077       err = memif_control_fd_handler (evt.data.fd, events);
1078       return err;
1079     }
1080   return 0;
1081 }
1082
1083 int
1084 memif_cancel_poll_event ()
1085 {
1086   uint64_t counter = 1;
1087   ssize_t w = 0;
1088
1089   if (poll_cancel_fd == -1)
1090     return 0;
1091   w = write (poll_cancel_fd, &counter, sizeof (counter));
1092   if (w < sizeof (counter))
1093     return MEMIF_ERR_INT_WRITE;
1094
1095   return 0;
1096 }
1097
1098 static void
1099 memif_msg_queue_free (libmemif_main_t * lm, memif_msg_queue_elt_t ** e)
1100 {
1101   if (*e == NULL)
1102     return;
1103   memif_msg_queue_free (lm, &(*e)->next);
1104   lm->free (*e);
1105   *e = NULL;
1106   return;
1107 }
1108
1109 /* send disconnect msg and close interface */
1110 int
1111 memif_disconnect_internal (memif_connection_t * c)
1112 {
1113   if (c == NULL)
1114     {
1115       DBG ("no connection");
1116       return MEMIF_ERR_NOCONN;
1117     }
1118   uint16_t num;
1119   int err = MEMIF_ERR_SUCCESS, i;       /* 0 */
1120   memif_queue_t *mq;
1121   libmemif_main_t *lm = &libmemif_main;
1122   memif_list_elt_t *e;
1123
1124   c->on_disconnect ((void *) c, c->private_ctx);
1125
1126   if (c->fd > 0)
1127     {
1128       memif_msg_send_disconnect (c->fd, (uint8_t *) "interface deleted", 0);
1129       lm->control_fd_update (c->fd, MEMIF_FD_EVENT_DEL);
1130       close (c->fd);
1131     }
1132   get_list_elt (&e, lm->control_list, lm->control_list_len, c->fd);
1133   if (e != NULL)
1134     {
1135       if (c->args.is_master)
1136         free_list_elt (lm->control_list, lm->control_list_len, c->fd);
1137       e->key = c->fd = -1;
1138     }
1139
1140   if (c->tx_queues != NULL)
1141     {
1142       num =
1143         (c->args.is_master) ? c->run_args.num_m2s_rings : c->
1144         run_args.num_s2m_rings;
1145       for (i = 0; i < num; i++)
1146         {
1147           mq = &c->tx_queues[i];
1148           if (mq != NULL)
1149             {
1150               if (mq->int_fd > 0)
1151                 close (mq->int_fd);
1152               free_list_elt (lm->interrupt_list, lm->interrupt_list_len,
1153                              mq->int_fd);
1154               mq->int_fd = -1;
1155             }
1156         }
1157       lm->free (c->tx_queues);
1158       c->tx_queues = NULL;
1159     }
1160
1161   if (c->rx_queues != NULL)
1162     {
1163       num =
1164         (c->args.is_master) ? c->run_args.num_s2m_rings : c->
1165         run_args.num_m2s_rings;
1166       for (i = 0; i < num; i++)
1167         {
1168           mq = &c->rx_queues[i];
1169           if (mq != NULL)
1170             {
1171               if (mq->int_fd > 0)
1172                 {
1173                   if (c->on_interrupt != NULL)
1174                     lm->control_fd_update (mq->int_fd, MEMIF_FD_EVENT_DEL);
1175                   close (mq->int_fd);
1176                 }
1177               free_list_elt (lm->interrupt_list, lm->interrupt_list_len,
1178                              mq->int_fd);
1179               mq->int_fd = -1;
1180             }
1181         }
1182       lm->free (c->rx_queues);
1183       c->rx_queues = NULL;
1184     }
1185
1186   for (i = 0; i < c->regions_num; i++)
1187     {
1188       if (c->regions[i].is_external != 0)
1189         {
1190           lm->del_external_region (c->regions[i].addr,
1191                                    c->regions[i].region_size,
1192                                    c->regions[i].fd, c->private_ctx);
1193         }
1194       else
1195         {
1196           if (munmap (c->regions[i].addr, c->regions[i].region_size) < 0)
1197             return memif_syscall_error_handler (errno);
1198           if (c->regions[i].fd > 0)
1199             close (c->regions[i].fd);
1200           c->regions[i].fd = -1;
1201         }
1202     }
1203   lm->free (c->regions);
1204   c->regions = NULL;
1205   c->regions_num = 0;
1206
1207   memset (&c->run_args, 0, sizeof (memif_conn_run_args_t));
1208
1209   memif_msg_queue_free (lm, &c->msg_queue);
1210
1211   if (!(c->args.is_master))
1212     {
1213       if (lm->disconn_slaves == 0)
1214         {
1215           if (timerfd_settime (lm->timerfd, 0, &lm->arm, NULL) < 0)
1216             {
1217               err = memif_syscall_error_handler (errno);
1218               DBG ("timerfd_settime: arm");
1219             }
1220         }
1221       lm->disconn_slaves++;
1222     }
1223
1224   return err;
1225 }
1226
1227 int
1228 memif_delete (memif_conn_handle_t * conn)
1229 {
1230   memif_connection_t *c = (memif_connection_t *) * conn;
1231   if (c == NULL)
1232     {
1233       DBG ("no connection");
1234       return MEMIF_ERR_NOCONN;
1235     }
1236   libmemif_main_t *lm = &libmemif_main;
1237   memif_list_elt_t *e = NULL;
1238   memif_socket_t *ms = NULL;
1239
1240   int err = MEMIF_ERR_SUCCESS;
1241
1242   if (c->fd > 0)
1243     {
1244       DBG ("DISCONNECTING");
1245       err = memif_disconnect_internal (c);
1246       if (err == MEMIF_ERR_NOCONN)
1247         return err;
1248     }
1249
1250   free_list_elt_ctx (lm->control_list, lm->control_list_len, c);
1251
1252   if (c->args.is_master)
1253     {
1254       get_list_elt (&e, lm->listener_list, lm->listener_list_len,
1255                     c->listener_fd);
1256       if (e != NULL)
1257         {
1258           ms = (memif_socket_t *) e->data_struct;
1259           ms->use_count--;
1260           free_list_elt (ms->interface_list, ms->interface_list_len,
1261                          c->args.interface_id);
1262           if (ms->use_count <= 0)
1263             {
1264               lm->control_fd_update (c->listener_fd, MEMIF_FD_EVENT_DEL);
1265               free_list_elt (lm->listener_list, lm->listener_list_len,
1266                              c->listener_fd);
1267               close (c->listener_fd);
1268               c->listener_fd = ms->fd = -1;
1269               lm->free (ms->interface_list);
1270               ms->interface_list = NULL;
1271               lm->free (ms->filename);
1272               ms->filename = NULL;
1273               lm->free (ms);
1274               ms = NULL;
1275             }
1276         }
1277     }
1278   else
1279     {
1280       lm->disconn_slaves--;
1281       if (lm->disconn_slaves <= 0)
1282         {
1283           if (timerfd_settime (lm->timerfd, 0, &lm->disarm, NULL) < 0)
1284             {
1285               err = memif_syscall_error_handler (errno);
1286               DBG ("timerfd_settime: disarm");
1287             }
1288         }
1289     }
1290
1291   if (c->args.socket_filename)
1292     lm->free (c->args.socket_filename);
1293   c->args.socket_filename = NULL;
1294
1295   lm->free (c);
1296   c = NULL;
1297
1298   *conn = c;
1299   return err;
1300 }
1301
1302 int
1303 memif_connect1 (memif_connection_t * c)
1304 {
1305   libmemif_main_t *lm = &libmemif_main;
1306   memif_region_t *mr;
1307   memif_queue_t *mq;
1308   int i;
1309   uint16_t num;
1310
1311   for (i = 0; i < c->regions_num; i++)
1312     {
1313       mr = &c->regions[i];
1314       if (mr != NULL)
1315         {
1316           if (!mr->addr)
1317             {
1318               if (mr->is_external)
1319                 {
1320                   if (lm->get_external_region_addr == NULL)
1321                     return 99;  /* FIXME: propper error report */
1322                   mr->addr =
1323                     lm->get_external_region_addr (mr->region_size, mr->fd,
1324                                                   c->private_ctx);
1325                 }
1326               else
1327                 {
1328                   if (mr->fd < 0)
1329                     return MEMIF_ERR_NO_SHMFD;
1330
1331                   if ((mr->addr =
1332                        mmap (NULL, mr->region_size, PROT_READ | PROT_WRITE,
1333                              MAP_SHARED, mr->fd, 0)) == MAP_FAILED)
1334                     {
1335                       return memif_syscall_error_handler (errno);
1336                     }
1337                 }
1338             }
1339         }
1340     }
1341
1342   for (i = 0; i < c->rx_queues_num; i++)
1343     {
1344       mq = &c->rx_queues[i];
1345       if (mq != NULL)
1346         {
1347           mq->ring = c->regions[mq->region].addr + mq->offset;
1348           if (mq->ring->cookie != MEMIF_COOKIE)
1349             {
1350               DBG ("wrong cookie on rx ring %u", i);
1351               return MEMIF_ERR_COOKIE;
1352             }
1353           mq->ring->head = mq->ring->tail = mq->last_head = mq->alloc_bufs =
1354             0;
1355         }
1356     }
1357
1358   for (i = 0; i < c->tx_queues_num; i++)
1359     {
1360       mq = &c->tx_queues[i];
1361       if (mq != NULL)
1362         {
1363           mq->ring = c->regions[mq->region].addr + mq->offset;
1364           if (mq->ring->cookie != MEMIF_COOKIE)
1365             {
1366               DBG ("wrong cookie on tx ring %u", i);
1367               return MEMIF_ERR_COOKIE;
1368             }
1369           mq->ring->head = mq->ring->tail = mq->last_head = mq->alloc_bufs =
1370             0;
1371         }
1372     }
1373
1374   lm->control_fd_update (c->fd, MEMIF_FD_EVENT_READ | MEMIF_FD_EVENT_MOD);
1375
1376   return 0;
1377 }
1378
1379 static inline int
1380 memif_add_region (libmemif_main_t * lm, memif_connection_t * conn,
1381                   uint8_t has_buffers)
1382 {
1383   memif_region_t *r;
1384
1385   r =
1386     lm->realloc (conn->regions,
1387                  sizeof (memif_region_t) * ++conn->regions_num);
1388   if (r == NULL)
1389     return MEMIF_ERR_NOMEM;
1390
1391   conn->regions = r;
1392   r = &conn->regions[conn->regions_num - 1];
1393   memset (r, 0, sizeof (memif_region_t));
1394
1395   if (has_buffers != 0)
1396     {
1397       r->buffer_offset = 0;
1398     }
1399   else
1400     {
1401       r->buffer_offset =
1402         (conn->run_args.num_s2m_rings +
1403          conn->run_args.num_m2s_rings) * (sizeof (memif_ring_t) +
1404                                           sizeof (memif_desc_t) *
1405                                           (1 << conn->
1406                                            run_args.log2_ring_size));
1407     }
1408
1409   r->region_size = (has_buffers == 0) ? r->buffer_offset : r->buffer_offset +
1410     conn->run_args.buffer_size * (1 << conn->run_args.log2_ring_size) *
1411     (conn->run_args.num_s2m_rings + conn->run_args.num_m2s_rings);
1412
1413   if ((r->fd = memfd_create ("memif region 0", MFD_ALLOW_SEALING)) == -1)
1414     return memif_syscall_error_handler (errno);
1415
1416   if ((fcntl (r->fd, F_ADD_SEALS, F_SEAL_SHRINK)) == -1)
1417     return memif_syscall_error_handler (errno);
1418
1419   if ((ftruncate (r->fd, r->region_size)) == -1)
1420     return memif_syscall_error_handler (errno);
1421
1422   if ((r->addr = mmap (NULL, r->region_size, PROT_READ | PROT_WRITE,
1423                        MAP_SHARED, r->fd, 0)) == MAP_FAILED)
1424     return memif_syscall_error_handler (errno);
1425
1426   return MEMIF_ERR_SUCCESS;
1427 }
1428
1429 static inline int
1430 memif_init_queues (libmemif_main_t * lm, memif_connection_t * conn)
1431 {
1432   int i, j;
1433   memif_ring_t *ring;
1434
1435   for (i = 0; i < conn->run_args.num_s2m_rings; i++)
1436     {
1437       ring = memif_get_ring (conn, MEMIF_RING_S2M, i);
1438       DBG ("RING: %p I: %d", ring, i);
1439       ring->head = ring->tail = 0;
1440       ring->cookie = MEMIF_COOKIE;
1441       ring->flags = 0;
1442       for (j = 0; j < (1 << conn->run_args.log2_ring_size); j++)
1443         {
1444           uint16_t slot = i * (1 << conn->run_args.log2_ring_size) + j;
1445           ring->desc[j].region = 1;
1446           ring->desc[j].offset =
1447             conn->regions[1].buffer_offset +
1448             (uint32_t) (slot * conn->run_args.buffer_size);
1449           ring->desc[j].length = conn->run_args.buffer_size;
1450         }
1451     }
1452   for (i = 0; i < conn->run_args.num_m2s_rings; i++)
1453     {
1454       ring = memif_get_ring (conn, MEMIF_RING_M2S, i);
1455       DBG ("RING: %p I: %d", ring, i);
1456       ring->head = ring->tail = 0;
1457       ring->cookie = MEMIF_COOKIE;
1458       ring->flags = 0;
1459       for (j = 0; j < (1 << conn->run_args.log2_ring_size); j++)
1460         {
1461           uint16_t slot = (i + conn->run_args.num_s2m_rings) *
1462             (1 << conn->run_args.log2_ring_size) + j;
1463           ring->desc[j].region = 1;
1464           ring->desc[j].offset =
1465             conn->regions[1].buffer_offset +
1466             (uint32_t) (slot * conn->run_args.buffer_size);
1467           ring->desc[j].length = conn->run_args.buffer_size;
1468         }
1469     }
1470   memif_queue_t *mq;
1471   DBG ("alloc: %p", lm->alloc);
1472   DBG ("size: %lu", sizeof (memif_queue_t) * conn->run_args.num_s2m_rings);
1473   mq =
1474     (memif_queue_t *) lm->alloc (sizeof (memif_queue_t) *
1475                                  conn->run_args.num_s2m_rings);
1476   if (mq == NULL)
1477     return MEMIF_ERR_NOMEM;
1478
1479   int x;
1480   memif_list_elt_t e;
1481   for (x = 0; x < conn->run_args.num_s2m_rings; x++)
1482     {
1483       if ((mq[x].int_fd = eventfd (0, EFD_NONBLOCK)) < 0)
1484         return memif_syscall_error_handler (errno);
1485       e.key = mq[x].int_fd;
1486       e.data_struct = conn;
1487       add_list_elt (&e, &lm->interrupt_list, &lm->interrupt_list_len);
1488
1489       mq[x].ring = memif_get_ring (conn, MEMIF_RING_S2M, x);
1490       DBG ("RING: %p I: %d", mq[x].ring, x);
1491       mq[x].log2_ring_size = conn->run_args.log2_ring_size;
1492       mq[x].region = 0;
1493       mq[x].offset =
1494         (void *) mq[x].ring - (void *) conn->regions[mq->region].addr;
1495       mq[x].last_head = mq[x].last_tail = 0;
1496       mq[x].alloc_bufs = 0;
1497     }
1498   conn->tx_queues = mq;
1499
1500   mq =
1501     (memif_queue_t *) lm->alloc (sizeof (memif_queue_t) *
1502                                  conn->run_args.num_m2s_rings);
1503   if (mq == NULL)
1504     return MEMIF_ERR_NOMEM;
1505
1506   for (x = 0; x < conn->run_args.num_m2s_rings; x++)
1507     {
1508       if ((mq[x].int_fd = eventfd (0, EFD_NONBLOCK)) < 0)
1509         return memif_syscall_error_handler (errno);
1510       e.key = mq[x].int_fd;
1511       e.data_struct = conn;
1512       add_list_elt (&e, &lm->interrupt_list, &lm->interrupt_list_len);
1513
1514       mq[x].ring = memif_get_ring (conn, MEMIF_RING_M2S, x);
1515       DBG ("RING: %p I: %d", mq[x].ring, x);
1516       mq[x].log2_ring_size = conn->run_args.log2_ring_size;
1517       mq[x].region = 0;
1518       mq[x].offset =
1519         (void *) mq[x].ring - (void *) conn->regions[mq->region].addr;
1520       mq[x].last_head = mq[x].last_tail = 0;
1521       mq[x].alloc_bufs = 0;
1522     }
1523   conn->rx_queues = mq;
1524
1525   return MEMIF_ERR_SUCCESS;
1526 }
1527
1528 int
1529 memif_init_regions_and_queues (memif_connection_t * conn)
1530 {
1531   memif_ring_t *ring = NULL;
1532   memif_region_t *r;
1533   int i, j;
1534   libmemif_main_t *lm = &libmemif_main;
1535   memif_list_elt_t e;
1536
1537   /* region 0. rings */
1538   memif_add_region (lm, conn, /* has_buffers */ 0);
1539
1540   /* region 1. buffers */
1541   if (lm->add_external_region)
1542     {
1543       r =
1544         (memif_region_t *) lm->realloc (conn->regions,
1545                                         sizeof (memif_region_t) *
1546                                         ++conn->regions_num);
1547       if (r == NULL)
1548         return MEMIF_ERR_NOMEM;
1549       conn->regions = r;
1550
1551       conn->regions[1].region_size =
1552         conn->run_args.buffer_size * (1 << conn->run_args.log2_ring_size) *
1553         (conn->run_args.num_s2m_rings + conn->run_args.num_m2s_rings);
1554       conn->regions[1].buffer_offset = 0;
1555       lm->add_external_region (&conn->regions[1].addr,
1556                                conn->regions[1].region_size,
1557                                &conn->regions[1].fd, conn->private_ctx);
1558       conn->regions[1].is_external = 1;
1559     }
1560   else
1561     {
1562       memif_add_region (lm, conn, 1);
1563     }
1564
1565   memif_init_queues (lm, conn);
1566
1567   return 0;
1568 }
1569
1570 int
1571 memif_buffer_enq_tx (memif_conn_handle_t conn, uint16_t qid,
1572                      memif_buffer_t * bufs, uint16_t count,
1573                      uint16_t * count_out)
1574 {
1575   memif_connection_t *c = (memif_connection_t *) conn;
1576   if (EXPECT_FALSE (c == NULL))
1577     return MEMIF_ERR_NOCONN;
1578   if (EXPECT_FALSE (c->fd < 0))
1579     return MEMIF_ERR_DISCONNECTED;
1580   uint8_t num =
1581     (c->args.is_master) ? c->run_args.num_m2s_rings : c->
1582     run_args.num_s2m_rings;
1583   if (EXPECT_FALSE (qid >= num))
1584     return MEMIF_ERR_QID;
1585   if (EXPECT_FALSE (!count_out))
1586     return MEMIF_ERR_INVAL_ARG;
1587   if (EXPECT_FALSE (c->args.is_master))
1588     return MEMIF_ERR_INVAL_ARG;
1589
1590   memif_queue_t *mq = &c->tx_queues[qid];
1591   memif_ring_t *ring = mq->ring;
1592   memif_buffer_t *b0;
1593   uint16_t mask = (1 << mq->log2_ring_size) - 1;
1594   uint16_t ring_size;
1595   uint16_t slot, ns;
1596   int i, err = MEMIF_ERR_SUCCESS;       /* 0 */
1597   *count_out = 0;
1598
1599   ring_size = (1 << mq->log2_ring_size);
1600   slot = (c->args.is_master) ? ring->tail : ring->head;
1601   slot += mq->alloc_bufs;
1602
1603   /* can only be called by slave */
1604   ns = ring_size - (ring->head + mq->alloc_bufs) + ring->tail;
1605
1606   b0 = bufs;
1607
1608   while (count && ns)
1609     {
1610       if (EXPECT_FALSE ((b0->flags & MEMIF_BUFFER_FLAG_RX) == 0))
1611         {
1612           /* not a valid buffer */
1613           count--;
1614           continue;
1615         }
1616       b0->flags &= ~MEMIF_BUFFER_FLAG_RX;
1617
1618       ((memif_ring_t *) b0->ring)->desc[b0->desc_index & mask].offset = ring->desc[slot & mask].offset; /* put free buffer on rx ring */
1619
1620       ring->desc[slot & mask].offset =
1621         (uint32_t) (b0->data -
1622                     c->regions[ring->desc[slot & mask].region].addr);
1623       ring->desc[slot & mask].flags |=
1624         (b0->flags & MEMIF_BUFFER_FLAG_NEXT) ? MEMIF_DESC_FLAG_NEXT : 0;
1625
1626       b0->desc_index = slot;
1627
1628       mq->alloc_bufs++;
1629       slot++;
1630
1631       count--;
1632       ns--;
1633       b0++;
1634       *count_out += 1;
1635     }
1636
1637   DBG ("allocated: %u/%u bufs. Total %u allocated bufs", *count_out, count,
1638        mq->alloc_bufs);
1639
1640   if (count)
1641     {
1642       DBG ("ring buffer full! qid: %u", qid);
1643       err = MEMIF_ERR_NOBUF_RING;
1644     }
1645
1646 error:
1647   return err;
1648 }
1649
1650 int
1651 memif_buffer_alloc (memif_conn_handle_t conn, uint16_t qid,
1652                     memif_buffer_t * bufs, uint16_t count,
1653                     uint16_t * count_out, uint16_t size)
1654 {
1655   memif_connection_t *c = (memif_connection_t *) conn;
1656   if (EXPECT_FALSE (c == NULL))
1657     return MEMIF_ERR_NOCONN;
1658   if (EXPECT_FALSE (c->fd < 0))
1659     return MEMIF_ERR_DISCONNECTED;
1660   uint8_t num =
1661     (c->args.is_master) ? c->run_args.num_m2s_rings : c->
1662     run_args.num_s2m_rings;
1663   if (EXPECT_FALSE (qid >= num))
1664     return MEMIF_ERR_QID;
1665   if (EXPECT_FALSE (!count_out))
1666     return MEMIF_ERR_INVAL_ARG;
1667
1668   libmemif_main_t *lm = &libmemif_main;
1669   memif_queue_t *mq = &c->tx_queues[qid];
1670   memif_ring_t *ring = mq->ring;
1671   memif_buffer_t *b0, *b1;
1672   uint16_t mask = (1 << mq->log2_ring_size) - 1;
1673   uint32_t offset_mask = c->run_args.buffer_size - 1;
1674   uint16_t ring_size;
1675   uint16_t slot, ns;
1676   int i, err = MEMIF_ERR_SUCCESS;       /* 0 */
1677   uint16_t dst_left, src_left;
1678   uint16_t saved_count;
1679   memif_buffer_t *saved_b;
1680   *count_out = 0;
1681
1682   ring_size = (1 << mq->log2_ring_size);
1683   slot = (c->args.is_master) ? ring->tail : ring->head;
1684   slot += mq->alloc_bufs;
1685
1686   if (c->args.is_master)
1687     ns = ring->head - (ring->tail + mq->alloc_bufs);
1688   else
1689     ns = ring_size - (ring->head + mq->alloc_bufs) + ring->tail;
1690
1691   while (count && ns)
1692     {
1693       b0 = (bufs + *count_out);
1694
1695       saved_b = b0;
1696       saved_count = count;
1697
1698       b0->desc_index = slot;
1699       ring->desc[slot & mask].flags = 0;
1700
1701       /* slave can produce buffer with original length */
1702       dst_left = (c->args.is_master) ? ring->desc[slot & mask].length :
1703         c->run_args.buffer_size;
1704       src_left = size;
1705
1706       while (src_left)
1707         {
1708           if (EXPECT_FALSE (dst_left == 0))
1709             {
1710               if (count && ns)
1711                 {
1712                   slot++;
1713                   *count_out += 1;
1714                   mq->alloc_bufs++;
1715                   ns--;
1716
1717                   ring->desc[b0->desc_index & mask].flags |=
1718                     MEMIF_DESC_FLAG_NEXT;
1719                   b0->flags |= MEMIF_BUFFER_FLAG_NEXT;
1720
1721                   b0 = (bufs + *count_out);
1722                   b0->desc_index = slot;
1723                   dst_left =
1724                     (c->args.is_master) ? ring->desc[slot & mask].
1725                     length : c->run_args.buffer_size;
1726                   ring->desc[slot & mask].flags = 0;
1727                 }
1728               else
1729                 {
1730                   /* rollback allocated chain buffers */
1731                   memset (saved_b, 0, sizeof (memif_buffer_t)
1732                           * (saved_count - count + 1));
1733                   *count_out -= saved_count - count;
1734                   mq->alloc_bufs = saved_count - count;
1735                   goto no_ns;
1736                 }
1737             }
1738           b0->len = memif_min (dst_left, src_left);
1739
1740           /* slave resets buffer offset */
1741           if (c->args.is_master == 0)
1742             {
1743               memif_desc_t *d = &ring->desc[slot & mask];
1744               if (lm->get_external_buffer_offset)
1745                 d->offset = lm->get_external_buffer_offset (c->private_ctx);
1746               else
1747                 d->offset = d->offset - (d->offset & offset_mask);
1748             }
1749           b0->data = memif_get_buffer (c, ring, slot & mask);
1750
1751           src_left -= b0->len;
1752           dst_left -= b0->len;
1753         }
1754
1755       slot++;
1756       *count_out += 1;
1757       mq->alloc_bufs++;
1758       ns--;
1759       count--;
1760     }
1761
1762 no_ns:
1763
1764   DBG ("allocated: %u/%u bufs. Total %u allocated bufs", *count_out, count,
1765        mq->alloc_bufs);
1766
1767   if (count)
1768     {
1769       DBG ("ring buffer full! qid: %u", qid);
1770       err = MEMIF_ERR_NOBUF_RING;
1771     }
1772
1773 error:
1774   return err;
1775 }
1776
1777 int
1778 memif_refill_queue (memif_conn_handle_t conn, uint16_t qid, uint16_t count,
1779                     uint16_t headroom)
1780 {
1781   memif_connection_t *c = (memif_connection_t *) conn;
1782   if (EXPECT_FALSE (c == NULL))
1783     return MEMIF_ERR_NOCONN;
1784   if (EXPECT_FALSE (c->fd < 0))
1785     return MEMIF_ERR_DISCONNECTED;
1786   uint8_t num =
1787     (c->args.is_master) ? c->run_args.num_s2m_rings : c->
1788     run_args.num_m2s_rings;
1789   if (EXPECT_FALSE (qid >= num))
1790     return MEMIF_ERR_QID;
1791   libmemif_main_t *lm = &libmemif_main;
1792   memif_queue_t *mq = &c->rx_queues[qid];
1793   memif_ring_t *ring = mq->ring;
1794   uint16_t mask = (1 << mq->log2_ring_size) - 1;
1795   uint32_t offset_mask = c->run_args.buffer_size - 1;
1796   uint16_t slot;
1797
1798   if (c->args.is_master)
1799     {
1800       MEMIF_MEMORY_BARRIER ();
1801       ring->tail =
1802         (ring->tail + count <=
1803          mq->last_head) ? ring->tail + count : mq->last_head;
1804       return MEMIF_ERR_SUCCESS;
1805     }
1806
1807   uint16_t head = ring->head;
1808   uint16_t ns = (1 << mq->log2_ring_size) - head + mq->last_tail;
1809   head += (count < ns) ? count : ns;
1810
1811   slot = ring->head;
1812   memif_desc_t *d;
1813   while (slot < head)
1814     {
1815       d = &ring->desc[slot & mask];
1816       d->region = 1;
1817       d->length = c->run_args.buffer_size - headroom;
1818       if (lm->get_external_buffer_offset)
1819         d->offset = lm->get_external_buffer_offset (c->private_ctx);
1820       else
1821         d->offset = d->offset - (d->offset & offset_mask) + headroom;
1822       slot++;
1823     }
1824
1825   MEMIF_MEMORY_BARRIER ();
1826   ring->head = head;
1827
1828   return MEMIF_ERR_SUCCESS;     /* 0 */
1829 }
1830
1831 int
1832 memif_tx_burst (memif_conn_handle_t conn, uint16_t qid,
1833                 memif_buffer_t * bufs, uint16_t count, uint16_t * tx)
1834 {
1835   memif_connection_t *c = (memif_connection_t *) conn;
1836   if (EXPECT_FALSE (c == NULL))
1837     return MEMIF_ERR_NOCONN;
1838   if (EXPECT_FALSE (c->fd < 0))
1839     return MEMIF_ERR_DISCONNECTED;
1840   uint8_t num =
1841     (c->args.is_master) ? c->run_args.num_m2s_rings : c->
1842     run_args.num_s2m_rings;
1843   if (EXPECT_FALSE (qid >= num))
1844     return MEMIF_ERR_QID;
1845   if (EXPECT_FALSE (!tx))
1846     return MEMIF_ERR_INVAL_ARG;
1847
1848   memif_queue_t *mq = &c->tx_queues[qid];
1849   memif_ring_t *ring = mq->ring;
1850   uint16_t mask = (1 << mq->log2_ring_size) - 1;
1851   memif_buffer_t *b0;
1852   *tx = 0;
1853
1854   if (count > mq->alloc_bufs)
1855     count = mq->alloc_bufs;
1856
1857   if (EXPECT_FALSE (count == 0))
1858     return MEMIF_ERR_SUCCESS;
1859
1860   while (count)
1861     {
1862       b0 = (bufs + *tx);
1863       ring->desc[b0->desc_index & mask].length = b0->len;
1864
1865 #ifdef MEMIF_DBG_SHM
1866       printf ("offset: %-6d\n", ring->desc[b0->desc_index & mask].offset);
1867       printf ("data: %p\n",
1868               memif_get_buffer (c, ring, b0->desc_index & mask));
1869       printf ("index: %u\n", b0->desc_index);
1870       print_bytes (memif_get_buffer (c, ring, b0->desc_index & mask),
1871                    ring->desc[b0->desc_index & mask].length, DBG_TX_BUF);
1872 #endif /* MEMIF_DBG_SHM */
1873
1874       *tx += 1;
1875       count--;
1876     }
1877
1878
1879   MEMIF_MEMORY_BARRIER ();
1880   if (c->args.is_master)
1881     ring->tail = b0->desc_index + 1;
1882   else
1883     ring->head = b0->desc_index + 1;
1884
1885   mq->alloc_bufs -= *tx;
1886
1887   if ((ring->flags & MEMIF_RING_FLAG_MASK_INT) == 0)
1888     {
1889       uint64_t a = 1;
1890       int r = write (mq->int_fd, &a, sizeof (a));
1891       if (r < 0)
1892         return MEMIF_ERR_INT_WRITE;
1893     }
1894
1895   return MEMIF_ERR_SUCCESS;     /* 0 */
1896 }
1897
1898 int
1899 memif_rx_burst (memif_conn_handle_t conn, uint16_t qid,
1900                 memif_buffer_t * bufs, uint16_t count, uint16_t * rx)
1901 {
1902   memif_connection_t *c = (memif_connection_t *) conn;
1903   if (EXPECT_FALSE (c == NULL))
1904     return MEMIF_ERR_NOCONN;
1905   if (EXPECT_FALSE (c->fd < 0))
1906     return MEMIF_ERR_DISCONNECTED;
1907   uint8_t num =
1908     (c->args.is_master) ? c->run_args.num_s2m_rings : c->
1909     run_args.num_m2s_rings;
1910   if (EXPECT_FALSE (qid >= num))
1911     return MEMIF_ERR_QID;
1912   if (EXPECT_FALSE (!rx))
1913     return MEMIF_ERR_INVAL_ARG;
1914
1915   memif_queue_t *mq = &c->rx_queues[qid];
1916   memif_ring_t *ring = mq->ring;
1917   uint16_t cur_slot, last_slot;
1918   uint16_t ns;
1919   uint16_t mask = (1 << mq->log2_ring_size) - 1;
1920   memif_buffer_t *b0, *b1;
1921   *rx = 0;
1922
1923   uint64_t b;
1924   ssize_t r = read (mq->int_fd, &b, sizeof (b));
1925   if (EXPECT_FALSE ((r == -1) && (errno != EAGAIN)))
1926     return memif_syscall_error_handler (errno);
1927
1928   cur_slot = (c->args.is_master) ? mq->last_head : mq->last_tail;
1929   last_slot = (c->args.is_master) ? ring->head : ring->tail;
1930   if (cur_slot == last_slot)
1931     return MEMIF_ERR_SUCCESS;
1932
1933   ns = last_slot - cur_slot;
1934
1935   while (ns && count)
1936     {
1937       b0 = (bufs + *rx);
1938
1939       b0->desc_index = cur_slot;
1940       b0->data = memif_get_buffer (c, ring, cur_slot & mask);
1941       b0->len = ring->desc[cur_slot & mask].length;
1942       /* slave resets buffer length */
1943       if (c->args.is_master == 0)
1944         {
1945           ring->desc[cur_slot & mask].length = c->run_args.buffer_size;
1946         }
1947
1948       b0->flags = MEMIF_BUFFER_FLAG_RX;
1949       if (ring->desc[cur_slot & mask].flags & MEMIF_DESC_FLAG_NEXT)
1950         {
1951           b0->flags |= MEMIF_BUFFER_FLAG_NEXT;
1952           ring->desc[cur_slot & mask].flags &= ~MEMIF_DESC_FLAG_NEXT;
1953         }
1954 /*      b0->offset = ring->desc[cur_slot & mask].offset;*/
1955       b0->ring = ring;
1956 #ifdef MEMIF_DBG_SHM
1957       printf ("data: %p\n", b0->data);
1958       printf ("index: %u\n", b0->desc_index);
1959       printf ("ring: %p\n", b0->ring);
1960       print_bytes (b0->data, b0->len, DBG_RX_BUF);
1961 #endif /* MEMIF_DBG_SHM */
1962       ns--;
1963       *rx += 1;
1964
1965       count--;
1966       cur_slot++;
1967     }
1968
1969   if (c->args.is_master)
1970     mq->last_head = cur_slot;
1971   else
1972     mq->last_tail = cur_slot;
1973
1974   if (ns)
1975     {
1976       DBG ("not enough buffers!");
1977       return MEMIF_ERR_NOBUF;
1978     }
1979
1980   return MEMIF_ERR_SUCCESS;     /* 0 */
1981 }
1982
1983 int
1984 memif_get_details (memif_conn_handle_t conn, memif_details_t * md,
1985                    char *buf, ssize_t buflen)
1986 {
1987   libmemif_main_t *lm = &libmemif_main;
1988   memif_connection_t *c = (memif_connection_t *) conn;
1989   if (c == NULL)
1990     return MEMIF_ERR_NOCONN;
1991
1992   int err = MEMIF_ERR_SUCCESS, i;
1993   ssize_t l0, l1, total_l;
1994   l0 = 0;
1995
1996   l1 = strlen ((char *) c->args.interface_name);
1997   if (l0 + l1 < buflen)
1998     {
1999       md->if_name =
2000         (uint8_t *) strcpy (buf + l0, (char *) c->args.interface_name);
2001       l0 += l1 + 1;
2002     }
2003   else
2004     err = MEMIF_ERR_NOBUF_DET;
2005
2006   l1 = strlen ((char *) lm->app_name);
2007   if (l0 + l1 < buflen)
2008     {
2009       md->inst_name = (uint8_t *) strcpy (buf + l0, (char *) lm->app_name);
2010       l0 += l1 + 1;
2011     }
2012   else
2013     err = MEMIF_ERR_NOBUF_DET;
2014
2015   l1 = strlen ((char *) c->remote_if_name);
2016   if (l0 + l1 < buflen)
2017     {
2018       md->remote_if_name =
2019         (uint8_t *) strcpy (buf + l0, (char *) c->remote_if_name);
2020       l0 += l1 + 1;
2021     }
2022   else
2023     err = MEMIF_ERR_NOBUF_DET;
2024
2025   l1 = strlen ((char *) c->remote_name);
2026   if (l0 + l1 < buflen)
2027     {
2028       md->remote_inst_name =
2029         (uint8_t *) strcpy (buf + l0, (char *) c->remote_name);
2030       l0 += l1 + 1;
2031     }
2032   else
2033     err = MEMIF_ERR_NOBUF_DET;
2034
2035   md->id = c->args.interface_id;
2036
2037   if (strlen ((char *) c->args.secret) > 0)
2038     {
2039       l1 = strlen ((char *) c->args.secret);
2040       if (l0 + l1 < buflen)
2041         {
2042           md->secret = (uint8_t *) strcpy (buf + l0, (char *) c->args.secret);
2043           l0 += l1 + 1;
2044         }
2045       else
2046         err = MEMIF_ERR_NOBUF_DET;
2047     }
2048
2049   md->role = (c->args.is_master) ? 0 : 1;
2050   md->mode = c->args.mode;
2051
2052   l1 = strlen ((char *) c->args.socket_filename);
2053   if (l0 + l1 < buflen)
2054     {
2055       md->socket_filename =
2056         (uint8_t *) strcpy (buf + l0, (char *) c->args.socket_filename);
2057       l0 += l1 + 1;
2058     }
2059   else
2060     err = MEMIF_ERR_NOBUF_DET;
2061
2062   l1 = strlen ((char *) c->remote_disconnect_string);
2063   if (l0 + l1 < buflen)
2064     {
2065       md->error =
2066         (uint8_t *) strcpy (buf + l0, (char *) c->remote_disconnect_string);
2067       l0 += l1 + 1;
2068     }
2069   else
2070     err = MEMIF_ERR_NOBUF_DET;
2071
2072   md->regions_num = c->regions_num;
2073   l1 = sizeof (memif_region_details_t) * md->regions_num;
2074   if (l0 + l1 <= buflen)
2075     {
2076       md->regions = (memif_region_details_t *) buf + l0;
2077       l0 += l1;
2078     }
2079   else
2080     err = MEMIF_ERR_NOBUF_DET;
2081
2082   for (i = 0; i < md->regions_num; i++)
2083     {
2084       md->regions[i].index = i;
2085       md->regions[i].addr = c->regions[i].addr;
2086       md->regions[i].size = c->regions[i].region_size;
2087       md->regions[i].fd = c->regions[i].fd;
2088       md->regions[i].is_external = c->regions[i].is_external;
2089     }
2090
2091   md->rx_queues_num =
2092     (c->args.is_master) ? c->run_args.num_s2m_rings : c->
2093     run_args.num_m2s_rings;
2094
2095   l1 = sizeof (memif_queue_details_t) * md->rx_queues_num;
2096   if (l0 + l1 <= buflen)
2097     {
2098       md->rx_queues = (memif_queue_details_t *) buf + l0;
2099       l0 += l1;
2100     }
2101   else
2102     err = MEMIF_ERR_NOBUF_DET;
2103
2104   for (i = 0; i < md->rx_queues_num; i++)
2105     {
2106       md->rx_queues[i].region = c->rx_queues[i].region;
2107       md->rx_queues[i].qid = i;
2108       md->rx_queues[i].ring_size = (1 << c->rx_queues[i].log2_ring_size);
2109       md->rx_queues[i].flags = c->rx_queues[i].ring->flags;
2110       md->rx_queues[i].head = c->rx_queues[i].ring->head;
2111       md->rx_queues[i].tail = c->rx_queues[i].ring->tail;
2112       md->rx_queues[i].buffer_size = c->run_args.buffer_size;
2113     }
2114
2115   md->tx_queues_num =
2116     (c->args.is_master) ? c->run_args.num_m2s_rings : c->
2117     run_args.num_s2m_rings;
2118
2119   l1 = sizeof (memif_queue_details_t) * md->tx_queues_num;
2120   if (l0 + l1 <= buflen)
2121     {
2122       md->tx_queues = (memif_queue_details_t *) buf + l0;
2123       l0 += l1;
2124     }
2125   else
2126     err = MEMIF_ERR_NOBUF_DET;
2127
2128   for (i = 0; i < md->tx_queues_num; i++)
2129     {
2130       md->tx_queues[i].region = c->tx_queues[i].region;
2131       md->tx_queues[i].qid = i;
2132       md->tx_queues[i].ring_size = (1 << c->tx_queues[i].log2_ring_size);
2133       md->tx_queues[i].flags = c->tx_queues[i].ring->flags;
2134       md->tx_queues[i].head = c->tx_queues[i].ring->head;
2135       md->tx_queues[i].tail = c->tx_queues[i].ring->tail;
2136       md->tx_queues[i].buffer_size = c->run_args.buffer_size;
2137     }
2138
2139   md->link_up_down = (c->fd > 0) ? 1 : 0;
2140
2141   return err;                   /* 0 */
2142 }
2143
2144 int
2145 memif_get_queue_efd (memif_conn_handle_t conn, uint16_t qid, int *efd)
2146 {
2147   memif_connection_t *c = (memif_connection_t *) conn;
2148   *efd = -1;
2149   if (c == NULL)
2150     return MEMIF_ERR_NOCONN;
2151   if (c->fd < 0)
2152     return MEMIF_ERR_DISCONNECTED;
2153   uint8_t num =
2154     (c->args.is_master) ? c->run_args.num_s2m_rings : c->
2155     run_args.num_m2s_rings;
2156   if (qid >= num)
2157     return MEMIF_ERR_QID;
2158
2159   *efd = c->rx_queues[qid].int_fd;
2160
2161   return MEMIF_ERR_SUCCESS;
2162 }
2163
2164 int
2165 memif_cleanup ()
2166 {
2167   libmemif_main_t *lm = &libmemif_main;
2168   if (lm->control_list)
2169     lm->free (lm->control_list);
2170   lm->control_list = NULL;
2171   if (lm->interrupt_list)
2172     lm->free (lm->interrupt_list);
2173   lm->interrupt_list = NULL;
2174   if (lm->listener_list)
2175     lm->free (lm->listener_list);
2176   lm->listener_list = NULL;
2177   if (lm->pending_list)
2178     lm->free (lm->pending_list);
2179   lm->pending_list = NULL;
2180   if (poll_cancel_fd != -1)
2181     close (poll_cancel_fd);
2182
2183   return MEMIF_ERR_SUCCESS;     /* 0 */
2184 }