vnet/vnet/lisp-cp/gid_dictionary.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/lisp-cp/gid_dictionary.h>
  17
  18 static void
  19 make_mac_sd_key (BVT (clib_bihash_kv) * kv, u32 vni, u8 src_mac[6],
  20                  u8 dst_mac[6])
  21 {
  22   kv->key[0] = (u64) vni;
  23   kv->key[1] = mac_to_u64 (dst_mac);
  24   kv->key[2] = src_mac ? mac_to_u64 (src_mac) : (u64) 0;
  25 }
  26
  27 static u32
  28 mac_sd_lookup (gid_mac_table_t * db, u32 vni, u8 * dst, u8 * src)
  29 {
  30   int rv;
  31   BVT (clib_bihash_kv) kv, value;
  32
  33   make_mac_sd_key (&kv, vni, src, dst);
  34   rv = BV (clib_bihash_search_inline_2) (&db->mac_lookup_table, &kv, &value);
  35
  36   /* no match, try with src 0, catch all for dst */
  37   if (rv != 0)
  38     {
  39       kv.key[2] = 0;
  40       rv = BV (clib_bihash_search_inline_2) (&db->mac_lookup_table, &kv,
  41                                              &value);
  42       if (rv == 0)
  43         return value.value;
  44     }
  45   else
  46     return value.value;
  47
  48   return GID_LOOKUP_MISS;
  49 }
  50
  51 static u32
  52 ip4_lookup (gid_ip4_table_t * db, u32 vni, ip_prefix_t * key)
  53 {
  54   int i, len;
  55   int rv;
  56   BVT (clib_bihash_kv) kv, value;
  57
  58   len = vec_len (db->ip4_prefix_lengths_in_search_order);
  59
  60   for (i = 0; i < len; i++)
  61     {
  62       int dst_address_length = db->ip4_prefix_lengths_in_search_order[i];
  63       ip4_address_t *mask;
  64
  65       ASSERT (dst_address_length >= 0 && dst_address_length <= 32);
  66
  67       mask = &db->ip4_fib_masks[dst_address_length];
  68
  69       kv.key[0] =
  70         ((u64) vni << 32) | (ip_prefix_v4 (key).as_u32 & mask->as_u32);
  71       kv.key[1] = 0;
  72       kv.key[2] = 0;
  73
  74       rv =
  75         BV (clib_bihash_search_inline_2) (&db->ip4_lookup_table, &kv, &value);
  76       if (rv == 0)
  77         return value.value;
  78     }
  79
  80   return GID_LOOKUP_MISS;
  81 }
  82
  83 static u32
  84 ip6_lookup (gid_ip6_table_t * db, u32 vni, ip_prefix_t * key)
  85 {
  86   int i, len;
  87   int rv;
  88   BVT (clib_bihash_kv) kv, value;
  89
  90   len = vec_len (db->ip6_prefix_lengths_in_search_order);
  91
  92   for (i = 0; i < len; i++)
  93     {
  94       int dst_address_length = db->ip6_prefix_lengths_in_search_order[i];
  95       ip6_address_t *mask;
  96
  97       ASSERT (dst_address_length >= 0 && dst_address_length <= 128);
  98
  99       mask = &db->ip6_fib_masks[dst_address_length];
 100
 101       kv.key[0] = ip_prefix_v6 (key).as_u64[0] & mask->as_u64[0];
 102       kv.key[1] = ip_prefix_v6 (key).as_u64[1] & mask->as_u64[1];
 103       kv.key[2] = (u64) vni;
 104
 105       rv =
 106         BV (clib_bihash_search_inline_2) (&db->ip6_lookup_table, &kv, &value);
 107       if (rv == 0)
 108         return value.value;
 109     }
 110
 111   return GID_LOOKUP_MISS;
 112 }
 113
 114 static u32
 115 ip_sd_lookup (gid_dictionary_t * db, u32 vni, ip_prefix_t * dst,
 116               ip_prefix_t * src)
 117 {
 118   u32 sfi;
 119   gid_ip4_table_t *sfib4;
 120   gid_ip6_table_t *sfib6;
 121
 122   switch (ip_prefix_version (dst))
 123     {
 124     case IP4:
 125       sfi = ip4_lookup (&db->dst_ip4_table, vni, dst);
 126       if (GID_LOOKUP_MISS != sfi)
 127         sfib4 = pool_elt_at_index (db->src_ip4_table_pool, sfi);
 128       else
 129         return GID_LOOKUP_MISS;
 130
 131       if (!src)
 132         {
 133           ip_prefix_t sp;
 134           memset (&sp, 0, sizeof (sp));
 135           return ip4_lookup (sfib4, 0, &sp);
 136         }
 137       else
 138         return ip4_lookup (sfib4, 0, src);
 139
 140       break;
 141     case IP6:
 142       sfi = ip6_lookup (&db->dst_ip6_table, vni, dst);
 143       if (GID_LOOKUP_MISS != sfi)
 144         sfib6 = pool_elt_at_index (db->src_ip6_table_pool, sfi);
 145       else
 146         return GID_LOOKUP_MISS;
 147
 148       if (!src)
 149         {
 150           ip_prefix_t sp;
 151           memset (&sp, 0, sizeof (sp));
 152           ip_prefix_version (&sp) = IP6;
 153           return ip6_lookup (sfib6, 0, &sp);
 154         }
 155       else
 156         return ip6_lookup (sfib6, 0, src);
 157
 158       break;
 159     default:
 160       clib_warning ("address type %d not supported!",
 161                     ip_prefix_version (dst));
 162       break;
 163     }
 164   return GID_LOOKUP_MISS;
 165 }
 166
 167 u32
 168 gid_dictionary_lookup (gid_dictionary_t * db, gid_address_t * key)
 169 {
 170   switch (gid_address_type (key))
 171     {
 172     case GID_ADDR_IP_PREFIX:
 173       return ip_sd_lookup (db, gid_address_vni (key),
 174                            &gid_address_ippref (key), 0);
 175     case GID_ADDR_MAC:
 176       return mac_sd_lookup (&db->sd_mac_table, gid_address_vni (key),
 177                             gid_address_mac (key), 0);
 178     case GID_ADDR_SRC_DST:
 179       switch (gid_address_sd_dst_type (key))
 180         {
 181         case FID_ADDR_IP_PREF:
 182           return ip_sd_lookup (db, gid_address_vni (key),
 183                                &gid_address_sd_dst_ippref (key),
 184                                &gid_address_sd_src_ippref (key));
 185           break;
 186         case FID_ADDR_MAC:
 187           return mac_sd_lookup (&db->sd_mac_table, gid_address_vni (key),
 188                                 gid_address_sd_dst_mac (key),
 189                                 gid_address_sd_src_mac (key));
 190           break;
 191         default:
 192           clib_warning ("Source/Dest address type %d not supported!",
 193                         gid_address_sd_dst_type (key));
 194           break;
 195         }
 196       break;
 197     default:
 198       clib_warning ("address type %d not supported!", gid_address_type (key));
 199       break;
 200     }
 201   return GID_LOOKUP_MISS;
 202 }
 203
 204 u32
 205 gid_dictionary_sd_lookup (gid_dictionary_t * db, gid_address_t * dst,
 206                           gid_address_t * src)
 207 {
 208   switch (gid_address_type (dst))
 209     {
 210     case GID_ADDR_IP_PREFIX:
 211       return ip_sd_lookup (db, gid_address_vni (dst),
 212                            &gid_address_ippref (dst),
 213                            &gid_address_ippref (src));
 214     case GID_ADDR_MAC:
 215       return mac_sd_lookup (&db->sd_mac_table, gid_address_vni (dst),
 216                             gid_address_mac (dst), gid_address_mac (src));
 217     default:
 218       clib_warning ("address type %d not supported!", gid_address_type (dst));
 219       break;
 220     }
 221   return GID_LOOKUP_MISS;
 222 }
 223
 224 static void
 225 ip4_compute_prefix_lengths_in_search_order (gid_ip4_table_t * db)
 226 {
 227   int i;
 228   vec_reset_length (db->ip4_prefix_lengths_in_search_order);
 229   /* Note: bitmap reversed so this is in fact a longest prefix match */
 230
 231   /* *INDENT-OFF* */
 232   clib_bitmap_foreach (i, db->ip4_non_empty_dst_address_length_bitmap,
 233   ({
 234     int dst_address_length = 32 - i;
 235     vec_add1 (db->ip4_prefix_lengths_in_search_order, dst_address_length);
 236   }));
 237   /* *INDENT-ON* */
 238
 239 }
 240
 241 static u32
 242 add_del_ip4_key (gid_ip4_table_t * db, u32 vni, ip_prefix_t * pref, u32 val,
 243                  u8 is_add)
 244 {
 245   BVT (clib_bihash_kv) kv, value;
 246   u32 old_val = ~0;
 247   ip4_address_t key;
 248   u8 plen = ip_prefix_len (pref);
 249
 250   clib_memcpy (&key, &ip_prefix_v4 (pref), sizeof (key));
 251   key.as_u32 &= db->ip4_fib_masks[plen].as_u32;
 252   if (is_add)
 253     {
 254       db->ip4_non_empty_dst_address_length_bitmap =
 255         clib_bitmap_set (db->ip4_non_empty_dst_address_length_bitmap,
 256                          32 - plen, 1);
 257       ip4_compute_prefix_lengths_in_search_order (db);
 258
 259       db->ip4_prefix_len_refcount[plen]++;
 260     }
 261   else
 262     {
 263       ASSERT (db->ip4_prefix_len_refcount[plen] != 0);
 264
 265       db->ip4_prefix_len_refcount[plen]--;
 266
 267       if (db->ip4_prefix_len_refcount[plen] == 0)
 268         {
 269           db->ip4_non_empty_dst_address_length_bitmap =
 270             clib_bitmap_set (db->ip4_non_empty_dst_address_length_bitmap,
 271                              32 - plen, 0);
 272           ip4_compute_prefix_lengths_in_search_order (db);
 273         }
 274     }
 275
 276   kv.key[0] = ((u64) vni << 32) | key.as_u32;
 277   kv.key[1] = 0;
 278   kv.key[2] = 0;
 279
 280   if (BV (clib_bihash_search) (&db->ip4_lookup_table, &kv, &value) == 0)
 281     old_val = value.value;
 282
 283   if (!is_add)
 284     BV (clib_bihash_add_del) (&db->ip4_lookup_table, &kv, 0 /* is_add */ );
 285   else
 286     {
 287       kv.value = val;
 288       BV (clib_bihash_add_del) (&db->ip4_lookup_table, &kv, 1 /* is_add */ );
 289     }
 290   return old_val;
 291 }
 292
 293 static void
 294 ip4_lookup_init (gid_ip4_table_t * db)
 295 {
 296   uword i;
 297
 298   memset (db->ip4_prefix_len_refcount, 0,
 299           sizeof (db->ip4_prefix_len_refcount));
 300
 301   for (i = 0; i < ARRAY_LEN (db->ip4_fib_masks); i++)
 302     {
 303       u32 m;
 304
 305       if (i < 32)
 306         m = pow2_mask (i) << (32 - i);
 307       else
 308         m = ~0;
 309       db->ip4_fib_masks[i].as_u32 = clib_host_to_net_u32 (m);
 310     }
 311   if (db->ip4_lookup_table_nbuckets == 0)
 312     db->ip4_lookup_table_nbuckets = IP4_LOOKUP_DEFAULT_HASH_NUM_BUCKETS;
 313
 314   db->ip4_lookup_table_nbuckets =
 315     1 << max_log2 (db->ip4_lookup_table_nbuckets);
 316
 317   if (db->ip4_lookup_table_size == 0)
 318     db->ip4_lookup_table_size = IP4_LOOKUP_DEFAULT_HASH_MEMORY_SIZE;
 319
 320   BV (clib_bihash_init) (&db->ip4_lookup_table, "ip4 lookup table",
 321                          db->ip4_lookup_table_nbuckets,
 322                          db->ip4_lookup_table_size);
 323 }
 324
 325 static u32
 326 add_del_sd_ip4_key (gid_dictionary_t * db, u32 vni, ip_prefix_t * dst_pref,
 327                     ip_prefix_t * src_pref, u32 val, u8 is_add)
 328 {
 329   u32 sfi, old_val = ~0;
 330   gid_ip4_table_t *sfib;
 331
 332   sfi = ip4_lookup (&db->dst_ip4_table, vni, dst_pref);
 333
 334   if (is_add)
 335     {
 336       if (GID_LOOKUP_MISS == sfi)
 337         {
 338           pool_get (db->src_ip4_table_pool, sfib);
 339           ip4_lookup_init (sfib);
 340           add_del_ip4_key (&db->dst_ip4_table, vni, dst_pref,
 341                            sfib - db->src_ip4_table_pool, is_add);
 342           if (src_pref)
 343             add_del_ip4_key (sfib, 0 /* vni */ , src_pref, val, is_add);
 344           else
 345             {
 346               ip_prefix_t sp;
 347               memset (&sp, 0, sizeof (sp));
 348               add_del_ip4_key (sfib, 0 /* vni */ , &sp, val, is_add);
 349             }
 350         }
 351       else
 352         {
 353           ASSERT (!pool_is_free_index (db->src_ip4_table_pool, sfi));
 354           sfib = pool_elt_at_index (db->src_ip4_table_pool, sfi);
 355           if (src_pref)
 356             {
 357               old_val = ip4_lookup (sfib, 0, src_pref);
 358               add_del_ip4_key (sfib, 0 /* vni */ , src_pref, val, is_add);
 359             }
 360           else
 361             {
 362               ip_prefix_t sp;
 363               memset (&sp, 0, sizeof (sp));
 364               old_val =
 365                 add_del_ip4_key (sfib, 0 /* vni */ , &sp, val, is_add);
 366             }
 367         }
 368     }
 369   else
 370     {
 371       if (GID_LOOKUP_MISS != sfi)
 372         {
 373           add_del_ip4_key (&db->dst_ip4_table, vni, dst_pref, 0, is_add);
 374           sfib = pool_elt_at_index (db->src_ip4_table_pool, sfi);
 375           if (src_pref)
 376             old_val = add_del_ip4_key (sfib, 0, src_pref, 0, is_add);
 377           else
 378             {
 379               ip_prefix_t sp;
 380               memset (&sp, 0, sizeof (sp));
 381               old_val = add_del_ip4_key (sfib, 0, &sp, 0, is_add);
 382             }
 383         }
 384       else
 385         clib_warning ("cannot delete dst mapping %U!", format_ip_prefix,
 386                       dst_pref);
 387     }
 388   return old_val;
 389 }
 390
 391 static void
 392 ip6_compute_prefix_lengths_in_search_order (gid_ip6_table_t * db)
 393 {
 394   int i;
 395   vec_reset_length (db->ip6_prefix_lengths_in_search_order);
 396   /* Note: bitmap reversed so this is in fact a longest prefix match */
 397
 398   /* *INDENT-OFF* */
 399   clib_bitmap_foreach (i, db->ip6_non_empty_dst_address_length_bitmap,
 400   ({
 401     int dst_address_length = 128 - i;
 402     vec_add1 (db->ip6_prefix_lengths_in_search_order, dst_address_length);
 403   }));
 404   /* *INDENT-ON* */
 405 }
 406
 407 static u32
 408 add_del_ip6_key (gid_ip6_table_t * db, u32 vni, ip_prefix_t * pref, u32 val,
 409                  u8 is_add)
 410 {
 411   BVT (clib_bihash_kv) kv, value;
 412   u32 old_val = ~0;
 413   ip6_address_t key;
 414   u8 plen = ip_prefix_len (pref);
 415
 416   clib_memcpy (&key, &ip_prefix_v6 (pref), sizeof (key));
 417   ip6_address_mask (&key, &db->ip6_fib_masks[plen]);
 418   if (is_add)
 419     {
 420       db->ip6_non_empty_dst_address_length_bitmap =
 421         clib_bitmap_set (db->ip6_non_empty_dst_address_length_bitmap,
 422                          128 - plen, 1);
 423       ip6_compute_prefix_lengths_in_search_order (db);
 424       db->ip6_prefix_len_refcount[plen]++;
 425     }
 426   else
 427     {
 428       ASSERT (db->ip6_prefix_len_refcount[plen] != 0);
 429
 430       db->ip6_prefix_len_refcount[plen]--;
 431
 432       if (db->ip6_prefix_len_refcount[plen] == 0)
 433         {
 434           db->ip6_non_empty_dst_address_length_bitmap =
 435             clib_bitmap_set (db->ip6_non_empty_dst_address_length_bitmap,
 436                              128 - plen, 0);
 437           ip6_compute_prefix_lengths_in_search_order (db);
 438         }
 439     }
 440
 441   kv.key[0] = key.as_u64[0];
 442   kv.key[1] = key.as_u64[1];
 443   kv.key[2] = (u64) vni;
 444 //  kv.key[2] = ((u64)((fib - im->fibs))<<32) | ip_prefix_len(key);
 445
 446   if (BV (clib_bihash_search) (&db->ip6_lookup_table, &kv, &value) == 0)
 447     old_val = value.value;
 448
 449   if (!is_add)
 450     BV (clib_bihash_add_del) (&db->ip6_lookup_table, &kv, 0 /* is_add */ );
 451   else
 452     {
 453       kv.value = val;
 454       BV (clib_bihash_add_del) (&db->ip6_lookup_table, &kv, 1 /* is_add */ );
 455     }
 456   return old_val;
 457 }
 458
 459 static u32
 460 add_del_mac (gid_mac_table_t * db, u32 vni, u8 * dst_mac, u8 * src_mac,
 461              u32 val, u8 is_add)
 462 {
 463   BVT (clib_bihash_kv) kv, value;
 464   u32 old_val = ~0;
 465
 466   make_mac_sd_key (&kv, vni, src_mac, dst_mac);
 467
 468   if (BV (clib_bihash_search) (&db->mac_lookup_table, &kv, &value) == 0)
 469     old_val = value.value;
 470
 471   if (!is_add)
 472     BV (clib_bihash_add_del) (&db->mac_lookup_table, &kv, 0 /* is_add */ );
 473   else
 474     {
 475       kv.value = val;
 476       BV (clib_bihash_add_del) (&db->mac_lookup_table, &kv, 1 /* is_add */ );
 477     }
 478   return old_val;
 479 }
 480
 481 static void
 482 ip6_lookup_init (gid_ip6_table_t * db)
 483 {
 484   uword i;
 485
 486   memset (db->ip6_prefix_len_refcount, 0,
 487           sizeof (db->ip6_prefix_len_refcount));
 488
 489   for (i = 0; i < ARRAY_LEN (db->ip6_fib_masks); i++)
 490     {
 491       u32 j, i0, i1;
 492
 493       i0 = i / 32;
 494       i1 = i % 32;
 495
 496       for (j = 0; j < i0; j++)
 497         db->ip6_fib_masks[i].as_u32[j] = ~0;
 498
 499       if (i1)
 500         db->ip6_fib_masks[i].as_u32[i0] =
 501           clib_host_to_net_u32 (pow2_mask (i1) << (32 - i1));
 502     }
 503
 504   if (db->ip6_lookup_table_nbuckets == 0)
 505     db->ip6_lookup_table_nbuckets = IP6_LOOKUP_DEFAULT_HASH_NUM_BUCKETS;
 506
 507   db->ip6_lookup_table_nbuckets =
 508     1 << max_log2 (db->ip6_lookup_table_nbuckets);
 509
 510   if (db->ip6_lookup_table_size == 0)
 511     db->ip6_lookup_table_size = IP6_LOOKUP_DEFAULT_HASH_MEMORY_SIZE;
 512
 513   BV (clib_bihash_init) (&db->ip6_lookup_table, "ip6 lookup table",
 514                          db->ip6_lookup_table_nbuckets,
 515                          db->ip6_lookup_table_size);
 516 }
 517
 518 static u32
 519 add_del_sd_ip6_key (gid_dictionary_t * db, u32 vni, ip_prefix_t * dst_pref,
 520                     ip_prefix_t * src_pref, u32 val, u8 is_add)
 521 {
 522   u32 sfi, old_val = ~0;
 523   gid_ip6_table_t *sfib;
 524
 525   sfi = ip6_lookup (&db->dst_ip6_table, vni, dst_pref);
 526
 527   if (is_add)
 528     {
 529       if (GID_LOOKUP_MISS == sfi)
 530         {
 531           pool_get (db->src_ip6_table_pool, sfib);
 532           ip6_lookup_init (sfib);
 533           add_del_ip6_key (&db->dst_ip6_table, vni, dst_pref,
 534                            sfib - db->src_ip6_table_pool, is_add);
 535           if (src_pref)
 536             add_del_ip6_key (sfib, 0 /* vni */ , src_pref, val, is_add);
 537           else
 538             {
 539               ip_prefix_t sp;
 540               memset (&sp, 0, sizeof (sp));
 541               add_del_ip6_key (sfib, 0 /* vni */ , &sp, val, is_add);
 542             }
 543         }
 544       else
 545         {
 546           ASSERT (!pool_is_free_index (db->src_ip6_table_pool, sfi));
 547           sfib = pool_elt_at_index (db->src_ip6_table_pool, sfi);
 548           if (src_pref)
 549             {
 550               old_val = ip6_lookup (sfib, 0, src_pref);
 551               add_del_ip6_key (sfib, 0 /* vni */ , src_pref, val, is_add);
 552             }
 553           else
 554             {
 555               ip_prefix_t sp;
 556               memset (&sp, 0, sizeof (sp));
 557               old_val =
 558                 add_del_ip6_key (sfib, 0 /* vni */ , &sp, val, is_add);
 559             }
 560         }
 561     }
 562   else
 563     {
 564       if (GID_LOOKUP_MISS != sfi)
 565         {
 566           add_del_ip6_key (&db->dst_ip6_table, vni, dst_pref, 0, is_add);
 567           sfib = pool_elt_at_index (db->src_ip6_table_pool, sfi);
 568           if (src_pref)
 569             old_val = add_del_ip6_key (sfib, 0, src_pref, 0, is_add);
 570           else
 571             {
 572               ip_prefix_t sp;
 573               memset (&sp, 0, sizeof (sp));
 574               old_val = add_del_ip6_key (sfib, 0, &sp, 0, is_add);
 575             }
 576         }
 577       else
 578         clib_warning ("cannot delete dst mapping %U!", format_ip_prefix,
 579                       dst_pref);
 580     }
 581   return old_val;
 582 }
 583
 584 static u32
 585 add_del_ip (gid_dictionary_t * db, u32 vni, ip_prefix_t * dst_key,
 586             ip_prefix_t * src_key, u32 value, u8 is_add)
 587 {
 588   switch (ip_prefix_version (dst_key))
 589     {
 590     case IP4:
 591       return add_del_sd_ip4_key (db, vni, dst_key, src_key, value, is_add);
 592       break;
 593     case IP6:
 594       return add_del_sd_ip6_key (db, vni, dst_key, src_key, value, is_add);
 595       break;
 596     default:
 597       clib_warning ("address type %d not supported!",
 598                     ip_prefix_version (dst_key));
 599       break;
 600     }
 601   return ~0;
 602 }
 603
 604 static u32
 605 add_del_sd (gid_dictionary_t * db, u32 vni, source_dest_t * key, u32 value,
 606             u8 is_add)
 607 {
 608   switch (sd_dst_type (key))
 609     {
 610     case FID_ADDR_IP_PREF:
 611       add_del_ip (db, vni, &sd_dst_ippref (key), &sd_src_ippref (key),
 612                   value, is_add);
 613
 614     case FID_ADDR_MAC:
 615       return add_del_mac (&db->sd_mac_table, vni, sd_dst_mac (key),
 616                           sd_src_mac (key), value, is_add);
 617
 618     default:
 619       clib_warning ("SD address type %d not supprted!", sd_dst_type (key));
 620       break;
 621     }
 622
 623   return ~0;
 624 }
 625
 626 u32
 627 gid_dictionary_add_del (gid_dictionary_t * db, gid_address_t * key, u32 value,
 628                         u8 is_add)
 629 {
 630   switch (gid_address_type (key))
 631     {
 632     case GID_ADDR_IP_PREFIX:
 633       return add_del_ip (db, gid_address_vni (key), &gid_address_ippref (key),
 634                          0, value, is_add);
 635     case GID_ADDR_MAC:
 636       return add_del_mac (&db->sd_mac_table, gid_address_vni (key),
 637                           gid_address_mac (key), 0, value, is_add);
 638     case GID_ADDR_SRC_DST:
 639       return add_del_sd (db, gid_address_vni (key), &gid_address_sd (key),
 640                          value, is_add);
 641     default:
 642       clib_warning ("address type %d not supported!", gid_address_type (key));
 643       break;
 644     }
 645   return ~0;
 646 }
 647
 648 static void
 649 mac_lookup_init (gid_mac_table_t * db)
 650 {
 651   if (db->mac_lookup_table_nbuckets == 0)
 652     db->mac_lookup_table_nbuckets = MAC_LOOKUP_DEFAULT_HASH_NUM_BUCKETS;
 653
 654   db->mac_lookup_table_nbuckets =
 655     1 << max_log2 (db->mac_lookup_table_nbuckets);
 656
 657   if (db->mac_lookup_table_size == 0)
 658     db->mac_lookup_table_size = MAC_LOOKUP_DEFAULT_HASH_MEMORY_SIZE;
 659
 660   BV (clib_bihash_init) (&db->mac_lookup_table, "mac lookup table",
 661                          db->mac_lookup_table_nbuckets,
 662                          db->mac_lookup_table_size);
 663 }
 664
 665 void
 666 gid_dictionary_init (gid_dictionary_t * db)
 667 {
 668   ip4_lookup_init (&db->dst_ip4_table);
 669   ip6_lookup_init (&db->dst_ip6_table);
 670   mac_lookup_init (&db->sd_mac_table);
 671 }
 672
 673 /*
 674  * fd.io coding-style-patch-verification: ON
 675  *
 676  * Local Variables:
 677  * eval: (c-set-style "gnu")
 678  * End:
 679  */