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