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 <vppinfra/linux/sysfs.h>
  47 #include <vlib/vlib.h>
  48 #include <vlib/unix/unix.h>
  49
  50 #define VLIB_BUFFER_DEFAULT_BUFFERS_PER_NUMA 16384
  51 #define VLIB_BUFFER_DEFAULT_BUFFERS_PER_NUMA_UNPRIV 8192
  52
  53 #ifdef CLIB_HAVE_VEC128
  54 /* Assumptions by vlib_buffer_free_inline: */
  55 STATIC_ASSERT_FITS_IN (vlib_buffer_t, flags, 16);
  56 STATIC_ASSERT_FITS_IN (vlib_buffer_t, ref_count, 16);
  57 STATIC_ASSERT_FITS_IN (vlib_buffer_t, buffer_pool_index, 16);
  58 #endif
  59
  60 /* Make sure that buffer template size is not accidentally changed */
  61 STATIC_ASSERT_OFFSET_OF (vlib_buffer_t, template_end, 64);
  62
  63 u16 __vlib_buffer_external_hdr_size = 0;
  64
  65 uword
  66 vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm,
  67                                        vlib_buffer_t * b_first)
  68 {
  69   vlib_buffer_t *b = b_first;
  70   uword l_first = b_first->current_length;
  71   uword l = 0;
  72   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
  73     {
  74       b = vlib_get_buffer (vm, b->next_buffer);
  75       l += b->current_length;
  76     }
  77   b_first->total_length_not_including_first_buffer = l;
  78   b_first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  79   return l + l_first;
  80 }
  81
  82 u8 *
  83 format_vlib_buffer (u8 * s, va_list * args)
  84 {
  85   vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
  86   u32 indent = format_get_indent (s);
  87   u8 *a = 0;
  88
  89 #define _(bit, name, v) \
  90   if (v && (b->flags & VLIB_BUFFER_##name)) \
  91     a = format (a, "%s ", v);
  92   foreach_vlib_buffer_flag
  93 #undef _
  94     s = format (s, "current data %d, length %d, buffer-pool %d, "
  95                 "ref-count %u", b->current_data, b->current_length,
  96                 b->buffer_pool_index, b->ref_count);
  97
  98   if (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID)
  99     s = format (s, ", totlen-nifb %d",
 100                 b->total_length_not_including_first_buffer);
 101
 102   if (b->flags & VLIB_BUFFER_IS_TRACED)
 103     s = format (s, ", trace 0x%x", b->trace_index);
 104
 105   if (a)
 106     s = format (s, "\n%U%v", format_white_space, indent, a);
 107   vec_free (a);
 108
 109   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 110     {
 111       vlib_main_t *vm = vlib_get_main ();
 112       u32 next_buffer = b->next_buffer;
 113       b = vlib_get_buffer (vm, next_buffer);
 114
 115       s =
 116         format (s, "\n%Unext-buffer 0x%x, segment length %d, ref-count %u",
 117                 format_white_space, indent, next_buffer, b->current_length,
 118                 b->ref_count);
 119     }
 120
 121   return s;
 122 }
 123
 124 u8 *
 125 format_vlib_buffer_and_data (u8 * s, va_list * args)
 126 {
 127   vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
 128
 129   s = format (s, "%U, %U",
 130               format_vlib_buffer, b,
 131               format_hex_bytes, vlib_buffer_get_current (b), 64);
 132
 133   return s;
 134 }
 135
 136 static u8 *
 137 format_vlib_buffer_known_state (u8 * s, va_list * args)
 138 {
 139   vlib_buffer_known_state_t state = va_arg (*args, vlib_buffer_known_state_t);
 140   char *t;
 141
 142   switch (state)
 143     {
 144     case VLIB_BUFFER_UNKNOWN:
 145       t = "unknown";
 146       break;
 147
 148     case VLIB_BUFFER_KNOWN_ALLOCATED:
 149       t = "known-allocated";
 150       break;
 151
 152     case VLIB_BUFFER_KNOWN_FREE:
 153       t = "known-free";
 154       break;
 155
 156     default:
 157       t = "invalid";
 158       break;
 159     }
 160
 161   return format (s, "%s", t);
 162 }
 163
 164 u8 *
 165 format_vlib_buffer_contents (u8 * s, va_list * va)
 166 {
 167   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
 168   vlib_buffer_t *b = va_arg (*va, vlib_buffer_t *);
 169
 170   while (1)
 171     {
 172       vec_add (s, vlib_buffer_get_current (b), b->current_length);
 173       if (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))
 174         break;
 175       b = vlib_get_buffer (vm, b->next_buffer);
 176     }
 177
 178   return s;
 179 }
 180
 181 static u8 *
 182 vlib_validate_buffer_helper (vlib_main_t * vm,
 183                              u32 bi,
 184                              uword follow_buffer_next, uword ** unique_hash)
 185 {
 186   vlib_buffer_main_t *bm = vm->buffer_main;
 187   vlib_buffer_t *b = vlib_get_buffer (vm, bi);
 188
 189   if (vec_len (bm->buffer_pools) <= b->buffer_pool_index)
 190     return format (0, "unknown buffer pool 0x%x", b->buffer_pool_index);
 191
 192   if ((signed) b->current_data < (signed) -VLIB_BUFFER_PRE_DATA_SIZE)
 193     return format (0, "current data %d before pre-data", b->current_data);
 194
 195   if (b->current_data + b->current_length > VLIB_BUFFER_DATA_SIZE)
 196     return format (0, "%d-%d beyond end of buffer %d", b->current_data,
 197                    b->current_length, VLIB_BUFFER_DATA_SIZE);
 198
 199   if (follow_buffer_next && (b->flags & VLIB_BUFFER_NEXT_PRESENT))
 200     {
 201       vlib_buffer_known_state_t k;
 202       u8 *msg, *result;
 203
 204       k = vlib_buffer_is_known (vm, b->next_buffer);
 205       if (k != VLIB_BUFFER_KNOWN_ALLOCATED)
 206         return format (0, "next 0x%x: %U",
 207                        b->next_buffer, format_vlib_buffer_known_state, k);
 208
 209       if (unique_hash)
 210         {
 211           if (hash_get (*unique_hash, b->next_buffer))
 212             return format (0, "duplicate buffer 0x%x", b->next_buffer);
 213
 214           hash_set1 (*unique_hash, b->next_buffer);
 215         }
 216
 217       msg = vlib_validate_buffer (vm, b->next_buffer, follow_buffer_next);
 218       if (msg)
 219         {
 220           result = format (0, "next 0x%x: %v", b->next_buffer, msg);
 221           vec_free (msg);
 222           return result;
 223         }
 224     }
 225
 226   return 0;
 227 }
 228
 229 u8 *
 230 vlib_validate_buffer (vlib_main_t * vm, u32 bi, uword follow_buffer_next)
 231 {
 232   return vlib_validate_buffer_helper (vm, bi, follow_buffer_next,
 233                                       /* unique_hash */ 0);
 234 }
 235
 236 u8 *
 237 vlib_validate_buffers (vlib_main_t * vm,
 238                        u32 * buffers,
 239                        uword next_buffer_stride,
 240                        uword n_buffers,
 241                        vlib_buffer_known_state_t known_state,
 242                        uword follow_buffer_next)
 243 {
 244   uword i, *hash;
 245   u32 bi, *b = buffers;
 246   vlib_buffer_known_state_t k;
 247   u8 *msg = 0, *result = 0;
 248
 249   hash = hash_create (0, 0);
 250   for (i = 0; i < n_buffers; i++)
 251     {
 252       bi = b[0];
 253       b += next_buffer_stride;
 254
 255       /* Buffer is not unique. */
 256       if (hash_get (hash, bi))
 257         {
 258           msg = format (0, "not unique");
 259           goto done;
 260         }
 261
 262       k = vlib_buffer_is_known (vm, bi);
 263       if (k != known_state)
 264         {
 265           msg = format (0, "is %U; expected %U",
 266                         format_vlib_buffer_known_state, k,
 267                         format_vlib_buffer_known_state, known_state);
 268           goto done;
 269         }
 270
 271       msg = vlib_validate_buffer_helper (vm, bi, follow_buffer_next, &hash);
 272       if (msg)
 273         goto done;
 274
 275       hash_set1 (hash, bi);
 276     }
 277
 278 done:
 279   if (msg)
 280     {
 281       result = format (0, "0x%x: %v", bi, msg);
 282       vec_free (msg);
 283     }
 284   hash_free (hash);
 285   return result;
 286 }
 287
 288 /*
 289  * Hand-craft a static vector w/ length 1, so vec_len(vlib_mains) =1
 290  * and vlib_mains[0] = &vlib_global_main from the beginning of time.
 291  *
 292  * The only place which should ever expand vlib_mains is start_workers()
 293  * in threads.c. It knows about the bootstrap vector.
 294  */
 295 /* *INDENT-OFF* */
 296 static struct
 297 {
 298   vec_header_t h;
 299   vlib_main_t *vm;
 300 } __attribute__ ((packed)) __bootstrap_vlib_main_vector
 301   __attribute__ ((aligned (CLIB_CACHE_LINE_BYTES))) =
 302 {
 303   .h.len = 1,
 304   .vm = &vlib_global_main,
 305 };
 306 /* *INDENT-ON* */
 307
 308 vlib_main_t **vlib_mains = &__bootstrap_vlib_main_vector.vm;
 309
 310
 311 /* When dubugging validate that given buffers are either known allocated
 312    or known free. */
 313 void
 314 vlib_buffer_validate_alloc_free (vlib_main_t * vm,
 315                                  u32 * buffers,
 316                                  uword n_buffers,
 317                                  vlib_buffer_known_state_t expected_state)
 318 {
 319   vlib_buffer_main_t *bm = vm->buffer_main;
 320   u32 *b;
 321   uword i, bi, is_free;
 322
 323   if (CLIB_DEBUG == 0)
 324     return;
 325
 326   is_free = expected_state == VLIB_BUFFER_KNOWN_ALLOCATED;
 327   b = buffers;
 328   for (i = 0; i < n_buffers; i++)
 329     {
 330       vlib_buffer_known_state_t known;
 331
 332       bi = b[0];
 333       b += 1;
 334       known = vlib_buffer_is_known (vm, bi);
 335
 336       if (known == VLIB_BUFFER_UNKNOWN &&
 337           expected_state == VLIB_BUFFER_KNOWN_FREE)
 338         known = VLIB_BUFFER_KNOWN_FREE;
 339
 340       if (known != expected_state)
 341         {
 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       clib_spinlock_lock (&bm->buffer_known_hash_lockp);
 349       hash_set (bm->buffer_known_hash, bi, is_free ? VLIB_BUFFER_KNOWN_FREE :
 350                 VLIB_BUFFER_KNOWN_ALLOCATED);
 351       clib_spinlock_unlock (&bm->buffer_known_hash_lockp);
 352     }
 353 }
 354
 355 void
 356 vlib_packet_template_init (vlib_main_t * vm,
 357                            vlib_packet_template_t * t,
 358                            void *packet_data,
 359                            uword n_packet_data_bytes,
 360                            uword min_n_buffers_each_alloc, char *fmt, ...)
 361 {
 362   va_list va;
 363
 364   va_start (va, fmt);
 365   t->name = va_format (0, fmt, &va);
 366   va_end (va);
 367
 368   vlib_worker_thread_barrier_sync (vm);
 369
 370   clib_memset (t, 0, sizeof (t[0]));
 371
 372   vec_add (t->packet_data, packet_data, n_packet_data_bytes);
 373   t->min_n_buffers_each_alloc = min_n_buffers_each_alloc;
 374   vlib_worker_thread_barrier_release (vm);
 375 }
 376
 377 void *
 378 vlib_packet_template_get_packet (vlib_main_t * vm,
 379                                  vlib_packet_template_t * t, u32 * bi_result)
 380 {
 381   u32 bi;
 382   vlib_buffer_t *b;
 383
 384   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
 385     return 0;
 386
 387   *bi_result = bi;
 388
 389   b = vlib_get_buffer (vm, bi);
 390   clib_memcpy_fast (vlib_buffer_get_current (b),
 391                     t->packet_data, vec_len (t->packet_data));
 392   b->current_length = vec_len (t->packet_data);
 393
 394   return b->data;
 395 }
 396
 397 /* Append given data to end of buffer, possibly allocating new buffers. */
 398 int
 399 vlib_buffer_add_data (vlib_main_t * vm, u32 * buffer_index, void *data,
 400                       u32 n_data_bytes)
 401 {
 402   u32 n_buffer_bytes, n_left, n_left_this_buffer, bi;
 403   vlib_buffer_t *b;
 404   void *d;
 405
 406   bi = *buffer_index;
 407   if (bi == ~0 && 1 != vlib_buffer_alloc (vm, &bi, 1))
 408     goto out_of_buffers;
 409
 410   d = data;
 411   n_left = n_data_bytes;
 412   n_buffer_bytes = VLIB_BUFFER_DATA_SIZE;
 413
 414   b = vlib_get_buffer (vm, bi);
 415   b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 416
 417   /* Get to the end of the chain before we try to append data... */
 418   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 419     b = vlib_get_buffer (vm, b->next_buffer);
 420
 421   while (1)
 422     {
 423       u32 n;
 424
 425       ASSERT (n_buffer_bytes >= b->current_length);
 426       n_left_this_buffer =
 427         n_buffer_bytes - (b->current_data + b->current_length);
 428       n = clib_min (n_left_this_buffer, n_left);
 429       clib_memcpy_fast (vlib_buffer_get_current (b) + b->current_length, d,
 430                         n);
 431       b->current_length += n;
 432       n_left -= n;
 433       if (n_left == 0)
 434         break;
 435
 436       d += n;
 437       if (1 != vlib_buffer_alloc (vm, &b->next_buffer, 1))
 438         goto out_of_buffers;
 439
 440       b->flags |= VLIB_BUFFER_NEXT_PRESENT;
 441
 442       b = vlib_get_buffer (vm, b->next_buffer);
 443     }
 444
 445   *buffer_index = bi;
 446   return 0;
 447
 448 out_of_buffers:
 449   clib_warning ("out of buffers");
 450   return 1;
 451 }
 452
 453 u16
 454 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
 455                                           vlib_buffer_t * first,
 456                                           vlib_buffer_t ** last, void *data,
 457                                           u16 data_len)
 458 {
 459   vlib_buffer_t *l = *last;
 460   u32 n_buffer_bytes = VLIB_BUFFER_DATA_SIZE;
 461   u16 copied = 0;
 462   ASSERT (n_buffer_bytes >= l->current_length + l->current_data);
 463   while (data_len)
 464     {
 465       u16 max = n_buffer_bytes - l->current_length - l->current_data;
 466       if (max == 0)
 467         {
 468           if (1 != vlib_buffer_alloc_from_pool (vm, &l->next_buffer, 1,
 469                                                 first->buffer_pool_index))
 470             return copied;
 471           *last = l = vlib_buffer_chain_buffer (vm, l, l->next_buffer);
 472           max = n_buffer_bytes - l->current_length - l->current_data;
 473         }
 474
 475       u16 len = (data_len > max) ? max : data_len;
 476       clib_memcpy_fast (vlib_buffer_get_current (l) + l->current_length,
 477                         data + copied, len);
 478       vlib_buffer_chain_increase_length (first, l, len);
 479       data_len -= len;
 480       copied += len;
 481     }
 482   return copied;
 483 }
 484
 485 clib_error_t *
 486 vlib_buffer_pool_create (vlib_main_t * vm, u8 index, char *name,
 487                          u32 data_size, u32 physmem_map_index)
 488 {
 489   vlib_buffer_main_t *bm = vm->buffer_main;
 490   vlib_buffer_pool_t *bp;
 491   vlib_physmem_map_t *m = vlib_physmem_get_map (vm, physmem_map_index);
 492   uword start = pointer_to_uword (m->base);
 493   uword size = (uword) m->n_pages << m->log2_page_size;
 494   u32 alloc_size, n_alloc_per_page;;
 495
 496   vec_validate_aligned (bm->buffer_pools, index, CLIB_CACHE_LINE_BYTES);
 497   bp = vec_elt_at_index (bm->buffer_pools, index);
 498
 499   if (bp->start)
 500     return clib_error_return (0, "buffer with index %u already exists",
 501                               index);
 502
 503   if (index >= 255)
 504     return clib_error_return (0, "buffer index must be < 255", index);
 505
 506   if (bm->buffer_mem_size == 0)
 507     {
 508       bm->buffer_mem_start = start;
 509       bm->buffer_mem_size = size;
 510     }
 511   else if (start < bm->buffer_mem_start)
 512     {
 513       bm->buffer_mem_size += bm->buffer_mem_start - start;
 514       bm->buffer_mem_start = start;
 515       if (size > bm->buffer_mem_size)
 516         bm->buffer_mem_size = size;
 517     }
 518   else if (start > bm->buffer_mem_start)
 519     {
 520       uword new_size = start - bm->buffer_mem_start + size;
 521       if (new_size > bm->buffer_mem_size)
 522         bm->buffer_mem_size = new_size;
 523     }
 524
 525   if ((u64) bm->buffer_mem_size >
 526       ((u64) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
 527     {
 528       clib_panic ("buffer memory size out of range!");
 529     }
 530
 531   bp->start = start;
 532   bp->size = size;
 533   bp->index = bp - bm->buffer_pools;
 534   bp->buffer_template.buffer_pool_index = bp->index;
 535   bp->buffer_template.ref_count = 1;
 536   bp->physmem_map_index = physmem_map_index;
 537   bp->name = format (0, "%s%c", name, 0);
 538   bp->data_size = data_size;
 539   bp->numa_node = m->numa_node;
 540
 541   vec_validate_aligned (bp->threads, vec_len (vlib_mains) - 1,
 542                         CLIB_CACHE_LINE_BYTES);
 543
 544   alloc_size = data_size + sizeof (vlib_buffer_t) + bm->ext_hdr_size;
 545   n_alloc_per_page = (1ULL << m->log2_page_size) / alloc_size;
 546
 547   /* preallocate buffer indices memory */
 548   vec_validate_aligned (bp->buffers, m->n_pages * n_alloc_per_page,
 549                         CLIB_CACHE_LINE_BYTES);
 550   vec_reset_length (bp->buffers);
 551
 552   clib_spinlock_init (&bp->lock);
 553
 554   while (1)
 555     {
 556       u8 *p;
 557       u32 bi;
 558
 559       p = vlib_physmem_alloc_from_map (vm, bp->physmem_map_index, alloc_size,
 560                                        CLIB_CACHE_LINE_BYTES);
 561
 562       if (p == 0)
 563         break;
 564
 565       p += bm->ext_hdr_size;
 566
 567       vlib_buffer_copy_template ((vlib_buffer_t *) p, &bp->buffer_template);
 568
 569       bi = vlib_get_buffer_index (vm, (vlib_buffer_t *) p);
 570
 571       vec_add1_aligned (bp->buffers, bi, CLIB_CACHE_LINE_BYTES);
 572       vlib_get_buffer (vm, bi);
 573
 574       bp->n_buffers += 1;
 575     }
 576
 577   return 0;
 578 }
 579
 580 static u8 *
 581 format_vlib_buffer_pool (u8 * s, va_list * va)
 582 {
 583   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
 584   vlib_buffer_pool_t *bp = va_arg (*va, vlib_buffer_pool_t *);
 585   vlib_buffer_pool_thread_t *bpt;
 586   u32 cached = 0;
 587
 588   if (!bp)
 589     return format (s, "%-20s%=6s%=6s%=6s%=11s%=6s%=8s%=8s%=8s",
 590                    "Pool Name", "Index", "NUMA", "Size", "Data Size",
 591                    "Total", "Avail", "Cached", "Used");
 592
 593   /* *INDENT-OFF* */
 594   vec_foreach (bpt, bp->threads)
 595     cached += vec_len (bpt->cached_buffers);
 596   /* *INDENT-ON* */
 597
 598   s = format (s, "%-20s%=6d%=6d%=6u%=11u%=6u%=8u%=8u%=8u",
 599               bp->name, bp->index, bp->numa_node, bp->data_size +
 600               sizeof (vlib_buffer_t) + vm->buffer_main->ext_hdr_size,
 601               bp->data_size, bp->n_buffers, vec_len (bp->buffers), cached,
 602               bp->n_buffers - vec_len (bp->buffers) - cached);
 603
 604   return s;
 605 }
 606
 607 static clib_error_t *
 608 show_buffers (vlib_main_t * vm,
 609               unformat_input_t * input, vlib_cli_command_t * cmd)
 610 {
 611   vlib_buffer_main_t *bm = vm->buffer_main;
 612   vlib_buffer_pool_t *bp;
 613
 614   vlib_cli_output (vm, "%U", format_vlib_buffer_pool, vm, 0);
 615
 616   /* *INDENT-OFF* */
 617   vec_foreach (bp, bm->buffer_pools)
 618     vlib_cli_output (vm, "%U", format_vlib_buffer_pool, vm, bp);
 619   /* *INDENT-ON* */
 620
 621   return 0;
 622 }
 623
 624 /* *INDENT-OFF* */
 625 VLIB_CLI_COMMAND (show_buffers_command, static) = {
 626   .path = "show buffers",
 627   .short_help = "Show packet buffer allocation",
 628   .function = show_buffers,
 629 };
 630 /* *INDENT-ON* */
 631
 632 clib_error_t *
 633 vlib_buffer_worker_init (vlib_main_t * vm)
 634 {
 635   vlib_buffer_main_t *bm = vm->buffer_main;
 636   vlib_buffer_pool_t *bp;
 637
 638   /* *INDENT-OFF* */
 639   vec_foreach (bp, bm->buffer_pools)
 640     {
 641       clib_spinlock_lock (&bp->lock);
 642       vec_validate_aligned (bp->threads, vec_len (vlib_mains) - 1,
 643                             CLIB_CACHE_LINE_BYTES);
 644       clib_spinlock_unlock (&bp->lock);
 645     }
 646   /* *INDENT-ON* */
 647
 648   return 0;
 649 }
 650
 651 VLIB_WORKER_INIT_FUNCTION (vlib_buffer_worker_init);
 652
 653 static clib_error_t *
 654 vlib_buffer_main_init_numa_node (struct vlib_main_t *vm, u32 numa_node)
 655 {
 656   vlib_buffer_main_t *bm = vm->buffer_main;
 657   clib_error_t *error;
 658   u32 physmem_map_index;
 659   uword n_pages, pagesize;
 660   u32 buffers_per_numa;
 661   u32 buffer_size = CLIB_CACHE_LINE_ROUND (bm->ext_hdr_size +
 662                                            sizeof (vlib_buffer_t) +
 663                                            VLIB_BUFFER_DATA_SIZE);
 664   u8 *name;
 665
 666   pagesize = clib_mem_get_default_hugepage_size ();
 667   name = format (0, "buffers-numa-%d%c", numa_node, 0);
 668
 669   buffers_per_numa = bm->buffers_per_numa ? bm->buffers_per_numa :
 670     VLIB_BUFFER_DEFAULT_BUFFERS_PER_NUMA;
 671
 672 retry:
 673   n_pages = (buffers_per_numa - 1) / (pagesize / buffer_size) + 1;
 674   error = vlib_physmem_shared_map_create (vm, (char *) name,
 675                                           n_pages * pagesize,
 676                                           min_log2 (pagesize), numa_node,
 677                                           &physmem_map_index);
 678
 679   if (error && pagesize != clib_mem_get_page_size ())
 680     {
 681       vlib_log_warn (bm->log_default, "%U", format_clib_error, error);
 682       clib_error_free (error);
 683       vlib_log_warn (bm->log_default, "falling back to non-hugepage "
 684                      "backed buffer pool");
 685       pagesize = clib_mem_get_page_size ();
 686       buffers_per_numa = bm->buffers_per_numa ? bm->buffers_per_numa :
 687         VLIB_BUFFER_DEFAULT_BUFFERS_PER_NUMA_UNPRIV;
 688       goto retry;
 689     }
 690
 691   if (error)
 692     return error;
 693
 694   vec_reset_length (name);
 695   name = format (name, "default-numa-%d%c", numa_node, 0);
 696
 697   return vlib_buffer_pool_create (vm, numa_node, (char *) name,
 698                                   VLIB_BUFFER_DATA_SIZE, physmem_map_index);
 699 }
 700
 701 clib_error_t *
 702 vlib_buffer_main_init (struct vlib_main_t *vm)
 703 {
 704   vlib_buffer_main_t *bm;
 705   clib_error_t *err;
 706   clib_bitmap_t *bmp = 0;
 707   u32 numa_node;
 708
 709   if (vm->buffer_main == 0)
 710     {
 711       vm->buffer_main = clib_mem_alloc (sizeof (bm[0]));
 712       clib_memset (vm->buffer_main, 0, sizeof (bm[0]));
 713     }
 714
 715   bm = vm->buffer_main;
 716   bm->log_default = vlib_log_register_class ("buffer", 0);
 717   bm->ext_hdr_size = __vlib_buffer_external_hdr_size;
 718
 719   clib_spinlock_init (&bm->buffer_known_hash_lockp);
 720
 721   err = clib_sysfs_read ("/sys/devices/system/node/possible", "%U",
 722                          unformat_bitmap_list, &bmp);
 723   if (err)
 724     {
 725       /* no info from sysfs, assuming that only numa 0 exists */
 726       clib_error_free (err);
 727       bmp = clib_bitmap_set (bmp, 0, 1);
 728     }
 729
 730   /* *INDENT-OFF* */
 731   clib_bitmap_foreach (numa_node, bmp, {
 732       if ((err = vlib_buffer_main_init_numa_node(vm, numa_node)))
 733           goto done;
 734     });
 735   /* *INDENT-ON* */
 736
 737   bm->n_numa_nodes = clib_bitmap_last_set (bmp) + 1;
 738
 739 done:
 740   vec_free (bmp);
 741   return err;
 742 }
 743
 744 static clib_error_t *
 745 vlib_buffers_configure (vlib_main_t * vm, unformat_input_t * input)
 746 {
 747   vlib_buffer_main_t *bm;
 748
 749   if (vm->buffer_main == 0)
 750     {
 751       vm->buffer_main = clib_mem_alloc (sizeof (bm[0]));
 752       clib_memset (vm->buffer_main, 0, sizeof (bm[0]));
 753     }
 754
 755   bm = vm->buffer_main;
 756
 757   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 758     {
 759       if (unformat (input, "buffers-per-numa %u", &bm->buffers_per_numa))
 760         ;
 761       else
 762         return unformat_parse_error (input);
 763     }
 764
 765   unformat_free (input);
 766   return 0;
 767 }
 768
 769 VLIB_EARLY_CONFIG_FUNCTION (vlib_buffers_configure, "buffers");
 770
 771
 772 /** @endcond */
 773 /*
 774  * fd.io coding-style-patch-verification: ON
 775  *
 776  * Local Variables:
 777  * eval: (c-set-style "gnu")
 778  * End:
 779  */