FD.io VPP  v20.01-48-g3e0dafb74
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  clib_memcpy (mp->mac, l2fe_key->fields.mac, 6);
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 
218  u8 mac[6];
219 
220  clib_memcpy (mac, mp->mac, 6);
221  if (mp->is_add)
222  {
223  if (mp->filter_mac)
224  l2fib_add_filter_entry (mac, 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, 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, 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
285 
286  if (mp->scan_delay)
287  fm->event_scan_delay = (f64) (mp->scan_delay) * 10e-3;
288  else
290 
291  /* change learn limit and flush all learned MACs */
292  if (learn_limit && (learn_limit < L2LEARN_DEFAULT_LIMIT))
293  lm->global_learn_limit = learn_limit;
294  else
296 
298  }
299  else if (lm->client_pid != pid)
300  {
301  rv = VNET_API_ERROR_L2_MACS_EVENT_CLINET_PRESENT;
302  goto exit;
303  }
304  }
305  else if (lm->client_pid)
306  {
307  lm->client_pid = 0;
308  lm->client_index = 0;
309  if (learn_limit && (learn_limit < L2LEARN_DEFAULT_LIMIT))
310  lm->global_learn_limit = learn_limit;
311  else
313  }
314 
315 exit:
316  REPLY_MACRO (VL_API_WANT_L2_MACS_EVENTS_REPLY);
317 }
318 
319 static void
321 {
322  int rv = 0;
324  vl_api_l2fib_flush_int_reply_t *rmp;
325 
327 
328  u32 sw_if_index = ntohl (mp->sw_if_index);
329  l2fib_flush_int_mac (vm, sw_if_index);
330 
332  REPLY_MACRO (VL_API_L2FIB_FLUSH_INT_REPLY);
333 }
334 
335 static void
337 {
338  int rv = 0;
339  vl_api_l2fib_flush_all_reply_t *rmp;
340 
342  REPLY_MACRO (VL_API_L2FIB_FLUSH_ALL_REPLY);
343 }
344 
345 static void
347 {
348  int rv = 0;
350  bd_main_t *bdm = &bd_main;
351  vl_api_l2fib_flush_bd_reply_t *rmp;
352 
353  u32 bd_id = ntohl (mp->bd_id);
354  uword *p = hash_get (bdm->bd_index_by_bd_id, bd_id);
355  if (p == 0)
356  {
357  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
358  goto out;
359  }
360  l2fib_flush_bd_mac (vm, *p);
361 out:
362  REPLY_MACRO (VL_API_L2FIB_FLUSH_BD_REPLY);
363 }
364 
365 static void
367 {
369  int rv = 0;
370  u32 rbm = 0;
371 
373 
374  u32 sw_if_index = ntohl (mp->sw_if_index);
375  u32 flags = ntohl (mp->feature_bitmap);
376  u32 bitmap = 0;
377 
378  if (flags & L2_LEARN)
379  bitmap |= L2INPUT_FEAT_LEARN;
380 
381  if (flags & L2_FWD)
382  bitmap |= L2INPUT_FEAT_FWD;
383 
384  if (flags & L2_FLOOD)
385  bitmap |= L2INPUT_FEAT_FLOOD;
386 
387  if (flags & L2_UU_FLOOD)
388  bitmap |= L2INPUT_FEAT_UU_FLOOD;
389 
390  if (flags & L2_ARP_TERM)
391  bitmap |= L2INPUT_FEAT_ARP_TERM;
392 
393  rbm = l2input_intf_bitmap_enable (sw_if_index, bitmap, mp->is_set);
394 
396 
397  /* *INDENT-OFF* */
398  REPLY_MACRO2(VL_API_L2_FLAGS_REPLY,
399  ({
400  rmp->resulting_feature_bitmap = ntohl(rbm);
401  }));
402  /* *INDENT-ON* */
403 }
404 
405 static void
407  * mp)
408 {
410  bd_main_t *bdm = &bd_main;
411  vl_api_bridge_domain_set_mac_age_reply_t *rmp;
412  int rv = 0;
413  u32 bd_id = ntohl (mp->bd_id);
414  uword *p;
415 
416  if (bd_id == 0)
417  {
418  rv = VNET_API_ERROR_BD_NOT_MODIFIABLE;
419  goto out;
420  }
421 
422  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
423  if (p == 0)
424  {
425  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
426  goto out;
427  }
428  bd_set_mac_age (vm, *p, mp->mac_age);
429 out:
430  REPLY_MACRO (VL_API_BRIDGE_DOMAIN_SET_MAC_AGE_REPLY);
431 }
432 
433 static void
435 {
437  .is_add = mp->is_add,
438  .flood = mp->flood,
439  .uu_flood = mp->uu_flood,
440  .forward = mp->forward,
441  .learn = mp->learn,
442  .arp_term = mp->arp_term,
443  .arp_ufwd = mp->arp_ufwd,
444  .mac_age = mp->mac_age,
445  .bd_id = ntohl (mp->bd_id),
446  .bd_tag = mp->bd_tag
447  };
448 
449  int rv = bd_add_del (&a);
450 
451  vl_api_bridge_domain_add_del_reply_t *rmp;
452  REPLY_MACRO (VL_API_BRIDGE_DOMAIN_ADD_DEL_REPLY);
453 }
454 
455 static void
457  vl_api_registration_t * reg,
458  l2_bridge_domain_t * bd_config,
459  u32 n_sw_ifs, u32 context)
460 {
463  vl_api_bridge_domain_sw_if_t *sw_ifs;
464  l2_input_config_t *input_cfg;
465 
466  mp = vl_msg_api_alloc (sizeof (*mp) +
467  (n_sw_ifs * sizeof (vl_api_bridge_domain_sw_if_t)));
468  clib_memset (mp, 0, sizeof (*mp));
469  mp->_vl_msg_id = ntohs (VL_API_BRIDGE_DOMAIN_DETAILS);
470  mp->bd_id = ntohl (bd_config->bd_id);
471  mp->flood = bd_feature_flood (bd_config);
472  mp->uu_flood = bd_feature_uu_flood (bd_config);
473  mp->forward = bd_feature_forward (bd_config);
474  mp->learn = bd_feature_learn (bd_config);
475  mp->arp_term = bd_feature_arp_term (bd_config);
476  mp->arp_ufwd = bd_feature_arp_ufwd (bd_config);
477  mp->bvi_sw_if_index = ntohl (bd_config->bvi_sw_if_index);
478  mp->uu_fwd_sw_if_index = ntohl (bd_config->uu_fwd_sw_if_index);
479  mp->mac_age = bd_config->mac_age;
480  if (bd_config->bd_tag)
481  {
482  strncpy ((char *) mp->bd_tag, (char *) bd_config->bd_tag,
483  ARRAY_LEN (mp->bd_tag) - 1);
484  mp->bd_tag[ARRAY_LEN (mp->bd_tag) - 1] = 0;
485  }
486 
487  mp->context = context;
488 
489  sw_ifs = (vl_api_bridge_domain_sw_if_t *) mp->sw_if_details;
490  vec_foreach (m, bd_config->members)
491  {
492  sw_ifs->sw_if_index = ntohl (m->sw_if_index);
493  input_cfg = vec_elt_at_index (l2im->configs, m->sw_if_index);
494  sw_ifs->shg = input_cfg->shg;
495  sw_ifs++;
496  mp->n_sw_ifs++;
497  }
498  mp->n_sw_ifs = htonl (mp->n_sw_ifs);
499 
500  vl_api_send_msg (reg, (u8 *) mp);
501 }
502 
503 static void
505 {
506  bd_main_t *bdm = &bd_main;
507  l2input_main_t *l2im = &l2input_main;
509  u32 bd_id, bd_index, end;
510 
512  if (!reg)
513  return;
514 
515  bd_id = ntohl (mp->bd_id);
516  if (bd_id == 0)
517  return;
518 
519  if (bd_id == ~0)
520  bd_index = 0, end = vec_len (l2im->bd_configs);
521  else
522  {
523  bd_index = bd_find_index (bdm, bd_id);
524  if (bd_index == ~0)
525  return;
526 
527  end = bd_index + 1;
528  }
529 
530  for (; bd_index < end; bd_index++)
531  {
532  l2_bridge_domain_t *bd_config =
533  l2input_bd_config_from_index (l2im, bd_index);
534  /* skip dummy bd_id 0 */
535  if (bd_config && (bd_config->bd_id > 0))
536  send_bridge_domain_details (l2im, reg, bd_config,
537  vec_len (bd_config->members),
538  mp->context);
539  }
540 }
541 
542 static bd_flags_t
543 bd_flags_decode (vl_api_bd_flags_t v)
544 {
545  bd_flags_t f = L2_NONE;
546 
547  v = ntohl (v);
548 
549  if (v & BRIDGE_API_FLAG_LEARN)
550  f |= L2_LEARN;
551  if (v & BRIDGE_API_FLAG_FWD)
552  f |= L2_FWD;
553  if (v & BRIDGE_API_FLAG_FLOOD)
554  f |= L2_FLOOD;
555  if (v & BRIDGE_API_FLAG_UU_FLOOD)
556  f |= L2_UU_FLOOD;
557  if (v & BRIDGE_API_FLAG_ARP_TERM)
558  f |= L2_ARP_TERM;
559  if (v & BRIDGE_API_FLAG_ARP_UFWD)
560  f |= L2_ARP_UFWD;
561 
562  return (f);
563 }
564 
565 static void
567 {
569  bd_main_t *bdm = &bd_main;
571  u32 bitmap = 0;
572  int rv = 0;
573 
575  u32 bd_id = ntohl (mp->bd_id);
576  if (bd_id == 0)
577  {
578  rv = VNET_API_ERROR_BD_NOT_MODIFIABLE;
579  goto out;
580  }
581 
582  u32 bd_index = bd_find_index (bdm, bd_id);
583  if (bd_index == ~0)
584  {
585  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
586  goto out;
587  }
588 
589  bitmap = bd_set_flags (vm, bd_index, flags, mp->is_set);
590 
591 out:
592  /* *INDENT-OFF* */
593  REPLY_MACRO2(VL_API_BRIDGE_FLAGS_REPLY,
594  ({
595  rmp->resulting_feature_bitmap = ntohl(bitmap);
596  }));
597  /* *INDENT-ON* */
598 }
599 
600 static void
603 {
604  int rv = 0;
605  vl_api_l2_interface_vlan_tag_rewrite_reply_t *rmp;
606  vnet_main_t *vnm = vnet_get_main ();
608  u32 vtr_op;
609 
611 
612  vtr_op = ntohl (mp->vtr_op);
613 
614  /* The L2 code is unsuspicious */
615  switch (vtr_op)
616  {
617  case L2_VTR_DISABLED:
618  case L2_VTR_PUSH_1:
619  case L2_VTR_PUSH_2:
620  case L2_VTR_POP_1:
621  case L2_VTR_POP_2:
626  break;
627 
628  default:
629  rv = VNET_API_ERROR_INVALID_VALUE;
630  goto bad_sw_if_index;
631  }
632 
633  rv = l2vtr_configure (vm, vnm, ntohl (mp->sw_if_index), vtr_op,
634  ntohl (mp->push_dot1q), ntohl (mp->tag1),
635  ntohl (mp->tag2));
636 
638 
639  REPLY_MACRO (VL_API_L2_INTERFACE_VLAN_TAG_REWRITE_REPLY);
640 }
641 
642 static void
645 {
646  vl_api_l2_interface_pbb_tag_rewrite_reply_t *rmp;
647  vnet_main_t *vnm = vnet_get_main ();
649  u32 vtr_op;
650  int rv = 0;
651 
653 
654  vtr_op = ntohl (mp->vtr_op);
655 
656  switch (vtr_op)
657  {
658  case L2_VTR_DISABLED:
659  case L2_VTR_PUSH_2:
660  case L2_VTR_POP_2:
662  break;
663 
664  default:
665  rv = VNET_API_ERROR_INVALID_VALUE;
666  goto bad_sw_if_index;
667  }
668 
669  rv = l2pbb_configure (vm, vnm, ntohl (mp->sw_if_index), vtr_op,
670  mp->b_dmac, mp->b_smac, ntohs (mp->b_vlanid),
671  ntohl (mp->i_sid), ntohs (mp->outer_tag));
672 
674 
675  REPLY_MACRO (VL_API_L2_INTERFACE_PBB_TAG_REWRITE_REPLY);
676 }
677 
678 static void
681 {
682  vl_api_sw_interface_set_l2_xconnect_reply_t *rmp;
683  int rv = 0;
684  u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index);
685  u32 tx_sw_if_index = ntohl (mp->tx_sw_if_index);
687  vnet_main_t *vnm = vnet_get_main ();
688 
690 
691  if (mp->enable)
692  {
694  rv = set_int_l2_mode (vm, vnm, MODE_L2_XC,
695  rx_sw_if_index, 0,
696  L2_BD_PORT_TYPE_NORMAL, 0, tx_sw_if_index);
697  }
698  else
699  {
700  rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0,
701  L2_BD_PORT_TYPE_NORMAL, 0, 0);
702  }
703 
704  switch (rv)
705  {
706  case MODE_ERROR_ETH:
707  rv = VNET_API_ERROR_NON_ETHERNET;
708  break;
709  case MODE_ERROR_BVI_DEF:
710  rv = VNET_API_ERROR_BD_ALREADY_HAS_BVI;
711  break;
712  }
713 
716 
717  REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_XCONNECT_REPLY);
718 }
719 
720 static int
721 l2_bd_port_type_decode (vl_api_l2_port_type_t v, l2_bd_port_type_t * l)
722 {
723  v = clib_net_to_host_u32 (v);
724 
725  switch (v)
726  {
729  return 0;
731  *l = L2_BD_PORT_TYPE_BVI;
732  return 0;
735  return 0;
736  }
737 
738  return (VNET_API_ERROR_INVALID_VALUE);
739 }
740 
741 static void
744 {
745  bd_main_t *bdm = &bd_main;
746  vl_api_sw_interface_set_l2_bridge_reply_t *rmp;
747  int rv = 0;
749  vnet_main_t *vnm = vnet_get_main ();
751 
753  u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index);
754  rv = l2_bd_port_type_decode (mp->port_type, &pt);
755 
756  if (0 != rv)
757  goto out;
758  if (mp->enable)
759  {
760  VALIDATE_BD_ID (mp);
761  u32 bd_id = ntohl (mp->bd_id);
762  u32 bd_index = bd_find_or_add_bd_index (bdm, bd_id);
763 
764  rv = set_int_l2_mode (vm, vnm, MODE_L2_BRIDGE,
765  rx_sw_if_index, bd_index, pt, mp->shg, 0);
766  }
767  else
768  {
769  rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0, pt, 0, 0);
770  }
771 
772  switch (rv)
773  {
774  case MODE_ERROR_ETH:
775  rv = VNET_API_ERROR_NON_ETHERNET;
776  break;
777  case MODE_ERROR_BVI_DEF:
778  rv = VNET_API_ERROR_BD_ALREADY_HAS_BVI;
779  break;
780  }
781 
784 out:
785  REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_BRIDGE_REPLY);
786 }
787 
788 static void
790  vl_api_registration_t * reg,
791  u32 bd_id,
792  const ip46_address_t * ip,
793  ip46_type_t itype,
794  const mac_address_t * mac, u32 context)
795 {
797 
798  mp = vl_msg_api_alloc (sizeof (*mp));
799  clib_memset (mp, 0, sizeof (*mp));
800  mp->_vl_msg_id = ntohs (VL_API_BD_IP_MAC_DETAILS);
801 
802  mp->context = context;
803  mp->entry.bd_id = ntohl (bd_id);
804 
805  ip_address_encode (ip, itype, &mp->entry.ip);
806  mac_address_encode (mac, mp->entry.mac);
807 
808  vl_api_send_msg (reg, (u8 *) mp);
809 }
810 
811 static void
813 {
815  bd_main_t *bdm = &bd_main;
816  l2_bridge_domain_t *bd_config;
817  u32 bd_id = ntohl (mp->bd_id);
818  u32 bd_index, start, end;
820  uword *p;
821 
823  if (!reg)
824  return;
825 
826  /* see bd_id: ~0 means "any" */
827  if (bd_id == ~0)
828  {
829  start = 1;
831  }
832  else
833  {
834  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
835  if (p == 0)
836  return;
837 
838  bd_index = p[0];
840  start = bd_index;
841  end = start + 1;
842  }
843 
844  for (bd_index = start; bd_index < end; bd_index++)
845  {
846  bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index);
847  if (bd_is_valid (bd_config))
848  {
849  ip4_address_t ip4_addr;
850  ip6_address_t *ip6_addr;
852  u64 mac64;
853  bd_id = bd_config->bd_id;
854 
855  /* *INDENT-OFF* */
856  hash_foreach (ip4_addr.as_u32, mac64, bd_config->mac_by_ip4,
857  ({
858  ip46_address_t ip = {
859  .ip4 = ip4_addr,
860  };
861  mac_address_from_u64(&mac, mac64);
862 
863  send_bd_ip_mac_entry (am, reg, bd_id, &ip, IP46_TYPE_IP4,
864  &mac, mp->context);
865  }));
866 
867  hash_foreach_mem (ip6_addr, mac64, bd_config->mac_by_ip6,
868  ({
869  ip46_address_t ip = {
870  .ip6 = *ip6_addr,
871  };
872  mac_address_from_u64(&mac, mac64);
873 
874  send_bd_ip_mac_entry (am, reg, bd_id, &ip, IP46_TYPE_IP6,
875  &mac, mp->context);
876  }));
877  /* *INDENT-ON* */
878  }
879  }
880 }
881 
882 static void
884 {
885  ip46_address_t ip_addr = ip46_address_initializer;
886  vl_api_bd_ip_mac_add_del_reply_t *rmp;
887  bd_main_t *bdm = &bd_main;
888  u32 bd_index, bd_id;
891  int rv = 0;
892  uword *p;
893 
894  bd_id = ntohl (mp->entry.bd_id);
895 
896  if (bd_id == 0)
897  {
898  rv = VNET_API_ERROR_BD_NOT_MODIFIABLE;
899  goto out;
900  }
901 
902  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
903  if (p == 0)
904  {
905  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
906  goto out;
907  }
908  bd_index = p[0];
909 
910  type = ip_address_decode (&mp->entry.ip, &ip_addr);
911  mac_address_decode (mp->entry.mac, &mac);
912 
913  if (bd_add_del_ip_mac (bd_index, type, &ip_addr, &mac, mp->is_add))
914  rv = VNET_API_ERROR_UNSPECIFIED;
915 
916 out:
917  REPLY_MACRO (VL_API_BD_IP_MAC_ADD_DEL_REPLY);
918 }
919 
920 static void
922 {
923  vl_api_bd_ip_mac_flush_reply_t *rmp;
924  bd_main_t *bdm = &bd_main;
925  u32 bd_index, bd_id;
926  int rv = 0;
927  uword *p;
928 
929  bd_id = ntohl (mp->bd_id);
930 
931  if (bd_id == 0)
932  {
933  rv = VNET_API_ERROR_BD_NOT_MODIFIABLE;
934  goto out;
935  }
936 
937  p = hash_get (bdm->bd_index_by_bd_id, bd_id);
938  if (p == 0)
939  {
940  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
941  goto out;
942  }
943  bd_index = p[0];
944 
945  bd_flush_ip_mac (bd_index);
946 
947 out:
948  REPLY_MACRO (VL_API_BD_IP_MAC_FLUSH_REPLY);
949 }
950 
952  u32 sw_if_index, u8 enable);
953 
954 static void
956  mp)
957 {
958  int rv;
959  vl_api_l2_interface_efp_filter_reply_t *rmp;
960  vnet_main_t *vnm = vnet_get_main ();
961 
963 
964  // enable/disable the feature
965  l2_efp_filter_configure (vnm, ntohl (mp->sw_if_index), mp->enable_disable);
966  rv = vnm->api_errno;
967 
969  REPLY_MACRO (VL_API_L2_INTERFACE_EFP_FILTER_REPLY);
970 }
971 
972 static void
974 {
975  extern int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index,
976  int is_add);
977  vl_api_l2_patch_add_del_reply_t *rmp;
978  int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index,
979  int is_add);
980  int rv = 0;
981 
984 
985  rv = vnet_l2_patch_add_del (ntohl (mp->rx_sw_if_index),
986  ntohl (mp->tx_sw_if_index),
987  (int) (mp->is_add != 0));
988 
991 
992  REPLY_MACRO (VL_API_L2_PATCH_ADD_DEL_REPLY);
993 }
994 
995 static void
997 {
998  vl_api_sw_interface_set_vpath_reply_t *rmp;
999  int rv = 0;
1000  u32 sw_if_index = ntohl (mp->sw_if_index);
1001 
1002  VALIDATE_SW_IF_INDEX (mp);
1003 
1004  l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_VPATH, mp->enable);
1005  vnet_feature_enable_disable ("ip4-unicast", "vpath-input-ip4",
1006  sw_if_index, mp->enable, 0, 0);
1007  vnet_feature_enable_disable ("ip4-multicast", "vpath-input-ip4",
1008  sw_if_index, mp->enable, 0, 0);
1009  vnet_feature_enable_disable ("ip6-unicast", "vpath-input-ip6",
1010  sw_if_index, mp->enable, 0, 0);
1011  vnet_feature_enable_disable ("ip6-multicast", "vpath-input-ip6",
1012  sw_if_index, mp->enable, 0, 0);
1013 
1015 
1016  REPLY_MACRO (VL_API_SW_INTERFACE_SET_VPATH_REPLY);
1017 }
1018 
1019 static void
1021 {
1024  u32 sw_if_index;
1025  int rv;
1026 
1027  mac_address_decode (mp->mac, &mac);
1028 
1029  rv = l2_bvi_create (ntohl (mp->user_instance), &mac, &sw_if_index);
1030 
1031  /* *INDENT-OFF* */
1032  REPLY_MACRO2(VL_API_BVI_CREATE_REPLY,
1033  ({
1034  rmp->sw_if_index = ntohl (sw_if_index);
1035  }));
1036  /* *INDENT-ON* */
1037 }
1038 
1039 static void
1041 {
1042  vl_api_bvi_delete_reply_t *rmp;
1043  int rv;
1044 
1045  rv = l2_bvi_delete (ntohl (mp->sw_if_index));
1046 
1047  REPLY_MACRO (VL_API_BVI_DELETE_REPLY);
1048 }
1049 
1050 static bool
1052  const l2_arp_term_publish_event_t * e2)
1053 {
1054  if (e1 == NULL || e2 == NULL)
1055  return false;
1056  return (ip46_address_is_equal (&e1->ip, &e2->ip) &&
1057  (e1->sw_if_index == e2->sw_if_index) &&
1058  (mac_address_equal (&e1->mac, &e2->mac)));
1059 }
1060 
1061 static uword
1063  vlib_frame_t * f)
1064 {
1065  /* These cross the longjmp boundary (vlib_process_wait_for_event)
1066  * and need to be volatile - to prevent them from being optimized into
1067  * a register - which could change during suspension */
1068  volatile f64 last = vlib_time_now (vm);
1069  volatile l2_arp_term_publish_event_t last_event = { };
1070 
1072 
1073  while (1)
1074  {
1075  uword event_type = L2_ARP_TERM_EVENT_PUBLISH;
1077  f64 now;
1078 
1080 
1081  vlib_process_get_event_data (vm, &event_type);
1082  now = vlib_time_now (vm);
1083 
1084  if (event_type == L2_ARP_TERM_EVENT_PUBLISH)
1085  {
1087 
1088  vec_foreach (event, l2am->publish_events)
1089  {
1090  /* dampen duplicate events - cast away volatile */
1092  (event, (l2_arp_term_publish_event_t *) & last_event) &&
1093  (now - last) < 10.0)
1094  {
1095  continue;
1096  }
1097  last_event = *event;
1098  last = now;
1099 
1100  /* *INDENT-OFF* */
1101  pool_foreach(reg, vpe_api_main.l2_arp_term_events_registrations,
1102  ({
1103  vl_api_registration_t *vl_reg;
1104  vl_reg = vl_api_client_index_to_registration (reg->client_index);
1105  ASSERT (vl_reg != NULL);
1106 
1107  if (reg && vl_api_can_send_msg (vl_reg))
1108  {
1109  vl_api_l2_arp_term_event_t * vevent;
1110  vevent = vl_msg_api_alloc (sizeof *vevent);
1111  clib_memset (vevent, 0, sizeof *vevent);
1112  vevent->_vl_msg_id = htons (VL_API_L2_ARP_TERM_EVENT);
1113  vevent->client_index = reg->client_index;
1114  vevent->pid = reg->client_pid;
1115  ip_address_encode(&event->ip,
1116  event->type,
1117  &vevent->ip);
1118  vevent->sw_if_index = htonl(event->sw_if_index);
1119  mac_address_encode(&event->mac, vevent->mac);
1120  vl_api_send_msg (vl_reg, (u8 *) vevent);
1121  }
1122  }));
1123  /* *INDENT-ON* */
1124  }
1126  }
1127  }
1128 
1129  return 0;
1130 }
1131 
1132 /* *INDENT-OFF* */
1133 VLIB_REGISTER_NODE (l2_arp_term_process_node) = {
1134  .function = l2_arp_term_process,
1135  .type = VLIB_NODE_TYPE_PROCESS,
1136  .name = "l2-arp-term-publisher",
1137 };
1138 /* *INDENT-ON* */
1139 
1140 static void
1142  mp)
1143 {
1144  vl_api_want_l2_arp_term_events_reply_t *rmp;
1147  int rv = 0;
1148  uword *p;
1149 
1150  p = hash_get (am->l2_arp_term_events_registration_hash, mp->client_index);
1151 
1152  if (p)
1153  {
1154  if (mp->enable)
1155  {
1156  clib_warning ("pid %d: already enabled...", mp->pid);
1157  rv = VNET_API_ERROR_INVALID_REGISTRATION;
1158  goto reply;
1159  }
1160  else
1161  {
1162  rp = pool_elt_at_index (am->l2_arp_term_events_registrations, p[0]);
1163  pool_put (am->l2_arp_term_events_registrations, rp);
1164  hash_unset (am->l2_arp_term_events_registration_hash,
1165  mp->client_index);
1166  if (pool_elts (am->l2_arp_term_events_registrations) == 0)
1168  goto reply;
1169  }
1170  }
1171  if (mp->enable == 0)
1172  {
1173  clib_warning ("pid %d: already disabled...", mp->pid);
1174  rv = VNET_API_ERROR_INVALID_REGISTRATION;
1175  goto reply;
1176  }
1177  pool_get (am->l2_arp_term_events_registrations, rp);
1178  rp->client_index = mp->client_index;
1179  rp->client_pid = mp->pid;
1180  hash_set (am->l2_arp_term_events_registration_hash, rp->client_index,
1181  rp - am->l2_arp_term_events_registrations);
1183 
1184 reply:
1185  REPLY_MACRO (VL_API_WANT_L2_ARP_TERM_EVENTS_REPLY);
1186 }
1187 
1188 static clib_error_t *
1190 {
1192  vpe_api_main_t *am;
1193  uword *p;
1194 
1195  am = &vpe_api_main;
1196 
1197  /* remove from the registration hash */
1198  p = hash_get (am->l2_arp_term_events_registration_hash, client_index);
1199 
1200  if (p)
1201  {
1202  rp = pool_elt_at_index (am->l2_arp_term_events_registrations, p[0]);
1203  pool_put (am->l2_arp_term_events_registrations, rp);
1204  hash_unset (am->l2_arp_term_events_registration_hash, client_index);
1205  if (pool_elts (am->l2_arp_term_events_registrations) == 0)
1207  }
1208  return (NULL);
1209 }
1210 
1212 
1213 /*
1214  * l2_api_hookup
1215  * Add vpe's API message handlers to the table.
1216  * vlib has already mapped shared memory and
1217  * added the client registration handlers.
1218  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1219  */
1220 #define vl_msg_name_crc_list
1221 #include <vnet/vnet_all_api_h.h>
1222 #undef vl_msg_name_crc_list
1223 
1224 static void
1226 {
1227 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1228  foreach_vl_msg_name_crc_l2;
1229 #undef _
1230 }
1231 
1232 static clib_error_t *
1234 {
1235  api_main_t *am = vlibapi_get_main ();
1236 
1237 #define _(N,n) \
1238  vl_msg_api_set_handlers(VL_API_##N, #n, \
1239  vl_api_##n##_t_handler, \
1240  vl_noop_handler, \
1241  vl_api_##n##_t_endian, \
1242  vl_api_##n##_t_print, \
1243  sizeof(vl_api_##n##_t), 1);
1245 #undef _
1246 
1247  /* Mark VL_API_BRIDGE_DOMAIN_DUMP as mp safe */
1248  am->is_mp_safe[VL_API_BRIDGE_DOMAIN_DUMP] = 1;
1249 
1250  /*
1251  * Set up the (msg_name, crc, message-id) table
1252  */
1254 
1255  return 0;
1256 }
1257 
1259 
1260 /*
1261  * fd.io coding-style-patch-verification: ON
1262  *
1263  * Local Variables:
1264  * eval: (c-set-style "gnu")
1265  * End:
1266  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:440
static void vl_api_want_l2_arp_term_events_t_handler(vl_api_want_l2_arp_term_events_t *mp)
Definition: l2_api.c:1141
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:543
#define vec_foreach_index(var, v)
Iterate over vector indices.
L2 FIB add entry request.
Definition: l2.api:129
#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:358
#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:1040
vl_api_bd_ip_mac_t entry
Definition: l2.api:522
vl_api_mac_address_t mac
Definition: l2.api:491
#define hash_unset(h, key)
Definition: hash.h:261
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:593
vl_api_l2_port_type_t port_type
Definition: l2.api:473
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
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:743
Create BVI interface instance request.
Definition: l2.api:570
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:973
static void vl_api_l2_flags_t_handler(vl_api_l2_flags_t *mp)
Definition: l2_api.c:366
vnet_interface_main_t interface_main
Definition: vnet.h:56
unsigned long u64
Definition: types.h:89
#define REPLY_MACRO2(t, body)
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:279
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)
static heap_elt_t * last(heap_header_t *h)
Definition: heap.c:53
L2 bridge domain set mac age.
Definition: l2.api:234
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:434
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
static void vl_api_bd_ip_mac_dump_t_handler(vl_api_bd_ip_mac_dump_t *mp)
Definition: l2_api.c:812
u32 max_macs_in_event
Definition: l2_fib.h:59
enum l2fib_entry_result_flags_t_ l2fib_entry_result_flags_t
L2 bridge domain request operational state details.
Definition: l2.api:276
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:519
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:237
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
#define clib_memcpy(d, s, n)
Definition: string.h:180
Definition: l2_fib.h:137
Reply to l2_xconnect_dump.
Definition: l2.api:28
static_always_inline u8 bd_feature_arp_ufwd(l2_bridge_domain_t *bd_config)
Definition: l2_input.h:197
L2 bridge domain operational state response.
Definition: l2.api:307
l2learn_main_t l2learn_main
Definition: l2_learn.c:33
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:498
static void vl_api_bd_ip_mac_flush_t_handler(vl_api_bd_ip_mac_flush_t *mp)
Definition: l2_api.c:921
vl_api_interface_index_t sw_if_index
Definition: gre.api:59
#define MODE_L2_BRIDGE
Definition: l2_input.h:221
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:442
u32 feature_bitmap
Definition: l2.api:213
#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
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)
Definition: ip_types_api.c:161
Dump l2 fib (aka bridge domain) table.
Definition: l2.api:68
vl_api_fib_path_type_t type
Definition: fib_types.api:123
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:78
#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:207
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:519
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
struct l2fib_entry_result_t_::@376::@378 fields
u32 bd_id
Definition: gbp.api:175
Set interface L2 flags response.
Definition: l2.api:221
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:287
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:883
#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
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
Create BVI interface instance response.
Definition: l2.api:583
#define hash_foreach_mem(key_var, value_var, h, body)
Definition: hash.h:461
vlib_main_t * vm
Definition: in2out_ed.c:1810
static clib_error_t * l2_api_hookup(vlib_main_t *vm)
Definition: l2_api.c:1233
#define L2FIB_EVENT_MAX_MACS_DEFAULT
Definition: l2_fib.h:37
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
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:225
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
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:46
#define BAD_SW_IF_INDEX_LABEL
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:456
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
u32 flags
Definition: vhost_user.h:141
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
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:789
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:342
#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:1225
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:1189
#define ARRAY_LEN(x)
Definition: clib.h:62
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:57
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:1051
#define VALIDATE_RX_SW_IF_INDEX(mp)
Dump bridge domain IP to MAC entries.
Definition: l2.api:529
void bd_flush_ip_mac(u32 bd_index)
Flush IP address to MAC address mapping tables in a BD.
Definition: l2_bd.c:889
#define L2FIB_EVENT_SCAN_DELAY_DEFAULT
Definition: l2_fib.h:34
Set L2 XConnect between two interfaces request.
Definition: l2.api:433
vl_api_interface_index_t tx_sw_if_index
Definition: ip.api:415
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
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:151
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:591
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:538
#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:225
static void vl_api_l2_interface_vlan_tag_rewrite_t_handler(vl_api_l2_interface_vlan_tag_rewrite_t *mp)
Definition: l2_api.c:602
Interface bridge mode request.
Definition: l2.api:467
#define L2FIB_EVENT_LEARN_LIMIT_DEFAULT
Definition: l2_fib.h:40
static void vl_api_sw_interface_set_l2_xconnect_t_handler(vl_api_sw_interface_set_l2_xconnect_t *mp)
Definition: l2_api.c:680
l2input_main_t l2input_main
Definition: l2_input.c:128
static void vl_api_bvi_create_t_handler(vl_api_bvi_create_t *mp)
Definition: l2_api.c:1020
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:463
static void vl_api_l2fib_flush_bd_t_handler(vl_api_l2fib_flush_bd_t *mp)
Definition: l2_api.c:346
vl_api_address_t ip
Definition: l2.api:490
vl_api_bd_flags_t flags
Definition: l2.api:350
#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 receing ARP reply or MAC/IP info from ARP requests in L2 BDs...
Definition: l2.api:609
u64 uword
Definition: types.h:112
L2 interface ethernet flow point filtering enable/disable request.
Definition: l2.api:542
u32 pid
Definition: dhcp.api:164
static void vl_api_bridge_flags_t_handler(vl_api_bridge_flags_t *mp)
Definition: l2_api.c:566
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:854
static void vl_api_l2_interface_efp_filter_t_handler(vl_api_l2_interface_efp_filter_t *mp)
Definition: l2_api.c:955
struct l2fib_entry_key_t::@368::@370 fields
L2 interface vlan tag rewrite configure request.
Definition: l2.api:374
static void vl_api_l2fib_flush_all_t_handler(vl_api_l2fib_flush_all_t *mp)
Definition: l2_api.c:336
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:406
void ip_address_encode(const ip46_address_t *in, ip46_type_t type, vl_api_address_t *out)
Definition: ip_types_api.c:178
L2 interface patch add / del request.
Definition: l2.api:417
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:378
Interface set vpath request.
Definition: l2.api:556
#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:721
u8 * is_mp_safe
Message is mp safe vector.
Definition: api_common.h:248
L2 interface pbb tag rewrite configure request.
Definition: l2.api:397
u32 sw_if_index
Definition: l2.api:211
#define vec_foreach(var, vec)
Vector iterator.
uword * mac_by_ip4
Definition: l2_bd.h:101
Set bridge flags request.
Definition: l2.api:344
f64 end
end of the time range
Definition: mactime.api:44
Delete BVI interface request.
Definition: l2.api:595
vl_api_bridge_domain_sw_if_t sw_if_details[n_sw_ifs]
Definition: l2.api:322
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:499
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:320
Flush bridge domain IP to MAC entries.
Definition: l2.api:506
#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:1062
static void vl_api_l2_interface_pbb_tag_rewrite_t_handler(vl_api_l2_interface_pbb_tag_rewrite_t *mp)
Definition: l2_api.c:644
vl_api_mac_address_t mac
Definition: l2.api:574
#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:304
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:504
L2 bridge domain add or delete request.
Definition: l2.api:255
static void vl_api_sw_interface_set_vpath_t_handler(vl_api_sw_interface_set_vpath_t *mp)
Definition: l2_api.c:996
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128