src/vlib/buffer_funcs.h

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