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_bufer_get_default_size (vm))
 196     return format (0, "%d-%d beyond end of buffer %d", b->current_data,
 197                    b->current_length, vlib_bufer_get_default_size (vm));
 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_bufer_get_default_size (vm);
 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_bufer_get_default_size (vm);
 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   uword i, j;
 493   u32 alloc_size, n_alloc_per_page;;
 494
 495   vec_validate_aligned (bm->buffer_pools, index, CLIB_CACHE_LINE_BYTES);
 496   bp = vec_elt_at_index (bm->buffer_pools, index);
 497
 498   if (bp->start)
 499     return clib_error_return (0, "buffer with index %u already exists",
 500                               index);
 501
 502   if (index >= 255)
 503     return clib_error_return (0, "buffer index must be < 255", index);
 504
 505   if (bm->buffer_mem_size == 0)
 506     {
 507       bm->buffer_mem_start = start;
 508       bm->buffer_mem_size = size;
 509     }
 510   else if (start < bm->buffer_mem_start)
 511     {
 512       bm->buffer_mem_size += bm->buffer_mem_start - start;
 513       bm->buffer_mem_start = start;
 514       if (size > bm->buffer_mem_size)
 515         bm->buffer_mem_size = size;
 516     }
 517   else if (start > bm->buffer_mem_start)
 518     {
 519       uword new_size = start - bm->buffer_mem_start + size;
 520       if (new_size > bm->buffer_mem_size)
 521         bm->buffer_mem_size = new_size;
 522     }
 523
 524   if ((u64) bm->buffer_mem_size >
 525       ((u64) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
 526     {
 527       clib_panic ("buffer memory size out of range!");
 528     }
 529
 530   bp->start = start;
 531   bp->size = size;
 532   bp->index = bp - bm->buffer_pools;
 533   bp->buffer_template.buffer_pool_index = bp->index;
 534   bp->buffer_template.ref_count = 1;
 535   bp->physmem_map_index = physmem_map_index;
 536   bp->name = format (0, "%s%c", name, 0);
 537   bp->data_size = data_size;
 538   bp->numa_node = m->numa_node;
 539
 540   vec_validate_aligned (bp->threads, vec_len (vlib_mains) - 1,
 541                         CLIB_CACHE_LINE_BYTES);
 542
 543   alloc_size = data_size + sizeof (vlib_buffer_t) + bm->ext_hdr_size;
 544   n_alloc_per_page = (1ULL << m->log2_page_size) / alloc_size;
 545
 546   /* preallocate buffer indices memory */
 547   vec_validate_aligned (bp->buffers, m->n_pages * n_alloc_per_page,
 548                         CLIB_CACHE_LINE_BYTES);
 549   vec_reset_length (bp->buffers);
 550
 551   clib_spinlock_init (&bp->lock);
 552
 553   for (j = 0; j < m->n_pages; j++)
 554     for (i = 0; i < n_alloc_per_page; i++)
 555       {
 556         u8 *p;
 557         u32 bi;
 558
 559         p = m->base + (j << m->log2_page_size) + i * alloc_size;
 560         p += bm->ext_hdr_size;
 561
 562         vlib_buffer_copy_template ((vlib_buffer_t *) p, &bp->buffer_template);
 563
 564         bi = vlib_get_buffer_index (vm, (vlib_buffer_t *) p);
 565
 566         vec_add1_aligned (bp->buffers, bi, CLIB_CACHE_LINE_BYTES);
 567         vlib_get_buffer (vm, bi);
 568       }
 569
 570   bp->n_buffers = vec_len (bp->buffers);
 571
 572   return 0;
 573 }
 574
 575 static u8 *
 576 format_vlib_buffer_pool (u8 * s, va_list * va)
 577 {
 578   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
 579   vlib_buffer_pool_t *bp = va_arg (*va, vlib_buffer_pool_t *);
 580   vlib_buffer_pool_thread_t *bpt;
 581   u32 cached = 0;
 582
 583   if (!bp)
 584     return format (s, "%-20s%=6s%=6s%=6s%=11s%=6s%=8s%=8s%=8s",
 585                    "Pool Name", "Index", "NUMA", "Size", "Data Size",
 586                    "Total", "Avail", "Cached", "Used");
 587
 588   /* *INDENT-OFF* */
 589   vec_foreach (bpt, bp->threads)
 590     cached += vec_len (bpt->cached_buffers);
 591   /* *INDENT-ON* */
 592
 593   s = format (s, "%-20s%=6d%=6d%=6u%=11u%=6u%=8u%=8u%=8u",
 594               bp->name, bp->index, bp->numa_node, bp->data_size +
 595               sizeof (vlib_buffer_t) + vm->buffer_main->ext_hdr_size,
 596               bp->data_size, bp->n_buffers, vec_len (bp->buffers), cached,
 597               bp->n_buffers - vec_len (bp->buffers) - cached);
 598
 599   return s;
 600 }
 601
 602 static clib_error_t *
 603 show_buffers (vlib_main_t * vm,
 604               unformat_input_t * input, vlib_cli_command_t * cmd)
 605 {
 606   vlib_buffer_main_t *bm = vm->buffer_main;
 607   vlib_buffer_pool_t *bp;
 608
 609   vlib_cli_output (vm, "%U", format_vlib_buffer_pool, vm, 0);
 610
 611   /* *INDENT-OFF* */
 612   vec_foreach (bp, bm->buffer_pools)
 613     vlib_cli_output (vm, "%U", format_vlib_buffer_pool, vm, bp);
 614   /* *INDENT-ON* */
 615
 616   return 0;
 617 }
 618
 619 /* *INDENT-OFF* */
 620 VLIB_CLI_COMMAND (show_buffers_command, static) = {
 621   .path = "show buffers",
 622   .short_help = "Show packet buffer allocation",
 623   .function = show_buffers,
 624 };
 625 /* *INDENT-ON* */
 626
 627 clib_error_t *
 628 vlib_buffer_worker_init (vlib_main_t * vm)
 629 {
 630   vlib_buffer_main_t *bm = vm->buffer_main;
 631   vlib_buffer_pool_t *bp;
 632
 633   /* *INDENT-OFF* */
 634   vec_foreach (bp, bm->buffer_pools)
 635     {
 636       clib_spinlock_lock (&bp->lock);
 637       vec_validate_aligned (bp->threads, vec_len (vlib_mains) - 1,
 638                             CLIB_CACHE_LINE_BYTES);
 639       clib_spinlock_unlock (&bp->lock);
 640     }
 641   /* *INDENT-ON* */
 642
 643   return 0;
 644 }
 645
 646 VLIB_WORKER_INIT_FUNCTION (vlib_buffer_worker_init);
 647
 648 static clib_error_t *
 649 vlib_buffer_main_init_numa_node (struct vlib_main_t *vm, u32 numa_node)
 650 {
 651   vlib_buffer_main_t *bm = vm->buffer_main;
 652   clib_error_t *error;
 653   u32 physmem_map_index;
 654   uword n_pages, pagesize;
 655   u32 buffers_per_numa;
 656   u32 buffer_size = CLIB_CACHE_LINE_ROUND (bm->ext_hdr_size +
 657                                            sizeof (vlib_buffer_t) +
 658                                            vlib_bufer_get_default_size (vm));
 659   u8 *name;
 660
 661   pagesize = clib_mem_get_default_hugepage_size ();
 662   name = format (0, "buffers-numa-%d%c", numa_node, 0);
 663
 664   buffers_per_numa = bm->buffers_per_numa ? bm->buffers_per_numa :
 665     VLIB_BUFFER_DEFAULT_BUFFERS_PER_NUMA;
 666
 667 retry:
 668   n_pages = (buffers_per_numa - 1) / (pagesize / buffer_size) + 1;
 669   error = vlib_physmem_shared_map_create (vm, (char *) name,
 670                                           n_pages * pagesize,
 671                                           min_log2 (pagesize), numa_node,
 672                                           &physmem_map_index);
 673
 674   if (error && pagesize != clib_mem_get_page_size ())
 675     {
 676       vlib_log_warn (bm->log_default, "%U", format_clib_error, error);
 677       clib_error_free (error);
 678       vlib_log_warn (bm->log_default, "falling back to non-hugepage "
 679                      "backed buffer pool");
 680       pagesize = clib_mem_get_page_size ();
 681       buffers_per_numa = bm->buffers_per_numa ? bm->buffers_per_numa :
 682         VLIB_BUFFER_DEFAULT_BUFFERS_PER_NUMA_UNPRIV;
 683       goto retry;
 684     }
 685
 686   if (error)
 687     return error;
 688
 689   vec_reset_length (name);
 690   name = format (name, "default-numa-%d%c", numa_node, 0);
 691
 692   return vlib_buffer_pool_create (vm, numa_node, (char *) name,
 693                                   vlib_bufer_get_default_size (vm),
 694                                   physmem_map_index);
 695 }
 696
 697 void
 698 vlib_buffer_main_alloc (vlib_main_t * vm)
 699 {
 700   vlib_buffer_main_t *bm;
 701
 702   if (vm->buffer_main)
 703     return;
 704
 705   vm->buffer_main = bm = clib_mem_alloc (sizeof (bm[0]));
 706   clib_memset (vm->buffer_main, 0, sizeof (bm[0]));
 707   bm->default_data_size = VLIB_BUFFER_DEFAULT_DATA_SIZE;
 708 }
 709
 710 clib_error_t *
 711 vlib_buffer_main_init (struct vlib_main_t *vm)
 712 {
 713   vlib_buffer_main_t *bm;
 714   clib_error_t *err;
 715   clib_bitmap_t *bmp = 0;
 716   u32 numa_node;
 717
 718   vlib_buffer_main_alloc (vm);
 719
 720   bm = vm->buffer_main;
 721   bm->log_default = vlib_log_register_class ("buffer", 0);
 722   bm->ext_hdr_size = __vlib_buffer_external_hdr_size;
 723
 724   clib_spinlock_init (&bm->buffer_known_hash_lockp);
 725
 726   err = clib_sysfs_read ("/sys/devices/system/node/possible", "%U",
 727                          unformat_bitmap_list, &bmp);
 728   if (err)
 729     {
 730       /* no info from sysfs, assuming that only numa 0 exists */
 731       clib_error_free (err);
 732       bmp = clib_bitmap_set (bmp, 0, 1);
 733     }
 734
 735   /* *INDENT-OFF* */
 736   clib_bitmap_foreach (numa_node, bmp, {
 737       if ((err = vlib_buffer_main_init_numa_node(vm, numa_node)))
 738           goto done;
 739     });
 740   /* *INDENT-ON* */
 741
 742   bm->n_numa_nodes = clib_bitmap_last_set (bmp) + 1;
 743
 744 done:
 745   vec_free (bmp);
 746   return err;
 747 }
 748
 749 static clib_error_t *
 750 vlib_buffers_configure (vlib_main_t * vm, unformat_input_t * input)
 751 {
 752   vlib_buffer_main_t *bm;
 753
 754   vlib_buffer_main_alloc (vm);
 755
 756   bm = vm->buffer_main;
 757
 758   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 759     {
 760       if (unformat (input, "buffers-per-numa %u", &bm->buffers_per_numa))
 761         ;
 762       else if (unformat (input, "default data-size %u",
 763                          &bm->default_data_size))
 764         ;
 765       else
 766         return unformat_parse_error (input);
 767     }
 768
 769   unformat_free (input);
 770   return 0;
 771 }
 772
 773 VLIB_EARLY_CONFIG_FUNCTION (vlib_buffers_configure, "buffers");
 774
 775
 776 /** @endcond */
 777 /*
 778  * fd.io coding-style-patch-verification: ON
 779  *
 780  * Local Variables:
 781  * eval: (c-set-style "gnu")
 782  * End:
 783  */