src/vlib/buffer_funcs.h

   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_funcs.h: VLIB buffer related functions/inlines
  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 #ifndef included_vlib_buffer_funcs_h
  41 #define included_vlib_buffer_funcs_h
  42
  43 #include <vppinfra/hash.h>
  44 #include <vppinfra/fifo.h>
  45 #include <vlib/buffer.h>
  46 #include <vlib/physmem_funcs.h>
  47 #include <vlib/main.h>
  48 #include <vlib/node.h>
  49
  50 /** \file
  51     vlib buffer access methods.
  52 */
  53
  54 always_inline void
  55 vlib_buffer_validate (vlib_main_t * vm, vlib_buffer_t * b)
  56 {
  57   vlib_buffer_main_t *bm = vm->buffer_main;
  58   vlib_buffer_pool_t *bp;
  59
  60   /* reference count in allocated buffer always must be 1 or higher */
  61   ASSERT (b->ref_count > 0);
  62
  63   /* verify that buffer pool index is valid */
  64   bp = vec_elt_at_index (bm->buffer_pools, b->buffer_pool_index);
  65   ASSERT (pointer_to_uword (b) >= bp->start);
  66   ASSERT (pointer_to_uword (b) < bp->start + bp->size -
  67           (bp->data_size + sizeof (vlib_buffer_t)));
  68 }
  69
  70 always_inline void *
  71 vlib_buffer_ptr_from_index (uword buffer_mem_start, u32 buffer_index,
  72                             uword offset)
  73 {
  74   offset += ((uword) buffer_index) << CLIB_LOG2_CACHE_LINE_BYTES;
  75   return uword_to_pointer (buffer_mem_start + offset, vlib_buffer_t *);
  76 }
  77
  78 /** \brief Translate buffer index into buffer pointer
  79
  80     @param vm - (vlib_main_t *) vlib main data structure pointer
  81     @param buffer_index - (u32) buffer index
  82     @return - (vlib_buffer_t *) buffer pointer
  83 */
  84 always_inline vlib_buffer_t *
  85 vlib_get_buffer (vlib_main_t * vm, u32 buffer_index)
  86 {
  87   vlib_buffer_main_t *bm = vm->buffer_main;
  88   vlib_buffer_t *b;
  89
  90   b = vlib_buffer_ptr_from_index (bm->buffer_mem_start, buffer_index, 0);
  91   vlib_buffer_validate (vm, b);
  92   return b;
  93 }
  94
  95 static_always_inline u32
  96 vlib_buffer_get_default_data_size (vlib_main_t * vm)
  97 {
  98   return vm->buffer_main->default_data_size;
  99 }
 100
 101 static_always_inline void
 102 vlib_buffer_copy_indices (u32 * dst, u32 * src, u32 n_indices)
 103 {
 104 #if defined(CLIB_HAVE_VEC512)
 105   while (n_indices >= 16)
 106     {
 107       u32x16_store_unaligned (u32x16_load_unaligned (src), dst);
 108       dst += 16;
 109       src += 16;
 110       n_indices -= 16;
 111     }
 112 #endif
 113
 114 #if defined(CLIB_HAVE_VEC256)
 115   while (n_indices >= 8)
 116     {
 117       u32x8_store_unaligned (u32x8_load_unaligned (src), dst);
 118       dst += 8;
 119       src += 8;
 120       n_indices -= 8;
 121     }
 122 #endif
 123
 124 #if defined(CLIB_HAVE_VEC128)
 125   while (n_indices >= 4)
 126     {
 127       u32x4_store_unaligned (u32x4_load_unaligned (src), dst);
 128       dst += 4;
 129       src += 4;
 130       n_indices -= 4;
 131     }
 132 #endif
 133
 134   while (n_indices)
 135     {
 136       dst[0] = src[0];
 137       dst += 1;
 138       src += 1;
 139       n_indices -= 1;
 140     }
 141 }
 142
 143 STATIC_ASSERT_OFFSET_OF (vlib_buffer_t, template_end, 64);
 144 static_always_inline void
 145 vlib_buffer_copy_template (vlib_buffer_t * b, vlib_buffer_t * bt)
 146 {
 147 #if defined CLIB_HAVE_VEC512
 148   b->as_u8x64[0] = bt->as_u8x64[0];
 149 #elif defined (CLIB_HAVE_VEC256)
 150   b->as_u8x32[0] = bt->as_u8x32[0];
 151   b->as_u8x32[1] = bt->as_u8x32[1];
 152 #elif defined (CLIB_HAVE_VEC128)
 153   b->as_u8x16[0] = bt->as_u8x16[0];
 154   b->as_u8x16[1] = bt->as_u8x16[1];
 155   b->as_u8x16[2] = bt->as_u8x16[2];
 156   b->as_u8x16[3] = bt->as_u8x16[3];
 157 #else
 158   clib_memcpy_fast (b, bt, 64);
 159 #endif
 160 }
 161
 162 always_inline u8
 163 vlib_buffer_pool_get_default_for_numa (vlib_main_t * vm, u32 numa_node)
 164 {
 165   ASSERT (numa_node < VLIB_BUFFER_MAX_NUMA_NODES);
 166   return vm->buffer_main->default_buffer_pool_index_for_numa[numa_node];
 167 }
 168
 169 /** \brief Translate array of buffer indices into buffer pointers with offset
 170
 171     @param vm - (vlib_main_t *) vlib main data structure pointer
 172     @param bi - (u32 *) array of buffer indices
 173     @param b - (void **) array to store buffer pointers
 174     @param count - (uword) number of elements
 175     @param offset - (i32) offset applied to each pointer
 176 */
 177 static_always_inline void
 178 vlib_get_buffers_with_offset (vlib_main_t * vm, u32 * bi, void **b, int count,
 179                               i32 offset)
 180 {
 181   uword buffer_mem_start = vm->buffer_main->buffer_mem_start;
 182 #ifdef CLIB_HAVE_VEC256
 183   u64x4 off = u64x4_splat (buffer_mem_start + offset);
 184   /* if count is not const, compiler will not unroll while loop
 185      se we maintain two-in-parallel variant */
 186   while (count >= 8)
 187     {
 188       u64x4 b0 = u32x4_extend_to_u64x4 (u32x4_load_unaligned (bi));
 189       u64x4 b1 = u32x4_extend_to_u64x4 (u32x4_load_unaligned (bi + 4));
 190       /* shift and add to get vlib_buffer_t pointer */
 191       u64x4_store_unaligned ((b0 << CLIB_LOG2_CACHE_LINE_BYTES) + off, b);
 192       u64x4_store_unaligned ((b1 << CLIB_LOG2_CACHE_LINE_BYTES) + off, b + 4);
 193       b += 8;
 194       bi += 8;
 195       count -= 8;
 196     }
 197 #endif
 198   while (count >= 4)
 199     {
 200 #ifdef CLIB_HAVE_VEC256
 201       u64x4 b0 = u32x4_extend_to_u64x4 (u32x4_load_unaligned (bi));
 202       /* shift and add to get vlib_buffer_t pointer */
 203       u64x4_store_unaligned ((b0 << CLIB_LOG2_CACHE_LINE_BYTES) + off, b);
 204 #elif defined (CLIB_HAVE_VEC128)
 205       u64x2 off = u64x2_splat (buffer_mem_start + offset);
 206       u32x4 bi4 = u32x4_load_unaligned (bi);
 207       u64x2 b0 = u32x4_extend_to_u64x2 ((u32x4) bi4);
 208 #if defined (__aarch64__)
 209       u64x2 b1 = u32x4_extend_to_u64x2_high ((u32x4) bi4);
 210 #else
 211       bi4 = u32x4_shuffle (bi4, 2, 3, 0, 1);
 212       u64x2 b1 = u32x4_extend_to_u64x2 ((u32x4) bi4);
 213 #endif
 214       u64x2_store_unaligned ((b0 << CLIB_LOG2_CACHE_LINE_BYTES) + off, b);
 215       u64x2_store_unaligned ((b1 << CLIB_LOG2_CACHE_LINE_BYTES) + off, b + 2);
 216 #else
 217       b[0] = vlib_buffer_ptr_from_index (buffer_mem_start, bi[0], offset);
 218       b[1] = vlib_buffer_ptr_from_index (buffer_mem_start, bi[1], offset);
 219       b[2] = vlib_buffer_ptr_from_index (buffer_mem_start, bi[2], offset);
 220       b[3] = vlib_buffer_ptr_from_index (buffer_mem_start, bi[3], offset);
 221 #endif
 222       b += 4;
 223       bi += 4;
 224       count -= 4;
 225     }
 226   while (count)
 227     {
 228       b[0] = vlib_buffer_ptr_from_index (buffer_mem_start, bi[0], offset);
 229       b += 1;
 230       bi += 1;
 231       count -= 1;
 232     }
 233 }
 234
 235 /** \brief Translate array of buffer indices into buffer pointers
 236
 237     @param vm - (vlib_main_t *) vlib main data structure pointer
 238     @param bi - (u32 *) array of buffer indices
 239     @param b - (vlib_buffer_t **) array to store buffer pointers
 240     @param count - (uword) number of elements
 241 */
 242
 243 static_always_inline void
 244 vlib_get_buffers (vlib_main_t * vm, u32 * bi, vlib_buffer_t ** b, int count)
 245 {
 246   vlib_get_buffers_with_offset (vm, bi, (void **) b, count, 0);
 247 }
 248
 249 /** \brief Translate buffer pointer into buffer index
 250
 251     @param vm - (vlib_main_t *) vlib main data structure pointer
 252     @param p - (void *) buffer pointer
 253     @return - (u32) buffer index
 254 */
 255
 256 always_inline u32
 257 vlib_get_buffer_index (vlib_main_t * vm, void *p)
 258 {
 259   vlib_buffer_main_t *bm = vm->buffer_main;
 260   uword offset = pointer_to_uword (p) - bm->buffer_mem_start;
 261   ASSERT (pointer_to_uword (p) >= bm->buffer_mem_start);
 262   ASSERT (offset < bm->buffer_mem_size);
 263   ASSERT ((offset % (1 << CLIB_LOG2_CACHE_LINE_BYTES)) == 0);
 264   return offset >> CLIB_LOG2_CACHE_LINE_BYTES;
 265 }
 266
 267 /** \brief Translate array of buffer pointers into buffer indices with offset
 268
 269     @param vm - (vlib_main_t *) vlib main data structure pointer
 270     @param b - (void **) array of buffer pointers
 271     @param bi - (u32 *) array to store buffer indices
 272     @param count - (uword) number of elements
 273     @param offset - (i32) offset applied to each pointer
 274 */
 275 static_always_inline void
 276 vlib_get_buffer_indices_with_offset (vlib_main_t * vm, void **b, u32 * bi,
 277                                      uword count, i32 offset)
 278 {
 279 #ifdef CLIB_HAVE_VEC256
 280   u32x8 mask = { 0, 2, 4, 6, 1, 3, 5, 7 };
 281   u64x4 off4 = u64x4_splat (vm->buffer_main->buffer_mem_start - offset);
 282
 283   while (count >= 8)
 284     {
 285       /* load 4 pointers into 256-bit register */
 286       u64x4 v0 = u64x4_load_unaligned (b);
 287       u64x4 v1 = u64x4_load_unaligned (b + 4);
 288       u32x8 v2, v3;
 289
 290       v0 -= off4;
 291       v1 -= off4;
 292
 293       v0 >>= CLIB_LOG2_CACHE_LINE_BYTES;
 294       v1 >>= CLIB_LOG2_CACHE_LINE_BYTES;
 295
 296       /* permute 256-bit register so lower u32s of each buffer index are
 297        * placed into lower 128-bits */
 298       v2 = u32x8_permute ((u32x8) v0, mask);
 299       v3 = u32x8_permute ((u32x8) v1, mask);
 300
 301       /* extract lower 128-bits and save them to the array of buffer indices */
 302       u32x4_store_unaligned (u32x8_extract_lo (v2), bi);
 303       u32x4_store_unaligned (u32x8_extract_lo (v3), bi + 4);
 304       bi += 8;
 305       b += 8;
 306       count -= 8;
 307     }
 308 #endif
 309   while (count >= 4)
 310     {
 311       /* equivalent non-nector implementation */
 312       bi[0] = vlib_get_buffer_index (vm, ((u8 *) b[0]) + offset);
 313       bi[1] = vlib_get_buffer_index (vm, ((u8 *) b[1]) + offset);
 314       bi[2] = vlib_get_buffer_index (vm, ((u8 *) b[2]) + offset);
 315       bi[3] = vlib_get_buffer_index (vm, ((u8 *) b[3]) + offset);
 316       bi += 4;
 317       b += 4;
 318       count -= 4;
 319     }
 320   while (count)
 321     {
 322       bi[0] = vlib_get_buffer_index (vm, ((u8 *) b[0]) + offset);
 323       bi += 1;
 324       b += 1;
 325       count -= 1;
 326     }
 327 }
 328
 329 /** \brief Translate array of buffer pointers into buffer indices
 330
 331     @param vm - (vlib_main_t *) vlib main data structure pointer
 332     @param b - (vlib_buffer_t **) array of buffer pointers
 333     @param bi - (u32 *) array to store buffer indices
 334     @param count - (uword) number of elements
 335 */
 336 static_always_inline void
 337 vlib_get_buffer_indices (vlib_main_t * vm, vlib_buffer_t ** b, u32 * bi,
 338                          uword count)
 339 {
 340   vlib_get_buffer_indices_with_offset (vm, (void **) b, bi, count, 0);
 341 }
 342
 343 /** \brief Get next buffer in buffer linklist, or zero for end of list.
 344
 345     @param vm - (vlib_main_t *) vlib main data structure pointer
 346     @param b - (void *) buffer pointer
 347     @return - (vlib_buffer_t *) next buffer, or NULL
 348 */
 349 always_inline vlib_buffer_t *
 350 vlib_get_next_buffer (vlib_main_t * vm, vlib_buffer_t * b)
 351 {
 352   return (b->flags & VLIB_BUFFER_NEXT_PRESENT
 353           ? vlib_get_buffer (vm, b->next_buffer) : 0);
 354 }
 355
 356 uword vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm,
 357                                              vlib_buffer_t * b_first);
 358
 359 /** \brief Get length in bytes of the buffer chain
 360
 361     @param vm - (vlib_main_t *) vlib main data structure pointer
 362     @param b - (void *) buffer pointer
 363     @return - (uword) length of buffer chain
 364 */
 365 always_inline uword
 366 vlib_buffer_length_in_chain (vlib_main_t * vm, vlib_buffer_t * b)
 367 {
 368   uword len = b->current_length;
 369
 370   if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0))
 371     return len;
 372
 373   if (PREDICT_TRUE (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID))
 374     return len + b->total_length_not_including_first_buffer;
 375
 376   return vlib_buffer_length_in_chain_slow_path (vm, b);
 377 }
 378
 379 /** \brief Get length in bytes of the buffer index buffer chain
 380
 381     @param vm - (vlib_main_t *) vlib main data structure pointer
 382     @param bi - (u32) buffer index
 383     @return - (uword) length of buffer chain
 384 */
 385 always_inline uword
 386 vlib_buffer_index_length_in_chain (vlib_main_t * vm, u32 bi)
 387 {
 388   vlib_buffer_t *b = vlib_get_buffer (vm, bi);
 389   return vlib_buffer_length_in_chain (vm, b);
 390 }
 391
 392 /** \brief Copy buffer contents to memory
 393
 394     @param vm - (vlib_main_t *) vlib main data structure pointer
 395     @param buffer_index - (u32) buffer index
 396     @param contents - (u8 *) memory, <strong>must be large enough</strong>
 397     @return - (uword) length of buffer chain
 398 */
 399 always_inline uword
 400 vlib_buffer_contents (vlib_main_t * vm, u32 buffer_index, u8 * contents)
 401 {
 402   uword content_len = 0;
 403   uword l;
 404   vlib_buffer_t *b;
 405
 406   while (1)
 407     {
 408       b = vlib_get_buffer (vm, buffer_index);
 409       l = b->current_length;
 410       clib_memcpy_fast (contents + content_len, b->data + b->current_data, l);
 411       content_len += l;
 412       if (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))
 413         break;
 414       buffer_index = b->next_buffer;
 415     }
 416
 417   return content_len;
 418 }
 419
 420 always_inline uword
 421 vlib_buffer_get_pa (vlib_main_t * vm, vlib_buffer_t * b)
 422 {
 423   return vlib_physmem_get_pa (vm, b->data);
 424 }
 425
 426 always_inline uword
 427 vlib_buffer_get_current_pa (vlib_main_t * vm, vlib_buffer_t * b)
 428 {
 429   return vlib_buffer_get_pa (vm, b) + b->current_data;
 430 }
 431
 432 /** \brief Prefetch buffer metadata by buffer index
 433     The first 64 bytes of buffer contains most header information
 434
 435     @param vm - (vlib_main_t *) vlib main data structure pointer
 436     @param bi - (u32) buffer index
 437     @param type - LOAD, STORE. In most cases, STORE is the right answer
 438 */
 439 /* Prefetch buffer header given index. */
 440 #define vlib_prefetch_buffer_with_index(vm,bi,type)     \
 441   do {                                                  \
 442     vlib_buffer_t * _b = vlib_get_buffer (vm, bi);      \
 443     vlib_prefetch_buffer_header (_b, type);             \
 444   } while (0)
 445
 446 typedef enum
 447 {
 448   /* Index is unknown. */
 449   VLIB_BUFFER_UNKNOWN,
 450
 451   /* Index is known and free/allocated. */
 452   VLIB_BUFFER_KNOWN_FREE,
 453   VLIB_BUFFER_KNOWN_ALLOCATED,
 454 } vlib_buffer_known_state_t;
 455
 456 void vlib_buffer_validate_alloc_free (vlib_main_t * vm, u32 * buffers,
 457                                       uword n_buffers,
 458                                       vlib_buffer_known_state_t
 459                                       expected_state);
 460
 461 always_inline vlib_buffer_known_state_t
 462 vlib_buffer_is_known (vlib_main_t * vm, u32 buffer_index)
 463 {
 464   vlib_buffer_main_t *bm = vm->buffer_main;
 465
 466   clib_spinlock_lock (&bm->buffer_known_hash_lockp);
 467   uword *p = hash_get (bm->buffer_known_hash, buffer_index);
 468   clib_spinlock_unlock (&bm->buffer_known_hash_lockp);
 469   return p ? p[0] : VLIB_BUFFER_UNKNOWN;
 470 }
 471
 472 /* Validates sanity of a single buffer.
 473    Returns format'ed vector with error message if any. */
 474 u8 *vlib_validate_buffer (vlib_main_t * vm, u32 buffer_index,
 475                           uword follow_chain);
 476
 477 static_always_inline vlib_buffer_pool_t *
 478 vlib_get_buffer_pool (vlib_main_t * vm, u8 buffer_pool_index)
 479 {
 480   vlib_buffer_main_t *bm = vm->buffer_main;
 481   return vec_elt_at_index (bm->buffer_pools, buffer_pool_index);
 482 }
 483
 484 static_always_inline uword
 485 vlib_buffer_pool_get (vlib_main_t * vm, u8 buffer_pool_index, u32 * buffers,
 486                       u32 n_buffers)
 487 {
 488   vlib_buffer_pool_t *bp = vlib_get_buffer_pool (vm, buffer_pool_index);
 489   u32 len;
 490
 491   ASSERT (bp->buffers);
 492
 493   clib_spinlock_lock (&bp->lock);
 494   len = vec_len (bp->buffers);
 495   if (PREDICT_TRUE (n_buffers < len))
 496     {
 497       len -= n_buffers;
 498       vlib_buffer_copy_indices (buffers, bp->buffers + len, n_buffers);
 499       _vec_len (bp->buffers) = len;
 500       clib_spinlock_unlock (&bp->lock);
 501       return n_buffers;
 502     }
 503   else
 504     {
 505       vlib_buffer_copy_indices (buffers, bp->buffers, len);
 506       _vec_len (bp->buffers) = 0;
 507       clib_spinlock_unlock (&bp->lock);
 508       return len;
 509     }
 510 }
 511
 512
 513 /** \brief Allocate buffers from specific pool into supplied array
 514
 515     @param vm - (vlib_main_t *) vlib main data structure pointer
 516     @param buffers - (u32 * ) buffer index array
 517     @param n_buffers - (u32) number of buffers requested
 518     @return - (u32) number of buffers actually allocated, may be
 519     less than the number requested or zero
 520 */
 521
 522 always_inline u32
 523 vlib_buffer_alloc_from_pool (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 524                              u8 buffer_pool_index)
 525 {
 526   vlib_buffer_main_t *bm = vm->buffer_main;
 527   vlib_buffer_pool_t *bp;
 528   vlib_buffer_pool_thread_t *bpt;
 529   u32 *src, *dst, len, n_left;
 530
 531   bp = vec_elt_at_index (bm->buffer_pools, buffer_pool_index);
 532   bpt = vec_elt_at_index (bp->threads, vm->thread_index);
 533
 534   dst = buffers;
 535   n_left = n_buffers;
 536   len = vec_len (bpt->cached_buffers);
 537
 538   /* per-thread cache contains enough buffers */
 539   if (len >= n_buffers)
 540     {
 541       src = bpt->cached_buffers + len - n_buffers;
 542       vlib_buffer_copy_indices (dst, src, n_buffers);
 543       _vec_len (bpt->cached_buffers) -= n_buffers;
 544
 545       if (CLIB_DEBUG > 0)
 546         vlib_buffer_validate_alloc_free (vm, buffers, n_buffers,
 547                                          VLIB_BUFFER_KNOWN_FREE);
 548       return n_buffers;
 549     }
 550
 551   /* take everything available in the cache */
 552   if (len)
 553     {
 554       vlib_buffer_copy_indices (dst, bpt->cached_buffers, len);
 555       _vec_len (bpt->cached_buffers) = 0;
 556       dst += len;
 557       n_left -= len;
 558     }
 559
 560   len = round_pow2 (n_left, 32);
 561   vec_validate_aligned (bpt->cached_buffers, len - 1, CLIB_CACHE_LINE_BYTES);
 562   len = vlib_buffer_pool_get (vm, buffer_pool_index, bpt->cached_buffers,
 563                               len);
 564   _vec_len (bpt->cached_buffers) = len;
 565
 566   if (len)
 567     {
 568       u32 n_copy = clib_min (len, n_left);
 569       src = bpt->cached_buffers + len - n_copy;
 570       vlib_buffer_copy_indices (dst, src, n_copy);
 571       _vec_len (bpt->cached_buffers) -= n_copy;
 572       n_left -= n_copy;
 573     }
 574
 575   n_buffers -= n_left;
 576
 577   /* Verify that buffers are known free. */
 578   if (CLIB_DEBUG > 0)
 579     vlib_buffer_validate_alloc_free (vm, buffers, n_buffers,
 580                                      VLIB_BUFFER_KNOWN_FREE);
 581
 582   return n_buffers;
 583 }
 584
 585 /** \brief Allocate buffers from specific numa node into supplied array
 586
 587     @param vm - (vlib_main_t *) vlib main data structure pointer
 588     @param buffers - (u32 * ) buffer index array
 589     @param n_buffers - (u32) number of buffers requested
 590     @param numa_node - (u32) numa node
 591     @return - (u32) number of buffers actually allocated, may be
 592     less than the number requested or zero
 593 */
 594 always_inline u32
 595 vlib_buffer_alloc_on_numa (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 596                            u32 numa_node)
 597 {
 598   u8 index = vlib_buffer_pool_get_default_for_numa (vm, numa_node);
 599   return vlib_buffer_alloc_from_pool (vm, buffers, n_buffers, index);
 600 }
 601
 602 /** \brief Allocate buffers into supplied array
 603
 604     @param vm - (vlib_main_t *) vlib main data structure pointer
 605     @param buffers - (u32 * ) buffer index array
 606     @param n_buffers - (u32) number of buffers requested
 607     @return - (u32) number of buffers actually allocated, may be
 608     less than the number requested or zero
 609 */
 610
 611 always_inline u32
 612 vlib_buffer_alloc (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 613 {
 614   return vlib_buffer_alloc_on_numa (vm, buffers, n_buffers, vm->numa_node);
 615 }
 616
 617 /** \brief Allocate buffers into ring
 618
 619     @param vm - (vlib_main_t *) vlib main data structure pointer
 620     @param buffers - (u32 * ) buffer index ring
 621     @param start - (u32) first slot in the ring
 622     @param ring_size - (u32) ring size
 623     @param n_buffers - (u32) number of buffers requested
 624     @return - (u32) number of buffers actually allocated, may be
 625     less than the number requested or zero
 626 */
 627 always_inline u32
 628 vlib_buffer_alloc_to_ring (vlib_main_t * vm, u32 * ring, u32 start,
 629                            u32 ring_size, u32 n_buffers)
 630 {
 631   u32 n_alloc;
 632
 633   ASSERT (n_buffers <= ring_size);
 634
 635   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 636     return vlib_buffer_alloc (vm, ring + start, n_buffers);
 637
 638   n_alloc = vlib_buffer_alloc (vm, ring + start, ring_size - start);
 639
 640   if (PREDICT_TRUE (n_alloc == ring_size - start))
 641     n_alloc += vlib_buffer_alloc (vm, ring, n_buffers - n_alloc);
 642
 643   return n_alloc;
 644 }
 645
 646 /** \brief Allocate buffers into ring from specific buffer pool
 647
 648     @param vm - (vlib_main_t *) vlib main data structure pointer
 649     @param buffers - (u32 * ) buffer index ring
 650     @param start - (u32) first slot in the ring
 651     @param ring_size - (u32) ring size
 652     @param n_buffers - (u32) number of buffers requested
 653     @return - (u32) number of buffers actually allocated, may be
 654     less than the number requested or zero
 655 */
 656 always_inline u32
 657 vlib_buffer_alloc_to_ring_from_pool (vlib_main_t * vm, u32 * ring, u32 start,
 658                                      u32 ring_size, u32 n_buffers,
 659                                      u8 buffer_pool_index)
 660 {
 661   u32 n_alloc;
 662
 663   ASSERT (n_buffers <= ring_size);
 664
 665   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 666     return vlib_buffer_alloc_from_pool (vm, ring + start, n_buffers,
 667                                         buffer_pool_index);
 668
 669   n_alloc = vlib_buffer_alloc_from_pool (vm, ring + start, ring_size - start,
 670                                          buffer_pool_index);
 671
 672   if (PREDICT_TRUE (n_alloc == ring_size - start))
 673     n_alloc += vlib_buffer_alloc_from_pool (vm, ring, n_buffers - n_alloc,
 674                                             buffer_pool_index);
 675
 676   return n_alloc;
 677 }
 678
 679 static_always_inline void
 680 vlib_buffer_pool_put (vlib_main_t * vm, u8 buffer_pool_index,
 681                       u32 * buffers, u32 n_buffers)
 682 {
 683   vlib_buffer_pool_t *bp = vlib_get_buffer_pool (vm, buffer_pool_index);
 684   vlib_buffer_pool_thread_t *bpt =
 685     vec_elt_at_index (bp->threads, vm->thread_index);
 686
 687   if (CLIB_DEBUG > 0)
 688     vlib_buffer_validate_alloc_free (vm, buffers, n_buffers,
 689                                      VLIB_BUFFER_KNOWN_ALLOCATED);
 690
 691   vec_add_aligned (bpt->cached_buffers, buffers, n_buffers,
 692                    CLIB_CACHE_LINE_BYTES);
 693
 694   if (vec_len (bpt->cached_buffers) > 4 * VLIB_FRAME_SIZE)
 695     {
 696       clib_spinlock_lock (&bp->lock);
 697       /* keep last stored buffers, as they are more likely hot in the cache */
 698       vec_add_aligned (bp->buffers, bpt->cached_buffers, VLIB_FRAME_SIZE,
 699                        CLIB_CACHE_LINE_BYTES);
 700       vec_delete (bpt->cached_buffers, VLIB_FRAME_SIZE, 0);
 701       bpt->n_alloc -= VLIB_FRAME_SIZE;
 702       clib_spinlock_unlock (&bp->lock);
 703     }
 704 }
 705
 706 static_always_inline void
 707 vlib_buffer_free_inline (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 708                          int maybe_next)
 709 {
 710   const int queue_size = 128;
 711   vlib_buffer_pool_t *bp = 0;
 712   u8 buffer_pool_index = ~0;
 713   u32 n_queue = 0, queue[queue_size + 4];
 714   vlib_buffer_t bt = { };
 715 #if defined(CLIB_HAVE_VEC128) && !__aarch64__
 716   vlib_buffer_t bpi_mask = {.buffer_pool_index = ~0 };
 717   vlib_buffer_t bpi_vec = {.buffer_pool_index = ~0 };
 718   vlib_buffer_t flags_refs_mask = {
 719     .flags = VLIB_BUFFER_NEXT_PRESENT,
 720     .ref_count = ~1
 721   };
 722 #endif
 723
 724   while (n_buffers)
 725     {
 726       vlib_buffer_t *b[8];
 727       u32 bi, sum = 0, flags, next;
 728
 729       if (n_buffers < 12)
 730         goto one_by_one;
 731
 732       vlib_get_buffers (vm, buffers, b, 4);
 733       vlib_get_buffers (vm, buffers + 8, b + 4, 4);
 734
 735       vlib_prefetch_buffer_header (b[4], LOAD);
 736       vlib_prefetch_buffer_header (b[5], LOAD);
 737       vlib_prefetch_buffer_header (b[6], LOAD);
 738       vlib_prefetch_buffer_header (b[7], LOAD);
 739
 740 #if defined(CLIB_HAVE_VEC128) && !__aarch64__
 741       u8x16 p0, p1, p2, p3, r;
 742       p0 = u8x16_load_unaligned (b[0]);
 743       p1 = u8x16_load_unaligned (b[1]);
 744       p2 = u8x16_load_unaligned (b[2]);
 745       p3 = u8x16_load_unaligned (b[3]);
 746
 747       r = p0 ^ bpi_vec.as_u8x16[0];
 748       r |= p1 ^ bpi_vec.as_u8x16[0];
 749       r |= p2 ^ bpi_vec.as_u8x16[0];
 750       r |= p3 ^ bpi_vec.as_u8x16[0];
 751       r &= bpi_mask.as_u8x16[0];
 752       r |= (p0 | p1 | p2 | p3) & flags_refs_mask.as_u8x16[0];
 753
 754       sum = !u8x16_is_all_zero (r);
 755 #else
 756       sum |= b[0]->flags;
 757       sum |= b[1]->flags;
 758       sum |= b[2]->flags;
 759       sum |= b[3]->flags;
 760       sum &= VLIB_BUFFER_NEXT_PRESENT;
 761       sum += b[0]->ref_count - 1;
 762       sum += b[1]->ref_count - 1;
 763       sum += b[2]->ref_count - 1;
 764       sum += b[3]->ref_count - 1;
 765       sum |= b[0]->buffer_pool_index ^ buffer_pool_index;
 766       sum |= b[1]->buffer_pool_index ^ buffer_pool_index;
 767       sum |= b[2]->buffer_pool_index ^ buffer_pool_index;
 768       sum |= b[3]->buffer_pool_index ^ buffer_pool_index;
 769 #endif
 770
 771       if (sum)
 772         goto one_by_one;
 773
 774       vlib_buffer_copy_indices (queue + n_queue, buffers, 4);
 775       vlib_buffer_copy_template (b[0], &bt);
 776       vlib_buffer_copy_template (b[1], &bt);
 777       vlib_buffer_copy_template (b[2], &bt);
 778       vlib_buffer_copy_template (b[3], &bt);
 779       n_queue += 4;
 780
 781       vlib_buffer_validate (vm, b[0]);
 782       vlib_buffer_validate (vm, b[1]);
 783       vlib_buffer_validate (vm, b[2]);
 784       vlib_buffer_validate (vm, b[3]);
 785
 786       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 787       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
 788       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]);
 789       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]);
 790
 791       if (n_queue >= queue_size)
 792         {
 793           vlib_buffer_pool_put (vm, buffer_pool_index, queue, n_queue);
 794           n_queue = 0;
 795         }
 796       buffers += 4;
 797       n_buffers -= 4;
 798       continue;
 799
 800     one_by_one:
 801       bi = buffers[0];
 802
 803     next_in_chain:
 804       b[0] = vlib_get_buffer (vm, bi);
 805       flags = b[0]->flags;
 806       next = b[0]->next_buffer;
 807
 808       if (PREDICT_FALSE (buffer_pool_index != b[0]->buffer_pool_index))
 809         {
 810
 811           if (n_queue)
 812             {
 813               vlib_buffer_pool_put (vm, buffer_pool_index, queue, n_queue);
 814               n_queue = 0;
 815             }
 816
 817           buffer_pool_index = b[0]->buffer_pool_index;
 818 #if defined(CLIB_HAVE_VEC128) && !__aarch64__
 819           bpi_vec.buffer_pool_index = buffer_pool_index;
 820 #endif
 821           bp = vlib_get_buffer_pool (vm, buffer_pool_index);
 822           vlib_buffer_copy_template (&bt, &bp->buffer_template);
 823         }
 824
 825       vlib_buffer_validate (vm, b[0]);
 826
 827       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 828
 829       if (clib_atomic_sub_fetch (&b[0]->ref_count, 1) == 0)
 830         {
 831           vlib_buffer_copy_template (b[0], &bt);
 832           queue[n_queue++] = bi;
 833         }
 834
 835       if (n_queue == queue_size)
 836         {
 837           vlib_buffer_pool_put (vm, buffer_pool_index, queue, queue_size);
 838           n_queue = 0;
 839         }
 840
 841       if (flags & VLIB_BUFFER_NEXT_PRESENT)
 842         {
 843           bi = next;
 844           goto next_in_chain;
 845         }
 846
 847       buffers++;
 848       n_buffers--;
 849     }
 850
 851   if (n_queue)
 852     vlib_buffer_pool_put (vm, buffer_pool_index, queue, n_queue);
 853 }
 854
 855
 856 /** \brief Free buffers
 857     Frees the entire buffer chain for each buffer
 858
 859     @param vm - (vlib_main_t *) vlib main data structure pointer
 860     @param buffers - (u32 * ) buffer index array
 861     @param n_buffers - (u32) number of buffers to free
 862
 863 */
 864 always_inline void
 865 vlib_buffer_free (vlib_main_t * vm,
 866                   /* pointer to first buffer */
 867                   u32 * buffers,
 868                   /* number of buffers to free */
 869                   u32 n_buffers)
 870 {
 871   vlib_buffer_free_inline (vm, buffers, n_buffers, /* maybe next */ 1);
 872 }
 873
 874 /** \brief Free buffers, does not free the buffer chain for each buffer
 875
 876     @param vm - (vlib_main_t *) vlib main data structure pointer
 877     @param buffers - (u32 * ) buffer index array
 878     @param n_buffers - (u32) number of buffers to free
 879
 880 */
 881 always_inline void
 882 vlib_buffer_free_no_next (vlib_main_t * vm,
 883                           /* pointer to first buffer */
 884                           u32 * buffers,
 885                           /* number of buffers to free */
 886                           u32 n_buffers)
 887 {
 888   vlib_buffer_free_inline (vm, buffers, n_buffers, /* maybe next */ 0);
 889 }
 890
 891 /** \brief Free one buffer
 892     Shorthand to free a single buffer chain.
 893
 894     @param vm - (vlib_main_t *) vlib main data structure pointer
 895     @param buffer_index - (u32) buffer index to free
 896 */
 897 always_inline void
 898 vlib_buffer_free_one (vlib_main_t * vm, u32 buffer_index)
 899 {
 900   vlib_buffer_free_inline (vm, &buffer_index, 1, /* maybe next */ 1);
 901 }
 902
 903 /** \brief Free buffers from ring
 904
 905     @param vm - (vlib_main_t *) vlib main data structure pointer
 906     @param buffers - (u32 * ) buffer index ring
 907     @param start - (u32) first slot in the ring
 908     @param ring_size - (u32) ring size
 909     @param n_buffers - (u32) number of buffers
 910 */
 911 always_inline void
 912 vlib_buffer_free_from_ring (vlib_main_t * vm, u32 * ring, u32 start,
 913                             u32 ring_size, u32 n_buffers)
 914 {
 915   ASSERT (n_buffers <= ring_size);
 916
 917   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 918     {
 919       vlib_buffer_free (vm, ring + start, n_buffers);
 920     }
 921   else
 922     {
 923       vlib_buffer_free (vm, ring + start, ring_size - start);
 924       vlib_buffer_free (vm, ring, n_buffers - (ring_size - start));
 925     }
 926 }
 927
 928 /** \brief Free buffers from ring without freeing tail buffers
 929
 930     @param vm - (vlib_main_t *) vlib main data structure pointer
 931     @param buffers - (u32 * ) buffer index ring
 932     @param start - (u32) first slot in the ring
 933     @param ring_size - (u32) ring size
 934     @param n_buffers - (u32) number of buffers
 935 */
 936 always_inline void
 937 vlib_buffer_free_from_ring_no_next (vlib_main_t * vm, u32 * ring, u32 start,
 938                                     u32 ring_size, u32 n_buffers)
 939 {
 940   ASSERT (n_buffers <= ring_size);
 941
 942   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 943     {
 944       vlib_buffer_free_no_next (vm, ring + start, n_buffers);
 945     }
 946   else
 947     {
 948       vlib_buffer_free_no_next (vm, ring + start, ring_size - start);
 949       vlib_buffer_free_no_next (vm, ring, n_buffers - (ring_size - start));
 950     }
 951 }
 952
 953 /* Append given data to end of buffer, possibly allocating new buffers. */
 954 int vlib_buffer_add_data (vlib_main_t * vm, u32 * buffer_index, void *data,
 955                           u32 n_data_bytes);
 956
 957 /* duplicate all buffers in chain */
 958 always_inline vlib_buffer_t *
 959 vlib_buffer_copy (vlib_main_t * vm, vlib_buffer_t * b)
 960 {
 961   vlib_buffer_t *s, *d, *fd;
 962   uword n_alloc, n_buffers = 1;
 963   u32 flag_mask = VLIB_BUFFER_NEXT_PRESENT | VLIB_BUFFER_TOTAL_LENGTH_VALID;
 964   int i;
 965
 966   s = b;
 967   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
 968     {
 969       n_buffers++;
 970       s = vlib_get_buffer (vm, s->next_buffer);
 971     }
 972   u32 new_buffers[n_buffers];
 973
 974   n_alloc = vlib_buffer_alloc (vm, new_buffers, n_buffers);
 975
 976   /* No guarantee that we'll get all the buffers we asked for */
 977   if (PREDICT_FALSE (n_alloc < n_buffers))
 978     {
 979       if (n_alloc > 0)
 980         vlib_buffer_free (vm, new_buffers, n_alloc);
 981       return 0;
 982     }
 983
 984   /* 1st segment */
 985   s = b;
 986   fd = d = vlib_get_buffer (vm, new_buffers[0]);
 987   d->current_data = s->current_data;
 988   d->current_length = s->current_length;
 989   d->flags = s->flags & flag_mask;
 990   d->total_length_not_including_first_buffer =
 991     s->total_length_not_including_first_buffer;
 992   clib_memcpy_fast (d->opaque, s->opaque, sizeof (s->opaque));
 993   clib_memcpy_fast (d->opaque2, s->opaque2, sizeof (s->opaque2));
 994   clib_memcpy_fast (vlib_buffer_get_current (d),
 995                     vlib_buffer_get_current (s), s->current_length);
 996
 997   /* next segments */
 998   for (i = 1; i < n_buffers; i++)
 999     {
1000       /* previous */
1001       d->next_buffer = new_buffers[i];
1002       /* current */
1003       s = vlib_get_buffer (vm, s->next_buffer);
1004       d = vlib_get_buffer (vm, new_buffers[i]);
1005       d->current_data = s->current_data;
1006       d->current_length = s->current_length;
1007       clib_memcpy_fast (vlib_buffer_get_current (d),
1008                         vlib_buffer_get_current (s), s->current_length);
1009       d->flags = s->flags & flag_mask;
1010     }
1011
1012   return fd;
1013 }
1014
1015 /* duplicate first buffer in chain */
1016 always_inline vlib_buffer_t *
1017 vlib_buffer_copy_no_chain (vlib_main_t * vm, vlib_buffer_t * b, u32 * di)
1018 {
1019   vlib_buffer_t *d;
1020
1021   if ((vlib_buffer_alloc (vm, di, 1)) != 1)
1022     return 0;
1023
1024   d = vlib_get_buffer (vm, *di);
1025   /* 1st segment */
1026   d->current_data = b->current_data;
1027   d->current_length = b->current_length;
1028   clib_memcpy_fast (d->opaque, b->opaque, sizeof (b->opaque));
1029   clib_memcpy_fast (d->opaque2, b->opaque2, sizeof (b->opaque2));
1030   clib_memcpy_fast (vlib_buffer_get_current (d),
1031                     vlib_buffer_get_current (b), b->current_length);
1032
1033   return d;
1034 }
1035
1036 /** \brief Create a maximum of 256 clones of buffer and store them
1037     in the supplied array
1038
1039     @param vm - (vlib_main_t *) vlib main data structure pointer
1040     @param src_buffer - (u32) source buffer index
1041     @param buffers - (u32 * ) buffer index array
1042     @param n_buffers - (u16) number of buffer clones requested (<=256)
1043     @param head_end_offset - (u16) offset relative to current position
1044            where packet head ends
1045     @return - (u16) number of buffers actually cloned, may be
1046     less than the number requested or zero
1047 */
1048 always_inline u16
1049 vlib_buffer_clone_256 (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1050                        u16 n_buffers, u16 head_end_offset)
1051 {
1052   u16 i;
1053   vlib_buffer_t *s = vlib_get_buffer (vm, src_buffer);
1054
1055   ASSERT (s->ref_count == 1);
1056   ASSERT (n_buffers);
1057   ASSERT (n_buffers <= 256);
1058
1059   if (s->current_length <= head_end_offset + CLIB_CACHE_LINE_BYTES * 2)
1060     {
1061       buffers[0] = src_buffer;
1062       for (i = 1; i < n_buffers; i++)
1063         {
1064           vlib_buffer_t *d;
1065           d = vlib_buffer_copy (vm, s);
1066           if (d == 0)
1067             return i;
1068           buffers[i] = vlib_get_buffer_index (vm, d);
1069
1070         }
1071       return n_buffers;
1072     }
1073
1074   if (PREDICT_FALSE (n_buffers == 1))
1075     {
1076       buffers[0] = src_buffer;
1077       return 1;
1078     }
1079
1080   n_buffers = vlib_buffer_alloc_from_pool (vm, buffers, n_buffers,
1081                                            s->buffer_pool_index);
1082
1083   for (i = 0; i < n_buffers; i++)
1084     {
1085       vlib_buffer_t *d = vlib_get_buffer (vm, buffers[i]);
1086       d->current_data = s->current_data;
1087       d->current_length = head_end_offset;
1088       ASSERT (d->buffer_pool_index == s->buffer_pool_index);
1089
1090       d->total_length_not_including_first_buffer = s->current_length -
1091         head_end_offset;
1092       if (PREDICT_FALSE (s->flags & VLIB_BUFFER_NEXT_PRESENT))
1093         {
1094           d->total_length_not_including_first_buffer +=
1095             s->total_length_not_including_first_buffer;
1096         }
1097       d->flags = s->flags | VLIB_BUFFER_NEXT_PRESENT;
1098       d->flags &= ~VLIB_BUFFER_EXT_HDR_VALID;
1099       clib_memcpy_fast (d->opaque, s->opaque, sizeof (s->opaque));
1100       clib_memcpy_fast (d->opaque2, s->opaque2, sizeof (s->opaque2));
1101       clib_memcpy_fast (vlib_buffer_get_current (d),
1102                         vlib_buffer_get_current (s), head_end_offset);
1103       d->next_buffer = src_buffer;
1104     }
1105   vlib_buffer_advance (s, head_end_offset);
1106   s->ref_count = n_buffers;
1107   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
1108     {
1109       s = vlib_get_buffer (vm, s->next_buffer);
1110       s->ref_count = n_buffers;
1111     }
1112
1113   return n_buffers;
1114 }
1115
1116 /** \brief Create multiple clones of buffer and store them
1117     in the supplied array
1118
1119     @param vm - (vlib_main_t *) vlib main data structure pointer
1120     @param src_buffer - (u32) source buffer index
1121     @param buffers - (u32 * ) buffer index array
1122     @param n_buffers - (u16) number of buffer clones requested (<=256)
1123     @param head_end_offset - (u16) offset relative to current position
1124            where packet head ends
1125     @return - (u16) number of buffers actually cloned, may be
1126     less than the number requested or zero
1127 */
1128 always_inline u16
1129 vlib_buffer_clone (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1130                    u16 n_buffers, u16 head_end_offset)
1131 {
1132   vlib_buffer_t *s = vlib_get_buffer (vm, src_buffer);
1133   u16 n_cloned = 0;
1134
1135   while (n_buffers > 256)
1136     {
1137       vlib_buffer_t *copy;
1138       copy = vlib_buffer_copy (vm, s);
1139       n_cloned += vlib_buffer_clone_256 (vm,
1140                                          vlib_get_buffer_index (vm, copy),
1141                                          (buffers + n_cloned),
1142                                          256, head_end_offset);
1143       n_buffers -= 256;
1144     }
1145   n_cloned += vlib_buffer_clone_256 (vm, src_buffer,
1146                                      buffers + n_cloned,
1147                                      n_buffers, head_end_offset);
1148
1149   return n_cloned;
1150 }
1151
1152 /** \brief Attach cloned tail to the buffer
1153
1154     @param vm - (vlib_main_t *) vlib main data structure pointer
1155     @param head - (vlib_buffer_t *) head buffer
1156     @param tail - (Vlib buffer_t *) tail buffer to clone and attach to head
1157 */
1158
1159 always_inline void
1160 vlib_buffer_attach_clone (vlib_main_t * vm, vlib_buffer_t * head,
1161                           vlib_buffer_t * tail)
1162 {
1163   ASSERT ((head->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
1164   ASSERT (head->buffer_pool_index == tail->buffer_pool_index);
1165
1166   head->flags |= VLIB_BUFFER_NEXT_PRESENT;
1167   head->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
1168   head->flags &= ~VLIB_BUFFER_EXT_HDR_VALID;
1169   head->flags |= (tail->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID);
1170   head->next_buffer = vlib_get_buffer_index (vm, tail);
1171   head->total_length_not_including_first_buffer = tail->current_length +
1172     tail->total_length_not_including_first_buffer;
1173
1174 next_segment:
1175   clib_atomic_add_fetch (&tail->ref_count, 1);
1176
1177   if (tail->flags & VLIB_BUFFER_NEXT_PRESENT)
1178     {
1179       tail = vlib_get_buffer (vm, tail->next_buffer);
1180       goto next_segment;
1181     }
1182 }
1183
1184 /* Initializes the buffer as an empty packet with no chained buffers. */
1185 always_inline void
1186 vlib_buffer_chain_init (vlib_buffer_t * first)
1187 {
1188   first->total_length_not_including_first_buffer = 0;
1189   first->current_length = 0;
1190   first->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1191   first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
1192 }
1193
1194 /* The provided next_bi buffer index is appended to the end of the packet. */
1195 always_inline vlib_buffer_t *
1196 vlib_buffer_chain_buffer (vlib_main_t * vm, vlib_buffer_t * last, u32 next_bi)
1197 {
1198   vlib_buffer_t *next_buffer = vlib_get_buffer (vm, next_bi);
1199   last->next_buffer = next_bi;
1200   last->flags |= VLIB_BUFFER_NEXT_PRESENT;
1201   next_buffer->current_length = 0;
1202   next_buffer->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1203   return next_buffer;
1204 }
1205
1206 /* Increases or decreases the packet length.
1207  * It does not allocate or deallocate new buffers.
1208  * Therefore, the added length must be compatible
1209  * with the last buffer. */
1210 always_inline void
1211 vlib_buffer_chain_increase_length (vlib_buffer_t * first,
1212                                    vlib_buffer_t * last, i32 len)
1213 {
1214   last->current_length += len;
1215   if (first != last)
1216     first->total_length_not_including_first_buffer += len;
1217 }
1218
1219 /* Copy data to the end of the packet and increases its length.
1220  * It does not allocate new buffers.
1221  * Returns the number of copied bytes. */
1222 always_inline u16
1223 vlib_buffer_chain_append_data (vlib_main_t * vm,
1224                                vlib_buffer_t * first,
1225                                vlib_buffer_t * last, void *data, u16 data_len)
1226 {
1227   u32 n_buffer_bytes = vlib_buffer_get_default_data_size (vm);
1228   ASSERT (n_buffer_bytes >= last->current_length + last->current_data);
1229   u16 len = clib_min (data_len,
1230                       n_buffer_bytes - last->current_length -
1231                       last->current_data);
1232   clib_memcpy_fast (vlib_buffer_get_current (last) + last->current_length,
1233                     data, len);
1234   vlib_buffer_chain_increase_length (first, last, len);
1235   return len;
1236 }
1237
1238 /* Copy data to the end of the packet and increases its length.
1239  * Allocates additional buffers from the free list if necessary.
1240  * Returns the number of copied bytes.
1241  * 'last' value is modified whenever new buffers are allocated and
1242  * chained and points to the last buffer in the chain. */
1243 u16
1244 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
1245                                           vlib_buffer_t * first,
1246                                           vlib_buffer_t ** last, void *data,
1247                                           u16 data_len);
1248 void vlib_buffer_chain_validate (vlib_main_t * vm, vlib_buffer_t * first);
1249
1250 format_function_t format_vlib_buffer, format_vlib_buffer_and_data,
1251   format_vlib_buffer_contents;
1252
1253 typedef struct
1254 {
1255   /* Vector of packet data. */
1256   u8 *packet_data;
1257
1258   /* Number of buffers to allocate in each call to allocator. */
1259   u32 min_n_buffers_each_alloc;
1260
1261   u8 *name;
1262 } vlib_packet_template_t;
1263
1264 void vlib_packet_template_init (vlib_main_t * vm,
1265                                 vlib_packet_template_t * t,
1266                                 void *packet_data,
1267                                 uword n_packet_data_bytes,
1268                                 uword min_n_buffers_each_alloc,
1269                                 char *fmt, ...);
1270
1271 void *vlib_packet_template_get_packet (vlib_main_t * vm,
1272                                        vlib_packet_template_t * t,
1273                                        u32 * bi_result);
1274
1275 always_inline void
1276 vlib_packet_template_free (vlib_main_t * vm, vlib_packet_template_t * t)
1277 {
1278   vec_free (t->packet_data);
1279 }
1280
1281 always_inline u32
1282 vlib_buffer_space_left_at_end (vlib_main_t * vm, vlib_buffer_t * b)
1283 {
1284   return b->data + vlib_buffer_get_default_data_size (vm) -
1285     ((u8 *) vlib_buffer_get_current (b) + b->current_length);
1286 }
1287
1288 always_inline u32
1289 vlib_buffer_chain_linearize (vlib_main_t * vm, vlib_buffer_t * b)
1290 {
1291   vlib_buffer_t *db = b, *sb, *first = b;
1292   int is_cloned = 0;
1293   u32 bytes_left = 0, data_size;
1294   u16 src_left, dst_left, n_buffers = 1;
1295   u8 *dp, *sp;
1296   u32 to_free = 0;
1297
1298   if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0))
1299     return 1;
1300
1301   data_size = vlib_buffer_get_default_data_size (vm);
1302
1303   dst_left = vlib_buffer_space_left_at_end (vm, b);
1304
1305   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
1306     {
1307       b = vlib_get_buffer (vm, b->next_buffer);
1308       if (b->ref_count > 1)
1309         is_cloned = 1;
1310       bytes_left += b->current_length;
1311       n_buffers++;
1312     }
1313
1314   /* if buffer is cloned, create completely new chain - unless everything fits
1315    * into one buffer */
1316   if (is_cloned && bytes_left >= dst_left)
1317     {
1318       u32 len = 0;
1319       u32 space_needed = bytes_left - dst_left;
1320       u32 tail;
1321
1322       if (vlib_buffer_alloc (vm, &tail, 1) == 0)
1323         return 0;
1324
1325       ++n_buffers;
1326       len += data_size;
1327       b = vlib_get_buffer (vm, tail);
1328
1329       while (len < space_needed)
1330         {
1331           u32 bi;
1332           if (vlib_buffer_alloc (vm, &bi, 1) == 0)
1333             {
1334               vlib_buffer_free_one (vm, tail);
1335               return 0;
1336             }
1337           b->flags = VLIB_BUFFER_NEXT_PRESENT;
1338           b->next_buffer = bi;
1339           b = vlib_get_buffer (vm, bi);
1340           len += data_size;
1341           n_buffers++;
1342         }
1343       sb = vlib_get_buffer (vm, first->next_buffer);
1344       to_free = first->next_buffer;
1345       first->next_buffer = tail;
1346     }
1347   else
1348     sb = vlib_get_buffer (vm, first->next_buffer);
1349
1350   src_left = sb->current_length;
1351   sp = vlib_buffer_get_current (sb);
1352   dp = vlib_buffer_get_tail (db);
1353
1354   while (bytes_left)
1355     {
1356       u16 bytes_to_copy;
1357
1358       if (dst_left == 0)
1359         {
1360           if (db != first)
1361             db->current_data = 0;
1362           db->current_length = dp - (u8 *) vlib_buffer_get_current (db);
1363           ASSERT (db->flags & VLIB_BUFFER_NEXT_PRESENT);
1364           db = vlib_get_buffer (vm, db->next_buffer);
1365           dst_left = data_size;
1366           dp = db->data;
1367         }
1368
1369       while (src_left == 0)
1370         {
1371           ASSERT (sb->flags & VLIB_BUFFER_NEXT_PRESENT);
1372           sb = vlib_get_buffer (vm, sb->next_buffer);
1373           src_left = sb->current_length;
1374           sp = vlib_buffer_get_current (sb);
1375         }
1376
1377       bytes_to_copy = clib_min (dst_left, src_left);
1378
1379       if (dp != sp)
1380         {
1381           if (sb == db)
1382             bytes_to_copy = clib_min (bytes_to_copy, sp - dp);
1383
1384           clib_memcpy_fast (dp, sp, bytes_to_copy);
1385         }
1386
1387       src_left -= bytes_to_copy;
1388       dst_left -= bytes_to_copy;
1389       dp += bytes_to_copy;
1390       sp += bytes_to_copy;
1391       bytes_left -= bytes_to_copy;
1392     }
1393   if (db != first)
1394     db->current_data = 0;
1395   db->current_length = dp - (u8 *) vlib_buffer_get_current (db);
1396
1397   if (is_cloned && to_free)
1398     vlib_buffer_free_one (vm, to_free);
1399   else
1400     {
1401       if (db->flags & VLIB_BUFFER_NEXT_PRESENT)
1402         vlib_buffer_free_one (vm, db->next_buffer);
1403       db->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1404       b = first;
1405       n_buffers = 1;
1406       while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
1407         {
1408           b = vlib_get_buffer (vm, b->next_buffer);
1409           ++n_buffers;
1410         }
1411     }
1412
1413   first->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
1414
1415   return n_buffers;
1416 }
1417
1418 #endif /* included_vlib_buffer_funcs_h */
1419
1420 /*
1421  * fd.io coding-style-patch-verification: ON
1422  *
1423  * Local Variables:
1424  * eval: (c-set-style "gnu")
1425  * End:
1426  */