Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1 | /* |
| 2 | * l2_learn.c : layer 2 learning using l2fib |
| 3 | * |
| 4 | * Copyright (c) 2013 Cisco and/or its affiliates. |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at: |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | */ |
| 17 | |
| 18 | #include <vlib/vlib.h> |
| 19 | #include <vnet/vnet.h> |
| 20 | #include <vnet/pg/pg.h> |
| 21 | #include <vnet/ethernet/ethernet.h> |
| 22 | #include <vlib/cli.h> |
| 23 | |
| 24 | #include <vnet/l2/l2_input.h> |
| 25 | #include <vnet/l2/feat_bitmap.h> |
| 26 | #include <vnet/l2/l2_fib.h> |
| 27 | #include <vnet/l2/l2_learn.h> |
| 28 | |
| 29 | #include <vppinfra/error.h> |
| 30 | #include <vppinfra/hash.h> |
| 31 | |
Neale Ranns | eb1525f | 2018-09-09 04:41:02 -0400 | [diff] [blame] | 32 | #ifndef CLIB_MARCH_VARIANT |
Dave Wallace | 71612d6 | 2017-10-24 01:32:41 -0400 | [diff] [blame] | 33 | l2learn_main_t l2learn_main; |
Neale Ranns | eb1525f | 2018-09-09 04:41:02 -0400 | [diff] [blame] | 34 | #endif |
Dave Wallace | 71612d6 | 2017-10-24 01:32:41 -0400 | [diff] [blame] | 35 | |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 36 | /** |
| 37 | * @file |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 38 | * @brief Ethernet Bridge Learning. |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 39 | * |
| 40 | * Populate the mac table with entries mapping the packet's source mac + bridge |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 41 | * domain ID to the input sw_if_index. |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 42 | * |
| 43 | * Note that learning and forwarding are separate graph nodes. This means that |
| 44 | * for a set of packets, all learning is performed first, then all nodes are |
| 45 | * forwarded. The forwarding is done based on the end-state of the mac table, |
| 46 | * instead of the state after each packet. Thus the forwarding results could |
| 47 | * differ in certain cases (mac move tests), but this not expected to cause |
| 48 | * problems in real-world networks. It is much simpler to separate learning |
| 49 | * and forwarding into separate nodes. |
| 50 | */ |
| 51 | |
| 52 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 53 | typedef struct |
| 54 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 55 | u8 src[6]; |
| 56 | u8 dst[6]; |
| 57 | u32 sw_if_index; |
| 58 | u16 bd_index; |
| 59 | } l2learn_trace_t; |
| 60 | |
| 61 | |
| 62 | /* packet trace format function */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 63 | static u8 * |
| 64 | format_l2learn_trace (u8 * s, va_list * args) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 65 | { |
| 66 | CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); |
| 67 | CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 68 | l2learn_trace_t *t = va_arg (*args, l2learn_trace_t *); |
| 69 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 70 | s = format (s, "l2-learn: sw_if_index %d dst %U src %U bd_index %d", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 71 | t->sw_if_index, |
| 72 | format_ethernet_address, t->dst, |
| 73 | format_ethernet_address, t->src, t->bd_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 74 | return s; |
| 75 | } |
| 76 | |
| 77 | static vlib_node_registration_t l2learn_node; |
| 78 | |
| 79 | #define foreach_l2learn_error \ |
| 80 | _(L2LEARN, "L2 learn packets") \ |
| 81 | _(MISS, "L2 learn misses") \ |
| 82 | _(MAC_MOVE, "L2 mac moves") \ |
| 83 | _(MAC_MOVE_VIOLATE, "L2 mac move violations") \ |
| 84 | _(LIMIT, "L2 not learned due to limit") \ |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 85 | _(HIT_UPDATE, "L2 learn hit updates") \ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 86 | _(FILTER_DROP, "L2 filter mac drops") |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 87 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 88 | typedef enum |
| 89 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 90 | #define _(sym,str) L2LEARN_ERROR_##sym, |
| 91 | foreach_l2learn_error |
| 92 | #undef _ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 93 | L2LEARN_N_ERROR, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 94 | } l2learn_error_t; |
| 95 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 96 | static char *l2learn_error_strings[] = { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 97 | #define _(sym,string) string, |
| 98 | foreach_l2learn_error |
| 99 | #undef _ |
| 100 | }; |
| 101 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 102 | typedef enum |
| 103 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 104 | L2LEARN_NEXT_L2FWD, |
| 105 | L2LEARN_NEXT_DROP, |
| 106 | L2LEARN_N_NEXT, |
| 107 | } l2learn_next_t; |
| 108 | |
| 109 | |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 110 | /** Perform learning on one packet based on the mac table lookup result. */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 111 | |
| 112 | static_always_inline void |
| 113 | l2learn_process (vlib_node_runtime_t * node, |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 114 | l2learn_main_t * msm, |
| 115 | u64 * counter_base, |
| 116 | vlib_buffer_t * b0, |
| 117 | u32 sw_if_index0, |
| 118 | l2fib_entry_key_t * key0, |
| 119 | l2fib_entry_key_t * cached_key, |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 120 | u32 * count, |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 121 | l2fib_entry_result_t * result0, u16 * next0, u8 timestamp) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 122 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 123 | /* Set up the default next node (typically L2FWD) */ |
John Lo | beb0b2e | 2017-07-22 00:21:36 -0400 | [diff] [blame] | 124 | *next0 = vnet_l2_feature_next (b0, msm->feat_next_node_index, |
| 125 | L2INPUT_FEAT_LEARN); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 126 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 127 | /* Check mac table lookup result */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 128 | if (PREDICT_TRUE (result0->fields.sw_if_index == sw_if_index0)) |
| 129 | { |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 130 | /* Entry in L2FIB with matching sw_if_index matched - normal fast path */ |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 131 | u32 dtime = timestamp - result0->fields.timestamp; |
| 132 | u32 dsn = result0->fields.sn.as_u16 - vnet_buffer (b0)->l2.l2fib_sn; |
John Lo | 5a6508d | 2017-10-03 13:13:47 -0400 | [diff] [blame] | 133 | u32 check = (dtime && vnet_buffer (b0)->l2.bd_age) || dsn; |
Eyal Bari | 31a71ab | 2017-06-25 14:42:33 +0300 | [diff] [blame] | 134 | |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 135 | if (PREDICT_TRUE (check == 0)) |
| 136 | return; /* MAC entry up to date */ |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 137 | if (l2fib_entry_result_is_set_AGE_NOT (result0)) |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 138 | return; /* Static MAC always age_not */ |
| 139 | if (msm->global_learn_count > msm->global_learn_limit) |
John Lo | e531f4c | 2017-08-22 09:16:50 -0400 | [diff] [blame] | 140 | return; /* Above learn limit - do not update */ |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 141 | |
| 142 | /* Limit updates per l2-learn node call to avoid prolonged update burst |
John Lo | 5a6508d | 2017-10-03 13:13:47 -0400 | [diff] [blame] | 143 | * as dtime advance over 1 minute mark, unless more than 1 min behind |
| 144 | * or SN obsolete */ |
| 145 | if ((*count > 2) && (dtime == 1) && (dsn == 0)) |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 146 | return; |
| 147 | |
| 148 | counter_base[L2LEARN_ERROR_HIT_UPDATE] += 1; |
| 149 | *count += 1; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 150 | } |
| 151 | else if (result0->raw == ~0) |
| 152 | { |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 153 | /* Entry not in L2FIB - add it */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 154 | counter_base[L2LEARN_ERROR_MISS] += 1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 155 | |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 156 | if (msm->global_learn_count >= msm->global_learn_limit) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 157 | { |
| 158 | /* |
| 159 | * Global limit reached. Do not learn the mac but forward the packet. |
| 160 | * In the future, limits could also be per-interface or bridge-domain. |
| 161 | */ |
| 162 | counter_base[L2LEARN_ERROR_LIMIT] += 1; |
Eyal Bari | 31a71ab | 2017-06-25 14:42:33 +0300 | [diff] [blame] | 163 | return; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 164 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 165 | |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 166 | /* Do not learn if mac is 0 */ |
| 167 | l2fib_entry_key_t key = *key0; |
| 168 | key.fields.bd_index = 0; |
| 169 | if (key.raw == 0) |
| 170 | return; |
| 171 | |
Eyal Bari | 31a71ab | 2017-06-25 14:42:33 +0300 | [diff] [blame] | 172 | /* It is ok to learn */ |
| 173 | msm->global_learn_count++; |
| 174 | result0->raw = 0; /* clear all fields */ |
| 175 | result0->fields.sw_if_index = sw_if_index0; |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 176 | if (msm->client_pid != 0) |
| 177 | l2fib_entry_result_set_LRN_EVT (result0); |
| 178 | else |
| 179 | l2fib_entry_result_clear_LRN_EVT (result0); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 180 | } |
| 181 | else |
| 182 | { |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 183 | /* Entry in L2FIB with different sw_if_index - mac move or filter */ |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 184 | if (l2fib_entry_result_is_set_FILTER (result0)) |
Eyal Bari | 31a71ab | 2017-06-25 14:42:33 +0300 | [diff] [blame] | 185 | { |
| 186 | ASSERT (result0->fields.sw_if_index == ~0); |
| 187 | /* drop packet because lookup matched a filter mac entry */ |
| 188 | b0->error = node->errors[L2LEARN_ERROR_FILTER_DROP]; |
| 189 | *next0 = L2LEARN_NEXT_DROP; |
| 190 | return; |
| 191 | } |
| 192 | |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 193 | if (l2fib_entry_result_is_set_STATIC (result0)) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 194 | { |
| 195 | /* |
| 196 | * Don't overwrite a static mac |
| 197 | * TODO: Check violation policy. For now drop the packet |
| 198 | */ |
| 199 | b0->error = node->errors[L2LEARN_ERROR_MAC_MOVE_VIOLATE]; |
| 200 | *next0 = L2LEARN_NEXT_DROP; |
Eyal Bari | 31a71ab | 2017-06-25 14:42:33 +0300 | [diff] [blame] | 201 | return; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 202 | } |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 203 | |
Eyal Bari | 31a71ab | 2017-06-25 14:42:33 +0300 | [diff] [blame] | 204 | /* |
| 205 | * TODO: may want to rate limit mac moves |
| 206 | * TODO: check global/bridge domain/interface learn limits |
| 207 | */ |
| 208 | result0->fields.sw_if_index = sw_if_index0; |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 209 | if (l2fib_entry_result_is_set_AGE_NOT (result0)) |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 210 | { |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 211 | /* The mac was provisioned */ |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 212 | msm->global_learn_count++; |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 213 | l2fib_entry_result_clear_AGE_NOT (result0); |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 214 | } |
Neale Ranns | b54d081 | 2018-09-06 06:22:56 -0700 | [diff] [blame] | 215 | if (msm->client_pid != 0) |
| 216 | l2fib_entry_result_set_bits (result0, |
| 217 | (L2FIB_ENTRY_RESULT_FLAG_LRN_EVT | |
| 218 | L2FIB_ENTRY_RESULT_FLAG_LRN_MOV)); |
| 219 | else |
| 220 | l2fib_entry_result_clear_bits (result0, |
| 221 | (L2FIB_ENTRY_RESULT_FLAG_LRN_EVT | |
| 222 | L2FIB_ENTRY_RESULT_FLAG_LRN_MOV)); |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 223 | counter_base[L2LEARN_ERROR_MAC_MOVE] += 1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 224 | } |
| 225 | |
Eyal Bari | 31a71ab | 2017-06-25 14:42:33 +0300 | [diff] [blame] | 226 | /* Update the entry */ |
| 227 | result0->fields.timestamp = timestamp; |
| 228 | result0->fields.sn.as_u16 = vnet_buffer (b0)->l2.l2fib_sn; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 229 | |
Eyal Bari | 31a71ab | 2017-06-25 14:42:33 +0300 | [diff] [blame] | 230 | BVT (clib_bihash_kv) kv; |
| 231 | kv.key = key0->raw; |
| 232 | kv.value = result0->raw; |
| 233 | BV (clib_bihash_add_del) (msm->mac_table, &kv, 1 /* is_add */ ); |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 234 | |
| 235 | /* Invalidate the cache */ |
| 236 | cached_key->raw = ~0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | |
Dave Barach | 681abe4 | 2017-02-15 09:01:01 -0500 | [diff] [blame] | 240 | static_always_inline uword |
| 241 | l2learn_node_inline (vlib_main_t * vm, vlib_node_runtime_t * node, |
| 242 | vlib_frame_t * frame, int do_trace) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 243 | { |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 244 | u32 n_left, *from; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 245 | l2learn_main_t *msm = &l2learn_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 246 | vlib_node_t *n = vlib_get_node (vm, l2learn_node.index); |
| 247 | u32 node_counter_base_index = n->error_heap_index; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 248 | vlib_error_main_t *em = &vm->error_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 249 | l2fib_entry_key_t cached_key; |
| 250 | l2fib_entry_result_t cached_result; |
Damjan Marion | d171d48 | 2016-12-05 14:16:38 +0100 | [diff] [blame] | 251 | u8 timestamp = (u8) (vlib_time_now (vm) / 60); |
John Lo | dbfa574 | 2017-09-02 08:27:36 -0400 | [diff] [blame] | 252 | u32 count = 0; |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 253 | vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; |
| 254 | u16 nexts[VLIB_FRAME_SIZE], *next; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 255 | |
| 256 | from = vlib_frame_vector_args (frame); |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 257 | n_left = frame->n_vectors; /* number of packets to process */ |
| 258 | vlib_get_buffers (vm, from, bufs, n_left); |
| 259 | next = nexts; |
| 260 | b = bufs; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 261 | |
| 262 | /* Clear the one-entry cache in case mac table was updated */ |
| 263 | cached_key.raw = ~0; |
| 264 | cached_result.raw = ~0; /* warning be gone */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 265 | |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 266 | while (n_left > 8) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 267 | { |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 268 | u32 sw_if_index0, sw_if_index1, sw_if_index2, sw_if_index3; |
| 269 | const ethernet_header_t *h0, *h1, *h2, *h3; |
| 270 | l2fib_entry_key_t key0, key1, key2, key3; |
| 271 | l2fib_entry_result_t result0, result1, result2, result3; |
| 272 | u32 bucket0, bucket1, bucket2, bucket3; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 273 | |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 274 | /* Prefetch next iteration. */ |
| 275 | { |
| 276 | /* buffer header is read and written, so use LOAD |
| 277 | * prefetch */ |
| 278 | vlib_prefetch_buffer_header (b[4], LOAD); |
| 279 | vlib_prefetch_buffer_header (b[5], LOAD); |
| 280 | vlib_prefetch_buffer_header (b[6], LOAD); |
| 281 | vlib_prefetch_buffer_header (b[7], LOAD); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 282 | |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 283 | CLIB_PREFETCH (b[4]->data, CLIB_CACHE_LINE_BYTES, LOAD); |
| 284 | CLIB_PREFETCH (b[5]->data, CLIB_CACHE_LINE_BYTES, LOAD); |
| 285 | CLIB_PREFETCH (b[6]->data, CLIB_CACHE_LINE_BYTES, LOAD); |
| 286 | CLIB_PREFETCH (b[7]->data, CLIB_CACHE_LINE_BYTES, LOAD); |
| 287 | } |
| 288 | |
| 289 | /* RX interface handles */ |
| 290 | sw_if_index0 = vnet_buffer (b[0])->sw_if_index[VLIB_RX]; |
| 291 | sw_if_index1 = vnet_buffer (b[1])->sw_if_index[VLIB_RX]; |
| 292 | sw_if_index2 = vnet_buffer (b[2])->sw_if_index[VLIB_RX]; |
| 293 | sw_if_index3 = vnet_buffer (b[3])->sw_if_index[VLIB_RX]; |
| 294 | |
| 295 | /* Process 4 x pkts */ |
| 296 | |
| 297 | h0 = vlib_buffer_get_current (b[0]); |
| 298 | h1 = vlib_buffer_get_current (b[1]); |
| 299 | h2 = vlib_buffer_get_current (b[2]); |
| 300 | h3 = vlib_buffer_get_current (b[3]); |
| 301 | |
| 302 | if (do_trace) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 303 | { |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 304 | if (b[0]->flags & VLIB_BUFFER_IS_TRACED) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 305 | { |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 306 | l2learn_trace_t *t = |
| 307 | vlib_add_trace (vm, node, b[0], sizeof (*t)); |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 308 | t->sw_if_index = sw_if_index0; |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 309 | t->bd_index = vnet_buffer (b[0])->l2.bd_index; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 310 | clib_memcpy (t->src, h0->src_address, 6); |
| 311 | clib_memcpy (t->dst, h0->dst_address, 6); |
| 312 | } |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 313 | if (b[1]->flags & VLIB_BUFFER_IS_TRACED) |
| 314 | { |
| 315 | l2learn_trace_t *t = |
| 316 | vlib_add_trace (vm, node, b[1], sizeof (*t)); |
| 317 | t->sw_if_index = sw_if_index1; |
| 318 | t->bd_index = vnet_buffer (b[1])->l2.bd_index; |
| 319 | clib_memcpy (t->src, h1->src_address, 6); |
| 320 | clib_memcpy (t->dst, h1->dst_address, 6); |
| 321 | } |
| 322 | if (b[2]->flags & VLIB_BUFFER_IS_TRACED) |
| 323 | { |
| 324 | l2learn_trace_t *t = |
| 325 | vlib_add_trace (vm, node, b[2], sizeof (*t)); |
| 326 | t->sw_if_index = sw_if_index2; |
| 327 | t->bd_index = vnet_buffer (b[2])->l2.bd_index; |
| 328 | clib_memcpy (t->src, h2->src_address, 6); |
| 329 | clib_memcpy (t->dst, h2->dst_address, 6); |
| 330 | } |
| 331 | if (b[3]->flags & VLIB_BUFFER_IS_TRACED) |
| 332 | { |
| 333 | l2learn_trace_t *t = |
| 334 | vlib_add_trace (vm, node, b[3], sizeof (*t)); |
| 335 | t->sw_if_index = sw_if_index3; |
| 336 | t->bd_index = vnet_buffer (b[3])->l2.bd_index; |
| 337 | clib_memcpy (t->src, h3->src_address, 6); |
| 338 | clib_memcpy (t->dst, h3->dst_address, 6); |
| 339 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 340 | } |
| 341 | |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 342 | /* process 4 pkts */ |
| 343 | vlib_node_increment_counter (vm, l2learn_node.index, |
| 344 | L2LEARN_ERROR_L2LEARN, 4); |
| 345 | |
| 346 | l2fib_lookup_4 (msm->mac_table, &cached_key, &cached_result, |
| 347 | h0->src_address, |
| 348 | h1->src_address, |
| 349 | h2->src_address, |
| 350 | h3->src_address, |
| 351 | vnet_buffer (b[0])->l2.bd_index, |
| 352 | vnet_buffer (b[1])->l2.bd_index, |
| 353 | vnet_buffer (b[2])->l2.bd_index, |
| 354 | vnet_buffer (b[3])->l2.bd_index, |
| 355 | &key0, &key1, &key2, &key3, |
| 356 | &bucket0, &bucket1, &bucket2, &bucket3, |
| 357 | &result0, &result1, &result2, &result3); |
| 358 | |
| 359 | l2learn_process (node, msm, &em->counters[node_counter_base_index], |
| 360 | b[0], sw_if_index0, &key0, &cached_key, |
| 361 | &count, &result0, next, timestamp); |
| 362 | |
| 363 | l2learn_process (node, msm, &em->counters[node_counter_base_index], |
| 364 | b[1], sw_if_index1, &key1, &cached_key, |
| 365 | &count, &result1, next + 1, timestamp); |
| 366 | |
| 367 | l2learn_process (node, msm, &em->counters[node_counter_base_index], |
| 368 | b[2], sw_if_index2, &key2, &cached_key, |
| 369 | &count, &result2, next + 2, timestamp); |
| 370 | |
| 371 | l2learn_process (node, msm, &em->counters[node_counter_base_index], |
| 372 | b[3], sw_if_index3, &key3, &cached_key, |
| 373 | &count, &result3, next + 3, timestamp); |
| 374 | |
| 375 | next += 4; |
| 376 | b += 4; |
| 377 | n_left -= 4; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 378 | } |
| 379 | |
Neale Ranns | f0fa317 | 2018-09-12 07:37:43 -0400 | [diff] [blame^] | 380 | while (n_left > 0) |
| 381 | { |
| 382 | u32 sw_if_index0; |
| 383 | ethernet_header_t *h0; |
| 384 | l2fib_entry_key_t key0; |
| 385 | l2fib_entry_result_t result0; |
| 386 | u32 bucket0; |
| 387 | |
| 388 | sw_if_index0 = vnet_buffer (b[0])->sw_if_index[VLIB_RX]; |
| 389 | |
| 390 | h0 = vlib_buffer_get_current (b[0]); |
| 391 | |
| 392 | if (do_trace && PREDICT_FALSE (b[0]->flags & VLIB_BUFFER_IS_TRACED)) |
| 393 | { |
| 394 | l2learn_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t)); |
| 395 | t->sw_if_index = sw_if_index0; |
| 396 | t->bd_index = vnet_buffer (b[0])->l2.bd_index; |
| 397 | clib_memcpy (t->src, h0->src_address, 6); |
| 398 | clib_memcpy (t->dst, h0->dst_address, 6); |
| 399 | } |
| 400 | |
| 401 | /* process 1 pkt */ |
| 402 | vlib_node_increment_counter (vm, l2learn_node.index, |
| 403 | L2LEARN_ERROR_L2LEARN, 1); |
| 404 | |
| 405 | |
| 406 | l2fib_lookup_1 (msm->mac_table, &cached_key, &cached_result, |
| 407 | h0->src_address, vnet_buffer (b[0])->l2.bd_index, |
| 408 | &key0, &bucket0, &result0); |
| 409 | |
| 410 | l2learn_process (node, msm, &em->counters[node_counter_base_index], |
| 411 | b[0], sw_if_index0, &key0, &cached_key, |
| 412 | &count, &result0, next, timestamp); |
| 413 | |
| 414 | next += 1; |
| 415 | b += 1; |
| 416 | n_left -= 1; |
| 417 | } |
| 418 | |
| 419 | vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors); |
| 420 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 421 | return frame->n_vectors; |
| 422 | } |
| 423 | |
Neale Ranns | eb1525f | 2018-09-09 04:41:02 -0400 | [diff] [blame] | 424 | VLIB_NODE_FN (l2learn_node) (vlib_main_t * vm, |
| 425 | vlib_node_runtime_t * node, vlib_frame_t * frame) |
Dave Barach | 681abe4 | 2017-02-15 09:01:01 -0500 | [diff] [blame] | 426 | { |
| 427 | if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) |
| 428 | return l2learn_node_inline (vm, node, frame, 1 /* do_trace */ ); |
| 429 | return l2learn_node_inline (vm, node, frame, 0 /* do_trace */ ); |
| 430 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 431 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 432 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 433 | VLIB_REGISTER_NODE (l2learn_node,static) = { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 434 | .name = "l2-learn", |
| 435 | .vector_size = sizeof (u32), |
| 436 | .format_trace = format_l2learn_trace, |
| 437 | .type = VLIB_NODE_TYPE_INTERNAL, |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 438 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 439 | .n_errors = ARRAY_LEN(l2learn_error_strings), |
| 440 | .error_strings = l2learn_error_strings, |
| 441 | |
| 442 | .n_next_nodes = L2LEARN_N_NEXT, |
| 443 | |
| 444 | /* edit / add dispositions here */ |
| 445 | .next_nodes = { |
| 446 | [L2LEARN_NEXT_DROP] = "error-drop", |
| 447 | [L2LEARN_NEXT_L2FWD] = "l2-fwd", |
| 448 | }, |
| 449 | }; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 450 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 451 | |
Neale Ranns | eb1525f | 2018-09-09 04:41:02 -0400 | [diff] [blame] | 452 | #ifndef CLIB_MARCH_VARIANT |
| 453 | clib_error_t * |
| 454 | l2learn_init (vlib_main_t * vm) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 455 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 456 | l2learn_main_t *mp = &l2learn_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 457 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 458 | mp->vlib_main = vm; |
| 459 | mp->vnet_main = vnet_get_main (); |
| 460 | |
| 461 | /* Initialize the feature next-node indexes */ |
| 462 | feat_bitmap_init_next_nodes (vm, |
| 463 | l2learn_node.index, |
| 464 | L2INPUT_N_FEAT, |
| 465 | l2input_get_feat_names (), |
| 466 | mp->feat_next_node_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 467 | |
| 468 | /* init the hash table ptr */ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 469 | mp->mac_table = get_mac_table (); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 470 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 471 | /* |
| 472 | * Set the default number of dynamically learned macs to the number |
| 473 | * of buckets. |
| 474 | */ |
John Lo | 8d00fff | 2017-08-03 00:35:36 -0400 | [diff] [blame] | 475 | mp->global_learn_limit = L2LEARN_DEFAULT_LIMIT; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 476 | |
| 477 | return 0; |
| 478 | } |
| 479 | |
| 480 | VLIB_INIT_FUNCTION (l2learn_init); |
| 481 | |
| 482 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 483 | /** |
Chris Luke | 16bcf7d | 2016-09-01 14:31:46 -0400 | [diff] [blame] | 484 | * Set subinterface learn enable/disable. |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 485 | * The CLI format is: |
| 486 | * set interface l2 learn <interface> [disable] |
| 487 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 488 | static clib_error_t * |
| 489 | int_learn (vlib_main_t * vm, |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 490 | unformat_input_t * input, vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 491 | { |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 492 | vnet_main_t *vnm = vnet_get_main (); |
| 493 | clib_error_t *error = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 494 | u32 sw_if_index; |
| 495 | u32 enable; |
| 496 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 497 | if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 498 | { |
| 499 | error = clib_error_return (0, "unknown interface `%U'", |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 500 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 501 | goto done; |
| 502 | } |
| 503 | |
| 504 | enable = 1; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 505 | if (unformat (input, "disable")) |
| 506 | { |
| 507 | enable = 0; |
| 508 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 509 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 510 | /* set the interface flag */ |
| 511 | l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_LEARN, enable); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 512 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 513 | done: |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 514 | return error; |
| 515 | } |
| 516 | |
Billy McFall | 22aa3e9 | 2016-09-09 08:46:40 -0400 | [diff] [blame] | 517 | /*? |
| 518 | * Layer 2 learning can be enabled and disabled on each |
| 519 | * interface and on each bridge-domain. Use this command to |
| 520 | * manage interfaces. It is enabled by default. |
| 521 | * |
| 522 | * @cliexpar |
| 523 | * Example of how to enable learning: |
| 524 | * @cliexcmd{set interface l2 learn GigabitEthernet0/8/0} |
| 525 | * Example of how to disable learning: |
| 526 | * @cliexcmd{set interface l2 learn GigabitEthernet0/8/0 disable} |
| 527 | ?*/ |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 528 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 529 | VLIB_CLI_COMMAND (int_learn_cli, static) = { |
| 530 | .path = "set interface l2 learn", |
| 531 | .short_help = "set interface l2 learn <interface> [disable]", |
| 532 | .function = int_learn, |
| 533 | }; |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 534 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 535 | |
| 536 | |
| 537 | static clib_error_t * |
| 538 | l2learn_config (vlib_main_t * vm, unformat_input_t * input) |
| 539 | { |
| 540 | l2learn_main_t *mp = &l2learn_main; |
| 541 | |
| 542 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 543 | { |
| 544 | if (unformat (input, "limit %d", &mp->global_learn_limit)) |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 545 | ; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 546 | |
| 547 | else |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 548 | return clib_error_return (0, "unknown input `%U'", |
| 549 | format_unformat_error, input); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 550 | } |
| 551 | |
| 552 | return 0; |
| 553 | } |
| 554 | |
| 555 | VLIB_CONFIG_FUNCTION (l2learn_config, "l2learn"); |
| 556 | |
Neale Ranns | eb1525f | 2018-09-09 04:41:02 -0400 | [diff] [blame] | 557 | #endif |
| 558 | |
Dave Barach | 97d8dc2 | 2016-08-15 15:31:15 -0400 | [diff] [blame] | 559 | |
| 560 | /* |
| 561 | * fd.io coding-style-patch-verification: ON |
| 562 | * |
| 563 | * Local Variables: |
| 564 | * eval: (c-set-style "gnu") |
| 565 | * End: |
| 566 | */ |