src/plugins/memif/memif.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
  19 #define _GNU_SOURCE
  20 #include <stdint.h>
  21 #include <net/if.h>
  22 #include <sys/types.h>
  23 #include <fcntl.h>
  24 #include <sys/ioctl.h>
  25 #include <sys/socket.h>
  26 #include <sys/un.h>
  27 #include <sys/uio.h>
  28 #include <sys/mman.h>
  29 #include <sys/prctl.h>
  30 #include <sys/eventfd.h>
  31 #include <inttypes.h>
  32 #include <limits.h>
  33
  34 #include <vlib/vlib.h>
  35 #include <vlib/unix/unix.h>
  36 #include <vppinfra/linux/syscall.h>
  37 #include <vnet/plugin/plugin.h>
  38 #include <vnet/ethernet/ethernet.h>
  39 #include <vpp/app/version.h>
  40 #include <memif/memif.h>
  41 #include <memif/private.h>
  42
  43 memif_main_t memif_main;
  44
  45 static u32
  46 memif_eth_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hi, u32 flags)
  47 {
  48   /* nothing for now */
  49   return 0;
  50 }
  51
  52 static void
  53 memif_queue_intfd_close (memif_queue_t * mq)
  54 {
  55   if (mq->int_clib_file_index != ~0)
  56     {
  57       memif_file_del_by_index (mq->int_clib_file_index);
  58       mq->int_clib_file_index = ~0;
  59       mq->int_fd = -1;
  60     }
  61   else if (mq->int_fd > -1)
  62     {
  63       close (mq->int_fd);
  64       mq->int_fd = -1;
  65     }
  66 }
  67
  68 void
  69 memif_disconnect (memif_if_t * mif, clib_error_t * err)
  70 {
  71   memif_main_t *mm = &memif_main;
  72   vnet_main_t *vnm = vnet_get_main ();
  73   memif_region_t *mr;
  74   memif_queue_t *mq;
  75   int i;
  76
  77   if (mif == 0)
  78     return;
  79
  80   DBG ("disconnect %u (%v)", mif->dev_instance, err ? err->what : 0);
  81
  82   if (err)
  83     {
  84       clib_error_t *e = 0;
  85       mif->local_disc_string = vec_dup (err->what);
  86       if (mif->sock && clib_socket_is_connected (mif->sock))
  87         e = memif_msg_send_disconnect (mif, err);
  88       clib_error_free (e);
  89     }
  90
  91   /* set interface down */
  92   mif->flags &= ~(MEMIF_IF_FLAG_CONNECTED | MEMIF_IF_FLAG_CONNECTING);
  93   if (mif->hw_if_index != ~0)
  94     vnet_hw_interface_set_flags (vnm, mif->hw_if_index, 0);
  95
  96   /* close connection socket */
  97   if (mif->sock && mif->sock->fd)
  98     {
  99       memif_socket_file_t *msf = vec_elt_at_index (mm->socket_files,
 100                                                    mif->socket_file_index);
 101       hash_unset (msf->dev_instance_by_fd, mif->sock->fd);
 102       memif_socket_close (&mif->sock);
 103     }
 104   else if (mif->sock)
 105     {
 106       clib_error_t *err;
 107       err = clib_socket_close (mif->sock);
 108       if (err)
 109         clib_error_report (err);
 110       clib_mem_free (mif->sock);
 111     }
 112
 113   /* *INDENT-OFF* */
 114   vec_foreach_index (i, mif->rx_queues)
 115     {
 116       mq = vec_elt_at_index (mif->rx_queues, i);
 117       if (mq->ring)
 118         {
 119           int rv;
 120           rv = vnet_hw_interface_unassign_rx_thread (vnm, mif->hw_if_index, i);
 121           if (rv)
 122             DBG ("Warning: unable to unassign interface %d, "
 123                  "queue %d: rc=%d", mif->hw_if_index, i, rv);
 124           mq->ring = 0;
 125         }
 126     }
 127
 128   /* free tx and rx queues */
 129   vec_foreach (mq, mif->rx_queues)
 130     memif_queue_intfd_close (mq);
 131   vec_free (mif->rx_queues);
 132
 133   vec_foreach (mq, mif->tx_queues)
 134     memif_queue_intfd_close (mq);
 135   vec_free (mif->tx_queues);
 136
 137   /* free memory regions */
 138   vec_foreach (mr, mif->regions)
 139     {
 140       int rv;
 141       if (mr->is_external)
 142         continue;
 143       if ((rv = munmap (mr->shm, mr->region_size)))
 144         clib_warning ("munmap failed, rv = %d", rv);
 145       if (mr->fd > -1)
 146         close (mr->fd);
 147     }
 148   /* *INDENT-ON* */
 149   vec_free (mif->regions);
 150   vec_free (mif->remote_name);
 151   vec_free (mif->remote_if_name);
 152   clib_fifo_free (mif->msg_queue);
 153 }
 154
 155 static clib_error_t *
 156 memif_int_fd_read_ready (clib_file_t * uf)
 157 {
 158   memif_main_t *mm = &memif_main;
 159   vnet_main_t *vnm = vnet_get_main ();
 160   u16 qid = uf->private_data & 0xFFFF;
 161   memif_if_t *mif = vec_elt_at_index (mm->interfaces, uf->private_data >> 16);
 162   memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, qid);
 163   u64 b;
 164   ssize_t size;
 165
 166   size = read (uf->file_descriptor, &b, sizeof (b));
 167   if (size < 0)
 168     {
 169       DBG_UNIX_LOG ("Failed to read from socket");
 170       return 0;
 171     }
 172
 173   vnet_device_input_set_interrupt_pending (vnm, mif->hw_if_index, qid);
 174   mq->int_count++;
 175
 176   return 0;
 177 }
 178
 179
 180 clib_error_t *
 181 memif_connect (memif_if_t * mif)
 182 {
 183   vnet_main_t *vnm = vnet_get_main ();
 184   clib_file_t template = { 0 };
 185   memif_region_t *mr;
 186   int i;
 187
 188   DBG ("connect %u", mif->dev_instance);
 189
 190   vec_free (mif->local_disc_string);
 191   vec_free (mif->remote_disc_string);
 192
 193   /* *INDENT-OFF* */
 194   vec_foreach (mr, mif->regions)
 195     {
 196       if (mr->shm)
 197         continue;
 198
 199       if (mr->fd < 0)
 200         clib_error_return (0, "no memory region fd");
 201
 202       if ((mr->shm = mmap (NULL, mr->region_size, PROT_READ | PROT_WRITE,
 203                            MAP_SHARED, mr->fd, 0)) == MAP_FAILED)
 204         return clib_error_return_unix (0, "mmap");
 205     }
 206   /* *INDENT-ON* */
 207
 208   template.read_function = memif_int_fd_read_ready;
 209
 210   /* *INDENT-OFF* */
 211   vec_foreach_index (i, mif->tx_queues)
 212     {
 213       memif_queue_t *mq = vec_elt_at_index (mif->tx_queues, i);
 214
 215       mq->ring = mif->regions[mq->region].shm + mq->offset;
 216       if (mq->ring->cookie != MEMIF_COOKIE)
 217         return clib_error_return (0, "wrong cookie on tx ring %u", i);
 218     }
 219
 220   vec_foreach_index (i, mif->rx_queues)
 221     {
 222       memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, i);
 223       int rv;
 224
 225       mq->ring = mif->regions[mq->region].shm + mq->offset;
 226       if (mq->ring->cookie != MEMIF_COOKIE)
 227         return clib_error_return (0, "wrong cookie on tx ring %u", i);
 228
 229       if (mq->int_fd > -1)
 230         {
 231           template.file_descriptor = mq->int_fd;
 232           template.private_data = (mif->dev_instance << 16) | (i & 0xFFFF);
 233           template.description = format (0, "%U rx %u int",
 234                                          format_memif_device_name,
 235                                          mif->dev_instance, i);
 236           memif_file_add (&mq->int_clib_file_index, &template);
 237         }
 238       vnet_hw_interface_assign_rx_thread (vnm, mif->hw_if_index, i, ~0);
 239       rv = vnet_hw_interface_set_rx_mode (vnm, mif->hw_if_index, i,
 240                                           VNET_HW_INTERFACE_RX_MODE_DEFAULT);
 241       if (rv)
 242         clib_warning
 243           ("Warning: unable to set rx mode for interface %d queue %d: "
 244            "rc=%d", mif->hw_if_index, i, rv);
 245       else
 246         {
 247           vnet_hw_interface_rx_mode rxmode;
 248           vnet_hw_interface_get_rx_mode (vnm, mif->hw_if_index, i, &rxmode);
 249
 250           if (rxmode == VNET_HW_INTERFACE_RX_MODE_POLLING)
 251             mq->ring->flags |= MEMIF_RING_FLAG_MASK_INT;
 252           else
 253             vnet_device_input_set_interrupt_pending (vnm, mif->hw_if_index, i);
 254         }
 255     }
 256   /* *INDENT-ON* */
 257
 258   mif->flags &= ~MEMIF_IF_FLAG_CONNECTING;
 259   mif->flags |= MEMIF_IF_FLAG_CONNECTED;
 260
 261   vnet_hw_interface_set_flags (vnm, mif->hw_if_index,
 262                                VNET_HW_INTERFACE_FLAG_LINK_UP);
 263   return 0;
 264 }
 265
 266 static_always_inline memif_ring_t *
 267 memif_get_ring (memif_if_t * mif, memif_ring_type_t type, u16 ring_num)
 268 {
 269   if (vec_len (mif->regions) == 0)
 270     return NULL;
 271   void *p = mif->regions[0].shm;
 272   int ring_size =
 273     sizeof (memif_ring_t) +
 274     sizeof (memif_desc_t) * (1 << mif->run.log2_ring_size);
 275   p += (ring_num + type * mif->run.num_s2m_rings) * ring_size;
 276
 277   return (memif_ring_t *) p;
 278 }
 279
 280 clib_error_t *
 281 memif_init_regions_and_queues (memif_if_t * mif)
 282 {
 283   vlib_main_t *vm = vlib_get_main ();
 284   memif_ring_t *ring = NULL;
 285   int i, j;
 286   u64 buffer_offset;
 287   memif_region_t *r;
 288   clib_mem_vm_alloc_t alloc = { 0 };
 289   clib_error_t *err;
 290
 291   ASSERT (vec_len (mif->regions) == 0);
 292   vec_add2_aligned (mif->regions, r, 1, CLIB_CACHE_LINE_BYTES);
 293
 294   buffer_offset = (mif->run.num_s2m_rings + mif->run.num_m2s_rings) *
 295     (sizeof (memif_ring_t) +
 296      sizeof (memif_desc_t) * (1 << mif->run.log2_ring_size));
 297
 298   r->region_size = buffer_offset;
 299
 300   if ((mif->flags & MEMIF_IF_FLAG_ZERO_COPY) == 0)
 301     r->region_size += mif->run.buffer_size * (1 << mif->run.log2_ring_size) *
 302       (mif->run.num_s2m_rings + mif->run.num_m2s_rings);
 303
 304   alloc.name = "memif region";
 305   alloc.size = r->region_size;
 306   alloc.flags = CLIB_MEM_VM_F_SHARED;
 307
 308   err = clib_mem_vm_ext_alloc (&alloc);
 309   if (err)
 310     return err;
 311
 312   r->fd = alloc.fd;
 313   r->shm = alloc.addr;
 314
 315   if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY)
 316     {
 317       vlib_buffer_pool_t *bp;
 318       /* *INDENT-OFF* */
 319       vec_foreach (bp, buffer_main.buffer_pools)
 320         {
 321           vlib_physmem_region_t *pr;
 322           pr = vlib_physmem_get_region (vm, bp->physmem_region);
 323           vec_add2_aligned (mif->regions, r, 1, CLIB_CACHE_LINE_BYTES);
 324           r->fd = pr->fd;
 325           r->region_size = pr->size;
 326           r->shm = pr->mem;
 327           r->is_external = 1;
 328         }
 329       /* *INDENT-ON* */
 330     }
 331
 332   for (i = 0; i < mif->run.num_s2m_rings; i++)
 333     {
 334       ring = memif_get_ring (mif, MEMIF_RING_S2M, i);
 335       ring->head = ring->tail = 0;
 336       ring->cookie = MEMIF_COOKIE;
 337
 338       if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY)
 339         continue;
 340
 341       for (j = 0; j < (1 << mif->run.log2_ring_size); j++)
 342         {
 343           u16 slot = i * (1 << mif->run.log2_ring_size) + j;
 344           ring->desc[j].region = 0;
 345           ring->desc[j].offset =
 346             buffer_offset + (u32) (slot * mif->run.buffer_size);
 347           ring->desc[j].length = mif->run.buffer_size;
 348         }
 349     }
 350   for (i = 0; i < mif->run.num_m2s_rings; i++)
 351     {
 352       ring = memif_get_ring (mif, MEMIF_RING_M2S, i);
 353       ring->head = ring->tail = 0;
 354       ring->cookie = MEMIF_COOKIE;
 355
 356       if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY)
 357         continue;
 358
 359       for (j = 0; j < (1 << mif->run.log2_ring_size); j++)
 360         {
 361           u16 slot =
 362             (i + mif->run.num_s2m_rings) * (1 << mif->run.log2_ring_size) + j;
 363           ring->desc[j].region = 0;
 364           ring->desc[j].offset =
 365             buffer_offset + (u32) (slot * mif->run.buffer_size);
 366           ring->desc[j].length = mif->run.buffer_size;
 367         }
 368     }
 369
 370   ASSERT (mif->tx_queues == 0);
 371   vec_validate_aligned (mif->tx_queues, mif->run.num_s2m_rings - 1,
 372                         CLIB_CACHE_LINE_BYTES);
 373
 374   /* *INDENT-OFF* */
 375   vec_foreach_index (i, mif->tx_queues)
 376     {
 377       memif_queue_t *mq = vec_elt_at_index (mif->tx_queues, i);
 378       if ((mq->int_fd = eventfd (0, EFD_NONBLOCK)) < 0)
 379         return clib_error_return_unix (0, "eventfd[tx queue %u]", i);
 380       mq->int_clib_file_index = ~0;
 381       mq->ring = memif_get_ring (mif, MEMIF_RING_S2M, i);
 382       mq->log2_ring_size = mif->cfg.log2_ring_size;
 383       mq->region = 0;
 384       mq->offset = (void *) mq->ring - (void *) mif->regions[mq->region].shm;
 385       mq->last_head = 0;
 386       mq->type = MEMIF_RING_S2M;
 387       if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY)
 388         vec_validate_aligned (mq->buffers, 1 << mq->log2_ring_size,
 389                               CLIB_CACHE_LINE_BYTES);
 390     }
 391   /* *INDENT-ON* */
 392
 393   ASSERT (mif->rx_queues == 0);
 394   vec_validate_aligned (mif->rx_queues, mif->run.num_m2s_rings - 1,
 395                         CLIB_CACHE_LINE_BYTES);
 396
 397   /* *INDENT-OFF* */
 398   vec_foreach_index (i, mif->rx_queues)
 399     {
 400       memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, i);
 401       if ((mq->int_fd = eventfd (0, EFD_NONBLOCK)) < 0)
 402         return clib_error_return_unix (0, "eventfd[rx queue %u]", i);
 403       mq->int_clib_file_index = ~0;
 404       mq->ring = memif_get_ring (mif, MEMIF_RING_M2S, i);
 405       mq->log2_ring_size = mif->cfg.log2_ring_size;
 406       mq->region = 0;
 407       mq->offset = (void *) mq->ring - (void *) mif->regions[mq->region].shm;
 408       mq->last_head = 0;
 409       mq->type = MEMIF_RING_M2S;
 410       if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY)
 411         vec_validate_aligned (mq->buffers, 1 << mq->log2_ring_size,
 412                               CLIB_CACHE_LINE_BYTES);
 413     }
 414   /* *INDENT-ON* */
 415
 416   return 0;
 417 }
 418
 419 static uword
 420 memif_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
 421 {
 422   memif_main_t *mm = &memif_main;
 423   memif_if_t *mif;
 424   clib_socket_t *sock;
 425   uword *event_data = 0, event_type;
 426   u8 enabled = 0;
 427   f64 start_time, last_run_duration = 0, now;
 428   clib_error_t *err;
 429
 430   sock = clib_mem_alloc (sizeof (clib_socket_t));
 431   memset (sock, 0, sizeof (clib_socket_t));
 432
 433   while (1)
 434     {
 435       if (enabled)
 436         vlib_process_wait_for_event_or_clock (vm, (f64) 3 -
 437                                               last_run_duration);
 438       else
 439         vlib_process_wait_for_event (vm);
 440
 441       event_type = vlib_process_get_events (vm, &event_data);
 442       vec_reset_length (event_data);
 443
 444       switch (event_type)
 445         {
 446         case ~0:
 447           break;
 448         case MEMIF_PROCESS_EVENT_START:
 449           enabled = 1;
 450           break;
 451         case MEMIF_PROCESS_EVENT_STOP:
 452           enabled = 0;
 453           continue;
 454         default:
 455           ASSERT (0);
 456         }
 457
 458       last_run_duration = start_time = vlib_time_now (vm);
 459       /* *INDENT-OFF* */
 460       pool_foreach (mif, mm->interfaces,
 461         ({
 462           memif_socket_file_t * msf = vec_elt_at_index (mm->socket_files, mif->socket_file_index);
 463           /* Allow no more than 10us without a pause */
 464           now = vlib_time_now (vm);
 465           if (now > start_time + 10e-6)
 466             {
 467               vlib_process_suspend (vm, 100e-6);        /* suspend for 100 us */
 468               start_time = vlib_time_now (vm);
 469             }
 470
 471           if ((mif->flags & MEMIF_IF_FLAG_ADMIN_UP) == 0)
 472             continue;
 473
 474           if (mif->flags & MEMIF_IF_FLAG_CONNECTING)
 475             continue;
 476
 477           if (mif->flags & MEMIF_IF_FLAG_CONNECTED)
 478             continue;
 479
 480           if (mif->flags & MEMIF_IF_FLAG_IS_SLAVE)
 481             {
 482               memset (sock, 0, sizeof(clib_socket_t));
 483               sock->config = (char *) msf->filename;
 484               sock->flags = CLIB_SOCKET_F_IS_CLIENT| CLIB_SOCKET_F_SEQPACKET;
 485
 486               if ((err = clib_socket_init (sock)))
 487                 {
 488                   clib_error_free (err);
 489                 }
 490               else
 491                 {
 492                   clib_file_t t = { 0 };
 493
 494                   t.read_function = memif_slave_conn_fd_read_ready;
 495                   t.write_function = memif_slave_conn_fd_write_ready;
 496                   t.error_function = memif_slave_conn_fd_error;
 497                   t.file_descriptor = sock->fd;
 498                   t.private_data = mif->dev_instance;
 499                   memif_file_add (&sock->private_data, &t);
 500                   t.description = format (0, "%U ctl",
 501                                           format_memif_device_name,
 502                                           mif->dev_instance);
 503                   hash_set (msf->dev_instance_by_fd, sock->fd, mif->dev_instance);
 504
 505                   mif->flags |= MEMIF_IF_FLAG_CONNECTING;
 506                   mif->sock = sock;
 507                   sock = clib_mem_alloc (sizeof(clib_socket_t));
 508                 }
 509             }
 510         }));
 511       /* *INDENT-ON* */
 512       last_run_duration = vlib_time_now (vm) - last_run_duration;
 513     }
 514   return 0;
 515 }
 516
 517 /* *INDENT-OFF* */
 518 VLIB_REGISTER_NODE (memif_process_node,static) = {
 519   .function = memif_process,
 520   .type = VLIB_NODE_TYPE_PROCESS,
 521   .name = "memif-process",
 522 };
 523 /* *INDENT-ON* */
 524
 525
 526 static int
 527 memif_add_socket_file (u32 sock_id, u8 * socket_filename)
 528 {
 529   memif_main_t *mm = &memif_main;
 530   uword *p;
 531   memif_socket_file_t *msf;
 532
 533   p = hash_get (mm->socket_file_index_by_sock_id, sock_id);
 534   if (p)
 535     {
 536       msf = pool_elt_at_index (mm->socket_files, *p);
 537       if (strcmp ((char *) msf->filename, (char *) socket_filename) == 0)
 538         {
 539           /* Silently accept identical "add". */
 540           return 0;
 541         }
 542
 543       /* But don't allow a direct add of a different filename. */
 544       return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
 545     }
 546
 547   DBG ("creating socket file (uninitialized) %s", msf->filename);
 548
 549   pool_get (mm->socket_files, msf);
 550   memset (msf, 0, sizeof (memif_socket_file_t));
 551
 552   msf->filename = socket_filename;
 553   msf->socket_id = sock_id;
 554
 555   hash_set (mm->socket_file_index_by_sock_id, sock_id,
 556             msf - mm->socket_files);
 557
 558   return 0;
 559 }
 560
 561 static int
 562 memif_delete_socket_file (u32 sock_id)
 563 {
 564   memif_main_t *mm = &memif_main;
 565   uword *p;
 566   memif_socket_file_t *msf;
 567
 568   p = hash_get (mm->socket_file_index_by_sock_id, sock_id);
 569   if (!p)
 570     {
 571       /* Don't delete non-existent entries. */
 572       return VNET_API_ERROR_INVALID_ARGUMENT;
 573     }
 574
 575   msf = pool_elt_at_index (mm->socket_files, *p);
 576   if (msf->ref_cnt > 0)
 577     {
 578       return VNET_API_ERROR_UNEXPECTED_INTF_STATE;
 579     }
 580
 581   vec_free (msf->filename);
 582   pool_put (mm->socket_files, msf);
 583
 584   hash_unset (mm->socket_file_index_by_sock_id, sock_id);
 585
 586   return 0;
 587 }
 588
 589 int
 590 memif_socket_filename_add_del (u8 is_add, u32 sock_id, u8 * sock_filename)
 591 {
 592   if (sock_id == 0 || sock_id == ~0)
 593     {
 594       return VNET_API_ERROR_INVALID_ARGUMENT;
 595     }
 596
 597   if (is_add == 0)
 598     {
 599       return memif_delete_socket_file (sock_id);
 600     }
 601
 602   if (sock_filename == 0 || sock_filename[0] == 0)
 603     {
 604       return VNET_API_ERROR_INVALID_ARGUMENT;
 605     }
 606
 607   if (sock_filename[0] != '/')
 608     {
 609       clib_error_t *error;
 610       error = vlib_unix_recursive_mkdir (vlib_unix_get_runtime_dir ());
 611       if (error)
 612         {
 613           clib_error_free (error);
 614           return VNET_API_ERROR_SYSCALL_ERROR_1;
 615         }
 616
 617       sock_filename = format (0, "%s/%s%c", vlib_unix_get_runtime_dir (),
 618                               sock_filename, 0);
 619     }
 620   else
 621     {
 622       sock_filename = vec_dup (sock_filename);
 623     }
 624
 625   return memif_add_socket_file (sock_id, sock_filename);
 626 }
 627
 628 int
 629 memif_delete_if (vlib_main_t * vm, memif_if_t * mif)
 630 {
 631   vnet_main_t *vnm = vnet_get_main ();
 632   memif_main_t *mm = &memif_main;
 633   memif_socket_file_t *msf =
 634     vec_elt_at_index (mm->socket_files, mif->socket_file_index);
 635   clib_error_t *err;
 636
 637   mif->flags |= MEMIF_IF_FLAG_DELETING;
 638   vec_free (mif->local_disc_string);
 639   vec_free (mif->remote_disc_string);
 640
 641   /* bring down the interface */
 642   vnet_hw_interface_set_flags (vnm, mif->hw_if_index, 0);
 643   vnet_sw_interface_set_flags (vnm, mif->sw_if_index, 0);
 644
 645   err = clib_error_return (0, "interface deleted");
 646   memif_disconnect (mif, err);
 647   clib_error_free (err);
 648
 649   if (mif->hw_if_index != ~0)
 650     {
 651       /* remove the interface */
 652       if (mif->mode == MEMIF_INTERFACE_MODE_IP)
 653         vnet_delete_hw_interface (vnm, mif->hw_if_index);
 654       else
 655         ethernet_delete_interface (vnm, mif->hw_if_index);
 656       mif->hw_if_index = ~0;
 657     }
 658
 659   /* free interface data structures */
 660   clib_spinlock_free (&mif->lockp);
 661   mhash_unset (&msf->dev_instance_by_id, &mif->id, 0);
 662
 663   /* remove socket file */
 664   if (--(msf->ref_cnt) == 0)
 665     {
 666       if (msf->is_listener)
 667         {
 668           int i;
 669           /* *INDENT-OFF* */
 670           vec_foreach_index (i, msf->pending_clients)
 671             memif_socket_close (msf->pending_clients + i);
 672           /* *INDENT-ON* */
 673           memif_socket_close (&msf->sock);
 674           vec_free (msf->pending_clients);
 675         }
 676       mhash_free (&msf->dev_instance_by_id);
 677       hash_free (msf->dev_instance_by_fd);
 678       if (msf->sock)
 679         {
 680           err = clib_socket_close (msf->sock);
 681           if (err)
 682             clib_error_report (err);
 683           clib_mem_free (msf->sock);
 684         }
 685     }
 686
 687   memset (mif, 0, sizeof (*mif));
 688   pool_put (mm->interfaces, mif);
 689
 690   if (pool_elts (mm->interfaces) == 0)
 691     vlib_process_signal_event (vm, memif_process_node.index,
 692                                MEMIF_PROCESS_EVENT_STOP, 0);
 693
 694   return 0;
 695 }
 696
 697 /* *INDENT-OFF* */
 698 VNET_HW_INTERFACE_CLASS (memif_ip_hw_if_class, static) =
 699 {
 700   .name = "memif-ip",
 701   .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
 702 };
 703 /* *INDENT-ON* */
 704
 705 int
 706 memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args)
 707 {
 708   memif_main_t *mm = &memif_main;
 709   vlib_thread_main_t *tm = vlib_get_thread_main ();
 710   vnet_main_t *vnm = vnet_get_main ();
 711   memif_if_t *mif = 0;
 712   vnet_sw_interface_t *sw;
 713   clib_error_t *error = 0;
 714   int ret = 0;
 715   uword *p;
 716   vnet_hw_interface_t *hw;
 717   memif_socket_file_t *msf = 0;
 718   int rv = 0;
 719
 720   p = hash_get (mm->socket_file_index_by_sock_id, args->socket_id);
 721   if (p == 0)
 722     {
 723       rv = VNET_API_ERROR_INVALID_ARGUMENT;
 724       goto done;
 725     }
 726
 727   msf = vec_elt_at_index (mm->socket_files, p[0]);
 728
 729   /* existing socket file can be either master or slave but cannot be both */
 730   if (msf->ref_cnt > 0)
 731     {
 732       if ((!msf->is_listener != !args->is_master))
 733         {
 734           rv = VNET_API_ERROR_SUBIF_ALREADY_EXISTS;
 735           goto done;
 736         }
 737
 738       p = mhash_get (&msf->dev_instance_by_id, &args->id);
 739       if (p)
 740         {
 741           rv = VNET_API_ERROR_SUBIF_ALREADY_EXISTS;
 742           goto done;
 743         }
 744     }
 745
 746   /* Create new socket file */
 747   if (msf->ref_cnt == 0)
 748     {
 749       struct stat file_stat;
 750
 751       /* If we are creating listener make sure file doesn't exist or if it
 752        * exists thn delete it if it is old socket file */
 753       if (args->is_master && (stat ((char *) msf->filename, &file_stat) == 0))
 754         {
 755           if (S_ISSOCK (file_stat.st_mode))
 756             {
 757               unlink ((char *) msf->filename);
 758             }
 759           else
 760             {
 761               error = clib_error_return (0, "File exists for %s",
 762                                          msf->filename);
 763               clib_error_report (error);
 764               rv = VNET_API_ERROR_VALUE_EXIST;
 765               goto done;
 766             }
 767         }
 768
 769       mhash_init (&msf->dev_instance_by_id, sizeof (uword),
 770                   sizeof (memif_interface_id_t));
 771       msf->dev_instance_by_fd = hash_create (0, sizeof (uword));
 772       msf->is_listener = (args->is_master != 0);
 773
 774       DBG ("initializing socket file %s", msf->filename);
 775     }
 776
 777   if (mm->per_thread_data == 0)
 778     {
 779       int i;
 780       vlib_buffer_free_list_t *fl;
 781
 782       vec_validate_aligned (mm->per_thread_data, tm->n_vlib_mains - 1,
 783                             CLIB_CACHE_LINE_BYTES);
 784
 785       fl =
 786         vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 787       for (i = 0; i < tm->n_vlib_mains; i++)
 788         {
 789           memif_per_thread_data_t *ptd =
 790             vec_elt_at_index (mm->per_thread_data, i);
 791           vlib_buffer_t *bt = &ptd->buffer_template;
 792           vlib_buffer_init_for_free_list (bt, fl);
 793           bt->flags = VLIB_BUFFER_TOTAL_LENGTH_VALID;
 794           bt->total_length_not_including_first_buffer = 0;
 795           vnet_buffer (bt)->sw_if_index[VLIB_TX] = (u32) ~ 0;
 796
 797           /* initially prealloc copy_ops so we can use
 798              _vec_len instead of vec_elen */
 799           vec_validate_aligned (ptd->copy_ops, 0, CLIB_CACHE_LINE_BYTES);
 800           vec_reset_length (ptd->copy_ops);
 801           vec_validate_aligned (ptd->buffers, 0, CLIB_CACHE_LINE_BYTES);
 802           vec_reset_length (ptd->buffers);
 803         }
 804     }
 805
 806   pool_get (mm->interfaces, mif);
 807   memset (mif, 0, sizeof (*mif));
 808   mif->dev_instance = mif - mm->interfaces;
 809   mif->socket_file_index = msf - mm->socket_files;
 810   mif->id = args->id;
 811   mif->sw_if_index = mif->hw_if_index = mif->per_interface_next_index = ~0;
 812   mif->mode = args->mode;
 813   if (args->secret)
 814     mif->secret = vec_dup (args->secret);
 815
 816   if (tm->n_vlib_mains > 1)
 817     clib_spinlock_init (&mif->lockp);
 818
 819   if (mif->mode == MEMIF_INTERFACE_MODE_ETHERNET)
 820     {
 821
 822       if (!args->hw_addr_set)
 823         {
 824           f64 now = vlib_time_now (vm);
 825           u32 rnd;
 826           rnd = (u32) (now * 1e6);
 827           rnd = random_u32 (&rnd);
 828
 829           memcpy (args->hw_addr + 2, &rnd, sizeof (rnd));
 830           args->hw_addr[0] = 2;
 831           args->hw_addr[1] = 0xfe;
 832         }
 833       error = ethernet_register_interface (vnm, memif_device_class.index,
 834                                            mif->dev_instance, args->hw_addr,
 835                                            &mif->hw_if_index,
 836                                            memif_eth_flag_change);
 837     }
 838   else if (mif->mode == MEMIF_INTERFACE_MODE_IP)
 839     {
 840       mif->hw_if_index =
 841         vnet_register_interface (vnm, memif_device_class.index,
 842                                  mif->dev_instance,
 843                                  memif_ip_hw_if_class.index,
 844                                  mif->dev_instance);
 845     }
 846   else
 847     error = clib_error_return (0, "unsupported interface mode");
 848
 849   if (error)
 850     {
 851       clib_error_report (error);
 852       ret = VNET_API_ERROR_SYSCALL_ERROR_2;
 853       goto error;
 854     }
 855
 856   sw = vnet_get_hw_sw_interface (vnm, mif->hw_if_index);
 857   mif->sw_if_index = sw->sw_if_index;
 858
 859   mif->cfg.log2_ring_size = args->log2_ring_size;
 860   mif->cfg.buffer_size = args->buffer_size;
 861   mif->cfg.num_s2m_rings =
 862     args->is_master ? args->rx_queues : args->tx_queues;
 863   mif->cfg.num_m2s_rings =
 864     args->is_master ? args->tx_queues : args->rx_queues;
 865
 866   args->sw_if_index = mif->sw_if_index;
 867
 868   /* If this is new one, start listening */
 869   if (msf->is_listener && msf->ref_cnt == 0)
 870     {
 871       struct stat file_stat;
 872       clib_socket_t *s = clib_mem_alloc (sizeof (clib_socket_t));
 873
 874       ASSERT (msf->sock == 0);
 875       msf->sock = s;
 876
 877       memset (s, 0, sizeof (clib_socket_t));
 878       s->config = (char *) msf->filename;
 879       s->flags = CLIB_SOCKET_F_IS_SERVER |
 880         CLIB_SOCKET_F_ALLOW_GROUP_WRITE |
 881         CLIB_SOCKET_F_SEQPACKET | CLIB_SOCKET_F_PASSCRED;
 882
 883       if ((error = clib_socket_init (s)))
 884         {
 885           clib_error_report (error);
 886           ret = VNET_API_ERROR_SYSCALL_ERROR_4;
 887           goto error;
 888         }
 889
 890       if (stat ((char *) msf->filename, &file_stat) == -1)
 891         {
 892           ret = VNET_API_ERROR_SYSCALL_ERROR_8;
 893           goto error;
 894         }
 895
 896       clib_file_t template = { 0 };
 897       template.read_function = memif_conn_fd_accept_ready;
 898       template.file_descriptor = msf->sock->fd;
 899       template.private_data = mif->socket_file_index;
 900       template.description = format (0, "memif listener %s", msf->filename);
 901       memif_file_add (&msf->sock->private_data, &template);
 902     }
 903
 904   msf->ref_cnt++;
 905
 906   if (args->is_master == 0)
 907     {
 908       mif->flags |= MEMIF_IF_FLAG_IS_SLAVE;
 909       if (args->is_zero_copy)
 910         mif->flags |= MEMIF_IF_FLAG_ZERO_COPY;
 911     }
 912
 913   hw = vnet_get_hw_interface (vnm, mif->hw_if_index);
 914   hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_INT_MODE;
 915   vnet_hw_interface_set_input_node (vnm, mif->hw_if_index,
 916                                     memif_input_node.index);
 917
 918   mhash_set (&msf->dev_instance_by_id, &mif->id, mif->dev_instance, 0);
 919
 920   if (pool_elts (mm->interfaces) == 1)
 921     {
 922       vlib_process_signal_event (vm, memif_process_node.index,
 923                                  MEMIF_PROCESS_EVENT_START, 0);
 924     }
 925   goto done;
 926
 927 error:
 928   if (mif->hw_if_index != ~0)
 929     {
 930       if (mif->mode == MEMIF_INTERFACE_MODE_IP)
 931         vnet_delete_hw_interface (vnm, mif->hw_if_index);
 932       else
 933         ethernet_delete_interface (vnm, mif->hw_if_index);
 934       mif->hw_if_index = ~0;
 935     }
 936   memif_delete_if (vm, mif);
 937   return ret;
 938
 939 done:
 940   return rv;
 941 }
 942
 943
 944 static clib_error_t *
 945 memif_init (vlib_main_t * vm)
 946 {
 947   memif_main_t *mm = &memif_main;
 948   u8 *filename;
 949
 950   memset (mm, 0, sizeof (memif_main_t));
 951
 952   /* initialize binary API */
 953   memif_plugin_api_hookup (vm);
 954
 955   /*
 956    * Pre-stuff socket filename pool with a non-modifieable mapping
 957    * for socket-id 0 to MEMIF_DEFAULT_SOCKET_FILENAME in the
 958    * default run-time directory.
 959    */
 960   filename = format (0, "%s/%s%c",
 961                      vlib_unix_get_runtime_dir (),
 962                      MEMIF_DEFAULT_SOCKET_FILENAME, 0);
 963   memif_add_socket_file (0, filename);
 964
 965   return 0;
 966 }
 967
 968 VLIB_INIT_FUNCTION (memif_init);
 969
 970 /* *INDENT-OFF* */
 971 VLIB_PLUGIN_REGISTER () = {
 972     .version = VPP_BUILD_VER,
 973     .description = "Packet Memory Interface (experimetal)",
 974 };
 975 /* *INDENT-ON* */
 976
 977 /*
 978  * fd.io coding-style-patch-verification: ON
 979  *
 980  * Local Variables:
 981  * eval: (c-set-style "gnu")
 982  * End:
 983  */