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