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   ip6_address_t src;
  51   ip6_address_t dst;
  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))
  61     return 0;
  62
  63   vnet_buffer_oflags_t oflags = vnet_buffer (b)->oflags;
  64   u32 is_tcp = is_tso || oflags & VNET_BUFFER_OFFLOAD_F_TCP_CKSUM;
  65   u32 is_udp = !is_tso && oflags & VNET_BUFFER_OFFLOAD_F_UDP_CKSUM;
  66
  67   if (!is_tcp && !is_udp)
  68     return 0;
  69
  70   u32 is_ip4 = b->flags & VNET_BUFFER_F_IS_IP4;
  71   u32 is_ip6 = b->flags & VNET_BUFFER_F_IS_IP6;
  72
  73   ASSERT (!(is_tcp && is_udp));
  74   ASSERT (is_ip4 || is_ip6);
  75   i16 l2_hdr_offset = b->current_data;
  76   i16 l3_hdr_offset = vnet_buffer (b)->l3_hdr_offset;
  77   i16 l4_hdr_offset = vnet_buffer (b)->l4_hdr_offset;
  78   u16 l2_len = l3_hdr_offset - l2_hdr_offset;
  79   u16 l3_len = l4_hdr_offset - l3_hdr_offset;
  80   ip4_header_t *ip4 = (void *) (b->data + l3_hdr_offset);
  81   ip6_header_t *ip6 = (void *) (b->data + l3_hdr_offset);
  82   tcp_header_t *tcp = (void *) (b->data + l4_hdr_offset);
  83   udp_header_t *udp = (void *) (b->data + l4_hdr_offset);
  84   u16 l4_len =
  85     is_tcp ? tcp_header_bytes (tcp) : is_udp ? sizeof (udp_header_t) : 0;
  86   u16 sum = 0;
  87
  88   flags |= AVF_TXD_OFFSET_MACLEN (l2_len) |
  89     AVF_TXD_OFFSET_IPLEN (l3_len) | AVF_TXD_OFFSET_L4LEN (l4_len);
  90   flags |= is_ip4 ? AVF_TXD_CMD_IIPT_IPV4 : AVF_TXD_CMD_IIPT_IPV6;
  91   flags |= is_tcp ? AVF_TXD_CMD_L4T_TCP : is_udp ? AVF_TXD_CMD_L4T_UDP : 0;
  92
  93   if (is_ip4)
  94     ip4->checksum = 0;
  95
  96   if (is_tso)
  97     {
  98       if (is_ip4)
  99         ip4->length = 0;
 100       else
 101         ip6->payload_length = 0;
 102     }
 103
 104   if (is_tcp || is_udp)
 105     {
 106       if (is_ip4)
 107         {
 108           struct avf_ip4_psh psh = { 0 };
 109           psh.src = ip4->src_address.as_u32;
 110           psh.dst = ip4->dst_address.as_u32;
 111           psh.proto = ip4->protocol;
 112           psh.l4len =
 113             is_tso ? 0 :
 114             clib_host_to_net_u16 (clib_net_to_host_u16 (ip4->length) -
 115                                   (l4_hdr_offset - l3_hdr_offset));
 116           sum = ~ip_csum (&psh, sizeof (psh));
 117         }
 118       else
 119         {
 120           struct avf_ip6_psh psh = { 0 };
 121           psh.src = ip6->src_address;
 122           psh.dst = ip6->dst_address;
 123           psh.proto = clib_host_to_net_u32 ((u32) ip6->protocol);
 124           psh.l4len = is_tso ? 0 : ip6->payload_length;
 125           sum = ~ip_csum (&psh, sizeof (psh));
 126         }
 127     }
 128   /* ip_csum does a byte swap for some reason... */
 129   sum = clib_net_to_host_u16 (sum);
 130   if (is_tcp)
 131     tcp->checksum = sum;
 132   else if (is_udp)
 133     udp->checksum = sum;
 134   return flags;
 135 }
 136
 137 static_always_inline u32
 138 avf_tx_fill_ctx_desc (vlib_main_t *vm, avf_txq_t *txq, avf_tx_desc_t *d,
 139                       vlib_buffer_t *b)
 140 {
 141   vlib_buffer_t *ctx_ph;
 142   u32 *bi = txq->ph_bufs;
 143
 144 next:
 145   ctx_ph = vlib_get_buffer (vm, bi[0]);
 146   if (PREDICT_FALSE (ctx_ph->ref_count == 255))
 147     {
 148       bi++;
 149       goto next;
 150     }
 151
 152   /* Acquire a reference on the placeholder buffer */
 153   ctx_ph->ref_count++;
 154
 155   u16 l234hdr_sz = vnet_buffer (b)->l4_hdr_offset - b->current_data +
 156                    vnet_buffer2 (b)->gso_l4_hdr_sz;
 157   u16 tlen = vlib_buffer_length_in_chain (vm, b) - l234hdr_sz;
 158   d[0].qword[0] = 0;
 159   d[0].qword[1] = AVF_TXD_DTYP_CTX | AVF_TXD_CTX_CMD_TSO
 160     | AVF_TXD_CTX_SEG_MSS (vnet_buffer2 (b)->gso_size) |
 161     AVF_TXD_CTX_SEG_TLEN (tlen);
 162   return bi[0];
 163 }
 164
 165 static_always_inline void
 166 avf_tx_copy_desc (avf_tx_desc_t *d, avf_tx_desc_t *s, u32 n_descs)
 167 {
 168 #if defined CLIB_HAVE_VEC512
 169   while (n_descs >= 8)
 170     {
 171       u64x8u *dv = (u64x8u *) d;
 172       u64x8u *sv = (u64x8u *) s;
 173
 174       dv[0] = sv[0];
 175       dv[1] = sv[1];
 176
 177       /* next */
 178       d += 8;
 179       s += 8;
 180       n_descs -= 8;
 181     }
 182 #elif defined CLIB_HAVE_VEC256
 183   while (n_descs >= 4)
 184     {
 185       u64x4u *dv = (u64x4u *) d;
 186       u64x4u *sv = (u64x4u *) s;
 187
 188       dv[0] = sv[0];
 189       dv[1] = sv[1];
 190
 191       /* next */
 192       d += 4;
 193       s += 4;
 194       n_descs -= 4;
 195     }
 196 #elif defined CLIB_HAVE_VEC128
 197   while (n_descs >= 2)
 198     {
 199       u64x2u *dv = (u64x2u *) d;
 200       u64x2u *sv = (u64x2u *) s;
 201
 202       dv[0] = sv[0];
 203       dv[1] = sv[1];
 204
 205       /* next */
 206       d += 2;
 207       s += 2;
 208       n_descs -= 2;
 209     }
 210 #endif
 211   while (n_descs)
 212     {
 213       d[0].qword[0] = s[0].qword[0];
 214       d[0].qword[1] = s[0].qword[1];
 215       d++;
 216       s++;
 217       n_descs--;
 218     }
 219 }
 220
 221 static_always_inline void
 222 avf_tx_fill_data_desc (vlib_main_t *vm, avf_tx_desc_t *d, vlib_buffer_t *b,
 223                        u64 cmd, int use_va_dma)
 224 {
 225   if (use_va_dma)
 226     d->qword[0] = vlib_buffer_get_current_va (b);
 227   else
 228     d->qword[0] = vlib_buffer_get_current_pa (vm, b);
 229   d->qword[1] = (((u64) b->current_length) << 34 | cmd | AVF_TXD_CMD_RSV);
 230 }
 231 static_always_inline u16
 232 avf_tx_prepare (vlib_main_t *vm, vlib_node_runtime_t *node, avf_txq_t *txq,
 233                 u32 *buffers, u32 n_packets, u16 *n_enq_descs, int use_va_dma)
 234 {
 235   const u64 cmd_eop = AVF_TXD_CMD_EOP;
 236   u16 n_free_desc, n_desc_left, n_packets_left = n_packets;
 237   vlib_buffer_t *b[4];
 238   avf_tx_desc_t *d = txq->tmp_descs;
 239   u32 *tb = txq->tmp_bufs;
 240
 241   n_free_desc = n_desc_left = txq->size - txq->n_enqueued - 8;
 242
 243   if (n_desc_left == 0)
 244     return 0;
 245
 246   while (n_packets_left && n_desc_left)
 247     {
 248       u32 flags, or_flags;
 249
 250       if (n_packets_left < 8 || n_desc_left < 4)
 251         goto one_by_one;
 252
 253       vlib_prefetch_buffer_with_index (vm, buffers[4], LOAD);
 254       vlib_prefetch_buffer_with_index (vm, buffers[5], LOAD);
 255       vlib_prefetch_buffer_with_index (vm, buffers[6], LOAD);
 256       vlib_prefetch_buffer_with_index (vm, buffers[7], LOAD);
 257
 258       b[0] = vlib_get_buffer (vm, buffers[0]);
 259       b[1] = vlib_get_buffer (vm, buffers[1]);
 260       b[2] = vlib_get_buffer (vm, buffers[2]);
 261       b[3] = vlib_get_buffer (vm, buffers[3]);
 262
 263       or_flags = b[0]->flags | b[1]->flags | b[2]->flags | b[3]->flags;
 264
 265       if (PREDICT_FALSE (or_flags &
 266                          (VLIB_BUFFER_NEXT_PRESENT | VNET_BUFFER_F_OFFLOAD |
 267                           VNET_BUFFER_F_GSO)))
 268         goto one_by_one;
 269
 270       vlib_buffer_copy_indices (tb, buffers, 4);
 271
 272       avf_tx_fill_data_desc (vm, d + 0, b[0], cmd_eop, use_va_dma);
 273       avf_tx_fill_data_desc (vm, d + 1, b[1], cmd_eop, use_va_dma);
 274       avf_tx_fill_data_desc (vm, d + 2, b[2], cmd_eop, use_va_dma);
 275       avf_tx_fill_data_desc (vm, d + 3, b[3], cmd_eop, use_va_dma);
 276
 277       buffers += 4;
 278       n_packets_left -= 4;
 279       n_desc_left -= 4;
 280       d += 4;
 281       tb += 4;
 282       continue;
 283
 284     one_by_one:
 285       tb[0] = buffers[0];
 286       b[0] = vlib_get_buffer (vm, buffers[0]);
 287       flags = b[0]->flags;
 288
 289       /* No chained buffers or TSO case */
 290       if (PREDICT_TRUE (
 291             (flags & (VLIB_BUFFER_NEXT_PRESENT | VNET_BUFFER_F_GSO)) == 0))
 292         {
 293           u64 cmd = cmd_eop;
 294
 295           if (PREDICT_FALSE (flags & VNET_BUFFER_F_OFFLOAD))
 296             cmd |= avf_tx_prepare_cksum (b[0], 0 /* is_tso */);
 297
 298           avf_tx_fill_data_desc (vm, d, b[0], cmd, use_va_dma);
 299         }
 300       else
 301         {
 302           u16 n_desc_needed = 1;
 303           u64 cmd = 0;
 304
 305           if (flags & VLIB_BUFFER_NEXT_PRESENT)
 306             {
 307               vlib_buffer_t *next = vlib_get_buffer (vm, b[0]->next_buffer);
 308               n_desc_needed = 2;
 309               while (next->flags & VLIB_BUFFER_NEXT_PRESENT)
 310                 {
 311                   next = vlib_get_buffer (vm, next->next_buffer);
 312                   n_desc_needed++;
 313                 }
 314             }
 315
 316           if (flags & VNET_BUFFER_F_GSO)
 317             {
 318               n_desc_needed++;
 319             }
 320           else if (PREDICT_FALSE (n_desc_needed > 8))
 321             {
 322               vlib_buffer_free_one (vm, buffers[0]);
 323               vlib_error_count (vm, node->node_index,
 324                                 AVF_TX_ERROR_SEGMENT_SIZE_EXCEEDED, 1);
 325               n_packets_left -= 1;
 326               buffers += 1;
 327               continue;
 328             }
 329
 330           if (PREDICT_FALSE (n_desc_left < n_desc_needed))
 331             break;
 332
 333           if (flags & VNET_BUFFER_F_GSO)
 334             {
 335               /* Enqueue a context descriptor */
 336               tb[1] = tb[0];
 337               tb[0] = avf_tx_fill_ctx_desc (vm, txq, d, b[0]);
 338               n_desc_left -= 1;
 339               d += 1;
 340               tb += 1;
 341               cmd = avf_tx_prepare_cksum (b[0], 1 /* is_tso */);
 342             }
 343           else if (flags & VNET_BUFFER_F_OFFLOAD)
 344             {
 345               cmd = avf_tx_prepare_cksum (b[0], 0 /* is_tso */);
 346             }
 347
 348           /* Deal with chain buffer if present */
 349           while (b[0]->flags & VLIB_BUFFER_NEXT_PRESENT)
 350             {
 351               avf_tx_fill_data_desc (vm, d, b[0], cmd, use_va_dma);
 352
 353               n_desc_left -= 1;
 354               d += 1;
 355               tb += 1;
 356
 357               tb[0] = b[0]->next_buffer;
 358               b[0] = vlib_get_buffer (vm, b[0]->next_buffer);
 359             }
 360
 361           avf_tx_fill_data_desc (vm, d, b[0], cmd_eop | cmd, use_va_dma);
 362         }
 363
 364       buffers += 1;
 365       n_packets_left -= 1;
 366       n_desc_left -= 1;
 367       d += 1;
 368       tb += 1;
 369     }
 370
 371   *n_enq_descs = n_free_desc - n_desc_left;
 372   return n_packets - n_packets_left;
 373 }
 374
 375 VNET_DEVICE_CLASS_TX_FN (avf_device_class) (vlib_main_t * vm,
 376                                             vlib_node_runtime_t * node,
 377                                             vlib_frame_t * frame)
 378 {
 379   vnet_interface_output_runtime_t *rd = (void *) node->runtime_data;
 380   avf_device_t *ad = avf_get_device (rd->dev_instance);
 381   u32 thread_index = vm->thread_index;
 382   u8 qid = thread_index;
 383   avf_txq_t *txq = vec_elt_at_index (ad->txqs, qid % ad->num_queue_pairs);
 384   u16 next;
 385   u16 mask = txq->size - 1;
 386   u32 *buffers = vlib_frame_vector_args (frame);
 387   u16 n_enq, n_left, n_desc, *slot;
 388   u16 n_retry = 2;
 389
 390   clib_spinlock_lock_if_init (&txq->lock);
 391
 392   n_left = frame->n_vectors;
 393
 394 retry:
 395   next = txq->next;
 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   n_desc = 0;
 429   if (ad->flags & AVF_DEVICE_F_VA_DMA)
 430     n_enq = avf_tx_prepare (vm, node, txq, buffers, n_left, &n_desc, 1);
 431   else
 432     n_enq = avf_tx_prepare (vm, node, txq, buffers, n_left, &n_desc, 0);
 433
 434   if (n_desc)
 435     {
 436       if (PREDICT_TRUE (next + n_desc <= txq->size))
 437         {
 438           /* no wrap */
 439           avf_tx_copy_desc (txq->descs + next, txq->tmp_descs, n_desc);
 440           vlib_buffer_copy_indices (txq->bufs + next, txq->tmp_bufs, n_desc);
 441         }
 442       else
 443         {
 444           /* wrap */
 445           u32 n_not_wrap = txq->size - next;
 446           avf_tx_copy_desc (txq->descs + next, txq->tmp_descs, n_not_wrap);
 447           avf_tx_copy_desc (txq->descs, txq->tmp_descs + n_not_wrap,
 448                             n_desc - n_not_wrap);
 449           vlib_buffer_copy_indices (txq->bufs + next, txq->tmp_bufs,
 450                                     n_not_wrap);
 451           vlib_buffer_copy_indices (txq->bufs, txq->tmp_bufs + n_not_wrap,
 452                                     n_desc - n_not_wrap);
 453         }
 454
 455       next += n_desc;
 456       if ((slot = clib_ring_enq (txq->rs_slots)))
 457         {
 458           u16 rs_slot = slot[0] = (next - 1) & mask;
 459           txq->descs[rs_slot].qword[1] |= AVF_TXD_CMD_RS;
 460         }
 461
 462       txq->next = next & mask;
 463       avf_tail_write (txq->qtx_tail, txq->next);
 464       txq->n_enqueued += n_desc;
 465       n_left -= n_enq;
 466     }
 467
 468   if (n_left)
 469     {
 470       buffers += n_enq;
 471
 472       if (n_retry--)
 473         goto retry;
 474
 475       vlib_buffer_free (vm, buffers, n_left);
 476       vlib_error_count (vm, node->node_index,
 477                         AVF_TX_ERROR_NO_FREE_SLOTS, n_left);
 478     }
 479
 480   clib_spinlock_unlock_if_init (&txq->lock);
 481
 482   return frame->n_vectors - n_left;
 483 }
 484
 485 /*
 486  * fd.io coding-style-patch-verification: ON
 487  *
 488  * Local Variables:
 489  * eval: (c-set-style "gnu")
 490  * End:
 491  */