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