src/plugins/dpdk/buffer.c

   1 /*
   2  * Copyright (c) 2017-2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <unistd.h>
  17 #include <errno.h>
  18
  19 #include <rte_config.h>
  20 #include <rte_mbuf.h>
  21 #include <rte_ethdev.h>
  22 #include <rte_cryptodev.h>
  23 #include <rte_vfio.h>
  24 #include <rte_version.h>
  25
  26 #include <vlib/vlib.h>
  27 #include <dpdk/buffer.h>
  28
  29 STATIC_ASSERT (VLIB_BUFFER_PRE_DATA_SIZE == RTE_PKTMBUF_HEADROOM,
  30                "VLIB_BUFFER_PRE_DATA_SIZE must be equal to RTE_PKTMBUF_HEADROOM");
  31
  32 extern struct rte_mbuf *dpdk_mbuf_template_by_pool_index;
  33 #ifndef CLIB_MARCH_VARIANT
  34 struct rte_mempool **dpdk_mempool_by_buffer_pool_index = 0;
  35 struct rte_mempool **dpdk_no_cache_mempool_by_buffer_pool_index = 0;
  36 struct rte_mbuf *dpdk_mbuf_template_by_pool_index = 0;
  37
  38 clib_error_t *
  39 dpdk_buffer_pool_init (vlib_main_t * vm, vlib_buffer_pool_t * bp)
  40 {
  41   uword buffer_mem_start = vm->buffer_main->buffer_mem_start;
  42   struct rte_mempool *mp, *nmp;
  43   struct rte_pktmbuf_pool_private priv;
  44   enum rte_iova_mode iova_mode;
  45   u32 i;
  46   u8 *name = 0;
  47
  48   u32 elt_size =
  49     sizeof (struct rte_mbuf) + sizeof (vlib_buffer_t) + bp->data_size;
  50
  51   /* create empty mempools */
  52   vec_validate_aligned (dpdk_mempool_by_buffer_pool_index, bp->index,
  53                         CLIB_CACHE_LINE_BYTES);
  54   vec_validate_aligned (dpdk_no_cache_mempool_by_buffer_pool_index, bp->index,
  55                         CLIB_CACHE_LINE_BYTES);
  56
  57   /* normal mempool */
  58   name = format (name, "vpp pool %u%c", bp->index, 0);
  59   mp = rte_mempool_create_empty ((char *) name, bp->n_buffers,
  60                                  elt_size, 512, sizeof (priv),
  61                                  bp->numa_node, 0);
  62   if (!mp)
  63     {
  64       vec_free (name);
  65       return clib_error_return (0,
  66                                 "failed to create normal mempool for numa node %u",
  67                                 bp->index);
  68     }
  69   vec_reset_length (name);
  70
  71   /* non-cached mempool */
  72   name = format (name, "vpp pool %u (no cache)%c", bp->index, 0);
  73   nmp = rte_mempool_create_empty ((char *) name, bp->n_buffers,
  74                                   elt_size, 0, sizeof (priv),
  75                                   bp->numa_node, 0);
  76   if (!nmp)
  77     {
  78       rte_mempool_free (mp);
  79       vec_free (name);
  80       return clib_error_return (0,
  81                                 "failed to create non-cache mempool for numa nude %u",
  82                                 bp->index);
  83     }
  84   vec_free (name);
  85
  86   dpdk_mempool_by_buffer_pool_index[bp->index] = mp;
  87   dpdk_no_cache_mempool_by_buffer_pool_index[bp->index] = nmp;
  88
  89   mp->pool_id = nmp->pool_id = bp->index;
  90
  91   rte_mempool_set_ops_byname (mp, "vpp", NULL);
  92   rte_mempool_set_ops_byname (nmp, "vpp-no-cache", NULL);
  93
  94   /* Call the mempool priv initializer */
  95   memset (&priv, 0, sizeof (priv));
  96   priv.mbuf_data_room_size = VLIB_BUFFER_PRE_DATA_SIZE +
  97     vlib_buffer_get_default_data_size (vm);
  98   priv.mbuf_priv_size = VLIB_BUFFER_HDR_SIZE;
  99   rte_pktmbuf_pool_init (mp, &priv);
 100   rte_pktmbuf_pool_init (nmp, &priv);
 101
 102   iova_mode = rte_eal_iova_mode ();
 103
 104   /* populate mempool object buffer header */
 105   for (i = 0; i < bp->n_buffers; i++)
 106     {
 107       struct rte_mempool_objhdr *hdr;
 108       vlib_buffer_t *b = vlib_get_buffer (vm, bp->buffers[i]);
 109       struct rte_mbuf *mb = rte_mbuf_from_vlib_buffer (b);
 110       hdr = (struct rte_mempool_objhdr *) RTE_PTR_SUB (mb, sizeof (*hdr));
 111       hdr->mp = mp;
 112       hdr->iova = (iova_mode == RTE_IOVA_VA) ?
 113         pointer_to_uword (mb) : vlib_physmem_get_pa (vm, mb);
 114       STAILQ_INSERT_TAIL (&mp->elt_list, hdr, next);
 115       STAILQ_INSERT_TAIL (&nmp->elt_list, hdr, next);
 116       mp->populated_size++;
 117       nmp->populated_size++;
 118     }
 119 #if RTE_VERSION >= RTE_VERSION_NUM(22, 3, 0, 0)
 120   mp->flags &= ~RTE_MEMPOOL_F_NON_IO;
 121 #endif
 122
 123   /* call the object initializers */
 124   rte_mempool_obj_iter (mp, rte_pktmbuf_init, 0);
 125
 126   /* create mbuf header tempate from the first buffer in the pool */
 127   vec_validate_aligned (dpdk_mbuf_template_by_pool_index, bp->index,
 128                         CLIB_CACHE_LINE_BYTES);
 129   clib_memcpy (vec_elt_at_index (dpdk_mbuf_template_by_pool_index, bp->index),
 130                rte_mbuf_from_vlib_buffer (vlib_buffer_ptr_from_index
 131                                           (buffer_mem_start, *bp->buffers,
 132                                            0)), sizeof (struct rte_mbuf));
 133
 134   for (i = 0; i < bp->n_buffers; i++)
 135     {
 136       vlib_buffer_t *b;
 137       b = vlib_buffer_ptr_from_index (buffer_mem_start, bp->buffers[i], 0);
 138       b->template = bp->buffer_template;
 139     }
 140
 141   /* map DMA pages if at least one physical device exists */
 142   if (rte_eth_dev_count_avail () || rte_cryptodev_count ())
 143     {
 144       uword i;
 145       size_t page_sz;
 146       vlib_physmem_map_t *pm;
 147       int do_vfio_map = 1;
 148
 149       pm = vlib_physmem_get_map (vm, bp->physmem_map_index);
 150       page_sz = 1ULL << pm->log2_page_size;
 151
 152       for (i = 0; i < pm->n_pages; i++)
 153         {
 154           char *va = ((char *) pm->base) + i * page_sz;
 155           uword pa = (iova_mode == RTE_IOVA_VA) ?
 156             pointer_to_uword (va) : pm->page_table[i];
 157
 158           if (do_vfio_map &&
 159 #if RTE_VERSION < RTE_VERSION_NUM(19, 11, 0, 0)
 160               rte_vfio_dma_map (pointer_to_uword (va), pa, page_sz))
 161 #else
 162               rte_vfio_container_dma_map (RTE_VFIO_DEFAULT_CONTAINER_FD,
 163                                           pointer_to_uword (va), pa, page_sz))
 164 #endif
 165             do_vfio_map = 0;
 166
 167           struct rte_mempool_memhdr *memhdr;
 168           memhdr = clib_mem_alloc (sizeof (*memhdr));
 169           memhdr->mp = mp;
 170           memhdr->addr = va;
 171           memhdr->iova = pa;
 172           memhdr->len = page_sz;
 173           memhdr->free_cb = 0;
 174           memhdr->opaque = 0;
 175
 176           STAILQ_INSERT_TAIL (&mp->mem_list, memhdr, next);
 177           mp->nb_mem_chunks++;
 178         }
 179     }
 180
 181   return 0;
 182 }
 183
 184 static int
 185 dpdk_ops_vpp_alloc (struct rte_mempool *mp)
 186 {
 187   clib_warning ("");
 188   return 0;
 189 }
 190
 191 static void
 192 dpdk_ops_vpp_free (struct rte_mempool *mp)
 193 {
 194   clib_warning ("");
 195 }
 196
 197 #endif
 198
 199 static_always_inline void
 200 dpdk_ops_vpp_enqueue_one (vlib_buffer_template_t *bt, void *obj)
 201 {
 202   /* Only non-replicated packets (b->ref_count == 1) expected */
 203
 204   struct rte_mbuf *mb = obj;
 205   vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
 206   ASSERT (b->ref_count == 1);
 207   ASSERT (b->buffer_pool_index == bt->buffer_pool_index);
 208   b->template = *bt;
 209 }
 210
 211 int
 212 CLIB_MULTIARCH_FN (dpdk_ops_vpp_enqueue) (struct rte_mempool * mp,
 213                                           void *const *obj_table, unsigned n)
 214 {
 215   const int batch_size = 32;
 216   vlib_main_t *vm = vlib_get_main ();
 217   vlib_buffer_template_t bt;
 218   u8 buffer_pool_index = mp->pool_id;
 219   vlib_buffer_pool_t *bp = vlib_get_buffer_pool (vm, buffer_pool_index);
 220   u32 bufs[batch_size];
 221   u32 n_left = n;
 222   void *const *obj = obj_table;
 223
 224   bt = bp->buffer_template;
 225
 226   while (n_left >= 4)
 227     {
 228       dpdk_ops_vpp_enqueue_one (&bt, obj[0]);
 229       dpdk_ops_vpp_enqueue_one (&bt, obj[1]);
 230       dpdk_ops_vpp_enqueue_one (&bt, obj[2]);
 231       dpdk_ops_vpp_enqueue_one (&bt, obj[3]);
 232       obj += 4;
 233       n_left -= 4;
 234     }
 235
 236   while (n_left)
 237     {
 238       dpdk_ops_vpp_enqueue_one (&bt, obj[0]);
 239       obj += 1;
 240       n_left -= 1;
 241     }
 242
 243   while (n >= batch_size)
 244     {
 245       vlib_get_buffer_indices_with_offset (vm, (void **) obj_table, bufs,
 246                                            batch_size,
 247                                            sizeof (struct rte_mbuf));
 248       vlib_buffer_pool_put (vm, buffer_pool_index, bufs, batch_size);
 249       n -= batch_size;
 250       obj_table += batch_size;
 251     }
 252
 253   if (n)
 254     {
 255       vlib_get_buffer_indices_with_offset (vm, (void **) obj_table, bufs,
 256                                            n, sizeof (struct rte_mbuf));
 257       vlib_buffer_pool_put (vm, buffer_pool_index, bufs, n);
 258     }
 259
 260   return 0;
 261 }
 262
 263 CLIB_MARCH_FN_REGISTRATION (dpdk_ops_vpp_enqueue);
 264
 265 static_always_inline void
 266 dpdk_ops_vpp_enqueue_no_cache_one (vlib_main_t *vm, struct rte_mempool *old,
 267                                    struct rte_mempool *new, void *obj,
 268                                    vlib_buffer_template_t *bt)
 269 {
 270   struct rte_mbuf *mb = obj;
 271   vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
 272
 273   if (clib_atomic_sub_fetch (&b->ref_count, 1) == 0)
 274     {
 275       u32 bi = vlib_get_buffer_index (vm, b);
 276       b->template = *bt;
 277       vlib_buffer_pool_put (vm, bt->buffer_pool_index, &bi, 1);
 278       return;
 279     }
 280 }
 281
 282 int
 283 CLIB_MULTIARCH_FN (dpdk_ops_vpp_enqueue_no_cache) (struct rte_mempool * cmp,
 284                                                    void *const *obj_table,
 285                                                    unsigned n)
 286 {
 287   vlib_main_t *vm = vlib_get_main ();
 288   vlib_buffer_template_t bt;
 289   struct rte_mempool *mp;
 290   mp = dpdk_mempool_by_buffer_pool_index[cmp->pool_id];
 291   u8 buffer_pool_index = cmp->pool_id;
 292   vlib_buffer_pool_t *bp = vlib_get_buffer_pool (vm, buffer_pool_index);
 293   bt = bp->buffer_template;
 294
 295   while (n >= 4)
 296     {
 297       dpdk_ops_vpp_enqueue_no_cache_one (vm, cmp, mp, obj_table[0], &bt);
 298       dpdk_ops_vpp_enqueue_no_cache_one (vm, cmp, mp, obj_table[1], &bt);
 299       dpdk_ops_vpp_enqueue_no_cache_one (vm, cmp, mp, obj_table[2], &bt);
 300       dpdk_ops_vpp_enqueue_no_cache_one (vm, cmp, mp, obj_table[3], &bt);
 301       obj_table += 4;
 302       n -= 4;
 303     }
 304
 305   while (n)
 306     {
 307       dpdk_ops_vpp_enqueue_no_cache_one (vm, cmp, mp, obj_table[0], &bt);
 308       obj_table += 1;
 309       n -= 1;
 310     }
 311
 312   return 0;
 313 }
 314
 315 CLIB_MARCH_FN_REGISTRATION (dpdk_ops_vpp_enqueue_no_cache);
 316
 317 static_always_inline void
 318 dpdk_mbuf_init_from_template (struct rte_mbuf **mba, struct rte_mbuf *mt,
 319                               int count)
 320 {
 321   /* Assumptions about rte_mbuf layout */
 322   STATIC_ASSERT_OFFSET_OF (struct rte_mbuf, buf_addr, 0);
 323   STATIC_ASSERT_OFFSET_OF (struct rte_mbuf, buf_iova, 8);
 324   STATIC_ASSERT_SIZEOF_ELT (struct rte_mbuf, buf_iova, 8);
 325   STATIC_ASSERT_SIZEOF_ELT (struct rte_mbuf, buf_iova, 8);
 326   STATIC_ASSERT_SIZEOF (struct rte_mbuf, 128);
 327
 328   while (count--)
 329     {
 330       struct rte_mbuf *mb = mba[0];
 331       int i;
 332       /* bytes 0 .. 15 hold buf_addr and buf_iova which we need to preserve */
 333       /* copy bytes 16 .. 31 */
 334       *((u8x16 *) mb + 1) = *((u8x16 *) mt + 1);
 335
 336       /* copy bytes 32 .. 127 */
 337 #ifdef CLIB_HAVE_VEC256
 338       for (i = 1; i < 4; i++)
 339         *((u8x32 *) mb + i) = *((u8x32 *) mt + i);
 340 #else
 341       for (i = 2; i < 8; i++)
 342         *((u8x16 *) mb + i) = *((u8x16 *) mt + i);
 343 #endif
 344       mba++;
 345     }
 346 }
 347
 348 int
 349 CLIB_MULTIARCH_FN (dpdk_ops_vpp_dequeue) (struct rte_mempool * mp,
 350                                           void **obj_table, unsigned n)
 351 {
 352   const int batch_size = 32;
 353   vlib_main_t *vm = vlib_get_main ();
 354   u32 bufs[batch_size], total = 0, n_alloc = 0;
 355   u8 buffer_pool_index = mp->pool_id;
 356   void **obj = obj_table;
 357   struct rte_mbuf t = dpdk_mbuf_template_by_pool_index[buffer_pool_index];
 358
 359   while (n >= batch_size)
 360     {
 361       n_alloc = vlib_buffer_alloc_from_pool (vm, bufs, batch_size,
 362                                              buffer_pool_index);
 363       if (n_alloc != batch_size)
 364         goto alloc_fail;
 365
 366       vlib_get_buffers_with_offset (vm, bufs, obj, batch_size,
 367                                     -(i32) sizeof (struct rte_mbuf));
 368       dpdk_mbuf_init_from_template ((struct rte_mbuf **) obj, &t, batch_size);
 369       total += batch_size;
 370       obj += batch_size;
 371       n -= batch_size;
 372     }
 373
 374   if (n)
 375     {
 376       n_alloc = vlib_buffer_alloc_from_pool (vm, bufs, n, buffer_pool_index);
 377
 378       if (n_alloc != n)
 379         goto alloc_fail;
 380
 381       vlib_get_buffers_with_offset (vm, bufs, obj, n,
 382                                     -(i32) sizeof (struct rte_mbuf));
 383       dpdk_mbuf_init_from_template ((struct rte_mbuf **) obj, &t, n);
 384     }
 385
 386   return 0;
 387
 388 alloc_fail:
 389   /* dpdk doesn't support partial alloc, so we need to return what we
 390      already got */
 391   if (n_alloc)
 392     vlib_buffer_pool_put (vm, buffer_pool_index, bufs, n_alloc);
 393   obj = obj_table;
 394   while (total)
 395     {
 396       vlib_get_buffer_indices_with_offset (vm, obj, bufs, batch_size,
 397                                            sizeof (struct rte_mbuf));
 398       vlib_buffer_pool_put (vm, buffer_pool_index, bufs, batch_size);
 399
 400       obj += batch_size;
 401       total -= batch_size;
 402     }
 403   return -ENOENT;
 404 }
 405
 406 CLIB_MARCH_FN_REGISTRATION (dpdk_ops_vpp_dequeue);
 407
 408 #ifndef CLIB_MARCH_VARIANT
 409
 410 static int
 411 dpdk_ops_vpp_dequeue_no_cache (struct rte_mempool *mp, void **obj_table,
 412                                unsigned n)
 413 {
 414   clib_error ("bug");
 415   return 0;
 416 }
 417
 418 static unsigned
 419 dpdk_ops_vpp_get_count (const struct rte_mempool *mp)
 420 {
 421   vlib_main_t *vm = vlib_get_main ();
 422   if (mp)
 423     {
 424       vlib_buffer_pool_t *pool = vlib_get_buffer_pool (vm, mp->pool_id);
 425       if (pool)
 426         {
 427           return pool->n_avail;
 428         }
 429     }
 430   return 0;
 431 }
 432
 433 static unsigned
 434 dpdk_ops_vpp_get_count_no_cache (const struct rte_mempool *mp)
 435 {
 436   struct rte_mempool *cmp;
 437   cmp = dpdk_no_cache_mempool_by_buffer_pool_index[mp->pool_id];
 438   return dpdk_ops_vpp_get_count (cmp);
 439 }
 440
 441 clib_error_t *
 442 dpdk_buffer_pools_create (vlib_main_t * vm)
 443 {
 444   clib_error_t *err;
 445   vlib_buffer_pool_t *bp;
 446
 447   struct rte_mempool_ops ops = { };
 448
 449   strncpy (ops.name, "vpp", 4);
 450   ops.alloc = dpdk_ops_vpp_alloc;
 451   ops.free = dpdk_ops_vpp_free;
 452   ops.get_count = dpdk_ops_vpp_get_count;
 453   ops.enqueue = CLIB_MARCH_FN_POINTER (dpdk_ops_vpp_enqueue);
 454   ops.dequeue = CLIB_MARCH_FN_POINTER (dpdk_ops_vpp_dequeue);
 455   rte_mempool_register_ops (&ops);
 456
 457   strncpy (ops.name, "vpp-no-cache", 13);
 458   ops.get_count = dpdk_ops_vpp_get_count_no_cache;
 459   ops.enqueue = CLIB_MARCH_FN_POINTER (dpdk_ops_vpp_enqueue_no_cache);
 460   ops.dequeue = dpdk_ops_vpp_dequeue_no_cache;
 461   rte_mempool_register_ops (&ops);
 462
 463   vec_foreach (bp, vm->buffer_main->buffer_pools)
 464     if (bp->start && (err = dpdk_buffer_pool_init (vm, bp)))
 465       return err;
 466   return 0;
 467 }
 468
 469 VLIB_BUFFER_SET_EXT_HDR_SIZE (sizeof (struct rte_mempool_objhdr) +
 470                               sizeof (struct rte_mbuf));
 471
 472 #endif
 473
 474 /** @endcond */
 475 /*
 476  * fd.io coding-style-patch-verification: ON
 477  *
 478  * Local Variables:
 479  * eval: (c-set-style "gnu")
 480  * End:
 481  */