src/plugins/memif/device.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2016 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/ioctl.h>
  22 #include <sys/uio.h>
  23
  24 #include <vlib/vlib.h>
  25 #include <vlib/unix/unix.h>
  26 #include <vnet/ethernet/ethernet.h>
  27
  28 #include <memif/memif.h>
  29 #include <memif/private.h>
  30
  31 #define foreach_memif_tx_func_error                                           \
  32   _ (NO_FREE_SLOTS, no_free_slots, ERROR, "no free tx slots")                 \
  33   _ (ROLLBACK, rollback, ERROR, "no enough space in tx buffers")
  34
  35 typedef enum
  36 {
  37 #define _(f, n, s, d) MEMIF_TX_ERROR_##f,
  38   foreach_memif_tx_func_error
  39 #undef _
  40     MEMIF_TX_N_ERROR,
  41 } memif_tx_func_error_t;
  42
  43 static vlib_error_desc_t memif_tx_func_error_counters[] = {
  44 #define _(f, n, s, d) { #n, d, VL_COUNTER_SEVERITY_##s },
  45   foreach_memif_tx_func_error
  46 #undef _
  47 };
  48
  49 #ifndef CLIB_MARCH_VARIANT
  50 u8 *
  51 format_memif_device_name (u8 * s, va_list * args)
  52 {
  53   u32 dev_instance = va_arg (*args, u32);
  54   memif_main_t *mm = &memif_main;
  55   memif_if_t *mif = pool_elt_at_index (mm->interfaces, dev_instance);
  56   memif_socket_file_t *msf;
  57
  58   msf = pool_elt_at_index (mm->socket_files, mif->socket_file_index);
  59   s = format (s, "memif%lu/%lu", msf->socket_id, mif->id);
  60   return s;
  61 }
  62 #endif
  63
  64 static u8 *
  65 format_memif_device (u8 * s, va_list * args)
  66 {
  67   u32 dev_instance = va_arg (*args, u32);
  68   int verbose = va_arg (*args, int);
  69   u32 indent = format_get_indent (s);
  70
  71   s = format (s, "MEMIF interface");
  72   if (verbose)
  73     {
  74       s = format (s, "\n%U instance %u", format_white_space, indent + 2,
  75                   dev_instance);
  76     }
  77   return s;
  78 }
  79
  80 static u8 *
  81 format_memif_tx_trace (u8 * s, va_list * args)
  82 {
  83   s = format (s, "Unimplemented...");
  84   return s;
  85 }
  86
  87 static_always_inline void
  88 memif_add_copy_op (memif_per_thread_data_t * ptd, void *data, u32 len,
  89                    u16 buffer_offset, u16 buffer_vec_index)
  90 {
  91   memif_copy_op_t *co;
  92   vec_add2_aligned (ptd->copy_ops, co, 1, CLIB_CACHE_LINE_BYTES);
  93   co->data = data;
  94   co->data_len = len;
  95   co->buffer_offset = buffer_offset;
  96   co->buffer_vec_index = buffer_vec_index;
  97 }
  98
  99 static_always_inline uword
 100 memif_interface_tx_inline (vlib_main_t *vm, vlib_node_runtime_t *node,
 101                            u32 *buffers, memif_if_t *mif,
 102                            memif_ring_type_t type, memif_queue_t *mq,
 103                            memif_per_thread_data_t *ptd, u32 n_left)
 104 {
 105   memif_ring_t *ring;
 106   u32 n_copy_op;
 107   u16 ring_size, mask, slot, free_slots;
 108   int n_retries = 5;
 109   vlib_buffer_t *b0, *b1, *b2, *b3;
 110   memif_copy_op_t *co;
 111   memif_region_index_t last_region = ~0;
 112   void *last_region_shm = 0;
 113   u16 head, tail;
 114
 115   ring = mq->ring;
 116   ring_size = 1 << mq->log2_ring_size;
 117   mask = ring_size - 1;
 118
 119 retry:
 120
 121   if (type == MEMIF_RING_S2M)
 122     {
 123       slot = head = ring->head;
 124       tail = __atomic_load_n (&ring->tail, __ATOMIC_ACQUIRE);
 125       mq->last_tail += tail - mq->last_tail;
 126       free_slots = ring_size - head + mq->last_tail;
 127     }
 128   else
 129     {
 130       slot = tail = ring->tail;
 131       head = __atomic_load_n (&ring->head, __ATOMIC_ACQUIRE);
 132       mq->last_tail += tail - mq->last_tail;
 133       free_slots = head - tail;
 134     }
 135
 136   while (n_left && free_slots)
 137     {
 138       memif_desc_t *d0;
 139       void *mb0;
 140       i32 src_off;
 141       u32 bi0, dst_off, src_left, dst_left, bytes_to_copy;
 142       u32 saved_ptd_copy_ops_len = _vec_len (ptd->copy_ops);
 143       u32 saved_ptd_buffers_len = _vec_len (ptd->buffers);
 144       u16 saved_slot = slot;
 145
 146       CLIB_PREFETCH (&ring->desc[(slot + 8) & mask], CLIB_CACHE_LINE_BYTES,
 147                      LOAD);
 148
 149       d0 = &ring->desc[slot & mask];
 150       if (PREDICT_FALSE (last_region != d0->region))
 151         {
 152           last_region_shm = mif->regions[d0->region].shm;
 153           last_region = d0->region;
 154         }
 155       mb0 = last_region_shm + d0->offset;
 156
 157       dst_off = 0;
 158
 159       /* slave is the producer, so it should be able to reset buffer length */
 160       dst_left = (type == MEMIF_RING_S2M) ? mif->run.buffer_size : d0->length;
 161
 162       if (PREDICT_TRUE (n_left >= 4))
 163         vlib_prefetch_buffer_header (vlib_get_buffer (vm, buffers[3]), LOAD);
 164       bi0 = buffers[0];
 165
 166     next_in_chain:
 167
 168       b0 = vlib_get_buffer (vm, bi0);
 169       src_off = b0->current_data;
 170       src_left = b0->current_length;
 171
 172       while (src_left)
 173         {
 174           if (PREDICT_FALSE (dst_left == 0))
 175             {
 176               if (free_slots)
 177                 {
 178                   slot++;
 179                   free_slots--;
 180                   d0->length = dst_off;
 181                   d0->flags = MEMIF_DESC_FLAG_NEXT;
 182                   d0 = &ring->desc[slot & mask];
 183                   dst_off = 0;
 184                   dst_left =
 185                     (type ==
 186                      MEMIF_RING_S2M) ? mif->run.buffer_size : d0->length;
 187
 188                   if (PREDICT_FALSE (last_region != d0->region))
 189                     {
 190                       last_region_shm = mif->regions[d0->region].shm;
 191                       last_region = d0->region;
 192                     }
 193                   mb0 = last_region_shm + d0->offset;
 194                 }
 195               else
 196                 {
 197                   /* we need to rollback vectors before bailing out */
 198                   _vec_len (ptd->buffers) = saved_ptd_buffers_len;
 199                   _vec_len (ptd->copy_ops) = saved_ptd_copy_ops_len;
 200                   vlib_error_count (vm, node->node_index,
 201                                     MEMIF_TX_ERROR_ROLLBACK, 1);
 202                   slot = saved_slot;
 203                   goto no_free_slots;
 204                 }
 205             }
 206           bytes_to_copy = clib_min (src_left, dst_left);
 207           memif_add_copy_op (ptd, mb0 + dst_off, bytes_to_copy, src_off,
 208                              vec_len (ptd->buffers));
 209           vec_add1_aligned (ptd->buffers, bi0, CLIB_CACHE_LINE_BYTES);
 210           src_off += bytes_to_copy;
 211           dst_off += bytes_to_copy;
 212           src_left -= bytes_to_copy;
 213           dst_left -= bytes_to_copy;
 214         }
 215
 216       if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_NEXT_PRESENT))
 217         {
 218           bi0 = b0->next_buffer;
 219           goto next_in_chain;
 220         }
 221
 222       d0->length = dst_off;
 223       d0->flags = 0;
 224
 225       free_slots -= 1;
 226       slot += 1;
 227
 228       buffers++;
 229       n_left--;
 230     }
 231 no_free_slots:
 232
 233   /* copy data */
 234   n_copy_op = vec_len (ptd->copy_ops);
 235   co = ptd->copy_ops;
 236   while (n_copy_op >= 8)
 237     {
 238       CLIB_PREFETCH (co[4].data, CLIB_CACHE_LINE_BYTES, LOAD);
 239       CLIB_PREFETCH (co[5].data, CLIB_CACHE_LINE_BYTES, LOAD);
 240       CLIB_PREFETCH (co[6].data, CLIB_CACHE_LINE_BYTES, LOAD);
 241       CLIB_PREFETCH (co[7].data, CLIB_CACHE_LINE_BYTES, LOAD);
 242
 243       b0 = vlib_get_buffer (vm, ptd->buffers[co[0].buffer_vec_index]);
 244       b1 = vlib_get_buffer (vm, ptd->buffers[co[1].buffer_vec_index]);
 245       b2 = vlib_get_buffer (vm, ptd->buffers[co[2].buffer_vec_index]);
 246       b3 = vlib_get_buffer (vm, ptd->buffers[co[3].buffer_vec_index]);
 247
 248       clib_memcpy_fast (co[0].data, b0->data + co[0].buffer_offset,
 249                         co[0].data_len);
 250       clib_memcpy_fast (co[1].data, b1->data + co[1].buffer_offset,
 251                         co[1].data_len);
 252       clib_memcpy_fast (co[2].data, b2->data + co[2].buffer_offset,
 253                         co[2].data_len);
 254       clib_memcpy_fast (co[3].data, b3->data + co[3].buffer_offset,
 255                         co[3].data_len);
 256
 257       co += 4;
 258       n_copy_op -= 4;
 259     }
 260   while (n_copy_op)
 261     {
 262       b0 = vlib_get_buffer (vm, ptd->buffers[co[0].buffer_vec_index]);
 263       clib_memcpy_fast (co[0].data, b0->data + co[0].buffer_offset,
 264                         co[0].data_len);
 265       co += 1;
 266       n_copy_op -= 1;
 267     }
 268
 269   vec_reset_length (ptd->copy_ops);
 270   vec_reset_length (ptd->buffers);
 271
 272   if (type == MEMIF_RING_S2M)
 273     __atomic_store_n (&ring->head, slot, __ATOMIC_RELEASE);
 274   else
 275     __atomic_store_n (&ring->tail, slot, __ATOMIC_RELEASE);
 276
 277   if (n_left && n_retries--)
 278     goto retry;
 279
 280   return n_left;
 281 }
 282
 283 static_always_inline uword
 284 memif_interface_tx_zc_inline (vlib_main_t *vm, vlib_node_runtime_t *node,
 285                               u32 *buffers, memif_if_t *mif, memif_queue_t *mq,
 286                               memif_per_thread_data_t *ptd, u32 n_left)
 287 {
 288   memif_ring_t *ring = mq->ring;
 289   u16 slot, free_slots, n_free;
 290   u16 ring_size = 1 << mq->log2_ring_size;
 291   u16 mask = ring_size - 1;
 292   int n_retries = 5;
 293   vlib_buffer_t *b0;
 294   u16 head, tail;
 295
 296 retry:
 297   tail = __atomic_load_n (&ring->tail, __ATOMIC_ACQUIRE);
 298   slot = head = ring->head;
 299
 300   n_free = tail - mq->last_tail;
 301   if (n_free >= 16)
 302     {
 303       vlib_buffer_free_from_ring_no_next (vm, mq->buffers,
 304                                           mq->last_tail & mask,
 305                                           ring_size, n_free);
 306       mq->last_tail += n_free;
 307     }
 308
 309   free_slots = ring_size - head + mq->last_tail;
 310
 311   while (n_left && free_slots)
 312     {
 313       u16 s0;
 314       u16 slots_in_packet = 1;
 315       memif_desc_t *d0;
 316       u32 bi0;
 317
 318       CLIB_PREFETCH (&ring->desc[(slot + 8) & mask], CLIB_CACHE_LINE_BYTES,
 319                      STORE);
 320
 321       if (PREDICT_TRUE (n_left >= 4))
 322         vlib_prefetch_buffer_header (vlib_get_buffer (vm, buffers[3]), LOAD);
 323
 324       bi0 = buffers[0];
 325
 326     next_in_chain:
 327       s0 = slot & mask;
 328       d0 = &ring->desc[s0];
 329       mq->buffers[s0] = bi0;
 330       b0 = vlib_get_buffer (vm, bi0);
 331
 332       d0->region = b0->buffer_pool_index + 1;
 333       d0->offset = (void *) b0->data + b0->current_data -
 334         mif->regions[d0->region].shm;
 335       d0->length = b0->current_length;
 336
 337       free_slots--;
 338       slot++;
 339
 340       if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_NEXT_PRESENT))
 341         {
 342           if (PREDICT_FALSE (free_slots == 0))
 343             {
 344               /* revert to last fully processed packet */
 345               free_slots += slots_in_packet;
 346               slot -= slots_in_packet;
 347               goto no_free_slots;
 348             }
 349
 350           d0->flags = MEMIF_DESC_FLAG_NEXT;
 351           bi0 = b0->next_buffer;
 352
 353           /* next */
 354           slots_in_packet++;
 355           goto next_in_chain;
 356         }
 357
 358       d0->flags = 0;
 359
 360       /* next from */
 361       buffers++;
 362       n_left--;
 363     }
 364 no_free_slots:
 365
 366   __atomic_store_n (&ring->head, slot, __ATOMIC_RELEASE);
 367
 368   if (n_left && n_retries--)
 369     goto retry;
 370
 371   return n_left;
 372 }
 373
 374 VNET_DEVICE_CLASS_TX_FN (memif_device_class) (vlib_main_t * vm,
 375                                               vlib_node_runtime_t * node,
 376                                               vlib_frame_t * frame)
 377 {
 378   memif_main_t *nm = &memif_main;
 379   vnet_interface_output_runtime_t *rund = (void *) node->runtime_data;
 380   memif_if_t *mif = pool_elt_at_index (nm->interfaces, rund->dev_instance);
 381   memif_queue_t *mq;
 382   u32 *from, thread_index = vm->thread_index;
 383   memif_per_thread_data_t *ptd = vec_elt_at_index (memif_main.per_thread_data,
 384                                                    thread_index);
 385   u8 tx_queues = vec_len (mif->tx_queues);
 386   uword n_left;
 387
 388   if (tx_queues < vlib_get_n_threads ())
 389     {
 390       ASSERT (tx_queues > 0);
 391       mq = vec_elt_at_index (mif->tx_queues, thread_index % tx_queues);
 392     }
 393   else
 394     mq = vec_elt_at_index (mif->tx_queues, thread_index);
 395
 396   clib_spinlock_lock_if_init (&mif->lockp);
 397
 398   from = vlib_frame_vector_args (frame);
 399   n_left = frame->n_vectors;
 400   if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY)
 401     n_left =
 402       memif_interface_tx_zc_inline (vm, node, from, mif, mq, ptd, n_left);
 403   else if (mif->flags & MEMIF_IF_FLAG_IS_SLAVE)
 404     n_left = memif_interface_tx_inline (vm, node, from, mif, MEMIF_RING_S2M,
 405                                         mq, ptd, n_left);
 406   else
 407     n_left = memif_interface_tx_inline (vm, node, from, mif, MEMIF_RING_M2S,
 408                                         mq, ptd, n_left);
 409
 410   clib_spinlock_unlock_if_init (&mif->lockp);
 411
 412   if (n_left)
 413     vlib_error_count (vm, node->node_index, MEMIF_TX_ERROR_NO_FREE_SLOTS,
 414                       n_left);
 415
 416   if ((mq->ring->flags & MEMIF_RING_FLAG_MASK_INT) == 0 && mq->int_fd > -1)
 417     {
 418       u64 b = 1;
 419       int __clib_unused r = write (mq->int_fd, &b, sizeof (b));
 420       mq->int_count++;
 421     }
 422
 423   if ((mif->flags & MEMIF_IF_FLAG_ZERO_COPY) == 0)
 424     vlib_buffer_free (vm, from, frame->n_vectors);
 425   else if (n_left)
 426     vlib_buffer_free (vm, from + frame->n_vectors - n_left, n_left);
 427
 428   return frame->n_vectors - n_left;
 429 }
 430
 431 static void
 432 memif_set_interface_next_node (vnet_main_t * vnm, u32 hw_if_index,
 433                                u32 node_index)
 434 {
 435   memif_main_t *apm = &memif_main;
 436   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
 437   memif_if_t *mif = pool_elt_at_index (apm->interfaces, hw->dev_instance);
 438
 439   /* Shut off redirection */
 440   if (node_index == ~0)
 441     {
 442       mif->per_interface_next_index = node_index;
 443       return;
 444     }
 445
 446   mif->per_interface_next_index =
 447     vlib_node_add_next (vlib_get_main (), memif_input_node.index, node_index);
 448 }
 449
 450 static void
 451 memif_clear_hw_interface_counters (u32 instance)
 452 {
 453   /* Nothing for now */
 454 }
 455
 456 static clib_error_t *
 457 memif_interface_rx_mode_change (vnet_main_t * vnm, u32 hw_if_index, u32 qid,
 458                                 vnet_hw_if_rx_mode mode)
 459 {
 460   memif_main_t *mm = &memif_main;
 461   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
 462   memif_if_t *mif = pool_elt_at_index (mm->interfaces, hw->dev_instance);
 463   memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, qid);
 464
 465   if (mode == VNET_HW_IF_RX_MODE_POLLING)
 466     mq->ring->flags |= MEMIF_RING_FLAG_MASK_INT;
 467   else
 468     mq->ring->flags &= ~MEMIF_RING_FLAG_MASK_INT;
 469
 470   return 0;
 471 }
 472
 473 static clib_error_t *
 474 memif_subif_add_del_function (vnet_main_t * vnm,
 475                               u32 hw_if_index,
 476                               struct vnet_sw_interface_t *st, int is_add)
 477 {
 478   /* Nothing for now */
 479   return 0;
 480 }
 481
 482 /* *INDENT-OFF* */
 483 VNET_DEVICE_CLASS (memif_device_class) = {
 484   .name = "memif",
 485   .format_device_name = format_memif_device_name,
 486   .format_device = format_memif_device,
 487   .format_tx_trace = format_memif_tx_trace,
 488   .tx_function_n_errors = MEMIF_TX_N_ERROR,
 489   .tx_function_error_counters = memif_tx_func_error_counters,
 490   .rx_redirect_to_node = memif_set_interface_next_node,
 491   .clear_counters = memif_clear_hw_interface_counters,
 492   .admin_up_down_function = memif_interface_admin_up_down,
 493   .subif_add_del_function = memif_subif_add_del_function,
 494   .rx_mode_change_function = memif_interface_rx_mode_change,
 495 };
 496
 497 /* *INDENT-ON* */
 498
 499 /*
 500  * fd.io coding-style-patch-verification: ON
 501  *
 502  * Local Variables:
 503  * eval: (c-set-style "gnu")
 504  * End:
 505  */