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