FD.io VPP  v19.01.2-3-gf61a1a8
Vector Packet Processing
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
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/l2/l2_fib.h>
27 
28 #include <vppinfra/error.h>
29 #include <vppinfra/hash.h>
30 
31 
32 /**
33  * @file
34  * @brief Ethernet Flooding.
35  *
36  * Flooding uses the packet replication infrastructure to send a copy of the
37  * packet to each member interface. Logically the replication infrastructure
38  * expects two graph nodes: a prep node that initiates replication and sends the
39  * packet to the first destination, and a recycle node that is passed the packet
40  * after it has been transmitted.
41  *
42  * To decrease the amount of code, l2 flooding implements both functions in
43  * the same graph node. This node can tell if is it being called as the "prep"
44  * or "recycle" using replication_is_recycled().
45  */
46 
47 
48 typedef struct
49 {
50 
51  /* Next nodes for each feature */
52  u32 feat_next_node_index[32];
53 
54  /* next node index for the L3 input node of each ethertype */
56 
57  /* convenience variables */
60 
61  /* per-cpu vector of cloned packets */
65 
66 typedef struct
67 {
68  u8 src[6];
69  u8 dst[6];
73 
74 
75 /* packet trace format function */
76 static u8 *
77 format_l2flood_trace (u8 * s, va_list * args)
78 {
79  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
80  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
81  l2flood_trace_t *t = va_arg (*args, l2flood_trace_t *);
82 
83  s = format (s, "l2-flood: sw_if_index %d dst %U src %U bd_index %d",
84  t->sw_if_index,
87  return s;
88 }
89 
91 
93 
94 #define foreach_l2flood_error \
95 _(L2FLOOD, "L2 flood packets") \
96 _(REPL_FAIL, "L2 replication failures") \
97 _(NO_MEMBERS, "L2 replication complete") \
98 _(BVI_BAD_MAC, "BVI L3 mac mismatch") \
99 _(BVI_ETHERTYPE, "BVI packet with unhandled ethertype")
100 
101 typedef enum
102 {
103 #define _(sym,str) L2FLOOD_ERROR_##sym,
105 #undef _
108 
109 static char *l2flood_error_strings[] = {
110 #define _(sym,string) string,
112 #undef _
113 };
114 
115 typedef enum
116 {
121 
122 /*
123  * Perform flooding on one packet
124  *
125  * Due to the way BVI processing can modify the packet, the BVI interface
126  * (if present) must be processed last in the replication. The member vector
127  * is arranged so that the BVI interface is always the first element.
128  * Flooding walks the vector in reverse.
129  *
130  * BVI processing causes the packet to go to L3 processing. This strips the
131  * L2 header, which is fine because the replication infrastructure restores
132  * it. However L3 processing can trigger larger changes to the packet. For
133  * example, an ARP request could be turned into an ARP reply, an ICMP request
134  * could be turned into an ICMP reply. If BVI processing is not performed
135  * last, the modified packet would be replicated to the remaining members.
136  */
137 static uword
139  vlib_node_runtime_t * node, vlib_frame_t * frame)
140 {
141  u32 n_left_from, *from, *to_next;
142  l2flood_next_t next_index;
144  u32 thread_index = vm->thread_index;
145 
146  from = vlib_frame_vector_args (frame);
147  n_left_from = frame->n_vectors;
148  next_index = node->cached_next_index;
149 
150  while (n_left_from > 0)
151  {
152  u32 n_left_to_next;
153 
154  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
155 
156  while (n_left_from > 0 && n_left_to_next > 0)
157  {
158  u16 n_clones, n_cloned, clone0;
159  l2_bridge_domain_t *bd_config;
160  u32 sw_if_index0, bi0, ci0;
161  l2_flood_member_t *member;
162  vlib_buffer_t *b0, *c0;
163  u16 next0;
164  u8 in_shg;
165  i32 mi;
166 
167  /* speculatively enqueue b0 to the current next frame */
168  bi0 = from[0];
169  from += 1;
170  n_left_from -= 1;
171  next0 = L2FLOOD_NEXT_L2_OUTPUT;
172 
173  b0 = vlib_get_buffer (vm, bi0);
174 
175  /* Get config for the bridge domain interface */
177  vnet_buffer (b0)->l2.bd_index);
178  in_shg = vnet_buffer (b0)->l2.shg;
179  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
180 
181  vec_validate (msm->members[thread_index],
182  vec_len (bd_config->members));
183 
184  vec_reset_length (msm->members[thread_index]);
185 
186  /* Find first members that passes the reflection and SHG checks */
187  for (mi = bd_config->flood_count - 1; mi >= 0; mi--)
188  {
189  member = &bd_config->members[mi];
190  if ((member->sw_if_index != sw_if_index0) &&
191  (!in_shg || (member->shg != in_shg)))
192  {
193  vec_add1 (msm->members[thread_index], member);
194  }
195  }
196 
197  n_clones = vec_len (msm->members[thread_index]);
198 
199  if (0 == n_clones)
200  {
201  /* No members to flood to */
202  to_next[0] = bi0;
203  to_next += 1;
204  n_left_to_next -= 1;
205 
206  b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS];
207  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
208  to_next, n_left_to_next,
209  bi0, L2FLOOD_NEXT_DROP);
210  continue;
211  }
212  else if (n_clones > 1)
213  {
214  vec_validate (msm->clones[thread_index], n_clones);
215  vec_reset_length (msm->clones[thread_index]);
216 
217  /*
218  * the header offset needs to be large enough to incorporate
219  * all the L3 headers that could be touched when doing BVI
220  * processing. So take the current l2 length plus 2 * IPv6
221  * headers (for tunnel encap)
222  */
223  n_cloned = vlib_buffer_clone (vm, bi0,
224  msm->clones[thread_index],
225  n_clones,
227 
228  if (PREDICT_FALSE (n_cloned != n_clones))
229  {
230  b0->error = node->errors[L2FLOOD_ERROR_REPL_FAIL];
231  }
232 
233  /*
234  * for all but the last clone, these are not BVI bound
235  */
236  for (clone0 = 0; clone0 < n_cloned - 1; clone0++)
237  {
238  member = msm->members[thread_index][clone0];
239  ci0 = msm->clones[thread_index][clone0];
240  c0 = vlib_get_buffer (vm, ci0);
241 
242  to_next[0] = ci0;
243  to_next += 1;
244  n_left_to_next -= 1;
245 
246  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
247  (b0->flags & VLIB_BUFFER_IS_TRACED)))
248  {
249  ethernet_header_t *h0;
250  l2flood_trace_t *t;
251 
252  if (c0 != b0)
253  vlib_buffer_copy_trace_flag (vm, b0, ci0);
254 
255  t = vlib_add_trace (vm, node, c0, sizeof (*t));
256  h0 = vlib_buffer_get_current (c0);
257  t->sw_if_index = sw_if_index0;
258  t->bd_index = vnet_buffer (c0)->l2.bd_index;
259  clib_memcpy_fast (t->src, h0->src_address, 6);
260  clib_memcpy_fast (t->dst, h0->dst_address, 6);
261  }
262 
263  /* Do normal L2 forwarding */
264  vnet_buffer (c0)->sw_if_index[VLIB_TX] =
265  member->sw_if_index;
266 
267  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
268  to_next, n_left_to_next,
269  ci0, next0);
270  if (PREDICT_FALSE (0 == n_left_to_next))
271  {
272  vlib_put_next_frame (vm, node, next_index,
273  n_left_to_next);
274  vlib_get_next_frame (vm, node, next_index, to_next,
275  n_left_to_next);
276  }
277  }
278  member = msm->members[thread_index][clone0];
279  ci0 = msm->clones[thread_index][clone0];
280  }
281  else
282  {
283  /* one clone */
284  ci0 = bi0;
285  member = msm->members[thread_index][0];
286  }
287 
288  /*
289  * the last clone that might go to a BVI
290  */
291  c0 = vlib_get_buffer (vm, ci0);
292 
293  to_next[0] = ci0;
294  to_next += 1;
295  n_left_to_next -= 1;
296 
297  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
298  (b0->flags & VLIB_BUFFER_IS_TRACED)))
299  {
300  ethernet_header_t *h0;
301  l2flood_trace_t *t;
302 
303  if (c0 != b0)
304  vlib_buffer_copy_trace_flag (vm, b0, ci0);
305 
306  t = vlib_add_trace (vm, node, c0, sizeof (*t));
307  h0 = vlib_buffer_get_current (c0);
308  t->sw_if_index = sw_if_index0;
309  t->bd_index = vnet_buffer (c0)->l2.bd_index;
310  clib_memcpy_fast (t->src, h0->src_address, 6);
311  clib_memcpy_fast (t->dst, h0->dst_address, 6);
312  }
313 
314 
315  /* Forward packet to the current member */
316  if (PREDICT_FALSE (member->flags & L2_FLOOD_MEMBER_BVI))
317  {
318  /* Do BVI processing */
319  u32 rc;
320  rc = l2_to_bvi (vm,
321  msm->vnet_main,
322  c0, member->sw_if_index, &msm->l3_next, &next0);
323 
324  if (PREDICT_FALSE (rc != TO_BVI_ERR_OK))
325  {
326  if (rc == TO_BVI_ERR_BAD_MAC)
327  {
328  c0->error = node->errors[L2FLOOD_ERROR_BVI_BAD_MAC];
329  }
330  else if (rc == TO_BVI_ERR_ETHERTYPE)
331  {
332  c0->error = node->errors[L2FLOOD_ERROR_BVI_ETHERTYPE];
333  }
334  next0 = L2FLOOD_NEXT_DROP;
335  }
336  }
337  else
338  {
339  /* Do normal L2 forwarding */
340  vnet_buffer (c0)->sw_if_index[VLIB_TX] = member->sw_if_index;
341  }
342 
343  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
344  to_next, n_left_to_next,
345  ci0, next0);
346  if (PREDICT_FALSE (0 == n_left_to_next))
347  {
348  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
349  vlib_get_next_frame (vm, node, next_index,
350  to_next, n_left_to_next);
351  }
352  }
353 
354  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
355  }
356 
358  L2FLOOD_ERROR_L2FLOOD, frame->n_vectors);
359 
360  return frame->n_vectors;
361 }
362 
363 
364 /* *INDENT-OFF* */
365 VLIB_REGISTER_NODE (l2flood_node,static) = {
366  .function = l2flood_node_fn,
367  .name = "l2-flood",
368  .vector_size = sizeof (u32),
369  .format_trace = format_l2flood_trace,
370  .type = VLIB_NODE_TYPE_INTERNAL,
371 
372  .n_errors = ARRAY_LEN(l2flood_error_strings),
373  .error_strings = l2flood_error_strings,
374 
375  .n_next_nodes = L2FLOOD_N_NEXT,
376 
377  /* edit / add dispositions here */
378  .next_nodes = {
379  [L2FLOOD_NEXT_L2_OUTPUT] = "l2-output",
380  [L2FLOOD_NEXT_DROP] = "error-drop",
381  },
382 };
383 
385 /* *INDENT-ON* */
386 
387 clib_error_t *
389 {
391 
392  mp->vlib_main = vm;
393  mp->vnet_main = vnet_get_main ();
394 
397 
398  /* Initialize the feature next-node indexes */
400  l2flood_node.index,
404 
405  return NULL;
406 }
407 
409 
410 
411 
412 /** Add the L3 input node for this ethertype to the next nodes structure. */
413 void
415  ethernet_type_t type, u32 node_index)
416 {
418  u32 next_index;
419 
420  next_index = vlib_node_add_next (vm, l2flood_node.index, node_index);
421 
422  next_by_ethertype_register (&mp->l3_next, type, next_index);
423 }
424 
425 
426 /**
427  * Set subinterface flood enable/disable.
428  * The CLI format is:
429  * set interface l2 flood <interface> [disable]
430  */
431 static clib_error_t *
433  unformat_input_t * input, vlib_cli_command_t * cmd)
434 {
435  vnet_main_t *vnm = vnet_get_main ();
436  clib_error_t *error = 0;
438  u32 enable;
439 
440  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
441  {
442  error = clib_error_return (0, "unknown interface `%U'",
443  format_unformat_error, input);
444  goto done;
445  }
446 
447  enable = 1;
448  if (unformat (input, "disable"))
449  {
450  enable = 0;
451  }
452 
453  /* set the interface flag */
454  l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_FLOOD, enable);
455 
456 done:
457  return error;
458 }
459 
460 /*?
461  * Layer 2 flooding can be enabled and disabled on each
462  * interface and on each bridge-domain. Use this command to
463  * manage interfaces. It is enabled by default.
464  *
465  * @cliexpar
466  * Example of how to enable flooding:
467  * @cliexcmd{set interface l2 flood GigabitEthernet0/8/0}
468  * Example of how to disable flooding:
469  * @cliexcmd{set interface l2 flood GigabitEthernet0/8/0 disable}
470 ?*/
471 /* *INDENT-OFF* */
472 VLIB_CLI_COMMAND (int_flood_cli, static) = {
473  .path = "set interface l2 flood",
474  .short_help = "set interface l2 flood <interface> [disable]",
475  .function = int_flood,
476 };
477 /* *INDENT-ON* */
478 
479 /*
480  * fd.io coding-style-patch-verification: ON
481  *
482  * Local Variables:
483  * eval: (c-set-style "gnu")
484  * End:
485  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
u32 feat_next_node_index[32]
Definition: l2_flood.c:52
u32 ** clones
Definition: l2_flood.c:62
vnet_main_t * vnet_main
Definition: l2_flood.c:59
l2flood_next_t
Definition: l2_flood.c:115
vl_api_address_t src
Definition: vxlan_gbp.api:32
#define CLIB_UNUSED(x)
Definition: clib.h:82
#define VLIB_BUFFER_CLONE_HEAD_SIZE
Definition: buffer.h:60
#define TO_BVI_ERR_BAD_MAC
Definition: l2_bvi.h:28
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
#define NULL
Definition: clib.h:58
ethernet_type_t
Definition: packet.h:45
#define TO_BVI_ERR_ETHERTYPE
Definition: l2_bvi.h:29
u8 src_address[6]
Definition: packet.h:56
u32 thread_index
Definition: main.h:179
vlib_main_t * vlib_main
Definition: l2_flood.c:58
l2flood_main_t l2flood_main
Definition: l2_flood.c:90
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:525
static uword l2flood_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: l2_flood.c:138
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:414
l2_flood_member_t * members
Definition: l2_bd.h:86
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
static char * l2flood_error_strings[]
Definition: l2_flood.c:109
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
unformat_function_t unformat_vnet_sw_interface
#define L2_FLOOD_MEMBER_BVI
Definition: l2_bd.h:51
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:494
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1122
unsigned char u8
Definition: types.h:56
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
u32 sw_if_index
Definition: vxlan_gbp.api:37
u8 dst_address[6]
Definition: packet.h:55
static u8 * format_l2flood_trace(u8 *s, va_list *args)
Definition: l2_flood.c:77
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define clib_error_return(e, args...)
Definition: error.h:99
unsigned int u32
Definition: types.h:88
#define VLIB_NODE_FUNCTION_MULTIARCH(node, fn)
Definition: node.h:223
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:214
#define PREDICT_FALSE(x)
Definition: clib.h:111
static vlib_node_registration_t l2flood_node
(constructor) VLIB_REGISTER_NODE (l2flood_node)
Definition: l2_flood.c:92
u32 node_index
Node index.
Definition: node.h:519
#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:368
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:139
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1180
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
static void vlib_buffer_copy_trace_flag(vlib_main_t *vm, vlib_buffer_t *b, u32 bi_target)
Definition: trace_funcs.h:147
clib_error_t * next_by_ethertype_register(next_by_ethertype_t *l3_next, u32 ethertype, u32 next_index)
Definition: node.c:1961
static u16 vlib_buffer_clone(vlib_main_t *vm, u32 src_buffer, u32 *buffers, u16 n_buffers, u16 head_end_offset)
Create multiple clones of buffer and store them in the supplied array.
Definition: buffer_funcs.h:836
u16 n_vectors
Definition: node.h:420
vlib_main_t * vm
Definition: buffer.c:301
vl_api_address_t dst
Definition: vxlan_gbp.api:33
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
l2_flood_member_t *** members
Definition: l2_flood.c:63
#define ARRAY_LEN(x)
Definition: clib.h:62
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
char ** l2input_get_feat_names(void)
Return an array of strings containing graph node names of each feature.
Definition: l2_input.c:60
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
signed int i32
Definition: types.h:77
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:538
u32 l2input_intf_bitmap_enable(u32 sw_if_index, l2input_feat_masks_t feature_bitmap, u32 enable)
Enable (or disable) the feature in the bitmap for the given interface.
Definition: l2_input.c:530
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:57
struct _vlib_node_registration vlib_node_registration_t
Definition: defs.h:47
l2input_main_t l2input_main
Definition: l2_input.c:122
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define foreach_l2flood_error
Definition: l2_flood.c:94
l2flood_error_t
Definition: l2_flood.c:101
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:274
l2_bridge_domain_t * bd_configs
Definition: l2_input.h:64
#define vnet_buffer(b)
Definition: buffer.h:368
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
static u32 vlib_num_workers()
Definition: threads.h:366
u16 flags
Copy of main node flags.
Definition: node.h:532
u32 sw_if_index
Definition: l2_bd.h:55
#define TO_BVI_ERR_OK
Definition: l2_bvi.h:27
next_by_ethertype_t l3_next
Definition: l2_flood.c:55
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:326
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:117
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:432
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:62
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
Definition: defs.h:46
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, u16 *next0)
Send a packet from L2 processing to L3 via the BVI interface.
Definition: l2_bvi.h:38
clib_error_t * l2flood_init(vlib_main_t *vm)
Definition: l2_flood.c:388