Line data Source code
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/ethernet/ethernet.h>
21 : #include <vlib/cli.h>
22 : #include <vnet/l2/l2_input.h>
23 : #include <vnet/l2/feat_bitmap.h>
24 : #include <vnet/l2/l2_bvi.h>
25 : #include <vnet/l2/l2_fib.h>
26 :
27 : #include <vppinfra/error.h>
28 : #include <vppinfra/hash.h>
29 :
30 :
31 : /**
32 : * @file
33 : * @brief Ethernet Flooding.
34 : *
35 : * Flooding uses the packet replication infrastructure to send a copy of the
36 : * packet to each member interface. Logically the replication infrastructure
37 : * expects two graph nodes: a prep node that initiates replication and sends the
38 : * packet to the first destination, and a recycle node that is passed the packet
39 : * after it has been transmitted.
40 : *
41 : * To decrease the amount of code, l2 flooding implements both functions in
42 : * the same graph node. This node can tell if is it being called as the "prep"
43 : * or "recycle" using replication_is_recycled().
44 : */
45 :
46 :
47 : typedef struct
48 : {
49 :
50 : /* Next nodes for each feature */
51 : u32 feat_next_node_index[32];
52 :
53 : /* next node index for the L3 input node of each ethertype */
54 : next_by_ethertype_t l3_next;
55 :
56 : /* convenience variables */
57 : vlib_main_t *vlib_main;
58 : vnet_main_t *vnet_main;
59 :
60 : /* per-cpu vector of cloned packets */
61 : u32 **clones;
62 : l2_flood_member_t ***members;
63 : } l2flood_main_t;
64 :
65 : typedef struct
66 : {
67 : u8 src[6];
68 : u8 dst[6];
69 : u32 sw_if_index;
70 : u16 bd_index;
71 : } l2flood_trace_t;
72 :
73 :
74 : /* packet trace format function */
75 : static u8 *
76 4733 : format_l2flood_trace (u8 * s, va_list * args)
77 : {
78 4733 : CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
79 4733 : CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
80 4733 : l2flood_trace_t *t = va_arg (*args, l2flood_trace_t *);
81 :
82 4733 : s = format (s, "l2-flood: sw_if_index %d dst %U src %U bd_index %d",
83 : t->sw_if_index,
84 4733 : format_ethernet_address, t->dst,
85 4733 : format_ethernet_address, t->src, t->bd_index);
86 4733 : return s;
87 : }
88 :
89 : extern l2flood_main_t l2flood_main;
90 :
91 : #ifndef CLIB_MARCH_VARIANT
92 : l2flood_main_t l2flood_main;
93 : #endif /* CLIB_MARCH_VARIANT */
94 :
95 : #define foreach_l2flood_error \
96 : _(L2FLOOD, "L2 flood packets") \
97 : _(REPL_FAIL, "L2 replication failures") \
98 : _(NO_MEMBERS, "L2 replication complete") \
99 : _(BVI_BAD_MAC, "BVI L3 mac mismatch") \
100 : _(BVI_ETHERTYPE, "BVI packet with unhandled ethertype")
101 :
102 : typedef enum
103 : {
104 : #define _(sym,str) L2FLOOD_ERROR_##sym,
105 : foreach_l2flood_error
106 : #undef _
107 : L2FLOOD_N_ERROR,
108 : } l2flood_error_t;
109 :
110 : static char *l2flood_error_strings[] = {
111 : #define _(sym,string) string,
112 : foreach_l2flood_error
113 : #undef _
114 : };
115 :
116 : typedef enum
117 : {
118 : L2FLOOD_NEXT_L2_OUTPUT,
119 : L2FLOOD_NEXT_DROP,
120 : L2FLOOD_N_NEXT,
121 : } l2flood_next_t;
122 :
123 : /*
124 : * Perform flooding on one packet
125 : *
126 : * Due to the way BVI processing can modify the packet, the BVI interface
127 : * (if present) must be processed last in the replication. The member vector
128 : * is arranged so that the BVI interface is always the first element.
129 : * Flooding walks the vector in reverse.
130 : *
131 : * BVI processing causes the packet to go to L3 processing. This strips the
132 : * L2 header, which is fine because the replication infrastructure restores
133 : * it. However L3 processing can trigger larger changes to the packet. For
134 : * example, an ARP request could be turned into an ARP reply, an ICMP request
135 : * could be turned into an ICMP reply. If BVI processing is not performed
136 : * last, the modified packet would be replicated to the remaining members.
137 : */
138 4117 : VLIB_NODE_FN (l2flood_node) (vlib_main_t * vm,
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;
143 1881 : l2flood_main_t *msm = &l2flood_main;
144 1881 : u32 thread_index = vm->thread_index;
145 :
146 1881 : from = vlib_frame_vector_args (frame);
147 1881 : n_left_from = frame->n_vectors;
148 1881 : next_index = node->cached_next_index;
149 :
150 3762 : while (n_left_from > 0)
151 : {
152 : u32 n_left_to_next;
153 :
154 1881 : vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
155 :
156 8729 : 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 6848 : bi0 = from[0];
169 6848 : from += 1;
170 6848 : n_left_from -= 1;
171 6848 : next0 = L2FLOOD_NEXT_L2_OUTPUT;
172 :
173 6848 : b0 = vlib_get_buffer (vm, bi0);
174 :
175 : /* Get config for the bridge domain interface */
176 6848 : bd_config = vec_elt_at_index (l2input_main.bd_configs,
177 : vnet_buffer (b0)->l2.bd_index);
178 6848 : in_shg = vnet_buffer (b0)->l2.shg;
179 6848 : sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
180 :
181 6848 : vec_validate (msm->members[thread_index],
182 : vec_len (bd_config->members));
183 :
184 6848 : vec_reset_length (msm->members[thread_index]);
185 :
186 : /* Find first members that passes the reflection and SHG checks */
187 25097 : for (mi = bd_config->flood_count - 1; mi >= 0; mi--)
188 : {
189 18249 : member = &bd_config->members[mi];
190 18249 : if ((member->sw_if_index != sw_if_index0) &&
191 1608 : (!in_shg || (member->shg != in_shg)))
192 : {
193 11039 : vec_add1 (msm->members[thread_index], member);
194 : }
195 : }
196 :
197 6848 : n_clones = vec_len (msm->members[thread_index]);
198 :
199 6848 : if (0 == n_clones)
200 : {
201 : /* No members to flood to */
202 156 : to_next[0] = bi0;
203 156 : to_next += 1;
204 156 : n_left_to_next -= 1;
205 :
206 156 : b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS];
207 156 : vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
208 : to_next, n_left_to_next,
209 : bi0, L2FLOOD_NEXT_DROP);
210 156 : continue;
211 : }
212 6692 : else if (n_clones > 1)
213 : {
214 1663 : vec_validate (msm->clones[thread_index], n_clones);
215 :
216 : /*
217 : * the header offset needs to be large enough to incorporate
218 : * all the L3 headers that could be touched when doing BVI
219 : * processing. So take the current l2 length plus 2 * IPv6
220 : * headers (for tunnel encap)
221 : */
222 1663 : n_cloned = vlib_buffer_clone (vm, bi0,
223 1663 : msm->clones[thread_index],
224 : n_clones,
225 : VLIB_BUFFER_CLONE_HEAD_SIZE);
226 :
227 1663 : vec_set_len (msm->clones[thread_index], n_cloned);
228 :
229 1663 : if (PREDICT_FALSE (n_cloned != n_clones))
230 : {
231 0 : b0->error = node->errors[L2FLOOD_ERROR_REPL_FAIL];
232 : /* Worst-case, no clones, consume the original buf */
233 0 : if (n_cloned == 0)
234 : {
235 0 : ci0 = bi0;
236 0 : member = msm->members[thread_index][0];
237 0 : goto use_original_buffer;
238 : }
239 : }
240 :
241 : /*
242 : * for all but the last clone, these are not BVI bound
243 : */
244 6010 : for (clone0 = 0; clone0 < n_cloned - 1; clone0++)
245 : {
246 4347 : member = msm->members[thread_index][clone0];
247 4347 : ci0 = msm->clones[thread_index][clone0];
248 4347 : c0 = vlib_get_buffer (vm, ci0);
249 :
250 4347 : to_next[0] = ci0;
251 4347 : to_next += 1;
252 4347 : n_left_to_next -= 1;
253 :
254 4347 : if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
255 : (b0->flags & VLIB_BUFFER_IS_TRACED)))
256 : {
257 : ethernet_header_t *h0;
258 : l2flood_trace_t *t;
259 :
260 4325 : t = vlib_add_trace (vm, node, c0, sizeof (*t));
261 4325 : h0 = vlib_buffer_get_current (c0);
262 4325 : t->sw_if_index = sw_if_index0;
263 4325 : t->bd_index = vnet_buffer (c0)->l2.bd_index;
264 4325 : clib_memcpy_fast (t->src, h0->src_address, 6);
265 4325 : clib_memcpy_fast (t->dst, h0->dst_address, 6);
266 : }
267 :
268 : /* Do normal L2 forwarding */
269 4347 : vnet_buffer (c0)->sw_if_index[VLIB_TX] =
270 4347 : member->sw_if_index;
271 :
272 4347 : vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
273 : to_next, n_left_to_next,
274 : ci0, next0);
275 4347 : if (PREDICT_FALSE (0 == n_left_to_next))
276 : {
277 8 : vlib_put_next_frame (vm, node, next_index,
278 : n_left_to_next);
279 8 : vlib_get_next_frame (vm, node, next_index, to_next,
280 : n_left_to_next);
281 : }
282 : }
283 1663 : member = msm->members[thread_index][clone0];
284 1663 : ci0 = msm->clones[thread_index][clone0];
285 : }
286 : else
287 : {
288 : /* one clone */
289 5029 : ci0 = bi0;
290 5029 : member = msm->members[thread_index][0];
291 : }
292 :
293 6692 : use_original_buffer:
294 : /*
295 : * the last clone that might go to a BVI
296 : */
297 6692 : c0 = vlib_get_buffer (vm, ci0);
298 :
299 6692 : to_next[0] = ci0;
300 6692 : to_next += 1;
301 6692 : n_left_to_next -= 1;
302 :
303 6692 : if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
304 : (b0->flags & VLIB_BUFFER_IS_TRACED)))
305 : {
306 : ethernet_header_t *h0;
307 : l2flood_trace_t *t;
308 :
309 4408 : t = vlib_add_trace (vm, node, c0, sizeof (*t));
310 4408 : h0 = vlib_buffer_get_current (c0);
311 4408 : t->sw_if_index = sw_if_index0;
312 4408 : t->bd_index = vnet_buffer (c0)->l2.bd_index;
313 4408 : clib_memcpy_fast (t->src, h0->src_address, 6);
314 4408 : clib_memcpy_fast (t->dst, h0->dst_address, 6);
315 : }
316 : /* Forward packet to the current member */
317 6692 : if (PREDICT_FALSE (member->flags & L2_FLOOD_MEMBER_BVI))
318 : {
319 : /* Do BVI processing */
320 : u32 rc;
321 282 : rc = l2_to_bvi (vm,
322 : msm->vnet_main,
323 : c0, member->sw_if_index, &msm->l3_next, &next0);
324 :
325 282 : if (PREDICT_FALSE (rc != TO_BVI_ERR_OK))
326 : {
327 0 : if (rc == TO_BVI_ERR_BAD_MAC)
328 : {
329 0 : c0->error = node->errors[L2FLOOD_ERROR_BVI_BAD_MAC];
330 : }
331 0 : else if (rc == TO_BVI_ERR_ETHERTYPE)
332 : {
333 0 : c0->error = node->errors[L2FLOOD_ERROR_BVI_ETHERTYPE];
334 : }
335 0 : next0 = L2FLOOD_NEXT_DROP;
336 : }
337 : }
338 : else
339 : {
340 : /* Do normal L2 forwarding */
341 6410 : vnet_buffer (c0)->sw_if_index[VLIB_TX] = member->sw_if_index;
342 : }
343 :
344 6692 : vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
345 : to_next, n_left_to_next,
346 : ci0, next0);
347 6692 : if (PREDICT_FALSE (0 == n_left_to_next))
348 : {
349 6 : vlib_put_next_frame (vm, node, next_index, n_left_to_next);
350 6 : vlib_get_next_frame (vm, node, next_index,
351 : to_next, n_left_to_next);
352 : }
353 : }
354 :
355 1881 : vlib_put_next_frame (vm, node, next_index, n_left_to_next);
356 : }
357 :
358 1881 : vlib_node_increment_counter (vm, node->node_index,
359 1881 : L2FLOOD_ERROR_L2FLOOD, frame->n_vectors);
360 :
361 1881 : return frame->n_vectors;
362 : }
363 :
364 :
365 : /* *INDENT-OFF* */
366 178120 : VLIB_REGISTER_NODE (l2flood_node) = {
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 : /* *INDENT-ON* */
384 :
385 : #ifndef CLIB_MARCH_VARIANT
386 : clib_error_t *
387 559 : l2flood_init (vlib_main_t * vm)
388 : {
389 559 : l2flood_main_t *mp = &l2flood_main;
390 :
391 559 : mp->vlib_main = vm;
392 559 : mp->vnet_main = vnet_get_main ();
393 :
394 559 : vec_validate (mp->clones, vlib_num_workers ());
395 559 : vec_validate (mp->members, vlib_num_workers ());
396 :
397 : /* Initialize the feature next-node indexes */
398 559 : feat_bitmap_init_next_nodes (vm,
399 : l2flood_node.index,
400 : L2INPUT_N_FEAT,
401 : l2input_get_feat_names (),
402 559 : mp->feat_next_node_index);
403 :
404 559 : return NULL;
405 : }
406 :
407 18479 : VLIB_INIT_FUNCTION (l2flood_init);
408 :
409 :
410 :
411 : /** Add the L3 input node for this ethertype to the next nodes structure. */
412 : void
413 3917 : l2flood_register_input_type (vlib_main_t * vm,
414 : ethernet_type_t type, u32 node_index)
415 : {
416 3917 : l2flood_main_t *mp = &l2flood_main;
417 : u32 next_index;
418 :
419 3917 : next_index = vlib_node_add_next (vm, l2flood_node.index, node_index);
420 :
421 3917 : next_by_ethertype_register (&mp->l3_next, type, next_index);
422 3917 : }
423 : #endif /* CLIB_MARCH_VARIANT */
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 *
432 0 : int_flood (vlib_main_t * vm,
433 : unformat_input_t * input, vlib_cli_command_t * cmd)
434 : {
435 0 : vnet_main_t *vnm = vnet_get_main ();
436 0 : clib_error_t *error = 0;
437 : u32 sw_if_index;
438 : u32 enable;
439 :
440 0 : if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
441 : {
442 0 : error = clib_error_return (0, "unknown interface `%U'",
443 : format_unformat_error, input);
444 0 : goto done;
445 : }
446 :
447 0 : enable = 1;
448 0 : if (unformat (input, "disable"))
449 : {
450 0 : enable = 0;
451 : }
452 :
453 : /* set the interface flag */
454 0 : l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_FLOOD, enable);
455 :
456 0 : done:
457 0 : 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 272887 : 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 : */
|
