FD.io VPP  v17.01-9-ge7dcee4
Vector Packet Processing
l2_flood.c
Go to the documentation of this file.
1 /*
2  * l2_flood.c : layer 2 flooding
3  *
4  * Copyright (c) 2013 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <vlib/vlib.h>
19 #include <vnet/vnet.h>
20 #include <vnet/pg/pg.h>
21 #include <vnet/ethernet/ethernet.h>
22 #include <vlib/cli.h>
23 #include <vnet/l2/l2_input.h>
24 #include <vnet/l2/feat_bitmap.h>
25 #include <vnet/l2/l2_bvi.h>
26 #include <vnet/replication.h>
27 #include <vnet/l2/l2_fib.h>
28 
29 #include <vppinfra/error.h>
30 #include <vppinfra/hash.h>
31 
32 
33 /**
34  * @file
35  * @brief Ethernet Flooding.
36  *
37  * Flooding uses the packet replication infrastructure to send a copy of the
38  * packet to each member interface. Logically the replication infrastructure
39  * expects two graph nodes: a prep node that initiates replication and sends the
40  * packet to the first destination, and a recycle node that is passed the packet
41  * after it has been transmitted.
42  *
43  * To decrease the amount of code, l2 flooding implements both functions in
44  * the same graph node. This node can tell if is it being called as the "prep"
45  * or "recycle" using replication_is_recycled().
46  */
47 
48 
49 typedef struct
50 {
51 
52  /* Next nodes for each feature */
53  u32 feat_next_node_index[32];
54 
55  /* next node index for the L3 input node of each ethertype */
57 
58  /* convenience variables */
62 
63 typedef struct
64 {
65  u8 src[6];
66  u8 dst[6];
70 
71 
72 /* packet trace format function */
73 static u8 *
74 format_l2flood_trace (u8 * s, va_list * args)
75 {
76  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
77  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
78  l2flood_trace_t *t = va_arg (*args, l2flood_trace_t *);
79 
80  s = format (s, "l2-flood: sw_if_index %d dst %U src %U bd_index %d",
81  t->sw_if_index,
84  return s;
85 }
86 
88 
90 
91 #define foreach_l2flood_error \
92 _(L2FLOOD, "L2 flood packets") \
93 _(REPL_FAIL, "L2 replication failures") \
94 _(NO_MEMBERS, "L2 replication complete") \
95 _(BVI_BAD_MAC, "BVI L3 mac mismatch") \
96 _(BVI_ETHERTYPE, "BVI packet with unhandled ethertype")
97 
98 typedef enum
99 {
100 #define _(sym,str) L2FLOOD_ERROR_##sym,
102 #undef _
105 
106 static char *l2flood_error_strings[] = {
107 #define _(sym,string) string,
109 #undef _
110 };
111 
112 typedef enum
113 {
118 
119 /*
120  * Perform flooding on one packet
121  *
122  * Due to the way BVI processing can modify the packet, the BVI interface
123  * (if present) must be processed last in the replication. The member vector
124  * is arranged so that the BVI interface is always the first element.
125  * Flooding walks the vector in reverse.
126  *
127  * BVI processing causes the packet to go to L3 processing. This strips the
128  * L2 header, which is fine because the replication infrastructure restores
129  * it. However L3 processing can trigger larger changes to the packet. For
130  * example, an ARP request could be turned into an ARP reply, an ICMP request
131  * could be turned into an ICMP reply. If BVI processing is not performed
132  * last, the modified packet would be replicated to the remaining members.
133  */
134 
137  vlib_node_runtime_t * node,
138  l2flood_main_t * msm,
139  u64 * counter_base,
140  vlib_buffer_t * b0,
141  u32 * sw_if_index0,
142  l2fib_entry_key_t * key0,
143  u32 * bucket0, l2fib_entry_result_t * result0, u32 * next0)
144 {
145  u16 bd_index0;
146  l2_bridge_domain_t *bd_config;
147  l2_flood_member_t *members;
148  i32 current_member; /* signed */
150  u8 in_shg = vnet_buffer (b0)->l2.shg;
151 
152  if (!replication_is_recycled (b0))
153  {
154 
155  /* Do flood "prep node" processing */
156 
157  /* Get config for the bridge domain interface */
158  bd_index0 = vnet_buffer (b0)->l2.bd_index;
159  bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index0);
160  members = bd_config->members;
161 
162  /* Find first member that passes the reflection and SHG checks */
163  current_member = bd_config->flood_count - 1;
164  while ((current_member >= 0) &&
165  ((members[current_member].sw_if_index == *sw_if_index0) ||
166  (in_shg && members[current_member].shg == in_shg)))
167  {
168  current_member--;
169  }
170 
171  if (current_member < 0)
172  {
173  /* No members to flood to */
174  *next0 = L2FLOOD_NEXT_DROP;
175  b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS];
176  return;
177  }
178 
179  if ((current_member > 0) &&
180  ((current_member > 1) ||
181  ((members[0].sw_if_index != *sw_if_index0) &&
182  (!in_shg || members[0].shg != in_shg))))
183  {
184  /* If more than one member then initiate replication */
185  ctx =
186  replication_prep (vm, b0, l2flood_node.index, 1 /* l2_packet */ );
187  ctx->feature_replicas = (uword) members;
188  ctx->feature_counter = current_member;
189  }
190 
191  }
192  else
193  {
194  vnet_buffer_opaque_t *vnet_buff_op;
195 
196  /* Do flood "recycle node" processing */
197 
199  {
200  (void) replication_recycle (vm, b0, 1 /* is_last */ );
201  *next0 = L2FLOOD_NEXT_DROP;
202  b0->error = node->errors[L2FLOOD_ERROR_REPL_FAIL];
203  return;
204  }
205 
206  ctx = replication_get_ctx (b0);
208 
209  members = (l2_flood_member_t *) (intptr_t) ctx->feature_replicas;
210  current_member = (i32) ctx->feature_counter - 1;
211 
212  /* Need to update input index from saved packet context */
213  vnet_buff_op = (vnet_buffer_opaque_t *) ctx->vnet_buffer;
214  *sw_if_index0 = vnet_buff_op->sw_if_index[VLIB_RX];
215 
216  /* Find next member that passes the reflection and SHG check */
217  while ((current_member >= 0) &&
218  ((members[current_member].sw_if_index == *sw_if_index0) ||
219  (in_shg && members[current_member].shg == in_shg)))
220  {
221  current_member--;
222  }
223 
224  if (current_member < 0)
225  {
226  /*
227  * No more members to flood to.
228  * Terminate replication and drop packet.
229  */
230 
231  replication_recycle (vm, b0, 1 /* is_last */ );
232 
233  *next0 = L2FLOOD_NEXT_DROP;
234  /* Ideally we woudn't bump a counter here, just silently complete */
235  b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS];
236  return;
237  }
238 
239  /* Restore packet and context and continue replication */
240  ctx->feature_counter = current_member;
241  replication_recycle (vm, b0, ((current_member == 0) || /*is_last */
242  ((current_member == 1) &&
243  ((members[0].sw_if_index ==
244  *sw_if_index0) || (in_shg
245  && members[0].shg ==
246  in_shg)))));
247  }
248 
249  /* Forward packet to the current member */
250  if (PREDICT_FALSE (members[current_member].flags & L2_FLOOD_MEMBER_BVI))
251  {
252  /* Do BVI processing */
253  u32 rc;
254  rc = l2_to_bvi (vm,
255  msm->vnet_main,
256  b0,
257  members[current_member].sw_if_index,
258  &msm->l3_next, next0);
259 
260  if (PREDICT_FALSE (rc))
261  {
262  if (rc == TO_BVI_ERR_BAD_MAC)
263  {
264  b0->error = node->errors[L2FLOOD_ERROR_BVI_BAD_MAC];
265  *next0 = L2FLOOD_NEXT_DROP;
266  }
267  else if (rc == TO_BVI_ERR_ETHERTYPE)
268  {
269  b0->error = node->errors[L2FLOOD_ERROR_BVI_ETHERTYPE];
270  *next0 = L2FLOOD_NEXT_DROP;
271  }
272  }
273  }
274  else
275  {
276  /* Do normal L2 forwarding */
277  vnet_buffer (b0)->sw_if_index[VLIB_TX] =
278  members[current_member].sw_if_index;
279  *next0 = L2FLOOD_NEXT_L2_OUTPUT;
280 
281  }
282 
283 }
284 
285 
286 static uword
288  vlib_node_runtime_t * node, vlib_frame_t * frame)
289 {
290  u32 n_left_from, *from, *to_next;
291  l2flood_next_t next_index;
293  vlib_node_t *n = vlib_get_node (vm, l2flood_node.index);
294  u32 node_counter_base_index = n->error_heap_index;
295  vlib_error_main_t *em = &vm->error_main;
296 
297  from = vlib_frame_vector_args (frame);
298  n_left_from = frame->n_vectors; /* number of packets to process */
299  next_index = node->cached_next_index;
300 
301  while (n_left_from > 0)
302  {
303  u32 n_left_to_next;
304 
305  /* get space to enqueue frame to graph node "next_index" */
306  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
307 
308  while (n_left_from >= 6 && n_left_to_next >= 2)
309  {
310  u32 bi0, bi1;
311  vlib_buffer_t *b0, *b1;
312  u32 next0, next1;
313  u32 sw_if_index0, sw_if_index1;
314  l2fib_entry_key_t key0, key1;
315  l2fib_entry_result_t result0, result1;
316  u32 bucket0, bucket1;
317 
318  /* Prefetch next iteration. */
319  {
320  vlib_buffer_t *p2, *p3, *p4, *p5;
321 
322  p2 = vlib_get_buffer (vm, from[2]);
323  p3 = vlib_get_buffer (vm, from[3]);
324  p4 = vlib_get_buffer (vm, from[4]);
325  p5 = vlib_get_buffer (vm, from[5]);
326 
327  /* Prefetch the buffer header for the N+2 loop iteration */
328  vlib_prefetch_buffer_header (p4, LOAD);
329  vlib_prefetch_buffer_header (p5, LOAD);
330 
331  /* Prefetch the replication context for the N+1 loop iteration */
332  /* This depends on the buffer header above */
335 
336  /* Prefetch the packet for the N+1 loop iteration */
339  }
340 
341  /* speculatively enqueue b0 and b1 to the current next frame */
342  /* bi is "buffer index", b is pointer to the buffer */
343  to_next[0] = bi0 = from[0];
344  to_next[1] = bi1 = from[1];
345  from += 2;
346  to_next += 2;
347  n_left_from -= 2;
348  n_left_to_next -= 2;
349 
350  b0 = vlib_get_buffer (vm, bi0);
351  b1 = vlib_get_buffer (vm, bi1);
352 
353  /* RX interface handles */
354  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
355  sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
356 
357  /* process 2 pkts */
358  em->counters[node_counter_base_index + L2FLOOD_ERROR_L2FLOOD] += 2;
359 
360  l2flood_process (vm, node, msm,
361  &em->counters[node_counter_base_index], b0,
362  &sw_if_index0, &key0, &bucket0, &result0, &next0);
363 
364  l2flood_process (vm, node, msm,
365  &em->counters[node_counter_base_index], b1,
366  &sw_if_index1, &key1, &bucket1, &result1, &next1);
367 
368  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
369  {
371  {
372  l2flood_trace_t *t =
373  vlib_add_trace (vm, node, b0, sizeof (*t));
375  t->sw_if_index = sw_if_index0;
376  t->bd_index = vnet_buffer (b0)->l2.bd_index;
377  clib_memcpy (t->src, h0->src_address, 6);
378  clib_memcpy (t->dst, h0->dst_address, 6);
379  }
381  {
382  l2flood_trace_t *t =
383  vlib_add_trace (vm, node, b1, sizeof (*t));
385  t->sw_if_index = sw_if_index1;
386  t->bd_index = vnet_buffer (b1)->l2.bd_index;
387  clib_memcpy (t->src, h1->src_address, 6);
388  clib_memcpy (t->dst, h1->dst_address, 6);
389  }
390  }
391 
392  /* verify speculative enqueues, maybe switch current next frame */
393  /* if next0==next1==next_index then nothing special needs to be done */
394  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
395  to_next, n_left_to_next,
396  bi0, bi1, next0, next1);
397  }
398 
399  while (n_left_from > 0 && n_left_to_next > 0)
400  {
401  u32 bi0;
402  vlib_buffer_t *b0;
403  u32 next0;
404  u32 sw_if_index0;
405  l2fib_entry_key_t key0;
406  l2fib_entry_result_t result0;
407  u32 bucket0;
408 
409  /* speculatively enqueue b0 to the current next frame */
410  bi0 = from[0];
411  to_next[0] = bi0;
412  from += 1;
413  to_next += 1;
414  n_left_from -= 1;
415  n_left_to_next -= 1;
416 
417  b0 = vlib_get_buffer (vm, bi0);
418 
419  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
420 
421  /* process 1 pkt */
422  em->counters[node_counter_base_index + L2FLOOD_ERROR_L2FLOOD] += 1;
423 
424  l2flood_process (vm, node, msm,
425  &em->counters[node_counter_base_index], b0,
426  &sw_if_index0, &key0, &bucket0, &result0, &next0);
427 
428  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
429  (b0->flags & VLIB_BUFFER_IS_TRACED)))
430  {
431  l2flood_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
433  t->sw_if_index = sw_if_index0;
434  t->bd_index = vnet_buffer (b0)->l2.bd_index;
435  clib_memcpy (t->src, h0->src_address, 6);
436  clib_memcpy (t->dst, h0->dst_address, 6);
437  }
438 
439  /* verify speculative enqueue, maybe switch current next frame */
440  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
441  to_next, n_left_to_next,
442  bi0, next0);
443  }
444 
445  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
446  }
447 
448  return frame->n_vectors;
449 }
450 
451 
452 /* *INDENT-OFF* */
453 VLIB_REGISTER_NODE (l2flood_node,static) = {
454  .function = l2flood_node_fn,
455  .name = "l2-flood",
456  .vector_size = sizeof (u32),
457  .format_trace = format_l2flood_trace,
459 
460  .n_errors = ARRAY_LEN(l2flood_error_strings),
461  .error_strings = l2flood_error_strings,
462 
463  .n_next_nodes = L2FLOOD_N_NEXT,
464 
465  /* edit / add dispositions here */
466  .next_nodes = {
467  [L2FLOOD_NEXT_L2_OUTPUT] = "l2-output",
468  [L2FLOOD_NEXT_DROP] = "error-drop",
469  },
470 };
471 /* *INDENT-ON* */
472 
475 {
477 
478  mp->vlib_main = vm;
479  mp->vnet_main = vnet_get_main ();
480 
481  /* Initialize the feature next-node indexes */
483  l2flood_node.index,
487 
488  return 0;
489 }
490 
492 
493 
494 
495 /** Add the L3 input node for this ethertype to the next nodes structure. */
496 void
498  ethernet_type_t type, u32 node_index)
499 {
501  u32 next_index;
502 
503  next_index = vlib_node_add_next (vm, l2flood_node.index, node_index);
504 
505  next_by_ethertype_register (&mp->l3_next, type, next_index);
506 }
507 
508 
509 /**
510  * Set subinterface flood enable/disable.
511  * The CLI format is:
512  * set interface l2 flood <interface> [disable]
513  */
514 static clib_error_t *
516  unformat_input_t * input, vlib_cli_command_t * cmd)
517 {
518  vnet_main_t *vnm = vnet_get_main ();
519  clib_error_t *error = 0;
520  u32 sw_if_index;
521  u32 enable;
522 
523  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
524  {
525  error = clib_error_return (0, "unknown interface `%U'",
526  format_unformat_error, input);
527  goto done;
528  }
529 
530  enable = 1;
531  if (unformat (input, "disable"))
532  {
533  enable = 0;
534  }
535 
536  /* set the interface flag */
537  l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_FLOOD, enable);
538 
539 done:
540  return error;
541 }
542 
543 /*?
544  * Layer 2 flooding can be enabled and disabled on each
545  * interface and on each bridge-domain. Use this command to
546  * manage interfaces. It is enabled by default.
547  *
548  * @cliexpar
549  * Example of how to enable flooding:
550  * @cliexcmd{set interface l2 flood GigabitEthernet0/8/0}
551  * Example of how to disable flooding:
552  * @cliexcmd{set interface l2 flood GigabitEthernet0/8/0 disable}
553 ?*/
554 /* *INDENT-OFF* */
555 VLIB_CLI_COMMAND (int_flood_cli, static) = {
556  .path = "set interface l2 flood",
557  .short_help = "set interface l2 flood <interface> [disable]",
558  .function = int_flood,
559 };
560 /* *INDENT-ON* */
561 
562 /*
563  * fd.io coding-style-patch-verification: ON
564  *
565  * Local Variables:
566  * eval: (c-set-style "gnu")
567  * End:
568  */
u32 feat_next_node_index[32]
Definition: l2_flood.c:53
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:459
vnet_main_t * vnet_main
Definition: l2_flood.c:60
l2flood_next_t
Definition: l2_flood.c:112
u32 error_heap_index
Definition: node.h:278
#define CLIB_UNUSED(x)
Definition: clib.h:79
uword unformat(unformat_input_t *i, char *fmt,...)
Definition: unformat.c:966
#define TO_BVI_ERR_BAD_MAC
Definition: l2_bvi.h:28
bad routing header type(not 4)") sr_error (NO_MORE_SEGMENTS
ethernet_type_t
Definition: packet.h:43
#define TO_BVI_ERR_ETHERTYPE
Definition: l2_bvi.h:29
static_always_inline u32 l2_to_bvi(vlib_main_t *vlib_main, vnet_main_t *vnet_main, vlib_buffer_t *b0, u32 bvi_sw_if_index, next_by_ethertype_t *l3_next, u32 *next0)
Send a packet from L2 processing to L3 via the BVI interface.
Definition: l2_bvi.h:38
u8 src_address[6]
Definition: packet.h:54
vlib_main_t * vlib_main
Definition: l2_flood.c:59
l2flood_main_t l2flood_main
Definition: l2_flood.c:87
static void replication_clear_recycled(vlib_buffer_t *b0)
Definition: replication.h:86
static uword l2flood_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: l2_flood.c:287
void l2flood_register_input_type(vlib_main_t *vm, ethernet_type_t type, u32 node_index)
Add the L3 input node for this ethertype to the next nodes structure.
Definition: l2_flood.c:497
struct _vlib_node_registration vlib_node_registration_t
l2_flood_member_t * members
Definition: l2_bd.h:71
static char * l2flood_error_strings[]
Definition: l2_flood.c:106
unformat_function_t unformat_vnet_sw_interface
Definition: l2_fib.h:56
#define L2_FLOOD_MEMBER_BVI
Definition: l2_bd.h:42
vlib_error_t * errors
Definition: node.h:419
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1063
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
#define static_always_inline
Definition: clib.h:85
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:194
u8 dst_address[6]
Definition: packet.h:53
static u8 * format_l2flood_trace(u8 *s, va_list *args)
Definition: l2_flood.c:74
int i32
Definition: types.h:81
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
unsigned long u64
Definition: types.h:89
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:977
static void replication_prefetch_ctx(vlib_buffer_t *b0)
Definition: replication.h:109
vlib_error_main_t error_main
Definition: main.h:124
#define PREDICT_FALSE(x)
Definition: clib.h:97
static vlib_node_registration_t l2flood_node
(constructor) VLIB_REGISTER_NODE (l2flood_node)
Definition: l2_flood.c:89
replication_context_t * replication_prep(vlib_main_t *vm, vlib_buffer_t *b0, u32 recycle_node_index, u32 l2_packet)
Definition: replication.c:29
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
Definition: buffer_node.h:70
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:216
#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:350
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:121
u64 * counters
Definition: error.h:78
clib_error_t * next_by_ethertype_register(next_by_ethertype_t *l3_next, u32 ethertype, u32 next_index)
Definition: node.c:1207
u16 n_vectors
Definition: node.h:344
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
static void feat_bitmap_init_next_nodes(vlib_main_t *vm, u32 node_index, u32 num_features, char **feat_names, u32 *next_nodes)
Initialize the feature next-node indexes of a graph node.
Definition: feat_bitmap.h:43
u32 sw_if_index[VLIB_N_RX_TX]
Definition: buffer.h:105
#define clib_memcpy(a, b, c)
Definition: string.h:69
#define ARRAY_LEN(x)
Definition: clib.h:59
char ** l2input_get_feat_names(void)
Return an array of strings containing graph node names of each feature.
Definition: l2_input.c:57
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
static replication_context_t * replication_get_ctx(vlib_buffer_t *b0)
Definition: replication.h:98
u16 cached_next_index
Definition: node.h:463
static u32 replication_is_recycled(vlib_buffer_t *b0)
Definition: replication.h:76
#define VLIB_BUFFER_REPL_FAIL
Definition: buffer.h:100
unsigned int u32
Definition: types.h:88
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
#define vnet_buffer(b)
Definition: buffer.h:361
Definition: l2_fib.h:33
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:259
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:95
u64 uword
Definition: types.h:112
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:55
u32 l2input_intf_bitmap_enable(u32 sw_if_index, u32 feature_bitmap, u32 enable)
Enable (or disable) the feature in the bitmap for the given interface.
Definition: l2_input.c:468
Definition: defs.h:47
unsigned short u16
Definition: types.h:57
l2input_main_t l2input_main
Definition: l2_input.c:87
unsigned char u8
Definition: types.h:56
#define foreach_l2flood_error
Definition: l2_flood.c:91
l2flood_error_t
Definition: l2_flood.c:98
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:253
l2_bridge_domain_t * bd_configs
Definition: l2_input.h:69
replication_context_t * replication_recycle(vlib_main_t *vm, vlib_buffer_t *b0, u32 is_last)
Definition: replication.c:93
static_always_inline void l2flood_process(vlib_main_t *vm, vlib_node_runtime_t *node, l2flood_main_t *msm, u64 *counter_base, vlib_buffer_t *b0, u32 *sw_if_index0, l2fib_entry_key_t *key0, u32 *bucket0, l2fib_entry_result_t *result0, u32 *next0)
Definition: l2_flood.c:136
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:170
#define VLIB_NODE_FUNCTION_MULTIARCH(node, fn)
Definition: node.h:158
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
u8 data[0]
Packet data.
Definition: buffer.h:158
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:58
u32 sw_if_index
Definition: l2_bd.h:46
#define clib_error_return(e, args...)
Definition: error.h:111
struct _unformat_input_t unformat_input_t
next_by_ethertype_t l3_next
Definition: l2_flood.c:56
u32 flags
Definition: vhost-user.h:75
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:85
static clib_error_t * int_flood(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Set subinterface flood enable/disable.
Definition: l2_flood.c:515
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:57
Definition: defs.h:46
clib_error_t * l2flood_init(vlib_main_t *vm)
Definition: l2_flood.c:474