src/vlib/buffer_funcs.h

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