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)
 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)
 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)
 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 (maybe_next && (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 /* Define vlib_buffer and vnet_buffer flags bits preserved for copy/clone */
 958 #define VLIB_BUFFER_COPY_CLONE_FLAGS_MASK                       \
 959   (VLIB_BUFFER_NEXT_PRESENT | VLIB_BUFFER_TOTAL_LENGTH_VALID |  \
 960    VLIB_BUFFER_IS_TRACED | ~VLIB_BUFFER_FLAGS_ALL)
 961
 962 /* duplicate all buffers in chain */
 963 always_inline vlib_buffer_t *
 964 vlib_buffer_copy (vlib_main_t * vm, vlib_buffer_t * b)
 965 {
 966   vlib_buffer_t *s, *d, *fd;
 967   uword n_alloc, n_buffers = 1;
 968   u32 flag_mask = VLIB_BUFFER_COPY_CLONE_FLAGS_MASK;
 969   int i;
 970
 971   s = b;
 972   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
 973     {
 974       n_buffers++;
 975       s = vlib_get_buffer (vm, s->next_buffer);
 976     }
 977   u32 new_buffers[n_buffers];
 978
 979   n_alloc = vlib_buffer_alloc (vm, new_buffers, n_buffers);
 980
 981   /* No guarantee that we'll get all the buffers we asked for */
 982   if (PREDICT_FALSE (n_alloc < n_buffers))
 983     {
 984       if (n_alloc > 0)
 985         vlib_buffer_free (vm, new_buffers, n_alloc);
 986       return 0;
 987     }
 988
 989   /* 1st segment */
 990   s = b;
 991   fd = d = vlib_get_buffer (vm, new_buffers[0]);
 992   d->current_data = s->current_data;
 993   d->current_length = s->current_length;
 994   d->flags = s->flags & flag_mask;
 995   d->total_length_not_including_first_buffer =
 996     s->total_length_not_including_first_buffer;
 997   clib_memcpy_fast (d->opaque, s->opaque, sizeof (s->opaque));
 998   clib_memcpy_fast (d->opaque2, s->opaque2, sizeof (s->opaque2));
 999   clib_memcpy_fast (vlib_buffer_get_current (d),
1000                     vlib_buffer_get_current (s), s->current_length);
1001
1002   /* next segments */
1003   for (i = 1; i < n_buffers; i++)
1004     {
1005       /* previous */
1006       d->next_buffer = new_buffers[i];
1007       /* current */
1008       s = vlib_get_buffer (vm, s->next_buffer);
1009       d = vlib_get_buffer (vm, new_buffers[i]);
1010       d->current_data = s->current_data;
1011       d->current_length = s->current_length;
1012       clib_memcpy_fast (vlib_buffer_get_current (d),
1013                         vlib_buffer_get_current (s), s->current_length);
1014       d->flags = s->flags & flag_mask;
1015     }
1016
1017   return fd;
1018 }
1019
1020 /* duplicate first buffer in chain */
1021 always_inline vlib_buffer_t *
1022 vlib_buffer_copy_no_chain (vlib_main_t * vm, vlib_buffer_t * b, u32 * di)
1023 {
1024   vlib_buffer_t *d;
1025
1026   if ((vlib_buffer_alloc (vm, di, 1)) != 1)
1027     return 0;
1028
1029   d = vlib_get_buffer (vm, *di);
1030   /* 1st segment */
1031   d->current_data = b->current_data;
1032   d->current_length = b->current_length;
1033   clib_memcpy_fast (d->opaque, b->opaque, sizeof (b->opaque));
1034   clib_memcpy_fast (d->opaque2, b->opaque2, sizeof (b->opaque2));
1035   clib_memcpy_fast (vlib_buffer_get_current (d),
1036                     vlib_buffer_get_current (b), b->current_length);
1037
1038   return d;
1039 }
1040
1041 /*  \brief Move packet from current position to offset position in buffer.
1042     Only work for small packet using one buffer with room to fit the move
1043     @param vm - (vlib_main_t *) vlib main data structure pointer
1044     @param b -  (vlib_buffer_t *) pointer to buffer
1045     @param offset - (i16) position to move the packet in buffer
1046  */
1047 always_inline void
1048 vlib_buffer_move (vlib_main_t * vm, vlib_buffer_t * b, i16 offset)
1049 {
1050   ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
1051   ASSERT (offset + VLIB_BUFFER_PRE_DATA_SIZE >= 0);
1052   ASSERT (offset + b->current_length <
1053           vlib_buffer_get_default_data_size (vm));
1054
1055   u8 *source = vlib_buffer_get_current (b);
1056   b->current_data = offset;
1057   u8 *destination = vlib_buffer_get_current (b);
1058   u16 length = b->current_length;
1059
1060   if (source + length <= destination)   /* no overlap */
1061     clib_memcpy_fast (destination, source, length);
1062   else
1063     memmove (destination, source, length);
1064 }
1065
1066 /** \brief Create a maximum of 256 clones of buffer and store them
1067     in the supplied array
1068
1069     @param vm - (vlib_main_t *) vlib main data structure pointer
1070     @param src_buffer - (u32) source buffer index
1071     @param buffers - (u32 * ) buffer index array
1072     @param n_buffers - (u16) number of buffer clones requested (<=256)
1073     @param head_end_offset - (u16) offset relative to current position
1074            where packet head ends
1075     @param offset - (i16) copy packet head at current position if 0,
1076            else at offset position to change headroom space as specified
1077     @return - (u16) number of buffers actually cloned, may be
1078     less than the number requested or zero
1079 */
1080 always_inline u16
1081 vlib_buffer_clone_256 (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1082                        u16 n_buffers, u16 head_end_offset, i16 offset)
1083 {
1084   u16 i;
1085   vlib_buffer_t *s = vlib_get_buffer (vm, src_buffer);
1086
1087   ASSERT (s->ref_count == 1);
1088   ASSERT (n_buffers);
1089   ASSERT (n_buffers <= 256);
1090   ASSERT (offset + VLIB_BUFFER_PRE_DATA_SIZE >= 0);
1091   ASSERT ((offset + head_end_offset) <
1092           vlib_buffer_get_default_data_size (vm));
1093
1094   if (s->current_length <= head_end_offset + CLIB_CACHE_LINE_BYTES * 2)
1095     {
1096       buffers[0] = src_buffer;
1097       if (offset)
1098         vlib_buffer_move (vm, s, offset);
1099
1100       for (i = 1; i < n_buffers; i++)
1101         {
1102           vlib_buffer_t *d;
1103           d = vlib_buffer_copy (vm, s);
1104           if (d == 0)
1105             return i;
1106           buffers[i] = vlib_get_buffer_index (vm, d);
1107
1108         }
1109       return n_buffers;
1110     }
1111
1112   if (PREDICT_FALSE ((n_buffers == 1) && (offset == 0)))
1113     {
1114       buffers[0] = src_buffer;
1115       return 1;
1116     }
1117
1118   n_buffers = vlib_buffer_alloc_from_pool (vm, buffers, n_buffers,
1119                                            s->buffer_pool_index);
1120
1121   for (i = 0; i < n_buffers; i++)
1122     {
1123       vlib_buffer_t *d = vlib_get_buffer (vm, buffers[i]);
1124       if (offset)
1125         d->current_data = offset;
1126       else
1127         d->current_data = s->current_data;
1128
1129       d->current_length = head_end_offset;
1130       ASSERT (d->buffer_pool_index == s->buffer_pool_index);
1131
1132       d->total_length_not_including_first_buffer = s->current_length -
1133         head_end_offset;
1134       if (PREDICT_FALSE (s->flags & VLIB_BUFFER_NEXT_PRESENT))
1135         {
1136           d->total_length_not_including_first_buffer +=
1137             s->total_length_not_including_first_buffer;
1138         }
1139       d->flags = (s->flags & VLIB_BUFFER_COPY_CLONE_FLAGS_MASK) |
1140         VLIB_BUFFER_NEXT_PRESENT;
1141       clib_memcpy_fast (d->opaque, s->opaque, sizeof (s->opaque));
1142       clib_memcpy_fast (d->opaque2, s->opaque2, sizeof (s->opaque2));
1143       clib_memcpy_fast (vlib_buffer_get_current (d),
1144                         vlib_buffer_get_current (s), head_end_offset);
1145       d->next_buffer = src_buffer;
1146     }
1147   vlib_buffer_advance (s, head_end_offset);
1148   s->ref_count = n_buffers;
1149   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
1150     {
1151       s = vlib_get_buffer (vm, s->next_buffer);
1152       s->ref_count = n_buffers;
1153     }
1154
1155   return n_buffers;
1156 }
1157
1158 /** \brief Create multiple clones of buffer and store them
1159     in the supplied array
1160
1161     @param vm - (vlib_main_t *) vlib main data structure pointer
1162     @param src_buffer - (u32) source buffer index
1163     @param buffers - (u32 * ) buffer index array
1164     @param n_buffers - (u16) number of buffer clones requested (<=256)
1165     @param head_end_offset - (u16) offset relative to current position
1166            where packet head ends
1167     @param offset - (i16) copy packet head at current position if 0,
1168            else at offset position to change headroom space as specified
1169     @return - (u16) number of buffers actually cloned, may be
1170     less than the number requested or zero
1171 */
1172 always_inline u16
1173 vlib_buffer_clone_at_offset (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1174                              u16 n_buffers, u16 head_end_offset, i16 offset)
1175 {
1176   vlib_buffer_t *s = vlib_get_buffer (vm, src_buffer);
1177   u16 n_cloned = 0;
1178
1179   while (n_buffers > 256)
1180     {
1181       vlib_buffer_t *copy;
1182       copy = vlib_buffer_copy (vm, s);
1183       n_cloned += vlib_buffer_clone_256 (vm,
1184                                          vlib_get_buffer_index (vm, copy),
1185                                          (buffers + n_cloned),
1186                                          256, head_end_offset, offset);
1187       n_buffers -= 256;
1188     }
1189   n_cloned += vlib_buffer_clone_256 (vm, src_buffer,
1190                                      buffers + n_cloned,
1191                                      n_buffers, head_end_offset, offset);
1192
1193   return n_cloned;
1194 }
1195
1196 /** \brief Create multiple clones of buffer and store them
1197     in the supplied array
1198
1199     @param vm - (vlib_main_t *) vlib main data structure pointer
1200     @param src_buffer - (u32) source buffer index
1201     @param buffers - (u32 * ) buffer index array
1202     @param n_buffers - (u16) number of buffer clones requested (<=256)
1203     @param head_end_offset - (u16) offset relative to current position
1204            where packet head ends
1205     @return - (u16) number of buffers actually cloned, may be
1206     less than the number requested or zero
1207 */
1208 always_inline u16
1209 vlib_buffer_clone (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1210                    u16 n_buffers, u16 head_end_offset)
1211 {
1212   return vlib_buffer_clone_at_offset (vm, src_buffer, buffers, n_buffers,
1213                                       head_end_offset, 0);
1214 }
1215
1216 /** \brief Attach cloned tail to the buffer
1217
1218     @param vm - (vlib_main_t *) vlib main data structure pointer
1219     @param head - (vlib_buffer_t *) head buffer
1220     @param tail - (Vlib buffer_t *) tail buffer to clone and attach to head
1221 */
1222
1223 always_inline void
1224 vlib_buffer_attach_clone (vlib_main_t * vm, vlib_buffer_t * head,
1225                           vlib_buffer_t * tail)
1226 {
1227   ASSERT ((head->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
1228   ASSERT (head->buffer_pool_index == tail->buffer_pool_index);
1229
1230   head->flags |= VLIB_BUFFER_NEXT_PRESENT;
1231   head->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
1232   head->flags &= ~VLIB_BUFFER_EXT_HDR_VALID;
1233   head->flags |= (tail->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID);
1234   head->next_buffer = vlib_get_buffer_index (vm, tail);
1235   head->total_length_not_including_first_buffer = tail->current_length +
1236     tail->total_length_not_including_first_buffer;
1237
1238 next_segment:
1239   clib_atomic_add_fetch (&tail->ref_count, 1);
1240
1241   if (tail->flags & VLIB_BUFFER_NEXT_PRESENT)
1242     {
1243       tail = vlib_get_buffer (vm, tail->next_buffer);
1244       goto next_segment;
1245     }
1246 }
1247
1248 /* Initializes the buffer as an empty packet with no chained buffers. */
1249 always_inline void
1250 vlib_buffer_chain_init (vlib_buffer_t * first)
1251 {
1252   first->total_length_not_including_first_buffer = 0;
1253   first->current_length = 0;
1254   first->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1255   first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
1256 }
1257
1258 /* The provided next_bi buffer index is appended to the end of the packet. */
1259 always_inline vlib_buffer_t *
1260 vlib_buffer_chain_buffer (vlib_main_t * vm, vlib_buffer_t * last, u32 next_bi)
1261 {
1262   vlib_buffer_t *next_buffer = vlib_get_buffer (vm, next_bi);
1263   last->next_buffer = next_bi;
1264   last->flags |= VLIB_BUFFER_NEXT_PRESENT;
1265   next_buffer->current_length = 0;
1266   next_buffer->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1267   return next_buffer;
1268 }
1269
1270 /* Increases or decreases the packet length.
1271  * It does not allocate or deallocate new buffers.
1272  * Therefore, the added length must be compatible
1273  * with the last buffer. */
1274 always_inline void
1275 vlib_buffer_chain_increase_length (vlib_buffer_t * first,
1276                                    vlib_buffer_t * last, i32 len)
1277 {
1278   last->current_length += len;
1279   if (first != last)
1280     first->total_length_not_including_first_buffer += len;
1281 }
1282
1283 /* Copy data to the end of the packet and increases its length.
1284  * It does not allocate new buffers.
1285  * Returns the number of copied bytes. */
1286 always_inline u16
1287 vlib_buffer_chain_append_data (vlib_main_t * vm,
1288                                vlib_buffer_t * first,
1289                                vlib_buffer_t * last, void *data, u16 data_len)
1290 {
1291   u32 n_buffer_bytes = vlib_buffer_get_default_data_size (vm);
1292   ASSERT (n_buffer_bytes >= last->current_length + last->current_data);
1293   u16 len = clib_min (data_len,
1294                       n_buffer_bytes - last->current_length -
1295                       last->current_data);
1296   clib_memcpy_fast (vlib_buffer_get_current (last) + last->current_length,
1297                     data, len);
1298   vlib_buffer_chain_increase_length (first, last, len);
1299   return len;
1300 }
1301
1302 /* Copy data to the end of the packet and increases its length.
1303  * Allocates additional buffers from the free list if necessary.
1304  * Returns the number of copied bytes.
1305  * 'last' value is modified whenever new buffers are allocated and
1306  * chained and points to the last buffer in the chain. */
1307 u16
1308 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
1309                                           vlib_buffer_t * first,
1310                                           vlib_buffer_t ** last, void *data,
1311                                           u16 data_len);
1312 void vlib_buffer_chain_validate (vlib_main_t * vm, vlib_buffer_t * first);
1313
1314 format_function_t format_vlib_buffer, format_vlib_buffer_and_data,
1315   format_vlib_buffer_contents;
1316
1317 typedef struct
1318 {
1319   /* Vector of packet data. */
1320   u8 *packet_data;
1321
1322   /* Number of buffers to allocate in each call to allocator. */
1323   u32 min_n_buffers_each_alloc;
1324
1325   u8 *name;
1326 } vlib_packet_template_t;
1327
1328 void vlib_packet_template_init (vlib_main_t * vm,
1329                                 vlib_packet_template_t * t,
1330                                 void *packet_data,
1331                                 uword n_packet_data_bytes,
1332                                 uword min_n_buffers_each_alloc,
1333                                 char *fmt, ...);
1334
1335 void *vlib_packet_template_get_packet (vlib_main_t * vm,
1336                                        vlib_packet_template_t * t,
1337                                        u32 * bi_result);
1338
1339 always_inline void
1340 vlib_packet_template_free (vlib_main_t * vm, vlib_packet_template_t * t)
1341 {
1342   vec_free (t->packet_data);
1343 }
1344
1345 always_inline u32
1346 vlib_buffer_space_left_at_end (vlib_main_t * vm, vlib_buffer_t * b)
1347 {
1348   return b->data + vlib_buffer_get_default_data_size (vm) -
1349     ((u8 *) vlib_buffer_get_current (b) + b->current_length);
1350 }
1351
1352 always_inline u32
1353 vlib_buffer_chain_linearize (vlib_main_t * vm, vlib_buffer_t * b)
1354 {
1355   vlib_buffer_t *db = b, *sb, *first = b;
1356   int is_cloned = 0;
1357   u32 bytes_left = 0, data_size;
1358   u16 src_left, dst_left, n_buffers = 1;
1359   u8 *dp, *sp;
1360   u32 to_free = 0;
1361
1362   if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0))
1363     return 1;
1364
1365   data_size = vlib_buffer_get_default_data_size (vm);
1366
1367   dst_left = vlib_buffer_space_left_at_end (vm, b);
1368
1369   while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
1370     {
1371       b = vlib_get_buffer (vm, b->next_buffer);
1372       if (b->ref_count > 1)
1373         is_cloned = 1;
1374       bytes_left += b->current_length;
1375       n_buffers++;
1376     }
1377
1378   /* if buffer is cloned, create completely new chain - unless everything fits
1379    * into one buffer */
1380   if (is_cloned && bytes_left >= dst_left)
1381     {
1382       u32 len = 0;
1383       u32 space_needed = bytes_left - dst_left;
1384       u32 tail;
1385
1386       if (vlib_buffer_alloc (vm, &tail, 1) == 0)
1387         return 0;
1388
1389       ++n_buffers;
1390       len += data_size;
1391       b = vlib_get_buffer (vm, tail);
1392
1393       while (len < space_needed)
1394         {
1395           u32 bi;
1396           if (vlib_buffer_alloc (vm, &bi, 1) == 0)
1397             {
1398               vlib_buffer_free_one (vm, tail);
1399               return 0;
1400             }
1401           b->flags = VLIB_BUFFER_NEXT_PRESENT;
1402           b->next_buffer = bi;
1403           b = vlib_get_buffer (vm, bi);
1404           len += data_size;
1405           n_buffers++;
1406         }
1407       sb = vlib_get_buffer (vm, first->next_buffer);
1408       to_free = first->next_buffer;
1409       first->next_buffer = tail;
1410     }
1411   else
1412     sb = vlib_get_buffer (vm, first->next_buffer);
1413
1414   src_left = sb->current_length;
1415   sp = vlib_buffer_get_current (sb);
1416   dp = vlib_buffer_get_tail (db);
1417
1418   while (bytes_left)
1419     {
1420       u16 bytes_to_copy;
1421
1422       if (dst_left == 0)
1423         {
1424           db->current_length = dp - (u8 *) vlib_buffer_get_current (db);
1425           ASSERT (db->flags & VLIB_BUFFER_NEXT_PRESENT);
1426           db = vlib_get_buffer (vm, db->next_buffer);
1427           dst_left = data_size;
1428           if (db->current_data > 0)
1429             {
1430               db->current_data = 0;
1431             }
1432           else
1433             {
1434               dst_left += -db->current_data;
1435             }
1436           dp = vlib_buffer_get_current (db);
1437         }
1438
1439       while (src_left == 0)
1440         {
1441           ASSERT (sb->flags & VLIB_BUFFER_NEXT_PRESENT);
1442           sb = vlib_get_buffer (vm, sb->next_buffer);
1443           src_left = sb->current_length;
1444           sp = vlib_buffer_get_current (sb);
1445         }
1446
1447       bytes_to_copy = clib_min (dst_left, src_left);
1448
1449       if (dp != sp)
1450         {
1451           if (sb == db)
1452             bytes_to_copy = clib_min (bytes_to_copy, sp - dp);
1453
1454           clib_memcpy_fast (dp, sp, bytes_to_copy);
1455         }
1456
1457       src_left -= bytes_to_copy;
1458       dst_left -= bytes_to_copy;
1459       dp += bytes_to_copy;
1460       sp += bytes_to_copy;
1461       bytes_left -= bytes_to_copy;
1462     }
1463   if (db != first)
1464     db->current_data = 0;
1465   db->current_length = dp - (u8 *) vlib_buffer_get_current (db);
1466
1467   if (is_cloned && to_free)
1468     vlib_buffer_free_one (vm, to_free);
1469   else
1470     {
1471       if (db->flags & VLIB_BUFFER_NEXT_PRESENT)
1472         vlib_buffer_free_one (vm, db->next_buffer);
1473       db->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1474       b = first;
1475       n_buffers = 1;
1476       while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
1477         {
1478           b = vlib_get_buffer (vm, b->next_buffer);
1479           ++n_buffers;
1480         }
1481     }
1482
1483   first->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
1484
1485   return n_buffers;
1486 }
1487
1488 #endif /* included_vlib_buffer_funcs_h */
1489
1490 /*
1491  * fd.io coding-style-patch-verification: ON
1492  *
1493  * Local Variables:
1494  * eval: (c-set-style "gnu")
1495  * End:
1496  */