FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
l2_api.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * l2_api.c - layer 2 forwarding api
4  *
5  * Copyright (c) 2016 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 
20 #include <vnet/vnet.h>
21 #include <vlibmemory/api.h>
22 
23 #include <vnet/interface.h>
24 #include <vnet/api_errno.h>
25 #include <vnet/l2/l2_input.h>
26 #include <vnet/l2/l2_fib.h>
27 #include <vnet/l2/l2_vtr.h>
28 #include <vnet/l2/l2_learn.h>
29 #include <vnet/l2/l2_bd.h>
30 #include <vnet/l2/l2_bvi.h>
31 #include <vnet/l2/l2_arp_term.h>
32 #include <vnet/ip/ip_types_api.h>
34 
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 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
46 #define vl_api_bridge_domain_details_t_print vl_noop_handler
47 
48 /* instantiate all the print functions we know about */
49 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
50 #define vl_printfun
51 #include <vnet/vnet_all_api_h.h>
52 #undef vl_printfun
53 
55 
56 #define foreach_vpe_api_msg \
57 _(L2_XCONNECT_DUMP, l2_xconnect_dump) \
58 _(L2_FIB_CLEAR_TABLE, l2_fib_clear_table) \
59 _(L2_FIB_TABLE_DUMP, l2_fib_table_dump) \
60 _(L2FIB_FLUSH_ALL, l2fib_flush_all) \
61 _(L2FIB_FLUSH_INT, l2fib_flush_int) \
62 _(L2FIB_FLUSH_BD, l2fib_flush_bd) \
63 _(L2FIB_ADD_DEL, l2fib_add_del) \
64 _(WANT_L2_MACS_EVENTS, want_l2_macs_events) \
65 _(L2_FLAGS, l2_flags) \
66 _(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect) \
67 _(SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge) \
68 _(L2_PATCH_ADD_DEL, l2_patch_add_del) \
69 _(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter) \
70 _(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del) \
71 _(BD_IP_MAC_FLUSH, bd_ip_mac_flush) \
72 _(BD_IP_MAC_DUMP, bd_ip_mac_dump) \
73 _(BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del) \
74 _(BRIDGE_DOMAIN_DUMP, bridge_domain_dump) \
75 _(BRIDGE_FLAGS, bridge_flags) \
76 _(L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite) \
77 _(L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite) \
78 _(BRIDGE_DOMAIN_SET_MAC_AGE, bridge_domain_set_mac_age) \
79 _(SW_INTERFACE_SET_VPATH, sw_interface_set_vpath) \
80 _(BVI_CREATE, bvi_create) \
81 _(BVI_DELETE, bvi_delete) \
82 _(WANT_L2_ARP_TERM_EVENTS, want_l2_arp_term_events)
83 
84 static void
86  u32 rx_sw_if_index, u32 tx_sw_if_index)
87 {
89 
90  mp = vl_msg_api_alloc (sizeof (*mp));
91  clib_memset (mp, 0, sizeof (*mp));
92  mp->_vl_msg_id = ntohs (VL_API_L2_XCONNECT_DETAILS);
93  mp->context = context;
94  mp->rx_sw_if_index = htonl (rx_sw_if_index);
95  mp->tx_sw_if_index = htonl (tx_sw_if_index);
96 
97  vl_api_send_msg (reg, (u8 *) mp);
98 }
99 
100 static void
102 {
104  vnet_main_t *vnm = vnet_get_main ();
106  l2input_main_t *l2im = &l2input_main;
107  vnet_sw_interface_t *swif;
108  l2_input_config_t *config;
109 
111  if (!reg)
112  return;
113 
114  /* *INDENT-OFF* */
115  pool_foreach (swif, im->sw_interfaces,
116  ({
117  config = vec_elt_at_index (l2im->configs, swif->sw_if_index);
118  if (config->xconnect)
119  send_l2_xconnect_details (reg, mp->context, swif->sw_if_index,
120  config->output_sw_if_index);
121  }));
122  /* *INDENT-ON* */
123 }
124 
125 static void
127 {
128  int rv = 0;
129  vl_api_l2_fib_clear_table_reply_t *rmp;
130 
131  /* Clear all MACs including static MACs */
133 
134  REPLY_MACRO (VL_API_L2_FIB_CLEAR_TABLE_REPLY);
135 }
136 
137 static void
139  vl_api_registration_t * reg,
140  l2fib_entry_key_t * l2fe_key,
141  l2fib_entry_result_t * l2fe_res, u32 context)
142 {
144 
145  mp = vl_msg_api_alloc (sizeof (*mp));
146  clib_memset (mp, 0, sizeof (*mp));
147  mp->_vl_msg_id = ntohs (VL_API_L2_FIB_TABLE_DETAILS);
148 
149  mp->bd_id =
150  ntohl (l2input_main.bd_configs[l2fe_key->fields.bd_index].bd_id);
151 
152  mac_address_encode ((mac_address_t *) l2fe_key->fields.mac, mp->mac);
153  mp->sw_if_index = ntohl (l2fe_res->fields.sw_if_index);
154  mp->static_mac = (l2fib_entry_result_is_set_STATIC (l2fe_res) ? 1 : 0);
155  mp->filter_mac = (l2fib_entry_result_is_set_FILTER (l2fe_res) ? 1 : 0);
156  mp->bvi_mac = (l2fib_entry_result_is_set_BVI (l2fe_res) ? 1 : 0);
157  mp->context = context;
158 
159  vl_api_send_msg (reg, (u8 *) mp);
160 }
161 
162 static void
164 {
166  bd_main_t *bdm = &bd_main;
167  l2fib_entry_key_t *l2fe_key = NULL;
168  l2fib_entry_result_t *l2fe_res = NULL;
169  u32 ni, bd_id = ntohl (mp->bd_id);
170  u32 bd_index;
172  uword *p;
173 
175  if (!reg)
176  return;
177 
178  /* see l2fib_table_dump: ~0 means "any" */
179  if (bd_id == ~0)
180  bd_index = ~0;
181  else
182  {
183  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
184  if (p == 0)
185  return;
186 
187  bd_index = p[0];
188  }
189 
190  l2fib_table_dump (bd_index, &l2fe_key, &l2fe_res);
191 
192  vec_foreach_index (ni, l2fe_key)
193  {
194  send_l2fib_table_entry (am, reg, vec_elt_at_index (l2fe_key, ni),
195  vec_elt_at_index (l2fe_res, ni), mp->context);
196  }
197  vec_free (l2fe_key);
198  vec_free (l2fe_res);
199 }
200 
201 static void
203 {
204  bd_main_t *bdm = &bd_main;
205  l2input_main_t *l2im = &l2input_main;
206  vl_api_l2fib_add_del_reply_t *rmp;
207  int rv = 0;
208  u32 bd_id = ntohl (mp->bd_id);
209  uword *p = hash_get (bdm->bd_index_by_bd_id, bd_id);
210 
211  if (!p)
212  {
213  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
214  goto bad_sw_if_index;
215  }
216  u32 bd_index = p[0];
217 
219 
220  mac_address_decode (mp->mac, &mac);
221  if (mp->is_add)
222  {
223  if (mp->filter_mac)
224  l2fib_add_filter_entry (mac.bytes, bd_index);
225  else
226  {
228  u32 sw_if_index = ntohl (mp->sw_if_index);
230  if (vec_len (l2im->configs) <= sw_if_index)
231  {
232  rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
233  goto bad_sw_if_index;
234  }
235  else
236  {
237  l2_input_config_t *config;
238  config = vec_elt_at_index (l2im->configs, sw_if_index);
239  if (config->bridge == 0)
240  {
241  rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
242  goto bad_sw_if_index;
243  }
244  }
245  if (mp->static_mac)
246  flags |= L2FIB_ENTRY_RESULT_FLAG_STATIC;
247  if (mp->bvi_mac)
248  flags |= L2FIB_ENTRY_RESULT_FLAG_BVI;
249  l2fib_add_entry (mac.bytes, bd_index, sw_if_index, flags);
250  }
251  }
252  else
253  {
254  u32 sw_if_index = ntohl (mp->sw_if_index);
255  if (l2fib_del_entry (mac.bytes, bd_index, sw_if_index))
256  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
257  }
258 
260 
261  REPLY_MACRO (VL_API_L2FIB_ADD_DEL_REPLY);
262 }
263 
264 static void
266 {
267  int rv = 0;
268  vl_api_want_l2_macs_events_reply_t *rmp;
271  u32 pid = ntohl (mp->pid);
272  u32 learn_limit = ntohl (mp->learn_limit);
273 
274  if (mp->enable_disable)
275  {
276  if (lm->client_pid == 0)
277  {
278  lm->client_pid = pid;
279  lm->client_index = mp->client_index;
280 
281  if (mp->max_macs_in_event)
282  fm->max_macs_in_event = mp->max_macs_in_event * 10;
283  else
284  {
285  rv = VNET_API_ERROR_INVALID_VALUE;
286  goto exit;
287  }
288 
289  if (mp->scan_delay)
290  fm->event_scan_delay = (f64) (mp->scan_delay) * 10e-3;
291  else
292  {
293  rv = VNET_API_ERROR_INVALID_VALUE;
294  goto exit;
295  }
296 
297  /* change learn limit and flush all learned MACs */
298  if (learn_limit && (learn_limit < L2LEARN_DEFAULT_LIMIT))
299  lm->global_learn_limit = learn_limit;
300  else
301  {
302  rv = VNET_API_ERROR_INVALID_VALUE;
303  goto exit;
304  }
305 
307  }
308  else if (lm->client_pid != pid)
309  {
310  rv = VNET_API_ERROR_L2_MACS_EVENT_CLINET_PRESENT;
311  goto exit;
312  }
313  }
314  else if (lm->client_pid)
315  {
316  lm->client_pid = 0;
317  lm->client_index = 0;
318  if (learn_limit && (learn_limit < L2LEARN_DEFAULT_LIMIT))
319  lm->global_learn_limit = learn_limit;
320  else
321  lm->global_learn_limit = L2LEARN_DEFAULT_LIMIT;
322  }
323 
324 exit:
325  REPLY_MACRO (VL_API_WANT_L2_MACS_EVENTS_REPLY);
326 }
327 
328 static void
330 {
331  int rv = 0;
333  vl_api_l2fib_flush_int_reply_t *rmp;
334 
336 
337  u32 sw_if_index = ntohl (mp->sw_if_index);
338  l2fib_flush_int_mac (vm, sw_if_index);
339 
341  REPLY_MACRO (VL_API_L2FIB_FLUSH_INT_REPLY);
342 }
343 
344 static void
346 {
347  int rv = 0;
348  vl_api_l2fib_flush_all_reply_t *rmp;
349 
351  REPLY_MACRO (VL_API_L2FIB_FLUSH_ALL_REPLY);
352 }
353 
354 static void
356 {
357  int rv = 0;
359  bd_main_t *bdm = &bd_main;
360  vl_api_l2fib_flush_bd_reply_t *rmp;
361 
362  u32 bd_id = ntohl (mp->bd_id);
363  uword *p = hash_get (bdm->bd_index_by_bd_id, bd_id);
364  if (p == 0)
365  {
366  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
367  goto out;
368  }
369  l2fib_flush_bd_mac (vm, *p);
370 out:
371  REPLY_MACRO (VL_API_L2FIB_FLUSH_BD_REPLY);
372 }
373 
374 static void
376 {
378  int rv = 0;
379  u32 rbm = 0;
380 
382 
383  u32 sw_if_index = ntohl (mp->sw_if_index);
384  u32 flags = ntohl (mp->feature_bitmap);
385  u32 bitmap = 0;
386 
387  if (flags & L2_LEARN)
388  bitmap |= L2INPUT_FEAT_LEARN;
389 
390  if (flags & L2_FWD)
391  bitmap |= L2INPUT_FEAT_FWD;
392 
393  if (flags & L2_FLOOD)
394  bitmap |= L2INPUT_FEAT_FLOOD;
395 
396  if (flags & L2_UU_FLOOD)
397  bitmap |= L2INPUT_FEAT_UU_FLOOD;
398 
399  if (flags & L2_ARP_TERM)
400  bitmap |= L2INPUT_FEAT_ARP_TERM;
401 
402  rbm = l2input_intf_bitmap_enable (sw_if_index, bitmap, mp->is_set);
403 
405 
406  /* *INDENT-OFF* */
407  REPLY_MACRO2(VL_API_L2_FLAGS_REPLY,
408  ({
409  rmp->resulting_feature_bitmap = ntohl(rbm);
410  }));
411  /* *INDENT-ON* */
412 }
413 
414 static void
416  * mp)
417 {
419  bd_main_t *bdm = &bd_main;
420  vl_api_bridge_domain_set_mac_age_reply_t *rmp;
421  int rv = 0;
422  u32 bd_id = ntohl (mp->bd_id);
423  uword *p;
424 
425  if (bd_id == 0)
426  {
427  rv = VNET_API_ERROR_BD_NOT_MODIFIABLE;
428  goto out;
429  }
430 
431  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
432  if (p == 0)
433  {
434  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
435  goto out;
436  }
437  bd_set_mac_age (vm, *p, mp->mac_age);
438 out:
439  REPLY_MACRO (VL_API_BRIDGE_DOMAIN_SET_MAC_AGE_REPLY);
440 }
441 
442 static void
444 {
446  .is_add = mp->is_add,
447  .flood = mp->flood,
448  .uu_flood = mp->uu_flood,
449  .forward = mp->forward,
450  .learn = mp->learn,
451  .arp_term = mp->arp_term,
452  .arp_ufwd = mp->arp_ufwd,
453  .mac_age = mp->mac_age,
454  .bd_id = ntohl (mp->bd_id),
455  .bd_tag = mp->bd_tag
456  };
457 
458  int rv = bd_add_del (&a);
459 
460  vl_api_bridge_domain_add_del_reply_t *rmp;
461  REPLY_MACRO (VL_API_BRIDGE_DOMAIN_ADD_DEL_REPLY);
462 }
463 
464 static void
466  vl_api_registration_t * reg,
467  l2_bridge_domain_t * bd_config,
468  u32 n_sw_ifs, u32 context)
469 {
472  vl_api_bridge_domain_sw_if_t *sw_ifs;
473  l2_input_config_t *input_cfg;
474 
475  mp = vl_msg_api_alloc (sizeof (*mp) +
476  (n_sw_ifs * sizeof (vl_api_bridge_domain_sw_if_t)));
477  clib_memset (mp, 0, sizeof (*mp));
478  mp->_vl_msg_id = ntohs (VL_API_BRIDGE_DOMAIN_DETAILS);
479  mp->bd_id = ntohl (bd_config->bd_id);
480  mp->flood = bd_feature_flood (bd_config);
481  mp->uu_flood = bd_feature_uu_flood (bd_config);
482  mp->forward = bd_feature_forward (bd_config);
483  mp->learn = bd_feature_learn (bd_config);
484  mp->arp_term = bd_feature_arp_term (bd_config);
485  mp->arp_ufwd = bd_feature_arp_ufwd (bd_config);
486  mp->bvi_sw_if_index = ntohl (bd_config->bvi_sw_if_index);
487  mp->uu_fwd_sw_if_index = ntohl (bd_config->uu_fwd_sw_if_index);
488  mp->mac_age = bd_config->mac_age;
489  if (bd_config->bd_tag)
490  {
491  strncpy ((char *) mp->bd_tag, (char *) bd_config->bd_tag,
492  ARRAY_LEN (mp->bd_tag) - 1);
493  mp->bd_tag[ARRAY_LEN (mp->bd_tag) - 1] = 0;
494  }
495 
496  mp->context = context;
497 
498  sw_ifs = (vl_api_bridge_domain_sw_if_t *) mp->sw_if_details;
499  vec_foreach (m, bd_config->members)
500  {
501  sw_ifs->sw_if_index = ntohl (m->sw_if_index);
502  input_cfg = vec_elt_at_index (l2im->configs, m->sw_if_index);
503  sw_ifs->shg = input_cfg->shg;
504  sw_ifs++;
505  mp->n_sw_ifs++;
506  }
507  mp->n_sw_ifs = htonl (mp->n_sw_ifs);
508 
509  vl_api_send_msg (reg, (u8 *) mp);
510 }
511 
512 static void
514 {
515  bd_main_t *bdm = &bd_main;
516  l2input_main_t *l2im = &l2input_main;
518  u32 bd_id, bd_index, end, filter_sw_if_index;
519 
521  if (!reg)
522  return;
523 
524  filter_sw_if_index = ntohl (mp->sw_if_index);
525  if (filter_sw_if_index != ~0)
526  return; /* UNIMPLEMENTED */
527 
528  bd_id = ntohl (mp->bd_id);
529  if (bd_id == 0)
530  return;
531 
532  if (bd_id == ~0)
533  bd_index = 0, end = vec_len (l2im->bd_configs);
534  else
535  {
536  bd_index = bd_find_index (bdm, bd_id);
537  if (bd_index == ~0)
538  return;
539 
540  end = bd_index + 1;
541  }
542 
543  for (; bd_index < end; bd_index++)
544  {
545  l2_bridge_domain_t *bd_config =
546  l2input_bd_config_from_index (l2im, bd_index);
547  /* skip placeholder bd_id 0 */
548  if (bd_config && (bd_config->bd_id > 0))
549  send_bridge_domain_details (l2im, reg, bd_config,
550  vec_len (bd_config->members),
551  mp->context);
552  }
553 }
554 
555 static bd_flags_t
556 bd_flags_decode (vl_api_bd_flags_t v)
557 {
558  bd_flags_t f = L2_NONE;
559 
560  v = ntohl (v);
561 
562  if (v & BRIDGE_API_FLAG_LEARN)
563  f |= L2_LEARN;
564  if (v & BRIDGE_API_FLAG_FWD)
565  f |= L2_FWD;
566  if (v & BRIDGE_API_FLAG_FLOOD)
567  f |= L2_FLOOD;
568  if (v & BRIDGE_API_FLAG_UU_FLOOD)
569  f |= L2_UU_FLOOD;
570  if (v & BRIDGE_API_FLAG_ARP_TERM)
571  f |= L2_ARP_TERM;
572  if (v & BRIDGE_API_FLAG_ARP_UFWD)
573  f |= L2_ARP_UFWD;
574 
575  return (f);
576 }
577 
578 static void
580 {
582  bd_main_t *bdm = &bd_main;
584  u32 bitmap = 0;
585  int rv = 0;
586 
588  u32 bd_id = ntohl (mp->bd_id);
589  if (bd_id == 0)
590  {
591  rv = VNET_API_ERROR_BD_NOT_MODIFIABLE;
592  goto out;
593  }
594 
595  u32 bd_index = bd_find_index (bdm, bd_id);
596  if (bd_index == ~0)
597  {
598  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
599  goto out;
600  }
601 
602  bitmap = bd_set_flags (vm, bd_index, flags, mp->is_set);
603 
604 out:
605  /* *INDENT-OFF* */
606  REPLY_MACRO2(VL_API_BRIDGE_FLAGS_REPLY,
607  ({
608  rmp->resulting_feature_bitmap = ntohl(bitmap);
609  }));
610  /* *INDENT-ON* */
611 }
612 
613 static void
616 {
617  int rv = 0;
618  vl_api_l2_interface_vlan_tag_rewrite_reply_t *rmp;
619  vnet_main_t *vnm = vnet_get_main ();
621  u32 vtr_op;
622 
624 
625  vtr_op = ntohl (mp->vtr_op);
626 
627  /* The L2 code is unsuspicious */
628  switch (vtr_op)
629  {
630  case L2_VTR_DISABLED:
631  case L2_VTR_PUSH_1:
632  case L2_VTR_PUSH_2:
633  case L2_VTR_POP_1:
634  case L2_VTR_POP_2:
639  break;
640 
641  default:
642  rv = VNET_API_ERROR_INVALID_VALUE;
643  goto bad_sw_if_index;
644  }
645 
646  rv = l2vtr_configure (vm, vnm, ntohl (mp->sw_if_index), vtr_op,
647  ntohl (mp->push_dot1q), ntohl (mp->tag1),
648  ntohl (mp->tag2));
649 
651 
652  REPLY_MACRO (VL_API_L2_INTERFACE_VLAN_TAG_REWRITE_REPLY);
653 }
654 
655 static void
658 {
659  vl_api_l2_interface_pbb_tag_rewrite_reply_t *rmp;
660  vnet_main_t *vnm = vnet_get_main ();
662  u32 vtr_op;
663  int rv = 0;
664  mac_address_t b_dmac, b_smac;
665 
667 
668  vtr_op = ntohl (mp->vtr_op);
669 
670  switch (vtr_op)
671  {
672  case L2_VTR_DISABLED:
673  case L2_VTR_PUSH_2:
674  case L2_VTR_POP_2:
676  break;
677 
678  default:
679  rv = VNET_API_ERROR_INVALID_VALUE;
680  goto bad_sw_if_index;
681  }
682 
683  mac_address_decode (mp->b_dmac, &b_dmac);
684  mac_address_decode (mp->b_smac, &b_smac);
685 
686  rv = l2pbb_configure (vm, vnm, ntohl (mp->sw_if_index), vtr_op,
687  b_dmac.bytes, b_smac.bytes, ntohs (mp->b_vlanid),
688  ntohl (mp->i_sid), ntohs (mp->outer_tag));
689 
691 
692  REPLY_MACRO (VL_API_L2_INTERFACE_PBB_TAG_REWRITE_REPLY);
693 }
694 
695 static void
698 {
699  vl_api_sw_interface_set_l2_xconnect_reply_t *rmp;
700  int rv = 0;
701  u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index);
702  u32 tx_sw_if_index = ntohl (mp->tx_sw_if_index);
704  vnet_main_t *vnm = vnet_get_main ();
705 
707 
708  if (mp->enable)
709  {
711  rv = set_int_l2_mode (vm, vnm, MODE_L2_XC,
712  rx_sw_if_index, 0,
713  L2_BD_PORT_TYPE_NORMAL, 0, tx_sw_if_index);
714  }
715  else
716  {
717  rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0,
718  L2_BD_PORT_TYPE_NORMAL, 0, 0);
719  }
720 
721  switch (rv)
722  {
723  case MODE_ERROR_ETH:
724  rv = VNET_API_ERROR_NON_ETHERNET;
725  break;
726  case MODE_ERROR_BVI_DEF:
727  rv = VNET_API_ERROR_BD_ALREADY_HAS_BVI;
728  break;
729  }
730 
733 
734  REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_XCONNECT_REPLY);
735 }
736 
737 static int
738 l2_bd_port_type_decode (vl_api_l2_port_type_t v, l2_bd_port_type_t * l)
739 {
740  v = clib_net_to_host_u32 (v);
741 
742  switch (v)
743  {
746  return 0;
748  *l = L2_BD_PORT_TYPE_BVI;
749  return 0;
752  return 0;
753  }
754 
755  return (VNET_API_ERROR_INVALID_VALUE);
756 }
757 
758 static void
761 {
762  bd_main_t *bdm = &bd_main;
763  vl_api_sw_interface_set_l2_bridge_reply_t *rmp;
764  int rv = 0;
766  vnet_main_t *vnm = vnet_get_main ();
768 
770  u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index);
771  rv = l2_bd_port_type_decode (mp->port_type, &pt);
772 
773  if (0 != rv)
774  goto out;
775  if (mp->enable)
776  {
777  VALIDATE_BD_ID (mp);
778  u32 bd_id = ntohl (mp->bd_id);
779  u32 bd_index = bd_find_or_add_bd_index (bdm, bd_id);
780 
781  rv = set_int_l2_mode (vm, vnm, MODE_L2_BRIDGE,
782  rx_sw_if_index, bd_index, pt, mp->shg, 0);
783  }
784  else
785  {
786  rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0, pt, 0, 0);
787  }
788 
789  switch (rv)
790  {
791  case MODE_ERROR_ETH:
792  rv = VNET_API_ERROR_NON_ETHERNET;
793  break;
794  case MODE_ERROR_BVI_DEF:
795  rv = VNET_API_ERROR_BD_ALREADY_HAS_BVI;
796  break;
797  }
798 
801 out:
802  REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_BRIDGE_REPLY);
803 }
804 
805 static void
807  vl_api_registration_t * reg,
808  u32 bd_id,
809  const ip46_address_t * ip,
810  ip46_type_t itype,
811  const mac_address_t * mac, u32 context)
812 {
814 
815  mp = vl_msg_api_alloc (sizeof (*mp));
816  clib_memset (mp, 0, sizeof (*mp));
817  mp->_vl_msg_id = ntohs (VL_API_BD_IP_MAC_DETAILS);
818 
819  mp->context = context;
820  mp->entry.bd_id = ntohl (bd_id);
821 
822  ip_address_encode (ip, itype, &mp->entry.ip);
823  mac_address_encode (mac, mp->entry.mac);
824 
825  vl_api_send_msg (reg, (u8 *) mp);
826 }
827 
828 static void
830 {
832  bd_main_t *bdm = &bd_main;
833  l2_bridge_domain_t *bd_config;
834  u32 bd_id = ntohl (mp->bd_id);
835  u32 bd_index, start, end;
837  uword *p;
838 
840  if (!reg)
841  return;
842 
843  /* see bd_id: ~0 means "any" */
844  if (bd_id == ~0)
845  {
846  start = 1;
848  }
849  else
850  {
851  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
852  if (p == 0)
853  return;
854 
855  bd_index = p[0];
857  start = bd_index;
858  end = start + 1;
859  }
860 
861  for (bd_index = start; bd_index < end; bd_index++)
862  {
863  bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index);
864  if (bd_is_valid (bd_config))
865  {
866  ip4_address_t ip4_addr;
867  ip6_address_t *ip6_addr;
869  u64 mac64;
870  bd_id = bd_config->bd_id;
871 
872  /* *INDENT-OFF* */
873  hash_foreach (ip4_addr.as_u32, mac64, bd_config->mac_by_ip4,
874  ({
875  ip46_address_t ip = {
876  .ip4 = ip4_addr,
877  };
878  mac_address_from_u64(&mac, mac64);
879 
880  send_bd_ip_mac_entry (am, reg, bd_id, &ip, IP46_TYPE_IP4,
881  &mac, mp->context);
882  }));
883 
884  hash_foreach_mem (ip6_addr, mac64, bd_config->mac_by_ip6,
885  ({
886  ip46_address_t ip = {
887  .ip6 = *ip6_addr,
888  };
889  mac_address_from_u64(&mac, mac64);
890 
891  send_bd_ip_mac_entry (am, reg, bd_id, &ip, IP46_TYPE_IP6,
892  &mac, mp->context);
893  }));
894  /* *INDENT-ON* */
895  }
896  }
897 }
898 
899 static void
901 {
902  ip46_address_t ip_addr = ip46_address_initializer;
903  vl_api_bd_ip_mac_add_del_reply_t *rmp;
904  bd_main_t *bdm = &bd_main;
905  u32 bd_index, bd_id;
908  int rv = 0;
909  uword *p;
910 
911  bd_id = ntohl (mp->entry.bd_id);
912 
913  if (bd_id == 0)
914  {
915  rv = VNET_API_ERROR_BD_NOT_MODIFIABLE;
916  goto out;
917  }
918 
919  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
920  if (p == 0)
921  {
922  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
923  goto out;
924  }
925  bd_index = p[0];
926 
927  type = ip_address_decode (&mp->entry.ip, &ip_addr);
928  mac_address_decode (mp->entry.mac, &mac);
929 
930  if (bd_add_del_ip_mac (bd_index, type, &ip_addr, &mac, mp->is_add))
931  rv = VNET_API_ERROR_UNSPECIFIED;
932 
933 out:
934  REPLY_MACRO (VL_API_BD_IP_MAC_ADD_DEL_REPLY);
935 }
936 
937 static void
939 {
940  vl_api_bd_ip_mac_flush_reply_t *rmp;
941  bd_main_t *bdm = &bd_main;
942  u32 bd_index, bd_id;
943  int rv = 0;
944  uword *p;
945 
946  bd_id = ntohl (mp->bd_id);
947 
948  if (bd_id == 0)
949  {
950  rv = VNET_API_ERROR_BD_NOT_MODIFIABLE;
951  goto out;
952  }
953 
954  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
955  if (p == 0)
956  {
957  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
958  goto out;
959  }
960  bd_index = p[0];
961 
962  bd_flush_ip_mac (bd_index);
963 
964 out:
965  REPLY_MACRO (VL_API_BD_IP_MAC_FLUSH_REPLY);
966 }
967 
969  u32 sw_if_index, u8 enable);
970 
971 static void
973  mp)
974 {
975  int rv;
976  vl_api_l2_interface_efp_filter_reply_t *rmp;
977  vnet_main_t *vnm = vnet_get_main ();
978 
980 
981  // enable/disable the feature
982  l2_efp_filter_configure (vnm, ntohl (mp->sw_if_index), mp->enable_disable);
983  rv = vnm->api_errno;
984 
986  REPLY_MACRO (VL_API_L2_INTERFACE_EFP_FILTER_REPLY);
987 }
988 
989 static void
991 {
992  extern int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index,
993  int is_add);
994  vl_api_l2_patch_add_del_reply_t *rmp;
995  int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index,
996  int is_add);
997  int rv = 0;
998 
1001 
1002  rv = vnet_l2_patch_add_del (ntohl (mp->rx_sw_if_index),
1003  ntohl (mp->tx_sw_if_index),
1004  (int) (mp->is_add != 0));
1005 
1008 
1009  REPLY_MACRO (VL_API_L2_PATCH_ADD_DEL_REPLY);
1010 }
1011 
1012 static void
1014 {
1015  vl_api_sw_interface_set_vpath_reply_t *rmp;
1016  int rv = 0;
1017  u32 sw_if_index = ntohl (mp->sw_if_index);
1018 
1019  VALIDATE_SW_IF_INDEX (mp);
1020 
1021  l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_VPATH, mp->enable);
1022  vnet_feature_enable_disable ("ip4-unicast", "vpath-input-ip4",
1023  sw_if_index, mp->enable, 0, 0);
1024  vnet_feature_enable_disable ("ip4-multicast", "vpath-input-ip4",
1025  sw_if_index, mp->enable, 0, 0);
1026  vnet_feature_enable_disable ("ip6-unicast", "vpath-input-ip6",
1027  sw_if_index, mp->enable, 0, 0);
1028  vnet_feature_enable_disable ("ip6-multicast", "vpath-input-ip6",
1029  sw_if_index, mp->enable, 0, 0);
1030 
1032 
1033  REPLY_MACRO (VL_API_SW_INTERFACE_SET_VPATH_REPLY);
1034 }
1035 
1036 static void
1038 {
1041  u32 sw_if_index;
1042  int rv;
1043 
1044  mac_address_decode (mp->mac, &mac);
1045 
1046  rv = l2_bvi_create (ntohl (mp->user_instance), &mac, &sw_if_index);
1047 
1048  /* *INDENT-OFF* */
1049  REPLY_MACRO2(VL_API_BVI_CREATE_REPLY,
1050  ({
1051  rmp->sw_if_index = ntohl (sw_if_index);
1052  }));
1053  /* *INDENT-ON* */
1054 }
1055 
1056 static void
1058 {
1059  vl_api_bvi_delete_reply_t *rmp;
1060  int rv;
1061 
1062  rv = l2_bvi_delete (ntohl (mp->sw_if_index));
1063 
1064  REPLY_MACRO (VL_API_BVI_DELETE_REPLY);
1065 }
1066 
1067 static bool
1069  const l2_arp_term_publish_event_t * e2)
1070 {
1071  if (e1 == NULL || e2 == NULL)
1072  return false;
1073  return (ip46_address_is_equal (&e1->ip, &e2->ip) &&
1074  (e1->sw_if_index == e2->sw_if_index) &&
1075  (mac_address_equal (&e1->mac, &e2->mac)));
1076 }
1077 
1078 static uword
1080  vlib_frame_t * f)
1081 {
1082  /* These cross the longjmp boundary (vlib_process_wait_for_event)
1083  * and need to be volatile - to prevent them from being optimized into
1084  * a register - which could change during suspension */
1085  volatile f64 last = vlib_time_now (vm);
1086  volatile l2_arp_term_publish_event_t last_event = { };
1087 
1089 
1090  while (1)
1091  {
1092  uword event_type = L2_ARP_TERM_EVENT_PUBLISH;
1094  f64 now;
1095 
1097 
1098  vlib_process_get_event_data (vm, &event_type);
1099  now = vlib_time_now (vm);
1100 
1101  if (event_type == L2_ARP_TERM_EVENT_PUBLISH)
1102  {
1104 
1105  vec_foreach (event, l2am->publish_events)
1106  {
1107  /* dampen duplicate events - cast away volatile */
1109  (event, (l2_arp_term_publish_event_t *) & last_event) &&
1110  (now - last) < 10.0)
1111  {
1112  continue;
1113  }
1114  last_event = *event;
1115  last = now;
1116 
1117  /* *INDENT-OFF* */
1118  pool_foreach(reg, vpe_api_main.l2_arp_term_events_registrations,
1119  ({
1120  vl_api_registration_t *vl_reg;
1121  vl_reg = vl_api_client_index_to_registration (reg->client_index);
1122  ALWAYS_ASSERT (vl_reg != NULL);
1123 
1124  if (reg && vl_api_can_send_msg (vl_reg))
1125  {
1126  vl_api_l2_arp_term_event_t * vevent;
1127  vevent = vl_msg_api_alloc (sizeof *vevent);
1128  clib_memset (vevent, 0, sizeof *vevent);
1129  vevent->_vl_msg_id = htons (VL_API_L2_ARP_TERM_EVENT);
1130  vevent->client_index = reg->client_index;
1131  vevent->pid = reg->client_pid;
1132  ip_address_encode(&event->ip,
1133  event->type,
1134  &vevent->ip);
1135  vevent->sw_if_index = htonl(event->sw_if_index);
1136  mac_address_encode(&event->mac, vevent->mac);
1137  vl_api_send_msg (vl_reg, (u8 *) vevent);
1138  }
1139  }));
1140  /* *INDENT-ON* */
1141  }
1143  }
1144  }
1145 
1146  return 0;
1147 }
1148 
1149 /* *INDENT-OFF* */
1151  .function = l2_arp_term_process,
1152  .type = VLIB_NODE_TYPE_PROCESS,
1153  .name = "l2-arp-term-publisher",
1154 };
1155 /* *INDENT-ON* */
1156 
1157 static void
1159  mp)
1160 {
1161  vl_api_want_l2_arp_term_events_reply_t *rmp;
1164  int rv = 0;
1165  uword *p;
1166 
1167  p = hash_get (am->l2_arp_term_events_registration_hash, mp->client_index);
1168 
1169  if (p)
1170  {
1171  if (mp->enable)
1172  {
1173  clib_warning ("pid %d: already enabled...", mp->pid);
1174  rv = VNET_API_ERROR_INVALID_REGISTRATION;
1175  goto reply;
1176  }
1177  else
1178  {
1179  rp = pool_elt_at_index (am->l2_arp_term_events_registrations, p[0]);
1180  pool_put (am->l2_arp_term_events_registrations, rp);
1181  hash_unset (am->l2_arp_term_events_registration_hash,
1182  mp->client_index);
1183  if (pool_elts (am->l2_arp_term_events_registrations) == 0)
1185  goto reply;
1186  }
1187  }
1188  if (mp->enable == 0)
1189  {
1190  clib_warning ("pid %d: already disabled...", mp->pid);
1191  rv = VNET_API_ERROR_INVALID_REGISTRATION;
1192  goto reply;
1193  }
1194  pool_get (am->l2_arp_term_events_registrations, rp);
1195  rp->client_index = mp->client_index;
1196  rp->client_pid = mp->pid;
1197  hash_set (am->l2_arp_term_events_registration_hash, rp->client_index,
1198  rp - am->l2_arp_term_events_registrations);
1200 
1201 reply:
1202  REPLY_MACRO (VL_API_WANT_L2_ARP_TERM_EVENTS_REPLY);
1203 }
1204 
1205 static clib_error_t *
1207 {
1209  vpe_api_main_t *am;
1210  uword *p;
1211 
1212  am = &vpe_api_main;
1213 
1214  /* remove from the registration hash */
1215  p = hash_get (am->l2_arp_term_events_registration_hash, client_index);
1216 
1217  if (p)
1218  {
1219  rp = pool_elt_at_index (am->l2_arp_term_events_registrations, p[0]);
1220  pool_put (am->l2_arp_term_events_registrations, rp);
1221  hash_unset (am->l2_arp_term_events_registration_hash, client_index);
1222  if (pool_elts (am->l2_arp_term_events_registrations) == 0)
1224  }
1225  return (NULL);
1226 }
1227 
1229 
1230 /*
1231  * l2_api_hookup
1232  * Add vpe's API message handlers to the table.
1233  * vlib has already mapped shared memory and
1234  * added the client registration handlers.
1235  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1236  */
1237 #define vl_msg_name_crc_list
1238 #include <vnet/vnet_all_api_h.h>
1239 #undef vl_msg_name_crc_list
1240 
1241 static void
1243 {
1244 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1245  foreach_vl_msg_name_crc_l2;
1246 #undef _
1247 }
1248 
1249 static clib_error_t *
1251 {
1252  api_main_t *am = vlibapi_get_main ();
1253 
1254 #define _(N,n) \
1255  vl_msg_api_set_handlers(VL_API_##N, #n, \
1256  vl_api_##n##_t_handler, \
1257  vl_noop_handler, \
1258  vl_api_##n##_t_endian, \
1259  vl_api_##n##_t_print, \
1260  sizeof(vl_api_##n##_t), 1);
1262 #undef _
1263 
1264  /* Mark VL_API_BRIDGE_DOMAIN_DUMP as mp safe */
1265  am->is_mp_safe[VL_API_BRIDGE_DOMAIN_DUMP] = 1;
1266 
1267  /*
1268  * Set up the (msg_name, crc, message-id) table
1269  */
1271 
1272  return 0;
1273 }
1274 
1276 
1277 /*
1278  * fd.io coding-style-patch-verification: ON
1279  *
1280  * Local Variables:
1281  * eval: (c-set-style "gnu")
1282  * End:
1283  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:509
static void vl_api_want_l2_arp_term_events_t_handler(vl_api_want_l2_arp_term_events_t *mp)
Definition: l2_api.c:1158
static_always_inline u8 bd_feature_forward(l2_bridge_domain_t *bd_config)
Definition: l2_input.h:177
static void vl_api_l2_fib_table_dump_t_handler(vl_api_l2_fib_table_dump_t *mp)
Definition: l2_api.c:163
#define BAD_RX_SW_IF_INDEX_LABEL
static bd_flags_t bd_flags_decode(vl_api_bd_flags_t v)
Definition: l2_api.c:556
#define vec_foreach_index(var, v)
Iterate over vector indices.
vl_api_mac_address_t b_smac
Definition: l2.api:416
vl_api_mac_address_t mac
Definition: l2.api:57
L2 FIB add entry request.
Definition: l2.api:130
#define hash_set(h, key, value)
Definition: hash.h:255
l2_input_config_t * configs
Definition: l2_input.h:62
Set bridge flags response.
Definition: l2.api:369
#define VALIDATE_TX_SW_IF_INDEX(mp)
u32 uu_fwd_sw_if_index
Definition: l2_bd.h:80
l2 fib table details structure
Definition: l2.api:53
static void vl_api_bvi_delete_t_handler(vl_api_bvi_delete_t *mp)
Definition: l2_api.c:1057
vl_api_bd_ip_mac_t entry
Definition: l2.api:533
vl_api_mac_address_t mac
Definition: l2.api:502
vlib_node_registration_t l2_arp_term_process_node
(constructor) VLIB_REGISTER_NODE (l2_arp_term_process_node)
Definition: l2_api.c:1150
#define hash_unset(h, key)
Definition: hash.h:261
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:103
u32 user_instance[default=0xffffffff]
Definition: l2.api:586
a
Definition: bitmap.h:538
u32 l2vtr_configure(vlib_main_t *vlib_main, vnet_main_t *vnet_main, u32 sw_if_index, u32 vtr_op, u32 push_dot1q, u32 vtr_tag1, u32 vtr_tag2)
Configure vtag tag rewrite on the given interface.
Definition: l2_vtr.c:136
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
Definition: node_funcs.h:656
vl_api_l2_port_type_t port_type
Definition: l2.api:484
#define ntohs(x)
Definition: af_xdp.bpf.c:29
l2_arp_term_publish_event_t * publish_events
Definition: l2_arp_term.h:38
u32 bd_add_del_ip_mac(u32 bd_index, ip46_type_t type, const ip46_address_t *ip, const mac_address_t *mac, u8 is_add)
Add/delete IP address to MAC address mapping.
Definition: l2_bd.c:812
vl_api_interface_index_t sw_if_index
Definition: l2.api:598
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
static void vl_api_sw_interface_set_l2_bridge_t_handler(vl_api_sw_interface_set_l2_bridge_t *mp)
Definition: l2_api.c:760
Create BVI interface instance request.
Definition: l2.api:581
u32 bvi_sw_if_index
Definition: l2_bd.h:74
void mac_address_encode(const mac_address_t *in, u8 *out)
static void vl_api_l2_patch_add_del_t_handler(vl_api_l2_patch_add_del_t *mp)
Definition: l2_api.c:990
static void vl_api_l2_flags_t_handler(vl_api_l2_flags_t *mp)
Definition: l2_api.c:375
vnet_interface_main_t interface_main
Definition: vnet.h:59
bool is_add[default=true]
Definition: l2.api:434
unsigned long u64
Definition: types.h:89
#define REPLY_MACRO2(t, body)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vl_api_interface_index_t sw_if_index
Definition: l2.api:557
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:333
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
Definition: l2_bd.h:152
VLIB_API_INIT_FUNCTION(l2_api_hookup)
bool is_add[default=true]
Definition: l2.api:276
static heap_elt_t * last(heap_header_t *h)
Definition: heap.c:53
L2 bridge domain set mac age.
Definition: l2.api:242
bool is_add[default=true]
Definition: l2.api:509
vl_api_interface_index_t rx_sw_if_index
Definition: l2.api:31
l2_flood_member_t * members
Definition: l2_bd.h:86
Dump L2 XConnects.
Definition: l2.api:39
static void vl_api_bridge_domain_add_del_t_handler(vl_api_bridge_domain_add_del_t *mp)
Definition: l2_api.c:443
vl_api_interface_index_t sw_if_index
Definition: l2.api:412
vl_api_interface_index_t rx_sw_if_index
Definition: l2.api:482
void l2_arp_term_set_publisher_node(bool on)
Definition: l2_arp_term.c:99
static void send_l2_xconnect_details(vl_api_registration_t *reg, u32 context, u32 rx_sw_if_index, u32 tx_sw_if_index)
Definition: l2_api.c:85
vlib_main_t * vm
Definition: in2out_ed.c:1582
static void vl_api_bd_ip_mac_dump_t_handler(vl_api_bd_ip_mac_dump_t *mp)
Definition: l2_api.c:829
u32 max_macs_in_event
Definition: l2_fib.h:59
enum l2fib_entry_result_flags_t_ l2fib_entry_result_flags_t
u32 bd_id[default=0xffffffff]
Definition: l2.api:289
L2 bridge domain request operational state details.
Definition: l2.api:285
int bd_add_del(l2_bridge_domain_add_del_args_t *a)
Definition: l2_bd.c:1226
bridge domain IP to MAC entry details structure
Definition: l2.api:530
static_always_inline u8 bd_feature_uu_flood(l2_bridge_domain_t *bd_config)
Definition: l2_input.h:170
static void vl_api_l2fib_add_del_t_handler(vl_api_l2fib_add_del_t *mp)
Definition: l2_api.c:202
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:252
void * vl_msg_api_alloc(int nbytes)
unsigned char u8
Definition: types.h:56
u32 client_index
Definition: l2_learn.h:39
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
#define fm
Definition: l2_fib.h:137
Reply to l2_xconnect_dump.
Definition: l2.api:28
u8 max_macs_in_event[default=10]
Definition: l2.api:158
static_always_inline u8 bd_feature_arp_ufwd(l2_bridge_domain_t *bd_config)
Definition: l2_input.h:197
vl_api_interface_index_t sw_if_index[default=0xffffffff]
Definition: l2.api:290
L2 bridge domain operational state response.
Definition: l2.api:318
l2learn_main_t l2learn_main
Definition: l2_learn.c:33
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:513
static void vl_api_bd_ip_mac_flush_t_handler(vl_api_bd_ip_mac_flush_t *mp)
Definition: l2_api.c:938
#define MODE_L2_BRIDGE
Definition: l2_input.h:221
bool enable[default=true]
Definition: l2.api:450
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:442
u32 feature_bitmap
Definition: l2.api:221
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
static_always_inline u8 bd_feature_arp_term(l2_bridge_domain_t *bd_config)
Definition: l2_input.h:190
static void vl_api_l2_fib_clear_table_t_handler(vl_api_l2_fib_clear_table_t *mp)
Definition: l2_api.c:126
L2 FIB flush bridge domain entries.
Definition: l2.api:100
void l2fib_add_entry(const u8 *mac, u32 bd_index, u32 sw_if_index, l2fib_entry_result_flags_t flags)
Add an entry to the l2fib.
Definition: l2_fib.c:405
unsigned int u32
Definition: types.h:88
vl_api_interface_index_t tx_sw_if_index
Definition: l2.api:32
uword * bd_index_by_bd_id
Definition: l2_bd.h:36
ip46_type_t ip_address_decode(const vl_api_address_t *in, ip46_address_t *out)
Decode/Encode for struct/union types.
Definition: ip_types_api.c:160
vl_api_mac_address_t mac
Definition: l2.api:134
Dump l2 fib (aka bridge domain) table.
Definition: l2.api:68
vl_api_fib_path_type_t type
Definition: fib_types.api:123
bool enable_disable[default=true]
Definition: l2.api:558
static_always_inline u8 bd_feature_flood(l2_bridge_domain_t *bd_config)
Definition: l2_input.h:163
vnet_api_error_t api_errno
Definition: vnet.h:84
vl_api_interface_index_t sw_if_index
Definition: l2.api:389
#define hash_get(h, key)
Definition: hash.h:249
f64 event_scan_delay
Definition: l2_fib.h:56
Set interface L2 flags (such as L2_LEARN, L2_FWD, L2_FLOOD, L2_UU_FLOOD, or L2_ARP_TERM bits)...
Definition: l2.api:215
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:534
L2 FIB flush all entries.
Definition: l2.api:89
L2 fib clear table request, clear all mac entries in the l2 fib.
Definition: l2.api:79
vl_api_interface_index_t uu_fwd_sw_if_index
Definition: l2.api:331
vl_api_interface_index_t sw_if_index
Definition: l2.api:571
bool enable_disable[default=true]
Definition: l2.api:159
u32 bd_id
Definition: gbp.api:188
Set interface L2 flags response.
Definition: l2.api:229
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:302
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:819
enum l2_bd_port_type_t_ l2_bd_port_type_t
static void vl_api_bd_ip_mac_add_del_t_handler(vl_api_bd_ip_mac_add_del_t *mp)
Definition: l2_api.c:900
#define REPLY_MACRO(t)
#define BAD_TX_SW_IF_INDEX_LABEL
vnet_main_t vnet_main
Definition: misc.c:43
void l2fib_flush_all_mac(vlib_main_t *vm)
Flush all non static MACs - flushes all valid BDs.
Definition: l2_fib.c:830
static_always_inline void mac_address_from_u64(mac_address_t *mac, u64 u)
Definition: mac_address.h:122
bool enable[default=true]
Definition: l2.api:486
vl_api_interface_index_t sw_if_index
Definition: l2.api:116
VL_MSG_API_REAPER_FUNCTION(want_l2_arp_term_events_reaper)
static_always_inline int mac_address_equal(const mac_address_t *a, const mac_address_t *b)
Definition: mac_address.h:140
vl_api_interface_index_t tx_sw_if_index
Definition: l2.api:449
Create BVI interface instance response.
Definition: l2.api:594
#define hash_foreach_mem(key_var, value_var, h, body)
Definition: hash.h:461
static clib_error_t * l2_api_hookup(vlib_main_t *vm)
Definition: l2_api.c:1250
l2fib_main_t l2fib_main
Definition: l2_fib.c:55
static u32 bd_is_valid(l2_bridge_domain_t *bd_config)
Definition: l2_bd.h:134
static u8 ip46_address_is_equal(const ip46_address_t *ip46_1, const ip46_address_t *ip46_2)
Definition: ip46_address.h:93
Definition: l2_bd.h:150
vl_api_interface_index_t sw_if_index
Definition: l2.api:219
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:227
vl_api_interface_index_t sw_if_index
Definition: l2.api:610
u32 l2pbb_configure(vlib_main_t *vlib_main, vnet_main_t *vnet_main, u32 sw_if_index, u32 vtr_op, u8 *b_dmac, u8 *b_smac, u16 b_vlanid, u32 i_sid, u16 vlan_outer_tag)
Definition: l2_vtr.c:54
struct l2fib_entry_result_t_::@458::@460 fields
void bd_set_mac_age(vlib_main_t *vm, u32 bd_index, u8 age)
Set the mac age for the bridge domain.
Definition: l2_bd.c:300
An API client registration, only in vpp/vlib.
Definition: api_common.h:47
#define BAD_SW_IF_INDEX_LABEL
struct l2fib_entry_key_t::@450::@452 fields
static void send_bridge_domain_details(l2input_main_t *l2im, vl_api_registration_t *reg, l2_bridge_domain_t *bd_config, u32 n_sw_ifs, u32 context)
Definition: l2_api.c:465
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
u32 l2fib_del_entry(const u8 *mac, u32 bd_index, u32 sw_if_index)
Delete an entry from the l2fib.
Definition: l2_fib.c:689
int l2_bvi_delete(u32 sw_if_index)
Definition: l2_bvi.c:210
vl_api_interface_index_t sw_if_index
Definition: l2.api:58
static void send_bd_ip_mac_entry(vpe_api_main_t *am, vl_api_registration_t *reg, u32 bd_id, const ip46_address_t *ip, ip46_type_t itype, const mac_address_t *mac, u32 context)
Definition: l2_api.c:806
static void vl_api_l2_xconnect_dump_t_handler(vl_api_l2_xconnect_dump_t *mp)
Definition: l2_api.c:101
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
#define foreach_vpe_api_msg
Definition: l2_api.c:56
u32 bd_set_flags(vlib_main_t *vm, u32 bd_index, bd_flags_t flags, u32 enable)
Set the learn/forward/flood flags for the bridge domain.
Definition: l2_bd.c:252
#define MODE_ERROR_ETH
Definition: l2_input.h:225
static_always_inline u8 bd_feature_learn(l2_bridge_domain_t *bd_config)
Definition: l2_input.h:183
#define clib_warning(format, args...)
Definition: error.h:59
static void setup_message_id_table(api_main_t *am)
Definition: l2_api.c:1242
vl_api_interface_index_t bvi_sw_if_index
Definition: l2.api:330
vl_api_interface_index_t tx_sw_if_index
Definition: l2.api:433
void l2fib_clear_table(void)
Definition: l2_fib.c:347
static clib_error_t * want_l2_arp_term_events_reaper(u32 client_index)
Definition: l2_api.c:1206
#define ARRAY_LEN(x)
Definition: clib.h:67
uword * mac_by_ip6
Definition: l2_bd.h:102
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:79
u8 scan_delay[default=10]
Definition: l2.api:157
static bool l2_arp_term_publish_event_is_equal(const l2_arp_term_publish_event_t *e1, const l2_arp_term_publish_event_t *e2)
Definition: l2_api.c:1068
#define VALIDATE_RX_SW_IF_INDEX(mp)
vl_api_interface_index_t rx_sw_if_index
Definition: l2.api:432
Dump bridge domain IP to MAC entries.
Definition: l2.api:540
bool enable[default=0xffffffff]
Definition: l2.api:572
void bd_flush_ip_mac(u32 bd_index)
Flush IP address to MAC address mapping tables in a BD.
Definition: l2_bd.c:889
Set L2 XConnect between two interfaces request.
Definition: l2.api:444
vl_api_interface_index_t rx_sw_if_index
Definition: l2.api:448
vl_api_interface_index_t tx_sw_if_index
Definition: ip.api:441
static u32 bd_find_or_add_bd_index(bd_main_t *bdm, u32 bd_id)
Get or create a bridge domain.
Definition: l2_bd.h:196
bool is_add[default=true]
Definition: l2.api:137
static_always_inline l2_bridge_domain_t * l2input_bd_config_from_index(l2input_main_t *l2im, u32 bd_index)
Definition: l2_input.h:77
Definition: l2_fib.h:71
Register to receive L2 MAC events for learned and aged MAC.
Definition: l2.api:152
u32 set_int_l2_mode(vlib_main_t *vm, vnet_main_t *vnet_main, u32 mode, u32 sw_if_index, u32 bd_index, l2_bd_port_type_t port_type, u32 shg, u32 xc_sw_if_index)
Set the subinterface to run in l2 or l3 mode.
Definition: l2_input.c:580
u32 l2input_intf_bitmap_enable(u32 sw_if_index, l2input_feat_masks_t feature_bitmap, u32 enable)
Enable (or disable) the feature in the bitmap for the given interface.
Definition: l2_input.c:527
#define BAD_BD_ID_LABEL
u32 global_learn_limit
Definition: l2_learn.h:35
#define VALIDATE_BD_ID(mp)
#define MODE_L2_XC
Definition: l2_input.h:222
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u32 resulting_feature_bitmap
Definition: l2.api:233
static void vl_api_l2_interface_vlan_tag_rewrite_t_handler(vl_api_l2_interface_vlan_tag_rewrite_t *mp)
Definition: l2_api.c:615
Interface bridge mode request.
Definition: l2.api:478
vl_api_interface_index_t sw_if_index
Definition: l2.api:136
static void vl_api_sw_interface_set_l2_xconnect_t_handler(vl_api_sw_interface_set_l2_xconnect_t *mp)
Definition: l2_api.c:697
l2input_main_t l2input_main
Definition: l2_input.c:127
static void vl_api_bvi_create_t_handler(vl_api_bvi_create_t *mp)
Definition: l2_api.c:1037
L2 FIB flush interface entries.
Definition: l2.api:112
static void * vlib_process_get_event_data(vlib_main_t *vm, uword *return_event_type_opaque)
Definition: node_funcs.h:526
static void vl_api_l2fib_flush_bd_t_handler(vl_api_l2fib_flush_bd_t *mp)
Definition: l2_api.c:355
vl_api_address_t ip
Definition: l2.api:501
vl_api_bd_flags_t flags
Definition: l2.api:361
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static void vl_api_want_l2_macs_events_t_handler(vl_api_want_l2_macs_events_t *mp)
Definition: l2_api.c:265
Register for IP4 ARP resolution event on receiving ARP reply or MAC/IP info from ARP requests in L2 B...
Definition: l2.api:620
u64 uword
Definition: types.h:112
L2 interface ethernet flow point filtering enable/disable request.
Definition: l2.api:553
u32 pid
Definition: dhcp.api:164
static void vl_api_bridge_flags_t_handler(vl_api_bridge_flags_t *mp)
Definition: l2_api.c:579
int vnet_l2_patch_add_del(u32 rx_sw_if_index, u32 tx_sw_if_index, int is_add)
Definition: l2_patch.c:233
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:872
static void vl_api_l2_interface_efp_filter_t_handler(vl_api_l2_interface_efp_filter_t *mp)
Definition: l2_api.c:972
vl_api_mac_address_t b_dmac
Definition: l2.api:415
L2 interface vlan tag rewrite configure request.
Definition: l2.api:385
static void vl_api_l2fib_flush_all_t_handler(vl_api_l2fib_flush_all_t *mp)
Definition: l2_api.c:345
l2_bridge_domain_t * bd_configs
Definition: l2_input.h:65
static void l2fib_add_filter_entry(const u8 *mac, u32 bd_index)
Definition: l2_fib.h:428
static void vl_api_bridge_domain_set_mac_age_t_handler(vl_api_bridge_domain_set_mac_age_t *mp)
Definition: l2_api.c:415
void ip_address_encode(const ip46_address_t *in, ip46_type_t type, vl_api_address_t *out)
Definition: ip_types_api.c:194
L2 interface patch add / del request.
Definition: l2.api:428
void l2fib_table_dump(u32 bd_index, l2fib_entry_key_t **l2fe_key, l2fib_entry_result_t **l2fe_res)
Definition: l2_fib.c:134
static void send_l2fib_table_entry(vpe_api_main_t *am, vl_api_registration_t *reg, l2fib_entry_key_t *l2fe_key, l2fib_entry_result_t *l2fe_res, u32 context)
Definition: l2_api.c:138
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:389
Interface set vpath request.
Definition: l2.api:567
#define MODE_ERROR_BVI_DEF
Definition: l2_input.h:226
static int l2_bd_port_type_decode(vl_api_l2_port_type_t v, l2_bd_port_type_t *l)
Definition: l2_api.c:738
u8 * is_mp_safe
Message is mp safe vector.
Definition: api_common.h:250
L2 interface pbb tag rewrite configure request.
Definition: l2.api:408
u32 learn_limit[default=1000]
Definition: l2.api:156
#define vec_foreach(var, vec)
Vector iterator.
uword * mac_by_ip4
Definition: l2_bd.h:101
Set bridge flags request.
Definition: l2.api:355
f64 end
end of the time range
Definition: mactime.api:44
Delete BVI interface request.
Definition: l2.api:606
vl_api_bridge_domain_sw_if_t sw_if_details[n_sw_ifs]
Definition: l2.api:333
u32 sw_if_index
Definition: l2_bd.h:55
u32 bd_find_index(bd_main_t *bdm, u32 bd_id)
Get a bridge domain.
Definition: l2_bd.c:70
vl_api_bd_ip_mac_t entry
Definition: l2.api:510
bd_main_t bd_main
Definition: l2_bd.c:44
vpe_api_main_t vpe_api_main
Definition: interface_api.c:54
void l2_efp_filter_configure(vnet_main_t *vnet_main, u32 sw_if_index, u8 enable)
Enable/disable the EFP Filter check on the subinterface.
u32 client_pid
Definition: l2_learn.h:38
l2_arp_term_main_t l2_arp_term_main
Definition: l2_arp_term.c:29
void mac_address_decode(const u8 *in, mac_address_t *out)
Conversion functions to/from (decode/encode) API types to VPP internal types.
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:809
static void vl_api_l2fib_flush_int_t_handler(vl_api_l2fib_flush_int_t *mp)
Definition: l2_api.c:329
Flush bridge domain IP to MAC entries.
Definition: l2.api:517
#define ip46_address_initializer
Definition: ip46_address.h:52
static uword l2_arp_term_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: l2_api.c:1079
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:33
static void vl_api_l2_interface_pbb_tag_rewrite_t_handler(vl_api_l2_interface_pbb_tag_rewrite_t *mp)
Definition: l2_api.c:657
vl_api_mac_address_t mac
Definition: l2.api:585
#define L2LEARN_DEFAULT_LIMIT
Definition: l2_learn.h:49
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
Definition: feature.c:303
int l2_bvi_create(u32 user_instance, const mac_address_t *mac_in, u32 *sw_if_indexp)
Definition: l2_bvi.c:136
#define VALIDATE_SW_IF_INDEX(mp)
#define MODE_L3
Definition: l2_input.h:220
enum bd_flags_t_ bd_flags_t
ip46_type_t
Definition: ip46_address.h:22
static void vl_api_bridge_domain_dump_t_handler(vl_api_bridge_domain_dump_t *mp)
Definition: l2_api.c:513
L2 bridge domain add or delete request.
Definition: l2.api:263
static void vl_api_sw_interface_set_vpath_t_handler(vl_api_sw_interface_set_vpath_t *mp)
Definition: l2_api.c:1013
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128