FD.io VPP  v19.01.3-6-g70449b9b9
Vector Packet Processing
buffer.h
Go to the documentation of this file.
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.h: VLIB buffers
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_h
41 #define included_vlib_buffer_h
42 
43 #include <vppinfra/types.h>
44 #include <vppinfra/cache.h>
45 #include <vppinfra/serialize.h>
46 #include <vppinfra/vector.h>
47 #include <vppinfra/lock.h>
48 #include <vlib/error.h> /* for vlib_error_t */
49 
50 #include <vlib/config.h> /* for __PRE_DATA_SIZE */
51 #define VLIB_BUFFER_DATA_SIZE (2048)
52 #define VLIB_BUFFER_PRE_DATA_SIZE __PRE_DATA_SIZE
53 
54 /* Minimum buffer chain segment size. Does not apply to last buffer in chain.
55  Dataplane code can safely asume that specified amount of data is not split
56  into 2 chained buffers */
57 #define VLIB_BUFFER_MIN_CHAIN_SEG_SIZE (128)
58 
59 /* Amount of head buffer data copied to each replica head buffer */
60 #define VLIB_BUFFER_CLONE_HEAD_SIZE (256)
61 
63 
64 /** \file
65  vlib buffer structure definition and a few select
66  access methods. This structure and the buffer allocation
67  mechanism should perhaps live in vnet, but it would take a lot
68  of typing to make it so.
69 */
70 
71 /**
72  * Buffer Flags
73  */
74 #define foreach_vlib_buffer_flag \
75  _( 0, NON_DEFAULT_FREELIST, "non-default-fl") \
76  _( 1, IS_TRACED, 0) \
77  _( 2, NEXT_PRESENT, 0) \
78  _( 3, TOTAL_LENGTH_VALID, 0) \
79  _( 4, EXT_HDR_VALID, "ext-hdr-valid")
80 
81 /* NOTE: only buffer generic flags should be defined here, please consider
82  using user flags. i.e. src/vnet/buffer.h */
83 
84 enum
85 {
86 #define _(bit, name, v) VLIB_BUFFER_##name = (1 << (bit)),
88 #undef _
89 };
90 
91 enum
92 {
93 #define _(bit, name, v) VLIB_BUFFER_LOG2_##name = (bit),
95 #undef _
96 };
97 
98  /* User defined buffer flags. */
99 #define LOG2_VLIB_BUFFER_FLAG_USER(n) (32 - (n))
100 #define VLIB_BUFFER_FLAG_USER(n) (1 << LOG2_VLIB_BUFFER_FLAG_USER(n))
101 #define VLIB_BUFFER_FLAGS_ALL (0x1f)
102 
103 /* VLIB buffer representation. */
104 typedef struct
105 {
106  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
107  STRUCT_MARK (template_start);
108  /* Offset within data[] that we are currently processing.
109  If negative current header points into predata area. */
110  i16 current_data; /**< signed offset in data[], pre_data[]
111  that we are currently processing.
112  If negative current header points into predata area.
113  */
114  u16 current_length; /**< Nbytes between current data and
115  the end of this buffer.
116  */
117  u32 flags; /**< buffer flags:
118  <br> VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index,
119  <br> VLIB_BUFFER_IS_TRACED: trace this buffer.
120  <br> VLIB_BUFFER_NEXT_PRESENT: this is a multi-chunk buffer.
121  <br> VLIB_BUFFER_TOTAL_LENGTH_VALID: as it says
122  <br> VLIB_BUFFER_EXT_HDR_VALID: buffer contains valid external buffer manager header,
123  set to avoid adding it to a flow report
124  <br> VLIB_BUFFER_FLAG_USER(n): user-defined bit N
125  */
126 
127  u32 flow_id; /**< Generic flow identifier */
128 
129 
130  u32 next_buffer; /**< Next buffer for this linked-list of buffers.
131  Only valid if VLIB_BUFFER_NEXT_PRESENT flag is set.
132  */
133 
134  STRUCT_MARK (template_end);
135 
136  u32 current_config_index; /**< Used by feature subgraph arcs to
137  visit enabled feature nodes
138  */
139  vlib_error_t error; /**< Error code for buffers to be enqueued
140  to error handler.
141  */
142  u8 n_add_refs; /**< Number of additional references to this buffer. */
143 
144  u8 buffer_pool_index; /**< index of buffer pool this buffer belongs. */
145 
146  u32 opaque[10]; /**< Opaque data used by sub-graphs for their own purposes.
147  See .../vnet/vnet/buffer.h
148  */
149  CLIB_CACHE_LINE_ALIGN_MARK (cacheline1);
150 
151  u32 trace_index; /**< Specifies index into trace buffer
152  if VLIB_PACKET_IS_TRACED flag is set.
153  */
154  u32 recycle_count; /**< Used by L2 path recycle code */
155 
157  /**< Only valid for first buffer in chain. Current length plus
158  total length given here give total number of bytes in buffer chain.
159  */
160  vlib_buffer_free_list_index_t free_list_index; /** < only used if
161  VLIB_BUFFER_NON_DEFAULT_FREELIST
162  flag is set */
163  u8 align_pad[3]; /**< available */
164  u32 opaque2[12]; /**< More opaque data, see ../vnet/vnet/buffer.h */
165 
166  /***** end of second cache line */
167  CLIB_CACHE_LINE_ALIGN_MARK (cacheline2);
168  u8 pre_data[VLIB_BUFFER_PRE_DATA_SIZE]; /**< Space for inserting data
169  before buffer start.
170  Packet rewrite string will be
171  rewritten backwards and may extend
172  back before buffer->data[0].
173  Must come directly before packet data.
174  */
175 
176  u8 data[0]; /**< Packet data. Hardware DMA here */
177 } vlib_buffer_t; /* Must be a multiple of 64B. */
178 
179 #define VLIB_BUFFER_HDR_SIZE (sizeof(vlib_buffer_t) - VLIB_BUFFER_PRE_DATA_SIZE)
180 
181 /** \brief Prefetch buffer metadata.
182  The first 64 bytes of buffer contains most header information
183 
184  @param b - (vlib_buffer_t *) pointer to the buffer
185  @param type - LOAD, STORE. In most cases, STORE is the right answer
186 */
187 
188 #define vlib_prefetch_buffer_header(b,type) CLIB_PREFETCH (b, 64, type)
189 #define vlib_prefetch_buffer_data(b,type) \
190  CLIB_PREFETCH (vlib_buffer_get_current(b), CLIB_CACHE_LINE_BYTES, type)
191 
192 always_inline void
194 {
195  ASSERT (sizeof (b[0]) % 64 == 0);
196 
197  /* Rewrite data must be before and contiguous with packet data. */
199 }
200 
203 {
204  return pointer_to_uword (b->data);
205 }
206 
207 /** \brief Get pointer to current data to process
208 
209  @param b - (vlib_buffer_t *) pointer to the buffer
210  @return - (void *) (b->data + b->current_data)
211 */
212 
213 always_inline void *
215 {
216  /* Check bounds. */
217  ASSERT ((signed) b->current_data >= (signed) -VLIB_BUFFER_PRE_DATA_SIZE);
218  return b->data + b->current_data;
219 }
220 
223 {
224  return vlib_buffer_get_va (b) + b->current_data;
225 }
226 
227 /** \brief Advance current data pointer by the supplied (signed!) amount
228 
229  @param b - (vlib_buffer_t *) pointer to the buffer
230  @param l - (word) signed increment
231 */
232 always_inline void
234 {
235  ASSERT (b->current_length >= l);
236  b->current_data += l;
237  b->current_length -= l;
238 
239  ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0 ||
241 }
242 
243 /** \brief Check if there is enough space in buffer to advance
244 
245  @param b - (vlib_buffer_t *) pointer to the buffer
246  @param l - (word) size to check
247  @return - 0 if there is less space than 'l' in buffer
248 */
251 {
252  return b->current_length >= l;
253 }
254 
255 /** \brief Reset current header & length to state they were in when
256  packet was received.
257 
258  @param b - (vlib_buffer_t *) pointer to the buffer
259 */
260 
261 always_inline void
263 {
264  b->current_length += clib_max (b->current_data, 0);
265  b->current_data = 0;
266 }
267 
268 /** \brief Get pointer to buffer's opaque data array
269 
270  @param b - (vlib_buffer_t *) pointer to the buffer
271  @return - (void *) b->opaque
272 */
273 always_inline void *
275 {
276  return (void *) b->opaque;
277 }
278 
279 /** \brief Get pointer to buffer's opaque2 data array
280 
281  @param b - (vlib_buffer_t *) pointer to the buffer
282  @return - (void *) b->opaque2
283 */
284 always_inline void *
286 {
287  return (void *) b->opaque2;
288 }
289 
290 /** \brief Get pointer to the end of buffer's data
291  * @param b pointer to the buffer
292  * @return pointer to tail of packet's data
293  */
296 {
297  return b->data + b->current_data + b->current_length;
298 }
299 
300 /** \brief Append uninitialized data to buffer
301  * @param b pointer to the buffer
302  * @param size number of uninitialized bytes
303  * @return pointer to beginning of uninitialized data
304  */
305 always_inline void *
307 {
308  void *p = vlib_buffer_get_tail (b);
309  /* XXX make sure there's enough space */
310  b->current_length += size;
311  return p;
312 }
313 
314 /** \brief Prepend uninitialized data to buffer
315  * @param b pointer to the buffer
316  * @param size number of uninitialized bytes
317  * @return pointer to beginning of uninitialized data
318  */
319 always_inline void *
321 {
323  b->current_data -= size;
324  b->current_length += size;
325 
326  return vlib_buffer_get_current (b);
327 }
328 
329 /** \brief Make head room, typically for packet headers
330  * @param b pointer to the buffer
331  * @param size number of head room bytes
332  * @return pointer to start of buffer (current data)
333  */
334 always_inline void *
336 {
338  b->current_data += size;
339  return vlib_buffer_get_current (b);
340 }
341 
342 /** \brief Retrieve bytes from buffer head
343  * @param b pointer to the buffer
344  * @param size number of bytes to pull
345  * @return pointer to start of buffer (current data)
346  */
347 always_inline void *
349 {
351  return 0;
352 
353  void *data = vlib_buffer_get_current (b);
354  vlib_buffer_advance (b, size);
355  return data;
356 }
357 
358 /* Forward declaration. */
359 struct vlib_main_t;
360 
362 {
363  /* Template buffer used to initialize first 16 bytes of buffers
364  allocated on this free list. */
366 
367  /* Our index into vlib_main_t's buffer_free_list_pool. */
368  vlib_buffer_free_list_index_t index;
369 
370  /* Number of data bytes for buffers in this free list. */
372 
373  /* Number of buffers to allocate when we need to allocate new buffers */
375 
376  /* Total number of buffers allocated from this free list. */
378 
379  /* Vector of free buffers. Each element is a byte offset into I/O heap. */
381 
382  /* index of buffer pool used to get / put buffers */
384 
385  /* Free list name. */
387 
388  /* Callback functions to initialize newly allocated buffers.
389  If null buffers are zeroed. */
391  struct vlib_buffer_free_list_t * fl,
392  u32 * buffers, u32 n_buffers);
393 
395 } __attribute__ ((aligned (16))) vlib_buffer_free_list_t;
396 
399  uword min_free_buffers);
400 typedef void (vlib_buffer_free_cb_t) (struct vlib_main_t * vm, u32 * buffers,
401  u32 n_buffers);
402 typedef void (vlib_buffer_free_no_next_cb_t) (struct vlib_main_t * vm,
403  u32 * buffers, u32 n_buffers);
404 
405 typedef struct
406 {
410  void (*vlib_buffer_delete_free_list_cb) (struct vlib_main_t * vm,
411  vlib_buffer_free_list_index_t
412  free_list_index);
414 
416 
417 typedef struct
418 {
419  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
428 
429 typedef struct
430 {
431  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
432  /* Virtual memory address and size of buffer memory, used for calculating
433  buffer index */
437 
438  /* Buffer free callback, for subversive activities */
439  u32 (*buffer_free_callback) (struct vlib_main_t * vm,
440  u32 * buffers,
441  u32 n_buffers, u32 follow_buffer_next);
442 #define VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX (0)
443 #define VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES VLIB_BUFFER_DATA_SIZE
444 
445  /* Hash table mapping buffer size (rounded to next unit of
446  sizeof (vlib_buffer_t)) to free list index. */
448 
449  /* Hash table mapping buffer index into number
450  0 => allocated but free, 1 => allocated and not-free.
451  If buffer index is not in hash table then this buffer
452  has never been allocated. */
455 
456  /* Callbacks */
460 
462 
465 {
467  return vec_elt_at_index (bm->buffer_pools, buffer_pool_index);
468 }
469 
471  u32 physmem_map_index);
472 
474 
475 
476 void *vlib_set_buffer_free_callback (struct vlib_main_t *vm, void *fp);
477 
478 /*
479  */
480 
481 /** \brief Compile time buffer trajectory tracing option
482  Turn this on if you run into "bad monkey" contexts,
483  and you want to know exactly which nodes they've visited...
484  See vlib/main.c...
485 */
486 #define VLIB_BUFFER_TRACE_TRAJECTORY 0
487 
488 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
489 extern void (*vlib_buffer_trace_trajectory_cb) (vlib_buffer_t * b, u32 index);
490 extern void (*vlib_buffer_trace_trajectory_init_cb) (vlib_buffer_t * b);
491 extern void vlib_buffer_trace_trajectory_init (vlib_buffer_t * b);
492 #define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b) \
493  vlib_buffer_trace_trajectory_init (b);
494 #else
495 #define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b)
496 #endif /* VLIB_BUFFER_TRACE_TRAJECTORY */
497 
498 #endif /* included_vlib_buffer_h */
499 
500 #define VLIB_BUFFER_REGISTER_CALLBACKS(x,...) \
501  __VA_ARGS__ vlib_buffer_callbacks_t __##x##_buffer_callbacks; \
502 static void __vlib_add_buffer_callbacks_t_##x (void) \
503  __attribute__((__constructor__)) ; \
504 static void __vlib_add_buffer_callbacks_t_##x (void) \
505 { \
506  if (vlib_buffer_callbacks) \
507  clib_panic ("vlib buffer callbacks already registered"); \
508  vlib_buffer_callbacks = &__##x##_buffer_callbacks; \
509 } \
510 static void __vlib_rm_buffer_callbacks_t_##x (void) \
511  __attribute__((__destructor__)) ; \
512 static void __vlib_rm_buffer_callbacks_t_##x (void) \
513 { vlib_buffer_callbacks = 0; } \
514 __VA_ARGS__ vlib_buffer_callbacks_t __##x##_buffer_callbacks
515 
516 /*
517  * fd.io coding-style-patch-verification: ON
518  *
519  * Local Variables:
520  * eval: (c-set-style "gnu")
521  * End:
522  */
#define CLIB_CACHE_LINE_ALIGN_MARK(mark)
Definition: cache.h:60
static u8 * vlib_buffer_get_tail(vlib_buffer_t *b)
Get pointer to the end of buffer&#39;s data.
Definition: buffer.h:295
static uword vlib_buffer_get_current_va(vlib_buffer_t *b)
Definition: buffer.h:222
static void vlib_buffer_reset(vlib_buffer_t *b)
Reset current header & length to state they were in when packet was received.
Definition: buffer.h:262
u32 current_config_index
Used by feature subgraph arcs to visit enabled feature nodes.
Definition: buffer.h:136
uword() vlib_buffer_fill_free_list_cb_t(struct vlib_main_t *vm, vlib_buffer_free_list_t *fl, uword min_free_buffers)
Definition: buffer.h:397
u32 opaque[10]
Opaque data used by sub-graphs for their own purposes.
Definition: buffer.h:146
vlib_buffer_callbacks_t cb
Definition: buffer.h:457
vlib_buffer_t buffer_init_template
Definition: buffer.h:365
#define VLIB_BUFFER_PRE_DATA_SIZE
Definition: buffer.h:52
u32 physmem_map_index
Definition: buffer.h:423
u8 buffer_pool_index
index of buffer pool this buffer belongs.
Definition: buffer.h:144
u16 vlib_error_t
Definition: error.h:43
#define STRUCT_MARK(mark)
Definition: clib.h:70
u32 recycle_count
Used by L2 path recycle code.
Definition: buffer.h:154
uword log2_page_size
Definition: buffer.h:422
vlib_buffer_free_list_index_t index
Definition: buffer.h:368
unsigned char u8
Definition: types.h:56
vlib_buffer_main_t buffer_main
Definition: buffer.c:56
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:110
#define static_always_inline
Definition: clib.h:99
i64 word
Definition: types.h:111
void(* buffer_init_function)(struct vlib_main_t *vm, struct vlib_buffer_free_list_t *fl, u32 *buffers, u32 n_buffers)
Definition: buffer.h:390
#define always_inline
Definition: clib.h:98
void * vlib_set_buffer_free_callback(struct vlib_main_t *vm, void *fp)
Definition: buffer.c:556
uword buffer_mem_size
Definition: buffer.h:435
vlib_buffer_free_no_next_cb_t * vlib_buffer_free_no_next_cb
Definition: buffer.h:409
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
u8 pre_data[VLIB_BUFFER_PRE_DATA_SIZE]
Space for inserting data before buffer start.
Definition: buffer.h:168
unsigned int u32
Definition: types.h:88
#define fl(x, y)
int callbacks_registered
Definition: buffer.h:458
uword size
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:114
void() vlib_buffer_free_cb_t(struct vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Definition: buffer.h:400
static void * vlib_buffer_make_headroom(vlib_buffer_t *b, u8 size)
Make head room, typically for packet headers.
Definition: buffer.h:335
unsigned short u16
Definition: types.h:57
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:214
vlib_buffer_pool_t * buffer_pools
Definition: buffer.h:436
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:139
clib_spinlock_t buffer_known_hash_lockp
Definition: buffer.h:454
vlib_buffer_fill_free_list_cb_t * vlib_buffer_fill_free_list_cb
Definition: buffer.h:407
u32 flow_id
Generic flow identifier.
Definition: buffer.h:127
vlib_main_t * vm
Definition: buffer.c:301
clib_spinlock_t lock
Definition: buffer.h:426
static void * vlib_get_buffer_opaque2(vlib_buffer_t *b)
Get pointer to buffer&#39;s opaque2 data array.
Definition: buffer.h:285
#define ASSERT(truth)
vlib_buffer_free_cb_t * vlib_buffer_free_cb
Definition: buffer.h:408
u32 next_buffer
Next buffer for this linked-list of buffers.
Definition: buffer.h:130
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:233
static uword pointer_to_uword(const void *p)
Definition: types.h:131
u8 n_add_refs
Number of additional references to this buffer.
Definition: buffer.h:142
#define clib_max(x, y)
Definition: clib.h:288
void() vlib_buffer_free_no_next_cb_t(struct vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Definition: buffer.h:402
u32 total_length_not_including_first_buffer
Only valid for first buffer in chain.
Definition: buffer.h:156
static void * vlib_buffer_push_uninit(vlib_buffer_t *b, u8 size)
Prepend uninitialized data to buffer.
Definition: buffer.h:320
static u8 vlib_buffer_has_space(vlib_buffer_t *b, word l)
Check if there is enough space in buffer to advance.
Definition: buffer.h:250
u32 opaque2[12]
More opaque data, see ../vnet/vnet/buffer.h.
Definition: buffer.h:164
static void * vlib_get_buffer_opaque(vlib_buffer_t *b)
Get pointer to buffer&#39;s opaque data array.
Definition: buffer.h:274
u64 uword
Definition: types.h:112
uword buffer_mem_start
Definition: buffer.h:434
uword * buffer_known_hash
Definition: buffer.h:453
#define VLIB_BUFFER_MIN_CHAIN_SEG_SIZE
Definition: buffer.h:57
clib_error_t * vlib_buffer_main_init(struct vlib_main_t *vm)
Definition: buffer.c:907
static uword vlib_buffer_get_va(vlib_buffer_t *b)
Definition: buffer.h:202
u8 data[0]
Packet data.
Definition: buffer.h:176
static void * vlib_buffer_pull(vlib_buffer_t *b, u8 size)
Retrieve bytes from buffer head.
Definition: buffer.h:348
static_always_inline vlib_buffer_pool_t * vlib_buffer_pool_get(u8 buffer_pool_index)
Definition: buffer.h:464
u8 vlib_buffer_free_list_index_t
Definition: buffer.h:62
#define foreach_vlib_buffer_flag
Buffer Flags.
Definition: buffer.h:74
static void * vlib_buffer_put_uninit(vlib_buffer_t *b, u16 size)
Append uninitialized data to buffer.
Definition: buffer.h:306
u8 vlib_buffer_register_physmem_map(struct vlib_main_t *vm, u32 physmem_map_index)
Definition: buffer.c:804
uword buffer_init_function_opaque
Definition: buffer.h:394
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:117
static void vlib_buffer_struct_is_sane(vlib_buffer_t *b)
Definition: buffer.h:193
u32 trace_index
Specifies index into trace buffer if VLIB_PACKET_IS_TRACED flag is set.
Definition: buffer.h:151
uword * free_list_by_size
Definition: buffer.h:447
vlib_buffer_callbacks_t * vlib_buffer_callbacks
Definition: buffer.c:49
signed short i16
Definition: types.h:46
vlib_buffer_free_list_index_t free_list_index
Definition: buffer.h:160