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 /* Copy template packet data into buffers as they are allocated. */
 665 static void __attribute__ ((unused))
 666 vlib_packet_template_buffer_init (vlib_main_t * vm,
 667                                   vlib_buffer_free_list_t * fl,
 668                                   u32 * buffers, u32 n_buffers)
 669 {
 670   vlib_packet_template_t *t =
 671     uword_to_pointer (fl->buffer_init_function_opaque,
 672                       vlib_packet_template_t *);
 673   uword i;
 674
 675   for (i = 0; i < n_buffers; i++)
 676     {
 677       vlib_buffer_t *b = vlib_get_buffer (vm, buffers[i]);
 678       ASSERT (b->current_length == vec_len (t->packet_data));
 679       clib_memcpy_fast (vlib_buffer_get_current (b), t->packet_data,
 680                         b->current_length);
 681     }
 682 }
 683
 684 void
 685 vlib_packet_template_init (vlib_main_t * vm,
 686                            vlib_packet_template_t * t,
 687                            void *packet_data,
 688                            uword n_packet_data_bytes,
 689                            uword min_n_buffers_each_alloc, char *fmt, ...)
 690 {
 691   vlib_buffer_main_t *bm = &buffer_main;
 692   va_list va;
 693   u8 *name;
 694   vlib_buffer_free_list_t *fl;
 695
 696   va_start (va, fmt);
 697   name = va_format (0, fmt, &va);
 698   va_end (va);
 699
 700   if (bm->cb.vlib_packet_template_init_cb)
 701     bm->cb.vlib_packet_template_init_cb (vm, (void *) t, packet_data,
 702                                          n_packet_data_bytes,
 703                                          min_n_buffers_each_alloc, name);
 704
 705   vlib_worker_thread_barrier_sync (vm);
 706
 707   clib_memset (t, 0, sizeof (t[0]));
 708
 709   vec_add (t->packet_data, packet_data, n_packet_data_bytes);
 710   t->min_n_buffers_each_alloc = min_n_buffers_each_alloc;
 711
 712   t->free_list_index = vlib_buffer_create_free_list_helper
 713     (vm, n_packet_data_bytes,
 714      /* is_public */ 1,
 715      /* is_default */ 0,
 716      name);
 717
 718   ASSERT (t->free_list_index != 0);
 719   fl = vlib_buffer_get_free_list (vm, t->free_list_index);
 720   fl->min_n_buffers_each_alloc = t->min_n_buffers_each_alloc;
 721
 722   fl->buffer_init_function = vlib_packet_template_buffer_init;
 723   fl->buffer_init_function_opaque = pointer_to_uword (t);
 724
 725   fl->buffer_init_template.current_data = 0;
 726   fl->buffer_init_template.current_length = n_packet_data_bytes;
 727   fl->buffer_init_template.flags = 0;
 728   fl->buffer_init_template.n_add_refs = 0;
 729   vlib_worker_thread_barrier_release (vm);
 730 }
 731
 732 void *
 733 vlib_packet_template_get_packet (vlib_main_t * vm,
 734                                  vlib_packet_template_t * t, u32 * bi_result)
 735 {
 736   u32 bi;
 737   vlib_buffer_t *b;
 738
 739   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
 740     return 0;
 741
 742   *bi_result = bi;
 743
 744   b = vlib_get_buffer (vm, bi);
 745   clib_memcpy_fast (vlib_buffer_get_current (b),
 746                     t->packet_data, vec_len (t->packet_data));
 747   b->current_length = vec_len (t->packet_data);
 748
 749   return b->data;
 750 }
 751
 752 void
 753 vlib_packet_template_get_packet_helper (vlib_main_t * vm,
 754                                         vlib_packet_template_t * t)
 755 {
 756   word n = t->min_n_buffers_each_alloc;
 757   word l = vec_len (t->packet_data);
 758   word n_alloc;
 759
 760   ASSERT (l > 0);
 761   ASSERT (vec_len (t->free_buffers) == 0);
 762
 763   vec_validate (t->free_buffers, n - 1);
 764   n_alloc = vlib_buffer_alloc_from_free_list (vm, t->free_buffers,
 765                                               n, t->free_list_index);
 766   _vec_len (t->free_buffers) = n_alloc;
 767 }
 768
 769 /* Append given data to end of buffer, possibly allocating new buffers. */
 770 u32
 771 vlib_buffer_add_data (vlib_main_t * vm,
 772                       vlib_buffer_free_list_index_t free_list_index,
 773                       u32 buffer_index, void *data, u32 n_data_bytes)
 774 {
 775   u32 n_buffer_bytes, n_left, n_left_this_buffer, bi;
 776   vlib_buffer_t *b;
 777   void *d;
 778
 779   bi = buffer_index;
 780   if (bi == ~0
 781       && 1 != vlib_buffer_alloc_from_free_list (vm, &bi, 1, free_list_index))
 782     goto out_of_buffers;
 783
 784   d = data;
 785   n_left = n_data_bytes;
 786   n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, free_list_index);
 787
 788   b = vlib_get_buffer (vm, bi);
 789   b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 790
 791   /* Get to the end of the chain before we try to append data... */
 792   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 793     b = vlib_get_buffer (vm, b->next_buffer);
 794
 795   while (1)
 796     {
 797       u32 n;
 798
 799       ASSERT (n_buffer_bytes >= b->current_length);
 800       n_left_this_buffer =
 801         n_buffer_bytes - (b->current_data + b->current_length);
 802       n = clib_min (n_left_this_buffer, n_left);
 803       clib_memcpy_fast (vlib_buffer_get_current (b) + b->current_length, d,
 804                         n);
 805       b->current_length += n;
 806       n_left -= n;
 807       if (n_left == 0)
 808         break;
 809
 810       d += n;
 811       if (1 !=
 812           vlib_buffer_alloc_from_free_list (vm, &b->next_buffer, 1,
 813                                             free_list_index))
 814         goto out_of_buffers;
 815
 816       b->flags |= VLIB_BUFFER_NEXT_PRESENT;
 817
 818       b = vlib_get_buffer (vm, b->next_buffer);
 819     }
 820
 821   return bi;
 822
 823 out_of_buffers:
 824   clib_error ("out of buffers");
 825   return bi;
 826 }
 827
 828 u16
 829 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
 830                                           vlib_buffer_free_list_index_t
 831                                           free_list_index,
 832                                           vlib_buffer_t * first,
 833                                           vlib_buffer_t ** last, void *data,
 834                                           u16 data_len)
 835 {
 836   vlib_buffer_t *l = *last;
 837   u32 n_buffer_bytes =
 838     vlib_buffer_free_list_buffer_size (vm, free_list_index);
 839   u16 copied = 0;
 840   ASSERT (n_buffer_bytes >= l->current_length + l->current_data);
 841   while (data_len)
 842     {
 843       u16 max = n_buffer_bytes - l->current_length - l->current_data;
 844       if (max == 0)
 845         {
 846           if (1 !=
 847               vlib_buffer_alloc_from_free_list (vm, &l->next_buffer, 1,
 848                                                 free_list_index))
 849             return copied;
 850           *last = l = vlib_buffer_chain_buffer (vm, l, l->next_buffer);
 851           max = n_buffer_bytes - l->current_length - l->current_data;
 852         }
 853
 854       u16 len = (data_len > max) ? max : data_len;
 855       clib_memcpy_fast (vlib_buffer_get_current (l) + l->current_length,
 856                         data + copied, len);
 857       vlib_buffer_chain_increase_length (first, l, len);
 858       data_len -= len;
 859       copied += len;
 860     }
 861   return copied;
 862 }
 863
 864 u8
 865 vlib_buffer_register_physmem_map (vlib_main_t * vm, u32 physmem_map_index)
 866 {
 867   vlib_buffer_main_t *bm = &buffer_main;
 868   vlib_buffer_pool_t *p;
 869   vlib_physmem_map_t *m = vlib_physmem_get_map (vm, physmem_map_index);
 870   uword start = pointer_to_uword (m->base);
 871   uword size = (uword) m->n_pages << m->log2_page_size;
 872
 873   if (bm->buffer_mem_size == 0)
 874     {
 875       bm->buffer_mem_start = start;
 876       bm->buffer_mem_size = size;
 877     }
 878   else if (start < bm->buffer_mem_start)
 879     {
 880       bm->buffer_mem_size += bm->buffer_mem_start - start;
 881       bm->buffer_mem_start = start;
 882       if (size > bm->buffer_mem_size)
 883         bm->buffer_mem_size = size;
 884     }
 885   else if (start > bm->buffer_mem_start)
 886     {
 887       uword new_size = start - bm->buffer_mem_start + size;
 888       if (new_size > bm->buffer_mem_size)
 889         bm->buffer_mem_size = new_size;
 890     }
 891
 892   if ((u64) bm->buffer_mem_size >
 893       ((u64) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
 894     {
 895       clib_panic ("buffer memory size out of range!");
 896     }
 897
 898   vec_add2 (bm->buffer_pools, p, 1);
 899   p->start = start;
 900   p->size = size;
 901   p->physmem_map_index = physmem_map_index;
 902
 903   ASSERT (p - bm->buffer_pools < 256);
 904   return p - bm->buffer_pools;
 905 }
 906
 907 static u8 *
 908 format_vlib_buffer_free_list (u8 * s, va_list * va)
 909 {
 910   vlib_buffer_free_list_t *f = va_arg (*va, vlib_buffer_free_list_t *);
 911   u32 threadnum = va_arg (*va, u32);
 912   uword bytes_alloc, bytes_free, n_free, size;
 913
 914   if (!f)
 915     return format (s, "%=7s%=30s%=12s%=12s%=12s%=12s%=12s%=12s",
 916                    "Thread", "Name", "Index", "Size", "Alloc", "Free",
 917                    "#Alloc", "#Free");
 918
 919   size = sizeof (vlib_buffer_t) + f->n_data_bytes;
 920   n_free = vec_len (f->buffers);
 921   bytes_alloc = size * f->n_alloc;
 922   bytes_free = size * n_free;
 923
 924   s = format (s, "%7d%30v%12d%12d%=12U%=12U%=12d%=12d", threadnum,
 925               f->name, f->index, f->n_data_bytes,
 926               format_memory_size, bytes_alloc,
 927               format_memory_size, bytes_free, f->n_alloc, n_free);
 928
 929   return s;
 930 }
 931
 932 static clib_error_t *
 933 show_buffers (vlib_main_t * vm,
 934               unformat_input_t * input, vlib_cli_command_t * cmd)
 935 {
 936   vlib_buffer_free_list_t *f;
 937   vlib_main_t *curr_vm;
 938   u32 vm_index = 0;
 939
 940   vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, 0, 0);
 941
 942   do
 943     {
 944       curr_vm = vlib_mains[vm_index];
 945
 946     /* *INDENT-OFF* */
 947     pool_foreach (f, curr_vm->buffer_free_list_pool, ({
 948       vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, f, vm_index);
 949     }));
 950     /* *INDENT-ON* */
 951
 952       vm_index++;
 953     }
 954   while (vm_index < vec_len (vlib_mains));
 955
 956   return 0;
 957 }
 958
 959 /* *INDENT-OFF* */
 960 VLIB_CLI_COMMAND (show_buffers_command, static) = {
 961   .path = "show buffers",
 962   .short_help = "Show packet buffer allocation",
 963   .function = show_buffers,
 964 };
 965 /* *INDENT-ON* */
 966
 967 clib_error_t *
 968 vlib_buffer_main_init (struct vlib_main_t * vm)
 969 {
 970   vlib_buffer_main_t *bm = &buffer_main;
 971   clib_error_t *error;
 972   u32 physmem_map_index;
 973   u8 pool_index;
 974   int log2_page_size = 0;
 975
 976   buffer_log_default = vlib_log_register_class ("buffer", 0);
 977
 978   if (vlib_buffer_callbacks)
 979     {
 980       /* external plugin has registered own buffer callbacks
 981          so we just copy them  and quit */
 982       clib_memcpy_fast (&bm->cb, vlib_buffer_callbacks,
 983                         sizeof (vlib_buffer_callbacks_t));
 984       bm->callbacks_registered = 1;
 985       return 0;
 986     }
 987
 988   bm->cb.vlib_buffer_fill_free_list_cb = &vlib_buffer_fill_free_list_internal;
 989   bm->cb.vlib_buffer_free_cb = &vlib_buffer_free_internal;
 990   bm->cb.vlib_buffer_free_no_next_cb = &vlib_buffer_free_no_next_internal;
 991   bm->cb.vlib_buffer_delete_free_list_cb =
 992     &vlib_buffer_delete_free_list_internal;
 993   clib_spinlock_init (&bm->buffer_known_hash_lockp);
 994
 995 retry:
 996   error = vlib_physmem_shared_map_create (vm, "buffers",
 997                                           vlib_buffer_physmem_sz,
 998                                           log2_page_size,
 999                                           CLIB_PMALLOC_NUMA_LOCAL,
1000                                           &physmem_map_index);
1001
1002   if (error && log2_page_size == 0)
1003     {
1004       vlib_log_warn (buffer_log_default, "%U", format_clib_error, error);
1005       clib_error_free (error);
1006       vlib_log_warn (buffer_log_default, "falling back to non-hugepage "
1007                      "backed buffer pool");
1008       log2_page_size = min_log2 (clib_mem_get_page_size ());
1009       goto retry;
1010     }
1011
1012   if (error)
1013     return error;
1014
1015   pool_index = vlib_buffer_register_physmem_map (vm, physmem_map_index);
1016   vlib_buffer_pool_t *bp = vlib_buffer_pool_get (pool_index);
1017   clib_spinlock_init (&bp->lock);
1018   bp->buffer_size = VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES +
1019     sizeof (vlib_buffer_t);
1020
1021   return 0;
1022 }
1023
1024 static clib_error_t *
1025 vlib_buffers_configure (vlib_main_t * vm, unformat_input_t * input)
1026 {
1027   u32 size_in_mb;
1028
1029   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1030     {
1031       if (unformat (input, "memory-size-in-mb %d", &size_in_mb))
1032         vlib_buffer_physmem_sz = size_in_mb << 20;
1033       else
1034         return unformat_parse_error (input);
1035     }
1036
1037   unformat_free (input);
1038   return 0;
1039 }
1040
1041 VLIB_EARLY_CONFIG_FUNCTION (vlib_buffers_configure, "buffers");
1042
1043
1044 /** @endcond */
1045 /*
1046  * fd.io coding-style-patch-verification: ON
1047  *
1048  * Local Variables:
1049  * eval: (c-set-style "gnu")
1050  * End:
1051  */