l2_flood.c revision 8a4bfdae
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
48typedef 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 */
55  next_by_ethertype_t l3_next;
56
57  /* convenience variables */
58  vlib_main_t *vlib_main;
59  vnet_main_t *vnet_main;
60
61  /* per-cpu vector of cloned packets */
62  u32 **clones;
63  l2_flood_member_t ***members;
64} l2flood_main_t;
65
66typedef struct
67{
68  u8 src[6];
69  u8 dst[6];
70  u32 sw_if_index;
71  u16 bd_index;
72} l2flood_trace_t;
73
74
75/* packet trace format function */
76static u8 *
77format_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,
85	      format_ethernet_address, t->dst,
86	      format_ethernet_address, t->src, t->bd_index);
87  return s;
88}
89
90extern l2flood_main_t l2flood_main;
91
92#ifndef CLIB_MARCH_VARIANT
93l2flood_main_t l2flood_main;
94#endif /* CLIB_MARCH_VARIANT */
95
96#define foreach_l2flood_error					\
97_(L2FLOOD,           "L2 flood packets")			\
98_(REPL_FAIL,         "L2 replication failures")			\
99_(NO_MEMBERS,        "L2 replication complete")			\
100_(BVI_BAD_MAC,       "BVI L3 mac mismatch")		        \
101_(BVI_ETHERTYPE,     "BVI packet with unhandled ethertype")
102
103typedef enum
104{
105#define _(sym,str) L2FLOOD_ERROR_##sym,
106  foreach_l2flood_error
107#undef _
108    L2FLOOD_N_ERROR,
109} l2flood_error_t;
110
111static char *l2flood_error_strings[] = {
112#define _(sym,string) string,
113  foreach_l2flood_error
114#undef _
115};
116
117typedef enum
118{
119  L2FLOOD_NEXT_L2_OUTPUT,
120  L2FLOOD_NEXT_DROP,
121  L2FLOOD_N_NEXT,
122} l2flood_next_t;
123
124/*
125 * Perform flooding on one packet
126 *
127 * Due to the way BVI processing can modify the packet, the BVI interface
128 * (if present) must be processed last in the replication. The member vector
129 * is arranged so that the BVI interface is always the first element.
130 * Flooding walks the vector in reverse.
131 *
132 * BVI processing causes the packet to go to L3 processing. This strips the
133 * L2 header, which is fine because the replication infrastructure restores
134 * it. However L3 processing can trigger larger changes to the packet. For
135 * example, an ARP request could be turned into an ARP reply, an ICMP request
136 * could be turned into an ICMP reply. If BVI processing is not performed
137 * last, the modified packet would be replicated to the remaining members.
138 */
139VLIB_NODE_FN (l2flood_node) (vlib_main_t * vm,
140			     vlib_node_runtime_t * node, vlib_frame_t * frame)
141{
142  u32 n_left_from, *from, *to_next;
143  l2flood_next_t next_index;
144  l2flood_main_t *msm = &l2flood_main;
145  u32 thread_index = vm->thread_index;
146
147  from = vlib_frame_vector_args (frame);
148  n_left_from = frame->n_vectors;
149  next_index = node->cached_next_index;
150
151  while (n_left_from > 0)
152    {
153      u32 n_left_to_next;
154
155      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
156
157      while (n_left_from > 0 && n_left_to_next > 0)
158	{
159	  u16 n_clones, n_cloned, clone0;
160	  l2_bridge_domain_t *bd_config;
161	  u32 sw_if_index0, bi0, ci0;
162	  l2_flood_member_t *member;
163	  vlib_buffer_t *b0, *c0;
164	  u16 next0;
165	  u8 in_shg;
166	  i32 mi;
167
168	  /* speculatively enqueue b0 to the current next frame */
169	  bi0 = from[0];
170	  from += 1;
171	  n_left_from -= 1;
172	  next0 = L2FLOOD_NEXT_L2_OUTPUT;
173
174	  b0 = vlib_get_buffer (vm, bi0);
175
176	  /* Get config for the bridge domain interface */
177	  bd_config = vec_elt_at_index (l2input_main.bd_configs,
178					vnet_buffer (b0)->l2.bd_index);
179	  in_shg = vnet_buffer (b0)->l2.shg;
180	  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
181
182	  vec_validate (msm->members[thread_index],
183			vec_len (bd_config->members));
184
185	  vec_reset_length (msm->members[thread_index]);
186
187	  /* Find first members that passes the reflection and SHG checks */
188	  for (mi = bd_config->flood_count - 1; mi >= 0; mi--)
189	    {
190	      member = &bd_config->members[mi];
191	      if ((member->sw_if_index != sw_if_index0) &&
192		  (!in_shg || (member->shg != in_shg)))
193		{
194		  vec_add1 (msm->members[thread_index], member);
195		}
196	    }
197
198	  n_clones = vec_len (msm->members[thread_index]);
199
200	  if (0 == n_clones)
201	    {
202	      /* No members to flood to */
203	      to_next[0] = bi0;
204	      to_next += 1;
205	      n_left_to_next -= 1;
206
207	      b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS];
208	      vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
209					       to_next, n_left_to_next,
210					       bi0, L2FLOOD_NEXT_DROP);
211	      continue;
212	    }
213	  else if (n_clones > 1)
214	    {
215	      vec_validate (msm->clones[thread_index], n_clones);
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,
226					    VLIB_BUFFER_CLONE_HEAD_SIZE);
227
228	      vec_set_len (msm->clones[thread_index], n_cloned);
229
230	      if (PREDICT_FALSE (n_cloned != n_clones))
231		{
232		  b0->error = node->errors[L2FLOOD_ERROR_REPL_FAIL];
233		}
234
235	      /*
236	       * for all but the last clone, these are not BVI bound
237	       */
238	      for (clone0 = 0; clone0 < n_cloned - 1; clone0++)
239		{
240		  member = msm->members[thread_index][clone0];
241		  ci0 = msm->clones[thread_index][clone0];
242		  c0 = vlib_get_buffer (vm, ci0);
243
244		  to_next[0] = ci0;
245		  to_next += 1;
246		  n_left_to_next -= 1;
247
248		  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
249				     (b0->flags & VLIB_BUFFER_IS_TRACED)))
250		    {
251		      ethernet_header_t *h0;
252		      l2flood_trace_t *t;
253
254		      t = vlib_add_trace (vm, node, c0, sizeof (*t));
255		      h0 = vlib_buffer_get_current (c0);
256		      t->sw_if_index = sw_if_index0;
257		      t->bd_index = vnet_buffer (c0)->l2.bd_index;
258		      clib_memcpy_fast (t->src, h0->src_address, 6);
259		      clib_memcpy_fast (t->dst, h0->dst_address, 6);
260		    }
261
262		  /* Do normal L2 forwarding */
263		  vnet_buffer (c0)->sw_if_index[VLIB_TX] =
264		    member->sw_if_index;
265
266		  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
267						   to_next, n_left_to_next,
268						   ci0, next0);
269		  if (PREDICT_FALSE (0 == n_left_to_next))
270		    {
271		      vlib_put_next_frame (vm, node, next_index,
272					   n_left_to_next);
273		      vlib_get_next_frame (vm, node, next_index, to_next,
274					   n_left_to_next);
275		    }
276		}
277	      member = msm->members[thread_index][clone0];
278	      ci0 = msm->clones[thread_index][clone0];
279	    }
280	  else
281	    {
282	      /* one clone */
283	      ci0 = bi0;
284	      member = msm->members[thread_index][0];
285	    }
286
287	  /*
288	   * the last clone that might go to a BVI
289	   */
290	  c0 = vlib_get_buffer (vm, ci0);
291
292	  to_next[0] = ci0;
293	  to_next += 1;
294	  n_left_to_next -= 1;
295
296	  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
297			     (b0->flags & VLIB_BUFFER_IS_TRACED)))
298	    {
299	      ethernet_header_t *h0;
300	      l2flood_trace_t *t;
301
302	      t = vlib_add_trace (vm, node, c0, sizeof (*t));
303	      h0 = vlib_buffer_get_current (c0);
304	      t->sw_if_index = sw_if_index0;
305	      t->bd_index = vnet_buffer (c0)->l2.bd_index;
306	      clib_memcpy_fast (t->src, h0->src_address, 6);
307	      clib_memcpy_fast (t->dst, h0->dst_address, 6);
308	    }
309
310
311	  /* Forward packet to the current member */
312	  if (PREDICT_FALSE (member->flags & L2_FLOOD_MEMBER_BVI))
313	    {
314	      /* Do BVI processing */
315	      u32 rc;
316	      rc = l2_to_bvi (vm,
317			      msm->vnet_main,
318			      c0, member->sw_if_index, &msm->l3_next, &next0);
319
320	      if (PREDICT_FALSE (rc != TO_BVI_ERR_OK))
321		{
322		  if (rc == TO_BVI_ERR_BAD_MAC)
323		    {
324		      c0->error = node->errors[L2FLOOD_ERROR_BVI_BAD_MAC];
325		    }
326		  else if (rc == TO_BVI_ERR_ETHERTYPE)
327		    {
328		      c0->error = node->errors[L2FLOOD_ERROR_BVI_ETHERTYPE];
329		    }
330		  next0 = L2FLOOD_NEXT_DROP;
331		}
332	    }
333	  else
334	    {
335	      /* Do normal L2 forwarding */
336	      vnet_buffer (c0)->sw_if_index[VLIB_TX] = member->sw_if_index;
337	    }
338
339	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
340					   to_next, n_left_to_next,
341					   ci0, next0);
342	  if (PREDICT_FALSE (0 == n_left_to_next))
343	    {
344	      vlib_put_next_frame (vm, node, next_index, n_left_to_next);
345	      vlib_get_next_frame (vm, node, next_index,
346				   to_next, n_left_to_next);
347	    }
348	}
349
350      vlib_put_next_frame (vm, node, next_index, n_left_to_next);
351    }
352
353  vlib_node_increment_counter (vm, node->node_index,
354			       L2FLOOD_ERROR_L2FLOOD, frame->n_vectors);
355
356  return frame->n_vectors;
357}
358
359
360/* *INDENT-OFF* */
361VLIB_REGISTER_NODE (l2flood_node) = {
362  .name = "l2-flood",
363  .vector_size = sizeof (u32),
364  .format_trace = format_l2flood_trace,
365  .type = VLIB_NODE_TYPE_INTERNAL,
366
367  .n_errors = ARRAY_LEN(l2flood_error_strings),
368  .error_strings = l2flood_error_strings,
369
370  .n_next_nodes = L2FLOOD_N_NEXT,
371
372  /* edit / add dispositions here */
373  .next_nodes = {
374        [L2FLOOD_NEXT_L2_OUTPUT] = "l2-output",
375        [L2FLOOD_NEXT_DROP] = "error-drop",
376  },
377};
378/* *INDENT-ON* */
379
380#ifndef CLIB_MARCH_VARIANT
381clib_error_t *
382l2flood_init (vlib_main_t * vm)
383{
384  l2flood_main_t *mp = &l2flood_main;
385
386  mp->vlib_main = vm;
387  mp->vnet_main = vnet_get_main ();
388
389  vec_validate (mp->clones, vlib_num_workers ());
390  vec_validate (mp->members, vlib_num_workers ());
391
392  /* Initialize the feature next-node indexes */
393  feat_bitmap_init_next_nodes (vm,
394			       l2flood_node.index,
395			       L2INPUT_N_FEAT,
396			       l2input_get_feat_names (),
397			       mp->feat_next_node_index);
398
399  return NULL;
400}
401
402VLIB_INIT_FUNCTION (l2flood_init);
403
404
405
406/** Add the L3 input node for this ethertype to the next nodes structure. */
407void
408l2flood_register_input_type (vlib_main_t * vm,
409			     ethernet_type_t type, u32 node_index)
410{
411  l2flood_main_t *mp = &l2flood_main;
412  u32 next_index;
413
414  next_index = vlib_node_add_next (vm, l2flood_node.index, node_index);
415
416  next_by_ethertype_register (&mp->l3_next, type, next_index);
417}
418#endif /* CLIB_MARCH_VARIANT */
419
420
421/**
422 * Set subinterface flood enable/disable.
423 * The CLI format is:
424 * set interface l2 flood <interface> [disable]
425 */
426static clib_error_t *
427int_flood (vlib_main_t * vm,
428	   unformat_input_t * input, vlib_cli_command_t * cmd)
429{
430  vnet_main_t *vnm = vnet_get_main ();
431  clib_error_t *error = 0;
432  u32 sw_if_index;
433  u32 enable;
434
435  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
436    {
437      error = clib_error_return (0, "unknown interface `%U'",
438				 format_unformat_error, input);
439      goto done;
440    }
441
442  enable = 1;
443  if (unformat (input, "disable"))
444    {
445      enable = 0;
446    }
447
448  /* set the interface flag */
449  l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_FLOOD, enable);
450
451done:
452  return error;
453}
454
455/*?
456 * Layer 2 flooding can be enabled and disabled on each
457 * interface and on each bridge-domain. Use this command to
458 * manage interfaces. It is enabled by default.
459 *
460 * @cliexpar
461 * Example of how to enable flooding:
462 * @cliexcmd{set interface l2 flood GigabitEthernet0/8/0}
463 * Example of how to disable flooding:
464 * @cliexcmd{set interface l2 flood GigabitEthernet0/8/0 disable}
465?*/
466/* *INDENT-OFF* */
467VLIB_CLI_COMMAND (int_flood_cli, static) = {
468  .path = "set interface l2 flood",
469  .short_help = "set interface l2 flood <interface> [disable]",
470  .function = int_flood,
471};
472/* *INDENT-ON* */
473
474/*
475 * fd.io coding-style-patch-verification: ON
476 *
477 * Local Variables:
478 * eval: (c-set-style "gnu")
479 * End:
480 */
481