FD.io VPP  v19.08.1-401-g8e4ed521a
Vector Packet Processing
gbp_endpoint.c
Go to the documentation of this file.
1 /*
2  * gbp.h : Group Based Policy
3  *
4  * Copyright (c) 2018 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
20 #include <plugins/gbp/gbp_itf.h>
25 #include <plugins/gbp/gbp_vxlan.h>
26 
27 #include <vnet/ethernet/arp.h>
28 #include <vnet/l2/l2_input.h>
29 #include <vnet/l2/l2_output.h>
30 #include <vnet/l2/feat_bitmap.h>
31 #include <vnet/l2/l2_fib.h>
32 #include <vnet/fib/fib_table.h>
33 #include <vnet/ip/ip_neighbor.h>
34 #include <vnet/fib/fib_walk.h>
36 
38 
39 /**
40  * EP DBs
41  */
43 
45 
47 
48 #define GBP_ENDPOINT_DBG(...) \
49  vlib_log_debug (gbp_ep_logger, __VA_ARGS__);
50 
51 #define GBP_ENDPOINT_INFO(...) \
52  vlib_log_notice (gbp_ep_logger, __VA_ARGS__);
53 
54 /**
55  * Pool of GBP endpoints
56  */
58 
59 /**
60  * A count of the number of dynamic entries
61  */
63 
64 #define FOR_EACH_GBP_ENDPOINT_ATTR(_item) \
65  for (_item = GBP_ENDPOINT_ATTR_FIRST; \
66  _item < GBP_ENDPOINT_ATTR_LAST; \
67  _item++)
68 
69 u8 *
70 format_gbp_endpoint_flags (u8 * s, va_list * args)
71 {
74 
76  {
77  if ((1 << attr) & flags)
78  {
79  s = format (s, "%s,", gbp_endpoint_attr_names[attr]);
80  }
81  }
82 
83  return (s);
84 }
85 
86 int
88 {
89  return (! !(ge->ge_fwd.gef_flags & GBP_ENDPOINT_FLAG_REMOTE));
90 }
91 
92 int
94 {
95  return (!(ge->ge_fwd.gef_flags & GBP_ENDPOINT_FLAG_REMOTE));
96 }
97 
98 int
100 {
101  return (! !(ge->ge_fwd.gef_flags & GBP_ENDPOINT_FLAG_EXTERNAL));
102 }
103 
104 int
106 {
107  if (0 == vec_len (ge->ge_locs))
108  return 0;
109 
110  /* DP is the highest source so if present it will be first */
111  return (ge->ge_locs[0].gel_src == GBP_ENDPOINT_SRC_DP);
112 }
113 
114 static void
117 {
118  mac_address_from_u64 (mac, key->key[0]);
119  *sw_if_index = key->key[1];
120 }
121 
122 static void
124  ip46_address_t * ip, u32 * sw_if_index)
125 {
126  ip->as_u64[0] = key->key[0];
127  ip->as_u64[1] = key->key[1];
128  *sw_if_index = key->key[2];
129 }
130 
132 gbp_endpoint_find_ip (const ip46_address_t * ip, u32 fib_index)
133 {
135  int rv;
136 
137  gbp_endpoint_mk_key_ip (ip, fib_index, &key);
138 
139  rv = clib_bihash_search_24_8 (&gbp_ep_db.ged_by_ip_rd, &key, &value);
140 
141  if (0 != rv)
142  return NULL;
143 
144  return (gbp_endpoint_get (value.value));
145 }
146 
147 static void
149 {
150  vec_validate_init_empty (gbp_ep_db.ged_by_sw_if_index, sw_if_index, ~0);
151 
152  gbp_ep_db.ged_by_sw_if_index[sw_if_index] = gei;
153 }
154 
155 static bool
157 {
159  int rv;
160 
161  gbp_endpoint_mk_key_mac (mac->bytes, bd_index, &key);
162  key.value = gei;
163 
164  rv = clib_bihash_add_del_16_8 (&gbp_ep_db.ged_by_mac_bd, &key, 1);
165 
166 
167  return (0 == rv);
168 }
169 
170 static bool
171 gbp_endpoint_add_ip (const ip46_address_t * ip, u32 fib_index, index_t gei)
172 {
174  int rv;
175 
176  gbp_endpoint_mk_key_ip (ip, fib_index, &key);
177  key.value = gei;
178 
179  rv = clib_bihash_add_del_24_8 (&gbp_ep_db.ged_by_ip_rd, &key, 1);
180 
181  return (0 == rv);
182 }
183 
184 static void
186 {
188 
189  gbp_endpoint_mk_key_mac (mac->bytes, bd_index, &key);
190 
191  clib_bihash_add_del_16_8 (&gbp_ep_db.ged_by_mac_bd, &key, 0);
192 }
193 
194 static void
195 gbp_endpoint_del_ip (const ip46_address_t * ip, u32 fib_index)
196 {
198 
199  gbp_endpoint_mk_key_ip (ip, fib_index, &key);
200 
201  clib_bihash_add_del_24_8 (&gbp_ep_db.ged_by_ip_rd, &key, 0);
202 }
203 
204 static index_t
206 {
207  return (ge - gbp_endpoint_pool);
208 }
209 
210 static ip46_type_t
211 ip46_address_get_type (const ip46_address_t * a)
212 {
214 }
215 
216 static int
217 gbp_endpoint_ip_is_equal (const fib_prefix_t * fp, const ip46_address_t * ip)
218 {
219  return (ip46_address_is_equal (ip, &fp->fp_addr));
220 }
221 
222 static void
224  const ip46_address_t * ips,
225  const gbp_route_domain_t * grd)
226 {
227  const ip46_address_t *ip;
228  index_t gei, grdi;
229 
230  gei = gbp_endpoint_index (ge);
231  grdi = gbp_route_domain_index (grd);
232 
233  ASSERT ((ge->ge_key.gek_grd == INDEX_INVALID) ||
234  (ge->ge_key.gek_grd == grdi));
235 
236  vec_foreach (ip, ips)
237  {
238  if (~0 == vec_search_with_function (ge->ge_key.gek_ips, ip,
240  {
241  fib_prefix_t *pfx;
242 
243  vec_add2 (ge->ge_key.gek_ips, pfx, 1);
244  fib_prefix_from_ip46_addr (ip, pfx);
245 
247  grd->grd_fib_index[pfx->fp_proto], gei);
248  }
249  ge->ge_key.gek_grd = grdi;
250  }
251 }
252 
253 static gbp_endpoint_t *
254 gbp_endpoint_alloc (const ip46_address_t * ips,
255  const gbp_route_domain_t * grd,
256  const mac_address_t * mac,
257  const gbp_bridge_domain_t * gbd)
258 {
260  index_t gei;
261 
262  pool_get_zero (gbp_endpoint_pool, ge);
263 
265  gei = gbp_endpoint_index (ge);
266  ge->ge_key.gek_gbd =
271 
272  if (NULL != mac)
273  {
274  mac_address_copy (&ge->ge_key.gek_mac, mac);
275  gbp_endpoint_add_mac (mac, gbd->gb_bd_index, gei);
276  }
277  gbp_endpoint_ips_update (ge, ips, grd);
278 
279  return (ge);
280 }
281 
282 static int
284 {
285  return (a->gel_src == b->gel_src);
286 }
287 
288 static int
290 {
291  return (a->gel_src - b->gel_src);
292 }
293 
294 static gbp_endpoint_loc_t *
296 {
297  gbp_endpoint_loc_t gel = {
298  .gel_src = src,
299  };
300  u32 pos;
301 
302  pos = vec_search_with_function (ge->ge_locs, &gel,
304 
305  if (~0 != pos)
306  return (&ge->ge_locs[pos]);
307 
308  return NULL;
309 }
310 
311 static int
313 {
314  u32 pos;
315 
316  gel->gel_locks--;
317 
318  if (0 == gel->gel_locks)
319  {
320  pos = gel - ge->ge_locs;
321 
322  vec_del1 (ge->ge_locs, pos);
323  if (vec_len (ge->ge_locs) > 1)
325 
326  /* This could be the last lock, so don't access the EP from
327  * this point on */
328  fib_node_unlock (&ge->ge_node);
329 
330  return (1);
331  }
332  return (0);
333 }
334 
335 static void
337 {
339  gbp_itf_unlock (&gel->gel_itf);
340 }
341 
342 static gbp_endpoint_loc_t *
344 {
345  gbp_endpoint_loc_t gel = {
346  .gel_src = src,
347  .gel_epg = INDEX_INVALID,
348  .gel_itf = GBP_ITF_HDL_INVALID,
349  .gel_locks = 0,
350  };
351  u32 pos;
352 
353  pos = vec_search_with_function (ge->ge_locs, &gel,
355 
356  if (~0 == pos)
357  {
358  vec_add1 (ge->ge_locs, gel);
359 
360  if (vec_len (ge->ge_locs) > 1)
361  {
363 
364  pos = vec_search_with_function (ge->ge_locs, &gel,
366  }
367  else
368  pos = 0;
369 
370  /*
371  * it's the sources and children that lock the endpoints
372  */
373  fib_node_lock (&ge->ge_node);
374  }
375 
376  return (&ge->ge_locs[pos]);
377 }
378 
379 /**
380  * Find an EP inthe DBs and check that if we find it in the L2 DB
381  * it has the same IPs as this update
382  */
383 static int
384 gbp_endpoint_find_for_update (const ip46_address_t * ips,
385  const gbp_route_domain_t * grd,
386  const mac_address_t * mac,
387  const gbp_bridge_domain_t * gbd,
388  gbp_endpoint_t ** ge)
389 {
390  gbp_endpoint_t *l2_ge, *l3_ge, *tmp;
391 
392  l2_ge = l3_ge = NULL;
393 
394  if (NULL != mac && !mac_address_is_zero (mac))
395  {
396  ASSERT (gbd);
397  l2_ge = gbp_endpoint_find_mac (mac->bytes, gbd->gb_bd_index);
398  }
399  if (NULL != ips && !ip46_address_is_zero (ips))
400  {
401  const ip46_address_t *ip;
402  fib_protocol_t fproto;
403 
404  ASSERT (grd);
405  vec_foreach (ip, ips)
406  {
408 
409  tmp = gbp_endpoint_find_ip (ip, grd->grd_fib_index[fproto]);
410 
411  if (NULL == tmp)
412  /* not found */
413  continue;
414  else if (NULL == l3_ge)
415  /* first match against an IP address */
416  l3_ge = tmp;
417  else if (tmp == l3_ge)
418  /* another match against IP address that is the same endpoint */
419  continue;
420  else
421  {
422  /*
423  * a match agains a different endpoint.
424  * this means the KEY of the EP is changing which is not allowed
425  */
426  return (-1);
427  }
428  }
429  }
430 
431  if (NULL == l2_ge && NULL == l3_ge)
432  /* not found */
433  *ge = NULL;
434  else if (NULL == l2_ge)
435  /* found at L3 */
436  *ge = l3_ge;
437  else if (NULL == l3_ge)
438  /* found at L2 */
439  *ge = l2_ge;
440  else
441  {
442  /* found both L3 and L2 - they must be the same else the KEY
443  * is changing
444  */
445  if (l2_ge == l3_ge)
446  *ge = l2_ge;
447  else
448  return (-1);
449  }
450 
451  return (0);
452 }
453 
454 static gbp_endpoint_src_t
456 {
457  if (0 == vec_len (ge->ge_locs))
458  return (GBP_ENDPOINT_SRC_MAX);
459 
460  return (ge->ge_locs[0].gel_src);
461 }
462 
463 static void
465 {
467 
468  if (n > 0 && 1 == gbp_n_learnt_endpoints)
469  {
471  gbp_scanner_node.index,
473  }
474  if (n < 0 && 0 == gbp_n_learnt_endpoints)
475  {
477  gbp_scanner_node.index,
479  }
480 }
481 
482 static void
484  gbp_endpoint_loc_t * gel,
485  const gbp_bridge_domain_t * gb,
487  index_t ggi,
489  const ip46_address_t * tun_src,
490  const ip46_address_t * tun_dst)
491 {
492  int was_learnt, is_learnt;
493 
494  gel->gel_locks++;
495  was_learnt = ! !(gel->gel_flags & GBP_ENDPOINT_FLAG_REMOTE);
496  gel->gel_flags = flags;
497  is_learnt = ! !(gel->gel_flags & GBP_ENDPOINT_FLAG_REMOTE);
498 
499  gbp_endpoint_n_learned (is_learnt - was_learnt);
500 
501  /*
502  * update the EPG
503  */
506  gel->gel_epg = ggi;
507 
509  {
510  if (NULL != tun_src)
511  ip46_address_copy (&gel->tun.gel_src, tun_src);
512  if (NULL != tun_dst)
513  ip46_address_copy (&gel->tun.gel_dst, tun_dst);
514 
516  {
517  /*
518  * we learnt the EP from the multicast tunnel.
519  * Create a unicast TEP from the packet's source
520  * and the fixed address of the BD's parent tunnel
521  */
522  const gbp_vxlan_tunnel_t *gt;
523 
524  gt = gbp_vxlan_tunnel_get (gb->gb_vni);
525 
526  if (NULL != gt)
527  {
528  ip46_address_copy (&gel->tun.gel_src, &gt->gt_src);
529  sw_if_index = gt->gt_sw_if_index;
530  }
531  }
532 
533  /*
534  * the input interface may be the parent GBP-vxlan interface,
535  * create a child vlxan-gbp tunnel and use that as the endpoint's
536  * interface.
537  */
538  gbp_itf_hdl_t old = gel->gel_itf;
539 
540  switch (gbp_vxlan_tunnel_get_type (sw_if_index))
541  {
544  gel->gel_itf = gbp_vxlan_tunnel_clone_and_lock (sw_if_index,
545  &gel->tun.gel_src,
546  &gel->tun.gel_dst);
547  break;
548  case VXLAN_GBP_TUNNEL:
550  vxlan_gbp_tunnel_get_parent (sw_if_index);
551  gel->gel_itf = vxlan_gbp_tunnel_lock_itf (sw_if_index);
552  break;
553  }
554 
555  gbp_itf_unlock (&old);
556  }
557  else
558  {
559  gel->gel_itf = gbp_itf_l2_add_and_lock (sw_if_index,
560  ge->ge_key.gek_gbd);
561  }
562 }
563 
564 static void
566 {
567  const gbp_route_domain_t *grd;
568  const gbp_bridge_domain_t *gbd;
569  gbp_endpoint_fwd_t *gef;
570  const fib_prefix_t *pfx;
571  index_t *ai;
572 
574  gef = &ge->ge_fwd;
575 
576  vec_foreach (pfx, ge->ge_key.gek_ips)
577  {
578  u32 fib_index;
579 
580  grd = gbp_route_domain_get (ge->ge_key.gek_grd);
581  fib_index = grd->grd_fib_index[pfx->fp_proto];
582 
584  &pfx->fp_addr, &ge->ge_key.gek_mac, 0);
585 
586  /*
587  * remove a host route
588  */
589  if (gbp_endpoint_is_remote (ge))
590  {
592  }
593 
595  }
596  vec_foreach (ai, gef->gef_adjs)
597  {
598  adj_unlock (*ai);
599  }
600 
601  if (gbp_itf_hdl_is_valid (gef->gef_itf))
602  {
604  gbd->gb_bd_index,
606  }
607 
608  gbp_itf_unlock (&gef->gef_itf);
609  vec_free (gef->gef_adjs);
610 }
611 
612 static void
614 {
615  const gbp_bridge_domain_t *gbd;
616  const gbp_endpoint_group_t *gg;
617  const gbp_route_domain_t *grd;
618  gbp_endpoint_loc_t *gel;
619  gbp_endpoint_fwd_t *gef;
620  const fib_prefix_t *pfx;
621  index_t gei;
622 
623  /*
624  * locations are sort in source priority order
625  */
626  gei = gbp_endpoint_index (ge);
627  gel = &ge->ge_locs[0];
628  gef = &ge->ge_fwd;
630 
631  gef->gef_flags = gel->gel_flags;
632 
633  if (INDEX_INVALID != gel->gel_epg)
634  {
635  gg = gbp_endpoint_group_get (gel->gel_epg);
636  gef->gef_sclass = gg->gg_sclass;
637  }
638  else
639  {
640  gg = NULL;
641  }
642 
643  gef->gef_itf = gbp_itf_clone_and_lock (gel->gel_itf);
644 
645  if (!mac_address_is_zero (&ge->ge_key.gek_mac))
646  {
647  gbp_itf_l2_set_input_feature (gef->gef_itf, L2INPUT_FEAT_GBP_FWD);
648 
650  {
651  /*
652  * bridged packets to external endpoints should be classifed
653  * based on the EP's/BD's EPG
654  */
656  L2OUTPUT_FEAT_GBP_POLICY_MAC);
657  }
658  else
659  {
662  L2OUTPUT_FEAT_GBP_POLICY_PORT);
663  }
665  gbd->gb_bd_index,
667  L2FIB_ENTRY_RESULT_FLAG_STATIC);
668  }
669 
670  vec_foreach (pfx, ge->ge_key.gek_ips)
671  {
672  ethernet_header_t *eth;
673  u32 ip_sw_if_index;
674  u32 fib_index;
675  u8 *rewrite;
676  index_t ai;
677 
678  rewrite = NULL;
679  grd = gbp_route_domain_get (ge->ge_key.gek_grd);
680  fib_index = grd->grd_fib_index[pfx->fp_proto];
681  gef->gef_fib_index = fib_index;
682 
684  &pfx->fp_addr, &ge->ge_key.gek_mac, 1);
685 
686  /*
687  * add a host route via the EPG's BVI we need this because the
688  * adj fib does not install, due to cover refinement check, since
689  * the BVI's prefix is /32
690  */
691  vec_validate (rewrite, sizeof (*eth) - 1);
692  eth = (ethernet_header_t *) rewrite;
693 
694  eth->type = clib_host_to_net_u16 ((pfx->fp_proto == FIB_PROTOCOL_IP4 ?
695  ETHERNET_TYPE_IP4 :
696  ETHERNET_TYPE_IP6));
697 
698  if (gbp_endpoint_is_remote (ge))
699  {
700  /*
701  * for dynamic EPs we must add the IP adjacency via the learned
702  * tunnel since the BD will not contain the EP's MAC since it was
703  * L3 learned. The dst MAC address used is the 'BD's MAC'.
704  */
705  ip_sw_if_index = gbp_itf_get_sw_if_index (gef->gef_itf);
706 
708  eth->src_address);
710  eth->dst_address);
711  }
712  else
713  {
714  /*
715  * for the static EPs we add the IP adjacency via the BVI
716  * knowing that the BD has the MAC address to route to and
717  * that policy will be applied on egress to the EP's port
718  */
719  ip_sw_if_index = gbd->gb_bvi_sw_if_index;
720 
721  clib_memcpy (eth->src_address,
723  ip_sw_if_index),
724  sizeof (eth->src_address));
726  }
727 
728  fib_table_entry_path_add (fib_index, pfx,
731  fib_proto_to_dpo (pfx->fp_proto),
732  &pfx->fp_addr, ip_sw_if_index,
734 
737  &pfx->fp_addr,
738  ip_sw_if_index, rewrite);
739  vec_add1 (gef->gef_adjs, ai);
740 
741  /*
742  * if the endpoint is external then routed packet to it must be
743  * classifed to the BD's EPG. but this will happen anyway with
744  * the GBP_MAC classification.
745  */
746 
747  if (NULL != gg)
748  {
749  if (gbp_endpoint_is_remote (ge))
750  {
751  dpo_id_t policy_dpo = DPO_INVALID;
752 
753  /*
754  * interpose a policy DPO from the endpoint so that policy
755  * is applied
756  */
758  grd->grd_scope,
759  gg->gg_sclass, ~0, &policy_dpo);
760 
761  fib_table_entry_special_dpo_add (fib_index, pfx,
764  &policy_dpo);
765  dpo_reset (&policy_dpo);
766  }
767 
768  /*
769  * send a gratuitous ARP on the EPG's uplink. this is done so
770  * that if this EP has moved from some other place in the
771  * 'fabric', upstream devices are informed
772  */
773  if (gbp_endpoint_is_local (ge) && ~0 != gg->gg_uplink_sw_if_index)
774  {
776  gei);
777  if (FIB_PROTOCOL_IP4 == pfx->fp_proto)
779  &pfx->fp_addr.ip4,
781  else
783  &pfx->fp_addr.ip6,
785  }
786  }
787  }
788 
789  if (gbp_endpoint_is_external (ge))
790  {
792  L2INPUT_FEAT_GBP_LPM_CLASSIFY);
793  }
794  else if (gbp_endpoint_is_local (ge))
795  {
796  /*
797  * non-remote endpoints (i.e. those not arriving on iVXLAN
798  * tunnels) need to be classifed based on the the input interface.
799  * We enable the GBP-FWD feature only if the group has an uplink
800  * interface (on which the GBP-FWD feature would send UU traffic).
801  * External endpoints get classified based on an LPM match
802  */
803  l2input_feat_masks_t feats = L2INPUT_FEAT_GBP_SRC_CLASSIFY;
804 
805  if (NULL != gg && ~0 != gg->gg_uplink_sw_if_index)
806  feats |= L2INPUT_FEAT_GBP_FWD;
808  }
809 
810  /*
811  * update children with the new forwarding info
812  */
813  fib_node_back_walk_ctx_t bw_ctx = {
815  .fnbw_flags = FIB_NODE_BW_FLAG_FORCE_SYNC,
816  };
817 
818  fib_walk_sync (gbp_endpoint_fib_type, gei, &bw_ctx);
819 }
820 
821 int
824  const ip46_address_t * ips,
825  const mac_address_t * mac,
826  index_t gbdi, index_t grdi,
829  const ip46_address_t * tun_src,
830  const ip46_address_t * tun_dst, u32 * handle)
831 {
832  gbp_bridge_domain_t *gbd;
834  gbp_endpoint_src_t best;
835  gbp_route_domain_t *grd;
836  gbp_endpoint_loc_t *gel;
838  index_t ggi, gei;
839  int rv;
840 
841  if (~0 == sw_if_index)
842  return (VNET_API_ERROR_INVALID_SW_IF_INDEX);
843 
844  ge = NULL;
845  gg = NULL;
846 
847  /*
848  * we need to determine the bridge-domain, either from the EPG or
849  * the BD passed
850  */
851  if (SCLASS_INVALID != sclass)
852  {
853  ggi = gbp_endpoint_group_find (sclass);
854 
855  if (INDEX_INVALID == ggi)
856  return (VNET_API_ERROR_NO_SUCH_ENTRY);
857 
858  gg = gbp_endpoint_group_get (ggi);
859  gbdi = gg->gg_gbd;
860  grdi = gg->gg_rd;
861  }
862  else
863  {
864  if (INDEX_INVALID == gbdi)
865  return (VNET_API_ERROR_NO_SUCH_ENTRY);
866  if (INDEX_INVALID == grdi)
867  return (VNET_API_ERROR_NO_SUCH_FIB);
868  ggi = INDEX_INVALID;
869  }
870 
871  gbd = gbp_bridge_domain_get (gbdi);
872  grd = gbp_route_domain_get (grdi);
873  rv = gbp_endpoint_find_for_update (ips, grd, mac, gbd, &ge);
874 
875  if (0 != rv)
876  return (rv);
877 
878  if (NULL == ge)
879  {
880  ge = gbp_endpoint_alloc (ips, grd, mac, gbd);
881  }
882  else
883  {
884  gbp_endpoint_ips_update (ge, ips, grd);
885  }
886 
887  best = gbp_endpoint_get_best_src (ge);
888  gei = gbp_endpoint_index (ge);
889  gel = gbp_endpoint_loc_find_or_add (ge, src);
890 
891  gbp_endpoint_loc_update (ge, gel, gbd, sw_if_index, ggi, flags,
892  tun_src, tun_dst);
893 
894  if (src <= best)
895  {
896  /*
897  * either the best source has been updated or we have a new best source
898  */
901  }
902  else
903  {
904  /*
905  * an update to a lower priority source, so we need do nothing
906  */
907  }
908 
909  if (handle)
910  *handle = gei;
911 
912  GBP_ENDPOINT_INFO ("update: %U", format_gbp_endpoint, gei);
913 
914  return (0);
915 }
916 
917 void
919 {
920  gbp_endpoint_loc_t *gel, gel_copy;
921  gbp_endpoint_src_t best;
923  int removed;
924 
925  if (pool_is_free_index (gbp_endpoint_pool, gei))
926  return;
927 
928  GBP_ENDPOINT_INFO ("delete: %U", format_gbp_endpoint, gei);
929 
930  ge = gbp_endpoint_get (gei);
931 
932  gel = gbp_endpoint_loc_find (ge, src);
933 
934  if (NULL == gel)
935  return;
936 
937  /*
938  * lock the EP so we can control when it is deleted
939  */
940  fib_node_lock (&ge->ge_node);
941  best = gbp_endpoint_get_best_src (ge);
942 
943  /*
944  * copy the location info since we'll lose it when it's removed from
945  * the vector
946  */
947  clib_memcpy (&gel_copy, gel, sizeof (gel_copy));
948 
949  /*
950  * remove the source we no longer need
951  */
952  removed = gbp_endpoint_loc_unlock (ge, gel);
953 
954  if (src == best)
955  {
956  /*
957  * we have removed the old best source => recalculate fwding
958  */
959  if (0 == vec_len (ge->ge_locs))
960  {
961  /*
962  * if there are no more sources left, then we need only release
963  * the fwding resources held and then this EP is gawn.
964  */
966  }
967  else
968  {
969  /*
970  * else there are more sources. release the old and get new
971  * fwding objects
972  */
975  }
976  }
977  /*
978  * else
979  * we removed a lower priority source so we need to do nothing
980  */
981 
982  /*
983  * clear up any resources held by the source
984  */
985  if (removed)
986  gbp_endpoint_loc_destroy (&gel_copy);
987 
988  /*
989  * remove the lock taken above
990  */
991  fib_node_unlock (&ge->ge_node);
992  /*
993  * We may have removed the last source and so this EP is now TOAST
994  * DO NOTHING BELOW HERE
995  */
996 }
997 
998 u32
1001 {
1002  return (fib_node_child_add (gbp_endpoint_fib_type, gei, type, index));
1003 }
1004 
1005 void
1007 {
1008  return (fib_node_child_remove (gbp_endpoint_fib_type, gei, sibling));
1009 }
1010 
1012 {
1017 
1018 static walk_rc_t
1020 {
1021  gbp_endpoint_flush_ctx_t *ctx = args;
1022  gbp_endpoint_loc_t *gel;
1023  gbp_endpoint_t *ge;
1024 
1025  ge = gbp_endpoint_get (gei);
1026  gel = gbp_endpoint_loc_find (ge, ctx->src);
1027 
1028  if ((NULL != gel) && ctx->sw_if_index == gel->tun.gel_parent_sw_if_index)
1029  {
1030  vec_add1 (ctx->geis, gei);
1031  }
1032 
1033  return (WALK_CONTINUE);
1034 }
1035 
1036 /**
1037  * remove all learnt endpoints using the interface
1038  */
1039 void
1041 {
1043  .sw_if_index = sw_if_index,
1044  .src = src,
1045  };
1046  index_t *gei;
1047 
1048  GBP_ENDPOINT_INFO ("flush: %U %U",
1051  sw_if_index);
1053 
1054  vec_foreach (gei, ctx.geis)
1055  {
1056  gbp_endpoint_unlock (src, *gei);
1057  }
1058 
1059  vec_free (ctx.geis);
1060 }
1061 
1062 void
1064 {
1065  u32 index;
1066 
1067  /* *INDENT-OFF* */
1068  pool_foreach_index(index, gbp_endpoint_pool,
1069  {
1070  if (!cb(index, ctx))
1071  break;
1072  });
1073  /* *INDENT-ON* */
1074 }
1075 
1076 static clib_error_t *
1078  unformat_input_t * input, vlib_cli_command_t * cmd)
1079 {
1080  ip46_address_t ip = ip46_address_initializer, *ips = NULL;
1082  vnet_main_t *vnm = vnet_get_main ();
1084  u32 handle = INDEX_INVALID;
1085  u32 sw_if_index = ~0;
1087  u8 add = 1;
1088  int rv;
1089 
1090  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1091  {
1092  ip46_address_reset (&ip);
1093 
1094  if (unformat (input, "%U", unformat_vnet_sw_interface,
1095  vnm, &sw_if_index))
1096  ;
1097  else if (unformat (input, "add"))
1098  add = 1;
1099  else if (unformat (input, "del"))
1100  add = 0;
1101  else if (unformat (input, "sclass %d", &sclass))
1102  ;
1103  else if (unformat (input, "handle %d", &handle))
1104  ;
1105  else if (unformat (input, "ip %U", unformat_ip4_address, &ip.ip4))
1106  vec_add1 (ips, ip);
1107  else if (unformat (input, "ip %U", unformat_ip6_address, &ip.ip6))
1108  vec_add1 (ips, ip);
1109  else if (unformat (input, "mac %U", unformat_mac_address, &mac))
1110  ;
1111  else if (unformat (input, "flags 0x%x", &flags))
1112  ;
1113  else
1114  break;
1115  }
1116 
1117  if (add)
1118  {
1119  if (~0 == sw_if_index)
1120  return clib_error_return (0, "interface must be specified");
1121  if (SCLASS_INVALID == sclass)
1122  return clib_error_return (0, "SCLASS must be specified");
1123 
1124  rv =
1125  gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_CP,
1126  sw_if_index, ips, &mac,
1128  sclass, flags, NULL, NULL, &handle);
1129 
1130  if (rv)
1131  return clib_error_return (0, "GBP Endpoint update returned %d", rv);
1132  else
1133  vlib_cli_output (vm, "handle %d\n", handle);
1134  }
1135  else
1136  {
1137  if (INDEX_INVALID == handle)
1138  return clib_error_return (0, "handle must be specified");
1139 
1140  gbp_endpoint_unlock (GBP_ENDPOINT_SRC_CP, handle);
1141  }
1142 
1143  vec_free (ips);
1144 
1145  return (NULL);
1146 }
1147 
1148 /*?
1149  * Configure a GBP Endpoint
1150  *
1151  * @cliexpar
1152  * @cliexstart{gbp endpoint del <handle> | [add] <interface> sclass <SCLASS> ip <IP> mac <MAC> [flags <flags>]}
1153  * @cliexend
1154  ?*/
1155 /* *INDENT-OFF* */
1156 VLIB_CLI_COMMAND (gbp_endpoint_cli_node, static) = {
1157  .path = "gbp endpoint",
1158  .short_help = "gbp endpoint del <handle> | [add] <interface> sclass <SCLASS> ip <IP> mac <MAC> [flags <flags>]",
1159  .function = gbp_endpoint_cli,
1160 };
1161 /* *INDENT-ON* */
1162 
1163 u8 *
1164 format_gbp_endpoint_src (u8 * s, va_list * args)
1165 {
1166  gbp_endpoint_src_t action = va_arg (*args, gbp_endpoint_src_t);
1167 
1168  switch (action)
1169  {
1170 #define _(v,a) case GBP_ENDPOINT_SRC_##v: return (format (s, "%s", a));
1172 #undef _
1173  }
1174 
1175  return (format (s, "unknown"));
1176 }
1177 
1178 static u8 *
1179 format_gbp_endpoint_fwd (u8 * s, va_list * args)
1180 {
1181  gbp_endpoint_fwd_t *gef = va_arg (*args, gbp_endpoint_fwd_t *);
1182 
1183  s = format (s, "fwd:");
1184  s = format (s, "\n itf:[%U]", format_gbp_itf_hdl, gef->gef_itf);
1185  if (GBP_ENDPOINT_FLAG_NONE != gef->gef_flags)
1186  {
1187  s = format (s, " flags:%U", format_gbp_endpoint_flags, gef->gef_flags);
1188  }
1189 
1190  return (s);
1191 }
1192 
1193 static u8 *
1194 format_gbp_endpoint_key (u8 * s, va_list * args)
1195 {
1196  gbp_endpoint_key_t *gek = va_arg (*args, gbp_endpoint_key_t *);
1197  const fib_prefix_t *pfx;
1198 
1199  s = format (s, "ips:[");
1200 
1201  vec_foreach (pfx, gek->gek_ips)
1202  {
1203  s = format (s, "%U, ", format_fib_prefix, pfx);
1204  }
1205  s = format (s, "]");
1206 
1207  s = format (s, " mac:%U", format_mac_address_t, &gek->gek_mac);
1208 
1209  return (s);
1210 }
1211 
1212 static u8 *
1213 format_gbp_endpoint_loc (u8 * s, va_list * args)
1214 {
1215  gbp_endpoint_loc_t *gel = va_arg (*args, gbp_endpoint_loc_t *);
1216 
1217  s = format (s, "%U", format_gbp_endpoint_src, gel->gel_src);
1218  s = format (s, "\n EPG:%d [%U]", gel->gel_epg,
1219  format_gbp_itf_hdl, gel->gel_itf);
1220 
1221  if (GBP_ENDPOINT_FLAG_NONE != gel->gel_flags)
1222  {
1223  s = format (s, " flags:%U", format_gbp_endpoint_flags, gel->gel_flags);
1224  }
1226  {
1227  s = format (s, " tun:[");
1228  s = format (s, "parent:%U", format_vnet_sw_if_index_name,
1230  s = format (s, " {%U,%U}]",
1233  }
1234 
1235  return (s);
1236 }
1237 
1238 u8 *
1239 format_gbp_endpoint (u8 * s, va_list * args)
1240 {
1241  index_t gei = va_arg (*args, index_t);
1242  gbp_endpoint_loc_t *gel;
1243  gbp_endpoint_t *ge;
1244 
1245  ge = gbp_endpoint_get (gei);
1246 
1247  s = format (s, "[@%d] %U", gei, format_gbp_endpoint_key, &ge->ge_key);
1248  s = format (s, " last-time:[%f]", ge->ge_last_time);
1249 
1250  vec_foreach (gel, ge->ge_locs)
1251  {
1252  s = format (s, "\n %U", format_gbp_endpoint_loc, gel);
1253  }
1254  s = format (s, "\n %U", format_gbp_endpoint_fwd, &ge->ge_fwd);
1255 
1256  return s;
1257 }
1258 
1259 static walk_rc_t
1261 {
1262  vlib_main_t *vm;
1263 
1264  vm = ctx;
1265  vlib_cli_output (vm, " %U", format_gbp_endpoint, gei);
1266 
1267  return (WALK_CONTINUE);
1268 }
1269 
1270 static void
1272 {
1273  ip46_address_t ip;
1274  vlib_main_t *vm;
1275  u32 sw_if_index;
1276 
1277  vm = arg;
1278 
1279  gbp_endpoint_extract_key_ip_itf (kvp, &ip, &sw_if_index);
1280 
1281  vlib_cli_output (vm, " {%U, %U} -> %d",
1284  sw_if_index, kvp->value);
1285 }
1286 
1287 static void
1289 {
1291  vlib_main_t *vm;
1292  u32 sw_if_index;
1293 
1294  vm = arg;
1295 
1296  gbp_endpoint_extract_key_mac_itf (kvp, &mac, &sw_if_index);
1297 
1298  vlib_cli_output (vm, " {%U, %U} -> %d",
1299  format_mac_address_t, &mac,
1301  sw_if_index, kvp->value);
1302 }
1303 
1304 static clib_error_t *
1306  unformat_input_t * input, vlib_cli_command_t * cmd)
1307 {
1308  u32 show_dbs, handle;
1309 
1310  handle = INDEX_INVALID;
1311  show_dbs = 0;
1312 
1313  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1314  {
1315  if (unformat (input, "%d", &handle))
1316  ;
1317  else if (unformat (input, "db"))
1318  show_dbs = 1;
1319  else
1320  break;
1321  }
1322 
1323  if (INDEX_INVALID != handle)
1324  {
1325  vlib_cli_output (vm, "%U", format_gbp_endpoint, handle);
1326  }
1327  else if (show_dbs)
1328  {
1329  vlib_cli_output (vm, "\nDatabases:");
1330  clib_bihash_foreach_key_value_pair_24_8 (&gbp_ep_db.ged_by_ip_rd,
1332  clib_bihash_foreach_key_value_pair_16_8
1333  (&gbp_ep_db.ged_by_mac_bd, gbp_endpoint_walk_mac_itf, vm);
1334  }
1335  else
1336  {
1337  vlib_cli_output (vm, "Endpoints:");
1339  }
1340 
1341  return (NULL);
1342 }
1343 
1344 /*?
1345  * Show Group Based Policy Endpoints and derived information
1346  *
1347  * @cliexpar
1348  * @cliexstart{show gbp endpoint}
1349  * @cliexend
1350  ?*/
1351 /* *INDENT-OFF* */
1352 VLIB_CLI_COMMAND (gbp_endpoint_show_node, static) = {
1353  .path = "show gbp endpoint",
1354  .short_help = "show gbp endpoint\n",
1355  .function = gbp_endpoint_show,
1356 };
1357 /* *INDENT-ON* */
1358 
1359 static void
1360 gbp_endpoint_check (index_t gei, f64 start_time)
1361 {
1363  gbp_endpoint_loc_t *gel;
1364  gbp_endpoint_t *ge;
1365 
1366  ge = gbp_endpoint_get (gei);
1367  gel = gbp_endpoint_loc_find (ge, GBP_ENDPOINT_SRC_DP);
1368 
1369  if (NULL != gel)
1370  {
1371  gg = gbp_endpoint_group_get (gel->gel_epg);
1372 
1373  if ((start_time - ge->ge_last_time) >
1375  {
1376  gbp_endpoint_unlock (GBP_ENDPOINT_SRC_DP, gei);
1377  }
1378  }
1379 }
1380 
1381 static void
1383 {
1384  clib_bihash_16_8_t *gte_table = &gbp_ep_db.ged_by_mac_bd;
1385  f64 last_start, start_time, delta_t;
1386  int i, j, k;
1387 
1388  if (!gte_table->instantiated)
1389  return;
1390 
1391  delta_t = 0;
1392  last_start = start_time = vlib_time_now (vm);
1393 
1394  for (i = 0; i < gte_table->nbuckets; i++)
1395  {
1396  clib_bihash_bucket_16_8_t *b;
1397  clib_bihash_value_16_8_t *v;
1398 
1399  /* allow no more than 20us without a pause */
1400  delta_t = vlib_time_now (vm) - last_start;
1401  if (delta_t > 20e-6)
1402  {
1403  /* suspend for 100 us */
1404  vlib_process_suspend (vm, 100e-6);
1405  last_start = vlib_time_now (vm);
1406  }
1407 
1408  b = &gte_table->buckets[i];
1409  if (b->offset == 0)
1410  continue;
1411  v = clib_bihash_get_value_16_8 (gte_table, b->offset);
1412 
1413  for (j = 0; j < (1 << b->log2_pages); j++)
1414  {
1415  for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
1416  {
1417  if (clib_bihash_is_free_16_8 (&v->kvp[k]))
1418  continue;
1419 
1420  gbp_endpoint_check (v->kvp[k].value, start_time);
1421 
1422  /*
1423  * Note: we may have just freed the bucket's backing
1424  * storage, so check right here...
1425  */
1426  if (b->offset == 0)
1427  goto doublebreak;
1428  }
1429  v++;
1430  }
1431  doublebreak:
1432  ;
1433  }
1434 }
1435 
1436 static void
1438 {
1439  clib_bihash_24_8_t *gte_table = &gbp_ep_db.ged_by_ip_rd;
1440  f64 last_start, start_time, delta_t;
1441  int i, j, k;
1442 
1443  if (!gte_table->instantiated)
1444  return;
1445 
1446  delta_t = 0;
1447  last_start = start_time = vlib_time_now (vm);
1448 
1449  for (i = 0; i < gte_table->nbuckets; i++)
1450  {
1451  clib_bihash_bucket_24_8_t *b;
1452  clib_bihash_value_24_8_t *v;
1453 
1454  /* allow no more than 20us without a pause */
1455  delta_t = vlib_time_now (vm) - last_start;
1456  if (delta_t > 20e-6)
1457  {
1458  /* suspend for 100 us */
1459  vlib_process_suspend (vm, 100e-6);
1460  last_start = vlib_time_now (vm);
1461  }
1462 
1463  b = &gte_table->buckets[i];
1464  if (b->offset == 0)
1465  continue;
1466  v = clib_bihash_get_value_24_8 (gte_table, b->offset);
1467 
1468  for (j = 0; j < (1 << b->log2_pages); j++)
1469  {
1470  for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
1471  {
1472  if (clib_bihash_is_free_24_8 (&v->kvp[k]))
1473  continue;
1474 
1475  gbp_endpoint_check (v->kvp[k].value, start_time);
1476 
1477  /*
1478  * Note: we may have just freed the bucket's backing
1479  * storage, so check right here...
1480  */
1481  if (b->offset == 0)
1482  goto doublebreak;
1483  }
1484  v++;
1485  }
1486  doublebreak:
1487  ;
1488  }
1489 }
1490 
1491 void
1493 {
1494  gbp_endpoint_scan_l2 (vm);
1495  gbp_endpoint_scan_l3 (vm);
1496 }
1497 
1498 static fib_node_t *
1500 {
1501  gbp_endpoint_t *ge;
1502 
1503  ge = gbp_endpoint_get (index);
1504 
1505  return (&ge->ge_node);
1506 }
1507 
1508 static gbp_endpoint_t *
1510 {
1512  return ((gbp_endpoint_t *) node);
1513 }
1514 
1515 static void
1517 {
1518  const gbp_bridge_domain_t *gbd;
1519  const gbp_route_domain_t *grd;
1520  const fib_prefix_t *pfx;
1521  gbp_endpoint_t *ge;
1522 
1523  ge = gbp_endpoint_from_fib_node (node);
1524 
1525  ASSERT (0 == vec_len (ge->ge_locs));
1526 
1527  gbd = gbp_bridge_domain_get (ge->ge_key.gek_gbd);
1528 
1529  /*
1530  * we have removed the last source. this EP is toast
1531  */
1532  if (INDEX_INVALID != ge->ge_key.gek_gbd)
1533  {
1535  }
1536  vec_foreach (pfx, ge->ge_key.gek_ips)
1537  {
1538  grd = gbp_route_domain_get (ge->ge_key.gek_grd);
1539  gbp_endpoint_del_ip (&pfx->fp_addr, grd->grd_fib_index[pfx->fp_proto]);
1540  }
1541  pool_put (gbp_endpoint_pool, ge);
1542 }
1543 
1547 {
1548  ASSERT (0);
1549 
1550  return (FIB_NODE_BACK_WALK_CONTINUE);
1551 }
1552 
1553 /*
1554  * The FIB path's graph node virtual function table
1555  */
1556 static const fib_node_vft_t gbp_endpoint_vft = {
1558  .fnv_last_lock = gbp_endpoint_last_lock_gone,
1559  .fnv_back_walk = gbp_endpoint_back_walk_notify,
1560  // .fnv_mem_show = fib_path_memory_show,
1561 };
1562 
1563 static clib_error_t *
1565 {
1566 #define GBP_EP_HASH_NUM_BUCKETS (2 * 1024)
1567 #define GBP_EP_HASH_MEMORY_SIZE (1 << 20)
1568 
1569  clib_bihash_init_24_8 (&gbp_ep_db.ged_by_ip_rd,
1570  "GBP Endpoints - IP/RD",
1572 
1573  clib_bihash_init_16_8 (&gbp_ep_db.ged_by_mac_bd,
1574  "GBP Endpoints - MAC/BD",
1576 
1577  gbp_ep_logger = vlib_log_register_class ("gbp", "ep");
1578  gbp_endpoint_fib_type = fib_node_register_new_type (&gbp_endpoint_vft);
1579 
1580  return (NULL);
1581 }
1582 
1584 
1585 /*
1586  * fd.io coding-style-patch-verification: ON
1587  *
1588  * Local Variables:
1589  * eval: (c-set-style "gnu")
1590  * End:
1591  */
vlib_log_class_t vlib_log_register_class(char *class, char *subclass)
Definition: log.c:176
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
A real VXLAN-GBP tunnel (from vnet/vxlan-gbp/...)
Definition: gbp_vxlan.h:100
static void gbp_endpoint_scan_l3(vlib_main_t *vm)
index_t gek_grd
Index of the Route-Domain.
Definition: gbp_endpoint.h:109
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:212
fib_node_index_t fib_table_entry_path_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, dpo_proto_t next_hop_proto, const ip46_address_t *next_hop, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, fib_mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags)
Add one path to an entry (aka route) in the FIB.
Definition: fib_table.c:532
int gbp_endpoint_is_external(const gbp_endpoint_t *ge)
Definition: gbp_endpoint.c:99
static gbp_endpoint_loc_t * gbp_endpoint_loc_find_or_add(gbp_endpoint_t *ge, gbp_endpoint_src_t src)
Definition: gbp_endpoint.c:343
static gbp_endpoint_src_t gbp_endpoint_get_best_src(const gbp_endpoint_t *ge)
Definition: gbp_endpoint.c:455
u32 flags
Definition: vhost_user.h:141
u32 gef_fib_index
FIB index the EP is in.
Definition: gbp_endpoint.h:177
int gbp_endpoint_is_remote(const gbp_endpoint_t *ge)
Definition: gbp_endpoint.c:87
static gbp_endpoint_t * gbp_endpoint_get(index_t gbpei)
Get the endpoint from a port/interface.
Definition: gbp_endpoint.h:265
f64 ge_last_time
The last time a packet from seen from this end point.
Definition: gbp_endpoint.h:213
u16 sclass_t
Definition: gbp_types.h:25
index_t * ged_by_sw_if_index
Definition: gbp_endpoint.h:223
A Group Based Policy Endpoint.
Definition: gbp_endpoint.h:190
fib_prefix_t * gek_ips
A vector of ip addresses that belong to the endpoint.
Definition: gbp_endpoint.h:93
const mac_address_t * gbp_route_domain_get_local_mac(void)
vl_api_mac_address_t mac
Definition: l2.api:490
#define BIHASH_KVP_PER_PAGE
Definition: bihash_16_8.h:21
a
Definition: bitmap.h:538
void gbp_endpoint_unlock(gbp_endpoint_src_t src, index_t gei)
Definition: gbp_endpoint.c:918
Information about the location of the endpoint provided by a source of endpoints. ...
Definition: gbp_endpoint.h:116
gbp_endpoint_fwd_t ge_fwd
Definition: gbp_endpoint.h:208
#define GBP_EP_HASH_NUM_BUCKETS
gbp_endpoint_key_t ge_key
The key/ID of this EP.
Definition: gbp_endpoint.h:200
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 gbp_endpoint_walk_mac_itf(const clib_bihash_kv_16_8_t *kvp, void *arg)
#define pool_get_zero(P, E)
Allocate an object E from a pool P and zero it.
Definition: pool.h:239
index_t * gef_adjs
The L3 adj, if created.
Definition: gbp_endpoint.h:167
void fib_node_init(fib_node_t *node, fib_node_type_t type)
Definition: fib_node.c:185
ip46_type_t fib_proto_to_ip46(fib_protocol_t fproto)
Convert from fib_protocol to ip46_type.
Definition: fib_types.c:295
u32 gb_vni
The index of the BD&#39;s VNI interface on which packets from unkown endpoints arrive.
void gbp_itf_l2_set_output_feature(gbp_itf_hdl_t gh, l2output_feat_masks_t feats)
Definition: gbp_itf.c:428
static void gbp_endpoint_walk_ip_itf(const clib_bihash_kv_24_8_t *kvp, void *arg)
struct gbp_endpoint_flush_ctx_t_ gbp_endpoint_flush_ctx_t
Definition: fib_entry.h:292
static void gbp_endpoint_del_ip(const ip46_address_t *ip, u32 fib_index)
Definition: gbp_endpoint.c:195
#define NULL
Definition: clib.h:58
int gbp_endpoint_is_local(const gbp_endpoint_t *ge)
Definition: gbp_endpoint.c:93
static walk_rc_t gbp_endpoint_show_one(index_t gei, void *ctx)
gbp_endpoint_flags_t gef_flags
Definition: gbp_endpoint.h:179
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:279
ip46_address_t gt_src
The source address to use for child tunnels.
Definition: gbp_vxlan.h:82
static gbp_endpoint_loc_t * gbp_endpoint_loc_find(gbp_endpoint_t *ge, gbp_endpoint_src_t src)
Definition: gbp_endpoint.c:295
void gbp_itf_unlock(gbp_itf_hdl_t *gh)
Definition: gbp_itf.c:286
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
u8 src_address[6]
Definition: packet.h:56
enum gbp_endpoint_src_t_ gbp_endpoint_src_t
A bridge Domain Representation.
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:41
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
vl_api_address_t src
Definition: gre.api:51
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:560
int i
static void gbp_endpoint_scan_l2(vlib_main_t *vm)
static_always_inline void mac_address_copy(mac_address_t *dst, const mac_address_t *src)
Definition: mac_address.h:128
format_function_t format_ip46_address
Definition: format.h:61
static_always_inline int mac_address_is_zero(const mac_address_t *mac)
Definition: mac_address.h:106
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
static u32 gbp_n_learnt_endpoints
A count of the number of dynamic entries.
Definition: gbp_endpoint.c:62
unformat_function_t unformat_vnet_sw_interface
index_t gg_rd
route-domain/IP-table ID the EPG is in
static void gbp_endpoint_loc_update(const gbp_endpoint_t *ge, gbp_endpoint_loc_t *gel, const gbp_bridge_domain_t *gb, u32 sw_if_index, index_t ggi, gbp_endpoint_flags_t flags, const ip46_address_t *tun_src, const ip46_address_t *tun_dst)
Definition: gbp_endpoint.c:483
index_t gbp_route_domain_index(const gbp_route_domain_t *grd)
static gbp_bridge_domain_t * gbp_bridge_domain_get(index_t i)
gbp_endpoint_src_t gel_src
The source providing this location information.
Definition: gbp_endpoint.h:121
adj_index_t adj_nbr_add_or_lock_w_rewrite(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index, u8 *rewrite)
Add (and lock) a new or lock an existing neighbour adjacency.
Definition: adj_nbr.c:263
static int clib_bihash_is_free_16_8(clib_bihash_kv_16_8_t *v)
Definition: bihash_16_8.h:39
static void gbb_endpoint_fwd_reset(gbp_endpoint_t *ge)
Definition: gbp_endpoint.c:565
format_function_t format_vnet_sw_if_index_name
#define GBP_ENDPOINT_SRC_MAX
Definition: gbp_endpoint.h:78
unsigned char u8
Definition: types.h:56
static gbp_endpoint_t * gbp_endpoint_from_fib_node(fib_node_t *node)
fib_node_type_t fib_node_register_new_type(const fib_node_vft_t *vft)
Create a new FIB node type and Register the function table for it.
Definition: fib_node.c:80
static int gbp_endpoint_ip_is_equal(const fib_prefix_t *fp, const ip46_address_t *ip)
Definition: gbp_endpoint.c:217
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
u32 fib_node_child_add(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_type_t type, fib_node_index_t index)
Definition: fib_node.c:98
static uword ip46_address_is_multicast(const ip46_address_t *a)
Definition: ip6_packet.h:193
double f64
Definition: types.h:142
static void gbp_endpoint_loc_destroy(gbp_endpoint_loc_t *gel)
Definition: gbp_endpoint.c:336
u32 gbp_itf_get_sw_if_index(gbp_itf_hdl_t hdl)
Definition: gbp_itf.c:148
#define clib_memcpy(d, s, n)
Definition: string.h:180
index_t gbp_bridge_domain_index(const gbp_bridge_domain_t *gbd)
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
Definition: node_funcs.h:422
enum walk_rc_t_ walk_rc_t
Walk return code.
gbp_endpoint_t * gbp_endpoint_pool
Pool of GBP endpoints.
Definition: gbp_endpoint.c:57
u32 vlib_log_class_t
Definition: vlib.h:51
unformat_function_t unformat_ip4_address
Definition: format.h:70
gbp_endpoint_flags_t gel_flags
Endpoint flags.
Definition: gbp_endpoint.h:131
vl_api_interface_index_t sw_if_index
Definition: gre.api:50
static int gbp_endpoint_loc_unlock(gbp_endpoint_t *ge, gbp_endpoint_loc_t *gel)
Definition: gbp_endpoint.c:312
static_always_inline void mac_address_to_bytes(const mac_address_t *mac, u8 *bytes)
Definition: mac_address.h:99
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a &#39;special&#39; entry from the FIB.
Definition: fib_table.c:407
void fib_walk_sync(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_back_walk_ctx_t *ctx)
Back walk all the children of a FIB node.
Definition: fib_walk.c:745
u8 dst_address[6]
Definition: packet.h:55
gbp_endpoint_group_t * gbp_endpoint_group_get(index_t i)
u8 * format_fib_prefix(u8 *s, va_list *args)
Definition: fib_types.c:185
A high priority source a plugin can use.
Definition: fib_entry.h:67
clib_bihash_24_8_t ged_by_ip_rd
Definition: gbp_endpoint.h:224
static int clib_bihash_is_free_24_8(const clib_bihash_kv_24_8_t *v)
Definition: bihash_24_8.h:39
static_always_inline gbp_endpoint_t * gbp_endpoint_find_mac(const u8 *mac, u32 bd_index)
Definition: gbp_endpoint.h:279
Aggregate type for a prefix.
Definition: fib_types.h:203
u8 * format_gbp_endpoint_flags(u8 *s, va_list *args)
Definition: gbp_endpoint.c:70
#define clib_error_return(e, args...)
Definition: error.h:99
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:401
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
Definition: adj.c:322
unsigned int u32
Definition: types.h:88
index_t gek_gbd
Index of the Bridge-Domain.
Definition: gbp_endpoint.h:104
static void gbp_endpoint_extract_key_ip_itf(const clib_bihash_kv_24_8_t *key, ip46_address_t *ip, u32 *sw_if_index)
Definition: gbp_endpoint.c:123
static fib_node_back_walk_rc_t gbp_endpoint_back_walk_notify(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
static void gbp_endpoint_check(index_t gei, f64 start_time)
static const u8 * vnet_sw_interface_get_hw_address(vnet_main_t *vnm, u32 sw_if_index)
Definition: fib_entry.h:281
vl_api_fib_path_type_t type
Definition: fib_types.api:123
fib_protocol_t fib_proto_from_ip46(ip46_type_t iproto)
Convert from ip46_type to fib_protocol.
Definition: fib_types.c:311
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:170
fib_node_bw_reason_flag_t fnbw_reason
The reason/trigger for the backwalk.
Definition: fib_node.h:212
#define GBP_ENDPOINT_ATTR_NAMES
Definition: gbp_endpoint.h:51
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:934
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:226
GBP Endpoint Databases.
Definition: gbp_endpoint.h:221
gbp_itf_hdl_t gel_itf
The interface on which the EP is connected.
Definition: gbp_endpoint.h:126
void fib_node_lock(fib_node_t *node)
Definition: fib_node.c:203
long ctx[MAX_CONNS]
Definition: main.c:144
static u8 * format_gbp_endpoint_key(u8 *s, va_list *args)
struct _unformat_input_t unformat_input_t
void gbp_policy_dpo_add_or_lock(dpo_proto_t dproto, gbp_scope_t scope, sclass_t sclass, u32 sw_if_index, dpo_id_t *dpo)
void gbp_endpoint_scan(vlib_main_t *vm)
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
u16 sclass
Definition: gbp.api:122
This is the object type deifend above.
Definition: gbp_vxlan.h:95
static fib_node_t * gbp_endpoint_get_node(fib_node_index_t index)
clib_bihash_16_8_t ged_by_mac_bd
Definition: gbp_endpoint.h:225
#define vec_del1(v, i)
Delete the element at index I.
Definition: vec.h:804
u32 remote_ep_timeout
Aging timeout for remote endpoints.
static_always_inline void mac_address_from_u64(mac_address_t *mac, u64 u)
Definition: mac_address.h:122
#define SCLASS_INVALID
Definition: gbp_types.h:26
fib_node_type_t fn_type
The node&#39;s type.
Definition: fib_node.h:299
An node in the FIB graph.
Definition: fib_node.h:295
sclass_t gef_sclass
Endpoint Group&#39;s sclass.
Definition: gbp_endpoint.h:172
gbp_itf_hdl_t gbp_vxlan_tunnel_clone_and_lock(u32 sw_if_index, const ip46_address_t *src, const ip46_address_t *dst)
Definition: gbp_vxlan.c:271
l2input_feat_masks_t
Definition: l2_input.h:141
void fib_node_unlock(fib_node_t *node)
Definition: fib_node.c:209
static ip46_type_t ip46_address_get_type(const ip46_address_t *a)
Definition: gbp_endpoint.c:211
mac_address_t gek_mac
MAC address of the endpoint.
Definition: gbp_endpoint.h:99
gbp_itf_hdl_t vxlan_gbp_tunnel_lock_itf(u32 sw_if_index)
Definition: gbp_vxlan.c:237
int gbp_endpoint_update_and_lock(gbp_endpoint_src_t src, u32 sw_if_index, const ip46_address_t *ips, const mac_address_t *mac, index_t gbdi, index_t grdi, sclass_t sclass, gbp_endpoint_flags_t flags, const ip46_address_t *tun_src, const ip46_address_t *tun_dst, u32 *handle)
Definition: gbp_endpoint.c:822
u32 gbp_endpoint_child_add(index_t gei, fib_node_type_t type, fib_node_index_t index)
Definition: gbp_endpoint.c:999
An Endpoint Group representation.
#define ip46_address_initializer
Definition: ip6_packet.h:96
vlib_node_registration_t gbp_scanner_node
(constructor) VLIB_REGISTER_NODE (gbp_scanner_node)
Definition: gbp_scanner.c:89
void gbp_itf_hdl_reset(gbp_itf_hdl_t *gh)
Definition: gbp_itf.c:108
static void gbp_endpoint_ips_update(gbp_endpoint_t *ge, const ip46_address_t *ips, const gbp_route_domain_t *grd)
Definition: gbp_endpoint.c:223
#define ip46_address_is_ip4(ip46)
Definition: ip6_packet.h:88
unformat_function_t unformat_ip6_address
Definition: format.h:91
static u8 * format_gbp_endpoint_loc(u8 *s, va_list *args)
bool gbp_itf_hdl_is_valid(gbp_itf_hdl_t gh)
Definition: gbp_itf.c:114
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
u32 l2fib_del_entry(const u8 *mac, u32 bd_index, u32 sw_if_index)
Delete an entry from the l2fib.
Definition: l2_fib.c:685
static void gbp_endpoint_add_itf(u32 sw_if_index, index_t gei)
Definition: gbp_endpoint.c:148
enum gbp_endpoint_attr_t_ gbp_endpoint_attr_t
Flags for each endpoint.
vlib_main_t * vm
Definition: buffer.c:323
static bool gbp_endpoint_add_ip(const ip46_address_t *ip, u32 fib_index, index_t gei)
Definition: gbp_endpoint.c:171
gbp_itf_hdl_t gbp_itf_l2_add_and_lock(u32 sw_if_index, index_t gbi)
Definition: gbp_itf.c:196
void gbp_endpoint_walk(gbp_endpoint_cb_t cb, void *ctx)
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
void fib_table_entry_delete(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Delete a FIB entry.
Definition: fib_table.c:869
Force the walk to be synchronous.
Definition: fib_node.h:174
#define FOR_EACH_GBP_ENDPOINT_ATTR(_item)
Definition: gbp_endpoint.c:64
u32 grd_fib_index[FIB_PROTOCOL_IP_MAX]
void gbp_endpoint_group_lock(index_t ggi)
fib_node_get_t fnv_get
Definition: fib_node.h:283
void send_ip6_na_w_addr(vlib_main_t *vm, const ip6_address_t *addr, u32 sw_if_index)
#define vec_search_with_function(v, E, fn)
Search a vector for the index of the entry that matches.
Definition: vec.h:961
static_always_inline void ip46_address_copy(ip46_address_t *dst, const ip46_address_t *src)
Definition: ip6_packet.h:114
static void gbb_endpoint_fwd_recalc(gbp_endpoint_t *ge)
Definition: gbp_endpoint.c:613
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:283
uword unformat_mac_address(unformat_input_t *input, va_list *args)
Definition: format.c:241
void fib_prefix_from_ip46_addr(const ip46_address_t *addr, fib_prefix_t *pfx)
Host prefix from ip.
Definition: fib_types.c:81
static clib_error_t * gbp_endpoint_init(vlib_main_t *vm)
gbp_endpoint_t * gbp_endpoint_find_ip(const ip46_address_t *ip, u32 fib_index)
Definition: gbp_endpoint.c:132
void send_ip4_garp_w_addr(vlib_main_t *vm, const ip4_address_t *ip4_addr, u32 sw_if_index)
Definition: arp.c:3020
void gbp_endpoint_flush(gbp_endpoint_src_t src, u32 sw_if_index)
remove all learnt endpoints using the interface
Context passed between object during a back walk.
Definition: fib_node.h:208
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:161
This is the identity of an endpoint, as such it is information about an endpoint that is idempotent...
Definition: gbp_endpoint.h:87
static walk_rc_t gbp_endpoint_flush_cb(index_t gei, void *args)
fib_node_index_t fib_table_entry_special_dpo_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo)
Add a &#39;special&#39; entry to the FIB that links to the DPO passed A special entry is an entry that the FI...
Definition: fib_table.c:307
gbp_endpoint_src_t src
enum gbp_endpoint_flags_t_ gbp_endpoint_flags_t
static bool gbp_endpoint_add_mac(const mac_address_t *mac, u32 bd_index, index_t gei)
Definition: gbp_endpoint.c:156
u8 value
Definition: qos.api:53
#define ASSERT(truth)
gbp_route_domain_t * gbp_route_domain_get(index_t i)
static u8 * format_gbp_endpoint_fwd(u8 *s, va_list *args)
u8 * format_gbp_endpoint(u8 *s, va_list *args)
const mac_address_t ZERO_MAC_ADDRESS
Definition: mac_address.c:19
u32 gb_bvi_sw_if_index
The BD&#39;s BVI interface (obligatory)
u8 * format_gbp_itf_hdl(u8 *s, va_list *args)
Definition: gbp_itf.c:520
vlib_log_class_t gbp_ep_logger
Definition: gbp_endpoint.c:46
ip46_type_t
Definition: ip6_packet.h:70
void gbp_endpoint_group_unlock(index_t ggi)
const mac_address_t * gbp_route_domain_get_remote_mac(void)
#define GBP_ENDPOINT_INFO(...)
Definition: gbp_endpoint.c:51
static clib_error_t * gbp_endpoint_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
void fib_node_child_remove(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_index_t sibling_index)
Definition: fib_node.c:123
gbp_endpoint_retention_t gg_retention
EP retention policy.
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:245
static gbp_endpoint_t * gbp_endpoint_alloc(const ip46_address_t *ips, const gbp_route_domain_t *grd, const mac_address_t *mac, const gbp_bridge_domain_t *gbd)
Definition: gbp_endpoint.c:254
static void gbp_endpoint_del_mac(const mac_address_t *mac, u32 bd_index)
Definition: gbp_endpoint.c:185
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
static_always_inline void gbp_endpoint_mk_key_mac(const u8 *mac, u32 bd_index, clib_bihash_kv_16_8_t *key)
Definition: gbp_endpoint.h:271
int gbp_endpoint_is_learnt(const gbp_endpoint_t *ge)
Definition: gbp_endpoint.c:105
#define ip46_address_reset(ip46)
Definition: ip6_packet.h:91
static_always_inline void gbp_endpoint_mk_key_ip(const ip46_address_t *ip, u32 fib_index, clib_bihash_kv_24_8_t *key)
Definition: gbp_endpoint.h:295
static int gbp_endpoint_find_for_update(const ip46_address_t *ips, const gbp_route_domain_t *grd, const mac_address_t *mac, const gbp_bridge_domain_t *gbd, gbp_endpoint_t **ge)
Find an EP inthe DBs and check that if we find it in the L2 DB it has the same IPs as this update...
Definition: gbp_endpoint.c:384
static int gbp_endpoint_loc_cmp_for_sort(gbp_endpoint_loc_t *a, gbp_endpoint_loc_t *b)
Definition: gbp_endpoint.c:289
fib_node_t ge_node
A FIB node that allows the tracking of children.
Definition: gbp_endpoint.h:195
gbp_itf_hdl_t gef_itf
The interface on which the EP is connected.
Definition: gbp_endpoint.h:162
vl_api_address_t ip
Definition: l2.api:489
gbp_vxlan_tunnel_t * gbp_vxlan_tunnel_get(index_t gti)
Definition: gbp_vxlan.c:84
u32 gel_locks
number of times this source has locked this
Definition: gbp_endpoint.h:141
void gbp_itf_l2_set_input_feature(gbp_itf_hdl_t gh, l2input_feat_masks_t feats)
Definition: gbp_itf.c:382
And endpoints current forwarding state.
Definition: gbp_endpoint.h:157
u32 vxlan_gbp_tunnel_get_parent(u32 sw_if_index)
Definition: gbp_vxlan.c:222
#define ip46_address_is_equal(a1, a2)
Definition: ip6_packet.h:94
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
A route Domain Representation.
u32 gg_uplink_sw_if_index
the uplink interface dedicated to the EPG
static void gbp_endpoint_n_learned(int n)
Definition: gbp_endpoint.c:464
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:980
gbp_itf_hdl_t gbp_itf_clone_and_lock(gbp_itf_hdl_t gh)
Definition: gbp_itf.c:271
static int gbp_endpoint_loc_is_equal(gbp_endpoint_loc_t *a, gbp_endpoint_loc_t *b)
Definition: gbp_endpoint.c:283
typedef key
Definition: ipsec.api:247
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:197
static void gbp_endpoint_last_lock_gone(fib_node_t *node)
gbp_vxlan_tunnel_type_t gbp_vxlan_tunnel_get_type(u32 sw_if_index)
Definition: gbp_vxlan.c:253
gbp_ep_db_t gbp_ep_db
EP DBs.
Definition: gbp_endpoint.c:42
struct gbp_endpoint_loc_t_::@462 tun
Tunnel info for remote endpoints.
A FIB graph nodes virtual function table.
Definition: fib_node.h:282
GBP VXLAN (template) tunnel.
Definition: gbp_vxlan.h:39
static const gbp_itf_hdl_t GBP_ITF_HDL_INVALID
Definition: gbp_itf.h:57
enum fib_node_type_t_ fib_node_type_t
The types of nodes in a FIB graph.
index_t gbp_endpoint_group_find(sclass_t sclass)
u8 * format_mac_address_t(u8 *s, va_list *args)
Definition: mac_address.c:27
vl_api_address_t ips[n_ips]
Definition: gbp.api:127
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:232
#define vec_foreach(var, vec)
Vector iterator.
vnet_link_t fib_proto_to_link(fib_protocol_t proto)
Convert from a protocol to a link type.
Definition: fib_types.c:279
static void gbp_endpoint_extract_key_mac_itf(const clib_bihash_kv_16_8_t *key, mac_address_t *mac, u32 *sw_if_index)
Definition: gbp_endpoint.c:115
index_t gel_epg
Endpoint Group.
Definition: gbp_endpoint.h:136
#define pool_foreach_index(i, v, body)
Iterate pool by index.
Definition: pool.h:538
static const char * gbp_endpoint_attr_names[]
Definition: gbp_endpoint.c:37
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:486
u8 ge
Definition: ip_types.api:135
fib_node_type_t gbp_endpoint_fib_type
Definition: gbp_endpoint.c:44
gbp_endpoint_loc_t * ge_locs
Location information provided by the various sources.
Definition: gbp_endpoint.h:206
#define ip46_address_is_zero(ip46)
Definition: ip6_packet.h:93
ip46_address_t gel_dst
Definition: gbp_endpoint.h:150
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:772
A low (below routing) priority source a plugin can use.
Definition: fib_entry.h:87
#define GBP_EP_HASH_MEMORY_SIZE
void gbp_endpoint_child_remove(index_t gei, u32 sibling)
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static index_t gbp_endpoint_index(const gbp_endpoint_t *ge)
Definition: gbp_endpoint.c:205
static clib_error_t * gbp_endpoint_cli(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
walk_rc_t(* gbp_endpoint_cb_t)(index_t gbpei, void *ctx)
Definition: gbp_endpoint.h:244
index_t gg_gbd
Bridge-domain ID the EPG is in.
u8 * format_gbp_endpoint_src(u8 *s, va_list *args)