FD.io VPP  v18.07.1-13-g909ba93
Vector Packet Processing
l2_fwd.c
Go to the documentation of this file.
1 /*
2  * l2_fwd.c : layer 2 forwarding using l2fib
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 
24 #include <vnet/l2/l2_input.h>
25 #include <vnet/l2/l2_bvi.h>
26 #include <vnet/l2/l2_fwd.h>
27 #include <vnet/l2/l2_fib.h>
28 
29 #include <vppinfra/error.h>
30 #include <vppinfra/hash.h>
31 #include <vppinfra/sparse_vec.h>
32 
33 
34 /**
35  * @file
36  * @brief Ethernet Forwarding.
37  *
38  * Code in this file handles forwarding Layer 2 packets. This file calls
39  * the FIB lookup, packet learning and the packet flooding as necessary.
40  * Packet is then sent to the next graph node.
41  */
42 
43 typedef struct
44 {
45 
46  /* Hash table */
47  BVT (clib_bihash) * mac_table;
48 
49  /* next node index for the L3 input node of each ethertype */
50  next_by_ethertype_t l3_next;
51 
52  /* Next nodes for each feature */
53  u32 feat_next_node_index[32];
54 
55  /* convenience variables */
58 } l2fwd_main_t;
59 
60 typedef struct
61 {
62  /* per-pkt trace data */
63  u8 src[6];
64  u8 dst[6];
68 
69 /* packet trace format function */
70 static u8 *
71 format_l2fwd_trace (u8 * s, va_list * args)
72 {
73  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
74  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
75  l2fwd_trace_t *t = va_arg (*args, l2fwd_trace_t *);
76 
77  s = format (s, "l2-fwd: sw_if_index %d dst %U src %U bd_index %d",
78  t->sw_if_index,
81  return s;
82 }
83 
85 
87 
88 #define foreach_l2fwd_error \
89 _(L2FWD, "L2 forward packets") \
90 _(FLOOD, "L2 forward misses") \
91 _(HIT, "L2 forward hits") \
92 _(BVI_BAD_MAC, "BVI L3 MAC mismatch") \
93 _(BVI_ETHERTYPE, "BVI packet with unhandled ethertype") \
94 _(FILTER_DROP, "Filter Mac Drop") \
95 _(REFLECT_DROP, "Reflection Drop") \
96 _(STALE_DROP, "Stale entry Drop")
97 
98 typedef enum
99 {
100 #define _(sym,str) L2FWD_ERROR_##sym,
102 #undef _
104 } l2fwd_error_t;
105 
106 static char *l2fwd_error_strings[] = {
107 #define _(sym,string) string,
109 #undef _
110 };
111 
112 typedef enum
113 {
117 } l2fwd_next_t;
118 
119 /** Forward one packet based on the mac table lookup result. */
120 
123  vlib_node_runtime_t * node,
124  l2fwd_main_t * msm,
125  vlib_error_main_t * em,
126  vlib_buffer_t * b0,
127  u32 sw_if_index0, l2fib_entry_result_t * result0, u32 * next0)
128 {
129  int try_flood = result0->raw == ~0;
130  int flood_error;
131 
132  if (PREDICT_FALSE (try_flood))
133  {
134  flood_error = L2FWD_ERROR_FLOOD;
135  }
136  else
137  {
138  /* lookup hit, forward packet */
139 #ifdef COUNTERS
140  em->counters[node_counter_base_index + L2FWD_ERROR_HIT] += 1;
141 #endif
142 
143  vnet_buffer (b0)->sw_if_index[VLIB_TX] = result0->fields.sw_if_index;
144  *next0 = L2FWD_NEXT_L2_OUTPUT;
145  int l2fib_seq_num_valid = 1;
146 
147  /* check l2fib seq num for stale entries */
148  if (!result0->fields.age_not)
149  {
150  l2fib_seq_num_t in_sn = {.as_u16 = vnet_buffer (b0)->l2.l2fib_sn };
151  l2fib_seq_num_t expected_sn = {
152  .bd = in_sn.bd,
153  .swif = *l2fib_swif_seq_num (result0->fields.sw_if_index),
154  };
155  l2fib_seq_num_valid =
156  expected_sn.as_u16 == result0->fields.sn.as_u16;
157  }
158 
159  if (PREDICT_FALSE (!l2fib_seq_num_valid))
160  {
161  flood_error = L2FWD_ERROR_STALE_DROP;
162  try_flood = 1;
163  }
164  /* perform reflection check */
165  else if (PREDICT_FALSE (sw_if_index0 == result0->fields.sw_if_index))
166  {
167  b0->error = node->errors[L2FWD_ERROR_REFLECT_DROP];
168  *next0 = L2FWD_NEXT_DROP;
169  }
170  /* perform filter check */
171  else if (PREDICT_FALSE (result0->fields.filter))
172  {
173  b0->error = node->errors[L2FWD_ERROR_FILTER_DROP];
174  *next0 = L2FWD_NEXT_DROP;
175  }
176  /* perform BVI check */
177  else if (PREDICT_FALSE (result0->fields.bvi))
178  {
179  u32 rc;
180  rc = l2_to_bvi (vm,
181  msm->vnet_main,
182  b0,
183  vnet_buffer (b0)->sw_if_index[VLIB_TX],
184  &msm->l3_next, next0);
185 
186  if (PREDICT_FALSE (rc))
187  {
188  if (rc == TO_BVI_ERR_BAD_MAC)
189  {
190  b0->error = node->errors[L2FWD_ERROR_BVI_BAD_MAC];
191  *next0 = L2FWD_NEXT_DROP;
192  }
193  else if (rc == TO_BVI_ERR_ETHERTYPE)
194  {
195  b0->error = node->errors[L2FWD_ERROR_BVI_ETHERTYPE];
196  *next0 = L2FWD_NEXT_DROP;
197  }
198  }
199  }
200  }
201 
202  /* flood */
203  if (PREDICT_FALSE (try_flood))
204  {
205  /*
206  * lookup miss, so flood which is typically the next feature
207  * unless some other feature is inserted before uu_flood
208  */
209  if (vnet_buffer (b0)->l2.feature_bitmap & L2INPUT_FEAT_UU_FLOOD)
210  {
211  *next0 = vnet_l2_feature_next (b0, msm->feat_next_node_index,
212  L2INPUT_FEAT_FWD);
213  }
214  else
215  {
216  /* Flooding is disabled */
217  b0->error = node->errors[flood_error];
218  *next0 = L2FWD_NEXT_DROP;
219  }
220  }
221 
222 }
223 
224 
227  vlib_frame_t * frame, int do_trace)
228 {
229  u32 n_left_from, *from, *to_next;
230  l2fwd_next_t next_index;
231  l2fwd_main_t *msm = &l2fwd_main;
232  vlib_node_t *n = vlib_get_node (vm, l2fwd_node.index);
233  CLIB_UNUSED (u32 node_counter_base_index) = n->error_heap_index;
234  vlib_error_main_t *em = &vm->error_main;
235  l2fib_entry_key_t cached_key;
236  l2fib_entry_result_t cached_result;
237 
238  /* Clear the one-entry cache in case mac table was updated */
239  cached_key.raw = ~0;
240  cached_result.raw = ~0;
241 
242  from = vlib_frame_vector_args (frame);
243  n_left_from = frame->n_vectors; /* number of packets to process */
244  next_index = node->cached_next_index;
245 
246  while (n_left_from > 0)
247  {
248  u32 n_left_to_next;
249 
250  /* get space to enqueue frame to graph node "next_index" */
251  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
252 
253  while (n_left_from >= 8 && n_left_to_next >= 4)
254  {
255  u32 bi0, bi1, bi2, bi3;
256  vlib_buffer_t *b0, *b1, *b2, *b3;
257  u32 next0, next1, next2, next3;
258  u32 sw_if_index0, sw_if_index1, sw_if_index2, sw_if_index3;
259  ethernet_header_t *h0, *h1, *h2, *h3;
260  l2fib_entry_key_t key0, key1, key2, key3;
261  l2fib_entry_result_t result0, result1, result2, result3;
262  u32 bucket0, bucket1, bucket2, bucket3;
263 
264  /* Prefetch next iteration. */
265  {
266  vlib_buffer_t *p4, *p5, *p6, *p7;
267 
268  p4 = vlib_get_buffer (vm, from[4]);
269  p5 = vlib_get_buffer (vm, from[5]);
270  p6 = vlib_get_buffer (vm, from[6]);
271  p7 = vlib_get_buffer (vm, from[7]);
272 
273  vlib_prefetch_buffer_header (p4, LOAD);
274  vlib_prefetch_buffer_header (p5, LOAD);
275  vlib_prefetch_buffer_header (p6, LOAD);
276  vlib_prefetch_buffer_header (p7, LOAD);
277 
282  }
283 
284  /* speculatively enqueue b0 and b1 to the current next frame */
285  /* bi is "buffer index", b is pointer to the buffer */
286  to_next[0] = bi0 = from[0];
287  to_next[1] = bi1 = from[1];
288  to_next[2] = bi2 = from[2];
289  to_next[3] = bi3 = from[3];
290  from += 4;
291  to_next += 4;
292  n_left_from -= 4;
293  n_left_to_next -= 4;
294 
295  b0 = vlib_get_buffer (vm, bi0);
296  b1 = vlib_get_buffer (vm, bi1);
297  b2 = vlib_get_buffer (vm, bi2);
298  b3 = vlib_get_buffer (vm, bi3);
299 
300  /* RX interface handles */
301  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
302  sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
303  sw_if_index2 = vnet_buffer (b2)->sw_if_index[VLIB_RX];
304  sw_if_index3 = vnet_buffer (b3)->sw_if_index[VLIB_RX];
305 
306  h0 = vlib_buffer_get_current (b0);
307  h1 = vlib_buffer_get_current (b1);
308  h2 = vlib_buffer_get_current (b2);
309  h3 = vlib_buffer_get_current (b3);
310 
311  if (do_trace)
312  {
313  if (b0->flags & VLIB_BUFFER_IS_TRACED)
314  {
315  l2fwd_trace_t *t =
316  vlib_add_trace (vm, node, b0, sizeof (*t));
317  t->sw_if_index = sw_if_index0;
318  t->bd_index = vnet_buffer (b0)->l2.bd_index;
319  clib_memcpy (t->src, h0->src_address, 6);
320  clib_memcpy (t->dst, h0->dst_address, 6);
321  }
322  if (b1->flags & VLIB_BUFFER_IS_TRACED)
323  {
324  l2fwd_trace_t *t =
325  vlib_add_trace (vm, node, b1, sizeof (*t));
326  t->sw_if_index = sw_if_index1;
327  t->bd_index = vnet_buffer (b1)->l2.bd_index;
328  clib_memcpy (t->src, h1->src_address, 6);
329  clib_memcpy (t->dst, h1->dst_address, 6);
330  }
331  if (b2->flags & VLIB_BUFFER_IS_TRACED)
332  {
333  l2fwd_trace_t *t =
334  vlib_add_trace (vm, node, b2, sizeof (*t));
335  t->sw_if_index = sw_if_index2;
336  t->bd_index = vnet_buffer (b2)->l2.bd_index;
337  clib_memcpy (t->src, h2->src_address, 6);
338  clib_memcpy (t->dst, h2->dst_address, 6);
339  }
340  if (b3->flags & VLIB_BUFFER_IS_TRACED)
341  {
342  l2fwd_trace_t *t =
343  vlib_add_trace (vm, node, b3, sizeof (*t));
344  t->sw_if_index = sw_if_index3;
345  t->bd_index = vnet_buffer (b3)->l2.bd_index;
346  clib_memcpy (t->src, h3->src_address, 6);
347  clib_memcpy (t->dst, h3->dst_address, 6);
348  }
349  }
350 
351  /* process 2 pkts */
352 #ifdef COUNTERS
353  em->counters[node_counter_base_index + L2FWD_ERROR_L2FWD] += 4;
354 #endif
355  /* *INDENT-OFF* */
356  l2fib_lookup_4 (msm->mac_table, &cached_key, &cached_result,
357  h0->dst_address, h1->dst_address,
358  h2->dst_address, h3->dst_address,
359  vnet_buffer (b0)->l2.bd_index,
360  vnet_buffer (b1)->l2.bd_index,
361  vnet_buffer (b2)->l2.bd_index,
362  vnet_buffer (b3)->l2.bd_index,
363  &key0, /* not used */
364  &key1, /* not used */
365  &key2, /* not used */
366  &key3, /* not used */
367  &bucket0, /* not used */
368  &bucket1, /* not used */
369  &bucket2, /* not used */
370  &bucket3, /* not used */
371  &result0,
372  &result1,
373  &result2,
374  &result3);
375  /* *INDENT-ON* */
376  l2fwd_process (vm, node, msm, em, b0, sw_if_index0, &result0,
377  &next0);
378  l2fwd_process (vm, node, msm, em, b1, sw_if_index1, &result1,
379  &next1);
380  l2fwd_process (vm, node, msm, em, b2, sw_if_index2, &result2,
381  &next2);
382  l2fwd_process (vm, node, msm, em, b3, sw_if_index3, &result3,
383  &next3);
384 
385  /* verify speculative enqueues, maybe switch current next frame */
386  /* if next0==next1==next_index then nothing special needs to be done */
387  vlib_validate_buffer_enqueue_x4 (vm, node, next_index,
388  to_next, n_left_to_next,
389  bi0, bi1, bi2, bi3,
390  next0, next1, next2, next3);
391  }
392 
393  while (n_left_from > 0 && n_left_to_next > 0)
394  {
395  u32 bi0;
396  vlib_buffer_t *b0;
397  u32 next0;
398  u32 sw_if_index0;
399  ethernet_header_t *h0;
400  l2fib_entry_key_t key0;
401  l2fib_entry_result_t result0;
402  u32 bucket0;
403 
404  /* speculatively enqueue b0 to the current next frame */
405  bi0 = from[0];
406  to_next[0] = bi0;
407  from += 1;
408  to_next += 1;
409  n_left_from -= 1;
410  n_left_to_next -= 1;
411 
412  b0 = vlib_get_buffer (vm, bi0);
413 
414  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
415 
416  h0 = vlib_buffer_get_current (b0);
417 
418  if (do_trace && PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
419  {
420  l2fwd_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
421  t->sw_if_index = sw_if_index0;
422  t->bd_index = vnet_buffer (b0)->l2.bd_index;
423  clib_memcpy (t->src, h0->src_address, 6);
424  clib_memcpy (t->dst, h0->dst_address, 6);
425  }
426 
427  /* process 1 pkt */
428 #ifdef COUNTERS
429  em->counters[node_counter_base_index + L2FWD_ERROR_L2FWD] += 1;
430 #endif
431  l2fib_lookup_1 (msm->mac_table, &cached_key, &cached_result, h0->dst_address, vnet_buffer (b0)->l2.bd_index, &key0, /* not used */
432  &bucket0, /* not used */
433  &result0);
434  l2fwd_process (vm, node, msm, em, b0, sw_if_index0, &result0,
435  &next0);
436 
437  /* verify speculative enqueue, maybe switch current next frame */
438  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
439  to_next, n_left_to_next,
440  bi0, next0);
441  }
442 
443  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
444  }
445 
446  return frame->n_vectors;
447 }
448 
449 static uword
451  vlib_node_runtime_t * node, vlib_frame_t * frame)
452 {
453  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
454  return l2fwd_node_inline (vm, node, frame, 1 /* do_trace */ );
455  return l2fwd_node_inline (vm, node, frame, 0 /* do_trace */ );
456 }
457 
458 /* *INDENT-OFF* */
459 VLIB_REGISTER_NODE (l2fwd_node,static) = {
460  .function = l2fwd_node_fn,
461  .name = "l2-fwd",
462  .vector_size = sizeof (u32),
463  .format_trace = format_l2fwd_trace,
464  .type = VLIB_NODE_TYPE_INTERNAL,
465 
466  .n_errors = ARRAY_LEN(l2fwd_error_strings),
467  .error_strings = l2fwd_error_strings,
468 
469  .n_next_nodes = L2FWD_N_NEXT,
470 
471  /* edit / add dispositions here */
472  .next_nodes = {
473  [L2FWD_NEXT_L2_OUTPUT] = "l2-output",
474  [L2FWD_NEXT_DROP] = "error-drop",
475  },
476 };
477 /* *INDENT-ON* */
478 
481 {
482  l2fwd_main_t *mp = &l2fwd_main;
483 
484  mp->vlib_main = vm;
485  mp->vnet_main = vnet_get_main ();
486 
487  /* Initialize the feature next-node indexes */
489  l2fwd_node.index,
492  mp->feat_next_node_index);
493 
494  /* init the hash table ptr */
495  mp->mac_table = get_mac_table ();
496 
497  /* Initialize the next nodes for each ethertype */
498  next_by_ethertype_init (&mp->l3_next);
499 
500  return 0;
501 }
502 
504 
505 
506 /** Add the L3 input node for this ethertype to the next nodes structure. */
507 void
509  ethernet_type_t type, u32 node_index)
510 {
511  l2fwd_main_t *mp = &l2fwd_main;
512  u32 next_index;
513 
514  next_index = vlib_node_add_next (vm, l2fwd_node.index, node_index);
515 
516  next_by_ethertype_register (&mp->l3_next, type, next_index);
517 }
518 
519 
520 /**
521  * Set subinterface forward enable/disable.
522  * The CLI format is:
523  * set interface l2 forward <interface> [disable]
524  */
525 static clib_error_t *
527 {
528  vnet_main_t *vnm = vnet_get_main ();
529  clib_error_t *error = 0;
530  u32 sw_if_index;
531  u32 enable;
532 
533  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
534  {
535  error = clib_error_return (0, "unknown interface `%U'",
536  format_unformat_error, input);
537  goto done;
538  }
539 
540  enable = 1;
541  if (unformat (input, "disable"))
542  {
543  enable = 0;
544  }
545 
546  /* set the interface flag */
547  if (l2input_intf_config (sw_if_index)->xconnect)
548  {
549  l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_XCONNECT, enable);
550  }
551  else
552  {
553  l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_FWD, enable);
554  }
555 
556 done:
557  return error;
558 }
559 
560 /*?
561  * Layer 2 unicast forwarding can be enabled and disabled on each
562  * interface and on each bridge-domain. Use this command to
563  * manage interfaces. It is enabled by default.
564  *
565  * @cliexpar
566  * Example of how to enable fowarding:
567  * @cliexcmd{set interface l2 forward GigabitEthernet0/8/0}
568  * Example of how to disable fowarding:
569  * @cliexcmd{set interface l2 forward GigabitEthernet0/8/0 disable}
570 ?*/
571 /* *INDENT-OFF* */
572 VLIB_CLI_COMMAND (int_fwd_cli, static) = {
573  .path = "set interface l2 forward",
574  .short_help = "set interface l2 forward <interface> [disable]",
575  .function = int_fwd,
576 };
577 /* *INDENT-ON* */
578 
579 /*
580  * fd.io coding-style-patch-verification: ON
581  *
582  * Local Variables:
583  * eval: (c-set-style "gnu")
584  * End:
585  */
u32 error_heap_index
Definition: node.h:314
#define CLIB_UNUSED(x)
Definition: clib.h:79
u16 bd_index
Definition: l2_fwd.c:66
#define TO_BVI_ERR_BAD_MAC
Definition: l2_bvi.h:28
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
l2_input_config_t * l2input_intf_config(u32 sw_if_index)
Get a pointer to the config for the given interface.
Definition: l2_input.c:510
ethernet_type_t
Definition: packet.h:45
#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:56
static uword l2fwd_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: l2_fwd.c:450
clib_error_t * l2fwd_init(vlib_main_t *vm)
Definition: l2_fwd.c:480
#define vlib_validate_buffer_enqueue_x4(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, bi2, bi3, next0, next1, next2, next3)
Finish enqueueing four buffers forward in the graph.
Definition: buffer_node.h:138
static_always_inline u8 * l2fib_swif_seq_num(u32 sw_if_index)
Definition: l2_fib.h:422
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
unformat_function_t unformat_vnet_sw_interface
Definition: l2_fib.h:108
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:451
static vlib_node_registration_t l2fwd_node
(constructor) VLIB_REGISTER_NODE (l2fwd_node)
Definition: l2_fwd.c:86
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1110
unsigned char u8
Definition: types.h:56
static u32 vnet_l2_feature_next(vlib_buffer_t *b, u32 *next_nodes, u32 feat_bit)
Return the graph node index for the feature corresponding to the next set bit after clearing the curr...
Definition: feat_bitmap.h:94
#define static_always_inline
Definition: clib.h:93
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:156
u8 dst_address[6]
Definition: packet.h:55
static BVT(clib_bihash)
Definition: adj_nbr.c:26
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:184
#define clib_error_return(e, args...)
Definition: error.h:99
struct l2fib_entry_result_t::@245::@247 fields
static_always_inline void l2fwd_process(vlib_main_t *vm, vlib_node_runtime_t *node, l2fwd_main_t *msm, vlib_error_main_t *em, vlib_buffer_t *b0, u32 sw_if_index0, l2fib_entry_result_t *result0, u32 *next0)
Forward one packet based on the mac table lookup result.
Definition: l2_fwd.c:122
unsigned int u32
Definition: types.h:88
static clib_error_t * int_fwd(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Set subinterface forward enable/disable.
Definition: l2_fwd.c:526
#define VLIB_NODE_FUNCTION_MULTIARCH(node, fn)
Definition: node.h:194
vlib_error_main_t error_main
Definition: main.h:141
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
void l2fwd_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_fwd.c:508
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:202
static char * l2fwd_error_strings[]
Definition: l2_fwd.c:106
static u8 * format_l2fwd_trace(u8 *s, va_list *args)
Definition: l2_fwd.c:71
#define PREDICT_FALSE(x)
Definition: clib.h:105
vnet_main_t vnet_main
Definition: misc.c:43
#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:218
#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:364
l2fwd_main_t l2fwd_main
Definition: l2_fwd.c:84
u64 raw
Definition: l2_fib.h:127
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:135
static_always_inline uword l2fwd_node_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int do_trace)
Definition: l2_fwd.c:226
u64 * counters
Definition: error.h:78
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:153
clib_error_t * next_by_ethertype_register(next_by_ethertype_t *l3_next, u32 ethertype, u32 next_index)
Definition: node.c:1267
u16 n_vectors
Definition: node.h:380
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:77
vlib_main_t * vm
Definition: buffer.c:294
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
#define clib_memcpy(a, b, c)
Definition: string.h:75
#define ARRAY_LEN(x)
Definition: clib.h:59
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:454
char ** l2input_get_feat_names(void)
Return an array of strings containing graph node names of each feature.
Definition: l2_input.c:60
l2fwd_error_t
Definition: l2_fwd.c:98
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
u32 sw_if_index
Definition: l2_fwd.c:65
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:492
Definition: l2_fib.h:71
#define foreach_l2fwd_error
Definition: l2_fwd.c:88
u8 src[6]
Definition: l2_fwd.c:63
l2fwd_next_t
Definition: l2_fwd.c: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:520
int vlib_main(vlib_main_t *volatile vm, unformat_input_t *input)
Definition: main.c:1695
struct _vlib_node_registration vlib_node_registration_t
Definition: defs.h:47
u64 uword
Definition: types.h:112
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:267
clib_error_t * next_by_ethertype_init(next_by_ethertype_t *l3_next)
Definition: node.c:1237
u8 dst[6]
Definition: l2_fwd.c:64
#define vnet_buffer(b)
Definition: buffer.h:360
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
u8 data[0]
Packet data.
Definition: buffer.h:172
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:59
static_always_inline void l2fib_lookup_4(BVT(clib_bihash)*mac_table, l2fib_entry_key_t *cached_key, l2fib_entry_result_t *cached_result, u8 *mac0, u8 *mac1, u8 *mac2, u8 *mac3, u16 bd_index0, u16 bd_index1, u16 bd_index2, u16 bd_index3, l2fib_entry_key_t *key0, l2fib_entry_key_t *key1, l2fib_entry_key_t *key2, l2fib_entry_key_t *key3, u32 *bucket0, u32 *bucket1, u32 *bucket2, u32 *bucket3, l2fib_entry_result_t *result0, l2fib_entry_result_t *result1, l2fib_entry_result_t *result2, l2fib_entry_result_t *result3)
Definition: l2_fib.h:308
u16 flags
Copy of main node flags.
Definition: node.h:486
static_always_inline void l2fib_lookup_1(BVT(clib_bihash)*mac_table, l2fib_entry_key_t *cached_key, l2fib_entry_result_t *cached_result, u8 *mac0, u16 bd_index0, l2fib_entry_key_t *key0, u32 *bucket0, l2fib_entry_result_t *result0)
Lookup the entry for mac and bd_index in the mac table for 1 packet.
Definition: l2_fib.h:209
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:295
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:62
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
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
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
Definition: defs.h:46
u64 raw
Definition: l2_fib.h:85