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           clib_panic ("%s %U buffer 0x%x", is_free ? "freeing" : "allocating",
 343                       format_vlib_buffer_known_state, known, bi);
 344         }
 345
 346       clib_spinlock_lock (&bm->buffer_known_hash_lockp);
 347       hash_set (bm->buffer_known_hash, bi, is_free ? VLIB_BUFFER_KNOWN_FREE :
 348                 VLIB_BUFFER_KNOWN_ALLOCATED);
 349       clib_spinlock_unlock (&bm->buffer_known_hash_lockp);
 350     }
 351 }
 352
 353 void
 354 vlib_packet_template_init (vlib_main_t * vm,
 355                            vlib_packet_template_t * t,
 356                            void *packet_data,
 357                            uword n_packet_data_bytes,
 358                            uword min_n_buffers_each_alloc, char *fmt, ...)
 359 {
 360   va_list va;
 361
 362   va_start (va, fmt);
 363   t->name = va_format (0, fmt, &va);
 364   va_end (va);
 365
 366   vlib_worker_thread_barrier_sync (vm);
 367
 368   clib_memset (t, 0, sizeof (t[0]));
 369
 370   vec_add (t->packet_data, packet_data, n_packet_data_bytes);
 371   t->min_n_buffers_each_alloc = min_n_buffers_each_alloc;
 372   vlib_worker_thread_barrier_release (vm);
 373 }
 374
 375 void *
 376 vlib_packet_template_get_packet (vlib_main_t * vm,
 377                                  vlib_packet_template_t * t, u32 * bi_result)
 378 {
 379   u32 bi;
 380   vlib_buffer_t *b;
 381
 382   if (vlib_buffer_alloc (vm, &bi, 1) != 1)
 383     return 0;
 384
 385   *bi_result = bi;
 386
 387   b = vlib_get_buffer (vm, bi);
 388   clib_memcpy_fast (vlib_buffer_get_current (b),
 389                     t->packet_data, vec_len (t->packet_data));
 390   b->current_length = vec_len (t->packet_data);
 391
 392   return b->data;
 393 }
 394
 395 /* Append given data to end of buffer, possibly allocating new buffers. */
 396 int
 397 vlib_buffer_add_data (vlib_main_t * vm, u32 * buffer_index, void *data,
 398                       u32 n_data_bytes)
 399 {
 400   u32 n_buffer_bytes, n_left, n_left_this_buffer, bi;
 401   vlib_buffer_t *b;
 402   void *d;
 403
 404   bi = *buffer_index;
 405   if (bi == ~0 && 1 != vlib_buffer_alloc (vm, &bi, 1))
 406     goto out_of_buffers;
 407
 408   d = data;
 409   n_left = n_data_bytes;
 410   n_buffer_bytes = VLIB_BUFFER_DATA_SIZE;
 411
 412   b = vlib_get_buffer (vm, bi);
 413   b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 414
 415   /* Get to the end of the chain before we try to append data... */
 416   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 417     b = vlib_get_buffer (vm, b->next_buffer);
 418
 419   while (1)
 420     {
 421       u32 n;
 422
 423       ASSERT (n_buffer_bytes >= b->current_length);
 424       n_left_this_buffer =
 425         n_buffer_bytes - (b->current_data + b->current_length);
 426       n = clib_min (n_left_this_buffer, n_left);
 427       clib_memcpy_fast (vlib_buffer_get_current (b) + b->current_length, d,
 428                         n);
 429       b->current_length += n;
 430       n_left -= n;
 431       if (n_left == 0)
 432         break;
 433
 434       d += n;
 435       if (1 != vlib_buffer_alloc (vm, &b->next_buffer, 1))
 436         goto out_of_buffers;
 437
 438       b->flags |= VLIB_BUFFER_NEXT_PRESENT;
 439
 440       b = vlib_get_buffer (vm, b->next_buffer);
 441     }
 442
 443   *buffer_index = bi;
 444   return 0;
 445
 446 out_of_buffers:
 447   clib_warning ("out of buffers");
 448   return 1;
 449 }
 450
 451 u16
 452 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
 453                                           vlib_buffer_t * first,
 454                                           vlib_buffer_t ** last, void *data,
 455                                           u16 data_len)
 456 {
 457   vlib_buffer_t *l = *last;
 458   u32 n_buffer_bytes = VLIB_BUFFER_DATA_SIZE;
 459   u16 copied = 0;
 460   ASSERT (n_buffer_bytes >= l->current_length + l->current_data);
 461   while (data_len)
 462     {
 463       u16 max = n_buffer_bytes - l->current_length - l->current_data;
 464       if (max == 0)
 465         {
 466           if (1 != vlib_buffer_alloc_from_pool (vm, &l->next_buffer, 1,
 467                                                 first->buffer_pool_index))
 468             return copied;
 469           *last = l = vlib_buffer_chain_buffer (vm, l, l->next_buffer);
 470           max = n_buffer_bytes - l->current_length - l->current_data;
 471         }
 472
 473       u16 len = (data_len > max) ? max : data_len;
 474       clib_memcpy_fast (vlib_buffer_get_current (l) + l->current_length,
 475                         data + copied, len);
 476       vlib_buffer_chain_increase_length (first, l, len);
 477       data_len -= len;
 478       copied += len;
 479     }
 480   return copied;
 481 }
 482
 483 clib_error_t *
 484 vlib_buffer_pool_create (vlib_main_t * vm, u8 index, char *name,
 485                          u32 data_size, u32 physmem_map_index)
 486 {
 487   vlib_buffer_main_t *bm = vm->buffer_main;
 488   vlib_buffer_pool_t *bp;
 489   vlib_physmem_map_t *m = vlib_physmem_get_map (vm, physmem_map_index);
 490   uword start = pointer_to_uword (m->base);
 491   uword size = (uword) m->n_pages << m->log2_page_size;
 492   u32 alloc_size, n_alloc_per_page;;
 493
 494   vec_validate_aligned (bm->buffer_pools, index, CLIB_CACHE_LINE_BYTES);
 495   bp = vec_elt_at_index (bm->buffer_pools, index);
 496
 497   if (bp->start)
 498     return clib_error_return (0, "buffer with index %u already exists",
 499                               index);
 500
 501   if (index >= 255)
 502     return clib_error_return (0, "buffer index must be < 255", index);
 503
 504   if (bm->buffer_mem_size == 0)
 505     {
 506       bm->buffer_mem_start = start;
 507       bm->buffer_mem_size = size;
 508     }
 509   else if (start < bm->buffer_mem_start)
 510     {
 511       bm->buffer_mem_size += bm->buffer_mem_start - start;
 512       bm->buffer_mem_start = start;
 513       if (size > bm->buffer_mem_size)
 514         bm->buffer_mem_size = size;
 515     }
 516   else if (start > bm->buffer_mem_start)
 517     {
 518       uword new_size = start - bm->buffer_mem_start + size;
 519       if (new_size > bm->buffer_mem_size)
 520         bm->buffer_mem_size = new_size;
 521     }
 522
 523   if ((u64) bm->buffer_mem_size >
 524       ((u64) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
 525     {
 526       clib_panic ("buffer memory size out of range!");
 527     }
 528
 529   bp->start = start;
 530   bp->size = size;
 531   bp->index = bp - bm->buffer_pools;
 532   bp->buffer_template.buffer_pool_index = bp->index;
 533   bp->buffer_template.ref_count = 1;
 534   bp->physmem_map_index = physmem_map_index;
 535   bp->name = format (0, "%s%c", name, 0);
 536   bp->data_size = data_size;
 537   bp->numa_node = m->numa_node;
 538
 539   vec_validate_aligned (bp->threads, vec_len (vlib_mains) - 1,
 540                         CLIB_CACHE_LINE_BYTES);
 541
 542   alloc_size = data_size + sizeof (vlib_buffer_t) + bm->ext_hdr_size;
 543   n_alloc_per_page = (1ULL << m->log2_page_size) / alloc_size;
 544
 545   /* preallocate buffer indices memory */
 546   vec_validate_aligned (bp->buffers, m->n_pages * n_alloc_per_page,
 547                         CLIB_CACHE_LINE_BYTES);
 548   vec_reset_length (bp->buffers);
 549
 550   clib_spinlock_init (&bp->lock);
 551
 552   while (1)
 553     {
 554       u8 *p;
 555       u32 bi;
 556
 557       p = vlib_physmem_alloc_from_map (vm, bp->physmem_map_index, alloc_size,
 558                                        CLIB_CACHE_LINE_BYTES);
 559
 560       if (p == 0)
 561         break;
 562
 563       p += bm->ext_hdr_size;
 564
 565       vlib_buffer_copy_template ((vlib_buffer_t *) p, &bp->buffer_template);
 566
 567       bi = vlib_get_buffer_index (vm, (vlib_buffer_t *) p);
 568
 569       vec_add1_aligned (bp->buffers, bi, CLIB_CACHE_LINE_BYTES);
 570       vlib_get_buffer (vm, bi);
 571
 572       bp->n_buffers += 1;
 573     }
 574
 575   return 0;
 576 }
 577
 578 static u8 *
 579 format_vlib_buffer_pool (u8 * s, va_list * va)
 580 {
 581   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
 582   vlib_buffer_pool_t *bp = va_arg (*va, vlib_buffer_pool_t *);
 583   vlib_buffer_pool_thread_t *bpt;
 584   u32 cached = 0;
 585
 586   if (!bp)
 587     return format (s, "%-20s%=6s%=6s%=6s%=11s%=6s%=8s%=8s%=8s",
 588                    "Pool Name", "Index", "NUMA", "Size", "Data Size",
 589                    "Total", "Avail", "Cached", "Used");
 590
 591   /* *INDENT-OFF* */
 592   vec_foreach (bpt, bp->threads)
 593     cached += vec_len (bpt->cached_buffers);
 594   /* *INDENT-ON* */
 595
 596   s = format (s, "%-20s%=6d%=6d%=6u%=11u%=6u%=8u%=8u%=8u",
 597               bp->name, bp->index, bp->numa_node, bp->data_size +
 598               sizeof (vlib_buffer_t) + vm->buffer_main->ext_hdr_size,
 599               bp->data_size, bp->n_buffers, vec_len (bp->buffers), cached,
 600               bp->n_buffers - vec_len (bp->buffers) - cached);
 601
 602   return s;
 603 }
 604
 605 static clib_error_t *
 606 show_buffers (vlib_main_t * vm,
 607               unformat_input_t * input, vlib_cli_command_t * cmd)
 608 {
 609   vlib_buffer_main_t *bm = vm->buffer_main;
 610   vlib_buffer_pool_t *bp;
 611
 612   vlib_cli_output (vm, "%U", format_vlib_buffer_pool, vm, 0);
 613
 614   /* *INDENT-OFF* */
 615   vec_foreach (bp, bm->buffer_pools)
 616     vlib_cli_output (vm, "%U", format_vlib_buffer_pool, vm, bp);
 617   /* *INDENT-ON* */
 618
 619   return 0;
 620 }
 621
 622 /* *INDENT-OFF* */
 623 VLIB_CLI_COMMAND (show_buffers_command, static) = {
 624   .path = "show buffers",
 625   .short_help = "Show packet buffer allocation",
 626   .function = show_buffers,
 627 };
 628 /* *INDENT-ON* */
 629
 630 clib_error_t *
 631 vlib_buffer_worker_init (vlib_main_t * vm)
 632 {
 633   vlib_buffer_main_t *bm = vm->buffer_main;
 634   vlib_buffer_pool_t *bp;
 635
 636   /* *INDENT-OFF* */
 637   vec_foreach (bp, bm->buffer_pools)
 638     {
 639       clib_spinlock_lock (&bp->lock);
 640       vec_validate_aligned (bp->threads, vec_len (vlib_mains) - 1,
 641                             CLIB_CACHE_LINE_BYTES);
 642       clib_spinlock_unlock (&bp->lock);
 643     }
 644   /* *INDENT-ON* */
 645
 646   return 0;
 647 }
 648
 649 VLIB_WORKER_INIT_FUNCTION (vlib_buffer_worker_init);
 650
 651 static clib_error_t *
 652 vlib_buffer_main_init_numa_node (struct vlib_main_t *vm, u32 numa_node)
 653 {
 654   vlib_buffer_main_t *bm = vm->buffer_main;
 655   clib_error_t *error;
 656   u32 physmem_map_index;
 657   uword n_pages, pagesize;
 658   u32 buffers_per_numa;
 659   u32 buffer_size = CLIB_CACHE_LINE_ROUND (bm->ext_hdr_size +
 660                                            sizeof (vlib_buffer_t) +
 661                                            VLIB_BUFFER_DATA_SIZE);
 662   u8 *name;
 663
 664   pagesize = clib_mem_get_default_hugepage_size ();
 665   name = format (0, "buffers-numa-%d%c", numa_node, 0);
 666
 667   buffers_per_numa = bm->buffers_per_numa ? bm->buffers_per_numa :
 668     VLIB_BUFFER_DEFAULT_BUFFERS_PER_NUMA;
 669
 670 retry:
 671   n_pages = (buffers_per_numa - 1) / (pagesize / buffer_size) + 1;
 672   error = vlib_physmem_shared_map_create (vm, (char *) name,
 673                                           n_pages * pagesize,
 674                                           min_log2 (pagesize), numa_node,
 675                                           &physmem_map_index);
 676
 677   if (error && pagesize != clib_mem_get_page_size ())
 678     {
 679       vlib_log_warn (bm->log_default, "%U", format_clib_error, error);
 680       clib_error_free (error);
 681       vlib_log_warn (bm->log_default, "falling back to non-hugepage "
 682                      "backed buffer pool");
 683       pagesize = clib_mem_get_page_size ();
 684       buffers_per_numa = bm->buffers_per_numa ? bm->buffers_per_numa :
 685         VLIB_BUFFER_DEFAULT_BUFFERS_PER_NUMA_UNPRIV;
 686       goto retry;
 687     }
 688
 689   if (error)
 690     return error;
 691
 692   vec_reset_length (name);
 693   name = format (name, "default-numa-%d%c", numa_node, 0);
 694
 695   return vlib_buffer_pool_create (vm, numa_node, (char *) name,
 696                                   VLIB_BUFFER_DATA_SIZE, physmem_map_index);
 697 }
 698
 699 clib_error_t *
 700 vlib_buffer_main_init (struct vlib_main_t *vm)
 701 {
 702   vlib_buffer_main_t *bm;
 703   clib_error_t *err;
 704   clib_bitmap_t *bmp = 0;
 705   u32 numa_node;
 706
 707   if (vm->buffer_main == 0)
 708     {
 709       vm->buffer_main = clib_mem_alloc (sizeof (bm[0]));
 710       clib_memset (vm->buffer_main, 0, sizeof (bm[0]));
 711     }
 712
 713   bm = vm->buffer_main;
 714   bm->log_default = vlib_log_register_class ("buffer", 0);
 715   bm->ext_hdr_size = __vlib_buffer_external_hdr_size;
 716
 717   clib_spinlock_init (&bm->buffer_known_hash_lockp);
 718
 719   err = clib_sysfs_read ("/sys/devices/system/node/possible", "%U",
 720                          unformat_bitmap_list, &bmp);
 721   if (err)
 722     {
 723       /* no info from sysfs, assuming that only numa 0 exists */
 724       clib_error_free (err);
 725       bmp = clib_bitmap_set (bmp, 0, 1);
 726     }
 727
 728   /* *INDENT-OFF* */
 729   clib_bitmap_foreach (numa_node, bmp, {
 730       if ((err = vlib_buffer_main_init_numa_node(vm, numa_node)))
 731           goto done;
 732     });
 733   /* *INDENT-ON* */
 734
 735   bm->n_numa_nodes = clib_bitmap_last_set (bmp) + 1;
 736
 737 done:
 738   vec_free (bmp);
 739   return err;
 740 }
 741
 742 static clib_error_t *
 743 vlib_buffers_configure (vlib_main_t * vm, unformat_input_t * input)
 744 {
 745   vlib_buffer_main_t *bm;
 746
 747   if (vm->buffer_main == 0)
 748     {
 749       vm->buffer_main = clib_mem_alloc (sizeof (bm[0]));
 750       clib_memset (vm->buffer_main, 0, sizeof (bm[0]));
 751     }
 752
 753   bm = vm->buffer_main;
 754
 755   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 756     {
 757       if (unformat (input, "buffers-per-numa %u", &bm->buffers_per_numa))
 758         ;
 759       else
 760         return unformat_parse_error (input);
 761     }
 762
 763   unformat_free (input);
 764   return 0;
 765 }
 766
 767 VLIB_EARLY_CONFIG_FUNCTION (vlib_buffers_configure, "buffers");
 768
 769
 770 /** @endcond */
 771 /*
 772  * fd.io coding-style-patch-verification: ON
 773  *
 774  * Local Variables:
 775  * eval: (c-set-style "gnu")
 776  * End:
 777  */