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 <vnet/plugin/plugin.h>
  37 #include <vnet/ethernet/ethernet.h>
  38 #include <vpp/app/version.h>
  39 #include <memif/memif.h>
  40 #include <memif/private.h>
  41
  42 memif_main_t memif_main;
  43
  44 static u32
  45 memif_eth_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hi, u32 flags)
  46 {
  47   /* nothing for now */
  48   return 0;
  49 }
  50
  51 static void
  52 memif_queue_intfd_close (memif_queue_t * mq)
  53 {
  54   if (mq->int_unix_file_index != ~0)
  55     {
  56       memif_file_del_by_index (mq->int_unix_file_index);
  57       mq->int_unix_file_index = ~0;
  58       mq->int_fd = -1;
  59     }
  60   else if (mq->int_fd > -1)
  61     {
  62       close (mq->int_fd);
  63       mq->int_fd = -1;
  64     }
  65 }
  66
  67 void
  68 memif_disconnect (memif_if_t * mif, clib_error_t * err)
  69 {
  70   vnet_main_t *vnm = vnet_get_main ();
  71   memif_region_t *mr;
  72   memif_queue_t *mq;
  73   int i;
  74
  75   if (mif == 0)
  76     return;
  77
  78   DBG ("disconnect %u (%v)", mif->dev_instance, err ? err->what : 0);
  79
  80   if (err)
  81     {
  82       clib_error_t *e = 0;
  83       mif->local_disc_string = vec_dup (err->what);
  84       if (mif->conn_fd > -1)
  85         e = memif_msg_send_disconnect (mif, err);
  86       clib_error_free (e);
  87     }
  88
  89   /* set interface down */
  90   mif->flags &= ~(MEMIF_IF_FLAG_CONNECTED | MEMIF_IF_FLAG_CONNECTING);
  91   if (mif->hw_if_index != ~0)
  92     vnet_hw_interface_set_flags (vnm, mif->hw_if_index, 0);
  93
  94   /* close connection socket */
  95   if (mif->conn_unix_file_index != ~0)
  96     {
  97       memif_file_del_by_index (mif->conn_unix_file_index);
  98       mif->conn_unix_file_index = ~0;
  99     }
 100   else if (mif->conn_fd > -1)
 101     close (mif->conn_fd);
 102   mif->conn_fd = -1;
 103
 104   vec_foreach_index (i, mif->rx_queues)
 105   {
 106     mq = vec_elt_at_index (mif->rx_queues, i);
 107     if (mq->ring)
 108       {
 109         int rv;
 110         rv = vnet_hw_interface_unassign_rx_thread (vnm, mif->hw_if_index, i);
 111         if (rv)
 112           DBG ("Warning: unable to unassign interface %d, "
 113                "queue %d: rc=%d", mif->hw_if_index, i, rv);
 114         mq->ring = 0;
 115       }
 116   }
 117
 118   /* free tx and rx queues */
 119   vec_foreach (mq, mif->rx_queues) memif_queue_intfd_close (mq);
 120   vec_free (mif->rx_queues);
 121
 122   vec_foreach (mq, mif->tx_queues) memif_queue_intfd_close (mq);
 123   vec_free (mif->tx_queues);
 124
 125   /* free memory regions */
 126   vec_foreach (mr, mif->regions)
 127   {
 128     int rv;
 129     if ((rv = munmap (mr->shm, mr->region_size)))
 130       clib_warning ("munmap failed, rv = %d", rv);
 131     if (mr->fd > -1)
 132       close (mr->fd);
 133   }
 134   vec_free (mif->regions);
 135
 136   mif->remote_pid = 0;
 137   vec_free (mif->remote_name);
 138   vec_free (mif->remote_if_name);
 139   clib_fifo_free (mif->msg_queue);
 140 }
 141
 142 static clib_error_t *
 143 memif_int_fd_read_ready (unix_file_t * uf)
 144 {
 145   memif_main_t *mm = &memif_main;
 146   vnet_main_t *vnm = vnet_get_main ();
 147   u16 qid = uf->private_data & 0xFFFF;
 148   memif_if_t *mif = vec_elt_at_index (mm->interfaces, uf->private_data >> 16);
 149   memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, qid);
 150   u64 b;
 151   ssize_t size;
 152
 153   size = read (uf->file_descriptor, &b, sizeof (b));
 154   if (size < 0)
 155     {
 156       DBG_UNIX_LOG ("Failed to read from socket");
 157       return 0;
 158     }
 159
 160   vnet_device_input_set_interrupt_pending (vnm, mif->hw_if_index, qid);
 161   mq->int_count++;
 162
 163   return 0;
 164 }
 165
 166
 167 clib_error_t *
 168 memif_connect (memif_if_t * mif)
 169 {
 170   vnet_main_t *vnm = vnet_get_main ();
 171   unix_file_t template = { 0 };
 172   memif_region_t *mr;
 173   int i;
 174
 175   DBG ("connect %u", mif->dev_instance);
 176
 177   vec_free (mif->local_disc_string);
 178   vec_free (mif->remote_disc_string);
 179
 180   vec_foreach (mr, mif->regions)
 181   {
 182     if (mr->shm)
 183       continue;
 184
 185     if (mr->fd < 0)
 186       clib_error_return (0, "no memory region fd");
 187
 188     if ((mr->shm = mmap (NULL, mr->region_size, PROT_READ | PROT_WRITE,
 189                          MAP_SHARED, mr->fd, 0)) == MAP_FAILED)
 190       return clib_error_return_unix (0, "mmap");
 191   }
 192
 193   template.read_function = memif_int_fd_read_ready;
 194
 195   vec_foreach_index (i, mif->tx_queues)
 196   {
 197     memif_queue_t *mq = vec_elt_at_index (mif->tx_queues, i);
 198
 199     mq->ring = mif->regions[mq->region].shm + mq->offset;
 200     if (mq->ring->cookie != MEMIF_COOKIE)
 201       return clib_error_return (0, "wrong cookie on tx ring %u", i);
 202   }
 203
 204   vec_foreach_index (i, mif->rx_queues)
 205   {
 206     memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, i);
 207     int rv;
 208
 209     mq->ring = mif->regions[mq->region].shm + mq->offset;
 210     if (mq->ring->cookie != MEMIF_COOKIE)
 211       return clib_error_return (0, "wrong cookie on tx ring %u", i);
 212
 213     if (mq->int_fd > -1)
 214       {
 215         template.file_descriptor = mq->int_fd;
 216         template.private_data = (mif->dev_instance << 16) | (i & 0xFFFF);
 217         memif_file_add (&mq->int_unix_file_index, &template);
 218       }
 219     vnet_hw_interface_assign_rx_thread (vnm, mif->hw_if_index, i, ~0);
 220     rv = vnet_hw_interface_set_rx_mode (vnm, mif->hw_if_index, i,
 221                                         VNET_HW_INTERFACE_RX_MODE_INTERRUPT);
 222     if (rv)
 223       clib_warning
 224         ("Warning: unable to set rx mode for interface %d queue %d: "
 225          "rc=%d", mif->hw_if_index, i, rv);
 226   }
 227
 228   mif->flags &= ~MEMIF_IF_FLAG_CONNECTING;
 229   mif->flags |= MEMIF_IF_FLAG_CONNECTED;
 230
 231   vnet_hw_interface_set_flags (vnm, mif->hw_if_index,
 232                                VNET_HW_INTERFACE_FLAG_LINK_UP);
 233   return 0;
 234 }
 235
 236 static_always_inline memif_ring_t *
 237 memif_get_ring (memif_if_t * mif, memif_ring_type_t type, u16 ring_num)
 238 {
 239   if (vec_len (mif->regions) == 0)
 240     return NULL;
 241   void *p = mif->regions[0].shm;
 242   int ring_size =
 243     sizeof (memif_ring_t) +
 244     sizeof (memif_desc_t) * (1 << mif->run.log2_ring_size);
 245   p += (ring_num + type * mif->run.num_s2m_rings) * ring_size;
 246
 247   return (memif_ring_t *) p;
 248 }
 249
 250 clib_error_t *
 251 memif_init_regions_and_queues (memif_if_t * mif)
 252 {
 253   memif_ring_t *ring = NULL;
 254   int i, j;
 255   u64 buffer_offset;
 256   memif_region_t *r;
 257
 258   vec_validate_aligned (mif->regions, 0, CLIB_CACHE_LINE_BYTES);
 259   r = vec_elt_at_index (mif->regions, 0);
 260
 261   buffer_offset = (mif->run.num_s2m_rings + mif->run.num_m2s_rings) *
 262     (sizeof (memif_ring_t) +
 263      sizeof (memif_desc_t) * (1 << mif->run.log2_ring_size));
 264
 265   r->region_size = buffer_offset +
 266     mif->run.buffer_size * (1 << mif->run.log2_ring_size) *
 267     (mif->run.num_s2m_rings + mif->run.num_m2s_rings);
 268
 269   if ((r->fd = memfd_create ("memif region 0", MFD_ALLOW_SEALING)) == -1)
 270     return clib_error_return_unix (0, "memfd_create");
 271
 272   if ((fcntl (r->fd, F_ADD_SEALS, F_SEAL_SHRINK)) == -1)
 273     return clib_error_return_unix (0, "fcntl (F_ADD_SEALS, F_SEAL_SHRINK)");
 274
 275   if ((ftruncate (r->fd, r->region_size)) == -1)
 276     return clib_error_return_unix (0, "ftruncate");
 277
 278   if ((r->shm = mmap (NULL, r->region_size, PROT_READ | PROT_WRITE,
 279                       MAP_SHARED, r->fd, 0)) == MAP_FAILED)
 280     return clib_error_return_unix (0, "mmap");
 281
 282   for (i = 0; i < mif->run.num_s2m_rings; i++)
 283     {
 284       ring = memif_get_ring (mif, MEMIF_RING_S2M, i);
 285       ring->head = ring->tail = 0;
 286       ring->cookie = MEMIF_COOKIE;
 287       for (j = 0; j < (1 << mif->run.log2_ring_size); j++)
 288         {
 289           u16 slot = i * (1 << mif->run.log2_ring_size) + j;
 290           ring->desc[j].region = 0;
 291           ring->desc[j].offset =
 292             buffer_offset + (u32) (slot * mif->run.buffer_size);
 293           ring->desc[j].buffer_length = mif->run.buffer_size;
 294         }
 295     }
 296   for (i = 0; i < mif->run.num_m2s_rings; i++)
 297     {
 298       ring = memif_get_ring (mif, MEMIF_RING_M2S, i);
 299       ring->head = ring->tail = 0;
 300       ring->cookie = MEMIF_COOKIE;
 301       for (j = 0; j < (1 << mif->run.log2_ring_size); j++)
 302         {
 303           u16 slot =
 304             (i + mif->run.num_s2m_rings) * (1 << mif->run.log2_ring_size) + j;
 305           ring->desc[j].region = 0;
 306           ring->desc[j].offset =
 307             buffer_offset + (u32) (slot * mif->run.buffer_size);
 308           ring->desc[j].buffer_length = mif->run.buffer_size;
 309         }
 310     }
 311
 312   ASSERT (mif->tx_queues == 0);
 313   vec_validate_aligned (mif->tx_queues, mif->run.num_s2m_rings - 1,
 314                         CLIB_CACHE_LINE_BYTES);
 315   vec_foreach_index (i, mif->tx_queues)
 316   {
 317     memif_queue_t *mq = vec_elt_at_index (mif->tx_queues, i);
 318     if ((mq->int_fd = eventfd (0, EFD_NONBLOCK)) < 0)
 319       return clib_error_return_unix (0, "eventfd[tx queue %u]", i);
 320     mq->int_unix_file_index = ~0;
 321     mq->ring = memif_get_ring (mif, MEMIF_RING_S2M, i);
 322     mq->log2_ring_size = mif->cfg.log2_ring_size;
 323     mq->region = 0;
 324     mq->offset = (void *) mq->ring - (void *) mif->regions[mq->region].shm;
 325     mq->last_head = 0;
 326   }
 327
 328   ASSERT (mif->rx_queues == 0);
 329   vec_validate_aligned (mif->rx_queues, mif->run.num_m2s_rings - 1,
 330                         CLIB_CACHE_LINE_BYTES);
 331   vec_foreach_index (i, mif->rx_queues)
 332   {
 333     memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, i);
 334     if ((mq->int_fd = eventfd (0, EFD_NONBLOCK)) < 0)
 335       return clib_error_return_unix (0, "eventfd[rx queue %u]", i);
 336     mq->int_unix_file_index = ~0;
 337     mq->ring = memif_get_ring (mif, MEMIF_RING_M2S, i);
 338     mq->log2_ring_size = mif->cfg.log2_ring_size;
 339     mq->region = 0;
 340     mq->offset = (void *) mq->ring - (void *) mif->regions[mq->region].shm;
 341     mq->last_head = 0;
 342   }
 343
 344   return 0;
 345 }
 346
 347 static uword
 348 memif_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
 349 {
 350   memif_main_t *mm = &memif_main;
 351   memif_if_t *mif;
 352   struct sockaddr_un sun;
 353   int sockfd;
 354   uword *event_data = 0, event_type;
 355   u8 enabled = 0;
 356   f64 start_time, last_run_duration = 0, now;
 357
 358   sockfd = socket (AF_UNIX, SOCK_SEQPACKET, 0);
 359   if (sockfd < 0)
 360     {
 361       DBG_UNIX_LOG ("socket AF_UNIX");
 362       return 0;
 363     }
 364   sun.sun_family = AF_UNIX;
 365
 366   while (1)
 367     {
 368       if (enabled)
 369         vlib_process_wait_for_event_or_clock (vm, (f64) 3 -
 370                                               last_run_duration);
 371       else
 372         vlib_process_wait_for_event (vm);
 373
 374       event_type = vlib_process_get_events (vm, &event_data);
 375       vec_reset_length (event_data);
 376
 377       switch (event_type)
 378         {
 379         case ~0:
 380           break;
 381         case MEMIF_PROCESS_EVENT_START:
 382           enabled = 1;
 383           break;
 384         case MEMIF_PROCESS_EVENT_STOP:
 385           enabled = 0;
 386           continue;
 387         default:
 388           ASSERT (0);
 389         }
 390
 391       last_run_duration = start_time = vlib_time_now (vm);
 392       /* *INDENT-OFF* */
 393       pool_foreach (mif, mm->interfaces,
 394         ({
 395           memif_socket_file_t * msf = vec_elt_at_index (mm->socket_files, mif->socket_file_index);
 396           /* Allow no more than 10us without a pause */
 397           now = vlib_time_now (vm);
 398           if (now > start_time + 10e-6)
 399             {
 400               vlib_process_suspend (vm, 100e-6);        /* suspend for 100 us */
 401               start_time = vlib_time_now (vm);
 402             }
 403
 404           if ((mif->flags & MEMIF_IF_FLAG_ADMIN_UP) == 0)
 405             continue;
 406
 407           if (mif->flags & MEMIF_IF_FLAG_CONNECTING)
 408             continue;
 409
 410           if (mif->flags & MEMIF_IF_FLAG_CONNECTED)
 411             continue;
 412
 413           if (mif->flags & MEMIF_IF_FLAG_IS_SLAVE)
 414             {
 415               strncpy (sun.sun_path, (char *) msf->filename,
 416                        sizeof (sun.sun_path) - 1);
 417
 418               if (connect
 419                   (sockfd, (struct sockaddr *) &sun,
 420                    sizeof (struct sockaddr_un)) == 0)
 421                 {
 422                   unix_file_t t = { 0 };
 423
 424                   mif->conn_fd = sockfd;
 425                   t.read_function = memif_slave_conn_fd_read_ready;
 426                   t.write_function = memif_slave_conn_fd_write_ready;
 427                   t.error_function = memif_slave_conn_fd_error;
 428                   t.file_descriptor = mif->conn_fd;
 429                   t.private_data = mif->dev_instance;
 430                   memif_file_add (&mif->conn_unix_file_index, &t);
 431                   hash_set (msf->dev_instance_by_fd, mif->conn_fd, mif->dev_instance);
 432
 433                   mif->flags |= MEMIF_IF_FLAG_CONNECTING;
 434
 435                   /* grab another fd */
 436                   sockfd = socket (AF_UNIX, SOCK_SEQPACKET, 0);
 437                   if (sockfd < 0)
 438                     {
 439                       DBG_UNIX_LOG ("socket AF_UNIX");
 440                       return 0;
 441                     }
 442                 }
 443             }
 444         }));
 445       /* *INDENT-ON* */
 446       last_run_duration = vlib_time_now (vm) - last_run_duration;
 447     }
 448   return 0;
 449 }
 450
 451 /* *INDENT-OFF* */
 452 VLIB_REGISTER_NODE (memif_process_node,static) = {
 453   .function = memif_process,
 454   .type = VLIB_NODE_TYPE_PROCESS,
 455   .name = "memif-process",
 456 };
 457 /* *INDENT-ON* */
 458
 459 int
 460 memif_delete_if (vlib_main_t * vm, memif_if_t * mif)
 461 {
 462   vnet_main_t *vnm = vnet_get_main ();
 463   memif_main_t *mm = &memif_main;
 464   memif_socket_file_t *msf =
 465     vec_elt_at_index (mm->socket_files, mif->socket_file_index);
 466   clib_error_t *err;
 467
 468   mif->flags |= MEMIF_IF_FLAG_DELETING;
 469   vec_free (mif->local_disc_string);
 470   vec_free (mif->remote_disc_string);
 471
 472   /* bring down the interface */
 473   vnet_hw_interface_set_flags (vnm, mif->hw_if_index, 0);
 474   vnet_sw_interface_set_flags (vnm, mif->sw_if_index, 0);
 475
 476   err = clib_error_return (0, "interface deleted");
 477   memif_disconnect (mif, err);
 478   clib_error_free (err);
 479
 480   /* remove the interface */
 481   ethernet_delete_interface (vnm, mif->hw_if_index);
 482   mif->hw_if_index = ~0;
 483
 484   /* free interface data structures */
 485   clib_spinlock_free (&mif->lockp);
 486   mhash_unset (&msf->dev_instance_by_id, &mif->id, 0);
 487
 488   /* remove socket file */
 489   if (--(msf->ref_cnt) == 0)
 490     {
 491       if (msf->is_listener)
 492         {
 493           uword *x;
 494           memif_file_del_by_index (msf->unix_file_index);
 495           vec_foreach (x, msf->pending_file_indices)
 496           {
 497             memif_file_del_by_index (*x);
 498           }
 499           vec_free (msf->pending_file_indices);
 500         }
 501       mhash_free (&msf->dev_instance_by_id);
 502       hash_free (msf->dev_instance_by_fd);
 503       mhash_unset (&mm->socket_file_index_by_filename, msf->filename, 0);
 504       vec_free (msf->filename);
 505       pool_put (mm->socket_files, msf);
 506     }
 507
 508   memset (mif, 0, sizeof (*mif));
 509   pool_put (mm->interfaces, mif);
 510
 511   if (pool_elts (mm->interfaces) == 0)
 512     vlib_process_signal_event (vm, memif_process_node.index,
 513                                MEMIF_PROCESS_EVENT_STOP, 0);
 514
 515   return 0;
 516 }
 517
 518 int
 519 memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args)
 520 {
 521   memif_main_t *mm = &memif_main;
 522   vlib_thread_main_t *tm = vlib_get_thread_main ();
 523   vnet_main_t *vnm = vnet_get_main ();
 524   memif_if_t *mif = 0;
 525   vnet_sw_interface_t *sw;
 526   clib_error_t *error = 0;
 527   int ret = 0;
 528   uword *p;
 529   vnet_hw_interface_t *hw;
 530   memif_socket_file_t *msf = 0;
 531   u8 *socket_filename;
 532   int rv = 0;
 533
 534   if (args->socket_filename == 0 || args->socket_filename[0] != '/')
 535     {
 536       rv = mkdir (MEMIF_DEFAULT_SOCKET_DIR, 0755);
 537       if (rv && errno != EEXIST)
 538         return VNET_API_ERROR_SYSCALL_ERROR_1;
 539
 540       if (args->socket_filename == 0)
 541         socket_filename = format (0, "%s/%s%c", MEMIF_DEFAULT_SOCKET_DIR,
 542                                   MEMIF_DEFAULT_SOCKET_FILENAME, 0);
 543       else
 544         socket_filename = format (0, "%s/%s%c", MEMIF_DEFAULT_SOCKET_DIR,
 545                                   args->socket_filename, 0);
 546
 547     }
 548   else
 549     socket_filename = vec_dup (args->socket_filename);
 550
 551   p = mhash_get (&mm->socket_file_index_by_filename, socket_filename);
 552
 553   if (p)
 554     {
 555       msf = vec_elt_at_index (mm->socket_files, p[0]);
 556
 557       /* existing socket file can be either master or slave but cannot be both */
 558       if (!msf->is_listener != !args->is_master)
 559         {
 560           rv = VNET_API_ERROR_SUBIF_ALREADY_EXISTS;
 561           goto done;
 562         }
 563
 564       p = mhash_get (&msf->dev_instance_by_id, &args->id);
 565       if (p)
 566         {
 567           rv = VNET_API_ERROR_SUBIF_ALREADY_EXISTS;
 568           goto done;
 569         }
 570     }
 571
 572   /* Create new socket file */
 573   if (msf == 0)
 574     {
 575       struct stat file_stat;
 576       /* If we are creating listener make sure file doesn't exist or if it
 577        * exists thn delete it if it is old socket file */
 578       if (args->is_master &&
 579           (stat ((char *) socket_filename, &file_stat) == 0))
 580         {
 581           if (S_ISSOCK (file_stat.st_mode))
 582             {
 583               unlink ((char *) socket_filename);
 584             }
 585           else
 586             {
 587               ret = VNET_API_ERROR_SYSCALL_ERROR_3;
 588               goto error;
 589             }
 590         }
 591       pool_get (mm->socket_files, msf);
 592       memset (msf, 0, sizeof (memif_socket_file_t));
 593       mhash_init (&msf->dev_instance_by_id, sizeof (uword),
 594                   sizeof (memif_interface_id_t));
 595       msf->dev_instance_by_fd = hash_create (0, sizeof (uword));
 596       msf->filename = socket_filename;
 597       msf->fd = -1;
 598       msf->is_listener = (args->is_master != 0);
 599       socket_filename = 0;
 600       mhash_set (&mm->socket_file_index_by_filename, msf->filename,
 601                  msf - mm->socket_files, 0);
 602       DBG ("creating socket file %s", msf->filename);
 603     }
 604
 605   pool_get (mm->interfaces, mif);
 606   memset (mif, 0, sizeof (*mif));
 607   mif->dev_instance = mif - mm->interfaces;
 608   mif->socket_file_index = msf - mm->socket_files;
 609   mif->id = args->id;
 610   mif->sw_if_index = mif->hw_if_index = mif->per_interface_next_index = ~0;
 611   mif->conn_unix_file_index = ~0;
 612   mif->conn_fd = -1;
 613   if (args->secret)
 614     mif->secret = vec_dup (args->secret);
 615
 616   if (tm->n_vlib_mains > 1)
 617     clib_spinlock_init (&mif->lockp);
 618
 619   if (!args->hw_addr_set)
 620     {
 621       f64 now = vlib_time_now (vm);
 622       u32 rnd;
 623       rnd = (u32) (now * 1e6);
 624       rnd = random_u32 (&rnd);
 625
 626       memcpy (args->hw_addr + 2, &rnd, sizeof (rnd));
 627       args->hw_addr[0] = 2;
 628       args->hw_addr[1] = 0xfe;
 629     }
 630
 631   error = ethernet_register_interface (vnm, memif_device_class.index,
 632                                        mif->dev_instance, args->hw_addr,
 633                                        &mif->hw_if_index,
 634                                        memif_eth_flag_change);
 635
 636   if (error)
 637     {
 638       clib_error_report (error);
 639       ret = VNET_API_ERROR_SYSCALL_ERROR_2;
 640       goto error;
 641     }
 642
 643   sw = vnet_get_hw_sw_interface (vnm, mif->hw_if_index);
 644   mif->sw_if_index = sw->sw_if_index;
 645
 646   mif->cfg.log2_ring_size = args->log2_ring_size;
 647   mif->cfg.buffer_size = args->buffer_size;
 648   mif->cfg.num_s2m_rings =
 649     args->is_master ? args->rx_queues : args->tx_queues;
 650   mif->cfg.num_m2s_rings =
 651     args->is_master ? args->tx_queues : args->rx_queues;
 652
 653   args->sw_if_index = mif->sw_if_index;
 654
 655   /* If this is new one, start listening */
 656   if (msf->is_listener && msf->ref_cnt == 0)
 657     {
 658       struct sockaddr_un un = { 0 };
 659       struct stat file_stat;
 660       int on = 1;
 661
 662       if ((msf->fd = socket (AF_UNIX, SOCK_SEQPACKET, 0)) < 0)
 663         {
 664           ret = VNET_API_ERROR_SYSCALL_ERROR_4;
 665           goto error;
 666         }
 667
 668       un.sun_family = AF_UNIX;
 669       strncpy ((char *) un.sun_path, (char *) msf->filename,
 670                sizeof (un.sun_path) - 1);
 671
 672       if (setsockopt (msf->fd, SOL_SOCKET, SO_PASSCRED, &on, sizeof (on)) < 0)
 673         {
 674           ret = VNET_API_ERROR_SYSCALL_ERROR_5;
 675           goto error;
 676         }
 677       if (bind (msf->fd, (struct sockaddr *) &un, sizeof (un)) == -1)
 678         {
 679           ret = VNET_API_ERROR_SYSCALL_ERROR_6;
 680           goto error;
 681         }
 682       if (listen (msf->fd, 1) == -1)
 683         {
 684           ret = VNET_API_ERROR_SYSCALL_ERROR_7;
 685           goto error;
 686         }
 687
 688       if (stat ((char *) msf->filename, &file_stat) == -1)
 689         {
 690           ret = VNET_API_ERROR_SYSCALL_ERROR_8;
 691           goto error;
 692         }
 693
 694       msf->unix_file_index = ~0;
 695       unix_file_t template = { 0 };
 696       template.read_function = memif_conn_fd_accept_ready;
 697       template.file_descriptor = msf->fd;
 698       template.private_data = mif->socket_file_index;
 699       memif_file_add (&msf->unix_file_index, &template);
 700     }
 701
 702   msf->ref_cnt++;
 703
 704   if (args->is_master == 0)
 705     mif->flags |= MEMIF_IF_FLAG_IS_SLAVE;
 706
 707   hw = vnet_get_hw_interface (vnm, mif->hw_if_index);
 708   hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_INT_MODE;
 709   vnet_hw_interface_set_input_node (vnm, mif->hw_if_index,
 710                                     memif_input_node.index);
 711
 712   mhash_set (&msf->dev_instance_by_id, &mif->id, mif->dev_instance, 0);
 713
 714   if (pool_elts (mm->interfaces) == 1)
 715     {
 716       vlib_process_signal_event (vm, memif_process_node.index,
 717                                  MEMIF_PROCESS_EVENT_START, 0);
 718     }
 719   goto done;
 720
 721 error:
 722   if (mif->hw_if_index != ~0)
 723     {
 724       ethernet_delete_interface (vnm, mif->hw_if_index);
 725       mif->hw_if_index = ~0;
 726     }
 727   memif_delete_if (vm, mif);
 728   return ret;
 729
 730 done:
 731   vec_free (socket_filename);
 732   return rv;
 733 }
 734
 735
 736 static clib_error_t *
 737 memif_init (vlib_main_t * vm)
 738 {
 739   memif_main_t *mm = &memif_main;
 740   vlib_thread_main_t *tm = vlib_get_thread_main ();
 741
 742   memset (mm, 0, sizeof (memif_main_t));
 743
 744   /* initialize binary API */
 745   memif_plugin_api_hookup (vm);
 746
 747   mhash_init_c_string (&mm->socket_file_index_by_filename, sizeof (uword));
 748
 749   vec_validate_aligned (mm->rx_buffers, tm->n_vlib_mains - 1,
 750                         CLIB_CACHE_LINE_BYTES);
 751
 752   return 0;
 753 }
 754
 755 VLIB_INIT_FUNCTION (memif_init);
 756
 757 /* *INDENT-OFF* */
 758 VLIB_PLUGIN_REGISTER () = {
 759     .version = VPP_BUILD_VER,
 760     .description = "Packet Memory Interface (experimetal)",
 761 };
 762 /* *INDENT-ON* */
 763
 764 /*
 765  * fd.io coding-style-patch-verification: ON
 766  *
 767  * Local Variables:
 768  * eval: (c-set-style "gnu")
 769  * End:
 770  */