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