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