vlib/vlib/dpdk_buffer.c

   1 /*
   2  * Copyright (c) 2015 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  * buffer.c: allocate/free network buffers.
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <rte_config.h>
  41
  42 #include <rte_common.h>
  43 #include <rte_log.h>
  44 #include <rte_memory.h>
  45 #include <rte_memcpy.h>
  46 #include <rte_memzone.h>
  47 #include <rte_tailq.h>
  48 #include <rte_eal.h>
  49 #include <rte_per_lcore.h>
  50 #include <rte_launch.h>
  51 #include <rte_atomic.h>
  52 #include <rte_cycles.h>
  53 #include <rte_prefetch.h>
  54 #include <rte_lcore.h>
  55 #include <rte_per_lcore.h>
  56 #include <rte_branch_prediction.h>
  57 #include <rte_interrupts.h>
  58 #include <rte_pci.h>
  59 #include <rte_random.h>
  60 #include <rte_debug.h>
  61 #include <rte_ether.h>
  62 #include <rte_ethdev.h>
  63 #include <rte_ring.h>
  64 #include <rte_mempool.h>
  65 #include <rte_mbuf.h>
  66
  67 #include <vlib/vlib.h>
  68
  69 phys_addr_t          __attribute__ ((weak)) rte_mem_virt2phy();
  70 int                  __attribute__ ((weak)) rte_eal_has_hugepages();
  71 unsigned             __attribute__ ((weak)) rte_socket_id();
  72 struct rte_mempool * __attribute__ ((weak)) rte_mempool_create();
  73 void                 __attribute__ ((weak)) rte_pktmbuf_init();
  74 void                 __attribute__ ((weak)) rte_pktmbuf_pool_init();
  75
  76 uword vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm, vlib_buffer_t * b_first)
  77 {
  78   vlib_buffer_t * b = b_first;
  79   uword l_first = b_first->current_length;
  80   uword l = 0;
  81   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
  82     {
  83       b = vlib_get_buffer (vm, b->next_buffer);
  84       l += b->current_length;
  85     }
  86   b_first->total_length_not_including_first_buffer = l;
  87   b_first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  88   return l + l_first;
  89 }
  90
  91 u8 * format_vlib_buffer (u8 * s, va_list * args)
  92 {
  93   vlib_buffer_t * b = va_arg (*args, vlib_buffer_t *);
  94   uword indent = format_get_indent (s);
  95
  96   s = format (s, "current data %d, length %d, free-list %d",
  97               b->current_data, b->current_length,
  98               b->free_list_index);
  99
 100   if (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID)
 101     s = format (s, ", totlen-nifb %d",
 102                 b->total_length_not_including_first_buffer);
 103
 104   if (b->flags & VLIB_BUFFER_IS_TRACED)
 105     s = format (s, ", trace 0x%x", b->trace_index);
 106
 107   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 108     {
 109       vlib_main_t * vm = vlib_get_main();
 110       u32 next_buffer = b->next_buffer;
 111       b = vlib_get_buffer(vm, next_buffer);
 112
 113       s = format (s, "\n%Unext-buffer 0x%x, segment length %d",
 114                   format_white_space, indent, next_buffer, b->current_length);
 115     }
 116
 117
 118   return s;
 119 }
 120
 121 u8 * format_vlib_buffer_and_data (u8 * s, va_list * args)
 122 {
 123   vlib_buffer_t * b = va_arg (*args, vlib_buffer_t *);
 124
 125   s = format (s, "%U, %U",
 126               format_vlib_buffer, b,
 127               format_hex_bytes, vlib_buffer_get_current (b), 64);
 128
 129   return s;
 130 }
 131
 132 u8 * format_vlib_buffer_contents (u8 * s, va_list * va)
 133 {
 134   vlib_main_t * vm = va_arg (*va, vlib_main_t *);
 135   vlib_buffer_t * b = va_arg (*va, vlib_buffer_t *);
 136
 137   while (1)
 138     {
 139       vec_add (s, vlib_buffer_get_current (b),
 140                b->current_length);
 141       if (! (b->flags & VLIB_BUFFER_NEXT_PRESENT))
 142         break;
 143       b = vlib_get_buffer (vm, b->next_buffer);
 144     }
 145
 146   return s;
 147 }
 148
 149 vlib_main_t **vlib_mains;
 150
 151 /* Aligned copy routine. */
 152 void
 153 vlib_aligned_memcpy (void * _dst, void * _src, int n_bytes)
 154 {
 155   vlib_copy_unit_t * dst = _dst;
 156   vlib_copy_unit_t * src = _src;
 157
 158   /* Arguments must be naturally aligned. */
 159   ASSERT (pointer_to_uword (dst) % sizeof (dst[0]) == 0);
 160   ASSERT (pointer_to_uword (src) % sizeof (src[0]) == 0);
 161   ASSERT (n_bytes % sizeof (dst[0]) == 0);
 162
 163   if (4 * sizeof (dst[0]) == CLIB_CACHE_LINE_BYTES)
 164     {
 165       CLIB_PREFETCH (dst + 0, 4 * sizeof (dst[0]), WRITE);
 166       CLIB_PREFETCH (src + 0, 4 * sizeof (src[0]), READ);
 167
 168       while (n_bytes >= 4 * sizeof (dst[0]))
 169         {
 170           dst += 4;
 171           src += 4;
 172           n_bytes -= 4 * sizeof (dst[0]);
 173           CLIB_PREFETCH (dst, 4 * sizeof (dst[0]), WRITE);
 174           CLIB_PREFETCH (src, 4 * sizeof (src[0]), READ);
 175           dst[-4] = src[-4];
 176           dst[-3] = src[-3];
 177           dst[-2] = src[-2];
 178           dst[-1] = src[-1];
 179         }
 180     }
 181   else if (8 * sizeof (dst[0]) == CLIB_CACHE_LINE_BYTES)
 182     {
 183       CLIB_PREFETCH (dst + 0, 8 * sizeof (dst[0]), WRITE);
 184       CLIB_PREFETCH (src + 0, 8 * sizeof (src[0]), READ);
 185
 186       while (n_bytes >= 8 * sizeof (dst[0]))
 187         {
 188           dst += 8;
 189           src += 8;
 190           n_bytes -= 8 * sizeof (dst[0]);
 191           CLIB_PREFETCH (dst, 8 * sizeof (dst[0]), WRITE);
 192           CLIB_PREFETCH (src, 8 * sizeof (src[0]), READ);
 193           dst[-8] = src[-8];
 194           dst[-7] = src[-7];
 195           dst[-6] = src[-6];
 196           dst[-5] = src[-5];
 197           dst[-4] = src[-4];
 198           dst[-3] = src[-3];
 199           dst[-2] = src[-2];
 200           dst[-1] = src[-1];
 201         }
 202     }
 203   else
 204     /* Cache line size unknown: fall back to slow version. */;
 205
 206   while (n_bytes > 0)
 207     {
 208       *dst++ = *src++;
 209       n_bytes -= 1 * sizeof (dst[0]);
 210     }
 211 }
 212
 213 #define BUFFERS_PER_COPY (sizeof (vlib_copy_unit_t) / sizeof (u32))
 214
 215 /* Make sure we have at least given number of unaligned buffers. */
 216 static void
 217 fill_unaligned (vlib_main_t * vm,
 218                 vlib_buffer_free_list_t * free_list,
 219                 uword n_unaligned_buffers)
 220 {
 221   word la = vec_len (free_list->aligned_buffers);
 222   word lu = vec_len (free_list->unaligned_buffers);
 223
 224   /* Aligned come in aligned copy-sized chunks. */
 225   ASSERT (la % BUFFERS_PER_COPY == 0);
 226
 227   ASSERT (la >= n_unaligned_buffers);
 228
 229   while (lu < n_unaligned_buffers)
 230     {
 231       /* Copy 4 buffers from end of aligned vector to unaligned vector. */
 232       vec_add (free_list->unaligned_buffers,
 233                free_list->aligned_buffers + la - BUFFERS_PER_COPY,
 234                BUFFERS_PER_COPY);
 235       la -= BUFFERS_PER_COPY;
 236       lu += BUFFERS_PER_COPY;
 237     }
 238   _vec_len (free_list->aligned_buffers) = la;
 239 }
 240
 241 /* After free aligned buffers may not contain even sized chunks. */
 242 static void
 243 trim_aligned (vlib_buffer_free_list_t * f)
 244 {
 245   uword l, n_trim;
 246
 247   /* Add unaligned to aligned before trim. */
 248   l = vec_len (f->unaligned_buffers);
 249   if (l > 0)
 250     {
 251       vec_add_aligned (f->aligned_buffers, f->unaligned_buffers, l,
 252                        /* align */ sizeof (vlib_copy_unit_t));
 253
 254       _vec_len (f->unaligned_buffers) = 0;
 255     }
 256
 257   /* Remove unaligned buffers from end of aligned vector and save for next trim. */
 258   l = vec_len (f->aligned_buffers);
 259   n_trim = l % BUFFERS_PER_COPY;
 260   if (n_trim)
 261     {
 262       /* Trim aligned -> unaligned. */
 263       vec_add (f->unaligned_buffers, f->aligned_buffers + l - n_trim, n_trim);
 264
 265       /* Remove from aligned. */
 266       _vec_len (f->aligned_buffers) = l - n_trim;
 267     }
 268 }
 269
 270 static void
 271 merge_free_lists (vlib_buffer_free_list_t * dst,
 272                   vlib_buffer_free_list_t * src)
 273 {
 274   uword l;
 275   u32 * d;
 276
 277   trim_aligned (src);
 278   trim_aligned (dst);
 279
 280   l = vec_len (src->aligned_buffers);
 281   if (l > 0)
 282     {
 283       vec_add2_aligned (dst->aligned_buffers, d, l,
 284                         /* align */ sizeof (vlib_copy_unit_t));
 285       vlib_aligned_memcpy (d, src->aligned_buffers, l * sizeof (d[0]));
 286       vec_free (src->aligned_buffers);
 287     }
 288
 289   l = vec_len (src->unaligned_buffers);
 290   if (l > 0)
 291     {
 292       vec_add (dst->unaligned_buffers, src->unaligned_buffers, l);
 293       vec_free (src->unaligned_buffers);
 294     }
 295 }
 296
 297 always_inline u32
 298 vlib_buffer_get_free_list_with_size (vlib_main_t * vm, u32 size)
 299 {
 300   vlib_buffer_main_t * bm = vm->buffer_main;
 301
 302   size = vlib_buffer_round_size (size);
 303   uword * p = hash_get (bm->free_list_by_size, size);
 304   return p ? p[0] : ~0;
 305 }
 306
 307 /* Add buffer free list. */
 308 static u32
 309 vlib_buffer_create_free_list_helper (vlib_main_t * vm,
 310                                      u32 n_data_bytes,
 311                                      u32 is_public,
 312                                      u32 is_default,
 313                                      u8 * name)
 314 {
 315   vlib_buffer_main_t * bm = vm->buffer_main;
 316   vlib_buffer_free_list_t * f;
 317
 318   if (! is_default && pool_elts (bm->buffer_free_list_pool) == 0)
 319     {
 320       u32 default_free_free_list_index;
 321
 322       default_free_free_list_index =
 323         vlib_buffer_create_free_list_helper (vm,
 324                                              /* default buffer size */ VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES,
 325                                              /* is_public */ 1,
 326                                              /* is_default */ 1,
 327                                              (u8 *) "default");
 328       ASSERT (default_free_free_list_index == VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 329
 330       if (n_data_bytes == VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES && is_public)
 331         return default_free_free_list_index;
 332     }
 333
 334   pool_get_aligned (bm->buffer_free_list_pool, f, CLIB_CACHE_LINE_BYTES);
 335
 336   memset (f, 0, sizeof (f[0]));
 337   f->index = f - bm->buffer_free_list_pool;
 338   f->n_data_bytes = vlib_buffer_round_size (n_data_bytes);
 339   f->min_n_buffers_each_physmem_alloc = 16;
 340   f->name = clib_mem_is_heap_object (name) ? name : format (0, "%s", name);
 341
 342   /* Setup free buffer template. */
 343   f->buffer_init_template.free_list_index = f->index;
 344
 345   if (is_public)
 346     {
 347       uword * p = hash_get (bm->free_list_by_size, f->n_data_bytes);
 348       if (! p)
 349         hash_set (bm->free_list_by_size, f->n_data_bytes, f->index);
 350     }
 351
 352   return f->index;
 353 }
 354
 355 u32 vlib_buffer_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
 356                                   char * fmt, ...)
 357 {
 358   va_list va;
 359   u8 * name;
 360
 361   va_start (va, fmt);
 362   name = va_format (0, fmt, &va);
 363   va_end (va);
 364
 365   return vlib_buffer_create_free_list_helper (vm, n_data_bytes,
 366                                               /* is_public */ 0,
 367                                               /* is_default */ 0,
 368                                               name);
 369 }
 370
 371 u32 vlib_buffer_get_or_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
 372                                          char * fmt, ...)
 373 {
 374   u32 i = vlib_buffer_get_free_list_with_size (vm, n_data_bytes);
 375
 376   if (i == ~0)
 377     {
 378       va_list va;
 379       u8 * name;
 380
 381       va_start (va, fmt);
 382       name = va_format (0, fmt, &va);
 383       va_end (va);
 384
 385       i = vlib_buffer_create_free_list_helper (vm, n_data_bytes,
 386                                                /* is_public */ 1,
 387                                                /* is_default */ 0,
 388                                                name);
 389     }
 390
 391   return i;
 392 }
 393
 394 static void
 395 del_free_list (vlib_main_t * vm, vlib_buffer_free_list_t * f)
 396 {
 397   u32 i;
 398   struct rte_mbuf *mb;
 399   vlib_buffer_t *b;
 400
 401   for (i = 0; i < vec_len (f->unaligned_buffers); i++) {
 402       b = vlib_get_buffer (vm, f->unaligned_buffers[i]);
 403       mb = ((struct rte_mbuf *)b)-1;
 404       ASSERT(rte_mbuf_refcnt_read(mb) == 1);
 405       rte_pktmbuf_free (mb);
 406   }
 407   for (i = 0; i < vec_len (f->aligned_buffers); i++) {
 408       b = vlib_get_buffer (vm, f->aligned_buffers[i]);
 409       mb = ((struct rte_mbuf *)b)-1;
 410       ASSERT(rte_mbuf_refcnt_read(mb) == 1);
 411       rte_pktmbuf_free (mb);
 412   }
 413   vec_free (f->name);
 414   vec_free (f->unaligned_buffers);
 415   vec_free (f->aligned_buffers);
 416 }
 417
 418 /* Add buffer free list. */
 419 void vlib_buffer_delete_free_list (vlib_main_t * vm, u32 free_list_index)
 420 {
 421   vlib_buffer_main_t * bm = vm->buffer_main;
 422   vlib_buffer_free_list_t * f;
 423   u32 merge_index;
 424
 425   f = vlib_buffer_get_free_list (vm, free_list_index);
 426
 427   merge_index = vlib_buffer_get_free_list_with_size (vm, f->n_data_bytes);
 428   if (merge_index != ~0 && merge_index != free_list_index)
 429     {
 430       merge_free_lists (pool_elt_at_index (bm->buffer_free_list_pool,
 431                                            merge_index), f);
 432     }
 433
 434   del_free_list (vm, f);
 435
 436   /* Poison it. */
 437   memset (f, 0xab, sizeof (f[0]));
 438
 439   pool_put (bm->buffer_free_list_pool, f);
 440 }
 441
 442 /* Make sure free list has at least given number of free buffers. */
 443 static uword
 444 fill_free_list (vlib_main_t * vm,
 445                 vlib_buffer_free_list_t * fl,
 446                 uword min_free_buffers)
 447 {
 448   vlib_buffer_t * b;
 449   int n, i;
 450   u32 bi;
 451   u32 n_remaining = 0, n_alloc = 0;
 452   unsigned socket_id = rte_socket_id ? rte_socket_id() : 0;
 453   struct rte_mempool *rmp = vm->buffer_main->pktmbuf_pools[socket_id];
 454   struct rte_mbuf *mb;
 455
 456   /* Too early? */
 457   if (PREDICT_FALSE(rmp == 0))
 458     return 0;
 459
 460   trim_aligned (fl);
 461
 462   /* Already have enough free buffers on free list? */
 463   n = min_free_buffers - vec_len (fl->aligned_buffers);
 464   if (n <= 0)
 465     return min_free_buffers;
 466
 467   /* Always allocate round number of buffers. */
 468   n = round_pow2 (n, BUFFERS_PER_COPY);
 469
 470   /* Always allocate new buffers in reasonably large sized chunks. */
 471   n = clib_max (n, fl->min_n_buffers_each_physmem_alloc);
 472
 473   vec_validate (vm->mbuf_alloc_list, n-1);
 474
 475   if (rte_mempool_get_bulk (rmp, vm->mbuf_alloc_list, n) < 0)
 476     return 0;
 477
 478   _vec_len (vm->mbuf_alloc_list) = n;
 479
 480   for (i = 0; i < n; i++)
 481     {
 482       mb = vm->mbuf_alloc_list[i];
 483
 484       ASSERT(rte_mbuf_refcnt_read(mb) == 0);
 485       rte_mbuf_refcnt_set(mb, 1);
 486       mb->next = NULL;
 487       mb->data_off = RTE_PKTMBUF_HEADROOM;
 488       mb->nb_segs = 1;
 489
 490       b = (vlib_buffer_t *)(mb+1);
 491       bi = vlib_get_buffer_index (vm, b);
 492
 493       vec_add1_aligned (fl->aligned_buffers, bi, sizeof (vlib_copy_unit_t));
 494       n_alloc++;
 495       n_remaining--;
 496
 497       vlib_buffer_init_for_free_list (b, fl);
 498
 499       if (fl->buffer_init_function)
 500         fl->buffer_init_function (vm, fl, &bi, 1);
 501     }
 502
 503   fl->n_alloc += n;
 504
 505   return n;
 506 }
 507
 508 always_inline uword
 509 copy_alignment (u32 * x)
 510 { return (pointer_to_uword (x) / sizeof (x[0])) % BUFFERS_PER_COPY; }
 511
 512 static u32
 513 alloc_from_free_list (vlib_main_t * vm,
 514                       vlib_buffer_free_list_t * free_list,
 515                       u32 * alloc_buffers,
 516                       u32 n_alloc_buffers)
 517 {
 518   u32 * dst, * u_src;
 519   uword u_len, n_left;
 520   uword n_unaligned_start, n_unaligned_end, n_filled;
 521
 522   n_left = n_alloc_buffers;
 523   dst = alloc_buffers;
 524   n_unaligned_start = ((BUFFERS_PER_COPY - copy_alignment (dst))
 525                        & (BUFFERS_PER_COPY - 1));
 526
 527   n_filled = fill_free_list (vm, free_list, n_alloc_buffers);
 528   if (n_filled == 0)
 529     return 0;
 530
 531   n_left = n_filled < n_left ? n_filled : n_left;
 532   n_alloc_buffers = n_left;
 533
 534   if (n_unaligned_start >= n_left)
 535     {
 536       n_unaligned_start = n_left;
 537       n_unaligned_end = 0;
 538     }
 539   else
 540     n_unaligned_end = copy_alignment (dst + n_alloc_buffers);
 541
 542   fill_unaligned (vm, free_list, n_unaligned_start + n_unaligned_end);
 543
 544   u_len = vec_len (free_list->unaligned_buffers);
 545   u_src = free_list->unaligned_buffers + u_len - 1;
 546
 547   if (n_unaligned_start)
 548     {
 549       uword n_copy = n_unaligned_start;
 550       if (n_copy > n_left)
 551         n_copy = n_left;
 552       n_left -= n_copy;
 553
 554       while (n_copy > 0)
 555         {
 556           *dst++ = *u_src--;
 557           n_copy--;
 558           u_len--;
 559         }
 560
 561       /* Now dst should be aligned. */
 562       if (n_left > 0)
 563         ASSERT (pointer_to_uword (dst) % sizeof (vlib_copy_unit_t) == 0);
 564     }
 565
 566   /* Aligned copy. */
 567   {
 568     vlib_copy_unit_t * d, * s;
 569     uword n_copy;
 570
 571     if (vec_len(free_list->aligned_buffers) < ((n_left/BUFFERS_PER_COPY)*BUFFERS_PER_COPY))
 572         abort();
 573
 574     n_copy = n_left / BUFFERS_PER_COPY;
 575     n_left = n_left % BUFFERS_PER_COPY;
 576
 577     /* Remove buffers from aligned free list. */
 578     _vec_len (free_list->aligned_buffers) -= n_copy * BUFFERS_PER_COPY;
 579
 580     s = (vlib_copy_unit_t *) vec_end (free_list->aligned_buffers);
 581     d = (vlib_copy_unit_t *) dst;
 582
 583     /* Fast path loop. */
 584     while (n_copy >= 4)
 585       {
 586         d[0] = s[0];
 587         d[1] = s[1];
 588         d[2] = s[2];
 589         d[3] = s[3];
 590         n_copy -= 4;
 591         s += 4;
 592         d += 4;
 593       }
 594
 595     while (n_copy >= 1)
 596       {
 597         d[0] = s[0];
 598         n_copy -= 1;
 599         s += 1;
 600         d += 1;
 601       }
 602
 603     dst = (void *) d;
 604   }
 605
 606   /* Unaligned copy. */
 607   ASSERT (n_unaligned_end == n_left);
 608   while (n_left > 0)
 609     {
 610       *dst++ = *u_src--;
 611       n_left--;
 612       u_len--;
 613     }
 614
 615   if (! free_list->unaligned_buffers)
 616     ASSERT (u_len == 0);
 617   else
 618     _vec_len (free_list->unaligned_buffers) = u_len;
 619
 620   return n_alloc_buffers;
 621 }
 622
 623 /* Allocate a given number of buffers into given array.
 624    Returns number actually allocated which will be either zero or
 625    number requested. */
 626 u32 vlib_buffer_alloc (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 627 {
 628   vlib_buffer_main_t * bm = vm->buffer_main;
 629
 630   return alloc_from_free_list
 631     (vm,
 632      pool_elt_at_index (bm->buffer_free_list_pool,
 633                         VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX),
 634      buffers, n_buffers);
 635 }
 636
 637 u32 vlib_buffer_alloc_from_free_list (vlib_main_t * vm,
 638                                       u32 * buffers,
 639                                       u32 n_buffers,
 640                                       u32 free_list_index)
 641 {
 642   vlib_buffer_main_t * bm = vm->buffer_main;
 643   vlib_buffer_free_list_t * f;
 644   f = pool_elt_at_index (bm->buffer_free_list_pool, free_list_index);
 645   return alloc_from_free_list (vm, f, buffers, n_buffers);
 646 }
 647
 648 always_inline void
 649 add_buffer_to_free_list (vlib_main_t * vm,
 650                          vlib_buffer_free_list_t * f,
 651                          u32 buffer_index, u8 do_init)
 652 {
 653   vlib_buffer_t * b;
 654   b = vlib_get_buffer (vm, buffer_index);
 655   if (PREDICT_TRUE(do_init))
 656       vlib_buffer_init_for_free_list (b, f);
 657   vec_add1_aligned (f->aligned_buffers, buffer_index, sizeof (vlib_copy_unit_t));
 658 }
 659
 660 always_inline vlib_buffer_free_list_t *
 661 buffer_get_free_list (vlib_main_t * vm, vlib_buffer_t * b, u32 * index)
 662 {
 663   vlib_buffer_main_t * bm = vm->buffer_main;
 664   u32 i;
 665
 666   *index = i = b->free_list_index;
 667   return pool_elt_at_index (bm->buffer_free_list_pool, i);
 668 }
 669
 670 void *vlib_set_buffer_free_callback (vlib_main_t *vm, void *fp)
 671 {
 672   vlib_buffer_main_t * bm = vm->buffer_main;
 673   void * rv = bm->buffer_free_callback;
 674
 675   bm->buffer_free_callback = fp;
 676   return rv;
 677 }
 678
 679 static_always_inline void
 680 vlib_buffer_free_inline (vlib_main_t * vm,
 681                          u32 * buffers,
 682                          u32 n_buffers,
 683                          u32 follow_buffer_next)
 684 {
 685   vlib_buffer_main_t * bm = vm->buffer_main;
 686   vlib_buffer_free_list_t * fl;
 687   u32 fi;
 688   int i;
 689   u32 (*cb)(vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 690             u32 follow_buffer_next);
 691
 692   cb = bm->buffer_free_callback;
 693
 694   if (PREDICT_FALSE (cb != 0))
 695     n_buffers = (*cb)(vm, buffers, n_buffers, follow_buffer_next);
 696
 697   if (! n_buffers)
 698     return;
 699
 700   for (i = 0; i < n_buffers; i++)
 701     {
 702       vlib_buffer_t * b;
 703       struct rte_mbuf * mb;
 704
 705       b = vlib_get_buffer (vm, buffers[i]);
 706
 707       fl = buffer_get_free_list (vm, b, &fi);
 708
 709       /* The only current use of this callback: multicast recycle */
 710       if (PREDICT_FALSE (fl->buffers_added_to_freelist_function != 0))
 711         {
 712           int j;
 713
 714           add_buffer_to_free_list (vm, fl, buffers[i], b->clone_count == 0);
 715
 716           for (j = 0; j < vec_len (bm->announce_list); j++)
 717             {
 718               if (fl == bm->announce_list[j])
 719                 goto already_announced;
 720             }
 721           vec_add1 (bm->announce_list, fl);
 722         already_announced:
 723           ;
 724         }
 725       else
 726         {
 727           if (PREDICT_TRUE (b->clone_count == 0))
 728             {
 729               mb = ((struct rte_mbuf *)b)-1;
 730               ASSERT(rte_mbuf_refcnt_read(mb) == 1);
 731               rte_pktmbuf_free (mb);
 732             }
 733         }
 734     }
 735   if (vec_len(bm->announce_list))
 736     {
 737       vlib_buffer_free_list_t * fl;
 738       for (i = 0; i < vec_len (bm->announce_list); i++)
 739         {
 740           fl = bm->announce_list[i];
 741           fl->buffers_added_to_freelist_function (vm, fl);
 742         }
 743       _vec_len(bm->announce_list) = 0;
 744     }
 745 }
 746
 747 void vlib_buffer_free (vlib_main_t * vm,
 748                        u32 * buffers,
 749                        u32 n_buffers)
 750 {
 751   vlib_buffer_free_inline (vm, buffers, n_buffers, /* follow_buffer_next */ 1);
 752 }
 753
 754 void vlib_buffer_free_no_next (vlib_main_t * vm,
 755                                u32 * buffers,
 756                                u32 n_buffers)
 757 {
 758   vlib_buffer_free_inline (vm, buffers, n_buffers, /* follow_buffer_next */ 0);
 759 }
 760
 761 /* Copy template packet data into buffers as they are allocated. */
 762 __attribute__((unused)) static void
 763 vlib_packet_template_buffer_init (vlib_main_t * vm,
 764                                   vlib_buffer_free_list_t * fl,
 765                                   u32 * buffers,
 766                                   u32 n_buffers)
 767 {
 768   vlib_packet_template_t * t = uword_to_pointer (fl->buffer_init_function_opaque,
 769                                                  vlib_packet_template_t *);
 770   uword i;
 771
 772   for (i = 0; i < n_buffers; i++)
 773     {
 774       vlib_buffer_t * b = vlib_get_buffer (vm, buffers[i]);
 775       ASSERT (b->current_length == vec_len (t->packet_data));
 776       memcpy (vlib_buffer_get_current (b), t->packet_data, b->current_length);
 777     }
 778 }
 779
 780 void vlib_packet_template_init (vlib_main_t * vm,
 781                                 vlib_packet_template_t * t,
 782                                 void * packet_data,
 783                                 uword n_packet_data_bytes,
 784                                 uword min_n_buffers_each_physmem_alloc,
 785                                 char * fmt,
 786                                 ...)
 787 {
 788   va_list va;
 789   __attribute__((unused)) u8 * name;
 790
 791   va_start (va, fmt);
 792   name = va_format (0, fmt, &va);
 793   va_end (va);
 794
 795   vlib_worker_thread_barrier_sync(vm);
 796   memset (t, 0, sizeof (t[0]));
 797
 798   vec_add (t->packet_data, packet_data, n_packet_data_bytes);
 799
 800   vlib_worker_thread_barrier_release(vm);
 801 }
 802
 803 void *
 804 vlib_packet_template_get_packet (vlib_main_t * vm,
 805                                  vlib_packet_template_t * t,
 806                                  u32 * bi_result)
 807 {
 808   u32 bi;
 809   vlib_buffer_t * b;
 810
 811   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
 812     return 0;
 813
 814   *bi_result = bi;
 815
 816   b = vlib_get_buffer (vm, bi);
 817   memcpy (vlib_buffer_get_current (b),
 818           t->packet_data, vec_len(t->packet_data));
 819   b->current_length = vec_len(t->packet_data);
 820
 821   /* Fix up mbuf header length fields */
 822   struct rte_mbuf * mb;
 823   mb = ((struct rte_mbuf *)b) - 1;
 824   mb->data_len = b->current_length;
 825   mb->pkt_len = b->current_length;
 826
 827   return b->data;
 828 }
 829
 830 /* Append given data to end of buffer, possibly allocating new buffers. */
 831 u32 vlib_buffer_add_data (vlib_main_t * vm,
 832                           u32 free_list_index,
 833                           u32 buffer_index,
 834                           void * data, u32 n_data_bytes)
 835 {
 836   u32 n_buffer_bytes, n_left, n_left_this_buffer, bi;
 837   vlib_buffer_t * b;
 838   void * d;
 839
 840   bi = buffer_index;
 841   if (bi == 0
 842       && 1 != vlib_buffer_alloc_from_free_list (vm, &bi, 1, free_list_index))
 843     goto out_of_buffers;
 844
 845   d = data;
 846   n_left = n_data_bytes;
 847   n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, free_list_index);
 848
 849   b = vlib_get_buffer (vm, bi);
 850   b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 851
 852   /* Get to the end of the chain before we try to append data...*/
 853   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 854     b = vlib_get_buffer (vm, b->next_buffer);
 855
 856   while (1)
 857     {
 858       u32 n;
 859
 860       ASSERT (n_buffer_bytes >= b->current_length);
 861       n_left_this_buffer = n_buffer_bytes - (b->current_data + b->current_length);
 862       n = clib_min (n_left_this_buffer, n_left);
 863       memcpy (vlib_buffer_get_current (b) + b->current_length, d, n);
 864       b->current_length += n;
 865       n_left -= n;
 866       if (n_left == 0)
 867         break;
 868
 869       d += n;
 870       if (1 != vlib_buffer_alloc_from_free_list (vm, &b->next_buffer, 1, free_list_index))
 871         goto out_of_buffers;
 872
 873       b->flags |= VLIB_BUFFER_NEXT_PRESENT;
 874
 875       b = vlib_get_buffer (vm, b->next_buffer);
 876     }
 877
 878   return bi;
 879
 880  out_of_buffers:
 881   clib_error ("out of buffers");
 882   return bi;
 883 }
 884
 885 u16
 886 vlib_buffer_chain_append_data_with_alloc(vlib_main_t *vm,
 887                              u32 free_list_index,
 888                              vlib_buffer_t *first,
 889                              vlib_buffer_t **last,
 890                              void * data, u16 data_len) {
 891   vlib_buffer_t *l = *last;
 892   u32 n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, free_list_index);
 893   u16 copied = 0;
 894   ASSERT(n_buffer_bytes >= l->current_length + l->current_data);
 895   while (data_len) {
 896     u16 max = n_buffer_bytes - l->current_length - l->current_data;
 897     if (max == 0) {
 898       if (1 != vlib_buffer_alloc_from_free_list (vm, &l->next_buffer, 1, free_list_index))
 899         return copied;
 900       *last = l = vlib_buffer_chain_buffer(vm, first, l, l->next_buffer);
 901       max = n_buffer_bytes - l->current_length - l->current_data;
 902     }
 903
 904     u16 len = (data_len > max)?max:data_len;
 905     rte_memcpy(vlib_buffer_get_current (l) + l->current_length, data + copied, len);
 906     vlib_buffer_chain_increase_length(first, l, len);
 907     data_len -= len;
 908     copied += len;
 909   }
 910   return copied;
 911 }
 912
 913 /*
 914  * Fills in the required rte_mbuf fields for chained buffers given a VLIB chain.
 915  */
 916 void vlib_buffer_chain_validate (vlib_main_t * vm, vlib_buffer_t * b_first)
 917 {
 918   vlib_buffer_t *b = b_first, *prev = b_first;
 919   struct rte_mbuf *mb_first = ((struct rte_mbuf *) b) - 1;
 920
 921   mb_first->pkt_len = mb_first-> data_len = b_first->current_length;
 922   while (b->flags & VLIB_BUFFER_NEXT_PRESENT) {
 923       b = vlib_get_buffer(vm, b->next_buffer);
 924       mb_first->nb_segs++;
 925       mb_first->pkt_len += b->current_length;
 926       (((struct rte_mbuf *) prev) - 1)->next = (((struct rte_mbuf *) b) - 1);
 927       (((struct rte_mbuf *) b) - 1)->data_len = b->current_length;
 928       prev = b;
 929   }
 930 }
 931
 932 clib_error_t *
 933 vlib_buffer_pool_create(vlib_main_t * vm, unsigned num_mbufs,
 934                         unsigned mbuf_size, unsigned socket_id)
 935 {
 936   vlib_buffer_main_t * bm = vm->buffer_main;
 937   vlib_physmem_main_t * vpm = &vm->physmem_main;
 938   struct rte_mempool * rmp;
 939   uword new_start, new_size;
 940   int i;
 941
 942   if (!rte_mempool_create)
 943     return clib_error_return (0, "not linked with DPDK");
 944
 945   vec_validate_aligned(bm->pktmbuf_pools, socket_id, CLIB_CACHE_LINE_BYTES);
 946
 947   /* pool already exists, nothing to do */
 948   if (bm->pktmbuf_pools[socket_id])
 949     return 0;
 950
 951   u8 * pool_name = format(0, "mbuf_pool_socket%u%c",socket_id, 0);
 952   rmp = rte_mempool_create((char *) pool_name,
 953                            num_mbufs, mbuf_size, 512,
 954                            sizeof(struct rte_pktmbuf_pool_private),
 955                            rte_pktmbuf_pool_init, NULL,
 956                            rte_pktmbuf_init, NULL,
 957                            socket_id, 0);
 958   vec_free(pool_name);
 959
 960   if (rmp)
 961     {
 962       new_start = pointer_to_uword(rmp);
 963       new_size = rmp->elt_va_end - new_start;
 964
 965       if (vpm->virtual.size > 0)
 966         {
 967           ASSERT(new_start != vpm->virtual.start);
 968           if (new_start < vpm->virtual.start)
 969             {
 970               new_size = vpm->virtual.size + vpm->virtual.start - new_start;
 971             }
 972           else
 973             {
 974               new_size += new_start - vpm->virtual.start;
 975               new_start = vpm->virtual.start;
 976             }
 977
 978           /* check if fits into buffer index range */
 979           if (new_size > ( (uword) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
 980             rmp = 0;
 981         }
 982     }
 983
 984   if (rmp)
 985     {
 986       bm->pktmbuf_pools[socket_id] = rmp;
 987       vpm->virtual.start = new_start;
 988       vpm->virtual.size = new_size;
 989       vpm->virtual.end = new_start + new_size;
 990       return 0;
 991     }
 992
 993   /* no usable pool for this socket, try to use pool from another one */
 994   for (i = 0; i < vec_len(bm->pktmbuf_pools); i++)
 995     {
 996       if(bm->pktmbuf_pools[i])
 997        {
 998           clib_warning("WARNING: Failed to allocate mempool for CPU socket %u. "
 999                        "Threads running on socket %u will use socket %u mempool.",
1000                        socket_id, socket_id, i);
1001           bm->pktmbuf_pools[socket_id] = bm->pktmbuf_pools[i];
1002           return 0;
1003        }
1004     }
1005
1006   return clib_error_return (0, "failed to allocate mempool on socket %u",
1007                             socket_id);
1008 }
1009
1010
1011 static void vlib_serialize_tx (serialize_main_header_t * m, serialize_stream_t * s)
1012 {
1013   vlib_main_t * vm;
1014   vlib_serialize_buffer_main_t * sm;
1015   uword n, n_bytes_to_write;
1016   vlib_buffer_t * last;
1017
1018   n_bytes_to_write = s->current_buffer_index;
1019   sm = uword_to_pointer (s->data_function_opaque, vlib_serialize_buffer_main_t *);
1020   vm = sm->vlib_main;
1021
1022   ASSERT (sm->tx.max_n_data_bytes_per_chain > 0);
1023   if (serialize_stream_is_end_of_stream (s)
1024       || sm->tx.n_total_data_bytes + n_bytes_to_write > sm->tx.max_n_data_bytes_per_chain)
1025     {
1026       vlib_process_t * p = vlib_get_current_process (vm);
1027
1028       last = vlib_get_buffer (vm, sm->last_buffer);
1029       last->current_length = n_bytes_to_write;
1030
1031       vlib_set_next_frame_buffer (vm, &p->node_runtime, sm->tx.next_index, sm->first_buffer);
1032
1033       sm->first_buffer = sm->last_buffer = ~0;
1034       sm->tx.n_total_data_bytes = 0;
1035     }
1036
1037   else if (n_bytes_to_write == 0 && s->n_buffer_bytes == 0)
1038     {
1039       ASSERT (sm->first_buffer == ~0);
1040       ASSERT (sm->last_buffer == ~0);
1041       n = vlib_buffer_alloc_from_free_list (vm, &sm->first_buffer, 1, sm->tx.free_list_index);
1042       if (n != 1)
1043         serialize_error (m, clib_error_create ("vlib_buffer_alloc_from_free_list fails"));
1044       sm->last_buffer = sm->first_buffer;
1045       s->n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, sm->tx.free_list_index);
1046     }
1047
1048   if (n_bytes_to_write > 0)
1049     {
1050       vlib_buffer_t * prev = vlib_get_buffer (vm, sm->last_buffer);
1051       n = vlib_buffer_alloc_from_free_list (vm, &sm->last_buffer, 1, sm->tx.free_list_index);
1052       if (n != 1)
1053         serialize_error (m, clib_error_create ("vlib_buffer_alloc_from_free_list fails"));
1054       sm->tx.n_total_data_bytes += n_bytes_to_write;
1055       prev->current_length = n_bytes_to_write;
1056       prev->next_buffer = sm->last_buffer;
1057       prev->flags |= VLIB_BUFFER_NEXT_PRESENT;
1058     }
1059
1060   if (sm->last_buffer != ~0)
1061     {
1062       last = vlib_get_buffer (vm, sm->last_buffer);
1063       s->buffer = vlib_buffer_get_current (last);
1064       s->current_buffer_index = 0;
1065       ASSERT (last->current_data == s->current_buffer_index);
1066     }
1067 }
1068
1069 static void vlib_serialize_rx (serialize_main_header_t * m, serialize_stream_t * s)
1070 {
1071   vlib_main_t * vm;
1072   vlib_serialize_buffer_main_t * sm;
1073   vlib_buffer_t * last;
1074
1075   sm = uword_to_pointer (s->data_function_opaque, vlib_serialize_buffer_main_t *);
1076   vm = sm->vlib_main;
1077
1078   if (serialize_stream_is_end_of_stream (s))
1079     return;
1080
1081   if (sm->last_buffer != ~0)
1082     {
1083       last = vlib_get_buffer (vm, sm->last_buffer);
1084
1085       if (last->flags & VLIB_BUFFER_NEXT_PRESENT)
1086         sm->last_buffer = last->next_buffer;
1087       else
1088         {
1089           vlib_buffer_free (vm, &sm->first_buffer, /* count */ 1);
1090           sm->first_buffer = sm->last_buffer = ~0;
1091         }
1092     }
1093
1094   if (sm->last_buffer == ~0)
1095     {
1096       while (clib_fifo_elts (sm->rx.buffer_fifo) == 0)
1097         {
1098           sm->rx.ready_one_time_event = vlib_process_create_one_time_event (vm, vlib_current_process (vm), ~0);
1099           vlib_process_wait_for_one_time_event (vm, /* no event data */ 0, sm->rx.ready_one_time_event);
1100         }
1101
1102       clib_fifo_sub1 (sm->rx.buffer_fifo, sm->first_buffer);
1103       sm->last_buffer = sm->first_buffer;
1104     }
1105
1106   ASSERT (sm->last_buffer != ~0);
1107
1108   last = vlib_get_buffer (vm, sm->last_buffer);
1109   s->current_buffer_index = 0;
1110   s->buffer = vlib_buffer_get_current (last);
1111   s->n_buffer_bytes = last->current_length;
1112 }
1113
1114 static void
1115 serialize_open_vlib_helper (serialize_main_t * m,
1116                             vlib_main_t * vm,
1117                             vlib_serialize_buffer_main_t * sm,
1118                             uword is_read)
1119 {
1120   /* Initialize serialize main but save overflow buffer for re-use between calls. */
1121   {
1122     u8 * save = m->stream.overflow_buffer;
1123     memset (m, 0, sizeof (m[0]));
1124     m->stream.overflow_buffer = save;
1125     if (save)
1126       _vec_len (save) = 0;
1127   }
1128
1129   sm->first_buffer = sm->last_buffer = ~0;
1130   if (is_read)
1131     clib_fifo_reset (sm->rx.buffer_fifo);
1132   else
1133     sm->tx.n_total_data_bytes = 0;
1134   sm->vlib_main = vm;
1135   m->header.data_function = is_read ? vlib_serialize_rx : vlib_serialize_tx;
1136   m->stream.data_function_opaque = pointer_to_uword (sm);
1137 }
1138
1139 void serialize_open_vlib_buffer (serialize_main_t * m, vlib_main_t * vm, vlib_serialize_buffer_main_t * sm)
1140 { serialize_open_vlib_helper (m, vm, sm, /* is_read */ 0); }
1141
1142 void unserialize_open_vlib_buffer (serialize_main_t * m, vlib_main_t * vm, vlib_serialize_buffer_main_t * sm)
1143 { serialize_open_vlib_helper (m, vm, sm, /* is_read */ 1); }
1144
1145 u32 serialize_close_vlib_buffer (serialize_main_t * m)
1146 {
1147   vlib_serialize_buffer_main_t * sm
1148     = uword_to_pointer (m->stream.data_function_opaque, vlib_serialize_buffer_main_t *);
1149   vlib_buffer_t * last;
1150   serialize_stream_t * s = &m->stream;
1151
1152   last = vlib_get_buffer (sm->vlib_main, sm->last_buffer);
1153   last->current_length = s->current_buffer_index;
1154
1155   if (vec_len (s->overflow_buffer) > 0)
1156     {
1157       sm->last_buffer
1158         = vlib_buffer_add_data (sm->vlib_main, sm->tx.free_list_index,
1159                                 sm->last_buffer == ~0 ? 0 : sm->last_buffer,
1160                                 s->overflow_buffer,
1161                                 vec_len (s->overflow_buffer));
1162       _vec_len (s->overflow_buffer) = 0;
1163     }
1164
1165   return sm->first_buffer;
1166 }
1167
1168 void unserialize_close_vlib_buffer (serialize_main_t * m)
1169 {
1170   vlib_serialize_buffer_main_t * sm
1171     = uword_to_pointer (m->stream.data_function_opaque, vlib_serialize_buffer_main_t *);
1172   if (sm->first_buffer != ~0)
1173     vlib_buffer_free_one (sm->vlib_main, sm->first_buffer);
1174   clib_fifo_reset (sm->rx.buffer_fifo);
1175   if (m->stream.overflow_buffer)
1176     _vec_len (m->stream.overflow_buffer) = 0;
1177 }
1178
1179 static u8 * format_vlib_buffer_free_list (u8 * s, va_list * va)
1180 {
1181   vlib_buffer_free_list_t * f = va_arg (*va, vlib_buffer_free_list_t *);
1182   u32 threadnum= va_arg (*va, u32);
1183   uword bytes_alloc, bytes_free, n_free, size;
1184
1185   if (! f)
1186     return format (s, "%=7s%=30s%=12s%=12s%=12s%=12s%=12s%=12s",
1187                    "Thread", "Name", "Index", "Size", "Alloc", "Free", "#Alloc", "#Free");
1188
1189   size = sizeof (vlib_buffer_t) + f->n_data_bytes;
1190   n_free = vec_len (f->aligned_buffers) + vec_len (f->unaligned_buffers);
1191   bytes_alloc = size * f->n_alloc;
1192   bytes_free = size * n_free;
1193
1194   s = format (s, "%7d%30s%12d%12d%=12U%=12U%=12d%=12d",
1195               threadnum,
1196               f->name, f->index, f->n_data_bytes,
1197               format_memory_size, bytes_alloc,
1198               format_memory_size, bytes_free,
1199               f->n_alloc, n_free);
1200
1201   return s;
1202 }
1203
1204 static clib_error_t *
1205 show_buffers (vlib_main_t * vm,
1206               unformat_input_t * input,
1207               vlib_cli_command_t * cmd)
1208 {
1209   vlib_buffer_main_t * bm;
1210   vlib_buffer_free_list_t * f;
1211   vlib_main_t *curr_vm;
1212   u32 vm_index = 0;
1213
1214   vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, 0, 0);
1215
1216   do {
1217     curr_vm = vec_len(vlib_mains) ? vlib_mains[vm_index] : vm;
1218     bm = curr_vm->buffer_main;
1219
1220     pool_foreach (f, bm->buffer_free_list_pool, ({
1221       vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, f, vm_index);
1222     }));
1223
1224     vm_index++;
1225   } while (vm_index < vec_len(vlib_mains));
1226
1227   return 0;
1228 }
1229
1230 VLIB_CLI_COMMAND (show_buffers_command, static) = {
1231   .path = "show buffers",
1232   .short_help = "Show packet buffer allocation",
1233   .function = show_buffers,
1234 };
1235
1236 #if CLIB_DEBUG > 0
1237
1238 u32 * vlib_buffer_state_validation_lock;
1239 uword * vlib_buffer_state_validation_hash;
1240 void * vlib_buffer_state_heap;
1241
1242 static clib_error_t *
1243 buffer_state_validation_init (vlib_main_t * vm)
1244 {
1245   void * oldheap;
1246
1247   vlib_buffer_state_heap = mheap_alloc (0, 10<<20);
1248
1249   oldheap = clib_mem_set_heap (vlib_buffer_state_heap);
1250
1251   vlib_buffer_state_validation_hash = hash_create (0, sizeof(uword));
1252   vec_validate_aligned (vlib_buffer_state_validation_lock, 0,
1253                         CLIB_CACHE_LINE_BYTES);
1254   clib_mem_set_heap (oldheap);
1255   return 0;
1256 }
1257
1258 VLIB_INIT_FUNCTION (buffer_state_validation_init);
1259 #endif