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 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   vec_add_aligned (bpt->cached_buffers, buffers, n_buffers,
 647                    CLIB_CACHE_LINE_BYTES);
 648
 649   if (vec_len (bpt->cached_buffers) > 4 * VLIB_FRAME_SIZE)
 650     {
 651       clib_spinlock_lock (&bp->lock);
 652       /* keep last stored buffers, as they are more likely hot in the cache */
 653       vec_add_aligned (bp->buffers, bpt->cached_buffers, VLIB_FRAME_SIZE,
 654                        CLIB_CACHE_LINE_BYTES);
 655       vec_delete (bpt->cached_buffers, VLIB_FRAME_SIZE, 0);
 656       bpt->n_alloc -= VLIB_FRAME_SIZE;
 657       clib_spinlock_unlock (&bp->lock);
 658     }
 659 }
 660
 661 static_always_inline void
 662 vlib_buffer_free_inline (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
 663                          int maybe_next)
 664 {
 665   const int queue_size = 128;
 666   vlib_buffer_pool_t *bp = 0;
 667   u8 buffer_pool_index = ~0;
 668   u32 n_queue = 0, queue[queue_size + 4];
 669   vlib_buffer_t bt = { };
 670 #if defined(CLIB_HAVE_VEC128) && !__aarch64__
 671   vlib_buffer_t bpi_mask = {.buffer_pool_index = ~0 };
 672   vlib_buffer_t bpi_vec = {.buffer_pool_index = ~0 };
 673   vlib_buffer_t flags_refs_mask = {
 674     .flags = VLIB_BUFFER_NEXT_PRESENT,
 675     .ref_count = ~0
 676   };
 677 #endif
 678
 679   while (n_buffers)
 680     {
 681       vlib_buffer_t *b[8];
 682       u32 bi, sum = 0, flags, next;
 683
 684       if (n_buffers < 12)
 685         goto one_by_one;
 686
 687       vlib_get_buffers (vm, buffers, b, 4);
 688       vlib_get_buffers (vm, buffers + 8, b + 4, 4);
 689
 690       vlib_prefetch_buffer_header (b[4], LOAD);
 691       vlib_prefetch_buffer_header (b[5], LOAD);
 692       vlib_prefetch_buffer_header (b[6], LOAD);
 693       vlib_prefetch_buffer_header (b[7], LOAD);
 694
 695 #if defined(CLIB_HAVE_VEC128) && !__aarch64__
 696       u8x16 p0, p1, p2, p3, r;
 697       p0 = u8x16_load_unaligned (b[0]);
 698       p1 = u8x16_load_unaligned (b[1]);
 699       p2 = u8x16_load_unaligned (b[2]);
 700       p3 = u8x16_load_unaligned (b[3]);
 701
 702       r = p0 ^ bpi_vec.as_u8x16[0];
 703       r |= p1 ^ bpi_vec.as_u8x16[0];
 704       r |= p2 ^ bpi_vec.as_u8x16[0];
 705       r |= p3 ^ bpi_vec.as_u8x16[0];
 706       r &= bpi_mask.as_u8x16[0];
 707       r |= (p0 | p1 | p2 | p3) & flags_refs_mask.as_u8x16[0];
 708
 709       sum = !u8x16_is_all_zero (r);
 710 #else
 711       sum |= b[0]->flags;
 712       sum |= b[1]->flags;
 713       sum |= b[2]->flags;
 714       sum |= b[3]->flags;
 715       sum &= VLIB_BUFFER_NEXT_PRESENT;
 716       sum += b[0]->ref_count - 1;
 717       sum += b[1]->ref_count - 1;
 718       sum += b[2]->ref_count - 1;
 719       sum += b[3]->ref_count - 1;
 720       sum |= b[0]->buffer_pool_index ^ buffer_pool_index;
 721       sum |= b[1]->buffer_pool_index ^ buffer_pool_index;
 722       sum |= b[2]->buffer_pool_index ^ buffer_pool_index;
 723       sum |= b[3]->buffer_pool_index ^ buffer_pool_index;
 724 #endif
 725
 726       if (sum)
 727         goto one_by_one;
 728
 729       vlib_buffer_copy_indices (queue + n_queue, buffers, 4);
 730       vlib_buffer_copy_template (b[0], &bt);
 731       vlib_buffer_copy_template (b[1], &bt);
 732       vlib_buffer_copy_template (b[2], &bt);
 733       vlib_buffer_copy_template (b[3], &bt);
 734       n_queue += 4;
 735
 736       if (CLIB_DEBUG > 0)
 737         vlib_buffer_validate_alloc_free (vm, buffers, 4,
 738                                          VLIB_BUFFER_KNOWN_ALLOCATED);
 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           if (CLIB_DEBUG > 0)
 790             vlib_buffer_validate_alloc_free (vm, &bi, 1,
 791                                              VLIB_BUFFER_KNOWN_ALLOCATED);
 792           vlib_buffer_copy_template (b[0], &bt);
 793           queue[n_queue++] = bi;
 794         }
 795
 796       if (n_queue == queue_size)
 797         {
 798           vlib_buffer_pool_put (vm, buffer_pool_index, queue, queue_size);
 799           n_queue = 0;
 800         }
 801
 802       if (flags & VLIB_BUFFER_NEXT_PRESENT)
 803         {
 804           bi = next;
 805           goto next_in_chain;
 806         }
 807
 808       buffers++;
 809       n_buffers--;
 810     }
 811
 812   if (n_queue)
 813     vlib_buffer_pool_put (vm, buffer_pool_index, queue, n_queue);
 814 }
 815
 816
 817 /** \brief Free buffers
 818     Frees the entire buffer chain for each buffer
 819
 820     @param vm - (vlib_main_t *) vlib main data structure pointer
 821     @param buffers - (u32 * ) buffer index array
 822     @param n_buffers - (u32) number of buffers to free
 823
 824 */
 825 always_inline void
 826 vlib_buffer_free (vlib_main_t * vm,
 827                   /* pointer to first buffer */
 828                   u32 * buffers,
 829                   /* number of buffers to free */
 830                   u32 n_buffers)
 831 {
 832   vlib_buffer_free_inline (vm, buffers, n_buffers, /* maybe next */ 1);
 833 }
 834
 835 /** \brief Free buffers, does not free the buffer chain for each buffer
 836
 837     @param vm - (vlib_main_t *) vlib main data structure pointer
 838     @param buffers - (u32 * ) buffer index array
 839     @param n_buffers - (u32) number of buffers to free
 840
 841 */
 842 always_inline void
 843 vlib_buffer_free_no_next (vlib_main_t * vm,
 844                           /* pointer to first buffer */
 845                           u32 * buffers,
 846                           /* number of buffers to free */
 847                           u32 n_buffers)
 848 {
 849   vlib_buffer_free_inline (vm, buffers, n_buffers, /* maybe next */ 0);
 850 }
 851
 852 /** \brief Free one buffer
 853     Shorthand to free a single buffer chain.
 854
 855     @param vm - (vlib_main_t *) vlib main data structure pointer
 856     @param buffer_index - (u32) buffer index to free
 857 */
 858 always_inline void
 859 vlib_buffer_free_one (vlib_main_t * vm, u32 buffer_index)
 860 {
 861   vlib_buffer_free_inline (vm, &buffer_index, 1, /* maybe next */ 1);
 862 }
 863
 864 /** \brief Free buffers from ring
 865
 866     @param vm - (vlib_main_t *) vlib main data structure pointer
 867     @param buffers - (u32 * ) buffer index ring
 868     @param start - (u32) first slot in the ring
 869     @param ring_size - (u32) ring size
 870     @param n_buffers - (u32) number of buffers
 871 */
 872 always_inline void
 873 vlib_buffer_free_from_ring (vlib_main_t * vm, u32 * ring, u32 start,
 874                             u32 ring_size, u32 n_buffers)
 875 {
 876   ASSERT (n_buffers <= ring_size);
 877
 878   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 879     {
 880       vlib_buffer_free (vm, ring + start, n_buffers);
 881     }
 882   else
 883     {
 884       vlib_buffer_free (vm, ring + start, ring_size - start);
 885       vlib_buffer_free (vm, ring, n_buffers - (ring_size - start));
 886     }
 887 }
 888
 889 /** \brief Free buffers from ring without freeing tail buffers
 890
 891     @param vm - (vlib_main_t *) vlib main data structure pointer
 892     @param buffers - (u32 * ) buffer index ring
 893     @param start - (u32) first slot in the ring
 894     @param ring_size - (u32) ring size
 895     @param n_buffers - (u32) number of buffers
 896 */
 897 always_inline void
 898 vlib_buffer_free_from_ring_no_next (vlib_main_t * vm, u32 * ring, u32 start,
 899                                     u32 ring_size, u32 n_buffers)
 900 {
 901   ASSERT (n_buffers <= ring_size);
 902
 903   if (PREDICT_TRUE (start + n_buffers <= ring_size))
 904     {
 905       vlib_buffer_free_no_next (vm, ring + start, n_buffers);
 906     }
 907   else
 908     {
 909       vlib_buffer_free_no_next (vm, ring + start, ring_size - start);
 910       vlib_buffer_free_no_next (vm, ring, n_buffers - (ring_size - start));
 911     }
 912 }
 913
 914 /* Append given data to end of buffer, possibly allocating new buffers. */
 915 int vlib_buffer_add_data (vlib_main_t * vm, u32 * buffer_index, void *data,
 916                           u32 n_data_bytes);
 917
 918 /* duplicate all buffers in chain */
 919 always_inline vlib_buffer_t *
 920 vlib_buffer_copy (vlib_main_t * vm, vlib_buffer_t * b)
 921 {
 922   vlib_buffer_t *s, *d, *fd;
 923   uword n_alloc, n_buffers = 1;
 924   u32 flag_mask = VLIB_BUFFER_NEXT_PRESENT | VLIB_BUFFER_TOTAL_LENGTH_VALID;
 925   int i;
 926
 927   s = b;
 928   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
 929     {
 930       n_buffers++;
 931       s = vlib_get_buffer (vm, s->next_buffer);
 932     }
 933   u32 new_buffers[n_buffers];
 934
 935   n_alloc = vlib_buffer_alloc (vm, new_buffers, n_buffers);
 936
 937   /* No guarantee that we'll get all the buffers we asked for */
 938   if (PREDICT_FALSE (n_alloc < n_buffers))
 939     {
 940       if (n_alloc > 0)
 941         vlib_buffer_free (vm, new_buffers, n_alloc);
 942       return 0;
 943     }
 944
 945   /* 1st segment */
 946   s = b;
 947   fd = d = vlib_get_buffer (vm, new_buffers[0]);
 948   d->current_data = s->current_data;
 949   d->current_length = s->current_length;
 950   d->flags = s->flags & flag_mask;
 951   d->total_length_not_including_first_buffer =
 952     s->total_length_not_including_first_buffer;
 953   clib_memcpy_fast (d->opaque, s->opaque, sizeof (s->opaque));
 954   clib_memcpy_fast (d->opaque2, s->opaque2, sizeof (s->opaque2));
 955   clib_memcpy_fast (vlib_buffer_get_current (d),
 956                     vlib_buffer_get_current (s), s->current_length);
 957
 958   /* next segments */
 959   for (i = 1; i < n_buffers; i++)
 960     {
 961       /* previous */
 962       d->next_buffer = new_buffers[i];
 963       /* current */
 964       s = vlib_get_buffer (vm, s->next_buffer);
 965       d = vlib_get_buffer (vm, new_buffers[i]);
 966       d->current_data = s->current_data;
 967       d->current_length = s->current_length;
 968       clib_memcpy_fast (vlib_buffer_get_current (d),
 969                         vlib_buffer_get_current (s), s->current_length);
 970       d->flags = s->flags & flag_mask;
 971     }
 972
 973   return fd;
 974 }
 975
 976 /** \brief Create a maximum of 256 clones of buffer and store them
 977     in the supplied array
 978
 979     @param vm - (vlib_main_t *) vlib main data structure pointer
 980     @param src_buffer - (u32) source buffer index
 981     @param buffers - (u32 * ) buffer index array
 982     @param n_buffers - (u16) number of buffer clones requested (<=256)
 983     @param head_end_offset - (u16) offset relative to current position
 984            where packet head ends
 985     @return - (u16) number of buffers actually cloned, may be
 986     less than the number requested or zero
 987 */
 988 always_inline u16
 989 vlib_buffer_clone_256 (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
 990                        u16 n_buffers, u16 head_end_offset)
 991 {
 992   u16 i;
 993   vlib_buffer_t *s = vlib_get_buffer (vm, src_buffer);
 994
 995   ASSERT (s->ref_count == 1);
 996   ASSERT (n_buffers);
 997   ASSERT (n_buffers <= 256);
 998
 999   if (s->current_length <= head_end_offset + CLIB_CACHE_LINE_BYTES * 2)
1000     {
1001       buffers[0] = src_buffer;
1002       for (i = 1; i < n_buffers; i++)
1003         {
1004           vlib_buffer_t *d;
1005           d = vlib_buffer_copy (vm, s);
1006           if (d == 0)
1007             return i;
1008           buffers[i] = vlib_get_buffer_index (vm, d);
1009
1010         }
1011       return n_buffers;
1012     }
1013
1014   if (PREDICT_FALSE (n_buffers == 1))
1015     {
1016       buffers[0] = src_buffer;
1017       return 1;
1018     }
1019
1020   n_buffers = vlib_buffer_alloc_from_pool (vm, buffers, n_buffers,
1021                                            s->buffer_pool_index);
1022
1023   for (i = 0; i < n_buffers; i++)
1024     {
1025       vlib_buffer_t *d = vlib_get_buffer (vm, buffers[i]);
1026       d->current_data = s->current_data;
1027       d->current_length = head_end_offset;
1028       ASSERT (d->buffer_pool_index == s->buffer_pool_index);
1029
1030       d->total_length_not_including_first_buffer = s->current_length -
1031         head_end_offset;
1032       if (PREDICT_FALSE (s->flags & VLIB_BUFFER_NEXT_PRESENT))
1033         {
1034           d->total_length_not_including_first_buffer +=
1035             s->total_length_not_including_first_buffer;
1036         }
1037       d->flags = s->flags | VLIB_BUFFER_NEXT_PRESENT;
1038       d->flags &= ~VLIB_BUFFER_EXT_HDR_VALID;
1039       clib_memcpy_fast (d->opaque, s->opaque, sizeof (s->opaque));
1040       clib_memcpy_fast (d->opaque2, s->opaque2, sizeof (s->opaque2));
1041       clib_memcpy_fast (vlib_buffer_get_current (d),
1042                         vlib_buffer_get_current (s), head_end_offset);
1043       d->next_buffer = src_buffer;
1044     }
1045   vlib_buffer_advance (s, head_end_offset);
1046   s->ref_count = n_buffers;
1047   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
1048     {
1049       s = vlib_get_buffer (vm, s->next_buffer);
1050       s->ref_count = n_buffers;
1051     }
1052
1053   return n_buffers;
1054 }
1055
1056 /** \brief Create multiple clones of buffer and store them
1057     in the supplied array
1058
1059     @param vm - (vlib_main_t *) vlib main data structure pointer
1060     @param src_buffer - (u32) source buffer index
1061     @param buffers - (u32 * ) buffer index array
1062     @param n_buffers - (u16) number of buffer clones requested (<=256)
1063     @param head_end_offset - (u16) offset relative to current position
1064            where packet head ends
1065     @return - (u16) number of buffers actually cloned, may be
1066     less than the number requested or zero
1067 */
1068 always_inline u16
1069 vlib_buffer_clone (vlib_main_t * vm, u32 src_buffer, u32 * buffers,
1070                    u16 n_buffers, u16 head_end_offset)
1071 {
1072   vlib_buffer_t *s = vlib_get_buffer (vm, src_buffer);
1073   u16 n_cloned = 0;
1074
1075   while (n_buffers > 256)
1076     {
1077       vlib_buffer_t *copy;
1078       copy = vlib_buffer_copy (vm, s);
1079       n_cloned += vlib_buffer_clone_256 (vm,
1080                                          vlib_get_buffer_index (vm, copy),
1081                                          (buffers + n_cloned),
1082                                          256, head_end_offset);
1083       n_buffers -= 256;
1084     }
1085   n_cloned += vlib_buffer_clone_256 (vm, src_buffer,
1086                                      buffers + n_cloned,
1087                                      n_buffers, head_end_offset);
1088
1089   return n_cloned;
1090 }
1091
1092 /** \brief Attach cloned tail to the buffer
1093
1094     @param vm - (vlib_main_t *) vlib main data structure pointer
1095     @param head - (vlib_buffer_t *) head buffer
1096     @param tail - (Vlib buffer_t *) tail buffer to clone and attach to head
1097 */
1098
1099 always_inline void
1100 vlib_buffer_attach_clone (vlib_main_t * vm, vlib_buffer_t * head,
1101                           vlib_buffer_t * tail)
1102 {
1103   ASSERT ((head->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
1104   ASSERT (head->buffer_pool_index == tail->buffer_pool_index);
1105
1106   head->flags |= VLIB_BUFFER_NEXT_PRESENT;
1107   head->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
1108   head->flags &= ~VLIB_BUFFER_EXT_HDR_VALID;
1109   head->flags |= (tail->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID);
1110   head->next_buffer = vlib_get_buffer_index (vm, tail);
1111   head->total_length_not_including_first_buffer = tail->current_length +
1112     tail->total_length_not_including_first_buffer;
1113
1114 next_segment:
1115   clib_atomic_add_fetch (&tail->ref_count, 1);
1116
1117   if (tail->flags & VLIB_BUFFER_NEXT_PRESENT)
1118     {
1119       tail = vlib_get_buffer (vm, tail->next_buffer);
1120       goto next_segment;
1121     }
1122 }
1123
1124 /* Initializes the buffer as an empty packet with no chained buffers. */
1125 always_inline void
1126 vlib_buffer_chain_init (vlib_buffer_t * first)
1127 {
1128   first->total_length_not_including_first_buffer = 0;
1129   first->current_length = 0;
1130   first->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1131   first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
1132 }
1133
1134 /* The provided next_bi buffer index is appended to the end of the packet. */
1135 always_inline vlib_buffer_t *
1136 vlib_buffer_chain_buffer (vlib_main_t * vm, vlib_buffer_t * last, u32 next_bi)
1137 {
1138   vlib_buffer_t *next_buffer = vlib_get_buffer (vm, next_bi);
1139   last->next_buffer = next_bi;
1140   last->flags |= VLIB_BUFFER_NEXT_PRESENT;
1141   next_buffer->current_length = 0;
1142   next_buffer->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1143   return next_buffer;
1144 }
1145
1146 /* Increases or decreases the packet length.
1147  * It does not allocate or deallocate new buffers.
1148  * Therefore, the added length must be compatible
1149  * with the last buffer. */
1150 always_inline void
1151 vlib_buffer_chain_increase_length (vlib_buffer_t * first,
1152                                    vlib_buffer_t * last, i32 len)
1153 {
1154   last->current_length += len;
1155   if (first != last)
1156     first->total_length_not_including_first_buffer += len;
1157 }
1158
1159 /* Copy data to the end of the packet and increases its length.
1160  * It does not allocate new buffers.
1161  * Returns the number of copied bytes. */
1162 always_inline u16
1163 vlib_buffer_chain_append_data (vlib_main_t * vm,
1164                                vlib_buffer_t * first,
1165                                vlib_buffer_t * last, void *data, u16 data_len)
1166 {
1167   u32 n_buffer_bytes = VLIB_BUFFER_DATA_SIZE;
1168   ASSERT (n_buffer_bytes >= last->current_length + last->current_data);
1169   u16 len = clib_min (data_len,
1170                       n_buffer_bytes - last->current_length -
1171                       last->current_data);
1172   clib_memcpy_fast (vlib_buffer_get_current (last) + last->current_length,
1173                     data, len);
1174   vlib_buffer_chain_increase_length (first, last, len);
1175   return len;
1176 }
1177
1178 /* Copy data to the end of the packet and increases its length.
1179  * Allocates additional buffers from the free list if necessary.
1180  * Returns the number of copied bytes.
1181  * 'last' value is modified whenever new buffers are allocated and
1182  * chained and points to the last buffer in the chain. */
1183 u16
1184 vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
1185                                           vlib_buffer_t * first,
1186                                           vlib_buffer_t ** last, void *data,
1187                                           u16 data_len);
1188 void vlib_buffer_chain_validate (vlib_main_t * vm, vlib_buffer_t * first);
1189
1190 format_function_t format_vlib_buffer, format_vlib_buffer_and_data,
1191   format_vlib_buffer_contents;
1192
1193 typedef struct
1194 {
1195   /* Vector of packet data. */
1196   u8 *packet_data;
1197
1198   /* Number of buffers to allocate in each call to allocator. */
1199   u32 min_n_buffers_each_alloc;
1200
1201   u8 *name;
1202 } vlib_packet_template_t;
1203
1204 void vlib_packet_template_init (vlib_main_t * vm,
1205                                 vlib_packet_template_t * t,
1206                                 void *packet_data,
1207                                 uword n_packet_data_bytes,
1208                                 uword min_n_buffers_each_alloc,
1209                                 char *fmt, ...);
1210
1211 void *vlib_packet_template_get_packet (vlib_main_t * vm,
1212                                        vlib_packet_template_t * t,
1213                                        u32 * bi_result);
1214
1215 always_inline void
1216 vlib_packet_template_free (vlib_main_t * vm, vlib_packet_template_t * t)
1217 {
1218   vec_free (t->packet_data);
1219 }
1220
1221 /**
1222  * @brief compress buffer chain in a way where the first buffer is at least
1223  * VLIB_BUFFER_CLONE_HEAD_SIZE long
1224  *
1225  * @param[in] vm - vlib_main
1226  * @param[in,out] first - first buffer in chain
1227  * @param[in,out] discard_vector - vector of buffer indexes which were removed
1228  * from the chain
1229  */
1230 always_inline void
1231 vlib_buffer_chain_compress (vlib_main_t * vm,
1232                             vlib_buffer_t * first, u32 ** discard_vector)
1233 {
1234   if (first->current_length >= VLIB_BUFFER_CLONE_HEAD_SIZE ||
1235       !(first->flags & VLIB_BUFFER_NEXT_PRESENT))
1236     {
1237       /* this is already big enough or not a chain */
1238       return;
1239     }
1240
1241   u32 want_first_size = clib_min (VLIB_BUFFER_CLONE_HEAD_SIZE,
1242                                   VLIB_BUFFER_DATA_SIZE -
1243                                   first->current_data);
1244   do
1245     {
1246       vlib_buffer_t *second = vlib_get_buffer (vm, first->next_buffer);
1247       u32 need = want_first_size - first->current_length;
1248       u32 amount_to_copy = clib_min (need, second->current_length);
1249       clib_memcpy_fast (((u8 *) vlib_buffer_get_current (first)) +
1250                         first->current_length,
1251                         vlib_buffer_get_current (second), amount_to_copy);
1252       first->current_length += amount_to_copy;
1253       second->current_data += amount_to_copy;
1254       second->current_length -= amount_to_copy;
1255       if (first->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID)
1256         {
1257           first->total_length_not_including_first_buffer -= amount_to_copy;
1258         }
1259       if (!second->current_length)
1260         {
1261           vec_add1 (*discard_vector, first->next_buffer);
1262           if (second->flags & VLIB_BUFFER_NEXT_PRESENT)
1263             {
1264               first->next_buffer = second->next_buffer;
1265             }
1266           else
1267             {
1268               first->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1269             }
1270           second->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1271         }
1272     }
1273   while ((first->current_length < want_first_size) &&
1274          (first->flags & VLIB_BUFFER_NEXT_PRESENT));
1275 }
1276
1277 /**
1278  * @brief linearize buffer chain - the first buffer is filled, if needed,
1279  * buffers are allocated and filled, returns free space in last buffer or
1280  * negative on failure
1281  *
1282  * @param[in] vm - vlib_main
1283  * @param[in,out] first - first buffer in chain
1284  */
1285 always_inline int
1286 vlib_buffer_chain_linearize (vlib_main_t * vm, vlib_buffer_t * first)
1287 {
1288   vlib_buffer_t *b = first;
1289   u32 buf_len = VLIB_BUFFER_DATA_SIZE;
1290   // free buffer chain starting from the second buffer
1291   int free_count = (b->flags & VLIB_BUFFER_NEXT_PRESENT) != 0;
1292   u32 chain_to_free = b->next_buffer;
1293
1294   u32 len = vlib_buffer_length_in_chain (vm, b);
1295   u32 free_len = buf_len - b->current_data - b->current_length;
1296   int alloc_len = clib_max (len - free_len, 0); //use the free len in the first buffer
1297   int n_buffers = (alloc_len + buf_len - 1) / buf_len;
1298   u32 new_buffers[n_buffers];
1299
1300   u32 n_alloc = vlib_buffer_alloc (vm, new_buffers, n_buffers);
1301   if (n_alloc != n_buffers)
1302     {
1303       vlib_buffer_free_no_next (vm, new_buffers, n_alloc);
1304       return -1;
1305     }
1306
1307   vlib_buffer_t *s = b;
1308   while (s->flags & VLIB_BUFFER_NEXT_PRESENT)
1309     {
1310       s = vlib_get_buffer (vm, s->next_buffer);
1311       int d_free_len = buf_len - b->current_data - b->current_length;
1312       ASSERT (d_free_len >= 0);
1313       // chain buf and split write
1314       u32 copy_len = clib_min (d_free_len, s->current_length);
1315       u8 *d = vlib_buffer_put_uninit (b, copy_len);
1316       clib_memcpy (d, vlib_buffer_get_current (s), copy_len);
1317       int rest = s->current_length - copy_len;
1318       if (rest > 0)
1319         {
1320           //prev buf is full
1321           ASSERT (vlib_buffer_get_tail (b) == b->data + buf_len);
1322           ASSERT (n_buffers > 0);
1323           b = vlib_buffer_chain_buffer (vm, b, new_buffers[--n_buffers]);
1324           //make full use of the new buffers
1325           b->current_data = 0;
1326           d = vlib_buffer_put_uninit (b, rest);
1327           clib_memcpy (d, vlib_buffer_get_current (s) + copy_len, rest);
1328         }
1329     }
1330   vlib_buffer_free (vm, &chain_to_free, free_count);
1331   b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
1332   if (b == first)               /* no buffers addeed */
1333     b->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
1334   ASSERT (len == vlib_buffer_length_in_chain (vm, first));
1335   ASSERT (n_buffers == 0);
1336   return buf_len - b->current_data - b->current_length;
1337 }
1338
1339 #endif /* included_vlib_buffer_funcs_h */
1340
1341 /*
1342  * fd.io coding-style-patch-verification: ON
1343  *
1344  * Local Variables:
1345  * eval: (c-set-style "gnu")
1346  * End:
1347  */