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