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