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