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 = bp->n_avail;
 495   if (PREDICT_TRUE (n_buffers < len))
 496     {
 497       len -= n_buffers;
 498       vlib_buffer_copy_indices (buffers, bp->buffers + len, n_buffers);
 499       bp->n_avail = 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       bp->n_avail = 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 = bpt->n_cached;
 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       bpt->n_cached -= 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   /* alloc bigger than cache - take buffers directly from main pool */
 552   if (n_buffers >= VLIB_BUFFER_POOL_PER_THREAD_CACHE_SZ)
 553     {
 554       n_buffers = vlib_buffer_pool_get (vm, buffer_pool_index, buffers,
 555                                         n_buffers);
 556
 557       if (CLIB_DEBUG > 0)
 558         vlib_buffer_validate_alloc_free (vm, buffers, n_buffers,
 559                                          VLIB_BUFFER_KNOWN_FREE);
 560       return n_buffers;
 561     }
 562
 563   /* take everything available in the cache */
 564   if (len)
 565     {
 566       vlib_buffer_copy_indices (dst, bpt->cached_buffers, len);
 567       bpt->n_cached = 0;
 568       dst += len;
 569       n_left -= len;
 570     }
 571
 572   len = round_pow2 (n_left, 32);
 573   len = vlib_buffer_pool_get (vm, buffer_pool_index, bpt->cached_buffers,
 574                               len);
 575   bpt->n_cached = len;
 576
 577   if (len)
 578     {
 579       u32 n_copy = clib_min (len, n_left);
 580       src = bpt->cached_buffers + len - n_copy;
 581       vlib_buffer_copy_indices (dst, src, n_copy);
 582       bpt->n_cached -= n_copy;
 583       n_left -= n_copy;
 584     }
 585
 586   n_buffers -= n_left;
 587
 588   /* Verify that buffers are known free. */
 589   if (CLIB_DEBUG > 0)
 590     vlib_buffer_validate_alloc_free (vm, buffers, n_buffers,
 591                                      VLIB_BUFFER_KNOWN_FREE);
 592
 593   return n_buffers;
 594 }
 595
 596 /** \brief Allocate buffers from specific numa node into supplied array
 597
 598     @param vm - (vlib_main_t *) vlib main data structure pointer
 599     @param buffers - (u32 * ) buffer index array
 600     @param n_buffers - (u32) number of buffers requested
 601     @param numa_node - (u32) numa node
 602     @return - (u32) number of buffers actually allocated, may be
 603     less than the number requested or zero
 604 */
 605 always_inline u32
 606 vlib_buffer_alloc_on_numa (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 607                            u32 numa_node)
 608 {
 609   u8 index = vlib_buffer_pool_get_default_for_numa (vm, numa_node);
 610   return vlib_buffer_alloc_from_pool (vm, buffers, n_buffers, index);
 611 }
 612
 613 /** \brief Allocate buffers into supplied array
 614
 615     @param vm - (vlib_main_t *) vlib main data structure pointer
 616     @param buffers - (u32 * ) buffer index array
 617     @param n_buffers - (u32) number of buffers requested
 618     @return - (u32) number of buffers actually allocated, may be
 619     less than the number requested or zero
 620 */
 621
 622 always_inline u32
 623 vlib_buffer_alloc (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
 624 {
 625   return vlib_buffer_alloc_on_numa (vm, buffers, n_buffers, vm->numa_node);
 626 }
 627
 628 /** \brief Allocate buffers into ring
 629
 630     @param vm - (vlib_main_t *) vlib main data structure pointer
 631     @param buffers - (u32 * ) buffer index ring
 632     @param start - (u32) first slot in the ring
 633     @param ring_size - (u32) ring size
 634     @param n_buffers - (u32) number of buffers requested
 635     @return - (u32) number of buffers actually allocated, may be
 636     less than the number requested or zero
 637 */
 638 always_inline u32
 639 vlib_buffer_alloc_to_ring (vlib_main_t * vm, u32 * ring, u32 start,
 640                            u32 ring_size, u32 n_buffers)
 641 {
 642   u32 n_alloc;
 643
 644   ASSERT (n_buffers <= ring_size);
 645
 646   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 647     return vlib_buffer_alloc (vm, ring + start, n_buffers);
 648
 649   n_alloc = vlib_buffer_alloc (vm, ring + start, ring_size - start);
 650
 651   if (PREDICT_TRUE (n_alloc == ring_size - start))
 652     n_alloc += vlib_buffer_alloc (vm, ring, n_buffers - n_alloc);
 653
 654   return n_alloc;
 655 }
 656
 657 /** \brief Allocate buffers into ring from specific buffer pool
 658
 659     @param vm - (vlib_main_t *) vlib main data structure pointer
 660     @param buffers - (u32 * ) buffer index ring
 661     @param start - (u32) first slot in the ring
 662     @param ring_size - (u32) ring size
 663     @param n_buffers - (u32) number of buffers requested
 664     @return - (u32) number of buffers actually allocated, may be
 665     less than the number requested or zero
 666 */
 667 always_inline u32
 668 vlib_buffer_alloc_to_ring_from_pool (vlib_main_t * vm, u32 * ring, u32 start,
 669                                      u32 ring_size, u32 n_buffers,
 670                                      u8 buffer_pool_index)
 671 {
 672   u32 n_alloc;
 673
 674   ASSERT (n_buffers <= ring_size);
 675
 676   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 677     return vlib_buffer_alloc_from_pool (vm, ring + start, n_buffers,
 678                                         buffer_pool_index);
 679
 680   n_alloc = vlib_buffer_alloc_from_pool (vm, ring + start, ring_size - start,
 681                                          buffer_pool_index);
 682
 683   if (PREDICT_TRUE (n_alloc == ring_size - start))
 684     n_alloc += vlib_buffer_alloc_from_pool (vm, ring, n_buffers - n_alloc,
 685                                             buffer_pool_index);
 686
 687   return n_alloc;
 688 }
 689
 690 static_always_inline void
 691 vlib_buffer_pool_put (vlib_main_t * vm, u8 buffer_pool_index,
 692                       u32 * buffers, u32 n_buffers)
 693 {
 694   vlib_buffer_pool_t *bp = vlib_get_buffer_pool (vm, buffer_pool_index);
 695   vlib_buffer_pool_thread_t *bpt = vec_elt_at_index (bp->threads,
 696                                                      vm->thread_index);
 697   u32 n_cached, n_empty;
 698
 699   if (CLIB_DEBUG > 0)
 700     vlib_buffer_validate_alloc_free (vm, buffers, n_buffers,
 701                                      VLIB_BUFFER_KNOWN_ALLOCATED);
 702
 703   n_cached = bpt->n_cached;
 704   n_empty = VLIB_BUFFER_POOL_PER_THREAD_CACHE_SZ - n_cached;
 705   if (n_buffers <= n_empty)
 706     {
 707       vlib_buffer_copy_indices (bpt->cached_buffers + n_cached,
 708                                 buffers, n_buffers);
 709       bpt->n_cached = n_cached + n_buffers;
 710       return;
 711     }
 712
 713   vlib_buffer_copy_indices (bpt->cached_buffers + n_cached,
 714                             buffers + n_buffers - n_empty, n_empty);
 715   bpt->n_cached = VLIB_BUFFER_POOL_PER_THREAD_CACHE_SZ;
 716
 717   clib_spinlock_lock (&bp->lock);
 718   vlib_buffer_copy_indices (bp->buffers + bp->n_avail, buffers,
 719                             n_buffers - n_empty);
 720   bp->n_avail += n_buffers - n_empty;
 721   clib_spinlock_unlock (&bp->lock);
 722 }
 723
 724 static_always_inline void
 725 vlib_buffer_free_inline (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 726                          int maybe_next)
 727 {
 728   const int queue_size = 128;
 729   vlib_buffer_pool_t *bp = 0;
 730   u8 buffer_pool_index = ~0;
 731   u32 n_queue = 0, queue[queue_size + 4];
 732   vlib_buffer_t bt = { };
 733 #if defined(CLIB_HAVE_VEC128)
 734   vlib_buffer_t bpi_mask = {.buffer_pool_index = ~0 };
 735   vlib_buffer_t bpi_vec = {.buffer_pool_index = ~0 };
 736   vlib_buffer_t flags_refs_mask = {
 737     .flags = VLIB_BUFFER_NEXT_PRESENT,
 738     .ref_count = ~1
 739   };
 740 #endif
 741
 742   while (n_buffers)
 743     {
 744       vlib_buffer_t *b[8];
 745       u32 bi, sum = 0, flags, next;
 746
 747       if (n_buffers < 12)
 748         goto one_by_one;
 749
 750       vlib_get_buffers (vm, buffers, b, 4);
 751       vlib_get_buffers (vm, buffers + 8, b + 4, 4);
 752
 753       vlib_prefetch_buffer_header (b[4], LOAD);
 754       vlib_prefetch_buffer_header (b[5], LOAD);
 755       vlib_prefetch_buffer_header (b[6], LOAD);
 756       vlib_prefetch_buffer_header (b[7], LOAD);
 757
 758 #if defined(CLIB_HAVE_VEC128)
 759       u8x16 p0, p1, p2, p3, r;
 760       p0 = u8x16_load_unaligned (b[0]);
 761       p1 = u8x16_load_unaligned (b[1]);
 762       p2 = u8x16_load_unaligned (b[2]);
 763       p3 = u8x16_load_unaligned (b[3]);
 764
 765       r = p0 ^ bpi_vec.as_u8x16[0];
 766       r |= p1 ^ bpi_vec.as_u8x16[0];
 767       r |= p2 ^ bpi_vec.as_u8x16[0];
 768       r |= p3 ^ bpi_vec.as_u8x16[0];
 769       r &= bpi_mask.as_u8x16[0];
 770       r |= (p0 | p1 | p2 | p3) & flags_refs_mask.as_u8x16[0];
 771
 772       sum = !u8x16_is_all_zero (r);
 773 #else
 774       sum |= b[0]->flags;
 775       sum |= b[1]->flags;
 776       sum |= b[2]->flags;
 777       sum |= b[3]->flags;
 778       sum &= VLIB_BUFFER_NEXT_PRESENT;
 779       sum += b[0]->ref_count - 1;
 780       sum += b[1]->ref_count - 1;
 781       sum += b[2]->ref_count - 1;
 782       sum += b[3]->ref_count - 1;
 783       sum |= b[0]->buffer_pool_index ^ buffer_pool_index;
 784       sum |= b[1]->buffer_pool_index ^ buffer_pool_index;
 785       sum |= b[2]->buffer_pool_index ^ buffer_pool_index;
 786       sum |= b[3]->buffer_pool_index ^ buffer_pool_index;
 787 #endif
 788
 789       if (sum)
 790         goto one_by_one;
 791
 792       vlib_buffer_copy_indices (queue + n_queue, buffers, 4);
 793       vlib_buffer_copy_template (b[0], &bt);
 794       vlib_buffer_copy_template (b[1], &bt);
 795       vlib_buffer_copy_template (b[2], &bt);
 796       vlib_buffer_copy_template (b[3], &bt);
 797       n_queue += 4;
 798
 799       vlib_buffer_validate (vm, b[0]);
 800       vlib_buffer_validate (vm, b[1]);
 801       vlib_buffer_validate (vm, b[2]);
 802       vlib_buffer_validate (vm, b[3]);
 803
 804       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 805       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
 806       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]);
 807       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]);
 808
 809       if (n_queue >= queue_size)
 810         {
 811           vlib_buffer_pool_put (vm, buffer_pool_index, queue, n_queue);
 812           n_queue = 0;
 813         }
 814       buffers += 4;
 815       n_buffers -= 4;
 816       continue;
 817
 818     one_by_one:
 819       bi = buffers[0];
 820
 821     next_in_chain:
 822       b[0] = vlib_get_buffer (vm, bi);
 823       flags = b[0]->flags;
 824       next = b[0]->next_buffer;
 825
 826       if (PREDICT_FALSE (buffer_pool_index != b[0]->buffer_pool_index))
 827         {
 828
 829           if (n_queue)
 830             {
 831               vlib_buffer_pool_put (vm, buffer_pool_index, queue, n_queue);
 832               n_queue = 0;
 833             }
 834
 835           buffer_pool_index = b[0]->buffer_pool_index;
 836 #if defined(CLIB_HAVE_VEC128)
 837           bpi_vec.buffer_pool_index = buffer_pool_index;
 838 #endif
 839           bp = vlib_get_buffer_pool (vm, buffer_pool_index);
 840           vlib_buffer_copy_template (&bt, &bp->buffer_template);
 841         }
 842
 843       vlib_buffer_validate (vm, b[0]);
 844
 845       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 846
 847       if (clib_atomic_sub_fetch (&b[0]->ref_count, 1) == 0)
 848         {
 849           vlib_buffer_copy_template (b[0], &bt);
 850           queue[n_queue++] = bi;
 851         }
 852
 853       if (n_queue == queue_size)
 854         {
 855           vlib_buffer_pool_put (vm, buffer_pool_index, queue, queue_size);
 856           n_queue = 0;
 857         }
 858
 859       if (maybe_next && (flags & VLIB_BUFFER_NEXT_PRESENT))
 860         {
 861           bi = next;
 862           goto next_in_chain;
 863         }
 864
 865       buffers++;
 866       n_buffers--;
 867     }
 868
 869   if (n_queue)
 870     vlib_buffer_pool_put (vm, buffer_pool_index, queue, n_queue);
 871 }
 872
 873
 874 /** \brief Free buffers
 875     Frees the entire buffer chain for each buffer
 876
 877     @param vm - (vlib_main_t *) vlib main data structure pointer
 878     @param buffers - (u32 * ) buffer index array
 879     @param n_buffers - (u32) number of buffers to free
 880
 881 */
 882 always_inline void
 883 vlib_buffer_free (vlib_main_t * vm,
 884                   /* pointer to first buffer */
 885                   u32 * buffers,
 886                   /* number of buffers to free */
 887                   u32 n_buffers)
 888 {
 889   vlib_buffer_free_inline (vm, buffers, n_buffers, /* maybe next */ 1);
 890 }
 891
 892 /** \brief Free buffers, does not free the buffer chain for each buffer
 893
 894     @param vm - (vlib_main_t *) vlib main data structure pointer
 895     @param buffers - (u32 * ) buffer index array
 896     @param n_buffers - (u32) number of buffers to free
 897
 898 */
 899 always_inline void
 900 vlib_buffer_free_no_next (vlib_main_t * vm,
 901                           /* pointer to first buffer */
 902                           u32 * buffers,
 903                           /* number of buffers to free */
 904                           u32 n_buffers)
 905 {
 906   vlib_buffer_free_inline (vm, buffers, n_buffers, /* maybe next */ 0);
 907 }
 908
 909 /** \brief Free one buffer
 910     Shorthand to free a single buffer chain.
 911
 912     @param vm - (vlib_main_t *) vlib main data structure pointer
 913     @param buffer_index - (u32) buffer index to free
 914 */
 915 always_inline void
 916 vlib_buffer_free_one (vlib_main_t * vm, u32 buffer_index)
 917 {
 918   vlib_buffer_free_inline (vm, &buffer_index, 1, /* maybe next */ 1);
 919 }
 920
 921 /** \brief Free buffers from ring
 922
 923     @param vm - (vlib_main_t *) vlib main data structure pointer
 924     @param buffers - (u32 * ) buffer index ring
 925     @param start - (u32) first slot in the ring
 926     @param ring_size - (u32) ring size
 927     @param n_buffers - (u32) number of buffers
 928 */
 929 always_inline void
 930 vlib_buffer_free_from_ring (vlib_main_t * vm, u32 * ring, u32 start,
 931                             u32 ring_size, u32 n_buffers)
 932 {
 933   ASSERT (n_buffers <= ring_size);
 934
 935   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 936     {
 937       vlib_buffer_free (vm, ring + start, n_buffers);
 938     }
 939   else
 940     {
 941       vlib_buffer_free (vm, ring + start, ring_size - start);
 942       vlib_buffer_free (vm, ring, n_buffers - (ring_size - start));
 943     }
 944 }
 945
 946 /** \brief Free buffers from ring without freeing tail buffers
 947
 948     @param vm - (vlib_main_t *) vlib main data structure pointer
 949     @param buffers - (u32 * ) buffer index ring
 950     @param start - (u32) first slot in the ring
 951     @param ring_size - (u32) ring size
 952     @param n_buffers - (u32) number of buffers
 953 */
 954 always_inline void
 955 vlib_buffer_free_from_ring_no_next (vlib_main_t * vm, u32 * ring, u32 start,
 956                                     u32 ring_size, u32 n_buffers)
 957 {
 958   ASSERT (n_buffers <= ring_size);
 959
 960   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 961     {
 962       vlib_buffer_free_no_next (vm, ring + start, n_buffers);
 963     }
 964   else
 965     {
 966       vlib_buffer_free_no_next (vm, ring + start, ring_size - start);
 967       vlib_buffer_free_no_next (vm, ring, n_buffers - (ring_size - start));
 968     }
 969 }
 970
 971 /* Append given data to end of buffer, possibly allocating new buffers. */
 972 int vlib_buffer_add_data (vlib_main_t * vm, u32 * buffer_index, void *data,
 973                           u32 n_data_bytes);
 974
 975 /* Define vlib_buffer and vnet_buffer flags bits preserved for copy/clone */
 976 #define VLIB_BUFFER_COPY_CLONE_FLAGS_MASK                       \
 977   (VLIB_BUFFER_NEXT_PRESENT | VLIB_BUFFER_TOTAL_LENGTH_VALID |  \
 978    VLIB_BUFFER_IS_TRACED | ~VLIB_BUFFER_FLAGS_ALL)
 979
 980 /* duplicate all buffers in chain */
 981 always_inline vlib_buffer_t *
 982 vlib_buffer_copy (vlib_main_t * vm, vlib_buffer_t * b)
 983 {
 984   vlib_buffer_t *s, *d, *fd;
 985   uword n_alloc, n_buffers = 1;
 986   u32 flag_mask = VLIB_BUFFER_COPY_CLONE_FLAGS_MASK;
 987   int i;
 988
 989   s = b;
 990   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
 991     {
 992       n_buffers++;
 993       s = vlib_get_buffer (vm, s->next_buffer);
 994     }
 995   u32 new_buffers[n_buffers];
 996
 997   n_alloc = vlib_buffer_alloc (vm, new_buffers, n_buffers);
 998
 999   /* No guarantee that we'll get all the buffers we asked for */
1000   if (PREDICT_FALSE (n_alloc < n_buffers))
1001     {
1002       if (n_alloc > 0)
1003         vlib_buffer_free (vm, new_buffers, n_alloc);
1004       return 0;
1005     }
1006
1007   /* 1st segment */
1008   s = b;
1009   fd = d = vlib_get_buffer (vm, new_buffers[0]);
1010   d->current_data = s->current_data;
1011   d->current_length = s->current_length;
1012   d->flags = s->flags & flag_mask;
1013   d->trace_handle = s->trace_handle;
1014   d->total_length_not_including_first_buffer =
1015     s->total_length_not_including_first_buffer;
1016   clib_memcpy_fast (d->opaque, s->opaque, sizeof (s->opaque));
1017   clib_memcpy_fast (d->opaque2, s->opaque2, sizeof (s->opaque2));
1018   clib_memcpy_fast (vlib_buffer_get_current (d),
1019                     vlib_buffer_get_current (s), s->current_length);
1020
1021   /* next segments */
1022   for (i = 1; i < n_buffers; i++)
1023     {
1024       /* previous */
1025       d->next_buffer = new_buffers[i];
1026       /* current */
1027       s = vlib_get_buffer (vm, s->next_buffer);
1028       d = vlib_get_buffer (vm, new_buffers[i]);
1029       d->current_data = s->current_data;
1030       d->current_length = s->current_length;
1031       clib_memcpy_fast (vlib_buffer_get_current (d),
1032                         vlib_buffer_get_current (s), s->current_length);
1033       d->flags = s->flags & flag_mask;
1034     }
1035
1036   return fd;
1037 }
1038
1039 /* duplicate first buffer in chain */
1040 always_inline vlib_buffer_t *
1041 vlib_buffer_copy_no_chain (vlib_main_t * vm, vlib_buffer_t * b, u32 * di)
1042 {
1043   vlib_buffer_t *d;
1044
1045   if ((vlib_buffer_alloc (vm, di, 1)) != 1)
1046     return 0;
1047
1048   d = vlib_get_buffer (vm, *di);
1049   /* 1st segment */
1050   d->current_data = b->current_data;
1051   d->current_length = b->current_length;
1052   clib_memcpy_fast (d->opaque, b->opaque, sizeof (b->opaque));
1053   clib_memcpy_fast (d->opaque2, b->opaque2, sizeof (b->opaque2));
1054   clib_memcpy_fast (vlib_buffer_get_current (d),
1055                     vlib_buffer_get_current (b), b->current_length);
1056
1057   return d;
1058 }
1059
1060 /*  \brief Move packet from current position to offset position in buffer.
1061     Only work for small packet using one buffer with room to fit the move
1062     @param vm - (vlib_main_t *) vlib main data structure pointer
1063     @param b -  (vlib_buffer_t *) pointer to buffer
1064     @param offset - (i16) position to move the packet in buffer
1065  */
1066 always_inline void
1067 vlib_buffer_move (vlib_main_t * vm, vlib_buffer_t * b, i16 offset)
1068 {
1069   ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
1070   ASSERT (offset + VLIB_BUFFER_PRE_DATA_SIZE >= 0);
1071   ASSERT (offset + b->current_length <
1072           vlib_buffer_get_default_data_size (vm));
1073
1074   u8 *source = vlib_buffer_get_current (b);
1075   b->current_data = offset;
1076   u8 *destination = vlib_buffer_get_current (b);
1077   u16 length = b->current_length;
1078
1079   if (source + length <= destination)   /* no overlap */
1080     clib_memcpy_fast (destination, source, length);
1081   else
1082     memmove (destination, source, length);
1083 }
1084
1085 /** \brief Create a maximum of 256 clones of buffer and store them
1086     in the supplied array
1087
1088     @param vm - (vlib_main_t *) vlib main data structure pointer
1089     @param src_buffer - (u32) source buffer index
1090     @param buffers - (u32 * ) buffer index array
1091     @param n_buffers - (u16) number of buffer clones requested (<=256)
1092     @param head_end_offset - (u16) offset relative to current position
1093            where packet head ends
1094     @param offset - (i16) copy packet head at current position if 0,
1095            else at offset position to change headroom space as specified
1096     @return - (u16) number of buffers actually cloned, may be
1097     less than the number requested or zero
1098 */
1099 always_inline u16
1100 vlib_buffer_clone_256 (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1101                        u16 n_buffers, u16 head_end_offset, i16 offset)
1102 {
1103   u16 i;
1104   vlib_buffer_t *s = vlib_get_buffer (vm, src_buffer);
1105
1106   ASSERT (s->ref_count == 1);
1107   ASSERT (n_buffers);
1108   ASSERT (n_buffers <= 256);
1109   ASSERT (offset + VLIB_BUFFER_PRE_DATA_SIZE >= 0);
1110   ASSERT ((offset + head_end_offset) <
1111           vlib_buffer_get_default_data_size (vm));
1112
1113   if (s->current_length <= head_end_offset + CLIB_CACHE_LINE_BYTES * 2)
1114     {
1115       buffers[0] = src_buffer;
1116       if (offset)
1117         vlib_buffer_move (vm, s, offset);
1118
1119       for (i = 1; i < n_buffers; i++)
1120         {
1121           vlib_buffer_t *d;
1122           d = vlib_buffer_copy (vm, s);
1123           if (d == 0)
1124             return i;
1125           buffers[i] = vlib_get_buffer_index (vm, d);
1126
1127         }
1128       return n_buffers;
1129     }
1130
1131   if (PREDICT_FALSE ((n_buffers == 1) && (offset == 0)))
1132     {
1133       buffers[0] = src_buffer;
1134       return 1;
1135     }
1136
1137   n_buffers = vlib_buffer_alloc_from_pool (vm, buffers, n_buffers,
1138                                            s->buffer_pool_index);
1139
1140   for (i = 0; i < n_buffers; i++)
1141     {
1142       vlib_buffer_t *d = vlib_get_buffer (vm, buffers[i]);
1143       if (offset)
1144         d->current_data = offset;
1145       else
1146         d->current_data = s->current_data;
1147
1148       d->current_length = head_end_offset;
1149       ASSERT (d->buffer_pool_index == s->buffer_pool_index);
1150
1151       d->total_length_not_including_first_buffer = s->current_length -
1152         head_end_offset;
1153       if (PREDICT_FALSE (s->flags & VLIB_BUFFER_NEXT_PRESENT))
1154         {
1155           d->total_length_not_including_first_buffer +=
1156             s->total_length_not_including_first_buffer;
1157         }
1158       d->flags = (s->flags & VLIB_BUFFER_COPY_CLONE_FLAGS_MASK) |
1159         VLIB_BUFFER_NEXT_PRESENT;
1160       d->trace_handle = s->trace_handle;
1161       clib_memcpy_fast (d->opaque, s->opaque, sizeof (s->opaque));
1162       clib_memcpy_fast (d->opaque2, s->opaque2, sizeof (s->opaque2));
1163       clib_memcpy_fast (vlib_buffer_get_current (d),
1164                         vlib_buffer_get_current (s), head_end_offset);
1165       d->next_buffer = src_buffer;
1166     }
1167   vlib_buffer_advance (s, head_end_offset);
1168   s->ref_count = n_buffers;
1169   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
1170     {
1171       s = vlib_get_buffer (vm, s->next_buffer);
1172       s->ref_count = n_buffers;
1173     }
1174
1175   return n_buffers;
1176 }
1177
1178 /** \brief Create multiple clones of buffer and store them
1179     in the supplied array
1180
1181     @param vm - (vlib_main_t *) vlib main data structure pointer
1182     @param src_buffer - (u32) source buffer index
1183     @param buffers - (u32 * ) buffer index array
1184     @param n_buffers - (u16) number of buffer clones requested (<=256)
1185     @param head_end_offset - (u16) offset relative to current position
1186            where packet head ends
1187     @param offset - (i16) copy packet head at current position if 0,
1188            else at offset position to change headroom space as specified
1189     @return - (u16) number of buffers actually cloned, may be
1190     less than the number requested or zero
1191 */
1192 always_inline u16
1193 vlib_buffer_clone_at_offset (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1194                              u16 n_buffers, u16 head_end_offset, i16 offset)
1195 {
1196   vlib_buffer_t *s = vlib_get_buffer (vm, src_buffer);
1197   u16 n_cloned = 0;
1198
1199   while (n_buffers > 256)
1200     {
1201       vlib_buffer_t *copy;
1202       copy = vlib_buffer_copy (vm, s);
1203       n_cloned += vlib_buffer_clone_256 (vm,
1204                                          vlib_get_buffer_index (vm, copy),
1205                                          (buffers + n_cloned),
1206                                          256, head_end_offset, offset);
1207       n_buffers -= 256;
1208     }
1209   n_cloned += vlib_buffer_clone_256 (vm, src_buffer,
1210                                      buffers + n_cloned,
1211                                      n_buffers, head_end_offset, offset);
1212
1213   return n_cloned;
1214 }
1215
1216 /** \brief Create multiple clones of buffer and store them
1217     in the supplied array
1218
1219     @param vm - (vlib_main_t *) vlib main data structure pointer
1220     @param src_buffer - (u32) source buffer index
1221     @param buffers - (u32 * ) buffer index array
1222     @param n_buffers - (u16) number of buffer clones requested (<=256)
1223     @param head_end_offset - (u16) offset relative to current position
1224            where packet head ends
1225     @return - (u16) number of buffers actually cloned, may be
1226     less than the number requested or zero
1227 */
1228 always_inline u16
1229 vlib_buffer_clone (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1230                    u16 n_buffers, u16 head_end_offset)
1231 {
1232   return vlib_buffer_clone_at_offset (vm, src_buffer, buffers, n_buffers,
1233                                       head_end_offset, 0);
1234 }
1235
1236 /** \brief Attach cloned tail to the buffer
1237
1238     @param vm - (vlib_main_t *) vlib main data structure pointer
1239     @param head - (vlib_buffer_t *) head buffer
1240     @param tail - (Vlib buffer_t *) tail buffer to clone and attach to head
1241 */
1242
1243 always_inline void
1244 vlib_buffer_attach_clone (vlib_main_t * vm, vlib_buffer_t * head,
1245                           vlib_buffer_t * tail)
1246 {
1247   ASSERT ((head->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
1248   ASSERT (head->buffer_pool_index == tail->buffer_pool_index);
1249
1250   head->flags |= VLIB_BUFFER_NEXT_PRESENT;
1251   head->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
1252   head->flags &= ~VLIB_BUFFER_EXT_HDR_VALID;
1253   head->flags |= (tail->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID);
1254   head->next_buffer = vlib_get_buffer_index (vm, tail);
1255   head->total_length_not_including_first_buffer = tail->current_length +
1256     tail->total_length_not_including_first_buffer;
1257
1258 next_segment:
1259   clib_atomic_add_fetch (&tail->ref_count, 1);
1260
1261   if (tail->flags & VLIB_BUFFER_NEXT_PRESENT)
1262     {
1263       tail = vlib_get_buffer (vm, tail->next_buffer);
1264       goto next_segment;
1265     }
1266 }
1267
1268 /* Initializes the buffer as an empty packet with no chained buffers. */
1269 always_inline void
1270 vlib_buffer_chain_init (vlib_buffer_t * first)
1271 {
1272   first->total_length_not_including_first_buffer = 0;
1273   first->current_length = 0;
1274   first->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1275   first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
1276 }
1277
1278 /* The provided next_bi buffer index is appended to the end of the packet. */
1279 always_inline vlib_buffer_t *
1280 vlib_buffer_chain_buffer (vlib_main_t * vm, vlib_buffer_t * last, u32 next_bi)
1281 {
1282   vlib_buffer_t *next_buffer = vlib_get_buffer (vm, next_bi);
1283   last->next_buffer = next_bi;
1284   last->flags |= VLIB_BUFFER_NEXT_PRESENT;
1285   next_buffer->current_length = 0;
1286   next_buffer->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1287   return next_buffer;
1288 }
1289
1290 /* Increases or decreases the packet length.
1291  * It does not allocate or deallocate new buffers.
1292  * Therefore, the added length must be compatible
1293  * with the last buffer. */
1294 always_inline void
1295 vlib_buffer_chain_increase_length (vlib_buffer_t * first,
1296                                    vlib_buffer_t * last, i32 len)
1297 {
1298   last->current_length += len;
1299   if (first != last)
1300     first->total_length_not_including_first_buffer += len;
1301 }
1302
1303 /* Copy data to the end of the packet and increases its length.
1304  * It does not allocate new buffers.
1305  * Returns the number of copied bytes. */
1306 always_inline u16
1307 vlib_buffer_chain_append_data (vlib_main_t * vm,
1308                                vlib_buffer_t * first,
1309                                vlib_buffer_t * last, void *data, u16 data_len)
1310 {
1311   u32 n_buffer_bytes = vlib_buffer_get_default_data_size (vm);
1312   ASSERT (n_buffer_bytes >= last->current_length + last->current_data);
1313   u16 len = clib_min (data_len,
1314                       n_buffer_bytes - last->current_length -
1315                       last->current_data);
1316   clib_memcpy_fast (vlib_buffer_get_current (last) + last->current_length,
1317                     data, len);
1318   vlib_buffer_chain_increase_length (first, last, len);
1319   return len;
1320 }
1321
1322 /* Copy data to the end of the packet and increases its length.
1323  * Allocates additional buffers from the free list if necessary.
1324  * Returns the number of copied bytes.
1325  * 'last' value is modified whenever new buffers are allocated and
1326  * chained and points to the last buffer in the chain. */
1327 u16
1328 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
1329                                           vlib_buffer_t * first,
1330                                           vlib_buffer_t ** last, void *data,
1331                                           u16 data_len);
1332 void vlib_buffer_chain_validate (vlib_main_t * vm, vlib_buffer_t * first);
1333
1334 format_function_t format_vlib_buffer, format_vlib_buffer_and_data,
1335   format_vlib_buffer_contents, format_vlib_buffer_no_chain;
1336
1337 typedef struct
1338 {
1339   /* Vector of packet data. */
1340   u8 *packet_data;
1341
1342   /* Number of buffers to allocate in each call to allocator. */
1343   u32 min_n_buffers_each_alloc;
1344
1345   u8 *name;
1346 } vlib_packet_template_t;
1347
1348 void vlib_packet_template_init (vlib_main_t * vm,
1349                                 vlib_packet_template_t * t,
1350                                 void *packet_data,
1351                                 uword n_packet_data_bytes,
1352                                 uword min_n_buffers_each_alloc,
1353                                 char *fmt, ...);
1354
1355 void *vlib_packet_template_get_packet (vlib_main_t * vm,
1356                                        vlib_packet_template_t * t,
1357                                        u32 * bi_result);
1358
1359 always_inline void
1360 vlib_packet_template_free (vlib_main_t * vm, vlib_packet_template_t * t)
1361 {
1362   vec_free (t->packet_data);
1363 }
1364
1365 always_inline u32
1366 vlib_buffer_space_left_at_end (vlib_main_t * vm, vlib_buffer_t * b)
1367 {
1368   return b->data + vlib_buffer_get_default_data_size (vm) -
1369     ((u8 *) vlib_buffer_get_current (b) + b->current_length);
1370 }
1371
1372 always_inline u32
1373 vlib_buffer_chain_linearize (vlib_main_t * vm, vlib_buffer_t * b)
1374 {
1375   vlib_buffer_t *db = b, *sb, *first = b;
1376   int is_cloned = 0;
1377   u32 bytes_left = 0, data_size;
1378   u16 src_left, dst_left, n_buffers = 1;
1379   u8 *dp, *sp;
1380   u32 to_free = 0;
1381
1382   if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0))
1383     return 1;
1384
1385   data_size = vlib_buffer_get_default_data_size (vm);
1386
1387   dst_left = vlib_buffer_space_left_at_end (vm, b);
1388
1389   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
1390     {
1391       b = vlib_get_buffer (vm, b->next_buffer);
1392       if (b->ref_count > 1)
1393         is_cloned = 1;
1394       bytes_left += b->current_length;
1395       n_buffers++;
1396     }
1397
1398   /* if buffer is cloned, create completely new chain - unless everything fits
1399    * into one buffer */
1400   if (is_cloned && bytes_left >= dst_left)
1401     {
1402       u32 len = 0;
1403       u32 space_needed = bytes_left - dst_left;
1404       u32 tail;
1405
1406       if (vlib_buffer_alloc (vm, &tail, 1) == 0)
1407         return 0;
1408
1409       ++n_buffers;
1410       len += data_size;
1411       b = vlib_get_buffer (vm, tail);
1412
1413       while (len < space_needed)
1414         {
1415           u32 bi;
1416           if (vlib_buffer_alloc (vm, &bi, 1) == 0)
1417             {
1418               vlib_buffer_free_one (vm, tail);
1419               return 0;
1420             }
1421           b->flags = VLIB_BUFFER_NEXT_PRESENT;
1422           b->next_buffer = bi;
1423           b = vlib_get_buffer (vm, bi);
1424           len += data_size;
1425           n_buffers++;
1426         }
1427       sb = vlib_get_buffer (vm, first->next_buffer);
1428       to_free = first->next_buffer;
1429       first->next_buffer = tail;
1430     }
1431   else
1432     sb = vlib_get_buffer (vm, first->next_buffer);
1433
1434   src_left = sb->current_length;
1435   sp = vlib_buffer_get_current (sb);
1436   dp = vlib_buffer_get_tail (db);
1437
1438   while (bytes_left)
1439     {
1440       u16 bytes_to_copy;
1441
1442       if (dst_left == 0)
1443         {
1444           db->current_length = dp - (u8 *) vlib_buffer_get_current (db);
1445           ASSERT (db->flags & VLIB_BUFFER_NEXT_PRESENT);
1446           db = vlib_get_buffer (vm, db->next_buffer);
1447           dst_left = data_size;
1448           if (db->current_data > 0)
1449             {
1450               db->current_data = 0;
1451             }
1452           else
1453             {
1454               dst_left += -db->current_data;
1455             }
1456           dp = vlib_buffer_get_current (db);
1457         }
1458
1459       while (src_left == 0)
1460         {
1461           ASSERT (sb->flags & VLIB_BUFFER_NEXT_PRESENT);
1462           sb = vlib_get_buffer (vm, sb->next_buffer);
1463           src_left = sb->current_length;
1464           sp = vlib_buffer_get_current (sb);
1465         }
1466
1467       bytes_to_copy = clib_min (dst_left, src_left);
1468
1469       if (dp != sp)
1470         {
1471           if (sb == db)
1472             bytes_to_copy = clib_min (bytes_to_copy, sp - dp);
1473
1474           clib_memcpy_fast (dp, sp, bytes_to_copy);
1475         }
1476
1477       src_left -= bytes_to_copy;
1478       dst_left -= bytes_to_copy;
1479       dp += bytes_to_copy;
1480       sp += bytes_to_copy;
1481       bytes_left -= bytes_to_copy;
1482     }
1483   if (db != first)
1484     db->current_data = 0;
1485   db->current_length = dp - (u8 *) vlib_buffer_get_current (db);
1486
1487   if (is_cloned && to_free)
1488     vlib_buffer_free_one (vm, to_free);
1489   else
1490     {
1491       if (db->flags & VLIB_BUFFER_NEXT_PRESENT)
1492         vlib_buffer_free_one (vm, db->next_buffer);
1493       db->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1494       b = first;
1495       n_buffers = 1;
1496       while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
1497         {
1498           b = vlib_get_buffer (vm, b->next_buffer);
1499           ++n_buffers;
1500         }
1501     }
1502
1503   first->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
1504
1505   return n_buffers;
1506 }
1507
1508 #endif /* included_vlib_buffer_funcs_h */
1509
1510 /*
1511  * fd.io coding-style-patch-verification: ON
1512  *
1513  * Local Variables:
1514  * eval: (c-set-style "gnu")
1515  * End:
1516  */