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_memzone.h>
  46 #include <rte_tailq.h>
  47 #include <rte_eal.h>
  48 #include <rte_per_lcore.h>
  49 #include <rte_launch.h>
  50 #include <rte_atomic.h>
  51 #include <rte_cycles.h>
  52 #include <rte_prefetch.h>
  53 #include <rte_lcore.h>
  54 #include <rte_per_lcore.h>
  55 #include <rte_branch_prediction.h>
  56 #include <rte_interrupts.h>
  57 #include <rte_pci.h>
  58 #include <rte_random.h>
  59 #include <rte_debug.h>
  60 #include <rte_ether.h>
  61 #include <rte_ethdev.h>
  62 #include <rte_ring.h>
  63 #include <rte_mempool.h>
  64 #include <rte_mbuf.h>
  65
  66 #include <vlib/vlib.h>
  67
  68 #pragma weak rte_mem_virt2phy
  69 #pragma weak rte_eal_has_hugepages
  70 #pragma weak rte_socket_id
  71 #pragma weak rte_pktmbuf_pool_create
  72
  73 uword
  74 vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm,
  75                                        vlib_buffer_t * b_first)
  76 {
  77   vlib_buffer_t *b = b_first;
  78   uword l_first = b_first->current_length;
  79   uword l = 0;
  80   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
  81     {
  82       b = vlib_get_buffer (vm, b->next_buffer);
  83       l += b->current_length;
  84     }
  85   b_first->total_length_not_including_first_buffer = l;
  86   b_first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  87   return l + l_first;
  88 }
  89
  90 u8 *
  91 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, b->free_list_index);
  98
  99   if (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID)
 100     s = format (s, ", totlen-nifb %d",
 101                 b->total_length_not_including_first_buffer);
 102
 103   if (b->flags & VLIB_BUFFER_IS_TRACED)
 104     s = format (s, ", trace 0x%x", b->trace_index);
 105
 106   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 107     {
 108       vlib_main_t *vm = vlib_get_main ();
 109       u32 next_buffer = b->next_buffer;
 110       b = vlib_get_buffer (vm, next_buffer);
 111
 112       s = format (s, "\n%Unext-buffer 0x%x, segment length %d",
 113                   format_white_space, indent, next_buffer, b->current_length);
 114     }
 115
 116
 117   return s;
 118 }
 119
 120 u8 *
 121 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 *
 133 format_vlib_buffer_contents (u8 * s, va_list * va)
 134 {
 135   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
 136   vlib_buffer_t *b = va_arg (*va, vlib_buffer_t *);
 137
 138   while (1)
 139     {
 140       vec_add (s, vlib_buffer_get_current (b), 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, u32 is_default, u8 * name)
 312 {
 313   vlib_buffer_main_t *bm = vm->buffer_main;
 314   vlib_buffer_free_list_t *f;
 315
 316   if (!is_default && pool_elts (bm->buffer_free_list_pool) == 0)
 317     {
 318       u32 default_free_free_list_index;
 319
 320       /* *INDENT-OFF* */
 321       default_free_free_list_index =
 322         vlib_buffer_create_free_list_helper
 323         (vm,
 324          /* default buffer size */ VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES,
 325          /* is_public */ 1,
 326          /* is_default */ 1,
 327          (u8 *) "default");
 328       /* *INDENT-ON* */
 329       ASSERT (default_free_free_list_index ==
 330               VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 331
 332       if (n_data_bytes == VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES && is_public)
 333         return default_free_free_list_index;
 334     }
 335
 336   pool_get_aligned (bm->buffer_free_list_pool, f, CLIB_CACHE_LINE_BYTES);
 337
 338   memset (f, 0, sizeof (f[0]));
 339   f->index = f - bm->buffer_free_list_pool;
 340   f->n_data_bytes = vlib_buffer_round_size (n_data_bytes);
 341   f->min_n_buffers_each_physmem_alloc = 16;
 342   f->name = clib_mem_is_heap_object (name) ? name : format (0, "%s", name);
 343
 344   /* Setup free buffer template. */
 345   f->buffer_init_template.free_list_index = f->index;
 346
 347   if (is_public)
 348     {
 349       uword *p = hash_get (bm->free_list_by_size, f->n_data_bytes);
 350       if (!p)
 351         hash_set (bm->free_list_by_size, f->n_data_bytes, f->index);
 352     }
 353
 354   return f->index;
 355 }
 356
 357 u32
 358 vlib_buffer_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
 359                               char *fmt, ...)
 360 {
 361   va_list va;
 362   u8 *name;
 363
 364   va_start (va, fmt);
 365   name = va_format (0, fmt, &va);
 366   va_end (va);
 367
 368   return vlib_buffer_create_free_list_helper (vm, n_data_bytes,
 369                                               /* is_public */ 0,
 370                                               /* is_default */ 0,
 371                                               name);
 372 }
 373
 374 u32
 375 vlib_buffer_get_or_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
 376                                      char *fmt, ...)
 377 {
 378   u32 i = vlib_buffer_get_free_list_with_size (vm, n_data_bytes);
 379
 380   if (i == ~0)
 381     {
 382       va_list va;
 383       u8 *name;
 384
 385       va_start (va, fmt);
 386       name = va_format (0, fmt, &va);
 387       va_end (va);
 388
 389       i = vlib_buffer_create_free_list_helper (vm, n_data_bytes,
 390                                                /* is_public */ 1,
 391                                                /* is_default */ 0,
 392                                                name);
 393     }
 394
 395   return i;
 396 }
 397
 398 static void
 399 del_free_list (vlib_main_t * vm, vlib_buffer_free_list_t * f)
 400 {
 401   u32 i;
 402   struct rte_mbuf *mb;
 403   vlib_buffer_t *b;
 404
 405   for (i = 0; i < vec_len (f->unaligned_buffers); i++)
 406     {
 407       b = vlib_get_buffer (vm, f->unaligned_buffers[i]);
 408       mb = rte_mbuf_from_vlib_buffer (b);
 409       ASSERT (rte_mbuf_refcnt_read (mb) == 1);
 410       rte_pktmbuf_free (mb);
 411     }
 412   for (i = 0; i < vec_len (f->aligned_buffers); i++)
 413     {
 414       b = vlib_get_buffer (vm, f->aligned_buffers[i]);
 415       mb = rte_mbuf_from_vlib_buffer (b);
 416       ASSERT (rte_mbuf_refcnt_read (mb) == 1);
 417       rte_pktmbuf_free (mb);
 418     }
 419   vec_free (f->name);
 420   vec_free (f->unaligned_buffers);
 421   vec_free (f->aligned_buffers);
 422 }
 423
 424 /* Add buffer free list. */
 425 void
 426 vlib_buffer_delete_free_list (vlib_main_t * vm, u32 free_list_index)
 427 {
 428   vlib_buffer_main_t *bm = vm->buffer_main;
 429   vlib_buffer_free_list_t *f;
 430   u32 merge_index;
 431
 432   f = vlib_buffer_get_free_list (vm, free_list_index);
 433
 434   merge_index = vlib_buffer_get_free_list_with_size (vm, f->n_data_bytes);
 435   if (merge_index != ~0 && merge_index != free_list_index)
 436     {
 437       merge_free_lists (pool_elt_at_index (bm->buffer_free_list_pool,
 438                                            merge_index), f);
 439     }
 440
 441   del_free_list (vm, f);
 442
 443   /* Poison it. */
 444   memset (f, 0xab, sizeof (f[0]));
 445
 446   pool_put (bm->buffer_free_list_pool, f);
 447 }
 448
 449 /* Make sure free list has at least given number of free buffers. */
 450 static uword
 451 fill_free_list (vlib_main_t * vm,
 452                 vlib_buffer_free_list_t * fl, uword min_free_buffers)
 453 {
 454   vlib_buffer_t *b;
 455   int n, i;
 456   u32 bi;
 457   u32 n_remaining = 0, n_alloc = 0;
 458   unsigned socket_id = rte_socket_id ? rte_socket_id () : 0;
 459   struct rte_mempool *rmp = vm->buffer_main->pktmbuf_pools[socket_id];
 460   struct rte_mbuf *mb;
 461
 462   /* Too early? */
 463   if (PREDICT_FALSE (rmp == 0))
 464     return 0;
 465
 466   trim_aligned (fl);
 467
 468   /* Already have enough free buffers on free list? */
 469   n = min_free_buffers - vec_len (fl->aligned_buffers);
 470   if (n <= 0)
 471     return min_free_buffers;
 472
 473   /* Always allocate round number of buffers. */
 474   n = round_pow2 (n, BUFFERS_PER_COPY);
 475
 476   /* Always allocate new buffers in reasonably large sized chunks. */
 477   n = clib_max (n, fl->min_n_buffers_each_physmem_alloc);
 478
 479   vec_validate (vm->mbuf_alloc_list, n - 1);
 480
 481   if (rte_mempool_get_bulk (rmp, vm->mbuf_alloc_list, n) < 0)
 482     return 0;
 483
 484   _vec_len (vm->mbuf_alloc_list) = n;
 485
 486   for (i = 0; i < n; i++)
 487     {
 488       mb = vm->mbuf_alloc_list[i];
 489
 490       ASSERT (rte_mbuf_refcnt_read (mb) == 0);
 491       rte_mbuf_refcnt_set (mb, 1);
 492       mb->next = NULL;
 493       mb->data_off = RTE_PKTMBUF_HEADROOM;
 494       mb->nb_segs = 1;
 495
 496       b = vlib_buffer_from_rte_mbuf (mb);
 497       bi = vlib_get_buffer_index (vm, b);
 498
 499       vec_add1_aligned (fl->aligned_buffers, bi, sizeof (vlib_copy_unit_t));
 500       n_alloc++;
 501       n_remaining--;
 502
 503       vlib_buffer_init_for_free_list (b, fl);
 504
 505       if (fl->buffer_init_function)
 506         fl->buffer_init_function (vm, fl, &bi, 1);
 507     }
 508
 509   fl->n_alloc += n;
 510
 511   return n;
 512 }
 513
 514 always_inline uword
 515 copy_alignment (u32 * x)
 516 {
 517   return (pointer_to_uword (x) / sizeof (x[0])) % BUFFERS_PER_COPY;
 518 }
 519
 520 static u32
 521 alloc_from_free_list (vlib_main_t * vm,
 522                       vlib_buffer_free_list_t * free_list,
 523                       u32 * alloc_buffers, u32 n_alloc_buffers)
 524 {
 525   u32 *dst, *u_src;
 526   uword u_len, n_left;
 527   uword n_unaligned_start, n_unaligned_end, n_filled;
 528
 529   n_left = n_alloc_buffers;
 530   dst = alloc_buffers;
 531   n_unaligned_start = ((BUFFERS_PER_COPY - copy_alignment (dst))
 532                        & (BUFFERS_PER_COPY - 1));
 533
 534   n_filled = fill_free_list (vm, free_list, n_alloc_buffers);
 535   if (n_filled == 0)
 536     return 0;
 537
 538   n_left = n_filled < n_left ? n_filled : n_left;
 539   n_alloc_buffers = n_left;
 540
 541   if (n_unaligned_start >= n_left)
 542     {
 543       n_unaligned_start = n_left;
 544       n_unaligned_end = 0;
 545     }
 546   else
 547     n_unaligned_end = copy_alignment (dst + n_alloc_buffers);
 548
 549   fill_unaligned (vm, free_list, n_unaligned_start + n_unaligned_end);
 550
 551   u_len = vec_len (free_list->unaligned_buffers);
 552   u_src = free_list->unaligned_buffers + u_len - 1;
 553
 554   if (n_unaligned_start)
 555     {
 556       uword n_copy = n_unaligned_start;
 557       if (n_copy > n_left)
 558         n_copy = n_left;
 559       n_left -= n_copy;
 560
 561       while (n_copy > 0)
 562         {
 563           *dst++ = *u_src--;
 564           n_copy--;
 565           u_len--;
 566         }
 567
 568       /* Now dst should be aligned. */
 569       if (n_left > 0)
 570         ASSERT (pointer_to_uword (dst) % sizeof (vlib_copy_unit_t) == 0);
 571     }
 572
 573   /* Aligned copy. */
 574   {
 575     vlib_copy_unit_t *d, *s;
 576     uword n_copy;
 577
 578     if (vec_len (free_list->aligned_buffers) <
 579         ((n_left / BUFFERS_PER_COPY) * BUFFERS_PER_COPY))
 580       abort ();
 581
 582     n_copy = n_left / BUFFERS_PER_COPY;
 583     n_left = n_left % BUFFERS_PER_COPY;
 584
 585     /* Remove buffers from aligned free list. */
 586     _vec_len (free_list->aligned_buffers) -= n_copy * BUFFERS_PER_COPY;
 587
 588     s = (vlib_copy_unit_t *) vec_end (free_list->aligned_buffers);
 589     d = (vlib_copy_unit_t *) dst;
 590
 591     /* Fast path loop. */
 592     while (n_copy >= 4)
 593       {
 594         d[0] = s[0];
 595         d[1] = s[1];
 596         d[2] = s[2];
 597         d[3] = s[3];
 598         n_copy -= 4;
 599         s += 4;
 600         d += 4;
 601       }
 602
 603     while (n_copy >= 1)
 604       {
 605         d[0] = s[0];
 606         n_copy -= 1;
 607         s += 1;
 608         d += 1;
 609       }
 610
 611     dst = (void *) d;
 612   }
 613
 614   /* Unaligned copy. */
 615   ASSERT (n_unaligned_end == n_left);
 616   while (n_left > 0)
 617     {
 618       *dst++ = *u_src--;
 619       n_left--;
 620       u_len--;
 621     }
 622
 623   if (!free_list->unaligned_buffers)
 624     ASSERT (u_len == 0);
 625   else
 626     _vec_len (free_list->unaligned_buffers) = u_len;
 627
 628   return n_alloc_buffers;
 629 }
 630
 631 /* Allocate a given number of buffers into given array.
 632    Returns number actually allocated which will be either zero or
 633    number requested. */
 634 u32
 635 vlib_buffer_alloc (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 636 {
 637   vlib_buffer_main_t *bm = vm->buffer_main;
 638
 639   return alloc_from_free_list
 640     (vm,
 641      pool_elt_at_index (bm->buffer_free_list_pool,
 642                         VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX),
 643      buffers, n_buffers);
 644 }
 645
 646 u32
 647 vlib_buffer_alloc_from_free_list (vlib_main_t * vm,
 648                                   u32 * buffers,
 649                                   u32 n_buffers, u32 free_list_index)
 650 {
 651   vlib_buffer_main_t *bm = vm->buffer_main;
 652   vlib_buffer_free_list_t *f;
 653   f = pool_elt_at_index (bm->buffer_free_list_pool, free_list_index);
 654   return alloc_from_free_list (vm, f, buffers, n_buffers);
 655 }
 656
 657 always_inline void
 658 add_buffer_to_free_list (vlib_main_t * vm,
 659                          vlib_buffer_free_list_t * f,
 660                          u32 buffer_index, u8 do_init)
 661 {
 662   vlib_buffer_t *b;
 663   b = vlib_get_buffer (vm, buffer_index);
 664   if (PREDICT_TRUE (do_init))
 665     vlib_buffer_init_for_free_list (b, f);
 666   vec_add1_aligned (f->aligned_buffers, buffer_index,
 667                     sizeof (vlib_copy_unit_t));
 668 }
 669
 670 always_inline vlib_buffer_free_list_t *
 671 buffer_get_free_list (vlib_main_t * vm, vlib_buffer_t * b, u32 * index)
 672 {
 673   vlib_buffer_main_t *bm = vm->buffer_main;
 674   u32 i;
 675
 676   *index = i = b->free_list_index;
 677   return pool_elt_at_index (bm->buffer_free_list_pool, i);
 678 }
 679
 680 void *
 681 vlib_set_buffer_free_callback (vlib_main_t * vm, void *fp)
 682 {
 683   vlib_buffer_main_t *bm = vm->buffer_main;
 684   void *rv = bm->buffer_free_callback;
 685
 686   bm->buffer_free_callback = fp;
 687   return rv;
 688 }
 689
 690 static_always_inline void
 691 vlib_buffer_free_inline (vlib_main_t * vm,
 692                          u32 * buffers, u32 n_buffers, u32 follow_buffer_next)
 693 {
 694   vlib_buffer_main_t *bm = vm->buffer_main;
 695   vlib_buffer_free_list_t *fl;
 696   u32 fi;
 697   int i;
 698   u32 (*cb) (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 699              u32 follow_buffer_next);
 700
 701   cb = bm->buffer_free_callback;
 702
 703   if (PREDICT_FALSE (cb != 0))
 704     n_buffers = (*cb) (vm, buffers, n_buffers, follow_buffer_next);
 705
 706   if (!n_buffers)
 707     return;
 708
 709   for (i = 0; i < n_buffers; i++)
 710     {
 711       vlib_buffer_t *b;
 712       struct rte_mbuf *mb;
 713
 714       b = vlib_get_buffer (vm, buffers[i]);
 715
 716       fl = buffer_get_free_list (vm, b, &fi);
 717
 718       /* The only current use of this callback: multicast recycle */
 719       if (PREDICT_FALSE (fl->buffers_added_to_freelist_function != 0))
 720         {
 721           int j;
 722
 723           add_buffer_to_free_list
 724             (vm, fl, buffers[i], (b->flags & VLIB_BUFFER_RECYCLE) == 0);
 725
 726           for (j = 0; j < vec_len (bm->announce_list); j++)
 727             {
 728               if (fl == bm->announce_list[j])
 729                 goto already_announced;
 730             }
 731           vec_add1 (bm->announce_list, fl);
 732         already_announced:
 733           ;
 734         }
 735       else
 736         {
 737           if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_RECYCLE) == 0))
 738             {
 739               mb = rte_mbuf_from_vlib_buffer (b);
 740               ASSERT (rte_mbuf_refcnt_read (mb) == 1);
 741               rte_pktmbuf_free (mb);
 742             }
 743         }
 744     }
 745   if (vec_len (bm->announce_list))
 746     {
 747       vlib_buffer_free_list_t *fl;
 748       for (i = 0; i < vec_len (bm->announce_list); i++)
 749         {
 750           fl = bm->announce_list[i];
 751           fl->buffers_added_to_freelist_function (vm, fl);
 752         }
 753       _vec_len (bm->announce_list) = 0;
 754     }
 755 }
 756
 757 void
 758 vlib_buffer_free (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 759 {
 760   vlib_buffer_free_inline (vm, buffers, n_buffers,      /* follow_buffer_next */
 761                            1);
 762 }
 763
 764 void
 765 vlib_buffer_free_no_next (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 766 {
 767   vlib_buffer_free_inline (vm, buffers, n_buffers,      /* follow_buffer_next */
 768                            0);
 769 }
 770
 771 /* Copy template packet data into buffers as they are allocated. */
 772 __attribute__ ((unused))
 773      static void
 774        vlib_packet_template_buffer_init (vlib_main_t * vm,
 775                                          vlib_buffer_free_list_t * fl,
 776                                          u32 * buffers, u32 n_buffers)
 777 {
 778   vlib_packet_template_t *t =
 779     uword_to_pointer (fl->buffer_init_function_opaque,
 780                       vlib_packet_template_t *);
 781   uword i;
 782
 783   for (i = 0; i < n_buffers; i++)
 784     {
 785       vlib_buffer_t *b = vlib_get_buffer (vm, buffers[i]);
 786       ASSERT (b->current_length == vec_len (t->packet_data));
 787       clib_memcpy (vlib_buffer_get_current (b), t->packet_data,
 788                    b->current_length);
 789     }
 790 }
 791
 792 void
 793 vlib_packet_template_init (vlib_main_t * vm,
 794                            vlib_packet_template_t * t,
 795                            void *packet_data,
 796                            uword n_packet_data_bytes,
 797                            uword min_n_buffers_each_physmem_alloc,
 798                            char *fmt, ...)
 799 {
 800   va_list va;
 801   __attribute__ ((unused)) u8 *name;
 802
 803   va_start (va, fmt);
 804   name = va_format (0, fmt, &va);
 805   va_end (va);
 806
 807   vlib_worker_thread_barrier_sync (vm);
 808   memset (t, 0, sizeof (t[0]));
 809
 810   vec_add (t->packet_data, packet_data, n_packet_data_bytes);
 811
 812   vlib_worker_thread_barrier_release (vm);
 813 }
 814
 815 void *
 816 vlib_packet_template_get_packet (vlib_main_t * vm,
 817                                  vlib_packet_template_t * t, u32 * bi_result)
 818 {
 819   u32 bi;
 820   vlib_buffer_t *b;
 821
 822   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
 823     return 0;
 824
 825   *bi_result = bi;
 826
 827   b = vlib_get_buffer (vm, bi);
 828   clib_memcpy (vlib_buffer_get_current (b),
 829                t->packet_data, vec_len (t->packet_data));
 830   b->current_length = vec_len (t->packet_data);
 831
 832   /* Fix up mbuf header length fields */
 833   struct rte_mbuf *mb;
 834   mb = rte_mbuf_from_vlib_buffer (b);
 835   mb->data_len = b->current_length;
 836   mb->pkt_len = b->current_length;
 837
 838   return b->data;
 839 }
 840
 841 /* Append given data to end of buffer, possibly allocating new buffers. */
 842 u32
 843 vlib_buffer_add_data (vlib_main_t * vm,
 844                       u32 free_list_index,
 845                       u32 buffer_index, void *data, u32 n_data_bytes)
 846 {
 847   u32 n_buffer_bytes, n_left, n_left_this_buffer, bi;
 848   vlib_buffer_t *b;
 849   void *d;
 850
 851   bi = buffer_index;
 852   if (bi == 0
 853       && 1 != vlib_buffer_alloc_from_free_list (vm, &bi, 1, free_list_index))
 854     goto out_of_buffers;
 855
 856   d = data;
 857   n_left = n_data_bytes;
 858   n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, free_list_index);
 859
 860   b = vlib_get_buffer (vm, bi);
 861   b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 862
 863   /* Get to the end of the chain before we try to append data... */
 864   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 865     b = vlib_get_buffer (vm, b->next_buffer);
 866
 867   while (1)
 868     {
 869       u32 n;
 870
 871       ASSERT (n_buffer_bytes >= b->current_length);
 872       n_left_this_buffer =
 873         n_buffer_bytes - (b->current_data + b->current_length);
 874       n = clib_min (n_left_this_buffer, n_left);
 875       clib_memcpy (vlib_buffer_get_current (b) + b->current_length, d, n);
 876       b->current_length += n;
 877       n_left -= n;
 878       if (n_left == 0)
 879         break;
 880
 881       d += n;
 882       if (1 !=
 883           vlib_buffer_alloc_from_free_list (vm, &b->next_buffer, 1,
 884                                             free_list_index))
 885         goto out_of_buffers;
 886
 887       b->flags |= VLIB_BUFFER_NEXT_PRESENT;
 888
 889       b = vlib_get_buffer (vm, b->next_buffer);
 890     }
 891
 892   return bi;
 893
 894 out_of_buffers:
 895   clib_error ("out of buffers");
 896   return bi;
 897 }
 898
 899 u16
 900 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
 901                                           u32 free_list_index,
 902                                           vlib_buffer_t * first,
 903                                           vlib_buffer_t ** last,
 904                                           void *data, u16 data_len)
 905 {
 906   vlib_buffer_t *l = *last;
 907   u32 n_buffer_bytes =
 908     vlib_buffer_free_list_buffer_size (vm, free_list_index);
 909   u16 copied = 0;
 910   ASSERT (n_buffer_bytes >= l->current_length + l->current_data);
 911   while (data_len)
 912     {
 913       u16 max = n_buffer_bytes - l->current_length - l->current_data;
 914       if (max == 0)
 915         {
 916           if (1 !=
 917               vlib_buffer_alloc_from_free_list (vm, &l->next_buffer, 1,
 918                                                 free_list_index))
 919             return copied;
 920           *last = l = vlib_buffer_chain_buffer (vm, first, l, l->next_buffer);
 921           max = n_buffer_bytes - l->current_length - l->current_data;
 922         }
 923
 924       u16 len = (data_len > max) ? max : data_len;
 925       clib_memcpy (vlib_buffer_get_current (l) + l->current_length,
 926                    data + copied, len);
 927       vlib_buffer_chain_increase_length (first, l, len);
 928       data_len -= len;
 929       copied += len;
 930     }
 931   return copied;
 932 }
 933
 934 /*
 935  * Fills in the required rte_mbuf fields for chained buffers given a VLIB chain.
 936  */
 937 void
 938 vlib_buffer_chain_validate (vlib_main_t * vm, vlib_buffer_t * b_first)
 939 {
 940   vlib_buffer_t *b = b_first, *prev = b_first;
 941   struct rte_mbuf *mb_prev, *mb, *mb_first;
 942
 943   mb_first = rte_mbuf_from_vlib_buffer (b_first);
 944
 945   mb_first->pkt_len = mb_first->data_len = b_first->current_length;
 946   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 947     {
 948       b = vlib_get_buffer (vm, b->next_buffer);
 949       mb = rte_mbuf_from_vlib_buffer (b);
 950       mb_prev = rte_mbuf_from_vlib_buffer (prev);
 951       mb_first->nb_segs++;
 952       mb_first->pkt_len += b->current_length;
 953       mb_prev->next = mb;
 954       mb->data_len = b->current_length;
 955       prev = b;
 956     }
 957 }
 958
 959 clib_error_t *
 960 vlib_buffer_pool_create (vlib_main_t * vm, unsigned num_mbufs,
 961                          unsigned socket_id)
 962 {
 963   vlib_buffer_main_t *bm = vm->buffer_main;
 964   vlib_physmem_main_t *vpm = &vm->physmem_main;
 965   struct rte_mempool *rmp;
 966   uword new_start, new_size;
 967   int i;
 968
 969   if (!rte_pktmbuf_pool_create)
 970     return clib_error_return (0, "not linked with DPDK");
 971
 972   vec_validate_aligned (bm->pktmbuf_pools, socket_id, CLIB_CACHE_LINE_BYTES);
 973
 974   /* pool already exists, nothing to do */
 975   if (bm->pktmbuf_pools[socket_id])
 976     return 0;
 977
 978   u8 *pool_name = format (0, "mbuf_pool_socket%u%c", socket_id, 0);
 979
 980   rmp = rte_pktmbuf_pool_create ((char *) pool_name,    /* pool name */
 981                                  num_mbufs,     /* number of mbufs */
 982                                  512,   /* cache size */
 983                                  VLIB_BUFFER_HDR_SIZE,  /* priv size */
 984                                  VLIB_BUFFER_PRE_DATA_SIZE + VLIB_BUFFER_DATA_SIZE,     /* dataroom size */
 985                                  socket_id);    /* cpu socket */
 986
 987   vec_free (pool_name);
 988
 989   if (rmp)
 990     {
 991       new_start = pointer_to_uword (rmp);
 992       new_size = rmp->elt_va_end - new_start;
 993
 994       if (vpm->virtual.size > 0)
 995         {
 996           ASSERT (new_start != vpm->virtual.start);
 997           if (new_start < vpm->virtual.start)
 998             {
 999               new_size = vpm->virtual.size + vpm->virtual.start - new_start;
1000             }
1001           else
1002             {
1003               new_size += new_start - vpm->virtual.start;
1004               new_start = vpm->virtual.start;
1005             }
1006
1007           /* check if fits into buffer index range */
1008           if ((u64) new_size > ((u64) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
1009             rmp = 0;
1010         }
1011     }
1012
1013   if (rmp)
1014     {
1015       bm->pktmbuf_pools[socket_id] = rmp;
1016       vpm->virtual.start = new_start;
1017       vpm->virtual.size = new_size;
1018       vpm->virtual.end = new_start + new_size;
1019       return 0;
1020     }
1021
1022   /* no usable pool for this socket, try to use pool from another one */
1023   for (i = 0; i < vec_len (bm->pktmbuf_pools); i++)
1024     {
1025       if (bm->pktmbuf_pools[i])
1026         {
1027           clib_warning
1028             ("WARNING: Failed to allocate mempool for CPU socket %u. "
1029              "Threads running on socket %u will use socket %u mempool.",
1030              socket_id, socket_id, i);
1031           bm->pktmbuf_pools[socket_id] = bm->pktmbuf_pools[i];
1032           return 0;
1033         }
1034     }
1035
1036   return clib_error_return (0, "failed to allocate mempool on socket %u",
1037                             socket_id);
1038 }
1039
1040
1041 static void
1042 vlib_serialize_tx (serialize_main_header_t * m, serialize_stream_t * s)
1043 {
1044   vlib_main_t *vm;
1045   vlib_serialize_buffer_main_t *sm;
1046   uword n, n_bytes_to_write;
1047   vlib_buffer_t *last;
1048
1049   n_bytes_to_write = s->current_buffer_index;
1050   sm =
1051     uword_to_pointer (s->data_function_opaque,
1052                       vlib_serialize_buffer_main_t *);
1053   vm = sm->vlib_main;
1054
1055   ASSERT (sm->tx.max_n_data_bytes_per_chain > 0);
1056   if (serialize_stream_is_end_of_stream (s)
1057       || sm->tx.n_total_data_bytes + n_bytes_to_write >
1058       sm->tx.max_n_data_bytes_per_chain)
1059     {
1060       vlib_process_t *p = vlib_get_current_process (vm);
1061
1062       last = vlib_get_buffer (vm, sm->last_buffer);
1063       last->current_length = n_bytes_to_write;
1064
1065       vlib_set_next_frame_buffer (vm, &p->node_runtime, sm->tx.next_index,
1066                                   sm->first_buffer);
1067
1068       sm->first_buffer = sm->last_buffer = ~0;
1069       sm->tx.n_total_data_bytes = 0;
1070     }
1071
1072   else if (n_bytes_to_write == 0 && s->n_buffer_bytes == 0)
1073     {
1074       ASSERT (sm->first_buffer == ~0);
1075       ASSERT (sm->last_buffer == ~0);
1076       n =
1077         vlib_buffer_alloc_from_free_list (vm, &sm->first_buffer, 1,
1078                                           sm->tx.free_list_index);
1079       if (n != 1)
1080         serialize_error (m,
1081                          clib_error_create
1082                          ("vlib_buffer_alloc_from_free_list fails"));
1083       sm->last_buffer = sm->first_buffer;
1084       s->n_buffer_bytes =
1085         vlib_buffer_free_list_buffer_size (vm, sm->tx.free_list_index);
1086     }
1087
1088   if (n_bytes_to_write > 0)
1089     {
1090       vlib_buffer_t *prev = vlib_get_buffer (vm, sm->last_buffer);
1091       n =
1092         vlib_buffer_alloc_from_free_list (vm, &sm->last_buffer, 1,
1093                                           sm->tx.free_list_index);
1094       if (n != 1)
1095         serialize_error (m,
1096                          clib_error_create
1097                          ("vlib_buffer_alloc_from_free_list fails"));
1098       sm->tx.n_total_data_bytes += n_bytes_to_write;
1099       prev->current_length = n_bytes_to_write;
1100       prev->next_buffer = sm->last_buffer;
1101       prev->flags |= VLIB_BUFFER_NEXT_PRESENT;
1102     }
1103
1104   if (sm->last_buffer != ~0)
1105     {
1106       last = vlib_get_buffer (vm, sm->last_buffer);
1107       s->buffer = vlib_buffer_get_current (last);
1108       s->current_buffer_index = 0;
1109       ASSERT (last->current_data == s->current_buffer_index);
1110     }
1111 }
1112
1113 static void
1114 vlib_serialize_rx (serialize_main_header_t * m, serialize_stream_t * s)
1115 {
1116   vlib_main_t *vm;
1117   vlib_serialize_buffer_main_t *sm;
1118   vlib_buffer_t *last;
1119
1120   sm =
1121     uword_to_pointer (s->data_function_opaque,
1122                       vlib_serialize_buffer_main_t *);
1123   vm = sm->vlib_main;
1124
1125   if (serialize_stream_is_end_of_stream (s))
1126     return;
1127
1128   if (sm->last_buffer != ~0)
1129     {
1130       last = vlib_get_buffer (vm, sm->last_buffer);
1131
1132       if (last->flags & VLIB_BUFFER_NEXT_PRESENT)
1133         sm->last_buffer = last->next_buffer;
1134       else
1135         {
1136           vlib_buffer_free (vm, &sm->first_buffer, /* count */ 1);
1137           sm->first_buffer = sm->last_buffer = ~0;
1138         }
1139     }
1140
1141   if (sm->last_buffer == ~0)
1142     {
1143       while (clib_fifo_elts (sm->rx.buffer_fifo) == 0)
1144         {
1145           sm->rx.ready_one_time_event =
1146             vlib_process_create_one_time_event (vm, vlib_current_process (vm),
1147                                                 ~0);
1148           vlib_process_wait_for_one_time_event (vm, /* no event data */ 0,
1149                                                 sm->rx.ready_one_time_event);
1150         }
1151
1152       clib_fifo_sub1 (sm->rx.buffer_fifo, sm->first_buffer);
1153       sm->last_buffer = sm->first_buffer;
1154     }
1155
1156   ASSERT (sm->last_buffer != ~0);
1157
1158   last = vlib_get_buffer (vm, sm->last_buffer);
1159   s->current_buffer_index = 0;
1160   s->buffer = vlib_buffer_get_current (last);
1161   s->n_buffer_bytes = last->current_length;
1162 }
1163
1164 static void
1165 serialize_open_vlib_helper (serialize_main_t * m,
1166                             vlib_main_t * vm,
1167                             vlib_serialize_buffer_main_t * sm, uword is_read)
1168 {
1169   /* Initialize serialize main but save overflow buffer for re-use between calls. */
1170   {
1171     u8 *save = m->stream.overflow_buffer;
1172     memset (m, 0, sizeof (m[0]));
1173     m->stream.overflow_buffer = save;
1174     if (save)
1175       _vec_len (save) = 0;
1176   }
1177
1178   sm->first_buffer = sm->last_buffer = ~0;
1179   if (is_read)
1180     clib_fifo_reset (sm->rx.buffer_fifo);
1181   else
1182     sm->tx.n_total_data_bytes = 0;
1183   sm->vlib_main = vm;
1184   m->header.data_function = is_read ? vlib_serialize_rx : vlib_serialize_tx;
1185   m->stream.data_function_opaque = pointer_to_uword (sm);
1186 }
1187
1188 void
1189 serialize_open_vlib_buffer (serialize_main_t * m, vlib_main_t * vm,
1190                             vlib_serialize_buffer_main_t * sm)
1191 {
1192   serialize_open_vlib_helper (m, vm, sm, /* is_read */ 0);
1193 }
1194
1195 void
1196 unserialize_open_vlib_buffer (serialize_main_t * m, vlib_main_t * vm,
1197                               vlib_serialize_buffer_main_t * sm)
1198 {
1199   serialize_open_vlib_helper (m, vm, sm, /* is_read */ 1);
1200 }
1201
1202 u32
1203 serialize_close_vlib_buffer (serialize_main_t * m)
1204 {
1205   vlib_serialize_buffer_main_t *sm
1206     = uword_to_pointer (m->stream.data_function_opaque,
1207                         vlib_serialize_buffer_main_t *);
1208   vlib_buffer_t *last;
1209   serialize_stream_t *s = &m->stream;
1210
1211   last = vlib_get_buffer (sm->vlib_main, sm->last_buffer);
1212   last->current_length = s->current_buffer_index;
1213
1214   if (vec_len (s->overflow_buffer) > 0)
1215     {
1216       sm->last_buffer
1217         = vlib_buffer_add_data (sm->vlib_main, sm->tx.free_list_index,
1218                                 sm->last_buffer == ~0 ? 0 : sm->last_buffer,
1219                                 s->overflow_buffer,
1220                                 vec_len (s->overflow_buffer));
1221       _vec_len (s->overflow_buffer) = 0;
1222     }
1223
1224   return sm->first_buffer;
1225 }
1226
1227 void
1228 unserialize_close_vlib_buffer (serialize_main_t * m)
1229 {
1230   vlib_serialize_buffer_main_t *sm
1231     = uword_to_pointer (m->stream.data_function_opaque,
1232                         vlib_serialize_buffer_main_t *);
1233   if (sm->first_buffer != ~0)
1234     vlib_buffer_free_one (sm->vlib_main, sm->first_buffer);
1235   clib_fifo_reset (sm->rx.buffer_fifo);
1236   if (m->stream.overflow_buffer)
1237     _vec_len (m->stream.overflow_buffer) = 0;
1238 }
1239
1240 static u8 *
1241 format_vlib_buffer_free_list (u8 * s, va_list * va)
1242 {
1243   vlib_buffer_free_list_t *f = va_arg (*va, vlib_buffer_free_list_t *);
1244   u32 threadnum = va_arg (*va, u32);
1245   uword bytes_alloc, bytes_free, n_free, size;
1246
1247   if (!f)
1248     return format (s, "%=7s%=30s%=12s%=12s%=12s%=12s%=12s%=12s",
1249                    "Thread", "Name", "Index", "Size", "Alloc", "Free",
1250                    "#Alloc", "#Free");
1251
1252   size = sizeof (vlib_buffer_t) + f->n_data_bytes;
1253   n_free = vec_len (f->aligned_buffers) + vec_len (f->unaligned_buffers);
1254   bytes_alloc = size * f->n_alloc;
1255   bytes_free = size * n_free;
1256
1257   s = format (s, "%7d%30s%12d%12d%=12U%=12U%=12d%=12d",
1258               threadnum,
1259               f->name, f->index, f->n_data_bytes,
1260               format_memory_size, bytes_alloc,
1261               format_memory_size, bytes_free, f->n_alloc, n_free);
1262
1263   return s;
1264 }
1265
1266 static clib_error_t *
1267 show_buffers (vlib_main_t * vm,
1268               unformat_input_t * input, vlib_cli_command_t * cmd)
1269 {
1270   vlib_buffer_main_t *bm;
1271   vlib_buffer_free_list_t *f;
1272   vlib_main_t *curr_vm;
1273   u32 vm_index = 0;
1274
1275   vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, 0, 0);
1276
1277   do
1278     {
1279       curr_vm = vec_len (vlib_mains) ? vlib_mains[vm_index] : vm;
1280       bm = curr_vm->buffer_main;
1281
1282     /* *INDENT-OFF* */
1283     pool_foreach (f, bm->buffer_free_list_pool, ({
1284       vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, f, vm_index);
1285     }));
1286     /* *INDENT-ON* */
1287
1288       vm_index++;
1289     }
1290   while (vm_index < vec_len (vlib_mains));
1291
1292   return 0;
1293 }
1294
1295 /* *INDENT-OFF* */
1296 VLIB_CLI_COMMAND (show_buffers_command, static) = {
1297   .path = "show buffers",
1298   .short_help = "Show packet buffer allocation",
1299   .function = show_buffers,
1300 };
1301 /* *INDENT-ON* */
1302
1303 #if CLIB_DEBUG > 0
1304
1305 u32 *vlib_buffer_state_validation_lock;
1306 uword *vlib_buffer_state_validation_hash;
1307 void *vlib_buffer_state_heap;
1308
1309 static clib_error_t *
1310 buffer_state_validation_init (vlib_main_t * vm)
1311 {
1312   void *oldheap;
1313
1314   vlib_buffer_state_heap = mheap_alloc (0, 10 << 20);
1315
1316   oldheap = clib_mem_set_heap (vlib_buffer_state_heap);
1317
1318   vlib_buffer_state_validation_hash = hash_create (0, sizeof (uword));
1319   vec_validate_aligned (vlib_buffer_state_validation_lock, 0,
1320                         CLIB_CACHE_LINE_BYTES);
1321   clib_mem_set_heap (oldheap);
1322   return 0;
1323 }
1324
1325 VLIB_INIT_FUNCTION (buffer_state_validation_init);
1326 #endif
1327
1328 /*
1329  * fd.io coding-style-patch-verification: ON
1330  *
1331  * Local Variables:
1332  * eval: (c-set-style "gnu")
1333  * End:
1334  */