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