Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 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> |
John Lo | 0f85333 | 2017-11-10 12:24:32 -0500 | [diff] [blame] | 26 | #include <vnet/fib/fib_node.h> |
| 27 | #include <vnet/ethernet/arp_packet.h> |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 28 | #include <vlib/cli.h> |
| 29 | #include <vnet/l2/l2_input.h> |
| 30 | #include <vnet/l2/l2_output.h> |
| 31 | #include <vnet/l2/feat_bitmap.h> |
| 32 | #include <vnet/l2/l2_bvi.h> |
| 33 | #include <vnet/l2/l2_fib.h> |
John Lo | da1f2c7 | 2017-03-24 20:11:15 -0400 | [diff] [blame] | 34 | #include <vnet/l2/l2_bd.h> |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 35 | |
| 36 | #include <vppinfra/error.h> |
| 37 | #include <vppinfra/hash.h> |
| 38 | #include <vppinfra/cache.h> |
| 39 | |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 40 | /** |
| 41 | * @file |
| 42 | * @brief Interface Input Mode (Layer 2 Cross-Connect or Bridge / Layer 3). |
| 43 | * |
| 44 | * This file contains the CLI Commands that modify the input mode of an |
| 45 | * interface. For interfaces in a Layer 2 cross-connect, all packets |
| 46 | * received on one interface will be transmitted to the other. For |
| 47 | * interfaces in a bridge-domain, packets will be forwarded to other |
| 48 | * interfaces in the same bridge-domain based on destination mac address. |
| 49 | * For interfaces in Layer 3 mode, the packets will be routed. |
| 50 | */ |
Pierre Pfister | e389de7 | 2016-03-09 15:56:31 +0000 | [diff] [blame] | 51 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 52 | /* Feature graph node names */ |
| 53 | static char *l2input_feat_names[] = { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 54 | #define _(sym,name) name, |
| 55 | foreach_l2input_feat |
| 56 | #undef _ |
| 57 | }; |
| 58 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 59 | char ** |
| 60 | l2input_get_feat_names (void) |
| 61 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 62 | return l2input_feat_names; |
| 63 | } |
| 64 | |
Eyal Bari | 942402b | 2017-07-26 11:57:04 +0300 | [diff] [blame] | 65 | u8 * |
| 66 | format_l2_input_features (u8 * s, va_list * args) |
| 67 | { |
| 68 | static char *display_names[] = { |
| 69 | #define _(sym,name) #sym, |
| 70 | foreach_l2input_feat |
| 71 | #undef _ |
| 72 | }; |
| 73 | u32 feature_bitmap = va_arg (*args, u32); |
Neale Ranns | 5d9df1d | 2018-11-09 08:19:27 -0800 | [diff] [blame] | 74 | u32 verbose = va_arg (*args, u32); |
Eyal Bari | 942402b | 2017-07-26 11:57:04 +0300 | [diff] [blame] | 75 | |
| 76 | if (feature_bitmap == 0) |
| 77 | { |
| 78 | s = format (s, " none configured"); |
| 79 | return s; |
| 80 | } |
| 81 | |
| 82 | feature_bitmap &= ~L2INPUT_FEAT_DROP; /* Not a feature */ |
| 83 | int i; |
| 84 | for (i = L2INPUT_N_FEAT; i >= 0; i--) |
Neale Ranns | 5d9df1d | 2018-11-09 08:19:27 -0800 | [diff] [blame] | 85 | { |
| 86 | if (feature_bitmap & (1 << i)) |
| 87 | { |
| 88 | if (verbose) |
| 89 | s = format (s, "%17s (%s)\n", |
| 90 | display_names[i], l2input_feat_names[i]); |
| 91 | else |
| 92 | s = format (s, "%s ", l2input_feat_names[i]); |
| 93 | } |
| 94 | } |
Eyal Bari | 942402b | 2017-07-26 11:57:04 +0300 | [diff] [blame] | 95 | return s; |
| 96 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 97 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 98 | typedef struct |
| 99 | { |
| 100 | /* per-pkt trace data */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 101 | u8 src[6]; |
| 102 | u8 dst[6]; |
| 103 | u32 next_index; |
| 104 | u32 sw_if_index; |
| 105 | } l2input_trace_t; |
| 106 | |
| 107 | /* packet trace format function */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 108 | static u8 * |
| 109 | format_l2input_trace (u8 * s, va_list * args) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 110 | { |
| 111 | CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); |
| 112 | CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 113 | l2input_trace_t *t = va_arg (*args, l2input_trace_t *); |
| 114 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 115 | s = format (s, "l2-input: sw_if_index %d dst %U src %U", |
| 116 | t->sw_if_index, |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 117 | format_ethernet_address, t->dst, |
| 118 | format_ethernet_address, t->src); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 119 | return s; |
| 120 | } |
| 121 | |
| 122 | l2input_main_t l2input_main; |
| 123 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 124 | #define foreach_l2input_error \ |
| 125 | _(L2INPUT, "L2 input packets") \ |
| 126 | _(DROP, "L2 input drops") |
| 127 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 128 | typedef enum |
| 129 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 130 | #define _(sym,str) L2INPUT_ERROR_##sym, |
| 131 | foreach_l2input_error |
| 132 | #undef _ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 133 | L2INPUT_N_ERROR, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 134 | } l2input_error_t; |
| 135 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 136 | static char *l2input_error_strings[] = { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 137 | #define _(sym,string) string, |
| 138 | foreach_l2input_error |
| 139 | #undef _ |
| 140 | }; |
| 141 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 142 | typedef enum |
| 143 | { /* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 144 | L2INPUT_NEXT_LEARN, |
| 145 | L2INPUT_NEXT_FWD, |
| 146 | L2INPUT_NEXT_DROP, |
| 147 | L2INPUT_N_NEXT, |
| 148 | } l2input_next_t; |
| 149 | |
| 150 | |
| 151 | static_always_inline void |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 152 | classify_and_dispatch (l2input_main_t * msm, vlib_buffer_t * b0, u32 * next0) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 153 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 154 | /* |
| 155 | * Load L2 input feature struct |
| 156 | * Load bridge domain struct |
| 157 | * Parse ethernet header to determine unicast/mcast/broadcast |
| 158 | * take L2 input stat |
| 159 | * classify packet as IP/UDP/TCP, control, other |
| 160 | * mask feature bitmap |
| 161 | * go to first node in bitmap |
| 162 | * Later: optimize VTM |
| 163 | * |
| 164 | * For L2XC, |
| 165 | * set tx sw-if-handle |
| 166 | */ |
| 167 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 168 | u32 feat_mask = ~0; |
| 169 | u32 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; |
| 170 | ethernet_header_t *h0 = vlib_buffer_get_current (b0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 171 | |
Damjan Marion | fc63973 | 2016-12-19 13:56:51 +0100 | [diff] [blame] | 172 | /* Get config for the input interface */ |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 173 | l2_input_config_t *config = vec_elt_at_index (msm->configs, sw_if_index0); |
Damjan Marion | fc63973 | 2016-12-19 13:56:51 +0100 | [diff] [blame] | 174 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 175 | /* Save split horizon group */ |
| 176 | vnet_buffer (b0)->l2.shg = config->shg; |
| 177 | |
| 178 | /* determine layer2 kind for stat and mask */ |
| 179 | if (PREDICT_FALSE (ethernet_address_cast (h0->dst_address))) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 180 | { |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 181 | u8 *l3h0 = (u8 *) h0 + vnet_buffer (b0)->l2.l2_len; |
Eyal Bari | 109139e | 2018-03-28 15:25:28 +0300 | [diff] [blame] | 182 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 183 | #define get_u16(addr) ( *((u16 *)(addr)) ) |
| 184 | u16 ethertype = clib_net_to_host_u16 (get_u16 (l3h0 - 2)); |
| 185 | u8 protocol = ((ip6_header_t *) l3h0)->protocol; |
Neale Ranns | b123255 | 2018-09-12 09:42:50 -0400 | [diff] [blame] | 186 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 187 | /* Disable bridge forwarding (flooding will execute instead if not xconnect) */ |
| 188 | feat_mask &= ~(L2INPUT_FEAT_FWD | |
Neale Ranns | d29cc88 | 2018-10-10 15:55:01 +0000 | [diff] [blame] | 189 | L2INPUT_FEAT_UU_FLOOD | |
| 190 | L2INPUT_FEAT_UU_FWD | L2INPUT_FEAT_GBP_FWD); |
Neale Ranns | b123255 | 2018-09-12 09:42:50 -0400 | [diff] [blame] | 191 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 192 | /* Disable ARP-term for non-ARP and non-ICMP6 packet */ |
| 193 | if (ethertype != ETHERNET_TYPE_ARP && |
| 194 | (ethertype != ETHERNET_TYPE_IP6 || protocol != IP_PROTOCOL_ICMP6)) |
| 195 | feat_mask &= ~(L2INPUT_FEAT_ARP_TERM); |
Neale Ranns | b123255 | 2018-09-12 09:42:50 -0400 | [diff] [blame] | 196 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 197 | /* |
| 198 | * For packet from BVI - set SHG of ARP request or ICMPv6 neighbor |
| 199 | * solicitation packet from BVI to 0 so it can also flood to VXLAN |
| 200 | * tunnels or other ports with the same SHG as that of the BVI. |
| 201 | */ |
| 202 | else if (PREDICT_FALSE (vnet_buffer (b0)->sw_if_index[VLIB_TX] == |
| 203 | L2INPUT_BVI)) |
Neale Ranns | b123255 | 2018-09-12 09:42:50 -0400 | [diff] [blame] | 204 | { |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 205 | if (ethertype == ETHERNET_TYPE_ARP) |
| 206 | { |
| 207 | ethernet_arp_header_t *arp0 = (ethernet_arp_header_t *) l3h0; |
| 208 | if (arp0->opcode == |
| 209 | clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request)) |
| 210 | vnet_buffer (b0)->l2.shg = 0; |
| 211 | } |
| 212 | else /* must be ICMPv6 */ |
| 213 | { |
| 214 | ip6_header_t *iph0 = (ip6_header_t *) l3h0; |
| 215 | icmp6_neighbor_solicitation_or_advertisement_header_t *ndh0; |
| 216 | ndh0 = ip6_next_header (iph0); |
| 217 | if (ndh0->icmp.type == ICMP6_neighbor_solicitation) |
| 218 | vnet_buffer (b0)->l2.shg = 0; |
| 219 | } |
Neale Ranns | b123255 | 2018-09-12 09:42:50 -0400 | [diff] [blame] | 220 | } |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 221 | } |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 222 | else |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 223 | { |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 224 | /* |
| 225 | * For packet from BVI - set SHG of unicast packet from BVI to 0 so it |
| 226 | * is not dropped on output to VXLAN tunnels or other ports with the |
| 227 | * same SHG as that of the BVI. |
| 228 | */ |
| 229 | if (PREDICT_FALSE (vnet_buffer (b0)->sw_if_index[VLIB_TX] == |
| 230 | L2INPUT_BVI)) |
| 231 | vnet_buffer (b0)->l2.shg = 0; |
Damjan Marion | fc63973 | 2016-12-19 13:56:51 +0100 | [diff] [blame] | 232 | } |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 233 | |
| 234 | |
| 235 | if (config->bridge) |
| 236 | { |
| 237 | /* Do bridge-domain processing */ |
| 238 | u16 bd_index0 = config->bd_index; |
| 239 | /* save BD ID for next feature graph nodes */ |
| 240 | vnet_buffer (b0)->l2.bd_index = bd_index0; |
| 241 | |
| 242 | /* Get config for the bridge domain interface */ |
| 243 | l2_bridge_domain_t *bd_config = |
| 244 | vec_elt_at_index (msm->bd_configs, bd_index0); |
| 245 | |
| 246 | /* Save bridge domain and interface seq_num */ |
| 247 | /* *INDENT-OFF* */ |
| 248 | l2fib_seq_num_t sn = { |
| 249 | .swif = *l2fib_swif_seq_num(sw_if_index0), |
| 250 | .bd = bd_config->seq_num, |
| 251 | }; |
| 252 | /* *INDENT-ON* */ |
| 253 | vnet_buffer (b0)->l2.l2fib_sn = sn.as_u16;; |
| 254 | vnet_buffer (b0)->l2.bd_age = bd_config->mac_age; |
| 255 | |
| 256 | /* |
| 257 | * Process bridge domain feature enables. |
| 258 | * To perform learning/flooding/forwarding, the corresponding bit |
| 259 | * must be enabled in both the input interface config and in the |
| 260 | * bridge domain config. In the bd_bitmap, bits for features other |
| 261 | * than learning/flooding/forwarding should always be set. |
| 262 | */ |
| 263 | feat_mask = feat_mask & bd_config->feature_bitmap; |
| 264 | } |
| 265 | else if (config->xconnect) |
| 266 | { |
| 267 | /* Set the output interface */ |
| 268 | vnet_buffer (b0)->sw_if_index[VLIB_TX] = config->output_sw_if_index; |
| 269 | } |
| 270 | else |
| 271 | feat_mask = L2INPUT_FEAT_DROP; |
| 272 | |
| 273 | /* mask out features from bitmap using packet type and bd config */ |
| 274 | u32 feature_bitmap = config->feature_bitmap & feat_mask; |
| 275 | |
| 276 | /* save for next feature graph nodes */ |
| 277 | vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap; |
| 278 | |
| 279 | /* Determine the next node */ |
| 280 | *next0 = feat_bitmap_get_next_node_index (msm->feat_next_node_index, |
| 281 | feature_bitmap); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 282 | } |
| 283 | |
Dave Barach | 681abe4 | 2017-02-15 09:01:01 -0500 | [diff] [blame] | 284 | static_always_inline uword |
| 285 | l2input_node_inline (vlib_main_t * vm, |
| 286 | vlib_node_runtime_t * node, vlib_frame_t * frame, |
| 287 | int do_trace) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 288 | { |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 289 | u32 n_left_from, *from, *to_next; |
| 290 | l2input_next_t next_index; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 291 | l2input_main_t *msm = &l2input_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 292 | |
| 293 | from = vlib_frame_vector_args (frame); |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 294 | n_left_from = frame->n_vectors; /* number of packets to process */ |
| 295 | next_index = node->cached_next_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 296 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 297 | while (n_left_from > 0) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 298 | { |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 299 | u32 n_left_to_next; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 300 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 301 | /* get space to enqueue frame to graph node "next_index" */ |
| 302 | vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 303 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 304 | while (n_left_from >= 8 && n_left_to_next >= 4) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 305 | { |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 306 | u32 bi0, bi1, bi2, bi3; |
| 307 | vlib_buffer_t *b0, *b1, *b2, *b3; |
| 308 | u32 next0, next1, next2, next3; |
| 309 | u32 sw_if_index0, sw_if_index1, sw_if_index2, sw_if_index3; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 310 | |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 311 | /* Prefetch next iteration. */ |
| 312 | { |
| 313 | vlib_buffer_t *p4, *p5, *p6, *p7; |
| 314 | |
| 315 | p4 = vlib_get_buffer (vm, from[4]); |
| 316 | p5 = vlib_get_buffer (vm, from[5]); |
| 317 | p6 = vlib_get_buffer (vm, from[6]); |
| 318 | p7 = vlib_get_buffer (vm, from[7]); |
| 319 | |
| 320 | /* Prefetch the buffer header and packet for the N+2 loop iteration */ |
| 321 | vlib_prefetch_buffer_header (p4, LOAD); |
| 322 | vlib_prefetch_buffer_header (p5, LOAD); |
| 323 | vlib_prefetch_buffer_header (p6, LOAD); |
| 324 | vlib_prefetch_buffer_header (p7, LOAD); |
| 325 | |
| 326 | CLIB_PREFETCH (p4->data, CLIB_CACHE_LINE_BYTES, STORE); |
| 327 | CLIB_PREFETCH (p5->data, CLIB_CACHE_LINE_BYTES, STORE); |
| 328 | CLIB_PREFETCH (p6->data, CLIB_CACHE_LINE_BYTES, STORE); |
| 329 | CLIB_PREFETCH (p7->data, CLIB_CACHE_LINE_BYTES, STORE); |
| 330 | |
| 331 | /* |
| 332 | * Don't bother prefetching the bridge-domain config (which |
| 333 | * depends on the input config above). Only a small number of |
| 334 | * bridge domains are expected. Plus the structure is small |
| 335 | * and several fit in a cache line. |
| 336 | */ |
| 337 | } |
| 338 | |
| 339 | /* speculatively enqueue b0 and b1 to the current next frame */ |
| 340 | /* bi is "buffer index", b is pointer to the buffer */ |
| 341 | to_next[0] = bi0 = from[0]; |
| 342 | to_next[1] = bi1 = from[1]; |
| 343 | to_next[2] = bi2 = from[2]; |
| 344 | to_next[3] = bi3 = from[3]; |
| 345 | from += 4; |
| 346 | to_next += 4; |
| 347 | n_left_from -= 4; |
| 348 | n_left_to_next -= 4; |
| 349 | |
| 350 | b0 = vlib_get_buffer (vm, bi0); |
| 351 | b1 = vlib_get_buffer (vm, bi1); |
| 352 | b2 = vlib_get_buffer (vm, bi2); |
| 353 | b3 = vlib_get_buffer (vm, bi3); |
| 354 | |
| 355 | if (do_trace) |
| 356 | { |
| 357 | /* RX interface handles */ |
| 358 | sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; |
| 359 | sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; |
| 360 | sw_if_index2 = vnet_buffer (b2)->sw_if_index[VLIB_RX]; |
| 361 | sw_if_index3 = vnet_buffer (b3)->sw_if_index[VLIB_RX]; |
| 362 | |
| 363 | if (b0->flags & VLIB_BUFFER_IS_TRACED) |
| 364 | { |
| 365 | ethernet_header_t *h0 = vlib_buffer_get_current (b0); |
| 366 | l2input_trace_t *t = |
| 367 | vlib_add_trace (vm, node, b0, sizeof (*t)); |
| 368 | t->sw_if_index = sw_if_index0; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame^] | 369 | clib_memcpy_fast (t->src, h0->src_address, 6); |
| 370 | clib_memcpy_fast (t->dst, h0->dst_address, 6); |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 371 | } |
| 372 | if (b1->flags & VLIB_BUFFER_IS_TRACED) |
| 373 | { |
| 374 | ethernet_header_t *h1 = vlib_buffer_get_current (b1); |
| 375 | l2input_trace_t *t = |
| 376 | vlib_add_trace (vm, node, b1, sizeof (*t)); |
| 377 | t->sw_if_index = sw_if_index1; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame^] | 378 | clib_memcpy_fast (t->src, h1->src_address, 6); |
| 379 | clib_memcpy_fast (t->dst, h1->dst_address, 6); |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 380 | } |
| 381 | if (b2->flags & VLIB_BUFFER_IS_TRACED) |
| 382 | { |
| 383 | ethernet_header_t *h2 = vlib_buffer_get_current (b2); |
| 384 | l2input_trace_t *t = |
| 385 | vlib_add_trace (vm, node, b2, sizeof (*t)); |
| 386 | t->sw_if_index = sw_if_index2; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame^] | 387 | clib_memcpy_fast (t->src, h2->src_address, 6); |
| 388 | clib_memcpy_fast (t->dst, h2->dst_address, 6); |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 389 | } |
| 390 | if (b3->flags & VLIB_BUFFER_IS_TRACED) |
| 391 | { |
| 392 | ethernet_header_t *h3 = vlib_buffer_get_current (b3); |
| 393 | l2input_trace_t *t = |
| 394 | vlib_add_trace (vm, node, b3, sizeof (*t)); |
| 395 | t->sw_if_index = sw_if_index3; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame^] | 396 | clib_memcpy_fast (t->src, h3->src_address, 6); |
| 397 | clib_memcpy_fast (t->dst, h3->dst_address, 6); |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 398 | } |
| 399 | } |
| 400 | |
| 401 | classify_and_dispatch (msm, b0, &next0); |
| 402 | classify_and_dispatch (msm, b1, &next1); |
| 403 | classify_and_dispatch (msm, b2, &next2); |
| 404 | classify_and_dispatch (msm, b3, &next3); |
| 405 | |
| 406 | /* verify speculative enqueues, maybe switch current next frame */ |
| 407 | /* if next0==next1==next_index then nothing special needs to be done */ |
| 408 | vlib_validate_buffer_enqueue_x4 (vm, node, next_index, |
| 409 | to_next, n_left_to_next, |
| 410 | bi0, bi1, bi2, bi3, |
| 411 | next0, next1, next2, next3); |
| 412 | } |
| 413 | |
| 414 | while (n_left_from > 0 && n_left_to_next > 0) |
| 415 | { |
| 416 | u32 bi0; |
| 417 | vlib_buffer_t *b0; |
| 418 | u32 next0; |
| 419 | u32 sw_if_index0; |
| 420 | |
| 421 | /* speculatively enqueue b0 to the current next frame */ |
| 422 | bi0 = from[0]; |
| 423 | to_next[0] = bi0; |
| 424 | from += 1; |
| 425 | to_next += 1; |
| 426 | n_left_from -= 1; |
| 427 | n_left_to_next -= 1; |
| 428 | |
| 429 | b0 = vlib_get_buffer (vm, bi0); |
| 430 | |
| 431 | if (do_trace && PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) |
| 432 | { |
| 433 | ethernet_header_t *h0 = vlib_buffer_get_current (b0); |
| 434 | l2input_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); |
| 435 | sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; |
| 436 | t->sw_if_index = sw_if_index0; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame^] | 437 | clib_memcpy_fast (t->src, h0->src_address, 6); |
| 438 | clib_memcpy_fast (t->dst, h0->dst_address, 6); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 439 | } |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 440 | |
| 441 | classify_and_dispatch (msm, b0, &next0); |
| 442 | |
| 443 | /* verify speculative enqueue, maybe switch current next frame */ |
| 444 | vlib_validate_buffer_enqueue_x1 (vm, node, next_index, |
| 445 | to_next, n_left_to_next, |
| 446 | bi0, next0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 447 | } |
John Lo | 1fc44b6 | 2018-09-13 22:10:25 +0000 | [diff] [blame] | 448 | |
| 449 | vlib_put_next_frame (vm, node, next_index, n_left_to_next); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 450 | } |
| 451 | |
Eyal Bari | 109139e | 2018-03-28 15:25:28 +0300 | [diff] [blame] | 452 | vlib_node_increment_counter (vm, l2input_node.index, |
| 453 | L2INPUT_ERROR_L2INPUT, frame->n_vectors); |
| 454 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 455 | return frame->n_vectors; |
| 456 | } |
| 457 | |
Dave Barach | 681abe4 | 2017-02-15 09:01:01 -0500 | [diff] [blame] | 458 | static uword |
| 459 | l2input_node_fn (vlib_main_t * vm, |
| 460 | vlib_node_runtime_t * node, vlib_frame_t * frame) |
| 461 | { |
| 462 | if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) |
| 463 | return l2input_node_inline (vm, node, frame, 1 /* do_trace */ ); |
| 464 | return l2input_node_inline (vm, node, frame, 0 /* do_trace */ ); |
| 465 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 466 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 467 | /* *INDENT-OFF* */ |
John Lo | 405e41b | 2016-04-23 15:14:12 -0400 | [diff] [blame] | 468 | VLIB_REGISTER_NODE (l2input_node) = { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 469 | .function = l2input_node_fn, |
| 470 | .name = "l2-input", |
| 471 | .vector_size = sizeof (u32), |
| 472 | .format_trace = format_l2input_trace, |
John Lo | 2d34374 | 2016-01-19 17:27:17 -0500 | [diff] [blame] | 473 | .format_buffer = format_ethernet_header_with_length, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 474 | .type = VLIB_NODE_TYPE_INTERNAL, |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 475 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 476 | .n_errors = ARRAY_LEN(l2input_error_strings), |
| 477 | .error_strings = l2input_error_strings, |
| 478 | |
| 479 | .n_next_nodes = L2INPUT_N_NEXT, |
| 480 | |
| 481 | /* edit / add dispositions here */ |
| 482 | .next_nodes = { |
| 483 | [L2INPUT_NEXT_LEARN] = "l2-learn", |
| 484 | [L2INPUT_NEXT_FWD] = "l2-fwd", |
| 485 | [L2INPUT_NEXT_DROP] = "error-drop", |
| 486 | }, |
| 487 | }; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 488 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 489 | |
Damjan Marion | 1c80e83 | 2016-05-11 23:07:18 +0200 | [diff] [blame] | 490 | VLIB_NODE_FUNCTION_MULTIARCH (l2input_node, l2input_node_fn) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 491 | clib_error_t *l2input_init (vlib_main_t * vm) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 492 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 493 | l2input_main_t *mp = &l2input_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 494 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 495 | mp->vlib_main = vm; |
| 496 | mp->vnet_main = vnet_get_main (); |
| 497 | |
| 498 | /* Get packets RX'd from L2 interfaces */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 499 | ethernet_register_l2_input (vm, l2input_node.index); |
| 500 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 501 | /* Create the config vector */ |
| 502 | vec_validate (mp->configs, 100); |
| 503 | /* create 100 sw interface entries and zero them */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 504 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 505 | /* Initialize the feature next-node indexes */ |
| 506 | feat_bitmap_init_next_nodes (vm, |
| 507 | l2input_node.index, |
| 508 | L2INPUT_N_FEAT, |
| 509 | l2input_get_feat_names (), |
| 510 | mp->feat_next_node_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 511 | |
| 512 | return 0; |
| 513 | } |
| 514 | |
| 515 | VLIB_INIT_FUNCTION (l2input_init); |
| 516 | |
| 517 | |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 518 | /** Get a pointer to the config for the given interface. */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 519 | l2_input_config_t * |
| 520 | l2input_intf_config (u32 sw_if_index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 521 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 522 | l2input_main_t *mp = &l2input_main; |
| 523 | |
| 524 | vec_validate (mp->configs, sw_if_index); |
| 525 | return vec_elt_at_index (mp->configs, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 526 | } |
| 527 | |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 528 | /** Enable (or disable) the feature in the bitmap for the given interface. */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 529 | u32 |
Neale Ranns | a117958 | 2018-10-24 02:31:51 -0700 | [diff] [blame] | 530 | l2input_intf_bitmap_enable (u32 sw_if_index, |
| 531 | l2input_feat_masks_t feature_bitmap, u32 enable) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 532 | { |
Eyal Bari | afc47aa | 2017-04-20 14:45:17 +0300 | [diff] [blame] | 533 | l2_input_config_t *config = l2input_intf_config (sw_if_index); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 534 | |
| 535 | if (enable) |
Eyal Bari | afc47aa | 2017-04-20 14:45:17 +0300 | [diff] [blame] | 536 | config->feature_bitmap |= feature_bitmap; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 537 | else |
Eyal Bari | afc47aa | 2017-04-20 14:45:17 +0300 | [diff] [blame] | 538 | config->feature_bitmap &= ~feature_bitmap; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 539 | |
| 540 | return config->feature_bitmap; |
| 541 | } |
| 542 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 543 | u32 |
| 544 | l2input_set_bridge_features (u32 bd_index, u32 feat_mask, u32 feat_value) |
Pierre Pfister | d6f5b96 | 2016-03-21 16:17:52 +0000 | [diff] [blame] | 545 | { |
Eyal Bari | afc47aa | 2017-04-20 14:45:17 +0300 | [diff] [blame] | 546 | l2_bridge_domain_t *bd_config = l2input_bd_config (bd_index);; |
Pierre Pfister | d6f5b96 | 2016-03-21 16:17:52 +0000 | [diff] [blame] | 547 | bd_validate (bd_config); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 548 | bd_config->feature_bitmap = |
| 549 | (bd_config->feature_bitmap & ~feat_mask) | feat_value; |
Pierre Pfister | d6f5b96 | 2016-03-21 16:17:52 +0000 | [diff] [blame] | 550 | return bd_config->feature_bitmap; |
| 551 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 552 | |
Neale Ranns | 3b81a1e | 2018-09-06 09:50:26 -0700 | [diff] [blame] | 553 | void |
| 554 | l2input_interface_mac_change (u32 sw_if_index, |
| 555 | const u8 * old_address, const u8 * new_address) |
| 556 | { |
| 557 | /* check if the sw_if_index passed is a BVI in a BD */ |
| 558 | l2_input_config_t *intf_config; |
| 559 | |
| 560 | intf_config = l2input_intf_config (sw_if_index); |
| 561 | |
| 562 | if (intf_config->bridge && intf_config->bvi) |
| 563 | { |
| 564 | /* delete and re-add l2fib entry for the bvi interface */ |
| 565 | l2fib_del_entry (old_address, intf_config->bd_index, sw_if_index); |
| 566 | l2fib_add_entry (new_address, |
| 567 | intf_config->bd_index, |
| 568 | sw_if_index, |
| 569 | L2FIB_ENTRY_RESULT_FLAG_BVI | |
| 570 | L2FIB_ENTRY_RESULT_FLAG_STATIC); |
| 571 | } |
| 572 | } |
| 573 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 574 | /** |
| 575 | * Set the subinterface to run in l2 or l3 mode. |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 576 | * For L3 mode, just the sw_if_index is specified. |
| 577 | * For bridged mode, the bd id and bvi flag are also specified. |
| 578 | * For xconnect mode, the peer sw_if_index is also specified. |
| 579 | * Return 0 if ok, or non-0 if there was an error. |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 580 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 581 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 582 | u32 |
John Lo | 7100b9c | 2017-02-28 13:10:52 -0500 | [diff] [blame] | 583 | set_int_l2_mode (vlib_main_t * vm, vnet_main_t * vnet_main, /* */ |
| 584 | u32 mode, /* One of L2 modes or back to L3 mode */ |
| 585 | u32 sw_if_index, /* sw interface index */ |
| 586 | u32 bd_index, /* for bridged interface */ |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 587 | l2_bd_port_type_t port_type, /* port_type */ |
John Lo | 7100b9c | 2017-02-28 13:10:52 -0500 | [diff] [blame] | 588 | u32 shg, /* the bridged interface split horizon group */ |
| 589 | u32 xc_sw_if_index) /* peer interface for xconnect */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 590 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 591 | l2input_main_t *mp = &l2input_main; |
| 592 | l2output_main_t *l2om = &l2output_main; |
| 593 | vnet_main_t *vnm = vnet_get_main (); |
| 594 | vnet_hw_interface_t *hi; |
| 595 | l2_output_config_t *out_config; |
| 596 | l2_input_config_t *config; |
| 597 | l2_bridge_domain_t *bd_config; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 598 | i32 l2_if_adjust = 0; |
Steven | 4f8863b | 2018-04-12 19:36:19 -0700 | [diff] [blame] | 599 | vnet_device_class_t *dev_class; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 600 | |
| 601 | hi = vnet_get_sup_hw_interface (vnet_main, sw_if_index); |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 602 | config = l2input_intf_config (sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 603 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 604 | if (config->bridge) |
| 605 | { |
| 606 | /* Interface is already in bridge mode. Undo the existing config. */ |
| 607 | bd_config = vec_elt_at_index (mp->bd_configs, config->bd_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 608 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 609 | /* remove interface from flood vector */ |
| 610 | bd_remove_member (bd_config, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 611 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 612 | /* undo any BVI-related config */ |
| 613 | if (bd_config->bvi_sw_if_index == sw_if_index) |
| 614 | { |
Neale Ranns | 87dad11 | 2018-04-09 01:53:01 -0700 | [diff] [blame] | 615 | vnet_sw_interface_t *si; |
| 616 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 617 | bd_config->bvi_sw_if_index = ~0; |
| 618 | config->bvi = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 619 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 620 | /* delete the l2fib entry for the bvi interface */ |
John Lo | 7dbd726 | 2018-05-31 10:25:18 -0400 | [diff] [blame] | 621 | l2fib_del_entry (hi->hw_address, config->bd_index, sw_if_index); |
Pierre Pfister | e389de7 | 2016-03-09 15:56:31 +0000 | [diff] [blame] | 622 | |
Neale Ranns | 87dad11 | 2018-04-09 01:53:01 -0700 | [diff] [blame] | 623 | /* since this is a no longer BVI interface do not to flood to it */ |
| 624 | si = vnet_get_sw_interface (vnm, sw_if_index); |
| 625 | si->flood_class = VNET_FLOOD_CLASS_NO_FLOOD; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 626 | } |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 627 | if (bd_config->uu_fwd_sw_if_index == sw_if_index) |
| 628 | { |
| 629 | bd_config->uu_fwd_sw_if_index = ~0; |
| 630 | bd_config->feature_bitmap &= ~L2INPUT_FEAT_UU_FWD; |
| 631 | } |
John Lo | da1f2c7 | 2017-03-24 20:11:15 -0400 | [diff] [blame] | 632 | |
| 633 | /* Clear MACs learned on the interface */ |
Eyal Bari | afc47aa | 2017-04-20 14:45:17 +0300 | [diff] [blame] | 634 | if ((config->feature_bitmap & L2INPUT_FEAT_LEARN) || |
| 635 | (bd_config->feature_bitmap & L2INPUT_FEAT_LEARN)) |
John Lo | da1f2c7 | 2017-03-24 20:11:15 -0400 | [diff] [blame] | 636 | l2fib_flush_int_mac (vm, sw_if_index); |
| 637 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 638 | l2_if_adjust--; |
| 639 | } |
| 640 | else if (config->xconnect) |
| 641 | { |
| 642 | l2_if_adjust--; |
| 643 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 644 | |
John Lo | b2fd6cb | 2017-07-12 19:56:45 -0400 | [diff] [blame] | 645 | /* Make sure vector is big enough */ |
John Lo | beb0b2e | 2017-07-22 00:21:36 -0400 | [diff] [blame] | 646 | vec_validate_init_empty (l2om->output_node_index_vec, sw_if_index, |
| 647 | L2OUTPUT_NEXT_DROP); |
John Lo | 0fc9bc1 | 2016-10-27 11:17:02 -0400 | [diff] [blame] | 648 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 649 | /* Initialize the l2-input configuration for the interface */ |
| 650 | if (mode == MODE_L3) |
| 651 | { |
John Lo | 0fc9bc1 | 2016-10-27 11:17:02 -0400 | [diff] [blame] | 652 | /* Set L2 config to BD index 0 so that if any packet accidentally |
| 653 | * came in on L2 path, it will be dropped in BD 0 */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 654 | config->xconnect = 0; |
| 655 | config->bridge = 0; |
| 656 | config->shg = 0; |
| 657 | config->bd_index = 0; |
| 658 | config->feature_bitmap = L2INPUT_FEAT_DROP; |
John Lo | 93a4691 | 2016-07-21 14:54:05 -0400 | [diff] [blame] | 659 | |
John Lo | 7100b9c | 2017-02-28 13:10:52 -0500 | [diff] [blame] | 660 | /* Clear L2 output config */ |
| 661 | out_config = l2output_intf_config (sw_if_index); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 662 | clib_memset (out_config, 0, sizeof (l2_output_config_t)); |
John Lo | 7100b9c | 2017-02-28 13:10:52 -0500 | [diff] [blame] | 663 | |
John Lo | 0fc9bc1 | 2016-10-27 11:17:02 -0400 | [diff] [blame] | 664 | /* Make sure any L2-output packet to this interface now in L3 mode is |
| 665 | * dropped. This may happen if L2 FIB MAC entry is stale */ |
John Lo | beb0b2e | 2017-07-22 00:21:36 -0400 | [diff] [blame] | 666 | l2om->output_node_index_vec[sw_if_index] = L2OUTPUT_NEXT_BAD_INTF; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 667 | } |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 668 | else |
| 669 | { |
John Lo | b2fd6cb | 2017-07-12 19:56:45 -0400 | [diff] [blame] | 670 | /* Add or update l2-output node next-arc and output_node_index_vec table |
| 671 | * for the interface */ |
| 672 | l2output_create_output_node_mapping (vm, vnet_main, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 673 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 674 | if (mode == MODE_L2_BRIDGE) |
| 675 | { |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 676 | u8 member_flags; |
| 677 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 678 | /* |
| 679 | * Remove a check that the interface must be an Ethernet. |
| 680 | * Specifically so we can bridge to L3 tunnel interfaces. |
| 681 | * Here's the check: |
| 682 | * if (hi->hw_class_index != ethernet_hw_interface_class.index) |
| 683 | * |
| 684 | */ |
| 685 | if (!hi) |
| 686 | return MODE_ERROR_ETH; /* non-ethernet */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 687 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 688 | config->xconnect = 0; |
| 689 | config->bridge = 1; |
| 690 | config->bd_index = bd_index; |
Eyal Bari | b12ac56 | 2017-07-18 13:25:19 +0300 | [diff] [blame] | 691 | *l2fib_valid_swif_seq_num (sw_if_index) += 1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 692 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 693 | /* |
| 694 | * Enable forwarding, flooding, learning and ARP termination by default |
| 695 | * (note that ARP term is disabled on BD feature bitmap by default) |
| 696 | */ |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 697 | config->feature_bitmap |= (L2INPUT_FEAT_FWD | |
| 698 | L2INPUT_FEAT_UU_FLOOD | |
| 699 | L2INPUT_FEAT_UU_FWD | |
| 700 | L2INPUT_FEAT_FLOOD | |
| 701 | L2INPUT_FEAT_LEARN | |
| 702 | L2INPUT_FEAT_ARP_TERM); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 703 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 704 | /* Make sure last-chance drop is configured */ |
| 705 | config->feature_bitmap |= L2INPUT_FEAT_DROP; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 706 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 707 | /* Make sure xconnect is disabled */ |
| 708 | config->feature_bitmap &= ~L2INPUT_FEAT_XCONNECT; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 709 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 710 | /* Set up bridge domain */ |
Eyal Bari | afc47aa | 2017-04-20 14:45:17 +0300 | [diff] [blame] | 711 | bd_config = l2input_bd_config (bd_index); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 712 | bd_validate (bd_config); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 713 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 714 | /* TODO: think: add l2fib entry even for non-bvi interface? */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 715 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 716 | /* Do BVI interface initializations */ |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 717 | if (L2_BD_PORT_TYPE_BVI == port_type) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 718 | { |
Neale Ranns | 87dad11 | 2018-04-09 01:53:01 -0700 | [diff] [blame] | 719 | vnet_sw_interface_t *si; |
| 720 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 721 | /* ensure BD has no bvi interface (or replace that one with this??) */ |
| 722 | if (bd_config->bvi_sw_if_index != ~0) |
| 723 | { |
| 724 | return MODE_ERROR_BVI_DEF; /* bd already has a bvi interface */ |
| 725 | } |
| 726 | bd_config->bvi_sw_if_index = sw_if_index; |
| 727 | config->bvi = 1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 728 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 729 | /* create the l2fib entry for the bvi interface */ |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 730 | l2fib_add_entry (hi->hw_address, bd_index, sw_if_index, |
| 731 | L2FIB_ENTRY_RESULT_FLAG_BVI | |
| 732 | L2FIB_ENTRY_RESULT_FLAG_STATIC); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 733 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 734 | /* Disable learning by default. no use since l2fib entry is static. */ |
| 735 | config->feature_bitmap &= ~L2INPUT_FEAT_LEARN; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 736 | |
Neale Ranns | 87dad11 | 2018-04-09 01:53:01 -0700 | [diff] [blame] | 737 | /* since this is a BVI interface we want to flood to it */ |
| 738 | si = vnet_get_sw_interface (vnm, sw_if_index); |
| 739 | si->flood_class = VNET_FLOOD_CLASS_BVI; |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 740 | member_flags = L2_FLOOD_MEMBER_BVI; |
| 741 | } |
| 742 | else if (L2_BD_PORT_TYPE_UU_FWD == port_type) |
| 743 | { |
| 744 | bd_config->uu_fwd_sw_if_index = sw_if_index; |
| 745 | bd_config->feature_bitmap |= L2INPUT_FEAT_UU_FWD; |
| 746 | } |
| 747 | else |
| 748 | { |
| 749 | member_flags = L2_FLOOD_MEMBER_NORMAL; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 750 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 751 | |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 752 | if (L2_BD_PORT_TYPE_NORMAL == port_type || |
| 753 | L2_BD_PORT_TYPE_BVI == port_type) |
| 754 | { |
| 755 | /* Add interface to bridge-domain flood vector */ |
| 756 | l2_flood_member_t member = { |
| 757 | .sw_if_index = sw_if_index, |
| 758 | .flags = member_flags, |
| 759 | .shg = shg, |
| 760 | }; |
| 761 | bd_add_member (bd_config, &member); |
| 762 | } |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 763 | } |
John Lo | b2fd6cb | 2017-07-12 19:56:45 -0400 | [diff] [blame] | 764 | else if (mode == MODE_L2_XC) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 765 | { |
| 766 | config->xconnect = 1; |
| 767 | config->bridge = 0; |
| 768 | config->output_sw_if_index = xc_sw_if_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 769 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 770 | /* Make sure last-chance drop is configured */ |
| 771 | config->feature_bitmap |= L2INPUT_FEAT_DROP; |
| 772 | |
| 773 | /* Make sure bridging features are disabled */ |
| 774 | config->feature_bitmap &= |
| 775 | ~(L2INPUT_FEAT_LEARN | L2INPUT_FEAT_FWD | L2INPUT_FEAT_FLOOD); |
| 776 | |
| 777 | config->feature_bitmap |= L2INPUT_FEAT_XCONNECT; |
| 778 | shg = 0; /* not used in xconnect */ |
| 779 | } |
John Lo | b2fd6cb | 2017-07-12 19:56:45 -0400 | [diff] [blame] | 780 | else if (mode == MODE_L2_CLASSIFY) |
| 781 | { |
| 782 | config->xconnect = 1; |
| 783 | config->bridge = 0; |
| 784 | config->output_sw_if_index = xc_sw_if_index; |
| 785 | |
| 786 | /* Make sure last-chance drop is configured */ |
| 787 | config->feature_bitmap |= |
| 788 | L2INPUT_FEAT_DROP | L2INPUT_FEAT_INPUT_CLASSIFY; |
| 789 | |
| 790 | /* Make sure bridging features are disabled */ |
| 791 | config->feature_bitmap &= |
| 792 | ~(L2INPUT_FEAT_LEARN | L2INPUT_FEAT_FWD | L2INPUT_FEAT_FLOOD); |
| 793 | shg = 0; /* not used in xconnect */ |
| 794 | |
| 795 | /* Insure all packets go to ethernet-input */ |
| 796 | ethernet_set_rx_redirect (vnet_main, hi, 1); |
| 797 | } |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 798 | |
Andrew Yourtchenko | cc40565 | 2017-03-03 13:11:30 +0000 | [diff] [blame] | 799 | /* set up split-horizon group and set output feature bit */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 800 | config->shg = shg; |
| 801 | out_config = l2output_intf_config (sw_if_index); |
| 802 | out_config->shg = shg; |
Andrew Yourtchenko | cc40565 | 2017-03-03 13:11:30 +0000 | [diff] [blame] | 803 | out_config->feature_bitmap |= L2OUTPUT_FEAT_OUTPUT; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 804 | |
| 805 | /* |
| 806 | * Test: remove this when non-IP features can be configured. |
| 807 | * Enable a non-IP feature to test IP feature masking |
| 808 | * config->feature_bitmap |= L2INPUT_FEAT_CTRL_PKT; |
| 809 | */ |
| 810 | |
| 811 | l2_if_adjust++; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 812 | } |
| 813 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 814 | /* Adjust count of L2 interfaces */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 815 | hi->l2_if_count += l2_if_adjust; |
| 816 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 817 | if (hi->hw_class_index == ethernet_hw_interface_class.index) |
| 818 | { |
| 819 | if ((hi->l2_if_count == 1) && (l2_if_adjust == 1)) |
| 820 | { |
| 821 | /* Just added first L2 interface on this port */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 822 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 823 | /* Set promiscuous mode on the l2 interface */ |
| 824 | ethernet_set_flags (vnet_main, hi->hw_if_index, |
| 825 | ETHERNET_INTERFACE_FLAG_ACCEPT_ALL); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 826 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 827 | /* ensure all packets go to ethernet-input */ |
| 828 | ethernet_set_rx_redirect (vnet_main, hi, 1); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 829 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 830 | } |
| 831 | else if ((hi->l2_if_count == 0) && (l2_if_adjust == -1)) |
| 832 | { |
| 833 | /* Just removed only L2 subinterface on this port */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 834 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 835 | /* Disable promiscuous mode on the l2 interface */ |
| 836 | ethernet_set_flags (vnet_main, hi->hw_if_index, 0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 837 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 838 | /* Allow ip packets to go directly to ip4-input etc */ |
| 839 | ethernet_set_rx_redirect (vnet_main, hi, 0); |
| 840 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 841 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 842 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 843 | /* Set up the L2/L3 flag in the interface parsing tables */ |
| 844 | ethernet_sw_interface_set_l2_mode (vnm, sw_if_index, (mode != MODE_L3)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 845 | |
Steven | 4f8863b | 2018-04-12 19:36:19 -0700 | [diff] [blame] | 846 | dev_class = vnet_get_device_class (vnet_main, hi->dev_class_index); |
| 847 | if (dev_class->set_l2_mode_function) |
| 848 | { |
| 849 | dev_class->set_l2_mode_function (vnet_main, hi, l2_if_adjust); |
| 850 | } |
| 851 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 852 | return 0; |
| 853 | } |
| 854 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 855 | /** |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 856 | * Set subinterface in bridging mode with a bridge-domain ID. |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 857 | * The CLI format is: |
| 858 | * set interface l2 bridge <interface> <bd> [bvi] [split-horizon-group] |
| 859 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 860 | static clib_error_t * |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 861 | int_l2_bridge (vlib_main_t * vm, |
| 862 | unformat_input_t * input, vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 863 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 864 | vnet_main_t *vnm = vnet_get_main (); |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 865 | l2_bd_port_type_t port_type; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 866 | clib_error_t *error = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 867 | u32 bd_index, bd_id; |
| 868 | u32 sw_if_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 869 | u32 rc; |
| 870 | u32 shg; |
| 871 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 872 | if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 873 | { |
| 874 | error = clib_error_return (0, "unknown interface `%U'", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 875 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 876 | goto done; |
| 877 | } |
| 878 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 879 | if (!unformat (input, "%d", &bd_id)) |
| 880 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 881 | error = clib_error_return (0, "expected bridge domain ID `%U'", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 882 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 883 | goto done; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 884 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 885 | |
John Lo | 9793477 | 2017-05-18 22:26:47 -0400 | [diff] [blame] | 886 | if (bd_id > L2_BD_ID_MAX) |
| 887 | { |
| 888 | error = clib_error_return (0, "bridge domain ID exceed 16M limit", |
| 889 | format_unformat_error, input); |
| 890 | goto done; |
| 891 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 892 | bd_index = bd_find_or_add_bd_index (&bd_main, bd_id); |
| 893 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 894 | /* optional bvi */ |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 895 | port_type = L2_BD_PORT_TYPE_NORMAL; |
| 896 | if (unformat (input, "bvi")) |
| 897 | port_type = L2_BD_PORT_TYPE_BVI; |
| 898 | if (unformat (input, "uu-fwd")) |
| 899 | port_type = L2_BD_PORT_TYPE_UU_FWD; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 900 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 901 | /* optional split horizon group */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 902 | shg = 0; |
| 903 | (void) unformat (input, "%d", &shg); |
| 904 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 905 | /* set the interface mode */ |
| 906 | if ((rc = |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 907 | set_int_l2_mode (vm, vnm, MODE_L2_BRIDGE, sw_if_index, bd_index, |
| 908 | port_type, shg, 0))) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 909 | { |
| 910 | if (rc == MODE_ERROR_ETH) |
| 911 | { |
| 912 | error = clib_error_return (0, "bridged interface must be ethernet", |
| 913 | format_unformat_error, input); |
| 914 | } |
| 915 | else if (rc == MODE_ERROR_BVI_DEF) |
| 916 | { |
| 917 | error = |
| 918 | clib_error_return (0, "bridge-domain already has a bvi interface", |
| 919 | format_unformat_error, input); |
| 920 | } |
| 921 | else |
| 922 | { |
| 923 | error = clib_error_return (0, "invalid configuration for interface", |
| 924 | format_unformat_error, input); |
| 925 | } |
| 926 | goto done; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 927 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 928 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 929 | done: |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 930 | return error; |
| 931 | } |
| 932 | |
Keith Burns (alagalah) | 6ef7bb9 | 2016-09-10 14:55:04 -0700 | [diff] [blame] | 933 | /*? |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 934 | * Use this command put an interface into Layer 2 bridge domain. If a |
| 935 | * bridge-domain with the provided bridge-domain-id does not exist, it |
| 936 | * will be created. Interfaces in a bridge-domain forward packets to |
| 937 | * other interfaces in the same bridge-domain based on destination mac |
| 938 | * address. To remove an interface from a the Layer 2 bridge domain, |
| 939 | * put the interface in a different mode, for example Layer 3 mode. |
| 940 | * |
| 941 | * Optionally, an interface can be added to a Layer 2 bridge-domain as |
| 942 | * a Bridged Virtual Interface (bvi). Only one interface in a Layer 2 |
| 943 | * bridge-domain can be a bvi. |
| 944 | * |
| 945 | * Optionally, a split-horizon group can also be specified. This defaults |
| 946 | * to 0 if not specified. |
Keith Burns (alagalah) | 6ef7bb9 | 2016-09-10 14:55:04 -0700 | [diff] [blame] | 947 | * |
| 948 | * @cliexpar |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 949 | * Example of how to configure a Layer 2 bridge-domain with three |
| 950 | * interfaces (where 200 is the bridge-domain-id): |
| 951 | * @cliexcmd{set interface l2 bridge GigabitEthernet0/8/0.200 200} |
| 952 | * This interface is added a BVI interface: |
| 953 | * @cliexcmd{set interface l2 bridge GigabitEthernet0/9/0.200 200 bvi} |
| 954 | * This interface also has a split-horizon group of 1 specified: |
| 955 | * @cliexcmd{set interface l2 bridge GigabitEthernet0/a/0.200 200 1} |
| 956 | * Example of how to remove an interface from a Layer2 bridge-domain: |
| 957 | * @cliexcmd{set interface l3 GigabitEthernet0/a/0.200} |
| 958 | ?*/ |
| 959 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 960 | VLIB_CLI_COMMAND (int_l2_bridge_cli, static) = { |
| 961 | .path = "set interface l2 bridge", |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 962 | .short_help = "set interface l2 bridge <interface> <bridge-domain-id> [bvi|uu-fwd] [shg]", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 963 | .function = int_l2_bridge, |
| 964 | }; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 965 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 966 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 967 | /** |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 968 | * Set subinterface in xconnect mode with another interface. |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 969 | * The CLI format is: |
| 970 | * set interface l2 xconnect <interface> <peer interface> |
| 971 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 972 | static clib_error_t * |
| 973 | int_l2_xc (vlib_main_t * vm, |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 974 | unformat_input_t * input, vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 975 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 976 | vnet_main_t *vnm = vnet_get_main (); |
| 977 | clib_error_t *error = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 978 | u32 sw_if_index; |
| 979 | u32 xc_sw_if_index; |
| 980 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 981 | if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 982 | { |
| 983 | error = clib_error_return (0, "unknown interface `%U'", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 984 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 985 | goto done; |
| 986 | } |
| 987 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 988 | if (!unformat_user |
| 989 | (input, unformat_vnet_sw_interface, vnm, &xc_sw_if_index)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 990 | { |
| 991 | error = clib_error_return (0, "unknown peer interface `%U'", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 992 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 993 | goto done; |
| 994 | } |
| 995 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 996 | /* set the interface mode */ |
| 997 | if (set_int_l2_mode |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 998 | (vm, vnm, MODE_L2_XC, sw_if_index, 0, L2_BD_PORT_TYPE_NORMAL, |
| 999 | 0, xc_sw_if_index)) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1000 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1001 | error = clib_error_return (0, "invalid configuration for interface", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1002 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1003 | goto done; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1004 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1005 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1006 | done: |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1007 | return error; |
| 1008 | } |
| 1009 | |
Keith Burns (alagalah) | 6ef7bb9 | 2016-09-10 14:55:04 -0700 | [diff] [blame] | 1010 | /*? |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1011 | * Use this command put an interface into Layer 2 cross-connect mode. |
Paul Vinciguerra | bdc0e6b | 2018-09-22 05:32:50 -0700 | [diff] [blame] | 1012 | * Both interfaces must be in this mode for bi-directional traffic. All |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1013 | * packets received on one interface will be transmitted to the other. |
| 1014 | * To remove the Layer 2 cross-connect, put the interface in a different |
| 1015 | * mode, for example Layer 3 mode. |
| 1016 | * |
Keith Burns (alagalah) | 6ef7bb9 | 2016-09-10 14:55:04 -0700 | [diff] [blame] | 1017 | * @cliexpar |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1018 | * Example of how to configure a Layer2 cross-connect between two interfaces: |
| 1019 | * @cliexcmd{set interface l2 xconnect GigabitEthernet0/8/0.300 GigabitEthernet0/9/0.300} |
| 1020 | * @cliexcmd{set interface l2 xconnect GigabitEthernet0/9/0.300 GigabitEthernet0/8/0.300} |
| 1021 | * Example of how to remove a Layer2 cross-connect: |
| 1022 | * @cliexcmd{set interface l3 GigabitEthernet0/8/0.300} |
| 1023 | * @cliexcmd{set interface l3 GigabitEthernet0/9/0.300} |
| 1024 | ?*/ |
| 1025 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1026 | VLIB_CLI_COMMAND (int_l2_xc_cli, static) = { |
| 1027 | .path = "set interface l2 xconnect", |
Keith Burns (alagalah) | 6ef7bb9 | 2016-09-10 14:55:04 -0700 | [diff] [blame] | 1028 | .short_help = "set interface l2 xconnect <interface> <peer interface>", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1029 | .function = int_l2_xc, |
| 1030 | }; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1031 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1032 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1033 | /** |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 1034 | * Set subinterface in L3 mode. |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1035 | * The CLI format is: |
| 1036 | * set interface l3 <interface> |
| 1037 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1038 | static clib_error_t * |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1039 | int_l3 (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1040 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1041 | vnet_main_t *vnm = vnet_get_main (); |
| 1042 | clib_error_t *error = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1043 | u32 sw_if_index; |
| 1044 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1045 | if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1046 | { |
| 1047 | error = clib_error_return (0, "unknown interface `%U'", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1048 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1049 | goto done; |
| 1050 | } |
| 1051 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1052 | /* set the interface mode */ |
Neale Ranns | b474380 | 2018-09-05 09:13:57 -0700 | [diff] [blame] | 1053 | if (set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0, |
| 1054 | L2_BD_PORT_TYPE_NORMAL, 0, 0)) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1055 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1056 | error = clib_error_return (0, "invalid configuration for interface", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1057 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1058 | goto done; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1059 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1060 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1061 | done: |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1062 | return error; |
| 1063 | } |
| 1064 | |
Keith Burns (alagalah) | 6ef7bb9 | 2016-09-10 14:55:04 -0700 | [diff] [blame] | 1065 | /*? |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1066 | * Modify the packet processing mode of the interface to Layer 3, which |
| 1067 | * implies packets will be routed. This is the default mode of an interface. |
| 1068 | * Use this command to remove an interface from a Layer 2 cross-connect or a |
| 1069 | * Layer 2 bridge. |
Keith Burns (alagalah) | 6ef7bb9 | 2016-09-10 14:55:04 -0700 | [diff] [blame] | 1070 | * |
| 1071 | * @cliexpar |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1072 | * Example of how to set the mode of an interface to Layer 3: |
| 1073 | * @cliexcmd{set interface l3 GigabitEthernet0/8/0.200} |
| 1074 | ?*/ |
| 1075 | /* *INDENT-OFF* */ |
Keith Burns (alagalah) | 6ef7bb9 | 2016-09-10 14:55:04 -0700 | [diff] [blame] | 1076 | VLIB_CLI_COMMAND (int_l3_cli, static) = { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1077 | .path = "set interface l3", |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1078 | .short_help = "set interface l3 <interface>", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1079 | .function = int_l3, |
| 1080 | }; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1081 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1082 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1083 | /** |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 1084 | * Show interface mode. |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1085 | * The CLI format is: |
| 1086 | * show mode [<if-name1> <if-name2> ...] |
| 1087 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1088 | static clib_error_t * |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1089 | show_int_mode (vlib_main_t * vm, |
| 1090 | unformat_input_t * input, vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1091 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1092 | vnet_main_t *vnm = vnet_get_main (); |
| 1093 | clib_error_t *error = 0; |
| 1094 | char *mode; |
| 1095 | u8 *args; |
| 1096 | vnet_interface_main_t *im = &vnm->interface_main; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1097 | |
Eyal Bari | afc47aa | 2017-04-20 14:45:17 +0300 | [diff] [blame] | 1098 | vnet_sw_interface_t *si, *sis = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1099 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 1100 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1101 | u32 sw_if_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1102 | |
| 1103 | /* See if user wants to show specific interface */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1104 | if (unformat |
| 1105 | (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1106 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1107 | si = pool_elt_at_index (im->sw_interfaces, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1108 | vec_add1 (sis, si[0]); |
| 1109 | } |
| 1110 | else |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1111 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1112 | error = clib_error_return (0, "unknown input `%U'", |
| 1113 | format_unformat_error, input); |
| 1114 | goto done; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1115 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1116 | } |
| 1117 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1118 | if (vec_len (sis) == 0) /* Get all interfaces */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1119 | { |
| 1120 | /* Gather interfaces. */ |
| 1121 | sis = vec_new (vnet_sw_interface_t, pool_elts (im->sw_interfaces)); |
| 1122 | _vec_len (sis) = 0; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1123 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1124 | pool_foreach (si, im->sw_interfaces, ({ vec_add1 (sis, si[0]); })); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1125 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1126 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1127 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1128 | vec_foreach (si, sis) |
| 1129 | { |
Eyal Bari | afc47aa | 2017-04-20 14:45:17 +0300 | [diff] [blame] | 1130 | l2_input_config_t *config = l2input_intf_config (si->sw_if_index); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1131 | if (config->bridge) |
| 1132 | { |
| 1133 | u32 bd_id; |
| 1134 | mode = "l2 bridge"; |
| 1135 | bd_id = l2input_main.bd_configs[config->bd_index].bd_id; |
| 1136 | |
| 1137 | args = format (0, "bd_id %d%s%d", bd_id, |
| 1138 | config->bvi ? " bvi shg " : " shg ", config->shg); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1139 | } |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1140 | else if (config->xconnect) |
| 1141 | { |
| 1142 | mode = "l2 xconnect"; |
| 1143 | args = format (0, "%U", |
| 1144 | format_vnet_sw_if_index_name, |
| 1145 | vnm, config->output_sw_if_index); |
| 1146 | } |
| 1147 | else |
| 1148 | { |
| 1149 | mode = "l3"; |
| 1150 | args = format (0, " "); |
| 1151 | } |
| 1152 | vlib_cli_output (vm, "%s %U %v\n", |
| 1153 | mode, |
| 1154 | format_vnet_sw_if_index_name, |
| 1155 | vnm, si->sw_if_index, args); |
| 1156 | vec_free (args); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1157 | } |
| 1158 | |
| 1159 | done: |
| 1160 | vec_free (sis); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1161 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1162 | return error; |
| 1163 | } |
| 1164 | |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1165 | /*? |
Paul Vinciguerra | bdc0e6b | 2018-09-22 05:32:50 -0700 | [diff] [blame] | 1166 | * Show the packet processing mode (Layer2 cross-connect, Layer 2 bridge, |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1167 | * Layer 3 routed) of all interfaces and sub-interfaces, or limit the |
| 1168 | * output to just the provided list of interfaces and sub-interfaces. |
| 1169 | * The output shows the mode, the interface, and if the interface is |
Paul Vinciguerra | bdc0e6b | 2018-09-22 05:32:50 -0700 | [diff] [blame] | 1170 | * a member of a bridge, the bridge-domain-id and the split horizon group (shg). |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1171 | * |
| 1172 | * @cliexpar |
| 1173 | * Example of displaying the mode of all interfaces: |
| 1174 | * @cliexstart{show mode} |
| 1175 | * l3 local0 |
| 1176 | * l3 GigabitEthernet0/8/0 |
| 1177 | * l3 GigabitEthernet0/9/0 |
| 1178 | * l3 GigabitEthernet0/a/0 |
| 1179 | * l2 bridge GigabitEthernet0/8/0.200 bd_id 200 shg 0 |
| 1180 | * l2 bridge GigabitEthernet0/9/0.200 bd_id 200 shg 0 |
| 1181 | * l2 bridge GigabitEthernet0/a/0.200 bd_id 200 shg 0 |
| 1182 | * l2 xconnect GigabitEthernet0/8/0.300 GigabitEthernet0/9/0.300 |
| 1183 | * l2 xconnect GigabitEthernet0/9/0.300 GigabitEthernet0/8/0.300 |
| 1184 | * @cliexend |
Paul Vinciguerra | bdc0e6b | 2018-09-22 05:32:50 -0700 | [diff] [blame] | 1185 | * Example of displaying the mode of a selected list of interfaces: |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 1186 | * @cliexstart{show mode GigabitEthernet0/8/0 GigabitEthernet0/8/0.200} |
| 1187 | * l3 GigabitEthernet0/8/0 |
| 1188 | * l2 bridge GigabitEthernet0/8/0.200 bd_id 200 shg 0 |
| 1189 | * @cliexend |
| 1190 | ?*/ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1191 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1192 | VLIB_CLI_COMMAND (show_l2_mode, static) = { |
| 1193 | .path = "show mode", |
| 1194 | .short_help = "show mode [<if-name1> <if-name2> ...]", |
| 1195 | .function = show_int_mode, |
| 1196 | }; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1197 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1198 | |
| 1199 | #define foreach_l2_init_function \ |
| 1200 | _(feat_bitmap_drop_init) \ |
| 1201 | _(l2fib_init) \ |
Dave Barach | b84a3e5 | 2016-08-30 17:01:52 -0400 | [diff] [blame] | 1202 | _(l2_input_classify_init) \ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1203 | _(l2bd_init) \ |
| 1204 | _(l2fwd_init) \ |
Andrew Yourtchenko | 815d7d5 | 2018-02-07 11:37:02 +0100 | [diff] [blame] | 1205 | _(l2_in_out_acl_init) \ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1206 | _(l2input_init) \ |
| 1207 | _(l2_vtr_init) \ |
| 1208 | _(l2_invtr_init) \ |
| 1209 | _(l2_efp_filter_init) \ |
| 1210 | _(l2learn_init) \ |
| 1211 | _(l2flood_init) \ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1212 | _(l2output_init) \ |
| 1213 | _(l2_patch_init) \ |
| 1214 | _(l2_xcrw_init) |
| 1215 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1216 | clib_error_t * |
| 1217 | l2_init (vlib_main_t * vm) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1218 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1219 | clib_error_t *error; |
| 1220 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1221 | #define _(a) do { \ |
| 1222 | if ((error = vlib_call_init_function (vm, a))) return error; } \ |
| 1223 | while (0); |
| 1224 | foreach_l2_init_function; |
| 1225 | #undef _ |
| 1226 | return 0; |
| 1227 | } |
| 1228 | |
| 1229 | VLIB_INIT_FUNCTION (l2_init); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 1230 | |
| 1231 | /* |
| 1232 | * fd.io coding-style-patch-verification: ON |
| 1233 | * |
| 1234 | * Local Variables: |
| 1235 | * eval: (c-set-style "gnu") |
| 1236 | * End: |
| 1237 | */ |