src/plugins/gbp/gbp_endpoint.c

   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
  18 #include <plugins/gbp/gbp_endpoint.h>
  19 #include <plugins/gbp/gbp_endpoint_group.h>
  20 #include <plugins/gbp/gbp_itf.h>
  21 #include <plugins/gbp/gbp_scanner.h>
  22 #include <plugins/gbp/gbp_bridge_domain.h>
  23 #include <plugins/gbp/gbp_route_domain.h>
  24 #include <plugins/gbp/gbp_policy_dpo.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>
  35 #include <vnet/vxlan-gbp/vxlan_gbp.h>
  36
  37 static const char *gbp_endpoint_attr_names[] = GBP_ENDPOINT_ATTR_NAMES;
  38
  39 /**
  40  * EP DBs
  41  */
  42 gbp_ep_db_t gbp_ep_db;
  43
  44 fib_node_type_t gbp_endpoint_fib_type;
  45
  46 vlib_log_class_t gbp_ep_logger;
  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  */
  57 gbp_endpoint_t *gbp_endpoint_pool;
  58
  59 /**
  60  * A count of the number of dynamic entries
  61  */
  62 static u32 gbp_n_learnt_endpoints;
  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 {
  72   gbp_endpoint_attr_t attr;
  73   gbp_endpoint_flags_t flags = va_arg (*args, gbp_endpoint_flags_t);
  74
  75   FOR_EACH_GBP_ENDPOINT_ATTR (attr)
  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
  87 gbp_endpoint_is_remote (const gbp_endpoint_t * ge)
  88 {
  89   return (! !(ge->ge_fwd.gef_flags & GBP_ENDPOINT_FLAG_REMOTE));
  90 }
  91
  92 int
  93 gbp_endpoint_is_local (const gbp_endpoint_t * ge)
  94 {
  95   return (!(ge->ge_fwd.gef_flags & GBP_ENDPOINT_FLAG_REMOTE));
  96 }
  97
  98 int
  99 gbp_endpoint_is_external (const gbp_endpoint_t * ge)
 100 {
 101   return (! !(ge->ge_fwd.gef_flags & GBP_ENDPOINT_FLAG_EXTERNAL));
 102 }
 103
 104 static void
 105 gbp_endpoint_extract_key_mac_itf (const clib_bihash_kv_16_8_t * key,
 106                                   mac_address_t * mac, u32 * sw_if_index)
 107 {
 108   mac_address_from_u64 (mac, key->key[0]);
 109   *sw_if_index = key->key[1];
 110 }
 111
 112 static void
 113 gbp_endpoint_extract_key_ip_itf (const clib_bihash_kv_24_8_t * key,
 114                                  ip46_address_t * ip, u32 * sw_if_index)
 115 {
 116   ip->as_u64[0] = key->key[0];
 117   ip->as_u64[1] = key->key[1];
 118   *sw_if_index = key->key[2];
 119 }
 120
 121 gbp_endpoint_t *
 122 gbp_endpoint_find_ip (const ip46_address_t * ip, u32 fib_index)
 123 {
 124   clib_bihash_kv_24_8_t key, value;
 125   int rv;
 126
 127   gbp_endpoint_mk_key_ip (ip, fib_index, &key);
 128
 129   rv = clib_bihash_search_24_8 (&gbp_ep_db.ged_by_ip_rd, &key, &value);
 130
 131   if (0 != rv)
 132     return NULL;
 133
 134   return (gbp_endpoint_get (value.value));
 135 }
 136
 137 static void
 138 gbp_endpoint_add_itf (u32 sw_if_index, index_t gei)
 139 {
 140   vec_validate_init_empty (gbp_ep_db.ged_by_sw_if_index, sw_if_index, ~0);
 141
 142   gbp_ep_db.ged_by_sw_if_index[sw_if_index] = gei;
 143 }
 144
 145 static bool
 146 gbp_endpoint_add_mac (const mac_address_t * mac, u32 bd_index, index_t gei)
 147 {
 148   clib_bihash_kv_16_8_t key;
 149   int rv;
 150
 151   gbp_endpoint_mk_key_mac (mac->bytes, bd_index, &key);
 152   key.value = gei;
 153
 154   rv = clib_bihash_add_del_16_8 (&gbp_ep_db.ged_by_mac_bd, &key, 1);
 155
 156
 157   return (0 == rv);
 158 }
 159
 160 static bool
 161 gbp_endpoint_add_ip (const ip46_address_t * ip, u32 fib_index, index_t gei)
 162 {
 163   clib_bihash_kv_24_8_t key;
 164   int rv;
 165
 166   gbp_endpoint_mk_key_ip (ip, fib_index, &key);
 167   key.value = gei;
 168
 169   rv = clib_bihash_add_del_24_8 (&gbp_ep_db.ged_by_ip_rd, &key, 1);
 170
 171   return (0 == rv);
 172 }
 173
 174 static void
 175 gbp_endpoint_del_mac (const mac_address_t * mac, u32 bd_index)
 176 {
 177   clib_bihash_kv_16_8_t key;
 178
 179   gbp_endpoint_mk_key_mac (mac->bytes, bd_index, &key);
 180
 181   clib_bihash_add_del_16_8 (&gbp_ep_db.ged_by_mac_bd, &key, 0);
 182 }
 183
 184 static void
 185 gbp_endpoint_del_ip (const ip46_address_t * ip, u32 fib_index)
 186 {
 187   clib_bihash_kv_24_8_t key;
 188
 189   gbp_endpoint_mk_key_ip (ip, fib_index, &key);
 190
 191   clib_bihash_add_del_24_8 (&gbp_ep_db.ged_by_ip_rd, &key, 0);
 192 }
 193
 194 static index_t
 195 gbp_endpoint_index (const gbp_endpoint_t * ge)
 196 {
 197   return (ge - gbp_endpoint_pool);
 198 }
 199
 200 static ip46_type_t
 201 ip46_address_get_type (const ip46_address_t * a)
 202 {
 203   return (ip46_address_is_ip4 (a) ? IP46_TYPE_IP4 : IP46_TYPE_IP6);
 204 }
 205
 206 static int
 207 gbp_endpoint_ip_is_equal (const fib_prefix_t * fp, const ip46_address_t * ip)
 208 {
 209   return (ip46_address_is_equal (ip, &fp->fp_addr));
 210 }
 211
 212 static void
 213 gbp_endpoint_ips_update (gbp_endpoint_t * ge,
 214                          const ip46_address_t * ips,
 215                          const gbp_route_domain_t * grd)
 216 {
 217   const ip46_address_t *ip;
 218   index_t gei, grdi;
 219
 220   gei = gbp_endpoint_index (ge);
 221   grdi = gbp_route_domain_index (grd);
 222
 223   ASSERT ((ge->ge_key.gek_grd == INDEX_INVALID) ||
 224           (ge->ge_key.gek_grd == grdi));
 225
 226   vec_foreach (ip, ips)
 227   {
 228     if (~0 == vec_search_with_function (ge->ge_key.gek_ips, ip,
 229                                         gbp_endpoint_ip_is_equal))
 230       {
 231         fib_prefix_t *pfx;
 232
 233         vec_add2 (ge->ge_key.gek_ips, pfx, 1);
 234         fib_prefix_from_ip46_addr (ip, pfx);
 235
 236         gbp_endpoint_add_ip (&pfx->fp_addr,
 237                              grd->grd_fib_index[pfx->fp_proto], gei);
 238       }
 239     ge->ge_key.gek_grd = grdi;
 240   }
 241 }
 242
 243 static gbp_endpoint_t *
 244 gbp_endpoint_alloc (const ip46_address_t * ips,
 245                     const gbp_route_domain_t * grd,
 246                     const mac_address_t * mac,
 247                     const gbp_bridge_domain_t * gbd)
 248 {
 249   gbp_endpoint_t *ge;
 250   index_t gei;
 251
 252   pool_get_zero (gbp_endpoint_pool, ge);
 253
 254   fib_node_init (&ge->ge_node, gbp_endpoint_fib_type);
 255   gei = gbp_endpoint_index (ge);
 256   ge->ge_key.gek_gbd =
 257     ge->ge_key.gek_grd =
 258     ge->ge_fwd.gef_itf = ge->ge_fwd.gef_fib_index = INDEX_INVALID;
 259   ge->ge_last_time = vlib_time_now (vlib_get_main ());
 260   ge->ge_key.gek_gbd = gbp_bridge_domain_index (gbd);
 261
 262   if (NULL != mac)
 263     {
 264       mac_address_copy (&ge->ge_key.gek_mac, mac);
 265       gbp_endpoint_add_mac (mac, gbd->gb_bd_index, gei);
 266     }
 267   gbp_endpoint_ips_update (ge, ips, grd);
 268
 269   return (ge);
 270 }
 271
 272 static int
 273 gbp_endpoint_loc_is_equal (gbp_endpoint_loc_t * a, gbp_endpoint_loc_t * b)
 274 {
 275   return (a->gel_src == b->gel_src);
 276 }
 277
 278 static int
 279 gbp_endpoint_loc_cmp_for_sort (gbp_endpoint_loc_t * a, gbp_endpoint_loc_t * b)
 280 {
 281   return (a->gel_src - b->gel_src);
 282 }
 283
 284 static gbp_endpoint_loc_t *
 285 gbp_endpoint_loc_find (gbp_endpoint_t * ge, gbp_endpoint_src_t src)
 286 {
 287   gbp_endpoint_loc_t gel = {
 288     .gel_src = src,
 289   };
 290   u32 pos;
 291
 292   pos = vec_search_with_function (ge->ge_locs, &gel,
 293                                   gbp_endpoint_loc_is_equal);
 294
 295   if (~0 != pos)
 296     return (&ge->ge_locs[pos]);
 297
 298   return NULL;
 299 }
 300
 301 static int
 302 gbp_endpoint_loc_unlock (gbp_endpoint_t * ge, gbp_endpoint_loc_t * gel)
 303 {
 304   u32 pos;
 305
 306   gel->gel_locks--;
 307
 308   if (0 == gel->gel_locks)
 309     {
 310       pos = gel - ge->ge_locs;
 311
 312       vec_del1 (ge->ge_locs, pos);
 313       if (vec_len (ge->ge_locs) > 1)
 314         vec_sort_with_function (ge->ge_locs, gbp_endpoint_loc_cmp_for_sort);
 315
 316       /* This could be the last lock, so don't access the EP from
 317        * this point on */
 318       fib_node_unlock (&ge->ge_node);
 319
 320       return (1);
 321     }
 322   return (0);
 323 }
 324
 325 static void
 326 gbp_endpoint_loc_destroy (gbp_endpoint_loc_t * gel)
 327 {
 328   gbp_endpoint_group_unlock (gel->gel_epg);
 329
 330   if (gel->gel_flags & GBP_ENDPOINT_FLAG_REMOTE)
 331     {
 332       vxlan_gbp_tunnel_unlock (gel->gel_sw_if_index);
 333     }
 334 }
 335
 336 static gbp_endpoint_loc_t *
 337 gbp_endpoint_loc_find_or_add (gbp_endpoint_t * ge, gbp_endpoint_src_t src)
 338 {
 339   gbp_endpoint_loc_t gel = {
 340     .gel_src = src,
 341     .gel_epg = INDEX_INVALID,
 342     .gel_sw_if_index = INDEX_INVALID,
 343     .gel_locks = 0,
 344   };
 345   u32 pos;
 346
 347   pos = vec_search_with_function (ge->ge_locs, &gel,
 348                                   gbp_endpoint_loc_is_equal);
 349
 350   if (~0 == pos)
 351     {
 352       vec_add1 (ge->ge_locs, gel);
 353
 354       if (vec_len (ge->ge_locs) > 1)
 355         {
 356           vec_sort_with_function (ge->ge_locs, gbp_endpoint_loc_cmp_for_sort);
 357
 358           pos = vec_search_with_function (ge->ge_locs, &gel,
 359                                           gbp_endpoint_loc_is_equal);
 360         }
 361       else
 362         pos = 0;
 363
 364       /*
 365        * it's the sources and children that lock the endpoints
 366        */
 367       fib_node_lock (&ge->ge_node);
 368     }
 369
 370   return (&ge->ge_locs[pos]);
 371 }
 372
 373 /**
 374  * Find an EP inthe DBs and check that if we find it in the L2 DB
 375  * it has the same IPs as this update
 376  */
 377 static int
 378 gbp_endpoint_find_for_update (const ip46_address_t * ips,
 379                               const gbp_route_domain_t * grd,
 380                               const mac_address_t * mac,
 381                               const gbp_bridge_domain_t * gbd,
 382                               gbp_endpoint_t ** ge)
 383 {
 384   gbp_endpoint_t *l2_ge, *l3_ge, *tmp;
 385
 386   l2_ge = l3_ge = NULL;
 387
 388   if (NULL != mac && !mac_address_is_zero (mac))
 389     {
 390       ASSERT (gbd);
 391       l2_ge = gbp_endpoint_find_mac (mac->bytes, gbd->gb_bd_index);
 392     }
 393   if (NULL != ips && !ip46_address_is_zero (ips))
 394     {
 395       const ip46_address_t *ip;
 396       fib_protocol_t fproto;
 397
 398       ASSERT (grd);
 399       vec_foreach (ip, ips)
 400       {
 401         fproto = fib_proto_from_ip46 (ip46_address_get_type (ip));
 402
 403         tmp = gbp_endpoint_find_ip (ip, grd->grd_fib_index[fproto]);
 404
 405         if (NULL == tmp)
 406           /* not found */
 407           continue;
 408         else if (NULL == l3_ge)
 409           /* first match against an IP address */
 410           l3_ge = tmp;
 411         else if (tmp == l3_ge)
 412           /* another match against IP address that is the same endpoint */
 413           continue;
 414         else
 415           {
 416             /*
 417              *  a match agains a different endpoint.
 418              * this means the KEY of the EP is changing which is not allowed
 419              */
 420             return (-1);
 421           }
 422       }
 423     }
 424
 425   if (NULL == l2_ge && NULL == l3_ge)
 426     /* not found */
 427     *ge = NULL;
 428   else if (NULL == l2_ge)
 429     /* found at L3 */
 430     *ge = l3_ge;
 431   else if (NULL == l3_ge)
 432     /* found at L2 */
 433     *ge = l2_ge;
 434   else
 435     {
 436       /* found both L3 and L2 - they must be the same else the KEY
 437        * is changing
 438        */
 439       if (l2_ge == l3_ge)
 440         *ge = l2_ge;
 441       else
 442         return (-1);
 443     }
 444
 445   return (0);
 446 }
 447
 448 static gbp_endpoint_src_t
 449 gbp_endpoint_get_best_src (const gbp_endpoint_t * ge)
 450 {
 451   if (0 == vec_len (ge->ge_locs))
 452     return (GBP_ENDPOINT_SRC_MAX);
 453
 454   return (ge->ge_locs[0].gel_src);
 455 }
 456
 457 static void
 458 gbp_endpoint_n_learned (int n)
 459 {
 460   gbp_n_learnt_endpoints += n;
 461
 462   if (n > 0 && 1 == gbp_n_learnt_endpoints)
 463     {
 464       vlib_process_signal_event (vlib_get_main (),
 465                                  gbp_scanner_node.index,
 466                                  GBP_ENDPOINT_SCAN_START, 0);
 467     }
 468   if (n < 0 && 0 == gbp_n_learnt_endpoints)
 469     {
 470       vlib_process_signal_event (vlib_get_main (),
 471                                  gbp_scanner_node.index,
 472                                  GBP_ENDPOINT_SCAN_STOP, 0);
 473     }
 474 }
 475
 476 static void
 477 gbp_endpoint_loc_update (gbp_endpoint_loc_t * gel,
 478                          const gbp_bridge_domain_t * gb,
 479                          u32 sw_if_index,
 480                          index_t ggi,
 481                          gbp_endpoint_flags_t flags,
 482                          const ip46_address_t * tun_src,
 483                          const ip46_address_t * tun_dst)
 484 {
 485   int was_learnt, is_learnt;
 486
 487   gel->gel_locks++;
 488   was_learnt = ! !(gel->gel_flags & GBP_ENDPOINT_FLAG_REMOTE);
 489   gel->gel_flags = flags;
 490   is_learnt = ! !(gel->gel_flags & GBP_ENDPOINT_FLAG_REMOTE);
 491
 492   gbp_endpoint_n_learned (is_learnt - was_learnt);
 493
 494   if (INDEX_INVALID == gel->gel_epg)
 495     {
 496       gel->gel_epg = ggi;
 497       if (INDEX_INVALID != gel->gel_epg)
 498         {
 499           gbp_endpoint_group_lock (gel->gel_epg);
 500         }
 501     }
 502   else
 503     {
 504       ASSERT (gel->gel_epg == ggi);
 505     }
 506
 507   if (gel->gel_flags & GBP_ENDPOINT_FLAG_REMOTE)
 508     {
 509       if (NULL != tun_src)
 510         ip46_address_copy (&gel->tun.gel_src, tun_src);
 511       if (NULL != tun_dst)
 512         ip46_address_copy (&gel->tun.gel_dst, tun_dst);
 513
 514       if (ip46_address_is_multicast (&gel->tun.gel_src))
 515         {
 516           /*
 517            * we learnt the EP from the multicast tunnel.
 518            * Create a unicast TEP from the packet's source
 519            * and the fixed address of the BD's parent tunnel
 520            */
 521           const gbp_vxlan_tunnel_t *gt;
 522
 523           gt = gbp_vxlan_tunnel_get (gb->gb_vni);
 524
 525           if (NULL != gt)
 526             {
 527               ip46_address_copy (&gel->tun.gel_src, &gt->gt_src);
 528               sw_if_index = gt->gt_sw_if_index;
 529             }
 530         }
 531
 532       /*
 533        * the input interface may be the parent GBP-vxlan interface,
 534        * create a child vlxan-gbp tunnel and use that as the endpoint's
 535        * interface.
 536        */
 537       if (~0 != gel->gel_sw_if_index)
 538         vxlan_gbp_tunnel_unlock (gel->gel_sw_if_index);
 539
 540       switch (gbp_vxlan_tunnel_get_type (sw_if_index))
 541         {
 542         case GBP_VXLAN_TEMPLATE_TUNNEL:
 543           gel->tun.gel_parent_sw_if_index = sw_if_index;
 544           gel->gel_sw_if_index =
 545             gbp_vxlan_tunnel_clone_and_lock (sw_if_index,
 546                                              &gel->tun.gel_src,
 547                                              &gel->tun.gel_dst);
 548           break;
 549         case VXLAN_GBP_TUNNEL:
 550           gel->tun.gel_parent_sw_if_index =
 551             vxlan_gbp_tunnel_get_parent (sw_if_index);
 552           gel->gel_sw_if_index = sw_if_index;
 553           vxlan_gbp_tunnel_lock (gel->gel_sw_if_index);
 554           break;
 555         }
 556     }
 557   else
 558     {
 559       gel->gel_sw_if_index = sw_if_index;
 560     }
 561 }
 562
 563 static void
 564 gbb_endpoint_fwd_reset (gbp_endpoint_t * ge)
 565 {
 566   const gbp_route_domain_t *grd;
 567   const gbp_bridge_domain_t *gbd;
 568   gbp_endpoint_fwd_t *gef;
 569   const fib_prefix_t *pfx;
 570   index_t *ai;
 571   index_t gei;
 572
 573   gei = gbp_endpoint_index (ge);
 574   gbd = gbp_bridge_domain_get (ge->ge_key.gek_gbd);
 575   gef = &ge->ge_fwd;
 576
 577   vec_foreach (pfx, ge->ge_key.gek_ips)
 578   {
 579     u32 fib_index;
 580
 581     grd = gbp_route_domain_get (ge->ge_key.gek_grd);
 582     fib_index = grd->grd_fib_index[pfx->fp_proto];
 583
 584     bd_add_del_ip_mac (gbd->gb_bd_index, fib_proto_to_ip46 (pfx->fp_proto),
 585                        &pfx->fp_addr, &ge->ge_key.gek_mac, 0);
 586
 587     /*
 588      * remove a host route
 589      */
 590     if (gbp_endpoint_is_remote (ge))
 591       {
 592         fib_table_entry_special_remove (fib_index, pfx, FIB_SOURCE_PLUGIN_HI);
 593       }
 594
 595     fib_table_entry_delete (fib_index, pfx, FIB_SOURCE_PLUGIN_LOW);
 596   }
 597   vec_foreach (ai, gef->gef_adjs)
 598   {
 599     adj_unlock (*ai);
 600   }
 601
 602   if (INDEX_INVALID != gef->gef_itf)
 603     {
 604       l2fib_del_entry (ge->ge_key.gek_mac.bytes,
 605                        gbd->gb_bd_index, gef->gef_itf);
 606       gbp_itf_set_l2_input_feature (gef->gef_itf, gei, L2INPUT_FEAT_NONE);
 607       gbp_itf_set_l2_output_feature (gef->gef_itf, gei, L2OUTPUT_FEAT_NONE);
 608
 609       gbp_itf_unlock (gef->gef_itf);
 610       gef->gef_itf = INDEX_INVALID;
 611     }
 612
 613   vec_free (gef->gef_adjs);
 614 }
 615
 616 static void
 617 gbb_endpoint_fwd_recalc (gbp_endpoint_t * ge)
 618 {
 619   const gbp_route_domain_t *grd;
 620   const gbp_bridge_domain_t *gbd;
 621   const gbp_endpoint_group_t *gg;
 622   gbp_endpoint_loc_t *gel;
 623   gbp_endpoint_fwd_t *gef;
 624   const fib_prefix_t *pfx;
 625   index_t gei;
 626
 627   /*
 628    * locations are sort in source priority order
 629    */
 630   gei = gbp_endpoint_index (ge);
 631   gel = &ge->ge_locs[0];
 632   gef = &ge->ge_fwd;
 633   gbd = gbp_bridge_domain_get (ge->ge_key.gek_gbd);
 634
 635   gef->gef_flags = gel->gel_flags;
 636
 637   if (INDEX_INVALID != gel->gel_epg)
 638     {
 639       gg = gbp_endpoint_group_get (gel->gel_epg);
 640       gef->gef_sclass = gg->gg_sclass;
 641     }
 642   else
 643     {
 644       gg = NULL;
 645     }
 646
 647   gef->gef_itf = gbp_itf_add_and_lock (gel->gel_sw_if_index,
 648                                        gbd->gb_bd_index);
 649
 650   if (!mac_address_is_zero (&ge->ge_key.gek_mac))
 651     {
 652       gbp_itf_set_l2_input_feature (gef->gef_itf, gei, L2INPUT_FEAT_GBP_FWD);
 653
 654       if (gbp_endpoint_is_remote (ge) || gbp_endpoint_is_external (ge))
 655         {
 656           /*
 657            * bridged packets to external endpoints should be classifed
 658            * based on the EP's/BD's EPG
 659            */
 660           gbp_itf_set_l2_output_feature (gef->gef_itf, gei,
 661                                          L2OUTPUT_FEAT_GBP_POLICY_MAC);
 662         }
 663       else
 664         {
 665           gbp_endpoint_add_itf (gef->gef_itf, gei);
 666           gbp_itf_set_l2_output_feature (gef->gef_itf, gei,
 667                                          L2OUTPUT_FEAT_GBP_POLICY_PORT);
 668         }
 669       l2fib_add_entry (ge->ge_key.gek_mac.bytes,
 670                        gbd->gb_bd_index,
 671                        gef->gef_itf, L2FIB_ENTRY_RESULT_FLAG_STATIC);
 672     }
 673
 674   vec_foreach (pfx, ge->ge_key.gek_ips)
 675   {
 676     ethernet_header_t *eth;
 677     u32 ip_sw_if_index;
 678     u32 fib_index;
 679     u8 *rewrite;
 680     index_t ai;
 681
 682     rewrite = NULL;
 683     grd = gbp_route_domain_get (ge->ge_key.gek_grd);
 684     fib_index = grd->grd_fib_index[pfx->fp_proto];
 685     gef->gef_fib_index = fib_index;
 686
 687     bd_add_del_ip_mac (gbd->gb_bd_index, fib_proto_to_ip46 (pfx->fp_proto),
 688                        &pfx->fp_addr, &ge->ge_key.gek_mac, 1);
 689
 690     /*
 691      * add a host route via the EPG's BVI we need this because the
 692      * adj fib does not install, due to cover refinement check, since
 693      * the BVI's prefix is /32
 694      */
 695     vec_validate (rewrite, sizeof (*eth) - 1);
 696     eth = (ethernet_header_t *) rewrite;
 697
 698     eth->type = clib_host_to_net_u16 ((pfx->fp_proto == FIB_PROTOCOL_IP4 ?
 699                                        ETHERNET_TYPE_IP4 :
 700                                        ETHERNET_TYPE_IP6));
 701
 702     if (gbp_endpoint_is_remote (ge))
 703       {
 704         /*
 705          * for dynamic EPs we must add the IP adjacency via the learned
 706          * tunnel since the BD will not contain the EP's MAC since it was
 707          * L3 learned. The dst MAC address used is the 'BD's MAC'.
 708          */
 709         ip_sw_if_index = gef->gef_itf;
 710
 711         mac_address_to_bytes (gbp_route_domain_get_local_mac (),
 712                               eth->src_address);
 713         mac_address_to_bytes (gbp_route_domain_get_remote_mac (),
 714                               eth->dst_address);
 715       }
 716     else
 717       {
 718         /*
 719          * for the static EPs we add the IP adjacency via the BVI
 720          * knowing that the BD has the MAC address to route to and
 721          * that policy will be applied on egress to the EP's port
 722          */
 723         ip_sw_if_index = gbd->gb_bvi_sw_if_index;
 724
 725         clib_memcpy (eth->src_address,
 726                      vnet_sw_interface_get_hw_address (vnet_get_main (),
 727                                                        ip_sw_if_index),
 728                      sizeof (eth->src_address));
 729         mac_address_to_bytes (&ge->ge_key.gek_mac, eth->dst_address);
 730       }
 731
 732     fib_table_entry_path_add (fib_index, pfx,
 733                               FIB_SOURCE_PLUGIN_LOW,
 734                               FIB_ENTRY_FLAG_NONE,
 735                               fib_proto_to_dpo (pfx->fp_proto),
 736                               &pfx->fp_addr, ip_sw_if_index,
 737                               ~0, 1, NULL, FIB_ROUTE_PATH_FLAG_NONE);
 738
 739     ai = adj_nbr_add_or_lock_w_rewrite (pfx->fp_proto,
 740                                         fib_proto_to_link (pfx->fp_proto),
 741                                         &pfx->fp_addr,
 742                                         ip_sw_if_index, rewrite);
 743     vec_add1 (gef->gef_adjs, ai);
 744
 745     /*
 746      * if the endpoint is external then routed packet to it must be
 747      * classifed to the BD's EPG. but this will happen anyway with
 748      * the GBP_MAC classification.
 749      */
 750
 751     if (NULL != gg)
 752       {
 753         if (gbp_endpoint_is_remote (ge))
 754           {
 755             dpo_id_t policy_dpo = DPO_INVALID;
 756
 757             /*
 758              * interpose a policy DPO from the endpoint so that policy
 759              * is applied
 760              */
 761             gbp_policy_dpo_add_or_lock (fib_proto_to_dpo (pfx->fp_proto),
 762                                         grd->grd_scope,
 763                                         gg->gg_sclass, ~0, &policy_dpo);
 764
 765             fib_table_entry_special_dpo_add (fib_index, pfx,
 766                                              FIB_SOURCE_PLUGIN_HI,
 767                                              FIB_ENTRY_FLAG_INTERPOSE,
 768                                              &policy_dpo);
 769             dpo_reset (&policy_dpo);
 770           }
 771
 772         /*
 773          * send a gratuitous ARP on the EPG's uplink. this is done so
 774          * that if this EP has moved from some other place in the
 775          * 'fabric', upstream devices are informed
 776          */
 777         if (gbp_endpoint_is_local (ge) && ~0 != gg->gg_uplink_sw_if_index)
 778           {
 779             gbp_endpoint_add_itf (gef->gef_itf, gei);
 780             if (FIB_PROTOCOL_IP4 == pfx->fp_proto)
 781               send_ip4_garp_w_addr (vlib_get_main (),
 782                                     &pfx->fp_addr.ip4,
 783                                     gg->gg_uplink_sw_if_index);
 784             else
 785               send_ip6_na_w_addr (vlib_get_main (),
 786                                   &pfx->fp_addr.ip6,
 787                                   gg->gg_uplink_sw_if_index);
 788           }
 789       }
 790   }
 791
 792   if (gbp_endpoint_is_external (ge))
 793     {
 794       gbp_itf_set_l2_input_feature (gef->gef_itf, gei,
 795                                     L2INPUT_FEAT_GBP_LPM_CLASSIFY);
 796     }
 797   else if (gbp_endpoint_is_local (ge))
 798     {
 799       /*
 800        * non-remote endpoints (i.e. those not arriving on iVXLAN
 801        * tunnels) need to be classifed based on the the input interface.
 802        * We enable the GBP-FWD feature only if the group has an uplink
 803        * interface (on which the GBP-FWD feature would send UU traffic).
 804        * External endpoints get classified based on an LPM match
 805        */
 806       l2input_feat_masks_t feats = L2INPUT_FEAT_GBP_SRC_CLASSIFY;
 807
 808       if (NULL != gg && ~0 != gg->gg_uplink_sw_if_index)
 809         feats |= L2INPUT_FEAT_GBP_FWD;
 810       gbp_itf_set_l2_input_feature (gef->gef_itf, gei, feats);
 811     }
 812
 813   /*
 814    * update children with the new forwarding info
 815    */
 816   fib_node_back_walk_ctx_t bw_ctx = {
 817     .fnbw_reason = FIB_NODE_BW_REASON_FLAG_EVALUATE,
 818     .fnbw_flags = FIB_NODE_BW_FLAG_FORCE_SYNC,
 819   };
 820
 821   fib_walk_sync (gbp_endpoint_fib_type, gei, &bw_ctx);
 822 }
 823
 824 int
 825 gbp_endpoint_update_and_lock (gbp_endpoint_src_t src,
 826                               u32 sw_if_index,
 827                               const ip46_address_t * ips,
 828                               const mac_address_t * mac,
 829                               index_t gbdi, index_t grdi,
 830                               sclass_t sclass,
 831                               gbp_endpoint_flags_t flags,
 832                               const ip46_address_t * tun_src,
 833                               const ip46_address_t * tun_dst, u32 * handle)
 834 {
 835   gbp_bridge_domain_t *gbd;
 836   gbp_endpoint_group_t *gg;
 837   gbp_endpoint_src_t best;
 838   gbp_route_domain_t *grd;
 839   gbp_endpoint_loc_t *gel;
 840   gbp_endpoint_t *ge;
 841   index_t ggi, gei;
 842   int rv;
 843
 844   if (~0 == sw_if_index)
 845     return (VNET_API_ERROR_INVALID_SW_IF_INDEX);
 846
 847   ge = NULL;
 848   gg = NULL;
 849
 850   /*
 851    * we need to determine the bridge-domain, either from the EPG or
 852    * the BD passed
 853    */
 854   if (SCLASS_INVALID != sclass)
 855     {
 856       ggi = gbp_endpoint_group_find (sclass);
 857
 858       if (INDEX_INVALID == ggi)
 859         return (VNET_API_ERROR_NO_SUCH_ENTRY);
 860
 861       gg = gbp_endpoint_group_get (ggi);
 862       gbdi = gg->gg_gbd;
 863       grdi = gg->gg_rd;
 864     }
 865   else
 866     {
 867       if (INDEX_INVALID == gbdi)
 868         return (VNET_API_ERROR_NO_SUCH_ENTRY);
 869       if (INDEX_INVALID == grdi)
 870         return (VNET_API_ERROR_NO_SUCH_FIB);
 871       ggi = INDEX_INVALID;
 872     }
 873
 874   gbd = gbp_bridge_domain_get (gbdi);
 875   grd = gbp_route_domain_get (grdi);
 876   rv = gbp_endpoint_find_for_update (ips, grd, mac, gbd, &ge);
 877
 878   if (0 != rv)
 879     return (rv);
 880
 881   if (NULL == ge)
 882     {
 883       ge = gbp_endpoint_alloc (ips, grd, mac, gbd);
 884     }
 885   else
 886     {
 887       gbp_endpoint_ips_update (ge, ips, grd);
 888     }
 889
 890   best = gbp_endpoint_get_best_src (ge);
 891   gei = gbp_endpoint_index (ge);
 892   gel = gbp_endpoint_loc_find_or_add (ge, src);
 893
 894   gbp_endpoint_loc_update (gel, gbd, sw_if_index, ggi, flags, tun_src,
 895                            tun_dst);
 896
 897   if (src <= best)
 898     {
 899       /*
 900        * either the best source has been updated or we have a new best source
 901        */
 902       gbb_endpoint_fwd_reset (ge);
 903       gbb_endpoint_fwd_recalc (ge);
 904     }
 905   else
 906     {
 907       /*
 908        * an update to a lower priority source, so we need do nothing
 909        */
 910     }
 911
 912   if (handle)
 913     *handle = gei;
 914
 915   GBP_ENDPOINT_INFO ("update: %U", format_gbp_endpoint, gei);
 916
 917   return (0);
 918 }
 919
 920 void
 921 gbp_endpoint_unlock (gbp_endpoint_src_t src, index_t gei)
 922 {
 923   gbp_endpoint_loc_t *gel, gel_copy;
 924   gbp_endpoint_src_t best;
 925   gbp_endpoint_t *ge;
 926   int removed;
 927
 928   if (pool_is_free_index (gbp_endpoint_pool, gei))
 929     return;
 930
 931   GBP_ENDPOINT_INFO ("delete: %U", format_gbp_endpoint, gei);
 932
 933   ge = gbp_endpoint_get (gei);
 934
 935   gel = gbp_endpoint_loc_find (ge, src);
 936
 937   if (NULL == gel)
 938     return;
 939
 940   /*
 941    * lock the EP so we can control when it is deleted
 942    */
 943   fib_node_lock (&ge->ge_node);
 944   best = gbp_endpoint_get_best_src (ge);
 945
 946   /*
 947    * copy the location info since we'll lose it when it's removed from
 948    * the vector
 949    */
 950   clib_memcpy (&gel_copy, gel, sizeof (gel_copy));
 951
 952   /*
 953    * remove the source we no longer need
 954    */
 955   removed = gbp_endpoint_loc_unlock (ge, gel);
 956
 957   if (src == best)
 958     {
 959       /*
 960        * we have removed the old best source => recalculate fwding
 961        */
 962       if (0 == vec_len (ge->ge_locs))
 963         {
 964           /*
 965            * if there are no more sources left, then we need only release
 966            * the fwding resources held and then this EP is gawn.
 967            */
 968           gbb_endpoint_fwd_reset (ge);
 969         }
 970       else
 971         {
 972           /*
 973            * else there are more sources. release the old and get new
 974            * fwding objects
 975            */
 976           gbb_endpoint_fwd_reset (ge);
 977           gbb_endpoint_fwd_recalc (ge);
 978         }
 979     }
 980   /*
 981    * else
 982    *  we removed a lower priority source so we need to do nothing
 983    */
 984
 985   /*
 986    * clear up any resources held by the source
 987    */
 988   if (removed)
 989     gbp_endpoint_loc_destroy (&gel_copy);
 990
 991   /*
 992    * remove the lock taken above
 993    */
 994   fib_node_unlock (&ge->ge_node);
 995   /*
 996    *  We may have removed the last source and so this EP is now TOAST
 997    *  DO NOTHING BELOW HERE
 998    */
 999 }
1000
1001 u32
1002 gbp_endpoint_child_add (index_t gei,
1003                         fib_node_type_t type, fib_node_index_t index)
1004 {
1005   return (fib_node_child_add (gbp_endpoint_fib_type, gei, type, index));
1006 }
1007
1008 void
1009 gbp_endpoint_child_remove (index_t gei, u32 sibling)
1010 {
1011   return (fib_node_child_remove (gbp_endpoint_fib_type, gei, sibling));
1012 }
1013
1014 typedef struct gbp_endpoint_flush_ctx_t_
1015 {
1016   u32 sw_if_index;
1017   gbp_endpoint_src_t src;
1018   index_t *geis;
1019 } gbp_endpoint_flush_ctx_t;
1020
1021 static walk_rc_t
1022 gbp_endpoint_flush_cb (index_t gei, void *args)
1023 {
1024   gbp_endpoint_flush_ctx_t *ctx = args;
1025   gbp_endpoint_loc_t *gel;
1026   gbp_endpoint_t *ge;
1027
1028   ge = gbp_endpoint_get (gei);
1029   gel = gbp_endpoint_loc_find (ge, ctx->src);
1030
1031   if ((NULL != gel) && ctx->sw_if_index == gel->tun.gel_parent_sw_if_index)
1032     {
1033       vec_add1 (ctx->geis, gei);
1034     }
1035
1036   return (WALK_CONTINUE);
1037 }
1038
1039 /**
1040  * remove all learnt endpoints using the interface
1041  */
1042 void
1043 gbp_endpoint_flush (gbp_endpoint_src_t src, u32 sw_if_index)
1044 {
1045   gbp_endpoint_flush_ctx_t ctx = {
1046     .sw_if_index = sw_if_index,
1047     .src = src,
1048   };
1049   index_t *gei;
1050
1051   GBP_ENDPOINT_INFO ("flush: %U %U",
1052                      format_gbp_endpoint_src, src,
1053                      format_vnet_sw_if_index_name, vnet_get_main (),
1054                      sw_if_index);
1055   gbp_endpoint_walk (gbp_endpoint_flush_cb, &ctx);
1056
1057   vec_foreach (gei, ctx.geis)
1058   {
1059     gbp_endpoint_unlock (src, *gei);
1060   }
1061
1062   vec_free (ctx.geis);
1063 }
1064
1065 void
1066 gbp_endpoint_walk (gbp_endpoint_cb_t cb, void *ctx)
1067 {
1068   u32 index;
1069
1070   /* *INDENT-OFF* */
1071   pool_foreach_index(index, gbp_endpoint_pool,
1072   {
1073     if (!cb(index, ctx))
1074       break;
1075   });
1076   /* *INDENT-ON* */
1077 }
1078
1079 static clib_error_t *
1080 gbp_endpoint_cli (vlib_main_t * vm,
1081                   unformat_input_t * input, vlib_cli_command_t * cmd)
1082 {
1083   ip46_address_t ip = ip46_address_initializer, *ips = NULL;
1084   mac_address_t mac = ZERO_MAC_ADDRESS;
1085   vnet_main_t *vnm = vnet_get_main ();
1086   u32 sclass = SCLASS_INVALID;
1087   u32 handle = INDEX_INVALID;
1088   u32 sw_if_index = ~0;
1089   u8 add = 1;
1090   int rv;
1091
1092   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1093     {
1094       ip46_address_reset (&ip);
1095
1096       if (unformat (input, "%U", unformat_vnet_sw_interface,
1097                     vnm, &sw_if_index))
1098         ;
1099       else if (unformat (input, "add"))
1100         add = 1;
1101       else if (unformat (input, "del"))
1102         add = 0;
1103       else if (unformat (input, "sclass %d", &sclass))
1104         ;
1105       else if (unformat (input, "handle %d", &handle))
1106         ;
1107       else if (unformat (input, "ip %U", unformat_ip4_address, &ip.ip4))
1108         vec_add1 (ips, ip);
1109       else if (unformat (input, "ip %U", unformat_ip6_address, &ip.ip6))
1110         vec_add1 (ips, ip);
1111       else if (unformat (input, "mac %U", unformat_mac_address, &mac))
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,
1127                                       INDEX_INVALID, INDEX_INVALID,
1128                                       sclass,
1129                                       GBP_ENDPOINT_FLAG_NONE,
1130                                       NULL, NULL, &handle);
1131
1132       if (rv)
1133         return clib_error_return (0, "GBP Endpoint update returned %d", rv);
1134       else
1135         vlib_cli_output (vm, "handle %d\n", handle);
1136     }
1137   else
1138     {
1139       if (INDEX_INVALID == handle)
1140         return clib_error_return (0, "handle must be specified");
1141
1142       gbp_endpoint_unlock (GBP_ENDPOINT_SRC_CP, handle);
1143     }
1144
1145   vec_free (ips);
1146
1147   return (NULL);
1148 }
1149
1150 /*?
1151  * Configure a GBP Endpoint
1152  *
1153  * @cliexpar
1154  * @cliexstart{set gbp endpoint [del] <interface> epg <ID> ip <IP>}
1155  * @cliexend
1156  ?*/
1157 /* *INDENT-OFF* */
1158 VLIB_CLI_COMMAND (gbp_endpoint_cli_node, static) = {
1159   .path = "gbp endpoint",
1160   .short_help = "gbp endpoint [del] <interface> epg <ID> ip <IP> mac <MAC>",
1161   .function = gbp_endpoint_cli,
1162 };
1163 /* *INDENT-ON* */
1164
1165 u8 *
1166 format_gbp_endpoint_src (u8 * s, va_list * args)
1167 {
1168   gbp_endpoint_src_t action = va_arg (*args, gbp_endpoint_src_t);
1169
1170   switch (action)
1171     {
1172 #define _(v,a) case GBP_ENDPOINT_SRC_##v: return (format (s, "%s", a));
1173       foreach_gbp_endpoint_src
1174 #undef _
1175     }
1176
1177   return (format (s, "unknown"));
1178 }
1179
1180 static u8 *
1181 format_gbp_endpoint_fwd (u8 * s, va_list * args)
1182 {
1183   gbp_endpoint_fwd_t *gef = va_arg (*args, gbp_endpoint_fwd_t *);
1184
1185   s = format (s, "fwd:");
1186   s = format (s, "\n   itf:[%U]", format_gbp_itf, gef->gef_itf);
1187   if (GBP_ENDPOINT_FLAG_NONE != gef->gef_flags)
1188     {
1189       s = format (s, " flags:%U", format_gbp_endpoint_flags, gef->gef_flags);
1190     }
1191
1192   return (s);
1193 }
1194
1195 static u8 *
1196 format_gbp_endpoint_key (u8 * s, va_list * args)
1197 {
1198   gbp_endpoint_key_t *gek = va_arg (*args, gbp_endpoint_key_t *);
1199   const fib_prefix_t *pfx;
1200
1201   s = format (s, "ips:[");
1202
1203   vec_foreach (pfx, gek->gek_ips)
1204   {
1205     s = format (s, "%U, ", format_fib_prefix, pfx);
1206   }
1207   s = format (s, "]");
1208
1209   s = format (s, " mac:%U", format_mac_address_t, &gek->gek_mac);
1210
1211   return (s);
1212 }
1213
1214 static u8 *
1215 format_gbp_endpoint_loc (u8 * s, va_list * args)
1216 {
1217   gbp_endpoint_loc_t *gel = va_arg (*args, gbp_endpoint_loc_t *);
1218
1219   s = format (s, "%U", format_gbp_endpoint_src, gel->gel_src);
1220   s =
1221     format (s, "\n    %U", format_vnet_sw_if_index_name, vnet_get_main (),
1222             gel->gel_sw_if_index);
1223   s = format (s, " EPG:%d", gel->gel_epg);
1224
1225   if (GBP_ENDPOINT_FLAG_NONE != gel->gel_flags)
1226     {
1227       s = format (s, " flags:%U", format_gbp_endpoint_flags, gel->gel_flags);
1228     }
1229   if (GBP_ENDPOINT_FLAG_REMOTE & gel->gel_flags)
1230     {
1231       s = format (s, " tun:[");
1232       s = format (s, "parent:%U", format_vnet_sw_if_index_name,
1233                   vnet_get_main (), gel->tun.gel_parent_sw_if_index);
1234       s = format (s, " {%U,%U}]",
1235                   format_ip46_address, &gel->tun.gel_src, IP46_TYPE_ANY,
1236                   format_ip46_address, &gel->tun.gel_dst, IP46_TYPE_ANY);
1237     }
1238
1239   return (s);
1240 }
1241
1242 u8 *
1243 format_gbp_endpoint (u8 * s, va_list * args)
1244 {
1245   index_t gei = va_arg (*args, index_t);
1246   gbp_endpoint_loc_t *gel;
1247   gbp_endpoint_t *ge;
1248
1249   ge = gbp_endpoint_get (gei);
1250
1251   s = format (s, "[@%d] %U", gei, format_gbp_endpoint_key, &ge->ge_key);
1252   s = format (s, " last-time:[%f]", ge->ge_last_time);
1253
1254   vec_foreach (gel, ge->ge_locs)
1255   {
1256     s = format (s, "\n  %U", format_gbp_endpoint_loc, gel);
1257   }
1258   s = format (s, "\n  %U", format_gbp_endpoint_fwd, &ge->ge_fwd);
1259
1260   return s;
1261 }
1262
1263 static walk_rc_t
1264 gbp_endpoint_show_one (index_t gei, void *ctx)
1265 {
1266   vlib_main_t *vm;
1267
1268   vm = ctx;
1269   vlib_cli_output (vm, " %U", format_gbp_endpoint, gei);
1270
1271   return (WALK_CONTINUE);
1272 }
1273
1274 static void
1275 gbp_endpoint_walk_ip_itf (const clib_bihash_kv_24_8_t * kvp, void *arg)
1276 {
1277   ip46_address_t ip;
1278   vlib_main_t *vm;
1279   u32 sw_if_index;
1280
1281   vm = arg;
1282
1283   gbp_endpoint_extract_key_ip_itf (kvp, &ip, &sw_if_index);
1284
1285   vlib_cli_output (vm, " {%U, %U} -> %d",
1286                    format_ip46_address, &ip, IP46_TYPE_ANY,
1287                    format_vnet_sw_if_index_name, vnet_get_main (),
1288                    sw_if_index, kvp->value);
1289 }
1290
1291 static void
1292 gbp_endpoint_walk_mac_itf (const clib_bihash_kv_16_8_t * kvp, void *arg)
1293 {
1294   mac_address_t mac;
1295   vlib_main_t *vm;
1296   u32 sw_if_index;
1297
1298   vm = arg;
1299
1300   gbp_endpoint_extract_key_mac_itf (kvp, &mac, &sw_if_index);
1301
1302   vlib_cli_output (vm, " {%U, %U} -> %d",
1303                    format_mac_address_t, &mac,
1304                    format_vnet_sw_if_index_name, vnet_get_main (),
1305                    sw_if_index, kvp->value);
1306 }
1307
1308 static clib_error_t *
1309 gbp_endpoint_show (vlib_main_t * vm,
1310                    unformat_input_t * input, vlib_cli_command_t * cmd)
1311 {
1312   u32 show_dbs, handle;
1313
1314   handle = INDEX_INVALID;
1315   show_dbs = 0;
1316
1317   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1318     {
1319       if (unformat (input, "%d", &handle))
1320         ;
1321       else if (unformat (input, "db"))
1322         show_dbs = 1;
1323       else
1324         break;
1325     }
1326
1327   if (INDEX_INVALID != handle)
1328     {
1329       vlib_cli_output (vm, "%U", format_gbp_endpoint, handle);
1330     }
1331   else if (show_dbs)
1332     {
1333       vlib_cli_output (vm, "\nDatabases:");
1334       clib_bihash_foreach_key_value_pair_24_8 (&gbp_ep_db.ged_by_ip_rd,
1335                                                gbp_endpoint_walk_ip_itf, vm);
1336       clib_bihash_foreach_key_value_pair_16_8
1337         (&gbp_ep_db.ged_by_mac_bd, gbp_endpoint_walk_mac_itf, vm);
1338     }
1339   else
1340     {
1341       vlib_cli_output (vm, "Endpoints:");
1342       gbp_endpoint_walk (gbp_endpoint_show_one, vm);
1343     }
1344
1345   return (NULL);
1346 }
1347
1348 /*?
1349  * Show Group Based Policy Endpoints and derived information
1350  *
1351  * @cliexpar
1352  * @cliexstart{show gbp endpoint}
1353  * @cliexend
1354  ?*/
1355 /* *INDENT-OFF* */
1356 VLIB_CLI_COMMAND (gbp_endpoint_show_node, static) = {
1357   .path = "show gbp endpoint",
1358   .short_help = "show gbp endpoint\n",
1359   .function = gbp_endpoint_show,
1360 };
1361 /* *INDENT-ON* */
1362
1363 static void
1364 gbp_endpoint_check (index_t gei, f64 start_time)
1365 {
1366   gbp_endpoint_group_t *gg;
1367   gbp_endpoint_loc_t *gel;
1368   gbp_endpoint_t *ge;
1369
1370   ge = gbp_endpoint_get (gei);
1371   gel = gbp_endpoint_loc_find (ge, GBP_ENDPOINT_SRC_DP);
1372
1373   if (NULL != gel)
1374     {
1375       gg = gbp_endpoint_group_get (gel->gel_epg);
1376
1377       if ((start_time - ge->ge_last_time) >
1378           gg->gg_retention.remote_ep_timeout)
1379         {
1380           gbp_endpoint_unlock (GBP_ENDPOINT_SRC_DP, gei);
1381         }
1382     }
1383 }
1384
1385 static void
1386 gbp_endpoint_scan_l2 (vlib_main_t * vm)
1387 {
1388   clib_bihash_16_8_t *gte_table = &gbp_ep_db.ged_by_mac_bd;
1389   f64 last_start, start_time, delta_t;
1390   int i, j, k;
1391
1392   delta_t = 0;
1393   last_start = start_time = vlib_time_now (vm);
1394
1395   for (i = 0; i < gte_table->nbuckets; i++)
1396     {
1397       clib_bihash_bucket_16_8_t *b;
1398       clib_bihash_value_16_8_t *v;
1399
1400       /* allow no more than 20us without a pause */
1401       delta_t = vlib_time_now (vm) - last_start;
1402       if (delta_t > 20e-6)
1403         {
1404           /* suspend for 100 us */
1405           vlib_process_suspend (vm, 100e-6);
1406           last_start = vlib_time_now (vm);
1407         }
1408
1409       b = &gte_table->buckets[i];
1410       if (b->offset == 0)
1411         continue;
1412       v = clib_bihash_get_value_16_8 (gte_table, b->offset);
1413
1414       for (j = 0; j < (1 << b->log2_pages); j++)
1415         {
1416           for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
1417             {
1418               if (clib_bihash_is_free_16_8 (&v->kvp[k]))
1419                 continue;
1420
1421               gbp_endpoint_check (v->kvp[k].value, start_time);
1422
1423               /*
1424                * Note: we may have just freed the bucket's backing
1425                * storage, so check right here...
1426                */
1427               if (b->offset == 0)
1428                 goto doublebreak;
1429             }
1430           v++;
1431         }
1432     doublebreak:
1433       ;
1434     }
1435 }
1436
1437 static void
1438 gbp_endpoint_scan_l3 (vlib_main_t * vm)
1439 {
1440   clib_bihash_24_8_t *gte_table = &gbp_ep_db.ged_by_ip_rd;
1441   f64 last_start, start_time, delta_t;
1442   int i, j, k;
1443
1444   delta_t = 0;
1445   last_start = start_time = vlib_time_now (vm);
1446
1447   for (i = 0; i < gte_table->nbuckets; i++)
1448     {
1449       clib_bihash_bucket_24_8_t *b;
1450       clib_bihash_value_24_8_t *v;
1451
1452       /* allow no more than 20us without a pause */
1453       delta_t = vlib_time_now (vm) - last_start;
1454       if (delta_t > 20e-6)
1455         {
1456           /* suspend for 100 us */
1457           vlib_process_suspend (vm, 100e-6);
1458           last_start = vlib_time_now (vm);
1459         }
1460
1461       b = &gte_table->buckets[i];
1462       if (b->offset == 0)
1463         continue;
1464       v = clib_bihash_get_value_24_8 (gte_table, b->offset);
1465
1466       for (j = 0; j < (1 << b->log2_pages); j++)
1467         {
1468           for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
1469             {
1470               if (clib_bihash_is_free_24_8 (&v->kvp[k]))
1471                 continue;
1472
1473               gbp_endpoint_check (v->kvp[k].value, start_time);
1474
1475               /*
1476                * Note: we may have just freed the bucket's backing
1477                * storage, so check right here...
1478                */
1479               if (b->offset == 0)
1480                 goto doublebreak;
1481             }
1482           v++;
1483         }
1484     doublebreak:
1485       ;
1486     }
1487 }
1488
1489 void
1490 gbp_endpoint_scan (vlib_main_t * vm)
1491 {
1492   gbp_endpoint_scan_l2 (vm);
1493   gbp_endpoint_scan_l3 (vm);
1494 }
1495
1496 static fib_node_t *
1497 gbp_endpoint_get_node (fib_node_index_t index)
1498 {
1499   gbp_endpoint_t *ge;
1500
1501   ge = gbp_endpoint_get (index);
1502
1503   return (&ge->ge_node);
1504 }
1505
1506 static gbp_endpoint_t *
1507 gbp_endpoint_from_fib_node (fib_node_t * node)
1508 {
1509   ASSERT (gbp_endpoint_fib_type == node->fn_type);
1510   return ((gbp_endpoint_t *) node);
1511 }
1512
1513 static void
1514 gbp_endpoint_last_lock_gone (fib_node_t * node)
1515 {
1516   const gbp_bridge_domain_t *gbd;
1517   const gbp_route_domain_t *grd;
1518   const fib_prefix_t *pfx;
1519   gbp_endpoint_t *ge;
1520
1521   ge = gbp_endpoint_from_fib_node (node);
1522
1523   ASSERT (0 == vec_len (ge->ge_locs));
1524
1525   gbd = gbp_bridge_domain_get (ge->ge_key.gek_gbd);
1526
1527   /*
1528    * we have removed the last source. this EP is toast
1529    */
1530   if (INDEX_INVALID != ge->ge_key.gek_gbd)
1531     {
1532       gbp_endpoint_del_mac (&ge->ge_key.gek_mac, gbd->gb_bd_index);
1533     }
1534   vec_foreach (pfx, ge->ge_key.gek_ips)
1535   {
1536     grd = gbp_route_domain_get (ge->ge_key.gek_grd);
1537     gbp_endpoint_del_ip (&pfx->fp_addr, grd->grd_fib_index[pfx->fp_proto]);
1538   }
1539   pool_put (gbp_endpoint_pool, ge);
1540 }
1541
1542 static fib_node_back_walk_rc_t
1543 gbp_endpoint_back_walk_notify (fib_node_t * node,
1544                                fib_node_back_walk_ctx_t * ctx)
1545 {
1546   ASSERT (0);
1547
1548   return (FIB_NODE_BACK_WALK_CONTINUE);
1549 }
1550
1551 /*
1552  * The FIB path's graph node virtual function table
1553  */
1554 static const fib_node_vft_t gbp_endpoint_vft = {
1555   .fnv_get = gbp_endpoint_get_node,
1556   .fnv_last_lock = gbp_endpoint_last_lock_gone,
1557   .fnv_back_walk = gbp_endpoint_back_walk_notify,
1558   // .fnv_mem_show = fib_path_memory_show,
1559 };
1560
1561 static clib_error_t *
1562 gbp_endpoint_init (vlib_main_t * vm)
1563 {
1564 #define GBP_EP_HASH_NUM_BUCKETS (2 * 1024)
1565 #define GBP_EP_HASH_MEMORY_SIZE (1 << 20)
1566
1567   clib_bihash_init_24_8 (&gbp_ep_db.ged_by_ip_rd,
1568                          "GBP Endpoints - IP/RD",
1569                          GBP_EP_HASH_NUM_BUCKETS, GBP_EP_HASH_MEMORY_SIZE);
1570
1571   clib_bihash_init_16_8 (&gbp_ep_db.ged_by_mac_bd,
1572                          "GBP Endpoints - MAC/BD",
1573                          GBP_EP_HASH_NUM_BUCKETS, GBP_EP_HASH_MEMORY_SIZE);
1574
1575   gbp_ep_logger = vlib_log_register_class ("gbp", "ep");
1576   gbp_endpoint_fib_type = fib_node_register_new_type (&gbp_endpoint_vft);
1577
1578   return (NULL);
1579 }
1580
1581 VLIB_INIT_FUNCTION (gbp_endpoint_init);
1582
1583 /*
1584  * fd.io coding-style-patch-verification: ON
1585  *
1586  * Local Variables:
1587  * eval: (c-set-style "gnu")
1588  * End:
1589  */