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