src/vlib/buffer_funcs.h

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