2 *------------------------------------------------------------------
3 * Copyright (c) 2017 Cisco and/or its affiliates.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *------------------------------------------------------------------
20 #include <vnet/llc/llc.h>
21 #include <vnet/snap/snap.h>
22 #include <vnet/bonding/node.h>
24 #ifndef CLIB_MARCH_VARIANT
25 bond_main_t bond_main;
26 #endif /* CLIB_MARCH_VARIANT */
28 #define foreach_bond_input_error \
30 _(IF_DOWN, "interface down") \
31 _(PASSIVE_IF, "traffic received on passive interface") \
32 _(PASS_THRU, "pass through (CDP, LLDP, slow protocols)")
36 #define _(f,s) BOND_INPUT_ERROR_##f,
37 foreach_bond_input_error
42 static char *bond_input_error_strings[] = {
44 foreach_bond_input_error
49 format_bond_input_trace (u8 * s, va_list * args)
51 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
52 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
53 bond_packet_trace_t *t = va_arg (*args, bond_packet_trace_t *);
55 s = format (s, "src %U, dst %U, %U -> %U",
56 format_ethernet_address, t->ethernet.src_address,
57 format_ethernet_address, t->ethernet.dst_address,
58 format_vnet_sw_if_index_name, vnet_get_main (),
60 format_vnet_sw_if_index_name, vnet_get_main (),
72 static_always_inline u8
73 packet_is_cdp (ethernet_header_t * eth)
78 llc = (llc_header_t *) (eth + 1);
79 snap = (snap_header_t *) (llc + 1);
81 return ((eth->type == htons (ETHERNET_TYPE_CDP)) ||
82 ((llc->src_sap == 0xAA) && (llc->control == 0x03) &&
83 (snap->protocol == htons (0x2000)) &&
84 (snap->oui[0] == 0) && (snap->oui[1] == 0) &&
85 (snap->oui[2] == 0x0C)));
89 bond_sw_if_idx_rewrite (vlib_main_t * vm, vlib_node_runtime_t * node,
90 vlib_buffer_t * b, u32 bond_sw_if_index,
91 u32 * n_rx_packets, u32 * n_rx_bytes)
93 u16 *ethertype_p, ethertype;
94 ethernet_vlan_header_t *vlan;
95 ethernet_header_t *eth = (ethernet_header_t *) vlib_buffer_get_current (b);
98 *n_rx_bytes += b->current_length;
99 ethertype = clib_mem_unaligned (ð->type, u16);
100 if (!ethernet_frame_is_tagged (ntohs (ethertype)))
102 // Let some layer2 packets pass through.
103 if (PREDICT_TRUE ((ethertype != htons (ETHERNET_TYPE_SLOW_PROTOCOLS))
104 && !packet_is_cdp (eth)
105 && (ethertype != htons (ETHERNET_TYPE_802_1_LLDP))))
107 /* Change the physical interface to bond interface */
108 vnet_buffer (b)->sw_if_index[VLIB_RX] = bond_sw_if_index;
114 vlan = (void *) (eth + 1);
115 ethertype_p = &vlan->type;
116 ethertype = clib_mem_unaligned (ethertype_p, u16);
117 if (ethertype == ntohs (ETHERNET_TYPE_VLAN))
120 ethertype_p = &vlan->type;
122 ethertype = clib_mem_unaligned (ethertype_p, u16);
123 if (PREDICT_TRUE ((ethertype != htons (ETHERNET_TYPE_SLOW_PROTOCOLS))
124 && (ethertype != htons (ETHERNET_TYPE_CDP))
125 && (ethertype != htons (ETHERNET_TYPE_802_1_LLDP))))
127 /* Change the physical interface to bond interface */
128 vnet_buffer (b)->sw_if_index[VLIB_RX] = bond_sw_if_index;
133 vlib_error_count (vm, node->node_index, BOND_INPUT_ERROR_PASS_THRU, 1);
138 bond_update_next (vlib_main_t * vm, vlib_node_runtime_t * node,
139 u32 * last_slave_sw_if_index, u32 slave_sw_if_index,
140 u32 * bond_sw_if_index, vlib_buffer_t * b,
141 u32 * next_index, vlib_error_t * error)
146 *next_index = BOND_INPUT_NEXT_DROP;
149 if (PREDICT_TRUE (*last_slave_sw_if_index == slave_sw_if_index))
152 *last_slave_sw_if_index = slave_sw_if_index;
154 sif = bond_get_slave_by_sw_if_index (slave_sw_if_index);
157 bif = bond_get_master_by_dev_instance (sif->bif_dev_instance);
160 ASSERT (vec_len (bif->slaves));
162 if (PREDICT_FALSE (bif->admin_up == 0))
164 *bond_sw_if_index = slave_sw_if_index;
165 *error = node->errors[BOND_INPUT_ERROR_IF_DOWN];
168 if (PREDICT_FALSE ((bif->mode == BOND_MODE_ACTIVE_BACKUP) &&
169 vec_len (bif->active_slaves) &&
170 (slave_sw_if_index != bif->active_slaves[0])))
172 *bond_sw_if_index = slave_sw_if_index;
173 *error = node->errors[BOND_INPUT_ERROR_PASSIVE_IF];
177 *bond_sw_if_index = bif->sw_if_index;
180 vnet_feature_next (next_index, b);
183 static_always_inline void
184 bond_update_next_x4 (vlib_buffer_t * b0, vlib_buffer_t * b1,
185 vlib_buffer_t * b2, vlib_buffer_t * b3)
187 u32 tmp0, tmp1, tmp2, tmp3;
189 tmp0 = tmp1 = tmp2 = tmp3 = BOND_INPUT_NEXT_DROP;
190 vnet_feature_next (&tmp0, b0);
191 vnet_feature_next (&tmp1, b1);
192 vnet_feature_next (&tmp2, b2);
193 vnet_feature_next (&tmp3, b3);
196 VLIB_NODE_FN (bond_input_node) (vlib_main_t * vm,
197 vlib_node_runtime_t * node,
198 vlib_frame_t * frame)
200 u16 thread_index = vm->thread_index;
202 vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
203 u32 sw_if_indices[VLIB_FRAME_SIZE], *sw_if_index;
204 u16 nexts[VLIB_FRAME_SIZE], *next;
205 u32 last_slave_sw_if_index = ~0;
206 u32 bond_sw_if_index = 0;
207 vlib_error_t error = 0;
209 u32 n_rx_bytes = 0, n_rx_packets = 0;
211 /* Vector of buffer / pkt indices we're supposed to process */
212 from = vlib_frame_vector_args (frame);
214 /* Number of buffers / pkts */
215 n_left = frame->n_vectors;
217 vlib_get_buffers (vm, from, bufs, n_left);
221 sw_if_index = sw_if_indices;
226 /* Prefetch next iteration */
227 if (PREDICT_TRUE (n_left >= 16))
229 vlib_prefetch_buffer_data (b[8], LOAD);
230 vlib_prefetch_buffer_data (b[9], LOAD);
231 vlib_prefetch_buffer_data (b[10], LOAD);
232 vlib_prefetch_buffer_data (b[11], LOAD);
234 vlib_prefetch_buffer_header (b[12], LOAD);
235 vlib_prefetch_buffer_header (b[13], LOAD);
236 vlib_prefetch_buffer_header (b[14], LOAD);
237 vlib_prefetch_buffer_header (b[15], LOAD);
240 sw_if_index[0] = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
241 sw_if_index[1] = vnet_buffer (b[1])->sw_if_index[VLIB_RX];
242 sw_if_index[2] = vnet_buffer (b[2])->sw_if_index[VLIB_RX];
243 sw_if_index[3] = vnet_buffer (b[3])->sw_if_index[VLIB_RX];
245 x |= sw_if_index[0] ^ last_slave_sw_if_index;
246 x |= sw_if_index[1] ^ last_slave_sw_if_index;
247 x |= sw_if_index[2] ^ last_slave_sw_if_index;
248 x |= sw_if_index[3] ^ last_slave_sw_if_index;
250 if (PREDICT_TRUE (x == 0))
253 * Optimize to call update_next only if there is a feature arc
254 * after bond-input. Test feature count greater than 1 because
255 * bond-input itself is a feature arc for this slave interface.
257 ASSERT ((vnet_buffer (b[0])->feature_arc_index ==
258 vnet_buffer (b[1])->feature_arc_index) &&
259 (vnet_buffer (b[0])->feature_arc_index ==
260 vnet_buffer (b[2])->feature_arc_index) &&
261 (vnet_buffer (b[0])->feature_arc_index ==
262 vnet_buffer (b[3])->feature_arc_index));
263 if (PREDICT_FALSE (vnet_get_feature_count
264 (vnet_buffer (b[0])->feature_arc_index,
265 last_slave_sw_if_index) > 1))
266 bond_update_next_x4 (b[0], b[1], b[2], b[3]);
268 next[0] = next[1] = next[2] = next[3] = next_index;
269 if (next_index == BOND_INPUT_NEXT_DROP)
278 bond_sw_if_idx_rewrite (vm, node, b[0], bond_sw_if_index,
279 &n_rx_packets, &n_rx_bytes);
280 bond_sw_if_idx_rewrite (vm, node, b[1], bond_sw_if_index,
281 &n_rx_packets, &n_rx_bytes);
282 bond_sw_if_idx_rewrite (vm, node, b[2], bond_sw_if_index,
283 &n_rx_packets, &n_rx_bytes);
284 bond_sw_if_idx_rewrite (vm, node, b[3], bond_sw_if_index,
285 &n_rx_packets, &n_rx_bytes);
290 bond_update_next (vm, node, &last_slave_sw_if_index, sw_if_index[0],
291 &bond_sw_if_index, b[0], &next_index, &error);
292 next[0] = next_index;
293 if (next_index == BOND_INPUT_NEXT_DROP)
296 bond_sw_if_idx_rewrite (vm, node, b[0], bond_sw_if_index,
297 &n_rx_packets, &n_rx_bytes);
299 bond_update_next (vm, node, &last_slave_sw_if_index, sw_if_index[1],
300 &bond_sw_if_index, b[1], &next_index, &error);
301 next[1] = next_index;
302 if (next_index == BOND_INPUT_NEXT_DROP)
305 bond_sw_if_idx_rewrite (vm, node, b[1], bond_sw_if_index,
306 &n_rx_packets, &n_rx_bytes);
308 bond_update_next (vm, node, &last_slave_sw_if_index, sw_if_index[2],
309 &bond_sw_if_index, b[2], &next_index, &error);
310 next[2] = next_index;
311 if (next_index == BOND_INPUT_NEXT_DROP)
314 bond_sw_if_idx_rewrite (vm, node, b[2], bond_sw_if_index,
315 &n_rx_packets, &n_rx_bytes);
317 bond_update_next (vm, node, &last_slave_sw_if_index, sw_if_index[3],
318 &bond_sw_if_index, b[3], &next_index, &error);
319 next[3] = next_index;
320 if (next_index == BOND_INPUT_NEXT_DROP)
323 bond_sw_if_idx_rewrite (vm, node, b[3], bond_sw_if_index,
324 &n_rx_packets, &n_rx_bytes);
327 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
328 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
329 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]);
330 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]);
341 sw_if_index[0] = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
342 bond_update_next (vm, node, &last_slave_sw_if_index, sw_if_index[0],
343 &bond_sw_if_index, b[0], &next_index, &error);
344 next[0] = next_index;
345 if (next_index == BOND_INPUT_NEXT_DROP)
348 bond_sw_if_idx_rewrite (vm, node, b[0], bond_sw_if_index,
349 &n_rx_packets, &n_rx_bytes);
351 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
360 if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
362 n_left = frame->n_vectors; /* number of packets to process */
364 sw_if_index = sw_if_indices;
365 bond_packet_trace_t *t0;
369 if (PREDICT_FALSE (b[0]->flags & VLIB_BUFFER_IS_TRACED))
371 t0 = vlib_add_trace (vm, node, b[0], sizeof (*t0));
372 t0->sw_if_index = sw_if_index[0];
373 clib_memcpy_fast (&t0->ethernet, vlib_buffer_get_current (b[0]),
374 sizeof (ethernet_header_t));
375 t0->bond_sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
384 /* increase rx counters */
385 vlib_increment_combined_counter
386 (vnet_main.interface_main.combined_sw_if_counters +
387 VNET_INTERFACE_COUNTER_RX, thread_index, bond_sw_if_index, n_rx_packets,
390 vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
391 vlib_node_increment_counter (vm, bond_input_node.index,
392 BOND_INPUT_ERROR_NONE, frame->n_vectors);
394 return frame->n_vectors;
397 static clib_error_t *
398 bond_input_init (vlib_main_t * vm)
404 VLIB_REGISTER_NODE (bond_input_node) = {
405 .name = "bond-input",
406 .vector_size = sizeof (u32),
407 .format_buffer = format_ethernet_header_with_length,
408 .format_trace = format_bond_input_trace,
409 .type = VLIB_NODE_TYPE_INTERNAL,
410 .n_errors = BOND_INPUT_N_ERROR,
411 .error_strings = bond_input_error_strings,
412 .n_next_nodes = BOND_INPUT_N_NEXT,
415 [BOND_INPUT_NEXT_DROP] = "error-drop"
419 VLIB_INIT_FUNCTION (bond_input_init);
421 VNET_FEATURE_INIT (bond_input, static) =
423 .arc_name = "device-input",
424 .node_name = "bond-input",
425 .runs_before = VNET_FEATURES ("ethernet-input"),
429 static clib_error_t *
430 bond_sw_interface_up_down (vnet_main_t * vnm, u32 sw_if_index, u32 flags)
432 bond_main_t *bm = &bond_main;
434 vlib_main_t *vm = bm->vlib_main;
436 sif = bond_get_slave_by_sw_if_index (sw_if_index);
439 if (sif->lacp_enabled)
442 /* port_enabled is both admin up and hw link up */
443 sif->port_enabled = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) &&
444 vnet_sw_interface_is_link_up (vnm, sw_if_index));
445 if (sif->port_enabled == 0)
446 bond_disable_collecting_distributing (vm, sif);
448 bond_enable_collecting_distributing (vm, sif);
454 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (bond_sw_interface_up_down);
456 static clib_error_t *
457 bond_hw_interface_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
459 bond_main_t *bm = &bond_main;
461 vnet_sw_interface_t *sw;
462 vlib_main_t *vm = bm->vlib_main;
464 sw = vnet_get_hw_sw_interface (vnm, hw_if_index);
465 sif = bond_get_slave_by_sw_if_index (sw->sw_if_index);
468 if (sif->lacp_enabled)
471 /* port_enabled is both admin up and hw link up */
472 sif->port_enabled = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) &&
473 vnet_sw_interface_is_admin_up (vnm,
475 if (sif->port_enabled == 0)
476 bond_disable_collecting_distributing (vm, sif);
478 bond_enable_collecting_distributing (vm, sif);
484 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION (bond_hw_interface_up_down);
487 * fd.io coding-style-patch-verification: ON
490 * eval: (c-set-style "gnu")