FD.io VPP  v18.07.1-19-g511ce25
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 
55 
56 /** \file
57  vlib buffer structure definition and a few select
58  access methods. This structure and the buffer allocation
59  mechanism should perhaps live in vnet, but it would take a lot
60  of typing to make it so.
61 */
62 
63 /**
64  * Buffer Flags
65  */
66 #define foreach_vlib_buffer_flag \
67  _( 0, NON_DEFAULT_FREELIST, "non-default-fl") \
68  _( 1, IS_TRACED, 0) \
69  _( 2, NEXT_PRESENT, 0) \
70  _( 3, IS_RECYCLED, "is-recycled") \
71  _( 4, TOTAL_LENGTH_VALID, 0) \
72  _( 5, REPL_FAIL, "repl-fail") \
73  _( 6, RECYCLE, "recycle") \
74  _( 7, EXT_HDR_VALID, "ext-hdr-valid")
75 
76 /* NOTE: only buffer generic flags should be defined here, please consider
77  using user flags. i.e. src/vnet/buffer.h */
78 
79 enum
80 {
81 #define _(bit, name, v) VLIB_BUFFER_##name = (1 << (bit)),
83 #undef _
84 };
85 
86 enum
87 {
88 #define _(bit, name, v) VLIB_BUFFER_LOG2_##name = (bit),
90 #undef _
91 };
92 
93  /* User defined buffer flags. */
94 #define LOG2_VLIB_BUFFER_FLAG_USER(n) (32 - (n))
95 #define VLIB_BUFFER_FLAG_USER(n) (1 << LOG2_VLIB_BUFFER_FLAG_USER(n))
96 
97 /* VLIB buffer representation. */
98 typedef struct
99 {
100  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
101  STRUCT_MARK (template_start);
102  /* Offset within data[] that we are currently processing.
103  If negative current header points into predata area. */
104  i16 current_data; /**< signed offset in data[], pre_data[]
105  that we are currently processing.
106  If negative current header points into predata area.
107  */
108  u16 current_length; /**< Nbytes between current data and
109  the end of this buffer.
110  */
111  u32 flags; /**< buffer flags:
112  <br> VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index,
113  <br> VLIB_BUFFER_IS_TRACED: trace this buffer.
114  <br> VLIB_BUFFER_NEXT_PRESENT: this is a multi-chunk buffer.
115  <br> VLIB_BUFFER_TOTAL_LENGTH_VALID: as it says
116  <br> VLIB_BUFFER_REPL_FAIL: packet replication failure
117  <br> VLIB_BUFFER_RECYCLE: as it says
118  <br> VLIB_BUFFER_EXT_HDR_VALID: buffer contains valid external buffer manager header,
119  set to avoid adding it to a flow report
120  <br> VLIB_BUFFER_FLAG_USER(n): user-defined bit N
121  */
122 
123  u32 flow_id; /**< Generic flow identifier */
124 
125 
126  u32 next_buffer; /**< Next buffer for this linked-list of buffers.
127  Only valid if VLIB_BUFFER_NEXT_PRESENT flag is set.
128  */
129 
130  STRUCT_MARK (template_end);
131 
132  u32 current_config_index; /**< Used by feature subgraph arcs to
133  visit enabled feature nodes
134  */
135  vlib_error_t error; /**< Error code for buffers to be enqueued
136  to error handler.
137  */
138  u8 n_add_refs; /**< Number of additional references to this buffer. */
139 
140  u8 buffer_pool_index; /**< index of buffer pool this buffer belongs. */
141 
142  u32 opaque[10]; /**< Opaque data used by sub-graphs for their own purposes.
143  See .../vnet/vnet/buffer.h
144  */
145  CLIB_CACHE_LINE_ALIGN_MARK (cacheline1);
146 
147  u32 trace_index; /**< Specifies index into trace buffer
148  if VLIB_PACKET_IS_TRACED flag is set.
149  */
150  u32 recycle_count; /**< Used by L2 path recycle code */
151 
153  /**< Only valid for first buffer in chain. Current length plus
154  total length given here give total number of bytes in buffer chain.
155  */
156  vlib_buffer_free_list_index_t free_list_index; /** < only used if
157  VLIB_BUFFER_NON_DEFAULT_FREELIST
158  flag is set */
159  u8 align_pad[3]; /**< available */
160  u32 opaque2[12]; /**< More opaque data, see ../vnet/vnet/buffer.h */
161 
162  /***** end of second cache line */
163  CLIB_CACHE_LINE_ALIGN_MARK (cacheline2);
164  u8 pre_data[VLIB_BUFFER_PRE_DATA_SIZE]; /**< Space for inserting data
165  before buffer start.
166  Packet rewrite string will be
167  rewritten backwards and may extend
168  back before buffer->data[0].
169  Must come directly before packet data.
170  */
171 
172  u8 data[0]; /**< Packet data. Hardware DMA here */
173 } vlib_buffer_t; /* Must be a multiple of 64B. */
174 
175 #define VLIB_BUFFER_HDR_SIZE (sizeof(vlib_buffer_t) - VLIB_BUFFER_PRE_DATA_SIZE)
176 
177 /** \brief Prefetch buffer metadata.
178  The first 64 bytes of buffer contains most header information
179 
180  @param b - (vlib_buffer_t *) pointer to the buffer
181  @param type - LOAD, STORE. In most cases, STORE is the right answer
182 */
183 
184 #define vlib_prefetch_buffer_header(b,type) CLIB_PREFETCH (b, 64, type)
185 
186 always_inline void
188 {
189  ASSERT (sizeof (b[0]) % 64 == 0);
190 
191  /* Rewrite data must be before and contiguous with packet data. */
193 }
194 
195 /** \brief Get pointer to current data to process
196 
197  @param b - (vlib_buffer_t *) pointer to the buffer
198  @return - (void *) (b->data + b->current_data)
199 */
200 
201 always_inline void *
203 {
204  /* Check bounds. */
205  ASSERT ((signed) b->current_data >= (signed) -VLIB_BUFFER_PRE_DATA_SIZE);
206  return b->data + b->current_data;
207 }
208 
209 /** \brief Advance current data pointer by the supplied (signed!) amount
210 
211  @param b - (vlib_buffer_t *) pointer to the buffer
212  @param l - (word) signed increment
213 */
214 always_inline void
216 {
217  ASSERT (b->current_length >= l);
218  b->current_data += l;
219  b->current_length -= l;
220 }
221 
222 /** \brief Check if there is enough space in buffer to advance
223 
224  @param b - (vlib_buffer_t *) pointer to the buffer
225  @param l - (word) size to check
226  @return - 0 if there is less space than 'l' in buffer
227 */
230 {
231  return b->current_length >= l;
232 }
233 
234 /** \brief Reset current header & length to state they were in when
235  packet was received.
236 
237  @param b - (vlib_buffer_t *) pointer to the buffer
238 */
239 
240 always_inline void
242 {
243  b->current_length += clib_max (b->current_data, 0);
244  b->current_data = 0;
245 }
246 
247 /** \brief Get pointer to buffer's opaque data array
248 
249  @param b - (vlib_buffer_t *) pointer to the buffer
250  @return - (void *) b->opaque
251 */
252 always_inline void *
254 {
255  return (void *) b->opaque;
256 }
257 
258 /** \brief Get pointer to buffer's opaque2 data array
259 
260  @param b - (vlib_buffer_t *) pointer to the buffer
261  @return - (void *) b->opaque2
262 */
263 always_inline void *
265 {
266  return (void *) b->opaque2;
267 }
268 
269 /** \brief Get pointer to the end of buffer's data
270  * @param b pointer to the buffer
271  * @return pointer to tail of packet's data
272  */
275 {
276  return b->data + b->current_data + b->current_length;
277 }
278 
279 /** \brief Append uninitialized data to buffer
280  * @param b pointer to the buffer
281  * @param size number of uninitialized bytes
282  * @return pointer to beginning of uninitialized data
283  */
284 always_inline void *
286 {
287  void *p = vlib_buffer_get_tail (b);
288  /* XXX make sure there's enough space */
289  b->current_length += size;
290  return p;
291 }
292 
293 /** \brief Prepend uninitialized data to buffer
294  * @param b pointer to the buffer
295  * @param size number of uninitialized bytes
296  * @return pointer to beginning of uninitialized data
297  */
298 always_inline void *
300 {
302  b->current_data -= size;
303  b->current_length += size;
304 
305  return vlib_buffer_get_current (b);
306 }
307 
308 /** \brief Make head room, typically for packet headers
309  * @param b pointer to the buffer
310  * @param size number of head room bytes
311  * @return pointer to start of buffer (current data)
312  */
313 always_inline void *
315 {
317  b->current_data += size;
318  return vlib_buffer_get_current (b);
319 }
320 
321 /** \brief Retrieve bytes from buffer head
322  * @param b pointer to the buffer
323  * @param size number of bytes to pull
324  * @return pointer to start of buffer (current data)
325  */
326 always_inline void *
328 {
330  return 0;
331 
332  void *data = vlib_buffer_get_current (b);
333  vlib_buffer_advance (b, size);
334  return data;
335 }
336 
337 /* Forward declaration. */
338 struct vlib_main_t;
339 
341 {
342  /* Template buffer used to initialize first 16 bytes of buffers
343  allocated on this free list. */
345 
346  /* Our index into vlib_main_t's buffer_free_list_pool. */
347  vlib_buffer_free_list_index_t index;
348 
349  /* Number of data bytes for buffers in this free list. */
351 
352  /* Number of buffers to allocate when we need to allocate new buffers */
354 
355  /* Total number of buffers allocated from this free list. */
357 
358  /* Vector of free buffers. Each element is a byte offset into I/O heap. */
360 
361  /* index of buffer pool used to get / put buffers */
363 
364  /* Free list name. */
366 
367  /* Callback functions to initialize newly allocated buffers.
368  If null buffers are zeroed. */
370  struct vlib_buffer_free_list_t * fl,
371  u32 * buffers, u32 n_buffers);
372 
373  /* Callback function to announce that buffers have been
374  added to the freelist */
376  (struct vlib_main_t * vm, struct vlib_buffer_free_list_t * fl);
377 
379 } __attribute__ ((aligned (16))) vlib_buffer_free_list_t;
380 
383  uword min_free_buffers);
384 typedef void (vlib_buffer_free_cb_t) (struct vlib_main_t * vm, u32 * buffers,
385  u32 n_buffers);
386 typedef void (vlib_buffer_free_no_next_cb_t) (struct vlib_main_t * vm,
387  u32 * buffers, u32 n_buffers);
388 
389 typedef struct
390 {
394  void (*vlib_packet_template_init_cb) (struct vlib_main_t * vm, void *t,
395  void *packet_data,
396  uword n_packet_data_bytes,
397  uword
398  min_n_buffers_each_physmem_alloc,
399  u8 * name);
400  void (*vlib_buffer_delete_free_list_cb) (struct vlib_main_t * vm,
401  vlib_buffer_free_list_index_t
402  free_list_index);
404 
406 
407 typedef struct
408 {
409  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
414 
416 
425 
426 typedef struct
427 {
428  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
429  /* Virtual memory address and size of buffer memory, used for calculating
430  buffer index */
434 
435  /* Buffer free callback, for subversive activities */
436  u32 (*buffer_free_callback) (struct vlib_main_t * vm,
437  u32 * buffers,
438  u32 n_buffers, u32 follow_buffer_next);
439 #define VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX (0)
440 #define VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES VLIB_BUFFER_DATA_SIZE
441 
442  /* Hash table mapping buffer size (rounded to next unit of
443  sizeof (vlib_buffer_t)) to free list index. */
445 
446  /* Hash table mapping buffer index into number
447  0 => allocated but free, 1 => allocated and not-free.
448  If buffer index is not in hash table then this buffer
449  has never been allocated. */
452 
453  /* Callbacks */
457 
459 
462 {
464  return vec_elt_at_index (bm->buffer_pools, buffer_pool_index);
465 }
466 
469  u16 buffer_size);
470 
472 
473 typedef struct
474 {
476 
477  u32 first_buffer, last_buffer;
478 
479  union
480  {
481  struct
482  {
483  /* Total accumulated bytes in chain starting with first_buffer. */
485 
486  /* Max number of bytes to accumulate in chain starting with first_buffer.
487  As this limit is reached buffers are enqueued to next node. */
489 
490  /* Next node to enqueue buffers to relative to current process node. */
492 
493  /* Free list to use to allocate new buffers. */
494  vlib_buffer_free_list_index_t free_list_index;
495  } tx;
496 
497  struct
498  {
499  /* CLIB fifo of buffer indices waiting to be unserialized. */
501 
502  /* Event type used to signal that RX buffers have been added to fifo. */
504  } rx;
505  };
507 
511  struct vlib_main_t *vm,
513 
516 void *vlib_set_buffer_free_callback (struct vlib_main_t *vm, void *fp);
517 
520 {
521  serialize_stream_t *s = &m->stream;
525  return sm->tx.n_total_data_bytes + s->current_buffer_index +
527 }
528 
529 /*
530  */
531 
532 /** \brief Compile time buffer trajectory tracing option
533  Turn this on if you run into "bad monkey" contexts,
534  and you want to know exactly which nodes they've visited...
535  See vlib/main.c...
536 */
537 #define VLIB_BUFFER_TRACE_TRAJECTORY 0
538 
539 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
540 extern void (*vlib_buffer_trace_trajectory_cb) (vlib_buffer_t * b, u32 index);
541 extern void (*vlib_buffer_trace_trajectory_init_cb) (vlib_buffer_t * b);
542 extern void vlib_buffer_trace_trajectory_init (vlib_buffer_t * b);
543 #define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b) \
544  vlib_buffer_trace_trajectory_init (b);
545 #else
546 #define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b)
547 #endif /* VLIB_BUFFER_TRACE_TRAJECTORY */
548 
549 #endif /* included_vlib_buffer_h */
550 
551 #define VLIB_BUFFER_REGISTER_CALLBACKS(x,...) \
552  __VA_ARGS__ vlib_buffer_callbacks_t __##x##_buffer_callbacks; \
553 static void __vlib_add_buffer_callbacks_t_##x (void) \
554  __attribute__((__constructor__)) ; \
555 static void __vlib_add_buffer_callbacks_t_##x (void) \
556 { \
557  if (vlib_buffer_callbacks) \
558  clib_panic ("vlib buffer callbacks already registered"); \
559  vlib_buffer_callbacks = &__##x##_buffer_callbacks; \
560 } \
561 static void __vlib_rm_buffer_callbacks_t_##x (void) \
562  __attribute__((__destructor__)) ; \
563 static void __vlib_rm_buffer_callbacks_t_##x (void) \
564 { vlib_buffer_callbacks = 0; } \
565 __VA_ARGS__ vlib_buffer_callbacks_t __##x##_buffer_callbacks
566 
567 /*
568  * fd.io coding-style-patch-verification: ON
569  *
570  * Local Variables:
571  * eval: (c-set-style "gnu")
572  * End:
573  */
vlib_physmem_region_index_t physmem_region
Definition: buffer.h:413
#define CLIB_CACHE_LINE_ALIGN_MARK(mark)
Definition: cache.h:63
static u8 * vlib_buffer_get_tail(vlib_buffer_t *b)
Get pointer to the end of buffer&#39;s data.
Definition: buffer.h:274
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:241
u32 current_config_index
Used by feature subgraph arcs to visit enabled feature nodes.
Definition: buffer.h:132
vlib_buffer_free_list_index_t free_list_index
Definition: buffer.h:494
u32 opaque[10]
Opaque data used by sub-graphs for their own purposes.
Definition: buffer.h:142
vlib_buffer_callbacks_t cb
Definition: buffer.h:454
vlib_buffer_t buffer_init_template
Definition: buffer.h:344
struct vlib_main_t * vlib_main
Definition: buffer.h:475
#define VLIB_BUFFER_PRE_DATA_SIZE
Definition: buffer.h:52
u8 buffer_pool_index
index of buffer pool this buffer belongs.
Definition: buffer.h:140
u16 vlib_error_t
Definition: error.h:44
#define STRUCT_MARK(mark)
Definition: clib.h:67
u32 recycle_count
Used by L2 path recycle code.
Definition: buffer.h:150
void unserialize_open_vlib_buffer(serialize_main_t *m, struct vlib_main_t *vm, vlib_serialize_buffer_main_t *sm)
void unserialize_close_vlib_buffer(serialize_main_t *m)
void( vlib_buffer_free_cb_t)(struct vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Definition: buffer.h:384
uword log2_page_size
Definition: buffer.h:412
vlib_buffer_free_list_index_t index
Definition: buffer.h:347
u32 serialize_close_vlib_buffer(serialize_main_t *m)
unsigned char u8
Definition: types.h:56
u8 vlib_buffer_pool_create(struct vlib_main_t *vm, vlib_physmem_region_index_t region, u16 buffer_size)
Definition: buffer.c:904
vlib_buffer_main_t buffer_main
Definition: buffer.c:52
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:104
#define static_always_inline
Definition: clib.h:93
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:369
#define always_inline
Definition: clib.h:92
void serialize_open_vlib_buffer(serialize_main_t *m, struct vlib_main_t *vm, vlib_serialize_buffer_main_t *sm)
void * vlib_set_buffer_free_callback(struct vlib_main_t *vm, void *fp)
Definition: buffer.c:561
uword buffer_mem_size
Definition: buffer.h:432
vlib_buffer_free_no_next_cb_t * vlib_buffer_free_no_next_cb
Definition: buffer.h:393
#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:164
unsigned int u32
Definition: types.h:88
static u32 serialize_vlib_buffer_n_bytes(serialize_main_t *m)
Definition: buffer.h:519
#define fl(x, y)
int callbacks_registered
Definition: buffer.h:455
uword next_clear
Definition: buffer.h:421
uword size
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:108
static void * vlib_buffer_make_headroom(vlib_buffer_t *b, u8 size)
Make head room, typically for packet headers.
Definition: buffer.h:314
static void * vlib_buffer_put_uninit(vlib_buffer_t *b, u8 size)
Append uninitialized data to buffer.
Definition: buffer.h:285
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:202
vlib_buffer_pool_t * buffer_pools
Definition: buffer.h:433
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:135
serialize_stream_t stream
Definition: serialize.h:147
clib_spinlock_t buffer_known_hash_lockp
Definition: buffer.h:451
vlib_buffer_fill_free_list_cb_t * vlib_buffer_fill_free_list_cb
Definition: buffer.h:391
u32 current_buffer_index
Definition: serialize.h:62
u32 flow_id
Generic flow identifier.
Definition: buffer.h:123
vlib_main_t * vm
Definition: buffer.c:294
clib_spinlock_t lock
Definition: buffer.h:423
static void * vlib_get_buffer_opaque2(vlib_buffer_t *b)
Get pointer to buffer&#39;s opaque2 data array.
Definition: buffer.h:264
void(* buffers_added_to_freelist_function)(struct vlib_main_t *vm, struct vlib_buffer_free_list_t *fl)
Definition: buffer.h:376
uword data_function_opaque
Definition: serialize.h:74
uword * bitmap
Definition: buffer.h:422
void( vlib_buffer_free_no_next_cb_t)(struct vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Definition: buffer.h:386
#define uword_to_pointer(u, type)
Definition: types.h:136
#define ASSERT(truth)
vlib_buffer_free_cb_t * vlib_buffer_free_cb
Definition: buffer.h:392
uword buffers_per_page
Definition: buffer.h:418
u32 next_buffer
Next buffer for this linked-list of buffers.
Definition: buffer.h:126
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:215
u8 n_add_refs
Number of additional references to this buffer.
Definition: buffer.h:138
#define clib_max(x, y)
Definition: clib.h:282
struct vlib_serialize_buffer_main_t::@32::@34 tx
u32 total_length_not_including_first_buffer
Only valid for first buffer in chain.
Definition: buffer.h:152
static void * vlib_buffer_push_uninit(vlib_buffer_t *b, u8 size)
Prepend uninitialized data to buffer.
Definition: buffer.h:299
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:229
u32 opaque2[12]
More opaque data, see ../vnet/vnet/buffer.h.
Definition: buffer.h:160
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static void * vlib_get_buffer_opaque(vlib_buffer_t *b)
Get pointer to buffer&#39;s opaque data array.
Definition: buffer.h:253
u64 uword
Definition: types.h:112
uword buffer_mem_start
Definition: buffer.h:431
uword * buffer_known_hash
Definition: buffer.h:450
clib_error_t * vlib_buffer_main_init(struct vlib_main_t *vm)
Definition: buffer.c:1018
u8 data[0]
Packet data.
Definition: buffer.h:172
static void * vlib_buffer_pull(vlib_buffer_t *b, u8 size)
Retrieve bytes from buffer head.
Definition: buffer.h:327
static_always_inline vlib_buffer_pool_t * vlib_buffer_pool_get(u8 buffer_pool_index)
Definition: buffer.h:461
u8 vlib_buffer_free_list_index_t
Definition: buffer.h:54
#define foreach_vlib_buffer_flag
Buffer Flags.
Definition: buffer.h:66
uword buffer_init_function_opaque
Definition: buffer.h:378
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:381
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:111
u8 vlib_physmem_region_index_t
Definition: physmem.h:43
static void vlib_buffer_struct_is_sane(vlib_buffer_t *b)
Definition: buffer.h:187
u32 trace_index
Specifies index into trace buffer if VLIB_PACKET_IS_TRACED flag is set.
Definition: buffer.h:147
uword * free_list_by_size
Definition: buffer.h:444
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:156