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