2 * l2_fib.h : layer 2 forwarding table (aka mac table)
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:
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #ifndef included_l2fib_h
19 #define included_l2fib_h
21 #include <vlib/vlib.h>
22 #include <vppinfra/bihash_8_8.h>
25 * The size of the hash table
27 #define L2FIB_NUM_BUCKETS (64 * 1024)
28 #define L2FIB_MEMORY_SIZE (512<<20)
30 /* Ager scan interval is 1 minute for aging */
31 #define L2FIB_AGE_SCAN_INTERVAL (60.0)
33 /* MAC event scan delay is 100 msec unless specified by MAC event client */
34 #define L2FIB_EVENT_SCAN_DELAY_DEFAULT (0.1)
36 /* Max MACs in a event message is 100 unless specified by MAC event client */
37 #define L2FIB_EVENT_MAX_MACS_DEFAULT (100)
39 /* MAC event learn limit is 1000 unless specified by MAC event client */
40 #define L2FIB_EVENT_LEARN_LIMIT_DEFAULT (1000)
46 BVT (clib_bihash) mac_table;
48 /* per swif vector of sequence number for interface based flush of MACs */
51 /* last event or ager scan duration */
52 f64 evt_scan_duration;
53 f64 age_scan_duration;
55 /* delay between event scans, default to 100 msec */
58 /* max macs in event message, default to 100 entries */
59 u32 max_macs_in_event;
61 /* convenience variables */
62 vlib_main_t *vlib_main;
63 vnet_main_t *vnet_main;
66 extern l2fib_main_t l2fib_main;
69 * The L2fib key is the mac address and bridge domain ID
89 STATIC_ASSERT_SIZEOF (l2fib_entry_key_t, 8);
106 * Flags associated with an L2 Fib Entry
107 * - static mac, no MAC move
108 * - not subject to age
109 * - mac is for a bridged virtual interface
110 * - drop packets to/from this mac
111 * - MAC learned to be sent in L2 MAC event
112 * -MAC learned is a MAC move
114 #define foreach_l2fib_entry_result_attr \
115 _(STATIC, 0, "static") \
116 _(AGE_NOT, 1, "age-not") \
118 _(FILTER, 3, "filter") \
119 _(LRN_EVT, 4, "learn-event") \
120 _(LRN_MOV, 5, "learn-move")
122 typedef enum l2fib_entry_result_flags_t_
124 L2FIB_ENTRY_RESULT_FLAG_NONE = 0,
125 #define _(a,v,s) L2FIB_ENTRY_RESULT_FLAG_##a = (1 << v),
126 foreach_l2fib_entry_result_attr
128 } __attribute__ ((packed)) l2fib_entry_result_flags_t;
130 STATIC_ASSERT_SIZEOF (l2fib_entry_result_flags_t, 1);
132 extern u8 *format_l2fib_entry_result_flags (u8 * s, va_list * args);
135 * The l2fib entry results
137 typedef struct l2fib_entry_result_t_
143 u32 sw_if_index; /* output sw_if_index (L3 intf if bvi==1) */
144 l2fib_entry_result_flags_t flags;
146 u8 timestamp; /* timestamp for aging */
147 l2fib_seq_num_t sn; /* bd/int seq num */
151 } l2fib_entry_result_t;
153 STATIC_ASSERT_SIZEOF (l2fib_entry_result_t, 8);
157 l2fib_entry_result_is_set_##a (const l2fib_entry_result_t *r) { \
158 return (r->fields.flags & L2FIB_ENTRY_RESULT_FLAG_##a); \
160 foreach_l2fib_entry_result_attr
164 l2fib_entry_result_set_##a (l2fib_entry_result_t *r) { \
165 r->fields.flags |= L2FIB_ENTRY_RESULT_FLAG_##a; \
167 foreach_l2fib_entry_result_attr
171 l2fib_entry_result_clear_##a (l2fib_entry_result_t *r) { \
172 r->fields.flags &= ~L2FIB_ENTRY_RESULT_FLAG_##a; \
174 foreach_l2fib_entry_result_attr
177 l2fib_entry_result_set_bits (l2fib_entry_result_t * r,
178 l2fib_entry_result_flags_t bits)
180 r->fields.flags |= bits;
184 l2fib_entry_result_clear_bits (l2fib_entry_result_t * r,
185 l2fib_entry_result_flags_t bits)
187 r->fields.flags &= ~bits;
190 /* L2 MAC event entry action enums (see mac_entry definition in l2.api) */
193 MAC_EVENT_ACTION_ADD = 0,
194 MAC_EVENT_ACTION_DELETE = 1,
195 MAC_EVENT_ACTION_MOVE = 2,
196 } l2_mac_event_action_t;
199 * Compute the hash for the given key and return
200 * the corresponding bucket index
203 l2fib_compute_hash_bucket (l2fib_entry_key_t * key)
209 result = 0xa5a5a5a5; /* some seed */
210 temp_a = key->words.w0;
211 temp_b = key->words.w1;
212 hash_mix32 (temp_a, temp_b, result);
214 return result % L2FIB_NUM_BUCKETS;
218 * make address sanitizer skip this:
219 * The 6-Bytes mac-address is cast into an 8-Bytes u64, with 2 additional Bytes.
220 * l2fib_make_key() does read those two Bytes but does not use them.
222 always_inline u64 __attribute__ ((no_sanitize_address))
223 l2fib_make_key (const u8 * mac_address, u16 bd_index)
228 * The mac address in memory is A:B:C:D:E:F
229 * The bd id in register is H:L
231 #if CLIB_ARCH_IS_LITTLE_ENDIAN
233 * Create the in-register key as F:E:D:C:B:A:H:L
234 * In memory the key is L:H:A:B:C:D:E:F
236 temp = *((u64 *) (mac_address)) << 16;
237 temp = (temp & ~0xffff) | (u64) (bd_index);
240 * Create the in-register key as H:L:A:B:C:D:E:F
241 * In memory the key is H:L:A:B:C:D:E:F
243 temp = *((u64 *) (mac_address)) >> 16;
244 temp = temp | (((u64) bd_index) << 48);
253 * Lookup the entry for mac and bd_index in the mac table for 1 packet.
254 * Cached_key and cached_result are used as a one-entry cache.
255 * The function reads and updates them as needed.
257 * mac0 and bd_index0 are the keys. The entry is written to result0.
258 * If the entry was not found, result0 is set to ~0.
260 * key0 and bucket0 return with the computed key and hash bucket,
261 * convenient if the entry needs to be updated afterward.
262 * If the cached_result was used, bucket0 is set to ~0.
265 static_always_inline void
266 l2fib_lookup_1 (BVT (clib_bihash) * mac_table,
267 l2fib_entry_key_t * cached_key,
268 l2fib_entry_result_t * cached_result,
271 l2fib_entry_key_t * key0,
272 u32 * bucket0, l2fib_entry_result_t * result0)
275 key0->raw = l2fib_make_key (mac0, bd_index0);
278 if (key0->raw == cached_key->raw)
280 /* Hit in the one-entry cache */
281 result0->raw = cached_result->raw;
285 /* Do a regular mac table lookup */
286 BVT (clib_bihash_kv) kv;
290 BV (clib_bihash_search_inline) (mac_table, &kv);
291 result0->raw = kv.value;
293 /* Update one-entry cache */
294 cached_key->raw = key0->raw;
295 cached_result->raw = result0->raw;
301 * Lookup the entry for mac and bd_index in the mac table for 2 packets.
302 * The lookups for the two packets are interleaved.
304 * Cached_key and cached_result are used as a one-entry cache.
305 * The function reads and updates them as needed.
307 * mac0 and bd_index0 are the keys. The entry is written to result0.
308 * If the entry was not found, result0 is set to ~0. The same
309 * holds for mac1/bd_index1/result1.
311 static_always_inline void
312 l2fib_lookup_2 (BVT (clib_bihash) * mac_table,
313 l2fib_entry_key_t * cached_key,
314 l2fib_entry_result_t * cached_result,
319 l2fib_entry_key_t * key0,
320 l2fib_entry_key_t * key1,
323 l2fib_entry_result_t * result0,
324 l2fib_entry_result_t * result1)
327 key0->raw = l2fib_make_key (mac0, bd_index0);
328 key1->raw = l2fib_make_key (mac1, bd_index1);
330 if ((key0->raw == cached_key->raw) && (key1->raw == cached_key->raw))
332 /* Both hit in the one-entry cache */
333 result0->raw = cached_result->raw;
334 result1->raw = cached_result->raw;
341 BVT (clib_bihash_kv) kv0, kv1;
344 * Do a regular mac table lookup
345 * Interleave lookups for packet 0 and packet 1
352 BV (clib_bihash_search_inline) (mac_table, &kv0);
353 BV (clib_bihash_search_inline) (mac_table, &kv1);
355 result0->raw = kv0.value;
356 result1->raw = kv1.value;
358 /* Update one-entry cache */
359 cached_key->raw = key1->raw;
360 cached_result->raw = result1->raw;
364 static_always_inline void
365 l2fib_lookup_4 (BVT (clib_bihash) * mac_table,
366 l2fib_entry_key_t * cached_key,
367 l2fib_entry_result_t * cached_result,
376 l2fib_entry_key_t * key0,
377 l2fib_entry_key_t * key1,
378 l2fib_entry_key_t * key2,
379 l2fib_entry_key_t * key3,
384 l2fib_entry_result_t * result0,
385 l2fib_entry_result_t * result1,
386 l2fib_entry_result_t * result2,
387 l2fib_entry_result_t * result3)
390 key0->raw = l2fib_make_key (mac0, bd_index0);
391 key1->raw = l2fib_make_key (mac1, bd_index1);
392 key2->raw = l2fib_make_key (mac2, bd_index2);
393 key3->raw = l2fib_make_key (mac3, bd_index3);
395 if ((key0->raw == cached_key->raw) && (key1->raw == cached_key->raw) &&
396 (key2->raw == cached_key->raw) && (key3->raw == cached_key->raw))
398 /* Both hit in the one-entry cache */
399 result0->raw = cached_result->raw;
400 result1->raw = cached_result->raw;
401 result2->raw = cached_result->raw;
402 result3->raw = cached_result->raw;
411 BVT (clib_bihash_kv) kv0, kv1, kv2, kv3;
414 * Do a regular mac table lookup
415 * Interleave lookups for packet 0 and packet 1
426 BV (clib_bihash_search_inline) (mac_table, &kv0);
427 BV (clib_bihash_search_inline) (mac_table, &kv1);
428 BV (clib_bihash_search_inline) (mac_table, &kv2);
429 BV (clib_bihash_search_inline) (mac_table, &kv3);
431 result0->raw = kv0.value;
432 result1->raw = kv1.value;
433 result2->raw = kv2.value;
434 result3->raw = kv3.value;
436 /* Update one-entry cache */
437 cached_key->raw = key1->raw;
438 cached_result->raw = result1->raw;
442 void l2fib_clear_table (void);
445 l2fib_add_entry (const u8 * mac,
447 u32 sw_if_index, l2fib_entry_result_flags_t flags);
450 l2fib_add_filter_entry (const u8 * mac, u32 bd_index)
452 l2fib_add_entry (mac, bd_index, ~0,
453 (L2FIB_ENTRY_RESULT_FLAG_FILTER |
454 L2FIB_ENTRY_RESULT_FLAG_STATIC));
457 u32 l2fib_del_entry (const u8 * mac, u32 bd_index, u32 sw_if_index);
459 void l2fib_start_ager_scan (vlib_main_t * vm);
461 void l2fib_flush_int_mac (vlib_main_t * vm, u32 sw_if_index);
463 void l2fib_flush_bd_mac (vlib_main_t * vm, u32 bd_index);
465 void l2fib_flush_all_mac (vlib_main_t * vm);
468 l2fib_table_dump (u32 bd_index, l2fib_entry_key_t ** l2fe_key,
469 l2fib_entry_result_t ** l2fe_res);
471 u8 *format_vnet_sw_if_index_name_with_NA (u8 * s, va_list * args);
473 static_always_inline u8 *
474 l2fib_swif_seq_num (u32 sw_if_index)
476 l2fib_main_t *mp = &l2fib_main;
477 return vec_elt_at_index (mp->swif_seq_num, sw_if_index);
480 static_always_inline u8 *
481 l2fib_valid_swif_seq_num (u32 sw_if_index)
483 l2fib_main_t *mp = &l2fib_main;
484 vec_validate (mp->swif_seq_num, sw_if_index);
485 return l2fib_swif_seq_num (sw_if_index);
488 BVT (clib_bihash) * get_mac_table (void);
493 * fd.io coding-style-patch-verification: ON
496 * eval: (c-set-style "gnu")