FD.io VPP  v21.06-3-gbb25fbf28
Vector Packet Processing
interface_rx_dpo.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 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 
17 #include <vnet/fib/fib_node.h>
18 #include <vnet/l2/l2_input.h>
19 
20 #ifndef CLIB_MARCH_VARIANT
22 
23 /*
24  * The 'DB' of interface DPOs.
25  * There is only one per-interface per-protocol, so this is a per-interface
26  * vector
27  */
29 
30 static interface_rx_dpo_t *
32 {
33  interface_rx_dpo_t *ido;
34 
36 
37  return (ido);
38 }
39 
40 static inline interface_rx_dpo_t *
42 {
44 
45  return (interface_rx_dpo_get(dpo->dpoi_index));
46 }
47 
48 static inline index_t
50 {
51  return (ido - interface_rx_dpo_pool);
52 }
53 
54 static void
56 {
57  interface_rx_dpo_t *ido;
58 
60  ido->ido_locks++;
61 }
62 
63 static void
65 {
66  interface_rx_dpo_t *ido;
67 
69  ido->ido_locks--;
70 
71  if (0 == ido->ido_locks)
72  {
76  }
77 }
78 
79 /*
80  * interface_rx_dpo_add_or_lock
81  *
82  * Add/create and lock a new or lock an existing for the interface DPO
83  * on the interface and protocol given
84  */
85 void
88  dpo_id_t *dpo)
89 {
90  interface_rx_dpo_t *ido;
91 
95 
97  {
98  ido = interface_rx_dpo_alloc();
99 
101  ido->ido_proto = proto;
102 
105  }
106  else
107  {
109  }
110 
112 }
113 #endif /* CLIB_MARCH_VARIANT */
114 
115 
116 static clib_error_t *
119  u32 flags)
120 {
121  /*
122  */
123  return (NULL);
124 }
125 
128 
129 /**
130  * @brief Registered callback for HW interface state changes
131  */
132 static clib_error_t *
134  u32 hw_if_index,
135  u32 flags)
136 {
137  return (NULL);
138 }
139 
142 
143 static clib_error_t *
146  u32 is_add)
147 {
148  return (NULL);
149 }
150 
153 
154 #ifndef CLIB_MARCH_VARIANT
155 static u8*
156 format_interface_rx_dpo (u8* s, va_list *ap)
157 {
158  index_t index = va_arg(*ap, index_t);
159  CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
160  vnet_main_t * vnm = vnet_get_main();
162 
163  return (format(s, "%U-rx-dpo: %U",
165  vnm,
167  format_dpo_proto, ido->ido_proto));
168 }
169 
170 static void
172 {
173  fib_show_memory_usage("Interface",
176  sizeof(interface_rx_dpo_t));
177 }
178 
179 
182  .dv_unlock = interface_rx_dpo_unlock,
183  .dv_format = format_interface_rx_dpo,
184  .dv_mem_show = interface_rx_dpo_mem_show,
185 };
186 
187 /**
188  * @brief The per-protocol VLIB graph nodes that are assigned to a glean
189  * object.
190  *
191  * this means that these graph nodes are ones from which a glean is the
192  * parent object in the DPO-graph.
193  */
194 const static char* const interface_rx_dpo_ip4_nodes[] =
195 {
196  "interface-rx-dpo-ip4",
197  NULL,
198 };
199 const static char* const interface_rx_dpo_ip6_nodes[] =
200 {
201  "interface-rx-dpo-ip6",
202  NULL,
203 };
204 const static char* const interface_rx_dpo_l2_nodes[] =
205 {
206  "interface-rx-dpo-l2",
207  NULL,
208 };
209 
210 const static char* const * const interface_rx_dpo_nodes[DPO_PROTO_NUM] =
211 {
215  [DPO_PROTO_MPLS] = NULL,
216 };
217 
218 void
220 {
224 }
225 #endif /* CLIB_MARCH_VARIANT */
226 
227 /**
228  * @brief Interface DPO trace data
229  */
231 {
234 
236 {
240 
245  u8 is_l2)
246 {
247  u32 n_left_from, next_index, * from, * to_next;
250 
253  n_left_from = from_frame->n_vectors;
254 
256 
257  while (n_left_from > 0)
258  {
259  u32 n_left_to_next;
260 
261  vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
262 
263  while (n_left_from >= 4 && n_left_to_next > 2)
264  {
265  const interface_rx_dpo_t *ido0, *ido1;
266  u32 bi0, idoi0, bi1, idoi1;
267  vlib_buffer_t *b0, *b1;
268 
269  bi0 = from[0];
270  to_next[0] = bi0;
271  bi1 = from[1];
272  to_next[1] = bi1;
273  from += 2;
274  to_next += 2;
275  n_left_from -= 2;
276  n_left_to_next -= 2;
277 
278  b0 = vlib_get_buffer (vm, bi0);
279  b1 = vlib_get_buffer (vm, bi1);
280 
281  idoi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
282  idoi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
283  ido0 = interface_rx_dpo_get(idoi0);
284  ido1 = interface_rx_dpo_get(idoi1);
285 
286  vnet_buffer(b0)->sw_if_index[VLIB_RX] = ido0->ido_sw_if_index;
287  vnet_buffer(b1)->sw_if_index[VLIB_RX] = ido1->ido_sw_if_index;
288 
289  if (is_l2)
290  {
291  vnet_update_l2_len (b0);
292  vnet_update_l2_len (b1);
293  }
294 
297  thread_index,
298  ido0->ido_sw_if_index,
299  1,
303  thread_index,
304  ido1->ido_sw_if_index,
305  1,
307 
308  if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
309  {
311 
312  tr0 = vlib_add_trace (vm, node, b0, sizeof (*tr0));
313  tr0->sw_if_index = ido0->ido_sw_if_index;
314  }
315  if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
316  {
318 
319  tr1 = vlib_add_trace (vm, node, b1, sizeof (*tr1));
320  tr1->sw_if_index = ido1->ido_sw_if_index;
321  }
322  }
323 
324  while (n_left_from > 0 && n_left_to_next > 0)
325  {
326  const interface_rx_dpo_t * ido0;
327  vlib_buffer_t * b0;
328  u32 bi0, idoi0;
329 
330  bi0 = from[0];
331  to_next[0] = bi0;
332  from += 1;
333  to_next += 1;
334  n_left_from -= 1;
335  n_left_to_next -= 1;
336 
337  b0 = vlib_get_buffer (vm, bi0);
338 
339  idoi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
340  ido0 = interface_rx_dpo_get(idoi0);
341 
342  /* Swap the RX interface of the packet to the one the
343  * interface DPR represents */
344  vnet_buffer(b0)->sw_if_index[VLIB_RX] = ido0->ido_sw_if_index;
345 
346  /* Update l2_len to make l2 tag rewrite work */
347  if (is_l2)
348  vnet_update_l2_len (b0);
349 
350  /* Bump the interface's RX coutners */
353  thread_index,
354  ido0->ido_sw_if_index,
355  1,
357 
358  if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
359  {
361 
362  tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
363  tr->sw_if_index = ido0->ido_sw_if_index;
364  }
365  }
366  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
367  }
368  return from_frame->n_vectors;
369 }
370 
371 static u8 *
372 format_interface_rx_dpo_trace (u8 * s, va_list * args)
373 {
374  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
375  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
376  interface_rx_dpo_trace_t * t = va_arg (*args, interface_rx_dpo_trace_t *);
377  u32 indent = format_get_indent (s);
378  s = format (s, "%U sw_if_index:%d",
379  format_white_space, indent,
380  t->sw_if_index);
381  return s;
382 }
383 
387 {
388  return (interface_rx_dpo_inline(vm, node, from_frame, 0));
389 }
390 
394 {
395  return (interface_rx_dpo_inline(vm, node, from_frame, 0));
396 }
397 
401 {
402  return (interface_rx_dpo_inline(vm, node, from_frame, 1));
403 }
404 
406  .name = "interface-rx-dpo-ip4",
407  .vector_size = sizeof (u32),
408  .format_trace = format_interface_rx_dpo_trace,
409 
410  .n_next_nodes = 2,
411  .next_nodes = {
412  [INTERFACE_RX_DPO_DROP] = "ip4-drop",
413  [INTERFACE_RX_DPO_INPUT] = "ip4-input",
414  },
415 };
416 
417 
419  .name = "interface-rx-dpo-ip6",
420  .vector_size = sizeof (u32),
421  .format_trace = format_interface_rx_dpo_trace,
422 
423  .n_next_nodes = 2,
424  .next_nodes = {
425  [INTERFACE_RX_DPO_DROP] = "ip6-drop",
426  [INTERFACE_RX_DPO_INPUT] = "ip6-input",
427  },
428 };
429 
430 
432  .name = "interface-rx-dpo-l2",
433  .vector_size = sizeof (u32),
434  .format_trace = format_interface_rx_dpo_trace,
435 
436  .n_next_nodes = 2,
437  .next_nodes = {
438  [INTERFACE_RX_DPO_DROP] = "error-drop",
439  [INTERFACE_RX_DPO_INPUT] = "l2-input",
440  },
441 };
442 
interface_rx_dpo_next_t
enum interface_rx_dpo_next_t_ interface_rx_dpo_next_t
im
vnet_interface_main_t * im
Definition: interface_output.c:395
dpo_id_t_::dpoi_index
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:190
interface_rx_dpo_get_index
static index_t interface_rx_dpo_get_index(interface_rx_dpo_t *ido)
Definition: interface_rx_dpo.c:49
thread_index
u32 thread_index
Definition: nat44_ei_hairpinning.c:492
interface_rx_dpo_db
static index_t * interface_rx_dpo_db[DPO_PROTO_NUM]
Definition: interface_rx_dpo.c:28
interface_rx_dpo_t_::ido_proto
dpo_proto_t ido_proto
DPO protocol that the packets will have as they 'ingress' on this interface.
Definition: interface_rx_dpo.h:44
next_index
nat44_ei_hairpin_src_next_t next_index
Definition: nat44_ei_hairpinning.c:412
interface_rx_dpo_t_::ido_sw_if_index
u32 ido_sw_if_index
The Software interface index that the packets will be given as the ingress/rx interface.
Definition: interface_rx_dpo.h:33
dpo_proto_t
enum dpo_proto_t_ dpo_proto_t
Data path protocol.
vlib_get_buffer
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:111
dpo_id_t_::dpoi_type
dpo_type_t dpoi_type
the type
Definition: dpo.h:178
interface_rx_dpo_ip4_node
vlib_node_registration_t interface_rx_dpo_ip4_node
(constructor) VLIB_REGISTER_NODE (interface_rx_dpo_ip4_node)
Definition: interface_rx_dpo.c:405
INTERFACE_RX_DPO_DROP
@ INTERFACE_RX_DPO_DROP
Definition: interface_rx_dpo.c:237
node
vlib_main_t vlib_node_runtime_t * node
Definition: nat44_ei.c:3047
VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION
VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION(interface_rx_dpo_hw_interface_state_change)
vnet_interface_main_t
Definition: interface.h:989
interface_rx_dpo_get_from_dpo
static interface_rx_dpo_t * interface_rx_dpo_get_from_dpo(const dpo_id_t *dpo)
Definition: interface_rx_dpo.c:41
DPO_INTERFACE_RX
@ DPO_INTERFACE_RX
Definition: dpo.h:119
pool_put
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:305
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
VLIB_RX
@ VLIB_RX
Definition: defs.h:46
vnet_get_sw_interface
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface_funcs.h:58
interface_rx_dpo_ip6_node
vlib_node_registration_t interface_rx_dpo_ip6_node
(constructor) VLIB_REGISTER_NODE (interface_rx_dpo_ip6_node)
Definition: interface_rx_dpo.c:418
from_frame
vlib_main_t vlib_node_runtime_t vlib_frame_t * from_frame
Definition: esp_encrypt.c:1328
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(interface_rx_dpo_interface_state_change)
fib_node.h
interface_rx_dpo_trace_t_::sw_if_index
u32 sw_if_index
Definition: interface_rx_dpo.c:232
vlib_frame_t
Definition: node.h:372
format_interface_rx_dpo_trace
static u8 * format_interface_rx_dpo_trace(u8 *s, va_list *args)
Definition: interface_rx_dpo.c:372
vlib_buffer_length_in_chain
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:433
interface_rx_dpo_unlock
static void interface_rx_dpo_unlock(dpo_id_t *dpo)
Definition: interface_rx_dpo.c:64
interface_rx_dpo_trace_t
struct interface_rx_dpo_trace_t_ interface_rx_dpo_trace_t
Interface DPO trace data.
VNET_SW_INTERFACE_ADD_DEL_FUNCTION
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(interface_rx_dpo_interface_delete)
VLIB_NODE_FN
#define VLIB_NODE_FN(node)
Definition: node.h:202
interface_rx_dpo_trace_t_
Interface DPO trace data.
Definition: interface_rx_dpo.c:230
interface_rx_dpo_l2_nodes
const static char *const interface_rx_dpo_l2_nodes[]
Definition: interface_rx_dpo.c:204
CLIB_UNUSED
#define CLIB_UNUSED(x)
Definition: clib.h:90
interface_rx_dpo_ip4_nodes
const static char *const interface_rx_dpo_ip4_nodes[]
The per-protocol VLIB graph nodes that are assigned to a glean object.
Definition: interface_rx_dpo.c:194
vnet_buffer
#define vnet_buffer(b)
Definition: buffer.h:437
interface_rx_dpo_inline
static uword interface_rx_dpo_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, u8 is_l2)
Definition: interface_rx_dpo.c:242
interface_rx_dpo_next_t_
interface_rx_dpo_next_t_
Definition: interface_rx_dpo.c:235
vnet_get_main
vnet_main_t * vnet_get_main(void)
Definition: pnat_test_stubs.h:56
interface_rx_dpo_nodes
const static char *const *const interface_rx_dpo_nodes[DPO_PROTO_NUM]
Definition: interface_rx_dpo.c:210
PREDICT_FALSE
#define PREDICT_FALSE(x)
Definition: clib.h:124
vlib_frame_vector_args
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:301
index_t
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:43
fib_show_memory_usage
void fib_show_memory_usage(const char *name, u32 in_use_elts, u32 allocd_elts, size_t size_elt)
Show the memory usage for a type.
Definition: fib_node.c:220
uword
u64 uword
Definition: types.h:112
interface_rx_dpo_l2_node
vlib_node_registration_t interface_rx_dpo_l2_node
(constructor) VLIB_REGISTER_NODE (interface_rx_dpo_l2_node)
Definition: interface_rx_dpo.c:431
vlib_main_t::thread_index
u32 thread_index
Definition: main.h:213
format_interface_rx_dpo
static u8 * format_interface_rx_dpo(u8 *s, va_list *ap)
Definition: interface_rx_dpo.c:156
pool_get
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:255
dpo_vft_t_::dv_lock
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:428
interface_rx_dpo_ip6_nodes
const static char *const interface_rx_dpo_ip6_nodes[]
Definition: interface_rx_dpo.c:199
VNET_INTERFACE_COUNTER_RX
@ VNET_INTERFACE_COUNTER_RX
Definition: interface.h:914
interface_rx_dpo.h
vlib_node_registration_t
struct _vlib_node_registration vlib_node_registration_t
vnet_interface_main_t::combined_sw_if_counters
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:1023
l2_input.h
vnet_main_t
Definition: vnet.h:76
pool_len
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:139
index
u32 index
Definition: flow_types.api:221
always_inline
#define always_inline
Definition: rdma_mlx5dv.h:23
vnet_update_l2_len
static u16 vnet_update_l2_len(vlib_buffer_t *b)
Definition: l2_input.h:298
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
format_get_indent
static u32 format_get_indent(u8 *s)
Definition: format.h:72
vec_validate_init_empty
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header,...
Definition: vec.h:570
vlib_put_next_frame
vlib_put_next_frame(vm, node, next_index, 0)
DPO_PROTO_IP6
@ DPO_PROTO_IP6
Definition: dpo.h:65
DPO_PROTO_MPLS
@ DPO_PROTO_MPLS
Definition: dpo.h:66
interface_rx_dpo_module_init
void interface_rx_dpo_module_init(void)
Definition: interface_rx_dpo.c:219
u32
unsigned int u32
Definition: types.h:88
interface_rx_dpo_alloc
static interface_rx_dpo_t * interface_rx_dpo_alloc(void)
Definition: interface_rx_dpo.c:31
interface_rx_dpo_lock
static void interface_rx_dpo_lock(dpo_id_t *dpo)
Definition: interface_rx_dpo.c:55
interface_rx_dpo_add_or_lock
void interface_rx_dpo_add_or_lock(dpo_proto_t proto, u32 sw_if_index, dpo_id_t *dpo)
Definition: interface_rx_dpo.c:86
pool_elts
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:127
vlib_main_t
Definition: main.h:102
vlib_node_t
Definition: node.h:247
dpo_vft_t_
A virtual function table regisitered for a DPO type.
Definition: dpo.h:423
format_dpo_proto
u8 * format_dpo_proto(u8 *s, va_list *args)
format a DPO protocol
Definition: dpo.c:180
vlib_add_trace
void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace.c:628
u8
unsigned char u8
Definition: types.h:56
clib_error_t
Definition: clib_error.h:21
DPO_PROTO_IP4
@ DPO_PROTO_IP4
Definition: dpo.h:64
dpo_id_t_
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:172
interface_rx_dpo_get
static interface_rx_dpo_t * interface_rx_dpo_get(index_t index)
Definition: interface_rx_dpo.h:64
interface_rx_dpo_hw_interface_state_change
static clib_error_t * interface_rx_dpo_hw_interface_state_change(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Registered callback for HW interface state changes.
Definition: interface_rx_dpo.c:133
DPO_PROTO_ETHERNET
@ DPO_PROTO_ETHERNET
Definition: dpo.h:67
interface_rx_dpo_pool
interface_rx_dpo_t * interface_rx_dpo_pool
pool of all interface DPOs
Definition: interface_rx_dpo.c:21
dpo_set
void dpo_set(dpo_id_t *dpo, dpo_type_t type, dpo_proto_t proto, index_t index)
Set/create a DPO ID The DPO will be locked.
Definition: dpo.c:188
vlib_node_runtime_t
Definition: node.h:454
proto
vl_api_ip_proto_t proto
Definition: acl_types.api:51
from
from
Definition: nat44_ei_hairpinning.c:415
INDEX_INVALID
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:49
sw_if_index
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
vlib_get_next_frame
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:395
interface_rx_dpo_vft
const static dpo_vft_t interface_rx_dpo_vft
Definition: interface_rx_dpo.c:180
VLIB_TX
@ VLIB_TX
Definition: defs.h:47
interface_rx_dpo_interface_delete
static clib_error_t * interface_rx_dpo_interface_delete(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
Definition: interface_rx_dpo.c:144
interface_rx_dpo_interface_state_change
static clib_error_t * interface_rx_dpo_interface_state_change(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: interface_rx_dpo.c:117
INTERFACE_RX_DPO_INPUT
@ INTERFACE_RX_DPO_INPUT
Definition: interface_rx_dpo.c:238
n_left_from
n_left_from
Definition: nat44_ei_hairpinning.c:416
DPO_PROTO_NUM
#define DPO_PROTO_NUM
Definition: dpo.h:72
interface_rx_dpo_t_::ido_locks
u16 ido_locks
number of locks.
Definition: interface_rx_dpo.h:49
vnet_main_t::interface_main
vnet_interface_main_t interface_main
Definition: vnet.h:81
vlib_increment_combined_counter
vlib_increment_combined_counter(ccm, ti, sw_if_index, n_buffers, n_bytes)
format_white_space
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
interface_rx_dpo_t_
The data-path object representing a change of receive interface.
Definition: interface_rx_dpo.h:27
vlib_buffer_t::flags
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index,...
Definition: buffer.h:133
format_vnet_sw_interface_name
format_function_t format_vnet_sw_interface_name
Definition: interface_funcs.h:453
dpo_register
void dpo_register(dpo_type_t type, const dpo_vft_t *vft, const char *const *const *nodes)
For a given DPO type Register:
Definition: dpo.c:329
interface_rx_dpo_mem_show
static void interface_rx_dpo_mem_show(void)
Definition: interface_rx_dpo.c:171
vlib_buffer_t
VLIB buffer representation.
Definition: buffer.h:111
VLIB_REGISTER_NODE
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
flags
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105