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 static u32 vlib_buffer_physmem_sz = 32 << 20;
  51
  52 uword
  53 vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm,
  54                                        vlib_buffer_t * b_first)
  55 {
  56   vlib_buffer_t *b = b_first;
  57   uword l_first = b_first->current_length;
  58   uword l = 0;
  59   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
  60     {
  61       b = vlib_get_buffer (vm, b->next_buffer);
  62       l += b->current_length;
  63     }
  64   b_first->total_length_not_including_first_buffer = l;
  65   b_first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  66   return l + l_first;
  67 }
  68
  69 u8 *
  70 format_vlib_buffer (u8 * s, va_list * args)
  71 {
  72   vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
  73   u32 indent = format_get_indent (s);
  74
  75   s = format (s, "current data %d, length %d, free-list %d, clone-count %u",
  76               b->current_data, b->current_length,
  77               vlib_buffer_get_free_list_index (b), b->n_add_refs);
  78
  79   if (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID)
  80     s = format (s, ", totlen-nifb %d",
  81                 b->total_length_not_including_first_buffer);
  82
  83   if (b->flags & VLIB_BUFFER_IS_TRACED)
  84     s = format (s, ", trace 0x%x", b->trace_index);
  85
  86   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
  87     {
  88       vlib_main_t *vm = vlib_get_main ();
  89       u32 next_buffer = b->next_buffer;
  90       b = vlib_get_buffer (vm, next_buffer);
  91
  92       s =
  93         format (s, "\n%Unext-buffer 0x%x, segment length %d, clone-count %u",
  94                 format_white_space, indent, next_buffer, b->current_length,
  95                 b->n_add_refs);
  96     }
  97
  98   return s;
  99 }
 100
 101 u8 *
 102 format_vlib_buffer_and_data (u8 * s, va_list * args)
 103 {
 104   vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
 105
 106   s = format (s, "%U, %U",
 107               format_vlib_buffer, b,
 108               format_hex_bytes, vlib_buffer_get_current (b), 64);
 109
 110   return s;
 111 }
 112
 113 static u8 *
 114 format_vlib_buffer_known_state (u8 * s, va_list * args)
 115 {
 116   vlib_buffer_known_state_t state = va_arg (*args, vlib_buffer_known_state_t);
 117   char *t;
 118
 119   switch (state)
 120     {
 121     case VLIB_BUFFER_UNKNOWN:
 122       t = "unknown";
 123       break;
 124
 125     case VLIB_BUFFER_KNOWN_ALLOCATED:
 126       t = "known-allocated";
 127       break;
 128
 129     case VLIB_BUFFER_KNOWN_FREE:
 130       t = "known-free";
 131       break;
 132
 133     default:
 134       t = "invalid";
 135       break;
 136     }
 137
 138   return format (s, "%s", t);
 139 }
 140
 141 u8 *
 142 format_vlib_buffer_contents (u8 * s, va_list * va)
 143 {
 144   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
 145   vlib_buffer_t *b = va_arg (*va, vlib_buffer_t *);
 146
 147   while (1)
 148     {
 149       vec_add (s, vlib_buffer_get_current (b), b->current_length);
 150       if (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))
 151         break;
 152       b = vlib_get_buffer (vm, b->next_buffer);
 153     }
 154
 155   return s;
 156 }
 157
 158 static u8 *
 159 vlib_validate_buffer_helper (vlib_main_t * vm,
 160                              u32 bi,
 161                              uword follow_buffer_next, uword ** unique_hash)
 162 {
 163   vlib_buffer_t *b = vlib_get_buffer (vm, bi);
 164   vlib_buffer_main_t *bm = vm->buffer_main;
 165   vlib_buffer_free_list_t *fl;
 166
 167   if (pool_is_free_index
 168       (bm->buffer_free_list_pool, vlib_buffer_get_free_list_index (b)))
 169     return format (0, "unknown free list 0x%x",
 170                    vlib_buffer_get_free_list_index (b));
 171
 172   fl =
 173     pool_elt_at_index (bm->buffer_free_list_pool,
 174                        vlib_buffer_get_free_list_index (b));
 175
 176   if ((signed) b->current_data < (signed) -VLIB_BUFFER_PRE_DATA_SIZE)
 177     return format (0, "current data %d before pre-data", b->current_data);
 178
 179   if (b->current_data + b->current_length > fl->n_data_bytes)
 180     return format (0, "%d-%d beyond end of buffer %d",
 181                    b->current_data, b->current_length, fl->n_data_bytes);
 182
 183   if (follow_buffer_next && (b->flags & VLIB_BUFFER_NEXT_PRESENT))
 184     {
 185       vlib_buffer_known_state_t k;
 186       u8 *msg, *result;
 187
 188       k = vlib_buffer_is_known (vm, b->next_buffer);
 189       if (k != VLIB_BUFFER_KNOWN_ALLOCATED)
 190         return format (0, "next 0x%x: %U",
 191                        b->next_buffer, format_vlib_buffer_known_state, k);
 192
 193       if (unique_hash)
 194         {
 195           if (hash_get (*unique_hash, b->next_buffer))
 196             return format (0, "duplicate buffer 0x%x", b->next_buffer);
 197
 198           hash_set1 (*unique_hash, b->next_buffer);
 199         }
 200
 201       msg = vlib_validate_buffer (vm, b->next_buffer, follow_buffer_next);
 202       if (msg)
 203         {
 204           result = format (0, "next 0x%x: %v", b->next_buffer, msg);
 205           vec_free (msg);
 206           return result;
 207         }
 208     }
 209
 210   return 0;
 211 }
 212
 213 u8 *
 214 vlib_validate_buffer (vlib_main_t * vm, u32 bi, uword follow_buffer_next)
 215 {
 216   return vlib_validate_buffer_helper (vm, bi, follow_buffer_next,
 217                                       /* unique_hash */ 0);
 218 }
 219
 220 u8 *
 221 vlib_validate_buffers (vlib_main_t * vm,
 222                        u32 * buffers,
 223                        uword next_buffer_stride,
 224                        uword n_buffers,
 225                        vlib_buffer_known_state_t known_state,
 226                        uword follow_buffer_next)
 227 {
 228   uword i, *hash;
 229   u32 bi, *b = buffers;
 230   vlib_buffer_known_state_t k;
 231   u8 *msg = 0, *result = 0;
 232
 233   hash = hash_create (0, 0);
 234   for (i = 0; i < n_buffers; i++)
 235     {
 236       bi = b[0];
 237       b += next_buffer_stride;
 238
 239       /* Buffer is not unique. */
 240       if (hash_get (hash, bi))
 241         {
 242           msg = format (0, "not unique");
 243           goto done;
 244         }
 245
 246       k = vlib_buffer_is_known (vm, bi);
 247       if (k != known_state)
 248         {
 249           msg = format (0, "is %U; expected %U",
 250                         format_vlib_buffer_known_state, k,
 251                         format_vlib_buffer_known_state, known_state);
 252           goto done;
 253         }
 254
 255       msg = vlib_validate_buffer_helper (vm, bi, follow_buffer_next, &hash);
 256       if (msg)
 257         goto done;
 258
 259       hash_set1 (hash, bi);
 260     }
 261
 262 done:
 263   if (msg)
 264     {
 265       result = format (0, "0x%x: %v", bi, msg);
 266       vec_free (msg);
 267     }
 268   hash_free (hash);
 269   return result;
 270 }
 271
 272 /*
 273  * Hand-craft a static vector w/ length 1, so vec_len(vlib_mains) =1
 274  * and vlib_mains[0] = &vlib_global_main from the beginning of time.
 275  *
 276  * The only place which should ever expand vlib_mains is start_workers()
 277  * in threads.c. It knows about the bootstrap vector.
 278  */
 279 /* *INDENT-OFF* */
 280 static struct
 281 {
 282   vec_header_t h;
 283   vlib_main_t *vm;
 284 } __attribute__ ((packed)) __bootstrap_vlib_main_vector
 285   __attribute__ ((aligned (CLIB_CACHE_LINE_BYTES))) =
 286 {
 287   .h.len = 1,
 288   .vm = &vlib_global_main,
 289 };
 290 /* *INDENT-ON* */
 291
 292 vlib_main_t **vlib_mains = &__bootstrap_vlib_main_vector.vm;
 293
 294
 295 /* When dubugging validate that given buffers are either known allocated
 296    or known free. */
 297 static void
 298 vlib_buffer_validate_alloc_free (vlib_main_t * vm,
 299                                  u32 * buffers,
 300                                  uword n_buffers,
 301                                  vlib_buffer_known_state_t expected_state)
 302 {
 303   u32 *b;
 304   uword i, bi, is_free;
 305
 306   if (CLIB_DEBUG == 0)
 307     return;
 308
 309   is_free = expected_state == VLIB_BUFFER_KNOWN_ALLOCATED;
 310   b = buffers;
 311   for (i = 0; i < n_buffers; i++)
 312     {
 313       vlib_buffer_known_state_t known;
 314
 315       bi = b[0];
 316       b += 1;
 317       known = vlib_buffer_is_known (vm, bi);
 318       if (known != expected_state)
 319         {
 320           ASSERT (0);
 321           vlib_panic_with_msg
 322             (vm, "%s %U buffer 0x%x",
 323              is_free ? "freeing" : "allocating",
 324              format_vlib_buffer_known_state, known, bi);
 325         }
 326
 327       vlib_buffer_set_known_state
 328         (vm, bi,
 329          is_free ? VLIB_BUFFER_KNOWN_FREE : VLIB_BUFFER_KNOWN_ALLOCATED);
 330     }
 331 }
 332
 333 void
 334 vlib_buffer_merge_free_lists (vlib_buffer_free_list_t * dst,
 335                               vlib_buffer_free_list_t * src)
 336 {
 337   uword l;
 338   u32 *d;
 339
 340   l = vec_len (src->buffers);
 341   if (l > 0)
 342     {
 343       vec_add2_aligned (dst->buffers, d, l, CLIB_CACHE_LINE_BYTES);
 344       clib_memcpy (d, src->buffers, l * sizeof (d[0]));
 345       vec_free (src->buffers);
 346     }
 347 }
 348
 349 /* Add buffer free list. */
 350 static u32
 351 vlib_buffer_create_free_list_helper (vlib_main_t * vm,
 352                                      u32 n_data_bytes,
 353                                      u32 is_public, u32 is_default, u8 * name)
 354 {
 355   vlib_buffer_main_t *bm = vm->buffer_main;
 356   vlib_buffer_free_list_t *f;
 357   int i;
 358
 359   ASSERT (vlib_get_thread_index () == 0);
 360
 361   if (!is_default && pool_elts (bm->buffer_free_list_pool) == 0)
 362     {
 363       u32 default_free_free_list_index;
 364
 365       /* *INDENT-OFF* */
 366       default_free_free_list_index =
 367         vlib_buffer_create_free_list_helper
 368         (vm,
 369          /* default buffer size */ VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES,
 370          /* is_public */ 1,
 371          /* is_default */ 1,
 372          (u8 *) "default");
 373       /* *INDENT-ON* */
 374       ASSERT (default_free_free_list_index ==
 375               VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 376
 377       if (n_data_bytes == VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES && is_public)
 378         return default_free_free_list_index;
 379     }
 380
 381   pool_get_aligned (bm->buffer_free_list_pool, f, CLIB_CACHE_LINE_BYTES);
 382
 383   memset (f, 0, sizeof (f[0]));
 384   f->index = f - bm->buffer_free_list_pool;
 385   f->n_data_bytes = vlib_buffer_round_size (n_data_bytes);
 386   f->min_n_buffers_each_physmem_alloc = VLIB_FRAME_SIZE;
 387   f->name = clib_mem_is_vec (name) ? name : format (0, "%s", name);
 388
 389   /* Setup free buffer template. */
 390   vlib_buffer_set_free_list_index (&f->buffer_init_template, f->index);
 391   f->buffer_init_template.n_add_refs = 0;
 392
 393   if (is_public)
 394     {
 395       uword *p = hash_get (bm->free_list_by_size, f->n_data_bytes);
 396       if (!p)
 397         hash_set (bm->free_list_by_size, f->n_data_bytes, f->index);
 398     }
 399
 400   clib_spinlock_init (&f->global_buffers_lock);
 401
 402   for (i = 1; i < vec_len (vlib_mains); i++)
 403     {
 404       vlib_buffer_main_t *wbm = vlib_mains[i]->buffer_main;
 405       vlib_buffer_free_list_t *wf;
 406       pool_get_aligned (wbm->buffer_free_list_pool,
 407                         wf, CLIB_CACHE_LINE_BYTES);
 408       ASSERT (f - bm->buffer_free_list_pool ==
 409               wf - wbm->buffer_free_list_pool);
 410       wf[0] = f[0];
 411       wf->buffers = 0;
 412       wf->n_alloc = 0;
 413     }
 414
 415   return f->index;
 416 }
 417
 418 u32
 419 vlib_buffer_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
 420                               char *fmt, ...)
 421 {
 422   va_list va;
 423   u8 *name;
 424
 425   va_start (va, fmt);
 426   name = va_format (0, fmt, &va);
 427   va_end (va);
 428
 429   return vlib_buffer_create_free_list_helper (vm, n_data_bytes,
 430                                               /* is_public */ 0,
 431                                               /* is_default */ 0,
 432                                               name);
 433 }
 434
 435 u32
 436 vlib_buffer_get_or_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
 437                                      char *fmt, ...)
 438 {
 439   u32 i = vlib_buffer_get_free_list_with_size (vm, n_data_bytes);
 440
 441   if (i == ~0)
 442     {
 443       va_list va;
 444       u8 *name;
 445
 446       va_start (va, fmt);
 447       name = va_format (0, fmt, &va);
 448       va_end (va);
 449
 450       i = vlib_buffer_create_free_list_helper (vm, n_data_bytes,
 451                                                /* is_public */ 1,
 452                                                /* is_default */ 0,
 453                                                name);
 454     }
 455
 456   return i;
 457 }
 458
 459 static void
 460 del_free_list (vlib_main_t * vm, vlib_buffer_free_list_t * f)
 461 {
 462   u32 i;
 463
 464   for (i = 0; i < vec_len (f->buffer_memory_allocated); i++)
 465     vm->os_physmem_free (vm, vm->buffer_main->buffer_pools[0].physmem_region,
 466                          f->buffer_memory_allocated[i]);
 467   vec_free (f->name);
 468   vec_free (f->buffer_memory_allocated);
 469   vec_free (f->buffers);
 470 }
 471
 472 /* Add buffer free list. */
 473 void
 474 vlib_buffer_delete_free_list_internal (vlib_main_t * vm, u32 free_list_index)
 475 {
 476   vlib_buffer_main_t *bm = vm->buffer_main;
 477   vlib_buffer_free_list_t *f;
 478   u32 merge_index;
 479   int i;
 480
 481   ASSERT (vlib_get_thread_index () == 0);
 482
 483   f = vlib_buffer_get_free_list (vm, free_list_index);
 484
 485   ASSERT (vec_len (f->buffers) == f->n_alloc);
 486   merge_index = vlib_buffer_get_free_list_with_size (vm, f->n_data_bytes);
 487   if (merge_index != ~0 && merge_index != free_list_index)
 488     {
 489       vlib_buffer_merge_free_lists (pool_elt_at_index
 490                                     (bm->buffer_free_list_pool, merge_index),
 491                                     f);
 492     }
 493
 494   del_free_list (vm, f);
 495
 496   /* Poison it. */
 497   memset (f, 0xab, sizeof (f[0]));
 498
 499   pool_put (bm->buffer_free_list_pool, f);
 500
 501   for (i = 1; i < vec_len (vlib_mains); i++)
 502     {
 503       bm = vlib_mains[i]->buffer_main;
 504       f = vlib_buffer_get_free_list (vlib_mains[i], free_list_index);;
 505       memset (f, 0xab, sizeof (f[0]));
 506       pool_put (bm->buffer_free_list_pool, f);
 507     }
 508 }
 509
 510 /* Make sure free list has at least given number of free buffers. */
 511 static uword
 512 fill_free_list (vlib_main_t * vm,
 513                 vlib_buffer_free_list_t * fl, uword min_free_buffers)
 514 {
 515   vlib_buffer_t *buffers, *b;
 516   vlib_buffer_free_list_t *mfl;
 517   int n, n_bytes, i;
 518   u32 *bi;
 519   u32 n_remaining, n_alloc, n_this_chunk;
 520
 521   /* Already have enough free buffers on free list? */
 522   n = min_free_buffers - vec_len (fl->buffers);
 523   if (n <= 0)
 524     return min_free_buffers;
 525
 526   mfl = vlib_buffer_get_free_list (vlib_mains[0], fl->index);
 527   if (vec_len (mfl->global_buffers) > 0)
 528     {
 529       int n_copy, n_left;
 530       clib_spinlock_lock (&mfl->global_buffers_lock);
 531       n_copy = clib_min (vec_len (mfl->global_buffers), n);
 532       n_left = vec_len (mfl->global_buffers) - n_copy;
 533       vec_add_aligned (fl->buffers, mfl->global_buffers + n_left, n_copy,
 534                        CLIB_CACHE_LINE_BYTES);
 535       _vec_len (mfl->global_buffers) = n_left;
 536       clib_spinlock_unlock (&mfl->global_buffers_lock);
 537       n = min_free_buffers - vec_len (fl->buffers);
 538       if (n <= 0)
 539         return min_free_buffers;
 540     }
 541
 542   /* Always allocate round number of buffers. */
 543   n = round_pow2 (n, CLIB_CACHE_LINE_BYTES / sizeof (u32));
 544
 545   /* Always allocate new buffers in reasonably large sized chunks. */
 546   n = clib_max (n, fl->min_n_buffers_each_physmem_alloc);
 547
 548   n_remaining = n;
 549   n_alloc = 0;
 550   while (n_remaining > 0)
 551     {
 552       n_this_chunk = clib_min (n_remaining, 16);
 553
 554       n_bytes = n_this_chunk * (sizeof (b[0]) + fl->n_data_bytes);
 555
 556       /* drb: removed power-of-2 ASSERT */
 557       buffers =
 558         vm->os_physmem_alloc_aligned (vm,
 559                                       vm->buffer_main->
 560                                       buffer_pools[0].physmem_region, n_bytes,
 561                                       sizeof (vlib_buffer_t));
 562       if (!buffers)
 563         return n_alloc;
 564
 565       /* Record chunk as being allocated so we can free it later. */
 566       vec_add1 (fl->buffer_memory_allocated, buffers);
 567
 568       fl->n_alloc += n_this_chunk;
 569       n_alloc += n_this_chunk;
 570       n_remaining -= n_this_chunk;
 571
 572       b = buffers;
 573       vec_add2_aligned (fl->buffers, bi, n_this_chunk, CLIB_CACHE_LINE_BYTES);
 574       for (i = 0; i < n_this_chunk; i++)
 575         {
 576           bi[i] = vlib_get_buffer_index (vm, b);
 577
 578           if (CLIB_DEBUG > 0)
 579             vlib_buffer_set_known_state (vm, bi[i], VLIB_BUFFER_KNOWN_FREE);
 580           b = vlib_buffer_next_contiguous (b, fl->n_data_bytes);
 581         }
 582
 583       memset (buffers, 0, n_bytes);
 584
 585       /* Initialize all new buffers. */
 586       b = buffers;
 587       for (i = 0; i < n_this_chunk; i++)
 588         {
 589           vlib_buffer_init_for_free_list (b, fl);
 590           b = vlib_buffer_next_contiguous (b, fl->n_data_bytes);
 591         }
 592
 593       if (fl->buffer_init_function)
 594         fl->buffer_init_function (vm, fl, bi, n_this_chunk);
 595     }
 596   return n_alloc;
 597 }
 598
 599 static u32
 600 alloc_from_free_list (vlib_main_t * vm,
 601                       vlib_buffer_free_list_t * free_list,
 602                       u32 * alloc_buffers, u32 n_alloc_buffers)
 603 {
 604   u32 *dst, *src;
 605   uword len;
 606   uword n_filled;
 607
 608   dst = alloc_buffers;
 609
 610   n_filled = fill_free_list (vm, free_list, n_alloc_buffers);
 611   if (n_filled == 0)
 612     return 0;
 613
 614   len = vec_len (free_list->buffers);
 615   ASSERT (len >= n_alloc_buffers);
 616
 617   src = free_list->buffers + len - n_alloc_buffers;
 618   clib_memcpy (dst, src, n_alloc_buffers * sizeof (u32));
 619
 620   _vec_len (free_list->buffers) -= n_alloc_buffers;
 621
 622   /* Verify that buffers are known free. */
 623   vlib_buffer_validate_alloc_free (vm, alloc_buffers,
 624                                    n_alloc_buffers, VLIB_BUFFER_KNOWN_FREE);
 625
 626   return n_alloc_buffers;
 627 }
 628
 629
 630 /* Allocate a given number of buffers into given array.
 631    Returns number actually allocated which will be either zero or
 632    number requested. */
 633 static u32
 634 vlib_buffer_alloc_internal (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 635 {
 636   vlib_buffer_main_t *bm = vm->buffer_main;
 637
 638   return alloc_from_free_list
 639     (vm,
 640      pool_elt_at_index (bm->buffer_free_list_pool,
 641                         VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX),
 642      buffers, n_buffers);
 643 }
 644
 645 static u32
 646 vlib_buffer_alloc_from_free_list_internal (vlib_main_t * vm,
 647                                            u32 * buffers,
 648                                            u32 n_buffers, u32 free_list_index)
 649 {
 650   vlib_buffer_main_t *bm = vm->buffer_main;
 651   vlib_buffer_free_list_t *f;
 652   f = pool_elt_at_index (bm->buffer_free_list_pool, free_list_index);
 653   return alloc_from_free_list (vm, f, buffers, n_buffers);
 654 }
 655
 656 void *
 657 vlib_set_buffer_free_callback (vlib_main_t * vm, void *fp)
 658 {
 659   vlib_buffer_main_t *bm = vm->buffer_main;
 660   void *rv = bm->buffer_free_callback;
 661
 662   bm->buffer_free_callback = fp;
 663   return rv;
 664 }
 665
 666 static_always_inline void
 667 vlib_buffer_free_inline (vlib_main_t * vm,
 668                          u32 * buffers, u32 n_buffers, u32 follow_buffer_next)
 669 {
 670   vlib_buffer_main_t *bm = vm->buffer_main;
 671   vlib_buffer_free_list_t *fl;
 672   u32 fi;
 673   int i;
 674   u32 (*cb) (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 675              u32 follow_buffer_next);
 676
 677   cb = bm->buffer_free_callback;
 678
 679   if (PREDICT_FALSE (cb != 0))
 680     n_buffers = (*cb) (vm, buffers, n_buffers, follow_buffer_next);
 681
 682   if (!n_buffers)
 683     return;
 684
 685   for (i = 0; i < n_buffers; i++)
 686     {
 687       vlib_buffer_t *b;
 688       u32 bi = buffers[i];
 689
 690       b = vlib_get_buffer (vm, bi);
 691       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
 692       fl = vlib_buffer_get_buffer_free_list (vm, b, &fi);
 693
 694       /* The only current use of this callback: multicast recycle */
 695       if (PREDICT_FALSE (fl->buffers_added_to_freelist_function != 0))
 696         {
 697           int j;
 698
 699           vlib_buffer_add_to_free_list
 700             (vm, fl, buffers[i], (b->flags & VLIB_BUFFER_RECYCLE) == 0);
 701
 702           for (j = 0; j < vec_len (bm->announce_list); j++)
 703             {
 704               if (fl == bm->announce_list[j])
 705                 goto already_announced;
 706             }
 707           vec_add1 (bm->announce_list, fl);
 708         already_announced:
 709           ;
 710         }
 711       else
 712         {
 713           if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_RECYCLE) == 0))
 714             {
 715               u32 flags, next;
 716
 717               do
 718                 {
 719                   vlib_buffer_t *nb = vlib_get_buffer (vm, bi);
 720                   flags = nb->flags;
 721                   next = nb->next_buffer;
 722                   if (nb->n_add_refs)
 723                     nb->n_add_refs--;
 724                   else
 725                     {
 726                       vlib_buffer_validate_alloc_free (vm, &bi, 1,
 727                                                        VLIB_BUFFER_KNOWN_ALLOCATED);
 728                       vlib_buffer_add_to_free_list (vm, fl, bi, 1);
 729                     }
 730                   bi = next;
 731                 }
 732               while (follow_buffer_next
 733                      && (flags & VLIB_BUFFER_NEXT_PRESENT));
 734
 735             }
 736         }
 737     }
 738   if (vec_len (bm->announce_list))
 739     {
 740       vlib_buffer_free_list_t *fl;
 741       for (i = 0; i < vec_len (bm->announce_list); i++)
 742         {
 743           fl = bm->announce_list[i];
 744           fl->buffers_added_to_freelist_function (vm, fl);
 745         }
 746       _vec_len (bm->announce_list) = 0;
 747     }
 748 }
 749
 750 static void
 751 vlib_buffer_free_internal (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 752 {
 753   vlib_buffer_free_inline (vm, buffers, n_buffers,      /* follow_buffer_next */
 754                            1);
 755 }
 756
 757 static void
 758 vlib_buffer_free_no_next_internal (vlib_main_t * vm, u32 * buffers,
 759                                    u32 n_buffers)
 760 {
 761   vlib_buffer_free_inline (vm, buffers, n_buffers,      /* follow_buffer_next */
 762                            0);
 763 }
 764
 765 /* Copy template packet data into buffers as they are allocated. */
 766 static void __attribute__ ((unused))
 767 vlib_packet_template_buffer_init (vlib_main_t * vm,
 768                                   vlib_buffer_free_list_t * fl,
 769                                   u32 * buffers, u32 n_buffers)
 770 {
 771   vlib_packet_template_t *t =
 772     uword_to_pointer (fl->buffer_init_function_opaque,
 773                       vlib_packet_template_t *);
 774   uword i;
 775
 776   for (i = 0; i < n_buffers; i++)
 777     {
 778       vlib_buffer_t *b = vlib_get_buffer (vm, buffers[i]);
 779       ASSERT (b->current_length == vec_len (t->packet_data));
 780       clib_memcpy (vlib_buffer_get_current (b), t->packet_data,
 781                    b->current_length);
 782     }
 783 }
 784
 785 void
 786 vlib_packet_template_init (vlib_main_t * vm,
 787                            vlib_packet_template_t * t,
 788                            void *packet_data,
 789                            uword n_packet_data_bytes,
 790                            uword min_n_buffers_each_physmem_alloc,
 791                            char *fmt, ...)
 792 {
 793   vlib_buffer_main_t *bm = vm->buffer_main;
 794   va_list va;
 795   u8 *name;
 796   vlib_buffer_free_list_t *fl;
 797
 798   va_start (va, fmt);
 799   name = va_format (0, fmt, &va);
 800   va_end (va);
 801
 802   if (bm->cb.vlib_packet_template_init_cb)
 803     bm->cb.vlib_packet_template_init_cb (vm, (void *) t, packet_data,
 804                                          n_packet_data_bytes,
 805                                          min_n_buffers_each_physmem_alloc,
 806                                          name);
 807
 808   vlib_worker_thread_barrier_sync (vm);
 809
 810   memset (t, 0, sizeof (t[0]));
 811
 812   vec_add (t->packet_data, packet_data, n_packet_data_bytes);
 813   t->min_n_buffers_each_physmem_alloc = min_n_buffers_each_physmem_alloc;
 814
 815   t->free_list_index = vlib_buffer_create_free_list_helper
 816     (vm, n_packet_data_bytes,
 817      /* is_public */ 1,
 818      /* is_default */ 0,
 819      name);
 820
 821   ASSERT (t->free_list_index != 0);
 822   fl = vlib_buffer_get_free_list (vm, t->free_list_index);
 823   fl->min_n_buffers_each_physmem_alloc = t->min_n_buffers_each_physmem_alloc;
 824
 825   fl->buffer_init_function = vlib_packet_template_buffer_init;
 826   fl->buffer_init_function_opaque = pointer_to_uword (t);
 827
 828   fl->buffer_init_template.current_data = 0;
 829   fl->buffer_init_template.current_length = n_packet_data_bytes;
 830   fl->buffer_init_template.flags = 0;
 831   fl->buffer_init_template.n_add_refs = 0;
 832   vlib_worker_thread_barrier_release (vm);
 833 }
 834
 835 void *
 836 vlib_packet_template_get_packet (vlib_main_t * vm,
 837                                  vlib_packet_template_t * t, u32 * bi_result)
 838 {
 839   u32 bi;
 840   vlib_buffer_t *b;
 841
 842   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
 843     return 0;
 844
 845   *bi_result = bi;
 846
 847   b = vlib_get_buffer (vm, bi);
 848   clib_memcpy (vlib_buffer_get_current (b),
 849                t->packet_data, vec_len (t->packet_data));
 850   b->current_length = vec_len (t->packet_data);
 851
 852   return b->data;
 853 }
 854
 855 void
 856 vlib_packet_template_get_packet_helper (vlib_main_t * vm,
 857                                         vlib_packet_template_t * t)
 858 {
 859   word n = t->min_n_buffers_each_physmem_alloc;
 860   word l = vec_len (t->packet_data);
 861   word n_alloc;
 862
 863   ASSERT (l > 0);
 864   ASSERT (vec_len (t->free_buffers) == 0);
 865
 866   vec_validate (t->free_buffers, n - 1);
 867   n_alloc = vlib_buffer_alloc_from_free_list (vm, t->free_buffers,
 868                                               n, t->free_list_index);
 869   _vec_len (t->free_buffers) = n_alloc;
 870 }
 871
 872 /* Append given data to end of buffer, possibly allocating new buffers. */
 873 u32
 874 vlib_buffer_add_data (vlib_main_t * vm,
 875                       u32 free_list_index,
 876                       u32 buffer_index, void *data, u32 n_data_bytes)
 877 {
 878   u32 n_buffer_bytes, n_left, n_left_this_buffer, bi;
 879   vlib_buffer_t *b;
 880   void *d;
 881
 882   bi = buffer_index;
 883   if (bi == 0
 884       && 1 != vlib_buffer_alloc_from_free_list (vm, &bi, 1, free_list_index))
 885     goto out_of_buffers;
 886
 887   d = data;
 888   n_left = n_data_bytes;
 889   n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, free_list_index);
 890
 891   b = vlib_get_buffer (vm, bi);
 892   b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 893
 894   /* Get to the end of the chain before we try to append data... */
 895   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 896     b = vlib_get_buffer (vm, b->next_buffer);
 897
 898   while (1)
 899     {
 900       u32 n;
 901
 902       ASSERT (n_buffer_bytes >= b->current_length);
 903       n_left_this_buffer =
 904         n_buffer_bytes - (b->current_data + b->current_length);
 905       n = clib_min (n_left_this_buffer, n_left);
 906       clib_memcpy (vlib_buffer_get_current (b) + b->current_length, d, n);
 907       b->current_length += n;
 908       n_left -= n;
 909       if (n_left == 0)
 910         break;
 911
 912       d += n;
 913       if (1 !=
 914           vlib_buffer_alloc_from_free_list (vm, &b->next_buffer, 1,
 915                                             free_list_index))
 916         goto out_of_buffers;
 917
 918       b->flags |= VLIB_BUFFER_NEXT_PRESENT;
 919
 920       b = vlib_get_buffer (vm, b->next_buffer);
 921     }
 922
 923   return bi;
 924
 925 out_of_buffers:
 926   clib_error ("out of buffers");
 927   return bi;
 928 }
 929
 930 u16
 931 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
 932                                           u32 free_list_index,
 933                                           vlib_buffer_t * first,
 934                                           vlib_buffer_t ** last,
 935                                           void *data, u16 data_len)
 936 {
 937   vlib_buffer_t *l = *last;
 938   u32 n_buffer_bytes =
 939     vlib_buffer_free_list_buffer_size (vm, free_list_index);
 940   u16 copied = 0;
 941   ASSERT (n_buffer_bytes >= l->current_length + l->current_data);
 942   while (data_len)
 943     {
 944       u16 max = n_buffer_bytes - l->current_length - l->current_data;
 945       if (max == 0)
 946         {
 947           if (1 !=
 948               vlib_buffer_alloc_from_free_list (vm, &l->next_buffer, 1,
 949                                                 free_list_index))
 950             return copied;
 951           *last = l = vlib_buffer_chain_buffer (vm, first, l, l->next_buffer);
 952           max = n_buffer_bytes - l->current_length - l->current_data;
 953         }
 954
 955       u16 len = (data_len > max) ? max : data_len;
 956       clib_memcpy (vlib_buffer_get_current (l) + l->current_length,
 957                    data + copied, len);
 958       vlib_buffer_chain_increase_length (first, l, len);
 959       data_len -= len;
 960       copied += len;
 961     }
 962   return copied;
 963 }
 964
 965 u8
 966 vlib_buffer_add_physmem_region (vlib_main_t * vm,
 967                                 vlib_physmem_region_index_t pri)
 968 {
 969   vlib_buffer_main_t *bm = vm->buffer_main;
 970   vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, pri);
 971   vlib_buffer_pool_t *p;
 972   uword start = pointer_to_uword (pr->mem);
 973   uword size = pr->size;
 974
 975   if (bm->buffer_mem_size == 0)
 976     {
 977       bm->buffer_mem_start = start;
 978       bm->buffer_mem_size = size;
 979     }
 980   else if (start < bm->buffer_mem_start)
 981     {
 982       bm->buffer_mem_size += bm->buffer_mem_start - start;
 983       bm->buffer_mem_start = start;
 984       if (size > bm->buffer_mem_size)
 985         bm->buffer_mem_size = size;
 986     }
 987   else if (start > bm->buffer_mem_start)
 988     {
 989       uword new_size = start - bm->buffer_mem_start + size;
 990       if (new_size > bm->buffer_mem_size)
 991         bm->buffer_mem_size = new_size;
 992     }
 993
 994   if ((u64) bm->buffer_mem_size >
 995       ((u64) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
 996     {
 997       clib_panic ("buffer memory size out of range!");
 998     }
 999
1000   vec_add2 (bm->buffer_pools, p, 1);
1001   p->start = start;
1002   p->size = size;
1003   p->physmem_region = pri;
1004   return p - bm->buffer_pools;
1005 }
1006
1007 static u8 *
1008 format_vlib_buffer_free_list (u8 * s, va_list * va)
1009 {
1010   vlib_buffer_free_list_t *f = va_arg (*va, vlib_buffer_free_list_t *);
1011   u32 threadnum = va_arg (*va, u32);
1012   uword bytes_alloc, bytes_free, n_free, size;
1013
1014   if (!f)
1015     return format (s, "%=7s%=30s%=12s%=12s%=12s%=12s%=12s%=12s",
1016                    "Thread", "Name", "Index", "Size", "Alloc", "Free",
1017                    "#Alloc", "#Free");
1018
1019   size = sizeof (vlib_buffer_t) + f->n_data_bytes;
1020   n_free = vec_len (f->buffers);
1021   bytes_alloc = size * f->n_alloc;
1022   bytes_free = size * n_free;
1023
1024   s = format (s, "%7d%30v%12d%12d%=12U%=12U%=12d%=12d", threadnum,
1025               f->name, f->index, f->n_data_bytes,
1026               format_memory_size, bytes_alloc,
1027               format_memory_size, bytes_free, f->n_alloc, n_free);
1028
1029   return s;
1030 }
1031
1032 static clib_error_t *
1033 show_buffers (vlib_main_t * vm,
1034               unformat_input_t * input, vlib_cli_command_t * cmd)
1035 {
1036   vlib_buffer_main_t *bm;
1037   vlib_buffer_free_list_t *f;
1038   vlib_main_t *curr_vm;
1039   u32 vm_index = 0;
1040
1041   vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, 0, 0);
1042
1043   do
1044     {
1045       curr_vm = vlib_mains[vm_index];
1046       bm = curr_vm->buffer_main;
1047
1048     /* *INDENT-OFF* */
1049     pool_foreach (f, bm->buffer_free_list_pool, ({
1050       vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, f, vm_index);
1051     }));
1052     /* *INDENT-ON* */
1053
1054       vm_index++;
1055     }
1056   while (vm_index < vec_len (vlib_mains));
1057
1058   return 0;
1059 }
1060
1061 /* *INDENT-OFF* */
1062 VLIB_CLI_COMMAND (show_buffers_command, static) = {
1063   .path = "show buffers",
1064   .short_help = "Show packet buffer allocation",
1065   .function = show_buffers,
1066 };
1067 /* *INDENT-ON* */
1068
1069 clib_error_t *
1070 vlib_buffer_main_init (struct vlib_main_t * vm)
1071 {
1072   vlib_buffer_main_t *bm;
1073   vlib_physmem_region_index_t pri;
1074   clib_error_t *error;
1075
1076   vec_validate (vm->buffer_main, 0);
1077   bm = vm->buffer_main;
1078
1079   if (vlib_buffer_callbacks)
1080     {
1081       /* external plugin has registered own buffer callbacks
1082          so we just copy them  and quit */
1083       vlib_buffer_main_t *bm = vm->buffer_main;
1084       clib_memcpy (&bm->cb, vlib_buffer_callbacks,
1085                    sizeof (vlib_buffer_callbacks_t));
1086       bm->callbacks_registered = 1;
1087       return 0;
1088     }
1089
1090   bm->cb.vlib_buffer_alloc_cb = &vlib_buffer_alloc_internal;
1091   bm->cb.vlib_buffer_alloc_from_free_list_cb =
1092     &vlib_buffer_alloc_from_free_list_internal;
1093   bm->cb.vlib_buffer_free_cb = &vlib_buffer_free_internal;
1094   bm->cb.vlib_buffer_free_no_next_cb = &vlib_buffer_free_no_next_internal;
1095   bm->cb.vlib_buffer_delete_free_list_cb =
1096     &vlib_buffer_delete_free_list_internal;
1097   clib_spinlock_init (&bm->buffer_known_hash_lockp);
1098
1099   /* allocate default region */
1100   error = vlib_physmem_region_alloc (vm, "buffers",
1101                                      vlib_buffer_physmem_sz, 0,
1102                                      VLIB_PHYSMEM_F_INIT_MHEAP, &pri);
1103
1104   if (error == 0)
1105     goto done;
1106
1107   clib_error_free (error);
1108
1109   /* we my be running unpriviledged, so try to allocate fake physmem */
1110   error = vlib_physmem_region_alloc (vm, "buffers (fake)",
1111                                      vlib_buffer_physmem_sz, 0,
1112                                      VLIB_PHYSMEM_F_FAKE |
1113                                      VLIB_PHYSMEM_F_INIT_MHEAP, &pri);
1114 done:
1115   vlib_buffer_add_physmem_region (vm, pri);
1116   return error;
1117 }
1118
1119 static clib_error_t *
1120 vlib_buffers_configure (vlib_main_t * vm, unformat_input_t * input)
1121 {
1122   u32 size_in_mb;
1123
1124   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1125     {
1126       if (unformat (input, "memory-size-in-mb %d", &size_in_mb))
1127         vlib_buffer_physmem_sz = size_in_mb << 20;
1128       else
1129         return unformat_parse_error (input);
1130     }
1131
1132   unformat_free (input);
1133   return 0;
1134 }
1135
1136 VLIB_EARLY_CONFIG_FUNCTION (vlib_buffers_configure, "buffers");
1137
1138
1139 /** @endcond */
1140 /*
1141  * fd.io coding-style-patch-verification: ON
1142  *
1143  * Local Variables:
1144  * eval: (c-set-style "gnu")
1145  * End:
1146  */