src/plugins/avf/input.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2018 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 #include <vlib/vlib.h>
  19 #include <vlib/unix/unix.h>
  20 #include <vlib/pci/pci.h>
  21 #include <vnet/ethernet/ethernet.h>
  22 #include <vnet/devices/devices.h>
  23
  24 #include <avf/avf.h>
  25
  26 #define foreach_avf_input_error \
  27   _(BUFFER_ALLOC, "buffer alloc error") \
  28   _(RX_PACKET_ERROR, "Rx packet errors")
  29
  30 typedef enum
  31 {
  32 #define _(f,s) AVF_INPUT_ERROR_##f,
  33   foreach_avf_input_error
  34 #undef _
  35     AVF_INPUT_N_ERROR,
  36 } avf_input_error_t;
  37
  38 static __clib_unused char *avf_input_error_strings[] = {
  39 #define _(n,s) s,
  40   foreach_avf_input_error
  41 #undef _
  42 };
  43
  44 #define AVF_RX_DESC_STATUS(x)           (1 << x)
  45 #define AVF_RX_DESC_STATUS_DD           AVF_RX_DESC_STATUS(0)
  46 #define AVF_RX_DESC_STATUS_EOP          AVF_RX_DESC_STATUS(1)
  47
  48 #define AVF_INPUT_REFILL_TRESHOLD 32
  49 static_always_inline void
  50 avf_rxq_refill (vlib_main_t * vm, vlib_node_runtime_t * node, avf_rxq_t * rxq,
  51                 int use_va_dma)
  52 {
  53   u16 n_refill, mask, n_alloc, slot;
  54   u32 s0, s1, s2, s3;
  55   vlib_buffer_t *b[4];
  56   avf_rx_desc_t *d[4];
  57
  58   n_refill = rxq->size - 1 - rxq->n_enqueued;
  59   if (PREDICT_TRUE (n_refill <= AVF_INPUT_REFILL_TRESHOLD))
  60     return;
  61
  62   mask = rxq->size - 1;
  63   slot = (rxq->next - n_refill - 1) & mask;
  64
  65   n_refill &= ~7;               /* round to 8 */
  66   n_alloc = vlib_buffer_alloc_to_ring (vm, rxq->bufs, slot, rxq->size,
  67                                        n_refill);
  68
  69   if (PREDICT_FALSE (n_alloc != n_refill))
  70     {
  71       vlib_error_count (vm, node->node_index,
  72                         AVF_INPUT_ERROR_BUFFER_ALLOC, 1);
  73       if (n_alloc)
  74         vlib_buffer_free_from_ring (vm, rxq->bufs, slot, rxq->size, n_alloc);
  75       return;
  76     }
  77
  78   rxq->n_enqueued += n_alloc;
  79
  80   while (n_alloc >= 4)
  81     {
  82       if (PREDICT_TRUE (slot + 3 < rxq->size))
  83         {
  84           s0 = slot;
  85           s1 = slot + 1;
  86           s2 = slot + 2;
  87           s3 = slot + 3;
  88         }
  89       else
  90         {
  91           s0 = slot;
  92           s1 = (slot + 1) & mask;
  93           s2 = (slot + 2) & mask;
  94           s3 = (slot + 3) & mask;
  95         }
  96
  97       d[0] = ((avf_rx_desc_t *) rxq->descs) + s0;
  98       d[1] = ((avf_rx_desc_t *) rxq->descs) + s1;
  99       d[2] = ((avf_rx_desc_t *) rxq->descs) + s2;
 100       d[3] = ((avf_rx_desc_t *) rxq->descs) + s3;
 101       b[0] = vlib_get_buffer (vm, rxq->bufs[s0]);
 102       b[1] = vlib_get_buffer (vm, rxq->bufs[s1]);
 103       b[2] = vlib_get_buffer (vm, rxq->bufs[s2]);
 104       b[3] = vlib_get_buffer (vm, rxq->bufs[s3]);
 105
 106       if (use_va_dma)
 107         {
 108           d[0]->qword[0] = vlib_buffer_get_va (b[0]);
 109           d[1]->qword[0] = vlib_buffer_get_va (b[1]);
 110           d[2]->qword[0] = vlib_buffer_get_va (b[2]);
 111           d[3]->qword[0] = vlib_buffer_get_va (b[3]);
 112         }
 113       else
 114         {
 115           d[0]->qword[0] = vlib_buffer_get_pa (vm, b[0]);
 116           d[1]->qword[0] = vlib_buffer_get_pa (vm, b[1]);
 117           d[2]->qword[0] = vlib_buffer_get_pa (vm, b[2]);
 118           d[3]->qword[0] = vlib_buffer_get_pa (vm, b[3]);
 119         }
 120
 121       d[0]->qword[1] = 0;
 122       d[1]->qword[1] = 0;
 123       d[2]->qword[1] = 0;
 124       d[3]->qword[1] = 0;
 125
 126       /* next */
 127       slot = (slot + 4) & mask;
 128       n_alloc -= 4;
 129     }
 130   while (n_alloc)
 131     {
 132       s0 = slot;
 133       d[0] = ((avf_rx_desc_t *) rxq->descs) + s0;
 134       b[0] = vlib_get_buffer (vm, rxq->bufs[s0]);
 135       if (use_va_dma)
 136         d[0]->qword[0] = vlib_buffer_get_va (b[0]);
 137       else
 138         d[0]->qword[0] = vlib_buffer_get_pa (vm, b[0]);
 139       d[0]->qword[1] = 0;
 140
 141       /* next */
 142       slot = (slot + 1) & mask;
 143       n_alloc -= 1;
 144     }
 145
 146   CLIB_MEMORY_BARRIER ();
 147   *(rxq->qrx_tail) = slot;
 148 }
 149
 150 static_always_inline uword
 151 avf_process_rx_burst (vlib_main_t * vm, vlib_node_runtime_t * node,
 152                       vlib_buffer_t * bt, avf_rx_vector_entry_t * rxve,
 153                       vlib_buffer_t ** b, u32 n_rxv)
 154 {
 155   uword n_rx_bytes = 0;
 156
 157   while (n_rxv >= 4)
 158     {
 159       if (n_rxv >= 12)
 160         {
 161           vlib_prefetch_buffer_header (b[8], LOAD);
 162           vlib_prefetch_buffer_header (b[9], LOAD);
 163           vlib_prefetch_buffer_header (b[10], LOAD);
 164           vlib_prefetch_buffer_header (b[11], LOAD);
 165         }
 166
 167       n_rx_bytes += b[0]->current_length = rxve[0].length;
 168       n_rx_bytes += b[1]->current_length = rxve[1].length;
 169       n_rx_bytes += b[2]->current_length = rxve[2].length;
 170       n_rx_bytes += b[3]->current_length = rxve[3].length;
 171
 172       clib_memcpy_fast (vnet_buffer (b[0])->sw_if_index,
 173                         vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
 174       clib_memcpy_fast (vnet_buffer (b[1])->sw_if_index,
 175                         vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
 176       clib_memcpy_fast (vnet_buffer (b[2])->sw_if_index,
 177                         vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
 178       clib_memcpy_fast (vnet_buffer (b[3])->sw_if_index,
 179                         vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
 180
 181       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 182       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
 183       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]);
 184       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]);
 185
 186       /* next */
 187       rxve += 4;
 188       b += 4;
 189       n_rxv -= 4;
 190     }
 191   while (n_rxv)
 192     {
 193       b[0]->current_length = rxve->length;
 194       n_rx_bytes += b[0]->current_length;
 195
 196       clib_memcpy_fast (vnet_buffer (b[0])->sw_if_index,
 197                         vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
 198
 199       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 200
 201       /* next */
 202       rxve += 1;
 203       b += 1;
 204       n_rxv -= 1;
 205     }
 206   return n_rx_bytes;
 207 }
 208
 209 static_always_inline uword
 210 avf_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 211                          vlib_frame_t * frame, avf_device_t * ad, u16 qid)
 212 {
 213   avf_main_t *am = &avf_main;
 214   vnet_main_t *vnm = vnet_get_main ();
 215   u32 thr_idx = vlib_get_thread_index ();
 216   avf_per_thread_data_t *ptd =
 217     vec_elt_at_index (am->per_thread_data, thr_idx);
 218   avf_rxq_t *rxq = vec_elt_at_index (ad->rxqs, qid);
 219   avf_rx_vector_entry_t *rxve = 0;
 220   uword n_trace;
 221   avf_rx_desc_t *d;
 222   u32 n_rx_packets = 0, n_rx_bytes = 0;
 223   u16 mask = rxq->size - 1;
 224   u16 n_rxv = 0;
 225   u8 or_error = 0;
 226   u32 *bi;
 227   vlib_buffer_t *bufs[AVF_RX_VECTOR_SZ];
 228   vlib_buffer_t *bt = &ptd->buffer_template;
 229   u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 230
 231   STATIC_ASSERT_SIZEOF (avf_rx_vector_entry_t, 8);
 232   STATIC_ASSERT_OFFSET_OF (avf_rx_vector_entry_t, status, 0);
 233   STATIC_ASSERT_OFFSET_OF (avf_rx_vector_entry_t, length, 4);
 234   STATIC_ASSERT_OFFSET_OF (avf_rx_vector_entry_t, ptype, 6);
 235   STATIC_ASSERT_OFFSET_OF (avf_rx_vector_entry_t, error, 7);
 236
 237   /* is there anything on the ring */
 238   d = rxq->descs + rxq->next;
 239   if ((d->qword[1] & AVF_RX_DESC_STATUS_DD) == 0)
 240     goto done;
 241
 242   u32 *to_next, n_left_to_next;
 243   if (PREDICT_FALSE (ad->per_interface_next_index != ~0))
 244     next_index = ad->per_interface_next_index;
 245   vlib_get_new_next_frame (vm, node, next_index, to_next, n_left_to_next);
 246
 247   /* fetch up to AVF_RX_VECTOR_SZ from the rx ring, unflatten them and
 248      copy needed data from descriptor to rx vector */
 249   bi = to_next;
 250   while (n_rxv < AVF_RX_VECTOR_SZ)
 251     {
 252       if (rxq->next + 11 < rxq->size)
 253         {
 254           int stride = 8;
 255           CLIB_PREFETCH ((void *) (rxq->descs + (rxq->next + stride)),
 256                          CLIB_CACHE_LINE_BYTES, LOAD);
 257           CLIB_PREFETCH ((void *) (rxq->descs + (rxq->next + stride + 1)),
 258                          CLIB_CACHE_LINE_BYTES, LOAD);
 259           CLIB_PREFETCH ((void *) (rxq->descs + (rxq->next + stride + 2)),
 260                          CLIB_CACHE_LINE_BYTES, LOAD);
 261           CLIB_PREFETCH ((void *) (rxq->descs + (rxq->next + stride + 3)),
 262                          CLIB_CACHE_LINE_BYTES, LOAD);
 263         }
 264
 265 #ifdef CLIB_HAVE_VEC256
 266       u64x4 q1x4, v, err4;
 267       u64x4 status_dd_eop_mask = u64x4_splat (0x3);
 268
 269       if (n_rxv >= AVF_RX_VECTOR_SZ - 4)
 270         goto one_by_one;
 271
 272       if (rxq->next >= rxq->size - 4)
 273         goto one_by_one;
 274
 275       /* load 1st quadword of 4 dscriptors into 256-bit vector register */
 276       /* *INDENT-OFF* */
 277       q1x4 = (u64x4) {
 278           d[0].qword[1],
 279           d[1].qword[1],
 280           d[2].qword[1],
 281           d[3].qword[1]
 282       };
 283       /* *INDENT-ON* */
 284
 285       /* not all packets are ready or at least one of them is chained */
 286       if (!u64x4_is_equal (q1x4 & status_dd_eop_mask, status_dd_eop_mask))
 287         goto one_by_one;
 288
 289       /* shift and mask status, length, ptype and err */
 290       v = q1x4 & u64x4_splat ((u64) 0x3FFFFULL);
 291       v |= (q1x4 >> 6) & u64x4_splat ((u64) 0xFFFF << 32);
 292       v |= (q1x4 << 18) & u64x4_splat ((u64) 0xFF << 48);
 293       v |= err4 = (q1x4 << 37) & u64x4_splat ((u64) 0xFF << 56);
 294
 295       u64x4_store_unaligned (v, ptd->rx_vector + n_rxv);
 296
 297       if (!u64x4_is_all_zero (err4))
 298         or_error |= err4[0] | err4[1] | err4[2] | err4[3];
 299
 300       clib_memcpy_fast (bi, rxq->bufs + rxq->next, 4 * sizeof (u32));
 301
 302       /* next */
 303       rxq->next = (rxq->next + 4) & mask;
 304       d = rxq->descs + rxq->next;
 305       n_rxv += 4;
 306       rxq->n_enqueued -= 4;
 307       bi += 4;
 308       continue;
 309     one_by_one:
 310 #endif
 311       CLIB_PREFETCH ((void *) (rxq->descs + ((rxq->next + 8) & mask)),
 312                      CLIB_CACHE_LINE_BYTES, LOAD);
 313       if ((d->qword[1] & AVF_RX_DESC_STATUS_DD) == 0)
 314         break;
 315       rxve = ptd->rx_vector + n_rxv;
 316       bi[0] = rxq->bufs[rxq->next];
 317       rxve->status = avf_get_u64_bits ((void *) d, 8, 18, 0);
 318       rxve->error = avf_get_u64_bits ((void *) d, 8, 26, 19);
 319       rxve->ptype = avf_get_u64_bits ((void *) d, 8, 37, 30);
 320       rxve->length = avf_get_u64_bits ((void *) d, 8, 63, 38);
 321       or_error |= rxve->error;
 322
 323       /* deal with chained buffers */
 324       while (PREDICT_FALSE ((d->qword[1] & AVF_RX_DESC_STATUS_EOP) == 0))
 325         {
 326           clib_error ("fixme");
 327         }
 328
 329       /* next */
 330       rxq->next = (rxq->next + 1) & mask;
 331       d = rxq->descs + rxq->next;
 332       n_rxv++;
 333       rxq->n_enqueued--;
 334       bi++;
 335     }
 336
 337   if (n_rxv == 0)
 338     goto done;
 339
 340   /* refill rx ring */
 341   if (ad->flags & AVF_DEVICE_F_VA_DMA)
 342     avf_rxq_refill (vm, node, rxq, 1 /* use_va_dma */ );
 343   else
 344     avf_rxq_refill (vm, node, rxq, 0 /* use_va_dma */ );
 345
 346   vlib_get_buffers (vm, to_next, bufs, n_rxv);
 347   n_rx_packets = n_rxv;
 348
 349   vnet_buffer (bt)->sw_if_index[VLIB_RX] = ad->sw_if_index;
 350   vnet_buffer (bt)->sw_if_index[VLIB_TX] = ~0;
 351
 352   n_rx_bytes = avf_process_rx_burst (vm, node, bt, ptd->rx_vector, bufs,
 353                                      n_rxv);
 354
 355   /* packet trace if enabled */
 356   if (PREDICT_FALSE ((n_trace = vlib_get_trace_count (vm, node))))
 357     {
 358       u32 n_left = n_rx_packets;
 359       bi = to_next;
 360       while (n_trace && n_left)
 361         {
 362           vlib_buffer_t *b;
 363           avf_input_trace_t *tr;
 364           b = vlib_get_buffer (vm, bi[0]);
 365           vlib_trace_buffer (vm, node, next_index, b, /* follow_chain */ 0);
 366           tr = vlib_add_trace (vm, node, b, sizeof (*tr));
 367           tr->next_index = next_index;
 368           tr->hw_if_index = ad->hw_if_index;
 369           clib_memcpy_fast (&tr->rxve, rxve, sizeof (avf_rx_vector_entry_t));
 370
 371           /* next */
 372           n_trace--;
 373           n_left--;
 374           bi++;
 375         }
 376       vlib_set_trace_count (vm, node, n_trace);
 377     }
 378
 379   if (PREDICT_TRUE (next_index == VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT))
 380     {
 381       vlib_next_frame_t *nf;
 382       vlib_frame_t *f;
 383       ethernet_input_frame_t *ef;
 384       nf = vlib_node_runtime_get_next_frame (vm, node, next_index);
 385       f = vlib_get_frame (vm, nf->frame_index);
 386       f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX;
 387
 388       ef = vlib_frame_scalar_args (f);
 389       ef->sw_if_index = ad->sw_if_index;
 390       ef->hw_if_index = ad->hw_if_index;
 391
 392       if ((or_error & (1 << 3)) == 0)
 393         f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK;
 394     }
 395   n_left_to_next -= n_rx_packets;
 396   vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 397
 398   vlib_increment_combined_counter (vnm->interface_main.combined_sw_if_counters
 399                                    + VNET_INTERFACE_COUNTER_RX, thr_idx,
 400                                    ad->hw_if_index, n_rx_packets, n_rx_bytes);
 401
 402 done:
 403   return n_rx_packets;
 404 }
 405
 406 VLIB_NODE_FN (avf_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
 407                                vlib_frame_t * frame)
 408 {
 409   u32 n_rx = 0;
 410   avf_main_t *am = &avf_main;
 411   vnet_device_input_runtime_t *rt = (void *) node->runtime_data;
 412   vnet_device_and_queue_t *dq;
 413
 414   foreach_device_and_queue (dq, rt->devices_and_queues)
 415   {
 416     avf_device_t *ad;
 417     ad = vec_elt_at_index (am->devices, dq->dev_instance);
 418     if ((ad->flags & AVF_DEVICE_F_ADMIN_UP) == 0)
 419       continue;
 420     n_rx += avf_device_input_inline (vm, node, frame, ad, dq->queue_id);
 421   }
 422   return n_rx;
 423 }
 424
 425 /* *INDENT-OFF* */
 426 VLIB_REGISTER_NODE (avf_input_node) = {
 427   .name = "avf-input",
 428   .sibling_of = "device-input",
 429   .format_trace = format_avf_input_trace,
 430   .type = VLIB_NODE_TYPE_INPUT,
 431   .state = VLIB_NODE_STATE_DISABLED,
 432   .n_errors = AVF_INPUT_N_ERROR,
 433   .error_strings = avf_input_error_strings,
 434 };
 435
 436 /* *INDENT-ON* */
 437
 438
 439 /*
 440  * fd.io coding-style-patch-verification: ON
 441  *
 442  * Local Variables:
 443  * eval: (c-set-style "gnu")
 444  * End:
 445  */