src/vlib/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  * @file
  42  *
  43  * Allocate/free network buffers.
  44  */
  45
  46 #include <vlib/vlib.h>
  47 #include <vlib/unix/unix.h>
  48
  49 vlib_buffer_callbacks_t *vlib_buffer_callbacks = 0;
  50
  51 /* when running unpriviledged we are limited by RLIMIT_MEMLOCK which is
  52    typically set to 16MB so setting default size for buffer memory to 14MB
  53    */
  54 static u32 vlib_buffer_physmem_sz = 14 << 20;
  55
  56 vlib_buffer_main_t buffer_main;
  57
  58 /* logging */
  59 static vlib_log_class_t buffer_log_default;
  60
  61 uword
  62 vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm,
  63                                        vlib_buffer_t * b_first)
  64 {
  65   vlib_buffer_t *b = b_first;
  66   uword l_first = b_first->current_length;
  67   uword l = 0;
  68   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
  69     {
  70       b = vlib_get_buffer (vm, b->next_buffer);
  71       l += b->current_length;
  72     }
  73   b_first->total_length_not_including_first_buffer = l;
  74   b_first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  75   return l + l_first;
  76 }
  77
  78 u8 *
  79 format_vlib_buffer (u8 * s, va_list * args)
  80 {
  81   vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
  82   u32 indent = format_get_indent (s);
  83   u8 *a = 0;
  84
  85 #define _(bit, name, v) \
  86   if (v && (b->flags & VLIB_BUFFER_##name)) \
  87     a = format (a, "%s ", v);
  88   foreach_vlib_buffer_flag
  89 #undef _
  90     s = format (s, "current data %d, length %d, free-list %d, clone-count %u",
  91                 b->current_data, b->current_length,
  92                 vlib_buffer_get_free_list_index (b), b->n_add_refs);
  93
  94   if (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID)
  95     s = format (s, ", totlen-nifb %d",
  96                 b->total_length_not_including_first_buffer);
  97
  98   if (b->flags & VLIB_BUFFER_IS_TRACED)
  99     s = format (s, ", trace 0x%x", b->trace_index);
 100
 101   if (a)
 102     s = format (s, "\n%U%v", format_white_space, indent, a);
 103   vec_free (a);
 104
 105   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 106     {
 107       vlib_main_t *vm = vlib_get_main ();
 108       u32 next_buffer = b->next_buffer;
 109       b = vlib_get_buffer (vm, next_buffer);
 110
 111       s =
 112         format (s, "\n%Unext-buffer 0x%x, segment length %d, clone-count %u",
 113                 format_white_space, indent, next_buffer, b->current_length,
 114                 b->n_add_refs);
 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 static u8 *
 133 format_vlib_buffer_known_state (u8 * s, va_list * args)
 134 {
 135   vlib_buffer_known_state_t state = va_arg (*args, vlib_buffer_known_state_t);
 136   char *t;
 137
 138   switch (state)
 139     {
 140     case VLIB_BUFFER_UNKNOWN:
 141       t = "unknown";
 142       break;
 143
 144     case VLIB_BUFFER_KNOWN_ALLOCATED:
 145       t = "known-allocated";
 146       break;
 147
 148     case VLIB_BUFFER_KNOWN_FREE:
 149       t = "known-free";
 150       break;
 151
 152     default:
 153       t = "invalid";
 154       break;
 155     }
 156
 157   return format (s, "%s", t);
 158 }
 159
 160 u8 *
 161 format_vlib_buffer_contents (u8 * s, va_list * va)
 162 {
 163   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
 164   vlib_buffer_t *b = va_arg (*va, vlib_buffer_t *);
 165
 166   while (1)
 167     {
 168       vec_add (s, vlib_buffer_get_current (b), b->current_length);
 169       if (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))
 170         break;
 171       b = vlib_get_buffer (vm, b->next_buffer);
 172     }
 173
 174   return s;
 175 }
 176
 177 static u8 *
 178 vlib_validate_buffer_helper (vlib_main_t * vm,
 179                              u32 bi,
 180                              uword follow_buffer_next, uword ** unique_hash)
 181 {
 182   vlib_buffer_t *b = vlib_get_buffer (vm, bi);
 183   vlib_buffer_free_list_t *fl;
 184
 185   if (pool_is_free_index
 186       (vm->buffer_free_list_pool, vlib_buffer_get_free_list_index (b)))
 187     return format (0, "unknown free list 0x%x",
 188                    vlib_buffer_get_free_list_index (b));
 189
 190   fl =
 191     pool_elt_at_index (vm->buffer_free_list_pool,
 192                        vlib_buffer_get_free_list_index (b));
 193
 194   if ((signed) b->current_data < (signed) -VLIB_BUFFER_PRE_DATA_SIZE)
 195     return format (0, "current data %d before pre-data", b->current_data);
 196
 197   if (b->current_data + b->current_length > fl->n_data_bytes)
 198     return format (0, "%d-%d beyond end of buffer %d",
 199                    b->current_data, b->current_length, fl->n_data_bytes);
 200
 201   if (follow_buffer_next && (b->flags & VLIB_BUFFER_NEXT_PRESENT))
 202     {
 203       vlib_buffer_known_state_t k;
 204       u8 *msg, *result;
 205
 206       k = vlib_buffer_is_known (b->next_buffer);
 207       if (k != VLIB_BUFFER_KNOWN_ALLOCATED)
 208         return format (0, "next 0x%x: %U",
 209                        b->next_buffer, format_vlib_buffer_known_state, k);
 210
 211       if (unique_hash)
 212         {
 213           if (hash_get (*unique_hash, b->next_buffer))
 214             return format (0, "duplicate buffer 0x%x", b->next_buffer);
 215
 216           hash_set1 (*unique_hash, b->next_buffer);
 217         }
 218
 219       msg = vlib_validate_buffer (vm, b->next_buffer, follow_buffer_next);
 220       if (msg)
 221         {
 222           result = format (0, "next 0x%x: %v", b->next_buffer, msg);
 223           vec_free (msg);
 224           return result;
 225         }
 226     }
 227
 228   return 0;
 229 }
 230
 231 u8 *
 232 vlib_validate_buffer (vlib_main_t * vm, u32 bi, uword follow_buffer_next)
 233 {
 234   return vlib_validate_buffer_helper (vm, bi, follow_buffer_next,
 235                                       /* unique_hash */ 0);
 236 }
 237
 238 u8 *
 239 vlib_validate_buffers (vlib_main_t * vm,
 240                        u32 * buffers,
 241                        uword next_buffer_stride,
 242                        uword n_buffers,
 243                        vlib_buffer_known_state_t known_state,
 244                        uword follow_buffer_next)
 245 {
 246   uword i, *hash;
 247   u32 bi, *b = buffers;
 248   vlib_buffer_known_state_t k;
 249   u8 *msg = 0, *result = 0;
 250
 251   hash = hash_create (0, 0);
 252   for (i = 0; i < n_buffers; i++)
 253     {
 254       bi = b[0];
 255       b += next_buffer_stride;
 256
 257       /* Buffer is not unique. */
 258       if (hash_get (hash, bi))
 259         {
 260           msg = format (0, "not unique");
 261           goto done;
 262         }
 263
 264       k = vlib_buffer_is_known (bi);
 265       if (k != known_state)
 266         {
 267           msg = format (0, "is %U; expected %U",
 268                         format_vlib_buffer_known_state, k,
 269                         format_vlib_buffer_known_state, known_state);
 270           goto done;
 271         }
 272
 273       msg = vlib_validate_buffer_helper (vm, bi, follow_buffer_next, &hash);
 274       if (msg)
 275         goto done;
 276
 277       hash_set1 (hash, bi);
 278     }
 279
 280 done:
 281   if (msg)
 282     {
 283       result = format (0, "0x%x: %v", bi, msg);
 284       vec_free (msg);
 285     }
 286   hash_free (hash);
 287   return result;
 288 }
 289
 290 /*
 291  * Hand-craft a static vector w/ length 1, so vec_len(vlib_mains) =1
 292  * and vlib_mains[0] = &vlib_global_main from the beginning of time.
 293  *
 294  * The only place which should ever expand vlib_mains is start_workers()
 295  * in threads.c. It knows about the bootstrap vector.
 296  */
 297 /* *INDENT-OFF* */
 298 static struct
 299 {
 300   vec_header_t h;
 301   vlib_main_t *vm;
 302 } __attribute__ ((packed)) __bootstrap_vlib_main_vector
 303   __attribute__ ((aligned (CLIB_CACHE_LINE_BYTES))) =
 304 {
 305   .h.len = 1,
 306   .vm = &vlib_global_main,
 307 };
 308 /* *INDENT-ON* */
 309
 310 vlib_main_t **vlib_mains = &__bootstrap_vlib_main_vector.vm;
 311
 312
 313 /* When dubugging validate that given buffers are either known allocated
 314    or known free. */
 315 void
 316 vlib_buffer_validate_alloc_free (vlib_main_t * vm,
 317                                  u32 * buffers,
 318                                  uword n_buffers,
 319                                  vlib_buffer_known_state_t expected_state)
 320 {
 321   u32 *b;
 322   uword i, bi, is_free;
 323
 324   if (CLIB_DEBUG == 0)
 325     return;
 326
 327   if (vlib_buffer_callbacks)
 328     return;
 329
 330   is_free = expected_state == VLIB_BUFFER_KNOWN_ALLOCATED;
 331   b = buffers;
 332   for (i = 0; i < n_buffers; i++)
 333     {
 334       vlib_buffer_known_state_t known;
 335
 336       bi = b[0];
 337       b += 1;
 338       known = vlib_buffer_is_known (bi);
 339       if (known != expected_state)
 340         {
 341           ASSERT (0);
 342           vlib_panic_with_msg
 343             (vm, "%s %U buffer 0x%x",
 344              is_free ? "freeing" : "allocating",
 345              format_vlib_buffer_known_state, known, bi);
 346         }
 347
 348       vlib_buffer_set_known_state
 349         (bi, is_free ? VLIB_BUFFER_KNOWN_FREE : VLIB_BUFFER_KNOWN_ALLOCATED);
 350     }
 351 }
 352
 353 /* Add buffer free list. */
 354 static vlib_buffer_free_list_index_t
 355 vlib_buffer_create_free_list_helper (vlib_main_t * vm,
 356                                      u32 n_data_bytes,
 357                                      u32 is_public, u32 is_default, u8 * name)
 358 {
 359   vlib_buffer_main_t *bm = &buffer_main;
 360   vlib_buffer_free_list_t *f;
 361   int i;
 362
 363   ASSERT (vlib_get_thread_index () == 0);
 364
 365   if (!is_default && pool_elts (vm->buffer_free_list_pool) == 0)
 366     {
 367       vlib_buffer_free_list_index_t default_free_free_list_index;
 368
 369       /* *INDENT-OFF* */
 370       default_free_free_list_index =
 371         vlib_buffer_create_free_list_helper
 372         (vm,
 373          /* default buffer size */ VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES,
 374          /* is_public */ 1,
 375          /* is_default */ 1,
 376          (u8 *) "default");
 377       /* *INDENT-ON* */
 378       ASSERT (default_free_free_list_index ==
 379               VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 380
 381       if (n_data_bytes == VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES && is_public)
 382         return default_free_free_list_index;
 383     }
 384
 385   pool_get_aligned (vm->buffer_free_list_pool, f, CLIB_CACHE_LINE_BYTES);
 386
 387   clib_memset (f, 0, sizeof (f[0]));
 388   f->index = f - vm->buffer_free_list_pool;
 389   vec_validate (f->buffers, 0);
 390   vec_reset_length (f->buffers);
 391   f->n_data_bytes = vlib_buffer_round_size (n_data_bytes);
 392   f->min_n_buffers_each_alloc = VLIB_FRAME_SIZE;
 393   f->buffer_pool_index = 0;
 394   f->name = clib_mem_is_vec (name) ? name : format (0, "%s", name);
 395
 396   /* Setup free buffer template. */
 397   vlib_buffer_set_free_list_index (&f->buffer_init_template, f->index);
 398   f->buffer_init_template.n_add_refs = 0;
 399
 400   if (is_public)
 401     {
 402       uword *p = hash_get (bm->free_list_by_size, f->n_data_bytes);
 403       if (!p)
 404         hash_set (bm->free_list_by_size, f->n_data_bytes, f->index);
 405     }
 406
 407   for (i = 1; i < vec_len (vlib_mains); i++)
 408     {
 409       vlib_main_t *wvm = vlib_mains[i];
 410       vlib_buffer_free_list_t *wf;
 411       pool_get_aligned (wvm->buffer_free_list_pool,
 412                         wf, CLIB_CACHE_LINE_BYTES);
 413       ASSERT (f - vm->buffer_free_list_pool ==
 414               wf - wvm->buffer_free_list_pool);
 415       wf[0] = f[0];
 416       wf->buffers = 0;
 417       vec_validate (wf->buffers, 0);
 418       vec_reset_length (wf->buffers);
 419       wf->n_alloc = 0;
 420     }
 421
 422   return f->index;
 423 }
 424
 425 vlib_buffer_free_list_index_t
 426 vlib_buffer_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
 427                               char *fmt, ...)
 428 {
 429   va_list va;
 430   u8 *name;
 431
 432   va_start (va, fmt);
 433   name = va_format (0, fmt, &va);
 434   va_end (va);
 435
 436   return vlib_buffer_create_free_list_helper (vm, n_data_bytes,
 437                                               /* is_public */ 0,
 438                                               /* is_default */ 0,
 439                                               name);
 440 }
 441
 442 static void
 443 del_free_list (vlib_main_t * vm, vlib_buffer_free_list_t * f)
 444 {
 445   vlib_buffer_pool_t *bp = vlib_buffer_pool_get (f->buffer_pool_index);
 446
 447   vec_add_aligned (bp->buffers, f->buffers, vec_len (f->buffers),
 448                    CLIB_CACHE_LINE_BYTES);
 449   vec_free (f->name);
 450   vec_free (f->buffers);
 451
 452   /* Poison it. */
 453   clib_memset (f, 0xab, sizeof (f[0]));
 454 }
 455
 456 /* Add buffer free list. */
 457 void
 458 vlib_buffer_delete_free_list_internal (vlib_main_t * vm,
 459                                        vlib_buffer_free_list_index_t index)
 460 {
 461   vlib_buffer_free_list_t *f;
 462   int i;
 463
 464   ASSERT (vlib_get_thread_index () == 0);
 465
 466   f = vlib_buffer_get_free_list (vm, index);
 467
 468   ASSERT (vec_len (f->buffers) == f->n_alloc);
 469
 470   del_free_list (vm, f);
 471
 472   pool_put (vm->buffer_free_list_pool, f);
 473
 474   for (i = 1; i < vec_len (vlib_mains); i++)
 475     {
 476       vlib_main_t *wvm = vlib_mains[i];
 477       f = vlib_buffer_get_free_list (vlib_mains[i], index);
 478       del_free_list (wvm, f);
 479       pool_put (wvm->buffer_free_list_pool, f);
 480     }
 481 }
 482
 483 static_always_inline void *
 484 vlib_buffer_pool_get_buffer (vlib_main_t * vm, vlib_buffer_pool_t * bp)
 485 {
 486   return vlib_physmem_alloc_from_map (vm, bp->physmem_map_index,
 487                                       bp->buffer_size, CLIB_CACHE_LINE_BYTES);
 488 }
 489
 490 /* Make sure free list has at least given number of free buffers. */
 491 static uword
 492 vlib_buffer_fill_free_list_internal (vlib_main_t * vm,
 493                                      vlib_buffer_free_list_t * fl,
 494                                      uword min_free_buffers)
 495 {
 496   vlib_buffer_t *b;
 497   vlib_buffer_pool_t *bp = vlib_buffer_pool_get (fl->buffer_pool_index);
 498   int n;
 499   u32 *bi;
 500   u32 n_alloc = 0;
 501
 502   /* Already have enough free buffers on free list? */
 503   n = min_free_buffers - vec_len (fl->buffers);
 504   if (n <= 0)
 505     return min_free_buffers;
 506
 507   if (vec_len (bp->buffers) > 0)
 508     {
 509       int n_copy, n_left;
 510       clib_spinlock_lock (&bp->lock);
 511       n_copy = clib_min (vec_len (bp->buffers), n);
 512       n_left = vec_len (bp->buffers) - n_copy;
 513       vec_add_aligned (fl->buffers, bp->buffers + n_left, n_copy,
 514                        CLIB_CACHE_LINE_BYTES);
 515       _vec_len (bp->buffers) = n_left;
 516       clib_spinlock_unlock (&bp->lock);
 517       n = min_free_buffers - vec_len (fl->buffers);
 518       if (n <= 0)
 519         return min_free_buffers;
 520     }
 521
 522   /* Always allocate round number of buffers. */
 523   n = round_pow2 (n, CLIB_CACHE_LINE_BYTES / sizeof (u32));
 524
 525   /* Always allocate new buffers in reasonably large sized chunks. */
 526   n = clib_max (n, fl->min_n_buffers_each_alloc);
 527
 528   clib_spinlock_lock (&bp->lock);
 529   while (n_alloc < n)
 530     {
 531       if ((b = vlib_buffer_pool_get_buffer (vm, bp)) == 0)
 532         goto done;
 533
 534       n_alloc += 1;
 535
 536       vec_add2_aligned (fl->buffers, bi, 1, CLIB_CACHE_LINE_BYTES);
 537       bi[0] = vlib_get_buffer_index (vm, b);
 538
 539       if (CLIB_DEBUG > 0)
 540         vlib_buffer_set_known_state (bi[0], VLIB_BUFFER_KNOWN_FREE);
 541
 542       clib_memset (b, 0, sizeof (vlib_buffer_t));
 543       vlib_buffer_init_for_free_list (b, fl);
 544
 545       if (fl->buffer_init_function)
 546         fl->buffer_init_function (vm, fl, bi, 1);
 547     }
 548
 549 done:
 550   clib_spinlock_unlock (&bp->lock);
 551   fl->n_alloc += n_alloc;
 552   return n_alloc;
 553 }
 554
 555 void *
 556 vlib_set_buffer_free_callback (vlib_main_t * vm, void *fp)
 557 {
 558   vlib_buffer_main_t *bm = &buffer_main;
 559   void *rv = bm->buffer_free_callback;
 560
 561   bm->buffer_free_callback = fp;
 562   return rv;
 563 }
 564
 565 static_always_inline void
 566 recycle_or_free (vlib_main_t * vm, vlib_buffer_main_t * bm, u32 bi,
 567                  vlib_buffer_t * b, u32 follow_buffer_next)
 568 {
 569   vlib_buffer_free_list_t *fl;
 570   vlib_buffer_free_list_index_t fi;
 571   u32 flags, next;
 572
 573   fl = vlib_buffer_get_buffer_free_list (vm, b, &fi);
 574
 575   do
 576     {
 577       vlib_buffer_t *nb = vlib_get_buffer (vm, bi);
 578       flags = nb->flags;
 579       next = nb->next_buffer;
 580       if (nb->n_add_refs)
 581         nb->n_add_refs--;
 582       else
 583         {
 584           vlib_buffer_validate_alloc_free (vm, &bi, 1,
 585                                            VLIB_BUFFER_KNOWN_ALLOCATED);
 586           vlib_buffer_add_to_free_list (vm, fl, bi, 1);
 587         }
 588       bi = next;
 589     }
 590   while (follow_buffer_next && (flags & VLIB_BUFFER_NEXT_PRESENT));
 591 }
 592
 593 static_always_inline void
 594 vlib_buffer_free_inline (vlib_main_t * vm,
 595                          u32 * buffers, u32 n_buffers, u32 follow_buffer_next)
 596 {
 597   vlib_buffer_main_t *bm = &buffer_main;
 598   vlib_buffer_t *p, *b0, *b1, *b2, *b3;
 599   int i = 0;
 600   u32 (*cb) (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 601              u32 follow_buffer_next);
 602
 603   cb = bm->buffer_free_callback;
 604
 605   if (PREDICT_FALSE (cb != 0))
 606     n_buffers = (*cb) (vm, buffers, n_buffers, follow_buffer_next);
 607
 608   if (!n_buffers)
 609     return;
 610
 611   while (i + 11 < n_buffers)
 612     {
 613       p = vlib_get_buffer (vm, buffers[i + 8]);
 614       vlib_prefetch_buffer_header (p, LOAD);
 615       p = vlib_get_buffer (vm, buffers[i + 9]);
 616       vlib_prefetch_buffer_header (p, LOAD);
 617       p = vlib_get_buffer (vm, buffers[i + 10]);
 618       vlib_prefetch_buffer_header (p, LOAD);
 619       p = vlib_get_buffer (vm, buffers[i + 11]);
 620       vlib_prefetch_buffer_header (p, LOAD);
 621
 622       b0 = vlib_get_buffer (vm, buffers[i]);
 623       b1 = vlib_get_buffer (vm, buffers[i + 1]);
 624       b2 = vlib_get_buffer (vm, buffers[i + 2]);
 625       b3 = vlib_get_buffer (vm, buffers[i + 3]);
 626
 627       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 628       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b1);
 629       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b2);
 630       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b3);
 631
 632       recycle_or_free (vm, bm, buffers[i], b0, follow_buffer_next);
 633       recycle_or_free (vm, bm, buffers[i + 1], b1, follow_buffer_next);
 634       recycle_or_free (vm, bm, buffers[i + 2], b2, follow_buffer_next);
 635       recycle_or_free (vm, bm, buffers[i + 3], b3, follow_buffer_next);
 636
 637       i += 4;
 638     }
 639
 640   while (i < n_buffers)
 641     {
 642       b0 = vlib_get_buffer (vm, buffers[i]);
 643       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 644       recycle_or_free (vm, bm, buffers[i], b0, follow_buffer_next);
 645       i++;
 646     }
 647 }
 648
 649 static void
 650 vlib_buffer_free_internal (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 651 {
 652   vlib_buffer_free_inline (vm, buffers, n_buffers,      /* follow_buffer_next */
 653                            1);
 654 }
 655
 656 static void
 657 vlib_buffer_free_no_next_internal (vlib_main_t * vm, u32 * buffers,
 658                                    u32 n_buffers)
 659 {
 660   vlib_buffer_free_inline (vm, buffers, n_buffers,      /* follow_buffer_next */
 661                            0);
 662 }
 663
 664 void
 665 vlib_packet_template_init (vlib_main_t * vm,
 666                            vlib_packet_template_t * t,
 667                            void *packet_data,
 668                            uword n_packet_data_bytes,
 669                            uword min_n_buffers_each_alloc, char *fmt, ...)
 670 {
 671   va_list va;
 672
 673   va_start (va, fmt);
 674   t->name = va_format (0, fmt, &va);
 675   va_end (va);
 676
 677   vlib_worker_thread_barrier_sync (vm);
 678
 679   clib_memset (t, 0, sizeof (t[0]));
 680
 681   vec_add (t->packet_data, packet_data, n_packet_data_bytes);
 682   t->min_n_buffers_each_alloc = min_n_buffers_each_alloc;
 683
 684   vlib_worker_thread_barrier_release (vm);
 685 }
 686
 687 void *
 688 vlib_packet_template_get_packet (vlib_main_t * vm,
 689                                  vlib_packet_template_t * t, u32 * bi_result)
 690 {
 691   u32 bi;
 692   vlib_buffer_t *b;
 693
 694   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
 695     return 0;
 696
 697   *bi_result = bi;
 698
 699   b = vlib_get_buffer (vm, bi);
 700   clib_memcpy_fast (vlib_buffer_get_current (b),
 701                     t->packet_data, vec_len (t->packet_data));
 702   b->current_length = vec_len (t->packet_data);
 703
 704   return b->data;
 705 }
 706
 707 /* Append given data to end of buffer, possibly allocating new buffers. */
 708 u32
 709 vlib_buffer_add_data (vlib_main_t * vm,
 710                       vlib_buffer_free_list_index_t free_list_index,
 711                       u32 buffer_index, void *data, u32 n_data_bytes)
 712 {
 713   u32 n_buffer_bytes, n_left, n_left_this_buffer, bi;
 714   vlib_buffer_t *b;
 715   void *d;
 716
 717   bi = buffer_index;
 718   if (bi == ~0
 719       && 1 != vlib_buffer_alloc_from_free_list (vm, &bi, 1, free_list_index))
 720     goto out_of_buffers;
 721
 722   d = data;
 723   n_left = n_data_bytes;
 724   n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, free_list_index);
 725
 726   b = vlib_get_buffer (vm, bi);
 727   b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 728
 729   /* Get to the end of the chain before we try to append data... */
 730   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 731     b = vlib_get_buffer (vm, b->next_buffer);
 732
 733   while (1)
 734     {
 735       u32 n;
 736
 737       ASSERT (n_buffer_bytes >= b->current_length);
 738       n_left_this_buffer =
 739         n_buffer_bytes - (b->current_data + b->current_length);
 740       n = clib_min (n_left_this_buffer, n_left);
 741       clib_memcpy_fast (vlib_buffer_get_current (b) + b->current_length, d,
 742                         n);
 743       b->current_length += n;
 744       n_left -= n;
 745       if (n_left == 0)
 746         break;
 747
 748       d += n;
 749       if (1 !=
 750           vlib_buffer_alloc_from_free_list (vm, &b->next_buffer, 1,
 751                                             free_list_index))
 752         goto out_of_buffers;
 753
 754       b->flags |= VLIB_BUFFER_NEXT_PRESENT;
 755
 756       b = vlib_get_buffer (vm, b->next_buffer);
 757     }
 758
 759   return bi;
 760
 761 out_of_buffers:
 762   clib_error ("out of buffers");
 763   return bi;
 764 }
 765
 766 u16
 767 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
 768                                           vlib_buffer_free_list_index_t
 769                                           free_list_index,
 770                                           vlib_buffer_t * first,
 771                                           vlib_buffer_t ** last, void *data,
 772                                           u16 data_len)
 773 {
 774   vlib_buffer_t *l = *last;
 775   u32 n_buffer_bytes =
 776     vlib_buffer_free_list_buffer_size (vm, free_list_index);
 777   u16 copied = 0;
 778   ASSERT (n_buffer_bytes >= l->current_length + l->current_data);
 779   while (data_len)
 780     {
 781       u16 max = n_buffer_bytes - l->current_length - l->current_data;
 782       if (max == 0)
 783         {
 784           if (1 !=
 785               vlib_buffer_alloc_from_free_list (vm, &l->next_buffer, 1,
 786                                                 free_list_index))
 787             return copied;
 788           *last = l = vlib_buffer_chain_buffer (vm, l, l->next_buffer);
 789           max = n_buffer_bytes - l->current_length - l->current_data;
 790         }
 791
 792       u16 len = (data_len > max) ? max : data_len;
 793       clib_memcpy_fast (vlib_buffer_get_current (l) + l->current_length,
 794                         data + copied, len);
 795       vlib_buffer_chain_increase_length (first, l, len);
 796       data_len -= len;
 797       copied += len;
 798     }
 799   return copied;
 800 }
 801
 802 u8
 803 vlib_buffer_register_physmem_map (vlib_main_t * vm, u32 physmem_map_index)
 804 {
 805   vlib_buffer_main_t *bm = &buffer_main;
 806   vlib_buffer_pool_t *p;
 807   vlib_physmem_map_t *m = vlib_physmem_get_map (vm, physmem_map_index);
 808   uword start = pointer_to_uword (m->base);
 809   uword size = (uword) m->n_pages << m->log2_page_size;
 810
 811   if (bm->buffer_mem_size == 0)
 812     {
 813       bm->buffer_mem_start = start;
 814       bm->buffer_mem_size = size;
 815     }
 816   else if (start < bm->buffer_mem_start)
 817     {
 818       bm->buffer_mem_size += bm->buffer_mem_start - start;
 819       bm->buffer_mem_start = start;
 820       if (size > bm->buffer_mem_size)
 821         bm->buffer_mem_size = size;
 822     }
 823   else if (start > bm->buffer_mem_start)
 824     {
 825       uword new_size = start - bm->buffer_mem_start + size;
 826       if (new_size > bm->buffer_mem_size)
 827         bm->buffer_mem_size = new_size;
 828     }
 829
 830   if ((u64) bm->buffer_mem_size >
 831       ((u64) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
 832     {
 833       clib_panic ("buffer memory size out of range!");
 834     }
 835
 836   vec_add2 (bm->buffer_pools, p, 1);
 837   p->start = start;
 838   p->size = size;
 839   p->physmem_map_index = physmem_map_index;
 840
 841   ASSERT (p - bm->buffer_pools < 256);
 842   return p - bm->buffer_pools;
 843 }
 844
 845 static u8 *
 846 format_vlib_buffer_free_list (u8 * s, va_list * va)
 847 {
 848   vlib_buffer_free_list_t *f = va_arg (*va, vlib_buffer_free_list_t *);
 849   u32 threadnum = va_arg (*va, u32);
 850   uword bytes_alloc, bytes_free, n_free, size;
 851
 852   if (!f)
 853     return format (s, "%=7s%=30s%=12s%=12s%=12s%=12s%=12s%=12s",
 854                    "Thread", "Name", "Index", "Size", "Alloc", "Free",
 855                    "#Alloc", "#Free");
 856
 857   size = sizeof (vlib_buffer_t) + f->n_data_bytes;
 858   n_free = vec_len (f->buffers);
 859   bytes_alloc = size * f->n_alloc;
 860   bytes_free = size * n_free;
 861
 862   s = format (s, "%7d%30v%12d%12d%=12U%=12U%=12d%=12d", threadnum,
 863               f->name, f->index, f->n_data_bytes,
 864               format_memory_size, bytes_alloc,
 865               format_memory_size, bytes_free, f->n_alloc, n_free);
 866
 867   return s;
 868 }
 869
 870 static clib_error_t *
 871 show_buffers (vlib_main_t * vm,
 872               unformat_input_t * input, vlib_cli_command_t * cmd)
 873 {
 874   vlib_buffer_free_list_t *f;
 875   vlib_main_t *curr_vm;
 876   u32 vm_index = 0;
 877
 878   vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, 0, 0);
 879
 880   do
 881     {
 882       curr_vm = vlib_mains[vm_index];
 883
 884     /* *INDENT-OFF* */
 885     pool_foreach (f, curr_vm->buffer_free_list_pool, ({
 886       vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, f, vm_index);
 887     }));
 888     /* *INDENT-ON* */
 889
 890       vm_index++;
 891     }
 892   while (vm_index < vec_len (vlib_mains));
 893
 894   return 0;
 895 }
 896
 897 /* *INDENT-OFF* */
 898 VLIB_CLI_COMMAND (show_buffers_command, static) = {
 899   .path = "show buffers",
 900   .short_help = "Show packet buffer allocation",
 901   .function = show_buffers,
 902 };
 903 /* *INDENT-ON* */
 904
 905 clib_error_t *
 906 vlib_buffer_main_init (struct vlib_main_t * vm)
 907 {
 908   vlib_buffer_main_t *bm = &buffer_main;
 909   clib_error_t *error;
 910   u32 physmem_map_index;
 911   u8 pool_index;
 912   int log2_page_size = 0;
 913
 914   buffer_log_default = vlib_log_register_class ("buffer", 0);
 915
 916   if (vlib_buffer_callbacks)
 917     {
 918       /* external plugin has registered own buffer callbacks
 919          so we just copy them  and quit */
 920       clib_memcpy_fast (&bm->cb, vlib_buffer_callbacks,
 921                         sizeof (vlib_buffer_callbacks_t));
 922       bm->callbacks_registered = 1;
 923       return 0;
 924     }
 925
 926   bm->cb.vlib_buffer_fill_free_list_cb = &vlib_buffer_fill_free_list_internal;
 927   bm->cb.vlib_buffer_free_cb = &vlib_buffer_free_internal;
 928   bm->cb.vlib_buffer_free_no_next_cb = &vlib_buffer_free_no_next_internal;
 929   bm->cb.vlib_buffer_delete_free_list_cb =
 930     &vlib_buffer_delete_free_list_internal;
 931   clib_spinlock_init (&bm->buffer_known_hash_lockp);
 932
 933 retry:
 934   error = vlib_physmem_shared_map_create (vm, "buffers",
 935                                           vlib_buffer_physmem_sz,
 936                                           log2_page_size,
 937                                           CLIB_PMALLOC_NUMA_LOCAL,
 938                                           &physmem_map_index);
 939
 940   if (error && log2_page_size == 0)
 941     {
 942       vlib_log_warn (buffer_log_default, "%U", format_clib_error, error);
 943       clib_error_free (error);
 944       vlib_log_warn (buffer_log_default, "falling back to non-hugepage "
 945                      "backed buffer pool");
 946       log2_page_size = min_log2 (clib_mem_get_page_size ());
 947       goto retry;
 948     }
 949
 950   if (error)
 951     return error;
 952
 953   pool_index = vlib_buffer_register_physmem_map (vm, physmem_map_index);
 954   vlib_buffer_pool_t *bp = vlib_buffer_pool_get (pool_index);
 955   clib_spinlock_init (&bp->lock);
 956   bp->buffer_size = VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES +
 957     sizeof (vlib_buffer_t);
 958
 959   return 0;
 960 }
 961
 962 static clib_error_t *
 963 vlib_buffers_configure (vlib_main_t * vm, unformat_input_t * input)
 964 {
 965   u32 size_in_mb;
 966
 967   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 968     {
 969       if (unformat (input, "memory-size-in-mb %d", &size_in_mb))
 970         vlib_buffer_physmem_sz = size_in_mb << 20;
 971       else
 972         return unformat_parse_error (input);
 973     }
 974
 975   unformat_free (input);
 976   return 0;
 977 }
 978
 979 VLIB_EARLY_CONFIG_FUNCTION (vlib_buffers_configure, "buffers");
 980
 981
 982 /** @endcond */
 983 /*
 984  * fd.io coding-style-patch-verification: ON
 985  *
 986  * Local Variables:
 987  * eval: (c-set-style "gnu")
 988  * End:
 989  */