FD.io VPP  v18.01-8-g0eacf49
Vector Packet Processing
l2_fib.c
Go to the documentation of this file.
1 /*
2  * l2_fib.c : layer 2 forwarding table (aka mac table)
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 
19 #include <vlib/vlib.h>
20 #include <vnet/vnet.h>
21 #include <vnet/pg/pg.h>
22 #include <vnet/ethernet/ethernet.h>
23 #include <vlib/cli.h>
24 
25 #include <vppinfra/error.h>
26 #include <vppinfra/hash.h>
27 #include <vnet/l2/l2_input.h>
28 #include <vnet/l2/l2_fib.h>
29 #include <vnet/l2/l2_learn.h>
30 #include <vnet/l2/l2_bd.h>
31 
33 
34 #include <vlibmemory/api.h>
35 #include <vnet/vnet_msg_enum.h>
36 
37 #define vl_typedefs /* define message structures */
38 #include <vnet/vnet_all_api_h.h>
39 #undef vl_typedefs
40 
41 #define vl_endianfun /* define message structures */
42 #include <vnet/vnet_all_api_h.h>
43 #undef vl_endianfun
44 
45 /**
46  * @file
47  * @brief Ethernet MAC Address FIB Table Management.
48  *
49  * The MAC Address forwarding table for bridge-domains is called the l2fib.
50  * Entries are added automatically as part of mac learning, but MAC Addresses
51  * entries can also be added manually.
52  *
53  */
54 
56 
57 static void
59 {
60  u64 tmp = *((u64 *) mac);
61  tmp = clib_net_to_host_u64 (tmp);
62  tmp += 1 << 16; /* skip unused (least significant) octets */
63  tmp = clib_host_to_net_u64 (tmp);
64 
65  clib_memcpy (mac, &tmp, 6);
66 }
67 
68 /** Format sw_if_index. If the value is ~0, use the text "N/A" */
69 u8 *
71 {
72  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
73  u32 sw_if_index = va_arg (*args, u32);
74  if (sw_if_index == ~0)
75  return format (s, "N/A");
76 
77  vnet_sw_interface_t *swif = vnet_get_sw_interface_safe (vnm, sw_if_index);
78  if (!swif)
79  return format (s, "Stale");
80 
81  return format (s, "%U", format_vnet_sw_interface_name, vnm,
82  vnet_get_sw_interface_safe (vnm, sw_if_index));
83 }
84 
85 void
86 l2fib_table_dump (u32 bd_index, l2fib_entry_key_t ** l2fe_key,
87  l2fib_entry_result_t ** l2fe_res)
88 {
89  l2fib_main_t *msm = &l2fib_main;
90  BVT (clib_bihash) * h = &msm->mac_table;
91  BVT (clib_bihash_bucket) * b;
94  l2fib_entry_result_t result;
95  int i, j, k;
96 
97  for (i = 0; i < h->nbuckets; i++)
98  {
99  b = &h->buckets[i];
100  if (b->offset == 0)
101  continue;
102  v = BV (clib_bihash_get_value) (h, b->offset);
103  for (j = 0; j < (1 << b->log2_pages); j++)
104  {
105  for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
106  {
107  if (v->kvp[k].key == ~0ULL && v->kvp[k].value == ~0ULL)
108  continue;
109 
110  key.raw = v->kvp[k].key;
111  result.raw = v->kvp[k].value;
112 
113  if ((bd_index == ~0) || (bd_index == key.fields.bd_index))
114  {
115  vec_add1 (*l2fe_key, key);
116  vec_add1 (*l2fe_res, result);
117  }
118  }
119  v++;
120  }
121  }
122 }
123 
124 /** Display the contents of the l2fib. */
125 static clib_error_t *
127  unformat_input_t * input, vlib_cli_command_t * cmd)
128 {
129  bd_main_t *bdm = &bd_main;
130  l2fib_main_t *msm = &l2fib_main;
131  l2_bridge_domain_t *bd_config;
132  BVT (clib_bihash) * h = &msm->mac_table;
133  BVT (clib_bihash_bucket) * b;
134  BVT (clib_bihash_value) * v;
135  l2fib_entry_key_t key;
136  l2fib_entry_result_t result;
137  u32 first_entry = 1;
138  u64 total_entries = 0;
139  int i, j, k;
140  u8 verbose = 0;
141  u8 raw = 0;
142  u8 learn = 0;
143  u32 bd_id, bd_index = ~0;
144  u8 now = (u8) (vlib_time_now (vm) / 60);
145  u8 *s = 0;
146 
147  if (unformat (input, "raw"))
148  raw = 1;
149  else if (unformat (input, "verbose"))
150  verbose = 1;
151  else if (unformat (input, "bd_index %d", &bd_index))
152  verbose = 1;
153  else if (unformat (input, "learn"))
154  {
155  learn = 1;
156  verbose = 0;
157  }
158  else if (unformat (input, "bd_id %d", &bd_id))
159  {
160  uword *p = hash_get (bdm->bd_index_by_bd_id, bd_id);
161  if (p)
162  {
163  if (learn == 0)
164  verbose = 1;
165  bd_index = p[0];
166  }
167  else
168  {
169  vlib_cli_output (vm, "no such bridge domain id");
170  return 0;
171  }
172  }
173 
174  for (i = 0; i < h->nbuckets; i++)
175  {
176  b = &h->buckets[i];
177  if (b->offset == 0)
178  continue;
179  v = BV (clib_bihash_get_value) (h, b->offset);
180  for (j = 0; j < (1 << b->log2_pages); j++)
181  {
182  for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
183  {
184  if (v->kvp[k].key == ~0ULL && v->kvp[k].value == ~0ULL)
185  continue;
186 
187  if ((verbose || learn) && first_entry)
188  {
189  first_entry = 0;
190  vlib_cli_output (vm,
191  "%=19s%=7s%=7s%=8s%=9s%=7s%=7s%=5s%=30s",
192  "Mac-Address", "BD-Idx", "If-Idx",
193  "BSN-ISN", "Age(min)", "static", "filter",
194  "bvi", "Interface-Name");
195  }
196 
197  key.raw = v->kvp[k].key;
198  result.raw = v->kvp[k].value;
199 
200  if ((verbose || learn)
201  & ((bd_index >> 31) || (bd_index == key.fields.bd_index)))
202  {
203  if (learn && result.fields.age_not)
204  {
205  total_entries++;
206  continue; /* skip provisioned macs */
207  }
208 
210  key.fields.bd_index);
211 
212  if (bd_config->mac_age && !result.fields.age_not)
213  {
214  i16 delta = now - result.fields.timestamp;
215  delta += delta < 0 ? 256 : 0;
216  s = format (s, "%d", delta);
217  }
218  else
219  s = format (s, "-");
220 
221  vlib_cli_output (vm,
222  "%=19U%=7d%=7d %3d/%-3d%=9v%=7s%=7s%=5s%=30U",
224  key.fields.bd_index,
225  result.fields.sw_if_index == ~0
226  ? -1 : result.fields.sw_if_index,
227  result.fields.sn.bd, result.fields.sn.swif,
228  s, result.fields.static_mac ? "*" : "-",
229  result.fields.filter ? "*" : "-",
230  result.fields.bvi ? "*" : "-",
232  msm->vnet_main, result.fields.sw_if_index);
233  vec_reset_length (s);
234  }
235  total_entries++;
236  }
237  v++;
238  }
239  }
240 
241  if (total_entries == 0)
242  vlib_cli_output (vm, "no l2fib entries");
243  else
244  {
246  vlib_cli_output (vm, "L2FIB total/learned entries: %d/%d "
247  "Last scan time: %.4esec Learn limit: %d ",
248  total_entries, lm->global_learn_count,
250  if (lm->client_pid)
251  vlib_cli_output (vm, "L2MAC events client PID: %d "
252  "Last e-scan time: %.4esec Delay: %.2esec "
253  "Max macs in event: %d",
254  lm->client_pid, msm->evt_scan_duration,
256  }
257 
258  if (raw)
259  vlib_cli_output (vm, "Raw Hash Table:\n%U\n",
260  BV (format_bihash), h, 1 /* verbose */ );
261 
262  vec_free (s);
263  return 0;
264 }
265 
266 /*?
267  * This command dispays the MAC Address entries of the L2 FIB table.
268  * Output can be filtered to just get the number of MAC Addresses or display
269  * each MAC Address for all bridge domains or just a single bridge domain.
270  *
271  * @cliexpar
272  * Example of how to display the number of MAC Address entries in the L2
273  * FIB table:
274  * @cliexstart{show l2fib}
275  * 3 l2fib entries
276  * @cliexend
277  * Example of how to display all the MAC Address entries in the L2
278  * FIB table:
279  * @cliexstart{show l2fib verbose}
280  * Mac Address BD Idx Interface Index static filter bvi refresh timestamp
281  * 52:54:00:53:18:33 1 GigabitEthernet0/8/0.200 3 0 0 0 0 0
282  * 52:54:00:53:18:55 1 GigabitEthernet0/8/0.200 3 1 0 0 0 0
283  * 52:54:00:53:18:77 1 N/A -1 1 1 0 0 0
284  * 3 l2fib entries
285  * @cliexend
286 ?*/
287 /* *INDENT-OFF* */
288 VLIB_CLI_COMMAND (show_l2fib_cli, static) = {
289  .path = "show l2fib",
290  .short_help = "show l2fib [verbose | learn | bd_id <nn> | bd_index <nn> | raw",
291  .function = show_l2fib,
292 };
293 /* *INDENT-ON* */
294 
295 
296 /* Remove all entries from the l2fib */
297 void
299 {
300  l2fib_main_t *mp = &l2fib_main;
301 
302  /* Remove all entries */
303  BV (clib_bihash_free) (&mp->mac_table);
304  BV (clib_bihash_init) (&mp->mac_table, "l2fib mac table",
307 }
308 
309 /** Clear all entries in L2FIB.
310  * @TODO: Later we may want a way to remove only the non-static entries
311  */
312 static clib_error_t *
314  unformat_input_t * input, vlib_cli_command_t * cmd)
315 {
317  return 0;
318 }
319 
320 /*?
321  * This command clears all the MAC Address entries from the L2 FIB table.
322  *
323  * @cliexpar
324  * Example of how to clear the L2 FIB Table:
325  * @cliexcmd{clear l2fib}
326  * Example to show the L2 FIB Table has been cleared:
327  * @cliexstart{show l2fib verbose}
328  * no l2fib entries
329  * @cliexend
330 ?*/
331 /* *INDENT-OFF* */
332 VLIB_CLI_COMMAND (clear_l2fib_cli, static) = {
333  .path = "clear l2fib",
334  .short_help = "clear l2fib",
335  .function = clear_l2fib,
336 };
337 /* *INDENT-ON* */
338 
339 static inline l2fib_seq_num_t
340 l2fib_cur_seq_num (u32 bd_index, u32 sw_if_index)
341 {
342  l2_bridge_domain_t *bd_config = l2input_bd_config (bd_index);
343  /* *INDENT-OFF* */
344  return (l2fib_seq_num_t) {
345  .swif = *l2fib_swif_seq_num (sw_if_index),
346  .bd = bd_config->seq_num,
347  };
348  /* *INDENT-ON* */
349 }
350 
351 /**
352  * Add an entry to the l2fib.
353  * If the entry already exists then overwrite it
354  */
355 void
356 l2fib_add_entry (u8 * mac, u32 bd_index,
357  u32 sw_if_index, u8 static_mac, u8 filter_mac, u8 bvi_mac)
358 {
359  l2fib_entry_key_t key;
360  l2fib_entry_result_t result;
361  __attribute__ ((unused)) u32 bucket_contents;
362  l2fib_main_t *fm = &l2fib_main;
364  BVT (clib_bihash_kv) kv;
365 
366  /* set up key */
367  key.raw = l2fib_make_key (mac, bd_index);
368 
369  /* check if entry alread exist */
370  if (BV (clib_bihash_search) (&fm->mac_table, &kv, &kv))
371  {
372  /* decrement counter if overwriting a learned mac */
373  result.raw = kv.value;
374  if ((result.fields.age_not == 0) && (lm->global_learn_count))
375  lm->global_learn_count--;
376  }
377 
378  /* set up result */
379  result.raw = 0; /* clear all fields */
380  result.fields.sw_if_index = sw_if_index;
381  result.fields.static_mac = static_mac;
382  result.fields.filter = filter_mac;
383  result.fields.bvi = bvi_mac;
384  result.fields.age_not = 1; /* no aging for provisioned entry */
385 
386  kv.key = key.raw;
387  kv.value = result.raw;
388 
389  BV (clib_bihash_add_del) (&fm->mac_table, &kv, 1 /* is_add */ );
390 }
391 
392 /**
393  * Add an entry to the L2FIB.
394  * The CLI format is:
395  * l2fib add <mac> <bd> <intf> [static] [bvi]
396  * l2fib add <mac> <bd> filter
397  * Note that filter and bvi entries are always static
398  */
399 static clib_error_t *
401  unformat_input_t * input, vlib_cli_command_t * cmd)
402 {
403  bd_main_t *bdm = &bd_main;
404  vnet_main_t *vnm = vnet_get_main ();
405  clib_error_t *error = 0;
406  u8 mac[6];
407  u32 bd_id;
408  u32 bd_index;
409  u32 sw_if_index = ~0;
410  u32 static_mac = 0;
411  u32 bvi_mac = 0;
412  uword *p;
413 
414  if (!unformat (input, "%U", unformat_ethernet_address, mac))
415  {
416  error = clib_error_return (0, "expected mac address `%U'",
417  format_unformat_error, input);
418  goto done;
419  }
420 
421  if (!unformat (input, "%d", &bd_id))
422  {
423  error = clib_error_return (0, "expected bridge domain ID `%U'",
424  format_unformat_error, input);
425  goto done;
426  }
427 
428  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
429  if (!p)
430  {
431  error = clib_error_return (0, "bridge domain ID %d invalid", bd_id);
432  goto done;
433  }
434  bd_index = p[0];
435 
436  if (unformat (input, "filter"))
437  {
438  l2fib_add_filter_entry (mac, bd_index);
439  return 0;
440  }
441 
442  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
443  {
444  error = clib_error_return (0, "unknown interface `%U'",
445  format_unformat_error, input);
446  goto done;
447  }
448 
449  if (unformat (input, "static"))
450  {
451  static_mac = 1;
452  }
453  else if (unformat (input, "bvi"))
454  {
455  bvi_mac = 1;
456  static_mac = 1;
457  }
458 
459  if (vec_len (l2input_main.configs) <= sw_if_index)
460  {
461  error = clib_error_return (0, "Interface sw_if_index %d not in L2 mode",
462  sw_if_index);
463  goto done;
464  }
465 
466  l2fib_add_fwd_entry (mac, bd_index, sw_if_index, static_mac, bvi_mac);
467 
468 done:
469  return error;
470 }
471 
472 /*?
473  * This command adds a MAC Address entry to the L2 FIB table
474  * of an existing bridge-domain. The MAC Address can be static
475  * or dynamic. This command also allows a filter to be added,
476  * such that packets with given MAC Addresses (source mac or
477  * destination mac match) are dropped.
478  *
479  * @cliexpar
480  * Example of how to add a dynamic MAC Address entry to the L2 FIB table
481  * of a bridge-domain (where 200 is the bridge-domain-id):
482  * @cliexcmd{l2fib add 52:54:00:53:18:33 200 GigabitEthernet0/8/0.200}
483  * Example of how to add a static MAC Address entry to the L2 FIB table
484  * of a bridge-domain (where 200 is the bridge-domain-id):
485  * @cliexcmd{l2fib add 52:54:00:53:18:55 200 GigabitEthernet0/8/0.200 static}
486  * Example of how to add a filter such that a packet with the given MAC
487  * Address will be dropped in a given bridge-domain (where 200 is the
488  * bridge-domain-id):
489  * @cliexcmd{l2fib add 52:54:00:53:18:77 200 filter}
490  * Example of show command of the provisioned MAC Addresses and filters:
491  * @cliexstart{show l2fib verbose}
492  * Mac Address BD Idx Interface Index static filter bvi refresh timestamp
493  * 52:54:00:53:18:33 1 GigabitEthernet0/8/0.200 3 0 0 0 0 0
494  * 52:54:00:53:18:55 1 GigabitEthernet0/8/0.200 3 1 0 0 0 0
495  * 52:54:00:53:18:77 1 N/A -1 1 1 0 0 0
496  * 3 l2fib entries
497  * @cliexend
498 ?*/
499 /* *INDENT-OFF* */
500 VLIB_CLI_COMMAND (l2fib_add_cli, static) = {
501  .path = "l2fib add",
502  .short_help = "l2fib add <mac> <bridge-domain-id> filter | <intf> [static | bvi]",
503  .function = l2fib_add,
504 };
505 /* *INDENT-ON* */
506 
507 
508 static clib_error_t *
510  unformat_input_t * input, vlib_cli_command_t * cmd)
511 {
512  clib_error_t *error = 0;
513  u8 mac[6], save_mac[6];
514  u32 bd_index = 0;
515  u32 sw_if_index = 8;
516  u32 bvi_mac = 0;
517  u32 is_add = 0;
518  u32 is_del = 0;
519  u32 is_check = 0;
520  u32 count = 1;
521  int mac_set = 0;
522  int i;
523 
525  {
526  if (unformat (input, "mac %U", unformat_ethernet_address, mac))
527  mac_set = 1;
528  else if (unformat (input, "add"))
529  is_add = 1;
530  else if (unformat (input, "del"))
531  is_del = 1;
532  else if (unformat (input, "check"))
533  is_check = 1;
534  else if (unformat (input, "count %d", &count))
535  ;
536  else
537  break;
538  }
539 
540  if (mac_set == 0)
541  return clib_error_return (0, "mac not set");
542 
543  if (is_add == 0 && is_del == 0 && is_check == 0)
544  return clib_error_return (0,
545  "noop: pick at least one of (add,del,check)");
546 
547  clib_memcpy (save_mac, mac, 6);
548 
549  if (is_add)
550  {
551  for (i = 0; i < count; i++)
552  {
553  l2fib_add_fwd_entry (mac, bd_index, sw_if_index, *mac, bvi_mac);
554  incr_mac_address (mac);
555  }
556  }
557 
558  if (is_check)
559  {
560  BVT (clib_bihash_kv) kv;
561  l2fib_main_t *mp = &l2fib_main;
562 
563  clib_memcpy (mac, save_mac, 6);
564 
565  for (i = 0; i < count; i++)
566  {
567  kv.key = l2fib_make_key (mac, bd_index);
568  if (BV (clib_bihash_search) (&mp->mac_table, &kv, &kv))
569  {
570  clib_warning ("key %U AWOL", format_ethernet_address, mac);
571  break;
572  }
573  incr_mac_address (mac);
574  }
575  }
576 
577  if (is_del)
578  {
579  clib_memcpy (mac, save_mac, 6);
580 
581  for (i = 0; i < count; i++)
582  {
583  l2fib_del_entry (mac, bd_index);
584  incr_mac_address (mac);
585  }
586  }
587 
588  return error;
589 }
590 
591 /*?
592  * The set of '<em>test l2fib</em>' commands allow the L2 FIB table of the default
593  * bridge domain (bridge-domain-id of 0) to be modified.
594  *
595  * @cliexpar
596  * @parblock
597  * Example of how to add a set of 4 sequential MAC Address entries to L2
598  * FIB table of the default bridge-domain:
599  * @cliexcmd{test l2fib add mac 52:54:00:53:00:00 count 4}
600  *
601  * Show the set of 4 sequential MAC Address entries that were added:
602  * @cliexstart{show l2fib verbose}
603  * Mac Address BD Idx Interface Index static filter bvi refresh timestamp
604  * 52:54:00:53:00:00 0 GigabitEthernet0/8/0.300 8 0 0 0 0 0
605  * 52:54:00:53:00:01 0 GigabitEthernet0/8/0.300 8 0 0 0 0 0
606  * 52:54:00:53:00:03 0 GigabitEthernet0/8/0.300 8 0 0 0 0 0
607  * 52:54:00:53:00:02 0 GigabitEthernet0/8/0.300 8 0 0 0 0 0
608  * 4 l2fib entries
609  * @cliexend
610  *
611  * Example of how to check that the set of 4 sequential MAC Address
612  * entries were added to L2 FIB table of the default
613  * bridge-domain. Used a count of 5 to produce an error:
614  *
615  * @cliexcmd{test l2fib check mac 52:54:00:53:00:00 count 5}
616  * The output of the check command is in the log files. Log file
617  * location may vary based on your OS and Version:
618  *
619  * <b><em># tail -f /var/log/messages | grep l2fib_test_command_fn</em></b>
620  *
621  * Sep 7 17:15:24 localhost vnet[4952]: l2fib_test_command_fn:446: key 52:54:00:53:00:04 AWOL
622  *
623  * Example of how to delete a set of 4 sequential MAC Address entries
624  * from L2 FIB table of the default bridge-domain:
625  * @cliexcmd{test l2fib del mac 52:54:00:53:00:00 count 4}
626  * @endparblock
627 ?*/
628 /* *INDENT-OFF* */
629 VLIB_CLI_COMMAND (l2fib_test_command, static) = {
630  .path = "test l2fib",
631  .short_help = "test l2fib [add|del|check] mac <base-addr> count <nn>",
632  .function = l2fib_test_command_fn,
633 };
634 /* *INDENT-ON* */
635 
636 
637 /**
638  * Delete an entry from the l2fib.
639  * Return 0 if the entry was deleted, or 1 if it was not found
640  */
641 static u32
643 {
644 
645  l2fib_entry_result_t result;
646  l2fib_main_t *mp = &l2fib_main;
647  BVT (clib_bihash_kv) kv;
648 
649  /* set up key */
650  kv.key = raw_key;
651 
652  if (BV (clib_bihash_search) (&mp->mac_table, &kv, &kv))
653  return 1;
654 
655  result.raw = kv.value;
656 
657  /* decrement counter if dynamically learned mac */
658  if ((result.fields.age_not == 0) && (l2learn_main.global_learn_count))
660 
661  /* Remove entry from hash table */
662  BV (clib_bihash_add_del) (&mp->mac_table, &kv, 0 /* is_add */ );
663  return 0;
664 }
665 
666 /**
667  * Delete an entry from the l2fib.
668  * Return 0 if the entry was deleted, or 1 if it was not found
669  */
670 u32
671 l2fib_del_entry (u8 * mac, u32 bd_index)
672 {
673  return l2fib_del_entry_by_key (l2fib_make_key (mac, bd_index));
674 }
675 
676 /**
677  * Delete an entry from the L2FIB.
678  * The CLI format is:
679  * l2fib del <mac> <bd-id>
680  */
681 static clib_error_t *
683  unformat_input_t * input, vlib_cli_command_t * cmd)
684 {
685  bd_main_t *bdm = &bd_main;
686  clib_error_t *error = 0;
687  u8 mac[6];
688  u32 bd_id;
689  u32 bd_index;
690  uword *p;
691 
692  if (!unformat (input, "%U", unformat_ethernet_address, mac))
693  {
694  error = clib_error_return (0, "expected mac address `%U'",
695  format_unformat_error, input);
696  goto done;
697  }
698 
699  if (!unformat (input, "%d", &bd_id))
700  {
701  error = clib_error_return (0, "expected bridge domain ID `%U'",
702  format_unformat_error, input);
703  goto done;
704  }
705 
706  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
707  if (!p)
708  {
709  error = clib_error_return (0, "bridge domain ID %d invalid", bd_id);
710  goto done;
711  }
712  bd_index = p[0];
713 
714  /* Delete the entry */
715  if (l2fib_del_entry (mac, bd_index))
716  {
717  error = clib_error_return (0, "mac entry not found");
718  goto done;
719  }
720 
721 done:
722  return error;
723 }
724 
725 /*?
726  * This command deletes an existing MAC Address entry from the L2 FIB
727  * table of an existing bridge-domain.
728  *
729  * @cliexpar
730  * Example of how to delete a MAC Address entry from the L2 FIB table of a bridge-domain (where 200 is the bridge-domain-id):
731  * @cliexcmd{l2fib del 52:54:00:53:18:33 200}
732 ?*/
733 /* *INDENT-OFF* */
734 VLIB_CLI_COMMAND (l2fib_del_cli, static) = {
735  .path = "l2fib del",
736  .short_help = "l2fib del <mac> <bridge-domain-id>",
737  .function = l2fib_del,
738 };
739 /* *INDENT-ON* */
740 
741 /**
742  Kick off ager to scan MACs to age/delete MAC entries
743 */
744 void
746 {
748 
749  /* check if there is at least one bd with mac aging enabled */
750  l2_bridge_domain_t *bd_config;
751  vec_foreach (bd_config, l2input_main.bd_configs)
752  {
753  if (bd_config->bd_id != ~0 && bd_config->mac_age != 0)
754  {
756  break;
757  }
758  }
759 
761  evt, 0);
762 }
763 
764 /**
765  Flush all non static MACs from an interface
766 */
767 void
769 {
770  *l2fib_swif_seq_num (sw_if_index) += 1;
772 }
773 
774 /**
775  Flush all non static MACs in a bridge domain
776 */
777 void
779 {
780  l2_bridge_domain_t *bd_config = l2input_bd_config (bd_index);
781  bd_config->seq_num += 1;
783 }
784 
785 /**
786  Flush all non static MACs - flushes all valid BDs
787 */
788 void
790 {
791  l2_bridge_domain_t *bd_config;
792  vec_foreach (bd_config, l2input_main.bd_configs)
793  if (bd_is_valid (bd_config))
794  bd_config->seq_num += 1;
795 
797 }
798 
799 
800 /**
801  Flush MACs, except static ones, associated with an interface
802  The CLI format is:
803  l2fib flush-mac interface <if-name>
804 */
805 static clib_error_t *
807  unformat_input_t * input, vlib_cli_command_t * cmd)
808 {
809  vnet_main_t *vnm = vnet_get_main ();
810  clib_error_t *error = 0;
811  u32 sw_if_index;
812 
813  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
814  {
815  error = clib_error_return (0, "unknown interface `%U'",
816  format_unformat_error, input);
817  goto done;
818  }
819 
820  l2fib_flush_int_mac (vm, sw_if_index);
821 
822 done:
823  return error;
824 }
825 
826 /**
827  Flush all MACs, except static ones
828  The CLI format is:
829  l2fib flush-mac all
830 */
831 static clib_error_t *
833  unformat_input_t * input, vlib_cli_command_t * cmd)
834 {
835  l2fib_flush_all_mac (vm);
836  return 0;
837 }
838 
839 /*?
840  * This command kick off ager to delete all existing MAC Address entries,
841  * except static ones, associated with an interface from the L2 FIB table.
842  *
843  * @cliexpar
844  * Example of how to flush MAC Address entries learned on an interface from the L2 FIB table:
845  * @cliexcmd{l2fib flush-mac interface GigabitEthernet2/1/0}
846 ?*/
847 /* *INDENT-OFF* */
848 VLIB_CLI_COMMAND (l2fib_flush_mac_all_cli, static) = {
849  .path = "l2fib flush-mac all",
850  .short_help = "l2fib flush-mac all",
851  .function = l2fib_flush_mac_all,
852 };
853 /* *INDENT-ON* */
854 
855 /*?
856  * This command kick off ager to delete all existing MAC Address entries,
857  * except static ones, associated with an interface from the L2 FIB table.
858  *
859  * @cliexpar
860  * Example of how to flush MAC Address entries learned on an interface from the L2 FIB table:
861  * @cliexcmd{l2fib flush-mac interface GigabitEthernet2/1/0}
862 ?*/
863 /* *INDENT-OFF* */
864 VLIB_CLI_COMMAND (l2fib_flush_mac_int_cli, static) = {
865  .path = "l2fib flush-mac interface",
866  .short_help = "l2fib flush-mac interface <if-name>",
867  .function = l2fib_flush_mac_int,
868 };
869 /* *INDENT-ON* */
870 
871 /**
872  Flush bridge-domain MACs except static ones.
873  The CLI format is:
874  l2fib flush-mac bridge-domain <bd-id>
875 */
876 static clib_error_t *
878  unformat_input_t * input, vlib_cli_command_t * cmd)
879 {
880  bd_main_t *bdm = &bd_main;
881  clib_error_t *error = 0;
882  u32 bd_index, bd_id;
883  uword *p;
884 
885  if (!unformat (input, "%d", &bd_id))
886  {
887  error = clib_error_return (0, "expecting bridge-domain id but got `%U'",
888  format_unformat_error, input);
889  goto done;
890  }
891 
892  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
893  if (p)
894  bd_index = *p;
895  else
896  return clib_error_return (0, "No such bridge domain %d", bd_id);
897 
898  l2fib_flush_bd_mac (vm, bd_index);
899 
900 done:
901  return error;
902 }
903 
904 /*?
905  * This command kick off ager to delete all existing MAC Address entries,
906  * except static ones, in a bridge domain from the L2 FIB table.
907  *
908  * @cliexpar
909  * Example of how to flush MAC Address entries learned in a bridge domain from the L2 FIB table:
910  * @cliexcmd{l2fib flush-mac bridge-domain 1000}
911 ?*/
912 /* *INDENT-OFF* */
913 VLIB_CLI_COMMAND (l2fib_flush_mac_bd_cli, static) = {
914  .path = "l2fib flush-mac bridge-domain",
915  .short_help = "l2fib flush-mac bridge-domain <bd-id>",
916  .function = l2fib_flush_mac_bd,
917 };
918 /* *INDENT-ON* */
919 
920 clib_error_t *
922 {
923  l2_input_config_t *config = l2input_intf_config (sw_if_index);
924  if ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) == 0 && config->bridge)
925  l2fib_flush_int_mac (vnm->vlib_main, sw_if_index);
926  return 0;
927 }
928 
930 
931 BVT (clib_bihash) * get_mac_table (void)
932 {
933  l2fib_main_t *mp = &l2fib_main;
934  return &mp->mac_table;
935 }
936 
938 allocate_mac_evt_buf (u32 client, u32 client_index)
939 {
940  l2fib_main_t *fm = &l2fib_main;
942  (sizeof (*mp) + (fm->max_macs_in_event * sizeof (vl_api_mac_entry_t)));
943  mp->_vl_msg_id = htons (VL_API_L2_MACS_EVENT);
944  mp->pid = htonl (client);
945  mp->client_index = client_index;
946  return mp;
947 }
948 
950 l2fib_scan (vlib_main_t * vm, f64 start_time, u8 event_only)
951 {
952  l2fib_main_t *fm = &l2fib_main;
954 
955  BVT (clib_bihash) * h = &fm->mac_table;
956  int i, j, k;
957  f64 last_start = start_time;
958  f64 accum_t = 0;
959  f64 delta_t = 0;
960  u32 evt_idx = 0;
961  u32 learn_count = 0;
962  u32 client = lm->client_pid;
963  u32 cl_idx = lm->client_index;
964  vl_api_l2_macs_event_t *mp = 0;
966 
967  if (client)
968  {
969  mp = allocate_mac_evt_buf (client, cl_idx);
971  }
972 
973  for (i = 0; i < h->nbuckets; i++)
974  {
975  /* allow no more than 20us without a pause */
976  delta_t = vlib_time_now (vm) - last_start;
977  if (delta_t > 20e-6)
978  {
979  vlib_process_suspend (vm, 100e-6); /* suspend for 100 us */
980  last_start = vlib_time_now (vm);
981  accum_t += delta_t;
982  }
983 
984  if (i < (h->nbuckets - 3))
985  {
986  BVT (clib_bihash_bucket) * b = &h->buckets[i + 3];
988  b = &h->buckets[i + 1];
989  if (b->offset)
990  {
991  BVT (clib_bihash_value) * v =
992  BV (clib_bihash_get_value) (h, b->offset);
994  }
995  }
996 
997  BVT (clib_bihash_bucket) * b = &h->buckets[i];
998  if (b->offset == 0)
999  continue;
1000  BVT (clib_bihash_value) * v = BV (clib_bihash_get_value) (h, b->offset);
1001  for (j = 0; j < (1 << b->log2_pages); j++)
1002  {
1003  for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
1004  {
1005  if (v->kvp[k].key == ~0ULL && v->kvp[k].value == ~0ULL)
1006  continue;
1007 
1008  l2fib_entry_key_t key = {.raw = v->kvp[k].key };
1009  l2fib_entry_result_t result = {.raw = v->kvp[k].value };
1010 
1011  if (result.fields.age_not == 0)
1012  learn_count++;
1013 
1014  if (client)
1015  {
1016  if (PREDICT_FALSE (evt_idx >= fm->max_macs_in_event))
1017  {
1018  /* event message full, send it and start a new one */
1019  if (q && (q->cursize < q->maxsize))
1020  {
1021  mp->n_macs = htonl (evt_idx);
1022  vl_msg_api_send_shmem (q, (u8 *) & mp);
1023  mp = allocate_mac_evt_buf (client, cl_idx);
1024  }
1025  else
1026  {
1027  if (q)
1028  clib_warning ("MAC event to pid %d queue stuffed!"
1029  " %d MAC entries lost", client,
1030  evt_idx);
1031  }
1032  evt_idx = 0;
1033  }
1034 
1035  if (result.fields.lrn_evt)
1036  {
1037  /* copy mac entry to event msg */
1038  clib_memcpy (mp->mac[evt_idx].mac_addr, key.fields.mac,
1039  6);
1040  mp->mac[evt_idx].is_del = 0;
1041  mp->mac[evt_idx].sw_if_index =
1042  htonl (result.fields.sw_if_index);
1043  /* clear event bit and update mac entry */
1044  result.fields.lrn_evt = 0;
1045  BVT (clib_bihash_kv) kv;
1046  kv.key = key.raw;
1047  kv.value = result.raw;
1048  BV (clib_bihash_add_del) (&fm->mac_table, &kv, 1);
1049  evt_idx++;
1050  continue; /* skip aging */
1051  }
1052  }
1053 
1054  if (event_only || result.fields.age_not)
1055  continue; /* skip aging - static_mac alsways age_not */
1056 
1057  /* start aging processing */
1058  u32 bd_index = key.fields.bd_index;
1059  u32 sw_if_index = result.fields.sw_if_index;
1060  u16 sn = l2fib_cur_seq_num (bd_index, sw_if_index).as_u16;
1061  if (result.fields.sn.as_u16 != sn)
1062  goto age_out; /* stale mac */
1063 
1064  l2_bridge_domain_t *bd_config =
1066 
1067  if (bd_config->mac_age == 0)
1068  continue; /* skip aging */
1069 
1070  i16 delta = (u8) (start_time / 60) - result.fields.timestamp;
1071  delta += delta < 0 ? 256 : 0;
1072 
1073  if (delta < bd_config->mac_age)
1074  continue; /* still valid */
1075 
1076  age_out:
1077  if (client)
1078  {
1079  /* copy mac entry to event msg */
1080  clib_memcpy (mp->mac[evt_idx].mac_addr, key.fields.mac, 6);
1081  mp->mac[evt_idx].is_del = 1;
1082  mp->mac[evt_idx].sw_if_index =
1083  htonl (result.fields.sw_if_index);
1084  evt_idx++;
1085  }
1086  /* delete mac entry */
1087  BVT (clib_bihash_kv) kv;
1088  kv.key = key.raw;
1089  BV (clib_bihash_add_del) (&fm->mac_table, &kv, 0);
1090  learn_count--;
1091  }
1092  v++;
1093  }
1094  }
1095 
1096  /* keep learn count consistent */
1097  l2learn_main.global_learn_count = learn_count;
1098 
1099  if (mp)
1100  {
1101  /* send any outstanding mac event message else free message buffer */
1102  if (evt_idx)
1103  {
1104  if (q && (q->cursize < q->maxsize))
1105  {
1106  mp->n_macs = htonl (evt_idx);
1107  vl_msg_api_send_shmem (q, (u8 *) & mp);
1108  }
1109  else
1110  {
1111  if (q)
1112  clib_warning ("MAC event to pid %d queue stuffed!"
1113  " %d MAC entries lost", client, evt_idx);
1114  vl_msg_api_free (mp);
1115  }
1116  }
1117  else
1118  vl_msg_api_free (mp);
1119  }
1120  return delta_t + accum_t;
1121 }
1122 
1123 /* Maximum f64 value */
1124 #define TIME_MAX (1.7976931348623157e+308)
1125 
1126 static uword
1128  vlib_frame_t * f)
1129 {
1130  uword event_type, *event_data = 0;
1131  l2fib_main_t *fm = &l2fib_main;
1133  bool enabled = 0;
1134  f64 start_time, next_age_scan_time = TIME_MAX;
1135 
1136  while (1)
1137  {
1138  if (lm->client_pid)
1140  else if (enabled)
1141  {
1142  f64 t = next_age_scan_time - vlib_time_now (vm);
1144  }
1145  else
1147 
1148  event_type = vlib_process_get_events (vm, &event_data);
1149  vec_reset_length (event_data);
1150 
1151  start_time = vlib_time_now (vm);
1152  enum
1153  { SCAN_MAC_AGE, SCAN_MAC_EVENT, SCAN_DISABLE } scan = SCAN_MAC_AGE;
1154 
1155  switch (event_type)
1156  {
1157  case ~0: /* timer expired */
1158  if (lm->client_pid != 0 && start_time < next_age_scan_time)
1159  scan = SCAN_MAC_EVENT;
1160  break;
1161 
1163  enabled = 1;
1164  break;
1165 
1167  enabled = 0;
1168  scan = SCAN_DISABLE;
1169  break;
1170 
1172  break;
1173 
1174  default:
1175  ASSERT (0);
1176  }
1177 
1178  if (scan == SCAN_MAC_EVENT)
1179  l2fib_main.evt_scan_duration = l2fib_scan (vm, start_time, 1);
1180  else
1181  {
1182  if (scan == SCAN_MAC_AGE)
1183  l2fib_main.age_scan_duration = l2fib_scan (vm, start_time, 0);
1184  if (scan == SCAN_DISABLE)
1185  {
1186  l2fib_main.age_scan_duration = 0;
1187  l2fib_main.evt_scan_duration = 0;
1188  }
1189  /* schedule next scan */
1190  if (enabled)
1191  next_age_scan_time = start_time + L2FIB_AGE_SCAN_INTERVAL;
1192  else
1193  next_age_scan_time = TIME_MAX;
1194  }
1195  }
1196  return 0;
1197 }
1198 
1199 /* *INDENT-OFF* */
1201  .function = l2fib_mac_age_scanner_process,
1202  .type = VLIB_NODE_TYPE_PROCESS,
1203  .name = "l2fib-mac-age-scanner-process",
1204 };
1205 /* *INDENT-ON* */
1206 
1207 clib_error_t *
1209 {
1210  l2fib_main_t *mp = &l2fib_main;
1211  l2fib_entry_key_t test_key;
1212  u8 test_mac[6];
1213 
1214  mp->vlib_main = vm;
1215  mp->vnet_main = vnet_get_main ();
1216 
1217  /* Create the hash table */
1218  BV (clib_bihash_init) (&mp->mac_table, "l2fib mac table",
1220 
1221  /* verify the key constructor is good, since it is endian-sensitive */
1222  memset (test_mac, 0, sizeof (test_mac));
1223  test_mac[0] = 0x11;
1224  test_key.raw = 0;
1225  test_key.raw = l2fib_make_key ((u8 *) & test_mac, 0x1234);
1226  ASSERT (test_key.fields.mac[0] == 0x11);
1227  ASSERT (test_key.fields.bd_index == 0x1234);
1228 
1229  return 0;
1230 }
1231 
1233 
1234 /*
1235  * fd.io coding-style-patch-verification: ON
1236  *
1237  * Local Variables:
1238  * eval: (c-set-style "gnu")
1239  * End:
1240  */
static_always_inline void * allocate_mac_evt_buf(u32 client, u32 client_index)
Definition: l2_fib.c:938
f64 evt_scan_duration
Definition: l2_fib.h:52
static clib_error_t * l2fib_test_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: l2_fib.c:509
u32 global_learn_count
Definition: l2_learn.h:32
l2_input_config_t * configs
Definition: l2_input.h:66
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
u8 * format_vnet_sw_if_index_name_with_NA(u8 *s, va_list *args)
Format sw_if_index.
Definition: l2_fib.c:70
vlib_main_t * vlib_main
Definition: l2_fib.h:62
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
Definition: node_funcs.h:699
#define BIHASH_KVP_PER_PAGE
Definition: bihash_16_8.h:20
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
Definition: node_funcs.h:619
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
vnet_main_t * vnet_main
Definition: l2_fib.h:63
void clib_bihash_free(clib_bihash *h)
Destroy a bounded index extensible hash table.
l2_input_config_t * l2input_intf_config(u32 sw_if_index)
Get a pointer to the config for the given interface.
Definition: l2_input.c:524
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:224
clib_error_t * l2fib_init(vlib_main_t *vm)
Definition: l2_fib.c:1208
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:518
static_always_inline u8 * l2fib_swif_seq_num(u32 sw_if_index)
Definition: l2_fib.h:413
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
#define L2FIB_MEMORY_SIZE
Definition: l2_fib.h:28
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
unformat_function_t unformat_vnet_sw_interface
u32 max_macs_in_event
Definition: l2_fib.h:59
Definition: l2_fib.h:108
static clib_error_t * l2fib_del(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Delete an entry from the L2FIB.
Definition: l2_fib.c:682
u32 client_index
Definition: l2_learn.h:39
Entry for learned or aged MAC in L2 MAC Events.
Definition: l2.api:163
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
Definition: node_funcs.h:448
#define L2FIB_AGE_SCAN_INTERVAL
Definition: l2_fib.h:31
l2learn_main_t l2learn_main
Definition: l2_learn.c:32
#define static_always_inline
Definition: clib.h:93
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
int clib_bihash_add_del(clib_bihash *h, clib_bihash_kv *add_v, int is_add)
Add or delete a (key,value) pair from a bi-hash table.
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:542
void l2fib_add_entry(u8 *mac, u32 bd_index, u32 sw_if_index, u8 static_mac, u8 filter_mac, u8 bvi_mac)
Add an entry to the l2fib.
Definition: l2_fib.c:356
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define clib_error_return(e, args...)
Definition: error.h:99
unsigned long u64
Definition: types.h:89
L2 MAC event for a list of learned or aged MACs.
Definition: l2.api:177
uword * bd_index_by_bd_id
Definition: l2_bd.h:27
void * vl_msg_api_alloc(int nbytes)
u32 sw_if_index
Definition: l2.api:165
void l2fib_start_ager_scan(vlib_main_t *vm)
Kick off ager to scan MACs to age/delete MAC entries.
Definition: l2_fib.c:745
#define hash_get(h, key)
Definition: hash.h:248
f64 event_scan_delay
Definition: l2_fib.h:56
format_function_t format_vnet_sw_interface_name
u8 is_del
Definition: l2.api:167
vlib_main_t * vlib_main
Definition: vnet.h:78
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:950
#define v
Definition: acl.c:341
struct _unformat_input_t unformat_input_t
void vl_msg_api_free(void *)
void l2fib_flush_bd_mac(vlib_main_t *vm, u32 bd_index)
Flush all non static MACs in a bridge domain.
Definition: l2_fib.c:778
#define PREDICT_FALSE(x)
Definition: clib.h:105
void l2fib_flush_all_mac(vlib_main_t *vm)
Flush all non static MACs - flushes all valid BDs.
Definition: l2_fib.c:789
#define L2FIB_NUM_BUCKETS
Definition: l2_fib.h:27
static_always_inline f64 l2fib_scan(vlib_main_t *vm, f64 start_time, u8 event_only)
Definition: l2_fib.c:950
void clib_bihash_init(clib_bihash *h, char *name, u32 nbuckets, uword memory_size)
initialize a bounded index extensible hash table
static void l2fib_add_fwd_entry(u8 *mac, u32 bd_index, u32 sw_if_index, u8 static_mac, u8 bvi_mac)
Definition: l2_fib.h:384
l2fib_main_t l2fib_main
Definition: l2_fib.c:55
u64 raw
Definition: l2_fib.h:126
static u32 bd_is_valid(l2_bridge_domain_t *bd_config)
Definition: l2_bd.h:114
struct l2fib_entry_key_t::@206::@208 fields
static clib_error_t * clear_l2fib(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Clear all entries in L2FIB.
Definition: l2_fib.c:313
BVT(clib_bihash)
Definition: l2_fib.c:931
clib_error_t * l2fib_sw_interface_up_down(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: l2_fib.c:921
static clib_error_t * show_l2fib(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Display the contents of the l2fib.
Definition: l2_fib.c:126
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
static clib_error_t * l2fib_flush_mac_all(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Flush all MACs, except static ones The CLI format is: l2fib flush-mac all.
Definition: l2_fib.c:832
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
vlib_main_t * vm
Definition: buffer.c:283
vec_header_t h
Definition: buffer.c:282
static void incr_mac_address(u8 *mac)
Definition: l2_fib.c:58
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
static clib_error_t * l2fib_flush_mac_int(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Flush MACs, except static ones, associated with an interface The CLI format is: l2fib flush-mac inter...
Definition: l2_fib.c:806
#define clib_warning(format, args...)
Definition: error.h:59
f64 age_scan_duration
Definition: l2_fib.h:53
#define clib_memcpy(a, b, c)
Definition: string.h:75
static vnet_sw_interface_t * vnet_get_sw_interface_safe(vnet_main_t *vnm, u32 sw_if_index)
unix_shared_memory_queue_t * vl_api_client_index_to_input_queue(u32 index)
void l2fib_clear_table(void)
Definition: l2_fib.c:298
static l2fib_seq_num_t l2fib_cur_seq_num(u32 bd_index, u32 sw_if_index)
Definition: l2_fib.c:340
static_always_inline l2_bridge_domain_t * l2input_bd_config(u32 bd_index)
Definition: l2_input.h:90
u8 mac_addr[6]
Definition: l2.api:166
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
struct l2fib_entry_result_t::@214::@216 fields
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:576
void vl_msg_api_send_shmem(unix_shared_memory_queue_t *q, u8 *elem)
uword unformat_ethernet_address(unformat_input_t *input, va_list *args)
Definition: format.c:227
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
int clib_bihash_search(clib_bihash *h, clib_bihash_kv *search_v, clib_bihash_kv *return_v)
Search a bi-hash table.
Definition: l2_fib.h:71
static void l2fib_add_filter_entry(u8 *mac, u32 bd_index)
Definition: l2_fib.h:391
static uword l2fib_mac_age_scanner_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: l2_fib.c:1127
vl_api_mac_entry_t mac[n_macs]
Definition: l2.api:182
size_t count
Definition: vapi.c:42
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(l2fib_sw_interface_up_down)
u32 global_learn_limit
Definition: l2_learn.h:35
#define TIME_MAX
Definition: l2_fib.c:1124
u64 uword
Definition: types.h:112
template key/value backing page structure
Definition: bihash_doc.h:44
static clib_error_t * l2fib_flush_mac_bd(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Flush bridge-domain MACs except static ones.
Definition: l2_fib.c:877
unsigned short u16
Definition: types.h:57
l2input_main_t l2input_main
Definition: l2_input.c:113
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
double f64
Definition: types.h:142
unsigned char u8
Definition: types.h:56
static u64 l2fib_make_key(u8 *mac_address, u16 bd_index)
make address sanitizer skip this: The 6-Bytes mac-address is cast into an 8-Bytes u64...
Definition: l2_fib.h:157
l2_bridge_domain_t * bd_configs
Definition: l2_input.h:69
void l2fib_table_dump(u32 bd_index, l2fib_entry_key_t **l2fe_key, l2fib_entry_result_t **l2fe_res)
Definition: l2_fib.c:86
short i16
Definition: types.h:46
u32 l2fib_del_entry(u8 *mac, u32 bd_index)
Delete an entry from the l2fib.
Definition: l2_fib.c:671
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
#define vec_foreach(var, vec)
Vector iterator.
static void * clib_bihash_get_value(clib_bihash *h, uword offset)
Get pointer to value page given its clib mheap offset.
u32 flags
Definition: vhost-user.h:77
bd_main_t bd_main
Definition: l2_bd.c:44
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
static clib_error_t * l2fib_add(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Add an entry to the L2FIB.
Definition: l2_fib.c:400
vlib_node_registration_t l2fib_mac_age_scanner_process_node
(constructor) VLIB_REGISTER_NODE (l2fib_mac_age_scanner_process_node)
Definition: l2_fib.c:1200
u32 client_pid
Definition: l2_learn.h:38
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
static u32 l2fib_del_entry_by_key(u64 raw_key)
Delete an entry from the l2fib.
Definition: l2_fib.c:642
void l2fib_flush_int_mac(vlib_main_t *vm, u32 sw_if_index)
Flush all non static MACs from an interface.
Definition: l2_fib.c:768
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
u64 raw
Definition: l2_fib.h:85
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
struct _unix_shared_memory_queue unix_shared_memory_queue_t