FD.io VPP  v17.01-9-ge7dcee4
Vector Packet Processing
l2_input.c
Go to the documentation of this file.
1 /*
2  * l2_input.c : layer 2 input packet processing
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 <vnet/ethernet/packet.h>
23 #include <vnet/ip/ip_packet.h>
24 #include <vnet/ip/ip4_packet.h>
25 #include <vnet/ip/ip6_packet.h>
26 #include <vlib/cli.h>
27 #include <vnet/l2/l2_input.h>
28 #include <vnet/l2/l2_output.h>
29 #include <vnet/l2/feat_bitmap.h>
30 #include <vnet/l2/l2_bvi.h>
31 #include <vnet/l2/l2_fib.h>
32 
33 #include <vppinfra/error.h>
34 #include <vppinfra/hash.h>
35 #include <vppinfra/cache.h>
36 
37 /**
38  * @file
39  * @brief Interface Input Mode (Layer 2 Cross-Connect or Bridge / Layer 3).
40  *
41  * This file contains the CLI Commands that modify the input mode of an
42  * interface. For interfaces in a Layer 2 cross-connect, all packets
43  * received on one interface will be transmitted to the other. For
44  * interfaces in a bridge-domain, packets will be forwarded to other
45  * interfaces in the same bridge-domain based on destination mac address.
46  * For interfaces in Layer 3 mode, the packets will be routed.
47  */
48 
49 /* Feature graph node names */
50 static char *l2input_feat_names[] = {
51 #define _(sym,name) name,
53 #undef _
54 };
55 
56 char **
58 {
59  return l2input_feat_names;
60 }
61 
62 
63 typedef struct
64 {
65  /* per-pkt trace data */
66  u8 src[6];
67  u8 dst[6];
71 
72 /* packet trace format function */
73 static u8 *
74 format_l2input_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  l2input_trace_t *t = va_arg (*args, l2input_trace_t *);
79 
80  s = format (s, "l2-input: sw_if_index %d dst %U src %U",
81  t->sw_if_index,
84  return s;
85 }
86 
88 
89 #define foreach_l2input_error \
90 _(L2INPUT, "L2 input packets") \
91 _(DROP, "L2 input drops")
92 
93 typedef enum
94 {
95 #define _(sym,str) L2INPUT_ERROR_##sym,
97 #undef _
100 
101 static char *l2input_error_strings[] = {
102 #define _(sym,string) string,
104 #undef _
105 };
106 
107 typedef enum
108 { /* */
114 
115 
118  vlib_node_runtime_t * node,
119  u32 cpu_index,
120  l2input_main_t * msm, vlib_buffer_t * b0, u32 * next0)
121 {
122  /*
123  * Load L2 input feature struct
124  * Load bridge domain struct
125  * Parse ethernet header to determine unicast/mcast/broadcast
126  * take L2 input stat
127  * classify packet as IP/UDP/TCP, control, other
128  * mask feature bitmap
129  * go to first node in bitmap
130  * Later: optimize VTM
131  *
132  * For L2XC,
133  * set tx sw-if-handle
134  */
135 
136  u16 ethertype;
137  u8 protocol;
138  l2_input_config_t *config;
139  l2_bridge_domain_t *bd_config;
140  u16 bd_index0;
141  u32 feature_bitmap;
142  u32 feat_mask;
143  ethernet_header_t *h0;
144  u8 *l3h0;
145  u32 sw_if_index0;
146 
147 #define get_u16(addr) ( *((u16 *)(addr)) )
148 
149  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
150 
151  h0 = vlib_buffer_get_current (b0);
152  l3h0 = (u8 *) h0 + vnet_buffer (b0)->l2.l2_len;
153 
154  ethertype = clib_net_to_host_u16 (get_u16 (l3h0 - 2));
155  feat_mask = ~0;
156 
157  /* Get config for the input interface */
158  config = vec_elt_at_index (msm->configs, sw_if_index0);
159 
160  /* Save split horizon group */
161  vnet_buffer (b0)->l2.shg = config->shg;
162 
163  /* determine layer2 kind for stat and mask */
165  {
166  protocol = ((ip6_header_t *) l3h0)->protocol;
167 
168  /* Disable bridge forwarding (flooding will execute instead if not xconnect) */
169  feat_mask &= ~(L2INPUT_FEAT_FWD | L2INPUT_FEAT_UU_FLOOD);
170 
171  /* Disable ARP-term for non-ARP and non-ICMP6 packet */
172  if (ethertype != ETHERNET_TYPE_ARP &&
173  (ethertype != ETHERNET_TYPE_IP6 || protocol != IP_PROTOCOL_ICMP6))
174  feat_mask &= ~(L2INPUT_FEAT_ARP_TERM);
175  }
176  else
177  {
178  /*
179  * Check for from-BVI processing - set SHG of unicast packets from BVI
180  * to 0 so it is not dropped for VXLAN tunnels or other ports with the
181  * same SHG as that of the BVI.
182  */
183  if (PREDICT_FALSE (vnet_buffer (b0)->sw_if_index[VLIB_TX] ==
184  L2INPUT_BVI))
185  vnet_buffer (b0)->l2.shg = 0;
186  }
187 
188 
189  if (config->xconnect)
190  {
191  /* Set the output interface */
192  vnet_buffer (b0)->sw_if_index[VLIB_TX] = config->output_sw_if_index;
193  }
194  else
195  {
196  /* Do bridge-domain processing */
197  bd_index0 = config->bd_index;
198  /* save BD ID for next feature graph nodes */
199  vnet_buffer (b0)->l2.bd_index = bd_index0;
200 
201  /* Get config for the bridge domain interface */
202  bd_config = vec_elt_at_index (msm->bd_configs, bd_index0);
203 
204  /*
205  * Process bridge domain feature enables.
206  * To perform learning/flooding/forwarding, the corresponding bit
207  * must be enabled in both the input interface config and in the
208  * bridge domain config. In the bd_bitmap, bits for features other
209  * than learning/flooding/forwarding should always be set.
210  */
211  feat_mask = feat_mask & bd_config->feature_bitmap;
212  }
213 
214  /* mask out features from bitmap using packet type and bd config */
215  feature_bitmap = config->feature_bitmap & feat_mask;
216 
217  /* save for next feature graph nodes */
218  vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap;
219 
220  /* Determine the next node */
222  feature_bitmap);
223 }
224 
225 
226 static uword
228  vlib_node_runtime_t * node, vlib_frame_t * frame)
229 {
230  u32 n_left_from, *from, *to_next;
231  l2input_next_t next_index;
233  u32 cpu_index = os_get_cpu_number ();
234 
235  from = vlib_frame_vector_args (frame);
236  n_left_from = frame->n_vectors; /* number of packets to process */
237  next_index = node->cached_next_index;
238 
239  while (n_left_from > 0)
240  {
241  u32 n_left_to_next;
242 
243  /* get space to enqueue frame to graph node "next_index" */
244  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
245 
246  while (n_left_from >= 8 && n_left_to_next >= 4)
247  {
248  u32 bi0, bi1, bi2, bi3;
249  vlib_buffer_t *b0, *b1, *b2, *b3;
250  u32 next0, next1, next2, next3;
251  u32 sw_if_index0, sw_if_index1, sw_if_index2, sw_if_index3;
252 
253  /* Prefetch next iteration. */
254  {
255  vlib_buffer_t *p4, *p5, *p6, *p7;
256 
257  p4 = vlib_get_buffer (vm, from[4]);
258  p5 = vlib_get_buffer (vm, from[5]);
259  p6 = vlib_get_buffer (vm, from[6]);
260  p7 = vlib_get_buffer (vm, from[7]);
261 
262  /* Prefetch the buffer header and packet for the N+2 loop iteration */
263  vlib_prefetch_buffer_header (p4, LOAD);
264  vlib_prefetch_buffer_header (p5, LOAD);
265  vlib_prefetch_buffer_header (p6, LOAD);
266  vlib_prefetch_buffer_header (p7, LOAD);
267 
272 
273  /*
274  * Don't bother prefetching the bridge-domain config (which
275  * depends on the input config above). Only a small number of
276  * bridge domains are expected. Plus the structure is small
277  * and several fit in a cache line.
278  */
279  }
280 
281  /* speculatively enqueue b0 and b1 to the current next frame */
282  /* bi is "buffer index", b is pointer to the buffer */
283  to_next[0] = bi0 = from[0];
284  to_next[1] = bi1 = from[1];
285  to_next[2] = bi2 = from[2];
286  to_next[3] = bi3 = from[3];
287  from += 4;
288  to_next += 4;
289  n_left_from -= 4;
290  n_left_to_next -= 4;
291 
292  b0 = vlib_get_buffer (vm, bi0);
293  b1 = vlib_get_buffer (vm, bi1);
294  b2 = vlib_get_buffer (vm, bi2);
295  b3 = vlib_get_buffer (vm, bi3);
296 
297  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
298  {
299  /* RX interface handles */
300  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
301  sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
302  sw_if_index2 = vnet_buffer (b2)->sw_if_index[VLIB_RX];
303  sw_if_index3 = vnet_buffer (b3)->sw_if_index[VLIB_RX];
304 
305  if (b0->flags & VLIB_BUFFER_IS_TRACED)
306  {
308  l2input_trace_t *t =
309  vlib_add_trace (vm, node, b0, sizeof (*t));
310  t->sw_if_index = sw_if_index0;
311  clib_memcpy (t->src, h0->src_address, 6);
312  clib_memcpy (t->dst, h0->dst_address, 6);
313  }
314  if (b1->flags & VLIB_BUFFER_IS_TRACED)
315  {
317  l2input_trace_t *t =
318  vlib_add_trace (vm, node, b1, sizeof (*t));
319  t->sw_if_index = sw_if_index1;
320  clib_memcpy (t->src, h1->src_address, 6);
321  clib_memcpy (t->dst, h1->dst_address, 6);
322  }
323  if (b2->flags & VLIB_BUFFER_IS_TRACED)
324  {
326  l2input_trace_t *t =
327  vlib_add_trace (vm, node, b2, sizeof (*t));
328  t->sw_if_index = sw_if_index2;
329  clib_memcpy (t->src, h2->src_address, 6);
330  clib_memcpy (t->dst, h2->dst_address, 6);
331  }
332  if (b3->flags & VLIB_BUFFER_IS_TRACED)
333  {
335  l2input_trace_t *t =
336  vlib_add_trace (vm, node, b3, sizeof (*t));
337  t->sw_if_index = sw_if_index3;
338  clib_memcpy (t->src, h3->src_address, 6);
339  clib_memcpy (t->dst, h3->dst_address, 6);
340  }
341  }
342 
344  L2INPUT_ERROR_L2INPUT, 4);
345 
346  classify_and_dispatch (vm, node, cpu_index, msm, b0, &next0);
347  classify_and_dispatch (vm, node, cpu_index, msm, b1, &next1);
348  classify_and_dispatch (vm, node, cpu_index, msm, b2, &next2);
349  classify_and_dispatch (vm, node, cpu_index, msm, b3, &next3);
350 
351  /* verify speculative enqueues, maybe switch current next frame */
352  /* if next0==next1==next_index then nothing special needs to be done */
353  vlib_validate_buffer_enqueue_x4 (vm, node, next_index,
354  to_next, n_left_to_next,
355  bi0, bi1, bi2, bi3,
356  next0, next1, next2, next3);
357  }
358 
359  while (n_left_from > 0 && n_left_to_next > 0)
360  {
361  u32 bi0;
362  vlib_buffer_t *b0;
363  u32 next0;
364  u32 sw_if_index0;
365 
366  /* speculatively enqueue b0 to the current next frame */
367  bi0 = from[0];
368  to_next[0] = bi0;
369  from += 1;
370  to_next += 1;
371  n_left_from -= 1;
372  n_left_to_next -= 1;
373 
374  b0 = vlib_get_buffer (vm, bi0);
375 
377  && (b0->flags & VLIB_BUFFER_IS_TRACED)))
378  {
380  l2input_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
381  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
382  t->sw_if_index = sw_if_index0;
383  clib_memcpy (t->src, h0->src_address, 6);
384  clib_memcpy (t->dst, h0->dst_address, 6);
385  }
386 
388  L2INPUT_ERROR_L2INPUT, 1);
389 
390  classify_and_dispatch (vm, node, cpu_index, msm, b0, &next0);
391 
392  /* verify speculative enqueue, maybe switch current next frame */
393  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
394  to_next, n_left_to_next,
395  bi0, next0);
396  }
397 
398  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
399  }
400 
401  return frame->n_vectors;
402 }
403 
404 
405 /* *INDENT-OFF* */
407  .function = l2input_node_fn,
408  .name = "l2-input",
409  .vector_size = sizeof (u32),
410  .format_trace = format_l2input_trace,
411  .format_buffer = format_ethernet_header_with_length,
413 
414  .n_errors = ARRAY_LEN(l2input_error_strings),
415  .error_strings = l2input_error_strings,
416 
417  .n_next_nodes = L2INPUT_N_NEXT,
418 
419  /* edit / add dispositions here */
420  .next_nodes = {
421  [L2INPUT_NEXT_LEARN] = "l2-learn",
422  [L2INPUT_NEXT_FWD] = "l2-fwd",
423  [L2INPUT_NEXT_DROP] = "error-drop",
424  },
425 };
426 /* *INDENT-ON* */
427 
430 {
432 
433  mp->vlib_main = vm;
434  mp->vnet_main = vnet_get_main ();
435 
436  /* Get packets RX'd from L2 interfaces */
438 
439  /* Create the config vector */
440  vec_validate (mp->configs, 100);
441  /* create 100 sw interface entries and zero them */
442 
443  /* Initialize the feature next-node indexes */
445  l2input_node.index,
449 
450  return 0;
451 }
452 
454 
455 
456 /** Get a pointer to the config for the given interface. */
459 {
461 
462  vec_validate (mp->configs, sw_if_index);
463  return vec_elt_at_index (mp->configs, sw_if_index);
464 }
465 
466 /** Enable (or disable) the feature in the bitmap for the given interface. */
467 u32
468 l2input_intf_bitmap_enable (u32 sw_if_index, u32 feature_bitmap, u32 enable)
469 {
471  l2_input_config_t *config;
472 
473  vec_validate (mp->configs, sw_if_index);
474  config = vec_elt_at_index (mp->configs, sw_if_index);
475 
476  if (enable)
477  {
478  config->feature_bitmap |= feature_bitmap;
479  }
480  else
481  {
482  config->feature_bitmap &= ~feature_bitmap;
483  }
484 
485  return config->feature_bitmap;
486 }
487 
488 u32
489 l2input_set_bridge_features (u32 bd_index, u32 feat_mask, u32 feat_value)
490 {
491  l2_bridge_domain_t *bd_config;
492  vec_validate (l2input_main.bd_configs, bd_index);
493  bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index);
494  bd_validate (bd_config);
495  bd_config->feature_bitmap =
496  (bd_config->feature_bitmap & ~feat_mask) | feat_value;
497  return bd_config->feature_bitmap;
498 }
499 
500 /**
501  * Set the subinterface to run in l2 or l3 mode.
502  * For L3 mode, just the sw_if_index is specified.
503  * For bridged mode, the bd id and bvi flag are also specified.
504  * For xconnect mode, the peer sw_if_index is also specified.
505  * Return 0 if ok, or non-0 if there was an error.
506  */
507 
508 u32
509 set_int_l2_mode (vlib_main_t * vm, vnet_main_t * vnet_main, u32 mode, u32 sw_if_index, u32 bd_index, /* for bridged interface */
510  u32 bvi, /* the bridged interface is the BVI */
511  u32 shg, /* the bridged interface's split horizon group */
512  u32 xc_sw_if_index) /* peer interface for xconnect */
513 {
516  vnet_main_t *vnm = vnet_get_main ();
518  l2_output_config_t *out_config;
519  l2_input_config_t *config;
520  l2_bridge_domain_t *bd_config;
521  l2_flood_member_t member;
522  u64 mac;
523  i32 l2_if_adjust = 0;
524  u32 slot;
525 
526  hi = vnet_get_sup_hw_interface (vnet_main, sw_if_index);
527  config = l2input_intf_config (sw_if_index);
528 
529  if (config->bridge)
530  {
531  /* Interface is already in bridge mode. Undo the existing config. */
532  bd_config = vec_elt_at_index (mp->bd_configs, config->bd_index);
533 
534  /* remove interface from flood vector */
535  bd_remove_member (bd_config, sw_if_index);
536 
537  /* undo any BVI-related config */
538  if (bd_config->bvi_sw_if_index == sw_if_index)
539  {
540  bd_config->bvi_sw_if_index = ~0;
541  config->bvi = 0;
542 
543  /* delete the l2fib entry for the bvi interface */
544  mac = *((u64 *) hi->hw_address);
545  l2fib_del_entry (mac, config->bd_index);
546 
547  /* Make loop output node send packet back to ethernet-input node */
548  slot =
550  "ethernet-input",
553  }
554  l2_if_adjust--;
555  }
556  else if (config->xconnect)
557  {
558  l2_if_adjust--;
559  }
560 
561  /*
562  * Directs the l2 output path to work out the interface
563  * output next-arc itself. Needed when recycling a sw_if_index.
564  */
566  sw_if_index, ~0);
567  l2om->next_nodes.output_node_index_vec[sw_if_index] = ~0;
568 
569  /* Initialize the l2-input configuration for the interface */
570  if (mode == MODE_L3)
571  {
572  /* Set L2 config to BD index 0 so that if any packet accidentally
573  * came in on L2 path, it will be dropped in BD 0 */
574  config->xconnect = 0;
575  config->bridge = 0;
576  config->shg = 0;
577  config->bd_index = 0;
578  config->feature_bitmap = L2INPUT_FEAT_DROP;
579 
580  /* Make sure any L2-output packet to this interface now in L3 mode is
581  * dropped. This may happen if L2 FIB MAC entry is stale */
582  l2om->next_nodes.output_node_index_vec[sw_if_index] =
584  }
585  else if (mode == MODE_L2_CLASSIFY)
586  {
587  config->xconnect = 1;
588  config->bridge = 0;
589  config->output_sw_if_index = xc_sw_if_index;
590 
591  /* Make sure last-chance drop is configured */
592  config->feature_bitmap |=
593  L2INPUT_FEAT_DROP | L2INPUT_FEAT_INPUT_CLASSIFY;
594 
595  /* Make sure bridging features are disabled */
596  config->feature_bitmap &=
597  ~(L2INPUT_FEAT_LEARN | L2INPUT_FEAT_FWD | L2INPUT_FEAT_FLOOD);
598  shg = 0; /* not used in xconnect */
599 
600  /* Insure all packets go to ethernet-input */
601  ethernet_set_rx_redirect (vnet_main, hi, 1);
602  }
603  else
604  {
605 
606  if (mode == MODE_L2_BRIDGE)
607  {
608  /*
609  * Remove a check that the interface must be an Ethernet.
610  * Specifically so we can bridge to L3 tunnel interfaces.
611  * Here's the check:
612  * if (hi->hw_class_index != ethernet_hw_interface_class.index)
613  *
614  */
615  if (!hi)
616  return MODE_ERROR_ETH; /* non-ethernet */
617 
618  config->xconnect = 0;
619  config->bridge = 1;
620  config->bd_index = bd_index;
621 
622  /*
623  * Enable forwarding, flooding, learning and ARP termination by default
624  * (note that ARP term is disabled on BD feature bitmap by default)
625  */
626  config->feature_bitmap |= L2INPUT_FEAT_FWD | L2INPUT_FEAT_UU_FLOOD |
627  L2INPUT_FEAT_FLOOD | L2INPUT_FEAT_LEARN | L2INPUT_FEAT_ARP_TERM;
628 
629  /* Make sure last-chance drop is configured */
630  config->feature_bitmap |= L2INPUT_FEAT_DROP;
631 
632  /* Make sure xconnect is disabled */
633  config->feature_bitmap &= ~L2INPUT_FEAT_XCONNECT;
634 
635  /* Set up bridge domain */
636  vec_validate (mp->bd_configs, bd_index);
637  bd_config = vec_elt_at_index (mp->bd_configs, bd_index);
638  bd_validate (bd_config);
639 
640  /* TODO: think: add l2fib entry even for non-bvi interface? */
641 
642  /* Do BVI interface initializations */
643  if (bvi)
644  {
645  /* ensure BD has no bvi interface (or replace that one with this??) */
646  if (bd_config->bvi_sw_if_index != ~0)
647  {
648  return MODE_ERROR_BVI_DEF; /* bd already has a bvi interface */
649  }
650  bd_config->bvi_sw_if_index = sw_if_index;
651  config->bvi = 1;
652 
653  /* create the l2fib entry for the bvi interface */
654  mac = *((u64 *) hi->hw_address);
655  l2fib_add_entry (mac, bd_index, sw_if_index, 1, 0, 1); /* static + bvi */
656 
657  /* Disable learning by default. no use since l2fib entry is static. */
658  config->feature_bitmap &= ~L2INPUT_FEAT_LEARN;
659 
660  /* Make loop output node send packet to l2-input node */
661  slot =
663  "l2-input",
666  }
667 
668  /* Add interface to bridge-domain flood vector */
669  member.sw_if_index = sw_if_index;
671  member.shg = shg;
672  bd_add_member (bd_config, &member);
673 
674  }
675  else
676  {
677  config->xconnect = 1;
678  config->bridge = 0;
679  config->output_sw_if_index = xc_sw_if_index;
680 
681  /* Make sure last-chance drop is configured */
682  config->feature_bitmap |= L2INPUT_FEAT_DROP;
683 
684  /* Make sure bridging features are disabled */
685  config->feature_bitmap &=
686  ~(L2INPUT_FEAT_LEARN | L2INPUT_FEAT_FWD | L2INPUT_FEAT_FLOOD);
687 
688  config->feature_bitmap |= L2INPUT_FEAT_XCONNECT;
689  shg = 0; /* not used in xconnect */
690  }
691 
692  /* set up split-horizon group and set output feature bit */
693  config->shg = shg;
694  out_config = l2output_intf_config (sw_if_index);
695  out_config->shg = shg;
696  out_config->feature_bitmap |= L2OUTPUT_FEAT_OUTPUT;
697 
698  /*
699  * Test: remove this when non-IP features can be configured.
700  * Enable a non-IP feature to test IP feature masking
701  * config->feature_bitmap |= L2INPUT_FEAT_CTRL_PKT;
702  */
703 
704  l2_if_adjust++;
705  }
706 
707  /* Adjust count of L2 interfaces */
708  hi->l2_if_count += l2_if_adjust;
709 
711  {
712  if ((hi->l2_if_count == 1) && (l2_if_adjust == 1))
713  {
714  /* Just added first L2 interface on this port */
715 
716  /* Set promiscuous mode on the l2 interface */
717  ethernet_set_flags (vnet_main, hi->hw_if_index,
719 
720  /* ensure all packets go to ethernet-input */
721  ethernet_set_rx_redirect (vnet_main, hi, 1);
722 
723  }
724  else if ((hi->l2_if_count == 0) && (l2_if_adjust == -1))
725  {
726  /* Just removed only L2 subinterface on this port */
727 
728  /* Disable promiscuous mode on the l2 interface */
729  ethernet_set_flags (vnet_main, hi->hw_if_index, 0);
730 
731  /* Allow ip packets to go directly to ip4-input etc */
732  ethernet_set_rx_redirect (vnet_main, hi, 0);
733  }
734  }
735 
736  /* Set up the L2/L3 flag in the interface parsing tables */
737  ethernet_sw_interface_set_l2_mode (vnm, sw_if_index, (mode != MODE_L3));
738 
739  return 0;
740 }
741 
742 /**
743  * Set subinterface in bridging mode with a bridge-domain ID.
744  * The CLI format is:
745  * set interface l2 bridge <interface> <bd> [bvi] [split-horizon-group]
746  */
747 static clib_error_t *
749  unformat_input_t * input, vlib_cli_command_t * cmd)
750 {
751  vnet_main_t *vnm = vnet_get_main ();
752  clib_error_t *error = 0;
753  u32 bd_index, bd_id;
754  u32 sw_if_index;
755  u32 bvi;
756  u32 rc;
757  u32 shg;
758 
759  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
760  {
761  error = clib_error_return (0, "unknown interface `%U'",
762  format_unformat_error, input);
763  goto done;
764  }
765 
766  if (!unformat (input, "%d", &bd_id))
767  {
768  error = clib_error_return (0, "expected bridge domain ID `%U'",
769  format_unformat_error, input);
770  goto done;
771  }
772 
773  bd_index = bd_find_or_add_bd_index (&bd_main, bd_id);
774 
775  /* optional bvi */
776  bvi = unformat (input, "bvi");
777 
778  /* optional split horizon group */
779  shg = 0;
780  (void) unformat (input, "%d", &shg);
781 
782  /* set the interface mode */
783  if ((rc =
784  set_int_l2_mode (vm, vnm, MODE_L2_BRIDGE, sw_if_index, bd_index, bvi,
785  shg, 0)))
786  {
787  if (rc == MODE_ERROR_ETH)
788  {
789  error = clib_error_return (0, "bridged interface must be ethernet",
790  format_unformat_error, input);
791  }
792  else if (rc == MODE_ERROR_BVI_DEF)
793  {
794  error =
795  clib_error_return (0, "bridge-domain already has a bvi interface",
796  format_unformat_error, input);
797  }
798  else
799  {
800  error = clib_error_return (0, "invalid configuration for interface",
801  format_unformat_error, input);
802  }
803  goto done;
804  }
805 
806 done:
807  return error;
808 }
809 
810 /*?
811  * Use this command put an interface into Layer 2 bridge domain. If a
812  * bridge-domain with the provided bridge-domain-id does not exist, it
813  * will be created. Interfaces in a bridge-domain forward packets to
814  * other interfaces in the same bridge-domain based on destination mac
815  * address. To remove an interface from a the Layer 2 bridge domain,
816  * put the interface in a different mode, for example Layer 3 mode.
817  *
818  * Optionally, an interface can be added to a Layer 2 bridge-domain as
819  * a Bridged Virtual Interface (bvi). Only one interface in a Layer 2
820  * bridge-domain can be a bvi.
821  *
822  * Optionally, a split-horizon group can also be specified. This defaults
823  * to 0 if not specified.
824  *
825  * @cliexpar
826  * Example of how to configure a Layer 2 bridge-domain with three
827  * interfaces (where 200 is the bridge-domain-id):
828  * @cliexcmd{set interface l2 bridge GigabitEthernet0/8/0.200 200}
829  * This interface is added a BVI interface:
830  * @cliexcmd{set interface l2 bridge GigabitEthernet0/9/0.200 200 bvi}
831  * This interface also has a split-horizon group of 1 specified:
832  * @cliexcmd{set interface l2 bridge GigabitEthernet0/a/0.200 200 1}
833  * Example of how to remove an interface from a Layer2 bridge-domain:
834  * @cliexcmd{set interface l3 GigabitEthernet0/a/0.200}
835 ?*/
836 /* *INDENT-OFF* */
837 VLIB_CLI_COMMAND (int_l2_bridge_cli, static) = {
838  .path = "set interface l2 bridge",
839  .short_help = "set interface l2 bridge <interface> <bridge-domain-id> [bvi] [shg]",
840  .function = int_l2_bridge,
841 };
842 /* *INDENT-ON* */
843 
844 /**
845  * Set subinterface in xconnect mode with another interface.
846  * The CLI format is:
847  * set interface l2 xconnect <interface> <peer interface>
848  */
849 static clib_error_t *
851  unformat_input_t * input, vlib_cli_command_t * cmd)
852 {
853  vnet_main_t *vnm = vnet_get_main ();
854  clib_error_t *error = 0;
855  u32 sw_if_index;
856  u32 xc_sw_if_index;
857 
858  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
859  {
860  error = clib_error_return (0, "unknown interface `%U'",
861  format_unformat_error, input);
862  goto done;
863  }
864 
865  if (!unformat_user
866  (input, unformat_vnet_sw_interface, vnm, &xc_sw_if_index))
867  {
868  error = clib_error_return (0, "unknown peer interface `%U'",
869  format_unformat_error, input);
870  goto done;
871  }
872 
873  /* set the interface mode */
874  if (set_int_l2_mode
875  (vm, vnm, MODE_L2_XC, sw_if_index, 0, 0, 0, xc_sw_if_index))
876  {
877  error = clib_error_return (0, "invalid configuration for interface",
878  format_unformat_error, input);
879  goto done;
880  }
881 
882 done:
883  return error;
884 }
885 
886 /*?
887  * Use this command put an interface into Layer 2 cross-connect mode.
888  * Both interfaces must be in this mode for bi-directioal traffic. All
889  * packets received on one interface will be transmitted to the other.
890  * To remove the Layer 2 cross-connect, put the interface in a different
891  * mode, for example Layer 3 mode.
892  *
893  * @cliexpar
894  * Example of how to configure a Layer2 cross-connect between two interfaces:
895  * @cliexcmd{set interface l2 xconnect GigabitEthernet0/8/0.300 GigabitEthernet0/9/0.300}
896  * @cliexcmd{set interface l2 xconnect GigabitEthernet0/9/0.300 GigabitEthernet0/8/0.300}
897  * Example of how to remove a Layer2 cross-connect:
898  * @cliexcmd{set interface l3 GigabitEthernet0/8/0.300}
899  * @cliexcmd{set interface l3 GigabitEthernet0/9/0.300}
900 ?*/
901 /* *INDENT-OFF* */
902 VLIB_CLI_COMMAND (int_l2_xc_cli, static) = {
903  .path = "set interface l2 xconnect",
904  .short_help = "set interface l2 xconnect <interface> <peer interface>",
905  .function = int_l2_xc,
906 };
907 /* *INDENT-ON* */
908 
909 /**
910  * Set subinterface in L3 mode.
911  * The CLI format is:
912  * set interface l3 <interface>
913  */
914 static clib_error_t *
916 {
917  vnet_main_t *vnm = vnet_get_main ();
918  clib_error_t *error = 0;
919  u32 sw_if_index;
920 
921  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
922  {
923  error = clib_error_return (0, "unknown interface `%U'",
924  format_unformat_error, input);
925  goto done;
926  }
927 
928  /* set the interface mode */
929  if (set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0))
930  {
931  error = clib_error_return (0, "invalid configuration for interface",
932  format_unformat_error, input);
933  goto done;
934  }
935 
936 done:
937  return error;
938 }
939 
940 /*?
941  * Modify the packet processing mode of the interface to Layer 3, which
942  * implies packets will be routed. This is the default mode of an interface.
943  * Use this command to remove an interface from a Layer 2 cross-connect or a
944  * Layer 2 bridge.
945  *
946  * @cliexpar
947  * Example of how to set the mode of an interface to Layer 3:
948  * @cliexcmd{set interface l3 GigabitEthernet0/8/0.200}
949 ?*/
950 /* *INDENT-OFF* */
951  VLIB_CLI_COMMAND (int_l3_cli, static) = {
952  .path = "set interface l3",
953  .short_help = "set interface l3 <interface>",
954  .function = int_l3,
955 };
956 /* *INDENT-ON* */
957 
958 /**
959  * Show interface mode.
960  * The CLI format is:
961  * show mode [<if-name1> <if-name2> ...]
962  */
963 static clib_error_t *
965  unformat_input_t * input, vlib_cli_command_t * cmd)
966 {
967  vnet_main_t *vnm = vnet_get_main ();
968  clib_error_t *error = 0;
969  char *mode;
970  u8 *args;
972  vnet_sw_interface_t *si, *sis = 0;
974  l2_input_config_t *config;
975 
977  {
978  u32 sw_if_index;
979 
980  /* See if user wants to show specific interface */
981  if (unformat
982  (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
983  {
984  si = pool_elt_at_index (im->sw_interfaces, sw_if_index);
985  vec_add1 (sis, si[0]);
986  }
987  else
988  {
989  error = clib_error_return (0, "unknown input `%U'",
990  format_unformat_error, input);
991  goto done;
992  }
993 
994  }
995 
996  if (vec_len (sis) == 0) /* Get all interfaces */
997  {
998  /* Gather interfaces. */
1000  _vec_len (sis) = 0;
1001  /* *INDENT-OFF* */
1002  pool_foreach (si, im->sw_interfaces, ({ vec_add1 (sis, si[0]); }));
1003  /* *INDENT-ON* */
1004  }
1005 
1006  vec_foreach (si, sis)
1007  {
1008  vec_validate (mp->configs, si->sw_if_index);
1009  config = vec_elt_at_index (mp->configs, si->sw_if_index);
1010  if (config->bridge)
1011  {
1012  u32 bd_id;
1013  mode = "l2 bridge";
1014  bd_id = l2input_main.bd_configs[config->bd_index].bd_id;
1015 
1016  args = format (0, "bd_id %d%s%d", bd_id,
1017  config->bvi ? " bvi shg " : " shg ", config->shg);
1018  }
1019  else if (config->xconnect)
1020  {
1021  mode = "l2 xconnect";
1022  args = format (0, "%U",
1024  vnm, config->output_sw_if_index);
1025  }
1026  else
1027  {
1028  mode = "l3";
1029  args = format (0, " ");
1030  }
1031  vlib_cli_output (vm, "%s %U %v\n",
1032  mode,
1034  vnm, si->sw_if_index, args);
1035  vec_free (args);
1036  }
1037 
1038 done:
1039  vec_free (sis);
1040 
1041  return error;
1042 }
1043 
1044 /*?
1045  * Show the packet processing mode (Layer2 xcross-onnect, Layer 2 bridge,
1046  * Layer 3 routed) of all interfaces and sub-interfaces, or limit the
1047  * output to just the provided list of interfaces and sub-interfaces.
1048  * The output shows the mode, the interface, and if the interface is
1049  * a member of a bridge, the bridge-domain-id and the split horizen group (shg).
1050  *
1051  * @cliexpar
1052  * Example of displaying the mode of all interfaces:
1053  * @cliexstart{show mode}
1054  * l3 local0
1055  * l3 GigabitEthernet0/8/0
1056  * l3 GigabitEthernet0/9/0
1057  * l3 GigabitEthernet0/a/0
1058  * l2 bridge GigabitEthernet0/8/0.200 bd_id 200 shg 0
1059  * l2 bridge GigabitEthernet0/9/0.200 bd_id 200 shg 0
1060  * l2 bridge GigabitEthernet0/a/0.200 bd_id 200 shg 0
1061  * l2 xconnect GigabitEthernet0/8/0.300 GigabitEthernet0/9/0.300
1062  * l2 xconnect GigabitEthernet0/9/0.300 GigabitEthernet0/8/0.300
1063  * @cliexend
1064  * Example of displaying the mode of a seleted list of interfaces:
1065  * @cliexstart{show mode GigabitEthernet0/8/0 GigabitEthernet0/8/0.200}
1066  * l3 GigabitEthernet0/8/0
1067  * l2 bridge GigabitEthernet0/8/0.200 bd_id 200 shg 0
1068  * @cliexend
1069 ?*/
1070 /* *INDENT-OFF* */
1071 VLIB_CLI_COMMAND (show_l2_mode, static) = {
1072  .path = "show mode",
1073  .short_help = "show mode [<if-name1> <if-name2> ...]",
1074  .function = show_int_mode,
1075 };
1076 /* *INDENT-ON* */
1077 
1078 #define foreach_l2_init_function \
1079 _(feat_bitmap_drop_init) \
1080 _(l2fib_init) \
1081 _(l2_input_classify_init) \
1082 _(l2bd_init) \
1083 _(l2fwd_init) \
1084 _(l2_inacl_init) \
1085 _(l2input_init) \
1086 _(l2_vtr_init) \
1087 _(l2_invtr_init) \
1088 _(l2_efp_filter_init) \
1089 _(l2learn_init) \
1090 _(l2flood_init) \
1091 _(l2_outacl_init) \
1092 _(l2output_init) \
1093 _(l2_patch_init) \
1094 _(l2_xcrw_init)
1095 
1096 clib_error_t *
1098 {
1099  clib_error_t *error;
1100 
1101 #define _(a) do { \
1102  if ((error = vlib_call_init_function (vm, a))) return error; } \
1103 while (0);
1105 #undef _
1106  return 0;
1107 }
1108 
1110 
1111 /*
1112  * fd.io coding-style-patch-verification: ON
1113  *
1114  * Local Variables:
1115  * eval: (c-set-style "gnu")
1116  * End:
1117  */
void bd_validate(l2_bridge_domain_t *bd_config)
Init bridge domain if not done already.
Definition: l2_bd.c:51
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:396
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
static char * l2input_feat_names[]
Definition: l2_input.c:50
vmrglw vmrglh hi
static clib_error_t * int_l3(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Set subinterface in L3 mode.
Definition: l2_input.c:915
l2_input_config_t * configs
Definition: l2_input.h:66
#define L2_FLOOD_MEMBER_NORMAL
Definition: l2_bd.h:41
#define CLIB_UNUSED(x)
Definition: clib.h:79
uword unformat(unformat_input_t *i, char *fmt,...)
Definition: unformat.c:966
bad routing header type(not 4)") sr_error (NO_MORE_SEGMENTS
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
u32 bvi_sw_if_index
Definition: l2_bd.h:65
vnet_interface_main_t interface_main
Definition: vnet.h:57
u32 l2input_set_bridge_features(u32 bd_index, u32 feat_mask, u32 feat_value)
Definition: l2_input.c:489
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:458
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
u8 src_address[6]
Definition: packet.h:54
u32 l2fib_del_entry(u64 mac, u32 bd_index)
Delete an entry from the l2fib.
Definition: l2_fib.c:612
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:482
vlib_node_registration_t l2input_node
(constructor) VLIB_REGISTER_NODE (l2input_node)
Definition: l2_input.c:406
#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
unformat_function_t unformat_vnet_sw_interface
u32 bd_remove_member(l2_bridge_domain_t *bd_config, u32 sw_if_index)
Definition: l2_bd.c:168
#define L2_FLOOD_MEMBER_BVI
Definition: l2_bd.h:42
static clib_error_t * int_l2_bridge(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Set subinterface in bridging mode with a bridge-domain ID.
Definition: l2_input.c:748
l2_output_next_nodes_st next_nodes
Definition: l2_output.h:81
format_function_t format_vnet_sw_if_index_name
l2input_error_t
Definition: l2_input.c:93
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 pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:348
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static uword ethernet_address_cast(u8 *a)
Definition: packet.h:65
u32 output_sw_if_index
Definition: l2_input.h:35
#define MODE_L2_BRIDGE
Definition: l2_input.h:179
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:194
#define vec_new(T, N)
Create new vector of given type and length (unspecified alignment, no header).
Definition: vec.h:270
u8 dst_address[6]
Definition: packet.h:53
void bd_add_member(l2_bridge_domain_t *bd_config, l2_flood_member_t *member)
Definition: l2_bd.c:129
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
u32 set_int_l2_mode(vlib_main_t *vm, vnet_main_t *vnet_main, u32 mode, u32 sw_if_index, u32 bd_index, u32 bvi, u32 shg, u32 xc_sw_if_index)
Set the subinterface to run in l2 or l3 mode.
Definition: l2_input.c:509
void ethernet_set_rx_redirect(vnet_main_t *vnm, vnet_hw_interface_t *hi, u32 enable)
#define foreach_l2input_error
Definition: l2_input.c:89
l2_output_config_t * l2output_intf_config(u32 sw_if_index)
Get a pointer to the config for the given interface.
Definition: l2_output.c:674
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
vnet_main_t * vnet_main
Definition: l2_input.h:73
uword os_get_cpu_number(void)
Definition: unix-misc.c:224
#define PREDICT_FALSE(x)
Definition: clib.h:97
vnet_main_t vnet_main
Definition: misc.c:43
l2output_main_t l2output_main
Definition: l2_output.c:43
u32 feat_next_node_index[32]
Definition: l2_input.h:63
static u32 feat_bitmap_get_next_node_index(u32 *next_nodes, u32 bitmap)
Return the graph node index for the feature corresponding to the first set bit in the bitmap...
Definition: feat_bitmap.h:79
#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
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:576
static clib_error_t * int_l2_xc(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Set subinterface in xconnect mode with another interface.
Definition: l2_input.c:850
#define L2INPUT_BVI
Definition: l2_input.h:90
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1113
vnet_hw_interface_class_t ethernet_hw_interface_class
u8 * format_ethernet_header_with_length(u8 *s, va_list *args)
Definition: format.c:115
#define foreach_l2_init_function
Definition: l2_input.c:1078
u16 n_vectors
Definition: node.h:344
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
static_always_inline void classify_and_dispatch(vlib_main_t *vm, vlib_node_runtime_t *node, u32 cpu_index, l2input_main_t *msm, vlib_buffer_t *b0, u32 *next0)
Definition: l2_input.c:117
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:300
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 MODE_ERROR_ETH
Definition: l2_input.h:183
void ethernet_register_l2_input(vlib_main_t *vm, u32 node_index)
Definition: node.c:1313
#define clib_memcpy(a, b, c)
Definition: string.h:69
#define VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT
#define ETHERNET_INTERFACE_FLAG_ACCEPT_ALL
Definition: ethernet.h:113
#define ARRAY_LEN(x)
Definition: clib.h:59
void l2fib_add_entry(u64 mac, u32 bd_index, u32 sw_if_index, u32 static_mac, u32 filter_mac, u32 bvi_mac)
Add an entry to the l2fib.
Definition: l2_fib.c:314
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
u16 cached_next_index
Definition: node.h:463
#define ASSERT(truth)
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
static clib_error_t * show_int_mode(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Show interface mode.
Definition: l2_input.c:964
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:259
#define MODE_L2_XC
Definition: l2_input.h:180
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:95
clib_error_t * l2_init(vlib_main_t *vm)
Definition: l2_input.c:1097
static uword l2input_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: l2_input.c:227
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
static u8 * format_l2input_trace(u8 *s, va_list *args)
Definition: l2_input.c:74
clib_error_t * l2input_init(vlib_main_t *vm)
Definition: l2_input.c:429
Definition: defs.h:47
unsigned short u16
Definition: types.h:57
l2input_main_t l2input_main
Definition: l2_input.c:87
void ethernet_sw_interface_set_l2_mode(vnet_main_t *vnm, u32 sw_if_index, u32 l2)
Definition: node.c:954
u32 bd_find_or_add_bd_index(bd_main_t *bdm, u32 bd_id)
Get or create a bridge domain.
Definition: l2_bd.c:68
u32 feature_bitmap
Definition: l2_bd.h:57
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
static char * l2input_error_strings[]
Definition: l2_input.c:101
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:606
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
#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 MODE_ERROR_BVI_DEF
Definition: l2_input.h:184
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
#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
#define MODE_L2_CLASSIFY
Definition: l2_input.h:181
#define vec_foreach(var, vec)
Vector iterator.
#define get_u16(addr)
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
l2input_next_t
Definition: l2_input.c:107
uword vlib_node_add_named_next_with_slot(vlib_main_t *vm, uword node, char *name, uword slot)
Definition: node.c:213
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:445
bd_main_t bd_main
Definition: l2_bd.c:44
#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 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
#define MODE_L3
Definition: l2_input.h:178
vlib_main_t * vlib_main
Definition: l2_input.h:72
u32 ethernet_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:319
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:109