src/plugins/avf/output.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 <vppinfra/ring.h>
  22
  23 #include <vnet/ethernet/ethernet.h>
  24 #include <vnet/ip/ip4_packet.h>
  25 #include <vnet/ip/ip6_packet.h>
  26 #include <vnet/udp/udp_packet.h>
  27 #include <vnet/tcp/tcp_packet.h>
  28
  29 #include <vnet/devices/devices.h>
  30
  31 #include <avf/avf.h>
  32
  33 static_always_inline u8
  34 avf_tx_desc_get_dtyp (avf_tx_desc_t * d)
  35 {
  36   return d->qword[1] & 0x0f;
  37 }
  38
  39 struct avf_ip4_psh
  40 {
  41   u32 src;
  42   u32 dst;
  43   u8 zero;
  44   u8 proto;
  45   u16 l4len;
  46 };
  47
  48 struct avf_ip6_psh
  49 {
  50   u32 src[4];
  51   u32 dst[4];
  52   u32 l4len;
  53   u32 proto;
  54 };
  55
  56 static_always_inline u64
  57 avf_tx_prepare_cksum (vlib_buffer_t * b, u8 is_tso)
  58 {
  59   u64 flags = 0;
  60   if (!is_tso && !(b->flags & ((VNET_BUFFER_F_OFFLOAD_IP_CKSUM |
  61                                 VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
  62                                 VNET_BUFFER_F_OFFLOAD_UDP_CKSUM))))
  63     return 0;
  64   u32 is_tcp = is_tso || b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
  65   u32 is_udp = !is_tso && b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM;
  66   u32 is_ip4 = b->flags & VNET_BUFFER_F_IS_IP4;
  67   u32 is_ip6 = b->flags & VNET_BUFFER_F_IS_IP6;
  68   ASSERT (!is_tcp || !is_udp);
  69   ASSERT (is_ip4 || is_ip6);
  70   i16 l2_hdr_offset = vnet_buffer (b)->l2_hdr_offset;
  71   i16 l3_hdr_offset = vnet_buffer (b)->l3_hdr_offset;
  72   i16 l4_hdr_offset = vnet_buffer (b)->l4_hdr_offset;
  73   u16 l2_len = l3_hdr_offset - l2_hdr_offset;
  74   u16 l3_len = l4_hdr_offset - l3_hdr_offset;
  75   ip4_header_t *ip4 = (void *) (b->data + l3_hdr_offset);
  76   ip6_header_t *ip6 = (void *) (b->data + l3_hdr_offset);
  77   tcp_header_t *tcp = (void *) (b->data + l4_hdr_offset);
  78   udp_header_t *udp = (void *) (b->data + l4_hdr_offset);
  79   u16 l4_len =
  80     is_tcp ? tcp_header_bytes (tcp) : is_udp ? sizeof (udp_header_t) : 0;
  81   u16 sum = 0;
  82
  83   flags |= AVF_TXD_OFFSET_MACLEN (l2_len) |
  84     AVF_TXD_OFFSET_IPLEN (l3_len) | AVF_TXD_OFFSET_L4LEN (l4_len);
  85   flags |= is_ip4 ? AVF_TXD_CMD_IIPT_IPV4 : AVF_TXD_CMD_IIPT_IPV6;
  86   flags |= is_tcp ? AVF_TXD_CMD_L4T_TCP : is_udp ? AVF_TXD_CMD_L4T_UDP : 0;
  87
  88   if (is_ip4)
  89     ip4->checksum = 0;
  90
  91   if (is_tcp || is_udp)
  92     {
  93       if (is_ip4)
  94         {
  95           struct avf_ip4_psh psh = { 0 };
  96           psh.src = ip4->src_address.as_u32;
  97           psh.dst = ip4->dst_address.as_u32;
  98           psh.proto = ip4->protocol;
  99           psh.l4len =
 100             is_tso ? 0 :
 101             clib_host_to_net_u16 (clib_net_to_host_u16 (ip4->length) -
 102                                   (l4_hdr_offset - l3_hdr_offset));
 103           sum = ~ip_csum (&psh, sizeof (psh));
 104         }
 105       else
 106         {
 107           struct avf_ip6_psh psh = { 0 };
 108           clib_memcpy_fast (&psh.src, &ip6->src_address, 32);
 109           psh.proto = clib_host_to_net_u32 ((u32) ip6->protocol);
 110           psh.l4len = is_tso ? 0 : ip6->payload_length;
 111           sum = ~ip_csum (&psh, sizeof (psh));
 112         }
 113     }
 114   /* ip_csum does a byte swap for some reason... */
 115   sum = clib_net_to_host_u16 (sum);
 116   if (is_tcp)
 117     tcp->checksum = sum;
 118   else if (is_udp)
 119     udp->checksum = sum;
 120   return flags;
 121 }
 122
 123 static_always_inline u16
 124 avf_tx_enqueue (vlib_main_t * vm, vlib_node_runtime_t * node, avf_txq_t * txq,
 125                 u32 * buffers, u32 n_packets, int use_va_dma)
 126 {
 127   u16 next = txq->next;
 128   u64 bits = AVF_TXD_CMD_EOP | AVF_TXD_CMD_RSV;
 129   u64 one_by_one_offload_flags = 0;
 130   u16 n_desc = 0;
 131   u16 *slot, n_desc_left, n_packets_left = n_packets;
 132   u16 mask = txq->size - 1;
 133   vlib_buffer_t *b[4];
 134   avf_tx_desc_t *d = txq->descs + next;
 135   u16 n_desc_needed;
 136   vlib_buffer_t *b0;
 137
 138   /* avoid ring wrap */
 139   n_desc_left = txq->size - clib_max (txq->next, txq->n_enqueued + 8);
 140
 141   if (n_desc_left == 0)
 142     return 0;
 143
 144   /* Fast path, no ring wrap */
 145   while (n_packets_left && n_desc_left)
 146     {
 147       u32 or_flags;
 148       if (n_packets_left < 8 || n_desc_left < 4)
 149         goto one_by_one;
 150
 151       vlib_prefetch_buffer_with_index (vm, buffers[4], LOAD);
 152       vlib_prefetch_buffer_with_index (vm, buffers[5], LOAD);
 153       vlib_prefetch_buffer_with_index (vm, buffers[6], LOAD);
 154       vlib_prefetch_buffer_with_index (vm, buffers[7], LOAD);
 155
 156       b[0] = vlib_get_buffer (vm, buffers[0]);
 157       b[1] = vlib_get_buffer (vm, buffers[1]);
 158       b[2] = vlib_get_buffer (vm, buffers[2]);
 159       b[3] = vlib_get_buffer (vm, buffers[3]);
 160
 161       or_flags = b[0]->flags | b[1]->flags | b[2]->flags | b[3]->flags;
 162
 163       if (or_flags &
 164           (VLIB_BUFFER_NEXT_PRESENT | VNET_BUFFER_F_OFFLOAD_IP_CKSUM |
 165            VNET_BUFFER_F_OFFLOAD_TCP_CKSUM | VNET_BUFFER_F_OFFLOAD_UDP_CKSUM))
 166         goto one_by_one;
 167
 168       vlib_buffer_copy_indices (txq->bufs + next, buffers, 4);
 169
 170       if (use_va_dma)
 171         {
 172           d[0].qword[0] = vlib_buffer_get_current_va (b[0]);
 173           d[1].qword[0] = vlib_buffer_get_current_va (b[1]);
 174           d[2].qword[0] = vlib_buffer_get_current_va (b[2]);
 175           d[3].qword[0] = vlib_buffer_get_current_va (b[3]);
 176         }
 177       else
 178         {
 179           d[0].qword[0] = vlib_buffer_get_current_pa (vm, b[0]);
 180           d[1].qword[0] = vlib_buffer_get_current_pa (vm, b[1]);
 181           d[2].qword[0] = vlib_buffer_get_current_pa (vm, b[2]);
 182           d[3].qword[0] = vlib_buffer_get_current_pa (vm, b[3]);
 183         }
 184
 185       d[0].qword[1] = ((u64) b[0]->current_length) << 34 | bits;
 186       d[1].qword[1] = ((u64) b[1]->current_length) << 34 | bits;
 187       d[2].qword[1] = ((u64) b[2]->current_length) << 34 | bits;
 188       d[3].qword[1] = ((u64) b[3]->current_length) << 34 | bits;
 189
 190       next += 4;
 191       n_desc += 4;
 192       buffers += 4;
 193       n_packets_left -= 4;
 194       n_desc_left -= 4;
 195       d += 4;
 196       continue;
 197
 198     one_by_one:
 199       one_by_one_offload_flags = 0;
 200       txq->bufs[next] = buffers[0];
 201       b[0] = vlib_get_buffer (vm, buffers[0]);
 202
 203       if (PREDICT_FALSE (b[0]->flags & (VNET_BUFFER_F_OFFLOAD_IP_CKSUM |
 204                                         VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
 205                                         VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)))
 206         one_by_one_offload_flags |=
 207           avf_tx_prepare_cksum (b[0], 0 /* no TSO */ );
 208
 209       /* Deal with chain buffer if present */
 210       if (b[0]->flags & VLIB_BUFFER_NEXT_PRESENT)
 211         {
 212           n_desc_needed = 1;
 213           b0 = b[0];
 214
 215           /* Wish there were a buffer count for chain buffer */
 216           while (b0->flags & VLIB_BUFFER_NEXT_PRESENT)
 217             {
 218               b0 = vlib_get_buffer (vm, b0->next_buffer);
 219               n_desc_needed++;
 220             }
 221
 222           /* spec says data descriptor is limited to 8 segments */
 223           if (PREDICT_FALSE (n_desc_needed > 8))
 224             {
 225               vlib_buffer_free_one (vm, buffers[0]);
 226               vlib_error_count (vm, node->node_index,
 227                                 AVF_TX_ERROR_SEGMENT_SIZE_EXCEEDED, 1);
 228               n_packets_left -= 1;
 229               buffers += 1;
 230               continue;
 231             }
 232
 233           if (PREDICT_FALSE (n_desc_left < n_desc_needed))
 234             /*
 235              * Slow path may be able to to deal with this since it can handle
 236              * ring wrap
 237              */
 238             break;
 239
 240           while (b[0]->flags & VLIB_BUFFER_NEXT_PRESENT)
 241             {
 242               if (use_va_dma)
 243                 d[0].qword[0] = vlib_buffer_get_current_va (b[0]);
 244               else
 245                 d[0].qword[0] = vlib_buffer_get_current_pa (vm, b[0]);
 246
 247               d[0].qword[1] = (((u64) b[0]->current_length) << 34) |
 248                 AVF_TXD_CMD_RSV | one_by_one_offload_flags;
 249
 250               next += 1;
 251               n_desc += 1;
 252               n_desc_left -= 1;
 253               d += 1;
 254
 255               txq->bufs[next] = b[0]->next_buffer;
 256               b[0] = vlib_get_buffer (vm, b[0]->next_buffer);
 257             }
 258         }
 259
 260       if (use_va_dma)
 261         d[0].qword[0] = vlib_buffer_get_current_va (b[0]);
 262       else
 263         d[0].qword[0] = vlib_buffer_get_current_pa (vm, b[0]);
 264
 265       d[0].qword[1] =
 266         (((u64) b[0]->current_length) << 34) | bits |
 267         one_by_one_offload_flags;
 268
 269       next += 1;
 270       n_desc += 1;
 271       buffers += 1;
 272       n_packets_left -= 1;
 273       n_desc_left -= 1;
 274       d += 1;
 275     }
 276
 277   /* Slow path to support ring wrap */
 278   if (PREDICT_FALSE (n_packets_left))
 279     {
 280       txq->n_enqueued += n_desc;
 281
 282       n_desc = 0;
 283       d = txq->descs + (next & mask);
 284
 285       /* +8 to be consistent with fast path */
 286       n_desc_left = txq->size - (txq->n_enqueued + 8);
 287
 288       while (n_packets_left && n_desc_left)
 289         {
 290
 291           txq->bufs[next & mask] = buffers[0];
 292           b[0] = vlib_get_buffer (vm, buffers[0]);
 293
 294           one_by_one_offload_flags = 0;
 295           if (PREDICT_FALSE (b[0]->flags & (VNET_BUFFER_F_OFFLOAD_IP_CKSUM |
 296                                             VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
 297                                             VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)))
 298             one_by_one_offload_flags |=
 299               avf_tx_prepare_cksum (b[0], 0 /* no TSO */ );
 300
 301           /* Deal with chain buffer if present */
 302           if (b[0]->flags & VLIB_BUFFER_NEXT_PRESENT)
 303             {
 304               n_desc_needed = 1;
 305               b0 = b[0];
 306
 307               while (b0->flags & VLIB_BUFFER_NEXT_PRESENT)
 308                 {
 309                   b0 = vlib_get_buffer (vm, b0->next_buffer);
 310                   n_desc_needed++;
 311                 }
 312
 313               /* Spec says data descriptor is limited to 8 segments */
 314               if (PREDICT_FALSE (n_desc_needed > 8))
 315                 {
 316                   vlib_buffer_free_one (vm, buffers[0]);
 317                   vlib_error_count (vm, node->node_index,
 318                                     AVF_TX_ERROR_SEGMENT_SIZE_EXCEEDED, 1);
 319                   n_packets_left -= 1;
 320                   buffers += 1;
 321                   continue;
 322                 }
 323
 324               if (PREDICT_FALSE (n_desc_left < n_desc_needed))
 325                 break;
 326
 327               while (b[0]->flags & VLIB_BUFFER_NEXT_PRESENT)
 328                 {
 329                   if (use_va_dma)
 330                     d[0].qword[0] = vlib_buffer_get_current_va (b[0]);
 331                   else
 332                     d[0].qword[0] = vlib_buffer_get_current_pa (vm, b[0]);
 333
 334                   d[0].qword[1] = (((u64) b[0]->current_length) << 34) |
 335                     AVF_TXD_CMD_RSV | one_by_one_offload_flags;
 336
 337                   next += 1;
 338                   n_desc += 1;
 339                   n_desc_left -= 1;
 340                   d = txq->descs + (next & mask);
 341
 342                   txq->bufs[next & mask] = b[0]->next_buffer;
 343                   b[0] = vlib_get_buffer (vm, b[0]->next_buffer);
 344                 }
 345             }
 346
 347           if (use_va_dma)
 348             d[0].qword[0] = vlib_buffer_get_current_va (b[0]);
 349           else
 350             d[0].qword[0] = vlib_buffer_get_current_pa (vm, b[0]);
 351
 352           d[0].qword[1] =
 353             (((u64) b[0]->current_length) << 34) | bits |
 354             one_by_one_offload_flags;
 355
 356           next += 1;
 357           n_desc += 1;
 358           buffers += 1;
 359           n_packets_left -= 1;
 360           n_desc_left -= 1;
 361           d = txq->descs + (next & mask);
 362         }
 363     }
 364
 365   if ((slot = clib_ring_enq (txq->rs_slots)))
 366     {
 367       u16 rs_slot = slot[0] = (next - 1) & mask;
 368       d = txq->descs + rs_slot;
 369       d[0].qword[1] |= AVF_TXD_CMD_RS;
 370     }
 371
 372   txq->next = next & mask;
 373   clib_atomic_store_rel_n (txq->qtx_tail, txq->next);
 374   txq->n_enqueued += n_desc;
 375   return n_packets - n_packets_left;
 376 }
 377
 378 VNET_DEVICE_CLASS_TX_FN (avf_device_class) (vlib_main_t * vm,
 379                                             vlib_node_runtime_t * node,
 380                                             vlib_frame_t * frame)
 381 {
 382   vnet_interface_output_runtime_t *rd = (void *) node->runtime_data;
 383   avf_device_t *ad = avf_get_device (rd->dev_instance);
 384   u32 thread_index = vm->thread_index;
 385   u8 qid = thread_index;
 386   avf_txq_t *txq = vec_elt_at_index (ad->txqs, qid % ad->num_queue_pairs);
 387   u32 *buffers = vlib_frame_vector_args (frame);
 388   u16 n_enq, n_left;
 389   u16 n_retry = 2;
 390
 391   clib_spinlock_lock_if_init (&txq->lock);
 392
 393   n_left = frame->n_vectors;
 394
 395 retry:
 396   /* release consumed bufs */
 397   if (txq->n_enqueued)
 398     {
 399       i32 complete_slot = -1;
 400       while (1)
 401         {
 402           u16 *slot = clib_ring_get_first (txq->rs_slots);
 403
 404           if (slot == 0)
 405             break;
 406
 407           if (avf_tx_desc_get_dtyp (txq->descs + slot[0]) != 0x0F)
 408             break;
 409
 410           complete_slot = slot[0];
 411
 412           clib_ring_deq (txq->rs_slots);
 413         }
 414
 415       if (complete_slot >= 0)
 416         {
 417           u16 first, mask, n_free;
 418           mask = txq->size - 1;
 419           first = (txq->next - txq->n_enqueued) & mask;
 420           n_free = (complete_slot + 1 - first) & mask;
 421
 422           txq->n_enqueued -= n_free;
 423           vlib_buffer_free_from_ring_no_next (vm, txq->bufs, first, txq->size,
 424                                               n_free);
 425         }
 426     }
 427
 428   if (ad->flags & AVF_DEVICE_F_VA_DMA)
 429     n_enq = avf_tx_enqueue (vm, node, txq, buffers, n_left, 1);
 430   else
 431     n_enq = avf_tx_enqueue (vm, node, txq, buffers, n_left, 0);
 432
 433   n_left -= n_enq;
 434
 435   if (n_left)
 436     {
 437       buffers += n_enq;
 438
 439       if (n_retry--)
 440         goto retry;
 441
 442       vlib_buffer_free (vm, buffers, n_left);
 443       vlib_error_count (vm, node->node_index,
 444                         AVF_TX_ERROR_NO_FREE_SLOTS, n_left);
 445     }
 446
 447   clib_spinlock_unlock_if_init (&txq->lock);
 448
 449   return frame->n_vectors - n_left;
 450 }
 451
 452 /*
 453  * fd.io coding-style-patch-verification: ON
 454  *
 455  * Local Variables:
 456  * eval: (c-set-style "gnu")
 457  * End:
 458  */